#include #include #include #include "portability.h" /* * vasprintf() and asprintf() for platforms with a C99-compliant * snprintf() - so that, if you format into a 1-byte buffer, it * will return how many characters it would have produced had * it been given an infinite-sized buffer. */ int pcapint_vasprintf(char **strp, const char *format, va_list args) { char buf; int len; size_t str_size; char *str; int ret; /* * XXX - the C99 standard says, in section 7.19.6.5 "The * snprintf function": * * The snprintf function is equivalent to fprintf, except that * the output is written into an array (specified by argument s) * rather than to a stream. If n is zero, nothing is written, * and s may be a null pointer. Otherwise, output characters * beyond the n-1st are discarded rather than being written * to the array, and a null character is written at the end * of the characters actually written into the array. * * ... * * The snprintf function returns the number of characters that * would have been written had n been sufficiently large, not * counting the terminating null character, or a negative value * if an encoding error occurred. Thus, the null-terminated * output has been completely written if and only if the returned * value is nonnegative and less than n. * * That doesn't make it entirely clear whether, if a null buffer * pointer and a zero count are passed, it will return the number * of characters that would have been written had a buffer been * passed. * * And, even if C99 *does*, in fact, say it has to work, it * doesn't work in Solaris 8, for example - it returns -1 for * NULL/0, but returns the correct character count for a 1-byte * buffer. * * So we pass a one-character pointer in order to find out how * many characters this format and those arguments will need * without actually generating any more of those characters * than we need. * * (The fact that it might happen to work with GNU libc or with * various BSD libcs is completely uninteresting, as those tend * to have asprintf() already and thus don't even *need* this * code; this is for use in those UN*Xes that *don't* have * asprintf().) */ len = vsnprintf(&buf, sizeof buf, format, args); if (len == -1) { *strp = NULL; return (-1); } str_size = len + 1; str = malloc(str_size); if (str == NULL) { *strp = NULL; return (-1); } ret = vsnprintf(str, str_size, format, args); if (ret == -1) { free(str); *strp = NULL; return (-1); } *strp = str; /* * vsnprintf() shouldn't truncate the string, as we have * allocated a buffer large enough to hold the string, so its * return value should be the number of characters written. */ return (ret); } int pcapint_asprintf(char **strp, const char *format, ...) { va_list args; int ret; va_start(args, format); ret = pcapint_vasprintf(strp, format, args); va_end(args); return (ret); }