1 /*

     2  * QEMU VNC display driver

     3  *

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

     5  * Copyright (C) 2006 Fabrice Bellard

     6  *

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

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

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

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

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

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

    13  *

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

    15  * all copies or substantial portions of the Software.

    16  *

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

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

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

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

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

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

    23  * THE SOFTWARE.

    24  */

    25 

    26 #include "qemu-common.h"

    27 #include "console.h"

    28 #include "sysemu.h"

    29 #include "qemu_socket.h"

    30 #include "qemu-timer.h"

    31 #include "gui_host.h"

    32 #include "audio/audio.h"

    33 

    34 #define VNC_REFRESH_INTERVAL (1000 / 30)

    35 

    36 #include "vnc_keysym.h"

    37 #include "keymaps.c"

    38 #include "d3des.h"

    39 

    40 #ifdef CONFIG_VNC_TLS

    41 #include <gnutls/gnutls.h>

    42 #include <gnutls/x509.h>

    43 #endif /* CONFIG_VNC_TLS */

    44 

    45 // #define _VNC_DEBUG 1

    46 

    47 #ifdef _VNC_DEBUG

    48 #define VNC_DEBUG(fmt, ...) do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)

    49 

    50 #if CONFIG_VNC_TLS && _VNC_DEBUG >= 2

    51 /* Very verbose, so only enabled for _VNC_DEBUG >= 2 */

    52 static void vnc_debug_gnutls_log(int level, const char* str) {

    53     VNC_DEBUG("%d %s", level, str);

    54 }

    55 #endif /* CONFIG_VNC_TLS && _VNC_DEBUG */

    56 #else

    57 #define VNC_DEBUG(fmt, ...) do { } while (0)

    58 #endif

    59 

    60 /* DFG TODO */

    61 #define kbd_put_keycode gui_notify_term_key

    62 /************/

    63 

    64 typedef struct Buffer

    65 {

    66     size_t capacity;

    67     size_t offset;

    68     uint8_t *buffer;

    69 } Buffer;

    70 

    71 typedef struct VncState VncState;

    72 

    73 typedef int VncReadEvent(VncState *vs, uint8_t *data, size_t len);

    74 

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

    76 

    77 typedef void VncSendHextileTile(VncState *vs,

    78                                 int x, int y, int w, int h,

    79                                 void *last_bg,

    80                                 void *last_fg,

    81                                 int *has_bg, int *has_fg);

    82 

    83 #define VNC_MAX_WIDTH 2048

    84 #define VNC_MAX_HEIGHT 2048

    85 #define VNC_DIRTY_WORDS (VNC_MAX_WIDTH / (16 * 32))

    86 

    87 #define VNC_AUTH_CHALLENGE_SIZE 16

    88 

    89 enum {

    90     VNC_AUTH_INVALID = 0,

    91     VNC_AUTH_NONE = 1,

    92     VNC_AUTH_VNC = 2,

    93     VNC_AUTH_RA2 = 5,

    94     VNC_AUTH_RA2NE = 6,

    95     VNC_AUTH_TIGHT = 16,

    96     VNC_AUTH_ULTRA = 17,

    97     VNC_AUTH_TLS = 18,

    98     VNC_AUTH_VENCRYPT = 19

    99 };

   100 

   101 #ifdef CONFIG_VNC_TLS

   102 enum {

   103     VNC_WIREMODE_CLEAR,

   104     VNC_WIREMODE_TLS,

   105 };

   106 

   107 enum {

   108     VNC_AUTH_VENCRYPT_PLAIN = 256,

   109     VNC_AUTH_VENCRYPT_TLSNONE = 257,

   110     VNC_AUTH_VENCRYPT_TLSVNC = 258,

   111     VNC_AUTH_VENCRYPT_TLSPLAIN = 259,

   112     VNC_AUTH_VENCRYPT_X509NONE = 260,

   113     VNC_AUTH_VENCRYPT_X509VNC = 261,

   114     VNC_AUTH_VENCRYPT_X509PLAIN = 262,

   115 };

   116 

   117 #define X509_CA_CERT_FILE "ca-cert.pem"

   118 #define X509_CA_CRL_FILE "ca-crl.pem"

   119 #define X509_SERVER_KEY_FILE "server-key.pem"

   120 #define X509_SERVER_CERT_FILE "server-cert.pem"

   121 

   122 #endif /* CONFIG_VNC_TLS */

   123 

   124 

   125 int kbd_in_terminal_mode; /* DFG TODO: MOVE THIS INTO VncState and implement! */

   126 

   127 struct VncState

   128 {

   129     QEMUTimer *timer;

   130     int lsock;

   131     int csock;

   132     DisplayState *ds;

   133     int need_update;

   134     int width;

   135     int height;

   136     uint32_t dirty_row[VNC_MAX_HEIGHT][VNC_DIRTY_WORDS];

   137     char *old_data;

   138     int depth; /* internal VNC frame buffer byte per pixel */

   139     int has_resize;

   140     int has_hextile;

   141     int has_pointer_type_change;

   142     int has_WMVi;

   143     int absolute;

   144     int last_x;

   145     int last_y;

   146 

   147     int major;

   148     int minor;

   149 

   150     char *display;

   151     char *password;

   152     int auth;

   153 #ifdef CONFIG_VNC_TLS

   154     int subauth;

   155     int x509verify;

   156 

   157     char *x509cacert;

   158     char *x509cacrl;

   159     char *x509cert;

   160     char *x509key;

   161 #endif

   162     char challenge[VNC_AUTH_CHALLENGE_SIZE];

   163 

   164 #ifdef CONFIG_VNC_TLS

   165     int wiremode;

   166     gnutls_session_t tls_session;

   167 #endif

   168 

   169     Buffer output;

   170     Buffer input;

   171     kbd_layout_t *kbd_layout;

   172     /* current output mode information */

   173     VncWritePixels *write_pixels;

   174     VncSendHextileTile *send_hextile_tile;

   175     int pix_bpp, pix_big_endian;

   176     int client_red_shift, client_red_max, server_red_shift, server_red_max;

   177     int client_green_shift, client_green_max, server_green_shift, server_green_max;

   178     int client_blue_shift, client_blue_max, server_blue_shift, server_blue_max;

   179 

   180     CaptureVoiceOut *audio_cap;

   181     struct audsettings as;

   182 

   183     VncReadEvent *read_handler;

   184     size_t read_handler_expect;

   185     /* input */

   186     uint8_t modifiers_state[256];

   187 };

   188 

   189 static VncState *vnc_state; /* needed for info vnc */

   190 

   191 void do_info_vnc(void)

   192 {

   193     if (vnc_state == NULL || vnc_state->display == NULL)

   194 	term_printf("VNC server disabled\n");

   195     else {

   196 	term_printf("VNC server active on: ");

   197 	term_print_filename(vnc_state->display);

   198 	term_printf("\n");

   199 

   200 	if (vnc_state->csock == -1)

   201 	    term_printf("No client connected\n");

   202 	else

   203 	    term_printf("Client connected\n");

   204     }

   205 }

   206 

   207 /* TODO

   208    1) Get the queue working for IO.

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

   210       and not totally invalidated

   211    3) resolutions > 1024

   212 */

   213 

   214 static void vnc_write(VncState *vs, const void *data, size_t len);

   215 static void vnc_write_u32(VncState *vs, uint32_t value);

   216 static void vnc_write_s32(VncState *vs, int32_t value);

   217 static void vnc_write_u16(VncState *vs, uint16_t value);

   218 static void vnc_write_u8(VncState *vs, uint8_t value);

   219 static void vnc_flush(VncState *vs);

   220 static void vnc_update_client(void *opaque);

   221 static void vnc_client_read(void *opaque);

   222 

   223 static void vnc_colordepth(DisplayState *ds, int depth);

   224 

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

   226 {

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

   228 }

   229 

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

   231 {

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

   233 }

   234 

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

   236 {

   237     int j;

   238 

   239     j = 0;

   240     while (n >= 32) {

   241         d[j++] = -1;

   242         n -= 32;

   243     }

   244     if (n > 0)

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

   246     while (j < nb_words)

   247         d[j++] = 0;

   248 }

   249 

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

   251 {

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

   253 }

   254 

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

   256                                int nb_words)

   257 {

   258     int i;

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

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

   261             return 1;

   262     }

   263     return 0;

   264 }

   265 

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

   267 {

   268     VncState *vs = ds->opaque;

   269     int i;

   270 

   271     h += y;

   272 

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

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

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

   276     */

   277     w += (x % 16);

   278     x -= (x % 16);

   279 

   280     x = MIN(x, vs->width);

   281     y = MIN(y, vs->height);

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

   283     h = MIN(h, vs->height);

   284 

   285     for (; y < h; y++)

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

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

   288 }

   289 

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

   291 				   int32_t encoding)

   292 {

   293     vnc_write_u16(vs, x);

   294     vnc_write_u16(vs, y);

   295     vnc_write_u16(vs, w);

   296     vnc_write_u16(vs, h);

   297 

   298     vnc_write_s32(vs, encoding);

   299 }

   300 

   301 static void vnc_dpy_resize(DisplayState *ds, int w, int h)

   302 {

   303     int size_changed;

   304     VncState *vs = ds->opaque;

   305 

   306     ds->data = qemu_realloc(ds->data, w * h * vs->depth);

   307     vs->old_data = qemu_realloc(vs->old_data, w * h * vs->depth);

   308 

   309     if (ds->data == NULL || vs->old_data == NULL) {

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

   311 	exit(1);

   312     }

   313 

   314     if (ds->depth != vs->depth * 8) {

   315         ds->depth = vs->depth * 8;

   316         console_color_init(ds);

   317     }

   318     size_changed = ds->width != w || ds->height != h;

   319     ds->width = w;

   320     ds->height = h;

   321     ds->linesize = w * vs->depth;

   322     if (size_changed) {

   323         vs->width = ds->width;

   324         vs->height = ds->height;

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

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

   327             vnc_write_u8(vs, 0);

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

   329             vnc_framebuffer_update(vs, 0, 0, ds->width, ds->height, -223);

   330             vnc_flush(vs);

   331         }

   332     }

   333 

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

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

   336 }

   337 

   338 /* fastest code */

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

   340 {

   341     vnc_write(vs, pixels, size);

   342 }

   343 

   344 /* slowest but generic code. */

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

   346 {

   347     uint8_t r, g, b;

   348 

   349     r = ((v >> vs->server_red_shift) & vs->server_red_max) * (vs->client_red_max + 1) /

   350         (vs->server_red_max + 1);

   351     g = ((v >> vs->server_green_shift) & vs->server_green_max) * (vs->client_green_max + 1) /

   352         (vs->server_green_max + 1);

   353     b = ((v >> vs->server_blue_shift) & vs->server_blue_max) * (vs->client_blue_max + 1) /

   354         (vs->server_blue_max + 1);

   355     v = (r << vs->client_red_shift) |

   356         (g << vs->client_green_shift) |

   357         (b << vs->client_blue_shift);

   358     switch(vs->pix_bpp) {

   359     case 1:

   360         buf[0] = v;

   361         break;

   362     case 2:

   363         if (vs->pix_big_endian) {

   364             buf[0] = v >> 8;

   365             buf[1] = v;

   366         } else {

   367             buf[1] = v >> 8;

   368             buf[0] = v;

   369         }

   370         break;

   371     default:

   372     case 4:

   373         if (vs->pix_big_endian) {

   374             buf[0] = v >> 24;

   375             buf[1] = v >> 16;

   376             buf[2] = v >> 8;

   377             buf[3] = v;

   378         } else {

   379             buf[3] = v >> 24;

   380             buf[2] = v >> 16;

   381             buf[1] = v >> 8;

   382             buf[0] = v;

   383         }

   384         break;

   385     }

   386 }

   387 

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

   389 {

   390     uint8_t buf[4];

   391 

   392     if (vs->depth == 4) {

   393         uint32_t *pixels = pixels1;

   394         int n, i;

   395         n = size >> 2;

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

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

   398             vnc_write(vs, buf, vs->pix_bpp);

   399         }

   400     } else if (vs->depth == 2) {

   401         uint16_t *pixels = pixels1;

   402         int n, i;

   403         n = size >> 1;

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

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

   406             vnc_write(vs, buf, vs->pix_bpp);

   407         }

   408     } else if (vs->depth == 1) {

   409         uint8_t *pixels = pixels1;

   410         int n, i;

   411         n = size;

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

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

   414             vnc_write(vs, buf, vs->pix_bpp);

   415         }

   416     } else {

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

   418     }

   419 }

   420 

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

   422 {

   423     int i;

   424     uint8_t *row;

   425 

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

   427 

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

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

   430 	vs->write_pixels(vs, row, w * vs->depth);

   431 	row += ds_get_linesize(vs->ds);

   432     }

   433 }

   434 

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

   436 {

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

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

   439 }

   440 

   441 #define BPP 8

   442 #include "vnchextile.h"

   443 #undef BPP

   444 

   445 #define BPP 16

   446 #include "vnchextile.h"

   447 #undef BPP

   448 

   449 #define BPP 32

   450 #include "vnchextile.h"

   451 #undef BPP

   452 

   453 #define GENERIC

   454 #define BPP 8

   455 #include "vnchextile.h"

   456 #undef BPP

   457 #undef GENERIC

   458 

   459 #define GENERIC

   460 #define BPP 16

   461 #include "vnchextile.h"

   462 #undef BPP

   463 #undef GENERIC

   464 

   465 #define GENERIC

   466 #define BPP 32

   467 #include "vnchextile.h"

   468 #undef BPP

   469 #undef GENERIC

   470 

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

   472 {

   473     int i, j;

   474     int has_fg, has_bg;

   475     uint8_t *last_fg, *last_bg;

   476 

   477     vnc_framebuffer_update(vs, x, y, w, h, 5);

   478 

   479     last_fg = (uint8_t *) malloc(vs->depth);

   480     last_bg = (uint8_t *) malloc(vs->depth);

   481     has_fg = has_bg = 0;

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

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

   484             vs->send_hextile_tile(vs, i, j,

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

   486                                   last_bg, last_fg, &has_bg, &has_fg);

   487 	}

   488     }

   489     free(last_fg);

   490     free(last_bg);

   491 

   492 }

   493 

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

   495 {

   496 	if (vs->has_hextile)

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

   498 	else

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

   500 }

   501 

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

   503 {

   504     int src, dst;

   505     uint8_t *src_row;

   506     uint8_t *dst_row;

   507     char *old_row;

   508     int y = 0;

   509     int pitch = ds_get_linesize(ds);

   510     VncState *vs = ds->opaque;

   511 

   512     vnc_update_client(vs);

   513 

   514     if (dst_y > src_y) {

   515 	y = h - 1;

   516 	pitch = -pitch;

   517     }

   518 

   519     src = (ds_get_linesize(ds) * (src_y + y) + vs->depth * src_x);

   520     dst = (ds_get_linesize(ds) * (dst_y + y) + vs->depth * dst_x);

   521 

   522     src_row = ds_get_data(ds) + src;

   523     dst_row = ds_get_data(ds) + dst;

   524     old_row = vs->old_data + dst;

   525 

   526     for (y = 0; y < h; y++) {

   527 	memmove(old_row, src_row, w * vs->depth);

   528 	memmove(dst_row, src_row, w * vs->depth);

   529 	src_row += pitch;

   530 	dst_row += pitch;

   531 	old_row += pitch;

   532     }

   533 

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

   535     vnc_write_u8(vs, 0);

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

   537     vnc_framebuffer_update(vs, dst_x, dst_y, w, h, 1);

   538     vnc_write_u16(vs, src_x);

   539     vnc_write_u16(vs, src_y);

   540     vnc_flush(vs);

   541 }

   542 

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

   544 {

   545     int h;

   546 

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

   548 	int tmp_x;

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

   550 	    break;

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

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

   553     }

   554 

   555     return h;

   556 }

   557 

   558 static void vnc_update_client(void *opaque)

   559 {

   560     VncState *vs = opaque;

   561 

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

   563 	int y;

   564 	uint8_t *row;

   565 	char *old_row;

   566 	uint32_t width_mask[VNC_DIRTY_WORDS];

   567 	int n_rectangles;

   568 	int saved_offset;

   569 	int has_dirty = 0;

   570 

   571 #if 0

   572         TODO CHECK DFG

   573         vga_hw_update();

   574 #endif

   575 

   576         vnc_set_bits(width_mask, (vs->width / 16), VNC_DIRTY_WORDS);

   577 

   578 	/* Walk through the dirty map and eliminate tiles that

   579 	   really aren't dirty */

   580 	row = ds_get_data(vs->ds);

   581 	old_row = vs->old_data;

   582 

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

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

   585 		int x;

   586 		uint8_t *ptr;

   587 		char *old_ptr;

   588 

   589 		ptr = row;

   590 		old_ptr = (char*)old_row;

   591 

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

   593 		    if (memcmp(old_ptr, ptr, 16 * vs->depth) == 0) {

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

   595 		    } else {

   596 			has_dirty = 1;

   597 			memcpy(old_ptr, ptr, 16 * vs->depth);

   598 		    }

   599 

   600 		    ptr += 16 * vs->depth;

   601 		    old_ptr += 16 * vs->depth;

   602 		}

   603 	    }

   604 

   605 	    row += ds_get_linesize(vs->ds);

   606 	    old_row += ds_get_linesize(vs->ds);

   607 	}

   608 

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

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

   611 	    return;

   612 	}

   613 

   614 	/* Count rectangles */

   615 	n_rectangles = 0;

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

   617 	vnc_write_u8(vs, 0);

   618 	saved_offset = vs->output.offset;

   619 	vnc_write_u16(vs, 0);

   620 

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

   622 	    int x;

   623 	    int last_x = -1;

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

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

   626 		    if (last_x == -1) {

   627 			last_x = x;

   628 		    }

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

   630 		} else {

   631 		    if (last_x != -1) {

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

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

   634 			n_rectangles++;

   635 		    }

   636 		    last_x = -1;

   637 		}

   638 	    }

   639 	    if (last_x != -1) {

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

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

   642 		n_rectangles++;

   643 	    }

   644 	}

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

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

   647 	vnc_flush(vs);

   648 

   649     }

   650 

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

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

   653     }

   654 

   655 }

   656 

   657 static int vnc_listen_poll(void *opaque)

   658 {

   659     VncState *vs = opaque;

   660     if (vs->csock == -1)

   661 	return 1;

   662     return 0;

   663 }

   664 

   665 static void buffer_reserve(Buffer *buffer, size_t len)

   666 {

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

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

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

   670 	if (buffer->buffer == NULL) {

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

   672 	    exit(1);

   673 	}

   674     }

   675 }

   676 

   677 static int buffer_empty(Buffer *buffer)

   678 {

   679     return buffer->offset == 0;

   680 }

   681 

   682 static uint8_t *buffer_end(Buffer *buffer)

   683 {

   684     return buffer->buffer + buffer->offset;

   685 }

   686 

   687 static void buffer_reset(Buffer *buffer)

   688 {

   689 	buffer->offset = 0;

   690 }

   691 

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

   693 {

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

   695     buffer->offset += len;

   696 }

   697 

   698 /* audio */

   699 static void audio_capture_notify(void *opaque, audcnotification_e cmd)

   700 {

   701     VncState *vs = opaque;

   702 

   703     switch (cmd) {

   704     case AUD_CNOTIFY_DISABLE:

   705         vnc_write_u8(vs, 255);

   706         vnc_write_u8(vs, 1);

   707         vnc_write_u16(vs, 0);

   708         vnc_flush(vs);

   709         break;

   710 

   711     case AUD_CNOTIFY_ENABLE:

   712         vnc_write_u8(vs, 255);

   713         vnc_write_u8(vs, 1);

   714         vnc_write_u16(vs, 1);

   715         vnc_flush(vs);

   716         break;

   717     }

   718 }

   719 

   720 static void audio_capture_destroy(void *opaque)

   721 {

   722 }

   723 

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

   725 {

   726     VncState *vs = opaque;

   727 

   728     vnc_write_u8(vs, 255);

   729     vnc_write_u8(vs, 1);

   730     vnc_write_u16(vs, 2);

   731     vnc_write_u32(vs, size);

   732     vnc_write(vs, buf, size);

   733     vnc_flush(vs);

   734 }

   735 

   736 static void audio_add(VncState *vs)

   737 {

   738     struct audio_capture_ops ops;

   739 

   740     if (vs->audio_cap) {

   741         term_printf ("audio already running\n");

   742         return;

   743     }

   744 

   745     ops.notify = audio_capture_notify;

   746     ops.destroy = audio_capture_destroy;

   747     ops.capture = audio_capture;

   748 

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

   750     if (!vs->audio_cap) {

   751         term_printf ("Failed to add audio capture\n");

   752     }

   753 }

   754 

   755 static void audio_del(VncState *vs)

   756 {

   757     if (vs->audio_cap) {

   758         AUD_del_capture(vs->audio_cap, vs);

   759         vs->audio_cap = NULL;

   760     }

   761 }

   762 

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

   764 {

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

   766         if (ret == -1) {

   767             switch (last_errno) {

   768                 case EINTR:

   769                 case EAGAIN:

   770 #ifdef _WIN32

   771                 case WSAEWOULDBLOCK:

   772 #endif

   773                     return 0;

   774                 default:

   775                     break;

   776             }

   777         }

   778 

   779 	VNC_DEBUG("Closing down client sock %d %d\n", ret, ret < 0 ? last_errno : 0);

   780 	qemu_set_fd_handler2(vs->csock, NULL, NULL, NULL, NULL);

   781 	closesocket(vs->csock);

   782 	vs->csock = -1;

   783     gui_notify_idle(1);

   784 	/*vs->ds->idle = 1;*/

   785 	buffer_reset(&vs->input);

   786 	buffer_reset(&vs->output);

   787 	vs->need_update = 0;

   788 #ifdef CONFIG_VNC_TLS

   789 	if (vs->tls_session) {

   790 	    gnutls_deinit(vs->tls_session);

   791 	    vs->tls_session = NULL;

   792 	}

   793 	vs->wiremode = VNC_WIREMODE_CLEAR;

   794 #endif /* CONFIG_VNC_TLS */

   795         audio_del(vs);

   796 	return 0;

   797     }

   798     return ret;

   799 }

   800 

   801 static void vnc_client_error(VncState *vs)

   802 {

   803     vnc_client_io_error(vs, -1, EINVAL);

   804 }

   805 

   806 static void vnc_client_write(void *opaque)

   807 {

   808     long ret;

   809     VncState *vs = opaque;

   810 

   811 #ifdef CONFIG_VNC_TLS

   812     if (vs->tls_session) {

   813 	ret = gnutls_write(vs->tls_session, vs->output.buffer, vs->output.offset);

   814 	if (ret < 0) {

   815 	    if (ret == GNUTLS_E_AGAIN)

   816 		errno = EAGAIN;

   817 	    else

   818 		errno = EIO;

   819 	    ret = -1;

   820 	}

   821     } else

   822 #endif /* CONFIG_VNC_TLS */

   823 	ret = send(vs->csock, vs->output.buffer, vs->output.offset, 0);

   824     ret = vnc_client_io_error(vs, ret, socket_error());

   825     if (!ret)

   826 	return;

   827 

   828     memmove(vs->output.buffer, vs->output.buffer + ret, (vs->output.offset - ret));

   829     vs->output.offset -= ret;

   830 

   831     if (vs->output.offset == 0) {

   832 	qemu_set_fd_handler2(vs->csock, NULL, vnc_client_read, NULL, vs);

   833     }

   834 }

   835 

   836 static void vnc_read_when(VncState *vs, VncReadEvent *func, size_t expecting)

   837 {

   838     vs->read_handler = func;

   839     vs->read_handler_expect = expecting;

   840 }

   841 

   842 static void vnc_client_read(void *opaque)

   843 {

   844     VncState *vs = opaque;

   845     long ret;

   846 

   847     buffer_reserve(&vs->input, 4096);

   848 

   849 #ifdef CONFIG_VNC_TLS

   850     if (vs->tls_session) {

   851 	ret = gnutls_read(vs->tls_session, buffer_end(&vs->input), 4096);

   852 	if (ret < 0) {

   853 	    if (ret == GNUTLS_E_AGAIN)

   854 		errno = EAGAIN;

   855 	    else

   856 		errno = EIO;

   857 	    ret = -1;

   858 	}

   859     } else

   860 #endif /* CONFIG_VNC_TLS */

   861 	ret = recv(vs->csock, buffer_end(&vs->input), 4096, 0);

   862     ret = vnc_client_io_error(vs, ret, socket_error());

   863     if (!ret)

   864 	return;

   865 

   866     vs->input.offset += ret;

   867 

   868     while (vs->read_handler && vs->input.offset >= vs->read_handler_expect) {

   869 	size_t len = vs->read_handler_expect;

   870 	int ret;

   871 

   872 	ret = vs->read_handler(vs, vs->input.buffer, len);

   873 	if (vs->csock == -1)

   874 	    return;

   875 

   876 	if (!ret) {

   877 	    memmove(vs->input.buffer, vs->input.buffer + len, (vs->input.offset - len));

   878 	    vs->input.offset -= len;

   879 	} else {

   880 	    vs->read_handler_expect = ret;

   881 	}

   882     }

   883 }

   884 

   885 static void vnc_write(VncState *vs, const void *data, size_t len)

   886 {

   887     buffer_reserve(&vs->output, len);

   888 

   889     if (buffer_empty(&vs->output)) {

   890 	qemu_set_fd_handler2(vs->csock, NULL, vnc_client_read, vnc_client_write, vs);

   891     }

   892 

   893     buffer_append(&vs->output, data, len);

   894 }

   895 

   896 static void vnc_write_s32(VncState *vs, int32_t value)

   897 {

   898     vnc_write_u32(vs, *(uint32_t *)&value);

   899 }

   900 

   901 static void vnc_write_u32(VncState *vs, uint32_t value)

   902 {

   903     uint8_t buf[4];

   904 

   905     buf[0] = (value >> 24) & 0xFF;

   906     buf[1] = (value >> 16) & 0xFF;

   907     buf[2] = (value >>  8) & 0xFF;

   908     buf[3] = value & 0xFF;

   909 

   910     vnc_write(vs, buf, 4);

   911 }

   912 

   913 static void vnc_write_u16(VncState *vs, uint16_t value)

   914 {

   915     uint8_t buf[2];

   916 

   917     buf[0] = (value >> 8) & 0xFF;

   918     buf[1] = value & 0xFF;

   919 

   920     vnc_write(vs, buf, 2);

   921 }

   922 

   923 static void vnc_write_u8(VncState *vs, uint8_t value)

   924 {

   925     vnc_write(vs, (char *)&value, 1);

   926 }

   927 

   928 static void vnc_flush(VncState *vs)

   929 {

   930     if (vs->output.offset)

   931 	vnc_client_write(vs);

   932 }

   933 

   934 static uint8_t read_u8(uint8_t *data, size_t offset)

   935 {

   936     return data[offset];

   937 }

   938 

   939 static uint16_t read_u16(uint8_t *data, size_t offset)

   940 {

   941     return ((data[offset] & 0xFF) << 8) | (data[offset + 1] & 0xFF);

   942 }

   943 

   944 static int32_t read_s32(uint8_t *data, size_t offset)

   945 {

   946     return (int32_t)((data[offset] << 24) | (data[offset + 1] << 16) |

   947 		     (data[offset + 2] << 8) | data[offset + 3]);

   948 }

   949 

   950 static uint32_t read_u32(uint8_t *data, size_t offset)

   951 {

   952     return ((data[offset] << 24) | (data[offset + 1] << 16) |

   953 	    (data[offset + 2] << 8) | data[offset + 3]);

   954 }

   955 

   956 #ifdef CONFIG_VNC_TLS

   957 static ssize_t vnc_tls_push(gnutls_transport_ptr_t transport,

   958                             const void *data,

   959                             size_t len) {

   960     struct VncState *vs = (struct VncState *)transport;

   961     int ret;

   962 

   963  retry:

   964     ret = send(vs->csock, data, len, 0);

   965     if (ret < 0) {

   966 	if (errno == EINTR)

   967 	    goto retry;

   968 	return -1;

   969     }

   970     return ret;

   971 }

   972 

   973 

   974 static ssize_t vnc_tls_pull(gnutls_transport_ptr_t transport,

   975                             void *data,

   976                             size_t len) {

   977     struct VncState *vs = (struct VncState *)transport;

   978     int ret;

   979 

   980  retry:

   981     ret = recv(vs->csock, data, len, 0);

   982     if (ret < 0) {

   983 	if (errno == EINTR)

   984 	    goto retry;

   985 	return -1;

   986     }

   987     return ret;

   988 }

   989 #endif /* CONFIG_VNC_TLS */

   990 

   991 static void client_cut_text(VncState *vs, size_t len, uint8_t *text)

   992 {

   993 }

   994 

   995 static void check_pointer_type_change(VncState *vs, int absolute)

   996 {

   997     if (vs->has_pointer_type_change && vs->absolute != absolute) {

   998 	vnc_write_u8(vs, 0);

   999 	vnc_write_u8(vs, 0);

  1000 	vnc_write_u16(vs, 1);

  1001 	vnc_framebuffer_update(vs, absolute, 0,

  1002 			       ds_get_width(vs->ds), ds_get_height(vs->ds), -257);

  1003 	vnc_flush(vs);

  1004     }

  1005     vs->absolute = absolute;

  1006 }

  1007 

  1008 static void pointer_event(VncState *vs, int button_mask, int x, int y)

  1009 {

  1010     int buttons = 0;

  1011     int dz = 0;

  1012 

  1013     if (button_mask & 0x01)

  1014 	buttons |= MOUSE_EVENT_LBUTTON;

  1015     if (button_mask & 0x02)

  1016 	buttons |= MOUSE_EVENT_MBUTTON;

  1017     if (button_mask & 0x04)

  1018 	buttons |= MOUSE_EVENT_RBUTTON;

  1019     if (button_mask & 0x08)

  1020 	dz = -1;

  1021     if (button_mask & 0x10)

  1022 	dz = 1;

  1023 

  1024     if (vs->absolute) {

  1025 	kbd_mouse_event(x * 0x7FFF / (ds_get_width(vs->ds) - 1),

  1026 			y * 0x7FFF / (ds_get_height(vs->ds) - 1),

  1027 			dz, buttons);

  1028     } else if (vs->has_pointer_type_change) {

  1029 	x -= 0x7FFF;

  1030 	y -= 0x7FFF;

  1031 

  1032 	kbd_mouse_event(x, y, dz, buttons);

  1033     } else {

  1034 	if (vs->last_x != -1)

  1035 	    kbd_mouse_event(x - vs->last_x,

  1036 			    y - vs->last_y,

  1037 			    dz, buttons);

  1038 	vs->last_x = x;

  1039 	vs->last_y = y;

  1040     }

  1041 

  1042     check_pointer_type_change(vs, kbd_mouse_is_absolute());

  1043 }

  1044 

  1045 static void reset_keys(VncState *vs)

  1046 {

  1047     int i;

  1048     for(i = 0; i < 256; i++) {

  1049         if (vs->modifiers_state[i]) {

  1050             if (i & 0x80)

  1051                 kbd_put_keycode(0xe0);

  1052             kbd_put_keycode(i | 0x80);

  1053             vs->modifiers_state[i] = 0;

  1054         }

  1055     }

  1056 }

  1057 

  1058 static void press_key(VncState *vs, int keysym)

  1059 {

  1060     kbd_put_keycode(keysym2scancode(vs->kbd_layout, keysym) & 0x7f);

  1061     kbd_put_keycode(keysym2scancode(vs->kbd_layout, keysym) | 0x80);

  1062 }

  1063 

  1064 static void do_key_event(VncState *vs, int down, int keycode, int sym)

  1065 {

  1066     /* QEMU console switch */

  1067     switch(keycode) {

  1068     case 0x2a:                          /* Left Shift */

  1069     case 0x36:                          /* Right Shift */

  1070     case 0x1d:                          /* Left CTRL */

  1071     case 0x9d:                          /* Right CTRL */

  1072     case 0x38:                          /* Left ALT */

  1073     case 0xb8:                          /* Right ALT */

  1074         if (down)

  1075             vs->modifiers_state[keycode] = 1;

  1076         else

  1077             vs->modifiers_state[keycode] = 0;

  1078         break;

  1079     case 0x02 ... 0x0a: /* '1' to '9' keys */

  1080         if (down && vs->modifiers_state[0x1d] && vs->modifiers_state[0x38]) {

  1081             /* Reset the modifiers sent to the current console */

  1082             reset_keys(vs);

  1083             gui_notify_console_select(keycode - 0x02);

  1084             return;

  1085         }

  1086         break;

  1087     case 0x3a:			/* CapsLock */

  1088     case 0x45:			/* NumLock */

  1089         if (!down)

  1090             vs->modifiers_state[keycode] ^= 1;

  1091         break;

  1092     }

  1093 

  1094     if (keycode_is_keypad(vs->kbd_layout, keycode)) {

  1095         /* If the numlock state needs to change then simulate an additional

  1096            keypress before sending this one.  This will happen if the user

  1097            toggles numlock away from the VNC window.

  1098         */

  1099         if (keysym_is_numlock(vs->kbd_layout, sym & 0xFFFF)) {

  1100             if (!vs->modifiers_state[0x45]) {

  1101                 vs->modifiers_state[0x45] = 1;

  1102                 press_key(vs, 0xff7f);

  1103             }

  1104         } else {

  1105             if (vs->modifiers_state[0x45]) {

  1106                 vs->modifiers_state[0x45] = 0;

  1107                 press_key(vs, 0xff7f);

  1108             }

  1109         }

  1110     }

  1111 

  1112     if (/*gui_is_graphic_console() DFG TODO */ !kbd_in_terminal_mode) {

  1113         if (keycode & 0x80)

  1114             kbd_put_keycode(0xe0);

  1115         if (down)

  1116             kbd_put_keycode(keycode & 0x7f);

  1117         else

  1118             kbd_put_keycode(keycode | 0x80);

  1119     } else {

  1120         /* QEMU console emulation */

  1121         if (down) {

  1122             switch (keycode) {

  1123             case 0x2a:                          /* Left Shift */

  1124             case 0x36:                          /* Right Shift */

  1125             case 0x1d:                          /* Left CTRL */

  1126             case 0x9d:                          /* Right CTRL */

  1127             case 0x38:                          /* Left ALT */

  1128             case 0xb8:                          /* Right ALT */

  1129                 break;

  1130             case 0xc8:

  1131                 gui_notify_term_key(QEMU_KEY_UP);

  1132                 break;

  1133             case 0xd0:

  1134                 gui_notify_term_key(QEMU_KEY_DOWN);

  1135                 break;