823eb2446903d8f499fce8a5c653e55f976dda34
[project/libubox.git] / blob.c
1 /*
2  * blob - library for generating/parsing tagged binary data
3  *
4  * Copyright (C) 2010 Felix Fietkau <nbd@openwrt.org>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU Lesser General Public License version 2.1
8  * as published by the Free Software Foundation
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  */
15
16 #include "blob.h"
17
18 static bool
19 blob_buffer_grow(struct blob_buf *buf, int minlen)
20 {
21         buf->buflen += ((minlen / 256) + 1) * 256;
22         buf->buf = realloc(buf->buf, buf->buflen);
23         return !!buf->buf;
24 }
25
26 static void
27 blob_init(struct blob_attr *attr, int id, unsigned int len)
28 {
29         len &= BLOB_ATTR_LEN_MASK;
30         len |= (id << BLOB_ATTR_ID_SHIFT) & BLOB_ATTR_ID_MASK;
31         attr->id_len = cpu_to_be32(len);
32 }
33
34 static inline struct blob_attr *
35 offset_to_attr(struct blob_buf *buf, int offset)
36 {
37         void *ptr = (char *)buf->buf + offset;
38         return ptr;
39 }
40
41 static inline int
42 attr_to_offset(struct blob_buf *buf, struct blob_attr *attr)
43 {
44         return (char *)attr - (char *) buf->buf;
45 }
46
47 static struct blob_attr *
48 blob_add(struct blob_buf *buf, struct blob_attr *pos, int id, int payload)
49 {
50         int offset = attr_to_offset(buf, pos);
51         int required = (offset + sizeof(struct blob_attr) + payload) - buf->buflen;
52         struct blob_attr *attr;
53
54         if (required > 0) {
55                 int offset_head = attr_to_offset(buf, buf->head);
56
57                 if (!buf->grow || !buf->grow(buf, required))
58                         return NULL;
59
60                 buf->head = offset_to_attr(buf, offset_head);
61                 attr = offset_to_attr(buf, offset);
62         } else {
63                 attr = pos;
64         }
65
66         blob_init(attr, id, payload + sizeof(struct blob_attr));
67         return attr;
68 }
69
70 int
71 blob_buf_init(struct blob_buf *buf, int id)
72 {
73         if (!buf->grow)
74                 buf->grow = blob_buffer_grow;
75
76         buf->head = buf->buf;
77         if (blob_add(buf, buf->buf, id, 0) == NULL)
78                 return -ENOMEM;
79
80         return 0;
81 }
82
83 struct blob_attr *
84 blob_new(struct blob_buf *buf, int id, int payload)
85 {
86         struct blob_attr *attr;
87
88         attr = blob_add(buf, blob_next(buf->head), id, payload);
89         if (!attr)
90                 return NULL;
91
92         blob_set_raw_len(buf->head, blob_pad_len(buf->head) + blob_pad_len(attr));
93         return attr;
94 }
95
96 struct blob_attr *
97 blob_put(struct blob_buf *buf, int id, const void *ptr, int len)
98 {
99         struct blob_attr *attr;
100
101         attr = blob_new(buf, id, len);
102         if (!attr)
103                 return NULL;
104
105         if (ptr)
106                 memcpy(blob_data(attr), ptr, len);
107         return attr;
108 }
109
110 void *
111 blob_nest_start(struct blob_buf *buf, int id)
112 {
113         unsigned long offset = attr_to_offset(buf, buf->head);
114         buf->head = blob_new(buf, id, 0);
115         return (void *) offset;
116 }
117
118 void
119 blob_nest_end(struct blob_buf *buf, void *cookie)
120 {
121         struct blob_attr *attr = offset_to_attr(buf, (unsigned long) cookie);
122         blob_set_raw_len(attr, blob_pad_len(attr) + blob_len(buf->head));
123         buf->head = attr;
124 }
125
126 static const int blob_type_minlen[BLOB_ATTR_LAST] = {
127         [BLOB_ATTR_STRING] = 1,
128         [BLOB_ATTR_INT8] = sizeof(uint8_t),
129         [BLOB_ATTR_INT16] = sizeof(uint16_t),
130         [BLOB_ATTR_INT32] = sizeof(uint32_t),
131         [BLOB_ATTR_INT64] = sizeof(uint64_t),
132 };
133
134 int
135 blob_parse(struct blob_attr *attr, struct blob_attr **data, struct blob_attr_info *info, int max)
136 {
137         struct blob_attr *pos;
138         int found = 0;
139         int rem;
140
141         memset(data, 0, sizeof(struct blob_attr *) * max);
142         blob_for_each_attr(pos, attr, rem) {
143                 int id = blob_id(pos);
144                 int len = blob_len(pos);
145
146                 if (id >= max)
147                         continue;
148
149                 if (info) {
150                         int type = info[id].type;
151                         if (type < BLOB_ATTR_LAST) {
152                                 if (type >= BLOB_ATTR_INT8 && type <= BLOB_ATTR_INT64) {
153                                         if (len != blob_type_minlen[type])
154                                                 continue;
155                                 } else {
156                                         if (len < blob_type_minlen[type])
157                                                 continue;
158                                 }
159                         }
160
161                         if (info[id].minlen && len < info[id].minlen)
162                                 continue;
163
164                         if (info[id].maxlen && len > info[id].maxlen)
165                                 continue;
166
167                         if (info[id].validate && !info[id].validate(&info[id], attr))
168                                 continue;
169                 }
170
171                 if (!data[id])
172                         found++;
173
174                 data[id] = pos;
175         }
176         return found;
177 }