serverRoom/backend-csharp/amt-sdk-20-0-0-1/MPSModule/Src/MPS_Src/APF.cpp

//----------------------------------------------------------------------------
//
//  Copyright (C) Intel Corporation, 2006 - 2007.
//
//  File:       APF.cpp
//
//  Contents:   APF (Intel(R) AMT Port Forwarding protocol).
//
//  Notes:      Version 1.0
//----------------------------------------------------------------------------

#include "APF.h"
#include "global.h"
#include "OptionsUtils.h"

// Messages serialization
STATUS  APF_Disconnect::read (ACE_SOCK_Stream &stream)
{
	READ_ERROR(stream, reason);
	READ_ERROR(stream, reserved);
	return STATUS_SUCCESS;
}

STATUS APF_ServiceRequest::read (ACE_SOCK_Stream &stream)
{
	READ_MAX_ERROR(stream, serviceNameLength, APF_MAX_SERVICE_NAME_LENGTH);
	READ_STR_ERROR(stream, serviceName, serviceNameLength);
	return STATUS_SUCCESS;
}

STATUS APF_UserauthRequest::read(ACE_SOCK_Stream &stream)
{
	READ_MAX_ERROR(stream, usernameLength, APF_MAX_USERNAME_LENGTH);
	READ_STR_ERROR(stream, username, usernameLength);

	READ_MAX_ERROR(stream, serviceNameLength, APF_MAX_SERVICE_NAME_LENGTH);
	READ_STR_ERROR(stream, serviceName, serviceNameLength);

	READ_MAX_ERROR(stream, methodNameLength, APF_MAX_METHOD_NAME_LENGTH);
	READ_STR_ERROR(stream, methodName, methodNameLength);

	if (methodName.compare(APF_USERAUTH_NONE) == 0)
		return STATUS_SUCCESS;

	if (methodName.compare(APF_USERAUTH_PASSWORD) != 0)
		return STATUS_ILLEGAL_APF_MESSAGE;
	
	// If method name = "password"
	READ_ERROR		(stream, reserved);
	READ_MAX_ERROR	(stream, passwordLength, APF_MAX_PASSWORD_LENGTH);
	READ_STR_ERROR	(stream, password, passwordLength);

	return STATUS_SUCCESS;
}
STATUS APF_GlobalRequestHeader::read(ACE_SOCK_Stream &stream)
{
	READ_MAX_ERROR	(stream, stringLen, APF_MAX_GLOBAL_STRING_LENGTH);
	READ_STR_ERROR	(stream, requestString, stringLen);
	READ_ERROR		(stream, wantReply);
	
	return STATUS_SUCCESS;
}

STATUS APF_ProtocolVersion::read(ACE_SOCK_Stream &stream)
{
	int res;
	READ_ERROR(stream, majorVersion);
	READ_ERROR(stream, minorVersion);
	READ_ERROR(stream, triggerReason);
	const time_t &timeout = *getMaxTunnelTimeout();
	if ((res = stream.recv_n(systemId,16,&ACE_Time_Value(timeout)))<=0) 
		return STATUS_NETWORK_ERROR;
	if ((res = stream.recv_n(reserved,64,&ACE_Time_Value(timeout)))<=0) 
		return STATUS_NETWORK_ERROR;
	return STATUS_SUCCESS;
}

STATUS APF_TcpForwardRequest::read(ACE_SOCK_Stream &stream)
{
	READ_MAX_ERROR(stream, addressToBindLength, APF_MAX_ADDRESS_SIZE);
	READ_STR_ERROR(stream, addressToBind, addressToBindLength);
	READ_ERROR	  (stream, port);
	return STATUS_SUCCESS;
}

STATUS APF_TcpForwardCancelRequest::read(ACE_SOCK_Stream &stream)
{
	READ_MAX_ERROR(stream, addressToBindLength, APF_MAX_ADDRESS_SIZE);
	READ_STR_ERROR(stream, addressToBind, addressToBindLength);
	READ_ERROR	  (stream, port);
	return STATUS_SUCCESS;
}

STATUS APF_UdpSendTo::read(ACE_SOCK_Stream &stream)
{
	READ_MAX_ERROR(stream, hostStrLen, APF_MAX_ADDRESS_SIZE);
	READ_STR_ERROR(stream, hostStr, hostStrLen);
	READ_ERROR	  (stream, port);
	READ_MAX_ERROR(stream, originatorIpAddressLen, APF_MAX_ADDRESS_SIZE);
	READ_STR_ERROR(stream, originatorIpAddress, originatorIpAddressLen);
	READ_ERROR	  (stream, originatorPort);
	READ_ERROR	  (stream, dataLength);
	READ_STR_ERROR(stream, data, dataLength);

	return STATUS_SUCCESS;
}

STATUS APF_ChannelOpenDirectRequest::read(ACE_SOCK_Stream &stream)
{
	READ_MAX_ERROR(stream, channelTypeStringLen, APF_MAX_CHANNEL_TYPE_STRING);
	READ_STR_ERROR(stream, channelTypeString, channelTypeStringLen);
	READ_ERROR	  (stream, senderChannel);
	READ_ERROR	  (stream, initialWindowSize);
	READ_ERROR	  (stream, reserved);
	READ_MAX_ERROR(stream, targetHostStringLen, APF_MAX_ADDRESS_SIZE);
	READ_STR_ERROR(stream, targetHostString, targetHostStringLen);
	READ_ERROR	  (stream, targetPort);
	READ_MAX_ERROR(stream, originatorIpAddressLen, APF_MAX_ADDRESS_SIZE);
	READ_STR_ERROR(stream, originatorIpAddress, originatorIpAddressLen);
	READ_ERROR	  (stream, originatorPort);
	return STATUS_SUCCESS;
}

STATUS APF_ChannelOpenReply::read(ACE_SOCK_Stream &stream)
{
	READ_ERROR	  (stream, recipientChannel);
	READ_ERROR	  (stream, senderChannel);
	READ_ERROR	  (stream, initialWindowSize);
	READ_ERROR	  (stream, reserved);
	return STATUS_SUCCESS;
}

STATUS APF_ChannelClose::read(ACE_SOCK_Stream &stream)
{
	READ_ERROR(stream, recipientChannel);
	return STATUS_SUCCESS;
}


STATUS APF_ChannelData::read(ACE_SOCK_Stream &stream)
{
	READ_ERROR	  (stream, recipientChannel);
	READ_ERROR	  (stream, dataLen);
	READ_STR_ERROR(stream, data, dataLen);
	return STATUS_SUCCESS;
}

STATUS APF_ChannelWindowAdjust::read(ACE_SOCK_Stream &stream)
{
	READ_ERROR	  (stream, recipientChannel);
	READ_ERROR	  (stream, bytesToAdd);
	return STATUS_SUCCESS;
}

STATUS APF_KeepAliveReq::read(ACE_SOCK_Stream &stream)
{
	READ_ERROR	  (stream, _cookie);
	return STATUS_SUCCESS;
}

STATUS APF_KeepAliveOptionReq::read(ACE_SOCK_Stream &stream)
{
	READ_ERROR	  (stream, _keepalive_interval);
	READ_ERROR	  (stream, _read_timeout);
	return STATUS_SUCCESS;
}

// Messages deserialization
void APF_Disconnect::write(ACE_Message_Block *&mb)
{
	mb = new ACE_Message_Block (this->size(),
                                MB_DISCONNECT);
	Protocol_BasicMessage::write(mb, (ACE_UINT8) APF_DISCONNECT);
	Protocol_BasicMessage::write(mb, reason);
	Protocol_BasicMessage::write(mb, reserved);
}

void APF_ServiceAccept::write(ACE_Message_Block *&mb) 
{
	mb = new ACE_Message_Block (this->size(),
		                          MB_APF_MESSAGE);
	Protocol_BasicMessage::write(mb, (ACE_UINT8) APF_SERVICE_ACCEPT);
	Protocol_BasicMessage::write(mb, serviceNameLength);
	Protocol_BasicMessage::write(mb, serviceName, serviceNameLength);
}

void APF_GlobalRequestHeader::write(ACE_Message_Block *&mb)
{
	mb = new ACE_Message_Block (this->size(),
                                MB_APF_MESSAGE);
	Protocol_BasicMessage::write(mb, (ACE_UINT8) APF_GLOBAL_REQUEST);
	Protocol_BasicMessage::write(mb, stringLen);
	Protocol_BasicMessage::write(mb, requestString, stringLen);
	Protocol_BasicMessage::write(mb, wantReply);
}

void APF_ProtocolVersion::write(ACE_Message_Block *&mb)
{	
	mb = new ACE_Message_Block (this->size(),
                                MB_APF_MESSAGE);
	Protocol_BasicMessage::write(mb,(ACE_UINT8)APF_PROTOCOLVERSION);
	Protocol_BasicMessage::write(mb, majorVersion);
	Protocol_BasicMessage::write(mb, minorVersion);
	Protocol_BasicMessage::write(mb, triggerReason);
	for (int i=0; i < 16; i++)
		Protocol_BasicMessage::write(mb, systemId[i]);
	for (int i=0; i < 16; i++)
		Protocol_BasicMessage::write(mb, reserved[i]);

}

void APF_TcpForwardReply::write(ACE_Message_Block *&mb)
{
	mb = new ACE_Message_Block (this->size(),
                                MB_APF_MESSAGE);
	Protocol_BasicMessage::write(mb, status);	
	if (status == APF_REQUEST_SUCCESS) {
		Protocol_BasicMessage::write(mb, portBound);
	}
}

void APF_ChannelOpenForwardedRequest::write(ACE_Message_Block *&mb)
{
	mb = new ACE_Message_Block (this->size(),
                                MB_APF_MESSAGE);
	Protocol_BasicMessage::write(mb, (ACE_UINT8)APF_CHANNEL_OPEN);
	Protocol_BasicMessage::write(mb, channelTypeStringLen);	
	Protocol_BasicMessage::write(mb, channelTypeString, channelTypeStringLen);
	Protocol_BasicMessage::write(mb, senderChannel);
	Protocol_BasicMessage::write(mb, initialWindowSize);
	Protocol_BasicMessage::write(mb, reserved);
	Protocol_BasicMessage::write(mb, connectedAddressStringLen);
	Protocol_BasicMessage::write(mb, connectedAddressString, connectedAddressStringLen);
	Protocol_BasicMessage::write(mb, connectedPort);
	Protocol_BasicMessage::write(mb, originatorIpAddressLen);
	Protocol_BasicMessage::write(mb, originatorIpAddress, originatorIpAddressLen);
	Protocol_BasicMessage::write(mb, originatorPort);
}

void APF_ChannelOpenReply::write(ACE_Message_Block *&mb)
{
	mb = new ACE_Message_Block (this->size(),
                                MB_APF_MESSAGE);
	Protocol_BasicMessage::write(mb, openChannelStatus);	
	Protocol_BasicMessage::write(mb, recipientChannel);
	Protocol_BasicMessage::write(mb, senderChannel);
	Protocol_BasicMessage::write(mb, initialWindowSize);
	Protocol_BasicMessage::write(mb, reserved);
}

void APF_ChannelClose::write(ACE_Message_Block *&mb)
{
	mb = new ACE_Message_Block (this->size(),
                                MB_APF_MESSAGE);
	Protocol_BasicMessage::write(mb, (ACE_UINT8)APF_CHANNEL_CLOSE);
	Protocol_BasicMessage::write(mb, recipientChannel);	
}

void APF_ChannelData::write(ACE_Message_Block *&mb)
{
	mb = new ACE_Message_Block (this->size(),
                                MB_APF_MESSAGE);
	Protocol_BasicMessage::write(mb, (ACE_UINT8)APF_CHANNEL_DATA);
	Protocol_BasicMessage::write(mb, recipientChannel);	
	Protocol_BasicMessage::write(mb, dataLen);
	Protocol_BasicMessage::write(mb, data, dataLen);
}

void APF_ChannelWindowAdjust::write(ACE_Message_Block *&mb)
{
	mb = new ACE_Message_Block (this->size(),
                                MB_APF_MESSAGE);
	Protocol_BasicMessage::write(mb, (ACE_UINT8)APF_CHANNEL_WINDOW_ADJUST);
	Protocol_BasicMessage::write(mb, recipientChannel);	
	Protocol_BasicMessage::write(mb, bytesToAdd);
}

void APF_KeepAliveReply::write(ACE_Message_Block *&mb)
{
	mb = new ACE_Message_Block (this->size(),
                                MB_APF_MESSAGE);
	Protocol_BasicMessage::write(mb, (ACE_UINT8)APF_KEEPALIVE_REPLY);
	Protocol_BasicMessage::write(mb, _cookie);	
}

void APF_KeepAliveOptionReply::write(ACE_Message_Block *&mb)
{
	mb = new ACE_Message_Block (this->size(),
                                MB_APF_MESSAGE);
	Protocol_BasicMessage::write(mb, (ACE_UINT8)APF_KEEPALIVE_OPTIONS_RESPONS);
	Protocol_BasicMessage::write(mb, _keepalive_interval);	
	Protocol_BasicMessage::write(mb, _read_timeout);
}

void APF_UserauthFailure::write(ACE_Message_Block *&mb)
{
	mb = new ACE_Message_Block (this->size(),
                                MB_APF_MESSAGE);
	Protocol_BasicMessage::write(mb, (ACE_UINT8)APF_USERAUTH_FAILURE);
	Protocol_BasicMessage::write(mb, methodNameListLength);
	Protocol_BasicMessage::write(mb, methodNameList, methodNameListLength);
	Protocol_BasicMessage::write(mb, (ACE_UINT8)0x0);
}
///////////////