blobmsg.c

   1 /*
   2  * Copyright (C) 2010-2012 Felix Fietkau <nbd@openwrt.org>
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16 #include "blobmsg.h"
  17
  18 static const int blob_type[__BLOBMSG_TYPE_LAST] = {
  19         [BLOBMSG_TYPE_INT8] = BLOB_ATTR_INT8,
  20         [BLOBMSG_TYPE_INT16] = BLOB_ATTR_INT16,
  21         [BLOBMSG_TYPE_INT32] = BLOB_ATTR_INT32,
  22         [BLOBMSG_TYPE_INT64] = BLOB_ATTR_INT64,
  23         [BLOBMSG_TYPE_DOUBLE] = BLOB_ATTR_DOUBLE,
  24         [BLOBMSG_TYPE_STRING] = BLOB_ATTR_STRING,
  25         [BLOBMSG_TYPE_UNSPEC] = BLOB_ATTR_BINARY,
  26 };
  27
  28 static uint16_t
  29 blobmsg_namelen(const struct blobmsg_hdr *hdr)
  30 {
  31         return be16_to_cpu(hdr->namelen);
  32 }
  33
  34 bool blobmsg_check_attr(const struct blob_attr *attr, bool name)
  35 {
  36         return blobmsg_check_attr_len(attr, name, blob_raw_len(attr));
  37 }
  38
  39 static bool blobmsg_check_name(const struct blob_attr *attr, size_t len, bool name)
  40 {
  41         char *limit = (char *) attr + len;
  42         const struct blobmsg_hdr *hdr;
  43
  44         hdr = blob_data(attr);
  45         if (name && !hdr->namelen)
  46                 return false;
  47
  48         if ((char *) hdr->name + blobmsg_namelen(hdr) > limit)
  49                 return false;
  50
  51         if (blobmsg_namelen(hdr) > (blob_len(attr) - sizeof(struct blobmsg_hdr)))
  52                 return false;
  53
  54         if (hdr->name[blobmsg_namelen(hdr)] != 0)
  55                 return false;
  56
  57         return true;
  58 }
  59
  60 static const char* blobmsg_check_data(const struct blob_attr *attr, size_t len, size_t *data_len)
  61 {
  62         char *limit = (char *) attr + len;
  63         const char *data;
  64
  65         *data_len = blobmsg_data_len(attr);
  66         if (*data_len > blob_raw_len(attr))
  67                 return NULL;
  68
  69         data = blobmsg_data(attr);
  70         if (data + *data_len > limit)
  71                 return NULL;
  72
  73         return data;
  74 }
  75
  76 bool blobmsg_check_attr_len(const struct blob_attr *attr, bool name, size_t len)
  77 {
  78         const char *data;
  79         size_t data_len;
  80         int id;
  81
  82         if (len < sizeof(struct blob_attr))
  83                 return false;
  84
  85         if (!blobmsg_check_name(attr, len, name))
  86                 return false;
  87
  88         id = blob_id(attr);
  89         if (id > BLOBMSG_TYPE_LAST)
  90                 return false;
  91
  92         if (!blob_type[id])
  93                 return true;
  94
  95         data = blobmsg_check_data(attr, len, &data_len);
  96         if (!data)
  97                 return false;
  98
  99         return blob_check_type(data, data_len, blob_type[id]);
 100 }
 101
 102 int blobmsg_check_array(const struct blob_attr *attr, int type)
 103 {
 104         struct blob_attr *cur;
 105         bool name;
 106         size_t rem;
 107         int size = 0;
 108
 109         switch (blobmsg_type(attr)) {
 110         case BLOBMSG_TYPE_TABLE:
 111                 name = true;
 112                 break;
 113         case BLOBMSG_TYPE_ARRAY:
 114                 name = false;
 115                 break;
 116         default:
 117                 return -1;
 118         }
 119
 120         blobmsg_for_each_attr(cur, attr, rem) {
 121                 if (type != BLOBMSG_TYPE_UNSPEC && blobmsg_type(cur) != type)
 122                         return -1;
 123
 124                 if (!blobmsg_check_attr(cur, name))
 125                         return -1;
 126
 127                 size++;
 128         }
 129
 130         return size;
 131 }
 132
 133 bool blobmsg_check_attr_list(const struct blob_attr *attr, int type)
 134 {
 135         return blobmsg_check_array(attr, type) >= 0;
 136 }
 137
 138 int blobmsg_parse_array(const struct blobmsg_policy *policy, int policy_len,
 139                         struct blob_attr **tb, void *data, unsigned int len)
 140 {
 141         struct blob_attr *attr;
 142         int i = 0;
 143
 144         memset(tb, 0, policy_len * sizeof(*tb));
 145         __blob_for_each_attr(attr, data, len) {
 146                 if (policy[i].type != BLOBMSG_TYPE_UNSPEC &&
 147                     blob_id(attr) != policy[i].type)
 148                         continue;
 149
 150                 if (!blobmsg_check_attr_len(attr, false, len))
 151                         return -1;
 152
 153                 if (tb[i])
 154                         continue;
 155
 156                 tb[i++] = attr;
 157                 if (i == policy_len)
 158                         break;
 159         }
 160
 161         return 0;
 162 }
 163
 164
 165 int blobmsg_parse(const struct blobmsg_policy *policy, int policy_len,
 166                   struct blob_attr **tb, void *data, unsigned int len)
 167 {
 168         struct blobmsg_hdr *hdr;
 169         struct blob_attr *attr;
 170         uint8_t *pslen;
 171         int i;
 172
 173         memset(tb, 0, policy_len * sizeof(*tb));
 174         if (!data || !len)
 175                 return -EINVAL;
 176         pslen = alloca(policy_len);
 177         for (i = 0; i < policy_len; i++) {
 178                 if (!policy[i].name)
 179                         continue;
 180
 181                 pslen[i] = strlen(policy[i].name);
 182         }
 183
 184         __blob_for_each_attr(attr, data, len) {
 185                 hdr = blob_data(attr);
 186                 for (i = 0; i < policy_len; i++) {
 187                         if (!policy[i].name)
 188                                 continue;
 189
 190                         if (policy[i].type != BLOBMSG_TYPE_UNSPEC &&
 191                             blob_id(attr) != policy[i].type)
 192                                 continue;
 193
 194                         if (blobmsg_namelen(hdr) != pslen[i])
 195                                 continue;
 196
 197                         if (!blobmsg_check_attr_len(attr, true, len))
 198                                 return -1;
 199
 200                         if (tb[i])
 201                                 continue;
 202
 203                         if (strcmp(policy[i].name, (char *) hdr->name) != 0)
 204                                 continue;
 205
 206                         tb[i] = attr;
 207                 }
 208         }
 209
 210         return 0;
 211 }
 212
 213
 214 static struct blob_attr *
 215 blobmsg_new(struct blob_buf *buf, int type, const char *name, int payload_len, void **data)
 216 {
 217         struct blob_attr *attr;
 218         struct blobmsg_hdr *hdr;
 219         int attrlen, namelen;
 220         char *pad_start, *pad_end;
 221
 222         if (!name)
 223                 name = "";
 224
 225         namelen = strlen(name);
 226         attrlen = blobmsg_hdrlen(namelen) + payload_len;
 227         attr = blob_new(buf, type, attrlen);
 228         if (!attr)
 229                 return NULL;
 230
 231         attr->id_len |= be32_to_cpu(BLOB_ATTR_EXTENDED);
 232         hdr = blob_data(attr);
 233         hdr->namelen = cpu_to_be16(namelen);
 234         strcpy((char *) hdr->name, (const char *)name);
 235         pad_end = *data = blobmsg_data(attr);
 236         pad_start = (char *) &hdr->name[namelen];
 237         if (pad_start < pad_end)
 238                 memset(pad_start, 0, pad_end - pad_start);
 239
 240         return attr;
 241 }
 242
 243 static inline int
 244 attr_to_offset(struct blob_buf *buf, struct blob_attr *attr)
 245 {
 246         return (char *)attr - (char *) buf->buf + BLOB_COOKIE;
 247 }
 248
 249
 250 void *
 251 blobmsg_open_nested(struct blob_buf *buf, const char *name, bool array)
 252 {
 253         struct blob_attr *head;
 254         int type = array ? BLOBMSG_TYPE_ARRAY : BLOBMSG_TYPE_TABLE;
 255         unsigned long offset = attr_to_offset(buf, buf->head);
 256         void *data;
 257
 258         if (!name)
 259                 name = "";
 260
 261         head = blobmsg_new(buf, type, name, 0, &data);
 262         if (!head)
 263                 return NULL;
 264         blob_set_raw_len(buf->head, blob_pad_len(buf->head) - blobmsg_hdrlen(strlen(name)));
 265         buf->head = head;
 266         return (void *)offset;
 267 }
 268
 269 __attribute__((format(printf, 3, 0)))
 270 int blobmsg_vprintf(struct blob_buf *buf, const char *name, const char *format, va_list arg)
 271 {
 272         va_list arg2;
 273         char cbuf;
 274         char *sbuf;
 275         int len, ret;
 276
 277         va_copy(arg2, arg);
 278         len = vsnprintf(&cbuf, sizeof(cbuf), format, arg2);
 279         va_end(arg2);
 280
 281         sbuf = blobmsg_alloc_string_buffer(buf, name, len + 1);
 282         if (!sbuf)
 283                 return -1;
 284         ret = vsprintf(sbuf, format, arg);
 285         blobmsg_add_string_buffer(buf);
 286
 287         return ret;
 288 }
 289
 290 __attribute__((format(printf, 3, 4)))
 291 int blobmsg_printf(struct blob_buf *buf, const char *name, const char *format, ...)
 292 {
 293         va_list ap;
 294         int ret;
 295
 296         va_start(ap, format);
 297         ret = blobmsg_vprintf(buf, name, format, ap);
 298         va_end(ap);
 299
 300         return ret;
 301 }
 302
 303 void *
 304 blobmsg_alloc_string_buffer(struct blob_buf *buf, const char *name, unsigned int maxlen)
 305 {
 306         struct blob_attr *attr;
 307         void *data_dest;
 308
 309         attr = blobmsg_new(buf, BLOBMSG_TYPE_STRING, name, maxlen, &data_dest);
 310         if (!attr)
 311                 return NULL;
 312
 313         blob_set_raw_len(buf->head, blob_pad_len(buf->head) - blob_pad_len(attr));
 314         blob_set_raw_len(attr, blob_raw_len(attr) - maxlen);
 315
 316         return data_dest;
 317 }
 318
 319 void *
 320 blobmsg_realloc_string_buffer(struct blob_buf *buf, unsigned int maxlen)
 321 {
 322         struct blob_attr *attr = blob_next(buf->head);
 323         int offset = attr_to_offset(buf, blob_next(buf->head)) + blob_pad_len(attr) - BLOB_COOKIE;
 324         int required = maxlen - (buf->buflen - offset);
 325
 326         if (required <= 0)
 327                 goto out;
 328
 329         if (!blob_buf_grow(buf, required))
 330                 return NULL;
 331         attr = blob_next(buf->head);
 332
 333 out:
 334         return blobmsg_data(attr);
 335 }
 336
 337 void
 338 blobmsg_add_string_buffer(struct blob_buf *buf)
 339 {
 340         struct blob_attr *attr;
 341         int len, attrlen;
 342
 343         attr = blob_next(buf->head);
 344         len = strlen(blobmsg_data(attr)) + 1;
 345
 346         attrlen = blob_raw_len(attr) + len;
 347         blob_set_raw_len(attr, attrlen);
 348         blob_fill_pad(attr);
 349
 350         blob_set_raw_len(buf->head, blob_raw_len(buf->head) + blob_pad_len(attr));
 351 }
 352
 353 int
 354 blobmsg_add_field(struct blob_buf *buf, int type, const char *name,
 355                   const void *data, unsigned int len)
 356 {
 357         struct blob_attr *attr;
 358         void *data_dest;
 359
 360         attr = blobmsg_new(buf, type, name, len, &data_dest);
 361         if (!attr)
 362                 return -1;
 363
 364         if (len > 0)
 365                 memcpy(data_dest, data, len);
 366
 367         return 0;
 368 }