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