diff -r 000000000000 -r bde4ae8d615e os/ossrv/lowlevellibsandfws/apputils/bsul/test/t_clientmessage/testclientmessageschema.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/ossrv/lowlevellibsandfws/apputils/bsul/test/t_clientmessage/testclientmessageschema.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,261 @@ +// 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 +#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 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 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));