// Copyright (c) 1997-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:

//

/**

 @file

 @internalComponent

*/

#ifndef SYMBIAN_DEN_COMMONSTD_H

#define SYMBIAN_DEN_COMMONSTD_H

#include <cflog.h>

#include <cfshared.h>

#include <elements/h_structures.h>

#include <elements/sd_thread.h>

#include <elements/sd_apiextensionregister.h>

#include <elements/nm_interfaces.h>

#ifdef _DEBUG

// Panic category for "absolutely impossible!" vanilla ASSERT()-type panics from this module

// (if it could happen through user error then you should give it an explicit, documented, category + code)

_LIT(KSpecAssert_ElemSvrDenStdH, "ElemSvrDenStdH");

#endif

namespace Den

{

/**

@internalComponent

*/

typedef TUint TSessionUniqueId;

typedef TUint TSubSessionUniqueId;

typedef TUint TScopeUniqueId;

class CCommonPlayer;

class CWorkerSession;

class CCommonSessionProxy;

class TIpcExtensionRoutingMessageFromSession;

class TIpcExtensionRoutingMessageFromSubSession;

_LIT(KDenFaultPanic, "Den");

_LIT(KWorkerClientPanic, "Worker client");

/** Supplementing RMessage2 with additional methods for transferring handle ownership and completing with

logging

*/

class RSafeMessage : public RMessage2

/**

@internalTechnology

*/

	{

public:

	/** Only a default constructor is supported; safe messages get initialised by adopting their handle from

	another instance, by downcasting from a received RMessage2 (ugly but safe since safe messages never add

	members or virtuals), or (rarely) by duplicating another instance, which diminishes safety.

	*/

	RSafeMessage()

		{

		iHandle = KNullHandle;

		}

	IMPORT_C ~RSafeMessage();

	IMPORT_C void Complete(TInt aReason) const;

	IMPORT_C void PanicClient(const TDesC& aCategory, TInt aReason) const;

	IMPORT_C void Adopt(RSafeMessage& aSrc);

	IMPORT_C void Duplicate(const RSafeMessage& aSrc);

	IMPORT_C void ResetHandle();

    IMPORT_C void ReadL(TInt aSrcParamIndex,TDes8& aDes,TInt anOffset=0) const;

	IMPORT_C TInt Read(TInt aSrcParamIndex,TDes8& aDes,TInt anOffset=0) const;

    IMPORT_C void WriteL(TInt aDstParamIndex,const TDesC8& aDes,TInt anOffset=0) const;

    IMPORT_C TInt Write(TInt aDstParamIndex,const TDesC8& aDes,TInt anOffset=0) const;

    IMPORT_C void WriteL(TInt aDstParamIndex,const TPckg<TUint32>& aDes,TInt anOffset = 0) const;

	IMPORT_C TInt Write(TInt aDstParamIndex,const TPckg<TUint32>& aDes,TInt anOffset = 0) const;

    IMPORT_C void ReadL(TInt aSrcParamIndex,TDes16& aDes,TInt anOffset=0) const;

    IMPORT_C TInt Read(TInt aSrcParamIndex,TDes16& aDes,TInt anOffset=0) const;

    IMPORT_C void WriteL(TInt aDstParamIndex,const TDesC16& aDes,TInt anOffset=0) const;

    IMPORT_C TInt Write(TInt aDstParamIndex,const TDesC16& aDes,TInt anOffset=0) const;

	IMPORT_C TInt GetDesLengthL(TInt aParam) const;

	IMPORT_C TInt GetDesMaxLengthL(TInt aParam) const;

private:

	// Conventional assignment and copy construction is not supported because of the likelihood of completing the

	// aliased message handle twice, eg storing a copy from a ServiceL() and then leaving, so completing the request

	// both from the error handler and the storing object's destructor

	RSafeMessage(const RSafeMessage&);

	RSafeMessage(const RMessage2&);

	RSafeMessage& operator=(const RSafeMessage&);

	RSafeMessage& operator=(const RMessage2&);

	};

class RSettableParameterMessage : public RSafeMessage

/**

@internalTechnology

*/

	{

public:

	inline RSettableParameterMessage(TInt aFunction, TInt aInt0 = 0, TInt aInt1 = 0, TInt aInt2 = 0, TInt aInt3 = 0)

		{

		iFunction = aFunction;

		iArgs[0] = aInt0;

		iArgs[1] = aInt1;

		iArgs[2] = aInt2;

		iArgs[3] = aInt3;

		}

	inline void SetInt0(TInt aInt0)

		{

		iArgs[0] = aInt0;

		}

	inline void SetInt1(TInt aInt1)

		{

		iArgs[1] = aInt1;

		}

	inline void SetInt2(TInt aInt2)

		{

		iArgs[2] = aInt2;

		}

	inline void SetInt3(TInt aInt3)

		{

		iArgs[3] = aInt3;

		}

	};

/** The panic numbers for panics caused by internal faults in Den

@internalComponent */

//TODO:

enum TDenFault

	{

	ECommonBadState = 0,

	ECommonNegativeSessionCount = 1,  //< Negative Session Count Den  Fault

	ECommonBadDescriptorRead = 2,     //< Read Bad Descriptor Den  Fault

	ECommonBadDescriptorWrite = 3,    //< Write Bad Descriptor Den  Fault

	ECommonBadDescriptorLength = 4,   //< Bad Descriptor Length Den  Fault

	ECommonCorruptIniData = 5,        //< Corrupt In Data Den  Fault

	ECommonBadSubSessionUniqueId = 6  //< Bad Subsession Unique Id Den  Fault

	};

class TPlayerRole : public Messages::TClientType

/**

Can be sent in a message and read as TClientType (for storage in iClients)

@internalComponent

*/

	{

public:

	inline TPlayerRole() //Needed for deserialisation

	:	Messages::TClientType()

		{

		}

	inline TBool HasRole(TUint32 aRole) const

		{

		return iClientType & aRole;

		}

	inline TUint32 Role() const

		{

		return iClientType;

		}

	inline TUint32 Kindex() const

		{

		return iClientFlags;

		}

protected:

	//This class is meant for derivation only, hence the useful ctr protected

	inline TPlayerRole(TUint32 aRole, TUint32 aKindex)

	:	Messages::TClientType(aRole, aKindex)

		{

		}

	};

/** Describes the type of configuration completed when a TWorkerConfigurationComplete is broadcast. (Although logically

associated with the message class putting it there introduces undesirable dependencies)

*/

enum TConfigurationCompletionType

/**

@internalComponent

*/

	{

	EModuleInitialisation,

	ETierMapping,

	};

/**

	Type identifier for the derived sub-session objects. Used e.g. in containers to identify

	what is stored.

	@see CWorkerSubSession::Type()

*/

class TSubSessInfo

/**

@internalComponent

*/

	{

public:

	enum TSubSessionType

		{

		ENull = 0,

		EAny = 1

		};

	TSubSessInfo(TUint8 aType)

	:	iType(aType)

		{

		}

	TUint8 iType;

	};

class CWorkerSubSession : public CBase

/**

@internalComponent

*/

	{

	friend class CWorkerSession;

	friend class CCommonPlayer;

public:

	// Reference counting methods formerly supplied by CObject.

    IMPORT_C virtual ~CWorkerSubSession();

	IMPORT_C void GetOwnerInfo(TProcessId& aProcessId, TUidType& aUidType, TThreadId& aThreadId) const;

	inline CWorkerSession* Session();

	inline const CWorkerSession* Session() const;

	inline CCommonPlayer& Player() const;

	inline CCommonSessionProxy* SessionProxy();

	inline const CCommonSessionProxy* SessionProxy() const;

	inline void SetSessionProxy(CCommonSessionProxy* aProxy);

	virtual void DeleteMe() = 0;

	void CleanupDeadWorker(CommsFW::TWorkerId aWorkerId);

	virtual TSubSessInfo Type() const = 0;

	// Some subsessions have opaque "names" that a client can retrieve to use as a reference

	// outside the owning session, eg for transferring a socket between sessions.

	IMPORT_C static void ComposeSubSessionName(const CWorkerSubSession* aSubSess, TName& aName);

	static TInt DecomposeSubSessionName(const TName& aName, CommsFW::TWorkerId& aWorkerId, CWorkerSubSession*& aSubSess);

	IMPORT_C static TInt FetchSubSessionFromName(const TName& aName, TSubSessInfo aType, const CCommonWorkerThread& aWorker, CWorkerSubSession*& aSubSess);

	IMPORT_C void DontCompleteCurrentRequest() const;

	IMPORT_C void SetReturn(TInt aReturnValue/*,TInt anError=0,TUid anOwner=TUid::Null()*/) const;

	TBool IsClosing() const { return iClosing; }

	/**

		Derived objects must implement this to make sure that all RMessage2 resources are completed when called. It

		is used in various close/clean-up scenarios.

	*/

	virtual void FinalCompleteAllBlockedMessages(TInt aResult) = 0;

//	virtual inline const RMessage2& Message() const; migrate to using SafeMessage

	IMPORT_C const RSafeMessage& SafeMessage() const;

	/**

		Derived objects must implement this to continue the processing of the current message.

	*/

	virtual void ProcessMessageL() = 0;

	inline const TSubSessionUniqueId& UniqueId() const

		{

		return iSubSessionUniqueId;

		}

	IMPORT_C void SetUniqueId(const TSubSessionUniqueId& aUniqueId);

	inline TScopeUniqueId NextScopeUniqueId()

		{

		return static_cast<TScopeUniqueId>(iNextScopeUniqueId++);

		}

	/** Special non-zero subsession pointer, used in a very few cases to select additional behaviour on a forwarded request. For example on

	creating a subsession this flags that tier resolution is first required

	*/

	static CWorkerSubSession* KFlagSpecialForwardCase();

	inline void SetSession(CWorkerSession* aProxy);

	IMPORT_C void StoreOwnerInfo();

protected:

	// API extension support

	IMPORT_C TIpcExtensionRoutingMessageFromSubSession* IsSubSessionIpcExtensionSupported(TInt aInterfaceId, TDes8& aBuff);

	IMPORT_C void OpenSubSessionIpcExtensionL(const RSafeMessage& aMessage, const TApiExtIdentification& aExtIdentification);

	IMPORT_C void SendReceiveSubSessionIpcExtensionL(const RSafeMessage& aMessage, const TApiExtIdentification& aExtIdentification);

	IMPORT_C void CloseSubSessionIpcExtension(const RSafeMessage& aMessage, const TApiExtIdentification& aExtIdentification);

	IMPORT_C void CloseAllSubSessionIpcExtensions();

	virtual TIpcExtensionRoutingMessageFromSubSession* DoIsSubSessionIpcExtensionSupported(TInt /*aInterfaceId*/, TDes8& /*aBuff*/)

		{

		//Not supported by default

		return NULL;

		}

protected:

	IMPORT_C CWorkerSubSession(CWorkerSession* aSession, CCommonPlayer* aPlayer, TSubSessionUniqueId aSubSessionUniqueId);

	IMPORT_C void ConstructL();

	void SetClosing()

		{

		iClosing = ETrue;

		}

	IMPORT_C void CompleteMessage(const RMessage2& aMessage, TInt aResult);

	void RemoveAndDestroy();

	IMPORT_C void PanicClient(TInt aPanic);

	IMPORT_C void PanicClient(const TDesC& aCategory, TInt aPanic);

protected:

	CWorkerSession* iSession;

	/**

	The thread id of the creator of the subsession, part of the OwnerInfo. This can be misleading,

	since sessions can be shared between threads of a client - to really know what thread is

	responsible for the current operator query its RMessage2

	*/

	TThreadId iThreadId;

	TBool iClosing : 1;		//< Set once the client directly closes the object (closing can be asynchronous. Remembering this state avoids a double close if the session then closes)

	CCommonPlayer* iPlayer;		//< The Player responsible for this sub-session instance.

	TSubSessionUniqueId iSubSessionUniqueId; //Sub session unique id.

private:

	TApiExtRegister iApiExtRegister;   //Register of opened interfaces (on this subsession only)

	CCommonSessionProxy* iSessionProxy;

	TUint iNextScopeUniqueId;

	};

// Subsession index

/**

class CSubSessionIx

This sub-session container will maintain its own array of TEntry cells in memory as arrays provide for

quick access in some situations. There will be two types of cells in the array; cells carrying pointers

to sub-sessions and a virtual list of free cells.

This layout means that with a handle, the entry holding the sub-session can be looked up in the container

directly and if needing to insert a new entry the first free cell is indicated by iFreeListHead.

The array will grow with EIndexGranularity each time it runs out of free entries. However, it maintains a high

watermark and will never shrink.

The handles are defined by TSubSessionHandle, which in the current architectures is a 32 bit word, constructed

as needed. It is simple to deduct from the context so there is no need to store it.

0        8        16              31

|--------|--------|----------------|

   Type     Magic       Index

The three components comprising the handle are:

    - Type	- 8 bit value. One of the members of CSockSubsession::TSubSessionType.

    - Magic	- 8 bit value. Ensures that handles are not re-used immediately. Each time an entry is re-cycled this value increments, rolling around when reaching max.

    - Index	- 16 bit value. The position in the array.

@see CSockSubsession::TSubSessionType

*/

class CSubSessionIx : public CBase

/**

@internalComponent

*/

	{

	friend class TIter;

public:

	typedef TInt TSubSessionHandle;

	enum { KTypeBits = 8, KMagicBits = 8, KIndexBits = 16 };

	enum { KIndexLimit = 1 << KIndexBits };

	enum { KMagicMask = (1 << KMagicBits) - 1 };

public:

	IMPORT_C ~CSubSessionIx();

	void InitialiseL();

	inline void Lock() const;

	inline void Unlock() const;

	inline TInt ActiveCount() const;

	IMPORT_C CWorkerSubSession* At(TInt aHandle, TSubSessInfo aType) const;

	IMPORT_C TInt Find(CWorkerSubSession* aSubSession, TSubSessionHandle& aHandle) const;

	TInt Add(CWorkerSubSession* aSubSession, TSubSessionHandle& aHandle);

	IMPORT_C CWorkerSubSession* Replace(TSubSessionHandle aHandle, CWorkerSubSession* aSubSession);

	IMPORT_C CWorkerSubSession* Remove(TSubSessionHandle aHandle);

	NONSHARABLE_CLASS(TIter)

		{

	public:

		TIter(CSubSessionIx& aContainer);

		void SetToFirst();

		CWorkerSubSession* operator++(TInt);

		CWorkerSubSession* Next(TSubSessionHandle& aHandle);

	private:

		TInt iPos;

		CSubSessionIx& iContainer;

		};

private:

	enum { EIndexGranularity = 8 };

	/** class CSubSessionIx::TEntry

	One entry in the container. If iType is CWorkerSubSession::ENull, then it is a member of the free-list

	and iNextFree is the index of the next free TEntry instance otherwise it is an iObject* and points

	to a sub-session instance.

	iType can be one those defined in CPlayerSubsession::TSubSessionType.

	@see CSockSubsession::TSubSessionType

	*/

	class TEntry

		{

	public:

		union

			{

			CWorkerSubSession* iObject;

			TInt iNextFree;

			};

		TUint8 iType;

		TUint16 iMagic;

		};

private:

	inline TSubSessionHandle MakeHandle(TInt aIndex, TInt aMagic, TInt aType) const

		{

		return (((aIndex << KMagicBits) | aMagic) << KTypeBits) | aType;

		}

	inline TInt IndexFromHandle(TInt aHandle) const

		{

		return aHandle >> (KTypeBits + KMagicBits);

		}

	IMPORT_C TEntry* At(TSubSessionHandle aHandle) const;

	TInt ExpandArray();

private:

	TEntry* iIx;

	TInt iSize;

	TInt iActiveCount;			//< Number of active sub-sessions stored in this container.

	TInt iFreeListHead;			//< Pointer to the first item/cell in the virtual free list.

	mutable RWorkerLock iLock;

	};

class CWorkerSession: public CSession2

/**

@internalComponent

*/

	{

	friend class CCommonPitBoss;

	friend class CCommonDealer;

public:

	IMPORT_C ~CWorkerSession();

	IMPORT_C void ConstructL(TProcessId aProcessId);

	// Called by worker when it has received a SessionCloseRespMsg

	IMPORT_C void SessionCloseResp(CommsFW::TWorkerId aPlayerId);

	TBool IsPlayerInDisconnectList(CommsFW::TWorkerId aPlayerId) const;

	IMPORT_C TBool IsDisconnectListEmpty() const;

	void CleanupDeadWorker(CommsFW::TWorkerId aPeerId);

	void CompleteDisconnect();

	IMPORT_C static void PanicClient(const TDesC& aCategory, TInt aPanic);

	IMPORT_C void DontCompleteCurrentRequest();

	IMPORT_C void SetReturn(TInt aReturn /*,TInt anError=0,TUid anOwner=TUid::Null()*/);

	void Disconnect();

	// Override of default behaviour for session disconnection

	IMPORT_C void Disconnect(const RMessage2& aMessage);

	inline const TSessionUniqueId& UniqueId() const

		{

		return iSessionUniqueId;

		}

#ifdef SYMBIAN_TRACE_ENABLE

	TInt DisconnectPlayers();

#endif

	IMPORT_C static void LogSubSession(CWorkerSession* aSession, CWorkerSubSession* aSubSession, TInt aSubSessionHandle, TAny* aArg);

		// Apply a callback function to subsessions of the session, either matching the worker id, or all

	// if aPeerId == ENullWorkerId

	typedef void (*TSubSessionProcessor)(CWorkerSession* aSession, CWorkerSubSession* aSubSession, TInt aSubSessionHandle, TAny* aArg);

	IMPORT_C void ProcessSubSessions(CommsFW::TWorkerId aPeerId, TSubSessionProcessor aSubSessionProcessor, TAny* aArg);

	static void CountSubSessions(CWorkerSession* aSession, CWorkerSubSession* aSubSession, TInt aSubSessionHandle, TAny* aArg);

//	[MZ]: Note, needs to be reimplemented properly:

//	IMPORT_C static void DebugParkRequestsL(CWorkerSession* aSelf, TInt aSubSessHandle, TInt aCount);

//	IMPORT_C static void DebugReleaseParkedRequests(CWorkerSession* aSelf);

protected:

	IMPORT_C CWorkerSession(TUidType aUid, TSessionUniqueId aSessionUniqueId);

	// Callbacks used with ProcessSubSessions()

	static void ForgetSubSession(CWorkerSession* aSession, CWorkerSubSession* aSubSession, TInt aSubSessionHandle, TAny* aArg);

	static void OrphanSubSession(CWorkerSession* aSession, CWorkerSubSession* aSubSession, TInt aSubSessionHandle, TAny* aArg);

	IMPORT_C void ForwardMessageL(const RMessage2& aMessage, CWorkerSubSession* aSS, CommsFW::TWorkerId aWorker);

	IMPORT_C void ForwardMessageL(const RMessage2& aMessage, CWorkerSubSession& aSubSess);

	IMPORT_C void OrphanSubSessions();

	IMPORT_C CWorkerSubSession* SubSessionFromHandle(TUint aHandle, TSubSessInfo aType) const;

	/* Disconnect handling: before processing EDisConnect message to destroy session

	the Players with subsessions in the session are given the opportunity to cleanup.

	Players are tracked in a dirty-bit manner: they're added to the disconnect list

	when first referenced by the session and never removed (too much bookwork) */

	void AddPlayerToDisconnectList(CommsFW::TWorkerId aPlayerId);