Versuch einen Registry Key zu exportiren (als *.reg Datei)

[mgee]

Ja hallöchen ich habe folgendes problem:

Mein Program soll, bevor es änderungen in der Registry vornimmt, eine sicherungsdatei eines bestimmten Pfades der Registry erstellen und zwar so dass man diese sicherungsdatei (*.reg) mit einem Doppelklick ausführen kann.
Leider bekomm ich das nicht so richtig gebacken... :gruebel:
Ich möchte das so zB, dass der pfad "Software\Program\settings" aus "HKEY_CURRENT_USER" in eine *.reg Datei abgespeichert wird.
Mit Delphi bin ich da noch zusehr unbeholfen, da ich zwar das zeig alles irgendwie exportiren kann, aber nicht in diesem komsichen "*.reg"-Dateiformat.
Deshalb habe ich nach alternativen gesucht, aber leider nichts entsprechendes gefunden. Eine Lösung über eine Batch-datei wäre für mich auch schon eine Lösung (aber bitte mit einem gerechtem Beispiel, danke :thumb: )

Für antworten wäre ich euch sehr dankbar!
(benutze vorwiegend delphi2005)

[fkerber]

HI!

Herzlich Willkommen in der DP!

Hast du dir mal eine solche Reg-Datei angesehen? Wenn mich nicht alles täuscht, ist das doch eine reine Textdatei, die folgendermaßen aussieht:

["Pfad"]
Bezeicher=Wert

Wenn du die Werte also aus der Registry auslesen kannst, solltest du doch auch so eine Datei erstellen können, oder?
An welcher Stelle hängts denn?

ciao Frederic

[3_of_8]

Sieh dir mal TIniFile an. Wenn du rekursiv den Registrierungspfad ausliest, kannst du das in eine INI speichern mit Dateiendung *.reg.

Vielleicht gibts aber auch ne API Funktion dafür.

[Lannes]

Hallo,

und wie wäre es damit?

Delphi-Quellcode:

ShellExecute(Form1.Handle
             ,'open'
             ,'regedit.exe'
             ,Pchar('/e C:\@Archiv\bmp.REG "HKEY_CLASSES_ROOT\.bmp"')
             ,''
             ,SW_SHOWNORMAL);

[mgee]

Ja das mit der Ini-Datei weiss ic bereits, aber mich hat eher ne einfache API-Funktion interresiert :)
Aber danke für eure antworten!

Ich versuch lieber mal die einfache Sache von Lannes :)

[ichbins]

Achtung, der Registry-Editor kann auf manchen Systemen vom Administrator gesperrt sein! Du darfst nicht darauf vertrauen dass die Shellexecute-Lösung klappt.

hm... ich hab vor ein paar Tagen schon mal dieselbe Frage zum Thema Importieren gemacht...
Ist aber auch keine nützliche Funktion dabei herausgekommen...

[mgee]

Zitat:

Zitat von ichbins

Achtung, der Registry-Editor kann auf manchen Systemen vom Administrator gesperrt sein! Du darfst nicht darauf vertrauen dass die Shellexecute-Lösung klappt.

hm... ich hab vor ein paar Tagen schon mal dieselbe Frage zum Thema Importieren gemacht...
Ist aber auch keine nützliche Funktion dabei herausgekommen...

Jo genau mit hilfe der Forum-Such-Funktion bin ich dabei auf Luckie's Post aufmerksam geworden. Dabei hat er ja versucht erst die Privilegien zu setzen, und dann den Registry Schlüssel in eine Datei exportiert, nur leider waren die Daten so gut wie unbrauchbar :)

So hab das mit dem ShellExecute hinbekommen :) (ob der User Admin-Rechte hat oder nicht is mir momentan erstmal wurst :)
nochmals danke für die hilfe :)

[ichbins]

Aber wenn der Regedit auf einem System gesperrt ist, dann bringt dir das alles nichts. Dann kommt beim Aufruf einfach eine Fehlermeldung und das war's dann mit dem Programm. Wenn du deine Software weitergeben willst, sollte sie zu jedem Windows-System mindestens ab Win98 kompatibel sein. Eine Reg-Datei ist aber nicht besonders schwierig aufgebaut:

Code:

Windows Registry Editor Version 5.00

[HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\CD Burning]
"CD Recorder Drive"="\\\\?\\Volume{d2fcfcb5-1623-11da-aeec-806d6172696f}\\"
"DriveIndex"=dword:00000006
"Auto Eject"=dword:00000001
"Auto Close"=dword:00000000
"Stage Rate"=hex:d1,23,db,00,00,00,00,00
"Burn Rate"=hex:ae,3d,01,00,00,00,00,00
"Close Factor"=dword:00000320

[HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\CD Burning\Drives]

[HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\CD Burning\Drives\Volume{d2fcfcb5-1623-11da-aeec-806d6172696f}]
"Drive Type"=dword:00000001
"CurrentCDWriteSpeed"=dword:ffffffff
"MaxCDWriteSpeed"=dword:00000028

[HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\CD Burning\Drives\Volume{d2fcfcb6-1623-11da-aeec-806d6172696f}]
"Drive Type"=dword:00000001
"CurrentCDWriteSpeed"=dword:ffffffff
"MaxCDWriteSpeed"=dword:00000034

wenn du eine Stunde daran arbeitest oder so könntest du das auch selber hinbekommen, eine solche Datei zu erstellen.

[ichbins]

Schau mal wass ich gerade bei den Schweizern gefunden hab:

Delphi-Quellcode:

procedure ExportRegistryBranch(Rootsection: Integer; regroot: string;
  FileName: string);

implementation

function dblBackSlash(t: string): string;
var
  k: longint;
begin
  Result := t; {Strings are not allowed to have}
  for k := Length(t) downto 1 do {single backslashes}
    if Result[k] = '\' then Insert('\', Result, k);
end;


procedure ExportRegistryBranch(rootsection: Integer; Regroot: string;
  FileName: string);
var
  reg: TRegistry;
  f: Textfile;
  p: PChar;

  procedure ProcessBranch(root: string); {recursive sub-procedure}
  var
    values, keys: TStringList;
    i, j, k: longint;
    s, t: string; {longstrings are on the heap, not on the stack!}
  begin
    Writeln(f); {write blank line}
    case rootsection of
      HKEY_CLASSES_ROOT: s   := 'HKEY_CLASSES_ROOT';
      HKEY_CURRENT_USER: s   := 'HKEY_CURRENT_USER';
      HKEY_LOCAL_MACHINE: s  := 'HKEY_LOCAL_MACHINE';
      HKEY_USERS: s          := 'HKEY_USERS';
      HKEY_PERFORMANCE_DATA: s := 'HKEY_PERFORMANCE_DATA';
      HKEY_CURRENT_CONFIG: s := 'HKEY_CURRENT_CONFIG';
      HKEY_DYN_DATA: s       := 'HKEY_DYN_DATA';
    end;
    Writeln(f, '[' + s + '\' + root + ']'); {write section name in brackets}

    reg.OpenKey(root, False);
    try
      values := TStringList.Create;
      try
        keys := TStringList.Create;
        try
          reg.GetValuenames(values); {get all value names}
          reg.GetKeynames(keys); {get all sub-branches}

          for i := 0 to values.Count - 1 do {write all the values first}
          begin
            s := values[i];
            t := s; {s=value name}
            if s = '' then s := '@' {empty means "default value", write as @}
            else
              s := '"' + s + '"'; {else put in quotes}
            Write(f, dblbackslash(s) + '='); {write the name of the key to the file}

            case reg.Getdatatype(t) of {What type of data is it?}

              rdString, rdExpandString: {String-type}
                Writeln(f, '"' + dblbackslash(reg.ReadString(t) + '"'));

              rdInteger: {32-bit unsigned long integer}
                Writeln(f, 'dword:' + IntToHex(reg.readinteger(t), 8));

             {write an array of hex bytes if data is "binary." Perform a line feed
              after approx. 25 numbers so the line length stays within limits}

              rdBinary:
                begin
                  Write(f, 'hex:');
                  j := reg.GetDataSize(t); {determine size}
                  GetMem(p, j); {Allocate memory}
                  reg.ReadBinaryData(t, p^, J); {read in the data, treat as pchar}
                  for k := 0 to j - 1 do
                  begin
                    Write(f, IntToHex(Byte(p[k]), 2)); {Write byte as hex}
                    if k <> j - 1 then {not yet last byte?}
                    begin
                      Write(f, ','); {then write Comma}
                      if (k > 0) and ((k mod 25) = 0) {line too long?} then
                        Writeln(f, '\'); {then write Backslash +lf}
                    end; {if}
                  end; {for}
                  FreeMem(p, j); {free the memory}
                  Writeln(f); {Linefeed}
                end;
              else
                Writeln(f, '""'); {write an empty string if datatype illegal/unknown}
            end;{case}
          end; {for}
        finally
          reg.CloseKey;
        end;

      finally
        {value names all done, no longer needed}
        values.Free;
      end;

      {Now al values are written, we process all subkeys}
      {Perform this process RECURSIVELY...}
      for i := 0 to keys.Count - 1 do
        ProcessBranch(root + '\' + keys[i]);
    finally
      keys.Free; {this branch is ready}
    end;
  end; { ProcessBranch}


begin
  if RegRoot[Length(Regroot)] = '\' then {No trailing backslash}
    SetLength(regroot, Length(Regroot) - 1);
  Assignfile(f, FileName); {create a text file}
  Rewrite(f);
  if ioResult <> 0 then Exit;
  Writeln(f, 'REGEDIT4'); {"magic key" for regedit}

  reg := TRegistry.Create;
  try
    reg.Rootkey := Rootsection;
    {Call the function that writes the branch and all subbranches}
    ProcessBranch(Regroot);
  finally
    reg.Free; {ready}
    Close(f);
  end;
end;

Im Anhang hab ich den ganzen Befehl noch als Unit angehängt.

Eine API-Funktion dierekt gibt es glaub nicht, wenn ich in der MSDN [msdn]api *.reg export[/msdn] such find ich nix.

[Christian Seehase]

Moin ichbins,

Zitat:

Zitat von ichbins

Achtung, der Registry-Editor kann auf manchen Systemen vom Administrator gesperrt sein!

das verhindert aber nur die interaktive Nutzung.
In der Kommandozeile wird es nach wie vor funktionieren.