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