Archipelago » qemu

/*

 * QEMU VNC display driver

 *

 * Copyright (C) 2006 Anthony Liguori <anthony@codemonkey.ws>

 * Copyright (C) 2006 Fabrice Bellard

 * Copyright (C) 2009 Red Hat, Inc

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to deal

 * in the Software without restriction, including without limitation the rights

 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 * THE SOFTWARE.

 */

#include "vnc.h"

#include "sysemu.h"

#include "qemu_socket.h"

#include "qemu-timer.h"

#include "acl.h"

#define VNC_REFRESH_INTERVAL (1000 / 30)

#include "vnc_keysym.h"

#include "d3des.h"

#define count_bits(c, v) { \

    for (c = 0; v; v >>= 1) \

    { \

        c += v & 1; \

    } \

}

static VncDisplay *vnc_display; /* needed for info vnc */

static DisplayChangeListener *dcl;

static char *addr_to_string(const char *format,

                            struct sockaddr_storage *sa,

                            socklen_t salen) {

    char *addr;

    char host[NI_MAXHOST];

    char serv[NI_MAXSERV];

    int err;

    if ((err = getnameinfo((struct sockaddr *)sa, salen,

                           host, sizeof(host),

                           serv, sizeof(serv),

                           NI_NUMERICHOST | NI_NUMERICSERV)) != 0) {

        VNC_DEBUG("Cannot resolve address %d: %s\n",

                  err, gai_strerror(err));

        return NULL;

    }

    if (asprintf(&addr, format, host, serv) < 0)

        return NULL;

    return addr;

}

char *vnc_socket_local_addr(const char *format, int fd) {

    struct sockaddr_storage sa;

    socklen_t salen;

    salen = sizeof(sa);

    if (getsockname(fd, (struct sockaddr*)&sa, &salen) < 0)

        return NULL;

    return addr_to_string(format, &sa, salen);

}

char *vnc_socket_remote_addr(const char *format, int fd) {

    struct sockaddr_storage sa;

    socklen_t salen;

    salen = sizeof(sa);

    if (getpeername(fd, (struct sockaddr*)&sa, &salen) < 0)

        return NULL;

    return addr_to_string(format, &sa, salen);

}

static const char *vnc_auth_name(VncDisplay *vd) {

    switch (vd->auth) {

    case VNC_AUTH_INVALID:

        return "invalid";

    case VNC_AUTH_NONE:

        return "none";

    case VNC_AUTH_VNC:

        return "vnc";

    case VNC_AUTH_RA2:

        return "ra2";

    case VNC_AUTH_RA2NE:

        return "ra2ne";

    case VNC_AUTH_TIGHT:

        return "tight";

    case VNC_AUTH_ULTRA:

        return "ultra";

    case VNC_AUTH_TLS:

        return "tls";

    case VNC_AUTH_VENCRYPT:

#ifdef CONFIG_VNC_TLS

        switch (vd->subauth) {

        case VNC_AUTH_VENCRYPT_PLAIN:

            return "vencrypt+plain";

        case VNC_AUTH_VENCRYPT_TLSNONE:

            return "vencrypt+tls+none";

        case VNC_AUTH_VENCRYPT_TLSVNC:

            return "vencrypt+tls+vnc";

        case VNC_AUTH_VENCRYPT_TLSPLAIN:

            return "vencrypt+tls+plain";

        case VNC_AUTH_VENCRYPT_X509NONE:

            return "vencrypt+x509+none";

        case VNC_AUTH_VENCRYPT_X509VNC:

            return "vencrypt+x509+vnc";

        case VNC_AUTH_VENCRYPT_X509PLAIN:

            return "vencrypt+x509+plain";

        case VNC_AUTH_VENCRYPT_TLSSASL:

            return "vencrypt+tls+sasl";

        case VNC_AUTH_VENCRYPT_X509SASL:

            return "vencrypt+x509+sasl";

        default:

            return "vencrypt";

        }

#else

        return "vencrypt";

#endif

    case VNC_AUTH_SASL:

        return "sasl";

    }

    return "unknown";

}

#define VNC_SOCKET_FORMAT_PRETTY "local %s:%s"

static void do_info_vnc_client(Monitor *mon, VncState *client)

{

    char *clientAddr =

        vnc_socket_remote_addr("     address: %s:%s\n",

                               client->csock);

    if (!clientAddr)

        return;

    monitor_printf(mon, "Client:\n");

    monitor_printf(mon, "%s", clientAddr);

    free(clientAddr);

#ifdef CONFIG_VNC_TLS

    if (client->tls.session &&

        client->tls.dname)

        monitor_printf(mon, "  x509 dname: %s\n", client->tls.dname);

    else

        monitor_printf(mon, "  x509 dname: none\n");

#endif

#ifdef CONFIG_VNC_SASL

    if (client->sasl.conn &&

        client->sasl.username)

        monitor_printf(mon, "    username: %s\n", client->sasl.username);

    else

        monitor_printf(mon, "    username: none\n");

#endif

}

void do_info_vnc(Monitor *mon)

{

    if (vnc_display == NULL || vnc_display->display == NULL) {

        monitor_printf(mon, "Server: disabled\n");

    } else {

        char *serverAddr = vnc_socket_local_addr("     address: %s:%s\n",

                                                 vnc_display->lsock);

        if (!serverAddr)

            return;

        monitor_printf(mon, "Server:\n");

        monitor_printf(mon, "%s", serverAddr);

        free(serverAddr);

        monitor_printf(mon, "        auth: %s\n", vnc_auth_name(vnc_display));

        if (vnc_display->clients) {

            VncState *client = vnc_display->clients;

            while (client) {

                do_info_vnc_client(mon, client);

                client = client->next;

            }

        } else {

            monitor_printf(mon, "Client: none\n");

        }

    }

}

static inline uint32_t vnc_has_feature(VncState *vs, int feature) {

    return (vs->features & (1 << feature));

}

/* TODO

   1) Get the queue working for IO.

   2) there is some weirdness when using the -S option (the screen is grey

      and not totally invalidated

   3) resolutions > 1024

*/

static void vnc_update_client(void *opaque);

static void vnc_colordepth(VncState *vs);

static inline void vnc_set_bit(uint32_t *d, int k)

{

    d[k >> 5] |= 1 << (k & 0x1f);

}

static inline void vnc_clear_bit(uint32_t *d, int k)

{

    d[k >> 5] &= ~(1 << (k & 0x1f));

}

static inline void vnc_set_bits(uint32_t *d, int n, int nb_words)

{

    int j;

    j = 0;

    while (n >= 32) {

        d[j++] = -1;

        n -= 32;

    }

    if (n > 0)

        d[j++] = (1 << n) - 1;

    while (j < nb_words)

        d[j++] = 0;

}

static inline int vnc_get_bit(const uint32_t *d, int k)

{

    return (d[k >> 5] >> (k & 0x1f)) & 1;

}

static inline int vnc_and_bits(const uint32_t *d1, const uint32_t *d2,

                               int nb_words)

{

    int i;

    for(i = 0; i < nb_words; i++) {

        if ((d1[i] & d2[i]) != 0)

            return 1;

    }

    return 0;

}

static void vnc_update(VncState *vs, int x, int y, int w, int h)

{

    int i;

    h += y;

    /* round x down to ensure the loop only spans one 16-pixel block per,

       iteration.  otherwise, if (x % 16) != 0, the last iteration may span

       two 16-pixel blocks but we only mark the first as dirty

    */

    w += (x % 16);

    x -= (x % 16);

    x = MIN(x, vs->serverds.width);

    y = MIN(y, vs->serverds.height);

    w = MIN(x + w, vs->serverds.width) - x;

    h = MIN(h, vs->serverds.height);

    for (; y < h; y++)

        for (i = 0; i < w; i += 16)

            vnc_set_bit(vs->dirty_row[y], (x + i) / 16);

}

static void vnc_dpy_update(DisplayState *ds, int x, int y, int w, int h)

{

    VncDisplay *vd = ds->opaque;

    VncState *vs = vd->clients;

    while (vs != NULL) {

        vnc_update(vs, x, y, w, h);

        vs = vs->next;

    }

}

static void vnc_framebuffer_update(VncState *vs, int x, int y, int w, int h,

                                   int32_t encoding)

{

    vnc_write_u16(vs, x);

    vnc_write_u16(vs, y);

    vnc_write_u16(vs, w);

    vnc_write_u16(vs, h);

    vnc_write_s32(vs, encoding);

}

void buffer_reserve(Buffer *buffer, size_t len)

{

    if ((buffer->capacity - buffer->offset) < len) {

        buffer->capacity += (len + 1024);

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

        if (buffer->buffer == NULL) {

            fprintf(stderr, "vnc: out of memory\n");

            exit(1);

        }

    }

}

int buffer_empty(Buffer *buffer)

{

    return buffer->offset == 0;

}

uint8_t *buffer_end(Buffer *buffer)

{

    return buffer->buffer + buffer->offset;

}

void buffer_reset(Buffer *buffer)

{

        buffer->offset = 0;

}

void buffer_append(Buffer *buffer, const void *data, size_t len)

{

    memcpy(buffer->buffer + buffer->offset, data, len);

    buffer->offset += len;

}

static void vnc_resize(VncState *vs)

{

    DisplayState *ds = vs->ds;

    int size_changed;

    vs->old_data = qemu_realloc(vs->old_data, ds_get_linesize(ds) * ds_get_height(ds));

    if (vs->old_data == NULL) {

        fprintf(stderr, "vnc: memory allocation failed\n");

        exit(1);

    }

    if (ds_get_bytes_per_pixel(ds) != vs->serverds.pf.bytes_per_pixel)

        console_color_init(ds);

    vnc_colordepth(vs);

    size_changed = ds_get_width(ds) != vs->serverds.width ||

                   ds_get_height(ds) != vs->serverds.height;

    vs->serverds = *(ds->surface);

    if (size_changed) {

        if (vs->csock != -1 && vnc_has_feature(vs, VNC_FEATURE_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_get_width(ds), ds_get_height(ds),

                                   VNC_ENCODING_DESKTOPRESIZE);

            vnc_flush(vs);

        }

    }

    memset(vs->dirty_row, 0xFF, sizeof(vs->dirty_row));

    memset(vs->old_data, 42, ds_get_linesize(vs->ds) * ds_get_height(vs->ds));

}

static void vnc_dpy_resize(DisplayState *ds)

{

    VncDisplay *vd = ds->opaque;

    VncState *vs = vd->clients;

    while (vs != NULL) {

        vnc_resize(vs);

        vs = vs->next;

    }

}

/* fastest code */

static void vnc_write_pixels_copy(VncState *vs, void *pixels, int size)

{

    vnc_write(vs, pixels, size);

}

/* slowest but generic code. */

static void vnc_convert_pixel(VncState *vs, uint8_t *buf, uint32_t v)

{

    uint8_t r, g, b;

    r = ((((v & vs->serverds.pf.rmask) >> vs->serverds.pf.rshift) << vs->clientds.pf.rbits) >>

        vs->serverds.pf.rbits);

    g = ((((v & vs->serverds.pf.gmask) >> vs->serverds.pf.gshift) << vs->clientds.pf.gbits) >>

        vs->serverds.pf.gbits);

    b = ((((v & vs->serverds.pf.bmask) >> vs->serverds.pf.bshift) << vs->clientds.pf.bbits) >>

        vs->serverds.pf.bbits);

    v = (r << vs->clientds.pf.rshift) |

        (g << vs->clientds.pf.gshift) |

        (b << vs->clientds.pf.bshift);

    switch(vs->clientds.pf.bytes_per_pixel) {

    case 1:

        buf[0] = v;

        break;

    case 2:

        if (vs->clientds.flags & QEMU_BIG_ENDIAN_FLAG) {

            buf[0] = v >> 8;

            buf[1] = v;

        } else {

            buf[1] = v >> 8;

            buf[0] = v;

        }

        break;

    default:

    case 4:

        if (vs->clientds.flags & QEMU_BIG_ENDIAN_FLAG) {

            buf[0] = v >> 24;

            buf[1] = v >> 16;

            buf[2] = v >> 8;

            buf[3] = v;

        } else {

            buf[3] = v >> 24;

            buf[2] = v >> 16;

            buf[1] = v >> 8;

            buf[0] = v;

        }

        break;

    }

}

static void vnc_write_pixels_generic(VncState *vs, void *pixels1, int size)

{

    uint8_t buf[4];

    if (vs->serverds.pf.bytes_per_pixel == 4) {

        uint32_t *pixels = pixels1;

        int n, i;

        n = size >> 2;

        for(i = 0; i < n; i++) {

            vnc_convert_pixel(vs, buf, pixels[i]);

            vnc_write(vs, buf, vs->clientds.pf.bytes_per_pixel);

        }

    } else if (vs->serverds.pf.bytes_per_pixel == 2) {

        uint16_t *pixels = pixels1;

        int n, i;

        n = size >> 1;

        for(i = 0; i < n; i++) {

            vnc_convert_pixel(vs, buf, pixels[i]);

            vnc_write(vs, buf, vs->clientds.pf.bytes_per_pixel);

        }

    } else if (vs->serverds.pf.bytes_per_pixel == 1) {

        uint8_t *pixels = pixels1;

        int n, i;

        n = size;

        for(i = 0; i < n; i++) {

            vnc_convert_pixel(vs, buf, pixels[i]);

            vnc_write(vs, buf, vs->clientds.pf.bytes_per_pixel);

        }

    } else {

        fprintf(stderr, "vnc_write_pixels_generic: VncState color depth not supported\n");

    }

}

static void send_framebuffer_update_raw(VncState *vs, int x, int y, int w, int h)

{

    int i;

    uint8_t *row;

    row = ds_get_data(vs->ds) + y * ds_get_linesize(vs->ds) + x * ds_get_bytes_per_pixel(vs->ds);

    for (i = 0; i < h; i++) {

        vs->write_pixels(vs, row, w * ds_get_bytes_per_pixel(vs->ds));

        row += ds_get_linesize(vs->ds);

    }

}

static void hextile_enc_cord(uint8_t *ptr, int x, int y, int w, int h)

{

    ptr[0] = ((x & 0x0F) << 4) | (y & 0x0F);

    ptr[1] = (((w - 1) & 0x0F) << 4) | ((h - 1) & 0x0F);

}

#define BPP 8

#include "vnchextile.h"

#undef BPP

#define BPP 16

#include "vnchextile.h"

#undef BPP

#define BPP 32

#include "vnchextile.h"

#undef BPP

#define GENERIC

#define BPP 8

#include "vnchextile.h"

#undef BPP

#undef GENERIC

#define GENERIC

#define BPP 16

#include "vnchextile.h"

#undef BPP

#undef GENERIC

#define GENERIC

#define BPP 32

#include "vnchextile.h"

#undef BPP

#undef GENERIC

static void send_framebuffer_update_hextile(VncState *vs, int x, int y, int w, int h)

{

    int i, j;

    int has_fg, has_bg;

    uint8_t *last_fg, *last_bg;

    last_fg = (uint8_t *) qemu_malloc(vs->serverds.pf.bytes_per_pixel);

    last_bg = (uint8_t *) qemu_malloc(vs->serverds.pf.bytes_per_pixel);

    has_fg = has_bg = 0;

    for (j = y; j < (y + h); j += 16) {

        for (i = x; i < (x + w); i += 16) {

            vs->send_hextile_tile(vs, i, j,

                                  MIN(16, x + w - i), MIN(16, y + h - j),

                                  last_bg, last_fg, &has_bg, &has_fg);

        }

    }

    free(last_fg);

    free(last_bg);

}

static void vnc_zlib_init(VncState *vs)

{

    int i;

    for (i=0; i<(sizeof(vs->zlib_stream) / sizeof(z_stream)); i++)

        vs->zlib_stream[i].opaque = NULL;

}

static void vnc_zlib_start(VncState *vs)

{

    buffer_reset(&vs->zlib);

    // make the output buffer be the zlib buffer, so we can compress it later

    vs->zlib_tmp = vs->output;

    vs->output = vs->zlib;

}

static int vnc_zlib_stop(VncState *vs, int stream_id)

{

    z_streamp zstream = &vs->zlib_stream[stream_id];

    int previous_out;

    // switch back to normal output/zlib buffers

    vs->zlib = vs->output;

    vs->output = vs->zlib_tmp;

    // compress the zlib buffer

    // initialize the stream

    // XXX need one stream per session

    if (zstream->opaque != vs) {

        int err;

        VNC_DEBUG("VNC: initializing zlib stream %d\n", stream_id);

        VNC_DEBUG("VNC: opaque = %p | vs = %p\n", zstream->opaque, vs);

        zstream->zalloc = Z_NULL;

        zstream->zfree = Z_NULL;

        err = deflateInit2(zstream, vs->tight_compression, Z_DEFLATED, MAX_WBITS,

                           MAX_MEM_LEVEL, Z_DEFAULT_STRATEGY);

        if (err != Z_OK) {

            fprintf(stderr, "VNC: error initializing zlib\n");

            return -1;

        }

        zstream->opaque = vs;

    }

    // XXX what to do if tight_compression changed in between?

    // reserve memory in output buffer

    buffer_reserve(&vs->output, vs->zlib.offset + 64);

    // set pointers

    zstream->next_in = vs->zlib.buffer;

    zstream->avail_in = vs->zlib.offset;

    zstream->next_out = vs->output.buffer + vs->output.offset;

    zstream->avail_out = vs->output.capacity - vs->output.offset;

    zstream->data_type = Z_BINARY;

    previous_out = zstream->total_out;

    // start encoding

    if (deflate(zstream, Z_SYNC_FLUSH) != Z_OK) {

        fprintf(stderr, "VNC: error during zlib compression\n");

        return -1;

    }

    vs->output.offset = vs->output.capacity - zstream->avail_out;

    return zstream->total_out - previous_out;

}

static void send_framebuffer_update_zlib(VncState *vs, int x, int y, int w, int h)

{

    int old_offset, new_offset, bytes_written;

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

    // remember where we put in the follow-up size

    old_offset = vs->output.offset;

    vnc_write_s32(vs, 0);

    // compress the stream

    vnc_zlib_start(vs);

    send_framebuffer_update_raw(vs, x, y, w, h);

    bytes_written = vnc_zlib_stop(vs, 0);

    if (bytes_written == -1)

        return;

    // hack in the size

    new_offset = vs->output.offset;

    vs->output.offset = old_offset;

    vnc_write_u32(vs, bytes_written);

    vs->output.offset = new_offset;

}

static void send_framebuffer_update(VncState *vs, int x, int y, int w, int h)

{

    switch(vs->vnc_encoding) {

        case VNC_ENCODING_ZLIB:

            send_framebuffer_update_zlib(vs, x, y, w, h);

            break;

        case VNC_ENCODING_HEXTILE:

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

            send_framebuffer_update_hextile(vs, x, y, w, h);

            break;

        default:

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

            send_framebuffer_update_raw(vs, x, y, w, h);

            break;

    }

}

static void vnc_copy(VncState *vs, int src_x, int src_y, int dst_x, int dst_y, int w, int h)

{

    vnc_update_client(vs);

    vnc_write_u8(vs, 0);  /* msg id */

    vnc_write_u8(vs, 0);

    vnc_write_u16(vs, 1); /* number of rects */

    vnc_framebuffer_update(vs, dst_x, dst_y, w, h, VNC_ENCODING_COPYRECT);

    vnc_write_u16(vs, src_x);

    vnc_write_u16(vs, src_y);

    vnc_flush(vs);

}

static void vnc_dpy_copy(DisplayState *ds, int src_x, int src_y, int dst_x, int dst_y, int w, int h)

{

    VncDisplay *vd = ds->opaque;

    VncState *vs = vd->clients;

    while (vs != NULL) {

        if (vnc_has_feature(vs, VNC_FEATURE_COPYRECT))

            vnc_copy(vs, src_x, src_y, dst_x, dst_y, w, h);

        else /* TODO */

            vnc_update(vs, dst_x, dst_y, w, h);

        vs = vs->next;

    }

}

static int find_dirty_height(VncState *vs, int y, int last_x, int x)

{

    int h;

    for (h = 1; h < (vs->serverds.height - y); h++) {

        int tmp_x;

        if (!vnc_get_bit(vs->dirty_row[y + h], last_x))

            break;

        for (tmp_x = last_x; tmp_x < x; tmp_x++)

            vnc_clear_bit(vs->dirty_row[y + h], tmp_x);

    }

    return h;

}

static void vnc_update_client(void *opaque)

{

    VncState *vs = opaque;

    if (vs->need_update && vs->csock != -1) {

        int y;

        uint8_t *row;

        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, (ds_get_width(vs->ds) / 16), VNC_DIRTY_WORDS);

        /* Walk through the dirty map and eliminate tiles that

           really aren't dirty */

        row = ds_get_data(vs->ds);

        old_row = vs->old_data;

        for (y = 0; y < ds_get_height(vs->ds); y++) {

            if (vnc_and_bits(vs->dirty_row[y], width_mask, VNC_DIRTY_WORDS)) {

                int x;

                uint8_t *ptr;

                char *old_ptr;

                ptr = row;

                old_ptr = (char*)old_row;

                for (x = 0; x < ds_get_width(vs->ds); x += 16) {

                    if (memcmp(old_ptr, ptr, 16 * ds_get_bytes_per_pixel(vs->ds)) == 0) {

                        vnc_clear_bit(vs->dirty_row[y], (x / 16));

                    } else {

                        has_dirty = 1;

                        memcpy(old_ptr, ptr, 16 * ds_get_bytes_per_pixel(vs->ds));

                    }

                    ptr += 16 * ds_get_bytes_per_pixel(vs->ds);

                    old_ptr += 16 * ds_get_bytes_per_pixel(vs->ds);

                }

            }

            row += ds_get_linesize(vs->ds);

            old_row += ds_get_linesize(vs->ds);

        }

        if (!has_dirty && !vs->audio_cap) {

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

            return;

        }

        /* Count rectangles */

        n_rectangles = 0;

        vnc_write_u8(vs, 0);  /* msg id */

        vnc_write_u8(vs, 0);

        saved_offset = vs->output.offset;

        vnc_write_u16(vs, 0);

        for (y = 0; y < vs->serverds.height; y++) {

            int x;

            int last_x = -1;

            for (x = 0; x < vs->serverds.width / 16; x++) {

                if (vnc_get_bit(vs->dirty_row[y], x)) {

                    if (last_x == -1) {

                        last_x = x;

                    }

                    vnc_clear_bit(vs->dirty_row[y], x);

                } else {

                    if (last_x != -1) {

                        int h = find_dirty_height(vs, y, last_x, x);

                        send_framebuffer_update(vs, last_x * 16, y, (x - last_x) * 16, h);

                        n_rectangles++;

                    }

                    last_x = -1;

                }

            }

            if (last_x != -1) {

                int h = find_dirty_height(vs, y, last_x, x);

                send_framebuffer_update(vs, last_x * 16, y, (x - last_x) * 16, h);

                n_rectangles++;

            }

        }

        vs->output.buffer[saved_offset] = (n_rectangles >> 8) & 0xFF;

        vs->output.buffer[saved_offset + 1] = n_rectangles & 0xFF;

        vnc_flush(vs);

    }

    if (vs->csock != -1) {

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

    }

}

/* audio */

static void audio_capture_notify(void *opaque, audcnotification_e cmd)

{

    VncState *vs = opaque;

    switch (cmd) {

    case AUD_CNOTIFY_DISABLE:

        vnc_write_u8(vs, 255);

        vnc_write_u8(vs, 1);

        vnc_write_u16(vs, 0);

        vnc_flush(vs);

        break;

    case AUD_CNOTIFY_ENABLE:

        vnc_write_u8(vs, 255);

        vnc_write_u8(vs, 1);

        vnc_write_u16(vs, 1);

        vnc_flush(vs);

        break;

    }

}

static void audio_capture_destroy(void *opaque)

{

}

static void audio_capture(void *opaque, void *buf, int size)

{

    VncState *vs = opaque;

    vnc_write_u8(vs, 255);

    vnc_write_u8(vs, 1);

    vnc_write_u16(vs, 2);

    vnc_write_u32(vs, size);

    vnc_write(vs, buf, size);

    vnc_flush(vs);

}

static void audio_add(VncState *vs)

{

    Monitor *mon = cur_mon;

    struct audio_capture_ops ops;

    if (vs->audio_cap) {

        monitor_printf(mon, "audio already running\n");

        return;

    }

    ops.notify = audio_capture_notify;

    ops.destroy = audio_capture_destroy;

    ops.capture = audio_capture;

    vs->audio_cap = AUD_add_capture(NULL, &vs->as, &ops, vs);

    if (!vs->audio_cap) {

        monitor_printf(mon, "Failed to add audio capture\n");

    }

}

static void audio_del(VncState *vs)

{

    if (vs->audio_cap) {

        AUD_del_capture(vs->audio_cap, vs);

        vs->audio_cap = NULL;

    }

}

int vnc_client_io_error(VncState *vs, int ret, int last_errno)

{

    if (ret == 0 || ret == -1) {

        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);

        qemu_del_timer(vs->timer);

        qemu_free_timer(vs->timer);

        if (vs->input.buffer) qemu_free(vs->input.buffer);

        if (vs->output.buffer) qemu_free(vs->output.buffer);

#ifdef CONFIG_VNC_TLS

        vnc_tls_client_cleanup(vs);

#endif /* CONFIG_VNC_TLS */

#ifdef CONFIG_VNC_SASL

        vnc_sasl_client_cleanup(vs);

#endif /* CONFIG_VNC_SASL */