wpabuf.c revision 849734c8d1847920ed7042463f7480b1e0c1dfea 
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
18struct wpabuf_trace {
19	unsigned int magic;
20} __attribute__((aligned(8)));
21
22static 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
30static 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
47int 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 */
113struct 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
135struct 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
160struct 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
169struct wpabuf * wpabuf_dup(const struct wpabuf *src)
170{
171	struct wpabuf *buf = wpabuf_alloc(wpabuf_len(src));
172	if (buf)
173		wpabuf_put_data(buf, wpabuf_head(src), wpabuf_len(src));
174	return buf;
175}
176
177
178/**
179 * wpabuf_free - Free a wpabuf
180 * @buf: wpabuf buffer
181 */
182void wpabuf_free(struct wpabuf *buf)
183{
184#ifdef WPA_TRACE
185	struct wpabuf_trace *trace;
186	if (buf == NULL)
187		return;
188	trace = wpabuf_get_trace(buf);
189	if (trace->magic != WPABUF_MAGIC) {
190		wpa_printf(MSG_ERROR, "wpabuf_free: invalid magic %x",
191			   trace->magic);
192		wpa_trace_show("wpabuf_free magic mismatch");
193		abort();
194	}
195	if (buf->flags & WPABUF_FLAG_EXT_DATA)
196		os_free(buf->buf);
197	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
208void wpabuf_clear_free(struct wpabuf *buf)
209{
210	if (buf) {
211		os_memset(wpabuf_mhead(buf), 0, wpabuf_len(buf));
212		wpabuf_free(buf);
213	}
214}
215
216
217void * wpabuf_put(struct wpabuf *buf, size_t len)
218{
219	void *tmp = wpabuf_mhead_u8(buf) + wpabuf_len(buf);
220	buf->used += len;
221	if (buf->used > buf->size) {
222		wpabuf_overflow(buf, len);
223	}
224	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 */
237struct wpabuf * wpabuf_concat(struct wpabuf *a, struct wpabuf *b)
238{
239	struct wpabuf *n = NULL;
240	size_t len = 0;
241
242	if (b == NULL)
243		return a;
244
245	if (a)
246		len += wpabuf_len(a);
247	if (b)
248		len += wpabuf_len(b);
249
250	n = wpabuf_alloc(len);
251	if (n) {
252		if (a)
253			wpabuf_put_buf(n, a);
254		if (b)
255			wpabuf_put_buf(n, b);
256	}
257
258	wpabuf_free(a);
259	wpabuf_free(b);
260
261	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 */
277struct wpabuf * wpabuf_zeropad(struct wpabuf *buf, size_t len)
278{
279	struct wpabuf *ret;
280	size_t blen;
281
282	if (buf == NULL)
283		return NULL;
284
285	blen = wpabuf_len(buf);
286	if (blen >= len)
287		return buf;
288
289	ret = wpabuf_alloc(len);
290	if (ret) {
291		os_memset(wpabuf_put(ret, len - blen), 0, len - blen);
292		wpabuf_put_buf(ret, buf);
293	}
294	wpabuf_free(buf);
295
296	return ret;
297}
298
299
300void wpabuf_printf(struct wpabuf *buf, char *fmt, ...)
301{
302	va_list ap;
303	void *tmp = wpabuf_mhead_u8(buf) + wpabuf_len(buf);
304	int res;
305
306	va_start(ap, fmt);
307	res = vsnprintf(tmp, buf->size - buf->used, fmt, ap);
308	va_end(ap);
309	if (res < 0 || (size_t) res >= buf->size - buf->used)
310		wpabuf_overflow(buf, res);
311	buf->used += res;
312}
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 */
322struct wpabuf * wpabuf_parse_bin(const char *buf)
323{
324	size_t len;
325	struct wpabuf *ret;
326
327	len = os_strlen(buf);
328	if (len & 0x01)
329		return NULL;
330	len /= 2;
331
332	ret = wpabuf_alloc(len);
333	if (ret == NULL)
334		return NULL;
335
336	if (hexstr2bin(buf, wpabuf_put(ret, len), len)) {
337		wpabuf_free(ret);
338		return NULL;
339	}
340
341	return ret;
342}
343