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

// Part of       : ConnectionMgr

// Version       : SIP/4.0 

//

#include "SipAssert.h"

#include "CTcpResSender.h"

#include "CSIPServerResolver.h"

#include "CSipConnection.h"

#include "COutgoingData.h"

#include "sipuri.h"

#include "sipviaheader.h"

#include "siphostport.h"

#include "CTransportBase.h"

#include "MSIPResolvingResult.h"

#include "sipstrings.h"

#include "sipstrconsts.h"

#include "TSIPTransportParams.h"

#include "siperr.h"

const TInt CTcpResponseSender::iSenderOffset =

	_FOFF(CTcpResponseSender, iSenderLink);

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

// CTcpResponseSender::CTcpResponseSender

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

//

CTcpResponseSender::CTcpResponseSender( const TSIPTransportParams& aParams,

                                        CSIPServerResolver& aHostResolver, 

							 		    CSipConnection& aOwner ) :

    iTransportParams( aParams ),

    iHostResolver( aHostResolver ),

    iOwner( &aOwner ),

    iSending( EFalse ),

    iResolving( EFalse )

	{

	}

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

// CTcpResponseSender::~CTcpResponseSender

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

//

CTcpResponseSender::~CTcpResponseSender()

	{

	if ( iResolving && iData )

		{

		CompleteRequest( iData->Status(), KErrCouldNotConnect );

		}

	iHostResolver.Cancel( this );		    

	iResultArray.ResetAndDestroy();

	delete iData;

	}

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

// CTcpResponseSender::ConnectionFailedL

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

//

void CTcpResponseSender::ConnectionFailedL()

	{

	// Safety check, although shouldn't ever exceed array bounds at this point

	if ( IndexWithinBounds() )

	    {

	    iResultArray[ iCurrentIndex ]->SetFailed( ETrue );

	    }

	SendL();

	}

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

// CTcpResponseSender::Connected

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

//

void CTcpResponseSender::Connected( const TInetAddr& aAddr )	

	{

	if ( iSending )

		{

		if ( IndexWithinBounds() && 

		     iResultArray[ iCurrentIndex ]->Address().CmpAddr( aAddr ) )

			{

			iOwner->RemoveTcpSender( this );

			}

		}

	}

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

// CTcpResponseSender::IsInProgress

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

//

TBool CTcpResponseSender::IsInProgress( COutgoingData& aData )

	{

	return iData && aData.Status() == iData->Status();

	}

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

// CTcpResponseSender::ResolveL

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

//

void CTcpResponseSender::ResolveL( COutgoingData& aData )

	{

	if ( !iResolving )

		{

		if ( aData.Message().HasHeader( 

		    	SIPStrings::StringF( SipStrConsts::EViaHeader ) ) )

			{

			TSglQueIter< CSIPHeaderBase > iter = aData.Message().Headers( 

				SIPStrings::StringF( SipStrConsts::EViaHeader ) );

			CSIPHeaderBase* header = iter;

			CSIPViaHeader* via = static_cast<CSIPViaHeader*>( header );

			iHostResolver.GetByViaL( *via, iResultArray, this );

			iResolving = ETrue;

			}

		}

	}

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

// CTcpResponseSender::CancelSend

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

//

TBool CTcpResponseSender::CancelSend( TRequestStatus &aStatus )

	{

	if ( iResolving && iData && &aStatus == iData->Status() )

		{

		CompleteRequest( iData->Status(), KErrSIPTransportFailure );

		iHostResolver.Cancel( this );

		iResolving = EFalse;

		return ETrue;

		}

	return EFalse;

	}

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

// CTcpResponseSender::SetData

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

//    

void CTcpResponseSender::SetData( COutgoingData* aData )

	{

	__SIP_ASSERT_RETURN( !iData, KErrAlreadyExists );

	iData = aData;

	}

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

// CTcpResponseSender::CompletedL

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

//   

void CTcpResponseSender::CompletedL()

    {

    iResolving = EFalse;

	SendL();

    }

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

// CTcpResponseSender::ErrorOccured

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

//	

void CTcpResponseSender::ErrorOccured( TInt /*aError*/ )

    {

    iResolving = EFalse;

	if ( iData )

		{

		CompleteRequest( iData->Status(), KErrCouldNotConnect );

		}

	iOwner->RemoveTcpSender( this );

    }

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

// CTcpResponseSender::SendL

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

//

void CTcpResponseSender::SendL()

	{

	__SIP_ASSERT_LEAVE( iData, KErrNotFound );

	MSIPResolvingResult* result = FirstUnfailedResult();

	if ( result )

		{

		CTransportBase* transport;

		transport = iOwner->FindTransportL( iTransportParams,

		                                    &iData->Message(),

			                                result->Address() );	

		if ( transport )

			{

			iSending = ETrue;

			transport->Send( iTransportParams,

			                 static_cast<CSIPResponse&>( iData->Message() ), 

				             result->Address(), 

						     *iData->Status() );

			}

		else

			{

			iOwner->CreateTcpTransportPointL( iTransportParams,

			                                  result->Address() );

			transport = iOwner->FindTransportL( iTransportParams,

			                                    &iData->Message(), 

				                                result->Address() );		

			if ( transport )

				{

				iSending = ETrue;

				transport->Send( iTransportParams,

				                 static_cast<CSIPResponse&>( iData->Message() ), 

					             result->Address(), 

								 *iData->Status() );

				}

			else

				{

				CompleteRequest( iData->Status(), KErrCouldNotConnect );

				iOwner->RemoveTcpSender( this );

				}

			}

		}

	else

		{

		// Sending to every resolved address failed, resolve more

		ResolveL( *iData );

		}

	}

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

// CTcpResponseSender::CompleteRequest

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

//

void CTcpResponseSender::CompleteRequest( TRequestStatus* aStatus, TInt aReason )

	{

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

		{

		User::RequestComplete( aStatus, aReason );

		}

	}

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

// CTcpResponseSender::FirstUnfailedResult

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

//

MSIPResolvingResult* CTcpResponseSender::FirstUnfailedResult()

    {

    for ( TInt i = 0; i < iResultArray.Count(); i++ )

        {

        MSIPResolvingResult* result = iResultArray[ i ];

        if ( !result->Failed() )

            {

            iCurrentIndex = i;

            return result;

            }

        }

    iCurrentIndex = KErrNotFound;

    return 0;

    }

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

// CTcpResponseSender::IndexWithinBounds

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

//

TBool CTcpResponseSender::IndexWithinBounds()

    {

    return ( iCurrentIndex >= 0 && iCurrentIndex < iResultArray.Count() );

    }