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