Given a char* with the prototype, can we cast a void* to a function pointer? and run it?

I've declared many functions in one driver, and am passing the pointers to the functions to another driver in a list with the node format:

struct node
{
 char def_prototype[256]; //example:(int (*)(wchar, int, int))
 void *def_function;
};

Is there a way to typecast def_function to the prototype given in def_prototype?

Currently I'm using simple switch and strcmp, but I wanted to generalize it if possible.
PS: I know that casting between void pointer and function pointer is unsafe (as mentioned in various places in SO), but desperate times call for desperate measures and I have taken lot of care.

EDIT:

Sorry for the lack in clarity. I want to actually call the function (not just cast it), making a function pointer at runtime based on the char[] provided.

EDIT AGAIN:

Since I'm working at the kernel level (windows driver), I don't have access to much resources, so, I'm sticking to开发者_运维知识库 my current implementation (with some changes to kill back-doors). Thanks to all for your help.

ISO-C does not allow casting between function and data pointers, ie you should use a void (*)(void) instead of a void * to hold your function.

That aside, YeenFei is correct in his assertion that there is no general platform-independant solution, meaning the best you can do in C itself is to supply a list of supported signatures.

You should implement your own encoding scheme instead of using plain C prototypes. It's common to use a string where each char represents a function argument (and the first one the return value); a function of type int (*)(wchar, int, int) for example could have the signature "iwii".

Signature lookup tables can then be easily built using bsearch() and strcmp(); here's a complete example:

#include <assert.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static int cmp(const void *key, const void *element)
{
    return strcmp(key, *(const char * const *)element);
}

static _Bool dispatch(const char *sig, void (*func)(void), void *retval, ...)
{
    // supported signatures; must be ordered according to strcmp()
    static const char * const SIGS[] = { "iii", "v", "vi" };

    const char * const *match = bsearch(
        sig, SIGS, sizeof SIGS / sizeof *SIGS, sizeof *SIGS, cmp);

    if(!match) return 0;

    va_list args;
    va_start(args, retval);

    switch(match - SIGS)
    {
        case 0: {   // iii
            int a1 = va_arg(args, int);
            int a2 = va_arg(args, int);
            int rv = ((int (*)(int, int))func)(a1, a2);
            if(retval) memcpy(retval, &rv, sizeof rv);
            break;
        }

        case 1: {   // v
            func();
            break;
        }

        case 2: {   // vi
            int a1 = va_arg(args, int);
            ((void (*)(int))func)(a1);
            break;
        }

        default:
        assert(!"PANIC");
    }

    va_end(args);
    return 1;
}

// example code:

static int add(int a, int b)
{
    return a + b;
}

int main(void)
{
    int sum;
    dispatch("iii", (void (*)(void))add, &sum, 3, 4);
    printf("%i", sum);
    return 0;
}

unless you want to mess with assembly thunking (pushing data onto stack before jumping, etc), there is better way other than doing some switch case.

if the destination function is finite and known, why not create a lookup table (map<string, functor>) for it ?

A good implementation of similar ideas is libffi. This implements the gory details of declaring and calling functions with arbitrary calling conventions and signatures. It is (surprisingly) platform portable, and known to work on Linux and Windows out of the box.

An example of its use is the Lua extension library alien. That demonstrates calling arbitrary functions declared at runtime and adapting from native Lua types to the types required for the calling conventions. The specific Lua binding won't be useful to you, but it serves as a complete working example of how and why one might actually use libffi.

Since C has no runtime type information, there is absolutely no need to do a dynamic cast as you are considering. Just pass the pointer and if everything fits, it will work. If the pointer doesn't point to a function with the right signature, there is no way to fix it.

There are basically two solutions:

1. Go to the assembly level and parse the prototype string there and put the arguments you find in the prototype there where the other function will expect them.
2. Make a long list of all supported prototypes and compare the current one with the list. When you find a match, you can make the typecast as needed. The most common structure for this test would ba an if-else ladder.