[thirdparty/qemu.git] / qapi / string-input-visitor.c

/*
 * String parsing visitor
 *
 * Copyright Red Hat, Inc. 2012-2016
 *
 * Author: Paolo Bonzini <pbonzini@redhat.com>
 *         David Hildenbrand <david@redhat.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 "qemu-common.h"
#include "qapi/string-input-visitor.h"
#include "qapi/visitor-impl.h"
#include "qapi/qmp/qerror.h"
#include "qapi/qmp/qnull.h"
#include "qemu/option.h"
#include "qemu/cutils.h"

typedef enum ListMode {
    /* no list parsing active / no list expected */
    LM_NONE,
    /* we have an unparsed string remaining */
    LM_UNPARSED,
    /* we have an unfinished int64 range */
    LM_INT64_RANGE,
    /* we have an unfinished uint64 range */
    LM_UINT64_RANGE,
    /* we have parsed the string completely and no range is remaining */
    LM_END,
} ListMode;

/* protect against DOS attacks, limit the amount of elements per range */
#define RANGE_MAX_ELEMENTS 65536

typedef union RangeElement {
    int64_t i64;
    uint64_t u64;
} RangeElement;

struct StringInputVisitor
{
    Visitor visitor;

    /* List parsing state */
    ListMode lm;
    RangeElement rangeNext;
    RangeElement rangeEnd;
    const char *unparsed_string;
    void *list;

    /* The original string to parse */
    const char *string;
};

static StringInputVisitor *to_siv(Visitor *v)
{
    return container_of(v, StringInputVisitor, visitor);
}

static void start_list(Visitor *v, const char *name, GenericList **list,
                       size_t size, Error **errp)
{
    StringInputVisitor *siv = to_siv(v);

    assert(siv->lm == LM_NONE);
    siv->list = list;
    siv->unparsed_string = siv->string;

    if (!siv->string[0]) {
        if (list) {
            *list = NULL;
        }
        siv->lm = LM_END;
    } else {
        if (list) {
            *list = g_malloc0(size);
        }
        siv->lm = LM_UNPARSED;
    }
}

static GenericList *next_list(Visitor *v, GenericList *tail, size_t size)
{
    StringInputVisitor *siv = to_siv(v);

    switch (siv->lm) {
    case LM_END:
        return NULL;
    case LM_INT64_RANGE:
    case LM_UINT64_RANGE:
    case LM_UNPARSED:
        /* we have an unparsed string or something left in a range */
        break;
    default:
        abort();
    }

    tail->next = g_malloc0(size);
    return tail->next;
}

static void check_list(Visitor *v, Error **errp)
{
    const StringInputVisitor *siv = to_siv(v);

    switch (siv->lm) {
    case LM_INT64_RANGE:
    case LM_UINT64_RANGE:
    case LM_UNPARSED:
        error_setg(errp, "Fewer list elements expected");
        return;
    case LM_END:
        return;
    default:
        abort();
    }
}

static void end_list(Visitor *v, void **obj)
{
    StringInputVisitor *siv = to_siv(v);

    assert(siv->lm != LM_NONE);
    assert(siv->list == obj);
    siv->list = NULL;
    siv->unparsed_string = NULL;
    siv->lm = LM_NONE;
}

static int try_parse_int64_list_entry(StringInputVisitor *siv, int64_t *obj)
{
    const char *endptr;
    int64_t start, end;

    /* parse a simple int64 or range */
    if (qemu_strtoi64(siv->unparsed_string, &endptr, 0, &start)) {
        return -EINVAL;
    }
    end = start;

    switch (endptr[0]) {
    case '\0':
        siv->unparsed_string = endptr;
        break;
    case ',':
        siv->unparsed_string = endptr + 1;
        break;
    case '-':
        /* parse the end of the range */
        if (qemu_strtoi64(endptr + 1, &endptr, 0, &end)) {
            return -EINVAL;
        }
        if (start > end || end - start >= RANGE_MAX_ELEMENTS) {
            return -EINVAL;
        }
        switch (endptr[0]) {
        case '\0':
            siv->unparsed_string = endptr;
            break;
        case ',':
            siv->unparsed_string = endptr + 1;
            break;
        default:
            return -EINVAL;
        }
        break;
    default:
        return -EINVAL;
    }

    /* we have a proper range (with maybe only one element) */
    siv->lm = LM_INT64_RANGE;
    siv->rangeNext.i64 = start;
    siv->rangeEnd.i64 = end;
    return 0;
}

static void parse_type_int64(Visitor *v, const char *name, int64_t *obj,
                             Error **errp)
{
    StringInputVisitor *siv = to_siv(v);
    int64_t val;

    switch (siv->lm) {
    case LM_NONE:
        /* just parse a simple int64, bail out if not completely consumed */
        if (qemu_strtoi64(siv->string, NULL, 0, &val)) {
                error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
                           name ? name : "null", "int64");
            return;
        }
        *obj = val;
        return;
    case LM_UNPARSED:
        if (try_parse_int64_list_entry(siv, obj)) {
            error_setg(errp, QERR_INVALID_PARAMETER_VALUE, name ? name : "null",
                       "list of int64 values or ranges");
            return;
        }
        assert(siv->lm == LM_INT64_RANGE);
        /* fall through */
    case LM_INT64_RANGE:
        /* return the next element in the range */
        assert(siv->rangeNext.i64 <= siv->rangeEnd.i64);
        *obj = siv->rangeNext.i64++;

        if (siv->rangeNext.i64 > siv->rangeEnd.i64 || *obj == INT64_MAX) {
            /* end of range, check if there is more to parse */
            siv->lm = siv->unparsed_string[0] ? LM_UNPARSED : LM_END;
        }
        return;
    case LM_END:
        error_setg(errp, "Fewer list elements expected");
        return;
    default:
        abort();
    }
}

static int try_parse_uint64_list_entry(StringInputVisitor *siv, uint64_t *obj)
{
    const char *endptr;
    uint64_t start, end;

    /* parse a simple uint64 or range */
    if (qemu_strtou64(siv->unparsed_string, &endptr, 0, &start)) {
        return -EINVAL;
    }
    end = start;

    switch (endptr[0]) {
    case '\0':
        siv->unparsed_string = endptr;
        break;
    case ',':
        siv->unparsed_string = endptr + 1;
        break;
    case '-':
        /* parse the end of the range */
        if (qemu_strtou64(endptr + 1, &endptr, 0, &end)) {
            return -EINVAL;
        }
        if (start > end || end - start >= RANGE_MAX_ELEMENTS) {
            return -EINVAL;
        }
        switch (endptr[0]) {
        case '\0':
            siv->unparsed_string = endptr;
            break;
        case ',':
            siv->unparsed_string = endptr + 1;
            break;
        default:
            return -EINVAL;
        }
        break;
    default:
        return -EINVAL;
    }

    /* we have a proper range (with maybe only one element) */
    siv->lm = LM_UINT64_RANGE;
    siv->rangeNext.u64 = start;
    siv->rangeEnd.u64 = end;
    return 0;
}

static void parse_type_uint64(Visitor *v, const char *name, uint64_t *obj,
                              Error **errp)
{
    StringInputVisitor *siv = to_siv(v);
    uint64_t val;

    switch (siv->lm) {
    case LM_NONE:
        /* just parse a simple uint64, bail out if not completely consumed */
        if (qemu_strtou64(siv->string, NULL, 0, &val)) {
            error_setg(errp, QERR_INVALID_PARAMETER_VALUE, name ? name : "null",
                       "uint64");
            return;
        }
        *obj = val;
        return;
    case LM_UNPARSED:
        if (try_parse_uint64_list_entry(siv, obj)) {
            error_setg(errp, QERR_INVALID_PARAMETER_VALUE, name ? name : "null",
                       "list of uint64 values or ranges");
            return;
        }
        assert(siv->lm == LM_UINT64_RANGE);
        /* fall through */
    case LM_UINT64_RANGE:
        /* return the next element in the range */
        assert(siv->rangeNext.u64 <= siv->rangeEnd.u64);
        *obj = siv->rangeNext.u64++;

        if (siv->rangeNext.u64 > siv->rangeEnd.u64 || *obj == UINT64_MAX) {
            /* end of range, check if there is more to parse */
            siv->lm = siv->unparsed_string[0] ? LM_UNPARSED : LM_END;
        }
        return;
    case LM_END:
        error_setg(errp, "Fewer list elements expected");
        return;
    default:
        abort();
    }
}

static void parse_type_size(Visitor *v, const char *name, uint64_t *obj,
                            Error **errp)
{
    StringInputVisitor *siv = to_siv(v);
    Error *err = NULL;
    uint64_t val;

    assert(siv->lm == LM_NONE);
    parse_option_size(name, siv->string, &val, &err);
    if (err) {
        error_propagate(errp, err);
        return;
    }

    *obj = val;
}

static void parse_type_bool(Visitor *v, const char *name, bool *obj,
                            Error **errp)
{
    StringInputVisitor *siv = to_siv(v);

    assert(siv->lm == LM_NONE);
    if (!strcasecmp(siv->string, "on") ||
        !strcasecmp(siv->string, "yes") ||
        !strcasecmp(siv->string, "true")) {
        *obj = true;
        return;
    }
    if (!strcasecmp(siv->string, "off") ||
        !strcasecmp(siv->string, "no") ||
        !strcasecmp(siv->string, "false")) {
        *obj = false;
        return;
    }

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

static void parse_type_str(Visitor *v, const char *name, char **obj,
                           Error **errp)
{
    StringInputVisitor *siv = to_siv(v);

    assert(siv->lm == LM_NONE);
    *obj = g_strdup(siv->string);
}

static void parse_type_number(Visitor *v, const char *name, double *obj,
                              Error **errp)
{
    StringInputVisitor *siv = to_siv(v);
    double val;

    assert(siv->lm == LM_NONE);
    if (qemu_strtod_finite(siv->string, NULL, &val)) {
        error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
                   "number");
        return;
    }

    *obj = val;
}

static void parse_type_null(Visitor *v, const char *name, QNull **obj,
                            Error **errp)
{
    StringInputVisitor *siv = to_siv(v);

    assert(siv->lm == LM_NONE);
    *obj = NULL;

    if (siv->string[0]) {
        error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
                   "null");
        return;
    }

    *obj = qnull();
}

static void string_input_free(Visitor *v)
{
    StringInputVisitor *siv = to_siv(v);

    g_free(siv);
}

Visitor *string_input_visitor_new(const char *str)
{
    StringInputVisitor *v;

    assert(str);
    v = g_malloc0(sizeof(*v));

    v->visitor.type = VISITOR_INPUT;
    v->visitor.type_int64 = parse_type_int64;
    v->visitor.type_uint64 = parse_type_uint64;
    v->visitor.type_size = parse_type_size;
    v->visitor.type_bool = parse_type_bool;
    v->visitor.type_str = parse_type_str;
    v->visitor.type_number = parse_type_number;
    v->visitor.type_null = parse_type_null;
    v->visitor.start_list = start_list;
    v->visitor.next_list = next_list;
    v->visitor.check_list = check_list;
    v->visitor.end_list = end_list;
    v->visitor.free = string_input_free;

    v->string = str;
    v->lm = LM_NONE;
    return &v->visitor;
}
Commit	Line	Data
a020f980 PB	1	/*
	2	* String parsing visitor
	3	*
08f9541d	4	* Copyright Red Hat, Inc. 2012-2016
a020f980 PB	5	*
a020f980 PB	6	* Author: Paolo Bonzini <pbonzini@redhat.com>
c9fba9de	7	* David Hildenbrand <david@redhat.com>
a020f980 PB	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.
a020f980 PB	11	*/
a020f980 PB	12
cbf21151	13	#include "qemu/osdep.h"
da34e65c	14	#include "qapi/error.h"
a020f980	15	#include "qemu-common.h"
7b1b5d19 PB	16	#include "qapi/string-input-visitor.h"
	17	#include "qapi/visitor-impl.h"
	18	#include "qapi/qmp/qerror.h"
84be629d	19	#include "qapi/qmp/qnull.h"
a5829ccf	20	#include "qemu/option.h"
4b69d4c3	21	#include "qemu/cutils.h"
659268ff	22
c9fba9de DH	23	typedef enum ListMode {
	24	/* no list parsing active / no list expected */
	25	LM_NONE,
	26	/* we have an unparsed string remaining */
	27	LM_UNPARSED,
	28	/* we have an unfinished int64 range */
	29	LM_INT64_RANGE,
	30	/* we have an unfinished uint64 range */
	31	LM_UINT64_RANGE,
	32	/* we have parsed the string completely and no range is remaining */
	33	LM_END,
	34	} ListMode;
	35
	36	/* protect against DOS attacks, limit the amount of elements per range */
	37	#define RANGE_MAX_ELEMENTS 65536
	38
	39	typedef union RangeElement {
	40	int64_t i64;
	41	uint64_t u64;
	42	} RangeElement;
a020f980 PB	43
	44	struct StringInputVisitor
	45	{
	46	Visitor visitor;
659268ff	47
c9fba9de DH	48	/* List parsing state */
	49	ListMode lm;
	50	RangeElement rangeNext;
	51	RangeElement rangeEnd;
	52	const char *unparsed_string;
	53	void *list;
659268ff	54
c9fba9de	55	/* The original string to parse */
a020f980 PB	56	const char *string;
	57	};
	58
d7bea75d EB	59	static StringInputVisitor to_siv(Visitor v)
	60	{
	61	return container_of(v, StringInputVisitor, visitor);
	62	}
	63
c9fba9de DH	64	static void start_list(Visitor v, const char name, GenericList **list,
c9fba9de DH	65	size_t size, Error **errp)
659268ff	66	{
d7bea75d	67	StringInputVisitor *siv = to_siv(v);
659268ff	68
c9fba9de	69	assert(siv->lm == LM_NONE);
1158bb2a	70	siv->list = list;
c9fba9de	71	siv->unparsed_string = siv->string;
d9f62dde	72
c9fba9de DH	73	if (!siv->string[0]) {
	74	if (list) {
	75	*list = NULL;
659268ff	76	}
c9fba9de	77	siv->lm = LM_END;
d9f62dde	78	} else {
c9fba9de DH	79	if (list) {
	80	*list = g_malloc0(size);
	81	}
	82	siv->lm = LM_UNPARSED;
659268ff HT	83	}
	84	}
	85
d9f62dde	86	static GenericList next_list(Visitor v, GenericList *tail, size_t size)
659268ff	87	{
d7bea75d	88	StringInputVisitor *siv = to_siv(v);
659268ff	89
c9fba9de DH	90	switch (siv->lm) {
c9fba9de DH	91	case LM_END:
659268ff	92	return NULL;
c9fba9de DH	93	case LM_INT64_RANGE:
	94	case LM_UINT64_RANGE:
	95	case LM_UNPARSED:
	96	/* we have an unparsed string or something left in a range */
	97	break;
	98	default:
	99	abort();
659268ff HT	100	}
659268ff HT	101
d9f62dde EB	102	tail->next = g_malloc0(size);
d9f62dde EB	103	return tail->next;
659268ff HT	104	}
659268ff HT	105
a4a1c70d MA	106	static void check_list(Visitor v, Error *errp)
	107	{
	108	const StringInputVisitor *siv = to_siv(v);
a4a1c70d	109
c9fba9de DH	110	switch (siv->lm) {
	111	case LM_INT64_RANGE:
	112	case LM_UINT64_RANGE:
	113	case LM_UNPARSED:
	114	error_setg(errp, "Fewer list elements expected");
a4a1c70d	115	return;
c9fba9de	116	case LM_END:
a4a1c70d	117	return;
c9fba9de DH	118	default:
c9fba9de DH	119	abort();
a4a1c70d	120	}
a4a1c70d MA	121	}
a4a1c70d MA	122
1158bb2a	123	static void end_list(Visitor v, void *obj)
659268ff	124	{
1158bb2a EB	125	StringInputVisitor *siv = to_siv(v);
1158bb2a EB	126
c9fba9de	127	assert(siv->lm != LM_NONE);
1158bb2a	128	assert(siv->list == obj);
c9fba9de DH	129	siv->list = NULL;
	130	siv->unparsed_string = NULL;
	131	siv->lm = LM_NONE;
	132	}
	133
	134	static int try_parse_int64_list_entry(StringInputVisitor siv, int64_t obj)
	135	{
	136	const char *endptr;
	137	int64_t start, end;
	138
	139	/* parse a simple int64 or range */
	140	if (qemu_strtoi64(siv->unparsed_string, &endptr, 0, &start)) {
	141	return -EINVAL;
	142	}
	143	end = start;
	144
	145	switch (endptr[0]) {
	146	case '\0':
	147	siv->unparsed_string = endptr;
	148	break;
	149	case ',':
	150	siv->unparsed_string = endptr + 1;
	151	break;
	152	case '-':
	153	/* parse the end of the range */
	154	if (qemu_strtoi64(endptr + 1, &endptr, 0, &end)) {
	155	return -EINVAL;
	156	}
	157	if (start > end \|\| end - start >= RANGE_MAX_ELEMENTS) {
	158	return -EINVAL;
	159	}
	160	switch (endptr[0]) {
	161	case '\0':
	162	siv->unparsed_string = endptr;
	163	break;
	164	case ',':
	165	siv->unparsed_string = endptr + 1;
	166	break;
	167	default:
	168	return -EINVAL;
	169	}
	170	break;
	171	default:
	172	return -EINVAL;
	173	}
	174
	175	/* we have a proper range (with maybe only one element) */
	176	siv->lm = LM_INT64_RANGE;
	177	siv->rangeNext.i64 = start;
	178	siv->rangeEnd.i64 = end;
	179	return 0;
659268ff HT	180	}
659268ff HT	181
0b2a0d6b	182	static void parse_type_int64(Visitor v, const char name, int64_t *obj,
4c40314a	183	Error **errp)
a020f980	184	{
d7bea75d	185	StringInputVisitor *siv = to_siv(v);
c9fba9de DH	186	int64_t val;
	187
	188	switch (siv->lm) {
	189	case LM_NONE:
	190	/* just parse a simple int64, bail out if not completely consumed */
	191	if (qemu_strtoi64(siv->string, NULL, 0, &val)) {
	192	error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
	193	name ? name : "null", "int64");
	194	return;
	195	}
	196	*obj = val;
74f24cb6	197	return;
c9fba9de DH	198	case LM_UNPARSED:
	199	if (try_parse_int64_list_entry(siv, obj)) {
	200	error_setg(errp, QERR_INVALID_PARAMETER_VALUE, name ? name : "null",
	201	"list of int64 values or ranges");
	202	return;
	203	}
	204	assert(siv->lm == LM_INT64_RANGE);
	205	/* fall through */
	206	case LM_INT64_RANGE:
	207	/* return the next element in the range */
	208	assert(siv->rangeNext.i64 <= siv->rangeEnd.i64);
	209	*obj = siv->rangeNext.i64++;
	210
	211	if (siv->rangeNext.i64 > siv->rangeEnd.i64 \|\| *obj == INT64_MAX) {
	212	/* end of range, check if there is more to parse */
	213	siv->lm = siv->unparsed_string[0] ? LM_UNPARSED : LM_END;
	214	}
	215	return;
	216	case LM_END:
	217	error_setg(errp, "Fewer list elements expected");
	218	return;
	219	default:
	220	abort();
74f24cb6	221	}
c9fba9de	222	}
659268ff	223
c9fba9de DH	224	static int try_parse_uint64_list_entry(StringInputVisitor siv, uint64_t obj)
	225	{
	226	const char *endptr;
	227	uint64_t start, end;
659268ff	228
c9fba9de DH	229	/* parse a simple uint64 or range */
	230	if (qemu_strtou64(siv->unparsed_string, &endptr, 0, &start)) {
	231	return -EINVAL;
	232	}
	233	end = start;
	234
	235	switch (endptr[0]) {
	236	case '\0':
	237	siv->unparsed_string = endptr;
	238	break;
	239	case ',':
	240	siv->unparsed_string = endptr + 1;
	241	break;
	242	case '-':
	243	/* parse the end of the range */
	244	if (qemu_strtou64(endptr + 1, &endptr, 0, &end)) {
	245	return -EINVAL;
659268ff	246	}
c9fba9de DH	247	if (start > end \|\| end - start >= RANGE_MAX_ELEMENTS) {
c9fba9de DH	248	return -EINVAL;
659268ff	249	}
c9fba9de DH	250	switch (endptr[0]) {
	251	case '\0':
	252	siv->unparsed_string = endptr;
	253	break;
	254	case ',':
	255	siv->unparsed_string = endptr + 1;
	256	break;
	257	default:
	258	return -EINVAL;
	259	}
	260	break;
	261	default:
	262	return -EINVAL;
659268ff HT	263	}
659268ff HT	264
c9fba9de DH	265	/* we have a proper range (with maybe only one element) */
	266	siv->lm = LM_UINT64_RANGE;
	267	siv->rangeNext.u64 = start;
	268	siv->rangeEnd.u64 = end;
	269	return 0;
a020f980 PB	270	}
a020f980 PB	271
0b2a0d6b	272	static void parse_type_uint64(Visitor v, const char name, uint64_t *obj,
f755dea7 EB	273	Error **errp)
f755dea7 EB	274	{
c9fba9de DH	275	StringInputVisitor *siv = to_siv(v);
	276	uint64_t val;
	277
	278	switch (siv->lm) {
	279	case LM_NONE:
	280	/* just parse a simple uint64, bail out if not completely consumed */
	281	if (qemu_strtou64(siv->string, NULL, 0, &val)) {
	282	error_setg(errp, QERR_INVALID_PARAMETER_VALUE, name ? name : "null",
	283	"uint64");
	284	return;
	285	}
	286	*obj = val;
	287	return;
	288	case LM_UNPARSED:
	289	if (try_parse_uint64_list_entry(siv, obj)) {
	290	error_setg(errp, QERR_INVALID_PARAMETER_VALUE, name ? name : "null",
	291	"list of uint64 values or ranges");
	292	return;
	293	}
	294	assert(siv->lm == LM_UINT64_RANGE);
	295	/* fall through */
	296	case LM_UINT64_RANGE:
	297	/* return the next element in the range */
	298	assert(siv->rangeNext.u64 <= siv->rangeEnd.u64);
	299	*obj = siv->rangeNext.u64++;
	300
	301	if (siv->rangeNext.u64 > siv->rangeEnd.u64 \|\| *obj == UINT64_MAX) {
	302	/* end of range, check if there is more to parse */
	303	siv->lm = siv->unparsed_string[0] ? LM_UNPARSED : LM_END;
	304	}
	305	return;
	306	case LM_END:
	307	error_setg(errp, "Fewer list elements expected");
	308	return;
	309	default:
	310	abort();
f755dea7 EB	311	}
	312	}
	313
0b2a0d6b	314	static void parse_type_size(Visitor v, const char name, uint64_t *obj,
a5829ccf PB	315	Error **errp)
a5829ccf PB	316	{
d7bea75d	317	StringInputVisitor *siv = to_siv(v);
a5829ccf PB	318	Error *err = NULL;
	319	uint64_t val;
	320
c9fba9de	321	assert(siv->lm == LM_NONE);
f332e830	322	parse_option_size(name, siv->string, &val, &err);
a5829ccf PB	323	if (err) {
	324	error_propagate(errp, err);
	325	return;
	326	}
	327
	328	*obj = val;
	329	}
	330
0b2a0d6b	331	static void parse_type_bool(Visitor v, const char name, bool *obj,
a020f980 PB	332	Error **errp)
a020f980 PB	333	{
d7bea75d	334	StringInputVisitor *siv = to_siv(v);
a020f980	335
c9fba9de	336	assert(siv->lm == LM_NONE);
f332e830 MA	337	if (!strcasecmp(siv->string, "on") \|\|
	338	!strcasecmp(siv->string, "yes") \|\|
	339	!strcasecmp(siv->string, "true")) {
	340	*obj = true;
	341	return;
	342	}
	343	if (!strcasecmp(siv->string, "off") \|\|
	344	!strcasecmp(siv->string, "no") \|\|
	345	!strcasecmp(siv->string, "false")) {
	346	*obj = false;
	347	return;
a020f980 PB	348	}
a020f980 PB	349
c6bd8c70 MA	350	error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
c6bd8c70 MA	351	"boolean");
a020f980 PB	352	}
a020f980 PB	353
0b2a0d6b	354	static void parse_type_str(Visitor v, const char name, char **obj,
a020f980 PB	355	Error **errp)
a020f980 PB	356	{
d7bea75d	357	StringInputVisitor *siv = to_siv(v);
f332e830	358
c9fba9de	359	assert(siv->lm == LM_NONE);
f332e830	360	*obj = g_strdup(siv->string);
a020f980 PB	361	}
a020f980 PB	362
0b2a0d6b	363	static void parse_type_number(Visitor v, const char name, double *obj,
a020f980 PB	364	Error **errp)
a020f980 PB	365	{
d7bea75d	366	StringInputVisitor *siv = to_siv(v);
a020f980 PB	367	double val;
a020f980 PB	368
c9fba9de	369	assert(siv->lm == LM_NONE);
4b69d4c3	370	if (qemu_strtod_finite(siv->string, NULL, &val)) {
c6bd8c70 MA	371	error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
c6bd8c70 MA	372	"number");
a020f980 PB	373	return;
	374	}
	375
	376	*obj = val;
	377	}
	378
d2f95f4d MA	379	static void parse_type_null(Visitor v, const char name, QNull **obj,
d2f95f4d MA	380	Error **errp)
a7333712 GK	381	{
	382	StringInputVisitor *siv = to_siv(v);
	383
c9fba9de	384	assert(siv->lm == LM_NONE);
d2f95f4d MA	385	*obj = NULL;
d2f95f4d MA	386
c9fba9de	387	if (siv->string[0]) {
a7333712 GK	388	error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
a7333712 GK	389	"null");
d2f95f4d	390	return;
a7333712	391	}
d2f95f4d MA	392
d2f95f4d MA	393	*obj = qnull();
a7333712 GK	394	}
a7333712 GK	395
2c0ef9f4 EB	396	static void string_input_free(Visitor *v)
	397	{
	398	StringInputVisitor *siv = to_siv(v);
	399
7a0525c7	400	g_free(siv);
a020f980 PB	401	}
a020f980 PB	402
7a0525c7	403	Visitor string_input_visitor_new(const char str)
a020f980 PB	404	{
	405	StringInputVisitor *v;
	406
f332e830	407	assert(str);
a020f980 PB	408	v = g_malloc0(sizeof(*v));
a020f980 PB	409
983f52d4	410	v->visitor.type = VISITOR_INPUT;
4c40314a	411	v->visitor.type_int64 = parse_type_int64;
f755dea7	412	v->visitor.type_uint64 = parse_type_uint64;
a5829ccf	413	v->visitor.type_size = parse_type_size;
a020f980 PB	414	v->visitor.type_bool = parse_type_bool;
	415	v->visitor.type_str = parse_type_str;
	416	v->visitor.type_number = parse_type_number;
a7333712	417	v->visitor.type_null = parse_type_null;
659268ff HT	418	v->visitor.start_list = start_list;
659268ff HT	419	v->visitor.next_list = next_list;
a4a1c70d	420	v->visitor.check_list = check_list;
659268ff	421	v->visitor.end_list = end_list;
2c0ef9f4	422	v->visitor.free = string_input_free;
a020f980 PB	423
a020f980 PB	424	v->string = str;
c9fba9de	425	v->lm = LM_NONE;
7a0525c7	426	return &v->visitor;
a020f980	427	}