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

// Part of       : ConnectionMgr

// Version       : SIP/5.0

//

#include "CSipConnection.h"

#include "CSipConnectionMgr.h"

#include "SipLogs.h"

#include "CTransportUdp.h"

#include "CTransportTcp.h"

#include "CTransportTls.h"

#include "CIcmpReceiver.h"

#include "MTransactionFinder.h"

#include "CSIPServerResolver.h"

#include "CTcpListeningPoint.h"

#include "COutgoingData.h"

#include "CTcpResSender.h"

#include "MConnectionStateObserver.h"

#include "CLocalAddrResolver.h"

#include "MSigCompController.h"

#include "SipAssert.h"

#include "CConnectionContainer.h"

#include "CNetworkManager.h"

#include "CStateModel.h"

#include "CommonConsts.h"

#include "sipstrings.h"

#include "sipstrconsts.h"

#include "TSIPTransportParams.h"

#include "COwnerSettingsList.h"

#include "siperr.h"

#include "NetworkInfo.h"

#include "sipviaheader.h"

#include "COutgoingRequestQueue.h"

#include "sipuri.h"

#include "uricontainer.h"

#include "siphostport.h"

#include "siprouteheader.h"

#include "sipaddress.h"

#include <uriutils.h>

using namespace CommsDat;

// Max length for an IP address string representation

// (The format is either "d.d.d.d" or "h:h:h:h:h:h:h:h"

//  depending on the address family, where "d" is an 8-bit decimal number

//  and "h" is a 16-bit hexadecimal number. )

const TUint KMaxAddressLength( 50 );

const TInt CTransportBase::iOffset = _FOFF( CTransportBase, iLink );

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

// CSipConnection::NewLC

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

//

CSipConnection* CSipConnection::NewLC(

								MTransactionFinder& aFinder,

								MServerTaFactory& aTaFactory,

								MTimerManager& aTimer,

								TUint aTOne,

								const TSIPTransportParams& aParams,

								RSocketServ& aServer,

								MSigCompController& aSigCompHandler,

								MConnectionStateObserver& aTUNetStatusObserver,

								CNetworkManager& aNetworkManager,

								MSipConnectionOwner& aOwner,

								CNetworkInfo& aNetworkInfo,

								CSIPNATTraversalController& aNATTraversal )

	{

	CSipConnection* self =

		new( ELeave ) CSipConnection( aFinder, aTaFactory, aTimer, aTOne,

									  aParams, aServer, aSigCompHandler,

									  aTUNetStatusObserver, aNetworkManager,

									  aOwner, aNetworkInfo, aNATTraversal );

	CleanupStack::PushL( self );

	self->ConstructL();

	return self;

	}

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

// CSipConnection::SetOptL

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

//	

void CSipConnection::SetOptL( 

    const TSIPTransportParams& aParams,

    TUint aOptionName,

	TUint aOptionLevel,

	const TDesC8& aOption )

    {	

    // Remember opt, it will be used when this caller is using sockets

    iSettingsList->AddSettingsL( aParams, aOptionName, aOptionLevel, aOption );

    }

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

// CSipConnection::SetOptL

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

//		         	                         

void CSipConnection::SetOptL( 

    const TSIPTransportParams& aParams,

    TUint aOptionName,

	TUint aOptionLevel,

	TInt aOption )

    {

    // Remember opt, it will be used when this caller is using sockets

    iSettingsList->AddSettingsL( aParams, aOptionName, aOptionLevel, aOption );

    }

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

// CSipConnection::SendL

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

//

void CSipConnection::SendL( 

    const TSIPTransportParams& aParams,

    CSIPResponse& aResponse,

	TTransactionId aId,

	TRequestStatus& aStatus )

	{

	__SIP_MESSAGE_LOG( "Connection Manager::SendL", aResponse )

	iStateModel->SendL( aParams, aResponse, aId, aStatus );

	}

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

// CSipConnection::SendL

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

//

void CSipConnection::SendL( 

    const TSIPTransportParams& aParams,

    CSIPRequest& aRequest,

    TBool aForceUDP,

    const CUri8* aOutboundProxy,

	const TInetAddr& aRemoteAddr,

	TRequestStatus& aStatus )

	{

	__SIP_MESSAGE_LOG( "Connection Manager::SendL", aRequest )

	if ( aRemoteAddr.IsMulticast() )

		{

		TRequestStatus* status = &aStatus;

		User::RequestComplete( status, KErrNotSupported );

		}

	else

		{

		iStateModel->SendL( aParams, 

		                    aRequest, 

		                    aForceUDP,

		                    aOutboundProxy, 

		                    aRemoteAddr, 

		                    aStatus );

		}

	}

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

// CSipConnection::CancelSend

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

//

TInt CSipConnection::CancelSend( TRequestStatus &aStatus )

	{

	TBool cancelled = EFalse;

	CTransportBase* listItem = 0;

	iListIter.SetToFirst();

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

		{

		cancelled = listItem->CancelSend( aStatus );

		if(cancelled)

			{

			return KErrNone;

			}

		}

	CTcpResponseSender* listsender( NULL );

	iTcpSenderListIter.SetToFirst();

	while ( ( listsender = iTcpSenderListIter++ ) != 0 )

		{

		if ( listsender->CancelSend( aStatus ) )

			{

			return KErrNone;

			}

		}

    if ( iRequestQueue )

        {

        if ( iRequestQueue->CancelSend( aStatus ) )

            {

            return KErrNone;

            }

        }

	return KErrNotFound;

	}

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

// CSipConnection::CancelResponseSend

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

//

TInt CSipConnection::CancelResponseSend( 

    TTransactionId aId, 

    TBool aCancelAlso2xxResponses )

	{

	TBool cancelled = EFalse;

	CTransportBase* listItem = 0;

	iListIter.SetToFirst();

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

		{

		cancelled = listItem->CancelResponseSend( aId, aCancelAlso2xxResponses );

		if ( cancelled )

			{

			return KErrNone;

			}

		}

	return KErrNotFound;

	}

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

// CSipConnection::TcpDisconnect

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

//

void CSipConnection::TcpDisconnect( 

    const TSIPTransportParams& aParams,

    const TInetAddr& aRemoteAddress )

	{

	CTransportBase* listItem = 0;

	iListIter.SetToFirst();

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

		{

		if ( listItem->HasRemoteHost( aParams, 

		                              aRemoteAddress, 

		                              SIPStrings::StringF(SipStrConsts::ETCP) ) )

			{

			listItem->Disconnect( aRemoteAddress );

			}

		}

	}

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

// CSipConnection::FreeResources

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

//	

void CSipConnection::FreeResources( 

    MSIPNATBindingObserver& aSIPNATBindingObserver )

    {

    if ( iRequestQueue )

        {

        iRequestQueue->FreeResources( aSIPNATBindingObserver );

        }

    // Remove all matching persistent transports    

    CTransportBase* listItem;

    iListIter.SetToFirst();

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

        {   

        if ( listItem->Remove( aSIPNATBindingObserver ) )

            {

            RemoveTransport( listItem );

            }

        }

    }

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

// CSipConnection::SendToTransportL

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

//

void CSipConnection::SendToTransportL(

    const TSIPTransportParams& aParams,

    CSIPResponse& aResponse,

	TTransactionId aId,

	TRequestStatus &aStatus )

	{

	CTransportBase* transport = 0;

	CSIPViaHeader* viaHeader = TopViaHeader( &aResponse );

	if ( viaHeader )

	{

		TBool isPortPresent = viaHeader->SentByHostPort().HasPort();

		if (isPortPresent)

		{

			TUint sentByPort = viaHeader->SentByHostPort().Port();

			if ((sentByPort > KMaxPortValue) || (sentByPort < KMinPortValue))

			{

				TRequestStatus* status = &aStatus;

		    	__SIP_LOG( "Sent-by port is topmost viaheader is invalid, dropping response" )

		    	User::RequestComplete( status, CSipConnectionMgr::EPortUnreachable );

		    	return;

			}

		}

	}

	TBool isTransportUdp = IsTransportUdp( &aResponse );

    transport = FindTransportL( aParams, &aResponse, aId, !isTransportUdp );

    if ( !isTransportUdp && !transport )

		{

		// When connected transport is used, there might be several connections

    	// with same remote address, in that case we had to search through all

    	// transports for matching the ta id. At this point any matching

    	// transport wasn't found, now we can take also remote address in count.

		transport = FindTransportL( aParams, &aResponse, aId, EFalse );

		if ( !transport )

		    {

    		// If there's saved settings regarding remote address, use them 

    		// instead of address passed from upper layers (probably only the

    		// port differs)

    		TInetAddr addrFromResponse;

            const TInetAddr* address;

            const TInetAddr* savedAddr = 

                iSettingsList->SavedRemoteAddr( aParams.TransportId() );

            if ( savedAddr )

                {

                address = savedAddr;

                }

            else

                {

    			CTransportBase* listItem;

    			if ( !iList.IsEmpty() )

    				{

    				iListIter.SetToFirst();

    				listItem = iListIter;

    				listItem->GetAddrFromResponseL( aParams, 

    				                                aResponse, 

    				                                addrFromResponse );

    				}

                address = &addrFromResponse;

                }    

    		if ( !address->IsWildAddr() )

    			{

        		CreateConnectedTransportPointL( aParams, aResponse, *address );

        		transport = FindTransportL( aParams, &aResponse, aId, EFalse );

    			}

    		}

		}

	if ( transport )

		{

		transport->Send( aParams, aResponse, aId, aStatus );

		}

	else

	    {	

        TRequestStatus* stat = &aStatus;

        User::RequestComplete( stat, KErrNotFound );

	    }

	}

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

// CSipConnection::SendToTransportL

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

//

void CSipConnection::SendToTransportL(

    const TSIPTransportParams& aParams,

    CSIPRequest& aRequest,

    TBool aForceUDP,

    const CUri8* aOutboundProxy,

	const TInetAddr& aAddr,

	TRequestStatus &aStatus )

	{

	TUint origTransport = 

	    UpdateTransportIfNeededL( aRequest, aParams, aForceUDP, aAddr );

    // If there's saved settings regarding remote address, use them instead of

    // address passed from upper layers (probably only the port differs)

    const TInetAddr* address = 

        iSettingsList->SavedRemoteAddr( aParams.TransportId() );

    if ( !address )

        {

        address = &aAddr;

        }

    TInetAddr localAddr;  

    GetLocalAddrL( localAddr, address );    

    iRequestQueue->NATTraverseL( aParams, 

                                 aRequest, 

                                 aForceUDP,

                                 *address, 

                                 aOutboundProxy,

                                 origTransport, 

                                 aStatus,

                                 localAddr );

	}

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

// CSipConnection::ContinueSendToTransportL

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

//	

void CSipConnection::ContinueSendToTransportL( 

    const TSIPTransportParams& aParams,

    CSIPRequest& aRequest,

    TBool aForceUDP,

    const TInetAddr& aRemoteAddr,

    TUint aLocalPort,

    TUint aOrigTransport,

    TRequestStatus& aStatus,

    TBool aPublicAddrResolved )

    {

    __ASSERT_ALWAYS( IsConnectionActive(), User::Leave( KErrNotReady ) );

	CTransportBase* transport = 

	    FindTransportL( aParams, &aRequest, aRemoteAddr, aLocalPort );

	if ( transport != 0 )

		{

		aStatus = KRequestPending;

		transport->Send( aParams, 

		                 aRequest,

		                 aForceUDP,

		                 aRemoteAddr, 

		                 aOrigTransport, 

		                 aStatus, 

		                 aPublicAddrResolved );

		}

	else

		{

		if ( aRequest.HasHeader( SIPStrings::StringF(SipStrConsts::EViaHeader) ) )

			{

            if ( IsTransportUdp( &aRequest ) )

                {

            	AddUdpListenerL( 

            	    TSIPTransportParams( KDefaultOwnerId, iIapId ),

            	    KDefaultSipPort );

            	}

            else

            	{	

            	CreateConnectedTransportPointL( aParams, aRequest, aRemoteAddr );

            	}

            transport = FindTransportL( aParams, &aRequest, aRemoteAddr );

            if ( transport )

                {

                aStatus = KRequestPending;

                transport->Send( aParams, 

                                 aRequest,

                                 aForceUDP, 

                                 aRemoteAddr, 

                                 aOrigTransport, 

                                 aStatus,

                                 aPublicAddrResolved );

            	}

            else

            	{

            	TRequestStatus* stat = &aStatus;

            	User::RequestComplete( stat, KErrNotReady );

            	}	

			}

		}

    }

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

// CSipConnection::RequestFailed

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

//   

void CSipConnection::RequestFailed( TRequestStatus& aStatus, TInt aError )

    {

    if ( aStatus == KRequestPending )

        {

        TRequestStatus* status = &aStatus;

		User::RequestComplete( status, aError );

        }

    }

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

// CSipConnection::GetUdpSocketL

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

//    

RSocket& CSipConnection::GetUdpSocketL( 

    const TSIPTransportParams& aParams, 

    const TInetAddr& aRemoteAddr,

    TUint& aLocalPort,

    MSocketUsagePermissionObserver* aObserver,

    TBool& aPermissionToUse )

    {

    CTransportBase* transport = 

        FindTransport( aParams, 

                       SIPStrings::StringF( SipStrConsts::EUDP ), 

                       aRemoteAddr,

                       aLocalPort,

                       EFalse );

    if ( !transport )

        {

        if ( !aLocalPort )

            {

            aLocalPort = iSettingsList->GetPrivatePortL( aParams );	

            }

        transport = AddUdpListenerL( aParams, aLocalPort, ETrue );

        }

    RSocket* udpSocket = 

        transport->AcquireUdpSocket( aObserver, aRemoteAddr, aPermissionToUse );

    __ASSERT_ALWAYS( udpSocket, User::Leave( KErrNotFound ) );

    return *udpSocket;

    }

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

// CSipConnection::UdpSocketFree

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

//       

void CSipConnection::UdpSocketFree( 

    const TSIPTransportParams& aParams,

    const TInetAddr& aRemoteAddr,

    TUint aLocalPort,

    MSocketUsagePermissionObserver* aObserver,

    RSocket& aSocket )

    {

    CTransportBase* transport = 

        FindTransport( aParams, 

                       SIPStrings::StringF( SipStrConsts::EUDP ), 

                       aRemoteAddr,

                       aLocalPort,

                       EFalse );

    if ( transport )

        {

        transport->UdpSocketReleased( aObserver, aSocket );

        }

    }