Dll: Funktionen erkennen

[Desmulator]

Hallo Leute,

also ich habe das Problem, dass, falls man dlls benutzen will, deren funktionen schon alle kennen muss, damit man sie entwerder dynamisch laden kann oder schon direkt am anfang. Ich will aber sowas sie Module machen, sodass man einfach die dll datei in das verzeichniss legt, sie geladen wird und wenn ein TcpClient ein commando sendet, soll gegukt werden, ob diese funktion in einer Dll zur verfügung steht. Dann sollen eventuelle parameter erkannt werden, damit ich diese vom Client anfordern kann...

Beispiel ( <- Server zu Client, -> Client zu Server ):

<- Ready
-> [Command]

Jetzt wird gegukt ob [Command] zurverfügung steht, wenn nicht

<- Undefined

ansonsten, falls Parameter gebraucht werdern

<- Param
-> [Param1]
-> [Param2]
-> ParamEnd

Jetzt wird die Funktion [Command] mit den Parametern [Param1] und [Param2] aufgerufen.

Ich hoffe ihr habt das jetzt verstanden^^

Naja ich suche in der Zeit auch mal weiter nach möglichkeiten...

cia

[sirius]

Ich habe noch nicht genau verstanden, was du willst.
Es ist richtig, dass du bei einer Win32-DLLs maximal die Funktionsnamen und deren Einsprungadresse bekommst. (ist übrigens bei .Net anders/besser)
Das kannst du natürlich auch bei Win32DLLs ändern indem du eine standard-Funktion implementierst, welche RTTI-mäßig dier den Ihalt der DLL erzählt.
Der zweite Teil deines Beitrags klingt, als willst du in der DLL einen TCP-Server initialisieren, der jedem Client erzählt, welche Funktionen in der DLL sind. Das auch ein schönes Konzept.

Ähm :gruebel: und wo war jetzt die Frage?

[Desmulator]

Ist eigendlich ganz einfach.

der Client sendet dem Server ein Command, dieser gukt, ob es in einer der zur verfügung stehenden dlls gibt. dann führt er es aus und gibt das ergbeniss zurück.

wir kann ich jedoch eine dll so auslesen, dass ich alle funktionen + parameter erhalte...

atm bin ich drauf und dran es über die RTTI methode zu machen, oder ein documentations file zumachen, der eingelesen wird

[Garfield]

Mit LoadLibrary kann man eine DLL laden und über GetProcAddress den Einsprungpunkt suchen. Die erforderlichen Parameter musst Du allerdings wissen und vorher unter Type deklarieren. Ergibt Assigned dann NIL, existiert Deine Funktion nicht.

Delphi-Quellcode:

Const
  szNameDLL = 'MediaInfo.DLL';

  szNameMediaInfo_Open = 'MediaInfo_Open';
  ...

Type
  TFNMediaInfo_Open = function(File__: PAnsiChar): Cardinal cdecl  {$IFDEF WIN32} stdcall {$ENDIF};
  ...

var
  lib: THandle;
  MediaInfo_Open: TFNMediaInfo_Open;
  ...

Function GetEntryPoints: Boolean;

implementation

Function GetEntryPoints: boolean;
begin
  @MediaInfo_Open := NIL;
  ...

  lib := LoadLibrary(@szNameDLL[1]);
  if lib = 0 
  then GetEntryPoints := False
  else begin
    GetEntryPoints := True;
    @MediaInfo_Open := GetProcAddress(lib, @szNameMediaInfo_Open[1]);
    if not Assigned(MediaInfo_Open) then GetEntryPoints := False;

    ...
  end;
end;

[Desmulator]

ja wie man läd weiß ich ja, und auch benutzt habe ich dlls schon, jedoch will ich ja auch das jeder andere einfach ein modul für das prog schreiben kann und ohne das ich davon was wissen muss...

[Luckie]

Schreib dir eine Funktion in der DLL, die dir eine Liste verfügbaren Funktionen der DLL zurückgibt.

[Garfield]

Dann musst Du Deine Funktionsaufrufe definieren und die anderen ihre Funktionen entsprechend programmieren.

[Desmulator]

daran habe ich schon gedacht... dann müsste allerdings jedes modul diese funktion beinhalten, aber das is immernoch besser als ne ini-datei für jede dll

[Garfield]

Nicht unbedingt. Du müsstest definieren, welche Funktionen enthalten sein müssen und welche enthalten sein dürfen. Dann musst Du prüfen, welche Funktion tatsächlich enthalten sind und entsprechend reagieren.

[Desmulator]

es läuft alle gut, doch atm steh ich auf dem schlauch, ich brauche ein array das so aufgebaut ist

[Funktionsname] -> [DllPath]
[Funktionsname2] -> [DllPath]
[...] -> [...]

also ein array in dem steht , in welcher dll welche funktion ist, wie bekomm ich das hin,ich wette die lösung ist einfach und lag die ganze zeit vor meiner nase :?

[Die Muhkuh]

Hi,

würde ich z.B. so machen:

Delphi-Quellcode:

type
  rFuncTable = record
    FunctionName: String;
    DLLName: String;
  end;

const
  FunctionTable: array[0..1] of rFuncTable = (
  (FunctionName: 'Funktionsname'; DLLName: 'Name / Pfad zur DLL'),
  (FunctionName: 'Funktionsname2'; DLLName: 'Name / Pfad zur DLL'));

// Zugriff:
FunctionTable[0].FunctionName // --> Für den Funktionsnamen
FunctionTable[0].DLLName      // --> Für den Namen bzw. den Pfad zur DLL

[sirius]

Zitat:

Zitat von Desmulator

daran habe ich schon gedacht... dann müsste allerdings jedes modul diese funktion beinhalten, aber das is immernoch besser als ne ini-datei für jede dll

Das ist imho genau die Methode die .Net nutzt :zwinker: (und COM irgendwie auch)

[Desmulator]

@Die Muhkuh:
hm... das problem ist, dass die liste nicht immer gleich ist sondern sich verändert, also wie kann ich da einen neuen eintrag einfügen? auserdem habe ich nur den namen, nicht die nummer der funktion in dem record...

der aufruf soll so sein:

Delphi-Quellcode:

DllPath := Liste[Name];

wenns net geht, dann muss ich alles nochmal überdenken

@sirius: die mit der ini oder der funktion die die documentation ausgibt?

[sirius]

Die Funktion innerhalb der DLL

[Desmulator]

ja das habe ich auch vor... nur wie mache ich das jetzt mit dem array?

[Die Muhkuh]

Alternativ könntest auch eine StringList verweden:

Delphi-Quellcode:

StringList.Value['Funktionsname'] := 'DLLName';

Aufruf:

DLLName := StringList.Value['Funktionsname'];

[Desmulator]

Argh, ja danke, ich wusste dass das i-wie gehts xD thx an alle

[Desmulator]

Argh Leute ich pack das net...

also meine dll sieht bis jetzt so aus:

Delphi-Quellcode:

library DateAndTime;

uses
  SysUtils,
  Classes;

type
  DllArrayOfString = array of string;

function YourTime: string; stdcall;
begin
  result := TimeToStr(Now);
end;

function dllinfo: DllArrayOfString; stdcall;
var
  List: DllArrayOfString;
begin
  //Rückgabe des Arrays
  List[0] := 'YourTime';


  //Rückgabe
  result := List;
end;

exports
  dllinfo,YourTime;

{$R *.res}

begin
end.

und die Procedure die die Dll laden soll so:

Delphi-Quellcode:

type
  //Tüpen
  DllFunktionParamList = array of string;
  DllFunktionResult = string;
  DllFunktionList = TStringList;

  //FunktionsTyp
  DllFunktion = function(Param:DllFunktionParamList):DllFunktionResult;
  DllListFunktion = function(): DllFunktionParamList;

procedure LoadDll(DllPath: string);
var
  DllHandle: THandle;
  ListFunktion: DllListFunktion;
  List: DllFunktionParamList;
  I : integer;
begin
  try
    //Dll laden
    DllHandle := LoadLibrary(PChar(DllPath));

    if DllHandle <> 0 then begin

      //Listenfunktion einlesen
      ListFunktion := GetProcAddress(DllHandle,PChar('dllinfo'));

      if ListFunktion <> nil then begin


        //Liste laden
        List := ListFunktion();

        //Schleife, um alle Funktionen zu speichern
        for I := 0 to High(List) do begin
          //Wert speichern
          DllList.Values[List[I]] := DllPath;

        end;
      end;
    end;
  except
    //Fehler
    ShowMsg('Konnte die Dll "' + DllPath + '" nicht finden/laden',Error);
  end;
end;

Ich erhalte beim afruf List := ListFunktion(); einen Fehler, bzw. machnmal kommt er garnicht über das if ListFunktion <> nil then ...


wo ist mein fehler?

[Die Muhkuh]

Dein Fehler ist, dass Du Strings benutzt! Pfui! Nimm PChars! Oder lies mal ganz genau den Hinweis durch, der im Projekt steht, wenn man eine neue DLL machen möchte.

[Desmulator]

hm... okay ich habe ShareMem jetzt eingebunden, jedoche rhalte ich immernoch den fehler... und zwar genau da: List := ListFunktion();