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