utils: ensure that byte-order conversion functions evaluate the argument only once
[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 }