Adding upstream version 3.3.0+dfsg1.upstream/3.3.0+dfsg1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

3 files changed, 784 insertions, 0 deletions

diff --git a/channels/rdpei/server/CMakeLists.txt b/channels/rdpei/server/CMakeLists.txt
new file mode 100644
index 0000000..21c96ee
--- /dev/null
+++ b/channels/rdpei/server/CMakeLists.txt
@@ -0,0 +1,32 @@
+# FreeRDP: A Remote Desktop Protocol Implementation
+# FreeRDP cmake build script
+#
+# Copyright 2014 Thincast Technologies Gmbh.
+# Copyright 2014 David FORT <contact@hardening-consulting.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+define_channel_server("rdpei")
+
+set(${MODULE_PREFIX}_SRCS
+	rdpei_main.c
+	rdpei_main.h
+	../rdpei_common.c
+	../rdpei_common.h
+)
+
+set(${MODULE_PREFIX}_LIBS
+    winpr
+)
+
+add_channel_server_library(${MODULE_PREFIX} ${MODULE_NAME} ${CHANNEL_NAME} FALSE "VirtualChannelEntry")
diff --git a/channels/rdpei/server/rdpei_main.c b/channels/rdpei/server/rdpei_main.c
new file mode 100644
index 0000000..c87a045
--- /dev/null
+++ b/channels/rdpei/server/rdpei_main.c
@@ -0,0 +1,720 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Extended Input channel server-side implementation
+ *
+ * Copyright 2014 Thincast Technologies Gmbh.
+ * Copyright 2014 David FORT <contact@hardening-consulting.com>
+ * Copyright 2015 Thincast Technologies GmbH
+ * Copyright 2015 DI (FH) Martin Haimberger <martin.haimberger@thincast.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/config.h>
+
+#include <winpr/crt.h>
+#include <winpr/print.h>
+#include <winpr/stream.h>
+
+#include "rdpei_main.h"
+#include "../rdpei_common.h"
+#include <freerdp/channels/rdpei.h>
+#include <freerdp/server/rdpei.h>
+
+enum RdpEiState
+{
+	STATE_INITIAL,
+	STATE_WAITING_CLIENT_READY,
+	STATE_WAITING_FRAME,
+	STATE_SUSPENDED,
+};
+
+struct s_rdpei_server_private
+{
+	HANDLE channelHandle;
+	HANDLE eventHandle;
+
+	UINT32 expectedBytes;
+	BOOL waitingHeaders;
+	wStream* inputStream;
+	wStream* outputStream;
+
+	UINT16 currentMsgType;
+
+	RDPINPUT_TOUCH_EVENT touchEvent;
+	RDPINPUT_PEN_EVENT penEvent;
+
+	enum RdpEiState automataState;
+};
+
+RdpeiServerContext* rdpei_server_context_new(HANDLE vcm)
+{
+	RdpeiServerContext* ret = calloc(1, sizeof(*ret));
+	RdpeiServerPrivate* priv = NULL;
+
+	if (!ret)
+		return NULL;
+
+	ret->priv = priv = calloc(1, sizeof(*ret->priv));
+	if (!priv)
+		goto fail;
+
+	priv->inputStream = Stream_New(NULL, 256);
+	if (!priv->inputStream)
+		goto fail;
+
+	priv->outputStream = Stream_New(NULL, 200);
+	if (!priv->inputStream)
+		goto fail;
+
+	ret->vcm = vcm;
+	rdpei_server_context_reset(ret);
+	return ret;
+
+fail:
+	WINPR_PRAGMA_DIAG_PUSH
+	WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
+	rdpei_server_context_free(ret);
+	WINPR_PRAGMA_DIAG_POP
+	return NULL;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+UINT rdpei_server_init(RdpeiServerContext* context)
+{
+	void* buffer = NULL;
+	DWORD bytesReturned = 0;
+	RdpeiServerPrivate* priv = context->priv;
+	UINT32 channelId = 0;
+	BOOL status = TRUE;
+
+	priv->channelHandle = WTSVirtualChannelOpenEx(WTS_CURRENT_SESSION, RDPEI_DVC_CHANNEL_NAME,
+	                                              WTS_CHANNEL_OPTION_DYNAMIC);
+	if (!priv->channelHandle)
+	{
+		WLog_ERR(TAG, "WTSVirtualChannelOpenEx failed!");
+		return CHANNEL_RC_INITIALIZATION_ERROR;
+	}
+
+	channelId = WTSChannelGetIdByHandle(priv->channelHandle);
+
+	IFCALLRET(context->onChannelIdAssigned, status, context, channelId);
+	if (!status)
+	{
+		WLog_ERR(TAG, "context->onChannelIdAssigned failed!");
+		goto out_close;
+	}
+
+	if (!WTSVirtualChannelQuery(priv->channelHandle, WTSVirtualEventHandle, &buffer,
+	                            &bytesReturned) ||
+	    (bytesReturned != sizeof(HANDLE)))
+	{
+		WLog_ERR(TAG,
+		         "WTSVirtualChannelQuery failed or invalid invalid returned size(%" PRIu32 ")!",
+		         bytesReturned);
+		if (buffer)
+			WTSFreeMemory(buffer);
+		goto out_close;
+	}
+	CopyMemory(&priv->eventHandle, buffer, sizeof(HANDLE));
+	WTSFreeMemory(buffer);
+
+	return CHANNEL_RC_OK;
+
+out_close:
+	WTSVirtualChannelClose(priv->channelHandle);
+	return CHANNEL_RC_INITIALIZATION_ERROR;
+}
+
+void rdpei_server_context_reset(RdpeiServerContext* context)
+{
+	RdpeiServerPrivate* priv = context->priv;
+
+	priv->channelHandle = INVALID_HANDLE_VALUE;
+	priv->expectedBytes = RDPINPUT_HEADER_LENGTH;
+	priv->waitingHeaders = TRUE;
+	priv->automataState = STATE_INITIAL;
+	Stream_SetPosition(priv->inputStream, 0);
+}
+
+void rdpei_server_context_free(RdpeiServerContext* context)
+{
+	RdpeiServerPrivate* priv = NULL;
+
+	if (!context)
+		return;
+	priv = context->priv;
+	if (priv)
+	{
+		if (priv->channelHandle != INVALID_HANDLE_VALUE)
+			WTSVirtualChannelClose(priv->channelHandle);
+		Stream_Free(priv->inputStream, TRUE);
+	}
+	free(priv);
+	free(context);
+}
+
+HANDLE rdpei_server_get_event_handle(RdpeiServerContext* context)
+{
+	return context->priv->eventHandle;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT read_cs_ready_message(RdpeiServerContext* context, wStream* s)
+{
+	UINT error = CHANNEL_RC_OK;
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 10))
+		return ERROR_INVALID_DATA;
+
+	Stream_Read_UINT32(s, context->protocolFlags);
+	Stream_Read_UINT32(s, context->clientVersion);
+	Stream_Read_UINT16(s, context->maxTouchPoints);
+
+	switch (context->clientVersion)
+	{
+		case RDPINPUT_PROTOCOL_V10:
+		case RDPINPUT_PROTOCOL_V101:
+		case RDPINPUT_PROTOCOL_V200:
+		case RDPINPUT_PROTOCOL_V300:
+			break;
+		default:
+			WLog_ERR(TAG, "unhandled RPDEI protocol version 0x%" PRIx32 "", context->clientVersion);
+			break;
+	}
+
+	IFCALLRET(context->onClientReady, error, context);
+	if (error)
+		WLog_ERR(TAG, "context->onClientReady failed with error %" PRIu32 "", error);
+
+	return error;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT read_touch_contact_data(RdpeiServerContext* context, wStream* s,
+                                    RDPINPUT_CONTACT_DATA* contactData)
+{
+	WINPR_UNUSED(context);
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
+		return ERROR_INVALID_DATA;
+
+	Stream_Read_UINT8(s, contactData->contactId);
+	if (!rdpei_read_2byte_unsigned(s, &contactData->fieldsPresent) ||
+	    !rdpei_read_4byte_signed(s, &contactData->x) ||
+	    !rdpei_read_4byte_signed(s, &contactData->y) ||
+	    !rdpei_read_4byte_unsigned(s, &contactData->contactFlags))
+	{
+		WLog_ERR(TAG, "rdpei_read_ failed!");
+		return ERROR_INTERNAL_ERROR;
+	}
+
+	if (contactData->fieldsPresent & CONTACT_DATA_CONTACTRECT_PRESENT)
+	{
+		if (!rdpei_read_2byte_signed(s, &contactData->contactRectLeft) ||
+		    !rdpei_read_2byte_signed(s, &contactData->contactRectTop) ||
+		    !rdpei_read_2byte_signed(s, &contactData->contactRectRight) ||
+		    !rdpei_read_2byte_signed(s, &contactData->contactRectBottom))
+		{
+			WLog_ERR(TAG, "rdpei_read_ failed!");
+			return ERROR_INTERNAL_ERROR;
+		}
+	}
+
+	if ((contactData->fieldsPresent & CONTACT_DATA_ORIENTATION_PRESENT) &&
+	    !rdpei_read_4byte_unsigned(s, &contactData->orientation))
+	{
+		WLog_ERR(TAG, "rdpei_read_ failed!");
+		return ERROR_INTERNAL_ERROR;
+	}
+
+	if ((contactData->fieldsPresent & CONTACT_DATA_PRESSURE_PRESENT) &&
+	    !rdpei_read_4byte_unsigned(s, &contactData->pressure))
+	{
+		WLog_ERR(TAG, "rdpei_read_ failed!");
+		return ERROR_INTERNAL_ERROR;
+	}
+
+	return CHANNEL_RC_OK;
+}
+
+static UINT read_pen_contact(RdpeiServerContext* context, wStream* s,
+                             RDPINPUT_PEN_CONTACT* contactData)
+{
+	WINPR_UNUSED(context);
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
+		return ERROR_INVALID_DATA;
+
+	Stream_Read_UINT8(s, contactData->deviceId);
+	if (!rdpei_read_2byte_unsigned(s, &contactData->fieldsPresent) ||
+	    !rdpei_read_4byte_signed(s, &contactData->x) ||
+	    !rdpei_read_4byte_signed(s, &contactData->y) ||
+	    !rdpei_read_4byte_unsigned(s, &contactData->contactFlags))
+	{
+		WLog_ERR(TAG, "rdpei_read_ failed!");
+		return ERROR_INTERNAL_ERROR;
+	}
+
+	if (contactData->fieldsPresent & RDPINPUT_PEN_CONTACT_PENFLAGS_PRESENT)
+	{
+		if (!rdpei_read_4byte_unsigned(s, &contactData->penFlags))
+			return ERROR_INVALID_DATA;
+	}
+	if (contactData->fieldsPresent & RDPINPUT_PEN_CONTACT_PRESSURE_PRESENT)
+	{
+		if (!rdpei_read_4byte_unsigned(s, &contactData->pressure))
+			return ERROR_INVALID_DATA;
+	}
+	if (contactData->fieldsPresent & RDPINPUT_PEN_CONTACT_ROTATION_PRESENT)
+	{
+		if (!rdpei_read_2byte_unsigned(s, &contactData->rotation))
+			return ERROR_INVALID_DATA;
+	}
+	if (contactData->fieldsPresent & RDPINPUT_PEN_CONTACT_TILTX_PRESENT)
+	{
+		if (!rdpei_read_2byte_signed(s, &contactData->tiltX))
+			return ERROR_INVALID_DATA;
+	}
+	if (contactData->fieldsPresent & RDPINPUT_PEN_CONTACT_TILTY_PRESENT)
+	{
+		if (!rdpei_read_2byte_signed(s, &contactData->tiltY))
+			return ERROR_INVALID_DATA;
+	}
+
+	return CHANNEL_RC_OK;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT read_touch_frame(RdpeiServerContext* context, wStream* s, RDPINPUT_TOUCH_FRAME* frame)
+{
+	RDPINPUT_CONTACT_DATA* contact = NULL;
+	UINT error = 0;
+
+	if (!rdpei_read_2byte_unsigned(s, &frame->contactCount) ||
+	    !rdpei_read_8byte_unsigned(s, &frame->frameOffset))
+	{
+		WLog_ERR(TAG, "rdpei_read_ failed!");
+		return ERROR_INTERNAL_ERROR;
+	}
+
+	frame->contacts = contact = calloc(frame->contactCount, sizeof(RDPINPUT_CONTACT_DATA));
+	if (!frame->contacts)
+	{
+		WLog_ERR(TAG, "calloc failed!");
+		return CHANNEL_RC_NO_MEMORY;
+	}
+
+	for (UINT32 i = 0; i < frame->contactCount; i++, contact++)
+	{
+		if ((error = read_touch_contact_data(context, s, contact)))
+		{
+			WLog_ERR(TAG, "read_touch_contact_data failed with error %" PRIu32 "!", error);
+			frame->contactCount = i;
+			touch_frame_reset(frame);
+			return error;
+		}
+	}
+	return CHANNEL_RC_OK;
+}
+
+static UINT read_pen_frame(RdpeiServerContext* context, wStream* s, RDPINPUT_PEN_FRAME* frame)
+{
+	RDPINPUT_PEN_CONTACT* contact = NULL;
+	UINT error = 0;
+
+	if (!rdpei_read_2byte_unsigned(s, &frame->contactCount) ||
+	    !rdpei_read_8byte_unsigned(s, &frame->frameOffset))
+	{
+		WLog_ERR(TAG, "rdpei_read_ failed!");
+		return ERROR_INTERNAL_ERROR;
+	}
+
+	frame->contacts = contact = calloc(frame->contactCount, sizeof(RDPINPUT_PEN_CONTACT));
+	if (!frame->contacts)
+	{
+		WLog_ERR(TAG, "calloc failed!");
+		return CHANNEL_RC_NO_MEMORY;
+	}
+
+	for (UINT32 i = 0; i < frame->contactCount; i++, contact++)
+	{
+		if ((error = read_pen_contact(context, s, contact)))
+		{
+			WLog_ERR(TAG, "read_touch_contact_data failed with error %" PRIu32 "!", error);
+			frame->contactCount = i;
+			pen_frame_reset(frame);
+			return error;
+		}
+	}
+	return CHANNEL_RC_OK;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT read_touch_event(RdpeiServerContext* context, wStream* s)
+{
+	UINT16 frameCount = 0;
+	RDPINPUT_TOUCH_EVENT* event = &context->priv->touchEvent;
+	RDPINPUT_TOUCH_FRAME* frame = NULL;
+	UINT error = CHANNEL_RC_OK;
+
+	if (!rdpei_read_4byte_unsigned(s, &event->encodeTime) ||
+	    !rdpei_read_2byte_unsigned(s, &frameCount))
+	{
+		WLog_ERR(TAG, "rdpei_read_ failed!");
+		return ERROR_INTERNAL_ERROR;
+	}
+
+	event->frameCount = frameCount;
+	event->frames = frame = calloc(event->frameCount, sizeof(RDPINPUT_TOUCH_FRAME));
+	if (!event->frames)
+	{
+		WLog_ERR(TAG, "calloc failed!");
+		return CHANNEL_RC_NO_MEMORY;
+	}
+
+	for (UINT32 i = 0; i < frameCount; i++, frame++)
+	{
+		if ((error = read_touch_frame(context, s, frame)))
+		{
+			WLog_ERR(TAG, "read_touch_contact_data failed with error %" PRIu32 "!", error);
+			event->frameCount = i;
+			goto out_cleanup;
+		}
+	}
+
+	IFCALLRET(context->onTouchEvent, error, context, event);
+	if (error)
+		WLog_ERR(TAG, "context->onTouchEvent failed with error %" PRIu32 "", error);
+
+out_cleanup:
+	touch_event_reset(event);
+	return error;
+}
+
+static UINT read_pen_event(RdpeiServerContext* context, wStream* s)
+{
+	UINT16 frameCount = 0;
+	RDPINPUT_PEN_EVENT* event = &context->priv->penEvent;
+	RDPINPUT_PEN_FRAME* frame = NULL;
+	UINT error = CHANNEL_RC_OK;
+
+	if (!rdpei_read_4byte_unsigned(s, &event->encodeTime) ||
+	    !rdpei_read_2byte_unsigned(s, &frameCount))
+	{
+		WLog_ERR(TAG, "rdpei_read_ failed!");
+		return ERROR_INTERNAL_ERROR;
+	}
+
+	event->frameCount = frameCount;
+	event->frames = frame = calloc(event->frameCount, sizeof(RDPINPUT_PEN_FRAME));
+	if (!event->frames)
+	{
+		WLog_ERR(TAG, "calloc failed!");
+		return CHANNEL_RC_NO_MEMORY;
+	}
+
+	for (UINT32 i = 0; i < frameCount; i++, frame++)
+	{
+		if ((error = read_pen_frame(context, s, frame)))
+		{
+			WLog_ERR(TAG, "read_pen_frame failed with error %" PRIu32 "!", error);
+			event->frameCount = i;
+			goto out_cleanup;
+		}
+	}
+
+	IFCALLRET(context->onPenEvent, error, context, event);
+	if (error)
+		WLog_ERR(TAG, "context->onPenEvent failed with error %" PRIu32 "", error);
+
+out_cleanup:
+	pen_event_reset(event);
+	return error;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT read_dismiss_hovering_contact(RdpeiServerContext* context, wStream* s)
+{
+	BYTE contactId = 0;
+	UINT error = CHANNEL_RC_OK;
+
+	if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
+		return ERROR_INVALID_DATA;
+
+	Stream_Read_UINT8(s, contactId);
+
+	IFCALLRET(context->onTouchReleased, error, context, contactId);
+	if (error)
+		WLog_ERR(TAG, "context->onTouchReleased failed with error %" PRIu32 "", error);
+
+	return error;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+UINT rdpei_server_handle_messages(RdpeiServerContext* context)
+{
+	DWORD bytesReturned = 0;
+	RdpeiServerPrivate* priv = context->priv;
+	wStream* s = priv->inputStream;
+	UINT error = CHANNEL_RC_OK;
+
+	if (!WTSVirtualChannelRead(priv->channelHandle, 0, Stream_Pointer(s), priv->expectedBytes,
+	                           &bytesReturned))
+	{
+		if (GetLastError() == ERROR_NO_DATA)
+			return ERROR_READ_FAULT;
+
+		WLog_DBG(TAG, "channel connection closed");
+		return CHANNEL_RC_OK;
+	}
+	priv->expectedBytes -= bytesReturned;
+	Stream_Seek(s, bytesReturned);
+
+	if (priv->expectedBytes)
+		return CHANNEL_RC_OK;
+
+	Stream_SealLength(s);
+	Stream_SetPosition(s, 0);
+
+	if (priv->waitingHeaders)
+	{
+		UINT32 pduLen = 0;
+
+		/* header case */
+		Stream_Read_UINT16(s, priv->currentMsgType);
+		Stream_Read_UINT16(s, pduLen);
+
+		if (pduLen < RDPINPUT_HEADER_LENGTH)
+		{
+			WLog_ERR(TAG, "invalid pduLength %" PRIu32 "", pduLen);
+			return ERROR_INVALID_DATA;
+		}
+		priv->expectedBytes = pduLen - RDPINPUT_HEADER_LENGTH;
+		priv->waitingHeaders = FALSE;
+		Stream_SetPosition(s, 0);
+		if (priv->expectedBytes)
+		{
+			if (!Stream_EnsureCapacity(s, priv->expectedBytes))
+			{
+				WLog_ERR(TAG, "Stream_EnsureCapacity failed!");
+				return CHANNEL_RC_NO_MEMORY;
+			}
+			return CHANNEL_RC_OK;
+		}
+	}
+
+	/* when here we have the header + the body */
+	switch (priv->currentMsgType)
+	{
+		case EVENTID_CS_READY:
+			if (priv->automataState != STATE_WAITING_CLIENT_READY)
+			{
+				WLog_ERR(TAG, "not expecting a CS_READY packet in this state(%d)",
+				         priv->automataState);
+				return ERROR_INVALID_STATE;
+			}
+
+			if ((error = read_cs_ready_message(context, s)))
+			{
+				WLog_ERR(TAG, "read_cs_ready_message failed with error %" PRIu32 "", error);
+				return error;
+			}
+			break;
+
+		case EVENTID_TOUCH:
+			if ((error = read_touch_event(context, s)))
+			{
+				WLog_ERR(TAG, "read_touch_event failed with error %" PRIu32 "", error);
+				return error;
+			}
+			break;
+		case EVENTID_DISMISS_HOVERING_CONTACT:
+			if ((error = read_dismiss_hovering_contact(context, s)))
+			{
+				WLog_ERR(TAG, "read_dismiss_hovering_contact failed with error %" PRIu32 "", error);
+				return error;
+			}
+			break;
+		case EVENTID_PEN:
+			if ((error = read_pen_event(context, s)))
+			{
+				WLog_ERR(TAG, "read_pen_event failed with error %" PRIu32 "", error);
+				return error;
+			}
+			break;
+		default:
+			WLog_ERR(TAG, "unexpected message type 0x%" PRIx16 "", priv->currentMsgType);
+	}
+
+	Stream_SetPosition(s, 0);
+	priv->waitingHeaders = TRUE;
+	priv->expectedBytes = RDPINPUT_HEADER_LENGTH;
+	return error;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+UINT rdpei_server_send_sc_ready(RdpeiServerContext* context, UINT32 version, UINT32 features)
+{
+	ULONG written = 0;
+	RdpeiServerPrivate* priv = context->priv;
+	UINT32 pduLen = 4;
+
+	if (priv->automataState != STATE_INITIAL)
+	{
+		WLog_ERR(TAG, "called from unexpected state %d", priv->automataState);
+		return ERROR_INVALID_STATE;
+	}
+
+	Stream_SetPosition(priv->outputStream, 0);
+
+	if (version >= RDPINPUT_PROTOCOL_V300)
+		pduLen += 4;
+
+	if (!Stream_EnsureCapacity(priv->outputStream, RDPINPUT_HEADER_LENGTH + pduLen))
+	{
+		WLog_ERR(TAG, "Stream_EnsureCapacity failed!");
+		return CHANNEL_RC_NO_MEMORY;
+	}
+
+	Stream_Write_UINT16(priv->outputStream, EVENTID_SC_READY);
+	Stream_Write_UINT32(priv->outputStream, RDPINPUT_HEADER_LENGTH + pduLen);
+	Stream_Write_UINT32(priv->outputStream, version);
+	if (version >= RDPINPUT_PROTOCOL_V300)
+		Stream_Write_UINT32(priv->outputStream, features);
+
+	if (!WTSVirtualChannelWrite(priv->channelHandle, (PCHAR)Stream_Buffer(priv->outputStream),
+	                            Stream_GetPosition(priv->outputStream), &written))
+	{
+		WLog_ERR(TAG, "WTSVirtualChannelWrite failed!");
+		return ERROR_INTERNAL_ERROR;
+	}
+
+	priv->automataState = STATE_WAITING_CLIENT_READY;
+	return CHANNEL_RC_OK;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+UINT rdpei_server_suspend(RdpeiServerContext* context)
+{
+	ULONG written = 0;
+	RdpeiServerPrivate* priv = context->priv;
+
+	switch (priv->automataState)
+	{
+		case STATE_SUSPENDED:
+			WLog_ERR(TAG, "already suspended");
+			return CHANNEL_RC_OK;
+		case STATE_WAITING_FRAME:
+			break;
+		default:
+			WLog_ERR(TAG, "called from unexpected state %d", priv->automataState);
+			return ERROR_INVALID_STATE;
+	}
+
+	Stream_SetPosition(priv->outputStream, 0);
+	if (!Stream_EnsureCapacity(priv->outputStream, RDPINPUT_HEADER_LENGTH))
+	{
+		WLog_ERR(TAG, "Stream_EnsureCapacity failed!");
+		return CHANNEL_RC_NO_MEMORY;
+	}
+
+	Stream_Write_UINT16(priv->outputStream, EVENTID_SUSPEND_TOUCH);
+	Stream_Write_UINT32(priv->outputStream, RDPINPUT_HEADER_LENGTH);
+
+	if (!WTSVirtualChannelWrite(priv->channelHandle, (PCHAR)Stream_Buffer(priv->outputStream),
+	                            Stream_GetPosition(priv->outputStream), &written))
+	{
+		WLog_ERR(TAG, "WTSVirtualChannelWrite failed!");
+		return ERROR_INTERNAL_ERROR;
+	}
+
+	priv->automataState = STATE_SUSPENDED;
+	return CHANNEL_RC_OK;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+UINT rdpei_server_resume(RdpeiServerContext* context)
+{
+	ULONG written = 0;
+	RdpeiServerPrivate* priv = context->priv;
+
+	switch (priv->automataState)
+	{
+		case STATE_WAITING_FRAME:
+			WLog_ERR(TAG, "not suspended");
+			return CHANNEL_RC_OK;
+		case STATE_SUSPENDED:
+			break;
+		default:
+			WLog_ERR(TAG, "called from unexpected state %d", priv->automataState);
+			return ERROR_INVALID_STATE;
+	}
+
+	Stream_SetPosition(priv->outputStream, 0);
+	if (!Stream_EnsureCapacity(priv->outputStream, RDPINPUT_HEADER_LENGTH))
+	{
+		WLog_ERR(TAG, "Stream_EnsureCapacity failed!");
+		return CHANNEL_RC_NO_MEMORY;
+	}
+
+	Stream_Write_UINT16(priv->outputStream, EVENTID_RESUME_TOUCH);
+	Stream_Write_UINT32(priv->outputStream, RDPINPUT_HEADER_LENGTH);
+
+	if (!WTSVirtualChannelWrite(priv->channelHandle, (PCHAR)Stream_Buffer(priv->outputStream),
+	                            Stream_GetPosition(priv->outputStream), &written))
+	{
+		WLog_ERR(TAG, "WTSVirtualChannelWrite failed!");
+		return ERROR_INTERNAL_ERROR;
+	}
+
+	priv->automataState = STATE_WAITING_FRAME;
+	return CHANNEL_RC_OK;
+}
diff --git a/channels/rdpei/server/rdpei_main.h b/channels/rdpei/server/rdpei_main.h
new file mode 100644
index 0000000..cf3e3cb
--- /dev/null
+++ b/channels/rdpei/server/rdpei_main.h
@@ -0,0 +1,32 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Extended Input channel server-side implementation
+ *
+ * Copyright 2014 David Fort <contact@hardening-consulting.com>
+ * Copyright 2015 Thincast Technologies GmbH
+ * Copyright 2015 DI (FH) Martin Haimberger <martin.haimberger@thincast.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FREERDP_CHANNEL_RDPEI_SERVER_MAIN_H
+#define FREERDP_CHANNEL_RDPEI_SERVER_MAIN_H
+
+#include <winpr/crt.h>
+#include <winpr/synch.h>
+#include <winpr/thread.h>
+#include <freerdp/channels/log.h>
+
+#define TAG CHANNELS_TAG("rdpei.server")
+
+#endif /* FREERDP_CHANNEL_RDPEI_SERVER_MAIN_H */