1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <stdarg.h> 4 5 #include "portability.h" 6 7 /* 8 * vasprintf() and asprintf() for platforms with a C99-compliant 9 * snprintf() - so that, if you format into a 1-byte buffer, it 10 * will return how many characters it would have produced had 11 * it been given an infinite-sized buffer. 12 */ 13 int 14 pcap_vasprintf(char **strp, const char *format, va_list args) 15 { 16 char buf; 17 int len; 18 size_t str_size; 19 char *str; 20 int ret; 21 22 /* 23 * XXX - the C99 standard says, in section 7.19.6.5 "Thes 24 * nprintf function": 25 * 26 * The snprintf function is equivalent to fprintf, except that 27 * the output is written into an array (specified by argument s) 28 * rather than to a stream. If n is zero, nothing is written, 29 * and s may be a null pointer. Otherwise, output characters 30 * beyond the n-1st are discarded rather than being written 31 * to the array, and a null character is written at the end 32 * of the characters actually written into the array. 33 * 34 * ... 35 * 36 * The snprintf function returns the number of characters that 37 * would have been written had n been sufficiently large, not 38 * counting the terminating null character, or a negative value 39 * if an encoding error occurred. Thus, the null-terminated 40 * output has been completely written if and only if the returned 41 * value is nonnegative and less than n. 42 * 43 * That doesn't make it entirely clear whether, if a null buffer 44 * pointer and a zero count are passed, it will return the number 45 * of characters that would have been written had a buffer been 46 * passed. 47 * 48 * And, even if C99 *does*, in fact, say it has to work, it 49 * doesn't work in Solaris 8, for example - it returns -1 for 50 * NULL/0, but returns the correct character count for a 1-byte 51 * buffer. 52 * 53 * So we pass a one-character pointer in order to find out how 54 * many characters this format and those arguments will need 55 * without actually generating any more of those characters 56 * than we need. 57 * 58 * (The fact that it might happen to work with GNU libc or with 59 * various BSD libcs is completely uninteresting, as those tend 60 * to have asprintf() already and thus don't even *need* this 61 * code; this is for use in those UN*Xes that *don't* have 62 * asprintf().) 63 */ 64 len = vsnprintf(&buf, sizeof buf, format, args); 65 if (len == -1) { 66 *strp = NULL; 67 return (-1); 68 } 69 str_size = len + 1; 70 str = malloc(str_size); 71 if (str == NULL) { 72 *strp = NULL; 73 return (-1); 74 } 75 ret = vsnprintf(str, str_size, format, args); 76 if (ret == -1) { 77 free(str); 78 *strp = NULL; 79 return (-1); 80 } 81 *strp = str; 82 /* 83 * vsnprintf() shouldn't truncate the string, as we have 84 * allocated a buffer large enough to hold the string, so its 85 * return value should be the number of characters written. 86 */ 87 return (ret); 88 } 89 90 int 91 pcap_asprintf(char **strp, const char *format, ...) 92 { 93 va_list args; 94 int ret; 95 96 va_start(args, format); 97 ret = pcap_vasprintf(strp, format, args); 98 va_end(args); 99 return (ret); 100 } 101 102