diff -r 000000000000 -r 307788aac0a8 realtimenetprots/sipfw/SIP/Transaction/inc/CTransaction.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/realtimenetprots/sipfw/SIP/Transaction/inc/CTransaction.h Tue Feb 02 01:03:15 2010 +0200 @@ -0,0 +1,290 @@ +/* +* 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 : CTransaction.h +* Part of : Transaction +* Version : SIP/5.0 +* +*/ + + + + +/** + @internalComponent +*/ + +#ifndef CTRANSACTION_H +#define CTRANSACTION_H + +// INCLUDES +#include +#include "SipStackServerDefs.h" +#include "SipLogs.h" //for USE_SIP_LOGS +#include "Lwtimer.h" +#include "SendStatus.h" +#include "TSIPTransportParams.h" +#include "TimerValues.h" + +#include "TransactionBase.h" +#include "sip.h" + +// FORWARD DECLARATIONS +class CSIPMessage; +class CTransmitter; +class CUserAgentBase; +class CTransactionState; +class TTimerValues; + +class CTransactionTimer; + +// CLASS DECLARATION +/* + * The base class for all transactions. + */ +class CTransaction : + public CTransactionBase, + public MExpirationHandler, + public MSendStatus + { +public: // Destructor + + ~CTransaction(); + +public: // From CTransactionBase + + void ReceiveL(CSIPRequest* aRequest); + + void ReceiveL(CSIPResponse* aResponse); + + void LeaveOccurred(TInt aReason); + + const TSIPTransportParams& TransportParams() const; + + virtual void IcmpErrorL(const TInetAddr& aAddress, + CSipConnectionMgr::TICMPError aError) = 0; + + void SendRequestL(CSIPRequest& aReq, + const TInetAddr& aAddress, + RStringF aProtocol, + TBool aForceUDP, + const TSIPTransportParams& aParams, + CUri8* aOutboundProxy); + + void SendResponseL(CSIPResponse* aResp, + RStringF aProtocol, + const TSIPTransportParams& aParams); + + TBool ClearSendBuffer(); + + void GetState(CSIPInternalStates::TState& aState); + + void Terminated(); + + virtual void TerminatedL(TInt aReason); + + TBool HasTerminated() const; + + void DetachFromUserAgent(); + + RStringF TransportProtocol() const; + +public: // From MExpirationHandler + + void TimerExpiredL(TTimerId aTimerId, TAny* aTimerParam); + +public: // From MSendStatus + + void SendCompleteL(); + + void SendFailedL(TInt aError); + + void LeaveFromTransmitter(TInt aReason); + +public: // New pure virtual functions + + /** + * Delete the Transaction specific timer. Each separate transaction type + * has different timers. If this transaction has a matching timer, the + * timer will be deleted. + * + * @param aTimer Timer to be deleted + */ + virtual void DeleteTimer(const CTransactionTimer& aTimer) = 0; + + /** + * Sends a SIP message to CTransmitter. + * + * @pre iOutgoingMsg != NULL, iTransmitter isn't active + */ + virtual void SendToTransmitterL() = 0; + +protected: // New pure virtual functions + + /** + * Stops transactions's all timers. + */ + virtual void CancelAllTimers() = 0; + +public: // New functions + + /** + * Tells if the transaction is an INVITE (client/server) transaction or a + * non-INVITE (client/server) transaction. + * + * @return ETrue if INVITE transaction, EFalse otherwise. + */ + virtual TBool IsInviteTransaction() const; + + /** + * Transaction enters a new state + * + * @param aNewState State which CTransaction enters + */ + void ChangeState(const CTransactionState& aNewState); + + /** + * Sets the iTransportProtocol member according to the transport protocol + * in the top Via header of the aMsg. + * + * @param aMsg SIP message + * @return value ETrue: if successful, EFalse: otherwise + */ + TBool UpdateTransportProtocol(CSIPMessage& aMsg); + + /** + * Checks if transaction is using unreliable transport. + * + * @return ETrue if an unreliable transport is used, EFalse otherwise + */ + TBool IsUnreliableTransportUsed() const; + + /** + * Checks if the CTransmitter is currently sending. + * + * @return ETrue: CTransmitter is sending, EFalse: otherwise + */ + TBool IsTransmitterSending() const; + + /** + * Returns a pointer to the current state. + * + * @return Transaction's current state, ownership isn't transferred. + */ + const CTransactionState* State() const; + +protected: + + /** + * Constructor + * + * @pre aTransmitter != NULL, aInitialState != NULL + * + * @param aUserAgent UserAgent owning the new CTransaction being created. + * @param aTransmitter CTransmitter used for sending messages. + * @param aTimers LwTimer subsystem + * @param aInitialState Initial state of the CTransaction object + * @param aTimerValues Values for calculating timer durations + */ + CTransaction(CUserAgentBase& aUserAgent, + CTransmitter& aTransmitter, + MTimerManager& aTimers, + CTransactionState& aInitialState, + TTimerValues& aTimerValues); + + /** + * Obtains the id of the transaction. + * + * @return TransactionId of the transaction + */ + virtual TTransactionId TransactionId() const; + +protected: // Data: + + //UserAgent associated with this transaction. Can be NULL. Not owned. + CUserAgentBase* iUserAgent; + + //CTransmitter used for sending messages, owned by UserAgent. + //In a special case the CInviteClientTransaction can own the CTransmitter. + CTransmitter* iTransmitter; + + //Timer subsystem + MTimerManager& iTimers; + + //Outgoing SIP message. + // + //In case of ClientTransaction, UAC owns the message, except when + //InviteClientTransaction has created the ACK (instead of UAC creating the + //ACK). + // + //In case of ServerTransaction, CTransaction owns the message. Except if + //InviteServerTransaction is sending a 2xx response, when the UAS owns it. + CSIPMessage* iOutgoingMsg; + + RStringF iTransportProtocol; + + //Transport parameters to be used when sending the SIP message + TSIPTransportParams iTransportParams; + + //Copy of the values in CTimerValueRetriever::TTimerValues, at the time the + //transaction was created. Later changes to + //CTimerValueRetriever::TTimerValues won't reflect here. + TTimerValues iTimerValues; + + //ETrue when CTransaction has reached terminated state. + //There is no separate state object for the terminated state. + TBool iTerminated; + +private: + +#if defined(USE_SIP_LOGS) + /** + * Write the transaction state to a log file. + * + * @param aState Transaction state + */ + void WriteStateToLog(const CTransactionState& aState) const; +#endif + +private: // Data + + //Current state of the transaction FSM, not owned. + const CTransactionState* iState; + + void __DbgTestInvariant() const; + + + +#ifdef CPPUNIT_TEST + friend class CTransactionUser_Test; + friend class ClientTransaction_Test; + friend class CServerTransaction_Test; + friend class CInviteServerTa_Test; + friend class CNormalCTa_Trying_Test; + friend class CNormalCTa_Proceeding_Test; + friend class CNormalCTa_Completed_Test; + friend class CNormalSTa_Trying_Test; + friend class CNormalSTa_Proceeding_Test; + friend class CNormalSTa_Completed_Test; + friend class CNormalUAS_GetTxOwner_Test; + friend class CNormalUAS_Start_Test; + friend class CUserAgentClient_Test; + friend class CUserAgentServer_Test; + friend class CInviteCTa_Calling_Test; +#endif + }; + +#endif // end of CTRANSACTION_H + +// End of File