1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
13 #include "string-util.h"
17 In case you wonder why we have our own JSON implementation, here are a couple of reasons why this implementation has
18 benefits over various other implementations:
20 - We need support for 64bit signed and unsigned integers, i.e. the full 64,5bit range of -9223372036854775808…18446744073709551615
21 - All our variants are immutable after creation
22 - Special values such as true, false, zero, null, empty strings, empty array, empty objects require zero dynamic memory
24 - Our integer/real type implicitly converts, but only if that's safe and loss-lessly possible
25 - There's a "builder" for putting together objects easily in varargs function calls
26 - There's a "dispatcher" for mapping objects to C data structures
27 - Every variant optionally carries parsing location information, which simplifies debugging and parse log error generation
28 - Formatter has color, line, column support
31 - Doesn't allow embedded NUL in strings
32 - Can't store integers outside of the -9223372036854775808…18446744073709551615 range (it will use 'long double' for
33 values outside this range, which is lossy)
34 - Can't store negative zero (will be treated identical to positive zero, and not retained across serialization)
35 - Can't store non-integer numbers that can't be stored in "long double" losslessly
36 - Allows creation and parsing of objects with duplicate keys. The "dispatcher" will refuse them however. This means
37 we can parse and pass around such objects, but will carefully refuse them when we convert them into our own data.
39 (These limitations should be pretty much in line with those of other JSON implementations, in fact might be less
40 limiting in most cases even.)
43 typedef struct JsonVariant JsonVariant
;
45 typedef enum JsonVariantType
{
48 JSON_VARIANT_UNSIGNED
,
50 JSON_VARIANT_NUMBER
, /* This a pseudo-type: we can never create variants of this type, but we use it as wildcard check for the above three types */
55 _JSON_VARIANT_TYPE_MAX
,
56 _JSON_VARIANT_TYPE_INVALID
= -EINVAL
,
59 int json_variant_new_stringn(JsonVariant
**ret
, const char *s
, size_t n
);
60 int json_variant_new_base64(JsonVariant
**ret
, const void *p
, size_t n
);
61 int json_variant_new_hex(JsonVariant
**ret
, const void *p
, size_t n
);
62 int json_variant_new_integer(JsonVariant
**ret
, intmax_t i
);
63 int json_variant_new_unsigned(JsonVariant
**ret
, uintmax_t u
);
64 int json_variant_new_real(JsonVariant
**ret
, long double d
);
65 int json_variant_new_boolean(JsonVariant
**ret
, bool b
);
66 int json_variant_new_array(JsonVariant
**ret
, JsonVariant
**array
, size_t n
);
67 int json_variant_new_array_bytes(JsonVariant
**ret
, const void *p
, size_t n
);
68 int json_variant_new_array_strv(JsonVariant
**ret
, char **l
);
69 int json_variant_new_object(JsonVariant
**ret
, JsonVariant
**array
, size_t n
);
70 int json_variant_new_null(JsonVariant
**ret
);
71 int json_variant_new_id128(JsonVariant
**ret
, sd_id128_t id
);
73 static inline int json_variant_new_string(JsonVariant
**ret
, const char *s
) {
74 return json_variant_new_stringn(ret
, s
, SIZE_MAX
);
77 JsonVariant
*json_variant_ref(JsonVariant
*v
);
78 JsonVariant
*json_variant_unref(JsonVariant
*v
);
79 void json_variant_unref_many(JsonVariant
**array
, size_t n
);
81 DEFINE_TRIVIAL_CLEANUP_FUNC(JsonVariant
*, json_variant_unref
);
83 const char *json_variant_string(JsonVariant
*v
);
84 intmax_t json_variant_integer(JsonVariant
*v
);
85 uintmax_t json_variant_unsigned(JsonVariant
*v
);
86 long double json_variant_real(JsonVariant
*v
);
87 bool json_variant_boolean(JsonVariant
*v
);
89 JsonVariantType
json_variant_type(JsonVariant
*v
);
90 bool json_variant_has_type(JsonVariant
*v
, JsonVariantType type
);
92 static inline bool json_variant_is_string(JsonVariant
*v
) {
93 return json_variant_has_type(v
, JSON_VARIANT_STRING
);
96 static inline bool json_variant_is_integer(JsonVariant
*v
) {
97 return json_variant_has_type(v
, JSON_VARIANT_INTEGER
);
100 static inline bool json_variant_is_unsigned(JsonVariant
*v
) {
101 return json_variant_has_type(v
, JSON_VARIANT_UNSIGNED
);
104 static inline bool json_variant_is_real(JsonVariant
*v
) {
105 return json_variant_has_type(v
, JSON_VARIANT_REAL
);
108 static inline bool json_variant_is_number(JsonVariant
*v
) {
109 return json_variant_has_type(v
, JSON_VARIANT_NUMBER
);
112 static inline bool json_variant_is_boolean(JsonVariant
*v
) {
113 return json_variant_has_type(v
, JSON_VARIANT_BOOLEAN
);
116 static inline bool json_variant_is_array(JsonVariant
*v
) {
117 return json_variant_has_type(v
, JSON_VARIANT_ARRAY
);
120 static inline bool json_variant_is_object(JsonVariant
*v
) {
121 return json_variant_has_type(v
, JSON_VARIANT_OBJECT
);
124 static inline bool json_variant_is_null(JsonVariant
*v
) {
125 return json_variant_has_type(v
, JSON_VARIANT_NULL
);
128 bool json_variant_is_negative(JsonVariant
*v
);
129 bool json_variant_is_blank_object(JsonVariant
*v
);
130 bool json_variant_is_blank_array(JsonVariant
*v
);
131 bool json_variant_is_normalized(JsonVariant
*v
);
132 bool json_variant_is_sorted(JsonVariant
*v
);
134 size_t json_variant_elements(JsonVariant
*v
);
135 JsonVariant
*json_variant_by_index(JsonVariant
*v
, size_t index
);
136 JsonVariant
*json_variant_by_key(JsonVariant
*v
, const char *key
);
137 JsonVariant
*json_variant_by_key_full(JsonVariant
*v
, const char *key
, JsonVariant
**ret_key
);
139 bool json_variant_equal(JsonVariant
*a
, JsonVariant
*b
);
141 void json_variant_sensitive(JsonVariant
*v
);
142 bool json_variant_is_sensitive(JsonVariant
*v
);
144 struct json_variant_foreach_state
{
145 JsonVariant
*variant
;
149 #define JSON_VARIANT_ARRAY_FOREACH(i, v) \
150 for (struct json_variant_foreach_state _state = { (v), 0 }; \
151 json_variant_is_array(_state.variant) && \
152 _state.idx < json_variant_elements(_state.variant) && \
153 ({ i = json_variant_by_index(_state.variant, _state.idx); \
157 #define JSON_VARIANT_OBJECT_FOREACH(k, e, v) \
158 for (struct json_variant_foreach_state _state = { (v), 0 }; \
159 json_variant_is_object(_state.variant) && \
160 _state.idx < json_variant_elements(_state.variant) && \
161 ({ k = json_variant_string(json_variant_by_index(_state.variant, _state.idx)); \
162 e = json_variant_by_index(_state.variant, _state.idx + 1); \
166 int json_variant_get_source(JsonVariant
*v
, const char **ret_source
, unsigned *ret_line
, unsigned *ret_column
);
168 typedef enum JsonFormatFlags
{
169 JSON_FORMAT_NEWLINE
= 1 << 0, /* suffix with newline */
170 JSON_FORMAT_PRETTY
= 1 << 1, /* add internal whitespace to appeal to human readers */
171 JSON_FORMAT_PRETTY_AUTO
= 1 << 2, /* same, but only if connected to a tty (and JSON_FORMAT_NEWLINE otherwise) */
172 JSON_FORMAT_COLOR
= 1 << 3, /* insert ANSI color sequences */
173 JSON_FORMAT_COLOR_AUTO
= 1 << 4, /* insert ANSI color sequences if colors_enabled() says so */
174 JSON_FORMAT_SOURCE
= 1 << 5, /* prefix with source filename/line/column */
175 JSON_FORMAT_SSE
= 1 << 6, /* prefix/suffix with W3C server-sent events */
176 JSON_FORMAT_SEQ
= 1 << 7, /* prefix/suffix with RFC 7464 application/json-seq */
177 JSON_FORMAT_FLUSH
= 1 << 8, /* call fflush() after dumping JSON */
178 JSON_FORMAT_OFF
= 1 << 9, /* make json_variant_format() fail with -ENOEXEC */
181 int json_variant_format(JsonVariant
*v
, JsonFormatFlags flags
, char **ret
);
182 void json_variant_dump(JsonVariant
*v
, JsonFormatFlags flags
, FILE *f
, const char *prefix
);
184 int json_variant_filter(JsonVariant
**v
, char **to_remove
);
186 int json_variant_set_field(JsonVariant
**v
, const char *field
, JsonVariant
*value
);
187 int json_variant_set_field_string(JsonVariant
**v
, const char *field
, const char *value
);
188 int json_variant_set_field_integer(JsonVariant
**v
, const char *field
, intmax_t value
);
189 int json_variant_set_field_unsigned(JsonVariant
**v
, const char *field
, uintmax_t value
);
190 int json_variant_set_field_boolean(JsonVariant
**v
, const char *field
, bool b
);
191 int json_variant_set_field_strv(JsonVariant
**v
, const char *field
, char **l
);
193 int json_variant_append_array(JsonVariant
**v
, JsonVariant
*element
);
195 int json_variant_merge(JsonVariant
**v
, JsonVariant
*m
);
197 int json_variant_strv(JsonVariant
*v
, char ***ret
);
199 int json_variant_sort(JsonVariant
**v
);
200 int json_variant_normalize(JsonVariant
**v
);
202 typedef enum JsonParseFlags
{
203 JSON_PARSE_SENSITIVE
= 1 << 0, /* mark variant as "sensitive", i.e. something containing secret key material or such */
206 int json_parse(const char *string
, JsonParseFlags flags
, JsonVariant
**ret
, unsigned *ret_line
, unsigned *ret_column
);
207 int json_parse_continue(const char **p
, JsonParseFlags flags
, JsonVariant
**ret
, unsigned *ret_line
, unsigned *ret_column
);
208 int json_parse_file_at(FILE *f
, int dir_fd
, const char *path
, JsonParseFlags flags
, JsonVariant
**ret
, unsigned *ret_line
, unsigned *ret_column
);
210 static inline int json_parse_file(FILE *f
, const char *path
, JsonParseFlags flags
, JsonVariant
**ret
, unsigned *ret_line
, unsigned *ret_column
) {
211 return json_parse_file_at(f
, AT_FDCWD
, path
, flags
, ret
, ret_line
, ret_column
);
217 _JSON_BUILD_UNSIGNED
,
220 _JSON_BUILD_ARRAY_BEGIN
,
221 _JSON_BUILD_ARRAY_END
,
222 _JSON_BUILD_OBJECT_BEGIN
,
223 _JSON_BUILD_OBJECT_END
,
225 _JSON_BUILD_PAIR_CONDITION
,
228 _JSON_BUILD_VARIANT_ARRAY
,
234 _JSON_BUILD_BYTE_ARRAY
,
238 #define JSON_BUILD_STRING(s) _JSON_BUILD_STRING, ({ const char *_x = s; _x; })
239 #define JSON_BUILD_INTEGER(i) _JSON_BUILD_INTEGER, ({ intmax_t _x = i; _x; })
240 #define JSON_BUILD_UNSIGNED(u) _JSON_BUILD_UNSIGNED, ({ uintmax_t _x = u; _x; })
241 #define JSON_BUILD_REAL(d) _JSON_BUILD_REAL, ({ long double _x = d; _x; })
242 #define JSON_BUILD_BOOLEAN(b) _JSON_BUILD_BOOLEAN, ({ bool _x = b; _x; })
243 #define JSON_BUILD_ARRAY(...) _JSON_BUILD_ARRAY_BEGIN, __VA_ARGS__, _JSON_BUILD_ARRAY_END
244 #define JSON_BUILD_EMPTY_ARRAY _JSON_BUILD_ARRAY_BEGIN, _JSON_BUILD_ARRAY_END
245 #define JSON_BUILD_OBJECT(...) _JSON_BUILD_OBJECT_BEGIN, __VA_ARGS__, _JSON_BUILD_OBJECT_END
246 #define JSON_BUILD_EMPTY_OBJECT _JSON_BUILD_OBJECT_BEGIN, _JSON_BUILD_OBJECT_END
247 #define JSON_BUILD_PAIR(n, ...) _JSON_BUILD_PAIR, ({ const char *_x = n; _x; }), __VA_ARGS__
248 #define JSON_BUILD_PAIR_CONDITION(c, n, ...) _JSON_BUILD_PAIR_CONDITION, ({ bool _x = c; _x; }), ({ const char *_x = n; _x; }), __VA_ARGS__
249 #define JSON_BUILD_NULL _JSON_BUILD_NULL
250 #define JSON_BUILD_VARIANT(v) _JSON_BUILD_VARIANT, ({ JsonVariant *_x = v; _x; })
251 #define JSON_BUILD_VARIANT_ARRAY(v, n) _JSON_BUILD_VARIANT_ARRAY, ({ JsonVariant **_x = v; _x; }), ({ size_t _y = n; _y; })
252 #define JSON_BUILD_LITERAL(l) _JSON_BUILD_LITERAL, ({ const char *_x = l; _x; })
253 #define JSON_BUILD_STRV(l) _JSON_BUILD_STRV, ({ char **_x = l; _x; })
254 #define JSON_BUILD_BASE64(p, n) _JSON_BUILD_BASE64, ({ const void *_x = p; _x; }), ({ size_t _y = n; _y; })
255 #define JSON_BUILD_HEX(p, n) _JSON_BUILD_HEX, ({ const void *_x = p; _x; }), ({ size_t _y = n; _y; })
256 #define JSON_BUILD_ID128(id) _JSON_BUILD_ID128, ({ sd_id128_t _x = id; _x; })
257 #define JSON_BUILD_BYTE_ARRAY(v, n) _JSON_BUILD_BYTE_ARRAY, ({ const void *_x = v; _x; }), ({ size_t _y = n; _y; })
259 int json_build(JsonVariant
**ret
, ...);
260 int json_buildv(JsonVariant
**ret
, va_list ap
);
262 /* A bitmask of flags used by the dispatch logic. Note that this is a combined bit mask, that is generated from the bit
263 * mask originally passed into json_dispatch(), the individual bitmask associated with the static JsonDispatch callout
264 * entry, as well the bitmask specified for json_log() calls */
265 typedef enum JsonDispatchFlags
{
266 /* The following three may be set in JsonDispatch's .flags field or the json_dispatch() flags parameter */
267 JSON_PERMISSIVE
= 1 << 0, /* Shall parsing errors be considered fatal for this property? */
268 JSON_MANDATORY
= 1 << 1, /* Should existence of this property be mandatory? */
269 JSON_LOG
= 1 << 2, /* Should the parser log about errors? */
270 JSON_SAFE
= 1 << 3, /* Don't accept "unsafe" strings in json_dispatch_string() + json_dispatch_string() */
271 JSON_RELAX
= 1 << 4, /* Use relaxed user name checking in json_dispatch_user_group_name */
273 /* The following two may be passed into log_json() in addition to the three above */
274 JSON_DEBUG
= 1 << 4, /* Indicates that this log message is a debug message */
275 JSON_WARNING
= 1 << 5, /* Indicates that this log message is a warning message */
278 typedef int (*JsonDispatchCallback
)(const char *name
, JsonVariant
*variant
, JsonDispatchFlags flags
, void *userdata
);
280 typedef struct JsonDispatch
{
282 JsonVariantType type
;
283 JsonDispatchCallback callback
;
285 JsonDispatchFlags flags
;
288 int json_dispatch(JsonVariant
*v
, const JsonDispatch table
[], JsonDispatchCallback bad
, JsonDispatchFlags flags
, void *userdata
);
290 int json_dispatch_string(const char *name
, JsonVariant
*variant
, JsonDispatchFlags flags
, void *userdata
);
291 int json_dispatch_const_string(const char *name
, JsonVariant
*variant
, JsonDispatchFlags flags
, void *userdata
);
292 int json_dispatch_strv(const char *name
, JsonVariant
*variant
, JsonDispatchFlags flags
, void *userdata
);
293 int json_dispatch_boolean(const char *name
, JsonVariant
*variant
, JsonDispatchFlags flags
, void *userdata
);
294 int json_dispatch_tristate(const char *name
, JsonVariant
*variant
, JsonDispatchFlags flags
, void *userdata
);
295 int json_dispatch_variant(const char *name
, JsonVariant
*variant
, JsonDispatchFlags flags
, void *userdata
);
296 int json_dispatch_intmax(const char *name
, JsonVariant
*variant
, JsonDispatchFlags flags
, void *userdata
);
297 int json_dispatch_uintmax(const char *name
, JsonVariant
*variant
, JsonDispatchFlags flags
, void *userdata
);
298 int json_dispatch_uint32(const char *name
, JsonVariant
*variant
, JsonDispatchFlags flags
, void *userdata
);
299 int json_dispatch_int32(const char *name
, JsonVariant
*variant
, JsonDispatchFlags flags
, void *userdata
);
300 int json_dispatch_uid_gid(const char *name
, JsonVariant
*variant
, JsonDispatchFlags flags
, void *userdata
);
301 int json_dispatch_user_group_name(const char *name
, JsonVariant
*variant
, JsonDispatchFlags flags
, void *userdata
);
302 int json_dispatch_id128(const char *name
, JsonVariant
*variant
, JsonDispatchFlags flags
, void *userdata
);
303 int json_dispatch_unsupported(const char *name
, JsonVariant
*variant
, JsonDispatchFlags flags
, void *userdata
);
305 assert_cc(sizeof(uintmax_t) == sizeof(uint64_t));
306 #define json_dispatch_uint64 json_dispatch_uintmax
308 assert_cc(sizeof(intmax_t) == sizeof(int64_t));
309 #define json_dispatch_int64 json_dispatch_intmax
311 assert_cc(sizeof(uint32_t) == sizeof(unsigned));
312 #define json_dispatch_uint json_dispatch_uint32
314 assert_cc(sizeof(int32_t) == sizeof(int));
315 #define json_dispatch_int json_dispatch_int32
317 static inline int json_dispatch_level(JsonDispatchFlags flags
) {
319 /* Did the user request no logging? If so, then never log higher than LOG_DEBUG. Also, if this is marked as
320 * debug message, then also log at debug level. */
322 if (!(flags
& JSON_LOG
) ||
323 (flags
& JSON_DEBUG
))
326 /* Are we invoked in permissive mode, or is this explicitly marked as warning message? Then this should be
327 * printed at LOG_WARNING */
328 if (flags
& (JSON_PERMISSIVE
|JSON_WARNING
))
331 /* Otherwise it's an error. */
335 int json_log_internal(JsonVariant
*variant
, int level
, int error
, const char *file
, int line
, const char *func
, const char *format
, ...) _printf_(7, 8);
337 #define json_log(variant, flags, error, ...) \
339 int _level = json_dispatch_level(flags), _e = (error); \
340 (log_get_max_level() >= LOG_PRI(_level)) \
341 ? json_log_internal(variant, _level, _e, PROJECT_FILE, __LINE__, __func__, __VA_ARGS__) \
342 : -ERRNO_VALUE(_e); \
345 #define json_log_oom(variant, flags) \
346 json_log(variant, flags, SYNTHETIC_ERRNO(ENOMEM), "Out of memory.")
348 #define JSON_VARIANT_STRING_CONST(x) _JSON_VARIANT_STRING_CONST(UNIQ, (x))
350 #define _JSON_VARIANT_STRING_CONST(xq, x) \
352 _align_(2) static const char UNIQ_T(json_string_const, xq)[] = (x); \
353 assert((((uintptr_t) UNIQ_T(json_string_const, xq)) & 1) == 0); \
354 (JsonVariant*) ((uintptr_t) UNIQ_T(json_string_const, xq) + 1); \
357 int json_variant_unbase64(JsonVariant
*v
, void **ret
, size_t *ret_size
);
358 int json_variant_unhex(JsonVariant
*v
, void **ret
, size_t *ret_size
);
360 const char *json_variant_type_to_string(JsonVariantType t
);
361 JsonVariantType
json_variant_type_from_string(const char *s
);