qemu/ui/vnc.c

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