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