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