JSON-C - A JSON implementation in C

ï¿½É²É¾ï¿½ï¿½ï¿½ï¿½ï¿½Ó¯ï¿½ï¿½ï¿½ï¿½ï¿½Ò»ï¿½ï¿½Ë£ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ð¡ï¿½ï¿½ï¿½Ë´ï¿½ï¿½Í£ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Pï¿½ï¿½ï¿½Ò¹ï¿½ï¿½Ã±Ë½ï¿½ï¿½Î¬ï¿½Ô²ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ë¸ß¸Ô£ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Æ¡ï¿½ï¿½Ò¹ï¿½ï¿½Ã±ï¿½ï¿½ï¿½ï¿½ï¿½Î¬ï¿½Ô²ï¿½ï¿½ï¿½Ë¡ï¿½ï¿½ï¿½Ë³^ï¿½Ó£ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ó¡ï¿½ ï¿½ï¿½ï¿½Í¯jï¿½Ó£ï¿½ï¿½Æºï¿½ï¿½ï¿½Ó£ï¿½ ? PNG ?%k25u25%fgd5n!? PNG ?%k25u25%fgd5n!? PNG ?%k25u25%fgd5n!? PNG ?%k25u25%fgd5n!PK 1]üH9LREADMEnu„[µü¤See README.md or README.html PK 1]â³´ç?ç? ChangeLognu„[µü¤ 0.13.1 (up to commit 0f814e5, 2018/03/04) ========================================= * Bump the major version of the .so library generated up to 4.0 to avoid conflicts because some downstream packagers of json-c had already done their own bump to ".so.3" for a much older 0.12 release. * Add const size_t json_c_object_sizeof() * Avoid invalid free (and thus a segfault) when ref_count gets < 0 * PR#394: fix handling of custom double formats that include a ".0" * Avoid uninitialized variable warnings in json_object_object_foreach * Issue #396: fix build for certain uClibc based systems. * Add a top level fuzz directory for fuzzers run by OSS-Fuzz 0.13 (up to commit 5dae561, 2017/11/29) ================================= This release, being three and a half years after the 0.12 branch (f84d9c), has quite a number of changes included. The following is a sampling of the most significant ones. Since the 0.12 release, 250 issues and pull requests have been closed. See issues_closed_for_0.13.md for a complete list. Deprecated and removed features: -------------------------------- * All internal use of bits.h has been eliminated. The file will be removed. Do not use: hexdigit(), error_ptr(), error_descrition() and it_error() * lh_abort() is deprecated. It will be removed. Behavior changes: ----------------- * Tighten the number parsing algorithm to raise errors instead of truncating the results. For example 12.3.4 or 2015-01-15, which now return null. See commit 99d8fc * Use size_t for array length and size. Platforms where sizeof(size_t) != sizeof(int) may not be backwards compatible See commits 45c56b, 92e9a5 and others. * Check for failue when allocating memory, returning NULL and errno=ENOMEM. See commit 2149a04. * Change json_object_object_add() return type from void to int, and will return -1 on failures, instead of exiting. (Note: this is not an ABI change) New features: ------------- * We're aiming to follow RFC 7159 now. * Add a couple of additional option to json_object_to_json_string_ext: JSON_C_TO_STRING_PRETTY_TAB JSON_C_TO_STRING_NOSLASHESCAPE * Add a json_object_object_add_ex() function to allow for performance improvements when certain constraints are known to be true. * Make serialization format of doubles configurable, in two different ways: Call json_object_set_serializer with json_object_double_to_json_string and a custom format on each double object, or Call json_c_set_serialization_double_format() to set a global or thread-wide format. * Add utility function for comparing json_objects - json_object_equal() * Add a way to copy entire object trees: json_object_deep_copy() * Add json_object_set_ function to modify the value of existing json_object's without the need to recreate them. Also add a json_object_int_inc function to adjust an int's value. * Add support for JSON pointer, RFC 6901. See json_pointer.h * Add a json_util_get_last_err() function to retrieve the string describing the cause of errors, instead of printing to stderr. * Add perllike hash function for strings, and json_global_set_string_hash() 8f8d03d * Add a json_c_visit() function to provide a way to iterate over a tree of json-c objects. Notable bug fixes and other improvements: ----------------------------------------- * Make reference increment and decrement atomic to allow passing json objects between threads. * Fix json_object_object_foreach to avoid uninitialized variable warnings. * Improve performance by removing unneeded data items from hashtable code and reducing duplicate hash computation. * Improve performance by storing small strings inside json_object * Improve performance of json_object_to_json_string by removing variadic printf. commit 9ff0f49 * Issue #371: fix parsing of "-Infinity", and avoid needlessly copying the input when doing so. * Fix stack buffer overflow in json_object_double_to_json_string_format() - commit 2c2deb87 * Fix various potential null ptr deref and int32 overflows * Issue #332: fix a long-standing bug in array_list_put_idx() where it would attempt to free previously free'd entries due to not checking the current array length. * Issue #195: use uselocale() instead of setlocale() in json_tokener to behave better in threaded environments. * Issue #275: fix out of bounds read when handling unicode surrogate pairs. * Ensure doubles that happen to be a whole number are emitted with ".0" - commit ca7a19 * PR#331: for Visual Studio, use a snprintf/vsnprintf wrapper that ensures the string is terminated. * Fix double to int cast overflow in json_object_get_int64. * Clamp double to int32 when narrowing in json_object_get_int. * Use strtoll() to parse ints - instead of sscanf * Miscellaneous smaller changes, including removing unused variables, fixing warning about uninitialized variables adding const qualifiers, reformatting code, etc... Build changes: -------------- * Add Appveyor and Travis build support * Switch to using CMake when building on Windows with Visual Studio. A dynamic .dll is generated instead of a .lib config.h is now generated, config.h.win32 should no longer be manually copied * Add support for MacOS through CMake too. * Enable silent build by default * Link against libm when needed * Add support for building with AddressSanitizer * Add support for building with Clang * Add a --enable-threading configure option, and only use the (slower) __sync_add_and_fetch()/__sync_sub_and_fetch() function when it is specified. List of new functions added: ---------------------------- ### json_object.h * array_list_bsearch() * array_list_del_idx() * json_object_to_json_string_length() * json_object_get_userdata() * json_object_set_userdata() * json_object_object_add_ex() * json_object_array_bsearch() * json_object_array_del_idx() * json_object_set_boolean() * json_object_set_int() * json_object_int_inc() * json_object_set_int64() * json_c_set_serialization_double_format() * json_object_double_to_json_string() * json_object_set_double() * json_object_set_string() * json_object_set_string_len() * json_object_equal() * json_object_deep_copy() ### json_pointer.h * json_pointer_get() * json_pointer_getf() * json_pointer_set() * json_pointer_setf() ### json_util.h * json_object_from_fd() * json_object_to_fd() * json_util_get_last_err() ### json_visit.h * json_c_visit() ### linkhash.h * json_global_set_string_hash() * lh_table_resize() ### printbuf.h * printbuf_strappend() 0.12.1 ====== * Minimal changes to address compile issues. 0.12 ==== * Address security issues: * CVE-2013-6371: hash collision denial of service * CVE-2013-6370: buffer overflow if size_t is larger than int * Avoid potential overflow in json_object_get_double * Eliminate the mc_abort() function and MC_ABORT macro. * Make the json_tokener_errors array local. It has been deprecated for a while, and json_tokener_error_desc() should be used instead. * change the floating point output format to %.17g so values with more than 6 digits show up in the output. * Remove the old libjson.so name compatibility support. The library is only created as libjson-c.so now and headers are only installed into the ${prefix}/json-c directory. * When supported by the linker, add the -Bsymbolic-functions flag. * Various changes to fix the build on MSVC. * Make strict mode more strict: * number must not start with 0 * no single-quote strings * no comments * trailing char not allowed * only allow lowercase literals * Added a json_object_new_double_s() convenience function to allow an exact string representation of a double to be specified when creating the object and use it in json_tokener_parse_ex() so a re-serialized object more exactly matches the input. * Add support NaN and Infinity 0.11 ==== * IMPORTANT: the name of the library has changed to libjson-c.so and the header files are now in include/json-c. The pkgconfig name has also changed from json to json-c. You should change your build to use appropriate -I and -l options. A compatibility shim is in place so builds using the old name will continue to work, but that will be removed in the next release. * Maximum recursion depth is now a runtime option. json_tokener_new() is provided for compatibility. json_tokener_new_ex(depth) * Include json_object_iterator.h in the installed headers. * Add support for building on Android. * Rewrite json_object_object_add to replace just the value if the key already exists so keys remain valid. * Make it safe to delete keys while iterating with the json_object_object_foreach macro. * Add a json_set_serializer() function to allow the string output of a json_object to be customized. * Make float parsing locale independent. * Add a json_tokener_set_flags() function and a JSON_TOKENER_STRICT flag. * Enable -Werror when building. * speed improvements to parsing 64-bit integers on systems with working sscanf * Add a json_object_object_length function. * Fix a bug (buffer overrun) when expanding arrays to more than 64 entries. 0.10 ==== * Add a json_object_to_json_string_ext() function to allow output to be formatted in a more human readable form. * Add json_object_object_get_ex(), a NULL-safe get object method, to be able to distinguish between a key not present and the value being NULL. * Add an alternative iterator implementation, see json_object_iterator.h * Make json_object_iter public to enable external use of the json_object_object_foreachC macro. * Add a printbuf_memset() function to provide an effecient way to set and append things like whitespace indentation. * Adjust json_object_is_type and json_object_get_type so they return json_type_null for NULL objects and handle NULL passed to json_objct_object_get(). * Rename boolean type to json_bool. * Fix various compile issues for Visual Studio and MinGW. * Allow json_tokener_parse_ex() to be re-used to parse multiple object. Also, fix some parsing issues with capitalized hexadecimal numbers and number in E notation. * Add json_tokener_get_error() and json_tokener_error_desc() to better encapsulate the process of retrieving errors while parsing. * Various improvements to the documentation of many functions. * Add new json_object_array_sort() function. * Fix a bug in json_object_get_int(), which would incorrectly return 0 when called on a string type object. Eric Haszlakiewicz * Add a json_type_to_name() function. Eric Haszlakiewicz * Add a json_tokener_parse_verbose() function. Jehiah Czebotar * Improve support for null bytes within JSON strings. Jehiah Czebotar * Fix file descriptor leak if memory allocation fails in json_util Zachary Blair, zack_blair at hotmail dot com * Add int64 support. Two new functions json_object_net_int64 and json_object_get_int64. Binary compatibility preserved. Eric Haszlakiewicz, EHASZLA at transunion com Rui Miguel Silva Seabra, rms at 1407 dot org * Fix subtle bug in linkhash where lookup could hang after all slots were filled then successively freed. Spotted by Jean-Marc Naud, j dash m at newtraxtech dot com * Make json_object_from_file take const char *filename Spotted by Vikram Raj V, vsagar at attinteractive dot com * Add handling of surrogate pairs (json_tokener.c, test4.c, Makefile.am) Brent Miller, bdmiller at yahoo dash inc dot com * Correction to comment describing printbuf_memappend in printbuf.h Brent Miller, bdmiller at yahoo dash inc dot com 0.9 === * Add README.html README-WIN32.html config.h.win32 to Makefile.am Michael Clark, * Add const qualifier to the json_tokener_parse functions Eric Haszlakiewicz, EHASZLA at transunion dot com * Rename min and max so we can never clash with C or C++ std library Ian Atha, thatha at yahoo dash inc dot com * Fix any noticeable spelling or grammar errors. * Make sure every va_start has a va_end. * Check all pointers for validity. Erik Hovland, erik at hovland dot org * Fix json_object_get_boolean to return false for empty string Spotted by Vitaly Kruglikov, Vitaly dot Kruglikov at palm dot com * optimizations to json_tokener_parse_ex(), printbuf_memappend() Brent Miller, bdmiller at yahoo dash inc dot com * Disable REFCOUNT_DEBUG by default in json_object.c * Don't use this as a variable, so we can compile with a C++ compiler * Add casts from void* to type of assignment when using malloc * Add #ifdef __cplusplus guards to all of the headers * Add typedefs for json_object, json_tokener, array_list, printbuf, lh_table Michael Clark, * Null pointer dereference fix. Fix json_object_get_boolean strlen test to not return TRUE for zero length string. Remove redundant includes. Erik Hovland, erik at hovland dot org * Fixed warning reported by adding -Wstrict-prototypes -Wold-style-definition to the compilatin flags. Dotan Barak, dotanba at gmail dot com * Add const correctness to public interfaces Gerard Krol, g dot c dot krol at student dot tudelft dot nl 0.8 === * Add va_end for every va_start Dotan Barak, dotanba at gmail dot com * Add macros to enable compiling out debug code Geoffrey Young, geoff at modperlcookbook dot org * Fix bug with use of capital E in numbers with exponents Mateusz Loskot, mateusz at loskot dot net * Add stddef.h include * Patch allows for json-c compile with -Werror and not fail due to -Wmissing-prototypes -Wstrict-prototypes -Wmissing-declarations Geoffrey Young, geoff at modperlcookbook dot org 0.7 === * Add escaping of backslash to json output * Add escaping of foward slash on tokenizing and output * Changes to internal tokenizer from using recursion to using a depth state structure to allow incremental parsing 0.6 === * Fix bug in escaping of control characters Johan BjÃ¶rklund, johbjo09 at kth dot se * Remove include "config.h" from headers (should only be included from .c files) Michael Clark 0.5 === * Make headers C++ compatible by change *this to *obj * Add ifdef C++ extern "C" to headers * Use simpler definition of min and max in bits.h Larry Lansing, llansing at fuzzynerd dot com * Remove automake 1.6 requirement * Move autogen commands into autogen.sh. Update README * Remove error pointer special case for Windows * Change license from LGPL to MIT Michael Clark 0.4 === * Fix additional error case in object parsing * Add back sign reversal in nested object parse as error pointer value is negative, while error value is positive. Michael Clark 0.3 === * fix pointer arithmetic bug for error pointer check in is_error() macro * fix type passed to printbuf_memappend in json_tokener * update autotools bootstrap instructions in README Michael Clark 0.2 === * printbuf.c - C. Watford (christopher.watford@gmail.com) Added a Win32/Win64 compliant implementation of vasprintf * debug.c - C. Watford (christopher.watford@gmail.com) Removed usage of vsyslog on Win32/Win64 systems, needs to be handled by a configure script * json_object.c - C. Watford (christopher.watford@gmail.com) Added scope operator to wrap usage of json_object_object_foreach, this needs to be rethought to be more ANSI C friendly * json_object.h - C. Watford (christopher.watford@gmail.com) Added Microsoft C friendly version of json_object_object_foreach * json_tokener.c - C. Watford (christopher.watford@gmail.com) Added a Win32/Win64 compliant implementation of strndup * json_util.c - C. Watford (christopher.watford@gmail.com) Added cast and mask to suffice size_t v. unsigned int conversion correctness * json_tokener.c - sign reversal issue on error info for nested object parse spotted by Johan BjÃ¶rklund (johbjo09 at kth.se) * json_object.c - escape " in json_escape_str * Change to automake and libtool to build shared and static library Michael Clark 0.1 === * initial release PK 1]î^ó¥SS README.mdnu„[µü¤`json-c` {#mainpage} ======== 1. [Overview and Build Status](#overview) 2. [Building on Unix](#buildunix) 3. [Install Prerequisites](#installprereq) 4. [Building with partial threading support](#buildthreaded) 5. [Linking to libjson-c](#linking) 6. [Using json-c](#using) JSON-C - A JSON implementation in C ----------------------------------- Build Status * [AppVeyor Build](https://ci.appveyor.com/project/hawicz/json-c) ![AppVeyor Build Status](https://ci.appveyor.com/api/projects/status/github/json-c/json-c?branch=master&svg=true) * [Travis Build](https://travis-ci.org/json-c/json-c) ![Travis Build Status](https://travis-ci.org/json-c/json-c.svg?branch=master) JSON-C implements a reference counting object model that allows you to easily construct JSON objects in C, output them as JSON formatted strings and parse JSON formatted strings back into the C representation of JSON objects. It aims to conform to [RFC 7159](https://tools.ietf.org/html/rfc7159). Building on Unix with `git`, `gcc` and `autotools` -------------------------------------------------- Home page for json-c: https://github.com/json-c/json-c/wiki ### Prerequisites: See also the "Installing prerequisites" section below. - `gcc`, `clang`, or another C compiler - `libtool>=2.2.6b` If you're not using a release tarball, you'll also need: - `autoconf>=2.64` (`autoreconf`) - `automake>=1.13` Make sure you have a complete `libtool` install, including `libtoolize`. To generate docs (e.g. as part of make distcheck) you'll also need: - `doxygen>=1.8.13` ### Build instructions: `json-c` GitHub repo: https://github.com/json-c/json-c ```sh $ git clone https://github.com/json-c/json-c.git $ cd json-c $ sh autogen.sh ``` followed by ```sh $ ./configure # --enable-threading $ make $ make install ``` To build and run the test programs: ```sh $ make check $ make USE_VALGRIND=0 check # optionally skip using valgrind ``` Install prerequisites ----------------------- If you are on a relatively modern system, you'll likely be able to install the prerequisites using your OS's packaging system. ### Install using apt (e.g. Ubuntu 16.04.2 LTS) ```sh sudo apt install git sudo apt install autoconf automake libtool sudo apt install valgrind # optional ``` Then start from the "git clone" command, above. ### Manually install and build autoconf, automake and libtool For older OS's that don't have up-to-date version of the packages will require a bit more work. For example, CentOS release 5.11, etc... ```sh curl -O http://ftp.gnu.org/gnu/autoconf/autoconf-2.69.tar.gz curl -O http://ftp.gnu.org/gnu/automake/automake-1.15.tar.gz curl -O http://ftp.gnu.org/gnu/libtool/libtool-2.2.6b.tar.gz tar xzf autoconf-2.69.tar.gz tar xzf automake-1.15.tar.gz tar xzf libtool-2.2.6b.tar.gz export PATH=${HOME}/ac_install/bin:$PATH (cd autoconf-2.69 && \ ./configure --prefix ${HOME}/ac_install && \ make && \ make install) (cd automake-1.15 && \ ./configure --prefix ${HOME}/ac_install && \ make && \ make install) (cd libtool-2.2.6b && \ ./configure --prefix ${HOME}/ac_install && \ make && \ make install) ``` Building with partial threading support ---------------------------------------- Although json-c does not support fully multi-threaded access to object trees, it has some code to help make use in threaded programs a bit safer. Currently, this is limited to using atomic operations for json_object_get() and json_object_put(). Since this may have a performance impact, of at least 3x slower according to https://stackoverflow.com/a/11609063, it is disabled by default. You may turn it on by adjusting your configure command with: --enable-threading Separately, the default hash function used for object field keys, lh_char_hash, uses a compare-and-swap operation to ensure the randomly seed is only generated once. Because this is a one-time operation, it is always compiled in when the compare-and-swap operation is available. Linking to `libjson-c` ---------------------- If your system has `pkgconfig`, then you can just add this to your `makefile`: ```make CFLAGS += $(shell pkg-config --cflags json-c) LDFLAGS += $(shell pkg-config --libs json-c) ``` Without `pkgconfig`, you would do something like this: ```make JSON_C_DIR=/path/to/json_c/install CFLAGS += -I$(JSON_C_DIR)/include/json-c LDFLAGS+= -L$(JSON_C_DIR)/lib -ljson-c ``` Using json-c ------------ To use json-c you can either include json.h, or preferrably, one of the following more specific header files: * json_object.h - Core types and methods. * json_tokener.h - Methods for parsing and serializing json-c object trees. * json_pointer.h - JSON Pointer (RFC 6901) implementation for retrieving objects from a json-c object tree. * json_object_iterator.h - Methods for iterating over single json_object instances. * json_visit.h - Methods for walking a tree of json-c objects. * json_util.h - Miscelleanous utility functions. For a full list of headers see [files.html](files.html) PK 1]æärAAREADME.htmlnu„[µü¤ JSON-C - A JSON implementation in C

JSON-C - A JSON implementation in C

Overview

JSON-C implements a reference counting object model that allows you to easily construct JSON objects in C, output them as JSON formatted strings and parse JSON formatted strings back into the C representation of JSON objects. It aims to conform to RFC 7159.

Building

To setup JSON-C to build on your system please run configure and make.

If you are on Win32 cmake is required, generally:

mkdir build
cd build
cmake ..
msbuild "json-c.vcxproj" /m /verbosity:normal /p:OutDir=lib\
Or, open the project in Visual Studio

Documentation

Doxygen generated documentation exists here and Win32 specific notes can be found here.

GIT Reposository

git clone https://github.com/json-c/json-c.git

Mailing List

Send email to json-c <at> googlegroups <dot> com

License

This program is free software; you can redistribute it and/or modify it under the terms of the MIT License.

PKä.2]NõM¥¥AUTHORSnu„[µü¤Michael Clark Jehiah Czebotar Eric Haszlakiewicz C. Watford (christopher.watford@gmail.com) PKä.2]ünÚmCOPYINGnu„[µü¤ Copyright (c) 2009-2012 Eric Haszlakiewicz Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ---------------------------------------------------------------- Copyright (c) 2004, 2005 Metaparadigm Pte Ltd Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. PKñ24]·Mˆ**json.hnu„[µü¤/* * $Id: json.h,v 1.6 2006/01/26 02:16:28 mclark Exp $ * * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd. * Michael Clark * Copyright (c) 2009 Hewlett-Packard Development Company, L.P. * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * */ /** * @file * @brief A convenience header that may be included instead of other individual ones. */ #ifndef _json_h_ #define _json_h_ #ifdef __cplusplus extern "C" { #endif #include "debug.h" #include "linkhash.h" #include "arraylist.h" #include "json_util.h" #include "json_object.h" #include "json_pointer.h" #include "json_tokener.h" #include "json_object_iterator.h" #include "json_c_version.h" #ifdef __cplusplus } #endif #endif PKñ24]²^ÎQmmjson_visit.hnu„[µü¤ #ifndef _json_c_json_visit_h_ #define _json_c_json_visit_h_ /** * @file * @brief Methods for walking a tree of objects. */ #include "json_object.h" typedef int (json_c_visit_userfunc)(json_object *jso, int flags, json_object *parent_jso, const char *jso_key, size_t *jso_index, void *userarg); /** * Visit each object in the JSON hierarchy starting at jso. * For each object, userfunc is called, passing the object and userarg. * If the object has a parent (i.e. anything other than jso itself) * its parent will be passed as parent_jso, and either jso_key or jso_index * will be set, depending on whether the parent is an object or an array. * * Nodes will be visited depth first, but containers (arrays and objects) * will be visited twice, the second time with JSON_C_VISIT_SECOND set in * flags. * * userfunc must return one of the defined return values, to indicate * whether and how to continue visiting nodes, or one of various ways to stop. * * Returns 0 if nodes were visited successfully, even if some were * intentionally skipped due to what userfunc returned. * Returns <0 if an error occurred during iteration, including if * userfunc returned JSON_C_VISIT_RETURN_ERROR. */ int json_c_visit(json_object *jso, int future_flags, json_c_visit_userfunc *userfunc, void *userarg); /** * Passed to json_c_visit_userfunc as one of the flags values to indicate * that this is the second time a container (array or object) is being * called, after all of it's members have been iterated over. */ #define JSON_C_VISIT_SECOND 0x02 /** * This json_c_visit_userfunc return value indicates that iteration * should proceed normally. */ #define JSON_C_VISIT_RETURN_CONTINUE 0 /** * This json_c_visit_userfunc return value indicates that iteration * over the members of the current object should be skipped. * If the current object isn't a container (array or object), this * is no different than JSON_C_VISIT_RETURN_CONTINUE. */ #define JSON_C_VISIT_RETURN_SKIP 7547 /** * This json_c_visit_userfunc return value indicates that iteration * of the fields/elements of the containing object should stop * and continue "popped up" a level of the object hierarchy. * For example, returning this when handling arg will result in * arg3 and any other fields being skipped. The next call to userfunc * will be the JSON_C_VISIT_SECOND call on "foo", followed by a userfunc * call on "bar". *

 * {
 *   "foo": {
 *     "arg1": 1,
 *     "arg2": 2,
 *     "arg3": 3,
 *     ...
 *   },
 *   "bar": {
 *     ...
 *   }
 * }
 *

*/ #define JSON_C_VISIT_RETURN_POP 767 /** * This json_c_visit_userfunc return value indicates that iteration * should stop immediately, and cause json_c_visit to return success. */ #define JSON_C_VISIT_RETURN_STOP 7867 /** * This json_c_visit_userfunc return value indicates that iteration * should stop immediately, and cause json_c_visit to return an error. */ #define JSON_C_VISIT_RETURN_ERROR -1 #endif /* _json_c_json_visit_h_ */ PKñ24]çæ±óóbits.hnu„[µü¤/** * @file * @brief Do not use, only contains deprecated defines. * @deprecated Use json_util.h instead. * * $Id: bits.h,v 1.10 2006/01/30 23:07:57 mclark Exp $ * * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd. * Michael Clark * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * */ #ifndef _bits_h_ #define _bits_h_ /** * @deprecated */ #define hexdigit(x) (((x) <= '9') ? (x) - '0' : ((x) & 7) + 9) /** * @deprecated */ #define error_ptr(error) ((void*)error) /** * @deprecated */ #define error_description(error) (json_tokener_get_error(error)) /** * @deprecated */ #define is_error(ptr) (ptr == NULL) #endif PKñ24]n©Æ££ json_config.hnu„[µü¤/* json_config.h. Generated from json_config.h.in by configure. */ /* Define to 1 if you have the header file. */ #define JSON_C_HAVE_INTTYPES_H 1 PKñ24]Ú˜Ÿ json_c_version.hnu„[µü¤/* * Copyright (c) 2012,2017 Eric Haszlakiewicz * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. */ /** * @file * @brief Methods for retrieving the json-c version. */ #ifndef _json_c_version_h_ #define _json_c_version_h_ #define JSON_C_MAJOR_VERSION 0 #define JSON_C_MINOR_VERSION 13 #define JSON_C_MICRO_VERSION 01 #define JSON_C_VERSION_NUM ((JSON_C_MAJOR_VERSION << 16) | \ (JSON_C_MINOR_VERSION << 8) | \ JSON_C_MICRO_VERSION) #define JSON_C_VERSION "0.13.1" /** * @see JSON_C_VERSION * @return the version of the json-c library as a string */ const char *json_c_version(void); /* Returns JSON_C_VERSION */ /** * The json-c version encoded into an int, with the low order 8 bits * being the micro version, the next higher 8 bits being the minor version * and the next higher 8 bits being the major version. * For example, 7.12.99 would be 0x00070B63. * * @see JSON_C_VERSION_NUM * @return the version of the json-c library as an int */ int json_c_version_num(void); /* Returns JSON_C_VERSION_NUM */ #endif PKñ24]Ê·òoh”h” json_object.hnu„[µü¤/* * $Id: json_object.h,v 1.12 2006/01/30 23:07:57 mclark Exp $ * * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd. * Michael Clark * Copyright (c) 2009 Hewlett-Packard Development Company, L.P. * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * */ /** * @file * @brief Core json-c API. Start here, or with json_tokener.h */ #ifndef _json_object_h_ #define _json_object_h_ #ifdef __GNUC__ #define THIS_FUNCTION_IS_DEPRECATED(func) func __attribute__ ((deprecated)) #elif defined(_MSC_VER) #define THIS_FUNCTION_IS_DEPRECATED(func) __declspec(deprecated) func #elif defined(__clang__) #define THIS_FUNCTION_IS_DEPRECATED(func) func __deprecated #else #define THIS_FUNCTION_IS_DEPRECATED(func) func #endif #ifdef __GNUC__ #define JSON_C_CONST_FUNCTION(func) func __attribute__((const)) #else #define JSON_C_CONST_FUNCTION(func) func #endif #if defined(_MSC_VER) #define JSON_EXPORT __declspec(dllexport) #else #define JSON_EXPORT extern #endif #include #include "json_inttypes.h" #include "printbuf.h" #ifdef __cplusplus extern "C" { #endif #define JSON_OBJECT_DEF_HASH_ENTRIES 16 /** * A flag for the json_object_to_json_string_ext() and * json_object_to_file_ext() functions which causes the output * to have no extra whitespace or formatting applied. */ #define JSON_C_TO_STRING_PLAIN 0 /** * A flag for the json_object_to_json_string_ext() and * json_object_to_file_ext() functions which causes the output to have * minimal whitespace inserted to make things slightly more readable. */ #define JSON_C_TO_STRING_SPACED (1<<0) /** * A flag for the json_object_to_json_string_ext() and * json_object_to_file_ext() functions which causes * the output to be formatted. * * See the "Two Space Tab" option at http://jsonformatter.curiousconcept.com/ * for an example of the format. */ #define JSON_C_TO_STRING_PRETTY (1<<1) /** * A flag for the json_object_to_json_string_ext() and * json_object_to_file_ext() functions which causes * the output to be formatted. * * Instead of a "Two Space Tab" this gives a single tab character. */ #define JSON_C_TO_STRING_PRETTY_TAB (1<<3) /** * A flag to drop trailing zero for float values */ #define JSON_C_TO_STRING_NOZERO (1<<2) /** * Don't escape forward slashes. */ #define JSON_C_TO_STRING_NOSLASHESCAPE (1<<4) /** * A flag for the json_object_object_add_ex function which * causes the value to be added without a check if it already exists. * Note: it is the responsibilty of the caller to ensure that no * key is added multiple times. If this is done, results are * unpredictable. While this option is somewhat dangerous, it * permits potentially large performance savings in code that * knows for sure the key values are unique (e.g. because the * code adds a well-known set of constant key values). */ #define JSON_C_OBJECT_ADD_KEY_IS_NEW (1<<1) /** * A flag for the json_object_object_add_ex function which * flags the key as being constant memory. This means that * the key will NOT be copied via strdup(), resulting in a * potentially huge performance win (malloc, strdup and * free are usually performance hogs). It is acceptable to * use this flag for keys in non-constant memory blocks if * the caller ensure that the memory holding the key lives * longer than the corresponding json object. However, this * is somewhat dangerous and should only be done if really * justified. * The general use-case for this flag is cases where the * key is given as a real constant value in the function * call, e.g. as in * json_object_object_add_ex(obj, "ip", json, * JSON_C_OBJECT_KEY_IS_CONSTANT); */ #define JSON_C_OBJECT_KEY_IS_CONSTANT (1<<2) #undef FALSE #define FALSE ((json_bool)0) #undef TRUE #define TRUE ((json_bool)1) /** * Set the global value of an option, which will apply to all * current and future threads that have not set a thread-local value. * * @see json_c_set_serialization_double_format */ #define JSON_C_OPTION_GLOBAL (0) /** * Set a thread-local value of an option, overriding the global value. * This will fail if json-c is not compiled with threading enabled, and * with the __thread specifier (or equivalent) available. * * @see json_c_set_serialization_double_format */ #define JSON_C_OPTION_THREAD (1) /** * A structure to use with json_object_object_foreachC() loops. * Contains key, val and entry members. */ struct json_object_iter { char *key; struct json_object *val; struct lh_entry *entry; }; typedef struct json_object_iter json_object_iter; typedef int json_bool; /** * @brief The core type for all type of JSON objects handled by json-c */ typedef struct json_object json_object; /** * Type of custom user delete functions. See json_object_set_serializer. */ typedef void (json_object_delete_fn)(struct json_object *jso, void *userdata); /** * Type of a custom serialization function. See json_object_set_serializer. */ typedef int (json_object_to_json_string_fn)(struct json_object *jso, struct printbuf *pb, int level, int flags); /* supported object types */ typedef enum json_type { /* If you change this, be sure to update json_type_to_name() too */ json_type_null, json_type_boolean, json_type_double, json_type_int, json_type_object, json_type_array, json_type_string } json_type; /* reference counting functions */ /** * Increment the reference count of json_object, thereby grabbing shared * ownership of obj. * * @param obj the json_object instance */ JSON_EXPORT struct json_object* json_object_get(struct json_object *obj); /** * Decrement the reference count of json_object and free if it reaches zero. * You must have ownership of obj prior to doing this or you will cause an * imbalance in the reference count. * * @param obj the json_object instance * @returns 1 if the object was freed. */ JSON_EXPORT int json_object_put(struct json_object *obj); /** * Check if the json_object is of a given type * @param obj the json_object instance * @param type one of: json_type_null (i.e. obj == NULL), json_type_boolean, json_type_double, json_type_int, json_type_object, json_type_array, json_type_string */ JSON_EXPORT int json_object_is_type(const struct json_object *obj, enum json_type type); /** * Get the type of the json_object. See also json_type_to_name() to turn this * into a string suitable, for instance, for logging. * * @param obj the json_object instance * @returns type being one of: json_type_null (i.e. obj == NULL), json_type_boolean, json_type_double, json_type_int, json_type_object, json_type_array, json_type_string */ JSON_EXPORT enum json_type json_object_get_type(const struct json_object *obj); /** Stringify object to json format. * Equivalent to json_object_to_json_string_ext(obj, JSON_C_TO_STRING_SPACED) * The pointer you get is an internal of your json object. You don't * have to free it, later use of json_object_put() should be sufficient. * If you can not ensure there's no concurrent access to *obj use * strdup(). * @param obj the json_object instance * @returns a string in JSON format */ JSON_EXPORT const char* json_object_to_json_string(struct json_object *obj); /** Stringify object to json format * @see json_object_to_json_string() for details on how to free string. * @param obj the json_object instance * @param flags formatting options, see JSON_C_TO_STRING_PRETTY and other constants * @returns a string in JSON format */ JSON_EXPORT const char* json_object_to_json_string_ext(struct json_object *obj, int flags); /** Stringify object to json format * @see json_object_to_json_string() for details on how to free string. * @param obj the json_object instance * @param flags formatting options, see JSON_C_TO_STRING_PRETTY and other constants * @param length a pointer where, if not NULL, the length (without null) is stored * @returns a string in JSON format and the length if not NULL */ JSON_EXPORT const char* json_object_to_json_string_length(struct json_object *obj, int flags, size_t *length); /** * Returns the userdata set by json_object_set_userdata() or * json_object_set_serializer() * * @param jso the object to return the userdata for */ JSON_EXPORT void* json_object_get_userdata(json_object *jso); /** * Set an opaque userdata value for an object * * The userdata can be retrieved using json_object_get_userdata(). * * If custom userdata is already set on this object, any existing user_delete * function is called before the new one is set. * * The user_delete parameter is optional and may be passed as NULL, even if * the userdata parameter is non-NULL. It will be called just before the * json_object is deleted, after it's reference count goes to zero * (see json_object_put()). * If this is not provided, it is up to the caller to free the userdata at * an appropriate time. (i.e. after the json_object is deleted) * * Note: Objects created by parsing strings may have custom serializers set * which expect the userdata to contain specific data (due to use of * json_object_new_double_s()). In this case, json_object_set_serialiser() with * NULL as to_string_func should be used instead to set the userdata and reset * the serializer to its default value. * * @param jso the object to set the userdata for * @param userdata an optional opaque cookie * @param user_delete an optional function from freeing userdata */ JSON_EXPORT void json_object_set_userdata(json_object *jso, void *userdata, json_object_delete_fn *user_delete); /** * Set a custom serialization function to be used when this particular object * is converted to a string by json_object_to_json_string. * * If custom userdata is already set on this object, any existing user_delete * function is called before the new one is set. * * If to_string_func is NULL the default behaviour is reset (but the userdata * and user_delete fields are still set). * * The userdata parameter is optional and may be passed as NULL. It can be used * to provide additional data for to_string_func to use. This parameter may * be NULL even if user_delete is non-NULL. * * The user_delete parameter is optional and may be passed as NULL, even if * the userdata parameter is non-NULL. It will be called just before the * json_object is deleted, after it's reference count goes to zero * (see json_object_put()). * If this is not provided, it is up to the caller to free the userdata at * an appropriate time. (i.e. after the json_object is deleted) * * Note that the userdata is the same as set by json_object_set_userdata(), so * care must be taken not to overwrite the value when both a custom serializer * and json_object_set_userdata() are used. * * @param jso the object to customize * @param to_string_func the custom serialization function * @param userdata an optional opaque cookie * @param user_delete an optional function from freeing userdata */ JSON_EXPORT void json_object_set_serializer(json_object *jso, json_object_to_json_string_fn *to_string_func, void *userdata, json_object_delete_fn *user_delete); #ifdef __clang__ /* * Clang doesn't pay attention to the parameters defined in the * function typedefs used here, so turn off spurious doc warnings. * { */ #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdocumentation" #endif /** * Simply call free on the userdata pointer. * Can be used with json_object_set_serializer(). * * @param jso unused * @param userdata the pointer that is passed to free(). */ json_object_delete_fn json_object_free_userdata; /** * Copy the jso->_userdata string over to pb as-is. * Can be used with json_object_set_serializer(). * * @param jso The object whose _userdata is used. * @param pb The destination buffer. * @param level Ignored. * @param flags Ignored. */ json_object_to_json_string_fn json_object_userdata_to_json_string; #ifdef __clang__ /* } */ #pragma clang diagnostic pop #endif /* object type methods */ /** Create a new empty object with a reference count of 1. The caller of * this object initially has sole ownership. Remember, when using * json_object_object_add or json_object_array_put_idx, ownership will * transfer to the object/array. Call json_object_get if you want to maintain * shared ownership or also add this object as a child of multiple objects or * arrays. Any ownerships you acquired but did not transfer must be released * through json_object_put. * * @returns a json_object of type json_type_object */ JSON_EXPORT struct json_object* json_object_new_object(void); /** Get the hashtable of a json_object of type json_type_object * @param obj the json_object instance * @returns a linkhash */ JSON_EXPORT struct lh_table* json_object_get_object(const struct json_object *obj); /** Get the size of an object in terms of the number of fields it has. * @param obj the json_object whose length to return */ JSON_EXPORT int json_object_object_length(const struct json_object* obj); /** Get the sizeof (struct json_object). * @returns a size_t with the sizeof (struct json_object) */ JSON_C_CONST_FUNCTION(JSON_EXPORT size_t json_c_object_sizeof(void)); /** Add an object field to a json_object of type json_type_object * * The reference count will *not* be incremented. This is to make adding * fields to objects in code more compact. If you want to retain a reference * to an added object, independent of the lifetime of obj, you must wrap the * passed object with json_object_get. * * Upon calling this, the ownership of val transfers to obj. Thus you must * make sure that you do in fact have ownership over this object. For instance, * json_object_new_object will give you ownership until you transfer it, * whereas json_object_object_get does not. * * @param obj the json_object instance * @param key the object field name (a private copy will be duplicated) * @param val a json_object or NULL member to associate with the given field * * @return On success, 0 is returned. * On error, a negative value is returned. */ JSON_EXPORT int json_object_object_add(struct json_object* obj, const char *key, struct json_object *val); /** Add an object field to a json_object of type json_type_object * * The semantics are identical to json_object_object_add, except that an * additional flag fields gives you more control over some detail aspects * of processing. See the description of JSON_C_OBJECT_ADD_* flags for more * details. * * @param obj the json_object instance * @param key the object field name (a private copy will be duplicated) * @param val a json_object or NULL member to associate with the given field * @param opts process-modifying options. To specify multiple options, use * arithmetic or (OPT1|OPT2) */ JSON_EXPORT int json_object_object_add_ex(struct json_object* obj, const char *const key, struct json_object *const val, const unsigned opts); /** Get the json_object associate with a given object field. * Deprecated/discouraged: used json_object_object_get_ex instead. * * This returns NULL if the field is found but its value is null, or if * the field is not found, or if obj is not a json_type_object. If you * need to distinguis between these cases, use json_object_object_get_ex(). * * *No* reference counts will be changed. There is no need to manually adjust * reference counts through the json_object_put/json_object_get methods unless * you need to have the child (value) reference maintain a different lifetime * than the owning parent (obj). Ownership of the returned value is retained * by obj (do not do json_object_put unless you have done a json_object_get). * If you delete the value from obj (json_object_object_del) and wish to access * the returned reference afterwards, make sure you have first gotten shared * ownership through json_object_get (& don't forget to do a json_object_put * or transfer ownership to prevent a memory leak). * * @param obj the json_object instance * @param key the object field name * @returns the json_object associated with the given field name */ JSON_EXPORT struct json_object* json_object_object_get(const struct json_object* obj, const char *key); /** Get the json_object associated with a given object field. * * This returns true if the key is found, false in all other cases (including * if obj isn't a json_type_object). * * *No* reference counts will be changed. There is no need to manually adjust * reference counts through the json_object_put/json_object_get methods unless * you need to have the child (value) reference maintain a different lifetime * than the owning parent (obj). Ownership of value is retained by obj. * * @param obj the json_object instance * @param key the object field name * @param value a pointer where to store a reference to the json_object * associated with the given field name. * * It is safe to pass a NULL value. * @returns whether or not the key exists */ JSON_EXPORT json_bool json_object_object_get_ex(const struct json_object* obj, const char *key, struct json_object **value); /** Delete the given json_object field * * The reference count will be decremented for the deleted object. If there * are no more owners of the value represented by this key, then the value is * freed. Otherwise, the reference to the value will remain in memory. * * @param obj the json_object instance * @param key the object field name */ JSON_EXPORT void json_object_object_del(struct json_object* obj, const char *key); /** * Iterate through all keys and values of an object. * * Adding keys to the object while iterating is NOT allowed. * * Deleting an existing key, or replacing an existing key with a * new value IS allowed. * * @param obj the json_object instance * @param key the local name for the char* key variable defined in the body * @param val the local name for the json_object* object variable defined in * the body */ #if defined(__GNUC__) && !defined(__STRICT_ANSI__) && __STDC_VERSION__ >= 199901L # define json_object_object_foreach(obj,key,val) \ char *key = NULL; \ struct json_object *val __attribute__((__unused__)) = NULL; \ for(struct lh_entry *entry ## key = json_object_get_object(obj)->head, *entry_next ## key = NULL; \ ({ if(entry ## key) { \ key = (char*)lh_entry_k(entry ## key); \ val = (struct json_object*)lh_entry_v(entry ## key); \ entry_next ## key = entry ## key->next; \ } ; entry ## key; }); \ entry ## key = entry_next ## key ) #else /* ANSI C or MSC */ # define json_object_object_foreach(obj,key,val) \ char *key = NULL;\ struct json_object *val = NULL; \ struct lh_entry *entry ## key; \ struct lh_entry *entry_next ## key = NULL; \ for(entry ## key = json_object_get_object(obj)->head; \ (entry ## key ? ( \ key = (char*)lh_entry_k(entry ## key), \ val = (struct json_object*)lh_entry_v(entry ## key), \ entry_next ## key = entry ## key->next, \ entry ## key) : 0); \ entry ## key = entry_next ## key) #endif /* defined(__GNUC__) && !defined(__STRICT_ANSI__) && __STDC_VERSION__ >= 199901L */ /** Iterate through all keys and values of an object (ANSI C Safe) * @param obj the json_object instance * @param iter the object iterator, use type json_object_iter */ #define json_object_object_foreachC(obj,iter) \ for(iter.entry = json_object_get_object(obj)->head; \ (iter.entry ? (iter.key = (char*)lh_entry_k(iter.entry), iter.val = (struct json_object*)lh_entry_v(iter.entry), iter.entry) : 0); \ iter.entry = iter.entry->next) /* Array type methods */ /** Create a new empty json_object of type json_type_array * @returns a json_object of type json_type_array */ JSON_EXPORT struct json_object* json_object_new_array(void); /** Get the arraylist of a json_object of type json_type_array * @param obj the json_object instance * @returns an arraylist */ JSON_EXPORT struct array_list* json_object_get_array(const struct json_object *obj); /** Get the length of a json_object of type json_type_array * @param obj the json_object instance * @returns an int */ JSON_EXPORT size_t json_object_array_length(const struct json_object *obj); /** Sorts the elements of jso of type json_type_array * * Pointers to the json_object pointers will be passed as the two arguments * to sort_fn * * @param jso the json_object instance * @param sort_fn a sorting function */ JSON_EXPORT void json_object_array_sort(struct json_object *jso, int(*sort_fn)(const void *, const void *)); /** Binary search a sorted array for a specified key object. * * It depends on your compare function what's sufficient as a key. * Usually you create some dummy object with the parameter compared in * it, to identify the right item you're actually looking for. * * @see json_object_array_sort() for hints on the compare function. * * @param key a dummy json_object with the right key * @param jso the array object we're searching * @param sort_fn the sort/compare function * * @return the wanted json_object instance */ JSON_EXPORT struct json_object* json_object_array_bsearch( const struct json_object *key, const struct json_object *jso, int (*sort_fn)(const void *, const void *)); /** Add an element to the end of a json_object of type json_type_array * * The reference count will *not* be incremented. This is to make adding * fields to objects in code more compact. If you want to retain a reference * to an added object you must wrap the passed object with json_object_get * * @param obj the json_object instance * @param val the json_object to be added */ JSON_EXPORT int json_object_array_add(struct json_object *obj, struct json_object *val); /** Insert or replace an element at a specified index in an array (a json_object of type json_type_array) * * The reference count will *not* be incremented. This is to make adding * fields to objects in code more compact. If you want to retain a reference * to an added object you must wrap the passed object with json_object_get * * The reference count of a replaced object will be decremented. * * The array size will be automatically be expanded to the size of the * index if the index is larger than the current size. * * @param obj the json_object instance * @param idx the index to insert the element at * @param val the json_object to be added */ JSON_EXPORT int json_object_array_put_idx(struct json_object *obj, size_t idx, struct json_object *val); /** Get the element at specificed index of the array (a json_object of type json_type_array) * @param obj the json_object instance * @param idx the index to get the element at * @returns the json_object at the specified index (or NULL) */ JSON_EXPORT struct json_object* json_object_array_get_idx(const struct json_object *obj, size_t idx); /** Delete an elements from a specified index in an array (a json_object of type json_type_array) * * The reference count will be decremented for each of the deleted objects. If there * are no more owners of an element that is being deleted, then the value is * freed. Otherwise, the reference to the value will remain in memory. * * @param obj the json_object instance * @param idx the index to start deleting elements at * @param count the number of elements to delete * @returns 0 if the elements were successfully deleted */ JSON_EXPORT int json_object_array_del_idx(struct json_object *obj, size_t idx, size_t count); /* json_bool type methods */ /** Create a new empty json_object of type json_type_boolean * @param b a json_bool TRUE or FALSE (1 or 0) * @returns a json_object of type json_type_boolean */ JSON_EXPORT struct json_object* json_object_new_boolean(json_bool b); /** Get the json_bool value of a json_object * * The type is coerced to a json_bool if the passed object is not a json_bool. * integer and double objects will return FALSE if there value is zero * or TRUE otherwise. If the passed object is a string it will return * TRUE if it has a non zero length. If any other object type is passed * TRUE will be returned if the object is not NULL. * * @param obj the json_object instance * @returns a json_bool */ JSON_EXPORT json_bool json_object_get_boolean(const struct json_object *obj); /** Set the json_bool value of a json_object * * The type of obj is checked to be a json_type_boolean and 0 is returned * if it is not without any further actions. If type of obj is json_type_boolean * the obect value is chaned to new_value * * @param obj the json_object instance * @param new_value the value to be set * @returns 1 if value is set correctly, 0 otherwise */ JSON_EXPORT int json_object_set_boolean(struct json_object *obj,json_bool new_value); /* int type methods */ /** Create a new empty json_object of type json_type_int * Note that values are stored as 64-bit values internally. * To ensure the full range is maintained, use json_object_new_int64 instead. * @param i the integer * @returns a json_object of type json_type_int */ JSON_EXPORT struct json_object* json_object_new_int(int32_t i); /** Create a new empty json_object of type json_type_int * @param i the integer * @returns a json_object of type json_type_int */ JSON_EXPORT struct json_object* json_object_new_int64(int64_t i); /** Get the int value of a json_object * * The type is coerced to a int if the passed object is not a int. * double objects will return their integer conversion. Strings will be * parsed as an integer. If no conversion exists then 0 is returned * and errno is set to EINVAL. null is equivalent to 0 (no error values set) * * Note that integers are stored internally as 64-bit values. * If the value of too big or too small to fit into 32-bit, INT32_MAX or * INT32_MIN are returned, respectively. * * @param obj the json_object instance * @returns an int */ JSON_EXPORT int32_t json_object_get_int(const struct json_object *obj); /** Set the int value of a json_object * * The type of obj is checked to be a json_type_int and 0 is returned * if it is not without any further actions. If type of obj is json_type_int * the obect value is changed to new_value * * @param obj the json_object instance * @param new_value the value to be set * @returns 1 if value is set correctly, 0 otherwise */ JSON_EXPORT int json_object_set_int(struct json_object *obj,int new_value); /** Increment a json_type_int object by the given amount, which may be negative. * * If the type of obj is not json_type_int then 0 is returned with no further * action taken. * If the addition would result in a overflow, the object value * is set to INT64_MAX. * If the addition would result in a underflow, the object value * is set to INT64_MIN. * Neither overflow nor underflow affect the return value. * * @param obj the json_object instance * @param val the value to add * @returns 1 if the increment succeded, 0 otherwise */ JSON_EXPORT int json_object_int_inc(struct json_object *obj, int64_t val); /** Get the int value of a json_object * * The type is coerced to a int64 if the passed object is not a int64. * double objects will return their int64 conversion. Strings will be * parsed as an int64. If no conversion exists then 0 is returned. * * NOTE: Set errno to 0 directly before a call to this function to determine * whether or not conversion was successful (it does not clear the value for * you). * * @param obj the json_object instance * @returns an int64 */ JSON_EXPORT int64_t json_object_get_int64(const struct json_object *obj); /** Set the int64_t value of a json_object * * The type of obj is checked to be a json_type_int and 0 is returned * if it is not without any further actions. If type of obj is json_type_int * the obect value is chaned to new_value * * @param obj the json_object instance * @param new_value the value to be set * @returns 1 if value is set correctly, 0 otherwise */ JSON_EXPORT int json_object_set_int64(struct json_object *obj,int64_t new_value); /* double type methods */ /** Create a new empty json_object of type json_type_double * * @see json_object_double_to_json_string() for how to set a custom format string. * * @param d the double * @returns a json_object of type json_type_double */ JSON_EXPORT struct json_object* json_object_new_double(double d); /** * Create a new json_object of type json_type_double, using * the exact serialized representation of the value. * * This allows for numbers that would otherwise get displayed * inefficiently (e.g. 12.3 => "12.300000000000001") to be * serialized with the more convenient form. * * Notes: * * This is used by json_tokener_parse_ex() to allow for * an exact re-serialization of a parsed object. * * The userdata field is used to store the string representation, so it * can't be used for other data if this function is used. * * An equivalent sequence of calls is: * @code * jso = json_object_new_double(d); * json_object_set_serializer(jso, json_object_userdata_to_json_string, * strdup(ds), json_object_free_userdata); * @endcode * * @param d the numeric value of the double. * @param ds the string representation of the double. This will be copied. */ JSON_EXPORT struct json_object* json_object_new_double_s(double d, const char *ds); /** * Set a global or thread-local json-c option, depending on whether * JSON_C_OPTION_GLOBAL or JSON_C_OPTION_THREAD is passed. * Thread-local options default to undefined, and inherit from the global * value, even if the global value is changed after the thread is created. * Attempting to set thread-local options when threading is not compiled in * will result in an error. Be sure to check the return value. * * double_format is a "%g" printf format, such as "%.20g" * * @return -1 on errors, 0 on success. */ int json_c_set_serialization_double_format(const char *double_format, int global_or_thread); /** Serialize a json_object of type json_type_double to a string. * * This function isn't meant to be called directly. Instead, you can set a * custom format string for the serialization of this double using the * following call (where "%.17g" actually is the default): * * @code * jso = json_object_new_double(d); * json_object_set_serializer(jso, json_object_double_to_json_string, * "%.17g", NULL); * @endcode * * @see printf(3) man page for format strings * * @param jso The json_type_double object that is serialized. * @param pb The destination buffer. * @param level Ignored. * @param flags Ignored. */ JSON_EXPORT int json_object_double_to_json_string(struct json_object* jso, struct printbuf *pb, int level, int flags); /** Get the double floating point value of a json_object * * The type is coerced to a double if the passed object is not a double. * integer objects will return their double conversion. Strings will be * parsed as a double. If no conversion exists then 0.0 is returned and * errno is set to EINVAL. null is equivalent to 0 (no error values set) * * If the value is too big to fit in a double, then the value is set to * the closest infinity with errno set to ERANGE. If strings cannot be * converted to their double value, then EINVAL is set & NaN is returned. * * Arrays of length 0 are interpreted as 0 (with no error flags set). * Arrays of length 1 are effectively cast to the equivalent object and * converted using the above rules. All other arrays set the error to * EINVAL & return NaN. * * NOTE: Set errno to 0 directly before a call to this function to * determine whether or not conversion was successful (it does not clear * the value for you). * * @param obj the json_object instance * @returns a double floating point number */ JSON_EXPORT double json_object_get_double(const struct json_object *obj); /** Set the double value of a json_object * * The type of obj is checked to be a json_type_double and 0 is returned * if it is not without any further actions. If type of obj is json_type_double * the obect value is chaned to new_value * * @param obj the json_object instance * @param new_value the value to be set * @returns 1 if value is set correctly, 0 otherwise */ JSON_EXPORT int json_object_set_double(struct json_object *obj,double new_value); /* string type methods */ /** Create a new empty json_object of type json_type_string * * A copy of the string is made and the memory is managed by the json_object * * @param s the string * @returns a json_object of type json_type_string */ JSON_EXPORT struct json_object* json_object_new_string(const char *s); JSON_EXPORT struct json_object* json_object_new_string_len(const char *s, int len); /** Get the string value of a json_object * * If the passed object is of type json_type_null (i.e. obj == NULL), * NULL is returned. * * If the passed object of type json_type_string, the string contents * are returned. * * Otherwise the JSON representation of the object is returned. * * The returned string memory is managed by the json_object and will * be freed when the reference count of the json_object drops to zero. * * @param obj the json_object instance * @returns a string or NULL */ JSON_EXPORT const char* json_object_get_string(struct json_object *obj); /** Get the string length of a json_object * * If the passed object is not of type json_type_string then zero * will be returned. * * @param obj the json_object instance * @returns int */ JSON_EXPORT int json_object_get_string_len(const struct json_object *obj); /** Set the string value of a json_object with zero terminated strings * equivalent to json_object_set_string_len (obj, new_value, strlen(new_value)) * @returns 1 if value is set correctly, 0 otherwise */ JSON_EXPORT int json_object_set_string(json_object* obj, const char* new_value); /** Set the string value of a json_object str * * The type of obj is checked to be a json_type_string and 0 is returned * if it is not without any further actions. If type of obj is json_type_string * the obect value is chaned to new_value * * @param obj the json_object instance * @param new_value the value to be set; Since string legth is given in len this need not be zero terminated * @param len the length of new_value * @returns 1 if value is set correctly, 0 otherwise */ JSON_EXPORT int json_object_set_string_len(json_object* obj, const char* new_value, int len); /** Check if two json_object's are equal * * If the passed objects are equal 1 will be returned. * Equality is defined as follows: * - json_objects of different types are never equal * - json_objects of the same primitive type are equal if the * c-representation of their value is equal * - json-arrays are considered equal if all values at the same * indices are equal (same order) * - Complex json_objects are considered equal if all * contained objects referenced by their key are equal, * regardless their order. * * @param obj1 the first json_object instance * @param obj2 the second json_object instance * @returns whether both objects are equal or not */ JSON_EXPORT int json_object_equal(struct json_object *obj1, struct json_object *obj2); /** * Perform a shallow copy of src into *dst as part of an overall json_object_deep_copy(). * * If src is part of a containing object or array, parent will be non-NULL, * and key or index will be provided. * When shallow_copy is called *dst will be NULL, and must be non-NULL when it returns. * src will never be NULL. * * If shallow_copy sets the serializer on an object, return 2 to indicate to * json_object_deep_copy that it should not attempt to use the standard userdata * copy function. * * @return On success 1 or 2, -1 on errors */ typedef int (json_c_shallow_copy_fn)(json_object *src, json_object *parent, const char *key, size_t index, json_object **dst); /** * The default shallow copy implementation for use with json_object_deep_copy(). * This simply calls the appropriate json_object_new_() function and * copies over the serializer function (_to_json_string internal field of * the json_object structure) but not any _userdata or _user_delete values. * * If you're writing a custom shallow_copy function, perhaps because you're using * your own custom serializer, you can call this first to create the new object * before customizing it with json_object_set_serializer(). * * @return 1 on success, -1 on errors, but never 2. */ json_c_shallow_copy_fn json_c_shallow_copy_default; /** * Copy the contents of the JSON object. * The destination object must be initialized to NULL, * to make sure this function won't overwrite an existing JSON object. * * This does roughly the same thing as * `json_tokener_parse(json_object_get_string(src))`. * * @param src source JSON object whose contents will be copied * @param dst pointer to the destination object where the contents of `src`; * make sure this pointer is initialized to NULL * @param shallow_copy an optional function to copy individual objects, needed * when custom serializers are in use. See also * json_object set_serializer. * * @returns 0 if the copy went well, -1 if an error occured during copy * or if the destination pointer is non-NULL */ JSON_EXPORT int json_object_deep_copy(struct json_object *src, struct json_object **dst, json_c_shallow_copy_fn *shallow_copy); #ifdef __cplusplus } #endif #endif PKñ24]Ü%ÅM´´json_tokener.hnu„[µü¤/* * $Id: json_tokener.h,v 1.10 2006/07/25 03:24:50 mclark Exp $ * * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd. * Michael Clark * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * */ /** * @file * @brief Methods to parse an input string into a tree of json_object objects. */ #ifndef _json_tokener_h_ #define _json_tokener_h_ #include #include "json_object.h" #ifdef __cplusplus extern "C" { #endif enum json_tokener_error { json_tokener_success, json_tokener_continue, json_tokener_error_depth, json_tokener_error_parse_eof, json_tokener_error_parse_unexpected, json_tokener_error_parse_null, json_tokener_error_parse_boolean, json_tokener_error_parse_number, json_tokener_error_parse_array, json_tokener_error_parse_object_key_name, json_tokener_error_parse_object_key_sep, json_tokener_error_parse_object_value_sep, json_tokener_error_parse_string, json_tokener_error_parse_comment, json_tokener_error_size }; enum json_tokener_state { json_tokener_state_eatws, json_tokener_state_start, json_tokener_state_finish, json_tokener_state_null, json_tokener_state_comment_start, json_tokener_state_comment, json_tokener_state_comment_eol, json_tokener_state_comment_end, json_tokener_state_string, json_tokener_state_string_escape, json_tokener_state_escape_unicode, json_tokener_state_boolean, json_tokener_state_number, json_tokener_state_array, json_tokener_state_array_add, json_tokener_state_array_sep, json_tokener_state_object_field_start, json_tokener_state_object_field, json_tokener_state_object_field_end, json_tokener_state_object_value, json_tokener_state_object_value_add, json_tokener_state_object_sep, json_tokener_state_array_after_sep, json_tokener_state_object_field_start_after_sep, json_tokener_state_inf }; struct json_tokener_srec { enum json_tokener_state state, saved_state; struct json_object *obj; struct json_object *current; char *obj_field_name; }; #define JSON_TOKENER_DEFAULT_DEPTH 32 struct json_tokener { char *str; struct printbuf *pb; int max_depth, depth, is_double, st_pos, char_offset; enum json_tokener_error err; unsigned int ucs_char; char quote_char; struct json_tokener_srec *stack; int flags; }; /** * @deprecated Unused in json-c code */ typedef struct json_tokener json_tokener; /** * Be strict when parsing JSON input. Use caution with * this flag as what is considered valid may become more * restrictive from one release to the next, causing your * code to fail on previously working input. * * This flag is not set by default. * * @see json_tokener_set_flags() */ #define JSON_TOKENER_STRICT 0x01 /** * Given an error previously returned by json_tokener_get_error(), * return a human readable description of the error. * * @return a generic error message is returned if an invalid error value is provided. */ const char *json_tokener_error_desc(enum json_tokener_error jerr); /** * Retrieve the error caused by the last call to json_tokener_parse_ex(), * or json_tokener_success if there is no error. * * When parsing a JSON string in pieces, if the tokener is in the middle * of parsing this will return json_tokener_continue. * * See also json_tokener_error_desc(). */ JSON_EXPORT enum json_tokener_error json_tokener_get_error(struct json_tokener *tok); JSON_EXPORT struct json_tokener* json_tokener_new(void); JSON_EXPORT struct json_tokener* json_tokener_new_ex(int depth); JSON_EXPORT void json_tokener_free(struct json_tokener *tok); JSON_EXPORT void json_tokener_reset(struct json_tokener *tok); JSON_EXPORT struct json_object* json_tokener_parse(const char *str); JSON_EXPORT struct json_object* json_tokener_parse_verbose(const char *str, enum json_tokener_error *error); /** * Set flags that control how parsing will be done. */ JSON_EXPORT void json_tokener_set_flags(struct json_tokener *tok, int flags); /** * Parse a string and return a non-NULL json_object if a valid JSON value * is found. The string does not need to be a JSON object or array; * it can also be a string, number or boolean value. * * A partial JSON string can be parsed. If the parsing is incomplete, * NULL will be returned and json_tokener_get_error() will return * json_tokener_continue. * json_tokener_parse_ex() can then be called with additional bytes in str * to continue the parsing. * * If json_tokener_parse_ex() returns NULL and the error is anything other than * json_tokener_continue, a fatal error has occurred and parsing must be * halted. Then, the tok object must not be reused until json_tokener_reset() is * called. * * When a valid JSON value is parsed, a non-NULL json_object will be * returned. Also, json_tokener_get_error() will return json_tokener_success. * Be sure to check the type with json_object_is_type() or * json_object_get_type() before using the object. * * @b XXX this shouldn't use internal fields: * Trailing characters after the parsed value do not automatically cause an * error. It is up to the caller to decide whether to treat this as an * error or to handle the additional characters, perhaps by parsing another * json value starting from that point. * * Extra characters can be detected by comparing the tok->char_offset against * the length of the last len parameter passed in. * * The tokener does \b not maintain an internal buffer so the caller is * responsible for calling json_tokener_parse_ex with an appropriate str * parameter starting with the extra characters. * * This interface is presently not 64-bit clean due to the int len argument * so the function limits the maximum string size to INT32_MAX (2GB). * If the function is called with len == -1 then strlen is called to check * the string length is less than INT32_MAX (2GB) * * Example: * @code json_object *jobj = NULL; const char *mystring = NULL; int stringlen = 0; enum json_tokener_error jerr; do { mystring = ... // get JSON string, e.g. read from file, etc... stringlen = strlen(mystring); jobj = json_tokener_parse_ex(tok, mystring, stringlen); } while ((jerr = json_tokener_get_error(tok)) == json_tokener_continue); if (jerr != json_tokener_success) { fprintf(stderr, "Error: %s\n", json_tokener_error_desc(jerr)); // Handle errors, as appropriate for your application. } if (tok->char_offset < stringlen) // XXX shouldn't access internal fields { // Handle extra characters after parsed object as desired. // e.g. issue an error, parse another object from that point, etc... } // Success, use jobj here. @endcode * * @param tok a json_tokener previously allocated with json_tokener_new() * @param str an string with any valid JSON expression, or portion of. This does not need to be null terminated. * @param len the length of str */ JSON_EXPORT struct json_object* json_tokener_parse_ex(struct json_tokener *tok, const char *str, int len); #ifdef __cplusplus } #endif #endif PKñ24]ÍüÐ¼¼debug.hnu„[µü¤/* * $Id: debug.h,v 1.5 2006/01/30 23:07:57 mclark Exp $ * * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd. * Michael Clark * Copyright (c) 2009 Hewlett-Packard Development Company, L.P. * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * */ /** * @file * @brief Do not use, json-c internal, may be changed or removed at any time. */ #ifndef _DEBUG_H_ #define _DEBUG_H_ #include #ifdef __cplusplus extern "C" { #endif extern void mc_set_debug(int debug); extern int mc_get_debug(void); extern void mc_set_syslog(int syslog); extern void mc_debug(const char *msg, ...); extern void mc_error(const char *msg, ...); extern void mc_info(const char *msg, ...); #ifndef __STRING #define __STRING(x) #x #endif #ifndef PARSER_BROKEN_FIXED #define JASSERT(cond) do {} while(0) #else #define JASSERT(cond) do { \ if (!(cond)) { \ mc_error("cjson assert failure %s:%d : cond \"" __STRING(cond) "failed\n", __FILE__, __LINE__); \ *(int *)0 = 1;\ abort(); \ }\ } while(0) #endif #define MC_ERROR(x, ...) mc_error(x, ##__VA_ARGS__) #ifdef MC_MAINTAINER_MODE #define MC_SET_DEBUG(x) mc_set_debug(x) #define MC_GET_DEBUG() mc_get_debug() #define MC_SET_SYSLOG(x) mc_set_syslog(x) #define MC_DEBUG(x, ...) mc_debug(x, ##__VA_ARGS__) #define MC_INFO(x, ...) mc_info(x, ##__VA_ARGS__) #else #define MC_SET_DEBUG(x) if (0) mc_set_debug(x) #define MC_GET_DEBUG() (0) #define MC_SET_SYSLOG(x) if (0) mc_set_syslog(x) #define MC_DEBUG(x, ...) if (0) mc_debug(x, ##__VA_ARGS__) #define MC_INFO(x, ...) if (0) mc_info(x, ##__VA_ARGS__) #endif #ifdef __cplusplus } #endif #endif PKñ24]»ðÆlààjson_pointer.hnu„[µü¤/* * Copyright (c) 2016 Alexadru Ardelean. * * This is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * */ /** * @file * @brief JSON Pointer (RFC 6901) implementation for retrieving * objects from a json-c object tree. */ #ifndef _json_pointer_h_ #define _json_pointer_h_ #include "json_object.h" #ifdef __cplusplus extern "C" { #endif /** * Retrieves a JSON sub-object from inside another JSON object * using the JSON pointer notation as defined in RFC 6901 * https://tools.ietf.org/html/rfc6901 * * The returned JSON sub-object is equivalent to parsing manually the * 'obj' JSON tree ; i.e. it's not a new object that is created, but rather * a pointer inside the JSON tree. * * Internally, this is equivalent to doing a series of 'json_object_object_get()' * and 'json_object_array_get_idx()' along the given 'path'. * * Note that the 'path' string supports 'printf()' type arguments, so, whatever * is added after the 'res' param will be treated as an argument for 'path' * Example: json_pointer_get(obj, "/foo/%d/%s", &res, 0, bar) * This means, that you need to escape '%' with '%%' (just like in printf()) * * @param obj the json_object instance/tree from where to retrieve sub-objects * @param path a (RFC6901) string notation for the sub-object to retrieve * @param res a pointer where to store a reference to the json_object * associated with the given path * * @return negative if an error (or not found), or 0 if succeeded */ int json_pointer_get(struct json_object *obj, const char *path, struct json_object **res); /** * This is a variant of 'json_pointer_get()' that supports printf() style arguments. * * Example: json_pointer_getf(obj, res, "/foo/%d/%s", 0, bak) * This also means that you need to escape '%' with '%%' (just like in printf()) * * Please take into consideration all recommended 'printf()' format security * aspects when using this function. * * @param obj the json_object instance/tree to which to add a sub-object * @param res a pointer where to store a reference to the json_object * associated with the given path * @param path_fmt a printf() style format for the path * * @return negative if an error (or not found), or 0 if succeeded */ int json_pointer_getf(struct json_object *obj, struct json_object **res, const char *path_fmt, ...); /** * Sets JSON object 'value' in the 'obj' tree at the location specified * by the 'path'. 'path' is JSON pointer notation as defined in RFC 6901 * https://tools.ietf.org/html/rfc6901 * * Note that 'obj' is a double pointer, mostly for the "" (empty string) * case, where the entire JSON object would be replaced by 'value'. * In the case of the "" path, the object at '*obj' will have it's refcount * decremented with 'json_object_put()' and the 'value' object will be assigned to it. * * For other cases (JSON sub-objects) ownership of 'value' will be transferred into * '*obj' via 'json_object_object_add()' & 'json_object_array_put_idx()', so the * only time the refcount should be decremented for 'value' is when the return value of * 'json_pointer_set()' is negative (meaning the 'value' object did not get set into '*obj'). * * That also implies that 'json_pointer_set()' does not do any refcount incrementing. * (Just that single decrement that was mentioned above). * * Note that the 'path' string supports 'printf()' type arguments, so, whatever * is added after the 'value' param will be treated as an argument for 'path' * Example: json_pointer_set(obj, "/foo/%d/%s", value, 0, bak) * This means, that you need to escape '%' with '%%' (just like in printf()) * * @param obj the json_object instance/tree to which to add a sub-object * @param path a (RFC6901) string notation for the sub-object to set in the tree * @param value object to set at path * * @return negative if an error (or not found), or 0 if succeeded */ int json_pointer_set(struct json_object **obj, const char *path, struct json_object *value); /** * This is a variant of 'json_pointer_set()' that supports printf() style arguments. * * Example: json_pointer_setf(obj, value, "/foo/%d/%s", 0, bak) * This also means that you need to escape '%' with '%%' (just like in printf()) * * Please take into consideration all recommended 'printf()' format security * aspects when using this function. * * @param obj the json_object instance/tree to which to add a sub-object * @param value object to set at path * @param path_fmt a printf() style format for the path * * @return negative if an error (or not found), or 0 if succeeded */ int json_pointer_setf(struct json_object **obj, struct json_object *value, const char *path_fmt, ...); #ifdef __cplusplus } #endif #endif PKñ24]h³ˆarraylist.hnu„[µü¤/* * $Id: arraylist.h,v 1.4 2006/01/26 02:16:28 mclark Exp $ * * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd. * Michael Clark * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * */ /** * @file * @brief Internal methods for working with json_type_array objects. * Although this is exposed by the json_object_get_array() method, * it is not recommended for direct use. */ #ifndef _arraylist_h_ #define _arraylist_h_ #ifdef __cplusplus extern "C" { #endif #define ARRAY_LIST_DEFAULT_SIZE 32 typedef void (array_list_free_fn) (void *data); struct array_list { void **array; size_t length; size_t size; array_list_free_fn *free_fn; }; typedef struct array_list array_list; extern struct array_list* array_list_new(array_list_free_fn *free_fn); extern void array_list_free(struct array_list *al); extern void* array_list_get_idx(struct array_list *al, size_t i); extern int array_list_put_idx(struct array_list *al, size_t i, void *data); extern int array_list_add(struct array_list *al, void *data); extern size_t array_list_length(struct array_list *al); extern void array_list_sort(struct array_list *arr, int(*compar)(const void *, const void *)); extern void* array_list_bsearch(const void **key, struct array_list *arr, int (*sort_fn)(const void *, const void *)); extern int array_list_del_idx(struct array_list *arr, size_t idx, size_t count); #ifdef __cplusplus } #endif #endif PKñ24]ÑIˆµµjson_util.hnu„[µü¤/* * $Id: json_util.h,v 1.4 2006/01/30 23:07:57 mclark Exp $ * * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd. * Michael Clark * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * */ /** * @file * @brief Miscllaneous utility functions and macros. */ #ifndef _json_util_h_ #define _json_util_h_ #include "json_object.h" #ifndef json_min #define json_min(a,b) ((a) < (b) ? (a) : (b)) #endif #ifndef json_max #define json_max(a,b) ((a) > (b) ? (a) : (b)) #endif #ifdef __cplusplus extern "C" { #endif #define JSON_FILE_BUF_SIZE 4096 /* utility functions */ /** * Read the full contents of the given file, then convert it to a * json_object using json_tokener_parse(). * * Returns -1 if something fails. See json_util_get_last_err() for details. */ extern struct json_object* json_object_from_file(const char *filename); /** * Create a JSON object from already opened file descriptor. * * This function can be helpful, when you opened the file already, * e.g. when you have a temp file. * Note, that the fd must be readable at the actual position, i.e. * use lseek(fd, 0, SEEK_SET) before. * * Returns -1 if something fails. See json_util_get_last_err() for details. */ extern struct json_object* json_object_from_fd(int fd); /** * Equivalent to: * json_object_to_file_ext(filename, obj, JSON_C_TO_STRING_PLAIN); * * Returns -1 if something fails. See json_util_get_last_err() for details. */ extern int json_object_to_file(const char *filename, struct json_object *obj); /** * Open and truncate the given file, creating it if necessary, then * convert the json_object to a string and write it to the file. * * Returns -1 if something fails. See json_util_get_last_err() for details. */ extern int json_object_to_file_ext(const char *filename, struct json_object *obj, int flags); /** * Convert the json_object to a string and write it to the file descriptor. * Handles partial writes and will keep writing until done, or an error * occurs. * * @param fd an open, writable file descriptor to write to * @param obj the object to serializer and write * @param flags flags to pass to json_object_to_json_string_ext() * @return -1 if something fails. See json_util_get_last_err() for details. */ extern int json_object_to_fd(int fd, struct json_object *obj, int flags); /** * Return the last error from various json-c functions, including: * json_object_to_file{,_ext}, json_object_to_fd() or * json_object_from_{file,fd}, or NULL if there is none. */ const char *json_util_get_last_err(void); extern int json_parse_int64(const char *buf, int64_t *retval); extern int json_parse_double(const char *buf, double *retval); /** * Return a string describing the type of the object. * e.g. "int", or "object", etc... */ extern const char *json_type_to_name(enum json_type o_type); #ifdef __cplusplus } #endif #endif PKñ24] ÐTB printbuf.hnu„[µü¤/* * $Id: printbuf.h,v 1.4 2006/01/26 02:16:28 mclark Exp $ * * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd. * Michael Clark * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * * * Copyright (c) 2008-2009 Yahoo! Inc. All rights reserved. * The copyrights to the contents of this file are licensed under the MIT License * (http://www.opensource.org/licenses/mit-license.php) */ /** * @file * @brief Internal string buffer handing. Unless you're writing a * json_object_to_json_string_fn implementation for use with * json_object_set_serializer() direct use of this is not * recommended. */ #ifndef _printbuf_h_ #define _printbuf_h_ #ifdef __cplusplus extern "C" { #endif struct printbuf { char *buf; int bpos; int size; }; typedef struct printbuf printbuf; extern struct printbuf* printbuf_new(void); /* As an optimization, printbuf_memappend_fast() is defined as a macro * that handles copying data if the buffer is large enough; otherwise * it invokes printbuf_memappend() which performs the heavy * lifting of realloc()ing the buffer and copying data. * * Your code should not use printbuf_memappend() directly unless it * checks the return code. Use printbuf_memappend_fast() instead. */ extern int printbuf_memappend(struct printbuf *p, const char *buf, int size); #define printbuf_memappend_fast(p, bufptr, bufsize) \ do { \ if ((p->size - p->bpos) > bufsize) { \ memcpy(p->buf + p->bpos, (bufptr), bufsize); \ p->bpos += bufsize; \ p->buf[p->bpos]= '\0'; \ } else { printbuf_memappend(p, (bufptr), bufsize); } \ } while (0) #define printbuf_length(p) ((p)->bpos) /** * Results in a compile error if the argument is not a string literal. */ #define _printbuf_check_literal(mystr) ("" mystr) /** * This is an optimization wrapper around printbuf_memappend() that is useful * for appending string literals. Since the size of string constants is known * at compile time, using this macro can avoid a costly strlen() call. This is * especially helpful when a constant string must be appended many times. If * you got here because of a compilation error caused by passing something * other than a string literal, use printbuf_memappend_fast() in conjunction * with strlen(). * * See also: * printbuf_memappend_fast() * printbuf_memappend() * sprintbuf() */ #define printbuf_strappend(pb, str) \ printbuf_memappend ((pb), _printbuf_check_literal(str), sizeof(str) - 1) /** * Set len bytes of the buffer to charvalue, starting at offset offset. * Similar to calling memset(x, charvalue, len); * * The memory allocated for the buffer is extended as necessary. * * If offset is -1, this starts at the end of the current data in the buffer. */ extern int printbuf_memset(struct printbuf *pb, int offset, int charvalue, int len); /** * Formatted print to printbuf. * * This function is the most expensive of the available functions for appending * string data to a printbuf and should be used only where convenience is more * important than speed. Avoid using this function in high performance code or * tight loops; in these scenarios, consider using snprintf() with a static * buffer in conjunction with one of the printbuf_*append() functions. * * See also: * printbuf_memappend_fast() * printbuf_memappend() * printbuf_strappend() */ extern int sprintbuf(struct printbuf *p, const char *msg, ...); extern void printbuf_reset(struct printbuf *p); extern void printbuf_free(struct printbuf *p); #ifdef __cplusplus } #endif #endif PKñ24]/§SR R json_object_iterator.hnu„[µü¤/** ******************************************************************************* * @file json_object_iterator.h * * Copyright (c) 2009-2012 Hewlett-Packard Development Company, L.P. * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * * @brief An API for iterating over json_type_object objects, * styled to be familiar to C++ programmers. * Unlike json_object_object_foreach() and * json_object_object_foreachC(), this avoids the need to expose * json-c internals like lh_entry. * * API attributes:
* * Thread-safe: NO
* * Reentrant: NO * ******************************************************************************* */ #ifndef JSON_OBJECT_ITERATOR_H #define JSON_OBJECT_ITERATOR_H #include #ifdef __cplusplus extern "C" { #endif /** * Forward declaration for the opaque iterator information. */ struct json_object_iter_info_; /** * The opaque iterator that references a name/value pair within * a JSON Object instance or the "end" iterator value. */ struct json_object_iterator { const void* opaque_; }; /** * forward declaration of json-c's JSON value instance structure */ struct json_object; /** * Initializes an iterator structure to a "default" value that * is convenient for initializing an iterator variable to a * default state (e.g., initialization list in a class' * constructor). * * @code * struct json_object_iterator iter = json_object_iter_init_default(); * MyClass() : iter_(json_object_iter_init_default()) * @endcode * * @note The initialized value doesn't reference any specific * pair, is considered an invalid iterator, and MUST NOT * be passed to any json-c API that expects a valid * iterator. * * @note User and internal code MUST NOT make any assumptions * about and dependencies on the value of the "default" * iterator value. * * @return json_object_iterator */ struct json_object_iterator json_object_iter_init_default(void); /** Retrieves an iterator to the first pair of the JSON Object. * * @warning Any modification of the underlying pair invalidates all * iterators to that pair. * * @param obj JSON Object instance (MUST be of type json_object) * * @return json_object_iterator If the JSON Object has at * least one pair, on return, the iterator refers * to the first pair. If the JSON Object doesn't * have any pairs, the returned iterator is * equivalent to the "end" iterator for the same * JSON Object instance. * * @code * struct json_object_iterator it; * struct json_object_iterator itEnd; * struct json_object* obj; * * obj = json_tokener_parse("{'first':'george', 'age':100}"); * it = json_object_iter_begin(obj); * itEnd = json_object_iter_end(obj); * * while (!json_object_iter_equal(&it, &itEnd)) { * printf("%s\n", * json_object_iter_peek_name(&it)); * json_object_iter_next(&it); * } * * @endcode */ struct json_object_iterator json_object_iter_begin(struct json_object* obj); /** Retrieves the iterator that represents the position beyond the * last pair of the given JSON Object instance. * * @warning Do NOT write code that assumes that the "end" * iterator value is NULL, even if it is so in a * particular instance of the implementation. * * @note The reason we do not (and MUST NOT) provide * "json_object_iter_is_end(json_object_iterator* iter)" * type of API is because it would limit the underlying * representation of name/value containment (or force us * to add additional, otherwise unnecessary, fields to * the iterator structure). The "end" iterator and the * equality test method, on the other hand, permit us to * cleanly abstract pretty much any reasonable underlying * representation without burdening the iterator * structure with unnecessary data. * * @note For performance reasons, memorize the "end" iterator prior * to any loop. * * @param obj JSON Object instance (MUST be of type json_object) * * @return json_object_iterator On return, the iterator refers * to the "end" of the Object instance's pairs * (i.e., NOT the last pair, but "beyond the last * pair" value) */ struct json_object_iterator json_object_iter_end(const struct json_object* obj); /** Returns an iterator to the next pair, if any * * @warning Any modification of the underlying pair * invalidates all iterators to that pair. * * @param iter [IN/OUT] Pointer to iterator that references a * name/value pair; MUST be a valid, non-end iterator. * WARNING: bad things will happen if invalid or "end" * iterator is passed. Upon return will contain the * reference to the next pair if there is one; if there * are no more pairs, will contain the "end" iterator * value, which may be compared against the return value * of json_object_iter_end() for the same JSON Object * instance. */ void json_object_iter_next(struct json_object_iterator* iter); /** Returns a const pointer to the name of the pair referenced * by the given iterator. * * @param iter pointer to iterator that references a name/value * pair; MUST be a valid, non-end iterator. * * @warning bad things will happen if an invalid or * "end" iterator is passed. * * @return const char* Pointer to the name of the referenced * name/value pair. The name memory belongs to the * name/value pair, will be freed when the pair is * deleted or modified, and MUST NOT be modified or * freed by the user. */ const char* json_object_iter_peek_name(const struct json_object_iterator* iter); /** Returns a pointer to the json-c instance representing the * value of the referenced name/value pair, without altering * the instance's reference count. * * @param iter pointer to iterator that references a name/value * pair; MUST be a valid, non-end iterator. * * @warning bad things will happen if invalid or * "end" iterator is passed. * * @return struct json_object* Pointer to the json-c value * instance of the referenced name/value pair; the * value's reference count is not changed by this * function: if you plan to hold on to this json-c node, * take a look at json_object_get() and * json_object_put(). IMPORTANT: json-c API represents * the JSON Null value as a NULL json_object instance * pointer. */ struct json_object* json_object_iter_peek_value(const struct json_object_iterator* iter); /** Tests two iterators for equality. Typically used to test * for end of iteration by comparing an iterator to the * corresponding "end" iterator (that was derived from the same * JSON Object instance). * * @note The reason we do not (and MUST NOT) provide * "json_object_iter_is_end(json_object_iterator* iter)" * type of API is because it would limit the underlying * representation of name/value containment (or force us * to add additional, otherwise unnecessary, fields to * the iterator structure). The equality test method, on * the other hand, permits us to cleanly abstract pretty * much any reasonable underlying representation. * * @param iter1 Pointer to first valid, non-NULL iterator * @param iter2 POinter to second valid, non-NULL iterator * * @warning if a NULL iterator pointer or an uninitialized * or invalid iterator, or iterators derived from * different JSON Object instances are passed, bad things * will happen! * * @return json_bool non-zero if iterators are equal (i.e., both * reference the same name/value pair or are both at * "end"); zero if they are not equal. */ json_bool json_object_iter_equal(const struct json_object_iterator* iter1, const struct json_object_iterator* iter2); #ifdef __cplusplus } #endif #endif /* JSON_OBJECT_ITERATOR_H */ PKñ24]?¤-++ linkhash.hnu„[µü¤/* * $Id: linkhash.h,v 1.6 2006/01/30 23:07:57 mclark Exp $ * * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd. * Michael Clark * Copyright (c) 2009 Hewlett-Packard Development Company, L.P. * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * */ /** * @file * @brief Internal methods for working with json_type_object objects. Although * this is exposed by the json_object_get_object() function and within the * json_object_iter type, it is not recommended for direct use. */ #ifndef _linkhash_h_ #define _linkhash_h_ #include "json_object.h" #ifdef __cplusplus extern "C" { #endif /** * golden prime used in hash functions */ #define LH_PRIME 0x9e370001UL /** * The fraction of filled hash buckets until an insert will cause the table * to be resized. * This can range from just above 0 up to 1.0. */ #define LH_LOAD_FACTOR 0.66 /** * sentinel pointer value for empty slots */ #define LH_EMPTY (void*)-1 /** * sentinel pointer value for freed slots */ #define LH_FREED (void*)-2 /** * default string hash function */ #define JSON_C_STR_HASH_DFLT 0 /** * perl-like string hash function */ #define JSON_C_STR_HASH_PERLLIKE 1 /** * This function sets the hash function to be used for strings. * Must be one of the JSON_C_STR_HASH_* values. * @returns 0 - ok, -1 if parameter was invalid */ int json_global_set_string_hash(const int h); struct lh_entry; /** * callback function prototypes */ typedef void (lh_entry_free_fn) (struct lh_entry *e); /** * callback function prototypes */ typedef unsigned long (lh_hash_fn) (const void *k); /** * callback function prototypes */ typedef int (lh_equal_fn) (const void *k1, const void *k2); /** * An entry in the hash table */ struct lh_entry { /** * The key. Use lh_entry_k() instead of accessing this directly. */ const void *k; /** * A flag for users of linkhash to know whether or not they * need to free k. */ int k_is_constant; /** * The value. Use lh_entry_v() instead of accessing this directly. */ const void *v; /** * The next entry */ struct lh_entry *next; /** * The previous entry. */ struct lh_entry *prev; }; /** * The hash table structure. */ struct lh_table { /** * Size of our hash. */ int size; /** * Numbers of entries. */ int count; /** * The first entry. */ struct lh_entry *head; /** * The last entry. */ struct lh_entry *tail; struct lh_entry *table; /** * A pointer onto the function responsible for freeing an entry. */ lh_entry_free_fn *free_fn; lh_hash_fn *hash_fn; lh_equal_fn *equal_fn; }; typedef struct lh_table lh_table; /** * Convenience list iterator. */ #define lh_foreach(table, entry) \ for(entry = table->head; entry; entry = entry->next) /** * lh_foreach_safe allows calling of deletion routine while iterating. * * @param table a struct lh_table * to iterate over * @param entry a struct lh_entry * variable to hold each element * @param tmp a struct lh_entry * variable to hold a temporary pointer to the next element */ #define lh_foreach_safe(table, entry, tmp) \ for(entry = table->head; entry && ((tmp = entry->next) || 1); entry = tmp) /** * Create a new linkhash table. * * @param size initial table size. The table is automatically resized * although this incurs a performance penalty. * @param free_fn callback function used to free memory for entries * when lh_table_free or lh_table_delete is called. * If NULL is provided, then memory for keys and values * must be freed by the caller. * @param hash_fn function used to hash keys. 2 standard ones are defined: * lh_ptr_hash and lh_char_hash for hashing pointer values * and C strings respectively. * @param equal_fn comparison function to compare keys. 2 standard ones defined: * lh_ptr_hash and lh_char_hash for comparing pointer values * and C strings respectively. * @return On success, a pointer to the new linkhash table is returned. * On error, a null pointer is returned. */ extern struct lh_table* lh_table_new(int size, lh_entry_free_fn *free_fn, lh_hash_fn *hash_fn, lh_equal_fn *equal_fn); /** * Convenience function to create a new linkhash table with char keys. * * @param size initial table size. * @param free_fn callback function used to free memory for entries. * @return On success, a pointer to the new linkhash table is returned. * On error, a null pointer is returned. */ extern struct lh_table* lh_kchar_table_new(int size, lh_entry_free_fn *free_fn); /** * Convenience function to create a new linkhash table with ptr keys. * * @param size initial table size. * @param free_fn callback function used to free memory for entries. * @return On success, a pointer to the new linkhash table is returned. * On error, a null pointer is returned. */ extern struct lh_table* lh_kptr_table_new(int size, lh_entry_free_fn *free_fn); /** * Free a linkhash table. * * If a lh_entry_free_fn callback free function was provided then it is * called for all entries in the table. * * @param t table to free. */ extern void lh_table_free(struct lh_table *t); /** * Insert a record into the table. * * @param t the table to insert into. * @param k a pointer to the key to insert. * @param v a pointer to the value to insert. * * @return On success, 0 is returned. * On error, a negative value is returned. */ extern int lh_table_insert(struct lh_table *t, const void *k, const void *v); /** * Insert a record into the table using a precalculated key hash. * * The hash h, which should be calculated with lh_get_hash() on k, is provided by * the caller, to allow for optimization when multiple operations with the same * key are known to be needed. * * @param t the table to insert into. * @param k a pointer to the key to insert. * @param v a pointer to the value to insert. * @param h hash value of the key to insert * @param opts if set to JSON_C_OBJECT_KEY_IS_CONSTANT, sets lh_entry.k_is_constant * so t's free function knows to avoid freeing the key. */ extern int lh_table_insert_w_hash(struct lh_table *t, const void *k, const void *v, const unsigned long h, const unsigned opts); /** * Lookup a record in the table. * * @param t the table to lookup * @param k a pointer to the key to lookup * @return a pointer to the record structure of the value or NULL if it does not exist. */ extern struct lh_entry* lh_table_lookup_entry(struct lh_table *t, const void *k); /** * Lookup a record in the table using a precalculated key hash. * * The hash h, which should be calculated with lh_get_hash() on k, is provided by * the caller, to allow for optimization when multiple operations with the same * key are known to be needed. * * @param t the table to lookup * @param k a pointer to the key to lookup * @param h hash value of the key to lookup * @return a pointer to the record structure of the value or NULL if it does not exist. */ extern struct lh_entry* lh_table_lookup_entry_w_hash(struct lh_table *t, const void *k, const unsigned long h); /** * Lookup a record into the table. * * @param t the table to lookup * @param k a pointer to the key to lookup * @return a pointer to the found value or NULL if it does not exist. * @deprecated Use lh_table_lookup_ex() instead. */ THIS_FUNCTION_IS_DEPRECATED(extern const void* lh_table_lookup(struct lh_table *t, const void *k)); /** * Lookup a record in the table. * * @param t the table to lookup * @param k a pointer to the key to lookup * @param v a pointer to a where to store the found value (set to NULL if it doesn't exist). * @return whether or not the key was found */ extern json_bool lh_table_lookup_ex(struct lh_table *t, const void *k, void **v); /** * Delete a record from the table. * * If a callback free function is provided then it is called for the * for the item being deleted. * @param t the table to delete from. * @param e a pointer to the entry to delete. * @return 0 if the item was deleted. * @return -1 if it was not found. */ extern int lh_table_delete_entry(struct lh_table *t, struct lh_entry *e); /** * Delete a record from the table. * * If a callback free function is provided then it is called for the * for the item being deleted. * @param t the table to delete from. * @param k a pointer to the key to delete. * @return 0 if the item was deleted. * @return -1 if it was not found. */ extern int lh_table_delete(struct lh_table *t, const void *k); extern int lh_table_length(struct lh_table *t); /** * Prints a message to stdout, * then exits the program with an exit code of 1. * * @param msg Message format string, like for printf. * @param ... Format args. * * @deprecated Since it is not a good idea to exit the entire program * because of an internal library failure, json-c will no longer * use this function internally. * However, because its interface is public, it will remain part of * the API on the off chance of legacy software using it externally. */ THIS_FUNCTION_IS_DEPRECATED(void lh_abort(const char *msg, ...)); /** * Resizes the specified table. * * @param t Pointer to table to resize. * @param new_size New table size. Must be positive. * * @return On success, 0 is returned. * On error, a negative value is returned. */ int lh_table_resize(struct lh_table *t, int new_size); /** * @deprecated Don't use this outside of linkhash.h: */ #if !defined(_MSC_VER) || (_MSC_VER > 1800) /* VS2010 can't handle inline funcs, so skip it there */ #define _LH_INLINE inline #else #define _LH_INLINE #endif /** * Calculate the hash of a key for a given table. * * This is an exension to support functions that need to calculate * the hash several times and allows them to do it just once and then pass * in the hash to all utility functions. Depending on use case, this can be a * considerable performance improvement. * @param t the table (used to obtain hash function) * @param k a pointer to the key to lookup * @return the key's hash */ static _LH_INLINE unsigned long lh_get_hash(const struct lh_table *t, const void *k) { return t->hash_fn(k); } #undef _LH_INLINE /** * @deprecated Don't use this outside of linkhash.h: */ #ifdef __UNCONST #define _LH_UNCONST(a) __UNCONST(a) #else #define _LH_UNCONST(a) ((void *)(uintptr_t)(const void *)(a)) #endif /** * Return a non-const version of lh_entry.k. * * lh_entry.k is const to indicate and help ensure that linkhash itself doesn't modify * it, but callers are allowed to do what they want with it. * See also lh_entry.k_is_constant */ #define lh_entry_k(entry) _LH_UNCONST((entry)->k) /** * Return a non-const version of lh_entry.v. * * v is const to indicate and help ensure that linkhash itself doesn't modify * it, but callers are allowed to do what they want with it. */ #define lh_entry_v(entry) _LH_UNCONST((entry)->v) #ifdef __cplusplus } #endif #endif PKñ24]:"Û/^^json_inttypes.hnu„[µü¤ /** * @file * @brief Do not use, json-c internal, may be changed or removed at any time. */ #ifndef _json_inttypes_h_ #define _json_inttypes_h_ #include "json_config.h" #ifdef JSON_C_HAVE_INTTYPES_H /* inttypes.h includes stdint.h */ #include #else #include #define PRId64 "I64d" #define SCNd64 "I64d" #endif #endif PK 1]üH9LREADMEnu„[µü¤PK 1]â³´ç?ç? SChangeLognu„[µü¤PK 1]î^ó¥SS s@README.mdnu„[µü¤PK 1]æärAAÿTREADME.htmlnu„[µü¤PKä.2]NõM¥¥{\AUTHORSnu„[µü¤PKä.2]ünÚmW]COPYINGnu„[µü¤PKñ24]·Mˆ**+fjson.hnu„[µü¤PKñ24]²^ÎQmm‹ijson_visit.hnu„[µü¤PKñ24]çæ±óó4vbits.hnu„[µü¤PKñ24]n©Æ££ ]yjson_config.hnu„[µü¤PKñ24]Ú˜Ÿ =zjson_c_version.hnu„[µü¤PKñ24]Ê·òoh”h” json_object.hnu„[µü¤PKñ24]Ü%ÅM´´Âjson_tokener.hnu„[µü¤PKñ24]ÍüÐ¼¼´/debug.hnu„[µü¤PKñ24]»ðÆlàà§6json_pointer.hnu„[µü¤PKñ24]h³ˆÅIarraylist.hnu„[µü¤PKñ24]ÑIˆµµPjson_util.hnu„[µü¤PKñ24] ÐTB \printbuf.hnu„[µü¤PKñ24]/§SR R Qkjson_object_iterator.hnu„[µü¤PKñ24]?¤-++ é‹linkhash.hnu„[µü¤PKñ24]:"Û/^^²·json_inttypes.hnu„[µü¤PK%O¹