2 * Copyright (C) 2010 Red Hat, Inc.
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License as
6 * published by the Free Software Foundation; either version 2 or
7 * (at your option) version 3 of the License.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, see <http://www.gnu.org/licenses/>.
18 #include "qemu/osdep.h"
21 #include "sysemu/sysemu.h"
22 #include "sysemu/runstate.h"
23 #include "ui/qemu-spice.h"
24 #include "qemu/error-report.h"
25 #include "qemu/main-loop.h"
26 #include "qemu/module.h"
27 #include "qemu/thread.h"
28 #include "qemu/timer.h"
29 #include "qemu/queue.h"
30 #include "qemu-x509.h"
31 #include "qemu/sockets.h"
32 #include "qapi/error.h"
33 #include "qapi/qapi-commands-ui.h"
34 #include "qapi/qapi-events-ui.h"
35 #include "qemu/notify.h"
36 #include "qemu/option.h"
37 #include "crypto/secret_common.h"
38 #include "migration/misc.h"
39 #include "hw/pci/pci_bus.h"
40 #include "ui/spice-display.h"
44 static SpiceServer
*spice_server
;
45 static Notifier migration_state
;
46 static const char *auth
= "spice";
47 static char *auth_passwd
;
48 static time_t auth_expires
= TIME_MAX
;
49 static int spice_migration_completed
;
50 static int spice_display_is_running
;
51 static int spice_have_target_host
;
59 static SpiceTimer
*timer_add(SpiceTimerFunc func
, void *opaque
)
63 timer
= g_malloc0(sizeof(*timer
));
64 timer
->timer
= timer_new_ms(QEMU_CLOCK_REALTIME
, func
, opaque
);
68 static void timer_start(SpiceTimer
*timer
, uint32_t ms
)
70 timer_mod(timer
->timer
, qemu_clock_get_ms(QEMU_CLOCK_REALTIME
) + ms
);
73 static void timer_cancel(SpiceTimer
*timer
)
75 timer_del(timer
->timer
);
78 static void timer_remove(SpiceTimer
*timer
)
80 timer_free(timer
->timer
);
90 static void watch_read(void *opaque
)
92 SpiceWatch
*watch
= opaque
;
93 watch
->func(watch
->fd
, SPICE_WATCH_EVENT_READ
, watch
->opaque
);
96 static void watch_write(void *opaque
)
98 SpiceWatch
*watch
= opaque
;
99 watch
->func(watch
->fd
, SPICE_WATCH_EVENT_WRITE
, watch
->opaque
);
102 static void watch_update_mask(SpiceWatch
*watch
, int event_mask
)
104 IOHandler
*on_read
= NULL
;
105 IOHandler
*on_write
= NULL
;
107 if (event_mask
& SPICE_WATCH_EVENT_READ
) {
108 on_read
= watch_read
;
110 if (event_mask
& SPICE_WATCH_EVENT_WRITE
) {
111 on_write
= watch_write
;
113 qemu_set_fd_handler(watch
->fd
, on_read
, on_write
, watch
);
116 static SpiceWatch
*watch_add(int fd
, int event_mask
, SpiceWatchFunc func
, void *opaque
)
120 watch
= g_malloc0(sizeof(*watch
));
123 watch
->opaque
= opaque
;
125 watch_update_mask(watch
, event_mask
);
129 static void watch_remove(SpiceWatch
*watch
)
131 qemu_set_fd_handler(watch
->fd
, NULL
, NULL
, NULL
);
135 typedef struct ChannelList ChannelList
;
137 SpiceChannelEventInfo
*info
;
138 QTAILQ_ENTRY(ChannelList
) link
;
140 static QTAILQ_HEAD(, ChannelList
) channel_list
= QTAILQ_HEAD_INITIALIZER(channel_list
);
142 static void channel_list_add(SpiceChannelEventInfo
*info
)
146 item
= g_malloc0(sizeof(*item
));
148 QTAILQ_INSERT_TAIL(&channel_list
, item
, link
);
151 static void channel_list_del(SpiceChannelEventInfo
*info
)
155 QTAILQ_FOREACH(item
, &channel_list
, link
) {
156 if (item
->info
!= info
) {
159 QTAILQ_REMOVE(&channel_list
, item
, link
);
165 static void add_addr_info(SpiceBasicInfo
*info
, struct sockaddr
*addr
, int len
)
167 char host
[NI_MAXHOST
], port
[NI_MAXSERV
];
169 getnameinfo(addr
, len
, host
, sizeof(host
), port
, sizeof(port
),
170 NI_NUMERICHOST
| NI_NUMERICSERV
);
172 info
->host
= g_strdup(host
);
173 info
->port
= g_strdup(port
);
174 info
->family
= inet_netfamily(addr
->sa_family
);
177 static void add_channel_info(SpiceChannel
*sc
, SpiceChannelEventInfo
*info
)
179 int tls
= info
->flags
& SPICE_CHANNEL_EVENT_FLAG_TLS
;
181 sc
->connection_id
= info
->connection_id
;
182 sc
->channel_type
= info
->type
;
183 sc
->channel_id
= info
->id
;
187 static void channel_event(int event
, SpiceChannelEventInfo
*info
)
189 SpiceServerInfo
*server
= g_malloc0(sizeof(*server
));
190 SpiceChannel
*client
= g_malloc0(sizeof(*client
));
193 * Spice server might have called us from spice worker thread
194 * context (happens on display channel disconnects). Spice should
195 * not do that. It isn't that easy to fix it in spice and even
196 * when it is fixed we still should cover the already released
197 * spice versions. So detect that we've been called from another
198 * thread and grab the iothread lock if so before calling qemu
201 bool need_lock
= !qemu_thread_is_self(&me
);
203 qemu_mutex_lock_iothread();
206 if (info
->flags
& SPICE_CHANNEL_EVENT_FLAG_ADDR_EXT
) {
207 add_addr_info(qapi_SpiceChannel_base(client
),
208 (struct sockaddr
*)&info
->paddr_ext
,
210 add_addr_info(qapi_SpiceServerInfo_base(server
),
211 (struct sockaddr
*)&info
->laddr_ext
,
214 error_report("spice: %s, extended address is expected",
219 case SPICE_CHANNEL_EVENT_CONNECTED
:
220 qapi_event_send_spice_connected(qapi_SpiceServerInfo_base(server
),
221 qapi_SpiceChannel_base(client
));
223 case SPICE_CHANNEL_EVENT_INITIALIZED
:
225 server
->auth
= g_strdup(auth
);
227 add_channel_info(client
, info
);
228 channel_list_add(info
);
229 qapi_event_send_spice_initialized(server
, client
);
231 case SPICE_CHANNEL_EVENT_DISCONNECTED
:
232 channel_list_del(info
);
233 qapi_event_send_spice_disconnected(qapi_SpiceServerInfo_base(server
),
234 qapi_SpiceChannel_base(client
));
241 qemu_mutex_unlock_iothread();
244 qapi_free_SpiceServerInfo(server
);
245 qapi_free_SpiceChannel(client
);
248 static SpiceCoreInterface core_interface
= {
249 .base
.type
= SPICE_INTERFACE_CORE
,
250 .base
.description
= "qemu core services",
251 .base
.major_version
= SPICE_INTERFACE_CORE_MAJOR
,
252 .base
.minor_version
= SPICE_INTERFACE_CORE_MINOR
,
254 .timer_add
= timer_add
,
255 .timer_start
= timer_start
,
256 .timer_cancel
= timer_cancel
,
257 .timer_remove
= timer_remove
,
259 .watch_add
= watch_add
,
260 .watch_update_mask
= watch_update_mask
,
261 .watch_remove
= watch_remove
,
263 .channel_event
= channel_event
,
266 static void migrate_connect_complete_cb(SpiceMigrateInstance
*sin
);
267 static void migrate_end_complete_cb(SpiceMigrateInstance
*sin
);
269 static const SpiceMigrateInterface migrate_interface
= {
270 .base
.type
= SPICE_INTERFACE_MIGRATION
,
271 .base
.description
= "migration",
272 .base
.major_version
= SPICE_INTERFACE_MIGRATION_MAJOR
,
273 .base
.minor_version
= SPICE_INTERFACE_MIGRATION_MINOR
,
274 .migrate_connect_complete
= migrate_connect_complete_cb
,
275 .migrate_end_complete
= migrate_end_complete_cb
,
278 static SpiceMigrateInstance spice_migrate
;
280 static void migrate_connect_complete_cb(SpiceMigrateInstance
*sin
)
282 /* nothing, but libspice-server expects this cb being present. */
285 static void migrate_end_complete_cb(SpiceMigrateInstance
*sin
)
287 qapi_event_send_spice_migrate_completed();
288 spice_migration_completed
= true;
291 /* config string parsing */
293 static int name2enum(const char *string
, const char *table
[], int entries
)
298 for (i
= 0; i
< entries
; i
++) {
302 if (strcmp(string
, table
[i
]) != 0) {
311 static int parse_name(const char *string
, const char *optname
,
312 const char *table
[], int entries
)
314 int value
= name2enum(string
, table
, entries
);
319 error_report("spice: invalid %s: %s", optname
, string
);
323 static const char *stream_video_names
[] = {
324 [ SPICE_STREAM_VIDEO_OFF
] = "off",
325 [ SPICE_STREAM_VIDEO_ALL
] = "all",
326 [ SPICE_STREAM_VIDEO_FILTER
] = "filter",
328 #define parse_stream_video(_name) \
329 parse_name(_name, "stream video control", \
330 stream_video_names, ARRAY_SIZE(stream_video_names))
332 static const char *compression_names
[] = {
333 [ SPICE_IMAGE_COMPRESS_OFF
] = "off",
334 [ SPICE_IMAGE_COMPRESS_AUTO_GLZ
] = "auto_glz",
335 [ SPICE_IMAGE_COMPRESS_AUTO_LZ
] = "auto_lz",
336 [ SPICE_IMAGE_COMPRESS_QUIC
] = "quic",
337 [ SPICE_IMAGE_COMPRESS_GLZ
] = "glz",
338 [ SPICE_IMAGE_COMPRESS_LZ
] = "lz",
340 #define parse_compression(_name) \
341 parse_name(_name, "image compression", \
342 compression_names, ARRAY_SIZE(compression_names))
344 static const char *wan_compression_names
[] = {
345 [ SPICE_WAN_COMPRESSION_AUTO
] = "auto",
346 [ SPICE_WAN_COMPRESSION_NEVER
] = "never",
347 [ SPICE_WAN_COMPRESSION_ALWAYS
] = "always",
349 #define parse_wan_compression(_name) \
350 parse_name(_name, "wan compression", \
351 wan_compression_names, ARRAY_SIZE(wan_compression_names))
353 /* functions for the rest of qemu */
355 static SpiceChannelList
*qmp_query_spice_channels(void)
357 SpiceChannelList
*head
= NULL
, **tail
= &head
;
360 QTAILQ_FOREACH(item
, &channel_list
, link
) {
362 char host
[NI_MAXHOST
], port
[NI_MAXSERV
];
363 struct sockaddr
*paddr
;
366 assert(item
->info
->flags
& SPICE_CHANNEL_EVENT_FLAG_ADDR_EXT
);
368 chan
= g_malloc0(sizeof(*chan
));
370 paddr
= (struct sockaddr
*)&item
->info
->paddr_ext
;
371 plen
= item
->info
->plen_ext
;
372 getnameinfo(paddr
, plen
,
373 host
, sizeof(host
), port
, sizeof(port
),
374 NI_NUMERICHOST
| NI_NUMERICSERV
);
375 chan
->host
= g_strdup(host
);
376 chan
->port
= g_strdup(port
);
377 chan
->family
= inet_netfamily(paddr
->sa_family
);
379 chan
->connection_id
= item
->info
->connection_id
;
380 chan
->channel_type
= item
->info
->type
;
381 chan
->channel_id
= item
->info
->id
;
382 chan
->tls
= item
->info
->flags
& SPICE_CHANNEL_EVENT_FLAG_TLS
;
384 QAPI_LIST_APPEND(tail
, chan
);
390 static QemuOptsList qemu_spice_opts
= {
392 .head
= QTAILQ_HEAD_INITIALIZER(qemu_spice_opts
.head
),
397 .type
= QEMU_OPT_NUMBER
,
400 .type
= QEMU_OPT_NUMBER
,
403 .type
= QEMU_OPT_STRING
,
406 .type
= QEMU_OPT_BOOL
,
409 .type
= QEMU_OPT_BOOL
,
410 #ifdef SPICE_ADDR_FLAG_UNIX_ONLY
413 .type
= QEMU_OPT_BOOL
,
417 .type
= QEMU_OPT_STRING
,
419 .name
= "password-secret",
420 .type
= QEMU_OPT_STRING
,
422 .name
= "disable-ticketing",
423 .type
= QEMU_OPT_BOOL
,
425 .name
= "disable-copy-paste",
426 .type
= QEMU_OPT_BOOL
,
428 .name
= "disable-agent-file-xfer",
429 .type
= QEMU_OPT_BOOL
,
432 .type
= QEMU_OPT_BOOL
,
435 .type
= QEMU_OPT_STRING
,
437 .name
= "x509-key-file",
438 .type
= QEMU_OPT_STRING
,
440 .name
= "x509-key-password",
441 .type
= QEMU_OPT_STRING
,
443 .name
= "x509-cert-file",
444 .type
= QEMU_OPT_STRING
,
446 .name
= "x509-cacert-file",
447 .type
= QEMU_OPT_STRING
,
449 .name
= "x509-dh-key-file",
450 .type
= QEMU_OPT_STRING
,
452 .name
= "tls-ciphers",
453 .type
= QEMU_OPT_STRING
,
455 .name
= "tls-channel",
456 .type
= QEMU_OPT_STRING
,
458 .name
= "plaintext-channel",
459 .type
= QEMU_OPT_STRING
,
461 .name
= "image-compression",
462 .type
= QEMU_OPT_STRING
,
464 .name
= "jpeg-wan-compression",
465 .type
= QEMU_OPT_STRING
,
467 .name
= "zlib-glz-wan-compression",
468 .type
= QEMU_OPT_STRING
,
470 .name
= "streaming-video",
471 .type
= QEMU_OPT_STRING
,
473 .name
= "agent-mouse",
474 .type
= QEMU_OPT_BOOL
,
476 .name
= "playback-compression",
477 .type
= QEMU_OPT_BOOL
,
479 .name
= "seamless-migration",
480 .type
= QEMU_OPT_BOOL
,
483 .type
= QEMU_OPT_STRING
,
486 .type
= QEMU_OPT_NUMBER
,
490 .type
= QEMU_OPT_BOOL
,
492 .name
= "rendernode",
493 .type
= QEMU_OPT_STRING
,
496 { /* end of list */ }
500 static SpiceInfo
*qmp_query_spice_real(Error
**errp
)
502 QemuOpts
*opts
= QTAILQ_FIRST(&qemu_spice_opts
.head
);
510 info
= g_malloc0(sizeof(*info
));
512 if (!spice_server
|| !opts
) {
513 info
->enabled
= false;
517 info
->enabled
= true;
518 info
->migrated
= spice_migration_completed
;
520 addr
= qemu_opt_get(opts
, "addr");
521 port
= qemu_opt_get_number(opts
, "port", 0);
522 tls_port
= qemu_opt_get_number(opts
, "tls-port", 0);
524 info
->auth
= g_strdup(auth
);
525 info
->host
= g_strdup(addr
? addr
: "*");
527 major
= (SPICE_SERVER_VERSION
& 0xff0000) >> 16;
528 minor
= (SPICE_SERVER_VERSION
& 0xff00) >> 8;
529 micro
= SPICE_SERVER_VERSION
& 0xff;
530 info
->compiled_version
= g_strdup_printf("%d.%d.%d", major
, minor
, micro
);
533 info
->has_port
= true;
537 info
->has_tls_port
= true;
538 info
->tls_port
= tls_port
;
541 info
->mouse_mode
= spice_server_is_server_mouse(spice_server
) ?
542 SPICE_QUERY_MOUSE_MODE_SERVER
:
543 SPICE_QUERY_MOUSE_MODE_CLIENT
;
545 /* for compatibility with the original command */
546 info
->has_channels
= true;
547 info
->channels
= qmp_query_spice_channels();
552 static void migration_state_notifier(Notifier
*notifier
, void *data
)
554 MigrationState
*s
= data
;
556 if (!spice_have_target_host
) {
560 if (migration_in_setup(s
)) {
561 spice_server_migrate_start(spice_server
);
562 } else if (migration_has_finished(s
) ||
563 migration_in_postcopy_after_devices(s
)) {
564 spice_server_migrate_end(spice_server
, true);
565 spice_have_target_host
= false;
566 } else if (migration_has_failed(s
)) {
567 spice_server_migrate_end(spice_server
, false);
568 spice_have_target_host
= false;
572 int qemu_spice_migrate_info(const char *hostname
, int port
, int tls_port
,
577 ret
= spice_server_migrate_connect(spice_server
, hostname
,
578 port
, tls_port
, subject
);
579 spice_have_target_host
= true;
583 static int add_channel(void *opaque
, const char *name
, const char *value
,
589 if (strcmp(name
, "tls-channel") == 0) {
590 int *tls_port
= opaque
;
592 error_setg(errp
, "spice: tried to setup tls-channel"
593 " without specifying a TLS port");
596 security
= SPICE_CHANNEL_SECURITY_SSL
;
598 if (strcmp(name
, "plaintext-channel") == 0) {
599 security
= SPICE_CHANNEL_SECURITY_NONE
;
604 if (strcmp(value
, "default") == 0) {
605 rc
= spice_server_set_channel_security(spice_server
, NULL
, security
);
607 rc
= spice_server_set_channel_security(spice_server
, value
, security
);
610 error_setg(errp
, "spice: failed to set channel security for %s",
617 static void vm_change_state_handler(void *opaque
, bool running
,
621 qemu_spice_display_start();
622 } else if (state
!= RUN_STATE_PAUSED
) {
623 qemu_spice_display_stop();
627 void qemu_spice_display_init_done(void)
629 if (runstate_is_running()) {
630 qemu_spice_display_start();
632 qemu_add_vm_change_state_handler(vm_change_state_handler
, NULL
);
635 static void qemu_spice_init(void)
637 QemuOpts
*opts
= QTAILQ_FIRST(&qemu_spice_opts
.head
);
638 char *password
= NULL
;
639 const char *passwordSecret
;
640 const char *str
, *x509_dir
, *addr
,
641 *x509_key_password
= NULL
,
642 *x509_dh_file
= NULL
,
644 char *x509_key_file
= NULL
,
645 *x509_cert_file
= NULL
,
646 *x509_cacert_file
= NULL
;
647 int port
, tls_port
, addr_flags
;
648 spice_image_compression_t compression
;
649 spice_wan_compression_t wan_compr
;
650 bool seamless_migration
;
652 qemu_thread_get_self(&me
);
657 port
= qemu_opt_get_number(opts
, "port", 0);
658 tls_port
= qemu_opt_get_number(opts
, "tls-port", 0);
659 if (port
< 0 || port
> 65535) {
660 error_report("spice port is out of range");
663 if (tls_port
< 0 || tls_port
> 65535) {
664 error_report("spice tls-port is out of range");
667 passwordSecret
= qemu_opt_get(opts
, "password-secret");
668 if (passwordSecret
) {
669 if (qemu_opt_get(opts
, "password")) {
670 error_report("'password' option is mutually exclusive with "
671 "'password-secret'");
674 password
= qcrypto_secret_lookup_as_utf8(passwordSecret
,
677 str
= qemu_opt_get(opts
, "password");
679 warn_report("'password' option is deprecated and insecure, "
680 "use 'password-secret' instead");
681 password
= g_strdup(str
);
686 x509_dir
= qemu_opt_get(opts
, "x509-dir");
691 str
= qemu_opt_get(opts
, "x509-key-file");
693 x509_key_file
= g_strdup(str
);
695 x509_key_file
= g_strdup_printf("%s/%s", x509_dir
,
696 X509_SERVER_KEY_FILE
);
699 str
= qemu_opt_get(opts
, "x509-cert-file");
701 x509_cert_file
= g_strdup(str
);
703 x509_cert_file
= g_strdup_printf("%s/%s", x509_dir
,
704 X509_SERVER_CERT_FILE
);
707 str
= qemu_opt_get(opts
, "x509-cacert-file");
709 x509_cacert_file
= g_strdup(str
);
711 x509_cacert_file
= g_strdup_printf("%s/%s", x509_dir
,
715 x509_key_password
= qemu_opt_get(opts
, "x509-key-password");
716 x509_dh_file
= qemu_opt_get(opts
, "x509-dh-key-file");
717 tls_ciphers
= qemu_opt_get(opts
, "tls-ciphers");
720 addr
= qemu_opt_get(opts
, "addr");
722 if (qemu_opt_get_bool(opts
, "ipv4", 0)) {
723 addr_flags
|= SPICE_ADDR_FLAG_IPV4_ONLY
;
724 } else if (qemu_opt_get_bool(opts
, "ipv6", 0)) {
725 addr_flags
|= SPICE_ADDR_FLAG_IPV6_ONLY
;
726 #ifdef SPICE_ADDR_FLAG_UNIX_ONLY
727 } else if (qemu_opt_get_bool(opts
, "unix", 0)) {
728 addr_flags
|= SPICE_ADDR_FLAG_UNIX_ONLY
;
732 spice_server
= spice_server_new();
733 spice_server_set_addr(spice_server
, addr
? addr
: "", addr_flags
);
735 spice_server_set_port(spice_server
, port
);
738 spice_server_set_tls(spice_server
, tls_port
,
747 qemu_spice
.set_passwd(password
, false, false);
749 if (qemu_opt_get_bool(opts
, "sasl", 0)) {
750 if (spice_server_set_sasl(spice_server
, 1) == -1) {
751 error_report("spice: failed to enable sasl");
756 if (qemu_opt_get_bool(opts
, "disable-ticketing", 0)) {
758 spice_server_set_noauth(spice_server
);
761 if (qemu_opt_get_bool(opts
, "disable-copy-paste", 0)) {
762 spice_server_set_agent_copypaste(spice_server
, false);
765 if (qemu_opt_get_bool(opts
, "disable-agent-file-xfer", 0)) {
766 spice_server_set_agent_file_xfer(spice_server
, false);
769 compression
= SPICE_IMAGE_COMPRESS_AUTO_GLZ
;
770 str
= qemu_opt_get(opts
, "image-compression");
772 compression
= parse_compression(str
);
774 spice_server_set_image_compression(spice_server
, compression
);
776 wan_compr
= SPICE_WAN_COMPRESSION_AUTO
;
777 str
= qemu_opt_get(opts
, "jpeg-wan-compression");
779 wan_compr
= parse_wan_compression(str
);
781 spice_server_set_jpeg_compression(spice_server
, wan_compr
);
783 wan_compr
= SPICE_WAN_COMPRESSION_AUTO
;
784 str
= qemu_opt_get(opts
, "zlib-glz-wan-compression");
786 wan_compr
= parse_wan_compression(str
);
788 spice_server_set_zlib_glz_compression(spice_server
, wan_compr
);
790 str
= qemu_opt_get(opts
, "streaming-video");
792 int streaming_video
= parse_stream_video(str
);
793 spice_server_set_streaming_video(spice_server
, streaming_video
);
795 spice_server_set_streaming_video(spice_server
, SPICE_STREAM_VIDEO_OFF
);
798 spice_server_set_agent_mouse
799 (spice_server
, qemu_opt_get_bool(opts
, "agent-mouse", 1));
800 spice_server_set_playback_compression
801 (spice_server
, qemu_opt_get_bool(opts
, "playback-compression", 1));
803 qemu_opt_foreach(opts
, add_channel
, &tls_port
, &error_fatal
);
805 spice_server_set_name(spice_server
, qemu_name
?: "QEMU " QEMU_VERSION
);
806 spice_server_set_uuid(spice_server
, (unsigned char *)&qemu_uuid
);
808 seamless_migration
= qemu_opt_get_bool(opts
, "seamless-migration", 0);
809 spice_server_set_seamless_migration(spice_server
, seamless_migration
);
810 spice_server_set_sasl_appname(spice_server
, "qemu");
811 if (spice_server_init(spice_server
, &core_interface
) != 0) {
812 error_report("failed to initialize spice server");
817 migration_state
.notify
= migration_state_notifier
;
818 add_migration_state_change_notifier(&migration_state
);
819 spice_migrate
.base
.sif
= &migrate_interface
.base
;
820 qemu_spice
.add_interface(&spice_migrate
.base
);
822 qemu_spice_input_init();
824 qemu_spice_display_stop();
826 g_free(x509_key_file
);
827 g_free(x509_cert_file
);
828 g_free(x509_cacert_file
);
832 if (qemu_opt_get_bool(opts
, "gl", 0)) {
833 if ((port
!= 0) || (tls_port
!= 0)) {
834 error_report("SPICE GL support is local-only for now and "
835 "incompatible with -spice port/tls-port");
838 if (egl_rendernode_init(qemu_opt_get(opts
, "rendernode"),
839 DISPLAYGL_MODE_ON
) != 0) {
840 error_report("Failed to initialize EGL render node for SPICE GL");
849 static int qemu_spice_add_interface(SpiceBaseInstance
*sin
)
852 if (QTAILQ_FIRST(&qemu_spice_opts
.head
) != NULL
) {
853 error_report("Oops: spice configured but not active");
857 * Create a spice server instance.
858 * It does *not* listen on the network.
859 * It handles QXL local rendering only.
861 * With a command line like '-vnc :0 -vga qxl' you'll end up here.
863 spice_server
= spice_server_new();
864 spice_server_set_sasl_appname(spice_server
, "qemu");
865 spice_server_init(spice_server
, &core_interface
);
866 qemu_add_vm_change_state_handler(vm_change_state_handler
, NULL
);
869 return spice_server_add_interface(spice_server
, sin
);
872 static GSList
*spice_consoles
;
874 bool qemu_spice_have_display_interface(QemuConsole
*con
)
876 if (g_slist_find(spice_consoles
, con
)) {
882 int qemu_spice_add_display_interface(QXLInstance
*qxlin
, QemuConsole
*con
)
884 if (g_slist_find(spice_consoles
, con
)) {
887 qxlin
->id
= qemu_console_get_index(con
);
888 spice_consoles
= g_slist_append(spice_consoles
, con
);
889 return qemu_spice_add_interface(&qxlin
->base
);
892 static int qemu_spice_set_ticket(bool fail_if_conn
, bool disconnect_if_conn
)
894 time_t lifetime
, now
= time(NULL
);
897 if (now
< auth_expires
) {
898 passwd
= auth_passwd
;
899 lifetime
= (auth_expires
- now
);
900 if (lifetime
> INT_MAX
) {
907 return spice_server_set_ticket(spice_server
, passwd
, lifetime
,
908 fail_if_conn
, disconnect_if_conn
);
911 static int qemu_spice_set_passwd(const char *passwd
,
912 bool fail_if_conn
, bool disconnect_if_conn
)
914 if (strcmp(auth
, "spice") != 0) {
919 auth_passwd
= g_strdup(passwd
);
920 return qemu_spice_set_ticket(fail_if_conn
, disconnect_if_conn
);
923 static int qemu_spice_set_pw_expire(time_t expires
)
925 auth_expires
= expires
;
926 return qemu_spice_set_ticket(false, false);
929 static int qemu_spice_display_add_client(int csock
, int skipauth
, int tls
)
932 return spice_server_add_ssl_client(spice_server
, csock
, skipauth
);
934 return spice_server_add_client(spice_server
, csock
, skipauth
);
938 void qemu_spice_display_start(void)
940 if (spice_display_is_running
) {
944 spice_display_is_running
= true;
945 spice_server_vm_start(spice_server
);
948 void qemu_spice_display_stop(void)
950 if (!spice_display_is_running
) {
954 spice_server_vm_stop(spice_server
);
955 spice_display_is_running
= false;
958 int qemu_spice_display_is_running(SimpleSpiceDisplay
*ssd
)
960 return spice_display_is_running
;
963 static struct QemuSpiceOps real_spice_ops
= {
964 .init
= qemu_spice_init
,
965 .display_init
= qemu_spice_display_init
,
966 .migrate_info
= qemu_spice_migrate_info
,
967 .set_passwd
= qemu_spice_set_passwd
,
968 .set_pw_expire
= qemu_spice_set_pw_expire
,
969 .display_add_client
= qemu_spice_display_add_client
,
970 .add_interface
= qemu_spice_add_interface
,
971 .qmp_query
= qmp_query_spice_real
,
974 static void spice_register_config(void)
976 qemu_spice
= real_spice_ops
;
977 qemu_add_opts(&qemu_spice_opts
);
979 opts_init(spice_register_config
);
980 module_opts("spice");
983 module_dep("ui-opengl");