edffcc9451b7d011128c8ddaae624ac20e296758
[asterisk/asterisk.git] / main / json.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2012 - 2013, Digium, Inc.
5  *
6  * David M. Lee, II <dlee@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! \file
20  *
21  * \brief JSON abstraction layer.
22  *
23  * This is a very thin wrapper around the Jansson API. For more details on it, see its
24  * docs at http://www.digip.org/jansson/doc/2.4/apiref.html.
25  *
26  * \author David M. Lee, II <dlee@digium.com>
27  */
28
29 /*** MODULEINFO
30         <support_level>core</support_level>
31  ***/
32
33 #include "asterisk.h"
34
35 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
36
37 #include "asterisk/json.h"
38 #include "asterisk/module.h"
39 #include "asterisk/utils.h"
40
41 #include <jansson.h>
42
43 /*!
44  * \brief Function wrapper around ast_malloc macro.
45  */
46 static void *json_malloc(size_t size)
47 {
48         return ast_malloc(size);
49 }
50
51 /*!
52  * \brief Function wrapper around ast_free macro.
53  */
54 static void json_free(void *p)
55 {
56         ast_free(p);
57 }
58
59 void ast_json_set_alloc_funcs(void *(*malloc_fn)(size_t), void (*free_fn)(void*))
60 {
61         json_set_alloc_funcs(malloc_fn, free_fn);
62 }
63
64 void ast_json_reset_alloc_funcs(void)
65 {
66         json_set_alloc_funcs(json_malloc, json_free);
67 }
68
69 struct ast_json *ast_json_ref(struct ast_json *json)
70 {
71         json_incref((json_t *)json);
72         return json;
73 }
74
75 void ast_json_unref(struct ast_json *json)
76 {
77         json_decref((json_t *)json);
78 }
79
80 enum ast_json_type ast_json_typeof(const struct ast_json *json)
81 {
82         int r = json_typeof((json_t*)json);
83         switch(r) {
84         case JSON_OBJECT: return AST_JSON_OBJECT;
85         case JSON_ARRAY: return AST_JSON_ARRAY;
86         case JSON_STRING: return AST_JSON_STRING;
87         case JSON_INTEGER: return AST_JSON_INTEGER;
88         case JSON_REAL: return AST_JSON_REAL;
89         case JSON_TRUE: return AST_JSON_TRUE;
90         case JSON_FALSE: return AST_JSON_FALSE;
91         case JSON_NULL: return AST_JSON_NULL;
92         }
93         ast_assert(0); /* Unexpect return from json_typeof */
94         return r;
95 }
96
97 struct ast_json *ast_json_true(void)
98 {
99         return (struct ast_json *)json_true();
100 }
101
102 struct ast_json *ast_json_false(void)
103 {
104         return (struct ast_json *)json_false();
105 }
106
107 struct ast_json *ast_json_boolean(int value)
108 {
109 #if JANSSON_VERSION_HEX >= 0x020400
110         return (struct ast_json *)json_boolean(value);
111 #else
112         return value ? ast_json_true() : ast_json_false();
113 #endif
114 }
115
116 struct ast_json *ast_json_null(void)
117 {
118         return (struct ast_json *)json_null();
119 }
120
121 int ast_json_is_true(const struct ast_json *json)
122 {
123         return json_is_true((const json_t *)json);
124 }
125
126 int ast_json_is_false(const struct ast_json *json)
127 {
128         return json_is_false((const json_t *)json);
129 }
130
131 int ast_json_is_null(const struct ast_json *json)
132 {
133         return json_is_null((const json_t *)json);
134 }
135
136 struct ast_json *ast_json_string_create(const char *value)
137 {
138         return (struct ast_json *)json_string(value);
139 }
140
141 const char *ast_json_string_get(const struct ast_json *string)
142 {
143         return json_string_value((json_t *)string);
144 }
145
146 int ast_json_string_set(struct ast_json *string, const char *value)
147 {
148         return json_string_set((json_t *)string, value);
149 }
150
151 struct ast_json *ast_json_stringf(const char *format, ...)
152 {
153         struct ast_json *ret;
154         va_list args;
155         va_start(args, format);
156         ret = ast_json_vstringf(format, args);
157         va_end(args);
158         return ret;
159 }
160
161 struct ast_json *ast_json_vstringf(const char *format, va_list args)
162 {
163         char *str = NULL;
164         json_t *ret = NULL;
165
166         if (format) {
167                 int err = vasprintf(&str, format, args);
168                 if (err > 0) {
169                         ret = json_string(str);
170                         free(str);
171                 }
172         }
173         return (struct ast_json *)ret;
174 }
175
176 struct ast_json *ast_json_integer_create(intmax_t value)
177 {
178         return (struct ast_json *)json_integer(value);
179 }
180
181 intmax_t ast_json_integer_get(const struct ast_json *integer)
182 {
183         return json_integer_value((json_t *)integer);
184 }
185
186 int ast_json_integer_set(struct ast_json *integer, intmax_t value)
187 {
188         return json_integer_set((json_t *)integer, value);
189 }
190
191
192 int ast_json_equal(const struct ast_json *lhs, const struct ast_json *rhs)
193 {
194         return json_equal((json_t *)lhs, (json_t *)rhs);
195 }
196
197 struct ast_json *ast_json_array_create(void)
198 {
199         return (struct ast_json *)json_array();
200 }
201 size_t ast_json_array_size(const struct ast_json *array)
202 {
203         return json_array_size((json_t *)array);
204 }
205 struct ast_json *ast_json_array_get(const struct ast_json *array, size_t index)
206 {
207         return (struct ast_json *)json_array_get((json_t *)array, index);
208 }
209 int ast_json_array_set(struct ast_json *array, size_t index, struct ast_json *value)
210 {
211         return json_array_set_new((json_t *)array, index, (json_t *)value);
212 }
213 int ast_json_array_append(struct ast_json *array, struct ast_json *value)
214 {
215         return json_array_append_new((json_t *)array, (json_t *)value);
216 }
217 int ast_json_array_insert(struct ast_json *array, size_t index, struct ast_json *value)
218 {
219         return json_array_insert_new((json_t *)array, index, (json_t *)value);
220 }
221 int ast_json_array_remove(struct ast_json *array, size_t index)
222 {
223         return json_array_remove((json_t *)array, index);
224 }
225 int ast_json_array_clear(struct ast_json *array)
226 {
227         return json_array_clear((json_t *)array);
228 }
229 int ast_json_array_extend(struct ast_json *array, struct ast_json *tail)
230 {
231         return json_array_extend((json_t *)array, (json_t *)tail);
232 }
233
234 struct ast_json *ast_json_object_create(void)
235 {
236         return (struct ast_json *)json_object();
237 }
238 size_t ast_json_object_size(struct ast_json *object)
239 {
240         return json_object_size((json_t *)object);
241 }
242 struct ast_json *ast_json_object_get(struct ast_json *object, const char *key)
243 {
244         if (!key) {
245                 return NULL;
246         }
247         return (struct ast_json *)json_object_get((json_t *)object, key);
248 }
249 int ast_json_object_set(struct ast_json *object, const char *key, struct ast_json *value)
250 {
251         return json_object_set_new((json_t *)object, key, (json_t *)value);
252 }
253 int ast_json_object_del(struct ast_json *object, const char *key)
254 {
255         return json_object_del((json_t *)object, key);
256 }
257 int ast_json_object_clear(struct ast_json *object)
258 {
259         return json_object_clear((json_t *)object);
260 }
261 int ast_json_object_update(struct ast_json *object, struct ast_json *other)
262 {
263         return json_object_update((json_t *)object, (json_t *)other);
264 }
265 int ast_json_object_update_existing(struct ast_json *object, struct ast_json *other)
266 {
267 #if JANSSON_VERSION_HEX >= 0x020300
268         return json_object_update_existing((json_t *)object, (json_t *)other);
269 #else
270         struct ast_json_iter *iter = ast_json_object_iter(other);
271         int ret = 0;
272
273         if (object == NULL || other == NULL) {
274                 return -1;
275         }
276
277         while (iter != NULL && ret == 0) {
278                 const char *key = ast_json_object_iter_key(iter);
279                 if (ast_json_object_get(object, key) != NULL) {
280                         ret = ast_json_object_set(object, key, ast_json_object_iter_value(iter));
281                 }
282                 iter = ast_json_object_iter_next(other, iter);
283         }
284         return ret;
285 #endif
286 }
287 int ast_json_object_update_missing(struct ast_json *object, struct ast_json *other)
288 {
289 #if JANSSON_VERSION_HEX >= 0x020300
290         return json_object_update_missing((json_t *)object, (json_t *)other);
291 #else
292         struct ast_json_iter *iter = ast_json_object_iter(other);
293         int ret = 0;
294
295         if (object == NULL || other == NULL) {
296                 return -1;
297         }
298
299         while (iter != NULL && ret == 0) {
300                 const char *key = ast_json_object_iter_key(iter);
301                 if (ast_json_object_get(object, key) == NULL) {
302                         ret = ast_json_object_set(object, key, ast_json_object_iter_value(iter));
303                 }
304                 iter = ast_json_object_iter_next(other, iter);
305         }
306         return ret;
307 #endif
308 }
309
310 struct ast_json_iter *ast_json_object_iter(struct ast_json *object)
311 {
312         return json_object_iter((json_t *)object);
313 }
314 struct ast_json_iter *ast_json_object_iter_at(struct ast_json *object, const char *key)
315 {
316         return json_object_iter_at((json_t *)object, key);
317 }
318 struct ast_json_iter *ast_json_object_iter_next(struct ast_json *object, struct ast_json_iter *iter)
319 {
320         return json_object_iter_next((json_t *)object, iter);
321 }
322 const char *ast_json_object_iter_key(struct ast_json_iter *iter)
323 {
324         return json_object_iter_key(iter);
325 }
326 struct ast_json *ast_json_object_iter_value(struct ast_json_iter *iter)
327 {
328         return (struct ast_json *)json_object_iter_value(iter);
329 }
330 int ast_json_object_iter_set(struct ast_json *object, struct ast_json_iter *iter, struct ast_json *value)
331 {
332         return json_object_iter_set_new((json_t *)object, iter, (json_t *)value);
333 }
334
335 /*!
336  * \brief Default flags for JSON encoding.
337  */
338 static size_t dump_flags(void)
339 {
340         /* There's a chance this could become a runtime flag */
341         int flags = JSON_COMPACT;
342 #ifdef AST_DEVMODE
343         /* In dev mode, write readable JSON */
344         flags = JSON_INDENT(2) | JSON_PRESERVE_ORDER;
345 #endif
346         return flags;
347 }
348
349 char *ast_json_dump_string(struct ast_json *root)
350 {
351         return json_dumps((json_t *)root, dump_flags());
352 }
353
354 static int write_to_ast_str(const char *buffer, size_t size, void *data)
355 {
356         struct ast_str **dst = data;
357         size_t str_size = ast_str_size(*dst);
358         size_t remaining = str_size - ast_str_strlen(*dst);
359         int ret;
360
361         /* While ast_str_append will grow the ast_str, it won't report
362          * allocation errors. Fortunately, it's not that hard.
363          */
364
365         /* Remaining needs to be big enough for buffer, plus null char */
366         while (remaining < size + 1) {
367                 /* doubling the size of the buffer gives us 'amortized
368                  * constant' time.
369                  * See http://stackoverflow.com/a/249695/115478 for info.
370                  */
371                 str_size *= 2;
372                 remaining = str_size - ast_str_strlen(*dst);
373         }
374
375         ret = ast_str_make_space(dst, str_size);
376         if (ret == -1) {
377                 /* Could not alloc; fail */
378                 return -1;
379         }
380
381         ast_str_append_substr(dst, -1, buffer, size);
382         return 0;
383 }
384
385 int ast_json_dump_str(struct ast_json *root, struct ast_str **dst)
386 {
387         return json_dump_callback((json_t *)root, write_to_ast_str, dst, dump_flags());
388 }
389
390
391 int ast_json_dump_file(struct ast_json *root, FILE *output)
392 {
393         if (!root || !output) {
394                 return -1;
395         }
396         return json_dumpf((json_t *)root, output, dump_flags());
397 }
398 int ast_json_dump_new_file(struct ast_json *root, const char *path)
399 {
400         if (!root || !path) {
401                 return -1;
402         }
403         return json_dump_file((json_t *)root, path, dump_flags());
404 }
405
406 /*!
407  * \brief Copy Jansson error struct to ours.
408  */
409 static void copy_error(struct ast_json_error *error, const json_error_t *jansson_error)
410 {
411         if (error && jansson_error) {
412                 error->line = jansson_error->line;
413                 error->column = jansson_error->column;
414                 error->position = jansson_error->position;
415                 ast_copy_string(error->text, jansson_error->text, sizeof(error->text));
416                 ast_copy_string(error->source, jansson_error->source, sizeof(error->source));
417         }
418
419 }
420
421 static void parse_error(struct ast_json_error *error, const char *text, const char *source)
422 {
423         if (error != NULL) {
424                 error->line = 0;
425                 error->column = 0;
426                 error->position = 0;
427                 strncpy(error->text, text, sizeof(error->text));
428                 strncpy(error->source, source, sizeof(error->text));
429         }
430 }
431
432 struct ast_json *ast_json_load_string(const char *input, struct ast_json_error *error)
433 {
434         json_error_t jansson_error = {};
435         struct ast_json *r = NULL;
436         if (input != NULL) {
437                 r = (struct ast_json *)json_loads(input, 0, &jansson_error);
438                 copy_error(error, &jansson_error);
439         } else {
440                 parse_error(error, "NULL input string", "<null>");
441         }
442         return r;
443 }
444
445 struct ast_json *ast_json_load_str(const struct ast_str *input, struct ast_json_error *error)
446 {
447         return ast_json_load_string(ast_str_buffer(input), error);
448 }
449
450 struct ast_json *ast_json_load_buf(const char *buffer, size_t buflen, struct ast_json_error *error)
451 {
452         json_error_t jansson_error = {};
453         struct ast_json *r = (struct ast_json *)json_loadb(buffer, buflen, 0, &jansson_error);
454         copy_error(error, &jansson_error);
455         return r;
456 }
457 struct ast_json *ast_json_load_file(FILE *input, struct ast_json_error *error)
458 {
459         json_error_t jansson_error = {};
460         struct ast_json *r = NULL;
461         if (input != NULL) {
462                 r = (struct ast_json *)json_loadf(input, 0, &jansson_error);
463                 copy_error(error, &jansson_error);
464         } else {
465                 parse_error(error, "NULL input file", "<null>");
466         }
467         return r;
468 }
469 struct ast_json *ast_json_load_new_file(const char *path, struct ast_json_error *error)
470 {
471         json_error_t jansson_error = {};
472         struct ast_json *r = (struct ast_json *)json_load_file(path, 0, &jansson_error);
473         copy_error(error, &jansson_error);
474         return r;
475 }
476
477 struct ast_json *ast_json_pack(char const *format, ...)
478 {
479         struct ast_json *ret;
480         va_list args;
481         va_start(args, format);
482         ret = ast_json_vpack(format, args);
483         va_end(args);
484         return ret;
485 }
486 struct ast_json *ast_json_vpack(char const *format, va_list ap)
487 {
488         struct ast_json *r = NULL;
489         if (format) {
490                 r = (struct ast_json *)json_vpack_ex(NULL, 0, format, ap);
491         }
492         return r;
493 }
494
495 struct ast_json *ast_json_copy(const struct ast_json *value)
496 {
497         return (struct ast_json *)json_copy((json_t *)value);
498 }
499 struct ast_json *ast_json_deep_copy(const struct ast_json *value)
500 {
501         return (struct ast_json *)json_deep_copy((json_t *)value);
502 }
503
504 void ast_json_init(void)
505 {
506         /* Setup to use Asterisk custom allocators */
507         ast_json_reset_alloc_funcs();
508 }