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