?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
guest agent: add RPC blacklist command-line option
[qemu/qmp-unstable.git] / ui / vnc.c
blobe85ee66fb0063f8128f000d27c1bf6e454a4749c
1 /*
2 * QEMU VNC display driver
3 *
4 * Copyright (C) 2006 Anthony Liguori <anthony@codemonkey.ws>
5 * Copyright (C) 2006 Fabrice Bellard
6 * Copyright (C) 2009 Red Hat, Inc
7 *
8 * Permission is hereby granted, free of charge, to any person obtaining a copy
9 * of this software and associated documentation files (the "Software"), to deal
10 * in the Software without restriction, including without limitation the rights
11 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12 * copies of the Software, and to permit persons to whom the Software is
13 * furnished to do so, subject to the following conditions:
14 *
15 * The above copyright notice and this permission notice shall be included in
16 * all copies or substantial portions of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
21 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 * THE SOFTWARE.
25 */
26
27 #include "vnc.h"
28 #include "vnc-jobs.h"
29 #include "sysemu.h"
30 #include "qemu_socket.h"
31 #include "qemu-timer.h"
32 #include "acl.h"
33 #include "qemu-objects.h"
34 #include "qmp-commands.h"
35
36 #define VNC_REFRESH_INTERVAL_BASE 30
37 #define VNC_REFRESH_INTERVAL_INC 50
38 #define VNC_REFRESH_INTERVAL_MAX 2000
39 static const struct timeval VNC_REFRESH_STATS = { 0, 500000 };
40 static const struct timeval VNC_REFRESH_LOSSY = { 2, 0 };
41
42 #include "vnc_keysym.h"
43 #include "d3des.h"
44
45 static VncDisplay *vnc_display; /* needed for info vnc */
46 static DisplayChangeListener *dcl;
47
48 static int vnc_cursor_define(VncState *vs);
49
50 static 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;
57 size_t addrlen;
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
68 /* Enough for the existing format + the 2 vars we're
69 * substituting in. */
70 addrlen = strlen(format) + strlen(host) + strlen(serv);
71 addr = g_malloc(addrlen + 1);
72 snprintf(addr, addrlen, format, host, serv);
73 addr[addrlen] = '\0';
74
75 return addr;
76 }
77
78
79 char *vnc_socket_local_addr(const char *format, int fd) {
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
90 char *vnc_socket_remote_addr(const char *format, int fd) {
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
101 static 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));
119 qdict_put(qdict, "family",qstring_from_str(inet_strfamily(sa->ss_family)));
120
121 return 0;
122 }
123
124 static int vnc_server_addr_put(QDict *qdict, int fd)
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
137 static 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
150 static 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";
185 case VNC_AUTH_VENCRYPT_TLSSASL:
186 return "vencrypt+tls+sasl";
187 case VNC_AUTH_VENCRYPT_X509SASL:
188 return "vencrypt+x509+sasl";
189 default:
190 return "vencrypt";
191 }
192 #else
193 return "vencrypt";
194 #endif
195 case VNC_AUTH_SASL:
196 return "sasl";
197 }
198 return "unknown";
199 }
200
201 static 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
211 static void vnc_client_cache_auth(VncState *client)
212 {
213 #if defined(CONFIG_VNC_TLS) || defined(CONFIG_VNC_SASL)
214 QDict *qdict;
215 #endif
216
217 if (!client->info) {
218 return;
219 }
220
221 #if defined(CONFIG_VNC_TLS) || defined(CONFIG_VNC_SASL)
222 qdict = qobject_to_qdict(client->info);
223 #endif
224
225 #ifdef CONFIG_VNC_TLS
226 if (client->tls.session &&
227 client->tls.dname) {
228 qdict_put(qdict, "x509_dname", qstring_from_str(client->tls.dname));
229 }
230 #endif
231 #ifdef CONFIG_VNC_SASL
232 if (client->sasl.conn &&
233 client->sasl.username) {
234 qdict_put(qdict, "sasl_username",
235 qstring_from_str(client->sasl.username));
236 }
237 #endif
238 }
239
240 static 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);
252 }
253
254 static 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
278 static VncClientInfo *qmp_query_vnc_client(const VncState *client)
279 {
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 }
296
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));
301
302 #ifdef CONFIG_VNC_TLS
303 if (client->tls.session && client->tls.dname) {
304 info->has_x509_dname = true;
305 info->x509_dname = g_strdup(client->tls.dname);
306 }
307 #endif
308 #ifdef CONFIG_VNC_SASL
309 if (client->sasl.conn && client->sasl.username) {
310 info->has_sasl_username = true;
311 info->sasl_username = g_strdup(client->sasl.username);
312 }
313 #endif
314
315 return info;
316 }
317
318 VncInfo *qmp_query_vnc(Error **errp)
319 {
320 VncInfo *info = g_malloc0(sizeof(*info));
321
322 if (vnc_display == NULL || vnc_display->display == NULL) {
323 info->enabled = false;
324 } else {
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];
330 VncState *client;
331
332 info->enabled = true;
333
334 /* for compatibility with the original command */
335 info->has_clients = true;
336
337 QTAILQ_FOREACH(client, &vnc_display->clients, next) {
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;
347 }
348 }
349
350 if (getsockname(vnc_display->lsock, (struct sockaddr *)&sa,
351 &salen) == -1) {
352 error_set(errp, QERR_UNDEFINED_ERROR);
353 goto out_error;
354 }
355
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;
362 }
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));
375 }
376
377 return info;
378
379 out_error:
380 qapi_free_VncInfo(info);
381 return NULL;
382 }
383
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
391 static int vnc_update_client(VncState *vs, int has_dirty);
392 static int vnc_update_client_sync(VncState *vs, int has_dirty);
393 static void vnc_disconnect_start(VncState *vs);
394 static void vnc_disconnect_finish(VncState *vs);
395 static void vnc_init_timer(VncDisplay *vd);
396 static void vnc_remove_timer(VncDisplay *vd);
397
398 static void vnc_colordepth(VncState *vs);
399 static void framebuffer_update_request(VncState *vs, int incremental,
400 int x_position, int y_position,
401 int w, int h);
402 static void vnc_refresh(void *opaque);
403 static int vnc_refresh_server_surface(VncDisplay *vd);
404
405 static void vnc_dpy_update(DisplayState *ds, int x, int y, int w, int h)
406 {
407 int i;
408 VncDisplay *vd = ds->opaque;
409 struct VncSurface *s = &vd->guest;
410
411 h += y;
412
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
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);
424
425 for (; y < h; y++)
426 for (i = 0; i < w; i += 16)
427 set_bit((x + i) / 16, s->dirty[y]);
428 }
429
430 void vnc_framebuffer_update(VncState *vs, int x, int y, int w, int h,
431 int32_t encoding)
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
441 void buffer_reserve(Buffer *buffer, size_t len)
442 {
443 if ((buffer->capacity - buffer->offset) < len) {
444 buffer->capacity += (len + 1024);
445 buffer->buffer = g_realloc(buffer->buffer, buffer->capacity);
446 if (buffer->buffer == NULL) {
447 fprintf(stderr, "vnc: out of memory\n");
448 exit(1);
449 }
450 }
451 }
452
453 int buffer_empty(Buffer *buffer)
454 {
455 return buffer->offset == 0;
456 }
457
458 uint8_t *buffer_end(Buffer *buffer)
459 {
460 return buffer->buffer + buffer->offset;
461 }
462
463 void buffer_reset(Buffer *buffer)
464 {
465 buffer->offset = 0;
466 }
467
468 void buffer_free(Buffer *buffer)
469 {
470 g_free(buffer->buffer);
471 buffer->offset = 0;
472 buffer->capacity = 0;
473 buffer->buffer = NULL;
474 }
475
476 void buffer_append(Buffer *buffer, const void *data, size_t len)
477 {
478 memcpy(buffer->buffer + buffer->offset, data, len);
479 buffer->offset += len;
480 }
481
482 static 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 }
489 if (vs->client_width == ds_get_width(ds) &&
490 vs->client_height == ds_get_height(ds)) {
491 return;
492 }
493 vs->client_width = ds_get_width(ds);
494 vs->client_height = ds_get_height(ds);
495 vnc_lock_output(vs);
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 */
499 vnc_framebuffer_update(vs, 0, 0, vs->client_width, vs->client_height,
500 VNC_ENCODING_DESKTOPRESIZE);
501 vnc_unlock_output(vs);
502 vnc_flush(vs);
503 }
504
505 #ifdef CONFIG_VNC_THREAD
506 static 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
525 static void vnc_abort_display_jobs(VncDisplay *vd)
526 {
527 }
528 #endif
529
530 static void vnc_dpy_resize(DisplayState *ds)
531 {
532 VncDisplay *vd = ds->opaque;
533 VncState *vs;
534
535 vnc_abort_display_jobs(vd);
536
537 /* server surface */
538 if (!vd->server)
539 vd->server = g_malloc0(sizeof(*vd->server));
540 if (vd->server->data)
541 g_free(vd->server->data);
542 *(vd->server) = *(ds->surface);
543 vd->server->data = g_malloc0(vd->server->linesize *
544 vd->server->height);
545
546 /* guest surface */
547 if (!vd->guest.ds)
548 vd->guest.ds = g_malloc0(sizeof(*vd->guest.ds));
549 if (ds_get_bytes_per_pixel(ds) != vd->guest.ds->pf.bytes_per_pixel)
550 console_color_init(ds);
551 *(vd->guest.ds) = *(ds->surface);
552 memset(vd->guest.dirty, 0xFF, sizeof(vd->guest.dirty));
553
554 QTAILQ_FOREACH(vs, &vd->clients, next) {
555 vnc_colordepth(vs);
556 vnc_desktop_resize(vs);
557 if (vs->vd->cursor) {
558 vnc_cursor_define(vs);
559 }
560 memset(vs->dirty, 0xFF, sizeof(vs->dirty));
561 }
562 }
563
564 /* fastest code */
565 static void vnc_write_pixels_copy(VncState *vs, struct PixelFormat *pf,
566 void *pixels, int size)
567 {
568 vnc_write(vs, pixels, size);
569 }
570
571 /* slowest but generic code. */
572 void vnc_convert_pixel(VncState *vs, uint8_t *buf, uint32_t v)
573 {
574 uint8_t r, g, b;
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);
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) {
587 case 1:
588 buf[0] = v;
589 break;
590 case 2:
591 if (vs->clientds.flags & QEMU_BIG_ENDIAN_FLAG) {
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:
601 if (vs->clientds.flags & QEMU_BIG_ENDIAN_FLAG) {
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
616 static void vnc_write_pixels_generic(VncState *vs, struct PixelFormat *pf,
617 void *pixels1, int size)
618 {
619 uint8_t buf[4];
620
621 if (pf->bytes_per_pixel == 4) {
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]);
627 vnc_write(vs, buf, vs->clientds.pf.bytes_per_pixel);
628 }
629 } else if (pf->bytes_per_pixel == 2) {
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]);
635 vnc_write(vs, buf, vs->clientds.pf.bytes_per_pixel);
636 }
637 } else if (pf->bytes_per_pixel == 1) {
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]);
643 vnc_write(vs, buf, vs->clientds.pf.bytes_per_pixel);
644 }
645 } else {
646 fprintf(stderr, "vnc_write_pixels_generic: VncState color depth not supported\n");
647 }
648 }
649
650 int vnc_raw_send_framebuffer_update(VncState *vs, int x, int y, int w, int h)
651 {
652 int i;
653 uint8_t *row;
654 VncDisplay *vd = vs->vd;
655
656 row = vd->server->data + y * ds_get_linesize(vs->ds) + x * ds_get_bytes_per_pixel(vs->ds);
657 for (i = 0; i < h; i++) {
658 vs->write_pixels(vs, &vd->server->pf, row, w * ds_get_bytes_per_pixel(vs->ds));
659 row += ds_get_linesize(vs->ds);
660 }
661 return 1;
662 }
663
664 int vnc_send_framebuffer_update(VncState *vs, int x, int y, int w, int h)
665 {
666 int n = 0;
667
668 switch(vs->vnc_encoding) {
669 case VNC_ENCODING_ZLIB:
670 n = vnc_zlib_send_framebuffer_update(vs, x, y, w, h);
671 break;
672 case VNC_ENCODING_HEXTILE:
673 vnc_framebuffer_update(vs, x, y, w, h, VNC_ENCODING_HEXTILE);
674 n = vnc_hextile_send_framebuffer_update(vs, x, y, w, h);
675 break;
676 case VNC_ENCODING_TIGHT:
677 n = vnc_tight_send_framebuffer_update(vs, x, y, w, h);
678 break;
679 case VNC_ENCODING_TIGHT_PNG:
680 n = vnc_tight_png_send_framebuffer_update(vs, x, y, w, h);
681 break;
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;
688 default:
689 vnc_framebuffer_update(vs, x, y, w, h, VNC_ENCODING_RAW);
690 n = vnc_raw_send_framebuffer_update(vs, x, y, w, h);
691 break;
692 }
693 return n;
694 }
695
696 static void vnc_copy(VncState *vs, int src_x, int src_y, int dst_x, int dst_y, int w, int h)
697 {
698 /* send bitblit op to the vnc client */
699 vnc_lock_output(vs);
700 vnc_write_u8(vs, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE);
701 vnc_write_u8(vs, 0);
702 vnc_write_u16(vs, 1); /* number of rects */
703 vnc_framebuffer_update(vs, dst_x, dst_y, w, h, VNC_ENCODING_COPYRECT);
704 vnc_write_u16(vs, src_x);
705 vnc_write_u16(vs, src_y);
706 vnc_unlock_output(vs);
707 vnc_flush(vs);
708 }
709
710 static 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;
713 VncState *vs, *vn;
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;
718
719 vnc_refresh_server_surface(vd);
720 QTAILQ_FOREACH_SAFE(vs, &vd->clients, next, vn) {
721 if (vnc_has_feature(vs, VNC_FEATURE_COPYRECT)) {
722 vs->force_update = 1;
723 vnc_update_client_sync(vs, 1);
724 /* vs might be free()ed here */
725 }
726 }
727
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);
764 QTAILQ_FOREACH(vs, &vd->clients, next) {
765 if (!vnc_has_feature(vs, VNC_FEATURE_COPYRECT)) {
766 set_bit(((x + dst_x) / 16), vs->dirty[y]);
767 }
768 }
769 }
770 src_row += pitch - w * depth;
771 dst_row += pitch - w * depth;
772 y += inc;
773 }
774
775 QTAILQ_FOREACH(vs, &vd->clients, next) {
776 if (vnc_has_feature(vs, VNC_FEATURE_COPYRECT)) {
777 vnc_copy(vs, src_x, src_y, dst_x, dst_y, w, h);
778 }
779 }
780 }
781
782 static void vnc_mouse_set(int x, int y, int visible)
783 {
784 /* can we ask the client(s) to move the pointer ??? */
785 }
786
787 static 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)) {
794 vnc_lock_output(vs);
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);
803 vnc_unlock_output(vs);
804 return 0;
805 }
806 return -1;
807 }
808
809 static void vnc_dpy_cursor_define(QEMUCursor *c)
810 {
811 VncDisplay *vd = vnc_display;
812 VncState *vs;
813
814 cursor_put(vd->cursor);
815 g_free(vd->cursor_mask);
816
817 vd->cursor = c;
818 cursor_get(vd->cursor);
819 vd->cursor_msize = cursor_get_mono_bpl(c) * c->height;
820 vd->cursor_mask = g_malloc0(vd->cursor_msize);
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
828 static int find_and_clear_dirty_height(struct VncState *vs,
829 int y, int last_x, int x, int height)
830 {
831 int h;
832
833 for (h = 1; h < (height - y); h++) {
834 int tmp_x;
835 if (!test_bit(last_x, vs->dirty[y + h])) {
836 break;
837 }
838 for (tmp_x = last_x; tmp_x < x; tmp_x++) {
839 clear_bit(tmp_x, vs->dirty[y + h]);
840 }
841 }
842
843 return h;
844 }
845
846 #ifdef CONFIG_VNC_THREAD
847 static 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
854 static int vnc_update_client_sync(VncState *vs, int has_dirty)
855 {
856 return vnc_update_client(vs, has_dirty);
857 }
858 #endif
859
860 static int vnc_update_client(VncState *vs, int has_dirty)
861 {
862 if (vs->need_update && vs->csock != -1) {
863 VncDisplay *vd = vs->vd;
864 VncJob *job;
865 int y;
866 int width, height;
867 int n = 0;
868
869
870 if (vs->output.offset && !vs->audio_cap && !vs->force_update)
871 /* kernel send buffers are full -> drop frames to throttle */
872 return 0;
873
874 if (!has_dirty && !vs->audio_cap && !vs->force_update)
875 return 0;
876
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 */
883 job = vnc_job_new(vs);
884
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++) {
889 int x;
890 int last_x = -1;
891 for (x = 0; x < width / 16; x++) {
892 if (test_and_clear_bit(x, vs->dirty[y])) {
893 if (last_x == -1) {
894 last_x = x;
895 }
896 } else {
897 if (last_x != -1) {
898 int h = find_and_clear_dirty_height(vs, y, last_x, x,
899 height);
900
901 n += vnc_job_add_rect(job, last_x * 16, y,
902 (x - last_x) * 16, h);
903 }
904 last_x = -1;
905 }
906 }
907 if (last_x != -1) {
908 int h = find_and_clear_dirty_height(vs, y, last_x, x, height);
909 n += vnc_job_add_rect(job, last_x * 16, y,
910 (x - last_x) * 16, h);
911 }
912 }
913
914 vnc_job_push(job);
915 vs->force_update = 0;
916 return n;
917 }
918
919 if (vs->csock == -1)
920 vnc_disconnect_finish(vs);
921
922 return 0;
923 }
924
925 /* audio */
926 static void audio_capture_notify(void *opaque, audcnotification_e cmd)
927 {
928 VncState *vs = opaque;
929
930 switch (cmd) {
931 case AUD_CNOTIFY_DISABLE:
932 vnc_lock_output(vs);
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);
936 vnc_unlock_output(vs);
937 vnc_flush(vs);
938 break;
939
940 case AUD_CNOTIFY_ENABLE:
941 vnc_lock_output(vs);
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);
945 vnc_unlock_output(vs);
946 vnc_flush(vs);
947 break;
948 }
949 }
950
951 static void audio_capture_destroy(void *opaque)
952 {
953 }
954
955 static void audio_capture(void *opaque, void *buf, int size)
956 {
957 VncState *vs = opaque;
958
959 vnc_lock_output(vs);
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);
963 vnc_write_u32(vs, size);
964 vnc_write(vs, buf, size);
965 vnc_unlock_output(vs);
966 vnc_flush(vs);
967 }
968
969 static void audio_add(VncState *vs)
970 {
971 struct audio_capture_ops ops;
972
973 if (vs->audio_cap) {
974 monitor_printf(default_mon, "audio already running\n");
975 return;
976 }
977
978 ops.notify = audio_capture_notify;
979 ops.destroy = audio_capture_destroy;
980 ops.capture = audio_capture;
981
982 vs->audio_cap = AUD_add_capture(&vs->as, &ops, vs);
983 if (!vs->audio_cap) {
984 monitor_printf(default_mon, "Failed to add audio capture\n");
985 }
986 }
987
988 static 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
996 static 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
1005 static void vnc_disconnect_finish(VncState *vs)
1006 {
1007 int i;
1008
1009 vnc_jobs_join(vs); /* Wait encoding jobs */
1010
1011 vnc_lock_output(vs);
1012 vnc_qmp_event(vs, QEVENT_VNC_DISCONNECTED);
1013
1014 buffer_free(&vs->input);
1015 buffer_free(&vs->output);
1016
1017 qobject_decref(vs->info);
1018
1019 vnc_zlib_clear(vs);
1020 vnc_tight_clear(vs);
1021 vnc_zrle_clear(vs);
1022
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
1031 QTAILQ_REMOVE(&vs->vd->clients, vs, next);
1032
1033 if (QTAILQ_EMPTY(&vs->vd->clients)) {
1034 dcl->idle = 1;
1035 }
1036
1037 qemu_remove_mouse_mode_change_notifier(&vs->mouse_mode_notifier);
1038 vnc_remove_timer(vs->vd);
1039 if (vs->vd->lock_key_sync)
1040 qemu_remove_led_event_handler(vs->led);
1041 vnc_unlock_output(vs);
1042
1043 #ifdef CONFIG_VNC_THREAD
1044 qemu_mutex_destroy(&vs->output_mutex);
1045 #endif
1046 for (i = 0; i < VNC_STAT_ROWS; ++i) {
1047 g_free(vs->lossy_rect[i]);
1048 }
1049 g_free(vs->lossy_rect);
1050 g_free(vs);
1051 }
1052
1053 int vnc_client_io_error(VncState *vs, int ret, int last_errno)
1054 {
1055 if (ret == 0 || ret == -1) {
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 }
1068
1069 VNC_DEBUG("Closing down client sock: ret %d, errno %d\n",
1070 ret, ret < 0 ? last_errno : 0);
1071 vnc_disconnect_start(vs);
1072
1073 return 0;
1074 }
1075 return ret;
1076 }
1077
1078
1079 void vnc_client_error(VncState *vs)
1080 {
1081 VNC_DEBUG("Closing down client sock: protocol error\n");
1082 vnc_disconnect_start(vs);
1083 }
1084
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 */
1101 long vnc_client_write_buf(VncState *vs, const uint8_t *data, size_t datalen)
1102 {
1103 long ret;
1104 #ifdef CONFIG_VNC_TLS
1105 if (vs->tls.session) {
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 }
1114 } else
1115 #endif /* CONFIG_VNC_TLS */
1116 ret = send(vs->csock, (const void *)data, datalen, 0);
1117 VNC_DEBUG("Wrote wire %p %zd -> %ld\n", data, datalen, ret);
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 */
1132 static long vnc_client_write_plain(VncState *vs)
1133 {
1134 long ret;
1135
1136 #ifdef CONFIG_VNC_SASL
1137 VNC_DEBUG("Write Plain: Pending output %p size %zd offset %zd. Wait SSF %d\n",
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);
1150 if (!ret)
1151 return 0;
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) {
1157 qemu_set_fd_handler2(vs->csock, NULL, vnc_client_read, NULL, vs);
1158 }
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 */
1169 static void vnc_client_write_locked(void *opaque)
1170 {
1171 VncState *vs = opaque;
1172
1173 #ifdef CONFIG_VNC_SASL
1174 if (vs->sasl.conn &&
1175 vs->sasl.runSSF &&
1176 !vs->sasl.waitWriteSSF) {
1177 vnc_client_write_sasl(vs);
1178 } else
1179 #endif /* CONFIG_VNC_SASL */
1180 vnc_client_write_plain(vs);
1181 }
1182
1183 void 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);
1190 } else if (vs->csock != -1) {
1191 qemu_set_fd_handler2(vs->csock, NULL, vnc_client_read, NULL, vs);
1192 }
1193 vnc_unlock_output(vs);
1194 }
1195
1196 void vnc_read_when(VncState *vs, VncReadEvent *func, size_t expecting)
1197 {
1198 vs->read_handler = func;
1199 vs->read_handler_expect = expecting;
1200 }
1201
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 */
1218 long vnc_client_read_buf(VncState *vs, uint8_t *data, size_t datalen)
1219 {
1220 long ret;
1221 #ifdef CONFIG_VNC_TLS
1222 if (vs->tls.session) {
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 }
1231 } else
1232 #endif /* CONFIG_VNC_TLS */
1233 ret = qemu_recv(vs->csock, data, datalen, 0);
1234 VNC_DEBUG("Read wire %p %zd -> %ld\n", data, datalen, ret);
1235 return vnc_client_io_error(vs, ret, socket_error());
1236 }
1237
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 */
1247 static long vnc_client_read_plain(VncState *vs)
1248 {
1249 int ret;
1250 VNC_DEBUG("Read plain %p size %zd offset %zd\n",
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;
1256 vs->input.offset += ret;
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 */
1266 void 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);
1277 if (!ret) {
1278 if (vs->csock == -1)
1279 vnc_disconnect_finish(vs);
1280 return;
1281 }
1282
1283 while (vs->read_handler && vs->input.offset >= vs->read_handler_expect) {
1284 size_t len = vs->read_handler_expect;
1285 int ret;
1286
1287 ret = vs->read_handler(vs, vs->input.buffer, len);
1288 if (vs->csock == -1) {
1289 vnc_disconnect_finish(vs);
1290 return;
1291 }
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 }
1299 }
1300 }
1301
1302 void vnc_write(VncState *vs, const void *data, size_t len)
1303 {
1304 buffer_reserve(&vs->output, len);
1305
1306 if (vs->csock != -1 && buffer_empty(&vs->output)) {
1307 qemu_set_fd_handler2(vs->csock, NULL, vnc_client_read, vnc_client_write, vs);
1308 }
1309
1310 buffer_append(&vs->output, data, len);
1311 }
1312
1313 void vnc_write_s32(VncState *vs, int32_t value)
1314 {
1315 vnc_write_u32(vs, *(uint32_t *)&value);
1316 }
1317
1318 void vnc_write_u32(VncState *vs, uint32_t value)
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
1330 void vnc_write_u16(VncState *vs, uint16_t value)
1331 {
1332 uint8_t buf[2];
1333
1334 buf[0] = (value >> 8) & 0xFF;
1335 buf[1] = value & 0xFF;
1336
1337 vnc_write(vs, buf, 2);
1338 }
1339
1340 void vnc_write_u8(VncState *vs, uint8_t value)
1341 {
1342 vnc_write(vs, (char *)&value, 1);
1343 }
1344
1345 void vnc_flush(VncState *vs)
1346 {
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);
1352 }
1353
1354 uint8_t read_u8(uint8_t *data, size_t offset)
1355 {
1356 return data[offset];
1357 }
1358
1359 uint16_t read_u16(uint8_t *data, size_t offset)
1360 {
1361 return ((data[offset] & 0xFF) << 8) | (data[offset + 1] & 0xFF);
1362 }
1363
1364 int32_t read_s32(uint8_t *data, size_t offset)
1365 {
1366 return (int32_t)((data[offset] << 24) | (data[offset + 1] << 16) |
1367 (data[offset + 2] << 8) | data[offset + 3]);
1368 }
1369
1370 uint32_t read_u32(uint8_t *data, size_t offset)
1371 {
1372 return ((data[offset] << 24) | (data[offset + 1] << 16) |
1373 (data[offset + 2] << 8) | data[offset + 3]);
1374 }
1375
1376 static void client_cut_text(VncState *vs, size_t len, uint8_t *text)
1377 {
1378 }
1379
1380 static void check_pointer_type_change(Notifier *notifier, void *data)
1381 {
1382 VncState *vs = container_of(notifier, VncState, mouse_mode_notifier);
1383 int absolute = kbd_mouse_is_absolute();
1384
1385 if (vnc_has_feature(vs, VNC_FEATURE_POINTER_TYPE_CHANGE) && vs->absolute != absolute) {
1386 vnc_lock_output(vs);
1387 vnc_write_u8(vs, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE);
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),
1392 VNC_ENCODING_POINTER_TYPE_CHANGE);
1393 vnc_unlock_output(vs);
1394 vnc_flush(vs);
1395 }
1396 vs->absolute = absolute;
1397 }
1398
1399 static 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)
1405 buttons |= MOUSE_EVENT_LBUTTON;
1406 if (button_mask & 0x02)
1407 buttons |= MOUSE_EVENT_MBUTTON;
1408 if (button_mask & 0x04)
1409 buttons |= MOUSE_EVENT_RBUTTON;
1410 if (button_mask & 0x08)
1411 dz = -1;
1412 if (button_mask & 0x10)
1413 dz = 1;
1414
1415 if (vs->absolute) {
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,
1420 dz, buttons);
1421 } else if (vnc_has_feature(vs, VNC_FEATURE_POINTER_TYPE_CHANGE)) {
1422 x -= 0x7FFF;
1423 y -= 0x7FFF;
1424
1425 kbd_mouse_event(x, y, dz, buttons);
1426 } else {
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;
1433 }
1434 }
1435
1436 static void reset_keys(VncState *vs)
1437 {
1438 int i;
1439 for(i = 0; i < 256; i++) {
1440 if (vs->modifiers_state[i]) {
1441 if (i & SCANCODE_GREY)
1442 kbd_put_keycode(SCANCODE_EMUL0);
1443 kbd_put_keycode(i | SCANCODE_UP);
1444 vs->modifiers_state[i] = 0;
1445 }
1446 }
1447 }
1448
1449 static void press_key(VncState *vs, int keysym)
1450 {
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);
1458 }
1459
1460 static 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
1476 static void do_key_event(VncState *vs, int down, int keycode, int sym)
1477 {
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;
1491 case 0x02 ... 0x0a: /* '1' to '9' keys */
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;
1499 case 0x3a: /* CapsLock */
1500 case 0x45: /* NumLock */
1501 if (down)
1502 vs->modifiers_state[keycode] ^= 1;
1503 break;
1504 }
1505
1506 if (down && vs->vd->lock_key_sync &&
1507 keycode_is_keypad(vs->vd->kbd_layout, keycode)) {
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 */
1512 if (keysym_is_numlock(vs->vd->kbd_layout, sym & 0xFFFF)) {
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 }
1523 }
1524
1525 if (down && vs->vd->lock_key_sync &&
1526 ((sym >= 'A' && sym <= 'Z') || (sym >= 'a' && sym <= 'z'))) {
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
1547 if (is_graphic_console()) {
1548 if (keycode & SCANCODE_GREY)
1549 kbd_put_keycode(SCANCODE_EMUL0);
1550 if (down)
1551 kbd_put_keycode(keycode & SCANCODE_KEYCODEMASK);
1552 else
1553 kbd_put_keycode(keycode | SCANCODE_UP);
1554 } else {
1555 /* QEMU console emulation */
1556 if (down) {
1557 int numlock = vs->modifiers_state[0x45];
1558 switch (keycode) {
1559 case 0x2a: /* Left Shift */
1560 case 0x36: /* Right Shift */
1561 case 0x1d: /* Left CTRL */
1562 case 0x9d: /* Right CTRL */
1563 case 0x38: /* Left ALT */
1564 case 0xb8: /* Right ALT */
1565 break;
1566 case 0xc8:
1567 kbd_put_keysym(QEMU_KEY_UP);
1568 break;
1569 case 0xd0:
1570 kbd_put_keysym(QEMU_KEY_DOWN);
1571 break;
1572 case 0xcb:
1573 kbd_put_keysym(QEMU_KEY_LEFT);
1574 break;
1575 case 0xcd:
1576 kbd_put_keysym(QEMU_KEY_RIGHT);
1577 break;
1578 case 0xd3:
1579 kbd_put_keysym(QEMU_KEY_DELETE);
1580 break;
1581 case 0xc7:
1582 kbd_put_keysym(QEMU_KEY_HOME);
1583 break;
1584 case 0xcf:
1585 kbd_put_keysym(QEMU_KEY_END);
1586 break;
1587 case 0xc9:
1588 kbd_put_keysym(QEMU_KEY_PAGEUP);
1589 break;
1590 case 0xd1:
1591 kbd_put_keysym(QEMU_KEY_PAGEDOWN);
1592 break;
1593
1594 case 0x47:
1595 kbd_put_keysym(numlock ? '7' : QEMU_KEY_HOME);
1596 break;
1597 case 0x48:
1598 kbd_put_keysym(numlock ? '8' : QEMU_KEY_UP);
1599 break;
1600 case 0x49:
1601 kbd_put_keysym(numlock ? '9' : QEMU_KEY_PAGEUP);
1602 break;
1603 case 0x4b:
1604 kbd_put_keysym(numlock ? '4' : QEMU_KEY_LEFT);
1605 break;
1606 case 0x4c:
1607 kbd_put_keysym('5');
1608 break;
1609 case 0x4d:
1610 kbd_put_keysym(numlock ? '6' : QEMU_KEY_RIGHT);
1611 break;
1612 case 0x4f:
1613 kbd_put_keysym(numlock ? '1' : QEMU_KEY_END);
1614 break;
1615 case 0x50:
1616 kbd_put_keysym(numlock ? '2' : QEMU_KEY_DOWN);
1617 break;
1618 case 0x51:
1619 kbd_put_keysym(numlock ? '3' : QEMU_KEY_PAGEDOWN);
1620 break;
1621 case 0x52:
1622 kbd_put_keysym('0');
1623 break;
1624 case 0x53:
1625 kbd_put_keysym(numlock ? '.' : QEMU_KEY_DELETE);
1626 break;
1627
1628 case 0xb5:
1629 kbd_put_keysym('/');
1630 break;
1631 case 0x37:
1632 kbd_put_keysym('*');
1633 break;
1634 case 0x4a:
1635 kbd_put_keysym('-');
1636 break;
1637 case 0x4e:
1638 kbd_put_keysym('+');
1639 break;
1640 case 0x9c:
1641 kbd_put_keysym('\n');
1642 break;
1643
1644 default:
1645 kbd_put_keysym(sym);
1646 break;
1647 }
1648 }
1649 }
1650 }
1651
1652 static void key_event(VncState *vs, int down, uint32_t sym)
1653 {
1654 int keycode;
1655 int lsym = sym;
1656
1657 if (lsym >= 'A' && lsym <= 'Z' && is_graphic_console()) {
1658 lsym = lsym - 'A' + 'a';
1659 }
1660
1661 keycode = keysym2scancode(vs->vd->kbd_layout, lsym & 0xFFFF) & SCANCODE_KEYMASK;
1662 do_key_event(vs, down, keycode, sym);
1663 }
1664
1665 static void ext_key_event(VncState *vs, int down,
1666 uint32_t sym, uint16_t keycode)
1667 {
1668 /* if the user specifies a keyboard layout, always use it */
1669 if (keyboard_layout)
1670 key_event(vs, down, sym);
1671 else
1672 do_key_event(vs, down, keycode, sym);
1673 }
1674
1675 static void framebuffer_update_request(VncState *vs, int incremental,
1676 int x_position, int y_position,
1677 int w, int h)
1678 {
1679 int i;
1680 const size_t width = ds_get_width(vs->ds) / 16;
1681
1682 if (y_position > ds_get_height(vs->ds))
1683 y_position = ds_get_height(vs->ds);
1684 if (y_position + h >= ds_get_height(vs->ds))
1685 h = ds_get_height(vs->ds) - y_position;
1686
1687 vs->need_update = 1;
1688 if (!incremental) {
1689 vs->force_update = 1;
1690 for (i = 0; i < h; i++) {
1691 bitmap_set(vs->dirty[y_position + i], 0, width);
1692 bitmap_clear(vs->dirty[y_position + i], width,
1693 VNC_DIRTY_BITS - width);
1694 }
1695 }
1696 }
1697
1698 static void send_ext_key_event_ack(VncState *vs)
1699 {
1700 vnc_lock_output(vs);
1701 vnc_write_u8(vs, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE);
1702 vnc_write_u8(vs, 0);
1703 vnc_write_u16(vs, 1);
1704 vnc_framebuffer_update(vs, 0, 0, ds_get_width(vs->ds), ds_get_height(vs->ds),
1705 VNC_ENCODING_EXT_KEY_EVENT);
1706 vnc_unlock_output(vs);
1707 vnc_flush(vs);
1708 }
1709
1710 static void send_ext_audio_ack(VncState *vs)
1711 {
1712 vnc_lock_output(vs);
1713 vnc_write_u8(vs, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE);
1714 vnc_write_u8(vs, 0);
1715 vnc_write_u16(vs, 1);
1716 vnc_framebuffer_update(vs, 0, 0, ds_get_width(vs->ds), ds_get_height(vs->ds),
1717 VNC_ENCODING_AUDIO);
1718 vnc_unlock_output(vs);
1719 vnc_flush(vs);
1720 }
1721
1722 static void set_encodings(VncState *vs, int32_t *encodings, size_t n_encodings)
1723 {
1724 int i;
1725 unsigned int enc = 0;
1726
1727 vs->features = 0;
1728 vs->vnc_encoding = 0;
1729 vs->tight.compression = 9;
1730 vs->tight.quality = -1; /* Lossless by default */
1731 vs->absolute = -1;
1732
1733 /*
1734 * Start from the end because the encodings are sent in order of preference.
1735 * This way the preferred encoding (first encoding defined in the array)
1736 * will be set at the end of the loop.
1737 */
1738 for (i = n_encodings - 1; i >= 0; i--) {
1739 enc = encodings[i];
1740 switch (enc) {
1741 case VNC_ENCODING_RAW:
1742 vs->vnc_encoding = enc;
1743 break;
1744 case VNC_ENCODING_COPYRECT:
1745 vs->features |= VNC_FEATURE_COPYRECT_MASK;
1746 break;
1747 case VNC_ENCODING_HEXTILE:
1748 vs->features |= VNC_FEATURE_HEXTILE_MASK;
1749 vs->vnc_encoding = enc;
1750 break;
1751 case VNC_ENCODING_TIGHT:
1752 vs->features |= VNC_FEATURE_TIGHT_MASK;
1753 vs->vnc_encoding = enc;
1754 break;
1755 case VNC_ENCODING_TIGHT_PNG:
1756 vs->features |= VNC_FEATURE_TIGHT_PNG_MASK;
1757 vs->vnc_encoding = enc;
1758 break;
1759 case VNC_ENCODING_ZLIB:
1760 vs->features |= VNC_FEATURE_ZLIB_MASK;
1761 vs->vnc_encoding = enc;
1762 break;
1763 case VNC_ENCODING_ZRLE:
1764 vs->features |= VNC_FEATURE_ZRLE_MASK;
1765 vs->vnc_encoding = enc;
1766 break;
1767 case VNC_ENCODING_ZYWRLE:
1768 vs->features |= VNC_FEATURE_ZYWRLE_MASK;
1769 vs->vnc_encoding = enc;
1770 break;
1771 case VNC_ENCODING_DESKTOPRESIZE:
1772 vs->features |= VNC_FEATURE_RESIZE_MASK;
1773 break;
1774 case VNC_ENCODING_POINTER_TYPE_CHANGE:
1775 vs->features |= VNC_FEATURE_POINTER_TYPE_CHANGE_MASK;
1776 break;
1777 case VNC_ENCODING_RICH_CURSOR:
1778 vs->features |= VNC_FEATURE_RICH_CURSOR_MASK;
1779 break;
1780 case VNC_ENCODING_EXT_KEY_EVENT:
1781 send_ext_key_event_ack(vs);
1782 break;
1783 case VNC_ENCODING_AUDIO:
1784 send_ext_audio_ack(vs);
1785 break;
1786 case VNC_ENCODING_WMVi:
1787 vs->features |= VNC_FEATURE_WMVI_MASK;
1788 break;
1789 case VNC_ENCODING_COMPRESSLEVEL0 ... VNC_ENCODING_COMPRESSLEVEL0 + 9:
1790 vs->tight.compression = (enc & 0x0F);
1791 break;
1792 case VNC_ENCODING_QUALITYLEVEL0 ... VNC_ENCODING_QUALITYLEVEL0 + 9:
1793 if (vs->vd->lossy) {
1794 vs->tight.quality = (enc & 0x0F);
1795 }
1796 break;
1797 default:
1798 VNC_DEBUG("Unknown encoding: %d (0x%.8x): %d\n", i, enc, enc);
1799 break;
1800 }
1801 }
1802 vnc_desktop_resize(vs);
1803 check_pointer_type_change(&vs->mouse_mode_notifier, NULL);
1804 }
1805
1806 static void set_pixel_conversion(VncState *vs)
1807 {
1808 if ((vs->clientds.flags & QEMU_BIG_ENDIAN_FLAG) ==
1809 (vs->ds->surface->flags & QEMU_BIG_ENDIAN_FLAG) &&
1810 !memcmp(&(vs->clientds.pf), &(vs->ds->surface->pf), sizeof(PixelFormat))) {
1811 vs->write_pixels = vnc_write_pixels_copy;
1812 vnc_hextile_set_pixel_conversion(vs, 0);
1813 } else {
1814 vs->write_pixels = vnc_write_pixels_generic;
1815 vnc_hextile_set_pixel_conversion(vs, 1);
1816 }
1817 }
1818
1819 static void set_pixel_format(VncState *vs,
1820 int bits_per_pixel, int depth,
1821 int big_endian_flag, int true_color_flag,
1822 int red_max, int green_max, int blue_max,
1823 int red_shift, int green_shift, int blue_shift)
1824 {
1825 if (!true_color_flag) {
1826 vnc_client_error(vs);
1827 return;
1828 }
1829
1830 vs->clientds = *(vs->vd->guest.ds);
1831 vs->clientds.pf.rmax = red_max;
1832 vs->clientds.pf.rbits = hweight_long(red_max);
1833 vs->clientds.pf.rshift = red_shift;
1834 vs->clientds.pf.rmask = red_max << red_shift;
1835 vs->clientds.pf.gmax = green_max;
1836 vs->clientds.pf.gbits = hweight_long(green_max);
1837 vs->clientds.pf.gshift = green_shift;
1838 vs->clientds.pf.gmask = green_max << green_shift;
1839 vs->clientds.pf.bmax = blue_max;
1840 vs->clientds.pf.bbits = hweight_long(blue_max);
1841 vs->clientds.pf.bshift = blue_shift;
1842 vs->clientds.pf.bmask = blue_max << blue_shift;
1843 vs->clientds.pf.bits_per_pixel = bits_per_pixel;
1844 vs->clientds.pf.bytes_per_pixel = bits_per_pixel / 8;
1845 vs->clientds.pf.depth = bits_per_pixel == 32 ? 24 : bits_per_pixel;
1846 vs->clientds.flags = big_endian_flag ? QEMU_BIG_ENDIAN_FLAG : 0x00;
1847
1848 set_pixel_conversion(vs);
1849
1850 vga_hw_invalidate();
1851 vga_hw_update();
1852 }
1853
1854 static void pixel_format_message (VncState *vs) {
1855 char pad[3] = { 0, 0, 0 };
1856
1857 vnc_write_u8(vs, vs->ds->surface->pf.bits_per_pixel); /* bits-per-pixel */
1858 vnc_write_u8(vs, vs->ds->surface->pf.depth); /* depth */
1859
1860 #ifdef HOST_WORDS_BIGENDIAN
1861 vnc_write_u8(vs, 1); /* big-endian-flag */
1862 #else
1863 vnc_write_u8(vs, 0); /* big-endian-flag */
1864 #endif
1865 vnc_write_u8(vs, 1); /* true-color-flag */
1866 vnc_write_u16(vs, vs->ds->surface->pf.rmax); /* red-max */
1867 vnc_write_u16(vs, vs->ds->surface->pf.gmax); /* green-max */
1868 vnc_write_u16(vs, vs->ds->surface->pf.bmax); /* blue-max */
1869 vnc_write_u8(vs, vs->ds->surface->pf.rshift); /* red-shift */
1870 vnc_write_u8(vs, vs->ds->surface->pf.gshift); /* green-shift */
1871 vnc_write_u8(vs, vs->ds->surface->pf.bshift); /* blue-shift */
1872
1873 vnc_hextile_set_pixel_conversion(vs, 0);
1874
1875 vs->clientds = *(vs->ds->surface);
1876 vs->clientds.flags &= ~QEMU_ALLOCATED_FLAG;
1877 vs->write_pixels = vnc_write_pixels_copy;
1878
1879 vnc_write(vs, pad, 3); /* padding */
1880 }
1881
1882 static void vnc_dpy_setdata(DisplayState *ds)
1883 {
1884 /* We don't have to do anything */
1885 }
1886
1887 static void vnc_colordepth(VncState *vs)
1888 {
1889 if (vnc_has_feature(vs, VNC_FEATURE_WMVI)) {
1890 /* Sending a WMVi message to notify the client*/
1891 vnc_lock_output(vs);
1892 vnc_write_u8(vs, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE);
1893 vnc_write_u8(vs, 0);
1894 vnc_write_u16(vs, 1); /* number of rects */
1895 vnc_framebuffer_update(vs, 0, 0, ds_get_width(vs->ds),
1896 ds_get_height(vs->ds), VNC_ENCODING_WMVi);
1897 pixel_format_message(vs);
1898 vnc_unlock_output(vs);
1899 vnc_flush(vs);
1900 } else {
1901 set_pixel_conversion(vs);
1902 }
1903 }
1904
1905 static int protocol_client_msg(VncState *vs, uint8_t *data, size_t len)
1906 {
1907 int i;
1908 uint16_t limit;
1909 VncDisplay *vd = vs->vd;
1910
1911 if (data[0] > 3) {
1912 vd->timer_interval = VNC_REFRESH_INTERVAL_BASE;
1913 if (!qemu_timer_expired(vd->timer, qemu_get_clock_ms(rt_clock) + vd->timer_interval))
1914 qemu_mod_timer(vd->timer, qemu_get_clock_ms(rt_clock) + vd->timer_interval);
1915 }
1916
1917 switch (data[0]) {
1918 case VNC_MSG_CLIENT_SET_PIXEL_FORMAT:
1919 if (len == 1)
1920 return 20;
1921
1922 set_pixel_format(vs, read_u8(data, 4), read_u8(data, 5),
1923 read_u8(data, 6), read_u8(data, 7),
1924 read_u16(data, 8), read_u16(data, 10),
1925 read_u16(data, 12), read_u8(data, 14),
1926 read_u8(data, 15), read_u8(data, 16));
1927 break;
1928 case VNC_MSG_CLIENT_SET_ENCODINGS:
1929 if (len == 1)
1930 return 4;
1931
1932 if (len == 4) {
1933 limit = read_u16(data, 2);
1934 if (limit > 0)
1935 return 4 + (limit * 4);
1936 } else
1937 limit = read_u16(data, 2);
1938
1939 for (i = 0; i < limit; i++) {
1940 int32_t val = read_s32(data, 4 + (i * 4));
1941 memcpy(data + 4 + (i * 4), &val, sizeof(val));
1942 }
1943
1944 set_encodings(vs, (int32_t *)(data + 4), limit);
1945 break;
1946 case VNC_MSG_CLIENT_FRAMEBUFFER_UPDATE_REQUEST:
1947 if (len == 1)
1948 return 10;
1949
1950 framebuffer_update_request(vs,
1951 read_u8(data, 1), read_u16(data, 2), read_u16(data, 4),
1952 read_u16(data, 6), read_u16(data, 8));
1953 break;
1954 case VNC_MSG_CLIENT_KEY_EVENT:
1955 if (len == 1)
1956 return 8;
1957
1958 key_event(vs, read_u8(data, 1), read_u32(data, 4));
1959 break;
1960 case VNC_MSG_CLIENT_POINTER_EVENT:
1961 if (len == 1)
1962 return 6;
1963
1964 pointer_event(vs, read_u8(data, 1), read_u16(data, 2), read_u16(data, 4));
1965 break;
1966 case VNC_MSG_CLIENT_CUT_TEXT:
1967 if (len == 1)
1968 return 8;
1969
1970 if (len == 8) {
1971 uint32_t dlen = read_u32(data, 4);
1972 if (dlen > 0)
1973 return 8 + dlen;
1974 }
1975
1976 client_cut_text(vs, read_u32(data, 4), data + 8);
1977 break;
1978 case VNC_MSG_CLIENT_QEMU:
1979 if (len == 1)
1980 return 2;
1981
1982 switch (read_u8(data, 1)) {
1983 case VNC_MSG_CLIENT_QEMU_EXT_KEY_EVENT:
1984 if (len == 2)
1985 return 12;
1986
1987 ext_key_event(vs, read_u16(data, 2),
1988 read_u32(data, 4), read_u32(data, 8));
1989 break;
1990 case VNC_MSG_CLIENT_QEMU_AUDIO:
1991 if (len == 2)
1992 return 4;
1993
1994 switch (read_u16 (data, 2)) {
1995 case VNC_MSG_CLIENT_QEMU_AUDIO_ENABLE:
1996 audio_add(vs);
1997 break;
1998 case VNC_MSG_CLIENT_QEMU_AUDIO_DISABLE:
1999 audio_del(vs);
2000 break;
2001 case VNC_MSG_CLIENT_QEMU_AUDIO_SET_FORMAT:
2002 if (len == 4)
2003 return 10;
2004 switch (read_u8(data, 4)) {
2005 case 0: vs->as.fmt = AUD_FMT_U8; break;
2006 case 1: vs->as.fmt = AUD_FMT_S8; break;
2007 case 2: vs->as.fmt = AUD_FMT_U16; break;
2008 case 3: vs->as.fmt = AUD_FMT_S16; break;
2009 case 4: vs->as.fmt = AUD_FMT_U32; break;
2010 case 5: vs->as.fmt = AUD_FMT_S32; break;
2011 default:
2012 printf("Invalid audio format %d\n", read_u8(data, 4));
2013 vnc_client_error(vs);
2014 break;
2015 }
2016 vs->as.nchannels = read_u8(data, 5);
2017 if (vs->as.nchannels != 1 && vs->as.nchannels != 2) {
2018 printf("Invalid audio channel coount %d\n",
2019 read_u8(data, 5));
2020 vnc_client_error(vs);
2021 break;
2022 }
2023 vs->as.freq = read_u32(data, 6);
2024 break;
2025 default:
2026 printf ("Invalid audio message %d\n", read_u8(data, 4));
2027 vnc_client_error(vs);
2028 break;
2029 }
2030 break;
2031
2032 default:
2033 printf("Msg: %d\n", read_u16(data, 0));
2034 vnc_client_error(vs);
2035 break;
2036 }
2037 break;
2038 default:
2039 printf("Msg: %d\n", data[0]);
2040 vnc_client_error(vs);
2041 break;
2042 }
2043
2044 vnc_read_when(vs, protocol_client_msg, 1);
2045 return 0;
2046 }
2047
2048 static int protocol_client_init(VncState *vs, uint8_t *data, size_t len)
2049 {
2050 char buf[1024];
2051 int size;
2052
2053 vs->client_width = ds_get_width(vs->ds);
2054 vs->client_height = ds_get_height(vs->ds);
2055 vnc_write_u16(vs, vs->client_width);
2056 vnc_write_u16(vs, vs->client_height);
2057
2058 pixel_format_message(vs);
2059
2060 if (qemu_name)
2061 size = snprintf(buf, sizeof(buf), "QEMU (%s)", qemu_name);
2062 else
2063 size = snprintf(buf, sizeof(buf), "QEMU");
2064
2065 vnc_write_u32(vs, size);
2066 vnc_write(vs, buf, size);
2067 vnc_flush(vs);
2068
2069 vnc_client_cache_auth(vs);
2070 vnc_qmp_event(vs, QEVENT_VNC_INITIALIZED);
2071
2072 vnc_read_when(vs, protocol_client_msg, 1);
2073
2074 return 0;
2075 }
2076
2077 void start_client_init(VncState *vs)
2078 {
2079 vnc_read_when(vs, protocol_client_init, 1);
2080 }
2081
2082 static void make_challenge(VncState *vs)
2083 {
2084 int i;
2085
2086 srand(time(NULL)+getpid()+getpid()*987654+rand());
2087
2088 for (i = 0 ; i < sizeof(vs->challenge) ; i++)
2089 vs->challenge[i] = (int) (256.0*rand()/(RAND_MAX+1.0));
2090 }
2091
2092 static int protocol_client_auth_vnc(VncState *vs, uint8_t *data, size_t len)
2093 {
2094 unsigned char response[VNC_AUTH_CHALLENGE_SIZE];
2095 int i, j, pwlen;
2096 unsigned char key[8];
2097 time_t now = time(NULL);
2098
2099 if (!vs->vd->password) {
2100 VNC_DEBUG("No password configured on server");
2101 goto reject;
2102 }
2103 if (vs->vd->expires < now) {
2104 VNC_DEBUG("Password is expired");
2105 goto reject;
2106 }
2107
2108 memcpy(response, vs->challenge, VNC_AUTH_CHALLENGE_SIZE);
2109
2110 /* Calculate the expected challenge response */
2111 pwlen = strlen(vs->vd->password);
2112 for (i=0; i<sizeof(key); i++)
2113 key[i] = i<pwlen ? vs->vd->password[i] : 0;
2114 deskey(key, EN0);
2115 for (j = 0; j < VNC_AUTH_CHALLENGE_SIZE; j += 8)
2116 des(response+j, response+j);
2117
2118 /* Compare expected vs actual challenge response */
2119 if (memcmp(response, data, VNC_AUTH_CHALLENGE_SIZE) != 0) {
2120 VNC_DEBUG("Client challenge response did not match\n");
2121 goto reject;
2122 } else {
2123 VNC_DEBUG("Accepting VNC challenge response\n");
2124 vnc_write_u32(vs, 0); /* Accept auth */
2125 vnc_flush(vs);
2126
2127 start_client_init(vs);
2128 }
2129 return 0;
2130
2131 reject:
2132 vnc_write_u32(vs, 1); /* Reject auth */
2133 if (vs->minor >= 8) {
2134 static const char err[] = "Authentication failed";
2135 vnc_write_u32(vs, sizeof(err));
2136 vnc_write(vs, err, sizeof(err));
2137 }
2138 vnc_flush(vs);
2139 vnc_client_error(vs);
2140 return 0;
2141 }
2142
2143 void start_auth_vnc(VncState *vs)
2144 {
2145 make_challenge(vs);
2146 /* Send client a 'random' challenge */
2147 vnc_write(vs, vs->challenge, sizeof(vs->challenge));
2148 vnc_flush(vs);
2149
2150 vnc_read_when(vs, protocol_client_auth_vnc, sizeof(vs->challenge));
2151 }
2152
2153
2154 static int protocol_client_auth(VncState *vs, uint8_t *data, size_t len)
2155 {
2156 /* We only advertise 1 auth scheme at a time, so client
2157 * must pick the one we sent. Verify this */
2158 if (data[0] != vs->auth) { /* Reject auth */
2159 VNC_DEBUG("Reject auth %d because it didn't match advertized\n", (int)data[0]);
2160 vnc_write_u32(vs, 1);
2161 if (vs->minor >= 8) {
2162 static const char err[] = "Authentication failed";
2163 vnc_write_u32(vs, sizeof(err));
2164 vnc_write(vs, err, sizeof(err));
2165 }
2166 vnc_client_error(vs);
2167 } else { /* Accept requested auth */
2168 VNC_DEBUG("Client requested auth %d\n", (int)data[0]);
2169 switch (vs->auth) {
2170 case VNC_AUTH_NONE:
2171 VNC_DEBUG("Accept auth none\n");
2172 if (vs->minor >= 8) {
2173 vnc_write_u32(vs, 0); /* Accept auth completion */
2174 vnc_flush(vs);
2175 }
2176 start_client_init(vs);
2177 break;
2178
2179 case VNC_AUTH_VNC:
2180 VNC_DEBUG("Start VNC auth\n");
2181 start_auth_vnc(vs);
2182 break;
2183
2184 #ifdef CONFIG_VNC_TLS
2185 case VNC_AUTH_VENCRYPT:
2186 VNC_DEBUG("Accept VeNCrypt auth\n");;
2187 start_auth_vencrypt(vs);
2188 break;
2189 #endif /* CONFIG_VNC_TLS */
2190
2191 #ifdef CONFIG_VNC_SASL
2192 case VNC_AUTH_SASL:
2193 VNC_DEBUG("Accept SASL auth\n");
2194 start_auth_sasl(vs);
2195 break;
2196 #endif /* CONFIG_VNC_SASL */
2197
2198 default: /* Should not be possible, but just in case */
2199 VNC_DEBUG("Reject auth %d server code bug\n", vs->auth);
2200 vnc_write_u8(vs, 1);
2201 if (vs->minor >= 8) {
2202 static const char err[] = "Authentication failed";
2203 vnc_write_u32(vs, sizeof(err));
2204 vnc_write(vs, err, sizeof(err));
2205 }
2206 vnc_client_error(vs);
2207 }
2208 }
2209 return 0;
2210 }
2211
2212 static int protocol_version(VncState *vs, uint8_t *version, size_t len)
2213 {
2214 char local[13];
2215
2216 memcpy(local, version, 12);
2217 local[12] = 0;
2218
2219 if (sscanf(local, "RFB %03d.%03d\n", &vs->major, &vs->minor) != 2) {
2220 VNC_DEBUG("Malformed protocol version %s\n", local);
2221 vnc_client_error(vs);
2222 return 0;
2223 }
2224 VNC_DEBUG("Client request protocol version %d.%d\n", vs->major, vs->minor);
2225 if (vs->major != 3 ||
2226 (vs->minor != 3 &&
2227 vs->minor != 4 &&
2228 vs->minor != 5 &&
2229 vs->minor != 7 &&
2230 vs->minor != 8)) {
2231 VNC_DEBUG("Unsupported client version\n");
2232 vnc_write_u32(vs, VNC_AUTH_INVALID);
2233 vnc_flush(vs);
2234 vnc_client_error(vs);
2235 return 0;
2236 }
2237 /* Some broken clients report v3.4 or v3.5, which spec requires to be treated
2238 * as equivalent to v3.3 by servers
2239 */
2240 if (vs->minor == 4 || vs->minor == 5)
2241 vs->minor = 3;
2242
2243 if (vs->minor == 3) {
2244 if (vs->auth == VNC_AUTH_NONE) {
2245 VNC_DEBUG("Tell client auth none\n");
2246 vnc_write_u32(vs, vs->auth);
2247 vnc_flush(vs);
2248 start_client_init(vs);
2249 } else if (vs->auth == VNC_AUTH_VNC) {
2250 VNC_DEBUG("Tell client VNC auth\n");
2251 vnc_write_u32(vs, vs->auth);
2252 vnc_flush(vs);
2253 start_auth_vnc(vs);
2254 } else {
2255 VNC_DEBUG("Unsupported auth %d for protocol 3.3\n", vs->auth);
2256 vnc_write_u32(vs, VNC_AUTH_INVALID);
2257 vnc_flush(vs);
2258 vnc_client_error(vs);
2259 }
2260 } else {
2261 VNC_DEBUG("Telling client we support auth %d\n", vs->auth);
2262 vnc_write_u8(vs, 1); /* num auth */
2263 vnc_write_u8(vs, vs->auth);
2264 vnc_read_when(vs, protocol_client_auth, 1);
2265 vnc_flush(vs);
2266 }
2267
2268 return 0;
2269 }
2270
2271 static VncRectStat *vnc_stat_rect(VncDisplay *vd, int x, int y)
2272 {
2273 struct VncSurface *vs = &vd->guest;
2274
2275 return &vs->stats[y / VNC_STAT_RECT][x / VNC_STAT_RECT];
2276 }
2277
2278 void vnc_sent_lossy_rect(VncState *vs, int x, int y, int w, int h)
2279 {
2280 int i, j;
2281
2282 w = (x + w) / VNC_STAT_RECT;
2283 h = (y + h) / VNC_STAT_RECT;
2284 x /= VNC_STAT_RECT;
2285 y /= VNC_STAT_RECT;
2286
2287 for (j = y; j <= h; j++) {
2288 for (i = x; i <= w; i++) {
2289 vs->lossy_rect[j][i] = 1;
2290 }
2291 }
2292 }
2293
2294 static int vnc_refresh_lossy_rect(VncDisplay *vd, int x, int y)
2295 {
2296 VncState *vs;
2297 int sty = y / VNC_STAT_RECT;
2298 int stx = x / VNC_STAT_RECT;
2299 int has_dirty = 0;
2300
2301 y = y / VNC_STAT_RECT * VNC_STAT_RECT;
2302 x = x / VNC_STAT_RECT * VNC_STAT_RECT;
2303
2304 QTAILQ_FOREACH(vs, &vd->clients, next) {
2305 int j;
2306
2307 /* kernel send buffers are full -> refresh later */
2308 if (vs->output.offset) {
2309 continue;
2310 }
2311
2312 if (!vs->lossy_rect[sty][stx]) {
2313 continue;
2314 }
2315
2316 vs->lossy_rect[sty][stx] = 0;
2317 for (j = 0; j < VNC_STAT_RECT; ++j) {
2318 bitmap_set(vs->dirty[y + j], x / 16, VNC_STAT_RECT / 16);
2319 }
2320 has_dirty++;
2321 }
2322
2323 return has_dirty;
2324 }
2325
2326 static int vnc_update_stats(VncDisplay *vd, struct timeval * tv)
2327 {
2328 int x, y;
2329 struct timeval res;
2330 int has_dirty = 0;
2331
2332 for (y = 0; y < vd->guest.ds->height; y += VNC_STAT_RECT) {
2333 for (x = 0; x < vd->guest.ds->width; x += VNC_STAT_RECT) {
2334 VncRectStat *rect = vnc_stat_rect(vd, x, y);
2335
2336 rect->updated = false;
2337 }
2338 }
2339
2340 qemu_timersub(tv, &VNC_REFRESH_STATS, &res);
2341
2342 if (timercmp(&vd->guest.last_freq_check, &res, >)) {
2343 return has_dirty;
2344 }
2345 vd->guest.last_freq_check = *tv;
2346
2347 for (y = 0; y < vd->guest.ds->height; y += VNC_STAT_RECT) {
2348 for (x = 0; x < vd->guest.ds->width; x += VNC_STAT_RECT) {
2349 VncRectStat *rect= vnc_stat_rect(vd, x, y);
2350 int count = ARRAY_SIZE(rect->times);
2351 struct timeval min, max;
2352
2353 if (!timerisset(&rect->times[count - 1])) {
2354 continue ;
2355 }
2356
2357 max = rect->times[(rect->idx + count - 1) % count];
2358 qemu_timersub(tv, &max, &res);
2359
2360 if (timercmp(&res, &VNC_REFRESH_LOSSY, >)) {
2361 rect->freq = 0;
2362 has_dirty += vnc_refresh_lossy_rect(vd, x, y);
2363 memset(rect->times, 0, sizeof (rect->times));
2364 continue ;
2365 }
2366
2367 min = rect->times[rect->idx];
2368 max = rect->times[(rect->idx + count - 1) % count];
2369 qemu_timersub(&max, &min, &res);
2370
2371 rect->freq = res.tv_sec + res.tv_usec / 1000000.;
2372 rect->freq /= count;
2373 rect->freq = 1. / rect->freq;
2374 }
2375 }
2376 return has_dirty;
2377 }
2378
2379 double vnc_update_freq(VncState *vs, int x, int y, int w, int h)
2380 {
2381 int i, j;
2382 double total = 0;
2383 int num = 0;
2384
2385 x = (x / VNC_STAT_RECT) * VNC_STAT_RECT;
2386 y = (y / VNC_STAT_RECT) * VNC_STAT_RECT;
2387
2388 for (j = y; j <= y + h; j += VNC_STAT_RECT) {
2389 for (i = x; i <= x + w; i += VNC_STAT_RECT) {
2390 total += vnc_stat_rect(vs->vd, i, j)->freq;
2391 num++;
2392 }
2393 }
2394
2395 if (num) {
2396 return total / num;
2397 } else {
2398 return 0;
2399 }
2400 }
2401
2402 static void vnc_rect_updated(VncDisplay *vd, int x, int y, struct timeval * tv)
2403 {
2404 VncRectStat *rect;
2405
2406 rect = vnc_stat_rect(vd, x, y);
2407 if (rect->updated) {
2408 return ;
2409 }
2410 rect->times[rect->idx] = *tv;
2411 rect->idx = (rect->idx + 1) % ARRAY_SIZE(rect->times);
2412 rect->updated = true;
2413 }
2414
2415 static int vnc_refresh_server_surface(VncDisplay *vd)
2416 {
2417 int y;
2418 uint8_t *guest_row;
2419 uint8_t *server_row;
2420 int cmp_bytes;
2421 VncState *vs;
2422 int has_dirty = 0;
2423
2424 struct timeval tv = { 0, 0 };
2425
2426 if (!vd->non_adaptive) {
2427 gettimeofday(&tv, NULL);
2428 has_dirty = vnc_update_stats(vd, &tv);
2429 }
2430
2431 /*
2432 * Walk through the guest dirty map.
2433 * Check and copy modified bits from guest to server surface.
2434 * Update server dirty map.
2435 */
2436 cmp_bytes = 16 * ds_get_bytes_per_pixel(vd->ds);
2437 guest_row = vd->guest.ds->data;
2438 server_row = vd->server->data;
2439 for (y = 0; y < vd->guest.ds->height; y++) {
2440 if (!bitmap_empty(vd->guest.dirty[y], VNC_DIRTY_BITS)) {
2441 int x;
2442 uint8_t *guest_ptr;
2443 uint8_t *server_ptr;
2444
2445 guest_ptr = guest_row;
2446 server_ptr = server_row;
2447
2448 for (x = 0; x < vd->guest.ds->width;
2449 x += 16, guest_ptr += cmp_bytes, server_ptr += cmp_bytes) {
2450 if (!test_and_clear_bit((x / 16), vd->guest.dirty[y]))
2451 continue;
2452 if (memcmp(server_ptr, guest_ptr, cmp_bytes) == 0)
2453 continue;
2454 memcpy(server_ptr, guest_ptr, cmp_bytes);
2455 if (!vd->non_adaptive)
2456 vnc_rect_updated(vd, x, y, &tv);
2457 QTAILQ_FOREACH(vs, &vd->clients, next) {
2458 set_bit((x / 16), vs->dirty[y]);
2459 }
2460 has_dirty++;
2461 }
2462 }
2463 guest_row += ds_get_linesize(vd->ds);
2464 server_row += ds_get_linesize(vd->ds);
2465 }
2466 return has_dirty;
2467 }
2468
2469 static void vnc_refresh(void *opaque)
2470 {
2471 VncDisplay *vd = opaque;
2472 VncState *vs, *vn;
2473 int has_dirty, rects = 0;
2474
2475 vga_hw_update();
2476
2477 if (vnc_trylock_display(vd)) {
2478 vd->timer_interval = VNC_REFRESH_INTERVAL_BASE;
2479 qemu_mod_timer(vd->timer, qemu_get_clock_ms(rt_clock) +
2480 vd->timer_interval);
2481 return;
2482 }
2483
2484 has_dirty = vnc_refresh_server_surface(vd);
2485 vnc_unlock_display(vd);
2486
2487 QTAILQ_FOREACH_SAFE(vs, &vd->clients, next, vn) {
2488 rects += vnc_update_client(vs, has_dirty);
2489 /* vs might be free()ed here */
2490 }
2491
2492 /* vd->timer could be NULL now if the last client disconnected,
2493 * in this case don't update the timer */
2494 if (vd->timer == NULL)
2495 return;
2496
2497 if (has_dirty && rects) {
2498 vd->timer_interval /= 2;
2499 if (vd->timer_interval < VNC_REFRESH_INTERVAL_BASE)
2500 vd->timer_interval = VNC_REFRESH_INTERVAL_BASE;
2501 } else {
2502 vd->timer_interval += VNC_REFRESH_INTERVAL_INC;
2503 if (vd->timer_interval > VNC_REFRESH_INTERVAL_MAX)
2504 vd->timer_interval = VNC_REFRESH_INTERVAL_MAX;
2505 }
2506 qemu_mod_timer(vd->timer, qemu_get_clock_ms(rt_clock) + vd->timer_interval);
2507 }
2508
2509 static void vnc_init_timer(VncDisplay *vd)
2510 {
2511 vd->timer_interval = VNC_REFRESH_INTERVAL_BASE;
2512 if (vd->timer == NULL && !QTAILQ_EMPTY(&vd->clients)) {
2513 vd->timer = qemu_new_timer_ms(rt_clock, vnc_refresh, vd);
2514 vnc_dpy_resize(vd->ds);
2515 vnc_refresh(vd);
2516 }
2517 }
2518
2519 static void vnc_remove_timer(VncDisplay *vd)
2520 {
2521 if (vd->timer != NULL && QTAILQ_EMPTY(&vd->clients)) {
2522 qemu_del_timer(vd->timer);
2523 qemu_free_timer(vd->timer);
2524 vd->timer = NULL;
2525 }
2526 }
2527
2528 static void vnc_connect(VncDisplay *vd, int csock, int skipauth)
2529 {
2530 VncState *vs = g_malloc0(sizeof(VncState));
2531 int i;
2532
2533 vs->csock = csock;
2534
2535 if (skipauth) {
2536 vs->auth = VNC_AUTH_NONE;
2537 #ifdef CONFIG_VNC_TLS
2538 vs->subauth = VNC_AUTH_INVALID;
2539 #endif
2540 } else {
2541 vs->auth = vd->auth;
2542 #ifdef CONFIG_VNC_TLS
2543 vs->subauth = vd->subauth;
2544 #endif
2545 }
2546
2547 vs->lossy_rect = g_malloc0(VNC_STAT_ROWS * sizeof (*vs->lossy_rect));
2548 for (i = 0; i < VNC_STAT_ROWS; ++i) {
2549 vs->lossy_rect[i] = g_malloc0(VNC_STAT_COLS * sizeof (uint8_t));
2550 }
2551
2552 VNC_DEBUG("New client on socket %d\n", csock);
2553 dcl->idle = 0;
2554 socket_set_nonblock(vs->csock);
2555 qemu_set_fd_handler2(vs->csock, NULL, vnc_client_read, NULL, vs);
2556
2557 vnc_client_cache_addr(vs);
2558 vnc_qmp_event(vs, QEVENT_VNC_CONNECTED);
2559
2560 vs->vd = vd;
2561 vs->ds = vd->ds;
2562 vs->last_x = -1;
2563 vs->last_y = -1;
2564
2565 vs->as.freq = 44100;
2566 vs->as.nchannels = 2;
2567 vs->as.fmt = AUD_FMT_S16;
2568 vs->as.endianness = 0;
2569
2570 #ifdef CONFIG_VNC_THREAD
2571 qemu_mutex_init(&vs->output_mutex);
2572 #endif
2573
2574 QTAILQ_INSERT_HEAD(&vd->clients, vs, next);
2575
2576 vga_hw_update();
2577
2578 vnc_write(vs, "RFB 003.008\n", 12);
2579 vnc_flush(vs);
2580 vnc_read_when(vs, protocol_version, 12);
2581 reset_keys(vs);
2582 if (vs->vd->lock_key_sync)
2583 vs->led = qemu_add_led_event_handler(kbd_leds, vs);
2584
2585 vs->mouse_mode_notifier.notify = check_pointer_type_change;
2586 qemu_add_mouse_mode_change_notifier(&vs->mouse_mode_notifier);
2587
2588 vnc_init_timer(vd);
2589
2590 /* vs might be free()ed here */
2591 }
2592
2593 static void vnc_listen_read(void *opaque)
2594 {
2595 VncDisplay *vs = opaque;
2596 struct sockaddr_in addr;
2597 socklen_t addrlen = sizeof(addr);
2598
2599 /* Catch-up */
2600 vga_hw_update();
2601
2602 int csock = qemu_accept(vs->lsock, (struct sockaddr *)&addr, &addrlen);
2603 if (csock != -1) {
2604 vnc_connect(vs, csock, 0);
2605 }
2606 }
2607
2608 void vnc_display_init(DisplayState *ds)
2609 {
2610 VncDisplay *vs = g_malloc0(sizeof(*vs));
2611
2612 dcl = g_malloc0(sizeof(DisplayChangeListener));
2613
2614 ds->opaque = vs;
2615 dcl->idle = 1;
2616 vnc_display = vs;
2617
2618 vs->lsock = -1;
2619
2620 vs->ds = ds;
2621 QTAILQ_INIT(&vs->clients);
2622 vs->expires = TIME_MAX;
2623
2624 if (keyboard_layout)
2625 vs->kbd_layout = init_keyboard_layout(name2keysym, keyboard_layout);
2626 else
2627 vs->kbd_layout = init_keyboard_layout(name2keysym, "en-us");
2628
2629 if (!vs->kbd_layout)
2630 exit(1);
2631
2632 #ifdef CONFIG_VNC_THREAD
2633 qemu_mutex_init(&vs->mutex);
2634 vnc_start_worker_thread();
2635 #endif
2636
2637 dcl->dpy_copy = vnc_dpy_copy;
2638 dcl->dpy_update = vnc_dpy_update;
2639 dcl->dpy_resize = vnc_dpy_resize;
2640 dcl->dpy_setdata = vnc_dpy_setdata;
2641 register_displaychangelistener(ds, dcl);
2642 ds->mouse_set = vnc_mouse_set;
2643 ds->cursor_define = vnc_dpy_cursor_define;
2644 }
2645
2646
2647 void vnc_display_close(DisplayState *ds)
2648 {
2649 VncDisplay *vs = ds ? (VncDisplay *)ds->opaque : vnc_display;
2650
2651 if (!vs)
2652 return;
2653 if (vs->display) {
2654 g_free(vs->display);
2655 vs->display = NULL;
2656 }
2657 if (vs->lsock != -1) {
2658 qemu_set_fd_handler2(vs->lsock, NULL, NULL, NULL, NULL);
2659 close(vs->lsock);
2660 vs->lsock = -1;
2661 }
2662 vs->auth = VNC_AUTH_INVALID;
2663 #ifdef CONFIG_VNC_TLS
2664 vs->subauth = VNC_AUTH_INVALID;
2665 vs->tls.x509verify = 0;
2666 #endif
2667 }
2668
2669 int vnc_display_disable_login(DisplayState *ds)
2670 {
2671 VncDisplay *vs = ds ? (VncDisplay *)ds->opaque : vnc_display;
2672
2673 if (!vs) {
2674 return -1;
2675 }
2676
2677 if (vs->password) {
2678 g_free(vs->password);
2679 }
2680
2681 vs->password = NULL;
2682 vs->auth = VNC_AUTH_VNC;
2683
2684 return 0;
2685 }
2686
2687 int vnc_display_password(DisplayState *ds, const char *password)
2688 {
2689 int ret = 0;
2690 VncDisplay *vs = ds ? (VncDisplay *)ds->opaque : vnc_display;
2691
2692 if (!vs) {
2693 ret = -EINVAL;
2694 goto out;
2695 }
2696
2697 if (!password) {
2698 /* This is not the intention of this interface but err on the side
2699 of being safe */
2700 ret = vnc_display_disable_login(ds);
2701 goto out;
2702 }
2703
2704 if (vs->password) {
2705 g_free(vs->password);
2706 vs->password = NULL;
2707 }
2708 vs->password = g_strdup(password);
2709 vs->auth = VNC_AUTH_VNC;
2710 out:
2711 if (ret != 0) {
2712 qerror_report(QERR_SET_PASSWD_FAILED);
2713 }
2714 return ret;
2715 }
2716
2717 int 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
2725 char *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
2732 int vnc_display_open(DisplayState *ds, const char *display)
2733 {
2734 VncDisplay *vs = ds ? (VncDisplay *)ds->opaque : vnc_display;
2735 const char *options;
2736 int password = 0;
2737 int reverse = 0;
2738 #ifdef CONFIG_VNC_TLS
2739 int tls = 0, x509 = 0;
2740 #endif
2741 #ifdef CONFIG_VNC_SASL
2742 int sasl = 0;
2743 int saslErr;
2744 #endif
2745 #if defined(CONFIG_VNC_TLS) || defined(CONFIG_VNC_SASL)
2746 int acl = 0;
2747 #endif
2748 int lock_key_sync = 1;
2749
2750 if (!vnc_display)
2751 return -1;
2752 vnc_display_close(ds);
2753 if (strcmp(display, "none") == 0)
2754 return 0;
2755
2756 if (!(vs->display = strdup(display)))
2757 return -1;
2758
2759 options = display;
2760 while ((options = strchr(options, ','))) {
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;
2766 } else if (strncmp(options, "no-lock-key-sync", 9) == 0) {
2767 lock_key_sync = 0;
2768 #ifdef CONFIG_VNC_SASL
2769 } else if (strncmp(options, "sasl", 4) == 0) {
2770 sasl = 1; /* Require SASL auth */
2771 #endif
2772 #ifdef CONFIG_VNC_TLS
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);
2787 char *path = g_strndup(start + 1, len);
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);
2792 g_free(path);
2793 g_free(vs->display);
2794 vs->display = NULL;
2795 return -1;
2796 }
2797 g_free(path);
2798 } else {
2799 fprintf(stderr, "No certificate path provided\n");
2800 g_free(vs->display);
2801 vs->display = NULL;
2802 return -1;
2803 }
2804 #endif
2805 #if defined(CONFIG_VNC_TLS) || defined(CONFIG_VNC_SASL)
2806 } else if (strncmp(options, "acl", 3) == 0) {
2807 acl = 1;
2808 #endif
2809 } else if (strncmp(options, "lossy", 5) == 0) {
2810 vs->lossy = true;
2811 } else if (strncmp(options, "non-adapative", 13) == 0) {
2812 vs->non_adaptive = true;
2813 }
2814 }
2815
2816 #ifdef CONFIG_VNC_TLS
2817 if (acl && x509 && vs->tls.x509verify) {
2818 if (!(vs->tls.acl = qemu_acl_init("vnc.x509dname"))) {
2819 fprintf(stderr, "Failed to create x509 dname ACL\n");
2820 exit(1);
2821 }
2822 }
2823 #endif
2824 #ifdef CONFIG_VNC_SASL
2825 if (acl && sasl) {
2826 if (!(vs->sasl.acl = qemu_acl_init("vnc.username"))) {
2827 fprintf(stderr, "Failed to create username ACL\n");
2828 exit(1);
2829 }
2830 }
2831 #endif
2832
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 */
2849 if (password) {
2850 #ifdef CONFIG_VNC_TLS
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 {
2861 #endif /* CONFIG_VNC_TLS */
2862 VNC_DEBUG("Initializing VNC server with password auth\n");
2863 vs->auth = VNC_AUTH_VNC;
2864 #ifdef CONFIG_VNC_TLS
2865 vs->subauth = VNC_AUTH_INVALID;
2866 }
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) {
2874 VNC_DEBUG("Initializing VNC server with x509 SASL auth\n");
2875 vs->subauth = VNC_AUTH_VENCRYPT_X509SASL;
2876 } else {
2877 VNC_DEBUG("Initializing VNC server with TLS SASL auth\n");
2878 vs->subauth = VNC_AUTH_VENCRYPT_TLSSASL;
2879 }
2880 } else {
2881 #endif /* CONFIG_VNC_TLS */
2882 VNC_DEBUG("Initializing VNC server with SASL auth\n");
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 */
2889 } else {
2890 #ifdef CONFIG_VNC_TLS
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 {
2901 #endif
2902 VNC_DEBUG("Initializing VNC server with no auth\n");
2903 vs->auth = VNC_AUTH_NONE;
2904 #ifdef CONFIG_VNC_TLS
2905 vs->subauth = VNC_AUTH_INVALID;
2906 }
2907 #endif
2908 }
2909
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));
2914 g_free(vs->display);
2915 vs->display = NULL;
2916 return -1;
2917 }
2918 #endif
2919 vs->lock_key_sync = lock_key_sync;
2920
2921 if (reverse) {
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) {
2928 g_free(vs->display);
2929 vs->display = NULL;
2930 return -1;
2931 } else {
2932 int csock = vs->lsock;
2933 vs->lsock = -1;
2934 vnc_connect(vs, csock, 0);
2935 }
2936 return 0;
2937
2938 } else {
2939 /* listen for connects */
2940 char *dpy;
2941 dpy = g_malloc(256);
2942 if (strncmp(display, "unix:", 5) == 0) {
2943 pstrcpy(dpy, 256, "unix:");
2944 vs->lsock = unix_listen(display+5, dpy+5, 256-5);
2945 } else {
2946 vs->lsock = inet_listen(display, dpy, 256, SOCK_STREAM, 5900);
2947 }
2948 if (-1 == vs->lsock) {
2949 g_free(dpy);
2950 return -1;
2951 } else {
2952 g_free(vs->display);
2953 vs->display = dpy;
2954 }
2955 }
2956 return qemu_set_fd_handler2(vs->lsock, NULL, vnc_listen_read, NULL, vs);
2957 }
2958
2959 void 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 }
QEMU Monitor Protocol