diff -r 000000000000 -r 307788aac0a8 realtimenetprots/sipfw/SIP/Transaction/inc/Transmitter.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/realtimenetprots/sipfw/SIP/Transaction/inc/Transmitter.h Tue Feb 02 01:03:15 2010 +0200 @@ -0,0 +1,193 @@ +/* +* 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 : Transmitter.h +* Part of : Transaction +* Version : SIP/5.0 +* +*/ + + + + +/** + @internalComponent +*/ + +#ifndef TRANSMITTER_H +#define TRANSMITTER_H + +// INCLUDES +#include +#include + +#include "SipStackServerDefs.h" + +// FORWARD DECLARATIONS +class CUri8; +class MSipConnectionMgr; +class CSIPRequest; +class CSIPResponse; +class TSIPTransportParams; +class MSendStatus; + +// CLASS DECLARATION + +/* + * CTransmitter handles sending data to ConnectionMgr. + * + * Every CUserAgent owns one CTransmitter instance, and the associated + * CTransaction uses the same CTransmitter object for sending. + * + * In case of a 2xx response to an INVITE, the InviteUAS/InviteUAC also use the + * CTransmitter. CUserAgent can use the same instance as the CTransaction was + * using since they are never both sending at the same time. + */ +class CTransmitter : public CActive + { +public: // Constructors and destructor + + /** + * Creates an instance of CTransmitter. + * + * @param aConnectionMgr ConnectionMgr to be used for sending. + * @return value New CTransmitter object, ownership is transferred. + */ + static CTransmitter* NewL(MSipConnectionMgr& aConnectionMgr); + + ~CTransmitter(); + +public: // From CActive: + + void DoCancel(); + + void RunL(); + + TInt RunError(TInt aError); + +public: // New functions + + /** + * Send a SIP request message to network. + * + * @pre aObserver != NULL + * + * @param aReq SIP request to be sent. Ownership is not transferred. + * @param aAddress Address where the message will be sent + * @param aForceUDP ETrue if transport protocol must remain UDP + * @param aParams Transport parameters that are given to ConnectionMgr when + * sending the SIP request. + * @param aOutboundProxy outbound proxy, NULL pointer if not used. + * The ownership is not transferred. + * @param aObserver Callback which CTransmitter will use after it has + * served the sending of the message. Since CUserAgent and CTransaction + * share a common CTransmitter object, the MSendStatus callback is passed + * on every SendRequestL/SendResponseL call, so CTransmitter calls the + * correct object. Ownership isn't transferred. + */ + void SendRequestL(CSIPRequest& aReq, + const TInetAddr& aAddress, + TBool aForceUDP, + const TSIPTransportParams& aParams, + const CUri8* aOutboundProxy, + MSendStatus* aObserver); + + /** + * Send a SIP response message to network. + * + * @pre aObserver != NULL + * + * @param aResp SIP response to be sent. Ownership is not transferred. + * @param aParams Transport parameters that are given to ConnectionMgr when + * sending the SIP response. + * @param aObserver Callback which CTransmitter will use after it has + * served the sending of the message. Since CUserAgent and CTransaction + * share a common CTransmitter object, the MSendStatus callback is passed + * on every SendRequestL/SendResponseL call, so CTransmitter calls the + * correct object. Ownership isn't transferred. + * @param aTransactionId TransactionId of transaction that sends the + * response. + */ + void SendResponseL(CSIPResponse& aResp, + const TSIPTransportParams& aParams, + MSendStatus* aObserver, + TTransactionId aTransactionId); + + /** + * The user of CTransmitter indicates it doesn't want any events to the + * callback it has provided earlier in SendRequestL or SendResponseL. + * + * E.g. a CTransaction is ending, but it doesn't use CTransmitter::Cancel() + * to make sure CTransmitter won't use callback anymore, since in case some + * other CTransaction instance or CUserAgent is currently sending, their + * sending would get canceled. + * + * @param aObserver Callback which CTransmitter shouldn't use anymore. + * In case CTransmitter is already serving another user (meaning its + * iObserver != aObserver), nothing is done. Ownership isn't transferred. + * @return value - + */ + void DetachCallback(MSendStatus* aObserver); + + /** + * Tells ConnectionMgr to clear any references to SIP responses associated + * with the aTransactionId. + * + * @param aTransactionId Identifies the transaction + * @param aAlso2xx Indicates if 2xx responses are also included + */ + void CancelSendResponses(TTransactionId aTransactionId, + TBool aAlso2xx) const; + + /** + * Disconnect TCP connection to the remote host + * + * @param aRemoteAddr Address of the remote host + * @param aParams Transport parameters + */ + void TcpDisconnect(TInetAddr& aRemoteAddr, + const TSIPTransportParams& aParams) const; + +private: // New functions, for internal use + + CTransmitter(MSipConnectionMgr& aConnectionMgr); + + /** + * Converts certain error codes into CSIP::ETransportFailure, to indicate + * a transport layer error has occurred but UAC might have a chance to + * try again. + * + * @param aError Error code received from ConnectionMgr + * @return Error code which will be used instead of the aError + */ + TInt MapErrorCode(TInt aError) const; + +private: // Data + + //Callback to the object of the most recent SendRequestL/SendResponseL + //call. Not owned. + MSendStatus* iObserver; + + //Transport layer used for sending + MSipConnectionMgr& iConnectionMgr; + +#ifdef CPPUNIT_TEST + friend class CTransmitter_Test; + friend class CInviteCTa_Completed_Test; +#endif + }; + +#endif // end of TRANSMITTER_H + +// End of File