Mit Regenumvalue() kann ich die augelisteten Values ja gleich speichern.

Nur wo genau soll ich sie speichern?

Soviel ich weiss in einer char oder void Variable und die dann richtig ausgeben.

Was sagt ihr dazu?

mfg

int enumvalues(HKEY subkey)

{

char kA[255];

unsigned long int valueindex=0;
unsigned long int valuesize=sizeof(kA);
unsigned long int type[30];

char byte[200];
char SZ[250];
unsigned long int dword;

LPBYTE data;

unsigned long int datasize=sizeof(data);

for (;valueindex<values;valueindex++)
{
RegEnumValue(subkey,valueindex,kA,&valuesize,NULL,&type[valueindex],data,&datasize);

if(type[valueindex]==REG_BINARY)  
{
printf("binaray ");
printf("%x",data);
}

if(type[valueindex]==REG_SZ)
{
printf("string ");
printf("%s\n", data);
}

if(type[valueindex]==REG_DWORD)
{
printf("Zahl ");
printf("%i",data);
}

valuesize=sizeof(kA);
datasize=sizeof(LPBYTE);
printf("%s\n",kA);

}

return 0;
}

is mal ne

Ich kann die Antwort kaum erwarten :D, und sitze wie auf Kohlen.

Nur wo genau soll ich sie speichern?

Soll man diese Frage ernst nehmen ? Das hängt doch davon ab, wo und wie Du die Daten verarbeiten willst...

PS: Dieser Part hier ist ja wohl Schwachsinn:

RegEnumValue(..., &type[valueindex],data,&datasize);

In der MSDN steht doch genau drin, was Du als Parameter übergeben musst .

http://msdn2.microsoft.com/en-us/library/aa914418.aspx

erstmal danke für die Antwort, auch wenn etwas kritisch.

Hab das jetzt eben überprüft und mir fällt der Fehler nicht auf,
ich verwende die Typen, die verlangt werden, falls du darauf angedeutet hast.

Mfg

Muhi89 schrieb:

Hab das jetzt eben überprüft und mir fällt der Fehler nicht auf,
ich verwende die Typen, die verlangt werden, falls du darauf angedeutet hast.

Jupp der Typ stimmt, aber der Inhalt nicht. Es wird doch nach einem
"Pointer to a variable that receives the type code for the value entry." gefragt. Du musst also einen Zeiger auf eine Variable übergeben. Du übergibst nur einen Zeiger. Und der zeigt ins Nirvana:

LPBYTE data;

(Vllt auch auf NULL, da global, aber trotzdem ändert das nur, dass es deshalb nicht abstürzt -> Access-Violation. Mach die mal lokal und initialisier sie nicht, dann wirds krachen .)

Must be something like this:

BYTE byData
RegEnumValue(..., &byData, ...);

Hoffe es ist auch klar wieso .

Könntest du mir das mit dem Byte erklären?

Ist das damits in bytes gespeichert wird (hmm komisch formuliert, wirds ja so eig/irgendwie) auch aber du weisst was ich mein hoff ich.
und ich den Inhalt der Variable je nach Bedarf ausgeben kann? (also das richtige Ausgabezeichen verwende)?

mfg

er findet alle Values nur kann der Inhalt nicht korrekt gespeichert werden...

mfg

er findet alle Values nur kann der Inhalt nicht korrekt gespeichert werden...

Eventuell so ?

// LPBYTE data;
BYTE data [500];

// RegEnumValue(subkey,valueindex,kA,&valuesize,NULL,&type[valueindex],data,&datasize);
RegEnumValue(subkey,valueindex,kA,&valuesize,NULL,&type[valueindex],&data,&datasize);

// datasize=sizeof(LPBYTE);
datasize=sizeof(data);

danke!

inzwischen klappt das Auslesen/Anzeigen von Strings, Probleme gibts aber noch bei Zahlen und Bytes muss ich noch testen.

Bei den Zahlen kommt immer die selbe Zahl, obwohls in Wirlichkeit verschiedene sind.

mfg

Mfg

Deshalb sollten bei der Ausgabe die BYTE's entsprechend zusammengefasst werden.

REG_SZ dürfte kein Problem sein.

REG_DWORD entspricht vier BYTE's :

if(type[valueindex]==REG_DWORD) 
{ 
 DWORD val;
 memmove (&val,&data,sizeof(DWORD)); // vier bytes "zusammengefasst"

 printf("Zahl "); 
// printf("%i",data);
 printf("%i",val);
}

REG_BINARY kann so ausgeben werden :

if(type[valueindex]==REG_BINARY)   
{ 
 printf("binaray "); 
// printf("%x",data); 
 printf("%x %x %x %x",data[0],data[1],data[2],data[3]); // vier sollten reichen
}

zB: die erste Value wird richtig ausgegeben (Name, Typ und Inhalt)

dann wird nur noch der Name der ersten Value angezeigt und der Inhalt der anderen gar nicht mehr.

Damit keine Verwirrung herrscht hier mal der Code:

int enumvalues(HKEY subkey)

{

char kA[255];

unsigned long int valueindex=0;
unsigned long int valuesize=sizeof(kA);
unsigned long int type[30];

unsigned char byte[200];
unsigned char SZ[250];
unsigned long int dword;

unsigned long int bytesize=sizeof(byte);
unsigned long int SZsize=sizeof(SZ);
unsigned long int dwordsize=sizeof(dword);

BYTE data[500];

memset(data,0,sizeof(BYTE));

unsigned long int datasize=sizeof(data);

for (;valueindex<values;valueindex++)
{
RegEnumValue(subkey,valueindex,kA,&valuesize,NULL,&type[valueindex],data,&datasize);

printf("%s ", kA);

if(type[valueindex]==REG_BINARY)  
{
 printf("binary ");

for(;data[i]!=0;i++)
{
printf("%x", data[i]);
}

}

if(type[valueindex]==REG_SZ)
{
if(data[0]!=0)
{
printf("string ");
printf("%s\n", data);
}

}

if(type[valueindex]==REG_DWORD)
{
 DWORD val;
 memmove (&val,&data,sizeof(DWORD)); 

 printf("Zahl ");
 printf("%i\n",val);
}

memset(data,0,sizeof(BYTE));

valuesize=sizeof(kA);
datasize=sizeof(BYTE);

}

return 0;
}

Ich habe sämtliche rootkeys in einem HKEY Array gespeichert.
Bei mir gibts 5 rootkeys daher habe ich das array mit 4 initialisiert.

Wenn ich dann bei der Auswahl am Anfang das 5te und letzte Element nehme kommen einfach ur viele Leerausgaben und ne (möglicherweise Endlos-)Schleife.

Initialisiere ich das Array mit 5 also zb HKEY array[5], passiert das nicht.

Das dürfte doch eig nicht passieren oder??

mfg

die erste Value wird richtig ausgegeben ... der Inhalt der anderen gar nicht mehr

...
// datasize=sizeof(BYTE);
datasize=sizeof(data);    // <- !
...

Muhi89 schrieb:

Initialisiere ich das Array mit 5 also zb HKEY array[5], passiert das nicht.

So muss es auch sein :

HKEY array[5]; // -5- Elemente, angesprochen mit Index 0,1,2,3,4