contrib/wpa_supplicant/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 "wpabuf.h"
  19
  20 static void wpabuf_overflow(const struct wpabuf *buf, size_t len)
  21 {
  22         wpa_printf(MSG_ERROR, "wpabuf %p (size=%lu used=%lu) overflow len=%lu",
  23                    buf, (unsigned long) buf->size, (unsigned long) buf->used,
  24                    (unsigned long) len);
  25         abort();
  26 }
  27
  28
  29 int wpabuf_resize(struct wpabuf **_buf, size_t add_len)
  30 {
  31         struct wpabuf *buf = *_buf;
  32         if (buf == NULL) {
  33                 *_buf = wpabuf_alloc(add_len);
  34                 return *_buf == NULL ? -1 : 0;
  35         }
  36         if (buf->used + add_len > buf->size) {
  37                 unsigned char *nbuf;
  38                 if (buf->ext_data) {
  39                         nbuf = os_realloc(buf->ext_data, buf->used + add_len);
  40                         if (nbuf == NULL)
  41                                 return -1;
  42                         os_memset(nbuf + buf->used, 0, add_len);
  43                         buf->ext_data = nbuf;
  44                 } else {
  45                         nbuf = os_realloc(buf, sizeof(struct wpabuf) +
  46                                           buf->used + add_len);
  47                         if (nbuf == NULL)
  48                                 return -1;
  49                         buf = (struct wpabuf *) nbuf;
  50                         os_memset(nbuf + sizeof(struct wpabuf) + buf->used, 0,
  51                                   add_len);
  52                         *_buf = buf;
  53                 }
  54                 buf->size = buf->used + add_len;
  55         }
  56
  57         return 0;
  58 }
  59
  60
  61 /**
  62  * wpabuf_alloc - Allocate a wpabuf of the given size
  63  * @len: Length for the allocated buffer
  64  * Returns: Buffer to the allocated wpabuf or %NULL on failure
  65  */
  66 struct wpabuf * wpabuf_alloc(size_t len)
  67 {
  68         struct wpabuf *buf = os_zalloc(sizeof(struct wpabuf) + len);
  69         if (buf == NULL)
  70                 return NULL;
  71         buf->size = len;
  72         return buf;
  73 }
  74
  75
  76 struct wpabuf * wpabuf_alloc_ext_data(u8 *data, size_t len)
  77 {
  78         struct wpabuf *buf = os_zalloc(sizeof(struct wpabuf));
  79         if (buf == NULL)
  80                 return NULL;
  81
  82         buf->size = len;
  83         buf->used = len;
  84         buf->ext_data = data;
  85
  86         return buf;
  87 }
  88
  89
  90 struct wpabuf * wpabuf_alloc_copy(const void *data, size_t len)
  91 {
  92         struct wpabuf *buf = wpabuf_alloc(len);
  93         if (buf)
  94                 wpabuf_put_data(buf, data, len);
  95         return buf;
  96 }
  97
  98
  99 struct wpabuf * wpabuf_dup(const struct wpabuf *src)
 100 {
 101         struct wpabuf *buf = wpabuf_alloc(wpabuf_len(src));
 102         if (buf)
 103                 wpabuf_put_data(buf, wpabuf_head(src), wpabuf_len(src));
 104         return buf;
 105 }
 106
 107
 108 /**
 109  * wpabuf_free - Free a wpabuf
 110  * @buf: wpabuf buffer
 111  */
 112 void wpabuf_free(struct wpabuf *buf)
 113 {
 114         if (buf == NULL)
 115                 return;
 116         os_free(buf->ext_data);
 117         os_free(buf);
 118 }
 119
 120
 121 void * wpabuf_put(struct wpabuf *buf, size_t len)
 122 {
 123         void *tmp = wpabuf_mhead_u8(buf) + wpabuf_len(buf);
 124         buf->used += len;
 125         if (buf->used > buf->size) {
 126                 wpabuf_overflow(buf, len);
 127         }
 128         return tmp;
 129 }
 130
 131
 132 /**
 133  * wpabuf_concat - Concatenate two buffers into a newly allocated one
 134  * @a: First buffer
 135  * @b: Second buffer
 136  * Returns: wpabuf with concatenated a + b data or %NULL on failure
 137  *
 138  * Both buffers a and b will be freed regardless of the return value. Input
 139  * buffers can be %NULL which is interpreted as an empty buffer.
 140  */
 141 struct wpabuf * wpabuf_concat(struct wpabuf *a, struct wpabuf *b)
 142 {
 143         struct wpabuf *n = NULL;
 144         size_t len = 0;
 145
 146         if (b == NULL)
 147                 return a;
 148
 149         if (a)
 150                 len += wpabuf_len(a);
 151         if (b)
 152                 len += wpabuf_len(b);
 153
 154         n = wpabuf_alloc(len);
 155         if (n) {
 156                 if (a)
 157                         wpabuf_put_buf(n, a);
 158                 if (b)
 159                         wpabuf_put_buf(n, b);
 160         }
 161
 162         wpabuf_free(a);
 163         wpabuf_free(b);
 164
 165         return n;
 166 }
 167
 168
 169 /**
 170  * wpabuf_zeropad - Pad buffer with 0x00 octets (prefix) to specified length
 171  * @buf: Buffer to be padded
 172  * @len: Length for the padded buffer
 173  * Returns: wpabuf padded to len octets or %NULL on failure
 174  *
 175  * If buf is longer than len octets or of same size, it will be returned as-is.
 176  * Otherwise a new buffer is allocated and prefixed with 0x00 octets followed
 177  * by the source data. The source buffer will be freed on error, i.e., caller
 178  * will only be responsible on freeing the returned buffer. If buf is %NULL,
 179  * %NULL will be returned.
 180  */
 181 struct wpabuf * wpabuf_zeropad(struct wpabuf *buf, size_t len)
 182 {
 183         struct wpabuf *ret;
 184         size_t blen;
 185
 186         if (buf == NULL)
 187                 return NULL;
 188
 189         blen = wpabuf_len(buf);
 190         if (blen >= len)
 191                 return buf;
 192
 193         ret = wpabuf_alloc(len);
 194         if (ret) {
 195                 os_memset(wpabuf_put(ret, len - blen), 0, len - blen);
 196                 wpabuf_put_buf(ret, buf);
 197         }
 198         wpabuf_free(buf);
 199
 200         return ret;
 201 }
 202
 203
 204 void wpabuf_printf(struct wpabuf *buf, char *fmt, ...)
 205 {
 206         va_list ap;
 207         void *tmp = wpabuf_mhead_u8(buf) + wpabuf_len(buf);
 208         int res;
 209
 210         va_start(ap, fmt);
 211         res = vsnprintf(tmp, buf->size - buf->used, fmt, ap);
 212         va_end(ap);
 213         if (res < 0 || (size_t) res >= buf->size - buf->used)
 214                 wpabuf_overflow(buf, res);
 215         buf->used += res;
 216 }