ui: convert VNC server to use QIOChannelWebsock (d5f04223) · Commits · SUMMER2020 / students / proj-2021291

ui/vnc-ws.c

+26 −302

Original line number	Diff line number	Diff line
		@@ -19,10 +19,7 @@
		*/

		#include "vnc.h"
		#include "qemu/main-loop.h"
		#include "crypto/hash.h"

		static void vncws_handshake_read(VncState *vs);
		#include "io/channel-websock.h"

		static void vncws_tls_handshake_done(Object *source,
		Error *err,
		@@ -34,6 +31,7 @@ static void vncws_tls_handshake_done(Object *source,
		VNC_DEBUG("Handshake failed %s\n", error_get_pretty(err));
		vnc_client_error(vs);
		} else {
		VNC_DEBUG("TLS handshake complete, starting websocket handshake\n");
		vs->ioc_tag = qio_channel_add_watch(
		QIO_CHANNEL(vs->ioc), G_IO_IN, vncws_handshake_io, vs, NULL);
		}
		@@ -79,38 +77,21 @@ gboolean vncws_tls_handshake_io(QIOChannel *ioc G_GNUC_UNUSED,
		return TRUE;
		}

		static void vncws_handshake_read(VncState *vs)
		{
		uint8_t *handshake_end;
		long ret;
		/* Typical HTTP headers from novnc are 512 bytes, so limiting
		* total header size to 4096 is easily enough. */
		size_t want = 4096 - vs->ws_input.offset;
		buffer_reserve(&vs->ws_input, want);
		ret = vnc_client_read_buf(vs, buffer_end(&vs->ws_input), want);

		if (!ret) {
		if (vs->disconnecting) {
		vnc_disconnect_finish(vs);
		}
		return;
		}
		vs->ws_input.offset += ret;
		static void vncws_handshake_done(Object *source,
		Error *err,
		gpointer user_data)
		{
		VncState *vs = user_data;

		handshake_end = (uint8_t )g_strstr_len((char )vs->ws_input.buffer,
		vs->ws_input.offset, WS_HANDSHAKE_END);
		if (handshake_end) {
		if (vs->ioc_tag) {
		g_source_remove(vs->ioc_tag);
		}
		if (err) {
		VNC_DEBUG("Websock handshake failed %s\n", error_get_pretty(err));
		vnc_client_error(vs);
		} else {
		VNC_DEBUG("Websock handshake complete, starting VNC protocol\n");
		vnc_init_state(vs);
		vs->ioc_tag = qio_channel_add_watch(
		vs->ioc, G_IO_IN, vnc_client_io, vs, NULL);
		vncws_process_handshake(vs, vs->ws_input.buffer, vs->ws_input.offset);
		buffer_advance(&vs->ws_input, handshake_end - vs->ws_input.buffer +
		strlen(WS_HANDSHAKE_END));
		} else if (vs->ws_input.offset >= 4096) {
		VNC_DEBUG("End of headers not found in first 4096 bytes\n");
		vnc_client_error(vs);
		}
		}

		@@ -120,280 +101,23 @@ gboolean vncws_handshake_io(QIOChannel *ioc G_GNUC_UNUSED,
		void *opaque)
		{
		VncState *vs = opaque;
		vncws_handshake_read(vs);
		return TRUE;
		}

		long vnc_client_read_ws(VncState *vs)
		{
		int ret, err;
		uint8_t *payload;
		size_t payload_size, header_size;
		VNC_DEBUG("Read websocket %p size %zd offset %zd\n", vs->ws_input.buffer,
		vs->ws_input.capacity, vs->ws_input.offset);
		buffer_reserve(&vs->ws_input, 4096);
		ret = vnc_client_read_buf(vs, buffer_end(&vs->ws_input), 4096);
		if (!ret) {
		return 0;
		}
		vs->ws_input.offset += ret;

		ret = 0;
		/* consume as much of ws_input buffer as possible */
		do {
		if (vs->ws_payload_remain == 0) {
		err = vncws_decode_frame_header(&vs->ws_input,
		&header_size,
		&vs->ws_payload_remain,
		&vs->ws_payload_mask);
		if (err <= 0) {
		return err;
		}

		buffer_advance(&vs->ws_input, header_size);
		}
		if (vs->ws_payload_remain != 0) {
		err = vncws_decode_frame_payload(&vs->ws_input,
		&vs->ws_payload_remain,
		&vs->ws_payload_mask,
		&payload,
		&payload_size);
		if (err < 0) {
		return err;
		}
		if (err == 0) {
		return ret;
		}
		ret += err;

		buffer_reserve(&vs->input, payload_size);
		buffer_append(&vs->input, payload, payload_size);

		buffer_advance(&vs->ws_input, payload_size);
		}
		} while (vs->ws_input.offset > 0);
		QIOChannelWebsock *wioc;

		return ret;
		}

		long vnc_client_write_ws(VncState *vs)
		{
		long ret;
		VNC_DEBUG("Write WS: Pending output %p size %zd offset %zd\n",
		vs->output.buffer, vs->output.capacity, vs->output.offset);
		vncws_encode_frame(&vs->ws_output, vs->output.buffer, vs->output.offset);
		buffer_reset(&vs->output);
		ret = vnc_client_write_buf(vs, vs->ws_output.buffer, vs->ws_output.offset);
		if (!ret) {
		return 0;
		}

		buffer_advance(&vs->ws_output, ret);

		if (vs->ws_output.offset == 0) {
		VNC_DEBUG("Websocket negotiate starting\n");
		if (vs->ioc_tag) {
		g_source_remove(vs->ioc_tag);
		}
		vs->ioc_tag = qio_channel_add_watch(
		vs->ioc, G_IO_IN, vnc_client_io, vs, NULL);
		}

		return ret;
		}

		static char vncws_extract_handshake_entry(const char handshake,
		size_t handshake_len, const char *name)
		{
		char begin, end, *ret = NULL;
		char *line = g_strdup_printf("%s%s: ", WS_HANDSHAKE_DELIM, name);
		begin = g_strstr_len(handshake, handshake_len, line);
		if (begin != NULL) {
		begin += strlen(line);
		end = g_strstr_len(begin, handshake_len - (begin - handshake),
		WS_HANDSHAKE_DELIM);
		if (end != NULL) {
		ret = g_strndup(begin, end - begin);
		}
		}
		g_free(line);
		return ret;
		}

		static void vncws_send_handshake_response(VncState vs, const char key)
		{
		char combined_key[WS_CLIENT_KEY_LEN + WS_GUID_LEN + 1];
		char accept = NULL, response = NULL;
		Error *err = NULL;

		g_strlcpy(combined_key, key, WS_CLIENT_KEY_LEN + 1);
		g_strlcat(combined_key, WS_GUID, WS_CLIENT_KEY_LEN + WS_GUID_LEN + 1);

		/* hash and encode it */
		if (qcrypto_hash_base64(QCRYPTO_HASH_ALG_SHA1,
		combined_key,
		WS_CLIENT_KEY_LEN + WS_GUID_LEN,
		&accept,
		&err) < 0) {
		VNC_DEBUG("Hashing Websocket combined key failed %s\n",
		error_get_pretty(err));
		error_free(err);
		vnc_client_error(vs);
		return;
		}

		response = g_strdup_printf(WS_HANDSHAKE, accept);
		vnc_client_write_buf(vs, (const uint8_t *)response, strlen(response));

		g_free(accept);
		g_free(response);

		vs->encode_ws = 1;
		vnc_init_state(vs);
		}

		void vncws_process_handshake(VncState vs, uint8_t line, size_t size)
		{
		char protocols = vncws_extract_handshake_entry((const char )line, size,
		"Sec-WebSocket-Protocol");
		char version = vncws_extract_handshake_entry((const char )line, size,
		"Sec-WebSocket-Version");
		char key = vncws_extract_handshake_entry((const char )line, size,
		"Sec-WebSocket-Key");

		if (protocols && version && key
		&& g_strrstr(protocols, "binary")
		&& !strcmp(version, WS_SUPPORTED_VERSION)
		&& strlen(key) == WS_CLIENT_KEY_LEN) {
		vncws_send_handshake_response(vs, key);
		} else {
		VNC_DEBUG("Defective Websockets header or unsupported protocol\n");
		vnc_client_error(vs);
		}

		g_free(protocols);
		g_free(version);
		g_free(key);
		}

		void vncws_encode_frame(Buffer output, const void payload,
		const size_t payload_size)
		{
		size_t header_size = 0;
		unsigned char opcode = WS_OPCODE_BINARY_FRAME;
		union {
		char buf[WS_HEAD_MAX_LEN];
		WsHeader ws;
		} header;

		if (!payload_size) {
		return;
		}

		header.ws.b0 = 0x80 \| (opcode & 0x0f);
		if (payload_size <= 125) {
		header.ws.b1 = (uint8_t)payload_size;
		header_size = 2;
		} else if (payload_size < 65536) {
		header.ws.b1 = 0x7e;
		header.ws.u.s16.l16 = cpu_to_be16((uint16_t)payload_size);
		header_size = 4;
		} else {
		header.ws.b1 = 0x7f;
		header.ws.u.s64.l64 = cpu_to_be64(payload_size);
		header_size = 10;
		}

		buffer_reserve(output, header_size + payload_size);
		buffer_append(output, header.buf, header_size);
		buffer_append(output, payload, payload_size);
		}

		int vncws_decode_frame_header(Buffer *input,
		size_t *header_size,
		size_t *payload_remain,
		WsMask *payload_mask)
		{
		unsigned char opcode = 0, fin = 0, has_mask = 0;
		size_t payload_len;
		WsHeader header = (WsHeader )input->buffer;

		if (input->offset < WS_HEAD_MIN_LEN + 4) {
		/* header not complete */
		return 0;
		}

		fin = (header->b0 & 0x80) >> 7;
		opcode = header->b0 & 0x0f;
		has_mask = (header->b1 & 0x80) >> 7;
		payload_len = header->b1 & 0x7f;

		if (opcode == WS_OPCODE_CLOSE) {
		/* disconnect */
		return -1;
		}

		/* Websocket frame sanity check:
		* * Websocket fragmentation is not supported.
		* * All websockets frames sent by a client have to be masked.
		* * Only binary encoding is supported.
		*/
		if (!fin \|\| !has_mask \|\| opcode != WS_OPCODE_BINARY_FRAME) {
		VNC_DEBUG("Received faulty/unsupported Websocket frame\n");
		return -2;
		}

		if (payload_len < 126) {
		*payload_remain = payload_len;
		*header_size = 6;
		*payload_mask = header->u.m;
		} else if (payload_len == 126 && input->offset >= 8) {
		*payload_remain = be16_to_cpu(header->u.s16.l16);
		*header_size = 8;
		*payload_mask = header->u.s16.m16;
		} else if (payload_len == 127 && input->offset >= 14) {
		*payload_remain = be64_to_cpu(header->u.s64.l64);
		*header_size = 14;
		*payload_mask = header->u.s64.m64;
		} else {
		/* header not complete */
		return 0;
		}

		return 1;
		vs->ioc_tag = 0;
		}

		int vncws_decode_frame_payload(Buffer *input,
		size_t payload_remain, WsMask payload_mask,
		uint8_t *payload, size_t payload_size)
		{
		size_t i;
		uint32_t *payload32;
		wioc = qio_channel_websock_new_server(vs->ioc);

		*payload = input->buffer;
		/* If we aren't at the end of the payload, then drop
		* off the last bytes, so we're always multiple of 4
		* for purpose of unmasking, except at end of payload
		*/
		if (input->offset < *payload_remain) {
		*payload_size = input->offset - (input->offset % 4);
		} else {
		payload_size = payload_remain;
		}
		if (*payload_size == 0) {
		return 0;
		}
		payload_remain -= payload_size;
		object_unref(OBJECT(vs->ioc));
		vs->ioc = QIO_CHANNEL(wioc);

		/* unmask frame */
		/* process 1 frame (32 bit op) */
		payload32 = (uint32_t )(payload);
		for (i = 0; i < *payload_size / 4; i++) {
		payload32[i] ^= payload_mask->u;
		}
		/* process the remaining bytes (if any) */
		for (i = 4; i < payload_size; i++) {
		(*payload)[i] ^= payload_mask->c[i % 4];
		}
		qio_channel_websock_handshake(wioc,
		vncws_handshake_done,
		vs,
		NULL);

		return 1;
		return TRUE;
		}

ui/vnc-ws.h

+0 −63

Original line number	Diff line number	Diff line
		@@ -21,74 +21,11 @@
		#ifndef __QEMU_UI_VNC_WS_H
		#define __QEMU_UI_VNC_WS_H

		#define B64LEN(__x) (((__x + 2) / 3) * 12 / 3)
		#define SHA1_DIGEST_LEN 20

		#define WS_ACCEPT_LEN (B64LEN(SHA1_DIGEST_LEN) + 1)
		#define WS_CLIENT_KEY_LEN 24
		#define WS_GUID "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
		#define WS_GUID_LEN strlen(WS_GUID)

		#define WS_HANDSHAKE "HTTP/1.1 101 Switching Protocols\r\n\
		Upgrade: websocket\r\n\
		Connection: Upgrade\r\n\
		Sec-WebSocket-Accept: %s\r\n\
		Sec-WebSocket-Protocol: binary\r\n\
		\r\n"
		#define WS_HANDSHAKE_DELIM "\r\n"
		#define WS_HANDSHAKE_END "\r\n\r\n"
		#define WS_SUPPORTED_VERSION "13"

		#define WS_HEAD_MIN_LEN sizeof(uint16_t)
		#define WS_HEAD_MAX_LEN (WS_HEAD_MIN_LEN + sizeof(uint64_t) + sizeof(uint32_t))

		typedef union WsMask {
		char c[4];
		uint32_t u;
		} WsMask;

		typedef struct QEMU_PACKED WsHeader {
		unsigned char b0;
		unsigned char b1;
		union {
		struct QEMU_PACKED {
		uint16_t l16;
		WsMask m16;
		} s16;
		struct QEMU_PACKED {
		uint64_t l64;
		WsMask m64;
		} s64;
		WsMask m;
		} u;
		} WsHeader;

		enum {
		WS_OPCODE_CONTINUATION = 0x0,
		WS_OPCODE_TEXT_FRAME = 0x1,
		WS_OPCODE_BINARY_FRAME = 0x2,
		WS_OPCODE_CLOSE = 0x8,
		WS_OPCODE_PING = 0x9,
		WS_OPCODE_PONG = 0xA
		};

		gboolean vncws_tls_handshake_io(QIOChannel *ioc,
		GIOCondition condition,
		void *opaque);
		gboolean vncws_handshake_io(QIOChannel *ioc,
		GIOCondition condition,
		void *opaque);
		long vnc_client_write_ws(VncState *vs);
		long vnc_client_read_ws(VncState *vs);
		void vncws_process_handshake(VncState vs, uint8_t line, size_t size);
		void vncws_encode_frame(Buffer output, const void payload,
		const size_t payload_size);
		int vncws_decode_frame_header(Buffer *input,
		size_t *header_size,
		size_t *payload_remain,
		WsMask *payload_mask);
		int vncws_decode_frame_payload(Buffer *input,
		size_t payload_remain, WsMask payload_mask,
		uint8_t *payload, size_t payload_size);

		#endif /* __QEMU_UI_VNC_WS_H */

ui/vnc.c

+4 −23

Original line number	Diff line number	Diff line
		@@ -1192,8 +1192,6 @@ void vnc_disconnect_finish(VncState *vs)

		buffer_free(&vs->input);
		buffer_free(&vs->output);
		buffer_free(&vs->ws_input);
		buffer_free(&vs->ws_output);

		qapi_free_VncClientInfo(vs->info);

		@@ -1352,19 +1350,15 @@ static void vnc_client_write_locked(VncState *vs)
		} else
		#endif /* CONFIG_VNC_SASL */
		{
		if (vs->encode_ws) {
		vnc_client_write_ws(vs);
		} else {
		vnc_client_write_plain(vs);
		}
		}
		}

		static void vnc_client_write(VncState *vs)
		{

		vnc_lock_output(vs);
		if (vs->output.offset \|\| vs->ws_output.offset) {
		if (vs->output.offset) {
		vnc_client_write_locked(vs);
		} else if (vs->ioc != NULL) {
		if (vs->ioc_tag) {
		@@ -1451,18 +1445,7 @@ static void vnc_client_read(VncState *vs)
		ret = vnc_client_read_sasl(vs);
		else
		#endif /* CONFIG_VNC_SASL */
		if (vs->encode_ws) {
		ret = vnc_client_read_ws(vs);
		if (ret == -1) {
		vnc_disconnect_start(vs);
		return;
		} else if (ret == -2) {
		vnc_client_error(vs);
		return;
		}
		} else {
		ret = vnc_client_read_plain(vs);
		}
		if (!ret) {
		if (vs->disconnecting) {
		vnc_disconnect_finish(vs);
		@@ -1552,7 +1535,7 @@ void vnc_write_u8(VncState *vs, uint8_t value)
		void vnc_flush(VncState *vs)
		{
		vnc_lock_output(vs);
		if (vs->ioc != NULL && (vs->output.offset \|\| vs->ws_output.offset)) {
		if (vs->ioc != NULL && vs->output.offset) {
		vnc_client_write_locked(vs);
		}
		vnc_unlock_output(vs);
		@@ -2950,8 +2933,6 @@ static void vnc_connect(VncDisplay vd, QIOChannelSocket sioc,

		buffer_init(&vs->input, "vnc-input/%p", sioc);
		buffer_init(&vs->output, "vnc-output/%p", sioc);
		buffer_init(&vs->ws_input, "vnc-ws_input/%p", sioc);
		buffer_init(&vs->ws_output, "vnc-ws_output/%p", sioc);
		buffer_init(&vs->jobs_buffer, "vnc-jobs_buffer/%p", sioc);

		buffer_init(&vs->tight.tight, "vnc-tight/%p", sioc);

ui/vnc.h

+0 −4

Original line number	Diff line number	Diff line
		@@ -293,10 +293,6 @@ struct VncState

		Buffer output;
		Buffer input;
		Buffer ws_input;
		Buffer ws_output;
		size_t ws_payload_remain;
		WsMask ws_payload_mask;
		/* current output mode information */
		VncWritePixels *write_pixels;
		PixelFormat client_pf;