1 /* 2 * QObject JSON integration 3 * 4 * Copyright IBM, Corp. 2009 5 * 6 * Authors: 7 * Anthony Liguori <aliguori@us.ibm.com> 8 * 9 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later. 10 * See the COPYING.LIB file in the top-level directory. 11 * 12 */ 13 14 #include "qemu/osdep.h" 15 #include "qapi/error.h" 16 #include "qapi/qmp/json-parser.h" 17 #include "qapi/qmp/json-writer.h" 18 #include "qapi/qmp/qjson.h" 19 #include "qapi/qmp/qbool.h" 20 #include "qapi/qmp/qdict.h" 21 #include "qapi/qmp/qlist.h" 22 #include "qapi/qmp/qnum.h" 23 #include "qapi/qmp/qstring.h" 24 25 typedef struct JSONParsingState 26 { 27 JSONMessageParser parser; 28 QObject *result; 29 Error *err; 30 } JSONParsingState; 31 32 static void consume_json(void *opaque, QObject *json, Error *err) 33 { 34 JSONParsingState *s = opaque; 35 36 assert(!json != !err); 37 assert(!s->result || !s->err); 38 39 if (s->result) { 40 qobject_unref(s->result); 41 s->result = NULL; 42 error_setg(&s->err, "Expecting at most one JSON value"); 43 } 44 if (s->err) { 45 qobject_unref(json); 46 error_free(err); 47 return; 48 } 49 s->result = json; 50 s->err = err; 51 } 52 53 /* 54 * Parse @string as JSON value. 55 * If @ap is non-null, interpolate %-escapes. 56 * Takes ownership of %p arguments. 57 * On success, return the JSON value. 58 * On failure, store an error through @errp and return NULL. 59 * Ownership of %p arguments becomes indeterminate then. To avoid 60 * leaks, callers passing %p must terminate on error, e.g. by passing 61 * &error_abort. 62 */ 63 static QObject *qobject_from_jsonv(const char *string, va_list *ap, 64 Error **errp) 65 { 66 JSONParsingState state = {}; 67 68 json_message_parser_init(&state.parser, consume_json, &state, ap); 69 json_message_parser_feed(&state.parser, string, strlen(string)); 70 json_message_parser_flush(&state.parser); 71 json_message_parser_destroy(&state.parser); 72 73 if (!state.result && !state.err) { 74 error_setg(&state.err, "Expecting a JSON value"); 75 } 76 77 error_propagate(errp, state.err); 78 return state.result; 79 } 80 81 QObject *qobject_from_json(const char *string, Error **errp) 82 { 83 return qobject_from_jsonv(string, NULL, errp); 84 } 85 86 /* 87 * Parse @string as JSON value with %-escapes interpolated. 88 * Abort on error. Do not use with untrusted @string. 89 * Return the resulting QObject. It is never null. 90 */ 91 QObject *qobject_from_vjsonf_nofail(const char *string, va_list ap) 92 { 93 va_list ap_copy; 94 QObject *obj; 95 96 /* va_copy() is needed when va_list is an array type */ 97 va_copy(ap_copy, ap); 98 obj = qobject_from_jsonv(string, &ap_copy, &error_abort); 99 va_end(ap_copy); 100 101 assert(obj); 102 return obj; 103 } 104 105 /* 106 * Parse @string as JSON value with %-escapes interpolated. 107 * Abort on error. Do not use with untrusted @string. 108 * Return the resulting QObject. It is never null. 109 */ 110 QObject *qobject_from_jsonf_nofail(const char *string, ...) 111 { 112 QObject *obj; 113 va_list ap; 114 115 va_start(ap, string); 116 obj = qobject_from_vjsonf_nofail(string, ap); 117 va_end(ap); 118 119 return obj; 120 } 121 122 /* 123 * Parse @string as JSON object with %-escapes interpolated. 124 * Abort on error. Do not use with untrusted @string. 125 * Return the resulting QDict. It is never null. 126 */ 127 QDict *qdict_from_vjsonf_nofail(const char *string, va_list ap) 128 { 129 QDict *qdict; 130 131 qdict = qobject_to(QDict, qobject_from_vjsonf_nofail(string, ap)); 132 assert(qdict); 133 return qdict; 134 } 135 136 /* 137 * Parse @string as JSON object with %-escapes interpolated. 138 * Abort on error. Do not use with untrusted @string. 139 * Return the resulting QDict. It is never null. 140 */ 141 QDict *qdict_from_jsonf_nofail(const char *string, ...) 142 { 143 QDict *qdict; 144 va_list ap; 145 146 va_start(ap, string); 147 qdict = qdict_from_vjsonf_nofail(string, ap); 148 va_end(ap); 149 return qdict; 150 } 151 152 static void to_json(JSONWriter *writer, const char *name, 153 const QObject *obj) 154 { 155 switch (qobject_type(obj)) { 156 case QTYPE_QNULL: 157 json_writer_null(writer, name); 158 break; 159 case QTYPE_QNUM: { 160 QNum *val = qobject_to(QNum, obj); 161 162 switch (val->kind) { 163 case QNUM_I64: 164 json_writer_int64(writer, name, val->u.i64); 165 break; 166 case QNUM_U64: 167 json_writer_uint64(writer, name, val->u.u64); 168 break; 169 case QNUM_DOUBLE: 170 json_writer_double(writer, name, val->u.dbl); 171 break; 172 default: 173 abort(); 174 } 175 break; 176 } 177 case QTYPE_QSTRING: { 178 QString *val = qobject_to(QString, obj); 179 180 json_writer_str(writer, name, qstring_get_str(val)); 181 break; 182 } 183 case QTYPE_QDICT: { 184 QDict *val = qobject_to(QDict, obj); 185 const QDictEntry *entry; 186 187 json_writer_start_object(writer, name); 188 189 for (entry = qdict_first(val); 190 entry; 191 entry = qdict_next(val, entry)) { 192 to_json(writer, qdict_entry_key(entry), qdict_entry_value(entry)); 193 } 194 195 json_writer_end_object(writer); 196 break; 197 } 198 case QTYPE_QLIST: { 199 QList *val = qobject_to(QList, obj); 200 QListEntry *entry; 201 202 json_writer_start_array(writer, name); 203 204 QLIST_FOREACH_ENTRY(val, entry) { 205 to_json(writer, NULL, qlist_entry_obj(entry)); 206 } 207 208 json_writer_end_array(writer); 209 break; 210 } 211 case QTYPE_QBOOL: { 212 QBool *val = qobject_to(QBool, obj); 213 214 json_writer_bool(writer, name, qbool_get_bool(val)); 215 break; 216 } 217 default: 218 abort(); 219 } 220 } 221 222 GString *qobject_to_json_pretty(const QObject *obj, bool pretty) 223 { 224 JSONWriter *writer = json_writer_new(pretty); 225 226 to_json(writer, NULL, obj); 227 return json_writer_get_and_free(writer); 228 } 229 230 GString *qobject_to_json(const QObject *obj) 231 { 232 return qobject_to_json_pretty(obj, false); 233 } 234