/**

 * FreeRDP: A Remote Desktop Protocol Implementation

 * Multiparty Virtual Channel

 *

 * Copyright 2014 Marc-Andre Moreau <marcandre.moreau@gmail.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.

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <winpr/crt.h>

#include <winpr/print.h>

#include <freerdp/channels/log.h>

#include <freerdp/client/encomsp.h>

#include "encomsp_main.h"

struct encomsp_plugin

{

	CHANNEL_DEF channelDef;

	CHANNEL_ENTRY_POINTS_FREERDP_EX channelEntryPoints;

	EncomspClientContext* context;

	HANDLE thread;

	wStream* data_in;

	void* InitHandle;

	DWORD OpenHandle;

	wMessageQueue* queue;

	rdpContext* rdpcontext;

};

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT encomsp_read_header(wStream* s, ENCOMSP_ORDER_HEADER* header)

{

	if (Stream_GetRemainingLength(s) < ENCOMSP_ORDER_HEADER_SIZE)

	{

		WLog_ERR(TAG, "Not enough data!");

		return ERROR_INVALID_DATA;

	}

	Stream_Read_UINT16(s, header->Type);   /* Type (2 bytes) */

	Stream_Read_UINT16(s, header->Length); /* Length (2 bytes) */

	return CHANNEL_RC_OK;

}

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT encomsp_write_header(wStream* s, const ENCOMSP_ORDER_HEADER* header)

{

	Stream_Write_UINT16(s, header->Type);   /* Type (2 bytes) */

	Stream_Write_UINT16(s, header->Length); /* Length (2 bytes) */

	return CHANNEL_RC_OK;

}

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT encomsp_read_unicode_string(wStream* s, ENCOMSP_UNICODE_STRING* str)

{

	ZeroMemory(str, sizeof(ENCOMSP_UNICODE_STRING));

	if (Stream_GetRemainingLength(s) < 2)

	{

		WLog_ERR(TAG, "Not enough data!");

		return ERROR_INVALID_DATA;

	}

	Stream_Read_UINT16(s, str->cchString); /* cchString (2 bytes) */

	if (str->cchString > 1024)

	{

		WLog_ERR(TAG, "cchString was %" PRIu16 " but has to be < 1025!", str->cchString);

		return ERROR_INVALID_DATA;

	}

	if (Stream_GetRemainingLength(s) < (size_t)(str->cchString * 2))

	{

		WLog_ERR(TAG, "Not enough data!");

		return ERROR_INVALID_DATA;

	}

	Stream_Read(s, &(str->wString), (str->cchString * 2)); /* String (variable) */

	return CHANNEL_RC_OK;

}

static EncomspClientContext* encomsp_get_client_interface(encomspPlugin* encomsp)

{

	EncomspClientContext* pInterface;

	pInterface = (EncomspClientContext*)encomsp->channelEntryPoints.pInterface;

	return pInterface;

}

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT encomsp_virtual_channel_write(encomspPlugin* encomsp, wStream* s)

{

	UINT status;

	if (!encomsp)

	{

		Stream_Free(s, TRUE);

		return ERROR_INVALID_HANDLE;

	}

#if 0

	WLog_INFO(TAG, "EncomspWrite (%"PRIuz")", Stream_Length(s));

	winpr_HexDump(Stream_Buffer(s), Stream_Length(s));

#endif

	status = encomsp->channelEntryPoints.pVirtualChannelWriteEx(

	    encomsp->InitHandle, encomsp->OpenHandle, Stream_Buffer(s), (UINT32)Stream_Length(s), s);

	if (status != CHANNEL_RC_OK)

	{

		Stream_Free(s, TRUE);

		WLog_ERR(TAG, "VirtualChannelWriteEx failed with %s [%08" PRIX32 "]",

		         WTSErrorToString(status), status);

	}

	return status;

}

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT encomsp_recv_filter_updated_pdu(encomspPlugin* encomsp, wStream* s,

                                            const ENCOMSP_ORDER_HEADER* header)

{

	size_t beg, end, pos;

	EncomspClientContext* context;

	ENCOMSP_FILTER_UPDATED_PDU pdu;

	UINT error = CHANNEL_RC_OK;

	context = encomsp_get_client_interface(encomsp);

	if (!context)

		return ERROR_INVALID_HANDLE;

	pos = Stream_GetPosition(s);

	if (pos < ENCOMSP_ORDER_HEADER_SIZE)

		return ERROR_INVALID_DATA;

	beg = pos - ENCOMSP_ORDER_HEADER_SIZE;

	CopyMemory(&pdu, header, sizeof(ENCOMSP_ORDER_HEADER));

	if (Stream_GetRemainingLength(s) < 1)

	{

		WLog_ERR(TAG, "Not enough data!");

		return ERROR_INVALID_DATA;

	}

	Stream_Read_UINT8(s, pdu.Flags); /* Flags (1 byte) */

	end = Stream_GetPosition(s);

	if ((beg + header->Length) < end)

	{

		WLog_ERR(TAG, "Not enough data!");

		return ERROR_INVALID_DATA;

	}

	if ((beg + header->Length) > end)

	{

		if (Stream_GetRemainingLength(s) < (size_t)((beg + header->Length) - end))

		{

			WLog_ERR(TAG, "Not enough data!");

			return ERROR_INVALID_DATA;

		}

		Stream_SetPosition(s, (beg + header->Length));

	}

	IFCALLRET(context->FilterUpdated, error, context, &pdu);

	if (error)

		WLog_ERR(TAG, "context->FilterUpdated failed with error %" PRIu32 "", error);

	return error;

}

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT encomsp_recv_application_created_pdu(encomspPlugin* encomsp, wStream* s,

                                                 const ENCOMSP_ORDER_HEADER* header)

{

	size_t beg, end, pos;

	EncomspClientContext* context;

	ENCOMSP_APPLICATION_CREATED_PDU pdu;

	UINT error;

	context = encomsp_get_client_interface(encomsp);

	if (!context)

		return ERROR_INVALID_HANDLE;

	if (Stream_GetRemainingLength(s) < 6)

	{

		WLog_ERR(TAG, "Not enough data!");

		return ERROR_INVALID_DATA;

	}

	pos = Stream_GetPosition(s);

	if (pos < ENCOMSP_ORDER_HEADER_SIZE)

		return ERROR_INVALID_DATA;

	beg = pos - ENCOMSP_ORDER_HEADER_SIZE;

	CopyMemory(&pdu, header, sizeof(ENCOMSP_ORDER_HEADER));

	Stream_Read_UINT16(s, pdu.Flags); /* Flags (2 bytes) */

	Stream_Read_UINT32(s, pdu.AppId); /* AppId (4 bytes) */

	if ((error = encomsp_read_unicode_string(s, &(pdu.Name))))

	{

		WLog_ERR(TAG, "encomsp_read_unicode_string failed with error %" PRIu32 "", error);

		return error;

	}

	end = Stream_GetPosition(s);

	if ((beg + header->Length) < end)

	{

		WLog_ERR(TAG, "Not enough data!");

		return ERROR_INVALID_DATA;

	}

	if ((beg + header->Length) > end)

	{

		if (Stream_GetRemainingLength(s) < (size_t)((beg + header->Length) - end))

		{

			WLog_ERR(TAG, "Not enough data!");

			return ERROR_INVALID_DATA;

		}

		Stream_SetPosition(s, (beg + header->Length));

	}

	IFCALLRET(context->ApplicationCreated, error, context, &pdu);

	if (error)

		WLog_ERR(TAG, "context->ApplicationCreated failed with error %" PRIu32 "", error);

	return error;

}

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT encomsp_recv_application_removed_pdu(encomspPlugin* encomsp, wStream* s,

                                                 const ENCOMSP_ORDER_HEADER* header)

{

	size_t beg, end, pos;

	EncomspClientContext* context;

	ENCOMSP_APPLICATION_REMOVED_PDU pdu;

	UINT error = CHANNEL_RC_OK;

	context = encomsp_get_client_interface(encomsp);

	if (!context)

		return ERROR_INVALID_HANDLE;

	pos = Stream_GetPosition(s);

	if (pos < ENCOMSP_ORDER_HEADER_SIZE)

		return ERROR_INVALID_DATA;

	beg = pos - ENCOMSP_ORDER_HEADER_SIZE;

	CopyMemory(&pdu, header, sizeof(ENCOMSP_ORDER_HEADER));

	if (Stream_GetRemainingLength(s) < 4)

	{

		WLog_ERR(TAG, "Not enough data!");

		return ERROR_INVALID_DATA;

	}

	Stream_Read_UINT32(s, pdu.AppId); /* AppId (4 bytes) */

	end = Stream_GetPosition(s);

	if ((beg + header->Length) < end)

	{

		WLog_ERR(TAG, "Not enough data!");

		return ERROR_INVALID_DATA;

	}

	if ((beg + header->Length) > end)

	{

		if (Stream_GetRemainingLength(s) < (size_t)((beg + header->Length) - end))

		{

			WLog_ERR(TAG, "Not enough data!");

			return ERROR_INVALID_DATA;

		}

		Stream_SetPosition(s, (beg + header->Length));

	}

	IFCALLRET(context->ApplicationRemoved, error, context, &pdu);

	if (error)

		WLog_ERR(TAG, "context->ApplicationRemoved failed with error %" PRIu32 "", error);

	return error;

}

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT encomsp_recv_window_created_pdu(encomspPlugin* encomsp, wStream* s,

                                            const ENCOMSP_ORDER_HEADER* header)

{

	size_t beg, end, pos;

	EncomspClientContext* context;

	ENCOMSP_WINDOW_CREATED_PDU pdu;

	UINT error;

	context = encomsp_get_client_interface(encomsp);

	if (!context)

		return ERROR_INVALID_HANDLE;

	pos = Stream_GetPosition(s);

	if (pos < ENCOMSP_ORDER_HEADER_SIZE)

		return ERROR_INVALID_DATA;

	beg = pos - ENCOMSP_ORDER_HEADER_SIZE;

	CopyMemory(&pdu, header, sizeof(ENCOMSP_ORDER_HEADER));

	if (Stream_GetRemainingLength(s) < 10)

	{

		WLog_ERR(TAG, "Not enough data!");

		return ERROR_INVALID_DATA;

	}

	Stream_Read_UINT16(s, pdu.Flags); /* Flags (2 bytes) */

	Stream_Read_UINT32(s, pdu.AppId); /* AppId (4 bytes) */

	Stream_Read_UINT32(s, pdu.WndId); /* WndId (4 bytes) */

	if ((error = encomsp_read_unicode_string(s, &(pdu.Name))))

	{

		WLog_ERR(TAG, "encomsp_read_unicode_string failed with error %" PRIu32 "", error);

		return error;

	}

	end = Stream_GetPosition(s);

	if ((beg + header->Length) < end)

	{

		WLog_ERR(TAG, "Not enough data!");

		return ERROR_INVALID_DATA;

	}

	if ((beg + header->Length) > end)

	{

		if (Stream_GetRemainingLength(s) < (size_t)((beg + header->Length) - end))

		{

			WLog_ERR(TAG, "Not enough data!");

			return ERROR_INVALID_DATA;

		}

		Stream_SetPosition(s, (beg + header->Length));

	}

	IFCALLRET(context->WindowCreated, error, context, &pdu);

	if (error)

		WLog_ERR(TAG, "context->WindowCreated failed with error %" PRIu32 "", error);

	return error;

}

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT encomsp_recv_window_removed_pdu(encomspPlugin* encomsp, wStream* s,

                                            const ENCOMSP_ORDER_HEADER* header)

{

	size_t beg, end, pos;

	EncomspClientContext* context;

	ENCOMSP_WINDOW_REMOVED_PDU pdu;

	UINT error = CHANNEL_RC_OK;

	context = encomsp_get_client_interface(encomsp);

	if (!context)

		return ERROR_INVALID_HANDLE;

	pos = Stream_GetPosition(s);

	if (pos < ENCOMSP_ORDER_HEADER_SIZE)

		return ERROR_INVALID_DATA;

	beg = pos - ENCOMSP_ORDER_HEADER_SIZE;

	CopyMemory(&pdu, header, sizeof(ENCOMSP_ORDER_HEADER));

	if (Stream_GetRemainingLength(s) < 4)

	{

		WLog_ERR(TAG, "Not enough data!");

		return ERROR_INVALID_DATA;

	}

	Stream_Read_UINT32(s, pdu.WndId); /* WndId (4 bytes) */

	end = Stream_GetPosition(s);

	if ((beg + header->Length) < end)

	{

		WLog_ERR(TAG, "Not enough data!");

		return ERROR_INVALID_DATA;

	}

	if ((beg + header->Length) > end)

	{

		if (Stream_GetRemainingLength(s) < (size_t)((beg + header->Length) - end))

		{

			WLog_ERR(TAG, "Not enough data!");

			return ERROR_INVALID_DATA;

		}

		Stream_SetPosition(s, (beg + header->Length));

	}

	IFCALLRET(context->WindowRemoved, error, context, &pdu);

	if (error)

		WLog_ERR(TAG, "context->WindowRemoved failed with error %" PRIu32 "", error);

	return error;

}

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT encomsp_recv_show_window_pdu(encomspPlugin* encomsp, wStream* s,

                                         const ENCOMSP_ORDER_HEADER* header)

{

	size_t beg, end, pos;

	EncomspClientContext* context;

	ENCOMSP_SHOW_WINDOW_PDU pdu;

	UINT error = CHANNEL_RC_OK;

	context = encomsp_get_client_interface(encomsp);

	if (!context)

		return ERROR_INVALID_HANDLE;

	pos = Stream_GetPosition(s);

	if (pos < ENCOMSP_ORDER_HEADER_SIZE)

		return ERROR_INVALID_DATA;

	beg = pos - ENCOMSP_ORDER_HEADER_SIZE;

	CopyMemory(&pdu, header, sizeof(ENCOMSP_ORDER_HEADER));

	if (Stream_GetRemainingLength(s) < 4)

	{

		WLog_ERR(TAG, "Not enough data!");

		return ERROR_INVALID_DATA;

	}

	Stream_Read_UINT32(s, pdu.WndId); /* WndId (4 bytes) */

	end = Stream_GetPosition(s);

	if ((beg + header->Length) < end)

	{

		WLog_ERR(TAG, "Not enough data!");

		return ERROR_INVALID_DATA;

	}

	if ((beg + header->Length) > end)

	{

		if (Stream_GetRemainingLength(s) < (size_t)((beg + header->Length) - end))

		{

			WLog_ERR(TAG, "Not enough data!");

			return ERROR_INVALID_DATA;

		}

		Stream_SetPosition(s, (beg + header->Length));

	}

	IFCALLRET(context->ShowWindow, error, context, &pdu);

	if (error)

		WLog_ERR(TAG, "context->ShowWindow failed with error %" PRIu32 "", error);

	return error;

}

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT encomsp_recv_participant_created_pdu(encomspPlugin* encomsp, wStream* s,

                                                 const ENCOMSP_ORDER_HEADER* header)

{

	size_t beg, end, pos;

	EncomspClientContext* context;

	ENCOMSP_PARTICIPANT_CREATED_PDU pdu;

	UINT error;

	context = encomsp_get_client_interface(encomsp);

	if (!context)

		return ERROR_INVALID_HANDLE;

	pos = Stream_GetPosition(s);

	if (pos < ENCOMSP_ORDER_HEADER_SIZE)

		return ERROR_INVALID_DATA;

	beg = pos - ENCOMSP_ORDER_HEADER_SIZE;

	CopyMemory(&pdu, header, sizeof(ENCOMSP_ORDER_HEADER));

	if (Stream_GetRemainingLength(s) < 10)

	{

		WLog_ERR(TAG, "Not enough data!");

		return ERROR_INVALID_DATA;

	}

	Stream_Read_UINT32(s, pdu.ParticipantId); /* ParticipantId (4 bytes) */

	Stream_Read_UINT32(s, pdu.GroupId);       /* GroupId (4 bytes) */

	Stream_Read_UINT16(s, pdu.Flags);         /* Flags (2 bytes) */

	if ((error = encomsp_read_unicode_string(s, &(pdu.FriendlyName))))

	{

		WLog_ERR(TAG, "encomsp_read_unicode_string failed with error %" PRIu32 "", error);

		return error;

	}

	end = Stream_GetPosition(s);

	if ((beg + header->Length) < end)

	{

		WLog_ERR(TAG, "Not enough data!");

		return ERROR_INVALID_DATA;

	}

	if ((beg + header->Length) > end)

	{

		if (Stream_GetRemainingLength(s) < (size_t)((beg + header->Length) - end))

		{

			WLog_ERR(TAG, "Not enough data!");

			return ERROR_INVALID_DATA;

		}

		Stream_SetPosition(s, (beg + header->Length));

	}

	IFCALLRET(context->ParticipantCreated, error, context, &pdu);

	if (error)

		WLog_ERR(TAG, "context->ParticipantCreated failed with error %" PRIu32 "", error);

	return error;

}

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT encomsp_recv_participant_removed_pdu(encomspPlugin* encomsp, wStream* s,

                                                 const ENCOMSP_ORDER_HEADER* header)

{

	size_t beg, end;

	EncomspClientContext* context;

	ENCOMSP_PARTICIPANT_REMOVED_PDU pdu;

	UINT error = CHANNEL_RC_OK;

	context = encomsp_get_client_interface(encomsp);

	if (!context)

		return ERROR_INVALID_HANDLE;

	if (Stream_GetRemainingLength(s) < 12)

	{

		WLog_ERR(TAG, "Not enough data!");

		return ERROR_INVALID_DATA;

	}

	beg = (Stream_GetPosition(s)) - ENCOMSP_ORDER_HEADER_SIZE;

	CopyMemory(&pdu, header, sizeof(ENCOMSP_ORDER_HEADER));

	Stream_Read_UINT32(s, pdu.ParticipantId); /* ParticipantId (4 bytes) */

	Stream_Read_UINT32(s, pdu.DiscType);      /* DiscType (4 bytes) */

	Stream_Read_UINT32(s, pdu.DiscCode);      /* DiscCode (4 bytes) */

	end = Stream_GetPosition(s);

	if ((beg + header->Length) < end)

	{

		WLog_ERR(TAG, "Not enough data!");

		return ERROR_INVALID_DATA;

	}

	if ((beg + header->Length) > end)

	{

		if (Stream_GetRemainingLength(s) < (size_t)((beg + header->Length) - end))

		{

			WLog_ERR(TAG, "Not enough data!");

			return ERROR_INVALID_DATA;

		}

		Stream_SetPosition(s, (beg + header->Length));

	}

	IFCALLRET(context->ParticipantRemoved, error, context, &pdu);

	if (error)

		WLog_ERR(TAG, "context->ParticipantRemoved failed with error %" PRIu32 "", error);

	return error;

}

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT encomsp_recv_change_participant_control_level_pdu(encomspPlugin* encomsp, wStream* s,

                                                              const ENCOMSP_ORDER_HEADER* header)

{

	size_t beg, end, pos;

	EncomspClientContext* context;

	ENCOMSP_CHANGE_PARTICIPANT_CONTROL_LEVEL_PDU pdu;

	UINT error = CHANNEL_RC_OK;

	context = encomsp_get_client_interface(encomsp);

	if (!context)

		return ERROR_INVALID_HANDLE;

	pos = Stream_GetPosition(s);

	if (pos < ENCOMSP_ORDER_HEADER_SIZE)

		return ERROR_INVALID_DATA;

	beg = pos - ENCOMSP_ORDER_HEADER_SIZE;

	CopyMemory(&pdu, header, sizeof(ENCOMSP_ORDER_HEADER));

	if (Stream_GetRemainingLength(s) < 6)

	{

		WLog_ERR(TAG, "Not enough data!");

		return ERROR_INVALID_DATA;

	}

	Stream_Read_UINT16(s, pdu.Flags);         /* Flags (2 bytes) */

	Stream_Read_UINT32(s, pdu.ParticipantId); /* ParticipantId (4 bytes) */

	end = Stream_GetPosition(s);

	if ((beg + header->Length) < end)

	{

		WLog_ERR(TAG, "Not enough data!");

		return ERROR_INVALID_DATA;

	}

	if ((beg + header->Length) > end)

	{

		if (Stream_GetRemainingLength(s) < (size_t)((beg + header->Length) - end))

		{

			WLog_ERR(TAG, "Not enough data!");

			return ERROR_INVALID_DATA;

		}

		Stream_SetPosition(s, (beg + header->Length));

	}

	IFCALLRET(context->ChangeParticipantControlLevel, error, context, &pdu);

	if (error)

		WLog_ERR(TAG, "context->ChangeParticipantControlLevel failed with error %" PRIu32 "",

		         error);

	return error;

}

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT encomsp_send_change_participant_control_level_pdu(

    EncomspClientContext* context, const ENCOMSP_CHANGE_PARTICIPANT_CONTROL_LEVEL_PDU* pdu)

{

	wStream* s;

	encomspPlugin* encomsp;

	UINT error;

	ENCOMSP_ORDER_HEADER header;

	encomsp = (encomspPlugin*)context->handle;

	header.Type = ODTYPE_PARTICIPANT_CTRL_CHANGED;

	header.Length = ENCOMSP_ORDER_HEADER_SIZE + 6;

	s = Stream_New(NULL, header.Length);

	if (!s)

	{

		WLog_ERR(TAG, "Stream_New failed!");

		return CHANNEL_RC_NO_MEMORY;

	}

	if ((error = encomsp_write_header(s, &header)))

	{

		WLog_ERR(TAG, "encomsp_write_header failed with error %" PRIu32 "!", error);

		return error;

	}

	Stream_Write_UINT16(s, pdu->Flags);         /* Flags (2 bytes) */

	Stream_Write_UINT32(s, pdu->ParticipantId); /* ParticipantId (4 bytes) */

	Stream_SealLength(s);

	return encomsp_virtual_channel_write(encomsp, s);

}

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT encomsp_recv_graphics_stream_paused_pdu(encomspPlugin* encomsp, wStream* s,

                                                    const ENCOMSP_ORDER_HEADER* header)

{

	size_t beg, end, pos;

	EncomspClientContext* context;

	ENCOMSP_GRAPHICS_STREAM_PAUSED_PDU pdu;

	UINT error = CHANNEL_RC_OK;

	context = encomsp_get_client_interface(encomsp);

	if (!context)

		return ERROR_INVALID_HANDLE;

	pos = Stream_GetPosition(s);

	if (pos < ENCOMSP_ORDER_HEADER_SIZE)

		return ERROR_INVALID_DATA;

	beg = pos - ENCOMSP_ORDER_HEADER_SIZE;

	CopyMemory(&pdu, header, sizeof(ENCOMSP_ORDER_HEADER));

	end = Stream_GetPosition(s);

	if ((beg + header->Length) < end)

	{

		WLog_ERR(TAG, "Not enough data!");

		return ERROR_INVALID_DATA;

	}

	if ((beg + header->Length) > end)

	{

		if (Stream_GetRemainingLength(s) < (size_t)((beg + header->Length) - end))

		{

			WLog_ERR(TAG, "Not enough data!");

			return ERROR_INVALID_DATA;

		}

		Stream_SetPosition(s, (beg + header->Length));

	}

	IFCALLRET(context->GraphicsStreamPaused, error, context, &pdu);

	if (error)

		WLog_ERR(TAG, "context->GraphicsStreamPaused failed with error %" PRIu32 "", error);

	return error;

}

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT encomsp_recv_graphics_stream_resumed_pdu(encomspPlugin* encomsp, wStream* s,

                                                     const ENCOMSP_ORDER_HEADER* header)

{

	size_t beg, end, pos;

	EncomspClientContext* context;

	ENCOMSP_GRAPHICS_STREAM_RESUMED_PDU pdu;

	UINT error = CHANNEL_RC_OK;

	context = encomsp_get_client_interface(encomsp);

	if (!context)

		return ERROR_INVALID_HANDLE;

	pos = Stream_GetPosition(s);

	if (pos < ENCOMSP_ORDER_HEADER_SIZE)

		return ERROR_INVALID_DATA;

	beg = pos - ENCOMSP_ORDER_HEADER_SIZE;

	CopyMemory(&pdu, header, sizeof(ENCOMSP_ORDER_HEADER));

	end = Stream_GetPosition(s);

	if ((beg + header->Length) < end)

	{

		WLog_ERR(TAG, "Not enough data!");

		return ERROR_INVALID_DATA;

	}

	if ((beg + header->Length) > end)

	{

		if (Stream_GetRemainingLength(s) < (size_t)((beg + header->Length) - end))

		{

			WLog_ERR(TAG, "Not enough data!");

			return ERROR_INVALID_DATA;

		}

		Stream_SetPosition(s, (beg + header->Length));

	}

	IFCALLRET(context->GraphicsStreamResumed, error, context, &pdu);

	if (error)

		WLog_ERR(TAG, "context->GraphicsStreamResumed failed with error %" PRIu32 "", error);

	return error;

}

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT encomsp_process_receive(encomspPlugin* encomsp, wStream* s)

{

	UINT error = CHANNEL_RC_OK;

	ENCOMSP_ORDER_HEADER header;

	while (Stream_GetRemainingLength(s) > 0)

	{

		if ((error = encomsp_read_header(s, &header)))

		{

			WLog_ERR(TAG, "encomsp_read_header failed with error %" PRIu32 "!", error);

			return error;

		}

		// WLog_DBG(TAG, "EncomspReceive: Type: %"PRIu16" Length: %"PRIu16"", header.Type,

		// header.Length);

		switch (header.Type)

		{

			case ODTYPE_FILTER_STATE_UPDATED:

				if ((error = encomsp_recv_filter_updated_pdu(encomsp, s, &header)))

				{

					WLog_ERR(TAG, "encomsp_recv_filter_updated_pdu failed with error %" PRIu32 "!",

					         error);

					return error;

				}

				break;

			case ODTYPE_APP_REMOVED:

				if ((error = encomsp_recv_application_removed_pdu(encomsp, s, &header)))

				{

					WLog_ERR(TAG,

					         "encomsp_recv_application_removed_pdu failed with error %" PRIu32 "!",

					         error);

					return error;

				}

				break;

			case ODTYPE_APP_CREATED:

				if ((error = encomsp_recv_application_created_pdu(encomsp, s, &header)))

				{

					WLog_ERR(TAG,

					         "encomsp_recv_application_removed_pdu failed with error %" PRIu32 "!",

					         error);

					return error;

				}

				break;

			case ODTYPE_WND_REMOVED: