Announcement

**Robert Marquardt** · 22.07.2002, 13:20

Oft enthalten die Callbackfunktionen einen frei verwendbaren Parameter. Dort kann man das Objekt uebergeben. Da das Objekt nur ein Pointer ist, reicht Pointer(Self) fuer die Zuweisung. Ist der freie Parameter ein DWORD, dann DWORD(Self)

**Daniel Fiederling** · 22.07.2002, 13:52

Da seh ich leider keine Chance, die Callbackfunktionen sind folgenderma�en def.: 
 
type 
TDllPrnt = function(Buffer: PChar; Size: ULONG): integer; stdcall; 
TDllPassword = function(P: PChar; N: Integer; M, Name: PChar): integer; stdcall; 
TDllService = function (CurFile: PChar; Size: ULONG): integer; stdcall; 
TDllSnd = procedure; stdcall; 
TDllReplace = function(FileName: PChar): integer; stdcall; 
TDllMessage = procedure (UnCompSize : ULONG; CompSize : ULONG Factor : UINT Month : UINT; Day : UINT; Year : UINT; Hour : UINT; Minute : UINT; C : Char FileName : PChar; MethBuf : PChar; CRC : ULONG; Crypt : Char); stdcall; 
 
�bergeben wird das ganze an die DLL als Record: 

type 
PUserFunctions = ^TUserFunctions; 
USERFUNCTIONS = record 
Print : TDllPrnt; 
Sound : TDllSnd; 
Replace : TDllReplace; 
Password : TDllPassword; 
SendApplicationMessage : TDllMessage; 
ServCallBk : TDllService; 
TotalSizeComp : ULONG; 
TotalSize : ULONG; 
CompFactor : Integer; 
NumMembers : UINT; 
cchComment : UINT; 
end; 
TUserFunctions = USERFUNCTIONS; 
 
Die letzten 5 Variablen werden lt. Doku nur von der DLL gef�llt. 
Schade ;-(, aber trotzdem danke! 
 
Ciao 
Daniel 
&#10

**Hagen Reddmann** · 22.07.2002, 14:42

Es gibt dann zwei M�glichkeiten:
<li>1. eine globale Variable die auf das Object zeigt
<li>2. die Callback-funktionen zeigen auf einen Callback-Handler der den zus�tzlichen Self zeiger enth�lt und damit eine methode des Objectes aufruft. 

Im ersten Fall ist wohl klar das nur EIN Object zu selben Zeit benutzt werden kann, da ja nur eine globale Variable existiert. Das s�he so aus: 

<pre>

var
MyObj: TMyObj = nil; 

function DllPrintCallback(..)..;
begin
MyObj.DllPrintCallback(...);
end;

</pre>

Die zweite Variante kann dagegen mehrere Objecte nutzen da nun die Callbackfunction eine Dispatcher-Callback ist, das s�he im Prinzip so aus: 

<pre>
type
TMyObject = class
function DllPrintCallback(); stdcall;
end;

function ObjDllPrintCallback();
asm
modifiziere Stackparameter und f�ge Self hinzu
springe zu TMyObj.DLLHandler
end;

</pre>

Dieser Fall ben�tigt die dynamische Erzeugung dieser Dispatcher-Callbacks. D.h. f�r jede Objectinstance m�ssen eigene Dispatcher erzeugt werden. Dazu bieten sich Klassen methoden an. 

Ein cleverer Programmier definiert seine Callbacks IMMER nach folgendem Schema:

<pre>

type
TMyCallback = function(UserParam: Pointer; Data1, Data2: TData): Result; stdcall; 

procedure DoCallback(Proc: TMyCallback; UserParam: Pointer); 

</pre>

In diesem Moment wird immer ein UserParam �bergeben und dieser ist in der Callback immer der ERSTE Parameter. Damit k�nnen wir dann folgendes nutzen:

<pre>

type
TMyObj = class
function MyCallback(Data1, Data2: TData): Result; stdcall;
end; 

DoCallback(@TMyObj.MyCallback, MyObjInstance);

</pre>

Im Falle eines Callback Records k�nnte es so aussehen:

<pre>

type
TCallbackRec = packed record
PrintCallbackUserData: Pointer;
PrintCallback: function(UserData: Pointer; Data1: TData): Result; stdcall;
TestCallbackUserData: Pointer;
TestCallback: function(UserData: Pointer; Data1,Data2: TData): Result; stdcall;
end; 

transliert in einen Delphi Record s�he es so aus 

type
TCallbackRec = packed record
PrintEvent: function(Data1: TData): Result; stdcall; of Object;
TestEvent: function(Data1,Data2: TData): Result; stdcall; of Object;
end; 

und die Initalisierung dann so: 

var
Callback: TCallbackRec;
begin
Callback.PrintEvent := MyObjectInstance.PrintCallback;
Callback.TestEvent := MyObjectInstance.TestCallback;
end; 

und in der DLL dann so: 

Callback.PrintCallback(Callback.PrintUserData, Data1); 

</pre>

Das w�re wohl das intelligenteste.

gru� Hage

**Daniel Fiederling** · 22.07.2002, 15:40

Hallo Hagen! 
 
Danke erstmal f�r die schnelle und ausf�hrliche Antwort, nur leider bin ich ein bissl zu dumm dazu :-): 
zu 1.) so habe ich das im Moment auch gemacht, allerdings soll das ganze mal eine Thread-Klasse werden - und nicht nur deshalb ist es nicht gerade sicher bzw. sauber. 
 
zu 2.) Der letzte Teil - wenn ich das richtig verstehe - n�tzt in meinem Fall recht wenig, da die DLLs in C geschrieben sind und ich da auch bestimmt nicht meine Finger reinlegen will und auch nicht die Zeit dazu habe. 
Der Teil mit den Dispatcher-Routinen h�rt sich interessant an. Ich kann mir ungef�hr vorstellen, was du damit meinst, nur leider bin ich in asm nicht so fit: vermutlich sieht das irgendwie so aus: 
 
push irgendwas 
call TMyObj.DLLHandler 
pop irgendwas 
 
und irgendwas = self? Oder wie sprech ich denn in asm Pascal-Variablen an? Meine Zeiten mit TP6 und Interrupts sind lange her und waren auch nicht so tiefgreifend

). 
Und dann kann ich in der Funktion per self auf das entsprechende Objekt zugreifen? Oder muss ich mir die Variable erst vom Stack holen? Wenn ja, wie? 
 
Danke! 
Bye Daniel<br&gt

**Hagen Reddmann** · 22.07.2002, 21:48

Ne nicht ganz so. Das Problem was dabei entsteht ist das man alle Parameter vom Stack holen mu� um sie dann nachdem Self gepusht wurde wieder auf dem Stack abzulegen. Nur so wird die richtige Reihenfolge der Params m�glich.

Also z.B. so:

<pre>

function DllPrintDispatcher(Param1, Param2: DWord): DWord; stdcall;
asm
MOV EAX,$123456 // adresse des Objectes
POP EDX // Param2
POP ECX // Param1
PUSH EAX // Self
PUSH ECX // Param1
PUSH EDX // Param2
JMP TMyObject.DllPrint
end; 

// oder so

function DllPrintDispatcher(Param1, Param2: DWord): DWord; stdcall;
asm
POP EAX // Param2
POP EDX // Param1
PUSH $1234567 // Self
PUSH EDX // Param1
PUSH EAX // Param2
JMP TMyObject.DllPrint
end; 

</pre>

Diesen Code testen und wenn fertig im CPU Window die HEX-Werte auslesen und als const record definieren, etwa so 

<pre>
type
TDllPrintDispatcher = packed record
MOV_EAX: Byte;
SelfPtr: Pointer;
POP_EDX: Byte;
POP_ECX: Byte;
PUSH_EAX: Byte;
PUSH_EDX: Byte;
PUSH_ECX: Byte;
JMP: Byte;
Offset: PChar;
Dummy: Byte;
end;

</pre>

Nun wird im private Teil des Objectes ein solcher Record deklariert, und ausgef�llt:

<pre>

type
TMyClass = class
private
FPrintDispatcher: TDllPrintDispatcher;
function DllPrint(Param1,Param2: DWord): DWord; stdcall;
function DllPrintCallback: Pointer;
end; 

function TMyClass.DllPrintCallback: Pointer;
begin
with FPrintDispatcher do
begin
MOV_EAX := $xx;
SelfPtr := Self;
POP_EDX := $xx;
POP_ECX := $xx;
PUSH_EAX := $xx;
PUSH_EDX := $xx;
PUSH_ECX := $xx;
JMP := $xx;
Offset := PChar(@FPrintDispatcher.Dummy) - PChar(@TMyClass.DllPrint);
end;
Result := @FPrintDispatcher;
end;

</pre>

Bei den $xx Stellen mu� der entsprechende OpCode eingetragen werden. Mit MyClass.DllPrintDispatcher bekommste nun den Callbackfunctionpointer f�r die C DLL zur�ck.

Gru� Hage

**Hagen Reddmann** · 22.07.2002, 21:53

DllMessage d�rfte wohl die schwierigste Proc werden.
Dort k�nntest Du die Parameter�bergabe durch den Compiler erledigen lassen:

<pre>

function Dll2Dispatcher: DWord;: stdcall;
asm
POP ECX // Caller
PUSH $123456
PUSH ECX
JMP DllReorder
end; 

fucntion DllReorder(P1,P2,P3,P4,P5,P6,P7: DWord; Self: TMyClass): DWord; stdcall;
begin
Result := Self.DllMessage(P1, P2, P3, P4, P5, P6, P7);
end; 

</pre>

�brigens im vorherigen Posting habe ich vergessen zu erw�hnen das der oberste Parameter auf dem Stack der Zeiger zum aufrufenden Code ist. Dieser mu� nat�rlich ber�cksichtigt werden !!! 
Nat�rlch kannste obiges Konstrukt f�r alle deine Callbacks benutzen. Dann br�uchteste nur einen "generischen" Basisdispatcher:

<pre>

type
TDispatcher = packed record
POP_EAX: Byte; // Caller
PUSH_CONST: Byte; // PUSH Self
SelfPtr: Pointer;
JMP: Byte; // rel. jump
OFFSET: PChar;
end;

</pre>

Dann bastelste so wie oben gezeigt f�r jede Callback eine "Zwischenfunktion" die identisch mit den C-Callbackdeklarationen ist mit der Ausnahme das ein zus�tzlicher Param Self als letzter Param hinzugef�gt wird. 

Gru� Hage

**Hagen Reddmann** · 22.07.2002, 22:42

<pre>

<code>type
TDispatcher = packed record
POP_EAX: Byte;
PUSH_CONST: Byte;
SelfPtr: Pointer;
PUSH_EAX: Byte;
JMP: Byte;
Offset: DWord;
end;
 
PUserFunctions = ^TUserFunctions;
TUserFunctions = packed record
Print: function(Buffer: PChar; Size: ULONG): Integer; stdcall;
Sound: procedure; stdcall;
Replace: function(FileName: PChar): Integer; stdcall;
Password: function(P: PChar; N: Integer; M, Name: PChar): Integer; stdcall;
AppMessage: procedure(UnCompSize : ULONG; CompSize : ULONG; Factor : UINT;
Month : UINT; Day : UINT; Year : UINT; Hour : UINT;
Minute : UINT; C : Char; FileName : PChar; MethBuf : PChar;
CRC : ULONG; Crypt : Char); stdcall;
Service: function(CurFile: PChar; Size: ULONG): integer; stdcall;
 
TotalSizeComp : ULONG;
TotalSize : ULONG;
CompFactor : Integer;
NumMembers : UINT;
cchComment : UINT;
end;
 
TMyClass = class
private
FDispatcher: array[0..5] of TDispatcher;
FUser: TUserFunctions;
function UserFunctions: PUserFunctions;
protected
function Print(Buffer: PChar; Size: ULONG): Integer; stdcall;
function Password(P: PChar; N: Integer; M, Name: PChar): Integer; stdcall;
function Service(CurFile: PChar; Size: ULONG): integer; stdcall;
procedure Sound; stdcall;
function Replace(FileName: PChar): integer; stdcall;
procedure AppMessage(UnCompSize : ULONG; CompSize : ULONG; Factor : UINT; Month : UINT; Day : UINT; Year : UINT; Hour : UINT; Minute : UINT; C : Char; FileName : PChar; MethBuf : PChar; CRC : ULONG; Crypt : Char); stdcall;
end;
 
function TMyClass.Print(Buffer: PChar; Size: ULONG): Integer;
begin
end;
 
function TMyClass.Password(P: PChar; N: Integer; M, Name: PChar): Integer;
begin
end;
 
function TMyClass.Service(CurFile: PChar; Size: ULONG): integer;
begin
end;
 
procedure TMyClass.Sound;
begin
end;
 
function TMyClass.Replace(FileName: PChar): integer;
begin
end;
 
procedure TMyClass.AppMessage(UnCompSize : ULONG; CompSize : ULONG; Factor : UINT; Month : UINT; Day : UINT; Year : UINT; Hour : UINT; Minute : UINT; C : Char; FileName : PChar; MethBuf : PChar; CRC : ULONG; Crypt : Char);
begin
end;
 
function TMyClass.UserFunctions: PUserFunctions;
 
function GetCallback(Index: Integer; DispatchProc: PChar): Pointer;
begin
with FDispatcher[Index] do
begin
POP_EAX := $58;
PUSH_CONST := $68;
SelfPtr := Self;
PUSH_EAX := $50;
JMP := $E9;
Offset := DispatchProc - PChar(@FDispatcher[Index]) - SizeOf(TDispatcher);
end;
Result := @FDispatcher[Index];
end;
 
begin
FUser.Print := GetCallback(0, @TMyClass.Print);
FUser.Sound := GetCallback(1, @TMyClass.Sound);
FUser.Replace := GetCallback(2, @TMyClass.Replace);
FUser.Password := GetCallback(3, @TMyClass.Password);
FUser.AppMessage := GetCallback(4, @TMyClass.AppMessage);
FUser.Service := GetCallback(5, @TMyClass.Service);
Result := @FUser;
end;

</code></pre>
&#10

**Hagen Reddmann** · 22.07.2002, 22:43

<pre>

<code>procedure Test;
var
Self: TMyClass;
User: PUserFunctions;
begin
Self := TMyClass.Create;
User := Self.UserFunctions;
User.Print('Hagen', 5);
end;
 

</code></pre&gt

**Hagen Reddmann** · 22.07.2002, 22:46

So, obiger Code funktioniert. Ich musste mal wieder feststellen das ich in meinen vorherigen Postings Schwachsinn gefasselt habe. Die Paramter bei stdcall Callingconvention m�ssen NICHT auf dem Stack bearbeitet werden. Dies w�re bei cdecl der Fall. Stattdessen muss nur der oberste Param = Calleraddress vom Stack geholt werden, Self gepusht werden und dann wieder die Calleraddress. Dann reicht ein relativer Jump zur statischen Objectmethode aus. Das liegt daran das bei stdcall die Paramter ja "umgekehrt" auf dem Stack liegen. 

Eventuell sollte noch in der UserFunctions Methode nach dem Initailisieren mit VirtualProtect(@FDispatcher, SizeOf(FDispatcher), PAGE_EXECUTE_READ{WRITE), nil); die Zugriffsrechte gesetzt werden. Normalerweise ist die nicht n�tig da eigentlich jedes Usersegment auch ausf�hrbaren Code enthalten kann. Unter meinem Win2000 lief alles auch ohne VirtualProtect(). 

Gru� Hage

**Hagen Reddmann** · 22.07.2002, 22:56

Der erzeugte Code im FDispatcher[] sieht dann so aus

<pre>

<code>function FDispatcher: ...; stdcall;
asm
POP EAX // caller poppen
PUSH $1234567 // SelfPtr pushen
PUSH EAX // caller pushen
JMP -$1234567 // relative jump to TMyClass.DllMethod()
end;

</code></pre>

Gru� Hage

**Daniel Fiederling** · 23.07.2002, 10:22

Tausendfachen Dank f�r deine M�he! 
L�uft prima! 
;o)<br&gt

**Hagen Reddmann** · 23.07.2002, 18:07

Nochwas, beim Translieren habe ich festgestellt das deine Namensconventionen uneinheitlich ist. Man sollte f�r die gleiche procedure + methode + type deklaration immer auch die gleiche Namensgebung und Parameterdefinition verwenden. Dies macht den sp�teren Support wesentlich besser. 
Zus�tzlich habe ich es mir angew�hnt die verkorkste C/C++ Syntax NICHT in Delphi zu �bernehmen. Stattdessen transliere ich solche Typen/Namen in Delphi-Syntax konforme Form. 
Gruns�tzlich sah dein Source durch die C Deklaration sehr unleserlich aus (was wohl bei den meisten C Sourcen der Fall ist

Gru� Hage

Announcement

Objekte aus Callback-Funktionen ansprechen

Objekte aus Callback-Funktionen ansprechen

Comment

Comment

Comment

Comment

Comment

Comment

Comment

Comment

Comment

Comment

Comment

Comment