Übergabe Funktionszeiger an DLL, was ist sicher?

22/08/2010 - 13:53 von Christoph Basedau | Report spam
Hallo

einer Win32-DLL übergebe ich einen Funktionszeiger,
der auf eine statische Methode einer MFC-Exe verweist.

Den Zeiger speichere ich in der DLL als glob. Variable und ruf ihn
dann auch irgendwann auf. Funktioniert.


Frage1:
Ist das sicher?
Wenn die DLL mehrfach in beliebige Prozess geladen wird,
wird sie dann auf mehrfach "instantiiert" (1x pro LoadLibrary)
oder "làuft" immer nur 1 "Instanz" in allen Prozessen,
bzw. wovon hàngt das ab?

Frage2:
Muss ich irgendwie Calling-Conventions berücksichtigen?
Hatte den Func-Pointer erst als CALLBACK definiert, also __stdcall,
was nicht funktionierte, da die MFC-Methode nun mal nicht __stcall
ist. Wenn ich keine Calling-Convention definiere, ist es OK,
auf meinen System.
Aber kann ich das auch für andere, bzw. alle Win32-Systeme voraus
setzen (x86 u. x64)?

Danke für alle Tipps,
Christoph


Code:
////1. MFC-exe
//DLL-Laden und eine DLL-Func aufrufen
void LoadHook()
{

//Typ für Func-Zeiger
typedef void (* LPF_RECVKEYS)(int, int, int, int, int);
//Typ für DLL-Func
typedef BOOL (CALLBACK * LPF_HOOK)(HINSTANCE, LPF_RECVKEYS);

static HINSTANCE hInstDLL LoadLibrary((LPCTSTR) "MyDLL.dll");
LPF_HOOK funcHook = (LPF_HOOK)
GetProcAddress(hInstDLL, "MyDLLFunc");

if (funcHook )
{

LPF_RECVKEYS revcFunc (LPF_RECVKEYS) CMyClass::ReceiveKeys;
funcHook (hInstDLL, revcFunc);
}
}

/* static */ void CMyClass::ReceiveKeys(int k1, int k2,
int k3, int k4, int k5)
{
//mach was mit den keys
}

////2 Win32-DLL
//glob Decl:
typedef void (* LPF_RECV_KEYS)(int, int, int, int, int);
LPF_RECVKEYS g_pFuncRecvKeys = NULL;

//Export-Func MyDLLFunc
BOOL __declspec(dllexport)__stdcall MyDLLFunc(
HINSTANCE hInstance, LPF_RECVKEYS pFuncRevcKeys)
{

g_pFuncRecvKeys = pFuncRevcKeys;
}

//Andere-Func MyDLLFunc2, nicht exportiert
void MyFunc2()
{
...
if (g_pFuncRecvKeys)
{
g_pFuncRecvKeys(wParam, nWk, nCtrl, nShift, nMenu); //5 int-Params
}
...
}
 

Lesen sie die antworten

#1 Stefan Reuther
22/08/2010 - 15:44 | Warnen spam
Christoph Basedau wrote:
Frage1:
Ist das sicher?
Wenn die DLL mehrfach in beliebige Prozess geladen wird,
wird sie dann auf mehrfach "instantiiert" (1x pro LoadLibrary)
oder "làuft" immer nur 1 "Instanz" in allen Prozessen,
bzw. wovon hàngt das ab?



Unter Win32 wird eine DLL prinzipiell für jeden Prozess einzeln geladen.
Wenn sie nicht explizit miteinander kommunizieren, wissen die einzelnen
Instanzen der DLL nichts voneinander. Unter Win16 war das mal anders.

Frage2:
Muss ich irgendwie Calling-Conventions berücksichtigen?
Hatte den Func-Pointer erst als CALLBACK definiert, also __stdcall,
was nicht funktionierte, da die MFC-Methode nun mal nicht __stcall
ist. Wenn ich keine Calling-Convention definiere, ist es OK,
auf meinen System.



Die Calling-Convention muss halt übereinstimmen, völlig unabhàngig
davon, ob die beiden Hàlften des Programms in der gleichen .exe liegen
oder in .exe und .dll. Wenn die DLL einen Zeiger ohne 'CALLBACK' haben
will, musst du ihr also einen ohne 'CALLBACK' geben; will sie einen mit
'CALLBACK', musst du ihr einen mit geben.

Davon abgesehen gibt es keinerlei Vorschriften, dass Callback-Funktionen
als 'CALLBACK' deklariert sein müssen. Unter Win16 gab es für Callback-
Funktionen mal Einschrànkungen (vgl. MakeProcInstance), die unter Win32
aber ebenfalls der Vergangenheit angehören.


Stefan

Ähnliche fragen