1 /*
2 * virjson.c: JSON object parsing/formatting
3 *
4 * Copyright (C) 2009-2010, 2012-2015 Red Hat, Inc.
5 * Copyright (C) 2009 Daniel P. Berrange
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library. If not, see
19 * <http://www.gnu.org/licenses/>.
20 *
21 */
22
23
24 #include <config.h>
25
26 #include "virjson.h"
27 #include "viralloc.h"
28 #include "virerror.h"
29 #include "virlog.h"
30 #include "virstring.h"
31 #include "virutil.h"
32 #include "virbuffer.h"
33 #include "virenum.h"
34 #include "virbitmap.h"
35
36 #if WITH_YAJL
37 # include <yajl/yajl_gen.h>
38 # include <yajl/yajl_parse.h>
39
40 #endif
41
42 /* XXX fixme */
43 #define VIR_FROM_THIS VIR_FROM_NONE
44
45 VIR_LOG_INIT("util.json");
46
47 typedef struct _virJSONObject virJSONObject;
48
49 typedef struct _virJSONObjectPair virJSONObjectPair;
50
51 typedef struct _virJSONArray virJSONArray;
52
53
54 struct _virJSONObjectPair {
55 char *key;
56 virJSONValue *value;
57 };
58
59 struct _virJSONObject {
60 size_t npairs;
61 virJSONObjectPair *pairs;
62 };
63
64 struct _virJSONArray {
65 size_t nvalues;
66 virJSONValue **values;
67 };
68
69 struct _virJSONValue {
70 int type; /* enum virJSONType */
71
72 union {
73 virJSONObject object;
74 virJSONArray array;
75 char *string;
76 char *number; /* int/float/etc format is context defined so we can't parse it here :-( */
77 int boolean;
78 } data;
79 };
80
81
82 typedef struct _virJSONParserState virJSONParserState;
83 struct _virJSONParserState {
84 virJSONValue *value;
85 char *key;
86 };
87
88 typedef struct _virJSONParser virJSONParser;
89 struct _virJSONParser {
90 virJSONValue *head;
91 virJSONParserState *state;
92 size_t nstate;
93 int wrap;
94 };
95
96
97 virJSONType
virJSONValueGetType(const virJSONValue * value)98 virJSONValueGetType(const virJSONValue *value)
99 {
100 return value->type;
101 }
102
103
104 /**
105 * virJSONValueObjectAddVArgs:
106 * @objptr: pointer to a pointer to a JSON object to add the values to
107 * @args: a key-value argument pairs, terminated by NULL
108 *
109 * Adds the key-value pairs supplied as variable argument list to @obj.
110 *
111 * Keys look like s:name the first letter is a type code:
112 * Explanation of type codes:
113 * s: string value, must be non-null
114 * S: string value, omitted if null
115 *
116 * i: signed integer value
117 * j: signed integer value, error if negative
118 * k: signed integer value, omitted if negative
119 * z: signed integer value, omitted if zero
120 * y: signed integer value, omitted if zero, error if negative
121 *
122 * I: signed long integer value
123 * J: signed long integer value, error if negative
124 * Z: signed long integer value, omitted if zero
125 * Y: signed long integer value, omitted if zero, error if negative
126 *
127 * u: unsigned integer value
128 * p: unsigned integer value, omitted if zero
129 *
130 * U: unsigned long integer value (see below for quirks)
131 * P: unsigned long integer value, omitted if zero
132 *
133 * b: boolean value
134 * B: boolean value, omitted if false
135 * T: boolean value specified by a virTristate(Bool|Switch) value, omitted on
136 * the _ABSENT value
137 *
138 * d: double precision floating point number
139 * n: json null value
140 *
141 * The following two cases take a pointer to a pointer to a virJSONValue *. The
142 * pointer is cleared when the virJSONValue *is stolen into the object.
143 * a: json object, must be non-NULL
144 * A: json object, omitted if NULL
145 *
146 * m: a bitmap represented as a JSON array, must be non-NULL
147 * M: a bitmap represented as a JSON array, omitted if NULL
148 *
149 * The value corresponds to the selected type.
150 *
151 * Returns -1 on error. 1 on success, if at least one key:pair was valid 0
152 * in case of no error but nothing was filled.
153 */
154 int
virJSONValueObjectAddVArgs(virJSONValue ** objptr,va_list args)155 virJSONValueObjectAddVArgs(virJSONValue **objptr,
156 va_list args)
157 {
158 g_autoptr(virJSONValue) newobj = NULL;
159 virJSONValue *obj = *objptr;
160 char type;
161 char *key;
162 int rc;
163
164 if (obj == NULL)
165 newobj = obj = virJSONValueNewObject();
166
167 while ((key = va_arg(args, char *)) != NULL) {
168
169 if (strlen(key) < 3 || key[1] != ':') {
170 virReportError(VIR_ERR_INTERNAL_ERROR,
171 _("argument key '%s' is too short or malformed"),
172 key);
173 return -1;
174 }
175
176 type = key[0];
177 key += 2;
178
179 /* This doesn't support maps, but no command uses those. */
180 switch (type) {
181 case 'S':
182 case 's': {
183 char *val = va_arg(args, char *);
184 if (!val) {
185 if (type == 'S')
186 continue;
187
188 virReportError(VIR_ERR_INTERNAL_ERROR,
189 _("argument key '%s' must not have null value"),
190 key);
191 return -1;
192 }
193 rc = virJSONValueObjectAppendString(obj, key, val);
194 } break;
195
196 case 'z':
197 case 'y':
198 case 'k':
199 case 'j':
200 case 'i': {
201 int val = va_arg(args, int);
202
203 if (val < 0 && (type == 'j' || type == 'y')) {
204 virReportError(VIR_ERR_INTERNAL_ERROR,
205 _("argument key '%s' must not be negative"),
206 key);
207 return -1;
208 }
209
210 if (!val && (type == 'z' || type == 'y'))
211 continue;
212
213 if (val < 0 && type == 'k')
214 continue;
215
216 rc = virJSONValueObjectAppendNumberInt(obj, key, val);
217 } break;
218
219 case 'p':
220 case 'u': {
221 unsigned int val = va_arg(args, unsigned int);
222
223 if (!val && type == 'p')
224 continue;
225
226 rc = virJSONValueObjectAppendNumberUint(obj, key, val);
227 } break;
228
229 case 'Z':
230 case 'Y':
231 case 'J':
232 case 'I': {
233 long long val = va_arg(args, long long);
234
235 if (val < 0 && (type == 'J' || type == 'Y')) {
236 virReportError(VIR_ERR_INTERNAL_ERROR,
237 _("argument key '%s' must not be negative"),
238 key);
239 return -1;
240 }
241
242 if (!val && (type == 'Z' || type == 'Y'))
243 continue;
244
245 rc = virJSONValueObjectAppendNumberLong(obj, key, val);
246 } break;
247
248 case 'P':
249 case 'U': {
250 /* qemu silently truncates numbers larger than LLONG_MAX,
251 * so passing the full range of unsigned 64 bit integers
252 * is not safe here. Pass them as signed 64 bit integers
253 * instead.
254 */
255 long long val = va_arg(args, long long);
256
257 if (!val && type == 'P')
258 continue;
259
260 rc = virJSONValueObjectAppendNumberLong(obj, key, val);
261 } break;
262
263 case 'd': {
264 double val = va_arg(args, double);
265 rc = virJSONValueObjectAppendNumberDouble(obj, key, val);
266 } break;
267
268 case 'T':
269 case 'B':
270 case 'b': {
271 int val = va_arg(args, int);
272
273 if (!val && type == 'B')
274 continue;
275
276 if (type == 'T') {
277 if (val == VIR_TRISTATE_BOOL_ABSENT)
278 continue;
279
280 if (val == VIR_TRISTATE_BOOL_NO)
281 val = 0;
282 else
283 val = 1;
284 }
285
286 rc = virJSONValueObjectAppendBoolean(obj, key, val);
287 } break;
288
289 case 'n': {
290 rc = virJSONValueObjectAppendNull(obj, key);
291 } break;
292
293 case 'A':
294 case 'a': {
295 virJSONValue **val = va_arg(args, virJSONValue **);
296
297 if (!(*val)) {
298 if (type == 'A')
299 continue;
300
301 virReportError(VIR_ERR_INTERNAL_ERROR,
302 _("argument key '%s' must not have null value"),
303 key);
304 return -1;
305 }
306
307 rc = virJSONValueObjectAppend(obj, key, val);
308 } break;
309
310 case 'M':
311 case 'm': {
312 virBitmap *map = va_arg(args, virBitmap *);
313 g_autoptr(virJSONValue) jsonMap = virJSONValueNewArray();
314 ssize_t pos = -1;
315
316 if (!map) {
317 if (type == 'M')
318 continue;
319
320 virReportError(VIR_ERR_INTERNAL_ERROR,
321 _("argument key '%s' must not have null value"),
322 key);
323 return -1;
324 }
325
326 while ((pos = virBitmapNextSetBit(map, pos)) > -1) {
327 g_autoptr(virJSONValue) newelem = virJSONValueNewNumberLong(pos);
328
329 if (virJSONValueArrayAppend(jsonMap, &newelem) < 0)
330 return -1;
331 }
332
333 if ((rc = virJSONValueObjectAppend(obj, key, &jsonMap)) < 0)
334 return -1;
335 } break;
336
337 default:
338 virReportError(VIR_ERR_INTERNAL_ERROR,
339 _("unsupported data type '%c' for arg '%s'"), type, key - 2);
340 return -1;
341 }
342
343 if (rc < 0)
344 return -1;
345 }
346
347 /* verify that we added at least one key-value pair */
348 if (virJSONValueObjectKeysNumber(obj) == 0)
349 return 0;
350
351 if (newobj)
352 *objptr = g_steal_pointer(&newobj);
353
354 return 1;
355 }
356
357
358 int
virJSONValueObjectAdd(virJSONValue ** objptr,...)359 virJSONValueObjectAdd(virJSONValue **objptr, ...)
360 {
361 va_list args;
362 int ret;
363
364 va_start(args, objptr);
365 ret = virJSONValueObjectAddVArgs(objptr, args);
366 va_end(args);
367
368 return ret;
369 }
370
371
372 void
virJSONValueFree(virJSONValue * value)373 virJSONValueFree(virJSONValue *value)
374 {
375 size_t i;
376 if (!value)
377 return;
378
379 switch ((virJSONType) value->type) {
380 case VIR_JSON_TYPE_OBJECT:
381 for (i = 0; i < value->data.object.npairs; i++) {
382 g_free(value->data.object.pairs[i].key);
383 virJSONValueFree(value->data.object.pairs[i].value);
384 }
385 g_free(value->data.object.pairs);
386 break;
387 case VIR_JSON_TYPE_ARRAY:
388 for (i = 0; i < value->data.array.nvalues; i++)
389 virJSONValueFree(value->data.array.values[i]);
390 g_free(value->data.array.values);
391 break;
392 case VIR_JSON_TYPE_STRING:
393 g_free(value->data.string);
394 break;
395 case VIR_JSON_TYPE_NUMBER:
396 g_free(value->data.number);
397 break;
398 case VIR_JSON_TYPE_BOOLEAN:
399 case VIR_JSON_TYPE_NULL:
400 break;
401 }
402
403 g_free(value);
404 }
405
406
407 void
virJSONValueHashFree(void * opaque)408 virJSONValueHashFree(void *opaque)
409 {
410 virJSONValueFree(opaque);
411 }
412
413
414 virJSONValue *
virJSONValueNewString(const char * data)415 virJSONValueNewString(const char *data)
416 {
417 virJSONValue *val;
418
419 if (!data)
420 return virJSONValueNewNull();
421
422 val = g_new0(virJSONValue, 1);
423
424 val->type = VIR_JSON_TYPE_STRING;
425 val->data.string = g_strdup(data);
426
427 return val;
428 }
429
430
431 virJSONValue *
virJSONValueNewStringLen(const char * data,size_t length)432 virJSONValueNewStringLen(const char *data,
433 size_t length)
434 {
435 virJSONValue *val;
436
437 if (!data)
438 return virJSONValueNewNull();
439
440 val = g_new0(virJSONValue, 1);
441
442 val->type = VIR_JSON_TYPE_STRING;
443 val->data.string = g_strndup(data, length);
444
445 return val;
446 }
447
448
449 /**
450 * virJSONValueNewNumber:
451 * @data: string representing the number
452 *
453 * Creates a new virJSONValue of VIR_JSON_TYPE_NUMBER type. Note that this
454 * function takes ownership of @data.
455 */
456 static virJSONValue *
virJSONValueNewNumber(char * data)457 virJSONValueNewNumber(char *data)
458 {
459 virJSONValue *val;
460
461 val = g_new0(virJSONValue, 1);
462
463 val->type = VIR_JSON_TYPE_NUMBER;
464 val->data.number = data;
465
466 return val;
467 }
468
469
470 virJSONValue *
virJSONValueNewNumberInt(int data)471 virJSONValueNewNumberInt(int data)
472 {
473 return virJSONValueNewNumber(g_strdup_printf("%i", data));
474 }
475
476
477 virJSONValue *
virJSONValueNewNumberUint(unsigned int data)478 virJSONValueNewNumberUint(unsigned int data)
479 {
480 return virJSONValueNewNumber(g_strdup_printf("%u", data));
481 }
482
483
484 virJSONValue *
virJSONValueNewNumberLong(long long data)485 virJSONValueNewNumberLong(long long data)
486 {
487 return virJSONValueNewNumber(g_strdup_printf("%lld", data));
488 }
489
490
491 virJSONValue *
virJSONValueNewNumberUlong(unsigned long long data)492 virJSONValueNewNumberUlong(unsigned long long data)
493 {
494 return virJSONValueNewNumber(g_strdup_printf("%llu", data));
495 }
496
497
498 virJSONValue *
virJSONValueNewNumberDouble(double data)499 virJSONValueNewNumberDouble(double data)
500 {
501 char *str = NULL;
502 if (virDoubleToStr(&str, data) < 0)
503 return NULL;
504 return virJSONValueNewNumber(str);
505 }
506
507
508 virJSONValue *
virJSONValueNewBoolean(int boolean_)509 virJSONValueNewBoolean(int boolean_)
510 {
511 virJSONValue *val;
512
513 val = g_new0(virJSONValue, 1);
514
515 val->type = VIR_JSON_TYPE_BOOLEAN;
516 val->data.boolean = boolean_;
517
518 return val;
519 }
520
521
522 virJSONValue *
virJSONValueNewNull(void)523 virJSONValueNewNull(void)
524 {
525 virJSONValue *val;
526
527 val = g_new0(virJSONValue, 1);
528
529 val->type = VIR_JSON_TYPE_NULL;
530
531 return val;
532 }
533
534
535 virJSONValue *
virJSONValueNewArray(void)536 virJSONValueNewArray(void)
537 {
538 virJSONValue *val = g_new0(virJSONValue, 1);
539
540 val->type = VIR_JSON_TYPE_ARRAY;
541
542 return val;
543 }
544
545
546 virJSONValue *
virJSONValueNewObject(void)547 virJSONValueNewObject(void)
548 {
549 virJSONValue *val = g_new0(virJSONValue, 1);
550
551 val->type = VIR_JSON_TYPE_OBJECT;
552
553 return val;
554 }
555
556
557 static int
virJSONValueObjectInsert(virJSONValue * object,const char * key,virJSONValue ** value,bool prepend)558 virJSONValueObjectInsert(virJSONValue *object,
559 const char *key,
560 virJSONValue **value,
561 bool prepend)
562 {
563 virJSONObjectPair pair = { NULL, *value };
564 int ret = -1;
565
566 if (object->type != VIR_JSON_TYPE_OBJECT) {
567 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
568 _("expecting JSON object"));
569 return -1;
570 }
571
572 if (virJSONValueObjectHasKey(object, key)) {
573 virReportError(VIR_ERR_INTERNAL_ERROR, _("duplicate key '%s'"), key);
574 return -1;
575 }
576
577 pair.key = g_strdup(key);
578
579 if (prepend) {
580 ret = VIR_INSERT_ELEMENT(object->data.object.pairs, 0,
581 object->data.object.npairs, pair);
582 } else {
583 VIR_APPEND_ELEMENT(object->data.object.pairs,
584 object->data.object.npairs, pair);
585 ret = 0;
586 }
587
588 if (ret == 0)
589 *value = NULL;
590
591 VIR_FREE(pair.key);
592 return ret;
593 }
594
595
596 int
virJSONValueObjectAppend(virJSONValue * object,const char * key,virJSONValue ** value)597 virJSONValueObjectAppend(virJSONValue *object,
598 const char *key,
599 virJSONValue **value)
600 {
601 return virJSONValueObjectInsert(object, key, value, false);
602 }
603
604
605 static int
virJSONValueObjectInsertString(virJSONValue * object,const char * key,const char * value,bool prepend)606 virJSONValueObjectInsertString(virJSONValue *object,
607 const char *key,
608 const char *value,
609 bool prepend)
610 {
611 virJSONValue *jvalue = virJSONValueNewString(value);
612 if (!jvalue)
613 return -1;
614 if (virJSONValueObjectInsert(object, key, &jvalue, prepend) < 0)
615 return -1;
616 return 0;
617 }
618
619
620 int
virJSONValueObjectAppendString(virJSONValue * object,const char * key,const char * value)621 virJSONValueObjectAppendString(virJSONValue *object,
622 const char *key,
623 const char *value)
624 {
625 return virJSONValueObjectInsertString(object, key, value, false);
626 }
627
628
629 int
virJSONValueObjectAppendStringPrintf(virJSONValue * object,const char * key,const char * fmt,...)630 virJSONValueObjectAppendStringPrintf(virJSONValue *object,
631 const char *key,
632 const char *fmt,
633 ...)
634 {
635 va_list ap;
636 g_autofree char *str = NULL;
637
638 va_start(ap, fmt);
639 str = g_strdup_vprintf(fmt, ap);
640 va_end(ap);
641
642 return virJSONValueObjectInsertString(object, key, str, false);
643 }
644
645
646 int
virJSONValueObjectPrependString(virJSONValue * object,const char * key,const char * value)647 virJSONValueObjectPrependString(virJSONValue *object,
648 const char *key,
649 const char *value)
650 {
651 return virJSONValueObjectInsertString(object, key, value, true);
652 }
653
654
655 int
virJSONValueObjectAppendNumberInt(virJSONValue * object,const char * key,int number)656 virJSONValueObjectAppendNumberInt(virJSONValue *object,
657 const char *key,
658 int number)
659 {
660 g_autoptr(virJSONValue) jvalue = virJSONValueNewNumberInt(number);
661
662 if (virJSONValueObjectAppend(object, key, &jvalue) < 0)
663 return -1;
664
665 return 0;
666 }
667
668
669 int
virJSONValueObjectAppendNumberUint(virJSONValue * object,const char * key,unsigned int number)670 virJSONValueObjectAppendNumberUint(virJSONValue *object,
671 const char *key,
672 unsigned int number)
673 {
674 g_autoptr(virJSONValue) jvalue = virJSONValueNewNumberUint(number);
675
676 if (virJSONValueObjectAppend(object, key, &jvalue) < 0)
677 return -1;
678
679 return 0;
680 }
681
682
683 int
virJSONValueObjectAppendNumberLong(virJSONValue * object,const char * key,long long number)684 virJSONValueObjectAppendNumberLong(virJSONValue *object,
685 const char *key,
686 long long number)
687 {
688 g_autoptr(virJSONValue) jvalue = virJSONValueNewNumberLong(number);
689
690 if (virJSONValueObjectAppend(object, key, &jvalue) < 0)
691 return -1;
692
693 return 0;
694 }
695
696
697 int
virJSONValueObjectAppendNumberUlong(virJSONValue * object,const char * key,unsigned long long number)698 virJSONValueObjectAppendNumberUlong(virJSONValue *object,
699 const char *key,
700 unsigned long long number)
701 {
702 g_autoptr(virJSONValue) jvalue = virJSONValueNewNumberUlong(number);
703
704 if (virJSONValueObjectAppend(object, key, &jvalue) < 0)
705 return -1;
706
707 return 0;
708 }
709
710
711 int
virJSONValueObjectAppendNumberDouble(virJSONValue * object,const char * key,double number)712 virJSONValueObjectAppendNumberDouble(virJSONValue *object,
713 const char *key,
714 double number)
715 {
716 g_autoptr(virJSONValue) jvalue = virJSONValueNewNumberDouble(number);
717
718 /* virJSONValueNewNumberDouble may return NULL if locale setting fails */
719 if (!jvalue)
720 return -1;
721
722 if (virJSONValueObjectAppend(object, key, &jvalue) < 0)
723 return -1;
724
725 return 0;
726 }
727
728
729 int
virJSONValueObjectAppendBoolean(virJSONValue * object,const char * key,int boolean_)730 virJSONValueObjectAppendBoolean(virJSONValue *object,
731 const char *key,
732 int boolean_)
733 {
734 g_autoptr(virJSONValue) jvalue = virJSONValueNewBoolean(boolean_);
735
736 if (virJSONValueObjectAppend(object, key, &jvalue) < 0)
737 return -1;
738
739 return 0;
740 }
741
742
743 int
virJSONValueObjectAppendNull(virJSONValue * object,const char * key)744 virJSONValueObjectAppendNull(virJSONValue *object,
745 const char *key)
746 {
747 g_autoptr(virJSONValue) jvalue = virJSONValueNewNull();
748
749 if (virJSONValueObjectAppend(object, key, &jvalue) < 0)
750 return -1;
751
752 return 0;
753 }
754
755
756 int
virJSONValueArrayAppend(virJSONValue * array,virJSONValue ** value)757 virJSONValueArrayAppend(virJSONValue *array,
758 virJSONValue **value)
759 {
760 if (array->type != VIR_JSON_TYPE_ARRAY) {
761 virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("expecting JSON array"));
762 return -1;
763 }
764
765 VIR_REALLOC_N(array->data.array.values, array->data.array.nvalues + 1);
766
767 array->data.array.values[array->data.array.nvalues] = g_steal_pointer(value);
768 array->data.array.nvalues++;
769
770 return 0;
771 }
772
773
774 int
virJSONValueArrayAppendString(virJSONValue * object,const char * value)775 virJSONValueArrayAppendString(virJSONValue *object,
776 const char *value)
777 {
778 g_autoptr(virJSONValue) jvalue = virJSONValueNewString(value);
779
780 if (virJSONValueArrayAppend(object, &jvalue) < 0)
781 return -1;
782
783 return 0;
784 }
785
786
787 /**
788 * virJSONValueArrayConcat:
789 * @a: JSON value array (destination)
790 * @c: JSON value array (source)
791 *
792 * Merges the members of @c array into @a. The values are stolen from @c.
793 */
794 int
virJSONValueArrayConcat(virJSONValue * a,virJSONValue * c)795 virJSONValueArrayConcat(virJSONValue *a,
796 virJSONValue *c)
797 {
798 size_t i;
799
800 if (a->type != VIR_JSON_TYPE_ARRAY ||
801 c->type != VIR_JSON_TYPE_ARRAY) {
802 virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("expecting JSON array"));
803 return -1;
804 }
805
806 a->data.array.values = g_renew(virJSONValue *, a->data.array.values,
807 a->data.array.nvalues + c->data.array.nvalues);
808
809 for (i = 0; i < c->data.array.nvalues; i++)
810 a->data.array.values[a->data.array.nvalues++] = g_steal_pointer(&c->data.array.values[i]);
811
812 c->data.array.nvalues = 0;
813
814 return 0;
815 }
816
817
818 int
virJSONValueObjectHasKey(virJSONValue * object,const char * key)819 virJSONValueObjectHasKey(virJSONValue *object,
820 const char *key)
821 {
822 size_t i;
823
824 if (object->type != VIR_JSON_TYPE_OBJECT)
825 return -1;
826
827 for (i = 0; i < object->data.object.npairs; i++) {
828 if (STREQ(object->data.object.pairs[i].key, key))
829 return 1;
830 }
831
832 return 0;
833 }
834
835
836 virJSONValue *
virJSONValueObjectGet(virJSONValue * object,const char * key)837 virJSONValueObjectGet(virJSONValue *object,
838 const char *key)
839 {
840 size_t i;
841
842 if (object->type != VIR_JSON_TYPE_OBJECT)
843 return NULL;
844
845 for (i = 0; i < object->data.object.npairs; i++) {
846 if (STREQ(object->data.object.pairs[i].key, key))
847 return object->data.object.pairs[i].value;
848 }
849
850 return NULL;
851 }
852
853
854 /* Return the value associated with KEY within OBJECT, but return NULL
855 * if the key is missing or if value is not the correct TYPE. */
856 virJSONValue *
virJSONValueObjectGetByType(virJSONValue * object,const char * key,virJSONType type)857 virJSONValueObjectGetByType(virJSONValue *object,
858 const char *key,
859 virJSONType type)
860 {
861 virJSONValue *value = virJSONValueObjectGet(object, key);
862
863 if (value && value->type == type)
864 return value;
865 return NULL;
866 }
867
868
869 /* Steal the value associated with KEY within OBJECT, but return NULL
870 * if the key is missing or if value is not the correct TYPE. */
871 static virJSONValue *
virJSONValueObjectStealByType(virJSONValue * object,const char * key,virJSONType type)872 virJSONValueObjectStealByType(virJSONValue *object,
873 const char *key,
874 virJSONType type)
875 {
876 virJSONValue *value;
877
878 if (virJSONValueObjectRemoveKey(object, key, &value) <= 0)
879 return NULL;
880
881 if (value && value->type == type)
882 return value;
883 return NULL;
884 }
885
886
887 int
virJSONValueObjectKeysNumber(virJSONValue * object)888 virJSONValueObjectKeysNumber(virJSONValue *object)
889 {
890 if (object->type != VIR_JSON_TYPE_OBJECT)
891 return -1;
892
893 return object->data.object.npairs;
894 }
895
896
897 const char *
virJSONValueObjectGetKey(virJSONValue * object,unsigned int n)898 virJSONValueObjectGetKey(virJSONValue *object,
899 unsigned int n)
900 {
901 if (object->type != VIR_JSON_TYPE_OBJECT)
902 return NULL;
903
904 if (n >= object->data.object.npairs)
905 return NULL;
906
907 return object->data.object.pairs[n].key;
908 }
909
910
911 /* Remove the key-value pair tied to @key out of @object. If @value is
912 * not NULL, the dropped value object is returned instead of freed.
913 * Returns 1 on success, 0 if no key was found, and -1 on error. */
914 int
virJSONValueObjectRemoveKey(virJSONValue * object,const char * key,virJSONValue ** value)915 virJSONValueObjectRemoveKey(virJSONValue *object,
916 const char *key,
917 virJSONValue **value)
918 {
919 size_t i;
920
921 if (value)
922 *value = NULL;
923
924 if (object->type != VIR_JSON_TYPE_OBJECT)
925 return -1;
926
927 for (i = 0; i < object->data.object.npairs; i++) {
928 if (STREQ(object->data.object.pairs[i].key, key)) {
929 if (value) {
930 *value = g_steal_pointer(&object->data.object.pairs[i].value);
931 }
932 VIR_FREE(object->data.object.pairs[i].key);
933 virJSONValueFree(object->data.object.pairs[i].value);
934 VIR_DELETE_ELEMENT(object->data.object.pairs, i,
935 object->data.object.npairs);
936 return 1;
937 }
938 }
939
940 return 0;
941 }
942
943
944 virJSONValue *
virJSONValueObjectGetValue(virJSONValue * object,unsigned int n)945 virJSONValueObjectGetValue(virJSONValue *object,
946 unsigned int n)
947 {
948 if (object->type != VIR_JSON_TYPE_OBJECT)
949 return NULL;
950
951 if (n >= object->data.object.npairs)
952 return NULL;
953
954 return object->data.object.pairs[n].value;
955 }
956
957
958 bool
virJSONValueIsObject(virJSONValue * object)959 virJSONValueIsObject(virJSONValue *object)
960 {
961 if (object)
962 return object->type == VIR_JSON_TYPE_OBJECT;
963 else
964 return false;
965 }
966
967
968 bool
virJSONValueIsArray(virJSONValue * array)969 virJSONValueIsArray(virJSONValue *array)
970 {
971 return array->type == VIR_JSON_TYPE_ARRAY;
972 }
973
974
975 size_t
virJSONValueArraySize(const virJSONValue * array)976 virJSONValueArraySize(const virJSONValue *array)
977 {
978 return array->data.array.nvalues;
979 }
980
981
982 virJSONValue *
virJSONValueArrayGet(virJSONValue * array,unsigned int element)983 virJSONValueArrayGet(virJSONValue *array,
984 unsigned int element)
985 {
986 if (array->type != VIR_JSON_TYPE_ARRAY)
987 return NULL;
988
989 if (element >= array->data.array.nvalues)
990 return NULL;
991
992 return array->data.array.values[element];
993 }
994
995
996 virJSONValue *
virJSONValueArraySteal(virJSONValue * array,unsigned int element)997 virJSONValueArraySteal(virJSONValue *array,
998 unsigned int element)
999 {
1000 virJSONValue *ret = NULL;
1001
1002 if (array->type != VIR_JSON_TYPE_ARRAY)
1003 return NULL;
1004
1005 if (element >= array->data.array.nvalues)
1006 return NULL;
1007
1008 ret = array->data.array.values[element];
1009
1010 VIR_DELETE_ELEMENT(array->data.array.values,
1011 element,
1012 array->data.array.nvalues);
1013
1014 return ret;
1015 }
1016
1017
1018 /**
1019 * virJSONValueArrayForeachSteal:
1020 * @array: array to iterate
1021 * @cb: callback called on every member of the array
1022 * @opaque: custom data for the callback
1023 *
1024 * Iterates members of the array and calls the callback on every single member.
1025 * The return codes of the callback are interpreted as follows:
1026 * 0: callback claims ownership of the array element and is responsible for
1027 * freeing it
1028 * 1: callback doesn't claim ownership of the element
1029 * -1: callback doesn't claim ownership of the element and iteration does not
1030 * continue
1031 *
1032 * Returns 0 if all members were iterated and/or stolen by the callback; -1
1033 * on callback failure or if the JSON value object is not an array.
1034 * The rest of the members stay in possession of the array and it's condensed.
1035 */
1036 int
virJSONValueArrayForeachSteal(virJSONValue * array,virJSONArrayIteratorFunc cb,void * opaque)1037 virJSONValueArrayForeachSteal(virJSONValue *array,
1038 virJSONArrayIteratorFunc cb,
1039 void *opaque)
1040 {
1041 size_t i;
1042 size_t j = 0;
1043 int ret = 0;
1044 int rc;
1045
1046 if (array->type != VIR_JSON_TYPE_ARRAY)
1047 return -1;
1048
1049 for (i = 0; i < array->data.array.nvalues; i++) {
1050 if ((rc = cb(i, array->data.array.values[i], opaque)) < 0) {
1051 ret = -1;
1052 break;
1053 }
1054
1055 if (rc == 0)
1056 array->data.array.values[i] = NULL;
1057 }
1058
1059 /* condense the remaining entries at the beginning */
1060 for (i = 0; i < array->data.array.nvalues; i++) {
1061 if (!array->data.array.values[i])
1062 continue;
1063
1064 array->data.array.values[j++] = array->data.array.values[i];
1065 }
1066
1067 array->data.array.nvalues = j;
1068
1069 return ret;
1070 }
1071
1072
1073 const char *
virJSONValueGetString(virJSONValue * string)1074 virJSONValueGetString(virJSONValue *string)
1075 {
1076 if (string->type != VIR_JSON_TYPE_STRING)
1077 return NULL;
1078
1079 return string->data.string;
1080 }
1081
1082
1083 const char *
virJSONValueGetNumberString(virJSONValue * number)1084 virJSONValueGetNumberString(virJSONValue *number)
1085 {
1086 if (number->type != VIR_JSON_TYPE_NUMBER)
1087 return NULL;
1088
1089 return number->data.number;
1090 }
1091
1092
1093 int
virJSONValueGetNumberInt(virJSONValue * number,int * value)1094 virJSONValueGetNumberInt(virJSONValue *number,
1095 int *value)
1096 {
1097 if (number->type != VIR_JSON_TYPE_NUMBER)
1098 return -1;
1099
1100 return virStrToLong_i(number->data.number, NULL, 10, value);
1101 }
1102
1103
1104 int
virJSONValueGetNumberUint(virJSONValue * number,unsigned int * value)1105 virJSONValueGetNumberUint(virJSONValue *number,
1106 unsigned int *value)
1107 {
1108 if (number->type != VIR_JSON_TYPE_NUMBER)
1109 return -1;
1110
1111 return virStrToLong_ui(number->data.number, NULL, 10, value);
1112 }
1113
1114
1115 int
virJSONValueGetNumberLong(virJSONValue * number,long long * value)1116 virJSONValueGetNumberLong(virJSONValue *number,
1117 long long *value)
1118 {
1119 if (number->type != VIR_JSON_TYPE_NUMBER)
1120 return -1;
1121
1122 return virStrToLong_ll(number->data.number, NULL, 10, value);
1123 }
1124
1125
1126 int
virJSONValueGetNumberUlong(virJSONValue * number,unsigned long long * value)1127 virJSONValueGetNumberUlong(virJSONValue *number,
1128 unsigned long long *value)
1129 {
1130 if (number->type != VIR_JSON_TYPE_NUMBER)
1131 return -1;
1132
1133 return virStrToLong_ull(number->data.number, NULL, 10, value);
1134 }
1135
1136
1137 int
virJSONValueGetNumberDouble(virJSONValue * number,double * value)1138 virJSONValueGetNumberDouble(virJSONValue *number,
1139 double *value)
1140 {
1141 if (number->type != VIR_JSON_TYPE_NUMBER)
1142 return -1;
1143
1144 return virStrToDouble(number->data.number, NULL, value);
1145 }
1146
1147
1148 int
virJSONValueGetBoolean(virJSONValue * val,bool * value)1149 virJSONValueGetBoolean(virJSONValue *val,
1150 bool *value)
1151 {
1152 if (val->type != VIR_JSON_TYPE_BOOLEAN)
1153 return -1;
1154
1155 *value = val->data.boolean;
1156 return 0;
1157 }
1158
1159
1160 bool
virJSONValueIsNull(virJSONValue * val)1161 virJSONValueIsNull(virJSONValue *val)
1162 {
1163 return val->type == VIR_JSON_TYPE_NULL;
1164 }
1165
1166
1167 const char *
virJSONValueObjectGetString(virJSONValue * object,const char * key)1168 virJSONValueObjectGetString(virJSONValue *object,
1169 const char *key)
1170 {
1171 virJSONValue *val = virJSONValueObjectGet(object, key);
1172
1173 if (!val)
1174 return NULL;
1175
1176 return virJSONValueGetString(val);
1177 }
1178
1179
1180 /**
1181 * virJSONValueObjectGetStringOrNumber:
1182 * @object: JSON value object
1183 * @key: name of the property in @object to get
1184 *
1185 * Gets a property named @key from the JSON object @object. The value may be
1186 * a number or a string and is returned as a string. In cases when the property
1187 * is not present or is not a string or number NULL is returned.
1188 */
1189 const char *
virJSONValueObjectGetStringOrNumber(virJSONValue * object,const char * key)1190 virJSONValueObjectGetStringOrNumber(virJSONValue *object,
1191 const char *key)
1192 {
1193 virJSONValue *val = virJSONValueObjectGet(object, key);
1194
1195 if (!val)
1196 return NULL;
1197
1198 if (val->type == VIR_JSON_TYPE_STRING)
1199 return val->data.string;
1200 else if (val->type == VIR_JSON_TYPE_NUMBER)
1201 return val->data.number;
1202
1203 return NULL;
1204 }
1205
1206
1207 int
virJSONValueObjectGetNumberInt(virJSONValue * object,const char * key,int * value)1208 virJSONValueObjectGetNumberInt(virJSONValue *object,
1209 const char *key,
1210 int *value)
1211 {
1212 virJSONValue *val = virJSONValueObjectGet(object, key);
1213
1214 if (!val)
1215 return -1;
1216
1217 return virJSONValueGetNumberInt(val, value);
1218 }
1219
1220
1221 int
virJSONValueObjectGetNumberUint(virJSONValue * object,const char * key,unsigned int * value)1222 virJSONValueObjectGetNumberUint(virJSONValue *object,
1223 const char *key,
1224 unsigned int *value)
1225 {
1226 virJSONValue *val = virJSONValueObjectGet(object, key);
1227
1228 if (!val)
1229 return -1;
1230
1231 return virJSONValueGetNumberUint(val, value);
1232 }
1233
1234
1235 int
virJSONValueObjectGetNumberLong(virJSONValue * object,const char * key,long long * value)1236 virJSONValueObjectGetNumberLong(virJSONValue *object,
1237 const char *key,
1238 long long *value)
1239 {
1240 virJSONValue *val = virJSONValueObjectGet(object, key);
1241
1242 if (!val)
1243 return -1;
1244
1245 return virJSONValueGetNumberLong(val, value);
1246 }
1247
1248
1249 int
virJSONValueObjectGetNumberUlong(virJSONValue * object,const char * key,unsigned long long * value)1250 virJSONValueObjectGetNumberUlong(virJSONValue *object,
1251 const char *key,
1252 unsigned long long *value)
1253 {
1254 virJSONValue *val = virJSONValueObjectGet(object, key);
1255
1256 if (!val)
1257 return -1;
1258
1259 return virJSONValueGetNumberUlong(val, value);
1260 }
1261
1262
1263 int
virJSONValueObjectGetNumberDouble(virJSONValue * object,const char * key,double * value)1264 virJSONValueObjectGetNumberDouble(virJSONValue *object,
1265 const char *key,
1266 double *value)
1267 {
1268 virJSONValue *val = virJSONValueObjectGet(object, key);
1269
1270 if (!val)
1271 return -1;
1272
1273 return virJSONValueGetNumberDouble(val, value);
1274 }
1275
1276
1277 int
virJSONValueObjectGetBoolean(virJSONValue * object,const char * key,bool * value)1278 virJSONValueObjectGetBoolean(virJSONValue *object,
1279 const char *key,
1280 bool *value)
1281 {
1282 virJSONValue *val = virJSONValueObjectGet(object, key);
1283
1284 if (!val)
1285 return -1;
1286
1287 return virJSONValueGetBoolean(val, value);
1288 }
1289
1290
1291 virJSONValue *
virJSONValueObjectGetObject(virJSONValue * object,const char * key)1292 virJSONValueObjectGetObject(virJSONValue *object, const char *key)
1293 {
1294 return virJSONValueObjectGetByType(object, key, VIR_JSON_TYPE_OBJECT);
1295 }
1296
1297
1298 virJSONValue *
virJSONValueObjectGetArray(virJSONValue * object,const char * key)1299 virJSONValueObjectGetArray(virJSONValue *object, const char *key)
1300 {
1301 return virJSONValueObjectGetByType(object, key, VIR_JSON_TYPE_ARRAY);
1302 }
1303
1304
1305 virJSONValue *
virJSONValueObjectStealArray(virJSONValue * object,const char * key)1306 virJSONValueObjectStealArray(virJSONValue *object, const char *key)
1307 {
1308 return virJSONValueObjectStealByType(object, key, VIR_JSON_TYPE_ARRAY);
1309 }
1310
1311
1312 virJSONValue *
virJSONValueObjectStealObject(virJSONValue * object,const char * key)1313 virJSONValueObjectStealObject(virJSONValue *object,
1314 const char *key)
1315 {
1316 return virJSONValueObjectStealByType(object, key, VIR_JSON_TYPE_OBJECT);
1317 }
1318
1319
1320 int
virJSONValueObjectIsNull(virJSONValue * object,const char * key)1321 virJSONValueObjectIsNull(virJSONValue *object,
1322 const char *key)
1323 {
1324 virJSONValue *val = virJSONValueObjectGet(object, key);
1325
1326 if (!val)
1327 return -1;
1328
1329 return virJSONValueIsNull(val);
1330 }
1331
1332 char **
virJSONValueObjectGetStringArray(virJSONValue * object,const char * key)1333 virJSONValueObjectGetStringArray(virJSONValue *object, const char *key)
1334 {
1335 g_auto(GStrv) ret = NULL;
1336 virJSONValue *data;
1337 size_t n;
1338 size_t i;
1339
1340 data = virJSONValueObjectGetArray(object, key);
1341 if (!data) {
1342 virReportError(VIR_ERR_INTERNAL_ERROR,
1343 _("%s is missing or not an array"),
1344 key);
1345 return NULL;
1346 }
1347
1348 n = virJSONValueArraySize(data);
1349 ret = g_new0(char *, n + 1);
1350 for (i = 0; i < n; i++) {
1351 virJSONValue *child = virJSONValueArrayGet(data, i);
1352 const char *tmp;
1353
1354 if (!child) {
1355 virReportError(VIR_ERR_INTERNAL_ERROR,
1356 _("%s array element is missing item %zu"),
1357 key, i);
1358 return NULL;
1359 }
1360
1361 if (!(tmp = virJSONValueGetString(child))) {
1362 virReportError(VIR_ERR_INTERNAL_ERROR,
1363 _("%s array element does not contain a string"),
1364 key);
1365 return NULL;
1366 }
1367
1368 ret[i] = g_strdup(tmp);
1369 }
1370
1371 return g_steal_pointer(&ret);
1372 }
1373
1374 /**
1375 * virJSONValueObjectForeachKeyValue:
1376 * @object: JSON object to iterate
1377 * @cb: callback to call on key-value pairs contained in the object
1378 * @opaque: generic data for the callback
1379 *
1380 * Iterates all key=value pairs in @object. Iteration breaks if @cb returns
1381 * negative value.
1382 *
1383 * Returns 0 if all elements were iterated, -2 if @cb returned negative value
1384 * during iteration and -1 on generic errors.
1385 */
1386 int
virJSONValueObjectForeachKeyValue(virJSONValue * object,virJSONValueObjectIteratorFunc cb,void * opaque)1387 virJSONValueObjectForeachKeyValue(virJSONValue *object,
1388 virJSONValueObjectIteratorFunc cb,
1389 void *opaque)
1390 {
1391 size_t i;
1392
1393 if (object->type != VIR_JSON_TYPE_OBJECT)
1394 return -1;
1395
1396 for (i = 0; i < object->data.object.npairs; i++) {
1397 virJSONObjectPair *elem = object->data.object.pairs + i;
1398
1399 if (cb(elem->key, elem->value, opaque) < 0)
1400 return -2;
1401 }
1402
1403 return 0;
1404 }
1405
1406
1407 virJSONValue *
virJSONValueCopy(const virJSONValue * in)1408 virJSONValueCopy(const virJSONValue *in)
1409 {
1410 size_t i;
1411 virJSONValue *out = NULL;
1412
1413 if (!in)
1414 return NULL;
1415
1416 switch ((virJSONType) in->type) {
1417 case VIR_JSON_TYPE_OBJECT:
1418 out = virJSONValueNewObject();
1419
1420 out->data.object.pairs = g_new0(virJSONObjectPair, in->data.object.npairs);
1421 out->data.object.npairs = in->data.object.npairs;
1422
1423 for (i = 0; i < in->data.object.npairs; i++) {
1424 out->data.object.pairs[i].key = g_strdup(in->data.object.pairs[i].key);
1425 out->data.object.pairs[i].value = virJSONValueCopy(in->data.object.pairs[i].value);
1426 }
1427 break;
1428 case VIR_JSON_TYPE_ARRAY:
1429 out = virJSONValueNewArray();
1430
1431 out->data.array.values = g_new0(virJSONValue *, in->data.array.nvalues);
1432 out->data.array.nvalues = in->data.array.nvalues;
1433
1434 for (i = 0; i < in->data.array.nvalues; i++) {
1435 out->data.array.values[i] = virJSONValueCopy(in->data.array.values[i]);
1436 }
1437 break;
1438
1439 /* No need to error out in the following cases */
1440 case VIR_JSON_TYPE_STRING:
1441 out = virJSONValueNewString(in->data.string);
1442 break;
1443 case VIR_JSON_TYPE_NUMBER:
1444 out = virJSONValueNewNumber(g_strdup(in->data.number));
1445 break;
1446 case VIR_JSON_TYPE_BOOLEAN:
1447 out = virJSONValueNewBoolean(in->data.boolean);
1448 break;
1449 case VIR_JSON_TYPE_NULL:
1450 out = virJSONValueNewNull();
1451 break;
1452 }
1453
1454 return out;
1455 }
1456
1457
1458 #if WITH_YAJL
1459 static int
virJSONParserInsertValue(virJSONParser * parser,virJSONValue ** value)1460 virJSONParserInsertValue(virJSONParser *parser,
1461 virJSONValue **value)
1462 {
1463 if (!parser->head) {
1464 parser->head = g_steal_pointer(value);
1465 } else {
1466 virJSONParserState *state;
1467 if (!parser->nstate) {
1468 VIR_DEBUG("got a value to insert without a container");
1469 return -1;
1470 }
1471
1472 state = &parser->state[parser->nstate-1];
1473
1474 switch (state->value->type) {
1475 case VIR_JSON_TYPE_OBJECT: {
1476 if (!state->key) {
1477 VIR_DEBUG("missing key when inserting object value");
1478 return -1;
1479 }
1480
1481 if (virJSONValueObjectAppend(state->value,
1482 state->key,
1483 value) < 0)
1484 return -1;
1485
1486 VIR_FREE(state->key);
1487 } break;
1488
1489 case VIR_JSON_TYPE_ARRAY: {
1490 if (state->key) {
1491 VIR_DEBUG("unexpected key when inserting array value");
1492 return -1;
1493 }
1494
1495 if (virJSONValueArrayAppend(state->value,
1496 value) < 0)
1497 return -1;
1498 } break;
1499
1500 default:
1501 VIR_DEBUG("unexpected value type, not a container");
1502 return -1;
1503 }
1504 }
1505
1506 return 0;
1507 }
1508
1509
1510 static int
virJSONParserHandleNull(void * ctx)1511 virJSONParserHandleNull(void *ctx)
1512 {
1513 virJSONParser *parser = ctx;
1514 g_autoptr(virJSONValue) value = virJSONValueNewNull();
1515
1516 VIR_DEBUG("parser=%p", parser);
1517
1518 if (virJSONParserInsertValue(parser, &value) < 0)
1519 return 0;
1520
1521 return 1;
1522 }
1523
1524
1525 static int
virJSONParserHandleBoolean(void * ctx,int boolean_)1526 virJSONParserHandleBoolean(void *ctx,
1527 int boolean_)
1528 {
1529 virJSONParser *parser = ctx;
1530 g_autoptr(virJSONValue) value = virJSONValueNewBoolean(boolean_);
1531
1532 VIR_DEBUG("parser=%p boolean=%d", parser, boolean_);
1533
1534 if (virJSONParserInsertValue(parser, &value) < 0)
1535 return 0;
1536
1537 return 1;
1538 }
1539
1540
1541 static int
virJSONParserHandleNumber(void * ctx,const char * s,size_t l)1542 virJSONParserHandleNumber(void *ctx,
1543 const char *s,
1544 size_t l)
1545 {
1546 virJSONParser *parser = ctx;
1547 g_autoptr(virJSONValue) value = virJSONValueNewNumber(g_strndup(s, l));
1548
1549 VIR_DEBUG("parser=%p str=%s", parser, value->data.number);
1550
1551 if (virJSONParserInsertValue(parser, &value) < 0)
1552 return 0;
1553
1554 return 1;
1555 }
1556
1557
1558 static int
virJSONParserHandleString(void * ctx,const unsigned char * stringVal,size_t stringLen)1559 virJSONParserHandleString(void *ctx,
1560 const unsigned char *stringVal,
1561 size_t stringLen)
1562 {
1563 virJSONParser *parser = ctx;
1564 g_autoptr(virJSONValue) value = virJSONValueNewStringLen((const char *)stringVal,
1565 stringLen);
1566
1567 VIR_DEBUG("parser=%p str=%p", parser, (const char *)stringVal);
1568
1569 if (virJSONParserInsertValue(parser, &value) < 0)
1570 return 0;
1571
1572 return 1;
1573 }
1574
1575
1576 static int
virJSONParserHandleMapKey(void * ctx,const unsigned char * stringVal,size_t stringLen)1577 virJSONParserHandleMapKey(void *ctx,
1578 const unsigned char *stringVal,
1579 size_t stringLen)
1580 {
1581 virJSONParser *parser = ctx;
1582 virJSONParserState *state;
1583
1584 VIR_DEBUG("parser=%p key=%p", parser, (const char *)stringVal);
1585
1586 if (!parser->nstate)
1587 return 0;
1588
1589 state = &parser->state[parser->nstate-1];
1590 if (state->key)
1591 return 0;
1592 state->key = g_strndup((const char *)stringVal, stringLen);
1593 return 1;
1594 }
1595
1596
1597 static int
virJSONParserHandleStartMap(void * ctx)1598 virJSONParserHandleStartMap(void *ctx)
1599 {
1600 virJSONParser *parser = ctx;
1601 g_autoptr(virJSONValue) value = virJSONValueNewObject();
1602 virJSONValue *tmp = value;
1603
1604 VIR_DEBUG("parser=%p", parser);
1605
1606 if (virJSONParserInsertValue(parser, &value) < 0)
1607 return 0;
1608
1609 VIR_REALLOC_N(parser->state, parser->nstate + 1);
1610
1611 parser->state[parser->nstate].value = tmp;
1612 parser->state[parser->nstate].key = NULL;
1613 parser->nstate++;
1614
1615 return 1;
1616 }
1617
1618
1619 static int
virJSONParserHandleEndMap(void * ctx)1620 virJSONParserHandleEndMap(void *ctx)
1621 {
1622 virJSONParser *parser = ctx;
1623 virJSONParserState *state;
1624
1625 VIR_DEBUG("parser=%p", parser);
1626
1627 if (!parser->nstate)
1628 return 0;
1629
1630 state = &(parser->state[parser->nstate-1]);
1631 if (state->key) {
1632 VIR_FREE(state->key);
1633 return 0;
1634 }
1635
1636 VIR_DELETE_ELEMENT(parser->state, parser->nstate - 1, parser->nstate);
1637
1638 return 1;
1639 }
1640
1641
1642 static int
virJSONParserHandleStartArray(void * ctx)1643 virJSONParserHandleStartArray(void *ctx)
1644 {
1645 virJSONParser *parser = ctx;
1646 g_autoptr(virJSONValue) value = virJSONValueNewArray();
1647 virJSONValue *tmp = value;
1648
1649 VIR_DEBUG("parser=%p", parser);
1650
1651 if (virJSONParserInsertValue(parser, &value) < 0)
1652 return 0;
1653
1654 VIR_REALLOC_N(parser->state, parser->nstate + 1);
1655
1656 parser->state[parser->nstate].value = tmp;
1657 parser->state[parser->nstate].key = NULL;
1658 parser->nstate++;
1659
1660 return 1;
1661 }
1662
1663
1664 static int
virJSONParserHandleEndArray(void * ctx)1665 virJSONParserHandleEndArray(void *ctx)
1666 {
1667 virJSONParser *parser = ctx;
1668 virJSONParserState *state;
1669
1670 VIR_DEBUG("parser=%p", parser);
1671
1672 if (!(parser->nstate - parser->wrap))
1673 return 0;
1674
1675 state = &(parser->state[parser->nstate-1]);
1676 if (state->key) {
1677 VIR_FREE(state->key);
1678 return 0;
1679 }
1680
1681 VIR_DELETE_ELEMENT(parser->state, parser->nstate - 1, parser->nstate);
1682
1683 return 1;
1684 }
1685
1686
1687 static const yajl_callbacks parserCallbacks = {
1688 virJSONParserHandleNull,
1689 virJSONParserHandleBoolean,
1690 NULL,
1691 NULL,
1692 virJSONParserHandleNumber,
1693 virJSONParserHandleString,
1694 virJSONParserHandleStartMap,
1695 virJSONParserHandleMapKey,
1696 virJSONParserHandleEndMap,
1697 virJSONParserHandleStartArray,
1698 virJSONParserHandleEndArray
1699 };
1700
1701
1702 /* XXX add an incremental streaming parser - yajl trivially supports it */
1703 virJSONValue *
virJSONValueFromString(const char * jsonstring)1704 virJSONValueFromString(const char *jsonstring)
1705 {
1706 yajl_handle hand;
1707 virJSONParser parser = { NULL, NULL, 0, 0 };
1708 virJSONValue *ret = NULL;
1709 int rc;
1710 size_t len = strlen(jsonstring);
1711
1712 VIR_DEBUG("string=%s", jsonstring);
1713
1714 hand = yajl_alloc(&parserCallbacks, NULL, &parser);
1715 if (!hand) {
1716 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
1717 _("Unable to create JSON parser"));
1718 return NULL;
1719 }
1720
1721 /* Yajl 2 is nice enough to default to rejecting trailing garbage. */
1722 rc = yajl_parse(hand, (const unsigned char *)jsonstring, len);
1723 if (rc != yajl_status_ok ||
1724 yajl_complete_parse(hand) != yajl_status_ok) {
1725 unsigned char *errstr = yajl_get_error(hand, 1,
1726 (const unsigned char*)jsonstring,
1727 strlen(jsonstring));
1728
1729 virReportError(VIR_ERR_INTERNAL_ERROR,
1730 _("cannot parse json %s: %s"),
1731 jsonstring, (const char*) errstr);
1732 yajl_free_error(hand, errstr);
1733 virJSONValueFree(parser.head);
1734 goto cleanup;
1735 }
1736
1737 if (parser.nstate != 0) {
1738 virReportError(VIR_ERR_INTERNAL_ERROR,
1739 _("cannot parse json %s: unterminated string/map/array"),
1740 jsonstring);
1741 virJSONValueFree(parser.head);
1742 } else {
1743 ret = parser.head;
1744 }
1745
1746 cleanup:
1747 yajl_free(hand);
1748
1749 if (parser.nstate) {
1750 size_t i;
1751 for (i = 0; i < parser.nstate; i++)
1752 VIR_FREE(parser.state[i].key);
1753 VIR_FREE(parser.state);
1754 }
1755
1756 VIR_DEBUG("result=%p", ret);
1757
1758 return ret;
1759 }
1760
1761
1762 static int
virJSONValueToStringOne(virJSONValue * object,yajl_gen g)1763 virJSONValueToStringOne(virJSONValue *object,
1764 yajl_gen g)
1765 {
1766 size_t i;
1767
1768 VIR_DEBUG("object=%p type=%d gen=%p", object, object->type, g);
1769
1770 switch (object->type) {
1771 case VIR_JSON_TYPE_OBJECT:
1772 if (yajl_gen_map_open(g) != yajl_gen_status_ok)
1773 return -1;
1774 for (i = 0; i < object->data.object.npairs; i++) {
1775 if (yajl_gen_string(g,
1776 (unsigned char *)object->data.object.pairs[i].key,
1777 strlen(object->data.object.pairs[i].key))
1778 != yajl_gen_status_ok)
1779 return -1;
1780 if (virJSONValueToStringOne(object->data.object.pairs[i].value, g) < 0)
1781 return -1;
1782 }
1783 if (yajl_gen_map_close(g) != yajl_gen_status_ok)
1784 return -1;
1785 break;
1786 case VIR_JSON_TYPE_ARRAY:
1787 if (yajl_gen_array_open(g) != yajl_gen_status_ok)
1788 return -1;
1789 for (i = 0; i < object->data.array.nvalues; i++) {
1790 if (virJSONValueToStringOne(object->data.array.values[i], g) < 0)
1791 return -1;
1792 }
1793 if (yajl_gen_array_close(g) != yajl_gen_status_ok)
1794 return -1;
1795 break;
1796
1797 case VIR_JSON_TYPE_STRING:
1798 if (yajl_gen_string(g, (unsigned char *)object->data.string,
1799 strlen(object->data.string)) != yajl_gen_status_ok)
1800 return -1;
1801 break;
1802
1803 case VIR_JSON_TYPE_NUMBER:
1804 if (yajl_gen_number(g, object->data.number,
1805 strlen(object->data.number)) != yajl_gen_status_ok)
1806 return -1;
1807 break;
1808
1809 case VIR_JSON_TYPE_BOOLEAN:
1810 if (yajl_gen_bool(g, object->data.boolean) != yajl_gen_status_ok)
1811 return -1;
1812 break;
1813
1814 case VIR_JSON_TYPE_NULL:
1815 if (yajl_gen_null(g) != yajl_gen_status_ok)
1816 return -1;
1817 break;
1818
1819 default:
1820 return -1;
1821 }
1822
1823 return 0;
1824 }
1825
1826
1827 int
virJSONValueToBuffer(virJSONValue * object,virBuffer * buf,bool pretty)1828 virJSONValueToBuffer(virJSONValue *object,
1829 virBuffer *buf,
1830 bool pretty)
1831 {
1832 yajl_gen g;
1833 const unsigned char *str;
1834 size_t len;
1835 int ret = -1;
1836
1837 VIR_DEBUG("object=%p", object);
1838
1839 g = yajl_gen_alloc(NULL);
1840 if (!g) {
1841 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
1842 _("Unable to create JSON formatter"));
1843 goto cleanup;
1844 }
1845 yajl_gen_config(g, yajl_gen_beautify, pretty ? 1 : 0);
1846 yajl_gen_config(g, yajl_gen_indent_string, pretty ? " " : " ");
1847 yajl_gen_config(g, yajl_gen_validate_utf8, 1);
1848
1849 if (virJSONValueToStringOne(object, g) < 0) {
1850 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
1851 _("failed to convert virJSONValue to yajl data"));
1852 goto cleanup;
1853 }
1854
1855 if (yajl_gen_get_buf(g, &str, &len) != yajl_gen_status_ok) {
1856 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
1857 _("failed to format JSON"));
1858 goto cleanup;
1859 }
1860
1861 virBufferAdd(buf, (const char *) str, len);
1862 ret = 0;
1863
1864 cleanup:
1865 yajl_gen_free(g);
1866
1867 return ret;
1868 }
1869
1870
1871 #else
1872 virJSONValue *
virJSONValueFromString(const char * jsonstring G_GNUC_UNUSED)1873 virJSONValueFromString(const char *jsonstring G_GNUC_UNUSED)
1874 {
1875 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
1876 _("No JSON parser implementation is available"));
1877 return NULL;
1878 }
1879
1880
1881 int
virJSONValueToBuffer(virJSONValue * object G_GNUC_UNUSED,virBuffer * buf G_GNUC_UNUSED,bool pretty G_GNUC_UNUSED)1882 virJSONValueToBuffer(virJSONValue *object G_GNUC_UNUSED,
1883 virBuffer *buf G_GNUC_UNUSED,
1884 bool pretty G_GNUC_UNUSED)
1885 {
1886 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
1887 _("No JSON parser implementation is available"));
1888 return -1;
1889 }
1890 #endif
1891
1892
1893 char *
virJSONValueToString(virJSONValue * object,bool pretty)1894 virJSONValueToString(virJSONValue *object,
1895 bool pretty)
1896 {
1897 g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
1898
1899 if (virJSONValueToBuffer(object, &buf, pretty) < 0)
1900 return NULL;
1901
1902 return virBufferContentAndReset(&buf);
1903 }
1904
1905
1906 /**
1907 * virJSONStringReformat:
1908 * @jsonstr: string to reformat
1909 * @pretty: use the pretty formatter
1910 *
1911 * Reformats a JSON string by passing it to the parser and then to the
1912 * formatter. If @pretty is true the JSON is formatted for human eye
1913 * compatibility.
1914 *
1915 * Returns the reformatted JSON string on success; NULL and a libvirt error on
1916 * failure.
1917 */
1918 char *
virJSONStringReformat(const char * jsonstr,bool pretty)1919 virJSONStringReformat(const char *jsonstr,
1920 bool pretty)
1921 {
1922 g_autoptr(virJSONValue) json = NULL;
1923
1924 if (!(json = virJSONValueFromString(jsonstr)))
1925 return NULL;
1926
1927 return virJSONValueToString(json, pretty);
1928 }
1929
1930
1931 static virJSONValue *
1932 virJSONValueObjectDeflattenKeys(virJSONValue *json);
1933
1934
1935 static int
virJSONValueObjectDeflattenWorker(const char * key,virJSONValue * value,void * opaque)1936 virJSONValueObjectDeflattenWorker(const char *key,
1937 virJSONValue *value,
1938 void *opaque)
1939 {
1940 virJSONValue *retobj = opaque;
1941 g_autoptr(virJSONValue) newval = NULL;
1942 virJSONValue *existobj;
1943 g_auto(GStrv) tokens = NULL;
1944
1945 /* non-nested keys only need to be copied */
1946 if (!strchr(key, '.')) {
1947
1948 if (virJSONValueIsObject(value))
1949 newval = virJSONValueObjectDeflattenKeys(value);
1950 else
1951 newval = virJSONValueCopy(value);
1952
1953 if (!newval)
1954 return -1;
1955
1956 if (virJSONValueObjectHasKey(retobj, key)) {
1957 virReportError(VIR_ERR_INVALID_ARG,
1958 _("can't deflatten colliding key '%s'"), key);
1959 return -1;
1960 }
1961
1962 if (virJSONValueObjectAppend(retobj, key, &newval) < 0)
1963 return -1;
1964
1965 return 0;
1966 }
1967
1968 if (!(tokens = g_strsplit(key, ".", 2)))
1969 return -1;
1970
1971 if (!tokens[0] || !tokens[1]) {
1972 virReportError(VIR_ERR_INVALID_ARG,
1973 _("invalid nested value key '%s'"), key);
1974 return -1;
1975 }
1976
1977 if (!(existobj = virJSONValueObjectGet(retobj, tokens[0]))) {
1978 virJSONValue *newobj = virJSONValueNewObject();
1979 existobj = newobj;
1980
1981 if (virJSONValueObjectAppend(retobj, tokens[0], &newobj) < 0)
1982 return -1;
1983
1984 } else {
1985 if (!virJSONValueIsObject(existobj)) {
1986 virReportError(VIR_ERR_INVALID_ARG, "%s",
1987 _("mixing nested objects and values is forbidden in "
1988 "JSON deflattening"));
1989 return -1;
1990 }
1991 }
1992
1993 return virJSONValueObjectDeflattenWorker(tokens[1], value, existobj);
1994 }
1995
1996
1997 static virJSONValue *
virJSONValueObjectDeflattenKeys(virJSONValue * json)1998 virJSONValueObjectDeflattenKeys(virJSONValue *json)
1999 {
2000 g_autoptr(virJSONValue) deflattened = virJSONValueNewObject();
2001
2002 if (virJSONValueObjectForeachKeyValue(json,
2003 virJSONValueObjectDeflattenWorker,
2004 deflattened) < 0)
2005 return NULL;
2006
2007 return g_steal_pointer(&deflattened);
2008 }
2009
2010
2011 /**
2012 * virJSONValueObjectDeflattenArrays:
2013 *
2014 * Reconstruct JSON arrays from objects which only have sequential numeric
2015 * keys starting from 0.
2016 */
2017 static void
virJSONValueObjectDeflattenArrays(virJSONValue * json)2018 virJSONValueObjectDeflattenArrays(virJSONValue *json)
2019 {
2020 g_autofree virJSONValue **arraymembers = NULL;
2021 virJSONObject *obj;
2022 size_t i;
2023
2024 if (!json ||
2025 json->type != VIR_JSON_TYPE_OBJECT)
2026 return;
2027
2028 obj = &json->data.object;
2029
2030 arraymembers = g_new0(virJSONValue *, obj->npairs);
2031
2032 for (i = 0; i < obj->npairs; i++)
2033 virJSONValueObjectDeflattenArrays(obj->pairs[i].value);
2034
2035 for (i = 0; i < obj->npairs; i++) {
2036 virJSONObjectPair *pair = obj->pairs + i;
2037 unsigned int keynum;
2038
2039 if (virStrToLong_uip(pair->key, NULL, 10, &keynum) < 0)
2040 return;
2041
2042 if (keynum >= obj->npairs)
2043 return;
2044
2045 if (arraymembers[keynum])
2046 return;
2047
2048 arraymembers[keynum] = pair->value;
2049 }
2050
2051 for (i = 0; i < obj->npairs; i++)
2052 g_free(obj->pairs[i].key);
2053
2054 g_free(json->data.object.pairs);
2055
2056 i = obj->npairs;
2057 json->type = VIR_JSON_TYPE_ARRAY;
2058 json->data.array.nvalues = i;
2059 json->data.array.values = g_steal_pointer(&arraymembers);
2060 }
2061
2062
2063 /**
2064 * virJSONValueObjectDeflatten:
2065 *
2066 * In some cases it's possible to nest JSON objects by prefixing object members
2067 * with the parent object name followed by the dot and then the attribute name
2068 * rather than directly using a nested value object (e.g qemu's JSON
2069 * pseudo-protocol in backing file definition).
2070 *
2071 * This function will attempt to reverse the process and provide a nested json
2072 * hierarchy so that the parsers can be kept simple and we still can use the
2073 * weird syntax some users might use.
2074 */
2075 virJSONValue *
virJSONValueObjectDeflatten(virJSONValue * json)2076 virJSONValueObjectDeflatten(virJSONValue *json)
2077 {
2078 virJSONValue *deflattened;
2079
2080 if (!(deflattened = virJSONValueObjectDeflattenKeys(json)))
2081 return NULL;
2082
2083 virJSONValueObjectDeflattenArrays(deflattened);
2084
2085 return deflattened;
2086 }
2087