diff -r 000000000000 -r dfb7c4ff071f datacommsserver/esockserver/inc/SS_conn.H --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/datacommsserver/esockserver/inc/SS_conn.H Thu Dec 17 09:22:25 2009 +0200 @@ -0,0 +1,308 @@ +// 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: +// + +#ifndef SS_CONN_H +#define SS_CONN_H + +#include +#include +#include +#include +#include +#include +#include + +class TSockOpt; + + +namespace ConnStates +{ + class TEmptyProgressQueueMutex; + + class TParseECNStart; + class TClearProgressQueue; + class TRequestCSRCreation; + class TProcessStateChange; + class TProcessIncomingConnection; + class TProcessProgressRequest; + class TParseECNAttach; + class TJoinReceivedCpr; + class TProcessBinderResponseForCpr; + class TCompleteLegacyAttach; + class TProcessEnumResponse; + + class TGenerateConnectionUpProgress; + class TGenerateConnectionDownProgress; + + class TNoTagOrCancelAllInterfaceWorker; + class TCancelAllInterfaceNotificationWorker; +} + +namespace AllInterfaceNotificationActivity +{ +class TStartLinkNotification; +class TEnqueueNotification; +class TSendErrorToConnection; +} + +namespace EnumerateConnectionsActivity +{ +class TQueryTierStatus; +class TCacheConnectionInfo; +class TCompleteClient; +} + +namespace ConnSubConnEventsActivity +{ +class TProcessSubConnEvent; +} + +namespace ESock +{ +class TCprRetrieveProgress; +class TCprRetrieveLastProgressError; + +class CConnectionInfo : public Meta::SMetaData +/** +@internalTechnology +*/ + { +public: + enum { ETypeId = 0, EUid = 0x10283005 }; + + static CConnectionInfo* NewL(const Den::TSubSessionUniqueId& aSubSessionId); + + virtual ~CConnectionInfo() + {} + + Den::TSubSessionUniqueId SubSessionId() const + { + return iSubSessionId; + } + + void SetSubSessionId(const Den::TSubSessionUniqueId& aSubSessionId) + { + iSubSessionId = aSubSessionId; + } + + DATA_VTABLE + +protected: + inline CConnectionInfo(const Den::TSubSessionUniqueId& aSubSessionId) + : iSubSessionId(aSubSessionId) + { + } + + Den::TSubSessionUniqueId iSubSessionId; + }; + +struct TCommsControlBinder; +struct TErrContext; +class XCommsDataObject; + +/** +Server side class representing an RConnection +@internalComponent +*/ +NONSHARABLE_CLASS(CConnection) : public CMMSockSubSession, + private ASubSessionPlatsecApiExt, + public ITFHIERARCHY_LINK_1(CConnection, MeshMachine::AMMNodeBase, MPlatsecApiExt) + { + friend class CSockSession; + friend class ConnStates::TEmptyProgressQueueMutex; +#ifdef __X86GCC__ + // gcc-mingw does not support declaring friends from different namespaces so we define proxy + // functions to do the cast. + friend CConnection* __x86gcc_connection_cast(Messages::ANode* aNode); + friend CConnection& __x86gcc_connection_cast(Messages::ANode& aNode); +#elif !defined(__GCCXML__) + friend CConnection* mcfnode_cast(Messages::ANode* aNode); + friend CConnection& mcfnode_cast(Messages::ANode& aNode); +#endif + + //Friendly activities: + + //Friendly transitions and states: + friend class ConnStates::TParseECNStart; + friend class ConnStates::TClearProgressQueue; + friend class ConnStates::TRequestCSRCreation; + friend class ConnStates::TProcessStateChange; + friend class ConnStates::TProcessIncomingConnection; + friend class ConnStates::TProcessProgressRequest; + friend class ConnStates::TParseECNAttach; + friend class ConnStates::TJoinReceivedCpr; + friend class ConnStates::TProcessBinderResponseForCpr; + friend class ConnStates::TCompleteLegacyAttach; + friend class ConnStates::TProcessEnumResponse; + friend class ESock::TCprRetrieveLastProgressError; + friend class ESock::TCprRetrieveProgress; + friend class EnumerateConnectionsActivity::TQueryTierStatus; + friend class EnumerateConnectionsActivity::TCacheConnectionInfo; + friend class EnumerateConnectionsActivity::TCompleteClient; + friend class AllInterfaceNotificationActivity::TEnqueueNotification; + friend class ConnSubConnEventsActivity::TProcessSubConnEvent; + + friend class ConnStates::TGenerateConnectionUpProgress; + friend class ConnStates::TGenerateConnectionDownProgress; + + friend class ConnStates::TNoTagOrCancelAllInterfaceWorker; + friend class ConnStates::TCancelAllInterfaceNotificationWorker; + + +public: + typedef ITFHIERARCHY_LINK_1(CConnection, MeshMachine::AMMNodeBase, MPlatsecApiExt) TIfStaticFetcherNearestInHierarchy; + +public: + // methods for creating CConnection instances + static CConnection* NewLC(CSockSession *aSession, CPlayer* aPlayer, TUid aTierId, const Den::TSubSessionUniqueId aSubSessionUniqueId); + static CConnection* NewLC(CSockSession *aSession, CPlayer* aPlayer, const CConnection& aExistingConnection, const Den::TSubSessionUniqueId aSubSessionUniqueId); + + virtual Den::TSubSessInfo Type() const + { + return TCFSubSessInfo(TCFSubSessInfo::EConnection); + } + + //Attached to interface in monitor mode? + inline TBool IsMonitor() const + { + return iIsMonitor; + } + + void ReturnInterfacePtrL(MPlatsecApiExt*& aInterface); + Messages::RNodeInterface* DefaultSubConnectionServiceProvider(); + TInt CheckCloneOpenPolicy(const RMessagePtr2& aMessage) const; + inline CConnectionInfo* ConnectionInfo() const + { + return iConnectionInfo; + } + +protected: + void Received(MeshMachine::TNodeContextBase& aContext); + void ReceivedL(const Messages::TRuntimeCtxId& aSender, const Messages::TNodeId& aRecipient, Messages::TSignatureBase& aCFMessage); //Messages::ANode + +//Signals from CSockSubSession + virtual void FinalCompleteAllBlockedMessages(TInt aResult); //Always KErrAbort + virtual void ProcessMessageL(); //IPC message arrived + +private: //Utility functions + void ForwardToServiceProviderL(const Messages::TSignalBase& aCFMessage); + inline void ResetLastProgressError(); + void SetCloneOpenPolicyL(TUint aOptionName); + +private: + virtual ~CConnection(); //Only my friend or subsess can delete me + +protected: + CConnection(CSockSession* aSession, CPlayer* aPlayer, TUid aTierId, const Den::TSubSessionUniqueId aSubSessionUniqueId); + void ConstructL(); + void CloneL(const CConnection& aExistingConnection); + +private: // Underlying implementations of individual RConnection methods + void GetReferenceL(); + void ControlL(); + void ProgressL(); + void LastProgressErrorL(); + void GetOrSetParametersL(); + void GetParametersResponseL(TBool aReturnLength); + void CancelIoctl(); + +private: + TUint iSelectedProgressStage; // the particular stage required for selected progress requests. + TProgressQueue iProgressQueue; // queue of progress notifications received + Elements::TStateChange iLastProgress; // last progress notified, so we can filter duplicates + Elements::TStateChange iLastProgressError; // last progress received which had an error + + TUid iTierId; + TSecurityPolicy iCloneOpenPolicy; // used for security checking during RConnection::Open(..., TName&) + TBool iCloneOpenEnabled :1; // flag indicating that iCloneOpenPolicy is initialized and "clone" open is enabled + TBool iIsMonitor :1; + XCommsDataObject* iCommsDataObject; + TUint iCommsDataObjectLength; // output query length + +protected: + + //-============================================= + //Legacy function + friend class AConnectionLegacy; + AConnectionLegacy iLegacyConnection; + //-============================================= + + CConnectionInfo *iConnectionInfo; + }; + + +//inline TBool CConnection::IsConnectionActive() const +// { return iConnectionProvider.Type() == RNodeInterface::EServProvider; } //WHO ADDS THIS THINGS????????????? + +inline void CConnection::ResetLastProgressError() + { iLastProgressError.iError = KErrNone; iLastProgressError.iStage = KConnectionUninitialised; }; + +#ifdef __X86GCC__ + // gcc-mingw does not support declaring friends from different namespaces so we define proxy + // functions to do the cast. + inline CConnection* __x86gcc_connection_cast(Messages::ANode* aNode) + { + return static_cast(aNode); + } + + inline CConnection& __x86gcc_connection_cast(Messages::ANode& aNode) + { + return static_cast(aNode); + } +#endif +} // namespace ESock + + +#ifdef __X86GCC__ + namespace Messages + { + // gcc-mingw does not support declaring friends from different namespaces so we define proxy + // functions to do the cast. + template <> + inline ESock::CConnection* mnode_cast(Messages::ANode* aNode) + { + return ESock::__x86gcc_connection_cast(aNode); + } + + template <> + inline ESock::CConnection& mnode_cast(Messages::ANode& aNode) + { + return ESock::__x86gcc_connection_cast(aNode); + } + } +#endif + + +NONSHARABLE_CLASS(CAllInterfaceNotificationWorker) : + public CBase, public ESock::ACFMMNodeIdBase + { +friend class AllInterfaceNotificationActivity::TStartLinkNotification; +friend class AllInterfaceNotificationActivity::TEnqueueNotification; +friend class AllInterfaceNotificationActivity::TSendErrorToConnection; + +public: + CAllInterfaceNotificationWorker(ESock::CConnection& aConnection); + virtual ~CAllInterfaceNotificationWorker(); + void ReceivedL(const Messages::TRuntimeCtxId& aSender, const Messages::TNodeId& aRecipient, Messages::TSignatureBase& aMessage); + +private: + void Received(MeshMachine::TNodeContextBase& aContext); + + ESock::CConnection& iConnection; + }; + + +#endif +// SS_CONN_H