Second commit

Signed-off-by: Mattias Andrée <maandree@kth.se>

1 files changed, 211 insertions, 0 deletions

diff --git a/libaxl_receive_handshake.c b/libaxl_receive_handshake.c
new file mode 100644
index 0000000..5e193e2
--- /dev/null
+++ b/libaxl_receive_handshake.c
@@ -0,0 +1,211 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+struct response {
+	uint8_t  status;
+	uint8_t  length_of_reason; /* Only used in Failed, and not in Authenticate */
+	uint16_t protocol_major_version; /* Not in Authenticate */
+	uint16_t protocol_minor_version; /* Not in Authenticate */
+	union {
+		struct {
+			uint16_t length_of_addition_data;
+			char additional_data[];
+		};
+		struct {
+			uint16_t __length_of_addition_data__1;
+			char reason[];
+		};
+		struct {
+			uint16_t __length_of_addition_data__2;
+			uint32_t release_number;
+			uint32_t resource_id_base;
+			uint32_t resource_id_mask;
+			uint32_t motion_buffer_size;
+			uint16_t length_of_vendor;
+			uint16_t maximum_request_length;
+			uint8_t number_of_roots;
+			uint8_t number_of_pixmap_formats;
+			uint8_t image_byte_order;
+			uint8_t bitmap_format_bit_order;
+			uint8_t bitmap_format_scanline_unit;
+			uint8_t bitmap_format_scanline_pad;
+			uint8_t min_keycode;
+			uint8_t max_keycode;
+			uint32_t __unused;
+			char vendor[];
+		};
+	};
+};
+
+int
+libaxl_receive_handshake(LIBAXL_CONTEXT *restrict ctx, int *restrict majorp, int *restrict minorp, char **restrict reasonp, int flags)
+{
+	LIBAXL_CONNECTION *conn = ctx->conn;
+	char *restrict inbuf, *new;
+	size_t n, t, len, vendor_len, out_off, in_off;
+	ssize_t r;
+	int read_stage = 0, saved_errno;
+	struct response *resp;
+#ifdef MSG_TRUNC
+	int flag_trunc;
+#endif
+
+#ifdef MSG_TRUNC
+	flags ^= flag_trunc = flags & MSG_TRUNC;
+#endif
+
+	WLOCK_CONNECTION_RECV(conn);
+
+	inbuf = conn->in_buf;
+	n = offsetof(struct response, additional_data);
+
+	if (conn->in_buf_size < n) {
+		inbuf = liberror_realloc(inbuf, n);
+		if (!inbuf) {
+			WUNLOCK_CONNECTION_RECV(conn);
+			return LIBAXL_ERROR_SYSTEM;
+		}
+		conn->in_buf = inbuf;
+		conn->in_buf_size = n;
+	}
+
+continue_read:
+	while (conn->in_progress < n) {
+		r = recv(conn->fd, &inbuf[conn->in_progress], n - conn->in_progress, flags);
+		if (r <= 0) {
+			WUNLOCK_CONNECTION_RECV(conn);
+			liberror_save_backtrace(NULL);
+			if (!r) {
+				liberror_set_error("The connection to the display server has been closed",
+				                   "libaxl_receive_handshake", "libaxl", LIBAXL_ERROR_CONNECTION_CLOSED);
+				return LIBAXL_ERROR_CONNECTION_CLOSED;
+			}
+			liberror_recv_failed(conn->fd, &inbuf[conn->in_progress], n - conn->in_progress, flags, "<display server>");
+			return LIBAXL_ERROR_SYSTEM;
+		}
+		conn->in_progress += (size_t)r;
+	}
+
+	if (read_stage == 0) {
+		n += (size_t)((struct response *)inbuf)->length_of_addition_data * 4;
+		read_stage = 1;
+		goto continue_read;
+	}
+
+	conn->in_progress = 0;
+
+#ifdef MSG_TRUNC
+	if (flag_trunc) {
+		WUNLOCK_CONNECTION_RECV(conn);
+		return 0;
+	}
+#endif
+
+	t = conn->in_buf_size;
+	conn->in_buf_size = ctx->in_buf_size;
+	ctx->in_buf_size = t;
+
+	conn->in_buf = ctx->in_buf;
+	ctx->in_buf = inbuf;
+
+	WUNLOCK_CONNECTION_RECV(conn);
+
+	resp = (struct response *)inbuf;
+
+	if (majorp)
+		*majorp = (int)resp->protocol_major_version;
+	if (minorp)
+		*minorp = (int)resp->protocol_minor_version;
+	if (reasonp)
+		*reasonp = NULL;
+
+	switch (resp->status) {
+	case LIBAXL_HANDSHAKE_FAILED:
+		len = (size_t)resp->length_of_reason;
+		if (n < len + offsetof(struct response, reason))
+			goto invalid;
+		goto return_reason;
+
+	case LIBAXL_HANDSHAKE_AUTHENTICATE:
+		len = n - offsetof(struct response, reason);
+	return_reason:
+		if (reasonp) {
+			*reasonp = liberror_malloc(len + 1);
+			if (!*reasonp)
+				return LIBAXL_ERROR_SYSTEM;
+			memcpy(*reasonp, resp->reason, len);
+			(*reasonp)[len] = '\0';
+		}
+		break;
+
+	case LIBAXL_HANDSHAKE_SUCCESS:
+		if (resp->resource_id_base & resp->resource_id_mask ||
+		    (resp->resource_id_base | resp->resource_id_mask) >> 29)
+			goto invalid;
+
+		conn->xid_base = resp->resource_id_base;
+		for (conn->xid_shift = 0; !(resp->resource_id_mask & 1); conn->xid_shift += 1)
+			resp->resource_id_mask >>= 1;
+		conn->xid_max = resp->resource_id_mask;
+		conn->info.vendor_release              = resp->release_number;
+		conn->info.min_keycode                 = resp->min_keycode;
+		conn->info.max_keycode                 = resp->max_keycode;
+		conn->info.image_byte_order            = resp->image_byte_order;
+		conn->info.motion_buffer_size          = resp->motion_buffer_size;
+		conn->info.maximum_request_length      = resp->maximum_request_length;
+		conn->info.bitmap_format_bit_order     = resp->bitmap_format_bit_order;
+		conn->info.bitmap_format_scanline_unit = resp->bitmap_format_scanline_unit;
+		conn->info.bitmap_format_scanline_pad  = resp->bitmap_format_scanline_pad;
+
+		/* These restricts are less restrictive than the protocol specifices,
+		 * in case the they are modified later on */
+		if (resp->resource_id_mask                ||
+		    conn->xid_max + 1 < UINT16_C(1) << 18 ||
+		    (conn->xid_max & (conn->xid_max + 1)) ||
+		    resp->min_keycode < 8                 ||
+		    resp->image_byte_order > 1            ||
+		    resp->maximum_request_length < 4096   ||
+		    resp->bitmap_format_bit_order > 1     ||
+		    resp->bitmap_format_scanline_unit % 8 ||
+		    resp->bitmap_format_scanline_pad % 8  ||
+		    resp->bitmap_format_scanline_unit > resp->bitmap_format_scanline_pad)
+			goto invalid;
+
+		vendor_len          = resp->length_of_vendor;
+		conn->info.nscreens = resp->number_of_roots;
+		conn->info.nformats = resp->number_of_pixmap_formats;
+
+		memmove(inbuf, resp->vendor, out_off = in_off = vendor_len);
+		inbuf[out_off++] = '\0';
+		out_off += (4 - out_off % 4) % 4;
+		in_off += (4 - in_off % 4) % 4;
+		in_off += offsetof(struct response, vendor);
+		t = out_off;
+		memmove(&inbuf[out_off], &inbuf[in_off], n - in_off);
+		out_off += n - in_off;
+
+		saved_errno = errno;
+		new = realloc(inbuf, out_off);
+		errno = saved_errno;
+		if (new)
+			inbuf = new;
+
+		conn->info_buf     = inbuf;
+		conn->info.vendor  = inbuf;
+		conn->info.formats = (void *)&inbuf[t];
+		conn->info.screens = (void *)&inbuf[t + conn->info.nformats * 8];
+
+		ctx->in_buf_size = 0;
+		ctx->in_buf = NULL;
+		break;
+
+	default:
+	invalid:
+		liberror_set_error("Invalid handshake response received from the display server",
+				   "libaxl_receive_handshake", "libaxl", LIBAXL_ERROR_INVALID_HANDSHAKE_RESPONSE);
+		errno = EBADMSG;
+		return LIBAXL_ERROR_INVALID_HANDSHAKE_RESPONSE;
+	}
+
+	return (int)resp->status;
+}