// Copyright (c) 2007-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.cpp

// Part of       : ConnectionMgr

// Version       : SIP/6.0 

//

#include "MHandler.h"

#include "CTransport.h"

#include "MTransportOwner.h"

#include "CErrorHandler.h"

#include "MTransactionFinder.h"

#include "MServerTaFactory.h"

#include "sipmessageparser.h"

#include "MReceiverObserver.h"

#include "SipLogs.h"

#include "sipcontactheader.h"

#include "sipaddress.h"

#include "sipuri.h"

#include "siptoheader.h"

#include "sipfromheader.h"

#include "sipcallidheader.h"

#include "sipcseqheader.h"

#include "sipviaheader.h"

#include "sipheaderbase.h"

#include "sipmessageparser.h"

#include "siphostport.h"

#include "sipcontenttypeheader.h"

#include "sipmaxforwardsheader.h"

#include "CSIPServerResolver.h"

#include "utf.h"

#include "CommonConsts.h"

#include "sipstrings.h"

#include "sipstrconsts.h"

#include "uricontainer.h"

#include "NetworkInfo.h"

#include "COwnerSettingsList.h"

#include "TSIPTransportParams.h"

#include "MSigCompController.h"

#include "CSocketContainer.h"

#include "siperr.h"

#include <sipnatbindingobserver.h>

#include <sipnattraversalcontroller.h>

const TUint KBadRequest = 400;

const TUint KVersionError = 505;

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

// CTransport::CTransport

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

//

CTransport::CTransport( MTransactionFinder& aFinder, 

					    MServerTaFactory& aTaFactory,

					    MTransportOwner& aTransportOwner,

					    CSIPServerResolver& aServerResolver,

					    MSigCompController& aSigCompHandler,

					    const TSIPTransportParams& aTransportParams,

					    CNetworkInfo& aNetworkInfo,

					    COwnerSettingsList& aSettingsList,

					    CSIPNATTraversalController& aNATTraversal ) :

	iTransportParams( aTransportParams ),

	iSettingsList( aSettingsList ),

	iNATTraversal( aNATTraversal ),

	iTaFinder( &aFinder ),

	iTaFactory( &aTaFactory ),

	iSigCompHandler( &aSigCompHandler ),

	iNetworkInfo( aNetworkInfo )

	{

	iServerResolver = &aServerResolver;

	iTransportOwner = &aTransportOwner;

	}

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

// CTransport::~CTransport

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

//

CTransport::~CTransport()

	{

	iIDArray.Reset();

	iIDArray.Close();

	iBindingObservers.Reset();

	iBindingObservers.Close();

	}

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

// CTransport::RecvL

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

//

void CTransport::RecvL( HBufC8* aData,

					    const TInetAddr& aRemoteAddr,

					    TBool aCompressed )

	{

	__ASSERT_DEBUG( aData, User::Panic( _L("Nullpointer"), KErrGeneral ) );

	CleanupStack::PushL( aData );

	CSIPMessageParser* sipparser = CSIPMessageParser::NewLC();	

	HBufC8* dataCopy = aData->Des().AllocL();

	CSIPMessage* message( NULL );

	TInt parserError = sipparser->FromText( aData, &message );

	CleanupStack::PopAndDestroy( sipparser );

    CleanupStack::Pop(aData);

    CleanupStack::PushL(dataCopy);

	if ( !message && parserError )

	    {

	    // Show data to NATTraversalController if message couldn't be parsed

	    // and it was received via UDP (might be e.g. a STUN binding response).

	    TBool permissionToUse( EFalse );

	    RSocket* socket = AcquireUdpSocket( 0, aRemoteAddr, permissionToUse );

	    if ( socket )

	        {

	       	__SIP_LOG( "Received unrecognized data, passing to NATTraversal" )

	        // NOTE: NATTraversal does not use the socket for sending

	        // in DataReceived phase.

	        TBool handled( EFalse );

	        iNATTraversal.DataReceivedL( *dataCopy, *socket, handled );

	        // Release immediately

	        UdpSocketReleased( 0, *socket );

	        }

	    CleanupStack::PopAndDestroy( dataCopy );

	    }

	else

	    {

	    CleanupStack::PopAndDestroy( dataCopy );

	    CleanupStack::PushL( message );

	    RecvL( message, aRemoteAddr, parserError, aCompressed );

	    CleanupStack::Pop( message );

	    }

	}

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

// CTransport::RecvL

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

//

void CTransport::RecvL( CSIPMessage* aMessage,

					    const TInetAddr& aRemoteAddr, 

					    TInt aParserError,

					    TBool aCompressed )

	{

	HandleSigCompAllowDenyL( aRemoteAddr, aParserError, aCompressed ); 

	if ( aMessage )

		{

		if ( aParserError == KErrNone && AllMandatoryHeaders( *aMessage ) )

			{

            __SIP_ADDR_LOG( "Incoming message from", aRemoteAddr )

			if ( aMessage->IsRequest() )

				{

				if ( HandleServerRequestL( aMessage, aRemoteAddr ) == KErrNone )

					{

					RouteL( aMessage, aRemoteAddr );

					return;

					}

				}

			else

				{

				if ( HandleServerResponseL( aMessage, aRemoteAddr ) )

					{

					RouteL( aMessage, aRemoteAddr );

					return;

					}

				}

			}

		else

			{			

			if ( aMessage->IsRequest() && !IsAck( *aMessage ) )

				{

				SetReceivedIfNeededL( TopViaHeader( aMessage ), aRemoteAddr );

				SendErrorResponseL( KBadRequest,

			                        SipStrConsts::EPhraseBadRequest, 

					                *aMessage,

				                    aRemoteAddr );

				__SIP_LOG( "Invalid SIP Request" )

				}

			else

				{

				__SIP_LOG( "Invalid SIP Response or ACK" )

				}

			__SIP_DES8_LOG( "Invalid data: ", aMessage->Content() )

			__SIP_INT_LOG1( "Parser error", aParserError )

			}

		}

	else

		{

		__SIP_INT_LOG1( "Parser error", aParserError )

		}

	delete aMessage;

	}

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

// CTransport::RouteL

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

//

void CTransport::RouteL( CSIPMessage* aMessage, const TInetAddr& aRemoteAddr )

	{

	TInt leaveValue = KErrNone;

	MReceiverObserver* receiver = iTaFinder->Search( *aMessage );

	if ( receiver )

		{

		const TSIPTransportParams& tpParams = receiver->TransportParams();

		// Discard the message if receiving is not allowed

		if ( !iSettingsList.IsReceivingAllowed( tpParams, 

		                                        aRemoteAddr, 

		                                        Protocol(), 

		                                        SourcePort() ) )

		    {

		    delete aMessage;

		    return;

		    }

		if ( aMessage->IsRequest() )

			{

			TRAP( leaveValue,

				  receiver->ReceiveL( static_cast<CSIPRequest*>( aMessage ) ) );

			}

		else

			{

			HandleResponseNATTraversalL( 

			        static_cast< CSIPResponse& >( *aMessage ), 

			        aRemoteAddr,

			        const_cast<TSIPTransportParams&>(

			            tpParams ).NATBindingObserver() );

			TRAP( leaveValue,

				  receiver->ReceiveL( static_cast<CSIPResponse*>( aMessage ) ) );

			}

		if ( leaveValue != KErrNone )

			{

			delete aMessage;

			receiver->LeaveOccurred( leaveValue );

			}

		}

	else

		{

		if ( aMessage->IsRequest() )

			{

			TTransactionId id;

			// OwnerId cannot be known at this stage, default id will be used

			TSIPTransportParams tpParams( KDefaultOwnerId,

										  iTransportOwner->IapId() );

			// Find out whether some existing SAs should be used also for

			// this new transaction

			TUint32 tpId = iSettingsList.FindTransportId( aRemoteAddr );

			tpParams.SetTransportId( tpId );

			receiver = iTaFactory->NewTransactionL(

				static_cast<CSIPRequest&>( *aMessage ),

				tpParams,

				id );

			if ( receiver )

				{

				if ( IsConnectedTransport() )

					{

					TResponseRoute route( id, aRemoteAddr );

					iIDArray.Append( route );

					}

				TRAP( leaveValue,

					  receiver->ReceiveL( static_cast<CSIPRequest*>( aMessage ) ) );

				if ( leaveValue != KErrNone )

					{

					delete aMessage;

					receiver->LeaveOccurred( leaveValue );

					}

				}

			else

				{

				delete aMessage;

				}

			}

		else

			{

			delete aMessage;

			}

		}

	}

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

// CTransport::Send

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

//

void CTransport::Send( const TSIPTransportParams& aParams,

                       CSIPResponse& aResponse,

					   const TInetAddr& aAddr,

					   TRequestStatus &aStatus )

	{

	TRAPD( leaveValue,

		   SendToNetL( aParams, aAddr, aResponse, EFalse, Protocol(), aStatus ) );

	if ( leaveValue != KErrNone )

		{

		TRequestStatus* stat = &aStatus;

		User::RequestComplete( stat, leaveValue );

		}

	}

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

// CTransport::Send

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

//

void CTransport::Send( const TSIPTransportParams& aParams,

                       CSIPResponse& aResponse,

					   TTransactionId aId,

					   TRequestStatus &aStatus )

	{

	TInt leaveValue = KErrNone;

	TInetAddr remoteAddr;

	if ( Protocol() == KProtocolInetUdp )

		{

		TRAP( leaveValue, 

			  HandleClientResponseL( aParams, &aResponse, remoteAddr );

			  SendToNetL( aParams, remoteAddr, aId, aResponse, aStatus ) );

		if ( leaveValue != KErrNone )

			{

			TRequestStatus* stat = &aStatus;

			User::RequestComplete( stat, leaveValue );

			}

		}

	else

		{

		TInt pos;

		pos = iIDArray.Count();

		while ( pos > 0 )

			{

			if ( iIDArray[ pos - 1 ].TAId() == aId )

				{

				TRAP( leaveValue,

					  UpdateContactHeadersL( aParams, &aResponse, ETrue );

					  SendToNetL( aParams,

	                              iIDArray[ pos - 1 ].Address(),

								  aResponse,

								  EFalse,

								  0,

								  aStatus ) );

				if ( leaveValue != KErrNone )

					{

					TRequestStatus* stat = &aStatus;

					User::RequestComplete( stat, leaveValue );

					}

				return;

				}

			pos--;

			}

		TRAP( leaveValue,

			  HandleClientResponseL( aParams, &aResponse, remoteAddr );

			  SendToNetL( aParams, remoteAddr, aResponse, EFalse, Protocol(), aStatus ) );

		if ( leaveValue != KErrNone )

			{

			TRequestStatus* stat = &aStatus;

			User::RequestComplete( stat, leaveValue );

			}

		}

	}

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

// CTransport::Send

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

//

void CTransport::Send( const TSIPTransportParams& aParams,

                       CSIPRequest& aRequest,

                       TBool aForceUDP,

					   const TInetAddr& aAddr,

					   TUint aOrigTransport,

					   TRequestStatus &aStatus,

					   TBool aPublicAddrResolved )

	{

	TInt leaveValue = KErrNone;

	TRAP( leaveValue, 

		  HandleClientRequestL( aParams, aRequest, aPublicAddrResolved );

		  UpdateListenersL( aParams, &aRequest );

		  SendToNetL( aParams, aAddr, aRequest, aForceUDP, aOrigTransport, aStatus ) );

	if ( leaveValue != KErrNone )

		{

		TRequestStatus* stat = &aStatus;

		User::RequestComplete( stat, leaveValue );

		}

	}

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

// CTransport::HandleL

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

//

TBool CTransport::HandleL(

    const TSIPTransportParams& aParams,

    CSIPMessage* aMessage, 

    TTransactionId aId,

    TBool aIsStrict )

	{

	if ( !aMessage ) 

		{

		return EFalse;

		}

	TInt pos = iIDArray.Count();

	while ( pos > 0 )

		{

		if ( iIDArray[ pos - 1 ].TAId() == aId )	

			{

			return ETrue;

			}

		pos--;

		}

    if ( aIsStrict )

        {

        return EFalse;

        }

	TInetAddr remoteAddr;

	HandleClientResponseL( aParams, aMessage, remoteAddr );

	return HandleL( aParams, aMessage, remoteAddr, 0, ETrue );

	}

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

// CTransport::HandleL

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

//

TBool CTransport::HandleL(

    const TSIPTransportParams& aParams,

    CSIPMessage* aMessage, 

    const TInetAddr& aAddr,

    TUint aLocalPort,

    TBool aIsStrict )

	{

	if ( !aMessage ) 

		{

		return EFalse;

		}

	CSIPViaHeader* viaHeader = TopViaHeader( aMessage );

	if ( viaHeader )

		{

		if ( HandleMessage( aParams, 

		                    viaHeader->Transport(), 

		                    aAddr,

		                    aLocalPort,

		                    aIsStrict ) )

			{

			return ETrue;

			}

		}

	return EFalse;

	}

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

// CTransport::Handle

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

//

TBool CTransport::Handle( TUint32 aTransportId )

    {

    return ( IsReservedTransport() && 

             iTransportParams.TransportId() == aTransportId );

    }

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

// CTransport::Match

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

//	

TBool CTransport::Match( const TSIPTransportParams& aParams )

    {

	return ( aParams.TransportId() == 0 || Handle( aParams.TransportId() ) );

    }

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

// CTransport::HasRemoteHost

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

//

TBool CTransport::HasRemoteHost(

    const TSIPTransportParams& aParams,

    const TInetAddr& aRemoteHost,

    RStringF aProtocol )

	{

	return HandleMessage( aParams, aProtocol, aRemoteHost, 0, ETrue );

	}

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

// CTransport::Remove

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

//

TBool CTransport::Remove( const TSIPTransportParams& aParams )

    {

    // Default transports are not removed when owner closes its connection.

    // Also removal of persistent and reserved transport are handled separately.

    return ( !IsDefault() &&

             iTransportParams.OwnerId() == aParams.OwnerId() &&

             !IsPersistent() &&

             !IsReservedTransport() );

    }

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

// CTransport::Remove

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

//

TBool CTransport::Remove( MSIPNATBindingObserver& aSIPNATBindingObserver )

    {

    return ( !IsDefault() && RemoveBindingObserver( aSIPNATBindingObserver ) );

    }

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

// CTransport::Shutdown

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

//    

TBool CTransport::Shutdown( 

    TUint32 /*aTransportId*/,

    MSIPTransportRemovalObserver* /*aRemovalObserver*/ )

    {

    return EFalse;

    }