Statistics
| Branch: | Revision:

root / ui / spice-core.c @ 84a23f25

History | View | Annotate | Download (10.9 kB)

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 "qemu-common.h"
22
#include "qemu-spice.h"
23
#include "qemu-timer.h"
24
#include "qemu-queue.h"
25
#include "qemu-x509.h"
26
#include "monitor.h"
27

    
28
/* core bits */
29

    
30
static SpiceServer *spice_server;
31
int using_spice = 0;
32

    
33
struct SpiceTimer {
34
    QEMUTimer *timer;
35
    QTAILQ_ENTRY(SpiceTimer) next;
36
};
37
static QTAILQ_HEAD(, SpiceTimer) timers = QTAILQ_HEAD_INITIALIZER(timers);
38

    
39
static SpiceTimer *timer_add(SpiceTimerFunc func, void *opaque)
40
{
41
    SpiceTimer *timer;
42

    
43
    timer = qemu_mallocz(sizeof(*timer));
44
    timer->timer = qemu_new_timer(rt_clock, func, opaque);
45
    QTAILQ_INSERT_TAIL(&timers, timer, next);
46
    return timer;
47
}
48

    
49
static void timer_start(SpiceTimer *timer, uint32_t ms)
50
{
51
    qemu_mod_timer(timer->timer, qemu_get_clock(rt_clock) + ms);
52
}
53

    
54
static void timer_cancel(SpiceTimer *timer)
55
{
56
    qemu_del_timer(timer->timer);
57
}
58

    
59
static void timer_remove(SpiceTimer *timer)
60
{
61
    qemu_del_timer(timer->timer);
62
    qemu_free_timer(timer->timer);
63
    QTAILQ_REMOVE(&timers, timer, next);
64
    qemu_free(timer);
65
}
66

    
67
struct SpiceWatch {
68
    int fd;
69
    int event_mask;
70
    SpiceWatchFunc func;
71
    void *opaque;
72
    QTAILQ_ENTRY(SpiceWatch) next;
73
};
74
static QTAILQ_HEAD(, SpiceWatch) watches = QTAILQ_HEAD_INITIALIZER(watches);
75

    
76
static void watch_read(void *opaque)
77
{
78
    SpiceWatch *watch = opaque;
79
    watch->func(watch->fd, SPICE_WATCH_EVENT_READ, watch->opaque);
80
}
81

    
82
static void watch_write(void *opaque)
83
{
84
    SpiceWatch *watch = opaque;
85
    watch->func(watch->fd, SPICE_WATCH_EVENT_WRITE, watch->opaque);
86
}
87

    
88
static void watch_update_mask(SpiceWatch *watch, int event_mask)
89
{
90
    IOHandler *on_read = NULL;
91
    IOHandler *on_write = NULL;
92

    
93
    watch->event_mask = event_mask;
94
    if (watch->event_mask & SPICE_WATCH_EVENT_READ) {
95
        on_read = watch_read;
96
    }
97
    if (watch->event_mask & SPICE_WATCH_EVENT_WRITE) {
98
        on_read = watch_write;
99
    }
100
    qemu_set_fd_handler(watch->fd, on_read, on_write, watch);
101
}
102

    
103
static SpiceWatch *watch_add(int fd, int event_mask, SpiceWatchFunc func, void *opaque)
104
{
105
    SpiceWatch *watch;
106

    
107
    watch = qemu_mallocz(sizeof(*watch));
108
    watch->fd     = fd;
109
    watch->func   = func;
110
    watch->opaque = opaque;
111
    QTAILQ_INSERT_TAIL(&watches, watch, next);
112

    
113
    watch_update_mask(watch, event_mask);
114
    return watch;
115
}
116

    
117
static void watch_remove(SpiceWatch *watch)
118
{
119
    watch_update_mask(watch, 0);
120
    QTAILQ_REMOVE(&watches, watch, next);
121
    qemu_free(watch);
122
}
123

    
124
static SpiceCoreInterface core_interface = {
125
    .base.type          = SPICE_INTERFACE_CORE,
126
    .base.description   = "qemu core services",
127
    .base.major_version = SPICE_INTERFACE_CORE_MAJOR,
128
    .base.minor_version = SPICE_INTERFACE_CORE_MINOR,
129

    
130
    .timer_add          = timer_add,
131
    .timer_start        = timer_start,
132
    .timer_cancel       = timer_cancel,
133
    .timer_remove       = timer_remove,
134

    
135
    .watch_add          = watch_add,
136
    .watch_update_mask  = watch_update_mask,
137
    .watch_remove       = watch_remove,
138
};
139

    
140
/* config string parsing */
141

    
142
static int name2enum(const char *string, const char *table[], int entries)
143
{
144
    int i;
145

    
146
    if (string) {
147
        for (i = 0; i < entries; i++) {
148
            if (!table[i]) {
149
                continue;
150
            }
151
            if (strcmp(string, table[i]) != 0) {
152
                continue;
153
            }
154
            return i;
155
        }
156
    }
157
    return -1;
158
}
159

    
160
static int parse_name(const char *string, const char *optname,
161
                      const char *table[], int entries)
162
{
163
    int value = name2enum(string, table, entries);
164

    
165
    if (value != -1) {
166
        return value;
167
    }
168
    fprintf(stderr, "spice: invalid %s: %s\n", optname, string);
169
    exit(1);
170
}
171

    
172
#if SPICE_SERVER_VERSION >= 0x000600 /* 0.6.0 */
173

    
174
static const char *stream_video_names[] = {
175
    [ SPICE_STREAM_VIDEO_OFF ]    = "off",
176
    [ SPICE_STREAM_VIDEO_ALL ]    = "all",
177
    [ SPICE_STREAM_VIDEO_FILTER ] = "filter",
178
};
179
#define parse_stream_video(_name) \
180
    name2enum(_name, stream_video_names, ARRAY_SIZE(stream_video_names))
181

    
182
#endif /* >= 0.6.0 */
183

    
184
static const char *compression_names[] = {
185
    [ SPICE_IMAGE_COMPRESS_OFF ]      = "off",
186
    [ SPICE_IMAGE_COMPRESS_AUTO_GLZ ] = "auto_glz",
187
    [ SPICE_IMAGE_COMPRESS_AUTO_LZ ]  = "auto_lz",
188
    [ SPICE_IMAGE_COMPRESS_QUIC ]     = "quic",
189
    [ SPICE_IMAGE_COMPRESS_GLZ ]      = "glz",
190
    [ SPICE_IMAGE_COMPRESS_LZ ]       = "lz",
191
};
192
#define parse_compression(_name)                                        \
193
    parse_name(_name, "image compression",                              \
194
               compression_names, ARRAY_SIZE(compression_names))
195

    
196
static const char *wan_compression_names[] = {
197
    [ SPICE_WAN_COMPRESSION_AUTO   ] = "auto",
198
    [ SPICE_WAN_COMPRESSION_NEVER  ] = "never",
199
    [ SPICE_WAN_COMPRESSION_ALWAYS ] = "always",
200
};
201
#define parse_wan_compression(_name)                                    \
202
    parse_name(_name, "wan compression",                                \
203
               wan_compression_names, ARRAY_SIZE(wan_compression_names))
204

    
205
/* functions for the rest of qemu */
206

    
207
static int add_channel(const char *name, const char *value, void *opaque)
208
{
209
    int security = 0;
210
    int rc;
211

    
212
    if (strcmp(name, "tls-channel") == 0) {
213
        security = SPICE_CHANNEL_SECURITY_SSL;
214
    }
215
    if (strcmp(name, "plaintext-channel") == 0) {
216
        security = SPICE_CHANNEL_SECURITY_NONE;
217
    }
218
    if (security == 0) {
219
        return 0;
220
    }
221
    if (strcmp(value, "default") == 0) {
222
        rc = spice_server_set_channel_security(spice_server, NULL, security);
223
    } else {
224
        rc = spice_server_set_channel_security(spice_server, value, security);
225
    }
226
    if (rc != 0) {
227
        fprintf(stderr, "spice: failed to set channel security for %s\n", value);
228
        exit(1);
229
    }
230
    return 0;
231
}
232

    
233
void qemu_spice_init(void)
234
{
235
    QemuOpts *opts = QTAILQ_FIRST(&qemu_spice_opts.head);
236
    const char *password, *str, *x509_dir, *addr,
237
        *x509_key_password = NULL,
238
        *x509_dh_file = NULL,
239
        *tls_ciphers = NULL;
240
    char *x509_key_file = NULL,
241
        *x509_cert_file = NULL,
242
        *x509_cacert_file = NULL;
243
    int port, tls_port, len, addr_flags, streaming_video;
244
    spice_image_compression_t compression;
245
    spice_wan_compression_t wan_compr;
246

    
247
    if (!opts) {
248
        return;
249
    }
250
    port = qemu_opt_get_number(opts, "port", 0);
251
    tls_port = qemu_opt_get_number(opts, "tls-port", 0);
252
    if (!port && !tls_port) {
253
        return;
254
    }
255
    password = qemu_opt_get(opts, "password");
256

    
257
    if (tls_port) {
258
        x509_dir = qemu_opt_get(opts, "x509-dir");
259
        if (NULL == x509_dir) {
260
            x509_dir = ".";
261
        }
262
        len = strlen(x509_dir) + 32;
263

    
264
        str = qemu_opt_get(opts, "x509-key-file");
265
        if (str) {
266
            x509_key_file = qemu_strdup(str);
267
        } else {
268
            x509_key_file = qemu_malloc(len);
269
            snprintf(x509_key_file, len, "%s/%s", x509_dir, X509_SERVER_KEY_FILE);
270
        }
271

    
272
        str = qemu_opt_get(opts, "x509-cert-file");
273
        if (str) {
274
            x509_cert_file = qemu_strdup(str);
275
        } else {
276
            x509_cert_file = qemu_malloc(len);
277
            snprintf(x509_cert_file, len, "%s/%s", x509_dir, X509_SERVER_CERT_FILE);
278
        }
279

    
280
        str = qemu_opt_get(opts, "x509-cacert-file");
281
        if (str) {
282
            x509_cacert_file = qemu_strdup(str);
283
        } else {
284
            x509_cacert_file = qemu_malloc(len);
285
            snprintf(x509_cacert_file, len, "%s/%s", x509_dir, X509_CA_CERT_FILE);
286
        }
287

    
288
        x509_key_password = qemu_opt_get(opts, "x509-key-password");
289
        x509_dh_file = qemu_opt_get(opts, "x509-dh-file");
290
        tls_ciphers = qemu_opt_get(opts, "tls-ciphers");
291
    }
292

    
293
    addr = qemu_opt_get(opts, "addr");
294
    addr_flags = 0;
295
    if (qemu_opt_get_bool(opts, "ipv4", 0)) {
296
        addr_flags |= SPICE_ADDR_FLAG_IPV4_ONLY;
297
    } else if (qemu_opt_get_bool(opts, "ipv6", 0)) {
298
        addr_flags |= SPICE_ADDR_FLAG_IPV6_ONLY;
299
    }
300

    
301
    spice_server = spice_server_new();
302
    spice_server_set_addr(spice_server, addr ? addr : "", addr_flags);
303
    if (port) {
304
        spice_server_set_port(spice_server, port);
305
    }
306
    if (tls_port) {
307
        spice_server_set_tls(spice_server, tls_port,
308
                             x509_cacert_file,
309
                             x509_cert_file,
310
                             x509_key_file,
311
                             x509_key_password,
312
                             x509_dh_file,
313
                             tls_ciphers);
314
    }
315
    if (password) {
316
        spice_server_set_ticket(spice_server, password, 0, 0, 0);
317
    }
318
    if (qemu_opt_get_bool(opts, "disable-ticketing", 0)) {
319
        spice_server_set_noauth(spice_server);
320
    }
321

    
322
    compression = SPICE_IMAGE_COMPRESS_AUTO_GLZ;
323
    str = qemu_opt_get(opts, "image-compression");
324
    if (str) {
325
        compression = parse_compression(str);
326
    }
327
    spice_server_set_image_compression(spice_server, compression);
328

    
329
    wan_compr = SPICE_WAN_COMPRESSION_AUTO;
330
    str = qemu_opt_get(opts, "jpeg-wan-compression");
331
    if (str) {
332
        wan_compr = parse_wan_compression(str);
333
    }
334
    spice_server_set_jpeg_compression(spice_server, wan_compr);
335

    
336
    wan_compr = SPICE_WAN_COMPRESSION_AUTO;
337
    str = qemu_opt_get(opts, "zlib-glz-wan-compression");
338
    if (str) {
339
        wan_compr = parse_wan_compression(str);
340
    }
341
    spice_server_set_zlib_glz_compression(spice_server, wan_compr);
342

    
343
#if SPICE_SERVER_VERSION >= 0x000600 /* 0.6.0 */
344

    
345
    str = qemu_opt_get(opts, "streaming-video");
346
    if (str) {
347
        streaming_video = parse_stream_video(str);
348
        spice_server_set_streaming_video(spice_server, streaming_video);
349
    }
350

    
351
    spice_server_set_agent_mouse
352
        (spice_server, qemu_opt_get_bool(opts, "agent-mouse", 1));
353
    spice_server_set_playback_compression
354
        (spice_server, qemu_opt_get_bool(opts, "playback-compression", 1));
355

    
356
#endif /* >= 0.6.0 */
357

    
358
    qemu_opt_foreach(opts, add_channel, NULL, 0);
359

    
360
    spice_server_init(spice_server, &core_interface);
361
    using_spice = 1;
362

    
363
    qemu_spice_input_init();
364

    
365
    qemu_free(x509_key_file);
366
    qemu_free(x509_cert_file);
367
    qemu_free(x509_cacert_file);
368
}
369

    
370
int qemu_spice_add_interface(SpiceBaseInstance *sin)
371
{
372
    return spice_server_add_interface(spice_server, sin);
373
}
374

    
375
static void spice_register_config(void)
376
{
377
    qemu_add_opts(&qemu_spice_opts);
378
}
379
machine_init(spice_register_config);
380

    
381
static void spice_initialize(void)
382
{
383
    qemu_spice_init();
384
}
385
device_init(spice_initialize);