// Copyright (c) 1999-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 "ASSrvServer.h"

// System includes

#include <e32base.h>

// User includes

#include "ASSrvSession.h"

#include "ASSrvStaticUtils.h"

//Only include these in the secured platform 

#include "ASSrvAlarmQueue.h"

#include "ASShdOpCodes.h"

#define KPolicyElementWriteUserData 0

#define KPolicyElementWriteDeviceData 1

const TUint KRangeCount = 5; 

const TInt KOpCodeRanges[KRangeCount] = 

	{	

	KCapabilityNone,

	KCapabilityCustomCheckData, 

	KCapabilityWriteUserData, 

	KCapabilityWriteDeviceData, 

	EASShdOpCodeLast,

	};

const TUint8 KElementsIndex[KRangeCount] =

	{

	CPolicyServer::EAlwaysPass, 	//Allways passing no capability required 0-99

	CPolicyServer::ECustomCheck, 	//Custom check for the Alarm SID 		 100-199

	KPolicyElementWriteUserData,	//Requires WriteUserData				 200-299

	KPolicyElementWriteDeviceData,	//Requires WriteDeviceData				 300-(EASShdOpCodeLast-1)

	CPolicyServer::ENotSupported, 	//Not Supported					 		 EASShdOpCodeLast-End

	};

const CPolicyServer::TPolicyElement KPolicyElements[] = 

	{ 

	{_INIT_SECURITY_POLICY_C1(ECapabilityWriteUserData), CPolicyServer::EFailClient},

	{_INIT_SECURITY_POLICY_C1(ECapabilityWriteDeviceData), CPolicyServer::EFailClient} 

	};

const CPolicyServer::TPolicy KAlarmServerPolicy =

	{

	CPolicyServer::EAlwaysPass, //specifies all connect attempts should pass

	KRangeCount,

	KOpCodeRanges,

	KElementsIndex, 	// what each range is compared to 

	KPolicyElements 	// what policies range is compared to

	};

//

// ----> CASSrvServer (source)

//

//*************************************************************************************

CASSrvServer::CASSrvServer()

 	:CPolicyServer(CActive::EPriorityHigh, KAlarmServerPolicy)

	{

	}

//*************************************************************************************

CASSrvServer::~CASSrvServer()

	{

	// In order to prevent access violations as the server

	// shuts down, we inform all sessions that the server is

	// about to be destroyed

	iSessionIter.SetToFirst();

	//

	CASSrvSession* session = static_cast<CASSrvSession*>(iSessionIter++);

	while(session)

		{

		session->HandleServerDestruction();

		session = static_cast<CASSrvSession*>(iSessionIter++);

		}

	//

	delete iServerWideData;

	}

//*************************************************************************************

void CASSrvServer::ConstructL()

	{

	// We "start" the server here (i.e before completing construction) since

	// if two sessions attempt to connect at the same time, we will end up

	// setting up an alarm alert notification with a server instance which is

	// about to be destroyed. Calling StartL here won't actually allow any connections

	// to be created until the active scheduler has a chance to run. However, the 

	// call below will leave should there already be a started alarm server instance.

	//

	StartL(ASSrvStaticUtils::ASName());

	iServerWideData = CASSrvServerWideData::NewL();

	}

//*************************************************************************************

CASSrvServer* CASSrvServer::NewLC()

	{

	CASSrvServer* self = new(ELeave) CASSrvServer();

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

//

//

//

//*************************************************************************************

CSession2* CASSrvServer::NewSessionL(const TVersion& aVersion,const RMessage2& /*aMessage*/) const

	{

	// Check client version is correct

	const TVersion alarmServerVersion(ASSrvStaticUtils::ASVersion());

	if	(!User::QueryVersionSupported(alarmServerVersion, aVersion))

		User::Leave(KErrNotSupported);

	// Get non-const reference

	CASSrvServerWideData& nonConstServerWideData = *const_cast<CASSrvServerWideData*>(iServerWideData);

	// Create new session

	CASSrvSession* session = CASSrvSession::NewL(nonConstServerWideData);

	return session;

	}

//

//

//

//*************************************************************************************

TInt CASSrvServer::RunError(TInt aError)

	{

	// A bad descriptor error implies a badly programmed client, so panic it;

	// otherwise report the error to the client

	if	(aError == KErrBadDescriptor)

		{

		ASSrvStaticUtils::PanicClient(Message(), EAlarmServerInitiatedClientPanicBadDescriptor);

		}

	else

		{

		Message().Complete(aError);

		}

	// The leave will result in an early return from CServer2::RunL(), skipping

	// the call to request another message. So do that now in order to keep the

	// server running.

	ReStart();

	// Indicate that we've handled the error fully

	return KErrNone;

	}

CPolicyServer::TCustomResult CASSrvServer::CustomSecurityCheckL(const RMessage2& aMsg, TInt& /*aAction*/, TSecurityInfo& /*aMissing*/)

	{

	CPolicyServer::TCustomResult returnValue = CPolicyServer::EFail;	

	// Initially, make sure there is alarms in the queue

	const CASSrvAlarmQueue& queue = iServerWideData->Queue();

	if(queue.QueueAlarmCount() > 0)

		{	

		// Get the alarm id from the client

		const TAlarmId alarmId = static_cast<TAlarmId>(aMsg.Int0());

		const TASSrvAlarm* theAlarm = queue.QueueAlarmById(alarmId);

		if (theAlarm)

			{

			//Now get the SID of the alarm, it should be const since we do not want to change the alarm here

			//Check that the SID of the alarm is equal to the SID of the client

			TSecureId AlarmOwnerSID = theAlarm->GetSid();

			TSecureId ClientSID = aMsg.SecureId();

			if (AlarmOwnerSID == ClientSID)

				{

				returnValue = CPolicyServer::EPass;

				}		

			}

		}

	// If the return value is not CPolicyServer::EPass that means that the client

	// does not own the alarm (he was not the one creating it)

	if (returnValue != CPolicyServer::EPass)

		{

		// Since different OP Codes require different capabilities

		// we then need to check the OP code

		// It is OK to 

		//		- EASShdOpCodeGetAlarmDetails

		//		- EASShdOpCodeGetAlarmData

		//		- EASShdOpCodeAlarmAtIndex

		// even if the client is not owning the alarm, as long as it has ReadUserData

		const TInt opCode = aMsg.Function();

		switch(opCode)

			{

			case EASShdOpCodeGetAlarmDetails:

			case EASShdOpCodeGetAlarmData:

			case EASShdOpCodeAlarmAtIndex:

				// Check that the client has ReadUserData

				if (aMsg.HasCapability(ECapabilityReadUserData))

					{

					returnValue = CPolicyServer::EPass;

					}

				break;

			case EASShdOpCodeAlarmNotificationCancelAndDeQueue:	

			case EASShdOpCodeAlarmDelete:						

			case EASShdOpCodeSetAlarmStatus:						

			case EASShdOpCodeSetAlarmDayOrTimed:					

			case EASShdOpCodeSetAlarmCharacteristics:			

			case EASShdOpCodeSetClientData:						

			case EASShdOpCodeAlarmDataAttach:					

			case EASShdOpCodeAlarmDataDetach:

#ifdef SYMBIAN_ALARM_REPEAT_EXTENSIONS

			case EASShdOpCodeSetAlarmDays:

#endif

				// Check that the client has WriteDeviceData

				if (aMsg.HasCapability(ECapabilityWriteDeviceData))

					{

					returnValue = CPolicyServer::EPass;

					}

				break;

			default:

				if (aMsg.HasCapability(ECapabilityReadUserData, ECapabilityWriteDeviceData))

					{

					// If the Client has booth ReadUserData and WriteDeviceData then just return CPolicyServer::EPass

					returnValue = CPolicyServer::EPass;

					}

				break;		

			}

		}

	return(returnValue);

	}