diff -r 000000000000 -r 1bce908db942 multimediacommsengine/mmcesrv/mmceserver/inc/mcecssubsession.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/multimediacommsengine/mmcesrv/mmceserver/inc/mcecssubsession.h Tue Feb 02 01:04:58 2010 +0200 @@ -0,0 +1,761 @@ +/* +* Copyright (c) 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: +* +*/ + + + + +#ifndef CMCECSSUBSESSION_H +#define CMCECSSUBSESSION_H + +// INCLUDES +#include +#include +#include +#include "mcesrv.h" +#include "mceclientserver.h" +#include "mcesip.h" +#include "fcsession.h" + + +//FORWARD DECLARATION +class CSIPProfile; +class CMceCsSession; +class CMceCsSessionImplementation; +class CMceCsSubSessionReceiver; +class CMceServerCore; +class TMceIds; +class CMceMsgBase; +class CMceSipManager; +class CMceSipConnection; +class CSIPServerTransaction; +class CSIPClientTransaction; +class CSIPDialogAssocBase; +class CSIPClientTransaction; +class CSIPTransactionBase; +class CSIPDialog; +class CDesC8Array; +class TMceStateTransitionEvent; +class CSIPProfileRegistry; + +#define LAST_REQUEST_IND iPendingReceivedRequests.Count()-1 +#define CURRENT_REQUEST_IND LAST_REQUEST_IND + +#define CURRENT_REQUEST()\ + ( iPendingReceivedRequests.Count() == 0 ?\ + NULL : iPendingReceivedRequests[ LAST_REQUEST_IND ] ) + +#define FIRST_REQUEST()\ + ( iPendingReceivedRequests.Count() == 0 ?\ + NULL : iPendingReceivedRequests[ 0 ] ) + +// CLASS DECLARATION + +/** +* Client-Server sub-session is the base class +* for SIP sessions, which have created to encapsulate +* SIP dialogs. +* This class provides methods to handle CS subsession +* specifig ITC functions and to receive SIP requests and +* responses. +* +* @lib +* @since +*/ +class CMceCsSubSession : public CBase + { + +public: //enums + + enum TType + { + EUnknown = -1, + EInSession, + EOutSession, + EOutSIPSession + }; + +public: // Constructors and destructor + + + /** + * Destructor. + */ + ~CMceCsSubSession(); + +public: // New functions + + + /** + * Returns client type of session. + * The type represents type of dialog used in session. + * @return client type of session + */ + TMceCsSessionType ClientType() const; + + /** + * Returns type of session + * @return type of session + */ + TType Type() const; + + /** + * Returns SIP connection instance + * @return SIP connection + */ + CMceSipConnection& SIPConnection() const; + + /** + * Returns SIP manager instance + * @return SIP manager + */ + CMceSipManager& Manager() const; + + /** + * Returns server core instance + * @return server core + */ + CMceServerCore& ServerCore() const; + + /** + * Returns client + * @return client + */ + CMceCsSessionImplementation& Client() const; + + /** + * Returns floor control session instance + * @return floor control session + */ + const CFCSession* FCSession() const; + + /** + * Executes ITC function called by client + * @param aIds set of ids defining ITC call context + * @param aFunction ITC function to be executed + * @param aMessage message from the client. + */ + void ServiceL( TMceIds& aIds, + TMceItcFunctions aFunction, + const RMessage2& aMessage ); + + /** + * Sends data via callback mechanism to client session + * @param aIds set of ids defining ITC callback context + * @return system wide error + */ + TInt SendToClient( TMceIds& aIds ); + + /** + * Sends data via callback mechanism to client session + * @param aIds set of ids defining ITC callback context + * @param aContext encoded context of message + * @param aContent content of message + */ + void SendToClientL( TMceIds& aIds, HBufC8* aContext, HBufC8* aContent ); + + /** + * Sends error via callback mechanism to client session + * @param aIds set of ids defining ITC callback context + * @param aError the error + * @return system wide error + */ + TInt SendErrorToClient( TMceIds& aIds, TInt aError ); + + + /** + * Resets the initial INVITE. + */ + void ResetInitialInvite(); + + /** + * Controls whether the session should generate automatically event + * at next state change. + * @param aIsEnabled + */ + void SetAutoEvent( TBool aIsEnabled ); + + /** + * Checks whether the session should automatically generate an event + * at next state change. + * @return ETrue if event should be generated, otherwise EFalse + */ + TBool AutoEvent(); + + /** + * Stores event which will be used when automatic event generation + * occurs. Request which is associated with the event may be defined. + * @param aEvent, ownership is not transferred + * @param aAssociatedRequest, ownership is not transferred + */ + void StoreAutoEventL( TMceStateTransitionEvent* aEvent, + CSIPServerTransaction* aAssociatedRequest ); + + /** + * Returns stored automatic event. + * @return event or null + */ + TMceStateTransitionEvent* StoredAutoEvent(); + + /** + * Checks if profile configured. + * + * @return return ETrue if profile configured. + */ + TBool ProfileConfigured() const; + + /** + * Return profile + * + * @return return profile of the connection + */ + CSIPProfile& Profile() const; + + /** + * Set profile + * + * @param aProfile Profile to be used + */ + void SetProfile( CSIPProfile& aProfile ); + + /** + * Check Profile contact secure status + * + * @return True if profile contact with sipsUri or tls + */ + TBool IsProfileContactSecureL(); + + /** + * Return NextHop + * + * @return NextHop TInetAddr + */ + TInetAddr* NextHopL( TInetAddr& aNextHop ); + + void RemoveCompletedRequests( TBool aAll = EFalse ); + +public://SIP adaptation methods + + + /** + * Initializes incoming dialog + * @param aTransaction server transaction representing a request, + * which caused dialog creation + */ + void InitializeIncomingDialogL( CSIPServerTransaction* aTransaction ); + + /** + * Handles SIP request, which has been received inside a dialog + * @param aTransaction server transaction representing a request + * @param aDialog dialog to wich transaction belongs + * @return ETrue, if session handled the request + */ + TBool DialogRequestReceived( CSIPServerTransaction* aTransaction, + CSIPDialog& aDialog ); + + /** + * Handles SIP request, which has been received inside a dialog. + * this will call DialogResponseReceived + * @param aTransaction server transaction representing a request + * @param aDialogAssoc the dialog + */ + void ResponseReceivedWithinDialog( CSIPClientTransaction& aTransaction, + CSIPDialogAssocBase& aDialogAssoc ); + + /** + * Handles SIP response, which has been received inside a dialog + * @param aTransaction client transaction representing a response + */ + void DialogResponseReceived( CSIPClientTransaction& aTransaction ); + + /** + * Handles SIP request, which has been received outside a dialog + * @param aTransaction server transaction representing a request + * @return ETrue, if session handled the request + */ + TBool MessageRequestReceived( CSIPServerTransaction* aTransaction ); + + /** + * Handles SIP response, which has been received outside a dialog + * @param aTransaction client transaction representing a response + */ + void MessageResponseReceived( CSIPClientTransaction& aTransaction ); + + /* + * Handles situation where SIP stack has completed UAC core INVITE + * transaction 64*T1 seconds after the reception of the first + * 2xx response. No more 2xx responses can be received to the issued + * single INVITE. + * @param aTransaction client transaction representing a response + */ + virtual void InviteCompleted( CSIPClientTransaction& aTransaction ); + + /** + * Handles situation where SIP connection state has changed. + * If connection state has changed to EInactive or EUnavailable, + * SIP stack terminates all pending SIP client transactions and no + * errors are reported back to the client about the terminated + * transactions. + * @param aState indicates the current connection state + */ + void ConnectionStateChanged( CSIPConnection::TState aState ); + + /** + * Handles situation where an asynchronous error has occured + * related to a request within an existing dialog. + * + * @param aError error code + * @param aTransaction the transaction + */ + virtual void ErrorOccured( TInt aError, CSIPTransactionBase& aTransaction ); + + /** + * Returns dialog id + * @return dialog id + */ + TUint32 DialogId() const; + + /** + * Returns ETrue, if client has called ready to receive + * @return ETrue, if client has called ready to receive + */ + TBool ClientExists(); + + /** + * Returns SIP dialog (assoc) + * @return SIP dialog or NULL if it does not exist + */ + virtual CSIPDialogAssocBase* Dialog() const; + + /** + * Returns current (pending) request + * @return server transaction representing the request + */ + CSIPServerTransaction& Request() const; + + /** + * Returns initial request which caused session creation. + * @return server transaction representing the initial request + */ + CSIPServerTransaction& InitialRequest() const; + + /** + * Transferes ownership of current (pending) request + * @return server transaction representing the request + */ + CSIPServerTransaction* PopRequest(); + + /** + * Returns current (pending) response + * @return client transaction representing the request + */ + CSIPClientTransaction& Response() const; + + /** + * Transferes ownership of current (pending) response + * @return completed client transaction or NULL if there is no + * pending response or transaction is not completed. + */ + CSIPClientTransaction* PopResponse(); + + /** + * Stores SIP dialog + * @param aType the type of session + * @param aDialog SIP dialog + * @param aDialogId generated dialog id + */ + void SetDialog( TType aType, + CSIPDialogAssocBase* aDialog, + TUint32 aDialogId ); + + /** + * Sets client transaction which is waiting response from peer + * @param aTransaction the pending transaction + */ + void SetPendingTransactionL( CSIPClientTransaction* aTransaction ); + + /** + * Returns ETrue, if session will consume the transaction + * @param aDialog SIP dialog + * @param aTransaction the pending transaction + * @return ETrue, if session will consume the transaction + */ + virtual TBool Consumes( CSIPDialog& aDialog, + CSIPServerTransaction& aTransaction, + TBool& aAssociatesWithDialog ); + + /** + * Returns ETrue, if session will consume the transaction + * @param aTransaction pending or new (incoming) transaction + * @return ETrue, if session will consume the transaction + */ + virtual TBool Consumes( CSIPTransactionBase& aTransaction ); + + /** + * Returns ETrue, if session accepts transaction + * @param aTransaction new (incoming) transaction + * @return ETrue, if session will accepts the transaction + */ + virtual TBool AcceptDialogTransaction( CSIPServerTransaction& aTransaction ); + + /** + * Returns ETrue, if session accepts stand-alone transaction + * @param aTransaction new (incoming) stand-alone transaction + * @return ETrue, if session will accepts the stand-alone transaction + */ + virtual TBool AcceptStandAloneTransaction( CSIPServerTransaction& aTransaction ); + + + /** + * Returns all pending transactions + * @return pending transactions as an array + */ + const RPointerArray& PendingTransactions(); + + + const RPointerArray& PendingReceivedRequests(); + + /** + * Returns pending transaction based on type + * @param aType type of transaction + * @return pending transactions or NULL. Ownership is NOT transfered + */ + CSIPClientTransaction* PendingTransaction( RStringF aType ); + + /** + * Returns the default headers + * @param aMethodInd the methond index in SIP strings + * @return default headers + */ + CDesC8Array& DefaultHeaders( TInt aMethodInd ); + + /** + * Stores client's message content + * @param aClientContent the message content + */ + void StoreClientContent( HBufC8* aClientContent ); + + /** + * Transferes ownership of client message content + * @return client content + */ + HBufC8* PopClientContent(); + + /** + * Removes the pending transaction. + * @param aTransaction the transaction to be removed + * @return ETrue if the transaction was removed. + */ + TBool RemovePendingTrx( CSIPClientTransaction& aTransaction ); + +public://abstract methods + + + /** + * Executes ITC function called by client. + * Default implementation leaves with KErrNotSupported + * @param aIds set of ids defining ITC call context + * @param aFunction ITC function to be executed + * @return aReturnMessage buffer to store message context, + * which will be wrote back to client + */ + virtual HBufC8* DoServiceL( TMceIds& aIds, + TMceItcFunctions aFunction ); + + /** + * Executes ITC function called by client. + * Default implementation leaves with KErrNotSupported + * @param aIds set of ids defining ITC call context + * @param aFunction ITC function to be executed + * @param aMessage message context from client + */ + virtual void DoServiceL( TMceIds& aIds, + TMceItcFunctions aFunction, + const TDesC8& aMessage ); + + /** + * Executes ITC function called by client. + * Default implementation leaves with KErrNotSupported + * @param aIds set of ids defining ITC call context + * @param aFunction ITC function to be executed + * @param aMessage message context from client + */ + virtual void DoServiceL( TMceIds& aIds, + TMceItcFunctions aFunction, + TPtr8& aMessage ); + + + /** + * Executes ITC function called by client. + * Default implementation leaves with KErrNotSupported + * @param aIds set of ids defining ITC call context + * @param aFunction ITC function to be executed + * @param aMessage decoded message context from client + */ + virtual void DoServiceL( TMceIds& aIds, + TMceItcFunctions aFunction, + CMceMsgBase& aMessage ); + + /** + * Returns ETrue, if session can be deleted + * @return ETrue, if session can be deleted + */ + virtual TBool CanDispose() = 0; + + /** + * Initializes incoming dialog + * @param aTransaction server transaction representing a request, + * which caused dialog creation + */ + virtual void DoInitializeIncomingDialogL( + CSIPServerTransaction& aTransaction ) = 0; + + /** + * Handles situation where an asynchronous error has occured + * related to a request within an existing dialog. + * + * @param aError error code + * @param aTransaction the transaction + */ + virtual void DoErrorOccured( TInt aError, + CSIPTransactionBase& aTransaction ) = 0; + + /** + * Called when error has been occured within dialog + * @param aError error code + */ + virtual void ErrorOccured( TInt aError ) = 0; + + /** + * Handles situation where SIP connection state has changed. + * If connection state has changed to EInactive or EUnavailable, + * SIP stack terminates all pending SIP client transactions and no + * errors are reported back to the client about the terminated + * transactions. + * @param aIsActive indicates if the current connection is active + */ + virtual void DoConnectionStateChanged( TBool aIsActive ) = 0; + + + /** + * Handles situation where incoming INVITE was + * canceled with the CANCEL + */ + virtual void Canceled() = 0; + + /** + * Handles situation where session must be forcefully terminated + * @return ETrue, if session can be deleted. If there are + * pending operations, which cannot be done within this call, EFalse + * is returned. + */ + virtual TBool Terminate() = 0; + + /** + * Creates new incoming dialog (association) + * @param aInitialRequest request causing creation + * @return created dialog association + */ + virtual CSIPDialogAssocBase* CreateIncomingDialogL( + CSIPServerTransaction& aInitialRequest ) = 0; + + /** + * Creates new outgoing dialog (association) from existing dialog + * @param aDialogType type of new dialog + * @param aParams parameters for creation + * @param aExistingDialog existing dialog + * @return created dialog association + */ + virtual CSIPDialogAssocBase* CreateOutgoingDialogL( + TMceDialogType aDialogType, + CDesC8Array& aParams, + CSIPDialog& aExistingDialog ) = 0; + + /** + * Creates outgoing dialog (association) based on given parameters + * @param aDialogType type of new dialog + * @param aParams parameters for creation + * @return created dialog association + */ + virtual CSIPDialogAssocBase* CreateOutgoingDialogL( + TMceDialogType aDialogType, + CDesC8Array& aParams ) = 0; + + /** + * Checks if session accepts method of incoming request + * @param aMethod the method + * @return ETrue, if session will accept + */ + virtual TBool AcceptMethod( RStringF aMethod ) = 0; + + + /** + * Called when request has been received. + * Request can be obtained by calling Request() method + * @param aInsideDialog tells whether request was received inside dialog + */ + virtual void RequestReceived( TBool aInsideDialog, CSIPDialog& aDialog ) = 0; + + + /** + * Called when response (2XX) has been received to pending transaction. + * Response can be obtained by calling Response() method + */ + virtual void ResponseReceived() = 0; + + /** + * Called when response (1XX) has been received to pending transaction. + * Response can be obtained by calling Response() method + */ + virtual void ProvisionalResponseReceived() = 0; + + /** + * Called when response (3XX) has been received to pending transaction. + * Response can be obtained by calling Response() method + */ + virtual void RedirectionResponseReceived() = 0; + + /** + * Called when error response (4XX-7XX) has been received + * to pending transaction. + * Response can be obtained by calling Response() method + */ + virtual void ErrorResponseReceived() = 0; + + /** + * Called when stand-alone request has been received. + * Request can be obtained by calling Request() method + */ + virtual void StandAloneRequestReceived() = 0; + + /** + * Called when stand-alone response (any) has been received + * to pending transaction. + * Response can be obtained by calling Response() method + * @param aResponseType response type + */ + virtual void StandAloneResponseReceived( + TMceSipResponseType aResponseType ) = 0; + + + +protected: + + CMceCsSubSession ( TMceCsSessionType aType, + CMceCsSession& aClientSession, + CMceSipConnection& aSIPConnection ); + + CMceCsSubSession ( TMceCsSessionType aType, + CMceCsSession& aClientSession, + CMceSipConnection& aSIPConnection, + CSIPProfile& aProfile ); + + void ConstructL( CMceCsSession& aClientSession ); + TBool IsOrphan(); + + TBool HasInitialInviteTransactionBeenCompleted() const; + +private: + + void DoServiceL( TMceIds& aIds, + TMceItcFunctions aFunction, + const RMessage2& aMessage ); + void ClientReadyToReceiveL( const RMessage2& aMessage ); + void CancelClientReceiveL(); + void ReceiveL( const RMessage2& aMessage ); + + void SetClient( CMceCsSessionImplementation& aClient ); + void SetSessionReceiver( CMceCsSubSessionReceiver* aSessionReceiver ); + void SetResponse( CSIPClientTransaction& aTransaction ); + TBool RemovePendingCompletedTrx( CSIPClientTransaction& aTransaction ); + void RegisterDialogAssoc( CSIPDialogAssocBase& aDialogAssoc ); + + +private:// Owned Data + + //type of session + TType iType; + //client type of session + TMceCsSessionType iClientType; + //receiver + CMceCsSubSessionReceiver* iReceiver; + //dialog id + TUint32 iDialogId; + //current response + CSIPClientTransaction* iResponse; + //first outgoing invite + CSIPClientTransaction* iInitialInvite; + //does client exist + TBool iClientExists; + //client message content + HBufC8* iClientContent; + +protected: // Owned Data + + //SIP dialog + CSIPDialogAssocBase* iDialog; + //pending transactions + RPointerArray iPendingTransactions; + //pending received requests + RPointerArray iPendingReceivedRequests; + + //data for automatic event + // + TBool iAutoEventEnabled; + TMceStateTransitionEvent* iAutoEvent; + CMceMsgBase* iAutoEventMsg; + TMceIds* iAutoEventIds; + CSIPServerTransaction* iAutoEventAssociatedRequest; + TMceStateTransitionEvent* iCurrentlyProcessedAutoEvent; + +protected: // NOT Owned Data + + //current dialog, if forking has been happend + CSIPDialogAssocBase* iCurrentDialog; + + +private:// NOT owned Data + + //client + CMceCsSessionImplementation* iClientSession; + //SIP connection + CMceSipConnection& iSIPConnection; + //MCE server core + CMceServerCore& iServerCore; + + // Sip Profile + CSIPProfile* iProfile; + //CSIPProfileRegistry* iProfileRegistry; + + +protected:// NOT owned Data + + //floor control session + CFCSession* iFCSession; + + + friend class TMceFCActionSet; + friend class CMceSipManager; + + //definitions for unit testing + MCESRV_UT_DEFINITIONS + + + }; + +#endif + +// End of File