DLL entry function

[HERMES]

Hallo,

ich muss eine DLL schreiben, welche eine DLL entryfunction zur verfügung stellt. Das Problem ist nun, dass es so aussieht, als ob Delphi nur entryfunctionen mit der folgenden Signatur unterstützt:
function DllMain( dwReason :DWORD ):Boolean; Die Dll muss aber eine entryfunction des Types :
function DllMain( hModule :HINST; dwReason :DWORD; lpRes :LPVOID ):Boolean; zur Verfügung stellen.

Kennt jemand eine Möglichkeit dies zu realisieren??

danke im voraus
SImon

[SirThornberry]

was hindert dich daran einfach die funktion mit den parametern zu exporitieren?

[brechi]

function DllMain( hModule :HINST; dwReason :DWORD; lpRes :LPVOID ):Boolean; [b]stdcall;[/b] das geht - so viel ich weiß nicht - ABER du könntest ganz einfach eine funktion mit dem aufbau machen und den entrypoint abändern (z.b. mit lordPE von yoda) um an die adresse zu kommen von der funktion kannste diese dann einfach exportieren und schon zeigt dir lordPE die funktion an und du änderst den entrypoint

falls es ne andere möglichekit gibt - ich würd mich sehr freun wenn jemand diese postet, da mich das auch ab und zu ärgert

[NicoDE]

Zitat von HERMES:

Kennt jemand eine Möglichkeit dies zu realisieren?

Kurz: Nein, nicht ohne mehr Informationen.

Die eigentliche DllMain (in dem von dir gewünschten Format) befindet sich in der RTL von Delphi und kann nicht ohne weiteres überschrieben werden.
Wenn Du mehr Informationen zm Warum/Wieso/Weshalb geben kannst, dann gibt es vielleicht andere Wege dies zu lösen...

ps@brechi: keine gute Idee, da dann initialization/finalization-Abschnitte (und vieles andere mehr) nicht mehr funktionieren

edit: vielleicht ist das das gesuchte:

Delphi-Quellcode:

library Project1;

uses
  Windows;

{$R *.res}
  
////////////////////////////////////////////////////////////////////////////////
// DllMain

function DllMain(Inst: HINST; Reason: ULONG; Reserved: Pointer): BOOL; stdcall;
begin
  case Reason of
    DLL_PROCESS_ATTACH:
      DisableThreadLibraryCalls(Inst);
  end;
  Result := True;
end;

////////////////////////////////////////////////////////////////////////////////
// LibraryProc

{$IFNDEF CONDITIONALDEFINE} // Delphi 2-5
type
  TDLLProc = procedure(Reason: Integer);
{$ENDIF}

var
  DllProcNext: TDLLProc;  // = nil

procedure LibraryProc(Reason: Integer);
begin
  ExitCode := Integer(DllMain(HInstance, Reason, nil));
  if Assigned(DllProcNext) then
    DllProcNext(Reason);
end;

////////////////////////////////////////////////////////////////////////////////
// RTL Entry Point

begin
  DllProcNext := TDLLProc(DllProc);
  TDLLProc(DllProc) := LibraryProc;
  LibraryProc(DLL_PROCESS_ATTACH);
end.

[HERMES]

@nico:
ganz so wie du das in deinem beispiel code hast kann das nicht gehen, aber es wäre eine möglichkeit, werde das mal ausprobieren, wobei ich da nicht sehr zuversichtlich bin.

Das mit dem LordPE werde ich auch mal testen, warum nicht wenns funzt. Es ist egal, wenn der initialisazion block nicht funzt.

Zur Info, das ist eine Dll die einen Printermonitor im spooler installieren soll und diese Dlls benötigen eine entryfkt mit den 3 parametern. Ich denke, das es irgendwie möglich sein sollte eine andere art von entryfkt zu verwenden, da man mit delphi auch systemsteuerungsprogramme schreiben kann und das sind auch nur dlls, die auch eine besondere entry fkt haben.

danke
SIm

[brechi]

man kann ja als 1. wenn man den entrypoint abgeändert hat die originale funktion aufrufen

[Olli]

Zitat von HERMES:

Es ist egal, wenn der initialisazion block nicht funzt.

Dir vielleicht. Dem Programm (i.e. der DLL) vermutlich nicht. Dazu solltest du dir vor Augen führen, daß auch solche Units, die du "nicht siehst", nämlich System und Sysinit, unter Umständen initialization und finalization enthalten. Um die kommst du also nicht herum, selbst wenn du in deinen eigenen Units keine solchen Abschnitte benutzt!

@HERMES: Wenn es um diesen PrinterMonitor geht, dann sollte es egal sein. Die echte Entryfunktion hat immer diesen Prototypen, weil es sich um eine Konvention von Windows handelt. Wie bei main() (in C) ist auch das was du in Delphi als "DllMain" siehst nur eine Funktion, welche von der drunterliegenden RTL (wenn du den Source hast, kannst du ja mal reinschauen) - mit einem der Konvention folgenden Prototypen - aufgerufen wird.

Fazit: Nach außen ist die DLL mit einem Entrypoint ausgestattet, welcher die gleichen Merkmale aufweist wie jede andere DLL. Punkt! Das Modulhandle bekommst du, wie in Delphi üblich.

[NicoDE]

Zitat von HERMES:

ganz so wie du das in deinem beispiel code hast kann das nicht gehen

Hm, warum?
(bei den meisten CRTs ist die DllMain auch nicht der Einstiegspunkt - es ist in der Delphi-RTL nur anders gelöst worden)