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