diff -r 000000000000 -r e4d67989cc36 genericservices/taskscheduler/SCHSVR/ClientMessageSchema.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/genericservices/taskscheduler/SCHSVR/ClientMessageSchema.cpp Tue Feb 02 02:01:42 2010 +0200 @@ -0,0 +1,338 @@ +// 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 "CSCHCODE.H" +#include "SCHINFO.H" + +using namespace BSUL; + +/** +Intended Usage : This Enum lists the currently supported Custom Parameter types. +The lower 16 bits of these enum values are used as indices to the +Parameter Factory Function which instantiates the appropriate +CMessageParammeterBase derived object to represent a given message parameter. +The upper 16 bits of these values are used as the index in the array +of custom validation functions. If the upper 16bits are set to 0, the default +validation is used. +*/ +enum TCustomParamType + { + EParamTScheduleSettings2 = (0x10000 | EParamPckg), + EParamTTsTime = (0x20000 | EParamPckg), + EParamTTaskInfo = (0x30000 | EParamPckg), + EParamTScheduleInfo = (0x40000 | EParamPckg), + EParamTSchedulerItemRef = (0x50000 | 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. + */ +const TInt KMaxInt32 = 0x7FFFFFFF; +const TInt KMinInt32 = 0x80000000; +const TInt KMaxTDes8 = 0x0FFFFFFF; +const TInt KMaxSchedules = 25000;//Max of 25000 schedules +const TInt KMaxScheduleId = (10000 * (KMaxSchedules - 1));//Schedule IDs have an offset of 10000 +const TInt KMaxTasks = 9999;//Max of 9999 tasks per schedule +const TInt KMaxTaskId = (KMaxScheduleId + KMaxTasks); + +const TParameterDetails KIntParam[] = {EParamInt,KMinInt32,KMaxInt32}; + + +const TParameterDetails KRegisterClientParam[] = {{EParamDes16Read,0,KMaxFileName}, + {EParamInt,0,KMaxInt32}}; + +const TParameterDetails KCreateTimeSchedParam[] = {{EParamTScheduleSettings2,sizeof(TScheduleSettings2),sizeof(TScheduleSettings2)}, + {EParamDes8Read,0,KMaxTDes8}, + {EParamPckg,sizeof(TInt),sizeof(TInt)}}; + +const TParameterDetails KCreateCondSchedParam[] = {{EParamTScheduleSettings2,sizeof(TScheduleSettings2),sizeof(TScheduleSettings2)}, + {EParamDes8Read,0,KMaxTDes8}, + {EParamTTsTime, sizeof(TTsTime), sizeof(TTsTime)}, + {EParamPckg,sizeof(TInt),sizeof(TInt)}}; + +const TParameterDetails KScheduleTaskParam[] = {{EParamTTaskInfo,sizeof(TTaskInfo),sizeof(TTaskInfo)}, + {EParamInt,0,KMaxScheduleId}, + {EParamPckg,sizeof(TInt),sizeof(TInt)}, + {EParamDes16,0,KMaxTDes8}}; + +const TParameterDetails KScheduleIdParam[] = {EParamInt,0,KMaxScheduleId}; + +const TParameterDetails KEditTimeSchedParam[] = {{EParamInt,0,KMaxTasks}, + {EParamInt,0,KMaxScheduleId}, + {EParamDes8Read,0,KMaxTDes8}}; + +const TParameterDetails KEditCondSchedParam[] = {{EParamInt,0,KMaxTasks}, + {EParamInt,0,KMaxScheduleId}, + {EParamDes8Read,0,KMaxTDes8}, + {EParamTTsTime, sizeof(TTsTime), sizeof(TTsTime)}}; + +const TParameterDetails KGetSchedRefsParam[] = {{EParamInt,0,KMaxSchedules}, + {EParamInt,EAllSchedules,EPendingSchedules}, + {EParamDes8,0,KMaxTDes8}}; + +const TParameterDetails KCountSchedulesParam[] = {{EParamPckg,sizeof(TInt),sizeof(TInt)}, + {EParamInt,EAllSchedules,EPendingSchedules}}; + +const TParameterDetails KGetSchedInfoParam[] = {{EParamInt,0,KMaxScheduleId}, + {EParamDes8,sizeof(TScheduleInfo), sizeof(TScheduleInfo)}, + {EParamDes8, 0, sizeof(TTsTime)}}; + +const TParameterDetails KGetTimeSchedDataParam[] = {{EParamInt,0,KMaxScheduleId}, + {EParamTScheduleInfo,sizeof(TScheduleInfo), sizeof(TScheduleInfo)}, + {EParamDes8,0,KMaxTDes8}}; + +const TParameterDetails KGetCondSchedDataParam[] = {{EParamInt,0,KMaxScheduleId}, + {EParamTScheduleInfo,sizeof(TScheduleInfo), sizeof(TScheduleInfo)}, + {EParamDes8,0,KMaxTDes8}, + {EParamDes8, 0, sizeof(TTsTime)}}; + +const TParameterDetails KGetTaskDataParam[] = {{EParamInt,0,KMaxScheduleId}, + {EParamTScheduleInfo,sizeof(TScheduleInfo), sizeof(TScheduleInfo)}, + {EParamDes8,0,KMaxTDes8}}; + +const TParameterDetails KGetTaskRefsParam[] = {{EParamInt,0,KMaxTasks}, + {EParamInt,EAllSchedules,EPendingSchedules}, + {EParamInt,EAllTasks,EMyTasks}, + {EParamDes8,0,KMaxTDes8}}; + +const TParameterDetails KCountTasksParam[] = {{EParamPckg,sizeof(TInt),sizeof(TInt)}, + {EParamInt,EAllSchedules,EPendingSchedules}, + {EParamInt,EAllTasks,EMyTasks}}; + +const TParameterDetails KGetTaskParam[] = {{EParamInt,KMinInt32,KMaxInt32}, + {EParamDes8,0,sizeof(TTaskInfo)}, + {EParamInt,KMinInt32,KMaxInt32}, + {EParamDes16,0,KMaxTDes8}}; + +const TParameterDetails KGetScheduledItemRefParam[] = {{EParamInt,0,KMaxTaskId}, + {EParamDes8,0, sizeof(TSchedulerItemRef)}, + {EParamDes8,0, sizeof(TTsTime)}}; + +const TParameterDetails KDeleteTaskParam[] = {EParamInt,KMinInt32,KMaxInt32}; + +const TParameterDetails KGetTaskDataSizeParam[] = {{EParamInt,KMinInt32,KMaxInt32}, + {EParamPckg,sizeof(TInt),sizeof(TInt)}}; + +const TParameterDetails KGetScheduleTypeParam[] = {{EParamInt,0,KMaxScheduleId}, + {EParamPckg,sizeof(TInt),sizeof(TInt)}}; + + +/* 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. + * For the bakup server no policy is required so a default always pass + * policy is used. + */ +_LIT_SECURITY_POLICY_PASS(KDefaultPolicy); + +/* This is the array of messages that will be accepted by the server. + * The messages are defined as follows: + * {Function Number, Security Policy, Number of Parameters, Parameter Descriptions} + * A Binary search is used to locate the messages in the table therefore + * the messages MUST appear in the list below sorted by function number. + */ +const TClientMessageSchema KClientMessages[] = + { + MESSAGE_SCHEMA(ERegisterClient,KDefaultPolicy,KRegisterClientParam), + MESSAGE_SCHEMA(ECreateTimeSchedule,KDefaultPolicy,KCreateTimeSchedParam), + MESSAGE_SCHEMA(ECreateConditionSchedule,KDefaultPolicy,KCreateCondSchedParam), + MESSAGE_SCHEMA(EScheduleTask,KDefaultPolicy,KScheduleTaskParam), + MESSAGE_SCHEMA(EDisableSchedule,KDefaultPolicy,KScheduleIdParam), + MESSAGE_SCHEMA(EEnableSchedule,KDefaultPolicy,KScheduleIdParam), + MESSAGE_SCHEMA(EDeleteSchedule,KDefaultPolicy,KScheduleIdParam), + MESSAGE_SCHEMA(EEditTimeSchedule,KDefaultPolicy,KEditTimeSchedParam), + MESSAGE_SCHEMA(EEditConditionSchedule,KDefaultPolicy,KEditCondSchedParam), + MESSAGE_SCHEMA(EGetScheduleInfo,KDefaultPolicy,KGetSchedInfoParam), + MESSAGE_SCHEMA(EGetTimeScheduleData,KDefaultPolicy,KGetTimeSchedDataParam), + MESSAGE_SCHEMA(EGetConditionScheduleData,KDefaultPolicy,KGetCondSchedDataParam), + MESSAGE_SCHEMA(EGetTaskData,KDefaultPolicy,KGetTaskDataParam), + MESSAGE_SCHEMA(ECountSchedules,KDefaultPolicy,KCountSchedulesParam), + MESSAGE_SCHEMA(ECountTasks,KDefaultPolicy,KCountTasksParam), + MESSAGE_SCHEMA(EGetTaskRefs,KDefaultPolicy,KGetTaskRefsParam), + MESSAGE_SCHEMA(EGetTask,KDefaultPolicy,KGetTaskParam), + MESSAGE_SCHEMA(EGetTaskDataSize,KDefaultPolicy,KGetTaskDataSizeParam), + MESSAGE_SCHEMA(EGetScheduleRefs,KDefaultPolicy,KGetSchedRefsParam), + MESSAGE_SCHEMA(EDeleteTask,KDefaultPolicy,KDeleteTaskParam), + MESSAGE_SCHEMA(EGetSchedulerItemRefAndNextDueTime,KDefaultPolicy,KGetScheduledItemRefParam), + MESSAGE_SCHEMA(EGetScheduleType,KDefaultPolicy,KGetScheduleTypeParam), + MESSAGE_SCHEMA_NO_PARAMS(ESchDbgMarkHeap,KDefaultPolicy), + MESSAGE_SCHEMA(ESchDbgCheckHeap,KDefaultPolicy,KIntParam), + MESSAGE_SCHEMA(ESchDbgMarkEnd,KDefaultPolicy,KIntParam), + MESSAGE_SCHEMA(ESchDbgFailNext,KDefaultPolicy,KIntParam), + MESSAGE_SCHEMA_NO_PARAMS(ESchDbgResetHeap,KDefaultPolicy), + MESSAGE_SCHEMA_NO_PARAMS(ESchFaultServer,KDefaultPolicy) + }; + + +static void ValidateTTsTimeL(CMessageParameterBase* aParameter); +static void ValidateTTaskInfoL(CMessageParameterBase* aParameter); +static void ValidateTScheduleInfoL(CMessageParameterBase* aParameter); +static void ValidateTSchedulerItemRefL(CMessageParameterBase* aParameter); +static void ValidateTScheduleSettingsL(CMessageParameterBase* aParameter); + +/* This is the array of custom validation functions that are used to validate + * parameters based on CPckgParameter parameter types + */ +const TCustomValidationFn KCustomValidationFunctions[] = {NULL, + &ValidateTScheduleSettingsL, + &ValidateTTsTimeL, + &ValidateTTaskInfoL, + &ValidateTScheduleInfoL, + &ValidateTSchedulerItemRefL + }; + +/*This struct defines the server data to be passed to the message framework on + * initialisation + */ +extern const TClientMessageServerData KServerData = SERVER_DATA(KClientMessages, + KCustomValidationFunctions, + "Task Scheduler", + ESrvFlagLogBadMessages); + +/* +Custom validation function for EParamTTsTime parameters. +Checks that the TPckg passed in to the server is exactly the size +defined in the schema. Reads the value from the clients message to +ensure the data is valid. +@param aParameter The parameter object to be validated +@leave KErrBadDescriptor if the TPckg passed in to the server is not + the expected size +@leave Any other system-wide error code. +*/ +void ValidateTTsTimeL(CMessageParameterBase* aParameter) + { + TTsTime time; + TPckg pTime(time); + + TInt length = aParameter->GetDesLengthL(); + + if((length < aParameter->Min())||(length > aParameter->Max())) + { + User::Leave(KErrBadDescriptor); + } + + aParameter->ReadL(pTime,0); + + } + +/* +Custom validation function for EParamTTaskInfo parameters. +Checks that the TPckg passed in to the server is exactly the size +defined in the schema. Reads the value from the clients message to +ensure the data is valid. +@param aParameter The parameter object to be validated +@leave KErrBadDescriptor if the TPckg passed in to the server is not + the expected size +@leave Any other system-wide error code. +*/ +void ValidateTTaskInfoL(CMessageParameterBase* aParameter) + { + TTaskInfo taskInfo; + TPckg pTaskInfo(taskInfo); + + TInt length = aParameter->GetDesLengthL(); + + if((length < aParameter->Min())||(length > aParameter->Max())) + { + User::Leave(KErrBadDescriptor); + } + + aParameter->ReadL(pTaskInfo,0); + } + +/* +Custom validation function for EParamTScheduleInfo parameters. +Checks that the TPckg passed in to the server is exactly the size +defined in the schema. Reads the value from the clients message to +ensure the data is valid. +@param aParameter The parameter object to be validated +@leave KErrBadDescriptor if the TPckg passed in to the server is not + the expected size +@leave Any other system-wide error code. +*/ +void ValidateTScheduleInfoL(CMessageParameterBase* aParameter) + { + TScheduleInfo scheduleInfo; + TPckg pScheduleInfo(scheduleInfo); + + TInt length = aParameter->GetDesLengthL(); + + if((length < aParameter->Min())||(length > aParameter->Max())) + { + User::Leave(KErrBadDescriptor); + } + + aParameter->ReadL(pScheduleInfo,0); + } + +/* +Custom validation function for EParamTSchedulerItemRef parameters. +Checks that the TPckg passed in to the server is exactly the size +defined in the schema. Reads the value from the clients message to +ensure the data is valid. +@param aParameter The parameter object to be validated +@leave KErrBadDescriptor if the TPckg passed in to the server is not + the expected size +@leave Any other system-wide error code. +*/ +void ValidateTSchedulerItemRefL(CMessageParameterBase* aParameter) + { + TSchedulerItemRef itemRef; + TPckg pItemRef(itemRef); + + TInt length = aParameter->GetDesLengthL(); + + if((length < aParameter->Min())||(length > aParameter->Max())) + { + User::Leave(KErrBadDescriptor); + } + + aParameter->ReadL(pItemRef,0); + } + +/* +Custom validation function for EParamTScheduleSettings2 parameters. +Checks that the TPckg passed in to the server is exactly the size +defined in the schema. Reads the value from the clients message to +ensure the data is valid. Checks iEntryCount is > 0. +@param aParameter The parameter object to be validated +@leave KErrBadDescriptor if the TPckg passed in to the server is not + the expected size +@leave Any other system-wide error code. +*/ +void ValidateTScheduleSettingsL(CMessageParameterBase* aParameter) + { + TScheduleSettings2 settings; + TPckg pSettings(settings); + + TInt length = aParameter->GetDesLengthL(); + + if((length < aParameter->Min())||(length > aParameter->Max())) + { + User::Leave(KErrBadDescriptor); + } + + aParameter->ReadL(pSettings,0); + + if(settings.iEntryCount < 0) + { + User::Leave(KErrBadParameter); + } + + }