2010-03-11 15:13:27 +01:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2010 Red Hat, Inc.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License as
|
|
|
|
* published by the Free Software Foundation; either version 2 or
|
|
|
|
* (at your option) version 3 of the License.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
2016-01-29 18:49:51 +01:00
|
|
|
#include "qemu/osdep.h"
|
2010-03-11 15:13:27 +01:00
|
|
|
#include <spice.h>
|
|
|
|
|
2010-10-11 18:03:51 +02:00
|
|
|
#include <netdb.h>
|
2012-12-17 18:20:04 +01:00
|
|
|
#include "sysemu/sysemu.h"
|
2010-10-11 18:03:51 +02:00
|
|
|
|
2010-03-11 15:13:27 +01:00
|
|
|
#include "qemu-common.h"
|
2012-11-28 12:06:30 +01:00
|
|
|
#include "ui/qemu-spice.h"
|
2015-03-17 18:29:20 +01:00
|
|
|
#include "qemu/error-report.h"
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/thread.h"
|
|
|
|
#include "qemu/timer.h"
|
|
|
|
#include "qemu/queue.h"
|
2010-03-11 15:13:32 +01:00
|
|
|
#include "qemu-x509.h"
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/sockets.h"
|
2011-10-20 21:01:33 +02:00
|
|
|
#include "qmp-commands.h"
|
2012-12-17 18:19:43 +01:00
|
|
|
#include "qapi/qmp/qint.h"
|
|
|
|
#include "qapi/qmp/qbool.h"
|
|
|
|
#include "qapi/qmp/qstring.h"
|
|
|
|
#include "qapi/qmp/qjson.h"
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/notify.h"
|
2012-12-17 18:19:50 +01:00
|
|
|
#include "migration/migration.h"
|
2010-04-23 13:28:21 +02:00
|
|
|
#include "hw/hw.h"
|
2012-11-28 12:06:30 +01:00
|
|
|
#include "ui/spice-display.h"
|
2014-06-18 08:43:50 +02:00
|
|
|
#include "qapi-event.h"
|
2010-03-11 15:13:27 +01:00
|
|
|
|
|
|
|
/* core bits */
|
|
|
|
|
|
|
|
static SpiceServer *spice_server;
|
2010-04-23 13:28:21 +02:00
|
|
|
static Notifier migration_state;
|
2010-10-11 18:03:51 +02:00
|
|
|
static const char *auth = "spice";
|
2010-10-07 12:22:54 +02:00
|
|
|
static char *auth_passwd;
|
|
|
|
static time_t auth_expires = TIME_MAX;
|
2012-08-21 10:51:58 +02:00
|
|
|
static int spice_migration_completed;
|
2013-12-09 15:54:46 +01:00
|
|
|
static int spice_display_is_running;
|
2014-04-29 09:27:31 +02:00
|
|
|
static int spice_have_target_host;
|
2010-03-11 15:13:27 +01:00
|
|
|
int using_spice = 0;
|
|
|
|
|
2011-09-20 17:14:33 +02:00
|
|
|
static QemuThread me;
|
2011-09-02 15:03:28 +02:00
|
|
|
|
2010-03-11 15:13:27 +01:00
|
|
|
struct SpiceTimer {
|
|
|
|
QEMUTimer *timer;
|
|
|
|
QTAILQ_ENTRY(SpiceTimer) next;
|
|
|
|
};
|
|
|
|
static QTAILQ_HEAD(, SpiceTimer) timers = QTAILQ_HEAD_INITIALIZER(timers);
|
|
|
|
|
|
|
|
static SpiceTimer *timer_add(SpiceTimerFunc func, void *opaque)
|
|
|
|
{
|
|
|
|
SpiceTimer *timer;
|
|
|
|
|
2011-08-21 05:09:37 +02:00
|
|
|
timer = g_malloc0(sizeof(*timer));
|
2013-08-21 17:03:08 +02:00
|
|
|
timer->timer = timer_new_ms(QEMU_CLOCK_REALTIME, func, opaque);
|
2010-03-11 15:13:27 +01:00
|
|
|
QTAILQ_INSERT_TAIL(&timers, timer, next);
|
|
|
|
return timer;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void timer_start(SpiceTimer *timer, uint32_t ms)
|
|
|
|
{
|
2013-08-21 17:03:08 +02:00
|
|
|
timer_mod(timer->timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + ms);
|
2010-03-11 15:13:27 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void timer_cancel(SpiceTimer *timer)
|
|
|
|
{
|
2013-08-21 17:03:08 +02:00
|
|
|
timer_del(timer->timer);
|
2010-03-11 15:13:27 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void timer_remove(SpiceTimer *timer)
|
|
|
|
{
|
2013-08-21 17:03:08 +02:00
|
|
|
timer_del(timer->timer);
|
|
|
|
timer_free(timer->timer);
|
2010-03-11 15:13:27 +01:00
|
|
|
QTAILQ_REMOVE(&timers, timer, next);
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free(timer);
|
2010-03-11 15:13:27 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
struct SpiceWatch {
|
|
|
|
int fd;
|
|
|
|
int event_mask;
|
|
|
|
SpiceWatchFunc func;
|
|
|
|
void *opaque;
|
|
|
|
QTAILQ_ENTRY(SpiceWatch) next;
|
|
|
|
};
|
|
|
|
static QTAILQ_HEAD(, SpiceWatch) watches = QTAILQ_HEAD_INITIALIZER(watches);
|
|
|
|
|
|
|
|
static void watch_read(void *opaque)
|
|
|
|
{
|
|
|
|
SpiceWatch *watch = opaque;
|
|
|
|
watch->func(watch->fd, SPICE_WATCH_EVENT_READ, watch->opaque);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void watch_write(void *opaque)
|
|
|
|
{
|
|
|
|
SpiceWatch *watch = opaque;
|
|
|
|
watch->func(watch->fd, SPICE_WATCH_EVENT_WRITE, watch->opaque);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void watch_update_mask(SpiceWatch *watch, int event_mask)
|
|
|
|
{
|
|
|
|
IOHandler *on_read = NULL;
|
|
|
|
IOHandler *on_write = NULL;
|
|
|
|
|
|
|
|
watch->event_mask = event_mask;
|
|
|
|
if (watch->event_mask & SPICE_WATCH_EVENT_READ) {
|
|
|
|
on_read = watch_read;
|
|
|
|
}
|
|
|
|
if (watch->event_mask & SPICE_WATCH_EVENT_WRITE) {
|
2010-10-15 09:47:53 +02:00
|
|
|
on_write = watch_write;
|
2010-03-11 15:13:27 +01:00
|
|
|
}
|
|
|
|
qemu_set_fd_handler(watch->fd, on_read, on_write, watch);
|
|
|
|
}
|
|
|
|
|
|
|
|
static SpiceWatch *watch_add(int fd, int event_mask, SpiceWatchFunc func, void *opaque)
|
|
|
|
{
|
|
|
|
SpiceWatch *watch;
|
|
|
|
|
2011-08-21 05:09:37 +02:00
|
|
|
watch = g_malloc0(sizeof(*watch));
|
2010-03-11 15:13:27 +01:00
|
|
|
watch->fd = fd;
|
|
|
|
watch->func = func;
|
|
|
|
watch->opaque = opaque;
|
|
|
|
QTAILQ_INSERT_TAIL(&watches, watch, next);
|
|
|
|
|
|
|
|
watch_update_mask(watch, event_mask);
|
|
|
|
return watch;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void watch_remove(SpiceWatch *watch)
|
|
|
|
{
|
2011-10-21 15:56:21 +02:00
|
|
|
qemu_set_fd_handler(watch->fd, NULL, NULL, NULL);
|
2010-03-11 15:13:27 +01:00
|
|
|
QTAILQ_REMOVE(&watches, watch, next);
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free(watch);
|
2010-03-11 15:13:27 +01:00
|
|
|
}
|
|
|
|
|
2010-11-30 11:02:51 +01:00
|
|
|
typedef struct ChannelList ChannelList;
|
|
|
|
struct ChannelList {
|
|
|
|
SpiceChannelEventInfo *info;
|
|
|
|
QTAILQ_ENTRY(ChannelList) link;
|
|
|
|
};
|
|
|
|
static QTAILQ_HEAD(, ChannelList) channel_list = QTAILQ_HEAD_INITIALIZER(channel_list);
|
|
|
|
|
|
|
|
static void channel_list_add(SpiceChannelEventInfo *info)
|
|
|
|
{
|
|
|
|
ChannelList *item;
|
|
|
|
|
2011-08-21 05:09:37 +02:00
|
|
|
item = g_malloc0(sizeof(*item));
|
2010-11-30 11:02:51 +01:00
|
|
|
item->info = info;
|
|
|
|
QTAILQ_INSERT_TAIL(&channel_list, item, link);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void channel_list_del(SpiceChannelEventInfo *info)
|
|
|
|
{
|
|
|
|
ChannelList *item;
|
|
|
|
|
|
|
|
QTAILQ_FOREACH(item, &channel_list, link) {
|
|
|
|
if (item->info != info) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
QTAILQ_REMOVE(&channel_list, item, link);
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free(item);
|
2010-11-30 11:02:51 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-18 08:43:50 +02:00
|
|
|
static void add_addr_info(SpiceBasicInfo *info, struct sockaddr *addr, int len)
|
2010-10-11 18:03:51 +02:00
|
|
|
{
|
|
|
|
char host[NI_MAXHOST], port[NI_MAXSERV];
|
|
|
|
|
|
|
|
getnameinfo(addr, len, host, sizeof(host), port, sizeof(port),
|
|
|
|
NI_NUMERICHOST | NI_NUMERICSERV);
|
|
|
|
|
2014-06-18 08:43:50 +02:00
|
|
|
info->host = g_strdup(host);
|
|
|
|
info->port = g_strdup(port);
|
|
|
|
info->family = inet_netfamily(addr->sa_family);
|
2010-10-11 18:03:51 +02:00
|
|
|
}
|
|
|
|
|
2014-06-18 08:43:50 +02:00
|
|
|
static void add_channel_info(SpiceChannel *sc, SpiceChannelEventInfo *info)
|
2010-10-11 18:03:51 +02:00
|
|
|
{
|
|
|
|
int tls = info->flags & SPICE_CHANNEL_EVENT_FLAG_TLS;
|
|
|
|
|
2014-06-18 08:43:50 +02:00
|
|
|
sc->connection_id = info->connection_id;
|
|
|
|
sc->channel_type = info->type;
|
|
|
|
sc->channel_id = info->id;
|
|
|
|
sc->tls = !!tls;
|
2010-10-11 18:03:51 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void channel_event(int event, SpiceChannelEventInfo *info)
|
|
|
|
{
|
2014-06-18 08:43:50 +02:00
|
|
|
SpiceServerInfo *server = g_malloc0(sizeof(*server));
|
|
|
|
SpiceChannel *client = g_malloc0(sizeof(*client));
|
2010-10-11 18:03:51 +02:00
|
|
|
|
2011-09-02 15:03:28 +02:00
|
|
|
/*
|
|
|
|
* Spice server might have called us from spice worker thread
|
|
|
|
* context (happens on display channel disconnects). Spice should
|
|
|
|
* not do that. It isn't that easy to fix it in spice and even
|
|
|
|
* when it is fixed we still should cover the already released
|
|
|
|
* spice versions. So detect that we've been called from another
|
|
|
|
* thread and grab the iothread lock if so before calling qemu
|
|
|
|
* functions.
|
|
|
|
*/
|
2011-09-20 17:14:33 +02:00
|
|
|
bool need_lock = !qemu_thread_is_self(&me);
|
2011-09-02 15:03:28 +02:00
|
|
|
if (need_lock) {
|
|
|
|
qemu_mutex_lock_iothread();
|
|
|
|
}
|
|
|
|
|
2012-02-08 14:40:15 +01:00
|
|
|
if (info->flags & SPICE_CHANNEL_EVENT_FLAG_ADDR_EXT) {
|
qapi: Unbox base members
Rather than storing a base class as a pointer to a box, just
store the fields of that base class in the same order, so that
a child struct can be directly cast to its parent. This gives
less malloc overhead, less pointer dereferencing, and even less
generated code. Compare to the earlier commit 1e6c1616a "qapi:
Generate a nicer struct for flat unions" (although that patch
had fewer places to change, as less of qemu was directly using
qapi structs for flat unions). It also allows us to turn on
automatic type-safe wrappers for upcasting to the base class
of a struct.
Changes to the generated code look like this in qapi-types.h:
| struct SpiceChannel {
|- SpiceBasicInfo *base;
|+ /* Members inherited from SpiceBasicInfo: */
|+ char *host;
|+ char *port;
|+ NetworkAddressFamily family;
|+ /* Own members: */
| int64_t connection_id;
as well as additional upcast functions like qapi_SpiceChannel_base().
Meanwhile, changes to qapi-visit.c look like:
| static void visit_type_SpiceChannel_fields(Visitor *v, SpiceChannel **obj, Error **errp)
| {
| Error *err = NULL;
|
|- visit_type_implicit_SpiceBasicInfo(v, &(*obj)->base, &err);
|+ visit_type_SpiceBasicInfo_fields(v, (SpiceBasicInfo **)obj, &err);
| if (err) {
(the cast is necessary, since our upcast wrappers only deal with a
single pointer, not pointer-to-pointer); plus the wholesale
elimination of some now-unused visit_type_implicit_FOO() functions.
Without boxing, the corner case of one empty struct having
another empty struct as its base type now requires inserting a
dummy member (previously, the 'Base *base' member sufficed).
And now that we no longer consume a 'base' member in the generated
C struct, we can delete the former negative struct-base-clash-base
test.
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1445898903-12082-11-git-send-email-eblake@redhat.com>
[Commit message tweaked slightly]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2015-10-26 23:34:49 +01:00
|
|
|
add_addr_info(qapi_SpiceChannel_base(client),
|
|
|
|
(struct sockaddr *)&info->paddr_ext,
|
2012-02-08 14:40:15 +01:00
|
|
|
info->plen_ext);
|
qapi: Unbox base members
Rather than storing a base class as a pointer to a box, just
store the fields of that base class in the same order, so that
a child struct can be directly cast to its parent. This gives
less malloc overhead, less pointer dereferencing, and even less
generated code. Compare to the earlier commit 1e6c1616a "qapi:
Generate a nicer struct for flat unions" (although that patch
had fewer places to change, as less of qemu was directly using
qapi structs for flat unions). It also allows us to turn on
automatic type-safe wrappers for upcasting to the base class
of a struct.
Changes to the generated code look like this in qapi-types.h:
| struct SpiceChannel {
|- SpiceBasicInfo *base;
|+ /* Members inherited from SpiceBasicInfo: */
|+ char *host;
|+ char *port;
|+ NetworkAddressFamily family;
|+ /* Own members: */
| int64_t connection_id;
as well as additional upcast functions like qapi_SpiceChannel_base().
Meanwhile, changes to qapi-visit.c look like:
| static void visit_type_SpiceChannel_fields(Visitor *v, SpiceChannel **obj, Error **errp)
| {
| Error *err = NULL;
|
|- visit_type_implicit_SpiceBasicInfo(v, &(*obj)->base, &err);
|+ visit_type_SpiceBasicInfo_fields(v, (SpiceBasicInfo **)obj, &err);
| if (err) {
(the cast is necessary, since our upcast wrappers only deal with a
single pointer, not pointer-to-pointer); plus the wholesale
elimination of some now-unused visit_type_implicit_FOO() functions.
Without boxing, the corner case of one empty struct having
another empty struct as its base type now requires inserting a
dummy member (previously, the 'Base *base' member sufficed).
And now that we no longer consume a 'base' member in the generated
C struct, we can delete the former negative struct-base-clash-base
test.
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1445898903-12082-11-git-send-email-eblake@redhat.com>
[Commit message tweaked slightly]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2015-10-26 23:34:49 +01:00
|
|
|
add_addr_info(qapi_SpiceServerInfo_base(server),
|
|
|
|
(struct sockaddr *)&info->laddr_ext,
|
2012-02-08 14:40:15 +01:00
|
|
|
info->llen_ext);
|
|
|
|
} else {
|
2012-02-24 18:13:12 +01:00
|
|
|
error_report("spice: %s, extended address is expected",
|
|
|
|
__func__);
|
2012-02-08 14:40:15 +01:00
|
|
|
}
|
2010-10-11 18:03:51 +02:00
|
|
|
|
2014-06-18 08:43:50 +02:00
|
|
|
switch (event) {
|
|
|
|
case SPICE_CHANNEL_EVENT_CONNECTED:
|
qapi: Unbox base members
Rather than storing a base class as a pointer to a box, just
store the fields of that base class in the same order, so that
a child struct can be directly cast to its parent. This gives
less malloc overhead, less pointer dereferencing, and even less
generated code. Compare to the earlier commit 1e6c1616a "qapi:
Generate a nicer struct for flat unions" (although that patch
had fewer places to change, as less of qemu was directly using
qapi structs for flat unions). It also allows us to turn on
automatic type-safe wrappers for upcasting to the base class
of a struct.
Changes to the generated code look like this in qapi-types.h:
| struct SpiceChannel {
|- SpiceBasicInfo *base;
|+ /* Members inherited from SpiceBasicInfo: */
|+ char *host;
|+ char *port;
|+ NetworkAddressFamily family;
|+ /* Own members: */
| int64_t connection_id;
as well as additional upcast functions like qapi_SpiceChannel_base().
Meanwhile, changes to qapi-visit.c look like:
| static void visit_type_SpiceChannel_fields(Visitor *v, SpiceChannel **obj, Error **errp)
| {
| Error *err = NULL;
|
|- visit_type_implicit_SpiceBasicInfo(v, &(*obj)->base, &err);
|+ visit_type_SpiceBasicInfo_fields(v, (SpiceBasicInfo **)obj, &err);
| if (err) {
(the cast is necessary, since our upcast wrappers only deal with a
single pointer, not pointer-to-pointer); plus the wholesale
elimination of some now-unused visit_type_implicit_FOO() functions.
Without boxing, the corner case of one empty struct having
another empty struct as its base type now requires inserting a
dummy member (previously, the 'Base *base' member sufficed).
And now that we no longer consume a 'base' member in the generated
C struct, we can delete the former negative struct-base-clash-base
test.
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1445898903-12082-11-git-send-email-eblake@redhat.com>
[Commit message tweaked slightly]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2015-10-26 23:34:49 +01:00
|
|
|
qapi_event_send_spice_connected(qapi_SpiceServerInfo_base(server),
|
|
|
|
qapi_SpiceChannel_base(client),
|
|
|
|
&error_abort);
|
2014-06-18 08:43:50 +02:00
|
|
|
break;
|
|
|
|
case SPICE_CHANNEL_EVENT_INITIALIZED:
|
|
|
|
if (auth) {
|
|
|
|
server->has_auth = true;
|
|
|
|
server->auth = g_strdup(auth);
|
|
|
|
}
|
2010-10-11 18:03:51 +02:00
|
|
|
add_channel_info(client, info);
|
2010-11-30 11:02:51 +01:00
|
|
|
channel_list_add(info);
|
2014-06-18 08:43:50 +02:00
|
|
|
qapi_event_send_spice_initialized(server, client, &error_abort);
|
|
|
|
break;
|
|
|
|
case SPICE_CHANNEL_EVENT_DISCONNECTED:
|
2010-11-30 11:02:51 +01:00
|
|
|
channel_list_del(info);
|
qapi: Unbox base members
Rather than storing a base class as a pointer to a box, just
store the fields of that base class in the same order, so that
a child struct can be directly cast to its parent. This gives
less malloc overhead, less pointer dereferencing, and even less
generated code. Compare to the earlier commit 1e6c1616a "qapi:
Generate a nicer struct for flat unions" (although that patch
had fewer places to change, as less of qemu was directly using
qapi structs for flat unions). It also allows us to turn on
automatic type-safe wrappers for upcasting to the base class
of a struct.
Changes to the generated code look like this in qapi-types.h:
| struct SpiceChannel {
|- SpiceBasicInfo *base;
|+ /* Members inherited from SpiceBasicInfo: */
|+ char *host;
|+ char *port;
|+ NetworkAddressFamily family;
|+ /* Own members: */
| int64_t connection_id;
as well as additional upcast functions like qapi_SpiceChannel_base().
Meanwhile, changes to qapi-visit.c look like:
| static void visit_type_SpiceChannel_fields(Visitor *v, SpiceChannel **obj, Error **errp)
| {
| Error *err = NULL;
|
|- visit_type_implicit_SpiceBasicInfo(v, &(*obj)->base, &err);
|+ visit_type_SpiceBasicInfo_fields(v, (SpiceBasicInfo **)obj, &err);
| if (err) {
(the cast is necessary, since our upcast wrappers only deal with a
single pointer, not pointer-to-pointer); plus the wholesale
elimination of some now-unused visit_type_implicit_FOO() functions.
Without boxing, the corner case of one empty struct having
another empty struct as its base type now requires inserting a
dummy member (previously, the 'Base *base' member sufficed).
And now that we no longer consume a 'base' member in the generated
C struct, we can delete the former negative struct-base-clash-base
test.
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1445898903-12082-11-git-send-email-eblake@redhat.com>
[Commit message tweaked slightly]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2015-10-26 23:34:49 +01:00
|
|
|
qapi_event_send_spice_disconnected(qapi_SpiceServerInfo_base(server),
|
|
|
|
qapi_SpiceChannel_base(client),
|
|
|
|
&error_abort);
|
2014-06-18 08:43:50 +02:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
2010-10-11 18:03:51 +02:00
|
|
|
}
|
|
|
|
|
2011-09-02 15:03:28 +02:00
|
|
|
if (need_lock) {
|
|
|
|
qemu_mutex_unlock_iothread();
|
|
|
|
}
|
2014-06-18 08:43:50 +02:00
|
|
|
|
|
|
|
qapi_free_SpiceServerInfo(server);
|
|
|
|
qapi_free_SpiceChannel(client);
|
2010-10-11 18:03:51 +02:00
|
|
|
}
|
|
|
|
|
2010-03-11 15:13:27 +01:00
|
|
|
static SpiceCoreInterface core_interface = {
|
|
|
|
.base.type = SPICE_INTERFACE_CORE,
|
|
|
|
.base.description = "qemu core services",
|
|
|
|
.base.major_version = SPICE_INTERFACE_CORE_MAJOR,
|
|
|
|
.base.minor_version = SPICE_INTERFACE_CORE_MINOR,
|
|
|
|
|
|
|
|
.timer_add = timer_add,
|
|
|
|
.timer_start = timer_start,
|
|
|
|
.timer_cancel = timer_cancel,
|
|
|
|
.timer_remove = timer_remove,
|
|
|
|
|
|
|
|
.watch_add = watch_add,
|
|
|
|
.watch_update_mask = watch_update_mask,
|
|
|
|
.watch_remove = watch_remove,
|
2010-10-11 18:03:51 +02:00
|
|
|
|
|
|
|
.channel_event = channel_event,
|
2010-03-11 15:13:27 +01:00
|
|
|
};
|
|
|
|
|
2011-10-17 10:03:19 +02:00
|
|
|
static void migrate_connect_complete_cb(SpiceMigrateInstance *sin);
|
2012-08-21 10:51:57 +02:00
|
|
|
static void migrate_end_complete_cb(SpiceMigrateInstance *sin);
|
2011-10-17 10:03:19 +02:00
|
|
|
|
|
|
|
static const SpiceMigrateInterface migrate_interface = {
|
|
|
|
.base.type = SPICE_INTERFACE_MIGRATION,
|
|
|
|
.base.description = "migration",
|
|
|
|
.base.major_version = SPICE_INTERFACE_MIGRATION_MAJOR,
|
|
|
|
.base.minor_version = SPICE_INTERFACE_MIGRATION_MINOR,
|
|
|
|
.migrate_connect_complete = migrate_connect_complete_cb,
|
2012-08-21 10:51:57 +02:00
|
|
|
.migrate_end_complete = migrate_end_complete_cb,
|
2011-10-17 10:03:19 +02:00
|
|
|
};
|
|
|
|
|
2015-03-05 09:30:16 +01:00
|
|
|
static SpiceMigrateInstance spice_migrate;
|
2011-10-17 10:03:19 +02:00
|
|
|
|
|
|
|
static void migrate_connect_complete_cb(SpiceMigrateInstance *sin)
|
|
|
|
{
|
2015-03-05 09:30:16 +01:00
|
|
|
/* nothing, but libspice-server expects this cb being present. */
|
2011-10-17 10:03:19 +02:00
|
|
|
}
|
2012-08-21 10:51:57 +02:00
|
|
|
|
|
|
|
static void migrate_end_complete_cb(SpiceMigrateInstance *sin)
|
|
|
|
{
|
2014-06-18 08:43:50 +02:00
|
|
|
qapi_event_send_spice_migrate_completed(&error_abort);
|
2012-08-21 10:51:58 +02:00
|
|
|
spice_migration_completed = true;
|
2012-08-21 10:51:57 +02:00
|
|
|
}
|
2011-10-17 10:03:19 +02:00
|
|
|
|
2010-07-14 12:26:34 +02:00
|
|
|
/* config string parsing */
|
|
|
|
|
|
|
|
static int name2enum(const char *string, const char *table[], int entries)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (string) {
|
|
|
|
for (i = 0; i < entries; i++) {
|
|
|
|
if (!table[i]) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (strcmp(string, table[i]) != 0) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int parse_name(const char *string, const char *optname,
|
|
|
|
const char *table[], int entries)
|
|
|
|
{
|
|
|
|
int value = name2enum(string, table, entries);
|
|
|
|
|
|
|
|
if (value != -1) {
|
|
|
|
return value;
|
|
|
|
}
|
2012-02-24 18:13:12 +01:00
|
|
|
error_report("spice: invalid %s: %s", optname, string);
|
2010-07-14 12:26:34 +02:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
2010-08-30 16:36:53 +02:00
|
|
|
static const char *stream_video_names[] = {
|
|
|
|
[ SPICE_STREAM_VIDEO_OFF ] = "off",
|
|
|
|
[ SPICE_STREAM_VIDEO_ALL ] = "all",
|
|
|
|
[ SPICE_STREAM_VIDEO_FILTER ] = "filter",
|
|
|
|
};
|
|
|
|
#define parse_stream_video(_name) \
|
2012-08-13 10:32:32 +02:00
|
|
|
parse_name(_name, "stream video control", \
|
|
|
|
stream_video_names, ARRAY_SIZE(stream_video_names))
|
2010-08-30 16:36:53 +02:00
|
|
|
|
2010-07-14 12:26:34 +02:00
|
|
|
static const char *compression_names[] = {
|
|
|
|
[ SPICE_IMAGE_COMPRESS_OFF ] = "off",
|
|
|
|
[ SPICE_IMAGE_COMPRESS_AUTO_GLZ ] = "auto_glz",
|
|
|
|
[ SPICE_IMAGE_COMPRESS_AUTO_LZ ] = "auto_lz",
|
|
|
|
[ SPICE_IMAGE_COMPRESS_QUIC ] = "quic",
|
|
|
|
[ SPICE_IMAGE_COMPRESS_GLZ ] = "glz",
|
|
|
|
[ SPICE_IMAGE_COMPRESS_LZ ] = "lz",
|
|
|
|
};
|
|
|
|
#define parse_compression(_name) \
|
|
|
|
parse_name(_name, "image compression", \
|
|
|
|
compression_names, ARRAY_SIZE(compression_names))
|
|
|
|
|
|
|
|
static const char *wan_compression_names[] = {
|
|
|
|
[ SPICE_WAN_COMPRESSION_AUTO ] = "auto",
|
|
|
|
[ SPICE_WAN_COMPRESSION_NEVER ] = "never",
|
|
|
|
[ SPICE_WAN_COMPRESSION_ALWAYS ] = "always",
|
|
|
|
};
|
|
|
|
#define parse_wan_compression(_name) \
|
|
|
|
parse_name(_name, "wan compression", \
|
|
|
|
wan_compression_names, ARRAY_SIZE(wan_compression_names))
|
|
|
|
|
2010-03-11 15:13:27 +01:00
|
|
|
/* functions for the rest of qemu */
|
|
|
|
|
2011-10-20 21:01:33 +02:00
|
|
|
static SpiceChannelList *qmp_query_spice_channels(void)
|
2010-11-30 11:02:51 +01:00
|
|
|
{
|
2011-10-20 21:01:33 +02:00
|
|
|
SpiceChannelList *cur_item = NULL, *head = NULL;
|
|
|
|
ChannelList *item;
|
2010-11-30 11:02:51 +01:00
|
|
|
|
2011-10-20 21:01:33 +02:00
|
|
|
QTAILQ_FOREACH(item, &channel_list, link) {
|
|
|
|
SpiceChannelList *chan;
|
|
|
|
char host[NI_MAXHOST], port[NI_MAXSERV];
|
2012-02-08 14:40:15 +01:00
|
|
|
struct sockaddr *paddr;
|
|
|
|
socklen_t plen;
|
2011-10-20 21:01:33 +02:00
|
|
|
|
2014-12-05 09:30:10 +01:00
|
|
|
assert(item->info->flags & SPICE_CHANNEL_EVENT_FLAG_ADDR_EXT);
|
2013-10-04 13:10:46 +02:00
|
|
|
|
2011-10-20 21:01:33 +02:00
|
|
|
chan = g_malloc0(sizeof(*chan));
|
|
|
|
chan->value = g_malloc0(sizeof(*chan->value));
|
|
|
|
|
2013-10-04 13:10:46 +02:00
|
|
|
paddr = (struct sockaddr *)&item->info->paddr_ext;
|
|
|
|
plen = item->info->plen_ext;
|
2012-02-08 14:40:15 +01:00
|
|
|
getnameinfo(paddr, plen,
|
2011-10-20 21:01:33 +02:00
|
|
|
host, sizeof(host), port, sizeof(port),
|
|
|
|
NI_NUMERICHOST | NI_NUMERICSERV);
|
qapi: Unbox base members
Rather than storing a base class as a pointer to a box, just
store the fields of that base class in the same order, so that
a child struct can be directly cast to its parent. This gives
less malloc overhead, less pointer dereferencing, and even less
generated code. Compare to the earlier commit 1e6c1616a "qapi:
Generate a nicer struct for flat unions" (although that patch
had fewer places to change, as less of qemu was directly using
qapi structs for flat unions). It also allows us to turn on
automatic type-safe wrappers for upcasting to the base class
of a struct.
Changes to the generated code look like this in qapi-types.h:
| struct SpiceChannel {
|- SpiceBasicInfo *base;
|+ /* Members inherited from SpiceBasicInfo: */
|+ char *host;
|+ char *port;
|+ NetworkAddressFamily family;
|+ /* Own members: */
| int64_t connection_id;
as well as additional upcast functions like qapi_SpiceChannel_base().
Meanwhile, changes to qapi-visit.c look like:
| static void visit_type_SpiceChannel_fields(Visitor *v, SpiceChannel **obj, Error **errp)
| {
| Error *err = NULL;
|
|- visit_type_implicit_SpiceBasicInfo(v, &(*obj)->base, &err);
|+ visit_type_SpiceBasicInfo_fields(v, (SpiceBasicInfo **)obj, &err);
| if (err) {
(the cast is necessary, since our upcast wrappers only deal with a
single pointer, not pointer-to-pointer); plus the wholesale
elimination of some now-unused visit_type_implicit_FOO() functions.
Without boxing, the corner case of one empty struct having
another empty struct as its base type now requires inserting a
dummy member (previously, the 'Base *base' member sufficed).
And now that we no longer consume a 'base' member in the generated
C struct, we can delete the former negative struct-base-clash-base
test.
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1445898903-12082-11-git-send-email-eblake@redhat.com>
[Commit message tweaked slightly]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2015-10-26 23:34:49 +01:00
|
|
|
chan->value->host = g_strdup(host);
|
|
|
|
chan->value->port = g_strdup(port);
|
|
|
|
chan->value->family = inet_netfamily(paddr->sa_family);
|
2011-10-20 21:01:33 +02:00
|
|
|
|
|
|
|
chan->value->connection_id = item->info->connection_id;
|
|
|
|
chan->value->channel_type = item->info->type;
|
|
|
|
chan->value->channel_id = item->info->id;
|
|
|
|
chan->value->tls = item->info->flags & SPICE_CHANNEL_EVENT_FLAG_TLS;
|
|
|
|
|
|
|
|
/* XXX: waiting for the qapi to support GSList */
|
|
|
|
if (!cur_item) {
|
|
|
|
head = cur_item = chan;
|
|
|
|
} else {
|
|
|
|
cur_item->next = chan;
|
|
|
|
cur_item = chan;
|
|
|
|
}
|
2010-11-30 11:02:51 +01:00
|
|
|
}
|
|
|
|
|
2011-10-20 21:01:33 +02:00
|
|
|
return head;
|
2010-11-30 11:02:51 +01:00
|
|
|
}
|
|
|
|
|
2012-11-26 16:03:42 +01:00
|
|
|
static QemuOptsList qemu_spice_opts = {
|
|
|
|
.name = "spice",
|
|
|
|
.head = QTAILQ_HEAD_INITIALIZER(qemu_spice_opts.head),
|
|
|
|
.desc = {
|
|
|
|
{
|
|
|
|
.name = "port",
|
|
|
|
.type = QEMU_OPT_NUMBER,
|
|
|
|
},{
|
|
|
|
.name = "tls-port",
|
|
|
|
.type = QEMU_OPT_NUMBER,
|
|
|
|
},{
|
|
|
|
.name = "addr",
|
|
|
|
.type = QEMU_OPT_STRING,
|
|
|
|
},{
|
|
|
|
.name = "ipv4",
|
|
|
|
.type = QEMU_OPT_BOOL,
|
|
|
|
},{
|
|
|
|
.name = "ipv6",
|
|
|
|
.type = QEMU_OPT_BOOL,
|
2015-01-13 17:57:51 +01:00
|
|
|
#ifdef SPICE_ADDR_FLAG_UNIX_ONLY
|
|
|
|
},{
|
|
|
|
.name = "unix",
|
|
|
|
.type = QEMU_OPT_BOOL,
|
|
|
|
#endif
|
2012-11-26 16:03:42 +01:00
|
|
|
},{
|
|
|
|
.name = "password",
|
|
|
|
.type = QEMU_OPT_STRING,
|
|
|
|
},{
|
|
|
|
.name = "disable-ticketing",
|
|
|
|
.type = QEMU_OPT_BOOL,
|
|
|
|
},{
|
|
|
|
.name = "disable-copy-paste",
|
|
|
|
.type = QEMU_OPT_BOOL,
|
2013-06-08 15:37:27 +02:00
|
|
|
},{
|
|
|
|
.name = "disable-agent-file-xfer",
|
|
|
|
.type = QEMU_OPT_BOOL,
|
2012-11-26 16:03:42 +01:00
|
|
|
},{
|
|
|
|
.name = "sasl",
|
|
|
|
.type = QEMU_OPT_BOOL,
|
|
|
|
},{
|
|
|
|
.name = "x509-dir",
|
|
|
|
.type = QEMU_OPT_STRING,
|
|
|
|
},{
|
|
|
|
.name = "x509-key-file",
|
|
|
|
.type = QEMU_OPT_STRING,
|
|
|
|
},{
|
|
|
|
.name = "x509-key-password",
|
|
|
|
.type = QEMU_OPT_STRING,
|
|
|
|
},{
|
|
|
|
.name = "x509-cert-file",
|
|
|
|
.type = QEMU_OPT_STRING,
|
|
|
|
},{
|
|
|
|
.name = "x509-cacert-file",
|
|
|
|
.type = QEMU_OPT_STRING,
|
|
|
|
},{
|
|
|
|
.name = "x509-dh-key-file",
|
|
|
|
.type = QEMU_OPT_STRING,
|
|
|
|
},{
|
|
|
|
.name = "tls-ciphers",
|
|
|
|
.type = QEMU_OPT_STRING,
|
|
|
|
},{
|
|
|
|
.name = "tls-channel",
|
|
|
|
.type = QEMU_OPT_STRING,
|
|
|
|
},{
|
|
|
|
.name = "plaintext-channel",
|
|
|
|
.type = QEMU_OPT_STRING,
|
|
|
|
},{
|
|
|
|
.name = "image-compression",
|
|
|
|
.type = QEMU_OPT_STRING,
|
|
|
|
},{
|
|
|
|
.name = "jpeg-wan-compression",
|
|
|
|
.type = QEMU_OPT_STRING,
|
|
|
|
},{
|
|
|
|
.name = "zlib-glz-wan-compression",
|
|
|
|
.type = QEMU_OPT_STRING,
|
|
|
|
},{
|
|
|
|
.name = "streaming-video",
|
|
|
|
.type = QEMU_OPT_STRING,
|
|
|
|
},{
|
|
|
|
.name = "agent-mouse",
|
|
|
|
.type = QEMU_OPT_BOOL,
|
|
|
|
},{
|
|
|
|
.name = "playback-compression",
|
|
|
|
.type = QEMU_OPT_BOOL,
|
2015-10-13 15:39:34 +02:00
|
|
|
},{
|
2012-11-26 16:03:42 +01:00
|
|
|
.name = "seamless-migration",
|
|
|
|
.type = QEMU_OPT_BOOL,
|
2015-10-13 15:39:34 +02:00
|
|
|
#ifdef HAVE_SPICE_GL
|
|
|
|
},{
|
|
|
|
.name = "gl",
|
|
|
|
.type = QEMU_OPT_BOOL,
|
|
|
|
#endif
|
2012-11-26 16:03:42 +01:00
|
|
|
},
|
|
|
|
{ /* end of list */ }
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2011-10-20 21:01:33 +02:00
|
|
|
SpiceInfo *qmp_query_spice(Error **errp)
|
2010-11-30 11:02:51 +01:00
|
|
|
{
|
|
|
|
QemuOpts *opts = QTAILQ_FIRST(&qemu_spice_opts.head);
|
|
|
|
int port, tls_port;
|
2011-10-20 21:01:33 +02:00
|
|
|
const char *addr;
|
|
|
|
SpiceInfo *info;
|
2013-09-02 15:41:32 +02:00
|
|
|
unsigned int major;
|
|
|
|
unsigned int minor;
|
|
|
|
unsigned int micro;
|
2010-11-30 11:02:51 +01:00
|
|
|
|
2011-10-20 21:01:33 +02:00
|
|
|
info = g_malloc0(sizeof(*info));
|
|
|
|
|
2011-10-04 13:25:53 +02:00
|
|
|
if (!spice_server || !opts) {
|
2011-10-20 21:01:33 +02:00
|
|
|
info->enabled = false;
|
|
|
|
return info;
|
2010-11-30 11:02:51 +01:00
|
|
|
}
|
|
|
|
|
2011-10-20 21:01:33 +02:00
|
|
|
info->enabled = true;
|
2012-08-21 10:51:58 +02:00
|
|
|
info->migrated = spice_migration_completed;
|
2011-10-20 21:01:33 +02:00
|
|
|
|
2010-11-30 11:02:51 +01:00
|
|
|
addr = qemu_opt_get(opts, "addr");
|
|
|
|
port = qemu_opt_get_number(opts, "port", 0);
|
|
|
|
tls_port = qemu_opt_get_number(opts, "tls-port", 0);
|
|
|
|
|
2011-10-20 21:01:33 +02:00
|
|
|
info->has_auth = true;
|
|
|
|
info->auth = g_strdup(auth);
|
|
|
|
|
|
|
|
info->has_host = true;
|
2014-04-15 08:55:44 +02:00
|
|
|
info->host = g_strdup(addr ? addr : "*");
|
2011-10-20 21:01:33 +02:00
|
|
|
|
|
|
|
info->has_compiled_version = true;
|
2013-09-02 15:41:32 +02:00
|
|
|
major = (SPICE_SERVER_VERSION & 0xff0000) >> 16;
|
|
|
|
minor = (SPICE_SERVER_VERSION & 0xff00) >> 8;
|
|
|
|
micro = SPICE_SERVER_VERSION & 0xff;
|
|
|
|
info->compiled_version = g_strdup_printf("%d.%d.%d", major, minor, micro);
|
2011-10-20 21:01:33 +02:00
|
|
|
|
2010-11-30 11:02:51 +01:00
|
|
|
if (port) {
|
2011-10-20 21:01:33 +02:00
|
|
|
info->has_port = true;
|
|
|
|
info->port = port;
|
2010-11-30 11:02:51 +01:00
|
|
|
}
|
|
|
|
if (tls_port) {
|
2011-10-20 21:01:33 +02:00
|
|
|
info->has_tls_port = true;
|
|
|
|
info->tls_port = tls_port;
|
2010-11-30 11:02:51 +01:00
|
|
|
}
|
|
|
|
|
2012-03-29 23:23:14 +02:00
|
|
|
info->mouse_mode = spice_server_is_server_mouse(spice_server) ?
|
|
|
|
SPICE_QUERY_MOUSE_MODE_SERVER :
|
|
|
|
SPICE_QUERY_MOUSE_MODE_CLIENT;
|
2012-09-24 10:23:40 +02:00
|
|
|
|
2011-10-20 21:01:33 +02:00
|
|
|
/* for compatibility with the original command */
|
|
|
|
info->has_channels = true;
|
|
|
|
info->channels = qmp_query_spice_channels();
|
|
|
|
|
|
|
|
return info;
|
2010-11-30 11:02:51 +01:00
|
|
|
}
|
|
|
|
|
2011-06-20 14:06:26 +02:00
|
|
|
static void migration_state_notifier(Notifier *notifier, void *data)
|
2010-04-23 13:28:21 +02:00
|
|
|
{
|
2011-02-23 00:43:59 +01:00
|
|
|
MigrationState *s = data;
|
2010-04-23 13:28:21 +02:00
|
|
|
|
2014-04-29 09:27:31 +02:00
|
|
|
if (!spice_have_target_host) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-07-29 15:01:58 +02:00
|
|
|
if (migration_in_setup(s)) {
|
2011-10-17 10:03:19 +02:00
|
|
|
spice_server_migrate_start(spice_server);
|
2016-02-22 18:17:32 +01:00
|
|
|
} else if (migration_has_finished(s) ||
|
|
|
|
migration_in_postcopy_after_devices(s)) {
|
2011-10-17 10:03:19 +02:00
|
|
|
spice_server_migrate_end(spice_server, true);
|
2014-04-29 09:27:31 +02:00
|
|
|
spice_have_target_host = false;
|
2011-10-17 10:03:19 +02:00
|
|
|
} else if (migration_has_failed(s)) {
|
|
|
|
spice_server_migrate_end(spice_server, false);
|
2014-04-29 09:27:31 +02:00
|
|
|
spice_have_target_host = false;
|
2010-04-23 13:28:21 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int qemu_spice_migrate_info(const char *hostname, int port, int tls_port,
|
2015-03-05 09:30:16 +01:00
|
|
|
const char *subject)
|
2010-04-23 13:28:21 +02:00
|
|
|
{
|
2011-10-17 10:03:18 +02:00
|
|
|
int ret;
|
2012-09-24 10:23:40 +02:00
|
|
|
|
2011-10-17 10:03:19 +02:00
|
|
|
ret = spice_server_migrate_connect(spice_server, hostname,
|
|
|
|
port, tls_port, subject);
|
2014-04-29 09:27:31 +02:00
|
|
|
spice_have_target_host = true;
|
2011-10-17 10:03:18 +02:00
|
|
|
return ret;
|
2010-04-23 13:28:21 +02:00
|
|
|
}
|
|
|
|
|
2015-03-12 08:40:25 +01:00
|
|
|
static int add_channel(void *opaque, const char *name, const char *value,
|
|
|
|
Error **errp)
|
2010-08-27 14:09:56 +02:00
|
|
|
{
|
|
|
|
int security = 0;
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
if (strcmp(name, "tls-channel") == 0) {
|
2012-02-24 18:28:32 +01:00
|
|
|
int *tls_port = opaque;
|
|
|
|
if (!*tls_port) {
|
|
|
|
error_report("spice: tried to setup tls-channel"
|
|
|
|
" without specifying a TLS port");
|
|
|
|
exit(1);
|
|
|
|
}
|
2010-08-27 14:09:56 +02:00
|
|
|
security = SPICE_CHANNEL_SECURITY_SSL;
|
|
|
|
}
|
|
|
|
if (strcmp(name, "plaintext-channel") == 0) {
|
|
|
|
security = SPICE_CHANNEL_SECURITY_NONE;
|
|
|
|
}
|
|
|
|
if (security == 0) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (strcmp(value, "default") == 0) {
|
|
|
|
rc = spice_server_set_channel_security(spice_server, NULL, security);
|
|
|
|
} else {
|
|
|
|
rc = spice_server_set_channel_security(spice_server, value, security);
|
|
|
|
}
|
|
|
|
if (rc != 0) {
|
2012-02-24 18:13:12 +01:00
|
|
|
error_report("spice: failed to set channel security for %s", value);
|
2010-08-27 14:09:56 +02:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-08-21 10:51:55 +02:00
|
|
|
static void vm_change_state_handler(void *opaque, int running,
|
|
|
|
RunState state)
|
|
|
|
{
|
|
|
|
if (running) {
|
2012-08-21 10:51:56 +02:00
|
|
|
qemu_spice_display_start();
|
2012-08-21 10:51:55 +02:00
|
|
|
} else {
|
2012-08-21 10:51:56 +02:00
|
|
|
qemu_spice_display_stop();
|
2012-08-21 10:51:55 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-03-11 15:13:27 +01:00
|
|
|
void qemu_spice_init(void)
|
|
|
|
{
|
|
|
|
QemuOpts *opts = QTAILQ_FIRST(&qemu_spice_opts.head);
|
2010-08-27 14:29:16 +02:00
|
|
|
const char *password, *str, *x509_dir, *addr,
|
2010-03-11 15:13:32 +01:00
|
|
|
*x509_key_password = NULL,
|
|
|
|
*x509_dh_file = NULL,
|
|
|
|
*tls_ciphers = NULL;
|
|
|
|
char *x509_key_file = NULL,
|
|
|
|
*x509_cert_file = NULL,
|
|
|
|
*x509_cacert_file = NULL;
|
2013-09-02 15:41:32 +02:00
|
|
|
int port, tls_port, addr_flags;
|
2010-07-14 12:26:34 +02:00
|
|
|
spice_image_compression_t compression;
|
|
|
|
spice_wan_compression_t wan_compr;
|
2012-08-21 10:51:59 +02:00
|
|
|
bool seamless_migration;
|
2010-03-11 15:13:27 +01:00
|
|
|
|
2011-09-20 17:14:33 +02:00
|
|
|
qemu_thread_get_self(&me);
|
2011-09-02 15:03:28 +02:00
|
|
|
|
2012-03-14 19:33:37 +01:00
|
|
|
if (!opts) {
|
2010-03-11 15:13:27 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
port = qemu_opt_get_number(opts, "port", 0);
|
2010-03-11 15:13:32 +01:00
|
|
|
tls_port = qemu_opt_get_number(opts, "tls-port", 0);
|
2011-07-07 17:04:17 +02:00
|
|
|
if (port < 0 || port > 65535) {
|
2012-02-24 18:13:12 +01:00
|
|
|
error_report("spice port is out of range");
|
2011-07-07 17:04:17 +02:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
if (tls_port < 0 || tls_port > 65535) {
|
2012-02-24 18:13:12 +01:00
|
|
|
error_report("spice tls-port is out of range");
|
2011-07-07 17:04:17 +02:00
|
|
|
exit(1);
|
2010-03-11 15:13:27 +01:00
|
|
|
}
|
|
|
|
password = qemu_opt_get(opts, "password");
|
|
|
|
|
2010-03-11 15:13:32 +01:00
|
|
|
if (tls_port) {
|
|
|
|
x509_dir = qemu_opt_get(opts, "x509-dir");
|
2014-08-11 15:00:56 +02:00
|
|
|
if (!x509_dir) {
|
2010-03-11 15:13:32 +01:00
|
|
|
x509_dir = ".";
|
|
|
|
}
|
|
|
|
|
|
|
|
str = qemu_opt_get(opts, "x509-key-file");
|
|
|
|
if (str) {
|
2011-08-21 05:09:37 +02:00
|
|
|
x509_key_file = g_strdup(str);
|
2010-03-11 15:13:32 +01:00
|
|
|
} else {
|
2013-09-02 15:41:32 +02:00
|
|
|
x509_key_file = g_strdup_printf("%s/%s", x509_dir,
|
|
|
|
X509_SERVER_KEY_FILE);
|
2010-03-11 15:13:32 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
str = qemu_opt_get(opts, "x509-cert-file");
|
|
|
|
if (str) {
|
2011-08-21 05:09:37 +02:00
|
|
|
x509_cert_file = g_strdup(str);
|
2010-03-11 15:13:32 +01:00
|
|
|
} else {
|
2013-09-02 15:41:32 +02:00
|
|
|
x509_cert_file = g_strdup_printf("%s/%s", x509_dir,
|
|
|
|
X509_SERVER_CERT_FILE);
|
2010-03-11 15:13:32 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
str = qemu_opt_get(opts, "x509-cacert-file");
|
|
|
|
if (str) {
|
2011-08-21 05:09:37 +02:00
|
|
|
x509_cacert_file = g_strdup(str);
|
2010-03-11 15:13:32 +01:00
|
|
|
} else {
|
2013-09-02 15:41:32 +02:00
|
|
|
x509_cacert_file = g_strdup_printf("%s/%s", x509_dir,
|
|
|
|
X509_CA_CERT_FILE);
|
2010-03-11 15:13:32 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
x509_key_password = qemu_opt_get(opts, "x509-key-password");
|
2012-11-19 10:15:08 +01:00
|
|
|
x509_dh_file = qemu_opt_get(opts, "x509-dh-key-file");
|
2010-03-11 15:13:32 +01:00
|
|
|
tls_ciphers = qemu_opt_get(opts, "tls-ciphers");
|
|
|
|
}
|
|
|
|
|
2010-08-27 14:29:16 +02:00
|
|
|
addr = qemu_opt_get(opts, "addr");
|
|
|
|
addr_flags = 0;
|
|
|
|
if (qemu_opt_get_bool(opts, "ipv4", 0)) {
|
|
|
|
addr_flags |= SPICE_ADDR_FLAG_IPV4_ONLY;
|
|
|
|
} else if (qemu_opt_get_bool(opts, "ipv6", 0)) {
|
|
|
|
addr_flags |= SPICE_ADDR_FLAG_IPV6_ONLY;
|
2015-01-13 17:57:51 +01:00
|
|
|
#ifdef SPICE_ADDR_FLAG_UNIX_ONLY
|
|
|
|
} else if (qemu_opt_get_bool(opts, "unix", 0)) {
|
|
|
|
addr_flags |= SPICE_ADDR_FLAG_UNIX_ONLY;
|
|
|
|
#endif
|
2010-08-27 14:29:16 +02:00
|
|
|
}
|
|
|
|
|
2010-03-11 15:13:27 +01:00
|
|
|
spice_server = spice_server_new();
|
2010-08-27 14:29:16 +02:00
|
|
|
spice_server_set_addr(spice_server, addr ? addr : "", addr_flags);
|
2010-03-11 15:13:32 +01:00
|
|
|
if (port) {
|
|
|
|
spice_server_set_port(spice_server, port);
|
|
|
|
}
|
|
|
|
if (tls_port) {
|
|
|
|
spice_server_set_tls(spice_server, tls_port,
|
|
|
|
x509_cacert_file,
|
|
|
|
x509_cert_file,
|
|
|
|
x509_key_file,
|
|
|
|
x509_key_password,
|
|
|
|
x509_dh_file,
|
|
|
|
tls_ciphers);
|
|
|
|
}
|
2010-03-11 15:13:27 +01:00
|
|
|
if (password) {
|
2014-09-05 14:08:48 +02:00
|
|
|
qemu_spice_set_passwd(password, false, false);
|
2010-03-11 15:13:27 +01:00
|
|
|
}
|
2011-05-17 10:40:33 +02:00
|
|
|
if (qemu_opt_get_bool(opts, "sasl", 0)) {
|
2016-01-12 15:08:58 +01:00
|
|
|
if (spice_server_set_sasl(spice_server, 1) == -1) {
|
2012-02-24 18:13:12 +01:00
|
|
|
error_report("spice: failed to enable sasl");
|
2011-05-17 10:40:33 +02:00
|
|
|
exit(1);
|
|
|
|
}
|
2014-07-02 12:56:42 +02:00
|
|
|
auth = "sasl";
|
2011-05-17 10:40:33 +02:00
|
|
|
}
|
2010-03-11 15:13:27 +01:00
|
|
|
if (qemu_opt_get_bool(opts, "disable-ticketing", 0)) {
|
2010-10-11 18:03:51 +02:00
|
|
|
auth = "none";
|
2010-03-11 15:13:27 +01:00
|
|
|
spice_server_set_noauth(spice_server);
|
|
|
|
}
|
|
|
|
|
2011-03-27 16:43:54 +02:00
|
|
|
if (qemu_opt_get_bool(opts, "disable-copy-paste", 0)) {
|
|
|
|
spice_server_set_agent_copypaste(spice_server, false);
|
|
|
|
}
|
|
|
|
|
2013-06-08 15:37:27 +02:00
|
|
|
if (qemu_opt_get_bool(opts, "disable-agent-file-xfer", 0)) {
|
|
|
|
#if SPICE_SERVER_VERSION >= 0x000c04
|
|
|
|
spice_server_set_agent_file_xfer(spice_server, false);
|
|
|
|
#else
|
|
|
|
error_report("this qemu build does not support the "
|
|
|
|
"\"disable-agent-file-xfer\" option");
|
|
|
|
exit(1);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2010-07-14 12:26:34 +02:00
|
|
|
compression = SPICE_IMAGE_COMPRESS_AUTO_GLZ;
|
|
|
|
str = qemu_opt_get(opts, "image-compression");
|
|
|
|
if (str) {
|
|
|
|
compression = parse_compression(str);
|
|
|
|
}
|
|
|
|
spice_server_set_image_compression(spice_server, compression);
|
|
|
|
|
|
|
|
wan_compr = SPICE_WAN_COMPRESSION_AUTO;
|
|
|
|
str = qemu_opt_get(opts, "jpeg-wan-compression");
|
|
|
|
if (str) {
|
|
|
|
wan_compr = parse_wan_compression(str);
|
|
|
|
}
|
|
|
|
spice_server_set_jpeg_compression(spice_server, wan_compr);
|
|
|
|
|
|
|
|
wan_compr = SPICE_WAN_COMPRESSION_AUTO;
|
|
|
|
str = qemu_opt_get(opts, "zlib-glz-wan-compression");
|
|
|
|
if (str) {
|
|
|
|
wan_compr = parse_wan_compression(str);
|
|
|
|
}
|
|
|
|
spice_server_set_zlib_glz_compression(spice_server, wan_compr);
|
2010-03-11 15:13:27 +01:00
|
|
|
|
2010-08-30 16:36:53 +02:00
|
|
|
str = qemu_opt_get(opts, "streaming-video");
|
|
|
|
if (str) {
|
2010-11-02 12:21:50 +01:00
|
|
|
int streaming_video = parse_stream_video(str);
|
2010-08-30 16:36:53 +02:00
|
|
|
spice_server_set_streaming_video(spice_server, streaming_video);
|
2013-12-02 11:17:04 +01:00
|
|
|
} else {
|
|
|
|
spice_server_set_streaming_video(spice_server, SPICE_STREAM_VIDEO_OFF);
|
2010-08-30 16:36:53 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
spice_server_set_agent_mouse
|
|
|
|
(spice_server, qemu_opt_get_bool(opts, "agent-mouse", 1));
|
|
|
|
spice_server_set_playback_compression
|
|
|
|
(spice_server, qemu_opt_get_bool(opts, "playback-compression", 1));
|
|
|
|
|
2015-03-12 08:40:25 +01:00
|
|
|
qemu_opt_foreach(opts, add_channel, &tls_port, NULL);
|
2010-08-27 14:09:56 +02:00
|
|
|
|
2012-03-05 18:22:26 +01:00
|
|
|
spice_server_set_name(spice_server, qemu_name);
|
|
|
|
spice_server_set_uuid(spice_server, qemu_uuid);
|
|
|
|
|
2012-08-21 10:51:59 +02:00
|
|
|
seamless_migration = qemu_opt_get_bool(opts, "seamless-migration", 0);
|
|
|
|
spice_server_set_seamless_migration(spice_server, seamless_migration);
|
2016-01-12 15:08:58 +01:00
|
|
|
spice_server_set_sasl_appname(spice_server, "qemu");
|
2014-08-11 15:00:56 +02:00
|
|
|
if (spice_server_init(spice_server, &core_interface) != 0) {
|
2012-02-24 18:13:12 +01:00
|
|
|
error_report("failed to initialize spice server");
|
2011-06-15 13:11:33 +02:00
|
|
|
exit(1);
|
|
|
|
};
|
2010-03-11 15:13:27 +01:00
|
|
|
using_spice = 1;
|
2010-03-11 15:13:28 +01:00
|
|
|
|
2010-04-23 13:28:21 +02:00
|
|
|
migration_state.notify = migration_state_notifier;
|
|
|
|
add_migration_state_change_notifier(&migration_state);
|
2015-03-05 09:30:16 +01:00
|
|
|
spice_migrate.base.sif = &migrate_interface.base;
|
|
|
|
qemu_spice_add_interface(&spice_migrate.base);
|
2010-04-23 13:28:21 +02:00
|
|
|
|
2010-03-11 15:13:28 +01:00
|
|
|
qemu_spice_input_init();
|
2010-11-09 17:29:46 +01:00
|
|
|
qemu_spice_audio_init();
|
2010-03-11 15:13:32 +01:00
|
|
|
|
2012-12-19 14:07:16 +01:00
|
|
|
qemu_add_vm_change_state_handler(vm_change_state_handler, NULL);
|
2015-05-12 11:54:34 +02:00
|
|
|
qemu_spice_display_stop();
|
2012-08-21 10:51:55 +02:00
|
|
|
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free(x509_key_file);
|
|
|
|
g_free(x509_cert_file);
|
|
|
|
g_free(x509_cacert_file);
|
2012-12-05 16:15:36 +01:00
|
|
|
|
|
|
|
#if SPICE_SERVER_VERSION >= 0x000c02
|
|
|
|
qemu_spice_register_ports();
|
|
|
|
#endif
|
2015-10-13 15:39:34 +02:00
|
|
|
|
|
|
|
#ifdef HAVE_SPICE_GL
|
|
|
|
if (qemu_opt_get_bool(opts, "gl", 0)) {
|
|
|
|
if (egl_rendernode_init() == 0) {
|
|
|
|
display_opengl = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
2010-03-11 15:13:27 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
int qemu_spice_add_interface(SpiceBaseInstance *sin)
|
|
|
|
{
|
2010-04-27 11:50:11 +02:00
|
|
|
if (!spice_server) {
|
|
|
|
if (QTAILQ_FIRST(&qemu_spice_opts.head) != NULL) {
|
2012-02-24 18:13:12 +01:00
|
|
|
error_report("Oops: spice configured but not active");
|
2010-04-27 11:50:11 +02:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Create a spice server instance.
|
|
|
|
* It does *not* listen on the network.
|
|
|
|
* It handles QXL local rendering only.
|
|
|
|
*
|
|
|
|
* With a command line like '-vnc :0 -vga qxl' you'll end up here.
|
|
|
|
*/
|
|
|
|
spice_server = spice_server_new();
|
2013-10-16 17:52:33 +02:00
|
|
|
spice_server_set_sasl_appname(spice_server, "qemu");
|
2010-04-27 11:50:11 +02:00
|
|
|
spice_server_init(spice_server, &core_interface);
|
2012-12-19 14:07:16 +01:00
|
|
|
qemu_add_vm_change_state_handler(vm_change_state_handler, NULL);
|
2010-04-27 11:50:11 +02:00
|
|
|
}
|
2012-08-21 10:51:56 +02:00
|
|
|
|
2013-10-11 22:39:59 +02:00
|
|
|
return spice_server_add_interface(spice_server, sin);
|
|
|
|
}
|
|
|
|
|
|
|
|
static GSList *spice_consoles;
|
|
|
|
|
|
|
|
bool qemu_spice_have_display_interface(QemuConsole *con)
|
|
|
|
{
|
|
|
|
if (g_slist_find(spice_consoles, con)) {
|
|
|
|
return true;
|
2013-07-22 15:34:12 +02:00
|
|
|
}
|
2013-10-11 22:39:59 +02:00
|
|
|
return false;
|
|
|
|
}
|
2013-07-22 15:34:12 +02:00
|
|
|
|
2013-10-11 22:39:59 +02:00
|
|
|
int qemu_spice_add_display_interface(QXLInstance *qxlin, QemuConsole *con)
|
|
|
|
{
|
|
|
|
if (g_slist_find(spice_consoles, con)) {
|
|
|
|
return -1;
|
|
|
|
}
|
2014-08-29 10:13:28 +02:00
|
|
|
qxlin->id = qemu_console_get_index(con);
|
2013-10-11 22:39:59 +02:00
|
|
|
spice_consoles = g_slist_append(spice_consoles, con);
|
|
|
|
return qemu_spice_add_interface(&qxlin->base);
|
2010-03-11 15:13:27 +01:00
|
|
|
}
|
|
|
|
|
2010-10-07 12:22:54 +02:00
|
|
|
static int qemu_spice_set_ticket(bool fail_if_conn, bool disconnect_if_conn)
|
|
|
|
{
|
|
|
|
time_t lifetime, now = time(NULL);
|
|
|
|
char *passwd;
|
|
|
|
|
|
|
|
if (now < auth_expires) {
|
|
|
|
passwd = auth_passwd;
|
|
|
|
lifetime = (auth_expires - now);
|
|
|
|
if (lifetime > INT_MAX) {
|
|
|
|
lifetime = INT_MAX;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
passwd = NULL;
|
|
|
|
lifetime = 1;
|
|
|
|
}
|
|
|
|
return spice_server_set_ticket(spice_server, passwd, lifetime,
|
|
|
|
fail_if_conn, disconnect_if_conn);
|
|
|
|
}
|
|
|
|
|
|
|
|
int qemu_spice_set_passwd(const char *passwd,
|
|
|
|
bool fail_if_conn, bool disconnect_if_conn)
|
|
|
|
{
|
2014-07-02 12:56:42 +02:00
|
|
|
if (strcmp(auth, "spice") != 0) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2013-01-22 11:08:00 +01:00
|
|
|
g_free(auth_passwd);
|
|
|
|
auth_passwd = g_strdup(passwd);
|
2010-10-07 12:22:54 +02:00
|
|
|
return qemu_spice_set_ticket(fail_if_conn, disconnect_if_conn);
|
|
|
|
}
|
|
|
|
|
|
|
|
int qemu_spice_set_pw_expire(time_t expires)
|
|
|
|
{
|
|
|
|
auth_expires = expires;
|
|
|
|
return qemu_spice_set_ticket(false, false);
|
|
|
|
}
|
|
|
|
|
2012-02-13 14:43:08 +01:00
|
|
|
int qemu_spice_display_add_client(int csock, int skipauth, int tls)
|
|
|
|
{
|
|
|
|
if (tls) {
|
|
|
|
return spice_server_add_ssl_client(spice_server, csock, skipauth);
|
|
|
|
} else {
|
|
|
|
return spice_server_add_client(spice_server, csock, skipauth);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-12-09 15:54:46 +01:00
|
|
|
void qemu_spice_display_start(void)
|
|
|
|
{
|
|
|
|
spice_display_is_running = true;
|
2013-12-09 16:00:15 +01:00
|
|
|
spice_server_vm_start(spice_server);
|
2013-12-09 15:54:46 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void qemu_spice_display_stop(void)
|
|
|
|
{
|
2013-12-09 16:00:15 +01:00
|
|
|
spice_server_vm_stop(spice_server);
|
2013-12-09 15:54:46 +01:00
|
|
|
spice_display_is_running = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
int qemu_spice_display_is_running(SimpleSpiceDisplay *ssd)
|
|
|
|
{
|
|
|
|
return spice_display_is_running;
|
|
|
|
}
|
|
|
|
|
2010-03-11 15:13:27 +01:00
|
|
|
static void spice_register_config(void)
|
|
|
|
{
|
|
|
|
qemu_add_opts(&qemu_spice_opts);
|
|
|
|
}
|
2016-02-16 21:59:07 +01:00
|
|
|
opts_init(spice_register_config);
|