AutoIt Français

Bonjour.

Je suppose que tout le monde connait l'outil java.

Qu'il est possible d'installer java 32 bits et/ou java 64 bits donc sur un système 64 bits.

Pour tout vous dire : j'ai les deux sur mon PC.

J'essaye donc de récupérer les ID désinstallation des 2 java.

Le souci, c'est que :
-> Si le script est compilé en 32 bits, je ne récupère que l'ID de désinstallation de java 32 bits.
-> Si le script est compilé en 64 bits, je ne récupère que l'ID de désinstallation de java 64 bits.

Comment faire pour récupérer les deux clés sous mon système en 64 bits ? Telle est la question. ^^
Sachant que les deux ID sont quasiment similaire.

Exemple :
Je récupère les ID de désinstallation de java via la clé HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall
-> ID de désinstallation de java 64 bits : {26A24AE4-039D-4CA4-87B4-2F86418011FF}
-> ID de désinstallation de java 32 bits : {26A24AE4-039D-4CA4-87B4-2F83218011FF}

J'ai pensé à faire un stringreplace avec 64/32.
Mais le hic, c'est qu'il se peut qu'il n'existe qu'un seul JAVA.

J'aimerais bien avoir vos idées sur le fait de récupérer les fameuses ID.
Merci.

Ah oui, voici le code :

Code : Tout sélectionner

$UninstallKey = "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\"

$a = 1
While @error = 0
    RegEnumKey($UninstallKey, $a)
    $a += 1
WEnd

For $i = 1 To $a - 2
    If StringLeft(RegEnumKey($UninstallKey, $i), 1) = "{" Then
        If RegRead($UninstallKey & RegEnumKey($UninstallKey, $i), "Contact") = "http://java.com" Then
            MsgBox(0,"",RegEnumKey($UninstallKey, $i))
        EndIf
    EndIf
Next

Cordialement,
Thomas.

Ton code a l'aire bien, tu vas peux être pas tout chercher :

"HKLM\SOFTWARE\Microsoft\windows\CurrentVersion\uninstall"
"HKLM\SOFTWARE\Wow6432Node\Microsoft\windows\CurrentVersion\uninstall"

Salut.

merci à toi. ^^

Au lancement du script (sans compiler) ça fonctionne pas.
Mais à la compilation, ça fonctionne.

Donc, il faut que je fasse deux fois la détection avec les deux clés.
A priori.

Je reviens dès que j'ai des nouvelles.

@+

Salut.

Juste pour info
La clé "HKLM\SOFTWARE\Wow6432Node\Microsoft\windows\CurrentVersion\uninstall" ne donne rien.

J'ai été voir la doc. http://www.autoitscript.fr/autoit3/docs ... upport.htm

Pour la base de registre, utilisez HKCR64 ou HKLM64 pour contourner le mécanisme de redirection (Voir les fonctions pour la base de registre dans la documentation).

Maintenant, je comprends mieux.

Je pense que c'est résolu.
Je vais tester.

++

Salut.

Donc : pas du tout résolu.

Ce que j'ai compris
=> Si c'est compilé en X86, il ne reconnait pas la clé "HKLM\SOFTWARE\Wow6432Node\Microsoft\windows\CurrentVersion\uninstall"

Logique.

Je ne vais pas me casser la tête je pense.

====

Vu que l'ID est la même - sauf l'élément 32/64 - je vais faire une condition lié à l'architecture.

=> Car si le pc utilisé est un PC en 32 bits, donc forcément, il n'y aura jamais de java 64bits.

=> Mais si le PC est un pc en 64 bits, je récupère l'ID.
Si présence de 32 dans le nom, je créé une variable contenant l'ID mais en modifiant 32 par 64.
Et vice versa.

Je ne vois que cela à faire.

Voici le code fonctionnel :

► Afficher le textecode

Il n'est pas fini, mais le reste je sais le faire.

En tout cas merci.

J'aurais préféré une solution plus... propre. ^^

Mais bon, si elle fonctionne, tant mieux.

Note :
Je posterais le code fini bien sur.

@+

il y a peux être des truc à trouver ici "HKLM\SOFTWARE\Classes\Installer\Products"

Salut. Et merci, je ne connaissais pas cette clé.

Mais contrairement à la clé uninstall, on ne trouve pas l'ID (entre { } ), utilisé pour la désinstallation de java en mode silencieux.

Merci à toi de m'aider à creuser ^^

++

franco a écrit :=> Si c'est compilé en X86, il ne reconnait pas la clé "HKLM\SOFTWARE\Wow6432Node\Microsoft\windows\CurrentVersion\uninstall"

Le code ci-dessous devrait répondre à votre demande :

Code : Tout sélectionner

Global $Arch = "", $IDJAVA = "", $a = 1
If @OSArch =  "X64" Then $Arch = "\Wow6432Node"

Global $UninstallKey = "HKLM\SOFTWARE" & $Arch & "\Microsoft\Windows\CurrentVersion\Uninstall\"


While RegRead($UninstallKey & "\" & RegEnumKey($UninstallKey, $a), "Contact") <> "http://java.com"
    $a += 1
WEnd
$IDJAVA = RegEnumKey($UninstallKey, $a)

MsgBox(0, "ID Java", $IDJAVA)

Le code compilé en x86 fonctionne très bien sur un OS x64 ...

franco :
- Un script compilé en 32 bits lit par défaut les clés 32 bits, donc pas besoin de spécifier Wow6432Node. Par contre il faudra utiliser HKLM64 pour lire les clés 64 bits (qui sont dans HKLM\Software)
- Un script compilé en 64 bits lit par défaut les clés 64 bits, donc pas besoin de spécifier HKLM64. Par contre, il faudra utiliser Wow6432Node pour lire les clés 32 bits (qui sont dans HKLM\Software\Wow6432Node)

Pour créer un truc universel, tu as à ta disposition @AutoItX64 qui te permettra d'aiguiller ton script vers les différentes possibilités.

Tlem, tu as pensé à celui qui n'a pas Java ?

jguinch a écrit :Par contre, il faudra utiliser Wow6432Node pour lire les clés 32 bits (qui sont dans HKLM\Software\Wow6432Node)

Voir : http://msdn.microsoft.com/en-us/library ... 85%29.aspx

MSDN a écrit :Note The Wow6432Node key is reserved. For compatibility, applications should not use this key directly.

J'ai donc pensé qu'avec les fonctions d'AutoIt (Reg...) on pouvait récupérer la version 32 bits du registre depuis un système 64 bits (comme on peut le faire avec RegOpenKeyEx et KEY_WOW64_32KEY). Je n'ai pas pu y arriver. Est-ce normal ? Par contre avec _WinAPI_RegOpenKey on peut récupérer la clef 32 bits sans problème (et surtout sans utiliser Wow6432Node).

► Afficher le texte

Code : Tout sélectionner

#include <APIRegConstants.au3>
#include <Debug.au3>
#include <MsgBoxConstants.au3>
#include <WinAPIDiag.au3>
#include <WinAPIReg.au3>
#Region ;**** Directives created by AutoIt3Wrapper_GUI ****
#AutoIt3Wrapper_Compile_Both=y
#EndRegion ;**** Directives created by AutoIt3Wrapper_GUI ****

If @Compiled Then
    _DebugSetup('', False, 1)
Else
    _DebugSetup('', False, 2)
EndIf

_regOpenKey()
_regAutoIt()

Func _regOpenKey()
    ; Obtient la version 64 bits (sur un système 64 bits) ou la version 32 bits (sur un système 32 bits).
    $hKey = _WinAPI_RegOpenKey($HKEY_LOCAL_MACHINE, 'Software\AutoIt v3\AutoIt', $KEY_READ)
    If @error Then Exit MsgBox(BitOR($MB_ICONERROR, $MB_SYSTEMMODAL), @extended, _WinAPI_GetErrorMessage(@extended))
    _enum($hKey, 'natif')

    ; Obtient la version 32 bits mais déconseillé.
    $hKey = _WinAPI_RegOpenKey($HKEY_LOCAL_MACHINE, 'Software\Wow6432Node\AutoIt v3\AutoIt', $KEY_READ)
    If @error Then Exit MsgBox(BitOR($MB_ICONERROR, $MB_SYSTEMMODAL), @extended, _WinAPI_GetErrorMessage(@extended))
    _enum($hKey, 'Wow6432Node')

    ; Obtient la version 32 bits (Access a 32-bit key from either a 32-bit or 64-bit application.).
    $hKey = _WinAPI_RegOpenKey($HKEY_LOCAL_MACHINE, 'Software\AutoIt v3\AutoIt', BitOR($KEY_READ, $KEY_WOW64_32KEY))
    If @error Then Exit MsgBox(BitOR($MB_ICONERROR, $MB_SYSTEMMODAL), @extended, _WinAPI_GetErrorMessage(@extended))
    _enum($hKey, '$KEY_WOW64_32KEY')

    ; Obtient la version 64 bits (Access a 64-bit key from either a 32-bit or 64-bit application.).
    $hKey = _WinAPI_RegOpenKey($HKEY_LOCAL_MACHINE, 'Software\AutoIt v3\AutoIt', BitOR($KEY_READ, $KEY_WOW64_64KEY))
    If @error Then Exit MsgBox(BitOR($MB_ICONERROR, $MB_SYSTEMMODAL), @extended, _WinAPI_GetErrorMessage(@extended))
    _enum($hKey, '$KEY_WOW64_64KEY')
EndFunc   ;==>_regOpenKey

Func _regAutoIt()
    For $i = 1 To 2
        $sSubKey                    = RegEnumKey('HKLM\SOFTWARE\AutoIt v3\AutoIt', $i)                  ; Obtient la version 64 bits (sur un système 64 bits) ou la version 32 bits (sur un système 32 bits).
        $sSubKeyWow6432Node         = RegEnumKey('HKLM\SOFTWARE\Wow6432Node\AutoIt v3\AutoIt', $i)      ; Obtient la version 32 bits mais déconseillé.
        $sSubKey64                  = RegEnumKey('HKLM64\SOFTWARE\AutoIt v3\AutoIt', $i)                ; Devrait obtenir la version 32 bits ???
        $sSubKey64Wow6432Node       = RegEnumKey('HKLM64\SOFTWARE\Wow6432Node\AutoIt v3\AutoIt', $i)

        _DebugOut('_regAutoIt' & @CRLF & $sSubKey & @CRLF & $sSubKey64 & @CRLF & $sSubKeyWow6432Node & @CRLF & $sSubKey64Wow6432Node)
    Next
EndFunc   ;==>_regAutoIt

Func _enum(ByRef $hKey, $version)
    Local $iCount = _WinAPI_RegQueryInfoKey($hKey)
    Local $aKey[$iCount[2]]
    For $i = 0 To UBound($aKey) - 1
        $aKey[$i] = _WinAPI_RegEnumValue($hKey, $i)
    Next

;~  _ArrayDisplay($aKey, $version)
    _DebugReportVar($version, $aKey)

    _WinAPI_RegCloseKey($hKey)
EndFunc   ;==>_enum

Et ça c'est ce que j'ai ajouté au registre pour les tests.

► Afficher le texteAutoIt.reg

Merci orax.
Effectivement, Wow6432Node est une clé réservée (à ne pas utiliser dans un programme normalement). Mais ici, on parle d'un programme qui a justement besoin d'accéder à cette ruche.
Donc je pense qu'à partir du moment où on sait où on met les pieds, on peut se permettre d'y aller (prudemment). En plus, ici c'est uniquement pour de la lecture de clé.
Cela dit, la doc est intéressante

De tout façon, le programme que va réaliser Franco devra être compilé en 32 bits; s'il doit pouvoir s'exécuter sur un système 32 bits.
Donc les deux clés à lire sont :
- HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall (pour la partie 32bits)
- HKLM64\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall (pour la partie 64 bits) - seulement si OSArch = 64 bits

jguinch a écrit :Tlem, tu as pensé à celui qui n'a pas Java ?

Java est omniprésent sur les machines actuelle. Ceci dit le cas peux effectivement ce présenter et dans ce cas on est prisonnier de la boucle While, donc pour résoudre le problème tout en prenant en compte la remarque d'orax (Note The Wow6432Node key is reserved. For compatibility, applications should not use this key directly.) :

Code : Tout sélectionner

Global $Arch = "", $IDJAVA = "", $IDRead, $a = 1
If @OSArch =  "X64" Then $Arch = "64"

Global $UninstallKey = "HKLM" & $Arch & "\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\"


While 1
    $IDJAVA = RegEnumKey($UninstallKey, $a)
    If @error Then ExitLoop
    If RegRead($UninstallKey & "\" & $IDJAVA, "Contact") = "http://java.com" Then ExitLoop
    $a += 1
WEnd


MsgBox(0, "ID Java", $IDJAVA)

Avec ce code, il n'y a qu'avec la version 32 bits (compilée) que j'arrive à avoir le résultat souhaité. (Je n'ai pas la βετα d'AutoIt.)

Pour la version 32 bits du script :
– avec $UninstallKey = "HKLM..., ça me retourne la clef 32 bits (la partie dans \SOFTWARE\Wow6432Node\Microsoft\...)
– avec $UninstallKey = "HKLM64..., ça me retourne la clef 64 bits (la partie dans \SOFTWARE\Microsoft\...)

Pour la version 64 bits du script :
– avec HKLM ou HKLM64, c'est pareil, ça me retourne la clef 64 bits
Dans cette version, je n'ai donc pas accès à ce qui ce trouve dans Wow6432Node à moins d'y accéder directement par la clef "HKLM\SOFTWARE\Wow6432Node\".

Je ne sais pas si c'est bien le comportement normal des fonctions RegEnumKey, etc. mais ça me semble bizarre. C'est comme si, quand le script est compilé en 64 bits, le fait d'ajouter "64" après "HK..." ne faisait rien de plus.

D'ailleurs en passant directement par les fonctions de l'API Windows, j'ai bien le comportement souhaité. Que le script soit compilé (ou pas) en 32 ou 64 bits, je récupère bien les IDs de désinstallation de Java 32 et 64 bits.
J'ai aussi ajouté une condition sur "DisplayName" sinon il récupérait aussi l'ID du JDK de Java.

► Afficher le texte

Code : Tout sélectionner

#Region ;**** Directives created by AutoIt3Wrapper_GUI ****
#AutoIt3Wrapper_Compile_Both=y
#EndRegion ;**** Directives created by AutoIt3Wrapper_GUI ****
#include <APIRegConstants.au3>
#include <Debug.au3>
#include <MsgBoxConstants.au3>
#include <WinAPIDiag.au3>
#include <WinAPIReg.au3>

_main()

Func _main()
    ; Obtient la version 32 bits (Access a 32-bit key from either a 32-bit or 64-bit application.).
    $aKey = _getCLSIDJava($KEY_WOW64_32KEY)

    ; Obtient la version 64 bits (Access a 64-bit key from either a 32-bit or 64-bit application.).
    $aKey = _getCLSIDJava($KEY_WOW64_64KEY)
EndFunc   ;==>_main

Func _desinstall($key, $flagWow)
    $flagWowTxt = ($flagWow = $KEY_WOW64_32KEY) ? '32 bits' : '64 bits'
    ConsoleWrite($flagWowTxt & ' > ' & $key & @CRLF)
    MsgBox(0, '', $flagWowTxt & ' > ' & $key)
EndFunc   ;==>_desinstall

Func _getCLSIDJava($flagWow)
    Local $rootKey = $HKEY_LOCAL_MACHINE
    Local $UninstallKey = "SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall"

    Local $hKey = _WinAPI_RegOpenKey($rootKey, $UninstallKey, BitOR($KEY_READ, $flagWow))
    _err()

    Local $iCount = _WinAPI_RegQueryInfoKey($hKey)
    _err()

    Local $aKey[$iCount[0]]
    For $i = 0 To UBound($aKey) - 1
        $aKey[$i] = _WinAPI_RegEnumKey($hKey, $i)
        _err()

        If StringLeft($aKey[$i], 1)  = '{' Then
            $contact = _regQueryValue($rootKey, $UninstallKey & '\' & $aKey[$i], 'Contact', $flagWow)
            $DisplayName = _regQueryValue($rootKey, $UninstallKey & '\' & $aKey[$i], 'DisplayName', $flagWow)
        If $contact = 'http://java.com' And StringRegExp($DisplayName, 'Java \d+') Then
            _desinstall($aKey[$i], $flagWow)
        EndIf
        EndIf
    Next

    Return $aKey
EndFunc   ;==>_getCLSIDJava

Func _regQueryValue($rootKey, $key, $value, $flagWow)
    Local $tData = DllStructCreate('wchar[260]')

    $hKey = _WinAPI_RegOpenKey($rootKey, $key, BitOR($KEY_READ, $flagWow))
    _err()

    _WinAPI_RegQueryValue($hKey, $value, $tData)
    _err()

    _WinAPI_RegCloseKey($hKey)

    Return DllStructGetData($tData, 1)
EndFunc   ;==>_regQueryValue

Func _err($err = @error, $ext = @extended)
    If @error Then MsgBox($MB_ICONERROR, @error, _WinAPI_GetErrorMessage(@extended))
EndFunc   ;==>_err

orax a écrit :C'est comme si, quand le script est compilé en 64 bits, le fait d'ajouter "64" après "HK..." ne faisait rien de plus

C'est le comportement "normal" : un script compilé/exécuté en 64 bits n'est pas concerné par la redirection Wow6432Node, donc HKLM = HKLM64.
Alors que pour un script compilé/exécuté en 32 bits, le redirection s'applique et on a HKLM\Software = HKLM\software\Wow6432Node.

L'exemple de la fonction RegEnumVal utilise Wow6432Node pour lister des clés 32 bits. Si c'est dans l'exemple, c'est qu'on peut se servir de Wow6432Node (un peu ce que déconseille MSDN du coup).

Pour clarifier les choses, petit test à faire chez soi :
Ouvrir deux invites de commande : l'une normale, depuis Démarrer, Exécuter : CMD, et l'autre depuis C:\Windows\SysWOW64\cmd.exe. On a ici deux invites de commandes, l'une en 64 et l'autre en 32 bits.
Dans chaque invite de commande, taper reg query "HKEY_LOCAL_MACHINE\SOFTWARE\AutoIt v3\AutoIt" /v Version
L'une nous dira que le chemin est introuvable (64 bits), l'autre nous donnera la valeur (32 bits).

Les solutions avec la commande reg.exe pour lire des valeurs natives ou redirigées sont :
- spécifier le chemin "complet" : Wow6432Node (par ex)
- utiliser la commande reg.exe sous c:\windows\SysWOW64 (depuis invite x64) ou c:\windows\sysnative (depuis invite x86)
- utiliser le commutateur /reg:32 ou /reg:64
Concernant AutoIt, il y a la possibilité d'utiliser HKLM64, mais il n'existe pas de HKLM32 (dommage).

Donc au final avec AutoIt, c'est soit utilisation de HKLM64 et/ou Wow6432Node avec les fonctions Reg natives, soit utilisation des fonctions WinAPI (comme proposé par Orax).

Je sais pas si j'ai été clair

En fait, mon interprétation de la doc était mauvaise, parce qu'en lisant :

When running on 64-bit Windows if you want to enum a value specific to the 64-bit environment you have to suffix the HK... with 64 i.e. HKLM64.

Par "value specific to the 64-bit environment" je comprenais qu'il s'agissait des clefs contenues dans Wow6432Node. Car les clefs/valeurs dans Wow6432Node sont justement spécifiques à un environnement 64 bits.
Et le fait que cela ne concerne que la version 32 bits du script n'est pas indiqué sur cette page mais sur une autre :

Titre > Exécuter la version 32-bit de AutoIt sur un système x64
Pour la base de registre, utilisez HKCR64 ou HKLM64 pour contourner le mécanisme de redirection (Voir les fonctions pour la base de registre dans la documentation).

En tout cas merci pour cette réponse, ça m'a aidé à y voir plus clair ! Il n'y avait donc pas de problème, ce n'était qu'une fonctionnalité !

Tout à fait. D'ailleurs la chose qui pose le plus de problème, c'est la lecture d'une clé x86 dans un environnement x64 avec un script compilé en x64. J'avais écrit cela il y à 2 ans (http://www.autoitscript.fr/forum/viewto ... 091#p74091).

Maintenant, vu que vous ne faites que de la lecture de clé, l'utilisation de Wow6432Node ne pose pas de problème particulier.
Je vous ai refait le script pour prendre en compte vos remarques et pour vous donner la liste des IDs en fonction des versions de Java installé, car vous pouvez en avoir plusieurs (Java 6, Java 7, x32, x64).

► Afficher le texte

Après, pourquoi ne compilez vous pas votre script uniquement en x86 ?
~~Cela vous simplifierait la tache~~ ...

Cela vous éviterait seulement d'utiliser Wow6432Node dans le chemin de la clé de registre.

Et donc dans le code ci-dessus, la ligne :

Code : Tout sélectionner

$RootKeyx86 = "HKLM\SOFTWARE\Wow6432Node"

deviendrait

Code : Tout sélectionner

$RootKeyx86 = "HKLM\SOFTWARE"

Peut-être que ça peut vous intéresser : _UninstallList : Liste/recherche des applications installées

Salut.

Oh pinaise, y'a eu du peuple ici

Désolé de répondre que maintenant, j'étais occupé.

Le dernier code de TLEM fonctionne.

Un grand merci à tous.

Je vais tout relier, y compris les codes, afin de mieux comprendre.

Moi qui détectai une seule ID et ensuite "la convertissait" sans savoir si elle existait, le code permet donc une réelle et propre détection de Java.

Ouf ^^
Merci encore.

Le reste étant déjà codé, me reste plus qu'à adapter le code.

Je reviendrai avec le code final.

@+

AutoIt Français

[..] Récupérer une clé registre 32bits sur un système 64bits

[..] Récupérer une clé registre 32bits sur un système 64bits

Re: [..] Récupérer une clé registre 32bits sur un système 64

Re: [..] Récupérer une clé registre 32bits sur un système 64

Re: [..] Récupérer une clé registre 32bits sur un système 64

Re: [..] Récupérer une clé registre 32bits sur un système 64

Re: [..] Récupérer une clé registre 32bits sur un système 64

Re: [..] Récupérer une clé registre 32bits sur un système 64

Re: [..] Récupérer une clé registre 32bits sur un système 64

Re: [..] Récupérer une clé registre 32bits sur un système 64

Re: [..] Récupérer une clé registre 32bits sur un système 64

Re: [..] Récupérer une clé registre 32bits sur un système 64

Re: [..] Récupérer une clé registre 32bits sur un système 64

Re: [..] Récupérer une clé registre 32bits sur un système 64

Re: [..] Récupérer une clé registre 32bits sur un système 64

Re: [..] Récupérer une clé registre 32bits sur un système 64

Re: [..] Récupérer une clé registre 32bits sur un système 64

Re: [..] Récupérer une clé registre 32bits sur un système 64

Re: [..] Récupérer une clé registre 32bits sur un système 64