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



#include "CSender.h"
#include "SipLogs.h"
#include "CSocketContainer.h"
#include "siperr.h"
#include "COwnerSettingsList.h"

// -----------------------------------------------------------------------------
// CSender::CSender
// -----------------------------------------------------------------------------
//
CSender::CSender(MContext& aContext,COwnerSettingsList& aSettingsList) :
    CActive(CActive::EPriorityStandard),
    iContext(aContext), 
    iSettingsList(aSettingsList),
    iList(COutgoingData::iOffset),
    iListIter(iList),
    iContinueSending(EFalse)
	{
	CActiveScheduler::Add(this);
	}

// -----------------------------------------------------------------------------
// CSender::~CSender
// -----------------------------------------------------------------------------
//
CSender::~CSender() 
	{
	CancelAllRequests( KErrSIPTransportFailure );
	}

// -----------------------------------------------------------------------------
// CSender::SendL
// -----------------------------------------------------------------------------
//
void CSender::SendL (
    const TSIPTransportParams& /*aTransportParams*/, 
    CSIPMessage& /*aMessage*/, 
    TRequestStatus& /*aStat*/)
	{
	__ASSERT_DEBUG(EFalse,
	User::Panic(_L("CSender baseclass is called"),
	KErrGeneral));
	}

// -----------------------------------------------------------------------------
// CSender::SendL
// -----------------------------------------------------------------------------
//
void CSender::SendL (COutgoingData* /*aData*/)
	{
	__ASSERT_DEBUG(EFalse,
	User::Panic(_L("CSender baseclass is called"),
	KErrGeneral));
	}

// -----------------------------------------------------------------------------
// CSender::StoredData
// -----------------------------------------------------------------------------
//
COutgoingData* CSender::StoredData()
	{
	return 0;
	}

// -----------------------------------------------------------------------------
// CSender::Data
// -----------------------------------------------------------------------------
//
COutgoingData* CSender::Data()
	{
	return 0;
	}

// -----------------------------------------------------------------------------
// CSender::FindAndCancel
// -----------------------------------------------------------------------------
//
TBool CSender::FindAndCancel(TRequestStatus& aStat)
	{
	COutgoingData* currentData = CurrentData();
	
	if (currentData && &aStat == currentData->Status())
		{
		iContext.SocketContainer().CancelSend();
        iContext.Sending( EFalse );
        RemoveCurrentData( KErrSIPTransportFailure );
        return ETrue;
		}	
	
	if (!iList.IsEmpty())
		{
		iListIter.SetToFirst();
		for(COutgoingData* data = iListIter; data; data = iListIter++)
			{
			if(&aStat == data->Status())
				{
				CompleteRequest(data->Status(), KErrSIPTransportFailure );
				iList.Remove(*data);
				delete data;
				return ETrue;
				}
			}
		}

	return EFalse;		
	}

// -----------------------------------------------------------------------------
// CSender::CancelAllRequests
// -----------------------------------------------------------------------------
//
void CSender::CancelAllRequests (TInt aReason)
	{
	Cancel();
	RemoveCurrentData(aReason);
	if (!iList.IsEmpty())
		{
		COutgoingData* data = 0;
		iListIter.SetToFirst();
		while ((data = iListIter++) != 0)
			{
			CompleteRequest(data->Status(),aReason);
			iList.Remove(*data);
			delete data;
			}
		}
	}

// -----------------------------------------------------------------------------
// CSender::CurrentData
// -----------------------------------------------------------------------------
//
COutgoingData* CSender::CurrentData()
    {
    COutgoingData* data( NULL );
    if ( !iList.IsEmpty() )
        {
        data = iList.First();
        }
    return data;
    }

// -----------------------------------------------------------------------------
// CSender::IpAddressType
// -----------------------------------------------------------------------------
//
TUint CSender::IpAddrType( const TInetAddr& aAddr )
    {
    // TInetAddr::Family returns sometimes KAfInet6 for an IPv4 address.
    // The way to make sure the address is IPv4 is to use TInetAddr::Address.
    // This is because a real IPv6 cannot be represented with a TUint.
    TUint type( KAFUnspec );
    if ( aAddr.Address() )
        {
        type = KAfInet;
        }
    else
        {
        type = KAfInet6;
        }
    return type;
    }

// -----------------------------------------------------------------------------
// CSender::CleanCurrentDataOnLeave
// -----------------------------------------------------------------------------
//
void CSender::CleanCurrentDataOnLeave( TAny* aSelf )
    {
    CSender* self = reinterpret_cast< CSender* >( aSelf );
    COutgoingData* data = self->CurrentData();
	if ( data )
		{
		self->iList.Remove( *data );
		self->iContinueSending = EFalse;
		delete data;
		}
	}

// -----------------------------------------------------------------------------
// CSender::WriteToLog
// -----------------------------------------------------------------------------
//
#if (defined(_DEBUG) && defined(USE_SIP_LOGS))
void CSender::WriteToLog( const TDesC8& aMessage )
	{
	if ( CurrentData() )
	    {
	    __SIP_ADDR_LOG( "Outgoing data to address", CurrentData()->Address() )
	    }
	__SIP_DES8_LOG( "Outgoing data", aMessage )
	}
#else
void CSender::WriteToLog( const TDesC8& /*aMessage*/ )
	{
	}
#endif


// -----------------------------------------------------------------------------
// CSender::RunL
// -----------------------------------------------------------------------------
//
void CSender::RunL()
	{
	TInt status = iStatus.Int();
	
	__SIP_INT_LOG1( "CSender::RunL status:", status )
	
	TBool terminated( EFalse );

    switch ( status )
        {
        case KErrNone:
            {
            COutgoingData* data = CurrentData();
           	if ( data )
    			{
    			data->Sent();
    			
    			CSocketContainer* socketContainer =
    			    iContext.SocketContainer( IpAddrType( data->Address() ) );
    			if ( socketContainer )
    			    {
        			// Clear socket options after sending has completed.
        			// Do only if it completed successfully as it might be 
        			// unsafe to attempt setting options after socket failure.
        			iSettingsList.ClearOpts( 
        			    data->TransportParams(),
        	            socketContainer->Socket() );
    			    }
    			}
    		if ( !iContinueSending )
    			{
    			RemoveCurrentData( KErrNone );
    			}
            break;
            }
        case KErrCancel:
            {
            break;
            }
        case KErrDisconnected:
            {
            terminated = iContext.DisconnectedL();
            break;
            }
        default: // Rest of the errors
            {
            terminated = iContext.StopL();
            if ( !terminated )
                {
                iContext.ResetSocketL();
			    iContext.ContinueL();
                }
            break;
            }
        }
        
    if ( !terminated )
        {
        SendNextL();
        }
	}

// -----------------------------------------------------------------------------
// CSender::RunError
// -----------------------------------------------------------------------------
//
TInt CSender::RunError(TInt aError)
	{
	if(aError != KErrNoMemory)
		{
		return KErrNone;
		}
	return aError;
	}

// -----------------------------------------------------------------------------
// CSender::DoCancel
// -----------------------------------------------------------------------------
//
void CSender::DoCancel()
	{
	iContext.SocketContainer().CancelSend();
	iContext.Sending( EFalse );
	RemoveCurrentData( KErrSIPTransportFailure );
	}

// -----------------------------------------------------------------------------
// CSender::RemoveCurrentData
// -----------------------------------------------------------------------------
//
void CSender::RemoveCurrentData(TInt aReason)
	{
	COutgoingData* data = CurrentData();
	if ( data )
		{
		iList.Remove( *data );
		iContinueSending = EFalse;
		CompleteRequest(data->Status(),aReason);
		delete data;
		}
	}

// -----------------------------------------------------------------------------
// CSender::CompleteRequest
// -----------------------------------------------------------------------------
//
void CSender::CompleteRequest (TRequestStatus* aStatus, TInt aReason)
	{
	if (aStatus != 0 && *aStatus == KRequestPending)
		{
		User::RequestComplete(aStatus,aReason);
		}
	}