/**

 * FreeRDP: A Remote Desktop Protocol Implementation

 * Device Redirection Virtual Channel Extension

 *

 * Copyright 2014 Dell Software <Mike.McDonald@software.dell.com>

 * Copyright 2013 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/nt.h>

#include <winpr/print.h>

#include <winpr/stream.h>

#include <freerdp/channels/log.h>

#include "rdpdr_main.h"

#define TAG "rdpdr.server"

static UINT32 g_ClientId = 0;

static RDPDR_IRP* rdpdr_server_irp_new()

{

	RDPDR_IRP* irp;

	irp = (RDPDR_IRP*)calloc(1, sizeof(RDPDR_IRP));

	return irp;

}

static void rdpdr_server_irp_free(RDPDR_IRP* irp)

{

	free(irp);

}

static BOOL rdpdr_server_enqueue_irp(RdpdrServerContext* context, RDPDR_IRP* irp)

{

	return ListDictionary_Add(context->priv->IrpList, (void*)(size_t)irp->CompletionId, irp);

}

static RDPDR_IRP* rdpdr_server_dequeue_irp(RdpdrServerContext* context, UINT32 completionId)

{

	RDPDR_IRP* irp;

	irp = (RDPDR_IRP*)ListDictionary_Remove(context->priv->IrpList, (void*)(size_t)completionId);

	return irp;

}

/**

 * Function description

 *

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

 */

static UINT rdpdr_server_send_announce_request(RdpdrServerContext* context)

{

	wStream* s;

	BOOL status;

	RDPDR_HEADER header;

	ULONG written;

	WLog_DBG(TAG, "RdpdrServerSendAnnounceRequest");

	header.Component = RDPDR_CTYP_CORE;

	header.PacketId = PAKID_CORE_SERVER_ANNOUNCE;

	s = Stream_New(NULL, RDPDR_HEADER_LENGTH + 8);

	if (!s)

	{

		WLog_ERR(TAG, "Stream_New failed!");

		return CHANNEL_RC_NO_MEMORY;

	}

	Stream_Write_UINT16(s, header.Component);            /* Component (2 bytes) */

	Stream_Write_UINT16(s, header.PacketId);             /* PacketId (2 bytes) */

	Stream_Write_UINT16(s, context->priv->VersionMajor); /* VersionMajor (2 bytes) */

	Stream_Write_UINT16(s, context->priv->VersionMinor); /* VersionMinor (2 bytes) */

	Stream_Write_UINT32(s, context->priv->ClientId);     /* ClientId (4 bytes) */

	Stream_SealLength(s);

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

	status = WTSVirtualChannelWrite(context->priv->ChannelHandle, (PCHAR)Stream_Buffer(s),

	                                Stream_Length(s), &written);

	Stream_Free(s, TRUE);

	return status ? CHANNEL_RC_OK : ERROR_INTERNAL_ERROR;

}

/**

 * Function description

 *

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

 */

static UINT rdpdr_server_receive_announce_response(RdpdrServerContext* context, wStream* s,

                                                   RDPDR_HEADER* header)

{

	UINT32 ClientId;

	UINT16 VersionMajor;

	UINT16 VersionMinor;

	if (Stream_GetRemainingLength(s) < 8)

	{

		WLog_ERR(TAG, "not enough data in stream!");

		return ERROR_INVALID_DATA;

	}

	Stream_Read_UINT16(s, VersionMajor); /* VersionMajor (2 bytes) */

	Stream_Read_UINT16(s, VersionMinor); /* VersionMinor (2 bytes) */

	Stream_Read_UINT32(s, ClientId);     /* ClientId (4 bytes) */

	WLog_DBG(TAG,

	         "Client Announce Response: VersionMajor: 0x%08" PRIX16 " VersionMinor: 0x%04" PRIX16

	         " ClientId: 0x%08" PRIX32 "",

	         VersionMajor, VersionMinor, ClientId);

	context->priv->ClientId = ClientId;

	return CHANNEL_RC_OK;

}

/**

 * Function description

 *

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

 */

static UINT rdpdr_server_receive_client_name_request(RdpdrServerContext* context, wStream* s,

                                                     RDPDR_HEADER* header)

{

	UINT32 UnicodeFlag;

	UINT32 ComputerNameLen;

	if (Stream_GetRemainingLength(s) < 12)

	{

		WLog_ERR(TAG, "not enough data in stream!");

		return ERROR_INVALID_DATA;

	}

	Stream_Read_UINT32(s, UnicodeFlag);     /* UnicodeFlag (4 bytes) */

	Stream_Seek_UINT32(s);                  /* CodePage (4 bytes), MUST be set to zero */

	Stream_Read_UINT32(s, ComputerNameLen); /* ComputerNameLen (4 bytes) */

	/* UnicodeFlag is either 0 or 1, the other 31 bits must be ignored.

	 */

	UnicodeFlag = UnicodeFlag & 0x00000001;

	/**

	 * Caution: ComputerNameLen is given *bytes*,

	 * not in characters, including the NULL terminator!

	 */

	if (UnicodeFlag)

	{

		if ((ComputerNameLen % 2) || ComputerNameLen > 512 || ComputerNameLen < 2)

		{

			WLog_ERR(TAG, "invalid unicode computer name length: %" PRIu32 "", ComputerNameLen);

			return ERROR_INVALID_DATA;

		}

	}

	else

	{

		if (ComputerNameLen > 256 || ComputerNameLen < 1)

		{

			WLog_ERR(TAG, "invalid ascii computer name length: %" PRIu32 "", ComputerNameLen);

			return ERROR_INVALID_DATA;

		}

	}

	if (Stream_GetRemainingLength(s) < ComputerNameLen)

	{

		WLog_ERR(TAG, "not enough data in stream!");

		return ERROR_INVALID_DATA;

	}

	/* ComputerName must be null terminated, check if it really is */

	if (Stream_Pointer(s)[ComputerNameLen - 1] ||

	    (UnicodeFlag && Stream_Pointer(s)[ComputerNameLen - 2]))

	{

		WLog_ERR(TAG, "computer name must be null terminated");

		return ERROR_INVALID_DATA;

	}

	if (context->priv->ClientComputerName)

	{

		free(context->priv->ClientComputerName);

		context->priv->ClientComputerName = NULL;

	}

	if (UnicodeFlag)

	{

		if (ConvertFromUnicode(CP_UTF8, 0, (WCHAR*)Stream_Pointer(s), -1,

		                       &(context->priv->ClientComputerName), 0, NULL, NULL) < 1)

		{

			WLog_ERR(TAG, "failed to convert client computer name");

			return ERROR_INVALID_DATA;

		}

	}

	else

	{

		context->priv->ClientComputerName = _strdup((char*)Stream_Pointer(s));

		if (!context->priv->ClientComputerName)

		{

			WLog_ERR(TAG, "failed to duplicate client computer name");

			return CHANNEL_RC_NO_MEMORY;

		}

	}

	Stream_Seek(s, ComputerNameLen);

	WLog_DBG(TAG, "ClientComputerName: %s", context->priv->ClientComputerName);

	return CHANNEL_RC_OK;

}

/**

 * Function description

 *

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

 */

static UINT rdpdr_server_read_capability_set_header(wStream* s, RDPDR_CAPABILITY_HEADER* header)

{

	if (Stream_GetRemainingLength(s) < 8)

	{

		WLog_ERR(TAG, "not enough data in stream!");

		return ERROR_INVALID_DATA;

	}

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

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

	Stream_Read_UINT32(s, header->Version);          /* Version (4 bytes) */

	return CHANNEL_RC_OK;

}

/**

 * Function description

 *

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

 */

static UINT rdpdr_server_write_capability_set_header(wStream* s, RDPDR_CAPABILITY_HEADER* header)

{

	if (!Stream_EnsureRemainingCapacity(s, 8))

	{

		WLog_ERR(TAG, "not enough data in stream!");

		return ERROR_INVALID_DATA;

	}

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

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

	Stream_Write_UINT32(s, header->Version);          /* Version (4 bytes) */

	return CHANNEL_RC_OK;

}

/**

 * Function description

 *

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

 */

static UINT rdpdr_server_read_general_capability_set(RdpdrServerContext* context, wStream* s,

                                                     RDPDR_CAPABILITY_HEADER* header)

{

	UINT32 ioCode1;

	UINT32 extraFlags1;

	UINT32 extendedPdu;

	UINT16 VersionMajor;

	UINT16 VersionMinor;

	UINT32 SpecialTypeDeviceCap;

	if (Stream_GetRemainingLength(s) < 32)

	{

		WLog_ERR(TAG, "not enough data in stream!");

		return ERROR_INVALID_DATA;

	}

	Stream_Seek_UINT32(s);               /* osType (4 bytes), ignored on receipt */

	Stream_Seek_UINT32(s);               /* osVersion (4 bytes), unused and must be set to zero */

	Stream_Read_UINT16(s, VersionMajor); /* protocolMajorVersion (2 bytes) */

	Stream_Read_UINT16(s, VersionMinor); /* protocolMinorVersion (2 bytes) */

	Stream_Read_UINT32(s, ioCode1);      /* ioCode1 (4 bytes) */

	Stream_Seek_UINT32(s); /* ioCode2 (4 bytes), must be set to zero, reserved for future use */

	Stream_Read_UINT32(s, extendedPdu); /* extendedPdu (4 bytes) */

	Stream_Read_UINT32(s, extraFlags1); /* extraFlags1 (4 bytes) */

	Stream_Seek_UINT32(s); /* extraFlags2 (4 bytes), must be set to zero, reserved for future use */

	if (header->Version == GENERAL_CAPABILITY_VERSION_02)

	{

		if (Stream_GetRemainingLength(s) < 4)

		{

			WLog_ERR(TAG, "not enough data in stream!");

			return ERROR_INVALID_DATA;

		}

		Stream_Read_UINT32(s, SpecialTypeDeviceCap); /* SpecialTypeDeviceCap (4 bytes) */

	}

	context->priv->UserLoggedOnPdu = (extendedPdu & RDPDR_USER_LOGGEDON_PDU) ? TRUE : FALSE;

	return CHANNEL_RC_OK;

}

/**

 * Function description

 *

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

 */

static UINT rdpdr_server_write_general_capability_set(RdpdrServerContext* context, wStream* s)

{

	UINT32 ioCode1;

	UINT32 extendedPdu;

	UINT32 extraFlags1;

	UINT32 SpecialTypeDeviceCap;

	RDPDR_CAPABILITY_HEADER header;

	header.CapabilityType = CAP_GENERAL_TYPE;

	header.CapabilityLength = RDPDR_CAPABILITY_HEADER_LENGTH + 36;

	header.Version = GENERAL_CAPABILITY_VERSION_02;

	ioCode1 = 0;

	ioCode1 |= RDPDR_IRP_MJ_CREATE;                   /* always set */

	ioCode1 |= RDPDR_IRP_MJ_CLEANUP;                  /* always set */

	ioCode1 |= RDPDR_IRP_MJ_CLOSE;                    /* always set */

	ioCode1 |= RDPDR_IRP_MJ_READ;                     /* always set */

	ioCode1 |= RDPDR_IRP_MJ_WRITE;                    /* always set */

	ioCode1 |= RDPDR_IRP_MJ_FLUSH_BUFFERS;            /* always set */

	ioCode1 |= RDPDR_IRP_MJ_SHUTDOWN;                 /* always set */

	ioCode1 |= RDPDR_IRP_MJ_DEVICE_CONTROL;           /* always set */

	ioCode1 |= RDPDR_IRP_MJ_QUERY_VOLUME_INFORMATION; /* always set */

	ioCode1 |= RDPDR_IRP_MJ_SET_VOLUME_INFORMATION;   /* always set */

	ioCode1 |= RDPDR_IRP_MJ_QUERY_INFORMATION;        /* always set */

	ioCode1 |= RDPDR_IRP_MJ_SET_INFORMATION;          /* always set */

	ioCode1 |= RDPDR_IRP_MJ_DIRECTORY_CONTROL;        /* always set */

	ioCode1 |= RDPDR_IRP_MJ_LOCK_CONTROL;             /* always set */

	ioCode1 |= RDPDR_IRP_MJ_QUERY_SECURITY;           /* optional */

	ioCode1 |= RDPDR_IRP_MJ_SET_SECURITY;             /* optional */

	extendedPdu = 0;

	extendedPdu |= RDPDR_CLIENT_DISPLAY_NAME_PDU; /* always set */

	extendedPdu |= RDPDR_DEVICE_REMOVE_PDUS;      /* optional */

	if (context->priv->UserLoggedOnPdu)

		extendedPdu |= RDPDR_USER_LOGGEDON_PDU; /* optional */

	extraFlags1 = 0;

	extraFlags1 |= ENABLE_ASYNCIO; /* optional */

	SpecialTypeDeviceCap = 0;

	if (!Stream_EnsureRemainingCapacity(s, header.CapabilityLength))

	{

		WLog_ERR(TAG, "Stream_EnsureRemainingCapacity failed!");

		return CHANNEL_RC_NO_MEMORY;

	}

	rdpdr_server_write_capability_set_header(s, &header);

	Stream_Write_UINT32(s, 0); /* osType (4 bytes), ignored on receipt */

	Stream_Write_UINT32(s, 0); /* osVersion (4 bytes), unused and must be set to zero */

	Stream_Write_UINT16(s, context->priv->VersionMajor); /* protocolMajorVersion (2 bytes) */

	Stream_Write_UINT16(s, context->priv->VersionMinor); /* protocolMinorVersion (2 bytes) */

	Stream_Write_UINT32(s, ioCode1);                     /* ioCode1 (4 bytes) */

	Stream_Write_UINT32(s, 0); /* ioCode2 (4 bytes), must be set to zero, reserved for future use */

	Stream_Write_UINT32(s, extendedPdu); /* extendedPdu (4 bytes) */

	Stream_Write_UINT32(s, extraFlags1); /* extraFlags1 (4 bytes) */

	Stream_Write_UINT32(

	    s, 0); /* extraFlags2 (4 bytes), must be set to zero, reserved for future use */

	Stream_Write_UINT32(s, SpecialTypeDeviceCap); /* SpecialTypeDeviceCap (4 bytes) */

	return CHANNEL_RC_OK;

}

/**

 * Function description

 *

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

 */

static UINT rdpdr_server_read_printer_capability_set(RdpdrServerContext* context, wStream* s,

                                                     RDPDR_CAPABILITY_HEADER* header)

{

	return CHANNEL_RC_OK;

}

/**

 * Function description

 *

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

 */

static UINT rdpdr_server_write_printer_capability_set(RdpdrServerContext* context, wStream* s)

{

	RDPDR_CAPABILITY_HEADER header;

	header.CapabilityType = CAP_PRINTER_TYPE;

	header.CapabilityLength = RDPDR_CAPABILITY_HEADER_LENGTH;

	header.Version = PRINT_CAPABILITY_VERSION_01;

	if (!Stream_EnsureRemainingCapacity(s, header.CapabilityLength))

	{

		WLog_ERR(TAG, "Stream_EnsureRemainingCapacity failed!");

		return CHANNEL_RC_NO_MEMORY;

	}

	return rdpdr_server_write_capability_set_header(s, &header);

}

/**

 * Function description

 *

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

 */

static UINT rdpdr_server_read_port_capability_set(RdpdrServerContext* context, wStream* s,

                                                  RDPDR_CAPABILITY_HEADER* header)

{

	return CHANNEL_RC_OK;

}

/**

 * Function description

 *

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

 */

static UINT rdpdr_server_write_port_capability_set(RdpdrServerContext* context, wStream* s)

{

	RDPDR_CAPABILITY_HEADER header;

	header.CapabilityType = CAP_PORT_TYPE;

	header.CapabilityLength = RDPDR_CAPABILITY_HEADER_LENGTH;

	header.Version = PORT_CAPABILITY_VERSION_01;

	if (!Stream_EnsureRemainingCapacity(s, header.CapabilityLength))

	{

		WLog_ERR(TAG, "Stream_EnsureRemainingCapacity failed!");

		return CHANNEL_RC_NO_MEMORY;

	}

	return rdpdr_server_write_capability_set_header(s, &header);

}

/**

 * Function description

 *

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

 */

static UINT rdpdr_server_read_drive_capability_set(RdpdrServerContext* context, wStream* s,

                                                   RDPDR_CAPABILITY_HEADER* header)

{

	return CHANNEL_RC_OK;

}

/**

 * Function description

 *

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

 */

static UINT rdpdr_server_write_drive_capability_set(RdpdrServerContext* context, wStream* s)

{

	RDPDR_CAPABILITY_HEADER header;

	header.CapabilityType = CAP_DRIVE_TYPE;

	header.CapabilityLength = RDPDR_CAPABILITY_HEADER_LENGTH;

	header.Version = DRIVE_CAPABILITY_VERSION_02;

	if (!Stream_EnsureRemainingCapacity(s, header.CapabilityLength))

	{

		WLog_ERR(TAG, "Stream_EnsureRemainingCapacity failed!");

		return CHANNEL_RC_NO_MEMORY;

	}

	return rdpdr_server_write_capability_set_header(s, &header);

}

/**

 * Function description

 *

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

 */

static UINT rdpdr_server_read_smartcard_capability_set(RdpdrServerContext* context, wStream* s,

                                                       RDPDR_CAPABILITY_HEADER* header)

{

	return CHANNEL_RC_OK;

}

/**

 * Function description

 *

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

 */

static UINT rdpdr_server_write_smartcard_capability_set(RdpdrServerContext* context, wStream* s)

{

	RDPDR_CAPABILITY_HEADER header;

	header.CapabilityType = CAP_SMARTCARD_TYPE;

	header.CapabilityLength = RDPDR_CAPABILITY_HEADER_LENGTH;

	header.Version = SMARTCARD_CAPABILITY_VERSION_01;

	if (!Stream_EnsureRemainingCapacity(s, header.CapabilityLength))

	{

		WLog_ERR(TAG, "Stream_EnsureRemainingCapacity failed!");

		return CHANNEL_RC_OK;

	}

	return rdpdr_server_write_capability_set_header(s, &header);

}

/**

 * Function description

 *

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

 */

static UINT rdpdr_server_send_core_capability_request(RdpdrServerContext* context)

{

	wStream* s;

	BOOL status;

	RDPDR_HEADER header;

	UINT16 numCapabilities;

	ULONG written;

	UINT error;

	WLog_DBG(TAG, "RdpdrServerSendCoreCapabilityRequest");

	header.Component = RDPDR_CTYP_CORE;

	header.PacketId = PAKID_CORE_SERVER_CAPABILITY;

	numCapabilities = 1;

	if (context->supportsDrives)

		numCapabilities++;

	if (context->supportsPorts)

		numCapabilities++;

	if (context->supportsPrinters)

		numCapabilities++;

	if (context->supportsSmartcards)

		numCapabilities++;

	s = Stream_New(NULL, RDPDR_HEADER_LENGTH + 512);

	if (!s)

	{

		WLog_ERR(TAG, "Stream_New failed!");

		return CHANNEL_RC_NO_MEMORY;

	}

	Stream_Write_UINT16(s, header.Component); /* Component (2 bytes) */

	Stream_Write_UINT16(s, header.PacketId);  /* PacketId (2 bytes) */

	Stream_Write_UINT16(s, numCapabilities);  /* numCapabilities (2 bytes) */

	Stream_Write_UINT16(s, 0);                /* Padding (2 bytes) */

	if ((error = rdpdr_server_write_general_capability_set(context, s)))

	{

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

		         error);

		goto out;

	}

	if (context->supportsDrives)

	{

		if ((error = rdpdr_server_write_drive_capability_set(context, s)))

		{

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

			         error);

			goto out;

		}

	}

	if (context->supportsPorts)

	{

		if ((error = rdpdr_server_write_port_capability_set(context, s)))

		{

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

			         error);

			goto out;

		}

	}

	if (context->supportsPrinters)

	{

		if ((error = rdpdr_server_write_printer_capability_set(context, s)))

		{

			WLog_ERR(TAG,

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

			         error);

			goto out;

		}

	}

	if (context->supportsSmartcards)

	{

		if ((error = rdpdr_server_write_smartcard_capability_set(context, s)))

		{

			WLog_ERR(TAG,

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

			         error);

			goto out;

		}

	}

	Stream_SealLength(s);

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

	status = WTSVirtualChannelWrite(context->priv->ChannelHandle, (PCHAR)Stream_Buffer(s),

	                                Stream_Length(s), &written);

	Stream_Free(s, TRUE);

	return status ? CHANNEL_RC_OK : ERROR_INTERNAL_ERROR;

out:

	Stream_Free(s, TRUE);

	return error;

}

/**

 * Function description

 *

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

 */

static UINT rdpdr_server_receive_core_capability_response(RdpdrServerContext* context, wStream* s,

                                                          RDPDR_HEADER* header)

{

	int i;

	UINT status;

	UINT16 numCapabilities;

	RDPDR_CAPABILITY_HEADER capabilityHeader;

	if (Stream_GetRemainingLength(s) < 4)

	{

		WLog_ERR(TAG, "not enough data in stream!");

		return ERROR_INVALID_DATA;

	}

	Stream_Read_UINT16(s, numCapabilities); /* numCapabilities (2 bytes) */

	Stream_Seek_UINT16(s);                  /* Padding (2 bytes) */

	for (i = 0; i < numCapabilities; i++)

	{

		if ((status = rdpdr_server_read_capability_set_header(s, &capabilityHeader)))

		{

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

			         status);

			return status;

		}

		switch (capabilityHeader.CapabilityType)

		{

			case CAP_GENERAL_TYPE:

				if ((status =

				         rdpdr_server_read_general_capability_set(context, s, &capabilityHeader)))

				{

					WLog_ERR(TAG,

					         "rdpdr_server_read_general_capability_set failed with error %" PRIu32

					         "!",

					         status);

					return status;

				}

				break;

			case CAP_PRINTER_TYPE:

				if ((status =

				         rdpdr_server_read_printer_capability_set(context, s, &capabilityHeader)))

				{

					WLog_ERR(TAG,

					         "rdpdr_server_read_printer_capability_set failed with error %" PRIu32

					         "!",

					         status);

					return status;

				}

				break;

			case CAP_PORT_TYPE:

				if ((status = rdpdr_server_read_port_capability_set(context, s, &capabilityHeader)))

				{

					WLog_ERR(TAG,

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

					         status);

					return status;

				}

				break;

			case CAP_DRIVE_TYPE:

				if ((status =

				         rdpdr_server_read_drive_capability_set(context, s, &capabilityHeader)))

				{

					WLog_ERR(TAG,

					         "rdpdr_server_read_drive_capability_set failed with error %" PRIu32

					         "!",

					         status);

					return status;

				}

				break;

			case CAP_SMARTCARD_TYPE:

				if ((status =

				         rdpdr_server_read_smartcard_capability_set(context, s, &capabilityHeader)))

				{

					WLog_ERR(TAG,

					         "rdpdr_server_read_smartcard_capability_set failed with error %" PRIu32

					         "!",

					         status);

					return status;

				}

				break;

			default:

				WLog_DBG(TAG, "Unknown capabilityType %" PRIu16 "",

				         capabilityHeader.CapabilityType);

				Stream_Seek(s, capabilityHeader.CapabilityLength - RDPDR_CAPABILITY_HEADER_LENGTH);

				return ERROR_INVALID_DATA;

				break;

		}

	}

	return CHANNEL_RC_OK;

}

/**

 * Function description

 *

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

 */

static UINT rdpdr_server_send_client_id_confirm(RdpdrServerContext* context)

{

	wStream* s;

	BOOL status;

	RDPDR_HEADER header;

	ULONG written;

	WLog_DBG(TAG, "RdpdrServerSendClientIdConfirm");

	header.Component = RDPDR_CTYP_CORE;

	header.PacketId = PAKID_CORE_CLIENTID_CONFIRM;

	s = Stream_New(NULL, RDPDR_HEADER_LENGTH + 8);

	if (!s)

	{

		WLog_ERR(TAG, "Stream_New failed!");

		return CHANNEL_RC_NO_MEMORY;

	}

	Stream_Write_UINT16(s, header.Component);            /* Component (2 bytes) */

	Stream_Write_UINT16(s, header.PacketId);             /* PacketId (2 bytes) */

	Stream_Write_UINT16(s, context->priv->VersionMajor); /* VersionMajor (2 bytes) */

	Stream_Write_UINT16(s, context->priv->VersionMinor); /* VersionMinor (2 bytes) */

	Stream_Write_UINT32(s, context->priv->ClientId);     /* ClientId (4 bytes) */

	Stream_SealLength(s);

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

	status = WTSVirtualChannelWrite(context->priv->ChannelHandle, (PCHAR)Stream_Buffer(s),

	                                Stream_Length(s), &written);

	Stream_Free(s, TRUE);

	return status ? CHANNEL_RC_OK : ERROR_INTERNAL_ERROR;

}

/**

 * Function description

 *

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

 */

static UINT rdpdr_server_receive_device_list_announce_request(RdpdrServerContext* context,

                                                              wStream* s, RDPDR_HEADER* header)

{

	UINT32 i;

	UINT32 DeviceCount;

	UINT32 DeviceType;

	UINT32 DeviceId;

	char PreferredDosName[9];

	UINT32 DeviceDataLength;

	if (Stream_GetRemainingLength(s) < 4)

	{

		WLog_ERR(TAG, "not enough data in stream!");

		return ERROR_INVALID_DATA;

	}

	Stream_Read_UINT32(s, DeviceCount); /* DeviceCount (4 bytes) */

	WLog_DBG(TAG, "DeviceCount: %" PRIu32 "", DeviceCount);

	for (i = 0; i < DeviceCount; i++)

	{

		ZeroMemory(PreferredDosName, sizeof(PreferredDosName));

		if (Stream_GetRemainingLength(s) < 20)

		{

			WLog_ERR(TAG, "not enough data in stream!");

			return ERROR_INVALID_DATA;

		}

		Stream_Read_UINT32(s, DeviceType);       /* DeviceType (4 bytes) */

		Stream_Read_UINT32(s, DeviceId);         /* DeviceId (4 bytes) */

		Stream_Read(s, PreferredDosName, 8);     /* PreferredDosName (8 bytes) */

		Stream_Read_UINT32(s, DeviceDataLength); /* DeviceDataLength (4 bytes) */

		if (Stream_GetRemainingLength(s) < DeviceDataLength)

		{

			WLog_ERR(TAG, "not enough data in stream!");

			return ERROR_INVALID_DATA;

		}

		WLog_DBG(TAG, "Device %d Name: %s Id: 0x%08" PRIX32 " DataLength: %" PRIu32 "", i,

		         PreferredDosName, DeviceId, DeviceDataLength);

		switch (DeviceType)

		{

			case RDPDR_DTYP_FILESYSTEM:

				if (context->supportsDrives)

				{

					IFCALL(context->OnDriveCreate, context, DeviceId, PreferredDosName);

				}

				break;

			case RDPDR_DTYP_PRINT:

				if (context->supportsPrinters)

				{

					IFCALL(context->OnPrinterCreate, context, DeviceId, PreferredDosName);

				}

				break;

			case RDPDR_DTYP_SERIAL:

			case RDPDR_DTYP_PARALLEL:

				if (context->supportsPorts)

				{

					IFCALL(context->OnPortCreate, context, DeviceId, PreferredDosName);

				}

				break;

			case RDPDR_DTYP_SMARTCARD:

				if (context->supportsSmartcards)

				{

					IFCALL(context->OnSmartcardCreate, context, DeviceId, PreferredDosName);

				}

				break;

			default:

				break;

		}

		Stream_Seek(s, DeviceDataLength);

	}

	return CHANNEL_RC_OK;

}

/**

 * Function description

 *

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

 */

static UINT rdpdr_server_receive_device_list_remove_request(RdpdrServerContext* context, wStream* s,

                                                            RDPDR_HEADER* header)

{

	UINT32 i;

	UINT32 DeviceCount;

	UINT32 DeviceType;

	UINT32 DeviceId;

	if (Stream_GetRemainingLength(s) < 4)

	{

		WLog_ERR(TAG, "not enough data in stream!");

		return ERROR_INVALID_DATA;

	}

	Stream_Read_UINT32(s, DeviceCount); /* DeviceCount (4 bytes) */

	WLog_DBG(TAG, "DeviceCount: %" PRIu32 "", DeviceCount);

	for (i = 0; i < DeviceCount; i++)

	{

		if (Stream_GetRemainingLength(s) < 4)

		{

			WLog_ERR(TAG, "not enough data in stream!");

			return ERROR_INVALID_DATA;

		}

		Stream_Read_UINT32(s, DeviceId); /* DeviceId (4 bytes) */

		WLog_DBG(TAG, "Device %d Id: 0x%08" PRIX32 "", i, DeviceId);

		DeviceType = 0; /* TODO: Save the device type on the announce request. */

		switch (DeviceType)

		{

			case RDPDR_DTYP_FILESYSTEM:

				if (context->supportsDrives)

				{

					IFCALL(context->OnDriveDelete, context, DeviceId);

				}

				break;

			case RDPDR_DTYP_PRINT:

				if (context->supportsPrinters)