--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/webservices/wscore/inc/senclientsession.h Thu Jan 07 16:19:19 2010 +0200
@@ -0,0 +1,590 @@
+/*
+* Copyright (c) 2002-2005 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: Header declaration
+*
+*/
+
+
+
+
+
+
+
+
+
+
+
+#ifndef SEN_CLIENTSESSION_H
+#define SEN_CLIENTSESSION_H
+
+// INCLUDES
+#include <e32base.h>
+#include <badesca.h>
+#include <flogger.h>
+
+#include "msenremoteserviceconsumer.h"
+#include "msenremotehostlet.h"
+#include "msenservicemanager.h"
+#include "msenremoteservicesession.h"
+#include "senpointermap.h"
+#include "senchunk.h"
+
+#include "sentransportbase.h"
+
+#include "msenmessagecontext.h" // application domain: Framework\inc
+#include "senmessagecontext.h"
+
+#include "sencontext.h" // private: Framework\inc
+
+#include "RSenDocument.h"
+#include "senservicemanagerdefines.h"
+#include "senatomentry.h"
+#ifdef __ENABLE_ALR__
+#include "senmobilityobserver.h"
+#endif //__ENABLE_ALR__
+
+// CONSTANTS
+const TInt KErrConsumerIdIsNull = 84;
+
+// FORWARD DECLARATIONS
+class CSenIdentifier;
+class CSenServiceSession;
+class CSenClientMessage;
+class CSenSoapEnvelope2;
+class TXmlEngElement;
+class TXmlEngDataContainer;
+class RSenDocument;
+class CSenMessageContext;
+class CSenServerContext;
+class RSenConnectionServerSession;
+class TFileTransferProgress;
+
+typedef RSenPointerMap<TInt, CSenClientMessage> RHostletRequestMap;
+
+//typedef RPointerArray<RMessage2> RTransactionArray;
+typedef RPointerArray<CSenClientMessage> RTransactionArray;
+typedef RPointerArray<TInt> RTransactionIdArray;
+
+
+NONSHARABLE_CLASS(CSenMessageResourceHandler): public CActive
+ {
+ friend class RSenConnectionServerSession;
+ private:
+ CSenMessageResourceHandler(TInt aTxnId, TBool aIncoming, TBool aIsSoap,
+ TInt aProgress, RSenConnectionServerSession* aOwner);
+ ~CSenMessageResourceHandler();
+ void DoCancel();
+ void RunL();
+ TInt SetBuffer(const TDesC8& aSoapOrCid);
+
+ private:
+ TPckgBuf<TTransferProgress> iProgressData;
+ HBufC8* iSoapOrCid;
+ RSenConnectionServerSession* iOwner;
+ CSenMessageResourceHandler* iNext;
+ CSenMessageResourceHandler* iPrevious;
+ };
+
+//class RSenConnectionServerSession: public RSessionBase
+NONSHARABLE_CLASS(RSenConnectionServerSession): public RSessionBase
+ {
+ public:
+ TInt CreateSession(const RMessage2& aMessage);
+ void SendFileProgress(TInt aTxnId, TBool aIncoming, TBool aIsSoap,
+ const TDesC8& aSoapOrCid, TInt aProgress);
+ void Remove(CSenMessageResourceHandler* aResourceHandler);
+ void Close();
+
+ TInt InitProgressObserver(const RMessage2& aMessage);
+ TInt InitAuthObserver(const RMessage2& aMessage);
+ TInt ReauthenticationNeeded(CSenChunk& aSenChunk);
+ TInt InitCoBrandingObserver(const RMessage2& aMessage);
+ TBool OnGetBrandIdL( const TDesC8& aBrandIdListAsXmlSnippet, RBuf8& aSelectedBrandId);
+#ifdef __ENABLE_ALR__
+ TInt InitMobilityObserver(const RMessage2& aMessage) ;
+
+ TInt PreferredCarrierAvailable( TAccessPointInfo& aOldAPInfo, TAccessPointInfo& aNewAPInfo, TBool& aIsUpgrade, TBool& aIsSeemLess) ;
+
+ TInt NewCarrierActive (TAccessPointInfo& aNewAPInfo, TBool& aIsSeamless ) ;
+ TInt MobilityError( TInt& aError ) ;
+#endif //__ENABLE_ALR__
+ private:
+ CSenMessageResourceHandler* iFirst;
+ };
+
+NONSHARABLE_CLASS(CSenConnAgentSync): public CActive
+ {
+ friend class RSenConnectionServerSession;
+private:
+ CSenConnAgentSync();
+ ~CSenConnAgentSync();
+ void DoCancel();
+ void RunL();
+ void Start();
+ };
+
+NONSHARABLE_CLASS(CSenBinaryData): public CBase
+ {
+ public:
+ enum TSenBinaryDataType
+ {
+ EFile = 1,
+ EChunk = 2
+ };
+
+ static CSenBinaryData* NewL(RChunk& aChunk, TDesC8& aCid, TInt aOffset, TInt aSize);
+ static CSenBinaryData* NewLC(RChunk& aChunk, TDesC8& aCid, TInt aOffset, TInt aSize);
+ static CSenBinaryData* NewL(RFs& aFs, RFile& aFile, TDesC8& aCid, TInt aOffset = 0, TInt aSize = 0);
+ static CSenBinaryData* NewLC(RFs& aFs, RFile& aFile, TDesC8& aCid, TInt aOffset = 0, TInt aSize = 0);
+
+ ~CSenBinaryData();
+
+ RChunk& Chunk();
+ RFile& File();
+ TDesC8& Cid();
+ TInt Offset();
+ TInt Size();
+ TSenBinaryDataType Type();
+
+ protected:
+ CSenBinaryData(TInt aOffset, TInt aSize);
+ void BaseConstructL(RChunk& aChunk, TDesC8& aCid);
+ void BaseConstructL(RFs& aFs, RFile& aFile, TDesC8& aCid);
+
+ private:
+ RChunk iChunk;
+
+ RFs iFs;
+ RFile iFile;
+
+ TSenBinaryDataType iType;
+ HBufC8* ipCid;
+ TInt iOffset;
+ TInt iSize;
+ };
+
+// CLASS DECLARATION
+#ifdef __ENABLE_ALR__
+class CSenClientSession : public CSession2, public MSenRemoteServiceConsumer, public MSenRemoteHostlet, public MMobilityProtocolResp
+#else
+class CSenClientSession : public CSession2, public MSenRemoteServiceConsumer, public MSenRemoteHostlet
+#endif
+ {
+ public: // Constructors and destructor
+
+ static CSenClientSession* NewL( MSenServiceManager& aServer, CSenServerContext& aCtx );
+ static CSenClientSession* NewLC( MSenServiceManager& aServer, CSenServerContext& aCtx );
+
+ ~CSenClientSession();
+
+ // Function from base classes
+
+ // from CSession2
+ void ServiceL(const RMessage2& aMessage);
+
+ // from MSenRemoteServiceConsumer
+ virtual const TDesC8& Id() const;
+ CSenIdentifier& Identifier() const;
+
+ TInt SetSessionL(MSenRemoteServiceSession& aServiceSession);
+ TInt HandleMessageL(HBufC8* apMessage,
+ const TInt aTxnId,
+ MSenProperties* aResponseTransportProperties);
+
+ TInt HandleErrorL(HBufC8* apError,
+ const TInt aErrorCode,
+ const TInt aTxnId,
+ MSenProperties* aResponseTransportProperties);
+
+ void SetStatusL(const TInt status);
+ void FileProgress(TInt aTxnId, TBool aIncoming, TBool aIsSoap,
+ const TDesC8& aSoapOrCid, TInt aProgress);
+ void TransferProgressForHostlet( TInt aTxnId, TBool aIsIncoming, TBool aIsSoap, const TDesC8& aSoapOrCid, TInt aProgress);
+ void SetDataTrafficDetails( TSenDataTrafficDetails& aDetails);
+
+ MSenTransport& TransportL();
+
+ TInt ProcessRequestFromConsumerL(const TDesC8& aMessage,
+ const TInt aTxnId,
+ MSenRemoteServiceConsumer& aConsumer);
+
+ TInt ChunkByTxnIdL(TInt aTxnId, CSenChunk*& aChunk);
+ MSenMessageContext* MessageContextByTxnIdL(TInt aTxnId, TInt& aError);
+
+ TInt OnServiceCompleteL(const TInt aTxnId, TInt aCompletionCode, const TDesC8& aDesc = KNullDesC8);
+
+ void StateChanged(TInt aState);
+
+ TBool HasAuthenticationCallback();
+ TInt ReauthenticationNeededL(CSenIdentityProvider*& aIdp);
+ TBool OnGetBrandIdL( const TDesC8& aBrandIdListAsXmlSnippet, RBuf8& aSelectedBrandId);
+ TBool HasCoBrandingCallback();
+#ifdef __ENABLE_ALR__
+ void ObserveMobiltyService(const RMessage2& aMessage) ;
+ void MigrateToPrefferedCarrierL(const RMessage2& aMessage) ;
+ void PreferredCarrierAvailable( TAccessPointInfo aOldAPInfo,
+ TAccessPointInfo aNewAPInfo,
+ TBool aIsUpgrade,
+ TBool aIsSeamless ) ;
+ void Error( TInt aError );
+ void NewCarrierActive( TAccessPointInfo aNewAPInfo, TBool aIsSeamless ) ;
+ void NewCarrierAcceptedL(const RMessage2& aMessage) ;
+#endif //__ENABLE_ALR__
+ protected:
+ CSenClientSession(MSenServiceManager& aServer, CSenServerContext& aCtx);
+ void ConstructL();
+
+ // New functions
+
+ void PanicClient(const RMessagePtr2& aMessage,TInt aPanic) const;
+ void InitializeL(const RMessage2& aMessage);
+ void TransactionL(const RMessage2& aMessage);
+ TInt SearchMsgChunk( const RMessage2& aMessage, CSenChunk*& aHit );
+ void SendMsg( const RMessage2& aMessage ); // async
+ void SendMsgL( const RMessage2& aMessage, CSenChunk& aSenChunk ); // async
+ RFileLogger* Log() const;
+ void InstallFrameworkL(const RMessage2& aMessage);
+ void DissociateServiceL(const RMessage2& aMessage);
+ void AssociateServiceL(const RMessage2& aMessage);
+ void RegisterIdentityProviderL(const RMessage2& aMessage);
+ void UnregisterIdentityProviderL(const RMessage2& aMessage);
+ void RegisterServiceDescriptionL(const RMessage2& aMessage);
+ void UnregisterServiceDescriptionL(const RMessage2& aMessage);
+
+ /**
+ * Searches and returns all service descriptions, which contain
+ * matching fields (elements) with spesified service pattern.
+ * Typical fields used in service pattern are Endpoint and
+ * Contract.
+ */
+ void ServiceDescriptionsByPatternL(const RMessage2& aMessage);
+ /**
+ * Searches and returns all service descriptions, which match
+ * with specified Contract (typically some URI).
+ */
+ void ServiceDescriptionsByUriL(const RMessage2& aMessage);
+
+ void IsReadyL(const RMessage2& aMessage);
+ void HasFacetL(const RMessage2& aMessage);
+ void CompleteServerMessagesOnOffL(const RMessage2& aMessage);
+ void ReceiveServiceDescriptionL(const RMessage2& aMessage);
+ void RequestServiceDescriptionL(const RMessage2& aMessage);
+ void StartTransactionL(const RMessage2& aMessage);
+ void TransactionCompletedL(const RMessage2& aMessage);
+ void CancelSessionL(const RMessage2& aMessage);
+ void TransportPropertiesL(const RMessage2& aMessage);
+ void SetTransportPropertiesL(const RMessage2& aMessage);
+
+ void EstablishHostletConnectionL(const RMessage2& aMessage);
+ void AwaitHostletRequestL(const RMessage2& aMessage);
+ void ProvideHostletResponseL(const RMessage2& aMessage);
+// void AcquireHostletRequestHandleL(const RMessage2& aMessage);
+ void MoveChunkL(const RMessage2& aMessage);
+ void MoveFileL(const RMessage2& aMessage);
+ void SendFileHandleL(const RMessage2& aMessage);
+ TInt SendProgressToHostlet(const RMessage2& aMessage);
+ CSenClientMessage* ClientMessageByPendingTxnIdL( TInt aTxnId);
+
+ private:
+
+ // Defines, whether this client session is a service connection (SC) or a hostlet connection (HC)
+ enum TSessionType
+ {
+ ENotInitialized = 0,
+ ERemoteConsumer_SC,
+ ERemoteHostlet_HC
+ };
+
+ // User permission check states
+ enum TestCase
+ {
+ ENotChecked = 0,
+ EAccepted,
+ ENotAccepted
+ };
+
+ // New functions
+
+ /**
+ * SessionValidity() method checks session validity
+ * @return KErrNone if session is ready and
+ * its credentials (if any) are valid
+ *
+ * KErrSenNotInitialized if session is not yet set
+ * (iSession is NULL)
+ *
+ * KErrConnectionInitializing if session's state is new
+ * (iStatus is KSenConnectionStatusNew)
+ *
+ * KSenConnectionStatusExpired if session's state is initializing
+ * (iStatus is KSenConnectionStatusNew)
+ *
+ * KSenConnectionStatusExpired if session's state is expired
+ * (iStatus is KSenConnectionStatusExpired)
+ */
+ TInt SessionValidity();
+
+ TBool CheckValidity(const RMessage2 &aMessage);
+ TBool CheckAllowRegisterL(TInt& aError, const RMessage2& aMessage, const TDesC8& aFrameworkId);
+ TBool CheckAllowUnRegisterL(TInt& aError, const RMessage2& aMessage, const TDesC8& aFrameworkId);
+ TBool CheckAllowUnRegisterL(TInt& aError, const RMessage2& aMessage);
+ /**
+ * ReleaseServiceSession is called in the destructor of this class to
+ * make sure that framework spesific garbage collection for consumed
+ * service session will be executed. It is up to framework implementations
+ * whether they need to cleanup (destroy) this service session which is
+ * being here released.
+ */
+ TInt ReleaseServiceSession();
+
+ /**
+ * Method is called from destructor, to ensure that
+ * all pending async requests get completed.
+ *
+ * Messages will be completed using ESenServRequestCancelled
+ * operation code from TWsfServRqstOpCode enumeration defined
+ * in SenServiceManagerDefines.h
+ *
+ * Internally, this method calls and TRAPS CleanupPendingMessagesL()
+ * @return KErrNone or leave code, if CompletePendingMessagesL() fails.
+ */
+ TInt CompletePendingMessages();
+ /**
+ * Leaving variant of CleanupPendingMessages(), which includes
+ * actual cleanup code.
+ *
+ * This version may be called if *cancel operation* is received
+ * from client to cancel all pending -async- operations.
+ */
+ void CompletePendingMessagesL();
+
+ TInt TransactionIndex(TInt aTxnId);
+ TInt ContextIndex(TInt aCtxId);
+
+ RTransactionArray& Transactions();
+ RTransactionIdArray& TxnIds();
+ RHostletRequestMap& HostletRequestMap();
+
+ TInt CompleteTransaction(TInt aErrorCode, CSenChunk& aChunk);
+ TInt CompleteTransactionByCtxId(TInt aErrorCode, TInt aCtxId);
+ TInt CompleteTransactionByIndex(TInt aErrorCode, TInt aTransactionIndex);
+
+ TInt ReadChunkNameLC( const RMessage2& aMessage, TInt aIpcArgIndex, HBufC*& apChunkName );
+
+ /**
+ * Helper called by SC::ReceiveInitialize and HC:EstablishConnection
+ * Instantiates a new XML service description object, which then will
+ * parse the provided XML (serialized XML service description)
+ * @param aSdAsXml is the input XML descriptor
+ * @param apInitializer provides ref-to-ptr where new initializer
+ * (a XML service description) will be assigned, when method succeeds.
+ * @param apConsumerPolicy is optional argument, which can be utilized
+ * to provide consumer policy descriptor, when such is available.
+ * @return KErrNone if session was initialized or
+ * otherwise some system-wide errorcode.
+ */
+ TInt ParseSessionInitializerL(CSenWSDescription*& apInitializer,
+ const TDesC8& aSdAsXml,
+ const TDesC8* apConsumerPolicy = NULL);
+
+ /**
+ * Helper called by SC::ReceiveInitialize and HC:EstablishConnection
+ * Initializes the service session or returns an error.
+ * @param aInitializer is the SD to be used in session initialization
+ * @param aErrorMsg will contain error description, typically SOAP fault,
+ * in case that (IDP / authentication) service spesific error occured
+ * @return KErrNone if session was initialized or
+ * otherwise some system-wide errorcode.
+ */
+ TInt InitializeServiceSessionL(CSenWSDescription& aInitializer, HBufC8*& aErrorMsg);
+
+ /**
+ * Helper.
+ * Reads a Service Description (buffer) from certain
+ * RMessage2 IPC ARGS indexes
+ * @return KErrNone if buffer was successfully read
+ * or otherwise some system-wide errorcode.
+ */
+ TInt ReadBufferFromRMessageL(const RMessage2& aMessage,
+ TInt aSdLengthIdx,
+ TInt aSdBufIdx,
+ HBufC8*& aSdBuf);
+
+ TInt ListBinaryElementsL(RArray<TXmlEngElement>& aElementArray,
+ TXmlEngElement& aElement);
+
+ TInt ParseMessageL(TInt aTransactionId,
+ const TDesC8& aRequest,
+ CSenSoapEnvelope2& aSoapEnvelope);
+ TInt ParseMessageL(TInt aTransactionId,
+ const TDesC8& aRequest,
+ CSenAtomEntry& aAtomEntry);
+ void AddCredentialL(const RMessage2& aMessage);
+ void CredentialsL(const RMessage2& aMessage);
+ void RemoveCredentialsL(const RMessage2& aMessage);
+
+ void CancelRequestL(const RMessage2& aMessage);
+
+ void DataTrafficDetails(const RMessage2& aMessage);
+ void ConnectionID(const RMessage2& aMessage);
+
+ void ConnectionIdentityProviderL(const RMessage2& aMessage);
+// CSenIdentityProvider* ConnectionIdentityProviderL();
+ // Constantantness on the TInt return type has no meaning so prototype is modified
+ // Overrides TInt MSenRemoteServiceConsumer::ConnectionId()
+ TInt ConnectionId();
+
+ void SearchIdentityProviderL(const RMessage2& aMessage);
+ void IdentityProviders(const RMessage2& aMessage);
+ void ObserveTransfer(const RMessage2& aMessage);
+ void ObserveAuthCallback(const RMessage2& aMessage);
+ TInt CompleteReauthLoop(CSenChunk& aSenChunk);
+ TBool IsTrustedClient(const RMessage2& aMessage);
+ TBool CleanPassword(const RMessage2& aMessage);
+ virtual TSecureId SecureId();
+ virtual TVendorId VendorId();
+
+ void ObserveCoBranding(const RMessage2& aMessage);
+
+ void DeliverProgressToClient( TInt aTxnId, TBool aIsIncoming, TBool aIsSoap, const TDesC8& aSoapOrCid, TInt aProgress );
+
+
+#ifdef __ENABLE_ALR__
+ void MigrateToPrefferedCarrier(TBool aUserChoice) ;
+ void NewCarrierAcceptedL(TBool aUserChoice) ;
+#endif //__ENABLE_ALR__
+
+ private: // Data
+ MSenServiceManager &iManager;
+ MSenRemoteServiceSession* iServiceSession; // not owned
+ //CSenServiceSession *iServiceSession; // not owned
+ TInt iStatus;
+
+ // can be used for routing of messages :
+ // could use the latest UUID for this too..
+ HBufC8* iConsumerID;
+ HBufC8* iPolicyBuf;
+
+ // data to be written to client
+ CBufFlat* iSendBuf;
+
+ CSenWSDescription* iInitializer;
+ TInt iAllowWSDataReg;
+ TInt iAllowWSDataUnReg;
+
+ CSenTransportBase* ipTransport;
+ CSenIdentifier* ipIdentifier;
+ CSenClientMessage* ipHostletAwaitOp;
+
+ RTransactionArray iPendingTransactions; // owned pointers to heap
+ RTransactionIdArray iPendingTxnIds; // owned pointers to heap
+ RHostletRequestMap iHostletRequests; // keys and values are owned
+
+ //RTransactionArray* ipPendingTransactions; // owned pointers to heap
+ //RTransactionIdArray* ipPendingTxnIds; // owned pointers to heap
+ //RHostletRequestMap* ipHostletRequests; // keys and values are owned
+
+ TSessionType iSessionType;
+
+ TInt iAllowShowDialogCount;
+
+ TInt iConnectionID;
+
+ TInt iAuthenticationRetries;
+ TBool iConnectionHasAuthenticationCallback;
+
+ CSenServerContext& iServerContext;
+ TSecureId iSecureId;
+ TVendorId iVendorId;
+ //session to client side server
+ RSenConnectionServerSession iConnectionSession;
+ TSenDataTrafficDetails iDetails;
+
+ TBool iFwNotified;
+
+ // Cache the client secure id to update clients about connection status
+ TSecureId iClientSecureID;
+ TBool iConnectionHasCoBrandingCallback;
+ TBool iReauthResendNeeded;
+#ifdef __ENABLE_ALR__
+ CALRObserver* iALRObserver; // mobilty observer
+ MMobilityProtocolResp* iMobiltyObserver ;
+ TBool iMobilityCallBackForwarded ;
+ TBool iMobilityChoice ;
+#endif //__ENABLE_ALR__
+ };
+
+// CLASS DECLARATION
+NONSHARABLE_CLASS(CSenClientMessage): public CSenChunk
+ {
+ public:
+ // Constructors and destructor
+ static CSenClientMessage* NewL(const RMessage2& aMessage, MSenRemoteServiceConsumer* apConsumer = NULL);
+ static CSenClientMessage* NewLC(const RMessage2& aMessage, MSenRemoteServiceConsumer* apConsumer = NULL);
+
+ static CSenClientMessage* NewL(const RMessage2& aMessage, MSenRemoteServiceConsumer* apConsumer, MSenTransport& aTransport);
+ static CSenClientMessage* NewLC(const RMessage2& aMessage, MSenRemoteServiceConsumer* apConsumer, MSenTransport& aTransport);
+
+ ~CSenClientMessage();
+
+ // New methods:
+ RMessage2& RMessage();
+ MSenRemoteServiceConsumer* Consumer();
+
+ TBool operator==(const CSenClientMessage& a);
+
+ MSenMessageContext& MessageContext();
+
+ RPointerArray<CSenBinaryData>& BinaryDataArray();
+
+ TInt CtxId();
+
+ private:
+ void ConstructL(const RMessage2& aMessage,
+ MSenRemoteServiceConsumer* apConsumer = NULL);
+
+ void ConstructL(const RMessage2& aMessage,
+ MSenRemoteServiceConsumer* apConsumer,
+ MSenTransport& aTransport);
+ CSenClientMessage();
+
+
+ private: // Data
+ CSenMessageContext* ipMessageContext;
+ RMessage2 iMessage;
+ MSenRemoteServiceConsumer* ipConsumer; // not owned
+ RPointerArray<CSenBinaryData> iBinaryDataArray;
+ };
+
+
+NONSHARABLE_CLASS(TFileOutgoingTransferProgress): public TFileOutgoingTransferProgressBase
+ {
+ public:
+ //~TFileOutgoingTransferProgress();
+ TFileOutgoingTransferProgress( TInt aTxnId, TBool aIsIncoming, TInt aProgress, TBool aHasCidPostfix, TInt aCid, TInt aCid2 = -1 );
+ };
+
+
+NONSHARABLE_CLASS( TFourInts )
+ {
+ public:
+ TInt iInt1;
+ TInt iInt2;
+ TInt iInt3;
+ TInt iInt4;
+ };
+
+#endif // SEN_CLIENTSESSION_H
+
+// End of File