DLL Standard 32 bits installée dans \Windows\System32 inaccessible

**Godzestla** · 11/12/2012, 11h14

Bonjour,

j'ai un code VBA qui fonctionne de longue date sur tout un tas de machines tournant sous XP et Vista, sans problème.

Ce code accède à une DLL standard, gsdll32.dll, installé avec le setup du logiciel GHOSTSCRIPT, dernière version en ligne (Ghostscript 9.06).

Ce code ne fonctionne plus sous Windows 8 (NB : je découvre Windows 8, donc ça ne m'aide pas).

J'ai plusieurs problèmes, liés je pense à la sécurité de WINDOWS 8, qui ressemble de près à celle d'Active Directory.
Pour info, le pc concerné travaille hors réseau et ne nécessite nullement une sécurité particulière.

Problème 1
Lors du setup Mon code copie la DLL sous C:\Windows\System32;
Je reçois un message qui me dit que je n'ai pas les droit nécessaires pour ce copy.

Lorsque je regarde les droit de l'utilisateur, il semble disposer des droits d'administrateur.
Lorsque je regarde sous c:\Windows\System32 je trouve bien ma DLL gsdl32.DLL

Problème 2
Lorsque mon code vérifie l'existence de cette DLL sous C:\WINDOWS\System32 il ne le voit pas alors qu'elle est là!!!

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
Function Check_Ghostscript_dll() As Boolean
Dim system32path As String
Dim Gs_fullname As String
Dim res As Variant
Gs_fullname = Environ$("systemroot") & "\System32\" & "gsdll32.dll"
res = Dir(Gs_fullname, vbSystem)
If res = "" Then
   Check_Ghostscript_dll = False
  Else
   Check_Ghostscript_dll = True
End If

End Function

Problème 3
Lorsque mon code tente d'utiliser cette DLL, il se plante magistralement sans aucune message (sur la ligne en gras.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
rivate Declare Function gsapi_revision Lib "gsdll32.dll" (ByVal pGSRevisionInfo As Long, ByVal intLen As Long) As Long
Private Declare Function gsapi_new_instance Lib "gsdll32.dll" (ByRef lngGSInstance As Long, ByVal lngCallerHandle As Long) As Long
Private Declare Function gsapi_set_stdio Lib "gsdll32.dll" (ByVal lngGSInstance As Long, ByVal gsdll_stdin As Long, ByVal gsdll_stdout As Long, ByVal gsdll_stderr As Long) As Long
Private Declare Sub gsapi_delete_instance Lib "gsdll32.dll" (ByVal lngGSInstance As Long)
Private Declare Function gsapi_init_with_args Lib "gsdll32.dll" (ByVal lngGSInstance As Long, ByVal lngArgumentCount As Long, ByVal lngArguments As Long) As Long
Private Declare Function gsapi_run_file Lib "gsdll32.dll" (ByVal lngGSInstance As Long, ByVal strFileName As String, ByVal intErrors As Long, ByVal intExitCode As Long) As Long
Private Declare Function gsapi_exit Lib "gsdll32.dll" (ByVal lngGSInstance As Long) As Long


'.....


Public Function CallGS(ByRef astrGSArgs() As String) As Boolean
    Dim intReturn As Long
    Dim intGSInstanceHandle As Long
    Dim aAnsiArgs() As String
    Dim aPtrArgs() As Long
    Dim intCounter As Long
    Dim intElementCount As Long
    Dim iTemp As Long
    Dim callerHandle As Long
    Dim ptrArgs As Long



    ' Load Ghostscript and get the instance handle
    intReturn = gsapi_new_instance(intGSInstanceHandle, callerHandle)
    If (intReturn < 0) Then
        CallGS = False
        Return
    End If

    ' Capture stdio
    intReturn = gsapi_set_stdio(intGSInstanceHandle, AddressOf gsdll_stdin, AddressOf gsdll_stdout, AddressOf gsdll_stderr)

    If (intReturn >= 0) Then
        ' Convert the Unicode strings to null terminated ANSI byte arrays
        ' then get pointers to the byte arrays.
        intElementCount = UBound(astrGSArgs)
        ReDim aAnsiArgs(intElementCount)
        ReDim aPtrArgs(intElementCount)
       
        For intCounter = 0 To intElementCount
            aAnsiArgs(intCounter) = StrConv(astrGSArgs(intCounter), vbFromUnicode)
            aPtrArgs(intCounter) = StrPtr(aAnsiArgs(intCounter))
        Next
        ptrArgs = VarPtr(aPtrArgs(0))
      
        intReturn = gsapi_init_with_args(intGSInstanceHandle, intElementCount + 1, ptrArgs)

        ' Stop the Ghostscript interpreter
        gsapi_exit (intGSInstanceHandle)
    End If

    ' release the Ghostscript instance handle
    gsapi_delete_instance (intGSInstanceHandle)

    If (intReturn >= 0) Then
        CallGS = True
    Else
        CallGS = False
    End If

End Function

Si quelqu'un à une idée ? (Installer le software en version 64 Bits, Supprimer la sécurité, ...) car je ne trouve pas de solution actuellement.

Merci d'avance.

**sevyc64** · 11/12/2012, 12h04

Première précision : Depuis Vista, et surtout W7 (et W8 ne doit pas différé je pense) un utilisateur de type Administrateur n'a pas plus de droit, en temps normal qu'un simple utilisateur, il a juste la possibilité d'obtenir ces droits là, ponctuellement, à la demande.

Pour ce qui est de l'installation, sur un système 32 bits, il n'y a pas de particularité. Sur un systeme 64 bits, par contre, il y a 2 dossiers "System32". Il y a le classique system32 qui est le dossier version 64bits, et le dossier sysWOW64, qui est la version 32 bits de system32.

Si ton logiciel est en 32 bits, il est probable que ta dll soit recherchée dans syswow64 (modifié automatiquement par l'os).
Ceci dit, il me semble que ta dll dans system32 devrait être vu quand même, mais j'ai un doute sur ce point.

**Godzestla** · 11/12/2012, 12h39

Bonjour,

merci pour ta réponse rapide.

Pour ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Ceci dit, il me semble que ta dll dans system32 devrait être vu quand même, mais j'ai un doute sur ce point.

j'ai aussi un doute, car l'explorer la voit.... mais par le DIR sous VBA !!

Mais soit. je vais regarder avec sysWOW64, sinon je vais tenter la version 64 bits.

Il faut juste que j'adapte mon code pour qu'il travaille en fonction de l'OS.

Je regarde.

**Godzestla** · 11/12/2012, 16h07

Pour info,
dans le but d'adapter mon code je me suis déjà aidé de cette contribution

**Godzestla** · 12/12/2012, 09h05

Bonjour,

j'ai pas mal progressé sur ce problème.

Voici, à ce stade, les différences que j'ai du apporter à mon code, dans la mesure ou cela pourrait aider quelqu'un d'autre.

Le code présenté est du VBA.
1) Comment détecter le type d'OS (Version, Nombre de Bits)

La fonction RetrieveWindows(Os_name As String, Os_bit As String) As String retourne le nom complet de l'OS , mais positionne également 2 variables publiques : OS_Name : Nom de la version, OS_bit : 32 ou 64 (selon la version)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
Option Explicit
'Public Declaration for OS Fullname, Release and Bit
Public Os_name As String
Public Os_bit As String
Public Os_fullname As String


 'API Windows pour version de Windows
Private Declare Function GetVersionExA Lib "kernel32" (lpVersionInformation As OSVERSIONINFOEX) As Integer
 
 'API Windows pour chercher si le système est en 64 bytes
Private Declare Function GetProcAddress Lib "kernel32" (ByVal hModule As Long, ByVal lpProcName As String) As Long
Private Declare Function GetModuleHandle Lib "kernel32" Alias "GetModuleHandleA" (ByVal lpModuleName As String) As Long
Private Declare Function GetCurrentProcess Lib "kernel32" () As Long
Private Declare Function IsWow64Process Lib "kernel32" (ByVal hProc As Long, bWow64Process As Boolean) As Long
 
Private Const VER_NT_WORKSTATION = 1 ' Le système d'exploitation est Windows 7, Windows Vista, Windows XP Professional, Windows XP Home Edition, or Windows 2000 Professional.
 
Private Type OSVERSIONINFOEX
    dwOSVersionInfoSize As Long ' La taille de cette structure de données, en octets
    dwMajorVersion As Long ' Le nombre de la version majeure du système d'exploitation
    dwMinorVersion As Long ' Le nombre de la version mineure du système d'exploitation
    dwBuildNumber As Long
    dwPlatformId As Long
    szCSDVersion As String * 128
    wServicePackMajor As Integer
    wServicePackMinor As Integer
    wSuiteMask As Integer
    wProductType As Byte ' Autre information supplémentaires sur le système et notamment  pour VER_NT_WORKSTATION, wProductType = 1
    wReserved As Byte
End Type


Public Function RetrieveWindows(Os_name As String, Os_bit As String) As String
' Fonction pour identifier les versions de Windows [32 et 64 bytes]
                                Dim Os                      As OSVERSIONINFOEX
 
                                Dim Handle                  As Long
                                Dim Est64bit                As Boolean
                                Dim Bytes                   As String
 
    'Initialise la valeur à false : il n'y a pas  Wow64 process
    Est64bit = False

 
    'On vérifie que la dll kernel32.dll contient bien une méthode IsWow64Process
    Handle = GetProcAddress(GetModuleHandle("kernel32"), "IsWow64Process")
 
    'Si la fonction IsWow64Process existe on l'utise pour déterminer si on est en 64 bytes
    If Handle > 0 Then IsWow64Process GetCurrentProcess(), Est64bit
 
    If Est64bit = False Then
        Bytes = "32"
    Else
        Bytes = "64"
    End If
 
    Os.dwOSVersionInfoSize = Len(Os)
    GetVersionExA Os
 
    'On teste sur les versions de Windows
    Select Case CStr(Os.dwMajorVersion & "." & Os.dwMinorVersion)
        Case "5.1"
            Os_name = "XP"
        Case "6.0"
            Os_name = "Vista"
        Case "6.1"
            If Os.wProductType = VER_NT_WORKSTATION Then Os_name = "7"
        Case "6.2"
            If Os.wProductType = VER_NT_WORKSTATION Then Os_name = "8"
        Case Else
            Os_name = "Version non reconnue(" & CStr(Os.dwMajorVersion & "." & Os.dwMinorVersion) & ")"

    End Select
    Os_bit = Bytes
    RetrieveWindows = "Windows " & Os_name & "-" & Bytes
End Function

2) Comment lancer un exécutable Via ShellExecuteEx sous OS 32 Bit et Sous OS 64 Bits.

Sous un OS 32 bits, on utilise "Open" de ShellexecuteEx pour ouvrir un document via le programme associé ET AUSSI LANCER UN EXECUTABLE.

Sous un OS 64 bits, on doit utiliser "RunAs" en lieu et place de "Open" pour lancer un exécutable (32 ou 64 bits).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
'------------------------------------------------
'API Calls Start
'------------------------------------------------
'Win32 API
'GhostScript API
Public Declare Sub CopyMemory Lib "kernel32" Alias "RtlMoveMemory" (ByVal dest As Long, ByVal source As Long, ByVal Bytes As Long)

Private Declare Function gsapi_revision Lib "gsdll32.dll" (ByVal pGSRevisionInfo As Long, ByVal intLen As Long) As Long
Private Declare Function gsapi_new_instance Lib "gsdll32.dll" (ByRef lngGSInstance As Long, ByVal lngCallerHandle As Long) As Long
Private Declare Function gsapi_set_stdio Lib "gsdll32.dll" (ByVal lngGSInstance As Long, ByVal gsdll_stdin As Long, ByVal gsdll_stdout As Long, ByVal gsdll_stderr As Long) As Long
Private Declare Sub gsapi_delete_instance Lib "gsdll32.dll" (ByVal lngGSInstance As Long)
Private Declare Function gsapi_init_with_args Lib "gsdll32.dll" (ByVal lngGSInstance As Long, ByVal lngArgumentCount As Long, ByVal lngArguments As Long) As Long
Private Declare Function gsapi_run_file Lib "gsdll32.dll" (ByVal lngGSInstance As Long, ByVal strFileName As String, ByVal intErrors As Long, ByVal intExitCode As Long) As Long
Private Declare Function gsapi_exit Lib "gsdll32.dll" (ByVal lngGSInstance As Long) As Long

'------------------------------------------------
' >>>> Godz Add
'------------------------------------------------
Private Declare Function SHCreateDirectoryEx Lib "shell32.dll" Alias "SHCreateDirectoryExA" _
 (ByVal hWnd As Long, ByVal pszPath As String, ByVal lngsec As Long) As Long
Private Declare Function RegCloseKey Lib "advapi32.dll" (ByVal hKey As Long) As Long
Private Declare Function RegOpenKey Lib "advapi32.dll" Alias "RegOpenKeyA" (ByVal hKey As Long, ByVal lpSubKey As String, phkResult As Long) As Long
Private Declare Function RegEnumKeyEx Lib "advapi32.dll" Alias "RegEnumKeyExA" (ByVal hKey As Long, ByVal dwIndex As Long, ByVal lpName As String, lpcbName As Long, ByVal lpReserved As Long, ByVal lpClass As String, lpcbClass As Long, lpftLastWriteTime As Any) As Long
Private Declare Function RegEnumValue Lib "advapi32.dll" Alias "RegEnumValueA" (ByVal hKey As Long, ByVal dwIndex As Long, ByVal lpValueName As String, lpcbValueName As Long, ByVal lpReserved As Long, lpType As Long, lpData As Any, lpcbData As Long) As Long
'------------------------------------------------
' <<<< Godz Add
'------------------------------------------------
'------------------------------------------------
'>>>>> Godz New 11/12/2012 : Windows 8 Compliance
'------------------------------------------------
'Flags ShellExecuteEx
Private Const SEE_MASK_NOCLOSEPROCESS = &H40
Private Const SEE_MASK_FLAG_NO_UI = &H400

'Constantes ERREUR ShellExecuteEx
Private Const SE_ERR_FNF As Byte = 2
Private Const SE_ERR_PNF As Byte = 3
Private Const SE_ERR_ACCESSDENIED As Byte = 5
Private Const SE_ERR_OOM As Byte = 8
Private Const SE_ERR_SHARE As Byte = 26
Private Const SE_ERR_ASSOCINCOMPLETE As Byte = 27
Private Const SE_ERR_DDETIMEOUT As Byte = 28
Private Const SE_ERR_DDEFAIL As Byte = 29
Private Const SE_ERR_DDEBUSY As Byte = 30
Private Const SE_ERR_NOASSOC As Byte = 31
Private Const SE_ERR_DLLNOTFOUND As Byte = 32

'Constantes AFFICHAGE ShellExecuteEx
Private Const SW_SHOWNORMAL = 1
Private Const SW_SHOW = 5
Private Const SW_SHOWDEFAULT = 10

Private Type SHELLEXECUTEINFO
    cbSize As Long
    fMask As Long
    hWnd As Long
    lpVerb As String
    lpFile As String
    lpParameters As String
    lpDirectory As String
    nShow As Long
    hInstApp As Long
    lpIDList As Long
    lpClass As String
    hkeyClass As Long
    dwHotKey As Long
    hIcon As Long
    hProcess As Long
End Type

'OpenProgram
Private Declare Function ShellExecuteEx Lib "shell32.dll" _
(SEI As SHELLEXECUTEINFO) As Long
'------------------------------------------------
'<<<<<Godz New 11/12/2012 : Windows 8 Compliance
'------------------------------------------------
'------------------------------------------------
'API Calls End
'------------------------------------------------
Public Function OpenProgram(ByRef Filename As String, ByRef OwnerhWnd As Long) As Long
    Dim SEI As SHELLEXECUTEINFO
    Dim File_Extension As String
    Dim SEx64          As Boolean
    
    
    On Error GoTo ErrorHandler
    
    'Vérifie si le fichier à lancer est un exécutable (.exe)
   
    SEx64 = False
    File_Extension = GetExtension(Filename)
    
    Select Case File_Extension
           Case "exe", "com", "msi"
            If Os_bit = "64" Then
                SEx64 = True
            End If
    End Select
    
    
    'Execute a program with 64 Bit O.S
    If SEx64 Then
        With SEI
            .cbSize = Len(SEI)
            .fMask = SEE_MASK_NOCLOSEPROCESS Or SEE_MASK_FLAG_NO_UI
            .hWnd = OwnerhWnd
            .lpVerb = "runas"
            .lpFile = Filename
            .lpParameters = vbNullChar
            .lpDirectory = vbNullChar
            .nShow = SW_SHOW
            .hInstApp = OwnerhWnd
        End With
     Else
        With SEI
            .cbSize = Len(SEI)
            .fMask = SEE_MASK_NOCLOSEPROCESS Or SEE_MASK_FLAG_NO_UI
            .hWnd = OwnerhWnd
            .lpVerb = "open"
            .lpFile = Filename
            .lpParameters = vbNullChar
            .lpDirectory = vbNullChar
            .nShow = SW_SHOW
            .hInstApp = OwnerhWnd
        End With
    End If
    
    OpenProgram = ShellExecuteEx(SEI)
    
    If SEI.hInstApp <= 32 Then
    'Erreurs
        OpenProgram = 0
        
        Select Case SEI.hInstApp
            Case SE_ERR_FNF
                OpenProgram = SEI.hProcess
            Case SE_ERR_PNF
                MsgBox "Le chemin du fichier à ouvrir est incorrect.", vbExclamation
            Case SE_ERR_ACCESSDENIED
                MsgBox "Accès au fichier refusé.", vbExclamation
            Case SE_ERR_OOM
                MsgBox "Mémoire insuffisante.", vbExclamation
            Case SE_ERR_DLLNOTFOUND
                MsgBox "Dynamic-link library non trouvé.", vbExclamation
            Case SE_ERR_SHARE
                MsgBox "Le fichier est déjà ouvert.", vbExclamation
            Case SE_ERR_ASSOCINCOMPLETE
                MsgBox "Information d'association du fichier incomplète.", vbExclamation
            Case SE_ERR_DDETIMEOUT
                MsgBox "Opération DDE dépassée.", vbExclamation
            Case SE_ERR_DDEFAIL
                MsgBox "Opération DDE echouée.", vbExclamation
            Case SE_ERR_DDEBUSY
                MsgBox "Opération DDE occupée.", vbExclamation
            Case SE_ERR_NOASSOC
                'Ouvrir avec...
                Call Shell("rundll32.exe shell32.dll,OpenAs_RunDLL " + Filename, vbNormalFocus)
        End Select
    Else
        'Retourne le hWnd du programme lançé par ShellExecuteEx
        OpenProgram = SEI.hProcess
    End If
    
    Exit Function
ErrorHandler:
    OpenProgram = 0
End Function
Public Function GetExtension(Filename As String) As String
Dim tablo() As String
tablo = Split(Filename, ".")
GetExtension = tablo(UBound(tablo))
End Function

.... Je reviens plus tard pour la suite.

**Andnotor** · 12/12/2012, 10h25

Envoyé par Godzestla

Sous un OS 32 bits, on utilise "Open" de ShellexecuteEx pour ouvrir un document via le programme associé ET AUSSI LANCER UN EXECUTABLE.

Sous un OS 64 bits, on doit utiliser "RunAs" en lieu et place de "Open" pour lancer un exécutable (32 ou 64 bits).

Absolument pas ! Comme l'a dit sevyc64, la redirection est automatique. Open est utilisé dans les deux cas. RunAs force la demande de confirmation d’élévation de privilèges, même si l'application n'en a pas besoin... Si tu copies manuellement des fichiers, à toi de les mettre au bon endroit

Maintenant, si tu veux vraiment que ton application 32 bits accède aux répertoires 64 bits, tu peux invoquer Wow64DisableWow64FsRedirection.

**Godzestla** · 12/12/2012, 12h08

Envoyé par Andnotor
Absolument pas !

Et pourtant, je t'assure que c'est le cas :

ShellexecuteEx, avec SEI.lpVerb = "open" pour un exécutable 64 Bit sous Windows 8 - 64 Bits ne lance pas l'exécutable mais donne une erreur qui de mémoire devrait être 458 ou 258 (je ne suis pas certain, je n'ai pas cette machine sous la main).

La même commande avec "runas" fonctionne.

L'exécutable appelé est dans un répertoire normal.

Est-ce alors juste un problème de droit ?

**sevyc64** · 12/12/2012, 13h33

Je ne connais pas les spécificités de W8, peut-être que nombre de choses ont encore changé,mais il est vrai qu'habituellement RunAs est utilisé pour obtenir une élévation de droit, pour obtenir les droits administrateur en langage courant.

Qu'appelle-tu "répertoire normal" ?

LE répertoire "normal" d'installation des applications est Programs Files (ou son jumeaux Programs Files (x86) pour les applications 32 bits). Ce répertoire et ses sous-répertoires sont en lecture seule hors élévation de droits.
Avec un logiciel mal conçu (conçu à l'ancienne, pour XP par exemple), si ce logiciel tente d'écrire dans un fichier (de configuration par exemple) dans son dossier d'installation ou dans un sous-dossier, il y aura une exception, il n'en a as le droit. Un RunAS, s'il fait effectivement une élévation de droits peut lui redonner ces droits là et permettre au logiciel de fonctionner.
(Les modes de compatibilités d’exécutions sont là pour ça aussi)

Donc le problème est de savoir si le logiciel ne se lance pas, ou s'il se lance et plante.
Le numéro de l'erreur n'est pas significatif hors contexte, le message d'erreur est plus utile lorsqu'il décrit l'erreur apparue.

**Godzestla** · 12/12/2012, 15h02

Rebonjour,

d'abord, je tiens à préciser que je suis novice en système, et que j'ai découvert , contraint et forcé, W8 et son 64 bit il y a qq jours.
La machine est monoposte, config dites standard, mais

vraiment pas évident de s'y retrouver pour moi.

Mon code de départ, en VBA (sous Excel) a été conçu (par moi) sous XP et tourne sans problème sous VISTA.

En grandes lignes, ce code effectue :
* La mise en place et/ou annulation d'une imprimante PDF
* la mise en place standard du logiciel Ghostscript
* la mise en place d'une barre d'outil personnelle pour office (Excel et Word) pour utiliser l'imprimante PDF via GHOSTSCRIPT, mais également la copie d'une DLL depuis le répertoire GHOSTSCRIPT installé vers windows, condition nécessaire à l'utilisation d'API pour accéder à Ghostscript.

Sous Win8-64bits, j'ai rencontré les problèmes suivants :
1) Impossible de lancer l'exécutable d'installation de CUTEPDF via Shell mais également via ShellexecuteEx. L'exécutable est dans le même répertoire que le code VBA, un répertoire quelconque du disque dur.

Solution trouvée au problème 1 : Si OS 64 Bit, utiliser SEI.lpVerb : "Runas" en lieu et place de "Open" avec ShelexecutEx pour "ouvrir" un exécutable. Marche sans problème. (C'est le code que j'ai publié).

2) Impossible de lancer exécutable d'installation de Ghostscript 32-bit (oui, je dit bien 32 bit mais j'y reviens).
-> Solution idem problème 1 : Marche sans problème.

3) Impossible de copier la DLL standard installée par GHOSTSCRIPT depuis c:\Pogram files (x86)...... vers C:\Windows\System32

-> Solution provisoire : copie la DLL à la main.

3.2) Impossible d'utiliser la DLL copiée (à ce stade j'ignorais pourquoi) :
-> Le code ne voit pas la DLL (DIR)
-> le code refuse d'y faire appel (Shell32)

-> Solution : Désinstalle GHOSTSCRIPT 32 bit et télécharge version 64 bits. Si OS 64-Bit, installe version 64-bit à la place de la 32. -> la copie fonctionne, le code voit la DLL, le code sait l'utiliser.

Voulant éviter de modifier mon code de manière profonde, celui-ci faisant appel à la DLL sous son nom 32bits, je décide de copier la DLL 64 bits installée dans windows\system32 également sous son nom 32 bit si l'OS est 64 bit, nom que j'utilise dans mon code.

--> Fonctionne sans problème même si douteux déontologiquement parlant.

En finalité, j'appelle la DLL 64 bit au travers de sa copie sous son nom 32 bit sur un OS 64 Bit et mon code fait parfaitement son travail.

4) L'acces à la base de registre via RegOpenKey pour lire la clé de HKEY_LOCAL_MACHINE qui donne le nom de la DLL standard à copier (et utiliser) ne fonctionne pas .

----> Solution reçue de ce forum (

) : Utiliser RegOpenKeyEx au lieu de RegOpenKey en passant le parametre KEY_WOW64_64KEY si OS 64 bit.
---> fonctionne sous vista (KEY_WOW64_32KEy). A tester sur WIN8.

Je propose de tester tout cela ce soir et de provoquer l'erreur ShellexecuteEx avec SEI.lpVerb = "open" pour un exécutable 64 bits.

je te donnerai le numéro et la description de l'erreur.

Et pour conclure,
*j'espère ne pas avoir dit trop de conneries, car franchement le système, ça me dépasse totalement.

* très sincèrement merci pour ton aide.

**sevyc64** · 12/12/2012, 16h15

Ah ben t'avais pas tout dit.

Je maintiens, je n'ai pas W8 sous la main et encore fait aucun test avec.
Normalement, tu ne devrais pas avoir à utiliser RunAs pour lancer un executable "standard".

Sauf que, les exécutables que tu veux lancer, toi, sont des setup d'installation. Et les installations de logiciels necessitent d'avoir les droits d'administration, d’où la nécessité probablement de lancer l’exécutable avec RunAS (les lanceras-tu en mode silencieux ? Car normalement tu devrais avoir une fenêtre de l'uac te demandant l'autorisation de continuer).

Normalement tu aurais du avoir le même soucis sous Vista, sauf que l'uac y est tellement pénible qu'il a surement été désactivé, pour se retrouver avec un système aussi permissif que XP.

**Andnotor** · 12/12/2012, 18h51

sevyc64 a parfaitement résumé la situation

Ton problème est dû aux Installers qui veulent soit écrire dans des répertoires protégés ou dans la base des registres dans une ruche protégée (HKLM...) et là RunAs trouve tout son sens.

Maintenant, la question à te poser est : Est-ce une version d'Office 32 ou 64 bits ? En fonction de cela, tu sauras si tu dois installer Ghostscript 32 ou 64

Ce n'est pas un problème spécifique Windows 8. Tu aurais les mêmes entre les versions précédentes 32 et 64.

**Godzestla** · 13/12/2012, 08h09

Rebonjour,

merci pour vos réponse.

Il s'agit effectivement d'exécutables de type setup.
Pour office, c'est une version 2007 32 bit (sur la machine WIn-8 64 bit) car ailleurs tout est différent.

J'ai tenté de reproduire l'erreur de ShellexecuteEx avec SEI.lpVerb = "open" pour un exécutable 32 ou 64 bit (setup) appelé par VBA-Excel Office 2007 32-bit sur Windows8-64 bits, mais impossible. Cela veut fonctionner à chaque coup.

La différence est que j'ai été depuis, je pense, donner tous les droits à l'utilisateur sur le répertoire où se trouve les exécutables de Setup que je voulais lancer. Ceci devrait confirmer votre théorie qu'il faut Runas pour lancer des installs.

Donc, maintenant , tout fonctionne sous WIn8 sauf RegopenKeyEx dont je parle dans mon autre post.

Je cloture ce post-ci, j'en sais assez pour mes petits besoins.

Et

de m'avoir sorti de mon

en vous jetant corps et âme dans ma problèmatique. J'ai appris pas mal de choses

**Andnotor** · 13/12/2012, 09h26

Ce n'est pas l'exe qui fait foi mais où il veut écrire (et ce n'est pas que de la théorie). Si ça passe en augmentant les droits sur son dossier, c'est qu'il se résume à un simple fichier compressé (autoextractible) qui extrait son contenu dans son propre répertoire

**Godzestla** · 13/12/2012, 11h50

J'en prend bonne note.

**Godzestla** · 18/12/2012, 09h53

Voilà,

il me reste un dernier problème pour copier ma DLL dans System32 ou SysWOW64. J'obtiens à chaque coup, quelle que soit la technique, quel que soit le répertoire sysxxxnn (system32 ou sysWOW64), un message accés refusé.

J'ai désactivé l'UAC qui m'empoisonnais la vie et m'étais inutile, mais je ne parviens pas à avoir le droit de copie dans sysxxxnn.

Acces refusé

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
    target = Environ$("systemroot") & "\System32\" & "gsdll32.dll"
   FileCopy source, target

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
target = Environ$("systemroot") & "\SysWOW64\" & "gsdll32.dll"
FileCopy source, target

L'utilisation de FSO donne le même résultat

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
CopyFileToAnotherLocation source, target

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Sub CopyFileToAnotherLocation(fromfile As String, tofile As String)
    Dim FSObj       As FileSystemObject
    Dim answer      As Integer
    Set FSObj = New FileSystemObject
    If FSObj.FileExists(tofile) Then
        answer = MsgBox("File already exists in this location. " _
            & "Are you sure you want to continue? If you continue " _
            & "the file at destination will be deletedo!", _
            vbInformation + vbYesNo)
             If Not answer = vbYes Then Exit Sub
    End If
    FSObj.CopyFile fromfile, _
        tofile, True
End Sub

Manuellement, le copy fonctionne sans problème.

DLL Standard 32 bits installée dans \Windows\System32 inaccessible

Windows 8

Discussions similaires

Partager

Partager