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
wpabuf_get_trace(const struct wpabuf * buf)22 static struct wpabuf_trace * wpabuf_get_trace(const struct wpabuf *buf)
23 {
24 return (struct wpabuf_trace *)
25 ((const u8 *) buf - sizeof(struct wpabuf_trace));
26 }
27 #endif /* WPA_TRACE */
28
29
wpabuf_overflow(const struct wpabuf * buf,size_t len)30 static void wpabuf_overflow(const struct wpabuf *buf, size_t len)
31 {
32 #ifdef WPA_TRACE
33 struct wpabuf_trace *trace = wpabuf_get_trace(buf);
34 if (trace->magic != WPABUF_MAGIC) {
35 wpa_printf(MSG_ERROR, "wpabuf: invalid magic %x",
36 trace->magic);
37 }
38 #endif /* WPA_TRACE */
39 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 wpa_trace_show("wpabuf overflow");
43 abort();
44 }
45
46
wpabuf_resize(struct wpabuf ** _buf,size_t add_len)47 int wpabuf_resize(struct wpabuf **_buf, size_t add_len)
48 {
49 struct wpabuf *buf = *_buf;
50 #ifdef WPA_TRACE
51 struct wpabuf_trace *trace;
52 #endif /* WPA_TRACE */
53
54 if (buf == NULL) {
55 *_buf = wpabuf_alloc(add_len);
56 return *_buf == NULL ? -1 : 0;
57 }
58
59 #ifdef WPA_TRACE
60 trace = wpabuf_get_trace(buf);
61 if (trace->magic != WPABUF_MAGIC) {
62 wpa_printf(MSG_ERROR, "wpabuf: invalid magic %x",
63 trace->magic);
64 wpa_trace_show("wpabuf_resize invalid magic");
65 abort();
66 }
67 #endif /* WPA_TRACE */
68
69 if (buf->used + add_len > buf->size) {
70 unsigned char *nbuf;
71 if (buf->flags & WPABUF_FLAG_EXT_DATA) {
72 nbuf = os_realloc(buf->buf, buf->used + add_len);
73 if (nbuf == NULL)
74 return -1;
75 os_memset(nbuf + buf->used, 0, add_len);
76 buf->buf = nbuf;
77 } else {
78 #ifdef WPA_TRACE
79 nbuf = os_realloc(trace, sizeof(struct wpabuf_trace) +
80 sizeof(struct wpabuf) +
81 buf->used + add_len);
82 if (nbuf == NULL)
83 return -1;
84 trace = (struct wpabuf_trace *) nbuf;
85 buf = (struct wpabuf *) (trace + 1);
86 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 buf->buf = (u8 *) (buf + 1);
99 *_buf = buf;
100 }
101 buf->size = buf->used + add_len;
102 }
103
104 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 */
wpabuf_alloc(size_t len)113 struct wpabuf * wpabuf_alloc(size_t len)
114 {
115 #ifdef WPA_TRACE
116 struct wpabuf_trace *trace = os_zalloc(sizeof(struct wpabuf_trace) +
117 sizeof(struct wpabuf) + len);
118 struct wpabuf *buf;
119 if (trace == NULL)
120 return NULL;
121 trace->magic = WPABUF_MAGIC;
122 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 buf->size = len;
130 buf->buf = (u8 *) (buf + 1);
131 return buf;
132 }
133
134
wpabuf_alloc_ext_data(u8 * data,size_t len)135 struct wpabuf * wpabuf_alloc_ext_data(u8 *data, size_t len)
136 {
137 #ifdef WPA_TRACE
138 struct wpabuf_trace *trace = os_zalloc(sizeof(struct wpabuf_trace) +
139 sizeof(struct wpabuf));
140 struct wpabuf *buf;
141 if (trace == NULL)
142 return NULL;
143 trace->magic = WPABUF_MAGIC;
144 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 buf->size = len;
152 buf->used = len;
153 buf->buf = data;
154 buf->flags |= WPABUF_FLAG_EXT_DATA;
155
156 return buf;
157 }
158
159
wpabuf_alloc_copy(const void * data,size_t len)160 struct wpabuf * wpabuf_alloc_copy(const void *data, size_t len)
161 {
162 struct wpabuf *buf = wpabuf_alloc(len);
163 if (buf)
164 wpabuf_put_data(buf, data, len);
165 return buf;
166 }
167
168
wpabuf_dup(const struct wpabuf * src)169 struct wpabuf * wpabuf_dup(const struct wpabuf *src)
170 {
171 struct wpabuf *buf;
172
173 if (!src)
174 return NULL;
175 buf = wpabuf_alloc(wpabuf_len(src));
176 if (buf)
177 wpabuf_put_data(buf, wpabuf_head(src), wpabuf_len(src));
178 return buf;
179 }
180
181
182 /**
183 * wpabuf_free - Free a wpabuf
184 * @buf: wpabuf buffer
185 */
wpabuf_free(struct wpabuf * buf)186 void wpabuf_free(struct wpabuf *buf)
187 {
188 #ifdef WPA_TRACE
189 struct wpabuf_trace *trace;
190 if (buf == NULL)
191 return;
192 trace = wpabuf_get_trace(buf);
193 if (trace->magic != WPABUF_MAGIC) {
194 wpa_printf(MSG_ERROR, "wpabuf_free: invalid magic %x",
195 trace->magic);
196 wpa_trace_show("wpabuf_free magic mismatch");
197 abort();
198 }
199 if (buf->flags & WPABUF_FLAG_EXT_DATA)
200 os_free(buf->buf);
201 os_free(trace);
202 #else /* WPA_TRACE */
203 if (buf == NULL)
204 return;
205 if (buf->flags & WPABUF_FLAG_EXT_DATA)
206 os_free(buf->buf);
207 os_free(buf);
208 #endif /* WPA_TRACE */
209 }
210
211
wpabuf_clear_free(struct wpabuf * buf)212 void wpabuf_clear_free(struct wpabuf *buf)
213 {
214 if (buf) {
215 os_memset(wpabuf_mhead(buf), 0, wpabuf_len(buf));
216 wpabuf_free(buf);
217 }
218 }
219
220
wpabuf_put(struct wpabuf * buf,size_t len)221 void * wpabuf_put(struct wpabuf *buf, size_t len)
222 {
223 void *tmp = wpabuf_mhead_u8(buf) + wpabuf_len(buf);
224 buf->used += len;
225 if (buf->used > buf->size) {
226 wpabuf_overflow(buf, len);
227 }
228 return tmp;
229 }
230
231
232 /**
233 * wpabuf_concat - Concatenate two buffers into a newly allocated one
234 * @a: First buffer
235 * @b: Second buffer
236 * Returns: wpabuf with concatenated a + b data or %NULL on failure
237 *
238 * Both buffers a and b will be freed regardless of the return value. Input
239 * buffers can be %NULL which is interpreted as an empty buffer.
240 */
wpabuf_concat(struct wpabuf * a,struct wpabuf * b)241 struct wpabuf * wpabuf_concat(struct wpabuf *a, struct wpabuf *b)
242 {
243 struct wpabuf *n = NULL;
244 size_t len = 0;
245
246 if (b == NULL)
247 return a;
248
249 if (a)
250 len += wpabuf_len(a);
251 len += wpabuf_len(b);
252
253 n = wpabuf_alloc(len);
254 if (n) {
255 if (a)
256 wpabuf_put_buf(n, a);
257 wpabuf_put_buf(n, b);
258 }
259
260 wpabuf_free(a);
261 wpabuf_free(b);
262
263 return n;
264 }
265
266
267 /**
268 * wpabuf_zeropad - Pad buffer with 0x00 octets (prefix) to specified length
269 * @buf: Buffer to be padded
270 * @len: Length for the padded buffer
271 * Returns: wpabuf padded to len octets or %NULL on failure
272 *
273 * If buf is longer than len octets or of same size, it will be returned as-is.
274 * Otherwise a new buffer is allocated and prefixed with 0x00 octets followed
275 * by the source data. The source buffer will be freed on error, i.e., caller
276 * will only be responsible on freeing the returned buffer. If buf is %NULL,
277 * %NULL will be returned.
278 */
wpabuf_zeropad(struct wpabuf * buf,size_t len)279 struct wpabuf * wpabuf_zeropad(struct wpabuf *buf, size_t len)
280 {
281 struct wpabuf *ret;
282 size_t blen;
283
284 if (buf == NULL)
285 return NULL;
286
287 blen = wpabuf_len(buf);
288 if (blen >= len)
289 return buf;
290
291 ret = wpabuf_alloc(len);
292 if (ret) {
293 os_memset(wpabuf_put(ret, len - blen), 0, len - blen);
294 wpabuf_put_buf(ret, buf);
295 }
296 wpabuf_free(buf);
297
298 return ret;
299 }
300
301
wpabuf_printf(struct wpabuf * buf,char * fmt,...)302 void wpabuf_printf(struct wpabuf *buf, char *fmt, ...)
303 {
304 va_list ap;
305 void *tmp = wpabuf_mhead_u8(buf) + wpabuf_len(buf);
306 int res;
307
308 va_start(ap, fmt);
309 res = vsnprintf(tmp, buf->size - buf->used, fmt, ap);
310 va_end(ap);
311 if (res < 0 || (size_t) res >= buf->size - buf->used)
312 wpabuf_overflow(buf, res);
313 buf->used += res;
314 }
315
316
317 /**
318 * wpabuf_parse_bin - Parse a null terminated string of binary data to a wpabuf
319 * @buf: Buffer with null terminated string (hexdump) of binary data
320 * Returns: wpabuf or %NULL on failure
321 *
322 * The string len must be a multiple of two and contain only hexadecimal digits.
323 */
wpabuf_parse_bin(const char * buf)324 struct wpabuf * wpabuf_parse_bin(const char *buf)
325 {
326 size_t len;
327 struct wpabuf *ret;
328
329 len = os_strlen(buf);
330 if (len & 0x01)
331 return NULL;
332 len /= 2;
333
334 ret = wpabuf_alloc(len);
335 if (ret == NULL)
336 return NULL;
337
338 if (hexstr2bin(buf, wpabuf_put(ret, len), len)) {
339 wpabuf_free(ret);
340 return NULL;
341 }
342
343 return ret;
344 }
345
346
wpabuf_array_alloc(void)347 struct wpabuf_array * wpabuf_array_alloc(void)
348 {
349 struct wpabuf_array *wa;
350
351 wa = os_zalloc(sizeof(*wa));
352 return wa;
353 }
354
355
wpabuf_array_free(struct wpabuf_array * wa)356 void wpabuf_array_free(struct wpabuf_array *wa)
357 {
358 unsigned int idx;
359
360 if (!wa)
361 return;
362 for (idx = 0; idx < wa->num; idx++)
363 wpabuf_free(wa->buf[idx]);
364 os_free(wa->buf);
365 os_free(wa);
366 }
367
368
wpabuf_array_add(struct wpabuf_array * wa,struct wpabuf * buf)369 int wpabuf_array_add(struct wpabuf_array *wa, struct wpabuf *buf)
370 {
371 struct wpabuf **n;
372
373 if (!wa || !buf)
374 return -1;
375 n = os_realloc(wa->buf, (wa->num + 1) * sizeof(struct wpabuf *));
376 if (!n)
377 return -1;
378 wa->buf = n;
379 wa->buf[wa->num++] = buf;
380 return 0;
381 }
382
383
wpabuf_array_remove(struct wpabuf_array * wa,unsigned int idx)384 void wpabuf_array_remove(struct wpabuf_array *wa, unsigned int idx)
385 {
386 if (!wa || wa->num == 0 || idx >= wa->num)
387 return;
388 wpabuf_free(wa->buf[idx]);
389 while (idx + 1 < wa->num) {
390 wa->buf[idx] = wa->buf[idx + 1];
391 idx++;
392 }
393 wa->num--;
394 wa->buf[wa->num] = NULL;
395 }
396