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

*/

#if !defined(__RSSTD_H__)

#define __RSSTD_H__

#include <cflog.h>

#include <cfshared.h>

#include <commschan.h>

#include <rscommon.h>

#include <e32property.h>

class CRootServerSession;

class CRootServer;

class CBindManager;

NONSHARABLE_CLASS(CRSTransientModuleInfo) : public CBase

/** Helper class/structure used by the RCFThread.

@internalComponent

*/

	{

	public:

	~CRSTransientModuleInfo();

	CRSTransientModuleInfo(const CommsFW::RCFChannel::TMsgQueues& aTxQueues, const CommsFW::RCFChannel::TMsgQueues& aRxQueues,

						   RootServer::TRSHeapType aThreadHeapType, TThreadFunction aLibEntry, HBufC8* aIniDataOnRSHeap,

                           TThreadPriority aPriority, TUint32 aControlFlags);

	static TInt ModuleThreadStartup(TAny* aArg);

	private:

	CommsFW::TCFModuleInfo iCFModuleInfo;

	RootServer::TRSHeapType iThreadHeapType;

	TThreadFunction iLibEntry;

	HBufC8* iIniDataOnRSHeap;

	RHeap* iHeapPtr;

	TThreadPriority iPriority;

	TUint32 iControlFlags;

	};

/** MNotifySuddenDeath is used by CModuleUndertaker to notify registered

sessions of Sudden Death.

@internalComponent

*/

class MNotifySuddenDeath

    {

public:

    virtual void SuddenDeath(TInt aError)=0;

    };

class CNotifySuddenDeathContainer:public CBase

    {

public:

    CNotifySuddenDeathContainer(MNotifySuddenDeath* aNotifier);

    void Dequeue();

    void Notify(TInt aReason);

	TBool Match(MNotifySuddenDeath* aNotifier) const;

public:

    TDblQueLink iLink;			// DblQue link element

private:

    MNotifySuddenDeath* iNotifier; 	// Reference to notifier

    };

/** The CModuleUnderTaker class monitors a thread for sudden death. If it happens it will call

iNotifier->SuddenDeath().

@internalComponent

*/

NONSHARABLE_CLASS(CModuleUndertaker) : public CActive

    {

public:

    ~CModuleUndertaker();

    static CModuleUndertaker* NewL(MNotifySuddenDeath& iNotifier, RThread& aThread);

    void Logon();

protected:

    void DoCancel();

    void RunL();

    void LogThreadDeath();

private:

    CModuleUndertaker(MNotifySuddenDeath& iNotifier, RThread& aThread);

    MNotifySuddenDeath& iNotifier;

    RThread& iThread;

    };

/** This is the main module orchestrating thread creation, loading and unloading, The class

is asynchronously activated from three active objects: its own derivative, the

iModuleTimer * member and the iUndertaker member. The type of action taken on a particular

input is decided by its internal state, defined by iState.

@internalTechnology

*/

class CCommsProviderModule : public CActive, public MNotifySuddenDeath

    {

public:

    IMPORT_C ~CCommsProviderModule();

    TInt Load(TRequestStatus& aStatus);			// Start module in new thread

    TInt CancelLoad();

    TInt Unload();								// Unload module

    TInt CancelUnload(RootServer::TRSUnLoadType aType);

	RThread GetThread() const;

	inline const CommsFW::TCFModuleNameF& GetName() const;		// Return name

	inline const TFileName& GetDll() const;			// Return name of dll

	inline RootServer::TRSModuleState GetState() const;

#ifdef __CFLOG_ACTIVE

	const TText8* GetStateName() const;

#endif

#if defined _DEBUG || defined __CFLOG_ACTIVE || defined SYMBIAN_TRACE_ENABLE

	static const TText8* GetUnloadTypeName(RootServer::TRSUnLoadType aType);

#endif

	inline RHeap* GetHeapPtr() const;

	inline const CommsFW::RCFChannel& GetSendChannel() const;

	inline const CommsFW::RCFChannel& GetRecvChannel() const;

    IMPORT_C virtual void SuddenDeath(TInt aReason);   // Called by iUndertaker upon thread death

	inline TBool IsSticky() const;

	inline TBool IsServer() const;

#ifdef SYMBIAN_C32ROOT_API_V3

	inline TUint32 ControlFlags() const;

	inline void SetControlFlags(TUint32 aFlags);

#endif

    // Functions for handling Sudden Death notification

    void RegisterSuddenDeathNotifierL(MNotifySuddenDeath* aNotifier);

	void UnregisterSuddenDeathNotifier(MNotifySuddenDeath* aNotifier);

	// Failure to respond promptly converts it into half-dead zombie

	void Inhume();

    void CreateThreadL();

public:

   	TDblQueLink iLink;	// DblQue link element

protected:

    IMPORT_C CCommsProviderModule( RThread& aThread );

    IMPORT_C void ConstructL(CRootServer* aRootServer, const RootServer::TRSStartModuleParams& aParams, HBufC8* aIniData);

private:

    virtual TInt CreateModuleThread(const TDesC& aName, TThreadFunction aOtherThreadFunction,

						TInt aStackSize, RHeap* aHeap, TAny* aModuleArgs) = 0;

private:

    void NotifyOfDeath( TInt aReason );

    TBool UidMatch(const TUid& aUid) const;

    IMPORT_C void RunL();

    void DoCancel() {};

    RootServer::TRSModuleState iState;					// Current state of module (running, starting, etc)

protected:

	/** Whether RootServer should deny client shutdown requests.

	 */

	TBool iIsSticky;

	/** Whether module is being loaded as a server.

	 */

	TBool iIsServer;

	/** Additional module control flags

	    @see TRSStartModuleParamContainer::TControlFlags

	 */

	TUint32 iControlFlags;

    /** Saved for asynchronous stuff.

	 */

    TRequestStatus* iReqStatus;

    /** Name of module, defined by privileged app.

	 */

    CommsFW::TCFModuleNameF iName;

    /** Filename of DLL containing this module.

	 */

    TFileName iDll;

    /** Handle on the DLL, kept open as long as the module is active.

	 */

    RLibrary iLibrary;

    HBufC8* iIniData;

    /** Priority of thread.

	 */

    TThreadPriority iPriority;

    /** Stack size of thread.

	 */

    TInt iStackSize;

    /** Min heap size of thread.

	 */

    TInt iMinHeapSize;

    /** Max heap size of thread.

	 */

    TInt iMaxHeapSize;

    /** Ordinal for main threadfunction in dll.

	 */

	TInt iThreadFunctionOrdinal;

	/** EDefaultHeap, EShareHeap(with another loaded module), ENewHeap.

	 */

    RootServer::TRSHeapType iHeapType;

    /** If sharing a heap, then this is the module to share with.

	 */

    CommsFW::TCFModuleNameF iShareHeapWith;

    /** Thread handle of running module context.

	 */

    RThread& iThread;

    /** Active object listening for sudden death.

	 */

    CModuleUndertaker* iUndertaker;

    /** Access to the root server public functions.

	 */

    CRootServer* iRootServer;

    /** Sending comms channel.

	 */

	CommsFW::RCFChannel iSend;

	/** Receiving comms channel.

	 */

	CommsFW::RCFChannel iRecv;

	/** Registered sudden death notifiers.

	 */

	TDblQue<CNotifySuddenDeathContainer> iNotifiers;

	/** Exitreason when module has exited.

	 */

	TInt iExitReason;

    CRSTransientModuleInfo* iThreadStartupInfo;

    RHeap* iHeapPtr;

    };

class CRootServer : public CPolicyServer, public MRootServerNotify

/** The main class implementing the Rootserver.

@internalTechnology

*/

    {

public:

	IMPORT_C ~CRootServer();

    // Create new CRootServerSession instance

    IMPORT_C virtual CSession2* NewSessionL(const TVersion &aVersion, const RMessage2& aMessage) const;

    // Create comms provider module and put it in list

    CCommsProviderModule* CreateCpmL(const RootServer::TRSStartModuleParams& aParams, HBufC8* aIniData);

    RHeap* FindHeap( const CommsFW::TCFModuleNameF& aName );

    // Retrieve Server or Provider reference by name

    CCommsProviderModule* FindCpm(const CommsFW::TCFModuleNameF& aName);

    // Sudden Death notification. Called by Undertaker's. Call all members of iNotifier.

    IMPORT_C void SuddenDeath(TInt aReason);

    // Information, module count

    IMPORT_C TInt CpmCount();

    // Information, Enumeration

    TInt EnumerateModules(TInt aStartAt, CommsFW::TCFModuleNameF& aName);

    TInt EnumerateSubModules(const CommsFW::TCFModuleNameF& aModuleName, TInt aStartAt, CommsFW::TCFSubModuleNameF& aName);

    TInt GetModuleInfo(const CommsFW::TCFModuleNameF& aName, RootServer::TRSModuleInfo& aInfo);

	IMPORT_C virtual void LazyLoadL();

	IMPORT_C virtual void ReceivedMessage(const CommsFW::TCFModuleName& aModule,

							              const CommsFW::TCFMessage& aNewMsg);	// Notification of messages from modules

	CBindManager* BindManager() const;	// returns a pointer to the bind manager

	TInt Shutdown();

	TInt Forward(const CommsFW::TCFModuleNameF& aModule, const RMessage2& aMessage);

	IMPORT_C virtual TBool IsCallerConfigurator(const CRootServerSession* aSession, const RMessage2& aMessage);

	IMPORT_C virtual void DisconnectSession(const CRootServerSession* aSession);

	TUid iDeathKey;

	TUid iLeakKey;

	TUid iProcessKey;

protected:

    IMPORT_C CRootServer(TInt aPriority, const TPolicy& aPolicy); 	// Construction

    IMPORT_C void ConstructL(const TRootServerStartupInfo& aRootServerStartupInfo); 			// Second level construction

protected:

    TDblQue<CCommsProviderModule> iModules;

	CBindManager* iBindMgr;

	RProperty iDeathProperty;

	TInt iDeathCount;

	__CFLOG_DECLARATION_MEMBER;

	static const TUint PolicyRangeCount;

	static const TInt PolicyRanges[];

	static const CPolicyServer::TPolicyElement PolicyElements[];

	static const TUint8 PolicyElementsIndex[];

	static const CPolicyServer::TPolicy Policy;

    TCommsProviderModuleCtor iCommsProviderModuleCtorL;

#ifdef SYMBIAN_NETWORKING_PERFMETRICS

	CPerfMetricStore* iPerfStore;

#endif

    };

NONSHARABLE_CLASS(CSessionHandler) : public CActive, public MNotifySuddenDeath

/** Active session response object. Used when the session makes an asynchronous request to

e.g. Binding Manager. Has access to public members of it's CRootServerSession parent.

@internalComponent

*/

    {

public:

    CSessionHandler( CRootServerSession* aSession, CBindManager* aBindMgr, const RMessage2& aMessage );

    ~CSessionHandler();

    CCommsProviderModule* GetModulePtr( const CommsFW::TCFModuleNameF& aName ) const;

	virtual TInt Start() = 0;

	virtual TBool CancelHandler( TBool aCompleteRequest, TBool aWaitForCompletionIfUncancelable = EFalse ) = 0;

	TDblQueLink iLink;	// DblQue link element

	enum TSHType

		{

		ESHTypeLoadCPM = 0,

		ESHTypeUnLoadCPM = 1,

		ESHTypeBinding = 2,

		ESHTypeUnBinding = 3

		};

	virtual TSHType HandlerType() = 0;

protected:

	virtual void CompleteClientRequest( TInt aRequest );

	virtual void RunL()=0;

	virtual void DoCancel()=0;

	void SuddenDeath(TInt aError);

    enum TSHState

		{

		ESHIdle = 0,

		ESHStarting = 1,

		ESHLoading = 2,

		ESHUnLoading = 3,

		ESHBinding = 4,

		ESHUnBinding = 5,

		ESHKilling = 6,

		ESHCompleting = 7

		};

	TBool iRequestCompleted;

    CRootServerSession* iSession;

	CBindManager* iBindMgr;

	TSHState iState;

	RMessage2 iMessage;

    };

NONSHARABLE_CLASS(CSessionHandlerLoadCPM) : public CSessionHandler

/** Small class to handle a pending operation for loading a module.

@internalComponent

*/

	{

public:

	static CSessionHandlerLoadCPM* NewL( CRootServerSession* aSession, CBindManager* aBindMgr, const RMessage2& aMessage );

	~CSessionHandlerLoadCPM();

	TInt Start();

	void SetHandler( const CommsFW::TCFModuleNameF& aModule );

	TBool CancelHandler( TBool aCompleteRequest, TBool aWaitForCompletionIfUncancelable = EFalse );

	CSessionHandler* MatchPending( const CommsFW::TCFModuleNameF& aModule );

	virtual TSHType HandlerType();

private:

	CSessionHandlerLoadCPM( CRootServerSession* aSession, CBindManager* aBindMgr, const RMessage2& aMessage );

	void ConstructL();

	void CompleteClientRequest( TInt aRequest );

	void RunL();

	void DoCancel();

	void CompleteModalWaiter();

	void SuddenDeath(TInt aError);

private:

	CommsFW::TCFModuleNameF iName;

	CActiveSchedulerWait* iLoadCompletionNotificationWaiter;

	};

NONSHARABLE_CLASS(CSessionHandlerUnLoadCPM) : public CSessionHandler

/** Small class to handle a pending operation for unloading a module.

@internalComponent

*/

	{

public:

	static CSessionHandlerUnLoadCPM* NewL( CRootServerSession* aSession, CBindManager* aBindMgr, const RMessage2& aMessage );

	~CSessionHandlerUnLoadCPM();

	TInt Start();

	void SetHandler( const CommsFW::TCFModuleNameF& aModule, RootServer::TRSUnLoadType aType );

	TBool CancelHandler( TBool aCompleteRequest, TBool aWaitForCompletionIfUncancelable = EFalse );

	CSessionHandler* MatchPending( const CommsFW::TCFModuleNameF& aModule );

	virtual TSHType HandlerType();

private:

	CSessionHandlerUnLoadCPM( CRootServerSession* aSession, CBindManager* aBindMgr, const RMessage2& aMessage );

	void ConstructL();

	void CompleteClientRequest( TInt aRequest );

	void RunL();

	void DoCancel();

	void SuddenDeath(TInt aError);

private:

	CommsFW::TCFModuleNameF iName;

	RootServer::TRSUnLoadType iType;

	CActiveSchedulerWait* iLoadCompletionNotificationWaiter;

	};

NONSHARABLE_CLASS(CSessionHandlerBinding) : public CSessionHandler

/** Small class to handle a pending operation for forbinding a module.

@internalComponent

*/

	{

public:

	static CSessionHandlerBinding* NewL( CRootServerSession* aSession, CBindManager* aBindMgr, const RMessage2& aMessage );

	TInt Start();

	void SetHandler(const CommsFW::TCFSubModuleAddress& aFrom,

					const CommsFW::TCFSubModuleAddress& aTo, RootServer::TRSBindType& aBindType,

					TInt aForwardQLength, TInt aReverseQLength);

	TBool CancelHandler( TBool aCompleteRequest, TBool aWaitForCompletionIfUncancelable = EFalse );

	CSessionHandler* MatchPending( const CommsFW::TCFSubModuleAddress& aFrom, const CommsFW::TCFSubModuleAddress& aTo );

	virtual TSHType HandlerType();

private:

	CSessionHandlerBinding( CRootServerSession* aSession, CBindManager* aBindMgr, const RMessage2& aMessage );

	void RunL();

	void DoCancel();

private:

	RootServer::TRSBindType iBindType;

	CommsFW::TCFSubModuleAddress iNameFrom;

	CommsFW::TCFSubModuleAddress iNameTo;

	TInt iForwardQLength;

	TInt iReverseQLength;

	};

NONSHARABLE_CLASS(CSessionHandlerUnBinding) : public CSessionHandler

/** Small class to handle a pending operation for unloading a module

@internalComponent */

	{

public:

	static CSessionHandlerUnBinding* NewL( CRootServerSession* aSession, CBindManager* aBindMgr, const RMessage2& aMessage );

	TInt Start();

	void SetHandler( const CommsFW::TCFSubModuleAddress& aFrom, const CommsFW::TCFSubModuleAddress& aTo );

	TBool CancelHandler( TBool aCompleteRequest, TBool aWaitForCompletionIfUncancelable = EFalse );

	CSessionHandler* MatchPending( const CommsFW::TCFSubModuleAddress& aFrom, const CommsFW::TCFSubModuleAddress& aTo );

private:

	CSessionHandlerUnBinding( CRootServerSession* aSession, CBindManager* aBindMgr, const RMessage2& aMessage );

	void RunL();

	void DoCancel();

	virtual TSHType HandlerType();

private:

	CommsFW::TCFSubModuleAddress iNameFrom;

	CommsFW::TCFSubModuleAddress iNameTo;

	};

class CRootServerSession : public CSession2, public MNotifySuddenDeath

/** Required session object as required by the client/server framework.

Implements the "Secure IPC" API.

@internalComponent

*/

    {

public:

	IMPORT_C CRootServerSession(const CRootServer* aRootServer);

	IMPORT_C virtual void ServiceL(const RMessage2& aMessage);

    IMPORT_C void SuddenDeath(TInt aError); // As required by MNotifySuddenDeath

	void RegisterHandler( CSessionHandler& aHandler );

 	void CloseSession();

 	CRootServer* RootServer();

    RMessage2& GetMessage();

    IMPORT_C virtual ~CRootServerSession();

protected:

	IMPORT_C void Disconnect(const RMessage2& aMessage);    

    virtual TInt IsCallerConfigurator(const RMessage2& aMessage);    

    TInt LoadCPML(const RMessage2& aMessage);

    TInt UnloadCPML(const RMessage2& aMessage);

	TInt GetModuleInfo(const RMessage2& aMessage);

    TInt EnumerateModules(const RMessage2& aMessage);

    TInt EnumerateSubModules(const RMessage2& aMessage);

	TInt CancelLoadCPM(const RMessage2& aMessage);

	TInt CancelUnloadCPM(const RMessage2& aMessage);

	TInt Forward(const RMessage2& aMessage);

    TInt EnumerateBindings(const RMessage2& aMessage);

    TInt BindL(const RMessage2& aMessage);

    TInt UnbindL(const RMessage2& aMessage);

	TInt CancelBind(const RMessage2& aMessage);

	TInt CancelUnbind(const RMessage2& aMessage);

	TInt Shutdown();

protected:

    CRootServer* iRootServer;

private:

    RMessage2 iMessage;

    TBool iSuddenDeathListener;

    RMessage2 iSuddenDeathMessage;

    TBool iRequestActive;

    TDblQue<CSessionHandler> iActiveHandlers;

	//Enumeration

    TInt iEnumerateModulesIndex;

    TInt iEnumerateSubModulesIndex;