diff -r 000000000000 -r dfb7c4ff071f commsfwsupport/commselements/rootserver/inc/rsstd.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/commsfwsupport/commselements/rootserver/inc/rsstd.h	Thu Dec 17 09:22:25 2009 +0200
@@ -0,0 +1,538 @@
+// 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;
+    TInt iEnumerateBindingsIndex;
+
+	CommsFW::TCFSubModuleAddress iEnumBindings;
+	CommsFW::TCFSubModuleNameF iEnumSubs;
+    };
+
+#include "rsstd.inl"
+
+#endif // __RSSTD_H__
+