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
¤tSubLen, //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
Vous devez vous connecter pour publier un commentaire.
Énumérer les clés de cette manière, c'est du matraquage. Ce serait tout simplement de gaspiller les ressources du système, de la mémoire, la pile des appels et de mettre la pression sur le registre de la sous-système. Ne pas le faire sauf si nécessaire.
Allez-vous avoir la "recherche du registre" dans votre application? Si oui, énumérer uniquement lorsque l'utilisateur le demande. Ou, si vous êtes en développement "Registry Viewer/Editor", faire élargir et d'ouvrir des sous-clés uniquement lorsque cela est nécessaire.
Si vous avez absolument besoin de récupérer et de stocker toutes les clés/valeurs, vous pouvez utiliser plusieurs threads pour énumérer les clés. Le nombre de threads est d'abord la HKEY-major-clés, et puis vous pouvez avoir plus de threads, selon le nombre de sous-clés de l'exécution et des heuristiques vous effectuez lors de l'énumération des clés.
La récursivité peut ou peut ne pas être la bonne approche pour "recursive-énumération" des sous-clés, vous devez conserver le nombre d'arguments à récursive de la mise en œuvre minimale de mettre les arguments dans un
struct
ou de les mettre dans la classe. Vous pouvez aussi utiliserstd::stack
pour la même chose.OriginalL'auteur Ajay
Il semble que vous appelez RegEnumValue() sans paramètre de la lpcchValueName paramètre à une valeur correcte. Ce paramètre est un paramètre [en] ainsi que [out] paramètre. Essayez ceci:
Documentation pour RegEnumValue() : http://msdn.microsoft.com/en-us/library/ms724865(v=vs. 85).aspx
OriginalL'auteur Brain2000