/// <summary>
/// 2.2.1.1
/// </summary>
/// <param name="clientPdu"></param>
public void VerifyPdu(Client_X_224_Connection_Request_Pdu clientPdu)
{
//Site.Log.Add(TestTools.LogEntryKind.Debug, "CheckX224ConnectionRequestPdu", clientPdu);
site.CaptureRequirementIfAreEqual<byte>(0, clientPdu.x224Crq.classOptions, 9,
@"[In Client X.224 Connection Request PDU] x224Crq (7 bytes): An X.224 Class 0 Connection Request "
+ @"transport protocol data unit (TPDU), as specified in [X224] section 13.3.");
if (clientPdu != null && clientPdu.routingToken != null )
{
int len = clientPdu.routingToken.Length;
site.CaptureRequirementIfIsTrue(clientPdu.routingToken[len - 2] == 0x0D && clientPdu.routingToken[len - 1] == 0x0A, 10,
@"[In Client X.224 Connection Request PDU]routingToken (variable): An optional and variable-length "
+ @"routing token (used for load balancing) terminated by a 0x0D0A two-byte sequence.");
}
if (clientPdu.rdpNegData != null)
{
site.CaptureRequirementIfAreEqual<type_Values>(type_Values.V1, clientPdu.rdpNegData.type, 22,
@"[In RDP Negotiation Request] type ( 1 byte): it MUST be set to 0x01 (TYPE_RDP_NEG_REQ) to indicate "
+ @"that the packet is a Negotiation Request.");
bool isRDPNegDataSatisfied = clientPdu.rdpNegData.flags == RDP_NEG_REQ_flags_Values.V1 || clientPdu.rdpNegData.flags == RDP_NEG_REQ_flags_Values.CORRELATION_INFO_PRESENT;
site.CaptureRequirementIfIsTrue(isRDPNegDataSatisfied, 24,
@"[In RDP Negotiation Request] flags (1 byte): An 8-bit, unsigned integer that contains protocol flags. "
+ @"this flags field MUST be set to 0x00 or CORRELATION_INFO_PRESENT(0x08).");
site.CaptureRequirementIfAreEqual<length_Values>(length_Values.V1, clientPdu.rdpNegData.length, 26,
@"[In RDP Negotiation Request] length (2 bytes): length MUST be set to 0x0008 (8 bytes).");
site.CaptureRequirementIfIsTrue(clientPdu.rdpNegData.requestedProtocols == (requestedProtocols_Values.PROTOCOL_HYBRID_FLAG | requestedProtocols_Values.PROTOCOL_SSL_FLAG | requestedProtocols_Values.PROTOCOL_HYBRID_EX) ||
clientPdu.rdpNegData.requestedProtocols == (requestedProtocols_Values.PROTOCOL_HYBRID_FLAG | requestedProtocols_Values.PROTOCOL_SSL_FLAG) ||
clientPdu.rdpNegData.requestedProtocols == requestedProtocols_Values.PROTOCOL_RDP_FLAG ||
clientPdu.rdpNegData.requestedProtocols == requestedProtocols_Values.PROTOCOL_SSL_FLAG, 28,
@"In RDP Negotiation Request the requestedProtocols can take one of the following values. 1. PROTOCOL_RDP_FLAG"
+ @" 0x00000000 Legacy RDP encryption 2. PROTOCOL_SSL_FLAG 0x00000001 TLS 1.0. 3. PROTOCOL_HYBRID_FLAG 0x00000002 CredSSP. ");
if( (clientPdu.rdpNegData.requestedProtocols&requestedProtocols_Values.PROTOCOL_HYBRID_FLAG) != 0 )
{
site.CaptureRequirementIfAreNotEqual<requestedProtocols_Values>(0, clientPdu.rdpNegData.requestedProtocols & requestedProtocols_Values.PROTOCOL_SSL_FLAG, 32,
@"In RDP Negotiation Request (RDP_NEG_REQ), requestedProtocols (4 bytes) : If PROTOCOL_HYBRID_FLAG (0x00000002)"
+ @" flag is set, then the PROTOCOL_SSL (0x00000001) SHOULD also be set because Transport Layer Security (TLS) "
+ @"is a subset of CredSSP.");
}
}
}
/// <summary>
/// Return a reasonable failureCode according to the receving Client_X_224_Connection_Request_Pdu.
/// </summary>
/// <param name="pdu">the Client_X_224_Connection_Request_Pdu</param>
/// <returns></returns>
private failureCode_Values GetFailureCode_RDP_NEG_FAILURE(Client_X_224_Connection_Request_Pdu pdu)
{
failureCode_Values result = failureCode_Values.NO_FAILURE;
if (pdu == null)
return result;
bool has_PROTOCOL_RDP_FLAG = pdu.rdpNegData.requestedProtocols.HasFlag(requestedProtocols_Values.PROTOCOL_RDP_FLAG);
bool has_PROTOCOL_SSL_FLAG = pdu.rdpNegData.requestedProtocols.HasFlag(requestedProtocols_Values.PROTOCOL_RDP_FLAG);
bool has_PROTOCOL_HYBRID_FLAG = pdu.rdpNegData.requestedProtocols.HasFlag(requestedProtocols_Values.PROTOCOL_HYBRID_FLAG);
bool has_PROTOCOL_HYBRID_EX = pdu.rdpNegData.requestedProtocols.HasFlag(requestedProtocols_Values.PROTOCOL_HYBRID_EX);
if (!has_PROTOCOL_HYBRID_EX && !has_PROTOCOL_HYBRID_FLAG && has_PROTOCOL_SSL_FLAG)
{
// 0000 | 0001
result = failureCode_Values.SSL_REQUIRED_BY_SERVER;
}
else if (!has_PROTOCOL_HYBRID_EX && !has_PROTOCOL_HYBRID_FLAG)
{
// 0010 | 0011
result = failureCode_Values.HYBRID_REQUIRED_BY_SERVER;
}
else if (!has_PROTOCOL_SSL_FLAG)
{
// 1000 | 0100 | 1101 | 1100 | 1001 | 0101 | 1100
result = failureCode_Values.SSL_WITH_USER_AUTH_REQUIRED_BY_SERVER;
}
else if (!has_PROTOCOL_RDP_FLAG)
{
// 1010 | 0110 | 1110
result = failureCode_Values.SSL_CERT_NOT_ON_SERVER;
}
else
{
// 1011 | 0111 | 1111
result = failureCode_Values.INCONSISTENT_FLAGS;
}
return result;
}
private void S8_ServerRedirection_PositiveTest_WithRoutingToken_VerifyX224ConnectioRequest(Client_X_224_Connection_Request_Pdu x224Request)
{
string receivedRoutingToken = string.Empty;
if (x224Request.routingToken != null)
{
receivedRoutingToken = ASCIIEncoding.ASCII.GetString(x224Request.routingToken);
}
this.TestSite.Assert.AreEqual<string>(RdpbcgrTestData.Test_Redirection_RoutingToken, receivedRoutingToken, "Verify if routingToken is present in X.224 Connection Request PDU and same as that sent in Server Redirection PDU.");
}
private void S8_ServerRedirection_PositiveTest_WithoutRoutingToken_VerifyX224ConnectioRequest(Client_X_224_Connection_Request_Pdu x224Request)
{
this.TestSite.Assert.IsTrue(x224Request.routingToken == null || x224Request.routingToken.Length == 0, "Verify if routingToken is not present in X.224 Connection Request PDU for server redirection.");
}
/// <summary>
/// Clear all the members except the reconnection relative members.
/// </summary>
internal void ClearForReconnect()
{
lock (contextLock)
{
x224ConnectionRequestPdu = null;
x224ConnectionConfirmPdu = null;
x224NegotiateFailurePdu = null;
mcsConnectInitialPdu = null;
mcsConnectResponsePdu = null;
userChannelId = 0;
ioChannelId = 0;
serverChannelId = 0;
clientInfo = null;
securityExchangePdu = null;
licenseErrorPdu = null;
demandActivePdu = null;
comfirmActivePdu = null;
logonInfoV1 = new TS_LOGON_INFO();
logonInfoV2 = new TS_LOGON_INFO_VERSION_2();
logonErrorsInfo = null;
encryptionCount = 0;
decryptionCount = 0;
if (encryptionAlgorithm != null)
{
encryptionAlgorithm.Dispose();
encryptionAlgorithm = null;
}
if (ioDecompressor != null)
{
ioDecompressor.Dispose();
ioDecompressor = null;
}
if (ioCompressor != null)
{
ioCompressor.Dispose();
ioCompressor = null;
}
}
}
/// <summary>
/// Update some members of context with the specified pdu.
/// </summary>
/// <param name="pdu">The sending or receiving pdu.</param>
public void UpdateContext(StackPacket pdu)
{
lock (contextLock)
{
if (!isSwitchOn)
{
// Don't update context but wait for upper layer TSD to do so.
return;
}
if (pdu.GetType() == typeof(Client_X_224_Connection_Request_Pdu))
{
x224ConnectionRequestPdu = (Client_X_224_Connection_Request_Pdu)pdu.Clone();
}
else if (pdu.GetType() == typeof(Server_X_224_Connection_Confirm_Pdu))
{
x224ConnectionConfirmPdu = ((Server_X_224_Connection_Confirm_Pdu)pdu.Clone()).rdpNegData;
}
else if (pdu.GetType() == typeof(Server_X_224_Negotiate_Failure_Pdu))
{
x224NegotiateFailurePdu = ((Server_X_224_Negotiate_Failure_Pdu)pdu.Clone()).rdpNegFailure;
}
else if (pdu.GetType() == typeof(Client_MCS_Connect_Initial_Pdu_with_GCC_Conference_Create_Request))
{
mcsConnectInitialPdu = ((Client_MCS_Connect_Initial_Pdu_with_GCC_Conference_Create_Request)
pdu.Clone()).mcsCi;
}
else if (pdu is Server_MCS_Connect_Response_Pdu_with_GCC_Conference_Create_Response)
{
mcsConnectResponsePdu = (Server_MCS_Connect_Response_Pdu_with_GCC_Conference_Create_Response)
pdu.Clone();
serverRandom = RdpbcgrUtility.CloneByteArray(mcsConnectResponsePdu.mcsCrsp.gccPdu.serverSecurityData.serverRandom);
ioChannelId = mcsConnectResponsePdu.mcsCrsp.gccPdu.serverNetworkData.MCSChannelId;
if(mcsConnectResponsePdu.mcsCrsp.gccPdu.serverMessageChannelData != null)
mcsMsgChannelId = mcsConnectResponsePdu.mcsCrsp.gccPdu.serverMessageChannelData.MCSChannelID;
encryptionAlgorithm = new EncryptionAlgorithm(RdpEncryptionMethod);
}
else if (pdu.GetType() == typeof(Server_MCS_Attach_User_Confirm_Pdu))
{
if (((Server_MCS_Attach_User_Confirm_Pdu)pdu).attachUserConfirm.initiator != null)
{
userChannelId = (ushort)((Server_MCS_Attach_User_Confirm_Pdu)pdu).attachUserConfirm.initiator.Value;
}
}
else if (pdu.GetType() == typeof(Client_Security_Exchange_Pdu))
{
securityExchangePdu = (Client_Security_Exchange_Pdu)pdu.Clone();
clientRandom = RdpbcgrUtility.CloneByteArray(
((Client_Security_Exchange_Pdu)pdu).securityExchangePduData.clientRandom);
GenerateSessionKey();
}
else if (pdu.GetType() == typeof(Client_Info_Pdu))
{
clientInfo = ((Client_Info_Pdu)pdu.Clone()).infoPacket;
if (clientInfo != null
&& (clientInfo.flags & flags_Values.INFO_COMPRESSION) == flags_Values.INFO_COMPRESSION)
{
ioDecompressor = new Decompressor(SlidingWindowSize.EightKB);
ioCompressor = new Compressor(SlidingWindowSize.EightKB);
}
isWaitingLicenseErrorPdu = true;
}
else if (pdu.GetType() == typeof(Server_Auto_Detect_Request_PDU))
{
NETWORK_DETECTION_REQUEST requestData = ((Server_Auto_Detect_Request_PDU)pdu).autoDetectReqData.Clone();
if (requestData.requestType == AUTO_DETECT_REQUEST_TYPE.RDP_RTT_REQUEST_IN_CONNECTTIME || requestData.requestType == AUTO_DETECT_REQUEST_TYPE.RDP_RTT_REQUEST_AFTER_CONNECTTIME)
{
RDP_RTT_REQUEST rttRequest = (RDP_RTT_REQUEST)requestData;
rttRequest.sendTime = DateTime.Now;
this.serverAutoDetectRequestData.Add(rttRequest.sequenceNumber, rttRequest);
}
}
else if (pdu.GetType() == typeof(Client_Auto_Detect_Response_PDU))
{
clientAutoDetectResponsePdu = (Client_Auto_Detect_Response_PDU)pdu.Clone();
NETWORK_DETECTION_RESPONSE responseData = clientAutoDetectResponsePdu.autodetectRspPduData;
if (responseData.responseType == AUTO_DETECT_RESPONSE_TYPE.RDP_RTT_RESPONSE)
{
RDP_RTT_REQUEST rttRequest = (RDP_RTT_REQUEST)serverAutoDetectRequestData[responseData.sequenceNumber];
if (rttRequest != null)
{
TimeSpan interval = DateTime.Now - rttRequest.sendTime;
this.autoDetectedRTTList.Add((uint)interval.TotalMilliseconds);
serverAutoDetectRequestData.Remove(responseData.sequenceNumber);
}
}
else if (responseData.responseType == AUTO_DETECT_RESPONSE_TYPE.RDP_BW_RESULTS_AFTER_CONNECT || responseData.responseType == AUTO_DETECT_RESPONSE_TYPE.RDP_BW_RESULTS_DURING_CONNECT)
{
RDP_BW_RESULTS bwResult = (RDP_BW_RESULTS)responseData;
if(bwResult.timeDelta != 0)
this.autoDetectedBandwidth = (uint)(bwResult.byteCount / bwResult.timeDelta);
}
else if (responseData.responseType == AUTO_DETECT_RESPONSE_TYPE.RDP_NETCHAR_SYNC)
{
RDP_NETCHAR_SYNC netSync = (RDP_NETCHAR_SYNC)responseData;
this.autoDetectedRTTList.Add(netSync.rtt);
this.autoDetectedBandwidth = netSync.bandwidth;
}
}
else if (pdu.GetType() == typeof(Server_License_Error_Pdu_Valid_Client))
{
licenseErrorPdu = (Server_License_Error_Pdu_Valid_Client)pdu.Clone();
serverChannelId = licenseErrorPdu.commonHeader.initiator;
}
else if (pdu.GetType() == typeof(Server_Initiate_Multitransport_Request_PDU))
{
Server_Initiate_Multitransport_Request_PDU requestPDU = (Server_Initiate_Multitransport_Request_PDU)pdu;
serverInitiateMultitransportRequestPduDictionary.Add(requestPDU.requestId, requestPDU);
}
else if (pdu.GetType() == typeof(Client_Initiate_Multitransport_Response_PDU))
{
clientInitiateMultitransportResponsePdu = (Client_Initiate_Multitransport_Response_PDU)pdu;
}
else if (pdu.GetType() == typeof(Server_Demand_Active_Pdu))
{
serverChannelId = ((Server_Demand_Active_Pdu)pdu.Clone()).commonHeader.initiator;
demandActivePdu = ((Server_Demand_Active_Pdu)pdu.Clone()).demandActivePduData;
}
else if (pdu.GetType() == typeof(Client_Confirm_Active_Pdu))
{
comfirmActivePdu = ((Client_Confirm_Active_Pdu)pdu.Clone()).confirmActivePduData;
if (channelManager == null)
{
channelManager = new ServerStaticVirtualChannelManager(this);
}
}
else if (pdu.GetType() == typeof(MCS_Disconnect_Provider_Ultimatum_Server_Pdu))
{
lastDisconnectReason = (int)((MCS_Disconnect_Provider_Ultimatum_Server_Pdu)
pdu).disconnectProvider.reason.Value;
}
else if (pdu.GetType() == typeof(MCS_Disconnect_Provider_Ultimatum_Pdu))
{
lastDisconnectReason = (int)((MCS_Disconnect_Provider_Ultimatum_Pdu)
pdu).disconnectProvider.reason.Value;
}
else if (pdu.GetType() == typeof(Server_Set_Error_Info_Pdu))
{
lastErrorInfo = ((Server_Set_Error_Info_Pdu)pdu).errorInfoPduData.errorInfo;
}
else if (pdu.GetType() == typeof(Server_Status_Info_Pdu))
{
lastStatusInfo = ((Server_Status_Info_Pdu)pdu).statusCode;
}
else if (pdu.GetType() == typeof(Server_Save_Session_Info_Pdu))
{
Server_Save_Session_Info_Pdu saveSessionInfoPdu = (Server_Save_Session_Info_Pdu)pdu.Clone();
switch (saveSessionInfoPdu.saveSessionInfoPduData.infoType)
{
case infoType_Values.INFOTYPE_LOGON:
logonInfoV1 = (TS_LOGON_INFO)saveSessionInfoPdu.saveSessionInfoPduData.infoData;
break;
case infoType_Values.INFOTYPE_LOGON_LONG:
logonInfoV2 = (TS_LOGON_INFO_VERSION_2)saveSessionInfoPdu.saveSessionInfoPduData.infoData;
break;
case infoType_Values.INFOTYPE_LOGON_EXTENDED_INF:
TS_LOGON_INFO_EXTENDED infoExtended =
(TS_LOGON_INFO_EXTENDED)saveSessionInfoPdu.saveSessionInfoPduData.infoData;
switch (infoExtended.FieldsPresent)
{
case FieldsPresent_Values.LOGON_EX_AUTORECONNECTCOOKIE
| FieldsPresent_Values.LOGON_EX_LOGONERRORS:
autoReconnectCookie = (ARC_SC_PRIVATE_PACKET)infoExtended.LogonFields[0].FieldData;
logonErrorsInfo = (TS_LOGON_ERRORS_INFO)infoExtended.LogonFields[1].FieldData;
break;
case FieldsPresent_Values.LOGON_EX_AUTORECONNECTCOOKIE:
autoReconnectCookie = (ARC_SC_PRIVATE_PACKET)infoExtended.LogonFields[0].FieldData;
break;
case FieldsPresent_Values.LOGON_EX_LOGONERRORS:
logonErrorsInfo = (TS_LOGON_ERRORS_INFO)infoExtended.LogonFields[0].FieldData;
break;
default:
break;
}
break;
default:
break;
}
}
}
}
/// <summary>
/// Update some members of context with the specified pdu.
/// </summary>
/// <param name="pdu">The sending or receiving pdu.</param>
public void UpdateContext(StackPacket pdu)
{
lock (contextLock)
{
if (!isSwitchOn)
{
// Don't update context but wait for upper layer TSD to do so.
return;
}
if (pdu.GetType() == typeof(Client_X_224_Connection_Request_Pdu))
{
x224ConnectionRequestPdu = (Client_X_224_Connection_Request_Pdu)pdu.Clone();
}
else if (pdu.GetType() == typeof(Server_X_224_Connection_Confirm_Pdu))
{
x224ConnectionConfirmPdu = ((Server_X_224_Connection_Confirm_Pdu)pdu.Clone()).rdpNegData;
}
else if (pdu.GetType() == typeof(Server_X_224_Negotiate_Failure_Pdu))
{
x224NegotiateFailurePdu = ((Server_X_224_Negotiate_Failure_Pdu)pdu.Clone()).rdpNegFailure;
}
else if (pdu.GetType() == typeof(Client_MCS_Connect_Initial_Pdu_with_GCC_Conference_Create_Request))
{
mcsConnectInitialPdu = ((Client_MCS_Connect_Initial_Pdu_with_GCC_Conference_Create_Request)
pdu.Clone()).mcsCi;
}
else if (pdu.GetType() == typeof(Server_MCS_Connect_Response_Pdu_with_GCC_Conference_Create_Response))
{
mcsConnectResponsePdu = (Server_MCS_Connect_Response_Pdu_with_GCC_Conference_Create_Response)
pdu.Clone();
encryptionAlgorithm = new EncryptionAlgorithm(RdpEncryptionMethod);
}
else if (pdu.GetType() == typeof(Server_MCS_Attach_User_Confirm_Pdu))
{
userChannelId = (long)((Server_MCS_Attach_User_Confirm_Pdu)pdu).attachUserConfirm.initiator.Value;
}
else if (pdu.GetType() == typeof(Client_Security_Exchange_Pdu))
{
clientRandom = RdpbcgrUtility.CloneByteArray(
((Client_Security_Exchange_Pdu)pdu).securityExchangePduData.clientRandom);
}
else if (pdu.GetType() == typeof(Client_Info_Pdu))
{
clientInfo = ((Client_Info_Pdu)pdu.Clone()).infoPacket;
if (clientInfo != null
&& (clientInfo.flags & flags_Values.INFO_COMPRESSION) == flags_Values.INFO_COMPRESSION)
{
ioDecompressor = new Decompressor((SlidingWindowSize)CompressionTypeSupported);
}
}
else if (pdu.GetType() == typeof(Server_License_Error_Pdu_Valid_Client))
{
licenseErrorPdu = (Server_License_Error_Pdu_Valid_Client)pdu.Clone();
}
else if (pdu.GetType() == typeof(Server_Initiate_Multitransport_Request_PDU))
{
Server_Initiate_Multitransport_Request_PDU initRequset = pdu as Server_Initiate_Multitransport_Request_PDU;
if (initRequset.requestedProtocol == Multitransport_Protocol_value.INITITATE_REQUEST_PROTOCOL_UDPFECR)
{
requestIdReliable = initRequset.requestId;
cookieReliable = initRequset.securityCookie;
}
else
{
requestIdLossy = initRequset.requestId;
cookieLossy = initRequset.securityCookie;
}
}
else if (pdu.GetType() == typeof(Server_Demand_Active_Pdu))
{
demandActivePdu = ((Server_Demand_Active_Pdu)pdu.Clone()).demandActivePduData;
}
else if (pdu.GetType() == typeof(Client_Confirm_Active_Pdu))
{
comfirmActivePdu = ((Client_Confirm_Active_Pdu)pdu.Clone()).confirmActivePduData;
if (channelManager == null)
{
channelManager = new ClientStaticVirtualChannelManager(this);
}
}
else if (pdu.GetType() == typeof(MCS_Disconnect_Provider_Ultimatum_Pdu))
{
lastDisconnectReason = (int)((MCS_Disconnect_Provider_Ultimatum_Pdu)
pdu).disconnectProvider.reason.Value;
}
else if (pdu.GetType() == typeof(Server_Set_Error_Info_Pdu))
{
lastErrorInfo = ((Server_Set_Error_Info_Pdu)pdu).errorInfoPduData.errorInfo;
}
else if (pdu.GetType() == typeof(Server_Status_Info_Pdu))
{
lastStatusInfo = ((Server_Status_Info_Pdu)pdu).statusCode;
}
else if (pdu.GetType() == typeof(Server_Save_Session_Info_Pdu))
{
Server_Save_Session_Info_Pdu saveSessionInfoPdu = (Server_Save_Session_Info_Pdu)pdu.Clone();
switch (saveSessionInfoPdu.saveSessionInfoPduData.infoType)
{
case infoType_Values.INFOTYPE_LOGON:
logonInfoV1 = (TS_LOGON_INFO)saveSessionInfoPdu.saveSessionInfoPduData.infoData;
break;
case infoType_Values.INFOTYPE_LOGON_LONG:
logonInfoV2 = (TS_LOGON_INFO_VERSION_2)saveSessionInfoPdu.saveSessionInfoPduData.infoData;
break;
case infoType_Values.INFOTYPE_LOGON_EXTENDED_INF:
TS_LOGON_INFO_EXTENDED infoExtended =
(TS_LOGON_INFO_EXTENDED)saveSessionInfoPdu.saveSessionInfoPduData.infoData;
switch (infoExtended.FieldsPresent)
{
case FieldsPresent_Values.LOGON_EX_AUTORECONNECTCOOKIE
| FieldsPresent_Values.LOGON_EX_LOGONERRORS:
autoReconnectCookie = (ARC_SC_PRIVATE_PACKET)infoExtended.LogonFields[0].FieldData;
logonErrorsInfo = (TS_LOGON_ERRORS_INFO)infoExtended.LogonFields[1].FieldData;
break;
case FieldsPresent_Values.LOGON_EX_AUTORECONNECTCOOKIE:
autoReconnectCookie = (ARC_SC_PRIVATE_PACKET)infoExtended.LogonFields[0].FieldData;
break;
case FieldsPresent_Values.LOGON_EX_LOGONERRORS:
logonErrorsInfo = (TS_LOGON_ERRORS_INFO)infoExtended.LogonFields[0].FieldData;
break;
default:
break;
}
break;
default:
break;
}
}
}
}
/// <summary>
/// Decode X.224 Connection Request PDU
/// </summary>
/// <param name="data">data to be parsed</param>
/// <returns>decoded X.224 Connection Request PDU</returns>
public StackPacket DecodeX224ConnectionRequestPDU(byte[] data)
{
// initialize
int currentIndex = 0;
// TpktHeader
TpktHeader tpktHeader = ParseTpktHeader(data, ref currentIndex);
// X224Crq
X224Crq x224Crq = ParseX224Crq(data, ref currentIndex);
Client_X_224_Connection_Request_Pdu requestPdu = new Client_X_224_Connection_Request_Pdu();
requestPdu.tpktHeader = tpktHeader;
requestPdu.x224Crq = x224Crq;
if (tpktHeader.length > currentIndex)
{
//routingToken or cookie
ParseRoutingTokenOrCookie(data, ref requestPdu.routingToken, ref requestPdu.cookie, ref currentIndex);
if (tpktHeader.length > currentIndex)
{
requestPdu.rdpNegData = ParseRdpNegReq(data, ref currentIndex);
if (requestPdu.rdpNegData.flags.HasFlag(RDP_NEG_REQ_flags_Values.CORRELATION_INFO_PRESENT) && tpktHeader.length > currentIndex)
{
requestPdu.rdpCorrelationInfo = ParseRdpNegCorrelationInfo(data, ref currentIndex);
}
}
else
{
requestPdu.rdpNegData = null;
}
}
// Check if data length exceeded expectation
if(data.Length != currentIndex)
{
server.AddWarning("{0} bytes of extra data found when decoding X224 Connection Request PDU", data.Length - currentIndex);
}
// temprory command out for winblue behavior change
// VerifyDataLength(data.Length, currentIndex, ConstValue.ERROR_MESSAGE_DATA_LENGTH_EXCEEDED);
return requestPdu;
}
/// <summary>
/// Create an instance of the class that is identical to the current PDU.
/// </summary>
/// <returns>The new instance.</returns>
public override StackPacket Clone()
{
Client_X_224_Connection_Request_Pdu cloneX224Pdu = new Client_X_224_Connection_Request_Pdu(context);
cloneX224Pdu.tpktHeader = tpktHeader;
cloneX224Pdu.x224Crq = x224Crq;
if (routingToken != null)
{
cloneX224Pdu.routingToken = (byte[])routingToken.Clone();
}
if (rdpNegData != null)
{
cloneX224Pdu.rdpNegData = new RDP_NEG_REQ();
cloneX224Pdu.rdpNegData.type = rdpNegData.type;
cloneX224Pdu.rdpNegData.flags = rdpNegData.flags;
cloneX224Pdu.rdpNegData.length = rdpNegData.length;
cloneX224Pdu.rdpNegData.requestedProtocols = rdpNegData.requestedProtocols;
}
return cloneX224Pdu;
}
