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
pcap_vasprintf(char ** strp,const char * format,va_list args)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
pcap_asprintf(char ** strp,const char * format,...)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