qapi/qmp-input-visitor.c

   1 /*
   2  * Input Visitor
   3  *
   4  * Copyright (C) 2012-2016 Red Hat, Inc.
   5  * Copyright IBM, Corp. 2011
   6  *
   7  * Authors:
   8  *  Anthony Liguori   <aliguori@us.ibm.com>
   9  *
  10  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
  11  * See the COPYING.LIB file in the top-level directory.
  12  *
  13  */
  14
  15 #include "qemu/osdep.h"
  16 #include "qapi/error.h"
  17 #include "qapi/qmp-input-visitor.h"
  18 #include "qapi/visitor-impl.h"
  19 #include "qemu/queue.h"
  20 #include "qemu-common.h"
  21 #include "qapi/qmp/types.h"
  22 #include "qapi/qmp/qerror.h"
  23
  24 #define QIV_STACK_SIZE 1024
  25
  26 typedef struct StackObject
  27 {
  28     QObject *obj; /* Object being visited */
  29     void *qapi; /* sanity check that caller uses same pointer */
  30
  31     GHashTable *h;           /* If obj is dict: unvisited keys */
  32     const QListEntry *entry; /* If obj is list: unvisited tail */
  33
  34     QSLIST_ENTRY(StackObject) node;
  35 } StackObject;
  36
  37 struct QmpInputVisitor
  38 {
  39     Visitor visitor;
  40
  41     /* Root of visit at visitor creation. */
  42     QObject *root;
  43
  44     /* Stack of objects being visited (all entries will be either
  45      * QDict or QList). */
  46     QSLIST_HEAD(, StackObject) stack;
  47
  48     /* True to reject parse in visit_end_struct() if unvisited keys remain. */
  49     bool strict;
  50 };
  51
  52 static QmpInputVisitor *to_qiv(Visitor *v)
  53 {
  54     return container_of(v, QmpInputVisitor, visitor);
  55 }
  56
  57 static QObject *qmp_input_get_object(QmpInputVisitor *qiv,
  58                                      const char *name,
  59                                      bool consume)
  60 {
  61     StackObject *tos;
  62     QObject *qobj;
  63     QObject *ret;
  64
  65     if (QSLIST_EMPTY(&qiv->stack)) {
  66         /* Starting at root, name is ignored. */
  67         assert(qiv->root);
  68         return qiv->root;
  69     }
  70
  71     /* We are in a container; find the next element. */
  72     tos = QSLIST_FIRST(&qiv->stack);
  73     qobj = tos->obj;
  74     assert(qobj);
  75
  76     if (qobject_type(qobj) == QTYPE_QDICT) {
  77         assert(name);
  78         ret = qdict_get(qobject_to_qdict(qobj), name);
  79         if (tos->h && consume && ret) {
  80             bool removed = g_hash_table_remove(tos->h, name);
  81             assert(removed);
  82         }
  83     } else {
  84         assert(qobject_type(qobj) == QTYPE_QLIST);
  85         assert(!name);
  86         ret = qlist_entry_obj(tos->entry);
  87         assert(ret);
  88         if (consume) {
  89             tos->entry = qlist_next(tos->entry);
  90         }
  91     }
  92
  93     return ret;
  94 }
  95
  96 static void qdict_add_key(const char *key, QObject *obj, void *opaque)
  97 {
  98     GHashTable *h = opaque;
  99     g_hash_table_insert(h, (gpointer) key, NULL);
 100 }
 101
 102 static const QListEntry *qmp_input_push(QmpInputVisitor *qiv, QObject *obj,
 103                                         void *qapi, Error **errp)
 104 {
 105     GHashTable *h;
 106     StackObject *tos = g_new0(StackObject, 1);
 107
 108     assert(obj);
 109     tos->obj = obj;
 110     tos->qapi = qapi;
 111
 112     if (qiv->strict && qobject_type(obj) == QTYPE_QDICT) {
 113         h = g_hash_table_new(g_str_hash, g_str_equal);
 114         qdict_iter(qobject_to_qdict(obj), qdict_add_key, h);
 115         tos->h = h;
 116     } else if (qobject_type(obj) == QTYPE_QLIST) {
 117         tos->entry = qlist_first(qobject_to_qlist(obj));
 118     }
 119
 120     QSLIST_INSERT_HEAD(&qiv->stack, tos, node);
 121     return tos->entry;
 122 }
 123
 124
 125 static void qmp_input_check_struct(Visitor *v, Error **errp)
 126 {
 127     QmpInputVisitor *qiv = to_qiv(v);
 128     StackObject *tos = QSLIST_FIRST(&qiv->stack);
 129
 130     assert(tos && !tos->entry);
 131     if (qiv->strict) {
 132         GHashTable *const top_ht = tos->h;
 133         if (top_ht) {
 134             GHashTableIter iter;
 135             const char *key;
 136
 137             g_hash_table_iter_init(&iter, top_ht);
 138             if (g_hash_table_iter_next(&iter, (void **)&key, NULL)) {
 139                 error_setg(errp, QERR_QMP_EXTRA_MEMBER, key);
 140             }
 141         }
 142     }
 143 }
 144
 145 static void qmp_input_stack_object_free(StackObject *tos)
 146 {
 147     if (tos->h) {
 148         g_hash_table_unref(tos->h);
 149     }
 150
 151     g_free(tos);
 152 }
 153
 154 static void qmp_input_pop(Visitor *v, void **obj)
 155 {
 156     QmpInputVisitor *qiv = to_qiv(v);
 157     StackObject *tos = QSLIST_FIRST(&qiv->stack);
 158
 159     assert(tos && tos->qapi == obj);
 160     QSLIST_REMOVE_HEAD(&qiv->stack, node);
 161     qmp_input_stack_object_free(tos);
 162 }
 163
 164 static void qmp_input_start_struct(Visitor *v, const char *name, void **obj,
 165                                    size_t size, Error **errp)
 166 {
 167     QmpInputVisitor *qiv = to_qiv(v);
 168     QObject *qobj = qmp_input_get_object(qiv, name, true);
 169     Error *err = NULL;
 170
 171     if (obj) {
 172         *obj = NULL;
 173     }
 174     if (!qobj || qobject_type(qobj) != QTYPE_QDICT) {
 175         error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
 176                    "QDict");
 177         return;
 178     }
 179
 180     qmp_input_push(qiv, qobj, obj, &err);
 181     if (err) {
 182         error_propagate(errp, err);
 183         return;
 184     }
 185
 186     if (obj) {
 187         *obj = g_malloc0(size);
 188     }
 189 }
 190
 191
 192 static void qmp_input_start_list(Visitor *v, const char *name,
 193                                  GenericList **list, size_t size, Error **errp)
 194 {
 195     QmpInputVisitor *qiv = to_qiv(v);
 196     QObject *qobj = qmp_input_get_object(qiv, name, true);
 197     const QListEntry *entry;
 198
 199     if (!qobj || qobject_type(qobj) != QTYPE_QLIST) {
 200         if (list) {
 201             *list = NULL;
 202         }
 203         error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
 204                    "list");
 205         return;
 206     }
 207
 208     entry = qmp_input_push(qiv, qobj, list, errp);
 209     if (list) {
 210         if (entry) {
 211             *list = g_malloc0(size);
 212         } else {
 213             *list = NULL;
 214         }
 215     }
 216 }
 217
 218 static GenericList *qmp_input_next_list(Visitor *v, GenericList *tail,
 219                                         size_t size)
 220 {
 221     QmpInputVisitor *qiv = to_qiv(v);
 222     StackObject *so = QSLIST_FIRST(&qiv->stack);
 223
 224     if (!so->entry) {
 225         return NULL;
 226     }
 227     tail->next = g_malloc0(size);
 228     return tail->next;
 229 }
 230
 231
 232 static void qmp_input_start_alternate(Visitor *v, const char *name,
 233                                       GenericAlternate **obj, size_t size,
 234                                       bool promote_int, Error **errp)
 235 {
 236     QmpInputVisitor *qiv = to_qiv(v);
 237     QObject *qobj = qmp_input_get_object(qiv, name, false);
 238
 239     if (!qobj) {
 240         *obj = NULL;
 241         error_setg(errp, QERR_MISSING_PARAMETER, name ? name : "null");
 242         return;
 243     }
 244     *obj = g_malloc0(size);
 245     (*obj)->type = qobject_type(qobj);
 246     if (promote_int && (*obj)->type == QTYPE_QINT) {
 247         (*obj)->type = QTYPE_QFLOAT;
 248     }
 249 }
 250
 251 static void qmp_input_type_int64(Visitor *v, const char *name, int64_t *obj,
 252                                  Error **errp)
 253 {
 254     QmpInputVisitor *qiv = to_qiv(v);
 255     QInt *qint = qobject_to_qint(qmp_input_get_object(qiv, name, true));
 256
 257     if (!qint) {
 258         error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
 259                    "integer");
 260         return;
 261     }
 262
 263     *obj = qint_get_int(qint);
 264 }
 265
 266 static void qmp_input_type_uint64(Visitor *v, const char *name, uint64_t *obj,
 267                                   Error **errp)
 268 {
 269     /* FIXME: qobject_to_qint mishandles values over INT64_MAX */
 270     QmpInputVisitor *qiv = to_qiv(v);
 271     QInt *qint = qobject_to_qint(qmp_input_get_object(qiv, name, true));
 272
 273     if (!qint) {
 274         error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
 275                    "integer");
 276         return;
 277     }
 278
 279     *obj = qint_get_int(qint);
 280 }
 281
 282 static void qmp_input_type_bool(Visitor *v, const char *name, bool *obj,
 283                                 Error **errp)
 284 {
 285     QmpInputVisitor *qiv = to_qiv(v);
 286     QBool *qbool = qobject_to_qbool(qmp_input_get_object(qiv, name, true));
 287
 288     if (!qbool) {
 289         error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
 290                    "boolean");
 291         return;
 292     }
 293
 294     *obj = qbool_get_bool(qbool);
 295 }
 296
 297 static void qmp_input_type_str(Visitor *v, const char *name, char **obj,
 298                                Error **errp)
 299 {
 300     QmpInputVisitor *qiv = to_qiv(v);
 301     QString *qstr = qobject_to_qstring(qmp_input_get_object(qiv, name, true));
 302
 303     if (!qstr) {
 304         *obj = NULL;
 305         error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
 306                    "string");
 307         return;
 308     }
 309
 310     *obj = g_strdup(qstring_get_str(qstr));
 311 }
 312
 313 static void qmp_input_type_number(Visitor *v, const char *name, double *obj,
 314                                   Error **errp)
 315 {
 316     QmpInputVisitor *qiv = to_qiv(v);
 317     QObject *qobj = qmp_input_get_object(qiv, name, true);
 318     QInt *qint;
 319     QFloat *qfloat;
 320
 321     qint = qobject_to_qint(qobj);
 322     if (qint) {
 323         *obj = qint_get_int(qobject_to_qint(qobj));
 324         return;
 325     }
 326
 327     qfloat = qobject_to_qfloat(qobj);
 328     if (qfloat) {
 329         *obj = qfloat_get_double(qobject_to_qfloat(qobj));
 330         return;
 331     }
 332
 333     error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
 334                "number");
 335 }
 336
 337 static void qmp_input_type_any(Visitor *v, const char *name, QObject **obj,
 338                                Error **errp)
 339 {
 340     QmpInputVisitor *qiv = to_qiv(v);
 341     QObject *qobj = qmp_input_get_object(qiv, name, true);
 342
 343     if (!qobj) {
 344         error_setg(errp, QERR_MISSING_PARAMETER, name ? name : "null");
 345         *obj = NULL;
 346         return;
 347     }
 348
 349     qobject_incref(qobj);
 350     *obj = qobj;
 351 }
 352
 353 static void qmp_input_type_null(Visitor *v, const char *name, Error **errp)
 354 {
 355     QmpInputVisitor *qiv = to_qiv(v);
 356     QObject *qobj = qmp_input_get_object(qiv, name, true);
 357
 358     if (!qobj) {
 359         error_setg(errp, QERR_MISSING_PARAMETER, name ? name : "null");
 360         return;
 361     }
 362
 363     if (qobject_type(qobj) != QTYPE_QNULL) {
 364         error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
 365                    "null");
 366     }
 367 }
 368
 369 static void qmp_input_optional(Visitor *v, const char *name, bool *present)
 370 {
 371     QmpInputVisitor *qiv = to_qiv(v);
 372     QObject *qobj = qmp_input_get_object(qiv, name, false);
 373
 374     if (!qobj) {
 375         *present = false;
 376         return;
 377     }
 378
 379     *present = true;
 380 }
 381
 382 static void qmp_input_free(Visitor *v)
 383 {
 384     QmpInputVisitor *qiv = to_qiv(v);
 385     while (!QSLIST_EMPTY(&qiv->stack)) {
 386         StackObject *tos = QSLIST_FIRST(&qiv->stack);
 387
 388         QSLIST_REMOVE_HEAD(&qiv->stack, node);
 389         qmp_input_stack_object_free(tos);
 390     }
 391
 392     qobject_decref(qiv->root);
 393     g_free(qiv);
 394 }
 395
 396 Visitor *qmp_input_visitor_new(QObject *obj, bool strict)
 397 {
 398     QmpInputVisitor *v;
 399
 400     assert(obj);
 401     v = g_malloc0(sizeof(*v));
 402
 403     v->visitor.type = VISITOR_INPUT;
 404     v->visitor.start_struct = qmp_input_start_struct;
 405     v->visitor.check_struct = qmp_input_check_struct;
 406     v->visitor.end_struct = qmp_input_pop;
 407     v->visitor.start_list = qmp_input_start_list;
 408     v->visitor.next_list = qmp_input_next_list;
 409     v->visitor.end_list = qmp_input_pop;
 410     v->visitor.start_alternate = qmp_input_start_alternate;
 411     v->visitor.type_int64 = qmp_input_type_int64;
 412     v->visitor.type_uint64 = qmp_input_type_uint64;
 413     v->visitor.type_bool = qmp_input_type_bool;
 414     v->visitor.type_str = qmp_input_type_str;
 415     v->visitor.type_number = qmp_input_type_number;
 416     v->visitor.type_any = qmp_input_type_any;
 417     v->visitor.type_null = qmp_input_type_null;
 418     v->visitor.optional = qmp_input_optional;
 419     v->visitor.free = qmp_input_free;
 420     v->strict = strict;
 421
 422     v->root = obj;
 423     qobject_incref(obj);
 424
 425     return &v->visitor;
 426 }