// 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          : CTransportUdp.cpp

// Part of       : ConnectionMgr

// Version       : SIP/4.0 

//

#include "CTransportUdp.h"

#include "CSipConnection.h"

#include "CErrorHandler.h"

#include "CReceiver.h"

#include "CSenderUdp.h"

#include "CSIPServerResolver.h"

#include "sipviaheader.h"

#include "siphostport.h"

#include "sipmessage.h"

#include "sipresponse.h"

#include "Lwtimer.h"

#include "SipLogs.h"

#include "CResHandler.h"

#include "utf.h"

#include "CommonConsts.h"

#include "sipstrings.h"

#include "sipstrconsts.h"

#include "siperr.h"

#include "NetworkInfo.h"

#include "COwnerSettingsList.h"

#include "CSocketContainer.h"

#include "MSocketUsagePermissionObserver.h"

#include <sipnattraversalcontroller.h>

const TInt KTransportUsersGranularity = 2;

// -----------------------------------------------------------------------------

// CTransportUdp::NewL

// -----------------------------------------------------------------------------

//

CTransportUdp* CTransportUdp::NewL( 

    RSocketServ& aServer, 

    TUint aPort,

    MTransactionFinder& aFinder, 

    MServerTaFactory& aTaFactory,

    MTransportOwner& aTransportOwner,

    MTimerManager& aTimerManager,

    CSIPServerResolver& aServerResolver,

    RConnection& aConnection,

    MSigCompController& aSigCompHandler,

    TUint aICMPErrorWaitTime,

    CNetworkInfo& aNetworkInfo,

    COwnerSettingsList& aSettingsList,

    const TSIPTransportParams& aTransportParams,

    CSIPNATTraversalController& aNATTraversal,

    TBool aOnlyForReceiving )

	{

	CTransportUdp* self = NewLC( aServer, aPort, aFinder, aTaFactory, 

						     	 aTransportOwner, aTimerManager, 

						     	 aServerResolver, aConnection, aSigCompHandler,

						    	 aICMPErrorWaitTime, aNetworkInfo,

						    	 aSettingsList, aTransportParams,

						    	 aNATTraversal, aOnlyForReceiving );

	CleanupStack::Pop( self );

	return self;

	}

// -----------------------------------------------------------------------------

// CTransportUdp::NewLC

// -----------------------------------------------------------------------------

//

CTransportUdp* CTransportUdp::NewLC( 

    RSocketServ& aServer, 

    TUint aPort,

    MTransactionFinder& aFinder, 

    MServerTaFactory& aTaFactory,

    MTransportOwner& aTransportOwner,

    MTimerManager& aTimerManager,

    CSIPServerResolver& aServerResolver,

    RConnection& aConnection,

    MSigCompController& aSigCompHandler,

    TUint aICMPErrorWaitTime,

    CNetworkInfo& aNetworkInfo,

    COwnerSettingsList& aSettingsList,

    const TSIPTransportParams& aTransportParams,

    CSIPNATTraversalController& aNATTraversal,

    TBool aOnlyForReceiving )

	{

	CTransportUdp* self = new ( ELeave ) CTransportUdp( aServer, 

	                                                    aPort,

	                                                    aFinder, 

	                                                    aTaFactory, 

													    aTransportOwner,

													    aTimerManager,

													    aServerResolver,

													    aConnection,

													    aSigCompHandler,

													    aICMPErrorWaitTime,

													    aNetworkInfo,

													    aSettingsList,

													    aTransportParams,

													    aNATTraversal,

													    aOnlyForReceiving );

	CleanupStack::PushL( self );

	self->ConstructL();

	return self;

	}

// -----------------------------------------------------------------------------

// CTransportUdp::CTransportUdp

// -----------------------------------------------------------------------------

//

CTransportUdp::CTransportUdp( 

    RSocketServ& aServer,

    TUint aPort, 

    MTransactionFinder& aFinder, 

    MServerTaFactory& aTaFactory,

    MTransportOwner& aTransportOwner,

    MTimerManager& aTimerManager,

    CSIPServerResolver& aServerResolver,

    RConnection& aConnection,

    MSigCompController& aSigCompHandler,

    TUint aICMPErrorWaitTime,

    CNetworkInfo& aNetworkInfo,

    COwnerSettingsList& aSettingsList,

    const TSIPTransportParams& aTransportParams,

    CSIPNATTraversalController& aNATTraversal,

    TBool aOnlyForReceiving ) 

        :

	CTransport( aFinder, aTaFactory, aTransportOwner, aServerResolver,

	            aSigCompHandler, aTransportParams, aNetworkInfo, 

	            aSettingsList, aNATTraversal ),

	iSocketServ( &aServer ),

	iConnection( &aConnection ),

	iSourcePort( aPort ),

	iTimerManager( aTimerManager ),

	iList( CResponseHandler::iOffset ),

	iListIter( iList ),

	iICMPErrorWaitTime( aICMPErrorWaitTime ),

	iTransportUsers( KTransportUsersGranularity ),

	iOnlyForReceiving( aOnlyForReceiving ),

	iIsSending( EFalse )

	{		

	}

// -----------------------------------------------------------------------------

// CTransportUdp::ConstructL

// -----------------------------------------------------------------------------

//

void CTransportUdp::ConstructL()

	{

	iErrorHandler =	CTransportErrorHandler::NewL( *this );

    RefreshSocketContainerL( KAfInet );

    RefreshSocketContainerL( KAfInet6 );	                                   	

	iSender = CSenderUdp::NewL( *this, iSettingsList );

	iTransportUsers.AppendL( iTransportParams.TransportId() );

	}

// -----------------------------------------------------------------------------

// CTransportUdp::~CTransportUdp

// -----------------------------------------------------------------------------

//

CTransportUdp::~CTransportUdp()

	{

    if ( iSocketUsagePermissionObserver )

	    {

	    iSocketUsagePermissionObserver->UsagePermissionChanged( iIPv4Socket, EFalse );

	    iSocketUsagePermissionObserver->UsagePermissionChanged( iIPv6Socket, EFalse );

	    }

	iNATTraversal.SocketIdle( EFalse, iIPv4Socket );

	iNATTraversal.SocketIdle( EFalse, iIPv6Socket );

	CResponseHandler* listItem;

	iListIter.SetToFirst();

	while ( ( listItem = iListIter++ ) != 0 )

		{

		iList.Remove( *listItem );

		delete listItem;

		}

	delete iErrorHandler;

	delete iIPv4Receiver;

	delete iIPv6Receiver;

	delete iSender;

	delete iIPv4SocketContainer;

	delete iIPv6SocketContainer;

	iNATTraversal.SocketIdle( EFalse, iIPv4Socket );

	iIPv4Socket.Close();

	iNATTraversal.SocketIdle( EFalse, iIPv6Socket );

	iIPv6Socket.Close();

	iTransportUsers.Close();

	}

// -----------------------------------------------------------------------------

// CTransportUdp::Handle

// -----------------------------------------------------------------------------

//

TBool CTransportUdp::Handle( TUint32 aTransportId )

    {

    // Only interested about "protected" transports

    return ( ( aTransportId > 0 ) && 

             ( iTransportUsers.Find( aTransportId ) != KErrNotFound ) );

    }

// -----------------------------------------------------------------------------

// CTransportUdp::HandleMessage

// -----------------------------------------------------------------------------

//

TBool CTransportUdp::HandleMessage( const TSIPTransportParams& aParams,

                                    RStringF aProtocol,

								    const TInetAddr& /*aRemoteAddr*/,

								    TUint aLocalPort,

								    TBool aIsStrict )

    {

    // If not strict comparison, receiveonly mode has no significance

	return ( aProtocol == SIPStrings::StringF( SipStrConsts::EUDP ) && 

	         Match( aParams ) &&

	         ( aLocalPort == 0 || iSourcePort == aLocalPort ) &&

	         ( !aIsStrict || !iOnlyForReceiving ) );

	}

// -----------------------------------------------------------------------------

// CTransportUdp::ResetSocketL

// -----------------------------------------------------------------------------

//

void CTransportUdp::ResetSocketL()

	{

	iIPv4Socket.Close();

	CSocketContainer* tmp = CreateSocketContainerL( KAfInet, iIPv4Socket );

	delete iIPv4SocketContainer;

	iIPv4SocketContainer = tmp;

	iIPv6Socket.Close();

	tmp = CreateSocketContainerL( KAfInet6, iIPv6Socket );

	delete iIPv6SocketContainer;

	iIPv6SocketContainer = tmp;	

	}

// -----------------------------------------------------------------------------

// CTransportUdp::StopL

// -----------------------------------------------------------------------------

//

TBool CTransportUdp::StopL()

	{

	if ( iIPv4Receiver )

	    {

	    iIPv4Receiver->Cancel();

	    }	

	if ( iIPv6Receiver )

	    {

	    iIPv6Receiver->Cancel();

	    }

	iSender->Cancel();

	// If there's binding observers, notify that old socket

	// cannot be used anymore

	return NotifyFlowFailure();

	}

// -----------------------------------------------------------------------------

// CTransportUdp::ContinueL

// -----------------------------------------------------------------------------

//

void CTransportUdp::ContinueL()

	{

	WaitL();

	iSender->SendNextL();

	}

// -----------------------------------------------------------------------------

// CTransportUdp::SourcePort

// -----------------------------------------------------------------------------

//

TUint CTransportUdp::SourcePort()

	{

	return iSourcePort;

	}

// -----------------------------------------------------------------------------

// CTransportUdp::WaitL

// -----------------------------------------------------------------------------

//

void CTransportUdp::WaitL()

	{

	if ( iIPv4Receiver )

	    {

	    iIPv4Receiver->Listen();

	    }

	if ( iIPv6Receiver )

	    {

	    iIPv6Receiver->Listen();

	    }

	}

// -----------------------------------------------------------------------------

// CTransportUdp::SendToNetL

// -----------------------------------------------------------------------------

//

void CTransportUdp::SendToNetL( const TSIPTransportParams& aParams,

                                const TInetAddr& aAddress, 

							    CSIPMessage& aMessage,

							    TBool aForceUDP,

							    TUint aOrigTransport,

							    TRequestStatus &aStatus )

	{

	RefreshSocketContainerL( CSender::IpAddrType( aAddress ) );

	HandleMixedAddressFamilysL( aMessage, aAddress );

	iSender->SendL(

	    aParams, 

	    aMessage, 

	    aAddress, 

	    aOrigTransport, 

	    aStatus, 

	    EFalse, 

	    aForceUDP );

	}

// -----------------------------------------------------------------------------

// CTransportUdp::SendToNetL

// -----------------------------------------------------------------------------

//

void CTransportUdp::SendToNetL( const TSIPTransportParams& aParams,

                                const TInetAddr& aAddress,

							    CSIPMessage& aMessage,

							    TRequestStatus &aStatus )

	{

	RefreshSocketContainerL( CSender::IpAddrType( aAddress ) );

	HandleMixedAddressFamilysL( aMessage, aAddress );

	iSender->SendL( 

	    aParams, 

	    aMessage, 

	    aAddress, 

	    0, 

	    aStatus, 

	    EFalse, 

	    EFalse );

	}

// -----------------------------------------------------------------------------

// CTransportUdp::SendToNetL

// -----------------------------------------------------------------------------

//

void CTransportUdp::SendToNetL( const TSIPTransportParams& aParams,

                                const TInetAddr& aAddress, 

                                TTransactionId aId, 

							    CSIPMessage& aMessage, 

							    TRequestStatus &aStatus )

	{

	RefreshSocketContainerL( CSender::IpAddrType( aAddress ) );

	HandleMixedAddressFamilysL( aMessage, aAddress );

	CResponseHandler* listItem = 0;

	iListIter.SetToFirst();

	while ( ( listItem = iListIter++ ) != 0 )

		{

		if(listItem->Handle( aId ) ) 

			{

			listItem->SendL( aParams, 

			                 static_cast<CSIPResponse&>( aMessage ), 

			                 aAddress, 

			                 aStatus );

			return;

			}

		}

	CResponseHandler* responsehandler =

		CResponseHandler::NewL( *this, iTimerManager, *iServerResolver, aId,

							    iICMPErrorWaitTime );

	iList.AddLast( *responsehandler );

	responsehandler->SendL( aParams, 

	                        static_cast<CSIPResponse&>( aMessage ), 

	                        aAddress, 

	                        aStatus);

	}

// -----------------------------------------------------------------------------

// CTransportUdp::CancelSend

// -----------------------------------------------------------------------------

//

TBool CTransportUdp::CancelSend( TRequestStatus& aStatus )

	{

	return iSender->FindAndCancel( aStatus );

	}

// -----------------------------------------------------------------------------

// CTransportUdp::CancelAllRequests

// -----------------------------------------------------------------------------

//

void CTransportUdp::CancelAllRequests( CSIPConnection::TState aReason )

	{

	iSender->CancelAllRequests( aReason );

	}

// -----------------------------------------------------------------------------

// CTransportUdp::CancelResponseSend

// -----------------------------------------------------------------------------

//

TBool CTransportUdp::CancelResponseSend( 

    TTransactionId aId, 

    TBool aCancelAlso2xxResponses )

	{

	CResponseHandler* listItem = 0;

	iListIter.SetToFirst();

	while ( ( listItem = iListIter++ ) != 0 )

		{

		if ( listItem->Handle( aId ) )

			{

			return listItem->CancelAll( aId, aCancelAlso2xxResponses );

			}

		}

	return EFalse;

	}

// -----------------------------------------------------------------------------

// CTransportUdp::IsWaiting

// -----------------------------------------------------------------------------

//

TBool CTransportUdp::IsWaiting( TUint aProtocol, TUint aPort )

	{

	return ( aPort == SourcePort() && aProtocol == KProtocolInetUdp );

	}

// -----------------------------------------------------------------------------

// CTransportUdp::SocketContainer

// -----------------------------------------------------------------------------

//

CSocketContainer& CTransportUdp::SocketContainer()

	{

    if ( iIPv6SocketContainer  )

	    {

	    return *iIPv6SocketContainer;

	    } 

	return *iIPv4SocketContainer;

	}

// -----------------------------------------------------------------------------

// CTransportUdp::SocketContainer

// -----------------------------------------------------------------------------

//

CSocketContainer* CTransportUdp::SocketContainer( TUint aIPAddrFamily )

	{

	if ( aIPAddrFamily == KAfInet )

	    {

	    if ( iIPv4SocketContainer  )

	        {

	        return iIPv4SocketContainer;

	        }

	    return iIPv6SocketContainer;

	    }

	else

	    {

	    if ( iIPv6SocketContainer  )

	        {

	        return iIPv6SocketContainer;

	        } 	    

	    }

	return NULL; // Only IPv6 socket can be used for sending to a IPv6 address

	}

// -----------------------------------------------------------------------------

// CTransportUdp::ICMPErrorL

// -----------------------------------------------------------------------------

//

void CTransportUdp::ICMPErrorL( CSipConnectionMgr::TICMPError aICMPError,

							    const TInetAddr& aSourceAddr )

	{

	CResponseHandler* listItem = 0;

	iListIter.SetToFirst();

	while ( ( listItem = iListIter++ ) != 0 )

		{

		listItem->ICMPErrorL( aICMPError, aSourceAddr );

		}

	}

// -----------------------------------------------------------------------------

// CTransportUdp::RemoveResHandler

// -----------------------------------------------------------------------------

//

void CTransportUdp::RemoveResHandler( CResponseHandler* aHandler )

	{

	if ( !iList.IsEmpty() )

		{

		iList.Remove( *aHandler );

		delete aHandler;

		__SIP_LOG( "CResHandler removed" )

		}

	}

// -----------------------------------------------------------------------------

// CTransportUdp::ConnectionOpenL

// -----------------------------------------------------------------------------

//

TBool CTransportUdp::ConnectionOpenL()

	{

	User::Leave( KErrNotSupported );

	return EFalse;

	}

// -----------------------------------------------------------------------------

// CTransportUdp::DisconnectedL

// -----------------------------------------------------------------------------

//

TBool CTransportUdp::DisconnectedL()

	{

	return EFalse;

	}

// -----------------------------------------------------------------------------

// CTransportUdp::GetSocketContainerL

// -----------------------------------------------------------------------------

//	

CSocketContainer& CTransportUdp::GetSocketContainerL(