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/qjson.h" 18 #include "qapi/qmp/qbool.h" 19 #include "qapi/qmp/qdict.h" 20 #include "qapi/qmp/qlist.h" 21 #include "qapi/qmp/qnum.h" 22 #include "qapi/qmp/qstring.h" 23 #include "qemu/unicode.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 json_pretty_newline(QString *str, bool pretty, int indent) 153 { 154 int i; 155 156 if (pretty) { 157 qstring_append(str, "\n"); 158 for (i = 0; i < indent; i++) { 159 qstring_append(str, " "); 160 } 161 } 162 } 163 164 static void to_json(const QObject *obj, QString *str, bool pretty, int indent) 165 { 166 switch (qobject_type(obj)) { 167 case QTYPE_QNULL: 168 qstring_append(str, "null"); 169 break; 170 case QTYPE_QNUM: { 171 QNum *val = qobject_to(QNum, obj); 172 char *buffer = qnum_to_string(val); 173 qstring_append(str, buffer); 174 g_free(buffer); 175 break; 176 } 177 case QTYPE_QSTRING: { 178 QString *val = qobject_to(QString, obj); 179 const char *ptr; 180 int cp; 181 char buf[16]; 182 char *end; 183 184 ptr = qstring_get_str(val); 185 qstring_append(str, "\""); 186 187 for (; *ptr; ptr = end) { 188 cp = mod_utf8_codepoint(ptr, 6, &end); 189 switch (cp) { 190 case '\"': 191 qstring_append(str, "\\\""); 192 break; 193 case '\\': 194 qstring_append(str, "\\\\"); 195 break; 196 case '\b': 197 qstring_append(str, "\\b"); 198 break; 199 case '\f': 200 qstring_append(str, "\\f"); 201 break; 202 case '\n': 203 qstring_append(str, "\\n"); 204 break; 205 case '\r': 206 qstring_append(str, "\\r"); 207 break; 208 case '\t': 209 qstring_append(str, "\\t"); 210 break; 211 default: 212 if (cp < 0) { 213 cp = 0xFFFD; /* replacement character */ 214 } 215 if (cp > 0xFFFF) { 216 /* beyond BMP; need a surrogate pair */ 217 snprintf(buf, sizeof(buf), "\\u%04X\\u%04X", 218 0xD800 + ((cp - 0x10000) >> 10), 219 0xDC00 + ((cp - 0x10000) & 0x3FF)); 220 } else if (cp < 0x20 || cp >= 0x7F) { 221 snprintf(buf, sizeof(buf), "\\u%04X", cp); 222 } else { 223 buf[0] = cp; 224 buf[1] = 0; 225 } 226 qstring_append(str, buf); 227 } 228 }; 229 230 qstring_append(str, "\""); 231 break; 232 } 233 case QTYPE_QDICT: { 234 QDict *val = qobject_to(QDict, obj); 235 const char *comma = pretty ? "," : ", "; 236 const char *sep = ""; 237 const QDictEntry *entry; 238 QString *qkey; 239 240 qstring_append(str, "{"); 241 242 for (entry = qdict_first(val); 243 entry; 244 entry = qdict_next(val, entry)) { 245 qstring_append(str, sep); 246 json_pretty_newline(str, pretty, indent + 1); 247 248 qkey = qstring_from_str(qdict_entry_key(entry)); 249 to_json(QOBJECT(qkey), str, pretty, indent + 1); 250 qobject_unref(qkey); 251 252 qstring_append(str, ": "); 253 to_json(qdict_entry_value(entry), str, pretty, indent + 1); 254 sep = comma; 255 } 256 257 json_pretty_newline(str, pretty, indent); 258 qstring_append(str, "}"); 259 break; 260 } 261 case QTYPE_QLIST: { 262 QList *val = qobject_to(QList, obj); 263 const char *comma = pretty ? "," : ", "; 264 const char *sep = ""; 265 QListEntry *entry; 266 267 qstring_append(str, "["); 268 269 QLIST_FOREACH_ENTRY(val, entry) { 270 qstring_append(str, sep); 271 json_pretty_newline(str, pretty, indent + 1); 272 to_json(qlist_entry_obj(entry), str, pretty, indent + 1); 273 sep = comma; 274 } 275 276 json_pretty_newline(str, pretty, indent); 277 qstring_append(str, "]"); 278 break; 279 } 280 case QTYPE_QBOOL: { 281 QBool *val = qobject_to(QBool, obj); 282 283 if (qbool_get_bool(val)) { 284 qstring_append(str, "true"); 285 } else { 286 qstring_append(str, "false"); 287 } 288 break; 289 } 290 default: 291 abort(); 292 } 293 } 294 295 QString *qobject_to_json_pretty(const QObject *obj, bool pretty) 296 { 297 QString *str = qstring_new(); 298 299 to_json(obj, str, pretty, 0); 300 301 return str; 302 } 303 304 QString *qobject_to_json(const QObject *obj) 305 { 306 return qobject_to_json_pretty(obj, false); 307 } 308