Passing char* as a parameter to dynamically called function gives runtime error

Question

I have a function named testdynamic which is called dynamically with dlopen and dlsym. Now, I have created a structure:

typedef struct BigStruct{
    char el[2000];
}BigStruct;

which is used to store the parameters for the function. Then, I allocate space to a variable named:

void *cur = (void*)malloc(totalSize);

where, totalSize is the size of the parameters. I have this information beforehand.

After that I copy all the parameters to cur.

Then, I cast it to BigStruct like this:

BigStruct *bg;
bg = (BigStruct*)cur;

And run it like this:

void* ch = (void*)testdynamic(*bg);

Now in the function testdynamic when I am printing the parameters, I am getting correct values for all data types like char**, int*, int, etc.

The only data type which is not working is char*. Even before calling the function with *bg, the contents of bg->el is correct even for char*. But, after calling, an error occurs.

What could be the problem?

Here is the code of testdynamic

char* testdynamic(char* x, char* y){
    printf("%s %s\n", x, y);
    return "hello";
}

I want to pass the parameters to the function testdynamic from my code.
This testdynamic can be any function which could accept any parameter of any type.
I get the information about the function during runtime. Since the size of char* is 1, I am casting everything to char* and then passing it to the function.
At this point, I am getting a runtime error if I am printing anything inside testdynamic which is of type char*.

Answer 1

You are assuming that BigStruct looks exactly like an array of 2000 characters. This is compiler dependent and unlikely to be true. I guess you really want to copy the data pointed to by cur into the el array and not to write it all over BigStruct itself which will have some internal storage format that you cannot know.

Answer 2

So to summarise what I understand you're doing:

• Treating cur as a char* and copying a parameter list into it
• Casting cur as a BigStruct* and then passing it to the testdynamic function.

This seems to me like an odd way of going about this, and without looking inside the testdynamic function I would guess that this is what is causing the error. I would recommend changing your definition of BigStruct:

typedef struct {
    char * el;
} BigStruct;

And that way, you can malloc space for your char array, copy your parameter list to it, and then set the char * in the BigStruct to point to the relevant block of memory as follows:

char * cur = malloc(totalSize);
// Copy parameters over into cur
BigStruct * bg = malloc(sizeof(BigStruct));
bg->el = cur;

And then call your testdynamic function again. Try this, do you still get a runtime error?

edit: having seen the content of the testdynamic function, I can see several problems with it

char* testdynamic(char* x, char* y){
    printf("%s %s\n", x, y);
    return "hello";
}

1. The function accepts 2 char * but you only seem to pass 1 in your code. What should it print for y if you only give it an argument for x?
2. Let's assume you are now passing arguments for both x and y. Are you sure that both strings are null-terminated? printf works by printing characters until it finds the '\0' character.
3. You can't just return a string literal from within a function like that. That string literal belongs to the function, and once the function returns you can't guarantee that the memory which held the string will still be safe to access again. If you want to return a string like that, you should first malloc() space for the string and return the address to the allocated block of memory.

Answer 3

If totalSize > sizeof(BigStruct), you have problems for you are not passing a complete copy of your data to testdynamic(), likely messing up the copy and hence undefined behavior.

If totalSize < sizeof(BigStruct), you have problems for you are reading memory space you do not own when you pass *bg to testdynamic() - hence undefined behavior.

You are much safer simply with

bg = malloc(*bg);

---

There other questionable program issues going on here too, but a more complete posting would be needed.

Answer 4

This only works if the size is sizeof(BigStruct)

You can't assume a structure is the size of its content, since compilers might make assumptions of alignment, etc.

If you just want 20,000 chars, then malloc it inside the BigStruct like others have suggested.

Answer 5

After reading it some more....

you're passing in one parameter for a function that requires 2 parameters.

Are you using -Wall for warning treated as errors during compilation? The second parameter isn't passed in, i.e, argument y is null. Accessing null would cause the problem.

Answer 6

To provide accurate, non-opinionated comments, a copy of the code is required. Thus, I have taken your comments and produced the following code. It is probably NOT what you want to do. However, a programming problem should be approached in steps or increments.

That is, get something simple to work and then make it a little more complex, but still working, and work towards your final version. This is how many of us work. No one is able to write a complex program correctly the first time, especially if new to the language!

#include <stdio.h>
#include <stdlib.h>
char *testdynamic(char *x, char* y){

        printf("%s %s\n", x, y);
        return "hello";
    }

main()
{
    typedef struct BigStruct{
        char el[2000];
    } BigStruct;

    char      *ret_char_ptr;

    BigStruct *bg;

    char x[] = "abcd";
    char y[] = "23456";

    bg = malloc(sizeof(BigStruct));

    // invoke the testdynamic function
    ret_char_ptr = testdynamic(x, y);


    printf("%s\n", ret_char_ptr);

}

I ran this code on Eclipse/Microsoft C compiler and got the following output:

abcd 23456
hello

Note. BigStruct has yet to used in this code. Not sure what your intent is, but C does provide a way to pass parameter lists that vary in length and data from several different calls to the same function.