Does sprintf/snprintf allocate additional memory?

Question

I'm writing a library and want to make it absolutely resource-agnostic which also means that library should live with user-supplied memory allocation functions. Library allows user to set their own error handler function too, which are called with an error message as an argument, like that:

typedef void (*error_handler)(const char* msg);

Library code prepares error message by itself, somehow like that (with case when message formatting fails being omitted):

char buf[BUF_SIZE];
snprintf(buf, BUF_SIZE, "Oops found at file '%s' line %d", __FILE__, __LINE__);

But can I be sure that snprintf will not allocate even more memory for its internal usage with malloc, obviously bypassing user-supplied allocation routines? Man page in my Linux system keeps silence on that.

`char* buf[BUF_SIZE];` or did you mean `char buf[BUF_SIZE];`? — Sourav Ghosh, Feb 17 '15 at 20:07
Even if it uses `malloc` internally, why should you be concerned, as long as it doesn't leak memory? — Blagovest Buyukliev, Feb 17 '15 at 20:11
At least for newlib only for formatting floats additional memory is needed. — Kijewski, Feb 17 '15 at 20:11
Have a look a glibc for example. I bet that it doesn't allocate memory, whatever is the implementation, but I have no proof of this and it is not part of the specification so you can't rely on any such assumption. — Jean-Baptiste Yunès, Feb 17 '15 at 20:13
@Jean-BaptisteYunès it does. Look at `stdio-common/vfprintf.c` — ouah, Feb 17 '15 at 20:14
Just looking at newlib source, that indeed seems to be the case, uses 40 byte buffer by default from stack and allocates more for some conversions if it is not enough — Antti Haapala -- Слава Україні, Feb 17 '15 at 20:15
@ouah I didn't find any allocation in the code source I looked at... — Jean-Baptiste Yunès, Feb 17 '15 at 20:16
I believe you can play some tricks with the dynamic linker to ensure that *every* call to `malloc()` and friends will be resolved to your own implementation automatically. I'm not into the details, but I believe one way is to execute a program with the `$LD_PRELOAD` variable set. If something like this is possilble on your system, it's likely a much better idea than trying to get all user code call your functions: You won't have to worry that you might have forgotten/cannot reach some code if you really replace the functions. — cmaster - reinstate monica, Feb 17 '15 at 20:37
@BlagovestBuyukliev: in this particular case this is not that big deal and bypassing allocator for, say, 100 bytes is still acceptable. But this seems to be just not enough perfect. — firegurafiku, Feb 17 '15 at 20:47
If you need just add file name and line, you can make string at a compile time... — Valeri Atamaniouk, Feb 17 '15 at 20:54
@ValeriAtamaniouk: this was just an example. Of course, I form strings at compile time whether possible. — firegurafiku, Feb 17 '15 at 21:11
how to version: http://stackoverflow.com/questions/3774417/sprintf-with-automatic-memory-allocation?noredirect=1&lq=1 — Ciro Santilli OurBigBook.com, Mar 19 '17 at 07:07

score 14 · Answer 1 · answered Feb 17 '15 at 20:47

According to the glibc, newlibc source code, both of them use malloc under some circumstances, but not in the likeliest cases.

If you want to find out whenever the current code executes malloc, or any other function, you can hook in the libc functions like this on Linux:

#define _GNU_SOURCE

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

void *malloc(size_t size) {
    static void *(*original_malloc)(size_t) = NULL;
    if (! original_malloc) {
        /* get the pointer to the original malloc */
        original_malloc = dlsym(RTLD_NEXT, "malloc");
    }

    void *rv = original_malloc(size);
    printf("allocated %zd bytes of memory\n", size);
    return rv;
}

Compile this into a shared object with

gcc -Wl,--no-as-needed -shared -ldl -fPIC hook.c -o hook.so

And given the code

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

int main() {
    char buf[256];
    char *malloced;

    printf("about to run sprintf\n");
    sprintf(buf, "%.250f", 0.123456789);
    printf("done\n");

    printf("about to run asprintf\n");
    asprintf(&malloced, "foo");
    free(malloced);
    printf("done\n");
}

compiled into prog, you can run it:

% LD_PRELOAD=./hook.so ./prog
about to run sprintf
done
about to run asprintf
allocated 100 bytes of memory
allocated 4 bytes of memory
done

Thank you a lot for showing the way how to test a particular implementation. — firegurafiku, Feb 23 '15 at 01:43

score 10 · Accepted Answer · answered Feb 17 '15 at 20:25

Like any library routine, sprintf and snprintf may or may not allocate memory for internal use.

They will not allocate memory for the resulting string. That memory must be allocated somehow by the caller, and its address passed as the first argument. If the allocated memory isn't big enough, then sprintf will have undefined behavior (since there's no way to tell it how much space is available), and snprintf will truncate the result (assuming the size argument is accurate).

If an implementation of sprintf or snprintf allocates memory and doesn't arrange for it to be released, that would be a memory leak. Such a leak would not actually violate the language standard (which has little to say about resource allocation), but it would be considered a bug in that implementation.

In particular, if your own code uses its own memory allocator rather than malloc, any library functions you call could call malloc internally, unless you use some system-specific feature to cause calls to malloc, even in the standard library, to call your allocator instead. fopen(), for example, is particularly likely to allocate memory for buffers.

If you do something to replace the standard library's calls to malloc with calls to your own allocator, you'll need to be sure that you also replace any calls to realloc, calloc, and free, and possibly one or more system-specific routines. For example, cleanup code that runs when your program finishes will close open files, which might involve calls to free.

Does sprintf/snprintf allocate additional memory?

2 Answers2