• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
24 struct wpabuf_trace {
25 	unsigned int magic;
26 };
27 
wpabuf_get_trace(const struct wpabuf * buf)28 static 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 
wpabuf_overflow(const struct wpabuf * buf,size_t len)36 static 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 
wpabuf_resize(struct wpabuf ** _buf,size_t add_len)53 int 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  */
wpabuf_alloc(size_t len)118 struct 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 
wpabuf_alloc_ext_data(u8 * data,size_t len)139 struct 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 
wpabuf_alloc_copy(const void * data,size_t len)163 struct 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 
wpabuf_dup(const struct wpabuf * src)172 struct 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  */
wpabuf_free(struct wpabuf * buf)185 void 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 
wpabuf_put(struct wpabuf * buf,size_t len)209 void * 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  */
wpabuf_concat(struct wpabuf * a,struct wpabuf * b)229 struct 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  */
wpabuf_zeropad(struct wpabuf * buf,size_t len)269 struct 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 
wpabuf_printf(struct wpabuf * buf,char * fmt,...)292 void 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