workbench/network/WirelessManager/src/utils/wpabuf.c

   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
  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
  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
  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  */
 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
 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
 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
 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  */
 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
 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  */
 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  */
 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
 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 }