// 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 <e32capability.h>
#include "t_clientmessagetestserver.h"

using namespace BSUL;

enum TCustomParamType
	{
	EParamCustom1 = (0x10000 | EParamPckg),
	EParamCustom2 = (0x20000 | EParamPckg),
	EParamCustom3 = (0x30000 | EParamInt),
	EParamCustom4 = (0x40000 | EParamDes16Read),
	EParamCustom5 = (0x90000 | EParamPckg)
	};


/* These are the parameter description sets for each message to be handled by the
 * server. These descriptions provide the type of the parameter and constraints
 * used to validate messages recieved from the client.  The particular validation
 * requirements are defined in the appropriate CMessageParameterBase derived class
 * and parameter objects are instantiated via the Parameter factory Lookup table.
 */
//Integer parameter set
const TParameterDetails KMessage0Params[2] = {{EParamInt,-10,100},{EParamInt,0,200}};

//These parameter sets are incorrectly defined. Attempts to call this message should
//panic the server.
const TParameterDetails KMessage2Params[1] = {{EParamInt,100,10}};
const TParameterDetails KMessage3Params[1] = {{EParamInt,-10,-20}};

//Des*Read parameter sets
const TParameterDetails KMessage4Params[2] = {{EParamDes8Read,2,16},{EParamDes16Read,0,32}};

//These parameter sets are incorrectly defined. Attempts to call this message should
//panic the server.
const TParameterDetails KMessage8Params[1] = {{EParamDes8Read,0,-16}};

//Des* parameter sets
const TParameterDetails KMessage9Params[4] = {{EParamDes8,64,64},
												{EParamInt,0,64},
												{EParamDes16,128,128},
												{EParamInt,0,128}};

const TParameterDetails KMessage11Params[4] = {{EParamDes8,64,64},
												{EParamInt,0,64},
												{EParamDes16,128,128},
												{EParamInt,0,128}};

//These parameter sets are incorrectly defined. Attempts to call this message should
//panic the server.
const TParameterDetails KMessage12Params[1] = {{EParamDes8,-64,64}};
const TParameterDetails KMessage13Params[1] = {{EParamDes8,64,-64}};

//Des parameter sets
const TParameterDetails KMessage14Params[3] = {{EParamDes8Read,0,16},
												{EParamInt,0,16},
												{EParamDes8,16,16}};

const TParameterDetails KMessage15Params[3] = {{EParamDes16Read,0,64},
												{EParamInt,0,64},
												{EParamDes16,64,64}};

//Ptr parameter sets
const TParameterDetails KMessage16Params[1] = {{EParamPtr,0,0}};


//Custom parameter sets
const TParameterDetails KMessage18Params[1] = {{EParamCustom1,sizeof(CMTestStruct2),sizeof(CMTestStruct2)}};
const TParameterDetails KMessage19Params[1] = {{EParamCustom2,sizeof(CMTestStruct1),sizeof(CMTestStruct1)}};

//Invalid parameter type
const TParameterDetails KMessage27Params[1] = {{453,0,0}};

//standard param types with custom validation functions
//Custom parameter sets
const TParameterDetails KMessage28Params[1] = {{EParamCustom3,0,0}};
const TParameterDetails KMessage29Params[1] = {{EParamCustom4,0,32}};

//Pkg parameter
const TParameterDetails KMessage30Params[1] = {{EParamPckg,sizeof(CMTestStruct1),sizeof(CMTestStruct1)}};

const TParameterDetails KMessage31Params[2] = {{EParamInt,EGetIntL,EWrite16L},{EParamPtr,0,0}};

//Custom parameter type. EParamCustom5 is incorrectly defined as the validation function
//index is outside the range of the supplied validation fuction array
const TParameterDetails KMessage32Params[1] = {{EParamCustom5,sizeof(CMTestStruct1),sizeof(CMTestStruct1)}};



/* This Security Policy defines the requirements for a client to interact
 * with the server. If a client sends a request to the server and doesnt
 * meet the security policy, the request is denied with KErrAccessDenied.
 * 
 */
_LIT_SECURITY_POLICY_PASS(KDefaultPolicy);
_LIT_SECURITY_POLICY_FAIL(KFailPolicy);
_LIT_SECURITY_POLICY_S0(KSidPassPolicy,0x10285B57);
_LIT_SECURITY_POLICY_S0(KSidFailPolicy,0x12345678);
_LIT_SECURITY_POLICY_C2(KCapFailPolicy,ECapabilityReadUserData,ECapabilityPowerMgmt);
_LIT_SECURITY_POLICY_C2(KCapPassPolicy,ECapabilityReadUserData,ECapabilityWriteUserData);

/* This is the array of messages that will be accepted by the server.  
 * The messages are defined as follows:
 *  	{Function Number, Number of Parameters, Parameter Descriptions}
 * When loading the message objects, this table is traversed and so the most 
 * frequently called messages should be first in the list to ensure the most
 * efficient operation
 */
const TClientMessageSchema KClientMessages[] = 
	{
	MESSAGE_SCHEMA(ETestMessage0,KDefaultPolicy,KMessage0Params),
	MESSAGE_SCHEMA(ETestMessage1,KDefaultPolicy,KMessage0Params),
	MESSAGE_SCHEMA(ETestMessage2,KDefaultPolicy,KMessage2Params),
	MESSAGE_SCHEMA(ETestMessage3,KDefaultPolicy,KMessage3Params),
	MESSAGE_SCHEMA(ETestMessage4,KDefaultPolicy,KMessage4Params),
	MESSAGE_SCHEMA(ETestMessage5,KDefaultPolicy,KMessage4Params),
	MESSAGE_SCHEMA(ETestMessage6,KDefaultPolicy,KMessage4Params),
	MESSAGE_SCHEMA(ETestMessage7,KDefaultPolicy,KMessage4Params),
	MESSAGE_SCHEMA(ETestMessage8,KDefaultPolicy,KMessage8Params),											 
	MESSAGE_SCHEMA(ETestMessage9,KDefaultPolicy,KMessage9Params),
	MESSAGE_SCHEMA(ETestMessage10,KDefaultPolicy,KMessage9Params),
	MESSAGE_SCHEMA(ETestMessage11,KDefaultPolicy,KMessage11Params),
	MESSAGE_SCHEMA(ETestMessage12,KDefaultPolicy,KMessage12Params),
	MESSAGE_SCHEMA(ETestMessage13,KDefaultPolicy,KMessage13Params),
	MESSAGE_SCHEMA(ETestMessage14,KDefaultPolicy,KMessage14Params),
	MESSAGE_SCHEMA(ETestMessage15,KDefaultPolicy,KMessage15Params),
	MESSAGE_SCHEMA(ETestMessage16,KDefaultPolicy,KMessage16Params),
	MESSAGE_SCHEMA(ETestMessage17,KDefaultPolicy,KMessage16Params),
	MESSAGE_SCHEMA(ETestMessage18,KDefaultPolicy,KMessage18Params),
	MESSAGE_SCHEMA(ETestMessage19,KDefaultPolicy,KMessage19Params),
	MESSAGE_SCHEMA(ETestMessage20,KFailPolicy,KMessage0Params),
	MESSAGE_SCHEMA(ETestMessage21,KSidPassPolicy,KMessage0Params),
	MESSAGE_SCHEMA(ETestMessage22,KSidFailPolicy,KMessage0Params),
	MESSAGE_SCHEMA(ETestMessage23,KCapPassPolicy,KMessage0Params),
	MESSAGE_SCHEMA(ETestMessage24,KCapFailPolicy,KMessage0Params),
	MESSAGE_SCHEMA_NO_PARAMS(ETestMessage25,KDefaultPolicy),
	MESSAGE_SCHEMA(ETestMessage26,KDefaultPolicy,KNoParams),
	MESSAGE_SCHEMA(ETestMessage27,KDefaultPolicy,KMessage27Params),
	MESSAGE_SCHEMA(ETestMessage28,KDefaultPolicy,KMessage28Params),
	MESSAGE_SCHEMA(ETestMessage29,KDefaultPolicy,KMessage29Params),
	MESSAGE_SCHEMA(ETestMessage30,KDefaultPolicy,KMessage30Params),
	MESSAGE_SCHEMA(ETestMessage31,KDefaultPolicy,KMessage31Params),
	MESSAGE_SCHEMA(ETestMessage32,KDefaultPolicy,KMessage32Params)
	};
														 
static void ValidationFn1L(CMessageParameterBase* aParameter);
static void ValidationFn2L(CMessageParameterBase* aParameter);
static void ValidationFn3L(CMessageParameterBase* aParameter);
static void ValidationFn4L(CMessageParameterBase* aParameter);

const TCustomValidationFn KCustomValidationFunctions[] = {NULL,
														&ValidationFn1L,
														&ValidationFn2L,
														&ValidationFn3L,
														&ValidationFn4L};

extern const TClientMessageServerData KServerData = SERVER_DATA(KClientMessages,
																KCustomValidationFunctions,
																"CMTestServer",
																ESrvFlagLogBadMessages);

void ValidationFn1L(CMessageParameterBase* aParameter)
	{
	CMTestStruct2 struct1;

	TPckg<CMTestStruct2> pData(struct1);
	
	if(aParameter->GetDesLengthL() != sizeof(CMTestStruct2))
		{
		User::Leave(KErrBadDescriptor);
		}
	
	aParameter->ReadL(pData,0);
	
	if((struct1.iEnum < ETestVal0)||(struct1.iEnum > ETestVal3))
		{
		User::Leave(KErrBadParameter);
		}
	
	if(struct1.iDes.Length() <= 0)
		{
		User::Leave(KErrBadParameter);
		}
	
	if(struct1.iCount < 0)
		{
		User::Leave(KErrBadParameter);
		}	
	}

void ValidationFn2L(CMessageParameterBase* aParameter)
	{
	CMTestStruct1 struct1;
	TPckg<CMTestStruct1> pData(struct1);
	
	aParameter->ReadL(pData,0);
	
	if(struct1.iInt <= 0)
		{
		User::Leave(KErrBadParameter);
		}
	}

void ValidationFn3L(CMessageParameterBase* aParameter)
	{
	
	TInt value = aParameter->GetIntL();
	
	if(value%4 != 0)
		{
		User::Leave(KErrBadParameter);
		}

	}

void ValidationFn4L(CMessageParameterBase* aParameter)
	{
	TBuf<32> data;
	
	aParameter->ReadL(data,0);
	
	if(data != _L("Expected Data"))
		{
		User::Leave(KErrBadParameter);
		}
	}


//parameter sets for server2
const TParameterDetails KMessage0Params2[2] = {{EParamInt,0,10},{EParamInt,-100,100}};

/* Descriptor parameter for server2 */
const TParameterDetails KMessage1Params2[1] = {{EParamDes8Read,0,16}};

/* This is the array of messages that will be accepted by the server.  
 * The messages are defined as follows:
 *  	{Function Number, Number of Parameters, Parameter Descriptions}
 */
const TClientMessageSchema KClientMessages2[] = {MESSAGE_SCHEMA(ETestMessage0,KDefaultPolicy,KMessage0Params2),
												MESSAGE_SCHEMA(ETestMessage1,KDefaultPolicy,KMessage1Params2)};

const TCustomValidationFn KCustomValidationFunctions2[] = {NULL};

extern const TClientMessageServerData KServer2Data = SERVER_DATA(KClientMessages2,
																KCustomValidationFunctions2,
																"CMTestServer2",
																(ESrvFlagLogBadMessages | ESrvFlagDoNotPanicClientOnBadMessageErrors));