2 * blob - library for generating/parsing tagged binary data
4 * Copyright (C) 2010 Felix Fietkau <nbd@openwrt.org>
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.
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.
22 blob_buffer_grow(struct blob_buf
*buf
, int minlen
)
24 int delta
= ((minlen
/ 256) + 1) * 256;
26 buf
->buf
= realloc(buf
->buf
, buf
->buflen
);
28 memset(buf
->buf
+ buf
->buflen
- delta
, 0, delta
);
33 blob_init(struct blob_attr
*attr
, int id
, unsigned int len
)
35 len
&= BLOB_ATTR_LEN_MASK
;
36 len
|= (id
<< BLOB_ATTR_ID_SHIFT
) & BLOB_ATTR_ID_MASK
;
37 attr
->id_len
= cpu_to_be32(len
);
40 static inline struct blob_attr
*
41 offset_to_attr(struct blob_buf
*buf
, int offset
)
43 void *ptr
= (char *)buf
->buf
+ offset
- BLOB_COOKIE
;
48 attr_to_offset(struct blob_buf
*buf
, struct blob_attr
*attr
)
50 return (char *)attr
- (char *) buf
->buf
+ BLOB_COOKIE
;
54 blob_buf_grow(struct blob_buf
*buf
, int required
)
56 int offset_head
= attr_to_offset(buf
, buf
->head
);
58 if (!buf
->grow
|| !buf
->grow(buf
, required
))
61 buf
->head
= offset_to_attr(buf
, offset_head
);
64 static struct blob_attr
*
65 blob_add(struct blob_buf
*buf
, struct blob_attr
*pos
, int id
, int payload
)
67 int offset
= attr_to_offset(buf
, pos
);
68 int required
= (offset
- BLOB_COOKIE
+ sizeof(struct blob_attr
) + payload
) - buf
->buflen
;
69 struct blob_attr
*attr
;
72 blob_buf_grow(buf
, required
);
73 attr
= offset_to_attr(buf
, offset
);
78 blob_init(attr
, id
, payload
+ sizeof(struct blob_attr
));
84 blob_buf_init(struct blob_buf
*buf
, int id
)
87 buf
->grow
= blob_buffer_grow
;
90 if (blob_add(buf
, buf
->buf
, id
, 0) == NULL
)
97 blob_buf_free(struct blob_buf
*buf
)
105 blob_fill_pad(struct blob_attr
*attr
)
107 char *buf
= (char *) attr
;
108 int len
= blob_pad_len(attr
);
109 int delta
= len
- blob_raw_len(attr
);
112 memset(buf
+ len
- delta
, 0, delta
);
116 blob_set_raw_len(struct blob_attr
*attr
, unsigned int len
)
118 int id
= blob_id(attr
);
119 len
&= BLOB_ATTR_LEN_MASK
;
120 len
|= (id
<< BLOB_ATTR_ID_SHIFT
) & BLOB_ATTR_ID_MASK
;
121 attr
->id_len
= cpu_to_be32(len
);
125 blob_new(struct blob_buf
*buf
, int id
, int payload
)
127 struct blob_attr
*attr
;
129 attr
= blob_add(buf
, blob_next(buf
->head
), id
, payload
);
133 blob_set_raw_len(buf
->head
, blob_pad_len(buf
->head
) + blob_pad_len(attr
));
138 blob_put_raw(struct blob_buf
*buf
, const void *ptr
, int len
)
140 struct blob_attr
*attr
;
142 if (len
< sizeof(struct blob_attr
) || !ptr
)
145 attr
= blob_add(buf
, blob_next(buf
->head
), 0, len
- sizeof(struct blob_attr
));
146 blob_set_raw_len(buf
->head
, blob_pad_len(buf
->head
) + len
);
147 memcpy(attr
, ptr
, len
);
152 blob_put(struct blob_buf
*buf
, int id
, const void *ptr
, int len
)
154 struct blob_attr
*attr
;
156 attr
= blob_new(buf
, id
, len
);
161 memcpy(blob_data(attr
), ptr
, len
);
166 blob_nest_start(struct blob_buf
*buf
, int id
)
168 unsigned long offset
= attr_to_offset(buf
, buf
->head
);
169 buf
->head
= blob_new(buf
, id
, 0);
170 return (void *) offset
;
174 blob_nest_end(struct blob_buf
*buf
, void *cookie
)
176 struct blob_attr
*attr
= offset_to_attr(buf
, (unsigned long) cookie
);
177 blob_set_raw_len(attr
, blob_pad_len(attr
) + blob_len(buf
->head
));
181 static const int blob_type_minlen
[BLOB_ATTR_LAST
] = {
182 [BLOB_ATTR_STRING
] = 1,
183 [BLOB_ATTR_INT8
] = sizeof(uint8_t),
184 [BLOB_ATTR_INT16
] = sizeof(uint16_t),
185 [BLOB_ATTR_INT32
] = sizeof(uint32_t),
186 [BLOB_ATTR_INT64
] = sizeof(uint64_t),
190 blob_check_type(const void *ptr
, int len
, int type
)
192 const char *data
= ptr
;
194 if (type
>= BLOB_ATTR_LAST
)
197 if (type
>= BLOB_ATTR_INT8
&& type
<= BLOB_ATTR_INT64
) {
198 if (len
!= blob_type_minlen
[type
])
201 if (len
< blob_type_minlen
[type
])
205 if (type
== BLOB_ATTR_STRING
&& data
[len
- 1] != 0)
212 blob_parse(struct blob_attr
*attr
, struct blob_attr
**data
, const struct blob_attr_info
*info
, int max
)
214 struct blob_attr
*pos
;
218 memset(data
, 0, sizeof(struct blob_attr
*) * max
);
219 blob_for_each_attr(pos
, attr
, rem
) {
220 int id
= blob_id(pos
);
221 int len
= blob_len(pos
);
227 int type
= info
[id
].type
;
229 if (type
< BLOB_ATTR_LAST
) {
230 if (!blob_check_type(blob_data(pos
), len
, type
))
234 if (info
[id
].minlen
&& len
< info
[id
].minlen
)
237 if (info
[id
].maxlen
&& len
> info
[id
].maxlen
)
240 if (info
[id
].validate
&& !info
[id
].validate(&info
[id
], attr
))
253 blob_attr_equal(const struct blob_attr
*a1
, const struct blob_attr
*a2
)
261 if (blob_pad_len(a1
) != blob_pad_len(a2
))
264 return !memcmp(a1
, a2
, blob_pad_len(a1
));
268 blob_memdup(struct blob_attr
*attr
)
270 struct blob_attr
*ret
;
271 int size
= blob_pad_len(attr
);
277 memcpy(ret
, attr
, size
);