#include "monitor.h"
#include "readline.h"
#include "console.h"
-#include "block.h"
+#include "blockdev.h"
#include "audio/audio.h"
#include "disas.h"
#include "balloon.h"
#include "json-streamer.h"
#include "json-parser.h"
#include "osdep.h"
+#include "exec-all.h"
//#define DEBUG
//#define DEBUG_COMPLETION
int (*cmd_async)(Monitor *mon, const QDict *params,
MonitorCompletion *cb, void *opaque);
} mhandler;
- int async;
+ int flags;
} mon_cmd_t;
/* file descriptors passed via SCM_RIGHTS */
static inline int mon_print_count_get(const Monitor *mon) { return 0; }
#endif /* CONFIG_DEBUG_MONITOR */
+/* QMP checker flags */
+#define QMP_ACCEPT_UNKNOWNS 1
+
static QLIST_HEAD(mon_list, Monitor) mon_list;
static const mon_cmd_t mon_cmds[];
static inline bool monitor_handler_is_async(const mon_cmd_t *cmd)
{
- return cmd->async != 0;
+ return cmd->flags & MONITOR_CMD_ASYNC;
+}
+
+static inline bool monitor_cmd_user_only(const mon_cmd_t *cmd)
+{
+ return (cmd->flags & MONITOR_CMD_USER_ONLY);
}
static inline int monitor_has_error(const Monitor *mon)
case QEVENT_STOP:
event_name = "STOP";
break;
+ case QEVENT_RESUME:
+ event_name = "RESUME";
+ break;
case QEVENT_VNC_CONNECTED:
event_name = "VNC_CONNECTED";
break;
help_cmd(mon, qdict_get_try_str(qdict, "name"));
}
-static void do_commit(Monitor *mon, const QDict *qdict)
-{
- int all_devices;
- DriveInfo *dinfo;
- const char *device = qdict_get_str(qdict, "device");
-
- all_devices = !strcmp(device, "all");
- QTAILQ_FOREACH(dinfo, &drives, next) {
- if (!all_devices)
- if (strcmp(bdrv_get_device_name(dinfo->bdrv), device))
- continue;
- bdrv_commit(dinfo->bdrv);
- }
-}
-
static void user_monitor_complete(void *opaque, QObject *ret_data)
{
MonitorCompletionData *data = (MonitorCompletionData *)opaque;
monitor_protocol_emitter(opaque, ret_data);
}
-static void qmp_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,
- const QDict *params)
+static int qmp_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,
+ const QDict *params)
{
- cmd->mhandler.cmd_async(mon, params, qmp_monitor_complete, mon);
+ return cmd->mhandler.cmd_async(mon, params, qmp_monitor_complete, mon);
}
static void qmp_async_info_handler(Monitor *mon, const mon_cmd_t *cmd)
goto help;
}
+ if (monitor_ctrl_mode(mon) && monitor_cmd_user_only(cmd)) {
+ qerror_report(QERR_COMMAND_NOT_FOUND, item);
+ return -1;
+ }
+
if (monitor_handler_is_async(cmd)) {
if (monitor_ctrl_mode(mon)) {
qmp_async_info_handler(mon, cmd);
static void do_info_version_print(Monitor *mon, const QObject *data)
{
QDict *qdict;
+ QDict *qemu;
qdict = qobject_to_qdict(data);
+ qemu = qdict_get_qdict(qdict, "qemu");
- monitor_printf(mon, "%s%s\n", qdict_get_str(qdict, "qemu"),
- qdict_get_str(qdict, "package"));
+ monitor_printf(mon, "%" PRId64 ".%" PRId64 ".%" PRId64 "%s\n",
+ qdict_get_int(qemu, "major"),
+ qdict_get_int(qemu, "minor"),
+ qdict_get_int(qemu, "micro"),
+ qdict_get_str(qdict, "package"));
}
-/**
- * do_info_version(): Show QEMU version
- *
- * Return a QDict with the following information:
- *
- * - "qemu": QEMU's version
- * - "package": package's version
- *
- * Example:
- *
- * { "qemu": "0.11.50", "package": "" }
- */
static void do_info_version(Monitor *mon, QObject **ret_data)
{
- *ret_data = qobject_from_jsonf("{ 'qemu': %s, 'package': %s }",
- QEMU_VERSION, QEMU_PKGVERSION);
+ const char *version = QEMU_VERSION;
+ int major = 0, minor = 0, micro = 0;
+ char *tmp;
+
+ major = strtol(version, &tmp, 10);
+ tmp++;
+ minor = strtol(tmp, &tmp, 10);
+ tmp++;
+ micro = strtol(tmp, &tmp, 10);
+
+ *ret_data = qobject_from_jsonf("{ 'qemu': { 'major': %d, 'minor': %d, \
+ 'micro': %d }, 'package': %s }", major, minor, micro, QEMU_PKGVERSION);
}
static void do_info_name_print(Monitor *mon, const QObject *data)
monitor_printf(mon, "%s\n", qdict_get_str(qdict, "name"));
}
-/**
- * do_info_name(): Show VM name
- *
- * Return a QDict with the following information:
- *
- * - "name": VM's name (optional)
- *
- * Example:
- *
- * { "name": "qemu-name" }
- */
static void do_info_name(Monitor *mon, QObject **ret_data)
{
*ret_data = qemu_name ? qobject_from_jsonf("{'name': %s }", qemu_name) :
return qobject_from_jsonf("{ 'name': %s }", p);
}
-/**
- * do_info_commands(): List QMP available commands
- *
- * Each command is represented by a QDict, the returned QObject is a QList
- * of all commands.
- *
- * The QDict contains:
- *
- * - "name": command's name
- *
- * Example:
- *
- * { [ { "name": "query-balloon" }, { "name": "system_powerdown" } ] }
- */
static void do_info_commands(Monitor *mon, QObject **ret_data)
{
QList *cmd_list;
cmd_list = qlist_new();
for (cmd = mon_cmds; cmd->name != NULL; cmd++) {
- if (monitor_handler_ported(cmd) && !compare_cmd(cmd->name, "info")) {
+ if (monitor_handler_ported(cmd) && !monitor_cmd_user_only(cmd) &&
+ !compare_cmd(cmd->name, "info")) {
qlist_append_obj(cmd_list, get_cmd_dict(cmd->name));
}
}
for (cmd = info_cmds; cmd->name != NULL; cmd++) {
- if (monitor_handler_ported(cmd)) {
+ if (monitor_handler_ported(cmd) && !monitor_cmd_user_only(cmd)) {
char buf[128];
snprintf(buf, sizeof(buf), "query-%s", cmd->name);
qlist_append_obj(cmd_list, get_cmd_dict(buf));
*ret_data = QOBJECT(cmd_list);
}
-#if defined(TARGET_I386)
-static void do_info_hpet_print(Monitor *mon, const QObject *data)
-{
- monitor_printf(mon, "HPET is %s by QEMU\n",
- qdict_get_bool(qobject_to_qdict(data), "enabled") ?
- "enabled" : "disabled");
-}
-
-/**
- * do_info_hpet(): Show HPET state
- *
- * Return a QDict with the following information:
- *
- * - "enabled": true if hpet if enabled, false otherwise
- *
- * Example:
- *
- * { "enabled": true }
- */
-static void do_info_hpet(Monitor *mon, QObject **ret_data)
-{
- *ret_data = qobject_from_jsonf("{ 'enabled': %i }", !no_hpet);
-}
-#endif
-
static void do_info_uuid_print(Monitor *mon, const QObject *data)
{
monitor_printf(mon, "%s\n", qdict_get_str(qobject_to_qdict(data), "UUID"));
}
-/**
- * do_info_uuid(): Show VM UUID
- *
- * Return a QDict with the following information:
- *
- * - "UUID": Universally Unique Identifier
- *
- * Example:
- *
- * { "UUID": "550e8400-e29b-41d4-a716-446655440000" }
- */
static void do_info_uuid(Monitor *mon, QObject **ret_data)
{
char uuid[64];
qlist_iter(cpu_list, print_cpu_iter, mon);
}
-/**
- * do_info_cpus(): Show CPU information
- *
- * Return a QList. Each CPU is represented by a QDict, which contains:
- *
- * - "cpu": CPU index
- * - "current": true if this is the current CPU, false otherwise
- * - "halted": true if the cpu is halted, false otherwise
- * - Current program counter. The key's name depends on the architecture:
- * "pc": i386/x86)64
- * "nip": PPC
- * "pc" and "npc": sparc
- * "PC": mips
- *
- * Example:
- *
- * [ { "CPU": 0, "current": true, "halted": false, "pc": 3227107138 },
- * { "CPU": 1, "current": false, "halted": true, "pc": 7108165 } ]
- */
static void do_info_cpus(Monitor *mon, QObject **ret_data)
{
CPUState *env;
*/
static int do_quit(Monitor *mon, const QDict *qdict, QObject **ret_data)
{
- exit(0);
- return 0;
-}
-
-static int eject_device(Monitor *mon, BlockDriverState *bs, int force)
-{
- if (bdrv_is_inserted(bs)) {
- if (!force) {
- if (!bdrv_is_removable(bs)) {
- qerror_report(QERR_DEVICE_NOT_REMOVABLE,
- bdrv_get_device_name(bs));
- return -1;
- }
- if (bdrv_is_locked(bs)) {
- qerror_report(QERR_DEVICE_LOCKED, bdrv_get_device_name(bs));
- return -1;
- }
- }
- bdrv_close(bs);
- }
- return 0;
-}
-
-static int do_eject(Monitor *mon, const QDict *qdict, QObject **ret_data)
-{
- BlockDriverState *bs;
- int force = qdict_get_int(qdict, "force");
- const char *filename = qdict_get_str(qdict, "device");
-
- bs = bdrv_find(filename);
- if (!bs) {
- qerror_report(QERR_DEVICE_NOT_FOUND, filename);
- return -1;
- }
- return eject_device(mon, bs, force);
-}
-
-static int do_block_set_passwd(Monitor *mon, const QDict *qdict,
- QObject **ret_data)
-{
- BlockDriverState *bs;
- int err;
-
- bs = bdrv_find(qdict_get_str(qdict, "device"));
- if (!bs) {
- qerror_report(QERR_DEVICE_NOT_FOUND, qdict_get_str(qdict, "device"));
- return -1;
- }
-
- err = bdrv_set_key(bs, qdict_get_str(qdict, "password"));
- if (err == -EINVAL) {
- qerror_report(QERR_DEVICE_NOT_ENCRYPTED, bdrv_get_device_name(bs));
- return -1;
- } else if (err < 0) {
- qerror_report(QERR_INVALID_PASSWORD);
- return -1;
- }
+ monitor_suspend(mon);
+ no_shutdown = 0;
+ qemu_system_shutdown_request();
return 0;
}
-static int do_change_block(Monitor *mon, const char *device,
- const char *filename, const char *fmt)
-{
- BlockDriverState *bs;
- BlockDriver *drv = NULL;
-
- bs = bdrv_find(device);
- if (!bs) {
- qerror_report(QERR_DEVICE_NOT_FOUND, device);
- return -1;
- }
- if (fmt) {
- drv = bdrv_find_whitelisted_format(fmt);
- if (!drv) {
- qerror_report(QERR_INVALID_BLOCK_FORMAT, fmt);
- return -1;
- }
- }
- if (eject_device(mon, bs, 0) < 0) {
- return -1;
- }
- if (bdrv_open(bs, filename, BDRV_O_RDWR, drv) < 0) {
- qerror_report(QERR_OPEN_FILE_FAILED, filename);
- return -1;
- }
- return monitor_read_bdrv_key_start(mon, bs, NULL, NULL);
-}
-
static int change_vnc_password(const char *password)
{
if (vnc_display_password(NULL, password) < 0) {
{
struct bdrv_iterate_context context = { mon, 0 };
+ if (incoming_expected) {
+ qerror_report(QERR_MIGRATION_EXPECTED);
+ return -1;
+ }
bdrv_iterate(encrypted_bdrv_it, &context);
/* only resume the vm if all keys are set and valid */
if (!context.err) {
{ 0x17, "i" },
{ 0x18, "o" },
{ 0x19, "p" },
-
+ { 0x1a, "bracket_left" },
+ { 0x1b, "bracket_right" },
{ 0x1c, "ret" },
{ 0x1e, "a" },
{ 0x24, "j" },
{ 0x25, "k" },
{ 0x26, "l" },
+ { 0x27, "semicolon" },
+ { 0x28, "apostrophe" },
+ { 0x29, "grave_accent" },
+ { 0x2b, "backslash" },
{ 0x2c, "z" },
{ 0x2d, "x" },
{ 0x2e, "c" },
}
}
-/**
- * do_info_kvm(): Show KVM information
- *
- * Return a QDict with the following information:
- *
- * - "enabled": true if KVM support is enabled, false otherwise
- * - "present": true if QEMU has KVM support, false otherwise
- *
- * Example:
- *
- * { "enabled": true, "present": true }
- */
static void do_info_kvm(Monitor *mon, QObject **ret_data)
{
#ifdef CONFIG_KVM
monitor_printf(mon, "\n");
}
-/**
- * do_info_status(): VM status
- *
- * Return a QDict with the following information:
- *
- * - "running": true if the VM is running, or false if it is paused
- * - "singlestep": true if the VM is in single step mode, false otherwise
- *
- * Example:
- *
- * { "running": true, "singlestep": false }
- */
static void do_info_status(Monitor *mon, QObject **ret_data)
{
*ret_data = qobject_from_jsonf("{ 'running': %i, 'singlestep': %i }",
return -1;
}
- fd = dup(fd);
- if (fd == -1) {
- if (errno == EMFILE)
- qerror_report(QERR_TOO_MANY_FILES);
- else
- qerror_report(QERR_UNDEFINED_ERROR);
- return -1;
- }
-
QLIST_FOREACH(monfd, &mon->fds, next) {
if (strcmp(monfd->name, fdname) != 0) {
continue;
.help = "show the active virtual memory mappings",
.mhandler.info = mem_info,
},
- {
- .name = "hpet",
- .args_type = "",
- .params = "",
- .help = "show state of HPET",
- .user_print = do_info_hpet_print,
- .mhandler.info_new = do_info_hpet,
- },
#endif
{
.name = "jit",
.help = "show balloon information",
.user_print = monitor_print_balloon,
.mhandler.info_async = do_info_balloon,
- .async = 1,
+ .flags = MONITOR_CMD_ASYNC,
},
{
.name = "qtree",
static target_long monitor_get_psr (const struct MonitorDef *md, int val)
{
CPUState *env = mon_get_cpu();
- return GET_PSR(env);
+
+ return cpu_get_psr(env);
}
#endif
case '-':
{
const char *tmp = p;
- int has_option, skip_key = 0;
+ int skip_key = 0;
/* option */
c = *typestr++;
goto bad_type;
while (qemu_isspace(*p))
p++;
- has_option = 0;
if (*p == '-') {
p++;
if(c != *p) {
if(skip_key) {
p = tmp;
} else {
+ /* has option */
p++;
- has_option = 1;
+ qdict_put(qdict, key, qbool_from_int(1));
}
}
- qdict_put(qdict, key, qint_from_int(has_option));
}
break;
default:
next arg */
len = strlen(cmdline);
if (len > 0 && qemu_isspace(cmdline[len - 1])) {
- if (nb_args >= MAX_ARGS)
- return;
+ if (nb_args >= MAX_ARGS) {
+ goto cleanup;
+ }
args[nb_args++] = qemu_strdup("");
}
if (nb_args <= 1) {
}
} else {
/* find the command */
- for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
- if (compare_cmd(args[0], cmd->name))
- goto found;
+ for (cmd = mon_cmds; cmd->name != NULL; cmd++) {
+ if (compare_cmd(args[0], cmd->name)) {
+ break;
+ }
}
- return;
- found:
+ if (!cmd->name) {
+ goto cleanup;
+ }
+
ptype = next_arg_type(cmd->args_type);
for(i = 0; i < nb_args - 2; i++) {
if (*ptype != '\0') {
}
str = args[nb_args - 1];
if (*ptype == '-' && ptype[1] != '\0') {
- ptype += 2;
+ ptype = next_arg_type(ptype);
}
switch(*ptype) {
case 'F':
break;
}
}
- for(i = 0; i < nb_args; i++)
+
+cleanup:
+ for (i = 0; i < nb_args; i++) {
qemu_free(args[i]);
+ }
}
static int monitor_can_read(void *opaque)
return (mon->suspend_cnt == 0) ? 1 : 0;
}
-typedef struct CmdArgs {
- QString *name;
- int type;
- int flag;
- int optional;
-} CmdArgs;
-
-static int check_opt(const CmdArgs *cmd_args, const char *name, QDict *args)
+static int invalid_qmp_mode(const Monitor *mon, const char *cmd_name)
{
- if (!cmd_args->optional) {
- qerror_report(QERR_MISSING_PARAMETER, name);
- return -1;
- }
-
- if (cmd_args->type == '-') {
- /* handlers expect a value, they need to be changed */
- qdict_put(args, name, qint_from_int(0));
- }
-
- return 0;
+ int is_cap = compare_cmd(cmd_name, "qmp_capabilities");
+ return (qmp_cmd_mode(mon) ? is_cap : !is_cap);
}
-static int check_arg(const CmdArgs *cmd_args, QDict *args)
+/*
+ * Argument validation rules:
+ *
+ * 1. The argument must exist in cmd_args qdict
+ * 2. The argument type must be the expected one
+ *
+ * Special case: If the argument doesn't exist in cmd_args and
+ * the QMP_ACCEPT_UNKNOWNS flag is set, then the
+ * checking is skipped for it.
+ */
+static int check_client_args_type(const QDict *client_args,
+ const QDict *cmd_args, int flags)
{
- QObject *value;
- const char *name;
+ const QDictEntry *ent;
- name = qstring_get_str(cmd_args->name);
-
- if (!args) {
- return check_opt(cmd_args, name, args);
- }
+ for (ent = qdict_first(client_args); ent;ent = qdict_next(client_args,ent)){
+ QObject *obj;
+ QString *arg_type;
+ const QObject *client_arg = qdict_entry_value(ent);
+ const char *client_arg_name = qdict_entry_key(ent);
+
+ obj = qdict_get(cmd_args, client_arg_name);
+ if (!obj) {
+ if (flags & QMP_ACCEPT_UNKNOWNS) {
+ /* handler accepts unknowns */
+ continue;
+ }
+ /* client arg doesn't exist */
+ qerror_report(QERR_INVALID_PARAMETER, client_arg_name);
+ return -1;
+ }
- value = qdict_get(args, name);
- if (!value) {
- return check_opt(cmd_args, name, args);
- }
+ arg_type = qobject_to_qstring(obj);
+ assert(arg_type != NULL);
- switch (cmd_args->type) {
+ /* check if argument's type is correct */
+ switch (qstring_get_str(arg_type)[0]) {
case 'F':
case 'B':
case 's':
- if (qobject_type(value) != QTYPE_QSTRING) {
- qerror_report(QERR_INVALID_PARAMETER_TYPE, name, "string");
+ if (qobject_type(client_arg) != QTYPE_QSTRING) {
+ qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
+ "string");
return -1;
}
- break;
- case '/': {
- int i;
- const char *keys[] = { "count", "format", "size", NULL };
-
- for (i = 0; keys[i]; i++) {
- QObject *obj = qdict_get(args, keys[i]);
- if (!obj) {
- qerror_report(QERR_MISSING_PARAMETER, name);
- return -1;
- }
- if (qobject_type(obj) != QTYPE_QINT) {
- qerror_report(QERR_INVALID_PARAMETER_TYPE, name, "int");
- return -1;
- }
- }
- break;
- }
+ break;
case 'i':
case 'l':
case 'M':
- if (qobject_type(value) != QTYPE_QINT) {
- qerror_report(QERR_INVALID_PARAMETER_TYPE, name, "int");
- return -1;
+ if (qobject_type(client_arg) != QTYPE_QINT) {
+ qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
+ "int");
+ return -1;
}
break;
case 'f':
case 'T':
- if (qobject_type(value) != QTYPE_QINT && qobject_type(value) != QTYPE_QFLOAT) {
- qerror_report(QERR_INVALID_PARAMETER_TYPE, name, "number");
- return -1;
+ if (qobject_type(client_arg) != QTYPE_QINT &&
+ qobject_type(client_arg) != QTYPE_QFLOAT) {
+ qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
+ "number");
+ return -1;
}
break;
case 'b':
- if (qobject_type(value) != QTYPE_QBOOL) {
- qerror_report(QERR_INVALID_PARAMETER_TYPE, name, "bool");
- return -1;
- }
- break;
case '-':
- if (qobject_type(value) != QTYPE_QINT &&
- qobject_type(value) != QTYPE_QBOOL) {
- qerror_report(QERR_INVALID_PARAMETER_TYPE, name, "bool");
- return -1;
- }
- if (qobject_type(value) == QTYPE_QBOOL) {
- /* handlers expect a QInt, they need to be changed */
- qdict_put(args, name,
- qint_from_int(qbool_get_int(qobject_to_qbool(value))));
+ if (qobject_type(client_arg) != QTYPE_QBOOL) {
+ qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
+ "bool");
+ return -1;
}
break;
case 'O':
+ assert(flags & QMP_ACCEPT_UNKNOWNS);
+ break;
+ case '/':
+ case '.':
+ /*
+ * These types are not supported by QMP and thus are not
+ * handled here. Fall through.
+ */
default:
- /* impossible */
abort();
+ }
+ }
+
+ return 0;
+}
+
+/*
+ * - Check if the client has passed all mandatory args
+ * - Set special flags for argument validation
+ */
+static int check_mandatory_args(const QDict *cmd_args,
+ const QDict *client_args, int *flags)
+{
+ const QDictEntry *ent;
+
+ for (ent = qdict_first(cmd_args); ent; ent = qdict_next(cmd_args, ent)) {
+ const char *cmd_arg_name = qdict_entry_key(ent);
+ QString *type = qobject_to_qstring(qdict_entry_value(ent));
+ assert(type != NULL);
+
+ if (qstring_get_str(type)[0] == 'O') {
+ assert((*flags & QMP_ACCEPT_UNKNOWNS) == 0);
+ *flags |= QMP_ACCEPT_UNKNOWNS;
+ } else if (qstring_get_str(type)[0] != '-' &&
+ qstring_get_str(type)[1] != '?' &&
+ !qdict_haskey(client_args, cmd_arg_name)) {
+ qerror_report(QERR_MISSING_PARAMETER, cmd_arg_name);
+ return -1;
+ }
}
return 0;
}
-static void cmd_args_init(CmdArgs *cmd_args)
+static QDict *qdict_from_args_type(const char *args_type)
{
- cmd_args->name = qstring_new();
- cmd_args->type = cmd_args->flag = cmd_args->optional = 0;
+ int i;
+ QDict *qdict;
+ QString *key, *type, *cur_qs;
+
+ assert(args_type != NULL);
+
+ qdict = qdict_new();
+
+ if (args_type == NULL || args_type[0] == '\0') {
+ /* no args, empty qdict */
+ goto out;
+ }
+
+ key = qstring_new();
+ type = qstring_new();
+
+ cur_qs = key;
+
+ for (i = 0;; i++) {
+ switch (args_type[i]) {
+ case ',':
+ case '\0':
+ qdict_put(qdict, qstring_get_str(key), type);
+ QDECREF(key);
+ if (args_type[i] == '\0') {
+ goto out;
+ }
+ type = qstring_new(); /* qdict has ref */
+ cur_qs = key = qstring_new();
+ break;
+ case ':':
+ cur_qs = type;
+ break;
+ default:
+ qstring_append_chr(cur_qs, args_type[i]);
+ break;
+ }
+ }
+
+out:
+ return qdict;
}
-static int check_opts(QemuOptsList *opts_list, QDict *args)
+/*
+ * Client argument checking rules:
+ *
+ * 1. Client must provide all mandatory arguments
+ * 2. Each argument provided by the client must be expected
+ * 3. Each argument provided by the client must have the type expected
+ * by the command
+ */
+static int qmp_check_client_args(const mon_cmd_t *cmd, QDict *client_args)
{
- assert(!opts_list->desc->name);
- return 0;
+ int flags, err;
+ QDict *cmd_args;
+
+ cmd_args = qdict_from_args_type(cmd->args_type);
+
+ flags = 0;
+ err = check_mandatory_args(cmd_args, client_args, &flags);
+ if (err) {
+ goto out;
+ }
+
+ err = check_client_args_type(client_args, cmd_args, flags);
+
+out:
+ QDECREF(cmd_args);
+ return err;
}
/*
- * This is not trivial, we have to parse Monitor command's argument
- * type syntax to be able to check the arguments provided by clients.
+ * Input object checking rules
*
- * In the near future we will be using an array for that and will be
- * able to drop all this parsing...
+ * 1. Input object must be a dict
+ * 2. The "execute" key must exist
+ * 3. The "execute" key must be a string
+ * 4. If the "arguments" key exists, it must be a dict
+ * 5. If the "id" key exists, it can be anything (ie. json-value)
+ * 6. Any argument not listed above is considered invalid
*/
-static int monitor_check_qmp_args(const mon_cmd_t *cmd, QDict *args)
+static QDict *qmp_check_input_obj(QObject *input_obj)
{
- int err;
- const char *p;
- CmdArgs cmd_args;
- QemuOptsList *opts_list;
+ const QDictEntry *ent;
+ int has_exec_key = 0;
+ QDict *input_dict;
- if (cmd->args_type == NULL) {
- return (qdict_size(args) == 0 ? 0 : -1);
+ if (qobject_type(input_obj) != QTYPE_QDICT) {
+ qerror_report(QERR_QMP_BAD_INPUT_OBJECT, "object");
+ return NULL;
}
- err = 0;
- cmd_args_init(&cmd_args);
- opts_list = NULL;
+ input_dict = qobject_to_qdict(input_obj);
- for (p = cmd->args_type;; p++) {
- if (*p == ':') {
- cmd_args.type = *++p;
- p++;
- if (cmd_args.type == '-') {
- cmd_args.flag = *p++;
- cmd_args.optional = 1;
- } else if (cmd_args.type == 'O') {
- opts_list = qemu_find_opts(qstring_get_str(cmd_args.name));
- assert(opts_list);
- } else if (*p == '?') {
- cmd_args.optional = 1;
- p++;
- }
+ for (ent = qdict_first(input_dict); ent; ent = qdict_next(input_dict, ent)){
+ const char *arg_name = qdict_entry_key(ent);
+ const QObject *arg_obj = qdict_entry_value(ent);
- assert(*p == ',' || *p == '\0');
- if (opts_list) {
- err = check_opts(opts_list, args);
- opts_list = NULL;
- } else {
- err = check_arg(&cmd_args, args);
- QDECREF(cmd_args.name);
- cmd_args_init(&cmd_args);
+ if (!strcmp(arg_name, "execute")) {
+ if (qobject_type(arg_obj) != QTYPE_QSTRING) {
+ qerror_report(QERR_QMP_BAD_INPUT_OBJECT_MEMBER, "execute",
+ "string");
+ return NULL;
}
-
- if (err < 0) {
- break;
+ has_exec_key = 1;
+ } else if (!strcmp(arg_name, "arguments")) {
+ if (qobject_type(arg_obj) != QTYPE_QDICT) {
+ qerror_report(QERR_QMP_BAD_INPUT_OBJECT_MEMBER, "arguments",
+ "object");
+ return NULL;
}
+ } else if (!strcmp(arg_name, "id")) {
+ /* FIXME: check duplicated IDs for async commands */
} else {
- qstring_append_chr(cmd_args.name, *p);
- }
-
- if (*p == '\0') {
- break;
+ qerror_report(QERR_QMP_EXTRA_MEMBER, arg_name);
+ return NULL;
}
}
- QDECREF(cmd_args.name);
- return err;
-}
+ if (!has_exec_key) {
+ qerror_report(QERR_QMP_BAD_INPUT_OBJECT, "execute");
+ return NULL;
+ }
-static int invalid_qmp_mode(const Monitor *mon, const char *cmd_name)
-{
- int is_cap = compare_cmd(cmd_name, "qmp_capabilities");
- return (qmp_cmd_mode(mon) ? is_cap : !is_cap);
+ return input_dict;
}
static void handle_qmp_command(JSONMessageParser *parser, QList *tokens)
Monitor *mon = cur_mon;
const char *cmd_name, *info_item;
- args = NULL;
+ args = input = NULL;
obj = json_parser_parse(tokens, NULL);
if (!obj) {
// FIXME: should be triggered in json_parser_parse()
qerror_report(QERR_JSON_PARSING);
goto err_out;
- } else if (qobject_type(obj) != QTYPE_QDICT) {
- qerror_report(QERR_QMP_BAD_INPUT_OBJECT, "object");
+ }
+
+ input = qmp_check_input_obj(obj);
+ if (!input) {
qobject_decref(obj);
goto err_out;
}
- input = qobject_to_qdict(obj);
-
mon->mc->id = qdict_get(input, "id");
qobject_incref(mon->mc->id);
- obj = qdict_get(input, "execute");
- if (!obj) {
- qerror_report(QERR_QMP_BAD_INPUT_OBJECT, "execute");
- goto err_input;
- } else if (qobject_type(obj) != QTYPE_QSTRING) {
- qerror_report(QERR_QMP_BAD_INPUT_OBJECT_MEMBER, "execute", "string");
- goto err_input;
- }
-
- cmd_name = qstring_get_str(qobject_to_qstring(obj));
-
+ cmd_name = qdict_get_str(input, "execute");
if (invalid_qmp_mode(mon, cmd_name)) {
qerror_report(QERR_COMMAND_NOT_FOUND, cmd_name);
- goto err_input;
+ goto err_out;
}
/*
*/
if (compare_cmd(cmd_name, "info")) {
qerror_report(QERR_COMMAND_NOT_FOUND, cmd_name);
- goto err_input;
+ goto err_out;
} else if (strstart(cmd_name, "query-", &info_item)) {
cmd = monitor_find_command("info");
qdict_put_obj(input, "arguments",
qobject_from_jsonf("{ 'item': %s }", info_item));
} else {
cmd = monitor_find_command(cmd_name);
- if (!cmd || !monitor_handler_ported(cmd)) {
+ if (!cmd || !monitor_handler_ported(cmd)
+ || monitor_cmd_user_only(cmd)) {
qerror_report(QERR_COMMAND_NOT_FOUND, cmd_name);
- goto err_input;
+ goto err_out;
}
}
obj = qdict_get(input, "arguments");
if (!obj) {
args = qdict_new();
- } else if (qobject_type(obj) != QTYPE_QDICT) {
- qerror_report(QERR_QMP_BAD_INPUT_OBJECT_MEMBER, "arguments", "object");
- goto err_input;
} else {
args = qobject_to_qdict(obj);
QINCREF(args);
}
- QDECREF(input);
-
- err = monitor_check_qmp_args(cmd, args);
+ err = qmp_check_client_args(cmd, args);
if (err < 0) {
goto err_out;
}
if (monitor_handler_is_async(cmd)) {
- qmp_async_cmd_handler(mon, cmd, args);
+ err = qmp_async_cmd_handler(mon, cmd, args);
+ if (err) {
+ /* emit the error response */
+ goto err_out;
+ }
} else {
monitor_call_handler(mon, cmd, args);
}
+
goto out;
-err_input:
- QDECREF(input);
err_out:
monitor_protocol_emitter(mon, NULL);
out:
+ QDECREF(input);
QDECREF(args);
}
projects / qemu.git / blobdiff