diff -r 000000000000 -r 307788aac0a8 realtimenetprots/sipfw/SIP/TransactionUser/inc/CTransactionUser.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/realtimenetprots/sipfw/SIP/TransactionUser/inc/CTransactionUser.h Tue Feb 02 01:03:15 2010 +0200 @@ -0,0 +1,432 @@ +/* +* Copyright (c) 2006-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: +* Name : CTransactionUser.h +* Part of : TransactionUser +* Version : SIP/5.0 +* +*/ + + + + +/** + @internalComponent +*/ + +#ifndef CTRANSACTIONUSER_H +#define CTRANSACTIONUSER_H + +// INCLUDES +#include +#include +#include +#include + +#include "sipinternalstates.h" + +#include "MTransactionUser.h" +#include "MServerTaFactory.h" +#include "MConnectionStateObserver.h" + +// FORWARD DECLARATIONS +class MSIPRequestRouter; +class MTimerManager; +class CSipConnectionMgr; +class MSipDialogs; +class MSipRegistrations; +class MSipRegistrationContact; +class CDeleteMgr; +class CSIPSec; +class CTransactionMgr; + +class MTransactionOwner; +class CTransactionStore; +class CUserAgent; +class CCancelUAC; +class CUserAgentCreateParams; +class CTimerValueRetriever; +class CSIPMessageUtility; +class CInviteUAC_Start; +class CInviteUAC_ResolveAddress; +class CInviteUAC_WaitResponse; +class CInviteUAC_WaitAckFromApp; +class CInviteUAC_ResolveAckAddress; +class CInviteUAC_SendingAck; +class CInviteUAC_WaitTransactionToEnd; +class CInviteUAC_WaitAuthentication; +class CNormalUAC_Start; +class CNormalUAC_ResolveAddress; +class CNormalUAC_WaitResponse; +class CNormalUAC_WaitAuthentication; +class CInviteUAS_Start; +class CInviteUAS_GetTxOwner; +class CInviteUAS_WaitRespFromApp; +class CInviteUAS_Accepted; +class CInviteUAS_Rejected; +class CNormalUAS_Start; +class CNormalUAS_GetTxOwner; +class CNormalUAS_WaitRespFromApp; +class CNormalUAS_FinalRespSent; +class CCancelUAC_Start; +class CCancelUAC_ResolveAddress; +class CCancelUAC_WaitResponse; +class CCancelUAC_WaitAuthentication; +class CCancelUAS_Start; +class CCancelUAS_FinalRespSent; + +// CLASS DECLARATION + +/** + * CTransactionUser class is the interface for using TransactionUser subsystem. + */ +class CTransactionUser : + public CBase, + public MTransactionUser, + public MServerTaFactory, + public MConnectionStateObserver + { +public: // Constructors and destructor + + /** + * Creates TransactionUser subsystem. + * + * @pre aRouter != NULL, aTimers != NULL + * + * @param aRouter Router interface. Ownership isn't transferred. + * @param aTimers Lwtimer interface. Ownership isn't transferred. + * @param aObserver Callback to pass connection state information + * @return value New CTransactionUser object, ownership is transferred. + */ + static CTransactionUser* NewL(MSIPRequestRouter* aRouter, + MTimerManager* aTimers, + MConnectionStateObserver& aObserver); + + /** + * Destructor. All existing transactions are immediately stopped. + */ + ~CTransactionUser(); + +public : // From MTransactionUser + + void SendL(TTransactionId& aTransactionId, + TRegistrationId aRegistrationId, + CSIPRequest* aRequest, + MTransactionOwner* aObserver, + CURIContainer& aRemoteTarget, + const TSIPTransportParams& aTransportParams, + TBool aDeleteRequest); + + MTransactionHeaders* SendAndGetHeadersL( + TTransactionId& aTransactionId, + TRegistrationId aRegistrationId, + CSIPRequest* aRequest, + MTransactionOwner* aObserver, + CURIContainer& aRemoteTarget, + const TSIPTransportParams& aTransportParams, + TBool aDeleteRequest); + + void SendL(TTransactionId aTransactionId, + CSIPResponse* aResponse, + const TSIPTransportParams& aTransportParams) const; + + void SendL(TTransactionId aTransactionId, + CSIPResponse* aResponse, + MTransactionOwner* aObserver, + const TSIPTransportParams& aTransportParams) const; + + void SendCancelL(TTransactionId aInviteTaId, + TTransactionId& aCancelTaId, + MTransactionOwner* aObserver); + + TInt ClearTransactionOwner(TTransactionId aTransactionId) const; + + TInt ClearTransactionOwner(MTransactionOwner* aObserver) const; + + + void GetLocalAddress(TUint32 aIapId, TInetAddr& aAddr) const; + + void FreeResources(MSIPNATBindingObserver& aSIPNATBindingObserver ); + + MTransactionHeaders* + TransactionHeadersL(TTransactionId aTransactionId) const; + + void MakeTagL(TDes8& aTag) const; + + virtual TInt NextHopIP( + const TTransactionId& aTransactionId, TInetAddr& aAddr); + +public: // From MServerTaFactory + + virtual MReceiverObserver* + NewTransactionL(CSIPRequest& aRequest, + const TSIPTransportParams& aParams, + TTransactionId& aTransactionId); + +public: // From MConnectionStateObserver + + void ConnectionStateChangedL(TUint32 aIapId, CSIPConnection::TState aState); + +public: // New functions + + /** + * Returns a reference to SIPSec. + * + * @returns SIPSec + */ + CSIPSec& SIPSec(); + + /** + * Returns a reference to SIP ConnnectionMgr. + * + * @returns ConnectionMgr + */ + CSipConnectionMgr& SipConnectionMgr(); + + /** + * Gives the address of SIP Dialogs subsystem to TransactionUser subsystem. + * + * @pre aSipDialogs != NULL + * + * @param aSipDialogs IN: address of SIP Dialogs subsystem. Ownership isn't + * transferred + */ + void SetDialogs(MSipDialogs* aSipDialogs); + + /** + * Gives the interfaces of SIP Registrations subsystem for TransactionUser + * subsystem. + * + * @pre aSipRegistrations != NULL, aRegistrationContact != NULL + * + * @param aSipRegistrations IN: interface for checking AORs. Ownership + * isn't transferred + * @param aRegistrationContact IN: interface for obtaining Contact header. + * Ownership isn't transferred + */ + void SetRegistrations(MSipRegistrations* aSipRegistrations, + MSipRegistrationContact* aRegistrationContact); + + /** + * Obtains the state of the specified transaction. + * + * @param aTransactionId TransactionId of the transaction whose state is + * requested. + * @param aState OUT: Transaction state + * @leave KErrNotFound if no such transaction exists. + */ + void GetStateL(TTransactionId aTransactionId, + CSIPInternalStates::TState& aState) const; + +private: // Constructors, for internal use + + CTransactionUser(MSIPRequestRouter* aRouter, + MTimerManager* aTimers, + MConnectionStateObserver& aStateObserver); + + void ConstructL(); + +private: // New functions, for internal use + + /** + * Builds UA state machines by creating the state objects and linking them + * together. + */ + void ConstructUaStateMachinesL(); + + /** + * Generate a new value to be used as a CSeq sequence number. + * + * @return value Sequence number + */ + TUint32 NewCSeqValue(); + + /** + * Fills the common parameters for creating a new UA. + * + * @param aTransactionId Transaction id for the new UserAgent + * @param aObserver Callback to the upper layer. Can be NULL. Ownership + * isn't transferred. + * @param aDeleteOutgoingMsg If ETrue, UserAgent deletes iOutgoingMsg when + * UserAgent itself is deleted. + * @param aParams IN: Transport parameters to be used when handing a SIP + * message to SIP Connection Mgr. + * @return Object containing the common parameters for all UserAgent types. + * Ownership is transferred. + */ + CUserAgentCreateParams* FillUserAgentParamsLC(TTransactionId aTransactionId, + MTransactionOwner* aObserver, + TBool aDeleteOutgoingMsg, + const TSIPTransportParams& aParams) const; + + /** + * Creates an UAS for handling a SIP request received from network. + * + * @param aTaId TransactionId for the UAS + * @param aMethod Method of the SIP request + * @param aParams IN: Transport parameters to be used when handing a SIP + * message to SIP Connection Mgr. + * @return value New UA object, ownership is transferred + */ + CUserAgent* CreateUasL(TTransactionId aTaId, + RStringF aMethod, + const TSIPTransportParams& aParams) const; + + /** + * Creates an UAC for sending a new SIP request to network. + * + * @param aTaId TransactionId for the UAC + * @param aMethod Method of the SIP request + * @param aObserver Callback where UAC sends the response and other events + * @param aDeleteRequest If ETrue, UAC will delete the SIP request when UAC + * ends. If EFalse, UAC doesn't delete the SIP request. In either case, + * UAC can modify the request. + * @param aCSeqNumber CSeq sequence number for UAC to use, unless filled by + * upper layer. + * @param aParams IN: Transport parameters to be used when handing a SIP + * request to SIP Connection Mgr. + * @return value New UA object, ownership is transferred + */ + CUserAgent* CreateUacL(TTransactionId aTaId, + RStringF aMethod, + MTransactionOwner& aObserver, + TBool aDeleteRequest, + TUint32 aCSeqNumber, + const TSIPTransportParams& aParams) const; + + /** + * Creates UAC for sending CANCEL request to network. + * + * @param aTaId TransactionId for the UAC + * @param aObserver Callback where UAC sends the response an other events + * @param aCSeqNumber CSeq sequence number for UAC to use, unless filled by + * upper layer. + * @param aParams IN: Transport parameters to be used when handing a SIP + * request to SIP Connection Mgr. + * @return value New CancelUAC object, ownership is transferred + */ + CCancelUAC* + CreateCancelUacL(TTransactionId aTaId, + MTransactionOwner& aObserver, + TUint32 aCSeqNumber, + const TSIPTransportParams& aParams) const; + + /** + * Returns the Timer Retriever Mapped bearer type + * @param aIapID IapID for which bearer type needs to be determined + */ + TInt TimerRetrieverMappedBearerTypeL(TUint32 aIapID) const; + +private: // Data + + //Determines where incoming requests are routed. Not owned. + MSIPRequestRouter* iRouter; + + //Timer services. Not owned. + MTimerManager* iTimers; + + //Connection state changes are reported to this callback + MConnectionStateObserver& iStateObserver; + + //Dialog subsystem. Not owned. + MSipDialogs* iDialogs; + + //Registration subsystem. Not owned. + MSipRegistrations* iRegistrations; + + //Used for filling in information to Contact-headers of outgoing SIP + //messages. Not owned. + MSipRegistrationContact* iRegistrationContact; + + //Transport layer. Owned. + CSipConnectionMgr* iConnectionMgr; + + //Contains information of all existing transactions and UAs. Owned. + CTransactionStore* iTransactionStore; + + //Used for freeing memory asynchronously. Owned. + CDeleteMgr* iDeleteMgr; + + + //There is one instance of each UA state object. They're all owned. + + //Invite user agent client states + CInviteUAC_Start* iInviteUAC_Start; + CInviteUAC_ResolveAddress* iInviteUAC_ResolveAddress; + CInviteUAC_WaitResponse* iInviteUAC_WaitResponse; + CInviteUAC_WaitAckFromApp* iInviteUAC_WaitAckFromApp; + CInviteUAC_ResolveAckAddress* iInviteUAC_ResolveAckAddress; + CInviteUAC_SendingAck* iInviteUAC_SendingAck; + CInviteUAC_WaitTransactionToEnd* iInviteUAC_WaitTransactionToEnd; + CInviteUAC_WaitAuthentication* iInviteUAC_WaitAuthentication; + + //Non-Invite user agent client states + CNormalUAC_Start* iNormalUAC_Start; + CNormalUAC_ResolveAddress* iNormalUAC_ResolveAddress; + CNormalUAC_WaitResponse* iNormalUAC_WaitResponse; + CNormalUAC_WaitAuthentication* iNormalUAC_WaitAuthentication; + + //Cancel user agent client states + CCancelUAC_Start* iCancelUAC_Start; + CCancelUAC_ResolveAddress* iCancelUAC_ResolveAddress; + CCancelUAC_WaitResponse* iCancelUAC_WaitResponse; + CCancelUAC_WaitAuthentication* iCancelUAC_WaitAuthentication; + + //Invite user agent server states + CInviteUAS_Start* iInviteUAS_Start; + CInviteUAS_GetTxOwner* iInviteUAS_GetTxOwner; + CInviteUAS_WaitRespFromApp* iInviteUAS_WaitRespFromApp; + CInviteUAS_Accepted* iInviteUAS_Accepted; + CInviteUAS_Rejected* iInviteUAS_Rejected; + + //Non-Invite user agent server states + CNormalUAS_Start* iNormalUAS_Start; + CNormalUAS_GetTxOwner* iNormalUAS_GetTxOwner; + CNormalUAS_WaitRespFromApp* iNormalUAS_WaitRespFromApp; + CNormalUAS_FinalRespSent* iNormalUAS_FinalRespSent; + + //Cancel user agent server states + CCancelUAS_Start* iCancelUAS_Start; + CCancelUAS_FinalRespSent* iCancelUAS_FinalRespSent; + + + //Counter used to produce CSeq numbers for outgoing requests when the upper + //layers have not filled the CSeq number. + TUint32 iCSeqCounter; + + //Transaction layer. Owned. + CTransactionMgr* iTransactionMgr; + + //Timer values, owned. + CTimerValueRetriever* iTimerValueRetriever; + + //SIP message manipulating utilities. Owned. + CSIPMessageUtility* iSIPMsgUtility; + + //SIP Security subsystem. Owned. + CSIPSec* iSIPSec; + +private: // For testing purposes + +#ifdef CPPUNIT_TEST + friend class CTransactionUser_Test; +#endif + + void __DbgTestInvariant() const; + + }; + +#endif // end of CTRANSACTIONUSER_H + +// End of File