[qemu.git] / qmp.c

/*
 * QEMU Management Protocol
 *
 * Copyright IBM, Corp. 2011
 *
 * Authors:
 *  Anthony Liguori   <aliguori@us.ibm.com>
 *
 * This work is licensed under the terms of the GNU GPL, version 2.  See
 * the COPYING file in the top-level directory.
 *
 * Contributions after 2012-01-13 are licensed under the terms of the
 * GNU GPL, version 2 or (at your option) any later version.
 */

#include "qemu-common.h"
#include "sysemu.h"
#include "qmp-commands.h"
#include "ui/qemu-spice.h"
#include "ui/vnc.h"
#include "kvm.h"
#include "arch_init.h"
#include "hw/qdev.h"
#include "qapi/qmp-input-visitor.h"
#include "qapi/qmp-output-visitor.h"
#include "blockdev.h"

NameInfo *qmp_query_name(Error **errp)
{
    NameInfo *info = g_malloc0(sizeof(*info));

    if (qemu_name) {
        info->has_name = true;
        info->name = g_strdup(qemu_name);
    }

    return info;
}

VersionInfo *qmp_query_version(Error **err)
{
    VersionInfo *info = g_malloc0(sizeof(*info));
    const char *version = QEMU_VERSION;
    char *tmp;

    info->qemu.major = strtol(version, &tmp, 10);
    tmp++;
    info->qemu.minor = strtol(tmp, &tmp, 10);
    tmp++;
    info->qemu.micro = strtol(tmp, &tmp, 10);
    info->package = g_strdup(QEMU_PKGVERSION);

    return info;
}

KvmInfo *qmp_query_kvm(Error **errp)
{
    KvmInfo *info = g_malloc0(sizeof(*info));

    info->enabled = kvm_enabled();
    info->present = kvm_available();

    return info;
}

UuidInfo *qmp_query_uuid(Error **errp)
{
    UuidInfo *info = g_malloc0(sizeof(*info));
    char uuid[64];

    snprintf(uuid, sizeof(uuid), UUID_FMT, qemu_uuid[0], qemu_uuid[1],
                   qemu_uuid[2], qemu_uuid[3], qemu_uuid[4], qemu_uuid[5],
                   qemu_uuid[6], qemu_uuid[7], qemu_uuid[8], qemu_uuid[9],
                   qemu_uuid[10], qemu_uuid[11], qemu_uuid[12], qemu_uuid[13],
                   qemu_uuid[14], qemu_uuid[15]);

    info->UUID = g_strdup(uuid);
    return info;
}

void qmp_quit(Error **err)
{
    no_shutdown = 0;
    qemu_system_shutdown_request();
}

void qmp_stop(Error **errp)
{
    vm_stop(RUN_STATE_PAUSED);
}

void qmp_system_reset(Error **errp)
{
    qemu_system_reset_request();
}

void qmp_system_powerdown(Error **erp)
{
    qemu_system_powerdown_request();
}

void qmp_cpu(int64_t index, Error **errp)
{
    /* Just do nothing */
}

#ifndef CONFIG_VNC
/* If VNC support is enabled, the "true" query-vnc command is
   defined in the VNC subsystem */
VncInfo *qmp_query_vnc(Error **errp)
{
    error_set(errp, QERR_FEATURE_DISABLED, "vnc");
    return NULL;
};
#endif

#ifndef CONFIG_SPICE
/* If SPICE support is enabled, the "true" query-spice command is
   defined in the SPICE subsystem. Also note that we use a small
   trick to maintain query-spice's original behavior, which is not
   to be available in the namespace if SPICE is not compiled in */
SpiceInfo *qmp_query_spice(Error **errp)
{
    error_set(errp, QERR_COMMAND_NOT_FOUND, "query-spice");
    return NULL;
};
#endif

static void iostatus_bdrv_it(void *opaque, BlockDriverState *bs)
{
    bdrv_iostatus_reset(bs);
}

static void encrypted_bdrv_it(void *opaque, BlockDriverState *bs)
{
    Error **err = opaque;

    if (!error_is_set(err) && bdrv_key_required(bs)) {
        error_set(err, QERR_DEVICE_ENCRYPTED, bdrv_get_device_name(bs),
                  bdrv_get_encrypted_filename(bs));
    }
}

void qmp_cont(Error **errp)
{
    Error *local_err = NULL;

    if (runstate_check(RUN_STATE_INMIGRATE)) {
        error_set(errp, QERR_MIGRATION_EXPECTED);
        return;
    } else if (runstate_check(RUN_STATE_INTERNAL_ERROR) ||
               runstate_check(RUN_STATE_SHUTDOWN)) {
        error_set(errp, QERR_RESET_REQUIRED);
        return;
    }

    bdrv_iterate(iostatus_bdrv_it, NULL);
    bdrv_iterate(encrypted_bdrv_it, &local_err);
    if (local_err) {
        error_propagate(errp, local_err);
        return;
    }

    vm_start();
}

DevicePropertyInfoList *qmp_qom_list(const char *path, Error **errp)
{
    DeviceState *dev;
    bool ambiguous = false;
    DevicePropertyInfoList *props = NULL;
    DeviceProperty *prop;

    dev = qdev_resolve_path(path, &ambiguous);
    if (dev == NULL) {
        error_set(errp, QERR_DEVICE_NOT_FOUND, path);
        return NULL;
    }

    QTAILQ_FOREACH(prop, &dev->properties, node) {
        DevicePropertyInfoList *entry = g_malloc0(sizeof(*entry));

        entry->value = g_malloc0(sizeof(DevicePropertyInfo));
        entry->next = props;
        props = entry;

        entry->value->name = g_strdup(prop->name);
        entry->value->type = g_strdup(prop->type);
    }

    return props;
}

/* FIXME: teach qapi about how to pass through Visitors */
int qmp_qom_set(Monitor *mon, const QDict *qdict, QObject **ret)
{
    const char *path = qdict_get_str(qdict, "path");
    const char *property = qdict_get_str(qdict, "property");
    QObject *value = qdict_get(qdict, "value");
    Error *local_err = NULL;
    QmpInputVisitor *mi;
    DeviceState *dev;

    dev = qdev_resolve_path(path, NULL);
    if (!dev) {
        error_set(&local_err, QERR_DEVICE_NOT_FOUND, path);
        goto out;
    }

    mi = qmp_input_visitor_new(value);
    qdev_property_set(dev, qmp_input_get_visitor(mi), property, &local_err);

    qmp_input_visitor_cleanup(mi);

out:
    if (local_err) {
        qerror_report_err(local_err);
        error_free(local_err);
        return -1;
    }

    return 0;
}

int qmp_qom_get(Monitor *mon, const QDict *qdict, QObject **ret)
{
    const char *path = qdict_get_str(qdict, "path");
    const char *property = qdict_get_str(qdict, "property");
    Error *local_err = NULL;
    QmpOutputVisitor *mo;
    DeviceState *dev;

    dev = qdev_resolve_path(path, NULL);
    if (!dev) {
        error_set(&local_err, QERR_DEVICE_NOT_FOUND, path);
        goto out;
    }

    mo = qmp_output_visitor_new();
    qdev_property_get(dev, qmp_output_get_visitor(mo), property, &local_err);
    if (!local_err) {
        *ret = qmp_output_get_qobject(mo);
    }

    qmp_output_visitor_cleanup(mo);

out:
    if (local_err) {
        qerror_report_err(local_err);
        error_free(local_err);
        return -1;
    }

    return 0;
}

void qmp_set_password(const char *protocol, const char *password,
                      bool has_connected, const char *connected, Error **errp)
{
    int disconnect_if_connected = 0;
    int fail_if_connected = 0;
    int rc;

    if (has_connected) {
        if (strcmp(connected, "fail") == 0) {
            fail_if_connected = 1;
        } else if (strcmp(connected, "disconnect") == 0) {
            disconnect_if_connected = 1;
        } else if (strcmp(connected, "keep") == 0) {
            /* nothing */
        } else {
            error_set(errp, QERR_INVALID_PARAMETER, "connected");
            return;
        }
    }

    if (strcmp(protocol, "spice") == 0) {
        if (!using_spice) {
            /* correct one? spice isn't a device ,,, */
            error_set(errp, QERR_DEVICE_NOT_ACTIVE, "spice");
            return;
        }
        rc = qemu_spice_set_passwd(password, fail_if_connected,
                                   disconnect_if_connected);
        if (rc != 0) {
            error_set(errp, QERR_SET_PASSWD_FAILED);
        }
        return;
    }

    if (strcmp(protocol, "vnc") == 0) {
        if (fail_if_connected || disconnect_if_connected) {
            /* vnc supports "connected=keep" only */
            error_set(errp, QERR_INVALID_PARAMETER, "connected");
            return;
        }
        /* Note that setting an empty password will not disable login through
         * this interface. */
        rc = vnc_display_password(NULL, password);
        if (rc < 0) {
            error_set(errp, QERR_SET_PASSWD_FAILED);
        }
        return;
    }

    error_set(errp, QERR_INVALID_PARAMETER, "protocol");
}

void qmp_expire_password(const char *protocol, const char *whenstr,
                         Error **errp)
{
    time_t when;
    int rc;

    if (strcmp(whenstr, "now") == 0) {
        when = 0;
    } else if (strcmp(whenstr, "never") == 0) {
        when = TIME_MAX;
    } else if (whenstr[0] == '+') {
        when = time(NULL) + strtoull(whenstr+1, NULL, 10);
    } else {
        when = strtoull(whenstr, NULL, 10);
    }

    if (strcmp(protocol, "spice") == 0) {
        if (!using_spice) {
            /* correct one? spice isn't a device ,,, */
            error_set(errp, QERR_DEVICE_NOT_ACTIVE, "spice");
            return;
        }
        rc = qemu_spice_set_pw_expire(when);
        if (rc != 0) {
            error_set(errp, QERR_SET_PASSWD_FAILED);
        }
        return;
    }

    if (strcmp(protocol, "vnc") == 0) {
        rc = vnc_display_pw_expire(NULL, when);
        if (rc != 0) {
            error_set(errp, QERR_SET_PASSWD_FAILED);
        }
        return;
    }

    error_set(errp, QERR_INVALID_PARAMETER, "protocol");
}

#ifdef CONFIG_VNC
void qmp_change_vnc_password(const char *password, Error **errp)
{
    if (vnc_display_password(NULL, password) < 0) {
        error_set(errp, QERR_SET_PASSWD_FAILED);
    }
}

static void qmp_change_vnc_listen(const char *target, Error **err)
{
    if (vnc_display_open(NULL, target) < 0) {
        error_set(err, QERR_VNC_SERVER_FAILED, target);
    }
}

static void qmp_change_vnc(const char *target, bool has_arg, const char *arg,
                           Error **errp)
{
    if (strcmp(target, "passwd") == 0 || strcmp(target, "password") == 0) {
        if (!has_arg) {
            error_set(errp, QERR_MISSING_PARAMETER, "password");
        } else {
            qmp_change_vnc_password(arg, errp);
        }
    } else {
        qmp_change_vnc_listen(target, errp);
    }
}
#else
void qmp_change_vnc_password(const char *password, Error **errp)
{
    error_set(errp, QERR_FEATURE_DISABLED, "vnc");
}
static void qmp_change_vnc(const char *target, bool has_arg, const char *arg,
                           Error **errp)
{
    error_set(errp, QERR_FEATURE_DISABLED, "vnc");
}
#endif /* !CONFIG_VNC */

void qmp_change(const char *device, const char *target,
                bool has_arg, const char *arg, Error **err)
{
    if (strcmp(device, "vnc") == 0) {
        qmp_change_vnc(target, has_arg, arg, err);
    } else {
        qmp_change_blockdev(device, target, has_arg, arg, err);
    }
}
Commit	Line	Data
48a32bed AL	1	/*
	2	* QEMU Management Protocol
	3	*
	4	* Copyright IBM, Corp. 2011
	5	*
	6	* Authors:
	7	* Anthony Liguori <aliguori@us.ibm.com>
	8	*
	9	* This work is licensed under the terms of the GNU GPL, version 2. See
	10	* the COPYING file in the top-level directory.
	11	*
6b620ca3 PB	12	* Contributions after 2012-01-13 are licensed under the terms of the
6b620ca3 PB	13	* GNU GPL, version 2 or (at your option) any later version.
48a32bed AL	14	*/
	15
	16	#include "qemu-common.h"
	17	#include "sysemu.h"
	18	#include "qmp-commands.h"
fbf796fd LC	19	#include "ui/qemu-spice.h"
fbf796fd LC	20	#include "ui/vnc.h"
292a2602 LC	21	#include "kvm.h"
292a2602 LC	22	#include "arch_init.h"
b4b12c62	23	#include "hw/qdev.h"
eb6e8ea5 AL	24	#include "qapi/qmp-input-visitor.h"
eb6e8ea5 AL	25	#include "qapi/qmp-output-visitor.h"
333a96ec	26	#include "blockdev.h"
48a32bed AL	27
	28	NameInfo qmp_query_name(Error *errp)
	29	{
	30	NameInfo info = g_malloc0(sizeof(info));
	31
	32	if (qemu_name) {
	33	info->has_name = true;
	34	info->name = g_strdup(qemu_name);
	35	}
	36
	37	return info;
	38	}
b9c15f16 LC	39
	40	VersionInfo qmp_query_version(Error *err)
	41	{
	42	VersionInfo info = g_malloc0(sizeof(info));
	43	const char *version = QEMU_VERSION;
	44	char *tmp;
	45
	46	info->qemu.major = strtol(version, &tmp, 10);
	47	tmp++;
	48	info->qemu.minor = strtol(tmp, &tmp, 10);
	49	tmp++;
	50	info->qemu.micro = strtol(tmp, &tmp, 10);
	51	info->package = g_strdup(QEMU_PKGVERSION);
	52
	53	return info;
	54	}
292a2602 LC	55
	56	KvmInfo qmp_query_kvm(Error *errp)
	57	{
	58	KvmInfo info = g_malloc0(sizeof(info));
	59
	60	info->enabled = kvm_enabled();
	61	info->present = kvm_available();
	62
	63	return info;
	64	}
	65
efab767e LC	66	UuidInfo qmp_query_uuid(Error *errp)
	67	{
	68	UuidInfo info = g_malloc0(sizeof(info));
	69	char uuid[64];
	70
	71	snprintf(uuid, sizeof(uuid), UUID_FMT, qemu_uuid[0], qemu_uuid[1],
	72	qemu_uuid[2], qemu_uuid[3], qemu_uuid[4], qemu_uuid[5],
	73	qemu_uuid[6], qemu_uuid[7], qemu_uuid[8], qemu_uuid[9],
	74	qemu_uuid[10], qemu_uuid[11], qemu_uuid[12], qemu_uuid[13],
	75	qemu_uuid[14], qemu_uuid[15]);
	76
	77	info->UUID = g_strdup(uuid);
	78	return info;
	79	}
	80
7a7f325e LC	81	void qmp_quit(Error **err)
	82	{
	83	no_shutdown = 0;
	84	qemu_system_shutdown_request();
	85	}
	86
5f158f21 LC	87	void qmp_stop(Error **errp)
	88	{
	89	vm_stop(RUN_STATE_PAUSED);
	90	}
	91
38d22653 LC	92	void qmp_system_reset(Error **errp)
	93	{
	94	qemu_system_reset_request();
	95	}
5bc465e4 LC	96
	97	void qmp_system_powerdown(Error **erp)
	98	{
	99	qemu_system_powerdown_request();
	100	}
755f1968 LC	101
	102	void qmp_cpu(int64_t index, Error **errp)
	103	{
	104	/* Just do nothing */
	105	}
2b54aa87 LC	106
	107	#ifndef CONFIG_VNC
	108	/* If VNC support is enabled, the "true" query-vnc command is
	109	defined in the VNC subsystem */
	110	VncInfo qmp_query_vnc(Error *errp)
	111	{
	112	error_set(errp, QERR_FEATURE_DISABLED, "vnc");
	113	return NULL;
	114	};
	115	#endif
d1f29646 LC	116
	117	#ifndef CONFIG_SPICE
	118	/* If SPICE support is enabled, the "true" query-spice command is
	119	defined in the SPICE subsystem. Also note that we use a small
	120	trick to maintain query-spice's original behavior, which is not
	121	to be available in the namespace if SPICE is not compiled in */
	122	SpiceInfo qmp_query_spice(Error *errp)
	123	{
	124	error_set(errp, QERR_COMMAND_NOT_FOUND, "query-spice");
	125	return NULL;
	126	};
	127	#endif
e42e818b LC	128
	129	static void iostatus_bdrv_it(void opaque, BlockDriverState bs)
	130	{
	131	bdrv_iostatus_reset(bs);
	132	}
	133
	134	static void encrypted_bdrv_it(void opaque, BlockDriverState bs)
	135	{
	136	Error **err = opaque;
	137
	138	if (!error_is_set(err) && bdrv_key_required(bs)) {
903a8814 LC	139	error_set(err, QERR_DEVICE_ENCRYPTED, bdrv_get_device_name(bs),
903a8814 LC	140	bdrv_get_encrypted_filename(bs));
e42e818b LC	141	}
	142	}
	143
	144	void qmp_cont(Error **errp)
	145	{
	146	Error *local_err = NULL;
	147
	148	if (runstate_check(RUN_STATE_INMIGRATE)) {
	149	error_set(errp, QERR_MIGRATION_EXPECTED);
	150	return;
	151	} else if (runstate_check(RUN_STATE_INTERNAL_ERROR) \|\|
	152	runstate_check(RUN_STATE_SHUTDOWN)) {
	153	error_set(errp, QERR_RESET_REQUIRED);
	154	return;
	155	}
	156
	157	bdrv_iterate(iostatus_bdrv_it, NULL);
	158	bdrv_iterate(encrypted_bdrv_it, &local_err);
	159	if (local_err) {
	160	error_propagate(errp, local_err);
	161	return;
	162	}
	163
	164	vm_start();
	165	}
b4b12c62 AL	166
	167	DevicePropertyInfoList qmp_qom_list(const char path, Error **errp)
	168	{
	169	DeviceState *dev;
	170	bool ambiguous = false;
	171	DevicePropertyInfoList *props = NULL;
	172	DeviceProperty *prop;
	173
	174	dev = qdev_resolve_path(path, &ambiguous);
	175	if (dev == NULL) {
	176	error_set(errp, QERR_DEVICE_NOT_FOUND, path);
	177	return NULL;
	178	}
	179
	180	QTAILQ_FOREACH(prop, &dev->properties, node) {
	181	DevicePropertyInfoList entry = g_malloc0(sizeof(entry));
	182
	183	entry->value = g_malloc0(sizeof(DevicePropertyInfo));
	184	entry->next = props;
	185	props = entry;
	186
	187	entry->value->name = g_strdup(prop->name);
	188	entry->value->type = g_strdup(prop->type);
	189	}
	190
	191	return props;
	192	}
eb6e8ea5 AL	193
	194	/* FIXME: teach qapi about how to pass through Visitors */
	195	int qmp_qom_set(Monitor mon, const QDict qdict, QObject **ret)
	196	{
	197	const char *path = qdict_get_str(qdict, "path");
	198	const char *property = qdict_get_str(qdict, "property");
	199	QObject *value = qdict_get(qdict, "value");
	200	Error *local_err = NULL;
	201	QmpInputVisitor *mi;
	202	DeviceState *dev;
	203
	204	dev = qdev_resolve_path(path, NULL);
	205	if (!dev) {
	206	error_set(&local_err, QERR_DEVICE_NOT_FOUND, path);
	207	goto out;
	208	}
	209
	210	mi = qmp_input_visitor_new(value);
	211	qdev_property_set(dev, qmp_input_get_visitor(mi), property, &local_err);
	212
	213	qmp_input_visitor_cleanup(mi);
	214
	215	out:
	216	if (local_err) {
	217	qerror_report_err(local_err);
	218	error_free(local_err);
	219	return -1;
	220	}
	221
	222	return 0;
	223	}
	224
	225	int qmp_qom_get(Monitor mon, const QDict qdict, QObject **ret)
	226	{
	227	const char *path = qdict_get_str(qdict, "path");
	228	const char *property = qdict_get_str(qdict, "property");
	229	Error *local_err = NULL;
	230	QmpOutputVisitor *mo;
	231	DeviceState *dev;
	232
	233	dev = qdev_resolve_path(path, NULL);
	234	if (!dev) {
	235	error_set(&local_err, QERR_DEVICE_NOT_FOUND, path);
	236	goto out;
	237	}
	238
	239	mo = qmp_output_visitor_new();
	240	qdev_property_get(dev, qmp_output_get_visitor(mo), property, &local_err);
	241	if (!local_err) {
	242	*ret = qmp_output_get_qobject(mo);
	243	}
	244
	245	qmp_output_visitor_cleanup(mo);
	246
	247	out:
	248	if (local_err) {
	249	qerror_report_err(local_err);
	250	error_free(local_err);
	251	return -1;
	252	}
	253
	254	return 0;
	255	}
fbf796fd LC	256
	257	void qmp_set_password(const char protocol, const char password,
	258	bool has_connected, const char connected, Error *errp)
	259	{
	260	int disconnect_if_connected = 0;
	261	int fail_if_connected = 0;
	262	int rc;
	263
	264	if (has_connected) {
	265	if (strcmp(connected, "fail") == 0) {
	266	fail_if_connected = 1;
	267	} else if (strcmp(connected, "disconnect") == 0) {
	268	disconnect_if_connected = 1;
	269	} else if (strcmp(connected, "keep") == 0) {
	270	/* nothing */
	271	} else {
	272	error_set(errp, QERR_INVALID_PARAMETER, "connected");
	273	return;
	274	}
	275	}
	276
	277	if (strcmp(protocol, "spice") == 0) {
	278	if (!using_spice) {
	279	/* correct one? spice isn't a device ,,, */
	280	error_set(errp, QERR_DEVICE_NOT_ACTIVE, "spice");
	281	return;
	282	}
	283	rc = qemu_spice_set_passwd(password, fail_if_connected,
	284	disconnect_if_connected);
	285	if (rc != 0) {
	286	error_set(errp, QERR_SET_PASSWD_FAILED);
	287	}
	288	return;
	289	}
	290
	291	if (strcmp(protocol, "vnc") == 0) {
	292	if (fail_if_connected \|\| disconnect_if_connected) {
	293	/* vnc supports "connected=keep" only */
	294	error_set(errp, QERR_INVALID_PARAMETER, "connected");
	295	return;
	296	}
	297	/* Note that setting an empty password will not disable login through
	298	* this interface. */
	299	rc = vnc_display_password(NULL, password);
	300	if (rc < 0) {
	301	error_set(errp, QERR_SET_PASSWD_FAILED);
	302	}
	303	return;
	304	}
	305
	306	error_set(errp, QERR_INVALID_PARAMETER, "protocol");
	307	}
9ad5372d LC	308
	309	void qmp_expire_password(const char protocol, const char whenstr,
	310	Error **errp)
	311	{
	312	time_t when;
	313	int rc;
	314
	315	if (strcmp(whenstr, "now") == 0) {
	316	when = 0;
	317	} else if (strcmp(whenstr, "never") == 0) {
	318	when = TIME_MAX;
	319	} else if (whenstr[0] == '+') {
	320	when = time(NULL) + strtoull(whenstr+1, NULL, 10);
	321	} else {
	322	when = strtoull(whenstr, NULL, 10);
	323	}
	324
	325	if (strcmp(protocol, "spice") == 0) {
	326	if (!using_spice) {
	327	/* correct one? spice isn't a device ,,, */
	328	error_set(errp, QERR_DEVICE_NOT_ACTIVE, "spice");
	329	return;
	330	}
	331	rc = qemu_spice_set_pw_expire(when);
	332	if (rc != 0) {
	333	error_set(errp, QERR_SET_PASSWD_FAILED);
	334	}
	335	return;
	336	}
	337
	338	if (strcmp(protocol, "vnc") == 0) {
	339	rc = vnc_display_pw_expire(NULL, when);
	340	if (rc != 0) {
	341	error_set(errp, QERR_SET_PASSWD_FAILED);
	342	}
	343	return;
	344	}
	345
	346	error_set(errp, QERR_INVALID_PARAMETER, "protocol");
	347	}
270b243f	348
333a96ec	349	#ifdef CONFIG_VNC
270b243f LC	350	void qmp_change_vnc_password(const char password, Error *errp)
	351	{
	352	if (vnc_display_password(NULL, password) < 0) {
	353	error_set(errp, QERR_SET_PASSWD_FAILED);
	354	}
	355	}
333a96ec LC	356
	357	static void qmp_change_vnc_listen(const char target, Error *err)
	358	{
	359	if (vnc_display_open(NULL, target) < 0) {
	360	error_set(err, QERR_VNC_SERVER_FAILED, target);
	361	}
	362	}
	363
	364	static void qmp_change_vnc(const char target, bool has_arg, const char arg,
	365	Error **errp)
	366	{
	367	if (strcmp(target, "passwd") == 0 \|\| strcmp(target, "password") == 0) {
	368	if (!has_arg) {
	369	error_set(errp, QERR_MISSING_PARAMETER, "password");
	370	} else {
	371	qmp_change_vnc_password(arg, errp);
	372	}
	373	} else {
	374	qmp_change_vnc_listen(target, errp);
	375	}
	376	}
	377	#else
	378	void qmp_change_vnc_password(const char password, Error *errp)
	379	{
	380	error_set(errp, QERR_FEATURE_DISABLED, "vnc");
	381	}
	382	static void qmp_change_vnc(const char target, bool has_arg, const char arg,
	383	Error **errp)
	384	{
	385	error_set(errp, QERR_FEATURE_DISABLED, "vnc");
	386	}
	387	#endif /* !CONFIG_VNC */
	388
	389	void qmp_change(const char device, const char target,
	390	bool has_arg, const char arg, Error *err)
	391	{
	392	if (strcmp(device, "vnc") == 0) {
	393	qmp_change_vnc(target, has_arg, arg, err);
	394	} else {
	395	qmp_change_blockdev(device, target, has_arg, arg, err);
	396	}
	397	}