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