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

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
57c9fafe	166	ObjectPropertyInfoList qmp_qom_list(const char path, Error **errp)
b4b12c62	167	{
57c9fafe	168	Object *obj;
b4b12c62	169	bool ambiguous = false;
57c9fafe AL	170	ObjectPropertyInfoList *props = NULL;
57c9fafe AL	171	ObjectProperty *prop;
b4b12c62	172
57c9fafe AL	173	obj = object_resolve_path(path, &ambiguous);
57c9fafe AL	174	if (obj == NULL) {
b4b12c62 AL	175	error_set(errp, QERR_DEVICE_NOT_FOUND, path);
	176	return NULL;
	177	}
	178
57c9fafe AL	179	QTAILQ_FOREACH(prop, &obj->properties, node) {
57c9fafe AL	180	ObjectPropertyInfoList entry = g_malloc0(sizeof(entry));
b4b12c62	181
57c9fafe	182	entry->value = g_malloc0(sizeof(ObjectPropertyInfo));
b4b12c62 AL	183	entry->next = props;
	184	props = entry;
	185
	186	entry->value->name = g_strdup(prop->name);
	187	entry->value->type = g_strdup(prop->type);
	188	}
	189
	190	return props;
	191	}
eb6e8ea5 AL	192
	193	/* FIXME: teach qapi about how to pass through Visitors */
	194	int qmp_qom_set(Monitor mon, const QDict qdict, QObject **ret)
	195	{
	196	const char *path = qdict_get_str(qdict, "path");
	197	const char *property = qdict_get_str(qdict, "property");
	198	QObject *value = qdict_get(qdict, "value");
	199	Error *local_err = NULL;
57c9fafe	200	Object *obj;
eb6e8ea5	201
57c9fafe AL	202	obj = object_resolve_path(path, NULL);
57c9fafe AL	203	if (!obj) {
eb6e8ea5 AL	204	error_set(&local_err, QERR_DEVICE_NOT_FOUND, path);
	205	goto out;
	206	}
	207
9f5f1350	208	object_property_set_qobject(obj, value, property, &local_err);
eb6e8ea5 AL	209
	210	out:
	211	if (local_err) {
	212	qerror_report_err(local_err);
	213	error_free(local_err);
	214	return -1;
	215	}
	216
	217	return 0;
	218	}
	219
	220	int qmp_qom_get(Monitor mon, const QDict qdict, QObject **ret)
	221	{
	222	const char *path = qdict_get_str(qdict, "path");
	223	const char *property = qdict_get_str(qdict, "property");
	224	Error *local_err = NULL;
57c9fafe	225	Object *obj;
eb6e8ea5	226
57c9fafe AL	227	obj = object_resolve_path(path, NULL);
57c9fafe AL	228	if (!obj) {
eb6e8ea5 AL	229	error_set(&local_err, QERR_DEVICE_NOT_FOUND, path);
	230	goto out;
	231	}
	232
9f5f1350	233	*ret = object_property_get_qobject(obj, property, &local_err);
eb6e8ea5 AL	234
	235	out:
	236	if (local_err) {
	237	qerror_report_err(local_err);
	238	error_free(local_err);
	239	return -1;
	240	}
	241
	242	return 0;
	243	}
fbf796fd LC	244
	245	void qmp_set_password(const char protocol, const char password,
	246	bool has_connected, const char connected, Error *errp)
	247	{
	248	int disconnect_if_connected = 0;
	249	int fail_if_connected = 0;
	250	int rc;
	251
	252	if (has_connected) {
	253	if (strcmp(connected, "fail") == 0) {
	254	fail_if_connected = 1;
	255	} else if (strcmp(connected, "disconnect") == 0) {
	256	disconnect_if_connected = 1;
	257	} else if (strcmp(connected, "keep") == 0) {
	258	/* nothing */
	259	} else {
	260	error_set(errp, QERR_INVALID_PARAMETER, "connected");
	261	return;
	262	}
	263	}
	264
	265	if (strcmp(protocol, "spice") == 0) {
	266	if (!using_spice) {
	267	/* correct one? spice isn't a device ,,, */
	268	error_set(errp, QERR_DEVICE_NOT_ACTIVE, "spice");
	269	return;
	270	}
	271	rc = qemu_spice_set_passwd(password, fail_if_connected,
	272	disconnect_if_connected);
	273	if (rc != 0) {
	274	error_set(errp, QERR_SET_PASSWD_FAILED);
	275	}
	276	return;
	277	}
	278
	279	if (strcmp(protocol, "vnc") == 0) {
	280	if (fail_if_connected \|\| disconnect_if_connected) {
	281	/* vnc supports "connected=keep" only */
	282	error_set(errp, QERR_INVALID_PARAMETER, "connected");
	283	return;
	284	}
	285	/* Note that setting an empty password will not disable login through
	286	* this interface. */
	287	rc = vnc_display_password(NULL, password);
	288	if (rc < 0) {
	289	error_set(errp, QERR_SET_PASSWD_FAILED);
	290	}
	291	return;
	292	}
	293
	294	error_set(errp, QERR_INVALID_PARAMETER, "protocol");
	295	}
9ad5372d LC	296
	297	void qmp_expire_password(const char protocol, const char whenstr,
	298	Error **errp)
	299	{
	300	time_t when;
	301	int rc;
	302
	303	if (strcmp(whenstr, "now") == 0) {
	304	when = 0;
	305	} else if (strcmp(whenstr, "never") == 0) {
	306	when = TIME_MAX;
	307	} else if (whenstr[0] == '+') {
	308	when = time(NULL) + strtoull(whenstr+1, NULL, 10);
	309	} else {
	310	when = strtoull(whenstr, NULL, 10);
	311	}
	312
	313	if (strcmp(protocol, "spice") == 0) {
	314	if (!using_spice) {
	315	/* correct one? spice isn't a device ,,, */
	316	error_set(errp, QERR_DEVICE_NOT_ACTIVE, "spice");
	317	return;
	318	}
	319	rc = qemu_spice_set_pw_expire(when);
	320	if (rc != 0) {
	321	error_set(errp, QERR_SET_PASSWD_FAILED);
	322	}
	323	return;
	324	}
	325
	326	if (strcmp(protocol, "vnc") == 0) {
	327	rc = vnc_display_pw_expire(NULL, when);
	328	if (rc != 0) {
	329	error_set(errp, QERR_SET_PASSWD_FAILED);
	330	}
	331	return;
	332	}
	333
	334	error_set(errp, QERR_INVALID_PARAMETER, "protocol");
	335	}
270b243f	336
333a96ec	337	#ifdef CONFIG_VNC
270b243f LC	338	void qmp_change_vnc_password(const char password, Error *errp)
	339	{
	340	if (vnc_display_password(NULL, password) < 0) {
	341	error_set(errp, QERR_SET_PASSWD_FAILED);
	342	}
	343	}
333a96ec LC	344
	345	static void qmp_change_vnc_listen(const char target, Error *err)
	346	{
	347	if (vnc_display_open(NULL, target) < 0) {
	348	error_set(err, QERR_VNC_SERVER_FAILED, target);
	349	}
	350	}
	351
	352	static void qmp_change_vnc(const char target, bool has_arg, const char arg,
	353	Error **errp)
	354	{
	355	if (strcmp(target, "passwd") == 0 \|\| strcmp(target, "password") == 0) {
	356	if (!has_arg) {
	357	error_set(errp, QERR_MISSING_PARAMETER, "password");
	358	} else {
	359	qmp_change_vnc_password(arg, errp);
	360	}
	361	} else {
	362	qmp_change_vnc_listen(target, errp);
	363	}
	364	}
	365	#else
	366	void qmp_change_vnc_password(const char password, Error *errp)
	367	{
	368	error_set(errp, QERR_FEATURE_DISABLED, "vnc");
	369	}
	370	static void qmp_change_vnc(const char target, bool has_arg, const char arg,
	371	Error **errp)
	372	{
	373	error_set(errp, QERR_FEATURE_DISABLED, "vnc");
	374	}
	375	#endif /* !CONFIG_VNC */
	376
	377	void qmp_change(const char device, const char target,
	378	bool has_arg, const char arg, Error *err)
	379	{
	380	if (strcmp(device, "vnc") == 0) {
	381	qmp_change_vnc(target, has_arg, arg, err);
	382	} else {
	383	qmp_change_blockdev(device, target, has_arg, arg, err);
	384	}
	385	}
5eeee3fa AL	386
	387	static void qom_list_types_tramp(ObjectClass klass, void data)
	388	{
	389	ObjectTypeInfoList e, *pret = data;
	390	ObjectTypeInfo *info;
	391
	392	info = g_malloc0(sizeof(*info));
	393	info->name = g_strdup(object_class_get_name(klass));
	394
	395	e = g_malloc0(sizeof(*e));
	396	e->value = info;
	397	e->next = *pret;
	398	*pret = e;
	399	}
	400
	401	ObjectTypeInfoList *qmp_qom_list_types(bool has_implements,
	402	const char *implements,
	403	bool has_abstract,
	404	bool abstract,
	405	Error **errp)
	406	{
	407	ObjectTypeInfoList *ret = NULL;
	408
	409	object_class_foreach(qom_list_types_tramp, implements, abstract, &ret);
	410
	411	return ret;
	412	}