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 "vnc.h"
  28 #include "sysemu.h"
  29 #include "qemu_socket.h"
  30 #include "qemu-timer.h"
  31 #include "acl.h"
  32 #include "qemu-objects.h"
  33
  34 #define VNC_REFRESH_INTERVAL_BASE 30
  35 #define VNC_REFRESH_INTERVAL_INC  50
  36 #define VNC_REFRESH_INTERVAL_MAX  2000
  37
  38 #include "vnc_keysym.h"
  39 #include "d3des.h"
  40
  41 #define count_bits(c, v) { \
  42     for (c = 0; v; v >>= 1) \
  43     { \
  44         c += v & 1; \
  45     } \
  46 }
  47
  48
  49 static VncDisplay *vnc_display; /* needed for info vnc */
  50 static DisplayChangeListener *dcl;
  51
  52 static char *addr_to_string(const char *format,
  53                             struct sockaddr_storage *sa,
  54                             socklen_t salen) {
  55     char *addr;
  56     char host[NI_MAXHOST];
  57     char serv[NI_MAXSERV];
  58     int err;
  59     size_t addrlen;
  60
  61     if ((err = getnameinfo((struct sockaddr *)sa, salen,
  62                            host, sizeof(host),
  63                            serv, sizeof(serv),
  64                            NI_NUMERICHOST | NI_NUMERICSERV)) != 0) {
  65         VNC_DEBUG("Cannot resolve address %d: %s\n",
  66                   err, gai_strerror(err));
  67         return NULL;
  68     }
  69
  70     /* Enough for the existing format + the 2 vars we're
  71      * substituting in. */
  72     addrlen = strlen(format) + strlen(host) + strlen(serv);
  73     addr = qemu_malloc(addrlen + 1);
  74     snprintf(addr, addrlen, format, host, serv);
  75     addr[addrlen] = '\0';
  76
  77     return addr;
  78 }
  79
  80
  81 char *vnc_socket_local_addr(const char *format, int fd) {
  82     struct sockaddr_storage sa;
  83     socklen_t salen;
  84
  85     salen = sizeof(sa);
  86     if (getsockname(fd, (struct sockaddr*)&sa, &salen) < 0)
  87         return NULL;
  88
  89     return addr_to_string(format, &sa, salen);
  90 }
  91
  92 char *vnc_socket_remote_addr(const char *format, int fd) {
  93     struct sockaddr_storage sa;
  94     socklen_t salen;
  95
  96     salen = sizeof(sa);
  97     if (getpeername(fd, (struct sockaddr*)&sa, &salen) < 0)
  98         return NULL;
  99
 100     return addr_to_string(format, &sa, salen);
 101 }
 102
 103 static int put_addr_qdict(QDict *qdict, struct sockaddr_storage *sa,
 104                           socklen_t salen)
 105 {
 106     char host[NI_MAXHOST];
 107     char serv[NI_MAXSERV];
 108     int err;
 109
 110     if ((err = getnameinfo((struct sockaddr *)sa, salen,
 111                            host, sizeof(host),
 112                            serv, sizeof(serv),
 113                            NI_NUMERICHOST | NI_NUMERICSERV)) != 0) {
 114         VNC_DEBUG("Cannot resolve address %d: %s\n",
 115                   err, gai_strerror(err));
 116         return -1;
 117     }
 118
 119     qdict_put(qdict, "host", qstring_from_str(host));
 120     qdict_put(qdict, "service", qstring_from_str(serv));
 121
 122     return 0;
 123 }
 124
 125 static int vnc_qdict_local_addr(QDict *qdict, int fd)
 126 {
 127     struct sockaddr_storage sa;
 128     socklen_t salen;
 129
 130     salen = sizeof(sa);
 131     if (getsockname(fd, (struct sockaddr*)&sa, &salen) < 0) {
 132         return -1;
 133     }
 134
 135     return put_addr_qdict(qdict, &sa, salen);
 136 }
 137
 138 static int vnc_qdict_remote_addr(QDict *qdict, int fd)
 139 {
 140     struct sockaddr_storage sa;
 141     socklen_t salen;
 142
 143     salen = sizeof(sa);
 144     if (getpeername(fd, (struct sockaddr*)&sa, &salen) < 0) {
 145         return -1;
 146     }
 147
 148     return put_addr_qdict(qdict, &sa, salen);
 149 }
 150
 151 static const char *vnc_auth_name(VncDisplay *vd) {
 152     switch (vd->auth) {
 153     case VNC_AUTH_INVALID:
 154         return "invalid";
 155     case VNC_AUTH_NONE:
 156         return "none";
 157     case VNC_AUTH_VNC:
 158         return "vnc";
 159     case VNC_AUTH_RA2:
 160         return "ra2";
 161     case VNC_AUTH_RA2NE:
 162         return "ra2ne";
 163     case VNC_AUTH_TIGHT:
 164         return "tight";
 165     case VNC_AUTH_ULTRA:
 166         return "ultra";
 167     case VNC_AUTH_TLS:
 168         return "tls";
 169     case VNC_AUTH_VENCRYPT:
 170 #ifdef CONFIG_VNC_TLS
 171         switch (vd->subauth) {
 172         case VNC_AUTH_VENCRYPT_PLAIN:
 173             return "vencrypt+plain";
 174         case VNC_AUTH_VENCRYPT_TLSNONE:
 175             return "vencrypt+tls+none";
 176         case VNC_AUTH_VENCRYPT_TLSVNC:
 177             return "vencrypt+tls+vnc";
 178         case VNC_AUTH_VENCRYPT_TLSPLAIN:
 179             return "vencrypt+tls+plain";
 180         case VNC_AUTH_VENCRYPT_X509NONE:
 181             return "vencrypt+x509+none";
 182         case VNC_AUTH_VENCRYPT_X509VNC:
 183             return "vencrypt+x509+vnc";
 184         case VNC_AUTH_VENCRYPT_X509PLAIN:
 185             return "vencrypt+x509+plain";
 186         case VNC_AUTH_VENCRYPT_TLSSASL:
 187             return "vencrypt+tls+sasl";
 188         case VNC_AUTH_VENCRYPT_X509SASL:
 189             return "vencrypt+x509+sasl";
 190         default:
 191             return "vencrypt";
 192         }
 193 #else
 194         return "vencrypt";
 195 #endif
 196     case VNC_AUTH_SASL:
 197         return "sasl";
 198     }
 199     return "unknown";
 200 }
 201
 202 static QDict *do_info_vnc_client(Monitor *mon, VncState *client)
 203 {
 204     QDict *qdict;
 205
 206     qdict = qdict_new();
 207     if (vnc_qdict_remote_addr(qdict, client->csock) < 0) {
 208         QDECREF(qdict);
 209         return NULL;
 210     }
 211
 212 #ifdef CONFIG_VNC_TLS
 213     if (client->tls.session &&
 214         client->tls.dname) {
 215         qdict_put(qdict, "x509_dname", qstring_from_str(client->tls.dname));
 216     }
 217 #endif
 218 #ifdef CONFIG_VNC_SASL
 219     if (client->sasl.conn &&
 220         client->sasl.username) {
 221         qdict_put(qdict, "username", qstring_from_str(client->sasl.username));
 222     }
 223 #endif
 224
 225     return qdict;
 226 }
 227
 228 static void info_vnc_iter(QObject *obj, void *opaque)
 229 {
 230     QDict *client;
 231     Monitor *mon = opaque;
 232
 233     client = qobject_to_qdict(obj);
 234     monitor_printf(mon, "Client:\n");
 235     monitor_printf(mon, "     address: %s:%s\n",
 236                    qdict_get_str(client, "host"),
 237                    qdict_get_str(client, "service"));
 238
 239 #ifdef CONFIG_VNC_TLS
 240     monitor_printf(mon, "  x509_dname: %s\n",
 241         qdict_haskey(client, "x509_dname") ?
 242         qdict_get_str(client, "x509_dname") : "none");
 243 #endif
 244 #ifdef CONFIG_VNC_SASL
 245     monitor_printf(mon, "    username: %s\n",
 246         qdict_haskey(client, "username") ?
 247         qdict_get_str(client, "username") : "none");
 248 #endif
 249 }
 250
 251 void do_info_vnc_print(Monitor *mon, const QObject *data)
 252 {
 253     QDict *server;
 254     QList *clients;
 255
 256     server = qobject_to_qdict(data);
 257     if (strcmp(qdict_get_str(server, "status"), "disabled") == 0) {
 258         monitor_printf(mon, "Server: disabled\n");
 259         return;
 260     }
 261
 262     monitor_printf(mon, "Server:\n");
 263     monitor_printf(mon, "     address: %s:%s\n",
 264                    qdict_get_str(server, "host"),
 265                    qdict_get_str(server, "service"));
 266     monitor_printf(mon, "        auth: %s\n",
 267         qdict_haskey(server, "auth") ? qdict_get_str(server, "auth") : "none");
 268
 269     clients = qdict_get_qlist(server, "clients");
 270     if (qlist_empty(clients)) {
 271         monitor_printf(mon, "Client: none\n");
 272     } else {
 273         qlist_iter(clients, info_vnc_iter, mon);
 274     }
 275 }
 276
 277 /**
 278  * do_info_vnc(): Show VNC server information
 279  *
 280  * Return a QDict with server information. Connected clients are returned
 281  * as a QList of QDicts.
 282  *
 283  * The main QDict contains the following:
 284  *
 285  * - "status": "disabled" or "enabled"
 286  * - "host": server's IP address
 287  * - "service": server's port number
 288  * - "auth": authentication method (optional)
 289  * - "clients": a QList of all connected clients
 290  *
 291  * Clients are described by a QDict, with the following information:
 292  *
 293  * - "host": client's IP address
 294  * - "service": client's port number
 295  * - "x509_dname": TLS dname (optional)
 296  * - "username": SASL username (optional)
 297  *
 298  * Example:
 299  *
 300  * { "status": "enabled", "host": "0.0.0.0", "service": "50402", "auth": "vnc",
 301  *   "clients": [ { "host": "127.0.0.1", "service": "50401" } ] }
 302  */
 303 void do_info_vnc(Monitor *mon, QObject **ret_data)
 304 {
 305     if (vnc_display == NULL || vnc_display->display == NULL) {
 306         *ret_data = qobject_from_jsonf("{ 'status': 'disabled' }");
 307     } else {
 308         QDict *qdict;
 309         QList *clist;
 310
 311         clist = qlist_new();
 312         if (vnc_display->clients) {
 313             VncState *client = vnc_display->clients;
 314             while (client) {
 315                 qdict = do_info_vnc_client(mon, client);
 316                 if (qdict)
 317                     qlist_append(clist, qdict);
 318                 client = client->next;
 319             }
 320         }
 321
 322         *ret_data = qobject_from_jsonf("{ 'status': 'enabled', 'clients': %p }",
 323                                        QOBJECT(clist));
 324         assert(*ret_data != NULL);
 325
 326         qdict = qobject_to_qdict(*ret_data);
 327
 328         if (vnc_display->auth != VNC_AUTH_NONE) {
 329             qdict_put(qdict, "auth",
 330                       qstring_from_str(vnc_auth_name(vnc_display)));
 331         }
 332
 333         if (vnc_qdict_local_addr(qdict, vnc_display->lsock) < 0) {
 334             qobject_decref(*ret_data);
 335             *ret_data = NULL;
 336         }
 337     }
 338 }
 339
 340 static inline uint32_t vnc_has_feature(VncState *vs, int feature) {
 341     return (vs->features & (1 << feature));
 342 }
 343
 344 /* TODO
 345    1) Get the queue working for IO.
 346    2) there is some weirdness when using the -S option (the screen is grey
 347       and not totally invalidated
 348    3) resolutions > 1024
 349 */
 350
 351 static int vnc_update_client(VncState *vs, int has_dirty);
 352 static void vnc_disconnect_start(VncState *vs);
 353 static void vnc_disconnect_finish(VncState *vs);
 354 static void vnc_init_timer(VncDisplay *vd);
 355 static void vnc_remove_timer(VncDisplay *vd);
 356
 357 static void vnc_colordepth(VncState *vs);
 358 static void framebuffer_update_request(VncState *vs, int incremental,
 359                                        int x_position, int y_position,
 360                                        int w, int h);
 361 static void vnc_refresh(void *opaque);
 362 static int vnc_refresh_server_surface(VncDisplay *vd);
 363
 364 static inline void vnc_set_bit(uint32_t *d, int k)
 365 {
 366     d[k >> 5] |= 1 << (k & 0x1f);
 367 }
 368
 369 static inline void vnc_clear_bit(uint32_t *d, int k)
 370 {
 371     d[k >> 5] &= ~(1 << (k & 0x1f));
 372 }
 373
 374 static inline void vnc_set_bits(uint32_t *d, int n, int nb_words)
 375 {
 376     int j;
 377
 378     j = 0;
 379     while (n >= 32) {
 380         d[j++] = -1;
 381         n -= 32;
 382     }
 383     if (n > 0)
 384         d[j++] = (1 << n) - 1;
 385     while (j < nb_words)
 386         d[j++] = 0;
 387 }
 388
 389 static inline int vnc_get_bit(const uint32_t *d, int k)
 390 {
 391     return (d[k >> 5] >> (k & 0x1f)) & 1;
 392 }
 393
 394 static inline int vnc_and_bits(const uint32_t *d1, const uint32_t *d2,
 395                                int nb_words)
 396 {
 397     int i;
 398     for(i = 0; i < nb_words; i++) {
 399         if ((d1[i] & d2[i]) != 0)
 400             return 1;
 401     }
 402     return 0;
 403 }
 404
 405 static void vnc_dpy_update(DisplayState *ds, int x, int y, int w, int h)
 406 {
 407     int i;
 408     VncDisplay *vd = ds->opaque;
 409     struct VncSurface *s = &vd->guest;
 410
 411     h += y;
 412
 413     /* round x down to ensure the loop only spans one 16-pixel block per,
 414        iteration.  otherwise, if (x % 16) != 0, the last iteration may span
 415        two 16-pixel blocks but we only mark the first as dirty
 416     */
 417     w += (x % 16);
 418     x -= (x % 16);
 419
 420     x = MIN(x, s->ds->width);
 421     y = MIN(y, s->ds->height);
 422     w = MIN(x + w, s->ds->width) - x;
 423     h = MIN(h, s->ds->height);
 424
 425     for (; y < h; y++)
 426         for (i = 0; i < w; i += 16)
 427             vnc_set_bit(s->dirty[y], (x + i) / 16);
 428 }
 429
 430 static void vnc_framebuffer_update(VncState *vs, int x, int y, int w, int h,
 431                                    int32_t encoding)
 432 {
 433     vnc_write_u16(vs, x);
 434     vnc_write_u16(vs, y);
 435     vnc_write_u16(vs, w);
 436     vnc_write_u16(vs, h);
 437
 438     vnc_write_s32(vs, encoding);
 439 }
 440
 441 void buffer_reserve(Buffer *buffer, size_t len)
 442 {
 443     if ((buffer->capacity - buffer->offset) < len) {
 444         buffer->capacity += (len + 1024);
 445         buffer->buffer = qemu_realloc(buffer->buffer, buffer->capacity);
 446         if (buffer->buffer == NULL) {
 447             fprintf(stderr, "vnc: out of memory\n");
 448             exit(1);
 449         }
 450     }
 451 }
 452
 453 int buffer_empty(Buffer *buffer)
 454 {
 455     return buffer->offset == 0;
 456 }
 457
 458 uint8_t *buffer_end(Buffer *buffer)
 459 {
 460     return buffer->buffer + buffer->offset;
 461 }
 462
 463 void buffer_reset(Buffer *buffer)
 464 {
 465         buffer->offset = 0;
 466 }
 467
 468 void buffer_append(Buffer *buffer, const void *data, size_t len)
 469 {
 470     memcpy(buffer->buffer + buffer->offset, data, len);
 471     buffer->offset += len;
 472 }
 473
 474 static void vnc_dpy_resize(DisplayState *ds)
 475 {
 476     int size_changed;
 477     VncDisplay *vd = ds->opaque;
 478     VncState *vs = vd->clients;
 479
 480     /* server surface */
 481     if (!vd->server)
 482         vd->server = qemu_mallocz(sizeof(*vd->server));
 483     if (vd->server->data)
 484         qemu_free(vd->server->data);
 485     *(vd->server) = *(ds->surface);
 486     vd->server->data = qemu_mallocz(vd->server->linesize *
 487                                     vd->server->height);
 488
 489     /* guest surface */
 490     if (!vd->guest.ds)
 491         vd->guest.ds = qemu_mallocz(sizeof(*vd->guest.ds));
 492     if (ds_get_bytes_per_pixel(ds) != vd->guest.ds->pf.bytes_per_pixel)
 493         console_color_init(ds);
 494     size_changed = ds_get_width(ds) != vd->guest.ds->width ||
 495                    ds_get_height(ds) != vd->guest.ds->height;
 496     *(vd->guest.ds) = *(ds->surface);
 497     memset(vd->guest.dirty, 0xFF, sizeof(vd->guest.dirty));
 498
 499     while (vs != NULL) {
 500         vnc_colordepth(vs);
 501         if (size_changed) {
 502             if (vs->csock != -1 && vnc_has_feature(vs, VNC_FEATURE_RESIZE)) {
 503                 vnc_write_u8(vs, 0);  /* msg id */
 504                 vnc_write_u8(vs, 0);
 505                 vnc_write_u16(vs, 1); /* number of rects */
 506                 vnc_framebuffer_update(vs, 0, 0, ds_get_width(ds), ds_get_height(ds),
 507                         VNC_ENCODING_DESKTOPRESIZE);
 508                 vnc_flush(vs);
 509             }
 510         }
 511         memset(vs->dirty, 0xFF, sizeof(vs->dirty));
 512         vs = vs->next;
 513     }
 514 }
 515
 516 /* fastest code */
 517 static void vnc_write_pixels_copy(VncState *vs, void *pixels, int size)
 518 {
 519     vnc_write(vs, pixels, size);
 520 }
 521
 522 /* slowest but generic code. */
 523 static void vnc_convert_pixel(VncState *vs, uint8_t *buf, uint32_t v)
 524 {
 525     uint8_t r, g, b;
 526     VncDisplay *vd = vs->vd;
 527
 528     r = ((((v & vd->server->pf.rmask) >> vd->server->pf.rshift) << vs->clientds.pf.rbits) >>
 529         vd->server->pf.rbits);
 530     g = ((((v & vd->server->pf.gmask) >> vd->server->pf.gshift) << vs->clientds.pf.gbits) >>
 531         vd->server->pf.gbits);
 532     b = ((((v & vd->server->pf.bmask) >> vd->server->pf.bshift) << vs->clientds.pf.bbits) >>
 533         vd->server->pf.bbits);
 534     v = (r << vs->clientds.pf.rshift) |
 535         (g << vs->clientds.pf.gshift) |
 536         (b << vs->clientds.pf.bshift);
 537     switch(vs->clientds.pf.bytes_per_pixel) {
 538     case 1:
 539         buf[0] = v;
 540         break;
 541     case 2:
 542         if (vs->clientds.flags & QEMU_BIG_ENDIAN_FLAG) {
 543             buf[0] = v >> 8;
 544             buf[1] = v;
 545         } else {
 546             buf[1] = v >> 8;
 547             buf[0] = v;
 548         }
 549         break;
 550     default:
 551     case 4:
 552         if (vs->clientds.flags & QEMU_BIG_ENDIAN_FLAG) {
 553             buf[0] = v >> 24;
 554             buf[1] = v >> 16;
 555             buf[2] = v >> 8;
 556             buf[3] = v;
 557         } else {
 558             buf[3] = v >> 24;
 559             buf[2] = v >> 16;
 560             buf[1] = v >> 8;
 561             buf[0] = v;
 562         }
 563         break;
 564     }
 565 }
 566
 567 static void vnc_write_pixels_generic(VncState *vs, void *pixels1, int size)
 568 {
 569     uint8_t buf[4];
 570     VncDisplay *vd = vs->vd;
 571
 572     if (vd->server->pf.bytes_per_pixel == 4) {
 573         uint32_t *pixels = pixels1;
 574         int n, i;
 575         n = size >> 2;
 576         for(i = 0; i < n; i++) {
 577             vnc_convert_pixel(vs, buf, pixels[i]);
 578             vnc_write(vs, buf, vs->clientds.pf.bytes_per_pixel);
 579         }
 580     } else if (vd->server->pf.bytes_per_pixel == 2) {
 581         uint16_t *pixels = pixels1;
 582         int n, i;
 583         n = size >> 1;
 584         for(i = 0; i < n; i++) {
 585             vnc_convert_pixel(vs, buf, pixels[i]);
 586             vnc_write(vs, buf, vs->clientds.pf.bytes_per_pixel);
 587         }
 588     } else if (vd->server->pf.bytes_per_pixel == 1) {
 589         uint8_t *pixels = pixels1;
 590         int n, i;
 591         n = size;
 592         for(i = 0; i < n; i++) {
 593             vnc_convert_pixel(vs, buf, pixels[i]);
 594             vnc_write(vs, buf, vs->clientds.pf.bytes_per_pixel);
 595         }
 596     } else {
 597         fprintf(stderr, "vnc_write_pixels_generic: VncState color depth not supported\n");
 598     }
 599 }
 600
 601 static void send_framebuffer_update_raw(VncState *vs, int x, int y, int w, int h)
 602 {
 603     int i;
 604     uint8_t *row;
 605     VncDisplay *vd = vs->vd;
 606
 607     row = vd->server->data + y * ds_get_linesize(vs->ds) + x * ds_get_bytes_per_pixel(vs->ds);
 608     for (i = 0; i < h; i++) {
 609         vs->write_pixels(vs, row, w * ds_get_bytes_per_pixel(vs->ds));
 610         row += ds_get_linesize(vs->ds);
 611     }
 612 }
 613
 614 static void hextile_enc_cord(uint8_t *ptr, int x, int y, int w, int h)
 615 {
 616     ptr[0] = ((x & 0x0F) << 4) | (y & 0x0F);
 617     ptr[1] = (((w - 1) & 0x0F) << 4) | ((h - 1) & 0x0F);
 618 }
 619
 620 #define BPP 8
 621 #include "vnchextile.h"
 622 #undef BPP
 623
 624 #define BPP 16
 625 #include "vnchextile.h"
 626 #undef BPP
 627
 628 #define BPP 32
 629 #include "vnchextile.h"
 630 #undef BPP
 631
 632 #define GENERIC
 633 #define BPP 8
 634 #include "vnchextile.h"
 635 #undef BPP
 636 #undef GENERIC
 637
 638 #define GENERIC
 639 #define BPP 16
 640 #include "vnchextile.h"
 641 #undef BPP
 642 #undef GENERIC
 643
 644 #define GENERIC
 645 #define BPP 32
 646 #include "vnchextile.h"
 647 #undef BPP
 648 #undef GENERIC
 649
 650 static void send_framebuffer_update_hextile(VncState *vs, int x, int y, int w, int h)
 651 {
 652     int i, j;
 653     int has_fg, has_bg;
 654     uint8_t *last_fg, *last_bg;
 655     VncDisplay *vd = vs->vd;
 656
 657     last_fg = (uint8_t *) qemu_malloc(vd->server->pf.bytes_per_pixel);
 658     last_bg = (uint8_t *) qemu_malloc(vd->server->pf.bytes_per_pixel);
 659     has_fg = has_bg = 0;
 660     for (j = y; j < (y + h); j += 16) {
 661         for (i = x; i < (x + w); i += 16) {
 662             vs->send_hextile_tile(vs, i, j,
 663                                   MIN(16, x + w - i), MIN(16, y + h - j),
 664                                   last_bg, last_fg, &has_bg, &has_fg);
 665         }
 666     }
 667     free(last_fg);
 668     free(last_bg);
 669
 670 }
 671
 672 #define ZALLOC_ALIGNMENT 16
 673
 674 static void *zalloc(void *x, unsigned items, unsigned size)
 675 {
 676     void *p;
 677
 678     size *= items;
 679     size = (size + ZALLOC_ALIGNMENT - 1) & ~(ZALLOC_ALIGNMENT - 1);
 680
 681     p = qemu_mallocz(size);
 682
 683     return (p);
 684 }
 685
 686 static void zfree(void *x, void *addr)
 687 {
 688     qemu_free(addr);
 689 }
 690
 691 static void vnc_zlib_init(VncState *vs)
 692 {
 693     int i;
 694     for (i=0; i<(sizeof(vs->zlib_stream) / sizeof(z_stream)); i++)
 695         vs->zlib_stream[i].opaque = NULL;
 696 }
 697
 698 static void vnc_zlib_start(VncState *vs)
 699 {
 700     buffer_reset(&vs->zlib);
 701
 702     // make the output buffer be the zlib buffer, so we can compress it later
 703     vs->zlib_tmp = vs->output;
 704     vs->output = vs->zlib;
 705 }
 706
 707 static int vnc_zlib_stop(VncState *vs, int stream_id)
 708 {
 709     z_streamp zstream = &vs->zlib_stream[stream_id];
 710     int previous_out;
 711
 712     // switch back to normal output/zlib buffers
 713     vs->zlib = vs->output;
 714     vs->output = vs->zlib_tmp;
 715
 716     // compress the zlib buffer
 717
 718     // initialize the stream
 719     // XXX need one stream per session
 720     if (zstream->opaque != vs) {
 721         int err;
 722
 723         VNC_DEBUG("VNC: initializing zlib stream %d\n", stream_id);
 724         VNC_DEBUG("VNC: opaque = %p | vs = %p\n", zstream->opaque, vs);
 725         zstream->zalloc = zalloc;
 726         zstream->zfree = zfree;
 727
 728         err = deflateInit2(zstream, vs->tight_compression, Z_DEFLATED, MAX_WBITS,
 729                            MAX_MEM_LEVEL, Z_DEFAULT_STRATEGY);
 730
 731         if (err != Z_OK) {
 732             fprintf(stderr, "VNC: error initializing zlib\n");
 733             return -1;
 734         }
 735
 736         zstream->opaque = vs;
 737     }
 738
 739     // XXX what to do if tight_compression changed in between?
 740
 741     // reserve memory in output buffer
 742     buffer_reserve(&vs->output, vs->zlib.offset + 64);
 743
 744     // set pointers
 745     zstream->next_in = vs->zlib.buffer;
 746     zstream->avail_in = vs->zlib.offset;
 747     zstream->next_out = vs->output.buffer + vs->output.offset;
 748     zstream->avail_out = vs->output.capacity - vs->output.offset;
 749     zstream->data_type = Z_BINARY;
 750     previous_out = zstream->total_out;
 751
 752     // start encoding
 753     if (deflate(zstream, Z_SYNC_FLUSH) != Z_OK) {
 754         fprintf(stderr, "VNC: error during zlib compression\n");
 755         return -1;
 756     }
 757
 758     vs->output.offset = vs->output.capacity - zstream->avail_out;
 759     return zstream->total_out - previous_out;
 760 }
 761
 762 static void send_framebuffer_update_zlib(VncState *vs, int x, int y, int w, int h)
 763 {
 764     int old_offset, new_offset, bytes_written;
 765
 766     vnc_framebuffer_update(vs, x, y, w, h, VNC_ENCODING_ZLIB);
 767
 768     // remember where we put in the follow-up size
 769     old_offset = vs->output.offset;
 770     vnc_write_s32(vs, 0);
 771
 772     // compress the stream
 773     vnc_zlib_start(vs);
 774     send_framebuffer_update_raw(vs, x, y, w, h);
 775     bytes_written = vnc_zlib_stop(vs, 0);
 776
 777     if (bytes_written == -1)
 778         return;
 779
 780     // hack in the size
 781     new_offset = vs->output.offset;
 782     vs->output.offset = old_offset;
 783     vnc_write_u32(vs, bytes_written);
 784     vs->output.offset = new_offset;
 785 }
 786
 787 static void send_framebuffer_update(VncState *vs, int x, int y, int w, int h)
 788 {
 789     switch(vs->vnc_encoding) {
 790         case VNC_ENCODING_ZLIB:
 791             send_framebuffer_update_zlib(vs, x, y, w, h);
 792             break;
 793         case VNC_ENCODING_HEXTILE:
 794             vnc_framebuffer_update(vs, x, y, w, h, VNC_ENCODING_HEXTILE);
 795             send_framebuffer_update_hextile(vs, x, y, w, h);
 796             break;
 797         default:
 798             vnc_framebuffer_update(vs, x, y, w, h, VNC_ENCODING_RAW);
 799             send_framebuffer_update_raw(vs, x, y, w, h);
 800             break;
 801     }
 802 }
 803
 804 static void vnc_copy(VncState *vs, int src_x, int src_y, int dst_x, int dst_y, int w, int h)
 805 {
 806     /* send bitblit op to the vnc client */
 807     vnc_write_u8(vs, 0);  /* msg id */
 808     vnc_write_u8(vs, 0);
 809     vnc_write_u16(vs, 1); /* number of rects */
 810     vnc_framebuffer_update(vs, dst_x, dst_y, w, h, VNC_ENCODING_COPYRECT);
 811     vnc_write_u16(vs, src_x);
 812     vnc_write_u16(vs, src_y);
 813     vnc_flush(vs);
 814 }
 815
 816 static void vnc_dpy_copy(DisplayState *ds, int src_x, int src_y, int dst_x, int dst_y, int w, int h)
 817 {
 818     VncDisplay *vd = ds->opaque;
 819     VncState *vs, *vn;
 820     uint8_t *src_row;
 821     uint8_t *dst_row;
 822     int i,x,y,pitch,depth,inc,w_lim,s;
 823     int cmp_bytes;
 824
 825     vnc_refresh_server_surface(vd);
 826     for (vs = vd->clients; vs != NULL; vs = vn) {
 827         vn = vs->next;
 828         if (vnc_has_feature(vs, VNC_FEATURE_COPYRECT)) {
 829             vs->force_update = 1;
 830             vnc_update_client(vs, 1);
 831             /* vs might be free()ed here */
 832         }
 833     }
 834
 835     /* do bitblit op on the local surface too */
 836     pitch = ds_get_linesize(vd->ds);
 837     depth = ds_get_bytes_per_pixel(vd->ds);
 838     src_row = vd->server->data + pitch * src_y + depth * src_x;
 839     dst_row = vd->server->data + pitch * dst_y + depth * dst_x;
 840     y = dst_y;
 841     inc = 1;
 842     if (dst_y > src_y) {
 843         /* copy backwards */
 844         src_row += pitch * (h-1);
 845         dst_row += pitch * (h-1);
 846         pitch = -pitch;
 847         y = dst_y + h - 1;
 848         inc = -1;
 849     }
 850     w_lim = w - (16 - (dst_x % 16));
 851     if (w_lim < 0)
 852         w_lim = w;
 853     else
 854         w_lim = w - (w_lim % 16);
 855     for (i = 0; i < h; i++) {
 856         for (x = 0; x <= w_lim;
 857                 x += s, src_row += cmp_bytes, dst_row += cmp_bytes) {
 858             if (x == w_lim) {
 859                 if ((s = w - w_lim) == 0)
 860                     break;
 861             } else if (!x) {
 862                 s = (16 - (dst_x % 16));
 863                 s = MIN(s, w_lim);
 864             } else {
 865                 s = 16;
 866             }
 867             cmp_bytes = s * depth;
 868             if (memcmp(src_row, dst_row, cmp_bytes) == 0)
 869                 continue;
 870             memmove(dst_row, src_row, cmp_bytes);
 871             vs = vd->clients;
 872             while (vs != NULL) {
 873                 if (!vnc_has_feature(vs, VNC_FEATURE_COPYRECT))
 874                     vnc_set_bit(vs->dirty[y], ((x + dst_x) / 16));
 875                 vs = vs->next;
 876             }
 877         }
 878         src_row += pitch - w * depth;
 879         dst_row += pitch - w * depth;
 880         y += inc;
 881     }
 882
 883     for (vs = vd->clients; vs != NULL; vs = vs->next) {
 884         if (vnc_has_feature(vs, VNC_FEATURE_COPYRECT))
 885             vnc_copy(vs, src_x, src_y, dst_x, dst_y, w, h);
 886     }
 887 }
 888
 889 static int find_and_clear_dirty_height(struct VncState *vs,
 890                                        int y, int last_x, int x)
 891 {
 892     int h;
 893     VncDisplay *vd = vs->vd;
 894
 895     for (h = 1; h < (vd->server->height - y); h++) {
 896         int tmp_x;
 897         if (!vnc_get_bit(vs->dirty[y + h], last_x))
 898             break;
 899         for (tmp_x = last_x; tmp_x < x; tmp_x++)
 900             vnc_clear_bit(vs->dirty[y + h], tmp_x);
 901     }
 902
 903     return h;
 904 }
 905
 906 static int vnc_update_client(VncState *vs, int has_dirty)
 907 {
 908     if (vs->need_update && vs->csock != -1) {
 909         VncDisplay *vd = vs->vd;
 910         int y;
 911         int n_rectangles;
 912         int saved_offset;
 913
 914         if (vs->output.offset && !vs->audio_cap && !vs->force_update)
 915             /* kernel send buffers are full -> drop frames to throttle */
 916             return 0;
 917
 918         if (!has_dirty && !vs->audio_cap && !vs->force_update)
 919             return 0;
 920
 921         /*
 922          * Send screen updates to the vnc client using the server
 923          * surface and server dirty map.  guest surface updates
 924          * happening in parallel don't disturb us, the next pass will
 925          * send them to the client.
 926          */
 927         n_rectangles = 0;
 928         vnc_write_u8(vs, 0);  /* msg id */
 929         vnc_write_u8(vs, 0);
 930         saved_offset = vs->output.offset;
 931         vnc_write_u16(vs, 0);
 932
 933         for (y = 0; y < vd->server->height; y++) {
 934             int x;
 935             int last_x = -1;
 936             for (x = 0; x < vd->server->width / 16; x++) {
 937                 if (vnc_get_bit(vs->dirty[y], x)) {
 938                     if (last_x == -1) {
 939                         last_x = x;
 940                     }
 941                     vnc_clear_bit(vs->dirty[y], x);
 942                 } else {
 943                     if (last_x != -1) {
 944                         int h = find_and_clear_dirty_height(vs, y, last_x, x);
 945                         send_framebuffer_update(vs, last_x * 16, y, (x - last_x) * 16, h);
 946                         n_rectangles++;
 947                     }
 948                     last_x = -1;
 949                 }
 950             }
 951             if (last_x != -1) {
 952                 int h = find_and_clear_dirty_height(vs, y, last_x, x);
 953                 send_framebuffer_update(vs, last_x * 16, y, (x - last_x) * 16, h);
 954                 n_rectangles++;
 955             }
 956         }
 957         vs->output.buffer[saved_offset] = (n_rectangles >> 8) & 0xFF;
 958         vs->output.buffer[saved_offset + 1] = n_rectangles & 0xFF;
 959         vnc_flush(vs);
 960         vs->force_update = 0;
 961         return n_rectangles;
 962     }
 963
 964     if (vs->csock == -1)
 965         vnc_disconnect_finish(vs);
 966
 967     return 0;
 968 }
 969
 970 /* audio */
 971 static void audio_capture_notify(void *opaque, audcnotification_e cmd)
 972 {
 973     VncState *vs = opaque;
 974
 975     switch (cmd) {
 976     case AUD_CNOTIFY_DISABLE:
 977         vnc_write_u8(vs, 255);
 978         vnc_write_u8(vs, 1);
 979         vnc_write_u16(vs, 0);
 980         vnc_flush(vs);
 981         break;
 982
 983     case AUD_CNOTIFY_ENABLE:
 984         vnc_write_u8(vs, 255);
 985         vnc_write_u8(vs, 1);
 986         vnc_write_u16(vs, 1);
 987         vnc_flush(vs);
 988         break;
 989     }
 990 }
 991
 992 static void audio_capture_destroy(void *opaque)
 993 {
 994 }
 995
 996 static void audio_capture(void *opaque, void *buf, int size)
 997 {
 998     VncState *vs = opaque;
 999
1000     vnc_write_u8(vs, 255);
1001     vnc_write_u8(vs, 1);
1002     vnc_write_u16(vs, 2);
1003     vnc_write_u32(vs, size);
1004     vnc_write(vs, buf, size);
1005     vnc_flush(vs);
1006 }
1007
1008 static void audio_add(VncState *vs)
1009 {
1010     Monitor *mon = cur_mon;
1011     struct audio_capture_ops ops;
1012
1013     if (vs->audio_cap) {
1014         monitor_printf(mon, "audio already running\n");
1015         return;
1016     }
1017
1018     ops.notify = audio_capture_notify;
1019     ops.destroy = audio_capture_destroy;
1020     ops.capture = audio_capture;
1021
1022     vs->audio_cap = AUD_add_capture(&vs->as, &ops, vs);
1023     if (!vs->audio_cap) {
1024         monitor_printf(mon, "Failed to add audio capture\n");
1025     }
1026 }
1027
1028 static void audio_del(VncState *vs)
1029 {
1030     if (vs->audio_cap) {
1031         AUD_del_capture(vs->audio_cap, vs);
1032         vs->audio_cap = NULL;
1033     }
1034 }
1035
1036 static void vnc_disconnect_start(VncState *vs)
1037 {
1038     if (vs->csock == -1)
1039         return;
1040     qemu_set_fd_handler2(vs->csock, NULL, NULL, NULL, NULL);
1041     closesocket(vs->csock);
1042     vs->csock = -1;
1043 }
1044
1045 static void vnc_disconnect_finish(VncState *vs)
1046 {
1047     if (vs->input.buffer) {
1048         qemu_free(vs->input.buffer);
1049         vs->input.buffer = NULL;
1050     }
1051     if (vs->output.buffer) {
1052         qemu_free(vs->output.buffer);
1053         vs->output.buffer = NULL;
1054     }
1055 #ifdef CONFIG_VNC_TLS
1056     vnc_tls_client_cleanup(vs);
1057 #endif /* CONFIG_VNC_TLS */
1058 #ifdef CONFIG_VNC_SASL
1059     vnc_sasl_client_cleanup(vs);
1060 #endif /* CONFIG_VNC_SASL */
1061     audio_del(vs);
1062
1063     VncState *p, *parent = NULL;
1064     for (p = vs->vd->clients; p != NULL; p = p->next) {
1065         if (p == vs) {
1066             if (parent)
1067                 parent->next = p->next;
1068             else
1069                 vs->vd->clients = p->next;
1070             break;
1071         }
1072         parent = p;
1073     }
1074     if (!vs->vd->clients)
1075         dcl->idle = 1;
1076
1077     vnc_remove_timer(vs->vd);
1078     qemu_free(vs);
1079 }
1080
1081 int vnc_client_io_error(VncState *vs, int ret, int last_errno)
1082 {
1083     if (ret == 0 || ret == -1) {
1084         if (ret == -1) {
1085             switch (last_errno) {
1086                 case EINTR:
1087                 case EAGAIN:
1088 #ifdef _WIN32
1089                 case WSAEWOULDBLOCK:
1090 #endif
1091                     return 0;
1092                 default:
1093                     break;
1094             }
1095         }
1096
1097         VNC_DEBUG("Closing down client sock: ret %d, errno %d\n",
1098                   ret, ret < 0 ? last_errno : 0);
1099         vnc_disconnect_start(vs);
1100
1101         return 0;
1102     }
1103     return ret;
1104 }
1105
1106
1107 void vnc_client_error(VncState *vs)
1108 {
1109     VNC_DEBUG("Closing down client sock: protocol error\n");
1110     vnc_disconnect_start(vs);
1111 }
1112
1113
1114 /*
1115  * Called to write a chunk of data to the client socket. The data may
1116  * be the raw data, or may have already been encoded by SASL.
1117  * The data will be written either straight onto the socket, or
1118  * written via the GNUTLS wrappers, if TLS/SSL encryption is enabled
1119  *
1120  * NB, it is theoretically possible to have 2 layers of encryption,
1121  * both SASL, and this TLS layer. It is highly unlikely in practice
1122  * though, since SASL encryption will typically be a no-op if TLS
1123  * is active
1124  *
1125  * Returns the number of bytes written, which may be less than
1126  * the requested 'datalen' if the socket would block. Returns
1127  * -1 on error, and disconnects the client socket.
1128  */
1129 long vnc_client_write_buf(VncState *vs, const uint8_t *data, size_t datalen)
1130 {
1131     long ret;
1132 #ifdef CONFIG_VNC_TLS
1133     if (vs->tls.session) {
1134         ret = gnutls_write(vs->tls.session, data, datalen);
1135         if (ret < 0) {
1136             if (ret == GNUTLS_E_AGAIN)
1137                 errno = EAGAIN;
1138             else
1139                 errno = EIO;
1140             ret = -1;
1141         }
1142     } else
1143 #endif /* CONFIG_VNC_TLS */
1144         ret = send(vs->csock, (const void *)data, datalen, 0);
1145     VNC_DEBUG("Wrote wire %p %zd -> %ld\n", data, datalen, ret);
1146     return vnc_client_io_error(vs, ret, socket_error());
1147 }
1148
1149
1150 /*
1151  * Called to write buffered data to the client socket, when not
1152  * using any SASL SSF encryption layers. Will write as much data
1153  * as possible without blocking. If all buffered data is written,
1154  * will switch the FD poll() handler back to read monitoring.
1155  *
1156  * Returns the number of bytes written, which may be less than
1157  * the buffered output data if the socket would block. Returns
1158  * -1 on error, and disconnects the client socket.
1159  */
1160 static long vnc_client_write_plain(VncState *vs)
1161 {
1162     long ret;
1163
1164 #ifdef CONFIG_VNC_SASL
1165     VNC_DEBUG("Write Plain: Pending output %p size %zd offset %zd. Wait SSF %d\n",
1166               vs->output.buffer, vs->output.capacity, vs->output.offset,
1167               vs->sasl.waitWriteSSF);
1168
1169     if (vs->sasl.conn &&
1170         vs->sasl.runSSF &&
1171         vs->sasl.waitWriteSSF) {
1172         ret = vnc_client_write_buf(vs, vs->output.buffer, vs->sasl.waitWriteSSF);
1173         if (ret)
1174             vs->sasl.waitWriteSSF -= ret;
1175     } else
1176 #endif /* CONFIG_VNC_SASL */
1177         ret = vnc_client_write_buf(vs, vs->output.buffer, vs->output.offset);
1178     if (!ret)
1179         return 0;
1180
1181     memmove(vs->output.buffer, vs->output.buffer + ret, (vs->output.offset - ret));
1182     vs->output.offset -= ret;
1183
1184     if (vs->output.offset == 0) {
1185         qemu_set_fd_handler2(vs->csock, NULL, vnc_client_read, NULL, vs);
1186     }
1187
1188     return ret;
1189 }
1190
1191
1192 /*
1193  * First function called whenever there is data to be written to
1194  * the client socket. Will delegate actual work according to whether
1195  * SASL SSF layers are enabled (thus requiring encryption calls)
1196  */
1197 void vnc_client_write(void *opaque)
1198 {
1199     long ret;
1200     VncState *vs = opaque;
1201
1202 #ifdef CONFIG_VNC_SASL
1203     if (vs->sasl.conn &&
1204         vs->sasl.runSSF &&
1205         !vs->sasl.waitWriteSSF)
1206         ret = vnc_client_write_sasl(vs);
1207     else
1208 #endif /* CONFIG_VNC_SASL */
1209         ret = vnc_client_write_plain(vs);
1210 }
1211
1212 void vnc_read_when(VncState *vs, VncReadEvent *func, size_t expecting)
1213 {
1214     vs->read_handler = func;
1215     vs->read_handler_expect = expecting;
1216 }
1217
1218
1219 /*
1220  * Called to read a chunk of data from the client socket. The data may
1221  * be the raw data, or may need to be further decoded by SASL.
1222  * The data will be read either straight from to the socket, or
1223  * read via the GNUTLS wrappers, if TLS/SSL encryption is enabled
1224  *
1225  * NB, it is theoretically possible to have 2 layers of encryption,
1226  * both SASL, and this TLS layer. It is highly unlikely in practice
1227  * though, since SASL encryption will typically be a no-op if TLS
1228  * is active
1229  *
1230  * Returns the number of bytes read, which may be less than
1231  * the requested 'datalen' if the socket would block. Returns
1232  * -1 on error, and disconnects the client socket.
1233  */
1234 long vnc_client_read_buf(VncState *vs, uint8_t *data, size_t datalen)
1235 {
1236     long ret;
1237 #ifdef CONFIG_VNC_TLS
1238     if (vs->tls.session) {
1239         ret = gnutls_read(vs->tls.session, data, datalen);
1240         if (ret < 0) {
1241             if (ret == GNUTLS_E_AGAIN)
1242                 errno = EAGAIN;
1243             else
1244                 errno = EIO;
1245             ret = -1;
1246         }
1247     } else
1248 #endif /* CONFIG_VNC_TLS */
1249         ret = recv(vs->csock, (void *)data, datalen, 0);
1250     VNC_DEBUG("Read wire %p %zd -> %ld\n", data, datalen, ret);
1251     return vnc_client_io_error(vs, ret, socket_error());
1252 }
1253
1254
1255 /*
1256  * Called to read data from the client socket to the input buffer,
1257  * when not using any SASL SSF encryption layers. Will read as much
1258  * data as possible without blocking.
1259  *
1260  * Returns the number of bytes read. Returns -1 on error, and
1261  * disconnects the client socket.
1262  */
1263 static long vnc_client_read_plain(VncState *vs)
1264 {
1265     int ret;
1266     VNC_DEBUG("Read plain %p size %zd offset %zd\n",
1267               vs->input.buffer, vs->input.capacity, vs->input.offset);
1268     buffer_reserve(&vs->input, 4096);
1269     ret = vnc_client_read_buf(vs, buffer_end(&vs->input), 4096);
1270     if (!ret)
1271         return 0;
1272     vs->input.offset += ret;
1273     return ret;
1274 }
1275
1276
1277 /*
1278  * First function called whenever there is more data to be read from
1279  * the client socket. Will delegate actual work according to whether
1280  * SASL SSF layers are enabled (thus requiring decryption calls)
1281  */
1282 void vnc_client_read(void *opaque)
1283 {
1284     VncState *vs = opaque;
1285     long ret;
1286
1287 #ifdef CONFIG_VNC_SASL
1288     if (vs->sasl.conn && vs->sasl.runSSF)
1289         ret = vnc_client_read_sasl(vs);
1290     else
1291 #endif /* CONFIG_VNC_SASL */
1292         ret = vnc_client_read_plain(vs);
1293     if (!ret) {
1294         if (vs->csock == -1)
1295             vnc_disconnect_finish(vs);
1296         return;
1297     }
1298
1299     while (vs->read_handler && vs->input.offset >= vs->read_handler_expect) {
1300         size_t len = vs->read_handler_expect;
1301         int ret;
1302
1303         ret = vs->read_handler(vs, vs->input.buffer, len);
1304         if (vs->csock == -1) {
1305             vnc_disconnect_finish(vs);
1306             return;
1307         }
1308
1309         if (!ret) {
1310             memmove(vs->input.buffer, vs->input.buffer + len, (vs->input.offset - len));
1311             vs->input.offset -= len;
1312         } else {
1313             vs->read_handler_expect = ret;
1314         }
1315     }
1316 }
1317
1318 void vnc_write(VncState *vs, const void *data, size_t len)
1319 {
1320     buffer_reserve(&vs->output, len);
1321
1322     if (vs->csock != -1 && buffer_empty(&vs->output)) {
1323         qemu_set_fd_handler2(vs->csock, NULL, vnc_client_read, vnc_client_write, vs);
1324     }
1325
1326     buffer_append(&vs->output, data, len);
1327 }
1328
1329 void vnc_write_s32(VncState *vs, int32_t value)
1330 {
1331     vnc_write_u32(vs, *(uint32_t *)&value);
1332 }
1333
1334 void vnc_write_u32(VncState *vs, uint32_t value)
1335 {
1336     uint8_t buf[4];
1337
1338     buf[0] = (value >> 24) & 0xFF;
1339     buf[1] = (value >> 16) & 0xFF;
1340     buf[2] = (value >>  8) & 0xFF;
1341     buf[3] = value & 0xFF;
1342
1343     vnc_write(vs, buf, 4);
1344 }
1345
1346 void vnc_write_u16(VncState *vs, uint16_t value)
1347 {
1348     uint8_t buf[2];
1349
1350     buf[0] = (value >> 8) & 0xFF;
1351     buf[1] = value & 0xFF;
1352
1353     vnc_write(vs, buf, 2);
1354 }
1355
1356 void vnc_write_u8(VncState *vs, uint8_t value)
1357 {
1358     vnc_write(vs, (char *)&value, 1);
1359 }
1360
1361 void vnc_flush(VncState *vs)
1362 {
1363     if (vs->csock != -1 && vs->output.offset)
1364         vnc_client_write(vs);
1365 }
1366
1367 uint8_t read_u8(uint8_t *data, size_t offset)
1368 {
1369     return data[offset];
1370 }
1371
1372 uint16_t read_u16(uint8_t *data, size_t offset)
1373 {
1374     return ((data[offset] & 0xFF) << 8) | (data[offset + 1] & 0xFF);
1375 }
1376
1377 int32_t read_s32(uint8_t *data, size_t offset)
1378 {
1379     return (int32_t)((data[offset] << 24) | (data[offset + 1] << 16) |
1380                      (data[offset + 2] << 8) | data[offset + 3]);
1381 }
1382
1383 uint32_t read_u32(uint8_t *data, size_t offset)
1384 {
1385     return ((data[offset] << 24) | (data[offset + 1] << 16) |
1386             (data[offset + 2] << 8) | data[offset + 3]);
1387 }
1388
1389 static void client_cut_text(VncState *vs, size_t len, uint8_t *text)
1390 {
1391 }
1392
1393 static void check_pointer_type_change(VncState *vs, int absolute)
1394 {
1395     if (vnc_has_feature(vs, VNC_FEATURE_POINTER_TYPE_CHANGE) && vs->absolute != absolute) {
1396         vnc_write_u8(vs, 0);
1397         vnc_write_u8(vs, 0);
1398         vnc_write_u16(vs, 1);
1399         vnc_framebuffer_update(vs, absolute, 0,
1400                                ds_get_width(vs->ds), ds_get_height(vs->ds),
1401                                VNC_ENCODING_POINTER_TYPE_CHANGE);
1402         vnc_flush(vs);
1403     }
1404     vs->absolute = absolute;
1405 }
1406
1407 static void pointer_event(VncState *vs, int button_mask, int x, int y)
1408 {
1409     int buttons = 0;
1410     int dz = 0;
1411
1412     if (button_mask & 0x01)
1413         buttons |= MOUSE_EVENT_LBUTTON;
1414     if (button_mask & 0x02)
1415         buttons |= MOUSE_EVENT_MBUTTON;
1416     if (button_mask & 0x04)
1417         buttons |= MOUSE_EVENT_RBUTTON;
1418     if (button_mask & 0x08)
1419         dz = -1;
1420     if (button_mask & 0x10)
1421         dz = 1;
1422
1423     if (vs->absolute) {
1424         kbd_mouse_event(x * 0x7FFF / (ds_get_width(vs->ds) - 1),
1425                         y * 0x7FFF / (ds_get_height(vs->ds) - 1),
1426                         dz, buttons);
1427     } else if (vnc_has_feature(vs, VNC_FEATURE_POINTER_TYPE_CHANGE)) {
1428         x -= 0x7FFF;
1429         y -= 0x7FFF;
1430
1431         kbd_mouse_event(x, y, dz, buttons);
1432     } else {
1433         if (vs->last_x != -1)
1434             kbd_mouse_event(x - vs->last_x,
1435                             y - vs->last_y,
1436                             dz, buttons);
1437         vs->last_x = x;
1438         vs->last_y = y;
1439     }
1440
1441     check_pointer_type_change(vs, kbd_mouse_is_absolute());
1442 }
1443
1444 static void reset_keys(VncState *vs)
1445 {
1446     int i;
1447     for(i = 0; i < 256; i++) {
1448         if (vs->modifiers_state[i]) {
1449             if (i & 0x80)
1450                 kbd_put_keycode(0xe0);
1451             kbd_put_keycode(i | 0x80);
1452             vs->modifiers_state[i] = 0;
1453         }
1454     }
1455 }
1456
1457 static void press_key(VncState *vs, int keysym)
1458 {
1459     kbd_put_keycode(keysym2scancode(vs->vd->kbd_layout, keysym) & 0x7f);
1460     kbd_put_keycode(keysym2scancode(vs->vd->kbd_layout, keysym) | 0x80);
1461 }
1462
1463 static void do_key_event(VncState *vs, int down, int keycode, int sym)
1464 {
1465     /* QEMU console switch */
1466     switch(keycode) {
1467     case 0x2a:                          /* Left Shift */
1468     case 0x36:                          /* Right Shift */
1469     case 0x1d:                          /* Left CTRL */
1470     case 0x9d:                          /* Right CTRL */
1471     case 0x38:                          /* Left ALT */
1472     case 0xb8:                          /* Right ALT */
1473         if (down)
1474             vs->modifiers_state[keycode] = 1;
1475         else
1476             vs->modifiers_state[keycode] = 0;
1477         break;
1478     case 0x02 ... 0x0a: /* '1' to '9' keys */
1479         if (down && vs->modifiers_state[0x1d] && vs->modifiers_state[0x38]) {
1480             /* Reset the modifiers sent to the current console */
1481             reset_keys(vs);
1482             console_select(keycode - 0x02);
1483             return;
1484         }
1485         break;
1486     case 0x3a:                        /* CapsLock */
1487     case 0x45:                        /* NumLock */
1488         if (!down)
1489             vs->modifiers_state[keycode] ^= 1;
1490         break;
1491     }
1492
1493     if (keycode_is_keypad(vs->vd->kbd_layout, keycode)) {
1494         /* If the numlock state needs to change then simulate an additional
1495            keypress before sending this one.  This will happen if the user
1496            toggles numlock away from the VNC window.
1497         */
1498         if (keysym_is_numlock(vs->vd->kbd_layout, sym & 0xFFFF)) {
1499             if (!vs->modifiers_state[0x45]) {
1500                 vs->modifiers_state[0x45] = 1;
1501                 press_key(vs, 0xff7f);
1502             }
1503         } else {
1504             if (vs->modifiers_state[0x45]) {
1505                 vs->modifiers_state[0x45] = 0;
1506                 press_key(vs, 0xff7f);
1507             }
1508         }
1509     }
1510
1511     if ((sym >= 'A' && sym <= 'Z') || (sym >= 'a' && sym <= 'z')) {
1512         /* If the capslock state needs to change then simulate an additional
1513            keypress before sending this one.  This will happen if the user
1514            toggles capslock away from the VNC window.
1515         */
1516         int uppercase = !!(sym >= 'A' && sym <= 'Z');
1517         int shift = !!(vs->modifiers_state[0x2a] | vs->modifiers_state[0x36]);
1518         int capslock = !!(vs->modifiers_state[0x3a]);
1519         if (capslock) {
1520             if (uppercase == shift) {
1521                 vs->modifiers_state[0x3a] = 0;
1522                 press_key(vs, 0xffe5);
1523             }
1524         } else {
1525             if (uppercase != shift) {
1526                 vs->modifiers_state[0x3a] = 1;
1527                 press_key(vs, 0xffe5);
1528             }
1529         }
1530     }
1531
1532     if (is_graphic_console()) {
1533         if (keycode & 0x80)
1534             kbd_put_keycode(0xe0);
1535         if (down)
1536             kbd_put_keycode(keycode & 0x7f);
1537         else
1538             kbd_put_keycode(keycode | 0x80);
1539     } else {
1540         /* QEMU console emulation */
1541         if (down) {
1542             int numlock = vs->modifiers_state[0x45];
1543             switch (keycode) {
1544             case 0x2a:                          /* Left Shift */
1545             case 0x36:                          /* Right Shift */
1546             case 0x1d:                          /* Left CTRL */
1547             case 0x9d:                          /* Right CTRL */
1548             case 0x38:                          /* Left ALT */
1549             case 0xb8:                          /* Right ALT */
1550                 break;
1551             case 0xc8:
1552                 kbd_put_keysym(QEMU_KEY_UP);
1553                 break;
1554             case 0xd0:
1555                 kbd_put_keysym(QEMU_KEY_DOWN);
1556                 break;
1557             case 0xcb:
1558                 kbd_put_keysym(QEMU_KEY_LEFT);
1559                 break;
1560             case 0xcd:
1561                 kbd_put_keysym(QEMU_KEY_RIGHT);
1562                 break;
1563             case 0xd3:
1564                 kbd_put_keysym(QEMU_KEY_DELETE);
1565                 break;
1566             case 0xc7:
1567                 kbd_put_keysym(QEMU_KEY_HOME);
1568                 break;
1569             case 0xcf:
1570                 kbd_put_keysym(QEMU_KEY_END);
1571                 break;
1572             case 0xc9:
1573                 kbd_put_keysym(QEMU_KEY_PAGEUP);
1574                 break;
1575             case 0xd1:
1576                 kbd_put_keysym(QEMU_KEY_PAGEDOWN);
1577                 break;
1578
1579             case 0x47:
1580                 kbd_put_keysym(numlock ? '7' : QEMU_KEY_HOME);
1581                 break;
1582             case 0x48:
1583                 kbd_put_keysym(numlock ? '8' : QEMU_KEY_UP);
1584                 break;
1585             case 0x49:
1586                 kbd_put_keysym(numlock ? '9' : QEMU_KEY_PAGEUP);
1587                 break;
1588             case 0x4b:
1589                 kbd_put_keysym(numlock ? '4' : QEMU_KEY_LEFT);
1590                 break;
1591             case 0x4c:
1592                 kbd_put_keysym('5');
1593                 break;
1594             case 0x4d:
1595                 kbd_put_keysym(numlock ? '6' : QEMU_KEY_RIGHT);
1596                 break;
1597             case 0x4f:
1598                 kbd_put_keysym(numlock ? '1' : QEMU_KEY_END);
1599                 break;
1600             case 0x50:
1601                 kbd_put_keysym(numlock ? '2' : QEMU_KEY_DOWN);
1602                 break;
1603             case 0x51:
1604                 kbd_put_keysym(numlock ? '3' : QEMU_KEY_PAGEDOWN);
1605                 break;
1606             case 0x52:
1607                 kbd_put_keysym('0');
1608                 break;
1609             case 0x53:
1610                 kbd_put_keysym(numlock ? '.' : QEMU_KEY_DELETE);
1611                 break;
1612
1613             case 0xb5:
1614                 kbd_put_keysym('/');
1615                 break;
1616             case 0x37:
1617                 kbd_put_keysym('*');
1618                 break;
1619             case 0x4a:
1620                 kbd_put_keysym('-');
1621                 break;
1622             case 0x4e:
1623                 kbd_put_keysym('+');
1624                 break;
1625             case 0x9c:
1626                 kbd_put_keysym('\n');
1627                 break;
1628
1629             default:
1630                 kbd_put_keysym(sym);
1631                 break;
1632             }
1633         }
1634     }
1635 }
1636
1637 static void key_event(VncState *vs, int down, uint32_t sym)
1638 {
1639     int keycode;
1640     int lsym = sym;
1641
1642     if (lsym >= 'A' && lsym <= 'Z' && is_graphic_console()) {
1643         lsym = lsym - 'A' + 'a';
1644     }
1645
1646     keycode = keysym2scancode(vs->vd->kbd_layout, lsym & 0xFFFF);
1647     do_key_event(vs, down, keycode, sym);
1648 }
1649
1650 static void ext_key_event(VncState *vs, int down,
1651                           uint32_t sym, uint16_t keycode)
1652 {
1653     /* if the user specifies a keyboard layout, always use it */
1654     if (keyboard_layout)
1655         key_event(vs, down, sym);
1656     else
1657         do_key_event(vs, down, keycode, sym);
1658 }
1659
1660 static void framebuffer_update_request(VncState *vs, int incremental,
1661                                        int x_position, int y_position,
1662                                        int w, int h)
1663 {
1664     if (x_position > ds_get_width(vs->ds))
1665         x_position = ds_get_width(vs->ds);
1666     if (y_position > ds_get_height(vs->ds))
1667         y_position = ds_get_height(vs->ds);
1668     if (x_position + w >= ds_get_width(vs->ds))
1669         w = ds_get_width(vs->ds)  - x_position;
1670     if (y_position + h >= ds_get_height(vs->ds))
1671         h = ds_get_height(vs->ds) - y_position;
1672
1673     int i;
1674     vs->need_update = 1;
1675     if (!incremental) {
1676         vs->force_update = 1;
1677         for (i = 0; i < h; i++) {
1678             vnc_set_bits(vs->dirty[y_position + i],
1679                          (ds_get_width(vs->ds) / 16), VNC_DIRTY_WORDS);
1680         }
1681     }
1682 }
1683
1684 static void send_ext_key_event_ack(VncState *vs)
1685 {
1686     vnc_write_u8(vs, 0);
1687     vnc_write_u8(vs, 0);
1688     vnc_write_u16(vs, 1);
1689     vnc_framebuffer_update(vs, 0, 0, ds_get_width(vs->ds), ds_get_height(vs->ds),
1690                            VNC_ENCODING_EXT_KEY_EVENT);
1691     vnc_flush(vs);
1692 }
1693
1694 static void send_ext_audio_ack(VncState *vs)
1695 {
1696     vnc_write_u8(vs, 0);
1697     vnc_write_u8(vs, 0);
1698     vnc_write_u16(vs, 1);
1699     vnc_framebuffer_update(vs, 0, 0, ds_get_width(vs->ds), ds_get_height(vs->ds),
1700                            VNC_ENCODING_AUDIO);
1701     vnc_flush(vs);
1702 }
1703
1704 static void set_encodings(VncState *vs, int32_t *encodings, size_t n_encodings)
1705 {
1706     int i;
1707     unsigned int enc = 0;
1708
1709     vnc_zlib_init(vs);
1710     vs->features = 0;
1711     vs->vnc_encoding = 0;
1712     vs->tight_compression = 9;
1713     vs->tight_quality = 9;
1714     vs->absolute = -1;
1715
1716     for (i = n_encodings - 1; i >= 0; i--) {
1717         enc = encodings[i];
1718         switch (enc) {
1719         case VNC_ENCODING_RAW:
1720             vs->vnc_encoding = enc;
1721             break;
1722         case VNC_ENCODING_COPYRECT:
1723             vs->features |= VNC_FEATURE_COPYRECT_MASK;
1724             break;
1725         case VNC_ENCODING_HEXTILE:
1726             vs->features |= VNC_FEATURE_HEXTILE_MASK;
1727             vs->vnc_encoding = enc;
1728             break;
1729         case VNC_ENCODING_ZLIB:
1730             vs->features |= VNC_FEATURE_ZLIB_MASK;
1731             vs->vnc_encoding = enc;
1732             break;
1733         case VNC_ENCODING_DESKTOPRESIZE:
1734             vs->features |= VNC_FEATURE_RESIZE_MASK;
1735             break;
1736         case VNC_ENCODING_POINTER_TYPE_CHANGE:
1737             vs->features |= VNC_FEATURE_POINTER_TYPE_CHANGE_MASK;
1738             break;
1739         case VNC_ENCODING_EXT_KEY_EVENT:
1740             send_ext_key_event_ack(vs);
1741             break;
1742         case VNC_ENCODING_AUDIO:
1743             send_ext_audio_ack(vs);
1744             break;
1745         case VNC_ENCODING_WMVi:
1746             vs->features |= VNC_FEATURE_WMVI_MASK;
1747             break;
1748         case VNC_ENCODING_COMPRESSLEVEL0 ... VNC_ENCODING_COMPRESSLEVEL0 + 9:
1749             vs->tight_compression = (enc & 0x0F);
1750             break;
1751         case VNC_ENCODING_QUALITYLEVEL0 ... VNC_ENCODING_QUALITYLEVEL0 + 9:
1752             vs->tight_quality = (enc & 0x0F);
1753             break;
1754         default:
1755             VNC_DEBUG("Unknown encoding: %d (0x%.8x): %d\n", i, enc, enc);
1756             break;
1757         }
1758     }
1759
1760     check_pointer_type_change(vs, kbd_mouse_is_absolute());
1761 }
1762
1763 static void set_pixel_conversion(VncState *vs)
1764 {
1765     if ((vs->clientds.flags & QEMU_BIG_ENDIAN_FLAG) ==
1766         (vs->ds->surface->flags & QEMU_BIG_ENDIAN_FLAG) &&
1767         !memcmp(&(vs->clientds.pf), &(vs->ds->surface->pf), sizeof(PixelFormat))) {
1768         vs->write_pixels = vnc_write_pixels_copy;
1769         switch (vs->ds->surface->pf.bits_per_pixel) {
1770             case 8:
1771                 vs->send_hextile_tile = send_hextile_tile_8;
1772                 break;
1773             case 16:
1774                 vs->send_hextile_tile = send_hextile_tile_16;
1775                 break;
1776             case 32:
1777                 vs->send_hextile_tile = send_hextile_tile_32;
1778                 break;
1779         }
1780     } else {
1781         vs->write_pixels = vnc_write_pixels_generic;
1782         switch (vs->ds->surface->pf.bits_per_pixel) {
1783             case 8:
1784                 vs->send_hextile_tile = send_hextile_tile_generic_8;
1785                 break;
1786             case 16:
1787                 vs->send_hextile_tile = send_hextile_tile_generic_16;
1788                 break;
1789             case 32:
1790                 vs->send_hextile_tile = send_hextile_tile_generic_32;
1791                 break;
1792         }
1793     }
1794 }
1795
1796 static void set_pixel_format(VncState *vs,
1797                              int bits_per_pixel, int depth,
1798                              int big_endian_flag, int true_color_flag,
1799                              int red_max, int green_max, int blue_max,
1800                              int red_shift, int green_shift, int blue_shift)
1801 {
1802     if (!true_color_flag) {
1803         vnc_client_error(vs);
1804         return;
1805     }
1806
1807     vs->clientds = *(vs->vd->guest.ds);
1808     vs->clientds.pf.rmax = red_max;
1809     count_bits(vs->clientds.pf.rbits, red_max);
1810     vs->clientds.pf.rshift = red_shift;
1811     vs->clientds.pf.rmask = red_max << red_shift;
1812     vs->clientds.pf.gmax = green_max;
1813     count_bits(vs->clientds.pf.gbits, green_max);
1814     vs->clientds.pf.gshift = green_shift;
1815     vs->clientds.pf.gmask = green_max << green_shift;
1816     vs->clientds.pf.bmax = blue_max;
1817     count_bits(vs->clientds.pf.bbits, blue_max);
1818     vs->clientds.pf.bshift = blue_shift;
1819     vs->clientds.pf.bmask = blue_max << blue_shift;
1820     vs->clientds.pf.bits_per_pixel = bits_per_pixel;
1821     vs->clientds.pf.bytes_per_pixel = bits_per_pixel / 8;
1822     vs->clientds.pf.depth = bits_per_pixel == 32 ? 24 : bits_per_pixel;
1823     vs->clientds.flags = big_endian_flag ? QEMU_BIG_ENDIAN_FLAG : 0x00;
1824
1825     set_pixel_conversion(vs);
1826
1827     vga_hw_invalidate();
1828     vga_hw_update();
1829 }
1830
1831 static void pixel_format_message (VncState *vs) {
1832     char pad[3] = { 0, 0, 0 };
1833
1834     vnc_write_u8(vs, vs->ds->surface->pf.bits_per_pixel); /* bits-per-pixel */
1835     vnc_write_u8(vs, vs->ds->surface->pf.depth); /* depth */
1836
1837 #ifdef HOST_WORDS_BIGENDIAN
1838     vnc_write_u8(vs, 1);             /* big-endian-flag */
1839 #else
1840     vnc_write_u8(vs, 0);             /* big-endian-flag */
1841 #endif
1842     vnc_write_u8(vs, 1);             /* true-color-flag */
1843     vnc_write_u16(vs, vs->ds->surface->pf.rmax);     /* red-max */
1844     vnc_write_u16(vs, vs->ds->surface->pf.gmax);     /* green-max */
1845     vnc_write_u16(vs, vs->ds->surface->pf.bmax);     /* blue-max */
1846     vnc_write_u8(vs, vs->ds->surface->pf.rshift);    /* red-shift */
1847     vnc_write_u8(vs, vs->ds->surface->pf.gshift);    /* green-shift */
1848     vnc_write_u8(vs, vs->ds->surface->pf.bshift);    /* blue-shift */
1849     if (vs->ds->surface->pf.bits_per_pixel == 32)
1850         vs->send_hextile_tile = send_hextile_tile_32;
1851     else if (vs->ds->surface->pf.bits_per_pixel == 16)
1852         vs->send_hextile_tile = send_hextile_tile_16;
1853     else if (vs->ds->surface->pf.bits_per_pixel == 8)
1854         vs->send_hextile_tile = send_hextile_tile_8;
1855     vs->clientds = *(vs->ds->surface);
1856     vs->clientds.flags &= ~QEMU_ALLOCATED_FLAG;
1857     vs->write_pixels = vnc_write_pixels_copy;
1858
1859     vnc_write(vs, pad, 3);           /* padding */
1860 }
1861
1862 static void vnc_dpy_setdata(DisplayState *ds)
1863 {
1864     /* We don't have to do anything */
1865 }
1866
1867 static void vnc_colordepth(VncState *vs)
1868 {
1869     if (vnc_has_feature(vs, VNC_FEATURE_WMVI)) {
1870         /* Sending a WMVi message to notify the client*/
1871         vnc_write_u8(vs, 0);  /* msg id */
1872         vnc_write_u8(vs, 0);
1873         vnc_write_u16(vs, 1); /* number of rects */
1874         vnc_framebuffer_update(vs, 0, 0, ds_get_width(vs->ds),
1875                                ds_get_height(vs->ds), VNC_ENCODING_WMVi);
1876         pixel_format_message(vs);
1877         vnc_flush(vs);
1878     } else {
1879         set_pixel_conversion(vs);
1880     }
1881 }
1882
1883 static int protocol_client_msg(VncState *vs, uint8_t *data, size_t len)
1884 {
1885     int i;
1886     uint16_t limit;
1887     VncDisplay *vd = vs->vd;
1888
1889     if (data[0] > 3) {
1890         vd->timer_interval = VNC_REFRESH_INTERVAL_BASE;
1891         if (!qemu_timer_expired(vd->timer, qemu_get_clock(rt_clock) + vd->timer_interval))
1892             qemu_mod_timer(vd->timer, qemu_get_clock(rt_clock) + vd->timer_interval);
1893     }
1894
1895     switch (data[0]) {
1896     case 0:
1897         if (len == 1)
1898             return 20;
1899
1900         set_pixel_format(vs, read_u8(data, 4), read_u8(data, 5),
1901                          read_u8(data, 6), read_u8(data, 7),
1902                          read_u16(data, 8), read_u16(data, 10),
1903                          read_u16(data, 12), read_u8(data, 14),
1904                          read_u8(data, 15), read_u8(data, 16));
1905         break;
1906     case 2:
1907         if (len == 1)
1908             return 4;
1909
1910         if (len == 4) {
1911             limit = read_u16(data, 2);
1912             if (limit > 0)
1913                 return 4 + (limit * 4);
1914         } else
1915             limit = read_u16(data, 2);
1916
1917         for (i = 0; i < limit; i++) {
1918             int32_t val = read_s32(data, 4 + (i * 4));
1919             memcpy(data + 4 + (i * 4), &val, sizeof(val));
1920         }
1921
1922         set_encodings(vs, (int32_t *)(data + 4), limit);
1923         break;
1924     case 3:
1925         if (len == 1)
1926             return 10;
1927
1928         framebuffer_update_request(vs,
1929                                    read_u8(data, 1), read_u16(data, 2), read_u16(data, 4),
1930                                    read_u16(data, 6), read_u16(data, 8));
1931         break;
1932     case 4:
1933         if (len == 1)
1934             return 8;
1935
1936         key_event(vs, read_u8(data, 1), read_u32(data, 4));
1937         break;
1938     case 5:
1939         if (len == 1)
1940             return 6;
1941
1942         pointer_event(vs, read_u8(data, 1), read_u16(data, 2), read_u16(data, 4));
1943         break;
1944     case 6:
1945         if (len == 1)
1946             return 8;
1947
1948         if (len == 8) {
1949             uint32_t dlen = read_u32(data, 4);
1950             if (dlen > 0)
1951                 return 8 + dlen;
1952         }
1953
1954         client_cut_text(vs, read_u32(data, 4), data + 8);
1955         break;
1956     case 255:
1957         if (len == 1)
1958             return 2;
1959
1960         switch (read_u8(data, 1)) {
1961         case 0:
1962             if (len == 2)
1963                 return 12;
1964
1965             ext_key_event(vs, read_u16(data, 2),
1966                           read_u32(data, 4), read_u32(data, 8));
1967             break;
1968         case 1:
1969             if (len == 2)
1970                 return 4;
1971
1972             switch (read_u16 (data, 2)) {
1973             case 0:
1974                 audio_add(vs);
1975                 break;
1976             case 1:
1977                 audio_del(vs);
1978                 break;
1979             case 2:
1980                 if (len == 4)
1981                     return 10;
1982                 switch (read_u8(data, 4)) {
1983                 case 0: vs->as.fmt = AUD_FMT_U8; break;
1984                 case 1: vs->as.fmt = AUD_FMT_S8; break;
1985                 case 2: vs->as.fmt = AUD_FMT_U16; break;
1986                 case 3: vs->as.fmt = AUD_FMT_S16; break;
1987                 case 4: vs->as.fmt = AUD_FMT_U32; break;
1988                 case 5: vs->as.fmt = AUD_FMT_S32; break;
1989                 default:
1990                     printf("Invalid audio format %d\n", read_u8(data, 4));
1991                     vnc_client_error(vs);
1992                     break;
1993                 }
1994                 vs->as.nchannels = read_u8(data, 5);
1995                 if (vs->as.nchannels != 1 && vs->as.nchannels != 2) {
1996                     printf("Invalid audio channel coount %d\n",
1997                            read_u8(data, 5));
1998                     vnc_client_error(vs);
1999                     break;
2000                 }
2001                 vs->as.freq = read_u32(data, 6);
2002                 break;
2003             default:
2004                 printf ("Invalid audio message %d\n", read_u8(data, 4));
2005                 vnc_client_error(vs);
2006                 break;
2007             }
2008             break;
2009
2010         default:
2011             printf("Msg: %d\n", read_u16(data, 0));
2012             vnc_client_error(vs);
2013             break;
2014         }
2015         break;
2016     default:
2017         printf("Msg: %d\n", data[0]);
2018         vnc_client_error(vs);
2019         break;
2020     }
2021
2022     vnc_read_when(vs, protocol_client_msg, 1);
2023     return 0;
2024 }
2025
2026 static int protocol_client_init(VncState *vs, uint8_t *data, size_t len)
2027 {
2028     char buf[1024];
2029     int size;
2030
2031     vnc_write_u16(vs, ds_get_width(vs->ds));
2032     vnc_write_u16(vs, ds_get_height(vs->ds));
2033
2034     pixel_format_message(vs);
2035
2036     if (qemu_name)
2037         size = snprintf(buf, sizeof(buf), "QEMU (%s)", qemu_name);
2038     else
2039         size = snprintf(buf, sizeof(buf), "QEMU");
2040
2041     vnc_write_u32(vs, size);
2042     vnc_write(vs, buf, size);
2043     vnc_flush(vs);
2044
2045     vnc_read_when(vs, protocol_client_msg, 1);
2046
2047     return 0;
2048 }
2049
2050 void start_client_init(VncState *vs)
2051 {
2052     vnc_read_when(vs, protocol_client_init, 1);
2053 }
2054
2055 static void make_challenge(VncState *vs)
2056 {
2057     int i;
2058
2059     srand(time(NULL)+getpid()+getpid()*987654+rand());
2060
2061     for (i = 0 ; i < sizeof(vs->challenge) ; i++)
2062         vs->challenge[i] = (int) (256.0*rand()/(RAND_MAX+1.0));
2063 }
2064
2065 static int protocol_client_auth_vnc(VncState *vs, uint8_t *data, size_t len)
2066 {
2067     unsigned char response[VNC_AUTH_CHALLENGE_SIZE];
2068     int i, j, pwlen;
2069     unsigned char key[8];
2070
2071     if (!vs->vd->password || !vs->vd->password[0]) {
2072         VNC_DEBUG("No password configured on server");
2073         vnc_write_u32(vs, 1); /* Reject auth */
2074         if (vs->minor >= 8) {
2075             static const char err[] = "Authentication failed";
2076             vnc_write_u32(vs, sizeof(err));
2077             vnc_write(vs, err, sizeof(err));
2078         }
2079         vnc_flush(vs);
2080         vnc_client_error(vs);
2081         return 0;
2082     }
2083
2084     memcpy(response, vs->challenge, VNC_AUTH_CHALLENGE_SIZE);
2085
2086     /* Calculate the expected challenge response */
2087     pwlen = strlen(vs->vd->password);
2088     for (i=0; i<sizeof(key); i++)
2089         key[i] = i<pwlen ? vs->vd->password[i] : 0;
2090     deskey(key, EN0);
2091     for (j = 0; j < VNC_AUTH_CHALLENGE_SIZE; j += 8)
2092         des(response+j, response+j);
2093
2094     /* Compare expected vs actual challenge response */
2095     if (memcmp(response, data, VNC_AUTH_CHALLENGE_SIZE) != 0) {
2096         VNC_DEBUG("Client challenge reponse did not match\n");
2097         vnc_write_u32(vs, 1); /* Reject auth */
2098         if (vs->minor >= 8) {
2099             static const char err[] = "Authentication failed";
2100             vnc_write_u32(vs, sizeof(err));
2101             vnc_write(vs, err, sizeof(err));
2102         }
2103         vnc_flush(vs);
2104         vnc_client_error(vs);
2105     } else {
2106         VNC_DEBUG("Accepting VNC challenge response\n");
2107         vnc_write_u32(vs, 0); /* Accept auth */
2108         vnc_flush(vs);
2109
2110         start_client_init(vs);
2111     }
2112     return 0;
2113 }
2114
2115 void start_auth_vnc(VncState *vs)
2116 {
2117     make_challenge(vs);
2118     /* Send client a 'random' challenge */
2119     vnc_write(vs, vs->challenge, sizeof(vs->challenge));
2120     vnc_flush(vs);
2121
2122     vnc_read_when(vs, protocol_client_auth_vnc, sizeof(vs->challenge));
2123 }
2124
2125
2126 static int protocol_client_auth(VncState *vs, uint8_t *data, size_t len)
2127 {
2128     /* We only advertise 1 auth scheme at a time, so client
2129      * must pick the one we sent. Verify this */
2130     if (data[0] != vs->vd->auth) { /* Reject auth */
2131        VNC_DEBUG("Reject auth %d because it didn't match advertized\n", (int)data[0]);
2132        vnc_write_u32(vs, 1);
2133        if (vs->minor >= 8) {
2134            static const char err[] = "Authentication failed";
2135            vnc_write_u32(vs, sizeof(err));
2136            vnc_write(vs, err, sizeof(err));
2137        }
2138        vnc_client_error(vs);
2139     } else { /* Accept requested auth */
2140        VNC_DEBUG("Client requested auth %d\n", (int)data[0]);
2141        switch (vs->vd->auth) {
2142        case VNC_AUTH_NONE:
2143            VNC_DEBUG("Accept auth none\n");
2144            if (vs->minor >= 8) {
2145                vnc_write_u32(vs, 0); /* Accept auth completion */
2146                vnc_flush(vs);
2147            }
2148            start_client_init(vs);
2149            break;
2150
2151        case VNC_AUTH_VNC:
2152            VNC_DEBUG("Start VNC auth\n");
2153            start_auth_vnc(vs);
2154            break;
2155
2156 #ifdef CONFIG_VNC_TLS
2157        case VNC_AUTH_VENCRYPT:
2158            VNC_DEBUG("Accept VeNCrypt auth\n");;
2159            start_auth_vencrypt(vs);
2160            break;
2161 #endif /* CONFIG_VNC_TLS */
2162
2163 #ifdef CONFIG_VNC_SASL
2164        case VNC_AUTH_SASL:
2165            VNC_DEBUG("Accept SASL auth\n");
2166            start_auth_sasl(vs);
2167            break;
2168 #endif /* CONFIG_VNC_SASL */
2169
2170        default: /* Should not be possible, but just in case */
2171            VNC_DEBUG("Reject auth %d server code bug\n", vs->vd->auth);
2172            vnc_write_u8(vs, 1);
2173            if (vs->minor >= 8) {
2174                static const char err[] = "Authentication failed";
2175                vnc_write_u32(vs, sizeof(err));
2176                vnc_write(vs, err, sizeof(err));
2177            }
2178            vnc_client_error(vs);
2179        }
2180     }
2181     return 0;
2182 }
2183
2184 static int protocol_version(VncState *vs, uint8_t *version, size_t len)
2185 {
2186     char local[13];
2187
2188     memcpy(local, version, 12);
2189     local[12] = 0;
2190
2191     if (sscanf(local, "RFB %03d.%03d\n", &vs->major, &vs->minor) != 2) {
2192         VNC_DEBUG("Malformed protocol version %s\n", local);
2193         vnc_client_error(vs);
2194         return 0;
2195     }
2196     VNC_DEBUG("Client request protocol version %d.%d\n", vs->major, vs->minor);
2197     if (vs->major != 3 ||
2198         (vs->minor != 3 &&
2199          vs->minor != 4 &&
2200          vs->minor != 5 &&
2201          vs->minor != 7 &&
2202          vs->minor != 8)) {
2203         VNC_DEBUG("Unsupported client version\n");
2204         vnc_write_u32(vs, VNC_AUTH_INVALID);
2205         vnc_flush(vs);
2206         vnc_client_error(vs);
2207         return 0;
2208     }
2209     /* Some broken clients report v3.4 or v3.5, which spec requires to be treated
2210      * as equivalent to v3.3 by servers
2211      */
2212     if (vs->minor == 4 || vs->minor == 5)
2213         vs->minor = 3;
2214
2215     if (vs->minor == 3) {
2216         if (vs->vd->auth == VNC_AUTH_NONE) {
2217             VNC_DEBUG("Tell client auth none\n");
2218             vnc_write_u32(vs, vs->vd->auth);
2219             vnc_flush(vs);
2220             start_client_init(vs);
2221        } else if (vs->vd->auth == VNC_AUTH_VNC) {
2222             VNC_DEBUG("Tell client VNC auth\n");
2223             vnc_write_u32(vs, vs->vd->auth);
2224             vnc_flush(vs);
2225             start_auth_vnc(vs);
2226        } else {
2227             VNC_DEBUG("Unsupported auth %d for protocol 3.3\n", vs->vd->auth);
2228             vnc_write_u32(vs, VNC_AUTH_INVALID);
2229             vnc_flush(vs);
2230             vnc_client_error(vs);
2231        }
2232     } else {
2233         VNC_DEBUG("Telling client we support auth %d\n", vs->vd->auth);
2234         vnc_write_u8(vs, 1); /* num auth */
2235         vnc_write_u8(vs, vs->vd->auth);
2236         vnc_read_when(vs, protocol_client_auth, 1);
2237         vnc_flush(vs);
2238     }
2239
2240     return 0;
2241 }
2242
2243 static int vnc_refresh_server_surface(VncDisplay *vd)
2244 {
2245     int y;
2246     uint8_t *guest_row;
2247     uint8_t *server_row;
2248     int cmp_bytes;
2249     uint32_t width_mask[VNC_DIRTY_WORDS];
2250     VncState *vs = NULL;
2251     int has_dirty = 0;
2252
2253     /*
2254      * Walk through the guest dirty map.
2255      * Check and copy modified bits from guest to server surface.
2256      * Update server dirty map.
2257      */
2258     vnc_set_bits(width_mask, (ds_get_width(vd->ds) / 16), VNC_DIRTY_WORDS);
2259     cmp_bytes = 16 * ds_get_bytes_per_pixel(vd->ds);
2260     guest_row  = vd->guest.ds->data;
2261     server_row = vd->server->data;
2262     for (y = 0; y < vd->guest.ds->height; y++) {
2263         if (vnc_and_bits(vd->guest.dirty[y], width_mask, VNC_DIRTY_WORDS)) {
2264             int x;
2265             uint8_t *guest_ptr;
2266             uint8_t *server_ptr;
2267
2268             guest_ptr  = guest_row;
2269             server_ptr = server_row;
2270
2271             for (x = 0; x < vd->guest.ds->width;
2272                     x += 16, guest_ptr += cmp_bytes, server_ptr += cmp_bytes) {
2273                 if (!vnc_get_bit(vd->guest.dirty[y], (x / 16)))
2274                     continue;
2275                 vnc_clear_bit(vd->guest.dirty[y], (x / 16));
2276                 if (memcmp(server_ptr, guest_ptr, cmp_bytes) == 0)
2277                     continue;
2278                 memcpy(server_ptr, guest_ptr, cmp_bytes);
2279                 vs = vd->clients;
2280                 while (vs != NULL) {
2281                     vnc_set_bit(vs->dirty[y], (x / 16));
2282                     vs = vs->next;
2283                 }
2284                 has_dirty++;
2285             }
2286         }
2287         guest_row  += ds_get_linesize(vd->ds);
2288         server_row += ds_get_linesize(vd->ds);
2289     }
2290     return has_dirty;
2291 }
2292
2293 static void vnc_refresh(void *opaque)
2294 {
2295     VncDisplay *vd = opaque;
2296     VncState *vs = NULL;
2297     int has_dirty = 0, rects = 0;
2298
2299     vga_hw_update();
2300
2301     has_dirty = vnc_refresh_server_surface(vd);
2302
2303     vs = vd->clients;
2304     while (vs != NULL) {
2305         rects += vnc_update_client(vs, has_dirty);
2306         vs = vs->next;
2307     }
2308
2309     if (has_dirty && rects) {
2310         vd->timer_interval /= 2;
2311         if (vd->timer_interval < VNC_REFRESH_INTERVAL_BASE)
2312             vd->timer_interval = VNC_REFRESH_INTERVAL_BASE;
2313     } else {
2314         vd->timer_interval += VNC_REFRESH_INTERVAL_INC;
2315         if (vd->timer_interval > VNC_REFRESH_INTERVAL_MAX)
2316             vd->timer_interval = VNC_REFRESH_INTERVAL_MAX;
2317     }
2318     qemu_mod_timer(vd->timer, qemu_get_clock(rt_clock) + vd->timer_interval);
2319 }
2320
2321 static void vnc_init_timer(VncDisplay *vd)
2322 {
2323     vd->timer_interval = VNC_REFRESH_INTERVAL_BASE;
2324     if (vd->timer == NULL && vd->clients != NULL) {
2325         vd->timer = qemu_new_timer(rt_clock, vnc_refresh, vd);
2326         vnc_refresh(vd);
2327     }
2328 }
2329
2330 static void vnc_remove_timer(VncDisplay *vd)
2331 {
2332     if (vd->timer != NULL && vd->clients == NULL) {
2333         qemu_del_timer(vd->timer);
2334         qemu_free_timer(vd->timer);
2335         vd->timer = NULL;
2336     }
2337 }
2338
2339 static void vnc_connect(VncDisplay *vd, int csock)
2340 {
2341     VncState *vs = qemu_mallocz(sizeof(VncState));
2342     vs->csock = csock;
2343
2344     VNC_DEBUG("New client on socket %d\n", csock);
2345     dcl->idle = 0;
2346     socket_set_nonblock(vs->csock);
2347     qemu_set_fd_handler2(vs->csock, NULL, vnc_client_read, NULL, vs);
2348
2349     vs->vd = vd;
2350     vs->ds = vd->ds;
2351     vs->last_x = -1;
2352     vs->last_y = -1;
2353
2354     vs->as.freq = 44100;
2355     vs->as.nchannels = 2;
2356     vs->as.fmt = AUD_FMT_S16;
2357     vs->as.endianness = 0;
2358
2359     vs->next = vd->clients;
2360     vd->clients = vs;
2361
2362     vga_hw_update();
2363
2364     vnc_write(vs, "RFB 003.008\n", 12);
2365     vnc_flush(vs);
2366     vnc_read_when(vs, protocol_version, 12);
2367     reset_keys(vs);
2368
2369     vnc_init_timer(vd);
2370
2371     /* vs might be free()ed here */
2372 }
2373
2374 static void vnc_listen_read(void *opaque)
2375 {
2376     VncDisplay *vs = opaque;
2377     struct sockaddr_in addr;
2378     socklen_t addrlen = sizeof(addr);
2379
2380     /* Catch-up */
2381     vga_hw_update();
2382
2383     int csock = qemu_accept(vs->lsock, (struct sockaddr *)&addr, &addrlen);
2384     if (csock != -1) {
2385         vnc_connect(vs, csock);
2386     }
2387 }
2388
2389 void vnc_display_init(DisplayState *ds)
2390 {
2391     VncDisplay *vs = qemu_mallocz(sizeof(*vs));
2392
2393     dcl = qemu_mallocz(sizeof(DisplayChangeListener));
2394
2395     ds->opaque = vs;
2396     dcl->idle = 1;
2397     vnc_display = vs;
2398
2399     vs->lsock = -1;
2400
2401     vs->ds = ds;
2402
2403     if (keyboard_layout)
2404         vs->kbd_layout = init_keyboard_layout(name2keysym, keyboard_layout);
2405     else
2406         vs->kbd_layout = init_keyboard_layout(name2keysym, "en-us");
2407
2408     if (!vs->kbd_layout)
2409         exit(1);
2410
2411     dcl->dpy_copy = vnc_dpy_copy;
2412     dcl->dpy_update = vnc_dpy_update;
2413     dcl->dpy_resize = vnc_dpy_resize;
2414     dcl->dpy_setdata = vnc_dpy_setdata;
2415     register_displaychangelistener(ds, dcl);
2416 }
2417
2418
2419 void vnc_display_close(DisplayState *ds)
2420 {
2421     VncDisplay *vs = ds ? (VncDisplay *)ds->opaque : vnc_display;
2422
2423     if (!vs)
2424         return;
2425     if (vs->display) {
2426         qemu_free(vs->display);
2427         vs->display = NULL;
2428     }
2429     if (vs->lsock != -1) {
2430         qemu_set_fd_handler2(vs->lsock, NULL, NULL, NULL, NULL);
2431         close(vs->lsock);
2432         vs->lsock = -1;
2433     }
2434     vs->auth = VNC_AUTH_INVALID;
2435 #ifdef CONFIG_VNC_TLS
2436     vs->subauth = VNC_AUTH_INVALID;
2437     vs->tls.x509verify = 0;
2438 #endif
2439 }
2440
2441 int vnc_display_password(DisplayState *ds, const char *password)
2442 {
2443     VncDisplay *vs = ds ? (VncDisplay *)ds->opaque : vnc_display;
2444
2445     if (!vs) {
2446         return -1;
2447     }
2448
2449     if (vs->password) {
2450         qemu_free(vs->password);
2451         vs->password = NULL;
2452     }
2453     if (password && password[0]) {
2454         if (!(vs->password = qemu_strdup(password)))
2455             return -1;
2456         if (vs->auth == VNC_AUTH_NONE) {
2457             vs->auth = VNC_AUTH_VNC;
2458         }
2459     } else {
2460         vs->auth = VNC_AUTH_NONE;
2461     }
2462
2463     return 0;
2464 }
2465
2466 char *vnc_display_local_addr(DisplayState *ds)
2467 {
2468     VncDisplay *vs = ds ? (VncDisplay *)ds->opaque : vnc_display;
2469
2470     return vnc_socket_local_addr("%s:%s", vs->lsock);
2471 }
2472
2473 int vnc_display_open(DisplayState *ds, const char *display)
2474 {
2475     VncDisplay *vs = ds ? (VncDisplay *)ds->opaque : vnc_display;
2476     const char *options;
2477     int password = 0;
2478     int reverse = 0;
2479     int to_port = 0;
2480 #ifdef CONFIG_VNC_TLS
2481     int tls = 0, x509 = 0;
2482 #endif
2483 #ifdef CONFIG_VNC_SASL
2484     int sasl = 0;
2485     int saslErr;
2486 #endif
2487     int acl = 0;
2488
2489     if (!vnc_display)
2490         return -1;
2491     vnc_display_close(ds);
2492     if (strcmp(display, "none") == 0)
2493         return 0;
2494
2495     if (!(vs->display = strdup(display)))
2496         return -1;
2497
2498     options = display;
2499     while ((options = strchr(options, ','))) {
2500         options++;
2501         if (strncmp(options, "password", 8) == 0) {
2502             password = 1; /* Require password auth */
2503         } else if (strncmp(options, "reverse", 7) == 0) {
2504             reverse = 1;
2505         } else if (strncmp(options, "to=", 3) == 0) {
2506             to_port = atoi(options+3) + 5900;
2507 #ifdef CONFIG_VNC_SASL
2508         } else if (strncmp(options, "sasl", 4) == 0) {
2509             sasl = 1; /* Require SASL auth */
2510 #endif
2511 #ifdef CONFIG_VNC_TLS
2512         } else if (strncmp(options, "tls", 3) == 0) {
2513             tls = 1; /* Require TLS */
2514         } else if (strncmp(options, "x509", 4) == 0) {
2515             char *start, *end;
2516             x509 = 1; /* Require x509 certificates */
2517             if (strncmp(options, "x509verify", 10) == 0)
2518                 vs->tls.x509verify = 1; /* ...and verify client certs */
2519
2520             /* Now check for 'x509=/some/path' postfix
2521              * and use that to setup x509 certificate/key paths */
2522             start = strchr(options, '=');
2523             end = strchr(options, ',');
2524             if (start && (!end || (start < end))) {
2525                 int len = end ? end-(start+1) : strlen(start+1);
2526                 char *path = qemu_strndup(start + 1, len);
2527
2528                 VNC_DEBUG("Trying certificate path '%s'\n", path);
2529                 if (vnc_tls_set_x509_creds_dir(vs, path) < 0) {
2530                     fprintf(stderr, "Failed to find x509 certificates/keys in %s\n", path);
2531                     qemu_free(path);
2532                     qemu_free(vs->display);
2533                     vs->display = NULL;
2534                     return -1;
2535                 }
2536                 qemu_free(path);
2537             } else {
2538                 fprintf(stderr, "No certificate path provided\n");
2539                 qemu_free(vs->display);
2540                 vs->display = NULL;
2541                 return -1;
2542             }
2543 #endif
2544         } else if (strncmp(options, "acl", 3) == 0) {
2545             acl = 1;
2546         }
2547     }
2548
2549 #ifdef CONFIG_VNC_TLS
2550     if (acl && x509 && vs->tls.x509verify) {
2551         if (!(vs->tls.acl = qemu_acl_init("vnc.x509dname"))) {
2552             fprintf(stderr, "Failed to create x509 dname ACL\n");
2553             exit(1);
2554         }
2555     }
2556 #endif
2557 #ifdef CONFIG_VNC_SASL
2558     if (acl && sasl) {
2559         if (!(vs->sasl.acl = qemu_acl_init("vnc.username"))) {
2560             fprintf(stderr, "Failed to create username ACL\n");
2561             exit(1);
2562         }
2563     }
2564 #endif
2565
2566     /*
2567      * Combinations we support here:
2568      *
2569      *  - no-auth                (clear text, no auth)
2570      *  - password               (clear text, weak auth)
2571      *  - sasl                   (encrypt, good auth *IF* using Kerberos via GSSAPI)
2572      *  - tls                    (encrypt, weak anonymous creds, no auth)
2573      *  - tls + password         (encrypt, weak anonymous creds, weak auth)
2574      *  - tls + sasl             (encrypt, weak anonymous creds, good auth)
2575      *  - tls + x509             (encrypt, good x509 creds, no auth)
2576      *  - tls + x509 + password  (encrypt, good x509 creds, weak auth)
2577      *  - tls + x509 + sasl      (encrypt, good x509 creds, good auth)
2578      *
2579      * NB1. TLS is a stackable auth scheme.
2580      * NB2. the x509 schemes have option to validate a client cert dname
2581      */
2582     if (password) {
2583 #ifdef CONFIG_VNC_TLS
2584         if (tls) {
2585             vs->auth = VNC_AUTH_VENCRYPT;
2586             if (x509) {
2587                 VNC_DEBUG("Initializing VNC server with x509 password auth\n");
2588                 vs->subauth = VNC_AUTH_VENCRYPT_X509VNC;
2589             } else {
2590                 VNC_DEBUG("Initializing VNC server with TLS password auth\n");
2591                 vs->subauth = VNC_AUTH_VENCRYPT_TLSVNC;
2592             }
2593         } else {
2594 #endif /* CONFIG_VNC_TLS */
2595             VNC_DEBUG("Initializing VNC server with password auth\n");
2596             vs->auth = VNC_AUTH_VNC;
2597 #ifdef CONFIG_VNC_TLS
2598             vs->subauth = VNC_AUTH_INVALID;
2599         }
2600 #endif /* CONFIG_VNC_TLS */
2601 #ifdef CONFIG_VNC_SASL
2602     } else if (sasl) {
2603 #ifdef CONFIG_VNC_TLS
2604         if (tls) {
2605             vs->auth = VNC_AUTH_VENCRYPT;
2606             if (x509) {
2607                 VNC_DEBUG("Initializing VNC server with x509 SASL auth\n");
2608                 vs->subauth = VNC_AUTH_VENCRYPT_X509SASL;
2609             } else {
2610                 VNC_DEBUG("Initializing VNC server with TLS SASL auth\n");
2611                 vs->subauth = VNC_AUTH_VENCRYPT_TLSSASL;
2612             }
2613         } else {
2614 #endif /* CONFIG_VNC_TLS */
2615             VNC_DEBUG("Initializing VNC server with SASL auth\n");
2616             vs->auth = VNC_AUTH_SASL;
2617 #ifdef CONFIG_VNC_TLS
2618             vs->subauth = VNC_AUTH_INVALID;
2619         }
2620 #endif /* CONFIG_VNC_TLS */
2621 #endif /* CONFIG_VNC_SASL */
2622     } else {
2623 #ifdef CONFIG_VNC_TLS
2624         if (tls) {
2625             vs->auth = VNC_AUTH_VENCRYPT;
2626             if (x509) {
2627                 VNC_DEBUG("Initializing VNC server with x509 no auth\n");
2628                 vs->subauth = VNC_AUTH_VENCRYPT_X509NONE;
2629             } else {
2630                 VNC_DEBUG("Initializing VNC server with TLS no auth\n");
2631                 vs->subauth = VNC_AUTH_VENCRYPT_TLSNONE;
2632             }
2633         } else {
2634 #endif
2635             VNC_DEBUG("Initializing VNC server with no auth\n");
2636             vs->auth = VNC_AUTH_NONE;
2637 #ifdef CONFIG_VNC_TLS
2638             vs->subauth = VNC_AUTH_INVALID;
2639         }
2640 #endif
2641     }
2642
2643 #ifdef CONFIG_VNC_SASL
2644     if ((saslErr = sasl_server_init(NULL, "qemu")) != SASL_OK) {
2645         fprintf(stderr, "Failed to initialize SASL auth %s",
2646                 sasl_errstring(saslErr, NULL, NULL));
2647         free(vs->display);
2648         vs->display = NULL;
2649         return -1;
2650     }
2651 #endif
2652
2653     if (reverse) {
2654         /* connect to viewer */
2655         if (strncmp(display, "unix:", 5) == 0)
2656             vs->lsock = unix_connect(display+5);
2657         else
2658             vs->lsock = inet_connect(display, SOCK_STREAM);
2659         if (-1 == vs->lsock) {
2660             free(vs->display);
2661             vs->display = NULL;
2662             return -1;
2663         } else {
2664             int csock = vs->lsock;
2665             vs->lsock = -1;
2666             vnc_connect(vs, csock);
2667         }
2668         return 0;
2669
2670     } else {
2671         /* listen for connects */
2672         char *dpy;
2673         dpy = qemu_malloc(256);
2674         if (strncmp(display, "unix:", 5) == 0) {
2675             pstrcpy(dpy, 256, "unix:");
2676             vs->lsock = unix_listen(display+5, dpy+5, 256-5);
2677         } else {
2678             vs->lsock = inet_listen(display, dpy, 256, SOCK_STREAM, 5900);
2679         }
2680         if (-1 == vs->lsock) {
2681             free(dpy);
2682             return -1;
2683         } else {
2684             free(vs->display);
2685             vs->display = dpy;
2686         }
2687     }
2688     return qemu_set_fd_handler2(vs->lsock, NULL, vnc_listen_read, NULL, vs);
2689 }