2015-08-21 07:04:50 +00:00
|
|
|
/*
|
|
|
|
* String parsing visitor
|
|
|
|
*
|
|
|
|
* Copyright Red Hat, Inc. 2012
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2018-02-19 06:29:26 +00:00
|
|
|
#include "qemu/osdep.h"
|
2015-08-21 07:04:50 +00:00
|
|
|
#include "qemu-common.h"
|
|
|
|
#include "qapi/string-input-visitor.h"
|
|
|
|
#include "qapi/visitor-impl.h"
|
|
|
|
#include "qapi/qmp/qerror.h"
|
|
|
|
#include "qemu/queue.h"
|
|
|
|
#include "qemu/range.h"
|
2017-01-19 11:50:28 +00:00
|
|
|
#include <stdlib.h> // strtoll
|
2015-08-21 07:04:50 +00:00
|
|
|
|
|
|
|
|
|
|
|
struct StringInputVisitor
|
|
|
|
{
|
|
|
|
Visitor visitor;
|
|
|
|
|
|
|
|
bool head;
|
|
|
|
|
|
|
|
GList *ranges;
|
|
|
|
GList *cur_range;
|
|
|
|
int64_t cur;
|
|
|
|
|
|
|
|
const char *string;
|
|
|
|
};
|
|
|
|
|
2018-02-19 16:47:12 +00:00
|
|
|
static StringInputVisitor *to_siv(Visitor *v)
|
|
|
|
{
|
|
|
|
return container_of(v, StringInputVisitor, visitor);
|
|
|
|
}
|
|
|
|
|
2015-08-21 07:04:50 +00:00
|
|
|
static void free_range(void *range, void *dummy)
|
|
|
|
{
|
2016-12-21 14:28:36 +00:00
|
|
|
g_free(range);
|
2015-08-21 07:04:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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)
|
|
|
|
{
|
2018-02-19 16:47:12 +00:00
|
|
|
StringInputVisitor *siv = to_siv(v);
|
2015-08-21 07:04:50 +00:00
|
|
|
|
|
|
|
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, Error **errp)
|
|
|
|
{
|
2018-02-19 16:47:12 +00:00
|
|
|
StringInputVisitor *siv = to_siv(v);
|
2015-08-21 07:04:50 +00:00
|
|
|
GenericList **link;
|
|
|
|
Range *r;
|
|
|
|
|
|
|
|
if (!siv->ranges || !siv->cur_range) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
r = siv->cur_range->data;
|
|
|
|
if (!r) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2017-01-19 11:50:28 +00:00
|
|
|
if ((uint64_t)siv->cur < r->begin || (uint64_t)siv->cur >= r->end) {
|
2015-08-21 07:04:50 +00:00
|
|
|
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(sizeof **link);
|
|
|
|
return *link;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
end_list(Visitor *v, Error **errp)
|
|
|
|
{
|
2018-02-19 16:47:12 +00:00
|
|
|
StringInputVisitor *siv = to_siv(v);
|
2015-08-21 07:04:50 +00:00
|
|
|
siv->head = true;
|
|
|
|
}
|
|
|
|
|
qapi: Prefer type_int64 over type_int in visitors
The qapi builtin type 'int' is basically shorthand for the type
'int64'. In fact, since no visitor was providing the optional
type_int64() callback, visit_type_int64() was just always falling
back to type_int(), cementing the equivalence between the types.
However, some visitors are providing a type_uint64() callback.
For purposes of code consistency, it is nicer if all visitors
use the paired type_int64/type_uint64 names rather than the
mismatched type_int/type_uint64. So this patch just renames
the signed int callbacks in place, dropping the type_int()
callback as redundant, and a later patch will focus on the
unsigned int callbacks.
Add some FIXMEs to questionable reuse of errp in code touched
by the rename, while at it (the reuse works as long as the
callbacks don't modify value when setting an error, but it's not
a good example to set) - a later patch will then fix those.
No change in functionality here, although further cleanups are
in the pipeline.
Backports commit 4c40314a35816de635e7170eaacdc0c35be83a8a from qemu
2018-02-19 16:53:19 +00:00
|
|
|
static void parse_type_int64(Visitor *v, int64_t *obj, const char *name,
|
|
|
|
Error **errp)
|
2015-08-21 07:04:50 +00:00
|
|
|
{
|
2018-02-19 16:47:12 +00:00
|
|
|
StringInputVisitor *siv = to_siv(v);
|
2015-08-21 07:04:50 +00:00
|
|
|
|
|
|
|
if (!siv->string) {
|
2018-02-13 22:34:32 +00:00
|
|
|
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
|
|
|
|
"integer");
|
2015-08-21 07:04:50 +00:00
|
|
|
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:
|
2018-02-13 22:34:32 +00:00
|
|
|
error_setg(errp, QERR_INVALID_PARAMETER_VALUE, name,
|
|
|
|
"an int64 value or range");
|
2015-08-21 07:04:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void parse_type_bool(Visitor *v, bool *obj, const char *name,
|
|
|
|
Error **errp)
|
|
|
|
{
|
2018-02-19 16:47:12 +00:00
|
|
|
StringInputVisitor *siv = to_siv(v);
|
2015-08-21 07:04:50 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-02-13 22:34:32 +00:00
|
|
|
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
|
|
|
|
"boolean");
|
2015-08-21 07:04:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void parse_type_str(Visitor *v, char **obj, const char *name,
|
|
|
|
Error **errp)
|
|
|
|
{
|
2018-02-19 16:47:12 +00:00
|
|
|
StringInputVisitor *siv = to_siv(v);
|
2015-08-21 07:04:50 +00:00
|
|
|
if (siv->string) {
|
|
|
|
*obj = g_strdup(siv->string);
|
|
|
|
} else {
|
2018-02-13 22:34:32 +00:00
|
|
|
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
|
|
|
|
"string");
|
2015-08-21 07:04:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void parse_type_number(Visitor *v, double *obj, const char *name,
|
|
|
|
Error **errp)
|
|
|
|
{
|
2018-02-19 16:47:12 +00:00
|
|
|
StringInputVisitor *siv = to_siv(v);
|
2015-08-21 07:04:50 +00:00
|
|
|
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) {
|
2018-02-13 22:34:32 +00:00
|
|
|
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
|
|
|
|
"number");
|
2015-08-21 07:04:50 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
*obj = val;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void parse_optional(Visitor *v, bool *present, const char *name,
|
|
|
|
Error **errp)
|
|
|
|
{
|
2018-02-19 16:47:12 +00:00
|
|
|
StringInputVisitor *siv = to_siv(v);
|
2015-08-21 07:04:50 +00:00
|
|
|
|
|
|
|
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);
|
2016-12-21 14:28:36 +00:00
|
|
|
g_free(v);
|
2015-08-21 07:04:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
StringInputVisitor *string_input_visitor_new(const char *str)
|
|
|
|
{
|
|
|
|
StringInputVisitor *v;
|
|
|
|
|
|
|
|
v = g_malloc0(sizeof(*v));
|
|
|
|
|
|
|
|
v->visitor.type_enum = input_type_enum;
|
qapi: Prefer type_int64 over type_int in visitors
The qapi builtin type 'int' is basically shorthand for the type
'int64'. In fact, since no visitor was providing the optional
type_int64() callback, visit_type_int64() was just always falling
back to type_int(), cementing the equivalence between the types.
However, some visitors are providing a type_uint64() callback.
For purposes of code consistency, it is nicer if all visitors
use the paired type_int64/type_uint64 names rather than the
mismatched type_int/type_uint64. So this patch just renames
the signed int callbacks in place, dropping the type_int()
callback as redundant, and a later patch will focus on the
unsigned int callbacks.
Add some FIXMEs to questionable reuse of errp in code touched
by the rename, while at it (the reuse works as long as the
callbacks don't modify value when setting an error, but it's not
a good example to set) - a later patch will then fix those.
No change in functionality here, although further cleanups are
in the pipeline.
Backports commit 4c40314a35816de635e7170eaacdc0c35be83a8a from qemu
2018-02-19 16:53:19 +00:00
|
|
|
v->visitor.type_int64 = parse_type_int64;
|
2017-01-10 04:57:12 +00:00
|
|
|
v->visitor.type_size = NULL;
|
2015-08-21 07:04:50 +00:00
|
|
|
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;
|
|
|
|
}
|