Return to vnc.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / ui

Annotation of qemu/ui/vnc.c, revision 1.1

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

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.