CODEWITHSUNDEEP
c++winapipipe
zerospiel
zerospiel

Reputation: 642

How to transmit a function to anonymous pipe WinAPI?

I need to write to anonymous pipe something like double (*fun)(double), but the following WriteFile(pipe, fun, 4, written_bytes, 0) causes an error in a pipe-receiver while ReadFile(read_pipe, fun, 4, written_bytes, 0). Are there any methods to do this?

I have an idea. I can create a struct with field of same type:

struct Foo
{
    double (*f)(double);
};

And then I write it WriteFile(hWritePipe_StdIN, &to_process, sizeof(Foo), &bytes, 0); But I have problem, that pipe-receiver never ends to read data: ReadFile(hReadPipe, &to_process, sizeof(Foo), &bytes, 0);

Upvotes: 2

Views: 292

Answers (5)

hamstergene
hamstergene

Reputation: 24439

In native code you can not send function (the code) itself, neither to the same nor to different process. (You could try low-level hacking like the one @Abyx suggests, but it seriously limits functionality that the code can perform, and will probably make you resort to writing it all in assembler by hand.)

You also can't send function's address to another process, because each process has its own isolated address space; in another process, that address will contain different data.

The solution will be to create a shared library (preferably dynamic) that will contain all functions that could possibly be sent this way. Assign each function some tag (e.g. number or name), let DLL maintain a mapping between tags and addresses. Then send tags instead.

Upvotes: 2

MSalters
MSalters

Reputation: 180295

Since you're using WinAPI, the native way to send a function is via COM. In particular, expose the function as a method on a COM object, obtain a COM moniker, and send the moniker. Monikers can be serialized and sent over pipes. The other side can deserialize the moniker and get access to your object.

Under water, this works by looking up the object in the COM Running Object Table

Upvotes: 1

Damon
Damon

Reputation: 70206

Seeing how this is excessively complicated and error-prone to do in C++ (and only works with a very limited set of functions at all), I recommend you use a scripting language for this. Instruction caches and DEP are another two things you'd have to consider in addition to the already mentioned ones.

Really. Transmit the function as script, and run it on the other end. Save yourself that pain.

Angelscript looks and feels almost like C++, so that might be a possible candidate.

Now, if you object to this because you need something that a script cannot trivially do, knoweth: C++ will not be able to do it either, in this scenario.

Apart from the above mentioned PIC code issue (@Abyx) and the fact that you cannot safely or portably know a function's size, the only C++ functions that you could conceivably send via a pipe and execute in a meaningful manner are strictly const functions. Here, const is in the sense of e.g. GCC's __attribute__((const)), not the C++ const keyword.

That is, any such function may not examine any values except its arguments, and have no effects except the return value. The reason is obvious: A different process lives in a different address space, so anything you reference is meaningless. Anything you change is meaningless.
Now, this is just what a script can do, in a safe, straightforward manner, and reliably. The overhead is, considering you already send code through a pipe, neglegible.

Upvotes: 0

Abyx
Abyx

Reputation: 12928

There are some problems with it:

First, you should know the size of function. If you do, you just call WriteFile(pipe, funcPtr, funcSize, ...) to transfer it.

Second, the function should contain only position-independent code, and don't address any data. E.g. a function like this won't work:

double fun(double x)
{
    int arr[10000]; // implicit function call (alloca or something like this)
    printf("some");
    static int some = 1;
    return globalVal + (++some);
}

because function printf will have a different address and there will be no static variable and string in another process.
(Well, maybe you can transfer data as well, but there is no way you'll generate PI code.)

So, with all that limitations, you can send a function:

__declspec(naked) double fun(double x) { __asm ret }

const auto funcSize = 1;
WriteFile(pipe, &fun, funcSize, ...);

Upvotes: 2

unwind
unwind

Reputation: 400129

What are you trying to achieve, here? Are you really trying to write the function itself? Why? That's not something you can easily do in C++, for instance because the size of a function is not well-defined.

You should probably write the data, i.e. the number returned by fun() instead:

const double value = fun(input);
DWORD numberOfBytesWritten;
WriteFile(pipe, &value, sizeof value, &numberOfBytesWritten, NULL);

You should of course add code to check the output. Note that writing binary data like this can be brittle.

Upvotes: 1

Related Questions