vector: Additional string vector definitions.
[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,
24  * see its 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 #include "asterisk/json.h"
37 #include "asterisk/localtime.h"
38 #include "asterisk/module.h"
39 #include "asterisk/utils.h"
40 #include "asterisk/astobj2.h"
41 #include "asterisk/channel.h"
42 #include "asterisk/callerid.h"
43
44 #include <jansson.h>
45 #include <time.h>
46
47 /*! \brief Magic number, for safety checks. */
48 #define JSON_MAGIC 0x1541992
49
50 /*! \brief Internal structure for allocated memory blocks */
51 struct json_mem {
52         /*! Magic number, for safety checks */
53         uint32_t magic;
54         /*! Mutext for locking this memory block */
55         ast_mutex_t mutex;
56         /*! Linked list pointer for the free list */
57         AST_LIST_ENTRY(json_mem) list;
58         /*! Data section of the allocation; void pointer for proper alignment */
59         void *data[];
60 };
61
62 /*! \brief Free a \ref json_mem block. */
63 static void json_mem_free(struct json_mem *mem)
64 {
65         mem->magic = 0;
66         ast_mutex_destroy(&mem->mutex);
67         ast_free(mem);
68 }
69
70 /*!
71  * \brief Get the \ref json_mem block for a pointer allocated via
72  * ast_json_malloc().
73  *
74  * This function properly handles Jansson singletons (null, true, false), and
75  * \c NULL.
76  *
77  * \param p Pointer, usually to a \c json_t or \ref ast_json.
78  * \return \ref json_mem object with extra allocation info.
79  */
80 static inline struct json_mem *to_json_mem(void *p)
81 {
82         struct json_mem *mem;
83         /* Avoid ref'ing the singleton values */
84         if (p == NULL || p == json_null() || p == json_true() ||
85                 p == json_false()) {
86                 return NULL;
87         }
88         mem = (struct json_mem *)((char *) (p) - sizeof(*mem));
89         ast_assert(mem->magic == JSON_MAGIC);
90         return mem;
91 }
92
93 /*!
94  * \brief Lock an \ref ast_json instance.
95  *
96  * If \a json is an immutable singleton (null, true, false), this function
97  * safely ignores it and returns \c NULL. Otherwise, \a json must have been
98  * allocates using ast_json_malloc().
99  *
100  * \param json JSON instance to lock.
101  * \return \ref Corresponding \ref json_mem block.
102  * \return \c NULL if \a json was not allocated.
103  */
104 static struct json_mem *json_mem_lock(struct ast_json *json)
105 {
106         struct json_mem *mem = to_json_mem(json);
107         if (!mem) {
108                 return NULL;
109         }
110         ast_mutex_lock(&mem->mutex);
111         return mem;
112 }
113
114 /*!
115  * \brief Unlock a \ref json_mem instance.
116  *
117  * \param mem \ref json_mem, usually returned from json_mem_lock().
118  */
119 static void json_mem_unlock(struct json_mem *mem)
120 {
121         if (!mem) {
122                 return;
123         }
124         ast_mutex_unlock(&mem->mutex);
125 }
126
127 /*!
128  * \brief Scoped lock for a \ref ast_json instance.
129  *
130  * \param json JSON instance to lock.
131  */
132 #define SCOPED_JSON_LOCK(json)                          \
133         RAII_VAR(struct json_mem *, __mem_ ## __LINE__, \
134                 json_mem_lock(json), json_mem_unlock)
135
136 void *ast_json_malloc(size_t size)
137 {
138         struct json_mem *mem = ast_malloc(size + sizeof(*mem));
139         if (!mem) {
140                 return NULL;
141         }
142         mem->magic = JSON_MAGIC;
143         ast_mutex_init(&mem->mutex);
144         return mem->data;
145 }
146
147 AST_THREADSTORAGE(json_free_list_ts);
148
149 /*!
150  * \brief Struct for a linked list of \ref json_mem.
151  */
152 AST_LIST_HEAD_NOLOCK(json_mem_list, json_mem);
153
154 /*!
155  * \brief Thread local list of \ref json_mem blocks to free at the end of an
156  * unref.
157  */
158 static struct json_mem_list *json_free_list(void)
159 {
160         return ast_threadstorage_get(&json_free_list_ts,
161                 sizeof(struct json_mem_list));
162 }
163
164 void ast_json_free(void *p)
165 {
166         struct json_mem *mem;
167         struct json_mem_list *free_list;
168         mem = to_json_mem(p);
169
170         if (!mem) {
171                 return;
172         }
173
174         /* Since the unref is holding a lock in mem, we can't free it
175          * immediately. Store it off on a thread local list to be freed by
176          * ast_json_unref().
177          */
178         free_list = json_free_list();
179         if (!free_list) {
180                 ast_log(LOG_ERROR, "Error allocating free list\n");
181                 ast_assert(0);
182                 /* It's not ideal to free the memory immediately, but that's the
183                  * best we can do if the threadlocal allocation fails */
184                 json_mem_free(mem);
185                 return;
186         }
187
188         AST_LIST_INSERT_HEAD(free_list, mem, list);
189 }
190
191 void ast_json_set_alloc_funcs(void *(*malloc_fn)(size_t), void (*free_fn)(void*))
192 {
193         json_set_alloc_funcs(malloc_fn, free_fn);
194 }
195
196 void ast_json_reset_alloc_funcs(void)
197 {
198         json_set_alloc_funcs(ast_json_malloc, ast_json_free);
199 }
200
201 struct ast_json *ast_json_ref(struct ast_json *json)
202 {
203         /* Jansson refcounting is non-atomic; lock it. */
204         SCOPED_JSON_LOCK(json);
205         json_incref((json_t *)json);
206         return json;
207 }
208
209 void ast_json_unref(struct ast_json *json)
210 {
211         struct json_mem_list *free_list;
212         struct json_mem *mem;
213
214         if (!json) {
215                 return;
216         }
217
218         /* Jansson refcounting is non-atomic; lock it. */
219         {
220                 SCOPED_JSON_LOCK(json);
221
222                 json_decref((json_t *) json);
223         }
224
225         /* Now free any objects that were ast_json_free()'s while the lock was
226          * held */
227         free_list = json_free_list();
228         if (!free_list) {
229                 return;
230         }
231
232         while ((mem = AST_LIST_REMOVE_HEAD(free_list, list))) {
233                 json_mem_free(mem);
234         }
235 }
236
237 enum ast_json_type ast_json_typeof(const struct ast_json *json)
238 {
239         int r = json_typeof((json_t*)json);
240         switch(r) {
241         case JSON_OBJECT: return AST_JSON_OBJECT;
242         case JSON_ARRAY: return AST_JSON_ARRAY;
243         case JSON_STRING: return AST_JSON_STRING;
244         case JSON_INTEGER: return AST_JSON_INTEGER;
245         case JSON_REAL: return AST_JSON_REAL;
246         case JSON_TRUE: return AST_JSON_TRUE;
247         case JSON_FALSE: return AST_JSON_FALSE;
248         case JSON_NULL: return AST_JSON_NULL;
249         }
250         ast_assert(0); /* Unexpect return from json_typeof */
251         return r;
252 }
253
254 const char *ast_json_typename(enum ast_json_type type)
255 {
256         switch (type) {
257         case AST_JSON_OBJECT: return "object";
258         case AST_JSON_ARRAY: return "array";
259         case AST_JSON_STRING: return "string";
260         case AST_JSON_INTEGER: return "integer";
261         case AST_JSON_REAL: return "real";
262         case AST_JSON_TRUE: return "boolean";
263         case AST_JSON_FALSE: return "boolean";
264         case AST_JSON_NULL: return "null";
265         }
266         ast_assert(0);
267         return "?";
268 }
269
270 /* Ported from libjansson utf.c:utf8_check_first() */
271 static size_t json_utf8_check_first(char byte)
272 {
273         unsigned char ch = (unsigned char) byte;
274
275         if (ch < 0x80) {
276                 return 1;
277         }
278
279         if (0x80 <= ch && ch <= 0xBF) {
280                 /* second, third or fourth byte of a multi-byte
281                    sequence, i.e. a "continuation byte" */
282                 return 0;
283         } else if (ch == 0xC0 || ch == 0xC1) {
284                 /* overlong encoding of an ASCII byte */
285                 return 0;
286         } else if (0xC2 <= ch && ch <= 0xDF) {
287                 /* 2-byte sequence */
288                 return 2;
289         } else if (0xE0 <= ch && ch <= 0xEF) {
290                 /* 3-byte sequence */
291                 return 3;
292         } else if (0xF0 <= ch && ch <= 0xF4) {
293                 /* 4-byte sequence */
294                 return 4;
295         } else { /* ch >= 0xF5 */
296                 /* Restricted (start of 4-, 5- or 6-byte sequence) or invalid
297                    UTF-8 */
298                 return 0;
299         }
300 }
301
302 /* Ported from libjansson utf.c:utf8_check_full() */
303 static size_t json_utf8_check_full(const char *str, size_t len)
304 {
305         size_t pos;
306         int32_t value;
307         unsigned char ch = (unsigned char) str[0];
308
309         if (len == 2) {
310                 value = ch & 0x1F;
311         } else if (len == 3) {
312                 value = ch & 0xF;
313         } else if (len == 4) {
314                 value = ch & 0x7;
315         } else {
316                 return 0;
317         }
318
319         for (pos = 1; pos < len; ++pos) {
320                 ch = (unsigned char) str[pos];
321                 if (ch < 0x80 || ch > 0xBF) {
322                         /* not a continuation byte */
323                         return 0;
324                 }
325
326                 value = (value << 6) + (ch & 0x3F);
327         }
328
329         if (value > 0x10FFFF) {
330                 /* not in Unicode range */
331                 return 0;
332         } else if (0xD800 <= value && value <= 0xDFFF) {
333                 /* invalid code point (UTF-16 surrogate halves) */
334                 return 0;
335         } else if ((len == 2 && value < 0x80)
336                 || (len == 3 && value < 0x800)
337                 || (len == 4 && value < 0x10000)) {
338                 /* overlong encoding */
339                 return 0;
340         }
341
342         return 1;
343 }
344
345 int ast_json_utf8_check_len(const char *str, size_t len)
346 {
347         size_t pos;
348         size_t count;
349         int res = 1;
350
351         if (!str) {
352                 return 0;
353         }
354
355         /*
356          * Since the json library does not make the check function
357          * public we recreate/copy the function in our interface
358          * module.
359          *
360          * Loop ported from libjansson utf.c:utf8_check_string()
361          */
362         for (pos = 0; pos < len; pos += count) {
363                 count = json_utf8_check_first(str[pos]);
364                 if (count == 0) {
365                         res = 0;
366                         break;
367                 } else if (count > 1) {
368                         if (count > len - pos) {
369                                 /* UTF-8 needs more than we have left in the string. */
370                                 res = 0;
371                                 break;
372                         }
373
374                         if (!json_utf8_check_full(&str[pos], count)) {
375                                 res = 0;
376                                 break;
377                         }
378                 }
379         }
380
381         if (!res) {
382                 ast_debug(1, "String '%.*s' is not UTF-8 for json conversion\n", (int) len, str);
383         }
384         return res;
385 }
386
387 int ast_json_utf8_check(const char *str)
388 {
389         return str ? ast_json_utf8_check_len(str, strlen(str)) : 0;
390 }
391
392 struct ast_json *ast_json_true(void)
393 {
394         return (struct ast_json *)json_true();
395 }
396
397 struct ast_json *ast_json_false(void)
398 {
399         return (struct ast_json *)json_false();
400 }
401
402 struct ast_json *ast_json_boolean(int value)
403 {
404 #if JANSSON_VERSION_HEX >= 0x020400
405         return (struct ast_json *)json_boolean(value);
406 #else
407         return value ? ast_json_true() : ast_json_false();
408 #endif
409 }
410
411 struct ast_json *ast_json_null(void)
412 {
413         return (struct ast_json *)json_null();
414 }
415
416 int ast_json_is_true(const struct ast_json *json)
417 {
418         return json_is_true((const json_t *)json);
419 }
420
421 int ast_json_is_false(const struct ast_json *json)
422 {
423         return json_is_false((const json_t *)json);
424 }
425
426 int ast_json_is_null(const struct ast_json *json)
427 {
428         return json_is_null((const json_t *)json);
429 }
430
431 struct ast_json *ast_json_string_create(const char *value)
432 {
433         return (struct ast_json *)json_string(value);
434 }
435
436 const char *ast_json_string_get(const struct ast_json *string)
437 {
438         return json_string_value((json_t *)string);
439 }
440
441 int ast_json_string_set(struct ast_json *string, const char *value)
442 {
443         return json_string_set((json_t *)string, value);
444 }
445
446 struct ast_json *ast_json_stringf(const char *format, ...)
447 {
448         struct ast_json *ret;
449         va_list args;
450         va_start(args, format);
451         ret = ast_json_vstringf(format, args);
452         va_end(args);
453         return ret;
454 }
455
456 struct ast_json *ast_json_vstringf(const char *format, va_list args)
457 {
458         char *str = NULL;
459         json_t *ret = NULL;
460
461         if (format) {
462                 int err = ast_vasprintf(&str, format, args);
463                 if (err >= 0) {
464                         ret = json_string(str);
465                         ast_free(str);
466                 }
467         }
468         return (struct ast_json *)ret;
469 }
470
471 struct ast_json *ast_json_integer_create(intmax_t value)
472 {
473         return (struct ast_json *)json_integer(value);
474 }
475
476 intmax_t ast_json_integer_get(const struct ast_json *integer)
477 {
478         return json_integer_value((json_t *)integer);
479 }
480
481 int ast_json_integer_set(struct ast_json *integer, intmax_t value)
482 {
483         return json_integer_set((json_t *)integer, value);
484 }
485
486 struct ast_json *ast_json_real_create(double value)
487 {
488         return (struct ast_json *)json_real(value);
489 }
490
491 double ast_json_real_get(const struct ast_json *real)
492 {
493         return json_real_value((json_t *)real);
494 }
495
496 int ast_json_real_set(struct ast_json *real, double value)
497 {
498         return json_real_set((json_t *)real, value);
499 }
500
501 int ast_json_equal(const struct ast_json *lhs, const struct ast_json *rhs)
502 {
503         return json_equal((json_t *)lhs, (json_t *)rhs);
504 }
505
506 struct ast_json *ast_json_array_create(void)
507 {
508         return (struct ast_json *)json_array();
509 }
510 size_t ast_json_array_size(const struct ast_json *array)
511 {
512         return json_array_size((json_t *)array);
513 }
514 struct ast_json *ast_json_array_get(const struct ast_json *array, size_t index)
515 {
516         return (struct ast_json *)json_array_get((json_t *)array, index);
517 }
518 int ast_json_array_set(struct ast_json *array, size_t index, struct ast_json *value)
519 {
520         return json_array_set_new((json_t *)array, index, (json_t *)value);
521 }
522 int ast_json_array_append(struct ast_json *array, struct ast_json *value)
523 {
524         return json_array_append_new((json_t *)array, (json_t *)value);
525 }
526 int ast_json_array_insert(struct ast_json *array, size_t index, struct ast_json *value)
527 {
528         return json_array_insert_new((json_t *)array, index, (json_t *)value);
529 }
530 int ast_json_array_remove(struct ast_json *array, size_t index)
531 {
532         return json_array_remove((json_t *)array, index);
533 }
534 int ast_json_array_clear(struct ast_json *array)
535 {
536         return json_array_clear((json_t *)array);
537 }
538 int ast_json_array_extend(struct ast_json *array, struct ast_json *tail)
539 {
540         return json_array_extend((json_t *)array, (json_t *)tail);
541 }
542
543 struct ast_json *ast_json_object_create(void)
544 {
545         return (struct ast_json *)json_object();
546 }
547 size_t ast_json_object_size(struct ast_json *object)
548 {
549         return json_object_size((json_t *)object);
550 }
551 struct ast_json *ast_json_object_get(struct ast_json *object, const char *key)
552 {
553         if (!key) {
554                 return NULL;
555         }
556         return (struct ast_json *)json_object_get((json_t *)object, key);
557 }
558 int ast_json_object_set(struct ast_json *object, const char *key, struct ast_json *value)
559 {
560         return json_object_set_new((json_t *)object, key, (json_t *)value);
561 }
562 int ast_json_object_del(struct ast_json *object, const char *key)
563 {
564         return json_object_del((json_t *)object, key);
565 }
566 int ast_json_object_clear(struct ast_json *object)
567 {
568         return json_object_clear((json_t *)object);
569 }
570 int ast_json_object_update(struct ast_json *object, struct ast_json *other)
571 {
572         return json_object_update((json_t *)object, (json_t *)other);
573 }
574 int ast_json_object_update_existing(struct ast_json *object, struct ast_json *other)
575 {
576 #if JANSSON_VERSION_HEX >= 0x020300
577         return json_object_update_existing((json_t *)object, (json_t *)other);
578 #else
579         struct ast_json_iter *iter = ast_json_object_iter(other);
580         int ret = 0;
581
582         if (object == NULL || other == NULL) {
583                 return -1;
584         }
585
586         while (iter != NULL && ret == 0) {
587                 const char *key = ast_json_object_iter_key(iter);
588
589                 if (ast_json_object_get(object, key) != NULL) {
590                         struct ast_json *value = ast_json_object_iter_value(iter);
591
592                         if (!value || ast_json_object_set(object, key, ast_json_ref(value))) {
593                                 ret = -1;
594                         }
595                 }
596                 iter = ast_json_object_iter_next(other, iter);
597         }
598         return ret;
599 #endif
600 }
601 int ast_json_object_update_missing(struct ast_json *object, struct ast_json *other)
602 {
603 #if JANSSON_VERSION_HEX >= 0x020300
604         return json_object_update_missing((json_t *)object, (json_t *)other);
605 #else
606         struct ast_json_iter *iter = ast_json_object_iter(other);
607         int ret = 0;
608
609         if (object == NULL || other == NULL) {
610                 return -1;
611         }
612
613         while (iter != NULL && ret == 0) {
614                 const char *key = ast_json_object_iter_key(iter);
615
616                 if (ast_json_object_get(object, key) == NULL) {
617                         struct ast_json *value = ast_json_object_iter_value(iter);
618
619                         if (!value || ast_json_object_set(object, key, ast_json_ref(value))) {
620                                 ret = -1;
621                         }
622                 }
623                 iter = ast_json_object_iter_next(other, iter);
624         }
625         return ret;
626 #endif
627 }
628
629 struct ast_json_iter *ast_json_object_iter(struct ast_json *object)
630 {
631         return json_object_iter((json_t *)object);
632 }
633 struct ast_json_iter *ast_json_object_iter_at(struct ast_json *object, const char *key)
634 {
635         return json_object_iter_at((json_t *)object, key);
636 }
637 struct ast_json_iter *ast_json_object_iter_next(struct ast_json *object, struct ast_json_iter *iter)
638 {
639         return json_object_iter_next((json_t *)object, iter);
640 }
641 const char *ast_json_object_iter_key(struct ast_json_iter *iter)
642 {
643         return json_object_iter_key(iter);
644 }
645 struct ast_json *ast_json_object_iter_value(struct ast_json_iter *iter)
646 {
647         return (struct ast_json *)json_object_iter_value(iter);
648 }
649 int ast_json_object_iter_set(struct ast_json *object, struct ast_json_iter *iter, struct ast_json *value)
650 {
651         return json_object_iter_set_new((json_t *)object, iter, (json_t *)value);
652 }
653
654 /*!
655  * \brief Default flags for JSON encoding.
656  */
657 static size_t dump_flags(enum ast_json_encoding_format format)
658 {
659         return format == AST_JSON_PRETTY ?
660                 JSON_INDENT(2) | JSON_PRESERVE_ORDER : JSON_COMPACT;
661 }
662
663 char *ast_json_dump_string_format(struct ast_json *root, enum ast_json_encoding_format format)
664 {
665         /* Jansson's json_dump*, even though it's a read operation, isn't
666          * thread safe for concurrent reads. Locking is necessary.
667          * See http://www.digip.org/jansson/doc/2.4/portability.html#thread-safety. */
668         SCOPED_JSON_LOCK(root);
669         return json_dumps((json_t *)root, dump_flags(format));
670 }
671
672 static int write_to_ast_str(const char *buffer, size_t size, void *data)
673 {
674         struct ast_str **dst = data;
675         size_t str_size = ast_str_size(*dst);
676         size_t remaining = str_size - ast_str_strlen(*dst);
677         int ret;
678
679         /* While ast_str_append will grow the ast_str, it won't report
680          * allocation errors. Fortunately, it's not that hard.
681          */
682
683         /* Remaining needs to be big enough for buffer, plus null char */
684         while (remaining < size + 1) {
685                 /* doubling the size of the buffer gives us 'amortized
686                  * constant' time.
687                  * See http://stackoverflow.com/a/249695/115478 for info.
688                  */
689                 str_size *= 2;
690                 remaining = str_size - ast_str_strlen(*dst);
691         }
692
693         ret = ast_str_make_space(dst, str_size);
694         if (ret == -1) {
695                 /* Could not alloc; fail */
696                 return -1;
697         }
698
699         ast_str_append_substr(dst, -1, buffer, size);
700         return 0;
701 }
702
703 int ast_json_dump_str_format(struct ast_json *root, struct ast_str **dst, enum ast_json_encoding_format format)
704 {
705         /* Jansson's json_dump*, even though it's a read operation, isn't
706          * thread safe for concurrent reads. Locking is necessary.
707          * See http://www.digip.org/jansson/doc/2.4/portability.html#thread-safety. */
708         SCOPED_JSON_LOCK(root);
709         return json_dump_callback((json_t *)root, write_to_ast_str, dst, dump_flags(format));
710 }
711
712
713 int ast_json_dump_file_format(struct ast_json *root, FILE *output, enum ast_json_encoding_format format)
714 {
715         /* Jansson's json_dump*, even though it's a read operation, isn't
716          * thread safe for concurrent reads. Locking is necessary.
717          * See http://www.digip.org/jansson/doc/2.4/portability.html#thread-safety. */
718         SCOPED_JSON_LOCK(root);
719         if (!root || !output) {
720                 return -1;
721         }
722         return json_dumpf((json_t *)root, output, dump_flags(format));
723 }
724 int ast_json_dump_new_file_format(struct ast_json *root, const char *path, enum ast_json_encoding_format format)
725 {
726         /* Jansson's json_dump*, even though it's a read operation, isn't
727          * thread safe for concurrent reads. Locking is necessary.
728          * See http://www.digip.org/jansson/doc/2.4/portability.html#thread-safety. */
729         SCOPED_JSON_LOCK(root);
730         if (!root || !path) {
731                 return -1;
732         }
733         return json_dump_file((json_t *)root, path, dump_flags(format));
734 }
735
736 /*!
737  * \brief Copy Jansson error struct to ours.
738  */
739 static void copy_error(struct ast_json_error *error, const json_error_t *jansson_error)
740 {
741         if (error && jansson_error) {
742                 error->line = jansson_error->line;
743                 error->column = jansson_error->column;
744                 error->position = jansson_error->position;
745                 ast_copy_string(error->text, jansson_error->text, sizeof(error->text));
746                 ast_copy_string(error->source, jansson_error->source, sizeof(error->source));
747         }
748
749 }
750
751 static void parse_error(struct ast_json_error *error, const char *text, const char *source)
752 {
753         if (error != NULL) {
754                 error->line = 0;
755                 error->column = 0;
756                 error->position = 0;
757                 strncpy(error->text, text, sizeof(error->text));
758                 strncpy(error->source, source, sizeof(error->text));
759         }
760 }
761
762 struct ast_json *ast_json_load_string(const char *input, struct ast_json_error *error)
763 {
764         json_error_t jansson_error = {};
765         struct ast_json *r = NULL;
766         if (input != NULL) {
767                 r = (struct ast_json *)json_loads(input, 0, &jansson_error);
768                 copy_error(error, &jansson_error);
769         } else {
770                 parse_error(error, "NULL input string", "<null>");
771         }
772         return r;
773 }
774
775 struct ast_json *ast_json_load_str(const struct ast_str *input, struct ast_json_error *error)
776 {
777         return ast_json_load_string(ast_str_buffer(input), error);
778 }
779
780 struct ast_json *ast_json_load_buf(const char *buffer, size_t buflen, struct ast_json_error *error)
781 {
782         json_error_t jansson_error = {};
783         struct ast_json *r = (struct ast_json *)json_loadb(buffer, buflen, 0, &jansson_error);
784         copy_error(error, &jansson_error);
785         return r;
786 }
787 struct ast_json *ast_json_load_file(FILE *input, struct ast_json_error *error)
788 {
789         json_error_t jansson_error = {};
790         struct ast_json *r = NULL;
791         if (input != NULL) {
792                 r = (struct ast_json *)json_loadf(input, 0, &jansson_error);
793                 copy_error(error, &jansson_error);
794         } else {
795                 parse_error(error, "NULL input file", "<null>");
796         }
797         return r;
798 }
799 struct ast_json *ast_json_load_new_file(const char *path, struct ast_json_error *error)
800 {
801         json_error_t jansson_error = {};
802         struct ast_json *r = (struct ast_json *)json_load_file(path, 0, &jansson_error);
803         copy_error(error, &jansson_error);
804         return r;
805 }
806
807 struct ast_json *ast_json_pack(char const *format, ...)
808 {
809         struct ast_json *ret;
810         va_list args;
811         va_start(args, format);
812         ret = ast_json_vpack(format, args);
813         va_end(args);
814         return ret;
815 }
816 struct ast_json *ast_json_vpack(char const *format, va_list ap)
817 {
818         json_error_t error;
819         struct ast_json *r = NULL;
820         if (format) {
821                 r = (struct ast_json *)json_vpack_ex(&error, 0, format, ap);
822                 if (!r && !ast_strlen_zero(error.text)) {
823                         ast_log(LOG_ERROR,
824                                 "Error building JSON from '%s': %s.\n",
825                                 format, error.text);
826                         ast_log_backtrace();
827                 }
828         }
829         return r;
830 }
831
832 struct ast_json *ast_json_copy(const struct ast_json *value)
833 {
834         return (struct ast_json *)json_copy((json_t *)value);
835 }
836 struct ast_json *ast_json_deep_copy(const struct ast_json *value)
837 {
838         return (struct ast_json *)json_deep_copy((json_t *)value);
839 }
840
841 struct ast_json *ast_json_name_number(const char *name, const char *number)
842 {
843         return ast_json_pack("{s: s, s: s}",
844                 "name", AST_JSON_UTF8_VALIDATE(name),
845                 "number", AST_JSON_UTF8_VALIDATE(number));
846 }
847
848 struct ast_json *ast_json_dialplan_cep(const char *context, const char *exten, int priority)
849 {
850         return ast_json_pack("{s: o, s: o, s: o}",
851                 "context", context ? ast_json_string_create(context) : ast_json_null(),
852                 "exten", exten ? ast_json_string_create(exten) : ast_json_null(),
853                 "priority", priority != -1 ? ast_json_integer_create(priority) : ast_json_null());
854 }
855
856 struct ast_json *ast_json_timeval(const struct timeval tv, const char *zone)
857 {
858         char buf[AST_ISO8601_LEN];
859         struct ast_tm tm = {};
860
861         ast_localtime(&tv, &tm, zone);
862
863         ast_strftime(buf, sizeof(buf),AST_ISO8601_FORMAT, &tm);
864
865         return ast_json_string_create(buf);
866 }
867
868 struct ast_json *ast_json_ipaddr(const struct ast_sockaddr *addr, enum ast_transport transport_type)
869 {
870         struct ast_str *string = ast_str_alloca(64);
871
872         if (!string) {
873                 return NULL;
874         }
875
876         ast_str_set(&string, 0, (ast_sockaddr_is_ipv4(addr) ||
877                 ast_sockaddr_is_ipv4_mapped(addr)) ? "IPV4/" : "IPV6/");
878
879         if (transport_type) {
880                 char *transport_string = NULL;
881
882                 /* NOTE: None will be applied if multiple transport types are specified in transport_type */
883                 switch(transport_type) {
884                 case AST_TRANSPORT_UDP:
885                         transport_string = "UDP";
886                         break;
887                 case AST_TRANSPORT_TCP:
888                         transport_string = "TCP";
889                         break;
890                 case AST_TRANSPORT_TLS:
891                         transport_string = "TLS";
892                         break;
893                 case AST_TRANSPORT_WS:
894                         transport_string = "WS";
895                         break;
896                 case AST_TRANSPORT_WSS:
897                         transport_string = "WSS";
898                         break;
899                 }
900
901                 if (transport_string) {
902                         ast_str_append(&string, 0, "%s/", transport_string);
903                 }
904         }
905
906         ast_str_append(&string, 0, "%s", ast_sockaddr_stringify_addr(addr));
907         ast_str_append(&string, 0, "/%s", ast_sockaddr_stringify_port(addr));
908
909         return ast_json_string_create(ast_str_buffer(string));
910 }
911
912 void ast_json_init(void)
913 {
914         /* Setup to use Asterisk custom allocators */
915         ast_json_reset_alloc_funcs();
916 }
917
918 static void json_payload_destructor(void *obj)
919 {
920         struct ast_json_payload *payload = obj;
921         ast_json_unref(payload->json);
922 }
923
924 struct ast_json_payload *ast_json_payload_create(struct ast_json *json)
925 {
926         struct ast_json_payload *payload;
927
928         if (!(payload = ao2_alloc(sizeof(*payload), json_payload_destructor))) {
929                 return NULL;
930         }
931
932         ast_json_ref(json);
933         payload->json = json;
934
935         return payload;
936 }
937
938 static struct ast_json *json_party_number(struct ast_party_number *number)
939 {
940         if (!number->valid) {
941                 return NULL;
942         }
943         return ast_json_pack("{s: s, s: i, s: i, s: s}",
944                 "number", AST_JSON_UTF8_VALIDATE(number->str),
945                 "plan", number->plan,
946                 "presentation", number->presentation,
947                 "presentation_txt", ast_describe_caller_presentation(number->presentation));
948 }
949
950 static struct ast_json *json_party_name(struct ast_party_name *name)
951 {
952         if (!name->valid) {
953                 return NULL;
954         }
955         return ast_json_pack("{s: s, s: s, s: i, s: s}",
956                 "name", AST_JSON_UTF8_VALIDATE(name->str),
957                 "character_set", ast_party_name_charset_describe(name->char_set),
958                 "presentation", name->presentation,
959                 "presentation_txt", ast_describe_caller_presentation(name->presentation));
960 }
961
962 static struct ast_json *json_party_subaddress(struct ast_party_subaddress *subaddress)
963 {
964         if (!subaddress->valid) {
965                 return NULL;
966         }
967         return ast_json_pack("{s: s, s: i, s: b}",
968                 "subaddress", AST_JSON_UTF8_VALIDATE(subaddress->str),
969                 "type", subaddress->type,
970                 "odd", subaddress->odd_even_indicator);
971 }
972
973 struct ast_json *ast_json_party_id(struct ast_party_id *party)
974 {
975         RAII_VAR(struct ast_json *, json_party_id, NULL, ast_json_unref);
976         int pres;
977
978         /* Combined party presentation */
979         pres = ast_party_id_presentation(party);
980         json_party_id = ast_json_pack("{s: i, s: s}",
981                 "presentation", pres,
982                 "presentation_txt", ast_describe_caller_presentation(pres));
983         if (!json_party_id) {
984                 return NULL;
985         }
986
987         /* Party number */
988         if (party->number.valid
989                 && ast_json_object_set(json_party_id, "number", json_party_number(&party->number))) {
990                 return NULL;
991         }
992
993         /* Party name */
994         if (party->name.valid
995                 && ast_json_object_set(json_party_id, "name", json_party_name(&party->name))) {
996                 return NULL;
997         }
998
999         /* Party subaddress */
1000         if (party->subaddress.valid
1001                 && ast_json_object_set(json_party_id, "subaddress", json_party_subaddress(&party->subaddress))) {
1002                 return NULL;
1003         }
1004
1005         return ast_json_ref(json_party_id);
1006 }
1007
1008 enum ast_json_to_ast_vars_code ast_json_to_ast_variables(struct ast_json *json_variables, struct ast_variable **variables)
1009 {
1010         struct ast_json_iter *it_json_var;
1011
1012         *variables = NULL;
1013
1014         for (it_json_var = ast_json_object_iter(json_variables); it_json_var;
1015                 it_json_var = ast_json_object_iter_next(json_variables, it_json_var)) {
1016                 struct ast_variable *new_var;
1017                 const char *key = ast_json_object_iter_key(it_json_var);
1018                 const char *value;
1019                 struct ast_json *json_value;
1020
1021                 if (ast_strlen_zero(key)) {
1022                         continue;
1023                 }
1024
1025                 json_value = ast_json_object_iter_value(it_json_var);
1026                 if (ast_json_typeof(json_value) != AST_JSON_STRING) {
1027                         /* Error: Only strings allowed */
1028                         ast_variables_destroy(*variables);
1029                         *variables = NULL;
1030                         return AST_JSON_TO_AST_VARS_CODE_INVALID_TYPE;
1031                 }
1032                 value = ast_json_string_get(json_value);
1033                 /* Should never be NULL.  Otherwise, how could it be a string type? */
1034                 ast_assert(value != NULL);
1035                 if (!value) {
1036                         /* To be safe. */
1037                         continue;
1038                 }
1039                 new_var = ast_variable_new(key, value, "");
1040                 if (!new_var) {
1041                         /* Error: OOM */
1042                         ast_variables_destroy(*variables);
1043                         *variables = NULL;
1044                         return AST_JSON_TO_AST_VARS_CODE_OOM;
1045                 }
1046
1047                 ast_variable_list_append(variables, new_var);
1048         }
1049
1050         return AST_JSON_TO_AST_VARS_CODE_SUCCESS;
1051 }
1052
1053 struct ast_json *ast_json_channel_vars(struct varshead *channelvars)
1054 {
1055         struct ast_json *ret;
1056         struct ast_var_t *var;
1057
1058         ret = ast_json_object_create();
1059         AST_LIST_TRAVERSE(channelvars, var, entries) {
1060                 ast_json_object_set(ret, var->name, ast_json_string_create(var->value));
1061         }
1062
1063         return ret;
1064 }