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