L'énumération de tous les sous-clés et valeurs de clé de registre de Windows

Je suis en train d'écrire une application Windows qui me donne de nouveau toutes les sous-clés et valeurs d'une clé donnée. J'ai écrit le code qui s'affiche à travailler comme fournissant le sous-clés à l'intérieur de la clé donnée, mais ne marche pas correctement l'énumération des valeurs; il a réussi à énumère les sous-clés sans valeurs, puis renvoie les résultats dans le genre des onglets de l'arbre arrangement. Cependant, lors de l'énumération des valeurs, le programme renvoie une valeur aléatoire pour chaque valeur actuelle (la même valeur aléatoire à chaque fois), et puis se bloque par la suite à une erreur de débogage.

Il est prévu de sortie est fondamentalement:

(1) KEY
    (1) SUBKEY
    (1) SUBKEYWITHINSUBKEY
        Code: value1data
        Code: value2data
        Code: value3data
(2) SUBKEY
    (1) SUBKEYWITHINSUBKEY
(3) SUBKEY

...et ainsi de suite.

La sortie j'obtiens plutôt quelque chose comme:

(1) KEY
(1) SUBKEY
    (1) SUBKEYWITHINSUBKEY
        Code: someValue
        Code: someValue
        Code: someValue

(...et puis le crash)

Ceci est suivi avec l'erreur suivante:

"Erreur De Débogage! "Au Moment de l'exécution de Panne de contrôle N ° 2 - Pile autour de la variable 'valNameLen" a été endommagé."

Le code est un peu brouillon actuellement (je suis une API de Windows débutant), mais si quelqu'un pouvait me montrer ce que je fais mal, ou de critiquer mon style de codage dans le même sens en forme, ce serait génial.

Merci!

-R

/*
Windows Registry Subkey Enumeration Example
Based on example found at code-blue.org
*/
#include <windows.h>
#include <stdio.h>
void EnumerateValues(HKEY hKey, DWORD numValues)
{
DWORD dwIndex = 0;
LPSTR valueName = new CHAR[64];
DWORD valNameLen;
DWORD dataType;
DWORD data;
DWORD dataSize;
for (int i = 0; i < numValues; i++)
{
RegEnumValue(hKey,
dwIndex,
valueName,
&valNameLen,
NULL,
&dataType,
(BYTE*)&data,
&dataSize);
dwIndex++;
printf("Code: 0x%08X\n", data);
}
}
void EnumerateSubKeys(HKEY RootKey, char* subKey, unsigned int tabs = 0) 
{
HKEY hKey;
DWORD cSubKeys;        //Used to store the number of Subkeys
DWORD maxSubkeyLen;    //Longest Subkey name length
DWORD cValues;        //Used to store the number of Subkeys
DWORD maxValueLen;    //Longest Subkey name length
DWORD retCode;        //Return values of calls
RegOpenKeyEx(RootKey, subKey, 0, KEY_ALL_ACCESS, &hKey);
RegQueryInfoKey(hKey,            //key handle
NULL,            //buffer for class name
NULL,            //size of class string
NULL,            //reserved
&cSubKeys,        //number of subkeys
&maxSubkeyLen,    //longest subkey length
NULL,            //longest class string 
&cValues,        //number of values for this key 
&maxValueLen,    //longest value name 
NULL,            //longest value data 
NULL,            //security descriptor 
NULL);            //last write time
if(cSubKeys>0)
{
char currentSubkey[MAX_PATH];
for(int i=0;i < cSubKeys;i++){
DWORD currentSubLen=MAX_PATH;
retCode=RegEnumKeyEx(hKey,    //Handle to an open/predefined key
i,                //Index of the subkey to retrieve.
currentSubkey,            //buffer to receives the name of the subkey
&currentSubLen,            //size of that buffer
NULL,                //Reserved
NULL,                //buffer for class string 
NULL,                //size of that buffer
NULL);                //last write time
if(retCode==ERROR_SUCCESS)
{
for (int i = 0; i < tabs; i++)
printf("\t");
printf("(%d) %s\n", i+1, currentSubkey);
char* subKeyPath = new char[currentSubLen + strlen(subKey)];
sprintf(subKeyPath, "%s\\%s", subKey, currentSubkey);
EnumerateSubKeys(RootKey, subKeyPath, (tabs + 1));
}
}
}
else
{
EnumerateValues(hKey, cValues);
}
RegCloseKey(hKey); 
}
int main()
{
EnumerateSubKeys(HKEY_CURRENT_USER,"SOFTWARE\\MyKeyToSearchIn");
return 0;
}

OriginalL'auteur 8bitcartridge | 2011-07-26