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/>.
19 #include <spice-experimental.h>
23 #include "qemu-common.h"
24 #include "qemu-spice.h"
25 #include "qemu-thread.h"
26 #include "qemu-timer.h"
27 #include "qemu-queue.h"
28 #include "qemu-x509.h"
29 #include "qemu_socket.h"
30 #include "qmp-commands.h"
36 #include "migration.h"
42 static SpiceServer
*spice_server
;
43 static Notifier migration_state
;
44 static const char *auth
= "spice";
45 static char *auth_passwd
;
46 static time_t auth_expires
= TIME_MAX
;
53 QTAILQ_ENTRY(SpiceTimer
) next
;
55 static QTAILQ_HEAD(, SpiceTimer
) timers
= QTAILQ_HEAD_INITIALIZER(timers
);
57 static SpiceTimer
*timer_add(SpiceTimerFunc func
, void *opaque
)
61 timer
= g_malloc0(sizeof(*timer
));
62 timer
->timer
= qemu_new_timer_ms(rt_clock
, func
, opaque
);
63 QTAILQ_INSERT_TAIL(&timers
, timer
, next
);
67 static void timer_start(SpiceTimer
*timer
, uint32_t ms
)
69 qemu_mod_timer(timer
->timer
, qemu_get_clock_ms(rt_clock
) + ms
);
72 static void timer_cancel(SpiceTimer
*timer
)
74 qemu_del_timer(timer
->timer
);
77 static void timer_remove(SpiceTimer
*timer
)
79 qemu_del_timer(timer
->timer
);
80 qemu_free_timer(timer
->timer
);
81 QTAILQ_REMOVE(&timers
, timer
, next
);
90 QTAILQ_ENTRY(SpiceWatch
) next
;
92 static QTAILQ_HEAD(, SpiceWatch
) watches
= QTAILQ_HEAD_INITIALIZER(watches
);
94 static void watch_read(void *opaque
)
96 SpiceWatch
*watch
= opaque
;
97 watch
->func(watch
->fd
, SPICE_WATCH_EVENT_READ
, watch
->opaque
);
100 static void watch_write(void *opaque
)
102 SpiceWatch
*watch
= opaque
;
103 watch
->func(watch
->fd
, SPICE_WATCH_EVENT_WRITE
, watch
->opaque
);
106 static void watch_update_mask(SpiceWatch
*watch
, int event_mask
)
108 IOHandler
*on_read
= NULL
;
109 IOHandler
*on_write
= NULL
;
111 watch
->event_mask
= event_mask
;
112 if (watch
->event_mask
& SPICE_WATCH_EVENT_READ
) {
113 on_read
= watch_read
;
115 if (watch
->event_mask
& SPICE_WATCH_EVENT_WRITE
) {
116 on_write
= watch_write
;
118 qemu_set_fd_handler(watch
->fd
, on_read
, on_write
, watch
);
121 static SpiceWatch
*watch_add(int fd
, int event_mask
, SpiceWatchFunc func
, void *opaque
)
125 watch
= g_malloc0(sizeof(*watch
));
128 watch
->opaque
= opaque
;
129 QTAILQ_INSERT_TAIL(&watches
, watch
, next
);
131 watch_update_mask(watch
, event_mask
);
135 static void watch_remove(SpiceWatch
*watch
)
137 qemu_set_fd_handler(watch
->fd
, NULL
, NULL
, NULL
);
138 QTAILQ_REMOVE(&watches
, watch
, next
);
142 #if SPICE_INTERFACE_CORE_MINOR >= 3
144 typedef struct ChannelList ChannelList
;
146 SpiceChannelEventInfo
*info
;
147 QTAILQ_ENTRY(ChannelList
) link
;
149 static QTAILQ_HEAD(, ChannelList
) channel_list
= QTAILQ_HEAD_INITIALIZER(channel_list
);
151 static void channel_list_add(SpiceChannelEventInfo
*info
)
155 item
= g_malloc0(sizeof(*item
));
157 QTAILQ_INSERT_TAIL(&channel_list
, item
, link
);
160 static void channel_list_del(SpiceChannelEventInfo
*info
)
164 QTAILQ_FOREACH(item
, &channel_list
, link
) {
165 if (item
->info
!= info
) {
168 QTAILQ_REMOVE(&channel_list
, item
, link
);
174 static void add_addr_info(QDict
*dict
, struct sockaddr
*addr
, int len
)
176 char host
[NI_MAXHOST
], port
[NI_MAXSERV
];
179 getnameinfo(addr
, len
, host
, sizeof(host
), port
, sizeof(port
),
180 NI_NUMERICHOST
| NI_NUMERICSERV
);
181 family
= inet_strfamily(addr
->sa_family
);
183 qdict_put(dict
, "host", qstring_from_str(host
));
184 qdict_put(dict
, "port", qstring_from_str(port
));
185 qdict_put(dict
, "family", qstring_from_str(family
));
188 static void add_channel_info(QDict
*dict
, SpiceChannelEventInfo
*info
)
190 int tls
= info
->flags
& SPICE_CHANNEL_EVENT_FLAG_TLS
;
192 qdict_put(dict
, "connection-id", qint_from_int(info
->connection_id
));
193 qdict_put(dict
, "channel-type", qint_from_int(info
->type
));
194 qdict_put(dict
, "channel-id", qint_from_int(info
->id
));
195 qdict_put(dict
, "tls", qbool_from_int(tls
));
198 static void channel_event(int event
, SpiceChannelEventInfo
*info
)
200 static const int qevent
[] = {
201 [ SPICE_CHANNEL_EVENT_CONNECTED
] = QEVENT_SPICE_CONNECTED
,
202 [ SPICE_CHANNEL_EVENT_INITIALIZED
] = QEVENT_SPICE_INITIALIZED
,
203 [ SPICE_CHANNEL_EVENT_DISCONNECTED
] = QEVENT_SPICE_DISCONNECTED
,
205 QDict
*server
, *client
;
209 * Spice server might have called us from spice worker thread
210 * context (happens on display channel disconnects). Spice should
211 * not do that. It isn't that easy to fix it in spice and even
212 * when it is fixed we still should cover the already released
213 * spice versions. So detect that we've been called from another
214 * thread and grab the iothread lock if so before calling qemu
217 bool need_lock
= !qemu_thread_is_self(&me
);
219 qemu_mutex_lock_iothread();
222 client
= qdict_new();
223 server
= qdict_new();
225 #ifdef SPICE_CHANNEL_EVENT_FLAG_ADDR_EXT
226 if (info
->flags
& SPICE_CHANNEL_EVENT_FLAG_ADDR_EXT
) {
227 add_addr_info(client
, (struct sockaddr
*)&info
->paddr_ext
,
229 add_addr_info(server
, (struct sockaddr
*)&info
->laddr_ext
,
232 fprintf(stderr
, "spice: %s, extended address is expected\n",
235 add_addr_info(client
, &info
->paddr
, info
->plen
);
236 add_addr_info(server
, &info
->laddr
, info
->llen
);
237 #ifdef SPICE_CHANNEL_EVENT_FLAG_ADDR_EXT
241 if (event
== SPICE_CHANNEL_EVENT_INITIALIZED
) {
242 qdict_put(server
, "auth", qstring_from_str(auth
));
243 add_channel_info(client
, info
);
244 channel_list_add(info
);
246 if (event
== SPICE_CHANNEL_EVENT_DISCONNECTED
) {
247 channel_list_del(info
);
250 data
= qobject_from_jsonf("{ 'client': %p, 'server': %p }",
251 QOBJECT(client
), QOBJECT(server
));
252 monitor_protocol_event(qevent
[event
], data
);
253 qobject_decref(data
);
256 qemu_mutex_unlock_iothread();
260 #else /* SPICE_INTERFACE_CORE_MINOR >= 3 */
262 static QList
*channel_list_get(void)
267 #endif /* SPICE_INTERFACE_CORE_MINOR >= 3 */
269 static SpiceCoreInterface core_interface
= {
270 .base
.type
= SPICE_INTERFACE_CORE
,
271 .base
.description
= "qemu core services",
272 .base
.major_version
= SPICE_INTERFACE_CORE_MAJOR
,
273 .base
.minor_version
= SPICE_INTERFACE_CORE_MINOR
,
275 .timer_add
= timer_add
,
276 .timer_start
= timer_start
,
277 .timer_cancel
= timer_cancel
,
278 .timer_remove
= timer_remove
,
280 .watch_add
= watch_add
,
281 .watch_update_mask
= watch_update_mask
,
282 .watch_remove
= watch_remove
,
284 #if SPICE_INTERFACE_CORE_MINOR >= 3
285 .channel_event
= channel_event
,
289 #ifdef SPICE_INTERFACE_MIGRATION
290 typedef struct SpiceMigration
{
291 SpiceMigrateInstance sin
;
293 MonitorCompletion
*cb
;
298 static void migrate_connect_complete_cb(SpiceMigrateInstance
*sin
);
300 static const SpiceMigrateInterface migrate_interface
= {
301 .base
.type
= SPICE_INTERFACE_MIGRATION
,
302 .base
.description
= "migration",
303 .base
.major_version
= SPICE_INTERFACE_MIGRATION_MAJOR
,
304 .base
.minor_version
= SPICE_INTERFACE_MIGRATION_MINOR
,
305 .migrate_connect_complete
= migrate_connect_complete_cb
,
306 .migrate_end_complete
= NULL
,
309 static SpiceMigration spice_migrate
;
311 static void migrate_connect_complete_cb(SpiceMigrateInstance
*sin
)
313 SpiceMigration
*sm
= container_of(sin
, SpiceMigration
, sin
);
314 if (sm
->connect_complete
.cb
) {
315 sm
->connect_complete
.cb(sm
->connect_complete
.opaque
, NULL
);
317 sm
->connect_complete
.cb
= NULL
;
321 /* config string parsing */
323 static int name2enum(const char *string
, const char *table
[], int entries
)
328 for (i
= 0; i
< entries
; i
++) {
332 if (strcmp(string
, table
[i
]) != 0) {
341 static int parse_name(const char *string
, const char *optname
,
342 const char *table
[], int entries
)
344 int value
= name2enum(string
, table
, entries
);
349 fprintf(stderr
, "spice: invalid %s: %s\n", optname
, string
);
353 static const char *stream_video_names
[] = {
354 [ SPICE_STREAM_VIDEO_OFF
] = "off",
355 [ SPICE_STREAM_VIDEO_ALL
] = "all",
356 [ SPICE_STREAM_VIDEO_FILTER
] = "filter",
358 #define parse_stream_video(_name) \
359 name2enum(_name, stream_video_names, ARRAY_SIZE(stream_video_names))
361 static const char *compression_names
[] = {
362 [ SPICE_IMAGE_COMPRESS_OFF
] = "off",
363 [ SPICE_IMAGE_COMPRESS_AUTO_GLZ
] = "auto_glz",
364 [ SPICE_IMAGE_COMPRESS_AUTO_LZ
] = "auto_lz",
365 [ SPICE_IMAGE_COMPRESS_QUIC
] = "quic",
366 [ SPICE_IMAGE_COMPRESS_GLZ
] = "glz",
367 [ SPICE_IMAGE_COMPRESS_LZ
] = "lz",
369 #define parse_compression(_name) \
370 parse_name(_name, "image compression", \
371 compression_names, ARRAY_SIZE(compression_names))
373 static const char *wan_compression_names
[] = {
374 [ SPICE_WAN_COMPRESSION_AUTO
] = "auto",
375 [ SPICE_WAN_COMPRESSION_NEVER
] = "never",
376 [ SPICE_WAN_COMPRESSION_ALWAYS
] = "always",
378 #define parse_wan_compression(_name) \
379 parse_name(_name, "wan compression", \
380 wan_compression_names, ARRAY_SIZE(wan_compression_names))
382 /* functions for the rest of qemu */
384 static SpiceChannelList
*qmp_query_spice_channels(void)
386 SpiceChannelList
*cur_item
= NULL
, *head
= NULL
;
389 QTAILQ_FOREACH(item
, &channel_list
, link
) {
390 SpiceChannelList
*chan
;
391 char host
[NI_MAXHOST
], port
[NI_MAXSERV
];
392 struct sockaddr
*paddr
;
395 chan
= g_malloc0(sizeof(*chan
));
396 chan
->value
= g_malloc0(sizeof(*chan
->value
));
398 #ifdef SPICE_CHANNEL_EVENT_FLAG_ADDR_EXT
399 if (item
->info
->flags
& SPICE_CHANNEL_EVENT_FLAG_ADDR_EXT
) {
400 paddr
= (struct sockaddr
*)&item
->info
->paddr_ext
;
401 plen
= item
->info
->plen_ext
;
404 paddr
= &item
->info
->paddr
;
405 plen
= item
->info
->plen
;
406 #ifdef SPICE_CHANNEL_EVENT_FLAG_ADDR_EXT
410 getnameinfo(paddr
, plen
,
411 host
, sizeof(host
), port
, sizeof(port
),
412 NI_NUMERICHOST
| NI_NUMERICSERV
);
413 chan
->value
->host
= g_strdup(host
);
414 chan
->value
->port
= g_strdup(port
);
415 chan
->value
->family
= g_strdup(inet_strfamily(paddr
->sa_family
));
417 chan
->value
->connection_id
= item
->info
->connection_id
;
418 chan
->value
->channel_type
= item
->info
->type
;
419 chan
->value
->channel_id
= item
->info
->id
;
420 chan
->value
->tls
= item
->info
->flags
& SPICE_CHANNEL_EVENT_FLAG_TLS
;
422 /* XXX: waiting for the qapi to support GSList */
424 head
= cur_item
= chan
;
426 cur_item
->next
= chan
;
434 SpiceInfo
*qmp_query_spice(Error
**errp
)
436 QemuOpts
*opts
= QTAILQ_FIRST(&qemu_spice_opts
.head
);
440 char version_string
[20]; /* 12 = |255.255.255\0| is the max */
442 info
= g_malloc0(sizeof(*info
));
444 if (!spice_server
|| !opts
) {
445 info
->enabled
= false;
449 info
->enabled
= true;
451 addr
= qemu_opt_get(opts
, "addr");
452 port
= qemu_opt_get_number(opts
, "port", 0);
453 tls_port
= qemu_opt_get_number(opts
, "tls-port", 0);
455 info
->has_auth
= true;
456 info
->auth
= g_strdup(auth
);
458 info
->has_host
= true;
459 info
->host
= g_strdup(addr
? addr
: "0.0.0.0");
461 info
->has_compiled_version
= true;
462 snprintf(version_string
, sizeof(version_string
), "%d.%d.%d",
463 (SPICE_SERVER_VERSION
& 0xff0000) >> 16,
464 (SPICE_SERVER_VERSION
& 0xff00) >> 8,
465 SPICE_SERVER_VERSION
& 0xff);
466 info
->compiled_version
= g_strdup(version_string
);
469 info
->has_port
= true;
473 info
->has_tls_port
= true;
474 info
->tls_port
= tls_port
;
477 /* for compatibility with the original command */
478 info
->has_channels
= true;
479 info
->channels
= qmp_query_spice_channels();
484 static void migration_state_notifier(Notifier
*notifier
, void *data
)
486 MigrationState
*s
= data
;
488 if (migration_is_active(s
)) {
489 #ifdef SPICE_INTERFACE_MIGRATION
490 spice_server_migrate_start(spice_server
);
492 } else if (migration_has_finished(s
)) {
493 #if SPICE_SERVER_VERSION >= 0x000701 /* 0.7.1 */
494 #ifndef SPICE_INTERFACE_MIGRATION
495 spice_server_migrate_switch(spice_server
);
497 spice_server_migrate_end(spice_server
, true);
498 } else if (migration_has_failed(s
)) {
499 spice_server_migrate_end(spice_server
, false);
505 int qemu_spice_migrate_info(const char *hostname
, int port
, int tls_port
,
507 MonitorCompletion
*cb
, void *opaque
)
510 #ifdef SPICE_INTERFACE_MIGRATION
511 spice_migrate
.connect_complete
.cb
= cb
;
512 spice_migrate
.connect_complete
.opaque
= opaque
;
513 ret
= spice_server_migrate_connect(spice_server
, hostname
,
514 port
, tls_port
, subject
);
516 ret
= spice_server_migrate_info(spice_server
, hostname
,
517 port
, tls_port
, subject
);
523 static int add_channel(const char *name
, const char *value
, void *opaque
)
528 if (strcmp(name
, "tls-channel") == 0) {
529 security
= SPICE_CHANNEL_SECURITY_SSL
;
531 if (strcmp(name
, "plaintext-channel") == 0) {
532 security
= SPICE_CHANNEL_SECURITY_NONE
;
537 if (strcmp(value
, "default") == 0) {
538 rc
= spice_server_set_channel_security(spice_server
, NULL
, security
);
540 rc
= spice_server_set_channel_security(spice_server
, value
, security
);
543 fprintf(stderr
, "spice: failed to set channel security for %s\n", value
);
549 void qemu_spice_init(void)
551 QemuOpts
*opts
= QTAILQ_FIRST(&qemu_spice_opts
.head
);
552 const char *password
, *str
, *x509_dir
, *addr
,
553 *x509_key_password
= NULL
,
554 *x509_dh_file
= NULL
,
556 char *x509_key_file
= NULL
,
557 *x509_cert_file
= NULL
,
558 *x509_cacert_file
= NULL
;
559 int port
, tls_port
, len
, addr_flags
;
560 spice_image_compression_t compression
;
561 spice_wan_compression_t wan_compr
;
563 qemu_thread_get_self(&me
);
568 port
= qemu_opt_get_number(opts
, "port", 0);
569 tls_port
= qemu_opt_get_number(opts
, "tls-port", 0);
570 if (!port
&& !tls_port
) {
571 fprintf(stderr
, "neither port nor tls-port specified for spice.");
574 if (port
< 0 || port
> 65535) {
575 fprintf(stderr
, "spice port is out of range");
578 if (tls_port
< 0 || tls_port
> 65535) {
579 fprintf(stderr
, "spice tls-port is out of range");
582 password
= qemu_opt_get(opts
, "password");
585 x509_dir
= qemu_opt_get(opts
, "x509-dir");
586 if (NULL
== x509_dir
) {
589 len
= strlen(x509_dir
) + 32;
591 str
= qemu_opt_get(opts
, "x509-key-file");
593 x509_key_file
= g_strdup(str
);
595 x509_key_file
= g_malloc(len
);
596 snprintf(x509_key_file
, len
, "%s/%s", x509_dir
, X509_SERVER_KEY_FILE
);
599 str
= qemu_opt_get(opts
, "x509-cert-file");
601 x509_cert_file
= g_strdup(str
);
603 x509_cert_file
= g_malloc(len
);
604 snprintf(x509_cert_file
, len
, "%s/%s", x509_dir
, X509_SERVER_CERT_FILE
);
607 str
= qemu_opt_get(opts
, "x509-cacert-file");
609 x509_cacert_file
= g_strdup(str
);
611 x509_cacert_file
= g_malloc(len
);
612 snprintf(x509_cacert_file
, len
, "%s/%s", x509_dir
, X509_CA_CERT_FILE
);
615 x509_key_password
= qemu_opt_get(opts
, "x509-key-password");
616 x509_dh_file
= qemu_opt_get(opts
, "x509-dh-file");
617 tls_ciphers
= qemu_opt_get(opts
, "tls-ciphers");
620 addr
= qemu_opt_get(opts
, "addr");
622 if (qemu_opt_get_bool(opts
, "ipv4", 0)) {
623 addr_flags
|= SPICE_ADDR_FLAG_IPV4_ONLY
;
624 } else if (qemu_opt_get_bool(opts
, "ipv6", 0)) {
625 addr_flags
|= SPICE_ADDR_FLAG_IPV6_ONLY
;
628 spice_server
= spice_server_new();
629 spice_server_set_addr(spice_server
, addr
? addr
: "", addr_flags
);
631 spice_server_set_port(spice_server
, port
);
634 spice_server_set_tls(spice_server
, tls_port
,
643 spice_server_set_ticket(spice_server
, password
, 0, 0, 0);
645 if (qemu_opt_get_bool(opts
, "sasl", 0)) {
646 #if SPICE_SERVER_VERSION >= 0x000900 /* 0.9.0 */
647 if (spice_server_set_sasl_appname(spice_server
, "qemu") == -1 ||
648 spice_server_set_sasl(spice_server
, 1) == -1) {
649 fprintf(stderr
, "spice: failed to enable sasl\n");
653 fprintf(stderr
, "spice: sasl is not available (spice >= 0.9 required)\n");
657 if (qemu_opt_get_bool(opts
, "disable-ticketing", 0)) {
659 spice_server_set_noauth(spice_server
);
662 #if SPICE_SERVER_VERSION >= 0x000801
663 if (qemu_opt_get_bool(opts
, "disable-copy-paste", 0)) {
664 spice_server_set_agent_copypaste(spice_server
, false);
668 compression
= SPICE_IMAGE_COMPRESS_AUTO_GLZ
;
669 str
= qemu_opt_get(opts
, "image-compression");
671 compression
= parse_compression(str
);
673 spice_server_set_image_compression(spice_server
, compression
);
675 wan_compr
= SPICE_WAN_COMPRESSION_AUTO
;
676 str
= qemu_opt_get(opts
, "jpeg-wan-compression");
678 wan_compr
= parse_wan_compression(str
);
680 spice_server_set_jpeg_compression(spice_server
, wan_compr
);
682 wan_compr
= SPICE_WAN_COMPRESSION_AUTO
;
683 str
= qemu_opt_get(opts
, "zlib-glz-wan-compression");
685 wan_compr
= parse_wan_compression(str
);
687 spice_server_set_zlib_glz_compression(spice_server
, wan_compr
);
689 str
= qemu_opt_get(opts
, "streaming-video");
691 int streaming_video
= parse_stream_video(str
);
692 spice_server_set_streaming_video(spice_server
, streaming_video
);
695 spice_server_set_agent_mouse
696 (spice_server
, qemu_opt_get_bool(opts
, "agent-mouse", 1));
697 spice_server_set_playback_compression
698 (spice_server
, qemu_opt_get_bool(opts
, "playback-compression", 1));
700 qemu_opt_foreach(opts
, add_channel
, NULL
, 0);
702 if (0 != spice_server_init(spice_server
, &core_interface
)) {
703 fprintf(stderr
, "failed to initialize spice server");
708 migration_state
.notify
= migration_state_notifier
;
709 add_migration_state_change_notifier(&migration_state
);
710 #ifdef SPICE_INTERFACE_MIGRATION
711 spice_migrate
.sin
.base
.sif
= &migrate_interface
.base
;
712 spice_migrate
.connect_complete
.cb
= NULL
;
713 qemu_spice_add_interface(&spice_migrate
.sin
.base
);
716 qemu_spice_input_init();
717 qemu_spice_audio_init();
719 g_free(x509_key_file
);
720 g_free(x509_cert_file
);
721 g_free(x509_cacert_file
);
724 int qemu_spice_add_interface(SpiceBaseInstance
*sin
)
727 if (QTAILQ_FIRST(&qemu_spice_opts
.head
) != NULL
) {
728 fprintf(stderr
, "Oops: spice configured but not active\n");
732 * Create a spice server instance.
733 * It does *not* listen on the network.
734 * It handles QXL local rendering only.
736 * With a command line like '-vnc :0 -vga qxl' you'll end up here.
738 spice_server
= spice_server_new();
739 spice_server_init(spice_server
, &core_interface
);
741 return spice_server_add_interface(spice_server
, sin
);
744 static int qemu_spice_set_ticket(bool fail_if_conn
, bool disconnect_if_conn
)
746 time_t lifetime
, now
= time(NULL
);
749 if (now
< auth_expires
) {
750 passwd
= auth_passwd
;
751 lifetime
= (auth_expires
- now
);
752 if (lifetime
> INT_MAX
) {
759 return spice_server_set_ticket(spice_server
, passwd
, lifetime
,
760 fail_if_conn
, disconnect_if_conn
);
763 int qemu_spice_set_passwd(const char *passwd
,
764 bool fail_if_conn
, bool disconnect_if_conn
)
767 auth_passwd
= strdup(passwd
);
768 return qemu_spice_set_ticket(fail_if_conn
, disconnect_if_conn
);
771 int qemu_spice_set_pw_expire(time_t expires
)
773 auth_expires
= expires
;
774 return qemu_spice_set_ticket(false, false);
777 int qemu_spice_display_add_client(int csock
, int skipauth
, int tls
)
779 #if SPICE_SERVER_VERSION >= 0x000a01
781 return spice_server_add_ssl_client(spice_server
, csock
, skipauth
);
783 return spice_server_add_client(spice_server
, csock
, skipauth
);
790 static void spice_register_config(void)
792 qemu_add_opts(&qemu_spice_opts
);
794 machine_init(spice_register_config
);
796 static void spice_register_types(void)
801 type_init(spice_register_types
)