/**

 * FreeRDP: A Remote Desktop Protocol Implementation

 * T.124 Generic Conference Control (GCC)

 *

 * Copyright 2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>

 * Copyright 2014 Norbert Federa <norbert.federa@thincast.com>

 * Copyright 2014 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/crypto.h>

#include <freerdp/log.h>

#include "gcc.h"

#include "certificate.h"

#define TAG FREERDP_TAG("core.gcc")

static BOOL gcc_read_client_cluster_data(wStream* s, rdpMcs* mcs, UINT16 blockLength);

static BOOL gcc_read_client_core_data(wStream* s, rdpMcs* mcs, UINT16 blockLength);

static BOOL gcc_read_client_data_blocks(wStream* s, rdpMcs* mcs, int length);

static BOOL gcc_read_server_data_blocks(wStream* s, rdpMcs* mcs, int length);

static BOOL gcc_read_user_data_header(wStream* s, UINT16* type, UINT16* length);

static void gcc_write_user_data_header(wStream* s, UINT16 type, UINT16 length);

static void gcc_write_client_core_data(wStream* s, rdpMcs* mcs);

static BOOL gcc_read_server_core_data(wStream* s, rdpMcs* mcs);

static BOOL gcc_write_server_core_data(wStream* s, rdpMcs* mcs);

static BOOL gcc_read_client_security_data(wStream* s, rdpMcs* mcs, UINT16 blockLength);

static void gcc_write_client_security_data(wStream* s, rdpMcs* mcs);

static BOOL gcc_read_server_security_data(wStream* s, rdpMcs* mcs);

static BOOL gcc_write_server_security_data(wStream* s, rdpMcs* mcs);

static BOOL gcc_read_client_network_data(wStream* s, rdpMcs* mcs, UINT16 blockLength);

static void gcc_write_client_network_data(wStream* s, rdpMcs* mcs);

static BOOL gcc_read_server_network_data(wStream* s, rdpMcs* mcs);

static BOOL gcc_write_server_network_data(wStream* s, rdpMcs* mcs);

static void gcc_write_client_cluster_data(wStream* s, rdpMcs* mcs);

static BOOL gcc_read_client_monitor_data(wStream* s, rdpMcs* mcs, UINT16 blockLength);

static void gcc_write_client_monitor_data(wStream* s, rdpMcs* mcs);

static BOOL gcc_read_client_monitor_extended_data(wStream* s, rdpMcs* mcs, UINT16 blockLength);

static void gcc_write_client_monitor_extended_data(wStream* s, rdpMcs* mcs);

static BOOL gcc_read_client_message_channel_data(wStream* s, rdpMcs* mcs, UINT16 blockLength);

static void gcc_write_client_message_channel_data(wStream* s, rdpMcs* mcs);

static BOOL gcc_read_server_message_channel_data(wStream* s, rdpMcs* mcs);

static BOOL gcc_write_server_message_channel_data(wStream* s, rdpMcs* mcs);

static BOOL gcc_read_client_multitransport_channel_data(wStream* s, rdpMcs* mcs,

                                                        UINT16 blockLength);

static void gcc_write_client_multitransport_channel_data(wStream* s, rdpMcs* mcs);

static BOOL gcc_read_server_multitransport_channel_data(wStream* s, rdpMcs* mcs);

static void gcc_write_server_multitransport_channel_data(wStream* s, rdpMcs* mcs);

static DWORD rdp_version_common(DWORD serverVersion, DWORD clientVersion)

{

	DWORD version = MIN(serverVersion, clientVersion);

	switch (version)

	{

		case RDP_VERSION_4:

		case RDP_VERSION_5_PLUS:

		case RDP_VERSION_10_0:

		case RDP_VERSION_10_1:

		case RDP_VERSION_10_2:

		case RDP_VERSION_10_3:

		case RDP_VERSION_10_4:

		case RDP_VERSION_10_5:

		case RDP_VERSION_10_6:

		case RDP_VERSION_10_7:

			return version;

		default:

			WLog_ERR(TAG, "Invalid client [%" PRId32 "] and server [%" PRId32 "] versions",

			         serverVersion, clientVersion);

			return version;

	}

}

/**

 * T.124 GCC is defined in:

 *

 * http://www.itu.int/rec/T-REC-T.124-199802-S/en

 * ITU-T T.124 (02/98): Generic Conference Control

 */

/**

 * ConnectData ::= SEQUENCE

 * {

 * 	t124Identifier	Key,

 * 	connectPDU	OCTET_STRING

 * }

 *

 * Key ::= CHOICE

 * {

 * 	object				OBJECT_IDENTIFIER,

 * 	h221NonStandard			H221NonStandardIdentifier

 * }

 *

 * ConnectGCCPDU ::= CHOICE

 * {

 * 	conferenceCreateRequest		ConferenceCreateRequest,

 * 	conferenceCreateResponse	ConferenceCreateResponse,

 * 	conferenceQueryRequest		ConferenceQueryRequest,

 * 	conferenceQueryResponse		ConferenceQueryResponse,

 * 	conferenceJoinRequest		ConferenceJoinRequest,

 *	conferenceJoinResponse		ConferenceJoinResponse,

 *	conferenceInviteRequest		ConferenceInviteRequest,

 *	conferenceInviteResponse	ConferenceInviteResponse,

 *	...

 * }

 *

 * ConferenceCreateRequest ::= SEQUENCE

 * {

 * 	conferenceName			ConferenceName,

 * 	convenerPassword		Password OPTIONAL,

 * 	password			Password OPTIONAL,

 * 	lockedConference		BOOLEAN,

 * 	listedConference		BOOLEAN,

 * 	conductibleConference		BOOLEAN,

 * 	terminationMethod		TerminationMethod,

 * 	conductorPrivileges		SET OF Privilege OPTIONAL,

 * 	conductedPrivileges		SET OF Privilege OPTIONAL,

 * 	nonConductedPrivileges		SET OF Privilege OPTIONAL,

 * 	conferenceDescription		TextString OPTIONAL,

 * 	callerIdentifier		TextString OPTIONAL,

 * 	userData			UserData OPTIONAL,

 * 	...,

 * 	conferencePriority		ConferencePriority OPTIONAL,

 * 	conferenceMode			ConferenceMode OPTIONAL

 * }

 *

 * ConferenceCreateResponse ::= SEQUENCE

 * {

 * 	nodeID				UserID,

 * 	tag				INTEGER,

 * 	result				ENUMERATED

 * 	{

 * 		success				(0),

 * 		userRejected			(1),

 * 		resourcesNotAvailable		(2),

 * 		rejectedForSymmetryBreaking	(3),

 * 		lockedConferenceNotSupported	(4)

 * 	},

 * 	userData			UserData OPTIONAL,

 * 	...

 * }

 *

 * ConferenceName ::= SEQUENCE

 * {

 * 	numeric				SimpleNumericString

 * 	text				SimpleTextString OPTIONAL,

 * 	...

 * }

 *

 * SimpleNumericString ::= NumericString (SIZE (1..255)) (FROM ("0123456789"))

 *

 * UserData ::= SET OF SEQUENCE

 * {

 * 	key				Key,

 * 	value				OCTET_STRING OPTIONAL

 * }

 *

 * H221NonStandardIdentifier ::= OCTET STRING (SIZE (4..255))

 *

 * UserID ::= DynamicChannelID

 *

 * ChannelID ::= INTEGER (1..65535)

 * StaticChannelID ::= INTEGER (1..1000)

 * DynamicChannelID ::= INTEGER (1001..65535)

 *

 */

/*

 * OID = 0.0.20.124.0.1

 * { itu-t(0) recommendation(0) t(20) t124(124) version(0) 1 }

 * v.1 of ITU-T Recommendation T.124 (Feb 1998): "Generic Conference Control"

 */

BYTE t124_02_98_oid[6] = { 0, 0, 20, 124, 0, 1 };

BYTE h221_cs_key[4] = "Duca";

BYTE h221_sc_key[4] = "McDn";

/**

 * Read a GCC Conference Create Request.\n

 * @msdn{cc240836}

 * @param s stream

 * @param settings rdp settings

 */

BOOL gcc_read_conference_create_request(wStream* s, rdpMcs* mcs)

{

	UINT16 length;

	BYTE choice;

	BYTE number;

	BYTE selection;

	/* ConnectData */

	if (!per_read_choice(s, &choice))

		return FALSE;

	if (!per_read_object_identifier(s, t124_02_98_oid))

		return FALSE;

	/* ConnectData::connectPDU (OCTET_STRING) */

	if (!per_read_length(s, &length))

		return FALSE;

	/* ConnectGCCPDU */

	if (!per_read_choice(s, &choice))

		return FALSE;

	if (!per_read_selection(s, &selection))

		return FALSE;

	/* ConferenceCreateRequest::conferenceName */

	if (!per_read_numeric_string(s, 1)) /* ConferenceName::numeric */

		return FALSE;

	if (!per_read_padding(s, 1)) /* padding */

		return FALSE;

	/* UserData (SET OF SEQUENCE) */

	if (!per_read_number_of_sets(s, &number) || number != 1) /* one set of UserData */

		return FALSE;

	if (!per_read_choice(s, &choice) ||

	    choice != 0xC0) /* UserData::value present + select h221NonStandard (1) */

		return FALSE;

	/* h221NonStandard */

	if (!per_read_octet_string(s, h221_cs_key, 4,

	                           4)) /* h221NonStandard, client-to-server H.221 key, "Duca" */

		return FALSE;

	/* userData::value (OCTET_STRING) */

	if (!per_read_length(s, &length))

		return FALSE;

	if (Stream_GetRemainingLength(s) < length)

		return FALSE;

	if (!gcc_read_client_data_blocks(s, mcs, length))

		return FALSE;

	return TRUE;

}

/**

 * Write a GCC Conference Create Request.\n

 * @msdn{cc240836}

 * @param s stream

 * @param user_data client data blocks

 */

void gcc_write_conference_create_request(wStream* s, wStream* userData)

{

	/* ConnectData */

	per_write_choice(s, 0); /* From Key select object (0) of type OBJECT_IDENTIFIER */

	per_write_object_identifier(s, t124_02_98_oid); /* ITU-T T.124 (02/98) OBJECT_IDENTIFIER */

	/* ConnectData::connectPDU (OCTET_STRING) */

	per_write_length(s, Stream_GetPosition(userData) + 14); /* connectPDU length */

	/* ConnectGCCPDU */

	per_write_choice(s, 0);       /* From ConnectGCCPDU select conferenceCreateRequest (0) of type

	                                 ConferenceCreateRequest */

	per_write_selection(s, 0x08); /* select optional userData from ConferenceCreateRequest */

	/* ConferenceCreateRequest::conferenceName */

	per_write_numeric_string(s, (BYTE*)"1", 1, 1); /* ConferenceName::numeric */

	per_write_padding(s, 1);                       /* padding */

	/* UserData (SET OF SEQUENCE) */

	per_write_number_of_sets(s, 1); /* one set of UserData */

	per_write_choice(s, 0xC0);      /* UserData::value present + select h221NonStandard (1) */

	/* h221NonStandard */

	per_write_octet_string(s, h221_cs_key, 4,

	                       4); /* h221NonStandard, client-to-server H.221 key, "Duca" */

	/* userData::value (OCTET_STRING) */

	per_write_octet_string(s, Stream_Buffer(userData), Stream_GetPosition(userData),

	                       0); /* array of client data blocks */

}

BOOL gcc_read_conference_create_response(wStream* s, rdpMcs* mcs)

{

	UINT16 length;

	UINT32 tag;

	UINT16 nodeID;

	BYTE result;

	BYTE choice;

	BYTE number;

	/* ConnectData */

	if (!per_read_choice(s, &choice) || !per_read_object_identifier(s, t124_02_98_oid))

		return FALSE;

	/* ConnectData::connectPDU (OCTET_STRING) */

	if (!per_read_length(s, &length))

		return FALSE;

	/* ConnectGCCPDU */

	if (!per_read_choice(s, &choice))

		return FALSE;

	/* ConferenceCreateResponse::nodeID (UserID) */

	if (!per_read_integer16(s, &nodeID, 1001))

		return FALSE;

	/* ConferenceCreateResponse::tag (INTEGER) */

	if (!per_read_integer(s, &tag))

		return FALSE;

	/* ConferenceCreateResponse::result (ENUMERATED) */

	if (!per_read_enumerated(s, &result, MCS_Result_enum_length))

		return FALSE;

	/* number of UserData sets */

	if (!per_read_number_of_sets(s, &number))

		return FALSE;

	/* UserData::value present + select h221NonStandard (1) */

	if (!per_read_choice(s, &choice))

		return FALSE;

	/* h221NonStandard */

	if (!per_read_octet_string(s, h221_sc_key, 4,

	                           4)) /* h221NonStandard, server-to-client H.221 key, "McDn" */

		return FALSE;

	/* userData (OCTET_STRING) */

	if (!per_read_length(s, &length))

		return FALSE;

	if (!gcc_read_server_data_blocks(s, mcs, length))

	{

		WLog_ERR(TAG, "gcc_read_conference_create_response: gcc_read_server_data_blocks failed");

		return FALSE;

	}

	return TRUE;

}

void gcc_write_conference_create_response(wStream* s, wStream* userData)

{

	/* ConnectData */

	per_write_choice(s, 0);

	per_write_object_identifier(s, t124_02_98_oid);

	/* ConnectData::connectPDU (OCTET_STRING) */

	/* This length MUST be ignored by the client according to [MS-RDPBCGR] */

	per_write_length(s, 0x2A);

	/* ConnectGCCPDU */

	per_write_choice(s, 0x14);

	/* ConferenceCreateResponse::nodeID (UserID) */

	per_write_integer16(s, 0x79F3, 1001);

	/* ConferenceCreateResponse::tag (INTEGER) */

	per_write_integer(s, 1);

	/* ConferenceCreateResponse::result (ENUMERATED) */

	per_write_enumerated(s, 0, MCS_Result_enum_length);

	/* number of UserData sets */

	per_write_number_of_sets(s, 1);

	/* UserData::value present + select h221NonStandard (1) */

	per_write_choice(s, 0xC0);

	/* h221NonStandard */

	per_write_octet_string(s, h221_sc_key, 4,

	                       4); /* h221NonStandard, server-to-client H.221 key, "McDn" */

	/* userData (OCTET_STRING) */

	per_write_octet_string(s, Stream_Buffer(userData), Stream_GetPosition(userData),

	                       0); /* array of server data blocks */

}

BOOL gcc_read_client_data_blocks(wStream* s, rdpMcs* mcs, int length)

{

	UINT16 type;

	UINT16 blockLength;

	size_t begPos, endPos;

	while (length > 0)

	{

		begPos = Stream_GetPosition(s);

		if (!gcc_read_user_data_header(s, &type, &blockLength))

			return FALSE;

		if (Stream_GetRemainingLength(s) < (size_t)(blockLength - 4))

			return FALSE;

		switch (type)

		{

			case CS_CORE:

				if (!gcc_read_client_core_data(s, mcs, blockLength - 4))

					return FALSE;

				break;

			case CS_SECURITY:

				if (!gcc_read_client_security_data(s, mcs, blockLength - 4))

					return FALSE;

				break;

			case CS_NET:

				if (!gcc_read_client_network_data(s, mcs, blockLength - 4))

					return FALSE;

				break;

			case CS_CLUSTER:

				if (!gcc_read_client_cluster_data(s, mcs, blockLength - 4))

					return FALSE;

				break;

			case CS_MONITOR:

				if (!gcc_read_client_monitor_data(s, mcs, blockLength - 4))

					return FALSE;

				break;

			case CS_MCS_MSGCHANNEL:

				if (!gcc_read_client_message_channel_data(s, mcs, blockLength - 4))

					return FALSE;

				break;

			case CS_MONITOR_EX:

				if (!gcc_read_client_monitor_extended_data(s, mcs, blockLength - 4))

					return FALSE;

				break;

			case 0xC009:

			case CS_MULTITRANSPORT:

				if (!gcc_read_client_multitransport_channel_data(s, mcs, blockLength - 4))

					return FALSE;

				break;

			default:

				WLog_ERR(TAG, "Unknown GCC client data block: 0x%04" PRIX16 "", type);

				Stream_Seek(s, blockLength - 4);

				break;

		}

		endPos = Stream_GetPosition(s);

		if (endPos != (begPos + blockLength))

		{

			WLog_ERR(TAG,

			         "Error parsing GCC client data block 0x%04" PRIX16

			         ": Actual Offset: %d Expected Offset: %d",

			         type, endPos, begPos + blockLength);

		}

		length -= blockLength;

		Stream_SetPosition(s, begPos + blockLength);

	}

	return TRUE;

}

void gcc_write_client_data_blocks(wStream* s, rdpMcs* mcs)

{

	rdpSettings* settings = mcs->settings;

	gcc_write_client_core_data(s, mcs);

	gcc_write_client_cluster_data(s, mcs);

	gcc_write_client_security_data(s, mcs);

	gcc_write_client_network_data(s, mcs);

	/* extended client data supported */

	if (settings->NegotiationFlags & EXTENDED_CLIENT_DATA_SUPPORTED)

	{

		if (settings->UseMultimon && !settings->SpanMonitors)

		{

			gcc_write_client_monitor_data(s, mcs);

			gcc_write_client_monitor_extended_data(s, mcs);

		}

		gcc_write_client_message_channel_data(s, mcs);

		gcc_write_client_multitransport_channel_data(s, mcs);

	}

	else

	{

		if (settings->UseMultimon && !settings->SpanMonitors)

		{

			WLog_ERR(TAG, "WARNING: true multi monitor support was not advertised by server!");

			if (settings->ForceMultimon)

			{

				WLog_ERR(TAG, "Sending multi monitor information anyway (may break connectivity!)");

				gcc_write_client_monitor_data(s, mcs);

				gcc_write_client_monitor_extended_data(s, mcs);

			}

			else

			{

				WLog_ERR(TAG, "Use /multimon:force to force sending multi monitor information");

			}

		}

	}

}

BOOL gcc_read_server_data_blocks(wStream* s, rdpMcs* mcs, int length)

{

	UINT16 type;

	UINT16 offset = 0;

	UINT16 blockLength;

	BYTE* holdp;

	while (offset < length)

	{

		size_t rest;

		wStream sub;

		if (!gcc_read_user_data_header(s, &type, &blockLength))

		{

			WLog_ERR(TAG, "gcc_read_server_data_blocks: gcc_read_user_data_header failed");

			return FALSE;

		}

		holdp = Stream_Pointer(s);

		Stream_StaticInit(&sub, holdp, blockLength - 4);

		if (!Stream_SafeSeek(s, blockLength - 4))

		{

			WLog_ERR(TAG, "gcc_read_server_data_blocks: stream too short");

			return FALSE;

		}

		offset += blockLength;

		switch (type)

		{

			case SC_CORE:

				if (!gcc_read_server_core_data(&sub, mcs))

				{

					WLog_ERR(TAG, "gcc_read_server_data_blocks: gcc_read_server_core_data failed");

					return FALSE;

				}

				break;

			case SC_SECURITY:

				if (!gcc_read_server_security_data(&sub, mcs))

				{

					WLog_ERR(TAG,

					         "gcc_read_server_data_blocks: gcc_read_server_security_data failed");

					return FALSE;

				}

				break;

			case SC_NET:

				if (!gcc_read_server_network_data(&sub, mcs))

				{

					WLog_ERR(TAG,

					         "gcc_read_server_data_blocks: gcc_read_server_network_data failed");

					return FALSE;

				}

				break;

			case SC_MCS_MSGCHANNEL:

				if (!gcc_read_server_message_channel_data(&sub, mcs))

				{

					WLog_ERR(

					    TAG,

					    "gcc_read_server_data_blocks: gcc_read_server_message_channel_data failed");

					return FALSE;

				}

				break;

			case SC_MULTITRANSPORT:

				if (!gcc_read_server_multitransport_channel_data(&sub, mcs))

				{

					WLog_ERR(TAG, "gcc_read_server_data_blocks: "

					              "gcc_read_server_multitransport_channel_data failed");

					return FALSE;

				}

				break;

			default:

				WLog_ERR(TAG, "gcc_read_server_data_blocks: ignoring type=%" PRIu16 "", type);

				break;

		}

		rest = Stream_GetRemainingLength(&sub);

		if (rest > 0)

		{

			WLog_WARN(

			    TAG, "gcc_read_server_data_blocks: ignoring %" PRIuz " bytes with type=%" PRIu16 "",

			    rest, type);

		}

	}

	return TRUE;

}

BOOL gcc_write_server_data_blocks(wStream* s, rdpMcs* mcs)

{

	return gcc_write_server_core_data(s, mcs) &&          /* serverCoreData */

	       gcc_write_server_network_data(s, mcs) &&       /* serverNetworkData */

	       gcc_write_server_security_data(s, mcs) &&      /* serverSecurityData */

	       gcc_write_server_message_channel_data(s, mcs); /* serverMessageChannelData */

	/* TODO: Send these GCC data blocks only when the client sent them */

	// gcc_write_server_multitransport_channel_data(s, settings); /* serverMultitransportChannelData

	// */

}

BOOL gcc_read_user_data_header(wStream* s, UINT16* type, UINT16* length)

{

	if (Stream_GetRemainingLength(s) < 4)

		return FALSE;

	Stream_Read_UINT16(s, *type);   /* type */

	Stream_Read_UINT16(s, *length); /* length */

	if ((*length < 4) || (Stream_GetRemainingLength(s) < (size_t)(*length - 4)))

		return FALSE;

	return TRUE;

}

/**

 * Write a user data header (TS_UD_HEADER).\n

 * @msdn{cc240509}

 * @param s stream

 * @param type data block type

 * @param length data block length

 */

void gcc_write_user_data_header(wStream* s, UINT16 type, UINT16 length)

{

	Stream_Write_UINT16(s, type);   /* type */

	Stream_Write_UINT16(s, length); /* length */

}

/**

 * Read a client core data block (TS_UD_CS_CORE).\n

 * @msdn{cc240510}

 * @param s stream

 * @param settings rdp settings

 */

BOOL gcc_read_client_core_data(wStream* s, rdpMcs* mcs, UINT16 blockLength)

{

	char* str = NULL;

	UINT32 version;

	BYTE connectionType = 0;

	UINT32 clientColorDepth;

	UINT16 colorDepth = 0;

	UINT16 postBeta2ColorDepth = 0;

	UINT16 highColorDepth = 0;

	UINT16 supportedColorDepths = 0;

	UINT32 serverSelectedProtocol = 0;

	UINT16 earlyCapabilityFlags = 0;

	rdpSettings* settings = mcs->settings;

	/* Length of all required fields, until imeFileName */

	if (blockLength < 128)

		return FALSE;

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

	settings->RdpVersion = rdp_version_common(version, settings->RdpVersion);

	Stream_Read_UINT16(s, settings->DesktopWidth);  /* DesktopWidth (2 bytes) */

	Stream_Read_UINT16(s, settings->DesktopHeight); /* DesktopHeight (2 bytes) */

	Stream_Read_UINT16(s, colorDepth);              /* ColorDepth (2 bytes) */

	Stream_Seek_UINT16(s); /* SASSequence (Secure Access Sequence) (2 bytes) */

	Stream_Read_UINT32(s, settings->KeyboardLayout); /* KeyboardLayout (4 bytes) */

	Stream_Read_UINT32(s, settings->ClientBuild);    /* ClientBuild (4 bytes) */

	/* clientName (32 bytes, null-terminated unicode, truncated to 15 characters) */

	if (ConvertFromUnicode(CP_UTF8, 0, (WCHAR*)Stream_Pointer(s), 32 / 2, &str, 0, NULL, NULL) < 1)

	{

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

		return FALSE;

	}

	Stream_Seek(s, 32);

	free(settings->ClientHostname);

	settings->ClientHostname = str;

	str = NULL;

	Stream_Read_UINT32(s, settings->KeyboardType);        /* KeyboardType (4 bytes) */

	Stream_Read_UINT32(s, settings->KeyboardSubType);     /* KeyboardSubType (4 bytes) */

	Stream_Read_UINT32(s, settings->KeyboardFunctionKey); /* KeyboardFunctionKey (4 bytes) */

	Stream_Seek(s, 64);                                   /* imeFileName (64 bytes) */

	blockLength -= 128;

	/**

	 * The following fields are all optional. If one field is present, all of the preceding

	 * fields MUST also be present. If one field is not present, all of the subsequent fields

	 * MUST NOT be present.

	 * We must check the bytes left before reading each field.

	 */

	do

	{

		if (blockLength < 2)

			break;

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

		blockLength -= 2;

		if (blockLength < 2)

			break;

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

		blockLength -= 2;

		if (blockLength < 4)

			break;

		Stream_Seek_UINT32(s); /* serialNumber (4 bytes) */

		blockLength -= 4;

		if (blockLength < 2)

			break;

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

		blockLength -= 2;

		if (blockLength < 2)

			break;

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

		blockLength -= 2;

		if (blockLength < 2)

			break;

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

		settings->EarlyCapabilityFlags = (UINT32)earlyCapabilityFlags;

		blockLength -= 2;

		/* clientDigProductId (64 bytes): Contains a value that uniquely identifies the client */

		if (blockLength < 64)

			break;

		if (ConvertFromUnicode(CP_UTF8, 0, (WCHAR*)Stream_Pointer(s), 64 / 2, &str, 0, NULL, NULL) <

		    1)

		{

			WLog_ERR(TAG, "failed to convert the client product identifier");

			return FALSE;

		}

		Stream_Seek(s, 64); /* clientDigProductId (64 bytes) */

		free(settings->ClientProductId);

		settings->ClientProductId = str;

		blockLength -= 64;

		if (blockLength < 1)

			break;

		Stream_Read_UINT8(s, connectionType); /* connectionType (1 byte) */

		blockLength -= 1;

		if (blockLength < 1)

			break;

		Stream_Seek_UINT8(s); /* pad1octet (1 byte) */

		blockLength -= 1;

		if (blockLength < 4)

			break;

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

		blockLength -= 4;

		if (blockLength < 4)

			break;

		Stream_Read_UINT32(s, settings->DesktopPhysicalWidth); /* desktopPhysicalWidth (4 bytes) */

		blockLength -= 4;

		if (blockLength < 4)

			break;

		Stream_Read_UINT32(s,

		                   settings->DesktopPhysicalHeight); /* desktopPhysicalHeight (4 bytes) */

		blockLength -= 4;

		if (blockLength < 2)

			break;

		Stream_Read_UINT16(s, settings->DesktopOrientation); /* desktopOrientation (2 bytes) */

		blockLength -= 2;

		if (blockLength < 4)

			break;

		Stream_Read_UINT32(s, settings->DesktopScaleFactor); /* desktopScaleFactor (4 bytes) */

		blockLength -= 4;

		if (blockLength < 4)

			break;

		Stream_Read_UINT32(s, settings->DeviceScaleFactor); /* deviceScaleFactor (4 bytes) */

		if (settings->SelectedProtocol != serverSelectedProtocol)

			return FALSE;

	} while (0);

	if (highColorDepth > 0)

	{

		if (earlyCapabilityFlags & RNS_UD_CS_WANT_32BPP_SESSION)

			clientColorDepth = 32;

		else

			clientColorDepth = highColorDepth;

	}

	else if (postBeta2ColorDepth > 0)

	{

		switch (postBeta2ColorDepth)

		{

			case RNS_UD_COLOR_4BPP:

				clientColorDepth = 4;

				break;

			case RNS_UD_COLOR_8BPP:

				clientColorDepth = 8;

				break;

			case RNS_UD_COLOR_16BPP_555:

				clientColorDepth = 15;

				break;

			case RNS_UD_COLOR_16BPP_565:

				clientColorDepth = 16;

				break;

			case RNS_UD_COLOR_24BPP:

				clientColorDepth = 24;

				break;

			default:

				return FALSE;

		}

	}

	else

	{

		switch (colorDepth)

		{

			case RNS_UD_COLOR_4BPP:

				clientColorDepth = 4;

				break;

			case RNS_UD_COLOR_8BPP:

				clientColorDepth = 8;

				break;

			default:

				return FALSE;

		}

	}

	/*

	 * If we are in server mode, accept client's color depth only if

	 * it is smaller than ours. This is what Windows server does.

	 */

	if ((clientColorDepth < settings->ColorDepth) || !settings->ServerMode)

		settings->ColorDepth = clientColorDepth;

	if (settings->NetworkAutoDetect)

		settings->NetworkAutoDetect =

		    (earlyCapabilityFlags & RNS_UD_CS_SUPPORT_NETWORK_AUTODETECT) ? TRUE : FALSE;

	if (settings->SupportHeartbeatPdu)

		settings->SupportHeartbeatPdu =

		    (earlyCapabilityFlags & RNS_UD_CS_SUPPORT_HEARTBEAT_PDU) ? TRUE : FALSE;

	if (settings->SupportGraphicsPipeline)