jshn: properly support JSON "null" type
[project/libubox.git] / blobmsg_json.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 <inttypes.h>
17 #include "blobmsg.h"
18 #include "blobmsg_json.h"
19
20 #ifdef JSONC
21 #include <json.h>
22 #else
23 #include <json/json.h>
24 #endif
25
26 bool blobmsg_add_object(struct blob_buf *b, json_object *obj)
27 {
28 json_object_object_foreach(obj, key, val) {
29 if (!blobmsg_add_json_element(b, key, val))
30 return false;
31 }
32 return true;
33 }
34
35 static bool blobmsg_add_array(struct blob_buf *b, struct array_list *a)
36 {
37 int i, len;
38
39 for (i = 0, len = array_list_length(a); i < len; i++) {
40 if (!blobmsg_add_json_element(b, NULL, array_list_get_idx(a, i)))
41 return false;
42 }
43
44 return true;
45 }
46
47 bool blobmsg_add_json_element(struct blob_buf *b, const char *name, json_object *obj)
48 {
49 bool ret = true;
50 void *c;
51
52 switch (json_object_get_type(obj)) {
53 case json_type_object:
54 c = blobmsg_open_table(b, name);
55 ret = blobmsg_add_object(b, obj);
56 blobmsg_close_table(b, c);
57 break;
58 case json_type_array:
59 c = blobmsg_open_array(b, name);
60 ret = blobmsg_add_array(b, json_object_get_array(obj));
61 blobmsg_close_array(b, c);
62 break;
63 case json_type_string:
64 blobmsg_add_string(b, name, json_object_get_string(obj));
65 break;
66 case json_type_boolean:
67 blobmsg_add_u8(b, name, json_object_get_boolean(obj));
68 break;
69 case json_type_int:
70 blobmsg_add_u32(b, name, json_object_get_int(obj));
71 break;
72 case json_type_double:
73 blobmsg_add_double(b, name, json_object_get_double(obj));
74 break;
75 case json_type_null:
76 blobmsg_add_field(b, BLOBMSG_TYPE_UNSPEC, name, NULL, 0);
77 break;
78 default:
79 return false;
80 }
81 return ret;
82 }
83
84 static bool __blobmsg_add_json(struct blob_buf *b, json_object *obj)
85 {
86 bool ret = false;
87
88 if (!obj)
89 return false;
90
91 if (json_object_get_type(obj) != json_type_object)
92 goto out;
93
94 ret = blobmsg_add_object(b, obj);
95
96 out:
97 json_object_put(obj);
98 return ret;
99 }
100
101 bool blobmsg_add_json_from_file(struct blob_buf *b, const char *file)
102 {
103 return __blobmsg_add_json(b, json_object_from_file(file));
104 }
105
106 bool blobmsg_add_json_from_string(struct blob_buf *b, const char *str)
107 {
108 return __blobmsg_add_json(b, json_tokener_parse(str));
109 }
110
111
112 struct strbuf {
113 int len;
114 int pos;
115 char *buf;
116
117 blobmsg_json_format_t custom_format;
118 void *priv;
119 bool indent;
120 int indent_level;
121 };
122
123 static bool blobmsg_puts(struct strbuf *s, const char *c, int len)
124 {
125 size_t new_len;
126 char *new_buf;
127
128 if (len <= 0)
129 return true;
130
131 if (s->pos + len >= s->len) {
132 new_len = s->len + 16 + len;
133 new_buf = realloc(s->buf, new_len);
134 if (!new_buf)
135 return false;
136
137 s->len = new_len;
138 s->buf = new_buf;
139 }
140
141 memcpy(s->buf + s->pos, c, len);
142 s->pos += len;
143 return true;
144 }
145
146 static void add_separator(struct strbuf *s)
147 {
148 const char *indent_chars = "\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t";
149 int len;
150
151 if (!s->indent)
152 return;
153
154 len = s->indent_level + 1;
155 if (len > strlen(indent_chars))
156 len = strlen(indent_chars);
157
158 blobmsg_puts(s, indent_chars, len);
159 }
160
161
162 static void blobmsg_format_string(struct strbuf *s, const char *str)
163 {
164 const unsigned char *p, *last, *end;
165 char buf[8] = "\\u00";
166
167 end = (unsigned char *) str + strlen(str);
168 blobmsg_puts(s, "\"", 1);
169 for (p = (unsigned char *) str, last = p; *p; p++) {
170 char escape = '\0';
171 int len;
172
173 switch(*p) {
174 case '\b':
175 escape = 'b';
176 break;
177 case '\n':
178 escape = 'n';
179 break;
180 case '\t':
181 escape = 't';
182 break;
183 case '\r':
184 escape = 'r';
185 break;
186 case '"':
187 case '\\':
188 case '/':
189 escape = *p;
190 break;
191 default:
192 if (*p < ' ')
193 escape = 'u';
194 break;
195 }
196
197 if (!escape)
198 continue;
199
200 if (p > last)
201 blobmsg_puts(s, (char *) last, p - last);
202 last = p + 1;
203 buf[1] = escape;
204
205 if (escape == 'u') {
206 sprintf(buf + 4, "%02x", (unsigned char) *p);
207 len = 6;
208 } else {
209 len = 2;
210 }
211 blobmsg_puts(s, buf, len);
212 }
213
214 blobmsg_puts(s, (char *) last, end - last);
215 blobmsg_puts(s, "\"", 1);
216 }
217
218 static void blobmsg_format_json_list(struct strbuf *s, struct blob_attr *attr, int len, bool array);
219
220 static void blobmsg_format_element(struct strbuf *s, struct blob_attr *attr, bool without_name, bool head)
221 {
222 const char *data_str;
223 char buf[32];
224 void *data;
225 int len;
226
227 if (!blobmsg_check_attr(attr, false))
228 return;
229
230 if (!without_name && blobmsg_name(attr)[0]) {
231 blobmsg_format_string(s, blobmsg_name(attr));
232 blobmsg_puts(s, ": ", s->indent ? 2 : 1);
233 }
234
235 data = blobmsg_data(attr);
236 len = blobmsg_data_len(attr);
237
238 if (!head && s->custom_format) {
239 data_str = s->custom_format(s->priv, attr);
240 if (data_str)
241 goto out;
242 }
243
244 data_str = buf;
245 switch(blob_id(attr)) {
246 case BLOBMSG_TYPE_UNSPEC:
247 sprintf(buf, "null");
248 break;
249 case BLOBMSG_TYPE_BOOL:
250 sprintf(buf, "%s", *(uint8_t *)data ? "true" : "false");
251 break;
252 case BLOBMSG_TYPE_INT16:
253 sprintf(buf, "%d", be16_to_cpu(*(uint16_t *)data));
254 break;
255 case BLOBMSG_TYPE_INT32:
256 sprintf(buf, "%d", (int32_t) be32_to_cpu(*(uint32_t *)data));
257 break;
258 case BLOBMSG_TYPE_INT64:
259 sprintf(buf, "%" PRId64, (int64_t) be64_to_cpu(*(uint64_t *)data));
260 break;
261 case BLOBMSG_TYPE_DOUBLE:
262 sprintf(buf, "%lf", blobmsg_get_double(attr));
263 break;
264 case BLOBMSG_TYPE_STRING:
265 blobmsg_format_string(s, data);
266 return;
267 case BLOBMSG_TYPE_ARRAY:
268 blobmsg_format_json_list(s, data, len, true);
269 return;
270 case BLOBMSG_TYPE_TABLE:
271 blobmsg_format_json_list(s, data, len, false);
272 return;
273 }
274
275 out:
276 blobmsg_puts(s, data_str, strlen(data_str));
277 }
278
279 static void blobmsg_format_json_list(struct strbuf *s, struct blob_attr *attr, int len, bool array)
280 {
281 struct blob_attr *pos;
282 bool first = true;
283 int rem = len;
284
285 blobmsg_puts(s, (array ? "[" : "{" ), 1);
286 s->indent_level++;
287 add_separator(s);
288 __blob_for_each_attr(pos, attr, rem) {
289 if (!first) {
290 blobmsg_puts(s, ",", 1);
291 add_separator(s);
292 }
293
294 blobmsg_format_element(s, pos, array, false);
295 first = false;
296 }
297 s->indent_level--;
298 add_separator(s);
299 blobmsg_puts(s, (array ? "]" : "}"), 1);
300 }
301
302 static void setup_strbuf(struct strbuf *s, struct blob_attr *attr, blobmsg_json_format_t cb, void *priv, int indent)
303 {
304 s->len = blob_len(attr);
305 s->buf = malloc(s->len);
306 s->pos = 0;
307 s->custom_format = cb;
308 s->priv = priv;
309 s->indent = false;
310
311 if (indent >= 0) {
312 s->indent = true;
313 s->indent_level = indent;
314 }
315 }
316
317 char *blobmsg_format_json_with_cb(struct blob_attr *attr, bool list, blobmsg_json_format_t cb, void *priv, int indent)
318 {
319 struct strbuf s;
320 bool array;
321 char *ret;
322
323 setup_strbuf(&s, attr, cb, priv, indent);
324 if (!s.buf)
325 return NULL;
326
327 array = blob_is_extended(attr) &&
328 blobmsg_type(attr) == BLOBMSG_TYPE_ARRAY;
329
330 if (list)
331 blobmsg_format_json_list(&s, blobmsg_data(attr), blobmsg_data_len(attr), array);
332 else
333 blobmsg_format_element(&s, attr, false, false);
334
335 if (!s.len) {
336 free(s.buf);
337 return NULL;
338 }
339
340 ret = realloc(s.buf, s.pos + 1);
341 if (!ret) {
342 free(s.buf);
343 return NULL;
344 }
345
346 ret[s.pos] = 0;
347
348 return ret;
349 }
350
351 char *blobmsg_format_json_value_with_cb(struct blob_attr *attr, blobmsg_json_format_t cb, void *priv, int indent)
352 {
353 struct strbuf s;
354 char *ret;
355
356 setup_strbuf(&s, attr, cb, priv, indent);
357 if (!s.buf)
358 return NULL;
359
360 blobmsg_format_element(&s, attr, true, false);
361
362 if (!s.len) {
363 free(s.buf);
364 return NULL;
365 }
366
367 ret = realloc(s.buf, s.pos + 1);
368 if (!ret) {
369 free(s.buf);
370 return NULL;
371 }
372
373 ret[s.pos] = 0;
374
375 return ret;
376 }