// Copyright (c) 2005-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        : CTransportTls.cpp

// Part of     : ConnectionMgr

// implementation

// Version     : SIP/5.0

//

#include <securesocket.h>

#include "CTransportTls.h"

#include "CSipConnection.h"

#include "CErrorHandler.h"

#include "MTransactionFinder.h"

#include "MTransportOwner.h"

#include "MServerTaFactory.h"

#include "CSender.h"

#include "CSenderTcp.h"

#include "CReceiverTcp.h"

#include "CommonConsts.h"

#include "siperr.h"

#include "NetworkInfo.h"

#include "COwnerSettingsList.h"

#include "sipstrings.h"

#include "sipstrconsts.h"

#include "TTlsTransTcpConnecting.h"

#include "TTlsTransTlsConnecting.h"

#include "TTlsTransTlsConnected.h"

#include "CSecureSocketContainer.h"

#include <sipnattraversalcontroller.h>

#include "SipLogs.h"

#include "uricontainer.h"

#include "sipuri.h"

#include "siphostport.h"

#include <asn1dec.h>

#include <ssl_internal.h>

#include <x509cert.h>

#include <x500dn.h>

#include <x520ava.h>

#include <x509certext.h>

#include <x509gn.h>

#include <securitydefsconst.h>

const TInt KMaxConnectAttempts = 2;

_LIT(KSipDomainOID, "1.3.6.1.5.5.7.3.20");

_LIT(KAnyExtendedKeyUsage, "2.5.29.37.0");

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

// CTransportTls::NewL

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

//

CTransportTls* CTransportTls::NewL(

    RSocketServ& aServer,

	MTransactionFinder& aFinder, 

	MServerTaFactory& aTaFactory,

	MTransportOwner& aTransportOwner,

	MTimerManager& aTimer,

	const TSIPTransportParams& aTransportParams,

	const TInetAddr& aRemoteAddr,

	TUint aTOne,

	CSIPServerResolver& aServerResolver,

	RConnection& aConnection,

	MSigCompController& aSigCompHandler,

	CNetworkInfo& aNetworkInfo,

	COwnerSettingsList& aSettingsList,

	CSIPNATTraversalController& aNATTraversal )

	{

	CTransportTls* self = NewLC( aServer, 

	                             aFinder, 

	                             aTaFactory, 

								 aTransportOwner, 

								 aTimer,

								 aTransportParams,

								 aRemoteAddr, 

								 aTOne,

								 aServerResolver, 

								 aConnection, 

								 aSigCompHandler, 

								 aNetworkInfo, 

								 aSettingsList,

								 aNATTraversal );

	CleanupStack::Pop( self );

	return self;

	}

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

// CTransportTls::NewLC

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

//

CTransportTls* CTransportTls::NewLC(

    RSocketServ& aServer,

	MTransactionFinder& aFinder, 

	MServerTaFactory& aTaFactory,

	MTransportOwner& aTransportOwner,

	MTimerManager& aTimer,

	const TSIPTransportParams& aTransportParams,

	const TInetAddr& aRemoteAddr,

	TUint aTOne,

	CSIPServerResolver& aServerResolver,

	RConnection& aConnection,

	MSigCompController& aSigCompHandler,

	CNetworkInfo& aNetworkInfo,

	COwnerSettingsList& aSettingsList,

	CSIPNATTraversalController& aNATTraversal )

	{

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

	                                                    aFinder, 

	                                                    aTaFactory, 

                					                    aTransportOwner, 

                					                    aTimer,

                					                    aTransportParams,

                					                    aRemoteAddr,

                					                    aTOne,

                					                    aServerResolver,

                					                    aConnection, 

                					                    aSigCompHandler,

                				                        aNetworkInfo,

                				                        aSettingsList,

                				                        aNATTraversal );

	CleanupStack::PushL( self );

	self->ConstructL();

	return self;

	}

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

// CTransportTls::CTransportTls

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

//

CTransportTls::CTransportTls(

    RSocketServ& aServer,

	MTransactionFinder& aFinder, 

	MServerTaFactory& aTaFactory,

	MTransportOwner& aTransportOwner,

	MTimerManager& aTimer,

	const TSIPTransportParams& aTransportParams,

	const TInetAddr& aRemoteAddr,

	TUint aTOne,

	CSIPServerResolver& aServerResolver,

	RConnection& aConnection,

	MSigCompController& aSigCompHandler,

	CNetworkInfo& aNetworkInfo,

	COwnerSettingsList& aSettingsList,

	CSIPNATTraversalController& aNATTraversal ) : 

	CTransport( aFinder, 

	            aTaFactory, 

	            aTransportOwner,

			    aServerResolver, 

			    aSigCompHandler,

			    aTransportParams, 

			    aNetworkInfo, 

			    aSettingsList,

			    aNATTraversal ),

	iSocketServ( aServer ),

	iTimer( aTimer ),

	iTimerValue( 64 * aTOne ),

	iConnection( aConnection ),

	iRemoteAddr( aRemoteAddr ),

	iStates( TTlsTransStateBase::EMaxStates ),

    iCurrentState( TTlsTransStateBase::ETcpConnecting ),

    iIsSending( EFalse )

	{

	}

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

// CTransportTls::ConstructL

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

//

void CTransportTls::ConstructL()

	{

	iErrorHandler =	CTransportErrorHandler::NewL( *this );

	User::LeaveIfError( iSocket.Open( iSocketServ, 

	                                  KAfInet, 

	                                  KSockStream,

									  KProtocolInetTcp, 

									  iConnection ) );

	// Secure socket will be added later to the container

	iSocketContainer = CSecureSocketContainer::NewL( iSocket );

	iReceiver = CReceiverTcp::NewL( *this );

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

	iDomainName = NULL;

	InitializeStatesL();

	}

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

// CTransportTls::~CTransportTls

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

//

CTransportTls::~CTransportTls()

	{

	iTimer.Stop( iMyTimerId );

	delete iErrorHandler;

	delete iReceiver;

	delete iSender;

	delete iSocketContainer;

	delete iDomainName;

	if ( iSecureSocket )

	    {

	    iNATTraversal.SocketIdle( EFalse, *iSecureSocket );

	    delete iSecureSocket;

	    }

	iSocket.Close();

	}

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

// CTransportTls::HandleMessage

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

//

TBool CTransportTls::HandleMessage(

    const TSIPTransportParams& aParams,

    RStringF aProtocol,

	const TInetAddr& aRemoteAddr,

	TUint /*aLocalPort*/,

	TBool /*aIsStrict*/ )

	{  

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

	         iRemoteAddr.CmpAddr( aRemoteAddr ) &&

	         Match( aParams ) );

	}

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

// CTransportTls::SourcePort

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

//

TUint CTransportTls::SourcePort()

	{

	return iSocket.LocalPort();

	}

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

// CTransportTls::SendToNetL

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

//

void CTransportTls::SendToNetL(

    const TSIPTransportParams& aParams,

    const TInetAddr& aAddress, 

    CSIPMessage& aMessage, 

    TBool /*aForceUDP*/,

    TUint aOrigTransport,

    TRequestStatus &aStatus )

	{

	HandleMixedAddressFamilysL( aMessage, aAddress );

	CurrentState().SendToNetL( aParams,

	                           aAddress,

	                           aMessage,

							   aOrigTransport,

							   aStatus );

	}

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

// CTransportTls::CancelSend

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

//

TBool CTransportTls::CancelSend( TRequestStatus& aStatus )

	{

	return iSender->FindAndCancel( aStatus );

	}

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

// CTransportTls::ErrorHandler

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

//	

CTransportErrorHandler& CTransportTls::ErrorHandler() 

    {

    return *iErrorHandler;

    }

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

// CTransportTls::WaitL

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

//

void CTransportTls::WaitL()

	{

	}

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

// CTransportTls::IsWaiting

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

//

TBool CTransportTls::IsWaiting( TUint /*aProtocol*/, TUint /*aPort*/ )

	{

	return EFalse;	

	}

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

// CTransportTls::CancelAllRequests

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

//

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

	{

	GetSender().CancelAllRequests( aReason );

	}

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

// CTransportTls::Protocol

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

//	

TUint CTransportTls::Protocol()

    {

    return KProtocolTls;

    }

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

// CTransportTls::GetSocketContainerL

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

//	

CSocketContainer& CTransportTls::GetSocketContainerL( 

    const TInetAddr& /*aRemoteAddr*/ )

    {

    return *iSocketContainer;

    }

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

// CTransportTls::InformSendingStatus

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

//    

void CTransportTls::InformSendingStatus( const TInetAddr& /*aRemoteAddr*/ )

    {

    Sending( iIsSending );

    }

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

// CTransportTls::Sender

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

//

CSender* CTransportTls::Sender(

    const TSIPTransportParams& aParams,

    TUint aProtocol, 

    const TInetAddr& aRemoteAddr )

	{

	if ( Protocol() == aProtocol && 

	     aRemoteAddr.CmpAddr( iRemoteAddr ) && 

	     Match( aParams ) )

		{

		return iSender;

		}

	return 0;

	}

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

// CTransportTls::Disconnect

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

//

void CTransportTls::Disconnect( const TInetAddr& /*aRemoteHost*/ )

	{

	// If this is reserved or persistent transport, 

	// only all send operations are cleared

	if ( IsReservedTransport() || IsPersistent() )

	    {

	    iSender->CancelAllRequests( KErrSIPTransportFailure );

	    }

	else

	    {

	    Remove();

	    }

	}

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

// CTransportTls::PersistentRemoteAddr

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

// 

TInetAddr* CTransportTls::PersistentRemoteAddr( 

    MSIPNATBindingObserver* aBindingObserver )

    {

    TInt index = iBindingObservers.FindInAddressOrder( aBindingObserver );

    if ( index >= 0 && index < iBindingObservers.Count() )

        {

        return &iRemoteAddr;

        }

    return 0;

    }

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

// CTransportTls::SocketContainer

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

//

CSocketContainer& CTransportTls::SocketContainer()

    {

    return *iSocketContainer;

    }

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

// CTransportTls::SocketContainer

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

//

CSocketContainer* CTransportTls::SocketContainer( 

    TUint /*aIPAddrFamily*/ )

    {

    return iSocketContainer;

    }   

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

// CTransportTls::ReceivedDataL

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

//

void CTransportTls::ReceivedDataL( 

    HBufC8* /*aData*/,

    const TInetAddr& /*aRemoteAddr*/,

    TBool /*aCompressed*/ ) 

    {

    }

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

// CTransportTls::ReceivedDataL

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

//

void CTransportTls::ReceivedDataL( 

    CSIPMessage* aMessage,

    const TInetAddr& aRemoteAddr,

    TInt aError,

    TBool aCompressed )

	{

	RecvL( aMessage, aRemoteAddr, aError, aCompressed );

	}

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

// CTransportTls::SigCompHandler

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

//

MSigCompController* CTransportTls::SigCompHandler()

	{

	return SigCompressionHandler();

	}

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

// CTransportTls::ResetSocketL

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

//

void CTransportTls::ResetSocketL()

	{

	}

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

// CTransportTls::ContinueL

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

//

void CTransportTls::ContinueL()

	{

	}

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

// CTransportTls::StopL

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

//

TBool CTransportTls::StopL()

	{

	return EFalse;

	}

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

// CTransportTls::Remove

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

//

TInt CTransportTls::Remove()

	{

	return iTransportOwner->RemoveTransport( this );

	}

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

// CTransportTls::ConnectionOpenL

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

//

TBool CTransportTls::ConnectionOpenL()

	{

	return CurrentState().ConnectionOpenL();

	}

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

// CTransportTls::DisconnectedL

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

//

TBool CTransportTls::DisconnectedL()

	{

	TBool retVal( ETrue );

	// Flow failure notification may lead to immediate self deletion

	if ( !NotifyFlowFailure() )

	    {

	    retVal = CurrentState().DisconnectedL();

	    }

	return retVal;

	}

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

// CTransportTls::ReRouteL

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

//

void CTransportTls::ReRouteL( TUint /*aProtocol*/, COutgoingData* aData )

	{

	// TLS transport doesn't allow rerouting

	if ( aData )

	    {

	    TRequestStatus* status = aData->Status();

    	if ( status != 0 && *status == KRequestPending )

    		{

    		User::RequestComplete( status, KErrSIPTransportFailure );

    		}

        delete aData;

	    }

	}

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

// CTransportTls::IapId

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

//

TUint32 CTransportTls::IapId()

	{

	return iTransportOwner->IapId();