12 All declarations are in :file:`jansson.h`, so it's enough to
20 All constants are prefixed with ``JSON_`` (except for those describing
21 the library version, prefixed with ``JANSSON_``). Other identifiers
22 are prefixed with ``json_``. Type names are suffixed with ``_t`` and
23 ``typedef``\ 'd so that the ``struct`` keyword need not be used.
29 The Jansson version is of the form *A.B.C*, where *A* is the major
30 version, *B* is the minor version and *C* is the micro version. If the
31 micro version is zero, it's omitted from the version string, i.e. the
32 version string is just *A.B*.
34 When a new release only fixes bugs and doesn't add new features or
35 functionality, the micro version is incremented. When new features are
36 added in a backwards compatible way, the minor version is incremented
37 and the micro version is set to zero. When there are backwards
38 incompatible changes, the major version is incremented and others are
41 The following preprocessor constants specify the current version of
44 ``JANSSON_MAJOR_VERSION``, ``JANSSON_MINOR_VERSION``, ``JANSSON_MICRO_VERSION``
45 Integers specifying the major, minor and micro versions,
49 A string representation of the current version, e.g. ``"1.2.1"`` or
52 ``JANSSON_VERSION_HEX``
53 A 3-byte hexadecimal representation of the version, e.g.
54 ``0x010201`` for version 1.2.1 and ``0x010300`` for version 1.3.
55 This is useful in numeric comparisions, e.g.::
57 #if JANSSON_VERSION_HEX >= 0x010300
58 /* Code specific to version 1.3 and above */
65 The JSON specification (:rfc:`4627`) defines the following data types:
66 *object*, *array*, *string*, *number*, *boolean*, and *null*. JSON
67 types are used dynamically; arrays and objects can hold any other data
68 type, including themselves. For this reason, Jansson's type system is
69 also dynamic in nature. There's one C type to represent all JSON
70 values, and this structure knows the type of the JSON value it holds.
74 This data structure is used throughout the library to represent all
75 JSON values. It always contains the type of the JSON value it holds
76 and the value's reference count. The rest depends on the type of the
79 Objects of :type:`json_t` are always used through a pointer. There
80 are APIs for querying the type, manipulating the reference count, and
81 for constructing and manipulating values of different types.
83 Unless noted otherwise, all API functions return an error value if an
84 error occurs. Depending on the function's signature, the error value
85 is either *NULL* or -1. Invalid arguments or invalid input are
86 apparent sources for errors. Memory allocation and I/O operations may
93 The type of a JSON value is queried and tested using the following
96 .. type:: enum json_type
98 The type of a JSON value. The following members are defined:
100 +--------------------+
102 +--------------------+
104 +--------------------+
106 +--------------------+
108 +--------------------+
110 +--------------------+
112 +--------------------+
114 +--------------------+
116 +--------------------+
118 These correspond to JSON object, array, string, number, boolean and
119 null. A number is represented by either a value of the type
120 ``JSON_INTEGER`` or of the type ``JSON_REAL``. A true boolean value
121 is represented by a value of the type ``JSON_TRUE`` and false by a
122 value of the type ``JSON_FALSE``.
124 .. function:: int json_typeof(const json_t *json)
126 Return the type of the JSON value (a :type:`json_type` cast to
127 :type:`int`). *json* MUST NOT be *NULL*. This function is actually
128 implemented as a macro for speed.
130 .. function:: json_is_object(const json_t *json)
131 json_is_array(const json_t *json)
132 json_is_string(const json_t *json)
133 json_is_integer(const json_t *json)
134 json_is_real(const json_t *json)
135 json_is_true(const json_t *json)
136 json_is_false(const json_t *json)
137 json_is_null(const json_t *json)
139 These functions (actually macros) return true (non-zero) for values
140 of the given type, and false (zero) for values of other types and
143 .. function:: json_is_number(const json_t *json)
145 Returns true for values of types ``JSON_INTEGER`` and
146 ``JSON_REAL``, and false for other types and for *NULL*.
148 .. function:: json_is_boolean(const json_t *json)
150 Returns true for types ``JSON_TRUE`` and ``JSON_FALSE``, and false
151 for values of other types and for *NULL*.
154 .. _apiref-reference-count:
159 The reference count is used to track whether a value is still in use
160 or not. When a value is created, it's reference count is set to 1. If
161 a reference to a value is kept (e.g. a value is stored somewhere for
162 later use), its reference count is incremented, and when the value is
163 no longer needed, the reference count is decremented. When the
164 reference count drops to zero, there are no references left, and the
165 value can be destroyed.
167 The following functions are used to manipulate the reference count.
169 .. function:: json_t *json_incref(json_t *json)
171 Increment the reference count of *json* if it's not non-*NULL*.
174 .. function:: void json_decref(json_t *json)
176 Decrement the reference count of *json*. As soon as a call to
177 :func:`json_decref()` drops the reference count to zero, the value
178 is destroyed and it can no longer be used.
180 Functions creating new JSON values set the reference count to 1. These
181 functions are said to return a **new reference**. Other functions
182 returning (existing) JSON values do not normally increase the
183 reference count. These functions are said to return a **borrowed
184 reference**. So, if the user will hold a reference to a value returned
185 as a borrowed reference, he must call :func:`json_incref`. As soon as
186 the value is no longer needed, :func:`json_decref` should be called
187 to release the reference.
189 Normally, all functions accepting a JSON value as an argument will
190 manage the reference, i.e. increase and decrease the reference count
191 as needed. However, some functions **steal** the reference, i.e. they
192 have the same result as if the user called :func:`json_decref()` on
193 the argument right after calling the function. These functions are
194 suffixed with ``_new`` or have ``_new_`` somewhere in their name.
196 For example, the following code creates a new JSON array and appends
199 json_t *array, *integer;
201 array = json_array();
202 integer = json_integer(42);
204 json_array_append(array, integer);
205 json_decref(integer);
207 Note how the caller has to release the reference to the integer value
208 by calling :func:`json_decref()`. By using a reference stealing
209 function :func:`json_array_append_new()` instead of
210 :func:`json_array_append()`, the code becomes much simpler::
212 json_t *array = json_array();
213 json_array_append_new(array, json_integer(42));
215 In this case, the user doesn't have to explicitly release the
216 reference to the integer value, as :func:`json_array_append_new()`
217 steals the reference when appending the value to the array.
219 In the following sections it is clearly documented whether a function
220 will return a new or borrowed reference or steal a reference to its
227 A circular reference is created when an object or an array is,
228 directly or indirectly, inserted inside itself. The direct case is
231 json_t *obj = json_object();
232 json_object_set(obj, "foo", obj);
234 Jansson will refuse to do this, and :func:`json_object_set()` (and
235 all the other such functions for objects and arrays) will return with
236 an error status. The indirect case is the dangerous one::
238 json_t *arr1 = json_array(), *arr2 = json_array();
239 json_array_append(arr1, arr2);
240 json_array_append(arr2, arr1);
242 In this example, the array ``arr2`` is contained in the array
243 ``arr1``, and vice versa. Jansson cannot check for this kind of
244 indirect circular references without a performance hit, so it's up to
245 the user to avoid them.
247 If a circular reference is created, the memory consumed by the values
248 cannot be freed by :func:`json_decref()`. The reference counts never
249 drops to zero because the values are keeping the references to each
250 other. Moreover, trying to encode the values with any of the encoding
251 functions will fail. The encoder detects circular references and
252 returns an error status.
258 These three values are implemented as singletons, so the returned
259 pointers won't change between invocations of these functions.
261 .. function:: json_t *json_true(void)
265 Returns the JSON true value.
267 .. function:: json_t *json_false(void)
271 Returns the JSON false value.
273 .. function:: json_t *json_boolean(val)
277 Returns JSON false if ``val`` is zero, and JSON true otherwise.
278 This is a macro, and equivalent to ``val ? json_true() :
282 .. function:: json_t *json_null(void)
286 Returns the JSON null value.
292 Jansson uses UTF-8 as the character encoding. All JSON strings must be
293 valid UTF-8 (or ASCII, as it's a subset of UTF-8). Normal null
294 terminated C strings are used, so JSON strings may not contain
295 embedded null characters. All other Unicode codepoints U+0001 through
296 U+10FFFF are allowed.
298 .. function:: json_t *json_string(const char *value)
302 Returns a new JSON string, or *NULL* on error. *value* must be a
303 valid UTF-8 encoded Unicode string.
305 .. function:: json_t *json_string_nocheck(const char *value)
309 Like :func:`json_string`, but doesn't check that *value* is valid
310 UTF-8. Use this function only if you are certain that this really
311 is the case (e.g. you have already checked it by other means).
313 .. function:: const char *json_string_value(const json_t *string)
315 Returns the associated value of *string* as a null terminated UTF-8
316 encoded string, or *NULL* if *string* is not a JSON string.
318 The retuned value is read-only and must not be modified or freed by
319 the user. It is valid as long as *string* exists, i.e. as long as
320 its reference count has not dropped to zero.
322 .. function:: int json_string_set(const json_t *string, const char *value)
324 Sets the associated value of *string* to *value*. *value* must be a
325 valid UTF-8 encoded Unicode string. Returns 0 on success and -1 on
328 .. function:: int json_string_set_nocheck(const json_t *string, const char *value)
330 Like :func:`json_string_set`, but doesn't check that *value* is
331 valid UTF-8. Use this function only if you are certain that this
332 really is the case (e.g. you have already checked it by other
339 The JSON specification only contains one numeric type, "number". The C
340 programming language has distinct types for integer and floating-point
341 numbers, so for practical reasons Jansson also has distinct types for
342 the two. They are called "integer" and "real", respectively. For more
343 information, see :ref:`rfc-conformance`.
347 This is the C type that is used to store JSON integer values. It
348 represents the widest integer type available on your system. In
349 practice it's just a typedef of ``long long`` if your compiler
350 supports it, otherwise ``long``.
352 Usually, you can safely use plain ``int`` in place of
353 ``json_int_t``, and the implicit C integer conversion handles the
354 rest. Only when you know that you need the full 64-bit range, you
355 should use ``json_int_t`` explicitly.
357 ``JSON_INTEGER_IS_LONG_LONG``
359 This is a preprocessor variable that holds the value 1 if
360 :type:`json_int_t` is ``long long``, and 0 if it's ``long``. It
361 can be used as follows::
363 #if JSON_INTEGER_IS_LONG_LONG
364 /* Code specific for long long */
366 /* Code specific for long */
369 ``JSON_INTEGER_FORMAT``
371 This is a macro that expands to a :func:`printf()` conversion
372 specifier that corresponds to :type:`json_int_t`, without the
373 leading ``%`` sign, i.e. either ``"lld"`` or ``"ld"``. This macro
374 is required because the actual type of :type:`json_int_t` can be
375 either ``long`` or ``long long``, and :func:`printf()` reuiqres
376 different length modifiers for the two.
380 json_int_t x = 123123123;
381 printf("x is %" JSON_INTEGER_FORMAT "\n", x);
384 .. function:: json_t *json_integer(json_int_t value)
388 Returns a new JSON integer, or *NULL* on error.
390 .. function:: json_int_t json_integer_value(const json_t *integer)
392 Returns the associated value of *integer*, or 0 if *json* is not a
395 .. function:: int json_integer_set(const json_t *integer, json_int_t value)
397 Sets the associated value of *integer* to *value*. Returns 0 on
398 success and -1 if *integer* is not a JSON integer.
400 .. function:: json_t *json_real(double value)
404 Returns a new JSON real, or *NULL* on error.
406 .. function:: double json_real_value(const json_t *real)
408 Returns the associated value of *real*, or 0.0 if *real* is not a
411 .. function:: int json_real_set(const json_t *real, double value)
413 Sets the associated value of *real* to *value*. Returns 0 on
414 success and -1 if *real* is not a JSON real.
416 In addition to the functions above, there's a common query function
417 for integers and reals:
419 .. function:: double json_number_value(const json_t *json)
421 Returns the associated value of the JSON integer or JSON real
422 *json*, cast to double regardless of the actual type. If *json* is
423 neither JSON real nor JSON integer, 0.0 is returned.
429 A JSON array is an ordered collection of other JSON values.
431 .. function:: json_t *json_array(void)
435 Returns a new JSON array, or *NULL* on error. Initially, the array
438 .. function:: size_t json_array_size(const json_t *array)
440 Returns the number of elements in *array*, or 0 if *array* is NULL
443 .. function:: json_t *json_array_get(const json_t *array, size_t index)
445 .. refcounting:: borrow
447 Returns the element in *array* at position *index*. The valid range
448 for *index* is from 0 to the return value of
449 :func:`json_array_size()` minus 1. If *array* is not a JSON array,
450 if *array* is *NULL*, or if *index* is out of range, *NULL* is
453 .. function:: int json_array_set(json_t *array, size_t index, json_t *value)
455 Replaces the element in *array* at position *index* with *value*.
456 The valid range for *index* is from 0 to the return value of
457 :func:`json_array_size()` minus 1. Returns 0 on success and -1 on
460 .. function:: int json_array_set_new(json_t *array, size_t index, json_t *value)
462 Like :func:`json_array_set()` but steals the reference to *value*.
463 This is useful when *value* is newly created and not used after
466 .. function:: int json_array_append(json_t *array, json_t *value)
468 Appends *value* to the end of *array*, growing the size of *array*
469 by 1. Returns 0 on success and -1 on error.
471 .. function:: int json_array_append_new(json_t *array, json_t *value)
473 Like :func:`json_array_append()` but steals the reference to
474 *value*. This is useful when *value* is newly created and not used
477 .. function:: int json_array_insert(json_t *array, size_t index, json_t *value)
479 Inserts *value* to *array* at position *index*, shifting the
480 elements at *index* and after it one position towards the end of
481 the array. Returns 0 on success and -1 on error.
483 .. function:: int json_array_insert_new(json_t *array, size_t index, json_t *value)
485 Like :func:`json_array_insert()` but steals the reference to
486 *value*. This is useful when *value* is newly created and not used
489 .. function:: int json_array_remove(json_t *array, size_t index)
491 Removes the element in *array* at position *index*, shifting the
492 elements after *index* one position towards the start of the array.
493 Returns 0 on success and -1 on error. The reference count of the
494 removed value is decremented.
496 .. function:: int json_array_clear(json_t *array)
498 Removes all elements from *array*. Returns 0 on sucess and -1 on
499 error. The reference count of all removed values are decremented.
501 .. function:: int json_array_extend(json_t *array, json_t *other_array)
503 Appends all elements in *other_array* to the end of *array*.
504 Returns 0 on success and -1 on error.
510 A JSON object is a dictionary of key-value pairs, where the key is a
511 Unicode string and the value is any JSON value.
513 .. function:: json_t *json_object(void)
517 Returns a new JSON object, or *NULL* on error. Initially, the
520 .. function:: size_t json_object_size(const json_t *object)
522 Returns the number of elements in *object*, or 0 if *object* is not
525 .. function:: json_t *json_object_get(const json_t *object, const char *key)
527 .. refcounting:: borrow
529 Get a value corresponding to *key* from *object*. Returns *NULL* if
530 *key* is not found and on error.
532 .. function:: int json_object_set(json_t *object, const char *key, json_t *value)
534 Set the value of *key* to *value* in *object*. *key* must be a
535 valid null terminated UTF-8 encoded Unicode string. If there
536 already is a value for *key*, it is replaced by the new value.
537 Returns 0 on success and -1 on error.
539 .. function:: int json_object_set_nocheck(json_t *object, const char *key, json_t *value)
541 Like :func:`json_object_set`, but doesn't check that *key* is
542 valid UTF-8. Use this function only if you are certain that this
543 really is the case (e.g. you have already checked it by other
546 .. function:: int json_object_set_new(json_t *object, const char *key, json_t *value)
548 Like :func:`json_object_set()` but steals the reference to
549 *value*. This is useful when *value* is newly created and not used
552 .. function:: int json_object_set_new_nocheck(json_t *object, const char *key, json_t *value)
554 Like :func:`json_object_set_new`, but doesn't check that *key* is
555 valid UTF-8. Use this function only if you are certain that this
556 really is the case (e.g. you have already checked it by other
559 .. function:: int json_object_del(json_t *object, const char *key)
561 Delete *key* from *object* if it exists. Returns 0 on success, or
562 -1 if *key* was not found. The reference count of the removed value
565 .. function:: int json_object_clear(json_t *object)
567 Remove all elements from *object*. Returns 0 on success and -1 if
568 *object* is not a JSON object. The reference count of all removed
569 values are decremented.
571 .. function:: int json_object_update(json_t *object, json_t *other)
573 Update *object* with the key-value pairs from *other*, overwriting
574 existing keys. Returns 0 on success or -1 on error.
576 .. function:: int json_object_update_existing(json_t *object, json_t *other)
578 Like :func:`json_object_update()`, but only the values of existing
579 keys are updated. No new keys are created. Returns 0 on success or
582 .. versionadded:: 2.3
584 .. function:: int json_object_update_missing(json_t *object, json_t *other)
586 Like :func:`json_object_update()`, but only new keys are created.
587 The value of any existing key is not changed. Returns 0 on success
590 .. versionadded:: 2.3
592 The following macro can be used to iterate through all key-value pairs
595 .. function:: json_object_foreach(object, key, value)
597 Iterate over every key-value pair of ``object``, running the block
598 of code that follows each time with the proper values set to
599 variables ``key`` and ``value``, of types :type:`const char *` and
600 :type:`json_t *` respectively. Example::
602 /* obj is a JSON object */
606 json_object_foreach(obj, key, value) {
607 /* block of code that uses key and value */
610 The items are not returned in any particular order.
612 This macro expands to an ordinary ``for`` statement upon
613 preprocessing, so its performance is equivalent to that of
614 hand-written iteration code using the object iteration protocol
615 (see below). The main advantage of this macro is that it abstracts
616 away the complexity behind iteration, and makes for shorter, more
619 .. versionadded:: 2.3
622 The following functions implement an iteration protocol for objects,
623 allowing to iterate through all key-value pairs in an object. The
624 items are not returned in any particular order, as this would require
625 sorting due to the internal hashtable implementation.
627 .. function:: void *json_object_iter(json_t *object)
629 Returns an opaque iterator which can be used to iterate over all
630 key-value pairs in *object*, or *NULL* if *object* is empty.
632 .. function:: void *json_object_iter_at(json_t *object, const char *key)
634 Like :func:`json_object_iter()`, but returns an iterator to the
635 key-value pair in *object* whose key is equal to *key*, or NULL if
636 *key* is not found in *object*. Iterating forward to the end of
637 *object* only yields all key-value pairs of the object if *key*
638 happens to be the first key in the underlying hash table.
640 .. function:: void *json_object_iter_next(json_t *object, void *iter)
642 Returns an iterator pointing to the next key-value pair in *object*
643 after *iter*, or *NULL* if the whole object has been iterated
646 .. function:: const char *json_object_iter_key(void *iter)
648 Extract the associated key from *iter*.
650 .. function:: json_t *json_object_iter_value(void *iter)
652 .. refcounting:: borrow
654 Extract the associated value from *iter*.
656 .. function:: int json_object_iter_set(json_t *object, void *iter, json_t *value)
658 Set the value of the key-value pair in *object*, that is pointed to
659 by *iter*, to *value*.
661 .. function:: int json_object_iter_set_new(json_t *object, void *iter, json_t *value)
663 Like :func:`json_object_iter_set()`, but steals the reference to
664 *value*. This is useful when *value* is newly created and not used
667 .. function:: void *json_object_key_to_iter(const char *key)
669 Like :func:`json_object_iter_at()`, but much faster. Only works for
670 values returned by :func:`json_object_iter_key()`. Using other keys
671 will lead to segfaults. This function is used internally to
672 implement :func:`json_object_foreach`.
674 .. versionadded:: 2.3
676 The iteration protocol can be used for example as follows::
678 /* obj is a JSON object */
682 void *iter = json_object_iter(obj);
685 key = json_object_iter_key(iter);
686 value = json_object_iter_value(iter);
687 /* use key and value ... */
688 iter = json_object_iter_next(obj, iter);
695 Jansson uses a single struct type to pass error information to the
696 user. See sections :ref:`apiref-decoding`, :ref:`apiref-pack` and
697 :ref:`apiref-unpack` for functions that pass error information using
700 .. type:: json_error_t
702 .. member:: char text[]
704 The error message (in UTF-8), or an empty string if a message is
707 .. member:: char source[]
709 Source of the error. This can be (a part of) the file name or a
710 special identifier in angle brackers (e.g. ``<string>``).
714 The line number on which the error occurred.
716 .. member:: int column
718 The column on which the error occurred. Note that this is the
719 *character column*, not the byte column, i.e. a multibyte UTF-8
720 character counts as one column.
722 .. member:: size_t position
724 The position in bytes from the start of the input. This is
725 useful for debugging Unicode encoding problems.
727 The normal use of :type:`json_error_t` is to allocate it on the stack,
728 and pass a pointer to a function. Example::
734 json = json_load_file("/path/to/file.json", 0, &error);
736 /* the error variable contains error information */
741 Also note that if the call succeeded (``json != NULL`` in the above
742 example), the contents of ``error`` are generally left unspecified.
743 The decoding functions write to the ``position`` member also on
744 success. See :ref:`apiref-decoding` for more info.
746 All functions also accept *NULL* as the :type:`json_error_t` pointer,
747 in which case no error information is returned to the caller.
753 This sections describes the functions that can be used to encode
754 values to JSON. By default, only objects and arrays can be encoded
755 directly, since they are the only valid *root* values of a JSON text.
756 To encode any JSON value, use the ``JSON_ENCODE_ANY`` flag (see
759 By default, the output has no newlines, and spaces are used between
760 array and object elements for a readable output. This behavior can be
761 altered by using the ``JSON_INDENT`` and ``JSON_COMPACT`` flags
762 described below. A newline is never appended to the end of the encoded
765 Each function takes a *flags* parameter that controls some aspects of
766 how the data is encoded. Its default value is 0. The following macros
767 can be ORed together to obtain *flags*.
770 Pretty-print the result, using newlines between array and object
771 items, and indenting with *n* spaces. The valid range for *n* is
772 between 0 and 31 (inclusive), other values result in an undefined
773 output. If ``JSON_INDENT`` is not used or *n* is 0, no newlines are
774 inserted between array and object items.
777 This flag enables a compact representation, i.e. sets the separator
778 between array and object items to ``","`` and between object keys
779 and values to ``":"``. Without this flag, the corresponding
780 separators are ``", "`` and ``": "`` for more readable output.
782 ``JSON_ENSURE_ASCII``
783 If this flag is used, the output is guaranteed to consist only of
784 ASCII characters. This is achived by escaping all Unicode
785 characters outside the ASCII range.
788 If this flag is used, all the objects in output are sorted by key.
789 This is useful e.g. if two JSON texts are diffed or visually
792 ``JSON_PRESERVE_ORDER``
793 If this flag is used, object keys in the output are sorted into the
794 same order in which they were first inserted to the object. For
795 example, decoding a JSON text and then encoding with this flag
796 preserves the order of object keys.
799 Specifying this flag makes it possible to encode any JSON value on
800 its own. Without it, only objects and arrays can be passed as the
801 *root* value to the encoding functions.
803 **Note:** Encoding any value may be useful in some scenarios, but
804 it's generally discouraged as it violates strict compatiblity with
805 :rfc:`4627`. If you use this flag, don't expect interoperatibility
806 with other JSON systems.
808 .. versionadded:: 2.1
810 ``JSON_ESCAPE_SLASH``
811 Escape the ``/`` characters in strings with ``\/``.
813 .. versionadded:: 2.4
815 The following functions perform the actual JSON encoding. The result
818 .. function:: char *json_dumps(const json_t *root, size_t flags)
820 Returns the JSON representation of *root* as a string, or *NULL* on
821 error. *flags* is described above. The return value must be freed
822 by the caller using :func:`free()`.
824 .. function:: int json_dumpf(const json_t *root, FILE *output, size_t flags)
826 Write the JSON representation of *root* to the stream *output*.
827 *flags* is described above. Returns 0 on success and -1 on error.
828 If an error occurs, something may have already been written to
829 *output*. In this case, the output is undefined and most likely not
832 .. function:: int json_dump_file(const json_t *json, const char *path, size_t flags)
834 Write the JSON representation of *root* to the file *path*. If
835 *path* already exists, it is overwritten. *flags* is described
836 above. Returns 0 on success and -1 on error.
838 .. type:: json_dump_callback_t
840 A typedef for a function that's called by
841 :func:`json_dump_callback()`::
843 typedef int (*json_dump_callback_t)(const char *buffer, size_t size, void *data);
845 *buffer* points to a buffer containing a chunk of output, *size* is
846 the length of the buffer, and *data* is the corresponding
847 :func:`json_dump_callback()` argument passed through.
849 On error, the function should return -1 to stop the encoding
850 process. On success, it should return 0.
852 .. versionadded:: 2.2
854 .. function:: int json_dump_callback(const json_t *json, json_dump_callback_t callback, void *data, size_t flags)
856 Call *callback* repeatedly, passing a chunk of the JSON
857 representation of *root* each time. *flags* is described above.
858 Returns 0 on success and -1 on error.
860 .. versionadded:: 2.2
868 This sections describes the functions that can be used to decode JSON
869 text to the Jansson representation of JSON data. The JSON
870 specification requires that a JSON text is either a serialized array
871 or object, and this requirement is also enforced with the following
872 functions. In other words, the top level value in the JSON text being
873 decoded must be either array or object. To decode any JSON value, use
874 the ``JSON_DECODE_ANY`` flag (see below).
876 See :ref:`rfc-conformance` for a discussion on Jansson's conformance
877 to the JSON specification. It explains many design decisions that
878 affect especially the behavior of the decoder.
880 Each function takes a *flags* parameter that can be used to control
881 the behavior of the decoder. Its default value is 0. The following
882 macros can be ORed together to obtain *flags*.
884 ``JSON_REJECT_DUPLICATES``
885 Issue a decoding error if any JSON object in the input text
886 contains duplicate keys. Without this flag, the value of the last
887 occurence of each key ends up in the result. Key equivalence is
888 checked byte-by-byte, without special Unicode comparison
891 .. versionadded:: 2.1
894 By default, the decoder expects an array or object as the input.
895 With this flag enabled, the decoder accepts any valid JSON value.
897 **Note:** Decoding any value may be useful in some scenarios, but
898 it's generally discouraged as it violates strict compatiblity with
899 :rfc:`4627`. If you use this flag, don't expect interoperatibility
900 with other JSON systems.
902 .. versionadded:: 2.3
904 ``JSON_DISABLE_EOF_CHECK``
905 By default, the decoder expects that its whole input constitutes a
906 valid JSON text, and issues an error if there's extra data after
907 the otherwise valid JSON input. With this flag enabled, the decoder
908 stops after decoding a valid JSON array or object, and thus allows
909 extra data after the JSON text.
911 Normally, reading will stop when the last ``]`` or ``}`` in the
912 JSON input is encountered. If both ``JSON_DISABLE_EOF_CHECK`` and
913 ``JSON_DECODE_ANY`` flags are used, the decoder may read one extra
914 UTF-8 code unit (up to 4 bytes of input). For example, decoding
915 ``4true`` correctly decodes the integer 4, but also reads the
916 ``t``. For this reason, if reading multiple consecutive values that
917 are not arrays or objects, they should be separated by at least one
918 whitespace character.
920 .. versionadded:: 2.1
922 Each function also takes an optional :type:`json_error_t` parameter
923 that is filled with error information if decoding fails. It's also
924 updated on success; the number of bytes of input read is written to
925 its ``position`` field. This is especially useful when using
926 ``JSON_DISABLE_EOF_CHECK`` to read multiple consecutive JSON texts.
928 .. versionadded:: 2.3
929 Number of bytes of input read is written to the ``position`` field
930 of the :type:`json_error_t` structure.
932 If no error or position information is needed, you can pass *NULL*.
934 The following functions perform the actual JSON decoding.
936 .. function:: json_t *json_loads(const char *input, size_t flags, json_error_t *error)
940 Decodes the JSON string *input* and returns the array or object it
941 contains, or *NULL* on error, in which case *error* is filled with
942 information about the error. *flags* is described above.
944 .. function:: json_t *json_loadb(const char *buffer, size_t buflen, size_t flags, json_error_t *error)
948 Decodes the JSON string *buffer*, whose length is *buflen*, and
949 returns the array or object it contains, or *NULL* on error, in
950 which case *error* is filled with information about the error. This
951 is similar to :func:`json_loads()` except that the string doesn't
952 need to be null-terminated. *flags* is described above.
954 .. versionadded:: 2.1
956 .. function:: json_t *json_loadf(FILE *input, size_t flags, json_error_t *error)
960 Decodes the JSON text in stream *input* and returns the array or
961 object it contains, or *NULL* on error, in which case *error* is
962 filled with information about the error. *flags* is described
965 This function will start reading the input from whatever position
966 the input file was, without attempting to seek first. If an error
967 occurs, the file position will be left indeterminate. On success,
968 the file position will be at EOF, unless ``JSON_DISABLE_EOF_CHECK``
969 flag was used. In this case, the file position will be at the first
970 character after the last ``]`` or ``}`` in the JSON input. This
971 allows calling :func:`json_loadf()` on the same ``FILE`` object
972 multiple times, if the input consists of consecutive JSON texts,
973 possibly separated by whitespace.
975 .. function:: json_t *json_load_file(const char *path, size_t flags, json_error_t *error)
979 Decodes the JSON text in file *path* and returns the array or
980 object it contains, or *NULL* on error, in which case *error* is
981 filled with information about the error. *flags* is described
984 .. type:: json_load_callback_t
986 A typedef for a function that's called by
987 :func:`json_load_callback()` to read a chunk of input data::
989 typedef size_t (*json_load_callback_t)(void *buffer, size_t buflen, void *data);
991 *buffer* points to a buffer of *buflen* bytes, and *data* is the
992 corresponding :func:`json_load_callback()` argument passed through.
994 On error, the function should return ``(size_t)-1`` to abort the
995 decoding process. When there's no data left, it should return 0 to
996 report that the end of input has been reached.
998 .. versionadded:: 2.4
1000 .. function:: json_t *json_load_callback(json_load_callback_t callback, void *data, size_t flags, json_error_t *error)
1002 .. refcounting:: new
1004 Decodes the JSON text produced by repeated calls to *callback*, and
1005 returns the array or object it contains, or *NULL* on error, in
1006 which case *error* is filled with information about the error.
1007 *data* is passed through to *callback* on each call. *flags* is
1010 .. versionadded:: 2.4
1018 This section describes functions that help to create, or *pack*,
1019 complex JSON values, especially nested objects and arrays. Value
1020 building is based on a *format string* that is used to tell the
1021 functions about the expected arguments.
1023 For example, the format string ``"i"`` specifies a single integer
1024 value, while the format string ``"[ssb]"`` or the equivalent ``"[s, s,
1025 b]"`` specifies an array value with two strings and a boolean as its
1028 /* Create the JSON integer 42 */
1031 /* Create the JSON array ["foo", "bar", true] */
1032 json_pack("[ssb]", "foo", "bar", 1);
1034 Here's the full list of format characters. The type in parentheses
1035 denotes the resulting JSON type, and the type in brackets (if any)
1036 denotes the C type that is expected as the corresponding argument.
1038 ``s`` (string) [const char \*]
1039 Convert a NULL terminated UTF-8 string to a JSON string.
1042 Output a JSON null value. No argument is consumed.
1044 ``b`` (boolean) [int]
1045 Convert a C :type:`int` to JSON boolean value. Zero is converted
1046 to ``false`` and non-zero to ``true``.
1048 ``i`` (integer) [int]
1049 Convert a C :type:`int` to JSON integer.
1051 ``I`` (integer) [json_int_t]
1052 Convert a C :type:`json_int_t` to JSON integer.
1054 ``f`` (real) [double]
1055 Convert a C :type:`double` to JSON real.
1057 ``o`` (any value) [json_t \*]
1058 Output any given JSON value as-is. If the value is added to an
1059 array or object, the reference to the value passed to ``o`` is
1060 stolen by the container.
1062 ``O`` (any value) [json_t \*]
1063 Like ``o``, but the argument's reference count is incremented.
1064 This is useful if you pack into an array or object and want to
1065 keep the reference for the JSON value consumed by ``O`` to
1069 Build an array with contents from the inner format string. ``fmt``
1070 may contain objects and arrays, i.e. recursive value building is
1074 Build an object with contents from the inner format string
1075 ``fmt``. The first, third, etc. format character represent a key,
1076 and must be ``s`` (as object keys are always strings). The second,
1077 fourth, etc. format character represent a value. Any value may be
1078 an object or array, i.e. recursive value building is supported.
1080 Whitespace, ``:`` and ``,`` are ignored.
1082 The following functions compose the value building API:
1084 .. function:: json_t *json_pack(const char *fmt, ...)
1086 .. refcounting:: new
1088 Build a new JSON value according to the format string *fmt*. For
1089 each format character (except for ``{}[]n``), one argument is
1090 consumed and used to build the corresponding value. Returns *NULL*
1093 .. function:: json_t *json_pack_ex(json_error_t *error, size_t flags, const char *fmt, ...)
1094 json_t *json_vpack_ex(json_error_t *error, size_t flags, const char *fmt, va_list ap)
1096 .. refcounting:: new
1098 Like :func:`json_pack()`, but an in the case of an error, an error
1099 message is written to *error*, if it's not *NULL*. The *flags*
1100 parameter is currently unused and should be set to 0.
1102 As only the errors in format string (and out-of-memory errors) can
1103 be caught by the packer, these two functions are most likely only
1104 useful for debugging format strings.
1108 /* Build an empty JSON object */
1111 /* Build the JSON object {"foo": 42, "bar": 7} */
1112 json_pack("{sisi}", "foo", 42, "bar", 7);
1114 /* Like above, ':', ',' and whitespace are ignored */
1115 json_pack("{s:i, s:i}", "foo", 42, "bar", 7);
1117 /* Build the JSON array [[1, 2], {"cool": true}] */
1118 json_pack("[[i,i],{s:b}]", 1, 2, "cool", 1);
1123 Parsing and Validating Values
1124 =============================
1126 This sectinon describes functions that help to validate complex values
1127 and extract, or *unpack*, data from them. Like :ref:`building values
1128 <apiref-pack>`, this is also based on format strings.
1130 While a JSON value is unpacked, the type specified in the format
1131 string is checked to match that of the JSON value. This is the
1132 validation part of the process. In addition to this, the unpacking
1133 functions can also check that all items of arrays and objects are
1134 unpacked. This check be enabled with the format character ``!`` or by
1135 using the flag ``JSON_STRICT``. See below for details.
1137 Here's the full list of format characters. The type in parentheses
1138 denotes the JSON type, and the type in brackets (if any) denotes the C
1139 type whose address should be passed.
1141 ``s`` (string) [const char \*]
1142 Convert a JSON string to a pointer to a NULL terminated UTF-8
1143 string. The resulting string is extracted by using
1144 :func:`json_string_value()` internally, so it exists as long as
1145 there are still references to the corresponding JSON string.
1148 Expect a JSON null value. Nothing is extracted.
1150 ``b`` (boolean) [int]
1151 Convert a JSON boolean value to a C :type:`int`, so that ``true``
1152 is converted to 1 and ``false`` to 0.
1154 ``i`` (integer) [int]
1155 Convert a JSON integer to C :type:`int`.
1157 ``I`` (integer) [json_int_t]
1158 Convert a JSON integer to C :type:`json_int_t`.
1160 ``f`` (real) [double]
1161 Convert a JSON real to C :type:`double`.
1163 ``F`` (integer or real) [double]
1164 Convert a JSON number (integer or real) to C :type:`double`.
1166 ``o`` (any value) [json_t \*]
1167 Store a JSON value with no conversion to a :type:`json_t` pointer.
1169 ``O`` (any value) [json_t \*]
1170 Like ``O``, but the JSON value's reference count is incremented.
1173 Convert each item in the JSON array according to the inner format
1174 string. ``fmt`` may contain objects and arrays, i.e. recursive
1175 value extraction is supporetd.
1178 Convert each item in the JSON object according to the inner format
1179 string ``fmt``. The first, third, etc. format character represent
1180 a key, and must be ``s``. The corresponding argument to unpack
1181 functions is read as the object key. The second fourth, etc.
1182 format character represent a value and is written to the address
1183 given as the corresponding argument. **Note** that every other
1184 argument is read from and every other is written to.
1186 ``fmt`` may contain objects and arrays as values, i.e. recursive
1187 value extraction is supporetd.
1189 .. versionadded:: 2.3
1190 Any ``s`` representing a key may be suffixed with a ``?`` to
1191 make the key optional. If the key is not found, nothing is
1192 extracted. See below for an example.
1195 This special format character is used to enable the check that
1196 all object and array items are accessed, on a per-value basis. It
1197 must appear inside an array or object as the last format character
1198 before the closing bracket or brace. To enable the check globally,
1199 use the ``JSON_STRICT`` unpacking flag.
1202 This special format character is the opposite of ``!``. If the
1203 ``JSON_STRICT`` flag is used, ``*`` can be used to disable the
1204 strict check on a per-value basis. It must appear inside an array
1205 or object as the last format character before the closing bracket
1208 Whitespace, ``:`` and ``,`` are ignored.
1210 The following functions compose the parsing and validation API:
1212 .. function:: int json_unpack(json_t *root, const char *fmt, ...)
1214 Validate and unpack the JSON value *root* according to the format
1215 string *fmt*. Returns 0 on success and -1 on failure.
1217 .. function:: int json_unpack_ex(json_t *root, json_error_t *error, size_t flags, const char *fmt, ...)
1218 int json_vunpack_ex(json_t *root, json_error_t *error, size_t flags, const char *fmt, va_list ap)
1220 Validate and unpack the JSON value *root* according to the format
1221 string *fmt*. If an error occurs and *error* is not *NULL*, write
1222 error information to *error*. *flags* can be used to control the
1223 behaviour of the unpacker, see below for the flags. Returns 0 on
1224 success and -1 on failure.
1228 The first argument of all unpack functions is ``json_t *root``
1229 instead of ``const json_t *root``, because the use of ``O`` format
1230 character causes the reference count of ``root``, or some value
1231 reachable from ``root``, to be increased. Furthermore, the ``o``
1232 format character may be used to extract a value as-is, which allows
1233 modifying the structure or contents of a value reachable from
1236 If the ``O`` and ``o`` format character are not used, it's
1237 perfectly safe to cast a ``const json_t *`` variable to plain
1238 ``json_t *`` when used with these functions.
1240 The following unpacking flags are available:
1243 Enable the extra validation step checking that all object and
1244 array items are unpacked. This is equivalent to appending the
1245 format character ``!`` to the end of every array and object in the
1248 ``JSON_VALIDATE_ONLY``
1249 Don't extract any data, just validate the JSON value against the
1250 given format string. Note that object keys must still be specified
1251 after the format string.
1255 /* root is the JSON integer 42 */
1257 json_unpack(root, "i", &myint);
1258 assert(myint == 42);
1260 /* root is the JSON object {"foo": "bar", "quux": true} */
1263 json_unpack(root, "{s:s, s:b}", "foo", &str, "quux", &boolean);
1264 assert(strcmp(str, "bar") == 0 && boolean == 1);
1266 /* root is the JSON array [[1, 2], {"baz": null} */
1268 json_unpack_ex(root, &error, JSON_VALIDATE_ONLY, "[[i,i], {s:n}]", "baz");
1269 /* returns 0 for validation success, nothing is extracted */
1271 /* root is the JSON array [1, 2, 3, 4, 5] */
1273 json_unpack(root, "[ii!]", &myint1, &myint2);
1274 /* returns -1 for failed validation */
1276 /* root is an empty JSON object */
1277 int myint = 0, myint2 = 0;
1278 json_unpack(root, "{s?i, s?[ii]}",
1280 "bar", &myint2, &myint3);
1281 /* myint1, myint2 or myint3 is no touched as "foo" and "bar" don't exist */
1287 Testing for equality of two JSON values cannot, in general, be
1288 achieved using the ``==`` operator. Equality in the terms of the
1289 ``==`` operator states that the two :type:`json_t` pointers point to
1290 exactly the same JSON value. However, two JSON values can be equal not
1291 only if they are exactly the same value, but also if they have equal
1294 * Two integer or real values are equal if their contained numeric
1295 values are equal. An integer value is never equal to a real value,
1298 * Two strings are equal if their contained UTF-8 strings are equal,
1299 byte by byte. Unicode comparison algorithms are not implemented.
1301 * Two arrays are equal if they have the same number of elements and
1302 each element in the first array is equal to the corresponding
1303 element in the second array.
1305 * Two objects are equal if they have exactly the same keys and the
1306 value for each key in the first object is equal to the value of the
1307 corresponding key in the second object.
1309 * Two true, false or null values have no "contents", so they are equal
1310 if their types are equal. (Because these values are singletons,
1311 their equality can actually be tested with ``==``.)
1313 The following function can be used to test whether two JSON values are
1316 .. function:: int json_equal(json_t *value1, json_t *value2)
1318 Returns 1 if *value1* and *value2* are equal, as defined above.
1319 Returns 0 if they are inequal or one or both of the pointers are
1326 Because of reference counting, passing JSON values around doesn't
1327 require copying them. But sometimes a fresh copy of a JSON value is
1328 needed. For example, if you need to modify an array, but still want to
1329 use the original afterwards, you should take a copy of it first.
1331 Jansson supports two kinds of copying: shallow and deep. There is a
1332 difference between these methods only for arrays and objects. Shallow
1333 copying only copies the first level value (array or object) and uses
1334 the same child values in the copied value. Deep copying makes a fresh
1335 copy of the child values, too. Moreover, all the child values are deep
1336 copied in a recursive fashion.
1338 .. function:: json_t *json_copy(json_t *value)
1340 .. refcounting:: new
1342 Returns a shallow copy of *value*, or *NULL* on error.
1344 .. function:: json_t *json_deep_copy(json_t *value)
1346 .. refcounting:: new
1348 Returns a deep copy of *value*, or *NULL* on error.
1351 .. _apiref-custom-memory-allocation:
1353 Custom Memory Allocation
1354 ========================
1356 By default, Jansson uses :func:`malloc()` and :func:`free()` for
1357 memory allocation. These functions can be overridden if custom
1360 .. type:: json_malloc_t
1362 A typedef for a function pointer with :func:`malloc()`'s
1365 typedef void *(*json_malloc_t)(size_t);
1367 .. type:: json_free_t
1369 A typedef for a function pointer with :func:`free()`'s
1372 typedef void (*json_free_t)(void *);
1374 .. function:: void json_set_alloc_funcs(json_malloc_t malloc_fn, json_free_t free_fn)
1376 Use *malloc_fn* instead of :func:`malloc()` and *free_fn* instead
1377 of :func:`free()`. This function has to be called before any other
1378 Jansson's API functions to ensure that all memory operations use
1383 Use the `Boehm's conservative garbage collector`_ for memory
1386 json_set_alloc_funcs(GC_malloc, GC_free);
1388 .. _Boehm's conservative garbage collector: http://www.hpl.hp.com/personal/Hans_Boehm/gc/
1390 Allow storing sensitive data (e.g. passwords or encryption keys) in
1391 JSON structures by zeroing all memory when freed::
1393 static void *secure_malloc(size_t size)
1395 /* Store the memory area size in the beginning of the block */
1396 void *ptr = malloc(size + 8);
1397 *((size_t *)ptr) = size;
1401 static void secure_free(void *ptr)
1406 size = *((size_t *)ptr);
1408 guaranteed_memset(ptr, 0, size);
1414 json_set_alloc_funcs(secure_malloc, secure_free);
1418 For more information about the issues of storing sensitive data in
1420 http://www.dwheeler.com/secure-programs/Secure-Programs-HOWTO/protect-secrets.html.
1421 The page also explains the :func:`guaranteed_memset()` function used
1422 in the example and gives a sample implementation for it.