Freeing up memory outside of the function causes a double free or corruption error

Question

I am facing a problem where I get double free or corruption error when I try to free up a memory, outside of the function in which I had allocated that block of memory, even though I had passed the pointer to the memory block to a pointer outside of that function.

My code is such that in the main() function, I make a call to a function with the definition char * reverseComplement(char * pattern); as such:

char * rev = reverseComplement(dna_input);

where dna_input is a char pointer to a block of allocated memory that was allocated within main(). Within the reverseComplement() function, there is a line where I allocate memory and then return the pointer to that block of memory at the very end.

...
...
char * revcomplpattern = (char *)malloc(strlen(pattern));
...
...
return revcomplpattern;

One reason I thought could be causing the problem is that after the reverseComplement() function finished executing, its stack gets torn down so I would lose the access to the memory on the heap. But this shouldn't be because I had passed over the handle of the heap-allocated memory over from revcomplpattern which was residing in reverseComplement() over to rev which is residing in main(). So free(rev) in main() should do the job.

I don't know what I might be doing wrong here, and any help is greatly appreciated!

Answer 1

...where dna_input is a char pointer to a block of allocated memory that was allocated within main(). Within the reverseComplement() function, there is a line where I allocate memory and then return the pointer to that block of memory at the very end.

Your idea tells me that you are allocating memory and somehow using that memory in reverseComplement() function but in the function, you're allocating another block of memory. I'm not sure why.

...a problem where I get double free or corruption error...

You need to make sure all allocated blocks of memory in your program are freed by the time your program exits for any reason. If not, then you'll have a memory leak.

If you must allocate memory within a function (which I don't recommend), then you can use code like this:

char *getnewblock(int size)
{
    char *secondblock=malloc(size);
    return secondblock;
}

int main()
{
    char *myblock = malloc(1000);
    char *myblock2 = getnewblock(5000);
    free(myblock);
    free(myblock2);
    return 0;
}

The above program allocates 1000 bytes of memory then calls a function to allocate 5000 bytes of memory then frees both blocks of memory.

What I really recommend you do is allocate memory only in one function then use the same memory block in child functions like so:

void insertfirstchar(char *block,char onechar)
{
   block[0]=onechar;
}

int main()
{
    char *myblock = malloc(1000);
    insertfirstchar(myblock,'A');
    free(myblock);
    return 0;
}

In the above program, 1000 bytes are allocated, then a function is called to make the first byte of the memory block the letter "A" then the memory is freed. This last program can be used as your starting point.

Answer 2

Ok guys I just got this all figured out! So sorry for the trouble! As it turns out, the error was not because of the way I was freeing my allocated memory, but at the malloc() call.

It turns out that what I did when I allocated

char * revcomplpattern = (char *)malloc(strlen(pattern));

was immediate followed by these lines

int strend = strlen(pattern)/sizeof(char) -1 ;
revcomplpattern[strend+1] = '\0';

where my goal was to ensure that revcomplpattern would be made into a string as I inserted a null termination at its end. Turns out that in indexing [strend+1], I was actually touching an unallocated position in memory! After correcting the malloc() call with an additional space for one more character

char * revcomplpattern = (char *)malloc(strlen(pattern) + 1 * sizeof(char));

The call to the free(rev) does not throw an error! Everything works fine now and Valgrind shows no errors! Special shoutout to @tofro and @jdigital for your advising. When I used valgrind it started telling me there was an error in strlen and malloc which I couldn't understand at first until I narrowed it down to that line and gave a hard look at it and realized what was wrong.

Man, I feel that GCC gives very cryptic error messages that don't help much. I'm actually puzzled now, if anyone can answer, why my mistake DID NOT throw a SEGFAULT instead? I thought this would cause a segfault since I was touching an unallocated portion of memory???

Nonetheless, thank you everyone for your help!

Answer 3

Maybe you are corrupting memory before returning control to main()? Freeing your "valid" block of memory could be failing because your malloc heap is already corrupted. Alternatively, maybe some error codepaths in reverseComplement() already free this memory?