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