david.venhoff/QEMU-Nyx-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ui: vnc cleanups, input-linux kbd fix.

Browse Source 
-----BEGIN PGP SIGNATURE-----
 Version: GnuPG v2.0.22 (GNU/Linux)
 
 iQIcBAABAgAGBQJX/0ovAAoJEEy22O7T6HE4iA0P/1hkEtjA1kuF2cOc8TrLouPQ
 QZSWK3GK0ZqlHkzW22FPqhH7uAOyvcvqdKAzfgWoIK4kDbAJtaUfV57OFB2hmXB+
 +tE+bhqZ8n0IiZbtvwMEoucrYTjlo/rtfdMB/TWUXkWAxgNNjLSqATq/oycQYDZn
 fLnZxPPSdAR1eNSB/Gwzh3Fthq2ejmVwPrS5X1F5LzS9q2l3buVhS2H1WxVllZiU
 j35gtHG5tBRrjwgNTEJwNkilPgKTrGXx8iQJhUQIrbjKNG72+8pgIPftqzyECj3M
 bCqBX8+A+WPkUBxNWcvhEhxn4xBUb+S7OlixXNOuTpMhex0LT8UGaH6sWVtOUs1j
 aZjUEBikSXHP/TvuRbWs1zEW2Gd6x/5Neu/By48WAag91qKpPMDF3Q7pQJO0H+sW
 Nlefu4Jh0PxWaugh7cRvb28lkb0fVb540/R3LiYXb49vjnUaFZGEqB2SGBcV3KeH
 oQHU6Ym2CWfBNeKbRuDigpqxHUQnia6+2p/UbkwwrRaNCM82VFTGG5dnpLfAvgYr
 ssNCRGipBclgr7QhkxU3TQj+1zMrCXkjJMT76c9QaxoulR7dDggrw9jsJH7AQYqN
 kBVWIZ6zzFwb4N2Hn9WZFZyXyeEvjVjl3OYN3I/QnW1wUseX/3V/xmIB8JzFffJ1
 8XnTi3GEo8FqcxAlvBZc
 =+E7A
 -----END PGP SIGNATURE-----

Merge remote-tracking branch 'remotes/kraxel/tags/pull-ui-20161013-1' into staging

ui: vnc cleanups, input-linux kbd fix.

# gpg: Signature made Thu 13 Oct 2016 09:47:43 BST
# gpg:                using RSA key 0x4CB6D8EED3E87138
# gpg: Good signature from "Gerd Hoffmann (work) <kraxel@redhat.com>"
# gpg:                 aka "Gerd Hoffmann <gerd@kraxel.org>"
# gpg:                 aka "Gerd Hoffmann (private) <kraxel@gmail.com>"
# Primary key fingerprint: A032 8CFF B93A 17A7 9901  FE7D 4CB6 D8EE D3E8 7138

* remotes/kraxel/tags/pull-ui-20161013-1:
  input-linux: initialize key state
  ui: rename vnc_init_state to vnc_start_protocol
  ui: move some initialization out of vnc_init_state
  ui: remove bogus call to reset_keys() in vnc_init_state
  ui: remove bogus call to graphic_hw_update() in vnc_listen_io
  ui: refactor method for setting up VncDisplay auth types
  ui: rename misleading 'VncDisplay' variables
  ui: remove 'ws_tls' field from VncState
  ui: remove 'enabled' and 'ws_enabled' fields from VncState
  ui: remove misleading comment from vnc_init_state

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
This commit is contained in:
Peter Maydell 2016-10-13 14:27:58 +01:00
commit 6aa5a36794
4 changed files with 207 additions and 237 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
ui/input-linux.c
View File

@ -347,7 +347,8 @@ static void input_linux_event(void *opaque)
static void input_linux_complete(UserCreatable *uc, Error **errp) static void input_linux_complete(UserCreatable *uc, Error **errp)
{ {
InputLinux *il = INPUT_LINUX(uc); InputLinux *il = INPUT_LINUX(uc);
uint8_t evtmap, relmap, absmap, keymap[KEY_CNT / 8]; uint8_t evtmap, relmap, absmap;
uint8_t keymap[KEY_CNT / 8], keystate[KEY_CNT / 8];
unsigned int i; unsigned int i;
int rc, ver; int rc, ver;
@ -394,6 +395,7 @@ static void input_linux_complete(UserCreatable *uc, Error **errp)
if (evtmap & (1 << EV_KEY)) { if (evtmap & (1 << EV_KEY)) {
memset(keymap, 0, sizeof(keymap)); memset(keymap, 0, sizeof(keymap));
rc = ioctl(il->fd, EVIOCGBIT(EV_KEY, sizeof(keymap)), keymap); rc = ioctl(il->fd, EVIOCGBIT(EV_KEY, sizeof(keymap)), keymap);
rc = ioctl(il->fd, EVIOCGKEY(sizeof(keystate)), keystate);
for (i = 0; i < KEY_CNT; i++) { for (i = 0; i < KEY_CNT; i++) {
if (keymap[i / 8] & (1 << (i % 8))) { if (keymap[i / 8] & (1 << (i % 8))) {
if (linux_is_button(i)) { if (linux_is_button(i)) {
@ -401,12 +403,21 @@ static void input_linux_complete(UserCreatable *uc, Error **errp)
} else { } else {
il->num_keys++; il->num_keys++;
} }
if (keystate[i / 8] & (1 << (i % 8))) {
il->keydown[i] = true;
il->keycount++;
}
} }
} }
} }
qemu_set_fd_handler(il->fd, input_linux_event, NULL, il); qemu_set_fd_handler(il->fd, input_linux_event, NULL, il);
if (il->keycount) {
/* delay grab until all keys are released */
il->grab_request = true;
} else {
input_linux_toggle_grab(il); input_linux_toggle_grab(il);
}
QTAILQ_INSERT_TAIL(&inputs, il, next); QTAILQ_INSERT_TAIL(&inputs, il, next);
il->initialized = true; il->initialized = true;
return; return;

2
ui/vnc-ws.c
View File

@ -92,7 +92,7 @@ static void vncws_handshake_done(Object *source,
vnc_client_error(vs); vnc_client_error(vs);
} else { } else {
VNC_DEBUG("Websock handshake complete, starting VNC protocol\n"); VNC_DEBUG("Websock handshake complete, starting VNC protocol\n");
vnc_init_state(vs); vnc_start_protocol(vs);
vs->ioc_tag = qio_channel_add_watch( vs->ioc_tag = qio_channel_add_watch(
vs->ioc, G_IO_IN, vnc_client_io, vs, NULL); vs->ioc, G_IO_IN, vnc_client_io, vs, NULL);
} }

410
ui/vnc.c
View File

@ -371,7 +371,7 @@ VncInfo *qmp_query_vnc(Error **errp)
VncDisplay *vd = vnc_display_find(NULL); VncDisplay *vd = vnc_display_find(NULL);
SocketAddress *addr = NULL; SocketAddress *addr = NULL;
if (vd == NULL || !vd->enabled) { if (vd == NULL || !vd->lsock) {
info->enabled = false; info->enabled = false;
} else { } else {
info->enabled = true; info->enabled = true;
@ -1222,14 +1222,14 @@ void vnc_disconnect_finish(VncState *vs)
audio_del(vs); audio_del(vs);
vnc_release_modifiers(vs); vnc_release_modifiers(vs);
if (vs->initialized) { if (vs->mouse_mode_notifier.notify != NULL) {
QTAILQ_REMOVE(&vs->vd->clients, vs, next);
qemu_remove_mouse_mode_change_notifier(&vs->mouse_mode_notifier); qemu_remove_mouse_mode_change_notifier(&vs->mouse_mode_notifier);
}
QTAILQ_REMOVE(&vs->vd->clients, vs, next);
if (QTAILQ_EMPTY(&vs->vd->clients)) { if (QTAILQ_EMPTY(&vs->vd->clients)) {
/* last client gone */ /* last client gone */
vnc_update_server_surface(vs->vd); vnc_update_server_surface(vs->vd);
} }
}
if (vs->vd->lock_key_sync) if (vs->vd->lock_key_sync)
qemu_remove_led_event_handler(vs->led); qemu_remove_led_event_handler(vs->led);
@ -2978,6 +2978,7 @@ static void vnc_connect(VncDisplay *vd, QIOChannelSocket *sioc,
bool skipauth, bool websocket) bool skipauth, bool websocket)
{ {
VncState *vs = g_new0(VncState, 1); VncState *vs = g_new0(VncState, 1);
bool first_client = QTAILQ_EMPTY(&vd->clients);
int i; int i;
vs->sioc = sioc; vs->sioc = sioc;
@ -3029,7 +3030,7 @@ static void vnc_connect(VncDisplay *vd, QIOChannelSocket *sioc,
qio_channel_set_blocking(vs->ioc, false, NULL); qio_channel_set_blocking(vs->ioc, false, NULL);
if (websocket) { if (websocket) {
vs->websocket = 1; vs->websocket = 1;
if (vd->ws_tls) { if (vd->tlscreds) {
vs->ioc_tag = qio_channel_add_watch( vs->ioc_tag = qio_channel_add_watch(
vs->ioc, G_IO_IN, vncws_tls_handshake_io, vs, NULL); vs->ioc, G_IO_IN, vncws_tls_handshake_io, vs, NULL);
} else { } else {
@ -3045,26 +3046,6 @@ static void vnc_connect(VncDisplay *vd, QIOChannelSocket *sioc,
vnc_qmp_event(vs, QAPI_EVENT_VNC_CONNECTED); vnc_qmp_event(vs, QAPI_EVENT_VNC_CONNECTED);
vnc_set_share_mode(vs, VNC_SHARE_MODE_CONNECTING); vnc_set_share_mode(vs, VNC_SHARE_MODE_CONNECTING);
if (!vs->websocket) {
vnc_init_state(vs);
}
if (vd->num_connecting > vd->connections_limit) {
QTAILQ_FOREACH(vs, &vd->clients, next) {
if (vs->share_mode == VNC_SHARE_MODE_CONNECTING) {
vnc_disconnect_start(vs);
return;
}
}
}
}
void vnc_init_state(VncState *vs)
{
vs->initialized = true;
VncDisplay *vd = vs->vd;
bool first_client = QTAILQ_EMPTY(&vd->clients);
vs->last_x = -1; vs->last_x = -1;
vs->last_y = -1; vs->last_y = -1;
@ -3083,34 +3064,45 @@ void vnc_init_state(VncState *vs)
graphic_hw_update(vd->dcl.con); graphic_hw_update(vd->dcl.con);
if (!vs->websocket) {
vnc_start_protocol(vs);
}
if (vd->num_connecting > vd->connections_limit) {
QTAILQ_FOREACH(vs, &vd->clients, next) {
if (vs->share_mode == VNC_SHARE_MODE_CONNECTING) {
vnc_disconnect_start(vs);
return;
}
}
}
}
void vnc_start_protocol(VncState *vs)
{
vnc_write(vs, "RFB 003.008\n", 12); vnc_write(vs, "RFB 003.008\n", 12);
vnc_flush(vs); vnc_flush(vs);
vnc_read_when(vs, protocol_version, 12); vnc_read_when(vs, protocol_version, 12);
reset_keys(vs);
if (vs->vd->lock_key_sync) if (vs->vd->lock_key_sync)
vs->led = qemu_add_led_event_handler(kbd_leds, vs); vs->led = qemu_add_led_event_handler(kbd_leds, vs);
vs->mouse_mode_notifier.notify = check_pointer_type_change; vs->mouse_mode_notifier.notify = check_pointer_type_change;
qemu_add_mouse_mode_change_notifier(&vs->mouse_mode_notifier); qemu_add_mouse_mode_change_notifier(&vs->mouse_mode_notifier);
/* vs might be free()ed here */
} }
static gboolean vnc_listen_io(QIOChannel *ioc, static gboolean vnc_listen_io(QIOChannel *ioc,
GIOCondition condition, GIOCondition condition,
void *opaque) void *opaque)
{ {
VncDisplay *vs = opaque; VncDisplay *vd = opaque;
QIOChannelSocket *sioc = NULL; QIOChannelSocket *sioc = NULL;
Error *err = NULL; Error *err = NULL;
/* Catch-up */
graphic_hw_update(vs->dcl.con);
sioc = qio_channel_socket_accept(QIO_CHANNEL_SOCKET(ioc), &err); sioc = qio_channel_socket_accept(QIO_CHANNEL_SOCKET(ioc), &err);
if (sioc != NULL) { if (sioc != NULL) {
qio_channel_set_delay(QIO_CHANNEL(sioc), false); qio_channel_set_delay(QIO_CHANNEL(sioc), false);
vnc_connect(vs, sioc, false, vnc_connect(vd, sioc, false,
ioc != QIO_CHANNEL(vs->lsock)); ioc != QIO_CHANNEL(vd->lsock));
object_unref(OBJECT(sioc)); object_unref(OBJECT(sioc));
} else { } else {
/* client probably closed connection before we got there */ /* client probably closed connection before we got there */
@ -3133,108 +3125,108 @@ static const DisplayChangeListenerOps dcl_ops = {
void vnc_display_init(const char *id) void vnc_display_init(const char *id)
{ {
VncDisplay *vs; VncDisplay *vd;
if (vnc_display_find(id) != NULL) { if (vnc_display_find(id) != NULL) {
return; return;
} }
vs = g_malloc0(sizeof(*vs)); vd = g_malloc0(sizeof(*vd));
vs->id = strdup(id); vd->id = strdup(id);
QTAILQ_INSERT_TAIL(&vnc_displays, vs, next); QTAILQ_INSERT_TAIL(&vnc_displays, vd, next);
QTAILQ_INIT(&vs->clients); QTAILQ_INIT(&vd->clients);
vs->expires = TIME_MAX; vd->expires = TIME_MAX;
if (keyboard_layout) { if (keyboard_layout) {
trace_vnc_key_map_init(keyboard_layout); trace_vnc_key_map_init(keyboard_layout);
vs->kbd_layout = init_keyboard_layout(name2keysym, keyboard_layout); vd->kbd_layout = init_keyboard_layout(name2keysym, keyboard_layout);
} else { } else {
vs->kbd_layout = init_keyboard_layout(name2keysym, "en-us"); vd->kbd_layout = init_keyboard_layout(name2keysym, "en-us");
} }
if (!vs->kbd_layout) if (!vd->kbd_layout) {
exit(1); exit(1);
}
vs->share_policy = VNC_SHARE_POLICY_ALLOW_EXCLUSIVE; vd->share_policy = VNC_SHARE_POLICY_ALLOW_EXCLUSIVE;
vs->connections_limit = 32; vd->connections_limit = 32;
qemu_mutex_init(&vs->mutex); qemu_mutex_init(&vd->mutex);
vnc_start_worker_thread(); vnc_start_worker_thread();
vs->dcl.ops = &dcl_ops; vd->dcl.ops = &dcl_ops;
register_displaychangelistener(&vs->dcl); register_displaychangelistener(&vd->dcl);
} }
static void vnc_display_close(VncDisplay *vs) static void vnc_display_close(VncDisplay *vd)
{ {
if (!vs) if (!vd) {
return; return;
vs->enabled = false;
vs->is_unix = false;
if (vs->lsock != NULL) {
if (vs->lsock_tag) {
g_source_remove(vs->lsock_tag);
} }
object_unref(OBJECT(vs->lsock)); vd->is_unix = false;
vs->lsock = NULL; if (vd->lsock != NULL) {
if (vd->lsock_tag) {
g_source_remove(vd->lsock_tag);
} }
vs->ws_enabled = false; object_unref(OBJECT(vd->lsock));
if (vs->lwebsock != NULL) { vd->lsock = NULL;
if (vs->lwebsock_tag) {
g_source_remove(vs->lwebsock_tag);
} }
object_unref(OBJECT(vs->lwebsock)); if (vd->lwebsock != NULL) {
vs->lwebsock = NULL; if (vd->lwebsock_tag) {
g_source_remove(vd->lwebsock_tag);
} }
vs->auth = VNC_AUTH_INVALID; object_unref(OBJECT(vd->lwebsock));
vs->subauth = VNC_AUTH_INVALID; vd->lwebsock = NULL;
if (vs->tlscreds) {
object_unparent(OBJECT(vs->tlscreds));
vs->tlscreds = NULL;
} }
g_free(vs->tlsaclname); vd->auth = VNC_AUTH_INVALID;
vs->tlsaclname = NULL; vd->subauth = VNC_AUTH_INVALID;
if (vd->tlscreds) {
object_unparent(OBJECT(vd->tlscreds));
vd->tlscreds = NULL;
}
g_free(vd->tlsaclname);
vd->tlsaclname = NULL;
} }
int vnc_display_password(const char *id, const char *password) int vnc_display_password(const char *id, const char *password)
{ {
VncDisplay *vs = vnc_display_find(id); VncDisplay *vd = vnc_display_find(id);
if (!vs) { if (!vd) {
return -EINVAL; return -EINVAL;
} }
if (vs->auth == VNC_AUTH_NONE) { if (vd->auth == VNC_AUTH_NONE) {
error_printf_unless_qmp("If you want use passwords please enable " error_printf_unless_qmp("If you want use passwords please enable "
"password auth using '-vnc ${dpy},password'.\n"); "password auth using '-vnc ${dpy},password'.\n");
return -EINVAL; return -EINVAL;
} }
g_free(vs->password); g_free(vd->password);
vs->password = g_strdup(password); vd->password = g_strdup(password);
return 0; return 0;
} }
int vnc_display_pw_expire(const char *id, time_t expires) int vnc_display_pw_expire(const char *id, time_t expires)
{ {
VncDisplay *vs = vnc_display_find(id); VncDisplay *vd = vnc_display_find(id);
if (!vs) { if (!vd) {
return -EINVAL; return -EINVAL;
} }
vs->expires = expires; vd->expires = expires;
return 0; return 0;
} }
static void vnc_display_print_local_addr(VncDisplay *vs) static void vnc_display_print_local_addr(VncDisplay *vd)
{ {
SocketAddress *addr; SocketAddress *addr;
Error *err = NULL; Error *err = NULL;
addr = qio_channel_socket_get_local_address(vs->lsock, &err); addr = qio_channel_socket_get_local_address(vd->lsock, &err);
if (!addr) { if (!addr) {
return; return;
} }
@ -3327,7 +3319,9 @@ static QemuOptsList qemu_vnc_opts = {
static int static int
vnc_display_setup_auth(VncDisplay *vs, vnc_display_setup_auth(int *auth,
int *subauth,
QCryptoTLSCreds *tlscreds,
bool password, bool password,
bool sasl, bool sasl,
bool websocket, bool websocket,
@ -3380,95 +3374,56 @@ vnc_display_setup_auth(VncDisplay *vs,
* VNC auth mechs for plain VNC vs websockets VNC, the end * VNC auth mechs for plain VNC vs websockets VNC, the end
* result has the same security characteristics. * result has the same security characteristics.
*/ */
if (websocket || !tlscreds) {
if (password) { if (password) {
if (vs->tlscreds) {
vs->auth = VNC_AUTH_VENCRYPT;
if (websocket) {
vs->ws_tls = true;
}
if (object_dynamic_cast(OBJECT(vs->tlscreds),
TYPE_QCRYPTO_TLS_CREDS_X509)) {
VNC_DEBUG("Initializing VNC server with x509 password auth\n");
vs->subauth = VNC_AUTH_VENCRYPT_X509VNC;
} else if (object_dynamic_cast(OBJECT(vs->tlscreds),
TYPE_QCRYPTO_TLS_CREDS_ANON)) {
VNC_DEBUG("Initializing VNC server with TLS password auth\n");
vs->subauth = VNC_AUTH_VENCRYPT_TLSVNC;
} else {
error_setg(errp,
"Unsupported TLS cred type %s",
object_get_typename(OBJECT(vs->tlscreds)));
return -1;
}
} else {
VNC_DEBUG("Initializing VNC server with password auth\n"); VNC_DEBUG("Initializing VNC server with password auth\n");
vs->auth = VNC_AUTH_VNC; *auth = VNC_AUTH_VNC;
vs->subauth = VNC_AUTH_INVALID;
}
if (websocket) {
vs->ws_auth = VNC_AUTH_VNC;
} else {
vs->ws_auth = VNC_AUTH_INVALID;
}
} else if (sasl) { } else if (sasl) {
if (vs->tlscreds) {
vs->auth = VNC_AUTH_VENCRYPT;
if (websocket) {
vs->ws_tls = true;
}
if (object_dynamic_cast(OBJECT(vs->tlscreds),
TYPE_QCRYPTO_TLS_CREDS_X509)) {
VNC_DEBUG("Initializing VNC server with x509 SASL auth\n");
vs->subauth = VNC_AUTH_VENCRYPT_X509SASL;
} else if (object_dynamic_cast(OBJECT(vs->tlscreds),
TYPE_QCRYPTO_TLS_CREDS_ANON)) {
VNC_DEBUG("Initializing VNC server with TLS SASL auth\n");
vs->subauth = VNC_AUTH_VENCRYPT_TLSSASL;
} else {
error_setg(errp,
"Unsupported TLS cred type %s",
object_get_typename(OBJECT(vs->tlscreds)));
return -1;
}
} else {
VNC_DEBUG("Initializing VNC server with SASL auth\n"); VNC_DEBUG("Initializing VNC server with SASL auth\n");
vs->auth = VNC_AUTH_SASL; *auth = VNC_AUTH_SASL;
vs->subauth = VNC_AUTH_INVALID;
}
if (websocket) {
vs->ws_auth = VNC_AUTH_SASL;
} else {
vs->ws_auth = VNC_AUTH_INVALID;
}
} else {
if (vs->tlscreds) {
vs->auth = VNC_AUTH_VENCRYPT;
if (websocket) {
vs->ws_tls = true;
}
if (object_dynamic_cast(OBJECT(vs->tlscreds),
TYPE_QCRYPTO_TLS_CREDS_X509)) {
VNC_DEBUG("Initializing VNC server with x509 no auth\n");
vs->subauth = VNC_AUTH_VENCRYPT_X509NONE;
} else if (object_dynamic_cast(OBJECT(vs->tlscreds),
TYPE_QCRYPTO_TLS_CREDS_ANON)) {
VNC_DEBUG("Initializing VNC server with TLS no auth\n");
vs->subauth = VNC_AUTH_VENCRYPT_TLSNONE;
} else {
error_setg(errp,
"Unsupported TLS cred type %s",
object_get_typename(OBJECT(vs->tlscreds)));
return -1;
}
} else { } else {
VNC_DEBUG("Initializing VNC server with no auth\n"); VNC_DEBUG("Initializing VNC server with no auth\n");
vs->auth = VNC_AUTH_NONE; *auth = VNC_AUTH_NONE;
vs->subauth = VNC_AUTH_INVALID;
} }
if (websocket) { *subauth = VNC_AUTH_INVALID;
vs->ws_auth = VNC_AUTH_NONE;
} else { } else {
vs->ws_auth = VNC_AUTH_INVALID; bool is_x509 = object_dynamic_cast(OBJECT(tlscreds),
TYPE_QCRYPTO_TLS_CREDS_X509) != NULL;
bool is_anon = object_dynamic_cast(OBJECT(tlscreds),
TYPE_QCRYPTO_TLS_CREDS_ANON) != NULL;
if (!is_x509 && !is_anon) {
error_setg(errp,
"Unsupported TLS cred type %s",
object_get_typename(OBJECT(tlscreds)));
return -1;
}
*auth = VNC_AUTH_VENCRYPT;
if (password) {
if (is_x509) {
VNC_DEBUG("Initializing VNC server with x509 password auth\n");
*subauth = VNC_AUTH_VENCRYPT_X509VNC;
} else {
VNC_DEBUG("Initializing VNC server with TLS password auth\n");
*subauth = VNC_AUTH_VENCRYPT_TLSVNC;
}
} else if (sasl) {
if (is_x509) {
VNC_DEBUG("Initializing VNC server with x509 SASL auth\n");
*subauth = VNC_AUTH_VENCRYPT_X509SASL;
} else {
VNC_DEBUG("Initializing VNC server with TLS SASL auth\n");
*subauth = VNC_AUTH_VENCRYPT_TLSSASL;
}
} else {
if (is_x509) {
VNC_DEBUG("Initializing VNC server with x509 no auth\n");
*subauth = VNC_AUTH_VENCRYPT_X509NONE;
} else {
VNC_DEBUG("Initializing VNC server with TLS no auth\n");
*subauth = VNC_AUTH_VENCRYPT_TLSNONE;
}
} }
} }
return 0; return 0;
@ -3522,7 +3477,7 @@ vnc_display_create_creds(bool x509,
void vnc_display_open(const char *id, Error **errp) void vnc_display_open(const char *id, Error **errp)
{ {
VncDisplay *vs = vnc_display_find(id); VncDisplay *vd = vnc_display_find(id);
QemuOpts *opts = qemu_opts_find(&qemu_vnc_opts, id); QemuOpts *opts = qemu_opts_find(&qemu_vnc_opts, id);
SocketAddress *saddr = NULL, *wsaddr = NULL; SocketAddress *saddr = NULL, *wsaddr = NULL;
const char *share, *device_id; const char *share, *device_id;
@ -3540,12 +3495,13 @@ void vnc_display_open(const char *id, Error **errp)
int acl = 0; int acl = 0;
int lock_key_sync = 1; int lock_key_sync = 1;
int key_delay_ms; int key_delay_ms;
bool ws_enabled = false;
if (!vs) { if (!vd) {
error_setg(errp, "VNC display not active"); error_setg(errp, "VNC display not active");
return; return;
} }
vnc_display_close(vs); vnc_display_close(vd);
if (!opts) { if (!opts) {
return; return;
@ -3575,7 +3531,7 @@ void vnc_display_open(const char *id, Error **errp)
} }
wsaddr = g_new0(SocketAddress, 1); wsaddr = g_new0(SocketAddress, 1);
vs->ws_enabled = true; ws_enabled = true;
} }
if (strncmp(vnc, "unix:", 5) == 0) { if (strncmp(vnc, "unix:", 5) == 0) {
@ -3583,7 +3539,7 @@ void vnc_display_open(const char *id, Error **errp)
saddr->u.q_unix.data = g_new0(UnixSocketAddress, 1); saddr->u.q_unix.data = g_new0(UnixSocketAddress, 1);
saddr->u.q_unix.data->path = g_strdup(vnc + 5); saddr->u.q_unix.data->path = g_strdup(vnc + 5);
if (vs->ws_enabled) { if (ws_enabled) {
error_setg(errp, "UNIX sockets not supported with websock"); error_setg(errp, "UNIX sockets not supported with websock");
goto fail; goto fail;
} }
@ -3619,7 +3575,7 @@ void vnc_display_open(const char *id, Error **errp)
inet->ipv6 = ipv6; inet->ipv6 = ipv6;
inet->has_ipv6 = has_ipv6; inet->has_ipv6 = has_ipv6;
if (vs->ws_enabled) { if (ws_enabled) {
wsaddr->type = SOCKET_ADDRESS_KIND_INET; wsaddr->type = SOCKET_ADDRESS_KIND_INET;
inet = wsaddr->u.inet.data = g_new0(InetSocketAddress, 1); inet = wsaddr->u.inet.data = g_new0(InetSocketAddress, 1);
inet->host = g_strdup(saddr->u.inet.data->host); inet->host = g_strdup(saddr->u.inet.data->host);
@ -3686,17 +3642,17 @@ void vnc_display_open(const char *id, Error **errp)
credid); credid);
goto fail; goto fail;
} }
vs->tlscreds = (QCryptoTLSCreds *) vd->tlscreds = (QCryptoTLSCreds *)
object_dynamic_cast(creds, object_dynamic_cast(creds,
TYPE_QCRYPTO_TLS_CREDS); TYPE_QCRYPTO_TLS_CREDS);
if (!vs->tlscreds) { if (!vd->tlscreds) {
error_setg(errp, "Object with id '%s' is not TLS credentials", error_setg(errp, "Object with id '%s' is not TLS credentials",
credid); credid);
goto fail; goto fail;
} }
object_ref(OBJECT(vs->tlscreds)); object_ref(OBJECT(vd->tlscreds));
if (vs->tlscreds->endpoint != QCRYPTO_TLS_CREDS_ENDPOINT_SERVER) { if (vd->tlscreds->endpoint != QCRYPTO_TLS_CREDS_ENDPOINT_SERVER) {
error_setg(errp, error_setg(errp,
"Expecting TLS credentials with a server endpoint"); "Expecting TLS credentials with a server endpoint");
goto fail; goto fail;
@ -3717,12 +3673,12 @@ void vnc_display_open(const char *id, Error **errp)
x509verify = true; x509verify = true;
} }
} }
vs->tlscreds = vnc_display_create_creds(x509, vd->tlscreds = vnc_display_create_creds(x509,
x509verify, x509verify,
path, path,
vs->id, vd->id,
errp); errp);
if (!vs->tlscreds) { if (!vd->tlscreds) {
goto fail; goto fail;
} }
} }
@ -3732,54 +3688,62 @@ void vnc_display_open(const char *id, Error **errp)
share = qemu_opt_get(opts, "share"); share = qemu_opt_get(opts, "share");
if (share) { if (share) {
if (strcmp(share, "ignore") == 0) { if (strcmp(share, "ignore") == 0) {
vs->share_policy = VNC_SHARE_POLICY_IGNORE; vd->share_policy = VNC_SHARE_POLICY_IGNORE;
} else if (strcmp(share, "allow-exclusive") == 0) { } else if (strcmp(share, "allow-exclusive") == 0) {
vs->share_policy = VNC_SHARE_POLICY_ALLOW_EXCLUSIVE; vd->share_policy = VNC_SHARE_POLICY_ALLOW_EXCLUSIVE;
} else if (strcmp(share, "force-shared") == 0) { } else if (strcmp(share, "force-shared") == 0) {
vs->share_policy = VNC_SHARE_POLICY_FORCE_SHARED; vd->share_policy = VNC_SHARE_POLICY_FORCE_SHARED;
} else { } else {
error_setg(errp, "unknown vnc share= option"); error_setg(errp, "unknown vnc share= option");
goto fail; goto fail;
} }
} else { } else {
vs->share_policy = VNC_SHARE_POLICY_ALLOW_EXCLUSIVE; vd->share_policy = VNC_SHARE_POLICY_ALLOW_EXCLUSIVE;
} }
vs->connections_limit = qemu_opt_get_number(opts, "connections", 32); vd->connections_limit = qemu_opt_get_number(opts, "connections", 32);
#ifdef CONFIG_VNC_JPEG #ifdef CONFIG_VNC_JPEG
vs->lossy = qemu_opt_get_bool(opts, "lossy", false); vd->lossy = qemu_opt_get_bool(opts, "lossy", false);
#endif #endif
vs->non_adaptive = qemu_opt_get_bool(opts, "non-adaptive", false); vd->non_adaptive = qemu_opt_get_bool(opts, "non-adaptive", false);
/* adaptive updates are only used with tight encoding and /* adaptive updates are only used with tight encoding and
* if lossy updates are enabled so we can disable all the * if lossy updates are enabled so we can disable all the
* calculations otherwise */ * calculations otherwise */
if (!vs->lossy) { if (!vd->lossy) {
vs->non_adaptive = true; vd->non_adaptive = true;
} }
if (acl) { if (acl) {
if (strcmp(vs->id, "default") == 0) { if (strcmp(vd->id, "default") == 0) {
vs->tlsaclname = g_strdup("vnc.x509dname"); vd->tlsaclname = g_strdup("vnc.x509dname");
} else { } else {
vs->tlsaclname = g_strdup_printf("vnc.%s.x509dname", vs->id); vd->tlsaclname = g_strdup_printf("vnc.%s.x509dname", vd->id);
} }
qemu_acl_init(vs->tlsaclname); qemu_acl_init(vd->tlsaclname);
} }
#ifdef CONFIG_VNC_SASL #ifdef CONFIG_VNC_SASL
if (acl && sasl) { if (acl && sasl) {
char *aclname; char *aclname;
if (strcmp(vs->id, "default") == 0) { if (strcmp(vd->id, "default") == 0) {
aclname = g_strdup("vnc.username"); aclname = g_strdup("vnc.username");
} else { } else {
aclname = g_strdup_printf("vnc.%s.username", vs->id); aclname = g_strdup_printf("vnc.%s.username", vd->id);
} }
vs->sasl.acl = qemu_acl_init(aclname); vd->sasl.acl = qemu_acl_init(aclname);
g_free(aclname); g_free(aclname);
} }
#endif #endif
if (vnc_display_setup_auth(vs, password, sasl, vs->ws_enabled, errp) < 0) { if (vnc_display_setup_auth(&vd->auth, &vd->subauth,
vd->tlscreds, password,
sasl, false, errp) < 0) {
goto fail;
}
if (vnc_display_setup_auth(&vd->ws_auth, &vd->ws_subauth,
vd->tlscreds, password,
sasl, true, errp) < 0) {
goto fail; goto fail;
} }
@ -3790,8 +3754,8 @@ void vnc_display_open(const char *id, Error **errp)
goto fail; goto fail;
} }
#endif #endif
vs->lock_key_sync = lock_key_sync; vd->lock_key_sync = lock_key_sync;
vs->key_delay_ms = key_delay_ms; vd->key_delay_ms = key_delay_ms;
device_id = qemu_opt_get(opts, "display"); device_id = qemu_opt_get(opts, "display");
if (device_id) { if (device_id) {
@ -3807,58 +3771,57 @@ void vnc_display_open(const char *id, Error **errp)
con = NULL; con = NULL;
} }
if (con != vs->dcl.con) { if (con != vd->dcl.con) {
unregister_displaychangelistener(&vs->dcl); unregister_displaychangelistener(&vd->dcl);
vs->dcl.con = con; vd->dcl.con = con;
register_displaychangelistener(&vs->dcl); register_displaychangelistener(&vd->dcl);
} }
if (reverse) { if (reverse) {
/* connect to viewer */ /* connect to viewer */
QIOChannelSocket *sioc = NULL; QIOChannelSocket *sioc = NULL;
vs->lsock = NULL; vd->lsock = NULL;
vs->lwebsock = NULL; vd->lwebsock = NULL;
if (vs->ws_enabled) { if (ws_enabled) {
error_setg(errp, "Cannot use websockets in reverse mode"); error_setg(errp, "Cannot use websockets in reverse mode");
goto fail; goto fail;
} }
vs->is_unix = saddr->type == SOCKET_ADDRESS_KIND_UNIX; vd->is_unix = saddr->type == SOCKET_ADDRESS_KIND_UNIX;
sioc = qio_channel_socket_new(); sioc = qio_channel_socket_new();
if (qio_channel_socket_connect_sync(sioc, saddr, errp) < 0) { if (qio_channel_socket_connect_sync(sioc, saddr, errp) < 0) {
goto fail; goto fail;
} }
vnc_connect(vs, sioc, false, false); vnc_connect(vd, sioc, false, false);
object_unref(OBJECT(sioc)); object_unref(OBJECT(sioc));
} else { } else {
vs->lsock = qio_channel_socket_new(); vd->lsock = qio_channel_socket_new();
if (qio_channel_socket_listen_sync(vs->lsock, saddr, errp) < 0) { if (qio_channel_socket_listen_sync(vd->lsock, saddr, errp) < 0) {
goto fail; goto fail;
} }
vs->is_unix = saddr->type == SOCKET_ADDRESS_KIND_UNIX; vd->is_unix = saddr->type == SOCKET_ADDRESS_KIND_UNIX;
vs->enabled = true;
if (vs->ws_enabled) { if (ws_enabled) {
vs->lwebsock = qio_channel_socket_new(); vd->lwebsock = qio_channel_socket_new();
if (qio_channel_socket_listen_sync(vs->lwebsock, if (qio_channel_socket_listen_sync(vd->lwebsock,
wsaddr, errp) < 0) { wsaddr, errp) < 0) {
object_unref(OBJECT(vs->lsock)); object_unref(OBJECT(vd->lsock));
vs->lsock = NULL; vd->lsock = NULL;
goto fail; goto fail;
} }
} }
vs->lsock_tag = qio_channel_add_watch( vd->lsock_tag = qio_channel_add_watch(
QIO_CHANNEL(vs->lsock), QIO_CHANNEL(vd->lsock),
G_IO_IN, vnc_listen_io, vs, NULL); G_IO_IN, vnc_listen_io, vd, NULL);
if (vs->ws_enabled) { if (ws_enabled) {
vs->lwebsock_tag = qio_channel_add_watch( vd->lwebsock_tag = qio_channel_add_watch(
QIO_CHANNEL(vs->lwebsock), QIO_CHANNEL(vd->lwebsock),
G_IO_IN, vnc_listen_io, vs, NULL); G_IO_IN, vnc_listen_io, vd, NULL);
} }
} }
if (show_vnc_port) { if (show_vnc_port) {
vnc_display_print_local_addr(vs); vnc_display_print_local_addr(vd);
} }
qapi_free_SocketAddress(saddr); qapi_free_SocketAddress(saddr);
@ -3868,22 +3831,21 @@ void vnc_display_open(const char *id, Error **errp)
fail: fail:
qapi_free_SocketAddress(saddr); qapi_free_SocketAddress(saddr);
qapi_free_SocketAddress(wsaddr); qapi_free_SocketAddress(wsaddr);
vs->enabled = false; ws_enabled = false;
vs->ws_enabled = false;
} }
void vnc_display_add_client(const char *id, int csock, bool skipauth) void vnc_display_add_client(const char *id, int csock, bool skipauth)
{ {
VncDisplay *vs = vnc_display_find(id); VncDisplay *vd = vnc_display_find(id);
QIOChannelSocket *sioc; QIOChannelSocket *sioc;
if (!vs) { if (!vd) {
return; return;
} }
sioc = qio_channel_socket_new_fd(csock, NULL); sioc = qio_channel_socket_new_fd(csock, NULL);
if (sioc) { if (sioc) {
vnc_connect(vs, sioc, skipauth, false); vnc_connect(vd, sioc, skipauth, false);
object_unref(OBJECT(sioc)); object_unref(OBJECT(sioc));
} }
} }

7
ui/vnc.h
View File

@ -150,7 +150,6 @@ struct VncDisplay
guint lsock_tag; guint lsock_tag;
QIOChannelSocket *lwebsock; QIOChannelSocket *lwebsock;
guint lwebsock_tag; guint lwebsock_tag;
bool ws_enabled;
DisplaySurface *ds; DisplaySurface *ds;
DisplayChangeListener dcl; DisplayChangeListener dcl;
kbd_layout_t *kbd_layout; kbd_layout_t *kbd_layout;
@ -167,14 +166,13 @@ struct VncDisplay
const char *id; const char *id;
QTAILQ_ENTRY(VncDisplay) next; QTAILQ_ENTRY(VncDisplay) next;
bool enabled;
bool is_unix; bool is_unix;
char *password; char *password;
time_t expires; time_t expires;
int auth; int auth;
int subauth; /* Used by VeNCrypt */ int subauth; /* Used by VeNCrypt */
int ws_auth; /* Used by websockets */ int ws_auth; /* Used by websockets */
bool ws_tls; /* Used by websockets */ int ws_subauth; /* Used by websockets */
bool lossy; bool lossy;
bool non_adaptive; bool non_adaptive;
QCryptoTLSCreds *tlscreds; QCryptoTLSCreds *tlscreds;
@ -309,7 +307,6 @@ struct VncState
QEMUPutLEDEntry *led; QEMUPutLEDEntry *led;
bool abort; bool abort;
bool initialized;
QemuMutex output_mutex; QemuMutex output_mutex;
QEMUBH *bh; QEMUBH *bh;
Buffer jobs_buffer; Buffer jobs_buffer;
@ -518,7 +515,7 @@ void vnc_write_u8(VncState *vs, uint8_t value);
void vnc_flush(VncState *vs); void vnc_flush(VncState *vs);
void vnc_read_when(VncState *vs, VncReadEvent *func, size_t expecting); void vnc_read_when(VncState *vs, VncReadEvent *func, size_t expecting);
void vnc_disconnect_finish(VncState *vs); void vnc_disconnect_finish(VncState *vs);
void vnc_init_state(VncState *vs); void vnc_start_protocol(VncState *vs);
/* Buffer I/O functions */ /* Buffer I/O functions */