?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
CRIS: Use a helper for lz.
[qemu/qemu-JZ.git] / vnc.c
blob575fd68983d21ba8c95c56ff2ca85526198d93b4
1 /*
2 * QEMU VNC display driver
3 *
4 * Copyright (C) 2006 Anthony Liguori <anthony@codemonkey.ws>
5 * Copyright (C) 2006 Fabrice Bellard
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a copy
8 * of this software and associated documentation files (the "Software"), to deal
9 * in the Software without restriction, including without limitation the rights
10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 * copies of the Software, and to permit persons to whom the Software is
12 * furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23 * THE SOFTWARE.
24 */
25
26 #include "qemu-common.h"
27 #include "console.h"
28 #include "sysemu.h"
29 #include "qemu_socket.h"
30 #include "qemu-timer.h"
31 #include "audio/audio.h"
32
33 #define VNC_REFRESH_INTERVAL (1000 / 30)
34
35 #include "vnc_keysym.h"
36 #include "keymaps.c"
37 #include "d3des.h"
38
39 #ifdef CONFIG_VNC_TLS
40 #include <gnutls/gnutls.h>
41 #include <gnutls/x509.h>
42 #endif /* CONFIG_VNC_TLS */
43
44 // #define _VNC_DEBUG 1
45
46 #ifdef _VNC_DEBUG
47 #define VNC_DEBUG(fmt, ...) do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
48
49 #if CONFIG_VNC_TLS && _VNC_DEBUG >= 2
50 /* Very verbose, so only enabled for _VNC_DEBUG >= 2 */
51 static void vnc_debug_gnutls_log(int level, const char* str) {
52 VNC_DEBUG("%d %s", level, str);
53 }
54 #endif /* CONFIG_VNC_TLS && _VNC_DEBUG */
55 #else
56 #define VNC_DEBUG(fmt, ...) do { } while (0)
57 #endif
58
59
60 typedef struct Buffer
61 {
62 size_t capacity;
63 size_t offset;
64 uint8_t *buffer;
65 } Buffer;
66
67 typedef struct VncState VncState;
68
69 typedef int VncReadEvent(VncState *vs, uint8_t *data, size_t len);
70
71 typedef void VncWritePixels(VncState *vs, void *data, int size);
72
73 typedef void VncSendHextileTile(VncState *vs,
74 int x, int y, int w, int h,
75 void *last_bg,
76 void *last_fg,
77 int *has_bg, int *has_fg);
78
79 #define VNC_MAX_WIDTH 2048
80 #define VNC_MAX_HEIGHT 2048
81 #define VNC_DIRTY_WORDS (VNC_MAX_WIDTH / (16 * 32))
82
83 #define VNC_AUTH_CHALLENGE_SIZE 16
84
85 enum {
86 VNC_AUTH_INVALID = 0,
87 VNC_AUTH_NONE = 1,
88 VNC_AUTH_VNC = 2,
89 VNC_AUTH_RA2 = 5,
90 VNC_AUTH_RA2NE = 6,
91 VNC_AUTH_TIGHT = 16,
92 VNC_AUTH_ULTRA = 17,
93 VNC_AUTH_TLS = 18,
94 VNC_AUTH_VENCRYPT = 19
95 };
96
97 #ifdef CONFIG_VNC_TLS
98 enum {
99 VNC_WIREMODE_CLEAR,
100 VNC_WIREMODE_TLS,
101 };
102
103 enum {
104 VNC_AUTH_VENCRYPT_PLAIN = 256,
105 VNC_AUTH_VENCRYPT_TLSNONE = 257,
106 VNC_AUTH_VENCRYPT_TLSVNC = 258,
107 VNC_AUTH_VENCRYPT_TLSPLAIN = 259,
108 VNC_AUTH_VENCRYPT_X509NONE = 260,
109 VNC_AUTH_VENCRYPT_X509VNC = 261,
110 VNC_AUTH_VENCRYPT_X509PLAIN = 262,
111 };
112
113 #define X509_CA_CERT_FILE "ca-cert.pem"
114 #define X509_CA_CRL_FILE "ca-crl.pem"
115 #define X509_SERVER_KEY_FILE "server-key.pem"
116 #define X509_SERVER_CERT_FILE "server-cert.pem"
117
118 #endif /* CONFIG_VNC_TLS */
119
120 struct VncState
121 {
122 QEMUTimer *timer;
123 int lsock;
124 int csock;
125 DisplayState *ds;
126 int need_update;
127 int width;
128 int height;
129 uint32_t dirty_row[VNC_MAX_HEIGHT][VNC_DIRTY_WORDS];
130 char *old_data;
131 int depth; /* internal VNC frame buffer byte per pixel */
132 int has_resize;
133 int has_hextile;
134 int has_pointer_type_change;
135 int has_WMVi;
136 int absolute;
137 int last_x;
138 int last_y;
139
140 int major;
141 int minor;
142
143 char *display;
144 char *password;
145 int auth;
146 #ifdef CONFIG_VNC_TLS
147 int subauth;
148 int x509verify;
149
150 char *x509cacert;
151 char *x509cacrl;
152 char *x509cert;
153 char *x509key;
154 #endif
155 char challenge[VNC_AUTH_CHALLENGE_SIZE];
156
157 #ifdef CONFIG_VNC_TLS
158 int wiremode;
159 gnutls_session_t tls_session;
160 #endif
161
162 Buffer output;
163 Buffer input;
164 kbd_layout_t *kbd_layout;
165 /* current output mode information */
166 VncWritePixels *write_pixels;
167 VncSendHextileTile *send_hextile_tile;
168 int pix_bpp, pix_big_endian;
169 int client_red_shift, client_red_max, server_red_shift, server_red_max;
170 int client_green_shift, client_green_max, server_green_shift, server_green_max;
171 int client_blue_shift, client_blue_max, server_blue_shift, server_blue_max;
172
173 CaptureVoiceOut *audio_cap;
174 struct audsettings as;
175
176 VncReadEvent *read_handler;
177 size_t read_handler_expect;
178 /* input */
179 uint8_t modifiers_state[256];
180 };
181
182 static VncState *vnc_state; /* needed for info vnc */
183
184 void do_info_vnc(void)
185 {
186 if (vnc_state == NULL || vnc_state->display == NULL)
187 term_printf("VNC server disabled\n");
188 else {
189 term_printf("VNC server active on: ");
190 term_print_filename(vnc_state->display);
191 term_printf("\n");
192
193 if (vnc_state->csock == -1)
194 term_printf("No client connected\n");
195 else
196 term_printf("Client connected\n");
197 }
198 }
199
200 /* TODO
201 1) Get the queue working for IO.
202 2) there is some weirdness when using the -S option (the screen is grey
203 and not totally invalidated
204 3) resolutions > 1024
205 */
206
207 static void vnc_write(VncState *vs, const void *data, size_t len);
208 static void vnc_write_u32(VncState *vs, uint32_t value);
209 static void vnc_write_s32(VncState *vs, int32_t value);
210 static void vnc_write_u16(VncState *vs, uint16_t value);
211 static void vnc_write_u8(VncState *vs, uint8_t value);
212 static void vnc_flush(VncState *vs);
213 static void vnc_update_client(void *opaque);
214 static void vnc_client_read(void *opaque);
215
216 static void vnc_colordepth(DisplayState *ds, int depth);
217
218 static inline void vnc_set_bit(uint32_t *d, int k)
219 {
220 d[k >> 5] |= 1 << (k & 0x1f);
221 }
222
223 static inline void vnc_clear_bit(uint32_t *d, int k)
224 {
225 d[k >> 5] &= ~(1 << (k & 0x1f));
226 }
227
228 static inline void vnc_set_bits(uint32_t *d, int n, int nb_words)
229 {
230 int j;
231
232 j = 0;
233 while (n >= 32) {
234 d[j++] = -1;
235 n -= 32;
236 }
237 if (n > 0)
238 d[j++] = (1 << n) - 1;
239 while (j < nb_words)
240 d[j++] = 0;
241 }
242
243 static inline int vnc_get_bit(const uint32_t *d, int k)
244 {
245 return (d[k >> 5] >> (k & 0x1f)) & 1;
246 }
247
248 static inline int vnc_and_bits(const uint32_t *d1, const uint32_t *d2,
249 int nb_words)
250 {
251 int i;
252 for(i = 0; i < nb_words; i++) {
253 if ((d1[i] & d2[i]) != 0)
254 return 1;
255 }
256 return 0;
257 }
258
259 static void vnc_dpy_update(DisplayState *ds, int x, int y, int w, int h)
260 {
261 VncState *vs = ds->opaque;
262 int i;
263
264 h += y;
265
266 /* round x down to ensure the loop only spans one 16-pixel block per,
267 iteration. otherwise, if (x % 16) != 0, the last iteration may span
268 two 16-pixel blocks but we only mark the first as dirty
269 */
270 w += (x % 16);
271 x -= (x % 16);
272
273 x = MIN(x, vs->width);
274 y = MIN(y, vs->height);
275 w = MIN(x + w, vs->width) - x;
276 h = MIN(h, vs->height);
277
278 for (; y < h; y++)
279 for (i = 0; i < w; i += 16)
280 vnc_set_bit(vs->dirty_row[y], (x + i) / 16);
281 }
282
283 static void vnc_framebuffer_update(VncState *vs, int x, int y, int w, int h,
284 int32_t encoding)
285 {
286 vnc_write_u16(vs, x);
287 vnc_write_u16(vs, y);
288 vnc_write_u16(vs, w);
289 vnc_write_u16(vs, h);
290
291 vnc_write_s32(vs, encoding);
292 }
293
294 static void vnc_dpy_resize(DisplayState *ds, int w, int h)
295 {
296 int size_changed;
297 VncState *vs = ds->opaque;
298
299 ds->data = qemu_realloc(ds->data, w * h * vs->depth);
300 vs->old_data = qemu_realloc(vs->old_data, w * h * vs->depth);
301
302 if (ds->data == NULL || vs->old_data == NULL) {
303 fprintf(stderr, "vnc: memory allocation failed\n");
304 exit(1);
305 }
306
307 if (ds->depth != vs->depth * 8) {
308 ds->depth = vs->depth * 8;
309 console_color_init(ds);
310 }
311 size_changed = ds->width != w || ds->height != h;
312 ds->width = w;
313 ds->height = h;
314 ds->linesize = w * vs->depth;
315 if (size_changed) {
316 vs->width = ds->width;
317 vs->height = ds->height;
318 if (vs->csock != -1 && vs->has_resize) {
319 vnc_write_u8(vs, 0); /* msg id */
320 vnc_write_u8(vs, 0);
321 vnc_write_u16(vs, 1); /* number of rects */
322 vnc_framebuffer_update(vs, 0, 0, ds->width, ds->height, -223);
323 vnc_flush(vs);
324 }
325 }
326
327 memset(vs->dirty_row, 0xFF, sizeof(vs->dirty_row));
328 memset(vs->old_data, 42, ds_get_linesize(vs->ds) * ds_get_height(vs->ds));
329 }
330
331 /* fastest code */
332 static void vnc_write_pixels_copy(VncState *vs, void *pixels, int size)
333 {
334 vnc_write(vs, pixels, size);
335 }
336
337 /* slowest but generic code. */
338 static void vnc_convert_pixel(VncState *vs, uint8_t *buf, uint32_t v)
339 {
340 uint8_t r, g, b;
341
342 r = ((v >> vs->server_red_shift) & vs->server_red_max) * (vs->client_red_max + 1) /
343 (vs->server_red_max + 1);
344 g = ((v >> vs->server_green_shift) & vs->server_green_max) * (vs->client_green_max + 1) /
345 (vs->server_green_max + 1);
346 b = ((v >> vs->server_blue_shift) & vs->server_blue_max) * (vs->client_blue_max + 1) /
347 (vs->server_blue_max + 1);
348 v = (r << vs->client_red_shift) |
349 (g << vs->client_green_shift) |
350 (b << vs->client_blue_shift);
351 switch(vs->pix_bpp) {
352 case 1:
353 buf[0] = v;
354 break;
355 case 2:
356 if (vs->pix_big_endian) {
357 buf[0] = v >> 8;
358 buf[1] = v;
359 } else {
360 buf[1] = v >> 8;
361 buf[0] = v;
362 }
363 break;
364 default:
365 case 4:
366 if (vs->pix_big_endian) {
367 buf[0] = v >> 24;
368 buf[1] = v >> 16;
369 buf[2] = v >> 8;
370 buf[3] = v;
371 } else {
372 buf[3] = v >> 24;
373 buf[2] = v >> 16;
374 buf[1] = v >> 8;
375 buf[0] = v;
376 }
377 break;
378 }
379 }
380
381 static void vnc_write_pixels_generic(VncState *vs, void *pixels1, int size)
382 {
383 uint8_t buf[4];
384
385 if (vs->depth == 4) {
386 uint32_t *pixels = pixels1;
387 int n, i;
388 n = size >> 2;
389 for(i = 0; i < n; i++) {
390 vnc_convert_pixel(vs, buf, pixels[i]);
391 vnc_write(vs, buf, vs->pix_bpp);
392 }
393 } else if (vs->depth == 2) {
394 uint16_t *pixels = pixels1;
395 int n, i;
396 n = size >> 1;
397 for(i = 0; i < n; i++) {
398 vnc_convert_pixel(vs, buf, pixels[i]);
399 vnc_write(vs, buf, vs->pix_bpp);
400 }
401 } else if (vs->depth == 1) {
402 uint8_t *pixels = pixels1;
403 int n, i;
404 n = size;
405 for(i = 0; i < n; i++) {
406 vnc_convert_pixel(vs, buf, pixels[i]);
407 vnc_write(vs, buf, vs->pix_bpp);
408 }
409 } else {
410 fprintf(stderr, "vnc_write_pixels_generic: VncState color depth not supported\n");
411 }
412 }
413
414 static void send_framebuffer_update_raw(VncState *vs, int x, int y, int w, int h)
415 {
416 int i;
417 uint8_t *row;
418
419 vnc_framebuffer_update(vs, x, y, w, h, 0);
420
421 row = ds_get_data(vs->ds) + y * ds_get_linesize(vs->ds) + x * vs->depth;
422 for (i = 0; i < h; i++) {
423 vs->write_pixels(vs, row, w * vs->depth);
424 row += ds_get_linesize(vs->ds);
425 }
426 }
427
428 static void hextile_enc_cord(uint8_t *ptr, int x, int y, int w, int h)
429 {
430 ptr[0] = ((x & 0x0F) << 4) | (y & 0x0F);
431 ptr[1] = (((w - 1) & 0x0F) << 4) | ((h - 1) & 0x0F);
432 }
433
434 #define BPP 8
435 #include "vnchextile.h"
436 #undef BPP
437
438 #define BPP 16
439 #include "vnchextile.h"
440 #undef BPP
441
442 #define BPP 32
443 #include "vnchextile.h"
444 #undef BPP
445
446 #define GENERIC
447 #define BPP 8
448 #include "vnchextile.h"
449 #undef BPP
450 #undef GENERIC
451
452 #define GENERIC
453 #define BPP 16
454 #include "vnchextile.h"
455 #undef BPP
456 #undef GENERIC
457
458 #define GENERIC
459 #define BPP 32
460 #include "vnchextile.h"
461 #undef BPP
462 #undef GENERIC
463
464 static void send_framebuffer_update_hextile(VncState *vs, int x, int y, int w, int h)
465 {
466 int i, j;
467 int has_fg, has_bg;
468 uint8_t *last_fg, *last_bg;
469
470 vnc_framebuffer_update(vs, x, y, w, h, 5);
471
472 last_fg = (uint8_t *) malloc(vs->depth);
473 last_bg = (uint8_t *) malloc(vs->depth);
474 has_fg = has_bg = 0;
475 for (j = y; j < (y + h); j += 16) {
476 for (i = x; i < (x + w); i += 16) {
477 vs->send_hextile_tile(vs, i, j,
478 MIN(16, x + w - i), MIN(16, y + h - j),
479 last_bg, last_fg, &has_bg, &has_fg);
480 }
481 }
482 free(last_fg);
483 free(last_bg);
484
485 }
486
487 static void send_framebuffer_update(VncState *vs, int x, int y, int w, int h)
488 {
489 if (vs->has_hextile)
490 send_framebuffer_update_hextile(vs, x, y, w, h);
491 else
492 send_framebuffer_update_raw(vs, x, y, w, h);
493 }
494
495 static void vnc_copy(DisplayState *ds, int src_x, int src_y, int dst_x, int dst_y, int w, int h)
496 {
497 int src, dst;
498 uint8_t *src_row;
499 uint8_t *dst_row;
500 char *old_row;
501 int y = 0;
502 int pitch = ds_get_linesize(ds);
503 VncState *vs = ds->opaque;
504
505 vnc_update_client(vs);
506
507 if (dst_y > src_y) {
508 y = h - 1;
509 pitch = -pitch;
510 }
511
512 src = (ds_get_linesize(ds) * (src_y + y) + vs->depth * src_x);
513 dst = (ds_get_linesize(ds) * (dst_y + y) + vs->depth * dst_x);
514
515 src_row = ds_get_data(ds) + src;
516 dst_row = ds_get_data(ds) + dst;
517 old_row = vs->old_data + dst;
518
519 for (y = 0; y < h; y++) {
520 memmove(old_row, src_row, w * vs->depth);
521 memmove(dst_row, src_row, w * vs->depth);
522 src_row += pitch;
523 dst_row += pitch;
524 old_row += pitch;
525 }
526
527 vnc_write_u8(vs, 0); /* msg id */
528 vnc_write_u8(vs, 0);
529 vnc_write_u16(vs, 1); /* number of rects */
530 vnc_framebuffer_update(vs, dst_x, dst_y, w, h, 1);
531 vnc_write_u16(vs, src_x);
532 vnc_write_u16(vs, src_y);
533 vnc_flush(vs);
534 }
535
536 static int find_dirty_height(VncState *vs, int y, int last_x, int x)
537 {
538 int h;
539
540 for (h = 1; h < (vs->height - y); h++) {
541 int tmp_x;
542 if (!vnc_get_bit(vs->dirty_row[y + h], last_x))
543 break;
544 for (tmp_x = last_x; tmp_x < x; tmp_x++)
545 vnc_clear_bit(vs->dirty_row[y + h], tmp_x);
546 }
547
548 return h;
549 }
550
551 static void vnc_update_client(void *opaque)
552 {
553 VncState *vs = opaque;
554
555 if (vs->need_update && vs->csock != -1) {
556 int y;
557 uint8_t *row;
558 char *old_row;
559 uint32_t width_mask[VNC_DIRTY_WORDS];
560 int n_rectangles;
561 int saved_offset;
562 int has_dirty = 0;
563
564 vga_hw_update();
565
566 vnc_set_bits(width_mask, (vs->width / 16), VNC_DIRTY_WORDS);
567
568 /* Walk through the dirty map and eliminate tiles that
569 really aren't dirty */
570 row = ds_get_data(vs->ds);
571 old_row = vs->old_data;
572
573 for (y = 0; y < vs->height; y++) {
574 if (vnc_and_bits(vs->dirty_row[y], width_mask, VNC_DIRTY_WORDS)) {
575 int x;
576 uint8_t *ptr;
577 char *old_ptr;
578
579 ptr = row;
580 old_ptr = (char*)old_row;
581
582 for (x = 0; x < ds_get_width(vs->ds); x += 16) {
583 if (memcmp(old_ptr, ptr, 16 * vs->depth) == 0) {
584 vnc_clear_bit(vs->dirty_row[y], (x / 16));
585 } else {
586 has_dirty = 1;
587 memcpy(old_ptr, ptr, 16 * vs->depth);
588 }
589
590 ptr += 16 * vs->depth;
591 old_ptr += 16 * vs->depth;
592 }
593 }
594
595 row += ds_get_linesize(vs->ds);
596 old_row += ds_get_linesize(vs->ds);
597 }
598
599 if (!has_dirty && !vs->audio_cap) {
600 qemu_mod_timer(vs->timer, qemu_get_clock(rt_clock) + VNC_REFRESH_INTERVAL);
601 return;
602 }
603
604 /* Count rectangles */
605 n_rectangles = 0;
606 vnc_write_u8(vs, 0); /* msg id */
607 vnc_write_u8(vs, 0);
608 saved_offset = vs->output.offset;
609 vnc_write_u16(vs, 0);
610
611 for (y = 0; y < vs->height; y++) {
612 int x;
613 int last_x = -1;
614 for (x = 0; x < vs->width / 16; x++) {
615 if (vnc_get_bit(vs->dirty_row[y], x)) {
616 if (last_x == -1) {
617 last_x = x;
618 }
619 vnc_clear_bit(vs->dirty_row[y], x);
620 } else {
621 if (last_x != -1) {
622 int h = find_dirty_height(vs, y, last_x, x);
623 send_framebuffer_update(vs, last_x * 16, y, (x - last_x) * 16, h);
624 n_rectangles++;
625 }
626 last_x = -1;
627 }
628 }
629 if (last_x != -1) {
630 int h = find_dirty_height(vs, y, last_x, x);
631 send_framebuffer_update(vs, last_x * 16, y, (x - last_x) * 16, h);
632 n_rectangles++;
633 }
634 }
635 vs->output.buffer[saved_offset] = (n_rectangles >> 8) & 0xFF;
636 vs->output.buffer[saved_offset + 1] = n_rectangles & 0xFF;
637 vnc_flush(vs);
638
639 }
640
641 if (vs->csock != -1) {
642 qemu_mod_timer(vs->timer, qemu_get_clock(rt_clock) + VNC_REFRESH_INTERVAL);
643 }
644
645 }
646
647 static int vnc_listen_poll(void *opaque)
648 {
649 VncState *vs = opaque;
650 if (vs->csock == -1)
651 return 1;
652 return 0;
653 }
654
655 static void buffer_reserve(Buffer *buffer, size_t len)
656 {
657 if ((buffer->capacity - buffer->offset) < len) {
658 buffer->capacity += (len + 1024);
659 buffer->buffer = qemu_realloc(buffer->buffer, buffer->capacity);
660 if (buffer->buffer == NULL) {
661 fprintf(stderr, "vnc: out of memory\n");
662 exit(1);
663 }
664 }
665 }
666
667 static int buffer_empty(Buffer *buffer)
668 {
669 return buffer->offset == 0;
670 }
671
672 static uint8_t *buffer_end(Buffer *buffer)
673 {
674 return buffer->buffer + buffer->offset;
675 }
676
677 static void buffer_reset(Buffer *buffer)
678 {
679 buffer->offset = 0;
680 }
681
682 static void buffer_append(Buffer *buffer, const void *data, size_t len)
683 {
684 memcpy(buffer->buffer + buffer->offset, data, len);
685 buffer->offset += len;
686 }
687
688 /* audio */
689 static void audio_capture_notify(void *opaque, audcnotification_e cmd)
690 {
691 VncState *vs = opaque;
692
693 switch (cmd) {
694 case AUD_CNOTIFY_DISABLE:
695 vnc_write_u8(vs, 255);
696 vnc_write_u8(vs, 1);
697 vnc_write_u16(vs, 0);
698 vnc_flush(vs);
699 break;
700
701 case AUD_CNOTIFY_ENABLE:
702 vnc_write_u8(vs, 255);
703 vnc_write_u8(vs, 1);
704 vnc_write_u16(vs, 1);
705 vnc_flush(vs);
706 break;
707 }
708 }
709
710 static void audio_capture_destroy(void *opaque)
711 {
712 }
713
714 static void audio_capture(void *opaque, void *buf, int size)
715 {
716 VncState *vs = opaque;
717
718 vnc_write_u8(vs, 255);
719 vnc_write_u8(vs, 1);
720 vnc_write_u16(vs, 2);
721 vnc_write_u32(vs, size);
722 vnc_write(vs, buf, size);
723 vnc_flush(vs);
724 }
725
726 static void audio_add(VncState *vs)
727 {
728 struct audio_capture_ops ops;
729
730 if (vs->audio_cap) {
731 term_printf ("audio already running\n");
732 return;
733 }
734
735 ops.notify = audio_capture_notify;
736 ops.destroy = audio_capture_destroy;
737 ops.capture = audio_capture;
738
739 vs->audio_cap = AUD_add_capture(NULL, &vs->as, &ops, vs);
740 if (!vs->audio_cap) {
741 term_printf ("Failed to add audio capture\n");
742 }
743 }
744
745 static void audio_del(VncState *vs)
746 {
747 if (vs->audio_cap) {
748 AUD_del_capture(vs->audio_cap, vs);
749 vs->audio_cap = NULL;
750 }
751 }
752
753 static int vnc_client_io_error(VncState *vs, int ret, int last_errno)
754 {
755 if (ret == 0 || ret == -1) {
756 if (ret == -1) {
757 switch (last_errno) {
758 case EINTR:
759 case EAGAIN:
760 #ifdef _WIN32
761 case WSAEWOULDBLOCK:
762 #endif
763 return 0;
764 default:
765 break;
766 }
767 }
768
769 VNC_DEBUG("Closing down client sock %d %d\n", ret, ret < 0 ? last_errno : 0);
770 qemu_set_fd_handler2(vs->csock, NULL, NULL, NULL, NULL);
771 closesocket(vs->csock);
772 vs->csock = -1;
773 vs->ds->idle = 1;
774 buffer_reset(&vs->input);
775 buffer_reset(&vs->output);
776 vs->need_update = 0;
777 #ifdef CONFIG_VNC_TLS
778 if (vs->tls_session) {
779 gnutls_deinit(vs->tls_session);
780 vs->tls_session = NULL;
781 }
782 vs->wiremode = VNC_WIREMODE_CLEAR;
783 #endif /* CONFIG_VNC_TLS */
784 audio_del(vs);
785 return 0;
786 }
787 return ret;
788 }
789
790 static void vnc_client_error(VncState *vs)
791 {
792 vnc_client_io_error(vs, -1, EINVAL);
793 }
794
795 static void vnc_client_write(void *opaque)
796 {
797 long ret;
798 VncState *vs = opaque;
799
800 #ifdef CONFIG_VNC_TLS
801 if (vs->tls_session) {
802 ret = gnutls_write(vs->tls_session, vs->output.buffer, vs->output.offset);
803 if (ret < 0) {
804 if (ret == GNUTLS_E_AGAIN)
805 errno = EAGAIN;
806 else
807 errno = EIO;
808 ret = -1;
809 }
810 } else
811 #endif /* CONFIG_VNC_TLS */
812 ret = send(vs->csock, vs->output.buffer, vs->output.offset, 0);
813 ret = vnc_client_io_error(vs, ret, socket_error());
814 if (!ret)
815 return;
816
817 memmove(vs->output.buffer, vs->output.buffer + ret, (vs->output.offset - ret));
818 vs->output.offset -= ret;
819
820 if (vs->output.offset == 0) {
821 qemu_set_fd_handler2(vs->csock, NULL, vnc_client_read, NULL, vs);
822 }
823 }
824
825 static void vnc_read_when(VncState *vs, VncReadEvent *func, size_t expecting)
826 {
827 vs->read_handler = func;
828 vs->read_handler_expect = expecting;
829 }
830
831 static void vnc_client_read(void *opaque)
832 {
833 VncState *vs = opaque;
834 long ret;
835
836 buffer_reserve(&vs->input, 4096);
837
838 #ifdef CONFIG_VNC_TLS
839 if (vs->tls_session) {
840 ret = gnutls_read(vs->tls_session, buffer_end(&vs->input), 4096);
841 if (ret < 0) {
842 if (ret == GNUTLS_E_AGAIN)
843 errno = EAGAIN;
844 else
845 errno = EIO;
846 ret = -1;
847 }
848 } else
849 #endif /* CONFIG_VNC_TLS */
850 ret = recv(vs->csock, buffer_end(&vs->input), 4096, 0);
851 ret = vnc_client_io_error(vs, ret, socket_error());
852 if (!ret)
853 return;
854
855 vs->input.offset += ret;
856
857 while (vs->read_handler && vs->input.offset >= vs->read_handler_expect) {
858 size_t len = vs->read_handler_expect;
859 int ret;
860
861 ret = vs->read_handler(vs, vs->input.buffer, len);
862 if (vs->csock == -1)
863 return;
864
865 if (!ret) {
866 memmove(vs->input.buffer, vs->input.buffer + len, (vs->input.offset - len));
867 vs->input.offset -= len;
868 } else {
869 vs->read_handler_expect = ret;
870 }
871 }
872 }
873
874 static void vnc_write(VncState *vs, const void *data, size_t len)
875 {
876 buffer_reserve(&vs->output, len);
877
878 if (buffer_empty(&vs->output)) {
879 qemu_set_fd_handler2(vs->csock, NULL, vnc_client_read, vnc_client_write, vs);
880 }
881
882 buffer_append(&vs->output, data, len);
883 }
884
885 static void vnc_write_s32(VncState *vs, int32_t value)
886 {
887 vnc_write_u32(vs, *(uint32_t *)&value);
888 }
889
890 static void vnc_write_u32(VncState *vs, uint32_t value)
891 {
892 uint8_t buf[4];
893
894 buf[0] = (value >> 24) & 0xFF;
895 buf[1] = (value >> 16) & 0xFF;
896 buf[2] = (value >> 8) & 0xFF;
897 buf[3] = value & 0xFF;
898
899 vnc_write(vs, buf, 4);
900 }
901
902 static void vnc_write_u16(VncState *vs, uint16_t value)
903 {
904 uint8_t buf[2];
905
906 buf[0] = (value >> 8) & 0xFF;
907 buf[1] = value & 0xFF;
908
909 vnc_write(vs, buf, 2);
910 }
911
912 static void vnc_write_u8(VncState *vs, uint8_t value)
913 {
914 vnc_write(vs, (char *)&value, 1);
915 }
916
917 static void vnc_flush(VncState *vs)
918 {
919 if (vs->output.offset)
920 vnc_client_write(vs);
921 }
922
923 static uint8_t read_u8(uint8_t *data, size_t offset)
924 {
925 return data[offset];
926 }
927
928 static uint16_t read_u16(uint8_t *data, size_t offset)
929 {
930 return ((data[offset] & 0xFF) << 8) | (data[offset + 1] & 0xFF);
931 }
932
933 static int32_t read_s32(uint8_t *data, size_t offset)
934 {
935 return (int32_t)((data[offset] << 24) | (data[offset + 1] << 16) |
936 (data[offset + 2] << 8) | data[offset + 3]);
937 }
938
939 static uint32_t read_u32(uint8_t *data, size_t offset)
940 {
941 return ((data[offset] << 24) | (data[offset + 1] << 16) |
942 (data[offset + 2] << 8) | data[offset + 3]);
943 }
944
945 #ifdef CONFIG_VNC_TLS
946 static ssize_t vnc_tls_push(gnutls_transport_ptr_t transport,
947 const void *data,
948 size_t len) {
949 struct VncState *vs = (struct VncState *)transport;
950 int ret;
951
952 retry:
953 ret = send(vs->csock, data, len, 0);
954 if (ret < 0) {
955 if (errno == EINTR)
956 goto retry;
957 return -1;
958 }
959 return ret;
960 }
961
962
963 static ssize_t vnc_tls_pull(gnutls_transport_ptr_t transport,
964 void *data,
965 size_t len) {
966 struct VncState *vs = (struct VncState *)transport;
967 int ret;
968
969 retry:
970 ret = recv(vs->csock, data, len, 0);
971 if (ret < 0) {
972 if (errno == EINTR)
973 goto retry;
974 return -1;
975 }
976 return ret;
977 }
978 #endif /* CONFIG_VNC_TLS */
979
980 static void client_cut_text(VncState *vs, size_t len, uint8_t *text)
981 {
982 }
983
984 static void check_pointer_type_change(VncState *vs, int absolute)
985 {
986 if (vs->has_pointer_type_change && vs->absolute != absolute) {
987 vnc_write_u8(vs, 0);
988 vnc_write_u8(vs, 0);
989 vnc_write_u16(vs, 1);
990 vnc_framebuffer_update(vs, absolute, 0,
991 ds_get_width(vs->ds), ds_get_height(vs->ds), -257);
992 vnc_flush(vs);
993 }
994 vs->absolute = absolute;
995 }
996
997 static void pointer_event(VncState *vs, int button_mask, int x, int y)
998 {
999 int buttons = 0;
1000 int dz = 0;
1001
1002 if (button_mask & 0x01)
1003 buttons |= MOUSE_EVENT_LBUTTON;
1004 if (button_mask & 0x02)
1005 buttons |= MOUSE_EVENT_MBUTTON;
1006 if (button_mask & 0x04)
1007 buttons |= MOUSE_EVENT_RBUTTON;
1008 if (button_mask & 0x08)
1009 dz = -1;
1010 if (button_mask & 0x10)
1011 dz = 1;
1012
1013 if (vs->absolute) {
1014 kbd_mouse_event(x * 0x7FFF / (ds_get_width(vs->ds) - 1),
1015 y * 0x7FFF / (ds_get_height(vs->ds) - 1),
1016 dz, buttons);
1017 } else if (vs->has_pointer_type_change) {
1018 x -= 0x7FFF;
1019 y -= 0x7FFF;
1020
1021 kbd_mouse_event(x, y, dz, buttons);
1022 } else {
1023 if (vs->last_x != -1)
1024 kbd_mouse_event(x - vs->last_x,
1025 y - vs->last_y,
1026 dz, buttons);
1027 vs->last_x = x;
1028 vs->last_y = y;
1029 }
1030
1031 check_pointer_type_change(vs, kbd_mouse_is_absolute());
1032 }
1033
1034 static void reset_keys(VncState *vs)
1035 {
1036 int i;
1037 for(i = 0; i < 256; i++) {
1038 if (vs->modifiers_state[i]) {
1039 if (i & 0x80)
1040 kbd_put_keycode(0xe0);
1041 kbd_put_keycode(i | 0x80);
1042 vs->modifiers_state[i] = 0;
1043 }
1044 }
1045 }
1046
1047 static void press_key(VncState *vs, int keysym)
1048 {
1049 kbd_put_keycode(keysym2scancode(vs->kbd_layout, keysym) & 0x7f);
1050 kbd_put_keycode(keysym2scancode(vs->kbd_layout, keysym) | 0x80);
1051 }
1052
1053 static void do_key_event(VncState *vs, int down, int keycode, int sym)
1054 {
1055 /* QEMU console switch */
1056 switch(keycode) {
1057 case 0x2a: /* Left Shift */
1058 case 0x36: /* Right Shift */
1059 case 0x1d: /* Left CTRL */
1060 case 0x9d: /* Right CTRL */
1061 case 0x38: /* Left ALT */
1062 case 0xb8: /* Right ALT */
1063 if (down)
1064 vs->modifiers_state[keycode] = 1;
1065 else
1066 vs->modifiers_state[keycode] = 0;
1067 break;
1068 case 0x02 ... 0x0a: /* '1' to '9' keys */
1069 if (down && vs->modifiers_state[0x1d] && vs->modifiers_state[0x38]) {
1070 /* Reset the modifiers sent to the current console */
1071 reset_keys(vs);
1072 console_select(keycode - 0x02);
1073 return;
1074 }
1075 break;
1076 case 0x3a: /* CapsLock */
1077 case 0x45: /* NumLock */
1078 if (!down)
1079 vs->modifiers_state[keycode] ^= 1;
1080 break;
1081 }
1082
1083 if (keycode_is_keypad(vs->kbd_layout, keycode)) {
1084 /* If the numlock state needs to change then simulate an additional
1085 keypress before sending this one. This will happen if the user
1086 toggles numlock away from the VNC window.
1087 */
1088 if (keysym_is_numlock(vs->kbd_layout, sym & 0xFFFF)) {
1089 if (!vs->modifiers_state[0x45]) {
1090 vs->modifiers_state[0x45] = 1;
1091 press_key(vs, 0xff7f);
1092 }
1093 } else {
1094 if (vs->modifiers_state[0x45]) {
1095 vs->modifiers_state[0x45] = 0;
1096 press_key(vs, 0xff7f);
1097 }
1098 }
1099 }
1100
1101 if (is_graphic_console()) {
1102 if (keycode & 0x80)
1103 kbd_put_keycode(0xe0);
1104 if (down)
1105 kbd_put_keycode(keycode & 0x7f);
1106 else
1107 kbd_put_keycode(keycode | 0x80);
1108 } else {
1109 /* QEMU console emulation */
1110 if (down) {
1111 switch (keycode) {
1112 case 0x2a: /* Left Shift */
1113 case 0x36: /* Right Shift */
1114 case 0x1d: /* Left CTRL */
1115 case 0x9d: /* Right CTRL */
1116 case 0x38: /* Left ALT */
1117 case 0xb8: /* Right ALT */
1118 break;
1119 case 0xc8:
1120 kbd_put_keysym(QEMU_KEY_UP);
1121 break;
1122 case 0xd0:
1123 kbd_put_keysym(QEMU_KEY_DOWN);
1124 break;
1125 case 0xcb:
1126 kbd_put_keysym(QEMU_KEY_LEFT);
1127 break;
1128 case 0xcd:
1129 kbd_put_keysym(QEMU_KEY_RIGHT);
1130 break;
1131 case 0xd3:
1132 kbd_put_keysym(QEMU_KEY_DELETE);
1133 break;
1134 case 0xc7:
1135 kbd_put_keysym(QEMU_KEY_HOME);
1136 break;
1137 case 0xcf:
1138 kbd_put_keysym(QEMU_KEY_END);
1139 break;
1140 case 0xc9:
1141 kbd_put_keysym(QEMU_KEY_PAGEUP);
1142 break;
1143 case 0xd1:
1144 kbd_put_keysym(QEMU_KEY_PAGEDOWN);
1145 break;
1146 default:
1147 kbd_put_keysym(sym);
1148 break;
1149 }
1150 }
1151 }
1152 }
1153
1154 static void key_event(VncState *vs, int down, uint32_t sym)
1155 {
1156 int keycode;
1157
1158 if (sym >= 'A' && sym <= 'Z' && is_graphic_console())
1159 sym = sym - 'A' + 'a';
1160
1161 keycode = keysym2scancode(vs->kbd_layout, sym & 0xFFFF);
1162 do_key_event(vs, down, keycode, sym);
1163 }
1164
1165 static void ext_key_event(VncState *vs, int down,
1166 uint32_t sym, uint16_t keycode)
1167 {
1168 /* if the user specifies a keyboard layout, always use it */
1169 if (keyboard_layout)
1170 key_event(vs, down, sym);
1171 else
1172 do_key_event(vs, down, keycode, sym);
1173 }
1174
1175 static void framebuffer_update_request(VncState *vs, int incremental,
1176 int x_position, int y_position,
1177 int w, int h)
1178 {
1179 if (x_position > ds_get_width(vs->ds))
1180 x_position = ds_get_width(vs->ds);
1181 if (y_position > ds_get_height(vs->ds))
1182 y_position = ds_get_height(vs->ds);
1183 if (x_position + w >= ds_get_width(vs->ds))
1184 w = ds_get_width(vs->ds) - x_position;
1185 if (y_position + h >= ds_get_height(vs->ds))
1186 h = ds_get_height(vs->ds) - y_position;
1187
1188 int i;
1189 vs->need_update = 1;
1190 if (!incremental) {
1191 char *old_row = vs->old_data + y_position * ds_get_linesize(vs->ds);
1192
1193 for (i = 0; i < h; i++) {
1194 vnc_set_bits(vs->dirty_row[y_position + i],
1195 (ds_get_width(vs->ds) / 16), VNC_DIRTY_WORDS);
1196 memset(old_row, 42, ds_get_width(vs->ds) * vs->depth);
1197 old_row += ds_get_linesize(vs->ds);
1198 }
1199 }
1200 }
1201
1202 static void send_ext_key_event_ack(VncState *vs)
1203 {
1204 vnc_write_u8(vs, 0);
1205 vnc_write_u8(vs, 0);
1206 vnc_write_u16(vs, 1);
1207 vnc_framebuffer_update(vs, 0, 0, ds_get_width(vs->ds), ds_get_height(vs->ds), -258);
1208 vnc_flush(vs);
1209 }
1210
1211 static void send_ext_audio_ack(VncState *vs)
1212 {
1213 vnc_write_u8(vs, 0);
1214 vnc_write_u8(vs, 0);
1215 vnc_write_u16(vs, 1);
1216 vnc_framebuffer_update(vs, 0, 0, ds_get_width(vs->ds), ds_get_height(vs->ds), -259);
1217 vnc_flush(vs);
1218 }
1219
1220 static void set_encodings(VncState *vs, int32_t *encodings, size_t n_encodings)
1221 {
1222 int i;
1223
1224 vs->has_hextile = 0;
1225 vs->has_resize = 0;
1226 vs->has_pointer_type_change = 0;
1227 vs->has_WMVi = 0;
1228 vs->absolute = -1;
1229 vs->ds->dpy_copy = NULL;
1230
1231 for (i = n_encodings - 1; i >= 0; i--) {
1232 switch (encodings[i]) {
1233 case 0: /* Raw */
1234 vs->has_hextile = 0;
1235 break;
1236 case 1: /* CopyRect */
1237 vs->ds->dpy_copy = vnc_copy;
1238 break;
1239 case 5: /* Hextile */
1240 vs->has_hextile = 1;
1241 break;
1242 case -223: /* DesktopResize */
1243 vs->has_resize = 1;
1244 break;
1245 case -257:
1246 vs->has_pointer_type_change = 1;
1247 break;
1248 case -258:
1249 send_ext_key_event_ack(vs);
1250 break;
1251 case -259:
1252 send_ext_audio_ack(vs);
1253 break;
1254 case 0x574D5669:
1255 vs->has_WMVi = 1;
1256 break;
1257 default:
1258 break;
1259 }
1260 }
1261
1262 check_pointer_type_change(vs, kbd_mouse_is_absolute());
1263 }
1264
1265 static void set_pixel_format(VncState *vs,
1266 int bits_per_pixel, int depth,
1267 int big_endian_flag, int true_color_flag,
1268 int red_max, int green_max, int blue_max,
1269 int red_shift, int green_shift, int blue_shift)
1270 {
1271 int host_big_endian_flag;
1272
1273 #ifdef WORDS_BIGENDIAN
1274 host_big_endian_flag = 1;
1275 #else
1276 host_big_endian_flag = 0;
1277 #endif
1278 if (!true_color_flag) {
1279 fail:
1280 vnc_client_error(vs);
1281 return;
1282 }
1283 if (bits_per_pixel == 32 &&
1284 bits_per_pixel == vs->depth * 8 &&
1285 host_big_endian_flag == big_endian_flag &&
1286 red_max == 0xff && green_max == 0xff && blue_max == 0xff &&
1287 red_shift == 16 && green_shift == 8 && blue_shift == 0) {
1288 vs->depth = 4;
1289 vs->write_pixels = vnc_write_pixels_copy;
1290 vs->send_hextile_tile = send_hextile_tile_32;
1291 } else
1292 if (bits_per_pixel == 16 &&
1293 bits_per_pixel == vs->depth * 8 &&
1294 host_big_endian_flag == big_endian_flag &&
1295 red_max == 31 && green_max == 63 && blue_max == 31 &&
1296 red_shift == 11 && green_shift == 5 && blue_shift == 0) {
1297 vs->depth = 2;
1298 vs->write_pixels = vnc_write_pixels_copy;
1299 vs->send_hextile_tile = send_hextile_tile_16;
1300 } else
1301 if (bits_per_pixel == 8 &&
1302 bits_per_pixel == vs->depth * 8 &&
1303 red_max == 7 && green_max == 7 && blue_max == 3 &&
1304 red_shift == 5 && green_shift == 2 && blue_shift == 0) {
1305 vs->depth = 1;
1306 vs->write_pixels = vnc_write_pixels_copy;
1307 vs->send_hextile_tile = send_hextile_tile_8;
1308 } else
1309 {
1310 /* generic and slower case */
1311 if (bits_per_pixel != 8 &&
1312 bits_per_pixel != 16 &&
1313 bits_per_pixel != 32)
1314 goto fail;
1315 if (vs->depth == 4) {
1316 vs->send_hextile_tile = send_hextile_tile_generic_32;
1317 } else if (vs->depth == 2) {
1318 vs->send_hextile_tile = send_hextile_tile_generic_16;
1319 } else {
1320 vs->send_hextile_tile = send_hextile_tile_generic_8;
1321 }
1322
1323 vs->pix_big_endian = big_endian_flag;
1324 vs->write_pixels = vnc_write_pixels_generic;
1325 }
1326
1327 vs->client_red_shift = red_shift;
1328 vs->client_red_max = red_max;
1329 vs->client_green_shift = green_shift;
1330 vs->client_green_max = green_max;
1331 vs->client_blue_shift = blue_shift;
1332 vs->client_blue_max = blue_max;
1333 vs->pix_bpp = bits_per_pixel / 8;
1334
1335 vga_hw_invalidate();
1336 vga_hw_update();
1337 }
1338
1339 static void pixel_format_message (VncState *vs) {
1340 char pad[3] = { 0, 0, 0 };
1341
1342 vnc_write_u8(vs, vs->depth * 8); /* bits-per-pixel */
1343 if (vs->depth == 4) vnc_write_u8(vs, 24); /* depth */
1344 else vnc_write_u8(vs, vs->depth * 8); /* depth */
1345
1346 #ifdef WORDS_BIGENDIAN
1347 vnc_write_u8(vs, 1); /* big-endian-flag */
1348 #else
1349 vnc_write_u8(vs, 0); /* big-endian-flag */
1350 #endif
1351 vnc_write_u8(vs, 1); /* true-color-flag */
1352 if (vs->depth == 4) {
1353 vnc_write_u16(vs, 0xFF); /* red-max */
1354 vnc_write_u16(vs, 0xFF); /* green-max */
1355 vnc_write_u16(vs, 0xFF); /* blue-max */
1356 vnc_write_u8(vs, 16); /* red-shift */
1357 vnc_write_u8(vs, 8); /* green-shift */
1358 vnc_write_u8(vs, 0); /* blue-shift */
1359 vs->send_hextile_tile = send_hextile_tile_32;
1360 } else if (vs->depth == 2) {
1361 vnc_write_u16(vs, 31); /* red-max */
1362 vnc_write_u16(vs, 63); /* green-max */
1363 vnc_write_u16(vs, 31); /* blue-max */
1364 vnc_write_u8(vs, 11); /* red-shift */
1365 vnc_write_u8(vs, 5); /* green-shift */
1366 vnc_write_u8(vs, 0); /* blue-shift */
1367 vs->send_hextile_tile = send_hextile_tile_16;
1368 } else if (vs->depth == 1) {
1369 /* XXX: change QEMU pixel 8 bit pixel format to match the VNC one ? */
1370 vnc_write_u16(vs, 7); /* red-max */
1371 vnc_write_u16(vs, 7); /* green-max */
1372 vnc_write_u16(vs, 3); /* blue-max */
1373 vnc_write_u8(vs, 5); /* red-shift */
1374 vnc_write_u8(vs, 2); /* green-shift */
1375 vnc_write_u8(vs, 0); /* blue-shift */
1376 vs->send_hextile_tile = send_hextile_tile_8;
1377 }
1378 vs->client_red_max = vs->server_red_max;
1379 vs->client_green_max = vs->server_green_max;
1380 vs->client_blue_max = vs->server_blue_max;
1381 vs->client_red_shift = vs->server_red_shift;
1382 vs->client_green_shift = vs->server_green_shift;
1383 vs->client_blue_shift = vs->server_blue_shift;
1384 vs->pix_bpp = vs->depth * 8;
1385 vs->write_pixels = vnc_write_pixels_copy;
1386
1387 vnc_write(vs, pad, 3); /* padding */
1388 }
1389
1390 static void vnc_colordepth(DisplayState *ds, int depth)
1391 {
1392 int host_big_endian_flag;
1393 struct VncState *vs = ds->opaque;
1394
1395 switch (depth) {
1396 case 24:
1397 if (ds->depth == 32) return;
1398 depth = 32;
1399 break;
1400 case 15:
1401 case 8:
1402 case 0:
1403 return;
1404 default:
1405 break;
1406 }
1407
1408 #ifdef WORDS_BIGENDIAN
1409 host_big_endian_flag = 1;
1410 #else
1411 host_big_endian_flag = 0;
1412 #endif
1413
1414 switch (depth) {
1415 case 8:
1416 vs->depth = depth / 8;
1417 vs->server_red_max = 7;
1418 vs->server_green_max = 7;
1419 vs->server_blue_max = 3;
1420 vs->server_red_shift = 5;
1421 vs->server_green_shift = 2;
1422 vs->server_blue_shift = 0;
1423 break;
1424 case 16:
1425 vs->depth = depth / 8;
1426 vs->server_red_max = 31;
1427 vs->server_green_max = 63;
1428 vs->server_blue_max = 31;
1429 vs->server_red_shift = 11;
1430 vs->server_green_shift = 5;
1431 vs->server_blue_shift = 0;
1432 break;
1433 case 32:
1434 vs->depth = 4;
1435 vs->server_red_max = 255;
1436 vs->server_green_max = 255;
1437 vs->server_blue_max = 255;
1438 vs->server_red_shift = 16;
1439 vs->server_green_shift = 8;
1440 vs->server_blue_shift = 0;
1441 break;
1442 default:
1443 return;
1444 }
1445
1446 if (vs->csock != -1 && vs->has_WMVi) {
1447 /* Sending a WMVi message to notify the client*/
1448 vnc_write_u8(vs, 0); /* msg id */
1449 vnc_write_u8(vs, 0);
1450 vnc_write_u16(vs, 1); /* number of rects */
1451 vnc_framebuffer_update(vs, 0, 0, ds->width, ds->height, 0x574D5669);
1452 pixel_format_message(vs);
1453 vnc_flush(vs);
1454 } else {
1455 if (vs->pix_bpp == 4 && vs->depth == 4 &&
1456 host_big_endian_flag == vs->pix_big_endian &&
1457 vs->client_red_max == 0xff && vs->client_green_max == 0xff && vs->client_blue_max == 0xff &&
1458 vs->client_red_shift == 16 && vs->client_green_shift == 8 && vs->client_blue_shift == 0) {
1459 vs->write_pixels = vnc_write_pixels_copy;
1460 vs->send_hextile_tile = send_hextile_tile_32;
1461 } else if (vs->pix_bpp == 2 && vs->depth == 2 &&
1462 host_big_endian_flag == vs->pix_big_endian &&
1463 vs->client_red_max == 31 && vs->client_green_max == 63 && vs->client_blue_max == 31 &&
1464 vs->client_red_shift == 11 && vs->client_green_shift == 5 && vs->client_blue_shift == 0) {
1465 vs->write_pixels = vnc_write_pixels_copy;
1466 vs->send_hextile_tile = send_hextile_tile_16;
1467 } else if (vs->pix_bpp == 1 && vs->depth == 1 &&
1468 host_big_endian_flag == vs->pix_big_endian &&
1469 vs->client_red_max == 7 && vs->client_green_max == 7 && vs->client_blue_max == 3 &&
1470 vs->client_red_shift == 5 && vs->client_green_shift == 2 && vs->client_blue_shift == 0) {
1471 vs->write_pixels = vnc_write_pixels_copy;
1472 vs->send_hextile_tile = send_hextile_tile_8;
1473 } else {
1474 if (vs->depth == 4) {
1475 vs->send_hextile_tile = send_hextile_tile_generic_32;
1476 } else if (vs->depth == 2) {
1477 vs->send_hextile_tile = send_hextile_tile_generic_16;
1478 } else {
1479 vs->send_hextile_tile = send_hextile_tile_generic_8;
1480 }
1481 vs->write_pixels = vnc_write_pixels_generic;
1482 }
1483 }
1484 }
1485
1486 static int protocol_client_msg(VncState *vs, uint8_t *data, size_t len)
1487 {
1488 int i;
1489 uint16_t limit;
1490
1491 switch (data[0]) {
1492 case 0:
1493 if (len == 1)
1494 return 20;
1495
1496 set_pixel_format(vs, read_u8(data, 4), read_u8(data, 5),
1497 read_u8(data, 6), read_u8(data, 7),
1498 read_u16(data, 8), read_u16(data, 10),
1499 read_u16(data, 12), read_u8(data, 14),
1500 read_u8(data, 15), read_u8(data, 16));
1501 break;
1502 case 2:
1503 if (len == 1)
1504 return 4;
1505
1506 if (len == 4) {
1507 limit = read_u16(data, 2);
1508 if (limit > 0)
1509 return 4 + (limit * 4);
1510 } else
1511 limit = read_u16(data, 2);
1512
1513 for (i = 0; i < limit; i++) {
1514 int32_t val = read_s32(data, 4 + (i * 4));
1515 memcpy(data + 4 + (i * 4), &val, sizeof(val));
1516 }
1517
1518 set_encodings(vs, (int32_t *)(data + 4), limit);
1519 break;
1520 case 3:
1521 if (len == 1)
1522 return 10;
1523
1524 framebuffer_update_request(vs,
1525 read_u8(data, 1), read_u16(data, 2), read_u16(data, 4),
1526 read_u16(data, 6), read_u16(data, 8));
1527 break;
1528 case 4:
1529 if (len == 1)
1530 return 8;
1531
1532 key_event(vs, read_u8(data, 1), read_u32(data, 4));
1533 break;
1534 case 5:
1535 if (len == 1)
1536 return 6;
1537
1538 pointer_event(vs, read_u8(data, 1), read_u16(data, 2), read_u16(data, 4));
1539 break;
1540 case 6:
1541 if (len == 1)
1542 return 8;
1543
1544 if (len == 8) {
1545 uint32_t dlen = read_u32(data, 4);
1546 if (dlen > 0)
1547 return 8 + dlen;
1548 }
1549
1550 client_cut_text(vs, read_u32(data, 4), data + 8);
1551 break;
1552 case 255:
1553 if (len == 1)
1554 return 2;
1555
1556 switch (read_u8(data, 1)) {
1557 case 0:
1558 if (len == 2)
1559 return 12;
1560
1561 ext_key_event(vs, read_u16(data, 2),
1562 read_u32(data, 4), read_u32(data, 8));
1563 break;
1564 case 1:
1565 if (len == 2)
1566 return 4;
1567
1568 switch (read_u16 (data, 2)) {
1569 case 0:
1570 audio_add(vs);
1571 break;
1572 case 1:
1573 audio_del(vs);
1574 break;
1575 case 2:
1576 if (len == 4)
1577 return 10;
1578 switch (read_u8(data, 4)) {
1579 case 0: vs->as.fmt = AUD_FMT_U8; break;
1580 case 1: vs->as.fmt = AUD_FMT_S8; break;
1581 case 2: vs->as.fmt = AUD_FMT_U16; break;
1582 case 3: vs->as.fmt = AUD_FMT_S16; break;
1583 case 4: vs->as.fmt = AUD_FMT_U32; break;
1584 case 5: vs->as.fmt = AUD_FMT_S32; break;
1585 default:
1586 printf("Invalid audio format %d\n", read_u8(data, 4));
1587 vnc_client_error(vs);
1588 break;
1589 }
1590 vs->as.nchannels = read_u8(data, 5);
1591 if (vs->as.nchannels != 1 && vs->as.nchannels != 2) {
1592 printf("Invalid audio channel coount %d\n",
1593 read_u8(data, 5));
1594 vnc_client_error(vs);
1595 break;
1596 }
1597 vs->as.freq = read_u32(data, 6);
1598 break;
1599 default:
1600 printf ("Invalid audio message %d\n", read_u8(data, 4));
1601 vnc_client_error(vs);
1602 break;
1603 }
1604 break;
1605
1606 default:
1607 printf("Msg: %d\n", read_u16(data, 0));
1608 vnc_client_error(vs);
1609 break;
1610 }
1611 break;
1612 default:
1613 printf("Msg: %d\n", data[0]);
1614 vnc_client_error(vs);
1615 break;
1616 }
1617
1618 vnc_read_when(vs, protocol_client_msg, 1);
1619 return 0;
1620 }
1621
1622 static int protocol_client_init(VncState *vs, uint8_t *data, size_t len)
1623 {
1624 char buf[1024];
1625 int size;
1626
1627 vs->width = ds_get_width(vs->ds);
1628 vs->height = ds_get_height(vs->ds);
1629 vnc_write_u16(vs, ds_get_width(vs->ds));
1630 vnc_write_u16(vs, ds_get_height(vs->ds));
1631
1632 pixel_format_message(vs);
1633
1634 if (qemu_name)
1635 size = snprintf(buf, sizeof(buf), "QEMU (%s)", qemu_name);
1636 else
1637 size = snprintf(buf, sizeof(buf), "QEMU");
1638
1639 vnc_write_u32(vs, size);
1640 vnc_write(vs, buf, size);
1641 vnc_flush(vs);
1642
1643 vnc_read_when(vs, protocol_client_msg, 1);
1644
1645 return 0;
1646 }
1647
1648 static void make_challenge(VncState *vs)
1649 {
1650 int i;
1651
1652 srand(time(NULL)+getpid()+getpid()*987654+rand());
1653
1654 for (i = 0 ; i < sizeof(vs->challenge) ; i++)
1655 vs->challenge[i] = (int) (256.0*rand()/(RAND_MAX+1.0));
1656 }
1657
1658 static int protocol_client_auth_vnc(VncState *vs, uint8_t *data, size_t len)
1659 {
1660 unsigned char response[VNC_AUTH_CHALLENGE_SIZE];
1661 int i, j, pwlen;
1662 unsigned char key[8];
1663
1664 if (!vs->password || !vs->password[0]) {
1665 VNC_DEBUG("No password configured on server");
1666 vnc_write_u32(vs, 1); /* Reject auth */
1667 if (vs->minor >= 8) {
1668 static const char err[] = "Authentication failed";
1669 vnc_write_u32(vs, sizeof(err));
1670 vnc_write(vs, err, sizeof(err));
1671 }
1672 vnc_flush(vs);
1673 vnc_client_error(vs);
1674 return 0;
1675 }
1676
1677 memcpy(response, vs->challenge, VNC_AUTH_CHALLENGE_SIZE);
1678
1679 /* Calculate the expected challenge response */
1680 pwlen = strlen(vs->password);
1681 for (i=0; i<sizeof(key); i++)
1682 key[i] = i<pwlen ? vs->password[i] : 0;
1683 deskey(key, EN0);
1684 for (j = 0; j < VNC_AUTH_CHALLENGE_SIZE; j += 8)
1685 des(response+j, response+j);
1686
1687 /* Compare expected vs actual challenge response */
1688 if (memcmp(response, data, VNC_AUTH_CHALLENGE_SIZE) != 0) {
1689 VNC_DEBUG("Client challenge reponse did not match\n");
1690 vnc_write_u32(vs, 1); /* Reject auth */
1691 if (vs->minor >= 8) {
1692 static const char err[] = "Authentication failed";
1693 vnc_write_u32(vs, sizeof(err));
1694 vnc_write(vs, err, sizeof(err));
1695 }
1696 vnc_flush(vs);
1697 vnc_client_error(vs);
1698 } else {
1699 VNC_DEBUG("Accepting VNC challenge response\n");
1700 vnc_write_u32(vs, 0); /* Accept auth */
1701 vnc_flush(vs);
1702
1703 vnc_read_when(vs, protocol_client_init, 1);
1704 }
1705 return 0;
1706 }
1707
1708 static int start_auth_vnc(VncState *vs)
1709 {
1710 make_challenge(vs);
1711 /* Send client a 'random' challenge */
1712 vnc_write(vs, vs->challenge, sizeof(vs->challenge));
1713 vnc_flush(vs);
1714
1715 vnc_read_when(vs, protocol_client_auth_vnc, sizeof(vs->challenge));
1716 return 0;
1717 }
1718
1719
1720 #ifdef CONFIG_VNC_TLS
1721 #define DH_BITS 1024
1722 static gnutls_dh_params_t dh_params;
1723
1724 static int vnc_tls_initialize(void)
1725 {
1726 static int tlsinitialized = 0;
1727
1728 if (tlsinitialized)
1729 return 1;
1730
1731 if (gnutls_global_init () < 0)
1732 return 0;
1733
1734 /* XXX ought to re-generate diffie-hellmen params periodically */
1735 if (gnutls_dh_params_init (&dh_params) < 0)
1736 return 0;
1737 if (gnutls_dh_params_generate2 (dh_params, DH_BITS) < 0)
1738 return 0;
1739
1740 #if defined(_VNC_DEBUG) && _VNC_DEBUG >= 2
1741 gnutls_global_set_log_level(10);
1742 gnutls_global_set_log_function(vnc_debug_gnutls_log);
1743 #endif
1744
1745 tlsinitialized = 1;
1746
1747 return 1;
1748 }
1749
1750 static gnutls_anon_server_credentials vnc_tls_initialize_anon_cred(void)
1751 {
1752 gnutls_anon_server_credentials anon_cred;
1753 int ret;
1754
1755 if ((ret = gnutls_anon_allocate_server_credentials(&anon_cred)) < 0) {
1756 VNC_DEBUG("Cannot allocate credentials %s\n", gnutls_strerror(ret));
1757 return NULL;
1758 }
1759
1760 gnutls_anon_set_server_dh_params(anon_cred, dh_params);
1761
1762 return anon_cred;
1763 }
1764
1765
1766 static gnutls_certificate_credentials_t vnc_tls_initialize_x509_cred(VncState *vs)
1767 {
1768 gnutls_certificate_credentials_t x509_cred;
1769 int ret;
1770
1771 if (!vs->x509cacert) {
1772 VNC_DEBUG("No CA x509 certificate specified\n");
1773 return NULL;
1774 }
1775 if (!vs->x509cert) {
1776 VNC_DEBUG("No server x509 certificate specified\n");
1777 return NULL;
1778 }
1779 if (!vs->x509key) {
1780 VNC_DEBUG("No server private key specified\n");
1781 return NULL;
1782 }
1783
1784 if ((ret = gnutls_certificate_allocate_credentials(&x509_cred)) < 0) {
1785 VNC_DEBUG("Cannot allocate credentials %s\n", gnutls_strerror(ret));
1786 return NULL;
1787 }
1788 if ((ret = gnutls_certificate_set_x509_trust_file(x509_cred,
1789 vs->x509cacert,
1790 GNUTLS_X509_FMT_PEM)) < 0) {
1791 VNC_DEBUG("Cannot load CA certificate %s\n", gnutls_strerror(ret));
1792 gnutls_certificate_free_credentials(x509_cred);
1793 return NULL;
1794 }
1795
1796 if ((ret = gnutls_certificate_set_x509_key_file (x509_cred,
1797 vs->x509cert,
1798 vs->x509key,
1799 GNUTLS_X509_FMT_PEM)) < 0) {
1800 VNC_DEBUG("Cannot load certificate & key %s\n", gnutls_strerror(ret));
1801 gnutls_certificate_free_credentials(x509_cred);
1802 return NULL;
1803 }
1804
1805 if (vs->x509cacrl) {
1806 if ((ret = gnutls_certificate_set_x509_crl_file(x509_cred,
1807 vs->x509cacrl,
1808 GNUTLS_X509_FMT_PEM)) < 0) {
1809 VNC_DEBUG("Cannot load CRL %s\n", gnutls_strerror(ret));
1810 gnutls_certificate_free_credentials(x509_cred);
1811 return NULL;
1812 }
1813 }
1814
1815 gnutls_certificate_set_dh_params (x509_cred, dh_params);
1816
1817 return x509_cred;
1818 }
1819
1820 static int vnc_validate_certificate(struct VncState *vs)
1821 {
1822 int ret;
1823 unsigned int status;
1824 const gnutls_datum_t *certs;
1825 unsigned int nCerts, i;
1826 time_t now;
1827
1828 VNC_DEBUG("Validating client certificate\n");
1829 if ((ret = gnutls_certificate_verify_peers2 (vs->tls_session, &status)) < 0) {
1830 VNC_DEBUG("Verify failed %s\n", gnutls_strerror(ret));
1831 return -1;
1832 }
1833
1834 if ((now = time(NULL)) == ((time_t)-1)) {
1835 return -1;
1836 }
1837
1838 if (status != 0) {
1839 if (status & GNUTLS_CERT_INVALID)
1840 VNC_DEBUG("The certificate is not trusted.\n");
1841
1842 if (status & GNUTLS_CERT_SIGNER_NOT_FOUND)
1843 VNC_DEBUG("The certificate hasn't got a known issuer.\n");
1844
1845 if (status & GNUTLS_CERT_REVOKED)
1846 VNC_DEBUG("The certificate has been revoked.\n");
1847
1848 if (status & GNUTLS_CERT_INSECURE_ALGORITHM)
1849 VNC_DEBUG("The certificate uses an insecure algorithm\n");
1850
1851 return -1;
1852 } else {
1853 VNC_DEBUG("Certificate is valid!\n");
1854 }
1855
1856 /* Only support x509 for now */
1857 if (gnutls_certificate_type_get(vs->tls_session) != GNUTLS_CRT_X509)
1858 return -1;
1859
1860 if (!(certs = gnutls_certificate_get_peers(vs->tls_session, &nCerts)))
1861 return -1;
1862
1863 for (i = 0 ; i < nCerts ; i++) {
1864 gnutls_x509_crt_t cert;
1865 VNC_DEBUG ("Checking certificate chain %d\n", i);
1866 if (gnutls_x509_crt_init (&cert) < 0)
1867 return -1;
1868
1869 if (gnutls_x509_crt_import(cert, &certs[i], GNUTLS_X509_FMT_DER) < 0) {
1870 gnutls_x509_crt_deinit (cert);
1871 return -1;
1872 }
1873
1874 if (gnutls_x509_crt_get_expiration_time (cert) < now) {
1875 VNC_DEBUG("The certificate has expired\n");
1876 gnutls_x509_crt_deinit (cert);
1877 return -1;
1878 }
1879
1880 if (gnutls_x509_crt_get_activation_time (cert) > now) {
1881 VNC_DEBUG("The certificate is not yet activated\n");
1882 gnutls_x509_crt_deinit (cert);
1883 return -1;
1884 }
1885
1886 if (gnutls_x509_crt_get_activation_time (cert) > now) {
1887 VNC_DEBUG("The certificate is not yet activated\n");
1888 gnutls_x509_crt_deinit (cert);
1889 return -1;
1890 }
1891
1892 gnutls_x509_crt_deinit (cert);
1893 }
1894
1895 return 0;
1896 }
1897
1898
1899 static int start_auth_vencrypt_subauth(VncState *vs)
1900 {
1901 switch (vs->subauth) {
1902 case VNC_AUTH_VENCRYPT_TLSNONE:
1903 case VNC_AUTH_VENCRYPT_X509NONE:
1904 VNC_DEBUG("Accept TLS auth none\n");
1905 vnc_write_u32(vs, 0); /* Accept auth completion */
1906 vnc_read_when(vs, protocol_client_init, 1);
1907 break;
1908
1909 case VNC_AUTH_VENCRYPT_TLSVNC:
1910 case VNC_AUTH_VENCRYPT_X509VNC:
1911 VNC_DEBUG("Start TLS auth VNC\n");
1912 return start_auth_vnc(vs);
1913
1914 default: /* Should not be possible, but just in case */
1915 VNC_DEBUG("Reject auth %d\n", vs->auth);
1916 vnc_write_u8(vs, 1);
1917 if (vs->minor >= 8) {
1918 static const char err[] = "Unsupported authentication type";
1919 vnc_write_u32(vs, sizeof(err));
1920 vnc_write(vs, err, sizeof(err));
1921 }
1922 vnc_client_error(vs);
1923 }
1924
1925 return 0;
1926 }
1927
1928 static void vnc_handshake_io(void *opaque);
1929
1930 static int vnc_continue_handshake(struct VncState *vs) {
1931 int ret;
1932
1933 if ((ret = gnutls_handshake(vs->tls_session)) < 0) {
1934 if (!gnutls_error_is_fatal(ret)) {
1935 VNC_DEBUG("Handshake interrupted (blocking)\n");
1936 if (!gnutls_record_get_direction(vs->tls_session))
1937 qemu_set_fd_handler(vs->csock, vnc_handshake_io, NULL, vs);
1938 else
1939 qemu_set_fd_handler(vs->csock, NULL, vnc_handshake_io, vs);
1940 return 0;
1941 }
1942 VNC_DEBUG("Handshake failed %s\n", gnutls_strerror(ret));
1943 vnc_client_error(vs);
1944 return -1;
1945 }
1946
1947 if (vs->x509verify) {
1948 if (vnc_validate_certificate(vs) < 0) {
1949 VNC_DEBUG("Client verification failed\n");
1950 vnc_client_error(vs);
1951 return -1;
1952 } else {
1953 VNC_DEBUG("Client verification passed\n");
1954 }
1955 }
1956
1957 VNC_DEBUG("Handshake done, switching to TLS data mode\n");
1958 vs->wiremode = VNC_WIREMODE_TLS;
1959 qemu_set_fd_handler2(vs->csock, NULL, vnc_client_read, vnc_client_write, vs);
1960
1961 return start_auth_vencrypt_subauth(vs);
1962 }
1963
1964 static void vnc_handshake_io(void *opaque) {
1965 struct VncState *vs = (struct VncState *)opaque;
1966
1967 VNC_DEBUG("Handshake IO continue\n");
1968 vnc_continue_handshake(vs);
1969 }
1970
1971 #define NEED_X509_AUTH(vs) \
1972 ((vs)->subauth == VNC_AUTH_VENCRYPT_X509NONE || \
1973 (vs)->subauth == VNC_AUTH_VENCRYPT_X509VNC || \
1974 (vs)->subauth == VNC_AUTH_VENCRYPT_X509PLAIN)
1975
1976
1977 static int vnc_start_tls(struct VncState *vs) {
1978 static const int cert_type_priority[] = { GNUTLS_CRT_X509, 0 };
1979 static const int protocol_priority[]= { GNUTLS_TLS1_1, GNUTLS_TLS1_0, GNUTLS_SSL3, 0 };
1980 static const int kx_anon[] = {GNUTLS_KX_ANON_DH, 0};
1981 static const int kx_x509[] = {GNUTLS_KX_DHE_DSS, GNUTLS_KX_RSA, GNUTLS_KX_DHE_RSA, GNUTLS_KX_SRP, 0};
1982
1983 VNC_DEBUG("Do TLS setup\n");
1984 if (vnc_tls_initialize() < 0) {
1985 VNC_DEBUG("Failed to init TLS\n");
1986 vnc_client_error(vs);
1987 return -1;
1988 }
1989 if (vs->tls_session == NULL) {
1990 if (gnutls_init(&vs->tls_session, GNUTLS_SERVER) < 0) {
1991 vnc_client_error(vs);
1992 return -1;
1993 }
1994
1995 if (gnutls_set_default_priority(vs->tls_session) < 0) {
1996 gnutls_deinit(vs->tls_session);
1997 vs->tls_session = NULL;
1998 vnc_client_error(vs);
1999 return -1;
2000 }
2001
2002 if (gnutls_kx_set_priority(vs->tls_session, NEED_X509_AUTH(vs) ? kx_x509 : kx_anon) < 0) {
2003 gnutls_deinit(vs->tls_session);
2004 vs->tls_session = NULL;
2005 vnc_client_error(vs);
2006 return -1;
2007 }
2008
2009 if (gnutls_certificate_type_set_priority(vs->tls_session, cert_type_priority) < 0) {
2010 gnutls_deinit(vs->tls_session);
2011 vs->tls_session = NULL;
2012 vnc_client_error(vs);
2013 return -1;
2014 }
2015
2016 if (gnutls_protocol_set_priority(vs->tls_session, protocol_priority) < 0) {
2017 gnutls_deinit(vs->tls_session);
2018 vs->tls_session = NULL;
2019 vnc_client_error(vs);
2020 return -1;
2021 }
2022
2023 if (NEED_X509_AUTH(vs)) {
2024 gnutls_certificate_server_credentials x509_cred = vnc_tls_initialize_x509_cred(vs);
2025 if (!x509_cred) {
2026 gnutls_deinit(vs->tls_session);
2027 vs->tls_session = NULL;
2028 vnc_client_error(vs);
2029 return -1;
2030 }
2031 if (gnutls_credentials_set(vs->tls_session, GNUTLS_CRD_CERTIFICATE, x509_cred) < 0) {
2032 gnutls_deinit(vs->tls_session);
2033 vs->tls_session = NULL;
2034 gnutls_certificate_free_credentials(x509_cred);
2035 vnc_client_error(vs);
2036 return -1;
2037 }
2038 if (vs->x509verify) {
2039 VNC_DEBUG("Requesting a client certificate\n");
2040 gnutls_certificate_server_set_request (vs->tls_session, GNUTLS_CERT_REQUEST);
2041 }
2042
2043 } else {
2044 gnutls_anon_server_credentials anon_cred = vnc_tls_initialize_anon_cred();
2045 if (!anon_cred) {
2046 gnutls_deinit(vs->tls_session);
2047 vs->tls_session = NULL;
2048 vnc_client_error(vs);
2049 return -1;
2050 }
2051 if (gnutls_credentials_set(vs->tls_session, GNUTLS_CRD_ANON, anon_cred) < 0) {
2052 gnutls_deinit(vs->tls_session);
2053 vs->tls_session = NULL;
2054 gnutls_anon_free_server_credentials(anon_cred);
2055 vnc_client_error(vs);
2056 return -1;
2057 }
2058 }
2059
2060 gnutls_transport_set_ptr(vs->tls_session, (gnutls_transport_ptr_t)vs);
2061 gnutls_transport_set_push_function(vs->tls_session, vnc_tls_push);
2062 gnutls_transport_set_pull_function(vs->tls_session, vnc_tls_pull);
2063 }
2064
2065 VNC_DEBUG("Start TLS handshake process\n");
2066 return vnc_continue_handshake(vs);
2067 }
2068
2069 static int protocol_client_vencrypt_auth(VncState *vs, uint8_t *data, size_t len)
2070 {
2071 int auth = read_u32(data, 0);
2072
2073 if (auth != vs->subauth) {
2074 VNC_DEBUG("Rejecting auth %d\n", auth);
2075 vnc_write_u8(vs, 0); /* Reject auth */
2076 vnc_flush(vs);
2077 vnc_client_error(vs);
2078 } else {
2079 VNC_DEBUG("Accepting auth %d, starting handshake\n", auth);
2080 vnc_write_u8(vs, 1); /* Accept auth */
2081 vnc_flush(vs);
2082
2083 if (vnc_start_tls(vs) < 0) {
2084 VNC_DEBUG("Failed to complete TLS\n");
2085 return 0;
2086 }
2087
2088 if (vs->wiremode == VNC_WIREMODE_TLS) {
2089 VNC_DEBUG("Starting VeNCrypt subauth\n");
2090 return start_auth_vencrypt_subauth(vs);
2091 } else {
2092 VNC_DEBUG("TLS handshake blocked\n");
2093 return 0;
2094 }
2095 }
2096 return 0;
2097 }
2098
2099 static int protocol_client_vencrypt_init(VncState *vs, uint8_t *data, size_t len)
2100 {
2101 if (data[0] != 0 ||
2102 data[1] != 2) {
2103 VNC_DEBUG("Unsupported VeNCrypt protocol %d.%d\n", (int)data[0], (int)data[1]);
2104 vnc_write_u8(vs, 1); /* Reject version */
2105 vnc_flush(vs);
2106 vnc_client_error(vs);
2107 } else {
2108 VNC_DEBUG("Sending allowed auth %d\n", vs->subauth);
2109 vnc_write_u8(vs, 0); /* Accept version */
2110 vnc_write_u8(vs, 1); /* Number of sub-auths */
2111 vnc_write_u32(vs, vs->subauth); /* The supported auth */
2112 vnc_flush(vs);
2113 vnc_read_when(vs, protocol_client_vencrypt_auth, 4);
2114 }
2115 return 0;
2116 }
2117
2118 static int start_auth_vencrypt(VncState *vs)
2119 {
2120 /* Send VeNCrypt version 0.2 */
2121 vnc_write_u8(vs, 0);
2122 vnc_write_u8(vs, 2);
2123
2124 vnc_read_when(vs, protocol_client_vencrypt_init, 2);
2125 return 0;
2126 }
2127 #endif /* CONFIG_VNC_TLS */
2128
2129 static int protocol_client_auth(VncState *vs, uint8_t *data, size_t len)
2130 {
2131 /* We only advertise 1 auth scheme at a time, so client
2132 * must pick the one we sent. Verify this */
2133 if (data[0] != vs->auth) { /* Reject auth */
2134 VNC_DEBUG("Reject auth %d\n", (int)data[0]);
2135 vnc_write_u32(vs, 1);
2136 if (vs->minor >= 8) {
2137 static const char err[] = "Authentication failed";
2138 vnc_write_u32(vs, sizeof(err));
2139 vnc_write(vs, err, sizeof(err));
2140 }
2141 vnc_client_error(vs);
2142 } else { /* Accept requested auth */
2143 VNC_DEBUG("Client requested auth %d\n", (int)data[0]);
2144 switch (vs->auth) {
2145 case VNC_AUTH_NONE:
2146 VNC_DEBUG("Accept auth none\n");
2147 if (vs->minor >= 8) {
2148 vnc_write_u32(vs, 0); /* Accept auth completion */
2149 vnc_flush(vs);
2150 }
2151 vnc_read_when(vs, protocol_client_init, 1);
2152 break;
2153
2154 case VNC_AUTH_VNC:
2155 VNC_DEBUG("Start VNC auth\n");
2156 return start_auth_vnc(vs);
2157
2158 #ifdef CONFIG_VNC_TLS
2159 case VNC_AUTH_VENCRYPT:
2160 VNC_DEBUG("Accept VeNCrypt auth\n");;
2161 return start_auth_vencrypt(vs);
2162 #endif /* CONFIG_VNC_TLS */
2163
2164 default: /* Should not be possible, but just in case */
2165 VNC_DEBUG("Reject auth %d\n", vs->auth);
2166 vnc_write_u8(vs, 1);
2167 if (vs->minor >= 8) {
2168 static const char err[] = "Authentication failed";
2169 vnc_write_u32(vs, sizeof(err));
2170 vnc_write(vs, err, sizeof(err));
2171 }
2172 vnc_client_error(vs);
2173 }
2174 }
2175 return 0;
2176 }
2177
2178 static int protocol_version(VncState *vs, uint8_t *version, size_t len)
2179 {
2180 char local[13];
2181
2182 memcpy(local, version, 12);
2183 local[12] = 0;
2184
2185 if (sscanf(local, "RFB %03d.%03d\n", &vs->major, &vs->minor) != 2) {
2186 VNC_DEBUG("Malformed protocol version %s\n", local);
2187 vnc_client_error(vs);
2188 return 0;
2189 }
2190 VNC_DEBUG("Client request protocol version %d.%d\n", vs->major, vs->minor);
2191 if (vs->major != 3 ||
2192 (vs->minor != 3 &&
2193 vs->minor != 4 &&
2194 vs->minor != 5 &&
2195 vs->minor != 7 &&
2196 vs->minor != 8)) {
2197 VNC_DEBUG("Unsupported client version\n");
2198 vnc_write_u32(vs, VNC_AUTH_INVALID);
2199 vnc_flush(vs);
2200 vnc_client_error(vs);
2201 return 0;
2202 }
2203 /* Some broken clients report v3.4 or v3.5, which spec requires to be treated
2204 * as equivalent to v3.3 by servers
2205 */
2206 if (vs->minor == 4 || vs->minor == 5)
2207 vs->minor = 3;
2208
2209 if (vs->minor == 3) {
2210 if (vs->auth == VNC_AUTH_NONE) {
2211 VNC_DEBUG("Tell client auth none\n");
2212 vnc_write_u32(vs, vs->auth);
2213 vnc_flush(vs);
2214 vnc_read_when(vs, protocol_client_init, 1);
2215 } else if (vs->auth == VNC_AUTH_VNC) {
2216 VNC_DEBUG("Tell client VNC auth\n");
2217 vnc_write_u32(vs, vs->auth);
2218 vnc_flush(vs);
2219 start_auth_vnc(vs);
2220 } else {
2221 VNC_DEBUG("Unsupported auth %d for protocol 3.3\n", vs->auth);
2222 vnc_write_u32(vs, VNC_AUTH_INVALID);
2223 vnc_flush(vs);
2224 vnc_client_error(vs);
2225 }
2226 } else {
2227 VNC_DEBUG("Telling client we support auth %d\n", vs->auth);
2228 vnc_write_u8(vs, 1); /* num auth */
2229 vnc_write_u8(vs, vs->auth);
2230 vnc_read_when(vs, protocol_client_auth, 1);
2231 vnc_flush(vs);
2232 }
2233
2234 return 0;
2235 }
2236
2237 static void vnc_connect(VncState *vs)
2238 {
2239 VNC_DEBUG("New client on socket %d\n", vs->csock);
2240 vs->ds->idle = 0;
2241 socket_set_nonblock(vs->csock);
2242 qemu_set_fd_handler2(vs->csock, NULL, vnc_client_read, NULL, vs);
2243 vnc_write(vs, "RFB 003.008\n", 12);
2244 vnc_flush(vs);
2245 vnc_read_when(vs, protocol_version, 12);
2246 memset(vs->old_data, 0, ds_get_linesize(vs->ds) * ds_get_height(vs->ds));
2247 memset(vs->dirty_row, 0xFF, sizeof(vs->dirty_row));
2248 vs->has_resize = 0;
2249 vs->has_hextile = 0;
2250 vs->ds->dpy_copy = NULL;
2251 vnc_update_client(vs);
2252 reset_keys(vs);
2253 }
2254
2255 static void vnc_listen_read(void *opaque)
2256 {
2257 VncState *vs = opaque;
2258 struct sockaddr_in addr;
2259 socklen_t addrlen = sizeof(addr);
2260
2261 /* Catch-up */
2262 vga_hw_update();
2263
2264 vs->csock = accept(vs->lsock, (struct sockaddr *)&addr, &addrlen);
2265 if (vs->csock != -1) {
2266 vnc_connect(vs);
2267 }
2268 }
2269
2270 void vnc_display_init(DisplayState *ds)
2271 {
2272 VncState *vs;
2273
2274 vs = qemu_mallocz(sizeof(VncState));
2275 if (!vs)
2276 exit(1);
2277
2278 ds->opaque = vs;
2279 ds->idle = 1;
2280 vnc_state = vs;
2281 vs->display = NULL;
2282 vs->password = NULL;
2283
2284 vs->lsock = -1;
2285 vs->csock = -1;
2286 vs->last_x = -1;
2287 vs->last_y = -1;
2288
2289 vs->ds = ds;
2290
2291 if (keyboard_layout)
2292 vs->kbd_layout = init_keyboard_layout(keyboard_layout);
2293 else
2294 vs->kbd_layout = init_keyboard_layout("en-us");
2295
2296 if (!vs->kbd_layout)
2297 exit(1);
2298
2299 vs->timer = qemu_new_timer(rt_clock, vnc_update_client, vs);
2300
2301 vs->ds->data = NULL;
2302 vs->ds->dpy_update = vnc_dpy_update;
2303 vs->ds->dpy_resize = vnc_dpy_resize;
2304 vs->ds->dpy_refresh = NULL;
2305
2306 vnc_colordepth(vs->ds, 32);
2307 vnc_dpy_resize(vs->ds, 640, 400);
2308
2309 vs->as.freq = 44100;
2310 vs->as.nchannels = 2;
2311 vs->as.fmt = AUD_FMT_S16;
2312 vs->as.endianness = 0;
2313 }
2314
2315 #ifdef CONFIG_VNC_TLS
2316 static int vnc_set_x509_credential(VncState *vs,
2317 const char *certdir,
2318 const char *filename,
2319 char **cred,
2320 int ignoreMissing)
2321 {
2322 struct stat sb;
2323
2324 if (*cred) {
2325 qemu_free(*cred);
2326 *cred = NULL;
2327 }
2328
2329 if (!(*cred = qemu_malloc(strlen(certdir) + strlen(filename) + 2)))
2330 return -1;
2331
2332 strcpy(*cred, certdir);
2333 strcat(*cred, "/");
2334 strcat(*cred, filename);
2335
2336 VNC_DEBUG("Check %s\n", *cred);
2337 if (stat(*cred, &sb) < 0) {
2338 qemu_free(*cred);
2339 *cred = NULL;
2340 if (ignoreMissing && errno == ENOENT)
2341 return 0;
2342 return -1;
2343 }
2344
2345 return 0;
2346 }
2347
2348 static int vnc_set_x509_credential_dir(VncState *vs,
2349 const char *certdir)
2350 {
2351 if (vnc_set_x509_credential(vs, certdir, X509_CA_CERT_FILE, &vs->x509cacert, 0) < 0)
2352 goto cleanup;
2353 if (vnc_set_x509_credential(vs, certdir, X509_CA_CRL_FILE, &vs->x509cacrl, 1) < 0)
2354 goto cleanup;
2355 if (vnc_set_x509_credential(vs, certdir, X509_SERVER_CERT_FILE, &vs->x509cert, 0) < 0)
2356 goto cleanup;
2357 if (vnc_set_x509_credential(vs, certdir, X509_SERVER_KEY_FILE, &vs->x509key, 0) < 0)
2358 goto cleanup;
2359
2360 return 0;
2361
2362 cleanup:
2363 qemu_free(vs->x509cacert);
2364 qemu_free(vs->x509cacrl);
2365 qemu_free(vs->x509cert);
2366 qemu_free(vs->x509key);
2367 vs->x509cacert = vs->x509cacrl = vs->x509cert = vs->x509key = NULL;
2368 return -1;
2369 }
2370 #endif /* CONFIG_VNC_TLS */
2371
2372 void vnc_display_close(DisplayState *ds)
2373 {
2374 VncState *vs = ds ? (VncState *)ds->opaque : vnc_state;
2375
2376 if (vs->display) {
2377 qemu_free(vs->display);
2378 vs->display = NULL;
2379 }
2380 if (vs->lsock != -1) {
2381 qemu_set_fd_handler2(vs->lsock, NULL, NULL, NULL, NULL);
2382 close(vs->lsock);
2383 vs->lsock = -1;
2384 }
2385 if (vs->csock != -1) {
2386 qemu_set_fd_handler2(vs->csock, NULL, NULL, NULL, NULL);
2387 closesocket(vs->csock);
2388 vs->csock = -1;
2389 buffer_reset(&vs->input);
2390 buffer_reset(&vs->output);
2391 vs->need_update = 0;
2392 #ifdef CONFIG_VNC_TLS
2393 if (vs->tls_session) {
2394 gnutls_deinit(vs->tls_session);
2395 vs->tls_session = NULL;
2396 }
2397 vs->wiremode = VNC_WIREMODE_CLEAR;
2398 #endif /* CONFIG_VNC_TLS */
2399 }
2400 vs->auth = VNC_AUTH_INVALID;
2401 #ifdef CONFIG_VNC_TLS
2402 vs->subauth = VNC_AUTH_INVALID;
2403 vs->x509verify = 0;
2404 #endif
2405 audio_del(vs);
2406 }
2407
2408 int vnc_display_password(DisplayState *ds, const char *password)
2409 {
2410 VncState *vs = ds ? (VncState *)ds->opaque : vnc_state;
2411
2412 if (vs->password) {
2413 qemu_free(vs->password);
2414 vs->password = NULL;
2415 }
2416 if (password && password[0]) {
2417 if (!(vs->password = qemu_strdup(password)))
2418 return -1;
2419 }
2420
2421 return 0;
2422 }
2423
2424 int vnc_display_open(DisplayState *ds, const char *display)
2425 {
2426 VncState *vs = ds ? (VncState *)ds->opaque : vnc_state;
2427 const char *options;
2428 int password = 0;
2429 int reverse = 0;
2430 int to_port = 0;
2431 #ifdef CONFIG_VNC_TLS
2432 int tls = 0, x509 = 0;
2433 #endif
2434
2435 vnc_display_close(ds);
2436 if (strcmp(display, "none") == 0)
2437 return 0;
2438
2439 if (!(vs->display = strdup(display)))
2440 return -1;
2441
2442 options = display;
2443 while ((options = strchr(options, ','))) {
2444 options++;
2445 if (strncmp(options, "password", 8) == 0) {
2446 password = 1; /* Require password auth */
2447 } else if (strncmp(options, "reverse", 7) == 0) {
2448 reverse = 1;
2449 } else if (strncmp(options, "to=", 3) == 0) {
2450 to_port = atoi(options+3) + 5900;
2451 #ifdef CONFIG_VNC_TLS
2452 } else if (strncmp(options, "tls", 3) == 0) {
2453 tls = 1; /* Require TLS */
2454 } else if (strncmp(options, "x509", 4) == 0) {
2455 char *start, *end;
2456 x509 = 1; /* Require x509 certificates */
2457 if (strncmp(options, "x509verify", 10) == 0)
2458 vs->x509verify = 1; /* ...and verify client certs */
2459
2460 /* Now check for 'x509=/some/path' postfix
2461 * and use that to setup x509 certificate/key paths */
2462 start = strchr(options, '=');
2463 end = strchr(options, ',');
2464 if (start && (!end || (start < end))) {
2465 int len = end ? end-(start+1) : strlen(start+1);
2466 char *path = qemu_strndup(start + 1, len);
2467
2468 VNC_DEBUG("Trying certificate path '%s'\n", path);
2469 if (vnc_set_x509_credential_dir(vs, path) < 0) {
2470 fprintf(stderr, "Failed to find x509 certificates/keys in %s\n", path);
2471 qemu_free(path);
2472 qemu_free(vs->display);
2473 vs->display = NULL;
2474 return -1;
2475 }
2476 qemu_free(path);
2477 } else {
2478 fprintf(stderr, "No certificate path provided\n");
2479 qemu_free(vs->display);
2480 vs->display = NULL;
2481 return -1;
2482 }
2483 #endif
2484 }
2485 }
2486
2487 if (password) {
2488 #ifdef CONFIG_VNC_TLS
2489 if (tls) {
2490 vs->auth = VNC_AUTH_VENCRYPT;
2491 if (x509) {
2492 VNC_DEBUG("Initializing VNC server with x509 password auth\n");
2493 vs->subauth = VNC_AUTH_VENCRYPT_X509VNC;
2494 } else {
2495 VNC_DEBUG("Initializing VNC server with TLS password auth\n");
2496 vs->subauth = VNC_AUTH_VENCRYPT_TLSVNC;
2497 }
2498 } else {
2499 #endif
2500 VNC_DEBUG("Initializing VNC server with password auth\n");
2501 vs->auth = VNC_AUTH_VNC;
2502 #ifdef CONFIG_VNC_TLS
2503 vs->subauth = VNC_AUTH_INVALID;
2504 }
2505 #endif
2506 } else {
2507 #ifdef CONFIG_VNC_TLS
2508 if (tls) {
2509 vs->auth = VNC_AUTH_VENCRYPT;
2510 if (x509) {
2511 VNC_DEBUG("Initializing VNC server with x509 no auth\n");
2512 vs->subauth = VNC_AUTH_VENCRYPT_X509NONE;
2513 } else {
2514 VNC_DEBUG("Initializing VNC server with TLS no auth\n");
2515 vs->subauth = VNC_AUTH_VENCRYPT_TLSNONE;
2516 }
2517 } else {
2518 #endif
2519 VNC_DEBUG("Initializing VNC server with no auth\n");
2520 vs->auth = VNC_AUTH_NONE;
2521 #ifdef CONFIG_VNC_TLS
2522 vs->subauth = VNC_AUTH_INVALID;
2523 }
2524 #endif
2525 }
2526
2527 if (reverse) {
2528 /* connect to viewer */
2529 if (strncmp(display, "unix:", 5) == 0)
2530 vs->lsock = unix_connect(display+5);
2531 else
2532 vs->lsock = inet_connect(display, SOCK_STREAM);
2533 if (-1 == vs->lsock) {
2534 free(vs->display);
2535 vs->display = NULL;
2536 return -1;
2537 } else {
2538 vs->csock = vs->lsock;
2539 vs->lsock = -1;
2540 vnc_connect(vs);
2541 }
2542 return 0;
2543
2544 } else {
2545 /* listen for connects */
2546 char *dpy;
2547 dpy = qemu_malloc(256);
2548 if (strncmp(display, "unix:", 5) == 0) {
2549 strcpy(dpy, "unix:");
2550 vs->lsock = unix_listen(display+5, dpy+5, 256-5);
2551 } else {
2552 vs->lsock = inet_listen(display, dpy, 256, SOCK_STREAM, 5900);
2553 }
2554 if (-1 == vs->lsock) {
2555 free(dpy);
2556 return -1;
2557 } else {
2558 free(vs->display);
2559 vs->display = dpy;
2560 }
2561 }
2562
2563 return qemu_set_fd_handler2(vs->lsock, vnc_listen_poll, vnc_listen_read, NULL, vs);
2564 }
jz4740 based target emulation