Fix most warnings that would be caused by gcc flag -Wundef

[qemu.git] / vnc.c

diff --git a/vnc.c b/vnc.c
index b20fe21d7d48f27e803c3af00ef0d56f2d9ff5d2..3c029f5f1c3046bfe435c60ecb52fccdc7182f85 100644 (file)
--- a/vnc.c
+++ b/vnc.c
@@ -35,14 +35,14 @@
 #include "keymaps.c"
 #include "d3des.h"
 
 #include "keymaps.c"
 #include "d3des.h"
 

-#if CONFIG_VNC_TLS
+#ifdef CONFIG_VNC_TLS

 #include <gnutls/gnutls.h>
 #include <gnutls/x509.h>
 #endif /* CONFIG_VNC_TLS */
 
 // #define _VNC_DEBUG 1
 
 #include <gnutls/gnutls.h>
 #include <gnutls/x509.h>
 #endif /* CONFIG_VNC_TLS */
 
 // #define _VNC_DEBUG 1
 

-#if _VNC_DEBUG
+#ifdef _VNC_DEBUG

 #define VNC_DEBUG(fmt, ...) do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
 
 #if CONFIG_VNC_TLS && _VNC_DEBUG >= 2
 #define VNC_DEBUG(fmt, ...) do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
 
 #if CONFIG_VNC_TLS && _VNC_DEBUG >= 2


@@ -60,12 +60,12 @@ typedef struct Buffer
 {
     size_t capacity;
     size_t offset;
 {
     size_t capacity;
     size_t offset;

-    char *buffer;
+    uint8_t *buffer;

 } Buffer;
 
 typedef struct VncState VncState;
 
 } Buffer;
 
 typedef struct VncState VncState;
 

-typedef int VncReadEvent(VncState *vs, char *data, size_t len);
+typedef int VncReadEvent(VncState *vs, uint8_t *data, size_t len);

 
 typedef void VncWritePixels(VncState *vs, void *data, int size);
 
 
 typedef void VncWritePixels(VncState *vs, void *data, int size);
 


@@ -93,7 +93,7 @@ enum {
     VNC_AUTH_VENCRYPT = 19
 };
 
     VNC_AUTH_VENCRYPT = 19
 };
 

-#if CONFIG_VNC_TLS
+#ifdef CONFIG_VNC_TLS

 enum {
     VNC_WIREMODE_CLEAR,
     VNC_WIREMODE_TLS,
 enum {
     VNC_WIREMODE_CLEAR,
     VNC_WIREMODE_TLS,


@@ -109,12 +109,10 @@ enum {
     VNC_AUTH_VENCRYPT_X509PLAIN = 262,
 };
 
     VNC_AUTH_VENCRYPT_X509PLAIN = 262,
 };
 

-#if CONFIG_VNC_TLS

 #define X509_CA_CERT_FILE "ca-cert.pem"
 #define X509_CA_CRL_FILE "ca-crl.pem"
 #define X509_SERVER_KEY_FILE "server-key.pem"
 #define X509_SERVER_CERT_FILE "server-cert.pem"
 #define X509_CA_CERT_FILE "ca-cert.pem"
 #define X509_CA_CRL_FILE "ca-crl.pem"
 #define X509_SERVER_KEY_FILE "server-key.pem"
 #define X509_SERVER_CERT_FILE "server-cert.pem"

-#endif

 
 #endif /* CONFIG_VNC_TLS */
 
 
 #endif /* CONFIG_VNC_TLS */
 


@@ -143,7 +141,7 @@ struct VncState
     char *display;
     char *password;
     int auth;
     char *display;
     char *password;
     int auth;

-#if CONFIG_VNC_TLS
+#ifdef CONFIG_VNC_TLS

     int subauth;
     int x509verify;
 
     int subauth;
     int x509verify;
 


@@ -154,7 +152,7 @@ struct VncState
 #endif
     char challenge[VNC_AUTH_CHALLENGE_SIZE];
 
 #endif
     char challenge[VNC_AUTH_CHALLENGE_SIZE];
 

-#if CONFIG_VNC_TLS
+#ifdef CONFIG_VNC_TLS

     int wiremode;
     gnutls_session_t tls_session;
 #endif
     int wiremode;
     gnutls_session_t tls_session;
 #endif


@@ -265,6 +263,11 @@ static void vnc_dpy_update(DisplayState *ds, int x, int y, int w, int h)
     w += (x % 16);
     x -= (x % 16);
 
     w += (x % 16);
     x -= (x % 16);
 

+    x = MIN(x, vs->width);
+    y = MIN(y, vs->height);
+    w = MIN(x + w, vs->width) - x;
+    h = MIN(h, vs->height);
+

     for (; y < h; y++)
        for (i = 0; i < w; i += 16)
            vnc_set_bit(vs->dirty_row[y], (x + i) / 16);
     for (; y < h; y++)
        for (i = 0; i < w; i += 16)
            vnc_set_bit(vs->dirty_row[y], (x + i) / 16);


@@ -286,8 +289,8 @@ static void vnc_dpy_resize(DisplayState *ds, int w, int h)
     int size_changed;
     VncState *vs = ds->opaque;
 
     int size_changed;
     VncState *vs = ds->opaque;
 

-    ds->data = realloc(ds->data, w * h * vs->depth);
-    vs->old_data = realloc(vs->old_data, w * h * vs->depth);
+    ds->data = qemu_realloc(ds->data, w * h * vs->depth);
+    vs->old_data = qemu_realloc(vs->old_data, w * h * vs->depth);

 
     if (ds->data == NULL || vs->old_data == NULL) {
        fprintf(stderr, "vnc: memory allocation failed\n");
 
     if (ds->data == NULL || vs->old_data == NULL) {
        fprintf(stderr, "vnc: memory allocation failed\n");


@@ -302,15 +305,20 @@ static void vnc_dpy_resize(DisplayState *ds, int w, int h)
     ds->width = w;
     ds->height = h;
     ds->linesize = w * vs->depth;
     ds->width = w;
     ds->height = h;
     ds->linesize = w * vs->depth;

-    if (vs->csock != -1 && vs->has_resize && size_changed) {
-       vnc_write_u8(vs, 0);  /* msg id */
-       vnc_write_u8(vs, 0);
-       vnc_write_u16(vs, 1); /* number of rects */
-       vnc_framebuffer_update(vs, 0, 0, ds->width, ds->height, -223);
-       vnc_flush(vs);
-       vs->width = ds->width;
-       vs->height = ds->height;
+    if (size_changed) {
+        vs->width = ds->width;
+        vs->height = ds->height;
+        if (vs->csock != -1 && vs->has_resize) {
+            vnc_write_u8(vs, 0);  /* msg id */
+            vnc_write_u8(vs, 0);
+            vnc_write_u16(vs, 1); /* number of rects */
+            vnc_framebuffer_update(vs, 0, 0, ds->width, ds->height, -223);
+            vnc_flush(vs);
+        }

     }
     }

+
+    memset(vs->dirty_row, 0xFF, sizeof(vs->dirty_row));
+    memset(vs->old_data, 42, vs->ds->linesize * vs->ds->height);

 }
 
 /* fastest code */
 }
 
 /* fastest code */


@@ -376,7 +384,7 @@ static void vnc_write_pixels_generic(VncState *vs, void *pixels1, int size)
 static void send_framebuffer_update_raw(VncState *vs, int x, int y, int w, int h)
 {
     int i;
 static void send_framebuffer_update_raw(VncState *vs, int x, int y, int w, int h)
 {
     int i;

-    char *row;
+    uint8_t *row;

 
     vnc_framebuffer_update(vs, x, y, w, h, 0);
 
 
     vnc_framebuffer_update(vs, x, y, w, h, 0);
 


@@ -440,8 +448,8 @@ static void send_framebuffer_update(VncState *vs, int x, int y, int w, int h)
 static void vnc_copy(DisplayState *ds, int src_x, int src_y, int dst_x, int dst_y, int w, int h)
 {
     int src, dst;
 static void vnc_copy(DisplayState *ds, int src_x, int src_y, int dst_x, int dst_y, int w, int h)
 {
     int src, dst;

-    char *src_row;
-    char *dst_row;
+    uint8_t *src_row;
+    uint8_t *dst_row;

     char *old_row;
     int y = 0;
     int pitch = ds->linesize;
     char *old_row;
     int y = 0;
     int pitch = ds->linesize;


@@ -499,13 +507,15 @@ static void vnc_update_client(void *opaque)
 
     if (vs->need_update && vs->csock != -1) {
        int y;
 
     if (vs->need_update && vs->csock != -1) {
        int y;

-       char *row;
+       uint8_t *row;

        char *old_row;
        uint32_t width_mask[VNC_DIRTY_WORDS];
        int n_rectangles;
        int saved_offset;
        int has_dirty = 0;
 
        char *old_row;
        uint32_t width_mask[VNC_DIRTY_WORDS];
        int n_rectangles;
        int saved_offset;
        int has_dirty = 0;
 

+        vga_hw_update();
+

         vnc_set_bits(width_mask, (vs->width / 16), VNC_DIRTY_WORDS);
 
        /* Walk through the dirty map and eliminate tiles that
         vnc_set_bits(width_mask, (vs->width / 16), VNC_DIRTY_WORDS);
 
        /* Walk through the dirty map and eliminate tiles that


@@ -516,10 +526,11 @@ static void vnc_update_client(void *opaque)
        for (y = 0; y < vs->height; y++) {
            if (vnc_and_bits(vs->dirty_row[y], width_mask, VNC_DIRTY_WORDS)) {
                int x;
        for (y = 0; y < vs->height; y++) {
            if (vnc_and_bits(vs->dirty_row[y], width_mask, VNC_DIRTY_WORDS)) {
                int x;

-               char *ptr, *old_ptr;
+               uint8_t *ptr;
+               char *old_ptr;

 
                ptr = row;
 
                ptr = row;

-               old_ptr = old_row;
+               old_ptr = (char*)old_row;

 
                for (x = 0; x < vs->ds->width; x += 16) {
                    if (memcmp(old_ptr, ptr, 16 * vs->depth) == 0) {
 
                for (x = 0; x < vs->ds->width; x += 16) {
                    if (memcmp(old_ptr, ptr, 16 * vs->depth) == 0) {


@@ -579,22 +590,11 @@ static void vnc_update_client(void *opaque)
        vnc_flush(vs);
 
     }
        vnc_flush(vs);
 
     }

-    qemu_mod_timer(vs->timer, qemu_get_clock(rt_clock) + VNC_REFRESH_INTERVAL);
-}

 
 

-static void vnc_timer_init(VncState *vs)
-{
-    if (vs->timer == NULL) {
-       vs->timer = qemu_new_timer(rt_clock, vnc_update_client, vs);
-       qemu_mod_timer(vs->timer, qemu_get_clock(rt_clock));
+    if (vs->csock != -1) {
+        qemu_mod_timer(vs->timer, qemu_get_clock(rt_clock) + VNC_REFRESH_INTERVAL);

     }
     }

-}

 
 

-static void vnc_dpy_refresh(DisplayState *ds)
-{
-    VncState *vs = ds->opaque;
-    vnc_timer_init(vs);
-    vga_hw_update();

 }
 
 static int vnc_listen_poll(void *opaque)
 }
 
 static int vnc_listen_poll(void *opaque)


@@ -609,7 +609,7 @@ static void buffer_reserve(Buffer *buffer, size_t len)
 {
     if ((buffer->capacity - buffer->offset) < len) {
        buffer->capacity += (len + 1024);
 {
     if ((buffer->capacity - buffer->offset) < len) {
        buffer->capacity += (len + 1024);

-       buffer->buffer = realloc(buffer->buffer, buffer->capacity);
+       buffer->buffer = qemu_realloc(buffer->buffer, buffer->capacity);

        if (buffer->buffer == NULL) {
            fprintf(stderr, "vnc: out of memory\n");
            exit(1);
        if (buffer->buffer == NULL) {
            fprintf(stderr, "vnc: out of memory\n");
            exit(1);


@@ -622,7 +622,7 @@ static int buffer_empty(Buffer *buffer)
     return buffer->offset == 0;
 }
 
     return buffer->offset == 0;
 }
 

-static char *buffer_end(Buffer *buffer)
+static uint8_t *buffer_end(Buffer *buffer)

 {
     return buffer->buffer + buffer->offset;
 }
 {
     return buffer->buffer + buffer->offset;
 }


@@ -641,17 +641,28 @@ static void buffer_append(Buffer *buffer, const void *data, size_t len)
 static int vnc_client_io_error(VncState *vs, int ret, int last_errno)
 {
     if (ret == 0 || ret == -1) {
 static int vnc_client_io_error(VncState *vs, int ret, int last_errno)
 {
     if (ret == 0 || ret == -1) {

-       if (ret == -1 && (last_errno == EINTR || last_errno == EAGAIN))
-           return 0;
+        if (ret == -1) {
+            switch (last_errno) {
+                case EINTR:
+                case EAGAIN:
+#ifdef _WIN32
+                case WSAEWOULDBLOCK:
+#endif
+                    return 0;
+                default:
+                    break;
+            }
+        }

 
        VNC_DEBUG("Closing down client sock %d %d\n", ret, ret < 0 ? last_errno : 0);
        qemu_set_fd_handler2(vs->csock, NULL, NULL, NULL, NULL);
        closesocket(vs->csock);
        vs->csock = -1;
 
        VNC_DEBUG("Closing down client sock %d %d\n", ret, ret < 0 ? last_errno : 0);
        qemu_set_fd_handler2(vs->csock, NULL, NULL, NULL, NULL);
        closesocket(vs->csock);
        vs->csock = -1;

+       vs->ds->idle = 1;

        buffer_reset(&vs->input);
        buffer_reset(&vs->output);
        vs->need_update = 0;
        buffer_reset(&vs->input);
        buffer_reset(&vs->output);
        vs->need_update = 0;

-#if CONFIG_VNC_TLS
+#ifdef CONFIG_VNC_TLS

        if (vs->tls_session) {
            gnutls_deinit(vs->tls_session);
            vs->tls_session = NULL;
        if (vs->tls_session) {
            gnutls_deinit(vs->tls_session);
            vs->tls_session = NULL;


@@ -673,7 +684,7 @@ static void vnc_client_write(void *opaque)
     long ret;
     VncState *vs = opaque;
 
     long ret;
     VncState *vs = opaque;
 

-#if CONFIG_VNC_TLS
+#ifdef CONFIG_VNC_TLS

     if (vs->tls_session) {
        ret = gnutls_write(vs->tls_session, vs->output.buffer, vs->output.offset);
        if (ret < 0) {
     if (vs->tls_session) {
        ret = gnutls_write(vs->tls_session, vs->output.buffer, vs->output.offset);
        if (ret < 0) {


@@ -711,7 +722,7 @@ static void vnc_client_read(void *opaque)
 
     buffer_reserve(&vs->input, 4096);
 
 
     buffer_reserve(&vs->input, 4096);
 

-#if CONFIG_VNC_TLS
+#ifdef CONFIG_VNC_TLS

     if (vs->tls_session) {
        ret = gnutls_read(vs->tls_session, buffer_end(&vs->input), 4096);
        if (ret < 0) {
     if (vs->tls_session) {
        ret = gnutls_read(vs->tls_session, buffer_end(&vs->input), 4096);
        if (ret < 0) {


@@ -818,7 +829,7 @@ static uint32_t read_u32(uint8_t *data, size_t offset)
            (data[offset + 2] << 8) | data[offset + 3]);
 }
 
            (data[offset + 2] << 8) | data[offset + 3]);
 }
 

-#if CONFIG_VNC_TLS
+#ifdef CONFIG_VNC_TLS

 static ssize_t vnc_tls_push(gnutls_transport_ptr_t transport,
                             const void *data,
                             size_t len) {
 static ssize_t vnc_tls_push(gnutls_transport_ptr_t transport,
                             const void *data,
                             size_t len) {


@@ -853,7 +864,7 @@ static ssize_t vnc_tls_pull(gnutls_transport_ptr_t transport,
 }
 #endif /* CONFIG_VNC_TLS */
 
 }
 #endif /* CONFIG_VNC_TLS */
 

-static void client_cut_text(VncState *vs, size_t len, char *text)
+static void client_cut_text(VncState *vs, size_t len, uint8_t *text)

 {
 }
 
 {
 }
 


@@ -887,8 +898,8 @@ static void pointer_event(VncState *vs, int button_mask, int x, int y)
        dz = 1;
 
     if (vs->absolute) {
        dz = 1;
 
     if (vs->absolute) {

-       kbd_mouse_event(x * 0x7FFF / vs->ds->width,
-                       y * 0x7FFF / vs->ds->height,
+       kbd_mouse_event(x * 0x7FFF / (vs->ds->width - 1),
+                       y * 0x7FFF / (vs->ds->height - 1),

                        dz, buttons);
     } else if (vs->has_pointer_type_change) {
        x -= 0x7FFF;
                        dz, buttons);
     } else if (vs->has_pointer_type_change) {
        x -= 0x7FFF;


@@ -926,12 +937,8 @@ static void press_key(VncState *vs, int keysym)
     kbd_put_keycode(keysym2scancode(vs->kbd_layout, keysym) | 0x80);
 }
 
     kbd_put_keycode(keysym2scancode(vs->kbd_layout, keysym) | 0x80);
 }
 

-static void do_key_event(VncState *vs, int down, uint32_t sym)
+static void do_key_event(VncState *vs, int down, int keycode, int sym)

 {
 {

-    int keycode;
-
-    keycode = keysym2scancode(vs->kbd_layout, sym & 0xFFFF);
-

     /* QEMU console switch */
     switch(keycode) {
     case 0x2a:                          /* Left Shift */
     /* QEMU console switch */
     switch(keycode) {
     case 0x2a:                          /* Left Shift */


@@ -953,6 +960,7 @@ static void do_key_event(VncState *vs, int down, uint32_t sym)
             return;
         }
         break;
             return;
         }
         break;

+    case 0x3a:                 /* CapsLock */

     case 0x45:                 /* NumLock */
         if (!down)
             vs->modifiers_state[keycode] ^= 1;
     case 0x45:                 /* NumLock */
         if (!down)
             vs->modifiers_state[keycode] ^= 1;


@@ -1032,9 +1040,23 @@ static void do_key_event(VncState *vs, int down, uint32_t sym)
 
 static void key_event(VncState *vs, int down, uint32_t sym)
 {
 
 static void key_event(VncState *vs, int down, uint32_t sym)
 {

+    int keycode;
+

     if (sym >= 'A' && sym <= 'Z' && is_graphic_console())
        sym = sym - 'A' + 'a';
     if (sym >= 'A' && sym <= 'Z' && is_graphic_console())
        sym = sym - 'A' + 'a';

-    do_key_event(vs, down, sym);
+
+    keycode = keysym2scancode(vs->kbd_layout, sym & 0xFFFF);
+    do_key_event(vs, down, keycode, sym);
+}
+
+static void ext_key_event(VncState *vs, int down,
+                          uint32_t sym, uint16_t keycode)
+{
+    /* if the user specifies a keyboard layout, always use it */
+    if (keyboard_layout)
+        key_event(vs, down, sym);
+    else
+        do_key_event(vs, down, keycode, sym);

 }
 
 static void framebuffer_update_request(VncState *vs, int incremental,
 }
 
 static void framebuffer_update_request(VncState *vs, int incremental,


@@ -1064,6 +1086,15 @@ static void framebuffer_update_request(VncState *vs, int incremental,
     }
 }
 
     }
 }
 

+static void send_ext_key_event_ack(VncState *vs)
+{
+    vnc_write_u8(vs, 0);
+    vnc_write_u8(vs, 0);
+    vnc_write_u16(vs, 1);
+    vnc_framebuffer_update(vs, 0, 0, vs->ds->width, vs->ds->height, -258);
+    vnc_flush(vs);
+}
+

 static void set_encodings(VncState *vs, int32_t *encodings, size_t n_encodings)
 {
     int i;
 static void set_encodings(VncState *vs, int32_t *encodings, size_t n_encodings)
 {
     int i;


@@ -1091,6 +1122,9 @@ static void set_encodings(VncState *vs, int32_t *encodings, size_t n_encodings)
        case -257:
            vs->has_pointer_type_change = 1;
            break;
        case -257:
            vs->has_pointer_type_change = 1;
            break;

+        case -258:
+            send_ext_key_event_ack(vs);
+            break;

        default:
            break;
        }
        default:
            break;
        }


@@ -1174,14 +1208,12 @@ static void set_pixel_format(VncState *vs,
     }
 
     vnc_dpy_resize(vs->ds, vs->ds->width, vs->ds->height);
     }
 
     vnc_dpy_resize(vs->ds, vs->ds->width, vs->ds->height);

-    memset(vs->dirty_row, 0xFF, sizeof(vs->dirty_row));
-    memset(vs->old_data, 42, vs->ds->linesize * vs->ds->height);

 
     vga_hw_invalidate();
     vga_hw_update();
 }
 
 
     vga_hw_invalidate();
     vga_hw_update();
 }
 

-static int protocol_client_msg(VncState *vs, char *data, size_t len)
+static int protocol_client_msg(VncState *vs, uint8_t *data, size_t len)

 {
     int i;
     uint16_t limit;
 {
     int i;
     uint16_t limit;


@@ -1244,6 +1276,24 @@ static int protocol_client_msg(VncState *vs, char *data, size_t len)
 
        client_cut_text(vs, read_u32(data, 4), data + 8);
        break;
 
        client_cut_text(vs, read_u32(data, 4), data + 8);
        break;

+    case 255:
+        if (len == 1)
+            return 2;
+
+        switch (read_u8(data, 1)) {
+        case 0:
+            if (len == 2)
+                return 12;
+
+            ext_key_event(vs, read_u16(data, 2),
+                          read_u32(data, 4), read_u32(data, 8));
+            break;
+        default:
+            printf("Msg: %d\n", read_u16(data, 0));
+            vnc_client_error(vs);
+            break;
+        }
+        break;

     default:
        printf("Msg: %d\n", data[0]);
        vnc_client_error(vs);
     default:
        printf("Msg: %d\n", data[0]);
        vnc_client_error(vs);


@@ -1254,7 +1304,7 @@ static int protocol_client_msg(VncState *vs, char *data, size_t len)
     return 0;
 }
 
     return 0;
 }
 

-static int protocol_client_init(VncState *vs, char *data, size_t len)
+static int protocol_client_init(VncState *vs, uint8_t *data, size_t len)

 {
     char pad[3] = { 0, 0, 0 };
     char buf[1024];
 {
     char pad[3] = { 0, 0, 0 };
     char buf[1024];


@@ -1327,11 +1377,11 @@ static void make_challenge(VncState *vs)
         vs->challenge[i] = (int) (256.0*rand()/(RAND_MAX+1.0));
 }
 
         vs->challenge[i] = (int) (256.0*rand()/(RAND_MAX+1.0));
 }
 

-static int protocol_client_auth_vnc(VncState *vs, char *data, size_t len)
+static int protocol_client_auth_vnc(VncState *vs, uint8_t *data, size_t len)

 {
 {

-    char response[VNC_AUTH_CHALLENGE_SIZE];
+    unsigned char response[VNC_AUTH_CHALLENGE_SIZE];

     int i, j, pwlen;
     int i, j, pwlen;

-    char key[8];
+    unsigned char key[8];

 
     if (!vs->password || !vs->password[0]) {
        VNC_DEBUG("No password configured on server");
 
     if (!vs->password || !vs->password[0]) {
        VNC_DEBUG("No password configured on server");


@@ -1389,7 +1439,7 @@ static int start_auth_vnc(VncState *vs)
 }
 
 
 }
 
 

-#if CONFIG_VNC_TLS
+#ifdef CONFIG_VNC_TLS

 #define DH_BITS 1024
 static gnutls_dh_params_t dh_params;
 
 #define DH_BITS 1024
 static gnutls_dh_params_t dh_params;
 


@@ -1738,7 +1788,7 @@ static int vnc_start_tls(struct VncState *vs) {
     return vnc_continue_handshake(vs);
 }
 
     return vnc_continue_handshake(vs);
 }
 

-static int protocol_client_vencrypt_auth(VncState *vs, char *data, size_t len)
+static int protocol_client_vencrypt_auth(VncState *vs, uint8_t *data, size_t len)

 {
     int auth = read_u32(data, 0);
 
 {
     int auth = read_u32(data, 0);
 


@@ -1768,7 +1818,7 @@ static int protocol_client_vencrypt_auth(VncState *vs, char *data, size_t len)
     return 0;
 }
 
     return 0;
 }
 

-static int protocol_client_vencrypt_init(VncState *vs, char *data, size_t len)
+static int protocol_client_vencrypt_init(VncState *vs, uint8_t *data, size_t len)

 {
     if (data[0] != 0 ||
        data[1] != 2) {
 {
     if (data[0] != 0 ||
        data[1] != 2) {


@@ -1798,7 +1848,7 @@ static int start_auth_vencrypt(VncState *vs)
 }
 #endif /* CONFIG_VNC_TLS */
 
 }
 #endif /* CONFIG_VNC_TLS */
 

-static int protocol_client_auth(VncState *vs, char *data, size_t len)
+static int protocol_client_auth(VncState *vs, uint8_t *data, size_t len)

 {
     /* We only advertise 1 auth scheme at a time, so client
      * must pick the one we sent. Verify this */
 {
     /* We only advertise 1 auth scheme at a time, so client
      * must pick the one we sent. Verify this */


@@ -1827,7 +1877,7 @@ static int protocol_client_auth(VncState *vs, char *data, size_t len)
            VNC_DEBUG("Start VNC auth\n");
            return start_auth_vnc(vs);
 
            VNC_DEBUG("Start VNC auth\n");
            return start_auth_vnc(vs);
 

-#if CONFIG_VNC_TLS
+#ifdef CONFIG_VNC_TLS

        case VNC_AUTH_VENCRYPT:
            VNC_DEBUG("Accept VeNCrypt auth\n");;
            return start_auth_vencrypt(vs);
        case VNC_AUTH_VENCRYPT:
            VNC_DEBUG("Accept VeNCrypt auth\n");;
            return start_auth_vencrypt(vs);


@@ -1847,7 +1897,7 @@ static int protocol_client_auth(VncState *vs, char *data, size_t len)
     return 0;
 }
 
     return 0;
 }
 

-static int protocol_version(VncState *vs, char *version, size_t len)
+static int protocol_version(VncState *vs, uint8_t *version, size_t len)

 {
     char local[13];
 
 {
     char local[13];
 


@@ -1906,25 +1956,35 @@ static int protocol_version(VncState *vs, char *version, size_t len)
     return 0;
 }
 
     return 0;
 }
 

+static void vnc_connect(VncState *vs)
+{
+    VNC_DEBUG("New client on socket %d\n", vs->csock);
+    vs->ds->idle = 0;
+    socket_set_nonblock(vs->csock);
+    qemu_set_fd_handler2(vs->csock, NULL, vnc_client_read, NULL, vs);
+    vnc_write(vs, "RFB 003.008\n", 12);
+    vnc_flush(vs);
+    vnc_read_when(vs, protocol_version, 12);
+    memset(vs->old_data, 0, vs->ds->linesize * vs->ds->height);
+    memset(vs->dirty_row, 0xFF, sizeof(vs->dirty_row));
+    vs->has_resize = 0;
+    vs->has_hextile = 0;
+    vs->ds->dpy_copy = NULL;
+    vnc_update_client(vs);
+}
+

 static void vnc_listen_read(void *opaque)
 {
     VncState *vs = opaque;
     struct sockaddr_in addr;
     socklen_t addrlen = sizeof(addr);
 
 static void vnc_listen_read(void *opaque)
 {
     VncState *vs = opaque;
     struct sockaddr_in addr;
     socklen_t addrlen = sizeof(addr);
 

+    /* Catch-up */
+    vga_hw_update();
+

     vs->csock = accept(vs->lsock, (struct sockaddr *)&addr, &addrlen);
     if (vs->csock != -1) {
     vs->csock = accept(vs->lsock, (struct sockaddr *)&addr, &addrlen);
     if (vs->csock != -1) {

-       VNC_DEBUG("New client on socket %d\n", vs->csock);
-        socket_set_nonblock(vs->csock);
-       qemu_set_fd_handler2(vs->csock, NULL, vnc_client_read, NULL, opaque);
-       vnc_write(vs, "RFB 003.008\n", 12);
-       vnc_flush(vs);
-       vnc_read_when(vs, protocol_version, 12);
-       memset(vs->old_data, 0, vs->ds->linesize * vs->ds->height);
-       memset(vs->dirty_row, 0xFF, sizeof(vs->dirty_row));
-       vs->has_resize = 0;
-       vs->has_hextile = 0;
-       vs->ds->dpy_copy = NULL;
+        vnc_connect(vs);

     }
 }
 
     }
 }
 


@@ -1939,6 +1999,7 @@ void vnc_display_init(DisplayState *ds)
        exit(1);
 
     ds->opaque = vs;
        exit(1);
 
     ds->opaque = vs;

+    ds->idle = 1;

     vnc_state = vs;
     vs->display = NULL;
     vs->password = NULL;
     vnc_state = vs;
     vs->display = NULL;
     vs->password = NULL;


@@ -1951,24 +2012,25 @@ void vnc_display_init(DisplayState *ds)
 
     vs->ds = ds;
 
 
     vs->ds = ds;
 

-    if (!keyboard_layout)
-       keyboard_layout = "en-us";
+    if (keyboard_layout)
+        vs->kbd_layout = init_keyboard_layout(keyboard_layout);
+    else
+        vs->kbd_layout = init_keyboard_layout("en-us");

 
 

-    vs->kbd_layout = init_keyboard_layout(keyboard_layout);

     if (!vs->kbd_layout)
        exit(1);
 
     if (!vs->kbd_layout)
        exit(1);
 

+    vs->timer = qemu_new_timer(rt_clock, vnc_update_client, vs);
+

     vs->ds->data = NULL;
     vs->ds->dpy_update = vnc_dpy_update;
     vs->ds->dpy_resize = vnc_dpy_resize;
     vs->ds->data = NULL;
     vs->ds->dpy_update = vnc_dpy_update;
     vs->ds->dpy_resize = vnc_dpy_resize;

-    vs->ds->dpy_refresh = vnc_dpy_refresh;
-
-    memset(vs->dirty_row, 0xFF, sizeof(vs->dirty_row));
+    vs->ds->dpy_refresh = NULL;

 
     vnc_dpy_resize(vs->ds, 640, 400);
 }
 
 
     vnc_dpy_resize(vs->ds, 640, 400);
 }
 

-#if CONFIG_VNC_TLS
+#ifdef CONFIG_VNC_TLS

 static int vnc_set_x509_credential(VncState *vs,
                                   const char *certdir,
                                   const char *filename,
 static int vnc_set_x509_credential(VncState *vs,
                                   const char *certdir,
                                   const char *filename,


@@ -2045,7 +2107,7 @@ void vnc_display_close(DisplayState *ds)
        buffer_reset(&vs->input);
        buffer_reset(&vs->output);
        vs->need_update = 0;
        buffer_reset(&vs->input);
        buffer_reset(&vs->output);
        vs->need_update = 0;

-#if CONFIG_VNC_TLS
+#ifdef CONFIG_VNC_TLS

        if (vs->tls_session) {
            gnutls_deinit(vs->tls_session);
            vs->tls_session = NULL;
        if (vs->tls_session) {
            gnutls_deinit(vs->tls_session);
            vs->tls_session = NULL;


@@ -2054,7 +2116,7 @@ void vnc_display_close(DisplayState *ds)
 #endif /* CONFIG_VNC_TLS */
     }
     vs->auth = VNC_AUTH_INVALID;
 #endif /* CONFIG_VNC_TLS */
     }
     vs->auth = VNC_AUTH_INVALID;

-#if CONFIG_VNC_TLS
+#ifdef CONFIG_VNC_TLS

     vs->subauth = VNC_AUTH_INVALID;
     vs->x509verify = 0;
 #endif
     vs->subauth = VNC_AUTH_INVALID;
     vs->x509verify = 0;
 #endif


@@ -2082,14 +2144,15 @@ int vnc_display_open(DisplayState *ds, const char *display)
     struct sockaddr_in iaddr;
 #ifndef _WIN32
     struct sockaddr_un uaddr;
     struct sockaddr_in iaddr;
 #ifndef _WIN32
     struct sockaddr_un uaddr;

+    const char *p;

 #endif
     int reuse_addr, ret;
     socklen_t addrlen;
 #endif
     int reuse_addr, ret;
     socklen_t addrlen;

-    const char *p;

     VncState *vs = ds ? (VncState *)ds->opaque : vnc_state;
     const char *options;
     int password = 0;
     VncState *vs = ds ? (VncState *)ds->opaque : vnc_state;
     const char *options;
     int password = 0;

-#if CONFIG_VNC_TLS
+    int reverse = 0;
+#ifdef CONFIG_VNC_TLS

     int tls = 0, x509 = 0;
 #endif
 
     int tls = 0, x509 = 0;
 #endif
 


@@ -2105,7 +2168,9 @@ int vnc_display_open(DisplayState *ds, const char *display)
        options++;
        if (strncmp(options, "password", 8) == 0) {
            password = 1; /* Require password auth */
        options++;
        if (strncmp(options, "password", 8) == 0) {
            password = 1; /* Require password auth */

-#if CONFIG_VNC_TLS
+       } else if (strncmp(options, "reverse", 7) == 0) {
+           reverse = 1;
+#ifdef CONFIG_VNC_TLS

        } else if (strncmp(options, "tls", 3) == 0) {
            tls = 1; /* Require TLS */
        } else if (strncmp(options, "x509", 4) == 0) {
        } else if (strncmp(options, "tls", 3) == 0) {
            tls = 1; /* Require TLS */
        } else if (strncmp(options, "x509", 4) == 0) {


@@ -2143,7 +2208,7 @@ int vnc_display_open(DisplayState *ds, const char *display)
     }
 
     if (password) {
     }
 
     if (password) {

-#if CONFIG_VNC_TLS
+#ifdef CONFIG_VNC_TLS

        if (tls) {
            vs->auth = VNC_AUTH_VENCRYPT;
            if (x509) {
        if (tls) {
            vs->auth = VNC_AUTH_VENCRYPT;
            if (x509) {


@@ -2157,12 +2222,12 @@ int vnc_display_open(DisplayState *ds, const char *display)
 #endif
            VNC_DEBUG("Initializing VNC server with password auth\n");
            vs->auth = VNC_AUTH_VNC;
 #endif
            VNC_DEBUG("Initializing VNC server with password auth\n");
            vs->auth = VNC_AUTH_VNC;

-#if CONFIG_VNC_TLS
+#ifdef CONFIG_VNC_TLS

            vs->subauth = VNC_AUTH_INVALID;
        }
 #endif
     } else {
            vs->subauth = VNC_AUTH_INVALID;
        }
 #endif
     } else {

-#if CONFIG_VNC_TLS
+#ifdef CONFIG_VNC_TLS

        if (tls) {
            vs->auth = VNC_AUTH_VENCRYPT;
            if (x509) {
        if (tls) {
            vs->auth = VNC_AUTH_VENCRYPT;
            if (x509) {


@@ -2176,7 +2241,7 @@ int vnc_display_open(DisplayState *ds, const char *display)
 #endif
            VNC_DEBUG("Initializing VNC server with no auth\n");
            vs->auth = VNC_AUTH_NONE;
 #endif
            VNC_DEBUG("Initializing VNC server with no auth\n");
            vs->auth = VNC_AUTH_NONE;

-#if CONFIG_VNC_TLS
+#ifdef CONFIG_VNC_TLS

            vs->subauth = VNC_AUTH_INVALID;
        }
 #endif
            vs->subauth = VNC_AUTH_INVALID;
        }
 #endif


@@ -2198,7 +2263,9 @@ int vnc_display_open(DisplayState *ds, const char *display)
        memset(uaddr.sun_path, 0, 108);
        snprintf(uaddr.sun_path, 108, "%s", p);
 
        memset(uaddr.sun_path, 0, 108);
        snprintf(uaddr.sun_path, 108, "%s", p);
 

-       unlink(uaddr.sun_path);
+       if (!reverse) {
+           unlink(uaddr.sun_path);
+       }

     } else
 #endif
     {
     } else
 #endif
     {


@@ -2212,7 +2279,7 @@ int vnc_display_open(DisplayState *ds, const char *display)
            return -1;
        }
 
            return -1;
        }
 

-       iaddr.sin_port = htons(ntohs(iaddr.sin_port) + 5900);
+       iaddr.sin_port = htons(ntohs(iaddr.sin_port) + (reverse ? 0 : 5900));

 
        vs->lsock = socket(PF_INET, SOCK_STREAM, 0);
        if (vs->lsock == -1) {
 
        vs->lsock = socket(PF_INET, SOCK_STREAM, 0);
        if (vs->lsock == -1) {


@@ -2235,6 +2302,22 @@ int vnc_display_open(DisplayState *ds, const char *display)
        }
     }
 
        }
     }
 

+    if (reverse) {
+        if (connect(vs->lsock, addr, addrlen) == -1) {
+            fprintf(stderr, "Connection to VNC client failed\n");
+            close(vs->lsock);
+            vs->lsock = -1;
+            free(vs->display);
+            vs->display = NULL;
+            return -1;
+        } else {
+            vs->csock = vs->lsock;
+            vs->lsock = -1;
+            vnc_connect(vs);
+            return 0;
+        }
+    }
+

     if (bind(vs->lsock, addr, addrlen) == -1) {
        fprintf(stderr, "bind() failed\n");
        close(vs->lsock);
     if (bind(vs->lsock, addr, addrlen) == -1) {
        fprintf(stderr, "bind() failed\n");
        close(vs->lsock);