// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#include "clientmessagecmn.h"

using namespace BSUL;

/**

Base 64 decoding table

*/

const TInt8 AsciiToBase64[80]=

	{

	 62, -1, -1, -1, 63, 52, 53, 54, 55, 56,

	 57, 58, 59, 60, 61, -1, -1, -1, 64, -1,

	 -1, -1,  0,  1,  2,  3,  4,  5,  6,  7,

	  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,

	 18, 19, 20, 21, 22, 23, 24, 25, -1, -1,

	 -1, -1, -1, -1, 26, 27, 28, 29, 30, 31,

	 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,

	 42, 43, 44, 45, 46, 47, 48, 49, 50, 51

	};

/**

Base 64 encoding table

*/	

const TInt8 Base64ToAscii[65]=

	{

	 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,

	 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,

	 85, 86, 87, 88, 89, 90, 97, 98, 99,100,

	101,102,103,104,105,106,107,108,109,110,

	111,112,113,114,115,116,117,118,119,120,

	121,122, 48, 49, 50, 51, 52, 53, 54, 55,

	 56, 57, 43, 47, 61 

	};

const TInt8 KImcvLookUpStartOffset = 43;

const TUint8 KImcvConvEquals = '=';

/**

The maximum number of US ASCII characters per line that are before the CRLF line

terminator when sending emails.  RFC 2822 recommends that each line SHOULD not exceed

80 characters including the CRLF terminator, and MUST not exceed 1000.

*/

const TInt KMaxB64EncodedCharsPerLine = 60; // Could be increased to 75 characters for every encoded line if KDecodeLineLength = 675.  60 was chosen to maintain existing behaviour.

/**

Parameter factory function lookup table.  This is used to instantiate a 

CMessageParameterBase derived object based on a TParamType enum value

*/

const TMessageParameterFactoryFn KParameterFactoryFunctions[] = {NULL,

															CIntParameter::NewL,

															CDes8ReadParameter::NewL,

															CDes8Parameter::NewL,

															CPckgParameter::NewL,

															CDes16ReadParameter::NewL,

															CDes16Parameter::NewL,

															CPtrParameter::NewL};

/**

Panic string for client message framework panic

*/

#ifdef _DEBUG

_LIT(KPanicCategory,"BSUL::ClientMsg");

#endif

const TInt KMaxServerNameLength = 32;

/**

This static function is used to panic the server in case of

incorrect use of CMessageParameterBase APIs or a badly formed

message schema

@param 	aPanic The Panic value

*/

void PanicServer(TInt aPanic)

	{

	_LIT(KUnknownServer, "Unknown");

	TBuf<KMaxServerNameLength> serverName(KUnknownServer);

	//Get the TLS data for this thread

	TClientMessageServerData* serverData = static_cast<TClientMessageServerData*>(Dll::Tls());

	if(serverData != NULL)

		{

		TPtrC8 name(serverData->iServerName);

		serverName.Copy(name);

		}

	User::Panic(serverName, aPanic);

	}

/**

Static initialisation function for ClientMessage Framework

@param 	aServerData The initialisation data for the server using the library

@leave Any system wide error code

*/

EXPORT_C void CClientMessage::InitialiseFrameworkL(const TClientMessageServerData& aServerData)

	{

	__ASSERT_DEBUG(User::StringLength(aServerData.iServerName) <= KMaxServerNameLength, User::Invariant());

	Dll::SetTls((TAny*)&aServerData);

	}

/**

Static factory function for CClientMessage class

@param 	aMessage The message that this object encapsulates

@return Pointer to a fully constructed CClientMessage object.

@leave  KErrNotInitialised if the framework has not been initialised by a 

		call to InitialiseFrameworkL.

*/

EXPORT_C CClientMessage* CClientMessage::NewL(const RMessage2& aMessage)

	{

	const TClientMessageServerData* serverData = static_cast<const TClientMessageServerData*>(Dll::Tls());

	if(serverData == NULL)

		{

		User::Leave(KErrNotInitialised);

		}

	CClientMessage* self = new(ELeave) CClientMessage(aMessage,*serverData);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/**

Second phase constructor of CClientMessage Object

Finds the schema for this message and checks the caller against the security

policy defined for this message.  Traverses the array of message parameters

and instantiates a CMessageParameterBase object for each parameter and adds these

to its internal array.

@leave  KErrInvalidFunction If the message function is not found in the message table

@leave  KErrBadHandle if the message handle is Null

@leave KErrPermissionDenied if the security policy for this message is not satisfied

*/

void CClientMessage::ConstructL()

	{

	if(!iMessage.IsNull())

		{

		//Find the message schema for this message.

		const TClientMessageSchema* messageSchema = FindMessageSchema();

		if(!messageSchema)

			{

			LogBadMessageL(KErrInvalidFunction);

			User::Leave(KErrInvalidFunction);

			}

		//Check message against security policy

		CheckSecurityPolicyL(messageSchema->iPolicy);

		//iterate through message parameters and instantiate all parameter objects

		for(int index = 0;index < messageSchema->iParamCount;index++)

			{	

			CMessageParameterBase* parameter = 

					CMessageParameterBase::CreateL(messageSchema->iParams[index], index, iMessage);		

			//Some parameter types are defined to be ignored.  These

			//should not be added to the list of parameters

			if(parameter != NULL)

				{

				//AppendL can leave so use cleanupstack to ensure that memory is not

				//leaked if AppendL leaves.

				CleanupStack::PushL(parameter);

				iParameters.AppendL(parameter);

				CleanupStack::Pop(parameter);

				}

			}

		}

	else

		{

		LogBadMessageL(KErrBadHandle);

		User::Leave(KErrBadHandle);

		}

	}

/**

Constructor for CClientMessage Object

@param aMessage The RMessage2 to be represented by this object

@param aServerData The Initialisation data for the server creating this object

*/

EXPORT_C CClientMessage::CClientMessage(const RMessage2& aMessage, 

						const TClientMessageServerData& aServerData) 

		: iParameters(KMaxParameters), iMessage(aMessage),

		iServerData(aServerData),iFlags(aServerData.iFlags & 0xFFFF0000)

	{	

	}

/**

Destructor for CClientMessageObject

*/

EXPORT_C CClientMessage::~CClientMessage()

	{

	for(int i = 0; i < iParameters.Count();i++)

		{

		delete iParameters[i];

		}

	iParameters.Reset();

	}

EXPORT_C const RMessage2& CClientMessage::Message()

	{

	return iMessage;

	}

/**

Panics the client through the message object

set an internal flag to indicate that the RMessage reference handle is now NULL

due to the client thread being tidied up.

@param 	aServer The Panic category

@param 	aPanic The Panic value

*/

EXPORT_C void CClientMessage::PanicClient(const TDesC& aServer, TInt aPanic)

	{

	iMessage.Panic(aServer, aPanic);

	iFlags.Set(EFlagPanicClient);

	}

/**

Checks a message against the security policy defined for the server

@param aPolicy The security policy to check this message against

@leave	KErrPermissionDenied if the message does not fulfil the security policy

*/

void CClientMessage::CheckSecurityPolicyL(const TSecurityPolicy& aPolicy)

	{

	if(!(aPolicy.CheckPolicy(iMessage,

				"Client failed security policy check for this server")))

		{

		User::Leave(KErrPermissionDenied);

		}

	return;

	}

/**

Finds a message schema in the message table for this server.

Does a binary search on the function number to pull the correct

message from the table.  Note that this assumes that the table

is sorted.

@return	A pointer to a TClientMessageSchema object in the message table, or Null if 

		the message does not correpsond to a message in the message table

*/

const TClientMessageSchema* CClientMessage::FindMessageSchema()

	{

	//This should always be less than KNumClientMessages 

	TInt function = iMessage.Function();

	TInt beg = 0;

	TInt end = iServerData.iMessageCount - 1;

	TInt mid = 0;

	TInt midFn = 0;

	while(beg <= end)

		{

		mid = (end + beg)/2;

		midFn = iServerData.iMessageSchema[mid].iFunction;

		if(midFn > function)

			{

			end = mid - 1;

			}	

		else if(midFn < function)

			{

			beg = mid + 1;

			}	

		else

			{

			return &iServerData.iMessageSchema[mid];

			}

		}

	return NULL;

	}

/**

Validates the message parameters against the constraints provided 

in the message table

@leave	KErrBadMessage if the message fails validation against the criteria supplied in the 

		message table

@leave	Any system-wide error code

*/

EXPORT_C void CClientMessage::ValidateL()

	{

	for(int i = 0; i < iParameters.Count();i++)

		{

		iParameters[i]->ValidateL();

		iFlags.Set(i);

		}

	}

/**

Validates a single message argument against the constraints provided 

in the message table

@param aParam The index value identifying the argument to validate

@leave	KErrBadMessage if the message fails validation against the criteria supplied in the 

		message table for the requested argument

@leave	KErrArgument if aParam is negative or is greater than the number of parameters for

		this message

@leave	Any system-wide error code

*/

EXPORT_C void CClientMessage::ValidateL(TInt aParam)

	{

	if(( aParam >= 0) && (aParam < iParameters.Count()))

		{	

		iParameters[aParam]->ValidateL();

		iFlags.Set(aParam);

		}

	else

		{

		User::Leave(KErrArgument);

		}

	}

/**

Checks if a given parameter has been validated

@param aParam The index value identifying the paramater to check

@leave	KErrArgument if aParam is not a valid parameter value

@leave	KErrNotValidated if the parameter has not been validated

*/

void CClientMessage::CheckValidatedL(TInt aParam)

	{

	if((aParam < EFlagParam0Validated) || (aParam > EFlagParam3Validated))

		{

		User::Leave(KErrArgument);

		}

	if(!iFlags.IsSet(aParam))

		{

		User::Leave(KErrNotValidated);

		}

	}

/**

Checks if a bad messages should be logged

@return True if bad messages should be logged

*/

TBool CClientMessage::LogBadMessages()

	{

	return iFlags.IsSet(EFlagLogBadMessages);

	}

/**

Checks if a bad messages should be logged

@param aError The error code to log

*/

void CClientMessage::LogBadMessageL(TInt aError)

	{

	//Check if logging of bad messages is enabled

	if(LogBadMessages())

		{

		TUid sid = TUid(iMessage.SecureId());

		TUidName clientSid = sid.Name();

		TInt function = Function();

		TBuf<KMaxServerNameLength> serverName;

		TPtrC8 name(iServerData.iServerName);

		serverName.Copy(name);

		switch(aError)

			{			

	#ifdef _DEBUG	

			case KErrInvalidFunction:

				RDebug::Print(_L("%S - CClientMessage Error: %d, Function %d. Unknown function request from client %S.\n"),

								&serverName,aError,function, &clientSid);

				break;

			case KErrBadParameter:

				RDebug::Print(_L("%S - CClientMessage Error: %d, Function %d. Bad argument in IPC request from client %S.\n"),

								&serverName,aError,function, &clientSid);

				break;

			case KErrBadMessageSchema:

				RDebug::Print(_L("%S - CClientMessage Error: %d, Function %d. Message schema incotrectly defined for this function %S.\n"),

								&serverName,aError,function, &clientSid);

				break;

			case KErrBadDescriptor:

			case KErrOverflow:

				RDebug::Print(_L("%S - CClientMessage Error: %d, Function %d. Bad descriptor argument in IPC request from client %S.\n"),

								&serverName,aError,function, &clientSid);

				break;

			case KErrNotValidated:

				RDebug::Print(_L("%S - CClientMessage Error: %d, Function %d. Message parameter not validated before use %S.\n"),

								&serverName,aError,function, &clientSid);

				break;

			default:

				RDebug::Print(_L("%S - CClientMessage Error: %d, Function %d. Bad message received from client %S.\n"),

										&serverName,aError,function, &clientSid);

			break;

	#else	

			default:

				break;

	#endif

			}

		}

	}

/**

Completes the message request or Panics the client if a

message error has occured.

@param aError The error value to complete the message with

*/

EXPORT_C void CClientMessage::CompleteRequestL(TInt aError)

	{

	//If server panics client 

	//then iMessage will be NULL

	if(!iFlags.IsSet(EFlagPanicClient))

		{

		if(aError != KErrNone)

			{

			LogBadMessageL(aError);

			}

		switch(aError)

			{

			case KErrInvalidFunction:

			case KErrBadDescriptor:

			case KErrOverflow:

				{

				//Check if Panic is disabled

				if( iFlags.IsClear(EFlagDoNotPanicClientOnBadMessageErrors) )

					{

					TBuf<KMaxServerNameLength> serverName;

					TPtrC8 name(iServerData.iServerName);

					serverName.Copy(name);

					PanicClient(serverName, aError);

					break;

					}

				}

			default:

				{	

				iMessage.Complete(aError);

				break;

				}

			}//switch

		}//if

	}

/**

Gets the function number of this message

@return The function number of this message

*/

EXPORT_C TInt CClientMessage::Function()

	{

	return iMessage.Function();

	}

/**

Gets the requested message argument as an integer value

@param aParam The parameter number to retrieve

@return The Int value for the requested parameter

@leave	KErrNotValidated if the message parameter has not been validated

		KErrWrongParameterType in UREL is the parameter requested is not an integer type

		Any other system wide error code

@panic ECMPanicWrongParameterType If this function is called for a parameter 

type that is not CIntParameter.

*/

EXPORT_C TInt CClientMessage::GetIntL(TInt aParam)

	{	

	CheckValidatedL(aParam);

	return iParameters[aParam]->GetIntL();

	}

/**

Gets the requested message argument as an TAny*

@param aParam The parameter number to retrieve

@return The TAny* for the requested parameter

@leave	KErrNotValidated if the message parameter has not been validated

		KErrWrongParameterType in UREL is the parameter requested is not an Ptr type

		Any other system wide error code

@panic ECMPanicWrongParameterType If this function is called for a parameter 

type that is not CPtrParameter.

*/

EXPORT_C const TAny* CClientMessage::GetPtrL(TInt aParam)

	{	

	CheckValidatedL(aParam);

	return iParameters[aParam]->GetPtrL();

	}

/**

Gets a reference to the local copy of the descriptor read from the message

@param aParam The parameter number of the descriptor to retrieve

@leave	KErrNotValidated if the message parameter has not been validated

		KErrWrongParameterType in UREL is the parameter requested is not a readable

		TDes8 type

		Any other system wide error code

@panic ECMPanicWrongParameterType If this function is called for a parameter 

type that is not CDes8ReadParameter.

*/

EXPORT_C const TDesC8& CClientMessage::GetDes8L(TInt aParam)

	{

	CheckValidatedL(aParam);

	return iParameters[aParam]->GetDes8L();

	}

/**

Gets a reference to the local copy of the descriptor read from the message

@param aParam The parameter number of the descriptor to retrieve

@leave	KErrNotValidated if the message parameter has not been validated