[mirror_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 "blockdev.h"
#include "qemu/qom-qobject.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();
}

void qmp_system_wakeup(Error **errp)
{
    qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER);
}

ObjectPropertyInfoList *qmp_qom_list(const char *path, Error **errp)
{
    Object *obj;
    bool ambiguous = false;
    ObjectPropertyInfoList *props = NULL;
    ObjectProperty *prop;

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

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

        entry->value = g_malloc0(sizeof(ObjectPropertyInfo));
        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;
    Object *obj;

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

    object_property_set_qobject(obj, value, property, &local_err);

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;
    Object *obj;

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

    *ret = object_property_get_qobject(obj, property, &local_err);

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);
    }
}

static void qom_list_types_tramp(ObjectClass *klass, void *data)
{
    ObjectTypeInfoList *e, **pret = data;
    ObjectTypeInfo *info;

    info = g_malloc0(sizeof(*info));
    info->name = g_strdup(object_class_get_name(klass));

    e = g_malloc0(sizeof(*e));
    e->value = info;
    e->next = *pret;
    *pret = e;
}

ObjectTypeInfoList *qmp_qom_list_types(bool has_implements,
                                       const char *implements,
                                       bool has_abstract,
                                       bool abstract,
                                       Error **errp)
{
    ObjectTypeInfoList *ret = NULL;

    object_class_foreach(qom_list_types_tramp, implements, abstract, &ret);

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