// 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:

//

/**

 @file

*/

#include "ET_SSTD.H"

#include "e32svr.h"

#include "et_record.h"

#define DOUBLE_COLON		_L("::")

#define ETEL_NAME			_L("Etel")

#define TSY_EXTENSION		_L(".TSY")

#define MBMS_CONTEXT_NAME	_L("MBMS_CONTEXT")

const TInt KLengthOfDoubleColon=2;

#ifdef __EABI__

// Patch data is used and KPriorityClientSid can be modified to a different value in ETel.iby file

extern const TInt32 KPriorityClientSid = 0x12345678 ;

// Patch data is used and KLocationServicesNetworkGatewaySid can be modified to a different value in ETel.iby file

extern const TInt32 KLocationServicesNetworkGatewaySid = 0x12345678;

// Patch data is used and KSatEngineSid can be modified to a different value in ETel.iby file

extern const TInt32 KSatEngineSid = 0x12345678;

#endif

// KEmergencyClientHeapMinSizeArray containing the bit- mask combination emergency client heap min size

// Array index 0 value refers to the decimal value 1 set from the RPhone::TEmergencyRequest bit-mask enum

// For example array index 0 value which is KEmergencyLCSClientHeapMinSize refers to the decimal value 1 set by

// passing EEmergencyLCSRequest from RPhone::TEmergencyRequest bit-mask enum

// Thus n-1 array index value refers to the decimal value n set from the RPhone::TEmergencyRequest bit-mask enum

const TInt KEmergencyClientHeapMinSizeArray[] = 

	{

	KEmergencyLCSClientHeapMinSize,

	KEmergencyCSVoiceCallClientHeapMinSize,

	KEmergencyLCSClientHeapMinSize + KEmergencyCSVoiceCallClientHeapMinSize

	//Add future bit- mask combination emergency client's heap min size here

	};

// KEmergencyClientHeapMaxSizeArray containing the bit- mask combination emergency client heap max size

// Array index 0 value refers to the decimal value 1 set from the RPhone::TEmergencyRequest bit-mask enum

// For example array index 0 value which is KEmergencyLCSClientHeapMinSize refers to the decimal value 1 set by

// passing EEmergencyLCSRequest from RPhone::TEmergencyRequest bit-mask enum

// Thus n-1 array index value refers to the decimal value n set from the RPhone::TEmergencyRequest bit-mask enum

const TInt KEmergencyClientHeapMaxSizeArray[] = 

	{

	KEmergencyLCSClientHeapMaxSize,

	KEmergencyCSVoiceCallClientHeapMaxSize,

	KEmergencyLCSClientHeapMaxSize + KEmergencyCSVoiceCallClientHeapMaxSize

	//Add future bit-mask combination emergency client's heap max size here

	};

//

// CTelSession class definitions

//

inline CTelServer* CTelSession::Server() const

	{

	return static_cast<CTelServer*>(const_cast<CServer2*>(CSession2::Server()));

	}

CTelSession::CTelSession(CPhoneManager* aPhoneManager)

	: iPhoneManager(aPhoneManager),iEmergencyHeap(NULL)

//

// C'Tor - must pass client to CSession

//

	{

	__DECLARE_NAME(_S("CTelSession"));

	}

CTelSession::~CTelSession()

//

//	clean up and go home.

//

	{

	// Just ensure that the server doing the closure all subsessions

	// if the client do not !

	if(iObjectIx)

		{

		TInt handle;

		CObject* theObj=NULL;

		TInt count=iObjectIx->Count();

		for(TInt i=0;i<count;i++)

			{

			theObj=iObjectIx->operator[](i);

			if(theObj)

				{

				handle=iObjectIx->At(theObj);

				CTelObject* theTelObj=REINTERPRET_CAST(CTelObject*,theObj); //

				theTelObj->CloseSubSessionPreProcessing(this,handle);

				theTelObj=REINTERPRET_CAST(CTelObject*,theObj->Owner());

				iObjectIx->Remove(handle);

				if(theTelObj)

					theTelObj->TelObjectClose();

				//

				// If the array length has changed, then update count and move

				// back one space, so that the same cell will be re-inspected

				// during the next iteration of the loop.  This is because we

				// have removed the current cell and therefore the next cell

				// is actually in iObjectIx[i] (e.g. the current one).

				//

				TInt  newCount = iObjectIx->Count();

				if (newCount != count)

					{

					count = newCount;

					i--;

					}

				}

			}

		delete iObjectIx;

		}

	if (iTsyModulesIx)

		{

		delete iTsyModulesIx;

		}

	UnsetPriorityClient();

	UnsetEmergencyClient();

    RECORD_SESSION_CLOSE(this);

	Server()->Dec();

	}

void CTelSession::CreateL()

//

// Allocate any extra knobbly bits

//

	{	

	Server()->Inc(); // increment session count by one

	iTsyModulesIx=CObjectIx::NewL();

	iObjectIx=CObjectIx::NewL();

	iNameIndex=0;

	}

void CTelSession::ServiceL(const RMessage2 &aMessage)

//

// Handle messages for this session

//

	{

	iMessage=aMessage;

	switch (aMessage.Function())

		{

	case EEtelOpenFromSession:

		NewTelObject(ETelObjectOpenSourceSession);

		return;

//RMobileLocationServices::Open() behaves like any other Open()

//method except it needs to be policed with an SID check and to facilitate

//this it has a separate IPC (EEtelOpenFromSubSessionLcs)

	case EEtelOpenFromSubSessionLcs:

	case EEtelOpenFromSubSession:

		NewTelObject(ETelObjectOpenSourceSubSession);

		return;

	case EEtelOpenByNameFromSession:

		NewTelObject(ETelObjectOpenByNameSourceSession);

		return;

	case EEtelOpenByNameFromSubSession:

		NewTelObject(ETelObjectOpenByNameSourceSubSession);

		return;

#if defined (_DEBUG)

	case EEtelDbgMarkHeap:

		{

		RECORD_IPC_LOG2(this, EEtelDbgMarkHeap);

		RECORD_COMPLETE(aMessage.Session(), aMessage.Function(), KErrNone);		

		__UHEAP_MARK;

		if(!aMessage.IsNull())

			{

			aMessage.Complete(KErrNone);

			}

		return;

		}

	case EEtelDbgCheckHeap:

		{

		__UHEAP_CHECK(aMessage.Int0());

		RECORD_IPC_LOG3(this, EEtelDbgCheckHeap, aMessage.Int0());

		RECORD_COMPLETE(aMessage.Session(), aMessage.Function(), KErrNone);		

		if(!aMessage.IsNull())

			{

			aMessage.Complete(KErrNone);

			}

		return;

		}

	case EEtelDbgMarkEnd:

		{

		__UHEAP_MARKENDC(aMessage.Int0());

		RECORD_IPC_LOG3(this, EEtelDbgMarkEnd, aMessage.Int0());

		RECORD_COMPLETE(aMessage.Session(), aMessage.Function(), KErrNone);

		if(!aMessage.IsNull())

			{

			aMessage.Complete(KErrNone);

			}

		return;

		}

	case EEtelDbgFailNext:

		{

		RECORD_IPC_LOG3(this, EEtelDbgFailNext, aMessage.Int0());

		RECORD_COMPLETE(aMessage.Session(), aMessage.Function(), KErrNone);

		if (aMessage.Int0() == 0)

			{

			__UHEAP_RESET;

			}

		else

			{

			__UHEAP_FAILNEXT(aMessage.Int0());

			}

		if(!aMessage.IsNull())

			{

			aMessage.Complete(KErrNone);

			}

		return;

		}

	case EEtelDbgFailNextAvail:

		{

		TBool result = ETrue;

		//Create a derived class from RHeap which provides exposure to

		//the Heap's iFailType member

		class RPeekHeap: public RHeap

			{

		public:

			RAllocator::TAllocFail FailNextMode() const

				{

				return iFailType;

				}

			};

		RPeekHeap* thisHeap = static_cast<RPeekHeap*>(&User::Heap());

		if(thisHeap->FailNextMode() != RAllocator::EFailNext)

 			{

 			result = EFalse;	//Simulated OOM is not available

 			}

		TPtr8 ptr(REINTERPRET_CAST(TText8*,&result),sizeof(TBool),sizeof(TBool));

		RECORD_IPC_LOG3(this, EEtelDbgFailNextAvail, ptr);

		TInt ret = aMessage.Write(0,ptr);

		RECORD_COMPLETE(aMessage.Session(), aMessage.Function(), ret);

		if(!aMessage.IsNull())

			{

			aMessage.Complete(ret);

			}

		return;

		}		

#endif

	case EEtelServerLoadPhoneModule:

 		LoadPhoneModule();

		return;

	case EEtelServerClosePhoneModule:

		ClosePhoneModule();

		return;

	case EEtelServerPhoneInfoByIndex:

			{

			PhoneInfo(aMessage.Int1()); // use Int1() same as client side

			return;

			}

	case EEtelServerEnumeratePhones:

		EnumeratePhones();

		return;

	case EEtelServerSetPriorityClient:

		SetPriorityClient();

		return;

	case EEtelServerQueryTsyFunctionality:

		IsSupportedByTsy();

		return;

	case EEtelServerGetTsyName:

		GetTsyNameByPhone(aMessage.Int0());

		return;

	case EEtelServerSetExtendedErrorGranularity:

		SetExtendedErrorGranularity();

		return;

	case EEtelServerGetTsyVersionNo:

		GetTsyVersionNumber();

		return;

	// ETelServer will first pre-allocate heap memory for the type of request received.

	// Once ETelServer successfully pre-allocates it will pass on EETelPhoneSetEmergencyClient IPC opcode

	// to TSY via ExtFunc for the TSY to pre-allocate. 

	case EETelPhoneSetEmergencyClient:

		{

		// ETel server pre-allocates heap memory for the type of request received

		TInt ret = SetEmergencyClient(aMessage);

		if(ret!=KErrNone)

			{

			if(!aMessage.IsNull())

				{

				RECORD_COMPLETE(aMessage.Session(), EETelPhoneSetEmergencyClient, ret);

				aMessage.Complete(ret);

				}

			return;

			}

		// EETelPhoneSetEmergencyClient IPC opcode is passed to TSY via ExtFunc for the TSY to pre-allocate.

		CTelObject* theObj=CObjectFromHandle(aMessage.Int3());

		if (theObj==NULL)

			{

			PanicClient(EEtelPanicBadPhoneHandle,aMessage);		

			return;

			}

		theObj->GeneralReq(aMessage,this,NULL);

		return;

		}

	case EEtelServerSetPriorityClientV2:

		SetPriorityClientV2();

		return;

	case EEtelFlushInterfaceQueue:

		{

		RECORD_COMPLETE(aMessage.Session(), aMessage.Function(), KErrNone);

		if (aMessage.IsNull() == EFalse)

			{

		    aMessage.Complete(KErrNone);

			}

		return;

		}

	default:

		;

		}

	// Closing

	CTelObject* theObj=CObjectFromHandle(aMessage.Int3());

 	switch (aMessage.Function())

		{

	case EEtelClose:

		{

		if (theObj==NULL && !aMessage.IsNull())

			{

			RECORD_COMPLETE_SUB(aMessage.Session(), theObj, aMessage.Int3(), aMessage.Function(), KErrBadHandle);

			aMessage.Complete(KErrBadHandle);

			}

		else

			{

			RECORD_SUBSESSION_CLOSE(this, EEtelClose, theObj, aMessage.Int3());

			if (theObj != NULL)

				{

				theObj->CloseSubSessionPreProcessing(this,aMessage.Int3());

				CTelObject* theObject=REINTERPRET_CAST(CTelObject*,theObj->Owner());

				iObjectIx->Remove(aMessage.Int3());

				if (theObject)

					{

					theObject->TelObjectClose();

					}

				}

			else

				{

				iObjectIx->Remove(aMessage.Int3());

				}

			if(!aMessage.IsNull())

				{

				RECORD_COMPLETE_SUB(aMessage.Session(), theObj, aMessage.Int3(), aMessage.Function(), KErrNone);

				aMessage.Complete(KErrNone);

				}

			}

		return;

		}

	case EEtelGlobalKernelObjectHandle:

		{

		// We log the handle received in the message and return the syncHandle in the "message.complete"

		RECORD_IPC_LOG3(this, EEtelGlobalKernelObjectHandle,aMessage.Int3());

		if (theObj==NULL)

		   {

		   RECORD_IPC_LOG3(this, EEtelGlobalKernelObjectHandle,NULL);

		   if(!aMessage.IsNull())

		   		{

		   		RECORD_COMPLETE_SUB(aMessage.Session(), theObj, aMessage.Int3(), aMessage.Function(), KErrBadHandle);

		   		aMessage.Complete(KErrBadHandle);

		   		}

		   }

		else

		   {   

			RHandleBase* syncHandle=theObj->GlobalKernelObjectHandle();

			if(syncHandle)

				{

				if(!aMessage.IsNull())	

					{

					//just record the message completion as KErrNone

					RECORD_COMPLETE_SUB(aMessage.Session(), theObj, aMessage.Int3(), aMessage.Function(), KErrNone);

					aMessage.Complete(*syncHandle);

					}

				}

			else

				{

				if(!aMessage.IsNull())

					{

					RECORD_COMPLETE_SUB(aMessage.Session(), theObj, aMessage.Int3(), aMessage.Function(), KErrNotSupported);

					aMessage.Complete(KErrNotSupported);

					}

				}

		    }

		return;

		}

	default:

		{

			if (theObj==NULL)

				{

				PanicClient(EEtelPanicBadPhoneHandle,aMessage);		

				return;

				}

			theObj->GeneralReq(aMessage,this,NULL);

			return;

		}

		}

	}

CTelObject* CTelSession::CObjectFromHandle(TUint aHandle) const

//

// Return an Object Pointer for Given Handle

//

	{

	return REINTERPRET_CAST(CTelObject*,iObjectIx->At(aHandle));

	}

CTelServer* CTelSession::TelServer() const

	{

	return Server();

	}

void CTelSession::EnumeratePhones()

//

// get number of phone currently loaded

//

	{

	TPckgBuf<TInt> num;

	num()=iPhoneManager->EnumeratePhones();

	RECORD_IPC_LOG3(this, EEtelServerEnumeratePhones, num());

	const RMessage2& m=iMessage;

	TRAPD(ret, m.WriteL(0,num));

	RECORD_COMPLETE(m.Session(), m.Function(), ret);

	m.Complete(ret);

	}

void CTelSession::GetTsyNameByPhone(const TInt aIndexOfPhone) 

//

// get the TSY name a particular phone belongs to

//

	{

	RECORD_IPC_LOG4(this, EEtelServerGetTsyName, aIndexOfPhone, CRecordMessage::TArgAllocBufFromLen(50, CRecordMessage::KArgTypeIsDes16));

	TName tsyName;

	TInt ret;

	if ((ret=iPhoneManager->GetTsyName(aIndexOfPhone,tsyName))==KErrNone)

		{

		ret = iMessage.Write(1,tsyName);

		}

	if(!iMessage.IsNull())

		{

		RECORD_COMPLETE(iMessage.Session(), iMessage.Function(), ret);

		iMessage.Complete(ret);

		}

	}

void CTelSession::SetExtendedErrorGranularity()

	{	

	TPtr8 ptr(REINTERPRET_CAST(TText8*,&iErrorGranularity),

		sizeof(RTelServer::TErrorGranularity),sizeof(RTelServer::TErrorGranularity));

	TInt res = Read(0,ptr);

	if (res == KErrNone)

		{		

		TInt descLength = iMessage.GetDesLength(0);

		if ( descLength<sizeof(iErrorGranularity) )

			{

			PanicClient(EEtelPanicBadDescriptor,iMessage);

			}	

		}		

	RECORD_IPC_LOG3(this, EEtelServerSetExtendedErrorGranularity, ptr);

	if(!iMessage.IsNull())

		{

		RECORD_COMPLETE(iMessage.Session(), iMessage.Function(), KErrNone);

		iMessage.Complete(KErrNone);

		}

	}