]> Git Repo - qemu.git/blame - ui/vnc.c
projects / qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
vnc: fix ctrl key in vnc terminal emulation
[qemu.git] / ui / vnc.c
CommitLineData
7d510b8c
FB		 1/*
2 * QEMU VNC display driver
5fafdf24 3 *
7d510b8c
FB		 4 * Copyright (C) 2006 Anthony Liguori <[email protected]>
5 * Copyright (C) 2006 Fabrice Bellard
19a490bf 6 * Copyright (C) 2009 Red Hat, Inc
5fafdf24 7 *
7d510b8c
FB		 8 * Permission is hereby granted, free of charge, to any person obtaining a copy
9 * of this software and associated documentation files (the "Software"), to deal
10 * in the Software without restriction, including without limitation the rights
11 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12 * copies of the Software, and to permit persons to whom the Software is
13 * furnished to do so, subject to the following conditions:
14 *
15 * The above copyright notice and this permission notice shall be included in
16 * all copies or substantial portions of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
21 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 * THE SOFTWARE.
25 */
26
19a490bf 27#include "vnc.h"
bd023f95 28#include "vnc-jobs.h"
87ecb68b 29#include "sysemu.h"
6ca957f0 30#include "qemu_socket.h"
87ecb68b 31#include "qemu-timer.h"
76655d6d 32#include "acl.h"
d96fd29c 33#include "qemu-objects.h"
2b54aa87 34#include "qmp-commands.h"
24236869 35
2430ffe4
SS		 36#define VNC_REFRESH_INTERVAL_BASE 30
37#define VNC_REFRESH_INTERVAL_INC 50
38#define VNC_REFRESH_INTERVAL_MAX 2000
999342a0
CC		 39static const struct timeval VNC_REFRESH_STATS = { 0, 500000 };
40static const struct timeval VNC_REFRESH_LOSSY = { 2, 0 };
24236869
FB		 41
42#include "vnc_keysym.h"
70848515
TS		 43#include "d3des.h"
44
753b4053 45static VncDisplay *vnc_display; /* needed for info vnc */
7d957bd8 46static DisplayChangeListener *dcl;
a9ce8590 47
d467b679
GH		 48static int vnc_cursor_define(VncState *vs);
49
1ff7df1a
AL		 50static char *addr_to_string(const char *format,
51 struct sockaddr_storage *sa,
52 socklen_t salen) {
53 char *addr;
54 char host[NI_MAXHOST];
55 char serv[NI_MAXSERV];
56 int err;
457772e6 57 size_t addrlen;
1ff7df1a
AL		 58
59 if ((err = getnameinfo((struct sockaddr *)sa, salen,
60 host, sizeof(host),
61 serv, sizeof(serv),
62 NI_NUMERICHOST | NI_NUMERICSERV)) != 0) {
63 VNC_DEBUG("Cannot resolve address %d: %s\n",
64 err, gai_strerror(err));
65 return NULL;
66 }
67
457772e6 68 /* Enough for the existing format + the 2 vars we're
f425c278 69 * substituting in. */
457772e6 70 addrlen = strlen(format) + strlen(host) + strlen(serv);
7267c094 71 addr = g_malloc(addrlen + 1);
457772e6
AL		 72 snprintf(addr, addrlen, format, host, serv);
73 addr[addrlen] = '\0';
1ff7df1a
AL		 74
75 return addr;
76}
77
2f9606b3
AL		 78
79char *vnc_socket_local_addr(const char *format, int fd) {
1ff7df1a
AL		 80 struct sockaddr_storage sa;
81 socklen_t salen;
82
83 salen = sizeof(sa);
84 if (getsockname(fd, (struct sockaddr*)&sa, &salen) < 0)
85 return NULL;
86
87 return addr_to_string(format, &sa, salen);
88}
89
2f9606b3 90char *vnc_socket_remote_addr(const char *format, int fd) {
1ff7df1a
AL		 91 struct sockaddr_storage sa;
92 socklen_t salen;
93
94 salen = sizeof(sa);
95 if (getpeername(fd, (struct sockaddr*)&sa, &salen) < 0)
96 return NULL;
97
98 return addr_to_string(format, &sa, salen);
99}
100
d96fd29c
LC		 101static int put_addr_qdict(QDict *qdict, struct sockaddr_storage *sa,
102 socklen_t salen)
103{
104 char host[NI_MAXHOST];
105 char serv[NI_MAXSERV];
106 int err;
107
108 if ((err = getnameinfo((struct sockaddr *)sa, salen,
109 host, sizeof(host),
110 serv, sizeof(serv),
111 NI_NUMERICHOST | NI_NUMERICSERV)) != 0) {
112 VNC_DEBUG("Cannot resolve address %d: %s\n",
113 err, gai_strerror(err));
114 return -1;
115 }
116
117 qdict_put(qdict, "host", qstring_from_str(host));
118 qdict_put(qdict, "service", qstring_from_str(serv));
dc0d4efc 119 qdict_put(qdict, "family",qstring_from_str(inet_strfamily(sa->ss_family)));
d96fd29c
LC		 120
121 return 0;
122}
123
a7789382 124static int vnc_server_addr_put(QDict *qdict, int fd)
d96fd29c
LC		 125{
126 struct sockaddr_storage sa;
127 socklen_t salen;
128
129 salen = sizeof(sa);
130 if (getsockname(fd, (struct sockaddr*)&sa, &salen) < 0) {
131 return -1;
132 }
133
134 return put_addr_qdict(qdict, &sa, salen);
135}
136
137static int vnc_qdict_remote_addr(QDict *qdict, int fd)
138{
139 struct sockaddr_storage sa;
140 socklen_t salen;
141
142 salen = sizeof(sa);
143 if (getpeername(fd, (struct sockaddr*)&sa, &salen) < 0) {
144 return -1;
145 }
146
147 return put_addr_qdict(qdict, &sa, salen);
148}
149
1ff7df1a
AL		 150static const char *vnc_auth_name(VncDisplay *vd) {
151 switch (vd->auth) {
152 case VNC_AUTH_INVALID:
153 return "invalid";
154 case VNC_AUTH_NONE:
155 return "none";
156 case VNC_AUTH_VNC:
157 return "vnc";
158 case VNC_AUTH_RA2:
159 return "ra2";
160 case VNC_AUTH_RA2NE:
161 return "ra2ne";
162 case VNC_AUTH_TIGHT:
163 return "tight";
164 case VNC_AUTH_ULTRA:
165 return "ultra";
166 case VNC_AUTH_TLS:
167 return "tls";
168 case VNC_AUTH_VENCRYPT:
169#ifdef CONFIG_VNC_TLS
170 switch (vd->subauth) {
171 case VNC_AUTH_VENCRYPT_PLAIN:
172 return "vencrypt+plain";
173 case VNC_AUTH_VENCRYPT_TLSNONE:
174 return "vencrypt+tls+none";
175 case VNC_AUTH_VENCRYPT_TLSVNC:
176 return "vencrypt+tls+vnc";
177 case VNC_AUTH_VENCRYPT_TLSPLAIN:
178 return "vencrypt+tls+plain";
179 case VNC_AUTH_VENCRYPT_X509NONE:
180 return "vencrypt+x509+none";
181 case VNC_AUTH_VENCRYPT_X509VNC:
182 return "vencrypt+x509+vnc";
183 case VNC_AUTH_VENCRYPT_X509PLAIN:
184 return "vencrypt+x509+plain";
28a76be8
AL		 185 case VNC_AUTH_VENCRYPT_TLSSASL:
186 return "vencrypt+tls+sasl";
187 case VNC_AUTH_VENCRYPT_X509SASL:
188 return "vencrypt+x509+sasl";
1ff7df1a
AL		 189 default:
190 return "vencrypt";
191 }
192#else
193 return "vencrypt";
194#endif
2f9606b3 195 case VNC_AUTH_SASL:
28a76be8 196 return "sasl";
1ff7df1a
AL		 197 }
198 return "unknown";
199}
200
a7789382
LC		 201static int vnc_server_info_put(QDict *qdict)
202{
203 if (vnc_server_addr_put(qdict, vnc_display->lsock) < 0) {
204 return -1;
205 }
206
207 qdict_put(qdict, "auth", qstring_from_str(vnc_auth_name(vnc_display)));
208 return 0;
209}
210
4a80dba3 211static void vnc_client_cache_auth(VncState *client)
1ff7df1a 212{
2ded6ad7 213#if defined(CONFIG_VNC_TLS) || defined(CONFIG_VNC_SASL)
d96fd29c 214 QDict *qdict;
2ded6ad7 215#endif
1ff7df1a 216
4a80dba3
LC		 217 if (!client->info) {
218 return;
d96fd29c 219 }
1263b7d6 220
2ded6ad7 221#if defined(CONFIG_VNC_TLS) || defined(CONFIG_VNC_SASL)
4a80dba3 222 qdict = qobject_to_qdict(client->info);
2ded6ad7 223#endif
4a80dba3 224
1263b7d6
AL		 225#ifdef CONFIG_VNC_TLS
226 if (client->tls.session &&
d96fd29c
LC		 227 client->tls.dname) {
228 qdict_put(qdict, "x509_dname", qstring_from_str(client->tls.dname));
229 }
1263b7d6
AL		 230#endif
231#ifdef CONFIG_VNC_SASL
232 if (client->sasl.conn &&
d96fd29c 233 client->sasl.username) {
76825067
LC		 234 qdict_put(qdict, "sasl_username",
235 qstring_from_str(client->sasl.username));
d96fd29c 236 }
1263b7d6 237#endif
4a80dba3 238}
d96fd29c 239
4a80dba3
LC		 240static void vnc_client_cache_addr(VncState *client)
241{
242 QDict *qdict;
243
244 qdict = qdict_new();
245 if (vnc_qdict_remote_addr(qdict, client->csock) < 0) {
246 QDECREF(qdict);
247 /* XXX: how to report the error? */
248 return;
249 }
250
251 client->info = QOBJECT(qdict);
1ff7df1a
AL		 252}
253
586153d9
LC		 254static void vnc_qmp_event(VncState *vs, MonitorEvent event)
255{
256 QDict *server;
257 QObject *data;
258
259 if (!vs->info) {
260 return;
261 }
262
263 server = qdict_new();
264 if (vnc_server_info_put(server) < 0) {
265 QDECREF(server);
266 return;
267 }
268
269 data = qobject_from_jsonf("{ 'client': %p, 'server': %p }",
270 vs->info, QOBJECT(server));
271
272 monitor_protocol_event(event, data);
273
274 qobject_incref(vs->info);
275 qobject_decref(data);
276}
277
2b54aa87 278static VncClientInfo *qmp_query_vnc_client(const VncState *client)
a9ce8590 279{
2b54aa87
LC		 280 struct sockaddr_storage sa;
281 socklen_t salen = sizeof(sa);
282 char host[NI_MAXHOST];
283 char serv[NI_MAXSERV];
284 VncClientInfo *info;
285
286 if (getpeername(client->csock, (struct sockaddr *)&sa, &salen) < 0) {
287 return NULL;
288 }
289
290 if (getnameinfo((struct sockaddr *)&sa, salen,
291 host, sizeof(host),
292 serv, sizeof(serv),
293 NI_NUMERICHOST | NI_NUMERICSERV) < 0) {
294 return NULL;
295 }
d96fd29c 296
2b54aa87
LC		 297 info = g_malloc0(sizeof(*info));
298 info->host = g_strdup(host);
299 info->service = g_strdup(serv);
300 info->family = g_strdup(inet_strfamily(sa.ss_family));
d96fd29c
LC		 301
302#ifdef CONFIG_VNC_TLS
2b54aa87
LC		 303 if (client->tls.session && client->tls.dname) {
304 info->has_x509_dname = true;
305 info->x509_dname = g_strdup(client->tls.dname);
306 }
d96fd29c
LC		 307#endif
308#ifdef CONFIG_VNC_SASL
2b54aa87
LC		 309 if (client->sasl.conn && client->sasl.username) {
310 info->has_sasl_username = true;
311 info->sasl_username = g_strdup(client->sasl.username);
d96fd29c 312 }
2b54aa87 313#endif
1ff7df1a 314
2b54aa87 315 return info;
d96fd29c 316}
1ff7df1a 317
2b54aa87 318VncInfo *qmp_query_vnc(Error **errp)
d96fd29c 319{
2b54aa87
LC		 320 VncInfo *info = g_malloc0(sizeof(*info));
321
d96fd29c 322 if (vnc_display == NULL || vnc_display->display == NULL) {
2b54aa87 323 info->enabled = false;
d96fd29c 324 } else {
2b54aa87
LC		 325 VncClientInfoList *cur_item = NULL;
326 struct sockaddr_storage sa;
327 socklen_t salen = sizeof(sa);
328 char host[NI_MAXHOST];
329 char serv[NI_MAXSERV];
41b4bef6 330 VncState *client;
1ff7df1a 331
2b54aa87
LC		 332 info->enabled = true;
333
334 /* for compatibility with the original command */
335 info->has_clients = true;
336
41b4bef6 337 QTAILQ_FOREACH(client, &vnc_display->clients, next) {
2b54aa87
LC		 338 VncClientInfoList *cinfo = g_malloc0(sizeof(*info));
339 cinfo->value = qmp_query_vnc_client(client);
340
341 /* XXX: waiting for the qapi to support GSList */
342 if (!cur_item) {
343 info->clients = cur_item = cinfo;
344 } else {
345 cur_item->next = cinfo;
346 cur_item = cinfo;
1ff7df1a 347 }
d96fd29c
LC		 348 }
349
2b54aa87
LC		 350 if (getsockname(vnc_display->lsock, (struct sockaddr *)&sa,
351 &salen) == -1) {
352 error_set(errp, QERR_UNDEFINED_ERROR);
353 goto out_error;
354 }
d96fd29c 355
2b54aa87
LC		 356 if (getnameinfo((struct sockaddr *)&sa, salen,
357 host, sizeof(host),
358 serv, sizeof(serv),
359 NI_NUMERICHOST | NI_NUMERICSERV) < 0) {
360 error_set(errp, QERR_UNDEFINED_ERROR);
361 goto out_error;
1ff7df1a 362 }
2b54aa87
LC		 363
364 info->has_host = true;
365 info->host = g_strdup(host);
366
367 info->has_service = true;
368 info->service = g_strdup(serv);
369
370 info->has_family = true;
371 info->family = g_strdup(inet_strfamily(sa.ss_family));
372
373 info->has_auth = true;
374 info->auth = g_strdup(vnc_auth_name(vnc_display));
a9ce8590 375 }
2b54aa87
LC		 376
377 return info;
378
379out_error:
380 qapi_free_VncInfo(info);
381 return NULL;
a9ce8590
FB		 382}
383
24236869
FB		 384/* TODO
385 1) Get the queue working for IO.
386 2) there is some weirdness when using the -S option (the screen is grey
387 and not totally invalidated
388 3) resolutions > 1024
389*/
390
2430ffe4 391static int vnc_update_client(VncState *vs, int has_dirty);
bd023f95 392static int vnc_update_client_sync(VncState *vs, int has_dirty);
198a0039
GH		 393static void vnc_disconnect_start(VncState *vs);
394static void vnc_disconnect_finish(VncState *vs);
703bc68f
SS		 395static void vnc_init_timer(VncDisplay *vd);
396static void vnc_remove_timer(VncDisplay *vd);
24236869 397
753b4053 398static void vnc_colordepth(VncState *vs);
1fc62412
SS		 399static void framebuffer_update_request(VncState *vs, int incremental,
400 int x_position, int y_position,
401 int w, int h);
402static void vnc_refresh(void *opaque);
403static int vnc_refresh_server_surface(VncDisplay *vd);
7eac3a87 404
1fc62412 405static void vnc_dpy_update(DisplayState *ds, int x, int y, int w, int h)
24236869 406{
24236869 407 int i;
1fc62412
SS		 408 VncDisplay *vd = ds->opaque;
409 struct VncSurface *s = &vd->guest;
24236869
FB		 410
411 h += y;
412
0486e8a7
AZ		 413 /* round x down to ensure the loop only spans one 16-pixel block per,
414 iteration. otherwise, if (x % 16) != 0, the last iteration may span
415 two 16-pixel blocks but we only mark the first as dirty
416 */
417 w += (x % 16);
418 x -= (x % 16);
419
6baebed7
AL		 420 x = MIN(x, s->ds->width);
421 y = MIN(y, s->ds->height);
422 w = MIN(x + w, s->ds->width) - x;
423 h = MIN(h, s->ds->height);
788abf8e 424
24236869 425 for (; y < h; y++)
28a76be8 426 for (i = 0; i < w; i += 16)
bc2429b9 427 set_bit((x + i) / 16, s->dirty[y]);
24236869
FB		 428}
429
70a4568f
CC		 430void vnc_framebuffer_update(VncState *vs, int x, int y, int w, int h,
431 int32_t encoding)
24236869
FB		 432{
433 vnc_write_u16(vs, x);
434 vnc_write_u16(vs, y);
435 vnc_write_u16(vs, w);
436 vnc_write_u16(vs, h);
437
438 vnc_write_s32(vs, encoding);
439}
440
2f9606b3 441void buffer_reserve(Buffer *buffer, size_t len)
89064286
AL		 442{
443 if ((buffer->capacity - buffer->offset) < len) {
28a76be8 444 buffer->capacity += (len + 1024);
7267c094 445 buffer->buffer = g_realloc(buffer->buffer, buffer->capacity);
28a76be8
AL		 446 if (buffer->buffer == NULL) {
447 fprintf(stderr, "vnc: out of memory\n");
448 exit(1);
449 }
89064286
AL		 450 }
451}
452
2f9606b3 453int buffer_empty(Buffer *buffer)
89064286
AL		 454{
455 return buffer->offset == 0;
456}
457
2f9606b3 458uint8_t *buffer_end(Buffer *buffer)
89064286
AL		 459{
460 return buffer->buffer + buffer->offset;
461}
462
2f9606b3 463void buffer_reset(Buffer *buffer)
89064286 464{
28a76be8 465 buffer->offset = 0;
89064286
AL		 466}
467
5d418e3b
CC		 468void buffer_free(Buffer *buffer)
469{
7267c094 470 g_free(buffer->buffer);
5d418e3b
CC		 471 buffer->offset = 0;
472 buffer->capacity = 0;
473 buffer->buffer = NULL;
474}
475
2f9606b3 476void buffer_append(Buffer *buffer, const void *data, size_t len)
89064286
AL		 477{
478 memcpy(buffer->buffer + buffer->offset, data, len);
479 buffer->offset += len;
480}
481
621aaeb9
GH		 482static void vnc_desktop_resize(VncState *vs)
483{
484 DisplayState *ds = vs->ds;
485
486 if (vs->csock == -1 || !vnc_has_feature(vs, VNC_FEATURE_RESIZE)) {
487 return;
488 }
1d4b638a
GH		 489 if (vs->client_width == ds_get_width(ds) &&
490 vs->client_height == ds_get_height(ds)) {
491 return;
492 }
5862d195
GH		 493 vs->client_width = ds_get_width(ds);
494 vs->client_height = ds_get_height(ds);
bd023f95 495 vnc_lock_output(vs);
621aaeb9
GH		 496 vnc_write_u8(vs, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE);
497 vnc_write_u8(vs, 0);
498 vnc_write_u16(vs, 1); /* number of rects */
5862d195 499 vnc_framebuffer_update(vs, 0, 0, vs->client_width, vs->client_height,
621aaeb9 500 VNC_ENCODING_DESKTOPRESIZE);
bd023f95 501 vnc_unlock_output(vs);
621aaeb9
GH		 502 vnc_flush(vs);
503}
504
bd023f95
CC		 505#ifdef CONFIG_VNC_THREAD
506static void vnc_abort_display_jobs(VncDisplay *vd)
507{
508 VncState *vs;
509
510 QTAILQ_FOREACH(vs, &vd->clients, next) {
511 vnc_lock_output(vs);
512 vs->abort = true;
513 vnc_unlock_output(vs);
514 }
515 QTAILQ_FOREACH(vs, &vd->clients, next) {
516 vnc_jobs_join(vs);
517 }
518 QTAILQ_FOREACH(vs, &vd->clients, next) {
519 vnc_lock_output(vs);
520 vs->abort = false;
521 vnc_unlock_output(vs);
522 }
523}
524#else
525static void vnc_abort_display_jobs(VncDisplay *vd)
526{
527}
528#endif
529
1fc62412 530static void vnc_dpy_resize(DisplayState *ds)
24236869 531{
1fc62412 532 VncDisplay *vd = ds->opaque;
41b4bef6 533 VncState *vs;
1fc62412 534
bd023f95
CC		 535 vnc_abort_display_jobs(vd);
536
1fc62412
SS		 537 /* server surface */
538 if (!vd->server)
7267c094 539 vd->server = g_malloc0(sizeof(*vd->server));
1fc62412 540 if (vd->server->data)
7267c094 541 g_free(vd->server->data);
1fc62412 542 *(vd->server) = *(ds->surface);
7267c094 543 vd->server->data = g_malloc0(vd->server->linesize *
1fc62412 544 vd->server->height);
24236869 545
6baebed7 546 /* guest surface */
1fc62412 547 if (!vd->guest.ds)
7267c094 548 vd->guest.ds = g_malloc0(sizeof(*vd->guest.ds));
1fc62412 549 if (ds_get_bytes_per_pixel(ds) != vd->guest.ds->pf.bytes_per_pixel)
a528b80c 550 console_color_init(ds);
1fc62412
SS		 551 *(vd->guest.ds) = *(ds->surface);
552 memset(vd->guest.dirty, 0xFF, sizeof(vd->guest.dirty));
24236869 553
41b4bef6 554 QTAILQ_FOREACH(vs, &vd->clients, next) {
1fc62412 555 vnc_colordepth(vs);
1d4b638a 556 vnc_desktop_resize(vs);
d467b679
GH		 557 if (vs->vd->cursor) {
558 vnc_cursor_define(vs);
559 }
1fc62412 560 memset(vs->dirty, 0xFF, sizeof(vs->dirty));
753b4053
AL		 561 }
562}
563
3512779a 564/* fastest code */
d467b679
GH		 565static void vnc_write_pixels_copy(VncState *vs, struct PixelFormat *pf,
566 void *pixels, int size)
3512779a
FB		 567{
568 vnc_write(vs, pixels, size);
569}
570
571/* slowest but generic code. */
70a4568f 572void vnc_convert_pixel(VncState *vs, uint8_t *buf, uint32_t v)
3512779a 573{
7eac3a87 574 uint8_t r, g, b;
1fc62412
SS		 575 VncDisplay *vd = vs->vd;
576
577 r = ((((v & vd->server->pf.rmask) >> vd->server->pf.rshift) << vs->clientds.pf.rbits) >>
578 vd->server->pf.rbits);
579 g = ((((v & vd->server->pf.gmask) >> vd->server->pf.gshift) << vs->clientds.pf.gbits) >>
580 vd->server->pf.gbits);
581 b = ((((v & vd->server->pf.bmask) >> vd->server->pf.bshift) << vs->clientds.pf.bbits) >>
582 vd->server->pf.bbits);
6cec5487
AL		 583 v = (r << vs->clientds.pf.rshift) |
584 (g << vs->clientds.pf.gshift) |
585 (b << vs->clientds.pf.bshift);
586 switch(vs->clientds.pf.bytes_per_pixel) {
3512779a
FB		 587 case 1:
588 buf[0] = v;
589 break;
590 case 2:
6cec5487 591 if (vs->clientds.flags & QEMU_BIG_ENDIAN_FLAG) {
3512779a
FB		 592 buf[0] = v >> 8;
593 buf[1] = v;
594 } else {
595 buf[1] = v >> 8;
596 buf[0] = v;
597 }
598 break;
599 default:
600 case 4:
6cec5487 601 if (vs->clientds.flags & QEMU_BIG_ENDIAN_FLAG) {
3512779a
FB		 602 buf[0] = v >> 24;
603 buf[1] = v >> 16;
604 buf[2] = v >> 8;
605 buf[3] = v;
606 } else {
607 buf[3] = v >> 24;
608 buf[2] = v >> 16;
609 buf[1] = v >> 8;
610 buf[0] = v;
611 }
612 break;
613 }
614}
615
d467b679
GH		 616static void vnc_write_pixels_generic(VncState *vs, struct PixelFormat *pf,
617 void *pixels1, int size)
3512779a 618{
3512779a 619 uint8_t buf[4];
3512779a 620
d467b679 621 if (pf->bytes_per_pixel == 4) {
7eac3a87
AL		 622 uint32_t *pixels = pixels1;
623 int n, i;
624 n = size >> 2;
625 for(i = 0; i < n; i++) {
626 vnc_convert_pixel(vs, buf, pixels[i]);
6cec5487 627 vnc_write(vs, buf, vs->clientds.pf.bytes_per_pixel);
7eac3a87 628 }
d467b679 629 } else if (pf->bytes_per_pixel == 2) {
7eac3a87
AL		 630 uint16_t *pixels = pixels1;
631 int n, i;
632 n = size >> 1;
633 for(i = 0; i < n; i++) {
634 vnc_convert_pixel(vs, buf, pixels[i]);
6cec5487 635 vnc_write(vs, buf, vs->clientds.pf.bytes_per_pixel);
7eac3a87 636 }
d467b679 637 } else if (pf->bytes_per_pixel == 1) {
7eac3a87
AL		 638 uint8_t *pixels = pixels1;
639 int n, i;
640 n = size;
641 for(i = 0; i < n; i++) {
642 vnc_convert_pixel(vs, buf, pixels[i]);
6cec5487 643 vnc_write(vs, buf, vs->clientds.pf.bytes_per_pixel);
7eac3a87
AL		 644 }
645 } else {
646 fprintf(stderr, "vnc_write_pixels_generic: VncState color depth not supported\n");
3512779a
FB		 647 }
648}
649
a885211e 650int vnc_raw_send_framebuffer_update(VncState *vs, int x, int y, int w, int h)
24236869
FB		 651{
652 int i;
60fe76f3 653 uint8_t *row;
1fc62412 654 VncDisplay *vd = vs->vd;
24236869 655
1fc62412 656 row = vd->server->data + y * ds_get_linesize(vs->ds) + x * ds_get_bytes_per_pixel(vs->ds);
24236869 657 for (i = 0; i < h; i++) {
d467b679 658 vs->write_pixels(vs, &vd->server->pf, row, w * ds_get_bytes_per_pixel(vs->ds));
28a76be8 659 row += ds_get_linesize(vs->ds);
24236869 660 }
a885211e 661 return 1;
24236869
FB		 662}
663
bd023f95 664int vnc_send_framebuffer_update(VncState *vs, int x, int y, int w, int h)
24236869 665{
a885211e
CC		 666 int n = 0;
667
fb437313 668 switch(vs->vnc_encoding) {
28a76be8 669 case VNC_ENCODING_ZLIB:
a885211e 670 n = vnc_zlib_send_framebuffer_update(vs, x, y, w, h);
28a76be8
AL		 671 break;
672 case VNC_ENCODING_HEXTILE:
673 vnc_framebuffer_update(vs, x, y, w, h, VNC_ENCODING_HEXTILE);
a885211e 674 n = vnc_hextile_send_framebuffer_update(vs, x, y, w, h);
28a76be8 675 break;
380282b0
CC		 676 case VNC_ENCODING_TIGHT:
677 n = vnc_tight_send_framebuffer_update(vs, x, y, w, h);
678 break;
efe556ad
CC		 679 case VNC_ENCODING_TIGHT_PNG:
680 n = vnc_tight_png_send_framebuffer_update(vs, x, y, w, h);
681 break;
148954fa
CC		 682 case VNC_ENCODING_ZRLE:
683 n = vnc_zrle_send_framebuffer_update(vs, x, y, w, h);
684 break;
685 case VNC_ENCODING_ZYWRLE:
686 n = vnc_zywrle_send_framebuffer_update(vs, x, y, w, h);
687 break;
28a76be8
AL		 688 default:
689 vnc_framebuffer_update(vs, x, y, w, h, VNC_ENCODING_RAW);
a885211e 690 n = vnc_raw_send_framebuffer_update(vs, x, y, w, h);
28a76be8 691 break;
fb437313 692 }
a885211e 693 return n;
24236869
FB		 694}
695
753b4053 696static void vnc_copy(VncState *vs, int src_x, int src_y, int dst_x, int dst_y, int w, int h)
24236869 697{
3e28c9ad 698 /* send bitblit op to the vnc client */
bd023f95 699 vnc_lock_output(vs);
46a183da 700 vnc_write_u8(vs, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE);
24236869
FB		 701 vnc_write_u8(vs, 0);
702 vnc_write_u16(vs, 1); /* number of rects */
29fa4ed9 703 vnc_framebuffer_update(vs, dst_x, dst_y, w, h, VNC_ENCODING_COPYRECT);
24236869
FB		 704 vnc_write_u16(vs, src_x);
705 vnc_write_u16(vs, src_y);
bd023f95 706 vnc_unlock_output(vs);
24236869
FB		 707 vnc_flush(vs);
708}
709
753b4053
AL		 710static void vnc_dpy_copy(DisplayState *ds, int src_x, int src_y, int dst_x, int dst_y, int w, int h)
711{
712 VncDisplay *vd = ds->opaque;
198a0039 713 VncState *vs, *vn;
1fc62412
SS		 714 uint8_t *src_row;
715 uint8_t *dst_row;
716 int i,x,y,pitch,depth,inc,w_lim,s;
717 int cmp_bytes;
198a0039 718
1fc62412 719 vnc_refresh_server_surface(vd);
41b4bef6 720 QTAILQ_FOREACH_SAFE(vs, &vd->clients, next, vn) {
198a0039
GH		 721 if (vnc_has_feature(vs, VNC_FEATURE_COPYRECT)) {
722 vs->force_update = 1;
bd023f95 723 vnc_update_client_sync(vs, 1);
198a0039
GH		 724 /* vs might be free()ed here */
725 }
726 }
727
1fc62412
SS		 728 /* do bitblit op on the local surface too */
729 pitch = ds_get_linesize(vd->ds);
730 depth = ds_get_bytes_per_pixel(vd->ds);
731 src_row = vd->server->data + pitch * src_y + depth * src_x;
732 dst_row = vd->server->data + pitch * dst_y + depth * dst_x;
733 y = dst_y;
734 inc = 1;
735 if (dst_y > src_y) {
736 /* copy backwards */
737 src_row += pitch * (h-1);
738 dst_row += pitch * (h-1);
739 pitch = -pitch;
740 y = dst_y + h - 1;
741 inc = -1;
742 }
743 w_lim = w - (16 - (dst_x % 16));
744 if (w_lim < 0)
745 w_lim = w;
746 else
747 w_lim = w - (w_lim % 16);
748 for (i = 0; i < h; i++) {
749 for (x = 0; x <= w_lim;
750 x += s, src_row += cmp_bytes, dst_row += cmp_bytes) {
751 if (x == w_lim) {
752 if ((s = w - w_lim) == 0)
753 break;
754 } else if (!x) {
755 s = (16 - (dst_x % 16));
756 s = MIN(s, w_lim);
757 } else {
758 s = 16;
759 }
760 cmp_bytes = s * depth;
761 if (memcmp(src_row, dst_row, cmp_bytes) == 0)
762 continue;
763 memmove(dst_row, src_row, cmp_bytes);
41b4bef6
AS		 764 QTAILQ_FOREACH(vs, &vd->clients, next) {
765 if (!vnc_has_feature(vs, VNC_FEATURE_COPYRECT)) {
bc2429b9 766 set_bit(((x + dst_x) / 16), vs->dirty[y]);
41b4bef6 767 }
1fc62412
SS		 768 }
769 }
770 src_row += pitch - w * depth;
771 dst_row += pitch - w * depth;
772 y += inc;
773 }
774
41b4bef6
AS		 775 QTAILQ_FOREACH(vs, &vd->clients, next) {
776 if (vnc_has_feature(vs, VNC_FEATURE_COPYRECT)) {
753b4053 777 vnc_copy(vs, src_x, src_y, dst_x, dst_y, w, h);
41b4bef6 778 }
753b4053
AL		 779 }
780}
781
d467b679
GH		 782static void vnc_mouse_set(int x, int y, int visible)
783{
784 /* can we ask the client(s) to move the pointer ??? */
785}
786
787static int vnc_cursor_define(VncState *vs)
788{
789 QEMUCursor *c = vs->vd->cursor;
790 PixelFormat pf = qemu_default_pixelformat(32);
791 int isize;
792
793 if (vnc_has_feature(vs, VNC_FEATURE_RICH_CURSOR)) {
d01f9595 794 vnc_lock_output(vs);
d467b679
GH		 795 vnc_write_u8(vs, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE);
796 vnc_write_u8(vs, 0); /* padding */
797 vnc_write_u16(vs, 1); /* # of rects */
798 vnc_framebuffer_update(vs, c->hot_x, c->hot_y, c->width, c->height,
799 VNC_ENCODING_RICH_CURSOR);
800 isize = c->width * c->height * vs->clientds.pf.bytes_per_pixel;
801 vnc_write_pixels_generic(vs, &pf, c->data, isize);
802 vnc_write(vs, vs->vd->cursor_mask, vs->vd->cursor_msize);
d01f9595 803 vnc_unlock_output(vs);
d467b679
GH		 804 return 0;
805 }
806 return -1;
807}
808
809static void vnc_dpy_cursor_define(QEMUCursor *c)
810{
811 VncDisplay *vd = vnc_display;
812 VncState *vs;
813
814 cursor_put(vd->cursor);
7267c094 815 g_free(vd->cursor_mask);
d467b679
GH		 816
817 vd->cursor = c;
818 cursor_get(vd->cursor);
819 vd->cursor_msize = cursor_get_mono_bpl(c) * c->height;
7267c094 820 vd->cursor_mask = g_malloc0(vd->cursor_msize);
d467b679
GH		 821 cursor_get_mono_mask(c, 0, vd->cursor_mask);
822
823 QTAILQ_FOREACH(vs, &vd->clients, next) {
824 vnc_cursor_define(vs);
825 }
826}
827
1fc62412 828static int find_and_clear_dirty_height(struct VncState *vs,
6c71a539 829 int y, int last_x, int x, int height)
24236869
FB		 830{
831 int h;
832
6c71a539 833 for (h = 1; h < (height - y); h++) {
28a76be8 834 int tmp_x;
bc2429b9 835 if (!test_bit(last_x, vs->dirty[y + h])) {
28a76be8 836 break;
bc2429b9
CC		 837 }
838 for (tmp_x = last_x; tmp_x < x; tmp_x++) {
839 clear_bit(tmp_x, vs->dirty[y + h]);
840 }
24236869
FB		 841 }
842
843 return h;
844}
845
bd023f95
CC		 846#ifdef CONFIG_VNC_THREAD
847static int vnc_update_client_sync(VncState *vs, int has_dirty)
848{
849 int ret = vnc_update_client(vs, has_dirty);
850 vnc_jobs_join(vs);
851 return ret;
852}
853#else
854static int vnc_update_client_sync(VncState *vs, int has_dirty)
855{
856 return vnc_update_client(vs, has_dirty);
857}
858#endif
859
2430ffe4 860static int vnc_update_client(VncState *vs, int has_dirty)
24236869 861{
24236869 862 if (vs->need_update && vs->csock != -1) {
1fc62412 863 VncDisplay *vd = vs->vd;
bd023f95 864 VncJob *job;
28a76be8 865 int y;
847ce6a1 866 int width, height;
bd023f95
CC		 867 int n = 0;
868
24236869 869
703bc68f 870 if (vs->output.offset && !vs->audio_cap && !vs->force_update)
c522d0e2 871 /* kernel send buffers are full -> drop frames to throttle */
2430ffe4 872 return 0;
a0ecfb73 873
703bc68f 874 if (!has_dirty && !vs->audio_cap && !vs->force_update)
2430ffe4 875 return 0;
28a76be8 876
6baebed7
AL		 877 /*
878 * Send screen updates to the vnc client using the server
879 * surface and server dirty map. guest surface updates
880 * happening in parallel don't disturb us, the next pass will
881 * send them to the client.
882 */
bd023f95 883 job = vnc_job_new(vs);
28a76be8 884
847ce6a1
GH		 885 width = MIN(vd->server->width, vs->client_width);
886 height = MIN(vd->server->height, vs->client_height);
887
888 for (y = 0; y < height; y++) {
28a76be8
AL		 889 int x;
890 int last_x = -1;
847ce6a1 891 for (x = 0; x < width / 16; x++) {
bc2429b9 892 if (test_and_clear_bit(x, vs->dirty[y])) {
28a76be8
AL		 893 if (last_x == -1) {
894 last_x = x;
895 }
28a76be8
AL		 896 } else {
897 if (last_x != -1) {
6c71a539
CC		 898 int h = find_and_clear_dirty_height(vs, y, last_x, x,
899 height);
bd023f95
CC		 900
901 n += vnc_job_add_rect(job, last_x * 16, y,
902 (x - last_x) * 16, h);
28a76be8
AL		 903 }
904 last_x = -1;
905 }
906 }
907 if (last_x != -1) {
6c71a539 908 int h = find_and_clear_dirty_height(vs, y, last_x, x, height);
bd023f95
CC		 909 n += vnc_job_add_rect(job, last_x * 16, y,
910 (x - last_x) * 16, h);
28a76be8
AL		 911 }
912 }
bd023f95
CC		 913
914 vnc_job_push(job);
c522d0e2 915 vs->force_update = 0;
bd023f95 916 return n;
24236869 917 }
24236869 918
703bc68f 919 if (vs->csock == -1)
198a0039 920 vnc_disconnect_finish(vs);
2430ffe4
SS		 921
922 return 0;
24236869
FB		 923}
924
429a8ed3 925/* audio */
926static void audio_capture_notify(void *opaque, audcnotification_e cmd)
927{
928 VncState *vs = opaque;
929
930 switch (cmd) {
931 case AUD_CNOTIFY_DISABLE:
bd023f95 932 vnc_lock_output(vs);
46a183da
DB		 933 vnc_write_u8(vs, VNC_MSG_SERVER_QEMU);
934 vnc_write_u8(vs, VNC_MSG_SERVER_QEMU_AUDIO);
935 vnc_write_u16(vs, VNC_MSG_SERVER_QEMU_AUDIO_END);
bd023f95 936 vnc_unlock_output(vs);
429a8ed3 937 vnc_flush(vs);
938 break;
939
940 case AUD_CNOTIFY_ENABLE:
bd023f95 941 vnc_lock_output(vs);
46a183da
DB		 942 vnc_write_u8(vs, VNC_MSG_SERVER_QEMU);
943 vnc_write_u8(vs, VNC_MSG_SERVER_QEMU_AUDIO);
944 vnc_write_u16(vs, VNC_MSG_SERVER_QEMU_AUDIO_BEGIN);
bd023f95 945 vnc_unlock_output(vs);
429a8ed3 946 vnc_flush(vs);
947 break;
948 }
949}
950
951static void audio_capture_destroy(void *opaque)
952{
953}
954
955static void audio_capture(void *opaque, void *buf, int size)
956{
957 VncState *vs = opaque;
958
bd023f95 959 vnc_lock_output(vs);
46a183da
DB		 960 vnc_write_u8(vs, VNC_MSG_SERVER_QEMU);
961 vnc_write_u8(vs, VNC_MSG_SERVER_QEMU_AUDIO);
962 vnc_write_u16(vs, VNC_MSG_SERVER_QEMU_AUDIO_DATA);
429a8ed3 963 vnc_write_u32(vs, size);
964 vnc_write(vs, buf, size);
bd023f95 965 vnc_unlock_output(vs);
429a8ed3 966 vnc_flush(vs);
967}
968
969static void audio_add(VncState *vs)
970{
971 struct audio_capture_ops ops;
972
973 if (vs->audio_cap) {
8631b608 974 monitor_printf(default_mon, "audio already running\n");
429a8ed3 975 return;
976 }
977
978 ops.notify = audio_capture_notify;
979 ops.destroy = audio_capture_destroy;
980 ops.capture = audio_capture;
981
1a7dafce 982 vs->audio_cap = AUD_add_capture(&vs->as, &ops, vs);
429a8ed3 983 if (!vs->audio_cap) {
8631b608 984 monitor_printf(default_mon, "Failed to add audio capture\n");
429a8ed3 985 }
986}
987
988static void audio_del(VncState *vs)
989{
990 if (vs->audio_cap) {
991 AUD_del_capture(vs->audio_cap, vs);
992 vs->audio_cap = NULL;
993 }
994}
995
198a0039
GH		 996static void vnc_disconnect_start(VncState *vs)
997{
998 if (vs->csock == -1)
999 return;
1000 qemu_set_fd_handler2(vs->csock, NULL, NULL, NULL, NULL);
1001 closesocket(vs->csock);
1002 vs->csock = -1;
1003}
1004
1005static void vnc_disconnect_finish(VncState *vs)
1006{
7d964c9d
CC		 1007 int i;
1008
bd023f95
CC		 1009 vnc_jobs_join(vs); /* Wait encoding jobs */
1010
1011 vnc_lock_output(vs);
0d72f3d3
LC		 1012 vnc_qmp_event(vs, QEVENT_VNC_DISCONNECTED);
1013
5d418e3b
CC		 1014 buffer_free(&vs->input);
1015 buffer_free(&vs->output);
4a80dba3
LC		 1016
1017 qobject_decref(vs->info);
1018
161c4f20 1019 vnc_zlib_clear(vs);
380282b0 1020 vnc_tight_clear(vs);
148954fa 1021 vnc_zrle_clear(vs);
161c4f20 1022
198a0039
GH		 1023#ifdef CONFIG_VNC_TLS
1024 vnc_tls_client_cleanup(vs);
1025#endif /* CONFIG_VNC_TLS */
1026#ifdef CONFIG_VNC_SASL
1027 vnc_sasl_client_cleanup(vs);
1028#endif /* CONFIG_VNC_SASL */
1029 audio_del(vs);
1030
41b4bef6
AS		 1031 QTAILQ_REMOVE(&vs->vd->clients, vs, next);
1032
1033 if (QTAILQ_EMPTY(&vs->vd->clients)) {
198a0039 1034 dcl->idle = 1;
41b4bef6 1035 }
198a0039 1036
37c34d9d 1037 qemu_remove_mouse_mode_change_notifier(&vs->mouse_mode_notifier);
703bc68f 1038 vnc_remove_timer(vs->vd);
3a0558b5
GH		 1039 if (vs->vd->lock_key_sync)
1040 qemu_remove_led_event_handler(vs->led);
bd023f95
CC		 1041 vnc_unlock_output(vs);
1042
1043#ifdef CONFIG_VNC_THREAD
1044 qemu_mutex_destroy(&vs->output_mutex);
1045#endif
7d964c9d 1046 for (i = 0; i < VNC_STAT_ROWS; ++i) {
7267c094 1047 g_free(vs->lossy_rect[i]);
7d964c9d 1048 }
7267c094
AL		 1049 g_free(vs->lossy_rect);
1050 g_free(vs);
198a0039 1051}
2f9606b3
AL		 1052
1053int vnc_client_io_error(VncState *vs, int ret, int last_errno)
24236869
FB		 1054{
1055 if (ret == 0 || ret == -1) {
ea01e5fd
AZ		 1056 if (ret == -1) {
1057 switch (last_errno) {
1058 case EINTR:
1059 case EAGAIN:
1060#ifdef _WIN32
1061 case WSAEWOULDBLOCK:
1062#endif
1063 return 0;
1064 default:
1065 break;
1066 }
1067 }
24236869 1068
198a0039
GH		 1069 VNC_DEBUG("Closing down client sock: ret %d, errno %d\n",
1070 ret, ret < 0 ? last_errno : 0);
1071 vnc_disconnect_start(vs);
6baebed7 1072
28a76be8 1073 return 0;
24236869
FB		 1074 }
1075 return ret;
1076}
1077
5fb6c7a8
AL		 1078
1079void vnc_client_error(VncState *vs)
24236869 1080{
198a0039
GH		 1081 VNC_DEBUG("Closing down client sock: protocol error\n");
1082 vnc_disconnect_start(vs);
24236869
FB		 1083}
1084
2f9606b3
AL		 1085
1086/*
1087 * Called to write a chunk of data to the client socket. The data may
1088 * be the raw data, or may have already been encoded by SASL.
1089 * The data will be written either straight onto the socket, or
1090 * written via the GNUTLS wrappers, if TLS/SSL encryption is enabled
1091 *
1092 * NB, it is theoretically possible to have 2 layers of encryption,
1093 * both SASL, and this TLS layer. It is highly unlikely in practice
1094 * though, since SASL encryption will typically be a no-op if TLS
1095 * is active
1096 *
1097 * Returns the number of bytes written, which may be less than
1098 * the requested 'datalen' if the socket would block. Returns
1099 * -1 on error, and disconnects the client socket.
1100 */
1101long vnc_client_write_buf(VncState *vs, const uint8_t *data, size_t datalen)
24236869 1102{
ceb5caaf 1103 long ret;
eb38c52c 1104#ifdef CONFIG_VNC_TLS
5fb6c7a8 1105 if (vs->tls.session) {
28a76be8
AL		 1106 ret = gnutls_write(vs->tls.session, data, datalen);
1107 if (ret < 0) {
1108 if (ret == GNUTLS_E_AGAIN)
1109 errno = EAGAIN;
1110 else
1111 errno = EIO;
1112 ret = -1;
1113 }
8d5d2d4c
TS		 1114 } else
1115#endif /* CONFIG_VNC_TLS */
70503264 1116 ret = send(vs->csock, (const void *)data, datalen, 0);
23decc87 1117 VNC_DEBUG("Wrote wire %p %zd -> %ld\n", data, datalen, ret);
2f9606b3
AL		 1118 return vnc_client_io_error(vs, ret, socket_error());
1119}
1120
1121
1122/*
1123 * Called to write buffered data to the client socket, when not
1124 * using any SASL SSF encryption layers. Will write as much data
1125 * as possible without blocking. If all buffered data is written,
1126 * will switch the FD poll() handler back to read monitoring.
1127 *
1128 * Returns the number of bytes written, which may be less than
1129 * the buffered output data if the socket would block. Returns
1130 * -1 on error, and disconnects the client socket.
1131 */
1132static long vnc_client_write_plain(VncState *vs)
1133{
1134 long ret;
1135
1136#ifdef CONFIG_VNC_SASL
23decc87 1137 VNC_DEBUG("Write Plain: Pending output %p size %zd offset %zd. Wait SSF %d\n",
2f9606b3
AL		 1138 vs->output.buffer, vs->output.capacity, vs->output.offset,
1139 vs->sasl.waitWriteSSF);
1140
1141 if (vs->sasl.conn &&
1142 vs->sasl.runSSF &&
1143 vs->sasl.waitWriteSSF) {
1144 ret = vnc_client_write_buf(vs, vs->output.buffer, vs->sasl.waitWriteSSF);
1145 if (ret)
1146 vs->sasl.waitWriteSSF -= ret;
1147 } else
1148#endif /* CONFIG_VNC_SASL */
1149 ret = vnc_client_write_buf(vs, vs->output.buffer, vs->output.offset);
24236869 1150 if (!ret)
2f9606b3 1151 return 0;
24236869
FB		 1152
1153 memmove(vs->output.buffer, vs->output.buffer + ret, (vs->output.offset - ret));
1154 vs->output.offset -= ret;
1155
1156 if (vs->output.offset == 0) {
28a76be8 1157 qemu_set_fd_handler2(vs->csock, NULL, vnc_client_read, NULL, vs);
24236869 1158 }
2f9606b3
AL		 1159
1160 return ret;
1161}
1162
1163
1164/*
1165 * First function called whenever there is data to be written to
1166 * the client socket. Will delegate actual work according to whether
1167 * SASL SSF layers are enabled (thus requiring encryption calls)
1168 */
bd023f95 1169static void vnc_client_write_locked(void *opaque)
2f9606b3 1170{
2f9606b3
AL		 1171 VncState *vs = opaque;
1172
1173#ifdef CONFIG_VNC_SASL
1174 if (vs->sasl.conn &&
1175 vs->sasl.runSSF &&
9678d950
BS		 1176 !vs->sasl.waitWriteSSF) {
1177 vnc_client_write_sasl(vs);
1178 } else
2f9606b3 1179#endif /* CONFIG_VNC_SASL */
9678d950 1180 vnc_client_write_plain(vs);
24236869
FB		 1181}
1182
bd023f95
CC		 1183void vnc_client_write(void *opaque)
1184{
1185 VncState *vs = opaque;
1186
1187 vnc_lock_output(vs);
1188 if (vs->output.offset) {
1189 vnc_client_write_locked(opaque);
ac71103d 1190 } else if (vs->csock != -1) {
bd023f95
CC		 1191 qemu_set_fd_handler2(vs->csock, NULL, vnc_client_read, NULL, vs);
1192 }
1193 vnc_unlock_output(vs);
1194}
1195
5fb6c7a8 1196void vnc_read_when(VncState *vs, VncReadEvent *func, size_t expecting)
24236869
FB		 1197{
1198 vs->read_handler = func;
1199 vs->read_handler_expect = expecting;
1200}
1201
2f9606b3
AL		 1202
1203/*
1204 * Called to read a chunk of data from the client socket. The data may
1205 * be the raw data, or may need to be further decoded by SASL.
1206 * The data will be read either straight from to the socket, or
1207 * read via the GNUTLS wrappers, if TLS/SSL encryption is enabled
1208 *
1209 * NB, it is theoretically possible to have 2 layers of encryption,
1210 * both SASL, and this TLS layer. It is highly unlikely in practice
1211 * though, since SASL encryption will typically be a no-op if TLS
1212 * is active
1213 *
1214 * Returns the number of bytes read, which may be less than
1215 * the requested 'datalen' if the socket would block. Returns
1216 * -1 on error, and disconnects the client socket.
1217 */
1218long vnc_client_read_buf(VncState *vs, uint8_t *data, size_t datalen)
24236869 1219{
ceb5caaf 1220 long ret;
eb38c52c 1221#ifdef CONFIG_VNC_TLS
5fb6c7a8 1222 if (vs->tls.session) {
28a76be8
AL		 1223 ret = gnutls_read(vs->tls.session, data, datalen);
1224 if (ret < 0) {
1225 if (ret == GNUTLS_E_AGAIN)
1226 errno = EAGAIN;
1227 else
1228 errno = EIO;
1229 ret = -1;
1230 }
8d5d2d4c
TS		 1231 } else
1232#endif /* CONFIG_VNC_TLS */
00aa0040 1233 ret = qemu_recv(vs->csock, data, datalen, 0);
23decc87 1234 VNC_DEBUG("Read wire %p %zd -> %ld\n", data, datalen, ret);
2f9606b3
AL		 1235 return vnc_client_io_error(vs, ret, socket_error());
1236}
24236869 1237
2f9606b3
AL		 1238
1239/*
1240 * Called to read data from the client socket to the input buffer,
1241 * when not using any SASL SSF encryption layers. Will read as much
1242 * data as possible without blocking.
1243 *
1244 * Returns the number of bytes read. Returns -1 on error, and
1245 * disconnects the client socket.
1246 */
1247static long vnc_client_read_plain(VncState *vs)
1248{
1249 int ret;
23decc87 1250 VNC_DEBUG("Read plain %p size %zd offset %zd\n",
2f9606b3
AL		 1251 vs->input.buffer, vs->input.capacity, vs->input.offset);
1252 buffer_reserve(&vs->input, 4096);
1253 ret = vnc_client_read_buf(vs, buffer_end(&vs->input), 4096);
1254 if (!ret)
1255 return 0;
24236869 1256 vs->input.offset += ret;
2f9606b3
AL		 1257 return ret;
1258}
1259
1260
1261/*
1262 * First function called whenever there is more data to be read from
1263 * the client socket. Will delegate actual work according to whether
1264 * SASL SSF layers are enabled (thus requiring decryption calls)
1265 */
1266void vnc_client_read(void *opaque)
1267{
1268 VncState *vs = opaque;
1269 long ret;
1270
1271#ifdef CONFIG_VNC_SASL
1272 if (vs->sasl.conn && vs->sasl.runSSF)
1273 ret = vnc_client_read_sasl(vs);
1274 else
1275#endif /* CONFIG_VNC_SASL */
1276 ret = vnc_client_read_plain(vs);
198a0039
GH		 1277 if (!ret) {
1278 if (vs->csock == -1)
1279 vnc_disconnect_finish(vs);
28a76be8 1280 return;
198a0039 1281 }
24236869
FB		 1282
1283 while (vs->read_handler && vs->input.offset >= vs->read_handler_expect) {
28a76be8
AL		 1284 size_t len = vs->read_handler_expect;
1285 int ret;
1286
1287 ret = vs->read_handler(vs, vs->input.buffer, len);
198a0039
GH		 1288 if (vs->csock == -1) {
1289 vnc_disconnect_finish(vs);
28a76be8 1290 return;
198a0039 1291 }
28a76be8
AL		 1292
1293 if (!ret) {
1294 memmove(vs->input.buffer, vs->input.buffer + len, (vs->input.offset - len));
1295 vs->input.offset -= len;
1296 } else {
1297 vs->read_handler_expect = ret;
1298 }
24236869
FB		 1299 }
1300}
1301
5fb6c7a8 1302void vnc_write(VncState *vs, const void *data, size_t len)
24236869
FB		 1303{
1304 buffer_reserve(&vs->output, len);
1305
198a0039 1306 if (vs->csock != -1 && buffer_empty(&vs->output)) {
28a76be8 1307 qemu_set_fd_handler2(vs->csock, NULL, vnc_client_read, vnc_client_write, vs);
24236869
FB		 1308 }
1309
1310 buffer_append(&vs->output, data, len);
1311}
1312
5fb6c7a8 1313void vnc_write_s32(VncState *vs, int32_t value)
24236869
FB		 1314{
1315 vnc_write_u32(vs, *(uint32_t *)&value);
1316}
1317
5fb6c7a8 1318void vnc_write_u32(VncState *vs, uint32_t value)
24236869
FB		 1319{
1320 uint8_t buf[4];
1321
1322 buf[0] = (value >> 24) & 0xFF;
1323 buf[1] = (value >> 16) & 0xFF;
1324 buf[2] = (value >> 8) & 0xFF;
1325 buf[3] = value & 0xFF;
1326
1327 vnc_write(vs, buf, 4);
1328}
1329
5fb6c7a8 1330void vnc_write_u16(VncState *vs, uint16_t value)
24236869 1331{
64f5a135 1332 uint8_t buf[2];
24236869
FB		 1333
1334 buf[0] = (value >> 8) & 0xFF;
1335 buf[1] = value & 0xFF;
1336
1337 vnc_write(vs, buf, 2);
1338}
1339
5fb6c7a8 1340void vnc_write_u8(VncState *vs, uint8_t value)
24236869
FB		 1341{
1342 vnc_write(vs, (char *)&value, 1);
1343}
1344
5fb6c7a8 1345void vnc_flush(VncState *vs)
24236869 1346{
bd023f95
CC		 1347 vnc_lock_output(vs);
1348 if (vs->csock != -1 && vs->output.offset) {
1349 vnc_client_write_locked(vs);
1350 }
1351 vnc_unlock_output(vs);
24236869
FB		 1352}
1353
5fb6c7a8 1354uint8_t read_u8(uint8_t *data, size_t offset)
24236869
FB		 1355{
1356 return data[offset];
1357}
1358
5fb6c7a8 1359uint16_t read_u16(uint8_t *data, size_t offset)
24236869
FB		 1360{
1361 return ((data[offset] & 0xFF) << 8) | (data[offset + 1] & 0xFF);
1362}
1363
5fb6c7a8 1364int32_t read_s32(uint8_t *data, size_t offset)
24236869
FB		 1365{
1366 return (int32_t)((data[offset] << 24) | (data[offset + 1] << 16) |
28a76be8 1367 (data[offset + 2] << 8) | data[offset + 3]);
24236869
FB		 1368}
1369
5fb6c7a8 1370uint32_t read_u32(uint8_t *data, size_t offset)
24236869
FB		 1371{
1372 return ((data[offset] << 24) | (data[offset + 1] << 16) |
28a76be8 1373 (data[offset + 2] << 8) | data[offset + 3]);
24236869
FB		 1374}
1375
60fe76f3 1376static void client_cut_text(VncState *vs, size_t len, uint8_t *text)
24236869
FB		 1377{
1378}
1379
9e8dd451 1380static void check_pointer_type_change(Notifier *notifier, void *data)
564c337e 1381{
37c34d9d
AL		 1382 VncState *vs = container_of(notifier, VncState, mouse_mode_notifier);
1383 int absolute = kbd_mouse_is_absolute();
1384
29fa4ed9 1385 if (vnc_has_feature(vs, VNC_FEATURE_POINTER_TYPE_CHANGE) && vs->absolute != absolute) {
bd023f95 1386 vnc_lock_output(vs);
46a183da 1387 vnc_write_u8(vs, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE);
28a76be8
AL		 1388 vnc_write_u8(vs, 0);
1389 vnc_write_u16(vs, 1);
1390 vnc_framebuffer_update(vs, absolute, 0,
1391 ds_get_width(vs->ds), ds_get_height(vs->ds),
29fa4ed9 1392 VNC_ENCODING_POINTER_TYPE_CHANGE);
bd023f95 1393 vnc_unlock_output(vs);
28a76be8 1394 vnc_flush(vs);
564c337e
FB		 1395 }
1396 vs->absolute = absolute;
1397}
1398
24236869
FB		 1399static void pointer_event(VncState *vs, int button_mask, int x, int y)
1400{
1401 int buttons = 0;
1402 int dz = 0;
1403
1404 if (button_mask & 0x01)
28a76be8 1405 buttons |= MOUSE_EVENT_LBUTTON;
24236869 1406 if (button_mask & 0x02)
28a76be8 1407 buttons |= MOUSE_EVENT_MBUTTON;
24236869 1408 if (button_mask & 0x04)
28a76be8 1409 buttons |= MOUSE_EVENT_RBUTTON;
24236869 1410 if (button_mask & 0x08)
28a76be8 1411 dz = -1;
24236869 1412 if (button_mask & 0x10)
28a76be8 1413 dz = 1;
564c337e
FB		 1414
1415 if (vs->absolute) {
cc39a92c
CW		 1416 kbd_mouse_event(ds_get_width(vs->ds) > 1 ?
1417 x * 0x7FFF / (ds_get_width(vs->ds) - 1) : 0x4000,
1418 ds_get_height(vs->ds) > 1 ?
1419 y * 0x7FFF / (ds_get_height(vs->ds) - 1) : 0x4000,
28a76be8 1420 dz, buttons);
29fa4ed9 1421 } else if (vnc_has_feature(vs, VNC_FEATURE_POINTER_TYPE_CHANGE)) {
28a76be8
AL		 1422 x -= 0x7FFF;
1423 y -= 0x7FFF;
24236869 1424
28a76be8 1425 kbd_mouse_event(x, y, dz, buttons);
564c337e 1426 } else {
28a76be8
AL		 1427 if (vs->last_x != -1)
1428 kbd_mouse_event(x - vs->last_x,
1429 y - vs->last_y,
1430 dz, buttons);
1431 vs->last_x = x;
1432 vs->last_y = y;
24236869
FB		 1433 }
1434}
1435
64f5a135
FB		 1436static void reset_keys(VncState *vs)
1437{
1438 int i;
1439 for(i = 0; i < 256; i++) {
1440 if (vs->modifiers_state[i]) {
44bb61c8
ST		 1441 if (i & SCANCODE_GREY)
1442 kbd_put_keycode(SCANCODE_EMUL0);
1443 kbd_put_keycode(i | SCANCODE_UP);
64f5a135
FB		 1444 vs->modifiers_state[i] = 0;
1445 }
1446 }
1447}
1448
a528b80c
AZ		 1449static void press_key(VncState *vs, int keysym)
1450{
44bb61c8
ST		 1451 int keycode = keysym2scancode(vs->vd->kbd_layout, keysym) & SCANCODE_KEYMASK;
1452 if (keycode & SCANCODE_GREY)
1453 kbd_put_keycode(SCANCODE_EMUL0);
1454 kbd_put_keycode(keycode & SCANCODE_KEYCODEMASK);
1455 if (keycode & SCANCODE_GREY)
1456 kbd_put_keycode(SCANCODE_EMUL0);
1457 kbd_put_keycode(keycode | SCANCODE_UP);
a528b80c
AZ		 1458}
1459
7ffb82ca
GH		 1460static void kbd_leds(void *opaque, int ledstate)
1461{
1462 VncState *vs = opaque;
1463 int caps, num;
1464
1465 caps = ledstate & QEMU_CAPS_LOCK_LED ? 1 : 0;
1466 num = ledstate & QEMU_NUM_LOCK_LED ? 1 : 0;
1467
1468 if (vs->modifiers_state[0x3a] != caps) {
1469 vs->modifiers_state[0x3a] = caps;
1470 }
1471 if (vs->modifiers_state[0x45] != num) {
1472 vs->modifiers_state[0x45] = num;
1473 }
1474}
1475
9ca313aa 1476static void do_key_event(VncState *vs, int down, int keycode, int sym)
24236869 1477{
64f5a135
FB		 1478 /* QEMU console switch */
1479 switch(keycode) {
1480 case 0x2a: /* Left Shift */
1481 case 0x36: /* Right Shift */
1482 case 0x1d: /* Left CTRL */
1483 case 0x9d: /* Right CTRL */
1484 case 0x38: /* Left ALT */
1485 case 0xb8: /* Right ALT */
1486 if (down)
1487 vs->modifiers_state[keycode] = 1;
1488 else
1489 vs->modifiers_state[keycode] = 0;
1490 break;
5fafdf24 1491 case 0x02 ... 0x0a: /* '1' to '9' keys */
64f5a135
FB		 1492 if (down && vs->modifiers_state[0x1d] && vs->modifiers_state[0x38]) {
1493 /* Reset the modifiers sent to the current console */
1494 reset_keys(vs);
1495 console_select(keycode - 0x02);
1496 return;
1497 }
1498 break;
28a76be8
AL		 1499 case 0x3a: /* CapsLock */
1500 case 0x45: /* NumLock */
7ffb82ca 1501 if (down)
a528b80c
AZ		 1502 vs->modifiers_state[keycode] ^= 1;
1503 break;
1504 }
1505
9892088b 1506 if (down && vs->vd->lock_key_sync &&
3a0558b5 1507 keycode_is_keypad(vs->vd->kbd_layout, keycode)) {
a528b80c
AZ		 1508 /* If the numlock state needs to change then simulate an additional
1509 keypress before sending this one. This will happen if the user
1510 toggles numlock away from the VNC window.
1511 */
753b4053 1512 if (keysym_is_numlock(vs->vd->kbd_layout, sym & 0xFFFF)) {
a528b80c
AZ		 1513 if (!vs->modifiers_state[0x45]) {
1514 vs->modifiers_state[0x45] = 1;
1515 press_key(vs, 0xff7f);
1516 }
1517 } else {
1518 if (vs->modifiers_state[0x45]) {
1519 vs->modifiers_state[0x45] = 0;
1520 press_key(vs, 0xff7f);
1521 }
1522 }
64f5a135 1523 }
24236869 1524
9892088b 1525 if (down && vs->vd->lock_key_sync &&
3a0558b5 1526 ((sym >= 'A' && sym <= 'Z') || (sym >= 'a' && sym <= 'z'))) {
6b132502
GH		 1527 /* If the capslock state needs to change then simulate an additional
1528 keypress before sending this one. This will happen if the user
1529 toggles capslock away from the VNC window.
1530 */
1531 int uppercase = !!(sym >= 'A' && sym <= 'Z');
1532 int shift = !!(vs->modifiers_state[0x2a] | vs->modifiers_state[0x36]);
1533 int capslock = !!(vs->modifiers_state[0x3a]);
1534 if (capslock) {
1535 if (uppercase == shift) {
1536 vs->modifiers_state[0x3a] = 0;
1537 press_key(vs, 0xffe5);
1538 }
1539 } else {
1540 if (uppercase != shift) {
1541 vs->modifiers_state[0x3a] = 1;
1542 press_key(vs, 0xffe5);
1543 }
1544 }
1545 }
1546
64f5a135 1547 if (is_graphic_console()) {
44bb61c8
ST		 1548 if (keycode & SCANCODE_GREY)
1549 kbd_put_keycode(SCANCODE_EMUL0);
64f5a135 1550 if (down)
44bb61c8 1551 kbd_put_keycode(keycode & SCANCODE_KEYCODEMASK);
64f5a135 1552 else
44bb61c8 1553 kbd_put_keycode(keycode | SCANCODE_UP);
64f5a135 1554 } else {
e26437c2
GH		 1555 bool numlock = vs->modifiers_state[0x45];
1556 bool control = (vs->modifiers_state[0x1d] ||
1557 vs->modifiers_state[0x9d]);
64f5a135
FB		 1558 /* QEMU console emulation */
1559 if (down) {
1560 switch (keycode) {
1561 case 0x2a: /* Left Shift */
1562 case 0x36: /* Right Shift */
1563 case 0x1d: /* Left CTRL */
1564 case 0x9d: /* Right CTRL */
1565 case 0x38: /* Left ALT */
1566 case 0xb8: /* Right ALT */
1567 break;
1568 case 0xc8:
1569 kbd_put_keysym(QEMU_KEY_UP);
1570 break;
1571 case 0xd0:
1572 kbd_put_keysym(QEMU_KEY_DOWN);
1573 break;
1574 case 0xcb:
1575 kbd_put_keysym(QEMU_KEY_LEFT);
1576 break;
1577 case 0xcd:
1578 kbd_put_keysym(QEMU_KEY_RIGHT);
1579 break;
1580 case 0xd3:
1581 kbd_put_keysym(QEMU_KEY_DELETE);
1582 break;
1583 case 0xc7:
1584 kbd_put_keysym(QEMU_KEY_HOME);
1585 break;
1586 case 0xcf:
1587 kbd_put_keysym(QEMU_KEY_END);
1588 break;
1589 case 0xc9:
1590 kbd_put_keysym(QEMU_KEY_PAGEUP);
1591 break;
1592 case 0xd1:
1593 kbd_put_keysym(QEMU_KEY_PAGEDOWN);
1594 break;
bb0a18e1
GH		 1595
1596 case 0x47:
1597 kbd_put_keysym(numlock ? '7' : QEMU_KEY_HOME);
1598 break;
1599 case 0x48:
1600 kbd_put_keysym(numlock ? '8' : QEMU_KEY_UP);
1601 break;
1602 case 0x49:
1603 kbd_put_keysym(numlock ? '9' : QEMU_KEY_PAGEUP);
1604 break;
1605 case 0x4b:
1606 kbd_put_keysym(numlock ? '4' : QEMU_KEY_LEFT);
1607 break;
1608 case 0x4c:
1609 kbd_put_keysym('5');
1610 break;
1611 case 0x4d:
1612 kbd_put_keysym(numlock ? '6' : QEMU_KEY_RIGHT);
1613 break;
1614 case 0x4f:
1615 kbd_put_keysym(numlock ? '1' : QEMU_KEY_END);
1616 break;
1617 case 0x50:
1618 kbd_put_keysym(numlock ? '2' : QEMU_KEY_DOWN);
1619 break;
1620 case 0x51:
1621 kbd_put_keysym(numlock ? '3' : QEMU_KEY_PAGEDOWN);
1622 break;
1623 case 0x52:
1624 kbd_put_keysym('0');
1625 break;
1626 case 0x53:
1627 kbd_put_keysym(numlock ? '.' : QEMU_KEY_DELETE);
1628 break;
1629
1630 case 0xb5:
1631 kbd_put_keysym('/');
1632 break;
1633 case 0x37:
1634 kbd_put_keysym('*');
1635 break;
1636 case 0x4a:
1637 kbd_put_keysym('-');
1638 break;
1639 case 0x4e:
1640 kbd_put_keysym('+');
1641 break;
1642 case 0x9c:
1643 kbd_put_keysym('\n');
1644 break;
1645
64f5a135 1646 default:
e26437c2
GH		 1647 if (control) {
1648 kbd_put_keysym(sym & 0x1f);
1649 } else {
1650 kbd_put_keysym(sym);
1651 }
64f5a135
FB		 1652 break;
1653 }
1654 }
1655 }
24236869
FB		 1656}
1657
bdbd7676
FB		 1658static void key_event(VncState *vs, int down, uint32_t sym)
1659{
9ca313aa 1660 int keycode;
4a93fe17 1661 int lsym = sym;
9ca313aa 1662
4a93fe17
GH		 1663 if (lsym >= 'A' && lsym <= 'Z' && is_graphic_console()) {
1664 lsym = lsym - 'A' + 'a';
1665 }
9ca313aa 1666
44bb61c8 1667 keycode = keysym2scancode(vs->vd->kbd_layout, lsym & 0xFFFF) & SCANCODE_KEYMASK;
9ca313aa
AL		 1668 do_key_event(vs, down, keycode, sym);
1669}
1670
1671static void ext_key_event(VncState *vs, int down,
1672 uint32_t sym, uint16_t keycode)
1673{
1674 /* if the user specifies a keyboard layout, always use it */
1675 if (keyboard_layout)
1676 key_event(vs, down, sym);
1677 else
1678 do_key_event(vs, down, keycode, sym);
bdbd7676
FB		 1679}
1680
24236869 1681static void framebuffer_update_request(VncState *vs, int incremental,
28a76be8
AL		 1682 int x_position, int y_position,
1683 int w, int h)
24236869 1684{
6ed391bf
WC		 1685 int i;
1686 const size_t width = ds_get_width(vs->ds) / 16;
1687
0e1f5a0c
AL		 1688 if (y_position > ds_get_height(vs->ds))
1689 y_position = ds_get_height(vs->ds);
0e1f5a0c
AL		 1690 if (y_position + h >= ds_get_height(vs->ds))
1691 h = ds_get_height(vs->ds) - y_position;
cf2d385c 1692
24236869
FB		 1693 vs->need_update = 1;
1694 if (!incremental) {
24cf0a6e 1695 vs->force_update = 1;
28a76be8 1696 for (i = 0; i < h; i++) {
6ed391bf
WC		 1697 bitmap_set(vs->dirty[y_position + i], 0, width);
1698 bitmap_clear(vs->dirty[y_position + i], width,
a0843a68 1699 VNC_DIRTY_BITS - width);
28a76be8 1700 }
24236869
FB		 1701 }
1702}
1703
9ca313aa
AL		 1704static void send_ext_key_event_ack(VncState *vs)
1705{
bd023f95 1706 vnc_lock_output(vs);
46a183da 1707 vnc_write_u8(vs, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE);
9ca313aa
AL		 1708 vnc_write_u8(vs, 0);
1709 vnc_write_u16(vs, 1);
29fa4ed9
AL		 1710 vnc_framebuffer_update(vs, 0, 0, ds_get_width(vs->ds), ds_get_height(vs->ds),
1711 VNC_ENCODING_EXT_KEY_EVENT);
bd023f95 1712 vnc_unlock_output(vs);
9ca313aa
AL		 1713 vnc_flush(vs);
1714}
1715
429a8ed3 1716static void send_ext_audio_ack(VncState *vs)
1717{
bd023f95 1718 vnc_lock_output(vs);
46a183da 1719 vnc_write_u8(vs, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE);
429a8ed3 1720 vnc_write_u8(vs, 0);
1721 vnc_write_u16(vs, 1);
29fa4ed9
AL		 1722 vnc_framebuffer_update(vs, 0, 0, ds_get_width(vs->ds), ds_get_height(vs->ds),
1723 VNC_ENCODING_AUDIO);
bd023f95 1724 vnc_unlock_output(vs);
429a8ed3 1725 vnc_flush(vs);
1726}
1727
24236869
FB		 1728static void set_encodings(VncState *vs, int32_t *encodings, size_t n_encodings)
1729{
1730 int i;
29fa4ed9 1731 unsigned int enc = 0;
24236869 1732
29fa4ed9 1733 vs->features = 0;
a9f20d31 1734 vs->vnc_encoding = 0;
d1af0e05
CC		 1735 vs->tight.compression = 9;
1736 vs->tight.quality = -1; /* Lossless by default */
564c337e 1737 vs->absolute = -1;
24236869 1738
8a0f0d0c
CC		 1739 /*
1740 * Start from the end because the encodings are sent in order of preference.
e5bed759 1741 * This way the preferred encoding (first encoding defined in the array)
8a0f0d0c
CC		 1742 * will be set at the end of the loop.
1743 */
24236869 1744 for (i = n_encodings - 1; i >= 0; i--) {
29fa4ed9
AL		 1745 enc = encodings[i];
1746 switch (enc) {
1747 case VNC_ENCODING_RAW:
a9f20d31 1748 vs->vnc_encoding = enc;
29fa4ed9
AL		 1749 break;
1750 case VNC_ENCODING_COPYRECT:
753b4053 1751 vs->features |= VNC_FEATURE_COPYRECT_MASK;
29fa4ed9
AL		 1752 break;
1753 case VNC_ENCODING_HEXTILE:
1754 vs->features |= VNC_FEATURE_HEXTILE_MASK;
a9f20d31 1755 vs->vnc_encoding = enc;
29fa4ed9 1756 break;
380282b0
CC		 1757 case VNC_ENCODING_TIGHT:
1758 vs->features |= VNC_FEATURE_TIGHT_MASK;
1759 vs->vnc_encoding = enc;
1760 break;
efe556ad
CC		 1761 case VNC_ENCODING_TIGHT_PNG:
1762 vs->features |= VNC_FEATURE_TIGHT_PNG_MASK;
1763 vs->vnc_encoding = enc;
1764 break;
059cef40
AL		 1765 case VNC_ENCODING_ZLIB:
1766 vs->features |= VNC_FEATURE_ZLIB_MASK;
a9f20d31 1767 vs->vnc_encoding = enc;
059cef40 1768 break;
148954fa
CC		 1769 case VNC_ENCODING_ZRLE:
1770 vs->features |= VNC_FEATURE_ZRLE_MASK;
1771 vs->vnc_encoding = enc;
1772 break;
1773 case VNC_ENCODING_ZYWRLE:
1774 vs->features |= VNC_FEATURE_ZYWRLE_MASK;
1775 vs->vnc_encoding = enc;
1776 break;
29fa4ed9
AL		 1777 case VNC_ENCODING_DESKTOPRESIZE:
1778 vs->features |= VNC_FEATURE_RESIZE_MASK;
1779 break;
1780 case VNC_ENCODING_POINTER_TYPE_CHANGE:
1781 vs->features |= VNC_FEATURE_POINTER_TYPE_CHANGE_MASK;
1782 break;
d467b679
GH		 1783 case VNC_ENCODING_RICH_CURSOR:
1784 vs->features |= VNC_FEATURE_RICH_CURSOR_MASK;
1785 break;
29fa4ed9 1786 case VNC_ENCODING_EXT_KEY_EVENT:
9ca313aa
AL		 1787 send_ext_key_event_ack(vs);
1788 break;
29fa4ed9 1789 case VNC_ENCODING_AUDIO:
429a8ed3 1790 send_ext_audio_ack(vs);
1791 break;
29fa4ed9
AL		 1792 case VNC_ENCODING_WMVi:
1793 vs->features |= VNC_FEATURE_WMVI_MASK;
ca4cca4d 1794 break;
fb437313 1795 case VNC_ENCODING_COMPRESSLEVEL0 ... VNC_ENCODING_COMPRESSLEVEL0 + 9:
d1af0e05 1796 vs->tight.compression = (enc & 0x0F);
fb437313
AL		 1797 break;
1798 case VNC_ENCODING_QUALITYLEVEL0 ... VNC_ENCODING_QUALITYLEVEL0 + 9:
b31f519e
CC		 1799 if (vs->vd->lossy) {
1800 vs->tight.quality = (enc & 0x0F);
1801 }
fb437313 1802 break;
29fa4ed9
AL		 1803 default:
1804 VNC_DEBUG("Unknown encoding: %d (0x%.8x): %d\n", i, enc, enc);
1805 break;
1806 }
24236869 1807 }
6356e472 1808 vnc_desktop_resize(vs);
9e8dd451 1809 check_pointer_type_change(&vs->mouse_mode_notifier, NULL);
24236869
FB		 1810}
1811
6cec5487
AL		 1812static void set_pixel_conversion(VncState *vs)
1813{
1814 if ((vs->clientds.flags & QEMU_BIG_ENDIAN_FLAG) ==
1815 (vs->ds->surface->flags & QEMU_BIG_ENDIAN_FLAG) &&
1816 !memcmp(&(vs->clientds.pf), &(vs->ds->surface->pf), sizeof(PixelFormat))) {
1817 vs->write_pixels = vnc_write_pixels_copy;
70a4568f 1818 vnc_hextile_set_pixel_conversion(vs, 0);
6cec5487
AL		 1819 } else {
1820 vs->write_pixels = vnc_write_pixels_generic;
70a4568f 1821 vnc_hextile_set_pixel_conversion(vs, 1);
6cec5487
AL		 1822 }
1823}
1824
24236869 1825static void set_pixel_format(VncState *vs,
28a76be8
AL		 1826 int bits_per_pixel, int depth,
1827 int big_endian_flag, int true_color_flag,
1828 int red_max, int green_max, int blue_max,
1829 int red_shift, int green_shift, int blue_shift)
24236869 1830{
3512779a 1831 if (!true_color_flag) {
28a76be8 1832 vnc_client_error(vs);
3512779a
FB		 1833 return;
1834 }
24236869 1835
1fc62412 1836 vs->clientds = *(vs->vd->guest.ds);
6cec5487 1837 vs->clientds.pf.rmax = red_max;
bc2429b9 1838 vs->clientds.pf.rbits = hweight_long(red_max);
6cec5487
AL		 1839 vs->clientds.pf.rshift = red_shift;
1840 vs->clientds.pf.rmask = red_max << red_shift;
1841 vs->clientds.pf.gmax = green_max;
bc2429b9 1842 vs->clientds.pf.gbits = hweight_long(green_max);
6cec5487
AL		 1843 vs->clientds.pf.gshift = green_shift;
1844 vs->clientds.pf.gmask = green_max << green_shift;
1845 vs->clientds.pf.bmax = blue_max;
bc2429b9 1846 vs->clientds.pf.bbits = hweight_long(blue_max);
6cec5487
AL		 1847 vs->clientds.pf.bshift = blue_shift;
1848 vs->clientds.pf.bmask = blue_max << blue_shift;
1849 vs->clientds.pf.bits_per_pixel = bits_per_pixel;
1850 vs->clientds.pf.bytes_per_pixel = bits_per_pixel / 8;
1851 vs->clientds.pf.depth = bits_per_pixel == 32 ? 24 : bits_per_pixel;
1852 vs->clientds.flags = big_endian_flag ? QEMU_BIG_ENDIAN_FLAG : 0x00;
1853
1854 set_pixel_conversion(vs);
24236869
FB		 1855
1856 vga_hw_invalidate();
1857 vga_hw_update();
1858}
1859
ca4cca4d
AL		 1860static void pixel_format_message (VncState *vs) {
1861 char pad[3] = { 0, 0, 0 };
1862
6cec5487
AL		 1863 vnc_write_u8(vs, vs->ds->surface->pf.bits_per_pixel); /* bits-per-pixel */
1864 vnc_write_u8(vs, vs->ds->surface->pf.depth); /* depth */
ca4cca4d 1865
e2542fe2 1866#ifdef HOST_WORDS_BIGENDIAN
ca4cca4d
AL		 1867 vnc_write_u8(vs, 1); /* big-endian-flag */
1868#else
1869 vnc_write_u8(vs, 0); /* big-endian-flag */
1870#endif
1871 vnc_write_u8(vs, 1); /* true-color-flag */
6cec5487
AL		 1872 vnc_write_u16(vs, vs->ds->surface->pf.rmax); /* red-max */
1873 vnc_write_u16(vs, vs->ds->surface->pf.gmax); /* green-max */
1874 vnc_write_u16(vs, vs->ds->surface->pf.bmax); /* blue-max */
1875 vnc_write_u8(vs, vs->ds->surface->pf.rshift); /* red-shift */
1876 vnc_write_u8(vs, vs->ds->surface->pf.gshift); /* green-shift */
1877 vnc_write_u8(vs, vs->ds->surface->pf.bshift); /* blue-shift */
70a4568f
CC		 1878
1879 vnc_hextile_set_pixel_conversion(vs, 0);
1880
6cec5487 1881 vs->clientds = *(vs->ds->surface);
3cded540 1882 vs->clientds.flags &= ~QEMU_ALLOCATED_FLAG;
ca4cca4d
AL		 1883 vs->write_pixels = vnc_write_pixels_copy;
1884
1885 vnc_write(vs, pad, 3); /* padding */
1886}
1887
7d957bd8
AL		 1888static void vnc_dpy_setdata(DisplayState *ds)
1889{
1890 /* We don't have to do anything */
1891}
1892
753b4053 1893static void vnc_colordepth(VncState *vs)
7eac3a87 1894{
753b4053 1895 if (vnc_has_feature(vs, VNC_FEATURE_WMVI)) {
ca4cca4d 1896 /* Sending a WMVi message to notify the client*/
bd023f95 1897 vnc_lock_output(vs);
46a183da 1898 vnc_write_u8(vs, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE);
ca4cca4d
AL		 1899 vnc_write_u8(vs, 0);
1900 vnc_write_u16(vs, 1); /* number of rects */
753b4053
AL		 1901 vnc_framebuffer_update(vs, 0, 0, ds_get_width(vs->ds),
1902 ds_get_height(vs->ds), VNC_ENCODING_WMVi);
ca4cca4d 1903 pixel_format_message(vs);
bd023f95 1904 vnc_unlock_output(vs);
ca4cca4d 1905 vnc_flush(vs);
7eac3a87 1906 } else {
6cec5487 1907 set_pixel_conversion(vs);
7eac3a87
AL		 1908 }
1909}
1910
60fe76f3 1911static int protocol_client_msg(VncState *vs, uint8_t *data, size_t len)
24236869
FB		 1912{
1913 int i;
1914 uint16_t limit;
2430ffe4
SS		 1915 VncDisplay *vd = vs->vd;
1916
1917 if (data[0] > 3) {
1918 vd->timer_interval = VNC_REFRESH_INTERVAL_BASE;
7bd427d8
PB		 1919 if (!qemu_timer_expired(vd->timer, qemu_get_clock_ms(rt_clock) + vd->timer_interval))
1920 qemu_mod_timer(vd->timer, qemu_get_clock_ms(rt_clock) + vd->timer_interval);
2430ffe4 1921 }
24236869
FB		 1922
1923 switch (data[0]) {
46a183da 1924 case VNC_MSG_CLIENT_SET_PIXEL_FORMAT:
28a76be8
AL		 1925 if (len == 1)
1926 return 20;
1927
1928 set_pixel_format(vs, read_u8(data, 4), read_u8(data, 5),
1929 read_u8(data, 6), read_u8(data, 7),
1930 read_u16(data, 8), read_u16(data, 10),
1931 read_u16(data, 12), read_u8(data, 14),
1932 read_u8(data, 15), read_u8(data, 16));
1933 break;
46a183da 1934 case VNC_MSG_CLIENT_SET_ENCODINGS:
28a76be8
AL		 1935 if (len == 1)
1936 return 4;
24236869 1937
28a76be8 1938 if (len == 4) {
69dd5c9f
AL		 1939 limit = read_u16(data, 2);
1940 if (limit > 0)
1941 return 4 + (limit * 4);
1942 } else
1943 limit = read_u16(data, 2);
24236869 1944
28a76be8
AL		 1945 for (i = 0; i < limit; i++) {
1946 int32_t val = read_s32(data, 4 + (i * 4));
1947 memcpy(data + 4 + (i * 4), &val, sizeof(val));
1948 }
24236869 1949
28a76be8
AL		 1950 set_encodings(vs, (int32_t *)(data + 4), limit);
1951 break;
46a183da 1952 case VNC_MSG_CLIENT_FRAMEBUFFER_UPDATE_REQUEST:
28a76be8
AL		 1953 if (len == 1)
1954 return 10;
24236869 1955
28a76be8
AL		 1956 framebuffer_update_request(vs,
1957 read_u8(data, 1), read_u16(data, 2), read_u16(data, 4),
1958 read_u16(data, 6), read_u16(data, 8));
1959 break;
46a183da 1960 case VNC_MSG_CLIENT_KEY_EVENT:
28a76be8
AL		 1961 if (len == 1)
1962 return 8;
24236869 1963
28a76be8
AL		 1964 key_event(vs, read_u8(data, 1), read_u32(data, 4));
1965 break;
46a183da 1966 case VNC_MSG_CLIENT_POINTER_EVENT:
28a76be8
AL		 1967 if (len == 1)
1968 return 6;
24236869 1969
28a76be8
AL		 1970 pointer_event(vs, read_u8(data, 1), read_u16(data, 2), read_u16(data, 4));
1971 break;
46a183da 1972 case VNC_MSG_CLIENT_CUT_TEXT:
28a76be8
AL		 1973 if (len == 1)
1974 return 8;
24236869 1975
28a76be8 1976 if (len == 8) {
baa7666c
TS		 1977 uint32_t dlen = read_u32(data, 4);
1978 if (dlen > 0)
1979 return 8 + dlen;
1980 }
24236869 1981
28a76be8
AL		 1982 client_cut_text(vs, read_u32(data, 4), data + 8);
1983 break;
46a183da 1984 case VNC_MSG_CLIENT_QEMU:
9ca313aa
AL		 1985 if (len == 1)
1986 return 2;
1987
1988 switch (read_u8(data, 1)) {
46a183da 1989 case VNC_MSG_CLIENT_QEMU_EXT_KEY_EVENT:
9ca313aa
AL		 1990 if (len == 2)
1991 return 12;
1992
1993 ext_key_event(vs, read_u16(data, 2),
1994 read_u32(data, 4), read_u32(data, 8));
1995 break;
46a183da 1996 case VNC_MSG_CLIENT_QEMU_AUDIO:
429a8ed3 1997 if (len == 2)
1998 return 4;
1999
2000 switch (read_u16 (data, 2)) {
46a183da 2001 case VNC_MSG_CLIENT_QEMU_AUDIO_ENABLE:
429a8ed3 2002 audio_add(vs);
2003 break;
46a183da 2004 case VNC_MSG_CLIENT_QEMU_AUDIO_DISABLE:
429a8ed3 2005 audio_del(vs);
2006 break;
46a183da 2007 case VNC_MSG_CLIENT_QEMU_AUDIO_SET_FORMAT:
429a8ed3 2008 if (len == 4)
2009 return 10;
2010 switch (read_u8(data, 4)) {
2011 case 0: vs->as.fmt = AUD_FMT_U8; break;
2012 case 1: vs->as.fmt = AUD_FMT_S8; break;
2013 case 2: vs->as.fmt = AUD_FMT_U16; break;
2014 case 3: vs->as.fmt = AUD_FMT_S16; break;
2015 case 4: vs->as.fmt = AUD_FMT_U32; break;
2016 case 5: vs->as.fmt = AUD_FMT_S32; break;
2017 default:
2018 printf("Invalid audio format %d\n", read_u8(data, 4));
2019 vnc_client_error(vs);
2020 break;
2021 }
2022 vs->as.nchannels = read_u8(data, 5);
2023 if (vs->as.nchannels != 1 && vs->as.nchannels != 2) {
2024 printf("Invalid audio channel coount %d\n",
2025 read_u8(data, 5));
2026 vnc_client_error(vs);
2027 break;
2028 }
2029 vs->as.freq = read_u32(data, 6);
2030 break;
2031 default:
2032 printf ("Invalid audio message %d\n", read_u8(data, 4));
2033 vnc_client_error(vs);
2034 break;
2035 }
2036 break;
2037
9ca313aa
AL		 2038 default:
2039 printf("Msg: %d\n", read_u16(data, 0));
2040 vnc_client_error(vs);
2041 break;
2042 }
2043 break;
24236869 2044 default:
28a76be8
AL		 2045 printf("Msg: %d\n", data[0]);
2046 vnc_client_error(vs);
2047 break;
24236869 2048 }
5fafdf24 2049
24236869
FB		 2050 vnc_read_when(vs, protocol_client_msg, 1);
2051 return 0;
2052}
2053
60fe76f3 2054static int protocol_client_init(VncState *vs, uint8_t *data, size_t len)
24236869 2055{
c35734b2
TS		 2056 char buf[1024];
2057 int size;
24236869 2058
5862d195
GH		 2059 vs->client_width = ds_get_width(vs->ds);
2060 vs->client_height = ds_get_height(vs->ds);
2061 vnc_write_u16(vs, vs->client_width);
2062 vnc_write_u16(vs, vs->client_height);
24236869 2063
ca4cca4d 2064 pixel_format_message(vs);
24236869 2065
c35734b2
TS		 2066 if (qemu_name)
2067 size = snprintf(buf, sizeof(buf), "QEMU (%s)", qemu_name);
2068 else
2069 size = snprintf(buf, sizeof(buf), "QEMU");
2070
2071 vnc_write_u32(vs, size);
2072 vnc_write(vs, buf, size);
24236869
FB		 2073 vnc_flush(vs);
2074
4a80dba3 2075 vnc_client_cache_auth(vs);
0d2ed46a 2076 vnc_qmp_event(vs, QEVENT_VNC_INITIALIZED);
4a80dba3 2077
24236869
FB		 2078 vnc_read_when(vs, protocol_client_msg, 1);
2079
2080 return 0;
2081}
2082
5fb6c7a8
AL		 2083void start_client_init(VncState *vs)
2084{
2085 vnc_read_when(vs, protocol_client_init, 1);
2086}
2087
70848515
TS		 2088static void make_challenge(VncState *vs)
2089{
2090 int i;
2091
2092 srand(time(NULL)+getpid()+getpid()*987654+rand());
2093
2094 for (i = 0 ; i < sizeof(vs->challenge) ; i++)
2095 vs->challenge[i] = (int) (256.0*rand()/(RAND_MAX+1.0));
2096}
2097
60fe76f3 2098static int protocol_client_auth_vnc(VncState *vs, uint8_t *data, size_t len)
70848515 2099{
60fe76f3 2100 unsigned char response[VNC_AUTH_CHALLENGE_SIZE];
70848515 2101 int i, j, pwlen;
60fe76f3 2102 unsigned char key[8];
3c9405a0 2103 time_t now = time(NULL);
70848515 2104
1cd20f8b 2105 if (!vs->vd->password) {
28a76be8 2106 VNC_DEBUG("No password configured on server");
6bffdf0f 2107 goto reject;
70848515 2108 }
3c9405a0
GH		 2109 if (vs->vd->expires < now) {
2110 VNC_DEBUG("Password is expired");
2111 goto reject;
2112 }
70848515
TS		 2113
2114 memcpy(response, vs->challenge, VNC_AUTH_CHALLENGE_SIZE);
2115
2116 /* Calculate the expected challenge response */
753b4053 2117 pwlen = strlen(vs->vd->password);
70848515 2118 for (i=0; i<sizeof(key); i++)
753b4053 2119 key[i] = i<pwlen ? vs->vd->password[i] : 0;
70848515
TS		 2120 deskey(key, EN0);
2121 for (j = 0; j < VNC_AUTH_CHALLENGE_SIZE; j += 8)
2122 des(response+j, response+j);
2123
2124 /* Compare expected vs actual challenge response */
2125 if (memcmp(response, data, VNC_AUTH_CHALLENGE_SIZE) != 0) {
e5bed759 2126 VNC_DEBUG("Client challenge response did not match\n");
6bffdf0f 2127 goto reject;
70848515 2128 } else {
28a76be8
AL		 2129 VNC_DEBUG("Accepting VNC challenge response\n");
2130 vnc_write_u32(vs, 0); /* Accept auth */
2131 vnc_flush(vs);
70848515 2132
5fb6c7a8 2133 start_client_init(vs);
70848515
TS		 2134 }
2135 return 0;
6bffdf0f
GH		 2136
2137reject:
2138 vnc_write_u32(vs, 1); /* Reject auth */
2139 if (vs->minor >= 8) {
2140 static const char err[] = "Authentication failed";
2141 vnc_write_u32(vs, sizeof(err));
2142 vnc_write(vs, err, sizeof(err));
2143 }
2144 vnc_flush(vs);
2145 vnc_client_error(vs);
2146 return 0;
70848515
TS		 2147}
2148
5fb6c7a8 2149void start_auth_vnc(VncState *vs)
70848515
TS		 2150{
2151 make_challenge(vs);
2152 /* Send client a 'random' challenge */
2153 vnc_write(vs, vs->challenge, sizeof(vs->challenge));
2154 vnc_flush(vs);
2155
2156 vnc_read_when(vs, protocol_client_auth_vnc, sizeof(vs->challenge));
469b15c6
TS		 2157}
2158
2159
60fe76f3 2160static int protocol_client_auth(VncState *vs, uint8_t *data, size_t len)
70848515
TS		 2161{
2162 /* We only advertise 1 auth scheme at a time, so client
2163 * must pick the one we sent. Verify this */
7e7e2ebc 2164 if (data[0] != vs->auth) { /* Reject auth */
1263b7d6 2165 VNC_DEBUG("Reject auth %d because it didn't match advertized\n", (int)data[0]);
70848515
TS		 2166 vnc_write_u32(vs, 1);
2167 if (vs->minor >= 8) {
2168 static const char err[] = "Authentication failed";
2169 vnc_write_u32(vs, sizeof(err));
2170 vnc_write(vs, err, sizeof(err));
2171 }
2172 vnc_client_error(vs);
2173 } else { /* Accept requested auth */
2174 VNC_DEBUG("Client requested auth %d\n", (int)data[0]);
7e7e2ebc 2175 switch (vs->auth) {
70848515
TS		 2176 case VNC_AUTH_NONE:
2177 VNC_DEBUG("Accept auth none\n");
a26c97ad
AZ		 2178 if (vs->minor >= 8) {
2179 vnc_write_u32(vs, 0); /* Accept auth completion */
2180 vnc_flush(vs);
2181 }
5fb6c7a8 2182 start_client_init(vs);
70848515
TS		 2183 break;
2184
2185 case VNC_AUTH_VNC:
2186 VNC_DEBUG("Start VNC auth\n");
5fb6c7a8
AL		 2187 start_auth_vnc(vs);
2188 break;
70848515 2189
eb38c52c 2190#ifdef CONFIG_VNC_TLS
8d5d2d4c 2191 case VNC_AUTH_VENCRYPT:
3a93113a 2192 VNC_DEBUG("Accept VeNCrypt auth\n");
5fb6c7a8
AL		 2193 start_auth_vencrypt(vs);
2194 break;
8d5d2d4c
TS		 2195#endif /* CONFIG_VNC_TLS */
2196
2f9606b3
AL		 2197#ifdef CONFIG_VNC_SASL
2198 case VNC_AUTH_SASL:
2199 VNC_DEBUG("Accept SASL auth\n");
2200 start_auth_sasl(vs);
2201 break;
2202#endif /* CONFIG_VNC_SASL */
2203
70848515 2204 default: /* Should not be possible, but just in case */
7e7e2ebc 2205 VNC_DEBUG("Reject auth %d server code bug\n", vs->auth);
70848515
TS		 2206 vnc_write_u8(vs, 1);
2207 if (vs->minor >= 8) {
2208 static const char err[] = "Authentication failed";
2209 vnc_write_u32(vs, sizeof(err));
2210 vnc_write(vs, err, sizeof(err));
2211 }
2212 vnc_client_error(vs);
2213 }
2214 }
2215 return 0;
2216}
2217
60fe76f3 2218static int protocol_version(VncState *vs, uint8_t *version, size_t len)
24236869
FB		 2219{
2220 char local[13];
24236869
FB		 2221
2222 memcpy(local, version, 12);
2223 local[12] = 0;
2224
70848515 2225 if (sscanf(local, "RFB %03d.%03d\n", &vs->major, &vs->minor) != 2) {
28a76be8
AL		 2226 VNC_DEBUG("Malformed protocol version %s\n", local);
2227 vnc_client_error(vs);
2228 return 0;
24236869 2229 }
70848515
TS		 2230 VNC_DEBUG("Client request protocol version %d.%d\n", vs->major, vs->minor);
2231 if (vs->major != 3 ||
28a76be8
AL		 2232 (vs->minor != 3 &&
2233 vs->minor != 4 &&
2234 vs->minor != 5 &&
2235 vs->minor != 7 &&
2236 vs->minor != 8)) {
2237 VNC_DEBUG("Unsupported client version\n");
2238 vnc_write_u32(vs, VNC_AUTH_INVALID);
2239 vnc_flush(vs);
2240 vnc_client_error(vs);
2241 return 0;
70848515 2242 }
b0566f4f 2243 /* Some broken clients report v3.4 or v3.5, which spec requires to be treated
70848515
TS		 2244 * as equivalent to v3.3 by servers
2245 */
b0566f4f 2246 if (vs->minor == 4 || vs->minor == 5)
28a76be8 2247 vs->minor = 3;
70848515
TS		 2248
2249 if (vs->minor == 3) {
7e7e2ebc 2250 if (vs->auth == VNC_AUTH_NONE) {
70848515 2251 VNC_DEBUG("Tell client auth none\n");
7e7e2ebc 2252 vnc_write_u32(vs, vs->auth);
70848515 2253 vnc_flush(vs);
28a76be8 2254 start_client_init(vs);
7e7e2ebc 2255 } else if (vs->auth == VNC_AUTH_VNC) {
70848515 2256 VNC_DEBUG("Tell client VNC auth\n");
7e7e2ebc 2257 vnc_write_u32(vs, vs->auth);
70848515
TS		 2258 vnc_flush(vs);
2259 start_auth_vnc(vs);
2260 } else {
7e7e2ebc 2261 VNC_DEBUG("Unsupported auth %d for protocol 3.3\n", vs->auth);
70848515
TS		 2262 vnc_write_u32(vs, VNC_AUTH_INVALID);
2263 vnc_flush(vs);
2264 vnc_client_error(vs);
2265 }
2266 } else {
7e7e2ebc 2267 VNC_DEBUG("Telling client we support auth %d\n", vs->auth);
28a76be8 2268 vnc_write_u8(vs, 1); /* num auth */
7e7e2ebc 2269 vnc_write_u8(vs, vs->auth);
28a76be8
AL		 2270 vnc_read_when(vs, protocol_client_auth, 1);
2271 vnc_flush(vs);
70848515 2272 }
24236869
FB		 2273
2274 return 0;
2275}
2276
999342a0
CC		 2277static VncRectStat *vnc_stat_rect(VncDisplay *vd, int x, int y)
2278{
2279 struct VncSurface *vs = &vd->guest;
2280
2281 return &vs->stats[y / VNC_STAT_RECT][x / VNC_STAT_RECT];
2282}
2283
7d964c9d
CC		 2284void vnc_sent_lossy_rect(VncState *vs, int x, int y, int w, int h)
2285{
2286 int i, j;
2287
2288 w = (x + w) / VNC_STAT_RECT;
2289 h = (y + h) / VNC_STAT_RECT;
2290 x /= VNC_STAT_RECT;
2291 y /= VNC_STAT_RECT;
2292
207f328a
CC		 2293 for (j = y; j <= h; j++) {
2294 for (i = x; i <= w; i++) {
7d964c9d
CC		 2295 vs->lossy_rect[j][i] = 1;
2296 }
2297 }
2298}
2299
2300static int vnc_refresh_lossy_rect(VncDisplay *vd, int x, int y)
2301{
2302 VncState *vs;
2303 int sty = y / VNC_STAT_RECT;
2304 int stx = x / VNC_STAT_RECT;
2305 int has_dirty = 0;
2306
2307 y = y / VNC_STAT_RECT * VNC_STAT_RECT;
2308 x = x / VNC_STAT_RECT * VNC_STAT_RECT;
2309
2310 QTAILQ_FOREACH(vs, &vd->clients, next) {
bc2429b9 2311 int j;
7d964c9d
CC		 2312
2313 /* kernel send buffers are full -> refresh later */
2314 if (vs->output.offset) {
2315 continue;
2316 }
2317
2318 if (!vs->lossy_rect[sty][stx]) {
2319 continue;
2320 }
207f328a 2321
7d964c9d
CC		 2322 vs->lossy_rect[sty][stx] = 0;
2323 for (j = 0; j < VNC_STAT_RECT; ++j) {
bc2429b9 2324 bitmap_set(vs->dirty[y + j], x / 16, VNC_STAT_RECT / 16);
7d964c9d
CC		 2325 }
2326 has_dirty++;
2327 }
207f328a 2328
7d964c9d
CC		 2329 return has_dirty;
2330}
2331
2332static int vnc_update_stats(VncDisplay *vd, struct timeval * tv)
999342a0
CC		 2333{
2334 int x, y;
2335 struct timeval res;
7d964c9d 2336 int has_dirty = 0;
999342a0
CC		 2337
2338 for (y = 0; y < vd->guest.ds->height; y += VNC_STAT_RECT) {
2339 for (x = 0; x < vd->guest.ds->width; x += VNC_STAT_RECT) {
2340 VncRectStat *rect = vnc_stat_rect(vd, x, y);
2341
2342 rect->updated = false;
2343 }
2344 }
2345
ad620c29 2346 qemu_timersub(tv, &VNC_REFRESH_STATS, &res);
999342a0
CC		 2347
2348 if (timercmp(&vd->guest.last_freq_check, &res, >)) {
7d964c9d 2349 return has_dirty;
999342a0
CC		 2350 }
2351 vd->guest.last_freq_check = *tv;
2352
2353 for (y = 0; y < vd->guest.ds->height; y += VNC_STAT_RECT) {
2354 for (x = 0; x < vd->guest.ds->width; x += VNC_STAT_RECT) {
2355 VncRectStat *rect= vnc_stat_rect(vd, x, y);
2356 int count = ARRAY_SIZE(rect->times);
2357 struct timeval min, max;
2358
2359 if (!timerisset(&rect->times[count - 1])) {
2360 continue ;
2361 }
2362
2363 max = rect->times[(rect->idx + count - 1) % count];
ad620c29 2364 qemu_timersub(tv, &max, &res);
999342a0
CC		 2365
2366 if (timercmp(&res, &VNC_REFRESH_LOSSY, >)) {
2367 rect->freq = 0;
7d964c9d 2368 has_dirty += vnc_refresh_lossy_rect(vd, x, y);
999342a0
CC		 2369 memset(rect->times, 0, sizeof (rect->times));
2370 continue ;
2371 }
2372
2373 min = rect->times[rect->idx];
2374 max = rect->times[(rect->idx + count - 1) % count];
ad620c29 2375 qemu_timersub(&max, &min, &res);
999342a0
CC		 2376
2377 rect->freq = res.tv_sec + res.tv_usec / 1000000.;
2378 rect->freq /= count;
2379 rect->freq = 1. / rect->freq;
2380 }
2381 }
7d964c9d 2382 return has_dirty;
999342a0
CC		 2383}
2384
2385double vnc_update_freq(VncState *vs, int x, int y, int w, int h)
2386{
2387 int i, j;
2388 double total = 0;
2389 int num = 0;
2390
2391 x = (x / VNC_STAT_RECT) * VNC_STAT_RECT;
2392 y = (y / VNC_STAT_RECT) * VNC_STAT_RECT;
2393
2394 for (j = y; j <= y + h; j += VNC_STAT_RECT) {
2395 for (i = x; i <= x + w; i += VNC_STAT_RECT) {
2396 total += vnc_stat_rect(vs->vd, i, j)->freq;
2397 num++;
2398 }
2399 }
2400
2401 if (num) {
2402 return total / num;
2403 } else {
2404 return 0;
2405 }
2406}
2407
2408static void vnc_rect_updated(VncDisplay *vd, int x, int y, struct timeval * tv)
2409{
2410 VncRectStat *rect;
2411
2412 rect = vnc_stat_rect(vd, x, y);
2413 if (rect->updated) {
2414 return ;
2415 }
2416 rect->times[rect->idx] = *tv;
2417 rect->idx = (rect->idx + 1) % ARRAY_SIZE(rect->times);
2418 rect->updated = true;
2419}
2420
1fc62412
SS		 2421static int vnc_refresh_server_surface(VncDisplay *vd)
2422{
2423 int y;
2424 uint8_t *guest_row;
2425 uint8_t *server_row;
2426 int cmp_bytes;
41b4bef6 2427 VncState *vs;
1fc62412
SS		 2428 int has_dirty = 0;
2429
80e0c8c3 2430 struct timeval tv = { 0, 0 };
999342a0 2431
80e0c8c3
CC		 2432 if (!vd->non_adaptive) {
2433 gettimeofday(&tv, NULL);
2434 has_dirty = vnc_update_stats(vd, &tv);
2435 }
999342a0 2436
1fc62412
SS		 2437 /*
2438 * Walk through the guest dirty map.
2439 * Check and copy modified bits from guest to server surface.
2440 * Update server dirty map.
2441 */
1fc62412
SS		 2442 cmp_bytes = 16 * ds_get_bytes_per_pixel(vd->ds);
2443 guest_row = vd->guest.ds->data;
2444 server_row = vd->server->data;
2445 for (y = 0; y < vd->guest.ds->height; y++) {
23bfe28f 2446 if (!bitmap_empty(vd->guest.dirty[y], VNC_DIRTY_BITS)) {
1fc62412
SS		 2447 int x;
2448 uint8_t *guest_ptr;
2449 uint8_t *server_ptr;
2450
2451 guest_ptr = guest_row;
2452 server_ptr = server_row;
2453
ce3e1417 2454 for (x = 0; x + 15 < vd->guest.ds->width;
1fc62412 2455 x += 16, guest_ptr += cmp_bytes, server_ptr += cmp_bytes) {
bc2429b9 2456 if (!test_and_clear_bit((x / 16), vd->guest.dirty[y]))
1fc62412 2457 continue;
1fc62412
SS		 2458 if (memcmp(server_ptr, guest_ptr, cmp_bytes) == 0)
2459 continue;
2460 memcpy(server_ptr, guest_ptr, cmp_bytes);
80e0c8c3
CC		 2461 if (!vd->non_adaptive)
2462 vnc_rect_updated(vd, x, y, &tv);
41b4bef6 2463 QTAILQ_FOREACH(vs, &vd->clients, next) {
bc2429b9 2464 set_bit((x / 16), vs->dirty[y]);
1fc62412
SS		 2465 }
2466 has_dirty++;
2467 }
2468 }
2469 guest_row += ds_get_linesize(vd->ds);
2470 server_row += ds_get_linesize(vd->ds);
2471 }
2472 return has_dirty;
2473}
2474
703bc68f
SS		 2475static void vnc_refresh(void *opaque)
2476{
2477 VncDisplay *vd = opaque;
41b4bef6
AS		 2478 VncState *vs, *vn;
2479 int has_dirty, rects = 0;
703bc68f
SS		 2480
2481 vga_hw_update();
2482
bd023f95
CC		 2483 if (vnc_trylock_display(vd)) {
2484 vd->timer_interval = VNC_REFRESH_INTERVAL_BASE;
7bd427d8 2485 qemu_mod_timer(vd->timer, qemu_get_clock_ms(rt_clock) +
bd023f95
CC		 2486 vd->timer_interval);
2487 return;
2488 }
2489
1fc62412 2490 has_dirty = vnc_refresh_server_surface(vd);
bd023f95 2491 vnc_unlock_display(vd);
1fc62412 2492
41b4bef6 2493 QTAILQ_FOREACH_SAFE(vs, &vd->clients, next, vn) {
2430ffe4 2494 rects += vnc_update_client(vs, has_dirty);
6185c578 2495 /* vs might be free()ed here */
703bc68f 2496 }
bd023f95 2497
83755c17
SS		 2498 /* vd->timer could be NULL now if the last client disconnected,
2499 * in this case don't update the timer */
2500 if (vd->timer == NULL)
2501 return;
703bc68f 2502
2430ffe4
SS		 2503 if (has_dirty && rects) {
2504 vd->timer_interval /= 2;
2505 if (vd->timer_interval < VNC_REFRESH_INTERVAL_BASE)
2506 vd->timer_interval = VNC_REFRESH_INTERVAL_BASE;
2507 } else {
2508 vd->timer_interval += VNC_REFRESH_INTERVAL_INC;
2509 if (vd->timer_interval > VNC_REFRESH_INTERVAL_MAX)
2510 vd->timer_interval = VNC_REFRESH_INTERVAL_MAX;
2511 }
7bd427d8 2512 qemu_mod_timer(vd->timer, qemu_get_clock_ms(rt_clock) + vd->timer_interval);
703bc68f
SS		 2513}
2514
2515static void vnc_init_timer(VncDisplay *vd)
2516{
2430ffe4 2517 vd->timer_interval = VNC_REFRESH_INTERVAL_BASE;
41b4bef6 2518 if (vd->timer == NULL && !QTAILQ_EMPTY(&vd->clients)) {
7bd427d8 2519 vd->timer = qemu_new_timer_ms(rt_clock, vnc_refresh, vd);
5db8378a 2520 vnc_dpy_resize(vd->ds);
1fc62412 2521 vnc_refresh(vd);
703bc68f
SS		 2522 }
2523}
2524
2525static void vnc_remove_timer(VncDisplay *vd)
2526{
41b4bef6 2527 if (vd->timer != NULL && QTAILQ_EMPTY(&vd->clients)) {
703bc68f
SS		 2528 qemu_del_timer(vd->timer);
2529 qemu_free_timer(vd->timer);
2530 vd->timer = NULL;
2531 }
2532}
2533
7e7e2ebc 2534static void vnc_connect(VncDisplay *vd, int csock, int skipauth)
3aa3eea3 2535{
7267c094 2536 VncState *vs = g_malloc0(sizeof(VncState));
7d964c9d
CC		 2537 int i;
2538
753b4053 2539 vs->csock = csock;
7e7e2ebc
DB		 2540
2541 if (skipauth) {
2542 vs->auth = VNC_AUTH_NONE;
2543#ifdef CONFIG_VNC_TLS
2544 vs->subauth = VNC_AUTH_INVALID;
2545#endif
2546 } else {
2547 vs->auth = vd->auth;
2548#ifdef CONFIG_VNC_TLS
2549 vs->subauth = vd->subauth;
2550#endif
2551 }
2552
7267c094 2553 vs->lossy_rect = g_malloc0(VNC_STAT_ROWS * sizeof (*vs->lossy_rect));
7d964c9d 2554 for (i = 0; i < VNC_STAT_ROWS; ++i) {
7267c094 2555 vs->lossy_rect[i] = g_malloc0(VNC_STAT_COLS * sizeof (uint8_t));
7d964c9d 2556 }
753b4053
AL		 2557
2558 VNC_DEBUG("New client on socket %d\n", csock);
7d957bd8 2559 dcl->idle = 0;
3aa3eea3
AZ		 2560 socket_set_nonblock(vs->csock);
2561 qemu_set_fd_handler2(vs->csock, NULL, vnc_client_read, NULL, vs);
753b4053 2562
4a80dba3 2563 vnc_client_cache_addr(vs);
586153d9 2564 vnc_qmp_event(vs, QEVENT_VNC_CONNECTED);
4a80dba3 2565
753b4053
AL		 2566 vs->vd = vd;
2567 vs->ds = vd->ds;
753b4053
AL		 2568 vs->last_x = -1;
2569 vs->last_y = -1;
2570
2571 vs->as.freq = 44100;
2572 vs->as.nchannels = 2;
2573 vs->as.fmt = AUD_FMT_S16;
2574 vs->as.endianness = 0;
2575
bd023f95
CC		 2576#ifdef CONFIG_VNC_THREAD
2577 qemu_mutex_init(&vs->output_mutex);
2578#endif
2579
41b4bef6 2580 QTAILQ_INSERT_HEAD(&vd->clients, vs, next);
1fc62412
SS		 2581
2582 vga_hw_update();
2583
3aa3eea3
AZ		 2584 vnc_write(vs, "RFB 003.008\n", 12);
2585 vnc_flush(vs);
2586 vnc_read_when(vs, protocol_version, 12);
53762ddb 2587 reset_keys(vs);
3a0558b5
GH		 2588 if (vs->vd->lock_key_sync)
2589 vs->led = qemu_add_led_event_handler(kbd_leds, vs);
753b4053 2590
37c34d9d
AL		 2591 vs->mouse_mode_notifier.notify = check_pointer_type_change;
2592 qemu_add_mouse_mode_change_notifier(&vs->mouse_mode_notifier);
2593
703bc68f 2594 vnc_init_timer(vd);
1fc62412 2595
198a0039 2596 /* vs might be free()ed here */
3aa3eea3
AZ		 2597}
2598
24236869
FB		 2599static void vnc_listen_read(void *opaque)
2600{
753b4053 2601 VncDisplay *vs = opaque;
24236869
FB		 2602 struct sockaddr_in addr;
2603 socklen_t addrlen = sizeof(addr);
2604
9f60ad50
AZ		 2605 /* Catch-up */
2606 vga_hw_update();
2607
40ff6d7e 2608 int csock = qemu_accept(vs->lsock, (struct sockaddr *)&addr, &addrlen);
753b4053 2609 if (csock != -1) {
7e7e2ebc 2610 vnc_connect(vs, csock, 0);
24236869
FB		 2611 }
2612}
2613
71cab5ca 2614void vnc_display_init(DisplayState *ds)
24236869 2615{
7267c094 2616 VncDisplay *vs = g_malloc0(sizeof(*vs));
24236869 2617
7267c094 2618 dcl = g_malloc0(sizeof(DisplayChangeListener));
24236869
FB		 2619
2620 ds->opaque = vs;
7d957bd8 2621 dcl->idle = 1;
753b4053 2622 vnc_display = vs;
24236869
FB		 2623
2624 vs->lsock = -1;
24236869
FB		 2625
2626 vs->ds = ds;
41b4bef6 2627 QTAILQ_INIT(&vs->clients);
3c9405a0 2628 vs->expires = TIME_MAX;
24236869 2629
9ca313aa 2630 if (keyboard_layout)
0483755a 2631 vs->kbd_layout = init_keyboard_layout(name2keysym, keyboard_layout);
9ca313aa 2632 else
0483755a 2633 vs->kbd_layout = init_keyboard_layout(name2keysym, "en-us");
24236869 2634
24236869 2635 if (!vs->kbd_layout)
28a76be8 2636 exit(1);
24236869 2637
bd023f95
CC		 2638#ifdef CONFIG_VNC_THREAD
2639 qemu_mutex_init(&vs->mutex);
2640 vnc_start_worker_thread();
2641#endif
2642
753b4053 2643 dcl->dpy_copy = vnc_dpy_copy;
7d957bd8
AL		 2644 dcl->dpy_update = vnc_dpy_update;
2645 dcl->dpy_resize = vnc_dpy_resize;
2646 dcl->dpy_setdata = vnc_dpy_setdata;
7d957bd8 2647 register_displaychangelistener(ds, dcl);
d467b679
GH		 2648 ds->mouse_set = vnc_mouse_set;
2649 ds->cursor_define = vnc_dpy_cursor_define;
71cab5ca
TS		 2650}
2651
6f43024c 2652
71cab5ca
TS		 2653void vnc_display_close(DisplayState *ds)
2654{
753b4053 2655 VncDisplay *vs = ds ? (VncDisplay *)ds->opaque : vnc_display;
71cab5ca 2656
452b4d88
AL		 2657 if (!vs)
2658 return;
71cab5ca 2659 if (vs->display) {
7267c094 2660 g_free(vs->display);
28a76be8 2661 vs->display = NULL;
71cab5ca
TS		 2662 }
2663 if (vs->lsock != -1) {
28a76be8
AL		 2664 qemu_set_fd_handler2(vs->lsock, NULL, NULL, NULL, NULL);
2665 close(vs->lsock);
2666 vs->lsock = -1;
71cab5ca 2667 }
70848515 2668 vs->auth = VNC_AUTH_INVALID;
eb38c52c 2669#ifdef CONFIG_VNC_TLS
8d5d2d4c 2670 vs->subauth = VNC_AUTH_INVALID;
5fb6c7a8 2671 vs->tls.x509verify = 0;
8d5d2d4c 2672#endif
70848515
TS		 2673}
2674
1cd20f8b
AL		 2675int vnc_display_disable_login(DisplayState *ds)
2676{
2677 VncDisplay *vs = ds ? (VncDisplay *)ds->opaque : vnc_display;
2678
2679 if (!vs) {
2680 return -1;
2681 }
2682
2683 if (vs->password) {
7267c094 2684 g_free(vs->password);
1cd20f8b
AL		 2685 }
2686
2687 vs->password = NULL;
2688 vs->auth = VNC_AUTH_VNC;
2689
2690 return 0;
2691}
2692
70848515
TS		 2693int vnc_display_password(DisplayState *ds, const char *password)
2694{
753b4053 2695 VncDisplay *vs = ds ? (VncDisplay *)ds->opaque : vnc_display;
70848515 2696
7ef92331 2697 if (!vs) {
a6aa9d3e 2698 return -EINVAL;
7ef92331
ZA		 2699 }
2700
1cd20f8b
AL		 2701 if (!password) {
2702 /* This is not the intention of this interface but err on the side
2703 of being safe */
a6aa9d3e 2704 return vnc_display_disable_login(ds);
1cd20f8b
AL		 2705 }
2706
70848515 2707 if (vs->password) {
7267c094 2708 g_free(vs->password);
28a76be8 2709 vs->password = NULL;
70848515 2710 }
7267c094 2711 vs->password = g_strdup(password);
1cd20f8b 2712 vs->auth = VNC_AUTH_VNC;
a6aa9d3e
LC		 2713
2714 return 0;
71cab5ca
TS		 2715}
2716
3c9405a0
GH		 2717int vnc_display_pw_expire(DisplayState *ds, time_t expires)
2718{
2719 VncDisplay *vs = ds ? (VncDisplay *)ds->opaque : vnc_display;
2720
2721 vs->expires = expires;
2722 return 0;
2723}
2724
f92f8afe
AL		 2725char *vnc_display_local_addr(DisplayState *ds)
2726{
2727 VncDisplay *vs = ds ? (VncDisplay *)ds->opaque : vnc_display;
2728
2729 return vnc_socket_local_addr("%s:%s", vs->lsock);
2730}
2731
70848515 2732int vnc_display_open(DisplayState *ds, const char *display)
71cab5ca 2733{
753b4053 2734 VncDisplay *vs = ds ? (VncDisplay *)ds->opaque : vnc_display;
70848515
TS		 2735 const char *options;
2736 int password = 0;
3aa3eea3 2737 int reverse = 0;
eb38c52c 2738#ifdef CONFIG_VNC_TLS
3a702699 2739 int tls = 0, x509 = 0;
8d5d2d4c 2740#endif
2f9606b3
AL		 2741#ifdef CONFIG_VNC_SASL
2742 int sasl = 0;
2743 int saslErr;
2744#endif
2ded6ad7 2745#if defined(CONFIG_VNC_TLS) || defined(CONFIG_VNC_SASL)
76655d6d 2746 int acl = 0;
2ded6ad7 2747#endif
3a0558b5 2748 int lock_key_sync = 1;
71cab5ca 2749
753b4053 2750 if (!vnc_display)
452b4d88 2751 return -1;
71cab5ca 2752 vnc_display_close(ds);
70848515 2753 if (strcmp(display, "none") == 0)
28a76be8 2754 return 0;
24236869 2755
70848515 2756 if (!(vs->display = strdup(display)))
28a76be8 2757 return -1;
70848515
TS		 2758
2759 options = display;
2760 while ((options = strchr(options, ','))) {
28a76be8
AL		 2761 options++;
2762 if (strncmp(options, "password", 8) == 0) {
2763 password = 1; /* Require password auth */
2764 } else if (strncmp(options, "reverse", 7) == 0) {
2765 reverse = 1;
cee8e6ad 2766 } else if (strncmp(options, "no-lock-key-sync", 16) == 0) {
3a0558b5 2767 lock_key_sync = 0;
2f9606b3 2768#ifdef CONFIG_VNC_SASL
28a76be8
AL		 2769 } else if (strncmp(options, "sasl", 4) == 0) {
2770 sasl = 1; /* Require SASL auth */
2f9606b3 2771#endif
eb38c52c 2772#ifdef CONFIG_VNC_TLS
28a76be8
AL		 2773 } else if (strncmp(options, "tls", 3) == 0) {
2774 tls = 1; /* Require TLS */
2775 } else if (strncmp(options, "x509", 4) == 0) {
2776 char *start, *end;
2777 x509 = 1; /* Require x509 certificates */
2778 if (strncmp(options, "x509verify", 10) == 0)
2779 vs->tls.x509verify = 1; /* ...and verify client certs */
2780
2781 /* Now check for 'x509=/some/path' postfix
2782 * and use that to setup x509 certificate/key paths */
2783 start = strchr(options, '=');
2784 end = strchr(options, ',');
2785 if (start && (!end || (start < end))) {
2786 int len = end ? end-(start+1) : strlen(start+1);
7267c094 2787 char *path = g_strndup(start + 1, len);
28a76be8
AL		 2788
2789 VNC_DEBUG("Trying certificate path '%s'\n", path);
2790 if (vnc_tls_set_x509_creds_dir(vs, path) < 0) {
2791 fprintf(stderr, "Failed to find x509 certificates/keys in %s\n", path);
7267c094
AL		 2792 g_free(path);
2793 g_free(vs->display);
28a76be8
AL		 2794 vs->display = NULL;
2795 return -1;
2796 }
7267c094 2797 g_free(path);
28a76be8
AL		 2798 } else {
2799 fprintf(stderr, "No certificate path provided\n");
7267c094 2800 g_free(vs->display);
28a76be8
AL		 2801 vs->display = NULL;
2802 return -1;
2803 }
8d5d2d4c 2804#endif
2ded6ad7 2805#if defined(CONFIG_VNC_TLS) || defined(CONFIG_VNC_SASL)
28a76be8
AL		 2806 } else if (strncmp(options, "acl", 3) == 0) {
2807 acl = 1;
2ded6ad7 2808#endif
6f9c78c1
CC		 2809 } else if (strncmp(options, "lossy", 5) == 0) {
2810 vs->lossy = true;
80e0c8c3
CC		 2811 } else if (strncmp(options, "non-adapative", 13) == 0) {
2812 vs->non_adaptive = true;
28a76be8 2813 }
70848515
TS		 2814 }
2815
76655d6d
AL		 2816#ifdef CONFIG_VNC_TLS
2817 if (acl && x509 && vs->tls.x509verify) {
28a76be8
AL		 2818 if (!(vs->tls.acl = qemu_acl_init("vnc.x509dname"))) {
2819 fprintf(stderr, "Failed to create x509 dname ACL\n");
2820 exit(1);
2821 }
76655d6d
AL		 2822 }
2823#endif
2824#ifdef CONFIG_VNC_SASL
2825 if (acl && sasl) {
28a76be8
AL		 2826 if (!(vs->sasl.acl = qemu_acl_init("vnc.username"))) {
2827 fprintf(stderr, "Failed to create username ACL\n");
2828 exit(1);
2829 }
76655d6d
AL		 2830 }
2831#endif
2832
2f9606b3
AL		 2833 /*
2834 * Combinations we support here:
2835 *
2836 * - no-auth (clear text, no auth)
2837 * - password (clear text, weak auth)
2838 * - sasl (encrypt, good auth *IF* using Kerberos via GSSAPI)
2839 * - tls (encrypt, weak anonymous creds, no auth)
2840 * - tls + password (encrypt, weak anonymous creds, weak auth)
2841 * - tls + sasl (encrypt, weak anonymous creds, good auth)
2842 * - tls + x509 (encrypt, good x509 creds, no auth)
2843 * - tls + x509 + password (encrypt, good x509 creds, weak auth)
2844 * - tls + x509 + sasl (encrypt, good x509 creds, good auth)
2845 *
2846 * NB1. TLS is a stackable auth scheme.
2847 * NB2. the x509 schemes have option to validate a client cert dname
2848 */
70848515 2849 if (password) {
eb38c52c 2850#ifdef CONFIG_VNC_TLS
28a76be8
AL		 2851 if (tls) {
2852 vs->auth = VNC_AUTH_VENCRYPT;
2853 if (x509) {
2854 VNC_DEBUG("Initializing VNC server with x509 password auth\n");
2855 vs->subauth = VNC_AUTH_VENCRYPT_X509VNC;
2856 } else {
2857 VNC_DEBUG("Initializing VNC server with TLS password auth\n");
2858 vs->subauth = VNC_AUTH_VENCRYPT_TLSVNC;
2859 }
2860 } else {
2f9606b3 2861#endif /* CONFIG_VNC_TLS */
28a76be8
AL		 2862 VNC_DEBUG("Initializing VNC server with password auth\n");
2863 vs->auth = VNC_AUTH_VNC;
eb38c52c 2864#ifdef CONFIG_VNC_TLS
28a76be8
AL		 2865 vs->subauth = VNC_AUTH_INVALID;
2866 }
2f9606b3
AL		 2867#endif /* CONFIG_VNC_TLS */
2868#ifdef CONFIG_VNC_SASL
2869 } else if (sasl) {
2870#ifdef CONFIG_VNC_TLS
2871 if (tls) {
2872 vs->auth = VNC_AUTH_VENCRYPT;
2873 if (x509) {
28a76be8 2874 VNC_DEBUG("Initializing VNC server with x509 SASL auth\n");
2f9606b3
AL		 2875 vs->subauth = VNC_AUTH_VENCRYPT_X509SASL;
2876 } else {
28a76be8 2877 VNC_DEBUG("Initializing VNC server with TLS SASL auth\n");
2f9606b3
AL		 2878 vs->subauth = VNC_AUTH_VENCRYPT_TLSSASL;
2879 }
2880 } else {
2881#endif /* CONFIG_VNC_TLS */
28a76be8 2882 VNC_DEBUG("Initializing VNC server with SASL auth\n");
2f9606b3
AL		 2883 vs->auth = VNC_AUTH_SASL;
2884#ifdef CONFIG_VNC_TLS
2885 vs->subauth = VNC_AUTH_INVALID;
2886 }
2887#endif /* CONFIG_VNC_TLS */
2888#endif /* CONFIG_VNC_SASL */
70848515 2889 } else {
eb38c52c 2890#ifdef CONFIG_VNC_TLS
28a76be8
AL		 2891 if (tls) {
2892 vs->auth = VNC_AUTH_VENCRYPT;
2893 if (x509) {
2894 VNC_DEBUG("Initializing VNC server with x509 no auth\n");
2895 vs->subauth = VNC_AUTH_VENCRYPT_X509NONE;
2896 } else {
2897 VNC_DEBUG("Initializing VNC server with TLS no auth\n");
2898 vs->subauth = VNC_AUTH_VENCRYPT_TLSNONE;
2899 }
2900 } else {
8d5d2d4c 2901#endif
28a76be8
AL		 2902 VNC_DEBUG("Initializing VNC server with no auth\n");
2903 vs->auth = VNC_AUTH_NONE;
eb38c52c 2904#ifdef CONFIG_VNC_TLS
28a76be8
AL		 2905 vs->subauth = VNC_AUTH_INVALID;
2906 }
8d5d2d4c 2907#endif
70848515 2908 }
24236869 2909
2f9606b3
AL		 2910#ifdef CONFIG_VNC_SASL
2911 if ((saslErr = sasl_server_init(NULL, "qemu")) != SASL_OK) {
2912 fprintf(stderr, "Failed to initialize SASL auth %s",
2913 sasl_errstring(saslErr, NULL, NULL));
ae878b17 2914 g_free(vs->display);
2f9606b3
AL		 2915 vs->display = NULL;
2916 return -1;
2917 }
2918#endif
3a0558b5 2919 vs->lock_key_sync = lock_key_sync;
2f9606b3 2920
3aa3eea3 2921 if (reverse) {
9712ecaf
AL		 2922 /* connect to viewer */
2923 if (strncmp(display, "unix:", 5) == 0)
2924 vs->lsock = unix_connect(display+5);
2925 else
2926 vs->lsock = inet_connect(display, SOCK_STREAM);
2927 if (-1 == vs->lsock) {
ae878b17 2928 g_free(vs->display);
3aa3eea3
AZ		 2929 vs->display = NULL;
2930 return -1;
2931 } else {
753b4053 2932 int csock = vs->lsock;
3aa3eea3 2933 vs->lsock = -1;
7e7e2ebc 2934 vnc_connect(vs, csock, 0);
3aa3eea3 2935 }
9712ecaf 2936 return 0;
24236869 2937
9712ecaf
AL		 2938 } else {
2939 /* listen for connects */
2940 char *dpy;
7267c094 2941 dpy = g_malloc(256);
9712ecaf 2942 if (strncmp(display, "unix:", 5) == 0) {
bc575e95 2943 pstrcpy(dpy, 256, "unix:");
4a55bfdf 2944 vs->lsock = unix_listen(display+5, dpy+5, 256-5);
9712ecaf
AL		 2945 } else {
2946 vs->lsock = inet_listen(display, dpy, 256, SOCK_STREAM, 5900);
2947 }
2948 if (-1 == vs->lsock) {
ae878b17 2949 g_free(dpy);
d0513623 2950 return -1;
9712ecaf 2951 } else {
ae878b17 2952 g_free(vs->display);
9712ecaf
AL		 2953 vs->display = dpy;
2954 }
24236869 2955 }
753b4053 2956 return qemu_set_fd_handler2(vs->lsock, NULL, vnc_listen_read, NULL, vs);
24236869 2957}
13661089
DB		 2958
2959void vnc_display_add_client(DisplayState *ds, int csock, int skipauth)
2960{
2961 VncDisplay *vs = ds ? (VncDisplay *)ds->opaque : vnc_display;
2962
2963 return vnc_connect(vs, csock, skipauth);
2964}
Empty description
This page took 1.078264 seconds and 4 git commands to generate.