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