blob.c

   1 /*
   2  * blob - library for generating/parsing tagged binary data
   3  *
   4  * Copyright (C) 2010 Felix Fietkau <nbd@openwrt.org>
   5  *
   6  * Permission to use, copy, modify, and/or distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18
  19 #include "blob.h"
  20
  21 static bool
  22 blob_buffer_grow(struct blob_buf *buf, int minlen)
  23 {
  24         struct blob_buf *new;
  25         int delta = ((minlen / 256) + 1) * 256;
  26         new = realloc(buf->buf, buf->buflen + delta);
  27         if (new) {
  28                 buf->buf = new;
  29                 memset(buf->buf + buf->buflen, 0, delta);
  30                 buf->buflen += delta;
  31         }
  32         return !!new;
  33 }
  34
  35 static void
  36 blob_init(struct blob_attr *attr, int id, unsigned int len)
  37 {
  38         len &= BLOB_ATTR_LEN_MASK;
  39         len |= (id << BLOB_ATTR_ID_SHIFT) & BLOB_ATTR_ID_MASK;
  40         attr->id_len = cpu_to_be32(len);
  41 }
  42
  43 static inline struct blob_attr *
  44 offset_to_attr(struct blob_buf *buf, int offset)
  45 {
  46         void *ptr = (char *)buf->buf + offset - BLOB_COOKIE;
  47         return ptr;
  48 }
  49
  50 static inline int
  51 attr_to_offset(struct blob_buf *buf, struct blob_attr *attr)
  52 {
  53         return (char *)attr - (char *) buf->buf + BLOB_COOKIE;
  54 }
  55
  56 bool
  57 blob_buf_grow(struct blob_buf *buf, int required)
  58 {
  59         int offset_head = attr_to_offset(buf, buf->head);
  60
  61         if (!buf->grow || !buf->grow(buf, required))
  62                 return false;
  63
  64         buf->head = offset_to_attr(buf, offset_head);
  65         return true;
  66 }
  67
  68 static struct blob_attr *
  69 blob_add(struct blob_buf *buf, struct blob_attr *pos, int id, int payload)
  70 {
  71         int offset = attr_to_offset(buf, pos);
  72         int required = (offset - BLOB_COOKIE + sizeof(struct blob_attr) + payload) - buf->buflen;
  73         struct blob_attr *attr;
  74
  75         if (required > 0) {
  76                 if (!blob_buf_grow(buf, required))
  77                         return NULL;
  78                 attr = offset_to_attr(buf, offset);
  79         } else {
  80                 attr = pos;
  81         }
  82
  83         blob_init(attr, id, payload + sizeof(struct blob_attr));
  84         blob_fill_pad(attr);
  85         return attr;
  86 }
  87
  88 int
  89 blob_buf_init(struct blob_buf *buf, int id)
  90 {
  91         if (!buf->grow)
  92                 buf->grow = blob_buffer_grow;
  93
  94         buf->head = buf->buf;
  95         if (blob_add(buf, buf->buf, id, 0) == NULL)
  96                 return -ENOMEM;
  97
  98         return 0;
  99 }
 100
 101 void
 102 blob_buf_free(struct blob_buf *buf)
 103 {
 104         free(buf->buf);
 105         buf->buf = NULL;
 106         buf->buflen = 0;
 107 }
 108
 109 void
 110 blob_fill_pad(struct blob_attr *attr)
 111 {
 112         char *buf = (char *) attr;
 113         int len = blob_pad_len(attr);
 114         int delta = len - blob_raw_len(attr);
 115
 116         if (delta > 0)
 117                 memset(buf + len - delta, 0, delta);
 118 }
 119
 120 void
 121 blob_set_raw_len(struct blob_attr *attr, unsigned int len)
 122 {
 123         len &= BLOB_ATTR_LEN_MASK;
 124         attr->id_len &= ~cpu_to_be32(BLOB_ATTR_LEN_MASK);
 125         attr->id_len |= cpu_to_be32(len);
 126 }
 127
 128 struct blob_attr *
 129 blob_new(struct blob_buf *buf, int id, int payload)
 130 {
 131         struct blob_attr *attr;
 132
 133         attr = blob_add(buf, blob_next(buf->head), id, payload);
 134         if (!attr)
 135                 return NULL;
 136
 137         blob_set_raw_len(buf->head, blob_pad_len(buf->head) + blob_pad_len(attr));
 138         return attr;
 139 }
 140
 141 struct blob_attr *
 142 blob_put_raw(struct blob_buf *buf, const void *ptr, unsigned int len)
 143 {
 144         struct blob_attr *attr;
 145
 146         if (len < sizeof(struct blob_attr) || !ptr)
 147                 return NULL;
 148
 149         attr = blob_add(buf, blob_next(buf->head), 0, len - sizeof(struct blob_attr));
 150         if (!attr)
 151                 return NULL;
 152         blob_set_raw_len(buf->head, blob_pad_len(buf->head) + len);
 153         memcpy(attr, ptr, len);
 154         return attr;
 155 }
 156
 157 struct blob_attr *
 158 blob_put(struct blob_buf *buf, int id, const void *ptr, unsigned int len)
 159 {
 160         struct blob_attr *attr;
 161
 162         attr = blob_new(buf, id, len);
 163         if (!attr)
 164                 return NULL;
 165
 166         if (ptr)
 167                 memcpy(blob_data(attr), ptr, len);
 168         return attr;
 169 }
 170
 171 void *
 172 blob_nest_start(struct blob_buf *buf, int id)
 173 {
 174         unsigned long offset = attr_to_offset(buf, buf->head);
 175         buf->head = blob_new(buf, id, 0);
 176         if (!buf->head)
 177                 return NULL;
 178         return (void *) offset;
 179 }
 180
 181 void
 182 blob_nest_end(struct blob_buf *buf, void *cookie)
 183 {
 184         struct blob_attr *attr = offset_to_attr(buf, (unsigned long) cookie);
 185         blob_set_raw_len(attr, blob_pad_len(attr) + blob_len(buf->head));
 186         buf->head = attr;
 187 }
 188
 189 static const int blob_type_minlen[BLOB_ATTR_LAST] = {
 190         [BLOB_ATTR_STRING] = 1,
 191         [BLOB_ATTR_INT8] = sizeof(uint8_t),
 192         [BLOB_ATTR_INT16] = sizeof(uint16_t),
 193         [BLOB_ATTR_INT32] = sizeof(uint32_t),
 194         [BLOB_ATTR_INT64] = sizeof(uint64_t),
 195 };
 196
 197 bool
 198 blob_check_type(const void *ptr, unsigned int len, int type)
 199 {
 200         const char *data = ptr;
 201
 202         if (type >= BLOB_ATTR_LAST)
 203                 return false;
 204
 205         if (type >= BLOB_ATTR_INT8 && type <= BLOB_ATTR_INT64) {
 206                 if (len != blob_type_minlen[type])
 207                         return false;
 208         } else {
 209                 if (len < blob_type_minlen[type])
 210                         return false;
 211         }
 212
 213         if (type == BLOB_ATTR_STRING && data[len - 1] != 0)
 214                 return false;
 215
 216         return true;
 217 }
 218
 219 int
 220 blob_parse(struct blob_attr *attr, struct blob_attr **data, const struct blob_attr_info *info, int max)
 221 {
 222         struct blob_attr *pos;
 223         int found = 0;
 224         int rem;
 225
 226         memset(data, 0, sizeof(struct blob_attr *) * max);
 227         blob_for_each_attr(pos, attr, rem) {
 228                 int id = blob_id(pos);
 229                 int len = blob_len(pos);
 230
 231                 if (id >= max)
 232                         continue;
 233
 234                 if (info) {
 235                         int type = info[id].type;
 236
 237                         if (type < BLOB_ATTR_LAST) {
 238                                 if (!blob_check_type(blob_data(pos), len, type))
 239                                         continue;
 240                         }
 241
 242                         if (info[id].minlen && len < info[id].minlen)
 243                                 continue;
 244
 245                         if (info[id].maxlen && len > info[id].maxlen)
 246                                 continue;
 247
 248                         if (info[id].validate && !info[id].validate(&info[id], pos))
 249                                 continue;
 250                 }
 251
 252                 if (!data[id])
 253                         found++;
 254
 255                 data[id] = pos;
 256         }
 257         return found;
 258 }
 259
 260 bool
 261 blob_attr_equal(const struct blob_attr *a1, const struct blob_attr *a2)
 262 {
 263         if (!a1 && !a2)
 264                 return true;
 265
 266         if (!a1 || !a2)
 267                 return false;
 268
 269         if (blob_pad_len(a1) != blob_pad_len(a2))
 270                 return false;
 271
 272         return !memcmp(a1, a2, blob_pad_len(a1));
 273 }
 274
 275 struct blob_attr *
 276 blob_memdup(struct blob_attr *attr)
 277 {
 278         struct blob_attr *ret;
 279         int size = blob_pad_len(attr);
 280
 281         ret = malloc(size);
 282         if (!ret)
 283                 return NULL;
 284
 285         memcpy(ret, attr, size);
 286         return ret;
 287 }