C++/Win32 Dynamically calling a function without knowing its signature

Question

This is a terrible idea, but i'm seeing if it's even feasible before I walk down this road.

I have to write a Win32 C++ program that can dynamically load a library based on a file that has serialized information on what dll, function, signature, and arguements to use. Loading the library is trivial (LoadLibraryEx works fine). Then getting the function pointer is easy (not a big deal, the GetProcAdderss takes care of this). However the rest is tricky.

Here's my plan of attack, feel free to let me know if this isn't the best approach:

1. Open the serialized information from a file on what DLL to load, and what function to execute.
2. LoadLibraryEx to bring in the DLL
3. GetProcAddress to get the function pointer (after casting the byte array to a string)
4. Write the arguments (which are read in as a byte array) to memory in bytes.
5. Get the address to the beginning of each argument (i'll know from serialization what the size of each argument is).
6. Using assembly jump to the beginning of the function pointer, push the addresses on the heap to the arguments in the stack (in reverse order).
7. Execute and get back the return value address (as a void * ?)
8. Use the memory address of the return value (that I got from assembly) and the size (which I got from the serialization) of the return type value and write the raw bytes back to a file.

Keep in mind my limitations:

1. I will never know except for run-time what the signature, dll, function name is.
2. It is always read in from a file.

Is there a better approach, will this approach even work?

Update

For anyone who comes poking in this thread to learn more, I found a solution. In C you can dynamically load a library using dlopen (there's a winlib of this for ease of use). Once loaded you can dynamically execute functions using libffi (supports mac/ios/win 64 and 32bit). This only gets you to C functions and primitive types (pointer,uint,int,double,float) and thats about it. However using macosx objective-c bridge you can access objective-c by loading libobjc (osx's native obj-c to c "toll free" bridge). Then through that dynamically create obj-c and c++ classes. A similar technique can be done on windows using C# and its marshaling capabilities.

This ends up with HIGH overhead, and you must be VERY careful about your memory, in addition don't mix pointers from C/C#/C++. Finally, whatever you do, at runtime. BE ABSOLUTELY SURE YOU KNOW YOUR TYPES.... seriously. BTW, libffi/cinvoke, amazing libraries.

Answer 1

There are existing libraries that can do what you describe, such as C/Invoke:

http://www.nongnu.org/cinvoke/

Answer 2

General rule, that if you have a terrible idea, drop it and find a good one.

If the signature is not known at all, what you describe will fall on face. Suppose your call works for my function as it is. I change the function from __stdcall to __cdecl or back, and you will crash.

Also you don't handle the return.

If you relax the "unknown" to allow some limitations, like fixing a return type and calling convention, you are somewhat ahead -- then really you can emulate the call but what is it good for? This whole thing sounds like a self-service hack-me engine.

The normal way is to publish some fixed interface (using function signatures), and make the DLL support it. Or arrange some uniform data transfer mechanism.

I'd suggest you to describe what you're after really and post ask that, maybe on Programmers SE.