diff -r 000000000000 -r dfb7c4ff071f datacommsserver/esockserver/eintsock/ss_eintsockimpl.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/datacommsserver/esockserver/eintsock/ss_eintsockimpl.h Thu Dec 17 09:22:25 2009 +0200 @@ -0,0 +1,237 @@ +// Copyright (c) 2005-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: +// eintsockimpl.h +// +// + +/** + @file + @internalTechnology +*/ + +#ifndef __EINTSOCKIMPL_H__ +#define __EINTSOCKIMPL_H__ + +#include +#include +#include +#include +#include "ss_eintsock_msgs.h" + +#include + +class CInternalServiceResolver; // not implemented as no-one wants it at the moment +class CInternalConnection; // not implemented, as too dodgy to bypass multiplexing in esock without some serious thought + +class RInternalSocket; +class TSockXferLength; +class TTransportUserStorage; + +using namespace ESock; + +// This is not really a C type class. +NONSHARABLE_CLASS(CIntSocketMessage) : public CBase, public AMessage + { + public: + virtual void AcquireMessage ( AMessage* aMessage ); + inline void SetMessage ( TEIntSockOpMsgWrapper& aMessage ); + + private: + virtual TInt ReadDes(TInt aSrcParamIndex,TDes8 &aDes,TInt anOffset=0 ); + virtual TInt ReadInt(TInt aSrcParamIndex); + virtual TInt ReadMBuf(TInt aSrcParamIndex, RMBufChain& aBufChain); + virtual void InitMBuf(TInt aParamIndex); + virtual TInt WriteDes(TInt aDstParamIndex,const TDesC8& aDes,TInt anOffset=0); + virtual TInt WriteMBuf(TInt aDstParamIndex,RMBufChain& aBufChain); + + virtual void CompleteMessage(TInt anError); + virtual TBool IsNull (TInt aParamIndex); + + inline TEIntSockOpMsgWrapper& Message (); + + private: + TEIntSockOpMsgWrapper iMessage; + }; + + +// A simple default security checker +class TDefaultSecurityChecker : public MProvdSecurityChecker + { + public: + TInt CheckPolicy (const TSecurityPolicy& /*aPolicy*/, const char * /*aDiagnostic*/) + { + return KErrNone; + } + }; + +// This class is needed for synchronous open +NONSHARABLE_CLASS(CAsyncWaiter) : public CActive + { + public: + static CAsyncWaiter* New (); + ~CAsyncWaiter (); + + TInt StartAndWait (); + + protected: + CAsyncWaiter (); + + // CActive + void RunL (); + void DoCancel (); + }; + + +NONSHARABLE_CLASS(CInternalSockSubSession) : public CBase, public MProvdSecurityChecker + { +public: + class TParameters + { + public: + TParameters(CommsFW::TWorkerId aClientWorkerId, CommsFW::MCommsTransportSender* aSender, TTransportUserStorage& aStorage, const Messages::TNodeId& aServerCookie, TRequestWrapper* aRequest /*TWorkerId aClientWorkerId, CommsFW::TWorkerId aServerWorkerId*/); + public: + TTransportUserStorage& iStorage; + CommsFW::TWorkerId iClientWorkerId; + Messages::TNodeId iServerCookie; + + // Used by the client for subsequent calls. Presumes client remains in same thread as when opened + // RInternalSocket must be Transfer()'d if client thread changes + CommsFW::MCommsTransportSender* iSender; + TRequestWrapper* iRequest; + }; + + IMPORT_C static void ProcessMessage(const Den::TWorkerTransportMsg& aMsg, TRequestWrapper& aRequest, TTransportUserStorage& aStorage, CommsFW::TWorkerId aPeerWorkerId); + IMPORT_C static void OnPeerDeath(CommsFW::TWorkerId aPeer, TTransportUserStorage& aStorage); + IMPORT_C static void Shutdown(TBool aAlreadyDead, TTransportUserStorage& aStorage); + + inline CommsFW::TWorkerId ClientWorkerId() const; + inline CommsFW::TWorkerId ServerWorkerId() const; + CommsFW::MCommsTransportSender* Sender() const; + void SetSender(CommsFW::MCommsTransportSender* aSender); + + inline TInt SendReceiveMsg(Den::TWorkerTransportMsg& aMsg); + inline void SendMsg(Den::TWorkerTransportMsg& aMsg); + static TInt SendReceiveMsg(Den::TWorkerTransportMsg& aMsg, CommsFW::MCommsTransportSender* aSender, const Messages::TNodeId& aServerCookie); + static void SendMsg(Den::TWorkerTransportMsg& aMsg, CommsFW::MCommsTransportSender* aSender, const Messages::TNodeId& aServerCookie); + static TInt SendReceiveMsgAsync( Den::TWorkerTransportMsg& aMsg, CommsFW::MCommsTransportSender* aSender, const Messages::TNodeId& aServerCookie ); + + virtual void FinalCompleteAllBlockedMessages(TInt aResult) = 0; + + virtual TInt CheckPolicy(const TSecurityPolicy& /*aPolicy*/, const char* /*aDiagnostic*/); + static TInt LinkOffset(); +protected: + typedef TDblQue TSubSessions; + class TGlobals + { + public: + TGlobals(); + TSubSessions iSubSessions; + }; + + CInternalSockSubSession(const TParameters& aParams); + void ConstructL(const TParameters& aParams); + + static TGlobals* Globals(TTransportUserStorage& aStorage); + + static TSubSessions& SubSessions(TTransportUserStorage& aStorage); + static void AddSubsession(TTransportUserStorage& aStorage, CInternalSockSubSession* aSubSession); + static void ProcessMessageL(const Den::TWorkerTransportMsg& aMsg, TRequestWrapper& aRequest, TTransportUserStorage& aStorage, CommsFW::TWorkerId aPeerWorkerId); + static TInt PerformOperationL(const TEIntSockMsg& aMsg, TRequestWrapper& aRequest); + +private: + TInt iAccessCount; + CommsFW::TWorkerId iClientWorkerId; +// TWorkerId iServerWorkerId; + Messages::TNodeId iServerCookie; + CommsFW::MCommsTransportSender* iSender; // presumes client remains in same thread as when opened - safe for now +protected: + TDblQueLink iLink; + CWorkerThread* iOwnerThread; + }; + + +NONSHARABLE_CLASS(CInternalSocketImpl) : public CInternalSockSubSession, public ASocket +/** +Implementation of RInternalSocket +*/ + { + typedef CInternalSockSubSession inherited; + friend class CInternalSockSubSession; + friend class ProtocolManager; +private: + // Various bits to create a new internal socket in different ways + static CInternalSocketImpl* NewL ( const CInternalSockSubSession::TParameters& aParams ); + static CInternalSocketImpl* NewL ( const CInternalSockSubSession::TParameters& aParams, TServerProtocolDesc* aServiceInfo, CProtocolBase* aProt ); + ~CInternalSocketImpl(); + + virtual void FinalCompleteAllBlockedMessages(TInt aResult); + + void SetImpl ( CInternalSocketImpl*& aImpl ); + + virtual TDes8* BorrowTemporaryBuffer(TInt aSize); + virtual TDes8* BorrowTemporaryBufferL(TInt aSize); +private: + CInternalSocketImpl(const CInternalSockSubSession::TParameters& aParams, TUint aSockType); + void ConstructL(const TParameters& aParams, TServerProtocolDesc* aServiceInfo, CProtocolBase* aProt); + void InitUserMessageL ( TSocketMessage aMessage ); + + void SendL ( TSockMess aWriteFunction, TEIntSockOpMsgWrapper& aMsg ); + void RecvL ( TSockMess aReadFunction, TEIntSockOpMsgWrapper& aMsg ); + void CancelOpen (); + + // From ASocket + // ---------------- + virtual void SetClosing(); + virtual TBool IsClosing(); + + virtual void DontCompleteCurrentRequest(); + + virtual ASocket* InitiateAcceptingSocket(); + virtual ASocket* GetAcceptingSocket(); + + virtual void SetReturn(TInt aReturnValue) const; + + virtual void GetOwnerInfo(TProcessId& aProcId, TSoOwnerInfo& aInfo, TThreadId& aThreadId); + virtual TInt SecurityCheck(); + + virtual void CompleteFlowRequestMessage(TInt aErr); + + virtual void InitiateDestruction(); + virtual TBool CloseSocket(); + virtual void PanicSocketClient(TESockPanic aPanic); + // -------------- + + TEIntSockOpMsgWrapper& GetMessage (TSocketMessage aMessage); + TBool ShouldCompleteCurrentRequest () const; + inline TInt Return () const; + void AdoptFlowRequest ( TRequestWrapper& aRequest ); + void SetCurrentMessage ( TEIntSockOpMsgWrapper& aIntSockMsg ); + void CompleteCurrentRequest ( TBool aValue ); + +private: + TBool iComplete:1; + TBool iClosing:1; + mutable TInt iReturn; + + TRequestWrapper iFlowRequest; + CInternalSocketImpl** iImpl; // This will hold the reference to the pointer that RInternalSocket holds. + // It will be set when the the internal socket is actuall created. in case of + // an error it will be NULL and socket will do a self deletion. + CProtocolBase* iProtocol; + }; + +#include "ss_eintsockimpl.inl" + +#endif // __EINTSOCKIMPL_H__ +