2 * QEMU VNC display driver
4 * Copyright (C) 2006 Anthony Liguori <anthony@codemonkey.ws>
5 * Copyright (C) 2006 Fabrice Bellard
6 * Copyright (C) 2009 Red Hat, Inc
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:
15 * The above copyright notice and this permission notice shall be included in
16 * all copies or substantial portions of the Software.
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
31 #include "sysemu/sysemu.h"
32 #include "qemu/error-report.h"
33 #include "qemu/sockets.h"
34 #include "qemu/timer.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"
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"
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 };
54 #include "vnc_keysym.h"
55 #include "crypto/cipher.h"
57 static QTAILQ_HEAD(, VncDisplay
) vnc_displays
=
58 QTAILQ_HEAD_INITIALIZER(vnc_displays
);
60 static int vnc_cursor_define(VncState
*vs
);
61 static void vnc_release_modifiers(VncState
*vs
);
63 static void vnc_set_share_mode(VncState
*vs
, VncShareMode mode
)
66 static const char *mn
[] = {
68 [VNC_SHARE_MODE_CONNECTING
] = "connecting",
69 [VNC_SHARE_MODE_SHARED
] = "shared",
70 [VNC_SHARE_MODE_EXCLUSIVE
] = "exclusive",
71 [VNC_SHARE_MODE_DISCONNECTED
] = "disconnected",
73 fprintf(stderr
, "%s/%d: %s -> %s\n", __func__
,
74 vs
->csock
, mn
[vs
->share_mode
], mn
[mode
]);
77 switch (vs
->share_mode
) {
78 case VNC_SHARE_MODE_CONNECTING
:
79 vs
->vd
->num_connecting
--;
81 case VNC_SHARE_MODE_SHARED
:
84 case VNC_SHARE_MODE_EXCLUSIVE
:
85 vs
->vd
->num_exclusive
--;
91 vs
->share_mode
= mode
;
93 switch (vs
->share_mode
) {
94 case VNC_SHARE_MODE_CONNECTING
:
95 vs
->vd
->num_connecting
++;
97 case VNC_SHARE_MODE_SHARED
:
100 case VNC_SHARE_MODE_EXCLUSIVE
:
101 vs
->vd
->num_exclusive
++;
108 static char *addr_to_string(const char *format
,
109 struct sockaddr_storage
*sa
,
112 char host
[NI_MAXHOST
];
113 char serv
[NI_MAXSERV
];
117 if ((err
= getnameinfo((struct sockaddr
*)sa
, salen
,
120 NI_NUMERICHOST
| NI_NUMERICSERV
)) != 0) {
121 VNC_DEBUG("Cannot resolve address %d: %s\n",
122 err
, gai_strerror(err
));
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';
137 char *vnc_socket_local_addr(const char *format
, int fd
) {
138 struct sockaddr_storage sa
;
142 if (getsockname(fd
, (struct sockaddr
*)&sa
, &salen
) < 0)
145 return addr_to_string(format
, &sa
, salen
);
148 char *vnc_socket_remote_addr(const char *format
, int fd
) {
149 struct sockaddr_storage sa
;
153 if (getpeername(fd
, (struct sockaddr
*)&sa
, &salen
) < 0)
156 return addr_to_string(format
, &sa
, salen
);
159 static VncBasicInfo
*vnc_basic_info_get(struct sockaddr_storage
*sa
,
163 char host
[NI_MAXHOST
];
164 char serv
[NI_MAXSERV
];
167 if ((err
= getnameinfo((struct sockaddr
*)sa
, salen
,
170 NI_NUMERICHOST
| NI_NUMERICSERV
)) != 0) {
171 VNC_DEBUG("Cannot resolve address %d: %s\n",
172 err
, gai_strerror(err
));
176 info
= g_malloc0(sizeof(VncBasicInfo
));
177 info
->host
= g_strdup(host
);
178 info
->service
= g_strdup(serv
);
179 info
->family
= inet_netfamily(sa
->ss_family
);
183 static VncBasicInfo
*vnc_basic_info_get_from_server_addr(int fd
)
185 struct sockaddr_storage sa
;
189 if (getsockname(fd
, (struct sockaddr
*)&sa
, &salen
) < 0) {
193 return vnc_basic_info_get(&sa
, salen
);
196 static VncBasicInfo
*vnc_basic_info_get_from_remote_addr(int fd
)
198 struct sockaddr_storage sa
;
202 if (getpeername(fd
, (struct sockaddr
*)&sa
, &salen
) < 0) {
206 return vnc_basic_info_get(&sa
, salen
);
209 static const char *vnc_auth_name(VncDisplay
*vd
) {
211 case VNC_AUTH_INVALID
:
227 case VNC_AUTH_VENCRYPT
:
228 switch (vd
->subauth
) {
229 case VNC_AUTH_VENCRYPT_PLAIN
:
230 return "vencrypt+plain";
231 case VNC_AUTH_VENCRYPT_TLSNONE
:
232 return "vencrypt+tls+none";
233 case VNC_AUTH_VENCRYPT_TLSVNC
:
234 return "vencrypt+tls+vnc";
235 case VNC_AUTH_VENCRYPT_TLSPLAIN
:
236 return "vencrypt+tls+plain";
237 case VNC_AUTH_VENCRYPT_X509NONE
:
238 return "vencrypt+x509+none";
239 case VNC_AUTH_VENCRYPT_X509VNC
:
240 return "vencrypt+x509+vnc";
241 case VNC_AUTH_VENCRYPT_X509PLAIN
:
242 return "vencrypt+x509+plain";
243 case VNC_AUTH_VENCRYPT_TLSSASL
:
244 return "vencrypt+tls+sasl";
245 case VNC_AUTH_VENCRYPT_X509SASL
:
246 return "vencrypt+x509+sasl";
256 static VncServerInfo
*vnc_server_info_get(VncDisplay
*vd
)
259 VncBasicInfo
*bi
= vnc_basic_info_get_from_server_addr(vd
->lsock
);
264 info
= g_malloc(sizeof(*info
));
266 info
->has_auth
= true;
267 info
->auth
= g_strdup(vnc_auth_name(vd
));
271 static void vnc_client_cache_auth(VncState
*client
)
278 client
->info
->x509_dname
=
279 qcrypto_tls_session_get_peer_name(client
->tls
);
280 client
->info
->has_x509_dname
=
281 client
->info
->x509_dname
!= NULL
;
283 #ifdef CONFIG_VNC_SASL
284 if (client
->sasl
.conn
&&
285 client
->sasl
.username
) {
286 client
->info
->has_sasl_username
= true;
287 client
->info
->sasl_username
= g_strdup(client
->sasl
.username
);
292 static void vnc_client_cache_addr(VncState
*client
)
294 VncBasicInfo
*bi
= vnc_basic_info_get_from_remote_addr(client
->csock
);
297 client
->info
= g_malloc0(sizeof(*client
->info
));
298 client
->info
->base
= bi
;
302 static void vnc_qmp_event(VncState
*vs
, QAPIEvent event
)
309 g_assert(vs
->info
->base
);
311 si
= vnc_server_info_get(vs
->vd
);
317 case QAPI_EVENT_VNC_CONNECTED
:
318 qapi_event_send_vnc_connected(si
, vs
->info
->base
, &error_abort
);
320 case QAPI_EVENT_VNC_INITIALIZED
:
321 qapi_event_send_vnc_initialized(si
, vs
->info
, &error_abort
);
323 case QAPI_EVENT_VNC_DISCONNECTED
:
324 qapi_event_send_vnc_disconnected(si
, vs
->info
, &error_abort
);
330 qapi_free_VncServerInfo(si
);
333 static VncClientInfo
*qmp_query_vnc_client(const VncState
*client
)
335 struct sockaddr_storage sa
;
336 socklen_t salen
= sizeof(sa
);
337 char host
[NI_MAXHOST
];
338 char serv
[NI_MAXSERV
];
341 if (getpeername(client
->csock
, (struct sockaddr
*)&sa
, &salen
) < 0) {
345 if (getnameinfo((struct sockaddr
*)&sa
, salen
,
348 NI_NUMERICHOST
| NI_NUMERICSERV
) < 0) {
352 info
= g_malloc0(sizeof(*info
));
353 info
->base
= g_malloc0(sizeof(*info
->base
));
354 info
->base
->host
= g_strdup(host
);
355 info
->base
->service
= g_strdup(serv
);
356 info
->base
->family
= inet_netfamily(sa
.ss_family
);
357 info
->base
->websocket
= client
->websocket
;
360 info
->x509_dname
= qcrypto_tls_session_get_peer_name(client
->tls
);
361 info
->has_x509_dname
= info
->x509_dname
!= NULL
;
363 #ifdef CONFIG_VNC_SASL
364 if (client
->sasl
.conn
&& client
->sasl
.username
) {
365 info
->has_sasl_username
= true;
366 info
->sasl_username
= g_strdup(client
->sasl
.username
);
373 static VncDisplay
*vnc_display_find(const char *id
)
378 return QTAILQ_FIRST(&vnc_displays
);
380 QTAILQ_FOREACH(vd
, &vnc_displays
, next
) {
381 if (strcmp(id
, vd
->id
) == 0) {
388 static VncClientInfoList
*qmp_query_client_list(VncDisplay
*vd
)
390 VncClientInfoList
*cinfo
, *prev
= NULL
;
393 QTAILQ_FOREACH(client
, &vd
->clients
, next
) {
394 cinfo
= g_new0(VncClientInfoList
, 1);
395 cinfo
->value
= qmp_query_vnc_client(client
);
402 VncInfo
*qmp_query_vnc(Error
**errp
)
404 VncInfo
*info
= g_malloc0(sizeof(*info
));
405 VncDisplay
*vd
= vnc_display_find(NULL
);
407 if (vd
== NULL
|| !vd
->enabled
) {
408 info
->enabled
= false;
410 struct sockaddr_storage sa
;
411 socklen_t salen
= sizeof(sa
);
412 char host
[NI_MAXHOST
];
413 char serv
[NI_MAXSERV
];
415 info
->enabled
= true;
417 /* for compatibility with the original command */
418 info
->has_clients
= true;
419 info
->clients
= qmp_query_client_list(vd
);
421 if (vd
->lsock
== -1) {
425 if (getsockname(vd
->lsock
, (struct sockaddr
*)&sa
,
427 error_setg(errp
, QERR_UNDEFINED_ERROR
);
431 if (getnameinfo((struct sockaddr
*)&sa
, salen
,
434 NI_NUMERICHOST
| NI_NUMERICSERV
) < 0) {
435 error_setg(errp
, QERR_UNDEFINED_ERROR
);
439 info
->has_host
= true;
440 info
->host
= g_strdup(host
);
442 info
->has_service
= true;
443 info
->service
= g_strdup(serv
);
445 info
->has_family
= true;
446 info
->family
= inet_netfamily(sa
.ss_family
);
448 info
->has_auth
= true;
449 info
->auth
= g_strdup(vnc_auth_name(vd
));
455 qapi_free_VncInfo(info
);
459 static VncBasicInfoList
*qmp_query_server_entry(int socket
,
461 VncBasicInfoList
*prev
)
463 VncBasicInfoList
*list
;
465 struct sockaddr_storage sa
;
466 socklen_t salen
= sizeof(sa
);
467 char host
[NI_MAXHOST
];
468 char serv
[NI_MAXSERV
];
470 if (getsockname(socket
, (struct sockaddr
*)&sa
, &salen
) < 0 ||
471 getnameinfo((struct sockaddr
*)&sa
, salen
,
472 host
, sizeof(host
), serv
, sizeof(serv
),
473 NI_NUMERICHOST
| NI_NUMERICSERV
) < 0) {
477 info
= g_new0(VncBasicInfo
, 1);
478 info
->host
= g_strdup(host
);
479 info
->service
= g_strdup(serv
);
480 info
->family
= inet_netfamily(sa
.ss_family
);
481 info
->websocket
= websocket
;
483 list
= g_new0(VncBasicInfoList
, 1);
489 static void qmp_query_auth(VncDisplay
*vd
, VncInfo2
*info
)
493 info
->auth
= VNC_PRIMARY_AUTH_VNC
;
496 info
->auth
= VNC_PRIMARY_AUTH_RA2
;
499 info
->auth
= VNC_PRIMARY_AUTH_RA2NE
;
502 info
->auth
= VNC_PRIMARY_AUTH_TIGHT
;
505 info
->auth
= VNC_PRIMARY_AUTH_ULTRA
;
508 info
->auth
= VNC_PRIMARY_AUTH_TLS
;
510 case VNC_AUTH_VENCRYPT
:
511 info
->auth
= VNC_PRIMARY_AUTH_VENCRYPT
;
512 info
->has_vencrypt
= true;
513 switch (vd
->subauth
) {
514 case VNC_AUTH_VENCRYPT_PLAIN
:
515 info
->vencrypt
= VNC_VENCRYPT_SUB_AUTH_PLAIN
;
517 case VNC_AUTH_VENCRYPT_TLSNONE
:
518 info
->vencrypt
= VNC_VENCRYPT_SUB_AUTH_TLS_NONE
;
520 case VNC_AUTH_VENCRYPT_TLSVNC
:
521 info
->vencrypt
= VNC_VENCRYPT_SUB_AUTH_TLS_VNC
;
523 case VNC_AUTH_VENCRYPT_TLSPLAIN
:
524 info
->vencrypt
= VNC_VENCRYPT_SUB_AUTH_TLS_PLAIN
;
526 case VNC_AUTH_VENCRYPT_X509NONE
:
527 info
->vencrypt
= VNC_VENCRYPT_SUB_AUTH_X509_NONE
;
529 case VNC_AUTH_VENCRYPT_X509VNC
:
530 info
->vencrypt
= VNC_VENCRYPT_SUB_AUTH_X509_VNC
;
532 case VNC_AUTH_VENCRYPT_X509PLAIN
:
533 info
->vencrypt
= VNC_VENCRYPT_SUB_AUTH_X509_PLAIN
;
535 case VNC_AUTH_VENCRYPT_TLSSASL
:
536 info
->vencrypt
= VNC_VENCRYPT_SUB_AUTH_TLS_SASL
;
538 case VNC_AUTH_VENCRYPT_X509SASL
:
539 info
->vencrypt
= VNC_VENCRYPT_SUB_AUTH_X509_SASL
;
542 info
->has_vencrypt
= false;
547 info
->auth
= VNC_PRIMARY_AUTH_SASL
;
551 info
->auth
= VNC_PRIMARY_AUTH_NONE
;
556 VncInfo2List
*qmp_query_vnc_servers(Error
**errp
)
558 VncInfo2List
*item
, *prev
= NULL
;
563 QTAILQ_FOREACH(vd
, &vnc_displays
, next
) {
564 info
= g_new0(VncInfo2
, 1);
565 info
->id
= g_strdup(vd
->id
);
566 info
->clients
= qmp_query_client_list(vd
);
567 qmp_query_auth(vd
, info
);
569 dev
= DEVICE(object_property_get_link(OBJECT(vd
->dcl
.con
),
571 info
->has_display
= true;
572 info
->display
= g_strdup(dev
->id
);
574 if (vd
->lsock
!= -1) {
575 info
->server
= qmp_query_server_entry(vd
->lsock
, false,
578 if (vd
->lwebsock
!= -1) {
579 info
->server
= qmp_query_server_entry(vd
->lwebsock
, true,
583 item
= g_new0(VncInfo2List
, 1);
592 1) Get the queue working for IO.
593 2) there is some weirdness when using the -S option (the screen is grey
594 and not totally invalidated
595 3) resolutions > 1024
598 static int vnc_update_client(VncState
*vs
, int has_dirty
, bool sync
);
599 static void vnc_disconnect_start(VncState
*vs
);
601 static void vnc_colordepth(VncState
*vs
);
602 static void framebuffer_update_request(VncState
*vs
, int incremental
,
603 int x_position
, int y_position
,
605 static void vnc_refresh(DisplayChangeListener
*dcl
);
606 static int vnc_refresh_server_surface(VncDisplay
*vd
);
608 static void vnc_set_area_dirty(DECLARE_BITMAP(dirty
[VNC_MAX_HEIGHT
],
609 VNC_MAX_WIDTH
/ VNC_DIRTY_PIXELS_PER_BIT
),
610 int width
, int height
,
611 int x
, int y
, int w
, int h
) {
612 /* this is needed this to ensure we updated all affected
613 * blocks if x % VNC_DIRTY_PIXELS_PER_BIT != 0 */
614 w
+= (x
% VNC_DIRTY_PIXELS_PER_BIT
);
615 x
-= (x
% VNC_DIRTY_PIXELS_PER_BIT
);
619 w
= MIN(x
+ w
, width
) - x
;
620 h
= MIN(y
+ h
, height
);
623 bitmap_set(dirty
[y
], x
/ VNC_DIRTY_PIXELS_PER_BIT
,
624 DIV_ROUND_UP(w
, VNC_DIRTY_PIXELS_PER_BIT
));
628 static void vnc_dpy_update(DisplayChangeListener
*dcl
,
629 int x
, int y
, int w
, int h
)
631 VncDisplay
*vd
= container_of(dcl
, VncDisplay
, dcl
);
632 struct VncSurface
*s
= &vd
->guest
;
633 int width
= pixman_image_get_width(vd
->server
);
634 int height
= pixman_image_get_height(vd
->server
);
636 vnc_set_area_dirty(s
->dirty
, width
, height
, x
, y
, w
, h
);
639 void vnc_framebuffer_update(VncState
*vs
, int x
, int y
, int w
, int h
,
642 vnc_write_u16(vs
, x
);
643 vnc_write_u16(vs
, y
);
644 vnc_write_u16(vs
, w
);
645 vnc_write_u16(vs
, h
);
647 vnc_write_s32(vs
, encoding
);
651 static void vnc_desktop_resize(VncState
*vs
)
653 if (vs
->csock
== -1 || !vnc_has_feature(vs
, VNC_FEATURE_RESIZE
)) {
656 if (vs
->client_width
== pixman_image_get_width(vs
->vd
->server
) &&
657 vs
->client_height
== pixman_image_get_height(vs
->vd
->server
)) {
660 vs
->client_width
= pixman_image_get_width(vs
->vd
->server
);
661 vs
->client_height
= pixman_image_get_height(vs
->vd
->server
);
663 vnc_write_u8(vs
, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE
);
665 vnc_write_u16(vs
, 1); /* number of rects */
666 vnc_framebuffer_update(vs
, 0, 0, vs
->client_width
, vs
->client_height
,
667 VNC_ENCODING_DESKTOPRESIZE
);
668 vnc_unlock_output(vs
);
672 static void vnc_abort_display_jobs(VncDisplay
*vd
)
676 QTAILQ_FOREACH(vs
, &vd
->clients
, next
) {
679 vnc_unlock_output(vs
);
681 QTAILQ_FOREACH(vs
, &vd
->clients
, next
) {
684 QTAILQ_FOREACH(vs
, &vd
->clients
, next
) {
687 vnc_unlock_output(vs
);
691 int vnc_server_fb_stride(VncDisplay
*vd
)
693 return pixman_image_get_stride(vd
->server
);
696 void *vnc_server_fb_ptr(VncDisplay
*vd
, int x
, int y
)
700 ptr
= (uint8_t *)pixman_image_get_data(vd
->server
);
701 ptr
+= y
* vnc_server_fb_stride(vd
);
702 ptr
+= x
* VNC_SERVER_FB_BYTES
;
706 static void vnc_dpy_switch(DisplayChangeListener
*dcl
,
707 DisplaySurface
*surface
)
709 VncDisplay
*vd
= container_of(dcl
, VncDisplay
, dcl
);
713 vnc_abort_display_jobs(vd
);
716 qemu_pixman_image_unref(vd
->server
);
718 width
= MIN(VNC_MAX_WIDTH
, ROUND_UP(surface_width(vd
->ds
),
719 VNC_DIRTY_PIXELS_PER_BIT
));
720 height
= MIN(VNC_MAX_HEIGHT
, surface_height(vd
->ds
));
721 vd
->server
= pixman_image_create_bits(VNC_SERVER_FB_FORMAT
,
722 width
, height
, NULL
, 0);
726 if (ds_get_bytes_per_pixel(ds
) != vd
->guest
.ds
->pf
.bytes_per_pixel
)
727 console_color_init(ds
);
729 qemu_pixman_image_unref(vd
->guest
.fb
);
730 vd
->guest
.fb
= pixman_image_ref(surface
->image
);
731 vd
->guest
.format
= surface
->format
;
732 memset(vd
->guest
.dirty
, 0x00, sizeof(vd
->guest
.dirty
));
733 vnc_set_area_dirty(vd
->guest
.dirty
, width
, height
, 0, 0,
736 QTAILQ_FOREACH(vs
, &vd
->clients
, next
) {
738 vnc_desktop_resize(vs
);
739 if (vs
->vd
->cursor
) {
740 vnc_cursor_define(vs
);
742 memset(vs
->dirty
, 0x00, sizeof(vs
->dirty
));
743 vnc_set_area_dirty(vs
->dirty
, width
, height
, 0, 0,
749 static void vnc_write_pixels_copy(VncState
*vs
,
750 void *pixels
, int size
)
752 vnc_write(vs
, pixels
, size
);
755 /* slowest but generic code. */
756 void vnc_convert_pixel(VncState
*vs
, uint8_t *buf
, uint32_t v
)
760 #if VNC_SERVER_FB_FORMAT == PIXMAN_FORMAT(32, PIXMAN_TYPE_ARGB, 0, 8, 8, 8)
761 r
= (((v
& 0x00ff0000) >> 16) << vs
->client_pf
.rbits
) >> 8;
762 g
= (((v
& 0x0000ff00) >> 8) << vs
->client_pf
.gbits
) >> 8;
763 b
= (((v
& 0x000000ff) >> 0) << vs
->client_pf
.bbits
) >> 8;
765 # error need some bits here if you change VNC_SERVER_FB_FORMAT
767 v
= (r
<< vs
->client_pf
.rshift
) |
768 (g
<< vs
->client_pf
.gshift
) |
769 (b
<< vs
->client_pf
.bshift
);
770 switch (vs
->client_pf
.bytes_per_pixel
) {
800 static void vnc_write_pixels_generic(VncState
*vs
,
801 void *pixels1
, int size
)
805 if (VNC_SERVER_FB_BYTES
== 4) {
806 uint32_t *pixels
= pixels1
;
809 for (i
= 0; i
< n
; i
++) {
810 vnc_convert_pixel(vs
, buf
, pixels
[i
]);
811 vnc_write(vs
, buf
, vs
->client_pf
.bytes_per_pixel
);
816 int vnc_raw_send_framebuffer_update(VncState
*vs
, int x
, int y
, int w
, int h
)
820 VncDisplay
*vd
= vs
->vd
;
822 row
= vnc_server_fb_ptr(vd
, x
, y
);
823 for (i
= 0; i
< h
; i
++) {
824 vs
->write_pixels(vs
, row
, w
* VNC_SERVER_FB_BYTES
);
825 row
+= vnc_server_fb_stride(vd
);
830 int vnc_send_framebuffer_update(VncState
*vs
, int x
, int y
, int w
, int h
)
834 switch(vs
->vnc_encoding
) {
835 case VNC_ENCODING_ZLIB
:
836 n
= vnc_zlib_send_framebuffer_update(vs
, x
, y
, w
, h
);
838 case VNC_ENCODING_HEXTILE
:
839 vnc_framebuffer_update(vs
, x
, y
, w
, h
, VNC_ENCODING_HEXTILE
);
840 n
= vnc_hextile_send_framebuffer_update(vs
, x
, y
, w
, h
);
842 case VNC_ENCODING_TIGHT
:
843 n
= vnc_tight_send_framebuffer_update(vs
, x
, y
, w
, h
);
845 case VNC_ENCODING_TIGHT_PNG
:
846 n
= vnc_tight_png_send_framebuffer_update(vs
, x
, y
, w
, h
);
848 case VNC_ENCODING_ZRLE
:
849 n
= vnc_zrle_send_framebuffer_update(vs
, x
, y
, w
, h
);
851 case VNC_ENCODING_ZYWRLE
:
852 n
= vnc_zywrle_send_framebuffer_update(vs
, x
, y
, w
, h
);
855 vnc_framebuffer_update(vs
, x
, y
, w
, h
, VNC_ENCODING_RAW
);
856 n
= vnc_raw_send_framebuffer_update(vs
, x
, y
, w
, h
);
862 static void vnc_copy(VncState
*vs
, int src_x
, int src_y
, int dst_x
, int dst_y
, int w
, int h
)
864 /* send bitblit op to the vnc client */
866 vnc_write_u8(vs
, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE
);
868 vnc_write_u16(vs
, 1); /* number of rects */
869 vnc_framebuffer_update(vs
, dst_x
, dst_y
, w
, h
, VNC_ENCODING_COPYRECT
);
870 vnc_write_u16(vs
, src_x
);
871 vnc_write_u16(vs
, src_y
);
872 vnc_unlock_output(vs
);
876 static void vnc_dpy_copy(DisplayChangeListener
*dcl
,
877 int src_x
, int src_y
,
878 int dst_x
, int dst_y
, int w
, int h
)
880 VncDisplay
*vd
= container_of(dcl
, VncDisplay
, dcl
);
884 int i
, x
, y
, pitch
, inc
, w_lim
, s
;
887 vnc_refresh_server_surface(vd
);
888 QTAILQ_FOREACH_SAFE(vs
, &vd
->clients
, next
, vn
) {
889 if (vnc_has_feature(vs
, VNC_FEATURE_COPYRECT
)) {
890 vs
->force_update
= 1;
891 vnc_update_client(vs
, 1, true);
892 /* vs might be free()ed here */
896 /* do bitblit op on the local surface too */
897 pitch
= vnc_server_fb_stride(vd
);
898 src_row
= vnc_server_fb_ptr(vd
, src_x
, src_y
);
899 dst_row
= vnc_server_fb_ptr(vd
, dst_x
, dst_y
);
904 src_row
+= pitch
* (h
-1);
905 dst_row
+= pitch
* (h
-1);
910 w_lim
= w
- (VNC_DIRTY_PIXELS_PER_BIT
- (dst_x
% VNC_DIRTY_PIXELS_PER_BIT
));
914 w_lim
= w
- (w_lim
% VNC_DIRTY_PIXELS_PER_BIT
);
916 for (i
= 0; i
< h
; i
++) {
917 for (x
= 0; x
<= w_lim
;
918 x
+= s
, src_row
+= cmp_bytes
, dst_row
+= cmp_bytes
) {
920 if ((s
= w
- w_lim
) == 0)
923 s
= (VNC_DIRTY_PIXELS_PER_BIT
-
924 (dst_x
% VNC_DIRTY_PIXELS_PER_BIT
));
927 s
= VNC_DIRTY_PIXELS_PER_BIT
;
929 cmp_bytes
= s
* VNC_SERVER_FB_BYTES
;
930 if (memcmp(src_row
, dst_row
, cmp_bytes
) == 0)
932 memmove(dst_row
, src_row
, cmp_bytes
);
933 QTAILQ_FOREACH(vs
, &vd
->clients
, next
) {
934 if (!vnc_has_feature(vs
, VNC_FEATURE_COPYRECT
)) {
935 set_bit(((x
+ dst_x
) / VNC_DIRTY_PIXELS_PER_BIT
),
940 src_row
+= pitch
- w
* VNC_SERVER_FB_BYTES
;
941 dst_row
+= pitch
- w
* VNC_SERVER_FB_BYTES
;
945 QTAILQ_FOREACH(vs
, &vd
->clients
, next
) {
946 if (vnc_has_feature(vs
, VNC_FEATURE_COPYRECT
)) {
947 vnc_copy(vs
, src_x
, src_y
, dst_x
, dst_y
, w
, h
);
952 static void vnc_mouse_set(DisplayChangeListener
*dcl
,
953 int x
, int y
, int visible
)
955 /* can we ask the client(s) to move the pointer ??? */
958 static int vnc_cursor_define(VncState
*vs
)
960 QEMUCursor
*c
= vs
->vd
->cursor
;
963 if (vnc_has_feature(vs
, VNC_FEATURE_RICH_CURSOR
)) {
965 vnc_write_u8(vs
, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE
);
966 vnc_write_u8(vs
, 0); /* padding */
967 vnc_write_u16(vs
, 1); /* # of rects */
968 vnc_framebuffer_update(vs
, c
->hot_x
, c
->hot_y
, c
->width
, c
->height
,
969 VNC_ENCODING_RICH_CURSOR
);
970 isize
= c
->width
* c
->height
* vs
->client_pf
.bytes_per_pixel
;
971 vnc_write_pixels_generic(vs
, c
->data
, isize
);
972 vnc_write(vs
, vs
->vd
->cursor_mask
, vs
->vd
->cursor_msize
);
973 vnc_unlock_output(vs
);
979 static void vnc_dpy_cursor_define(DisplayChangeListener
*dcl
,
982 VncDisplay
*vd
= container_of(dcl
, VncDisplay
, dcl
);
985 cursor_put(vd
->cursor
);
986 g_free(vd
->cursor_mask
);
989 cursor_get(vd
->cursor
);
990 vd
->cursor_msize
= cursor_get_mono_bpl(c
) * c
->height
;
991 vd
->cursor_mask
= g_malloc0(vd
->cursor_msize
);
992 cursor_get_mono_mask(c
, 0, vd
->cursor_mask
);
994 QTAILQ_FOREACH(vs
, &vd
->clients
, next
) {
995 vnc_cursor_define(vs
);
999 static int find_and_clear_dirty_height(VncState
*vs
,
1000 int y
, int last_x
, int x
, int height
)
1004 for (h
= 1; h
< (height
- y
); h
++) {
1005 if (!test_bit(last_x
, vs
->dirty
[y
+ h
])) {
1008 bitmap_clear(vs
->dirty
[y
+ h
], last_x
, x
- last_x
);
1014 static int vnc_update_client(VncState
*vs
, int has_dirty
, bool sync
)
1016 vs
->has_dirty
+= has_dirty
;
1017 if (vs
->need_update
&& vs
->csock
!= -1) {
1018 VncDisplay
*vd
= vs
->vd
;
1024 if (vs
->output
.offset
&& !vs
->audio_cap
&& !vs
->force_update
)
1025 /* kernel send buffers are full -> drop frames to throttle */
1028 if (!vs
->has_dirty
&& !vs
->audio_cap
&& !vs
->force_update
)
1032 * Send screen updates to the vnc client using the server
1033 * surface and server dirty map. guest surface updates
1034 * happening in parallel don't disturb us, the next pass will
1035 * send them to the client.
1037 job
= vnc_job_new(vs
);
1039 height
= pixman_image_get_height(vd
->server
);
1040 width
= pixman_image_get_width(vd
->server
);
1046 unsigned long offset
= find_next_bit((unsigned long *) &vs
->dirty
,
1047 height
* VNC_DIRTY_BPL(vs
),
1048 y
* VNC_DIRTY_BPL(vs
));
1049 if (offset
== height
* VNC_DIRTY_BPL(vs
)) {
1050 /* no more dirty bits */
1053 y
= offset
/ VNC_DIRTY_BPL(vs
);
1054 x
= offset
% VNC_DIRTY_BPL(vs
);
1055 x2
= find_next_zero_bit((unsigned long *) &vs
->dirty
[y
],
1056 VNC_DIRTY_BPL(vs
), x
);
1057 bitmap_clear(vs
->dirty
[y
], x
, x2
- x
);
1058 h
= find_and_clear_dirty_height(vs
, y
, x
, x2
, height
);
1059 x2
= MIN(x2
, width
/ VNC_DIRTY_PIXELS_PER_BIT
);
1061 n
+= vnc_job_add_rect(job
, x
* VNC_DIRTY_PIXELS_PER_BIT
, y
,
1062 (x2
- x
) * VNC_DIRTY_PIXELS_PER_BIT
, h
);
1064 if (!x
&& x2
== width
/ VNC_DIRTY_PIXELS_PER_BIT
) {
1076 vs
->force_update
= 0;
1081 if (vs
->csock
== -1) {
1082 vnc_disconnect_finish(vs
);
1091 static void audio_capture_notify(void *opaque
, audcnotification_e cmd
)
1093 VncState
*vs
= opaque
;
1096 case AUD_CNOTIFY_DISABLE
:
1097 vnc_lock_output(vs
);
1098 vnc_write_u8(vs
, VNC_MSG_SERVER_QEMU
);
1099 vnc_write_u8(vs
, VNC_MSG_SERVER_QEMU_AUDIO
);
1100 vnc_write_u16(vs
, VNC_MSG_SERVER_QEMU_AUDIO_END
);
1101 vnc_unlock_output(vs
);
1105 case AUD_CNOTIFY_ENABLE
:
1106 vnc_lock_output(vs
);
1107 vnc_write_u8(vs
, VNC_MSG_SERVER_QEMU
);
1108 vnc_write_u8(vs
, VNC_MSG_SERVER_QEMU_AUDIO
);
1109 vnc_write_u16(vs
, VNC_MSG_SERVER_QEMU_AUDIO_BEGIN
);
1110 vnc_unlock_output(vs
);
1116 static void audio_capture_destroy(void *opaque
)
1120 static void audio_capture(void *opaque
, void *buf
, int size
)
1122 VncState
*vs
= opaque
;
1124 vnc_lock_output(vs
);
1125 vnc_write_u8(vs
, VNC_MSG_SERVER_QEMU
);
1126 vnc_write_u8(vs
, VNC_MSG_SERVER_QEMU_AUDIO
);
1127 vnc_write_u16(vs
, VNC_MSG_SERVER_QEMU_AUDIO_DATA
);
1128 vnc_write_u32(vs
, size
);
1129 vnc_write(vs
, buf
, size
);
1130 vnc_unlock_output(vs
);
1134 static void audio_add(VncState
*vs
)
1136 struct audio_capture_ops ops
;
1138 if (vs
->audio_cap
) {
1139 error_report("audio already running");
1143 ops
.notify
= audio_capture_notify
;
1144 ops
.destroy
= audio_capture_destroy
;
1145 ops
.capture
= audio_capture
;
1147 vs
->audio_cap
= AUD_add_capture(&vs
->as
, &ops
, vs
);
1148 if (!vs
->audio_cap
) {
1149 error_report("Failed to add audio capture");
1153 static void audio_del(VncState
*vs
)
1155 if (vs
->audio_cap
) {
1156 AUD_del_capture(vs
->audio_cap
, vs
);
1157 vs
->audio_cap
= NULL
;
1161 static void vnc_disconnect_start(VncState
*vs
)
1163 if (vs
->csock
== -1)
1165 vnc_set_share_mode(vs
, VNC_SHARE_MODE_DISCONNECTED
);
1166 qemu_set_fd_handler(vs
->csock
, NULL
, NULL
, NULL
);
1167 closesocket(vs
->csock
);
1171 void vnc_disconnect_finish(VncState
*vs
)
1175 vnc_jobs_join(vs
); /* Wait encoding jobs */
1177 vnc_lock_output(vs
);
1178 vnc_qmp_event(vs
, QAPI_EVENT_VNC_DISCONNECTED
);
1180 buffer_free(&vs
->input
);
1181 buffer_free(&vs
->output
);
1182 buffer_free(&vs
->ws_input
);
1183 buffer_free(&vs
->ws_output
);
1185 qapi_free_VncClientInfo(vs
->info
);
1188 vnc_tight_clear(vs
);
1191 qcrypto_tls_session_free(vs
->tls
);
1192 #ifdef CONFIG_VNC_SASL
1193 vnc_sasl_client_cleanup(vs
);
1194 #endif /* CONFIG_VNC_SASL */
1196 vnc_release_modifiers(vs
);
1198 if (vs
->initialized
) {
1199 QTAILQ_REMOVE(&vs
->vd
->clients
, vs
, next
);
1200 qemu_remove_mouse_mode_change_notifier(&vs
->mouse_mode_notifier
);
1203 if (vs
->vd
->lock_key_sync
)
1204 qemu_remove_led_event_handler(vs
->led
);
1205 vnc_unlock_output(vs
);
1207 qemu_mutex_destroy(&vs
->output_mutex
);
1208 if (vs
->bh
!= NULL
) {
1209 qemu_bh_delete(vs
->bh
);
1211 buffer_free(&vs
->jobs_buffer
);
1213 for (i
= 0; i
< VNC_STAT_ROWS
; ++i
) {
1214 g_free(vs
->lossy_rect
[i
]);
1216 g_free(vs
->lossy_rect
);
1220 ssize_t
vnc_client_io_error(VncState
*vs
, ssize_t ret
, int last_errno
)
1222 if (ret
== 0 || ret
== -1) {
1224 switch (last_errno
) {
1228 case WSAEWOULDBLOCK
:
1236 VNC_DEBUG("Closing down client sock: ret %zd, errno %d\n",
1237 ret
, ret
< 0 ? last_errno
: 0);
1238 vnc_disconnect_start(vs
);
1246 void vnc_client_error(VncState
*vs
)
1248 VNC_DEBUG("Closing down client sock: protocol error\n");
1249 vnc_disconnect_start(vs
);
1253 ssize_t
vnc_tls_pull(char *buf
, size_t len
, void *opaque
)
1255 VncState
*vs
= opaque
;
1259 ret
= qemu_recv(vs
->csock
, buf
, len
, 0);
1261 if (errno
== EINTR
) {
1270 ssize_t
vnc_tls_push(const char *buf
, size_t len
, void *opaque
)
1272 VncState
*vs
= opaque
;
1276 ret
= send(vs
->csock
, buf
, len
, 0);
1278 if (errno
== EINTR
) {
1288 * Called to write a chunk of data to the client socket. The data may
1289 * be the raw data, or may have already been encoded by SASL.
1290 * The data will be written either straight onto the socket, or
1291 * written via the GNUTLS wrappers, if TLS/SSL encryption is enabled
1293 * NB, it is theoretically possible to have 2 layers of encryption,
1294 * both SASL, and this TLS layer. It is highly unlikely in practice
1295 * though, since SASL encryption will typically be a no-op if TLS
1298 * Returns the number of bytes written, which may be less than
1299 * the requested 'datalen' if the socket would block. Returns
1300 * -1 on error, and disconnects the client socket.
1302 ssize_t
vnc_client_write_buf(VncState
*vs
, const uint8_t *data
, size_t datalen
)
1307 ret
= qcrypto_tls_session_write(vs
->tls
, (const char *)data
, datalen
);
1312 ret
= send(vs
->csock
, (const void *)data
, datalen
, 0);
1314 err
= socket_error();
1317 VNC_DEBUG("Wrote wire %p %zd -> %ld\n", data
, datalen
, ret
);
1318 return vnc_client_io_error(vs
, ret
, err
);
1323 * Called to write buffered data to the client socket, when not
1324 * using any SASL SSF encryption layers. Will write as much data
1325 * as possible without blocking. If all buffered data is written,
1326 * will switch the FD poll() handler back to read monitoring.
1328 * Returns the number of bytes written, which may be less than
1329 * the buffered output data if the socket would block. Returns
1330 * -1 on error, and disconnects the client socket.
1332 static ssize_t
vnc_client_write_plain(VncState
*vs
)
1336 #ifdef CONFIG_VNC_SASL
1337 VNC_DEBUG("Write Plain: Pending output %p size %zd offset %zd. Wait SSF %d\n",
1338 vs
->output
.buffer
, vs
->output
.capacity
, vs
->output
.offset
,
1339 vs
->sasl
.waitWriteSSF
);
1341 if (vs
->sasl
.conn
&&
1343 vs
->sasl
.waitWriteSSF
) {
1344 ret
= vnc_client_write_buf(vs
, vs
->output
.buffer
, vs
->sasl
.waitWriteSSF
);
1346 vs
->sasl
.waitWriteSSF
-= ret
;
1348 #endif /* CONFIG_VNC_SASL */
1349 ret
= vnc_client_write_buf(vs
, vs
->output
.buffer
, vs
->output
.offset
);
1353 buffer_advance(&vs
->output
, ret
);
1355 if (vs
->output
.offset
== 0) {
1356 qemu_set_fd_handler(vs
->csock
, vnc_client_read
, NULL
, vs
);
1364 * First function called whenever there is data to be written to
1365 * the client socket. Will delegate actual work according to whether
1366 * SASL SSF layers are enabled (thus requiring encryption calls)
1368 static void vnc_client_write_locked(void *opaque
)
1370 VncState
*vs
= opaque
;
1372 #ifdef CONFIG_VNC_SASL
1373 if (vs
->sasl
.conn
&&
1375 !vs
->sasl
.waitWriteSSF
) {
1376 vnc_client_write_sasl(vs
);
1378 #endif /* CONFIG_VNC_SASL */
1380 if (vs
->encode_ws
) {
1381 vnc_client_write_ws(vs
);
1383 vnc_client_write_plain(vs
);
1388 void vnc_client_write(void *opaque
)
1390 VncState
*vs
= opaque
;
1392 vnc_lock_output(vs
);
1393 if (vs
->output
.offset
|| vs
->ws_output
.offset
) {
1394 vnc_client_write_locked(opaque
);
1395 } else if (vs
->csock
!= -1) {
1396 qemu_set_fd_handler(vs
->csock
, vnc_client_read
, NULL
, vs
);
1398 vnc_unlock_output(vs
);
1401 void vnc_read_when(VncState
*vs
, VncReadEvent
*func
, size_t expecting
)
1403 vs
->read_handler
= func
;
1404 vs
->read_handler_expect
= expecting
;
1409 * Called to read a chunk of data from the client socket. The data may
1410 * be the raw data, or may need to be further decoded by SASL.
1411 * The data will be read either straight from to the socket, or
1412 * read via the GNUTLS wrappers, if TLS/SSL encryption is enabled
1414 * NB, it is theoretically possible to have 2 layers of encryption,
1415 * both SASL, and this TLS layer. It is highly unlikely in practice
1416 * though, since SASL encryption will typically be a no-op if TLS
1419 * Returns the number of bytes read, which may be less than
1420 * the requested 'datalen' if the socket would block. Returns
1421 * -1 on error, and disconnects the client socket.
1423 ssize_t
vnc_client_read_buf(VncState
*vs
, uint8_t *data
, size_t datalen
)
1428 ret
= qcrypto_tls_session_read(vs
->tls
, (char *)data
, datalen
);
1433 ret
= qemu_recv(vs
->csock
, data
, datalen
, 0);
1435 err
= socket_error();
1438 VNC_DEBUG("Read wire %p %zd -> %ld\n", data
, datalen
, ret
);
1439 return vnc_client_io_error(vs
, ret
, err
);
1444 * Called to read data from the client socket to the input buffer,
1445 * when not using any SASL SSF encryption layers. Will read as much
1446 * data as possible without blocking.
1448 * Returns the number of bytes read. Returns -1 on error, and
1449 * disconnects the client socket.
1451 static ssize_t
vnc_client_read_plain(VncState
*vs
)
1454 VNC_DEBUG("Read plain %p size %zd offset %zd\n",
1455 vs
->input
.buffer
, vs
->input
.capacity
, vs
->input
.offset
);
1456 buffer_reserve(&vs
->input
, 4096);
1457 ret
= vnc_client_read_buf(vs
, buffer_end(&vs
->input
), 4096);
1460 vs
->input
.offset
+= ret
;
1464 static void vnc_jobs_bh(void *opaque
)
1466 VncState
*vs
= opaque
;
1468 vnc_jobs_consume_buffer(vs
);
1472 * First function called whenever there is more data to be read from
1473 * the client socket. Will delegate actual work according to whether
1474 * SASL SSF layers are enabled (thus requiring decryption calls)
1476 void vnc_client_read(void *opaque
)
1478 VncState
*vs
= opaque
;
1481 #ifdef CONFIG_VNC_SASL
1482 if (vs
->sasl
.conn
&& vs
->sasl
.runSSF
)
1483 ret
= vnc_client_read_sasl(vs
);
1485 #endif /* CONFIG_VNC_SASL */
1486 if (vs
->encode_ws
) {
1487 ret
= vnc_client_read_ws(vs
);
1489 vnc_disconnect_start(vs
);
1491 } else if (ret
== -2) {
1492 vnc_client_error(vs
);
1496 ret
= vnc_client_read_plain(vs
);
1499 if (vs
->csock
== -1)
1500 vnc_disconnect_finish(vs
);
1504 while (vs
->read_handler
&& vs
->input
.offset
>= vs
->read_handler_expect
) {
1505 size_t len
= vs
->read_handler_expect
;
1508 ret
= vs
->read_handler(vs
, vs
->input
.buffer
, len
);
1509 if (vs
->csock
== -1) {
1510 vnc_disconnect_finish(vs
);
1515 buffer_advance(&vs
->input
, len
);
1517 vs
->read_handler_expect
= ret
;
1522 void vnc_write(VncState
*vs
, const void *data
, size_t len
)
1524 buffer_reserve(&vs
->output
, len
);
1526 if (vs
->csock
!= -1 && buffer_empty(&vs
->output
)) {
1527 qemu_set_fd_handler(vs
->csock
, vnc_client_read
, vnc_client_write
, vs
);
1530 buffer_append(&vs
->output
, data
, len
);
1533 void vnc_write_s32(VncState
*vs
, int32_t value
)
1535 vnc_write_u32(vs
, *(uint32_t *)&value
);
1538 void vnc_write_u32(VncState
*vs
, uint32_t value
)
1542 buf
[0] = (value
>> 24) & 0xFF;
1543 buf
[1] = (value
>> 16) & 0xFF;
1544 buf
[2] = (value
>> 8) & 0xFF;
1545 buf
[3] = value
& 0xFF;
1547 vnc_write(vs
, buf
, 4);
1550 void vnc_write_u16(VncState
*vs
, uint16_t value
)
1554 buf
[0] = (value
>> 8) & 0xFF;
1555 buf
[1] = value
& 0xFF;
1557 vnc_write(vs
, buf
, 2);
1560 void vnc_write_u8(VncState
*vs
, uint8_t value
)
1562 vnc_write(vs
, (char *)&value
, 1);
1565 void vnc_flush(VncState
*vs
)
1567 vnc_lock_output(vs
);
1568 if (vs
->csock
!= -1 && (vs
->output
.offset
||
1569 vs
->ws_output
.offset
)) {
1570 vnc_client_write_locked(vs
);
1572 vnc_unlock_output(vs
);
1575 static uint8_t read_u8(uint8_t *data
, size_t offset
)
1577 return data
[offset
];
1580 static uint16_t read_u16(uint8_t *data
, size_t offset
)
1582 return ((data
[offset
] & 0xFF) << 8) | (data
[offset
+ 1] & 0xFF);
1585 static int32_t read_s32(uint8_t *data
, size_t offset
)
1587 return (int32_t)((data
[offset
] << 24) | (data
[offset
+ 1] << 16) |
1588 (data
[offset
+ 2] << 8) | data
[offset
+ 3]);
1591 uint32_t read_u32(uint8_t *data
, size_t offset
)
1593 return ((data
[offset
] << 24) | (data
[offset
+ 1] << 16) |
1594 (data
[offset
+ 2] << 8) | data
[offset
+ 3]);
1597 static void client_cut_text(VncState
*vs
, size_t len
, uint8_t *text
)
1601 static void check_pointer_type_change(Notifier
*notifier
, void *data
)
1603 VncState
*vs
= container_of(notifier
, VncState
, mouse_mode_notifier
);
1604 int absolute
= qemu_input_is_absolute();
1606 if (vnc_has_feature(vs
, VNC_FEATURE_POINTER_TYPE_CHANGE
) && vs
->absolute
!= absolute
) {
1607 vnc_lock_output(vs
);
1608 vnc_write_u8(vs
, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE
);
1609 vnc_write_u8(vs
, 0);
1610 vnc_write_u16(vs
, 1);
1611 vnc_framebuffer_update(vs
, absolute
, 0,
1612 pixman_image_get_width(vs
->vd
->server
),
1613 pixman_image_get_height(vs
->vd
->server
),
1614 VNC_ENCODING_POINTER_TYPE_CHANGE
);
1615 vnc_unlock_output(vs
);
1618 vs
->absolute
= absolute
;
1621 static void pointer_event(VncState
*vs
, int button_mask
, int x
, int y
)
1623 static uint32_t bmap
[INPUT_BUTTON_MAX
] = {
1624 [INPUT_BUTTON_LEFT
] = 0x01,
1625 [INPUT_BUTTON_MIDDLE
] = 0x02,
1626 [INPUT_BUTTON_RIGHT
] = 0x04,
1627 [INPUT_BUTTON_WHEEL_UP
] = 0x08,
1628 [INPUT_BUTTON_WHEEL_DOWN
] = 0x10,
1630 QemuConsole
*con
= vs
->vd
->dcl
.con
;
1631 int width
= pixman_image_get_width(vs
->vd
->server
);
1632 int height
= pixman_image_get_height(vs
->vd
->server
);
1634 if (vs
->last_bmask
!= button_mask
) {
1635 qemu_input_update_buttons(con
, bmap
, vs
->last_bmask
, button_mask
);
1636 vs
->last_bmask
= button_mask
;
1640 qemu_input_queue_abs(con
, INPUT_AXIS_X
, x
, width
);
1641 qemu_input_queue_abs(con
, INPUT_AXIS_Y
, y
, height
);
1642 } else if (vnc_has_feature(vs
, VNC_FEATURE_POINTER_TYPE_CHANGE
)) {
1643 qemu_input_queue_rel(con
, INPUT_AXIS_X
, x
- 0x7FFF);
1644 qemu_input_queue_rel(con
, INPUT_AXIS_Y
, y
- 0x7FFF);
1646 if (vs
->last_x
!= -1) {
1647 qemu_input_queue_rel(con
, INPUT_AXIS_X
, x
- vs
->last_x
);
1648 qemu_input_queue_rel(con
, INPUT_AXIS_Y
, y
- vs
->last_y
);
1653 qemu_input_event_sync();
1656 static void reset_keys(VncState
*vs
)
1659 for(i
= 0; i
< 256; i
++) {
1660 if (vs
->modifiers_state
[i
]) {
1661 qemu_input_event_send_key_number(vs
->vd
->dcl
.con
, i
, false);
1662 vs
->modifiers_state
[i
] = 0;
1667 static void press_key(VncState
*vs
, int keysym
)
1669 int keycode
= keysym2scancode(vs
->vd
->kbd_layout
, keysym
) & SCANCODE_KEYMASK
;
1670 qemu_input_event_send_key_number(vs
->vd
->dcl
.con
, keycode
, true);
1671 qemu_input_event_send_key_delay(0);
1672 qemu_input_event_send_key_number(vs
->vd
->dcl
.con
, keycode
, false);
1673 qemu_input_event_send_key_delay(0);
1676 static int current_led_state(VncState
*vs
)
1680 if (vs
->modifiers_state
[0x46]) {
1681 ledstate
|= QEMU_SCROLL_LOCK_LED
;
1683 if (vs
->modifiers_state
[0x45]) {
1684 ledstate
|= QEMU_NUM_LOCK_LED
;
1686 if (vs
->modifiers_state
[0x3a]) {
1687 ledstate
|= QEMU_CAPS_LOCK_LED
;
1693 static void vnc_led_state_change(VncState
*vs
)
1697 if (!vnc_has_feature(vs
, VNC_FEATURE_LED_STATE
)) {
1701 ledstate
= current_led_state(vs
);
1702 vnc_lock_output(vs
);
1703 vnc_write_u8(vs
, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE
);
1704 vnc_write_u8(vs
, 0);
1705 vnc_write_u16(vs
, 1);
1706 vnc_framebuffer_update(vs
, 0, 0, 1, 1, VNC_ENCODING_LED_STATE
);
1707 vnc_write_u8(vs
, ledstate
);
1708 vnc_unlock_output(vs
);
1712 static void kbd_leds(void *opaque
, int ledstate
)
1714 VncState
*vs
= opaque
;
1716 bool has_changed
= (ledstate
!= current_led_state(vs
));
1718 trace_vnc_key_guest_leds((ledstate
& QEMU_CAPS_LOCK_LED
),
1719 (ledstate
& QEMU_NUM_LOCK_LED
),
1720 (ledstate
& QEMU_SCROLL_LOCK_LED
));
1722 caps
= ledstate
& QEMU_CAPS_LOCK_LED
? 1 : 0;
1723 num
= ledstate
& QEMU_NUM_LOCK_LED
? 1 : 0;
1724 scr
= ledstate
& QEMU_SCROLL_LOCK_LED
? 1 : 0;
1726 if (vs
->modifiers_state
[0x3a] != caps
) {
1727 vs
->modifiers_state
[0x3a] = caps
;
1729 if (vs
->modifiers_state
[0x45] != num
) {
1730 vs
->modifiers_state
[0x45] = num
;
1732 if (vs
->modifiers_state
[0x46] != scr
) {
1733 vs
->modifiers_state
[0x46] = scr
;
1736 /* Sending the current led state message to the client */
1738 vnc_led_state_change(vs
);
1742 static void do_key_event(VncState
*vs
, int down
, int keycode
, int sym
)
1744 /* QEMU console switch */
1746 case 0x2a: /* Left Shift */
1747 case 0x36: /* Right Shift */
1748 case 0x1d: /* Left CTRL */
1749 case 0x9d: /* Right CTRL */
1750 case 0x38: /* Left ALT */
1751 case 0xb8: /* Right ALT */
1753 vs
->modifiers_state
[keycode
] = 1;
1755 vs
->modifiers_state
[keycode
] = 0;
1757 case 0x02 ... 0x0a: /* '1' to '9' keys */
1758 if (vs
->vd
->dcl
.con
== NULL
&&
1759 down
&& vs
->modifiers_state
[0x1d] && vs
->modifiers_state
[0x38]) {
1760 /* Reset the modifiers sent to the current console */
1762 console_select(keycode
- 0x02);
1766 case 0x3a: /* CapsLock */
1767 case 0x45: /* NumLock */
1769 vs
->modifiers_state
[keycode
] ^= 1;
1773 /* Turn off the lock state sync logic if the client support the led
1776 if (down
&& vs
->vd
->lock_key_sync
&&
1777 !vnc_has_feature(vs
, VNC_FEATURE_LED_STATE
) &&
1778 keycode_is_keypad(vs
->vd
->kbd_layout
, keycode
)) {
1779 /* If the numlock state needs to change then simulate an additional
1780 keypress before sending this one. This will happen if the user
1781 toggles numlock away from the VNC window.
1783 if (keysym_is_numlock(vs
->vd
->kbd_layout
, sym
& 0xFFFF)) {
1784 if (!vs
->modifiers_state
[0x45]) {
1785 trace_vnc_key_sync_numlock(true);
1786 vs
->modifiers_state
[0x45] = 1;
1787 press_key(vs
, 0xff7f);
1790 if (vs
->modifiers_state
[0x45]) {
1791 trace_vnc_key_sync_numlock(false);
1792 vs
->modifiers_state
[0x45] = 0;
1793 press_key(vs
, 0xff7f);
1798 if (down
&& vs
->vd
->lock_key_sync
&&
1799 !vnc_has_feature(vs
, VNC_FEATURE_LED_STATE
) &&
1800 ((sym
>= 'A' && sym
<= 'Z') || (sym
>= 'a' && sym
<= 'z'))) {
1801 /* If the capslock state needs to change then simulate an additional
1802 keypress before sending this one. This will happen if the user
1803 toggles capslock away from the VNC window.
1805 int uppercase
= !!(sym
>= 'A' && sym
<= 'Z');
1806 int shift
= !!(vs
->modifiers_state
[0x2a] | vs
->modifiers_state
[0x36]);
1807 int capslock
= !!(vs
->modifiers_state
[0x3a]);
1809 if (uppercase
== shift
) {
1810 trace_vnc_key_sync_capslock(false);
1811 vs
->modifiers_state
[0x3a] = 0;
1812 press_key(vs
, 0xffe5);
1815 if (uppercase
!= shift
) {
1816 trace_vnc_key_sync_capslock(true);
1817 vs
->modifiers_state
[0x3a] = 1;
1818 press_key(vs
, 0xffe5);
1823 if (qemu_console_is_graphic(NULL
)) {
1824 qemu_input_event_send_key_number(vs
->vd
->dcl
.con
, keycode
, down
);
1826 bool numlock
= vs
->modifiers_state
[0x45];
1827 bool control
= (vs
->modifiers_state
[0x1d] ||
1828 vs
->modifiers_state
[0x9d]);
1829 /* QEMU console emulation */
1832 case 0x2a: /* Left Shift */
1833 case 0x36: /* Right Shift */
1834 case 0x1d: /* Left CTRL */
1835 case 0x9d: /* Right CTRL */
1836 case 0x38: /* Left ALT */
1837 case 0xb8: /* Right ALT */
1840 kbd_put_keysym(QEMU_KEY_UP
);
1843 kbd_put_keysym(QEMU_KEY_DOWN
);
1846 kbd_put_keysym(QEMU_KEY_LEFT
);
1849 kbd_put_keysym(QEMU_KEY_RIGHT
);
1852 kbd_put_keysym(QEMU_KEY_DELETE
);
1855 kbd_put_keysym(QEMU_KEY_HOME
);
1858 kbd_put_keysym(QEMU_KEY_END
);
1861 kbd_put_keysym(QEMU_KEY_PAGEUP
);
1864 kbd_put_keysym(QEMU_KEY_PAGEDOWN
);
1868 kbd_put_keysym(numlock
? '7' : QEMU_KEY_HOME
);
1871 kbd_put_keysym(numlock
? '8' : QEMU_KEY_UP
);
1874 kbd_put_keysym(numlock
? '9' : QEMU_KEY_PAGEUP
);
1877 kbd_put_keysym(numlock
? '4' : QEMU_KEY_LEFT
);
1880 kbd_put_keysym('5');
1883 kbd_put_keysym(numlock
? '6' : QEMU_KEY_RIGHT
);
1886 kbd_put_keysym(numlock
? '1' : QEMU_KEY_END
);
1889 kbd_put_keysym(numlock
? '2' : QEMU_KEY_DOWN
);
1892 kbd_put_keysym(numlock
? '3' : QEMU_KEY_PAGEDOWN
);
1895 kbd_put_keysym('0');
1898 kbd_put_keysym(numlock
? '.' : QEMU_KEY_DELETE
);
1902 kbd_put_keysym('/');
1905 kbd_put_keysym('*');
1908 kbd_put_keysym('-');
1911 kbd_put_keysym('+');
1914 kbd_put_keysym('\n');
1919 kbd_put_keysym(sym
& 0x1f);
1921 kbd_put_keysym(sym
);
1929 static void vnc_release_modifiers(VncState
*vs
)
1931 static const int keycodes
[] = {
1932 /* shift, control, alt keys, both left & right */
1933 0x2a, 0x36, 0x1d, 0x9d, 0x38, 0xb8,
1937 if (!qemu_console_is_graphic(NULL
)) {
1940 for (i
= 0; i
< ARRAY_SIZE(keycodes
); i
++) {
1941 keycode
= keycodes
[i
];
1942 if (!vs
->modifiers_state
[keycode
]) {
1945 qemu_input_event_send_key_number(vs
->vd
->dcl
.con
, keycode
, false);
1949 static const char *code2name(int keycode
)
1951 return QKeyCode_lookup
[qemu_input_key_number_to_qcode(keycode
)];
1954 static void key_event(VncState
*vs
, int down
, uint32_t sym
)
1959 if (lsym
>= 'A' && lsym
<= 'Z' && qemu_console_is_graphic(NULL
)) {
1960 lsym
= lsym
- 'A' + 'a';
1963 keycode
= keysym2scancode(vs
->vd
->kbd_layout
, lsym
& 0xFFFF) & SCANCODE_KEYMASK
;
1964 trace_vnc_key_event_map(down
, sym
, keycode
, code2name(keycode
));
1965 do_key_event(vs
, down
, keycode
, sym
);
1968 static void ext_key_event(VncState
*vs
, int down
,
1969 uint32_t sym
, uint16_t keycode
)
1971 /* if the user specifies a keyboard layout, always use it */
1972 if (keyboard_layout
) {
1973 key_event(vs
, down
, sym
);
1975 trace_vnc_key_event_ext(down
, sym
, keycode
, code2name(keycode
));
1976 do_key_event(vs
, down
, keycode
, sym
);
1980 static void framebuffer_update_request(VncState
*vs
, int incremental
,
1981 int x
, int y
, int w
, int h
)
1983 int width
= pixman_image_get_width(vs
->vd
->server
);
1984 int height
= pixman_image_get_height(vs
->vd
->server
);
1986 vs
->need_update
= 1;
1992 vs
->force_update
= 1;
1993 vnc_set_area_dirty(vs
->dirty
, width
, height
, x
, y
, w
, h
);
1996 static void send_ext_key_event_ack(VncState
*vs
)
1998 vnc_lock_output(vs
);
1999 vnc_write_u8(vs
, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE
);
2000 vnc_write_u8(vs
, 0);
2001 vnc_write_u16(vs
, 1);
2002 vnc_framebuffer_update(vs
, 0, 0,
2003 pixman_image_get_width(vs
->vd
->server
),
2004 pixman_image_get_height(vs
->vd
->server
),
2005 VNC_ENCODING_EXT_KEY_EVENT
);
2006 vnc_unlock_output(vs
);
2010 static void send_ext_audio_ack(VncState
*vs
)
2012 vnc_lock_output(vs
);
2013 vnc_write_u8(vs
, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE
);
2014 vnc_write_u8(vs
, 0);
2015 vnc_write_u16(vs
, 1);
2016 vnc_framebuffer_update(vs
, 0, 0,
2017 pixman_image_get_width(vs
->vd
->server
),
2018 pixman_image_get_height(vs
->vd
->server
),
2019 VNC_ENCODING_AUDIO
);
2020 vnc_unlock_output(vs
);
2024 static void set_encodings(VncState
*vs
, int32_t *encodings
, size_t n_encodings
)
2027 unsigned int enc
= 0;
2030 vs
->vnc_encoding
= 0;
2031 vs
->tight
.compression
= 9;
2032 vs
->tight
.quality
= -1; /* Lossless by default */
2036 * Start from the end because the encodings are sent in order of preference.
2037 * This way the preferred encoding (first encoding defined in the array)
2038 * will be set at the end of the loop.
2040 for (i
= n_encodings
- 1; i
>= 0; i
--) {
2043 case VNC_ENCODING_RAW
:
2044 vs
->vnc_encoding
= enc
;
2046 case VNC_ENCODING_COPYRECT
:
2047 vs
->features
|= VNC_FEATURE_COPYRECT_MASK
;
2049 case VNC_ENCODING_HEXTILE
:
2050 vs
->features
|= VNC_FEATURE_HEXTILE_MASK
;
2051 vs
->vnc_encoding
= enc
;
2053 case VNC_ENCODING_TIGHT
:
2054 vs
->features
|= VNC_FEATURE_TIGHT_MASK
;
2055 vs
->vnc_encoding
= enc
;
2057 #ifdef CONFIG_VNC_PNG
2058 case VNC_ENCODING_TIGHT_PNG
:
2059 vs
->features
|= VNC_FEATURE_TIGHT_PNG_MASK
;
2060 vs
->vnc_encoding
= enc
;
2063 case VNC_ENCODING_ZLIB
:
2064 vs
->features
|= VNC_FEATURE_ZLIB_MASK
;
2065 vs
->vnc_encoding
= enc
;
2067 case VNC_ENCODING_ZRLE
:
2068 vs
->features
|= VNC_FEATURE_ZRLE_MASK
;
2069 vs
->vnc_encoding
= enc
;
2071 case VNC_ENCODING_ZYWRLE
:
2072 vs
->features
|= VNC_FEATURE_ZYWRLE_MASK
;
2073 vs
->vnc_encoding
= enc
;
2075 case VNC_ENCODING_DESKTOPRESIZE
:
2076 vs
->features
|= VNC_FEATURE_RESIZE_MASK
;
2078 case VNC_ENCODING_POINTER_TYPE_CHANGE
:
2079 vs
->features
|= VNC_FEATURE_POINTER_TYPE_CHANGE_MASK
;
2081 case VNC_ENCODING_RICH_CURSOR
:
2082 vs
->features
|= VNC_FEATURE_RICH_CURSOR_MASK
;
2084 case VNC_ENCODING_EXT_KEY_EVENT
:
2085 send_ext_key_event_ack(vs
);
2087 case VNC_ENCODING_AUDIO
:
2088 send_ext_audio_ack(vs
);
2090 case VNC_ENCODING_WMVi
:
2091 vs
->features
|= VNC_FEATURE_WMVI_MASK
;
2093 case VNC_ENCODING_LED_STATE
:
2094 vs
->features
|= VNC_FEATURE_LED_STATE_MASK
;
2096 case VNC_ENCODING_COMPRESSLEVEL0
... VNC_ENCODING_COMPRESSLEVEL0
+ 9:
2097 vs
->tight
.compression
= (enc
& 0x0F);
2099 case VNC_ENCODING_QUALITYLEVEL0
... VNC_ENCODING_QUALITYLEVEL0
+ 9:
2100 if (vs
->vd
->lossy
) {
2101 vs
->tight
.quality
= (enc
& 0x0F);
2105 VNC_DEBUG("Unknown encoding: %d (0x%.8x): %d\n", i
, enc
, enc
);
2109 vnc_desktop_resize(vs
);
2110 check_pointer_type_change(&vs
->mouse_mode_notifier
, NULL
);
2111 vnc_led_state_change(vs
);
2114 static void set_pixel_conversion(VncState
*vs
)
2116 pixman_format_code_t fmt
= qemu_pixman_get_format(&vs
->client_pf
);
2118 if (fmt
== VNC_SERVER_FB_FORMAT
) {
2119 vs
->write_pixels
= vnc_write_pixels_copy
;
2120 vnc_hextile_set_pixel_conversion(vs
, 0);
2122 vs
->write_pixels
= vnc_write_pixels_generic
;
2123 vnc_hextile_set_pixel_conversion(vs
, 1);
2127 static void set_pixel_format(VncState
*vs
,
2128 int bits_per_pixel
, int depth
,
2129 int big_endian_flag
, int true_color_flag
,
2130 int red_max
, int green_max
, int blue_max
,
2131 int red_shift
, int green_shift
, int blue_shift
)
2133 if (!true_color_flag
) {
2134 vnc_client_error(vs
);
2138 switch (bits_per_pixel
) {
2144 vnc_client_error(vs
);
2148 vs
->client_pf
.rmax
= red_max
;
2149 vs
->client_pf
.rbits
= hweight_long(red_max
);
2150 vs
->client_pf
.rshift
= red_shift
;
2151 vs
->client_pf
.rmask
= red_max
<< red_shift
;
2152 vs
->client_pf
.gmax
= green_max
;
2153 vs
->client_pf
.gbits
= hweight_long(green_max
);
2154 vs
->client_pf
.gshift
= green_shift
;
2155 vs
->client_pf
.gmask
= green_max
<< green_shift
;
2156 vs
->client_pf
.bmax
= blue_max
;
2157 vs
->client_pf
.bbits
= hweight_long(blue_max
);
2158 vs
->client_pf
.bshift
= blue_shift
;
2159 vs
->client_pf
.bmask
= blue_max
<< blue_shift
;
2160 vs
->client_pf
.bits_per_pixel
= bits_per_pixel
;
2161 vs
->client_pf
.bytes_per_pixel
= bits_per_pixel
/ 8;
2162 vs
->client_pf
.depth
= bits_per_pixel
== 32 ? 24 : bits_per_pixel
;
2163 vs
->client_be
= big_endian_flag
;
2165 set_pixel_conversion(vs
);
2167 graphic_hw_invalidate(vs
->vd
->dcl
.con
);
2168 graphic_hw_update(vs
->vd
->dcl
.con
);
2171 static void pixel_format_message (VncState
*vs
) {
2172 char pad
[3] = { 0, 0, 0 };
2174 vs
->client_pf
= qemu_default_pixelformat(32);
2176 vnc_write_u8(vs
, vs
->client_pf
.bits_per_pixel
); /* bits-per-pixel */
2177 vnc_write_u8(vs
, vs
->client_pf
.depth
); /* depth */
2179 #ifdef HOST_WORDS_BIGENDIAN
2180 vnc_write_u8(vs
, 1); /* big-endian-flag */
2182 vnc_write_u8(vs
, 0); /* big-endian-flag */
2184 vnc_write_u8(vs
, 1); /* true-color-flag */
2185 vnc_write_u16(vs
, vs
->client_pf
.rmax
); /* red-max */
2186 vnc_write_u16(vs
, vs
->client_pf
.gmax
); /* green-max */
2187 vnc_write_u16(vs
, vs
->client_pf
.bmax
); /* blue-max */
2188 vnc_write_u8(vs
, vs
->client_pf
.rshift
); /* red-shift */
2189 vnc_write_u8(vs
, vs
->client_pf
.gshift
); /* green-shift */
2190 vnc_write_u8(vs
, vs
->client_pf
.bshift
); /* blue-shift */
2191 vnc_write(vs
, pad
, 3); /* padding */
2193 vnc_hextile_set_pixel_conversion(vs
, 0);
2194 vs
->write_pixels
= vnc_write_pixels_copy
;
2197 static void vnc_colordepth(VncState
*vs
)
2199 if (vnc_has_feature(vs
, VNC_FEATURE_WMVI
)) {
2200 /* Sending a WMVi message to notify the client*/
2201 vnc_lock_output(vs
);
2202 vnc_write_u8(vs
, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE
);
2203 vnc_write_u8(vs
, 0);
2204 vnc_write_u16(vs
, 1); /* number of rects */
2205 vnc_framebuffer_update(vs
, 0, 0,
2206 pixman_image_get_width(vs
->vd
->server
),
2207 pixman_image_get_height(vs
->vd
->server
),
2209 pixel_format_message(vs
);
2210 vnc_unlock_output(vs
);
2213 set_pixel_conversion(vs
);
2217 static int protocol_client_msg(VncState
*vs
, uint8_t *data
, size_t len
)
2221 VncDisplay
*vd
= vs
->vd
;
2224 update_displaychangelistener(&vd
->dcl
, VNC_REFRESH_INTERVAL_BASE
);
2228 case VNC_MSG_CLIENT_SET_PIXEL_FORMAT
:
2232 set_pixel_format(vs
, read_u8(data
, 4), read_u8(data
, 5),
2233 read_u8(data
, 6), read_u8(data
, 7),
2234 read_u16(data
, 8), read_u16(data
, 10),
2235 read_u16(data
, 12), read_u8(data
, 14),
2236 read_u8(data
, 15), read_u8(data
, 16));
2238 case VNC_MSG_CLIENT_SET_ENCODINGS
:
2243 limit
= read_u16(data
, 2);
2245 return 4 + (limit
* 4);
2247 limit
= read_u16(data
, 2);
2249 for (i
= 0; i
< limit
; i
++) {
2250 int32_t val
= read_s32(data
, 4 + (i
* 4));
2251 memcpy(data
+ 4 + (i
* 4), &val
, sizeof(val
));
2254 set_encodings(vs
, (int32_t *)(data
+ 4), limit
);
2256 case VNC_MSG_CLIENT_FRAMEBUFFER_UPDATE_REQUEST
:
2260 framebuffer_update_request(vs
,
2261 read_u8(data
, 1), read_u16(data
, 2), read_u16(data
, 4),
2262 read_u16(data
, 6), read_u16(data
, 8));
2264 case VNC_MSG_CLIENT_KEY_EVENT
:
2268 key_event(vs
, read_u8(data
, 1), read_u32(data
, 4));
2270 case VNC_MSG_CLIENT_POINTER_EVENT
:
2274 pointer_event(vs
, read_u8(data
, 1), read_u16(data
, 2), read_u16(data
, 4));
2276 case VNC_MSG_CLIENT_CUT_TEXT
:
2281 uint32_t dlen
= read_u32(data
, 4);
2282 if (dlen
> (1 << 20)) {
2283 error_report("vnc: client_cut_text msg payload has %u bytes"
2284 " which exceeds our limit of 1MB.", dlen
);
2285 vnc_client_error(vs
);
2293 client_cut_text(vs
, read_u32(data
, 4), data
+ 8);
2295 case VNC_MSG_CLIENT_QEMU
:
2299 switch (read_u8(data
, 1)) {
2300 case VNC_MSG_CLIENT_QEMU_EXT_KEY_EVENT
:
2304 ext_key_event(vs
, read_u16(data
, 2),
2305 read_u32(data
, 4), read_u32(data
, 8));
2307 case VNC_MSG_CLIENT_QEMU_AUDIO
:
2311 switch (read_u16 (data
, 2)) {
2312 case VNC_MSG_CLIENT_QEMU_AUDIO_ENABLE
:
2315 case VNC_MSG_CLIENT_QEMU_AUDIO_DISABLE
:
2318 case VNC_MSG_CLIENT_QEMU_AUDIO_SET_FORMAT
:
2321 switch (read_u8(data
, 4)) {
2322 case 0: vs
->as
.fmt
= AUD_FMT_U8
; break;
2323 case 1: vs
->as
.fmt
= AUD_FMT_S8
; break;
2324 case 2: vs
->as
.fmt
= AUD_FMT_U16
; break;
2325 case 3: vs
->as
.fmt
= AUD_FMT_S16
; break;
2326 case 4: vs
->as
.fmt
= AUD_FMT_U32
; break;
2327 case 5: vs
->as
.fmt
= AUD_FMT_S32
; break;
2329 VNC_DEBUG("Invalid audio format %d\n", read_u8(data
, 4));
2330 vnc_client_error(vs
);
2333 vs
->as
.nchannels
= read_u8(data
, 5);
2334 if (vs
->as
.nchannels
!= 1 && vs
->as
.nchannels
!= 2) {
2335 VNC_DEBUG("Invalid audio channel coount %d\n",
2337 vnc_client_error(vs
);
2340 vs
->as
.freq
= read_u32(data
, 6);
2343 VNC_DEBUG("Invalid audio message %d\n", read_u8(data
, 4));
2344 vnc_client_error(vs
);
2350 VNC_DEBUG("Msg: %d\n", read_u16(data
, 0));
2351 vnc_client_error(vs
);
2356 VNC_DEBUG("Msg: %d\n", data
[0]);
2357 vnc_client_error(vs
);
2361 vnc_read_when(vs
, protocol_client_msg
, 1);
2365 static int protocol_client_init(VncState
*vs
, uint8_t *data
, size_t len
)
2371 mode
= data
[0] ? VNC_SHARE_MODE_SHARED
: VNC_SHARE_MODE_EXCLUSIVE
;
2372 switch (vs
->vd
->share_policy
) {
2373 case VNC_SHARE_POLICY_IGNORE
:
2375 * Ignore the shared flag. Nothing to do here.
2377 * Doesn't conform to the rfb spec but is traditional qemu
2378 * behavior, thus left here as option for compatibility
2382 case VNC_SHARE_POLICY_ALLOW_EXCLUSIVE
:
2384 * Policy: Allow clients ask for exclusive access.
2386 * Implementation: When a client asks for exclusive access,
2387 * disconnect all others. Shared connects are allowed as long
2388 * as no exclusive connection exists.
2390 * This is how the rfb spec suggests to handle the shared flag.
2392 if (mode
== VNC_SHARE_MODE_EXCLUSIVE
) {
2394 QTAILQ_FOREACH(client
, &vs
->vd
->clients
, next
) {
2398 if (client
->share_mode
!= VNC_SHARE_MODE_EXCLUSIVE
&&
2399 client
->share_mode
!= VNC_SHARE_MODE_SHARED
) {
2402 vnc_disconnect_start(client
);
2405 if (mode
== VNC_SHARE_MODE_SHARED
) {
2406 if (vs
->vd
->num_exclusive
> 0) {
2407 vnc_disconnect_start(vs
);
2412 case VNC_SHARE_POLICY_FORCE_SHARED
:
2414 * Policy: Shared connects only.
2415 * Implementation: Disallow clients asking for exclusive access.
2417 * Useful for shared desktop sessions where you don't want
2418 * someone forgetting to say -shared when running the vnc
2419 * client disconnect everybody else.
2421 if (mode
== VNC_SHARE_MODE_EXCLUSIVE
) {
2422 vnc_disconnect_start(vs
);
2427 vnc_set_share_mode(vs
, mode
);
2429 if (vs
->vd
->num_shared
> vs
->vd
->connections_limit
) {
2430 vnc_disconnect_start(vs
);
2434 vs
->client_width
= pixman_image_get_width(vs
->vd
->server
);
2435 vs
->client_height
= pixman_image_get_height(vs
->vd
->server
);
2436 vnc_write_u16(vs
, vs
->client_width
);
2437 vnc_write_u16(vs
, vs
->client_height
);
2439 pixel_format_message(vs
);
2442 size
= snprintf(buf
, sizeof(buf
), "QEMU (%s)", qemu_name
);
2444 size
= snprintf(buf
, sizeof(buf
), "QEMU");
2446 vnc_write_u32(vs
, size
);
2447 vnc_write(vs
, buf
, size
);
2450 vnc_client_cache_auth(vs
);
2451 vnc_qmp_event(vs
, QAPI_EVENT_VNC_INITIALIZED
);
2453 vnc_read_when(vs
, protocol_client_msg
, 1);
2458 void start_client_init(VncState
*vs
)
2460 vnc_read_when(vs
, protocol_client_init
, 1);
2463 static void make_challenge(VncState
*vs
)
2467 srand(time(NULL
)+getpid()+getpid()*987654+rand());
2469 for (i
= 0 ; i
< sizeof(vs
->challenge
) ; i
++)
2470 vs
->challenge
[i
] = (int) (256.0*rand()/(RAND_MAX
+1.0));
2473 static int protocol_client_auth_vnc(VncState
*vs
, uint8_t *data
, size_t len
)
2475 unsigned char response
[VNC_AUTH_CHALLENGE_SIZE
];
2477 unsigned char key
[8];
2478 time_t now
= time(NULL
);
2479 QCryptoCipher
*cipher
= NULL
;
2482 if (!vs
->vd
->password
) {
2483 VNC_DEBUG("No password configured on server");
2486 if (vs
->vd
->expires
< now
) {
2487 VNC_DEBUG("Password is expired");
2491 memcpy(response
, vs
->challenge
, VNC_AUTH_CHALLENGE_SIZE
);
2493 /* Calculate the expected challenge response */
2494 pwlen
= strlen(vs
->vd
->password
);
2495 for (i
=0; i
<sizeof(key
); i
++)
2496 key
[i
] = i
<pwlen
? vs
->vd
->password
[i
] : 0;
2498 cipher
= qcrypto_cipher_new(
2499 QCRYPTO_CIPHER_ALG_DES_RFB
,
2500 QCRYPTO_CIPHER_MODE_ECB
,
2501 key
, G_N_ELEMENTS(key
),
2504 VNC_DEBUG("Cannot initialize cipher %s",
2505 error_get_pretty(err
));
2510 if (qcrypto_cipher_encrypt(cipher
,
2513 VNC_AUTH_CHALLENGE_SIZE
,
2515 VNC_DEBUG("Cannot encrypt challenge %s",
2516 error_get_pretty(err
));
2521 /* Compare expected vs actual challenge response */
2522 if (memcmp(response
, data
, VNC_AUTH_CHALLENGE_SIZE
) != 0) {
2523 VNC_DEBUG("Client challenge response did not match\n");
2526 VNC_DEBUG("Accepting VNC challenge response\n");
2527 vnc_write_u32(vs
, 0); /* Accept auth */
2530 start_client_init(vs
);
2533 qcrypto_cipher_free(cipher
);
2537 vnc_write_u32(vs
, 1); /* Reject auth */
2538 if (vs
->minor
>= 8) {
2539 static const char err
[] = "Authentication failed";
2540 vnc_write_u32(vs
, sizeof(err
));
2541 vnc_write(vs
, err
, sizeof(err
));
2544 vnc_client_error(vs
);
2545 qcrypto_cipher_free(cipher
);
2549 void start_auth_vnc(VncState
*vs
)
2552 /* Send client a 'random' challenge */
2553 vnc_write(vs
, vs
->challenge
, sizeof(vs
->challenge
));
2556 vnc_read_when(vs
, protocol_client_auth_vnc
, sizeof(vs
->challenge
));
2560 static int protocol_client_auth(VncState
*vs
, uint8_t *data
, size_t len
)
2562 /* We only advertise 1 auth scheme at a time, so client
2563 * must pick the one we sent. Verify this */
2564 if (data
[0] != vs
->auth
) { /* Reject auth */
2565 VNC_DEBUG("Reject auth %d because it didn't match advertized\n", (int)data
[0]);
2566 vnc_write_u32(vs
, 1);
2567 if (vs
->minor
>= 8) {
2568 static const char err
[] = "Authentication failed";
2569 vnc_write_u32(vs
, sizeof(err
));
2570 vnc_write(vs
, err
, sizeof(err
));
2572 vnc_client_error(vs
);
2573 } else { /* Accept requested auth */
2574 VNC_DEBUG("Client requested auth %d\n", (int)data
[0]);
2577 VNC_DEBUG("Accept auth none\n");
2578 if (vs
->minor
>= 8) {
2579 vnc_write_u32(vs
, 0); /* Accept auth completion */
2582 start_client_init(vs
);
2586 VNC_DEBUG("Start VNC auth\n");
2590 case VNC_AUTH_VENCRYPT
:
2591 VNC_DEBUG("Accept VeNCrypt auth\n");
2592 start_auth_vencrypt(vs
);
2595 #ifdef CONFIG_VNC_SASL
2597 VNC_DEBUG("Accept SASL auth\n");
2598 start_auth_sasl(vs
);
2600 #endif /* CONFIG_VNC_SASL */
2602 default: /* Should not be possible, but just in case */
2603 VNC_DEBUG("Reject auth %d server code bug\n", vs
->auth
);
2604 vnc_write_u8(vs
, 1);
2605 if (vs
->minor
>= 8) {
2606 static const char err
[] = "Authentication failed";
2607 vnc_write_u32(vs
, sizeof(err
));
2608 vnc_write(vs
, err
, sizeof(err
));
2610 vnc_client_error(vs
);
2616 static int protocol_version(VncState
*vs
, uint8_t *version
, size_t len
)
2620 memcpy(local
, version
, 12);
2623 if (sscanf(local
, "RFB %03d.%03d\n", &vs
->major
, &vs
->minor
) != 2) {
2624 VNC_DEBUG("Malformed protocol version %s\n", local
);
2625 vnc_client_error(vs
);
2628 VNC_DEBUG("Client request protocol version %d.%d\n", vs
->major
, vs
->minor
);
2629 if (vs
->major
!= 3 ||
2635 VNC_DEBUG("Unsupported client version\n");
2636 vnc_write_u32(vs
, VNC_AUTH_INVALID
);
2638 vnc_client_error(vs
);
2641 /* Some broken clients report v3.4 or v3.5, which spec requires to be treated
2642 * as equivalent to v3.3 by servers
2644 if (vs
->minor
== 4 || vs
->minor
== 5)
2647 if (vs
->minor
== 3) {
2648 if (vs
->auth
== VNC_AUTH_NONE
) {
2649 VNC_DEBUG("Tell client auth none\n");
2650 vnc_write_u32(vs
, vs
->auth
);
2652 start_client_init(vs
);
2653 } else if (vs
->auth
== VNC_AUTH_VNC
) {
2654 VNC_DEBUG("Tell client VNC auth\n");
2655 vnc_write_u32(vs
, vs
->auth
);
2659 VNC_DEBUG("Unsupported auth %d for protocol 3.3\n", vs
->auth
);
2660 vnc_write_u32(vs
, VNC_AUTH_INVALID
);
2662 vnc_client_error(vs
);
2665 VNC_DEBUG("Telling client we support auth %d\n", vs
->auth
);
2666 vnc_write_u8(vs
, 1); /* num auth */
2667 vnc_write_u8(vs
, vs
->auth
);
2668 vnc_read_when(vs
, protocol_client_auth
, 1);
2675 static VncRectStat
*vnc_stat_rect(VncDisplay
*vd
, int x
, int y
)
2677 struct VncSurface
*vs
= &vd
->guest
;
2679 return &vs
->stats
[y
/ VNC_STAT_RECT
][x
/ VNC_STAT_RECT
];
2682 void vnc_sent_lossy_rect(VncState
*vs
, int x
, int y
, int w
, int h
)
2686 w
= (x
+ w
) / VNC_STAT_RECT
;
2687 h
= (y
+ h
) / VNC_STAT_RECT
;
2691 for (j
= y
; j
<= h
; j
++) {
2692 for (i
= x
; i
<= w
; i
++) {
2693 vs
->lossy_rect
[j
][i
] = 1;
2698 static int vnc_refresh_lossy_rect(VncDisplay
*vd
, int x
, int y
)
2701 int sty
= y
/ VNC_STAT_RECT
;
2702 int stx
= x
/ VNC_STAT_RECT
;
2705 y
= y
/ VNC_STAT_RECT
* VNC_STAT_RECT
;
2706 x
= x
/ VNC_STAT_RECT
* VNC_STAT_RECT
;
2708 QTAILQ_FOREACH(vs
, &vd
->clients
, next
) {
2711 /* kernel send buffers are full -> refresh later */
2712 if (vs
->output
.offset
) {
2716 if (!vs
->lossy_rect
[sty
][stx
]) {
2720 vs
->lossy_rect
[sty
][stx
] = 0;
2721 for (j
= 0; j
< VNC_STAT_RECT
; ++j
) {
2722 bitmap_set(vs
->dirty
[y
+ j
],
2723 x
/ VNC_DIRTY_PIXELS_PER_BIT
,
2724 VNC_STAT_RECT
/ VNC_DIRTY_PIXELS_PER_BIT
);
2732 static int vnc_update_stats(VncDisplay
*vd
, struct timeval
* tv
)
2734 int width
= pixman_image_get_width(vd
->guest
.fb
);
2735 int height
= pixman_image_get_height(vd
->guest
.fb
);
2740 for (y
= 0; y
< height
; y
+= VNC_STAT_RECT
) {
2741 for (x
= 0; x
< width
; x
+= VNC_STAT_RECT
) {
2742 VncRectStat
*rect
= vnc_stat_rect(vd
, x
, y
);
2744 rect
->updated
= false;
2748 qemu_timersub(tv
, &VNC_REFRESH_STATS
, &res
);
2750 if (timercmp(&vd
->guest
.last_freq_check
, &res
, >)) {
2753 vd
->guest
.last_freq_check
= *tv
;
2755 for (y
= 0; y
< height
; y
+= VNC_STAT_RECT
) {
2756 for (x
= 0; x
< width
; x
+= VNC_STAT_RECT
) {
2757 VncRectStat
*rect
= vnc_stat_rect(vd
, x
, y
);
2758 int count
= ARRAY_SIZE(rect
->times
);
2759 struct timeval min
, max
;
2761 if (!timerisset(&rect
->times
[count
- 1])) {
2765 max
= rect
->times
[(rect
->idx
+ count
- 1) % count
];
2766 qemu_timersub(tv
, &max
, &res
);
2768 if (timercmp(&res
, &VNC_REFRESH_LOSSY
, >)) {
2770 has_dirty
+= vnc_refresh_lossy_rect(vd
, x
, y
);
2771 memset(rect
->times
, 0, sizeof (rect
->times
));
2775 min
= rect
->times
[rect
->idx
];
2776 max
= rect
->times
[(rect
->idx
+ count
- 1) % count
];
2777 qemu_timersub(&max
, &min
, &res
);
2779 rect
->freq
= res
.tv_sec
+ res
.tv_usec
/ 1000000.;
2780 rect
->freq
/= count
;
2781 rect
->freq
= 1. / rect
->freq
;
2787 double vnc_update_freq(VncState
*vs
, int x
, int y
, int w
, int h
)
2793 x
= (x
/ VNC_STAT_RECT
) * VNC_STAT_RECT
;
2794 y
= (y
/ VNC_STAT_RECT
) * VNC_STAT_RECT
;
2796 for (j
= y
; j
<= y
+ h
; j
+= VNC_STAT_RECT
) {
2797 for (i
= x
; i
<= x
+ w
; i
+= VNC_STAT_RECT
) {
2798 total
+= vnc_stat_rect(vs
->vd
, i
, j
)->freq
;
2810 static void vnc_rect_updated(VncDisplay
*vd
, int x
, int y
, struct timeval
* tv
)
2814 rect
= vnc_stat_rect(vd
, x
, y
);
2815 if (rect
->updated
) {
2818 rect
->times
[rect
->idx
] = *tv
;
2819 rect
->idx
= (rect
->idx
+ 1) % ARRAY_SIZE(rect
->times
);
2820 rect
->updated
= true;
2823 static int vnc_refresh_server_surface(VncDisplay
*vd
)
2825 int width
= MIN(pixman_image_get_width(vd
->guest
.fb
),
2826 pixman_image_get_width(vd
->server
));
2827 int height
= MIN(pixman_image_get_height(vd
->guest
.fb
),
2828 pixman_image_get_height(vd
->server
));
2829 int cmp_bytes
, server_stride
, line_bytes
, guest_ll
, guest_stride
, y
= 0;
2830 uint8_t *guest_row0
= NULL
, *server_row0
;
2833 pixman_image_t
*tmpbuf
= NULL
;
2835 struct timeval tv
= { 0, 0 };
2837 if (!vd
->non_adaptive
) {
2838 gettimeofday(&tv
, NULL
);
2839 has_dirty
= vnc_update_stats(vd
, &tv
);
2843 * Walk through the guest dirty map.
2844 * Check and copy modified bits from guest to server surface.
2845 * Update server dirty map.
2847 server_row0
= (uint8_t *)pixman_image_get_data(vd
->server
);
2848 server_stride
= guest_stride
= guest_ll
=
2849 pixman_image_get_stride(vd
->server
);
2850 cmp_bytes
= MIN(VNC_DIRTY_PIXELS_PER_BIT
* VNC_SERVER_FB_BYTES
,
2852 if (vd
->guest
.format
!= VNC_SERVER_FB_FORMAT
) {
2853 int width
= pixman_image_get_width(vd
->server
);
2854 tmpbuf
= qemu_pixman_linebuf_create(VNC_SERVER_FB_FORMAT
, width
);
2857 PIXMAN_FORMAT_BPP(pixman_image_get_format(vd
->guest
.fb
));
2858 guest_row0
= (uint8_t *)pixman_image_get_data(vd
->guest
.fb
);
2859 guest_stride
= pixman_image_get_stride(vd
->guest
.fb
);
2860 guest_ll
= pixman_image_get_width(vd
->guest
.fb
) * ((guest_bpp
+ 7) / 8);
2862 line_bytes
= MIN(server_stride
, guest_ll
);
2866 uint8_t *guest_ptr
, *server_ptr
;
2867 unsigned long offset
= find_next_bit((unsigned long *) &vd
->guest
.dirty
,
2868 height
* VNC_DIRTY_BPL(&vd
->guest
),
2869 y
* VNC_DIRTY_BPL(&vd
->guest
));
2870 if (offset
== height
* VNC_DIRTY_BPL(&vd
->guest
)) {
2871 /* no more dirty bits */
2874 y
= offset
/ VNC_DIRTY_BPL(&vd
->guest
);
2875 x
= offset
% VNC_DIRTY_BPL(&vd
->guest
);
2877 server_ptr
= server_row0
+ y
* server_stride
+ x
* cmp_bytes
;
2879 if (vd
->guest
.format
!= VNC_SERVER_FB_FORMAT
) {
2880 qemu_pixman_linebuf_fill(tmpbuf
, vd
->guest
.fb
, width
, 0, y
);
2881 guest_ptr
= (uint8_t *)pixman_image_get_data(tmpbuf
);
2883 guest_ptr
= guest_row0
+ y
* guest_stride
;
2885 guest_ptr
+= x
* cmp_bytes
;
2887 for (; x
< DIV_ROUND_UP(width
, VNC_DIRTY_PIXELS_PER_BIT
);
2888 x
++, guest_ptr
+= cmp_bytes
, server_ptr
+= cmp_bytes
) {
2889 int _cmp_bytes
= cmp_bytes
;
2890 if (!test_and_clear_bit(x
, vd
->guest
.dirty
[y
])) {
2893 if ((x
+ 1) * cmp_bytes
> line_bytes
) {
2894 _cmp_bytes
= line_bytes
- x
* cmp_bytes
;
2896 assert(_cmp_bytes
>= 0);
2897 if (memcmp(server_ptr
, guest_ptr
, _cmp_bytes
) == 0) {
2900 memcpy(server_ptr
, guest_ptr
, _cmp_bytes
);
2901 if (!vd
->non_adaptive
) {
2902 vnc_rect_updated(vd
, x
* VNC_DIRTY_PIXELS_PER_BIT
,
2905 QTAILQ_FOREACH(vs
, &vd
->clients
, next
) {
2906 set_bit(x
, vs
->dirty
[y
]);
2913 qemu_pixman_image_unref(tmpbuf
);
2917 static void vnc_refresh(DisplayChangeListener
*dcl
)
2919 VncDisplay
*vd
= container_of(dcl
, VncDisplay
, dcl
);
2921 int has_dirty
, rects
= 0;
2923 if (QTAILQ_EMPTY(&vd
->clients
)) {
2924 update_displaychangelistener(&vd
->dcl
, VNC_REFRESH_INTERVAL_MAX
);
2928 graphic_hw_update(vd
->dcl
.con
);
2930 if (vnc_trylock_display(vd
)) {
2931 update_displaychangelistener(&vd
->dcl
, VNC_REFRESH_INTERVAL_BASE
);
2935 has_dirty
= vnc_refresh_server_surface(vd
);
2936 vnc_unlock_display(vd
);
2938 QTAILQ_FOREACH_SAFE(vs
, &vd
->clients
, next
, vn
) {
2939 rects
+= vnc_update_client(vs
, has_dirty
, false);
2940 /* vs might be free()ed here */
2943 if (has_dirty
&& rects
) {
2944 vd
->dcl
.update_interval
/= 2;
2945 if (vd
->dcl
.update_interval
< VNC_REFRESH_INTERVAL_BASE
) {
2946 vd
->dcl
.update_interval
= VNC_REFRESH_INTERVAL_BASE
;
2949 vd
->dcl
.update_interval
+= VNC_REFRESH_INTERVAL_INC
;
2950 if (vd
->dcl
.update_interval
> VNC_REFRESH_INTERVAL_MAX
) {
2951 vd
->dcl
.update_interval
= VNC_REFRESH_INTERVAL_MAX
;
2956 static void vnc_connect(VncDisplay
*vd
, int csock
,
2957 bool skipauth
, bool websocket
)
2959 VncState
*vs
= g_malloc0(sizeof(VncState
));
2966 vs
->auth
= VNC_AUTH_NONE
;
2967 vs
->subauth
= VNC_AUTH_INVALID
;
2970 vs
->auth
= vd
->ws_auth
;
2971 vs
->subauth
= VNC_AUTH_INVALID
;
2973 vs
->auth
= vd
->auth
;
2974 vs
->subauth
= vd
->subauth
;
2977 VNC_DEBUG("Client sock=%d ws=%d auth=%d subauth=%d\n",
2978 csock
, websocket
, vs
->auth
, vs
->subauth
);
2980 vs
->lossy_rect
= g_malloc0(VNC_STAT_ROWS
* sizeof (*vs
->lossy_rect
));
2981 for (i
= 0; i
< VNC_STAT_ROWS
; ++i
) {
2982 vs
->lossy_rect
[i
] = g_malloc0(VNC_STAT_COLS
* sizeof (uint8_t));
2985 VNC_DEBUG("New client on socket %d\n", csock
);
2986 update_displaychangelistener(&vd
->dcl
, VNC_REFRESH_INTERVAL_BASE
);
2987 qemu_set_nonblock(vs
->csock
);
2991 qemu_set_fd_handler(vs
->csock
, vncws_tls_handshake_io
, NULL
, vs
);
2993 qemu_set_fd_handler(vs
->csock
, vncws_handshake_read
, NULL
, vs
);
2997 qemu_set_fd_handler(vs
->csock
, vnc_client_read
, NULL
, vs
);
3000 vnc_client_cache_addr(vs
);
3001 vnc_qmp_event(vs
, QAPI_EVENT_VNC_CONNECTED
);
3002 vnc_set_share_mode(vs
, VNC_SHARE_MODE_CONNECTING
);
3004 if (!vs
->websocket
) {
3008 if (vd
->num_connecting
> vd
->connections_limit
) {
3009 QTAILQ_FOREACH(vs
, &vd
->clients
, next
) {
3010 if (vs
->share_mode
== VNC_SHARE_MODE_CONNECTING
) {
3011 vnc_disconnect_start(vs
);
3018 void vnc_init_state(VncState
*vs
)
3020 vs
->initialized
= true;
3021 VncDisplay
*vd
= vs
->vd
;
3026 vs
->as
.freq
= 44100;
3027 vs
->as
.nchannels
= 2;
3028 vs
->as
.fmt
= AUD_FMT_S16
;
3029 vs
->as
.endianness
= 0;
3031 qemu_mutex_init(&vs
->output_mutex
);
3032 vs
->bh
= qemu_bh_new(vnc_jobs_bh
, vs
);
3034 QTAILQ_INSERT_TAIL(&vd
->clients
, vs
, next
);
3036 graphic_hw_update(vd
->dcl
.con
);
3038 vnc_write(vs
, "RFB 003.008\n", 12);
3040 vnc_read_when(vs
, protocol_version
, 12);
3042 if (vs
->vd
->lock_key_sync
)
3043 vs
->led
= qemu_add_led_event_handler(kbd_leds
, vs
);
3045 vs
->mouse_mode_notifier
.notify
= check_pointer_type_change
;
3046 qemu_add_mouse_mode_change_notifier(&vs
->mouse_mode_notifier
);
3048 /* vs might be free()ed here */
3051 static void vnc_listen_read(void *opaque
, bool websocket
)
3053 VncDisplay
*vs
= opaque
;
3054 struct sockaddr_in addr
;
3055 socklen_t addrlen
= sizeof(addr
);
3059 graphic_hw_update(vs
->dcl
.con
);
3061 csock
= qemu_accept(vs
->lwebsock
, (struct sockaddr
*)&addr
, &addrlen
);
3063 csock
= qemu_accept(vs
->lsock
, (struct sockaddr
*)&addr
, &addrlen
);
3067 socket_set_nodelay(csock
);
3068 vnc_connect(vs
, csock
, false, websocket
);
3072 static void vnc_listen_regular_read(void *opaque
)
3074 vnc_listen_read(opaque
, false);
3077 static void vnc_listen_websocket_read(void *opaque
)
3079 vnc_listen_read(opaque
, true);
3082 static const DisplayChangeListenerOps dcl_ops
= {
3084 .dpy_refresh
= vnc_refresh
,
3085 .dpy_gfx_copy
= vnc_dpy_copy
,
3086 .dpy_gfx_update
= vnc_dpy_update
,
3087 .dpy_gfx_switch
= vnc_dpy_switch
,
3088 .dpy_gfx_check_format
= qemu_pixman_check_format
,
3089 .dpy_mouse_set
= vnc_mouse_set
,
3090 .dpy_cursor_define
= vnc_dpy_cursor_define
,
3093 void vnc_display_init(const char *id
)
3097 if (vnc_display_find(id
) != NULL
) {
3100 vs
= g_malloc0(sizeof(*vs
));
3102 vs
->id
= strdup(id
);
3103 QTAILQ_INSERT_TAIL(&vnc_displays
, vs
, next
);
3108 QTAILQ_INIT(&vs
->clients
);
3109 vs
->expires
= TIME_MAX
;
3111 if (keyboard_layout
) {
3112 trace_vnc_key_map_init(keyboard_layout
);
3113 vs
->kbd_layout
= init_keyboard_layout(name2keysym
, keyboard_layout
);
3115 vs
->kbd_layout
= init_keyboard_layout(name2keysym
, "en-us");
3118 if (!vs
->kbd_layout
)
3121 qemu_mutex_init(&vs
->mutex
);
3122 vnc_start_worker_thread();
3124 vs
->dcl
.ops
= &dcl_ops
;
3125 register_displaychangelistener(&vs
->dcl
);
3129 static void vnc_display_close(VncDisplay
*vs
)
3133 vs
->enabled
= false;
3134 vs
->is_unix
= false;
3135 if (vs
->lsock
!= -1) {
3136 qemu_set_fd_handler(vs
->lsock
, NULL
, NULL
, NULL
);
3140 vs
->ws_enabled
= false;
3141 if (vs
->lwebsock
!= -1) {
3142 qemu_set_fd_handler(vs
->lwebsock
, NULL
, NULL
, NULL
);
3143 close(vs
->lwebsock
);
3146 vs
->auth
= VNC_AUTH_INVALID
;
3147 vs
->subauth
= VNC_AUTH_INVALID
;
3149 object_unparent(OBJECT(vs
->tlscreds
));
3151 g_free(vs
->tlsaclname
);
3152 vs
->tlsaclname
= NULL
;
3155 int vnc_display_password(const char *id
, const char *password
)
3157 VncDisplay
*vs
= vnc_display_find(id
);
3162 if (vs
->auth
== VNC_AUTH_NONE
) {
3163 error_printf_unless_qmp("If you want use passwords please enable "
3164 "password auth using '-vnc ${dpy},password'.");
3168 g_free(vs
->password
);
3169 vs
->password
= g_strdup(password
);
3174 int vnc_display_pw_expire(const char *id
, time_t expires
)
3176 VncDisplay
*vs
= vnc_display_find(id
);
3182 vs
->expires
= expires
;
3186 char *vnc_display_local_addr(const char *id
)
3188 VncDisplay
*vs
= vnc_display_find(id
);
3191 return vnc_socket_local_addr("%s:%s", vs
->lsock
);
3194 static QemuOptsList qemu_vnc_opts
= {
3196 .head
= QTAILQ_HEAD_INITIALIZER(qemu_vnc_opts
.head
),
3197 .implied_opt_name
= "vnc",
3201 .type
= QEMU_OPT_STRING
,
3203 .name
= "websocket",
3204 .type
= QEMU_OPT_STRING
,
3206 .name
= "tls-creds",
3207 .type
= QEMU_OPT_STRING
,
3209 /* Deprecated in favour of tls-creds */
3211 .type
= QEMU_OPT_STRING
,
3214 .type
= QEMU_OPT_STRING
,
3217 .type
= QEMU_OPT_STRING
,
3220 .type
= QEMU_OPT_NUMBER
,
3222 .name
= "connections",
3223 .type
= QEMU_OPT_NUMBER
,
3226 .type
= QEMU_OPT_NUMBER
,
3229 .type
= QEMU_OPT_BOOL
,
3232 .type
= QEMU_OPT_BOOL
,
3235 .type
= QEMU_OPT_BOOL
,
3238 .type
= QEMU_OPT_BOOL
,
3240 .name
= "lock-key-sync",
3241 .type
= QEMU_OPT_BOOL
,
3244 .type
= QEMU_OPT_BOOL
,
3246 /* Deprecated in favour of tls-creds */
3248 .type
= QEMU_OPT_BOOL
,
3250 /* Deprecated in favour of tls-creds */
3251 .name
= "x509verify",
3252 .type
= QEMU_OPT_STRING
,
3255 .type
= QEMU_OPT_BOOL
,
3258 .type
= QEMU_OPT_BOOL
,
3260 .name
= "non-adaptive",
3261 .type
= QEMU_OPT_BOOL
,
3263 { /* end of list */ }
3269 vnc_display_setup_auth(VncDisplay
*vs
,
3276 * We have a choice of 3 authentication options
3282 * The channel can be run in 2 modes
3287 * And TLS can use 2 types of credentials
3292 * We thus have 9 possible logical combinations
3297 * 4. tls + anon + none
3298 * 5. tls + anon + vnc
3299 * 6. tls + anon + sasl
3300 * 7. tls + x509 + none
3301 * 8. tls + x509 + vnc
3302 * 9. tls + x509 + sasl
3304 * These need to be mapped into the VNC auth schemes
3305 * in an appropriate manner. In regular VNC, all the
3306 * TLS options get mapped into VNC_AUTH_VENCRYPT
3309 * In websockets, the https:// protocol already provides
3310 * TLS support, so there is no need to make use of the
3311 * VeNCrypt extension. Furthermore, websockets browser
3312 * clients could not use VeNCrypt even if they wanted to,
3313 * as they cannot control when the TLS handshake takes
3314 * place. Thus there is no option but to rely on https://,
3315 * meaning combinations 4->6 and 7->9 will be mapped to
3316 * VNC auth schemes in the same way as combos 1->3.
3318 * Regardless of fact that we have a different mapping to
3319 * VNC auth mechs for plain VNC vs websockets VNC, the end
3320 * result has the same security characteristics.
3324 vs
->auth
= VNC_AUTH_VENCRYPT
;
3328 if (object_dynamic_cast(OBJECT(vs
->tlscreds
),
3329 TYPE_QCRYPTO_TLS_CREDS_X509
)) {
3330 VNC_DEBUG("Initializing VNC server with x509 password auth\n");
3331 vs
->subauth
= VNC_AUTH_VENCRYPT_X509VNC
;
3332 } else if (object_dynamic_cast(OBJECT(vs
->tlscreds
),
3333 TYPE_QCRYPTO_TLS_CREDS_ANON
)) {
3334 VNC_DEBUG("Initializing VNC server with TLS password auth\n");
3335 vs
->subauth
= VNC_AUTH_VENCRYPT_TLSVNC
;
3338 "Unsupported TLS cred type %s",
3339 object_get_typename(OBJECT(vs
->tlscreds
)));
3343 VNC_DEBUG("Initializing VNC server with password auth\n");
3344 vs
->auth
= VNC_AUTH_VNC
;
3345 vs
->subauth
= VNC_AUTH_INVALID
;
3348 vs
->ws_auth
= VNC_AUTH_VNC
;
3350 vs
->ws_auth
= VNC_AUTH_INVALID
;
3354 vs
->auth
= VNC_AUTH_VENCRYPT
;
3358 if (object_dynamic_cast(OBJECT(vs
->tlscreds
),
3359 TYPE_QCRYPTO_TLS_CREDS_X509
)) {
3360 VNC_DEBUG("Initializing VNC server with x509 SASL auth\n");
3361 vs
->subauth
= VNC_AUTH_VENCRYPT_X509SASL
;
3362 } else if (object_dynamic_cast(OBJECT(vs
->tlscreds
),
3363 TYPE_QCRYPTO_TLS_CREDS_ANON
)) {
3364 VNC_DEBUG("Initializing VNC server with TLS SASL auth\n");
3365 vs
->subauth
= VNC_AUTH_VENCRYPT_TLSSASL
;
3368 "Unsupported TLS cred type %s",
3369 object_get_typename(OBJECT(vs
->tlscreds
)));
3373 VNC_DEBUG("Initializing VNC server with SASL auth\n");
3374 vs
->auth
= VNC_AUTH_SASL
;
3375 vs
->subauth
= VNC_AUTH_INVALID
;
3378 vs
->ws_auth
= VNC_AUTH_SASL
;
3380 vs
->ws_auth
= VNC_AUTH_INVALID
;
3384 vs
->auth
= VNC_AUTH_VENCRYPT
;
3388 if (object_dynamic_cast(OBJECT(vs
->tlscreds
),
3389 TYPE_QCRYPTO_TLS_CREDS_X509
)) {
3390 VNC_DEBUG("Initializing VNC server with x509 no auth\n");
3391 vs
->subauth
= VNC_AUTH_VENCRYPT_X509NONE
;
3392 } else if (object_dynamic_cast(OBJECT(vs
->tlscreds
),
3393 TYPE_QCRYPTO_TLS_CREDS_ANON
)) {
3394 VNC_DEBUG("Initializing VNC server with TLS no auth\n");
3395 vs
->subauth
= VNC_AUTH_VENCRYPT_TLSNONE
;
3398 "Unsupported TLS cred type %s",
3399 object_get_typename(OBJECT(vs
->tlscreds
)));
3403 VNC_DEBUG("Initializing VNC server with no auth\n");
3404 vs
->auth
= VNC_AUTH_NONE
;
3405 vs
->subauth
= VNC_AUTH_INVALID
;
3408 vs
->ws_auth
= VNC_AUTH_NONE
;
3410 vs
->ws_auth
= VNC_AUTH_INVALID
;
3418 * Handle back compat with old CLI syntax by creating some
3419 * suitable QCryptoTLSCreds objects
3421 static QCryptoTLSCreds
*
3422 vnc_display_create_creds(bool x509
,
3428 gchar
*credsid
= g_strdup_printf("tlsvnc%s", id
);
3429 Object
*parent
= object_get_objects_root();
3434 creds
= object_new_with_props(TYPE_QCRYPTO_TLS_CREDS_X509
,
3438 "endpoint", "server",
3440 "verify-peer", x509verify
? "yes" : "no",
3443 creds
= object_new_with_props(TYPE_QCRYPTO_TLS_CREDS_ANON
,
3447 "endpoint", "server",
3454 error_propagate(errp
, err
);
3458 return QCRYPTO_TLS_CREDS(creds
);
3462 void vnc_display_open(const char *id
, Error
**errp
)
3464 VncDisplay
*vs
= vnc_display_find(id
);
3465 QemuOpts
*opts
= qemu_opts_find(&qemu_vnc_opts
, id
);
3466 SocketAddress
*saddr
= NULL
, *wsaddr
= NULL
;
3467 const char *share
, *device_id
;
3469 bool password
= false;
3470 bool reverse
= false;
3475 #ifdef CONFIG_VNC_SASL
3479 int lock_key_sync
= 1;
3482 error_setg(errp
, "VNC display not active");
3485 vnc_display_close(vs
);
3490 vnc
= qemu_opt_get(opts
, "vnc");
3491 if (!vnc
|| strcmp(vnc
, "none") == 0) {
3495 h
= strrchr(vnc
, ':');
3497 size_t hlen
= h
- vnc
;
3499 const char *websocket
= qemu_opt_get(opts
, "websocket");
3500 int to
= qemu_opt_get_number(opts
, "to", 0);
3501 bool has_ipv4
= qemu_opt_get_bool(opts
, "ipv4", false);
3502 bool has_ipv6
= qemu_opt_get_bool(opts
, "ipv6", false);
3504 saddr
= g_new0(SocketAddress
, 1);
3506 if (!qcrypto_hash_supports(QCRYPTO_HASH_ALG_SHA1
)) {
3508 "SHA1 hash support is required for websockets");
3512 wsaddr
= g_new0(SocketAddress
, 1);
3513 vs
->ws_enabled
= true;
3516 if (strncmp(vnc
, "unix:", 5) == 0) {
3517 saddr
->kind
= SOCKET_ADDRESS_KIND_UNIX
;
3518 saddr
->q_unix
= g_new0(UnixSocketAddress
, 1);
3519 saddr
->q_unix
->path
= g_strdup(vnc
+ 5);
3521 if (vs
->ws_enabled
) {
3522 error_setg(errp
, "UNIX sockets not supported with websock");
3526 unsigned long long baseport
;
3527 saddr
->kind
= SOCKET_ADDRESS_KIND_INET
;
3528 saddr
->inet
= g_new0(InetSocketAddress
, 1);
3529 if (vnc
[0] == '[' && vnc
[hlen
- 1] == ']') {
3530 saddr
->inet
->host
= g_strndup(vnc
+ 1, hlen
- 2);
3532 saddr
->inet
->host
= g_strndup(vnc
, hlen
);
3534 if (parse_uint_full(h
+ 1, &baseport
, 10) < 0) {
3535 error_setg(errp
, "can't convert to a number: %s", h
+ 1);
3538 if (baseport
> 65535 ||
3539 baseport
+ 5900 > 65535) {
3540 error_setg(errp
, "port %s out of range", h
+ 1);
3543 saddr
->inet
->port
= g_strdup_printf(
3544 "%d", (int)baseport
+ 5900);
3547 saddr
->inet
->has_to
= true;
3548 saddr
->inet
->to
= to
;
3550 saddr
->inet
->ipv4
= saddr
->inet
->has_ipv4
= has_ipv4
;
3551 saddr
->inet
->ipv6
= saddr
->inet
->has_ipv6
= has_ipv6
;
3553 if (vs
->ws_enabled
) {
3554 wsaddr
->kind
= SOCKET_ADDRESS_KIND_INET
;
3555 wsaddr
->inet
= g_new0(InetSocketAddress
, 1);
3556 wsaddr
->inet
->host
= g_strdup(saddr
->inet
->host
);
3557 wsaddr
->inet
->port
= g_strdup(websocket
);
3560 wsaddr
->inet
->has_to
= true;
3561 wsaddr
->inet
->to
= to
;
3563 wsaddr
->inet
->ipv4
= wsaddr
->inet
->has_ipv4
= has_ipv4
;
3564 wsaddr
->inet
->ipv6
= wsaddr
->inet
->has_ipv6
= has_ipv6
;
3568 error_setg(errp
, "no vnc port specified");
3572 password
= qemu_opt_get_bool(opts
, "password", false);
3574 if (fips_get_state()) {
3576 "VNC password auth disabled due to FIPS mode, "
3577 "consider using the VeNCrypt or SASL authentication "
3578 "methods as an alternative");
3581 if (!qcrypto_cipher_supports(
3582 QCRYPTO_CIPHER_ALG_DES_RFB
)) {
3584 "Cipher backend does not support DES RFB algorithm");
3589 reverse
= qemu_opt_get_bool(opts
, "reverse", false);
3590 lock_key_sync
= qemu_opt_get_bool(opts
, "lock-key-sync", true);
3591 sasl
= qemu_opt_get_bool(opts
, "sasl", false);
3592 #ifndef CONFIG_VNC_SASL
3594 error_setg(errp
, "VNC SASL auth requires cyrus-sasl support");
3597 #endif /* CONFIG_VNC_SASL */
3598 credid
= qemu_opt_get(opts
, "tls-creds");
3601 if (qemu_opt_get(opts
, "tls") ||
3602 qemu_opt_get(opts
, "x509") ||
3603 qemu_opt_get(opts
, "x509verify")) {
3605 "'credid' parameter is mutually exclusive with "
3606 "'tls', 'x509' and 'x509verify' parameters");
3610 creds
= object_resolve_path_component(
3611 object_get_objects_root(), credid
);
3613 error_setg(errp
, "No TLS credentials with id '%s'",
3617 vs
->tlscreds
= (QCryptoTLSCreds
*)
3618 object_dynamic_cast(creds
,
3619 TYPE_QCRYPTO_TLS_CREDS
);
3620 if (!vs
->tlscreds
) {
3621 error_setg(errp
, "Object with id '%s' is not TLS credentials",
3625 object_ref(OBJECT(vs
->tlscreds
));
3627 if (vs
->tlscreds
->endpoint
!= QCRYPTO_TLS_CREDS_ENDPOINT_SERVER
) {
3629 "Expecting TLS credentials with a server endpoint");
3634 bool tls
= false, x509
= false, x509verify
= false;
3635 tls
= qemu_opt_get_bool(opts
, "tls", false);
3637 path
= qemu_opt_get(opts
, "x509");
3642 path
= qemu_opt_get(opts
, "x509verify");
3648 vs
->tlscreds
= vnc_display_create_creds(x509
,
3653 if (!vs
->tlscreds
) {
3658 acl
= qemu_opt_get_bool(opts
, "acl", false);
3660 share
= qemu_opt_get(opts
, "share");
3662 if (strcmp(share
, "ignore") == 0) {
3663 vs
->share_policy
= VNC_SHARE_POLICY_IGNORE
;
3664 } else if (strcmp(share
, "allow-exclusive") == 0) {
3665 vs
->share_policy
= VNC_SHARE_POLICY_ALLOW_EXCLUSIVE
;
3666 } else if (strcmp(share
, "force-shared") == 0) {
3667 vs
->share_policy
= VNC_SHARE_POLICY_FORCE_SHARED
;
3669 error_setg(errp
, "unknown vnc share= option");
3673 vs
->share_policy
= VNC_SHARE_POLICY_ALLOW_EXCLUSIVE
;
3675 vs
->connections_limit
= qemu_opt_get_number(opts
, "connections", 32);
3677 #ifdef CONFIG_VNC_JPEG
3678 vs
->lossy
= qemu_opt_get_bool(opts
, "lossy", false);
3680 vs
->non_adaptive
= qemu_opt_get_bool(opts
, "non-adaptive", false);
3681 /* adaptive updates are only used with tight encoding and
3682 * if lossy updates are enabled so we can disable all the
3683 * calculations otherwise */
3685 vs
->non_adaptive
= true;
3689 if (strcmp(vs
->id
, "default") == 0) {
3690 vs
->tlsaclname
= g_strdup("vnc.x509dname");
3692 vs
->tlsaclname
= g_strdup_printf("vnc.%s.x509dname", vs
->id
);
3694 qemu_acl_init(vs
->tlsaclname
);
3696 #ifdef CONFIG_VNC_SASL
3700 if (strcmp(vs
->id
, "default") == 0) {
3701 aclname
= g_strdup("vnc.username");
3703 aclname
= g_strdup_printf("vnc.%s.username", vs
->id
);
3705 vs
->sasl
.acl
= qemu_acl_init(aclname
);
3710 if (vnc_display_setup_auth(vs
, password
, sasl
, vs
->ws_enabled
, errp
) < 0) {
3714 #ifdef CONFIG_VNC_SASL
3715 if ((saslErr
= sasl_server_init(NULL
, "qemu")) != SASL_OK
) {
3716 error_setg(errp
, "Failed to initialize SASL auth: %s",
3717 sasl_errstring(saslErr
, NULL
, NULL
));
3721 vs
->lock_key_sync
= lock_key_sync
;
3723 device_id
= qemu_opt_get(opts
, "display");
3726 int head
= qemu_opt_get_number(opts
, "head", 0);
3728 dev
= qdev_find_recursive(sysbus_get_default(), device_id
);
3730 error_setg(errp
, "Device '%s' not found", device_id
);
3734 con
= qemu_console_lookup_by_device(dev
, head
);
3736 error_setg(errp
, "Device %s is not bound to a QemuConsole",
3744 if (con
!= vs
->dcl
.con
) {
3745 unregister_displaychangelistener(&vs
->dcl
);
3747 register_displaychangelistener(&vs
->dcl
);
3751 /* connect to viewer */
3755 if (vs
->ws_enabled
) {
3756 error_setg(errp
, "Cannot use websockets in reverse mode");
3759 csock
= socket_connect(saddr
, errp
, NULL
, NULL
);
3763 vs
->is_unix
= saddr
->kind
== SOCKET_ADDRESS_KIND_UNIX
;
3764 vnc_connect(vs
, csock
, false, false);
3766 /* listen for connects */
3767 vs
->lsock
= socket_listen(saddr
, errp
);
3768 if (vs
->lsock
< 0) {
3771 vs
->is_unix
= saddr
->kind
== SOCKET_ADDRESS_KIND_UNIX
;
3772 if (vs
->ws_enabled
) {
3773 vs
->lwebsock
= socket_listen(wsaddr
, errp
);
3774 if (vs
->lwebsock
< 0) {
3775 if (vs
->lsock
!= -1) {
3783 qemu_set_fd_handler(vs
->lsock
, vnc_listen_regular_read
, NULL
, vs
);
3784 if (vs
->ws_enabled
) {
3785 qemu_set_fd_handler(vs
->lwebsock
, vnc_listen_websocket_read
,
3790 qapi_free_SocketAddress(saddr
);
3791 qapi_free_SocketAddress(wsaddr
);
3795 qapi_free_SocketAddress(saddr
);
3796 qapi_free_SocketAddress(wsaddr
);
3797 vs
->enabled
= false;
3798 vs
->ws_enabled
= false;
3801 void vnc_display_add_client(const char *id
, int csock
, bool skipauth
)
3803 VncDisplay
*vs
= vnc_display_find(id
);
3808 vnc_connect(vs
, csock
, skipauth
, false);
3811 static void vnc_auto_assign_id(QemuOptsList
*olist
, QemuOpts
*opts
)
3816 id
= g_strdup("default");
3817 while (qemu_opts_find(olist
, id
)) {
3819 id
= g_strdup_printf("vnc%d", i
++);
3821 qemu_opts_set_id(opts
, id
);
3824 QemuOpts
*vnc_parse(const char *str
, Error
**errp
)
3826 QemuOptsList
*olist
= qemu_find_opts("vnc");
3827 QemuOpts
*opts
= qemu_opts_parse(olist
, str
, true, errp
);
3834 id
= qemu_opts_id(opts
);
3836 /* auto-assign id if not present */
3837 vnc_auto_assign_id(olist
, opts
);
3842 int vnc_init_func(void *opaque
, QemuOpts
*opts
, Error
**errp
)
3844 Error
*local_err
= NULL
;
3845 char *id
= (char *)qemu_opts_id(opts
);
3848 vnc_display_init(id
);
3849 vnc_display_open(id
, &local_err
);
3850 if (local_err
!= NULL
) {
3851 error_report("Failed to start VNC server: %s",
3852 error_get_pretty(local_err
));
3853 error_free(local_err
);
3859 static void vnc_register_config(void)
3861 qemu_add_opts(&qemu_vnc_opts
);
3863 machine_init(vnc_register_config
);