DLL vor allem anderen aus Ressourcen laden?

[HaCkAttaCk2001]

Hi @ all.

Ich suche nun schon nach einer Weile für dieses Problem... und zwar:

Ich habe ein Programm geschrieben, welches unbedingt eine DLL benötigt. Ich möchte dem User aber das Programm als eine einzige Datei präsentieren. Also habe ich die DLL in eine .rc eingefügt und das ganze mit Delphi zu einer .res kompilieren lassen. Diese habe ich auch schon in das Programm eingefügt und ich weiß auch, wie ich die DLL wieder aus der Res-Datei herausbekomme.
Nun das Problem: Mein Programm startet, und meckert mich an, dass die DLL fehlt, weil sie noch nicht aus den Ressourcen extrahiert wurde. Wie kann ich das Lösen, dass die DLL vor allem anderen[b] extrahiert wird, damit mein Programm die DLL auch findet?

Kann ich die DLL-Prozeduren vielleicht sogar direkt aus den Ressourcen heraus aufrufen?


THX 4 Help.


C ya.

[Luckie]

Zu welchen Zeitpunkt extrahierst du denn die Ressource? In OnCreate der Form oder schon irgendwo im Hauptprogramm?

[shmia]

Zitat:

Zitat von HaCkAttaCk2001

Nun das Problem: Mein Programm startet, und meckert mich an, dass die DLL fehlt, weil sie noch nicht aus den Ressourcen extrahiert wurde. Wie kann ich das Lösen, dass die DLL vor allem anderen extrahiert wird, damit mein Programm die DLL auch findet?

Du darfst nicht statisch linken (function FunktionsName; external DLL_name name 'FunktionsName'; )
sondern musst dynamisch linken mit LoadLibrary, GetProcAdress und FreeLibrary.
LoadLibrary darfst du erst dann aufrufen, wenn die DLL auf dem Dateisystem liegt.

Zitat:

Zitat von HaCkAttaCk2001

Kann ich die DLL-Prozeduren vielleicht sogar direkt aus den Ressourcen heraus aufrufen?

Nein.
PS: HaCkAttaCk2001; soll das heisen du bist ein Hacker ?

[HaCkAttaCk2001]

Hi.

Zum 1. Post: Das Extrahieren der DLL aus den Ressourcen nehme ich im OnCreate vor... zu spät?

Zum 2. Post: Das mit dem dynamischen Einbinden hab ich auch schon gelesen, allerdings stellt sich mir da eine Frage: Wo soll ich die DLL dynamisch laden lassen?

Kleine Ergänzung noch zu meinem Post oben: Mein Hauptprogramm selbst braucht diese DLL nicht, aber eine Unit, die ich verwenden muss. Kann ich vielleicht die Unit erst später dazuladen lassen? Denn ich glaub das verheddert sich doch, wenn ich im Hauptprogramm die DLLs dynamisch lade, die die Unit schon viel früher braucht... oder hab ich da nen Denkfehler?


C ya.

[OT]
PS: Zum Nicknamen: Ich interessiere mich sehr für's Hacken. Aber in letzter Zeit nicht so sehr. Das heißt aber nicht, dass ich deswegen gleich meinen Nicknamen aufgebe, den ich mir vor Jahren mühevoll ausgedacht habe ^^ .
[/OT]

[shmia]

Zitat:

Zitat von HaCkAttaCk2001

Kleine Ergänzung noch zu meinem Post oben: Mein Hauptprogramm selbst braucht diese DLL nicht, aber eine Unit, die ich verwenden muss. Kann ich vielleicht die Unit erst später dazuladen lassen? Denn ich glaub das verheddert sich doch, wenn ich im Hauptprogramm die DLLs dynamisch lade, die die Unit schon viel früher braucht... oder hab ich da nen Denkfehler?

Die DLL muss mit LoadLibrary in dieser Unit dynamisch geladen und freigegeben werden.
Wenn du von dieser Unit keinen Sourcecode hast, dann hast du die A-Karte gezogen. :wall:
Ansonsten einfach in die Unit mal nach dem Wort External suchen.

Delphi-Quellcode:

// Hier ein Beispiel (von Marcel van Brakel), wie man dynamisch oder statisch linken kann
procedure GetProcedureAddress(var P: Pointer; const ModuleName, ProcName: string);
var
  ModuleHandle: HMODULE;
begin
  if not Assigned(P) then
  begin
    ModuleHandle := GetModuleHandle(PChar(ModuleName));
    if ModuleHandle = 0 then
    begin
      ModuleHandle := LoadLibrary(PChar(ModuleName));
      if ModuleHandle = 0 then raise Ewin32Error.Create('Library not found: ' + ModuleName);
    end;
    P := GetProcAddress(ModuleHandle, PChar(ProcName));
    if not Assigned(P) then raise EWin32Error.Create('Function not found: ' + ModuleName + '.' + ProcName);
  end;
end;

{$IFDEF DYNAMIC_LINK}
var
  _FindWindowEx: Pointer;

function FindWindowEx;
begin
  GetProcedureAddress(_FindWindowEx, user32, 'FindWindowExW');
  asm
    mov esp, ebp
    pop ebp
    jmp [_FindWindowEx]
  end;
end;
{$ELSE}
function FindWindowEx; external user32 name 'FindWindowExW';
{$ENDIF DYNAMIC_LINK}

[HaCkAttaCk2001]

Hi.

Du liebes Lieschen...

Also nochmal zum mitmeißeln (den Sourcecode der Unit hab ich): Statt (z.b.):

Delphi-Quellcode:

function AInitialize: Integer; stdcall; external 'AUDIOW32.DLL';  //die DLL wird im OnCreate aus der Ressource exportiert

schreib ich jetzt:

einmal:

Delphi-Quellcode:

procedure GetProcedureAddress(var P: Pointer; const ModuleName, ProcName: string);
var
  ModuleHandle: HMODULE;
begin
  if not Assigned(P) then
  begin
    ModuleHandle := GetModuleHandle(PChar(ModuleName));
    if ModuleHandle = 0 then
    begin
      ModuleHandle := LoadLibrary(PChar(ModuleName));
      if ModuleHandle = 0 then raise Ewin32Error.Create('Library not found: ' + ModuleName);
    end;
    P := GetProcAddress(ModuleHandle, PChar(ProcName));
    if not Assigned(P) then raise EWin32Error.Create('Function not found: ' + ModuleName + '.' + ProcName);
  end;
end;

und dann für jede Prozedur einzeln (jetzt auf's Bsp. angewandt):

{$IFDEF DYNAMIC_LINK}
var
_AInitialise: Pointer;

function FindWindowEx;
begin
GetProcedureAddress(_AInitialise, AUDIOW32.DLL, 'AInitialize');
asm
mov esp, ebp
pop ebp
jmp [_AInitialise]
end;
end;
{$ELSE}
function AInitialize: Integer; stdcall; external 'AUDIOW32.DLL' name 'AInitialise';
{$ENDIF DYNAMIC_LINK}

Muss ich noch irgendwas im Hauptprogramm dann ändern?

Was ich nicht verstehe: die Unit wird vor dem OnCreate geladen... soll heißen, wenn die Unit die DLL sucht, ist sie ja noch gar nicht da?! Oder sag ich der Unit mit dem Code: "Warte, bis die DLL extrahiert ist, dann darfst du loslegen."?

Edit: Ich hab mir jetzt mal den Source von dir nochmal genau angesehen... und muss leider sagen das ich überhaupt keinen Plan hab, wann das wo wie hinkommen soll :pale: .

C ya.

[SirThornberry]

schau dir einfach mal an wie dll's dynamich eingebunden werden. Danach dürfte sich die Frage erledigt haben.
Tutorial: http://www.delphi-source.de/tutorials/dlls/

[HaCkAttaCk2001]

Zitat:

Zitat von SirThornberry

schau dir einfach mal an wie dll's dynamich eingebunden werden. Danach dürfte sich die Frage erledigt haben.
Tutorial: http://www.delphi-source.de/tutorials/dlls/

Hi.

Ich habe mir das mal durchgelesen... sieht ganz einleuchtend aus, aber eine Frage habe ich noch:

Wie ich eine Funktion dynamisch einbinde, weiß ich nun durch das Tutorial. Wie verhält es sich aber, wenn ich, wie in dem Fall den ich hier zu bearbeiten habe, ca. 50 Prozeduren so umschreiben muss? Muss ich da für alles ein Type etc. anlegen? Das kann ja Jahre dauern :cry: .


C ya.

[NicoDE]

Zitat:

Zitat von HaCkAttaCk2001

Das kann ja Jahre dauern :cry:

Wenn Du mit regulären Ausdrücken vertraut bist, dann nimmt Dir Search 'n Replace die Hälfte der Arbeit ab...
(dauert mit Sicherheit weniger als ein Jahr :))

[HaCkAttaCk2001]

Zitat:

Zitat von NicoDE

Zitat:

Zitat von HaCkAttaCk2001

Das kann ja Jahre dauern :cry:

Wenn Du mit regulären Ausdrücken vertraut bist, dann nimmt Dir Search 'n Replace die Hälfte der Arbeit ab...
(dauert mit Sicherheit weniger als ein Jahr :))

Das soll also heißen, dass ich für jede Prozedur ein type und den Rest anlegen muss? *seufz*

Na gut, trotzdem danke für die kompetente Hilfe @ all!


Ich melde mich in einem Jahr wieder *g*.

Edit: Habe gerade 1 1/2 Stunden benötigt, eine function in den dynamischen Code zu portieren... *uff*. Aber langsam kapier ich's :D .

C ya!

[HaCkAttaCk2001]

Hi.

Ich hab noch ne Frage!

Muss ich das type jedes mal wieder angeben?

Beispiel:

Delphi-Quellcode:

type
  TACloseAudio = function: Integer; stdcall;
  function ACloseAudio: Integer;
  //hier
  TAOpenAudio = function(var pInfo: TAudioInfo): Integer; stdcall;
  function AOpenAudio(var pInfo: TAudioInfo): Integer;

Wenn ich das so mach, wie es Delphi doch selbst eigentlich auch macht, dann bekomm ich den Fehler: "Unbekannte Anweisung: TAOpenAudio". Schreibe ich aber dort wo ich das "//hier" geschrieben habe, ein "type" hinein, erzeugt das Programm beim Beenden eine Schutzverletzung.
Diese Schutzverletzung sehe ich aber nur in Delphi! Wenn ich das Projekt erzeuge und dann die .exe ausführe, kommt die Schutzverletzung nicht!

Was muss ich machen?! Die Verletzung ignorieren?

C ya!

[NicoDE]

Zitat:

Zitat von HaCkAttaCk2001

Das soll also heißen, dass ich für jede Prozedur ein type und den Rest anlegen muss? *seufz*

Eben das kannst Du vermeiden (zumindest die stupide Handarbeit)

Nehmen wir an es gibt folgende Deklarationen:

Delphi-Quellcode:

function foo: Integer; stdcall; external 'foo.dll' name 'foo';
function bar(const i: Integer): Integer; stdcall; external 'bar.dll' name 'bar';

...dann kannst Du:
- Die Zeilen markieren
- Im Menü 'Search / Replace... (Strg+R)' auswählen
- Option 'Regular Expressions' aktivieren
- 'Text to find:'

Code:

^ *function *{[a-z_A-Z0-9]*}{.*}; external *{[a-z_A-Z0-9.']*} *name *{[a-z_A-Z0-9.']*};$

- 'Replace with:'

Code:

{$IFDEF DYNAMIC_LINK}[color=red]\r// foo\r[/color]{$ELSE}\rfunction \0\1; external \2 name \3;\r{$ENDIF DYNAMIC_LINK}

...und dann wird bei 'Replace All' daraus

Delphi-Quellcode:

{$IFDEF DYNAMIC_LINK}
// foo
{$ELSE}
function foo: Integer; stdcall; external 'foo.dll' name 'foo';
{$ENDIF DYNAMIC_LINK}
{$IFDEF DYNAMIC_LINK}
// foo
{$ELSE}
function bar(const i: Integer): Integer; stdcall; external 'bar.dll' name 'bar';
{$ENDIF DYNAMIC_LINK}

\r// foo\r kannst Du durch Deinen Wrapper ersetzen, wobei:
- \r ist ein Zeilenumbruch
- \0 ist der Name der Funktion
- \1 sind die Parameter der Funktion
- \2 ist der Name der Dll
- \3 ist der Export-Name


Gruss Nico

[SirThornberry]

Zitat:

... Wie verhält es sich aber, wenn ich, wie in dem Fall den ich hier zu bearbeiten habe, ca. 50 Prozeduren so umschreiben muss? Muss ich da für alles ein Type etc. anlegen? ...

Du hast doch bestimmt nicht 50 Proceduren mit unterschiedlichem Funktionkopf.
angenommen du hast die funktionen

Delphi-Quellcode:

function GetIrgendwas1(Labelcaption: String): Integer;
function GetIrgendwas2(Editcaption: String): Integer;

so sind diese ja vom gleichen typ und du musst nicht für beide einen extra typ anlegen

Delphi-Quellcode:

type
  TGetIntegerBySetString = function(StringtoGive: String): Integer;

Es gäbe auch noch die Variante das du eine Extra Exe-Datei anlegst und darein per Ressource die eigentliche Exe sowie die Dll einbindest. Beim start der neuen Exe extrahierst du dann einfach die exe und die dll und somit hat sich dein problem mit dem dynamichen einbinden erledigt.

[HaCkAttaCk2001]

Hi.

Also die Übergaben sind recht verschieden... aber du hast recht, so könnte ich ein wenig Schreibarbeit sparen.

Das mit dem Ersetzen sieht jetzt erstmal kompliziert für mich aus, vor allem, weil ich noch nie mit solchen Ausdrücken gearbeitet habe. Aber ich werd's auf jeden Fall mal versuchen!

Da gibts jetzt noch die eine Frage, die schon weiter oben steht. Muss ich nun immer wieder "type" schreiben oder reicht einmal "type" und dann die ganzen Definitionen? Siehe oben. Das mit der Schutzverletzung irritiert mich halt ein wenig.


C ya.

[franksch88]

Du solltest mal versuchen alle types zusammen machen, und dann alle functions zusammen.

Anstatt

Code:

type
  TACloseAudio = function: Integer; stdcall;
  function ACloseAudio: Integer;

type
  TAOpenAudio = function(var pInfo: TAudioInfo): Integer; stdcall;
  function AOpenAudio(var pInfo: TAudioInfo): Integer;

versuchs lieber so:

Code:

type
  TACloseAudio = function: Integer; stdcall;
  TAOpenAudio = function(var pInfo: TAudioInfo): Integer; stdcall;
  TAOthertype = function:String; stdcall;

function ACloseAudio: Integer;
function AOpenAudio(var pInfo: TAudioInfo): Integer;
function AOtherFunction: String;

Ist nicht nur mit types so, sondern auch mit uses, var, und const. Du hattest vorher nähmlich ein Type deklariert, danach eine funktion deklariert, aber die nächste Anweisung hat Delphi nicht erkannt (weil das letzte deklarierte eine "function" war, und das muss man für jede deklaration extra dazuschreiben). Wenn du aber alle Types nacheinander deklarierst, bruachst du (genau so wie bei var und const) nur einmal das wort Type hinzuschreiben, und nur Types dazwischenlegen.

[HaCkAttaCk2001]

Hi.

Die Frage hat sich erledigt... es darf nicht so aussehen:

Delphi-Quellcode:

type
  TACloseAudio = function: Integer; stdcall;
  function ACloseAudio: Integer;

  TAOpenAudio = function(var pInfo: TAudioInfo): Integer; stdcall;
  function AOpenAudio(var pInfo: TAudioInfo): Integer;

Sondern es muss so sein:

Delphi-Quellcode:

type
  TACloseAudio = function: Integer; stdcall;
  TAOpenAudio = function(var pInfo: TAudioInfo): Integer; stdcall;
  
  function AOpenAudio(var pInfo: TAudioInfo): Integer;
  function ACloseAudio: Integer;

[franksch88]

sagte ich doch.... ;)

[NicoDE]

Zitat:

Zitat von HaCkAttaCk2001

Das mit dem Ersetzen sieht jetzt erstmal kompliziert für mich aus, vor allem, weil ich noch nie mit solchen Ausdrücken gearbeitet habe. Aber ich werd's auf jeden Fall mal versuchen!

Sieht nur auf den ersten Blick kompliziert aus, da der Ausdruck ziemlich lang geworden ist. Wenn man damit etwas gearbeitet hat, möchte man es nicht mehr missen und kommt schnell auch ohne Blick in die Delphi-Hilfe aus...

...wie oben schon erwähnt wurde, wird es wohl am schnellsten gehen, die EXE und die DLL aus einem Stub zu entpacken...
...oder fertige Lösungen wie PEBundle ( http://www.collakesoftware.com ) zu verwenden...