[mirror_qemu.git] / qapi / qmp-input-visitor.c

/*
 * Input Visitor
 *
 * Copyright (C) 2012-2016 Red Hat, Inc.
 * Copyright IBM, Corp. 2011
 *
 * Authors:
 *  Anthony Liguori   <aliguori@us.ibm.com>
 *
 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
 * See the COPYING.LIB file in the top-level directory.
 *
 */

#include "qemu/osdep.h"
#include "qapi/error.h"
#include "qapi/qmp-input-visitor.h"
#include "qapi/visitor-impl.h"
#include "qemu/queue.h"
#include "qemu-common.h"
#include "qapi/qmp/types.h"
#include "qapi/qmp/qerror.h"

#define QIV_STACK_SIZE 1024

typedef struct StackObject
{
    QObject *obj; /* Object being visited */

    GHashTable *h;           /* If obj is dict: unvisited keys */
    const QListEntry *entry; /* If obj is list: unvisited tail */
    bool first;              /* If obj is list: next_list() not yet called? */
} StackObject;

struct QmpInputVisitor
{
    Visitor visitor;

    /* Root of visit at visitor creation. */
    QObject *root;

    /* Stack of objects being visited (all entries will be either
     * QDict or QList). */
    StackObject stack[QIV_STACK_SIZE];
    int nb_stack;

    /* True to reject parse in visit_end_struct() if unvisited keys remain. */
    bool strict;
};

static QmpInputVisitor *to_qiv(Visitor *v)
{
    return container_of(v, QmpInputVisitor, visitor);
}

static QObject *qmp_input_get_object(QmpInputVisitor *qiv,
                                     const char *name,
                                     bool consume)
{
    StackObject *tos;
    QObject *qobj;
    QObject *ret;

    if (!qiv->nb_stack) {
        /* Starting at root, name is ignored. */
        return qiv->root;
    }

    /* We are in a container; find the next element. */
    tos = &qiv->stack[qiv->nb_stack - 1];
    qobj = tos->obj;
    assert(qobj);

    if (qobject_type(qobj) == QTYPE_QDICT) {
        assert(name);
        ret = qdict_get(qobject_to_qdict(qobj), name);
        if (tos->h && consume && ret) {
            bool removed = g_hash_table_remove(tos->h, name);
            assert(removed);
        }
    } else {
        assert(qobject_type(qobj) == QTYPE_QLIST);
        assert(!name);
        assert(!tos->first);
        ret = qlist_entry_obj(tos->entry);
        if (consume) {
            tos->entry = qlist_next(tos->entry);
        }
    }

    return ret;
}

static void qdict_add_key(const char *key, QObject *obj, void *opaque)
{
    GHashTable *h = opaque;
    g_hash_table_insert(h, (gpointer) key, NULL);
}

static void qmp_input_push(QmpInputVisitor *qiv, QObject *obj, Error **errp)
{
    GHashTable *h;
    StackObject *tos = &qiv->stack[qiv->nb_stack];

    assert(obj);
    if (qiv->nb_stack >= QIV_STACK_SIZE) {
        error_setg(errp, "An internal buffer overran");
        return;
    }

    tos->obj = obj;
    assert(!tos->h);
    assert(!tos->entry);

    if (qiv->strict && qobject_type(obj) == QTYPE_QDICT) {
        h = g_hash_table_new(g_str_hash, g_str_equal);
        qdict_iter(qobject_to_qdict(obj), qdict_add_key, h);
        tos->h = h;
    } else if (qobject_type(obj) == QTYPE_QLIST) {
        tos->entry = qlist_first(qobject_to_qlist(obj));
        tos->first = true;
    }

    qiv->nb_stack++;
}


static void qmp_input_check_struct(Visitor *v, Error **errp)
{
    QmpInputVisitor *qiv = to_qiv(v);
    StackObject *tos = &qiv->stack[qiv->nb_stack - 1];

    assert(qiv->nb_stack > 0);

    if (qiv->strict) {
        GHashTable *const top_ht = tos->h;
        if (top_ht) {
            GHashTableIter iter;
            const char *key;

            g_hash_table_iter_init(&iter, top_ht);
            if (g_hash_table_iter_next(&iter, (void **)&key, NULL)) {
                error_setg(errp, QERR_QMP_EXTRA_MEMBER, key);
            }
        }
    }
}

static void qmp_input_pop(Visitor *v)
{
    QmpInputVisitor *qiv = to_qiv(v);
    StackObject *tos = &qiv->stack[qiv->nb_stack - 1];

    assert(qiv->nb_stack > 0);

    if (qiv->strict) {
        GHashTable * const top_ht = qiv->stack[qiv->nb_stack - 1].h;
        if (top_ht) {
            g_hash_table_unref(top_ht);
        }
        tos->h = NULL;
    }

    qiv->nb_stack--;
}

static void qmp_input_start_struct(Visitor *v, const char *name, void **obj,
                                   size_t size, Error **errp)
{
    QmpInputVisitor *qiv = to_qiv(v);
    QObject *qobj = qmp_input_get_object(qiv, name, true);
    Error *err = NULL;

    if (obj) {
        *obj = NULL;
    }
    if (!qobj || qobject_type(qobj) != QTYPE_QDICT) {
        error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
                   "QDict");
        return;
    }

    qmp_input_push(qiv, qobj, &err);
    if (err) {
        error_propagate(errp, err);
        return;
    }

    if (obj) {
        *obj = g_malloc0(size);
    }
}


static void qmp_input_start_list(Visitor *v, const char *name, Error **errp)
{
    QmpInputVisitor *qiv = to_qiv(v);
    QObject *qobj = qmp_input_get_object(qiv, name, true);

    if (!qobj || qobject_type(qobj) != QTYPE_QLIST) {
        error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
                   "list");
        return;
    }

    qmp_input_push(qiv, qobj, errp);
}

static GenericList *qmp_input_next_list(Visitor *v, GenericList **list,
                                        size_t size)
{
    QmpInputVisitor *qiv = to_qiv(v);
    GenericList *entry;
    StackObject *so = &qiv->stack[qiv->nb_stack - 1];

    if (!so->entry) {
        return NULL;
    }

    entry = g_malloc0(size);
    if (so->first) {
        *list = entry;
        so->first = false;
    } else {
        (*list)->next = entry;
    }

    return entry;
}


static void qmp_input_start_alternate(Visitor *v, const char *name,
                                      GenericAlternate **obj, size_t size,
                                      bool promote_int, Error **errp)
{
    QmpInputVisitor *qiv = to_qiv(v);
    QObject *qobj = qmp_input_get_object(qiv, name, false);

    if (!qobj) {
        *obj = NULL;
        error_setg(errp, QERR_MISSING_PARAMETER, name ? name : "null");
        return;
    }
    *obj = g_malloc0(size);
    (*obj)->type = qobject_type(qobj);
    if (promote_int && (*obj)->type == QTYPE_QINT) {
        (*obj)->type = QTYPE_QFLOAT;
    }
}

static void qmp_input_type_int64(Visitor *v, const char *name, int64_t *obj,
                                 Error **errp)
{
    QmpInputVisitor *qiv = to_qiv(v);
    QInt *qint = qobject_to_qint(qmp_input_get_object(qiv, name, true));

    if (!qint) {
        error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
                   "integer");
        return;
    }

    *obj = qint_get_int(qint);
}

static void qmp_input_type_uint64(Visitor *v, const char *name, uint64_t *obj,
                                  Error **errp)
{
    /* FIXME: qobject_to_qint mishandles values over INT64_MAX */
    QmpInputVisitor *qiv = to_qiv(v);
    QInt *qint = qobject_to_qint(qmp_input_get_object(qiv, name, true));

    if (!qint) {
        error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
                   "integer");
        return;
    }

    *obj = qint_get_int(qint);
}

static void qmp_input_type_bool(Visitor *v, const char *name, bool *obj,
                                Error **errp)
{
    QmpInputVisitor *qiv = to_qiv(v);
    QBool *qbool = qobject_to_qbool(qmp_input_get_object(qiv, name, true));

    if (!qbool) {
        error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
                   "boolean");
        return;
    }

    *obj = qbool_get_bool(qbool);
}

static void qmp_input_type_str(Visitor *v, const char *name, char **obj,
                               Error **errp)
{
    QmpInputVisitor *qiv = to_qiv(v);
    QString *qstr = qobject_to_qstring(qmp_input_get_object(qiv, name, true));

    if (!qstr) {
        *obj = NULL;
        error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
                   "string");
        return;
    }

    *obj = g_strdup(qstring_get_str(qstr));
}

static void qmp_input_type_number(Visitor *v, const char *name, double *obj,
                                  Error **errp)
{
    QmpInputVisitor *qiv = to_qiv(v);
    QObject *qobj = qmp_input_get_object(qiv, name, true);
    QInt *qint;
    QFloat *qfloat;

    qint = qobject_to_qint(qobj);
    if (qint) {
        *obj = qint_get_int(qobject_to_qint(qobj));
        return;
    }

    qfloat = qobject_to_qfloat(qobj);
    if (qfloat) {
        *obj = qfloat_get_double(qobject_to_qfloat(qobj));
        return;
    }

    error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
               "number");
}

static void qmp_input_type_any(Visitor *v, const char *name, QObject **obj,
                               Error **errp)
{
    QmpInputVisitor *qiv = to_qiv(v);
    QObject *qobj = qmp_input_get_object(qiv, name, true);

    qobject_incref(qobj);
    *obj = qobj;
}

static void qmp_input_type_null(Visitor *v, const char *name, Error **errp)
{
    QmpInputVisitor *qiv = to_qiv(v);
    QObject *qobj = qmp_input_get_object(qiv, name, true);

    if (qobject_type(qobj) != QTYPE_QNULL) {
        error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
                   "null");
    }
}

static void qmp_input_optional(Visitor *v, const char *name, bool *present)
{
    QmpInputVisitor *qiv = to_qiv(v);
    QObject *qobj = qmp_input_get_object(qiv, name, false);

    if (!qobj) {
        *present = false;
        return;
    }

    *present = true;
}

Visitor *qmp_input_get_visitor(QmpInputVisitor *v)
{
    return &v->visitor;
}

void qmp_input_visitor_cleanup(QmpInputVisitor *v)
{
    qobject_decref(v->root);
    g_free(v);
}

QmpInputVisitor *qmp_input_visitor_new(QObject *obj, bool strict)
{
    QmpInputVisitor *v;

    v = g_malloc0(sizeof(*v));

    v->visitor.type = VISITOR_INPUT;
    v->visitor.start_struct = qmp_input_start_struct;
    v->visitor.check_struct = qmp_input_check_struct;
    v->visitor.end_struct = qmp_input_pop;
    v->visitor.start_list = qmp_input_start_list;
    v->visitor.next_list = qmp_input_next_list;
    v->visitor.end_list = qmp_input_pop;
    v->visitor.start_alternate = qmp_input_start_alternate;
    v->visitor.type_int64 = qmp_input_type_int64;
    v->visitor.type_uint64 = qmp_input_type_uint64;
    v->visitor.type_bool = qmp_input_type_bool;
    v->visitor.type_str = qmp_input_type_str;
    v->visitor.type_number = qmp_input_type_number;
    v->visitor.type_any = qmp_input_type_any;
    v->visitor.type_null = qmp_input_type_null;
    v->visitor.optional = qmp_input_optional;
    v->strict = strict;

    v->root = obj;
    qobject_incref(obj);

    return v;
}
Commit	Line	Data
c40cc0a0 MR	1	/*
	2	* Input Visitor
	3	*
08f9541d	4	* Copyright (C) 2012-2016 Red Hat, Inc.
c40cc0a0 MR	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
cbf21151	15	#include "qemu/osdep.h"
da34e65c	16	#include "qapi/error.h"
7b1b5d19 PB	17	#include "qapi/qmp-input-visitor.h"
7b1b5d19 PB	18	#include "qapi/visitor-impl.h"
1de7afc9	19	#include "qemu/queue.h"
c40cc0a0	20	#include "qemu-common.h"
7b1b5d19 PB	21	#include "qapi/qmp/types.h"
7b1b5d19 PB	22	#include "qapi/qmp/qerror.h"
c40cc0a0 MR	23
	24	#define QIV_STACK_SIZE 1024
	25
	26	typedef struct StackObject
	27	{
b471d012 EB	28	QObject obj; / Object being visited */
	29
	30	GHashTable h; / If obj is dict: unvisited keys */
	31	const QListEntry entry; / If obj is list: unvisited tail */
fcf3cb21	32	bool first; /* If obj is list: next_list() not yet called? */
c40cc0a0 MR	33	} StackObject;
	34
	35	struct QmpInputVisitor
	36	{
	37	Visitor visitor;
b471d012	38
ce140b17 EB	39	/* Root of visit at visitor creation. */
	40	QObject *root;
	41
	42	/* Stack of objects being visited (all entries will be either
	43	* QDict or QList). */
c40cc0a0 MR	44	StackObject stack[QIV_STACK_SIZE];
c40cc0a0 MR	45	int nb_stack;
b471d012 EB	46
b471d012 EB	47	/* True to reject parse in visit_end_struct() if unvisited keys remain. */
e38ac962	48	bool strict;
c40cc0a0 MR	49	};
	50
	51	static QmpInputVisitor to_qiv(Visitor v)
	52	{
	53	return container_of(v, QmpInputVisitor, visitor);
	54	}
	55
4faaec6a	56	static QObject qmp_input_get_object(QmpInputVisitor qiv,
e8316d7e KW	57	const char *name,
e8316d7e KW	58	bool consume)
c40cc0a0	59	{
ce140b17 EB	60	StackObject *tos;
ce140b17 EB	61	QObject *qobj;
e5826a2f	62	QObject *ret;
b471d012	63
ce140b17 EB	64	if (!qiv->nb_stack) {
	65	/* Starting at root, name is ignored. */
	66	return qiv->root;
	67	}
	68
	69	/* We are in a container; find the next element. */
	70	tos = &qiv->stack[qiv->nb_stack - 1];
	71	qobj = tos->obj;
b471d012 EB	72	assert(qobj);
b471d012 EB	73
ce140b17 EB	74	if (qobject_type(qobj) == QTYPE_QDICT) {
ce140b17 EB	75	assert(name);
e5826a2f EB	76	ret = qdict_get(qobject_to_qdict(qobj), name);
	77	if (tos->h && consume && ret) {
	78	bool removed = g_hash_table_remove(tos->h, name);
	79	assert(removed);
47c6d3ec	80	}
ce140b17	81	} else {
b471d012	82	assert(qobject_type(qobj) == QTYPE_QLIST);
ce140b17	83	assert(!name);
fcf3cb21	84	assert(!tos->first);
ce140b17	85	ret = qlist_entry_obj(tos->entry);
fcf3cb21 EB	86	if (consume) {
	87	tos->entry = qlist_next(tos->entry);
	88	}
c40cc0a0 MR	89	}
c40cc0a0 MR	90
ce140b17	91	return ret;
c40cc0a0 MR	92	}
c40cc0a0 MR	93
e38ac962 PB	94	static void qdict_add_key(const char key, QObject obj, void *opaque)
	95	{
	96	GHashTable *h = opaque;
	97	g_hash_table_insert(h, (gpointer) key, NULL);
	98	}
	99
4faaec6a	100	static void qmp_input_push(QmpInputVisitor qiv, QObject obj, Error **errp)
c40cc0a0	101	{
e38ac962	102	GHashTable *h;
b471d012	103	StackObject *tos = &qiv->stack[qiv->nb_stack];
c40cc0a0	104
b471d012	105	assert(obj);
c40cc0a0	106	if (qiv->nb_stack >= QIV_STACK_SIZE) {
f231b88d	107	error_setg(errp, "An internal buffer overran");
c40cc0a0 MR	108	return;
c40cc0a0 MR	109	}
e38ac962	110
b471d012	111	tos->obj = obj;
fcf3cb21 EB	112	assert(!tos->h);
fcf3cb21 EB	113	assert(!tos->entry);
e38ac962 PB	114
	115	if (qiv->strict && qobject_type(obj) == QTYPE_QDICT) {
	116	h = g_hash_table_new(g_str_hash, g_str_equal);
	117	qdict_iter(qobject_to_qdict(obj), qdict_add_key, h);
b471d012	118	tos->h = h;
fcf3cb21 EB	119	} else if (qobject_type(obj) == QTYPE_QLIST) {
	120	tos->entry = qlist_first(qobject_to_qlist(obj));
	121	tos->first = true;
e38ac962 PB	122	}
	123
	124	qiv->nb_stack++;
c40cc0a0 MR	125	}
c40cc0a0 MR	126
57a33d89	127
15c2f669	128	static void qmp_input_check_struct(Visitor v, Error *errp)
c40cc0a0	129	{
15c2f669	130	QmpInputVisitor *qiv = to_qiv(v);
fcf3cb21	131	StackObject *tos = &qiv->stack[qiv->nb_stack - 1];
15c2f669	132
57a33d89	133	assert(qiv->nb_stack > 0);
e38ac962	134
57a33d89	135	if (qiv->strict) {
fcf3cb21	136	GHashTable *const top_ht = tos->h;
57a33d89	137	if (top_ht) {
f96493b1 EB	138	GHashTableIter iter;
	139	const char *key;
	140
	141	g_hash_table_iter_init(&iter, top_ht);
	142	if (g_hash_table_iter_next(&iter, (void **)&key, NULL)) {
c6bd8c70	143	error_setg(errp, QERR_QMP_EXTRA_MEMBER, key);
57a33d89	144	}
15c2f669 EB	145	}
	146	}
	147	}
	148
	149	static void qmp_input_pop(Visitor *v)
	150	{
	151	QmpInputVisitor *qiv = to_qiv(v);
	152	StackObject *tos = &qiv->stack[qiv->nb_stack - 1];
	153
	154	assert(qiv->nb_stack > 0);
	155
	156	if (qiv->strict) {
	157	GHashTable * const top_ht = qiv->stack[qiv->nb_stack - 1].h;
	158	if (top_ht) {
57a33d89	159	g_hash_table_unref(top_ht);
e38ac962	160	}
fcf3cb21	161	tos->h = NULL;
e38ac962 PB	162	}
e38ac962 PB	163
c40cc0a0	164	qiv->nb_stack--;
c40cc0a0 MR	165	}
c40cc0a0 MR	166
0b2a0d6b	167	static void qmp_input_start_struct(Visitor v, const char name, void **obj,
337283df	168	size_t size, Error **errp)
c40cc0a0 MR	169	{
c40cc0a0 MR	170	QmpInputVisitor *qiv = to_qiv(v);
e8316d7e	171	QObject *qobj = qmp_input_get_object(qiv, name, true);
8b714d37	172	Error *err = NULL;
c40cc0a0	173
e58d695e EB	174	if (obj) {
	175	*obj = NULL;
	176	}
c40cc0a0	177	if (!qobj \|\| qobject_type(qobj) != QTYPE_QDICT) {
c6bd8c70 MA	178	error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
c6bd8c70 MA	179	"QDict");
c40cc0a0 MR	180	return;
	181	}
	182
8b714d37 PB	183	qmp_input_push(qiv, qobj, &err);
	184	if (err) {
	185	error_propagate(errp, err);
c40cc0a0 MR	186	return;
	187	}
	188
	189	if (obj) {
7267c094	190	*obj = g_malloc0(size);
c40cc0a0 MR	191	}
	192	}
	193
c40cc0a0 MR	194
	195	static void qmp_input_start_list(Visitor v, const char name, Error **errp)
	196	{
	197	QmpInputVisitor *qiv = to_qiv(v);
e8316d7e	198	QObject *qobj = qmp_input_get_object(qiv, name, true);
c40cc0a0 MR	199
c40cc0a0 MR	200	if (!qobj \|\| qobject_type(qobj) != QTYPE_QLIST) {
c6bd8c70 MA	201	error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
c6bd8c70 MA	202	"list");
c40cc0a0 MR	203	return;
	204	}
	205
	206	qmp_input_push(qiv, qobj, errp);
	207	}
	208
e65d89bf EB	209	static GenericList qmp_input_next_list(Visitor v, GenericList **list,
e65d89bf EB	210	size_t size)
c40cc0a0 MR	211	{
	212	QmpInputVisitor *qiv = to_qiv(v);
	213	GenericList *entry;
	214	StackObject *so = &qiv->stack[qiv->nb_stack - 1];
	215
fcf3cb21	216	if (!so->entry) {
c40cc0a0 MR	217	return NULL;
	218	}
	219
e65d89bf	220	entry = g_malloc0(size);
fcf3cb21	221	if (so->first) {
3a86a0fa	222	*list = entry;
fcf3cb21	223	so->first = false;
3a86a0fa	224	} else {
c40cc0a0 MR	225	(*list)->next = entry;
c40cc0a0 MR	226	}
c40cc0a0 MR	227
	228	return entry;
	229	}
	230
c40cc0a0	231
dbf11922 EB	232	static void qmp_input_start_alternate(Visitor v, const char name,
	233	GenericAlternate **obj, size_t size,
	234	bool promote_int, Error **errp)
69dd62df KW	235	{
	236	QmpInputVisitor *qiv = to_qiv(v);
	237	QObject *qobj = qmp_input_get_object(qiv, name, false);
	238
	239	if (!qobj) {
dbf11922	240	*obj = NULL;
c6bd8c70	241	error_setg(errp, QERR_MISSING_PARAMETER, name ? name : "null");
69dd62df KW	242	return;
69dd62df KW	243	}
dbf11922 EB	244	*obj = g_malloc0(size);
	245	(*obj)->type = qobject_type(qobj);
	246	if (promote_int && (*obj)->type == QTYPE_QINT) {
	247	(*obj)->type = QTYPE_QFLOAT;
d00341af	248	}
69dd62df KW	249	}
69dd62df KW	250
0b2a0d6b	251	static void qmp_input_type_int64(Visitor v, const char name, int64_t *obj,
4c40314a	252	Error **errp)
c40cc0a0 MR	253	{
c40cc0a0 MR	254	QmpInputVisitor *qiv = to_qiv(v);
fcf73f66	255	QInt *qint = qobject_to_qint(qmp_input_get_object(qiv, name, true));
c40cc0a0	256
fcf73f66	257	if (!qint) {
c6bd8c70 MA	258	error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
c6bd8c70 MA	259	"integer");
c40cc0a0 MR	260	return;
	261	}
	262
fcf73f66	263	*obj = qint_get_int(qint);
c40cc0a0 MR	264	}
c40cc0a0 MR	265
0b2a0d6b	266	static void qmp_input_type_uint64(Visitor v, const char name, uint64_t *obj,
f755dea7 EB	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
0b2a0d6b	282	static void qmp_input_type_bool(Visitor v, const char name, bool *obj,
c40cc0a0 MR	283	Error **errp)
	284	{
	285	QmpInputVisitor *qiv = to_qiv(v);
14b61600	286	QBool *qbool = qobject_to_qbool(qmp_input_get_object(qiv, name, true));
c40cc0a0	287
14b61600	288	if (!qbool) {
c6bd8c70 MA	289	error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
c6bd8c70 MA	290	"boolean");
c40cc0a0 MR	291	return;
	292	}
	293
14b61600	294	*obj = qbool_get_bool(qbool);
c40cc0a0 MR	295	}
c40cc0a0 MR	296
0b2a0d6b	297	static void qmp_input_type_str(Visitor v, const char name, char **obj,
c40cc0a0 MR	298	Error **errp)
	299	{
	300	QmpInputVisitor *qiv = to_qiv(v);
7f027843	301	QString *qstr = qobject_to_qstring(qmp_input_get_object(qiv, name, true));
c40cc0a0	302
7f027843	303	if (!qstr) {
e58d695e	304	*obj = NULL;
c6bd8c70 MA	305	error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
c6bd8c70 MA	306	"string");
c40cc0a0 MR	307	return;
	308	}
	309
7f027843	310	*obj = g_strdup(qstring_get_str(qstr));
c40cc0a0 MR	311	}
c40cc0a0 MR	312
0b2a0d6b	313	static void qmp_input_type_number(Visitor v, const char name, double *obj,
c40cc0a0 MR	314	Error **errp)
	315	{
	316	QmpInputVisitor *qiv = to_qiv(v);
e8316d7e	317	QObject *qobj = qmp_input_get_object(qiv, name, true);
fcf73f66 MA	318	QInt *qint;
fcf73f66 MA	319	QFloat *qfloat;
c40cc0a0	320
fcf73f66 MA	321	qint = qobject_to_qint(qobj);
	322	if (qint) {
	323	*obj = qint_get_int(qobject_to_qint(qobj));
c40cc0a0 MR	324	return;
	325	}
	326
fcf73f66 MA	327	qfloat = qobject_to_qfloat(qobj);
fcf73f66 MA	328	if (qfloat) {
1ee51876	329	*obj = qfloat_get_double(qobject_to_qfloat(qobj));
fcf73f66	330	return;
1ee51876	331	}
fcf73f66 MA	332
	333	error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
	334	"number");
c40cc0a0 MR	335	}
c40cc0a0 MR	336
0b2a0d6b	337	static void qmp_input_type_any(Visitor v, const char name, QObject **obj,
28770e05 MA	338	Error **errp)
	339	{
	340	QmpInputVisitor *qiv = to_qiv(v);
	341	QObject *qobj = qmp_input_get_object(qiv, name, true);
	342
	343	qobject_incref(qobj);
	344	*obj = qobj;
	345	}
	346
3bc97fd5 EB	347	static void qmp_input_type_null(Visitor v, const char name, Error **errp)
3bc97fd5 EB	348	{
3df016f1 EB	349	QmpInputVisitor *qiv = to_qiv(v);
	350	QObject *qobj = qmp_input_get_object(qiv, name, true);
	351
	352	if (qobject_type(qobj) != QTYPE_QNULL) {
	353	error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
	354	"null");
	355	}
3bc97fd5 EB	356	}
3bc97fd5 EB	357
0b2a0d6b	358	static void qmp_input_optional(Visitor v, const char name, bool *present)
c40cc0a0 MR	359	{
c40cc0a0 MR	360	QmpInputVisitor *qiv = to_qiv(v);
e5826a2f	361	QObject *qobj = qmp_input_get_object(qiv, name, false);
c40cc0a0 MR	362
	363	if (!qobj) {
	364	*present = false;
	365	return;
	366	}
	367
	368	*present = true;
	369	}
	370
c40cc0a0 MR	371	Visitor qmp_input_get_visitor(QmpInputVisitor v)
	372	{
	373	return &v->visitor;
	374	}
	375
	376	void qmp_input_visitor_cleanup(QmpInputVisitor *v)
	377	{
ce140b17	378	qobject_decref(v->root);
7267c094	379	g_free(v);
c40cc0a0 MR	380	}
c40cc0a0 MR	381
fc471c18	382	QmpInputVisitor qmp_input_visitor_new(QObject obj, bool strict)
c40cc0a0 MR	383	{
	384	QmpInputVisitor *v;
	385
7267c094	386	v = g_malloc0(sizeof(*v));
c40cc0a0	387
983f52d4	388	v->visitor.type = VISITOR_INPUT;
c40cc0a0	389	v->visitor.start_struct = qmp_input_start_struct;
15c2f669 EB	390	v->visitor.check_struct = qmp_input_check_struct;
15c2f669 EB	391	v->visitor.end_struct = qmp_input_pop;
c40cc0a0 MR	392	v->visitor.start_list = qmp_input_start_list;
c40cc0a0 MR	393	v->visitor.next_list = qmp_input_next_list;
15c2f669	394	v->visitor.end_list = qmp_input_pop;
dbf11922	395	v->visitor.start_alternate = qmp_input_start_alternate;
4c40314a	396	v->visitor.type_int64 = qmp_input_type_int64;
f755dea7	397	v->visitor.type_uint64 = qmp_input_type_uint64;
c40cc0a0 MR	398	v->visitor.type_bool = qmp_input_type_bool;
	399	v->visitor.type_str = qmp_input_type_str;
	400	v->visitor.type_number = qmp_input_type_number;
28770e05	401	v->visitor.type_any = qmp_input_type_any;
3bc97fd5	402	v->visitor.type_null = qmp_input_type_null;
e2cd0f4f	403	v->visitor.optional = qmp_input_optional;
fc471c18	404	v->strict = strict;
c40cc0a0	405
ce140b17	406	v->root = obj;
4faaec6a	407	qobject_incref(obj);
c40cc0a0 MR	408
	409	return v;
	410	}