Line data Source code
1 : /*
2 : * Dynamic data buffer
3 : * Copyright (c) 2007-2012, Jouni Malinen <j@w1.fi>
4 : *
5 : * This software may be distributed under the terms of the BSD license.
6 : * See README for more details.
7 : */
8 :
9 : #include "includes.h"
10 :
11 : #include "common.h"
12 : #include "trace.h"
13 : #include "wpabuf.h"
14 :
15 : #ifdef WPA_TRACE
16 : #define WPABUF_MAGIC 0x51a974e3
17 :
18 : struct wpabuf_trace {
19 : unsigned int magic;
20 : } __attribute__((aligned(8)));
21 :
22 346913 : static struct wpabuf_trace * wpabuf_get_trace(const struct wpabuf *buf)
23 : {
24 346913 : return (struct wpabuf_trace *)
25 : ((const u8 *) buf - sizeof(struct wpabuf_trace));
26 : }
27 : #endif /* WPA_TRACE */
28 :
29 :
30 0 : static void wpabuf_overflow(const struct wpabuf *buf, size_t len)
31 : {
32 : #ifdef WPA_TRACE
33 0 : struct wpabuf_trace *trace = wpabuf_get_trace(buf);
34 0 : if (trace->magic != WPABUF_MAGIC) {
35 0 : wpa_printf(MSG_ERROR, "wpabuf: invalid magic %x",
36 : trace->magic);
37 : }
38 : #endif /* WPA_TRACE */
39 0 : wpa_printf(MSG_ERROR, "wpabuf %p (size=%lu used=%lu) overflow len=%lu",
40 : buf, (unsigned long) buf->size, (unsigned long) buf->used,
41 : (unsigned long) len);
42 0 : wpa_trace_show("wpabuf overflow");
43 0 : abort();
44 : }
45 :
46 :
47 69057 : int wpabuf_resize(struct wpabuf **_buf, size_t add_len)
48 : {
49 69057 : struct wpabuf *buf = *_buf;
50 : #ifdef WPA_TRACE
51 : struct wpabuf_trace *trace;
52 : #endif /* WPA_TRACE */
53 :
54 69057 : if (buf == NULL) {
55 22500 : *_buf = wpabuf_alloc(add_len);
56 22500 : return *_buf == NULL ? -1 : 0;
57 : }
58 :
59 : #ifdef WPA_TRACE
60 46557 : trace = wpabuf_get_trace(buf);
61 46557 : if (trace->magic != WPABUF_MAGIC) {
62 0 : wpa_printf(MSG_ERROR, "wpabuf: invalid magic %x",
63 : trace->magic);
64 0 : wpa_trace_show("wpabuf_resize invalid magic");
65 0 : abort();
66 : }
67 : #endif /* WPA_TRACE */
68 :
69 46557 : if (buf->used + add_len > buf->size) {
70 : unsigned char *nbuf;
71 33040 : if (buf->flags & WPABUF_FLAG_EXT_DATA) {
72 1 : nbuf = os_realloc(buf->buf, buf->used + add_len);
73 1 : if (nbuf == NULL)
74 0 : return -1;
75 1 : os_memset(nbuf + buf->used, 0, add_len);
76 1 : buf->buf = nbuf;
77 : } else {
78 : #ifdef WPA_TRACE
79 33039 : nbuf = os_realloc(trace, sizeof(struct wpabuf_trace) +
80 : sizeof(struct wpabuf) +
81 33039 : buf->used + add_len);
82 33039 : if (nbuf == NULL)
83 8 : return -1;
84 33031 : trace = (struct wpabuf_trace *) nbuf;
85 33031 : buf = (struct wpabuf *) (trace + 1);
86 33031 : os_memset(nbuf + sizeof(struct wpabuf_trace) +
87 : sizeof(struct wpabuf) + buf->used, 0,
88 : add_len);
89 : #else /* WPA_TRACE */
90 : nbuf = os_realloc(buf, sizeof(struct wpabuf) +
91 : buf->used + add_len);
92 : if (nbuf == NULL)
93 : return -1;
94 : buf = (struct wpabuf *) nbuf;
95 : os_memset(nbuf + sizeof(struct wpabuf) + buf->used, 0,
96 : add_len);
97 : #endif /* WPA_TRACE */
98 33031 : buf->buf = (u8 *) (buf + 1);
99 33031 : *_buf = buf;
100 : }
101 33032 : buf->size = buf->used + add_len;
102 : }
103 :
104 46549 : return 0;
105 : }
106 :
107 :
108 : /**
109 : * wpabuf_alloc - Allocate a wpabuf of the given size
110 : * @len: Length for the allocated buffer
111 : * Returns: Buffer to the allocated wpabuf or %NULL on failure
112 : */
113 300209 : struct wpabuf * wpabuf_alloc(size_t len)
114 : {
115 : #ifdef WPA_TRACE
116 300209 : struct wpabuf_trace *trace = os_zalloc(sizeof(struct wpabuf_trace) +
117 : sizeof(struct wpabuf) + len);
118 : struct wpabuf *buf;
119 300209 : if (trace == NULL)
120 229 : return NULL;
121 299980 : trace->magic = WPABUF_MAGIC;
122 299980 : buf = (struct wpabuf *) (trace + 1);
123 : #else /* WPA_TRACE */
124 : struct wpabuf *buf = os_zalloc(sizeof(struct wpabuf) + len);
125 : if (buf == NULL)
126 : return NULL;
127 : #endif /* WPA_TRACE */
128 :
129 299980 : buf->size = len;
130 299980 : buf->buf = (u8 *) (buf + 1);
131 299980 : return buf;
132 : }
133 :
134 :
135 378 : struct wpabuf * wpabuf_alloc_ext_data(u8 *data, size_t len)
136 : {
137 : #ifdef WPA_TRACE
138 378 : struct wpabuf_trace *trace = os_zalloc(sizeof(struct wpabuf_trace) +
139 : sizeof(struct wpabuf));
140 : struct wpabuf *buf;
141 378 : if (trace == NULL)
142 2 : return NULL;
143 376 : trace->magic = WPABUF_MAGIC;
144 376 : buf = (struct wpabuf *) (trace + 1);
145 : #else /* WPA_TRACE */
146 : struct wpabuf *buf = os_zalloc(sizeof(struct wpabuf));
147 : if (buf == NULL)
148 : return NULL;
149 : #endif /* WPA_TRACE */
150 :
151 376 : buf->size = len;
152 376 : buf->used = len;
153 376 : buf->buf = data;
154 376 : buf->flags |= WPABUF_FLAG_EXT_DATA;
155 :
156 376 : return buf;
157 : }
158 :
159 :
160 50185 : struct wpabuf * wpabuf_alloc_copy(const void *data, size_t len)
161 : {
162 50185 : struct wpabuf *buf = wpabuf_alloc(len);
163 50185 : if (buf)
164 50174 : wpabuf_put_data(buf, data, len);
165 50185 : return buf;
166 : }
167 :
168 :
169 57937 : struct wpabuf * wpabuf_dup(const struct wpabuf *src)
170 : {
171 57937 : struct wpabuf *buf = wpabuf_alloc(wpabuf_len(src));
172 57937 : if (buf)
173 57915 : wpabuf_put_data(buf, wpabuf_head(src), wpabuf_len(src));
174 57937 : return buf;
175 : }
176 :
177 :
178 : /**
179 : * wpabuf_free - Free a wpabuf
180 : * @buf: wpabuf buffer
181 : */
182 802967 : void wpabuf_free(struct wpabuf *buf)
183 : {
184 : #ifdef WPA_TRACE
185 : struct wpabuf_trace *trace;
186 802967 : if (buf == NULL)
187 1305578 : return;
188 300356 : trace = wpabuf_get_trace(buf);
189 300356 : if (trace->magic != WPABUF_MAGIC) {
190 0 : wpa_printf(MSG_ERROR, "wpabuf_free: invalid magic %x",
191 : trace->magic);
192 0 : wpa_trace_show("wpabuf_free magic mismatch");
193 0 : abort();
194 : }
195 300356 : if (buf->flags & WPABUF_FLAG_EXT_DATA)
196 376 : os_free(buf->buf);
197 300356 : os_free(trace);
198 : #else /* WPA_TRACE */
199 : if (buf == NULL)
200 : return;
201 : if (buf->flags & WPABUF_FLAG_EXT_DATA)
202 : os_free(buf->buf);
203 : os_free(buf);
204 : #endif /* WPA_TRACE */
205 : }
206 :
207 :
208 9587 : void wpabuf_clear_free(struct wpabuf *buf)
209 : {
210 9587 : if (buf) {
211 5969 : os_memset(wpabuf_mhead(buf), 0, wpabuf_len(buf));
212 5969 : wpabuf_free(buf);
213 : }
214 9587 : }
215 :
216 :
217 1942533 : void * wpabuf_put(struct wpabuf *buf, size_t len)
218 : {
219 1942533 : void *tmp = wpabuf_mhead_u8(buf) + wpabuf_len(buf);
220 1942533 : buf->used += len;
221 1942533 : if (buf->used > buf->size) {
222 0 : wpabuf_overflow(buf, len);
223 : }
224 1942533 : return tmp;
225 : }
226 :
227 :
228 : /**
229 : * wpabuf_concat - Concatenate two buffers into a newly allocated one
230 : * @a: First buffer
231 : * @b: Second buffer
232 : * Returns: wpabuf with concatenated a + b data or %NULL on failure
233 : *
234 : * Both buffers a and b will be freed regardless of the return value. Input
235 : * buffers can be %NULL which is interpreted as an empty buffer.
236 : */
237 645 : struct wpabuf * wpabuf_concat(struct wpabuf *a, struct wpabuf *b)
238 : {
239 645 : struct wpabuf *n = NULL;
240 645 : size_t len = 0;
241 :
242 645 : if (b == NULL)
243 25 : return a;
244 :
245 620 : if (a)
246 221 : len += wpabuf_len(a);
247 620 : if (b)
248 620 : len += wpabuf_len(b);
249 :
250 620 : n = wpabuf_alloc(len);
251 620 : if (n) {
252 620 : if (a)
253 221 : wpabuf_put_buf(n, a);
254 620 : if (b)
255 620 : wpabuf_put_buf(n, b);
256 : }
257 :
258 620 : wpabuf_free(a);
259 620 : wpabuf_free(b);
260 :
261 620 : return n;
262 : }
263 :
264 :
265 : /**
266 : * wpabuf_zeropad - Pad buffer with 0x00 octets (prefix) to specified length
267 : * @buf: Buffer to be padded
268 : * @len: Length for the padded buffer
269 : * Returns: wpabuf padded to len octets or %NULL on failure
270 : *
271 : * If buf is longer than len octets or of same size, it will be returned as-is.
272 : * Otherwise a new buffer is allocated and prefixed with 0x00 octets followed
273 : * by the source data. The source buffer will be freed on error, i.e., caller
274 : * will only be responsible on freeing the returned buffer. If buf is %NULL,
275 : * %NULL will be returned.
276 : */
277 1890 : struct wpabuf * wpabuf_zeropad(struct wpabuf *buf, size_t len)
278 : {
279 : struct wpabuf *ret;
280 : size_t blen;
281 :
282 1890 : if (buf == NULL)
283 4 : return NULL;
284 :
285 1886 : blen = wpabuf_len(buf);
286 1886 : if (blen >= len)
287 1874 : return buf;
288 :
289 12 : ret = wpabuf_alloc(len);
290 12 : if (ret) {
291 12 : os_memset(wpabuf_put(ret, len - blen), 0, len - blen);
292 12 : wpabuf_put_buf(ret, buf);
293 : }
294 12 : wpabuf_free(buf);
295 :
296 12 : return ret;
297 : }
298 :
299 :
300 78931 : void wpabuf_printf(struct wpabuf *buf, char *fmt, ...)
301 : {
302 : va_list ap;
303 78931 : void *tmp = wpabuf_mhead_u8(buf) + wpabuf_len(buf);
304 : int res;
305 :
306 78931 : va_start(ap, fmt);
307 78931 : res = vsnprintf(tmp, buf->size - buf->used, fmt, ap);
308 78931 : va_end(ap);
309 78931 : if (res < 0 || (size_t) res >= buf->size - buf->used)
310 0 : wpabuf_overflow(buf, res);
311 78931 : buf->used += res;
312 78931 : }
313 :
314 :
315 : /**
316 : * wpabuf_parse_bin - Parse a null terminated string of binary data to a wpabuf
317 : * @buf: Buffer with null terminated string (hexdump) of binary data
318 : * Returns: wpabuf or %NULL on failure
319 : *
320 : * The string len must be a multiple of two and contain only hexadecimal digits.
321 : */
322 50 : struct wpabuf * wpabuf_parse_bin(const char *buf)
323 : {
324 : size_t len;
325 : struct wpabuf *ret;
326 :
327 50 : len = os_strlen(buf);
328 50 : if (len & 0x01)
329 5 : return NULL;
330 45 : len /= 2;
331 :
332 45 : ret = wpabuf_alloc(len);
333 45 : if (ret == NULL)
334 0 : return NULL;
335 :
336 45 : if (hexstr2bin(buf, wpabuf_put(ret, len), len)) {
337 3 : wpabuf_free(ret);
338 3 : return NULL;
339 : }
340 :
341 42 : return ret;
342 : }
|