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