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         /* Jansson refcounting is non-atomic; lock it. */
 217         {
 218                 SCOPED_JSON_LOCK(json);
 219                 if (!json) {
 220                         return;
 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
 271 struct ast_json *ast_json_true(void)
 272 {
 273         return (struct ast_json *)json_true();
 274 }
 275
 276 struct ast_json *ast_json_false(void)
 277 {
 278         return (struct ast_json *)json_false();
 279 }
 280
 281 struct ast_json *ast_json_boolean(int value)
 282 {
 283 #if JANSSON_VERSION_HEX >= 0x020400
 284         return (struct ast_json *)json_boolean(value);
 285 #else
 286         return value ? ast_json_true() : ast_json_false();
 287 #endif
 288 }
 289
 290 struct ast_json *ast_json_null(void)
 291 {
 292         return (struct ast_json *)json_null();
 293 }
 294
 295 int ast_json_is_true(const struct ast_json *json)
 296 {
 297         return json_is_true((const json_t *)json);
 298 }
 299
 300 int ast_json_is_false(const struct ast_json *json)
 301 {
 302         return json_is_false((const json_t *)json);
 303 }
 304
 305 int ast_json_is_null(const struct ast_json *json)
 306 {
 307         return json_is_null((const json_t *)json);
 308 }
 309
 310 struct ast_json *ast_json_string_create(const char *value)
 311 {
 312         return (struct ast_json *)json_string(value);
 313 }
 314
 315 const char *ast_json_string_get(const struct ast_json *string)
 316 {
 317         return json_string_value((json_t *)string);
 318 }
 319
 320 int ast_json_string_set(struct ast_json *string, const char *value)
 321 {
 322         return json_string_set((json_t *)string, value);
 323 }
 324
 325 struct ast_json *ast_json_stringf(const char *format, ...)
 326 {
 327         struct ast_json *ret;
 328         va_list args;
 329         va_start(args, format);
 330         ret = ast_json_vstringf(format, args);
 331         va_end(args);
 332         return ret;
 333 }
 334
 335 struct ast_json *ast_json_vstringf(const char *format, va_list args)
 336 {
 337         char *str = NULL;
 338         json_t *ret = NULL;
 339
 340         if (format) {
 341                 int err = vasprintf(&str, format, args);
 342                 if (err > 0) {
 343                         ret = json_string(str);
 344                         free(str);
 345                 }
 346         }
 347         return (struct ast_json *)ret;
 348 }
 349
 350 struct ast_json *ast_json_integer_create(intmax_t value)
 351 {
 352         return (struct ast_json *)json_integer(value);
 353 }
 354
 355 intmax_t ast_json_integer_get(const struct ast_json *integer)
 356 {
 357         return json_integer_value((json_t *)integer);
 358 }
 359
 360 int ast_json_integer_set(struct ast_json *integer, intmax_t value)
 361 {
 362         return json_integer_set((json_t *)integer, value);
 363 }
 364
 365 struct ast_json *ast_json_real_create(double value)
 366 {
 367         return (struct ast_json *)json_real(value);
 368 }
 369
 370 double ast_json_real_get(const struct ast_json *real)
 371 {
 372         return json_real_value((json_t *)real);
 373 }
 374
 375 int ast_json_real_set(struct ast_json *real, double value)
 376 {
 377         return json_real_set((json_t *)real, value);
 378 }
 379
 380 int ast_json_equal(const struct ast_json *lhs, const struct ast_json *rhs)
 381 {
 382         return json_equal((json_t *)lhs, (json_t *)rhs);
 383 }
 384
 385 struct ast_json *ast_json_array_create(void)
 386 {
 387         return (struct ast_json *)json_array();
 388 }
 389 size_t ast_json_array_size(const struct ast_json *array)
 390 {
 391         return json_array_size((json_t *)array);
 392 }
 393 struct ast_json *ast_json_array_get(const struct ast_json *array, size_t index)
 394 {
 395         return (struct ast_json *)json_array_get((json_t *)array, index);
 396 }
 397 int ast_json_array_set(struct ast_json *array, size_t index, struct ast_json *value)
 398 {
 399         return json_array_set_new((json_t *)array, index, (json_t *)value);
 400 }
 401 int ast_json_array_append(struct ast_json *array, struct ast_json *value)
 402 {
 403         return json_array_append_new((json_t *)array, (json_t *)value);
 404 }
 405 int ast_json_array_insert(struct ast_json *array, size_t index, struct ast_json *value)
 406 {
 407         return json_array_insert_new((json_t *)array, index, (json_t *)value);
 408 }
 409 int ast_json_array_remove(struct ast_json *array, size_t index)
 410 {
 411         return json_array_remove((json_t *)array, index);
 412 }
 413 int ast_json_array_clear(struct ast_json *array)
 414 {
 415         return json_array_clear((json_t *)array);
 416 }
 417 int ast_json_array_extend(struct ast_json *array, struct ast_json *tail)
 418 {
 419         return json_array_extend((json_t *)array, (json_t *)tail);
 420 }
 421
 422 struct ast_json *ast_json_object_create(void)
 423 {
 424         return (struct ast_json *)json_object();
 425 }
 426 size_t ast_json_object_size(struct ast_json *object)
 427 {
 428         return json_object_size((json_t *)object);
 429 }
 430 struct ast_json *ast_json_object_get(struct ast_json *object, const char *key)
 431 {
 432         if (!key) {
 433                 return NULL;
 434         }
 435         return (struct ast_json *)json_object_get((json_t *)object, key);
 436 }
 437 int ast_json_object_set(struct ast_json *object, const char *key, struct ast_json *value)
 438 {
 439         return json_object_set_new((json_t *)object, key, (json_t *)value);
 440 }
 441 int ast_json_object_del(struct ast_json *object, const char *key)
 442 {
 443         return json_object_del((json_t *)object, key);
 444 }
 445 int ast_json_object_clear(struct ast_json *object)
 446 {
 447         return json_object_clear((json_t *)object);
 448 }
 449 int ast_json_object_update(struct ast_json *object, struct ast_json *other)
 450 {
 451         return json_object_update((json_t *)object, (json_t *)other);
 452 }
 453 int ast_json_object_update_existing(struct ast_json *object, struct ast_json *other)
 454 {
 455 #if JANSSON_VERSION_HEX >= 0x020300
 456         return json_object_update_existing((json_t *)object, (json_t *)other);
 457 #else
 458         struct ast_json_iter *iter = ast_json_object_iter(other);
 459         int ret = 0;
 460
 461         if (object == NULL || other == NULL) {
 462                 return -1;
 463         }
 464
 465         while (iter != NULL && ret == 0) {
 466                 const char *key = ast_json_object_iter_key(iter);
 467                 if (ast_json_object_get(object, key) != NULL) {
 468                         ret = ast_json_object_set(object, key, ast_json_object_iter_value(iter));
 469                 }
 470                 iter = ast_json_object_iter_next(other, iter);
 471         }
 472         return ret;
 473 #endif
 474 }
 475 int ast_json_object_update_missing(struct ast_json *object, struct ast_json *other)
 476 {
 477 #if JANSSON_VERSION_HEX >= 0x020300
 478         return json_object_update_missing((json_t *)object, (json_t *)other);
 479 #else
 480         struct ast_json_iter *iter = ast_json_object_iter(other);
 481         int ret = 0;
 482
 483         if (object == NULL || other == NULL) {
 484                 return -1;
 485         }
 486
 487         while (iter != NULL && ret == 0) {
 488                 const char *key = ast_json_object_iter_key(iter);
 489                 if (ast_json_object_get(object, key) == NULL) {
 490                         ret = ast_json_object_set(object, key, ast_json_object_iter_value(iter));
 491                 }
 492                 iter = ast_json_object_iter_next(other, iter);
 493         }
 494         return ret;
 495 #endif
 496 }
 497
 498 struct ast_json_iter *ast_json_object_iter(struct ast_json *object)
 499 {
 500         return json_object_iter((json_t *)object);
 501 }
 502 struct ast_json_iter *ast_json_object_iter_at(struct ast_json *object, const char *key)
 503 {
 504         return json_object_iter_at((json_t *)object, key);
 505 }
 506 struct ast_json_iter *ast_json_object_iter_next(struct ast_json *object, struct ast_json_iter *iter)
 507 {
 508         return json_object_iter_next((json_t *)object, iter);
 509 }
 510 const char *ast_json_object_iter_key(struct ast_json_iter *iter)
 511 {
 512         return json_object_iter_key(iter);
 513 }
 514 struct ast_json *ast_json_object_iter_value(struct ast_json_iter *iter)
 515 {
 516         return (struct ast_json *)json_object_iter_value(iter);
 517 }
 518 int ast_json_object_iter_set(struct ast_json *object, struct ast_json_iter *iter, struct ast_json *value)
 519 {
 520         return json_object_iter_set_new((json_t *)object, iter, (json_t *)value);
 521 }
 522
 523 /*!
 524  * \brief Default flags for JSON encoding.
 525  */
 526 static size_t dump_flags(enum ast_json_encoding_format format)
 527 {
 528         return format == AST_JSON_PRETTY ?
 529                 JSON_INDENT(2) | JSON_PRESERVE_ORDER : JSON_COMPACT;
 530 }
 531
 532 char *ast_json_dump_string_format(struct ast_json *root, enum ast_json_encoding_format format)
 533 {
 534         /* Jansson's json_dump*, even though it's a read operation, isn't
 535          * thread safe for concurrent reads. Locking is necessary.
 536          * See http://www.digip.org/jansson/doc/2.4/portability.html#thread-safety. */
 537         SCOPED_JSON_LOCK(root);
 538         return json_dumps((json_t *)root, dump_flags(format));
 539 }
 540
 541 static int write_to_ast_str(const char *buffer, size_t size, void *data)
 542 {
 543         struct ast_str **dst = data;
 544         size_t str_size = ast_str_size(*dst);
 545         size_t remaining = str_size - ast_str_strlen(*dst);
 546         int ret;
 547
 548         /* While ast_str_append will grow the ast_str, it won't report
 549          * allocation errors. Fortunately, it's not that hard.
 550          */
 551
 552         /* Remaining needs to be big enough for buffer, plus null char */
 553         while (remaining < size + 1) {
 554                 /* doubling the size of the buffer gives us 'amortized
 555                  * constant' time.
 556                  * See http://stackoverflow.com/a/249695/115478 for info.
 557                  */
 558                 str_size *= 2;
 559                 remaining = str_size - ast_str_strlen(*dst);
 560         }
 561
 562         ret = ast_str_make_space(dst, str_size);
 563         if (ret == -1) {
 564                 /* Could not alloc; fail */
 565                 return -1;
 566         }
 567
 568         ast_str_append_substr(dst, -1, buffer, size);
 569         return 0;
 570 }
 571
 572 int ast_json_dump_str_format(struct ast_json *root, struct ast_str **dst, enum ast_json_encoding_format format)
 573 {
 574         /* Jansson's json_dump*, even though it's a read operation, isn't
 575          * thread safe for concurrent reads. Locking is necessary.
 576          * See http://www.digip.org/jansson/doc/2.4/portability.html#thread-safety. */
 577         SCOPED_JSON_LOCK(root);
 578         return json_dump_callback((json_t *)root, write_to_ast_str, dst, dump_flags(format));
 579 }
 580
 581
 582 int ast_json_dump_file_format(struct ast_json *root, FILE *output, enum ast_json_encoding_format format)
 583 {
 584         /* Jansson's json_dump*, even though it's a read operation, isn't
 585          * thread safe for concurrent reads. Locking is necessary.
 586          * See http://www.digip.org/jansson/doc/2.4/portability.html#thread-safety. */
 587         SCOPED_JSON_LOCK(root);
 588         if (!root || !output) {
 589                 return -1;
 590         }
 591         return json_dumpf((json_t *)root, output, dump_flags(format));
 592 }
 593 int ast_json_dump_new_file_format(struct ast_json *root, const char *path, enum ast_json_encoding_format format)
 594 {
 595         /* Jansson's json_dump*, even though it's a read operation, isn't
 596          * thread safe for concurrent reads. Locking is necessary.
 597          * See http://www.digip.org/jansson/doc/2.4/portability.html#thread-safety. */
 598         SCOPED_JSON_LOCK(root);
 599         if (!root || !path) {
 600                 return -1;
 601         }
 602         return json_dump_file((json_t *)root, path, dump_flags(format));
 603 }
 604
 605 /*!
 606  * \brief Copy Jansson error struct to ours.
 607  */
 608 static void copy_error(struct ast_json_error *error, const json_error_t *jansson_error)
 609 {
 610         if (error && jansson_error) {
 611                 error->line = jansson_error->line;
 612                 error->column = jansson_error->column;
 613                 error->position = jansson_error->position;
 614                 ast_copy_string(error->text, jansson_error->text, sizeof(error->text));
 615                 ast_copy_string(error->source, jansson_error->source, sizeof(error->source));
 616         }
 617
 618 }
 619
 620 static void parse_error(struct ast_json_error *error, const char *text, const char *source)
 621 {
 622         if (error != NULL) {
 623                 error->line = 0;
 624                 error->column = 0;
 625                 error->position = 0;
 626                 strncpy(error->text, text, sizeof(error->text));
 627                 strncpy(error->source, source, sizeof(error->text));
 628         }
 629 }
 630
 631 struct ast_json *ast_json_load_string(const char *input, struct ast_json_error *error)
 632 {
 633         json_error_t jansson_error = {};
 634         struct ast_json *r = NULL;
 635         if (input != NULL) {
 636                 r = (struct ast_json *)json_loads(input, 0, &jansson_error);
 637                 copy_error(error, &jansson_error);
 638         } else {
 639                 parse_error(error, "NULL input string", "<null>");
 640         }
 641         return r;
 642 }
 643
 644 struct ast_json *ast_json_load_str(const struct ast_str *input, struct ast_json_error *error)
 645 {
 646         return ast_json_load_string(ast_str_buffer(input), error);
 647 }
 648
 649 struct ast_json *ast_json_load_buf(const char *buffer, size_t buflen, struct ast_json_error *error)
 650 {
 651         json_error_t jansson_error = {};
 652         struct ast_json *r = (struct ast_json *)json_loadb(buffer, buflen, 0, &jansson_error);
 653         copy_error(error, &jansson_error);
 654         return r;
 655 }
 656 struct ast_json *ast_json_load_file(FILE *input, struct ast_json_error *error)
 657 {
 658         json_error_t jansson_error = {};
 659         struct ast_json *r = NULL;
 660         if (input != NULL) {
 661                 r = (struct ast_json *)json_loadf(input, 0, &jansson_error);
 662                 copy_error(error, &jansson_error);
 663         } else {
 664                 parse_error(error, "NULL input file", "<null>");
 665         }
 666         return r;
 667 }
 668 struct ast_json *ast_json_load_new_file(const char *path, struct ast_json_error *error)
 669 {
 670         json_error_t jansson_error = {};
 671         struct ast_json *r = (struct ast_json *)json_load_file(path, 0, &jansson_error);
 672         copy_error(error, &jansson_error);
 673         return r;
 674 }
 675
 676 struct ast_json *ast_json_pack(char const *format, ...)
 677 {
 678         struct ast_json *ret;
 679         va_list args;
 680         va_start(args, format);
 681         ret = ast_json_vpack(format, args);
 682         va_end(args);
 683         return ret;
 684 }
 685 struct ast_json *ast_json_vpack(char const *format, va_list ap)
 686 {
 687         struct ast_json *r = NULL;
 688         if (format) {
 689                 r = (struct ast_json *)json_vpack_ex(NULL, 0, format, ap);
 690         }
 691         return r;
 692 }
 693
 694 struct ast_json *ast_json_copy(const struct ast_json *value)
 695 {
 696         return (struct ast_json *)json_copy((json_t *)value);
 697 }
 698 struct ast_json *ast_json_deep_copy(const struct ast_json *value)
 699 {
 700         return (struct ast_json *)json_deep_copy((json_t *)value);
 701 }
 702
 703 struct ast_json *ast_json_name_number(const char *name, const char *number)
 704 {
 705         return ast_json_pack("{s: s, s: s}",
 706                              "name", name,
 707                              "number", number);
 708 }
 709
 710 struct ast_json *ast_json_dialplan_cep(const char *context, const char *exten, int priority)
 711 {
 712         return ast_json_pack("{s: o, s: o, s: o}",
 713                              "context", context ? ast_json_string_create(context) : ast_json_null(),
 714                              "exten", exten ? ast_json_string_create(exten) : ast_json_null(),
 715                              "priority", priority != -1 ? ast_json_integer_create(priority) : ast_json_null());
 716 }
 717
 718 struct ast_json *ast_json_timeval(const struct timeval tv, const char *zone)
 719 {
 720         char buf[AST_ISO8601_LEN];
 721         struct ast_tm tm = {};
 722
 723         ast_localtime(&tv, &tm, zone);
 724
 725         ast_strftime(buf, sizeof(buf),AST_ISO8601_FORMAT, &tm);
 726
 727         return ast_json_string_create(buf);
 728 }
 729
 730 struct ast_json *ast_json_ipaddr(const struct ast_sockaddr *addr, enum ast_transport transport_type)
 731 {
 732         struct ast_str *string = ast_str_alloca(64);
 733
 734         if (!string) {
 735                 return NULL;
 736         }
 737
 738         ast_str_set(&string, 0, (ast_sockaddr_is_ipv4(addr) ||
 739                 ast_sockaddr_is_ipv4_mapped(addr)) ? "IPV4/" : "IPV6/");
 740
 741         if (transport_type) {
 742                 char *transport_string = NULL;
 743
 744                 /* NOTE: None will be applied if multiple transport types are specified in transport_type */
 745                 switch(transport_type) {
 746                 case AST_TRANSPORT_UDP:
 747                         transport_string = "UDP";
 748                         break;
 749                 case AST_TRANSPORT_TCP:
 750                         transport_string = "TCP";
 751                         break;
 752                 case AST_TRANSPORT_TLS:
 753                         transport_string = "TLS";
 754                         break;
 755                 case AST_TRANSPORT_WS:
 756                         transport_string = "WS";
 757                         break;
 758                 case AST_TRANSPORT_WSS:
 759                         transport_string = "WSS";
 760                         break;
 761                 }
 762
 763                 if (transport_string) {
 764                         ast_str_append(&string, 0, "%s/", transport_string);
 765                 }
 766         }
 767
 768         ast_str_append(&string, 0, "%s", ast_sockaddr_stringify_addr(addr));
 769         ast_str_append(&string, 0, "/%s", ast_sockaddr_stringify_port(addr));
 770
 771         return ast_json_string_create(ast_str_buffer(string));
 772 }
 773
 774 void ast_json_init(void)
 775 {
 776         /* Setup to use Asterisk custom allocators */
 777         ast_json_reset_alloc_funcs();
 778 }
 779
 780 static void json_payload_destructor(void *obj)
 781 {
 782         struct ast_json_payload *payload = obj;
 783         ast_json_unref(payload->json);
 784 }
 785
 786 struct ast_json_payload *ast_json_payload_create(struct ast_json *json)
 787 {
 788         struct ast_json_payload *payload;
 789
 790         if (!(payload = ao2_alloc(sizeof(*payload), json_payload_destructor))) {
 791                 return NULL;
 792         }
 793
 794         ast_json_ref(json);
 795         payload->json = json;
 796
 797         return payload;
 798 }
 799
 800 static struct ast_json *json_party_number(struct ast_party_number *number)
 801 {
 802         if (!number->valid) {
 803                 return NULL;
 804         }
 805         return ast_json_pack("{s: s, s: i, s: i, s: s}",
 806                 "number", number->str,
 807                 "plan", number->plan,
 808                 "presentation", number->presentation,
 809                 "presentation_txt", ast_describe_caller_presentation(number->presentation));
 810 }
 811
 812 static struct ast_json *json_party_name(struct ast_party_name *name)
 813 {
 814         if (!name->valid) {
 815                 return NULL;
 816         }
 817         return ast_json_pack("{s: s, s: s, s: i, s: s}",
 818                 "name", name->str,
 819                 "character_set", ast_party_name_charset_describe(name->char_set),
 820                 "presentation", name->presentation,
 821                 "presentation_txt", ast_describe_caller_presentation(name->presentation));
 822 }
 823
 824 static struct ast_json *json_party_subaddress(struct ast_party_subaddress *subaddress)
 825 {
 826         if (!subaddress->valid) {
 827                 return NULL;
 828         }
 829         return ast_json_pack("{s: s, s: i, s: b}",
 830                 "subaddress", subaddress->str,
 831                 "type", subaddress->type,
 832                 "odd", subaddress->odd_even_indicator);
 833 }
 834
 835 struct ast_json *ast_json_party_id(struct ast_party_id *party)
 836 {
 837         RAII_VAR(struct ast_json *, json_party_id, NULL, ast_json_unref);
 838         int pres;
 839
 840         /* Combined party presentation */
 841         pres = ast_party_id_presentation(party);
 842         json_party_id = ast_json_pack("{s: i, s: s}",
 843                 "presentation", pres,
 844                 "presentation_txt", ast_describe_caller_presentation(pres));
 845         if (!json_party_id) {
 846                 return NULL;
 847         }
 848
 849         /* Party number */
 850         if (party->number.valid && ast_json_object_set(json_party_id, "number", json_party_number(&party->number))) {
 851                 return NULL;
 852         }
 853
 854         /* Party name */
 855         if (party->name.valid && ast_json_object_set(json_party_id, "name", json_party_name(&party->name))) {
 856                 return NULL;
 857         }
 858
 859         /* Party subaddress */
 860         if (party->subaddress.valid && ast_json_object_set(json_party_id, "subaddress", json_party_subaddress(&party->subaddress))) {
 861                 return NULL;
 862         }
 863
 864         return ast_json_ref(json_party_id);
 865 }