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

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of the License "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:

 // e32\euser\cbase\ub_polsvr.cpp

 // 

 //

 #include "ub_std.h"

 _LIT(KPolicyServer, "CPolicyServer");

 #include <e32debug.h>

 #define __PSD(x) __PLATSEC_DIAGNOSTIC_STRING(x)

 EXPORT_C CPolicyServer::CPolicyServer(TInt aPriority, const TPolicy& aPolicy, TServerType aType)

 	: CServer2(aPriority, aType), iPolicy(aPolicy)

 	{

 #ifdef _DEBUG

 	TUint i;

 	TInt prev = iPolicy.iRanges[0];

 	//iPolicy.iRangeCount must be greater than 0. (ie you must have at least

 	//one policy

 	__ASSERT_DEBUG(iPolicy.iRangeCount > 0, Panic(EPolSvrIRangeCountInvalid));

 	//iRanges must start from request number 0.

 	__ASSERT_DEBUG(prev == 0, Panic(EPolSvr1stRangeNotZero));

 	__ASSERT_DEBUG((iPolicy.iElementsIndex[0] < ESpecialCaseHardLimit

 		|| iPolicy.iElementsIndex[0] > ESpecialCaseLimit), 

 		Panic(EPolSvrElementsIndexValueInvalid) );

 	for(i=1; i<iPolicy.iRangeCount; i++)

 		{

 		TInt next = iPolicy.iRanges[i];

 		//iRanges must be in increasing order.

 		__ASSERT_DEBUG(next > prev, Panic(EPolSvrRangesNotIncreasing));

 		//iElementsIndex must not contain invalid values.

 		__ASSERT_DEBUG((iPolicy.iElementsIndex[i] < ESpecialCaseHardLimit

 			|| iPolicy.iElementsIndex[i] > ESpecialCaseLimit), 

 			Panic(EPolSvrElementsIndexValueInvalid) );

 		prev = next;

 		}

 	//iOnConnect must not be an invalid value.

 	__ASSERT_DEBUG((iPolicy.iOnConnect < ESpecialCaseHardLimit

 		|| iPolicy.iOnConnect > ESpecialCaseLimit), 

 		Panic(EPolSvrIOnConnectValueInvalid) );

 #endif

 	}

 EXPORT_C void CPolicyServer::RunL()

 	{

 	const RMessage2& msg = Message();

 	msg.ClearAuthorised();

 	TInt fn = msg.Function();

 	__ASSERT_COMPILE(-1 == RMessage2::EConnect);

 	if(fn >= RMessage2::EConnect) 

 		//So this implies any "normal" message or Connect

 		//Now we have two steps to follow each having two mutually exculsive

 		//parts.

 		//Step 1: Find policy.

 		//Step 2: Apply policy.

 		{

 		const TPolicyElement* element = 0;

 		TUint specialCase = 0;

 		//1a: If its a normal message.  Find the associate policy or special

 		//case action.

 		if(fn >= 0)

 			{

 			element = FindPolicyElement(fn, specialCase);

 			}

 		//1b: If its a connect message, there's a shortcut to the policy.

 		else 

 			{

 			TUint8 i = iPolicy.iOnConnect;

 			if(i >= ESpecialCaseHardLimit)

 				specialCase = i;

 			else

 				element = &(iPolicy.iElements[i]);

 			}

 		//2a: We found a policy that we can automatically apply... Apply it!

 		if(element)

 			{

 			TSecurityInfo missing;

 			//If policy check succeeds, allow it through

 			if(element->iPolicy.CheckPolicy(msg, missing, __PSD("Checked by CPolicyServer::RunL")))

 				{

 				ProcessL(msg);

 				}

 			//Else see what failure action is required (return error code,

 			//panic client, ask user, etc...)

 			else

 				{

 				CheckFailedL(msg, element->iAction, missing);

 				}

 			}

 		//2b: The policy is a special case

 		else 

 			{

 			switch(specialCase)

 				{

 				//If you change this you'll have to add to the switch statement

 				__ASSERT_COMPILE(ESpecialCaseLimit == 252u);

 				case ECustomCheck:

 					{

 					TInt action = EFailClient; 

 					//The default action after failing a CustomSecurityCheck is

 					//to complete the message with KErrPermissionDenied.  If

 					//you want a different action, then change the action

 					//parameter prior to returning from your derived

 					//implementation of CustomSecurityCheckL

 					TSecurityInfo missing;

 					__ASSERT_COMPILE(SCapabilitySet::ENCapW == 2);

 					memset(&missing, 0, sizeof(SSecurityInfo));

 					TCustomResult result = CustomSecurityCheckL(msg, action, missing);

 					if(result == EPass)

 						{

 						ProcessL(msg);

 						}

 					else if(result == EFail)

 						{

 						CheckFailedL(msg, action, missing); 

 						}

 					else if(result == EAsync)

 						{

 						//Do Nothing.  Derived CustomSecurityCheck is

 						//responsible for calling ProcessL/CheckFailedL

 						}

 					else

 						Panic(EPolSvrInvalidCustomResult);

 					}

 					break;	

 				case ENotSupported:

 					msg.Complete(KErrNotSupported);	

 					break;

 				case EAlwaysPass:

 					ProcessL(msg);

 					break;

 				default:

 					Panic(EPolSvrPolicyInvalid);

 					break;

 				}

 			}

 		}

 	//else it must be either Disconnect or bad message.  Both are handled by

 	//ProcessL

 	else 

 		{

 		ProcessL(msg);

 		}

 	// Queue reception of next message if it hasn't already been done

 	if(!IsActive())

 		ReStart();

 	}

 EXPORT_C TInt CPolicyServer::RunError(TInt aError)

 	{

 	ProcessError(Message(), aError);

 	if (!IsActive())

 		ReStart();

 	return KErrNone;

 	}

 EXPORT_C void CPolicyServer::ProcessL(const RMessage2& aMsg)

 	{

 	aMsg.SetAuthorised();

 	TInt fn = aMsg.Function();

 	if(fn >= 0)

 		{

 		CSession2* session=aMsg.Session();

 		if(session)

 			{

 			session->ServiceL(aMsg);

 			}

 		else

 			{

 			NotConnected(aMsg);

 			}

 		}

 	else if(fn==RMessage2::EConnect)

 		{

 		Connect(aMsg);

 		}

 	else if(fn==RMessage2::EDisConnect)

 		{

 		Disconnect(aMsg);

 		}

 	else

 		{

 		BadMessage(aMsg);

 		}

 	}

 EXPORT_C void CPolicyServer::ProcessError(const RMessage2& aMsg, TInt aError)

 	{

 	__ASSERT_COMPILE(-1 == RMessage2::EConnect);

 	__ASSERT_ALWAYS(aMsg.Function() >= RMessage2::EConnect, User::Panic(KPolicyServer, 2));

 	if(aMsg.Authorised() && aMsg.Function() >= 0)

 		{

 		aMsg.Session()->ServiceError(aMsg, aError);

 		}

 	else //Either ServiceL hadn't been called yet (not (yet) authorised) or

 		//it's a Connect message

 		{

 		aMsg.Complete(aError);

 		}

 	}

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

 	{

 	Panic(EPolSvrCallingBaseImplementation);

 	return EFail;

 	}

 EXPORT_C void CPolicyServer::CheckFailedL(const RMessage2& aMsg, TInt aAction, const TSecurityInfo& aMissing)

 	{

 	if(aAction < 0)

 		{

 		TCustomResult result = CustomFailureActionL(aMsg, aAction, aMissing);

 		if(result == EPass)

 			ProcessL(aMsg);

 		else if(result == EFail)

 			aMsg.Complete(KErrPermissionDenied);

 		else if(result == EAsync)

 			{}

 			//Do Nothing.  Derived CustomFailureActionL is responsible for

 			//calling ProcessL/completing message with KErrPermissionDenied

 		else

 			Panic(EPolSvrInvalidCustomResult);

 		}

 	else if(aAction == EFailClient)

 		{

 		aMsg.Complete(KErrPermissionDenied);

 		}

 	else //if (aAction == EPanic) and all other +ve values

 		{

 		_LIT(KE32UserCBase, "E32USER-CBase");

 		aMsg.Panic(KE32UserCBase, EPolSvrActionPanicClient);

 		}

 	}

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

 	{

 	Panic(EPolSvrCallingBaseImplementation);

 	return EFail;

 	}

 const CPolicyServer::TPolicyElement* CPolicyServer::FindPolicyElement(TInt aFn, TUint& aSpecialCase) const

 	{

 	//Connect (aFn == -1) is handled through iPolicy.iOnConnect.  So aFn should

 	//always be greater than -1.

 	__ASSERT_DEBUG(aFn >= 0, User::Panic(KPolicyServer, 1));

 	TUint l = 0;

 	TUint u = iPolicy.iRangeCount;

 	TUint m = 0;

 	while(u > l)

 		{

 		m = (l+u) >> 1;

 		if(iPolicy.iRanges[m] > aFn)

 			u = m;

 		else

 			l = m + 1;

 		}

 	--l;

 	//the mth element of iElementsIndex tells us the index in iElements

 	//we want

 	TUint8 i = iPolicy.iElementsIndex[l];

 	//if the mth element of iElementsIndex is >= 250 -> Special Case

 	if(i >= ESpecialCaseHardLimit)

 		{

 		aSpecialCase = i;

 		return 0;

 		}

 	return &(iPolicy.iElements[i]);

 	}

 /**

 Extension function

 */

 EXPORT_C TInt CPolicyServer::Extension_(TUint aExtensionId, TAny*& a0, TAny* a1)

 	{

 	return CServer2::Extension_(aExtensionId, a0, a1);

 	}