?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mmu-hash*: Correctly mask RPN from hash PTE
[qemu/agraf.git] / ui / vnc.c
blobbbe1e0f179c46ac05a0567b34c80145969c911cf
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 "vnc-jobs.h"
29 #include "sysemu/sysemu.h"
30 #include "qemu/sockets.h"
31 #include "qemu/timer.h"
32 #include "qemu/acl.h"
33 #include "qapi/qmp/types.h"
34 #include "qmp-commands.h"
35 #include "qemu/osdep.h"
36
37 #define VNC_REFRESH_INTERVAL_BASE 30
38 #define VNC_REFRESH_INTERVAL_INC 50
39 #define VNC_REFRESH_INTERVAL_MAX 2000
40 static const struct timeval VNC_REFRESH_STATS = { 0, 500000 };
41 static const struct timeval VNC_REFRESH_LOSSY = { 2, 0 };
42
43 #include "vnc_keysym.h"
44 #include "d3des.h"
45
46 static VncDisplay *vnc_display; /* needed for info vnc */
47
48 static int vnc_cursor_define(VncState *vs);
49 static void vnc_release_modifiers(VncState *vs);
50
51 static void vnc_set_share_mode(VncState *vs, VncShareMode mode)
52 {
53 #ifdef _VNC_DEBUG
54 static const char *mn[] = {
55 [0] = "undefined",
56 [VNC_SHARE_MODE_CONNECTING] = "connecting",
57 [VNC_SHARE_MODE_SHARED] = "shared",
58 [VNC_SHARE_MODE_EXCLUSIVE] = "exclusive",
59 [VNC_SHARE_MODE_DISCONNECTED] = "disconnected",
60 };
61 fprintf(stderr, "%s/%d: %s -> %s\n", __func__,
62 vs->csock, mn[vs->share_mode], mn[mode]);
63 #endif
64
65 if (vs->share_mode == VNC_SHARE_MODE_EXCLUSIVE) {
66 vs->vd->num_exclusive--;
67 }
68 vs->share_mode = mode;
69 if (vs->share_mode == VNC_SHARE_MODE_EXCLUSIVE) {
70 vs->vd->num_exclusive++;
71 }
72 }
73
74 static char *addr_to_string(const char *format,
75 struct sockaddr_storage *sa,
76 socklen_t salen) {
77 char *addr;
78 char host[NI_MAXHOST];
79 char serv[NI_MAXSERV];
80 int err;
81 size_t addrlen;
82
83 if ((err = getnameinfo((struct sockaddr *)sa, salen,
84 host, sizeof(host),
85 serv, sizeof(serv),
86 NI_NUMERICHOST | NI_NUMERICSERV)) != 0) {
87 VNC_DEBUG("Cannot resolve address %d: %s\n",
88 err, gai_strerror(err));
89 return NULL;
90 }
91
92 /* Enough for the existing format + the 2 vars we're
93 * substituting in. */
94 addrlen = strlen(format) + strlen(host) + strlen(serv);
95 addr = g_malloc(addrlen + 1);
96 snprintf(addr, addrlen, format, host, serv);
97 addr[addrlen] = '\0';
98
99 return addr;
100 }
101
102
103 char *vnc_socket_local_addr(const char *format, int fd) {
104 struct sockaddr_storage sa;
105 socklen_t salen;
106
107 salen = sizeof(sa);
108 if (getsockname(fd, (struct sockaddr*)&sa, &salen) < 0)
109 return NULL;
110
111 return addr_to_string(format, &sa, salen);
112 }
113
114 char *vnc_socket_remote_addr(const char *format, int fd) {
115 struct sockaddr_storage sa;
116 socklen_t salen;
117
118 salen = sizeof(sa);
119 if (getpeername(fd, (struct sockaddr*)&sa, &salen) < 0)
120 return NULL;
121
122 return addr_to_string(format, &sa, salen);
123 }
124
125 static int put_addr_qdict(QDict *qdict, struct sockaddr_storage *sa,
126 socklen_t salen)
127 {
128 char host[NI_MAXHOST];
129 char serv[NI_MAXSERV];
130 int err;
131
132 if ((err = getnameinfo((struct sockaddr *)sa, salen,
133 host, sizeof(host),
134 serv, sizeof(serv),
135 NI_NUMERICHOST | NI_NUMERICSERV)) != 0) {
136 VNC_DEBUG("Cannot resolve address %d: %s\n",
137 err, gai_strerror(err));
138 return -1;
139 }
140
141 qdict_put(qdict, "host", qstring_from_str(host));
142 qdict_put(qdict, "service", qstring_from_str(serv));
143 qdict_put(qdict, "family",qstring_from_str(inet_strfamily(sa->ss_family)));
144
145 return 0;
146 }
147
148 static int vnc_server_addr_put(QDict *qdict, int fd)
149 {
150 struct sockaddr_storage sa;
151 socklen_t salen;
152
153 salen = sizeof(sa);
154 if (getsockname(fd, (struct sockaddr*)&sa, &salen) < 0) {
155 return -1;
156 }
157
158 return put_addr_qdict(qdict, &sa, salen);
159 }
160
161 static int vnc_qdict_remote_addr(QDict *qdict, int fd)
162 {
163 struct sockaddr_storage sa;
164 socklen_t salen;
165
166 salen = sizeof(sa);
167 if (getpeername(fd, (struct sockaddr*)&sa, &salen) < 0) {
168 return -1;
169 }
170
171 return put_addr_qdict(qdict, &sa, salen);
172 }
173
174 static const char *vnc_auth_name(VncDisplay *vd) {
175 switch (vd->auth) {
176 case VNC_AUTH_INVALID:
177 return "invalid";
178 case VNC_AUTH_NONE:
179 return "none";
180 case VNC_AUTH_VNC:
181 return "vnc";
182 case VNC_AUTH_RA2:
183 return "ra2";
184 case VNC_AUTH_RA2NE:
185 return "ra2ne";
186 case VNC_AUTH_TIGHT:
187 return "tight";
188 case VNC_AUTH_ULTRA:
189 return "ultra";
190 case VNC_AUTH_TLS:
191 return "tls";
192 case VNC_AUTH_VENCRYPT:
193 #ifdef CONFIG_VNC_TLS
194 switch (vd->subauth) {
195 case VNC_AUTH_VENCRYPT_PLAIN:
196 return "vencrypt+plain";
197 case VNC_AUTH_VENCRYPT_TLSNONE:
198 return "vencrypt+tls+none";
199 case VNC_AUTH_VENCRYPT_TLSVNC:
200 return "vencrypt+tls+vnc";
201 case VNC_AUTH_VENCRYPT_TLSPLAIN:
202 return "vencrypt+tls+plain";
203 case VNC_AUTH_VENCRYPT_X509NONE:
204 return "vencrypt+x509+none";
205 case VNC_AUTH_VENCRYPT_X509VNC:
206 return "vencrypt+x509+vnc";
207 case VNC_AUTH_VENCRYPT_X509PLAIN:
208 return "vencrypt+x509+plain";
209 case VNC_AUTH_VENCRYPT_TLSSASL:
210 return "vencrypt+tls+sasl";
211 case VNC_AUTH_VENCRYPT_X509SASL:
212 return "vencrypt+x509+sasl";
213 default:
214 return "vencrypt";
215 }
216 #else
217 return "vencrypt";
218 #endif
219 case VNC_AUTH_SASL:
220 return "sasl";
221 }
222 return "unknown";
223 }
224
225 static int vnc_server_info_put(QDict *qdict)
226 {
227 if (vnc_server_addr_put(qdict, vnc_display->lsock) < 0) {
228 return -1;
229 }
230
231 qdict_put(qdict, "auth", qstring_from_str(vnc_auth_name(vnc_display)));
232 return 0;
233 }
234
235 static void vnc_client_cache_auth(VncState *client)
236 {
237 #if defined(CONFIG_VNC_TLS) || defined(CONFIG_VNC_SASL)
238 QDict *qdict;
239 #endif
240
241 if (!client->info) {
242 return;
243 }
244
245 #if defined(CONFIG_VNC_TLS) || defined(CONFIG_VNC_SASL)
246 qdict = qobject_to_qdict(client->info);
247 #endif
248
249 #ifdef CONFIG_VNC_TLS
250 if (client->tls.session &&
251 client->tls.dname) {
252 qdict_put(qdict, "x509_dname", qstring_from_str(client->tls.dname));
253 }
254 #endif
255 #ifdef CONFIG_VNC_SASL
256 if (client->sasl.conn &&
257 client->sasl.username) {
258 qdict_put(qdict, "sasl_username",
259 qstring_from_str(client->sasl.username));
260 }
261 #endif
262 }
263
264 static void vnc_client_cache_addr(VncState *client)
265 {
266 QDict *qdict;
267
268 qdict = qdict_new();
269 if (vnc_qdict_remote_addr(qdict, client->csock) < 0) {
270 QDECREF(qdict);
271 /* XXX: how to report the error? */
272 return;
273 }
274
275 client->info = QOBJECT(qdict);
276 }
277
278 static void vnc_qmp_event(VncState *vs, MonitorEvent event)
279 {
280 QDict *server;
281 QObject *data;
282
283 if (!vs->info) {
284 return;
285 }
286
287 server = qdict_new();
288 if (vnc_server_info_put(server) < 0) {
289 QDECREF(server);
290 return;
291 }
292
293 data = qobject_from_jsonf("{ 'client': %p, 'server': %p }",
294 vs->info, QOBJECT(server));
295
296 monitor_protocol_event(event, data);
297
298 qobject_incref(vs->info);
299 qobject_decref(data);
300 }
301
302 static VncClientInfo *qmp_query_vnc_client(const VncState *client)
303 {
304 struct sockaddr_storage sa;
305 socklen_t salen = sizeof(sa);
306 char host[NI_MAXHOST];
307 char serv[NI_MAXSERV];
308 VncClientInfo *info;
309
310 if (getpeername(client->csock, (struct sockaddr *)&sa, &salen) < 0) {
311 return NULL;
312 }
313
314 if (getnameinfo((struct sockaddr *)&sa, salen,
315 host, sizeof(host),
316 serv, sizeof(serv),
317 NI_NUMERICHOST | NI_NUMERICSERV) < 0) {
318 return NULL;
319 }
320
321 info = g_malloc0(sizeof(*info));
322 info->host = g_strdup(host);
323 info->service = g_strdup(serv);
324 info->family = g_strdup(inet_strfamily(sa.ss_family));
325
326 #ifdef CONFIG_VNC_TLS
327 if (client->tls.session && client->tls.dname) {
328 info->has_x509_dname = true;
329 info->x509_dname = g_strdup(client->tls.dname);
330 }
331 #endif
332 #ifdef CONFIG_VNC_SASL
333 if (client->sasl.conn && client->sasl.username) {
334 info->has_sasl_username = true;
335 info->sasl_username = g_strdup(client->sasl.username);
336 }
337 #endif
338
339 return info;
340 }
341
342 VncInfo *qmp_query_vnc(Error **errp)
343 {
344 VncInfo *info = g_malloc0(sizeof(*info));
345
346 if (vnc_display == NULL || vnc_display->display == NULL) {
347 info->enabled = false;
348 } else {
349 VncClientInfoList *cur_item = NULL;
350 struct sockaddr_storage sa;
351 socklen_t salen = sizeof(sa);
352 char host[NI_MAXHOST];
353 char serv[NI_MAXSERV];
354 VncState *client;
355
356 info->enabled = true;
357
358 /* for compatibility with the original command */
359 info->has_clients = true;
360
361 QTAILQ_FOREACH(client, &vnc_display->clients, next) {
362 VncClientInfoList *cinfo = g_malloc0(sizeof(*info));
363 cinfo->value = qmp_query_vnc_client(client);
364
365 /* XXX: waiting for the qapi to support GSList */
366 if (!cur_item) {
367 info->clients = cur_item = cinfo;
368 } else {
369 cur_item->next = cinfo;
370 cur_item = cinfo;
371 }
372 }
373
374 if (vnc_display->lsock == -1) {
375 return info;
376 }
377
378 if (getsockname(vnc_display->lsock, (struct sockaddr *)&sa,
379 &salen) == -1) {
380 error_set(errp, QERR_UNDEFINED_ERROR);
381 goto out_error;
382 }
383
384 if (getnameinfo((struct sockaddr *)&sa, salen,
385 host, sizeof(host),
386 serv, sizeof(serv),
387 NI_NUMERICHOST | NI_NUMERICSERV) < 0) {
388 error_set(errp, QERR_UNDEFINED_ERROR);
389 goto out_error;
390 }
391
392 info->has_host = true;
393 info->host = g_strdup(host);
394
395 info->has_service = true;
396 info->service = g_strdup(serv);
397
398 info->has_family = true;
399 info->family = g_strdup(inet_strfamily(sa.ss_family));
400
401 info->has_auth = true;
402 info->auth = g_strdup(vnc_auth_name(vnc_display));
403 }
404
405 return info;
406
407 out_error:
408 qapi_free_VncInfo(info);
409 return NULL;
410 }
411
412 /* TODO
413 1) Get the queue working for IO.
414 2) there is some weirdness when using the -S option (the screen is grey
415 and not totally invalidated
416 3) resolutions > 1024
417 */
418
419 static int vnc_update_client(VncState *vs, int has_dirty);
420 static int vnc_update_client_sync(VncState *vs, int has_dirty);
421 static void vnc_disconnect_start(VncState *vs);
422 static void vnc_init_timer(VncDisplay *vd);
423 static void vnc_remove_timer(VncDisplay *vd);
424
425 static void vnc_colordepth(VncState *vs);
426 static void framebuffer_update_request(VncState *vs, int incremental,
427 int x_position, int y_position,
428 int w, int h);
429 static void vnc_refresh(void *opaque);
430 static int vnc_refresh_server_surface(VncDisplay *vd);
431
432 static void vnc_dpy_update(DisplayChangeListener *dcl,
433 int x, int y, int w, int h)
434 {
435 int i;
436 VncDisplay *vd = container_of(dcl, VncDisplay, dcl);
437 struct VncSurface *s = &vd->guest;
438 int width = surface_width(vd->ds);
439 int height = surface_height(vd->ds);
440
441 h += y;
442
443 /* round x down to ensure the loop only spans one 16-pixel block per,
444 iteration. otherwise, if (x % 16) != 0, the last iteration may span
445 two 16-pixel blocks but we only mark the first as dirty
446 */
447 w += (x % 16);
448 x -= (x % 16);
449
450 x = MIN(x, width);
451 y = MIN(y, height);
452 w = MIN(x + w, width) - x;
453 h = MIN(h, height);
454
455 for (; y < h; y++)
456 for (i = 0; i < w; i += 16)
457 set_bit((x + i) / 16, s->dirty[y]);
458 }
459
460 void vnc_framebuffer_update(VncState *vs, int x, int y, int w, int h,
461 int32_t encoding)
462 {
463 vnc_write_u16(vs, x);
464 vnc_write_u16(vs, y);
465 vnc_write_u16(vs, w);
466 vnc_write_u16(vs, h);
467
468 vnc_write_s32(vs, encoding);
469 }
470
471 void buffer_reserve(Buffer *buffer, size_t len)
472 {
473 if ((buffer->capacity - buffer->offset) < len) {
474 buffer->capacity += (len + 1024);
475 buffer->buffer = g_realloc(buffer->buffer, buffer->capacity);
476 if (buffer->buffer == NULL) {
477 fprintf(stderr, "vnc: out of memory\n");
478 exit(1);
479 }
480 }
481 }
482
483 static int buffer_empty(Buffer *buffer)
484 {
485 return buffer->offset == 0;
486 }
487
488 uint8_t *buffer_end(Buffer *buffer)
489 {
490 return buffer->buffer + buffer->offset;
491 }
492
493 void buffer_reset(Buffer *buffer)
494 {
495 buffer->offset = 0;
496 }
497
498 void buffer_free(Buffer *buffer)
499 {
500 g_free(buffer->buffer);
501 buffer->offset = 0;
502 buffer->capacity = 0;
503 buffer->buffer = NULL;
504 }
505
506 void buffer_append(Buffer *buffer, const void *data, size_t len)
507 {
508 memcpy(buffer->buffer + buffer->offset, data, len);
509 buffer->offset += len;
510 }
511
512 void buffer_advance(Buffer *buf, size_t len)
513 {
514 memmove(buf->buffer, buf->buffer + len,
515 (buf->offset - len));
516 buf->offset -= len;
517 }
518
519 static void vnc_desktop_resize(VncState *vs)
520 {
521 DisplaySurface *ds = vs->vd->ds;
522
523 if (vs->csock == -1 || !vnc_has_feature(vs, VNC_FEATURE_RESIZE)) {
524 return;
525 }
526 if (vs->client_width == surface_width(ds) &&
527 vs->client_height == surface_height(ds)) {
528 return;
529 }
530 vs->client_width = surface_width(ds);
531 vs->client_height = surface_height(ds);
532 vnc_lock_output(vs);
533 vnc_write_u8(vs, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE);
534 vnc_write_u8(vs, 0);
535 vnc_write_u16(vs, 1); /* number of rects */
536 vnc_framebuffer_update(vs, 0, 0, vs->client_width, vs->client_height,
537 VNC_ENCODING_DESKTOPRESIZE);
538 vnc_unlock_output(vs);
539 vnc_flush(vs);
540 }
541
542 static void vnc_abort_display_jobs(VncDisplay *vd)
543 {
544 VncState *vs;
545
546 QTAILQ_FOREACH(vs, &vd->clients, next) {
547 vnc_lock_output(vs);
548 vs->abort = true;
549 vnc_unlock_output(vs);
550 }
551 QTAILQ_FOREACH(vs, &vd->clients, next) {
552 vnc_jobs_join(vs);
553 }
554 QTAILQ_FOREACH(vs, &vd->clients, next) {
555 vnc_lock_output(vs);
556 vs->abort = false;
557 vnc_unlock_output(vs);
558 }
559 }
560
561 int vnc_server_fb_stride(VncDisplay *vd)
562 {
563 return pixman_image_get_stride(vd->server);
564 }
565
566 void *vnc_server_fb_ptr(VncDisplay *vd, int x, int y)
567 {
568 uint8_t *ptr;
569
570 ptr = (uint8_t *)pixman_image_get_data(vd->server);
571 ptr += y * vnc_server_fb_stride(vd);
572 ptr += x * VNC_SERVER_FB_BYTES;
573 return ptr;
574 }
575
576 static void vnc_dpy_switch(DisplayChangeListener *dcl,
577 DisplaySurface *surface)
578 {
579 VncDisplay *vd = container_of(dcl, VncDisplay, dcl);
580 VncState *vs;
581
582 vnc_abort_display_jobs(vd);
583
584 /* server surface */
585 qemu_pixman_image_unref(vd->server);
586 vd->ds = surface;
587 vd->server = pixman_image_create_bits(VNC_SERVER_FB_FORMAT,
588 surface_width(vd->ds),
589 surface_height(vd->ds),
590 NULL, 0);
591
592 /* guest surface */
593 #if 0 /* FIXME */
594 if (ds_get_bytes_per_pixel(ds) != vd->guest.ds->pf.bytes_per_pixel)
595 console_color_init(ds);
596 #endif
597 qemu_pixman_image_unref(vd->guest.fb);
598 vd->guest.fb = pixman_image_ref(surface->image);
599 vd->guest.format = surface->format;
600 memset(vd->guest.dirty, 0xFF, sizeof(vd->guest.dirty));
601
602 QTAILQ_FOREACH(vs, &vd->clients, next) {
603 vnc_colordepth(vs);
604 vnc_desktop_resize(vs);
605 if (vs->vd->cursor) {
606 vnc_cursor_define(vs);
607 }
608 memset(vs->dirty, 0xFF, sizeof(vs->dirty));
609 }
610 }
611
612 /* fastest code */
613 static void vnc_write_pixels_copy(VncState *vs,
614 void *pixels, int size)
615 {
616 vnc_write(vs, pixels, size);
617 }
618
619 /* slowest but generic code. */
620 void vnc_convert_pixel(VncState *vs, uint8_t *buf, uint32_t v)
621 {
622 uint8_t r, g, b;
623
624 #if VNC_SERVER_FB_FORMAT == PIXMAN_FORMAT(32, PIXMAN_TYPE_ARGB, 0, 8, 8, 8)
625 r = (((v & 0x00ff0000) >> 16) << vs->client_pf.rbits) >> 8;
626 g = (((v & 0x0000ff00) >> 8) << vs->client_pf.gbits) >> 8;
627 b = (((v & 0x000000ff) >> 0) << vs->client_pf.bbits) >> 8;
628 #else
629 # error need some bits here if you change VNC_SERVER_FB_FORMAT
630 #endif
631 v = (r << vs->client_pf.rshift) |
632 (g << vs->client_pf.gshift) |
633 (b << vs->client_pf.bshift);
634 switch (vs->client_pf.bytes_per_pixel) {
635 case 1:
636 buf[0] = v;
637 break;
638 case 2:
639 if (vs->client_be) {
640 buf[0] = v >> 8;
641 buf[1] = v;
642 } else {
643 buf[1] = v >> 8;
644 buf[0] = v;
645 }
646 break;
647 default:
648 case 4:
649 if (vs->client_be) {
650 buf[0] = v >> 24;
651 buf[1] = v >> 16;
652 buf[2] = v >> 8;
653 buf[3] = v;
654 } else {
655 buf[3] = v >> 24;
656 buf[2] = v >> 16;
657 buf[1] = v >> 8;
658 buf[0] = v;
659 }
660 break;
661 }
662 }
663
664 static void vnc_write_pixels_generic(VncState *vs,
665 void *pixels1, int size)
666 {
667 uint8_t buf[4];
668
669 if (VNC_SERVER_FB_BYTES == 4) {
670 uint32_t *pixels = pixels1;
671 int n, i;
672 n = size >> 2;
673 for (i = 0; i < n; i++) {
674 vnc_convert_pixel(vs, buf, pixels[i]);
675 vnc_write(vs, buf, vs->client_pf.bytes_per_pixel);
676 }
677 }
678 }
679
680 int vnc_raw_send_framebuffer_update(VncState *vs, int x, int y, int w, int h)
681 {
682 int i;
683 uint8_t *row;
684 VncDisplay *vd = vs->vd;
685
686 row = vnc_server_fb_ptr(vd, x, y);
687 for (i = 0; i < h; i++) {
688 vs->write_pixels(vs, row, w * VNC_SERVER_FB_BYTES);
689 row += vnc_server_fb_stride(vd);
690 }
691 return 1;
692 }
693
694 int vnc_send_framebuffer_update(VncState *vs, int x, int y, int w, int h)
695 {
696 int n = 0;
697
698 switch(vs->vnc_encoding) {
699 case VNC_ENCODING_ZLIB:
700 n = vnc_zlib_send_framebuffer_update(vs, x, y, w, h);
701 break;
702 case VNC_ENCODING_HEXTILE:
703 vnc_framebuffer_update(vs, x, y, w, h, VNC_ENCODING_HEXTILE);
704 n = vnc_hextile_send_framebuffer_update(vs, x, y, w, h);
705 break;
706 case VNC_ENCODING_TIGHT:
707 n = vnc_tight_send_framebuffer_update(vs, x, y, w, h);
708 break;
709 case VNC_ENCODING_TIGHT_PNG:
710 n = vnc_tight_png_send_framebuffer_update(vs, x, y, w, h);
711 break;
712 case VNC_ENCODING_ZRLE:
713 n = vnc_zrle_send_framebuffer_update(vs, x, y, w, h);
714 break;
715 case VNC_ENCODING_ZYWRLE:
716 n = vnc_zywrle_send_framebuffer_update(vs, x, y, w, h);
717 break;
718 default:
719 vnc_framebuffer_update(vs, x, y, w, h, VNC_ENCODING_RAW);
720 n = vnc_raw_send_framebuffer_update(vs, x, y, w, h);
721 break;
722 }
723 return n;
724 }
725
726 static void vnc_copy(VncState *vs, int src_x, int src_y, int dst_x, int dst_y, int w, int h)
727 {
728 /* send bitblit op to the vnc client */
729 vnc_lock_output(vs);
730 vnc_write_u8(vs, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE);
731 vnc_write_u8(vs, 0);
732 vnc_write_u16(vs, 1); /* number of rects */
733 vnc_framebuffer_update(vs, dst_x, dst_y, w, h, VNC_ENCODING_COPYRECT);
734 vnc_write_u16(vs, src_x);
735 vnc_write_u16(vs, src_y);
736 vnc_unlock_output(vs);
737 vnc_flush(vs);
738 }
739
740 static void vnc_dpy_copy(DisplayChangeListener *dcl,
741 int src_x, int src_y,
742 int dst_x, int dst_y, int w, int h)
743 {
744 VncDisplay *vd = container_of(dcl, VncDisplay, dcl);
745 VncState *vs, *vn;
746 uint8_t *src_row;
747 uint8_t *dst_row;
748 int i, x, y, pitch, inc, w_lim, s;
749 int cmp_bytes;
750
751 vnc_refresh_server_surface(vd);
752 QTAILQ_FOREACH_SAFE(vs, &vd->clients, next, vn) {
753 if (vnc_has_feature(vs, VNC_FEATURE_COPYRECT)) {
754 vs->force_update = 1;
755 vnc_update_client_sync(vs, 1);
756 /* vs might be free()ed here */
757 }
758 }
759
760 /* do bitblit op on the local surface too */
761 pitch = vnc_server_fb_stride(vd);
762 src_row = vnc_server_fb_ptr(vd, src_x, src_y);
763 dst_row = vnc_server_fb_ptr(vd, dst_x, dst_y);
764 y = dst_y;
765 inc = 1;
766 if (dst_y > src_y) {
767 /* copy backwards */
768 src_row += pitch * (h-1);
769 dst_row += pitch * (h-1);
770 pitch = -pitch;
771 y = dst_y + h - 1;
772 inc = -1;
773 }
774 w_lim = w - (16 - (dst_x % 16));
775 if (w_lim < 0)
776 w_lim = w;
777 else
778 w_lim = w - (w_lim % 16);
779 for (i = 0; i < h; i++) {
780 for (x = 0; x <= w_lim;
781 x += s, src_row += cmp_bytes, dst_row += cmp_bytes) {
782 if (x == w_lim) {
783 if ((s = w - w_lim) == 0)
784 break;
785 } else if (!x) {
786 s = (16 - (dst_x % 16));
787 s = MIN(s, w_lim);
788 } else {
789 s = 16;
790 }
791 cmp_bytes = s * VNC_SERVER_FB_BYTES;
792 if (memcmp(src_row, dst_row, cmp_bytes) == 0)
793 continue;
794 memmove(dst_row, src_row, cmp_bytes);
795 QTAILQ_FOREACH(vs, &vd->clients, next) {
796 if (!vnc_has_feature(vs, VNC_FEATURE_COPYRECT)) {
797 set_bit(((x + dst_x) / 16), vs->dirty[y]);
798 }
799 }
800 }
801 src_row += pitch - w * VNC_SERVER_FB_BYTES;
802 dst_row += pitch - w * VNC_SERVER_FB_BYTES;
803 y += inc;
804 }
805
806 QTAILQ_FOREACH(vs, &vd->clients, next) {
807 if (vnc_has_feature(vs, VNC_FEATURE_COPYRECT)) {
808 vnc_copy(vs, src_x, src_y, dst_x, dst_y, w, h);
809 }
810 }
811 }
812
813 static void vnc_mouse_set(DisplayChangeListener *dcl,
814 int x, int y, int visible)
815 {
816 /* can we ask the client(s) to move the pointer ??? */
817 }
818
819 static int vnc_cursor_define(VncState *vs)
820 {
821 QEMUCursor *c = vs->vd->cursor;
822 int isize;
823
824 if (vnc_has_feature(vs, VNC_FEATURE_RICH_CURSOR)) {
825 vnc_lock_output(vs);
826 vnc_write_u8(vs, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE);
827 vnc_write_u8(vs, 0); /* padding */
828 vnc_write_u16(vs, 1); /* # of rects */
829 vnc_framebuffer_update(vs, c->hot_x, c->hot_y, c->width, c->height,
830 VNC_ENCODING_RICH_CURSOR);
831 isize = c->width * c->height * vs->client_pf.bytes_per_pixel;
832 vnc_write_pixels_generic(vs, c->data, isize);
833 vnc_write(vs, vs->vd->cursor_mask, vs->vd->cursor_msize);
834 vnc_unlock_output(vs);
835 return 0;
836 }
837 return -1;
838 }
839
840 static void vnc_dpy_cursor_define(DisplayChangeListener *dcl,
841 QEMUCursor *c)
842 {
843 VncDisplay *vd = vnc_display;
844 VncState *vs;
845
846 cursor_put(vd->cursor);
847 g_free(vd->cursor_mask);
848
849 vd->cursor = c;
850 cursor_get(vd->cursor);
851 vd->cursor_msize = cursor_get_mono_bpl(c) * c->height;
852 vd->cursor_mask = g_malloc0(vd->cursor_msize);
853 cursor_get_mono_mask(c, 0, vd->cursor_mask);
854
855 QTAILQ_FOREACH(vs, &vd->clients, next) {
856 vnc_cursor_define(vs);
857 }
858 }
859
860 static int find_and_clear_dirty_height(struct VncState *vs,
861 int y, int last_x, int x, int height)
862 {
863 int h;
864
865 for (h = 1; h < (height - y); h++) {
866 int tmp_x;
867 if (!test_bit(last_x, vs->dirty[y + h])) {
868 break;
869 }
870 for (tmp_x = last_x; tmp_x < x; tmp_x++) {
871 clear_bit(tmp_x, vs->dirty[y + h]);
872 }
873 }
874
875 return h;
876 }
877
878 static int vnc_update_client_sync(VncState *vs, int has_dirty)
879 {
880 int ret = vnc_update_client(vs, has_dirty);
881 vnc_jobs_join(vs);
882 return ret;
883 }
884
885 static int vnc_update_client(VncState *vs, int has_dirty)
886 {
887 if (vs->need_update && vs->csock != -1) {
888 VncDisplay *vd = vs->vd;
889 VncJob *job;
890 int y;
891 int width, height;
892 int n = 0;
893
894
895 if (vs->output.offset && !vs->audio_cap && !vs->force_update)
896 /* kernel send buffers are full -> drop frames to throttle */
897 return 0;
898
899 if (!has_dirty && !vs->audio_cap && !vs->force_update)
900 return 0;
901
902 /*
903 * Send screen updates to the vnc client using the server
904 * surface and server dirty map. guest surface updates
905 * happening in parallel don't disturb us, the next pass will
906 * send them to the client.
907 */
908 job = vnc_job_new(vs);
909
910 width = MIN(pixman_image_get_width(vd->server), vs->client_width);
911 height = MIN(pixman_image_get_height(vd->server), vs->client_height);
912
913 for (y = 0; y < height; y++) {
914 int x;
915 int last_x = -1;
916 for (x = 0; x < width / 16; x++) {
917 if (test_and_clear_bit(x, vs->dirty[y])) {
918 if (last_x == -1) {
919 last_x = x;
920 }
921 } else {
922 if (last_x != -1) {
923 int h = find_and_clear_dirty_height(vs, y, last_x, x,
924 height);
925
926 n += vnc_job_add_rect(job, last_x * 16, y,
927 (x - last_x) * 16, h);
928 }
929 last_x = -1;
930 }
931 }
932 if (last_x != -1) {
933 int h = find_and_clear_dirty_height(vs, y, last_x, x, height);
934 n += vnc_job_add_rect(job, last_x * 16, y,
935 (x - last_x) * 16, h);
936 }
937 }
938
939 vnc_job_push(job);
940 vs->force_update = 0;
941 return n;
942 }
943
944 if (vs->csock == -1)
945 vnc_disconnect_finish(vs);
946
947 return 0;
948 }
949
950 /* audio */
951 static void audio_capture_notify(void *opaque, audcnotification_e cmd)
952 {
953 VncState *vs = opaque;
954
955 switch (cmd) {
956 case AUD_CNOTIFY_DISABLE:
957 vnc_lock_output(vs);
958 vnc_write_u8(vs, VNC_MSG_SERVER_QEMU);
959 vnc_write_u8(vs, VNC_MSG_SERVER_QEMU_AUDIO);
960 vnc_write_u16(vs, VNC_MSG_SERVER_QEMU_AUDIO_END);
961 vnc_unlock_output(vs);
962 vnc_flush(vs);
963 break;
964
965 case AUD_CNOTIFY_ENABLE:
966 vnc_lock_output(vs);
967 vnc_write_u8(vs, VNC_MSG_SERVER_QEMU);
968 vnc_write_u8(vs, VNC_MSG_SERVER_QEMU_AUDIO);
969 vnc_write_u16(vs, VNC_MSG_SERVER_QEMU_AUDIO_BEGIN);
970 vnc_unlock_output(vs);
971 vnc_flush(vs);
972 break;
973 }
974 }
975
976 static void audio_capture_destroy(void *opaque)
977 {
978 }
979
980 static void audio_capture(void *opaque, void *buf, int size)
981 {
982 VncState *vs = opaque;
983
984 vnc_lock_output(vs);
985 vnc_write_u8(vs, VNC_MSG_SERVER_QEMU);
986 vnc_write_u8(vs, VNC_MSG_SERVER_QEMU_AUDIO);
987 vnc_write_u16(vs, VNC_MSG_SERVER_QEMU_AUDIO_DATA);
988 vnc_write_u32(vs, size);
989 vnc_write(vs, buf, size);
990 vnc_unlock_output(vs);
991 vnc_flush(vs);
992 }
993
994 static void audio_add(VncState *vs)
995 {
996 struct audio_capture_ops ops;
997
998 if (vs->audio_cap) {
999 monitor_printf(default_mon, "audio already running\n");
1000 return;
1001 }
1002
1003 ops.notify = audio_capture_notify;
1004 ops.destroy = audio_capture_destroy;
1005 ops.capture = audio_capture;
1006
1007 vs->audio_cap = AUD_add_capture(&vs->as, &ops, vs);
1008 if (!vs->audio_cap) {
1009 monitor_printf(default_mon, "Failed to add audio capture\n");
1010 }
1011 }
1012
1013 static void audio_del(VncState *vs)
1014 {
1015 if (vs->audio_cap) {
1016 AUD_del_capture(vs->audio_cap, vs);
1017 vs->audio_cap = NULL;
1018 }
1019 }
1020
1021 static void vnc_disconnect_start(VncState *vs)
1022 {
1023 if (vs->csock == -1)
1024 return;
1025 vnc_set_share_mode(vs, VNC_SHARE_MODE_DISCONNECTED);
1026 qemu_set_fd_handler2(vs->csock, NULL, NULL, NULL, NULL);
1027 closesocket(vs->csock);
1028 vs->csock = -1;
1029 }
1030
1031 void vnc_disconnect_finish(VncState *vs)
1032 {
1033 int i;
1034
1035 vnc_jobs_join(vs); /* Wait encoding jobs */
1036
1037 vnc_lock_output(vs);
1038 vnc_qmp_event(vs, QEVENT_VNC_DISCONNECTED);
1039
1040 buffer_free(&vs->input);
1041 buffer_free(&vs->output);
1042 #ifdef CONFIG_VNC_WS
1043 buffer_free(&vs->ws_input);
1044 buffer_free(&vs->ws_output);
1045 #endif /* CONFIG_VNC_WS */
1046
1047 qobject_decref(vs->info);
1048
1049 vnc_zlib_clear(vs);
1050 vnc_tight_clear(vs);
1051 vnc_zrle_clear(vs);
1052
1053 #ifdef CONFIG_VNC_TLS
1054 vnc_tls_client_cleanup(vs);
1055 #endif /* CONFIG_VNC_TLS */
1056 #ifdef CONFIG_VNC_SASL
1057 vnc_sasl_client_cleanup(vs);
1058 #endif /* CONFIG_VNC_SASL */
1059 audio_del(vs);
1060 vnc_release_modifiers(vs);
1061
1062 if (vs->initialized) {
1063 QTAILQ_REMOVE(&vs->vd->clients, vs, next);
1064 qemu_remove_mouse_mode_change_notifier(&vs->mouse_mode_notifier);
1065 }
1066
1067 if (QTAILQ_EMPTY(&vs->vd->clients)) {
1068 vs->vd->dcl.idle = 1;
1069 }
1070
1071 vnc_remove_timer(vs->vd);
1072 if (vs->vd->lock_key_sync)
1073 qemu_remove_led_event_handler(vs->led);
1074 vnc_unlock_output(vs);
1075
1076 qemu_mutex_destroy(&vs->output_mutex);
1077 if (vs->bh != NULL) {
1078 qemu_bh_delete(vs->bh);
1079 }
1080 buffer_free(&vs->jobs_buffer);
1081
1082 for (i = 0; i < VNC_STAT_ROWS; ++i) {
1083 g_free(vs->lossy_rect[i]);
1084 }
1085 g_free(vs->lossy_rect);
1086 g_free(vs);
1087 }
1088
1089 int vnc_client_io_error(VncState *vs, int ret, int last_errno)
1090 {
1091 if (ret == 0 || ret == -1) {
1092 if (ret == -1) {
1093 switch (last_errno) {
1094 case EINTR:
1095 case EAGAIN:
1096 #ifdef _WIN32
1097 case WSAEWOULDBLOCK:
1098 #endif
1099 return 0;
1100 default:
1101 break;
1102 }
1103 }
1104
1105 VNC_DEBUG("Closing down client sock: ret %d, errno %d\n",
1106 ret, ret < 0 ? last_errno : 0);
1107 vnc_disconnect_start(vs);
1108
1109 return 0;
1110 }
1111 return ret;
1112 }
1113
1114
1115 void vnc_client_error(VncState *vs)
1116 {
1117 VNC_DEBUG("Closing down client sock: protocol error\n");
1118 vnc_disconnect_start(vs);
1119 }
1120
1121
1122 /*
1123 * Called to write a chunk of data to the client socket. The data may
1124 * be the raw data, or may have already been encoded by SASL.
1125 * The data will be written either straight onto the socket, or
1126 * written via the GNUTLS wrappers, if TLS/SSL encryption is enabled
1127 *
1128 * NB, it is theoretically possible to have 2 layers of encryption,
1129 * both SASL, and this TLS layer. It is highly unlikely in practice
1130 * though, since SASL encryption will typically be a no-op if TLS
1131 * is active
1132 *
1133 * Returns the number of bytes written, which may be less than
1134 * the requested 'datalen' if the socket would block. Returns
1135 * -1 on error, and disconnects the client socket.
1136 */
1137 long vnc_client_write_buf(VncState *vs, const uint8_t *data, size_t datalen)
1138 {
1139 long ret;
1140 #ifdef CONFIG_VNC_TLS
1141 if (vs->tls.session) {
1142 ret = gnutls_write(vs->tls.session, data, datalen);
1143 if (ret < 0) {
1144 if (ret == GNUTLS_E_AGAIN)
1145 errno = EAGAIN;
1146 else
1147 errno = EIO;
1148 ret = -1;
1149 }
1150 } else
1151 #endif /* CONFIG_VNC_TLS */
1152 ret = send(vs->csock, (const void *)data, datalen, 0);
1153 VNC_DEBUG("Wrote wire %p %zd -> %ld\n", data, datalen, ret);
1154 return vnc_client_io_error(vs, ret, socket_error());
1155 }
1156
1157
1158 /*
1159 * Called to write buffered data to the client socket, when not
1160 * using any SASL SSF encryption layers. Will write as much data
1161 * as possible without blocking. If all buffered data is written,
1162 * will switch the FD poll() handler back to read monitoring.
1163 *
1164 * Returns the number of bytes written, which may be less than
1165 * the buffered output data if the socket would block. Returns
1166 * -1 on error, and disconnects the client socket.
1167 */
1168 static long vnc_client_write_plain(VncState *vs)
1169 {
1170 long ret;
1171
1172 #ifdef CONFIG_VNC_SASL
1173 VNC_DEBUG("Write Plain: Pending output %p size %zd offset %zd. Wait SSF %d\n",
1174 vs->output.buffer, vs->output.capacity, vs->output.offset,
1175 vs->sasl.waitWriteSSF);
1176
1177 if (vs->sasl.conn &&
1178 vs->sasl.runSSF &&
1179 vs->sasl.waitWriteSSF) {
1180 ret = vnc_client_write_buf(vs, vs->output.buffer, vs->sasl.waitWriteSSF);
1181 if (ret)
1182 vs->sasl.waitWriteSSF -= ret;
1183 } else
1184 #endif /* CONFIG_VNC_SASL */
1185 ret = vnc_client_write_buf(vs, vs->output.buffer, vs->output.offset);
1186 if (!ret)
1187 return 0;
1188
1189 buffer_advance(&vs->output, ret);
1190
1191 if (vs->output.offset == 0) {
1192 qemu_set_fd_handler2(vs->csock, NULL, vnc_client_read, NULL, vs);
1193 }
1194
1195 return ret;
1196 }
1197
1198
1199 /*
1200 * First function called whenever there is data to be written to
1201 * the client socket. Will delegate actual work according to whether
1202 * SASL SSF layers are enabled (thus requiring encryption calls)
1203 */
1204 static void vnc_client_write_locked(void *opaque)
1205 {
1206 VncState *vs = opaque;
1207
1208 #ifdef CONFIG_VNC_SASL
1209 if (vs->sasl.conn &&
1210 vs->sasl.runSSF &&
1211 !vs->sasl.waitWriteSSF) {
1212 vnc_client_write_sasl(vs);
1213 } else
1214 #endif /* CONFIG_VNC_SASL */
1215 {
1216 #ifdef CONFIG_VNC_WS
1217 if (vs->encode_ws) {
1218 vnc_client_write_ws(vs);
1219 } else
1220 #endif /* CONFIG_VNC_WS */
1221 {
1222 vnc_client_write_plain(vs);
1223 }
1224 }
1225 }
1226
1227 void vnc_client_write(void *opaque)
1228 {
1229 VncState *vs = opaque;
1230
1231 vnc_lock_output(vs);
1232 if (vs->output.offset
1233 #ifdef CONFIG_VNC_WS
1234 || vs->ws_output.offset
1235 #endif
1236 ) {
1237 vnc_client_write_locked(opaque);
1238 } else if (vs->csock != -1) {
1239 qemu_set_fd_handler2(vs->csock, NULL, vnc_client_read, NULL, vs);
1240 }
1241 vnc_unlock_output(vs);
1242 }
1243
1244 void vnc_read_when(VncState *vs, VncReadEvent *func, size_t expecting)
1245 {
1246 vs->read_handler = func;
1247 vs->read_handler_expect = expecting;
1248 }
1249
1250
1251 /*
1252 * Called to read a chunk of data from the client socket. The data may
1253 * be the raw data, or may need to be further decoded by SASL.
1254 * The data will be read either straight from to the socket, or
1255 * read via the GNUTLS wrappers, if TLS/SSL encryption is enabled
1256 *
1257 * NB, it is theoretically possible to have 2 layers of encryption,
1258 * both SASL, and this TLS layer. It is highly unlikely in practice
1259 * though, since SASL encryption will typically be a no-op if TLS
1260 * is active
1261 *
1262 * Returns the number of bytes read, which may be less than
1263 * the requested 'datalen' if the socket would block. Returns
1264 * -1 on error, and disconnects the client socket.
1265 */
1266 long vnc_client_read_buf(VncState *vs, uint8_t *data, size_t datalen)
1267 {
1268 long ret;
1269 #ifdef CONFIG_VNC_TLS
1270 if (vs->tls.session) {
1271 ret = gnutls_read(vs->tls.session, data, datalen);
1272 if (ret < 0) {
1273 if (ret == GNUTLS_E_AGAIN)
1274 errno = EAGAIN;
1275 else
1276 errno = EIO;
1277 ret = -1;
1278 }
1279 } else
1280 #endif /* CONFIG_VNC_TLS */
1281 ret = qemu_recv(vs->csock, data, datalen, 0);
1282 VNC_DEBUG("Read wire %p %zd -> %ld\n", data, datalen, ret);
1283 return vnc_client_io_error(vs, ret, socket_error());
1284 }
1285
1286
1287 /*
1288 * Called to read data from the client socket to the input buffer,
1289 * when not using any SASL SSF encryption layers. Will read as much
1290 * data as possible without blocking.
1291 *
1292 * Returns the number of bytes read. Returns -1 on error, and
1293 * disconnects the client socket.
1294 */
1295 static long vnc_client_read_plain(VncState *vs)
1296 {
1297 int ret;
1298 VNC_DEBUG("Read plain %p size %zd offset %zd\n",
1299 vs->input.buffer, vs->input.capacity, vs->input.offset);
1300 buffer_reserve(&vs->input, 4096);
1301 ret = vnc_client_read_buf(vs, buffer_end(&vs->input), 4096);
1302 if (!ret)
1303 return 0;
1304 vs->input.offset += ret;
1305 return ret;
1306 }
1307
1308 static void vnc_jobs_bh(void *opaque)
1309 {
1310 VncState *vs = opaque;
1311
1312 vnc_jobs_consume_buffer(vs);
1313 }
1314
1315 /*
1316 * First function called whenever there is more data to be read from
1317 * the client socket. Will delegate actual work according to whether
1318 * SASL SSF layers are enabled (thus requiring decryption calls)
1319 */
1320 void vnc_client_read(void *opaque)
1321 {
1322 VncState *vs = opaque;
1323 long ret;
1324
1325 #ifdef CONFIG_VNC_SASL
1326 if (vs->sasl.conn && vs->sasl.runSSF)
1327 ret = vnc_client_read_sasl(vs);
1328 else
1329 #endif /* CONFIG_VNC_SASL */
1330 #ifdef CONFIG_VNC_WS
1331 if (vs->encode_ws) {
1332 ret = vnc_client_read_ws(vs);
1333 if (ret == -1) {
1334 vnc_disconnect_start(vs);
1335 return;
1336 } else if (ret == -2) {
1337 vnc_client_error(vs);
1338 return;
1339 }
1340 } else
1341 #endif /* CONFIG_VNC_WS */
1342 {
1343 ret = vnc_client_read_plain(vs);
1344 }
1345 if (!ret) {
1346 if (vs->csock == -1)
1347 vnc_disconnect_finish(vs);
1348 return;
1349 }
1350
1351 while (vs->read_handler && vs->input.offset >= vs->read_handler_expect) {
1352 size_t len = vs->read_handler_expect;
1353 int ret;
1354
1355 ret = vs->read_handler(vs, vs->input.buffer, len);
1356 if (vs->csock == -1) {
1357 vnc_disconnect_finish(vs);
1358 return;
1359 }
1360
1361 if (!ret) {
1362 buffer_advance(&vs->input, len);
1363 } else {
1364 vs->read_handler_expect = ret;
1365 }
1366 }
1367 }
1368
1369 void vnc_write(VncState *vs, const void *data, size_t len)
1370 {
1371 buffer_reserve(&vs->output, len);
1372
1373 if (vs->csock != -1 && buffer_empty(&vs->output)) {
1374 qemu_set_fd_handler2(vs->csock, NULL, vnc_client_read, vnc_client_write, vs);
1375 }
1376
1377 buffer_append(&vs->output, data, len);
1378 }
1379
1380 void vnc_write_s32(VncState *vs, int32_t value)
1381 {
1382 vnc_write_u32(vs, *(uint32_t *)&value);
1383 }
1384
1385 void vnc_write_u32(VncState *vs, uint32_t value)
1386 {
1387 uint8_t buf[4];
1388
1389 buf[0] = (value >> 24) & 0xFF;
1390 buf[1] = (value >> 16) & 0xFF;
1391 buf[2] = (value >> 8) & 0xFF;
1392 buf[3] = value & 0xFF;
1393
1394 vnc_write(vs, buf, 4);
1395 }
1396
1397 void vnc_write_u16(VncState *vs, uint16_t value)
1398 {
1399 uint8_t buf[2];
1400
1401 buf[0] = (value >> 8) & 0xFF;
1402 buf[1] = value & 0xFF;
1403
1404 vnc_write(vs, buf, 2);
1405 }
1406
1407 void vnc_write_u8(VncState *vs, uint8_t value)
1408 {
1409 vnc_write(vs, (char *)&value, 1);
1410 }
1411
1412 void vnc_flush(VncState *vs)
1413 {
1414 vnc_lock_output(vs);
1415 if (vs->csock != -1 && (vs->output.offset
1416 #ifdef CONFIG_VNC_WS
1417 || vs->ws_output.offset
1418 #endif
1419 )) {
1420 vnc_client_write_locked(vs);
1421 }
1422 vnc_unlock_output(vs);
1423 }
1424
1425 static uint8_t read_u8(uint8_t *data, size_t offset)
1426 {
1427 return data[offset];
1428 }
1429
1430 static uint16_t read_u16(uint8_t *data, size_t offset)
1431 {
1432 return ((data[offset] & 0xFF) << 8) | (data[offset + 1] & 0xFF);
1433 }
1434
1435 static int32_t read_s32(uint8_t *data, size_t offset)
1436 {
1437 return (int32_t)((data[offset] << 24) | (data[offset + 1] << 16) |
1438 (data[offset + 2] << 8) | data[offset + 3]);
1439 }
1440
1441 uint32_t read_u32(uint8_t *data, size_t offset)
1442 {
1443 return ((data[offset] << 24) | (data[offset + 1] << 16) |
1444 (data[offset + 2] << 8) | data[offset + 3]);
1445 }
1446
1447 static void client_cut_text(VncState *vs, size_t len, uint8_t *text)
1448 {
1449 }
1450
1451 static void check_pointer_type_change(Notifier *notifier, void *data)
1452 {
1453 VncState *vs = container_of(notifier, VncState, mouse_mode_notifier);
1454 int absolute = kbd_mouse_is_absolute();
1455
1456 if (vnc_has_feature(vs, VNC_FEATURE_POINTER_TYPE_CHANGE) && vs->absolute != absolute) {
1457 vnc_lock_output(vs);
1458 vnc_write_u8(vs, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE);
1459 vnc_write_u8(vs, 0);
1460 vnc_write_u16(vs, 1);
1461 vnc_framebuffer_update(vs, absolute, 0,
1462 surface_width(vs->vd->ds),
1463 surface_height(vs->vd->ds),
1464 VNC_ENCODING_POINTER_TYPE_CHANGE);
1465 vnc_unlock_output(vs);
1466 vnc_flush(vs);
1467 }
1468 vs->absolute = absolute;
1469 }
1470
1471 static void pointer_event(VncState *vs, int button_mask, int x, int y)
1472 {
1473 int buttons = 0;
1474 int dz = 0;
1475 int width = surface_width(vs->vd->ds);
1476 int height = surface_height(vs->vd->ds);
1477
1478 if (button_mask & 0x01)
1479 buttons |= MOUSE_EVENT_LBUTTON;
1480 if (button_mask & 0x02)
1481 buttons |= MOUSE_EVENT_MBUTTON;
1482 if (button_mask & 0x04)
1483 buttons |= MOUSE_EVENT_RBUTTON;
1484 if (button_mask & 0x08)
1485 dz = -1;
1486 if (button_mask & 0x10)
1487 dz = 1;
1488
1489 if (vs->absolute) {
1490 kbd_mouse_event(width > 1 ? x * 0x7FFF / (width - 1) : 0x4000,
1491 height > 1 ? y * 0x7FFF / (height - 1) : 0x4000,
1492 dz, buttons);
1493 } else if (vnc_has_feature(vs, VNC_FEATURE_POINTER_TYPE_CHANGE)) {
1494 x -= 0x7FFF;
1495 y -= 0x7FFF;
1496
1497 kbd_mouse_event(x, y, dz, buttons);
1498 } else {
1499 if (vs->last_x != -1)
1500 kbd_mouse_event(x - vs->last_x,
1501 y - vs->last_y,
1502 dz, buttons);
1503 vs->last_x = x;
1504 vs->last_y = y;
1505 }
1506 }
1507
1508 static void reset_keys(VncState *vs)
1509 {
1510 int i;
1511 for(i = 0; i < 256; i++) {
1512 if (vs->modifiers_state[i]) {
1513 if (i & SCANCODE_GREY)
1514 kbd_put_keycode(SCANCODE_EMUL0);
1515 kbd_put_keycode(i | SCANCODE_UP);
1516 vs->modifiers_state[i] = 0;
1517 }
1518 }
1519 }
1520
1521 static void press_key(VncState *vs, int keysym)
1522 {
1523 int keycode = keysym2scancode(vs->vd->kbd_layout, keysym) & SCANCODE_KEYMASK;
1524 if (keycode & SCANCODE_GREY)
1525 kbd_put_keycode(SCANCODE_EMUL0);
1526 kbd_put_keycode(keycode & SCANCODE_KEYCODEMASK);
1527 if (keycode & SCANCODE_GREY)
1528 kbd_put_keycode(SCANCODE_EMUL0);
1529 kbd_put_keycode(keycode | SCANCODE_UP);
1530 }
1531
1532 static void kbd_leds(void *opaque, int ledstate)
1533 {
1534 VncState *vs = opaque;
1535 int caps, num;
1536
1537 caps = ledstate & QEMU_CAPS_LOCK_LED ? 1 : 0;
1538 num = ledstate & QEMU_NUM_LOCK_LED ? 1 : 0;
1539
1540 if (vs->modifiers_state[0x3a] != caps) {
1541 vs->modifiers_state[0x3a] = caps;
1542 }
1543 if (vs->modifiers_state[0x45] != num) {
1544 vs->modifiers_state[0x45] = num;
1545 }
1546 }
1547
1548 static void do_key_event(VncState *vs, int down, int keycode, int sym)
1549 {
1550 /* QEMU console switch */
1551 switch(keycode) {
1552 case 0x2a: /* Left Shift */
1553 case 0x36: /* Right Shift */
1554 case 0x1d: /* Left CTRL */
1555 case 0x9d: /* Right CTRL */
1556 case 0x38: /* Left ALT */
1557 case 0xb8: /* Right ALT */
1558 if (down)
1559 vs->modifiers_state[keycode] = 1;
1560 else
1561 vs->modifiers_state[keycode] = 0;
1562 break;
1563 case 0x02 ... 0x0a: /* '1' to '9' keys */
1564 if (down && vs->modifiers_state[0x1d] && vs->modifiers_state[0x38]) {
1565 /* Reset the modifiers sent to the current console */
1566 reset_keys(vs);
1567 console_select(keycode - 0x02);
1568 return;
1569 }
1570 break;
1571 case 0x3a: /* CapsLock */
1572 case 0x45: /* NumLock */
1573 if (down)
1574 vs->modifiers_state[keycode] ^= 1;
1575 break;
1576 }
1577
1578 if (down && vs->vd->lock_key_sync &&
1579 keycode_is_keypad(vs->vd->kbd_layout, keycode)) {
1580 /* If the numlock state needs to change then simulate an additional
1581 keypress before sending this one. This will happen if the user
1582 toggles numlock away from the VNC window.
1583 */
1584 if (keysym_is_numlock(vs->vd->kbd_layout, sym & 0xFFFF)) {
1585 if (!vs->modifiers_state[0x45]) {
1586 vs->modifiers_state[0x45] = 1;
1587 press_key(vs, 0xff7f);
1588 }
1589 } else {
1590 if (vs->modifiers_state[0x45]) {
1591 vs->modifiers_state[0x45] = 0;
1592 press_key(vs, 0xff7f);
1593 }
1594 }
1595 }
1596
1597 if (down && vs->vd->lock_key_sync &&
1598 ((sym >= 'A' && sym <= 'Z') || (sym >= 'a' && sym <= 'z'))) {
1599 /* If the capslock state needs to change then simulate an additional
1600 keypress before sending this one. This will happen if the user
1601 toggles capslock away from the VNC window.
1602 */
1603 int uppercase = !!(sym >= 'A' && sym <= 'Z');
1604 int shift = !!(vs->modifiers_state[0x2a] | vs->modifiers_state[0x36]);
1605 int capslock = !!(vs->modifiers_state[0x3a]);
1606 if (capslock) {
1607 if (uppercase == shift) {
1608 vs->modifiers_state[0x3a] = 0;
1609 press_key(vs, 0xffe5);
1610 }
1611 } else {
1612 if (uppercase != shift) {
1613 vs->modifiers_state[0x3a] = 1;
1614 press_key(vs, 0xffe5);
1615 }
1616 }
1617 }
1618
1619 if (is_graphic_console()) {
1620 if (keycode & SCANCODE_GREY)
1621 kbd_put_keycode(SCANCODE_EMUL0);
1622 if (down)
1623 kbd_put_keycode(keycode & SCANCODE_KEYCODEMASK);
1624 else
1625 kbd_put_keycode(keycode | SCANCODE_UP);
1626 } else {
1627 bool numlock = vs->modifiers_state[0x45];
1628 bool control = (vs->modifiers_state[0x1d] ||
1629 vs->modifiers_state[0x9d]);
1630 /* QEMU console emulation */
1631 if (down) {
1632 switch (keycode) {
1633 case 0x2a: /* Left Shift */
1634 case 0x36: /* Right Shift */
1635 case 0x1d: /* Left CTRL */
1636 case 0x9d: /* Right CTRL */
1637 case 0x38: /* Left ALT */
1638 case 0xb8: /* Right ALT */
1639 break;
1640 case 0xc8:
1641 kbd_put_keysym(QEMU_KEY_UP);
1642 break;
1643 case 0xd0:
1644 kbd_put_keysym(QEMU_KEY_DOWN);
1645 break;
1646 case 0xcb:
1647 kbd_put_keysym(QEMU_KEY_LEFT);
1648 break;
1649 case 0xcd:
1650 kbd_put_keysym(QEMU_KEY_RIGHT);
1651 break;
1652 case 0xd3:
1653 kbd_put_keysym(QEMU_KEY_DELETE);
1654 break;
1655 case 0xc7:
1656 kbd_put_keysym(QEMU_KEY_HOME);
1657 break;
1658 case 0xcf:
1659 kbd_put_keysym(QEMU_KEY_END);
1660 break;
1661 case 0xc9:
1662 kbd_put_keysym(QEMU_KEY_PAGEUP);
1663 break;
1664 case 0xd1:
1665 kbd_put_keysym(QEMU_KEY_PAGEDOWN);
1666 break;
1667
1668 case 0x47:
1669 kbd_put_keysym(numlock ? '7' : QEMU_KEY_HOME);
1670 break;
1671 case 0x48:
1672 kbd_put_keysym(numlock ? '8' : QEMU_KEY_UP);
1673 break;
1674 case 0x49:
1675 kbd_put_keysym(numlock ? '9' : QEMU_KEY_PAGEUP);
1676 break;
1677 case 0x4b:
1678 kbd_put_keysym(numlock ? '4' : QEMU_KEY_LEFT);
1679 break;
1680 case 0x4c:
1681 kbd_put_keysym('5');
1682 break;
1683 case 0x4d:
1684 kbd_put_keysym(numlock ? '6' : QEMU_KEY_RIGHT);
1685 break;
1686 case 0x4f:
1687 kbd_put_keysym(numlock ? '1' : QEMU_KEY_END);
1688 break;
1689 case 0x50:
1690 kbd_put_keysym(numlock ? '2' : QEMU_KEY_DOWN);
1691 break;
1692 case 0x51:
1693 kbd_put_keysym(numlock ? '3' : QEMU_KEY_PAGEDOWN);
1694 break;
1695 case 0x52:
1696 kbd_put_keysym('0');
1697 break;
1698 case 0x53:
1699 kbd_put_keysym(numlock ? '.' : QEMU_KEY_DELETE);
1700 break;
1701
1702 case 0xb5:
1703 kbd_put_keysym('/');
1704 break;
1705 case 0x37:
1706 kbd_put_keysym('*');
1707 break;
1708 case 0x4a:
1709 kbd_put_keysym('-');
1710 break;
1711 case 0x4e:
1712 kbd_put_keysym('+');
1713 break;
1714 case 0x9c:
1715 kbd_put_keysym('\n');
1716 break;
1717
1718 default:
1719 if (control) {
1720 kbd_put_keysym(sym & 0x1f);
1721 } else {
1722 kbd_put_keysym(sym);
1723 }
1724 break;
1725 }
1726 }
1727 }
1728 }
1729
1730 static void vnc_release_modifiers(VncState *vs)
1731 {
1732 static const int keycodes[] = {
1733 /* shift, control, alt keys, both left & right */
1734 0x2a, 0x36, 0x1d, 0x9d, 0x38, 0xb8,
1735 };
1736 int i, keycode;
1737
1738 if (!is_graphic_console()) {
1739 return;
1740 }
1741 for (i = 0; i < ARRAY_SIZE(keycodes); i++) {
1742 keycode = keycodes[i];
1743 if (!vs->modifiers_state[keycode]) {
1744 continue;
1745 }
1746 if (keycode & SCANCODE_GREY) {
1747 kbd_put_keycode(SCANCODE_EMUL0);
1748 }
1749 kbd_put_keycode(keycode | SCANCODE_UP);
1750 }
1751 }
1752
1753 static void key_event(VncState *vs, int down, uint32_t sym)
1754 {
1755 int keycode;
1756 int lsym = sym;
1757
1758 if (lsym >= 'A' && lsym <= 'Z' && is_graphic_console()) {
1759 lsym = lsym - 'A' + 'a';
1760 }
1761
1762 keycode = keysym2scancode(vs->vd->kbd_layout, lsym & 0xFFFF) & SCANCODE_KEYMASK;
1763 do_key_event(vs, down, keycode, sym);
1764 }
1765
1766 static void ext_key_event(VncState *vs, int down,
1767 uint32_t sym, uint16_t keycode)
1768 {
1769 /* if the user specifies a keyboard layout, always use it */
1770 if (keyboard_layout)
1771 key_event(vs, down, sym);
1772 else
1773 do_key_event(vs, down, keycode, sym);
1774 }
1775
1776 static void framebuffer_update_request(VncState *vs, int incremental,
1777 int x_position, int y_position,
1778 int w, int h)
1779 {
1780 int i;
1781 const size_t width = surface_width(vs->vd->ds) / 16;
1782 const size_t height = surface_height(vs->vd->ds);
1783
1784 if (y_position > height) {
1785 y_position = height;
1786 }
1787 if (y_position + h >= height) {
1788 h = height - y_position;
1789 }
1790
1791 vs->need_update = 1;
1792 if (!incremental) {
1793 vs->force_update = 1;
1794 for (i = 0; i < h; i++) {
1795 bitmap_set(vs->dirty[y_position + i], 0, width);
1796 bitmap_clear(vs->dirty[y_position + i], width,
1797 VNC_DIRTY_BITS - width);
1798 }
1799 }
1800 }
1801
1802 static void send_ext_key_event_ack(VncState *vs)
1803 {
1804 vnc_lock_output(vs);
1805 vnc_write_u8(vs, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE);
1806 vnc_write_u8(vs, 0);
1807 vnc_write_u16(vs, 1);
1808 vnc_framebuffer_update(vs, 0, 0,
1809 surface_width(vs->vd->ds),
1810 surface_height(vs->vd->ds),
1811 VNC_ENCODING_EXT_KEY_EVENT);
1812 vnc_unlock_output(vs);
1813 vnc_flush(vs);
1814 }
1815
1816 static void send_ext_audio_ack(VncState *vs)
1817 {
1818 vnc_lock_output(vs);
1819 vnc_write_u8(vs, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE);
1820 vnc_write_u8(vs, 0);
1821 vnc_write_u16(vs, 1);
1822 vnc_framebuffer_update(vs, 0, 0,
1823 surface_width(vs->vd->ds),
1824 surface_height(vs->vd->ds),
1825 VNC_ENCODING_AUDIO);
1826 vnc_unlock_output(vs);
1827 vnc_flush(vs);
1828 }
1829
1830 static void set_encodings(VncState *vs, int32_t *encodings, size_t n_encodings)
1831 {
1832 int i;
1833 unsigned int enc = 0;
1834
1835 vs->features = 0;
1836 vs->vnc_encoding = 0;
1837 vs->tight.compression = 9;
1838 vs->tight.quality = -1; /* Lossless by default */
1839 vs->absolute = -1;
1840
1841 /*
1842 * Start from the end because the encodings are sent in order of preference.
1843 * This way the preferred encoding (first encoding defined in the array)
1844 * will be set at the end of the loop.
1845 */
1846 for (i = n_encodings - 1; i >= 0; i--) {
1847 enc = encodings[i];
1848 switch (enc) {
1849 case VNC_ENCODING_RAW:
1850 vs->vnc_encoding = enc;
1851 break;
1852 case VNC_ENCODING_COPYRECT:
1853 vs->features |= VNC_FEATURE_COPYRECT_MASK;
1854 break;
1855 case VNC_ENCODING_HEXTILE:
1856 vs->features |= VNC_FEATURE_HEXTILE_MASK;
1857 vs->vnc_encoding = enc;
1858 break;
1859 case VNC_ENCODING_TIGHT:
1860 vs->features |= VNC_FEATURE_TIGHT_MASK;
1861 vs->vnc_encoding = enc;
1862 break;
1863 #ifdef CONFIG_VNC_PNG
1864 case VNC_ENCODING_TIGHT_PNG:
1865 vs->features |= VNC_FEATURE_TIGHT_PNG_MASK;
1866 vs->vnc_encoding = enc;
1867 break;
1868 #endif
1869 case VNC_ENCODING_ZLIB:
1870 vs->features |= VNC_FEATURE_ZLIB_MASK;
1871 vs->vnc_encoding = enc;
1872 break;
1873 case VNC_ENCODING_ZRLE:
1874 vs->features |= VNC_FEATURE_ZRLE_MASK;
1875 vs->vnc_encoding = enc;
1876 break;
1877 case VNC_ENCODING_ZYWRLE:
1878 vs->features |= VNC_FEATURE_ZYWRLE_MASK;
1879 vs->vnc_encoding = enc;
1880 break;
1881 case VNC_ENCODING_DESKTOPRESIZE:
1882 vs->features |= VNC_FEATURE_RESIZE_MASK;
1883 break;
1884 case VNC_ENCODING_POINTER_TYPE_CHANGE:
1885 vs->features |= VNC_FEATURE_POINTER_TYPE_CHANGE_MASK;
1886 break;
1887 case VNC_ENCODING_RICH_CURSOR:
1888 vs->features |= VNC_FEATURE_RICH_CURSOR_MASK;
1889 break;
1890 case VNC_ENCODING_EXT_KEY_EVENT:
1891 send_ext_key_event_ack(vs);
1892 break;
1893 case VNC_ENCODING_AUDIO:
1894 send_ext_audio_ack(vs);
1895 break;
1896 case VNC_ENCODING_WMVi:
1897 vs->features |= VNC_FEATURE_WMVI_MASK;
1898 break;
1899 case VNC_ENCODING_COMPRESSLEVEL0 ... VNC_ENCODING_COMPRESSLEVEL0 + 9:
1900 vs->tight.compression = (enc & 0x0F);
1901 break;
1902 case VNC_ENCODING_QUALITYLEVEL0 ... VNC_ENCODING_QUALITYLEVEL0 + 9:
1903 if (vs->vd->lossy) {
1904 vs->tight.quality = (enc & 0x0F);
1905 }
1906 break;
1907 default:
1908 VNC_DEBUG("Unknown encoding: %d (0x%.8x): %d\n", i, enc, enc);
1909 break;
1910 }
1911 }
1912 vnc_desktop_resize(vs);
1913 check_pointer_type_change(&vs->mouse_mode_notifier, NULL);
1914 }
1915
1916 static void set_pixel_conversion(VncState *vs)
1917 {
1918 pixman_format_code_t fmt = qemu_pixman_get_format(&vs->client_pf);
1919
1920 if (fmt == VNC_SERVER_FB_FORMAT) {
1921 vs->write_pixels = vnc_write_pixels_copy;
1922 vnc_hextile_set_pixel_conversion(vs, 0);
1923 } else {
1924 vs->write_pixels = vnc_write_pixels_generic;
1925 vnc_hextile_set_pixel_conversion(vs, 1);
1926 }
1927 }
1928
1929 static void set_pixel_format(VncState *vs,
1930 int bits_per_pixel, int depth,
1931 int big_endian_flag, int true_color_flag,
1932 int red_max, int green_max, int blue_max,
1933 int red_shift, int green_shift, int blue_shift)
1934 {
1935 if (!true_color_flag) {
1936 vnc_client_error(vs);
1937 return;
1938 }
1939
1940 vs->client_pf.rmax = red_max;
1941 vs->client_pf.rbits = hweight_long(red_max);
1942 vs->client_pf.rshift = red_shift;
1943 vs->client_pf.rmask = red_max << red_shift;
1944 vs->client_pf.gmax = green_max;
1945 vs->client_pf.gbits = hweight_long(green_max);
1946 vs->client_pf.gshift = green_shift;
1947 vs->client_pf.gmask = green_max << green_shift;
1948 vs->client_pf.bmax = blue_max;
1949 vs->client_pf.bbits = hweight_long(blue_max);
1950 vs->client_pf.bshift = blue_shift;
1951 vs->client_pf.bmask = blue_max << blue_shift;
1952 vs->client_pf.bits_per_pixel = bits_per_pixel;
1953 vs->client_pf.bytes_per_pixel = bits_per_pixel / 8;
1954 vs->client_pf.depth = bits_per_pixel == 32 ? 24 : bits_per_pixel;
1955 vs->client_be = big_endian_flag;
1956
1957 set_pixel_conversion(vs);
1958
1959 vga_hw_invalidate();
1960 vga_hw_update();
1961 }
1962
1963 static void pixel_format_message (VncState *vs) {
1964 char pad[3] = { 0, 0, 0 };
1965
1966 vs->client_pf = qemu_default_pixelformat(32);
1967
1968 vnc_write_u8(vs, vs->client_pf.bits_per_pixel); /* bits-per-pixel */
1969 vnc_write_u8(vs, vs->client_pf.depth); /* depth */
1970
1971 #ifdef HOST_WORDS_BIGENDIAN
1972 vnc_write_u8(vs, 1); /* big-endian-flag */
1973 #else
1974 vnc_write_u8(vs, 0); /* big-endian-flag */
1975 #endif
1976 vnc_write_u8(vs, 1); /* true-color-flag */
1977 vnc_write_u16(vs, vs->client_pf.rmax); /* red-max */
1978 vnc_write_u16(vs, vs->client_pf.gmax); /* green-max */
1979 vnc_write_u16(vs, vs->client_pf.bmax); /* blue-max */
1980 vnc_write_u8(vs, vs->client_pf.rshift); /* red-shift */
1981 vnc_write_u8(vs, vs->client_pf.gshift); /* green-shift */
1982 vnc_write_u8(vs, vs->client_pf.bshift); /* blue-shift */
1983 vnc_write(vs, pad, 3); /* padding */
1984
1985 vnc_hextile_set_pixel_conversion(vs, 0);
1986 vs->write_pixels = vnc_write_pixels_copy;
1987 }
1988
1989 static void vnc_colordepth(VncState *vs)
1990 {
1991 if (vnc_has_feature(vs, VNC_FEATURE_WMVI)) {
1992 /* Sending a WMVi message to notify the client*/
1993 vnc_lock_output(vs);
1994 vnc_write_u8(vs, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE);
1995 vnc_write_u8(vs, 0);
1996 vnc_write_u16(vs, 1); /* number of rects */
1997 vnc_framebuffer_update(vs, 0, 0,
1998 surface_width(vs->vd->ds),
1999 surface_height(vs->vd->ds),
2000 VNC_ENCODING_WMVi);
2001 pixel_format_message(vs);
2002 vnc_unlock_output(vs);
2003 vnc_flush(vs);
2004 } else {
2005 set_pixel_conversion(vs);
2006 }
2007 }
2008
2009 static int protocol_client_msg(VncState *vs, uint8_t *data, size_t len)
2010 {
2011 int i;
2012 uint16_t limit;
2013 VncDisplay *vd = vs->vd;
2014
2015 if (data[0] > 3) {
2016 vd->timer_interval = VNC_REFRESH_INTERVAL_BASE;
2017 if (!qemu_timer_expired(vd->timer, qemu_get_clock_ms(rt_clock) + vd->timer_interval))
2018 qemu_mod_timer(vd->timer, qemu_get_clock_ms(rt_clock) + vd->timer_interval);
2019 }
2020
2021 switch (data[0]) {
2022 case VNC_MSG_CLIENT_SET_PIXEL_FORMAT:
2023 if (len == 1)
2024 return 20;
2025
2026 set_pixel_format(vs, read_u8(data, 4), read_u8(data, 5),
2027 read_u8(data, 6), read_u8(data, 7),
2028 read_u16(data, 8), read_u16(data, 10),
2029 read_u16(data, 12), read_u8(data, 14),
2030 read_u8(data, 15), read_u8(data, 16));
2031 break;
2032 case VNC_MSG_CLIENT_SET_ENCODINGS:
2033 if (len == 1)
2034 return 4;
2035
2036 if (len == 4) {
2037 limit = read_u16(data, 2);
2038 if (limit > 0)
2039 return 4 + (limit * 4);
2040 } else
2041 limit = read_u16(data, 2);
2042
2043 for (i = 0; i < limit; i++) {
2044 int32_t val = read_s32(data, 4 + (i * 4));
2045 memcpy(data + 4 + (i * 4), &val, sizeof(val));
2046 }
2047
2048 set_encodings(vs, (int32_t *)(data + 4), limit);
2049 break;
2050 case VNC_MSG_CLIENT_FRAMEBUFFER_UPDATE_REQUEST:
2051 if (len == 1)
2052 return 10;
2053
2054 framebuffer_update_request(vs,
2055 read_u8(data, 1), read_u16(data, 2), read_u16(data, 4),
2056 read_u16(data, 6), read_u16(data, 8));
2057 break;
2058 case VNC_MSG_CLIENT_KEY_EVENT:
2059 if (len == 1)
2060 return 8;
2061
2062 key_event(vs, read_u8(data, 1), read_u32(data, 4));
2063 break;
2064 case VNC_MSG_CLIENT_POINTER_EVENT:
2065 if (len == 1)
2066 return 6;
2067
2068 pointer_event(vs, read_u8(data, 1), read_u16(data, 2), read_u16(data, 4));
2069 break;
2070 case VNC_MSG_CLIENT_CUT_TEXT:
2071 if (len == 1)
2072 return 8;
2073
2074 if (len == 8) {
2075 uint32_t dlen = read_u32(data, 4);
2076 if (dlen > 0)
2077 return 8 + dlen;
2078 }
2079
2080 client_cut_text(vs, read_u32(data, 4), data + 8);
2081 break;
2082 case VNC_MSG_CLIENT_QEMU:
2083 if (len == 1)
2084 return 2;
2085
2086 switch (read_u8(data, 1)) {
2087 case VNC_MSG_CLIENT_QEMU_EXT_KEY_EVENT:
2088 if (len == 2)
2089 return 12;
2090
2091 ext_key_event(vs, read_u16(data, 2),
2092 read_u32(data, 4), read_u32(data, 8));
2093 break;
2094 case VNC_MSG_CLIENT_QEMU_AUDIO:
2095 if (len == 2)
2096 return 4;
2097
2098 switch (read_u16 (data, 2)) {
2099 case VNC_MSG_CLIENT_QEMU_AUDIO_ENABLE:
2100 audio_add(vs);
2101 break;
2102 case VNC_MSG_CLIENT_QEMU_AUDIO_DISABLE:
2103 audio_del(vs);
2104 break;
2105 case VNC_MSG_CLIENT_QEMU_AUDIO_SET_FORMAT:
2106 if (len == 4)
2107 return 10;
2108 switch (read_u8(data, 4)) {
2109 case 0: vs->as.fmt = AUD_FMT_U8; break;
2110 case 1: vs->as.fmt = AUD_FMT_S8; break;
2111 case 2: vs->as.fmt = AUD_FMT_U16; break;
2112 case 3: vs->as.fmt = AUD_FMT_S16; break;
2113 case 4: vs->as.fmt = AUD_FMT_U32; break;
2114 case 5: vs->as.fmt = AUD_FMT_S32; break;
2115 default:
2116 printf("Invalid audio format %d\n", read_u8(data, 4));
2117 vnc_client_error(vs);
2118 break;
2119 }
2120 vs->as.nchannels = read_u8(data, 5);
2121 if (vs->as.nchannels != 1 && vs->as.nchannels != 2) {
2122 printf("Invalid audio channel coount %d\n",
2123 read_u8(data, 5));
2124 vnc_client_error(vs);
2125 break;
2126 }
2127 vs->as.freq = read_u32(data, 6);
2128 break;
2129 default:
2130 printf ("Invalid audio message %d\n", read_u8(data, 4));
2131 vnc_client_error(vs);
2132 break;
2133 }
2134 break;
2135
2136 default:
2137 printf("Msg: %d\n", read_u16(data, 0));
2138 vnc_client_error(vs);
2139 break;
2140 }
2141 break;
2142 default:
2143 printf("Msg: %d\n", data[0]);
2144 vnc_client_error(vs);
2145 break;
2146 }
2147
2148 vnc_read_when(vs, protocol_client_msg, 1);
2149 return 0;
2150 }
2151
2152 static int protocol_client_init(VncState *vs, uint8_t *data, size_t len)
2153 {
2154 char buf[1024];
2155 VncShareMode mode;
2156 int size;
2157
2158 mode = data[0] ? VNC_SHARE_MODE_SHARED : VNC_SHARE_MODE_EXCLUSIVE;
2159 switch (vs->vd->share_policy) {
2160 case VNC_SHARE_POLICY_IGNORE:
2161 /*
2162 * Ignore the shared flag. Nothing to do here.
2163 *
2164 * Doesn't conform to the rfb spec but is traditional qemu
2165 * behavior, thus left here as option for compatibility
2166 * reasons.
2167 */
2168 break;
2169 case VNC_SHARE_POLICY_ALLOW_EXCLUSIVE:
2170 /*
2171 * Policy: Allow clients ask for exclusive access.
2172 *
2173 * Implementation: When a client asks for exclusive access,
2174 * disconnect all others. Shared connects are allowed as long
2175 * as no exclusive connection exists.
2176 *
2177 * This is how the rfb spec suggests to handle the shared flag.
2178 */
2179 if (mode == VNC_SHARE_MODE_EXCLUSIVE) {
2180 VncState *client;
2181 QTAILQ_FOREACH(client, &vs->vd->clients, next) {
2182 if (vs == client) {
2183 continue;
2184 }
2185 if (client->share_mode != VNC_SHARE_MODE_EXCLUSIVE &&
2186 client->share_mode != VNC_SHARE_MODE_SHARED) {
2187 continue;
2188 }
2189 vnc_disconnect_start(client);
2190 }
2191 }
2192 if (mode == VNC_SHARE_MODE_SHARED) {
2193 if (vs->vd->num_exclusive > 0) {
2194 vnc_disconnect_start(vs);
2195 return 0;
2196 }
2197 }
2198 break;
2199 case VNC_SHARE_POLICY_FORCE_SHARED:
2200 /*
2201 * Policy: Shared connects only.
2202 * Implementation: Disallow clients asking for exclusive access.
2203 *
2204 * Useful for shared desktop sessions where you don't want
2205 * someone forgetting to say -shared when running the vnc
2206 * client disconnect everybody else.
2207 */
2208 if (mode == VNC_SHARE_MODE_EXCLUSIVE) {
2209 vnc_disconnect_start(vs);
2210 return 0;
2211 }
2212 break;
2213 }
2214 vnc_set_share_mode(vs, mode);
2215
2216 vs->client_width = surface_width(vs->vd->ds);
2217 vs->client_height = surface_height(vs->vd->ds);
2218 vnc_write_u16(vs, vs->client_width);
2219 vnc_write_u16(vs, vs->client_height);
2220
2221 pixel_format_message(vs);
2222
2223 if (qemu_name)
2224 size = snprintf(buf, sizeof(buf), "QEMU (%s)", qemu_name);
2225 else
2226 size = snprintf(buf, sizeof(buf), "QEMU");
2227
2228 vnc_write_u32(vs, size);
2229 vnc_write(vs, buf, size);
2230 vnc_flush(vs);
2231
2232 vnc_client_cache_auth(vs);
2233 vnc_qmp_event(vs, QEVENT_VNC_INITIALIZED);
2234
2235 vnc_read_when(vs, protocol_client_msg, 1);
2236
2237 return 0;
2238 }
2239
2240 void start_client_init(VncState *vs)
2241 {
2242 vnc_read_when(vs, protocol_client_init, 1);
2243 }
2244
2245 static void make_challenge(VncState *vs)
2246 {
2247 int i;
2248
2249 srand(time(NULL)+getpid()+getpid()*987654+rand());
2250
2251 for (i = 0 ; i < sizeof(vs->challenge) ; i++)
2252 vs->challenge[i] = (int) (256.0*rand()/(RAND_MAX+1.0));
2253 }
2254
2255 static int protocol_client_auth_vnc(VncState *vs, uint8_t *data, size_t len)
2256 {
2257 unsigned char response[VNC_AUTH_CHALLENGE_SIZE];
2258 int i, j, pwlen;
2259 unsigned char key[8];
2260 time_t now = time(NULL);
2261
2262 if (!vs->vd->password) {
2263 VNC_DEBUG("No password configured on server");
2264 goto reject;
2265 }
2266 if (vs->vd->expires < now) {
2267 VNC_DEBUG("Password is expired");
2268 goto reject;
2269 }
2270
2271 memcpy(response, vs->challenge, VNC_AUTH_CHALLENGE_SIZE);
2272
2273 /* Calculate the expected challenge response */
2274 pwlen = strlen(vs->vd->password);
2275 for (i=0; i<sizeof(key); i++)
2276 key[i] = i<pwlen ? vs->vd->password[i] : 0;
2277 deskey(key, EN0);
2278 for (j = 0; j < VNC_AUTH_CHALLENGE_SIZE; j += 8)
2279 des(response+j, response+j);
2280
2281 /* Compare expected vs actual challenge response */
2282 if (memcmp(response, data, VNC_AUTH_CHALLENGE_SIZE) != 0) {
2283 VNC_DEBUG("Client challenge response did not match\n");
2284 goto reject;
2285 } else {
2286 VNC_DEBUG("Accepting VNC challenge response\n");
2287 vnc_write_u32(vs, 0); /* Accept auth */
2288 vnc_flush(vs);
2289
2290 start_client_init(vs);
2291 }
2292 return 0;
2293
2294 reject:
2295 vnc_write_u32(vs, 1); /* Reject auth */
2296 if (vs->minor >= 8) {
2297 static const char err[] = "Authentication failed";
2298 vnc_write_u32(vs, sizeof(err));
2299 vnc_write(vs, err, sizeof(err));
2300 }
2301 vnc_flush(vs);
2302 vnc_client_error(vs);
2303 return 0;
2304 }
2305
2306 void start_auth_vnc(VncState *vs)
2307 {
2308 make_challenge(vs);
2309 /* Send client a 'random' challenge */
2310 vnc_write(vs, vs->challenge, sizeof(vs->challenge));
2311 vnc_flush(vs);
2312
2313 vnc_read_when(vs, protocol_client_auth_vnc, sizeof(vs->challenge));
2314 }
2315
2316
2317 static int protocol_client_auth(VncState *vs, uint8_t *data, size_t len)
2318 {
2319 /* We only advertise 1 auth scheme at a time, so client
2320 * must pick the one we sent. Verify this */
2321 if (data[0] != vs->auth) { /* Reject auth */
2322 VNC_DEBUG("Reject auth %d because it didn't match advertized\n", (int)data[0]);
2323 vnc_write_u32(vs, 1);
2324 if (vs->minor >= 8) {
2325 static const char err[] = "Authentication failed";
2326 vnc_write_u32(vs, sizeof(err));
2327 vnc_write(vs, err, sizeof(err));
2328 }
2329 vnc_client_error(vs);
2330 } else { /* Accept requested auth */
2331 VNC_DEBUG("Client requested auth %d\n", (int)data[0]);
2332 switch (vs->auth) {
2333 case VNC_AUTH_NONE:
2334 VNC_DEBUG("Accept auth none\n");
2335 if (vs->minor >= 8) {
2336 vnc_write_u32(vs, 0); /* Accept auth completion */
2337 vnc_flush(vs);
2338 }
2339 start_client_init(vs);
2340 break;
2341
2342 case VNC_AUTH_VNC:
2343 VNC_DEBUG("Start VNC auth\n");
2344 start_auth_vnc(vs);
2345 break;
2346
2347 #ifdef CONFIG_VNC_TLS
2348 case VNC_AUTH_VENCRYPT:
2349 VNC_DEBUG("Accept VeNCrypt auth\n");
2350 start_auth_vencrypt(vs);
2351 break;
2352 #endif /* CONFIG_VNC_TLS */
2353
2354 #ifdef CONFIG_VNC_SASL
2355 case VNC_AUTH_SASL:
2356 VNC_DEBUG("Accept SASL auth\n");
2357 start_auth_sasl(vs);
2358 break;
2359 #endif /* CONFIG_VNC_SASL */
2360
2361 default: /* Should not be possible, but just in case */
2362 VNC_DEBUG("Reject auth %d server code bug\n", vs->auth);
2363 vnc_write_u8(vs, 1);
2364 if (vs->minor >= 8) {
2365 static const char err[] = "Authentication failed";
2366 vnc_write_u32(vs, sizeof(err));
2367 vnc_write(vs, err, sizeof(err));
2368 }
2369 vnc_client_error(vs);
2370 }
2371 }
2372 return 0;
2373 }
2374
2375 static int protocol_version(VncState *vs, uint8_t *version, size_t len)
2376 {
2377 char local[13];
2378
2379 memcpy(local, version, 12);
2380 local[12] = 0;
2381
2382 if (sscanf(local, "RFB %03d.%03d\n", &vs->major, &vs->minor) != 2) {
2383 VNC_DEBUG("Malformed protocol version %s\n", local);
2384 vnc_client_error(vs);
2385 return 0;
2386 }
2387 VNC_DEBUG("Client request protocol version %d.%d\n", vs->major, vs->minor);
2388 if (vs->major != 3 ||
2389 (vs->minor != 3 &&
2390 vs->minor != 4 &&
2391 vs->minor != 5 &&
2392 vs->minor != 7 &&
2393 vs->minor != 8)) {
2394 VNC_DEBUG("Unsupported client version\n");
2395 vnc_write_u32(vs, VNC_AUTH_INVALID);
2396 vnc_flush(vs);
2397 vnc_client_error(vs);
2398 return 0;
2399 }
2400 /* Some broken clients report v3.4 or v3.5, which spec requires to be treated
2401 * as equivalent to v3.3 by servers
2402 */
2403 if (vs->minor == 4 || vs->minor == 5)
2404 vs->minor = 3;
2405
2406 if (vs->minor == 3) {
2407 if (vs->auth == VNC_AUTH_NONE) {
2408 VNC_DEBUG("Tell client auth none\n");
2409 vnc_write_u32(vs, vs->auth);
2410 vnc_flush(vs);
2411 start_client_init(vs);
2412 } else if (vs->auth == VNC_AUTH_VNC) {
2413 VNC_DEBUG("Tell client VNC auth\n");
2414 vnc_write_u32(vs, vs->auth);
2415 vnc_flush(vs);
2416 start_auth_vnc(vs);
2417 } else {
2418 VNC_DEBUG("Unsupported auth %d for protocol 3.3\n", vs->auth);
2419 vnc_write_u32(vs, VNC_AUTH_INVALID);
2420 vnc_flush(vs);
2421 vnc_client_error(vs);
2422 }
2423 } else {
2424 VNC_DEBUG("Telling client we support auth %d\n", vs->auth);
2425 vnc_write_u8(vs, 1); /* num auth */
2426 vnc_write_u8(vs, vs->auth);
2427 vnc_read_when(vs, protocol_client_auth, 1);
2428 vnc_flush(vs);
2429 }
2430
2431 return 0;
2432 }
2433
2434 static VncRectStat *vnc_stat_rect(VncDisplay *vd, int x, int y)
2435 {
2436 struct VncSurface *vs = &vd->guest;
2437
2438 return &vs->stats[y / VNC_STAT_RECT][x / VNC_STAT_RECT];
2439 }
2440
2441 void vnc_sent_lossy_rect(VncState *vs, int x, int y, int w, int h)
2442 {
2443 int i, j;
2444
2445 w = (x + w) / VNC_STAT_RECT;
2446 h = (y + h) / VNC_STAT_RECT;
2447 x /= VNC_STAT_RECT;
2448 y /= VNC_STAT_RECT;
2449
2450 for (j = y; j <= h; j++) {
2451 for (i = x; i <= w; i++) {
2452 vs->lossy_rect[j][i] = 1;
2453 }
2454 }
2455 }
2456
2457 static int vnc_refresh_lossy_rect(VncDisplay *vd, int x, int y)
2458 {
2459 VncState *vs;
2460 int sty = y / VNC_STAT_RECT;
2461 int stx = x / VNC_STAT_RECT;
2462 int has_dirty = 0;
2463
2464 y = y / VNC_STAT_RECT * VNC_STAT_RECT;
2465 x = x / VNC_STAT_RECT * VNC_STAT_RECT;
2466
2467 QTAILQ_FOREACH(vs, &vd->clients, next) {
2468 int j;
2469
2470 /* kernel send buffers are full -> refresh later */
2471 if (vs->output.offset) {
2472 continue;
2473 }
2474
2475 if (!vs->lossy_rect[sty][stx]) {
2476 continue;
2477 }
2478
2479 vs->lossy_rect[sty][stx] = 0;
2480 for (j = 0; j < VNC_STAT_RECT; ++j) {
2481 bitmap_set(vs->dirty[y + j], x / 16, VNC_STAT_RECT / 16);
2482 }
2483 has_dirty++;
2484 }
2485
2486 return has_dirty;
2487 }
2488
2489 static int vnc_update_stats(VncDisplay *vd, struct timeval * tv)
2490 {
2491 int width = pixman_image_get_width(vd->guest.fb);
2492 int height = pixman_image_get_height(vd->guest.fb);
2493 int x, y;
2494 struct timeval res;
2495 int has_dirty = 0;
2496
2497 for (y = 0; y < height; y += VNC_STAT_RECT) {
2498 for (x = 0; x < width; x += VNC_STAT_RECT) {
2499 VncRectStat *rect = vnc_stat_rect(vd, x, y);
2500
2501 rect->updated = false;
2502 }
2503 }
2504
2505 qemu_timersub(tv, &VNC_REFRESH_STATS, &res);
2506
2507 if (timercmp(&vd->guest.last_freq_check, &res, >)) {
2508 return has_dirty;
2509 }
2510 vd->guest.last_freq_check = *tv;
2511
2512 for (y = 0; y < height; y += VNC_STAT_RECT) {
2513 for (x = 0; x < width; x += VNC_STAT_RECT) {
2514 VncRectStat *rect= vnc_stat_rect(vd, x, y);
2515 int count = ARRAY_SIZE(rect->times);
2516 struct timeval min, max;
2517
2518 if (!timerisset(&rect->times[count - 1])) {
2519 continue ;
2520 }
2521
2522 max = rect->times[(rect->idx + count - 1) % count];
2523 qemu_timersub(tv, &max, &res);
2524
2525 if (timercmp(&res, &VNC_REFRESH_LOSSY, >)) {
2526 rect->freq = 0;
2527 has_dirty += vnc_refresh_lossy_rect(vd, x, y);
2528 memset(rect->times, 0, sizeof (rect->times));
2529 continue ;
2530 }
2531
2532 min = rect->times[rect->idx];
2533 max = rect->times[(rect->idx + count - 1) % count];
2534 qemu_timersub(&max, &min, &res);
2535
2536 rect->freq = res.tv_sec + res.tv_usec / 1000000.;
2537 rect->freq /= count;
2538 rect->freq = 1. / rect->freq;
2539 }
2540 }
2541 return has_dirty;
2542 }
2543
2544 double vnc_update_freq(VncState *vs, int x, int y, int w, int h)
2545 {
2546 int i, j;
2547 double total = 0;
2548 int num = 0;
2549
2550 x = (x / VNC_STAT_RECT) * VNC_STAT_RECT;
2551 y = (y / VNC_STAT_RECT) * VNC_STAT_RECT;
2552
2553 for (j = y; j <= y + h; j += VNC_STAT_RECT) {
2554 for (i = x; i <= x + w; i += VNC_STAT_RECT) {
2555 total += vnc_stat_rect(vs->vd, i, j)->freq;
2556 num++;
2557 }
2558 }
2559
2560 if (num) {
2561 return total / num;
2562 } else {
2563 return 0;
2564 }
2565 }
2566
2567 static void vnc_rect_updated(VncDisplay *vd, int x, int y, struct timeval * tv)
2568 {
2569 VncRectStat *rect;
2570
2571 rect = vnc_stat_rect(vd, x, y);
2572 if (rect->updated) {
2573 return ;
2574 }
2575 rect->times[rect->idx] = *tv;
2576 rect->idx = (rect->idx + 1) % ARRAY_SIZE(rect->times);
2577 rect->updated = true;
2578 }
2579
2580 static int vnc_refresh_server_surface(VncDisplay *vd)
2581 {
2582 int width = pixman_image_get_width(vd->guest.fb);
2583 int height = pixman_image_get_height(vd->guest.fb);
2584 int y;
2585 uint8_t *guest_row;
2586 uint8_t *server_row;
2587 int cmp_bytes;
2588 VncState *vs;
2589 int has_dirty = 0;
2590 pixman_image_t *tmpbuf = NULL;
2591
2592 struct timeval tv = { 0, 0 };
2593
2594 if (!vd->non_adaptive) {
2595 gettimeofday(&tv, NULL);
2596 has_dirty = vnc_update_stats(vd, &tv);
2597 }
2598
2599 /*
2600 * Walk through the guest dirty map.
2601 * Check and copy modified bits from guest to server surface.
2602 * Update server dirty map.
2603 */
2604 cmp_bytes = 64;
2605 if (cmp_bytes > vnc_server_fb_stride(vd)) {
2606 cmp_bytes = vnc_server_fb_stride(vd);
2607 }
2608 if (vd->guest.format != VNC_SERVER_FB_FORMAT) {
2609 int width = pixman_image_get_width(vd->server);
2610 tmpbuf = qemu_pixman_linebuf_create(VNC_SERVER_FB_FORMAT, width);
2611 }
2612 guest_row = (uint8_t *)pixman_image_get_data(vd->guest.fb);
2613 server_row = (uint8_t *)pixman_image_get_data(vd->server);
2614 for (y = 0; y < height; y++) {
2615 if (!bitmap_empty(vd->guest.dirty[y], VNC_DIRTY_BITS)) {
2616 int x;
2617 uint8_t *guest_ptr;
2618 uint8_t *server_ptr;
2619
2620 if (vd->guest.format != VNC_SERVER_FB_FORMAT) {
2621 qemu_pixman_linebuf_fill(tmpbuf, vd->guest.fb, width, 0, y);
2622 guest_ptr = (uint8_t *)pixman_image_get_data(tmpbuf);
2623 } else {
2624 guest_ptr = guest_row;
2625 }
2626 server_ptr = server_row;
2627
2628 for (x = 0; x + 15 < width;
2629 x += 16, guest_ptr += cmp_bytes, server_ptr += cmp_bytes) {
2630 if (!test_and_clear_bit((x / 16), vd->guest.dirty[y]))
2631 continue;
2632 if (memcmp(server_ptr, guest_ptr, cmp_bytes) == 0)
2633 continue;
2634 memcpy(server_ptr, guest_ptr, cmp_bytes);
2635 if (!vd->non_adaptive)
2636 vnc_rect_updated(vd, x, y, &tv);
2637 QTAILQ_FOREACH(vs, &vd->clients, next) {
2638 set_bit((x / 16), vs->dirty[y]);
2639 }
2640 has_dirty++;
2641 }
2642 }
2643 guest_row += pixman_image_get_stride(vd->guest.fb);
2644 server_row += pixman_image_get_stride(vd->server);
2645 }
2646 qemu_pixman_image_unref(tmpbuf);
2647 return has_dirty;
2648 }
2649
2650 static void vnc_refresh(void *opaque)
2651 {
2652 VncDisplay *vd = opaque;
2653 VncState *vs, *vn;
2654 int has_dirty, rects = 0;
2655
2656 vga_hw_update();
2657
2658 if (vnc_trylock_display(vd)) {
2659 vd->timer_interval = VNC_REFRESH_INTERVAL_BASE;
2660 qemu_mod_timer(vd->timer, qemu_get_clock_ms(rt_clock) +
2661 vd->timer_interval);
2662 return;
2663 }
2664
2665 has_dirty = vnc_refresh_server_surface(vd);
2666 vnc_unlock_display(vd);
2667
2668 QTAILQ_FOREACH_SAFE(vs, &vd->clients, next, vn) {
2669 rects += vnc_update_client(vs, has_dirty);
2670 /* vs might be free()ed here */
2671 }
2672
2673 /* vd->timer could be NULL now if the last client disconnected,
2674 * in this case don't update the timer */
2675 if (vd->timer == NULL)
2676 return;
2677
2678 if (has_dirty && rects) {
2679 vd->timer_interval /= 2;
2680 if (vd->timer_interval < VNC_REFRESH_INTERVAL_BASE)
2681 vd->timer_interval = VNC_REFRESH_INTERVAL_BASE;
2682 } else {
2683 vd->timer_interval += VNC_REFRESH_INTERVAL_INC;
2684 if (vd->timer_interval > VNC_REFRESH_INTERVAL_MAX)
2685 vd->timer_interval = VNC_REFRESH_INTERVAL_MAX;
2686 }
2687 qemu_mod_timer(vd->timer, qemu_get_clock_ms(rt_clock) + vd->timer_interval);
2688 }
2689
2690 static void vnc_init_timer(VncDisplay *vd)
2691 {
2692 vd->timer_interval = VNC_REFRESH_INTERVAL_BASE;
2693 if (vd->timer == NULL && !QTAILQ_EMPTY(&vd->clients)) {
2694 vd->timer = qemu_new_timer_ms(rt_clock, vnc_refresh, vd);
2695 vga_hw_update();
2696 vnc_refresh(vd);
2697 }
2698 }
2699
2700 static void vnc_remove_timer(VncDisplay *vd)
2701 {
2702 if (vd->timer != NULL && QTAILQ_EMPTY(&vd->clients)) {
2703 qemu_del_timer(vd->timer);
2704 qemu_free_timer(vd->timer);
2705 vd->timer = NULL;
2706 }
2707 }
2708
2709 static void vnc_connect(VncDisplay *vd, int csock, int skipauth, bool websocket)
2710 {
2711 VncState *vs = g_malloc0(sizeof(VncState));
2712 int i;
2713
2714 vs->csock = csock;
2715
2716 if (skipauth) {
2717 vs->auth = VNC_AUTH_NONE;
2718 #ifdef CONFIG_VNC_TLS
2719 vs->subauth = VNC_AUTH_INVALID;
2720 #endif
2721 } else {
2722 vs->auth = vd->auth;
2723 #ifdef CONFIG_VNC_TLS
2724 vs->subauth = vd->subauth;
2725 #endif
2726 }
2727
2728 vs->lossy_rect = g_malloc0(VNC_STAT_ROWS * sizeof (*vs->lossy_rect));
2729 for (i = 0; i < VNC_STAT_ROWS; ++i) {
2730 vs->lossy_rect[i] = g_malloc0(VNC_STAT_COLS * sizeof (uint8_t));
2731 }
2732
2733 VNC_DEBUG("New client on socket %d\n", csock);
2734 vd->dcl.idle = 0;
2735 socket_set_nonblock(vs->csock);
2736 #ifdef CONFIG_VNC_WS
2737 if (websocket) {
2738 vs->websocket = 1;
2739 qemu_set_fd_handler2(vs->csock, NULL, vncws_handshake_read, NULL, vs);
2740 } else
2741 #endif /* CONFIG_VNC_WS */
2742 {
2743 qemu_set_fd_handler2(vs->csock, NULL, vnc_client_read, NULL, vs);
2744 }
2745
2746 vnc_client_cache_addr(vs);
2747 vnc_qmp_event(vs, QEVENT_VNC_CONNECTED);
2748 vnc_set_share_mode(vs, VNC_SHARE_MODE_CONNECTING);
2749
2750 vs->vd = vd;
2751
2752 #ifdef CONFIG_VNC_WS
2753 if (!vs->websocket)
2754 #endif
2755 {
2756 vnc_init_state(vs);
2757 }
2758 }
2759
2760 void vnc_init_state(VncState *vs)
2761 {
2762 vs->initialized = true;
2763 VncDisplay *vd = vs->vd;
2764
2765 vs->last_x = -1;
2766 vs->last_y = -1;
2767
2768 vs->as.freq = 44100;
2769 vs->as.nchannels = 2;
2770 vs->as.fmt = AUD_FMT_S16;
2771 vs->as.endianness = 0;
2772
2773 qemu_mutex_init(&vs->output_mutex);
2774 vs->bh = qemu_bh_new(vnc_jobs_bh, vs);
2775
2776 QTAILQ_INSERT_HEAD(&vd->clients, vs, next);
2777
2778 vga_hw_update();
2779
2780 vnc_write(vs, "RFB 003.008\n", 12);
2781 vnc_flush(vs);
2782 vnc_read_when(vs, protocol_version, 12);
2783 reset_keys(vs);
2784 if (vs->vd->lock_key_sync)
2785 vs->led = qemu_add_led_event_handler(kbd_leds, vs);
2786
2787 vs->mouse_mode_notifier.notify = check_pointer_type_change;
2788 qemu_add_mouse_mode_change_notifier(&vs->mouse_mode_notifier);
2789
2790 vnc_init_timer(vd);
2791
2792 /* vs might be free()ed here */
2793 }
2794
2795 static void vnc_listen_read(void *opaque, bool websocket)
2796 {
2797 VncDisplay *vs = opaque;
2798 struct sockaddr_in addr;
2799 socklen_t addrlen = sizeof(addr);
2800 int csock;
2801
2802 /* Catch-up */
2803 vga_hw_update();
2804 #ifdef CONFIG_VNC_WS
2805 if (websocket) {
2806 csock = qemu_accept(vs->lwebsock, (struct sockaddr *)&addr, &addrlen);
2807 } else
2808 #endif /* CONFIG_VNC_WS */
2809 {
2810 csock = qemu_accept(vs->lsock, (struct sockaddr *)&addr, &addrlen);
2811 }
2812
2813 if (csock != -1) {
2814 vnc_connect(vs, csock, 0, websocket);
2815 }
2816 }
2817
2818 static void vnc_listen_regular_read(void *opaque)
2819 {
2820 vnc_listen_read(opaque, 0);
2821 }
2822
2823 #ifdef CONFIG_VNC_WS
2824 static void vnc_listen_websocket_read(void *opaque)
2825 {
2826 vnc_listen_read(opaque, 1);
2827 }
2828 #endif /* CONFIG_VNC_WS */
2829
2830 static const DisplayChangeListenerOps dcl_ops = {
2831 .dpy_name = "vnc",
2832 .dpy_gfx_copy = vnc_dpy_copy,
2833 .dpy_gfx_update = vnc_dpy_update,
2834 .dpy_gfx_switch = vnc_dpy_switch,
2835 .dpy_mouse_set = vnc_mouse_set,
2836 .dpy_cursor_define = vnc_dpy_cursor_define,
2837 };
2838
2839 void vnc_display_init(DisplayState *ds)
2840 {
2841 VncDisplay *vs = g_malloc0(sizeof(*vs));
2842
2843 vs->dcl.idle = 1;
2844 vnc_display = vs;
2845
2846 vs->lsock = -1;
2847 #ifdef CONFIG_VNC_WS
2848 vs->lwebsock = -1;
2849 #endif
2850
2851 QTAILQ_INIT(&vs->clients);
2852 vs->expires = TIME_MAX;
2853
2854 if (keyboard_layout)
2855 vs->kbd_layout = init_keyboard_layout(name2keysym, keyboard_layout);
2856 else
2857 vs->kbd_layout = init_keyboard_layout(name2keysym, "en-us");
2858
2859 if (!vs->kbd_layout)
2860 exit(1);
2861
2862 qemu_mutex_init(&vs->mutex);
2863 vnc_start_worker_thread();
2864
2865 vs->dcl.ops = &dcl_ops;
2866 register_displaychangelistener(ds, &vs->dcl);
2867 }
2868
2869
2870 static void vnc_display_close(DisplayState *ds)
2871 {
2872 VncDisplay *vs = vnc_display;
2873
2874 if (!vs)
2875 return;
2876 if (vs->display) {
2877 g_free(vs->display);
2878 vs->display = NULL;
2879 }
2880 if (vs->lsock != -1) {
2881 qemu_set_fd_handler2(vs->lsock, NULL, NULL, NULL, NULL);
2882 close(vs->lsock);
2883 vs->lsock = -1;
2884 }
2885 #ifdef CONFIG_VNC_WS
2886 g_free(vs->ws_display);
2887 vs->ws_display = NULL;
2888 if (vs->lwebsock != -1) {
2889 qemu_set_fd_handler2(vs->lwebsock, NULL, NULL, NULL, NULL);
2890 close(vs->lwebsock);
2891 vs->lwebsock = -1;
2892 }
2893 #endif /* CONFIG_VNC_WS */
2894 vs->auth = VNC_AUTH_INVALID;
2895 #ifdef CONFIG_VNC_TLS
2896 vs->subauth = VNC_AUTH_INVALID;
2897 vs->tls.x509verify = 0;
2898 #endif
2899 }
2900
2901 static int vnc_display_disable_login(DisplayState *ds)
2902 {
2903 VncDisplay *vs = vnc_display;
2904
2905 if (!vs) {
2906 return -1;
2907 }
2908
2909 if (vs->password) {
2910 g_free(vs->password);
2911 }
2912
2913 vs->password = NULL;
2914 if (vs->auth == VNC_AUTH_NONE) {
2915 vs->auth = VNC_AUTH_VNC;
2916 }
2917
2918 return 0;
2919 }
2920
2921 int vnc_display_password(DisplayState *ds, const char *password)
2922 {
2923 VncDisplay *vs = vnc_display;
2924
2925 if (!vs) {
2926 return -EINVAL;
2927 }
2928
2929 if (!password) {
2930 /* This is not the intention of this interface but err on the side
2931 of being safe */
2932 return vnc_display_disable_login(ds);
2933 }
2934
2935 if (vs->password) {
2936 g_free(vs->password);
2937 vs->password = NULL;
2938 }
2939 vs->password = g_strdup(password);
2940 if (vs->auth == VNC_AUTH_NONE) {
2941 vs->auth = VNC_AUTH_VNC;
2942 }
2943
2944 return 0;
2945 }
2946
2947 int vnc_display_pw_expire(DisplayState *ds, time_t expires)
2948 {
2949 VncDisplay *vs = vnc_display;
2950
2951 if (!vs) {
2952 return -EINVAL;
2953 }
2954
2955 vs->expires = expires;
2956 return 0;
2957 }
2958
2959 char *vnc_display_local_addr(DisplayState *ds)
2960 {
2961 VncDisplay *vs = vnc_display;
2962
2963 return vnc_socket_local_addr("%s:%s", vs->lsock);
2964 }
2965
2966 void vnc_display_open(DisplayState *ds, const char *display, Error **errp)
2967 {
2968 VncDisplay *vs = vnc_display;
2969 const char *options;
2970 int password = 0;
2971 int reverse = 0;
2972 #ifdef CONFIG_VNC_TLS
2973 int tls = 0, x509 = 0;
2974 #endif
2975 #ifdef CONFIG_VNC_SASL
2976 int sasl = 0;
2977 int saslErr;
2978 #endif
2979 #if defined(CONFIG_VNC_TLS) || defined(CONFIG_VNC_SASL)
2980 int acl = 0;
2981 #endif
2982 int lock_key_sync = 1;
2983
2984 if (!vnc_display) {
2985 error_setg(errp, "VNC display not active");
2986 return;
2987 }
2988 vnc_display_close(ds);
2989 if (strcmp(display, "none") == 0)
2990 return;
2991
2992 vs->display = g_strdup(display);
2993 vs->share_policy = VNC_SHARE_POLICY_ALLOW_EXCLUSIVE;
2994
2995 options = display;
2996 while ((options = strchr(options, ','))) {
2997 options++;
2998 if (strncmp(options, "password", 8) == 0) {
2999 if (fips_get_state()) {
3000 error_setg(errp,
3001 "VNC password auth disabled due to FIPS mode, "
3002 "consider using the VeNCrypt or SASL authentication "
3003 "methods as an alternative");
3004 goto fail;
3005 }
3006 password = 1; /* Require password auth */
3007 } else if (strncmp(options, "reverse", 7) == 0) {
3008 reverse = 1;
3009 } else if (strncmp(options, "no-lock-key-sync", 16) == 0) {
3010 lock_key_sync = 0;
3011 #ifdef CONFIG_VNC_SASL
3012 } else if (strncmp(options, "sasl", 4) == 0) {
3013 sasl = 1; /* Require SASL auth */
3014 #endif
3015 #ifdef CONFIG_VNC_WS
3016 } else if (strncmp(options, "websocket", 9) == 0) {
3017 char *start, *end;
3018 vs->websocket = 1;
3019
3020 /* Check for 'websocket=<port>' */
3021 start = strchr(options, '=');
3022 end = strchr(options, ',');
3023 if (start && (!end || (start < end))) {
3024 int len = end ? end-(start+1) : strlen(start+1);
3025 if (len < 6) {
3026 /* extract the host specification from display */
3027 char *host = NULL, *port = NULL, *host_end = NULL;
3028 port = g_strndup(start + 1, len);
3029
3030 /* ipv6 hosts have colons */
3031 end = strchr(display, ',');
3032 host_end = g_strrstr_len(display, end - display, ":");
3033
3034 if (host_end) {
3035 host = g_strndup(display, host_end - display + 1);
3036 } else {
3037 host = g_strndup(":", 1);
3038 }
3039 vs->ws_display = g_strconcat(host, port, NULL);
3040 g_free(host);
3041 g_free(port);
3042 }
3043 }
3044 #endif /* CONFIG_VNC_WS */
3045 #ifdef CONFIG_VNC_TLS
3046 } else if (strncmp(options, "tls", 3) == 0) {
3047 tls = 1; /* Require TLS */
3048 } else if (strncmp(options, "x509", 4) == 0) {
3049 char *start, *end;
3050 x509 = 1; /* Require x509 certificates */
3051 if (strncmp(options, "x509verify", 10) == 0)
3052 vs->tls.x509verify = 1; /* ...and verify client certs */
3053
3054 /* Now check for 'x509=/some/path' postfix
3055 * and use that to setup x509 certificate/key paths */
3056 start = strchr(options, '=');
3057 end = strchr(options, ',');
3058 if (start && (!end || (start < end))) {
3059 int len = end ? end-(start+1) : strlen(start+1);
3060 char *path = g_strndup(start + 1, len);
3061
3062 VNC_DEBUG("Trying certificate path '%s'\n", path);
3063 if (vnc_tls_set_x509_creds_dir(vs, path) < 0) {
3064 error_setg(errp, "Failed to find x509 certificates/keys in %s", path);
3065 g_free(path);
3066 goto fail;
3067 }
3068 g_free(path);
3069 } else {
3070 error_setg(errp, "No certificate path provided");
3071 goto fail;
3072 }
3073 #endif
3074 #if defined(CONFIG_VNC_TLS) || defined(CONFIG_VNC_SASL)
3075 } else if (strncmp(options, "acl", 3) == 0) {
3076 acl = 1;
3077 #endif
3078 } else if (strncmp(options, "lossy", 5) == 0) {
3079 vs->lossy = true;
3080 } else if (strncmp(options, "non-adaptive", 12) == 0) {
3081 vs->non_adaptive = true;
3082 } else if (strncmp(options, "share=", 6) == 0) {
3083 if (strncmp(options+6, "ignore", 6) == 0) {
3084 vs->share_policy = VNC_SHARE_POLICY_IGNORE;
3085 } else if (strncmp(options+6, "allow-exclusive", 15) == 0) {
3086 vs->share_policy = VNC_SHARE_POLICY_ALLOW_EXCLUSIVE;
3087 } else if (strncmp(options+6, "force-shared", 12) == 0) {
3088 vs->share_policy = VNC_SHARE_POLICY_FORCE_SHARED;
3089 } else {
3090 error_setg(errp, "unknown vnc share= option");
3091 goto fail;
3092 }
3093 }
3094 }
3095
3096 #ifdef CONFIG_VNC_TLS
3097 if (acl && x509 && vs->tls.x509verify) {
3098 if (!(vs->tls.acl = qemu_acl_init("vnc.x509dname"))) {
3099 fprintf(stderr, "Failed to create x509 dname ACL\n");
3100 exit(1);
3101 }
3102 }
3103 #endif
3104 #ifdef CONFIG_VNC_SASL
3105 if (acl && sasl) {
3106 if (!(vs->sasl.acl = qemu_acl_init("vnc.username"))) {
3107 fprintf(stderr, "Failed to create username ACL\n");
3108 exit(1);
3109 }
3110 }
3111 #endif
3112
3113 /*
3114 * Combinations we support here:
3115 *
3116 * - no-auth (clear text, no auth)
3117 * - password (clear text, weak auth)
3118 * - sasl (encrypt, good auth *IF* using Kerberos via GSSAPI)
3119 * - tls (encrypt, weak anonymous creds, no auth)
3120 * - tls + password (encrypt, weak anonymous creds, weak auth)
3121 * - tls + sasl (encrypt, weak anonymous creds, good auth)
3122 * - tls + x509 (encrypt, good x509 creds, no auth)
3123 * - tls + x509 + password (encrypt, good x509 creds, weak auth)
3124 * - tls + x509 + sasl (encrypt, good x509 creds, good auth)
3125 *
3126 * NB1. TLS is a stackable auth scheme.
3127 * NB2. the x509 schemes have option to validate a client cert dname
3128 */
3129 if (password) {
3130 #ifdef CONFIG_VNC_TLS
3131 if (tls) {
3132 vs->auth = VNC_AUTH_VENCRYPT;
3133 if (x509) {
3134 VNC_DEBUG("Initializing VNC server with x509 password auth\n");
3135 vs->subauth = VNC_AUTH_VENCRYPT_X509VNC;
3136 } else {
3137 VNC_DEBUG("Initializing VNC server with TLS password auth\n");
3138 vs->subauth = VNC_AUTH_VENCRYPT_TLSVNC;
3139 }
3140 } else {
3141 #endif /* CONFIG_VNC_TLS */
3142 VNC_DEBUG("Initializing VNC server with password auth\n");
3143 vs->auth = VNC_AUTH_VNC;
3144 #ifdef CONFIG_VNC_TLS
3145 vs->subauth = VNC_AUTH_INVALID;
3146 }
3147 #endif /* CONFIG_VNC_TLS */
3148 #ifdef CONFIG_VNC_SASL
3149 } else if (sasl) {
3150 #ifdef CONFIG_VNC_TLS
3151 if (tls) {
3152 vs->auth = VNC_AUTH_VENCRYPT;
3153 if (x509) {
3154 VNC_DEBUG("Initializing VNC server with x509 SASL auth\n");
3155 vs->subauth = VNC_AUTH_VENCRYPT_X509SASL;
3156 } else {
3157 VNC_DEBUG("Initializing VNC server with TLS SASL auth\n");
3158 vs->subauth = VNC_AUTH_VENCRYPT_TLSSASL;
3159 }
3160 } else {
3161 #endif /* CONFIG_VNC_TLS */
3162 VNC_DEBUG("Initializing VNC server with SASL auth\n");
3163 vs->auth = VNC_AUTH_SASL;
3164 #ifdef CONFIG_VNC_TLS
3165 vs->subauth = VNC_AUTH_INVALID;
3166 }
3167 #endif /* CONFIG_VNC_TLS */
3168 #endif /* CONFIG_VNC_SASL */
3169 } else {
3170 #ifdef CONFIG_VNC_TLS
3171 if (tls) {
3172 vs->auth = VNC_AUTH_VENCRYPT;
3173 if (x509) {
3174 VNC_DEBUG("Initializing VNC server with x509 no auth\n");
3175 vs->subauth = VNC_AUTH_VENCRYPT_X509NONE;
3176 } else {
3177 VNC_DEBUG("Initializing VNC server with TLS no auth\n");
3178 vs->subauth = VNC_AUTH_VENCRYPT_TLSNONE;
3179 }
3180 } else {
3181 #endif
3182 VNC_DEBUG("Initializing VNC server with no auth\n");
3183 vs->auth = VNC_AUTH_NONE;
3184 #ifdef CONFIG_VNC_TLS
3185 vs->subauth = VNC_AUTH_INVALID;
3186 }
3187 #endif
3188 }
3189
3190 #ifdef CONFIG_VNC_SASL
3191 if ((saslErr = sasl_server_init(NULL, "qemu")) != SASL_OK) {
3192 error_setg(errp, "Failed to initialize SASL auth: %s",
3193 sasl_errstring(saslErr, NULL, NULL));
3194 goto fail;
3195 }
3196 #endif
3197 vs->lock_key_sync = lock_key_sync;
3198
3199 if (reverse) {
3200 /* connect to viewer */
3201 int csock;
3202 vs->lsock = -1;
3203 #ifdef CONFIG_VNC_WS
3204 vs->lwebsock = -1;
3205 #endif
3206 if (strncmp(display, "unix:", 5) == 0) {
3207 csock = unix_connect(display+5, errp);
3208 } else {
3209 csock = inet_connect(display, errp);
3210 }
3211 if (csock < 0) {
3212 goto fail;
3213 }
3214 vnc_connect(vs, csock, 0, 0);
3215 } else {
3216 /* listen for connects */
3217 char *dpy;
3218 dpy = g_malloc(256);
3219 if (strncmp(display, "unix:", 5) == 0) {
3220 pstrcpy(dpy, 256, "unix:");
3221 vs->lsock = unix_listen(display+5, dpy+5, 256-5, errp);
3222 } else {
3223 vs->lsock = inet_listen(display, dpy, 256,
3224 SOCK_STREAM, 5900, errp);
3225 if (vs->lsock < 0) {
3226 g_free(dpy);
3227 goto fail;
3228 }
3229 #ifdef CONFIG_VNC_WS
3230 if (vs->websocket) {
3231 if (vs->ws_display) {
3232 vs->lwebsock = inet_listen(vs->ws_display, NULL, 256,
3233 SOCK_STREAM, 0, errp);
3234 } else {
3235 vs->lwebsock = inet_listen(vs->display, NULL, 256,
3236 SOCK_STREAM, 5700, errp);
3237 }
3238
3239 if (vs->lwebsock < 0) {
3240 if (vs->lsock) {
3241 close(vs->lsock);
3242 vs->lsock = -1;
3243 }
3244 g_free(dpy);
3245 goto fail;
3246 }
3247 }
3248 #endif /* CONFIG_VNC_WS */
3249 }
3250 g_free(vs->display);
3251 vs->display = dpy;
3252 qemu_set_fd_handler2(vs->lsock, NULL,
3253 vnc_listen_regular_read, NULL, vs);
3254 #ifdef CONFIG_VNC_WS
3255 if (vs->websocket) {
3256 qemu_set_fd_handler2(vs->lwebsock, NULL,
3257 vnc_listen_websocket_read, NULL, vs);
3258 }
3259 #endif /* CONFIG_VNC_WS */
3260 }
3261 return;
3262
3263 fail:
3264 g_free(vs->display);
3265 vs->display = NULL;
3266 #ifdef CONFIG_VNC_WS
3267 g_free(vs->ws_display);
3268 vs->ws_display = NULL;
3269 #endif /* CONFIG_VNC_WS */
3270 }
3271
3272 void vnc_display_add_client(DisplayState *ds, int csock, int skipauth)
3273 {
3274 VncDisplay *vs = vnc_display;
3275
3276 vnc_connect(vs, csock, skipauth, 0);
3277 }
Qemu with PowerPC KVM improvements