Provide a QOM-based authorization API
Subsystems (2)
PATCH v6 1/7 qdict: implement a qdict_crumple method for un-flattening a dict
In reply to Daniel P. BerrangeThe qdict_flatten() method will take a dict whose elements are further nested dicts/lists and flatten them by concatenating keys.
The qdict_crumple() method aims to do the reverse, taking a flat qdict, and turning it into a set of nested dicts/lists. It will apply nesting based on the key name, with a '.' indicating a new level in the hierarchy. If the keys in the nested structure are all numeric, it will create a list, otherwise it will create a dict.
If the keys are a mixture of numeric and non-numeric, or the numeric keys are not in strictly ascending order, an error will be reported.
As an example, a flat dict containing
{
'foo.0.bar': 'one',
'foo.0.wizz': '1',
'foo.1.bar': 'two',
'foo.1.wizz': '2'
}
will get turned into a dict with one element 'foo' whose value is a list. The list elements will each in turn be dicts.
{
'foo': [
{ 'bar': 'one', 'wizz': '1' },
{ 'bar': 'two', 'wizz': '2' } ],
}
If the key is intended to contain a literal '.', then it must be escaped as '..'. ie a flat dict
{
'foo..bar': 'wizz',
'bar.foo..bar': 'eek',
'bar.hello': 'world'
}Will end up as
{
'foo.bar': 'wizz',
'bar': {
'foo.bar': 'eek',
'hello': 'world'
}
}The intent of this function is that it allows a set of QemuOpts to be turned into a nested data structure that mirrors the nesting used when the same object is defined over QMP.
--- include/qapi/qmp/qdict.h | 1 + qobject/qdict.c | 283 +++++++++++++++++++++++++++++++++++++++++++++++ tests/check-qdict.c | 241 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 525 insertions(+)
include/qapi/qmp/qdict.h +1 -0
@@ -73,6 +73,7 @@ void qdict_flatten(QDict *qdict);void qdict_extract_subqdict (QDict *src,QDict **dst,const char *start);void qdict_array_split (QDict *src,QList **dst);int qdict_array_entries (QDict *src,const char *subqdict); +QObject *qdict_crumple (QDict *src,bool recursive,Error **errp);void qdict_join (QDict *dest,QDict *src,bool overwrite);
qobject/qdict.c +283 -0
295 lines not on this page · raw message
tests/check-qdict.c +241 -0
259 lines not on this page · raw message
Signature · 1 line
2.5.5
v6 cover Provide a QOM-based authorization API
This is a followup of previously posted work in 2.6 cycle:
v1: https://lists.gnu.org/archive/html/qemu-devel/2016-02/msg04618.html
v2: https://lists.gnu.org/archive/html/qemu-devel/2016-03/msg01454.html
v3: https://lists.gnu.org/archive/html/qemu-devel/2016-03/msg02498.html
v4: https://lists.gnu.org/archive/html/qemu-devel/2016-05/msg01661.html
v5: https://lists.gnu.org/archive/html/qemu-devel/2016-06/msg00485.html
Many years ago I was responsible for adding the 'qemu_acl' type and associated HMP commands. Looking back at it now, it is quite a poor facility with a couple of bad limitations. First, the responsibility for creating the ACLs was left with the QEMU network service (VNC server was only thing ever doing it). This meant you could not share ACLs across multiple services. Second, there was no way to populate ACLs on the command line, you had no choice but to use the HMP commands. Third, the API was hardcoded around the idea of an in-QEMU implementation, leaving no scope for plugging in alternative implementations backed by, for example, LDAP or PAM.
This series introduces a much better authorization API design to QEMU that addresses all these problems, and maintains back compatibility. It of course is based on the QOM framework, so that immediately gives us ability to create objects via the CLI, HMP or QMP. There is an abstract base clss "QAuthZ" which defines the basic API for QEMU network services to use, and a specific implementation "QAuthZ" simple which replicates the functionality of 'qemu_acl'. It is thus possible to add other impls, without changing any other part of QEMU in the future. Finally, the user is responsible for creating the ACL objects, so they can have one ACL associated with all their TLS enabled network services.
There was only one small problem with this, specifically the -object CLI arg and HMP 'object_add' command had no way to let the user specify non-scalar properties for objects. eg if an object had a property which is a list of structs, you are out of luck if you want to create it without using QMP.
Thus the first four patches do some work around QAPI / QOM to make it possible to specify non-scalar properties with the -object CLI arg and HMP 'object_add' command. See the respective patches for illustration of the syntax used. Some of Max's recent block patches also depend on the qdict_crumple method in patch 1.
The patches 5 and 6 introduce the new base class and specific implementation.
Patch 7 kills the old qemu_acl code, updating any existing callers of it to use the QAuthZSimple QOM class instead.
Previously there were further patches adding ACL support for chardevs, migration, nbd, etc. These will be posted later once this core code is merged, so they can flow via the respective maintainer's trees
Changed in v6:
- Switch from while() to for() loop for iterating over dicts (Markus)
- Avoid redundant strdup (Markus)
- Rewrap comments at 70 chars (Markus)
- Change qdict_list_size() to qdict_is_list() (Markus)
- Misc docs changes (Markus)
- Change QmpInputVisitor so the code for handling the string types is separate from code using native scalar types (Paolo)
- Centralize code parsing bool strings (Markus)
- Centralize code parsing int strings (Markus)
Changed in v5:
- Resolved conflicts with Eric's visitor refactoring which made it stricter about struct begin/end calls
- Added support for ACLs to migration code now its TLS support is merged.
- Fixed typos in example in commit message
Changed in v4:
- Ensure examples use shell escaping for '*' (Eric)
- Add more tests for crumple impl (Eric)
- Raise error if sasl-acl/tls-acl are requested but sasl/tls auth are not enabled (Eric)
- Document return codes for auth check more clearly (Eric)
- Don't silently turn a glob match into a strcmp if fnmatch is not present (Eric)
- Other misc small typos/fixes (Eric)
Changed in v3:
- Created separate qdict_list_size method (Max)
- Added unit tests for case of empty dict (Max)
- Fix variable names to use underscore separator (Max)
- Fix potential free of uninitialized variables (Max)
- Use QObject APIs for casts, instead of C type casts (Max)
Changed in v2:
- Adapt to changes in qapi visitor APIs
- Add a 'bool recursive' flag to qdict_crumple (Max)
- Fix memory leaks in qdict_crumple (Max)
- Split out key splitting code from qdict_crumple (Max)
- Use saner variable names in qdict_crumple (Max)
- Added some tests for bad inputs to qdict_crumple
Daniel P. Berrange (7):
qdict: implement a qdict_crumple method for un-flattening a dict
option: make parse_option_bool/number non-static
qapi: add a QmpInputVisitor that does string conversion
qom: support arbitrary non-scalar properties with -object
util: add QAuthZ object as an authorization base class
util: add QAuthZSimple object type for a simple access control list
acl: delete existing ACL implementation
MAINTAINERS | 7 + Makefile | 9 +- Makefile.objs | 2 + Makefile.target | 2 + crypto/tlssession.c | 28 +++- hmp.c | 18 +-- include/qapi/qmp-input-visitor.h | 42 +++++- include/qapi/qmp/qdict.h | 1 + include/qemu/acl.h | 74 --------- include/qemu/authz-simple.h | 115 ++++++++++++++ include/qemu/authz.h | 89 +++++++++++ include/qemu/option.h | 4 + include/qom/object_interfaces.h | 10 +- monitor.c | 181 ++++++++++++++-------- qapi-schema.json | 6 +- qapi/opts-visitor.c | 19 +-- qapi/qmp-input-visitor.c | 80 ++++++++++ qapi/util.json | 47 ++++++ qmp.c | 2 +- qobject/qdict.c | 283 ++++++++++++++++++++++++++++++++++ qom/object_interfaces.c | 49 ++++-- tests/.gitignore | 1 + tests/Makefile.include | 5 +- tests/check-qdict.c | 241 +++++++++++++++++++++++++++++ tests/check-qom-proplist.c | 319 ++++++++++++++++++++++++++++++++++++++- tests/test-authz-simple.c | 172 +++++++++++++++++++++ tests/test-crypto-tlssession.c | 15 +- tests/test-io-channel-tls.c | 16 +- tests/test-qmp-input-visitor.c | 119 ++++++++++++++- ui/vnc-auth-sasl.c | 2 +- ui/vnc-auth-sasl.h | 4 +- ui/vnc.c | 11 +- util/Makefile.objs | 4 +- util/acl.c | 188 ----------------------- util/authz-simple.c | 314 ++++++++++++++++++++++++++++++++++++++ util/authz.c | 46 ++++++ util/qemu-option.c | 27 ++-- 37 files changed, 2133 insertions(+), 419 deletions(-) delete mode 100644 include/qemu/acl.h create mode 100644 include/qemu/authz-simple.h create mode 100644 include/qemu/authz.h create mode 100644 qapi/util.json create mode 100644 tests/test-authz-simple.c delete mode 100644 util/acl.c create mode 100644 util/authz-simple.c create mode 100644 util/authz.c
Signature · 1 line
2.5.5
PATCH v6 2/7 option: make parse_option_bool/number non-static
The opts-visitor.c opts_type_bool() method has code for parsing a string to set a bool value, as does the qemu-option.c parse_option_bool() method, except it handles fewer cases.
To enable consistency across the codebase, extend parse_option_bool() to handle "yes", "no", "y" and "n", and make it non-static. Convert the opts visitor to call this method directly.
Also make parse_option_number() non-static to allow for similar reuse later.
--- include/qemu/option.h | 4 ++++ qapi/opts-visitor.c | 19 +------------------ util/qemu-option.c | 27 ++++++++++++++++----------- 3 files changed, 21 insertions(+), 29 deletions(-)
include/qemu/option.h +4 -0
@@ -37,6 +37,10 @@ int get_param_value(char *buf, int buf_size, const char *tag, const char *str); +void parse_option_bool (const char *name,const char *value,bool *ret, +Error **errp); +void parse_option_number (const char *name,const char *value, +uint64_t *ret,Error **errp);void parse_option_size (const char *name,const char *value,uint64_t *ret,Error **errp);bool has_help_option (const char *param);
qapi/opts-visitor.c +1 -18
@@ -334,7 +334,6 @@ opts_type_str(Visitor *v, const char *name, char **obj, Error **errp) } -/* mimics qemu-option.c::parse_option_bool() */ static void opts_type_bool (Visitor *v,const char *name,bool *obj,Error **errp) {
@@ -346,23 +345,7 @@ opts_type_bool(Visitor *v, const char *name, bool *obj, Error **errp)return ; } -if (opt->str) { -if (strcmp (opt->str,"on" ) ==0 || -strcmp (opt->str,"yes" ) ==0 || -strcmp (opt->str,"y" ) ==0 ) { - *obj = true; - }else if (strcmp (opt->str,"off" ) ==0 || -strcmp (opt->str,"no" ) ==0 || -strcmp (opt->str,"n" ) ==0 ) { - *obj = false; - }else { -error_setg (errp,QERR_INVALID_PARAMETER_VALUE , opt->name, -"on|yes|y|off|no|n" ); -return ; - } - }else { - *obj = true; - } +parse_option_bool (opt->name, opt->str, obj, errp);processed (ov, name); }
util/qemu-option.c +16 -11
@@ -125,25 +125,30 @@ int get_param_value(char *buf, int buf_size,return get_next_param_value (buf, buf_size, tag, &str); } -static void parse_option_bool (const char *name,const char *value,bool *ret, -Error **errp) +void parse_option_bool (const char *name,const char *value,bool *ret, +Error **errp) {if (value !=NULL ) { -if (!strcmp (value,"on" )) { - *ret =1 ; - }else if (!strcmp (value,"off" )) { - *ret =0 ; +if (strcmp (value,"on" ) ==0 || +strcmp (value,"yes" ) ==0 || +strcmp (value,"y" ) ==0 ) { + *ret = true; + }else if (strcmp (value,"off" ) ==0 || +strcmp (value,"no" ) ==0 || +strcmp (value,"n" ) ==0 ) { + *ret = false; }else { -error_setg (errp,QERR_INVALID_PARAMETER_VALUE , - name,"'on' or 'off'" ); +error_setg (errp,QERR_INVALID_PARAMETER_VALUE , name, +"on|yes|y|off|no|n" ); +return ; } }else { - *ret =1 ; + *ret = true; } } -static void parse_option_number (const char *name,const char *value, -uint64_t *ret,Error **errp) +void parse_option_number (const char *name,const char *value, +uint64_t *ret,Error **errp) {char *postfix;uint64_t number;
Signature · 1 line
2.5.5
PATCH v6 3/7 qapi: add a QmpInputVisitor that does string conversion
In reply to Daniel P. BerrangeCurrently the QmpInputVisitor assumes that all scalar values are directly represented as their final types. ie it assumes an 'int' is using QInt, and a 'bool' is using QBool.
This adds an alternative constructor for QmpInputVisitor that will set it up such that it expects a QString for all scalar types instead.
This makes it possible to use QmpInputVisitor with a QDict produced from QemuOpts, where everything is in string format.
--- include/qapi/qmp-input-visitor.h | 42 ++++++++++++-- qapi/qmp-input-visitor.c | 80 ++++++++++++++++++++++++++ tests/test-qmp-input-visitor.c | 119 ++++++++++++++++++++++++++++++++++++++- 3 files changed, 234 insertions(+), 7 deletions(-)
include/qapi/qmp-input-visitor.h +38 -4
@@ -19,14 +19,48 @@typedef struct QmpInputVisitor QmpInputVisitor ; -/* -* Return a new input visitor that converts QMP to QAPI. +/** +* qmp_input_visitor_new: +* @obj: the input object to visit +* @strict: whether to require that all input keys are consumed +* +* Create a new input visitor that converts QMP to QAPI. +* +* Any scalar values in the @obj input data structure should be in the +* required type already. ie if visiting a bool, the value should +* already be a QBool instance. * -* Set @strict to reject a parse that doesn't consume all keys of a -* dictionary; otherwise excess input is ignored. +* If @strict is set to true, then an error will be reported if any +* dict keys are not consumed during visitation. +* +* The returned input visitor should be released by calling +* qmp_input_visitor_cleanup when no longer required. +* +* Returns: a new input visitor */ QmpInputVisitor *qmp_input_visitor_new (QObject *obj,bool strict); +/** +* qmp_input_visitor_new: +* @obj: the input object to visit +* @strict: whether to require that all input keys are consumed +* +* Create a new input visitor that converts QMP to QAPI. +* +* Any scalar values in the @obj input data structure should always be +* represented as strings. ie if visiting a boolean, the value should +* be a QString whose contents represent a valid boolean. +* +* If @strict is set to true, then an error will be reported if any +* dict keys are not consumed during visitation. +* +* The returned input visitor should be released by calling +* qmp_input_visitor_cleanup when no longer required. +* +* Returns: a new input visitor +*/ +QmpInputVisitor *qmp_string_input_visitor_new (QObject *obj,bool strict); +void qmp_input_visitor_cleanup (QmpInputVisitor *v);Visitor *qmp_input_get_visitor (QmpInputVisitor *v);
qapi/qmp-input-visitor.c +80 -0
113 lines not on this page · raw message
tests/test-qmp-input-visitor.c +116 -3
177 lines not on this page · raw message
Signature · 1 line
2.5.5
PATCH v6 4/7 qom: support arbitrary non-scalar properties with -object
In reply to Daniel P. BerrangeThe current -object command line syntax only allows for creation of objects with scalar properties, or a list with a fixed scalar element type. Objects which have properties that are represented as structs in the QAPI schema cannot be created using -object.
This is a design limitation of the way the OptsVisitor is written. It simply iterates over the QemuOpts values as a flat list. The support for lists is enabled by allowing the same key to be repeated in the opts string.
It is not practical to extend the OptsVisitor to support more complex data structures while also maintaining the existing list handling behaviour that is relied upon by other areas of QEMU.
Fortunately there is no existing object that implements the UserCreatable interface that relies on the list handling behaviour, so it is possible to swap out the OptsVisitor for a different visitor implementation, so -object supports non-scalar properties, thus leaving other users of OptsVisitor unaffected.
The previously added qdict_crumple() method is able to take a qdict containing a flat set of properties and turn that into a arbitrarily nested set of dicts and lists. By combining qemu_opts_to_qdict and qdict_crumple() together, we can turn the opt string into a data structure that is practically identical to that passed over QMP when defining an object. The only difference is that all the scalar values are represented as strings, rather than strings, ints and bools. This is sufficient to let us replace the OptsVisitor with the QMPInputVisitor for use with -object.
Thus -object can now support non-scalar properties, for example the QMP object
{
"execute": "object-add",
"arguments": {
"qom-type": "demo",
"id": "demo0",
"parameters": {
"foo": [
{ "bar": "one", "wizz": "1" },
{ "bar": "two", "wizz": "2" }
]
}
}
}Would be creatable via the CLI now using
$QEMU \
-object demo,id=demo0,\
foo.0.bar=one,foo.0.wizz=1,\
foo.1.bar=two,foo.1.wizz=2Notice that this syntax is intentionally compatible with that currently used by block drivers.
This is also wired up to work for the 'object_add' command in the HMP monitor with the same syntax.
(hmp) object_add demo,id=demo0,\
foo.0.bar=one,foo.0.wizz=1,\
foo.1.bar=two,foo.1.wizz=2NB indentation should not be used with HMP commands, this is just for convenient formatting in this commit message.
--- hmp.c | 18 +-- include/qom/object_interfaces.h | 10 +- qmp.c | 2 +- qom/object_interfaces.c | 49 ++++-- tests/check-qom-proplist.c | 319 +++++++++++++++++++++++++++++++++++++++- 5 files changed, 365 insertions(+), 33 deletions(-)
hmp.c +5 -13
@@ -25,7 +25,7 @@#include "qemu/sockets.h" #include "monitor/monitor.h" #include "monitor/qdev.h" -#include "qapi/opts-visitor.h" +#include "qapi/qmp-input-visitor.h" #include "qapi/qmp/qerror.h" #include "qapi/string-output-visitor.h" #include "qapi/util.h"
@@ -1717,20 +1717,12 @@ void hmp_netdev_del(Monitor *mon, const QDict *qdict)void hmp_object_add (Monitor *mon,const QDict *qdict) {Error *err =NULL ; -QemuOpts *opts; -OptsVisitor *ov; +QmpInputVisitor *qiv;Object *obj =NULL ; - opts =qemu_opts_from_qdict (qemu_find_opts ("object" ), qdict, &err); -if (err) { -hmp_handle_error (mon, &err); -return ; - } - - ov =opts_visitor_new (opts); - obj =user_creatable_add (qdict,opts_get_visitor (ov), &err); -opts_visitor_cleanup (ov); -qemu_opts_del (opts); + qiv =qmp_string_input_visitor_new ((QObject *)qdict, true); + obj =user_creatable_add (qdict,qmp_input_get_visitor (qiv), &err); +qmp_input_visitor_cleanup (qiv);if (err) {hmp_handle_error (mon, &err);
include/qom/object_interfaces.h +8 -2
@@ -96,18 +96,24 @@ Object *user_creatable_add(const QDict *qdict,* user_creatable_add_type: * @type: the object type name * @id: the unique ID for the object +* @nested: whether to recurse into the visitor for properties * @qdict: the object properties * @v: the visitor * @errp: if an error occurs, a pointer to an area to store the error * * Create an instance of the user creatable object @type, placing * it in the object composition tree with name @id, initializing -* it with properties from @qdict +* it with properties from @qdict. +* +* If the visitor is already positioned to read the properties +* in @qdict, @nested should be false. Conversely, if it is +* neccessary to open/close a struct to read the properties in +* @qdict, @nested should be true. * * Returns: the newly created object or NULL on error */ Object *user_creatable_add_type (const char *type,const char *id, -const QDict *qdict, +bool nested,const QDict *qdict,Visitor *v,Error **errp);/**
qmp.c +1 -1
@@ -667,7 +667,7 @@ void qmp_object_add(const char *type, const char *id, } qiv =qmp_input_visitor_new (props, true); - obj =user_creatable_add_type (type, id, pdict, + obj =user_creatable_add_type (type, id, true, pdict,qmp_input_get_visitor (qiv), errp);qmp_input_visitor_cleanup (qiv);if (obj) {
qom/object_interfaces.c +33 -16
94 lines not on this page · raw message
tests/check-qom-proplist.c +318 -1
411 lines not on this page · raw message
Signature · 1 line
2.5.5
PATCH v6 5/7 util: add QAuthZ object as an authorization base class
In reply to Daniel P. BerrangeThe current qemu_acl module provides a simple access control list facility inside QEMU, which is used via a set of monitor commands acl_show, acl_policy, acl_add, acl_remove & acl_reset.
Note there is no ability to create ACLs - the network services (eg VNC server) were expected to create ACLs that they want to check.
There is also no way to define ACLs on the command line, nor potentially integrate with external authorization systems like polkit, pam, ldap lookup, etc.
The QAuthZ object defines a minimal abstract QOM class that can be subclassed for creating different authorization providers.
--- MAINTAINERS | 7 +++++ Makefile | 1 + Makefile.objs | 2 ++ Makefile.target | 2 ++ include/qemu/authz.h | 89 ++++++++++++++++++++++++++++++++++++++++++++++++++++ util/Makefile.objs | 2 ++ util/authz.c | 46 +++++++++++++++++++++++++++ 7 files changed, 149 insertions(+) create mode 100644 include/qemu/authz.h create mode 100644 util/authz.c
MAINTAINERS +7 -0
@@ -1324,6 +1324,13 @@ F: include/qemu/throttle.h F: util/throttle.c L: [email protected] +Authorization +M: Daniel P. Berrange <[email protected]> +S: Maintained +F: util/authz* +F: include/qemu/authz* +F: tests/test-authz-* + Usermode Emulation ------------------ Overall
Makefile +1 -0
@@ -148,6 +148,7 @@ endif dummy := $(call unnest-vars,, \ stub-obj-y \ util-obj-y \ + util-qom-obj-y \ qga-obj-y \ ivshmem-client-obj-y \ ivshmem-server-obj-y \
Makefile.objs +2 -0
@@ -4,6 +4,8 @@ stub-obj-y = stubs/ crypto/ util-obj-y = util/ qobject/ qapi/ util-obj-y += qmp-introspect.o qapi-types.o qapi-visit.o qapi-event.o +util-qom-obj-y += util/ + ####################################################################### # block-obj-y is code used by both qemu system emulation and qemu-img
Makefile.target +2 -0
@@ -176,6 +176,7 @@ include $(SRC_PATH)/Makefile.objs dummy := $(call unnest-vars,,target-obj-y) target-obj-y-save := $(target-obj-y) dummy := $(call unnest-vars,.., \ + util-qom-obj-y \ block-obj-y \ block-obj-m \ crypto-obj-y \
@@ -188,6 +189,7 @@ target-obj-y := $(target-obj-y-save) all-obj-y += $(common-obj-y) all-obj-y += $(target-obj-y) all-obj-y += $(qom-obj-y) +all-obj-y += $(util-qom-obj-y) all-obj-$(CONFIG_SOFTMMU) += $(block-obj-y) all-obj-$(CONFIG_USER_ONLY) += $(crypto-aes-obj-y) all-obj-$(CONFIG_SOFTMMU) += $(crypto-obj-y)
include/qemu/authz.h new file +89 -0
89 lines not on this page · raw message
util/Makefile.objs +2 -0
@@ -34,3 +34,5 @@ util-obj-y += base64.o util-obj-y += log.o util-obj-y += qdist.o util-obj-y += qht.o + +util-qom-obj-y += authz.o
util/authz.c new file +46 -0
46 lines not on this page · raw message
Signature · 1 line
2.5.5
PATCH v6 6/7 util: add QAuthZSimple object type for a simple access control list
In reply to Daniel P. BerrangeAdd a QAuthZSimple object type that implements the QAuthZ interface. This simple built-in implementation maintains a trivial access control list with a sequence of match rules and a final default policy. This replicates the functionality currently provided by the qemu_acl module.
To create an instance of this object via the QMP monitor, the syntax used would be
{
"execute": "object-add",
"arguments": {
"qom-type": "authz-simple",
"id": "auth0",
"parameters": {
"rules": [
{ "match": "fred", "policy": "allow", "format": "exact" },
{ "match": "bob", "policy": "allow", "format": "exact" },
{ "match": "danb", "policy": "deny", "format": "glob" },
{ "match": "dan*", "policy": "allow", "format": "exact" },
],
"policy": "deny"
}
}
}Or via the -object command line
$QEMU \
-object authz-simple,id=acl0,policy=deny,\
rules.0.match=fred,rules.0.policy=allow,rules.0.format=exact,\
rules.1.match=bob,rules.1.policy=allow,rules.1.format=exact,\
rules.2.match=danb,rules.2.policy=deny,rules.2.format=glob,\
rules.3.match=dan\*,rules.3.policy=allow,rules.3.format=exactThis sets up an authorization rule that allows 'fred', 'bob' and anyone whose name starts with 'dan', except for 'danb'. Everyone unmatched is denied.
--- Makefile | 2 +- include/qemu/authz-simple.h | 115 ++++++++++++++++ qapi-schema.json | 6 +- qapi/util.json | 47 +++++++ tests/.gitignore | 1 + tests/Makefile.include | 3 + tests/test-authz-simple.c | 172 ++++++++++++++++++++++++ util/Makefile.objs | 1 + util/authz-simple.c | 314 ++++++++++++++++++++++++++++++++++++++++++++ 9 files changed, 659 insertions(+), 2 deletions(-) create mode 100644 include/qemu/authz-simple.h create mode 100644 qapi/util.json create mode 100644 tests/test-authz-simple.c create mode 100644 util/authz-simple.c
Makefile +1 -1
@@ -292,7 +292,7 @@ qapi-modules = $(SRC_PATH)/qapi-schema.json $(SRC_PATH)/qapi/common.json \ $(SRC_PATH)/qapi/block.json $(SRC_PATH)/qapi/block-core.json \ $(SRC_PATH)/qapi/event.json $(SRC_PATH)/qapi/introspect.json \ $(SRC_PATH)/qapi/crypto.json $(SRC_PATH)/qapi/rocker.json \ - $(SRC_PATH)/qapi/trace.json + $(SRC_PATH)/qapi/trace.json $(SRC_PATH)/qapi/util.json qapi-types.c qapi-types.h :\ $(qapi-modules) $(SRC_PATH)/scripts/qapi-types.py $(qapi-py)
include/qemu/authz-simple.h new file +115 -0
115 lines not on this page · raw message
qapi-schema.json +5 -1
@@ -5,6 +5,9 @@ # QAPI common definitions { 'include': 'qapi/common.json' } +# QAPI util definitions +{ 'include': 'qapi/util.json' } + # QAPI crypto definitions { 'include': 'qapi/crypto.json' }
@@ -3729,7 +3732,8 @@ # Since 2.5 ## { 'struct': 'DummyForceArrays', - 'data': { 'unused': ['X86CPUFeatureWordInfo'] } } + 'data': { 'unused1': ['X86CPUFeatureWordInfo'], + 'unused2': ['QAuthZSimpleRule'] } } ##
qapi/util.json new file +47 -0
47 lines not on this page · raw message
tests/.gitignore +1 -0
@@ -10,6 +10,7 @@ check-qom-proplist qht-bench rcutorture test-aio +test-authz-simple test-base64 test-bitops test-blockjob-txn
tests/Makefile.include +3 -0
@@ -109,6 +109,7 @@ check-unit-y += tests/test-crypto-xts$(EXESUF) check-unit-y += tests/test-crypto-block$(EXESUF) gcov-files-test-logging-y = tests/test-logging.c check-unit-y += tests/test-logging$(EXESUF) +check-unit-y += tests/test-authz-simple$(EXESUF) check-block-$(CONFIG_POSIX) += tests/qemu-iotests-quick.sh
@@ -460,6 +461,8 @@ tests/test-timed-average$(EXESUF): tests/test-timed-average.o qemu-timer.o \ $(test-util-obj-y) tests/test-base64$(EXESUF): tests/test-base64.o \ libqemuutil.a libqemustub.a +tests/test-authz-simple$(EXESUF): tests/test-authz-simple.o \ + libqemuutil.a libqemustub.a $(util-qom-obj-y) $(qom-obj-y) tests/test-logging$(EXESUF): tests/test-logging.o $(test-util-obj-y)
tests/test-authz-simple.c new file +172 -0
172 lines not on this page · raw message
util/Makefile.objs +1 -0
@@ -36,3 +36,4 @@ util-obj-y += qdist.o util-obj-y += qht.o util-qom-obj-y += authz.o +util-qom-obj-y += authz-simple.o
util/authz-simple.c new file +314 -0
314 lines not on this page · raw message
Signature · 1 line
2.5.5
PATCH v6 7/7 acl: delete existing ACL implementation
In reply to Daniel P. BerrangeThe 'qemu_acl' type was a previous non-QOM based attempt to provide an authorization facility in QEMU. Because it is non-QOM based it cannot be created via the command line and requires special monitor commands to manipulate it.
The new QAuthZ and QAuthZSimple QOM classes provide a superset of the functionality in qemu_acl, so the latter can now be deleted. The HMP 'acl_*' monitor commands are converted to use the new QAuthZSimple data type instead in order to provide backwards compatibility, but their use is discouraged.
--- Makefile | 6 +- crypto/tlssession.c | 28 ++++-- include/qemu/acl.h | 74 ---------------- monitor.c | 181 ++++++++++++++++++++++++++------------- tests/Makefile.include | 2 +- tests/test-crypto-tlssession.c | 15 ++-- tests/test-io-channel-tls.c | 16 ++-- ui/vnc-auth-sasl.c | 2 +- ui/vnc-auth-sasl.h | 4 +- ui/vnc.c | 11 ++- util/Makefile.objs | 1 - util/acl.c | 188 ----------------------------------------- 12 files changed, 180 insertions(+), 348 deletions(-) delete mode 100644 include/qemu/acl.h delete mode 100644 util/acl.c
Makefile +3 -3
@@ -253,9 +253,9 @@ util/module.o-cflags = -D'CONFIG_BLOCK_MODULES=$(block-modules)' qemu-img.o: qemu-img-cmds.h -qemu-img$(EXESUF): qemu-img.o $(block-obj-y) $(crypto-obj-y) $(io-obj-y) $(qom-obj-y) libqemuutil.a libqemustub.a -qemu-nbd$(EXESUF): qemu-nbd.o $(block-obj-y) $(crypto-obj-y) $(io-obj-y) $(qom-obj-y) libqemuutil.a libqemustub.a -qemu-io$(EXESUF): qemu-io.o $(block-obj-y) $(crypto-obj-y) $(io-obj-y) $(qom-obj-y) libqemuutil.a libqemustub.a +qemu-img$(EXESUF): qemu-img.o $(block-obj-y) $(crypto-obj-y) $(io-obj-y) $(qom-obj-y) $(util-qom-obj-y) libqemuutil.a libqemustub.a +qemu-nbd$(EXESUF): qemu-nbd.o $(block-obj-y) $(crypto-obj-y) $(io-obj-y) $(qom-obj-y) $(util-qom-obj-y) libqemuutil.a libqemustub.a +qemu-io$(EXESUF): qemu-io.o $(block-obj-y) $(crypto-obj-y) $(io-obj-y) $(qom-obj-y) $(util-qom-obj-y) libqemuutil.a libqemustub.a qemu-bridge-helper$(EXESUF): qemu-bridge-helper.o libqemuutil.a libqemustub.a
crypto/tlssession.c +23 -5
@@ -23,7 +23,7 @@#include "crypto/tlscredsanon.h" #include "crypto/tlscredsx509.h" #include "qapi/error.h" -#include "qemu/acl.h" +#include "qemu/authz.h" #include "trace.h" #ifdef CONFIG_GNUTLS
@@ -208,6 +208,7 @@ qcrypto_tls_session_check_certificate(QCryptoTLSSession *session,unsigned int nCerts, i;time_t now;gnutls_x509_crt_t cert =NULL ; +Error *err =NULL ; now =time (NULL );if (now == ((time_t)-1 )) {
@@ -296,16 +297,33 @@ qcrypto_tls_session_check_certificate(QCryptoTLSSession *session, goto error; }if (session->aclname) { -qemu_acl *acl =qemu_acl_find (session->aclname); -int allow; -if (!acl) { +QAuthZ *acl; +Object *obj; +Object *container; +bool allow; + + container =object_get_objects_root (); + obj =object_resolve_path_component (container, + session->aclname); +if (!obj) {error_setg (errp,"Cannot find ACL %s" , session->aclname); goto error; } - allow =qemu_acl_party_is_allowed (acl, session->peername); +if (!object_dynamic_cast (obj,TYPE_QAUTHZ )) { +error_setg (errp,"Object '%s' is not a QAuthZ subclass" , + session->aclname); + goto error; + } + acl =QAUTHZ (obj); + + allow =qauthz_is_allowed (acl, session->peername, &err); +if (err) { +error_propagate (errp, err); + goto error; + }if (!allow) {error_setg (errp,"TLS x509 ACL check for %s is denied" , session->peername);
include/qemu/acl.h deleted +0 -74
74 lines not on this page · raw message
monitor.c +121 -60
240 lines not on this page · raw message
tests/Makefile.include +1 -1
@@ -415,7 +415,7 @@ test-qom-obj-y = $(qom-obj-y) $(test-util-obj-y) test-qapi-obj-y = tests/test-qapi-visit.o tests/test-qapi-types.o \ tests/test-qapi-event.o tests/test-qmp-introspect.o \ $(test-qom-obj-y) -test-crypto-obj-y = $(crypto-obj-y) $(test-qom-obj-y) +test-crypto-obj-y = $(crypto-obj-y) $(util-qom-obj-y) $(test-qom-obj-y) test-io-obj-y = $(io-obj-y) $(test-crypto-obj-y) test-block-obj-y = $(block-obj-y) $(test-io-obj-y)
tests/test-crypto-tlssession.c +10 -5
@@ -26,7 +26,7 @@#include "qom/object_interfaces.h" #include "qapi/error.h" #include "qemu/sockets.h" -#include "qemu/acl.h" +#include "qemu/authz-simple.h" #ifdef QCRYPTO_HAVE_TLS_TEST_SUPPORT
@@ -111,7 +111,7 @@ static void test_crypto_tls_session(const void *opaque)QCryptoTLSCreds *serverCreds;QCryptoTLSSession *clientSess =NULL ;QCryptoTLSSession *serverSess =NULL ; -qemu_acl *acl; +QAuthZSimple *auth;const char *const *wildcards;int channel[2 ];bool clientShake = false;
@@ -170,11 +170,15 @@ static void test_crypto_tls_session(const void *opaque) &err);g_assert (serverCreds !=NULL ); - acl =qemu_acl_init ("tlssessionacl" ); -qemu_acl_reset (acl); + auth =qauthz_simple_new ("tlssessionacl" , +QAUTHZ_SIMPLE_POLICY_DENY , + &error_abort); wildcards = data->wildcards;while (wildcards && *wildcards) { -qemu_acl_append (acl,0 , *wildcards); +qauthz_simple_append_rule (auth, *wildcards, +QAUTHZ_SIMPLE_POLICY_ALLOW , +QAUTHZ_SIMPLE_FORMAT_GLOB , + &error_abort); wildcards++; }
@@ -264,6 +268,7 @@ static void test_crypto_tls_session(const void *opaque)object_unparent (OBJECT (serverCreds));object_unparent (OBJECT (clientCreds)); +object_unparent (OBJECT (auth));qcrypto_tls_session_free (serverSess);qcrypto_tls_session_free (clientSess);
tests/test-io-channel-tls.c +11 -5
@@ -28,7 +28,7 @@#include "io/channel-socket.h" #include "io-channel-helpers.h" #include "crypto/tlscredsx509.h" -#include "qemu/acl.h" +#include "qemu/authz-simple.h" #include "qom/object_interfaces.h" #ifdef QCRYPTO_HAVE_TLS_TEST_SUPPORT
@@ -115,7 +115,7 @@ static void test_io_channel_tls(const void *opaque)QIOChannelTLS *serverChanTLS;QIOChannelSocket *clientChanSock;QIOChannelSocket *serverChanSock; -qemu_acl *acl; +QAuthZSimple *auth;const char *const *wildcards;int channel[2 ];struct QIOChannelTLSHandshakeData clientHandshake = { false, false };
@@ -166,11 +166,15 @@ static void test_io_channel_tls(const void *opaque) &err);g_assert (serverCreds !=NULL ); - acl =qemu_acl_init ("channeltlsacl" ); -qemu_acl_reset (acl); + auth =qauthz_simple_new ("channeltlsacl" , +QAUTHZ_SIMPLE_POLICY_DENY , + &error_abort); wildcards = data->wildcards;while (wildcards && *wildcards) { -qemu_acl_append (acl,0 , *wildcards); +qauthz_simple_append_rule (auth, *wildcards, +QAUTHZ_SIMPLE_POLICY_ALLOW , +QAUTHZ_SIMPLE_FORMAT_GLOB , + &error_abort); wildcards++; }
@@ -256,6 +260,8 @@ static void test_io_channel_tls(const void *opaque)object_unref (OBJECT (serverChanSock));object_unref (OBJECT (clientChanSock)); +object_unparent (OBJECT (auth)); +close (channel[0 ]);close (channel[1 ]); }
ui/vnc-auth-sasl.c +1 -1
@@ -150,7 +150,7 @@ static int vnc_auth_sasl_check_access(VncState *vs)return 0 ; } - allow =qemu_acl_party_is_allowed (vs->vd->sasl.acl, vs->sasl.username); + allow =qauthz_is_allowed (vs->vd->sasl.acl, vs->sasl.username,NULL );VNC_DEBUG ("SASL client %s %s by ACL\n" , vs->sasl.username, allow ?"allowed" :"denied" );
ui/vnc-auth-sasl.h +2 -2
@@ -32,7 +32,7 @@typedef struct VncStateSASL VncStateSASL ;typedef struct VncDisplaySASL VncDisplaySASL ; -#include "qemu/acl.h" +#include "qemu/authz.h" #include "qemu/main-loop.h" struct VncStateSASL {
@@ -61,7 +61,7 @@ struct VncStateSASL { };struct VncDisplaySASL { -qemu_acl *acl; +QAuthZ *acl; };void vnc_sasl_client_cleanup (VncState *vs);
ui/vnc.c +8 -3
@@ -33,7 +33,7 @@#include "qemu/error-report.h" #include "qemu/sockets.h" #include "qemu/timer.h" -#include "qemu/acl.h" +#include "qemu/authz-simple.h" #include "qemu/config-file.h" #include "qapi/qmp/qerror.h" #include "qapi/qmp/types.h"
@@ -3742,7 +3742,9 @@ void vnc_display_open(const char *id, Error **errp) }else { vs->tlsaclname =g_strdup_printf ("vnc.%s.x509dname" , vs->id); } -qemu_acl_init (vs->tlsaclname); +qauthz_simple_new (vs->tlsaclname, +QAUTHZ_SIMPLE_POLICY_DENY , + &error_abort); }#ifdef CONFIG_VNC_SASL if (acl && sasl) {
@@ -3753,7 +3755,10 @@ void vnc_display_open(const char *id, Error **errp) } else { aclname =g_strdup_printf ("vnc.%s.username" , vs->id); } - vs->sasl.acl =qemu_acl_init (aclname); + vs->sasl.acl = +QAUTHZ (qauthz_simple_new (aclname, +QAUTHZ_SIMPLE_POLICY_DENY , + &error_abort));g_free (aclname); }#endif
util/Makefile.objs +0 -1
@@ -13,7 +13,6 @@ util-obj-y += envlist.o path.o module.o util-obj-$(call lnot,$(CONFIG_INT128)) += host-utils.o util-obj-y += bitmap.o bitops.o hbitmap.o util-obj-y += fifo8.o -util-obj-y += acl.o util-obj-y += error.o qemu-error.o util-obj-y += id.o util-obj-y += iov.o qemu-config.o qemu-sockets.o uri.o notify.o
util/acl.c deleted +0 -188
188 lines not on this page · raw message
Signature · 1 line
2.5.5
Ping, does anyone have further feedback about this series ?
Quoted 153 lines · Daniel P. Berrange
This is a followup of previously posted work in 2.6 cycle:
v1: https://lists.gnu.org/archive/html/qemu-devel/2016-02/msg04618.html
v2: https://lists.gnu.org/archive/html/qemu-devel/2016-03/msg01454.html
v3: https://lists.gnu.org/archive/html/qemu-devel/2016-03/msg02498.html
v4: https://lists.gnu.org/archive/html/qemu-devel/2016-05/msg01661.html
v5: https://lists.gnu.org/archive/html/qemu-devel/2016-06/msg00485.htmlMany years ago I was responsible for adding the '
qemu_acl' type and associated HMP commands. Looking back at it now, it is quite a poor facility with a couple of bad limitations. First, the responsibility for creating the ACLs was left with the QEMU network service (VNC server was only thing ever doing it). This meant you could not share ACLs across multiple services. Second, there was no way to populate ACLs on the command line, you had no choice but to use the HMP commands. Third, the API was hardcoded around the idea of an in-QEMU implementation, leaving no scope for plugging in alternative implementations backed by, for example, LDAP or PAM.This series introduces a much better authorization API design to QEMU that addresses all these problems, and maintains back compatibility. It of course is based on the QOM framework, so that immediately gives us ability to create objects via the CLI, HMP or QMP. There is an abstract base clss "QAuthZ" which defines the basic API for QEMU network services to use, and a specific implementation "QAuthZ" simple which replicates the functionality of '
qemu_acl'. It is thus possible to add other impls, without changing any other part of QEMU in the future. Finally, the user is responsible for creating the ACL objects, so they can have one ACL associated with all their TLS enabled network services.There was only one small problem with this, specifically the -object CLI arg and HMP '
object_add' command had no way to let the user specify non-scalar properties for objects. eg if an object had a property which is a list of structs, you are out of luck if you want to create it without using QMP.Thus the first four patches do some work around QAPI / QOM to make it possible to specify non-scalar properties with the -object CLI arg and HMP '
object_add' command. See the respective patches for illustration of the syntax used. Some of Max's recent block patches also depend on theqdict_crumplemethod in patch 1.The patches 5 and 6 introduce the new base class and specific implementation.
Patch 7 kills the old
qemu_aclcode, updating any existing callers of it to use the QAuthZSimple QOM class instead.Previously there were further patches adding ACL support for chardevs, migration, nbd, etc. These will be posted later once this core code is merged, so they can flow via the respective maintainer's trees
Changed in v6:
- Switch from
while()tofor()loop for iterating over dicts (Markus)
- Avoid redundant strdup (Markus)
- Rewrap comments at 70 chars (Markus)
- Changeqdict_list_size()toqdict_is_list()(Markus)
- Misc docs changes (Markus)
- Change QmpInputVisitor so the code for handling the string types is separate from code using native scalar types (Paolo)
- Centralize code parsing bool strings (Markus)
- Centralize code parsing int strings (Markus)Changed in v5:
- Resolved conflicts with Eric's visitor refactoring which made it stricter about struct begin/end calls
- Added support for ACLs to migration code now its TLS support is merged.
- Fixed typos in example in commit messageChanged in v4:
- Ensure examples use shell escaping for '*' (Eric)
- Add more tests for crumple impl (Eric)
- Raise error if sasl-acl/tls-acl are requested but sasl/tls auth are not enabled (Eric)
- Document return codes for auth check more clearly (Eric)
- Don't silently turn a glob match into a strcmp if fnmatch is not present (Eric)
- Other misc small typos/fixes (Eric)Changed in v3:
- Created separate
qdict_list_sizemethod (Max)
- Added unit tests for case of empty dict (Max)
- Fix variable names to use underscore separator (Max)
- Fix potential free of uninitialized variables (Max)
- Use QObject APIs for casts, instead of C type casts (Max)Changed in v2:
- Adapt to changes in qapi visitor APIs
- Add a 'bool recursive' flag toqdict_crumple(Max)
- Fix memory leaks inqdict_crumple(Max)
- Split out key splitting code fromqdict_crumple(Max)
- Use saner variable names inqdict_crumple(Max)
- Added some tests for bad inputs toqdict_crumpleDaniel P. Berrange (7):
qdict: implement aqdict_crumplemethod for un-flattening a dict
option: make parse_option_bool/number non-static
qapi: add a QmpInputVisitor that does string conversion
qom: support arbitrary non-scalar properties with -object
util: add QAuthZ object as an authorization base class
util: add QAuthZSimple object type for a simple access control list
acl: delete existing ACL implementationMAINTAINERS | 7 + Makefile | 9 +- Makefile.objs | 2 + Makefile.target | 2 + crypto/tlssession.c | 28 +++- hmp.c | 18 +-- include/qapi/qmp-input-visitor.h | 42 +++++- include/qapi/qmp/qdict.h | 1 + include/qemu/acl.h | 74 --------- include/qemu/authz-simple.h | 115 ++++++++++++++ include/qemu/authz.h | 89 +++++++++++ include/qemu/option.h | 4 + include/qom/object_interfaces.h | 10 +- monitor.c | 181 ++++++++++++++-------- qapi-schema.json | 6 +- qapi/opts-visitor.c | 19 +-- qapi/qmp-input-visitor.c | 80 ++++++++++ qapi/util.json | 47 ++++++ qmp.c | 2 +- qobject/qdict.c | 283 ++++++++++++++++++++++++++++++++++ qom/object_interfaces.c | 49 ++++-- tests/.gitignore | 1 + tests/Makefile.include | 5 +- tests/check-qdict.c | 241 +++++++++++++++++++++++++++++ tests/check-qom-proplist.c | 319 ++++++++++++++++++++++++++++++++++++++- tests/test-authz-simple.c | 172 +++++++++++++++++++++ tests/test-crypto-tlssession.c | 15 +- tests/test-io-channel-tls.c | 16 +- tests/test-qmp-input-visitor.c | 119 ++++++++++++++- ui/vnc-auth-sasl.c | 2 +- ui/vnc-auth-sasl.h | 4 +- ui/vnc.c | 11 +- util/Makefile.objs | 4 +- util/acl.c | 188 ----------------------- util/authz-simple.c | 314 ++++++++++++++++++++++++++++++++++++++ util/authz.c | 46 ++++++ util/qemu-option.c | 27 ++-- 37 files changed, 2133 insertions(+), 419 deletions(-)
Quoted 12 lines
delete mode 100644 include/qemu/acl.h create mode 100644 include/qemu/authz-simple.h create mode 100644 include/qemu/authz.h create mode 100644 qapi/util.json create mode 100644 tests/test-authz-simple.c delete mode 100644 util/acl.c create mode 100644 util/authz-simple.c create mode 100644 util/authz.cSignature · 1 line
2.5.5
Regards,
Daniel
Signature · 4 lines
|: http://berrange.com -o- http://www.flickr.com/photos/dberrange/ :| |: http://libvirt.org -o- http://virt-manager.org :| |: http://autobuild.org -o- http://search.cpan.org/~danberr/ :| |: http://entangle-photo.org -o- http://live.gnome.org/gtk-vnc :|
Re: [Qemu-devel] [PATCH v6 4/7] qom: support arbitrary non-scalar properties with -object
In reply to Daniel P. BerrangeHi
Quoted 65 lines · Daniel P. Berrange
The current -object command line syntax only allows for creation of objects with scalar properties, or a list with a fixed scalar element type. Objects which have properties that are represented as structs in the QAPI schema cannot be created using -object.
This is a design limitation of the way the OptsVisitor is written. It simply iterates over the QemuOpts values as a flat list. The support for lists is enabled by allowing the same key to be repeated in the opts string.
It is not practical to extend the OptsVisitor to support more complex data structures while also maintaining the existing list handling behaviour that is relied upon by other areas of QEMU.
Fortunately there is no existing object that implements the UserCreatable interface that relies on the list handling behaviour, so it is possible to swap out the OptsVisitor for a different visitor implementation, so -object supports non-scalar properties, thus leaving other users of OptsVisitor unaffected.
The previously added
qdict_crumple()method is able to take a qdict containing a flat set of properties and turn that into a arbitrarily nested set of dicts and lists. By combiningqemu_opts_to_qdictandqdict_crumple()together, we can turn the opt string into a data structure that is practically identical to that passed over QMP when defining an object. The only difference is that all the scalar values are represented as strings, rather than strings, ints and bools. This is sufficient to let us replace the OptsVisitor with the QMPInputVisitor for use with -object.Thus -object can now support non-scalar properties, for example the QMP object
{ "execute": "object-add", "arguments": { "qom-type": "demo", "id": "demo0", "parameters": { "foo": [ { "bar": "one", "wizz": "1" }, { "bar": "two", "wizz": "2" } ] } } }Would be creatable via the CLI now using
$QEMU \ -object demo,id=demo0,\ foo.0.bar=one,foo.0.wizz=1,\ foo.1.bar=two,foo.1.wizz=2Notice that this syntax is intentionally compatible with that currently used by block drivers.
This is also wired up to work for the '
object_add' command in the HMP monitor with the same syntax.
Quoted 8 lines
(hmp) object_add demo,id=demo0,\ foo.0.bar=one,foo.0.wizz=1,\ foo.1.bar=two,foo.1.wizz=2NB indentation should not be used with HMP commands, this is just for convenient formatting in this commit message.
Signed-off-by Daniel P. Berrange <[email protected]>
The patch breaks parsing of size arguments:
-object memory-backend-file,id=mem,size=512M,mem-path=/tmp: Parameter 'size' expects a number
Looks like the previous patch needs type_size support
Quoted 625 lines
--- hmp.c | 18 +-- include/qom/object_interfaces.h | 10 +- qmp.c | 2 +- qom/object_interfaces.c | 49 ++++-- tests/check-qom-proplist.c | 319 +++++++++++++++++++++++++++++++++++++++- 5 files changed, 365 insertions(+), 33 deletions(-)hmp.c +5
-13@@ -25,7 +25,7 @@#include "qemu/sockets.h" #include "monitor/monitor.h" #include "monitor/qdev.h" -#include "qapi/opts-visitor.h" +#include "qapi/qmp-input-visitor.h" #include "qapi/qmp/qerror.h" #include "qapi/string-output-visitor.h" #include "qapi/util.h" @@ -1717,20 +1717,12 @@ void hmp_netdev_del(Monitor *mon, const QDict *qdict)void hmp_object_add (Monitor *mon,const QDict *qdict) {Error *err =NULL ; -QemuOpts *opts; -OptsVisitor *ov; +QmpInputVisitor *qiv;Object *obj =NULL ; - opts =qemu_opts_from_qdict (qemu_find_opts ("object" ), qdict, &err); -if (err) { -hmp_handle_error (mon, &err); -return ; - } - - ov =opts_visitor_new (opts); - obj =user_creatable_add (qdict,opts_get_visitor (ov), &err); -opts_visitor_cleanup (ov); -qemu_opts_del (opts); + qiv =qmp_string_input_visitor_new ((QObject *)qdict, true); + obj =user_creatable_add (qdict,qmp_input_get_visitor (qiv), &err); +qmp_input_visitor_cleanup (qiv);if (err) {hmp_handle_error (mon, &err);include/qom/object_interfaces.h +8
-2@@ -96,18 +96,24 @@ Object *user_creatable_add(const QDict *qdict,* user_creatable_add_type: * @type: the object type name * @id: the unique ID for the object +* @nested: whether to recurse into the visitor for properties * @qdict: the object properties * @v: the visitor * @errp: if an error occurs, a pointer to an area to store the error * * Create an instance of the user creatable object @type, placing * it in the object composition tree with name @id, initializing -* it with properties from @qdict +* it with properties from @qdict. +* +* If the visitor is already positioned to read the properties +* in @qdict, @nested should be false. Conversely, if it is +* neccessary to open/close a struct to read the properties in +* @qdict, @nested should be true. * * Returns: the newly created object or NULL on error */ Object *user_creatable_add_type (const char *type,const char *id, -const QDict *qdict, +bool nested,const QDict *qdict,Visitor *v,Error **errp);/** qmp.c +1
-1@@ -667,7 +667,7 @@ void qmp_object_add(const char *type, const char *id, } qiv =qmp_input_visitor_new (props, true); - obj =user_creatable_add_type (type, id, pdict, + obj =user_creatable_add_type (type, id, true, pdict,qmp_input_get_visitor (qiv), errp);qmp_input_visitor_cleanup (qiv);if (obj) {qom/object_interfaces.c +33
-16@@ -3,6 +3,7 @@#include "qom/object_interfaces.h" #include "qemu/module.h" #include "qapi-visit.h" +#include "qapi/qmp-input-visitor.h" #include "qapi/qmp-output-visitor.h" #include "qapi/opts-visitor.h" @@ -63,12 +64,16 @@ Object *user_creatable_add(const QDict *qdict,if (local_err) { goto out_visit; } -visit_check_struct (v, &local_err); + + obj =user_creatable_add_type (type, id, false, pdict, v, &local_err);if (local_err) { goto out_visit; } - obj =user_creatable_add_type (type, id, pdict, v, &local_err); +visit_check_struct (v, &local_err); +if (local_err) { + goto out_visit; + } out_visit:visit_end_struct (v);@@ -87,7 +92,7 @@ out:Object *user_creatable_add_type (const char *type,const char *id, -const QDict *qdict, +bool nested,const QDict *qdict,Visitor *v,Error **errp) {Object *obj;@@ -114,9 +119,11 @@ Object *user_creatable_add_type(const char *type, const char *id,assert (qdict); obj =object_new (type); -visit_start_struct (v,NULL ,NULL ,0 , &local_err); -if (local_err) { - goto out; +if (nested) { +visit_start_struct (v,NULL ,NULL ,0 , &local_err); +if (local_err) { + goto out; + } }for (e =qdict_first (qdict); e; e =qdict_next (qdict, e)) {object_property_set (obj, v, e->key, &local_err);@@ -124,12 +131,14 @@ Object *user_creatable_add_type(const char *type, const char *id,break ; } } -if (!local_err) { -visit_check_struct (v, &local_err); - } -visit_end_struct (v); -if (local_err) { - goto out; +if (nested) { +if (!local_err) { +visit_check_struct (v, &local_err); + } +visit_end_struct (v); +if (local_err) { + goto out; + } } object_property_add_child(object_get_objects_root(),@@ -156,15 +165,23 @@ out:Object *user_creatable_add_opts (QemuOpts *opts,Error **errp) { -OptsVisitor *ov; +QmpInputVisitor *qiv;QDict *pdict; +QObject *pobj;Object *obj =NULL ; - ov =opts_visitor_new (opts); pdict =qemu_opts_to_qdict (opts,NULL ); - obj =user_creatable_add (pdict,opts_get_visitor (ov), errp); -opts_visitor_cleanup (ov); + pobj =qdict_crumple (pdict, true, errp); +if (!pobj) { + goto cleanup; + } + qiv =qmp_string_input_visitor_new (pobj, true); + + obj =user_creatable_add ((QDict *)pobj,qmp_input_get_visitor (qiv), errp); +qmp_input_visitor_cleanup (qiv); +qobject_decref (pobj); + cleanup:QDECREF (pdict);return obj; }tests/check-qom-proplist.c +318
-2@@ -23,6 +23,14 @@#include "qapi/error.h" #include "qom/object.h" #include "qemu/module.h" +#include "qapi/visitor.h" +#include "qom/object_interfaces.h" +#include "qemu/option.h" +#include "qemu/config-file.h" +#include "qapi/qmp/qjson.h" +#include "qapi/qmp-input-visitor.h" +#include "qapi-visit.h" +#include "qapi/dealloc-visitor.h" #define TYPE_DUMMY "qemu-dummy"@@ -30,6 +38,11 @@typedef struct DummyObject DummyObject ;typedef struct DummyObjectClass DummyObjectClass ; +typedef struct DummyPerson DummyPerson ; +typedef struct DummyAddr DummyAddr ; +typedef struct DummyAddrList DummyAddrList ; +typedef struct DummySizeList DummySizeList ; +#define DUMMY_OBJECT (obj) \ OBJECT_CHECK(DummyObject, (obj), TYPE_DUMMY)@@ -50,12 +63,35 @@ static const char *const dummy_animal_map[DUMMY_LAST + 1] = { [DUMMY_LAST] = NULL, }; + +struct DummyAddr { +char *ip; +int64_t prefix; +bool ipv6only; +}; + +struct DummyAddrList { +DummyAddrList *next; +struct DummyAddr *value; +}; + +struct DummyPerson { +char *name; +int64_t age; +}; +struct DummyObject {Object parent_obj;bool bv;DummyAnimal av;char *sv; + +intList *sizes; + +DummyPerson *person; + +DummyAddrList *addrs; };struct DummyObjectClass {@@ -117,6 +153,159 @@ static char *dummy_get_sv(Object *obj,return g_strdup (dobj->sv); } +static void visit_type_DummyPerson_fields (Visitor *v,DummyPerson **obj, +Error **errp) +{ +Error *err =NULL ; + +visit_type_str (v,"name" , &(*obj)->name, &err); +if (err) { + goto out; + } +visit_type_int (v,"age" , &(*obj)->age, &err); +if (err) { + goto out; + } + +out: +error_propagate (errp, err); +} + +static void visit_type_DummyPerson (Visitor *v,const char *name, +DummyPerson **obj,Error **errp) +{ +Error *err =NULL ; + +visit_start_struct (v, name, (void **)obj,sizeof (DummyPerson), &err); +if (err) { + goto out; + } +if (!*obj) { + goto out_obj; + } +visit_type_DummyPerson_fields (v, obj, &err); +error_propagate (errp, err); + err =NULL ; +out_obj: +visit_end_struct (v); +out: +error_propagate (errp, err); +} + +static void visit_type_DummyAddr_members (Visitor *v,DummyAddr **obj, +Error **errp) +{ +Error *err =NULL ; + +visit_type_str (v,"ip" , &(*obj)->ip, &err); +if (err) { + goto out; + } +visit_type_int (v,"prefix" , &(*obj)->prefix, &err); +if (err) { + goto out; + } +visit_type_bool (v,"ipv6only" , &(*obj)->ipv6only, &err); +if (err) { + goto out; + } + +out: +error_propagate (errp, err); +} + +static void visit_type_DummyAddr (Visitor *v,const char *name, +DummyAddr **obj,Error **errp) +{ +Error *err =NULL ; + +visit_start_struct (v, name, (void **)obj,sizeof (DummyAddr), &err); +if (err) { + goto out; + } +if (!*obj) { + goto out_obj; + } +visit_type_DummyAddr_members (v, obj, &err); +error_propagate (errp, err); + err =NULL ; +out_obj: +visit_end_struct (v); +out: +error_propagate (errp, err); +} + +static void qapi_free_DummyAddrList (DummyAddrList *obj); + +static void visit_type_DummyAddrList (Visitor *v,const char *name, +DummyAddrList **obj,Error **errp) +{ +Error *err =NULL ; +DummyAddrList *tail; +size_t size =sizeof (**obj); + +visit_start_list (v, name, (GenericList **)obj, size, &err); +if (err) { + goto out; + } + +for (tail = *obj; tail; + tail = (DummyAddrList *)visit_next_list (v, + (GenericList *)tail, + size)) { +visit_type_DummyAddr (v,NULL , &tail->value, &err); +if (err) { +break ; + } + } + +visit_end_list (v); +if (err &&visit_is_input (v)) { +qapi_free_DummyAddrList (*obj); + *obj =NULL ; + } +out: +error_propagate (errp, err); +} + +static void qapi_free_DummyAddrList (DummyAddrList *obj) +{ +QapiDeallocVisitor *qdv; +Visitor *v; + +if (!obj) { +return ; + } + + qdv =qapi_dealloc_visitor_new (); + v =qapi_dealloc_get_visitor (qdv); +visit_type_DummyAddrList (v,NULL , &obj,NULL ); +qapi_dealloc_visitor_cleanup (qdv); +} + +static void dummy_set_sizes (Object *obj,Visitor *v,const char *name, +void *opaque,Error **errp) +{ +DummyObject *dobj =DUMMY_OBJECT (obj); + +visit_type_intList (v, name, &dobj->sizes, errp); +} + +static void dummy_set_person (Object *obj,Visitor *v,const char *name, +void *opaque,Error **errp) +{ +DummyObject *dobj =DUMMY_OBJECT (obj); + +visit_type_DummyPerson (v, name, &dobj->person, errp); +} + +static void dummy_set_addrs (Object *obj,Visitor *v,const char *name, +void *opaque,Error **errp) +{ +DummyObject *dobj =DUMMY_OBJECT (obj); + +visit_type_DummyAddrList (v, name, &dobj->addrs, errp); +}static void dummy_init (Object *obj) {@@ -126,9 +315,16 @@ static void dummy_init(Object *obj) NULL); } +static void +dummy_complete (UserCreatable *uc,Error **errp) +{ +}static void dummy_class_init (ObjectClass *cls,void *data) { +UserCreatableClass *ucc =USER_CREATABLE_CLASS (cls); + ucc->complete = dummy_complete; + object_class_property_add_bool(cls, "bv", dummy_get_bv, dummy_set_bv,@@ -143,12 +339,36 @@ static void dummy_class_init(ObjectClass *cls, void *data) dummy_get_av, dummy_set_av, NULL); +object_class_property_add (cls,"sizes" , +"int[]" , +NULL , + dummy_set_sizes, +NULL ,NULL ,NULL ); +object_class_property_add (cls,"person" , +"DummyPerson" , +NULL , + dummy_set_person, +NULL ,NULL ,NULL ); +object_class_property_add (cls,"addrs" , +"DummyAddrList" , +NULL , + dummy_set_addrs, +NULL ,NULL ,NULL ); }static void dummy_finalize (Object *obj) {DummyObject *dobj =DUMMY_OBJECT (obj); +QapiDeallocVisitor *qdv; +Visitor *v; + + qdv =qapi_dealloc_visitor_new (); + v =qapi_dealloc_get_visitor (qdv); +visit_type_intList (v,NULL , &dobj->sizes,NULL ); +visit_type_DummyAddrList (v,NULL , &dobj->addrs,NULL ); +visit_type_DummyPerson (v,NULL , &dobj->person,NULL ); +qapi_dealloc_visitor_cleanup (qdv);g_free (dobj->sv); }@@ -162,6 +382,10 @@ static const TypeInfo dummy_info = { .instance_finalize = dummy_finalize, .class_size = sizeof(DummyObjectClass), .class_init = dummy_class_init, + .interfaces = (InterfaceInfo []) { + {TYPE_USER_CREATABLE }, + { } + } };@@ -457,7 +681,9 @@ static void test_dummy_iterator(void)ObjectProperty *prop;ObjectPropertyIterator iter; -bool seenbv = false, seensv = false, seenav = false, seentype; +bool seenbv = false, seensv = false, seenav = false, + seentype = false, seenaddrs = false, seenperson = false, + seensizes = false;object_property_iter_init (&iter,OBJECT (dobj));while ((prop =object_property_iter_next (&iter))) {@@ -470,6 +696,12 @@ static void test_dummy_iterator(void) }else if (g_str_equal (prop->name,"type" )) {/* This prop comes from the base Object class */ seentype = true; + }else if (g_str_equal (prop->name,"addrs" )) { + seenaddrs = true; + }else if (g_str_equal (prop->name,"person" )) { + seenperson = true; + }else if (g_str_equal (prop->name,"sizes" )) { + seensizes = true; }else {g_printerr ("Found prop '%s'\n" , prop->name);g_assert_not_reached ();@@ -479,6 +711,9 @@ static void test_dummy_iterator(void)g_assert (seenav);g_assert (seensv);g_assert (seentype); +g_assert (seenaddrs); +g_assert (seenperson); +g_assert (seensizes);object_unparent (OBJECT (dobj)); }@@ -497,11 +732,91 @@ static void test_dummy_delchild(void)object_unparent (OBJECT (dev)); } + +static QemuOptsList dummy_opts = { + .name ="object" , + .implied_opt_name ="qom-type" , + .head =QTAILQ_HEAD_INITIALIZER (dummy_opts.head), + .desc = { + { } + }, +}; + +static void test_dummy_create_complex (DummyObject *dummy) +{ +g_assert (dummy->person !=NULL ); + g_assert_cmpstr(dummy->person->name, ==, "fred"); + g_assert_cmpint(dummy->person->age, ==, 52); + +g_assert (dummy->sizes !=NULL ); + g_assert_cmpint(dummy->sizes->value, ==, 12); + g_assert_cmpint(dummy->sizes->next->value, ==, 65); + g_assert_cmpint(dummy->sizes->next->next->value, ==, 8139); + +g_assert (dummy->addrs !=NULL ); + g_assert_cmpstr(dummy->addrs->value->ip, ==, "127.0.0.1"); + g_assert_cmpint(dummy->addrs->value->prefix, ==, 24); +g_assert (dummy->addrs->value->ipv6only); + g_assert_cmpstr(dummy->addrs->next->value->ip, ==, "0.0.0.0"); + g_assert_cmpint(dummy->addrs->next->value->prefix, ==, 16); +g_assert (!dummy->addrs->next->value->ipv6only); +} + + +static void test_dummy_createopts (void ) +{ +const char *optstr ="qemu-dummy,id=dummy0,bv=yes,av=alligator,sv=hiss," +"person.name=fred,person.age=52,sizes.0=12,sizes.1=65,sizes.2=8139," +"addrs.0.ip=127.0.0.1,addrs.0.prefix=24,addrs.0.ipv6only=yes," +"addrs.1.ip=0.0.0.0,addrs.1.prefix=16,addrs.1.ipv6only=no" ; +QemuOpts *opts; +DummyObject *dummy; + + opts =qemu_opts_parse_noisily (&dummy_opts, + optstr, true); +g_assert (opts !=NULL ); + + dummy =DUMMY_OBJECT (user_creatable_add_opts (opts, &error_abort)); + +test_dummy_create_complex (dummy); + +object_unparent (OBJECT (dummy)); +object_unref (OBJECT (dummy)); +} + + +static void test_dummy_createqmp (void ) +{ +const char *jsonstr = +"{ 'qom-type': 'qemu-dummy', 'id': 'dummy0', " +" 'bv': true, 'av': 'alligator', 'sv': 'hiss', " +" 'person': { 'name': 'fred', 'age': 52 }, " +" 'sizes': [12, 65, 8139], " +" 'addrs': [ { 'ip': '127.0.0.1', 'prefix': 24, 'ipv6only': true }, " +" { 'ip': '0.0.0.0', 'prefix': 16, 'ipv6only': false } ] }" ; +QObject *obj =qobject_from_json (jsonstr); +QmpInputVisitor *qiv =qmp_input_visitor_new (obj, true); +DummyObject *dummy; +g_assert (obj); + dummy =DUMMY_OBJECT (user_creatable_add (qobject_to_qdict (obj), +qmp_input_get_visitor (qiv), + &error_abort)); + +test_dummy_create_complex (dummy); +qmp_input_visitor_cleanup (qiv); +object_unparent (OBJECT (dummy)); +object_unref (OBJECT (dummy)); +qobject_decref (obj); +} +int main (int argc,char **argv) {g_test_init (&argc, &argv,NULL );module_call_init (MODULE_INIT_QOM ); + +qemu_add_opts (&dummy_opts); +type_register_static (&dummy_info);type_register_static (&dummy_dev_info);type_register_static (&dummy_bus_info);@@ -513,6 +828,8 @@ int main(int argc, char **argv)g_test_add_func ("/qom/proplist/getenum" , test_dummy_getenum);g_test_add_func ("/qom/proplist/iterator" , test_dummy_iterator);g_test_add_func ("/qom/proplist/delchild" , test_dummy_delchild); +g_test_add_func ("/qom/proplist/createopts" , test_dummy_createopts); +g_test_add_func ("/qom/proplist/createqmp" , test_dummy_createqmp);return g_test_run (); } --2.5.5
Signature · 1 line
Marc-André Lureau
Re: [Qemu-devel] [PATCH v6 1/7] qdict: implement a qdict_crumple method for un-flattening a dict
In reply to Daniel P. BerrangeHi
Quoted 104 lines · Daniel P. Berrange
The
qdict_flatten()method will take a dict whose elements are further nested dicts/lists and flatten them by concatenating keys.The
qdict_crumple()method aims to do the reverse, taking a flat qdict, and turning it into a set of nested dicts/lists. It will apply nesting based on the key name, with a '.' indicating a new level in the hierarchy. If the keys in the nested structure are all numeric, it will create a list, otherwise it will create a dict.If the keys are a mixture of numeric and non-numeric, or the numeric keys are not in strictly ascending order, an error will be reported.
As an example, a flat dict containing
{ 'foo.0.bar': 'one', 'foo.0.wizz': '1', 'foo.1.bar': 'two', 'foo.1.wizz': '2'}
will get turned into a dict with one element 'foo' whose value is a list. The list elements will each in turn be dicts.
{ 'foo': [ { 'bar': 'one', 'wizz': '1' }, { 'bar': 'two', 'wizz': '2' } ],}
If the key is intended to contain a literal '.', then it must be escaped as '..'. ie a flat dict
{ 'foo..bar': 'wizz', 'bar.foo..bar': 'eek', 'bar.hello': 'world' }Will end up as
{ 'foo.bar': 'wizz', 'bar': { 'foo.bar': 'eek', 'hello': 'world' } }The intent of this function is that it allows a set of QemuOpts to be turned into a nested data structure that mirrors the nesting used when the same object is defined over QMP.
Signed-off-by Daniel P. Berrange <[email protected]>--- include/qapi/qmp/qdict.h | 1 + qobject/qdict.c | 283 +++++++++++++++++++++++++++++++++++++++++++++++ tests/check-qdict.c | 241 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 525 insertions(+)include/qapi/qmp/qdict.h +1
-0@@ -73,6 +73,7 @@ void qdict_flatten(QDict *qdict);void qdict_extract_subqdict (QDict *src,QDict **dst,const char *start);void qdict_array_split (QDict *src,QList **dst);int qdict_array_entries (QDict *src,const char *subqdict); +QObject *qdict_crumple (QDict *src,bool recursive,Error **errp);void qdict_join (QDict *dest,QDict *src,bool overwrite);qobject/qdict.c +12
-0@@ -17,6 +17,7 @@#include "qapi/qmp/qbool.h" #include "qapi/qmp/qstring.h" #include "qapi/qmp/qobject.h" +#include "qapi/error.h" #include "qemu/queue.h" #include "qemu-common.h" #include "qemu/cutils.h" @@ -683,6 +684,288 @@ void qdict_array_split(QDict *src, QList **dst) } } + +/** +* qdict_split_flat_key: +* @key: the key string to split +* @prefix: non-NULL pointer to hold extracted prefix +* @suffix: non-NULL pointer to remaining suffix +* +* Given a flattened key such as 'foo.0.bar', split it into two parts +* at the first '.' separator. Allows double dot ('..') to escape the +* normal separator. +*
qobject/qdict.c void qdict_array_split(QDict *src, QList **dst) · line 707
Quoted 10 lines
qobject/qdict.c +10
-0+* eg +* 'foo.0.bar' -> prefix='foo' and suffix='0.bar' +* 'foo..0.bar' -> prefix='foo.0' and suffix='bar' +* +* The '..' sequence will be unescaped in the returned 'prefix' +* string. The 'suffix' string will be left in escaped format, so it +* can be fed back into the qdict_split_flat_key() key as the input +* later. +* +* The caller is responsible for freeing the strin returned in @prefix
s/strin/string
Quoted 33 lines
qobject/qdict.c +33
-0+* using g_free(). +*/ +static void qdict_split_flat_key (const char *key,char **prefix, +const char **suffix) +{ +const char *separator; +size_t i, j; + +/* Find first '.' separator, but if there is a pair '..' +* that acts as an escape, so skip over '..' */ + separator =NULL ; +do { +if (separator) { + separator +=2 ; + }else { + separator = key; + } + separator =strchr (separator,'.' ); + }while (separator && separator[1 ] =='.' ); + +if (separator) { + *prefix =g_strndup (key, + separator - key); + *suffix = separator +1 ; + }else { + *prefix =g_strdup (key); + *suffix =NULL ; + } + +/* Unescape the '..' sequence into '.' */ +for (i =0 , j =0 ; (*prefix)[i] !='\0' ; i++, j++) { +if ((*prefix)[i] =='.' ) { +assert ((*prefix)[i +1 ] =='.' );
qobject/qdict.c void qdict_array_split(QDict *src, QList **dst) · line 750
Quoted 10 lines
qobject/qdict.c +10
-0+ i++; + } + (*prefix)[j] = (*prefix)[i]; + } + (*prefix)[j] ='\0' ; +} + + +/** +* qdict_is_list
missing :
Quoted 59 lines
qobject/qdict.c +59
-0+* @maybe_list: dict to check if keys represent list elements. +* +* Determine whether all keys in @maybe_list are valid list elements. +* If @maybe_list is non-zero in length and all the keys look like +* valid list indexes, this will return 1. If @maybe_list is zero +* length or all keys are non-numeric then it will return 0 to indicate +* it is a normal qdict. If there is a mix of numeric and non-numeric +* keys, or the list indexes are non-contiguous, an error is reported. +* +* Returns: 1 if a valid list, 0 if a dict, -1 on error +*/ +static int qdict_is_list (QDict *maybe_list,Error **errp) +{ +const QDictEntry *ent; +ssize_t len =0 ; +ssize_t max =-1 ; +int is_list =-1 ; +int64_t val; + +for (ent =qdict_first (maybe_list); ent !=NULL ; + ent =qdict_next (maybe_list, ent)) { + +if (qemu_strtoll (ent->key,NULL ,10 , &val) ==0 ) { +if (is_list ==-1 ) { + is_list =1 ; + }else if (!is_list) { +error_setg (errp, +"Cannot crumple a dictionary with a mix of list " +"and non-list keys" ); +return -1 ; + } + len++; +if (val > max) { + max = val; + } + }else { +if (is_list ==-1 ) { + is_list =0 ; + }else if (is_list) { +error_setg (errp, +"Cannot crumple a dictionary with a mix of list " +"and non-list keys" ); +return -1 ; + } + } + } + +if (is_list ==-1 ) { +assert (!qdict_size (maybe_list)); + is_list =0 ; + } + +if (len != (max +1 )) { +error_setg (errp,"List indexes are not contigous, " +"saw %zd elements but %zd largest index" , + len, max); +return -1 ; + } +
qobject/qdict.c void qdict_array_split(QDict *src, QList **dst) · line 819
Quoted 10 lines
qobject/qdict.c +10
-0+return is_list ?1 :0 ; +} + +/** +* qdict_crumple: +* @src: the original flat dictionary (only scalar values) to crumple +* @recursive: true to recursively crumple nested dictionaries +* +* Takes a flat dictionary whose keys use '.' separator to indicate +* nesting, and values are scalars, and crumpls it into a nested
crumples
Quoted 419 lines
qobject/qdict.c +149
-0+* structure. If the @recursive parameter is false, then only the +* first level of structure implied by the keys will be crumpled. If +* @recursive is true, then the input will be recursively crumpled to +* expand all levels of structure in the keys. +* +* To include a literal '.' in a key name, it must be escaped as '..' +* +* For example, an input of: +* +* { 'foo.0.bar': 'one', 'foo.0.wizz': '1', +* 'foo.1.bar': 'two', 'foo.1.wizz': '2' } +* +* will result in any output of: +* +* { +* 'foo': [ +* { 'bar': 'one', 'wizz': '1' }, +* { 'bar': 'two', 'wizz': '2' } +* ], +* } +* +* The following scenarios in the input dict will result in an +* error being returned: +* +* - Any values in @src are non-scalar types +* - If keys in @src imply that a particular level is both a +* list and a dict. eg, "foo.0.bar" and "foo.eek.bar". +* - If keys in @src imply that a particular level is a list, +* but the indexes are non-contigous. eg "foo.0.bar" and +* "foo.2.bar" without any "foo.1.bar" present. +* - If keys in @src represent list indexes, but are not in +* the "%zu" format. eg "foo.+0.bar" +* +* Returns: either a QDict or QList for the nested data structure, or NULL +* on error +*/ +QObject *qdict_crumple (QDict *src,bool recursive,Error **errp) +{ +const QDictEntry *ent; +QDict *two_level, *multi_level =NULL ; +QObject *dst =NULL , *child; +size_t i; +char *prefix =NULL ; +const char *suffix =NULL ; +int is_list; + + two_level =qdict_new (); + +/* Step 1: split our totally flat dict into a two level dict */ +for (ent =qdict_first (src); ent !=NULL ; ent =qdict_next (src, ent)) { +if (qobject_type (ent->value) ==QTYPE_QDICT || +qobject_type (ent->value) ==QTYPE_QLIST ) { +error_setg (errp,"Value %s is not a scalar" , + ent->key); + goto error; + } + +qdict_split_flat_key (ent->key, &prefix, &suffix); + + child =qdict_get (two_level, prefix); +if (suffix) { +if (child) { +if (qobject_type (child) !=QTYPE_QDICT ) { +error_setg (errp,"Key %s prefix is already set as a scalar" , + prefix); + goto error; + } + }else { + child =QOBJECT (qdict_new ()); +qdict_put_obj (two_level, prefix, child); + } +qobject_incref (ent->value); +qdict_put_obj (qobject_to_qdict (child), suffix, ent->value); + }else { +if (child) { +error_setg (errp,"Key %s prefix is already set as a dict" , + prefix); + goto error; + } +qobject_incref (ent->value); +qdict_put_obj (two_level, prefix, ent->value); + } + +g_free (prefix); + prefix =NULL ; + } + +/* Step 2: optionally process the two level dict recursively +* into a multi-level dict */ +if (recursive) { + multi_level =qdict_new (); +for (ent =qdict_first (two_level); ent !=NULL ; + ent =qdict_next (two_level, ent)) { + +if (qobject_type (ent->value) ==QTYPE_QDICT ) { + child =qdict_crumple (qobject_to_qdict (ent->value), + recursive, errp); +if (!child) { + goto error; + } + +qdict_put_obj (multi_level, ent->key, child); + }else { +qobject_incref (ent->value); +qdict_put_obj (multi_level, ent->key, ent->value); + } + } +QDECREF (two_level); + }else { + multi_level = two_level; + } + two_level =NULL ; + +/* Step 3: detect if we need to turn our dict into list */ + is_list =qdict_is_list (multi_level, errp); +if (is_list <0 ) { + goto error; + } + +if (is_list) { + dst =QOBJECT (qlist_new ()); + +for (i =0 ; i <qdict_size (multi_level); i++) { +char *key =g_strdup_printf ("%zu" , i); + + child =qdict_get (multi_level, key); +g_free (key); +assert (child); + +qobject_incref (child); +qlist_append_obj (qobject_to_qlist (dst), child); + } +QDECREF (multi_level); + multi_level =NULL ; + }else { + dst =QOBJECT (multi_level); + } + +return dst; + + error: +g_free (prefix); +QDECREF (multi_level); +QDECREF (two_level); +qobject_decref (dst); +return NULL ; +} + +/** * qdict_array_entries(): Returns the number of direct array entries if the * sub-QDict of src specified by the prefix in subqdict (or src itself for tests/check-qdict.c +241
-1@@ -14,6 +14,7 @@#include "qapi/qmp/qint.h" #include "qapi/qmp/qdict.h" #include "qapi/qmp/qstring.h" +#include "qapi/error.h" #include "qemu-common.h" /* @@ -595,6 +596,235 @@ static void qdict_join_test(void)QDECREF (dict2); } + +static void qdict_crumple_test_nonrecursive (void ) +{ +QDict *src, *dst, *rules, *vnc; +QObject *child, *res; + + src =qdict_new (); +qdict_put (src,"vnc.listen.addr" ,qstring_from_str ("127.0.0.1" )); +qdict_put (src,"vnc.listen.port" ,qstring_from_str ("5901" )); +qdict_put (src,"rule.0.match" ,qstring_from_str ("fred" )); +qdict_put (src,"rule.0.policy" ,qstring_from_str ("allow" )); +qdict_put (src,"rule.1.match" ,qstring_from_str ("bob" )); +qdict_put (src,"rule.1.policy" ,qstring_from_str ("deny" )); + + res =qdict_crumple (src, false, &error_abort); + + g_assert_cmpint(qobject_type(res), ==, QTYPE_QDICT); + + dst =qobject_to_qdict (res); + + g_assert_cmpint(qdict_size(dst), ==, 2); + + child =qdict_get (dst,"vnc" ); + g_assert_cmpint(qobject_type(child), ==, QTYPE_QDICT); + vnc =qdict_get_qdict (dst,"vnc" ); + + g_assert_cmpint(qdict_size(vnc), ==, 2); + + g_assert_cmpstr("127.0.0.1", ==, qdict_get_str(vnc, "listen.addr")); + g_assert_cmpstr("5901", ==, qdict_get_str(vnc, "listen.port")); + + child =qdict_get (dst,"rule" ); + g_assert_cmpint(qobject_type(child), ==, QTYPE_QDICT); + rules =qdict_get_qdict (dst,"rule" ); + + g_assert_cmpint(qdict_size(rules), ==, 4); + + g_assert_cmpstr("fred", ==, qdict_get_str(rules, "0.match")); + g_assert_cmpstr("allow", ==, qdict_get_str(rules, "0.policy")); + g_assert_cmpstr("bob", ==, qdict_get_str(rules, "1.match")); + g_assert_cmpstr("deny", ==, qdict_get_str(rules, "1.policy")); + +QDECREF (src); +QDECREF (dst); +} + + +static void qdict_crumple_test_listtop (void ) +{ +QDict *src, *rule; +QList *rules; +QObject *res; + + src =qdict_new (); +qdict_put (src,"0.match.name" ,qstring_from_str ("Fred" )); +qdict_put (src,"0.match.email" ,qstring_from_str ("[email protected]" )); +qdict_put (src,"0.policy" ,qstring_from_str ("allow" )); +qdict_put (src,"1.match.name" ,qstring_from_str ("Bob" )); +qdict_put (src,"1.match.email" ,qstring_from_str ("[email protected]" )); +qdict_put (src,"1.policy" ,qstring_from_str ("deny" )); + + res =qdict_crumple (src, false, &error_abort); + + g_assert_cmpint(qobject_type(res), ==, QTYPE_QLIST); + + rules =qobject_to_qlist (res); + + g_assert_cmpint(qlist_size(rules), ==, 2); + + g_assert_cmpint(qobject_type(qlist_peek(rules)), ==, QTYPE_QDICT); + rule =qobject_to_qdict (qlist_pop (rules)); + g_assert_cmpint(qdict_size(rule), ==, 3); + + g_assert_cmpstr("Fred", ==, qdict_get_str(rule, "match.name")); + g_assert_cmpstr("[email protected]", ==, qdict_get_str(rule, "match.email")); + g_assert_cmpstr("allow", ==, qdict_get_str(rule, "policy")); +QDECREF (rule); + + g_assert_cmpint(qobject_type(qlist_peek(rules)), ==, QTYPE_QDICT); + rule =qobject_to_qdict (qlist_pop (rules)); + g_assert_cmpint(qdict_size(rule), ==, 3); + + g_assert_cmpstr("Bob", ==, qdict_get_str(rule, "match.name")); + g_assert_cmpstr("[email protected]", ==, qdict_get_str(rule, "match.email")); + g_assert_cmpstr("deny", ==, qdict_get_str(rule, "policy")); +QDECREF (rule); + +QDECREF (src); +qobject_decref (res); +} + + +static void qdict_crumple_test_recursive (void ) +{ +QDict *src, *dst, *rule, *vnc, *acl, *listen; +QObject *child, *res; +QList *rules; + + src =qdict_new (); +qdict_put (src,"vnc.listen.addr" ,qstring_from_str ("127.0.0.1" )); +qdict_put (src,"vnc.listen.port" ,qstring_from_str ("5901" )); +qdict_put (src,"vnc.acl.rules.0.match" ,qstring_from_str ("fred" )); +qdict_put (src,"vnc.acl.rules.0.policy" ,qstring_from_str ("allow" )); +qdict_put (src,"vnc.acl.rules.1.match" ,qstring_from_str ("bob" )); +qdict_put (src,"vnc.acl.rules.1.policy" ,qstring_from_str ("deny" )); +qdict_put (src,"vnc.acl.default" ,qstring_from_str ("deny" )); + + res =qdict_crumple (src, true, &error_abort); + + g_assert_cmpint(qobject_type(res), ==, QTYPE_QDICT); + + dst =qobject_to_qdict (res); + + g_assert_cmpint(qdict_size(dst), ==, 1); + + child =qdict_get (dst,"vnc" ); + g_assert_cmpint(qobject_type(child), ==, QTYPE_QDICT); + vnc =qobject_to_qdict (child); + + child =qdict_get (vnc,"listen" ); + g_assert_cmpint(qobject_type(child), ==, QTYPE_QDICT); + listen =qobject_to_qdict (child); + g_assert_cmpstr("127.0.0.1", ==, qdict_get_str(listen, "addr")); + g_assert_cmpstr("5901", ==, qdict_get_str(listen, "port")); + + child =qdict_get (vnc,"acl" ); + g_assert_cmpint(qobject_type(child), ==, QTYPE_QDICT); + acl =qobject_to_qdict (child); + + child =qdict_get (acl,"rules" ); + g_assert_cmpint(qobject_type(child), ==, QTYPE_QLIST); + rules =qobject_to_qlist (child); + g_assert_cmpint(qlist_size(rules), ==, 2); + + rule =qobject_to_qdict (qlist_pop (rules)); + g_assert_cmpint(qdict_size(rule), ==, 2); + g_assert_cmpstr("fred", ==, qdict_get_str(rule, "match")); + g_assert_cmpstr("allow", ==, qdict_get_str(rule, "policy")); +QDECREF (rule); + + rule =qobject_to_qdict (qlist_pop (rules)); + g_assert_cmpint(qdict_size(rule), ==, 2); + g_assert_cmpstr("bob", ==, qdict_get_str(rule, "match")); + g_assert_cmpstr("deny", ==, qdict_get_str(rule, "policy")); +QDECREF (rule); + +QDECREF (src); +QDECREF (dst); +} + + +static void qdict_crumple_test_empty (void ) +{ +QDict *src, *dst; + + src =qdict_new (); + + dst = (QDict *)qdict_crumple (src, true, &error_abort); + + g_assert_cmpint(qdict_size(dst), ==, 0); + +QDECREF (src); +QDECREF (dst); +} + + +static void qdict_crumple_test_bad_inputs (void ) +{ +QDict *src; +Error *error =NULL ; + + src =qdict_new (); +/* rule.0 can't be both a string and a dict */ +qdict_put (src,"rule.0" ,qstring_from_str ("fred" )); +qdict_put (src,"rule.0.policy" ,qstring_from_str ("allow" )); + +g_assert (qdict_crumple (src, true, &error) ==NULL ); +g_assert (error !=NULL ); +error_free (error); + error =NULL ; +QDECREF (src); + + src =qdict_new (); +/* rule can't be both a list and a dict */ +qdict_put (src,"rule.0" ,qstring_from_str ("fred" )); +qdict_put (src,"rule.a" ,qstring_from_str ("allow" )); + +g_assert (qdict_crumple (src, true, &error) ==NULL ); +g_assert (error !=NULL ); +error_free (error); + error =NULL ; +QDECREF (src); + + src =qdict_new (); +/* The input should be flat, ie no dicts or lists */ +qdict_put (src,"rule.a" ,qdict_new ()); +qdict_put (src,"rule.b" ,qstring_from_str ("allow" )); + +g_assert (qdict_crumple (src, true, &error) ==NULL ); +g_assert (error !=NULL ); +error_free (error); + error =NULL ; +QDECREF (src); + + + src =qdict_new (); +/* List indexes must not have gaps */ +qdict_put (src,"rule.0" ,qdict_new ()); +qdict_put (src,"rule.3" ,qstring_from_str ("allow" )); + +g_assert (qdict_crumple (src, true, &error) ==NULL ); +g_assert (error !=NULL ); +error_free (error); + error =NULL ; +QDECREF (src); + + + src =qdict_new (); +/* List indexes must be in %zu format */ +qdict_put (src,"rule.0" ,qdict_new ()); +qdict_put (src,"rule.+1" ,qstring_from_str ("allow" )); + +g_assert (qdict_crumple (src, true, &error) ==NULL ); +g_assert (error !=NULL ); +error_free (error); + error =NULL ; +QDECREF (src); +} +/* * Errors test-cases */ @@ -742,6 +972,17 @@ int main(int argc, char **argv)g_test_add_func ("/errors/put_exists" , qdict_put_exists_test);g_test_add_func ("/errors/get_not_exists" , qdict_get_not_exists_test); +g_test_add_func ("/public/crumple/nonrecursive" , + qdict_crumple_test_nonrecursive); +g_test_add_func ("/public/crumple/recursive" , + qdict_crumple_test_recursive); +g_test_add_func ("/public/crumple/listtop" , + qdict_crumple_test_listtop); +g_test_add_func ("/public/crumple/empty" , + qdict_crumple_test_empty); +g_test_add_func ("/public/crumple/bad_inputs" , + qdict_crumple_test_bad_inputs); +/* The Big one */ if (g_test_slow ()) {g_test_add_func ("/stress/test" , qdict_stress_test); --
Quoted 3 lines
2.5.5
Signature · 1 line
Marc-André Lureau
Re: [Qemu-devel] [PATCH v6 2/7] option: make parse_option_bool/number non-static
In reply to Daniel P. BerrangeHi
Quoted 119 lines · Daniel P. Berrange
The
opts-visitor.copts_type_bool()method has code for parsing a string to set a bool value, as does theqemu-option.cparse_option_bool()method, except it handles fewer cases.To enable consistency across the codebase, extend
parse_option_bool()to handle "yes", "no", "y" and "n", and make it non-static. Convert the opts visitor to call this method directly.Also make
parse_option_number()non-static to allow for similar reuse later.Signed-off-by Daniel P. Berrange <[email protected]>--- include/qemu/option.h | 4 ++++ qapi/opts-visitor.c | 19 +------------------ util/qemu-option.c | 27 ++++++++++++++++----------- 3 files changed, 21 insertions(+), 29 deletions(-)include/qemu/option.h +4
-0@@ -37,6 +37,10 @@ int get_param_value(char *buf, int buf_size, const char *tag, const char *str); +void parse_option_bool (const char *name,const char *value,bool *ret, +Error **errp); +void parse_option_number (const char *name,const char *value, +uint64_t *ret,Error **errp);void parse_option_size (const char *name,const char *value,uint64_t *ret,Error **errp);bool has_help_option (const char *param);qapi/opts-visitor.c +1
-18@@ -334,7 +334,6 @@ opts_type_str(Visitor *v, const char *name, char **obj, Error **errp) } -/* mimics qemu-option.c::parse_option_bool() */ static void opts_type_bool (Visitor *v,const char *name,bool *obj,Error **errp) {@@ -346,23 +345,7 @@ opts_type_bool(Visitor *v, const char *name, bool *obj, Error **errp)return ; } -if (opt->str) { -if (strcmp (opt->str,"on" ) ==0 || -strcmp (opt->str,"yes" ) ==0 || -strcmp (opt->str,"y" ) ==0 ) { - *obj = true; - }else if (strcmp (opt->str,"off" ) ==0 || -strcmp (opt->str,"no" ) ==0 || -strcmp (opt->str,"n" ) ==0 ) { - *obj = false; - }else { -error_setg (errp,QERR_INVALID_PARAMETER_VALUE , opt->name, -"on|yes|y|off|no|n" ); -return ; - } - }else { - *obj = true; - } +parse_option_bool (opt->name, opt->str, obj, errp);processed (ov, name); }util/qemu-option.c +16
-12@@ -125,25 +125,30 @@ int get_param_value(char *buf, int buf_size,return get_next_param_value (buf, buf_size, tag, &str); } -static void parse_option_bool (const char *name,const char *value,bool *ret, -Error **errp) +void parse_option_bool (const char *name,const char *value,bool *ret, +Error **errp) {if (value !=NULL ) { -if (!strcmp (value,"on" )) { - *ret =1 ; - }else if (!strcmp (value,"off" )) { - *ret =0 ; +if (strcmp (value,"on" ) ==0 || +strcmp (value,"yes" ) ==0 || +strcmp (value,"y" ) ==0 ) { + *ret = true; + }else if (strcmp (value,"off" ) ==0 || +strcmp (value,"no" ) ==0 || +strcmp (value,"n" ) ==0 ) { + *ret = false; }else { -error_setg (errp,QERR_INVALID_PARAMETER_VALUE , - name,"'on' or 'off'" ); +error_setg (errp,QERR_INVALID_PARAMETER_VALUE , name, +"on|yes|y|off|no|n" ); +return ; } }else { - *ret =1 ; + *ret = true; } } -static void parse_option_number (const char *name,const char *value, -uint64_t *ret,Error **errp) +void parse_option_number (const char *name,const char *value, +uint64_t *ret,Error **errp) {char *postfix;uint64_t number; --
Quoted 3 lines
2.5.5
Signature · 1 line
Marc-André Lureau
Re: [Qemu-devel] [PATCH v6 3/7] qapi: add a QmpInputVisitor that does string conversion
In reply to Daniel P. BerrangeHi
Quoted 45 lines · Daniel P. Berrange
Currently the QmpInputVisitor assumes that all scalar values are directly represented as their final types. ie it assumes an 'int' is using QInt, and a 'bool' is using QBool.
This adds an alternative constructor for QmpInputVisitor that will set it up such that it expects a QString for all scalar types instead.
This makes it possible to use QmpInputVisitor with a QDict produced from QemuOpts, where everything is in string format.
Signed-off-by Daniel P. Berrange <[email protected]>--- include/qapi/qmp-input-visitor.h | 42 ++++++++++++-- qapi/qmp-input-visitor.c | 80 ++++++++++++++++++++++++++ tests/test-qmp-input-visitor.c | 119 ++++++++++++++++++++++++++++++++++++++- 3 files changed, 234 insertions(+), 7 deletions(-)include/qapi/qmp-input-visitor.h +12
-4@@ -19,14 +19,48 @@typedef struct QmpInputVisitor QmpInputVisitor ; -/* -* Return a new input visitor that converts QMP to QAPI. +/** +* qmp_input_visitor_new: +* @obj: the input object to visit +* @strict: whether to require that all input keys are consumed +* +* Create a new input visitor that converts QMP to QAPI. +* +* Any scalar values in the @obj input data structure should be in the +* required type already. ie if visiting a bool, the value should +* already be a QBool instance. * -* Set @strict to reject a parse that doesn't consume all keys of a -* dictionary; otherwise excess input is ignored. +* If @strict is set to true, then an error will be reported if any +* dict keys are not consumed during visitation.
include/qapi/qmp-input-visitor.h line 44
Quoted 10 lines
include/qapi/qmp-input-visitor.h +7
-0+* +* The returned input visitor should be released by calling +* qmp_input_visitor_cleanup when no longer required. +* +* Returns: a new input visitor */ QmpInputVisitor *qmp_input_visitor_new (QObject *obj,bool strict); +/** +* qmp_input_visitor_new:
qmp_string_input_visitor_new
Quoted 111 lines
include/qapi/qmp-input-visitor.h +19
-0+* @obj: the input object to visit +* @strict: whether to require that all input keys are consumed +* +* Create a new input visitor that converts QMP to QAPI. +* +* Any scalar values in the @obj input data structure should always be +* represented as strings. ie if visiting a boolean, the value should +* be a QString whose contents represent a valid boolean. +* +* If @strict is set to true, then an error will be reported if any +* dict keys are not consumed during visitation. +* +* The returned input visitor should be released by calling +* qmp_input_visitor_cleanup when no longer required. +* +* Returns: a new input visitor +*/ +QmpInputVisitor *qmp_string_input_visitor_new (QObject *obj,bool strict); +void qmp_input_visitor_cleanup (QmpInputVisitor *v);Visitor *qmp_input_get_visitor (QmpInputVisitor *v);qapi/qmp-input-visitor.c +49
-0@@ -20,6 +20,7 @@#include "qemu-common.h" #include "qapi/qmp/types.h" #include "qapi/qmp/qerror.h" +#include "qemu/cutils.h" #define QIV_STACK_SIZE 1024@@ -265,6 +266,17 @@ static void qmp_input_type_int64(Visitor *v, const char *name, int64_t *obj, *obj =qint_get_int (qint); } +static void qmp_input_type_int64_str (Visitor *v,const char *name,int64_t *obj, +Error **errp) +{ +QmpInputVisitor *qiv =to_qiv (v); +QString *qstr =qobject_to_qstring (qmp_input_get_object (qiv, name, true)); +uint64_t ret; + +parse_option_number (name, qstr ? qstr->string :NULL , &ret, errp); + *obj = ret; +} +static void qmp_input_type_uint64 (Visitor *v,const char *name,uint64_t *obj,Error **errp) {@@ -281,6 +293,15 @@ static void qmp_input_type_uint64(Visitor *v, const char *name, uint64_t *obj, *obj =qint_get_int (qint); } +static void qmp_input_type_uint64_str (Visitor *v,const char *name, +uint64_t *obj,Error **errp) +{ +QmpInputVisitor *qiv =to_qiv (v); +QString *qstr =qobject_to_qstring (qmp_input_get_object (qiv, name, true)); + +parse_option_number (name, qstr ? qstr->string :NULL , obj, errp); +} +static void qmp_input_type_bool (Visitor *v,const char *name,bool *obj,Error **errp) {@@ -296,6 +317,15 @@ static void qmp_input_type_bool(Visitor *v, const char *name, bool *obj, *obj =qbool_get_bool (qbool); } +static void qmp_input_type_bool_str (Visitor *v,const char *name,bool *obj, +Error **errp) +{ +QmpInputVisitor *qiv =to_qiv (v); +QString *qstr =qobject_to_qstring (qmp_input_get_object (qiv, name, true)); + +parse_option_bool (name, qstr ? qstr->string :NULL , obj, errp); +} +static void qmp_input_type_str (Visitor *v,const char *name,char **obj,Error **errp) {@@ -336,6 +366,25 @@ static void qmp_input_type_number(Visitor *v, const char *name, double *obj, "number"); } +static void qmp_input_type_number_str (Visitor *v,const char *name,double *obj, +Error **errp) +{ +QmpInputVisitor *qiv =to_qiv (v); +QString *qstr =qobject_to_qstring (qmp_input_get_object (qiv, name, true)); +char *endp; + +if (qstr && qstr->string) { + errno =0 ; + *obj =strtod (qstr->string, &endp); +if (errno ==0 && endp != qstr->string && *endp =='\0' ) { +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) {
qapi/qmp-input-visitor.c QmpInputVisitor *qmp_input_visitor_new(QObject *obj, bool strict) · line 463
Quoted 5 lines
qapi/qmp-input-visitor.c +2
-0@@ -410,3 +459,34 @@ QmpInputVisitor *qmp_input_visitor_new(QObject *obj, bool strict)return v; } + +
why 2 lines?
Quoted 220 lines
qapi/qmp-input-visitor.c +29
-0+QmpInputVisitor *qmp_string_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_str; + v->visitor.type_uint64 = qmp_input_type_uint64_str; + v->visitor.type_bool = qmp_input_type_bool_str; + v->visitor.type_str = qmp_input_type_str; + v->visitor.type_number = qmp_input_type_number_str; + 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; +}tests/test-qmp-input-visitor.c +116
-4@@ -40,6 +40,7 @@ static void visitor_input_teardown(TestInputVisitorData *data,function so that the JSON string used by the tests are kept in the test functions (and not in main()). */ static Visitor *visitor_input_test_init_internal (TestInputVisitorData *data, +bool strict,bool autocast,const char *json_string,va_list *ap) {@@ -50,7 +51,11 @@ static Visitor *visitor_input_test_init_internal(TestInputVisitorData *data, data->obj =qobject_from_jsonv (json_string, ap);g_assert (data->obj); - data->qiv =qmp_input_visitor_new (data->obj, false); +if (autocast) { + data->qiv =qmp_string_input_visitor_new (data->obj, strict); + }else { + data->qiv =qmp_input_visitor_new (data->obj, strict); + }g_assert (data->qiv); v =qmp_input_get_visitor (data->qiv);@@ -59,6 +64,21 @@ static Visitor *visitor_input_test_init_internal(TestInputVisitorData *data,return v; } +static GCC_FMT_ATTR(4, 5) +Visitor *visitor_input_test_init_full (TestInputVisitorData *data, +bool strict,bool autocast, +const char *json_string, ...) +{ +Visitor *v; +va_list ap; + +va_start (ap, json_string); + v =visitor_input_test_init_internal (data, strict, autocast, + json_string, &ap); +va_end (ap); +return v; +} + static GCC_FMT_ATTR(2, 3) Visitor *visitor_input_test_init(TestInputVisitorData *data, const char *json_string, ...)@@ -67,7 +87,8 @@ Visitor *visitor_input_test_init(TestInputVisitorData *data,va_list ap;va_start (ap, json_string); - v =visitor_input_test_init_internal (data, json_string, &ap); + v =visitor_input_test_init_internal (data, false, false, + json_string, &ap);va_end (ap);return v; }@@ -82,7 +103,8 @@ Visitor *visitor_input_test_init(TestInputVisitorData *data,static Visitor *visitor_input_test_init_raw (TestInputVisitorData *data,const char *json_string) { -return visitor_input_test_init_internal (data, json_string,NULL ); +return visitor_input_test_init_internal (data, false, false, + json_string,NULL ); } static void test_visitor_in_int(TestInputVisitorData *data,@@ -114,6 +136,33 @@ static void test_visitor_in_int_overflow(TestInputVisitorData *data,error_free_or_abort (&err); } +static void test_visitor_in_int_autocast (TestInputVisitorData *data, +const void *unused) +{ +int64_t res =0 , value =-42 ; +Visitor *v; + + v =visitor_input_test_init_full (data, false, true, +"\"-42\"" ); + +visit_type_int (v,NULL , &res, &error_abort); + g_assert_cmpint(res, ==, value); +} + +static void test_visitor_in_int_noautocast (TestInputVisitorData *data, +const void *unused) +{ +int64_t res =0 ; +Visitor *v; +Error *err =NULL ; + + v =visitor_input_test_init (data,"\"-42\"" ); + +visit_type_int (v,NULL , &res, &err); +g_assert (err !=NULL ); +error_free (err); +} +static void test_visitor_in_bool (TestInputVisitorData *data,const void *unused) {@@ -126,6 +175,32 @@ static void test_visitor_in_bool(TestInputVisitorData *data, g_assert_cmpint(res, ==, true); } +static void test_visitor_in_bool_autocast (TestInputVisitorData *data, +const void *unused) +{ +bool res = false; +Visitor *v; + + v =visitor_input_test_init_full (data, false, true,"\"yes\"" ); + +visit_type_bool (v,NULL , &res, &error_abort); + g_assert_cmpint(res, ==, true); +} + +static void test_visitor_in_bool_noautocast (TestInputVisitorData *data, +const void *unused) +{ +bool res = false; +Visitor *v; +Error *err =NULL ; + + v =visitor_input_test_init (data,"\"true\"" ); + +visit_type_bool (v,NULL , &res, &err); +g_assert (err !=NULL ); +error_free (err); +} +static void test_visitor_in_number (TestInputVisitorData *data,const void *unused) {@@ -138,6 +213,32 @@ static void test_visitor_in_number(TestInputVisitorData *data, g_assert_cmpfloat(res, ==, value); } +static void test_visitor_in_number_autocast (TestInputVisitorData *data, +const void *unused) +{ +double res =0 , value =3.14 ; +Visitor *v; + + v =visitor_input_test_init_full (data, false, true,"\"3.14\"" ); + +visit_type_number (v,NULL , &res, &error_abort); + g_assert_cmpfloat(res, ==, value); +} + +static void test_visitor_in_number_noautocast (TestInputVisitorData *data, +const void *unused) +{ +double res =0 ; +Visitor *v; +Error *err =NULL ; + + v =visitor_input_test_init (data,"\"3.14\"" ); + +visit_type_number (v,NULL , &res, &err); +g_assert (err !=NULL ); +error_free (err); +} +static void test_visitor_in_string (TestInputVisitorData *data,const void *unused) {@@ -834,10 +935,22 @@ int main(int argc, char **argv) &in_visitor_data, test_visitor_in_int);input_visitor_test_add ("/visitor/input/int_overflow" , &in_visitor_data, test_visitor_in_int_overflow); +input_visitor_test_add ("/visitor/input/int_autocast" , + &in_visitor_data, test_visitor_in_int_autocast); +input_visitor_test_add ("/visitor/input/int_noautocast" , + &in_visitor_data, test_visitor_in_int_noautocast);input_visitor_test_add ("/visitor/input/bool" , &in_visitor_data, test_visitor_in_bool); +input_visitor_test_add ("/visitor/input/bool_autocast" , + &in_visitor_data, test_visitor_in_bool_autocast); +input_visitor_test_add ("/visitor/input/bool_noautocast" , + &in_visitor_data, test_visitor_in_bool_noautocast);input_visitor_test_add ("/visitor/input/number" , &in_visitor_data, test_visitor_in_number); +input_visitor_test_add ("/visitor/input/number_autocast" , + &in_visitor_data, test_visitor_in_number_autocast); +input_visitor_test_add ("/visitor/input/number_noautocast" , + &in_visitor_data, test_visitor_in_number_noautocast);input_visitor_test_add ("/visitor/input/string" , &in_visitor_data, test_visitor_in_string); input_visitor_test_add("/visitor/input/enum", --
Quoted 3 lines
2.5.5
looks good otherwise
Signature · 1 line
Marc-André Lureau
Re: [Qemu-devel] [PATCH v6 5/7] util: add QAuthZ object as an authorization base class
In reply to Daniel P. BerrangeHi
Quoted 160 lines · Daniel P. Berrange
The current
qemu_aclmodule provides a simple access control list facility inside QEMU, which is used via a set of monitor commandsacl_show,acl_policy,acl_add,acl_remove&acl_reset.Note there is no ability to create ACLs - the network services (eg VNC server) were expected to create ACLs that they want to check.
There is also no way to define ACLs on the command line, nor potentially integrate with external authorization systems like polkit, pam, ldap lookup, etc.
The QAuthZ object defines a minimal abstract QOM class that can be subclassed for creating different authorization providers.
Signed-off-by Daniel P. Berrange <[email protected]>--- MAINTAINERS | 7 +++++ Makefile | 1 + Makefile.objs | 2 ++ Makefile.target | 2 ++ include/qemu/authz.h | 89 ++++++++++++++++++++++++++++++++++++++++++++++++++++ util/Makefile.objs | 2 ++ util/authz.c | 46 +++++++++++++++++++++++++++ 7 files changed, 149 insertions(+) create mode 100644 include/qemu/authz.h create mode 100644 util/authz.cMAINTAINERS +7
-0@@ -1324,6 +1324,13 @@ F: include/qemu/throttle.h F: util/throttle.c L: [email protected] +Authorization +M: Daniel P. Berrange <[email protected]> +S: Maintained +F: util/authz* +F: include/qemu/authz* +F: tests/test-authz-* + Usermode Emulation ------------------ OverallMakefile +1
-0@@ -148,6 +148,7 @@ endif dummy := $(call unnest-vars,, \ stub-obj-y \ util-obj-y \ + util-qom-obj-y \ qga-obj-y \ ivshmem-client-obj-y \ ivshmem-server-obj-y \Makefile.objs +2
-0@@ -4,6 +4,8 @@ stub-obj-y = stubs/ crypto/ util-obj-y = util/ qobject/ qapi/ util-obj-y += qmp-introspect.o qapi-types.o qapi-visit.o qapi-event.o +util-qom-obj-y += util/ + ####################################################################### # block-obj-y is code used by both qemu system emulation and qemu-imgMakefile.target +2
-0@@ -176,6 +176,7 @@ include $(SRC_PATH)/Makefile.objs dummy := $(call unnest-vars,,target-obj-y) target-obj-y-save := $(target-obj-y) dummy := $(call unnest-vars,.., \ + util-qom-obj-y \ block-obj-y \ block-obj-m \ crypto-obj-y \@@ -188,6 +189,7 @@ target-obj-y := $(target-obj-y-save) all-obj-y += $(common-obj-y) all-obj-y += $(target-obj-y) all-obj-y += $(qom-obj-y) +all-obj-y += $(util-qom-obj-y) all-obj-$(CONFIG_SOFTMMU) += $(block-obj-y) all-obj-$(CONFIG_USER_ONLY) += $(crypto-aes-obj-y) all-obj-$(CONFIG_SOFTMMU) += $(crypto-obj-y)include/qemu/authz.h new file +63
-0@@ -0,0 +1,89 @@ +/* +* QEMU authorization framework +* +* Copyright (c) 2016 Red Hat, Inc. +* +* This library is free software; you can redistribute it and/or +* modify it under the terms of the GNU Lesser General Public +* License as published by the Free Software Foundation; either +* version 2 of the License, or (at your option) any later version. +* +* This library is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public +* License along with this library; if not, see <http://www.gnu.org/licenses/>. +* +*/ + +#ifndef QAUTHZ_H__ +#define QAUTHZ_H__ + +#include "qemu-common.h" +#include "qapi/error.h" +#include "qom/object.h" + + +#define TYPE_QAUTHZ "authz" + +#define QAUTHZ_CLASS (klass) \ + OBJECT_CLASS_CHECK(QAuthZClass, (klass), \ + TYPE_QAUTHZ) +#define QAUTHZ_GET_CLASS (obj) \ + OBJECT_GET_CLASS(QAuthZClass, (obj), \ + TYPE_QAUTHZ) +#define QAUTHZ (obj) \ + INTERFACE_CHECK(QAuthZ, (obj), \ + TYPE_QAUTHZ) + +typedef struct QAuthZ QAuthZ ; +typedef struct QAuthZClass QAuthZClass ; + +/** +* QAuthZ: +* +* The QAuthZ class defines an API contract to be used +* for providing an authorization driver for services +* with user identities. +*/ + +struct QAuthZ { +Object parent_obj; +}; + + +struct QAuthZClass { +ObjectClass parent_class; + +bool (*is_allowed)(QAuthZ *authz, +const char *identity, +Error **errp); +};
include/qemu/authz.h line 73
Quoted 10 lines
include/qemu/authz.h new file +10
-0+ + +/** +* qauthz_is_allowed: +* @authz: the authorization object +* @identity: the user identity to authorize +* @errp: pointer to a NULL initialized error object +* +* Check if a user @identity is authorized. If an error +* occurrs this method will return false to indicate
occurs
Quoted 59 lines
include/qemu/authz.h new file +16
-0+* denial, as well as setting @errp to contain the details. +* Callers are recommended to treat the denial and error +* scenarios identically. Specifically the error info in +* @errp should never be fed back to the user being +* authorized, it is merely for benefit of administrator +* debugging. +* +* Returns: true if @identity is authorized, false if denied or if +* an error occurred. +*/ +bool qauthz_is_allowed (QAuthZ *authz, +const char *identity, +Error **errp); + +#endif /* QAUTHZ_H__ */ +util/Makefile.objs +2
-0@@ -34,3 +34,5 @@ util-obj-y += base64.o util-obj-y += log.o util-obj-y += qdist.o util-obj-y += qht.o + +util-qom-obj-y += authz.outil/authz.c new file +27
-0@@ -0,0 +1,46 @@ +/* +* QEMU authorization framework +* +* Copyright (c) 2016 Red Hat, Inc. +* +* This library is free software; you can redistribute it and/or +* modify it under the terms of the GNU Lesser General Public +* License as published by the Free Software Foundation; either +* version 2 of the License, or (at your option) any later version. +* +* This library is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public +* License along with this library; if not, see <http://www.gnu.org/licenses/>. +* +*/ + +#include "qemu/osdep.h" +#include "qemu/authz.h" + +bool qauthz_is_allowed (QAuthZ *authz, +const char *identity, +Error **errp) +{
util/authz.c line 37
Quoted 10 lines
util/authz.c new file +10
-0+QAuthZClass *cls =QAUTHZ_GET_CLASS (authz); + +return cls->is_allowed (authz, identity, errp); +} + +static const TypeInfo authz_info = { + .parent =TYPE_OBJECT , + .name =TYPE_QAUTHZ , + .instance_size =sizeof (QAuthZ), + .class_size =sizeof (QAuthZClass),
.abstract = true? (perhaps it's not necessary, but that would be more clear)
Quoted 13 lines
util/authz.c new file +9
-1+}; + +static void qauthz_register_types (void ) +{ +type_register_static (&authz_info); +} + +type_init (qauthz_register_types) + --2.5.5
Signature · 1 line
Marc-André Lureau
Re: [Qemu-devel] [PATCH v6 6/7] util: add QAuthZSimple object type for a simple access control list
In reply to Daniel P. BerrangeQuoted 223 lines · Daniel P. Berrange
Add a QAuthZSimple object type that implements the QAuthZ interface. This simple built-in implementation maintains a trivial access control list with a sequence of match rules and a final default policy. This replicates the functionality currently provided by the
qemu_aclmodule.To create an instance of this object via the QMP monitor, the syntax used would be
{ "execute": "object-add", "arguments": { "qom-type": "authz-simple", "id": "auth0", "parameters": { "rules": [ { "match": "fred", "policy": "allow", "format": "exact" }, { "match": "bob", "policy": "allow", "format": "exact" }, { "match": "danb", "policy": "deny", "format": "glob" }, { "match": "dan*", "policy": "allow", "format": "exact" }, ], "policy": "deny" } } }Or via the -object command line
$QEMU \ -object authz-simple,id=acl0,policy=deny,\ rules.0.match=fred,rules.0.policy=allow,rules.0.format=exact,\ rules.1.match=bob,rules.1.policy=allow,rules.1.format=exact,\ rules.2.match=danb,rules.2.policy=deny,rules.2.format=glob,\ rules.3.match=dan\*,rules.3.policy=allow,rules.3.format=exactThis sets up an authorization rule that allows 'fred', 'bob' and anyone whose name starts with 'dan', except for 'danb'. Everyone unmatched is denied.
Signed-off-by Daniel P. Berrange <[email protected]>--- Makefile | 2 +- include/qemu/authz-simple.h | 115 ++++++++++++++++ qapi-schema.json | 6 +- qapi/util.json | 47 +++++++ tests/.gitignore | 1 + tests/Makefile.include | 3 + tests/test-authz-simple.c | 172 ++++++++++++++++++++++++ util/Makefile.objs | 1 + util/authz-simple.c | 314 ++++++++++++++++++++++++++++++++++++++++++++ 9 files changed, 659 insertions(+), 2 deletions(-) create mode 100644 include/qemu/authz-simple.h create mode 100644 qapi/util.json create mode 100644 tests/test-authz-simple.c create mode 100644 util/authz-simple.cMakefile +1
-1@@ -292,7 +292,7 @@ qapi-modules = $(SRC_PATH)/qapi-schema.json $(SRC_PATH)/qapi/common.json \ $(SRC_PATH)/qapi/block.json $(SRC_PATH)/qapi/block-core.json \ $(SRC_PATH)/qapi/event.json $(SRC_PATH)/qapi/introspect.json \ $(SRC_PATH)/qapi/crypto.json $(SRC_PATH)/qapi/rocker.json \ - $(SRC_PATH)/qapi/trace.json + $(SRC_PATH)/qapi/trace.json $(SRC_PATH)/qapi/util.json qapi-types.c qapi-types.h :\ $(qapi-modules) $(SRC_PATH)/scripts/qapi-types.py $(qapi-py)include/qemu/authz-simple.h new file +115
-0@@ -0,0 +1,115 @@ +/* +* QEMU simple authorization driver +* +* Copyright (c) 2016 Red Hat, Inc. +* +* This library is free software; you can redistribute it and/or +* modify it under the terms of the GNU Lesser General Public +* License as published by the Free Software Foundation; either +* version 2 of the License, or (at your option) any later version. +* +* This library is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public +* License along with this library; if not, see <http://www.gnu.org/licenses/>. +* +*/ + +#ifndef QAUTHZ_SIMPLE_H__ +#define QAUTHZ_SIMPLE_H__ + +#include "qemu/authz.h" + + +#define TYPE_QAUTHZ_SIMPLE "authz-simple" + +#define QAUTHZ_SIMPLE_CLASS (klass) \ + OBJECT_CLASS_CHECK(QAuthZSimpleClass, (klass), \ + TYPE_QAUTHZ_SIMPLE) +#define QAUTHZ_SIMPLE_GET_CLASS (obj) \ + OBJECT_GET_CLASS(QAuthZSimpleClass, (obj), \ + TYPE_QAUTHZ_SIMPLE) +#define QAUTHZ_SIMPLE (obj) \ + INTERFACE_CHECK(QAuthZSimple, (obj), \ + TYPE_QAUTHZ_SIMPLE) + +typedef struct QAuthZSimple QAuthZSimple ; +typedef struct QAuthZSimpleClass QAuthZSimpleClass ; + + +/** +* QAuthZSimple: +* +* This authorization driver provides a simple mechanism +* for granting access by matching user names against a +* list of globs. Each match rule has an associated policy +* and a catch all policy applies if no rule matches +* +* To create an instance of this class via QMP: +* +* { +* "execute": "object-add", +* "arguments": { +* "qom-type": "authz-simple", +* "id": "auth0", +* "parameters": { +* "rules": [ +* { "match": "fred", "policy": "allow", "format": "exact" }, +* { "match": "bob", "policy": "allow", "format": "exact" }, +* { "match": "danb", "policy": "deny", "format": "exact" }, +* { "match": "dan*", "policy": "allow", "format": "glob" } +* ], +* "policy": "deny" +* } +* } +* } +* +* Or via the CLI: +* +* $QEMU \ +* -object authz-simple,id=acl0,policy=deny, \ +* match.0.name=fred,match.0.policy=allow,format=exact, \ +* match.1.name=bob,match.1.policy=allow,format=exact, \ +* match.2.name=danb,match.2.policy=deny,format=exact, \ +* match.3.name=dan\*,match.3.policy=allow,format=exact +* +*/ +struct QAuthZSimple { +QAuthZ parent_obj; + +QAuthZSimplePolicy policy; +QAuthZSimpleRuleList *rules; +}; + + +struct QAuthZSimpleClass { +QAuthZClass parent_class; +}; + + +QAuthZSimple *qauthz_simple_new (const char *id, +QAuthZSimplePolicy policy, +Error **errp); + +ssize_t qauthz_simple_append_rule (QAuthZSimple *auth, +const char *match, +QAuthZSimplePolicy policy, +QAuthZSimpleFormat format, +Error **errp); + +ssize_t qauthz_simple_insert_rule (QAuthZSimple *auth, +const char *match, +QAuthZSimplePolicy policy, +QAuthZSimpleFormat format, +size_t index, +Error **errp); + +ssize_t qauthz_simple_delete_rule (QAuthZSimple *auth, +const char *match); + + +#endif /* QAUTHZ_SIMPLE_H__ */ +qapi-schema.json +5
-1@@ -5,6 +5,9 @@ # QAPI common definitions { 'include': 'qapi/common.json' } +# QAPI util definitions +{ 'include': 'qapi/util.json' } + # QAPI crypto definitions { 'include': 'qapi/crypto.json' }@@ -3729,7 +3732,8 @@ # Since 2.5 ## { 'struct': 'DummyForceArrays', - 'data': { 'unused': ['X86CPUFeatureWordInfo'] } } + 'data': { 'unused1': ['X86CPUFeatureWordInfo'], + 'unused2': ['QAuthZSimpleRule'] } } ##qapi/util.json new file +3
-0@@ -0,0 +1,47 @@ +# -*- Mode: Python -*- +# +# QAPI util definitions
qapi/util.json line 13
Quoted 10 lines
qapi/util.json new file +10
-0+ +## +# QAuthZSimplePolicy: +# +# The authorization policy result +# +# @deny: deny access +# @allow: allow access +# +# Since: 2.6
now 2.7 (and the rest of the file)
Quoted 17 lines
qapi/util.json new file +17
-0+## +{ 'enum': 'QAuthZSimplePolicy', + 'prefix': 'QAUTHZ_SIMPLE_POLICY', + 'data': ['deny', 'allow']} + +## +# QAuthZSimpleFormat: +# +# The authorization policy result +# +# @exact: an exact string match +# @glob: string with ? and * shell wildcard support +# +# Since: 2.6 +## +{ 'enum': 'QAuthZSimpleFormat', + 'prefix': 'QAUTHZ_SIMPLE_FORMAT',
qapi/util.json line 40
Quoted 10 lines
qapi/util.json new file +10
-0+ 'data': ['exact', 'glob']} + +## +# QAuthZSimpleRule: +# +# A single authorization rule. +# +# @match: a glob to match against a user identity +# @policy: the result to return if @match evaluates to true +# @format: (optional) the format ofthe @match rule (default 'exact')
"of the" (missing space)
Quoted 548 lines
qapi/util.json new file +7
-0+# +# Since: 2.6 +## +{ 'struct': 'QAuthZSimpleRule', + 'data': {'match': 'str', + 'policy': 'QAuthZSimplePolicy', + '*format': 'QAuthZSimpleFormat'}}tests/.gitignore +1
-0@@ -10,6 +10,7 @@ check-qom-proplist qht-bench rcutorture test-aio +test-authz-simple test-base64 test-bitops test-blockjob-txntests/Makefile.include +3
-0@@ -109,6 +109,7 @@ check-unit-y += tests/test-crypto-xts$(EXESUF) check-unit-y += tests/test-crypto-block$(EXESUF) gcov-files-test-logging-y = tests/test-logging.c check-unit-y += tests/test-logging$(EXESUF) +check-unit-y += tests/test-authz-simple$(EXESUF) check-block-$(CONFIG_POSIX) += tests/qemu-iotests-quick.sh@@ -460,6 +461,8 @@ tests/test-timed-average$(EXESUF): tests/test-timed-average.o qemu-timer.o \ $(test-util-obj-y) tests/test-base64$(EXESUF): tests/test-base64.o \ libqemuutil.a libqemustub.a +tests/test-authz-simple$(EXESUF): tests/test-authz-simple.o \ + libqemuutil.a libqemustub.a $(util-qom-obj-y) $(qom-obj-y) tests/test-logging$(EXESUF): tests/test-logging.o $(test-util-obj-y)tests/test-authz-simple.c new file +172
-0@@ -0,0 +1,172 @@ +/* +* QEMU simple authorization object +* +* Copyright (c) 2016 Red Hat, Inc. +* +* This library is free software; you can redistribute it and/or +* modify it under the terms of the GNU Lesser General Public +* License as published by the Free Software Foundation; either +* version 2 of the License, or (at your option) any later version. +* +* This library is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public +* License along with this library; if not, see <http://www.gnu.org/licenses/>. +* +*/ + +#include "qemu/osdep.h" +#include <glib.h> + +#include "qemu/authz-simple.h" + +static void test_authz_default_deny (void ) +{ +QAuthZSimple *auth =qauthz_simple_new ("auth0" , +QAUTHZ_SIMPLE_POLICY_DENY , + &error_abort); + +g_assert (!qauthz_is_allowed (QAUTHZ (auth),"fred" , &error_abort)); + +object_unparent (OBJECT (auth)); +} + +static void test_authz_default_allow (void ) +{ +QAuthZSimple *auth =qauthz_simple_new ("auth0" , +QAUTHZ_SIMPLE_POLICY_ALLOW , + &error_abort); + +g_assert (qauthz_is_allowed (QAUTHZ (auth),"fred" , &error_abort)); + +object_unparent (OBJECT (auth)); +} + +static void test_authz_explicit_deny (void ) +{ +QAuthZSimple *auth =qauthz_simple_new ("auth0" , +QAUTHZ_SIMPLE_POLICY_ALLOW , + &error_abort); + +qauthz_simple_append_rule (auth,"fred" ,QAUTHZ_SIMPLE_POLICY_DENY , +QAUTHZ_SIMPLE_FORMAT_EXACT , &error_abort); + +g_assert (!qauthz_is_allowed (QAUTHZ (auth),"fred" , &error_abort)); + +object_unparent (OBJECT (auth)); +} + +static void test_authz_explicit_allow (void ) +{ +QAuthZSimple *auth =qauthz_simple_new ("auth0" , +QAUTHZ_SIMPLE_POLICY_DENY , + &error_abort); + +qauthz_simple_append_rule (auth,"fred" ,QAUTHZ_SIMPLE_POLICY_ALLOW , +QAUTHZ_SIMPLE_FORMAT_EXACT , &error_abort); + +g_assert (qauthz_is_allowed (QAUTHZ (auth),"fred" , &error_abort)); + +object_unparent (OBJECT (auth)); +} + + +static void test_authz_complex (void ) +{ +#ifndef CONFIG_FNMATCH +Error *local_err =NULL ; +#endif +QAuthZSimple *auth =qauthz_simple_new ("auth0" , +QAUTHZ_SIMPLE_POLICY_DENY , + &error_abort); + +qauthz_simple_append_rule (auth,"fred" ,QAUTHZ_SIMPLE_POLICY_ALLOW , +QAUTHZ_SIMPLE_FORMAT_EXACT , &error_abort); +qauthz_simple_append_rule (auth,"bob" ,QAUTHZ_SIMPLE_POLICY_ALLOW , +QAUTHZ_SIMPLE_FORMAT_EXACT , &error_abort); +qauthz_simple_append_rule (auth,"dan" ,QAUTHZ_SIMPLE_POLICY_DENY , +QAUTHZ_SIMPLE_FORMAT_EXACT , &error_abort); +#ifdef CONFIG_FNMATCH +qauthz_simple_append_rule (auth,"dan*" ,QAUTHZ_SIMPLE_POLICY_ALLOW , +QAUTHZ_SIMPLE_FORMAT_GLOB , &error_abort); + +g_assert (qauthz_is_allowed (QAUTHZ (auth),"fred" , &error_abort)); +g_assert (qauthz_is_allowed (QAUTHZ (auth),"bob" , &error_abort)); +g_assert (!qauthz_is_allowed (QAUTHZ (auth),"dan" , &error_abort)); +g_assert (qauthz_is_allowed (QAUTHZ (auth),"danb" , &error_abort)); +#else +g_assert (qauthz_simple_append_rule (auth,"dan*" , +QAUTHZ_SIMPLE_POLICY_ALLOW , +QAUTHZ_SIMPLE_FORMAT_GLOB , + &local_err) <0 ); +g_assert (local_err !=NULL ); +error_free (local_err); +#endif + +object_unparent (OBJECT (auth)); +} + +static void test_authz_add_remove (void ) +{ +QAuthZSimple *auth =qauthz_simple_new ("auth0" , +QAUTHZ_SIMPLE_POLICY_ALLOW , + &error_abort); + +g_assert_cmpint (qauthz_simple_append_rule (auth,"fred" , +QAUTHZ_SIMPLE_POLICY_ALLOW , +QAUTHZ_SIMPLE_FORMAT_EXACT , + &error_abort), + ==, 0); +g_assert_cmpint (qauthz_simple_append_rule (auth,"bob" , +QAUTHZ_SIMPLE_POLICY_ALLOW , +QAUTHZ_SIMPLE_FORMAT_EXACT , + &error_abort), + ==, 1); +g_assert_cmpint (qauthz_simple_append_rule (auth,"dan" , +QAUTHZ_SIMPLE_POLICY_DENY , +QAUTHZ_SIMPLE_FORMAT_EXACT , + &error_abort), + ==, 2); +g_assert_cmpint (qauthz_simple_append_rule (auth,"frank" , +QAUTHZ_SIMPLE_POLICY_DENY , +QAUTHZ_SIMPLE_FORMAT_EXACT , + &error_abort), + ==, 3); + +g_assert (!qauthz_is_allowed (QAUTHZ (auth),"dan" , &error_abort)); + +g_assert_cmpint (qauthz_simple_delete_rule (auth,"dan" ), + ==, 2); + +g_assert (qauthz_is_allowed (QAUTHZ (auth),"dan" , &error_abort)); + +g_assert_cmpint (qauthz_simple_insert_rule (auth,"dan" , +QAUTHZ_SIMPLE_POLICY_DENY , +QAUTHZ_SIMPLE_FORMAT_EXACT , +2 , + &error_abort), + ==, 2); + +g_assert (!qauthz_is_allowed (QAUTHZ (auth),"dan" , &error_abort)); + +object_unparent (OBJECT (auth)); +} + +int main (int argc,char **argv) +{ +g_test_init (&argc, &argv,NULL ); + +module_call_init (MODULE_INIT_QOM ); + +g_test_add_func ("/auth/simple/default/deny" , test_authz_default_deny); +g_test_add_func ("/auth/simple/default/allow" , test_authz_default_allow); +g_test_add_func ("/auth/simple/explicit/deny" , test_authz_explicit_deny); +g_test_add_func ("/auth/simple/explicit/allow" , test_authz_explicit_allow); +g_test_add_func ("/auth/simple/complex" , test_authz_complex); +g_test_add_func ("/auth/simple/add-remove" , test_authz_add_remove); + +return g_test_run (); +}util/Makefile.objs +1
-0@@ -36,3 +36,4 @@ util-obj-y += qdist.o util-obj-y += qht.o util-qom-obj-y += authz.o +util-qom-obj-y += authz-simple.outil/authz-simple.c new file +314
-1@@ -0,0 +1,314 @@ +/* +* QEMU simple authorization driver +* +* Copyright (c) 2016 Red Hat, Inc. +* +* This library is free software; you can redistribute it and/or +* modify it under the terms of the GNU Lesser General Public +* License as published by the Free Software Foundation; either +* version 2 of the License, or (at your option) any later version. +* +* This library is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public +* License along with this library; if not, see <http://www.gnu.org/licenses/>. +* +*/ + +#include "qemu/osdep.h" +#include "qemu/authz-simple.h" +#include "qom/object_interfaces.h" +#include "qapi-visit.h" + +#ifdef CONFIG_FNMATCH +#include <fnmatch.h> +#endif + +static bool qauthz_simple_is_allowed (QAuthZ *authz, +const char *identity, +Error **errp) +{ +QAuthZSimple *sauthz =QAUTHZ_SIMPLE (authz); +QAuthZSimpleRuleList *rules = sauthz->rules; + +while (rules) { +QAuthZSimpleRule *rule = rules->value; +QAuthZSimpleFormat format = rule->has_format ? rule->format : +QAUTHZ_SIMPLE_FORMAT_EXACT ; + +switch (format) { +case QAUTHZ_SIMPLE_FORMAT_EXACT : +if (strcmp (rule->match, identity) ==0 ) { +return rule->policy ==QAUTHZ_SIMPLE_POLICY_ALLOW ; + } +break ; +#ifdef CONFIG_FNMATCH +case QAUTHZ_SIMPLE_FORMAT_GLOB : +if (fnmatch (rule->match, identity,0 ) ==0 ) { +return rule->policy ==QAUTHZ_SIMPLE_POLICY_ALLOW ; + } +break ; +#else +return false; +#endif +default : +return false; + } + rules = rules->next; + } + +return sauthz->policy ==QAUTHZ_SIMPLE_POLICY_ALLOW ; +} + + +static void +qauthz_simple_prop_set_policy (Object *obj, +int value, + Error **errp G_GNUC_UNUSED) +{ +QAuthZSimple *sauthz =QAUTHZ_SIMPLE (obj); + + sauthz->policy = value; +} + + +static int +qauthz_simple_prop_get_policy (Object *obj, + Error **errp G_GNUC_UNUSED) +{ +QAuthZSimple *sauthz =QAUTHZ_SIMPLE (obj); + +return sauthz->policy; +} + + +static void +qauthz_simple_prop_get_rules (Object *obj,Visitor *v,const char *name, +void *opaque,Error **errp) +{ +QAuthZSimple *sauthz =QAUTHZ_SIMPLE (obj); + +visit_type_QAuthZSimpleRuleList (v, name, &sauthz->rules, errp); +} + +static void +qauthz_simple_prop_set_rules (Object *obj,Visitor *v,const char *name, +void *opaque,Error **errp) +{ +QAuthZSimple *sauthz =QAUTHZ_SIMPLE (obj); +QAuthZSimpleRuleList *oldrules; +#ifndef CONFIG_FNMATCH +QAuthZSimpleRuleList *rules; +#endif + + oldrules = sauthz->rules; +visit_type_QAuthZSimpleRuleList (v, name, &sauthz->rules, errp); + +#ifndef CONFIG_FNMATCH + rules = sauthz->rules; +while (rules) { +QAuthZSimpleRule *rule = rules->value; +if (rule->has_format && + rule->format ==QAUTHZ_SIMPLE_FORMAT_GLOB ) { +error_setg (errp,"Glob format not supported on this platform" ); +qapi_free_QAuthZSimpleRuleList (sauthz->rules); + sauthz->rules = oldrules; +return ; + } + } +#endif + +qapi_free_QAuthZSimpleRuleList (oldrules); +} + + +static void +qauthz_simple_complete (UserCreatable *uc,Error **errp) +{ +} + + +static void +qauthz_simple_finalize (Object *obj) +{ +QAuthZSimple *sauthz =QAUTHZ_SIMPLE (obj); + +qapi_free_QAuthZSimpleRuleList (sauthz->rules); +} + + +static void +qauthz_simple_class_init (ObjectClass *oc,void *data) +{ +UserCreatableClass *ucc =USER_CREATABLE_CLASS (oc); +QAuthZClass *authz =QAUTHZ_CLASS (oc); + + ucc->complete = qauthz_simple_complete; + authz->is_allowed = qauthz_simple_is_allowed; + +object_class_property_add_enum (oc,"policy" , +"QAuthZSimplePolicy" , + QAuthZSimplePolicy_lookup, + qauthz_simple_prop_get_policy, + qauthz_simple_prop_set_policy, +NULL ); + +object_class_property_add (oc,"rules" ,"QAuthZSimpleRule" , + qauthz_simple_prop_get_rules, + qauthz_simple_prop_set_rules, +NULL ,NULL ,NULL ); +} + + +QAuthZSimple *qauthz_simple_new (const char *id, +QAuthZSimplePolicy policy, +Error **errp) +{ +return QAUTHZ_SIMPLE ( +object_new_with_props (TYPE_QAUTHZ_SIMPLE , +object_get_objects_root (), + id, errp, +"policy" , QAuthZSimplePolicy_lookup[policy], +NULL )); +} + + +ssize_t qauthz_simple_append_rule (QAuthZSimple *auth, +const char *match, +QAuthZSimplePolicy policy, +QAuthZSimpleFormat format, +Error **errp) +{ +QAuthZSimpleRule *rule; +QAuthZSimpleRuleList *rules, *tmp; +size_t i =0 ; + +#ifndef CONFIG_FNMATCH +if (format ==QAUTHZ_SIMPLE_FORMAT_GLOB ) { +error_setg (errp,"Glob format not supported on this platform" ); +return -1 ; + } +#endif + + rule =g_new0 (QAuthZSimpleRule,1 ); + rule->policy = policy; + rule->match =g_strdup (match); + rule->format = format; + rule->has_format = true; + + tmp =g_new0 (QAuthZSimpleRuleList,1 ); + tmp->value = rule; + + rules = auth->rules; +if (rules) { +while (rules->next) { + i++; + rules = rules->next; + } + rules->next = tmp; +return i +1 ; + }else { + auth->rules = tmp; +return 0 ; + } +} + + +ssize_t qauthz_simple_insert_rule (QAuthZSimple *auth, +const char *match, +QAuthZSimplePolicy policy, +QAuthZSimpleFormat format, +size_t index, +Error **errp) +{ +QAuthZSimpleRule *rule; +QAuthZSimpleRuleList *rules, *tmp; +size_t i =0 ; + +#ifndef CONFIG_FNMATCH +if (format ==QAUTHZ_SIMPLE_FORMAT_GLOB ) { +error_setg (errp,"Glob format not supported on this platform" ); +return -1 ; + } +#endif + + rule =g_new0 (QAuthZSimpleRule,1 ); + rule->policy = policy; + rule->match =g_strdup (match); + rule->format = format; + rule->has_format = true; + + tmp =g_new0 (QAuthZSimpleRuleList,1 ); + tmp->value = rule; + + rules = auth->rules; +if (rules && index >0 ) { +while (rules->next && i < (index -1 )) { + i++; + rules = rules->next; + } + tmp->next = rules->next; + rules->next = tmp; +return i +1 ; + }else { + tmp->next = auth->rules; + auth->rules = tmp; +return 0 ; + } +} + + +ssize_t qauthz_simple_delete_rule (QAuthZSimple *auth,const char *match) +{ +QAuthZSimpleRule *rule; +QAuthZSimpleRuleList *rules, *prev; +size_t i =0 ; + + prev =NULL ; + rules = auth->rules; +while (rules) { + rule = rules->value; +if (g_str_equal (rule->match, match)) { +if (prev) { + prev->next = rules->next; + }else { + auth->rules = rules->next; + } + rules->next =NULL ; +qapi_free_QAuthZSimpleRuleList (rules); +return i; + } + prev = rules; + rules = rules->next; + i++; + } + +return -1 ; +} + + +static const TypeInfo qauthz_simple_info = { + .parent =TYPE_QAUTHZ , + .name =TYPE_QAUTHZ_SIMPLE , + .instance_size =sizeof (QAuthZSimple), + .instance_finalize = qauthz_simple_finalize, + .class_size =sizeof (QAuthZSimpleClass), + .class_init = qauthz_simple_class_init, + .interfaces = (InterfaceInfo []) { + {TYPE_USER_CREATABLE }, + { } + } +}; + + +static void +qauthz_simple_register_types (void ) +{ +type_register_static (&qauthz_simple_info); +} + + +type_init (qauthz_simple_register_types); --
Quoted 3 lines
2.5.5
Signature · 1 line
Marc-André Lureau
Re: [Qemu-devel] [PATCH v6 5/7] util: add QAuthZ object as an authorization base class
In reply to Marc-André LureauQuoted 8 lines · Marc-André Lureau
util/authz.c line 37
Quoted 6 lines
util/authz.c new file +6
-0+ +static const TypeInfo authz_info = { + .parent =TYPE_OBJECT , + .name =TYPE_QAUTHZ , + .instance_size =sizeof (QAuthZ), + .class_size =sizeof (QAuthZClass),.abstract = true? (perhaps it's not necessary, but that would be more clear)
Yes, makes sense to add that since you can't instantiate this class and do anything useful with it.
Regards,
Daniel
Signature · 4 lines
|: http://berrange.com -o- http://www.flickr.com/photos/dberrange/ :| |: http://libvirt.org -o- http://virt-manager.org :| |: http://autobuild.org -o- http://search.cpan.org/~danberr/ :| |: http://entangle-photo.org -o- http://live.gnome.org/gtk-vnc :|
Re: [Qemu-devel] [PATCH v6 4/7] qom: support arbitrary non-scalar properties with -object
In reply to Marc-André LureauQuoted 77 lines · Marc-André Lureau
Hi
Quoted 65 lines · Daniel P. Berrange
The current -object command line syntax only allows for creation of objects with scalar properties, or a list with a fixed scalar element type. Objects which have properties that are represented as structs in the QAPI schema cannot be created using -object.
This is a design limitation of the way the OptsVisitor is written. It simply iterates over the QemuOpts values as a flat list. The support for lists is enabled by allowing the same key to be repeated in the opts string.
It is not practical to extend the OptsVisitor to support more complex data structures while also maintaining the existing list handling behaviour that is relied upon by other areas of QEMU.
Fortunately there is no existing object that implements the UserCreatable interface that relies on the list handling behaviour, so it is possible to swap out the OptsVisitor for a different visitor implementation, so -object supports non-scalar properties, thus leaving other users of OptsVisitor unaffected.
The previously added
qdict_crumple()method is able to take a qdict containing a flat set of properties and turn that into a arbitrarily nested set of dicts and lists. By combiningqemu_opts_to_qdictandqdict_crumple()together, we can turn the opt string into a data structure that is practically identical to that passed over QMP when defining an object. The only difference is that all the scalar values are represented as strings, rather than strings, ints and bools. This is sufficient to let us replace the OptsVisitor with the QMPInputVisitor for use with -object.Thus -object can now support non-scalar properties, for example the QMP object
{ "execute": "object-add", "arguments": { "qom-type": "demo", "id": "demo0", "parameters": { "foo": [ { "bar": "one", "wizz": "1" }, { "bar": "two", "wizz": "2" } ] } } }Would be creatable via the CLI now using
$QEMU \ -object demo,id=demo0,\ foo.0.bar=one,foo.0.wizz=1,\ foo.1.bar=two,foo.1.wizz=2Notice that this syntax is intentionally compatible with that currently used by block drivers.
This is also wired up to work for the '
object_add' command in the HMP monitor with the same syntax.Quoted 8 lines
(hmp) object_add demo,id=demo0,\ foo.0.bar=one,foo.0.wizz=1,\ foo.1.bar=two,foo.1.wizz=2NB indentation should not be used with HMP commands, this is just for convenient formatting in this commit message.
Signed-off-by Daniel P. Berrange <[email protected]>
Quoted 7 lines
The patch breaks parsing of size arguments:
-object memory-backend-file,id=mem,size=512M,mem-path=/tmp: Parameter 'size' expects a number
Looks like the previous patch needs
type_sizesupport
Yep, I've modified the previous patch to implement the type_size callback on the QMP visitor and added a unit test case for this too.
Regards,
Daniel
Signature · 4 lines
|: http://berrange.com -o- http://www.flickr.com/photos/dberrange/ :| |: http://libvirt.org -o- http://virt-manager.org :| |: http://autobuild.org -o- http://search.cpan.org/~danberr/ :| |: http://entangle-photo.org -o- http://live.gnome.org/gtk-vnc :|