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