/*
* Copyright (c) 2002-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          : CTransport.h
* Part of       : ConnectionMgr
* Version       : SIP/4.0 
*
*/




/**
 @internalComponent
*/

#ifndef __CTRANSPORT_H__
#define __CTRANSPORT_H__

#include "CTransportBase.h"
#include "SipStackServerDefs.h"
#include "TResponseRoute.h"
#include "CSipConnectionMgr.h"


//SIP version 
_LIT8(KDefaultSipVersion, "SIP/2.0");
_LIT8(KDefaultProtocol, "SIP");
_LIT8(KDefaultVersion, "2.0");

class MTransactionFinder;
class MServerTaFactory;
class MTransportOwner;
class CSIPServerResolver;
class CNetworkInfo;
class COwnerSettingsList;
class CSIPMessage;
class CSIPRequest;
class CSIPResponse;
class CSIPViaHeader;
class CTransportErrorHandler;
class CSIPHostPort;
class CSIPNATTraversalController;
class CSocketContainer;
class MSIPNATBindingObserver;

class CTransport : public CTransportBase
	{
public:

	virtual ~CTransport();

public: // From CTransportBase	   
                     
	void Send( const TSIPTransportParams& aParams,
	           CSIPResponse& aResponse,
			   TTransactionId aId,
			   TRequestStatus &aStatus );
	void Send( const TSIPTransportParams& aParams,
	           CSIPResponse& aResponse,
			   const TInetAddr& aAddr,
			   TRequestStatus &aStatus );
	void Send( const TSIPTransportParams& aParams,
	           CSIPRequest& aRequest, 
	           TBool aForceUDP,
	           const TInetAddr& aAddr,
			   TUint aOrigTransport, 
			   TRequestStatus &aStatus,
			   TBool aPublicAddrResolved );
			  
	TBool HandleL( const TSIPTransportParams& aParams, 
	               CSIPMessage* aMessage, 
	               TTransactionId aId,
	               TBool aIsStrict );
	TBool HandleL( const TSIPTransportParams& aParams, 
	               CSIPMessage* aMessage, 
	               const TInetAddr& aAddr,
	               TUint aLocalPort,
	               TBool aIsStrict );
	               
	virtual TBool HandleMessage( const TSIPTransportParams& aParams,
	                             RStringF aProtocol,
							 	 const TInetAddr& aRemoteAddr,
							 	 TUint aLocalPort,
							 	 TBool aIsStrict ) = 0;
	
	virtual TBool Handle( TUint32 aTransportId );
	
	TBool Match( const TSIPTransportParams& aParams );
	
	void GetAddrFromResponseL( const TSIPTransportParams& aParams,
	                           CSIPMessage& aMessage, 
	                           TInetAddr& aAddr );
	TUint ProtocolType();
	TBool HasRemoteHost( const TSIPTransportParams& aParams,
	                     const TInetAddr& aRemoteHost,
	                     RStringF aProtocol );
	
	virtual void Disconnect( const TInetAddr& /*aRemoteHost*/ ) {}
	virtual void ICMPErrorL( CSipConnectionMgr::TICMPError /*aICMPError*/,
							 const TInetAddr& /*aSourceAddr*/ ) {}
	
	virtual TBool Remove( const TSIPTransportParams& aParams );
	virtual TBool Remove( TUint32 /*aTransportId*/ ) {return ETrue;}
	virtual TBool Remove( MSIPNATBindingObserver& aSIPNATBindingObserver );
	
	virtual TBool Shutdown( TUint32 aTransportId,
	                        MSIPTransportRemovalObserver* aRemovalObserver );
    
    virtual TBool AddUserL( const TSIPTransportParams& /*aParams*/, 
                            TUint /*aReceivePort*/ ) {return EFalse;}
                           
    TBool IsReservedTransport() const;
    
    virtual RSocket* AcquireUdpSocket( 
        MSocketUsagePermissionObserver* aObserver,
        const TInetAddr& aRemoteAddr,
        TBool& aPermissionToUse );
                                        
    virtual void UdpSocketReleased( MSocketUsagePermissionObserver* aObserver,
                                    RSocket& aSocket ); 
    
    virtual TInetAddr* PersistentRemoteAddr( 
                            MSIPNATBindingObserver* aBindingObserver );
    

public:

    static void ConvertToInetAddrL( const TDesC8& aAddrStr, TInetAddr& aAddr );

    static HBufC8* ConvertInetAddrToTextL( const TInetAddr& aAddr );
    
    static CSIPViaHeader* TopViaHeader( CSIPMessage* aMessage );
	
protected:
	
	// Uses cleanupstack for aData inside method, so caller should not 
	// push aData to cleanupstack before calling this method
	void RecvL( HBufC8* aData,
			    const TInetAddr& aRemoteAddr,
			    TBool aCompressed );
	void RecvL( CSIPMessage* aMessage,
			    const TInetAddr& aRemoteAddr,
			    TInt aParserError,
			    TBool aCompressed );
	CTransport( MTransactionFinder& aFinder, 
				MServerTaFactory& aTaFactory,
				MTransportOwner& aTransportOwner,
				CSIPServerResolver& aServerResolver,
				MSigCompController& aSigCompHandler,
				const TSIPTransportParams& aTransportParams,
				CNetworkInfo& aNetworkInfo,
				COwnerSettingsList& aOwnerSettingsList,
				CSIPNATTraversalController& aNATTraversal );
	virtual TBool CancelResponseSend( TTransactionId aId, TBool aCancelAlso2xxResponses );
	virtual void SendToNetL( const TSIPTransportParams& aParams,
	                         const TInetAddr& aAddress, 
	                         CSIPMessage& aMessage, 
	                         TBool aForceUDP,
				             TUint aOrigTransport, 
				             TRequestStatus &aStatus );
	virtual void SendToNetL( const TSIPTransportParams& aParams,
	                         const TInetAddr& aAddress, 
	                         TTransactionId aId, 
				             CSIPMessage& aMessage, 
				             TRequestStatus &aStatus );
	virtual void SendToNetL( const TSIPTransportParams& aParams,
	                         const TInetAddr& aAddress,
							 CSIPMessage& aMessage,
							 TRequestStatus &aStatus );
	virtual TUint SourcePort() = 0;
	virtual TUint Protocol() = 0;
	virtual CTransportErrorHandler& ErrorHandler() = 0;
	virtual CSocketContainer& GetSocketContainerL( const TInetAddr& aRemoteAddr ) = 0;
	virtual void InformSendingStatus( const TInetAddr& aRemoteAddr ) = 0; 
	virtual void SetPersistencyL( const TInetAddr& aRemoteAddr, 
	                              TBool aIsPersistent,
	                              MSIPNATBindingObserver* aBindingObserver );
	TBool IsPersistent() const;
	TBool IsDefault() const;
	void RemoveResponseRoute( const TInetAddr& aRemoteAddr );
	void RemoveResponseRoute( TTransactionId aId );
	HBufC8* LocalAddressL();
	void HandleMixedAddressFamilysL( CSIPMessage& aMessage, 
	                                 const TInetAddr& aRemoteAddr );	

    MSigCompController* SigCompressionHandler() {return iSigCompHandler;}
    
    TBool IsConnectedTransport();
    
    TBool NotifyFlowFailure();
    
protected: // Data
	
	MTransportOwner* iTransportOwner;
	RArray<TResponseRoute> iIDArray;
	
	// Binding observers are not owned
	RPointerArray<MSIPNATBindingObserver> iBindingObservers;
	
	CSIPServerResolver* iServerResolver;
	
    TSIPTransportParams iTransportParams;
    COwnerSettingsList& iSettingsList;  
    
    CSIPNATTraversalController& iNATTraversal;
	
private:

	void HandleClientRequestL( const TSIPTransportParams& aParams,
	                           CSIPRequest& aRequest,
	                           TBool aPublicAddrResolved );
	
	//Obtains address from the top Via-header of aMessage, and places it
	//into aAddr
	void HandleClientResponseL( const TSIPTransportParams& aParams,
	                            CSIPMessage* aMessage, 
	                            TInetAddr& aAddr );
	
	TBool HandleServerResponseL( CSIPMessage* aMessage,
								 const TInetAddr& aAddr );
	TInt HandleServerRequestL( CSIPMessage* aMessage,
							   const TInetAddr& aAddr );
	
	TBool MethodIsSameInCSecAndReqLine( CSIPRequest& aMessage );
	TBool AllMandatoryHeaders( CSIPMessage& aMessage );
	TBool SupportedSIPVersion( CSIPMessage& aMessage );
	TBool ContentTypeOk( CSIPMessage& aMessage );
	TBool OnlyOneViaHeader( CSIPMessage& aMessage );
	TBool CorrectProtocolInVia( CSIPMessage& aMessage );
	TInt CheckAndUpdateContentLengthL( CSIPMessage* aMessage,
									   const TInetAddr& aAddr );
	TBool IsAck( CSIPMessage& aMessage );
	void HandleSigCompAllowDenyL( const TInetAddr& aRemoteAddr, 
                                  TInt aParserError,
                                  TBool aCompressed );
	void UpdateListenersL( const TSIPTransportParams& aParams, 
	                       CSIPMessage* aMessage );
	void SetReceivedIfNeededL( CSIPViaHeader* aViaHeader, TInetAddr aAddr );

	void RouteL( CSIPMessage* aMessage, const TInetAddr& aRemoteAddr );
	
	void SendErrorResponseL( TUint aResponseCode, 
	                         TInt aStrIndex, 
	                         CSIPMessage& aMessage,
	                         const TInetAddr& aAddr );
	
	void UpdateContactHeadersL( const TSIPTransportParams& aParams,
	                            CSIPMessage* aMessage,
	                            TBool aUpdatePorts );         
	                            
	void ChangeHostAddressFamilyIfNeededL( CSIPHostPort& aHostPort, 
                                           const TInetAddr& aRemoteAddr );
	
	TBool HandleClientResponseRPortL( CSIPViaHeader& aViaHeader, TInetAddr& aAddr );
	
	void HandleResponseNATTraversalL( CSIPResponse& aResponse, 
	                                  const TInetAddr& aRemoteAddr,
	                                  MSIPNATBindingObserver* aBindingObserver );
	 
	TBool HasValue( CSIPViaHeader& aViaHeader, RStringF& aParam );
	
	void AddBindingObserverL( MSIPNATBindingObserver& aBindingObserver );
	
	TBool RemoveBindingObserver( MSIPNATBindingObserver& aBindingObserver );
	
private: // Data

	MTransactionFinder* iTaFinder;
	MServerTaFactory* iTaFactory;
	MSigCompController* iSigCompHandler;
	
	TTimerId iTimerId;
	TUint iTime;

	//For constructing P-Access-Network-Info header
	CNetworkInfo& iNetworkInfo;	
private: //For testing purposes
#ifdef CPPUNIT_TEST	
	friend class CValidTest;
	friend class CSipConnectionTest;
	friend class CTransportTlsTest;
#endif
	};
#endif // end of __CTRANSPORT_H__

// End of File