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