Allocating memory using malloc in a function, segmentation fault

Question

I am trying to run the following program, in which I dynamically allocate memory to a variable using a function called reserve. When I run the application, I get segmentation fault because of allocating the memory in a separate function for an empty pointer, but If I want allocate the memory in the main, I don't get this error. So what am I doing wrong?

Here is the code:

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

typedef struct{

unsigned char state;

/* socket fd of the client */
int fd;

/* File path requested by the client */
char file_path [255];

/* Current file offset */
unsigned long int offset;

} STATE;


void reserve(int length, void *context_data ,void *buffer)
{
    context_data = (char *) malloc(length);
    memcpy(context_data, buffer, length);
}

int main()
{
    STATE test;
    int length = sizeof(STATE);
    char buffer[1500];
    char *ptr = buffer;

    test.state = 10;
    strcpy(test.file_path, "Hello How are you");

    memcpy(ptr, &test, length);
    ptr += length;

    char *context_data;
    reserve(length, context_data, buffer);

    STATE *temp = (STATE *) context_data;
    printf("File Path %s\n", temp->file_path);
    printf("State %d\n", temp->state);
 }

templatetypedef · Accepted Answer · 2014-04-23 20:42:10Z

In this code:

void reserve(int length, void *context_data ,void *buffer)
{
    context_data = (char *) malloc(length);
    memcpy(context_data, buffer, length);
}

The context_data parameter is passed by value, so context_data inside of reserve and context_data outside of reserve aren't the same pointer. Consequently, when you reassign context_data locally inside this function, the context_data pointer in main isn't updated, causing the crash.

To fix this, either take in a pointer to the context_data variable to update, like this:

void reserve(int length, void **context_data ,void *buffer)
{
    *context_data = malloc(length);
    memcpy(*context_data, buffer, length);
}
reserve(length, &context_data, buffer);

Or, alternatively, have reserve return the updated pointer:

void* reserve(int length,void *buffer)
{
    void* context_data = (char *) malloc(length);
    memcpy(context_data, buffer, length);
    return context_data;
}
void* context_data = reserve(length, buffer);

Hope this helps!

Henry Hu · Accepted Answer · 2014-04-23 20:41:36Z

2

Notice that context_data is passed by value. So the local copy in reserve is changed, but not the original one. As a result, the context_data in main() is not initialized. So you got the crash.

answered Apr 23, 2014 at 20:41

Henry Hu

5244 silver badges12 bronze badges

1 Comment

mah Over a year ago

@HA-AS but you want the pointer itself to be modified, thus you must pass a pointer to the pointer.

mah · Accepted Answer · 2014-04-23 20:41:45Z

1

The problem is your main() function has no current means of learning where the allocation took place. You're passing the pointer from main() to reserve() which is fine to allow the subroutine to modify what the pointer points at... but that's not what you need; you need to have reserve() modify where the pointer points.

void reserve(int length, void **context_data ,void *buffer)
{
    *context_data = malloc(length);
    memcpy(*context_data, buffer, length);
}

// in main():
char *context_data;
reserve(length, &context_data, buffer);

answered Apr 23, 2014 at 20:41

mah

40.1k9 gold badges79 silver badges94 bronze badges

Comments

brokenfoot · Accepted Answer · 2014-04-23 20:44:11Z

1

In pass by reference, you pass the address of the variable. Here your variable is a pointer, hence pass the address of the pointer.

Call it like:

reserve(length, &context_data, buffer);

And change the function definition:

void reserve(int length, void **p_context_data ,void *buffer)
{
*p_context_data = malloc(sizeof(char)*length);
.....

answered Apr 23, 2014 at 20:44

brokenfoot

11.7k10 gold badges66 silver badges85 bronze badges

Comments

Always Learning · Accepted Answer · 2014-04-23 20:45:02Z

1

You pass a char* into reserve() but you should pass char** like this:

char *context_data;
reserve(length, &context_data, buffer);

then reserve should look like this:

void reserve(int length, void **context_data ,void *buffer) {
  *context_data = (char *) malloc(length); 
  memcpy(*context_data, buffer, length); 
}

answered Apr 23, 2014 at 20:45

Always Learning

5,6232 gold badges20 silver badges35 bronze badges

Comments

pashkoff · Accepted Answer · 2014-04-23 20:55:45Z

Variable void* context_data in function reserve() is a local variable, which means that it is different from variable char* context_data in function main(). Its value will not propagate back to the main() from reserve(). You pass a value of context_data to reserve() (the undefined value), and then use it as STATE* temp, but the value is still undefined.

If you would like to update a local variable of main() function, you have to pass a pointer to that variable. In your case, you have to pass pointer to pointer, i.e. your code should look like this:

void reserve(int length, void **context_data, void *buffer)
{
    *context_data = (char *) malloc(length);
    memcpy(*context_data, buffer, length);
}

int main()
{
    ...

    char* context_data;
    reserve(length, &context_data, buffer);
    ...
}

Or, you can also change your reserve() function and make it return a pointer to allocated memory.

Collectives™ on Stack Overflow

Allocating memory using malloc in a function, segmentation fault

6 Answers 6

Comments

1 Comment

Comments

Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

6 Answers 6

Comments

1 Comment

Comments

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related