Return to qmp-dispatch.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / qapi

Annotation of qemu/qapi/qmp-dispatch.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * Core Definitions for QAPI/QMP Dispatch
                      3:  *
                      4:  * Copyright IBM, Corp. 2011
                      5:  *
                      6:  * Authors:
                      7:  *  Anthony Liguori   <[email protected]>
                      8:  *
                      9:  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
                     10:  * See the COPYING.LIB file in the top-level directory.
                     11:  *
                     12:  */
                     13: 
                     14: #include "qemu-objects.h"
                     15: #include "qapi/qmp-core.h"
                     16: #include "json-parser.h"
                     17: #include "error.h"
                     18: #include "error_int.h"
                     19: #include "qerror.h"
                     20: 
                     21: static QDict *qmp_dispatch_check_obj(const QObject *request, Error **errp)
                     22: {
                     23:     const QDictEntry *ent;
                     24:     const char *arg_name;
                     25:     const QObject *arg_obj;
                     26:     bool has_exec_key = false;
                     27:     QDict *dict = NULL;
                     28: 
                     29:     if (qobject_type(request) != QTYPE_QDICT) {
                     30:         error_set(errp, QERR_QMP_BAD_INPUT_OBJECT,
                     31:                   "request is not a dictionary");
                     32:         return NULL;
                     33:     }
                     34: 
                     35:     dict = qobject_to_qdict(request);
                     36: 
                     37:     for (ent = qdict_first(dict); ent;
                     38:          ent = qdict_next(dict, ent)) {
                     39:         arg_name = qdict_entry_key(ent);
                     40:         arg_obj = qdict_entry_value(ent);
                     41: 
                     42:         if (!strcmp(arg_name, "execute")) {
                     43:             if (qobject_type(arg_obj) != QTYPE_QSTRING) {
                     44:                 error_set(errp, QERR_QMP_BAD_INPUT_OBJECT_MEMBER, "execute",
                     45:                           "string");
                     46:                 return NULL;
                     47:             }
                     48:             has_exec_key = true;
                     49:         } else if (strcmp(arg_name, "arguments")) {
                     50:             error_set(errp, QERR_QMP_EXTRA_MEMBER, arg_name);
                     51:             return NULL;
                     52:         }
                     53:     }
                     54: 
                     55:     if (!has_exec_key) {
                     56:         error_set(errp, QERR_QMP_BAD_INPUT_OBJECT, "execute");
                     57:         return NULL;
                     58:     }
                     59: 
                     60:     return dict;
                     61: }
                     62: 
                     63: static QObject *do_qmp_dispatch(QObject *request, Error **errp)
                     64: {
                     65:     const char *command;
                     66:     QDict *args, *dict;
                     67:     QmpCommand *cmd;
                     68:     QObject *ret = NULL;
                     69: 
                     70: 
                     71:     dict = qmp_dispatch_check_obj(request, errp);
                     72:     if (!dict || error_is_set(errp)) {
                     73:         return NULL;
                     74:     }
                     75: 
                     76:     command = qdict_get_str(dict, "execute");
                     77:     cmd = qmp_find_command(command);
                     78:     if (cmd == NULL) {
                     79:         error_set(errp, QERR_COMMAND_NOT_FOUND, command);
                     80:         return NULL;
                     81:     }
                     82: 
                     83:     if (!qdict_haskey(dict, "arguments")) {
                     84:         args = qdict_new();
                     85:     } else {
                     86:         args = qdict_get_qdict(dict, "arguments");
                     87:         QINCREF(args);
                     88:     }
                     89: 
                     90:     switch (cmd->type) {
                     91:     case QCT_NORMAL:
                     92:         cmd->fn(args, &ret, errp);
                     93:         if (!error_is_set(errp) && ret == NULL) {
                     94:             ret = QOBJECT(qdict_new());
                     95:         }
                     96:         break;
                     97:     }
                     98: 
                     99:     QDECREF(args);
                    100: 
                    101:     return ret;
                    102: }
                    103: 
                    104: QObject *qmp_dispatch(QObject *request)
                    105: {
                    106:     Error *err = NULL;
                    107:     QObject *ret;
                    108:     QDict *rsp;
                    109: 
                    110:     ret = do_qmp_dispatch(request, &err);
                    111: 
                    112:     rsp = qdict_new();
                    113:     if (err) {
                    114:         qdict_put_obj(rsp, "error", error_get_qobject(err));
                    115:         error_free(err);
                    116:     } else if (ret) {
                    117:         qdict_put_obj(rsp, "return", ret);
                    118:     } else {
                    119:         QDECREF(rsp);
                    120:         return NULL;
                    121:     }
                    122: 
                    123:     return QOBJECT(rsp);
                    124: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.