Datei an eine Exe anhängen

[Rafet El Roman]

Hallo zusammen,

ich möchte ein Programm schreiben mit welchem ich eine Datei ausliefern kann. Es soll nur eine Datei existieren (die Exe) die andere sollte dabei sein. Beim ausführen sollte es die angehängte Datei in ein bestimmtes Verzeichnis kopieren. Eine Art Selfextractor. Ich habe kein Anhaltspunkt wie ich das realisieren könnte.

Für Jede Hilfe bin ich sehr dankbar.

Gruss

[Andreas Horlaender]

Hi,<br>
Schreib ein Programm und stelle fest wie groß es ist auf's Byte genau. In deinem Progamm gibt es eine Funktion die dein Programm öffnet und die Daten beginnend von deiner Programmgröße an liest und z.B. nach Temp schreibt. Kopiere nun die Extract Daten an dein Programm und fertig.<br>
Ein paar Tips<br>
<pre>
Dateiaufbau
--- DeineExe
--- DeinAnhängsel :-)

Was du dafür benötigst: einen FileStream
Wie bekomme ich die Daten an mein Programm?
Entweder im Programm selbst oder mit Copy /b +
</pre&gt

[Hagen Reddmann]

ich würde in dieser einfachen Form noch die orginale EXE Größe als 4 Byte Wert am Ende dranhängen. Also
<li>EXE
<li>Daten
<li>4 Bytes = Integer von EXE

Gruß Hage

[Hagen Reddmann]

<pre>

<code><font size=2 face="Courier New"><b>procedure </b>AddDaten(<b>const </b>EXEFileName, DatenFilename: <b>String</b>);
<b>var
</b>F,S: TStream;
EXESize: Integer;
<b>begin
</b><font color="#008080"><i>// EXE zum schreiben öffnen
</i></font>F := TFileStream.Create(EXEFileName, fmOpenWrite);
<b>try
</b><font color="#008080"><i>// datenfile readonly öffnen
</i></font>S := TFileStream.Create(DataFileName, fmOpenRead <b>or </b>fmShareDenyNone);
<b>try
</b><font color="#008080"><i>// EXESize lesen
</i></font>EXESize := F.Size;
<font color="#008080"><i>// ans Ende der EXE positionieren
</i></font>F.Position := EXESize;
<font color="#008080"><i>// Daten an EXE File ranhängen
</i></font>F.CopyFrom(S, S.Size);
<font color="#008080"><i>// zum schluß noch die originale EXE Größe in EXE speichern
</i></font>F.Write(EXESize, SizeOf(EXESize));
<b>finally
</b>S.Free;
<b>end</b>;
<b>finally
</b>F.Free;
<b>end</b>;
<b>end</b>;
<br>
<b>procedure </b>ExtractDaten(<b>const </b>DatenFileName: <b>String</b>);
<b>var
</b>F,S: TStream;
EXESize: Integer;
<b>begin
</b><font color="#008080"><i>// aktuelle EXE öffenen, readonly
</i></font>F := TFileStream.Create(ParamStr(<font color="#0000FF">0</font>), fmOpenRead <b>or </b>fmShareDenyNone);
<b>try
</b><font color="#008080"><i>// Daten File erstellen
</i></font>S := TFileStream.Create(DataFileName, fmCreate);
<b>try
</b><font color="#008080"><i>// zu erst org. EXE Größe am ende auslesen
</i></font>F.Postion := F.Size - SizeOf(EXESize);
F.Read(EXESize, SizeOf(EXESize));
<font color="#008080"><i>// nun an diese Position springen
</i></font>F.Position := EXESize;
<font color="#008080"><i>// und den Rest als daten file speichern
</i></font>S.CopyFrom(F, F.Size - SizeOf(EXESize) - EXESize);
<b>finally
</b>S.Free;
<b>end</b>;
<b>finally
</b>F.Free;
<b>end</b>;
<b>end</b>;
<br>
<br>
Gruß Hagen
</font>
</code></pre&gt

[Mathias Simmack]

Ich würd´s als Ressource in die EXE einbinden. Dann ist´s egal, wie groß der Starter ist. Ich will nichts falsches sagen, aber ich glaube, Jens Schuhmann (?) hat so ein Beispiel schon mal gepostet. Ansonsten -

1. Die RC-Datei zum Einlinken in das Projekt:

<PRE>
FILEXY RC_DATA "MeineDatei"
</PRE>

2. Der entsprechende Delphi-Code:

<PRE>
procedure ExpandInternalResource;
var
iStream : TResourceStream;
begin
iStream := TResourceStream.Create(hInstance,'FILEXY','RC_DATA ');
iStream.SaveToFile('C:\Windows\System\Dateiname');
iStream.free;
end;
</PRE>

Aus der RC-Datei wird eine RES-Datei gemacht (mit dem Ressourcencompiler von Borland). Diese RES wird im Delphi-Projekt angegeben und kompiliert.
Fertig! )

Mathias.

PS: Auch wenn´s vielleicht uninteressant ist, aber ich würde noch prüfen, unter welchem System das Programm läuft. Bei NT/2000/XP sind ja möglicherweise Rechte erforderlich, um z.B. eine Datei im Systemverzeichnis ablegen zu dürfen. Auch wenn der Standardbenutzer bei XP grundsätzlich ein Admin ist, sollte man nicht davon ausgehen, dass das überall so ist. Ich hab´s z.B. geändert, weil´s mir zu unsicher war

[Hagen Reddmann]

Jo, generell ist der Weg über Resources besser, das habe ich schon immer empfohlen. Was aber wenn die Größe der Daten zur Laufzeit nicht bekannt sein kann. In einem solchen Falle gäbe es den fertigen EXE-Stub und den "EXE-Compilierer". Die Manipulation der Resources von Aussen ist zwar möglich, im gegensatz zum obigen einfachsten Ansatz dauert aber die Einarbeitung ins PE Dateiformat mindestens 1 Woche.
Das einfache Anhängen hat noch einen anderen Vorteil. Auf Grund der der originalen EXE-Stub Informationen existieren die angehängten Daten für Windows überhaupt nicht. Sie werden also NICHT im Memory Mapped File der EXE mit eingebunden !!

Gruß Hage

[Mathias Simmack]

Wenn die Größe der Daten zur Laufzeit nicht bekannt ist, dann kann es meines Erachtens nach kein Programm oder keine Datei sein, die man kopieren möchte. Ich will damit sagen: ich schreibe ein Programm und entwickle es meinetwegen noch weiter. Wenn es dann fertig ist, und ich es ausliefern möchte (so wie Rafet das ja am Anfang sagt), dann werde ich die Datei nicht mehr ändern. Und selbst wenn - ich kann das Setup (also die Exe, die ich weitergeben will) ja einfach neu kompilieren und - schwupp - ist die neue Version meiner Datei drin. In dem Fall kann man also unbesorgt den Weg über die Ressourcen gehen, finde ich.

Daten anhängen würde ich nur bei Infos, die z.B. zur Laufzeit des Programms wichtig sind und sich evtl. ändern können. Was weiß ich, als 30-Tage-Begrenzung für Shareware oder so. Man sollte aber auch bedenken, dass viele Virenscanner Alarm schlagen, wenn sich die Prüfsumme eines Programms ständig ändert.

Mathias

[Hagen Reddmann]

Ich meinte es anders. Angenommen bei einem größeren Projekt bauen andere Mitarbeiter auf anderen Rechnern mal schnell ein solches "setup" zusammen. Diese hätten dann kein Delphi etc. und würden dann eine kleines Kommandotool nutzen das dann den vorbereiteten EXE-Stub mit den gewünschten Daten verknüpft. Der EXE-Stub könnte ja dann als Resource in diesem Commandline Tool integriert sein.

Gruß Hage

[Rafet El Roman]

Danke,

Hagen, Dein Vorschlag hat mir sehr viel weitergeholfen. Es funktioniert mit einer Datei prima!. Wo muss ich ansetzten wenn ich mehrere Dateien mitschicken möchten. Ich dachte ich gib eine Datei mit in welchem Dateiname und Groesse enthalten ist, welches bei ausführen ausgewertet wird (Zu Kopierende Zielverzeichnis usw.).

Gruss
Rafe

[Hagen Reddmann]

Also ich würde diese Infos mit hintendran hängen, sozusagen einen Header am Schluß der Daten, dieser sollte dann z.B. Zieldateiname, Dateigröße und Position im EXEFile enthalten und eventl. noch eine Prüfsumme. Dann kannste aber auch gleich mit der Delphi ZLib Unit diese Daten auch noch komprimieren. Wobei sich dann die Frage stellt ob es dann nich sinnvoller wäre z.B. WISE Install o.ä. Tools zu benutzen die natürlich auch selbstextrahierende Archive ermöglichen.
Für mich wäre bei einer Datei Schluß, alles was drüber geht würde ich mir den Aufwand nicht antun sondern solche Tools benutzen.

Gruß Hage

[Mathias Simmack]

Stimmt, Hagen, da hast du wohl recht. Ich gehe halt zu sehr von mir aus. Ich mache solche Sachen allein. )<br><br>
Aber ich denke, ab einer bestimmten Größe sollte man vielleicht sowieso die zu kopierende Datei anhängen. Ich denke, es macht einen Unterschied, ob ein 40k-Setup so startet, oder ob es versucht, noch einen 100meg-Ressourcenanhang mit zu laden.<br><br>
Und wenn´s wirklich aufwändig wird, dann empfehle ich auch ein richtiges Setup. Zumal das auch "schicker" aussieht und der Anwender auch weiß, was eigentlich gerade passiert.<br><br>
Mathias