1 /* 2 * Dynamic data buffer 3 * Copyright (c) 2007-2012, Jouni Malinen <j (at) 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 }; 21 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 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 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 */ 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 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 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 169 struct 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 */ 182 void 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 208 void * wpabuf_put(struct wpabuf *buf, size_t len) 209 { 210 void *tmp = wpabuf_mhead_u8(buf) + wpabuf_len(buf); 211 buf->used += len; 212 if (buf->used > buf->size) { 213 wpabuf_overflow(buf, len); 214 } 215 return tmp; 216 } 217 218 219 /** 220 * wpabuf_concat - Concatenate two buffers into a newly allocated one 221 * @a: First buffer 222 * @b: Second buffer 223 * Returns: wpabuf with concatenated a + b data or %NULL on failure 224 * 225 * Both buffers a and b will be freed regardless of the return value. Input 226 * buffers can be %NULL which is interpreted as an empty buffer. 227 */ 228 struct wpabuf * wpabuf_concat(struct wpabuf *a, struct wpabuf *b) 229 { 230 struct wpabuf *n = NULL; 231 size_t len = 0; 232 233 if (b == NULL) 234 return a; 235 236 if (a) 237 len += wpabuf_len(a); 238 if (b) 239 len += wpabuf_len(b); 240 241 n = wpabuf_alloc(len); 242 if (n) { 243 if (a) 244 wpabuf_put_buf(n, a); 245 if (b) 246 wpabuf_put_buf(n, b); 247 } 248 249 wpabuf_free(a); 250 wpabuf_free(b); 251 252 return n; 253 } 254 255 256 /** 257 * wpabuf_zeropad - Pad buffer with 0x00 octets (prefix) to specified length 258 * @buf: Buffer to be padded 259 * @len: Length for the padded buffer 260 * Returns: wpabuf padded to len octets or %NULL on failure 261 * 262 * If buf is longer than len octets or of same size, it will be returned as-is. 263 * Otherwise a new buffer is allocated and prefixed with 0x00 octets followed 264 * by the source data. The source buffer will be freed on error, i.e., caller 265 * will only be responsible on freeing the returned buffer. If buf is %NULL, 266 * %NULL will be returned. 267 */ 268 struct wpabuf * wpabuf_zeropad(struct wpabuf *buf, size_t len) 269 { 270 struct wpabuf *ret; 271 size_t blen; 272 273 if (buf == NULL) 274 return NULL; 275 276 blen = wpabuf_len(buf); 277 if (blen >= len) 278 return buf; 279 280 ret = wpabuf_alloc(len); 281 if (ret) { 282 os_memset(wpabuf_put(ret, len - blen), 0, len - blen); 283 wpabuf_put_buf(ret, buf); 284 } 285 wpabuf_free(buf); 286 287 return ret; 288 } 289 290 291 void wpabuf_printf(struct wpabuf *buf, char *fmt, ...) 292 { 293 va_list ap; 294 void *tmp = wpabuf_mhead_u8(buf) + wpabuf_len(buf); 295 int res; 296 297 va_start(ap, fmt); 298 res = vsnprintf(tmp, buf->size - buf->used, fmt, ap); 299 va_end(ap); 300 if (res < 0 || (size_t) res >= buf->size - buf->used) 301 wpabuf_overflow(buf, res); 302 buf->used += res; 303 } 304
