]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/shared/json.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge pull request #12394 from poettering/oncalendar-tweak
[thirdparty/systemd.git] / src / shared / json.c
1 /* SPDX-License-Identifier: LGPL-2.1+ */
2
3 #include <errno.h>
4 #include <locale.h>
5 #include <math.h>
6 #include <stdarg.h>
7 #include <stdlib.h>
8 #include <string.h>
9 #include <sys/types.h>
10
11 #include "sd-messages.h"
12
13 #include "alloc-util.h"
14 #include "errno-util.h"
15 #include "fd-util.h"
16 #include "fileio.h"
17 #include "float.h"
18 #include "hexdecoct.h"
19 #include "json-internal.h"
20 #include "json.h"
21 #include "macro.h"
22 #include "memory-util.h"
23 #include "string-table.h"
24 #include "string-util.h"
25 #include "strv.h"
26 #include "terminal-util.h"
27 #include "utf8.h"
28
29 /* Refuse putting together variants with a larger depth than 4K by default (as a protection against overflowing stacks
30 * if code processes JSON objects recursively. Note that we store the depth in an uint16_t, hence make sure this
31 * remains under 2^16.
32 * The value was 16k, but it was discovered to be too high on llvm/x86-64. See also the issue #10738. */
33 #define DEPTH_MAX (4U*1024U)
34 assert_cc(DEPTH_MAX <= UINT16_MAX);
35
36 typedef struct JsonSource {
37 /* When we parse from a file or similar, encodes the filename, to indicate the source of a json variant */
38 size_t n_ref;
39 unsigned max_line;
40 unsigned max_column;
41 char name[];
42 } JsonSource;
43
44 /* On x86-64 this whole structure should have a size of 6 * 64 bit = 48 bytes */
45 struct JsonVariant {
46 union {
47 /* We either maintain a reference counter for this variant itself, or we are embedded into an
48 * array/object, in which case only that surrounding object is ref-counted. (If 'embedded' is false,
49 * see below.) */
50 size_t n_ref;
51
52 /* If this JsonVariant is part of an array/object, then this field points to the surrounding
53 * JSON_VARIANT_ARRAY/JSON_VARIANT_OBJECT object. (If 'embedded' is true, see below.) */
54 JsonVariant *parent;
55 };
56
57 /* If this was parsed from some file or buffer, this stores where from, as well as the source line/column */
58 JsonSource *source;
59 unsigned line, column;
60
61 JsonVariantType type:5;
62
63 /* A marker whether this variant is embedded into in array/object or not. If true, the 'parent' pointer above
64 * is valid. If false, the 'n_ref' field above is valid instead. */
65 bool is_embedded:1;
66
67 /* In some conditions (for example, if this object is part of an array of strings or objects), we don't store
68 * any data inline, but instead simply reference an external object and act as surrogate of it. In that case
69 * this bool is set, and the external object is referenced through the .reference field below. */
70 bool is_reference:1;
71
72 /* While comparing two arrays, we use this for marking what we already have seen */
73 bool is_marked:1;
74
75 /* The current 'depth' of the JsonVariant, i.e. how many levels of member variants this has */
76 uint16_t depth;
77
78 union {
79 /* For simple types we store the value in-line. */
80 JsonValue value;
81
82 /* For objects and arrays we store the number of elements immediately following */
83 size_t n_elements;
84
85 /* If is_reference as indicated above is set, this is where the reference object is actually stored. */
86 JsonVariant *reference;
87
88 /* Strings are placed immediately after the structure. Note that when this is a JsonVariant embedded
89 * into an array we might encode strings up to INLINE_STRING_LENGTH characters directly inside the
90 * element, while longer strings are stored as references. When this object is not embedded into an
91 * array, but stand-alone we allocate the right size for the whole structure, i.e. the array might be
92 * much larger than INLINE_STRING_LENGTH.
93 *
94 * Note that because we want to allocate arrays of the JsonVariant structure we specify [0] here,
95 * rather than the prettier []. If we wouldn't, then this char array would have undefined size, and so
96 * would the union and then the struct this is included in. And of structures with undefined size we
97 * can't allocate arrays (at least not easily). */
98 char string[0];
99 };
100 };
101
102 /* Inside string arrays we have a series of JasonVariant structures one after the other. In this case, strings longer
103 * than INLINE_STRING_MAX are stored as references, and all shorter ones inline. (This means — on x86-64 — strings up
104 * to 15 chars are stored within the array elements, and all others in separate allocations) */
105 #define INLINE_STRING_MAX (sizeof(JsonVariant) - offsetof(JsonVariant, string) - 1U)
106
107 /* Let's make sure this structure isn't increased in size accidentally. This check is only for our most relevant arch
108 * (x86-64). */
109 #ifdef __x86_64__
110 assert_cc(sizeof(JsonVariant) == 48U);
111 assert_cc(INLINE_STRING_MAX == 15U);
112 #endif
113
114 static JsonSource* json_source_new(const char *name) {
115 JsonSource *s;
116
117 assert(name);
118
119 s = malloc(offsetof(JsonSource, name) + strlen(name) + 1);
120 if (!s)
121 return NULL;
122
123 *s = (JsonSource) {
124 .n_ref = 1,
125 };
126 strcpy(s->name, name);
127
128 return s;
129 }
130
131 DEFINE_PRIVATE_TRIVIAL_REF_UNREF_FUNC(JsonSource, json_source, mfree);
132
133 static bool json_source_equal(JsonSource *a, JsonSource *b) {
134 if (a == b)
135 return true;
136
137 if (!a || !b)
138 return false;
139
140 return streq(a->name, b->name);
141 }
142
143 DEFINE_TRIVIAL_CLEANUP_FUNC(JsonSource*, json_source_unref);
144
145 /* There are four kind of JsonVariant* pointers:
146 *
147 * 1. NULL
148 * 2. A 'regular' one, i.e. pointing to malloc() memory
149 * 3. A 'magic' one, i.e. one of the special JSON_VARIANT_MAGIC_XYZ values, that encode a few very basic values directly in the pointer.
150 * 4. A 'const string' one, i.e. a pointer to a const string.
151 *
152 * The four kinds of pointers can be discerned like this:
153 *
154 * Detecting #1 is easy, just compare with NULL. Detecting #3 is similarly easy: all magic pointers are below
155 * _JSON_VARIANT_MAGIC_MAX (which is pretty low, within the first memory page, which is special on Linux and other
156 * OSes, as it is a faulting page). In order to discern #2 and #4 we check the lowest bit. If it's off it's #2,
157 * otherwise #4. This makes use of the fact that malloc() will return "maximum aligned" memory, which definitely
158 * means the pointer is even. This means we can use the uneven pointers to reference static strings, as long as we
159 * make sure that all static strings used like this are aligned to 2 (or higher), and that we mask the bit on
160 * access. The JSON_VARIANT_STRING_CONST() macro encodes strings as JsonVariant* pointers, with the bit set. */
161
162 static bool json_variant_is_magic(const JsonVariant *v) {
163 if (!v)
164 return false;
165
166 return v < _JSON_VARIANT_MAGIC_MAX;
167 }
168
169 static bool json_variant_is_const_string(const JsonVariant *v) {
170
171 if (v < _JSON_VARIANT_MAGIC_MAX)
172 return false;
173
174 /* A proper JsonVariant is aligned to whatever malloc() aligns things too, which is definitely not uneven. We
175 * hence use all uneven pointers as indicators for const strings. */
176
177 return (((uintptr_t) v) & 1) != 0;
178 }
179
180 static bool json_variant_is_regular(const JsonVariant *v) {
181
182 if (v < _JSON_VARIANT_MAGIC_MAX)
183 return false;
184
185 return (((uintptr_t) v) & 1) == 0;
186 }
187
188 static JsonVariant *json_variant_dereference(JsonVariant *v) {
189
190 /* Recursively dereference variants that are references to other variants */
191
192 if (!v)
193 return NULL;
194
195 if (!json_variant_is_regular(v))
196 return v;
197
198 if (!v->is_reference)
199 return v;
200
201 return json_variant_dereference(v->reference);
202 }
203
204 static uint16_t json_variant_depth(JsonVariant *v) {
205
206 v = json_variant_dereference(v);
207 if (!v)
208 return 0;
209
210 if (!json_variant_is_regular(v))
211 return 0;
212
213 return v->depth;
214 }
215
216 static JsonVariant *json_variant_normalize(JsonVariant *v) {
217
218 /* Converts json variants to their normalized form, i.e. fully dereferenced and wherever possible converted to
219 * the "magic" version if there is one */
220
221 if (!v)
222 return NULL;
223
224 v = json_variant_dereference(v);
225
226 switch (json_variant_type(v)) {
227
228 case JSON_VARIANT_BOOLEAN:
229 return json_variant_boolean(v) ? JSON_VARIANT_MAGIC_TRUE : JSON_VARIANT_MAGIC_FALSE;
230
231 case JSON_VARIANT_NULL:
232 return JSON_VARIANT_MAGIC_NULL;
233
234 case JSON_VARIANT_INTEGER:
235 return json_variant_integer(v) == 0 ? JSON_VARIANT_MAGIC_ZERO_INTEGER : v;
236
237 case JSON_VARIANT_UNSIGNED:
238 return json_variant_unsigned(v) == 0 ? JSON_VARIANT_MAGIC_ZERO_UNSIGNED : v;
239
240 case JSON_VARIANT_REAL:
241 #pragma GCC diagnostic push
242 #pragma GCC diagnostic ignored "-Wfloat-equal"
243 return json_variant_real(v) == 0.0 ? JSON_VARIANT_MAGIC_ZERO_REAL : v;
244 #pragma GCC diagnostic pop
245
246 case JSON_VARIANT_STRING:
247 return isempty(json_variant_string(v)) ? JSON_VARIANT_MAGIC_EMPTY_STRING : v;
248
249 case JSON_VARIANT_ARRAY:
250 return json_variant_elements(v) == 0 ? JSON_VARIANT_MAGIC_EMPTY_ARRAY : v;
251
252 case JSON_VARIANT_OBJECT:
253 return json_variant_elements(v) == 0 ? JSON_VARIANT_MAGIC_EMPTY_OBJECT : v;
254
255 default:
256 return v;
257 }
258 }
259
260 static JsonVariant *json_variant_conservative_normalize(JsonVariant *v) {
261
262 /* Much like json_variant_normalize(), but won't simplify if the variant has a source/line location attached to
263 * it, in order not to lose context */
264
265 if (!v)
266 return NULL;
267
268 if (!json_variant_is_regular(v))
269 return v;
270
271 if (v->source || v->line > 0 || v->column > 0)
272 return v;
273
274 return json_variant_normalize(v);
275 }
276
277 static int json_variant_new(JsonVariant **ret, JsonVariantType type, size_t space) {
278 JsonVariant *v;
279
280 assert_return(ret, -EINVAL);
281
282 v = malloc0(offsetof(JsonVariant, value) + space);
283 if (!v)
284 return -ENOMEM;
285
286 v->n_ref = 1;
287 v->type = type;
288
289 *ret = v;
290 return 0;
291 }
292
293 int json_variant_new_integer(JsonVariant **ret, intmax_t i) {
294 JsonVariant *v;
295 int r;
296
297 assert_return(ret, -EINVAL);
298
299 if (i == 0) {
300 *ret = JSON_VARIANT_MAGIC_ZERO_INTEGER;
301 return 0;
302 }
303
304 r = json_variant_new(&v, JSON_VARIANT_INTEGER, sizeof(i));
305 if (r < 0)
306 return r;
307
308 v->value.integer = i;
309 *ret = v;
310
311 return 0;
312 }
313
314 int json_variant_new_unsigned(JsonVariant **ret, uintmax_t u) {
315 JsonVariant *v;
316 int r;
317
318 assert_return(ret, -EINVAL);
319 if (u == 0) {
320 *ret = JSON_VARIANT_MAGIC_ZERO_UNSIGNED;
321 return 0;
322 }
323
324 r = json_variant_new(&v, JSON_VARIANT_UNSIGNED, sizeof(u));
325 if (r < 0)
326 return r;
327
328 v->value.unsig = u;
329 *ret = v;
330
331 return 0;
332 }
333
334 int json_variant_new_real(JsonVariant **ret, long double d) {
335 JsonVariant *v;
336 int r;
337
338 assert_return(ret, -EINVAL);
339
340 #pragma GCC diagnostic push
341 #pragma GCC diagnostic ignored "-Wfloat-equal"
342 if (d == 0.0) {
343 #pragma GCC diagnostic pop
344 *ret = JSON_VARIANT_MAGIC_ZERO_REAL;
345 return 0;
346 }
347
348 r = json_variant_new(&v, JSON_VARIANT_REAL, sizeof(d));
349 if (r < 0)
350 return r;
351
352 v->value.real = d;
353 *ret = v;
354
355 return 0;
356 }
357
358 int json_variant_new_boolean(JsonVariant **ret, bool b) {
359 assert_return(ret, -EINVAL);
360
361 if (b)
362 *ret = JSON_VARIANT_MAGIC_TRUE;
363 else
364 *ret = JSON_VARIANT_MAGIC_FALSE;
365
366 return 0;
367 }
368
369 int json_variant_new_null(JsonVariant **ret) {
370 assert_return(ret, -EINVAL);
371
372 *ret = JSON_VARIANT_MAGIC_NULL;
373 return 0;
374 }
375
376 int json_variant_new_stringn(JsonVariant **ret, const char *s, size_t n) {
377 JsonVariant *v;
378 int r;
379
380 assert_return(ret, -EINVAL);
381 if (!s) {
382 assert_return(IN_SET(n, 0, (size_t) -1), -EINVAL);
383 return json_variant_new_null(ret);
384 }
385 if (n == (size_t) -1) /* determine length automatically */
386 n = strlen(s);
387 else if (memchr(s, 0, n)) /* don't allow embedded NUL, as we can't express that in JSON */
388 return -EINVAL;
389 if (n == 0) {
390 *ret = JSON_VARIANT_MAGIC_EMPTY_STRING;
391 return 0;
392 }
393
394 r = json_variant_new(&v, JSON_VARIANT_STRING, n + 1);
395 if (r < 0)
396 return r;
397
398 memcpy(v->string, s, n);
399 v->string[n] = 0;
400
401 *ret = v;
402 return 0;
403 }
404
405 static void json_variant_set(JsonVariant *a, JsonVariant *b) {
406 assert(a);
407
408 b = json_variant_dereference(b);
409 if (!b) {
410 a->type = JSON_VARIANT_NULL;
411 return;
412 }
413
414 a->type = json_variant_type(b);
415 switch (a->type) {
416
417 case JSON_VARIANT_INTEGER:
418 a->value.integer = json_variant_integer(b);
419 break;
420
421 case JSON_VARIANT_UNSIGNED:
422 a->value.unsig = json_variant_unsigned(b);
423 break;
424
425 case JSON_VARIANT_REAL:
426 a->value.real = json_variant_real(b);
427 break;
428
429 case JSON_VARIANT_BOOLEAN:
430 a->value.boolean = json_variant_boolean(b);
431 break;
432
433 case JSON_VARIANT_STRING: {
434 const char *s;
435
436 assert_se(s = json_variant_string(b));
437
438 /* Short strings we can store inline */
439 if (strnlen(s, INLINE_STRING_MAX+1) <= INLINE_STRING_MAX) {
440 strcpy(a->string, s);
441 break;
442 }
443
444 /* For longer strings, use a reference… */
445 _fallthrough_;
446 }
447
448 case JSON_VARIANT_ARRAY:
449 case JSON_VARIANT_OBJECT:
450 a->is_reference = true;
451 a->reference = json_variant_ref(json_variant_conservative_normalize(b));
452 break;
453
454 case JSON_VARIANT_NULL:
455 break;
456
457 default:
458 assert_not_reached("Unexpected variant type");
459 }
460 }
461
462 static void json_variant_copy_source(JsonVariant *v, JsonVariant *from) {
463 assert(v);
464 assert(from);
465
466 if (!json_variant_is_regular(from))
467 return;
468
469 v->line = from->line;
470 v->column = from->column;
471 v->source = json_source_ref(from->source);
472 }
473
474 int json_variant_new_array(JsonVariant **ret, JsonVariant **array, size_t n) {
475 _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
476
477 assert_return(ret, -EINVAL);
478 if (n == 0) {
479 *ret = JSON_VARIANT_MAGIC_EMPTY_ARRAY;
480 return 0;
481 }
482 assert_return(array, -EINVAL);
483
484 v = new(JsonVariant, n + 1);
485 if (!v)
486 return -ENOMEM;
487
488 *v = (JsonVariant) {
489 .n_ref = 1,
490 .type = JSON_VARIANT_ARRAY,
491 };
492
493 for (v->n_elements = 0; v->n_elements < n; v->n_elements++) {
494 JsonVariant *w = v + 1 + v->n_elements,
495 *c = array[v->n_elements];
496 uint16_t d;
497
498 d = json_variant_depth(c);
499 if (d >= DEPTH_MAX) /* Refuse too deep nesting */
500 return -ELNRNG;
501 if (d >= v->depth)
502 v->depth = d + 1;
503
504 *w = (JsonVariant) {
505 .is_embedded = true,
506 .parent = v,
507 };
508
509 json_variant_set(w, c);
510 json_variant_copy_source(w, c);
511 }
512
513 *ret = TAKE_PTR(v);
514 return 0;
515 }
516
517 int json_variant_new_array_bytes(JsonVariant **ret, const void *p, size_t n) {
518 JsonVariant *v;
519 size_t i;
520
521 assert_return(ret, -EINVAL);
522 if (n == 0) {
523 *ret = JSON_VARIANT_MAGIC_EMPTY_ARRAY;
524 return 0;
525 }
526 assert_return(p, -EINVAL);
527
528 v = new(JsonVariant, n + 1);
529 if (!v)
530 return -ENOMEM;
531
532 *v = (JsonVariant) {
533 .n_ref = 1,
534 .type = JSON_VARIANT_ARRAY,
535 .n_elements = n,
536 .depth = 1,
537 };
538
539 for (i = 0; i < n; i++) {
540 JsonVariant *w = v + 1 + i;
541
542 *w = (JsonVariant) {
543 .is_embedded = true,
544 .parent = v,
545 .type = JSON_VARIANT_UNSIGNED,
546 .value.unsig = ((const uint8_t*) p)[i],
547 };
548 }
549
550 *ret = v;
551 return 0;
552 }
553
554 int json_variant_new_array_strv(JsonVariant **ret, char **l) {
555 _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
556 size_t n;
557 int r;
558
559 assert(ret);
560
561 n = strv_length(l);
562 if (n == 0) {
563 *ret = JSON_VARIANT_MAGIC_EMPTY_ARRAY;
564 return 0;
565 }
566
567 v = new(JsonVariant, n + 1);
568 if (!v)
569 return -ENOMEM;
570
571 *v = (JsonVariant) {
572 .n_ref = 1,
573 .type = JSON_VARIANT_ARRAY,
574 .depth = 1,
575 };
576
577 for (v->n_elements = 0; v->n_elements < n; v->n_elements++) {
578 JsonVariant *w = v + 1 + v->n_elements;
579 size_t k;
580
581 *w = (JsonVariant) {
582 .is_embedded = true,
583 .parent = v,
584 .type = JSON_VARIANT_STRING,
585 };
586
587 k = strlen(l[v->n_elements]);
588
589 if (k > INLINE_STRING_MAX) {
590 /* If string is too long, store it as reference. */
591
592 r = json_variant_new_string(&w->reference, l[v->n_elements]);
593 if (r < 0)
594 return r;
595
596 w->is_reference = true;
597 } else
598 memcpy(w->string, l[v->n_elements], k+1);
599 }
600
601 *ret = TAKE_PTR(v);
602 return 0;
603 }
604
605 int json_variant_new_object(JsonVariant **ret, JsonVariant **array, size_t n) {
606 _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
607
608 assert_return(ret, -EINVAL);
609 if (n == 0) {
610 *ret = JSON_VARIANT_MAGIC_EMPTY_OBJECT;
611 return 0;
612 }
613 assert_return(array, -EINVAL);
614 assert_return(n % 2 == 0, -EINVAL);
615
616 v = new(JsonVariant, n + 1);
617 if (!v)
618 return -ENOMEM;
619
620 *v = (JsonVariant) {
621 .n_ref = 1,
622 .type = JSON_VARIANT_OBJECT,
623 };
624
625 for (v->n_elements = 0; v->n_elements < n; v->n_elements++) {
626 JsonVariant *w = v + 1 + v->n_elements,
627 *c = array[v->n_elements];
628 uint16_t d;
629
630 if ((v->n_elements & 1) == 0 &&
631 !json_variant_is_string(c))
632 return -EINVAL; /* Every second one needs to be a string, as it is the key name */
633
634 d = json_variant_depth(c);
635 if (d >= DEPTH_MAX) /* Refuse too deep nesting */
636 return -ELNRNG;
637 if (d >= v->depth)
638 v->depth = d + 1;
639
640 *w = (JsonVariant) {
641 .is_embedded = true,
642 .parent = v,
643 };
644
645 json_variant_set(w, c);
646 json_variant_copy_source(w, c);
647 }
648
649 *ret = TAKE_PTR(v);
650 return 0;
651 }
652
653 static void json_variant_free_inner(JsonVariant *v) {
654 assert(v);
655
656 if (!json_variant_is_regular(v))
657 return;
658
659 json_source_unref(v->source);
660
661 if (v->is_reference) {
662 json_variant_unref(v->reference);
663 return;
664 }
665
666 if (IN_SET(v->type, JSON_VARIANT_ARRAY, JSON_VARIANT_OBJECT)) {
667 size_t i;
668
669 for (i = 0; i < v->n_elements; i++)
670 json_variant_free_inner(v + 1 + i);
671 }
672 }
673
674 JsonVariant *json_variant_ref(JsonVariant *v) {
675 if (!v)
676 return NULL;
677 if (!json_variant_is_regular(v))
678 return v;
679
680 if (v->is_embedded)
681 json_variant_ref(v->parent); /* ref the compounding variant instead */
682 else {
683 assert(v->n_ref > 0);
684 v->n_ref++;
685 }
686
687 return v;
688 }
689
690 JsonVariant *json_variant_unref(JsonVariant *v) {
691 if (!v)
692 return NULL;
693 if (!json_variant_is_regular(v))
694 return NULL;
695
696 if (v->is_embedded)
697 json_variant_unref(v->parent);
698 else {
699 assert(v->n_ref > 0);
700 v->n_ref--;
701
702 if (v->n_ref == 0) {
703 json_variant_free_inner(v);
704 free(v);
705 }
706 }
707
708 return NULL;
709 }
710
711 void json_variant_unref_many(JsonVariant **array, size_t n) {
712 size_t i;
713
714 assert(array || n == 0);
715
716 for (i = 0; i < n; i++)
717 json_variant_unref(array[i]);
718 }
719
720 const char *json_variant_string(JsonVariant *v) {
721 if (!v)
722 return NULL;
723 if (v == JSON_VARIANT_MAGIC_EMPTY_STRING)
724 return "";
725 if (json_variant_is_magic(v))
726 goto mismatch;
727 if (json_variant_is_const_string(v)) {
728 uintptr_t p = (uintptr_t) v;
729
730 assert((p & 1) != 0);
731 return (const char*) (p ^ 1U);
732 }
733
734 if (v->is_reference)
735 return json_variant_string(v->reference);
736 if (v->type != JSON_VARIANT_STRING)
737 goto mismatch;
738
739 return v->string;
740
741 mismatch:
742 log_debug("Non-string JSON variant requested as string, returning NULL.");
743 return NULL;
744 }
745
746 bool json_variant_boolean(JsonVariant *v) {
747 if (!v)
748 goto mismatch;
749 if (v == JSON_VARIANT_MAGIC_TRUE)
750 return true;
751 if (v == JSON_VARIANT_MAGIC_FALSE)
752 return false;
753 if (!json_variant_is_regular(v))
754 goto mismatch;
755 if (v->type != JSON_VARIANT_BOOLEAN)
756 goto mismatch;
757 if (v->is_reference)
758 return json_variant_boolean(v->reference);
759
760 return v->value.boolean;
761
762 mismatch:
763 log_debug("Non-boolean JSON variant requested as boolean, returning false.");
764 return false;
765 }
766
767 intmax_t json_variant_integer(JsonVariant *v) {
768 if (!v)
769 goto mismatch;
770 if (v == JSON_VARIANT_MAGIC_ZERO_INTEGER ||
771 v == JSON_VARIANT_MAGIC_ZERO_UNSIGNED ||
772 v == JSON_VARIANT_MAGIC_ZERO_REAL)
773 return 0;
774 if (!json_variant_is_regular(v))
775 goto mismatch;
776 if (v->is_reference)
777 return json_variant_integer(v->reference);
778
779 switch (v->type) {
780
781 case JSON_VARIANT_INTEGER:
782 return v->value.integer;
783
784 case JSON_VARIANT_UNSIGNED:
785 if (v->value.unsig <= INTMAX_MAX)
786 return (intmax_t) v->value.unsig;
787
788 log_debug("Unsigned integer %ju requested as signed integer and out of range, returning 0.", v->value.unsig);
789 return 0;
790
791 case JSON_VARIANT_REAL: {
792 intmax_t converted;
793
794 converted = (intmax_t) v->value.real;
795
796 #pragma GCC diagnostic push
797 #pragma GCC diagnostic ignored "-Wfloat-equal"
798 if ((long double) converted == v->value.real)
799 #pragma GCC diagnostic pop
800 return converted;
801
802 log_debug("Real %Lg requested as integer, and cannot be converted losslessly, returning 0.", v->value.real);
803 return 0;
804 }
805
806 default:
807 break;
808 }
809
810 mismatch:
811 log_debug("Non-integer JSON variant requested as integer, returning 0.");
812 return 0;
813 }
814
815 uintmax_t json_variant_unsigned(JsonVariant *v) {
816 if (!v)
817 goto mismatch;
818 if (v == JSON_VARIANT_MAGIC_ZERO_INTEGER ||
819 v == JSON_VARIANT_MAGIC_ZERO_UNSIGNED ||
820 v == JSON_VARIANT_MAGIC_ZERO_REAL)
821 return 0;
822 if (!json_variant_is_regular(v))
823 goto mismatch;
824 if (v->is_reference)
825 return json_variant_integer(v->reference);
826
827 switch (v->type) {
828
829 case JSON_VARIANT_INTEGER:
830 if (v->value.integer >= 0)
831 return (uintmax_t) v->value.integer;
832
833 log_debug("Signed integer %ju requested as unsigned integer and out of range, returning 0.", v->value.integer);
834 return 0;
835
836 case JSON_VARIANT_UNSIGNED:
837 return v->value.unsig;
838
839 case JSON_VARIANT_REAL: {
840 uintmax_t converted;
841
842 converted = (uintmax_t) v->value.real;
843
844 #pragma GCC diagnostic push
845 #pragma GCC diagnostic ignored "-Wfloat-equal"
846 if ((long double) converted == v->value.real)
847 #pragma GCC diagnostic pop
848 return converted;
849
850 log_debug("Real %Lg requested as unsigned integer, and cannot be converted losslessly, returning 0.", v->value.real);
851 return 0;
852 }
853
854 default:
855 break;
856 }
857
858 mismatch:
859 log_debug("Non-integer JSON variant requested as unsigned, returning 0.");
860 return 0;
861 }
862
863 long double json_variant_real(JsonVariant *v) {
864 if (!v)
865 return 0.0;
866 if (v == JSON_VARIANT_MAGIC_ZERO_INTEGER ||
867 v == JSON_VARIANT_MAGIC_ZERO_UNSIGNED ||
868 v == JSON_VARIANT_MAGIC_ZERO_REAL)
869 return 0.0;
870 if (!json_variant_is_regular(v))
871 goto mismatch;
872 if (v->is_reference)
873 return json_variant_real(v->reference);
874
875 switch (v->type) {
876
877 case JSON_VARIANT_REAL:
878 return v->value.real;
879
880 case JSON_VARIANT_INTEGER: {
881 long double converted;
882
883 converted = (long double) v->value.integer;
884
885 if ((intmax_t) converted == v->value.integer)
886 return converted;
887
888 log_debug("Signed integer %ji requested as real, and cannot be converted losslessly, returning 0.", v->value.integer);
889 return 0.0;
890 }
891
892 case JSON_VARIANT_UNSIGNED: {
893 long double converted;
894
895 converted = (long double) v->value.unsig;
896
897 if ((uintmax_t) converted == v->value.unsig)
898 return converted;
899
900 log_debug("Unsigned integer %ju requested as real, and cannot be converted losslessly, returning 0.", v->value.unsig);
901 return 0.0;
902 }
903
904 default:
905 break;
906 }
907
908 mismatch:
909 log_debug("Non-integer JSON variant requested as integer, returning 0.");
910 return 0.0;
911 }
912
913 bool json_variant_is_negative(JsonVariant *v) {
914 if (!v)
915 goto mismatch;
916 if (v == JSON_VARIANT_MAGIC_ZERO_INTEGER ||
917 v == JSON_VARIANT_MAGIC_ZERO_UNSIGNED ||
918 v == JSON_VARIANT_MAGIC_ZERO_REAL)
919 return false;
920 if (!json_variant_is_regular(v))
921 goto mismatch;
922 if (v->is_reference)
923 return json_variant_is_negative(v->reference);
924
925 /* This function is useful as checking whether numbers are negative is pretty complex since we have three types
926 * of numbers. And some JSON code (OCI for example) uses negative numbers to mark "not defined" numeric
927 * values. */
928
929 switch (v->type) {
930
931 case JSON_VARIANT_REAL:
932 return v->value.real < 0;
933
934 case JSON_VARIANT_INTEGER:
935 return v->value.integer < 0;
936
937 case JSON_VARIANT_UNSIGNED:
938 return false;
939
940 default:
941 break;
942 }
943
944 mismatch:
945 log_debug("Non-integer JSON variant tested for negativity, returning false.");
946 return false;
947 }
948
949 JsonVariantType json_variant_type(JsonVariant *v) {
950
951 if (!v)
952 return _JSON_VARIANT_TYPE_INVALID;
953
954 if (json_variant_is_const_string(v))
955 return JSON_VARIANT_STRING;
956
957 if (v == JSON_VARIANT_MAGIC_TRUE || v == JSON_VARIANT_MAGIC_FALSE)
958 return JSON_VARIANT_BOOLEAN;
959
960 if (v == JSON_VARIANT_MAGIC_NULL)
961 return JSON_VARIANT_NULL;
962
963 if (v == JSON_VARIANT_MAGIC_ZERO_INTEGER)
964 return JSON_VARIANT_INTEGER;
965
966 if (v == JSON_VARIANT_MAGIC_ZERO_UNSIGNED)
967 return JSON_VARIANT_UNSIGNED;
968
969 if (v == JSON_VARIANT_MAGIC_ZERO_REAL)
970 return JSON_VARIANT_REAL;
971
972 if (v == JSON_VARIANT_MAGIC_EMPTY_STRING)
973 return JSON_VARIANT_STRING;
974
975 if (v == JSON_VARIANT_MAGIC_EMPTY_ARRAY)
976 return JSON_VARIANT_ARRAY;
977
978 if (v == JSON_VARIANT_MAGIC_EMPTY_OBJECT)
979 return JSON_VARIANT_OBJECT;
980
981 return v->type;
982 }
983
984 bool json_variant_has_type(JsonVariant *v, JsonVariantType type) {
985 JsonVariantType rt;
986
987 v = json_variant_dereference(v);
988 if (!v)
989 return false;
990
991 rt = json_variant_type(v);
992 if (rt == type)
993 return true;
994
995 /* If it's a const string, then it only can be a string, and if it is not, it's not */
996 if (json_variant_is_const_string(v))
997 return false;
998
999 /* All three magic zeroes qualify as integer, unsigned and as real */
1000 if ((v == JSON_VARIANT_MAGIC_ZERO_INTEGER || v == JSON_VARIANT_MAGIC_ZERO_UNSIGNED || v == JSON_VARIANT_MAGIC_ZERO_REAL) &&
1001 IN_SET(type, JSON_VARIANT_INTEGER, JSON_VARIANT_UNSIGNED, JSON_VARIANT_REAL, JSON_VARIANT_NUMBER))
1002 return true;
1003
1004 /* All other magic variant types are only equal to themselves */
1005 if (json_variant_is_magic(v))
1006 return false;
1007
1008 /* Handle the "number" pseudo type */
1009 if (type == JSON_VARIANT_NUMBER)
1010 return IN_SET(rt, JSON_VARIANT_INTEGER, JSON_VARIANT_UNSIGNED, JSON_VARIANT_REAL);
1011
1012 /* Integer conversions are OK in many cases */
1013 if (rt == JSON_VARIANT_INTEGER && type == JSON_VARIANT_UNSIGNED)
1014 return v->value.integer >= 0;
1015 if (rt == JSON_VARIANT_UNSIGNED && type == JSON_VARIANT_INTEGER)
1016 return v->value.unsig <= INTMAX_MAX;
1017
1018 /* Any integer that can be converted lossley to a real and back may also be considered a real */
1019 if (rt == JSON_VARIANT_INTEGER && type == JSON_VARIANT_REAL)
1020 return (intmax_t) (long double) v->value.integer == v->value.integer;
1021 if (rt == JSON_VARIANT_UNSIGNED && type == JSON_VARIANT_REAL)
1022 return (uintmax_t) (long double) v->value.unsig == v->value.unsig;
1023
1024 #pragma GCC diagnostic push
1025 #pragma GCC diagnostic ignored "-Wfloat-equal"
1026 /* Any real that can be converted losslessly to an integer and back may also be considered an integer */
1027 if (rt == JSON_VARIANT_REAL && type == JSON_VARIANT_INTEGER)
1028 return (long double) (intmax_t) v->value.real == v->value.real;
1029 if (rt == JSON_VARIANT_REAL && type == JSON_VARIANT_UNSIGNED)
1030 return (long double) (uintmax_t) v->value.real == v->value.real;
1031 #pragma GCC diagnostic pop
1032
1033 return false;
1034 }
1035
1036 size_t json_variant_elements(JsonVariant *v) {
1037 if (!v)
1038 return 0;
1039 if (v == JSON_VARIANT_MAGIC_EMPTY_ARRAY ||
1040 v == JSON_VARIANT_MAGIC_EMPTY_OBJECT)
1041 return 0;
1042 if (!json_variant_is_regular(v))
1043 goto mismatch;
1044 if (!IN_SET(v->type, JSON_VARIANT_ARRAY, JSON_VARIANT_OBJECT))
1045 goto mismatch;
1046 if (v->is_reference)
1047 return json_variant_elements(v->reference);
1048
1049 return v->n_elements;
1050
1051 mismatch:
1052 log_debug("Number of elements in non-array/non-object JSON variant requested, returning 0.");
1053 return 0;
1054 }
1055
1056 JsonVariant *json_variant_by_index(JsonVariant *v, size_t idx) {
1057 if (!v)
1058 return NULL;
1059 if (v == JSON_VARIANT_MAGIC_EMPTY_ARRAY ||
1060 v == JSON_VARIANT_MAGIC_EMPTY_OBJECT)
1061 return NULL;
1062 if (!json_variant_is_regular(v))
1063 goto mismatch;
1064 if (!IN_SET(v->type, JSON_VARIANT_ARRAY, JSON_VARIANT_OBJECT))
1065 goto mismatch;
1066 if (v->is_reference)
1067 return json_variant_by_index(v->reference, idx);
1068 if (idx >= v->n_elements)
1069 return NULL;
1070
1071 return json_variant_conservative_normalize(v + 1 + idx);
1072
1073 mismatch:
1074 log_debug("Element in non-array/non-object JSON variant requested by index, returning NULL.");
1075 return NULL;
1076 }
1077
1078 JsonVariant *json_variant_by_key_full(JsonVariant *v, const char *key, JsonVariant **ret_key) {
1079 size_t i;
1080
1081 if (!v)
1082 goto not_found;
1083 if (!key)
1084 goto not_found;
1085 if (v == JSON_VARIANT_MAGIC_EMPTY_OBJECT)
1086 goto not_found;
1087 if (!json_variant_is_regular(v))
1088 goto mismatch;
1089 if (v->type != JSON_VARIANT_OBJECT)
1090 goto mismatch;
1091 if (v->is_reference)
1092 return json_variant_by_key(v->reference, key);
1093
1094 for (i = 0; i < v->n_elements; i += 2) {
1095 JsonVariant *p;
1096
1097 p = json_variant_dereference(v + 1 + i);
1098
1099 if (!json_variant_has_type(p, JSON_VARIANT_STRING))
1100 continue;
1101
1102 if (streq(json_variant_string(p), key)) {
1103
1104 if (ret_key)
1105 *ret_key = json_variant_conservative_normalize(v + 1 + i);
1106
1107 return json_variant_conservative_normalize(v + 1 + i + 1);
1108 }
1109 }
1110
1111 not_found:
1112 if (ret_key)
1113 *ret_key = NULL;
1114
1115 return NULL;
1116
1117 mismatch:
1118 log_debug("Element in non-object JSON variant requested by key, returning NULL.");
1119 if (ret_key)
1120 *ret_key = NULL;
1121
1122 return NULL;
1123 }
1124
1125 JsonVariant *json_variant_by_key(JsonVariant *v, const char *key) {
1126 return json_variant_by_key_full(v, key, NULL);
1127 }
1128
1129 bool json_variant_equal(JsonVariant *a, JsonVariant *b) {
1130 JsonVariantType t;
1131
1132 a = json_variant_normalize(a);
1133 b = json_variant_normalize(b);
1134
1135 if (a == b)
1136 return true;
1137
1138 t = json_variant_type(a);
1139 if (!json_variant_has_type(b, t))
1140 return false;
1141
1142 switch (t) {
1143
1144 case JSON_VARIANT_STRING:
1145 return streq(json_variant_string(a), json_variant_string(b));
1146
1147 case JSON_VARIANT_INTEGER:
1148 return json_variant_integer(a) == json_variant_integer(b);
1149
1150 case JSON_VARIANT_UNSIGNED:
1151 return json_variant_unsigned(a) == json_variant_unsigned(b);
1152
1153 case JSON_VARIANT_REAL:
1154 #pragma GCC diagnostic push
1155 #pragma GCC diagnostic ignored "-Wfloat-equal"
1156 return json_variant_real(a) == json_variant_real(b);
1157 #pragma GCC diagnostic pop
1158
1159 case JSON_VARIANT_BOOLEAN:
1160 return json_variant_boolean(a) == json_variant_boolean(b);
1161
1162 case JSON_VARIANT_NULL:
1163 return true;
1164
1165 case JSON_VARIANT_ARRAY: {
1166 size_t i, n;
1167
1168 n = json_variant_elements(a);
1169 if (n != json_variant_elements(b))
1170 return false;
1171
1172 for (i = 0; i < n; i++) {
1173 if (!json_variant_equal(json_variant_by_index(a, i), json_variant_by_index(b, i)))
1174 return false;
1175 }
1176
1177 return true;
1178 }
1179
1180 case JSON_VARIANT_OBJECT: {
1181 size_t i, n;
1182
1183 n = json_variant_elements(a);
1184 if (n != json_variant_elements(b))
1185 return false;
1186
1187 /* Iterate through all keys in 'a' */
1188 for (i = 0; i < n; i += 2) {
1189 bool found = false;
1190 size_t j;
1191
1192 /* Match them against all keys in 'b' */
1193 for (j = 0; j < n; j += 2) {
1194 JsonVariant *key_b;
1195
1196 key_b = json_variant_by_index(b, j);
1197
1198 /* During the first iteration unmark everything */
1199 if (i == 0)
1200 key_b->is_marked = false;
1201 else if (key_b->is_marked) /* In later iterations if we already marked something, don't bother with it again */
1202 continue;
1203
1204 if (found)
1205 continue;
1206
1207 if (json_variant_equal(json_variant_by_index(a, i), key_b) &&
1208 json_variant_equal(json_variant_by_index(a, i+1), json_variant_by_index(b, j+1))) {
1209 /* Key and values match! */
1210 key_b->is_marked = found = true;
1211
1212 /* In the first iteration we continue the inner loop since we want to mark
1213 * everything, otherwise exit the loop quickly after we found what we were
1214 * looking for. */
1215 if (i != 0)
1216 break;
1217 }
1218 }
1219
1220 if (!found)
1221 return false;
1222 }
1223
1224 return true;
1225 }
1226
1227 default:
1228 assert_not_reached("Unknown variant type.");
1229 }
1230 }
1231
1232 int json_variant_get_source(JsonVariant *v, const char **ret_source, unsigned *ret_line, unsigned *ret_column) {
1233 assert_return(v, -EINVAL);
1234
1235 if (ret_source)
1236 *ret_source = json_variant_is_regular(v) && v->source ? v->source->name : NULL;
1237
1238 if (ret_line)
1239 *ret_line = json_variant_is_regular(v) ? v->line : 0;
1240
1241 if (ret_column)
1242 *ret_column = json_variant_is_regular(v) ? v->column : 0;
1243
1244 return 0;
1245 }
1246
1247 static int print_source(FILE *f, JsonVariant *v, JsonFormatFlags flags, bool whitespace) {
1248 size_t w, k;
1249
1250 if (!FLAGS_SET(flags, JSON_FORMAT_SOURCE|JSON_FORMAT_PRETTY))
1251 return 0;
1252
1253 if (!json_variant_is_regular(v))
1254 return 0;
1255
1256 if (!v->source && v->line == 0 && v->column == 0)
1257 return 0;
1258
1259 /* The max width we need to format the line numbers for this source file */
1260 w = (v->source && v->source->max_line > 0) ?
1261 DECIMAL_STR_WIDTH(v->source->max_line) :
1262 DECIMAL_STR_MAX(unsigned)-1;
1263 k = (v->source && v->source->max_column > 0) ?
1264 DECIMAL_STR_WIDTH(v->source->max_column) :
1265 DECIMAL_STR_MAX(unsigned) -1;
1266
1267 if (whitespace) {
1268 size_t i, n;
1269
1270 n = 1 + (v->source ? strlen(v->source->name) : 0) +
1271 ((v->source && (v->line > 0 || v->column > 0)) ? 1 : 0) +
1272 (v->line > 0 ? w : 0) +
1273 (((v->source || v->line > 0) && v->column > 0) ? 1 : 0) +
1274 (v->column > 0 ? k : 0) +
1275 2;
1276
1277 for (i = 0; i < n; i++)
1278 fputc(' ', f);
1279 } else {
1280 fputc('[', f);
1281
1282 if (v->source)
1283 fputs(v->source->name, f);
1284 if (v->source && (v->line > 0 || v->column > 0))
1285 fputc(':', f);
1286 if (v->line > 0)
1287 fprintf(f, "%*u", (int) w, v->line);
1288 if ((v->source || v->line > 0) || v->column > 0)
1289 fputc(':', f);
1290 if (v->column > 0)
1291 fprintf(f, "%*u", (int) k, v->column);
1292
1293 fputc(']', f);
1294 fputc(' ', f);
1295 }
1296
1297 return 0;
1298 }
1299
1300 static int json_format(FILE *f, JsonVariant *v, JsonFormatFlags flags, const char *prefix) {
1301 int r;
1302
1303 assert(f);
1304 assert(v);
1305
1306 switch (json_variant_type(v)) {
1307
1308 case JSON_VARIANT_REAL: {
1309 locale_t loc;
1310
1311 loc = newlocale(LC_NUMERIC_MASK, "C", (locale_t) 0);
1312 if (loc == (locale_t) 0)
1313 return -errno;
1314
1315 if (flags & JSON_FORMAT_COLOR)
1316 fputs(ANSI_HIGHLIGHT_BLUE, f);
1317
1318 fprintf(f, "%.*Le", DECIMAL_DIG, json_variant_real(v));
1319
1320 if (flags & JSON_FORMAT_COLOR)
1321 fputs(ANSI_NORMAL, f);
1322
1323 freelocale(loc);
1324 break;
1325 }
1326
1327 case JSON_VARIANT_INTEGER:
1328 if (flags & JSON_FORMAT_COLOR)
1329 fputs(ANSI_HIGHLIGHT_BLUE, f);
1330
1331 fprintf(f, "%" PRIdMAX, json_variant_integer(v));
1332
1333 if (flags & JSON_FORMAT_COLOR)
1334 fputs(ANSI_NORMAL, f);
1335 break;
1336
1337 case JSON_VARIANT_UNSIGNED:
1338 if (flags & JSON_FORMAT_COLOR)
1339 fputs(ANSI_HIGHLIGHT_BLUE, f);
1340
1341 fprintf(f, "%" PRIuMAX, json_variant_unsigned(v));
1342
1343 if (flags & JSON_FORMAT_COLOR)
1344 fputs(ANSI_NORMAL, f);
1345 break;
1346
1347 case JSON_VARIANT_BOOLEAN:
1348
1349 if (flags & JSON_FORMAT_COLOR)
1350 fputs(ANSI_HIGHLIGHT, f);
1351
1352 if (json_variant_boolean(v))
1353 fputs("true", f);
1354 else
1355 fputs("false", f);
1356
1357 if (flags & JSON_FORMAT_COLOR)
1358 fputs(ANSI_NORMAL, f);
1359
1360 break;
1361
1362 case JSON_VARIANT_NULL:
1363 if (flags & JSON_FORMAT_COLOR)
1364 fputs(ANSI_HIGHLIGHT, f);
1365
1366 fputs("null", f);
1367
1368 if (flags & JSON_FORMAT_COLOR)
1369 fputs(ANSI_NORMAL, f);
1370 break;
1371
1372 case JSON_VARIANT_STRING: {
1373 const char *q;
1374
1375 fputc('"', f);
1376
1377 if (flags & JSON_FORMAT_COLOR)
1378 fputs(ANSI_GREEN, f);
1379
1380 for (q = json_variant_string(v); *q; q++) {
1381
1382 switch (*q) {
1383
1384 case '"':
1385 fputs("\\\"", f);
1386 break;
1387
1388 case '\\':
1389 fputs("\\\\", f);
1390 break;
1391
1392 case '\b':
1393 fputs("\\b", f);
1394 break;
1395
1396 case '\f':
1397 fputs("\\f", f);
1398 break;
1399
1400 case '\n':
1401 fputs("\\n", f);
1402 break;
1403
1404 case '\r':
1405 fputs("\\r", f);
1406 break;
1407
1408 case '\t':
1409 fputs("\\t", f);
1410 break;
1411
1412 default:
1413 if ((signed char) *q >= 0 && *q < ' ')
1414 fprintf(f, "\\u%04x", *q);
1415 else
1416 fputc(*q, f);
1417 break;
1418 }
1419 }
1420
1421 if (flags & JSON_FORMAT_COLOR)
1422 fputs(ANSI_NORMAL, f);
1423
1424 fputc('"', f);
1425 break;
1426 }
1427
1428 case JSON_VARIANT_ARRAY: {
1429 size_t i, n;
1430
1431 n = json_variant_elements(v);
1432
1433 if (n == 0)
1434 fputs("[]", f);
1435 else {
1436 _cleanup_free_ char *joined = NULL;
1437 const char *prefix2;
1438
1439 if (flags & JSON_FORMAT_PRETTY) {
1440 joined = strjoin(strempty(prefix), "\t");
1441 if (!joined)
1442 return -ENOMEM;
1443
1444 prefix2 = joined;
1445 fputs("[\n", f);
1446 } else {
1447 prefix2 = strempty(prefix);
1448 fputc('[', f);
1449 }
1450
1451 for (i = 0; i < n; i++) {
1452 JsonVariant *e;
1453
1454 assert_se(e = json_variant_by_index(v, i));
1455
1456 if (i > 0) {
1457 if (flags & JSON_FORMAT_PRETTY)
1458 fputs(",\n", f);
1459 else
1460 fputc(',', f);
1461 }
1462
1463 if (flags & JSON_FORMAT_PRETTY) {
1464 print_source(f, e, flags, false);
1465 fputs(prefix2, f);
1466 }
1467
1468 r = json_format(f, e, flags, prefix2);
1469 if (r < 0)
1470 return r;
1471 }
1472
1473 if (flags & JSON_FORMAT_PRETTY) {
1474 fputc('\n', f);
1475 print_source(f, v, flags, true);
1476 fputs(strempty(prefix), f);
1477 }
1478
1479 fputc(']', f);
1480 }
1481 break;
1482 }
1483
1484 case JSON_VARIANT_OBJECT: {
1485 size_t i, n;
1486
1487 n = json_variant_elements(v);
1488
1489 if (n == 0)
1490 fputs("{}", f);
1491 else {
1492 _cleanup_free_ char *joined = NULL;
1493 const char *prefix2;
1494
1495 if (flags & JSON_FORMAT_PRETTY) {
1496 joined = strjoin(strempty(prefix), "\t");
1497 if (!joined)
1498 return -ENOMEM;
1499
1500 prefix2 = joined;
1501 fputs("{\n", f);
1502 } else {
1503 prefix2 = strempty(prefix);
1504 fputc('{', f);
1505 }
1506
1507 for (i = 0; i < n; i += 2) {
1508 JsonVariant *e;
1509
1510 e = json_variant_by_index(v, i);
1511
1512 if (i > 0) {
1513 if (flags & JSON_FORMAT_PRETTY)
1514 fputs(",\n", f);
1515 else
1516 fputc(',', f);
1517 }
1518
1519 if (flags & JSON_FORMAT_PRETTY) {
1520 print_source(f, e, flags, false);
1521 fputs(prefix2, f);
1522 }
1523
1524 r = json_format(f, e, flags, prefix2);
1525 if (r < 0)
1526 return r;
1527
1528 fputs(flags & JSON_FORMAT_PRETTY ? " : " : ":", f);
1529
1530 r = json_format(f, json_variant_by_index(v, i+1), flags, prefix2);
1531 if (r < 0)
1532 return r;
1533 }
1534
1535 if (flags & JSON_FORMAT_PRETTY) {
1536 fputc('\n', f);
1537 print_source(f, v, flags, true);
1538 fputs(strempty(prefix), f);
1539 }
1540
1541 fputc('}', f);
1542 }
1543 break;
1544 }
1545
1546 default:
1547 assert_not_reached("Unexpected variant type.");
1548 }
1549
1550 return 0;
1551 }
1552
1553 int json_variant_format(JsonVariant *v, JsonFormatFlags flags, char **ret) {
1554 _cleanup_free_ char *s = NULL;
1555 size_t sz = 0;
1556 int r;
1557
1558 assert_return(v, -EINVAL);
1559 assert_return(ret, -EINVAL);
1560
1561 {
1562 _cleanup_fclose_ FILE *f = NULL;
1563
1564 f = open_memstream_unlocked(&s, &sz);
1565 if (!f)
1566 return -ENOMEM;
1567
1568 json_variant_dump(v, flags, f, NULL);
1569
1570 r = fflush_and_check(f);
1571 }
1572 if (r < 0)
1573 return r;
1574
1575 assert(s);
1576 *ret = TAKE_PTR(s);
1577
1578 return (int) sz;
1579 }
1580
1581 void json_variant_dump(JsonVariant *v, JsonFormatFlags flags, FILE *f, const char *prefix) {
1582 if (!v)
1583 return;
1584
1585 if (!f)
1586 f = stdout;
1587
1588 print_source(f, v, flags, false);
1589
1590 if (((flags & (JSON_FORMAT_COLOR_AUTO|JSON_FORMAT_COLOR)) == JSON_FORMAT_COLOR_AUTO) && colors_enabled())
1591 flags |= JSON_FORMAT_COLOR;
1592
1593 if (flags & JSON_FORMAT_SSE)
1594 fputs("data: ", f);
1595 if (flags & JSON_FORMAT_SEQ)
1596 fputc('\x1e', f); /* ASCII Record Separator */
1597
1598 json_format(f, v, flags, prefix);
1599
1600 if (flags & (JSON_FORMAT_PRETTY|JSON_FORMAT_SEQ|JSON_FORMAT_SSE|JSON_FORMAT_NEWLINE))
1601 fputc('\n', f);
1602 if (flags & JSON_FORMAT_SSE)
1603 fputc('\n', f); /* In case of SSE add a second newline */
1604 }
1605
1606 static int json_variant_copy(JsonVariant **nv, JsonVariant *v) {
1607 JsonVariantType t;
1608 JsonVariant *c;
1609 JsonValue value;
1610 const void *source;
1611 size_t k;
1612
1613 assert(nv);
1614 assert(v);
1615
1616 /* Let's copy the simple types literally, and the larger types by references */
1617 t = json_variant_type(v);
1618 switch (t) {
1619 case JSON_VARIANT_INTEGER:
1620 k = sizeof(intmax_t);
1621 value.integer = json_variant_integer(v);
1622 source = &value;
1623 break;
1624
1625 case JSON_VARIANT_UNSIGNED:
1626 k = sizeof(uintmax_t);
1627 value.unsig = json_variant_unsigned(v);
1628 source = &value;
1629 break;
1630
1631 case JSON_VARIANT_REAL:
1632 k = sizeof(long double);
1633 value.real = json_variant_real(v);
1634 source = &value;
1635 break;
1636
1637 case JSON_VARIANT_BOOLEAN:
1638 k = sizeof(bool);
1639 value.boolean = json_variant_boolean(v);
1640 source = &value;
1641 break;
1642
1643 case JSON_VARIANT_NULL:
1644 k = 0;
1645 source = NULL;
1646 break;
1647
1648 case JSON_VARIANT_STRING:
1649 source = json_variant_string(v);
1650 k = strnlen(source, INLINE_STRING_MAX + 1);
1651 if (k <= INLINE_STRING_MAX) {
1652 k ++;
1653 break;
1654 }
1655
1656 _fallthrough_;
1657
1658 default:
1659 /* Everything else copy by reference */
1660
1661 c = malloc0(offsetof(JsonVariant, reference) + sizeof(JsonVariant*));
1662 if (!c)
1663 return -ENOMEM;
1664
1665 c->n_ref = 1;
1666 c->type = t;
1667 c->is_reference = true;
1668 c->reference = json_variant_ref(json_variant_normalize(v));
1669
1670 *nv = c;
1671 return 0;
1672 }
1673
1674 c = malloc0(offsetof(JsonVariant, value) + k);
1675 if (!c)
1676 return -ENOMEM;
1677
1678 c->n_ref = 1;
1679 c->type = t;
1680
1681 memcpy_safe(&c->value, source, k);
1682
1683 *nv = c;
1684 return 0;
1685 }
1686
1687 static bool json_single_ref(JsonVariant *v) {
1688
1689 /* Checks whether the caller is the single owner of the object, i.e. can get away with changing it */
1690
1691 if (!json_variant_is_regular(v))
1692 return false;
1693
1694 if (v->is_embedded)
1695 return json_single_ref(v->parent);
1696
1697 assert(v->n_ref > 0);
1698 return v->n_ref == 1;
1699 }
1700
1701 static int json_variant_set_source(JsonVariant **v, JsonSource *source, unsigned line, unsigned column) {
1702 JsonVariant *w;
1703 int r;
1704
1705 assert(v);
1706
1707 /* Patch in source and line/column number. Tries to do this in-place if the caller is the sole referencer of
1708 * the object. If not, allocates a new object, possibly a surrogate for the original one */
1709
1710 if (!*v)
1711 return 0;
1712
1713 if (source && line > source->max_line)
1714 source->max_line = line;
1715 if (source && column > source->max_column)
1716 source->max_column = column;
1717
1718 if (!json_variant_is_regular(*v)) {
1719
1720 if (!source && line == 0 && column == 0)
1721 return 0;
1722
1723 } else {
1724 if (json_source_equal((*v)->source, source) &&
1725 (*v)->line == line &&
1726 (*v)->column == column)
1727 return 0;
1728
1729 if (json_single_ref(*v)) { /* Sole reference? */
1730 json_source_unref((*v)->source);
1731 (*v)->source = json_source_ref(source);
1732 (*v)->line = line;
1733 (*v)->column = column;
1734 return 1;
1735 }
1736 }
1737
1738 r = json_variant_copy(&w, *v);
1739 if (r < 0)
1740 return r;
1741
1742 assert(json_variant_is_regular(w));
1743 assert(!w->is_embedded);
1744 assert(w->n_ref == 1);
1745 assert(!w->source);
1746
1747 w->source = json_source_ref(source);
1748 w->line = line;
1749 w->column = column;
1750
1751 json_variant_unref(*v);
1752 *v = w;
1753
1754 return 1;
1755 }
1756
1757 static void inc_lines_columns(unsigned *line, unsigned *column, const char *s, size_t n) {
1758 assert(line);
1759 assert(column);
1760 assert(s || n == 0);
1761
1762 while (n > 0) {
1763 if (*s == '\n') {
1764 (*line)++;
1765 *column = 1;
1766 } else if ((signed char) *s >= 0 && *s < 127) /* Process ASCII chars quickly */
1767 (*column)++;
1768 else {
1769 int w;
1770
1771 w = utf8_encoded_valid_unichar(s, n);
1772 if (w < 0) /* count invalid unichars as normal characters */
1773 w = 1;
1774 else if ((size_t) w > n) /* never read more than the specified number of characters */
1775 w = (int) n;
1776
1777 (*column)++;
1778
1779 s += w;
1780 n -= w;
1781 continue;
1782 }
1783
1784 s++;
1785 n--;
1786 }
1787 }
1788
1789 static int unhex_ucs2(const char *c, uint16_t *ret) {
1790 int aa, bb, cc, dd;
1791 uint16_t x;
1792
1793 assert(c);
1794 assert(ret);
1795
1796 aa = unhexchar(c[0]);
1797 if (aa < 0)
1798 return -EINVAL;
1799
1800 bb = unhexchar(c[1]);
1801 if (bb < 0)
1802 return -EINVAL;
1803
1804 cc = unhexchar(c[2]);
1805 if (cc < 0)
1806 return -EINVAL;
1807
1808 dd = unhexchar(c[3]);
1809 if (dd < 0)
1810 return -EINVAL;
1811
1812 x = ((uint16_t) aa << 12) |
1813 ((uint16_t) bb << 8) |
1814 ((uint16_t) cc << 4) |
1815 ((uint16_t) dd);
1816
1817 if (x <= 0)
1818 return -EINVAL;
1819
1820 *ret = x;
1821
1822 return 0;
1823 }
1824
1825 static int json_parse_string(const char **p, char **ret) {
1826 _cleanup_free_ char *s = NULL;
1827 size_t n = 0, allocated = 0;
1828 const char *c;
1829
1830 assert(p);
1831 assert(*p);
1832 assert(ret);
1833
1834 c = *p;
1835
1836 if (*c != '"')
1837 return -EINVAL;
1838
1839 c++;
1840
1841 for (;;) {
1842 int len;
1843
1844 /* Check for EOF */
1845 if (*c == 0)
1846 return -EINVAL;
1847
1848 /* Check for control characters 0x00..0x1f */
1849 if (*c > 0 && *c < ' ')
1850 return -EINVAL;
1851
1852 /* Check for control character 0x7f */
1853 if (*c == 0x7f)
1854 return -EINVAL;
1855
1856 if (*c == '"') {
1857 if (!s) {
1858 s = strdup("");
1859 if (!s)
1860 return -ENOMEM;
1861 } else
1862 s[n] = 0;
1863
1864 *p = c + 1;
1865
1866 *ret = TAKE_PTR(s);
1867 return JSON_TOKEN_STRING;
1868 }
1869
1870 if (*c == '\\') {
1871 char ch = 0;
1872 c++;
1873
1874 if (*c == 0)
1875 return -EINVAL;
1876
1877 if (IN_SET(*c, '"', '\\', '/'))
1878 ch = *c;
1879 else if (*c == 'b')
1880 ch = '\b';
1881 else if (*c == 'f')
1882 ch = '\f';
1883 else if (*c == 'n')
1884 ch = '\n';
1885 else if (*c == 'r')
1886 ch = '\r';
1887 else if (*c == 't')
1888 ch = '\t';
1889 else if (*c == 'u') {
1890 char16_t x;
1891 int r;
1892
1893 r = unhex_ucs2(c + 1, &x);
1894 if (r < 0)
1895 return r;
1896
1897 c += 5;
1898
1899 if (!GREEDY_REALLOC(s, allocated, n + 5))
1900 return -ENOMEM;
1901
1902 if (!utf16_is_surrogate(x))
1903 n += utf8_encode_unichar(s + n, (char32_t) x);
1904 else if (utf16_is_trailing_surrogate(x))
1905 return -EINVAL;
1906 else {
1907 char16_t y;
1908
1909 if (c[0] != '\\' || c[1] != 'u')
1910 return -EINVAL;
1911
1912 r = unhex_ucs2(c + 2, &y);
1913 if (r < 0)
1914 return r;
1915
1916 c += 6;
1917
1918 if (!utf16_is_trailing_surrogate(y))
1919 return -EINVAL;
1920
1921 n += utf8_encode_unichar(s + n, utf16_surrogate_pair_to_unichar(x, y));
1922 }
1923
1924 continue;
1925 } else
1926 return -EINVAL;
1927
1928 if (!GREEDY_REALLOC(s, allocated, n + 2))
1929 return -ENOMEM;
1930
1931 s[n++] = ch;
1932 c ++;
1933 continue;
1934 }
1935
1936 len = utf8_encoded_valid_unichar(c, (size_t) -1);
1937 if (len < 0)
1938 return len;
1939
1940 if (!GREEDY_REALLOC(s, allocated, n + len + 1))
1941 return -ENOMEM;
1942
1943 memcpy(s + n, c, len);
1944 n += len;
1945 c += len;
1946 }
1947 }
1948
1949 static int json_parse_number(const char **p, JsonValue *ret) {
1950 bool negative = false, exponent_negative = false, is_real = false;
1951 long double x = 0.0, y = 0.0, exponent = 0.0, shift = 1.0;
1952 intmax_t i = 0;
1953 uintmax_t u = 0;
1954 const char *c;
1955
1956 assert(p);
1957 assert(*p);
1958 assert(ret);
1959
1960 c = *p;
1961
1962 if (*c == '-') {
1963 negative = true;
1964 c++;
1965 }
1966
1967 if (*c == '0')
1968 c++;
1969 else {
1970 if (!strchr("123456789", *c) || *c == 0)
1971 return -EINVAL;
1972
1973 do {
1974 if (!is_real) {
1975 if (negative) {
1976
1977 if (i < INTMAX_MIN / 10) /* overflow */
1978 is_real = true;
1979 else {
1980 intmax_t t = 10 * i;
1981
1982 if (t < INTMAX_MIN + (*c - '0')) /* overflow */
1983 is_real = true;
1984 else
1985 i = t - (*c - '0');
1986 }
1987 } else {
1988 if (u > UINTMAX_MAX / 10) /* overflow */
1989 is_real = true;
1990 else {
1991 uintmax_t t = 10 * u;
1992
1993 if (t > UINTMAX_MAX - (*c - '0')) /* overflow */
1994 is_real = true;
1995 else
1996 u = t + (*c - '0');
1997 }
1998 }
1999 }
2000
2001 x = 10.0 * x + (*c - '0');
2002
2003 c++;
2004 } while (strchr("0123456789", *c) && *c != 0);
2005 }
2006
2007 if (*c == '.') {
2008 is_real = true;
2009 c++;
2010
2011 if (!strchr("0123456789", *c) || *c == 0)
2012 return -EINVAL;
2013
2014 do {
2015 y = 10.0 * y + (*c - '0');
2016 shift = 10.0 * shift;
2017 c++;
2018 } while (strchr("0123456789", *c) && *c != 0);
2019 }
2020
2021 if (IN_SET(*c, 'e', 'E')) {
2022 is_real = true;
2023 c++;
2024
2025 if (*c == '-') {
2026 exponent_negative = true;
2027 c++;
2028 } else if (*c == '+')
2029 c++;
2030
2031 if (!strchr("0123456789", *c) || *c == 0)
2032 return -EINVAL;
2033
2034 do {
2035 exponent = 10.0 * exponent + (*c - '0');
2036 c++;
2037 } while (strchr("0123456789", *c) && *c != 0);
2038 }
2039
2040 *p = c;
2041
2042 if (is_real) {
2043 ret->real = ((negative ? -1.0 : 1.0) * (x + (y / shift))) * exp10l((exponent_negative ? -1.0 : 1.0) * exponent);
2044 return JSON_TOKEN_REAL;
2045 } else if (negative) {
2046 ret->integer = i;
2047 return JSON_TOKEN_INTEGER;
2048 } else {
2049 ret->unsig = u;
2050 return JSON_TOKEN_UNSIGNED;
2051 }
2052 }
2053
2054 int json_tokenize(
2055 const char **p,
2056 char **ret_string,
2057 JsonValue *ret_value,
2058 unsigned *ret_line, /* 'ret_line' returns the line at the beginning of this token */
2059 unsigned *ret_column,
2060 void **state,
2061 unsigned *line, /* 'line' is used as a line state, it always reflect the line we are at after the token was read */
2062 unsigned *column) {
2063
2064 unsigned start_line, start_column;
2065 const char *start, *c;
2066 size_t n;
2067 int t, r;
2068
2069 enum {
2070 STATE_NULL,
2071 STATE_VALUE,
2072 STATE_VALUE_POST,
2073 };
2074
2075 assert(p);
2076 assert(*p);
2077 assert(ret_string);
2078 assert(ret_value);
2079 assert(ret_line);
2080 assert(ret_column);
2081 assert(line);
2082 assert(column);
2083 assert(state);
2084
2085 t = PTR_TO_INT(*state);
2086 if (t == STATE_NULL) {
2087 *line = 1;
2088 *column = 1;
2089 t = STATE_VALUE;
2090 }
2091
2092 /* Skip over the whitespace */
2093 n = strspn(*p, WHITESPACE);
2094 inc_lines_columns(line, column, *p, n);
2095 c = *p + n;
2096
2097 /* Remember where we started processing this token */
2098 start = c;
2099 start_line = *line;
2100 start_column = *column;
2101
2102 if (*c == 0) {
2103 *ret_string = NULL;
2104 *ret_value = JSON_VALUE_NULL;
2105 r = JSON_TOKEN_END;
2106 goto finish;
2107 }
2108
2109 switch (t) {
2110
2111 case STATE_VALUE:
2112
2113 if (*c == '{') {
2114 c++;
2115 *state = INT_TO_PTR(STATE_VALUE);
2116 r = JSON_TOKEN_OBJECT_OPEN;
2117 goto null_return;
2118
2119 } else if (*c == '}') {
2120 c++;
2121 *state = INT_TO_PTR(STATE_VALUE_POST);
2122 r = JSON_TOKEN_OBJECT_CLOSE;
2123 goto null_return;
2124
2125 } else if (*c == '[') {
2126 c++;
2127 *state = INT_TO_PTR(STATE_VALUE);
2128 r = JSON_TOKEN_ARRAY_OPEN;
2129 goto null_return;
2130
2131 } else if (*c == ']') {
2132 c++;
2133 *state = INT_TO_PTR(STATE_VALUE_POST);
2134 r = JSON_TOKEN_ARRAY_CLOSE;
2135 goto null_return;
2136
2137 } else if (*c == '"') {
2138
2139 r = json_parse_string(&c, ret_string);
2140 if (r < 0)
2141 return r;
2142
2143 *ret_value = JSON_VALUE_NULL;
2144 *state = INT_TO_PTR(STATE_VALUE_POST);
2145 goto finish;
2146
2147 } else if (strchr("-0123456789", *c)) {
2148
2149 r = json_parse_number(&c, ret_value);
2150 if (r < 0)
2151 return r;
2152
2153 *ret_string = NULL;
2154 *state = INT_TO_PTR(STATE_VALUE_POST);
2155 goto finish;
2156
2157 } else if (startswith(c, "true")) {
2158 *ret_string = NULL;
2159 ret_value->boolean = true;
2160 c += 4;
2161 *state = INT_TO_PTR(STATE_VALUE_POST);
2162 r = JSON_TOKEN_BOOLEAN;
2163 goto finish;
2164
2165 } else if (startswith(c, "false")) {
2166 *ret_string = NULL;
2167 ret_value->boolean = false;
2168 c += 5;
2169 *state = INT_TO_PTR(STATE_VALUE_POST);
2170 r = JSON_TOKEN_BOOLEAN;
2171 goto finish;
2172
2173 } else if (startswith(c, "null")) {
2174 *ret_string = NULL;
2175 *ret_value = JSON_VALUE_NULL;
2176 c += 4;
2177 *state = INT_TO_PTR(STATE_VALUE_POST);
2178 r = JSON_TOKEN_NULL;
2179 goto finish;
2180
2181 }
2182
2183 return -EINVAL;
2184
2185 case STATE_VALUE_POST:
2186
2187 if (*c == ':') {
2188 c++;
2189 *state = INT_TO_PTR(STATE_VALUE);
2190 r = JSON_TOKEN_COLON;
2191 goto null_return;
2192
2193 } else if (*c == ',') {
2194 c++;
2195 *state = INT_TO_PTR(STATE_VALUE);
2196 r = JSON_TOKEN_COMMA;
2197 goto null_return;
2198
2199 } else if (*c == '}') {
2200 c++;
2201 *state = INT_TO_PTR(STATE_VALUE_POST);
2202 r = JSON_TOKEN_OBJECT_CLOSE;
2203 goto null_return;
2204
2205 } else if (*c == ']') {
2206 c++;
2207 *state = INT_TO_PTR(STATE_VALUE_POST);
2208 r = JSON_TOKEN_ARRAY_CLOSE;
2209 goto null_return;
2210 }
2211
2212 return -EINVAL;
2213
2214 default:
2215 assert_not_reached("Unexpected tokenizer state");
2216 }
2217
2218 null_return:
2219 *ret_string = NULL;
2220 *ret_value = JSON_VALUE_NULL;
2221
2222 finish:
2223 inc_lines_columns(line, column, start, c - start);
2224 *p = c;
2225
2226 *ret_line = start_line;
2227 *ret_column = start_column;
2228
2229 return r;
2230 }
2231
2232 typedef enum JsonExpect {
2233 /* The following values are used by json_parse() */
2234 EXPECT_TOPLEVEL,
2235 EXPECT_END,
2236 EXPECT_OBJECT_FIRST_KEY,
2237 EXPECT_OBJECT_NEXT_KEY,
2238 EXPECT_OBJECT_COLON,
2239 EXPECT_OBJECT_VALUE,
2240 EXPECT_OBJECT_COMMA,
2241 EXPECT_ARRAY_FIRST_ELEMENT,
2242 EXPECT_ARRAY_NEXT_ELEMENT,
2243 EXPECT_ARRAY_COMMA,
2244
2245 /* And these are used by json_build() */
2246 EXPECT_ARRAY_ELEMENT,
2247 EXPECT_OBJECT_KEY,
2248 } JsonExpect;
2249
2250 typedef struct JsonStack {
2251 JsonExpect expect;
2252 JsonVariant **elements;
2253 size_t n_elements, n_elements_allocated;
2254 unsigned line_before;
2255 unsigned column_before;
2256 size_t n_suppress; /* When building: if > 0, suppress this many subsequent elements. If == (size_t) -1, suppress all subsequent elements */
2257 } JsonStack;
2258
2259 static void json_stack_release(JsonStack *s) {
2260 assert(s);
2261
2262 json_variant_unref_many(s->elements, s->n_elements);
2263 s->elements = mfree(s->elements);
2264 }
2265
2266 static int json_parse_internal(
2267 const char **input,
2268 JsonSource *source,
2269 JsonVariant **ret,
2270 unsigned *line,
2271 unsigned *column,
2272 bool continue_end) {
2273
2274 size_t n_stack = 1, n_stack_allocated = 0, i;
2275 unsigned line_buffer = 0, column_buffer = 0;
2276 void *tokenizer_state = NULL;
2277 JsonStack *stack = NULL;
2278 const char *p;
2279 int r;
2280
2281 assert_return(input, -EINVAL);
2282 assert_return(ret, -EINVAL);
2283
2284 p = *input;
2285
2286 if (!GREEDY_REALLOC(stack, n_stack_allocated, n_stack))
2287 return -ENOMEM;
2288
2289 stack[0] = (JsonStack) {
2290 .expect = EXPECT_TOPLEVEL,
2291 };
2292
2293 if (!line)
2294 line = &line_buffer;
2295 if (!column)
2296 column = &column_buffer;
2297
2298 for (;;) {
2299 _cleanup_free_ char *string = NULL;
2300 unsigned line_token, column_token;
2301 JsonVariant *add = NULL;
2302 JsonStack *current;
2303 JsonValue value;
2304 int token;
2305
2306 assert(n_stack > 0);
2307 current = stack + n_stack - 1;
2308
2309 if (continue_end && current->expect == EXPECT_END)
2310 goto done;
2311
2312 token = json_tokenize(&p, &string, &value, &line_token, &column_token, &tokenizer_state, line, column);
2313 if (token < 0) {
2314 r = token;
2315 goto finish;
2316 }
2317
2318 switch (token) {
2319
2320 case JSON_TOKEN_END:
2321 if (current->expect != EXPECT_END) {
2322 r = -EINVAL;
2323 goto finish;
2324 }
2325
2326 assert(current->n_elements == 1);
2327 assert(n_stack == 1);
2328 goto done;
2329
2330 case JSON_TOKEN_COLON:
2331
2332 if (current->expect != EXPECT_OBJECT_COLON) {
2333 r = -EINVAL;
2334 goto finish;
2335 }
2336
2337 current->expect = EXPECT_OBJECT_VALUE;
2338 break;
2339
2340 case JSON_TOKEN_COMMA:
2341
2342 if (current->expect == EXPECT_OBJECT_COMMA)
2343 current->expect = EXPECT_OBJECT_NEXT_KEY;
2344 else if (current->expect == EXPECT_ARRAY_COMMA)
2345 current->expect = EXPECT_ARRAY_NEXT_ELEMENT;
2346 else {
2347 r = -EINVAL;
2348 goto finish;
2349 }
2350
2351 break;
2352
2353 case JSON_TOKEN_OBJECT_OPEN:
2354
2355 if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_FIRST_ELEMENT, EXPECT_ARRAY_NEXT_ELEMENT)) {
2356 r = -EINVAL;
2357 goto finish;
2358 }
2359
2360 if (!GREEDY_REALLOC(stack, n_stack_allocated, n_stack+1)) {
2361 r = -ENOMEM;
2362 goto finish;
2363 }
2364 current = stack + n_stack - 1;
2365
2366 /* Prepare the expect for when we return from the child */
2367 if (current->expect == EXPECT_TOPLEVEL)
2368 current->expect = EXPECT_END;
2369 else if (current->expect == EXPECT_OBJECT_VALUE)
2370 current->expect = EXPECT_OBJECT_COMMA;
2371 else {
2372 assert(IN_SET(current->expect, EXPECT_ARRAY_FIRST_ELEMENT, EXPECT_ARRAY_NEXT_ELEMENT));
2373 current->expect = EXPECT_ARRAY_COMMA;
2374 }
2375
2376 stack[n_stack++] = (JsonStack) {
2377 .expect = EXPECT_OBJECT_FIRST_KEY,
2378 .line_before = line_token,
2379 .column_before = column_token,
2380 };
2381
2382 current = stack + n_stack - 1;
2383 break;
2384
2385 case JSON_TOKEN_OBJECT_CLOSE:
2386 if (!IN_SET(current->expect, EXPECT_OBJECT_FIRST_KEY, EXPECT_OBJECT_COMMA)) {
2387 r = -EINVAL;
2388 goto finish;
2389 }
2390
2391 assert(n_stack > 1);
2392
2393 r = json_variant_new_object(&add, current->elements, current->n_elements);
2394 if (r < 0)
2395 goto finish;
2396
2397 line_token = current->line_before;
2398 column_token = current->column_before;
2399
2400 json_stack_release(current);
2401 n_stack--, current--;
2402
2403 break;
2404
2405 case JSON_TOKEN_ARRAY_OPEN:
2406 if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_FIRST_ELEMENT, EXPECT_ARRAY_NEXT_ELEMENT)) {
2407 r = -EINVAL;
2408 goto finish;
2409 }
2410
2411 if (!GREEDY_REALLOC(stack, n_stack_allocated, n_stack+1)) {
2412 r = -ENOMEM;
2413 goto finish;
2414 }
2415 current = stack + n_stack - 1;
2416
2417 /* Prepare the expect for when we return from the child */
2418 if (current->expect == EXPECT_TOPLEVEL)
2419 current->expect = EXPECT_END;
2420 else if (current->expect == EXPECT_OBJECT_VALUE)
2421 current->expect = EXPECT_OBJECT_COMMA;
2422 else {
2423 assert(IN_SET(current->expect, EXPECT_ARRAY_FIRST_ELEMENT, EXPECT_ARRAY_NEXT_ELEMENT));
2424 current->expect = EXPECT_ARRAY_COMMA;
2425 }
2426
2427 stack[n_stack++] = (JsonStack) {
2428 .expect = EXPECT_ARRAY_FIRST_ELEMENT,
2429 .line_before = line_token,
2430 .column_before = column_token,
2431 };
2432
2433 break;
2434
2435 case JSON_TOKEN_ARRAY_CLOSE:
2436 if (!IN_SET(current->expect, EXPECT_ARRAY_FIRST_ELEMENT, EXPECT_ARRAY_COMMA)) {
2437 r = -EINVAL;
2438 goto finish;
2439 }
2440
2441 assert(n_stack > 1);
2442
2443 r = json_variant_new_array(&add, current->elements, current->n_elements);
2444 if (r < 0)
2445 goto finish;
2446
2447 line_token = current->line_before;
2448 column_token = current->column_before;
2449
2450 json_stack_release(current);
2451 n_stack--, current--;
2452 break;
2453
2454 case JSON_TOKEN_STRING:
2455 if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_FIRST_KEY, EXPECT_OBJECT_NEXT_KEY, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_FIRST_ELEMENT, EXPECT_ARRAY_NEXT_ELEMENT)) {
2456 r = -EINVAL;
2457 goto finish;
2458 }
2459
2460 r = json_variant_new_string(&add, string);
2461 if (r < 0)
2462 goto finish;
2463
2464 if (current->expect == EXPECT_TOPLEVEL)
2465 current->expect = EXPECT_END;
2466 else if (IN_SET(current->expect, EXPECT_OBJECT_FIRST_KEY, EXPECT_OBJECT_NEXT_KEY))
2467 current->expect = EXPECT_OBJECT_COLON;
2468 else if (current->expect == EXPECT_OBJECT_VALUE)
2469 current->expect = EXPECT_OBJECT_COMMA;
2470 else {
2471 assert(IN_SET(current->expect, EXPECT_ARRAY_FIRST_ELEMENT, EXPECT_ARRAY_NEXT_ELEMENT));
2472 current->expect = EXPECT_ARRAY_COMMA;
2473 }
2474
2475 break;
2476
2477 case JSON_TOKEN_REAL:
2478 if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_FIRST_ELEMENT, EXPECT_ARRAY_NEXT_ELEMENT)) {
2479 r = -EINVAL;
2480 goto finish;
2481 }
2482
2483 r = json_variant_new_real(&add, value.real);
2484 if (r < 0)
2485 goto finish;
2486
2487 if (current->expect == EXPECT_TOPLEVEL)
2488 current->expect = EXPECT_END;
2489 else if (current->expect == EXPECT_OBJECT_VALUE)
2490 current->expect = EXPECT_OBJECT_COMMA;
2491 else {
2492 assert(IN_SET(current->expect, EXPECT_ARRAY_FIRST_ELEMENT, EXPECT_ARRAY_NEXT_ELEMENT));
2493 current->expect = EXPECT_ARRAY_COMMA;
2494 }
2495
2496 break;
2497
2498 case JSON_TOKEN_INTEGER:
2499 if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_FIRST_ELEMENT, EXPECT_ARRAY_NEXT_ELEMENT)) {
2500 r = -EINVAL;
2501 goto finish;
2502 }
2503
2504 r = json_variant_new_integer(&add, value.integer);
2505 if (r < 0)
2506 goto finish;
2507
2508 if (current->expect == EXPECT_TOPLEVEL)
2509 current->expect = EXPECT_END;
2510 else if (current->expect == EXPECT_OBJECT_VALUE)
2511 current->expect = EXPECT_OBJECT_COMMA;
2512 else {
2513 assert(IN_SET(current->expect, EXPECT_ARRAY_FIRST_ELEMENT, EXPECT_ARRAY_NEXT_ELEMENT));
2514 current->expect = EXPECT_ARRAY_COMMA;
2515 }
2516
2517 break;
2518
2519 case JSON_TOKEN_UNSIGNED:
2520 if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_FIRST_ELEMENT, EXPECT_ARRAY_NEXT_ELEMENT)) {
2521 r = -EINVAL;
2522 goto finish;
2523 }
2524
2525 r = json_variant_new_unsigned(&add, value.unsig);
2526 if (r < 0)
2527 goto finish;
2528
2529 if (current->expect == EXPECT_TOPLEVEL)
2530 current->expect = EXPECT_END;
2531 else if (current->expect == EXPECT_OBJECT_VALUE)
2532 current->expect = EXPECT_OBJECT_COMMA;
2533 else {
2534 assert(IN_SET(current->expect, EXPECT_ARRAY_FIRST_ELEMENT, EXPECT_ARRAY_NEXT_ELEMENT));
2535 current->expect = EXPECT_ARRAY_COMMA;
2536 }
2537
2538 break;
2539
2540 case JSON_TOKEN_BOOLEAN:
2541 if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_FIRST_ELEMENT, EXPECT_ARRAY_NEXT_ELEMENT)) {
2542 r = -EINVAL;
2543 goto finish;
2544 }
2545
2546 r = json_variant_new_boolean(&add, value.boolean);
2547 if (r < 0)
2548 goto finish;
2549
2550 if (current->expect == EXPECT_TOPLEVEL)
2551 current->expect = EXPECT_END;
2552 else if (current->expect == EXPECT_OBJECT_VALUE)
2553 current->expect = EXPECT_OBJECT_COMMA;
2554 else {
2555 assert(IN_SET(current->expect, EXPECT_ARRAY_FIRST_ELEMENT, EXPECT_ARRAY_NEXT_ELEMENT));
2556 current->expect = EXPECT_ARRAY_COMMA;
2557 }
2558
2559 break;
2560
2561 case JSON_TOKEN_NULL:
2562 if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_FIRST_ELEMENT, EXPECT_ARRAY_NEXT_ELEMENT)) {
2563 r = -EINVAL;
2564 goto finish;
2565 }
2566
2567 r = json_variant_new_null(&add);
2568 if (r < 0)
2569 goto finish;
2570
2571 if (current->expect == EXPECT_TOPLEVEL)
2572 current->expect = EXPECT_END;
2573 else if (current->expect == EXPECT_OBJECT_VALUE)
2574 current->expect = EXPECT_OBJECT_COMMA;
2575 else {
2576 assert(IN_SET(current->expect, EXPECT_ARRAY_FIRST_ELEMENT, EXPECT_ARRAY_NEXT_ELEMENT));
2577 current->expect = EXPECT_ARRAY_COMMA;
2578 }
2579
2580 break;
2581
2582 default:
2583 assert_not_reached("Unexpected token");
2584 }
2585
2586 if (add) {
2587 (void) json_variant_set_source(&add, source, line_token, column_token);
2588
2589 if (!GREEDY_REALLOC(current->elements, current->n_elements_allocated, current->n_elements + 1)) {
2590 r = -ENOMEM;
2591 goto finish;
2592 }
2593
2594 current->elements[current->n_elements++] = add;
2595 }
2596 }
2597
2598 done:
2599 assert(n_stack == 1);
2600 assert(stack[0].n_elements == 1);
2601
2602 *ret = json_variant_ref(stack[0].elements[0]);
2603 *input = p;
2604 r = 0;
2605
2606 finish:
2607 for (i = 0; i < n_stack; i++)
2608 json_stack_release(stack + i);
2609
2610 free(stack);
2611
2612 return r;
2613 }
2614
2615 int json_parse(const char *input, JsonVariant **ret, unsigned *ret_line, unsigned *ret_column) {
2616 return json_parse_internal(&input, NULL, ret, ret_line, ret_column, false);
2617 }
2618
2619 int json_parse_continue(const char **p, JsonVariant **ret, unsigned *ret_line, unsigned *ret_column) {
2620 return json_parse_internal(p, NULL, ret, ret_line, ret_column, true);
2621 }
2622
2623 int json_parse_file(FILE *f, const char *path, JsonVariant **ret, unsigned *ret_line, unsigned *ret_column) {
2624 _cleanup_(json_source_unrefp) JsonSource *source = NULL;
2625 _cleanup_free_ char *text = NULL;
2626 const char *p;
2627 int r;
2628
2629 if (f)
2630 r = read_full_stream(f, &text, NULL);
2631 else if (path)
2632 r = read_full_file(path, &text, NULL);
2633 else
2634 return -EINVAL;
2635 if (r < 0)
2636 return r;
2637
2638 if (path) {
2639 source = json_source_new(path);
2640 if (!source)
2641 return -ENOMEM;
2642 }
2643
2644 p = text;
2645 return json_parse_internal(&p, source, ret, ret_line, ret_column, false);
2646 }
2647
2648 int json_buildv(JsonVariant **ret, va_list ap) {
2649 JsonStack *stack = NULL;
2650 size_t n_stack = 1, n_stack_allocated = 0, i;
2651 int r;
2652
2653 assert_return(ret, -EINVAL);
2654
2655 if (!GREEDY_REALLOC(stack, n_stack_allocated, n_stack))
2656 return -ENOMEM;
2657
2658 stack[0] = (JsonStack) {
2659 .expect = EXPECT_TOPLEVEL,
2660 };
2661
2662 for (;;) {
2663 _cleanup_(json_variant_unrefp) JsonVariant *add = NULL;
2664 size_t n_subtract = 0; /* how much to subtract from current->n_suppress, i.e. how many elements would
2665 * have been added to the current variant */
2666 JsonStack *current;
2667 int command;
2668
2669 assert(n_stack > 0);
2670 current = stack + n_stack - 1;
2671
2672 if (current->expect == EXPECT_END)
2673 goto done;
2674
2675 command = va_arg(ap, int);
2676
2677 switch (command) {
2678
2679 case _JSON_BUILD_STRING: {
2680 const char *p;
2681
2682 if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
2683 r = -EINVAL;
2684 goto finish;
2685 }
2686
2687 p = va_arg(ap, const char *);
2688
2689 if (current->n_suppress == 0) {
2690 r = json_variant_new_string(&add, p);
2691 if (r < 0)
2692 goto finish;
2693 }
2694
2695 n_subtract = 1;
2696
2697 if (current->expect == EXPECT_TOPLEVEL)
2698 current->expect = EXPECT_END;
2699 else if (current->expect == EXPECT_OBJECT_VALUE)
2700 current->expect = EXPECT_OBJECT_KEY;
2701 else
2702 assert(current->expect == EXPECT_ARRAY_ELEMENT);
2703
2704 break;
2705 }
2706
2707 case _JSON_BUILD_INTEGER: {
2708 intmax_t j;
2709
2710 if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
2711 r = -EINVAL;
2712 goto finish;
2713 }
2714
2715 j = va_arg(ap, intmax_t);
2716
2717 if (current->n_suppress == 0) {
2718 r = json_variant_new_integer(&add, j);
2719 if (r < 0)
2720 goto finish;
2721 }
2722
2723 n_subtract = 1;
2724
2725 if (current->expect == EXPECT_TOPLEVEL)
2726 current->expect = EXPECT_END;
2727 else if (current->expect == EXPECT_OBJECT_VALUE)
2728 current->expect = EXPECT_OBJECT_KEY;
2729 else
2730 assert(current->expect == EXPECT_ARRAY_ELEMENT);
2731
2732 break;
2733 }
2734
2735 case _JSON_BUILD_UNSIGNED: {
2736 uintmax_t j;
2737
2738 if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
2739 r = -EINVAL;
2740 goto finish;
2741 }
2742
2743 j = va_arg(ap, uintmax_t);
2744
2745 if (current->n_suppress == 0) {
2746 r = json_variant_new_unsigned(&add, j);
2747 if (r < 0)
2748 goto finish;
2749 }
2750
2751 n_subtract = 1;
2752
2753 if (current->expect == EXPECT_TOPLEVEL)
2754 current->expect = EXPECT_END;
2755 else if (current->expect == EXPECT_OBJECT_VALUE)
2756 current->expect = EXPECT_OBJECT_KEY;
2757 else
2758 assert(current->expect == EXPECT_ARRAY_ELEMENT);
2759
2760 break;
2761 }
2762
2763 case _JSON_BUILD_REAL: {
2764 long double d;
2765
2766 if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
2767 r = -EINVAL;
2768 goto finish;
2769 }
2770
2771 d = va_arg(ap, long double);
2772
2773 if (current->n_suppress == 0) {
2774 r = json_variant_new_real(&add, d);
2775 if (r < 0)
2776 goto finish;
2777 }
2778
2779 n_subtract = 1;
2780
2781 if (current->expect == EXPECT_TOPLEVEL)
2782 current->expect = EXPECT_END;
2783 else if (current->expect == EXPECT_OBJECT_VALUE)
2784 current->expect = EXPECT_OBJECT_KEY;
2785 else
2786 assert(current->expect == EXPECT_ARRAY_ELEMENT);
2787
2788 break;
2789 }
2790
2791 case _JSON_BUILD_BOOLEAN: {
2792 bool b;
2793
2794 if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
2795 r = -EINVAL;
2796 goto finish;
2797 }
2798
2799 b = va_arg(ap, int);
2800
2801 if (current->n_suppress == 0) {
2802 r = json_variant_new_boolean(&add, b);
2803 if (r < 0)
2804 goto finish;
2805 }
2806
2807 n_subtract = 1;
2808
2809 if (current->expect == EXPECT_TOPLEVEL)
2810 current->expect = EXPECT_END;
2811 else if (current->expect == EXPECT_OBJECT_VALUE)
2812 current->expect = EXPECT_OBJECT_KEY;
2813 else
2814 assert(current->expect == EXPECT_ARRAY_ELEMENT);
2815
2816 break;
2817 }
2818
2819 case _JSON_BUILD_NULL:
2820
2821 if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
2822 r = -EINVAL;
2823 goto finish;
2824 }
2825
2826 if (current->n_suppress == 0) {
2827 r = json_variant_new_null(&add);
2828 if (r < 0)
2829 goto finish;
2830 }
2831
2832 n_subtract = 1;
2833
2834 if (current->expect == EXPECT_TOPLEVEL)
2835 current->expect = EXPECT_END;
2836 else if (current->expect == EXPECT_OBJECT_VALUE)
2837 current->expect = EXPECT_OBJECT_KEY;
2838 else
2839 assert(current->expect == EXPECT_ARRAY_ELEMENT);
2840
2841 break;
2842
2843 case _JSON_BUILD_VARIANT:
2844
2845 if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
2846 r = -EINVAL;
2847 goto finish;
2848 }
2849
2850 /* Note that we don't care for current->n_suppress here, after all the variant is already
2851 * allocated anyway... */
2852 add = va_arg(ap, JsonVariant*);
2853 if (!add)
2854 add = JSON_VARIANT_MAGIC_NULL;
2855 else
2856 json_variant_ref(add);
2857
2858 n_subtract = 1;
2859
2860 if (current->expect == EXPECT_TOPLEVEL)
2861 current->expect = EXPECT_END;
2862 else if (current->expect == EXPECT_OBJECT_VALUE)
2863 current->expect = EXPECT_OBJECT_KEY;
2864 else
2865 assert(current->expect == EXPECT_ARRAY_ELEMENT);
2866
2867 break;
2868
2869 case _JSON_BUILD_LITERAL: {
2870 const char *l;
2871
2872 if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
2873 r = -EINVAL;
2874 goto finish;
2875 }
2876
2877 l = va_arg(ap, const char *);
2878
2879 if (l) {
2880 /* Note that we don't care for current->n_suppress here, we should generate parsing
2881 * errors even in suppressed object properties */
2882
2883 r = json_parse(l, &add, NULL, NULL);
2884 if (r < 0)
2885 goto finish;
2886 } else
2887 add = JSON_VARIANT_MAGIC_NULL;
2888
2889 n_subtract = 1;
2890
2891 if (current->expect == EXPECT_TOPLEVEL)
2892 current->expect = EXPECT_END;
2893 else if (current->expect == EXPECT_OBJECT_VALUE)
2894 current->expect = EXPECT_OBJECT_KEY;
2895 else
2896 assert(current->expect == EXPECT_ARRAY_ELEMENT);
2897
2898 break;
2899 }
2900
2901 case _JSON_BUILD_ARRAY_BEGIN:
2902
2903 if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
2904 r = -EINVAL;
2905 goto finish;
2906 }
2907
2908 if (!GREEDY_REALLOC(stack, n_stack_allocated, n_stack+1)) {
2909 r = -ENOMEM;
2910 goto finish;
2911 }
2912 current = stack + n_stack - 1;
2913
2914 if (current->expect == EXPECT_TOPLEVEL)
2915 current->expect = EXPECT_END;
2916 else if (current->expect == EXPECT_OBJECT_VALUE)
2917 current->expect = EXPECT_OBJECT_KEY;
2918 else
2919 assert(current->expect == EXPECT_ARRAY_ELEMENT);
2920
2921 stack[n_stack++] = (JsonStack) {
2922 .expect = EXPECT_ARRAY_ELEMENT,
2923 .n_suppress = current->n_suppress != 0 ? (size_t) -1 : 0, /* if we shall suppress the
2924 * new array, then we should
2925 * also suppress all array
2926 * members */
2927 };
2928
2929 break;
2930
2931 case _JSON_BUILD_ARRAY_END:
2932 if (current->expect != EXPECT_ARRAY_ELEMENT) {
2933 r = -EINVAL;
2934 goto finish;
2935 }
2936
2937 assert(n_stack > 1);
2938
2939 if (current->n_suppress == 0) {
2940 r = json_variant_new_array(&add, current->elements, current->n_elements);
2941 if (r < 0)
2942 goto finish;
2943 }
2944
2945 n_subtract = 1;
2946
2947 json_stack_release(current);
2948 n_stack--, current--;
2949
2950 break;
2951
2952 case _JSON_BUILD_STRV: {
2953 char **l;
2954
2955 if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
2956 r = -EINVAL;
2957 goto finish;
2958 }
2959
2960 l = va_arg(ap, char **);
2961
2962 if (current->n_suppress == 0) {
2963 r = json_variant_new_array_strv(&add, l);
2964 if (r < 0)
2965 goto finish;
2966 }
2967
2968 n_subtract = 1;
2969
2970 if (current->expect == EXPECT_TOPLEVEL)
2971 current->expect = EXPECT_END;
2972 else if (current->expect == EXPECT_OBJECT_VALUE)
2973 current->expect = EXPECT_OBJECT_KEY;
2974 else
2975 assert(current->expect == EXPECT_ARRAY_ELEMENT);
2976
2977 break;
2978 }
2979
2980 case _JSON_BUILD_OBJECT_BEGIN:
2981
2982 if (!IN_SET(current->expect, EXPECT_TOPLEVEL, EXPECT_OBJECT_VALUE, EXPECT_ARRAY_ELEMENT)) {
2983 r = -EINVAL;
2984 goto finish;
2985 }
2986
2987 if (!GREEDY_REALLOC(stack, n_stack_allocated, n_stack+1)) {
2988 r = -ENOMEM;
2989 goto finish;
2990 }
2991 current = stack + n_stack - 1;
2992
2993 if (current->expect == EXPECT_TOPLEVEL)
2994 current->expect = EXPECT_END;
2995 else if (current->expect == EXPECT_OBJECT_VALUE)
2996 current->expect = EXPECT_OBJECT_KEY;
2997 else
2998 assert(current->expect == EXPECT_ARRAY_ELEMENT);
2999
3000 stack[n_stack++] = (JsonStack) {
3001 .expect = EXPECT_OBJECT_KEY,
3002 .n_suppress = current->n_suppress != 0 ? (size_t) -1 : 0, /* if we shall suppress the
3003 * new object, then we should
3004 * also suppress all object
3005 * members */
3006 };
3007
3008 break;
3009
3010 case _JSON_BUILD_OBJECT_END:
3011
3012 if (current->expect != EXPECT_OBJECT_KEY) {
3013 r = -EINVAL;
3014 goto finish;
3015 }
3016
3017 assert(n_stack > 1);
3018
3019 if (current->n_suppress == 0) {
3020 r = json_variant_new_object(&add, current->elements, current->n_elements);
3021 if (r < 0)
3022 goto finish;
3023 }
3024
3025 n_subtract = 1;
3026
3027 json_stack_release(current);
3028 n_stack--, current--;
3029
3030 break;
3031
3032 case _JSON_BUILD_PAIR: {
3033 const char *n;
3034
3035 if (current->expect != EXPECT_OBJECT_KEY) {
3036 r = -EINVAL;
3037 goto finish;
3038 }
3039
3040 n = va_arg(ap, const char *);
3041
3042 if (current->n_suppress == 0) {
3043 r = json_variant_new_string(&add, n);
3044 if (r < 0)
3045 goto finish;
3046 }
3047
3048 n_subtract = 1;
3049
3050 current->expect = EXPECT_OBJECT_VALUE;
3051 break;
3052 }
3053
3054 case _JSON_BUILD_PAIR_CONDITION: {
3055 const char *n;
3056 bool b;
3057
3058 if (current->expect != EXPECT_OBJECT_KEY) {
3059 r = -EINVAL;
3060 goto finish;
3061 }
3062
3063 b = va_arg(ap, int);
3064 n = va_arg(ap, const char *);
3065
3066 if (b && current->n_suppress == 0) {
3067 r = json_variant_new_string(&add, n);
3068 if (r < 0)
3069 goto finish;
3070 }
3071
3072 n_subtract = 1; /* we generated one item */
3073
3074 if (!b && current->n_suppress != (size_t) -1)
3075 current->n_suppress += 2; /* Suppress this one and the next item */
3076
3077 current->expect = EXPECT_OBJECT_VALUE;
3078 break;
3079 }}
3080
3081 /* If a variant was generated, add it to our current variant, but only if we are not supposed to suppress additions */
3082 if (add && current->n_suppress == 0) {
3083 if (!GREEDY_REALLOC(current->elements, current->n_elements_allocated, current->n_elements + 1)) {
3084 r = -ENOMEM;
3085 goto finish;
3086 }
3087
3088 current->elements[current->n_elements++] = TAKE_PTR(add);
3089 }
3090
3091 /* If we are supposed to suppress items, let's subtract how many items where generated from that
3092 * counter. Except if the counter is (size_t) -1, i.e. we shall suppress an infinite number of elements
3093 * on this stack level */
3094 if (current->n_suppress != (size_t) -1) {
3095 if (current->n_suppress <= n_subtract) /* Saturated */
3096 current->n_suppress = 0;
3097 else
3098 current->n_suppress -= n_subtract;
3099 }
3100 }
3101
3102 done:
3103 assert(n_stack == 1);
3104 assert(stack[0].n_elements == 1);
3105
3106 *ret = json_variant_ref(stack[0].elements[0]);
3107 r = 0;
3108
3109 finish:
3110 for (i = 0; i < n_stack; i++)
3111 json_stack_release(stack + i);
3112
3113 free(stack);
3114
3115 return r;
3116 }
3117
3118 int json_build(JsonVariant **ret, ...) {
3119 va_list ap;
3120 int r;
3121
3122 va_start(ap, ret);
3123 r = json_buildv(ret, ap);
3124 va_end(ap);
3125
3126 return r;
3127 }
3128
3129 int json_log_internal(
3130 JsonVariant *variant,
3131 int level,
3132 int error,
3133 const char *file,
3134 int line,
3135 const char *func,
3136 const char *format, ...) {
3137
3138 PROTECT_ERRNO;
3139
3140 unsigned source_line, source_column;
3141 char buffer[LINE_MAX];
3142 const char *source;
3143 va_list ap;
3144 int r;
3145
3146 errno = ERRNO_VALUE(error);
3147
3148 va_start(ap, format);
3149 (void) vsnprintf(buffer, sizeof buffer, format, ap);
3150 va_end(ap);
3151
3152 if (variant) {
3153 r = json_variant_get_source(variant, &source, &source_line, &source_column);
3154 if (r < 0)
3155 return r;
3156 } else {
3157 source = NULL;
3158 source_line = 0;
3159 source_column = 0;
3160 }
3161
3162 if (source && source_line > 0 && source_column > 0)
3163 return log_struct_internal(
3164 LOG_REALM_PLUS_LEVEL(LOG_REALM_SYSTEMD, level),
3165 error,
3166 file, line, func,
3167 "MESSAGE_ID=" SD_MESSAGE_INVALID_CONFIGURATION_STR,
3168 "CONFIG_FILE=%s", source,
3169 "CONFIG_LINE=%u", source_line,
3170 "CONFIG_COLUMN=%u", source_column,
3171 LOG_MESSAGE("%s:%u:%u: %s", source, source_line, source_column, buffer),
3172 NULL);
3173 else
3174 return log_struct_internal(
3175 LOG_REALM_PLUS_LEVEL(LOG_REALM_SYSTEMD, level),
3176 error,
3177 file, line, func,
3178 "MESSAGE_ID=" SD_MESSAGE_INVALID_CONFIGURATION_STR,
3179 LOG_MESSAGE("%s", buffer),
3180 NULL);
3181 }
3182
3183 int json_dispatch(JsonVariant *v, const JsonDispatch table[], JsonDispatchCallback bad, JsonDispatchFlags flags, void *userdata) {
3184 const JsonDispatch *p;
3185 size_t i, n, m;
3186 int r, done = 0;
3187 bool *found;
3188
3189 if (!json_variant_is_object(v)) {
3190 json_log(v, flags, 0, "JSON variant is not an object.");
3191
3192 if (flags & JSON_PERMISSIVE)
3193 return 0;
3194
3195 return -EINVAL;
3196 }
3197
3198 for (p = table, m = 0; p->name; p++)
3199 m++;
3200
3201 found = newa0(bool, m);
3202
3203 n = json_variant_elements(v);
3204 for (i = 0; i < n; i += 2) {
3205 JsonVariant *key, *value;
3206
3207 assert_se(key = json_variant_by_index(v, i));
3208 assert_se(value = json_variant_by_index(v, i+1));
3209
3210 for (p = table; p->name; p++)
3211 if (p->name == (const char*) -1 ||
3212 streq_ptr(json_variant_string(key), p->name))
3213 break;
3214
3215 if (p->name) { /* Found a matching entry! :-) */
3216 JsonDispatchFlags merged_flags;
3217
3218 merged_flags = flags | p->flags;
3219
3220 if (p->type != _JSON_VARIANT_TYPE_INVALID &&
3221 !json_variant_has_type(value, p->type)) {
3222
3223 json_log(value, merged_flags, 0,
3224 "Object field '%s' has wrong type %s, expected %s.", json_variant_string(key),
3225 json_variant_type_to_string(json_variant_type(value)), json_variant_type_to_string(p->type));
3226
3227 if (merged_flags & JSON_PERMISSIVE)
3228 continue;
3229
3230 return -EINVAL;
3231 }
3232
3233 if (found[p-table]) {
3234 json_log(value, merged_flags, 0, "Duplicate object field '%s'.", json_variant_string(key));
3235
3236 if (merged_flags & JSON_PERMISSIVE)
3237 continue;
3238
3239 return -ENOTUNIQ;
3240 }
3241
3242 found[p-table] = true;
3243
3244 if (p->callback) {
3245 r = p->callback(json_variant_string(key), value, merged_flags, (uint8_t*) userdata + p->offset);
3246 if (r < 0) {
3247 if (merged_flags & JSON_PERMISSIVE)
3248 continue;
3249
3250 return r;
3251 }
3252 }
3253
3254 done ++;
3255
3256 } else { /* Didn't find a matching entry! :-( */
3257
3258 if (bad) {
3259 r = bad(json_variant_string(key), value, flags, userdata);
3260 if (r < 0) {
3261 if (flags & JSON_PERMISSIVE)
3262 continue;
3263
3264 return r;
3265 } else
3266 done ++;
3267
3268 } else {
3269 json_log(value, flags, 0, "Unexpected object field '%s'.", json_variant_string(key));
3270
3271 if (flags & JSON_PERMISSIVE)
3272 continue;
3273
3274 return -EADDRNOTAVAIL;
3275 }
3276 }
3277 }
3278
3279 for (p = table; p->name; p++) {
3280 JsonDispatchFlags merged_flags = p->flags | flags;
3281
3282 if ((merged_flags & JSON_MANDATORY) && !found[p-table]) {
3283 json_log(v, merged_flags, 0, "Missing object field '%s'.", p->name);
3284
3285 if ((merged_flags & JSON_PERMISSIVE))
3286 continue;
3287
3288 return -ENXIO;
3289 }
3290 }
3291
3292 return done;
3293 }
3294
3295 int json_dispatch_boolean(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
3296 bool *b = userdata;
3297
3298 assert(variant);
3299 assert(b);
3300
3301 if (!json_variant_is_boolean(variant))
3302 return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a boolean.", strna(name));
3303
3304 *b = json_variant_boolean(variant);
3305 return 0;
3306 }
3307
3308 int json_dispatch_tristate(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
3309 int *b = userdata;
3310
3311 assert(variant);
3312 assert(b);
3313
3314 if (!json_variant_is_boolean(variant))
3315 return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a boolean.", strna(name));
3316
3317 *b = json_variant_boolean(variant);
3318 return 0;
3319 }
3320
3321 int json_dispatch_integer(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
3322 intmax_t *i = userdata;
3323
3324 assert(variant);
3325 assert(i);
3326
3327 if (!json_variant_is_integer(variant))
3328 return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an integer.", strna(name));
3329
3330 *i = json_variant_integer(variant);
3331 return 0;
3332 }
3333
3334 int json_dispatch_unsigned(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
3335 uintmax_t *u = userdata;
3336
3337 assert(variant);
3338 assert(u);
3339
3340 if (!json_variant_is_unsigned(variant))
3341 return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an unsigned integer.", strna(name));
3342
3343 *u = json_variant_unsigned(variant);
3344 return 0;
3345 }
3346
3347 int json_dispatch_uint32(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
3348 uint32_t *u = userdata;
3349
3350 assert(variant);
3351 assert(u);
3352
3353 if (!json_variant_is_unsigned(variant))
3354 return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an unsigned integer.", strna(name));
3355
3356 if (json_variant_unsigned(variant) > UINT32_MAX)
3357 return json_log(variant, flags, SYNTHETIC_ERRNO(ERANGE), "JSON field '%s' out of bounds.", strna(name));
3358
3359 *u = (uint32_t) json_variant_unsigned(variant);
3360 return 0;
3361 }
3362
3363 int json_dispatch_int32(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
3364 int32_t *i = userdata;
3365
3366 assert(variant);
3367 assert(i);
3368
3369 if (!json_variant_is_integer(variant))
3370 return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an integer.", strna(name));
3371
3372 if (json_variant_integer(variant) < INT32_MIN || json_variant_integer(variant) > INT32_MAX)
3373 return json_log(variant, flags, SYNTHETIC_ERRNO(ERANGE), "JSON field '%s' out of bounds.", strna(name));
3374
3375 *i = (int32_t) json_variant_integer(variant);
3376 return 0;
3377 }
3378
3379 int json_dispatch_string(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
3380 char **s = userdata;
3381 int r;
3382
3383 assert(variant);
3384 assert(s);
3385
3386 if (json_variant_is_null(variant)) {
3387 *s = mfree(*s);
3388 return 0;
3389 }
3390
3391 if (!json_variant_is_string(variant))
3392 return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a string.", strna(name));
3393
3394 r = free_and_strdup(s, json_variant_string(variant));
3395 if (r < 0)
3396 return json_log(variant, flags, r, "Failed to allocate string: %m");
3397
3398 return 0;
3399 }
3400
3401 int json_dispatch_strv(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
3402 _cleanup_strv_free_ char **l = NULL;
3403 char ***s = userdata;
3404 size_t i;
3405 int r;
3406
3407 assert(variant);
3408 assert(s);
3409
3410 if (json_variant_is_null(variant)) {
3411 *s = strv_free(*s);
3412 return 0;
3413 }
3414
3415 if (!json_variant_is_array(variant))
3416 return json_log(variant, SYNTHETIC_ERRNO(EINVAL), flags, "JSON field '%s' is not an array.", strna(name));
3417
3418 for (i = 0; i < json_variant_elements(variant); i++) {
3419 JsonVariant *e;
3420
3421 assert_se(e = json_variant_by_index(variant, i));
3422
3423 if (!json_variant_is_string(e))
3424 return json_log(e, flags, SYNTHETIC_ERRNO(EINVAL), "JSON array element is not a string.");
3425
3426 r = strv_extend(&l, json_variant_string(e));
3427 if (r < 0)
3428 return json_log(e, flags, r, "Failed to append array element: %m");
3429 }
3430
3431 strv_free_and_replace(*s, l);
3432 return 0;
3433 }
3434
3435 int json_dispatch_variant(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
3436 JsonVariant **p = userdata;
3437
3438 assert(variant);
3439 assert(p);
3440
3441 json_variant_unref(*p);
3442 *p = json_variant_ref(variant);
3443
3444 return 0;
3445 }
3446
3447 static const char* const json_variant_type_table[_JSON_VARIANT_TYPE_MAX] = {
3448 [JSON_VARIANT_STRING] = "string",
3449 [JSON_VARIANT_INTEGER] = "integer",
3450 [JSON_VARIANT_UNSIGNED] = "unsigned",
3451 [JSON_VARIANT_REAL] = "real",
3452 [JSON_VARIANT_NUMBER] = "number",
3453 [JSON_VARIANT_BOOLEAN] = "boolean",
3454 [JSON_VARIANT_ARRAY] = "array",
3455 [JSON_VARIANT_OBJECT] = "object",
3456 [JSON_VARIANT_NULL] = "null",
3457 };
3458
3459 DEFINE_STRING_TABLE_LOOKUP(json_variant_type, JsonVariantType);
Unnamed repository; edit this file 'description' to name the repository.