git.maemo.org Git - qemu/blob - vnc.c

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