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