1
2
3
4
5
6
7
8
9
10
11
12
13#include "qemu/osdep.h"
14#include "qapi/qmp/qint.h"
15#include "qapi/qmp/qfloat.h"
16#include "qapi/qmp/qdict.h"
17#include "qapi/qmp/qbool.h"
18#include "qapi/qmp/qstring.h"
19#include "qapi/qmp/qobject.h"
20#include "qemu/queue.h"
21#include "qemu-common.h"
22#include "qemu/cutils.h"
23
24
25
26
27
28
29QDict *qdict_new(void)
30{
31 QDict *qdict;
32
33 qdict = g_malloc0(sizeof(*qdict));
34 qobject_init(QOBJECT(qdict), QTYPE_QDICT);
35
36 return qdict;
37}
38
39
40
41
42QDict *qobject_to_qdict(const QObject *obj)
43{
44 if (!obj || qobject_type(obj) != QTYPE_QDICT) {
45 return NULL;
46 }
47 return container_of(obj, QDict, base);
48}
49
50
51
52
53
54static unsigned int tdb_hash(const char *name)
55{
56 unsigned value;
57 unsigned i;
58
59
60 for (value = 0x238F13AF * strlen(name), i=0; name[i]; i++)
61 value = (value + (((const unsigned char *)name)[i] << (i*5 % 24)));
62
63 return (1103515243 * value + 12345);
64}
65
66
67
68
69static QDictEntry *alloc_entry(const char *key, QObject *value)
70{
71 QDictEntry *entry;
72
73 entry = g_malloc0(sizeof(*entry));
74 entry->key = g_strdup(key);
75 entry->value = value;
76
77 return entry;
78}
79
80
81
82
83
84
85QObject *qdict_entry_value(const QDictEntry *entry)
86{
87 return entry->value;
88}
89
90
91
92
93
94
95
96const char *qdict_entry_key(const QDictEntry *entry)
97{
98 return entry->key;
99}
100
101
102
103
104static QDictEntry *qdict_find(const QDict *qdict,
105 const char *key, unsigned int bucket)
106{
107 QDictEntry *entry;
108
109 QLIST_FOREACH(entry, &qdict->table[bucket], next)
110 if (!strcmp(entry->key, key))
111 return entry;
112
113 return NULL;
114}
115
116
117
118
119
120
121
122
123
124
125
126
127void qdict_put_obj(QDict *qdict, const char *key, QObject *value)
128{
129 unsigned int bucket;
130 QDictEntry *entry;
131
132 bucket = tdb_hash(key) % QDICT_BUCKET_MAX;
133 entry = qdict_find(qdict, key, bucket);
134 if (entry) {
135
136 qobject_decref(entry->value);
137 entry->value = value;
138 } else {
139
140 entry = alloc_entry(key, value);
141 QLIST_INSERT_HEAD(&qdict->table[bucket], entry, next);
142 qdict->size++;
143 }
144}
145
146
147
148
149
150
151
152QObject *qdict_get(const QDict *qdict, const char *key)
153{
154 QDictEntry *entry;
155
156 entry = qdict_find(qdict, key, tdb_hash(key) % QDICT_BUCKET_MAX);
157 return (entry == NULL ? NULL : entry->value);
158}
159
160
161
162
163
164
165int qdict_haskey(const QDict *qdict, const char *key)
166{
167 unsigned int bucket = tdb_hash(key) % QDICT_BUCKET_MAX;
168 return (qdict_find(qdict, key, bucket) == NULL ? 0 : 1);
169}
170
171
172
173
174size_t qdict_size(const QDict *qdict)
175{
176 return qdict->size;
177}
178
179
180
181
182static QObject *qdict_get_obj(const QDict *qdict, const char *key, QType type)
183{
184 QObject *obj;
185
186 obj = qdict_get(qdict, key);
187 assert(obj != NULL);
188 assert(qobject_type(obj) == type);
189
190 return obj;
191}
192
193
194
195
196
197
198
199
200
201double qdict_get_double(const QDict *qdict, const char *key)
202{
203 QObject *obj = qdict_get(qdict, key);
204
205 assert(obj);
206 switch (qobject_type(obj)) {
207 case QTYPE_QFLOAT:
208 return qfloat_get_double(qobject_to_qfloat(obj));
209 case QTYPE_QINT:
210 return qint_get_int(qobject_to_qint(obj));
211 default:
212 abort();
213 }
214}
215
216
217
218
219
220
221
222
223
224int64_t qdict_get_int(const QDict *qdict, const char *key)
225{
226 return qint_get_int(qobject_to_qint(qdict_get(qdict, key)));
227}
228
229
230
231
232
233
234
235
236
237bool qdict_get_bool(const QDict *qdict, const char *key)
238{
239 return qbool_get_bool(qobject_to_qbool(qdict_get(qdict, key)));
240}
241
242
243
244
245
246
247
248
249
250QList *qdict_get_qlist(const QDict *qdict, const char *key)
251{
252 return qobject_to_qlist(qdict_get_obj(qdict, key, QTYPE_QLIST));
253}
254
255
256
257
258
259
260
261
262
263QDict *qdict_get_qdict(const QDict *qdict, const char *key)
264{
265 return qobject_to_qdict(qdict_get(qdict, key));
266}
267
268
269
270
271
272
273
274
275
276
277const char *qdict_get_str(const QDict *qdict, const char *key)
278{
279 return qstring_get_str(qobject_to_qstring(qdict_get(qdict, key)));
280}
281
282
283
284
285
286
287
288
289int64_t qdict_get_try_int(const QDict *qdict, const char *key,
290 int64_t def_value)
291{
292 QInt *qint = qobject_to_qint(qdict_get(qdict, key));
293
294 return qint ? qint_get_int(qint) : def_value;
295}
296
297
298
299
300
301
302
303
304bool qdict_get_try_bool(const QDict *qdict, const char *key, bool def_value)
305{
306 QBool *qbool = qobject_to_qbool(qdict_get(qdict, key));
307
308 return qbool ? qbool_get_bool(qbool) : def_value;
309}
310
311
312
313
314
315
316
317
318
319const char *qdict_get_try_str(const QDict *qdict, const char *key)
320{
321 QString *qstr = qobject_to_qstring(qdict_get(qdict, key));
322
323 return qstr ? qstring_get_str(qstr) : NULL;
324}
325
326
327
328
329
330
331
332void qdict_iter(const QDict *qdict,
333 void (*iter)(const char *key, QObject *obj, void *opaque),
334 void *opaque)
335{
336 int i;
337 QDictEntry *entry;
338
339 for (i = 0; i < QDICT_BUCKET_MAX; i++) {
340 QLIST_FOREACH(entry, &qdict->table[i], next)
341 iter(entry->key, entry->value, opaque);
342 }
343}
344
345static QDictEntry *qdict_next_entry(const QDict *qdict, int first_bucket)
346{
347 int i;
348
349 for (i = first_bucket; i < QDICT_BUCKET_MAX; i++) {
350 if (!QLIST_EMPTY(&qdict->table[i])) {
351 return QLIST_FIRST(&qdict->table[i]);
352 }
353 }
354
355 return NULL;
356}
357
358
359
360
361const QDictEntry *qdict_first(const QDict *qdict)
362{
363 return qdict_next_entry(qdict, 0);
364}
365
366
367
368
369const QDictEntry *qdict_next(const QDict *qdict, const QDictEntry *entry)
370{
371 QDictEntry *ret;
372
373 ret = QLIST_NEXT(entry, next);
374 if (!ret) {
375 unsigned int bucket = tdb_hash(entry->key) % QDICT_BUCKET_MAX;
376 ret = qdict_next_entry(qdict, bucket + 1);
377 }
378
379 return ret;
380}
381
382
383
384
385
386QDict *qdict_clone_shallow(const QDict *src)
387{
388 QDict *dest;
389 QDictEntry *entry;
390 int i;
391
392 dest = qdict_new();
393
394 for (i = 0; i < QDICT_BUCKET_MAX; i++) {
395 QLIST_FOREACH(entry, &src->table[i], next) {
396 qobject_incref(entry->value);
397 qdict_put_obj(dest, entry->key, entry->value);
398 }
399 }
400
401 return dest;
402}
403
404
405
406
407static void qentry_destroy(QDictEntry *e)
408{
409 assert(e != NULL);
410 assert(e->key != NULL);
411 assert(e->value != NULL);
412
413 qobject_decref(e->value);
414 g_free(e->key);
415 g_free(e);
416}
417
418
419
420
421
422
423void qdict_del(QDict *qdict, const char *key)
424{
425 QDictEntry *entry;
426
427 entry = qdict_find(qdict, key, tdb_hash(key) % QDICT_BUCKET_MAX);
428 if (entry) {
429 QLIST_REMOVE(entry, next);
430 qentry_destroy(entry);
431 qdict->size--;
432 }
433}
434
435
436
437
438void qdict_destroy_obj(QObject *obj)
439{
440 int i;
441 QDict *qdict;
442
443 assert(obj != NULL);
444 qdict = qobject_to_qdict(obj);
445
446 for (i = 0; i < QDICT_BUCKET_MAX; i++) {
447 QDictEntry *entry = QLIST_FIRST(&qdict->table[i]);
448 while (entry) {
449 QDictEntry *tmp = QLIST_NEXT(entry, next);
450 QLIST_REMOVE(entry, next);
451 qentry_destroy(entry);
452 entry = tmp;
453 }
454 }
455
456 g_free(qdict);
457}
458
459
460
461
462
463
464void qdict_copy_default(QDict *dst, QDict *src, const char *key)
465{
466 QObject *val;
467
468 if (qdict_haskey(dst, key)) {
469 return;
470 }
471
472 val = qdict_get(src, key);
473 if (val) {
474 qobject_incref(val);
475 qdict_put_obj(dst, key, val);
476 }
477}
478
479
480
481
482
483void qdict_set_default_str(QDict *dst, const char *key, const char *val)
484{
485 if (qdict_haskey(dst, key)) {
486 return;
487 }
488
489 qdict_put(dst, key, qstring_from_str(val));
490}
491
492static void qdict_flatten_qdict(QDict *qdict, QDict *target,
493 const char *prefix);
494
495static void qdict_flatten_qlist(QList *qlist, QDict *target, const char *prefix)
496{
497 QObject *value;
498 const QListEntry *entry;
499 char *new_key;
500 int i;
501
502
503
504
505
506 assert(prefix);
507
508 entry = qlist_first(qlist);
509
510 for (i = 0; entry; entry = qlist_next(entry), i++) {
511 value = qlist_entry_obj(entry);
512 new_key = g_strdup_printf("%s.%i", prefix, i);
513
514 if (qobject_type(value) == QTYPE_QDICT) {
515 qdict_flatten_qdict(qobject_to_qdict(value), target, new_key);
516 } else if (qobject_type(value) == QTYPE_QLIST) {
517 qdict_flatten_qlist(qobject_to_qlist(value), target, new_key);
518 } else {
519
520 qobject_incref(value);
521 qdict_put_obj(target, new_key, value);
522 }
523
524 g_free(new_key);
525 }
526}
527
528static void qdict_flatten_qdict(QDict *qdict, QDict *target, const char *prefix)
529{
530 QObject *value;
531 const QDictEntry *entry, *next;
532 char *new_key;
533 bool delete;
534
535 entry = qdict_first(qdict);
536
537 while (entry != NULL) {
538
539 next = qdict_next(qdict, entry);
540 value = qdict_entry_value(entry);
541 new_key = NULL;
542 delete = false;
543
544 if (prefix) {
545 new_key = g_strdup_printf("%s.%s", prefix, entry->key);
546 }
547
548 if (qobject_type(value) == QTYPE_QDICT) {
549
550
551 qdict_flatten_qdict(qobject_to_qdict(value), target,
552 new_key ? new_key : entry->key);
553 delete = true;
554 } else if (qobject_type(value) == QTYPE_QLIST) {
555 qdict_flatten_qlist(qobject_to_qlist(value), target,
556 new_key ? new_key : entry->key);
557 delete = true;
558 } else if (prefix) {
559
560 qobject_incref(value);
561 qdict_put_obj(target, new_key, value);
562 delete = true;
563 }
564
565 g_free(new_key);
566
567 if (delete) {
568 qdict_del(qdict, entry->key);
569
570
571 entry = qdict_first(qdict);
572 continue;
573 }
574
575 entry = next;
576 }
577}
578
579
580
581
582
583
584
585
586void qdict_flatten(QDict *qdict)
587{
588 qdict_flatten_qdict(qdict, qdict, NULL);
589}
590
591
592void qdict_extract_subqdict(QDict *src, QDict **dst, const char *start)
593
594{
595 const QDictEntry *entry, *next;
596 const char *p;
597
598 *dst = qdict_new();
599 entry = qdict_first(src);
600
601 while (entry != NULL) {
602 next = qdict_next(src, entry);
603 if (strstart(entry->key, start, &p)) {
604 qobject_incref(entry->value);
605 qdict_put_obj(*dst, p, entry->value);
606 qdict_del(src, entry->key);
607 }
608 entry = next;
609 }
610}
611
612static int qdict_count_prefixed_entries(const QDict *src, const char *start)
613{
614 const QDictEntry *entry;
615 int count = 0;
616
617 for (entry = qdict_first(src); entry; entry = qdict_next(src, entry)) {
618 if (strstart(entry->key, start, NULL)) {
619 if (count == INT_MAX) {
620 return -ERANGE;
621 }
622 count++;
623 }
624 }
625
626 return count;
627}
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644void qdict_array_split(QDict *src, QList **dst)
645{
646 unsigned i;
647
648 *dst = qlist_new();
649
650 for (i = 0; i < UINT_MAX; i++) {
651 QObject *subqobj;
652 bool is_subqdict;
653 QDict *subqdict;
654 char indexstr[32], prefix[32];
655 size_t snprintf_ret;
656
657 snprintf_ret = snprintf(indexstr, 32, "%u", i);
658 assert(snprintf_ret < 32);
659
660 subqobj = qdict_get(src, indexstr);
661
662 snprintf_ret = snprintf(prefix, 32, "%u.", i);
663 assert(snprintf_ret < 32);
664
665
666 is_subqdict = qdict_count_prefixed_entries(src, prefix);
667
668
669
670 if (!subqobj == !is_subqdict) {
671 break;
672 }
673
674 if (is_subqdict) {
675 qdict_extract_subqdict(src, &subqdict, prefix);
676 assert(qdict_size(subqdict) > 0);
677 } else {
678 qobject_incref(subqobj);
679 qdict_del(src, indexstr);
680 }
681
682 qlist_append_obj(*dst, subqobj ?: QOBJECT(subqdict));
683 }
684}
685
686
687
688
689
690
691
692
693int qdict_array_entries(QDict *src, const char *subqdict)
694{
695 const QDictEntry *entry;
696 unsigned i;
697 unsigned entries = 0;
698 size_t subqdict_len = strlen(subqdict);
699
700 assert(!subqdict_len || subqdict[subqdict_len - 1] == '.');
701
702
703
704
705 for (i = 0; i < INT_MAX; i++) {
706 QObject *subqobj;
707 int subqdict_entries;
708 size_t slen = 32 + subqdict_len;
709 char indexstr[slen], prefix[slen];
710 size_t snprintf_ret;
711
712 snprintf_ret = snprintf(indexstr, slen, "%s%u", subqdict, i);
713 assert(snprintf_ret < slen);
714
715 subqobj = qdict_get(src, indexstr);
716
717 snprintf_ret = snprintf(prefix, slen, "%s%u.", subqdict, i);
718 assert(snprintf_ret < slen);
719
720 subqdict_entries = qdict_count_prefixed_entries(src, prefix);
721 if (subqdict_entries < 0) {
722 return subqdict_entries;
723 }
724
725
726
727 if (subqobj && subqdict_entries) {
728 return -EINVAL;
729 } else if (!subqobj && !subqdict_entries) {
730 break;
731 }
732
733 entries += subqdict_entries ? subqdict_entries : 1;
734 }
735
736
737 for (entry = qdict_first(src); entry; entry = qdict_next(src, entry)) {
738 if (!strstart(qdict_entry_key(entry), subqdict, NULL)) {
739 entries++;
740 }
741 }
742
743
744 if (qdict_size(src) != entries) {
745 return -EINVAL;
746 }
747
748 return i;
749}
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765void qdict_join(QDict *dest, QDict *src, bool overwrite)
766{
767 const QDictEntry *entry, *next;
768
769 entry = qdict_first(src);
770 while (entry) {
771 next = qdict_next(src, entry);
772
773 if (overwrite || !qdict_haskey(dest, entry->key)) {
774 qobject_incref(entry->value);
775 qdict_put_obj(dest, entry->key, entry->value);
776 qdict_del(src, entry->key);
777 }
778
779 entry = next;
780 }
781}
782