ui/vnc.c

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