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

/*
 * String parsing visitor
 *
 * Copyright Red Hat, Inc. 2012-2016
 *
 * Author: Paolo Bonzini <pbonzini@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 "qemu/option.h"
#include "qemu/queue.h"
#include "qemu/range.h"


struct StringInputVisitor
{
    Visitor visitor;

    bool head;

    GList *ranges;
    GList *cur_range;
    int64_t cur;

    const char *string;
};

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

static void free_range(void *range, void *dummy)
{
    g_free(range);
}

static void parse_str(StringInputVisitor *siv, Error **errp)
{
    char *str = (char *) siv->string;
    long long start, end;
    Range *cur;
    char *endptr;

    if (siv->ranges) {
        return;
    }

    do {
        errno = 0;
        start = strtoll(str, &endptr, 0);
        if (errno == 0 && endptr > str) {
            if (*endptr == '\0') {
                cur = g_malloc0(sizeof(*cur));
                cur->begin = start;
                cur->end = start + 1;
                siv->ranges = g_list_insert_sorted_merged(siv->ranges, cur,
                                                          range_compare);
                cur = NULL;
                str = NULL;
            } else if (*endptr == '-') {
                str = endptr + 1;
                errno = 0;
                end = strtoll(str, &endptr, 0);
                if (errno == 0 && endptr > str && start <= end &&
                    (start > INT64_MAX - 65536 ||
                     end < start + 65536)) {
                    if (*endptr == '\0') {
                        cur = g_malloc0(sizeof(*cur));
                        cur->begin = start;
                        cur->end = end + 1;
                        siv->ranges =
                            g_list_insert_sorted_merged(siv->ranges,
                                                        cur,
                                                        range_compare);
                        cur = NULL;
                        str = NULL;
                    } else if (*endptr == ',') {
                        str = endptr + 1;
                        cur = g_malloc0(sizeof(*cur));
                        cur->begin = start;
                        cur->end = end + 1;
                        siv->ranges =
                            g_list_insert_sorted_merged(siv->ranges,
                                                        cur,
                                                        range_compare);
                        cur = NULL;
                    } else {
                        goto error;
                    }
                } else {
                    goto error;
                }
            } else if (*endptr == ',') {
                str = endptr + 1;
                cur = g_malloc0(sizeof(*cur));
                cur->begin = start;
                cur->end = start + 1;
                siv->ranges = g_list_insert_sorted_merged(siv->ranges,
                                                          cur,
                                                          range_compare);
                cur = NULL;
            } else {
                goto error;
            }
        } else {
            goto error;
        }
    } while (str);

    return;
error:
    g_list_foreach(siv->ranges, free_range, NULL);
    g_list_free(siv->ranges);
    siv->ranges = NULL;
}

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

    parse_str(siv, errp);

    siv->cur_range = g_list_first(siv->ranges);
    if (siv->cur_range) {
        Range *r = siv->cur_range->data;
        if (r) {
            siv->cur = r->begin;
        }
    }
}

static GenericList *next_list(Visitor *v, GenericList **list, size_t size)
{
    StringInputVisitor *siv = to_siv(v);
    GenericList **link;
    Range *r;

    if (!siv->ranges || !siv->cur_range) {
        return NULL;
    }

    r = siv->cur_range->data;
    if (!r) {
        return NULL;
    }

    if (siv->cur < r->begin || siv->cur >= r->end) {
        siv->cur_range = g_list_next(siv->cur_range);
        if (!siv->cur_range) {
            return NULL;
        }
        r = siv->cur_range->data;
        if (!r) {
            return NULL;
        }
        siv->cur = r->begin;
    }

    if (siv->head) {
        link = list;
        siv->head = false;
    } else {
        link = &(*list)->next;
    }

    *link = g_malloc0(size);
    return *link;
}

static void end_list(Visitor *v)
{
    StringInputVisitor *siv = to_siv(v);
    siv->head = true;
}

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

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

    parse_str(siv, errp);

    if (!siv->ranges) {
        goto error;
    }

    if (!siv->cur_range) {
        Range *r;

        siv->cur_range = g_list_first(siv->ranges);
        if (!siv->cur_range) {
            goto error;
        }

        r = siv->cur_range->data;
        if (!r) {
            goto error;
        }

        siv->cur = r->begin;
    }

    *obj = siv->cur;
    siv->cur++;
    return;

error:
    error_setg(errp, QERR_INVALID_PARAMETER_VALUE, name ? name : "null",
               "an int64 value or range");
}

static void parse_type_uint64(Visitor *v, const char *name, uint64_t *obj,
                              Error **errp)
{
    /* FIXME: parse_type_int64 mishandles values over INT64_MAX */
    int64_t i;
    Error *err = NULL;
    parse_type_int64(v, name, &i, &err);
    if (err) {
        error_propagate(errp, err);
    } else {
        *obj = i;
    }
}

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;

    if (siv->string) {
        parse_option_size(name, siv->string, &val, &err);
    } else {
        error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
                   "size");
        return;
    }
    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);

    if (siv->string) {
        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);
    if (siv->string) {
        *obj = g_strdup(siv->string);
    } else {
        *obj = NULL;
        error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
                   "string");
    }
}

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

    errno = 0;
    if (siv->string) {
        val = strtod(siv->string, &endp);
    }
    if (!siv->string || errno || endp == siv->string || *endp) {
        error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
                   "number");
        return;
    }

    *obj = val;
}

static void parse_optional(Visitor *v, const char *name, bool *present)
{
    StringInputVisitor *siv = to_siv(v);

    if (!siv->string) {
        *present = false;
        return;
    }

    *present = true;
}

Visitor *string_input_get_visitor(StringInputVisitor *v)
{
    return &v->visitor;
}

void string_input_visitor_cleanup(StringInputVisitor *v)
{
    g_list_foreach(v->ranges, free_range, NULL);
    g_list_free(v->ranges);
    g_free(v);
}

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

    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.start_list = start_list;
    v->visitor.next_list = next_list;
    v->visitor.end_list = end_list;
    v->visitor.optional = parse_optional;

    v->string = str;
    v->head = true;
    return v;
}
Commit	Line	Data
a020f980 PB	1	/*
	2	* String parsing visitor
	3	*
08f9541d	4	* Copyright Red Hat, Inc. 2012-2016
a020f980 PB	5	*
	6	* Author: Paolo Bonzini <pbonzini@redhat.com>
	7	*
	8	* This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
	9	* See the COPYING.LIB file in the top-level directory.
	10	*
	11	*/
	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"
a5829ccf	19	#include "qemu/option.h"
659268ff HT	20	#include "qemu/queue.h"
	21	#include "qemu/range.h"
	22
a020f980 PB	23
	24	struct StringInputVisitor
	25	{
	26	Visitor visitor;
659268ff HT	27
	28	bool head;
	29
	30	GList *ranges;
	31	GList *cur_range;
	32	int64_t cur;
	33
a020f980 PB	34	const char *string;
	35	};
	36
d7bea75d EB	37	static StringInputVisitor to_siv(Visitor v)
	38	{
	39	return container_of(v, StringInputVisitor, visitor);
	40	}
	41
0d156683 MT	42	static void free_range(void range, void dummy)
	43	{
	44	g_free(range);
	45	}
	46
659268ff HT	47	static void parse_str(StringInputVisitor siv, Error *errp)
	48	{
	49	char str = (char ) siv->string;
	50	long long start, end;
	51	Range *cur;
	52	char *endptr;
	53
	54	if (siv->ranges) {
	55	return;
	56	}
	57
659268ff	58	do {
c210ee95	59	errno = 0;
659268ff	60	start = strtoll(str, &endptr, 0);
c210ee95	61	if (errno == 0 && endptr > str) {
659268ff HT	62	if (*endptr == '\0') {
	63	cur = g_malloc0(sizeof(*cur));
	64	cur->begin = start;
	65	cur->end = start + 1;
	66	siv->ranges = g_list_insert_sorted_merged(siv->ranges, cur,
	67	range_compare);
	68	cur = NULL;
	69	str = NULL;
	70	} else if (*endptr == '-') {
	71	str = endptr + 1;
c210ee95	72	errno = 0;
659268ff	73	end = strtoll(str, &endptr, 0);
c210ee95	74	if (errno == 0 && endptr > str && start <= end &&
659268ff HT	75	(start > INT64_MAX - 65536 \|\|
	76	end < start + 65536)) {
	77	if (*endptr == '\0') {
	78	cur = g_malloc0(sizeof(*cur));
	79	cur->begin = start;
	80	cur->end = end + 1;
	81	siv->ranges =
	82	g_list_insert_sorted_merged(siv->ranges,
	83	cur,
	84	range_compare);
	85	cur = NULL;
	86	str = NULL;
	87	} else if (*endptr == ',') {
	88	str = endptr + 1;
	89	cur = g_malloc0(sizeof(*cur));
	90	cur->begin = start;
	91	cur->end = end + 1;
	92	siv->ranges =
	93	g_list_insert_sorted_merged(siv->ranges,
	94	cur,
	95	range_compare);
	96	cur = NULL;
	97	} else {
	98	goto error;
	99	}
	100	} else {
	101	goto error;
	102	}
	103	} else if (*endptr == ',') {
	104	str = endptr + 1;
	105	cur = g_malloc0(sizeof(*cur));
	106	cur->begin = start;
	107	cur->end = start + 1;
	108	siv->ranges = g_list_insert_sorted_merged(siv->ranges,
	109	cur,
	110	range_compare);
	111	cur = NULL;
	112	} else {
	113	goto error;
	114	}
	115	} else {
	116	goto error;
	117	}
	118	} while (str);
	119
	120	return;
	121	error:
0d156683 MT	122	g_list_foreach(siv->ranges, free_range, NULL);
	123	g_list_free(siv->ranges);
	124	siv->ranges = NULL;
659268ff HT	125	}
	126
	127	static void
	128	start_list(Visitor v, const char name, Error **errp)
	129	{
d7bea75d	130	StringInputVisitor *siv = to_siv(v);
659268ff HT	131
	132	parse_str(siv, errp);
	133
	134	siv->cur_range = g_list_first(siv->ranges);
	135	if (siv->cur_range) {
	136	Range *r = siv->cur_range->data;
	137	if (r) {
	138	siv->cur = r->begin;
	139	}
	140	}
	141	}
	142
e65d89bf	143	static GenericList next_list(Visitor v, GenericList **list, size_t size)
659268ff	144	{
d7bea75d	145	StringInputVisitor *siv = to_siv(v);
659268ff HT	146	GenericList **link;
	147	Range *r;
	148
	149	if (!siv->ranges \|\| !siv->cur_range) {
	150	return NULL;
	151	}
	152
	153	r = siv->cur_range->data;
	154	if (!r) {
	155	return NULL;
	156	}
	157
	158	if (siv->cur < r->begin \|\| siv->cur >= r->end) {
	159	siv->cur_range = g_list_next(siv->cur_range);
	160	if (!siv->cur_range) {
	161	return NULL;
	162	}
	163	r = siv->cur_range->data;
	164	if (!r) {
	165	return NULL;
	166	}
	167	siv->cur = r->begin;
	168	}
	169
	170	if (siv->head) {
	171	link = list;
	172	siv->head = false;
	173	} else {
	174	link = &(*list)->next;
	175	}
	176
e65d89bf	177	*link = g_malloc0(size);
659268ff HT	178	return *link;
	179	}
	180
08f9541d	181	static void end_list(Visitor *v)
659268ff	182	{
d7bea75d	183	StringInputVisitor *siv = to_siv(v);
659268ff HT	184	siv->head = true;
	185	}
	186
0b2a0d6b	187	static void parse_type_int64(Visitor v, const char name, int64_t *obj,
4c40314a	188	Error **errp)
a020f980	189	{
d7bea75d	190	StringInputVisitor *siv = to_siv(v);
a020f980	191
659268ff	192	if (!siv->string) {
c6bd8c70 MA	193	error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
c6bd8c70 MA	194	"integer");
a020f980 PB	195	return;
	196	}
	197
659268ff HT	198	parse_str(siv, errp);
	199
	200	if (!siv->ranges) {
	201	goto error;
	202	}
	203
	204	if (!siv->cur_range) {
	205	Range *r;
	206
	207	siv->cur_range = g_list_first(siv->ranges);
	208	if (!siv->cur_range) {
	209	goto error;
	210	}
	211
	212	r = siv->cur_range->data;
	213	if (!r) {
	214	goto error;
	215	}
	216
	217	siv->cur = r->begin;
	218	}
	219
	220	*obj = siv->cur;
	221	siv->cur++;
	222	return;
	223
	224	error:
0a40bdab	225	error_setg(errp, QERR_INVALID_PARAMETER_VALUE, name ? name : "null",
c6bd8c70	226	"an int64 value or range");
a020f980 PB	227	}
a020f980 PB	228
0b2a0d6b	229	static void parse_type_uint64(Visitor v, const char name, uint64_t *obj,
f755dea7 EB	230	Error **errp)
	231	{
	232	/* FIXME: parse_type_int64 mishandles values over INT64_MAX */
	233	int64_t i;
	234	Error *err = NULL;
0b2a0d6b	235	parse_type_int64(v, name, &i, &err);
f755dea7 EB	236	if (err) {
	237	error_propagate(errp, err);
	238	} else {
	239	*obj = i;
	240	}
	241	}
	242
0b2a0d6b	243	static void parse_type_size(Visitor v, const char name, uint64_t *obj,
a5829ccf PB	244	Error **errp)
a5829ccf PB	245	{
d7bea75d	246	StringInputVisitor *siv = to_siv(v);
a5829ccf PB	247	Error *err = NULL;
	248	uint64_t val;
	249
	250	if (siv->string) {
	251	parse_option_size(name, siv->string, &val, &err);
	252	} else {
c6bd8c70 MA	253	error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
c6bd8c70 MA	254	"size");
a5829ccf PB	255	return;
	256	}
	257	if (err) {
	258	error_propagate(errp, err);
	259	return;
	260	}
	261
	262	*obj = val;
	263	}
	264
0b2a0d6b	265	static void parse_type_bool(Visitor v, const char name, bool *obj,
a020f980 PB	266	Error **errp)
a020f980 PB	267	{
d7bea75d	268	StringInputVisitor *siv = to_siv(v);
a020f980 PB	269
	270	if (siv->string) {
	271	if (!strcasecmp(siv->string, "on") \|\|
	272	!strcasecmp(siv->string, "yes") \|\|
	273	!strcasecmp(siv->string, "true")) {
	274	*obj = true;
	275	return;
	276	}
	277	if (!strcasecmp(siv->string, "off") \|\|
	278	!strcasecmp(siv->string, "no") \|\|
	279	!strcasecmp(siv->string, "false")) {
	280	*obj = false;
	281	return;
	282	}
	283	}
	284
c6bd8c70 MA	285	error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
c6bd8c70 MA	286	"boolean");
a020f980 PB	287	}
a020f980 PB	288
0b2a0d6b	289	static void parse_type_str(Visitor v, const char name, char **obj,
a020f980 PB	290	Error **errp)
a020f980 PB	291	{
d7bea75d	292	StringInputVisitor *siv = to_siv(v);
a020f980 PB	293	if (siv->string) {
	294	*obj = g_strdup(siv->string);
	295	} else {
e58d695e	296	*obj = NULL;
c6bd8c70 MA	297	error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
c6bd8c70 MA	298	"string");
a020f980 PB	299	}
	300	}
	301
0b2a0d6b	302	static void parse_type_number(Visitor v, const char name, double *obj,
a020f980 PB	303	Error **errp)
a020f980 PB	304	{
d7bea75d	305	StringInputVisitor *siv = to_siv(v);
a020f980 PB	306	char endp = (char ) siv->string;
	307	double val;
	308
	309	errno = 0;
	310	if (siv->string) {
	311	val = strtod(siv->string, &endp);
	312	}
	313	if (!siv->string \|\| errno \|\| endp == siv->string \|\| *endp) {
c6bd8c70 MA	314	error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
c6bd8c70 MA	315	"number");
a020f980 PB	316	return;
	317	}
	318
	319	*obj = val;
	320	}
	321
0b2a0d6b	322	static void parse_optional(Visitor v, const char name, bool *present)
a020f980	323	{
d7bea75d	324	StringInputVisitor *siv = to_siv(v);
a020f980 PB	325
	326	if (!siv->string) {
	327	*present = false;
	328	return;
	329	}
	330
	331	*present = true;
	332	}
	333
	334	Visitor string_input_get_visitor(StringInputVisitor v)
	335	{
	336	return &v->visitor;
	337	}
	338
	339	void string_input_visitor_cleanup(StringInputVisitor *v)
	340	{
0d156683 MT	341	g_list_foreach(v->ranges, free_range, NULL);
0d156683 MT	342	g_list_free(v->ranges);
a020f980 PB	343	g_free(v);
	344	}
	345
	346	StringInputVisitor string_input_visitor_new(const char str)
	347	{
	348	StringInputVisitor *v;
	349
	350	v = g_malloc0(sizeof(*v));
	351
983f52d4	352	v->visitor.type = VISITOR_INPUT;
4c40314a	353	v->visitor.type_int64 = parse_type_int64;
f755dea7	354	v->visitor.type_uint64 = parse_type_uint64;
a5829ccf	355	v->visitor.type_size = parse_type_size;
a020f980 PB	356	v->visitor.type_bool = parse_type_bool;
	357	v->visitor.type_str = parse_type_str;
	358	v->visitor.type_number = parse_type_number;
659268ff HT	359	v->visitor.start_list = start_list;
	360	v->visitor.next_list = next_list;
	361	v->visitor.end_list = end_list;
e2cd0f4f	362	v->visitor.optional = parse_optional;
a020f980 PB	363
a020f980 PB	364	v->string = str;
659268ff	365	v->head = true;
a020f980 PB	366	return v;
a020f980 PB	367	}