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
30 #include "qemu_socket.h"
31 #include "qemu-timer.h"
33 #include "qemu-objects.h"
34 #include "qmp-commands.h"
37 #define VNC_REFRESH_INTERVAL_BASE 30
38 #define VNC_REFRESH_INTERVAL_INC 50
39 #define VNC_REFRESH_INTERVAL_MAX 2000
40 static const struct timeval VNC_REFRESH_STATS
= { 0, 500000 };
41 static const struct timeval VNC_REFRESH_LOSSY
= { 2, 0 };
43 #include "vnc_keysym.h"
46 static VncDisplay
*vnc_display
; /* needed for info vnc */
47 static DisplayChangeListener
*dcl
;
49 static int vnc_cursor_define(VncState
*vs
);
50 static void vnc_release_modifiers(VncState
*vs
);
52 static void vnc_set_share_mode(VncState
*vs
, VncShareMode mode
)
55 static const char *mn
[] = {
57 [VNC_SHARE_MODE_CONNECTING
] = "connecting",
58 [VNC_SHARE_MODE_SHARED
] = "shared",
59 [VNC_SHARE_MODE_EXCLUSIVE
] = "exclusive",
60 [VNC_SHARE_MODE_DISCONNECTED
] = "disconnected",
62 fprintf(stderr
, "%s/%d: %s -> %s\n", __func__
,
63 vs
->csock
, mn
[vs
->share_mode
], mn
[mode
]);
66 if (vs
->share_mode
== VNC_SHARE_MODE_EXCLUSIVE
) {
67 vs
->vd
->num_exclusive
--;
69 vs
->share_mode
= mode
;
70 if (vs
->share_mode
== VNC_SHARE_MODE_EXCLUSIVE
) {
71 vs
->vd
->num_exclusive
++;
75 static char *addr_to_string(const char *format
,
76 struct sockaddr_storage
*sa
,
79 char host
[NI_MAXHOST
];
80 char serv
[NI_MAXSERV
];
84 if ((err
= getnameinfo((struct sockaddr
*)sa
, salen
,
87 NI_NUMERICHOST
| NI_NUMERICSERV
)) != 0) {
88 VNC_DEBUG("Cannot resolve address %d: %s\n",
89 err
, gai_strerror(err
));
93 /* Enough for the existing format + the 2 vars we're
95 addrlen
= strlen(format
) + strlen(host
) + strlen(serv
);
96 addr
= g_malloc(addrlen
+ 1);
97 snprintf(addr
, addrlen
, format
, host
, serv
);
104 char *vnc_socket_local_addr(const char *format
, int fd
) {
105 struct sockaddr_storage sa
;
109 if (getsockname(fd
, (struct sockaddr
*)&sa
, &salen
) < 0)
112 return addr_to_string(format
, &sa
, salen
);
115 char *vnc_socket_remote_addr(const char *format
, int fd
) {
116 struct sockaddr_storage sa
;
120 if (getpeername(fd
, (struct sockaddr
*)&sa
, &salen
) < 0)
123 return addr_to_string(format
, &sa
, salen
);
126 static int put_addr_qdict(QDict
*qdict
, struct sockaddr_storage
*sa
,
129 char host
[NI_MAXHOST
];
130 char serv
[NI_MAXSERV
];
133 if ((err
= getnameinfo((struct sockaddr
*)sa
, salen
,
136 NI_NUMERICHOST
| NI_NUMERICSERV
)) != 0) {
137 VNC_DEBUG("Cannot resolve address %d: %s\n",
138 err
, gai_strerror(err
));
142 qdict_put(qdict
, "host", qstring_from_str(host
));
143 qdict_put(qdict
, "service", qstring_from_str(serv
));
144 qdict_put(qdict
, "family",qstring_from_str(inet_strfamily(sa
->ss_family
)));
149 static int vnc_server_addr_put(QDict
*qdict
, int fd
)
151 struct sockaddr_storage sa
;
155 if (getsockname(fd
, (struct sockaddr
*)&sa
, &salen
) < 0) {
159 return put_addr_qdict(qdict
, &sa
, salen
);
162 static int vnc_qdict_remote_addr(QDict
*qdict
, int fd
)
164 struct sockaddr_storage sa
;
168 if (getpeername(fd
, (struct sockaddr
*)&sa
, &salen
) < 0) {
172 return put_addr_qdict(qdict
, &sa
, salen
);
175 static const char *vnc_auth_name(VncDisplay
*vd
) {
177 case VNC_AUTH_INVALID
:
193 case VNC_AUTH_VENCRYPT
:
194 #ifdef CONFIG_VNC_TLS
195 switch (vd
->subauth
) {
196 case VNC_AUTH_VENCRYPT_PLAIN
:
197 return "vencrypt+plain";
198 case VNC_AUTH_VENCRYPT_TLSNONE
:
199 return "vencrypt+tls+none";
200 case VNC_AUTH_VENCRYPT_TLSVNC
:
201 return "vencrypt+tls+vnc";
202 case VNC_AUTH_VENCRYPT_TLSPLAIN
:
203 return "vencrypt+tls+plain";
204 case VNC_AUTH_VENCRYPT_X509NONE
:
205 return "vencrypt+x509+none";
206 case VNC_AUTH_VENCRYPT_X509VNC
:
207 return "vencrypt+x509+vnc";
208 case VNC_AUTH_VENCRYPT_X509PLAIN
:
209 return "vencrypt+x509+plain";
210 case VNC_AUTH_VENCRYPT_TLSSASL
:
211 return "vencrypt+tls+sasl";
212 case VNC_AUTH_VENCRYPT_X509SASL
:
213 return "vencrypt+x509+sasl";
226 static int vnc_server_info_put(QDict
*qdict
)
228 if (vnc_server_addr_put(qdict
, vnc_display
->lsock
) < 0) {
232 qdict_put(qdict
, "auth", qstring_from_str(vnc_auth_name(vnc_display
)));
236 static void vnc_client_cache_auth(VncState
*client
)
238 #if defined(CONFIG_VNC_TLS) || defined(CONFIG_VNC_SASL)
246 #if defined(CONFIG_VNC_TLS) || defined(CONFIG_VNC_SASL)
247 qdict
= qobject_to_qdict(client
->info
);
250 #ifdef CONFIG_VNC_TLS
251 if (client
->tls
.session
&&
253 qdict_put(qdict
, "x509_dname", qstring_from_str(client
->tls
.dname
));
256 #ifdef CONFIG_VNC_SASL
257 if (client
->sasl
.conn
&&
258 client
->sasl
.username
) {
259 qdict_put(qdict
, "sasl_username",
260 qstring_from_str(client
->sasl
.username
));
265 static void vnc_client_cache_addr(VncState
*client
)
270 if (vnc_qdict_remote_addr(qdict
, client
->csock
) < 0) {
272 /* XXX: how to report the error? */
276 client
->info
= QOBJECT(qdict
);
279 static void vnc_qmp_event(VncState
*vs
, MonitorEvent event
)
288 server
= qdict_new();
289 if (vnc_server_info_put(server
) < 0) {
294 data
= qobject_from_jsonf("{ 'client': %p, 'server': %p }",
295 vs
->info
, QOBJECT(server
));
297 monitor_protocol_event(event
, data
);
299 qobject_incref(vs
->info
);
300 qobject_decref(data
);
303 static VncClientInfo
*qmp_query_vnc_client(const VncState
*client
)
305 struct sockaddr_storage sa
;
306 socklen_t salen
= sizeof(sa
);
307 char host
[NI_MAXHOST
];
308 char serv
[NI_MAXSERV
];
311 if (getpeername(client
->csock
, (struct sockaddr
*)&sa
, &salen
) < 0) {
315 if (getnameinfo((struct sockaddr
*)&sa
, salen
,
318 NI_NUMERICHOST
| NI_NUMERICSERV
) < 0) {
322 info
= g_malloc0(sizeof(*info
));
323 info
->host
= g_strdup(host
);
324 info
->service
= g_strdup(serv
);
325 info
->family
= g_strdup(inet_strfamily(sa
.ss_family
));
327 #ifdef CONFIG_VNC_TLS
328 if (client
->tls
.session
&& client
->tls
.dname
) {
329 info
->has_x509_dname
= true;
330 info
->x509_dname
= g_strdup(client
->tls
.dname
);
333 #ifdef CONFIG_VNC_SASL
334 if (client
->sasl
.conn
&& client
->sasl
.username
) {
335 info
->has_sasl_username
= true;
336 info
->sasl_username
= g_strdup(client
->sasl
.username
);
343 VncInfo
*qmp_query_vnc(Error
**errp
)
345 VncInfo
*info
= g_malloc0(sizeof(*info
));
347 if (vnc_display
== NULL
|| vnc_display
->display
== NULL
) {
348 info
->enabled
= false;
350 VncClientInfoList
*cur_item
= NULL
;
351 struct sockaddr_storage sa
;
352 socklen_t salen
= sizeof(sa
);
353 char host
[NI_MAXHOST
];
354 char serv
[NI_MAXSERV
];
357 info
->enabled
= true;
359 /* for compatibility with the original command */
360 info
->has_clients
= true;
362 QTAILQ_FOREACH(client
, &vnc_display
->clients
, next
) {
363 VncClientInfoList
*cinfo
= g_malloc0(sizeof(*info
));
364 cinfo
->value
= qmp_query_vnc_client(client
);
366 /* XXX: waiting for the qapi to support GSList */
368 info
->clients
= cur_item
= cinfo
;
370 cur_item
->next
= cinfo
;
375 if (vnc_display
->lsock
== -1) {
379 if (getsockname(vnc_display
->lsock
, (struct sockaddr
*)&sa
,
381 error_set(errp
, QERR_UNDEFINED_ERROR
);
385 if (getnameinfo((struct sockaddr
*)&sa
, salen
,
388 NI_NUMERICHOST
| NI_NUMERICSERV
) < 0) {
389 error_set(errp
, QERR_UNDEFINED_ERROR
);
393 info
->has_host
= true;
394 info
->host
= g_strdup(host
);
396 info
->has_service
= true;
397 info
->service
= g_strdup(serv
);
399 info
->has_family
= true;
400 info
->family
= g_strdup(inet_strfamily(sa
.ss_family
));
402 info
->has_auth
= true;
403 info
->auth
= g_strdup(vnc_auth_name(vnc_display
));
409 qapi_free_VncInfo(info
);
414 1) Get the queue working for IO.
415 2) there is some weirdness when using the -S option (the screen is grey
416 and not totally invalidated
417 3) resolutions > 1024
420 static int vnc_update_client(VncState
*vs
, int has_dirty
);
421 static int vnc_update_client_sync(VncState
*vs
, int has_dirty
);
422 static void vnc_disconnect_start(VncState
*vs
);
423 static void vnc_disconnect_finish(VncState
*vs
);
424 static void vnc_init_timer(VncDisplay
*vd
);
425 static void vnc_remove_timer(VncDisplay
*vd
);
427 static void vnc_colordepth(VncState
*vs
);
428 static void framebuffer_update_request(VncState
*vs
, int incremental
,
429 int x_position
, int y_position
,
431 static void vnc_refresh(void *opaque
);
432 static int vnc_refresh_server_surface(VncDisplay
*vd
);
434 static void vnc_dpy_update(DisplayState
*ds
, int x
, int y
, int w
, int h
)
437 VncDisplay
*vd
= ds
->opaque
;
438 struct VncSurface
*s
= &vd
->guest
;
442 /* round x down to ensure the loop only spans one 16-pixel block per,
443 iteration. otherwise, if (x % 16) != 0, the last iteration may span
444 two 16-pixel blocks but we only mark the first as dirty
449 x
= MIN(x
, s
->ds
->width
);
450 y
= MIN(y
, s
->ds
->height
);
451 w
= MIN(x
+ w
, s
->ds
->width
) - x
;
452 h
= MIN(h
, s
->ds
->height
);
455 for (i
= 0; i
< w
; i
+= 16)
456 set_bit((x
+ i
) / 16, s
->dirty
[y
]);
459 void vnc_framebuffer_update(VncState
*vs
, int x
, int y
, int w
, int h
,
462 vnc_write_u16(vs
, x
);
463 vnc_write_u16(vs
, y
);
464 vnc_write_u16(vs
, w
);
465 vnc_write_u16(vs
, h
);
467 vnc_write_s32(vs
, encoding
);
470 void buffer_reserve(Buffer
*buffer
, size_t len
)
472 if ((buffer
->capacity
- buffer
->offset
) < len
) {
473 buffer
->capacity
+= (len
+ 1024);
474 buffer
->buffer
= g_realloc(buffer
->buffer
, buffer
->capacity
);
475 if (buffer
->buffer
== NULL
) {
476 fprintf(stderr
, "vnc: out of memory\n");
482 int buffer_empty(Buffer
*buffer
)
484 return buffer
->offset
== 0;
487 uint8_t *buffer_end(Buffer
*buffer
)
489 return buffer
->buffer
+ buffer
->offset
;
492 void buffer_reset(Buffer
*buffer
)
497 void buffer_free(Buffer
*buffer
)
499 g_free(buffer
->buffer
);
501 buffer
->capacity
= 0;
502 buffer
->buffer
= NULL
;
505 void buffer_append(Buffer
*buffer
, const void *data
, size_t len
)
507 memcpy(buffer
->buffer
+ buffer
->offset
, data
, len
);
508 buffer
->offset
+= len
;
511 static void vnc_desktop_resize(VncState
*vs
)
513 DisplayState
*ds
= vs
->ds
;
515 if (vs
->csock
== -1 || !vnc_has_feature(vs
, VNC_FEATURE_RESIZE
)) {
518 if (vs
->client_width
== ds_get_width(ds
) &&
519 vs
->client_height
== ds_get_height(ds
)) {
522 vs
->client_width
= ds_get_width(ds
);
523 vs
->client_height
= ds_get_height(ds
);
525 vnc_write_u8(vs
, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE
);
527 vnc_write_u16(vs
, 1); /* number of rects */
528 vnc_framebuffer_update(vs
, 0, 0, vs
->client_width
, vs
->client_height
,
529 VNC_ENCODING_DESKTOPRESIZE
);
530 vnc_unlock_output(vs
);
534 static void vnc_abort_display_jobs(VncDisplay
*vd
)
538 QTAILQ_FOREACH(vs
, &vd
->clients
, next
) {
541 vnc_unlock_output(vs
);
543 QTAILQ_FOREACH(vs
, &vd
->clients
, next
) {
546 QTAILQ_FOREACH(vs
, &vd
->clients
, next
) {
549 vnc_unlock_output(vs
);
553 static void vnc_dpy_resize(DisplayState
*ds
)
555 VncDisplay
*vd
= ds
->opaque
;
558 vnc_abort_display_jobs(vd
);
562 vd
->server
= g_malloc0(sizeof(*vd
->server
));
563 if (vd
->server
->data
)
564 g_free(vd
->server
->data
);
565 *(vd
->server
) = *(ds
->surface
);
566 vd
->server
->data
= g_malloc0(vd
->server
->linesize
*
571 vd
->guest
.ds
= g_malloc0(sizeof(*vd
->guest
.ds
));
572 if (ds_get_bytes_per_pixel(ds
) != vd
->guest
.ds
->pf
.bytes_per_pixel
)
573 console_color_init(ds
);
574 *(vd
->guest
.ds
) = *(ds
->surface
);
575 memset(vd
->guest
.dirty
, 0xFF, sizeof(vd
->guest
.dirty
));
577 QTAILQ_FOREACH(vs
, &vd
->clients
, next
) {
579 vnc_desktop_resize(vs
);
580 if (vs
->vd
->cursor
) {
581 vnc_cursor_define(vs
);
583 memset(vs
->dirty
, 0xFF, sizeof(vs
->dirty
));
588 static void vnc_write_pixels_copy(VncState
*vs
, struct PixelFormat
*pf
,
589 void *pixels
, int size
)
591 vnc_write(vs
, pixels
, size
);
594 /* slowest but generic code. */
595 void vnc_convert_pixel(VncState
*vs
, uint8_t *buf
, uint32_t v
)
598 VncDisplay
*vd
= vs
->vd
;
600 r
= ((((v
& vd
->server
->pf
.rmask
) >> vd
->server
->pf
.rshift
) << vs
->clientds
.pf
.rbits
) >>
601 vd
->server
->pf
.rbits
);
602 g
= ((((v
& vd
->server
->pf
.gmask
) >> vd
->server
->pf
.gshift
) << vs
->clientds
.pf
.gbits
) >>
603 vd
->server
->pf
.gbits
);
604 b
= ((((v
& vd
->server
->pf
.bmask
) >> vd
->server
->pf
.bshift
) << vs
->clientds
.pf
.bbits
) >>
605 vd
->server
->pf
.bbits
);
606 v
= (r
<< vs
->clientds
.pf
.rshift
) |
607 (g
<< vs
->clientds
.pf
.gshift
) |
608 (b
<< vs
->clientds
.pf
.bshift
);
609 switch(vs
->clientds
.pf
.bytes_per_pixel
) {
614 if (vs
->clientds
.flags
& QEMU_BIG_ENDIAN_FLAG
) {
624 if (vs
->clientds
.flags
& QEMU_BIG_ENDIAN_FLAG
) {
639 static void vnc_write_pixels_generic(VncState
*vs
, struct PixelFormat
*pf
,
640 void *pixels1
, int size
)
644 if (pf
->bytes_per_pixel
== 4) {
645 uint32_t *pixels
= pixels1
;
648 for(i
= 0; i
< n
; i
++) {
649 vnc_convert_pixel(vs
, buf
, pixels
[i
]);
650 vnc_write(vs
, buf
, vs
->clientds
.pf
.bytes_per_pixel
);
652 } else if (pf
->bytes_per_pixel
== 2) {
653 uint16_t *pixels
= pixels1
;
656 for(i
= 0; i
< n
; i
++) {
657 vnc_convert_pixel(vs
, buf
, pixels
[i
]);
658 vnc_write(vs
, buf
, vs
->clientds
.pf
.bytes_per_pixel
);
660 } else if (pf
->bytes_per_pixel
== 1) {
661 uint8_t *pixels
= pixels1
;
664 for(i
= 0; i
< n
; i
++) {
665 vnc_convert_pixel(vs
, buf
, pixels
[i
]);
666 vnc_write(vs
, buf
, vs
->clientds
.pf
.bytes_per_pixel
);
669 fprintf(stderr
, "vnc_write_pixels_generic: VncState color depth not supported\n");
673 int vnc_raw_send_framebuffer_update(VncState
*vs
, int x
, int y
, int w
, int h
)
677 VncDisplay
*vd
= vs
->vd
;
679 row
= vd
->server
->data
+ y
* ds_get_linesize(vs
->ds
) + x
* ds_get_bytes_per_pixel(vs
->ds
);
680 for (i
= 0; i
< h
; i
++) {
681 vs
->write_pixels(vs
, &vd
->server
->pf
, row
, w
* ds_get_bytes_per_pixel(vs
->ds
));
682 row
+= ds_get_linesize(vs
->ds
);
687 int vnc_send_framebuffer_update(VncState
*vs
, int x
, int y
, int w
, int h
)
691 switch(vs
->vnc_encoding
) {
692 case VNC_ENCODING_ZLIB
:
693 n
= vnc_zlib_send_framebuffer_update(vs
, x
, y
, w
, h
);
695 case VNC_ENCODING_HEXTILE
:
696 vnc_framebuffer_update(vs
, x
, y
, w
, h
, VNC_ENCODING_HEXTILE
);
697 n
= vnc_hextile_send_framebuffer_update(vs
, x
, y
, w
, h
);
699 case VNC_ENCODING_TIGHT
:
700 n
= vnc_tight_send_framebuffer_update(vs
, x
, y
, w
, h
);
702 case VNC_ENCODING_TIGHT_PNG
:
703 n
= vnc_tight_png_send_framebuffer_update(vs
, x
, y
, w
, h
);
705 case VNC_ENCODING_ZRLE
:
706 n
= vnc_zrle_send_framebuffer_update(vs
, x
, y
, w
, h
);
708 case VNC_ENCODING_ZYWRLE
:
709 n
= vnc_zywrle_send_framebuffer_update(vs
, x
, y
, w
, h
);
712 vnc_framebuffer_update(vs
, x
, y
, w
, h
, VNC_ENCODING_RAW
);
713 n
= vnc_raw_send_framebuffer_update(vs
, x
, y
, w
, h
);
719 static void vnc_copy(VncState
*vs
, int src_x
, int src_y
, int dst_x
, int dst_y
, int w
, int h
)
721 /* send bitblit op to the vnc client */
723 vnc_write_u8(vs
, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE
);
725 vnc_write_u16(vs
, 1); /* number of rects */
726 vnc_framebuffer_update(vs
, dst_x
, dst_y
, w
, h
, VNC_ENCODING_COPYRECT
);
727 vnc_write_u16(vs
, src_x
);
728 vnc_write_u16(vs
, src_y
);
729 vnc_unlock_output(vs
);
733 static void vnc_dpy_copy(DisplayState
*ds
, int src_x
, int src_y
, int dst_x
, int dst_y
, int w
, int h
)
735 VncDisplay
*vd
= ds
->opaque
;
739 int i
,x
,y
,pitch
,depth
,inc
,w_lim
,s
;
742 vnc_refresh_server_surface(vd
);
743 QTAILQ_FOREACH_SAFE(vs
, &vd
->clients
, next
, vn
) {
744 if (vnc_has_feature(vs
, VNC_FEATURE_COPYRECT
)) {
745 vs
->force_update
= 1;
746 vnc_update_client_sync(vs
, 1);
747 /* vs might be free()ed here */
751 /* do bitblit op on the local surface too */
752 pitch
= ds_get_linesize(vd
->ds
);
753 depth
= ds_get_bytes_per_pixel(vd
->ds
);
754 src_row
= vd
->server
->data
+ pitch
* src_y
+ depth
* src_x
;
755 dst_row
= vd
->server
->data
+ pitch
* dst_y
+ depth
* dst_x
;
760 src_row
+= pitch
* (h
-1);
761 dst_row
+= pitch
* (h
-1);
766 w_lim
= w
- (16 - (dst_x
% 16));
770 w_lim
= w
- (w_lim
% 16);
771 for (i
= 0; i
< h
; i
++) {
772 for (x
= 0; x
<= w_lim
;
773 x
+= s
, src_row
+= cmp_bytes
, dst_row
+= cmp_bytes
) {
775 if ((s
= w
- w_lim
) == 0)
778 s
= (16 - (dst_x
% 16));
783 cmp_bytes
= s
* depth
;
784 if (memcmp(src_row
, dst_row
, cmp_bytes
) == 0)
786 memmove(dst_row
, src_row
, cmp_bytes
);
787 QTAILQ_FOREACH(vs
, &vd
->clients
, next
) {
788 if (!vnc_has_feature(vs
, VNC_FEATURE_COPYRECT
)) {
789 set_bit(((x
+ dst_x
) / 16), vs
->dirty
[y
]);
793 src_row
+= pitch
- w
* depth
;
794 dst_row
+= pitch
- w
* depth
;
798 QTAILQ_FOREACH(vs
, &vd
->clients
, next
) {
799 if (vnc_has_feature(vs
, VNC_FEATURE_COPYRECT
)) {
800 vnc_copy(vs
, src_x
, src_y
, dst_x
, dst_y
, w
, h
);
805 static void vnc_mouse_set(int x
, int y
, int visible
)
807 /* can we ask the client(s) to move the pointer ??? */
810 static int vnc_cursor_define(VncState
*vs
)
812 QEMUCursor
*c
= vs
->vd
->cursor
;
813 PixelFormat pf
= qemu_default_pixelformat(32);
816 if (vnc_has_feature(vs
, VNC_FEATURE_RICH_CURSOR
)) {
818 vnc_write_u8(vs
, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE
);
819 vnc_write_u8(vs
, 0); /* padding */
820 vnc_write_u16(vs
, 1); /* # of rects */
821 vnc_framebuffer_update(vs
, c
->hot_x
, c
->hot_y
, c
->width
, c
->height
,
822 VNC_ENCODING_RICH_CURSOR
);
823 isize
= c
->width
* c
->height
* vs
->clientds
.pf
.bytes_per_pixel
;
824 vnc_write_pixels_generic(vs
, &pf
, c
->data
, isize
);
825 vnc_write(vs
, vs
->vd
->cursor_mask
, vs
->vd
->cursor_msize
);
826 vnc_unlock_output(vs
);
832 static void vnc_dpy_cursor_define(QEMUCursor
*c
)
834 VncDisplay
*vd
= vnc_display
;
837 cursor_put(vd
->cursor
);
838 g_free(vd
->cursor_mask
);
841 cursor_get(vd
->cursor
);
842 vd
->cursor_msize
= cursor_get_mono_bpl(c
) * c
->height
;
843 vd
->cursor_mask
= g_malloc0(vd
->cursor_msize
);
844 cursor_get_mono_mask(c
, 0, vd
->cursor_mask
);
846 QTAILQ_FOREACH(vs
, &vd
->clients
, next
) {
847 vnc_cursor_define(vs
);
851 static int find_and_clear_dirty_height(struct VncState
*vs
,
852 int y
, int last_x
, int x
, int height
)
856 for (h
= 1; h
< (height
- y
); h
++) {
858 if (!test_bit(last_x
, vs
->dirty
[y
+ h
])) {
861 for (tmp_x
= last_x
; tmp_x
< x
; tmp_x
++) {
862 clear_bit(tmp_x
, vs
->dirty
[y
+ h
]);
869 static int vnc_update_client_sync(VncState
*vs
, int has_dirty
)
871 int ret
= vnc_update_client(vs
, has_dirty
);
876 static int vnc_update_client(VncState
*vs
, int has_dirty
)
878 if (vs
->need_update
&& vs
->csock
!= -1) {
879 VncDisplay
*vd
= vs
->vd
;
886 if (vs
->output
.offset
&& !vs
->audio_cap
&& !vs
->force_update
)
887 /* kernel send buffers are full -> drop frames to throttle */
890 if (!has_dirty
&& !vs
->audio_cap
&& !vs
->force_update
)
894 * Send screen updates to the vnc client using the server
895 * surface and server dirty map. guest surface updates
896 * happening in parallel don't disturb us, the next pass will
897 * send them to the client.
899 job
= vnc_job_new(vs
);
901 width
= MIN(vd
->server
->width
, vs
->client_width
);
902 height
= MIN(vd
->server
->height
, vs
->client_height
);
904 for (y
= 0; y
< height
; y
++) {
907 for (x
= 0; x
< width
/ 16; x
++) {
908 if (test_and_clear_bit(x
, vs
->dirty
[y
])) {
914 int h
= find_and_clear_dirty_height(vs
, y
, last_x
, x
,
917 n
+= vnc_job_add_rect(job
, last_x
* 16, y
,
918 (x
- last_x
) * 16, h
);
924 int h
= find_and_clear_dirty_height(vs
, y
, last_x
, x
, height
);
925 n
+= vnc_job_add_rect(job
, last_x
* 16, y
,
926 (x
- last_x
) * 16, h
);
931 vs
->force_update
= 0;
936 vnc_disconnect_finish(vs
);
942 static void audio_capture_notify(void *opaque
, audcnotification_e cmd
)
944 VncState
*vs
= opaque
;
947 case AUD_CNOTIFY_DISABLE
:
949 vnc_write_u8(vs
, VNC_MSG_SERVER_QEMU
);
950 vnc_write_u8(vs
, VNC_MSG_SERVER_QEMU_AUDIO
);
951 vnc_write_u16(vs
, VNC_MSG_SERVER_QEMU_AUDIO_END
);
952 vnc_unlock_output(vs
);
956 case AUD_CNOTIFY_ENABLE
:
958 vnc_write_u8(vs
, VNC_MSG_SERVER_QEMU
);
959 vnc_write_u8(vs
, VNC_MSG_SERVER_QEMU_AUDIO
);
960 vnc_write_u16(vs
, VNC_MSG_SERVER_QEMU_AUDIO_BEGIN
);
961 vnc_unlock_output(vs
);
967 static void audio_capture_destroy(void *opaque
)
971 static void audio_capture(void *opaque
, void *buf
, int size
)
973 VncState
*vs
= opaque
;
976 vnc_write_u8(vs
, VNC_MSG_SERVER_QEMU
);
977 vnc_write_u8(vs
, VNC_MSG_SERVER_QEMU_AUDIO
);
978 vnc_write_u16(vs
, VNC_MSG_SERVER_QEMU_AUDIO_DATA
);
979 vnc_write_u32(vs
, size
);
980 vnc_write(vs
, buf
, size
);
981 vnc_unlock_output(vs
);
985 static void audio_add(VncState
*vs
)
987 struct audio_capture_ops ops
;
990 monitor_printf(default_mon
, "audio already running\n");
994 ops
.notify
= audio_capture_notify
;
995 ops
.destroy
= audio_capture_destroy
;
996 ops
.capture
= audio_capture
;
998 vs
->audio_cap
= AUD_add_capture(&vs
->as
, &ops
, vs
);
999 if (!vs
->audio_cap
) {
1000 monitor_printf(default_mon
, "Failed to add audio capture\n");
1004 static void audio_del(VncState
*vs
)
1006 if (vs
->audio_cap
) {
1007 AUD_del_capture(vs
->audio_cap
, vs
);
1008 vs
->audio_cap
= NULL
;
1012 static void vnc_disconnect_start(VncState
*vs
)
1014 if (vs
->csock
== -1)
1016 vnc_set_share_mode(vs
, VNC_SHARE_MODE_DISCONNECTED
);
1017 qemu_set_fd_handler2(vs
->csock
, NULL
, NULL
, NULL
, NULL
);
1018 closesocket(vs
->csock
);
1022 static void vnc_disconnect_finish(VncState
*vs
)
1026 vnc_jobs_join(vs
); /* Wait encoding jobs */
1028 vnc_lock_output(vs
);
1029 vnc_qmp_event(vs
, QEVENT_VNC_DISCONNECTED
);
1031 buffer_free(&vs
->input
);
1032 buffer_free(&vs
->output
);
1034 qobject_decref(vs
->info
);
1037 vnc_tight_clear(vs
);
1040 #ifdef CONFIG_VNC_TLS
1041 vnc_tls_client_cleanup(vs
);
1042 #endif /* CONFIG_VNC_TLS */
1043 #ifdef CONFIG_VNC_SASL
1044 vnc_sasl_client_cleanup(vs
);
1045 #endif /* CONFIG_VNC_SASL */
1047 vnc_release_modifiers(vs
);
1049 QTAILQ_REMOVE(&vs
->vd
->clients
, vs
, next
);
1051 if (QTAILQ_EMPTY(&vs
->vd
->clients
)) {
1055 qemu_remove_mouse_mode_change_notifier(&vs
->mouse_mode_notifier
);
1056 vnc_remove_timer(vs
->vd
);
1057 if (vs
->vd
->lock_key_sync
)
1058 qemu_remove_led_event_handler(vs
->led
);
1059 vnc_unlock_output(vs
);
1061 qemu_mutex_destroy(&vs
->output_mutex
);
1062 qemu_bh_delete(vs
->bh
);
1063 buffer_free(&vs
->jobs_buffer
);
1065 for (i
= 0; i
< VNC_STAT_ROWS
; ++i
) {
1066 g_free(vs
->lossy_rect
[i
]);
1068 g_free(vs
->lossy_rect
);
1072 int vnc_client_io_error(VncState
*vs
, int ret
, int last_errno
)
1074 if (ret
== 0 || ret
== -1) {
1076 switch (last_errno
) {
1080 case WSAEWOULDBLOCK
:
1088 VNC_DEBUG("Closing down client sock: ret %d, errno %d\n",
1089 ret
, ret
< 0 ? last_errno
: 0);
1090 vnc_disconnect_start(vs
);
1098 void vnc_client_error(VncState
*vs
)
1100 VNC_DEBUG("Closing down client sock: protocol error\n");
1101 vnc_disconnect_start(vs
);
1106 * Called to write a chunk of data to the client socket. The data may
1107 * be the raw data, or may have already been encoded by SASL.
1108 * The data will be written either straight onto the socket, or
1109 * written via the GNUTLS wrappers, if TLS/SSL encryption is enabled
1111 * NB, it is theoretically possible to have 2 layers of encryption,
1112 * both SASL, and this TLS layer. It is highly unlikely in practice
1113 * though, since SASL encryption will typically be a no-op if TLS
1116 * Returns the number of bytes written, which may be less than
1117 * the requested 'datalen' if the socket would block. Returns
1118 * -1 on error, and disconnects the client socket.
1120 long vnc_client_write_buf(VncState
*vs
, const uint8_t *data
, size_t datalen
)
1123 #ifdef CONFIG_VNC_TLS
1124 if (vs
->tls
.session
) {
1125 ret
= gnutls_write(vs
->tls
.session
, data
, datalen
);
1127 if (ret
== GNUTLS_E_AGAIN
)
1134 #endif /* CONFIG_VNC_TLS */
1135 ret
= send(vs
->csock
, (const void *)data
, datalen
, 0);
1136 VNC_DEBUG("Wrote wire %p %zd -> %ld\n", data
, datalen
, ret
);
1137 return vnc_client_io_error(vs
, ret
, socket_error());
1142 * Called to write buffered data to the client socket, when not
1143 * using any SASL SSF encryption layers. Will write as much data
1144 * as possible without blocking. If all buffered data is written,
1145 * will switch the FD poll() handler back to read monitoring.
1147 * Returns the number of bytes written, which may be less than
1148 * the buffered output data if the socket would block. Returns
1149 * -1 on error, and disconnects the client socket.
1151 static long vnc_client_write_plain(VncState
*vs
)
1155 #ifdef CONFIG_VNC_SASL
1156 VNC_DEBUG("Write Plain: Pending output %p size %zd offset %zd. Wait SSF %d\n",
1157 vs
->output
.buffer
, vs
->output
.capacity
, vs
->output
.offset
,
1158 vs
->sasl
.waitWriteSSF
);
1160 if (vs
->sasl
.conn
&&
1162 vs
->sasl
.waitWriteSSF
) {
1163 ret
= vnc_client_write_buf(vs
, vs
->output
.buffer
, vs
->sasl
.waitWriteSSF
);
1165 vs
->sasl
.waitWriteSSF
-= ret
;
1167 #endif /* CONFIG_VNC_SASL */
1168 ret
= vnc_client_write_buf(vs
, vs
->output
.buffer
, vs
->output
.offset
);
1172 memmove(vs
->output
.buffer
, vs
->output
.buffer
+ ret
, (vs
->output
.offset
- ret
));
1173 vs
->output
.offset
-= ret
;
1175 if (vs
->output
.offset
== 0) {
1176 qemu_set_fd_handler2(vs
->csock
, NULL
, vnc_client_read
, NULL
, vs
);
1184 * First function called whenever there is data to be written to
1185 * the client socket. Will delegate actual work according to whether
1186 * SASL SSF layers are enabled (thus requiring encryption calls)
1188 static void vnc_client_write_locked(void *opaque
)
1190 VncState
*vs
= opaque
;
1192 #ifdef CONFIG_VNC_SASL
1193 if (vs
->sasl
.conn
&&
1195 !vs
->sasl
.waitWriteSSF
) {
1196 vnc_client_write_sasl(vs
);
1198 #endif /* CONFIG_VNC_SASL */
1199 vnc_client_write_plain(vs
);
1202 void vnc_client_write(void *opaque
)
1204 VncState
*vs
= opaque
;
1206 vnc_lock_output(vs
);
1207 if (vs
->output
.offset
) {
1208 vnc_client_write_locked(opaque
);
1209 } else if (vs
->csock
!= -1) {
1210 qemu_set_fd_handler2(vs
->csock
, NULL
, vnc_client_read
, NULL
, vs
);
1212 vnc_unlock_output(vs
);
1215 void vnc_read_when(VncState
*vs
, VncReadEvent
*func
, size_t expecting
)
1217 vs
->read_handler
= func
;
1218 vs
->read_handler_expect
= expecting
;
1223 * Called to read a chunk of data from the client socket. The data may
1224 * be the raw data, or may need to be further decoded by SASL.
1225 * The data will be read either straight from to the socket, or
1226 * read via the GNUTLS wrappers, if TLS/SSL encryption is enabled
1228 * NB, it is theoretically possible to have 2 layers of encryption,
1229 * both SASL, and this TLS layer. It is highly unlikely in practice
1230 * though, since SASL encryption will typically be a no-op if TLS
1233 * Returns the number of bytes read, which may be less than
1234 * the requested 'datalen' if the socket would block. Returns
1235 * -1 on error, and disconnects the client socket.
1237 long vnc_client_read_buf(VncState
*vs
, uint8_t *data
, size_t datalen
)
1240 #ifdef CONFIG_VNC_TLS
1241 if (vs
->tls
.session
) {
1242 ret
= gnutls_read(vs
->tls
.session
, data
, datalen
);
1244 if (ret
== GNUTLS_E_AGAIN
)
1251 #endif /* CONFIG_VNC_TLS */
1252 ret
= qemu_recv(vs
->csock
, data
, datalen
, 0);
1253 VNC_DEBUG("Read wire %p %zd -> %ld\n", data
, datalen
, ret
);
1254 return vnc_client_io_error(vs
, ret
, socket_error());
1259 * Called to read data from the client socket to the input buffer,
1260 * when not using any SASL SSF encryption layers. Will read as much
1261 * data as possible without blocking.
1263 * Returns the number of bytes read. Returns -1 on error, and
1264 * disconnects the client socket.
1266 static long vnc_client_read_plain(VncState
*vs
)
1269 VNC_DEBUG("Read plain %p size %zd offset %zd\n",
1270 vs
->input
.buffer
, vs
->input
.capacity
, vs
->input
.offset
);
1271 buffer_reserve(&vs
->input
, 4096);
1272 ret
= vnc_client_read_buf(vs
, buffer_end(&vs
->input
), 4096);
1275 vs
->input
.offset
+= ret
;
1279 static void vnc_jobs_bh(void *opaque
)
1281 VncState
*vs
= opaque
;
1283 vnc_jobs_consume_buffer(vs
);
1287 * First function called whenever there is more data to be read from
1288 * the client socket. Will delegate actual work according to whether
1289 * SASL SSF layers are enabled (thus requiring decryption calls)
1291 void vnc_client_read(void *opaque
)
1293 VncState
*vs
= opaque
;
1296 #ifdef CONFIG_VNC_SASL
1297 if (vs
->sasl
.conn
&& vs
->sasl
.runSSF
)
1298 ret
= vnc_client_read_sasl(vs
);
1300 #endif /* CONFIG_VNC_SASL */
1301 ret
= vnc_client_read_plain(vs
);
1303 if (vs
->csock
== -1)
1304 vnc_disconnect_finish(vs
);
1308 while (vs
->read_handler
&& vs
->input
.offset
>= vs
->read_handler_expect
) {
1309 size_t len
= vs
->read_handler_expect
;
1312 ret
= vs
->read_handler(vs
, vs
->input
.buffer
, len
);
1313 if (vs
->csock
== -1) {
1314 vnc_disconnect_finish(vs
);
1319 memmove(vs
->input
.buffer
, vs
->input
.buffer
+ len
, (vs
->input
.offset
- len
));
1320 vs
->input
.offset
-= len
;
1322 vs
->read_handler_expect
= ret
;
1327 void vnc_write(VncState
*vs
, const void *data
, size_t len
)
1329 buffer_reserve(&vs
->output
, len
);
1331 if (vs
->csock
!= -1 && buffer_empty(&vs
->output
)) {
1332 qemu_set_fd_handler2(vs
->csock
, NULL
, vnc_client_read
, vnc_client_write
, vs
);
1335 buffer_append(&vs
->output
, data
, len
);
1338 void vnc_write_s32(VncState
*vs
, int32_t value
)
1340 vnc_write_u32(vs
, *(uint32_t *)&value
);
1343 void vnc_write_u32(VncState
*vs
, uint32_t value
)
1347 buf
[0] = (value
>> 24) & 0xFF;
1348 buf
[1] = (value
>> 16) & 0xFF;
1349 buf
[2] = (value
>> 8) & 0xFF;
1350 buf
[3] = value
& 0xFF;
1352 vnc_write(vs
, buf
, 4);
1355 void vnc_write_u16(VncState
*vs
, uint16_t value
)
1359 buf
[0] = (value
>> 8) & 0xFF;
1360 buf
[1] = value
& 0xFF;
1362 vnc_write(vs
, buf
, 2);
1365 void vnc_write_u8(VncState
*vs
, uint8_t value
)
1367 vnc_write(vs
, (char *)&value
, 1);
1370 void vnc_flush(VncState
*vs
)
1372 vnc_lock_output(vs
);
1373 if (vs
->csock
!= -1 && vs
->output
.offset
) {
1374 vnc_client_write_locked(vs
);
1376 vnc_unlock_output(vs
);
1379 uint8_t read_u8(uint8_t *data
, size_t offset
)
1381 return data
[offset
];
1384 uint16_t read_u16(uint8_t *data
, size_t offset
)
1386 return ((data
[offset
] & 0xFF) << 8) | (data
[offset
+ 1] & 0xFF);
1389 int32_t read_s32(uint8_t *data
, size_t offset
)
1391 return (int32_t)((data
[offset
] << 24) | (data
[offset
+ 1] << 16) |
1392 (data
[offset
+ 2] << 8) | data
[offset
+ 3]);
1395 uint32_t read_u32(uint8_t *data
, size_t offset
)
1397 return ((data
[offset
] << 24) | (data
[offset
+ 1] << 16) |
1398 (data
[offset
+ 2] << 8) | data
[offset
+ 3]);
1401 static void client_cut_text(VncState
*vs
, size_t len
, uint8_t *text
)
1405 static void check_pointer_type_change(Notifier
*notifier
, void *data
)
1407 VncState
*vs
= container_of(notifier
, VncState
, mouse_mode_notifier
);
1408 int absolute
= kbd_mouse_is_absolute();
1410 if (vnc_has_feature(vs
, VNC_FEATURE_POINTER_TYPE_CHANGE
) && vs
->absolute
!= absolute
) {
1411 vnc_lock_output(vs
);
1412 vnc_write_u8(vs
, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE
);
1413 vnc_write_u8(vs
, 0);
1414 vnc_write_u16(vs
, 1);
1415 vnc_framebuffer_update(vs
, absolute
, 0,
1416 ds_get_width(vs
->ds
), ds_get_height(vs
->ds
),
1417 VNC_ENCODING_POINTER_TYPE_CHANGE
);
1418 vnc_unlock_output(vs
);
1421 vs
->absolute
= absolute
;
1424 static void pointer_event(VncState
*vs
, int button_mask
, int x
, int y
)
1429 if (button_mask
& 0x01)
1430 buttons
|= MOUSE_EVENT_LBUTTON
;
1431 if (button_mask
& 0x02)
1432 buttons
|= MOUSE_EVENT_MBUTTON
;
1433 if (button_mask
& 0x04)
1434 buttons
|= MOUSE_EVENT_RBUTTON
;
1435 if (button_mask
& 0x08)
1437 if (button_mask
& 0x10)
1441 kbd_mouse_event(ds_get_width(vs
->ds
) > 1 ?
1442 x
* 0x7FFF / (ds_get_width(vs
->ds
) - 1) : 0x4000,
1443 ds_get_height(vs
->ds
) > 1 ?
1444 y
* 0x7FFF / (ds_get_height(vs
->ds
) - 1) : 0x4000,
1446 } else if (vnc_has_feature(vs
, VNC_FEATURE_POINTER_TYPE_CHANGE
)) {
1450 kbd_mouse_event(x
, y
, dz
, buttons
);
1452 if (vs
->last_x
!= -1)
1453 kbd_mouse_event(x
- vs
->last_x
,
1461 static void reset_keys(VncState
*vs
)
1464 for(i
= 0; i
< 256; i
++) {
1465 if (vs
->modifiers_state
[i
]) {
1466 if (i
& SCANCODE_GREY
)
1467 kbd_put_keycode(SCANCODE_EMUL0
);
1468 kbd_put_keycode(i
| SCANCODE_UP
);
1469 vs
->modifiers_state
[i
] = 0;
1474 static void press_key(VncState
*vs
, int keysym
)
1476 int keycode
= keysym2scancode(vs
->vd
->kbd_layout
, keysym
) & SCANCODE_KEYMASK
;
1477 if (keycode
& SCANCODE_GREY
)
1478 kbd_put_keycode(SCANCODE_EMUL0
);
1479 kbd_put_keycode(keycode
& SCANCODE_KEYCODEMASK
);
1480 if (keycode
& SCANCODE_GREY
)
1481 kbd_put_keycode(SCANCODE_EMUL0
);
1482 kbd_put_keycode(keycode
| SCANCODE_UP
);
1485 static void kbd_leds(void *opaque
, int ledstate
)
1487 VncState
*vs
= opaque
;
1490 caps
= ledstate
& QEMU_CAPS_LOCK_LED
? 1 : 0;
1491 num
= ledstate
& QEMU_NUM_LOCK_LED
? 1 : 0;
1493 if (vs
->modifiers_state
[0x3a] != caps
) {
1494 vs
->modifiers_state
[0x3a] = caps
;
1496 if (vs
->modifiers_state
[0x45] != num
) {
1497 vs
->modifiers_state
[0x45] = num
;
1501 static void do_key_event(VncState
*vs
, int down
, int keycode
, int sym
)
1503 /* QEMU console switch */
1505 case 0x2a: /* Left Shift */
1506 case 0x36: /* Right Shift */
1507 case 0x1d: /* Left CTRL */
1508 case 0x9d: /* Right CTRL */
1509 case 0x38: /* Left ALT */
1510 case 0xb8: /* Right ALT */
1512 vs
->modifiers_state
[keycode
] = 1;
1514 vs
->modifiers_state
[keycode
] = 0;
1516 case 0x02 ... 0x0a: /* '1' to '9' keys */
1517 if (down
&& vs
->modifiers_state
[0x1d] && vs
->modifiers_state
[0x38]) {
1518 /* Reset the modifiers sent to the current console */
1520 console_select(keycode
- 0x02);
1524 case 0x3a: /* CapsLock */
1525 case 0x45: /* NumLock */
1527 vs
->modifiers_state
[keycode
] ^= 1;
1531 if (down
&& vs
->vd
->lock_key_sync
&&
1532 keycode_is_keypad(vs
->vd
->kbd_layout
, keycode
)) {
1533 /* If the numlock state needs to change then simulate an additional
1534 keypress before sending this one. This will happen if the user
1535 toggles numlock away from the VNC window.
1537 if (keysym_is_numlock(vs
->vd
->kbd_layout
, sym
& 0xFFFF)) {
1538 if (!vs
->modifiers_state
[0x45]) {
1539 vs
->modifiers_state
[0x45] = 1;
1540 press_key(vs
, 0xff7f);
1543 if (vs
->modifiers_state
[0x45]) {
1544 vs
->modifiers_state
[0x45] = 0;
1545 press_key(vs
, 0xff7f);
1550 if (down
&& vs
->vd
->lock_key_sync
&&
1551 ((sym
>= 'A' && sym
<= 'Z') || (sym
>= 'a' && sym
<= 'z'))) {
1552 /* If the capslock state needs to change then simulate an additional
1553 keypress before sending this one. This will happen if the user
1554 toggles capslock away from the VNC window.
1556 int uppercase
= !!(sym
>= 'A' && sym
<= 'Z');
1557 int shift
= !!(vs
->modifiers_state
[0x2a] | vs
->modifiers_state
[0x36]);
1558 int capslock
= !!(vs
->modifiers_state
[0x3a]);
1560 if (uppercase
== shift
) {
1561 vs
->modifiers_state
[0x3a] = 0;
1562 press_key(vs
, 0xffe5);
1565 if (uppercase
!= shift
) {
1566 vs
->modifiers_state
[0x3a] = 1;
1567 press_key(vs
, 0xffe5);
1572 if (is_graphic_console()) {
1573 if (keycode
& SCANCODE_GREY
)
1574 kbd_put_keycode(SCANCODE_EMUL0
);
1576 kbd_put_keycode(keycode
& SCANCODE_KEYCODEMASK
);
1578 kbd_put_keycode(keycode
| SCANCODE_UP
);
1580 bool numlock
= vs
->modifiers_state
[0x45];
1581 bool control
= (vs
->modifiers_state
[0x1d] ||
1582 vs
->modifiers_state
[0x9d]);
1583 /* QEMU console emulation */
1586 case 0x2a: /* Left Shift */
1587 case 0x36: /* Right Shift */
1588 case 0x1d: /* Left CTRL */
1589 case 0x9d: /* Right CTRL */
1590 case 0x38: /* Left ALT */
1591 case 0xb8: /* Right ALT */
1594 kbd_put_keysym(QEMU_KEY_UP
);
1597 kbd_put_keysym(QEMU_KEY_DOWN
);
1600 kbd_put_keysym(QEMU_KEY_LEFT
);
1603 kbd_put_keysym(QEMU_KEY_RIGHT
);
1606 kbd_put_keysym(QEMU_KEY_DELETE
);
1609 kbd_put_keysym(QEMU_KEY_HOME
);
1612 kbd_put_keysym(QEMU_KEY_END
);
1615 kbd_put_keysym(QEMU_KEY_PAGEUP
);
1618 kbd_put_keysym(QEMU_KEY_PAGEDOWN
);
1622 kbd_put_keysym(numlock
? '7' : QEMU_KEY_HOME
);
1625 kbd_put_keysym(numlock
? '8' : QEMU_KEY_UP
);
1628 kbd_put_keysym(numlock
? '9' : QEMU_KEY_PAGEUP
);
1631 kbd_put_keysym(numlock
? '4' : QEMU_KEY_LEFT
);
1634 kbd_put_keysym('5');
1637 kbd_put_keysym(numlock
? '6' : QEMU_KEY_RIGHT
);
1640 kbd_put_keysym(numlock
? '1' : QEMU_KEY_END
);
1643 kbd_put_keysym(numlock
? '2' : QEMU_KEY_DOWN
);
1646 kbd_put_keysym(numlock
? '3' : QEMU_KEY_PAGEDOWN
);
1649 kbd_put_keysym('0');
1652 kbd_put_keysym(numlock
? '.' : QEMU_KEY_DELETE
);
1656 kbd_put_keysym('/');
1659 kbd_put_keysym('*');
1662 kbd_put_keysym('-');
1665 kbd_put_keysym('+');
1668 kbd_put_keysym('\n');
1673 kbd_put_keysym(sym
& 0x1f);
1675 kbd_put_keysym(sym
);
1683 static void vnc_release_modifiers(VncState
*vs
)
1685 static const int keycodes
[] = {
1686 /* shift, control, alt keys, both left & right */
1687 0x2a, 0x36, 0x1d, 0x9d, 0x38, 0xb8,
1691 if (!is_graphic_console()) {
1694 for (i
= 0; i
< ARRAY_SIZE(keycodes
); i
++) {
1695 keycode
= keycodes
[i
];
1696 if (!vs
->modifiers_state
[keycode
]) {
1699 if (keycode
& SCANCODE_GREY
) {
1700 kbd_put_keycode(SCANCODE_EMUL0
);
1702 kbd_put_keycode(keycode
| SCANCODE_UP
);
1706 static void key_event(VncState
*vs
, int down
, uint32_t sym
)
1711 if (lsym
>= 'A' && lsym
<= 'Z' && is_graphic_console()) {
1712 lsym
= lsym
- 'A' + 'a';
1715 keycode
= keysym2scancode(vs
->vd
->kbd_layout
, lsym
& 0xFFFF) & SCANCODE_KEYMASK
;
1716 do_key_event(vs
, down
, keycode
, sym
);
1719 static void ext_key_event(VncState
*vs
, int down
,
1720 uint32_t sym
, uint16_t keycode
)
1722 /* if the user specifies a keyboard layout, always use it */
1723 if (keyboard_layout
)
1724 key_event(vs
, down
, sym
);
1726 do_key_event(vs
, down
, keycode
, sym
);
1729 static void framebuffer_update_request(VncState
*vs
, int incremental
,
1730 int x_position
, int y_position
,
1734 const size_t width
= ds_get_width(vs
->ds
) / 16;
1736 if (y_position
> ds_get_height(vs
->ds
))
1737 y_position
= ds_get_height(vs
->ds
);
1738 if (y_position
+ h
>= ds_get_height(vs
->ds
))
1739 h
= ds_get_height(vs
->ds
) - y_position
;
1741 vs
->need_update
= 1;
1743 vs
->force_update
= 1;
1744 for (i
= 0; i
< h
; i
++) {
1745 bitmap_set(vs
->dirty
[y_position
+ i
], 0, width
);
1746 bitmap_clear(vs
->dirty
[y_position
+ i
], width
,
1747 VNC_DIRTY_BITS
- width
);
1752 static void send_ext_key_event_ack(VncState
*vs
)
1754 vnc_lock_output(vs
);
1755 vnc_write_u8(vs
, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE
);
1756 vnc_write_u8(vs
, 0);
1757 vnc_write_u16(vs
, 1);
1758 vnc_framebuffer_update(vs
, 0, 0, ds_get_width(vs
->ds
), ds_get_height(vs
->ds
),
1759 VNC_ENCODING_EXT_KEY_EVENT
);
1760 vnc_unlock_output(vs
);
1764 static void send_ext_audio_ack(VncState
*vs
)
1766 vnc_lock_output(vs
);
1767 vnc_write_u8(vs
, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE
);
1768 vnc_write_u8(vs
, 0);
1769 vnc_write_u16(vs
, 1);
1770 vnc_framebuffer_update(vs
, 0, 0, ds_get_width(vs
->ds
), ds_get_height(vs
->ds
),
1771 VNC_ENCODING_AUDIO
);
1772 vnc_unlock_output(vs
);
1776 static void set_encodings(VncState
*vs
, int32_t *encodings
, size_t n_encodings
)
1779 unsigned int enc
= 0;
1782 vs
->vnc_encoding
= 0;
1783 vs
->tight
.compression
= 9;
1784 vs
->tight
.quality
= -1; /* Lossless by default */
1788 * Start from the end because the encodings are sent in order of preference.
1789 * This way the preferred encoding (first encoding defined in the array)
1790 * will be set at the end of the loop.
1792 for (i
= n_encodings
- 1; i
>= 0; i
--) {
1795 case VNC_ENCODING_RAW
:
1796 vs
->vnc_encoding
= enc
;
1798 case VNC_ENCODING_COPYRECT
:
1799 vs
->features
|= VNC_FEATURE_COPYRECT_MASK
;
1801 case VNC_ENCODING_HEXTILE
:
1802 vs
->features
|= VNC_FEATURE_HEXTILE_MASK
;
1803 vs
->vnc_encoding
= enc
;
1805 case VNC_ENCODING_TIGHT
:
1806 vs
->features
|= VNC_FEATURE_TIGHT_MASK
;
1807 vs
->vnc_encoding
= enc
;
1809 case VNC_ENCODING_TIGHT_PNG
:
1810 vs
->features
|= VNC_FEATURE_TIGHT_PNG_MASK
;
1811 vs
->vnc_encoding
= enc
;
1813 case VNC_ENCODING_ZLIB
:
1814 vs
->features
|= VNC_FEATURE_ZLIB_MASK
;
1815 vs
->vnc_encoding
= enc
;
1817 case VNC_ENCODING_ZRLE
:
1818 vs
->features
|= VNC_FEATURE_ZRLE_MASK
;
1819 vs
->vnc_encoding
= enc
;
1821 case VNC_ENCODING_ZYWRLE
:
1822 vs
->features
|= VNC_FEATURE_ZYWRLE_MASK
;
1823 vs
->vnc_encoding
= enc
;
1825 case VNC_ENCODING_DESKTOPRESIZE
:
1826 vs
->features
|= VNC_FEATURE_RESIZE_MASK
;
1828 case VNC_ENCODING_POINTER_TYPE_CHANGE
:
1829 vs
->features
|= VNC_FEATURE_POINTER_TYPE_CHANGE_MASK
;
1831 case VNC_ENCODING_RICH_CURSOR
:
1832 vs
->features
|= VNC_FEATURE_RICH_CURSOR_MASK
;
1834 case VNC_ENCODING_EXT_KEY_EVENT
:
1835 send_ext_key_event_ack(vs
);
1837 case VNC_ENCODING_AUDIO
:
1838 send_ext_audio_ack(vs
);
1840 case VNC_ENCODING_WMVi
:
1841 vs
->features
|= VNC_FEATURE_WMVI_MASK
;
1843 case VNC_ENCODING_COMPRESSLEVEL0
... VNC_ENCODING_COMPRESSLEVEL0
+ 9:
1844 vs
->tight
.compression
= (enc
& 0x0F);
1846 case VNC_ENCODING_QUALITYLEVEL0
... VNC_ENCODING_QUALITYLEVEL0
+ 9:
1847 if (vs
->vd
->lossy
) {
1848 vs
->tight
.quality
= (enc
& 0x0F);
1852 VNC_DEBUG("Unknown encoding: %d (0x%.8x): %d\n", i
, enc
, enc
);
1856 vnc_desktop_resize(vs
);
1857 check_pointer_type_change(&vs
->mouse_mode_notifier
, NULL
);
1860 static void set_pixel_conversion(VncState
*vs
)
1862 if ((vs
->clientds
.flags
& QEMU_BIG_ENDIAN_FLAG
) ==
1863 (vs
->ds
->surface
->flags
& QEMU_BIG_ENDIAN_FLAG
) &&
1864 !memcmp(&(vs
->clientds
.pf
), &(vs
->ds
->surface
->pf
), sizeof(PixelFormat
))) {
1865 vs
->write_pixels
= vnc_write_pixels_copy
;
1866 vnc_hextile_set_pixel_conversion(vs
, 0);
1868 vs
->write_pixels
= vnc_write_pixels_generic
;
1869 vnc_hextile_set_pixel_conversion(vs
, 1);
1873 static void set_pixel_format(VncState
*vs
,
1874 int bits_per_pixel
, int depth
,
1875 int big_endian_flag
, int true_color_flag
,
1876 int red_max
, int green_max
, int blue_max
,
1877 int red_shift
, int green_shift
, int blue_shift
)
1879 if (!true_color_flag
) {
1880 vnc_client_error(vs
);
1884 vs
->clientds
= *(vs
->vd
->guest
.ds
);
1885 vs
->clientds
.pf
.rmax
= red_max
;
1886 vs
->clientds
.pf
.rbits
= hweight_long(red_max
);
1887 vs
->clientds
.pf
.rshift
= red_shift
;
1888 vs
->clientds
.pf
.rmask
= red_max
<< red_shift
;
1889 vs
->clientds
.pf
.gmax
= green_max
;
1890 vs
->clientds
.pf
.gbits
= hweight_long(green_max
);
1891 vs
->clientds
.pf
.gshift
= green_shift
;
1892 vs
->clientds
.pf
.gmask
= green_max
<< green_shift
;
1893 vs
->clientds
.pf
.bmax
= blue_max
;
1894 vs
->clientds
.pf
.bbits
= hweight_long(blue_max
);
1895 vs
->clientds
.pf
.bshift
= blue_shift
;
1896 vs
->clientds
.pf
.bmask
= blue_max
<< blue_shift
;
1897 vs
->clientds
.pf
.bits_per_pixel
= bits_per_pixel
;
1898 vs
->clientds
.pf
.bytes_per_pixel
= bits_per_pixel
/ 8;
1899 vs
->clientds
.pf
.depth
= bits_per_pixel
== 32 ? 24 : bits_per_pixel
;
1900 vs
->clientds
.flags
= big_endian_flag
? QEMU_BIG_ENDIAN_FLAG
: 0x00;
1902 set_pixel_conversion(vs
);
1904 vga_hw_invalidate();
1908 static void pixel_format_message (VncState
*vs
) {
1909 char pad
[3] = { 0, 0, 0 };
1911 vnc_write_u8(vs
, vs
->ds
->surface
->pf
.bits_per_pixel
); /* bits-per-pixel */
1912 vnc_write_u8(vs
, vs
->ds
->surface
->pf
.depth
); /* depth */
1914 #ifdef HOST_WORDS_BIGENDIAN
1915 vnc_write_u8(vs
, 1); /* big-endian-flag */
1917 vnc_write_u8(vs
, 0); /* big-endian-flag */
1919 vnc_write_u8(vs
, 1); /* true-color-flag */
1920 vnc_write_u16(vs
, vs
->ds
->surface
->pf
.rmax
); /* red-max */
1921 vnc_write_u16(vs
, vs
->ds
->surface
->pf
.gmax
); /* green-max */
1922 vnc_write_u16(vs
, vs
->ds
->surface
->pf
.bmax
); /* blue-max */
1923 vnc_write_u8(vs
, vs
->ds
->surface
->pf
.rshift
); /* red-shift */
1924 vnc_write_u8(vs
, vs
->ds
->surface
->pf
.gshift
); /* green-shift */
1925 vnc_write_u8(vs
, vs
->ds
->surface
->pf
.bshift
); /* blue-shift */
1927 vnc_hextile_set_pixel_conversion(vs
, 0);
1929 vs
->clientds
= *(vs
->ds
->surface
);
1930 vs
->clientds
.flags
&= ~QEMU_ALLOCATED_FLAG
;
1931 vs
->write_pixels
= vnc_write_pixels_copy
;
1933 vnc_write(vs
, pad
, 3); /* padding */
1936 static void vnc_dpy_setdata(DisplayState
*ds
)
1938 VncDisplay
*vd
= ds
->opaque
;
1940 *(vd
->guest
.ds
) = *(ds
->surface
);
1941 vnc_dpy_update(ds
, 0, 0, ds_get_width(ds
), ds_get_height(ds
));
1944 static void vnc_colordepth(VncState
*vs
)
1946 if (vnc_has_feature(vs
, VNC_FEATURE_WMVI
)) {
1947 /* Sending a WMVi message to notify the client*/
1948 vnc_lock_output(vs
);
1949 vnc_write_u8(vs
, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE
);
1950 vnc_write_u8(vs
, 0);
1951 vnc_write_u16(vs
, 1); /* number of rects */
1952 vnc_framebuffer_update(vs
, 0, 0, ds_get_width(vs
->ds
),
1953 ds_get_height(vs
->ds
), VNC_ENCODING_WMVi
);
1954 pixel_format_message(vs
);
1955 vnc_unlock_output(vs
);
1958 set_pixel_conversion(vs
);
1962 static int protocol_client_msg(VncState
*vs
, uint8_t *data
, size_t len
)
1966 VncDisplay
*vd
= vs
->vd
;
1969 vd
->timer_interval
= VNC_REFRESH_INTERVAL_BASE
;
1970 if (!qemu_timer_expired(vd
->timer
, qemu_get_clock_ms(rt_clock
) + vd
->timer_interval
))
1971 qemu_mod_timer(vd
->timer
, qemu_get_clock_ms(rt_clock
) + vd
->timer_interval
);
1975 case VNC_MSG_CLIENT_SET_PIXEL_FORMAT
:
1979 set_pixel_format(vs
, read_u8(data
, 4), read_u8(data
, 5),
1980 read_u8(data
, 6), read_u8(data
, 7),
1981 read_u16(data
, 8), read_u16(data
, 10),
1982 read_u16(data
, 12), read_u8(data
, 14),
1983 read_u8(data
, 15), read_u8(data
, 16));
1985 case VNC_MSG_CLIENT_SET_ENCODINGS
:
1990 limit
= read_u16(data
, 2);
1992 return 4 + (limit
* 4);
1994 limit
= read_u16(data
, 2);
1996 for (i
= 0; i
< limit
; i
++) {
1997 int32_t val
= read_s32(data
, 4 + (i
* 4));
1998 memcpy(data
+ 4 + (i
* 4), &val
, sizeof(val
));
2001 set_encodings(vs
, (int32_t *)(data
+ 4), limit
);
2003 case VNC_MSG_CLIENT_FRAMEBUFFER_UPDATE_REQUEST
:
2007 framebuffer_update_request(vs
,
2008 read_u8(data
, 1), read_u16(data
, 2), read_u16(data
, 4),
2009 read_u16(data
, 6), read_u16(data
, 8));
2011 case VNC_MSG_CLIENT_KEY_EVENT
:
2015 key_event(vs
, read_u8(data
, 1), read_u32(data
, 4));
2017 case VNC_MSG_CLIENT_POINTER_EVENT
:
2021 pointer_event(vs
, read_u8(data
, 1), read_u16(data
, 2), read_u16(data
, 4));
2023 case VNC_MSG_CLIENT_CUT_TEXT
:
2028 uint32_t dlen
= read_u32(data
, 4);
2033 client_cut_text(vs
, read_u32(data
, 4), data
+ 8);
2035 case VNC_MSG_CLIENT_QEMU
:
2039 switch (read_u8(data
, 1)) {
2040 case VNC_MSG_CLIENT_QEMU_EXT_KEY_EVENT
:
2044 ext_key_event(vs
, read_u16(data
, 2),
2045 read_u32(data
, 4), read_u32(data
, 8));
2047 case VNC_MSG_CLIENT_QEMU_AUDIO
:
2051 switch (read_u16 (data
, 2)) {
2052 case VNC_MSG_CLIENT_QEMU_AUDIO_ENABLE
:
2055 case VNC_MSG_CLIENT_QEMU_AUDIO_DISABLE
:
2058 case VNC_MSG_CLIENT_QEMU_AUDIO_SET_FORMAT
:
2061 switch (read_u8(data
, 4)) {
2062 case 0: vs
->as
.fmt
= AUD_FMT_U8
; break;
2063 case 1: vs
->as
.fmt
= AUD_FMT_S8
; break;
2064 case 2: vs
->as
.fmt
= AUD_FMT_U16
; break;
2065 case 3: vs
->as
.fmt
= AUD_FMT_S16
; break;
2066 case 4: vs
->as
.fmt
= AUD_FMT_U32
; break;
2067 case 5: vs
->as
.fmt
= AUD_FMT_S32
; break;
2069 printf("Invalid audio format %d\n", read_u8(data
, 4));
2070 vnc_client_error(vs
);
2073 vs
->as
.nchannels
= read_u8(data
, 5);
2074 if (vs
->as
.nchannels
!= 1 && vs
->as
.nchannels
!= 2) {
2075 printf("Invalid audio channel coount %d\n",
2077 vnc_client_error(vs
);
2080 vs
->as
.freq
= read_u32(data
, 6);
2083 printf ("Invalid audio message %d\n", read_u8(data
, 4));
2084 vnc_client_error(vs
);
2090 printf("Msg: %d\n", read_u16(data
, 0));
2091 vnc_client_error(vs
);
2096 printf("Msg: %d\n", data
[0]);
2097 vnc_client_error(vs
);
2101 vnc_read_when(vs
, protocol_client_msg
, 1);
2105 static int protocol_client_init(VncState
*vs
, uint8_t *data
, size_t len
)
2111 mode
= data
[0] ? VNC_SHARE_MODE_SHARED
: VNC_SHARE_MODE_EXCLUSIVE
;
2112 switch (vs
->vd
->share_policy
) {
2113 case VNC_SHARE_POLICY_IGNORE
:
2115 * Ignore the shared flag. Nothing to do here.
2117 * Doesn't conform to the rfb spec but is traditional qemu
2118 * behavior, thus left here as option for compatibility
2122 case VNC_SHARE_POLICY_ALLOW_EXCLUSIVE
:
2124 * Policy: Allow clients ask for exclusive access.
2126 * Implementation: When a client asks for exclusive access,
2127 * disconnect all others. Shared connects are allowed as long
2128 * as no exclusive connection exists.
2130 * This is how the rfb spec suggests to handle the shared flag.
2132 if (mode
== VNC_SHARE_MODE_EXCLUSIVE
) {
2134 QTAILQ_FOREACH(client
, &vs
->vd
->clients
, next
) {
2138 if (client
->share_mode
!= VNC_SHARE_MODE_EXCLUSIVE
&&
2139 client
->share_mode
!= VNC_SHARE_MODE_SHARED
) {
2142 vnc_disconnect_start(client
);
2145 if (mode
== VNC_SHARE_MODE_SHARED
) {
2146 if (vs
->vd
->num_exclusive
> 0) {
2147 vnc_disconnect_start(vs
);
2152 case VNC_SHARE_POLICY_FORCE_SHARED
:
2154 * Policy: Shared connects only.
2155 * Implementation: Disallow clients asking for exclusive access.
2157 * Useful for shared desktop sessions where you don't want
2158 * someone forgetting to say -shared when running the vnc
2159 * client disconnect everybody else.
2161 if (mode
== VNC_SHARE_MODE_EXCLUSIVE
) {
2162 vnc_disconnect_start(vs
);
2167 vnc_set_share_mode(vs
, mode
);
2169 vs
->client_width
= ds_get_width(vs
->ds
);
2170 vs
->client_height
= ds_get_height(vs
->ds
);
2171 vnc_write_u16(vs
, vs
->client_width
);
2172 vnc_write_u16(vs
, vs
->client_height
);
2174 pixel_format_message(vs
);
2177 size
= snprintf(buf
, sizeof(buf
), "QEMU (%s)", qemu_name
);
2179 size
= snprintf(buf
, sizeof(buf
), "QEMU");
2181 vnc_write_u32(vs
, size
);
2182 vnc_write(vs
, buf
, size
);
2185 vnc_client_cache_auth(vs
);
2186 vnc_qmp_event(vs
, QEVENT_VNC_INITIALIZED
);
2188 vnc_read_when(vs
, protocol_client_msg
, 1);
2193 void start_client_init(VncState
*vs
)
2195 vnc_read_when(vs
, protocol_client_init
, 1);
2198 static void make_challenge(VncState
*vs
)
2202 srand(time(NULL
)+getpid()+getpid()*987654+rand());
2204 for (i
= 0 ; i
< sizeof(vs
->challenge
) ; i
++)
2205 vs
->challenge
[i
] = (int) (256.0*rand()/(RAND_MAX
+1.0));
2208 static int protocol_client_auth_vnc(VncState
*vs
, uint8_t *data
, size_t len
)
2210 unsigned char response
[VNC_AUTH_CHALLENGE_SIZE
];
2212 unsigned char key
[8];
2213 time_t now
= time(NULL
);
2215 if (!vs
->vd
->password
) {
2216 VNC_DEBUG("No password configured on server");
2219 if (vs
->vd
->expires
< now
) {
2220 VNC_DEBUG("Password is expired");
2224 memcpy(response
, vs
->challenge
, VNC_AUTH_CHALLENGE_SIZE
);
2226 /* Calculate the expected challenge response */
2227 pwlen
= strlen(vs
->vd
->password
);
2228 for (i
=0; i
<sizeof(key
); i
++)
2229 key
[i
] = i
<pwlen
? vs
->vd
->password
[i
] : 0;
2231 for (j
= 0; j
< VNC_AUTH_CHALLENGE_SIZE
; j
+= 8)
2232 des(response
+j
, response
+j
);
2234 /* Compare expected vs actual challenge response */
2235 if (memcmp(response
, data
, VNC_AUTH_CHALLENGE_SIZE
) != 0) {
2236 VNC_DEBUG("Client challenge response did not match\n");
2239 VNC_DEBUG("Accepting VNC challenge response\n");
2240 vnc_write_u32(vs
, 0); /* Accept auth */
2243 start_client_init(vs
);
2248 vnc_write_u32(vs
, 1); /* Reject auth */
2249 if (vs
->minor
>= 8) {
2250 static const char err
[] = "Authentication failed";
2251 vnc_write_u32(vs
, sizeof(err
));
2252 vnc_write(vs
, err
, sizeof(err
));
2255 vnc_client_error(vs
);
2259 void start_auth_vnc(VncState
*vs
)
2262 /* Send client a 'random' challenge */
2263 vnc_write(vs
, vs
->challenge
, sizeof(vs
->challenge
));
2266 vnc_read_when(vs
, protocol_client_auth_vnc
, sizeof(vs
->challenge
));
2270 static int protocol_client_auth(VncState
*vs
, uint8_t *data
, size_t len
)
2272 /* We only advertise 1 auth scheme at a time, so client
2273 * must pick the one we sent. Verify this */
2274 if (data
[0] != vs
->auth
) { /* Reject auth */
2275 VNC_DEBUG("Reject auth %d because it didn't match advertized\n", (int)data
[0]);
2276 vnc_write_u32(vs
, 1);
2277 if (vs
->minor
>= 8) {
2278 static const char err
[] = "Authentication failed";
2279 vnc_write_u32(vs
, sizeof(err
));
2280 vnc_write(vs
, err
, sizeof(err
));
2282 vnc_client_error(vs
);
2283 } else { /* Accept requested auth */
2284 VNC_DEBUG("Client requested auth %d\n", (int)data
[0]);
2287 VNC_DEBUG("Accept auth none\n");
2288 if (vs
->minor
>= 8) {
2289 vnc_write_u32(vs
, 0); /* Accept auth completion */
2292 start_client_init(vs
);
2296 VNC_DEBUG("Start VNC auth\n");
2300 #ifdef CONFIG_VNC_TLS
2301 case VNC_AUTH_VENCRYPT
:
2302 VNC_DEBUG("Accept VeNCrypt auth\n");
2303 start_auth_vencrypt(vs
);
2305 #endif /* CONFIG_VNC_TLS */
2307 #ifdef CONFIG_VNC_SASL
2309 VNC_DEBUG("Accept SASL auth\n");
2310 start_auth_sasl(vs
);
2312 #endif /* CONFIG_VNC_SASL */
2314 default: /* Should not be possible, but just in case */
2315 VNC_DEBUG("Reject auth %d server code bug\n", vs
->auth
);
2316 vnc_write_u8(vs
, 1);
2317 if (vs
->minor
>= 8) {
2318 static const char err
[] = "Authentication failed";
2319 vnc_write_u32(vs
, sizeof(err
));
2320 vnc_write(vs
, err
, sizeof(err
));
2322 vnc_client_error(vs
);
2328 static int protocol_version(VncState
*vs
, uint8_t *version
, size_t len
)
2332 memcpy(local
, version
, 12);
2335 if (sscanf(local
, "RFB %03d.%03d\n", &vs
->major
, &vs
->minor
) != 2) {
2336 VNC_DEBUG("Malformed protocol version %s\n", local
);
2337 vnc_client_error(vs
);
2340 VNC_DEBUG("Client request protocol version %d.%d\n", vs
->major
, vs
->minor
);
2341 if (vs
->major
!= 3 ||
2347 VNC_DEBUG("Unsupported client version\n");
2348 vnc_write_u32(vs
, VNC_AUTH_INVALID
);
2350 vnc_client_error(vs
);
2353 /* Some broken clients report v3.4 or v3.5, which spec requires to be treated
2354 * as equivalent to v3.3 by servers
2356 if (vs
->minor
== 4 || vs
->minor
== 5)
2359 if (vs
->minor
== 3) {
2360 if (vs
->auth
== VNC_AUTH_NONE
) {
2361 VNC_DEBUG("Tell client auth none\n");
2362 vnc_write_u32(vs
, vs
->auth
);
2364 start_client_init(vs
);
2365 } else if (vs
->auth
== VNC_AUTH_VNC
) {
2366 VNC_DEBUG("Tell client VNC auth\n");
2367 vnc_write_u32(vs
, vs
->auth
);
2371 VNC_DEBUG("Unsupported auth %d for protocol 3.3\n", vs
->auth
);
2372 vnc_write_u32(vs
, VNC_AUTH_INVALID
);
2374 vnc_client_error(vs
);
2377 VNC_DEBUG("Telling client we support auth %d\n", vs
->auth
);
2378 vnc_write_u8(vs
, 1); /* num auth */
2379 vnc_write_u8(vs
, vs
->auth
);
2380 vnc_read_when(vs
, protocol_client_auth
, 1);
2387 static VncRectStat
*vnc_stat_rect(VncDisplay
*vd
, int x
, int y
)
2389 struct VncSurface
*vs
= &vd
->guest
;
2391 return &vs
->stats
[y
/ VNC_STAT_RECT
][x
/ VNC_STAT_RECT
];
2394 void vnc_sent_lossy_rect(VncState
*vs
, int x
, int y
, int w
, int h
)
2398 w
= (x
+ w
) / VNC_STAT_RECT
;
2399 h
= (y
+ h
) / VNC_STAT_RECT
;
2403 for (j
= y
; j
<= h
; j
++) {
2404 for (i
= x
; i
<= w
; i
++) {
2405 vs
->lossy_rect
[j
][i
] = 1;
2410 static int vnc_refresh_lossy_rect(VncDisplay
*vd
, int x
, int y
)
2413 int sty
= y
/ VNC_STAT_RECT
;
2414 int stx
= x
/ VNC_STAT_RECT
;
2417 y
= y
/ VNC_STAT_RECT
* VNC_STAT_RECT
;
2418 x
= x
/ VNC_STAT_RECT
* VNC_STAT_RECT
;
2420 QTAILQ_FOREACH(vs
, &vd
->clients
, next
) {
2423 /* kernel send buffers are full -> refresh later */
2424 if (vs
->output
.offset
) {
2428 if (!vs
->lossy_rect
[sty
][stx
]) {
2432 vs
->lossy_rect
[sty
][stx
] = 0;
2433 for (j
= 0; j
< VNC_STAT_RECT
; ++j
) {
2434 bitmap_set(vs
->dirty
[y
+ j
], x
/ 16, VNC_STAT_RECT
/ 16);
2442 static int vnc_update_stats(VncDisplay
*vd
, struct timeval
* tv
)
2448 for (y
= 0; y
< vd
->guest
.ds
->height
; y
+= VNC_STAT_RECT
) {
2449 for (x
= 0; x
< vd
->guest
.ds
->width
; x
+= VNC_STAT_RECT
) {
2450 VncRectStat
*rect
= vnc_stat_rect(vd
, x
, y
);
2452 rect
->updated
= false;
2456 qemu_timersub(tv
, &VNC_REFRESH_STATS
, &res
);
2458 if (timercmp(&vd
->guest
.last_freq_check
, &res
, >)) {
2461 vd
->guest
.last_freq_check
= *tv
;
2463 for (y
= 0; y
< vd
->guest
.ds
->height
; y
+= VNC_STAT_RECT
) {
2464 for (x
= 0; x
< vd
->guest
.ds
->width
; x
+= VNC_STAT_RECT
) {
2465 VncRectStat
*rect
= vnc_stat_rect(vd
, x
, y
);
2466 int count
= ARRAY_SIZE(rect
->times
);
2467 struct timeval min
, max
;
2469 if (!timerisset(&rect
->times
[count
- 1])) {
2473 max
= rect
->times
[(rect
->idx
+ count
- 1) % count
];
2474 qemu_timersub(tv
, &max
, &res
);
2476 if (timercmp(&res
, &VNC_REFRESH_LOSSY
, >)) {
2478 has_dirty
+= vnc_refresh_lossy_rect(vd
, x
, y
);
2479 memset(rect
->times
, 0, sizeof (rect
->times
));
2483 min
= rect
->times
[rect
->idx
];
2484 max
= rect
->times
[(rect
->idx
+ count
- 1) % count
];
2485 qemu_timersub(&max
, &min
, &res
);
2487 rect
->freq
= res
.tv_sec
+ res
.tv_usec
/ 1000000.;
2488 rect
->freq
/= count
;
2489 rect
->freq
= 1. / rect
->freq
;
2495 double vnc_update_freq(VncState
*vs
, int x
, int y
, int w
, int h
)
2501 x
= (x
/ VNC_STAT_RECT
) * VNC_STAT_RECT
;
2502 y
= (y
/ VNC_STAT_RECT
) * VNC_STAT_RECT
;
2504 for (j
= y
; j
<= y
+ h
; j
+= VNC_STAT_RECT
) {
2505 for (i
= x
; i
<= x
+ w
; i
+= VNC_STAT_RECT
) {
2506 total
+= vnc_stat_rect(vs
->vd
, i
, j
)->freq
;
2518 static void vnc_rect_updated(VncDisplay
*vd
, int x
, int y
, struct timeval
* tv
)
2522 rect
= vnc_stat_rect(vd
, x
, y
);
2523 if (rect
->updated
) {
2526 rect
->times
[rect
->idx
] = *tv
;
2527 rect
->idx
= (rect
->idx
+ 1) % ARRAY_SIZE(rect
->times
);
2528 rect
->updated
= true;
2531 static int vnc_refresh_server_surface(VncDisplay
*vd
)
2535 uint8_t *server_row
;
2540 struct timeval tv
= { 0, 0 };
2542 if (!vd
->non_adaptive
) {
2543 gettimeofday(&tv
, NULL
);
2544 has_dirty
= vnc_update_stats(vd
, &tv
);
2548 * Walk through the guest dirty map.
2549 * Check and copy modified bits from guest to server surface.
2550 * Update server dirty map.
2552 cmp_bytes
= 16 * ds_get_bytes_per_pixel(vd
->ds
);
2553 if (cmp_bytes
> vd
->ds
->surface
->linesize
) {
2554 cmp_bytes
= vd
->ds
->surface
->linesize
;
2556 guest_row
= vd
->guest
.ds
->data
;
2557 server_row
= vd
->server
->data
;
2558 for (y
= 0; y
< vd
->guest
.ds
->height
; y
++) {
2559 if (!bitmap_empty(vd
->guest
.dirty
[y
], VNC_DIRTY_BITS
)) {
2562 uint8_t *server_ptr
;
2564 guest_ptr
= guest_row
;
2565 server_ptr
= server_row
;
2567 for (x
= 0; x
+ 15 < vd
->guest
.ds
->width
;
2568 x
+= 16, guest_ptr
+= cmp_bytes
, server_ptr
+= cmp_bytes
) {
2569 if (!test_and_clear_bit((x
/ 16), vd
->guest
.dirty
[y
]))
2571 if (memcmp(server_ptr
, guest_ptr
, cmp_bytes
) == 0)
2573 memcpy(server_ptr
, guest_ptr
, cmp_bytes
);
2574 if (!vd
->non_adaptive
)
2575 vnc_rect_updated(vd
, x
, y
, &tv
);
2576 QTAILQ_FOREACH(vs
, &vd
->clients
, next
) {
2577 set_bit((x
/ 16), vs
->dirty
[y
]);
2582 guest_row
+= ds_get_linesize(vd
->ds
);
2583 server_row
+= ds_get_linesize(vd
->ds
);
2588 static void vnc_refresh(void *opaque
)
2590 VncDisplay
*vd
= opaque
;
2592 int has_dirty
, rects
= 0;
2596 if (vnc_trylock_display(vd
)) {
2597 vd
->timer_interval
= VNC_REFRESH_INTERVAL_BASE
;
2598 qemu_mod_timer(vd
->timer
, qemu_get_clock_ms(rt_clock
) +
2599 vd
->timer_interval
);
2603 has_dirty
= vnc_refresh_server_surface(vd
);
2604 vnc_unlock_display(vd
);
2606 QTAILQ_FOREACH_SAFE(vs
, &vd
->clients
, next
, vn
) {
2607 rects
+= vnc_update_client(vs
, has_dirty
);
2608 /* vs might be free()ed here */
2611 /* vd->timer could be NULL now if the last client disconnected,
2612 * in this case don't update the timer */
2613 if (vd
->timer
== NULL
)
2616 if (has_dirty
&& rects
) {
2617 vd
->timer_interval
/= 2;
2618 if (vd
->timer_interval
< VNC_REFRESH_INTERVAL_BASE
)
2619 vd
->timer_interval
= VNC_REFRESH_INTERVAL_BASE
;
2621 vd
->timer_interval
+= VNC_REFRESH_INTERVAL_INC
;
2622 if (vd
->timer_interval
> VNC_REFRESH_INTERVAL_MAX
)
2623 vd
->timer_interval
= VNC_REFRESH_INTERVAL_MAX
;
2625 qemu_mod_timer(vd
->timer
, qemu_get_clock_ms(rt_clock
) + vd
->timer_interval
);
2628 static void vnc_init_timer(VncDisplay
*vd
)
2630 vd
->timer_interval
= VNC_REFRESH_INTERVAL_BASE
;
2631 if (vd
->timer
== NULL
&& !QTAILQ_EMPTY(&vd
->clients
)) {
2632 vd
->timer
= qemu_new_timer_ms(rt_clock
, vnc_refresh
, vd
);
2633 vnc_dpy_resize(vd
->ds
);
2638 static void vnc_remove_timer(VncDisplay
*vd
)
2640 if (vd
->timer
!= NULL
&& QTAILQ_EMPTY(&vd
->clients
)) {
2641 qemu_del_timer(vd
->timer
);
2642 qemu_free_timer(vd
->timer
);
2647 static void vnc_connect(VncDisplay
*vd
, int csock
, int skipauth
)
2649 VncState
*vs
= g_malloc0(sizeof(VncState
));
2655 vs
->auth
= VNC_AUTH_NONE
;
2656 #ifdef CONFIG_VNC_TLS
2657 vs
->subauth
= VNC_AUTH_INVALID
;
2660 vs
->auth
= vd
->auth
;
2661 #ifdef CONFIG_VNC_TLS
2662 vs
->subauth
= vd
->subauth
;
2666 vs
->lossy_rect
= g_malloc0(VNC_STAT_ROWS
* sizeof (*vs
->lossy_rect
));
2667 for (i
= 0; i
< VNC_STAT_ROWS
; ++i
) {
2668 vs
->lossy_rect
[i
] = g_malloc0(VNC_STAT_COLS
* sizeof (uint8_t));
2671 VNC_DEBUG("New client on socket %d\n", csock
);
2673 socket_set_nonblock(vs
->csock
);
2674 qemu_set_fd_handler2(vs
->csock
, NULL
, vnc_client_read
, NULL
, vs
);
2676 vnc_client_cache_addr(vs
);
2677 vnc_qmp_event(vs
, QEVENT_VNC_CONNECTED
);
2678 vnc_set_share_mode(vs
, VNC_SHARE_MODE_CONNECTING
);
2685 vs
->as
.freq
= 44100;
2686 vs
->as
.nchannels
= 2;
2687 vs
->as
.fmt
= AUD_FMT_S16
;
2688 vs
->as
.endianness
= 0;
2690 qemu_mutex_init(&vs
->output_mutex
);
2691 vs
->bh
= qemu_bh_new(vnc_jobs_bh
, vs
);
2693 QTAILQ_INSERT_HEAD(&vd
->clients
, vs
, next
);
2697 vnc_write(vs
, "RFB 003.008\n", 12);
2699 vnc_read_when(vs
, protocol_version
, 12);
2701 if (vs
->vd
->lock_key_sync
)
2702 vs
->led
= qemu_add_led_event_handler(kbd_leds
, vs
);
2704 vs
->mouse_mode_notifier
.notify
= check_pointer_type_change
;
2705 qemu_add_mouse_mode_change_notifier(&vs
->mouse_mode_notifier
);
2709 /* vs might be free()ed here */
2712 static void vnc_listen_read(void *opaque
)
2714 VncDisplay
*vs
= opaque
;
2715 struct sockaddr_in addr
;
2716 socklen_t addrlen
= sizeof(addr
);
2721 int csock
= qemu_accept(vs
->lsock
, (struct sockaddr
*)&addr
, &addrlen
);
2723 vnc_connect(vs
, csock
, 0);
2727 void vnc_display_init(DisplayState
*ds
)
2729 VncDisplay
*vs
= g_malloc0(sizeof(*vs
));
2731 dcl
= g_malloc0(sizeof(DisplayChangeListener
));
2740 QTAILQ_INIT(&vs
->clients
);
2741 vs
->expires
= TIME_MAX
;
2743 if (keyboard_layout
)
2744 vs
->kbd_layout
= init_keyboard_layout(name2keysym
, keyboard_layout
);
2746 vs
->kbd_layout
= init_keyboard_layout(name2keysym
, "en-us");
2748 if (!vs
->kbd_layout
)
2751 qemu_mutex_init(&vs
->mutex
);
2752 vnc_start_worker_thread();
2754 dcl
->dpy_copy
= vnc_dpy_copy
;
2755 dcl
->dpy_update
= vnc_dpy_update
;
2756 dcl
->dpy_resize
= vnc_dpy_resize
;
2757 dcl
->dpy_setdata
= vnc_dpy_setdata
;
2758 register_displaychangelistener(ds
, dcl
);
2759 ds
->mouse_set
= vnc_mouse_set
;
2760 ds
->cursor_define
= vnc_dpy_cursor_define
;
2764 void vnc_display_close(DisplayState
*ds
)
2766 VncDisplay
*vs
= ds
? (VncDisplay
*)ds
->opaque
: vnc_display
;
2771 g_free(vs
->display
);
2774 if (vs
->lsock
!= -1) {
2775 qemu_set_fd_handler2(vs
->lsock
, NULL
, NULL
, NULL
, NULL
);
2779 vs
->auth
= VNC_AUTH_INVALID
;
2780 #ifdef CONFIG_VNC_TLS
2781 vs
->subauth
= VNC_AUTH_INVALID
;
2782 vs
->tls
.x509verify
= 0;
2786 int vnc_display_disable_login(DisplayState
*ds
)
2788 VncDisplay
*vs
= ds
? (VncDisplay
*)ds
->opaque
: vnc_display
;
2795 g_free(vs
->password
);
2798 vs
->password
= NULL
;
2799 if (vs
->auth
== VNC_AUTH_NONE
) {
2800 vs
->auth
= VNC_AUTH_VNC
;
2806 int vnc_display_password(DisplayState
*ds
, const char *password
)
2808 VncDisplay
*vs
= ds
? (VncDisplay
*)ds
->opaque
: vnc_display
;
2815 /* This is not the intention of this interface but err on the side
2817 return vnc_display_disable_login(ds
);
2821 g_free(vs
->password
);
2822 vs
->password
= NULL
;
2824 vs
->password
= g_strdup(password
);
2825 if (vs
->auth
== VNC_AUTH_NONE
) {
2826 vs
->auth
= VNC_AUTH_VNC
;
2832 int vnc_display_pw_expire(DisplayState
*ds
, time_t expires
)
2834 VncDisplay
*vs
= ds
? (VncDisplay
*)ds
->opaque
: vnc_display
;
2840 vs
->expires
= expires
;
2844 char *vnc_display_local_addr(DisplayState
*ds
)
2846 VncDisplay
*vs
= ds
? (VncDisplay
*)ds
->opaque
: vnc_display
;
2848 return vnc_socket_local_addr("%s:%s", vs
->lsock
);
2851 int vnc_display_open(DisplayState
*ds
, const char *display
)
2853 VncDisplay
*vs
= ds
? (VncDisplay
*)ds
->opaque
: vnc_display
;
2854 const char *options
;
2857 #ifdef CONFIG_VNC_TLS
2858 int tls
= 0, x509
= 0;
2860 #ifdef CONFIG_VNC_SASL
2864 #if defined(CONFIG_VNC_TLS) || defined(CONFIG_VNC_SASL)
2867 int lock_key_sync
= 1;
2871 vnc_display_close(ds
);
2872 if (strcmp(display
, "none") == 0)
2875 if (!(vs
->display
= strdup(display
)))
2877 vs
->share_policy
= VNC_SHARE_POLICY_ALLOW_EXCLUSIVE
;
2880 while ((options
= strchr(options
, ','))) {
2882 if (strncmp(options
, "password", 8) == 0) {
2883 if (fips_get_state()) {
2885 "VNC password auth disabled due to FIPS mode, "
2886 "consider using the VeNCrypt or SASL authentication "
2887 "methods as an alternative\n");
2888 g_free(vs
->display
);
2892 password
= 1; /* Require password auth */
2893 } else if (strncmp(options
, "reverse", 7) == 0) {
2895 } else if (strncmp(options
, "no-lock-key-sync", 16) == 0) {
2897 #ifdef CONFIG_VNC_SASL
2898 } else if (strncmp(options
, "sasl", 4) == 0) {
2899 sasl
= 1; /* Require SASL auth */
2901 #ifdef CONFIG_VNC_TLS
2902 } else if (strncmp(options
, "tls", 3) == 0) {
2903 tls
= 1; /* Require TLS */
2904 } else if (strncmp(options
, "x509", 4) == 0) {
2906 x509
= 1; /* Require x509 certificates */
2907 if (strncmp(options
, "x509verify", 10) == 0)
2908 vs
->tls
.x509verify
= 1; /* ...and verify client certs */
2910 /* Now check for 'x509=/some/path' postfix
2911 * and use that to setup x509 certificate/key paths */
2912 start
= strchr(options
, '=');
2913 end
= strchr(options
, ',');
2914 if (start
&& (!end
|| (start
< end
))) {
2915 int len
= end
? end
-(start
+1) : strlen(start
+1);
2916 char *path
= g_strndup(start
+ 1, len
);
2918 VNC_DEBUG("Trying certificate path '%s'\n", path
);
2919 if (vnc_tls_set_x509_creds_dir(vs
, path
) < 0) {
2920 fprintf(stderr
, "Failed to find x509 certificates/keys in %s\n", path
);
2922 g_free(vs
->display
);
2928 fprintf(stderr
, "No certificate path provided\n");
2929 g_free(vs
->display
);
2934 #if defined(CONFIG_VNC_TLS) || defined(CONFIG_VNC_SASL)
2935 } else if (strncmp(options
, "acl", 3) == 0) {
2938 } else if (strncmp(options
, "lossy", 5) == 0) {
2940 } else if (strncmp(options
, "non-adapative", 13) == 0) {
2941 vs
->non_adaptive
= true;
2942 } else if (strncmp(options
, "share=", 6) == 0) {
2943 if (strncmp(options
+6, "ignore", 6) == 0) {
2944 vs
->share_policy
= VNC_SHARE_POLICY_IGNORE
;
2945 } else if (strncmp(options
+6, "allow-exclusive", 15) == 0) {
2946 vs
->share_policy
= VNC_SHARE_POLICY_ALLOW_EXCLUSIVE
;
2947 } else if (strncmp(options
+6, "force-shared", 12) == 0) {
2948 vs
->share_policy
= VNC_SHARE_POLICY_FORCE_SHARED
;
2950 fprintf(stderr
, "unknown vnc share= option\n");
2951 g_free(vs
->display
);
2958 #ifdef CONFIG_VNC_TLS
2959 if (acl
&& x509
&& vs
->tls
.x509verify
) {
2960 if (!(vs
->tls
.acl
= qemu_acl_init("vnc.x509dname"))) {
2961 fprintf(stderr
, "Failed to create x509 dname ACL\n");
2966 #ifdef CONFIG_VNC_SASL
2968 if (!(vs
->sasl
.acl
= qemu_acl_init("vnc.username"))) {
2969 fprintf(stderr
, "Failed to create username ACL\n");
2976 * Combinations we support here:
2978 * - no-auth (clear text, no auth)
2979 * - password (clear text, weak auth)
2980 * - sasl (encrypt, good auth *IF* using Kerberos via GSSAPI)
2981 * - tls (encrypt, weak anonymous creds, no auth)
2982 * - tls + password (encrypt, weak anonymous creds, weak auth)
2983 * - tls + sasl (encrypt, weak anonymous creds, good auth)
2984 * - tls + x509 (encrypt, good x509 creds, no auth)
2985 * - tls + x509 + password (encrypt, good x509 creds, weak auth)
2986 * - tls + x509 + sasl (encrypt, good x509 creds, good auth)
2988 * NB1. TLS is a stackable auth scheme.
2989 * NB2. the x509 schemes have option to validate a client cert dname
2992 #ifdef CONFIG_VNC_TLS
2994 vs
->auth
= VNC_AUTH_VENCRYPT
;
2996 VNC_DEBUG("Initializing VNC server with x509 password auth\n");
2997 vs
->subauth
= VNC_AUTH_VENCRYPT_X509VNC
;
2999 VNC_DEBUG("Initializing VNC server with TLS password auth\n");
3000 vs
->subauth
= VNC_AUTH_VENCRYPT_TLSVNC
;
3003 #endif /* CONFIG_VNC_TLS */
3004 VNC_DEBUG("Initializing VNC server with password auth\n");
3005 vs
->auth
= VNC_AUTH_VNC
;
3006 #ifdef CONFIG_VNC_TLS
3007 vs
->subauth
= VNC_AUTH_INVALID
;
3009 #endif /* CONFIG_VNC_TLS */
3010 #ifdef CONFIG_VNC_SASL
3012 #ifdef CONFIG_VNC_TLS
3014 vs
->auth
= VNC_AUTH_VENCRYPT
;
3016 VNC_DEBUG("Initializing VNC server with x509 SASL auth\n");
3017 vs
->subauth
= VNC_AUTH_VENCRYPT_X509SASL
;
3019 VNC_DEBUG("Initializing VNC server with TLS SASL auth\n");
3020 vs
->subauth
= VNC_AUTH_VENCRYPT_TLSSASL
;
3023 #endif /* CONFIG_VNC_TLS */
3024 VNC_DEBUG("Initializing VNC server with SASL auth\n");
3025 vs
->auth
= VNC_AUTH_SASL
;
3026 #ifdef CONFIG_VNC_TLS
3027 vs
->subauth
= VNC_AUTH_INVALID
;
3029 #endif /* CONFIG_VNC_TLS */
3030 #endif /* CONFIG_VNC_SASL */
3032 #ifdef CONFIG_VNC_TLS
3034 vs
->auth
= VNC_AUTH_VENCRYPT
;
3036 VNC_DEBUG("Initializing VNC server with x509 no auth\n");
3037 vs
->subauth
= VNC_AUTH_VENCRYPT_X509NONE
;
3039 VNC_DEBUG("Initializing VNC server with TLS no auth\n");
3040 vs
->subauth
= VNC_AUTH_VENCRYPT_TLSNONE
;
3044 VNC_DEBUG("Initializing VNC server with no auth\n");
3045 vs
->auth
= VNC_AUTH_NONE
;
3046 #ifdef CONFIG_VNC_TLS
3047 vs
->subauth
= VNC_AUTH_INVALID
;
3052 #ifdef CONFIG_VNC_SASL
3053 if ((saslErr
= sasl_server_init(NULL
, "qemu")) != SASL_OK
) {
3054 fprintf(stderr
, "Failed to initialize SASL auth %s",
3055 sasl_errstring(saslErr
, NULL
, NULL
));
3056 g_free(vs
->display
);
3061 vs
->lock_key_sync
= lock_key_sync
;
3064 /* connect to viewer */
3065 if (strncmp(display
, "unix:", 5) == 0)
3066 vs
->lsock
= unix_connect(display
+5);
3068 vs
->lsock
= inet_connect(display
, NULL
);
3069 if (-1 == vs
->lsock
) {
3070 g_free(vs
->display
);
3074 int csock
= vs
->lsock
;
3076 vnc_connect(vs
, csock
, 0);
3081 /* listen for connects */
3083 dpy
= g_malloc(256);
3084 if (strncmp(display
, "unix:", 5) == 0) {
3085 pstrcpy(dpy
, 256, "unix:");
3086 vs
->lsock
= unix_listen(display
+5, dpy
+5, 256-5);
3088 vs
->lsock
= inet_listen(display
, dpy
, 256,
3089 SOCK_STREAM
, 5900, NULL
);
3091 if (-1 == vs
->lsock
) {
3095 g_free(vs
->display
);
3099 return qemu_set_fd_handler2(vs
->lsock
, NULL
, vnc_listen_read
, NULL
, vs
);
3102 void vnc_display_add_client(DisplayState
*ds
, int csock
, int skipauth
)
3104 VncDisplay
*vs
= ds
? (VncDisplay
*)ds
->opaque
: vnc_display
;
3106 vnc_connect(vs
, csock
, skipauth
);