libpcap  1.10.1
About: libpcap is a packet filter library used by tools like tcpdump.
  Fossies Dox: libpcap-1.10.1.tar.gz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

asprintf.c
Go to the documentation of this file.
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 
int pcap_vasprintf(char **strp, const char *format, va_list args)
Definition: asprintf.c:14
int pcap_asprintf(char **strp, const char *format,...)
Definition: asprintf.c:91
int vsnprintf(char *, size_t, const char *, va_list)