armsrc/frozen.h

   1 /*
   2  * Copyright (c) 2004-2013 Sergey Lyubka <valenok@gmail.com>
   3  * Copyright (c) 2018 Cesanta Software Limited
   4  * All rights reserved
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the ""License"");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an ""AS IS"" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18
  19 #ifndef CS_FROZEN_FROZEN_H_
  20 #define CS_FROZEN_FROZEN_H_
  21
  22 #include <stdarg.h>
  23 #include <stdio.h>
  24
  25 /* JSON token type */
  26 enum json_token_type {
  27     JSON_TYPE_INVALID = 0, /* memsetting to 0 should create INVALID value */
  28     JSON_TYPE_STRING,
  29     JSON_TYPE_NUMBER,
  30     JSON_TYPE_TRUE,
  31     JSON_TYPE_FALSE,
  32     JSON_TYPE_NULL,
  33     JSON_TYPE_OBJECT_START,
  34     JSON_TYPE_OBJECT_END,
  35     JSON_TYPE_ARRAY_START,
  36     JSON_TYPE_ARRAY_END,
  37
  38     JSON_TYPES_CNT
  39 };
  40
  41 /*
  42  * Structure containing token type and value. Used in `json_walk()` and
  43  * `json_scanf()` with the format specifier `%T`.
  44  */
  45 struct json_token {
  46     const char *ptr;           /* Points to the beginning of the value */
  47     int len;                   /* Value length */
  48     enum json_token_type type; /* Type of the token, possible values are above */
  49 };
  50
  51 #define JSON_INVALID_TOKEN \
  52   { 0, 0, JSON_TYPE_INVALID }
  53
  54 /* Error codes */
  55 #define JSON_STRING_INVALID -1
  56 #define JSON_STRING_INCOMPLETE -2
  57
  58 /*
  59  * Callback-based SAX-like API.
  60  *
  61  * Property name and length is given only if it's available: i.e. if current
  62  * event is an object's property. In other cases, `name` is `NULL`. For
  63  * example, name is never given:
  64  *   - For the first value in the JSON string;
  65  *   - For events JSON_TYPE_OBJECT_END and JSON_TYPE_ARRAY_END
  66  *
  67  * E.g. for the input `{ "foo": 123, "bar": [ 1, 2, { "baz": true } ] }`,
  68  * the sequence of callback invocations will be as follows:
  69  *
  70  * - type: JSON_TYPE_OBJECT_START, name: NULL, path: "", value: NULL
  71  * - type: JSON_TYPE_NUMBER, name: "foo", path: ".foo", value: "123"
  72  * - type: JSON_TYPE_ARRAY_START,  name: "bar", path: ".bar", value: NULL
  73  * - type: JSON_TYPE_NUMBER, name: "0", path: ".bar[0]", value: "1"
  74  * - type: JSON_TYPE_NUMBER, name: "1", path: ".bar[1]", value: "2"
  75  * - type: JSON_TYPE_OBJECT_START, name: "2", path: ".bar[2]", value: NULL
  76  * - type: JSON_TYPE_TRUE, name: "baz", path: ".bar[2].baz", value: "true"
  77  * - type: JSON_TYPE_OBJECT_END, name: NULL, path: ".bar[2]", value: "{ \"baz\":
  78  *true }"
  79  * - type: JSON_TYPE_ARRAY_END, name: NULL, path: ".bar", value: "[ 1, 2, {
  80  *\"baz\": true } ]"
  81  * - type: JSON_TYPE_OBJECT_END, name: NULL, path: "", value: "{ \"foo\": 123,
  82  *\"bar\": [ 1, 2, { \"baz\": true } ] }"
  83  */
  84 typedef void (*json_walk_callback_t)(void *callback_data, const char *name,
  85                                      size_t name_len, const char *path,
  86                                      const struct json_token *token);
  87
  88 /*
  89  * Parse `json_string`, invoking `callback` in a way similar to SAX parsers;
  90  * see `json_walk_callback_t`.
  91  * Return number of processed bytes, or a negative error code.
  92  */
  93 int json_walk(const char *json_string, int json_string_length,
  94               json_walk_callback_t callback, void *callback_data);
  95
  96 /*
  97  * JSON generation API.
  98  * struct json_out abstracts output, allowing alternative printing plugins.
  99  */
 100 struct json_out {
 101     int (*printer)(struct json_out *, const char *str, size_t len);
 102     union {
 103         struct {
 104             char *buf;
 105             size_t size;
 106             size_t len;
 107         } buf;
 108         void *data;
 109         FILE *fp;
 110     } u;
 111 };
 112
 113 extern int json_printer_buf(struct json_out *, const char *, size_t);
 114 extern int json_printer_file(struct json_out *, const char *, size_t);
 115
 116 #define JSON_OUT_BUF(buf, len) \
 117   {                            \
 118     json_printer_buf, {        \
 119       { buf, len, 0 }          \
 120     }                          \
 121   }
 122 #define JSON_OUT_FILE(fp)   \
 123   {                         \
 124     json_printer_file, {    \
 125       { (char *) fp, 0, 0 } \
 126     }                       \
 127   }
 128
 129 typedef int (*json_printf_callback_t)(struct json_out *, va_list *ap);
 130
 131 /*
 132  * Generate formatted output into a given sting buffer.
 133  * This is a superset of printf() function, with extra format specifiers:
 134  *  - `%B` print json boolean, `true` or `false`. Accepts an `int`.
 135  *  - `%Q` print quoted escaped string or `null`. Accepts a `const char *`.
 136  *  - `%.*Q` same as `%Q`, but with length. Accepts `int`, `const char *`
 137  *  - `%V` print quoted base64-encoded string. Accepts a `const char *`, `int`.
 138  *  - `%H` print quoted hex-encoded string. Accepts a `int`, `const char *`.
 139  *  - `%M` invokes a json_printf_callback_t function. That callback function
 140  *  can consume more parameters.
 141  *
 142  * Return number of bytes printed. If the return value is bigger than the
 143  * supplied buffer, that is an indicator of overflow. In the overflow case,
 144  * overflown bytes are not printed.
 145  */
 146 int json_printf(struct json_out *, const char *fmt, ...);
 147 int json_vprintf(struct json_out *, const char *fmt, va_list xap);
 148
 149 /*
 150  * Same as json_printf, but prints to a file.
 151  * File is created if does not exist. File is truncated if already exists.
 152  */
 153 int json_fprintf(const char *file_name, const char *fmt, ...);
 154 int json_vfprintf(const char *file_name, const char *fmt, va_list ap);
 155
 156 /*
 157  * Print JSON into an allocated 0-terminated string.
 158  * Return allocated string, or NULL on error.
 159  * Example:
 160  *
 161  * ```c
 162  *   char *str = json_asprintf("{a:%H}", 3, "abc");
 163  *   printf("%s\n", str);  // Prints "616263"
 164  *   free(str);
 165  * ```
 166  */
 167 char *json_asprintf(const char *fmt, ...);
 168 char *json_vasprintf(const char *fmt, va_list ap);
 169
 170 /*
 171  * Helper %M callback that prints contiguous C arrays.
 172  * Consumes void *array_ptr, size_t array_size, size_t elem_size, char *fmt
 173  * Return number of bytes printed.
 174  */
 175 int json_printf_array(struct json_out *, va_list *ap);
 176
 177 /*
 178  * Scan JSON string `str`, performing scanf-like conversions according to `fmt`.
 179  * This is a `scanf()` - like function, with following differences:
 180  *
 181  * 1. Object keys in the format string may be not quoted, e.g. "{key: %d}"
 182  * 2. Order of keys in an object is irrelevant.
 183  * 3. Several extra format specifiers are supported:
 184  *    - %B: consumes `int *` (or `char *`, if `sizeof(bool) == sizeof(char)`),
 185  *       expects boolean `true` or `false`.
 186  *    - %Q: consumes `char **`, expects quoted, JSON-encoded string. Scanned
 187  *       string is malloc-ed, caller must free() the string.
 188  *    - %V: consumes `char **`, `int *`. Expects base64-encoded string.
 189  *       Result string is base64-decoded, malloced and NUL-terminated.
 190  *       The length of result string is stored in `int *` placeholder.
 191  *       Caller must free() the result.
 192  *    - %H: consumes `int *`, `char **`.
 193  *       Expects a hex-encoded string, e.g. "fa014f".
 194  *       Result string is hex-decoded, malloced and NUL-terminated.
 195  *       The length of the result string is stored in `int *` placeholder.
 196  *       Caller must free() the result.
 197  *    - %M: consumes custom scanning function pointer and
 198  *       `void *user_data` parameter - see json_scanner_t definition.
 199  *    - %T: consumes `struct json_token *`, fills it out with matched token.
 200  *
 201  * Return number of elements successfully scanned & converted.
 202  * Negative number means scan error.
 203  */
 204 int json_scanf(const char *str, int len, const char *fmt, ...);
 205 int json_vscanf(const char *str, int len, const char *fmt, va_list ap);
 206
 207 /* json_scanf's %M handler  */
 208 typedef void (*json_scanner_t)(const char *str, int len, void *user_data);
 209
 210 /*
 211  * Helper function to scan array item with given path and index.
 212  * Fills `token` with the matched JSON token.
 213  * Return -1 if no array element found, otherwise non-negative token length.
 214  */
 215 int json_scanf_array_elem(const char *s, int len, const char *path, int idx, struct json_token *token);
 216
 217 /*
 218  * Unescape JSON-encoded string src,slen into dst, dlen.
 219  * src and dst may overlap.
 220  * If destination buffer is too small (or zero-length), result string is not
 221  * written but the length is counted nevertheless (similar to snprintf).
 222  * Return the length of unescaped string in bytes.
 223  */
 224 int json_unescape(const char *src, int slen, char *dst, int dlen);
 225
 226 /*
 227  * Escape a string `str`, `str_len` into the printer `out`.
 228  * Return the number of bytes printed.
 229  */
 230 int json_escape(struct json_out *out, const char *str, size_t str_len);
 231
 232 /*
 233  * Read the whole file in memory.
 234  * Return malloc-ed file content, or NULL on error. The caller must free().
 235  */
 236 char *json_fread(const char *path);
 237
 238 /*
 239  * Update given JSON string `s,len` by changing the value at given `json_path`.
 240  * The result is saved to `out`. If `json_fmt` == NULL, that deletes the key.
 241  * If path is not present, missing keys are added. Array path without an
 242  * index pushes a value to the end of an array.
 243  * Return 1 if the string was changed, 0 otherwise.
 244  *
 245  * Example:  s is a JSON string { "a": 1, "b": [ 2 ] }
 246  *   json_setf(s, len, out, ".a", "7");     // { "a": 7, "b": [ 2 ] }
 247  *   json_setf(s, len, out, ".b", "7");     // { "a": 1, "b": 7 }
 248  *   json_setf(s, len, out, ".b[]", "7");   // { "a": 1, "b": [ 2,7 ] }
 249  *   json_setf(s, len, out, ".b", NULL);    // { "a": 1 }
 250  */
 251 int json_setf(const char *s, int len, struct json_out *out,
 252               const char *json_path, const char *json_fmt, ...);
 253
 254 int json_vsetf(const char *s, int len, struct json_out *out,
 255                const char *json_path, const char *json_fmt, va_list ap);
 256
 257 /*
 258  * Pretty-print JSON string `s,len` into `out`.
 259  * Return number of processed bytes in `s`.
 260  */
 261 int json_prettify(const char *s, int len, struct json_out *out);
 262
 263 /*
 264  * Prettify JSON file `file_name`.
 265  * Return number of processed bytes, or negative number of error.
 266  * On error, file content is not modified.
 267  */
 268 int json_prettify_file(const char *file_name);
 269
 270 /*
 271  * Iterate over an object at given JSON `path`.
 272  * On each iteration, fill the `key` and `val` tokens. It is OK to pass NULL
 273  * for `key`, or `val`, in which case they won't be populated.
 274  * Return an opaque value suitable for the next iteration, or NULL when done.
 275  *
 276  * Example:
 277  *
 278  * ```c
 279  * void *h = NULL;
 280  * struct json_token key, val;
 281  * while ((h = json_next_key(s, len, h, ".foo", &key, &val)) != NULL) {
 282  *   printf("[%.*s] -> [%.*s]\n", key.len, key.ptr, val.len, val.ptr);
 283  * }
 284  * ```
 285  */
 286 void *json_next_key(const char *s, int len, void *handle, const char *path,
 287                     struct json_token *key, struct json_token *val);
 288
 289 /*
 290  * Iterate over an array at given JSON `path`.
 291  * Similar to `json_next_key`, but fills array index `idx` instead of `key`.
 292  */
 293 void *json_next_elem(const char *s, int len, void *handle, const char *path,
 294                      int *idx, struct json_token *val);
 295
 296 #ifndef JSON_MAX_PATH_LEN
 297 #define JSON_MAX_PATH_LEN 256
 298 #endif
 299
 300 #ifndef JSON_MINIMAL
 301 #define JSON_MINIMAL 1
 302 #endif
 303
 304 #ifndef JSON_ENABLE_BASE64
 305 #define JSON_ENABLE_BASE64 !JSON_MINIMAL
 306 #endif
 307
 308 #ifndef JSON_ENABLE_HEX
 309 #define JSON_ENABLE_HEX !JSON_MINIMAL
 310 #endif
 311
 312 #endif /* CS_FROZEN_FROZEN_H_ */