// 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);
	}