[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_pop(QmpInputVisitor *qiv, Error **errp)
{
    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);
            }
            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_end_struct(Visitor *v, Error **errp)
{
    QmpInputVisitor *qiv = to_qiv(v);

    qmp_input_pop(qiv, errp);
}

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_end_list(Visitor *v)
{
    QmpInputVisitor *qiv = to_qiv(v);

    qmp_input_pop(qiv, &error_abort);
}

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)
{
    abort();
}

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.end_struct = qmp_input_end_struct;
    v->visitor.start_list = qmp_input_start_list;
    v->visitor.next_list = qmp_input_next_list;
    v->visitor.end_list = qmp_input_end_list;
    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
c40cc0a0 MR	128	static void qmp_input_pop(QmpInputVisitor qiv, Error *errp)
c40cc0a0 MR	129	{
fcf3cb21	130	StackObject *tos = &qiv->stack[qiv->nb_stack - 1];
57a33d89	131	assert(qiv->nb_stack > 0);
e38ac962	132
57a33d89	133	if (qiv->strict) {
fcf3cb21	134	GHashTable *const top_ht = tos->h;
57a33d89	135	if (top_ht) {
f96493b1 EB	136	GHashTableIter iter;
	137	const char *key;
	138
	139	g_hash_table_iter_init(&iter, top_ht);
	140	if (g_hash_table_iter_next(&iter, (void **)&key, NULL)) {
c6bd8c70	141	error_setg(errp, QERR_QMP_EXTRA_MEMBER, key);
57a33d89 NK	142	}
57a33d89 NK	143	g_hash_table_unref(top_ht);
e38ac962	144	}
fcf3cb21	145	tos->h = NULL;
e38ac962 PB	146	}
e38ac962 PB	147
c40cc0a0	148	qiv->nb_stack--;
c40cc0a0 MR	149	}
c40cc0a0 MR	150
0b2a0d6b	151	static void qmp_input_start_struct(Visitor v, const char name, void **obj,
337283df	152	size_t size, Error **errp)
c40cc0a0 MR	153	{
c40cc0a0 MR	154	QmpInputVisitor *qiv = to_qiv(v);
e8316d7e	155	QObject *qobj = qmp_input_get_object(qiv, name, true);
8b714d37	156	Error *err = NULL;
c40cc0a0	157
e58d695e EB	158	if (obj) {
	159	*obj = NULL;
	160	}
c40cc0a0	161	if (!qobj \|\| qobject_type(qobj) != QTYPE_QDICT) {
c6bd8c70 MA	162	error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
c6bd8c70 MA	163	"QDict");
c40cc0a0 MR	164	return;
	165	}
	166
8b714d37 PB	167	qmp_input_push(qiv, qobj, &err);
	168	if (err) {
	169	error_propagate(errp, err);
c40cc0a0 MR	170	return;
	171	}
	172
	173	if (obj) {
7267c094	174	*obj = g_malloc0(size);
c40cc0a0 MR	175	}
	176	}
	177
	178	static void qmp_input_end_struct(Visitor v, Error *errp)
	179	{
	180	QmpInputVisitor *qiv = to_qiv(v);
	181
	182	qmp_input_pop(qiv, errp);
	183	}
	184
	185	static void qmp_input_start_list(Visitor v, const char name, Error **errp)
	186	{
	187	QmpInputVisitor *qiv = to_qiv(v);
e8316d7e	188	QObject *qobj = qmp_input_get_object(qiv, name, true);
c40cc0a0 MR	189
c40cc0a0 MR	190	if (!qobj \|\| qobject_type(qobj) != QTYPE_QLIST) {
c6bd8c70 MA	191	error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
c6bd8c70 MA	192	"list");
c40cc0a0 MR	193	return;
	194	}
	195
	196	qmp_input_push(qiv, qobj, errp);
	197	}
	198
e65d89bf EB	199	static GenericList qmp_input_next_list(Visitor v, GenericList **list,
e65d89bf EB	200	size_t size)
c40cc0a0 MR	201	{
	202	QmpInputVisitor *qiv = to_qiv(v);
	203	GenericList *entry;
	204	StackObject *so = &qiv->stack[qiv->nb_stack - 1];
	205
fcf3cb21	206	if (!so->entry) {
c40cc0a0 MR	207	return NULL;
	208	}
	209
e65d89bf	210	entry = g_malloc0(size);
fcf3cb21	211	if (so->first) {
3a86a0fa	212	*list = entry;
fcf3cb21	213	so->first = false;
3a86a0fa	214	} else {
c40cc0a0 MR	215	(*list)->next = entry;
c40cc0a0 MR	216	}
c40cc0a0 MR	217
	218	return entry;
	219	}
	220
08f9541d	221	static void qmp_input_end_list(Visitor *v)
c40cc0a0 MR	222	{
	223	QmpInputVisitor *qiv = to_qiv(v);
	224
bdd8e6b5	225	qmp_input_pop(qiv, &error_abort);
c40cc0a0 MR	226	}
c40cc0a0 MR	227
dbf11922 EB	228	static void qmp_input_start_alternate(Visitor v, const char name,
	229	GenericAlternate **obj, size_t size,
	230	bool promote_int, Error **errp)
69dd62df KW	231	{
	232	QmpInputVisitor *qiv = to_qiv(v);
	233	QObject *qobj = qmp_input_get_object(qiv, name, false);
	234
	235	if (!qobj) {
dbf11922	236	*obj = NULL;
c6bd8c70	237	error_setg(errp, QERR_MISSING_PARAMETER, name ? name : "null");
69dd62df KW	238	return;
69dd62df KW	239	}
dbf11922 EB	240	*obj = g_malloc0(size);
	241	(*obj)->type = qobject_type(qobj);
	242	if (promote_int && (*obj)->type == QTYPE_QINT) {
	243	(*obj)->type = QTYPE_QFLOAT;
d00341af	244	}
69dd62df KW	245	}
69dd62df KW	246
0b2a0d6b	247	static void qmp_input_type_int64(Visitor v, const char name, int64_t *obj,
4c40314a	248	Error **errp)
c40cc0a0 MR	249	{
c40cc0a0 MR	250	QmpInputVisitor *qiv = to_qiv(v);
fcf73f66	251	QInt *qint = qobject_to_qint(qmp_input_get_object(qiv, name, true));
c40cc0a0	252
fcf73f66	253	if (!qint) {
c6bd8c70 MA	254	error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
c6bd8c70 MA	255	"integer");
c40cc0a0 MR	256	return;
	257	}
	258
fcf73f66	259	*obj = qint_get_int(qint);
c40cc0a0 MR	260	}
c40cc0a0 MR	261
0b2a0d6b	262	static void qmp_input_type_uint64(Visitor v, const char name, uint64_t *obj,
f755dea7 EB	263	Error **errp)
	264	{
	265	/* FIXME: qobject_to_qint mishandles values over INT64_MAX */
	266	QmpInputVisitor *qiv = to_qiv(v);
	267	QInt *qint = qobject_to_qint(qmp_input_get_object(qiv, name, true));
	268
	269	if (!qint) {
	270	error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
	271	"integer");
	272	return;
	273	}
	274
	275	*obj = qint_get_int(qint);
	276	}
	277
0b2a0d6b	278	static void qmp_input_type_bool(Visitor v, const char name, bool *obj,
c40cc0a0 MR	279	Error **errp)
	280	{
	281	QmpInputVisitor *qiv = to_qiv(v);
14b61600	282	QBool *qbool = qobject_to_qbool(qmp_input_get_object(qiv, name, true));
c40cc0a0	283
14b61600	284	if (!qbool) {
c6bd8c70 MA	285	error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
c6bd8c70 MA	286	"boolean");
c40cc0a0 MR	287	return;
	288	}
	289
14b61600	290	*obj = qbool_get_bool(qbool);
c40cc0a0 MR	291	}
c40cc0a0 MR	292
0b2a0d6b	293	static void qmp_input_type_str(Visitor v, const char name, char **obj,
c40cc0a0 MR	294	Error **errp)
	295	{
	296	QmpInputVisitor *qiv = to_qiv(v);
7f027843	297	QString *qstr = qobject_to_qstring(qmp_input_get_object(qiv, name, true));
c40cc0a0	298
7f027843	299	if (!qstr) {
e58d695e	300	*obj = NULL;
c6bd8c70 MA	301	error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
c6bd8c70 MA	302	"string");
c40cc0a0 MR	303	return;
	304	}
	305
7f027843	306	*obj = g_strdup(qstring_get_str(qstr));
c40cc0a0 MR	307	}
c40cc0a0 MR	308
0b2a0d6b	309	static void qmp_input_type_number(Visitor v, const char name, double *obj,
c40cc0a0 MR	310	Error **errp)
	311	{
	312	QmpInputVisitor *qiv = to_qiv(v);
e8316d7e	313	QObject *qobj = qmp_input_get_object(qiv, name, true);
fcf73f66 MA	314	QInt *qint;
fcf73f66 MA	315	QFloat *qfloat;
c40cc0a0	316
fcf73f66 MA	317	qint = qobject_to_qint(qobj);
	318	if (qint) {
	319	*obj = qint_get_int(qobject_to_qint(qobj));
c40cc0a0 MR	320	return;
	321	}
	322
fcf73f66 MA	323	qfloat = qobject_to_qfloat(qobj);
fcf73f66 MA	324	if (qfloat) {
1ee51876	325	*obj = qfloat_get_double(qobject_to_qfloat(qobj));
fcf73f66	326	return;
1ee51876	327	}
fcf73f66 MA	328
	329	error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
	330	"number");
c40cc0a0 MR	331	}
c40cc0a0 MR	332
0b2a0d6b	333	static void qmp_input_type_any(Visitor v, const char name, QObject **obj,
28770e05 MA	334	Error **errp)
	335	{
	336	QmpInputVisitor *qiv = to_qiv(v);
	337	QObject *qobj = qmp_input_get_object(qiv, name, true);
	338
	339	qobject_incref(qobj);
	340	*obj = qobj;
	341	}
	342
3bc97fd5 EB	343	static void qmp_input_type_null(Visitor v, const char name, Error **errp)
	344	{
	345	abort();
	346	}
	347
0b2a0d6b	348	static void qmp_input_optional(Visitor v, const char name, bool *present)
c40cc0a0 MR	349	{
c40cc0a0 MR	350	QmpInputVisitor *qiv = to_qiv(v);
e5826a2f	351	QObject *qobj = qmp_input_get_object(qiv, name, false);
c40cc0a0 MR	352
	353	if (!qobj) {
	354	*present = false;
	355	return;
	356	}
	357
	358	*present = true;
	359	}
	360
c40cc0a0 MR	361	Visitor qmp_input_get_visitor(QmpInputVisitor v)
	362	{
	363	return &v->visitor;
	364	}
	365
	366	void qmp_input_visitor_cleanup(QmpInputVisitor *v)
	367	{
ce140b17	368	qobject_decref(v->root);
7267c094	369	g_free(v);
c40cc0a0 MR	370	}
c40cc0a0 MR	371
fc471c18	372	QmpInputVisitor qmp_input_visitor_new(QObject obj, bool strict)
c40cc0a0 MR	373	{
	374	QmpInputVisitor *v;
	375
7267c094	376	v = g_malloc0(sizeof(*v));
c40cc0a0	377
983f52d4	378	v->visitor.type = VISITOR_INPUT;
c40cc0a0 MR	379	v->visitor.start_struct = qmp_input_start_struct;
	380	v->visitor.end_struct = qmp_input_end_struct;
	381	v->visitor.start_list = qmp_input_start_list;
	382	v->visitor.next_list = qmp_input_next_list;
	383	v->visitor.end_list = qmp_input_end_list;
dbf11922	384	v->visitor.start_alternate = qmp_input_start_alternate;
4c40314a	385	v->visitor.type_int64 = qmp_input_type_int64;
f755dea7	386	v->visitor.type_uint64 = qmp_input_type_uint64;
c40cc0a0 MR	387	v->visitor.type_bool = qmp_input_type_bool;
	388	v->visitor.type_str = qmp_input_type_str;
	389	v->visitor.type_number = qmp_input_type_number;
28770e05	390	v->visitor.type_any = qmp_input_type_any;
3bc97fd5	391	v->visitor.type_null = qmp_input_type_null;
e2cd0f4f	392	v->visitor.optional = qmp_input_optional;
fc471c18	393	v->strict = strict;
c40cc0a0	394
ce140b17	395	v->root = obj;
4faaec6a	396	qobject_incref(obj);
c40cc0a0 MR	397
	398	return v;
	399	}