[C] Recherche complète d'un terme dans le registre.

[franco]

Bonjour à tous.

Depuis un loooong moment, je cherche à créer un outil qui me permettrait de faire une recherche d'un terme dans tout le registre.

En effet, connaissant bien SEAF ( http://general-changelog-team.fr/fr/dow ... -xx/6-seaf ), je me suis dis qu'un tel outil, je pouvais le coder (pas le même, je ne cherche que la partie registre).

Or, en testant un autre logiciel ( regscanner : http://www.nirsoft.net/utils/regscanner.html), celui est bien plus fourni en options, et trouve plus de chose que seaf.

Un screen de regscanner : http://i1-win.softpedia-static.com/scre ... nner_1.png

=====

En fait, seul les éléments suivants m'intéressent dans la recherche :
-> La clé trouvée (que ce soit la clé elle-même, la valeur, etc)
-> Le nom de la valeur trouvé
-> Le type si possible.

Comme ceci :

► Afficher le texteImage

j'avais trouvé cela : http://www.autoitscript.com/forum/topic ... ntry222610
Mais j'ai du mal, vraiment du mal à faire ce que je désire ^^

Tout de même un code qui recherche les installations / désinstallations au sein du registre:

► Afficher le textecode

Code : Tout sélectionner

#include <_regsearch.au3>
#include <file.au3>
$UninstallTXT = @TempDir & "\RapportUninstall.txt"
Global $sUninstallKey = "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall"
Global $sValName = "UninstallString"

; Get array of all "UninstallString" values
$aUninstallKeys = _RegSearch($sUninstallKey, $sValName, 2, True) ; 2 = Match on Value Names only, True = return array

; Create 2D array for data
Global $aUninstallStrings[UBound($aUninstallKeys)][2] = [[$aUninstallKeys[0], ""]]

; Populate 2D array with value location and data
$_UninstallTXT = FileOpen($UninstallTXT, 2)
For $n = 1 To $aUninstallKeys[0]
    $aUninstallStrings[$n][0] = $aUninstallKeys[$n]
    $aUninstallStrings[$n][1] = RegRead(StringTrimRight($aUninstallStrings[$n][0], StringLen($sValName)), $sValName)
    If $aUninstallStrings[$n][1] = "" Then $aUninstallStrings[$n][1] = "yoyoyo"
    FileWriteLine($_UninstallTXT, $n & " - " & $aUninstallStrings[$n][0] & @CRLF & $aUninstallStrings[$n][1] & @CRLF & @CRLF)
Next
FileClose($_UninstallTXT)
_ReplaceStringInFile($UninstallTXT, @CRLF & "yoyoyo" & @CRLF, @CRLF)
ShellExecute($UninstallTXT)
; Display results
;~ $test = _ArrayDisplay($aUninstallStrings)

;~ for $i = 1 to $test[0][0]
;~  MsgBox(0,"",$test[$i][0])
;~  Next
 

Mais à faire ce que je veux vraiment, j'y arrive pas.


Du coup, j'aimerais bien qu'on m'aide beaucoup sur ce coup ^^
Et si je peux comprendre, ça serait cool


Merci.
++

[jguinch]

Qu'est-ce qui te bloque avec _regsearch.au3 ?
Vu le nombre d'entrées dans la base de registre, tu risques d'être confronté à plusieurs problèmes :
- lenteur
- limite de récursivité (avec _regsearch.au3)
- limite de taille de tableau (pas sûr...)
Le premier point (lenteur) est vraiment un frein énorme, qui, à mon avis, risque de te faire passer l'envie d'aller plus loin...

Je m'étais bricolé une fonction qui permet de lister les entrées de la BDR, un peu comme _FileListToArray, mais sans filtre. Je te mets le code ici si tu veux piquer des idées. La fonction liste les clés/valeurs de manière récursive, sans utiliser la récursivité.
Fais le test en changeant la clé de recherche, et vois le temps que ça prends. Tu peux faire pareil avec _regsearch.au3 pour comparer, mais dans tous les cas ce sera lent.

► Afficher le texte

Code : Tout sélectionner

; Example : List all keys, subkeys and values :
#Include <Array.au3> ; for result only
Local $aRes = _RegListToArrayRec("HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\ProfileList", 1)
 _ArrayDisplay($aRes)




; #FUNCTION# ====================================================================================================================
; Name ..........: _RegListToArrayRec
; Description ...: List keys, valuenames and values from the specified registry key and its subkeys.
; Syntax ........: _RegListToArrayRec($sKeyName[, $iFlag = 1])
; Parameters ....: $sKeyName            - The registry key to read.
;                  $iFlag               - [optional] Specifies whether to return values, keys or both.
;                    0 : Returns both valuenames/values and keys.
;                    1 : Returns valuenames and values only.
;                    2 : Returns keys only.
; Return values .: Success : A 2 dimmension array.
;                   $aArray[0][0] : Number of valuenames/keys returned.
;                   $aArray[1][0] : 1st valuename/key path
;                   $aArray[1][1] : 1st valuename/key type.
;                                   Types are KEY, REG_SZ, REG_MULTI_SZ, REG_EXPAND_SZ, REG_DWORD, REG_QWORD, REG_BINARY
;                   $aArray[1][2] : 1st valuename/key name.
;                   $aArray[1][3] : 1st value.
;                 Failure : 0 and set @error flag as follows:
;                   1 : Unable to open requested key.
;                   2 : $iFlag is not valid.
;                   3 : Valuename or registry key not found.
; Author ........: jguinch
; ===============================================================================================================================
Func _RegListToArrayRec($sKeyName, $iFlag = 0)
    If NOT _RegKeyExists($sKeyName) Then Return SetError(1, 0, 0)
    If NOT IsInt($iFlag) OR $iFlag < 0 OR $iFlag > 2 Then Return SetError(2, 0, 0)

    Local $sKFlag = "REG_KEY", $n = 0, $iCountKeys = 0, $iCountValues = 0, $aKeys[1][4] = [[$sKeyName   , $sKFlag]]
    Local $aList, $aValues[1][4]
    
    $sKeyName = StringRegExpReplace($sKeyName, "\\$", "")

    While $aKeys[$n][0] <> ""
        If $aKeys[$n][1] = $sKFlag Then
            $aList = _RegListToArray($aKeys[$n][0], 0)
            
            If NOT @error Then
                For $i = 1 To $aList[0][0]
                    If $aList[$i][1] = $sKFlag OR $iFlag = 0 OR $iFlag = 2 Then
                        If $iFlag = 2 AND $aList[$i][1] <> $sKFlag Then ContinueLoop

                        $iCountKeys += 1
                        If ( UBound($aKeys) + $iCountKeys)  >= UBound($aKeys) Then Redim $aKeys[ $iCountKeys * 2][4]
                        $aKeys[$iCountKeys][0] = $aList[$i][0]
                        $aKeys[$iCountKeys][1] = $aList[$i][1]
                        $aKeys[$iCountKeys][2] = $aList[$i][2]
                        $aKeys[$iCountKeys][3] = $aList[$i][3]
                    Else
                        $iCountValues += 1
                        If ( UBound($aValues) + $iCountValues ) >= UBound($aValues) Then Redim $aValues[ $iCountValues * 2][4]
                        $aValues[$iCountValues][0] = $aList[$i][0]
                        $aValues[$iCountValues][1] = $aList[$i][1]
                        $aValues[$iCountValues][2] = $aList[$i][2]
                        $aValues[$iCountValues][3] = $aList[$i][3]
                    EndIf
                Next
            EndIf
        EndIf
        
        $n += 1
        If $n > UBound($aKeys) - 1 Then ExitLoop 
    WEnd

    If $iFlag = 0 OR $iFlag = 2 Then
        $aValues = $aKeys
        $iCountValues =  $iCountKeys
    EndIf

    If $iCountValues = 0 Then Return SetError(3, 0, 0)

    Redim $aValues[$iCountValues + 1][4]
    $aValues[0][0] = UBound($aValues) - 1
    $aValues[0][1] = ""

    Return $aValues
EndFunc ; ===> _RegListToArrayRec



; #FUNCTION# ====================================================================================================================
; Name ..........: _RegListToArray
; Description ...: List keys, valuenames and values from the specified registry key.
; Syntax ........: _RegListToArray($sKeyName[, $iFlag = 1])
; Parameters ....: $sKeyName            - The registry key to read.
;                  $iFlag               - [optional] Specifies whether to return values, keys or both.
;                    0 : Returns both valuenames/values and keys.
;                    1 : Returns valuenames and values only.
;                    2 : Returns keys only.
; Return values .: Success : A 2 dimmension array.
;                   $aArray[0][0] : Number of valuenames/keys returned.
;                   $aArray[1][0] : 1st valuename/key path
;                   $aArray[1][1] : 1st valuename/key type.
;                                   Types are KEY, REG_SZ, REG_MULTI_SZ, REG_EXPAND_SZ, REG_DWORD, REG_QWORD, REG_BINARY
;                   $aArray[1][2] : 1st valuename/key name.
;                   $aArray[1][3] : 1st value.
;                 Failure : 0 and set @error flag as follows:
;                   1 : Unable to open requested key.
;                   2 : $iFlag is not valid.
;                   3 : Valuename or registry key not found.
; Author ........: jguinch
; ===============================================================================================================================
Func _RegListToArray($sKeyName, $iFlag = 0)
    If NOT _RegKeyExists($sKeyName) Then Return SetError(1, 0, 0)
    If NOT IsInt($iFlag) OR $iFlag < 0 OR $iFlag > 2 Then Return SetError(2, 0, 0)

    Local $sKFlag = "REG_KEY", $iCountKeys = 0, $iCountValues = 0
    Local $sName, $vValue, $iType, $aResult[1][4]
    
    $sKeyName = StringRegExpReplace($sKeyName, "\\$", "")

    If $iFlag = 0 OR $iFlag = 1 Then
        While 1
            $sName = RegEnumVal($sKeyName, $iCountValues + 1)
            If @error Then ExitLoop

            $vValue = RegRead($sKeyName, $sName)
            $iType = @Extended
            Switch @extended
                Case $REG_SZ
                    $iType = "REG_SZ"
                Case $REG_MULTI_SZ
                    $iType = "REG_MULTI_SZ"
                Case $REG_EXPAND_SZ
                    $iType = "REG_EXPAND_SZ"
                Case $REG_DWORD
                    $iType = "REG_DWORD"
                Case $REG_QWORD
                    $iType = "REG_QWORD"
                Case $REG_BINARY
                    $iType = "REG_BINARY"
                Case Else
                    ContinueLoop
            EndSwitch

            $iCountValues += 1

            If $iCountValues >= UBound($aResult) Then Redim $aResult[ UBound($aResult) * 2 ][4]
            $aResult[$iCountValues][0] = $sKeyName
            $aResult[$iCountValues][1] = $iType
            $aResult[$iCountValues][2] = $sName
            $aResult[$iCountValues][3] = $vValue
        WEnd
    EndIf

    If $iFlag = 0 OR $iFlag = 2 Then
        While 1
            $sName = RegEnumKey($sKeyName, $iCountKeys + 1)
            If @error Then ExitLoop
            $iCountKeys += 1

            If $iCountKeys + $iCountValues >= UBound($aResult) Then Redim $aResult[ UBound($aResult) * 2][4]
            $aResult[$iCountKeys + $iCountValues][0] = $sKeyName & "\" & $sName
            $aResult[$iCountKeys + $iCountValues][1] = $sKFlag
        WEnd
    EndIf

    If $iCountKeys + $iCountValues = 0 Then Return SetError(3, 0, 0)

    Redim $aResult[$iCountKeys + $iCountValues + 1][4]
    $aResult[0][0] = UBound($aResult) - 1

    Return $aResult
EndFunc ; ===> _RegListToArray



Func _RegKeyExists($sKey)
    RegEnumVal($sKey, 1)
    Return NOT ( @error > 0)
EndFunc
 

[franco]

Salut.

Je confirme, c'est extrêment lent.

8h après, toujours en exécution, en recherche.

Du coup, je laisse tomber la recherche via le registre, je garde donc regscanner sous le coude.


Sujet donc clos.
Merci.