X-Git-Url: http://git.archive.openwrt.org/?p=project%2Flibubox.git;a=blobdiff_plain;f=blob.c;h=ec8617bef8c725c5efae727753d5f4e817ee2bb0;hp=3bd69fac04d43043172b7bd6032dc9529974c049;hb=213122a0830e1ba3a05013b5cb5d17c49af13282;hpb=ec593913f4a5ee31d4a295708ba91beb0d439ffe diff --git a/blob.c b/blob.c index 3bd69fa..ec8617b 100644 --- a/blob.c +++ b/blob.c @@ -3,14 +3,17 @@ * * Copyright (C) 2010 Felix Fietkau * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License version 2.1 - * as published by the Free Software Foundation + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #include "blob.h" @@ -18,9 +21,15 @@ static bool blob_buffer_grow(struct blob_buf *buf, int minlen) { - buf->buflen += ((minlen / 256) + 1) * 256; - buf->buf = realloc(buf->buf, buf->buflen); - return !!buf->buf; + struct blob_buf *new; + int delta = ((minlen / 256) + 1) * 256; + new = realloc(buf->buf, buf->buflen + delta); + if (new) { + buf->buf = new; + memset(buf->buf + buf->buflen, 0, delta); + buf->buflen += delta; + } + return !!new; } static void @@ -34,36 +43,45 @@ blob_init(struct blob_attr *attr, int id, unsigned int len) static inline struct blob_attr * offset_to_attr(struct blob_buf *buf, int offset) { - void *ptr = (char *)buf->buf + offset; + void *ptr = (char *)buf->buf + offset - BLOB_COOKIE; return ptr; } static inline int attr_to_offset(struct blob_buf *buf, struct blob_attr *attr) { - return (char *)attr - (char *) buf->buf; + return (char *)attr - (char *) buf->buf + BLOB_COOKIE; +} + +bool +blob_buf_grow(struct blob_buf *buf, int required) +{ + int offset_head = attr_to_offset(buf, buf->head); + + if (!buf->grow || !buf->grow(buf, required)) + return false; + + buf->head = offset_to_attr(buf, offset_head); + return true; } static struct blob_attr * blob_add(struct blob_buf *buf, struct blob_attr *pos, int id, int payload) { int offset = attr_to_offset(buf, pos); - int required = (offset + sizeof(struct blob_attr) + payload) - buf->buflen; + int required = (offset - BLOB_COOKIE + sizeof(struct blob_attr) + payload) - buf->buflen; struct blob_attr *attr; if (required > 0) { - int offset_head = attr_to_offset(buf, buf->head); - - if (!buf->grow || !buf->grow(buf, required)) + if (!blob_buf_grow(buf, required)) return NULL; - - buf->head = offset_to_attr(buf, offset_head); attr = offset_to_attr(buf, offset); } else { attr = pos; } blob_init(attr, id, payload + sizeof(struct blob_attr)); + blob_fill_pad(attr); return attr; } @@ -80,6 +98,33 @@ blob_buf_init(struct blob_buf *buf, int id) return 0; } +void +blob_buf_free(struct blob_buf *buf) +{ + free(buf->buf); + buf->buf = NULL; + buf->buflen = 0; +} + +void +blob_fill_pad(struct blob_attr *attr) +{ + char *buf = (char *) attr; + int len = blob_pad_len(attr); + int delta = len - blob_raw_len(attr); + + if (delta > 0) + memset(buf + len - delta, 0, delta); +} + +void +blob_set_raw_len(struct blob_attr *attr, unsigned int len) +{ + len &= BLOB_ATTR_LEN_MASK; + attr->id_len &= ~cpu_to_be32(BLOB_ATTR_LEN_MASK); + attr->id_len |= cpu_to_be32(len); +} + struct blob_attr * blob_new(struct blob_buf *buf, int id, int payload) { @@ -94,7 +139,23 @@ blob_new(struct blob_buf *buf, int id, int payload) } struct blob_attr * -blob_put(struct blob_buf *buf, int id, const void *ptr, int len) +blob_put_raw(struct blob_buf *buf, const void *ptr, unsigned int len) +{ + struct blob_attr *attr; + + if (len < sizeof(struct blob_attr) || !ptr) + return NULL; + + attr = blob_add(buf, blob_next(buf->head), 0, len - sizeof(struct blob_attr)); + if (!attr) + return NULL; + blob_set_raw_len(buf->head, blob_pad_len(buf->head) + len); + memcpy(attr, ptr, len); + return attr; +} + +struct blob_attr * +blob_put(struct blob_buf *buf, int id, const void *ptr, unsigned int len) { struct blob_attr *attr; @@ -112,6 +173,8 @@ blob_nest_start(struct blob_buf *buf, int id) { unsigned long offset = attr_to_offset(buf, buf->head); buf->head = blob_new(buf, id, 0); + if (!buf->head) + return NULL; return (void *) offset; } @@ -131,6 +194,28 @@ static const int blob_type_minlen[BLOB_ATTR_LAST] = { [BLOB_ATTR_INT64] = sizeof(uint64_t), }; +bool +blob_check_type(const void *ptr, unsigned int len, int type) +{ + const char *data = ptr; + + if (type >= BLOB_ATTR_LAST) + return false; + + if (type >= BLOB_ATTR_INT8 && type <= BLOB_ATTR_INT64) { + if (len != blob_type_minlen[type]) + return false; + } else { + if (len < blob_type_minlen[type]) + return false; + } + + if (type == BLOB_ATTR_STRING && data[len - 1] != 0) + return false; + + return true; +} + int blob_parse(struct blob_attr *attr, struct blob_attr **data, const struct blob_attr_info *info, int max) { @@ -142,34 +227,25 @@ blob_parse(struct blob_attr *attr, struct blob_attr **data, const struct blob_at blob_for_each_attr(pos, attr, rem) { int id = blob_id(pos); int len = blob_len(pos); - char *pdata; if (id >= max) continue; if (info) { int type = info[id].type; + if (type < BLOB_ATTR_LAST) { - if (type >= BLOB_ATTR_INT8 && type <= BLOB_ATTR_INT64) { - if (len != blob_type_minlen[type]) - continue; - } else { - if (len < blob_type_minlen[type]) - continue; - } + if (!blob_check_type(blob_data(pos), len, type)) + continue; } - pdata = blob_data(pos); - if (type == BLOB_ATTR_STRING && pdata[len] != 0) - continue; - if (info[id].minlen && len < info[id].minlen) continue; if (info[id].maxlen && len > info[id].maxlen) continue; - if (info[id].validate && !info[id].validate(&info[id], attr)) + if (info[id].validate && !info[id].validate(&info[id], pos)) continue; } @@ -180,3 +256,32 @@ blob_parse(struct blob_attr *attr, struct blob_attr **data, const struct blob_at } return found; } + +bool +blob_attr_equal(const struct blob_attr *a1, const struct blob_attr *a2) +{ + if (!a1 && !a2) + return true; + + if (!a1 || !a2) + return false; + + if (blob_pad_len(a1) != blob_pad_len(a2)) + return false; + + return !memcmp(a1, a2, blob_pad_len(a1)); +} + +struct blob_attr * +blob_memdup(struct blob_attr *attr) +{ + struct blob_attr *ret; + int size = blob_pad_len(attr); + + ret = malloc(size); + if (!ret) + return NULL; + + memcpy(ret, attr, size); + return ret; +}