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>
24 #include "qemu-common.h"
25 #include "qemu-spice.h"
26 #include "qemu-thread.h"
27 #include "qemu-timer.h"
28 #include "qemu-queue.h"
29 #include "qemu-x509.h"
30 #include "qemu_socket.h"
31 #include "qmp-commands.h"
37 #include "migration.h"
43 static SpiceServer
*spice_server
;
44 static Notifier migration_state
;
45 static const char *auth
= "spice";
46 static char *auth_passwd
;
47 static time_t auth_expires
= TIME_MAX
;
54 QTAILQ_ENTRY(SpiceTimer
) next
;
56 static QTAILQ_HEAD(, SpiceTimer
) timers
= QTAILQ_HEAD_INITIALIZER(timers
);
58 static SpiceTimer
*timer_add(SpiceTimerFunc func
, void *opaque
)
62 timer
= g_malloc0(sizeof(*timer
));
63 timer
->timer
= qemu_new_timer_ms(rt_clock
, func
, opaque
);
64 QTAILQ_INSERT_TAIL(&timers
, timer
, next
);
68 static void timer_start(SpiceTimer
*timer
, uint32_t ms
)
70 qemu_mod_timer(timer
->timer
, qemu_get_clock_ms(rt_clock
) + ms
);
73 static void timer_cancel(SpiceTimer
*timer
)
75 qemu_del_timer(timer
->timer
);
78 static void timer_remove(SpiceTimer
*timer
)
80 qemu_del_timer(timer
->timer
);
81 qemu_free_timer(timer
->timer
);
82 QTAILQ_REMOVE(&timers
, timer
, next
);
91 QTAILQ_ENTRY(SpiceWatch
) next
;
93 static QTAILQ_HEAD(, SpiceWatch
) watches
= QTAILQ_HEAD_INITIALIZER(watches
);
95 static void watch_read(void *opaque
)
97 SpiceWatch
*watch
= opaque
;
98 watch
->func(watch
->fd
, SPICE_WATCH_EVENT_READ
, watch
->opaque
);
101 static void watch_write(void *opaque
)
103 SpiceWatch
*watch
= opaque
;
104 watch
->func(watch
->fd
, SPICE_WATCH_EVENT_WRITE
, watch
->opaque
);
107 static void watch_update_mask(SpiceWatch
*watch
, int event_mask
)
109 IOHandler
*on_read
= NULL
;
110 IOHandler
*on_write
= NULL
;
112 watch
->event_mask
= event_mask
;
113 if (watch
->event_mask
& SPICE_WATCH_EVENT_READ
) {
114 on_read
= watch_read
;
116 if (watch
->event_mask
& SPICE_WATCH_EVENT_WRITE
) {
117 on_write
= watch_write
;
119 qemu_set_fd_handler(watch
->fd
, on_read
, on_write
, watch
);
122 static SpiceWatch
*watch_add(int fd
, int event_mask
, SpiceWatchFunc func
, void *opaque
)
126 watch
= g_malloc0(sizeof(*watch
));
129 watch
->opaque
= opaque
;
130 QTAILQ_INSERT_TAIL(&watches
, watch
, next
);
132 watch_update_mask(watch
, event_mask
);
136 static void watch_remove(SpiceWatch
*watch
)
138 qemu_set_fd_handler(watch
->fd
, NULL
, NULL
, NULL
);
139 QTAILQ_REMOVE(&watches
, watch
, next
);
143 typedef struct ChannelList ChannelList
;
145 SpiceChannelEventInfo
*info
;
146 QTAILQ_ENTRY(ChannelList
) link
;
148 static QTAILQ_HEAD(, ChannelList
) channel_list
= QTAILQ_HEAD_INITIALIZER(channel_list
);
150 static void channel_list_add(SpiceChannelEventInfo
*info
)
154 item
= g_malloc0(sizeof(*item
));
156 QTAILQ_INSERT_TAIL(&channel_list
, item
, link
);
159 static void channel_list_del(SpiceChannelEventInfo
*info
)
163 QTAILQ_FOREACH(item
, &channel_list
, link
) {
164 if (item
->info
!= info
) {
167 QTAILQ_REMOVE(&channel_list
, item
, link
);
173 static void add_addr_info(QDict
*dict
, struct sockaddr
*addr
, int len
)
175 char host
[NI_MAXHOST
], port
[NI_MAXSERV
];
178 getnameinfo(addr
, len
, host
, sizeof(host
), port
, sizeof(port
),
179 NI_NUMERICHOST
| NI_NUMERICSERV
);
180 family
= inet_strfamily(addr
->sa_family
);
182 qdict_put(dict
, "host", qstring_from_str(host
));
183 qdict_put(dict
, "port", qstring_from_str(port
));
184 qdict_put(dict
, "family", qstring_from_str(family
));
187 static void add_channel_info(QDict
*dict
, SpiceChannelEventInfo
*info
)
189 int tls
= info
->flags
& SPICE_CHANNEL_EVENT_FLAG_TLS
;
191 qdict_put(dict
, "connection-id", qint_from_int(info
->connection_id
));
192 qdict_put(dict
, "channel-type", qint_from_int(info
->type
));
193 qdict_put(dict
, "channel-id", qint_from_int(info
->id
));
194 qdict_put(dict
, "tls", qbool_from_int(tls
));
197 static void channel_event(int event
, SpiceChannelEventInfo
*info
)
199 static const int qevent
[] = {
200 [ SPICE_CHANNEL_EVENT_CONNECTED
] = QEVENT_SPICE_CONNECTED
,
201 [ SPICE_CHANNEL_EVENT_INITIALIZED
] = QEVENT_SPICE_INITIALIZED
,
202 [ SPICE_CHANNEL_EVENT_DISCONNECTED
] = QEVENT_SPICE_DISCONNECTED
,
204 QDict
*server
, *client
;
208 * Spice server might have called us from spice worker thread
209 * context (happens on display channel disconnects). Spice should
210 * not do that. It isn't that easy to fix it in spice and even
211 * when it is fixed we still should cover the already released
212 * spice versions. So detect that we've been called from another
213 * thread and grab the iothread lock if so before calling qemu
216 bool need_lock
= !qemu_thread_is_self(&me
);
218 qemu_mutex_lock_iothread();
221 client
= qdict_new();
222 server
= qdict_new();
224 #ifdef SPICE_CHANNEL_EVENT_FLAG_ADDR_EXT
225 if (info
->flags
& SPICE_CHANNEL_EVENT_FLAG_ADDR_EXT
) {
226 add_addr_info(client
, (struct sockaddr
*)&info
->paddr_ext
,
228 add_addr_info(server
, (struct sockaddr
*)&info
->laddr_ext
,
231 error_report("spice: %s, extended address is expected",
234 add_addr_info(client
, &info
->paddr
, info
->plen
);
235 add_addr_info(server
, &info
->laddr
, info
->llen
);
236 #ifdef SPICE_CHANNEL_EVENT_FLAG_ADDR_EXT
240 if (event
== SPICE_CHANNEL_EVENT_INITIALIZED
) {
241 qdict_put(server
, "auth", qstring_from_str(auth
));
242 add_channel_info(client
, info
);
243 channel_list_add(info
);
245 if (event
== SPICE_CHANNEL_EVENT_DISCONNECTED
) {
246 channel_list_del(info
);
249 data
= qobject_from_jsonf("{ 'client': %p, 'server': %p }",
250 QOBJECT(client
), QOBJECT(server
));
251 monitor_protocol_event(qevent
[event
], data
);
252 qobject_decref(data
);
255 qemu_mutex_unlock_iothread();
259 static SpiceCoreInterface core_interface
= {
260 .base
.type
= SPICE_INTERFACE_CORE
,
261 .base
.description
= "qemu core services",
262 .base
.major_version
= SPICE_INTERFACE_CORE_MAJOR
,
263 .base
.minor_version
= SPICE_INTERFACE_CORE_MINOR
,
265 .timer_add
= timer_add
,
266 .timer_start
= timer_start
,
267 .timer_cancel
= timer_cancel
,
268 .timer_remove
= timer_remove
,
270 .watch_add
= watch_add
,
271 .watch_update_mask
= watch_update_mask
,
272 .watch_remove
= watch_remove
,
274 .channel_event
= channel_event
,
277 #ifdef SPICE_INTERFACE_MIGRATION
278 typedef struct SpiceMigration
{
279 SpiceMigrateInstance sin
;
281 MonitorCompletion
*cb
;
286 static void migrate_connect_complete_cb(SpiceMigrateInstance
*sin
);
288 static const SpiceMigrateInterface migrate_interface
= {
289 .base
.type
= SPICE_INTERFACE_MIGRATION
,
290 .base
.description
= "migration",
291 .base
.major_version
= SPICE_INTERFACE_MIGRATION_MAJOR
,
292 .base
.minor_version
= SPICE_INTERFACE_MIGRATION_MINOR
,
293 .migrate_connect_complete
= migrate_connect_complete_cb
,
294 .migrate_end_complete
= NULL
,
297 static SpiceMigration spice_migrate
;
299 static void migrate_connect_complete_cb(SpiceMigrateInstance
*sin
)
301 SpiceMigration
*sm
= container_of(sin
, SpiceMigration
, sin
);
302 if (sm
->connect_complete
.cb
) {
303 sm
->connect_complete
.cb(sm
->connect_complete
.opaque
, NULL
);
305 sm
->connect_complete
.cb
= NULL
;
309 /* config string parsing */
311 static int name2enum(const char *string
, const char *table
[], int entries
)
316 for (i
= 0; i
< entries
; i
++) {
320 if (strcmp(string
, table
[i
]) != 0) {
329 static int parse_name(const char *string
, const char *optname
,
330 const char *table
[], int entries
)
332 int value
= name2enum(string
, table
, entries
);
337 error_report("spice: invalid %s: %s", optname
, string
);
341 static const char *stream_video_names
[] = {
342 [ SPICE_STREAM_VIDEO_OFF
] = "off",
343 [ SPICE_STREAM_VIDEO_ALL
] = "all",
344 [ SPICE_STREAM_VIDEO_FILTER
] = "filter",
346 #define parse_stream_video(_name) \
347 parse_name(_name, "stream video control", \
348 stream_video_names, ARRAY_SIZE(stream_video_names))
350 static const char *compression_names
[] = {
351 [ SPICE_IMAGE_COMPRESS_OFF
] = "off",
352 [ SPICE_IMAGE_COMPRESS_AUTO_GLZ
] = "auto_glz",
353 [ SPICE_IMAGE_COMPRESS_AUTO_LZ
] = "auto_lz",
354 [ SPICE_IMAGE_COMPRESS_QUIC
] = "quic",
355 [ SPICE_IMAGE_COMPRESS_GLZ
] = "glz",
356 [ SPICE_IMAGE_COMPRESS_LZ
] = "lz",
358 #define parse_compression(_name) \
359 parse_name(_name, "image compression", \
360 compression_names, ARRAY_SIZE(compression_names))
362 static const char *wan_compression_names
[] = {
363 [ SPICE_WAN_COMPRESSION_AUTO
] = "auto",
364 [ SPICE_WAN_COMPRESSION_NEVER
] = "never",
365 [ SPICE_WAN_COMPRESSION_ALWAYS
] = "always",
367 #define parse_wan_compression(_name) \
368 parse_name(_name, "wan compression", \
369 wan_compression_names, ARRAY_SIZE(wan_compression_names))
371 /* functions for the rest of qemu */
373 static SpiceChannelList
*qmp_query_spice_channels(void)
375 SpiceChannelList
*cur_item
= NULL
, *head
= NULL
;
378 QTAILQ_FOREACH(item
, &channel_list
, link
) {
379 SpiceChannelList
*chan
;
380 char host
[NI_MAXHOST
], port
[NI_MAXSERV
];
381 struct sockaddr
*paddr
;
384 chan
= g_malloc0(sizeof(*chan
));
385 chan
->value
= g_malloc0(sizeof(*chan
->value
));
387 #ifdef SPICE_CHANNEL_EVENT_FLAG_ADDR_EXT
388 if (item
->info
->flags
& SPICE_CHANNEL_EVENT_FLAG_ADDR_EXT
) {
389 paddr
= (struct sockaddr
*)&item
->info
->paddr_ext
;
390 plen
= item
->info
->plen_ext
;
393 paddr
= &item
->info
->paddr
;
394 plen
= item
->info
->plen
;
395 #ifdef SPICE_CHANNEL_EVENT_FLAG_ADDR_EXT
399 getnameinfo(paddr
, plen
,
400 host
, sizeof(host
), port
, sizeof(port
),
401 NI_NUMERICHOST
| NI_NUMERICSERV
);
402 chan
->value
->host
= g_strdup(host
);
403 chan
->value
->port
= g_strdup(port
);
404 chan
->value
->family
= g_strdup(inet_strfamily(paddr
->sa_family
));
406 chan
->value
->connection_id
= item
->info
->connection_id
;
407 chan
->value
->channel_type
= item
->info
->type
;
408 chan
->value
->channel_id
= item
->info
->id
;
409 chan
->value
->tls
= item
->info
->flags
& SPICE_CHANNEL_EVENT_FLAG_TLS
;
411 /* XXX: waiting for the qapi to support GSList */
413 head
= cur_item
= chan
;
415 cur_item
->next
= chan
;
423 SpiceInfo
*qmp_query_spice(Error
**errp
)
425 QemuOpts
*opts
= QTAILQ_FIRST(&qemu_spice_opts
.head
);
429 char version_string
[20]; /* 12 = |255.255.255\0| is the max */
431 info
= g_malloc0(sizeof(*info
));
433 if (!spice_server
|| !opts
) {
434 info
->enabled
= false;
438 info
->enabled
= true;
440 addr
= qemu_opt_get(opts
, "addr");
441 port
= qemu_opt_get_number(opts
, "port", 0);
442 tls_port
= qemu_opt_get_number(opts
, "tls-port", 0);
444 info
->has_auth
= true;
445 info
->auth
= g_strdup(auth
);
447 info
->has_host
= true;
448 info
->host
= g_strdup(addr
? addr
: "0.0.0.0");
450 info
->has_compiled_version
= true;
451 snprintf(version_string
, sizeof(version_string
), "%d.%d.%d",
452 (SPICE_SERVER_VERSION
& 0xff0000) >> 16,
453 (SPICE_SERVER_VERSION
& 0xff00) >> 8,
454 SPICE_SERVER_VERSION
& 0xff);
455 info
->compiled_version
= g_strdup(version_string
);
458 info
->has_port
= true;
462 info
->has_tls_port
= true;
463 info
->tls_port
= tls_port
;
466 #if SPICE_SERVER_VERSION >= 0x000a03 /* 0.10.3 */
467 info
->mouse_mode
= spice_server_is_server_mouse(spice_server
) ?
468 SPICE_QUERY_MOUSE_MODE_SERVER
:
469 SPICE_QUERY_MOUSE_MODE_CLIENT
;
471 info
->mouse_mode
= SPICE_QUERY_MOUSE_MODE_UNKNOWN
;
473 /* for compatibility with the original command */
474 info
->has_channels
= true;
475 info
->channels
= qmp_query_spice_channels();
480 static void migration_state_notifier(Notifier
*notifier
, void *data
)
482 MigrationState
*s
= data
;
484 if (migration_is_active(s
)) {
485 #ifdef SPICE_INTERFACE_MIGRATION
486 spice_server_migrate_start(spice_server
);
488 } else if (migration_has_finished(s
)) {
489 #ifndef SPICE_INTERFACE_MIGRATION
490 spice_server_migrate_switch(spice_server
);
492 spice_server_migrate_end(spice_server
, true);
493 } else if (migration_has_failed(s
)) {
494 spice_server_migrate_end(spice_server
, false);
499 int qemu_spice_migrate_info(const char *hostname
, int port
, int tls_port
,
501 MonitorCompletion
*cb
, void *opaque
)
504 #ifdef SPICE_INTERFACE_MIGRATION
505 spice_migrate
.connect_complete
.cb
= cb
;
506 spice_migrate
.connect_complete
.opaque
= opaque
;
507 ret
= spice_server_migrate_connect(spice_server
, hostname
,
508 port
, tls_port
, subject
);
510 ret
= spice_server_migrate_info(spice_server
, hostname
,
511 port
, tls_port
, subject
);
517 static int add_channel(const char *name
, const char *value
, void *opaque
)
522 if (strcmp(name
, "tls-channel") == 0) {
523 int *tls_port
= opaque
;
525 error_report("spice: tried to setup tls-channel"
526 " without specifying a TLS port");
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 error_report("spice: failed to set channel security for %s", value
);
549 static void vm_change_state_handler(void *opaque
, int running
,
552 #if SPICE_SERVER_VERSION >= 0x000b02 /* 0.11.2 */
554 spice_server_vm_start(spice_server
);
556 spice_server_vm_stop(spice_server
);
561 void qemu_spice_init(void)
563 QemuOpts
*opts
= QTAILQ_FIRST(&qemu_spice_opts
.head
);
564 const char *password
, *str
, *x509_dir
, *addr
,
565 *x509_key_password
= NULL
,
566 *x509_dh_file
= NULL
,
568 char *x509_key_file
= NULL
,
569 *x509_cert_file
= NULL
,
570 *x509_cacert_file
= NULL
;
571 int port
, tls_port
, len
, addr_flags
;
572 spice_image_compression_t compression
;
573 spice_wan_compression_t wan_compr
;
575 qemu_thread_get_self(&me
);
580 port
= qemu_opt_get_number(opts
, "port", 0);
581 tls_port
= qemu_opt_get_number(opts
, "tls-port", 0);
582 if (!port
&& !tls_port
) {
583 error_report("neither port nor tls-port specified for spice");
586 if (port
< 0 || port
> 65535) {
587 error_report("spice port is out of range");
590 if (tls_port
< 0 || tls_port
> 65535) {
591 error_report("spice tls-port is out of range");
594 password
= qemu_opt_get(opts
, "password");
597 x509_dir
= qemu_opt_get(opts
, "x509-dir");
598 if (NULL
== x509_dir
) {
601 len
= strlen(x509_dir
) + 32;
603 str
= qemu_opt_get(opts
, "x509-key-file");
605 x509_key_file
= g_strdup(str
);
607 x509_key_file
= g_malloc(len
);
608 snprintf(x509_key_file
, len
, "%s/%s", x509_dir
, X509_SERVER_KEY_FILE
);
611 str
= qemu_opt_get(opts
, "x509-cert-file");
613 x509_cert_file
= g_strdup(str
);
615 x509_cert_file
= g_malloc(len
);
616 snprintf(x509_cert_file
, len
, "%s/%s", x509_dir
, X509_SERVER_CERT_FILE
);
619 str
= qemu_opt_get(opts
, "x509-cacert-file");
621 x509_cacert_file
= g_strdup(str
);
623 x509_cacert_file
= g_malloc(len
);
624 snprintf(x509_cacert_file
, len
, "%s/%s", x509_dir
, X509_CA_CERT_FILE
);
627 x509_key_password
= qemu_opt_get(opts
, "x509-key-password");
628 x509_dh_file
= qemu_opt_get(opts
, "x509-dh-file");
629 tls_ciphers
= qemu_opt_get(opts
, "tls-ciphers");
632 addr
= qemu_opt_get(opts
, "addr");
634 if (qemu_opt_get_bool(opts
, "ipv4", 0)) {
635 addr_flags
|= SPICE_ADDR_FLAG_IPV4_ONLY
;
636 } else if (qemu_opt_get_bool(opts
, "ipv6", 0)) {
637 addr_flags
|= SPICE_ADDR_FLAG_IPV6_ONLY
;
640 spice_server
= spice_server_new();
641 spice_server_set_addr(spice_server
, addr
? addr
: "", addr_flags
);
643 spice_server_set_port(spice_server
, port
);
646 spice_server_set_tls(spice_server
, tls_port
,
655 spice_server_set_ticket(spice_server
, password
, 0, 0, 0);
657 if (qemu_opt_get_bool(opts
, "sasl", 0)) {
658 #if SPICE_SERVER_VERSION >= 0x000900 /* 0.9.0 */
659 if (spice_server_set_sasl_appname(spice_server
, "qemu") == -1 ||
660 spice_server_set_sasl(spice_server
, 1) == -1) {
661 error_report("spice: failed to enable sasl");
665 error_report("spice: sasl is not available (spice >= 0.9 required)");
669 if (qemu_opt_get_bool(opts
, "disable-ticketing", 0)) {
671 spice_server_set_noauth(spice_server
);
674 if (qemu_opt_get_bool(opts
, "disable-copy-paste", 0)) {
675 spice_server_set_agent_copypaste(spice_server
, false);
678 compression
= SPICE_IMAGE_COMPRESS_AUTO_GLZ
;
679 str
= qemu_opt_get(opts
, "image-compression");
681 compression
= parse_compression(str
);
683 spice_server_set_image_compression(spice_server
, compression
);
685 wan_compr
= SPICE_WAN_COMPRESSION_AUTO
;
686 str
= qemu_opt_get(opts
, "jpeg-wan-compression");
688 wan_compr
= parse_wan_compression(str
);
690 spice_server_set_jpeg_compression(spice_server
, wan_compr
);
692 wan_compr
= SPICE_WAN_COMPRESSION_AUTO
;
693 str
= qemu_opt_get(opts
, "zlib-glz-wan-compression");
695 wan_compr
= parse_wan_compression(str
);
697 spice_server_set_zlib_glz_compression(spice_server
, wan_compr
);
699 str
= qemu_opt_get(opts
, "streaming-video");
701 int streaming_video
= parse_stream_video(str
);
702 spice_server_set_streaming_video(spice_server
, streaming_video
);
705 spice_server_set_agent_mouse
706 (spice_server
, qemu_opt_get_bool(opts
, "agent-mouse", 1));
707 spice_server_set_playback_compression
708 (spice_server
, qemu_opt_get_bool(opts
, "playback-compression", 1));
710 qemu_opt_foreach(opts
, add_channel
, &tls_port
, 0);
712 #if SPICE_SERVER_VERSION >= 0x000a02 /* 0.10.2 */
713 spice_server_set_name(spice_server
, qemu_name
);
714 spice_server_set_uuid(spice_server
, qemu_uuid
);
717 if (0 != spice_server_init(spice_server
, &core_interface
)) {
718 error_report("failed to initialize spice server");
723 migration_state
.notify
= migration_state_notifier
;
724 add_migration_state_change_notifier(&migration_state
);
725 #ifdef SPICE_INTERFACE_MIGRATION
726 spice_migrate
.sin
.base
.sif
= &migrate_interface
.base
;
727 spice_migrate
.connect_complete
.cb
= NULL
;
728 qemu_spice_add_interface(&spice_migrate
.sin
.base
);
731 qemu_spice_input_init();
732 qemu_spice_audio_init();
734 qemu_add_vm_change_state_handler(vm_change_state_handler
, &spice_server
);
736 g_free(x509_key_file
);
737 g_free(x509_cert_file
);
738 g_free(x509_cacert_file
);
741 int qemu_spice_add_interface(SpiceBaseInstance
*sin
)
744 if (QTAILQ_FIRST(&qemu_spice_opts
.head
) != NULL
) {
745 error_report("Oops: spice configured but not active");
749 * Create a spice server instance.
750 * It does *not* listen on the network.
751 * It handles QXL local rendering only.
753 * With a command line like '-vnc :0 -vga qxl' you'll end up here.
755 spice_server
= spice_server_new();
756 spice_server_init(spice_server
, &core_interface
);
758 return spice_server_add_interface(spice_server
, sin
);
761 static int qemu_spice_set_ticket(bool fail_if_conn
, bool disconnect_if_conn
)
763 time_t lifetime
, now
= time(NULL
);
766 if (now
< auth_expires
) {
767 passwd
= auth_passwd
;
768 lifetime
= (auth_expires
- now
);
769 if (lifetime
> INT_MAX
) {
776 return spice_server_set_ticket(spice_server
, passwd
, lifetime
,
777 fail_if_conn
, disconnect_if_conn
);
780 int qemu_spice_set_passwd(const char *passwd
,
781 bool fail_if_conn
, bool disconnect_if_conn
)
784 auth_passwd
= strdup(passwd
);
785 return qemu_spice_set_ticket(fail_if_conn
, disconnect_if_conn
);
788 int qemu_spice_set_pw_expire(time_t expires
)
790 auth_expires
= expires
;
791 return qemu_spice_set_ticket(false, false);
794 int qemu_spice_display_add_client(int csock
, int skipauth
, int tls
)
796 #if SPICE_SERVER_VERSION >= 0x000a01
798 return spice_server_add_ssl_client(spice_server
, csock
, skipauth
);
800 return spice_server_add_client(spice_server
, csock
, skipauth
);
807 static void spice_register_config(void)
809 qemu_add_opts(&qemu_spice_opts
);
811 machine_init(spice_register_config
);