--- /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 <e32std.h>
+#include <es_prot.h>
+#include <ss_std.h>
+#include <es_mbuf.h>
+#include "ss_eintsock_msgs.h"
+
+#include <comms-infras/ss_intsock.h>
+
+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<CInternalSockSubSession> 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__
+