// 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          : CSenderTcp.cpp
// Part of       : ConnectionMgr
// Version       : SIP/5.1 
//



#include "SipAssert.h"
#include "CSenderTcp.h"
#include "MContext.h"
#include "SipLogs.h"
#include "sipmessage.h"
#include "CSocketContainer.h"
#include "CommonConsts.h"
#include "COwnerSettingsList.h"

// -----------------------------------------------------------------------------
// CSenderTcp::NewL
// -----------------------------------------------------------------------------
//
CSenderTcp* CSenderTcp::NewL(
    MContext& aContext, 
    COwnerSettingsList& aSettingsList)
	{
	CSenderTcp* self = NewLC(aContext, aSettingsList);
	CleanupStack::Pop();
	return self;
	}

// -----------------------------------------------------------------------------
// CSenderTcp::NewLC
// -----------------------------------------------------------------------------
//
CSenderTcp* CSenderTcp::NewLC(
    MContext& aContext,
    COwnerSettingsList& aSettingsList)
	{
	CSenderTcp* self = new (ELeave) CSenderTcp(aContext, aSettingsList);
	CleanupStack::PushL(self);
	return self;
	}

// -----------------------------------------------------------------------------
// CSenderTcp::CSenderTcp
// -----------------------------------------------------------------------------
//
CSenderTcp::CSenderTcp(MContext& aContext, COwnerSettingsList& aSettingsList) : 
    CSender(aContext, aSettingsList)
	{	
	}
	
// -----------------------------------------------------------------------------
// CSenderTcp::~CSenderTcp
// -----------------------------------------------------------------------------
//
CSenderTcp::~CSenderTcp()
	{
	Cancel();
	}

// -----------------------------------------------------------------------------
// CSenderTcp::SendL
// -----------------------------------------------------------------------------
//
TBool CSenderTcp::SendL(const TSIPTransportParams& aTransportParams,
                        CSIPMessage& aMessage,
					    const TInetAddr& aAddr,
					    TUint aOrigTransport,
					    TRequestStatus& aStat,
					    TBool aStore,
					    TBool /*aForceUDP*/)
	{
	if(!aStore)
		{
		if(!IsActive())
			{
			if(aMessage.Content().Length() > 0)
				{
				iContinueSending = ETrue;
				}
			
			COutgoingData* data = 
			    COutgoingData::NewL( aTransportParams, aMessage, aAddr, 
			                         aOrigTransport, aStat, 
			                         *iContext.SigCompHandler() );		

	        iList.AddFirst( *data );		
		
            TCleanupItem cleanupItem( CleanCurrentDataOnLeave, this );
            CleanupStack::PushL( cleanupItem );
										
			EncodeAndSendL(aAddr);
			
			CleanupStack::Pop( 1 ); // cleanupItem
			
			return EFalse;
			}
		}

	return HandleFirstSendL( aTransportParams,
		                     aMessage, 
		                     aAddr, 
		                     aOrigTransport, 
		                     aStat,
		                     aStore );
	}

// -----------------------------------------------------------------------------
// CSenderTcp::SendL
// -----------------------------------------------------------------------------
//
void CSenderTcp::SendL(const TSIPTransportParams& aTransportParams,
                       CSIPMessage& aMessage, 
                       TRequestStatus& aStat)
	{
	if (!IsActive())
		{
		if(aMessage.Content().Length() > 0)
			{
			iContinueSending = ETrue;
			}
		
		COutgoingData* data = 	
            COutgoingData::NewL( aTransportParams, aMessage, aStat, 
                                 *iContext.SigCompHandler() );

        iList.AddFirst( *data );		
		
        TCleanupItem cleanupItem( CleanCurrentDataOnLeave, this );
        CleanupStack::PushL( cleanupItem );

		TInetAddr address;
		iContext.SocketContainer().RemoteName( address );
		
		EncodeAndSendL( address );
		
		CleanupStack::Pop( 1 ); // cleanupItem
		}
	else
		{
    	COutgoingData* data = COutgoingData::NewL( aTransportParams, 
    	                                           aMessage, aStat,
    	                                           *iContext.SigCompHandler() );
	    iList.AddLast( *data );
		}
	}

// -----------------------------------------------------------------------------
// CSenderTcp::SendNextL
// -----------------------------------------------------------------------------
//
void CSenderTcp::SendNextL()
	{
	COutgoingData* data = CurrentData();
	
	if ( !IsActive() )
		{
		if ( iContinueSending && data )
			{
			DoSend( data->Message().Content() );
			iContinueSending = EFalse;
			}
		else if ( data )
			{
			if ( data->Message().Content().Length() > 0 )
				{
				iContinueSending = ETrue;
				}
			TInetAddr address;
			iContext.SocketContainer().RemoteName( address );
            EncodeAndSendL( address );
			}
		else
			{
			iContext.Sending( EFalse );
			}
		}
	}

// -----------------------------------------------------------------------------
// CSenderTcp::EncodeAndSendL
// -----------------------------------------------------------------------------
//
void CSenderTcp::EncodeAndSendL( const TInetAddr& aAddr )
	{
	COutgoingData* data = CurrentData();
	
	__SIP_ASSERT_LEAVE( data, KErrNotFound );
	
	data->SetAddress( aAddr );
			
    TPtr8 ptrOutgoing = data->EncodeL( ETrue );
    
    if ( data->OrigTransport() == KProtocolInetUdp &&
         data->Compressed() &&
         ptrOutgoing.Length() < KMaxUdpMessageSize )
	    {
	    // If transport was originally UDP and compression decreased size
	    // of the message to be under MTU, UDP can be used.
	    data->Sent();
		iList.Remove( *data );
		iContext.Sending( EFalse );
		CleanupStack::PushL( data );
		iContext.ReRouteL( KProtocolInetUdp, data );
		CleanupStack::Pop( data );
		SendNextL();
		}
    else
        {
    	iOutgoingMessage.Set( ptrOutgoing );
    	if ( data->Compressed() )
    		{
    		iContinueSending = EFalse;
    		}
    	
    	__SIP_MESSAGE_LOG( "Connection Manager::SendToNetwork via TCP", 
    	                   iOutgoingMessage )
    	WriteToLog( iOutgoingMessage );
    	
    	DoSend( iOutgoingMessage );
        }
	}

// -----------------------------------------------------------------------------
// CSenderTcp::HandleFirstSendL
// -----------------------------------------------------------------------------
//	
TBool CSenderTcp::HandleFirstSendL( 
    const TSIPTransportParams& aTransportParams,
    CSIPMessage& aMessage, 
    const TInetAddr& aAddr, 
	TUint aOrigTransport, 
	TRequestStatus& aStat,
	TBool aStore )
    {
    COutgoingData* data = COutgoingData::NewLC( aTransportParams,
	                                            aMessage, 
	                                            aAddr, 
	                                            aOrigTransport,
		                                        aStat, 
											    *iContext.SigCompHandler() );
	
	TBool isFirstSend( iList.IsEmpty() && aStore );
	
	if ( aOrigTransport == KProtocolInetUdp && isFirstSend )
	    {
	    // Have to check immediately whether compression decreases size
	    // so that UDP could be used.
	    
	    TPtr8 encoded = data->EncodeL( ETrue );
	    
	    if ( encoded.Length() < KMaxUdpMessageSize && data->Compressed() )
	        {
	        data->Sent();
    		iContext.ReRouteL( KProtocolInetUdp, data );
    		CleanupStack::Pop( data );
    		return EFalse;
	        }
	    }

    CleanupStack::Pop( data );
	iList.AddLast( *data );
	
	return isFirstSend;
    }
	
// -----------------------------------------------------------------------------
// CSenderTcp::StoredData
// -----------------------------------------------------------------------------
//
COutgoingData* CSenderTcp::StoredData()
	{
	if (!iList.IsEmpty())
		{
		COutgoingData* listItem = 0;
		iListIter.SetToFirst();
		while ((listItem = iListIter++) != 0)
			{
			iList.Remove(*listItem);
            return listItem;
			}
		}
	return 0;
	}

// -----------------------------------------------------------------------------
// CSenderTcp::Data
// -----------------------------------------------------------------------------
//
COutgoingData* CSenderTcp::Data()
	{
	if (!iList.IsEmpty())
		{
		COutgoingData* listItem = 0;
		iListIter.SetToFirst();
		while ((listItem = iListIter++) != 0)
			{
			iList.Remove(*listItem);
			return listItem;
			}
		}
	return 0;
	}

// -----------------------------------------------------------------------------
// CSenderTcp::DoSend
// -----------------------------------------------------------------------------
//
void CSenderTcp::DoSend( const TDesC8& aData )
    {
    COutgoingData* data = CurrentData();
    
    __SIP_ASSERT_RETURN( !IsActive() && data, KErrInUse );
    
    // Set socket options before sending, options will be cleared after
    // send has completed.
    iSettingsList.SetOpts( data->TransportParams(),
    	                   iContext.SocketContainer().Socket() );
    	                       
	iContext.Sending( ETrue );
	iContext.SocketContainer().Send( aData, 0, iStatus );
			
	SetActive();
    }