]> git.proxmox.com Git - mirror_qemu.git/blob - ui/vnc.c
projects / mirror_qemu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge remote-tracking branch 'remotes/dgibson/tags/ppc-for-4.0-20190226' into staging
[mirror_qemu.git] / ui / vnc.c
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 "qemu/osdep.h"
28 #include "vnc.h"
29 #include "vnc-jobs.h"
30 #include "trace.h"
31 #include "sysemu/sysemu.h"
32 #include "qemu/error-report.h"
33 #include "qemu/option.h"
34 #include "qemu/sockets.h"
35 #include "qemu/timer.h"
36 #include "authz/list.h"
37 #include "qemu/config-file.h"
38 #include "qapi/qapi-emit-events.h"
39 #include "qapi/qapi-events-ui.h"
40 #include "qapi/error.h"
41 #include "qapi/qapi-commands-ui.h"
42 #include "ui/input.h"
43 #include "crypto/hash.h"
44 #include "crypto/tlscredsanon.h"
45 #include "crypto/tlscredsx509.h"
46 #include "qom/object_interfaces.h"
47 #include "qemu/cutils.h"
48 #include "io/dns-resolver.h"
49
50 #define VNC_REFRESH_INTERVAL_BASE GUI_REFRESH_INTERVAL_DEFAULT
51 #define VNC_REFRESH_INTERVAL_INC 50
52 #define VNC_REFRESH_INTERVAL_MAX GUI_REFRESH_INTERVAL_IDLE
53 static const struct timeval VNC_REFRESH_STATS = { 0, 500000 };
54 static const struct timeval VNC_REFRESH_LOSSY = { 2, 0 };
55
56 #include "vnc_keysym.h"
57 #include "crypto/cipher.h"
58
59 static QTAILQ_HEAD(, VncDisplay) vnc_displays =
60 QTAILQ_HEAD_INITIALIZER(vnc_displays);
61
62 static int vnc_cursor_define(VncState *vs);
63 static void vnc_update_throttle_offset(VncState *vs);
64
65 static void vnc_set_share_mode(VncState *vs, VncShareMode mode)
66 {
67 #ifdef _VNC_DEBUG
68 static const char *mn[] = {
69 [0] = "undefined",
70 [VNC_SHARE_MODE_CONNECTING] = "connecting",
71 [VNC_SHARE_MODE_SHARED] = "shared",
72 [VNC_SHARE_MODE_EXCLUSIVE] = "exclusive",
73 [VNC_SHARE_MODE_DISCONNECTED] = "disconnected",
74 };
75 fprintf(stderr, "%s/%p: %s -> %s\n", __func__,
76 vs->ioc, mn[vs->share_mode], mn[mode]);
77 #endif
78
79 switch (vs->share_mode) {
80 case VNC_SHARE_MODE_CONNECTING:
81 vs->vd->num_connecting--;
82 break;
83 case VNC_SHARE_MODE_SHARED:
84 vs->vd->num_shared--;
85 break;
86 case VNC_SHARE_MODE_EXCLUSIVE:
87 vs->vd->num_exclusive--;
88 break;
89 default:
90 break;
91 }
92
93 vs->share_mode = mode;
94
95 switch (vs->share_mode) {
96 case VNC_SHARE_MODE_CONNECTING:
97 vs->vd->num_connecting++;
98 break;
99 case VNC_SHARE_MODE_SHARED:
100 vs->vd->num_shared++;
101 break;
102 case VNC_SHARE_MODE_EXCLUSIVE:
103 vs->vd->num_exclusive++;
104 break;
105 default:
106 break;
107 }
108 }
109
110
111 static void vnc_init_basic_info(SocketAddress *addr,
112 VncBasicInfo *info,
113 Error **errp)
114 {
115 switch (addr->type) {
116 case SOCKET_ADDRESS_TYPE_INET:
117 info->host = g_strdup(addr->u.inet.host);
118 info->service = g_strdup(addr->u.inet.port);
119 if (addr->u.inet.ipv6) {
120 info->family = NETWORK_ADDRESS_FAMILY_IPV6;
121 } else {
122 info->family = NETWORK_ADDRESS_FAMILY_IPV4;
123 }
124 break;
125
126 case SOCKET_ADDRESS_TYPE_UNIX:
127 info->host = g_strdup("");
128 info->service = g_strdup(addr->u.q_unix.path);
129 info->family = NETWORK_ADDRESS_FAMILY_UNIX;
130 break;
131
132 case SOCKET_ADDRESS_TYPE_VSOCK:
133 case SOCKET_ADDRESS_TYPE_FD:
134 error_setg(errp, "Unsupported socket address type %s",
135 SocketAddressType_str(addr->type));
136 break;
137 default:
138 abort();
139 }
140
141 return;
142 }
143
144 static void vnc_init_basic_info_from_server_addr(QIOChannelSocket *ioc,
145 VncBasicInfo *info,
146 Error **errp)
147 {
148 SocketAddress *addr = NULL;
149
150 if (!ioc) {
151 error_setg(errp, "No listener socket available");
152 return;
153 }
154
155 addr = qio_channel_socket_get_local_address(ioc, errp);
156 if (!addr) {
157 return;
158 }
159
160 vnc_init_basic_info(addr, info, errp);
161 qapi_free_SocketAddress(addr);
162 }
163
164 static void vnc_init_basic_info_from_remote_addr(QIOChannelSocket *ioc,
165 VncBasicInfo *info,
166 Error **errp)
167 {
168 SocketAddress *addr = NULL;
169
170 addr = qio_channel_socket_get_remote_address(ioc, errp);
171 if (!addr) {
172 return;
173 }
174
175 vnc_init_basic_info(addr, info, errp);
176 qapi_free_SocketAddress(addr);
177 }
178
179 static const char *vnc_auth_name(VncDisplay *vd) {
180 switch (vd->auth) {
181 case VNC_AUTH_INVALID:
182 return "invalid";
183 case VNC_AUTH_NONE:
184 return "none";
185 case VNC_AUTH_VNC:
186 return "vnc";
187 case VNC_AUTH_RA2:
188 return "ra2";
189 case VNC_AUTH_RA2NE:
190 return "ra2ne";
191 case VNC_AUTH_TIGHT:
192 return "tight";
193 case VNC_AUTH_ULTRA:
194 return "ultra";
195 case VNC_AUTH_TLS:
196 return "tls";
197 case VNC_AUTH_VENCRYPT:
198 switch (vd->subauth) {
199 case VNC_AUTH_VENCRYPT_PLAIN:
200 return "vencrypt+plain";
201 case VNC_AUTH_VENCRYPT_TLSNONE:
202 return "vencrypt+tls+none";
203 case VNC_AUTH_VENCRYPT_TLSVNC:
204 return "vencrypt+tls+vnc";
205 case VNC_AUTH_VENCRYPT_TLSPLAIN:
206 return "vencrypt+tls+plain";
207 case VNC_AUTH_VENCRYPT_X509NONE:
208 return "vencrypt+x509+none";
209 case VNC_AUTH_VENCRYPT_X509VNC:
210 return "vencrypt+x509+vnc";
211 case VNC_AUTH_VENCRYPT_X509PLAIN:
212 return "vencrypt+x509+plain";
213 case VNC_AUTH_VENCRYPT_TLSSASL:
214 return "vencrypt+tls+sasl";
215 case VNC_AUTH_VENCRYPT_X509SASL:
216 return "vencrypt+x509+sasl";
217 default:
218 return "vencrypt";
219 }
220 case VNC_AUTH_SASL:
221 return "sasl";
222 }
223 return "unknown";
224 }
225
226 static VncServerInfo *vnc_server_info_get(VncDisplay *vd)
227 {
228 VncServerInfo *info;
229 Error *err = NULL;
230
231 if (!vd->listener || !vd->listener->nsioc) {
232 return NULL;
233 }
234
235 info = g_malloc0(sizeof(*info));
236 vnc_init_basic_info_from_server_addr(vd->listener->sioc[0],
237 qapi_VncServerInfo_base(info), &err);
238 info->has_auth = true;
239 info->auth = g_strdup(vnc_auth_name(vd));
240 if (err) {
241 qapi_free_VncServerInfo(info);
242 info = NULL;
243 error_free(err);
244 }
245 return info;
246 }
247
248 static void vnc_client_cache_auth(VncState *client)
249 {
250 if (!client->info) {
251 return;
252 }
253
254 if (client->tls) {
255 client->info->x509_dname =
256 qcrypto_tls_session_get_peer_name(client->tls);
257 client->info->has_x509_dname =
258 client->info->x509_dname != NULL;
259 }
260 #ifdef CONFIG_VNC_SASL
261 if (client->sasl.conn &&
262 client->sasl.username) {
263 client->info->has_sasl_username = true;
264 client->info->sasl_username = g_strdup(client->sasl.username);
265 }
266 #endif
267 }
268
269 static void vnc_client_cache_addr(VncState *client)
270 {
271 Error *err = NULL;
272
273 client->info = g_malloc0(sizeof(*client->info));
274 vnc_init_basic_info_from_remote_addr(client->sioc,
275 qapi_VncClientInfo_base(client->info),
276 &err);
277 if (err) {
278 qapi_free_VncClientInfo(client->info);
279 client->info = NULL;
280 error_free(err);
281 }
282 }
283
284 static void vnc_qmp_event(VncState *vs, QAPIEvent event)
285 {
286 VncServerInfo *si;
287
288 if (!vs->info) {
289 return;
290 }
291
292 si = vnc_server_info_get(vs->vd);
293 if (!si) {
294 return;
295 }
296
297 switch (event) {
298 case QAPI_EVENT_VNC_CONNECTED:
299 qapi_event_send_vnc_connected(si, qapi_VncClientInfo_base(vs->info));
300 break;
301 case QAPI_EVENT_VNC_INITIALIZED:
302 qapi_event_send_vnc_initialized(si, vs->info);
303 break;
304 case QAPI_EVENT_VNC_DISCONNECTED:
305 qapi_event_send_vnc_disconnected(si, vs->info);
306 break;
307 default:
308 break;
309 }
310
311 qapi_free_VncServerInfo(si);
312 }
313
314 static VncClientInfo *qmp_query_vnc_client(const VncState *client)
315 {
316 VncClientInfo *info;
317 Error *err = NULL;
318
319 info = g_malloc0(sizeof(*info));
320
321 vnc_init_basic_info_from_remote_addr(client->sioc,
322 qapi_VncClientInfo_base(info),
323 &err);
324 if (err) {
325 error_free(err);
326 qapi_free_VncClientInfo(info);
327 return NULL;
328 }
329
330 info->websocket = client->websocket;
331
332 if (client->tls) {
333 info->x509_dname = qcrypto_tls_session_get_peer_name(client->tls);
334 info->has_x509_dname = info->x509_dname != NULL;
335 }
336 #ifdef CONFIG_VNC_SASL
337 if (client->sasl.conn && client->sasl.username) {
338 info->has_sasl_username = true;
339 info->sasl_username = g_strdup(client->sasl.username);
340 }
341 #endif
342
343 return info;
344 }
345
346 static VncDisplay *vnc_display_find(const char *id)
347 {
348 VncDisplay *vd;
349
350 if (id == NULL) {
351 return QTAILQ_FIRST(&vnc_displays);
352 }
353 QTAILQ_FOREACH(vd, &vnc_displays, next) {
354 if (strcmp(id, vd->id) == 0) {
355 return vd;
356 }
357 }
358 return NULL;
359 }
360
361 static VncClientInfoList *qmp_query_client_list(VncDisplay *vd)
362 {
363 VncClientInfoList *cinfo, *prev = NULL;
364 VncState *client;
365
366 QTAILQ_FOREACH(client, &vd->clients, next) {
367 cinfo = g_new0(VncClientInfoList, 1);
368 cinfo->value = qmp_query_vnc_client(client);
369 cinfo->next = prev;
370 prev = cinfo;
371 }
372 return prev;
373 }
374
375 VncInfo *qmp_query_vnc(Error **errp)
376 {
377 VncInfo *info = g_malloc0(sizeof(*info));
378 VncDisplay *vd = vnc_display_find(NULL);
379 SocketAddress *addr = NULL;
380
381 if (vd == NULL || !vd->listener || !vd->listener->nsioc) {
382 info->enabled = false;
383 } else {
384 info->enabled = true;
385
386 /* for compatibility with the original command */
387 info->has_clients = true;
388 info->clients = qmp_query_client_list(vd);
389
390 addr = qio_channel_socket_get_local_address(vd->listener->sioc[0],
391 errp);
392 if (!addr) {
393 goto out_error;
394 }
395
396 switch (addr->type) {
397 case SOCKET_ADDRESS_TYPE_INET:
398 info->host = g_strdup(addr->u.inet.host);
399 info->service = g_strdup(addr->u.inet.port);
400 if (addr->u.inet.ipv6) {
401 info->family = NETWORK_ADDRESS_FAMILY_IPV6;
402 } else {
403 info->family = NETWORK_ADDRESS_FAMILY_IPV4;
404 }
405 break;
406
407 case SOCKET_ADDRESS_TYPE_UNIX:
408 info->host = g_strdup("");
409 info->service = g_strdup(addr->u.q_unix.path);
410 info->family = NETWORK_ADDRESS_FAMILY_UNIX;
411 break;
412
413 case SOCKET_ADDRESS_TYPE_VSOCK:
414 case SOCKET_ADDRESS_TYPE_FD:
415 error_setg(errp, "Unsupported socket address type %s",
416 SocketAddressType_str(addr->type));
417 goto out_error;
418 default:
419 abort();
420 }
421
422 info->has_host = true;
423 info->has_service = true;
424 info->has_family = true;
425
426 info->has_auth = true;
427 info->auth = g_strdup(vnc_auth_name(vd));
428 }
429
430 qapi_free_SocketAddress(addr);
431 return info;
432
433 out_error:
434 qapi_free_SocketAddress(addr);
435 qapi_free_VncInfo(info);
436 return NULL;
437 }
438
439
440 static void qmp_query_auth(int auth, int subauth,
441 VncPrimaryAuth *qmp_auth,
442 VncVencryptSubAuth *qmp_vencrypt,
443 bool *qmp_has_vencrypt);
444
445 static VncServerInfo2List *qmp_query_server_entry(QIOChannelSocket *ioc,
446 bool websocket,
447 int auth,
448 int subauth,
449 VncServerInfo2List *prev)
450 {
451 VncServerInfo2List *list;
452 VncServerInfo2 *info;
453 Error *err = NULL;
454 SocketAddress *addr;
455
456 addr = qio_channel_socket_get_local_address(ioc, &err);
457 if (!addr) {
458 error_free(err);
459 return prev;
460 }
461
462 info = g_new0(VncServerInfo2, 1);
463 vnc_init_basic_info(addr, qapi_VncServerInfo2_base(info), &err);
464 qapi_free_SocketAddress(addr);
465 if (err) {
466 qapi_free_VncServerInfo2(info);
467 error_free(err);
468 return prev;
469 }
470 info->websocket = websocket;
471
472 qmp_query_auth(auth, subauth, &info->auth,
473 &info->vencrypt, &info->has_vencrypt);
474
475 list = g_new0(VncServerInfo2List, 1);
476 list->value = info;
477 list->next = prev;
478 return list;
479 }
480
481 static void qmp_query_auth(int auth, int subauth,
482 VncPrimaryAuth *qmp_auth,
483 VncVencryptSubAuth *qmp_vencrypt,
484 bool *qmp_has_vencrypt)
485 {
486 switch (auth) {
487 case VNC_AUTH_VNC:
488 *qmp_auth = VNC_PRIMARY_AUTH_VNC;
489 break;
490 case VNC_AUTH_RA2:
491 *qmp_auth = VNC_PRIMARY_AUTH_RA2;
492 break;
493 case VNC_AUTH_RA2NE:
494 *qmp_auth = VNC_PRIMARY_AUTH_RA2NE;
495 break;
496 case VNC_AUTH_TIGHT:
497 *qmp_auth = VNC_PRIMARY_AUTH_TIGHT;
498 break;
499 case VNC_AUTH_ULTRA:
500 *qmp_auth = VNC_PRIMARY_AUTH_ULTRA;
501 break;
502 case VNC_AUTH_TLS:
503 *qmp_auth = VNC_PRIMARY_AUTH_TLS;
504 break;
505 case VNC_AUTH_VENCRYPT:
506 *qmp_auth = VNC_PRIMARY_AUTH_VENCRYPT;
507 *qmp_has_vencrypt = true;
508 switch (subauth) {
509 case VNC_AUTH_VENCRYPT_PLAIN:
510 *qmp_vencrypt = VNC_VENCRYPT_SUB_AUTH_PLAIN;
511 break;
512 case VNC_AUTH_VENCRYPT_TLSNONE:
513 *qmp_vencrypt = VNC_VENCRYPT_SUB_AUTH_TLS_NONE;
514 break;
515 case VNC_AUTH_VENCRYPT_TLSVNC:
516 *qmp_vencrypt = VNC_VENCRYPT_SUB_AUTH_TLS_VNC;
517 break;
518 case VNC_AUTH_VENCRYPT_TLSPLAIN:
519 *qmp_vencrypt = VNC_VENCRYPT_SUB_AUTH_TLS_PLAIN;
520 break;
521 case VNC_AUTH_VENCRYPT_X509NONE:
522 *qmp_vencrypt = VNC_VENCRYPT_SUB_AUTH_X509_NONE;
523 break;
524 case VNC_AUTH_VENCRYPT_X509VNC:
525 *qmp_vencrypt = VNC_VENCRYPT_SUB_AUTH_X509_VNC;
526 break;
527 case VNC_AUTH_VENCRYPT_X509PLAIN:
528 *qmp_vencrypt = VNC_VENCRYPT_SUB_AUTH_X509_PLAIN;
529 break;
530 case VNC_AUTH_VENCRYPT_TLSSASL:
531 *qmp_vencrypt = VNC_VENCRYPT_SUB_AUTH_TLS_SASL;
532 break;
533 case VNC_AUTH_VENCRYPT_X509SASL:
534 *qmp_vencrypt = VNC_VENCRYPT_SUB_AUTH_X509_SASL;
535 break;
536 default:
537 *qmp_has_vencrypt = false;
538 break;
539 }
540 break;
541 case VNC_AUTH_SASL:
542 *qmp_auth = VNC_PRIMARY_AUTH_SASL;
543 break;
544 case VNC_AUTH_NONE:
545 default:
546 *qmp_auth = VNC_PRIMARY_AUTH_NONE;
547 break;
548 }
549 }
550
551 VncInfo2List *qmp_query_vnc_servers(Error **errp)
552 {
553 VncInfo2List *item, *prev = NULL;
554 VncInfo2 *info;
555 VncDisplay *vd;
556 DeviceState *dev;
557 size_t i;
558
559 QTAILQ_FOREACH(vd, &vnc_displays, next) {
560 info = g_new0(VncInfo2, 1);
561 info->id = g_strdup(vd->id);
562 info->clients = qmp_query_client_list(vd);
563 qmp_query_auth(vd->auth, vd->subauth, &info->auth,
564 &info->vencrypt, &info->has_vencrypt);
565 if (vd->dcl.con) {
566 dev = DEVICE(object_property_get_link(OBJECT(vd->dcl.con),
567 "device", NULL));
568 info->has_display = true;
569 info->display = g_strdup(dev->id);
570 }
571 for (i = 0; vd->listener != NULL && i < vd->listener->nsioc; i++) {
572 info->server = qmp_query_server_entry(
573 vd->listener->sioc[i], false, vd->auth, vd->subauth,
574 info->server);
575 }
576 for (i = 0; vd->wslistener != NULL && i < vd->wslistener->nsioc; i++) {
577 info->server = qmp_query_server_entry(
578 vd->wslistener->sioc[i], true, vd->ws_auth,
579 vd->ws_subauth, info->server);
580 }
581
582 item = g_new0(VncInfo2List, 1);
583 item->value = info;
584 item->next = prev;
585 prev = item;
586 }
587 return prev;
588 }
589
590 /* TODO
591 1) Get the queue working for IO.
592 2) there is some weirdness when using the -S option (the screen is grey
593 and not totally invalidated
594 3) resolutions > 1024
595 */
596
597 static int vnc_update_client(VncState *vs, int has_dirty);
598 static void vnc_disconnect_start(VncState *vs);
599
600 static void vnc_colordepth(VncState *vs);
601 static void framebuffer_update_request(VncState *vs, int incremental,
602 int x_position, int y_position,
603 int w, int h);
604 static void vnc_refresh(DisplayChangeListener *dcl);
605 static int vnc_refresh_server_surface(VncDisplay *vd);
606
607 static int vnc_width(VncDisplay *vd)
608 {
609 return MIN(VNC_MAX_WIDTH, ROUND_UP(surface_width(vd->ds),
610 VNC_DIRTY_PIXELS_PER_BIT));
611 }
612
613 static int vnc_height(VncDisplay *vd)
614 {
615 return MIN(VNC_MAX_HEIGHT, surface_height(vd->ds));
616 }
617
618 static void vnc_set_area_dirty(DECLARE_BITMAP(dirty[VNC_MAX_HEIGHT],
619 VNC_MAX_WIDTH / VNC_DIRTY_PIXELS_PER_BIT),
620 VncDisplay *vd,
621 int x, int y, int w, int h)
622 {
623 int width = vnc_width(vd);
624 int height = vnc_height(vd);
625
626 /* this is needed this to ensure we updated all affected
627 * blocks if x % VNC_DIRTY_PIXELS_PER_BIT != 0 */
628 w += (x % VNC_DIRTY_PIXELS_PER_BIT);
629 x -= (x % VNC_DIRTY_PIXELS_PER_BIT);
630
631 x = MIN(x, width);
632 y = MIN(y, height);
633 w = MIN(x + w, width) - x;
634 h = MIN(y + h, height);
635
636 for (; y < h; y++) {
637 bitmap_set(dirty[y], x / VNC_DIRTY_PIXELS_PER_BIT,
638 DIV_ROUND_UP(w, VNC_DIRTY_PIXELS_PER_BIT));
639 }
640 }
641
642 static void vnc_dpy_update(DisplayChangeListener *dcl,
643 int x, int y, int w, int h)
644 {
645 VncDisplay *vd = container_of(dcl, VncDisplay, dcl);
646 struct VncSurface *s = &vd->guest;
647
648 vnc_set_area_dirty(s->dirty, vd, x, y, w, h);
649 }
650
651 void vnc_framebuffer_update(VncState *vs, int x, int y, int w, int h,
652 int32_t encoding)
653 {
654 vnc_write_u16(vs, x);
655 vnc_write_u16(vs, y);
656 vnc_write_u16(vs, w);
657 vnc_write_u16(vs, h);
658
659 vnc_write_s32(vs, encoding);
660 }
661
662
663 static void vnc_desktop_resize(VncState *vs)
664 {
665 if (vs->ioc == NULL || !vnc_has_feature(vs, VNC_FEATURE_RESIZE)) {
666 return;
667 }
668 if (vs->client_width == pixman_image_get_width(vs->vd->server) &&
669 vs->client_height == pixman_image_get_height(vs->vd->server)) {
670 return;
671 }
672
673 assert(pixman_image_get_width(vs->vd->server) < 65536 &&
674 pixman_image_get_width(vs->vd->server) >= 0);
675 assert(pixman_image_get_height(vs->vd->server) < 65536 &&
676 pixman_image_get_height(vs->vd->server) >= 0);
677 vs->client_width = pixman_image_get_width(vs->vd->server);
678 vs->client_height = pixman_image_get_height(vs->vd->server);
679 vnc_lock_output(vs);
680 vnc_write_u8(vs, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE);
681 vnc_write_u8(vs, 0);
682 vnc_write_u16(vs, 1); /* number of rects */
683 vnc_framebuffer_update(vs, 0, 0, vs->client_width, vs->client_height,
684 VNC_ENCODING_DESKTOPRESIZE);
685 vnc_unlock_output(vs);
686 vnc_flush(vs);
687 }
688
689 static void vnc_abort_display_jobs(VncDisplay *vd)
690 {
691 VncState *vs;
692
693 QTAILQ_FOREACH(vs, &vd->clients, next) {
694 vnc_lock_output(vs);
695 vs->abort = true;
696 vnc_unlock_output(vs);
697 }
698 QTAILQ_FOREACH(vs, &vd->clients, next) {
699 vnc_jobs_join(vs);
700 }
701 QTAILQ_FOREACH(vs, &vd->clients, next) {
702 vnc_lock_output(vs);
703 vs->abort = false;
704 vnc_unlock_output(vs);
705 }
706 }
707
708 int vnc_server_fb_stride(VncDisplay *vd)
709 {
710 return pixman_image_get_stride(vd->server);
711 }
712
713 void *vnc_server_fb_ptr(VncDisplay *vd, int x, int y)
714 {
715 uint8_t *ptr;
716
717 ptr = (uint8_t *)pixman_image_get_data(vd->server);
718 ptr += y * vnc_server_fb_stride(vd);
719 ptr += x * VNC_SERVER_FB_BYTES;
720 return ptr;
721 }
722
723 static void vnc_update_server_surface(VncDisplay *vd)
724 {
725 int width, height;
726
727 qemu_pixman_image_unref(vd->server);
728 vd->server = NULL;
729
730 if (QTAILQ_EMPTY(&vd->clients)) {
731 return;
732 }
733
734 width = vnc_width(vd);
735 height = vnc_height(vd);
736 vd->server = pixman_image_create_bits(VNC_SERVER_FB_FORMAT,
737 width, height,
738 NULL, 0);
739
740 memset(vd->guest.dirty, 0x00, sizeof(vd->guest.dirty));
741 vnc_set_area_dirty(vd->guest.dirty, vd, 0, 0,
742 width, height);
743 }
744
745 static bool vnc_check_pageflip(DisplaySurface *s1,
746 DisplaySurface *s2)
747 {
748 return (s1 != NULL &&
749 s2 != NULL &&
750 surface_width(s1) == surface_width(s2) &&
751 surface_height(s1) == surface_height(s2) &&
752 surface_format(s1) == surface_format(s2));
753
754 }
755
756 static void vnc_dpy_switch(DisplayChangeListener *dcl,
757 DisplaySurface *surface)
758 {
759 static const char placeholder_msg[] =
760 "Display output is not active.";
761 static DisplaySurface *placeholder;
762 VncDisplay *vd = container_of(dcl, VncDisplay, dcl);
763 bool pageflip = vnc_check_pageflip(vd->ds, surface);
764 VncState *vs;
765
766 if (surface == NULL) {
767 if (placeholder == NULL) {
768 placeholder = qemu_create_message_surface(640, 480, placeholder_msg);
769 }
770 surface = placeholder;
771 }
772
773 vnc_abort_display_jobs(vd);
774 vd->ds = surface;
775
776 /* guest surface */
777 qemu_pixman_image_unref(vd->guest.fb);
778 vd->guest.fb = pixman_image_ref(surface->image);
779 vd->guest.format = surface->format;
780
781 if (pageflip) {
782 vnc_set_area_dirty(vd->guest.dirty, vd, 0, 0,
783 surface_width(surface),
784 surface_height(surface));
785 return;
786 }
787
788 /* server surface */
789 vnc_update_server_surface(vd);
790
791 QTAILQ_FOREACH(vs, &vd->clients, next) {
792 vnc_colordepth(vs);
793 vnc_desktop_resize(vs);
794 if (vs->vd->cursor) {
795 vnc_cursor_define(vs);
796 }
797 memset(vs->dirty, 0x00, sizeof(vs->dirty));
798 vnc_set_area_dirty(vs->dirty, vd, 0, 0,
799 vnc_width(vd),
800 vnc_height(vd));
801 vnc_update_throttle_offset(vs);
802 }
803 }
804
805 /* fastest code */
806 static void vnc_write_pixels_copy(VncState *vs,
807 void *pixels, int size)
808 {
809 vnc_write(vs, pixels, size);
810 }
811
812 /* slowest but generic code. */
813 void vnc_convert_pixel(VncState *vs, uint8_t *buf, uint32_t v)
814 {
815 uint8_t r, g, b;
816
817 #if VNC_SERVER_FB_FORMAT == PIXMAN_FORMAT(32, PIXMAN_TYPE_ARGB, 0, 8, 8, 8)
818 r = (((v & 0x00ff0000) >> 16) << vs->client_pf.rbits) >> 8;
819 g = (((v & 0x0000ff00) >> 8) << vs->client_pf.gbits) >> 8;
820 b = (((v & 0x000000ff) >> 0) << vs->client_pf.bbits) >> 8;
821 #else
822 # error need some bits here if you change VNC_SERVER_FB_FORMAT
823 #endif
824 v = (r << vs->client_pf.rshift) |
825 (g << vs->client_pf.gshift) |
826 (b << vs->client_pf.bshift);
827 switch (vs->client_pf.bytes_per_pixel) {
828 case 1:
829 buf[0] = v;
830 break;
831 case 2:
832 if (vs->client_be) {
833 buf[0] = v >> 8;
834 buf[1] = v;
835 } else {
836 buf[1] = v >> 8;
837 buf[0] = v;
838 }
839 break;
840 default:
841 case 4:
842 if (vs->client_be) {
843 buf[0] = v >> 24;
844 buf[1] = v >> 16;
845 buf[2] = v >> 8;
846 buf[3] = v;
847 } else {
848 buf[3] = v >> 24;
849 buf[2] = v >> 16;
850 buf[1] = v >> 8;
851 buf[0] = v;
852 }
853 break;
854 }
855 }
856
857 static void vnc_write_pixels_generic(VncState *vs,
858 void *pixels1, int size)
859 {
860 uint8_t buf[4];
861
862 if (VNC_SERVER_FB_BYTES == 4) {
863 uint32_t *pixels = pixels1;
864 int n, i;
865 n = size >> 2;
866 for (i = 0; i < n; i++) {
867 vnc_convert_pixel(vs, buf, pixels[i]);
868 vnc_write(vs, buf, vs->client_pf.bytes_per_pixel);
869 }
870 }
871 }
872
873 int vnc_raw_send_framebuffer_update(VncState *vs, int x, int y, int w, int h)
874 {
875 int i;
876 uint8_t *row;
877 VncDisplay *vd = vs->vd;
878
879 row = vnc_server_fb_ptr(vd, x, y);
880 for (i = 0; i < h; i++) {
881 vs->write_pixels(vs, row, w * VNC_SERVER_FB_BYTES);
882 row += vnc_server_fb_stride(vd);
883 }
884 return 1;
885 }
886
887 int vnc_send_framebuffer_update(VncState *vs, int x, int y, int w, int h)
888 {
889 int n = 0;
890 bool encode_raw = false;
891 size_t saved_offs = vs->output.offset;
892
893 switch(vs->vnc_encoding) {
894 case VNC_ENCODING_ZLIB:
895 n = vnc_zlib_send_framebuffer_update(vs, x, y, w, h);
896 break;
897 case VNC_ENCODING_HEXTILE:
898 vnc_framebuffer_update(vs, x, y, w, h, VNC_ENCODING_HEXTILE);
899 n = vnc_hextile_send_framebuffer_update(vs, x, y, w, h);
900 break;
901 case VNC_ENCODING_TIGHT:
902 n = vnc_tight_send_framebuffer_update(vs, x, y, w, h);
903 break;
904 case VNC_ENCODING_TIGHT_PNG:
905 n = vnc_tight_png_send_framebuffer_update(vs, x, y, w, h);
906 break;
907 case VNC_ENCODING_ZRLE:
908 n = vnc_zrle_send_framebuffer_update(vs, x, y, w, h);
909 break;
910 case VNC_ENCODING_ZYWRLE:
911 n = vnc_zywrle_send_framebuffer_update(vs, x, y, w, h);
912 break;
913 default:
914 encode_raw = true;
915 break;
916 }
917
918 /* If the client has the same pixel format as our internal buffer and
919 * a RAW encoding would need less space fall back to RAW encoding to
920 * save bandwidth and processing power in the client. */
921 if (!encode_raw && vs->write_pixels == vnc_write_pixels_copy &&
922 12 + h * w * VNC_SERVER_FB_BYTES <= (vs->output.offset - saved_offs)) {
923 vs->output.offset = saved_offs;
924 encode_raw = true;
925 }
926
927 if (encode_raw) {
928 vnc_framebuffer_update(vs, x, y, w, h, VNC_ENCODING_RAW);
929 n = vnc_raw_send_framebuffer_update(vs, x, y, w, h);
930 }
931
932 return n;
933 }
934
935 static void vnc_mouse_set(DisplayChangeListener *dcl,
936 int x, int y, int visible)
937 {
938 /* can we ask the client(s) to move the pointer ??? */
939 }
940
941 static int vnc_cursor_define(VncState *vs)
942 {
943 QEMUCursor *c = vs->vd->cursor;
944 int isize;
945
946 if (vnc_has_feature(vs, VNC_FEATURE_RICH_CURSOR)) {
947 vnc_lock_output(vs);
948 vnc_write_u8(vs, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE);
949 vnc_write_u8(vs, 0); /* padding */
950 vnc_write_u16(vs, 1); /* # of rects */
951 vnc_framebuffer_update(vs, c->hot_x, c->hot_y, c->width, c->height,
952 VNC_ENCODING_RICH_CURSOR);
953 isize = c->width * c->height * vs->client_pf.bytes_per_pixel;
954 vnc_write_pixels_generic(vs, c->data, isize);
955 vnc_write(vs, vs->vd->cursor_mask, vs->vd->cursor_msize);
956 vnc_unlock_output(vs);
957 return 0;
958 }
959 return -1;
960 }
961
962 static void vnc_dpy_cursor_define(DisplayChangeListener *dcl,
963 QEMUCursor *c)
964 {
965 VncDisplay *vd = container_of(dcl, VncDisplay, dcl);
966 VncState *vs;
967
968 cursor_put(vd->cursor);
969 g_free(vd->cursor_mask);
970
971 vd->cursor = c;
972 cursor_get(vd->cursor);
973 vd->cursor_msize = cursor_get_mono_bpl(c) * c->height;
974 vd->cursor_mask = g_malloc0(vd->cursor_msize);
975 cursor_get_mono_mask(c, 0, vd->cursor_mask);
976
977 QTAILQ_FOREACH(vs, &vd->clients, next) {
978 vnc_cursor_define(vs);
979 }
980 }
981
982 static int find_and_clear_dirty_height(VncState *vs,
983 int y, int last_x, int x, int height)
984 {
985 int h;
986
987 for (h = 1; h < (height - y); h++) {
988 if (!test_bit(last_x, vs->dirty[y + h])) {
989 break;
990 }
991 bitmap_clear(vs->dirty[y + h], last_x, x - last_x);
992 }
993
994 return h;
995 }
996
997 /*
998 * Figure out how much pending data we should allow in the output
999 * buffer before we throttle incremental display updates, and/or
1000 * drop audio samples.
1001 *
1002 * We allow for equiv of 1 full display's worth of FB updates,
1003 * and 1 second of audio samples. If audio backlog was larger
1004 * than that the client would already suffering awful audio
1005 * glitches, so dropping samples is no worse really).
1006 */
1007 static void vnc_update_throttle_offset(VncState *vs)
1008 {
1009 size_t offset =
1010 vs->client_width * vs->client_height * vs->client_pf.bytes_per_pixel;
1011
1012 if (vs->audio_cap) {
1013 int bps;
1014 switch (vs->as.fmt) {
1015 default:
1016 case AUD_FMT_U8:
1017 case AUD_FMT_S8:
1018 bps = 1;
1019 break;
1020 case AUD_FMT_U16:
1021 case AUD_FMT_S16:
1022 bps = 2;
1023 break;
1024 case AUD_FMT_U32:
1025 case AUD_FMT_S32:
1026 bps = 4;
1027 break;
1028 }
1029 offset += vs->as.freq * bps * vs->as.nchannels;
1030 }
1031
1032 /* Put a floor of 1MB on offset, so that if we have a large pending
1033 * buffer and the display is resized to a small size & back again
1034 * we don't suddenly apply a tiny send limit
1035 */
1036 offset = MAX(offset, 1024 * 1024);
1037
1038 if (vs->throttle_output_offset != offset) {
1039 trace_vnc_client_throttle_threshold(
1040 vs, vs->ioc, vs->throttle_output_offset, offset, vs->client_width,
1041 vs->client_height, vs->client_pf.bytes_per_pixel, vs->audio_cap);
1042 }
1043
1044 vs->throttle_output_offset = offset;
1045 }
1046
1047 static bool vnc_should_update(VncState *vs)
1048 {
1049 switch (vs->update) {
1050 case VNC_STATE_UPDATE_NONE:
1051 break;
1052 case VNC_STATE_UPDATE_INCREMENTAL:
1053 /* Only allow incremental updates if the pending send queue
1054 * is less than the permitted threshold, and the job worker
1055 * is completely idle.
1056 */
1057 if (vs->output.offset < vs->throttle_output_offset &&
1058 vs->job_update == VNC_STATE_UPDATE_NONE) {
1059 return true;
1060 }
1061 trace_vnc_client_throttle_incremental(
1062 vs, vs->ioc, vs->job_update, vs->output.offset);
1063 break;
1064 case VNC_STATE_UPDATE_FORCE:
1065 /* Only allow forced updates if the pending send queue
1066 * does not contain a previous forced update, and the
1067 * job worker is completely idle.
1068 *
1069 * Note this means we'll queue a forced update, even if
1070 * the output buffer size is otherwise over the throttle
1071 * output limit.
1072 */
1073 if (vs->force_update_offset == 0 &&
1074 vs->job_update == VNC_STATE_UPDATE_NONE) {
1075 return true;
1076 }
1077 trace_vnc_client_throttle_forced(
1078 vs, vs->ioc, vs->job_update, vs->force_update_offset);
1079 break;
1080 }
1081 return false;
1082 }
1083
1084 static int vnc_update_client(VncState *vs, int has_dirty)
1085 {
1086 VncDisplay *vd = vs->vd;
1087 VncJob *job;
1088 int y;
1089 int height, width;
1090 int n = 0;
1091
1092 if (vs->disconnecting) {
1093 vnc_disconnect_finish(vs);
1094 return 0;
1095 }
1096
1097 vs->has_dirty += has_dirty;
1098 if (!vnc_should_update(vs)) {
1099 return 0;
1100 }
1101
1102 if (!vs->has_dirty && vs->update != VNC_STATE_UPDATE_FORCE) {
1103 return 0;
1104 }
1105
1106 /*
1107 * Send screen updates to the vnc client using the server
1108 * surface and server dirty map. guest surface updates
1109 * happening in parallel don't disturb us, the next pass will
1110 * send them to the client.
1111 */
1112 job = vnc_job_new(vs);
1113
1114 height = pixman_image_get_height(vd->server);
1115 width = pixman_image_get_width(vd->server);
1116
1117 y = 0;
1118 for (;;) {
1119 int x, h;
1120 unsigned long x2;
1121 unsigned long offset = find_next_bit((unsigned long *) &vs->dirty,
1122 height * VNC_DIRTY_BPL(vs),
1123 y * VNC_DIRTY_BPL(vs));
1124 if (offset == height * VNC_DIRTY_BPL(vs)) {
1125 /* no more dirty bits */
1126 break;
1127 }
1128 y = offset / VNC_DIRTY_BPL(vs);
1129 x = offset % VNC_DIRTY_BPL(vs);
1130 x2 = find_next_zero_bit((unsigned long *) &vs->dirty[y],
1131 VNC_DIRTY_BPL(vs), x);
1132 bitmap_clear(vs->dirty[y], x, x2 - x);
1133 h = find_and_clear_dirty_height(vs, y, x, x2, height);
1134 x2 = MIN(x2, width / VNC_DIRTY_PIXELS_PER_BIT);
1135 if (x2 > x) {
1136 n += vnc_job_add_rect(job, x * VNC_DIRTY_PIXELS_PER_BIT, y,
1137 (x2 - x) * VNC_DIRTY_PIXELS_PER_BIT, h);
1138 }
1139 if (!x && x2 == width / VNC_DIRTY_PIXELS_PER_BIT) {
1140 y += h;
1141 if (y == height) {
1142 break;
1143 }
1144 }
1145 }
1146
1147 vs->job_update = vs->update;
1148 vs->update = VNC_STATE_UPDATE_NONE;
1149 vnc_job_push(job);
1150 vs->has_dirty = 0;
1151 return n;
1152 }
1153
1154 /* audio */
1155 static void audio_capture_notify(void *opaque, audcnotification_e cmd)
1156 {
1157 VncState *vs = opaque;
1158
1159 assert(vs->magic == VNC_MAGIC);
1160 switch (cmd) {
1161 case AUD_CNOTIFY_DISABLE:
1162 vnc_lock_output(vs);
1163 vnc_write_u8(vs, VNC_MSG_SERVER_QEMU);
1164 vnc_write_u8(vs, VNC_MSG_SERVER_QEMU_AUDIO);
1165 vnc_write_u16(vs, VNC_MSG_SERVER_QEMU_AUDIO_END);
1166 vnc_unlock_output(vs);
1167 vnc_flush(vs);
1168 break;
1169
1170 case AUD_CNOTIFY_ENABLE:
1171 vnc_lock_output(vs);
1172 vnc_write_u8(vs, VNC_MSG_SERVER_QEMU);
1173 vnc_write_u8(vs, VNC_MSG_SERVER_QEMU_AUDIO);
1174 vnc_write_u16(vs, VNC_MSG_SERVER_QEMU_AUDIO_BEGIN);
1175 vnc_unlock_output(vs);
1176 vnc_flush(vs);
1177 break;
1178 }
1179 }
1180
1181 static void audio_capture_destroy(void *opaque)
1182 {
1183 }
1184
1185 static void audio_capture(void *opaque, void *buf, int size)
1186 {
1187 VncState *vs = opaque;
1188
1189 assert(vs->magic == VNC_MAGIC);
1190 vnc_lock_output(vs);
1191 if (vs->output.offset < vs->throttle_output_offset) {
1192 vnc_write_u8(vs, VNC_MSG_SERVER_QEMU);
1193 vnc_write_u8(vs, VNC_MSG_SERVER_QEMU_AUDIO);
1194 vnc_write_u16(vs, VNC_MSG_SERVER_QEMU_AUDIO_DATA);
1195 vnc_write_u32(vs, size);
1196 vnc_write(vs, buf, size);
1197 } else {
1198 trace_vnc_client_throttle_audio(vs, vs->ioc, vs->output.offset);
1199 }
1200 vnc_unlock_output(vs);
1201 vnc_flush(vs);
1202 }
1203
1204 static void audio_add(VncState *vs)
1205 {
1206 struct audio_capture_ops ops;
1207
1208 if (vs->audio_cap) {
1209 error_report("audio already running");
1210 return;
1211 }
1212
1213 ops.notify = audio_capture_notify;
1214 ops.destroy = audio_capture_destroy;
1215 ops.capture = audio_capture;
1216
1217 vs->audio_cap = AUD_add_capture(&vs->as, &ops, vs);
1218 if (!vs->audio_cap) {
1219 error_report("Failed to add audio capture");
1220 }
1221 }
1222
1223 static void audio_del(VncState *vs)
1224 {
1225 if (vs->audio_cap) {
1226 AUD_del_capture(vs->audio_cap, vs);
1227 vs->audio_cap = NULL;
1228 }
1229 }
1230
1231 static void vnc_disconnect_start(VncState *vs)
1232 {
1233 if (vs->disconnecting) {
1234 return;
1235 }
1236 trace_vnc_client_disconnect_start(vs, vs->ioc);
1237 vnc_set_share_mode(vs, VNC_SHARE_MODE_DISCONNECTED);
1238 if (vs->ioc_tag) {
1239 g_source_remove(vs->ioc_tag);
1240 vs->ioc_tag = 0;
1241 }
1242 qio_channel_close(vs->ioc, NULL);
1243 vs->disconnecting = TRUE;
1244 }
1245
1246 void vnc_disconnect_finish(VncState *vs)
1247 {
1248 int i;
1249
1250 trace_vnc_client_disconnect_finish(vs, vs->ioc);
1251
1252 vnc_jobs_join(vs); /* Wait encoding jobs */
1253
1254 vnc_lock_output(vs);
1255 vnc_qmp_event(vs, QAPI_EVENT_VNC_DISCONNECTED);
1256
1257 buffer_free(&vs->input);
1258 buffer_free(&vs->output);
1259
1260 qapi_free_VncClientInfo(vs->info);
1261
1262 vnc_zlib_clear(vs);
1263 vnc_tight_clear(vs);
1264 vnc_zrle_clear(vs);
1265
1266 #ifdef CONFIG_VNC_SASL
1267 vnc_sasl_client_cleanup(vs);
1268 #endif /* CONFIG_VNC_SASL */
1269 audio_del(vs);
1270 qkbd_state_lift_all_keys(vs->vd->kbd);
1271
1272 if (vs->mouse_mode_notifier.notify != NULL) {
1273 qemu_remove_mouse_mode_change_notifier(&vs->mouse_mode_notifier);
1274 }
1275 QTAILQ_REMOVE(&vs->vd->clients, vs, next);
1276 if (QTAILQ_EMPTY(&vs->vd->clients)) {
1277 /* last client gone */
1278 vnc_update_server_surface(vs->vd);
1279 }
1280
1281 vnc_unlock_output(vs);
1282
1283 qemu_mutex_destroy(&vs->output_mutex);
1284 if (vs->bh != NULL) {
1285 qemu_bh_delete(vs->bh);
1286 }
1287 buffer_free(&vs->jobs_buffer);
1288
1289 for (i = 0; i < VNC_STAT_ROWS; ++i) {
1290 g_free(vs->lossy_rect[i]);
1291 }
1292 g_free(vs->lossy_rect);
1293
1294 object_unref(OBJECT(vs->ioc));
1295 vs->ioc = NULL;
1296 object_unref(OBJECT(vs->sioc));
1297 vs->sioc = NULL;
1298 vs->magic = 0;
1299 g_free(vs);
1300 }
1301
1302 size_t vnc_client_io_error(VncState *vs, ssize_t ret, Error **errp)
1303 {
1304 if (ret <= 0) {
1305 if (ret == 0) {
1306 trace_vnc_client_eof(vs, vs->ioc);
1307 vnc_disconnect_start(vs);
1308 } else if (ret != QIO_CHANNEL_ERR_BLOCK) {
1309 trace_vnc_client_io_error(vs, vs->ioc,
1310 errp ? error_get_pretty(*errp) :
1311 "Unknown");
1312 vnc_disconnect_start(vs);
1313 }
1314
1315 if (errp) {
1316 error_free(*errp);
1317 *errp = NULL;
1318 }
1319 return 0;
1320 }
1321 return ret;
1322 }
1323
1324
1325 void vnc_client_error(VncState *vs)
1326 {
1327 VNC_DEBUG("Closing down client sock: protocol error\n");
1328 vnc_disconnect_start(vs);
1329 }
1330
1331
1332 /*
1333 * Called to write a chunk of data to the client socket. The data may
1334 * be the raw data, or may have already been encoded by SASL.
1335 * The data will be written either straight onto the socket, or
1336 * written via the GNUTLS wrappers, if TLS/SSL encryption is enabled
1337 *
1338 * NB, it is theoretically possible to have 2 layers of encryption,
1339 * both SASL, and this TLS layer. It is highly unlikely in practice
1340 * though, since SASL encryption will typically be a no-op if TLS
1341 * is active
1342 *
1343 * Returns the number of bytes written, which may be less than
1344 * the requested 'datalen' if the socket would block. Returns
1345 * 0 on I/O error, and disconnects the client socket.
1346 */
1347 size_t vnc_client_write_buf(VncState *vs, const uint8_t *data, size_t datalen)
1348 {
1349 Error *err = NULL;
1350 ssize_t ret;
1351 ret = qio_channel_write(
1352 vs->ioc, (const char *)data, datalen, &err);
1353 VNC_DEBUG("Wrote wire %p %zd -> %ld\n", data, datalen, ret);
1354 return vnc_client_io_error(vs, ret, &err);
1355 }
1356
1357
1358 /*
1359 * Called to write buffered data to the client socket, when not
1360 * using any SASL SSF encryption layers. Will write as much data
1361 * as possible without blocking. If all buffered data is written,
1362 * will switch the FD poll() handler back to read monitoring.
1363 *
1364 * Returns the number of bytes written, which may be less than
1365 * the buffered output data if the socket would block. Returns
1366 * 0 on I/O error, and disconnects the client socket.
1367 */
1368 static size_t vnc_client_write_plain(VncState *vs)
1369 {
1370 size_t offset;
1371 size_t ret;
1372
1373 #ifdef CONFIG_VNC_SASL
1374 VNC_DEBUG("Write Plain: Pending output %p size %zd offset %zd. Wait SSF %d\n",
1375 vs->output.buffer, vs->output.capacity, vs->output.offset,
1376 vs->sasl.waitWriteSSF);
1377
1378 if (vs->sasl.conn &&
1379 vs->sasl.runSSF &&
1380 vs->sasl.waitWriteSSF) {
1381 ret = vnc_client_write_buf(vs, vs->output.buffer, vs->sasl.waitWriteSSF);
1382 if (ret)
1383 vs->sasl.waitWriteSSF -= ret;
1384 } else
1385 #endif /* CONFIG_VNC_SASL */
1386 ret = vnc_client_write_buf(vs, vs->output.buffer, vs->output.offset);
1387 if (!ret)
1388 return 0;
1389
1390 if (ret >= vs->force_update_offset) {
1391 if (vs->force_update_offset != 0) {
1392 trace_vnc_client_unthrottle_forced(vs, vs->ioc);
1393 }
1394 vs->force_update_offset = 0;
1395 } else {
1396 vs->force_update_offset -= ret;
1397 }
1398 offset = vs->output.offset;
1399 buffer_advance(&vs->output, ret);
1400 if (offset >= vs->throttle_output_offset &&
1401 vs->output.offset < vs->throttle_output_offset) {
1402 trace_vnc_client_unthrottle_incremental(vs, vs->ioc, vs->output.offset);
1403 }
1404
1405 if (vs->output.offset == 0) {
1406 if (vs->ioc_tag) {
1407 g_source_remove(vs->ioc_tag);
1408 }
1409 vs->ioc_tag = qio_channel_add_watch(
1410 vs->ioc, G_IO_IN, vnc_client_io, vs, NULL);
1411 }
1412
1413 return ret;
1414 }
1415
1416
1417 /*
1418 * First function called whenever there is data to be written to
1419 * the client socket. Will delegate actual work according to whether
1420 * SASL SSF layers are enabled (thus requiring encryption calls)
1421 */
1422 static void vnc_client_write_locked(VncState *vs)
1423 {
1424 #ifdef CONFIG_VNC_SASL
1425 if (vs->sasl.conn &&
1426 vs->sasl.runSSF &&
1427 !vs->sasl.waitWriteSSF) {
1428 vnc_client_write_sasl(vs);
1429 } else
1430 #endif /* CONFIG_VNC_SASL */
1431 {
1432 vnc_client_write_plain(vs);
1433 }
1434 }
1435
1436 static void vnc_client_write(VncState *vs)
1437 {
1438 assert(vs->magic == VNC_MAGIC);
1439 vnc_lock_output(vs);
1440 if (vs->output.offset) {
1441 vnc_client_write_locked(vs);
1442 } else if (vs->ioc != NULL) {
1443 if (vs->ioc_tag) {
1444 g_source_remove(vs->ioc_tag);
1445 }
1446 vs->ioc_tag = qio_channel_add_watch(
1447 vs->ioc, G_IO_IN, vnc_client_io, vs, NULL);
1448 }
1449 vnc_unlock_output(vs);
1450 }
1451
1452 void vnc_read_when(VncState *vs, VncReadEvent *func, size_t expecting)
1453 {
1454 vs->read_handler = func;
1455 vs->read_handler_expect = expecting;
1456 }
1457
1458
1459 /*
1460 * Called to read a chunk of data from the client socket. The data may
1461 * be the raw data, or may need to be further decoded by SASL.
1462 * The data will be read either straight from to the socket, or
1463 * read via the GNUTLS wrappers, if TLS/SSL encryption is enabled
1464 *
1465 * NB, it is theoretically possible to have 2 layers of encryption,
1466 * both SASL, and this TLS layer. It is highly unlikely in practice
1467 * though, since SASL encryption will typically be a no-op if TLS
1468 * is active
1469 *
1470 * Returns the number of bytes read, which may be less than
1471 * the requested 'datalen' if the socket would block. Returns
1472 * 0 on I/O error or EOF, and disconnects the client socket.
1473 */
1474 size_t vnc_client_read_buf(VncState *vs, uint8_t *data, size_t datalen)
1475 {
1476 ssize_t ret;
1477 Error *err = NULL;
1478 ret = qio_channel_read(
1479 vs->ioc, (char *)data, datalen, &err);
1480 VNC_DEBUG("Read wire %p %zd -> %ld\n", data, datalen, ret);
1481 return vnc_client_io_error(vs, ret, &err);
1482 }
1483
1484
1485 /*
1486 * Called to read data from the client socket to the input buffer,
1487 * when not using any SASL SSF encryption layers. Will read as much
1488 * data as possible without blocking.
1489 *
1490 * Returns the number of bytes read, which may be less than
1491 * the requested 'datalen' if the socket would block. Returns
1492 * 0 on I/O error or EOF, and disconnects the client socket.
1493 */
1494 static size_t vnc_client_read_plain(VncState *vs)
1495 {
1496 size_t ret;
1497 VNC_DEBUG("Read plain %p size %zd offset %zd\n",
1498 vs->input.buffer, vs->input.capacity, vs->input.offset);
1499 buffer_reserve(&vs->input, 4096);
1500 ret = vnc_client_read_buf(vs, buffer_end(&vs->input), 4096);
1501 if (!ret)
1502 return 0;
1503 vs->input.offset += ret;
1504 return ret;
1505 }
1506
1507 static void vnc_jobs_bh(void *opaque)
1508 {
1509 VncState *vs = opaque;
1510
1511 assert(vs->magic == VNC_MAGIC);
1512 vnc_jobs_consume_buffer(vs);
1513 }
1514
1515 /*
1516 * First function called whenever there is more data to be read from
1517 * the client socket. Will delegate actual work according to whether
1518 * SASL SSF layers are enabled (thus requiring decryption calls)
1519 * Returns 0 on success, -1 if client disconnected
1520 */
1521 static int vnc_client_read(VncState *vs)
1522 {
1523 size_t ret;
1524
1525 #ifdef CONFIG_VNC_SASL
1526 if (vs->sasl.conn && vs->sasl.runSSF)
1527 ret = vnc_client_read_sasl(vs);
1528 else
1529 #endif /* CONFIG_VNC_SASL */
1530 ret = vnc_client_read_plain(vs);
1531 if (!ret) {
1532 if (vs->disconnecting) {
1533 vnc_disconnect_finish(vs);
1534 return -1;
1535 }
1536 return 0;
1537 }
1538
1539 while (vs->read_handler && vs->input.offset >= vs->read_handler_expect) {
1540 size_t len = vs->read_handler_expect;
1541 int ret;
1542
1543 ret = vs->read_handler(vs, vs->input.buffer, len);
1544 if (vs->disconnecting) {
1545 vnc_disconnect_finish(vs);
1546 return -1;
1547 }
1548
1549 if (!ret) {
1550 buffer_advance(&vs->input, len);
1551 } else {
1552 vs->read_handler_expect = ret;
1553 }
1554 }
1555 return 0;
1556 }
1557
1558 gboolean vnc_client_io(QIOChannel *ioc G_GNUC_UNUSED,
1559 GIOCondition condition, void *opaque)
1560 {
1561 VncState *vs = opaque;
1562
1563 assert(vs->magic == VNC_MAGIC);
1564 if (condition & G_IO_IN) {
1565 if (vnc_client_read(vs) < 0) {
1566 /* vs is free()ed here */
1567 return TRUE;
1568 }
1569 }
1570 if (condition & G_IO_OUT) {
1571 vnc_client_write(vs);
1572 }
1573
1574 if (vs->disconnecting) {
1575 if (vs->ioc_tag != 0) {
1576 g_source_remove(vs->ioc_tag);
1577 }
1578 vs->ioc_tag = 0;
1579 }
1580 return TRUE;
1581 }
1582
1583
1584 /*
1585 * Scale factor to apply to vs->throttle_output_offset when checking for
1586 * hard limit. Worst case normal usage could be x2, if we have a complete
1587 * incremental update and complete forced update in the output buffer.
1588 * So x3 should be good enough, but we pick x5 to be conservative and thus
1589 * (hopefully) never trigger incorrectly.
1590 */
1591 #define VNC_THROTTLE_OUTPUT_LIMIT_SCALE 5
1592
1593 void vnc_write(VncState *vs, const void *data, size_t len)
1594 {
1595 assert(vs->magic == VNC_MAGIC);
1596 if (vs->disconnecting) {
1597 return;
1598 }
1599 /* Protection against malicious client/guest to prevent our output
1600 * buffer growing without bound if client stops reading data. This
1601 * should rarely trigger, because we have earlier throttling code
1602 * which stops issuing framebuffer updates and drops audio data
1603 * if the throttle_output_offset value is exceeded. So we only reach
1604 * this higher level if a huge number of pseudo-encodings get
1605 * triggered while data can't be sent on the socket.
1606 *
1607 * NB throttle_output_offset can be zero during early protocol
1608 * handshake, or from the job thread's VncState clone
1609 */
1610 if (vs->throttle_output_offset != 0 &&
1611 (vs->output.offset / VNC_THROTTLE_OUTPUT_LIMIT_SCALE) >
1612 vs->throttle_output_offset) {
1613 trace_vnc_client_output_limit(vs, vs->ioc, vs->output.offset,
1614 vs->throttle_output_offset);
1615 vnc_disconnect_start(vs);
1616 return;
1617 }
1618 buffer_reserve(&vs->output, len);
1619
1620 if (vs->ioc != NULL && buffer_empty(&vs->output)) {
1621 if (vs->ioc_tag) {
1622 g_source_remove(vs->ioc_tag);
1623 }
1624 vs->ioc_tag = qio_channel_add_watch(
1625 vs->ioc, G_IO_IN | G_IO_OUT, vnc_client_io, vs, NULL);
1626 }
1627
1628 buffer_append(&vs->output, data, len);
1629 }
1630
1631 void vnc_write_s32(VncState *vs, int32_t value)
1632 {
1633 vnc_write_u32(vs, *(uint32_t *)&value);
1634 }
1635
1636 void vnc_write_u32(VncState *vs, uint32_t value)
1637 {
1638 uint8_t buf[4];
1639
1640 buf[0] = (value >> 24) & 0xFF;
1641 buf[1] = (value >> 16) & 0xFF;
1642 buf[2] = (value >> 8) & 0xFF;
1643 buf[3] = value & 0xFF;
1644
1645 vnc_write(vs, buf, 4);
1646 }
1647
1648 void vnc_write_u16(VncState *vs, uint16_t value)
1649 {
1650 uint8_t buf[2];
1651
1652 buf[0] = (value >> 8) & 0xFF;
1653 buf[1] = value & 0xFF;
1654
1655 vnc_write(vs, buf, 2);
1656 }
1657
1658 void vnc_write_u8(VncState *vs, uint8_t value)
1659 {
1660 vnc_write(vs, (char *)&value, 1);
1661 }
1662
1663 void vnc_flush(VncState *vs)
1664 {
1665 vnc_lock_output(vs);
1666 if (vs->ioc != NULL && vs->output.offset) {
1667 vnc_client_write_locked(vs);
1668 }
1669 if (vs->disconnecting) {
1670 if (vs->ioc_tag != 0) {
1671 g_source_remove(vs->ioc_tag);
1672 }
1673 vs->ioc_tag = 0;
1674 }
1675 vnc_unlock_output(vs);
1676 }
1677
1678 static uint8_t read_u8(uint8_t *data, size_t offset)
1679 {
1680 return data[offset];
1681 }
1682
1683 static uint16_t read_u16(uint8_t *data, size_t offset)
1684 {
1685 return ((data[offset] & 0xFF) << 8) | (data[offset + 1] & 0xFF);
1686 }
1687
1688 static int32_t read_s32(uint8_t *data, size_t offset)
1689 {
1690 return (int32_t)((data[offset] << 24) | (data[offset + 1] << 16) |
1691 (data[offset + 2] << 8) | data[offset + 3]);
1692 }
1693
1694 uint32_t read_u32(uint8_t *data, size_t offset)
1695 {
1696 return ((data[offset] << 24) | (data[offset + 1] << 16) |
1697 (data[offset + 2] << 8) | data[offset + 3]);
1698 }
1699
1700 static void client_cut_text(VncState *vs, size_t len, uint8_t *text)
1701 {
1702 }
1703
1704 static void check_pointer_type_change(Notifier *notifier, void *data)
1705 {
1706 VncState *vs = container_of(notifier, VncState, mouse_mode_notifier);
1707 int absolute = qemu_input_is_absolute();
1708
1709 if (vnc_has_feature(vs, VNC_FEATURE_POINTER_TYPE_CHANGE) && vs->absolute != absolute) {
1710 vnc_lock_output(vs);
1711 vnc_write_u8(vs, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE);
1712 vnc_write_u8(vs, 0);
1713 vnc_write_u16(vs, 1);
1714 vnc_framebuffer_update(vs, absolute, 0,
1715 pixman_image_get_width(vs->vd->server),
1716 pixman_image_get_height(vs->vd->server),
1717 VNC_ENCODING_POINTER_TYPE_CHANGE);
1718 vnc_unlock_output(vs);
1719 vnc_flush(vs);
1720 }
1721 vs->absolute = absolute;
1722 }
1723
1724 static void pointer_event(VncState *vs, int button_mask, int x, int y)
1725 {
1726 static uint32_t bmap[INPUT_BUTTON__MAX] = {
1727 [INPUT_BUTTON_LEFT] = 0x01,
1728 [INPUT_BUTTON_MIDDLE] = 0x02,
1729 [INPUT_BUTTON_RIGHT] = 0x04,
1730 [INPUT_BUTTON_WHEEL_UP] = 0x08,
1731 [INPUT_BUTTON_WHEEL_DOWN] = 0x10,
1732 };
1733 QemuConsole *con = vs->vd->dcl.con;
1734 int width = pixman_image_get_width(vs->vd->server);
1735 int height = pixman_image_get_height(vs->vd->server);
1736
1737 if (vs->last_bmask != button_mask) {
1738 qemu_input_update_buttons(con, bmap, vs->last_bmask, button_mask);
1739 vs->last_bmask = button_mask;
1740 }
1741
1742 if (vs->absolute) {
1743 qemu_input_queue_abs(con, INPUT_AXIS_X, x, 0, width);
1744 qemu_input_queue_abs(con, INPUT_AXIS_Y, y, 0, height);
1745 } else if (vnc_has_feature(vs, VNC_FEATURE_POINTER_TYPE_CHANGE)) {
1746 qemu_input_queue_rel(con, INPUT_AXIS_X, x - 0x7FFF);
1747 qemu_input_queue_rel(con, INPUT_AXIS_Y, y - 0x7FFF);
1748 } else {
1749 if (vs->last_x != -1) {
1750 qemu_input_queue_rel(con, INPUT_AXIS_X, x - vs->last_x);
1751 qemu_input_queue_rel(con, INPUT_AXIS_Y, y - vs->last_y);
1752 }
1753 vs->last_x = x;
1754 vs->last_y = y;
1755 }
1756 qemu_input_event_sync();
1757 }
1758
1759 static void press_key(VncState *vs, QKeyCode qcode)
1760 {
1761 qkbd_state_key_event(vs->vd->kbd, qcode, true);
1762 qkbd_state_key_event(vs->vd->kbd, qcode, false);
1763 }
1764
1765 static void vnc_led_state_change(VncState *vs)
1766 {
1767 if (!vnc_has_feature(vs, VNC_FEATURE_LED_STATE)) {
1768 return;
1769 }
1770
1771 vnc_lock_output(vs);
1772 vnc_write_u8(vs, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE);
1773 vnc_write_u8(vs, 0);
1774 vnc_write_u16(vs, 1);
1775 vnc_framebuffer_update(vs, 0, 0, 1, 1, VNC_ENCODING_LED_STATE);
1776 vnc_write_u8(vs, vs->vd->ledstate);
1777 vnc_unlock_output(vs);
1778 vnc_flush(vs);
1779 }
1780
1781 static void kbd_leds(void *opaque, int ledstate)
1782 {
1783 VncDisplay *vd = opaque;
1784 VncState *client;
1785
1786 trace_vnc_key_guest_leds((ledstate & QEMU_CAPS_LOCK_LED),
1787 (ledstate & QEMU_NUM_LOCK_LED),
1788 (ledstate & QEMU_SCROLL_LOCK_LED));
1789
1790 if (ledstate == vd->ledstate) {
1791 return;
1792 }
1793
1794 vd->ledstate = ledstate;
1795
1796 QTAILQ_FOREACH(client, &vd->clients, next) {
1797 vnc_led_state_change(client);
1798 }
1799 }
1800
1801 static void do_key_event(VncState *vs, int down, int keycode, int sym)
1802 {
1803 QKeyCode qcode = qemu_input_key_number_to_qcode(keycode);
1804
1805 /* QEMU console switch */
1806 switch (qcode) {
1807 case Q_KEY_CODE_1 ... Q_KEY_CODE_9: /* '1' to '9' keys */
1808 if (vs->vd->dcl.con == NULL && down &&
1809 qkbd_state_modifier_get(vs->vd->kbd, QKBD_MOD_CTRL) &&
1810 qkbd_state_modifier_get(vs->vd->kbd, QKBD_MOD_ALT)) {
1811 /* Reset the modifiers sent to the current console */
1812 qkbd_state_lift_all_keys(vs->vd->kbd);
1813 console_select(qcode - Q_KEY_CODE_1);
1814 return;
1815 }
1816 default:
1817 break;
1818 }
1819
1820 /* Turn off the lock state sync logic if the client support the led
1821 state extension.
1822 */
1823 if (down && vs->vd->lock_key_sync &&
1824 !vnc_has_feature(vs, VNC_FEATURE_LED_STATE) &&
1825 keycode_is_keypad(vs->vd->kbd_layout, keycode)) {
1826 /* If the numlock state needs to change then simulate an additional
1827 keypress before sending this one. This will happen if the user
1828 toggles numlock away from the VNC window.
1829 */
1830 if (keysym_is_numlock(vs->vd->kbd_layout, sym & 0xFFFF)) {
1831 if (!qkbd_state_modifier_get(vs->vd->kbd, QKBD_MOD_NUMLOCK)) {
1832 trace_vnc_key_sync_numlock(true);
1833 press_key(vs, Q_KEY_CODE_NUM_LOCK);
1834 }
1835 } else {
1836 if (qkbd_state_modifier_get(vs->vd->kbd, QKBD_MOD_NUMLOCK)) {
1837 trace_vnc_key_sync_numlock(false);
1838 press_key(vs, Q_KEY_CODE_NUM_LOCK);
1839 }
1840 }
1841 }
1842
1843 if (down && vs->vd->lock_key_sync &&
1844 !vnc_has_feature(vs, VNC_FEATURE_LED_STATE) &&
1845 ((sym >= 'A' && sym <= 'Z') || (sym >= 'a' && sym <= 'z'))) {
1846 /* If the capslock state needs to change then simulate an additional
1847 keypress before sending this one. This will happen if the user
1848 toggles capslock away from the VNC window.
1849 */
1850 int uppercase = !!(sym >= 'A' && sym <= 'Z');
1851 bool shift = qkbd_state_modifier_get(vs->vd->kbd, QKBD_MOD_SHIFT);
1852 bool capslock = qkbd_state_modifier_get(vs->vd->kbd, QKBD_MOD_CAPSLOCK);
1853 if (capslock) {
1854 if (uppercase == shift) {
1855 trace_vnc_key_sync_capslock(false);
1856 press_key(vs, Q_KEY_CODE_CAPS_LOCK);
1857 }
1858 } else {
1859 if (uppercase != shift) {
1860 trace_vnc_key_sync_capslock(true);
1861 press_key(vs, Q_KEY_CODE_CAPS_LOCK);
1862 }
1863 }
1864 }
1865
1866 qkbd_state_key_event(vs->vd->kbd, qcode, down);
1867 if (!qemu_console_is_graphic(NULL)) {
1868 bool numlock = qkbd_state_modifier_get(vs->vd->kbd, QKBD_MOD_NUMLOCK);
1869 bool control = qkbd_state_modifier_get(vs->vd->kbd, QKBD_MOD_CTRL);
1870 /* QEMU console emulation */
1871 if (down) {
1872 switch (keycode) {
1873 case 0x2a: /* Left Shift */
1874 case 0x36: /* Right Shift */
1875 case 0x1d: /* Left CTRL */
1876 case 0x9d: /* Right CTRL */
1877 case 0x38: /* Left ALT */
1878 case 0xb8: /* Right ALT */
1879 break;
1880 case 0xc8:
1881 kbd_put_keysym(QEMU_KEY_UP);
1882 break;
1883 case 0xd0:
1884 kbd_put_keysym(QEMU_KEY_DOWN);
1885 break;
1886 case 0xcb:
1887 kbd_put_keysym(QEMU_KEY_LEFT);
1888 break;
1889 case 0xcd:
1890 kbd_put_keysym(QEMU_KEY_RIGHT);
1891 break;
1892 case 0xd3:
1893 kbd_put_keysym(QEMU_KEY_DELETE);
1894 break;
1895 case 0xc7:
1896 kbd_put_keysym(QEMU_KEY_HOME);
1897 break;
1898 case 0xcf:
1899 kbd_put_keysym(QEMU_KEY_END);
1900 break;
1901 case 0xc9:
1902 kbd_put_keysym(QEMU_KEY_PAGEUP);
1903 break;
1904 case 0xd1:
1905 kbd_put_keysym(QEMU_KEY_PAGEDOWN);
1906 break;
1907
1908 case 0x47:
1909 kbd_put_keysym(numlock ? '7' : QEMU_KEY_HOME);
1910 break;
1911 case 0x48:
1912 kbd_put_keysym(numlock ? '8' : QEMU_KEY_UP);
1913 break;
1914 case 0x49:
1915 kbd_put_keysym(numlock ? '9' : QEMU_KEY_PAGEUP);
1916 break;
1917 case 0x4b:
1918 kbd_put_keysym(numlock ? '4' : QEMU_KEY_LEFT);
1919 break;
1920 case 0x4c:
1921 kbd_put_keysym('5');
1922 break;
1923 case 0x4d:
1924 kbd_put_keysym(numlock ? '6' : QEMU_KEY_RIGHT);
1925 break;
1926 case 0x4f:
1927 kbd_put_keysym(numlock ? '1' : QEMU_KEY_END);
1928 break;
1929 case 0x50:
1930 kbd_put_keysym(numlock ? '2' : QEMU_KEY_DOWN);
1931 break;
1932 case 0x51:
1933 kbd_put_keysym(numlock ? '3' : QEMU_KEY_PAGEDOWN);
1934 break;
1935 case 0x52:
1936 kbd_put_keysym('0');
1937 break;
1938 case 0x53:
1939 kbd_put_keysym(numlock ? '.' : QEMU_KEY_DELETE);
1940 break;
1941
1942 case 0xb5:
1943 kbd_put_keysym('/');
1944 break;
1945 case 0x37:
1946 kbd_put_keysym('*');
1947 break;
1948 case 0x4a:
1949 kbd_put_keysym('-');
1950 break;
1951 case 0x4e:
1952 kbd_put_keysym('+');
1953 break;
1954 case 0x9c:
1955 kbd_put_keysym('\n');
1956 break;
1957
1958 default:
1959 if (control) {
1960 kbd_put_keysym(sym & 0x1f);
1961 } else {
1962 kbd_put_keysym(sym);
1963 }
1964 break;
1965 }
1966 }
1967 }
1968 }
1969
1970 static const char *code2name(int keycode)
1971 {
1972 return QKeyCode_str(qemu_input_key_number_to_qcode(keycode));
1973 }
1974
1975 static void key_event(VncState *vs, int down, uint32_t sym)
1976 {
1977 int keycode;
1978 int lsym = sym;
1979
1980 if (lsym >= 'A' && lsym <= 'Z' && qemu_console_is_graphic(NULL)) {
1981 lsym = lsym - 'A' + 'a';
1982 }
1983
1984 keycode = keysym2scancode(vs->vd->kbd_layout, lsym & 0xFFFF,
1985 vs->vd->kbd, down) & SCANCODE_KEYMASK;
1986 trace_vnc_key_event_map(down, sym, keycode, code2name(keycode));
1987 do_key_event(vs, down, keycode, sym);
1988 }
1989
1990 static void ext_key_event(VncState *vs, int down,
1991 uint32_t sym, uint16_t keycode)
1992 {
1993 /* if the user specifies a keyboard layout, always use it */
1994 if (keyboard_layout) {
1995 key_event(vs, down, sym);
1996 } else {
1997 trace_vnc_key_event_ext(down, sym, keycode, code2name(keycode));
1998 do_key_event(vs, down, keycode, sym);
1999 }
2000 }
2001
2002 static void framebuffer_update_request(VncState *vs, int incremental,
2003 int x, int y, int w, int h)
2004 {
2005 if (incremental) {
2006 if (vs->update != VNC_STATE_UPDATE_FORCE) {
2007 vs->update = VNC_STATE_UPDATE_INCREMENTAL;
2008 }
2009 } else {
2010 vs->update = VNC_STATE_UPDATE_FORCE;
2011 vnc_set_area_dirty(vs->dirty, vs->vd, x, y, w, h);
2012 }
2013 }
2014
2015 static void send_ext_key_event_ack(VncState *vs)
2016 {
2017 vnc_lock_output(vs);
2018 vnc_write_u8(vs, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE);
2019 vnc_write_u8(vs, 0);
2020 vnc_write_u16(vs, 1);
2021 vnc_framebuffer_update(vs, 0, 0,
2022 pixman_image_get_width(vs->vd->server),
2023 pixman_image_get_height(vs->vd->server),
2024 VNC_ENCODING_EXT_KEY_EVENT);
2025 vnc_unlock_output(vs);
2026 vnc_flush(vs);
2027 }
2028
2029 static void send_ext_audio_ack(VncState *vs)
2030 {
2031 vnc_lock_output(vs);
2032 vnc_write_u8(vs, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE);
2033 vnc_write_u8(vs, 0);
2034 vnc_write_u16(vs, 1);
2035 vnc_framebuffer_update(vs, 0, 0,
2036 pixman_image_get_width(vs->vd->server),
2037 pixman_image_get_height(vs->vd->server),
2038 VNC_ENCODING_AUDIO);
2039 vnc_unlock_output(vs);
2040 vnc_flush(vs);
2041 }
2042
2043 static void set_encodings(VncState *vs, int32_t *encodings, size_t n_encodings)
2044 {
2045 int i;
2046 unsigned int enc = 0;
2047
2048 vs->features = 0;
2049 vs->vnc_encoding = 0;
2050 vs->tight.compression = 9;
2051 vs->tight.quality = -1; /* Lossless by default */
2052 vs->absolute = -1;
2053
2054 /*
2055 * Start from the end because the encodings are sent in order of preference.
2056 * This way the preferred encoding (first encoding defined in the array)
2057 * will be set at the end of the loop.
2058 */
2059 for (i = n_encodings - 1; i >= 0; i--) {
2060 enc = encodings[i];
2061 switch (enc) {
2062 case VNC_ENCODING_RAW:
2063 vs->vnc_encoding = enc;
2064 break;
2065 case VNC_ENCODING_COPYRECT:
2066 vs->features |= VNC_FEATURE_COPYRECT_MASK;
2067 break;
2068 case VNC_ENCODING_HEXTILE:
2069 vs->features |= VNC_FEATURE_HEXTILE_MASK;
2070 vs->vnc_encoding = enc;
2071 break;
2072 case VNC_ENCODING_TIGHT:
2073 vs->features |= VNC_FEATURE_TIGHT_MASK;
2074 vs->vnc_encoding = enc;
2075 break;
2076 #ifdef CONFIG_VNC_PNG
2077 case VNC_ENCODING_TIGHT_PNG:
2078 vs->features |= VNC_FEATURE_TIGHT_PNG_MASK;
2079 vs->vnc_encoding = enc;
2080 break;
2081 #endif
2082 case VNC_ENCODING_ZLIB:
2083 vs->features |= VNC_FEATURE_ZLIB_MASK;
2084 vs->vnc_encoding = enc;
2085 break;
2086 case VNC_ENCODING_ZRLE:
2087 vs->features |= VNC_FEATURE_ZRLE_MASK;
2088 vs->vnc_encoding = enc;
2089 break;
2090 case VNC_ENCODING_ZYWRLE:
2091 vs->features |= VNC_FEATURE_ZYWRLE_MASK;
2092 vs->vnc_encoding = enc;
2093 break;
2094 case VNC_ENCODING_DESKTOPRESIZE:
2095 vs->features |= VNC_FEATURE_RESIZE_MASK;
2096 break;
2097 case VNC_ENCODING_POINTER_TYPE_CHANGE:
2098 vs->features |= VNC_FEATURE_POINTER_TYPE_CHANGE_MASK;
2099 break;
2100 case VNC_ENCODING_RICH_CURSOR:
2101 vs->features |= VNC_FEATURE_RICH_CURSOR_MASK;
2102 if (vs->vd->cursor) {
2103 vnc_cursor_define(vs);
2104 }
2105 break;
2106 case VNC_ENCODING_EXT_KEY_EVENT:
2107 send_ext_key_event_ack(vs);
2108 break;
2109 case VNC_ENCODING_AUDIO:
2110 send_ext_audio_ack(vs);
2111 break;
2112 case VNC_ENCODING_WMVi:
2113 vs->features |= VNC_FEATURE_WMVI_MASK;
2114 break;
2115 case VNC_ENCODING_LED_STATE:
2116 vs->features |= VNC_FEATURE_LED_STATE_MASK;
2117 break;
2118 case VNC_ENCODING_COMPRESSLEVEL0 ... VNC_ENCODING_COMPRESSLEVEL0 + 9:
2119 vs->tight.compression = (enc & 0x0F);
2120 break;
2121 case VNC_ENCODING_QUALITYLEVEL0 ... VNC_ENCODING_QUALITYLEVEL0 + 9:
2122 if (vs->vd->lossy) {
2123 vs->tight.quality = (enc & 0x0F);
2124 }
2125 break;
2126 default:
2127 VNC_DEBUG("Unknown encoding: %d (0x%.8x): %d\n", i, enc, enc);
2128 break;
2129 }
2130 }
2131 vnc_desktop_resize(vs);
2132 check_pointer_type_change(&vs->mouse_mode_notifier, NULL);
2133 vnc_led_state_change(vs);
2134 }
2135
2136 static void set_pixel_conversion(VncState *vs)
2137 {
2138 pixman_format_code_t fmt = qemu_pixman_get_format(&vs->client_pf);
2139
2140 if (fmt == VNC_SERVER_FB_FORMAT) {
2141 vs->write_pixels = vnc_write_pixels_copy;
2142 vnc_hextile_set_pixel_conversion(vs, 0);
2143 } else {
2144 vs->write_pixels = vnc_write_pixels_generic;
2145 vnc_hextile_set_pixel_conversion(vs, 1);
2146 }
2147 }
2148
2149 static void send_color_map(VncState *vs)
2150 {
2151 int i;
2152
2153 vnc_write_u8(vs, VNC_MSG_SERVER_SET_COLOUR_MAP_ENTRIES);
2154 vnc_write_u8(vs, 0); /* padding */
2155 vnc_write_u16(vs, 0); /* first color */
2156 vnc_write_u16(vs, 256); /* # of colors */
2157
2158 for (i = 0; i < 256; i++) {
2159 PixelFormat *pf = &vs->client_pf;
2160
2161 vnc_write_u16(vs, (((i >> pf->rshift) & pf->rmax) << (16 - pf->rbits)));
2162 vnc_write_u16(vs, (((i >> pf->gshift) & pf->gmax) << (16 - pf->gbits)));
2163 vnc_write_u16(vs, (((i >> pf->bshift) & pf->bmax) << (16 - pf->bbits)));
2164 }
2165 }
2166
2167 static void set_pixel_format(VncState *vs, int bits_per_pixel,
2168 int big_endian_flag, int true_color_flag,
2169 int red_max, int green_max, int blue_max,
2170 int red_shift, int green_shift, int blue_shift)
2171 {
2172 if (!true_color_flag) {
2173 /* Expose a reasonable default 256 color map */
2174 bits_per_pixel = 8;
2175 red_max = 7;
2176 green_max = 7;
2177 blue_max = 3;
2178 red_shift = 0;
2179 green_shift = 3;
2180 blue_shift = 6;
2181 }
2182
2183 switch (bits_per_pixel) {
2184 case 8:
2185 case 16:
2186 case 32:
2187 break;
2188 default:
2189 vnc_client_error(vs);
2190 return;
2191 }
2192
2193 vs->client_pf.rmax = red_max ? red_max : 0xFF;
2194 vs->client_pf.rbits = ctpopl(red_max);
2195 vs->client_pf.rshift = red_shift;
2196 vs->client_pf.rmask = red_max << red_shift;
2197 vs->client_pf.gmax = green_max ? green_max : 0xFF;
2198 vs->client_pf.gbits = ctpopl(green_max);
2199 vs->client_pf.gshift = green_shift;
2200 vs->client_pf.gmask = green_max << green_shift;
2201 vs->client_pf.bmax = blue_max ? blue_max : 0xFF;
2202 vs->client_pf.bbits = ctpopl(blue_max);
2203 vs->client_pf.bshift = blue_shift;
2204 vs->client_pf.bmask = blue_max << blue_shift;
2205 vs->client_pf.bits_per_pixel = bits_per_pixel;
2206 vs->client_pf.bytes_per_pixel = bits_per_pixel / 8;
2207 vs->client_pf.depth = bits_per_pixel == 32 ? 24 : bits_per_pixel;
2208 vs->client_be = big_endian_flag;
2209
2210 if (!true_color_flag) {
2211 send_color_map(vs);
2212 }
2213
2214 set_pixel_conversion(vs);
2215
2216 graphic_hw_invalidate(vs->vd->dcl.con);
2217 graphic_hw_update(vs->vd->dcl.con);
2218 }
2219
2220 static void pixel_format_message (VncState *vs) {
2221 char pad[3] = { 0, 0, 0 };
2222
2223 vs->client_pf = qemu_default_pixelformat(32);
2224
2225 vnc_write_u8(vs, vs->client_pf.bits_per_pixel); /* bits-per-pixel */
2226 vnc_write_u8(vs, vs->client_pf.depth); /* depth */
2227
2228 #ifdef HOST_WORDS_BIGENDIAN
2229 vnc_write_u8(vs, 1); /* big-endian-flag */
2230 #else
2231 vnc_write_u8(vs, 0); /* big-endian-flag */
2232 #endif
2233 vnc_write_u8(vs, 1); /* true-color-flag */
2234 vnc_write_u16(vs, vs->client_pf.rmax); /* red-max */
2235 vnc_write_u16(vs, vs->client_pf.gmax); /* green-max */
2236 vnc_write_u16(vs, vs->client_pf.bmax); /* blue-max */
2237 vnc_write_u8(vs, vs->client_pf.rshift); /* red-shift */
2238 vnc_write_u8(vs, vs->client_pf.gshift); /* green-shift */
2239 vnc_write_u8(vs, vs->client_pf.bshift); /* blue-shift */
2240 vnc_write(vs, pad, 3); /* padding */
2241
2242 vnc_hextile_set_pixel_conversion(vs, 0);
2243 vs->write_pixels = vnc_write_pixels_copy;
2244 }
2245
2246 static void vnc_colordepth(VncState *vs)
2247 {
2248 if (vnc_has_feature(vs, VNC_FEATURE_WMVI)) {
2249 /* Sending a WMVi message to notify the client*/
2250 vnc_lock_output(vs);
2251 vnc_write_u8(vs, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE);
2252 vnc_write_u8(vs, 0);
2253 vnc_write_u16(vs, 1); /* number of rects */
2254 vnc_framebuffer_update(vs, 0, 0,
2255 pixman_image_get_width(vs->vd->server),
2256 pixman_image_get_height(vs->vd->server),
2257 VNC_ENCODING_WMVi);
2258 pixel_format_message(vs);
2259 vnc_unlock_output(vs);
2260 vnc_flush(vs);
2261 } else {
2262 set_pixel_conversion(vs);
2263 }
2264 }
2265
2266 static int protocol_client_msg(VncState *vs, uint8_t *data, size_t len)
2267 {
2268 int i;
2269 uint16_t limit;
2270 uint32_t freq;
2271 VncDisplay *vd = vs->vd;
2272
2273 if (data[0] > 3) {
2274 update_displaychangelistener(&vd->dcl, VNC_REFRESH_INTERVAL_BASE);
2275 }
2276
2277 switch (data[0]) {
2278 case VNC_MSG_CLIENT_SET_PIXEL_FORMAT:
2279 if (len == 1)
2280 return 20;
2281
2282 set_pixel_format(vs, read_u8(data, 4),
2283 read_u8(data, 6), read_u8(data, 7),
2284 read_u16(data, 8), read_u16(data, 10),
2285 read_u16(data, 12), read_u8(data, 14),
2286 read_u8(data, 15), read_u8(data, 16));
2287 break;
2288 case VNC_MSG_CLIENT_SET_ENCODINGS:
2289 if (len == 1)
2290 return 4;
2291
2292 if (len == 4) {
2293 limit = read_u16(data, 2);
2294 if (limit > 0)
2295 return 4 + (limit * 4);
2296 } else
2297 limit = read_u16(data, 2);
2298
2299 for (i = 0; i < limit; i++) {
2300 int32_t val = read_s32(data, 4 + (i * 4));
2301 memcpy(data + 4 + (i * 4), &val, sizeof(val));
2302 }
2303
2304 set_encodings(vs, (int32_t *)(data + 4), limit);
2305 break;
2306 case VNC_MSG_CLIENT_FRAMEBUFFER_UPDATE_REQUEST:
2307 if (len == 1)
2308 return 10;
2309
2310 framebuffer_update_request(vs,
2311 read_u8(data, 1), read_u16(data, 2), read_u16(data, 4),
2312 read_u16(data, 6), read_u16(data, 8));
2313 break;
2314 case VNC_MSG_CLIENT_KEY_EVENT:
2315 if (len == 1)
2316 return 8;
2317
2318 key_event(vs, read_u8(data, 1), read_u32(data, 4));
2319 break;
2320 case VNC_MSG_CLIENT_POINTER_EVENT:
2321 if (len == 1)
2322 return 6;
2323
2324 pointer_event(vs, read_u8(data, 1), read_u16(data, 2), read_u16(data, 4));
2325 break;
2326 case VNC_MSG_CLIENT_CUT_TEXT:
2327 if (len == 1) {
2328 return 8;
2329 }
2330 if (len == 8) {
2331 uint32_t dlen = read_u32(data, 4);
2332 if (dlen > (1 << 20)) {
2333 error_report("vnc: client_cut_text msg payload has %u bytes"
2334 " which exceeds our limit of 1MB.", dlen);
2335 vnc_client_error(vs);
2336 break;
2337 }
2338 if (dlen > 0) {
2339 return 8 + dlen;
2340 }
2341 }
2342
2343 client_cut_text(vs, read_u32(data, 4), data + 8);
2344 break;
2345 case VNC_MSG_CLIENT_QEMU:
2346 if (len == 1)
2347 return 2;
2348
2349 switch (read_u8(data, 1)) {
2350 case VNC_MSG_CLIENT_QEMU_EXT_KEY_EVENT:
2351 if (len == 2)
2352 return 12;
2353
2354 ext_key_event(vs, read_u16(data, 2),
2355 read_u32(data, 4), read_u32(data, 8));
2356 break;
2357 case VNC_MSG_CLIENT_QEMU_AUDIO:
2358 if (len == 2)
2359 return 4;
2360
2361 switch (read_u16 (data, 2)) {
2362 case VNC_MSG_CLIENT_QEMU_AUDIO_ENABLE:
2363 audio_add(vs);
2364 break;
2365 case VNC_MSG_CLIENT_QEMU_AUDIO_DISABLE:
2366 audio_del(vs);
2367 break;
2368 case VNC_MSG_CLIENT_QEMU_AUDIO_SET_FORMAT:
2369 if (len == 4)
2370 return 10;
2371 switch (read_u8(data, 4)) {
2372 case 0: vs->as.fmt = AUD_FMT_U8; break;
2373 case 1: vs->as.fmt = AUD_FMT_S8; break;
2374 case 2: vs->as.fmt = AUD_FMT_U16; break;
2375 case 3: vs->as.fmt = AUD_FMT_S16; break;
2376 case 4: vs->as.fmt = AUD_FMT_U32; break;
2377 case 5: vs->as.fmt = AUD_FMT_S32; break;
2378 default:
2379 VNC_DEBUG("Invalid audio format %d\n", read_u8(data, 4));
2380 vnc_client_error(vs);
2381 break;
2382 }
2383 vs->as.nchannels = read_u8(data, 5);
2384 if (vs->as.nchannels != 1 && vs->as.nchannels != 2) {
2385 VNC_DEBUG("Invalid audio channel count %d\n",
2386 read_u8(data, 5));
2387 vnc_client_error(vs);
2388 break;
2389 }
2390 freq = read_u32(data, 6);
2391 /* No official limit for protocol, but 48khz is a sensible
2392 * upper bound for trustworthy clients, and this limit
2393 * protects calculations involving 'vs->as.freq' later.
2394 */
2395 if (freq > 48000) {
2396 VNC_DEBUG("Invalid audio frequency %u > 48000", freq);
2397 vnc_client_error(vs);
2398 break;
2399 }
2400 vs->as.freq = freq;
2401 break;
2402 default:
2403 VNC_DEBUG("Invalid audio message %d\n", read_u8(data, 4));
2404 vnc_client_error(vs);
2405 break;
2406 }
2407 break;
2408
2409 default:
2410 VNC_DEBUG("Msg: %d\n", read_u16(data, 0));
2411 vnc_client_error(vs);
2412 break;
2413 }
2414 break;
2415 default:
2416 VNC_DEBUG("Msg: %d\n", data[0]);
2417 vnc_client_error(vs);
2418 break;
2419 }
2420
2421 vnc_update_throttle_offset(vs);
2422 vnc_read_when(vs, protocol_client_msg, 1);
2423 return 0;
2424 }
2425
2426 static int protocol_client_init(VncState *vs, uint8_t *data, size_t len)
2427 {
2428 char buf[1024];
2429 VncShareMode mode;
2430 int size;
2431
2432 mode = data[0] ? VNC_SHARE_MODE_SHARED : VNC_SHARE_MODE_EXCLUSIVE;
2433 switch (vs->vd->share_policy) {
2434 case VNC_SHARE_POLICY_IGNORE:
2435 /*
2436 * Ignore the shared flag. Nothing to do here.
2437 *
2438 * Doesn't conform to the rfb spec but is traditional qemu
2439 * behavior, thus left here as option for compatibility
2440 * reasons.
2441 */
2442 break;
2443 case VNC_SHARE_POLICY_ALLOW_EXCLUSIVE:
2444 /*
2445 * Policy: Allow clients ask for exclusive access.
2446 *
2447 * Implementation: When a client asks for exclusive access,
2448 * disconnect all others. Shared connects are allowed as long
2449 * as no exclusive connection exists.
2450 *
2451 * This is how the rfb spec suggests to handle the shared flag.
2452 */
2453 if (mode == VNC_SHARE_MODE_EXCLUSIVE) {
2454 VncState *client;
2455 QTAILQ_FOREACH(client, &vs->vd->clients, next) {
2456 if (vs == client) {
2457 continue;
2458 }
2459 if (client->share_mode != VNC_SHARE_MODE_EXCLUSIVE &&
2460 client->share_mode != VNC_SHARE_MODE_SHARED) {
2461 continue;
2462 }
2463 vnc_disconnect_start(client);
2464 }
2465 }
2466 if (mode == VNC_SHARE_MODE_SHARED) {
2467 if (vs->vd->num_exclusive > 0) {
2468 vnc_disconnect_start(vs);
2469 return 0;
2470 }
2471 }
2472 break;
2473 case VNC_SHARE_POLICY_FORCE_SHARED:
2474 /*
2475 * Policy: Shared connects only.
2476 * Implementation: Disallow clients asking for exclusive access.
2477 *
2478 * Useful for shared desktop sessions where you don't want
2479 * someone forgetting to say -shared when running the vnc
2480 * client disconnect everybody else.
2481 */
2482 if (mode == VNC_SHARE_MODE_EXCLUSIVE) {
2483 vnc_disconnect_start(vs);
2484 return 0;
2485 }
2486 break;
2487 }
2488 vnc_set_share_mode(vs, mode);
2489
2490 if (vs->vd->num_shared > vs->vd->connections_limit) {
2491 vnc_disconnect_start(vs);
2492 return 0;
2493 }
2494
2495 assert(pixman_image_get_width(vs->vd->server) < 65536 &&
2496 pixman_image_get_width(vs->vd->server) >= 0);
2497 assert(pixman_image_get_height(vs->vd->server) < 65536 &&
2498 pixman_image_get_height(vs->vd->server) >= 0);
2499 vs->client_width = pixman_image_get_width(vs->vd->server);
2500 vs->client_height = pixman_image_get_height(vs->vd->server);
2501 vnc_write_u16(vs, vs->client_width);
2502 vnc_write_u16(vs, vs->client_height);
2503
2504 pixel_format_message(vs);
2505
2506 if (qemu_name) {
2507 size = snprintf(buf, sizeof(buf), "QEMU (%s)", qemu_name);
2508 if (size > sizeof(buf)) {
2509 size = sizeof(buf);
2510 }
2511 } else {
2512 size = snprintf(buf, sizeof(buf), "QEMU");
2513 }
2514
2515 vnc_write_u32(vs, size);
2516 vnc_write(vs, buf, size);
2517 vnc_flush(vs);
2518
2519 vnc_client_cache_auth(vs);
2520 vnc_qmp_event(vs, QAPI_EVENT_VNC_INITIALIZED);
2521
2522 vnc_read_when(vs, protocol_client_msg, 1);
2523
2524 return 0;
2525 }
2526
2527 void start_client_init(VncState *vs)
2528 {
2529 vnc_read_when(vs, protocol_client_init, 1);
2530 }
2531
2532 static void make_challenge(VncState *vs)
2533 {
2534 int i;
2535
2536 srand(time(NULL)+getpid()+getpid()*987654+rand());
2537
2538 for (i = 0 ; i < sizeof(vs->challenge) ; i++)
2539 vs->challenge[i] = (int) (256.0*rand()/(RAND_MAX+1.0));
2540 }
2541
2542 static int protocol_client_auth_vnc(VncState *vs, uint8_t *data, size_t len)
2543 {
2544 unsigned char response[VNC_AUTH_CHALLENGE_SIZE];
2545 size_t i, pwlen;
2546 unsigned char key[8];
2547 time_t now = time(NULL);
2548 QCryptoCipher *cipher = NULL;
2549 Error *err = NULL;
2550
2551 if (!vs->vd->password) {
2552 trace_vnc_auth_fail(vs, vs->auth, "password is not set", "");
2553 goto reject;
2554 }
2555 if (vs->vd->expires < now) {
2556 trace_vnc_auth_fail(vs, vs->auth, "password is expired", "");
2557 goto reject;
2558 }
2559
2560 memcpy(response, vs->challenge, VNC_AUTH_CHALLENGE_SIZE);
2561
2562 /* Calculate the expected challenge response */
2563 pwlen = strlen(vs->vd->password);
2564 for (i=0; i<sizeof(key); i++)
2565 key[i] = i<pwlen ? vs->vd->password[i] : 0;
2566
2567 cipher = qcrypto_cipher_new(
2568 QCRYPTO_CIPHER_ALG_DES_RFB,
2569 QCRYPTO_CIPHER_MODE_ECB,
2570 key, G_N_ELEMENTS(key),
2571 &err);
2572 if (!cipher) {
2573 trace_vnc_auth_fail(vs, vs->auth, "cannot create cipher",
2574 error_get_pretty(err));
2575 error_free(err);
2576 goto reject;
2577 }
2578
2579 if (qcrypto_cipher_encrypt(cipher,
2580 vs->challenge,
2581 response,
2582 VNC_AUTH_CHALLENGE_SIZE,
2583 &err) < 0) {
2584 trace_vnc_auth_fail(vs, vs->auth, "cannot encrypt challenge response",
2585 error_get_pretty(err));
2586 error_free(err);
2587 goto reject;
2588 }
2589
2590 /* Compare expected vs actual challenge response */
2591 if (memcmp(response, data, VNC_AUTH_CHALLENGE_SIZE) != 0) {
2592 trace_vnc_auth_fail(vs, vs->auth, "mis-matched challenge response", "");
2593 goto reject;
2594 } else {
2595 trace_vnc_auth_pass(vs, vs->auth);
2596 vnc_write_u32(vs, 0); /* Accept auth */
2597 vnc_flush(vs);
2598
2599 start_client_init(vs);
2600 }
2601
2602 qcrypto_cipher_free(cipher);
2603 return 0;
2604
2605 reject:
2606 vnc_write_u32(vs, 1); /* Reject auth */
2607 if (vs->minor >= 8) {
2608 static const char err[] = "Authentication failed";
2609 vnc_write_u32(vs, sizeof(err));
2610 vnc_write(vs, err, sizeof(err));
2611 }
2612 vnc_flush(vs);
2613 vnc_client_error(vs);
2614 qcrypto_cipher_free(cipher);
2615 return 0;
2616 }
2617
2618 void start_auth_vnc(VncState *vs)
2619 {
2620 make_challenge(vs);
2621 /* Send client a 'random' challenge */
2622 vnc_write(vs, vs->challenge, sizeof(vs->challenge));
2623 vnc_flush(vs);
2624
2625 vnc_read_when(vs, protocol_client_auth_vnc, sizeof(vs->challenge));
2626 }
2627
2628
2629 static int protocol_client_auth(VncState *vs, uint8_t *data, size_t len)
2630 {
2631 /* We only advertise 1 auth scheme at a time, so client
2632 * must pick the one we sent. Verify this */
2633 if (data[0] != vs->auth) { /* Reject auth */
2634 trace_vnc_auth_reject(vs, vs->auth, (int)data[0]);
2635 vnc_write_u32(vs, 1);
2636 if (vs->minor >= 8) {
2637 static const char err[] = "Authentication failed";
2638 vnc_write_u32(vs, sizeof(err));
2639 vnc_write(vs, err, sizeof(err));
2640 }
2641 vnc_client_error(vs);
2642 } else { /* Accept requested auth */
2643 trace_vnc_auth_start(vs, vs->auth);
2644 switch (vs->auth) {
2645 case VNC_AUTH_NONE:
2646 if (vs->minor >= 8) {
2647 vnc_write_u32(vs, 0); /* Accept auth completion */
2648 vnc_flush(vs);
2649 }
2650 trace_vnc_auth_pass(vs, vs->auth);
2651 start_client_init(vs);
2652 break;
2653
2654 case VNC_AUTH_VNC:
2655 start_auth_vnc(vs);
2656 break;
2657
2658 case VNC_AUTH_VENCRYPT:
2659 start_auth_vencrypt(vs);
2660 break;
2661
2662 #ifdef CONFIG_VNC_SASL
2663 case VNC_AUTH_SASL:
2664 start_auth_sasl(vs);
2665 break;
2666 #endif /* CONFIG_VNC_SASL */
2667
2668 default: /* Should not be possible, but just in case */
2669 trace_vnc_auth_fail(vs, vs->auth, "Unhandled auth method", "");
2670 vnc_write_u8(vs, 1);
2671 if (vs->minor >= 8) {
2672 static const char err[] = "Authentication failed";
2673 vnc_write_u32(vs, sizeof(err));
2674 vnc_write(vs, err, sizeof(err));
2675 }
2676 vnc_client_error(vs);
2677 }
2678 }
2679 return 0;
2680 }
2681
2682 static int protocol_version(VncState *vs, uint8_t *version, size_t len)
2683 {
2684 char local[13];
2685
2686 memcpy(local, version, 12);
2687 local[12] = 0;
2688
2689 if (sscanf(local, "RFB %03d.%03d\n", &vs->major, &vs->minor) != 2) {
2690 VNC_DEBUG("Malformed protocol version %s\n", local);
2691 vnc_client_error(vs);
2692 return 0;
2693 }
2694 VNC_DEBUG("Client request protocol version %d.%d\n", vs->major, vs->minor);
2695 if (vs->major != 3 ||
2696 (vs->minor != 3 &&
2697 vs->minor != 4 &&
2698 vs->minor != 5 &&
2699 vs->minor != 7 &&
2700 vs->minor != 8)) {
2701 VNC_DEBUG("Unsupported client version\n");
2702 vnc_write_u32(vs, VNC_AUTH_INVALID);
2703 vnc_flush(vs);
2704 vnc_client_error(vs);
2705 return 0;
2706 }
2707 /* Some broken clients report v3.4 or v3.5, which spec requires to be treated
2708 * as equivalent to v3.3 by servers
2709 */
2710 if (vs->minor == 4 || vs->minor == 5)
2711 vs->minor = 3;
2712
2713 if (vs->minor == 3) {
2714 trace_vnc_auth_start(vs, vs->auth);
2715 if (vs->auth == VNC_AUTH_NONE) {
2716 vnc_write_u32(vs, vs->auth);
2717 vnc_flush(vs);
2718 trace_vnc_auth_pass(vs, vs->auth);
2719 start_client_init(vs);
2720 } else if (vs->auth == VNC_AUTH_VNC) {
2721 VNC_DEBUG("Tell client VNC auth\n");
2722 vnc_write_u32(vs, vs->auth);
2723 vnc_flush(vs);
2724 start_auth_vnc(vs);
2725 } else {
2726 trace_vnc_auth_fail(vs, vs->auth,
2727 "Unsupported auth method for v3.3", "");
2728 vnc_write_u32(vs, VNC_AUTH_INVALID);
2729 vnc_flush(vs);
2730 vnc_client_error(vs);
2731 }
2732 } else {
2733 vnc_write_u8(vs, 1); /* num auth */
2734 vnc_write_u8(vs, vs->auth);
2735 vnc_read_when(vs, protocol_client_auth, 1);
2736 vnc_flush(vs);
2737 }
2738
2739 return 0;
2740 }
2741
2742 static VncRectStat *vnc_stat_rect(VncDisplay *vd, int x, int y)
2743 {
2744 struct VncSurface *vs = &vd->guest;
2745
2746 return &vs->stats[y / VNC_STAT_RECT][x / VNC_STAT_RECT];
2747 }
2748
2749 void vnc_sent_lossy_rect(VncState *vs, int x, int y, int w, int h)
2750 {
2751 int i, j;
2752
2753 w = (x + w) / VNC_STAT_RECT;
2754 h = (y + h) / VNC_STAT_RECT;
2755 x /= VNC_STAT_RECT;
2756 y /= VNC_STAT_RECT;
2757
2758 for (j = y; j <= h; j++) {
2759 for (i = x; i <= w; i++) {
2760 vs->lossy_rect[j][i] = 1;
2761 }
2762 }
2763 }
2764
2765 static int vnc_refresh_lossy_rect(VncDisplay *vd, int x, int y)
2766 {
2767 VncState *vs;
2768 int sty = y / VNC_STAT_RECT;
2769 int stx = x / VNC_STAT_RECT;
2770 int has_dirty = 0;
2771
2772 y = QEMU_ALIGN_DOWN(y, VNC_STAT_RECT);
2773 x = QEMU_ALIGN_DOWN(x, VNC_STAT_RECT);
2774
2775 QTAILQ_FOREACH(vs, &vd->clients, next) {
2776 int j;
2777
2778 /* kernel send buffers are full -> refresh later */
2779 if (vs->output.offset) {
2780 continue;
2781 }
2782
2783 if (!vs->lossy_rect[sty][stx]) {
2784 continue;
2785 }
2786
2787 vs->lossy_rect[sty][stx] = 0;
2788 for (j = 0; j < VNC_STAT_RECT; ++j) {
2789 bitmap_set(vs->dirty[y + j],
2790 x / VNC_DIRTY_PIXELS_PER_BIT,
2791 VNC_STAT_RECT / VNC_DIRTY_PIXELS_PER_BIT);
2792 }
2793 has_dirty++;
2794 }
2795
2796 return has_dirty;
2797 }
2798
2799 static int vnc_update_stats(VncDisplay *vd, struct timeval * tv)
2800 {
2801 int width = MIN(pixman_image_get_width(vd->guest.fb),
2802 pixman_image_get_width(vd->server));
2803 int height = MIN(pixman_image_get_height(vd->guest.fb),
2804 pixman_image_get_height(vd->server));
2805 int x, y;
2806 struct timeval res;
2807 int has_dirty = 0;
2808
2809 for (y = 0; y < height; y += VNC_STAT_RECT) {
2810 for (x = 0; x < width; x += VNC_STAT_RECT) {
2811 VncRectStat *rect = vnc_stat_rect(vd, x, y);
2812
2813 rect->updated = false;
2814 }
2815 }
2816
2817 qemu_timersub(tv, &VNC_REFRESH_STATS, &res);
2818
2819 if (timercmp(&vd->guest.last_freq_check, &res, >)) {
2820 return has_dirty;
2821 }
2822 vd->guest.last_freq_check = *tv;
2823
2824 for (y = 0; y < height; y += VNC_STAT_RECT) {
2825 for (x = 0; x < width; x += VNC_STAT_RECT) {
2826 VncRectStat *rect= vnc_stat_rect(vd, x, y);
2827 int count = ARRAY_SIZE(rect->times);
2828 struct timeval min, max;
2829
2830 if (!timerisset(&rect->times[count - 1])) {
2831 continue ;
2832 }
2833
2834 max = rect->times[(rect->idx + count - 1) % count];
2835 qemu_timersub(tv, &max, &res);
2836
2837 if (timercmp(&res, &VNC_REFRESH_LOSSY, >)) {
2838 rect->freq = 0;
2839 has_dirty += vnc_refresh_lossy_rect(vd, x, y);
2840 memset(rect->times, 0, sizeof (rect->times));
2841 continue ;
2842 }
2843
2844 min = rect->times[rect->idx];
2845 max = rect->times[(rect->idx + count - 1) % count];
2846 qemu_timersub(&max, &min, &res);
2847
2848 rect->freq = res.tv_sec + res.tv_usec / 1000000.;
2849 rect->freq /= count;
2850 rect->freq = 1. / rect->freq;
2851 }
2852 }
2853 return has_dirty;
2854 }
2855
2856 double vnc_update_freq(VncState *vs, int x, int y, int w, int h)
2857 {
2858 int i, j;
2859 double total = 0;
2860 int num = 0;
2861
2862 x = QEMU_ALIGN_DOWN(x, VNC_STAT_RECT);
2863 y = QEMU_ALIGN_DOWN(y, VNC_STAT_RECT);
2864
2865 for (j = y; j <= y + h; j += VNC_STAT_RECT) {
2866 for (i = x; i <= x + w; i += VNC_STAT_RECT) {
2867 total += vnc_stat_rect(vs->vd, i, j)->freq;
2868 num++;
2869 }
2870 }
2871
2872 if (num) {
2873 return total / num;
2874 } else {
2875 return 0;
2876 }
2877 }
2878
2879 static void vnc_rect_updated(VncDisplay *vd, int x, int y, struct timeval * tv)
2880 {
2881 VncRectStat *rect;
2882
2883 rect = vnc_stat_rect(vd, x, y);
2884 if (rect->updated) {
2885 return ;
2886 }
2887 rect->times[rect->idx] = *tv;
2888 rect->idx = (rect->idx + 1) % ARRAY_SIZE(rect->times);
2889 rect->updated = true;
2890 }
2891
2892 static int vnc_refresh_server_surface(VncDisplay *vd)
2893 {
2894 int width = MIN(pixman_image_get_width(vd->guest.fb),
2895 pixman_image_get_width(vd->server));
2896 int height = MIN(pixman_image_get_height(vd->guest.fb),
2897 pixman_image_get_height(vd->server));
2898 int cmp_bytes, server_stride, line_bytes, guest_ll, guest_stride, y = 0;
2899 uint8_t *guest_row0 = NULL, *server_row0;
2900 VncState *vs;
2901 int has_dirty = 0;
2902 pixman_image_t *tmpbuf = NULL;
2903
2904 struct timeval tv = { 0, 0 };
2905
2906 if (!vd->non_adaptive) {
2907 gettimeofday(&tv, NULL);
2908 has_dirty = vnc_update_stats(vd, &tv);
2909 }
2910
2911 /*
2912 * Walk through the guest dirty map.
2913 * Check and copy modified bits from guest to server surface.
2914 * Update server dirty map.
2915 */
2916 server_row0 = (uint8_t *)pixman_image_get_data(vd->server);
2917 server_stride = guest_stride = guest_ll =
2918 pixman_image_get_stride(vd->server);
2919 cmp_bytes = MIN(VNC_DIRTY_PIXELS_PER_BIT * VNC_SERVER_FB_BYTES,
2920 server_stride);
2921 if (vd->guest.format != VNC_SERVER_FB_FORMAT) {
2922 int width = pixman_image_get_width(vd->server);
2923 tmpbuf = qemu_pixman_linebuf_create(VNC_SERVER_FB_FORMAT, width);
2924 } else {
2925 int guest_bpp =
2926 PIXMAN_FORMAT_BPP(pixman_image_get_format(vd->guest.fb));
2927 guest_row0 = (uint8_t *)pixman_image_get_data(vd->guest.fb);
2928 guest_stride = pixman_image_get_stride(vd->guest.fb);
2929 guest_ll = pixman_image_get_width(vd->guest.fb)
2930 * DIV_ROUND_UP(guest_bpp, 8);
2931 }
2932 line_bytes = MIN(server_stride, guest_ll);
2933
2934 for (;;) {
2935 int x;
2936 uint8_t *guest_ptr, *server_ptr;
2937 unsigned long offset = find_next_bit((unsigned long *) &vd->guest.dirty,
2938 height * VNC_DIRTY_BPL(&vd->guest),
2939 y * VNC_DIRTY_BPL(&vd->guest));
2940 if (offset == height * VNC_DIRTY_BPL(&vd->guest)) {
2941 /* no more dirty bits */
2942 break;
2943 }
2944 y = offset / VNC_DIRTY_BPL(&vd->guest);
2945 x = offset % VNC_DIRTY_BPL(&vd->guest);
2946
2947 server_ptr = server_row0 + y * server_stride + x * cmp_bytes;
2948
2949 if (vd->guest.format != VNC_SERVER_FB_FORMAT) {
2950 qemu_pixman_linebuf_fill(tmpbuf, vd->guest.fb, width, 0, y);
2951 guest_ptr = (uint8_t *)pixman_image_get_data(tmpbuf);
2952 } else {
2953 guest_ptr = guest_row0 + y * guest_stride;
2954 }
2955 guest_ptr += x * cmp_bytes;
2956
2957 for (; x < DIV_ROUND_UP(width, VNC_DIRTY_PIXELS_PER_BIT);
2958 x++, guest_ptr += cmp_bytes, server_ptr += cmp_bytes) {
2959 int _cmp_bytes = cmp_bytes;
2960 if (!test_and_clear_bit(x, vd->guest.dirty[y])) {
2961 continue;
2962 }
2963 if ((x + 1) * cmp_bytes > line_bytes) {
2964 _cmp_bytes = line_bytes - x * cmp_bytes;
2965 }
2966 assert(_cmp_bytes >= 0);
2967 if (memcmp(server_ptr, guest_ptr, _cmp_bytes) == 0) {
2968 continue;
2969 }
2970 memcpy(server_ptr, guest_ptr, _cmp_bytes);
2971 if (!vd->non_adaptive) {
2972 vnc_rect_updated(vd, x * VNC_DIRTY_PIXELS_PER_BIT,
2973 y, &tv);
2974 }
2975 QTAILQ_FOREACH(vs, &vd->clients, next) {
2976 set_bit(x, vs->dirty[y]);
2977 }
2978 has_dirty++;
2979 }
2980
2981 y++;
2982 }
2983 qemu_pixman_image_unref(tmpbuf);
2984 return has_dirty;
2985 }
2986
2987 static void vnc_refresh(DisplayChangeListener *dcl)
2988 {
2989 VncDisplay *vd = container_of(dcl, VncDisplay, dcl);
2990 VncState *vs, *vn;
2991 int has_dirty, rects = 0;
2992
2993 if (QTAILQ_EMPTY(&vd->clients)) {
2994 update_displaychangelistener(&vd->dcl, VNC_REFRESH_INTERVAL_MAX);
2995 return;
2996 }
2997
2998 graphic_hw_update(vd->dcl.con);
2999
3000 if (vnc_trylock_display(vd)) {
3001 update_displaychangelistener(&vd->dcl, VNC_REFRESH_INTERVAL_BASE);
3002 return;
3003 }
3004
3005 has_dirty = vnc_refresh_server_surface(vd);
3006 vnc_unlock_display(vd);
3007
3008 QTAILQ_FOREACH_SAFE(vs, &vd->clients, next, vn) {
3009 rects += vnc_update_client(vs, has_dirty);
3010 /* vs might be free()ed here */
3011 }
3012
3013 if (has_dirty && rects) {
3014 vd->dcl.update_interval /= 2;
3015 if (vd->dcl.update_interval < VNC_REFRESH_INTERVAL_BASE) {
3016 vd->dcl.update_interval = VNC_REFRESH_INTERVAL_BASE;
3017 }
3018 } else {
3019 vd->dcl.update_interval += VNC_REFRESH_INTERVAL_INC;
3020 if (vd->dcl.update_interval > VNC_REFRESH_INTERVAL_MAX) {
3021 vd->dcl.update_interval = VNC_REFRESH_INTERVAL_MAX;
3022 }
3023 }
3024 }
3025
3026 static void vnc_connect(VncDisplay *vd, QIOChannelSocket *sioc,
3027 bool skipauth, bool websocket)
3028 {
3029 VncState *vs = g_new0(VncState, 1);
3030 bool first_client = QTAILQ_EMPTY(&vd->clients);
3031 int i;
3032
3033 trace_vnc_client_connect(vs, sioc);
3034 vs->magic = VNC_MAGIC;
3035 vs->sioc = sioc;
3036 object_ref(OBJECT(vs->sioc));
3037 vs->ioc = QIO_CHANNEL(sioc);
3038 object_ref(OBJECT(vs->ioc));
3039 vs->vd = vd;
3040
3041 buffer_init(&vs->input, "vnc-input/%p", sioc);
3042 buffer_init(&vs->output, "vnc-output/%p", sioc);
3043 buffer_init(&vs->jobs_buffer, "vnc-jobs_buffer/%p", sioc);
3044
3045 buffer_init(&vs->tight.tight, "vnc-tight/%p", sioc);
3046 buffer_init(&vs->tight.zlib, "vnc-tight-zlib/%p", sioc);
3047 buffer_init(&vs->tight.gradient, "vnc-tight-gradient/%p", sioc);
3048 #ifdef CONFIG_VNC_JPEG
3049 buffer_init(&vs->tight.jpeg, "vnc-tight-jpeg/%p", sioc);
3050 #endif
3051 #ifdef CONFIG_VNC_PNG
3052 buffer_init(&vs->tight.png, "vnc-tight-png/%p", sioc);
3053 #endif
3054 buffer_init(&vs->zlib.zlib, "vnc-zlib/%p", sioc);
3055 buffer_init(&vs->zrle.zrle, "vnc-zrle/%p", sioc);
3056 buffer_init(&vs->zrle.fb, "vnc-zrle-fb/%p", sioc);
3057 buffer_init(&vs->zrle.zlib, "vnc-zrle-zlib/%p", sioc);
3058
3059 if (skipauth) {
3060 vs->auth = VNC_AUTH_NONE;
3061 vs->subauth = VNC_AUTH_INVALID;
3062 } else {
3063 if (websocket) {
3064 vs->auth = vd->ws_auth;
3065 vs->subauth = VNC_AUTH_INVALID;
3066 } else {
3067 vs->auth = vd->auth;
3068 vs->subauth = vd->subauth;
3069 }
3070 }
3071 VNC_DEBUG("Client sioc=%p ws=%d auth=%d subauth=%d\n",
3072 sioc, websocket, vs->auth, vs->subauth);
3073
3074 vs->lossy_rect = g_malloc0(VNC_STAT_ROWS * sizeof (*vs->lossy_rect));
3075 for (i = 0; i < VNC_STAT_ROWS; ++i) {
3076 vs->lossy_rect[i] = g_new0(uint8_t, VNC_STAT_COLS);
3077 }
3078
3079 VNC_DEBUG("New client on socket %p\n", vs->sioc);
3080 update_displaychangelistener(&vd->dcl, VNC_REFRESH_INTERVAL_BASE);
3081 qio_channel_set_blocking(vs->ioc, false, NULL);
3082 if (vs->ioc_tag) {
3083 g_source_remove(vs->ioc_tag);
3084 }
3085 if (websocket) {
3086 vs->websocket = 1;
3087 if (vd->tlscreds) {
3088 vs->ioc_tag = qio_channel_add_watch(
3089 vs->ioc, G_IO_IN, vncws_tls_handshake_io, vs, NULL);
3090 } else {
3091 vs->ioc_tag = qio_channel_add_watch(
3092 vs->ioc, G_IO_IN, vncws_handshake_io, vs, NULL);
3093 }
3094 } else {
3095 vs->ioc_tag = qio_channel_add_watch(
3096 vs->ioc, G_IO_IN, vnc_client_io, vs, NULL);
3097 }
3098
3099 vnc_client_cache_addr(vs);
3100 vnc_qmp_event(vs, QAPI_EVENT_VNC_CONNECTED);
3101 vnc_set_share_mode(vs, VNC_SHARE_MODE_CONNECTING);
3102
3103 vs->last_x = -1;
3104 vs->last_y = -1;
3105
3106 vs->as.freq = 44100;
3107 vs->as.nchannels = 2;
3108 vs->as.fmt = AUD_FMT_S16;
3109 vs->as.endianness = 0;
3110
3111 qemu_mutex_init(&vs->output_mutex);
3112 vs->bh = qemu_bh_new(vnc_jobs_bh, vs);
3113
3114 QTAILQ_INSERT_TAIL(&vd->clients, vs, next);
3115 if (first_client) {
3116 vnc_update_server_surface(vd);
3117 }
3118
3119 graphic_hw_update(vd->dcl.con);
3120
3121 if (!vs->websocket) {
3122 vnc_start_protocol(vs);
3123 }
3124
3125 if (vd->num_connecting > vd->connections_limit) {
3126 QTAILQ_FOREACH(vs, &vd->clients, next) {
3127 if (vs->share_mode == VNC_SHARE_MODE_CONNECTING) {
3128 vnc_disconnect_start(vs);
3129 return;
3130 }
3131 }
3132 }
3133 }
3134
3135 void vnc_start_protocol(VncState *vs)
3136 {
3137 vnc_write(vs, "RFB 003.008\n", 12);
3138 vnc_flush(vs);
3139 vnc_read_when(vs, protocol_version, 12);
3140
3141 vs->mouse_mode_notifier.notify = check_pointer_type_change;
3142 qemu_add_mouse_mode_change_notifier(&vs->mouse_mode_notifier);
3143 }
3144
3145 static void vnc_listen_io(QIONetListener *listener,
3146 QIOChannelSocket *cioc,
3147 void *opaque)
3148 {
3149 VncDisplay *vd = opaque;
3150 bool isWebsock = listener == vd->wslistener;
3151
3152 qio_channel_set_name(QIO_CHANNEL(cioc),
3153 isWebsock ? "vnc-ws-server" : "vnc-server");
3154 qio_channel_set_delay(QIO_CHANNEL(cioc), false);
3155 vnc_connect(vd, cioc, false, isWebsock);
3156 }
3157
3158 static const DisplayChangeListenerOps dcl_ops = {
3159 .dpy_name = "vnc",
3160 .dpy_refresh = vnc_refresh,
3161 .dpy_gfx_update = vnc_dpy_update,
3162 .dpy_gfx_switch = vnc_dpy_switch,
3163 .dpy_gfx_check_format = qemu_pixman_check_format,
3164 .dpy_mouse_set = vnc_mouse_set,
3165 .dpy_cursor_define = vnc_dpy_cursor_define,
3166 };
3167
3168 void vnc_display_init(const char *id, Error **errp)
3169 {
3170 VncDisplay *vd;
3171
3172 if (vnc_display_find(id) != NULL) {
3173 return;
3174 }
3175 vd = g_malloc0(sizeof(*vd));
3176
3177 vd->id = strdup(id);
3178 QTAILQ_INSERT_TAIL(&vnc_displays, vd, next);
3179
3180 QTAILQ_INIT(&vd->clients);
3181 vd->expires = TIME_MAX;
3182
3183 if (keyboard_layout) {
3184 trace_vnc_key_map_init(keyboard_layout);
3185 vd->kbd_layout = init_keyboard_layout(name2keysym,
3186 keyboard_layout, errp);
3187 } else {
3188 vd->kbd_layout = init_keyboard_layout(name2keysym, "en-us", errp);
3189 }
3190
3191 if (!vd->kbd_layout) {
3192 return;
3193 }
3194
3195 vd->share_policy = VNC_SHARE_POLICY_ALLOW_EXCLUSIVE;
3196 vd->connections_limit = 32;
3197
3198 qemu_mutex_init(&vd->mutex);
3199 vnc_start_worker_thread();
3200
3201 vd->dcl.ops = &dcl_ops;
3202 register_displaychangelistener(&vd->dcl);
3203 vd->kbd = qkbd_state_init(vd->dcl.con);
3204 }
3205
3206
3207 static void vnc_display_close(VncDisplay *vd)
3208 {
3209 if (!vd) {
3210 return;
3211 }
3212 vd->is_unix = false;
3213
3214 if (vd->listener) {
3215 qio_net_listener_disconnect(vd->listener);
3216 object_unref(OBJECT(vd->listener));
3217 }
3218 vd->listener = NULL;
3219
3220 if (vd->wslistener) {
3221 qio_net_listener_disconnect(vd->wslistener);
3222 object_unref(OBJECT(vd->wslistener));
3223 }
3224 vd->wslistener = NULL;
3225
3226 vd->auth = VNC_AUTH_INVALID;
3227 vd->subauth = VNC_AUTH_INVALID;
3228 if (vd->tlscreds) {
3229 object_unparent(OBJECT(vd->tlscreds));
3230 vd->tlscreds = NULL;
3231 }
3232 if (vd->tlsauthz) {
3233 object_unparent(OBJECT(vd->tlsauthz));
3234 vd->tlsauthz = NULL;
3235 }
3236 g_free(vd->tlsauthzid);
3237 vd->tlsauthzid = NULL;
3238 if (vd->lock_key_sync) {
3239 qemu_remove_led_event_handler(vd->led);
3240 vd->led = NULL;
3241 }
3242 #ifdef CONFIG_VNC_SASL
3243 if (vd->sasl.authz) {
3244 object_unparent(OBJECT(vd->sasl.authz));
3245 vd->sasl.authz = NULL;
3246 }
3247 g_free(vd->sasl.authzid);
3248 vd->sasl.authzid = NULL;
3249 #endif
3250 }
3251
3252 int vnc_display_password(const char *id, const char *password)
3253 {
3254 VncDisplay *vd = vnc_display_find(id);
3255
3256 if (!vd) {
3257 return -EINVAL;
3258 }
3259 if (vd->auth == VNC_AUTH_NONE) {
3260 error_printf_unless_qmp("If you want use passwords please enable "
3261 "password auth using '-vnc ${dpy},password'.\n");
3262 return -EINVAL;
3263 }
3264
3265 g_free(vd->password);
3266 vd->password = g_strdup(password);
3267
3268 return 0;
3269 }
3270
3271 int vnc_display_pw_expire(const char *id, time_t expires)
3272 {
3273 VncDisplay *vd = vnc_display_find(id);
3274
3275 if (!vd) {
3276 return -EINVAL;
3277 }
3278
3279 vd->expires = expires;
3280 return 0;
3281 }
3282
3283 static void vnc_display_print_local_addr(VncDisplay *vd)
3284 {
3285 SocketAddress *addr;
3286 Error *err = NULL;
3287
3288 if (!vd->listener || !vd->listener->nsioc) {
3289 return;
3290 }
3291
3292 addr = qio_channel_socket_get_local_address(vd->listener->sioc[0], &err);
3293 if (!addr) {
3294 return;
3295 }
3296
3297 if (addr->type != SOCKET_ADDRESS_TYPE_INET) {
3298 qapi_free_SocketAddress(addr);
3299 return;
3300 }
3301 error_printf_unless_qmp("VNC server running on %s:%s\n",
3302 addr->u.inet.host,
3303 addr->u.inet.port);
3304 qapi_free_SocketAddress(addr);
3305 }
3306
3307 static QemuOptsList qemu_vnc_opts = {
3308 .name = "vnc",
3309 .head = QTAILQ_HEAD_INITIALIZER(qemu_vnc_opts.head),
3310 .implied_opt_name = "vnc",
3311 .desc = {
3312 {
3313 .name = "vnc",
3314 .type = QEMU_OPT_STRING,
3315 },{
3316 .name = "websocket",
3317 .type = QEMU_OPT_STRING,
3318 },{
3319 .name = "tls-creds",
3320 .type = QEMU_OPT_STRING,
3321 },{
3322 .name = "share",
3323 .type = QEMU_OPT_STRING,
3324 },{
3325 .name = "display",
3326 .type = QEMU_OPT_STRING,
3327 },{
3328 .name = "head",
3329 .type = QEMU_OPT_NUMBER,
3330 },{
3331 .name = "connections",
3332 .type = QEMU_OPT_NUMBER,
3333 },{
3334 .name = "to",
3335 .type = QEMU_OPT_NUMBER,
3336 },{
3337 .name = "ipv4",
3338 .type = QEMU_OPT_BOOL,
3339 },{
3340 .name = "ipv6",
3341 .type = QEMU_OPT_BOOL,
3342 },{
3343 .name = "password",
3344 .type = QEMU_OPT_BOOL,
3345 },{
3346 .name = "reverse",
3347 .type = QEMU_OPT_BOOL,
3348 },{
3349 .name = "lock-key-sync",
3350 .type = QEMU_OPT_BOOL,
3351 },{
3352 .name = "key-delay-ms",
3353 .type = QEMU_OPT_NUMBER,
3354 },{
3355 .name = "sasl",
3356 .type = QEMU_OPT_BOOL,
3357 },{
3358 .name = "acl",
3359 .type = QEMU_OPT_BOOL,
3360 },{
3361 .name = "lossy",
3362 .type = QEMU_OPT_BOOL,
3363 },{
3364 .name = "non-adaptive",
3365 .type = QEMU_OPT_BOOL,
3366 },
3367 { /* end of list */ }
3368 },
3369 };
3370
3371
3372 static int
3373 vnc_display_setup_auth(int *auth,
3374 int *subauth,
3375 QCryptoTLSCreds *tlscreds,
3376 bool password,
3377 bool sasl,
3378 bool websocket,
3379 Error **errp)
3380 {
3381 /*
3382 * We have a choice of 3 authentication options
3383 *
3384 * 1. none
3385 * 2. vnc
3386 * 3. sasl
3387 *
3388 * The channel can be run in 2 modes
3389 *
3390 * 1. clear
3391 * 2. tls
3392 *
3393 * And TLS can use 2 types of credentials
3394 *
3395 * 1. anon
3396 * 2. x509
3397 *
3398 * We thus have 9 possible logical combinations
3399 *
3400 * 1. clear + none
3401 * 2. clear + vnc
3402 * 3. clear + sasl
3403 * 4. tls + anon + none
3404 * 5. tls + anon + vnc
3405 * 6. tls + anon + sasl
3406 * 7. tls + x509 + none
3407 * 8. tls + x509 + vnc
3408 * 9. tls + x509 + sasl
3409 *
3410 * These need to be mapped into the VNC auth schemes
3411 * in an appropriate manner. In regular VNC, all the
3412 * TLS options get mapped into VNC_AUTH_VENCRYPT
3413 * sub-auth types.
3414 *
3415 * In websockets, the https:// protocol already provides
3416 * TLS support, so there is no need to make use of the
3417 * VeNCrypt extension. Furthermore, websockets browser
3418 * clients could not use VeNCrypt even if they wanted to,
3419 * as they cannot control when the TLS handshake takes
3420 * place. Thus there is no option but to rely on https://,
3421 * meaning combinations 4->6 and 7->9 will be mapped to
3422 * VNC auth schemes in the same way as combos 1->3.
3423 *
3424 * Regardless of fact that we have a different mapping to
3425 * VNC auth mechs for plain VNC vs websockets VNC, the end
3426 * result has the same security characteristics.
3427 */
3428 if (websocket || !tlscreds) {
3429 if (password) {
3430 VNC_DEBUG("Initializing VNC server with password auth\n");
3431 *auth = VNC_AUTH_VNC;
3432 } else if (sasl) {
3433 VNC_DEBUG("Initializing VNC server with SASL auth\n");
3434 *auth = VNC_AUTH_SASL;
3435 } else {
3436 VNC_DEBUG("Initializing VNC server with no auth\n");
3437 *auth = VNC_AUTH_NONE;
3438 }
3439 *subauth = VNC_AUTH_INVALID;
3440 } else {
3441 bool is_x509 = object_dynamic_cast(OBJECT(tlscreds),
3442 TYPE_QCRYPTO_TLS_CREDS_X509) != NULL;
3443 bool is_anon = object_dynamic_cast(OBJECT(tlscreds),
3444 TYPE_QCRYPTO_TLS_CREDS_ANON) != NULL;
3445
3446 if (!is_x509 && !is_anon) {
3447 error_setg(errp,
3448 "Unsupported TLS cred type %s",
3449 object_get_typename(OBJECT(tlscreds)));
3450 return -1;
3451 }
3452 *auth = VNC_AUTH_VENCRYPT;
3453 if (password) {
3454 if (is_x509) {
3455 VNC_DEBUG("Initializing VNC server with x509 password auth\n");
3456 *subauth = VNC_AUTH_VENCRYPT_X509VNC;
3457 } else {
3458 VNC_DEBUG("Initializing VNC server with TLS password auth\n");
3459 *subauth = VNC_AUTH_VENCRYPT_TLSVNC;
3460 }
3461
3462 } else if (sasl) {
3463 if (is_x509) {
3464 VNC_DEBUG("Initializing VNC server with x509 SASL auth\n");
3465 *subauth = VNC_AUTH_VENCRYPT_X509SASL;
3466 } else {
3467 VNC_DEBUG("Initializing VNC server with TLS SASL auth\n");
3468 *subauth = VNC_AUTH_VENCRYPT_TLSSASL;
3469 }
3470 } else {
3471 if (is_x509) {
3472 VNC_DEBUG("Initializing VNC server with x509 no auth\n");
3473 *subauth = VNC_AUTH_VENCRYPT_X509NONE;
3474 } else {
3475 VNC_DEBUG("Initializing VNC server with TLS no auth\n");
3476 *subauth = VNC_AUTH_VENCRYPT_TLSNONE;
3477 }
3478 }
3479 }
3480 return 0;
3481 }
3482
3483
3484 static int vnc_display_get_address(const char *addrstr,
3485 bool websocket,
3486 bool reverse,
3487 int displaynum,
3488 int to,
3489 bool has_ipv4,
3490 bool has_ipv6,
3491 bool ipv4,
3492 bool ipv6,
3493 SocketAddress **retaddr,
3494 Error **errp)
3495 {
3496 int ret = -1;
3497 SocketAddress *addr = NULL;
3498
3499 addr = g_new0(SocketAddress, 1);
3500
3501 if (strncmp(addrstr, "unix:", 5) == 0) {
3502 addr->type = SOCKET_ADDRESS_TYPE_UNIX;
3503 addr->u.q_unix.path = g_strdup(addrstr + 5);
3504
3505 if (websocket) {
3506 error_setg(errp, "UNIX sockets not supported with websock");
3507 goto cleanup;
3508 }
3509
3510 if (to) {
3511 error_setg(errp, "Port range not support with UNIX socket");
3512 goto cleanup;
3513 }
3514 ret = 0;
3515 } else {
3516 const char *port;
3517 size_t hostlen;
3518 unsigned long long baseport = 0;
3519 InetSocketAddress *inet;
3520
3521 port = strrchr(addrstr, ':');
3522 if (!port) {
3523 if (websocket) {
3524 hostlen = 0;
3525 port = addrstr;
3526 } else {
3527 error_setg(errp, "no vnc port specified");
3528 goto cleanup;
3529 }
3530 } else {
3531 hostlen = port - addrstr;
3532 port++;
3533 if (*port == '\0') {
3534 error_setg(errp, "vnc port cannot be empty");
3535 goto cleanup;
3536 }
3537 }
3538
3539 addr->type = SOCKET_ADDRESS_TYPE_INET;
3540 inet = &addr->u.inet;
3541 if (addrstr[0] == '[' && addrstr[hostlen - 1] == ']') {
3542 inet->host = g_strndup(addrstr + 1, hostlen - 2);
3543 } else {
3544 inet->host = g_strndup(addrstr, hostlen);
3545 }
3546 /* plain VNC port is just an offset, for websocket
3547 * port is absolute */
3548 if (websocket) {
3549 if (g_str_equal(addrstr, "") ||
3550 g_str_equal(addrstr, "on")) {
3551 if (displaynum == -1) {
3552 error_setg(errp, "explicit websocket port is required");
3553 goto cleanup;
3554 }
3555 inet->port = g_strdup_printf(
3556 "%d", displaynum + 5700);
3557 if (to) {
3558 inet->has_to = true;
3559 inet->to = to + 5700;
3560 }
3561 } else {
3562 inet->port = g_strdup(port);
3563 }
3564 } else {
3565 int offset = reverse ? 0 : 5900;
3566 if (parse_uint_full(port, &baseport, 10) < 0) {
3567 error_setg(errp, "can't convert to a number: %s", port);
3568 goto cleanup;
3569 }
3570 if (baseport > 65535 ||
3571 baseport + offset > 65535) {
3572 error_setg(errp, "port %s out of range", port);
3573 goto cleanup;
3574 }
3575 inet->port = g_strdup_printf(
3576 "%d", (int)baseport + offset);
3577
3578 if (to) {
3579 inet->has_to = true;
3580 inet->to = to + offset;
3581 }
3582 }
3583
3584 inet->ipv4 = ipv4;
3585 inet->has_ipv4 = has_ipv4;
3586 inet->ipv6 = ipv6;
3587 inet->has_ipv6 = has_ipv6;
3588
3589 ret = baseport;
3590 }
3591
3592 *retaddr = addr;
3593
3594 cleanup:
3595 if (ret < 0) {
3596 qapi_free_SocketAddress(addr);
3597 }
3598 return ret;
3599 }
3600
3601 static void vnc_free_addresses(SocketAddress ***retsaddr,
3602 size_t *retnsaddr)
3603 {
3604 size_t i;
3605
3606 for (i = 0; i < *retnsaddr; i++) {
3607 qapi_free_SocketAddress((*retsaddr)[i]);
3608 }
3609 g_free(*retsaddr);
3610
3611 *retsaddr = NULL;
3612 *retnsaddr = 0;
3613 }
3614
3615 static int vnc_display_get_addresses(QemuOpts *opts,
3616 bool reverse,
3617 SocketAddress ***retsaddr,
3618 size_t *retnsaddr,
3619 SocketAddress ***retwsaddr,
3620 size_t *retnwsaddr,
3621 Error **errp)
3622 {
3623 SocketAddress *saddr = NULL;
3624 SocketAddress *wsaddr = NULL;
3625 QemuOptsIter addriter;
3626 const char *addr;
3627 int to = qemu_opt_get_number(opts, "to", 0);
3628 bool has_ipv4 = qemu_opt_get(opts, "ipv4");
3629 bool has_ipv6 = qemu_opt_get(opts, "ipv6");
3630 bool ipv4 = qemu_opt_get_bool(opts, "ipv4", false);
3631 bool ipv6 = qemu_opt_get_bool(opts, "ipv6", false);
3632 int displaynum = -1;
3633 int ret = -1;
3634
3635 *retsaddr = NULL;
3636 *retnsaddr = 0;
3637 *retwsaddr = NULL;
3638 *retnwsaddr = 0;
3639
3640 addr = qemu_opt_get(opts, "vnc");
3641 if (addr == NULL || g_str_equal(addr, "none")) {
3642 ret = 0;
3643 goto cleanup;
3644 }
3645 if (qemu_opt_get(opts, "websocket") &&
3646 !qcrypto_hash_supports(QCRYPTO_HASH_ALG_SHA1)) {
3647 error_setg(errp,
3648 "SHA1 hash support is required for websockets");
3649 goto cleanup;
3650 }
3651
3652 qemu_opt_iter_init(&addriter, opts, "vnc");
3653 while ((addr = qemu_opt_iter_next(&addriter)) != NULL) {
3654 int rv;
3655 rv = vnc_display_get_address(addr, false, reverse, 0, to,
3656 has_ipv4, has_ipv6,
3657 ipv4, ipv6,
3658 &saddr, errp);
3659 if (rv < 0) {
3660 goto cleanup;
3661 }
3662 /* Historical compat - first listen address can be used
3663 * to set the default websocket port
3664 */
3665 if (displaynum == -1) {
3666 displaynum = rv;
3667 }
3668 *retsaddr = g_renew(SocketAddress *, *retsaddr, *retnsaddr + 1);
3669 (*retsaddr)[(*retnsaddr)++] = saddr;
3670 }
3671
3672 /* If we had multiple primary displays, we don't do defaults
3673 * for websocket, and require explicit config instead. */
3674 if (*retnsaddr > 1) {
3675 displaynum = -1;
3676 }
3677
3678 qemu_opt_iter_init(&addriter, opts, "websocket");
3679 while ((addr = qemu_opt_iter_next(&addriter)) != NULL) {
3680 if (vnc_display_get_address(addr, true, reverse, displaynum, to,
3681 has_ipv4, has_ipv6,
3682 ipv4, ipv6,
3683 &wsaddr, errp) < 0) {
3684 goto cleanup;
3685 }
3686
3687 /* Historical compat - if only a single listen address was
3688 * provided, then this is used to set the default listen
3689 * address for websocket too
3690 */
3691 if (*retnsaddr == 1 &&
3692 (*retsaddr)[0]->type == SOCKET_ADDRESS_TYPE_INET &&
3693 wsaddr->type == SOCKET_ADDRESS_TYPE_INET &&
3694 g_str_equal(wsaddr->u.inet.host, "") &&
3695 !g_str_equal((*retsaddr)[0]->u.inet.host, "")) {
3696 g_free(wsaddr->u.inet.host);
3697 wsaddr->u.inet.host = g_strdup((*retsaddr)[0]->u.inet.host);
3698 }
3699
3700 *retwsaddr = g_renew(SocketAddress *, *retwsaddr, *retnwsaddr + 1);
3701 (*retwsaddr)[(*retnwsaddr)++] = wsaddr;
3702 }
3703
3704 ret = 0;
3705 cleanup:
3706 if (ret < 0) {
3707 vnc_free_addresses(retsaddr, retnsaddr);
3708 vnc_free_addresses(retwsaddr, retnwsaddr);
3709 }
3710 return ret;
3711 }
3712
3713 static int vnc_display_connect(VncDisplay *vd,
3714 SocketAddress **saddr,
3715 size_t nsaddr,
3716 SocketAddress **wsaddr,
3717 size_t nwsaddr,
3718 Error **errp)
3719 {
3720 /* connect to viewer */
3721 QIOChannelSocket *sioc = NULL;
3722 if (nwsaddr != 0) {
3723 error_setg(errp, "Cannot use websockets in reverse mode");
3724 return -1;
3725 }
3726 if (nsaddr != 1) {
3727 error_setg(errp, "Expected a single address in reverse mode");
3728 return -1;
3729 }
3730 /* TODO SOCKET_ADDRESS_TYPE_FD when fd has AF_UNIX */
3731 vd->is_unix = saddr[0]->type == SOCKET_ADDRESS_TYPE_UNIX;
3732 sioc = qio_channel_socket_new();
3733 qio_channel_set_name(QIO_CHANNEL(sioc), "vnc-reverse");
3734 if (qio_channel_socket_connect_sync(sioc, saddr[0], errp) < 0) {
3735 return -1;
3736 }
3737 vnc_connect(vd, sioc, false, false);
3738 object_unref(OBJECT(sioc));
3739 return 0;
3740 }
3741
3742
3743 static int vnc_display_listen(VncDisplay *vd,
3744 SocketAddress **saddr,
3745 size_t nsaddr,
3746 SocketAddress **wsaddr,
3747 size_t nwsaddr,
3748 Error **errp)
3749 {
3750 size_t i;
3751
3752 if (nsaddr) {
3753 vd->listener = qio_net_listener_new();
3754 qio_net_listener_set_name(vd->listener, "vnc-listen");
3755 for (i = 0; i < nsaddr; i++) {
3756 if (qio_net_listener_open_sync(vd->listener,
3757 saddr[i],
3758 errp) < 0) {
3759 return -1;
3760 }
3761 }
3762
3763 qio_net_listener_set_client_func(vd->listener,
3764 vnc_listen_io, vd, NULL);
3765 }
3766
3767 if (nwsaddr) {
3768 vd->wslistener = qio_net_listener_new();
3769 qio_net_listener_set_name(vd->wslistener, "vnc-ws-listen");
3770 for (i = 0; i < nwsaddr; i++) {
3771 if (qio_net_listener_open_sync(vd->wslistener,
3772 wsaddr[i],
3773 errp) < 0) {
3774 return -1;
3775 }
3776 }
3777
3778 qio_net_listener_set_client_func(vd->wslistener,
3779 vnc_listen_io, vd, NULL);
3780 }
3781
3782 return 0;
3783 }
3784
3785
3786 void vnc_display_open(const char *id, Error **errp)
3787 {
3788 VncDisplay *vd = vnc_display_find(id);
3789 QemuOpts *opts = qemu_opts_find(&qemu_vnc_opts, id);
3790 SocketAddress **saddr = NULL, **wsaddr = NULL;
3791 size_t nsaddr, nwsaddr;
3792 const char *share, *device_id;
3793 QemuConsole *con;
3794 bool password = false;
3795 bool reverse = false;
3796 const char *credid;
3797 bool sasl = false;
3798 int acl = 0;
3799 int lock_key_sync = 1;
3800 int key_delay_ms;
3801
3802 if (!vd) {
3803 error_setg(errp, "VNC display not active");
3804 return;
3805 }
3806 vnc_display_close(vd);
3807
3808 if (!opts) {
3809 return;
3810 }
3811
3812 reverse = qemu_opt_get_bool(opts, "reverse", false);
3813 if (vnc_display_get_addresses(opts, reverse, &saddr, &nsaddr,
3814 &wsaddr, &nwsaddr, errp) < 0) {
3815 goto fail;
3816 }
3817
3818 password = qemu_opt_get_bool(opts, "password", false);
3819 if (password) {
3820 if (fips_get_state()) {
3821 error_setg(errp,
3822 "VNC password auth disabled due to FIPS mode, "
3823 "consider using the VeNCrypt or SASL authentication "
3824 "methods as an alternative");
3825 goto fail;
3826 }
3827 if (!qcrypto_cipher_supports(
3828 QCRYPTO_CIPHER_ALG_DES_RFB, QCRYPTO_CIPHER_MODE_ECB)) {
3829 error_setg(errp,
3830 "Cipher backend does not support DES RFB algorithm");
3831 goto fail;
3832 }
3833 }
3834
3835 lock_key_sync = qemu_opt_get_bool(opts, "lock-key-sync", true);
3836 key_delay_ms = qemu_opt_get_number(opts, "key-delay-ms", 10);
3837 sasl = qemu_opt_get_bool(opts, "sasl", false);
3838 #ifndef CONFIG_VNC_SASL
3839 if (sasl) {
3840 error_setg(errp, "VNC SASL auth requires cyrus-sasl support");
3841 goto fail;
3842 }
3843 #endif /* CONFIG_VNC_SASL */
3844 credid = qemu_opt_get(opts, "tls-creds");
3845 if (credid) {
3846 Object *creds;
3847 creds = object_resolve_path_component(
3848 object_get_objects_root(), credid);
3849 if (!creds) {
3850 error_setg(errp, "No TLS credentials with id '%s'",
3851 credid);
3852 goto fail;
3853 }
3854 vd->tlscreds = (QCryptoTLSCreds *)
3855 object_dynamic_cast(creds,
3856 TYPE_QCRYPTO_TLS_CREDS);
3857 if (!vd->tlscreds) {
3858 error_setg(errp, "Object with id '%s' is not TLS credentials",
3859 credid);
3860 goto fail;
3861 }
3862 object_ref(OBJECT(vd->tlscreds));
3863
3864 if (vd->tlscreds->endpoint != QCRYPTO_TLS_CREDS_ENDPOINT_SERVER) {
3865 error_setg(errp,
3866 "Expecting TLS credentials with a server endpoint");
3867 goto fail;
3868 }
3869 }
3870 acl = qemu_opt_get_bool(opts, "acl", false);
3871
3872 share = qemu_opt_get(opts, "share");
3873 if (share) {
3874 if (strcmp(share, "ignore") == 0) {
3875 vd->share_policy = VNC_SHARE_POLICY_IGNORE;
3876 } else if (strcmp(share, "allow-exclusive") == 0) {
3877 vd->share_policy = VNC_SHARE_POLICY_ALLOW_EXCLUSIVE;
3878 } else if (strcmp(share, "force-shared") == 0) {
3879 vd->share_policy = VNC_SHARE_POLICY_FORCE_SHARED;
3880 } else {
3881 error_setg(errp, "unknown vnc share= option");
3882 goto fail;
3883 }
3884 } else {
3885 vd->share_policy = VNC_SHARE_POLICY_ALLOW_EXCLUSIVE;
3886 }
3887 vd->connections_limit = qemu_opt_get_number(opts, "connections", 32);
3888
3889 #ifdef CONFIG_VNC_JPEG
3890 vd->lossy = qemu_opt_get_bool(opts, "lossy", false);
3891 #endif
3892 vd->non_adaptive = qemu_opt_get_bool(opts, "non-adaptive", false);
3893 /* adaptive updates are only used with tight encoding and
3894 * if lossy updates are enabled so we can disable all the
3895 * calculations otherwise */
3896 if (!vd->lossy) {
3897 vd->non_adaptive = true;
3898 }
3899
3900 if (acl) {
3901 if (strcmp(vd->id, "default") == 0) {
3902 vd->tlsauthzid = g_strdup("vnc.x509dname");
3903 } else {
3904 vd->tlsauthzid = g_strdup_printf("vnc.%s.x509dname", vd->id);
3905 }
3906 vd->tlsauthz = QAUTHZ(qauthz_list_new(vd->tlsauthzid,
3907 QAUTHZ_LIST_POLICY_DENY,
3908 &error_abort));
3909 }
3910 #ifdef CONFIG_VNC_SASL
3911 if (acl && sasl) {
3912 if (strcmp(vd->id, "default") == 0) {
3913 vd->sasl.authzid = g_strdup("vnc.username");
3914 } else {
3915 vd->sasl.authzid = g_strdup_printf("vnc.%s.username", vd->id);
3916 }
3917 vd->sasl.authz = QAUTHZ(qauthz_list_new(vd->sasl.authzid,
3918 QAUTHZ_LIST_POLICY_DENY,
3919 &error_abort));
3920 }
3921 #endif
3922
3923 if (vnc_display_setup_auth(&vd->auth, &vd->subauth,
3924 vd->tlscreds, password,
3925 sasl, false, errp) < 0) {
3926 goto fail;
3927 }
3928 trace_vnc_auth_init(vd, 0, vd->auth, vd->subauth);
3929
3930 if (vnc_display_setup_auth(&vd->ws_auth, &vd->ws_subauth,
3931 vd->tlscreds, password,
3932 sasl, true, errp) < 0) {
3933 goto fail;
3934 }
3935 trace_vnc_auth_init(vd, 1, vd->ws_auth, vd->ws_subauth);
3936
3937 #ifdef CONFIG_VNC_SASL
3938 if (sasl) {
3939 int saslErr = sasl_server_init(NULL, "qemu");
3940
3941 if (saslErr != SASL_OK) {
3942 error_setg(errp, "Failed to initialize SASL auth: %s",
3943 sasl_errstring(saslErr, NULL, NULL));
3944 goto fail;
3945 }
3946 }
3947 #endif
3948 vd->lock_key_sync = lock_key_sync;
3949 if (lock_key_sync) {
3950 vd->led = qemu_add_led_event_handler(kbd_leds, vd);
3951 }
3952 vd->ledstate = 0;
3953
3954 device_id = qemu_opt_get(opts, "display");
3955 if (device_id) {
3956 int head = qemu_opt_get_number(opts, "head", 0);
3957 Error *err = NULL;
3958
3959 con = qemu_console_lookup_by_device_name(device_id, head, &err);
3960 if (err) {
3961 error_propagate(errp, err);
3962 goto fail;
3963 }
3964 } else {
3965 con = NULL;
3966 }
3967
3968 if (con != vd->dcl.con) {
3969 qkbd_state_free(vd->kbd);
3970 unregister_displaychangelistener(&vd->dcl);
3971 vd->dcl.con = con;
3972 register_displaychangelistener(&vd->dcl);
3973 vd->kbd = qkbd_state_init(vd->dcl.con);
3974 }
3975 qkbd_state_set_delay(vd->kbd, key_delay_ms);
3976
3977 if (saddr == NULL) {
3978 goto cleanup;
3979 }
3980
3981 if (reverse) {
3982 if (vnc_display_connect(vd, saddr, nsaddr, wsaddr, nwsaddr, errp) < 0) {
3983 goto fail;
3984 }
3985 } else {
3986 if (vnc_display_listen(vd, saddr, nsaddr, wsaddr, nwsaddr, errp) < 0) {
3987 goto fail;
3988 }
3989 }
3990
3991 if (qemu_opt_get(opts, "to")) {
3992 vnc_display_print_local_addr(vd);
3993 }
3994
3995 cleanup:
3996 vnc_free_addresses(&saddr, &nsaddr);
3997 vnc_free_addresses(&wsaddr, &nwsaddr);
3998 return;
3999
4000 fail:
4001 vnc_display_close(vd);
4002 goto cleanup;
4003 }
4004
4005 void vnc_display_add_client(const char *id, int csock, bool skipauth)
4006 {
4007 VncDisplay *vd = vnc_display_find(id);
4008 QIOChannelSocket *sioc;
4009
4010 if (!vd) {
4011 return;
4012 }
4013
4014 sioc = qio_channel_socket_new_fd(csock, NULL);
4015 if (sioc) {
4016 qio_channel_set_name(QIO_CHANNEL(sioc), "vnc-server");
4017 vnc_connect(vd, sioc, skipauth, false);
4018 object_unref(OBJECT(sioc));
4019 }
4020 }
4021
4022 static void vnc_auto_assign_id(QemuOptsList *olist, QemuOpts *opts)
4023 {
4024 int i = 2;
4025 char *id;
4026
4027 id = g_strdup("default");
4028 while (qemu_opts_find(olist, id)) {
4029 g_free(id);
4030 id = g_strdup_printf("vnc%d", i++);
4031 }
4032 qemu_opts_set_id(opts, id);
4033 }
4034
4035 QemuOpts *vnc_parse(const char *str, Error **errp)
4036 {
4037 QemuOptsList *olist = qemu_find_opts("vnc");
4038 QemuOpts *opts = qemu_opts_parse(olist, str, true, errp);
4039 const char *id;
4040
4041 if (!opts) {
4042 return NULL;
4043 }
4044
4045 id = qemu_opts_id(opts);
4046 if (!id) {
4047 /* auto-assign id if not present */
4048 vnc_auto_assign_id(olist, opts);
4049 }
4050 return opts;
4051 }
4052
4053 int vnc_init_func(void *opaque, QemuOpts *opts, Error **errp)
4054 {
4055 Error *local_err = NULL;
4056 char *id = (char *)qemu_opts_id(opts);
4057
4058 assert(id);
4059 vnc_display_init(id, &local_err);
4060 if (local_err) {
4061 error_propagate(errp, local_err);
4062 return -1;
4063 }
4064 vnc_display_open(id, &local_err);
4065 if (local_err != NULL) {
4066 error_propagate(errp, local_err);
4067 return -1;
4068 }
4069 return 0;
4070 }
4071
4072 static void vnc_register_config(void)
4073 {
4074 qemu_add_opts(&qemu_vnc_opts);
4075 }
4076 opts_init(vnc_register_config);
QEMU mirror