Can you determine if a string if freeable in C?

Question

If I say:

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

char *x;
char *y;

int main() {
        x = malloc(sizeof("Hello, world!"));
        strcpy(x, "Hello world!");
        y = "Hello, world";
        free(x);
        fprintf(stderr, "okay");
        free(y);
}

Then, obviously, the program will print "okay" followed by dying because the "pointer being freed was not allocated"—obviously, because the string was a string literal.

I'd like to write a function that does nothing when given string literals, but calls free when given non-string literals. Is that possible, and if so, how?

Nope :) That's the fun of memory management -- it's up to you the developer to keep track of these fun things. — Chris Eberle, Jun 22 '11 at 22:38
@mark do literals live on the heap or the stack? If neither then how is this a duplicate of that other question. other question. — David Heffernan, Jun 22 '11 at 22:50
@David: An easy way to achieve that is to follow the more general advice: always assign the address of a string literal to a `const char *`, never a `char *`. — Oliver Charlesworth, Jun 22 '11 at 22:52
@David: In that particular situation, the basic question was how to determine if a pointer is a heap pointer that can be freed. This seems like the same basic question. — Mark Wilkins, Jun 22 '11 at 22:57
@David: I believe that string literals are statically allocated, i.e. at compile time, but moreover they are not modifiable, and some architectures actually have a way of marking memory read-only. So you really better make sure to stay away from modifying (the pointer to) string literals! — Kerrek SB, Jun 22 '11 at 23:02

score 9 · Answer 1 · answered Jun 22 '11 at 22:39

9

I don't think the standard has anything for checking whether a pointer was returned by malloc or not (and you're only supposed to pass those to free) so I'd say no, you can't find that out. You'll have to keep track of it yourself.

answered Jun 22 '11 at 22:39

Matti Virkkunen

63,558
9
127
159

2

+1: This is the only answer so far that doesn't suggest some horrible non-portable, non-robust mechanism, and instead simply says "don't do that". – Oliver Charlesworth Jun 22 '11 at 22:50
@Oli: True, but OP did not say he needed a portable solution. – David R Tribble Jun 22 '11 at 22:54

score 6 · Accepted Answer · answered Jun 22 '11 at 22:48

No. In C, you have to keep track of what you've allocated yourself.

Some malloc implementations (such as dlmalloc) provide some extra functionality for inspecting the heap, but you shouldn't rely on those. dlmalloc has the function dlmalloc_inspect_all, which will walk the heap and return to you all of the regions of memory that malloc has allocated, except for memory-mapped chunks. So you could use that to test if a pointer points to a non-memory-mapped allocation, but it's still a bad idea in general.

And on Windows, don't even think about using [IsBadReadPtr] to test if a pointer points to readable memory or not -- it should really be called CrashProgramRandomly.

David R Tribble · Answer 3 · 2011-06-22T22:52:41.697

There is no portable way. However, since most implementations allocate heap objects in a different memory region than literal (string) data, it is possible to make an educated guess if a given string pointer falls within either region.

static char    x;

bool isStatic(const void *p)
{
    const char *  cp = (const char *)p;

    // Check if the pointer falls within +/-16K of 'x'
    if (cp-16*1024 <= &x  &&  &x <= cp+16*1024)
        return true;
    else
        return false;
}

Obviously, this is a bit of a hack. A much better way would be to directly access the .bss, .data, and .text addresses (these are Unix, Win32 is similar) of your executable after it is loaded into memory, and compare your pointers to those regions.

score 1 · Answer 4 · answered Jun 22 '11 at 22:41

1

If you know something about the memory map of your program at execution time, then you might be able to do something. A better idea is to do proper memory management, though.

answered Jun 22 '11 at 22:41

Carl Norum

219,201
40
422
469

score 1 · Answer 5 · answered Jun 22 '11 at 22:42

You can write a wrapper for malloc that tracks the addresses of the memory that was allocated. Then in your free function you can see if that memory is on the list.

Aside from that you might be able to play around with the heap but it won't be even remotely portable.

but why not build GC of some sort or use a GC library.

Can you determine if a string if freeable in C?

5 Answers5

Linked

Related