ich habe ein kleines problem mit einer (eventuell mit mehreren) registry funktionen ... code sieht (ungefähr) so aus:

// Key öffnen 
lRet = RegOpenKeyEx(HKEY_CURRENT_USER, "Software\\Ordner", 0, KEY_QUERY_VALUE, &hKey1);

if( lRet != ERROR_SUCCESS ) {
  // irgendwas machen ... Fehlermeldung oder so ... 
}

else {
   do 
      {
         char cName1[256] = ""; 
         iLastError = 0; 
         DWORD dwData = 256;
         // suche alle Ordner die im geöffneten hKey1 stehen
         iLastError = RegEnumKeyEx(hKey1,i,cName1,&dwData,0,0,0,0); 
         i++;

         CString Pfad;
         Pfad.Format("Software\\Ordner\\%s", cName1);
         // jeden Ordner per MsgBox ausgeben
         MessageBox(NULL, Pfad, "Warning !!!", MB_OK | MB_ICONQUESTION);
}while(iLastError!=ERROR_NO_MORE_ITEMS);

so ... eigentlich müsste die while Schleife doch solange durchlaufen bis kein Ordner/Schlüssel mehr gefunden wird. Bei mir läuft das aber endlos und er schreibt mir nichts in cName1 oder eventuell findet er nichtmal was ;/ ... also die MsgBox sieht immer gleich aus und es steht nur Software\Ordner\ drin

warum ist das so ???

meiner meinung nach ist das genau so wie in der FAQ http://www.c-plusplus.net/forum/viewtopic.php?t=39373&highlight=registry nur das ich das noch per MsgBox ausgebe

das ist doch HKEY_CURRENT_USER und auf den muss ich zugreifen können ... dachte ich zumindest ...

mit dem code (an einer anderen stelle) führe ich eigentlich auch eine .reg datei aus die genau an der stelle was schreibt ... und das funktioniert oder hat das damit nichts zu tun ???

auf welche stellen muss ich den 100% als normaler benutzer zugreifen können ???

probier mal zugriff KEY_ALL_ACCESS oder KEY_ENUMERATE_SUB_KEYS statt KEY_QUERY_VALUE.
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/sysinfo/base/registry_key_security_and_access_rights.asp

Denn das ist sein Fehler:
Er sagt, er will einen Wert abfragen (KEY_QUERY_VALUE), tut aber letzendlich enumerieren (RegEnumKeyEx).

Mit KEY_READ anstatt KEY_QUERY_VALUE wär das nicht passiert!

btw. und es funktioniert auch mit KEY_ALL_ACCESS ... würde aber natürlich auch mit den anderen beiden funktionieren ...

jetzt habe ich aber das problem das ich in dem gefundenen, unbekannten Ordner nochmal unbekannte Ordner habe und die kann ich irgendwie nicht mehr auf diese weiße auslesen ... bzw. den ersten schon noch aber dann schneidet er mir immer mehr von den namen ab und deshalb kann ich die dann nicht mehr nach values durchsuchen ... ;/

werd jetzt noch nen bischen rumprobieren ... eventuell bekomm ichs noch hin ^^

thx für die Hilfe ... ohne euch wäre ich nicht weitergekommen

aber es wäre eigentlich ein char[256] ???

wenn ich mal was einigermaßen brauchbares hinbekommen habe (das aber vermutlich nicht funktionieren wird) poste ich es mal ...

char cName1[256] = {0};

aber ich will später von den einzelnen, unbekannten Ordner dann Werte auslesen ... darum nehme ich jetzt KEY_ALL_ACCESS ... das funktioniert garantiert

...solange der User als ADMINISTRATOR am Rechner sitzt, ja.

Versuch das als "Benutzer" oder "Hauptbenutzer" mit KEY_ALL_ACCESS und Du machst 'ne Bauchlandung...

Versuch das als "Benutzer" oder "Hauptbenutzer" mit KEY_ALL_ACCESS und Du machst 'ne Bauchlandung...

auch bei HKEY_CURRENT_USER

auch bei HKEY_CURRENT_USER?

normalerweise nicht. Aber ab etwa 50 Nutzern lernst du ziemlich schnell das "normal" ein sehr subjektives Konzept ist.
*Immer* mit minimalen Rechten an Dateien, Registry usw. rangehen. Ich kannte mal einen, der Dateien immer mit read/write_Rechten aufgemacht hat, auch zum lesen. Drei Tage später war er tot.

ja irgendwie wird der kleiner

(...,&dwData, ...)

MSDN:

lpcbData
[in, out] Pointer to a variable that specifies the size of the buffer pointed to by the lpData parameter, in bytes. When the function returns, this variable contains the size of the data copied to lpData.

i.a.w. dwData gibt reinzu die Länge deines Puffers an, und rauszu die Länge der eigentlichen Daten

sollte öfter in dieses Forum schauen ^^

das ist nun das was ich bis jetzt geschafft habe und bis auf den Teil bei dem ich meine Werte auslese bzw. dann vergleichen will funktioniert glaub ich alles

path = REGISTRYPFAD;

lRet = RegOpenKeyEx(HKEY_CURRENT_USER, path, 0, KEY_READ, &hKey1);   // öffne .../Ordner

do
{
   path = "Software\\Ordner";  // bekannter Pfad
   j = jLastError = 0;   // wieder zurücksetzen

   if (lRet  != ERROR_SUCCESS)   // prüfen
   {
      errorMSG.Format("Unable open Registry!\nERROR: 1_%i", lRet);
      MessageBox(NULL, errorMSG, "MsgBox 1", MB_OK | MB_ICONQUESTION);
      abbruch = TRUE;
   }
   else
   {
      char cName1[256] = ""; 
      DWORD dwData1 = 256; 

      iLastError = RegEnumKeyEx(hKey1,i,cName1,&dwData1,0,0,0,0);
      if (iLastError == ERROR_NO_MORE_ITEMS)     // wenn im bekannten Ordner nichts mehr ist
      {                                          // Schluss, da sonst die beiden anderen
         break;                                  // Schleifen ein letztes mal durchlaufen
      }                                          // werden
      i++; 

      path.Format("%s\\%s", REGISTRYPFAD, cName1);
      // TEST
      test.Format("%s  iLastError:%i", path, iLastError);
      MessageBox(NULL, test, "Warning !!!", MB_OK | MB_ICONQUESTION);
      // TEST //
      buffer1.Format("%s",cName1);
   }

      lRet = RegOpenKeyEx(HKEY_CURRENT_USER, path, 0, KEY_READ, &hKey2);   // öffne .../Ordner/Ebene_1

      do
      {

         if (lRet  != ERROR_SUCCESS)   // prüfen
         {
            errorMSG.Format("Unable open Registry!\nERROR: 2_%i", lRet);
            MessageBox(NULL, errorMSG, "Warning !!!", MB_OK | MB_ICONQUESTION);
            abbruch = TRUE;
         }
         else
         {
            char cName2[256] = ""; 
            DWORD dwData2 = 256; 

            jLastError = RegEnumKeyEx(hKey2,j,cName2,&dwData2,0,0,0,0);   // suchen 
            j++; 

            path.Format("%s\\%s\\%s", REGISTRYPFAD, buffer1, cName2);
            // TEST
            test.Format("%s  jLastError:%i", path, jLastError);
            MessageBox(NULL, test, "MsgBox 2", MB_OK | MB_ICONQUESTION);
            // TEST //
         }

            lRet = RegOpenKeyEx(HKEY_CURRENT_USER, path, 0, KEY_READ, &hKey3);    // öffne .../Ordner/Ebene_1/Ebene_2

          //  do
          //  {

               if (lRet  != ERROR_SUCCESS)    // prüfen
               {
                  errorMSG.Format("Unable open Registry!\nERROR: 3_%i", lRet);
                  MessageBox(NULL, errorMSG, "Warning !!!", MB_OK | MB_ICONQUESTION);
                  abbruch = TRUE;
               }
               else
               {

                  // Value "Wert" auslesen
                  readValueRet = RegQueryValueEx( hKey3, "Wert",  NULL, NULL, (LPBYTE) result, &dwBufLen);

                  if (readValueRet == ERROR_SUCCESS)  // Value gefunden  
                  {
                     // TEST
                     errorMSG.Format("%s", "Erfolgreich!!!");
                     MessageBox(NULL, errorMSG, "Warning !!!", MB_OK | MB_ICONQUESTION);
                     // TEST //

                     if((result[528] == '0') && (result[529] == '0'))
                     {
                              gefunden++;   // wieviele Werte enthalten den das was man sucht  
                     }
                     else
                     {
                              nichtGefunden++;  // wieviele Werte enthalten es nicht
                     }

                  }
                  else if (readValueRet == ERROR_FILE_NOT_FOUND)  // dieses Value gibt es nicht
                  {
                     // TEST
                     errorMSG.Format("%s", "File not found");
                     MessageBox(NULL, errorMSG, "Warning !!!", MB_OK | MB_ICONQUESTION);
                     // TEST //
                     // nichts machen
                  }
                  else   // siehe Fehlercode lRet
                  {
                     errorMSG.Format("Unable open Registry!\nERROR: 4_%i", lRet);
                     MessageBox(NULL, errorMSG, "Warning !!!", MB_OK | MB_ICONQUESTION);
                     abbruch = TRUE;
                  }

               //   kLastError = ERROR_NO_MORE_ITEMS;

               }

           // } while ( !(kLastError == ERROR_NO_MORE_ITEMS) && !abbruch);

      } while ( !(jLastError == ERROR_NO_MORE_ITEMS) && !abbruch);

} while ( !(iLastError == ERROR_NO_MORE_ITEMS) && !abbruch);

als ergebnis erhalte ich dann immer nur "nichtGefunden" ;/ ich weiß aber das auch "gefunden" drin steht

Die Werte die ich auslese sind immer REG_BINARY ... wenn ich das aber bei "RegQueryValueEx" statt der zweiten NULL eintrage bekomme ich immer den Fehler, dass er nicht von int auf unsignd long casten kann oder sowas ??? (habe den WATCOM C/C++ Compiler ... weiß das der nicht toll ist ^^ )

Ich habe mir hier im Forum jetzt nen paar sachen zum auslesen angeschaut, aber irgendwie verstehe ich das nicht ganz bzw. bin genau so schlau wie vorher ... will eigentlich nur diesen Wert auslesen und dann an einer bestimmten Stelle vergleichen ... das es so wie ich das oben machen nicht geht verstehe ich inzwischen ... weiß aber nicht wie es richtig geht.

PS: Ich weiß das der Code schrecklich aussieht ... aber ich bin erstmal froh das es (einigermaßen) funktioniert ... verbessert wird nachher ^^

#define SIZE 300
DWORD dwNumber[SIZE]; 
DWORD dwData; 
RegQueryValueEx(hKey,"EintragsName",NULL,NULL,(BYTE*)&dwNumber,&dwData);

ich habe dann dwNumber mit 0 vorbesetzt und als int ausgeben lassen ... da stehen dann lauter 0 in den zellen. Wenn ich dann das "RegQueryValueEx" mache und es mir nochmal als int ausgeben lasse steht was anderes drin ... das zeigt doch das etwas ausgelesen wird ??? ... wie ich das jetzt aber vergleiche, weiterverarbeite oder überprüfe ob der wert drinsteht den ich will weiß ich ned ... vermutlich darf ich für dwNumber auch garkein array verwenden ... ka ... aber is vermutlich sowieso falsch was ich da mache ^^

ich mach jetzt einfach

BYTE dwNumber[BUFSIZE];   // Speicher für Registrywert
DWORD dwData = BUFSIZE;   // Speicher für länge des Registrywerts
BYTE dummy;               // Verglichsbyte für gesuchstes Byte im Registrywert
dummy = 04;

// usw. 

readValueRet = RegQueryValueEx ( hKey3, "Wert", NULL, NULL, (BYTE*)&dwNumber, &dwData );  

 if (dwNumber[264] == dummy)
    gefunden++;
 else
    nichtGefunden++;

und es funktioniert anscheinend so ... allerdings recht toll ist es nicht ^^

ich habe ja nur nicht gewusst wie ich das was ich bekomme mit was anderem vergleiche ... ;/

so und nun mus ich das ganze nur noch ordentlicher, intelligenter und besser machen ^^ ...

aber mich interresiert ja nur ob dieses eine byte 04 ist :p allerdings muss ich ja immer den kompletten registrie wert auslesen ^^

und naja gefallen tut mir der gesamte code nicht ... das kann man sicher noch "ordentlicher" schreiben ... werd mir das jetzt am we nochmal anschauen ... irgendwie gehts sicher "besser"