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