// 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 <e32svr.h>

#include "ET_SSTD.H"

#include <e32cmn.h>

#include "et_record.h"

#include <u32hal.h>

#ifdef __EABI__

extern const TInt32 KPriorityClientSid;

extern const TInt32 KLocationServicesNetworkGatewaySid;

extern const TInt32 KSatEngineSid;

#endif

//

// CDestroyDummySubSession class definitions

//

CDestroyDummySubSession* CDestroyDummySubSession::NewL(CTelServer* aTelServer,CTelObject* aTelObject)

//

//	Create an async one shot

//

	{

	return new(ELeave)CDestroyDummySubSession(aTelServer,aTelObject);

	}

CDestroyDummySubSession::CDestroyDummySubSession(CTelServer* aTelServer,CTelObject* aTelObject)

//

// C'tor

//

	:CAsyncOneShot(CActive::EPriorityLow),

	iTelObject(aTelObject), iTelServer(aTelServer)

	{

	__DECLARE_NAME(_S("CDestroyDummySubSession"));

	}

CDestroyDummySubSession::~CDestroyDummySubSession()

	{

	Cancel();

	}

void CDestroyDummySubSession::RunL()

//

// Destroy the tel object and the the server

//

	{

	iOpen=EFalse;

	iTelObject->TelObjectClose();

	}

//

// CTelChannelHandler class definitions

//

CTelChannelHandler::CTelChannelHandler(CTelServer* aServer):

    CCFModuleChannelHandler(CActive::EPriorityStandard)

	/** Constructor

	@internalComponent */

	{

	iServer=aServer;

	}

CTelChannelHandler* CTelChannelHandler::NewL(RCFChannel::TMsgQueues aRxQueues, 

    RCFChannel::TMsgQueues aTxQueues, CTelServer* aServer)

	/** Create channel handler instance and construct it. Standard pattern

	@internalComponent */

	{

	CTelChannelHandler* pHandler = new (ELeave) CTelChannelHandler(aServer);

	CleanupStack::PushL(pHandler);

	pHandler->ConstructL(aRxQueues, aTxQueues);

	CleanupStack::Pop(pHandler);

	return pHandler;

	}

void CTelChannelHandler::CFMessageShutdown(const CommsFW::TCFShutdownMsg& aMessage)

	{

	iServer->CFMessageShutdown(aMessage);

	}

void CTelServer::CFMessageShutdown(const CommsFW::TCFShutdownMsg& aMessage)

	/** 

	@internalComponent */

	{

	if((aMessage.Type()==EOptional) || (aMessage.Type()==EGraceful))

		{

		iShutGracefully = ETrue;

		if(iSessionCount==0)

			{

			iSch->Call();

			}

		}

	else

		{

		}

	}

//

// CTelSchedulerStop class definitions

//

CTelSchedulerStop* CTelSchedulerStop::NewL()

//

//	Create the TelScheduler Stop async one shot

//

	{

	return new(ELeave)CTelSchedulerStop;

	}

CTelSchedulerStop::CTelSchedulerStop()

//

// C'tor

//

	:CAsyncOneShot(CActive::EPriorityLow)

	{

	__DECLARE_NAME(_S("CTelSchedulerStop"));

	}

CTelSchedulerStop::~CTelSchedulerStop()

	{

	Cancel();

	}

void CTelSchedulerStop::RunL()

//

// Stop the Active Scheduler (after any libraries have been unloaded)

//

	{

	CActiveScheduler::Stop();

	}

//

// CTelServer class definitions

//

CTelServer* CTelServer::NewL(RCFChannel::TMsgQueues aRxQueues, RCFChannel::TMsgQueues aTxQueues)

	{

	CTelServer* pS = new (ELeave) CTelServer(EPriority);

	CleanupStack::PushL(pS);

	pS->ConstructL(aRxQueues, aTxQueues);

	CleanupStack::Pop(pS);

	return pS;

	}

CTelServer::CTelServer(TInt aPriority)

	: CPolicyServer(aPriority, iPolicy, ESharableSessions), iSessionCount(0), iShutGracefully(EFalse)

	{

	__DECLARE_NAME(_S("CTelServer"));

	}

void CTelServer::ConstructL(RCFChannel::TMsgQueues aRxQueues, RCFChannel::TMsgQueues aTxQueues)

	{

	iPhoneManager=CPhoneManager::NewL();

	iSch=CTelSchedulerStop::NewL();

	iPriorityClientSession=NULL;

	iChannelHandler = CTelChannelHandler::NewL(aRxQueues, aTxQueues, this);

#if defined (__EABI__) 

	iPriorityClientSid = KPriorityClientSid;

	iLocationServicesNetworkGatewaySid = KLocationServicesNetworkGatewaySid;

	iSatEngineSid = KSatEngineSid;

#else // WINS

	// for the emulator the SecureId of Master phone application is patched via the epoc.ini file 

	UserSvr::HalFunction(EHalGroupEmulator,EEmulatorHalIntProperty,(TAny*)"etel_KPriorityClientSid",&iPriorityClientSid);

	// for the emulator the SecureId of Location Services Network Gateway process is patched via the epoc.ini file

	UserSvr::HalFunction(EHalGroupEmulator,EEmulatorHalIntProperty,(TAny*)"etel_KLocationServicesNetworkGatewaySid",&iLocationServicesNetworkGatewaySid);

	// for the emulator the SecureId of the SAT engine is patched via the epoc.ini file

	UserSvr::HalFunction(EHalGroupEmulator,EEmulatorHalIntProperty,(TAny*)"etel_KSatEngineSid",&iSatEngineSid);

#endif

    RECORD_HEADER

	StartL(ETEL_SERVER_NAME);

	}

CTelServer::~CTelServer()

	{

	delete iChannelHandler;

	delete iPhoneManager;

	delete iSch;

	iEmergencyClientSessions.Reset();

	}

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

//

// Create a new client for this server.

//

	{

	TVersion v(KEtelMajorVersionNumber,KEtelMinorVersionNumber,KEtelBuildVersionNumber);

	if (User::QueryVersionSupported(v,aVersion)==FALSE)

		User::Leave(KErrNotSupported);

	CTelSession* sess = new(ELeave) CTelSession(iPhoneManager);	

	RECORD_SESSION_NEW(sess);

	RECORD_COMPLETE(sess,0,KErrNone);

	return sess;

	}

void CTelServer::Inc()

//

// Increase session count

//

	{

	if((iSessionCount==0)&&(iSch->IsActive()))

		{

		iSch->Cancel();

		}

	iSessionCount++;

	}

TInt CTelServer::Count() const

//

// Session count

//

	{

	return iSessionCount;

	}

void CTelServer::Dec()

//

// Decrement a session stop scheduler if no session

//

	{

	__ASSERT_ALWAYS((iSessionCount>0),Fault(EEtelFaultNegativeSessionCount));

	iSessionCount--;

	// If iShutGracefully==ETrue the Rootserver has informed us that it wants us to shutdown

	// next time there is no sessions. If it is EFalse no such notification has arrived and 

	// ETel continues running even though there are no sessions.

	if((iSessionCount==0) && (iShutGracefully))

		{

		iSch->Call();

		}

	}

TBool CTelServer::IsPriorityClient(const CTelSession* aSession) const

//

// Check if aSession is the priority client session

//

	{

	return (aSession==iPriorityClientSession);

	}

TInt CTelServer::SetPriorityClient(CTelSession* aSession)

//

// Set aSession as the priority client session if there is not one already.

// Return KErrAlreadyExists if there is one already, KErrNoMemory if the

// heap cannot be allocated.

//

	{

	if (iPriorityClientSession==NULL)

		{

		iPriorityClientSession=aSession;

		return KErrNone;

		}

	return KErrAlreadyExists;

	}

TInt CTelServer::RemovePriorityClient(CTelSession* aSession)

//

// Remove aSession as the priority client if it is the priority client

// Returns KErrAccessDenied if aSession is not the priority client

//

	{

	if (IsPriorityClient(aSession))

		{

		iPriorityClientSession=NULL;

		return KErrNone;

		}

	return KErrAccessDenied;

	}

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

/**

Performs a custom security policy check on an IPC. Requests from the TSY 

the capabilities required to service the specified IPC.

In the case of Etel RTelServer::SetPriorityClient and 

RTelServer::SetPriorityClientV2 APIs which has IPC opcodes 

EEtelServerSetPriorityClient, EEtelServerSetPriorityClientV2 respectively 

a combination of NetworkControl and SID of the phone application is checked.

In the case of ETelMM RMobileLocationServices::Open call which has IPC opcode 

EEtelOpenFromSubSessionLcs, the SecureId of Location Services Network 

Gateway is checked.

For ETelMM RMobileCall::DialCallControl, which has IPC 

EMobileCallDialCallControl, a check for NetworkServices and NetworkControl 

capabilities is made and the SID of the SAT engine is checked.

@param aMsg RMessage2 containing client capabilites and request IPC.

@param aAction A reference to the action to take if the security check fails.

@param aMissing  reference to the list of security attributes missing from the checked process.

@return CPolicyServer::EPass or CPolicyServer::EFail

*/

	{

	//Set the defualt required capability to always fail the check

	TSecurityPolicy requiredCapabilities(TSecurityPolicy::EAlwaysFail);

	TCustomResult retCode = EFail;

	CTelSession* session=static_cast<CTelSession*>(aMsg.Session());

	if(session)

		{

		switch(aMsg.Function())

			{

		// RTelServer::SetPriorityClient is policed with NetworkControl capability and SecureId of master phone application

		case EEtelServerSetPriorityClient:

		case EEtelServerSetPriorityClientV2:

			{

			TSecurityPolicy securityPolicy(ECapabilityNetworkControl);

			if(securityPolicy.CheckPolicy(aMsg) && aMsg.SecureId() == iPriorityClientSid)

				{

				retCode = EPass;	

				}

			break;

			}

		// RMobileLocationServices::Open call is policed with SecureId of Location Services Network Gateway process

		case EEtelOpenFromSubSessionLcs:

			{

			if(aMsg.SecureId() == iLocationServicesNetworkGatewaySid)

				{

				retCode = EPass;

				}

			break;

			}

		// RMobileCall::DialCallControl and cancellation of this

		// request is policed by NetworkControl and 

		// NetworkServices capability and the SecureId of the SAT engine.

		case EMobileCallDialCallControl:

		case EMobileCallDialCallControlCancel:		

			{

			TSecurityPolicy securityPolicy(ECapabilityNetworkControl, ECapabilityNetworkServices);

			if (securityPolicy.CheckPolicy(aMsg) && aMsg.SecureId() == iSatEngineSid)

				{

				retCode = EPass;

				}

			break;

			}

		default:

			{

			CTelObject* theObj=session->CObjectFromHandle(aMsg.Int3());

			if(theObj)

				{

				//Get the policy for the incoming custom IPC request from the TSY

				requiredCapabilities = theObj->GetRequiredPlatSecCaps(aMsg.Function()); 

				}

			//Check the capability of the client against the required capability 

			//retrieved from the TSY

			if(requiredCapabilities.CheckPolicy(aMsg))

				{

				retCode = EPass;

				}

			break;	

			}

			}

		}

	return retCode;

	}

void CTelServer::SetEmergencyClientSession(CTelSession* aEmergencyClientSession)

	{

	iEmergencyClientSessions.Append(aEmergencyClientSession);

	}

TInt CTelServer::EmergencyClientSessionsCount()

	{

	return iEmergencyClientSessions.Count();

	}

TInt CTelServer::RemoveEmergencyClient(CTelSession* aSession)

	{

	for(int i =0;i<iEmergencyClientSessions.Count();i++)

		{

		if(iEmergencyClientSessions[i] == aSession)

			{

			iEmergencyClientSessions.Remove(i);

			return KErrNone;

			}

		}

	return KErrAccessDenied;

	}

TBool CTelServer::IsEmergencyClient(const CTelSession* aSession) const

	{

	for(int i =0;i<iEmergencyClientSessions.Count();i++)

		{

		if(iEmergencyClientSessions[i] == aSession)

			{

			return ETrue;

			}

		}

	return EFalse;

	}

//

// CTelScheduler class definitions

//

CTelScheduler* CTelScheduler::New()

//

// Create and install the active scheduler.

//

	{

	CTelScheduler* pA=new CTelScheduler;

	__ASSERT_ALWAYS(pA!=NULL,Fault(EEtelFaultMainSchedulerError));

	CTelScheduler::Install(pA);

	return pA;

	}

void CTelScheduler::Error(TInt) const

//

// Called if any Run() method leaves.

//

	{

	Fault(EEtelFaultMainSchedulerError);

	}

EXPORT_C TInt EtelServerThread(TAny* aArg)

//

// The ETel Server Thread.

//

	{

	// RThread::SetProtected is superceded by the security model

	__UHEAP_MARK;

	CTrapCleanup* pT;

	if ((pT=CTrapCleanup::New())==NULL)

		{

		Fault(EEtelFaultCreateTrapCleanup);

		}

	//

	// Start the scheduler and then the server

	//

	CTelScheduler* pScheduler = CTelScheduler::New();

	if(!pScheduler)

		{

		Fault(EEtelFaultMainSchedulerError);

		}

	TCFModuleInfo* pParameters = (TCFModuleInfo*) aArg;

	CTelServer* pServer=NULL;

	TRAPD(err, pServer=CTelServer::NewL(pParameters->iRxQueues, pParameters->iTxQueues));

	if(err!=KErrNone)

		{

		Fault(EEtelFaultSvrStartServer);

		}

	RThread::Rendezvous(KErrNone);

	CTelScheduler::Start();

	delete pT;

	delete pServer;

	delete pScheduler;

	__UHEAP_MARKEND;

	return(KErrNone);

	}

//Definition of ETel's policy table -

//Dicates what capability checking takes place for any given IPC request

const TUint CTelServer::iRangeCount = 332;

const TInt CTelServer::iRanges[iRangeCount] = 

	{

	0,		//range is 0-61 inclusive

	62,		//range is 62-70 inclusive

	71,		//range is 71-72 inclusive

	73,		//range is 73

	74,		//range is 74

	75,		//range is 75-76 inclusive

	77,		//range is 77

	78,		//range is 78-84 inclusive

	85,		//range is 85

	86,		//range is 86

	87,		//range is 87

	88,		//range is 88

	89,		//range is 89-91 inclusive

	92,		//range is 92-505 inclusive

	506,		//range is 506

	507,		//range is 507-507 inclusive

	508,		//range is 508

	509,		//range is 509-509 inclusive

	510,		//range is 510

	511,		//range is 511-519 inclusive

	520,		//range is 520

	521,		//range is 521-521 inclusive

	522,		//range is 522