xref: /illumos-kvm-cmd/ui/spice-core.c (revision 68396ea9)
1 /*
2  * Copyright (C) 2010 Red Hat, Inc.
3  *
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.
8  *
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.
13  *
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/>.
16  */
17 
18 #include <spice.h>
19 #include <spice-experimental.h>
20 
21 #include <netdb.h>
22 
23 #include "qemu-common.h"
24 #include "qemu-spice.h"
25 #include "qemu-timer.h"
26 #include "qemu-queue.h"
27 #include "qemu-x509.h"
28 #include "qemu_socket.h"
29 #include "qint.h"
30 #include "qbool.h"
31 #include "qstring.h"
32 #include "qjson.h"
33 #include "notify.h"
34 #include "migration.h"
35 #include "monitor.h"
36 #include "hw/hw.h"
37 
38 /* core bits */
39 
40 static SpiceServer *spice_server;
41 static Notifier migration_state;
42 static const char *auth = "spice";
43 static char *auth_passwd;
44 static time_t auth_expires = TIME_MAX;
45 int using_spice = 0;
46 
47 struct SpiceTimer {
48     QEMUTimer *timer;
49     QTAILQ_ENTRY(SpiceTimer) next;
50 };
51 static QTAILQ_HEAD(, SpiceTimer) timers = QTAILQ_HEAD_INITIALIZER(timers);
52 
timer_add(SpiceTimerFunc func,void * opaque)53 static SpiceTimer *timer_add(SpiceTimerFunc func, void *opaque)
54 {
55     SpiceTimer *timer;
56 
57     timer = qemu_mallocz(sizeof(*timer));
58     timer->timer = qemu_new_timer(rt_clock, func, opaque);
59     QTAILQ_INSERT_TAIL(&timers, timer, next);
60     return timer;
61 }
62 
timer_start(SpiceTimer * timer,uint32_t ms)63 static void timer_start(SpiceTimer *timer, uint32_t ms)
64 {
65     qemu_mod_timer(timer->timer, qemu_get_clock(rt_clock) + ms);
66 }
67 
timer_cancel(SpiceTimer * timer)68 static void timer_cancel(SpiceTimer *timer)
69 {
70     qemu_del_timer(timer->timer);
71 }
72 
timer_remove(SpiceTimer * timer)73 static void timer_remove(SpiceTimer *timer)
74 {
75     qemu_del_timer(timer->timer);
76     qemu_free_timer(timer->timer);
77     QTAILQ_REMOVE(&timers, timer, next);
78     qemu_free(timer);
79 }
80 
81 struct SpiceWatch {
82     int fd;
83     int event_mask;
84     SpiceWatchFunc func;
85     void *opaque;
86     QTAILQ_ENTRY(SpiceWatch) next;
87 };
88 static QTAILQ_HEAD(, SpiceWatch) watches = QTAILQ_HEAD_INITIALIZER(watches);
89 
watch_read(void * opaque)90 static void watch_read(void *opaque)
91 {
92     SpiceWatch *watch = opaque;
93     watch->func(watch->fd, SPICE_WATCH_EVENT_READ, watch->opaque);
94 }
95 
watch_write(void * opaque)96 static void watch_write(void *opaque)
97 {
98     SpiceWatch *watch = opaque;
99     watch->func(watch->fd, SPICE_WATCH_EVENT_WRITE, watch->opaque);
100 }
101 
watch_update_mask(SpiceWatch * watch,int event_mask)102 static void watch_update_mask(SpiceWatch *watch, int event_mask)
103 {
104     IOHandler *on_read = NULL;
105     IOHandler *on_write = NULL;
106 
107     watch->event_mask = event_mask;
108     if (watch->event_mask & SPICE_WATCH_EVENT_READ) {
109         on_read = watch_read;
110     }
111     if (watch->event_mask & SPICE_WATCH_EVENT_WRITE) {
112         on_write = watch_write;
113     }
114     qemu_set_fd_handler(watch->fd, on_read, on_write, watch);
115 }
116 
watch_add(int fd,int event_mask,SpiceWatchFunc func,void * opaque)117 static SpiceWatch *watch_add(int fd, int event_mask, SpiceWatchFunc func, void *opaque)
118 {
119     SpiceWatch *watch;
120 
121     watch = qemu_mallocz(sizeof(*watch));
122     watch->fd     = fd;
123     watch->func   = func;
124     watch->opaque = opaque;
125     QTAILQ_INSERT_TAIL(&watches, watch, next);
126 
127     watch_update_mask(watch, event_mask);
128     return watch;
129 }
130 
watch_remove(SpiceWatch * watch)131 static void watch_remove(SpiceWatch *watch)
132 {
133     watch_update_mask(watch, 0);
134     QTAILQ_REMOVE(&watches, watch, next);
135     qemu_free(watch);
136 }
137 
138 #if SPICE_INTERFACE_CORE_MINOR >= 3
139 
140 typedef struct ChannelList ChannelList;
141 struct ChannelList {
142     SpiceChannelEventInfo *info;
143     QTAILQ_ENTRY(ChannelList) link;
144 };
145 static QTAILQ_HEAD(, ChannelList) channel_list = QTAILQ_HEAD_INITIALIZER(channel_list);
146 
channel_list_add(SpiceChannelEventInfo * info)147 static void channel_list_add(SpiceChannelEventInfo *info)
148 {
149     ChannelList *item;
150 
151     item = qemu_mallocz(sizeof(*item));
152     item->info = info;
153     QTAILQ_INSERT_TAIL(&channel_list, item, link);
154 }
155 
channel_list_del(SpiceChannelEventInfo * info)156 static void channel_list_del(SpiceChannelEventInfo *info)
157 {
158     ChannelList *item;
159 
160     QTAILQ_FOREACH(item, &channel_list, link) {
161         if (item->info != info) {
162             continue;
163         }
164         QTAILQ_REMOVE(&channel_list, item, link);
165         qemu_free(item);
166         return;
167     }
168 }
169 
add_addr_info(QDict * dict,struct sockaddr * addr,int len)170 static void add_addr_info(QDict *dict, struct sockaddr *addr, int len)
171 {
172     char host[NI_MAXHOST], port[NI_MAXSERV];
173     const char *family;
174 
175     getnameinfo(addr, len, host, sizeof(host), port, sizeof(port),
176                 NI_NUMERICHOST | NI_NUMERICSERV);
177     family = inet_strfamily(addr->sa_family);
178 
179     qdict_put(dict, "host", qstring_from_str(host));
180     qdict_put(dict, "port", qstring_from_str(port));
181     qdict_put(dict, "family", qstring_from_str(family));
182 }
183 
add_channel_info(QDict * dict,SpiceChannelEventInfo * info)184 static void add_channel_info(QDict *dict, SpiceChannelEventInfo *info)
185 {
186     int tls = info->flags & SPICE_CHANNEL_EVENT_FLAG_TLS;
187 
188     qdict_put(dict, "connection-id", qint_from_int(info->connection_id));
189     qdict_put(dict, "channel-type", qint_from_int(info->type));
190     qdict_put(dict, "channel-id", qint_from_int(info->id));
191     qdict_put(dict, "tls", qbool_from_int(tls));
192 }
193 
channel_list_get(void)194 static QList *channel_list_get(void)
195 {
196     ChannelList *item;
197     QList *list;
198     QDict *dict;
199 
200     list = qlist_new();
201     QTAILQ_FOREACH(item, &channel_list, link) {
202         dict = qdict_new();
203         add_addr_info(dict, &item->info->paddr, item->info->plen);
204         add_channel_info(dict, item->info);
205         qlist_append(list, dict);
206     }
207     return list;
208 }
209 
channel_event(int event,SpiceChannelEventInfo * info)210 static void channel_event(int event, SpiceChannelEventInfo *info)
211 {
212     static const int qevent[] = {
213         [ SPICE_CHANNEL_EVENT_CONNECTED    ] = QEVENT_SPICE_CONNECTED,
214         [ SPICE_CHANNEL_EVENT_INITIALIZED  ] = QEVENT_SPICE_INITIALIZED,
215         [ SPICE_CHANNEL_EVENT_DISCONNECTED ] = QEVENT_SPICE_DISCONNECTED,
216     };
217     QDict *server, *client;
218     QObject *data;
219 
220     client = qdict_new();
221     add_addr_info(client, &info->paddr, info->plen);
222 
223     server = qdict_new();
224     add_addr_info(server, &info->laddr, info->llen);
225 
226     if (event == SPICE_CHANNEL_EVENT_INITIALIZED) {
227         qdict_put(server, "auth", qstring_from_str(auth));
228         add_channel_info(client, info);
229         channel_list_add(info);
230     }
231     if (event == SPICE_CHANNEL_EVENT_DISCONNECTED) {
232         channel_list_del(info);
233     }
234 
235     data = qobject_from_jsonf("{ 'client': %p, 'server': %p }",
236                               QOBJECT(client), QOBJECT(server));
237     monitor_protocol_event(qevent[event], data);
238     qobject_decref(data);
239 }
240 
241 #else /* SPICE_INTERFACE_CORE_MINOR >= 3 */
242 
channel_list_get(void)243 static QList *channel_list_get(void)
244 {
245     return NULL;
246 }
247 
248 #endif /* SPICE_INTERFACE_CORE_MINOR >= 3 */
249 
250 static SpiceCoreInterface core_interface = {
251     .base.type          = SPICE_INTERFACE_CORE,
252     .base.description   = "qemu core services",
253     .base.major_version = SPICE_INTERFACE_CORE_MAJOR,
254     .base.minor_version = SPICE_INTERFACE_CORE_MINOR,
255 
256     .timer_add          = timer_add,
257     .timer_start        = timer_start,
258     .timer_cancel       = timer_cancel,
259     .timer_remove       = timer_remove,
260 
261     .watch_add          = watch_add,
262     .watch_update_mask  = watch_update_mask,
263     .watch_remove       = watch_remove,
264 
265 #if SPICE_INTERFACE_CORE_MINOR >= 3
266     .channel_event      = channel_event,
267 #endif
268 };
269 
270 /* config string parsing */
271 
name2enum(const char * string,const char * table[],int entries)272 static int name2enum(const char *string, const char *table[], int entries)
273 {
274     int i;
275 
276     if (string) {
277         for (i = 0; i < entries; i++) {
278             if (!table[i]) {
279                 continue;
280             }
281             if (strcmp(string, table[i]) != 0) {
282                 continue;
283             }
284             return i;
285         }
286     }
287     return -1;
288 }
289 
parse_name(const char * string,const char * optname,const char * table[],int entries)290 static int parse_name(const char *string, const char *optname,
291                       const char *table[], int entries)
292 {
293     int value = name2enum(string, table, entries);
294 
295     if (value != -1) {
296         return value;
297     }
298     fprintf(stderr, "spice: invalid %s: %s\n", optname, string);
299     exit(1);
300 }
301 
302 #if SPICE_SERVER_VERSION >= 0x000600 /* 0.6.0 */
303 
304 static const char *stream_video_names[] = {
305     [ SPICE_STREAM_VIDEO_OFF ]    = "off",
306     [ SPICE_STREAM_VIDEO_ALL ]    = "all",
307     [ SPICE_STREAM_VIDEO_FILTER ] = "filter",
308 };
309 #define parse_stream_video(_name) \
310     name2enum(_name, stream_video_names, ARRAY_SIZE(stream_video_names))
311 
312 #endif /* >= 0.6.0 */
313 
314 static const char *compression_names[] = {
315     [ SPICE_IMAGE_COMPRESS_OFF ]      = "off",
316     [ SPICE_IMAGE_COMPRESS_AUTO_GLZ ] = "auto_glz",
317     [ SPICE_IMAGE_COMPRESS_AUTO_LZ ]  = "auto_lz",
318     [ SPICE_IMAGE_COMPRESS_QUIC ]     = "quic",
319     [ SPICE_IMAGE_COMPRESS_GLZ ]      = "glz",
320     [ SPICE_IMAGE_COMPRESS_LZ ]       = "lz",
321 };
322 #define parse_compression(_name)                                        \
323     parse_name(_name, "image compression",                              \
324                compression_names, ARRAY_SIZE(compression_names))
325 
326 static const char *wan_compression_names[] = {
327     [ SPICE_WAN_COMPRESSION_AUTO   ] = "auto",
328     [ SPICE_WAN_COMPRESSION_NEVER  ] = "never",
329     [ SPICE_WAN_COMPRESSION_ALWAYS ] = "always",
330 };
331 #define parse_wan_compression(_name)                                    \
332     parse_name(_name, "wan compression",                                \
333                wan_compression_names, ARRAY_SIZE(wan_compression_names))
334 
335 /* functions for the rest of qemu */
336 
info_spice_iter(QObject * obj,void * opaque)337 static void info_spice_iter(QObject *obj, void *opaque)
338 {
339     QDict *client;
340     Monitor *mon = opaque;
341 
342     client = qobject_to_qdict(obj);
343     monitor_printf(mon, "Channel:\n");
344     monitor_printf(mon, "     address: %s:%s%s\n",
345                    qdict_get_str(client, "host"),
346                    qdict_get_str(client, "port"),
347                    qdict_get_bool(client, "tls") ? " [tls]" : "");
348     monitor_printf(mon, "     session: %" PRId64 "\n",
349                    qdict_get_int(client, "connection-id"));
350     monitor_printf(mon, "     channel: %d:%d\n",
351                    (int)qdict_get_int(client, "channel-type"),
352                    (int)qdict_get_int(client, "channel-id"));
353 }
354 
do_info_spice_print(Monitor * mon,const QObject * data)355 void do_info_spice_print(Monitor *mon, const QObject *data)
356 {
357     QDict *server;
358     QList *channels;
359     const char *host;
360     int port;
361 
362     server = qobject_to_qdict(data);
363     if (qdict_get_bool(server, "enabled") == 0) {
364         monitor_printf(mon, "Server: disabled\n");
365         return;
366     }
367 
368     monitor_printf(mon, "Server:\n");
369     host = qdict_get_str(server, "host");
370     port = qdict_get_try_int(server, "port", -1);
371     if (port != -1) {
372         monitor_printf(mon, "     address: %s:%d\n", host, port);
373     }
374     port = qdict_get_try_int(server, "tls-port", -1);
375     if (port != -1) {
376         monitor_printf(mon, "     address: %s:%d [tls]\n", host, port);
377     }
378     monitor_printf(mon, "        auth: %s\n", qdict_get_str(server, "auth"));
379 
380     channels = qdict_get_qlist(server, "channels");
381     if (qlist_empty(channels)) {
382         monitor_printf(mon, "Channels: none\n");
383     } else {
384         qlist_iter(channels, info_spice_iter, mon);
385     }
386 }
387 
do_info_spice(Monitor * mon,QObject ** ret_data)388 void do_info_spice(Monitor *mon, QObject **ret_data)
389 {
390     QemuOpts *opts = QTAILQ_FIRST(&qemu_spice_opts.head);
391     QDict *server;
392     QList *clist;
393     const char *addr;
394     int port, tls_port;
395 
396     if (!spice_server) {
397         *ret_data = qobject_from_jsonf("{ 'enabled': false }");
398         return;
399     }
400 
401     addr = qemu_opt_get(opts, "addr");
402     port = qemu_opt_get_number(opts, "port", 0);
403     tls_port = qemu_opt_get_number(opts, "tls-port", 0);
404     clist = channel_list_get();
405 
406     server = qdict_new();
407     qdict_put(server, "enabled", qbool_from_int(true));
408     qdict_put(server, "auth", qstring_from_str(auth));
409     qdict_put(server, "host", qstring_from_str(addr ? addr : "0.0.0.0"));
410     if (port) {
411         qdict_put(server, "port", qint_from_int(port));
412     }
413     if (tls_port) {
414         qdict_put(server, "tls-port", qint_from_int(tls_port));
415     }
416     if (clist) {
417         qdict_put(server, "channels", clist);
418     }
419 
420     *ret_data = QOBJECT(server);
421 }
422 
migration_state_notifier(Notifier * notifier)423 static void migration_state_notifier(Notifier *notifier)
424 {
425     int state = get_migration_state();
426 
427     if (state == MIG_STATE_COMPLETED) {
428 #if SPICE_SERVER_VERSION >= 0x000701 /* 0.7.1 */
429         spice_server_migrate_switch(spice_server);
430 #endif
431     }
432 }
433 
qemu_spice_migrate_info(const char * hostname,int port,int tls_port,const char * subject)434 int qemu_spice_migrate_info(const char *hostname, int port, int tls_port,
435                             const char *subject)
436 {
437     return spice_server_migrate_info(spice_server, hostname,
438                                      port, tls_port, subject);
439 }
440 
add_channel(const char * name,const char * value,void * opaque)441 static int add_channel(const char *name, const char *value, void *opaque)
442 {
443     int security = 0;
444     int rc;
445 
446     if (strcmp(name, "tls-channel") == 0) {
447         security = SPICE_CHANNEL_SECURITY_SSL;
448     }
449     if (strcmp(name, "plaintext-channel") == 0) {
450         security = SPICE_CHANNEL_SECURITY_NONE;
451     }
452     if (security == 0) {
453         return 0;
454     }
455     if (strcmp(value, "default") == 0) {
456         rc = spice_server_set_channel_security(spice_server, NULL, security);
457     } else {
458         rc = spice_server_set_channel_security(spice_server, value, security);
459     }
460     if (rc != 0) {
461         fprintf(stderr, "spice: failed to set channel security for %s\n", value);
462         exit(1);
463     }
464     return 0;
465 }
466 
qemu_spice_init(void)467 void qemu_spice_init(void)
468 {
469     QemuOpts *opts = QTAILQ_FIRST(&qemu_spice_opts.head);
470     const char *password, *str, *x509_dir, *addr,
471         *x509_key_password = NULL,
472         *x509_dh_file = NULL,
473         *tls_ciphers = NULL;
474     char *x509_key_file = NULL,
475         *x509_cert_file = NULL,
476         *x509_cacert_file = NULL;
477     int port, tls_port, len, addr_flags;
478     spice_image_compression_t compression;
479     spice_wan_compression_t wan_compr;
480 
481     if (!opts) {
482         return;
483     }
484     port = qemu_opt_get_number(opts, "port", 0);
485     tls_port = qemu_opt_get_number(opts, "tls-port", 0);
486     if (!port && !tls_port) {
487         return;
488     }
489     password = qemu_opt_get(opts, "password");
490 
491     if (tls_port) {
492         x509_dir = qemu_opt_get(opts, "x509-dir");
493         if (NULL == x509_dir) {
494             x509_dir = ".";
495         }
496         len = strlen(x509_dir) + 32;
497 
498         str = qemu_opt_get(opts, "x509-key-file");
499         if (str) {
500             x509_key_file = qemu_strdup(str);
501         } else {
502             x509_key_file = qemu_malloc(len);
503             snprintf(x509_key_file, len, "%s/%s", x509_dir, X509_SERVER_KEY_FILE);
504         }
505 
506         str = qemu_opt_get(opts, "x509-cert-file");
507         if (str) {
508             x509_cert_file = qemu_strdup(str);
509         } else {
510             x509_cert_file = qemu_malloc(len);
511             snprintf(x509_cert_file, len, "%s/%s", x509_dir, X509_SERVER_CERT_FILE);
512         }
513 
514         str = qemu_opt_get(opts, "x509-cacert-file");
515         if (str) {
516             x509_cacert_file = qemu_strdup(str);
517         } else {
518             x509_cacert_file = qemu_malloc(len);
519             snprintf(x509_cacert_file, len, "%s/%s", x509_dir, X509_CA_CERT_FILE);
520         }
521 
522         x509_key_password = qemu_opt_get(opts, "x509-key-password");
523         x509_dh_file = qemu_opt_get(opts, "x509-dh-file");
524         tls_ciphers = qemu_opt_get(opts, "tls-ciphers");
525     }
526 
527     addr = qemu_opt_get(opts, "addr");
528     addr_flags = 0;
529     if (qemu_opt_get_bool(opts, "ipv4", 0)) {
530         addr_flags |= SPICE_ADDR_FLAG_IPV4_ONLY;
531     } else if (qemu_opt_get_bool(opts, "ipv6", 0)) {
532         addr_flags |= SPICE_ADDR_FLAG_IPV6_ONLY;
533     }
534 
535     spice_server = spice_server_new();
536     spice_server_set_addr(spice_server, addr ? addr : "", addr_flags);
537     if (port) {
538         spice_server_set_port(spice_server, port);
539     }
540     if (tls_port) {
541         spice_server_set_tls(spice_server, tls_port,
542                              x509_cacert_file,
543                              x509_cert_file,
544                              x509_key_file,
545                              x509_key_password,
546                              x509_dh_file,
547                              tls_ciphers);
548     }
549     if (password) {
550         spice_server_set_ticket(spice_server, password, 0, 0, 0);
551     }
552     if (qemu_opt_get_bool(opts, "disable-ticketing", 0)) {
553         auth = "none";
554         spice_server_set_noauth(spice_server);
555     }
556 
557     compression = SPICE_IMAGE_COMPRESS_AUTO_GLZ;
558     str = qemu_opt_get(opts, "image-compression");
559     if (str) {
560         compression = parse_compression(str);
561     }
562     spice_server_set_image_compression(spice_server, compression);
563 
564     wan_compr = SPICE_WAN_COMPRESSION_AUTO;
565     str = qemu_opt_get(opts, "jpeg-wan-compression");
566     if (str) {
567         wan_compr = parse_wan_compression(str);
568     }
569     spice_server_set_jpeg_compression(spice_server, wan_compr);
570 
571     wan_compr = SPICE_WAN_COMPRESSION_AUTO;
572     str = qemu_opt_get(opts, "zlib-glz-wan-compression");
573     if (str) {
574         wan_compr = parse_wan_compression(str);
575     }
576     spice_server_set_zlib_glz_compression(spice_server, wan_compr);
577 
578 #if SPICE_SERVER_VERSION >= 0x000600 /* 0.6.0 */
579 
580     str = qemu_opt_get(opts, "streaming-video");
581     if (str) {
582         int streaming_video = parse_stream_video(str);
583         spice_server_set_streaming_video(spice_server, streaming_video);
584     }
585 
586     spice_server_set_agent_mouse
587         (spice_server, qemu_opt_get_bool(opts, "agent-mouse", 1));
588     spice_server_set_playback_compression
589         (spice_server, qemu_opt_get_bool(opts, "playback-compression", 1));
590 
591 #endif /* >= 0.6.0 */
592 
593     qemu_opt_foreach(opts, add_channel, NULL, 0);
594 
595     spice_server_init(spice_server, &core_interface);
596     using_spice = 1;
597 
598     migration_state.notify = migration_state_notifier;
599     add_migration_state_change_notifier(&migration_state);
600 
601     qemu_spice_input_init();
602     qemu_spice_audio_init();
603 
604     qemu_free(x509_key_file);
605     qemu_free(x509_cert_file);
606     qemu_free(x509_cacert_file);
607 }
608 
qemu_spice_add_interface(SpiceBaseInstance * sin)609 int qemu_spice_add_interface(SpiceBaseInstance *sin)
610 {
611     if (!spice_server) {
612         if (QTAILQ_FIRST(&qemu_spice_opts.head) != NULL) {
613             fprintf(stderr, "Oops: spice configured but not active\n");
614             exit(1);
615         }
616         /*
617          * Create a spice server instance.
618          * It does *not* listen on the network.
619          * It handles QXL local rendering only.
620          *
621          * With a command line like '-vnc :0 -vga qxl' you'll end up here.
622          */
623         spice_server = spice_server_new();
624         spice_server_init(spice_server, &core_interface);
625     }
626     return spice_server_add_interface(spice_server, sin);
627 }
628 
qemu_spice_set_ticket(bool fail_if_conn,bool disconnect_if_conn)629 static int qemu_spice_set_ticket(bool fail_if_conn, bool disconnect_if_conn)
630 {
631     time_t lifetime, now = time(NULL);
632     char *passwd;
633 
634     if (now < auth_expires) {
635         passwd = auth_passwd;
636         lifetime = (auth_expires - now);
637         if (lifetime > INT_MAX) {
638             lifetime = INT_MAX;
639         }
640     } else {
641         passwd = NULL;
642         lifetime = 1;
643     }
644     return spice_server_set_ticket(spice_server, passwd, lifetime,
645                                    fail_if_conn, disconnect_if_conn);
646 }
647 
qemu_spice_set_passwd(const char * passwd,bool fail_if_conn,bool disconnect_if_conn)648 int qemu_spice_set_passwd(const char *passwd,
649                           bool fail_if_conn, bool disconnect_if_conn)
650 {
651     free(auth_passwd);
652     auth_passwd = strdup(passwd);
653     return qemu_spice_set_ticket(fail_if_conn, disconnect_if_conn);
654 }
655 
qemu_spice_set_pw_expire(time_t expires)656 int qemu_spice_set_pw_expire(time_t expires)
657 {
658     auth_expires = expires;
659     return qemu_spice_set_ticket(false, false);
660 }
661 
spice_register_config(void)662 static void spice_register_config(void)
663 {
664     qemu_add_opts(&qemu_spice_opts);
665 }
666 machine_init(spice_register_config);
667 
spice_initialize(void)668 static void spice_initialize(void)
669 {
670     qemu_spice_init();
671 }
672 device_init(spice_initialize);
673