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 = vasprintf(&str, format, args);
 344                 if (err > 0) {
 345                         ret = json_string(str);
 346                         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                 if (ast_json_object_get(object, key) != NULL) {
 470                         ret = ast_json_object_set(object, key, ast_json_object_iter_value(iter));
 471                 }
 472                 iter = ast_json_object_iter_next(other, iter);
 473         }
 474         return ret;
 475 #endif
 476 }
 477 int ast_json_object_update_missing(struct ast_json *object, struct ast_json *other)
 478 {
 479 #if JANSSON_VERSION_HEX >= 0x020300
 480         return json_object_update_missing((json_t *)object, (json_t *)other);
 481 #else
 482         struct ast_json_iter *iter = ast_json_object_iter(other);
 483         int ret = 0;
 484
 485         if (object == NULL || other == NULL) {
 486                 return -1;
 487         }
 488
 489         while (iter != NULL && ret == 0) {
 490                 const char *key = ast_json_object_iter_key(iter);
 491                 if (ast_json_object_get(object, key) == NULL) {
 492                         ret = ast_json_object_set(object, key, ast_json_object_iter_value(iter));
 493                 }
 494                 iter = ast_json_object_iter_next(other, iter);
 495         }
 496         return ret;
 497 #endif
 498 }
 499
 500 struct ast_json_iter *ast_json_object_iter(struct ast_json *object)
 501 {
 502         return json_object_iter((json_t *)object);
 503 }
 504 struct ast_json_iter *ast_json_object_iter_at(struct ast_json *object, const char *key)
 505 {
 506         return json_object_iter_at((json_t *)object, key);
 507 }
 508 struct ast_json_iter *ast_json_object_iter_next(struct ast_json *object, struct ast_json_iter *iter)
 509 {
 510         return json_object_iter_next((json_t *)object, iter);
 511 }
 512 const char *ast_json_object_iter_key(struct ast_json_iter *iter)
 513 {
 514         return json_object_iter_key(iter);
 515 }
 516 struct ast_json *ast_json_object_iter_value(struct ast_json_iter *iter)
 517 {
 518         return (struct ast_json *)json_object_iter_value(iter);
 519 }
 520 int ast_json_object_iter_set(struct ast_json *object, struct ast_json_iter *iter, struct ast_json *value)
 521 {
 522         return json_object_iter_set_new((json_t *)object, iter, (json_t *)value);
 523 }
 524
 525 /*!
 526  * \brief Default flags for JSON encoding.
 527  */
 528 static size_t dump_flags(enum ast_json_encoding_format format)
 529 {
 530         return format == AST_JSON_PRETTY ?
 531                 JSON_INDENT(2) | JSON_PRESERVE_ORDER : JSON_COMPACT;
 532 }
 533
 534 char *ast_json_dump_string_format(struct ast_json *root, enum ast_json_encoding_format format)
 535 {
 536         /* Jansson's json_dump*, even though it's a read operation, isn't
 537          * thread safe for concurrent reads. Locking is necessary.
 538          * See http://www.digip.org/jansson/doc/2.4/portability.html#thread-safety. */
 539         SCOPED_JSON_LOCK(root);
 540         return json_dumps((json_t *)root, dump_flags(format));
 541 }
 542
 543 static int write_to_ast_str(const char *buffer, size_t size, void *data)
 544 {
 545         struct ast_str **dst = data;
 546         size_t str_size = ast_str_size(*dst);
 547         size_t remaining = str_size - ast_str_strlen(*dst);
 548         int ret;
 549
 550         /* While ast_str_append will grow the ast_str, it won't report
 551          * allocation errors. Fortunately, it's not that hard.
 552          */
 553
 554         /* Remaining needs to be big enough for buffer, plus null char */
 555         while (remaining < size + 1) {
 556                 /* doubling the size of the buffer gives us 'amortized
 557                  * constant' time.
 558                  * See http://stackoverflow.com/a/249695/115478 for info.
 559                  */
 560                 str_size *= 2;
 561                 remaining = str_size - ast_str_strlen(*dst);
 562         }
 563
 564         ret = ast_str_make_space(dst, str_size);
 565         if (ret == -1) {
 566                 /* Could not alloc; fail */
 567                 return -1;
 568         }
 569
 570         ast_str_append_substr(dst, -1, buffer, size);
 571         return 0;
 572 }
 573
 574 int ast_json_dump_str_format(struct ast_json *root, struct ast_str **dst, enum ast_json_encoding_format format)
 575 {
 576         /* Jansson's json_dump*, even though it's a read operation, isn't
 577          * thread safe for concurrent reads. Locking is necessary.
 578          * See http://www.digip.org/jansson/doc/2.4/portability.html#thread-safety. */
 579         SCOPED_JSON_LOCK(root);
 580         return json_dump_callback((json_t *)root, write_to_ast_str, dst, dump_flags(format));
 581 }
 582
 583
 584 int ast_json_dump_file_format(struct ast_json *root, FILE *output, 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         if (!root || !output) {
 591                 return -1;
 592         }
 593         return json_dumpf((json_t *)root, output, dump_flags(format));
 594 }
 595 int ast_json_dump_new_file_format(struct ast_json *root, const char *path, enum ast_json_encoding_format format)
 596 {
 597         /* Jansson's json_dump*, even though it's a read operation, isn't
 598          * thread safe for concurrent reads. Locking is necessary.
 599          * See http://www.digip.org/jansson/doc/2.4/portability.html#thread-safety. */
 600         SCOPED_JSON_LOCK(root);
 601         if (!root || !path) {
 602                 return -1;
 603         }
 604         return json_dump_file((json_t *)root, path, dump_flags(format));
 605 }
 606
 607 /*!
 608  * \brief Copy Jansson error struct to ours.
 609  */
 610 static void copy_error(struct ast_json_error *error, const json_error_t *jansson_error)
 611 {
 612         if (error && jansson_error) {
 613                 error->line = jansson_error->line;
 614                 error->column = jansson_error->column;
 615                 error->position = jansson_error->position;
 616                 ast_copy_string(error->text, jansson_error->text, sizeof(error->text));
 617                 ast_copy_string(error->source, jansson_error->source, sizeof(error->source));
 618         }
 619
 620 }
 621
 622 static void parse_error(struct ast_json_error *error, const char *text, const char *source)
 623 {
 624         if (error != NULL) {
 625                 error->line = 0;
 626                 error->column = 0;
 627                 error->position = 0;
 628                 strncpy(error->text, text, sizeof(error->text));
 629                 strncpy(error->source, source, sizeof(error->text));
 630         }
 631 }
 632
 633 struct ast_json *ast_json_load_string(const char *input, struct ast_json_error *error)
 634 {
 635         json_error_t jansson_error = {};
 636         struct ast_json *r = NULL;
 637         if (input != NULL) {
 638                 r = (struct ast_json *)json_loads(input, 0, &jansson_error);
 639                 copy_error(error, &jansson_error);
 640         } else {
 641                 parse_error(error, "NULL input string", "<null>");
 642         }
 643         return r;
 644 }
 645
 646 struct ast_json *ast_json_load_str(const struct ast_str *input, struct ast_json_error *error)
 647 {
 648         return ast_json_load_string(ast_str_buffer(input), error);
 649 }
 650
 651 struct ast_json *ast_json_load_buf(const char *buffer, size_t buflen, struct ast_json_error *error)
 652 {
 653         json_error_t jansson_error = {};
 654         struct ast_json *r = (struct ast_json *)json_loadb(buffer, buflen, 0, &jansson_error);
 655         copy_error(error, &jansson_error);
 656         return r;
 657 }
 658 struct ast_json *ast_json_load_file(FILE *input, struct ast_json_error *error)
 659 {
 660         json_error_t jansson_error = {};
 661         struct ast_json *r = NULL;
 662         if (input != NULL) {
 663                 r = (struct ast_json *)json_loadf(input, 0, &jansson_error);
 664                 copy_error(error, &jansson_error);
 665         } else {
 666                 parse_error(error, "NULL input file", "<null>");
 667         }
 668         return r;
 669 }
 670 struct ast_json *ast_json_load_new_file(const char *path, struct ast_json_error *error)
 671 {
 672         json_error_t jansson_error = {};
 673         struct ast_json *r = (struct ast_json *)json_load_file(path, 0, &jansson_error);
 674         copy_error(error, &jansson_error);
 675         return r;
 676 }
 677
 678 struct ast_json *ast_json_pack(char const *format, ...)
 679 {
 680         struct ast_json *ret;
 681         va_list args;
 682         va_start(args, format);
 683         ret = ast_json_vpack(format, args);
 684         va_end(args);
 685         return ret;
 686 }
 687 struct ast_json *ast_json_vpack(char const *format, va_list ap)
 688 {
 689         struct ast_json *r = NULL;
 690         if (format) {
 691                 r = (struct ast_json *)json_vpack_ex(NULL, 0, format, ap);
 692         }
 693         return r;
 694 }
 695
 696 struct ast_json *ast_json_copy(const struct ast_json *value)
 697 {
 698         return (struct ast_json *)json_copy((json_t *)value);
 699 }
 700 struct ast_json *ast_json_deep_copy(const struct ast_json *value)
 701 {
 702         return (struct ast_json *)json_deep_copy((json_t *)value);
 703 }
 704
 705 struct ast_json *ast_json_name_number(const char *name, const char *number)
 706 {
 707         return ast_json_pack("{s: s, s: s}",
 708                              "name", name,
 709                              "number", number);
 710 }
 711
 712 struct ast_json *ast_json_dialplan_cep(const char *context, const char *exten, int priority)
 713 {
 714         return ast_json_pack("{s: o, s: o, s: o}",
 715                              "context", context ? ast_json_string_create(context) : ast_json_null(),
 716                              "exten", exten ? ast_json_string_create(exten) : ast_json_null(),
 717                              "priority", priority != -1 ? ast_json_integer_create(priority) : ast_json_null());
 718 }
 719
 720 struct ast_json *ast_json_timeval(const struct timeval tv, const char *zone)
 721 {
 722         char buf[AST_ISO8601_LEN];
 723         struct ast_tm tm = {};
 724
 725         ast_localtime(&tv, &tm, zone);
 726
 727         ast_strftime(buf, sizeof(buf),AST_ISO8601_FORMAT, &tm);
 728
 729         return ast_json_string_create(buf);
 730 }
 731
 732 struct ast_json *ast_json_ipaddr(const struct ast_sockaddr *addr, enum ast_transport transport_type)
 733 {
 734         struct ast_str *string = ast_str_alloca(64);
 735
 736         if (!string) {
 737                 return NULL;
 738         }
 739
 740         ast_str_set(&string, 0, (ast_sockaddr_is_ipv4(addr) ||
 741                 ast_sockaddr_is_ipv4_mapped(addr)) ? "IPV4/" : "IPV6/");
 742
 743         if (transport_type) {
 744                 char *transport_string = NULL;
 745
 746                 /* NOTE: None will be applied if multiple transport types are specified in transport_type */
 747                 switch(transport_type) {
 748                 case AST_TRANSPORT_UDP:
 749                         transport_string = "UDP";
 750                         break;
 751                 case AST_TRANSPORT_TCP:
 752                         transport_string = "TCP";
 753                         break;
 754                 case AST_TRANSPORT_TLS:
 755                         transport_string = "TLS";
 756                         break;
 757                 case AST_TRANSPORT_WS:
 758                         transport_string = "WS";
 759                         break;
 760                 case AST_TRANSPORT_WSS:
 761                         transport_string = "WSS";
 762                         break;
 763                 }
 764
 765                 if (transport_string) {
 766                         ast_str_append(&string, 0, "%s/", transport_string);
 767                 }
 768         }
 769
 770         ast_str_append(&string, 0, "%s", ast_sockaddr_stringify_addr(addr));
 771         ast_str_append(&string, 0, "/%s", ast_sockaddr_stringify_port(addr));
 772
 773         return ast_json_string_create(ast_str_buffer(string));
 774 }
 775
 776 void ast_json_init(void)
 777 {
 778         /* Setup to use Asterisk custom allocators */
 779         ast_json_reset_alloc_funcs();
 780 }
 781
 782 static void json_payload_destructor(void *obj)
 783 {
 784         struct ast_json_payload *payload = obj;
 785         ast_json_unref(payload->json);
 786 }
 787
 788 struct ast_json_payload *ast_json_payload_create(struct ast_json *json)
 789 {
 790         struct ast_json_payload *payload;
 791
 792         if (!(payload = ao2_alloc(sizeof(*payload), json_payload_destructor))) {
 793                 return NULL;
 794         }
 795
 796         ast_json_ref(json);
 797         payload->json = json;
 798
 799         return payload;
 800 }
 801
 802 static struct ast_json *json_party_number(struct ast_party_number *number)
 803 {
 804         if (!number->valid) {
 805                 return NULL;
 806         }
 807         return ast_json_pack("{s: s, s: i, s: i, s: s}",
 808                 "number", number->str,
 809                 "plan", number->plan,
 810                 "presentation", number->presentation,
 811                 "presentation_txt", ast_describe_caller_presentation(number->presentation));
 812 }
 813
 814 static struct ast_json *json_party_name(struct ast_party_name *name)
 815 {
 816         if (!name->valid) {
 817                 return NULL;
 818         }
 819         return ast_json_pack("{s: s, s: s, s: i, s: s}",
 820                 "name", name->str,
 821                 "character_set", ast_party_name_charset_describe(name->char_set),
 822                 "presentation", name->presentation,
 823                 "presentation_txt", ast_describe_caller_presentation(name->presentation));
 824 }
 825
 826 static struct ast_json *json_party_subaddress(struct ast_party_subaddress *subaddress)
 827 {
 828         if (!subaddress->valid) {
 829                 return NULL;
 830         }
 831         return ast_json_pack("{s: s, s: i, s: b}",
 832                 "subaddress", subaddress->str,
 833                 "type", subaddress->type,
 834                 "odd", subaddress->odd_even_indicator);
 835 }
 836
 837 struct ast_json *ast_json_party_id(struct ast_party_id *party)
 838 {
 839         RAII_VAR(struct ast_json *, json_party_id, NULL, ast_json_unref);
 840         int pres;
 841
 842         /* Combined party presentation */
 843         pres = ast_party_id_presentation(party);
 844         json_party_id = ast_json_pack("{s: i, s: s}",
 845                 "presentation", pres,
 846                 "presentation_txt", ast_describe_caller_presentation(pres));
 847         if (!json_party_id) {
 848                 return NULL;
 849         }
 850
 851         /* Party number */
 852         if (party->number.valid && ast_json_object_set(json_party_id, "number", json_party_number(&party->number))) {
 853                 return NULL;
 854         }
 855
 856         /* Party name */
 857         if (party->name.valid && ast_json_object_set(json_party_id, "name", json_party_name(&party->name))) {
 858                 return NULL;
 859         }
 860
 861         /* Party subaddress */
 862         if (party->subaddress.valid && ast_json_object_set(json_party_id, "subaddress", json_party_subaddress(&party->subaddress))) {
 863                 return NULL;
 864         }
 865
 866         return ast_json_ref(json_party_id);
 867 }