Wert von RegSetValueEx

[me2u]

Hallo,

ich versuche mich gerade daran RegSetValueEx zu hooken. Dabei möchte ich den Wert (Parameter "lpValue"), der gesetzt wird als string an meine LogApplication senden. Allerdings weiß ich nicht, wie ich an den Inhalt von "lpValue" (Typ: PByte) kommen kann. Erstmal ist es ja immer ein unterschiedlicher Datentyp, d.h. ich mache eine Fallunterscheidung (case) nach dem Parameter "dwType".

Code:

  
  function ValueToStr(lpData: PByte): string;
  case dwType of
    REG_DWORD : Str(lpData^, Result);
    REG_SZ    : Result := lpData^;
    ...

und zweitens komme ich über den zeiger lpData immer nur an das erste Byte heran. Also meine Strings die ich übermittle bestehen immer nur aus dem ersten Character und meine Zahlen bewegen sich nur im Intervall 0 .. 255. Der Funktion RegSetValueEx wird aber auch noch der Parameter "cbData" (Typ: DWORD) übergeben, der der Grösse von "lpData" in Byte entspricht.
Habe schon versucht ihn mit an ValueToStr zu übergeben und ihn einzusetzen... nur ich weiß nicht wie.
Also wie kann ich einer Variablen den Speicherinhalt (referenziert durch "lpData") zuweisen?

MfG
Markus

[ste_ett]

Versuch mal dieses.

REG_SZ : Result := PChar(lpData); "lpData^" ist korekterweise auch nur ein Zeichen.

[me2u]

oh... das is ja super wie schnell man hier eine Antwort bekommt

leider hilft das auch nichts... das Resultat besteht wieder nur aus dem ersten Zeichen. Ich vermute, dass es an dem Datentyp PBYTE (von "lpData") liegt.
Beispiel: Registryeintrag = "Lucida Console" (vom Typ REG_SZ), cbData = 30... mein String enthält nur "L"

Irgendwie muss man noch den Wert von "cbData" mit einbauen. Ich vermute dass cbData immer der (Länge des Eintrags + 1 Zeichen) * 2 entspricht. Das zusätzliche Zeichen wird Null sein, um den String abzuschliessen. Beim Registry-Datentyp REG_DWORD ist "cbData" übrigens immer 4.

Für Typ REG_SZ: Ist es nicht irgendwie möglich den Zeiger "lpData" immer ein Byte weiter zu setzen und dann das Zeichen im Speicher abzufragen? Wenn ja, dann hätte ich aber keine Ahnung wie es syntaktisch richtig aufgeschrieben würde.

kleiner Nachtrag:
So was in der Art, würde helfen (hatte ich mal versucht... verdeutlicht glaub ich eine Idee):

Delphi-Quellcode:

var s: string;
    i: DWORD
...
REG_DWORD: begin
             GetMem(@i, cbData)  // konnte man so nicht schreiben
             @i := lpData;       // der linken Seite kann nix zugewiesen werden
             Result := IntToStr(i);
           end;
REG_SZ: begin                    // Kommentare... siehe oben
          GetMem(@s, cbData);
          @s := lpData;  
          Result := s;
        end;
...

Viele Grüsse
Markus

[ste_ett]

Hookst du "RegSetValueExA" oder "RegSetValueExW"?

Bei "RegSetValueExW" musst du statt "PChar()" einfach "PWideChar" nehmen.

- edit -

Zitat:

Beim Registry-Datentyp REG_DWORD ist "cbData" übrigens immer 4.

Das liegt daran, dass eine Variable vom Typ "DWORD" immer exakt vier Byte groß ist.

[me2u]

super... da hätte ich ja auch mal selber drauf kommen können
Damit wäre der Typ REG_SZ schonmal geklärt... vielen Dank.

Aber wie funktioniert das ganze nun bei REG_DWORD?

Str(lpData^, Result); liefert immer nur Werte zw. 0 und 255.

und ein Typcast mittels DWORD() vor dem lpData^ liefert dasselbe Ergebnis.

Nachtrag:

Delphi-Quellcode:

   var b1, b2, b3, b4: Byte;
   ...
   REG_DWORD : begin
                 b1 := lpData^;
                 b2 := PByte(DWORD(lpData) + 1 * SizeOf(Byte))^;
                 b3 := PByte(DWORD(lpData) + 2 * SizeOf(Byte))^;
                 b4 := PByte(DWORD(lpData) + 3 * SizeOf(Byte))^;
                 Str(b1 + b2*256 + b3*65536 + b4*16777216, Result);
               end;

Dabei verlasse ich mich aber darauf, dass cbData beim Typ REG_DWORD immer 4 ist... was ja eigentlich auch der Fall sein müsste, oder? Ausserdem würde mich interessieren, ob es auch eine elegantere Lösung für das Problem gibt.

Dennoch einen herzlichen Dank an ste_ett für deine Hilfe.

Gruss Markus

[ste_ett]

Delphi-Quellcode:

var
  dwTemp: DWORD;
...

   REG_DWORD : begin
                 CopyMemory(@dwTemp, lpData, sizeof(DWORD)); // vier Byte in ein DWORD kopieren
                                                             // DWORD ist immer vier Byte groß
                 Str(dwTemp, Result);
               end;

[me2u]

super... vielen dank!