qapi/qmp-input-visitor.c

   1 /*
   2  * Input Visitor
   3  *
   4  * Copyright IBM, Corp. 2011
   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 "qapi/qmp-input-visitor.h"
  15 #include "qapi/visitor-impl.h"
  16 #include "qemu/queue.h"
  17 #include "qemu-common.h"
  18 #include "qapi/qmp/types.h"
  19 #include "qapi/qmp/qerror.h"
  20
  21 #define QIV_STACK_SIZE 1024
  22
  23 typedef struct StackObject
  24 {
  25     QObject *obj;
  26     const QListEntry *entry;
  27     GHashTable *h;
  28 } StackObject;
  29
  30 struct QmpInputVisitor
  31 {
  32     Visitor visitor;
  33     StackObject stack[QIV_STACK_SIZE];
  34     int nb_stack;
  35     bool strict;
  36 };
  37
  38 static QmpInputVisitor *to_qiv(Visitor *v)
  39 {
  40     return container_of(v, QmpInputVisitor, visitor);
  41 }
  42
  43 static QObject *qmp_input_get_object(QmpInputVisitor *qiv,
  44                                      const char *name)
  45 {
  46     QObject *qobj = qiv->stack[qiv->nb_stack - 1].obj;
  47
  48     if (qobj) {
  49         if (name && qobject_type(qobj) == QTYPE_QDICT) {
  50             if (qiv->stack[qiv->nb_stack - 1].h) {
  51                 g_hash_table_remove(qiv->stack[qiv->nb_stack - 1].h, name);
  52             }
  53             return qdict_get(qobject_to_qdict(qobj), name);
  54         } else if (qiv->stack[qiv->nb_stack - 1].entry) {
  55             return qlist_entry_obj(qiv->stack[qiv->nb_stack - 1].entry);
  56         }
  57     }
  58
  59     return qobj;
  60 }
  61
  62 static void qdict_add_key(const char *key, QObject *obj, void *opaque)
  63 {
  64     GHashTable *h = opaque;
  65     g_hash_table_insert(h, (gpointer) key, NULL);
  66 }
  67
  68 static void qmp_input_push(QmpInputVisitor *qiv, QObject *obj, Error **errp)
  69 {
  70     GHashTable *h;
  71
  72     if (qiv->nb_stack >= QIV_STACK_SIZE) {
  73         error_set(errp, QERR_BUFFER_OVERRUN);
  74         return;
  75     }
  76
  77     qiv->stack[qiv->nb_stack].obj = obj;
  78     qiv->stack[qiv->nb_stack].entry = NULL;
  79     qiv->stack[qiv->nb_stack].h = NULL;
  80
  81     if (qiv->strict && qobject_type(obj) == QTYPE_QDICT) {
  82         h = g_hash_table_new(g_str_hash, g_str_equal);
  83         qdict_iter(qobject_to_qdict(obj), qdict_add_key, h);
  84         qiv->stack[qiv->nb_stack].h = h;
  85     }
  86
  87     qiv->nb_stack++;
  88 }
  89
  90 /** Only for qmp_input_pop. */
  91 static gboolean always_true(gpointer key, gpointer val, gpointer user_pkey)
  92 {
  93     *(const char **)user_pkey = (const char *)key;
  94     return TRUE;
  95 }
  96
  97 static void qmp_input_pop(QmpInputVisitor *qiv, Error **errp)
  98 {
  99     assert(qiv->nb_stack > 0);
 100
 101     if (qiv->strict) {
 102         GHashTable * const top_ht = qiv->stack[qiv->nb_stack - 1].h;
 103         if (top_ht) {
 104             if (g_hash_table_size(top_ht)) {
 105                 const char *key;
 106                 g_hash_table_find(top_ht, always_true, &key);
 107                 error_set(errp, QERR_QMP_EXTRA_MEMBER, key);
 108             }
 109             g_hash_table_unref(top_ht);
 110         }
 111     }
 112
 113     qiv->nb_stack--;
 114 }
 115
 116 static void qmp_input_start_struct(Visitor *v, void **obj, const char *kind,
 117                                    const char *name, size_t size, Error **errp)
 118 {
 119     QmpInputVisitor *qiv = to_qiv(v);
 120     QObject *qobj = qmp_input_get_object(qiv, name);
 121     Error *err = NULL;
 122
 123     if (!qobj || qobject_type(qobj) != QTYPE_QDICT) {
 124         error_set(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
 125                   "QDict");
 126         return;
 127     }
 128
 129     qmp_input_push(qiv, qobj, &err);
 130     if (err) {
 131         error_propagate(errp, err);
 132         return;
 133     }
 134
 135     if (obj) {
 136         *obj = g_malloc0(size);
 137     }
 138 }
 139
 140 static void qmp_input_end_struct(Visitor *v, Error **errp)
 141 {
 142     QmpInputVisitor *qiv = to_qiv(v);
 143
 144     qmp_input_pop(qiv, errp);
 145 }
 146
 147 static void qmp_input_start_implicit_struct(Visitor *v, void **obj,
 148                                             size_t size, Error **errp)
 149 {
 150     if (obj) {
 151         *obj = g_malloc0(size);
 152     }
 153 }
 154
 155 static void qmp_input_end_implicit_struct(Visitor *v, Error **errp)
 156 {
 157 }
 158
 159 static void qmp_input_start_list(Visitor *v, const char *name, Error **errp)
 160 {
 161     QmpInputVisitor *qiv = to_qiv(v);
 162     QObject *qobj = qmp_input_get_object(qiv, name);
 163
 164     if (!qobj || qobject_type(qobj) != QTYPE_QLIST) {
 165         error_set(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
 166                   "list");
 167         return;
 168     }
 169
 170     qmp_input_push(qiv, qobj, errp);
 171 }
 172
 173 static GenericList *qmp_input_next_list(Visitor *v, GenericList **list,
 174                                         Error **errp)
 175 {
 176     QmpInputVisitor *qiv = to_qiv(v);
 177     GenericList *entry;
 178     StackObject *so = &qiv->stack[qiv->nb_stack - 1];
 179     bool first;
 180
 181     if (so->entry == NULL) {
 182         so->entry = qlist_first(qobject_to_qlist(so->obj));
 183         first = true;
 184     } else {
 185         so->entry = qlist_next(so->entry);
 186         first = false;
 187     }
 188
 189     if (so->entry == NULL) {
 190         return NULL;
 191     }
 192
 193     entry = g_malloc0(sizeof(*entry));
 194     if (first) {
 195         *list = entry;
 196     } else {
 197         (*list)->next = entry;
 198     }
 199
 200     return entry;
 201 }
 202
 203 static void qmp_input_end_list(Visitor *v, Error **errp)
 204 {
 205     QmpInputVisitor *qiv = to_qiv(v);
 206
 207     qmp_input_pop(qiv, errp);
 208 }
 209
 210 static void qmp_input_type_int(Visitor *v, int64_t *obj, const char *name,
 211                                Error **errp)
 212 {
 213     QmpInputVisitor *qiv = to_qiv(v);
 214     QObject *qobj = qmp_input_get_object(qiv, name);
 215
 216     if (!qobj || qobject_type(qobj) != QTYPE_QINT) {
 217         error_set(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
 218                   "integer");
 219         return;
 220     }
 221
 222     *obj = qint_get_int(qobject_to_qint(qobj));
 223 }
 224
 225 static void qmp_input_type_bool(Visitor *v, bool *obj, const char *name,
 226                                 Error **errp)
 227 {
 228     QmpInputVisitor *qiv = to_qiv(v);
 229     QObject *qobj = qmp_input_get_object(qiv, name);
 230
 231     if (!qobj || qobject_type(qobj) != QTYPE_QBOOL) {
 232         error_set(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
 233                   "boolean");
 234         return;
 235     }
 236
 237     *obj = qbool_get_int(qobject_to_qbool(qobj));
 238 }
 239
 240 static void qmp_input_type_str(Visitor *v, char **obj, const char *name,
 241                                Error **errp)
 242 {
 243     QmpInputVisitor *qiv = to_qiv(v);
 244     QObject *qobj = qmp_input_get_object(qiv, name);
 245
 246     if (!qobj || qobject_type(qobj) != QTYPE_QSTRING) {
 247         error_set(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
 248                   "string");
 249         return;
 250     }
 251
 252     *obj = g_strdup(qstring_get_str(qobject_to_qstring(qobj)));
 253 }
 254
 255 static void qmp_input_type_number(Visitor *v, double *obj, const char *name,
 256                                   Error **errp)
 257 {
 258     QmpInputVisitor *qiv = to_qiv(v);
 259     QObject *qobj = qmp_input_get_object(qiv, name);
 260
 261     if (!qobj || (qobject_type(qobj) != QTYPE_QFLOAT &&
 262         qobject_type(qobj) != QTYPE_QINT)) {
 263         error_set(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
 264                   "number");
 265         return;
 266     }
 267
 268     if (qobject_type(qobj) == QTYPE_QINT) {
 269         *obj = qint_get_int(qobject_to_qint(qobj));
 270     } else {
 271         *obj = qfloat_get_double(qobject_to_qfloat(qobj));
 272     }
 273 }
 274
 275 static void qmp_input_start_optional(Visitor *v, bool *present,
 276                                      const char *name, Error **errp)
 277 {
 278     QmpInputVisitor *qiv = to_qiv(v);
 279     QObject *qobj = qmp_input_get_object(qiv, name);
 280
 281     if (!qobj) {
 282         *present = false;
 283         return;
 284     }
 285
 286     *present = true;
 287 }
 288
 289 Visitor *qmp_input_get_visitor(QmpInputVisitor *v)
 290 {
 291     return &v->visitor;
 292 }
 293
 294 void qmp_input_visitor_cleanup(QmpInputVisitor *v)
 295 {
 296     qobject_decref(v->stack[0].obj);
 297     g_free(v);
 298 }
 299
 300 QmpInputVisitor *qmp_input_visitor_new(QObject *obj)
 301 {
 302     QmpInputVisitor *v;
 303
 304     v = g_malloc0(sizeof(*v));
 305
 306     v->visitor.start_struct = qmp_input_start_struct;
 307     v->visitor.end_struct = qmp_input_end_struct;
 308     v->visitor.start_implicit_struct = qmp_input_start_implicit_struct;
 309     v->visitor.end_implicit_struct = qmp_input_end_implicit_struct;
 310     v->visitor.start_list = qmp_input_start_list;
 311     v->visitor.next_list = qmp_input_next_list;
 312     v->visitor.end_list = qmp_input_end_list;
 313     v->visitor.type_enum = input_type_enum;
 314     v->visitor.type_int = qmp_input_type_int;
 315     v->visitor.type_bool = qmp_input_type_bool;
 316     v->visitor.type_str = qmp_input_type_str;
 317     v->visitor.type_number = qmp_input_type_number;
 318     v->visitor.start_optional = qmp_input_start_optional;
 319
 320     qmp_input_push(v, obj, NULL);
 321     qobject_incref(obj);
 322
 323     return v;
 324 }
 325
 326 QmpInputVisitor *qmp_input_visitor_new_strict(QObject *obj)
 327 {
 328     QmpInputVisitor *v;
 329
 330     v = qmp_input_visitor_new(obj);
 331     v->strict = true;
 332
 333     return v;
 334 }