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 "vnc-jobs.h"

#include "sysemu/sysemu.h"

#include "qemu/sockets.h"

#include "qemu/timer.h"

#include "qemu/acl.h"

#include "qapi/qmp/types.h"

#include "qmp-commands.h"

#include "qemu/osdep.h"

#define VNC_REFRESH_INTERVAL_BASE GUI_REFRESH_INTERVAL_DEFAULT

#define VNC_REFRESH_INTERVAL_INC  50

#define VNC_REFRESH_INTERVAL_MAX  GUI_REFRESH_INTERVAL_IDLE

static const struct timeval VNC_REFRESH_STATS = { 0, 500000 };

static const struct timeval VNC_REFRESH_LOSSY = { 2, 0 };

#include "vnc_keysym.h"

#include "d3des.h"

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

static int vnc_cursor_define(VncState *vs);

static void vnc_release_modifiers(VncState *vs);

static void vnc_set_share_mode(VncState *vs, VncShareMode mode)

{

#ifdef _VNC_DEBUG

    static const char *mn[] = {

        [0]                           = "undefined",

        [VNC_SHARE_MODE_CONNECTING]   = "connecting",

        [VNC_SHARE_MODE_SHARED]       = "shared",

        [VNC_SHARE_MODE_EXCLUSIVE]    = "exclusive",

        [VNC_SHARE_MODE_DISCONNECTED] = "disconnected",

    };

    fprintf(stderr, "%s/%d: %s -> %s\n", __func__,

            vs->csock, mn[vs->share_mode], mn[mode]);

#endif

    if (vs->share_mode == VNC_SHARE_MODE_EXCLUSIVE) {

        vs->vd->num_exclusive--;

    }

    vs->share_mode = mode;

    if (vs->share_mode == VNC_SHARE_MODE_EXCLUSIVE) {

        vs->vd->num_exclusive++;

    }

}

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;

    size_t addrlen;

    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;

    }

    /* Enough for the existing format + the 2 vars we're

     * substituting in. */

    addrlen = strlen(format) + strlen(host) + strlen(serv);

    addr = g_malloc(addrlen + 1);

    snprintf(addr, addrlen, format, host, serv);

    addr[addrlen] = '\0';

    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 int put_addr_qdict(QDict *qdict, struct sockaddr_storage *sa,

                          socklen_t salen)

{

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

    }

    qdict_put(qdict, "host", qstring_from_str(host));

    qdict_put(qdict, "service", qstring_from_str(serv));

    qdict_put(qdict, "family",qstring_from_str(inet_strfamily(sa->ss_family)));

    return 0;

}

static int vnc_server_addr_put(QDict *qdict, int fd)

{

    struct sockaddr_storage sa;

    socklen_t salen;

    salen = sizeof(sa);

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

        return -1;

    }

    return put_addr_qdict(qdict, &sa, salen);

}

static int vnc_qdict_remote_addr(QDict *qdict, int fd)

{

    struct sockaddr_storage sa;

    socklen_t salen;

    salen = sizeof(sa);

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

        return -1;

    }

    return put_addr_qdict(qdict, &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";

}

static int vnc_server_info_put(QDict *qdict)

{

    if (vnc_server_addr_put(qdict, vnc_display->lsock) < 0) {

        return -1;

    }

    qdict_put(qdict, "auth", qstring_from_str(vnc_auth_name(vnc_display)));

    return 0;

}

static void vnc_client_cache_auth(VncState *client)

{

#if defined(CONFIG_VNC_TLS) || defined(CONFIG_VNC_SASL)

    QDict *qdict;

#endif

    if (!client->info) {

        return;

    }

#if defined(CONFIG_VNC_TLS) || defined(CONFIG_VNC_SASL)

    qdict = qobject_to_qdict(client->info);

#endif

#ifdef CONFIG_VNC_TLS

    if (client->tls.session &&

        client->tls.dname) {

        qdict_put(qdict, "x509_dname", qstring_from_str(client->tls.dname));

    }

#endif

#ifdef CONFIG_VNC_SASL

    if (client->sasl.conn &&

        client->sasl.username) {

        qdict_put(qdict, "sasl_username",

                  qstring_from_str(client->sasl.username));

    }

#endif

}

static void vnc_client_cache_addr(VncState *client)

{

    QDict *qdict;

    qdict = qdict_new();

    if (vnc_qdict_remote_addr(qdict, client->csock) < 0) {

        QDECREF(qdict);

        /* XXX: how to report the error? */

        return;

    }

    client->info = QOBJECT(qdict);

}

static void vnc_qmp_event(VncState *vs, MonitorEvent event)

{

    QDict *server;

    QObject *data;

    if (!vs->info) {

        return;

    }

    server = qdict_new();

    if (vnc_server_info_put(server) < 0) {

        QDECREF(server);

        return;

    }

    data = qobject_from_jsonf("{ 'client': %p, 'server': %p }",

                              vs->info, QOBJECT(server));

    monitor_protocol_event(event, data);

    qobject_incref(vs->info);

    qobject_decref(data);

}

static VncClientInfo *qmp_query_vnc_client(const VncState *client)

{

    struct sockaddr_storage sa;

    socklen_t salen = sizeof(sa);

    char host[NI_MAXHOST];

    char serv[NI_MAXSERV];

    VncClientInfo *info;

    if (getpeername(client->csock, (struct sockaddr *)&sa, &salen) < 0) {

        return NULL;

    }

    if (getnameinfo((struct sockaddr *)&sa, salen,

                    host, sizeof(host),

                    serv, sizeof(serv),

                    NI_NUMERICHOST | NI_NUMERICSERV) < 0) {

        return NULL;

    }

    info = g_malloc0(sizeof(*info));

    info->host = g_strdup(host);

    info->service = g_strdup(serv);

    info->family = g_strdup(inet_strfamily(sa.ss_family));

#ifdef CONFIG_VNC_TLS

    if (client->tls.session && client->tls.dname) {

        info->has_x509_dname = true;

        info->x509_dname = g_strdup(client->tls.dname);

    }

#endif

#ifdef CONFIG_VNC_SASL

    if (client->sasl.conn && client->sasl.username) {

        info->has_sasl_username = true;

        info->sasl_username = g_strdup(client->sasl.username);

    }

#endif

    return info;

}

VncInfo *qmp_query_vnc(Error **errp)

{

    VncInfo *info = g_malloc0(sizeof(*info));

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

        info->enabled = false;

    } else {

        VncClientInfoList *cur_item = NULL;

        struct sockaddr_storage sa;

        socklen_t salen = sizeof(sa);

        char host[NI_MAXHOST];

        char serv[NI_MAXSERV];

        VncState *client;

        info->enabled = true;

        /* for compatibility with the original command */

        info->has_clients = true;

        QTAILQ_FOREACH(client, &vnc_display->clients, next) {

            VncClientInfoList *cinfo = g_malloc0(sizeof(*info));

            cinfo->value = qmp_query_vnc_client(client);

            /* XXX: waiting for the qapi to support GSList */

            if (!cur_item) {

                info->clients = cur_item = cinfo;

            } else {

                cur_item->next = cinfo;

                cur_item = cinfo;

            }

        }

        if (vnc_display->lsock == -1) {

            return info;

        }

        if (getsockname(vnc_display->lsock, (struct sockaddr *)&sa,

                        &salen) == -1) {

            error_set(errp, QERR_UNDEFINED_ERROR);

            goto out_error;

        }

        if (getnameinfo((struct sockaddr *)&sa, salen,

                        host, sizeof(host),

                        serv, sizeof(serv),

                        NI_NUMERICHOST | NI_NUMERICSERV) < 0) {

            error_set(errp, QERR_UNDEFINED_ERROR);

            goto out_error;

        }

        info->has_host = true;

        info->host = g_strdup(host);

        info->has_service = true;

        info->service = g_strdup(serv);

        info->has_family = true;

        info->family = g_strdup(inet_strfamily(sa.ss_family));

        info->has_auth = true;

        info->auth = g_strdup(vnc_auth_name(vnc_display));

    }

    return info;

out_error:

    qapi_free_VncInfo(info);

    return NULL;

}

/* 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 int vnc_update_client(VncState *vs, int has_dirty);

static int vnc_update_client_sync(VncState *vs, int has_dirty);

static void vnc_disconnect_start(VncState *vs);

static void vnc_colordepth(VncState *vs);

static void framebuffer_update_request(VncState *vs, int incremental,

                                       int x_position, int y_position,

                                       int w, int h);

static void vnc_refresh(DisplayChangeListener *dcl);

static int vnc_refresh_server_surface(VncDisplay *vd);

static void vnc_dpy_update(DisplayChangeListener *dcl,

                           int x, int y, int w, int h)

{

    int i;

    VncDisplay *vd = container_of(dcl, VncDisplay, dcl);

    struct VncSurface *s = &vd->guest;

    int width = surface_width(vd->ds);

    int height = surface_height(vd->ds);

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

    y = MIN(y, height);

    w = MIN(x + w, width) - x;

    h = MIN(h, height);

    for (; y < h; y++)

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

            set_bit((x + i) / 16, s->dirty[y]);

}

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 = g_realloc(buffer->buffer, buffer->capacity);

        if (buffer->buffer == NULL) {

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

            exit(1);

        }

    }

}

static 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_free(Buffer *buffer)

{

    g_free(buffer->buffer);

    buffer->offset = 0;

    buffer->capacity = 0;

    buffer->buffer = NULL;

}

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

{

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

    buffer->offset += len;

}

void buffer_advance(Buffer *buf, size_t len)

{

    memmove(buf->buffer, buf->buffer + len,

            (buf->offset - len));

    buf->offset -= len;

}

static void vnc_desktop_resize(VncState *vs)

{

    DisplaySurface *ds = vs->vd->ds;

    if (vs->csock == -1 || !vnc_has_feature(vs, VNC_FEATURE_RESIZE)) {

        return;

    }

    if (vs->client_width == surface_width(ds) &&

        vs->client_height == surface_height(ds)) {

        return;

    }

    vs->client_width = surface_width(ds);

    vs->client_height = surface_height(ds);

    vnc_lock_output(vs);

    vnc_write_u8(vs, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE);

    vnc_write_u8(vs, 0);

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

    vnc_framebuffer_update(vs, 0, 0, vs->client_width, vs->client_height,

                           VNC_ENCODING_DESKTOPRESIZE);

    vnc_unlock_output(vs);

    vnc_flush(vs);

}

static void vnc_abort_display_jobs(VncDisplay *vd)

{

    VncState *vs;

    QTAILQ_FOREACH(vs, &vd->clients, next) {

        vnc_lock_output(vs);

        vs->abort = true;

        vnc_unlock_output(vs);

    }

    QTAILQ_FOREACH(vs, &vd->clients, next) {

        vnc_jobs_join(vs);

    }

    QTAILQ_FOREACH(vs, &vd->clients, next) {

        vnc_lock_output(vs);

        vs->abort = false;

        vnc_unlock_output(vs);

    }

}

int vnc_server_fb_stride(VncDisplay *vd)

{

    return pixman_image_get_stride(vd->server);

}

void *vnc_server_fb_ptr(VncDisplay *vd, int x, int y)

{

    uint8_t *ptr;

    ptr  = (uint8_t *)pixman_image_get_data(vd->server);

    ptr += y * vnc_server_fb_stride(vd);

    ptr += x * VNC_SERVER_FB_BYTES;

    return ptr;

}

static void vnc_dpy_switch(DisplayChangeListener *dcl,

                           DisplaySurface *surface)

{

    VncDisplay *vd = container_of(dcl, VncDisplay, dcl);

    VncState *vs;

    vnc_abort_display_jobs(vd);

    /* server surface */

    qemu_pixman_image_unref(vd->server);

    vd->ds = surface;

    vd->server = pixman_image_create_bits(VNC_SERVER_FB_FORMAT,

                                          surface_width(vd->ds),

                                          surface_height(vd->ds),

                                          NULL, 0);

    /* guest surface */

#if 0 /* FIXME */

    if (ds_get_bytes_per_pixel(ds) != vd->guest.ds->pf.bytes_per_pixel)

        console_color_init(ds);

#endif

    qemu_pixman_image_unref(vd->guest.fb);

    vd->guest.fb = pixman_image_ref(surface->image);

    vd->guest.format = surface->format;

    memset(vd->guest.dirty, 0xFF, sizeof(vd->guest.dirty));

    QTAILQ_FOREACH(vs, &vd->clients, next) {

        vnc_colordepth(vs);

        vnc_desktop_resize(vs);

        if (vs->vd->cursor) {

            vnc_cursor_define(vs);

        }

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

    }

}

/* fastest code */

static void vnc_write_pixels_copy(VncState *vs,

                                  void *pixels, int size)

{

    vnc_write(vs, pixels, size);

}

/* slowest but generic code. */

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

{

    uint8_t r, g, b;

#if VNC_SERVER_FB_FORMAT == PIXMAN_FORMAT(32, PIXMAN_TYPE_ARGB, 0, 8, 8, 8)

    r = (((v & 0x00ff0000) >> 16) << vs->client_pf.rbits) >> 8;

    g = (((v & 0x0000ff00) >>  8) << vs->client_pf.gbits) >> 8;

    b = (((v & 0x000000ff) >>  0) << vs->client_pf.bbits) >> 8;

#else

# error need some bits here if you change VNC_SERVER_FB_FORMAT

#endif

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

        (g << vs->client_pf.gshift) |

        (b << vs->client_pf.bshift);

    switch (vs->client_pf.bytes_per_pixel) {

    case 1:

        buf[0] = v;

        break;

    case 2:

        if (vs->client_be) {

            buf[0] = v >> 8;

            buf[1] = v;

        } else {

            buf[1] = v >> 8;

            buf[0] = v;

        }

        break;

    default:

    case 4:

        if (vs->client_be) {

            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 (VNC_SERVER_FB_BYTES == 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->client_pf.bytes_per_pixel);

        }

    }

}

int vnc_raw_send_framebuffer_update(VncState *vs, int x, int y, int w, int h)

{

    int i;

    uint8_t *row;

    VncDisplay *vd = vs->vd;

    row = vnc_server_fb_ptr(vd, x, y);

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

        vs->write_pixels(vs, row, w * VNC_SERVER_FB_BYTES);

        row += vnc_server_fb_stride(vd);

    }

    return 1;

}

int vnc_send_framebuffer_update(VncState *vs, int x, int y, int w, int h)

{

    int n = 0;

    switch(vs->vnc_encoding) {

        case VNC_ENCODING_ZLIB:

            n = vnc_zlib_send_framebuffer_update(vs, x, y, w, h);

            break;

        case VNC_ENCODING_HEXTILE:

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

            n = vnc_hextile_send_framebuffer_update(vs, x, y, w, h);

            break;

        case VNC_ENCODING_TIGHT:

            n = vnc_tight_send_framebuffer_update(vs, x, y, w, h);

            break;

        case VNC_ENCODING_TIGHT_PNG:

            n = vnc_tight_png_send_framebuffer_update(vs, x, y, w, h);

            break;

        case VNC_ENCODING_ZRLE:

            n = vnc_zrle_send_framebuffer_update(vs, x, y, w, h);

            break;

        case VNC_ENCODING_ZYWRLE:

            n = vnc_zywrle_send_framebuffer_update(vs, x, y, w, h);

            break;

        default:

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

            n = vnc_raw_send_framebuffer_update(vs, x, y, w, h);

            break;

    }

    return n;

}

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

{

    /* send bitblit op to the vnc client */

    vnc_lock_output(vs);

    vnc_write_u8(vs, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE);

    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_unlock_output(vs);

    vnc_flush(vs);

}

static void vnc_dpy_copy(DisplayChangeListener *dcl,

                         int src_x, int src_y,

                         int dst_x, int dst_y, int w, int h)

{

    VncDisplay *vd = container_of(dcl, VncDisplay, dcl);

    VncState *vs, *vn;

    uint8_t *src_row;

    uint8_t *dst_row;

    int i, x, y, pitch, inc, w_lim, s;

    int cmp_bytes;

    vnc_refresh_server_surface(vd);

    QTAILQ_FOREACH_SAFE(vs, &vd->clients, next, vn) {

        if (vnc_has_feature(vs, VNC_FEATURE_COPYRECT)) {

            vs->force_update = 1;

            vnc_update_client_sync(vs, 1);

            /* vs might be free()ed here */

        }

    }

    /* do bitblit op on the local surface too */

    pitch = vnc_server_fb_stride(vd);

    src_row = vnc_server_fb_ptr(vd, src_x, src_y);

    dst_row = vnc_server_fb_ptr(vd, dst_x, dst_y);

    y = dst_y;

    inc = 1;

    if (dst_y > src_y) {

        /* copy backwards */

        src_row += pitch * (h-1);

        dst_row += pitch * (h-1);

        pitch = -pitch;

        y = dst_y + h - 1;

        inc = -1;

    }

    w_lim = w - (16 - (dst_x % 16));

    if (w_lim < 0)

        w_lim = w;

    else

        w_lim = w - (w_lim % 16);

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

        for (x = 0; x <= w_lim;

                x += s, src_row += cmp_bytes, dst_row += cmp_bytes) {

            if (x == w_lim) {

                if ((s = w - w_lim) == 0)

                    break;

            } else if (!x) {

                s = (16 - (dst_x % 16));

                s = MIN(s, w_lim);

            } else {

                s = 16;

            }

            cmp_bytes = s * VNC_SERVER_FB_BYTES;

            if (memcmp(src_row, dst_row, cmp_bytes) == 0)

                continue;

            memmove(dst_row, src_row, cmp_bytes);

            QTAILQ_FOREACH(vs, &vd->clients, next) {

                if (!vnc_has_feature(vs, VNC_FEATURE_COPYRECT)) {

                    set_bit(((x + dst_x) / 16), vs->dirty[y]);

                }

            }

        }

        src_row += pitch - w * VNC_SERVER_FB_BYTES;

        dst_row += pitch - w * VNC_SERVER_FB_BYTES;

        y += inc;

    }

    QTAILQ_FOREACH(vs, &vd->clients, next) {

        if (vnc_has_feature(vs, VNC_FEATURE_COPYRECT)) {

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

        }

    }

}

static void vnc_mouse_set(DisplayChangeListener *dcl,

                          int x, int y, int visible)

{

    /* can we ask the client(s) to move the pointer ??? */

}

static int vnc_cursor_define(VncState *vs)

{

    QEMUCursor *c = vs->vd->cursor;

    int isize;

    if (vnc_has_feature(vs, VNC_FEATURE_RICH_CURSOR)) {

        vnc_lock_output(vs);

        vnc_write_u8(vs,  VNC_MSG_SERVER_FRAMEBUFFER_UPDATE);

        vnc_write_u8(vs,  0);  /*  padding     */

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

        vnc_framebuffer_update(vs, c->hot_x, c->hot_y, c->width, c->height,

                               VNC_ENCODING_RICH_CURSOR);

        isize = c->width * c->height * vs->client_pf.bytes_per_pixel;

        vnc_write_pixels_generic(vs, c->data, isize);

        vnc_write(vs, vs->vd->cursor_mask, vs->vd->cursor_msize);

        vnc_unlock_output(vs);

        return 0;

    }

    return -1;

}

static void vnc_dpy_cursor_define(DisplayChangeListener *dcl,

                                  QEMUCursor *c)

{

    VncDisplay *vd = vnc_display;

    VncState *vs;

    cursor_put(vd->cursor);

    g_free(vd->cursor_mask);

    vd->cursor = c;

    cursor_get(vd->cursor);

    vd->cursor_msize = cursor_get_mono_bpl(c) * c->height;

    vd->cursor_mask = g_malloc0(vd->cursor_msize);

    cursor_get_mono_mask(c, 0, vd->cursor_mask);

    QTAILQ_FOREACH(vs, &vd->clients, next) {

        vnc_cursor_define(vs);

    }

}

static int find_and_clear_dirty_height(struct VncState *vs,

                                       int y, int last_x, int x, int height)

{

    int h;

    for (h = 1; h < (height - y); h++) {

        int tmp_x;

        if (!test_bit(last_x, vs->dirty[y + h])) {

            break;

        }

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

            clear_bit(tmp_x, vs->dirty[y + h]);

        }

    }

    return h;

}

static int vnc_update_client_sync(VncState *vs, int has_dirty)

{

    int ret = vnc_update_client(vs, has_dirty);

    vnc_jobs_join(vs);

    return ret;

}

static int vnc_update_client(VncState *vs, int has_dirty)

{

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

        VncDisplay *vd = vs->vd;

        VncJob *job;

        int y;

        int width, height;

        int n = 0;