// Copyright (c) 2006-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          : Transmitter.cpp
// Part of       : Transaction
// Version       : SIP/5.0 
//



#include <in_sock.h>

#include "siperr.h"
#include "SipAssert.h"
#include "CSipConnectionMgr.h"
#include "TSIPTransportParams.h"
#include "SipLogs.h"

#include "Transmitter.h"
#include "SendStatus.h"

// -----------------------------------------------------------------------------
// CTransmitter::NewL
// -----------------------------------------------------------------------------
//
CTransmitter* CTransmitter::NewL(MSipConnectionMgr& aConnectionMgr)
	{
	return new (ELeave) CTransmitter(aConnectionMgr);	
	}

// -----------------------------------------------------------------------------
// CTransmitter::CTransmitter
// -----------------------------------------------------------------------------
//
CTransmitter::CTransmitter(MSipConnectionMgr& aConnectionMgr) :
	CActive(EPriorityStandard),
	iConnectionMgr(aConnectionMgr)
	{
	CActiveScheduler::Add(this);
	}

// -----------------------------------------------------------------------------
// CTransmitter::~CTransmitter
// -----------------------------------------------------------------------------
//
CTransmitter::~CTransmitter()
	{
	Cancel();
	}

// -----------------------------------------------------------------------------
// CTransmitter::SendRequestL
// -----------------------------------------------------------------------------
//
void CTransmitter::SendRequestL(CSIPRequest& aReq,
							    const TInetAddr& aAddress,
							    TBool aForceUDP,
							    const TSIPTransportParams& aParams,
							    const CUri8* aOutboundProxy,
								MSendStatus* aObserver)
	{	
	__SIP_ASSERT_LEAVE(aObserver, KErrArgument);

	if (IsActive())
		{
		User::Leave(KErrAlreadyExists);
        }
    iConnectionMgr.SendL(aParams,
    					 aReq,
    					 aForceUDP,
    					 aOutboundProxy,
    					 aAddress,
    					 iStatus);
    iObserver = aObserver;
	SetActive();
	}

// -----------------------------------------------------------------------------
// CTransmitter::SendResponseL
// -----------------------------------------------------------------------------
//
void CTransmitter::SendResponseL(CSIPResponse& aResp,
								 const TSIPTransportParams& aParams,
								 MSendStatus* aObserver,
								 TTransactionId aTransactionId)
	{	
	__SIP_ASSERT_LEAVE(aObserver, KErrArgument);

	if (IsActive())
		{
		User::Leave(KErrAlreadyExists);
		}

    iConnectionMgr.SendL(aParams, aResp, aTransactionId, iStatus);
    iObserver = aObserver;
	SetActive();	
	}

// -----------------------------------------------------------------------------
// CTransmitter::TcpDisconnect
// -----------------------------------------------------------------------------
//
void CTransmitter::TcpDisconnect(TInetAddr& aRemoteAddr,
							     const TSIPTransportParams& aParams) const
    {
    iConnectionMgr.TcpDisconnect(aParams, aRemoteAddr);
    }

// -----------------------------------------------------------------------------
// CTransmitter::MapErrorCode
// ICMP Errors are seperated with a new Error Code KErrSIPICMPFailure
// -----------------------------------------------------------------------------
//
TInt CTransmitter::MapErrorCode(TInt aError) const
	{	
	switch (aError)
		{
    //Connection is (temporarily) not available. Treat as sending error.
	case CSIPConnection::ESuspended:
	case CSIPConnection::EInactive:
		return KErrSIPTransportFailure;
    //ICMP errors
	case CSipConnectionMgr::EHostUnreachable:
	case CSipConnectionMgr::ENetUnreachable:
	case CSipConnectionMgr::EPortUnreachable:
	case CSipConnectionMgr::EProtocolUnreachable:
		return KErrSIPICMPFailure;

	default:
		return aError;
		}
	}

// -----------------------------------------------------------------------------
// CTransmitter::DetachCallback
// -----------------------------------------------------------------------------
//
void CTransmitter::DetachCallback(MSendStatus* aObserver)
	{	
	if (iObserver == aObserver)
		{
		iObserver = NULL;
		Cancel();
		}
	}

// -----------------------------------------------------------------------------
// CTransmitter::CancelSendResponses
// CTransmitter doesn't cancel its possibly existing send request yet.
// -----------------------------------------------------------------------------
//
void CTransmitter::CancelSendResponses(TTransactionId aTransactionId,
									   TBool aAlso2xx) const
	{    
    iConnectionMgr.CancelResponseSend(aTransactionId, aAlso2xx);
	}

// -----------------------------------------------------------------------------
// CTransmitter::DoCancel
// If ConnectionMgr didn't cancel the request, complete it if iStatus is still
// KRequestPending. If ConnectionMgr used User::RequestComplete but RunL hasn't
// been called, CTransmitter is still active, but iStatus isn't KRequestPending.
// -----------------------------------------------------------------------------
//
void CTransmitter::DoCancel()
	{
	__SIP_LOG("CTransmitter::DoCancel")

	if (iConnectionMgr.CancelSend(iStatus) != KErrNone &&
        iStatus == KRequestPending)
        {
    	__SIP_LOG("CTransmitter::DoCancel cancel own request")

        TRequestStatus* status = &iStatus;
        User::RequestComplete(status, KErrCancel);
        }

    __SIP_LOG("CTransmitter::DoCancel ends")
	}

// -----------------------------------------------------------------------------    
// CTransmitter::RunL
// -----------------------------------------------------------------------------
//
void CTransmitter::RunL()
    {
	if (iObserver)
		{
		if (iStatus.Int() == KErrNone)
			{
			iObserver->SendCompleteL();
			}
		else
			{
			iObserver->SendFailedL(MapErrorCode(iStatus.Int()));
			}
		}
	}

// -----------------------------------------------------------------------------
// CTransmitter::RunError
// -----------------------------------------------------------------------------
//
TInt CTransmitter::RunError(TInt aError)
    {
    __SIP_INT_LOG1("CTransmitter::RunError, err=", aError)

	if (iObserver)
		{
		iObserver->LeaveFromTransmitter(aError);
		}

	if (aError == KErrNoMemory)
		{
		return aError;
		}

	return KErrNone;
	}