/*

* Copyright (c) 2005 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:  

*

*/

#include <e32base.h>

#include <e32cmn.h>

#include <siprackheader.h>

#include <sipconnection.h>

#include <sipresponseelements.h>

#include <siprequestelements.h>

#include <sipcseqheader.h> 

#include <siprseqheader.h> 

#include <centralrepository.h>

#include <sipsdkcrkeys.h>

#include <stringpool.h>

#include "mcesip.h"

#include "mcesrvlogs.h"

#include "mcereliableobserver.h"

#include "mcereliablesender.h"

#include "mceeventstatebase.h"

// CONSTANTS

const TInt KMaxTransTimeOut = 64;

const TUint KTransInterval = 2;

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

// CMCEReliableSender::NewL ;

// Two-phased constructor. ;

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

//

CMceReliableSender* CMceReliableSender::NewL( MMceReliableObserver& aObserver )

    {

	CMceReliableSender* self = new( ELeave ) CMceReliableSender( aObserver );

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( self );

	return self;

    }

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

// CMceReliableSender::CMceReliableSender

// Constructor

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

//

CMceReliableSender::CMceReliableSender( MMceReliableObserver& aObserver )

: iObserver( &aObserver )

    {

    }

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

// Destructor

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

//

CMceReliableSender::~CMceReliableSender()

    {

	delete iDTimer;

	delete iResponseElements;

    }

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

// CMceReliableSender::ConstructL

// Symbian 2nd phase constructor.

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

//

void CMceReliableSender::ConstructL()

    {

	const TUint	KMaxRSec = 0x7fffffff;

    const TUint	KMinRSec = 1;

	TInt timerT1;

	CRepository* repository = CRepository::NewLC( KCRUidSIP );

	User::LeaveIfError( repository->Get( KSIPTransactionTimerT1, timerT1 ));

	CleanupStack::PopAndDestroy( repository );

    iT1 = timerT1;

    iRetransTimer = 1;

    iTotaltime = 0;

    iSequenceNumber = MceSip::Random( KMinRSec, KMaxRSec );

	iTransactionMatched = EFalse;

	iTransactionStatus = EFalse;	// No Pending transaction Yet 

	iTransTimeoutFlag = EFalse;

    // Create the timer entry 

	iDTimer = CDeltaTimer::NewL( CActive::EPriorityStandard );

	TCallBack cb( TimerExpire, this );

	iDeltaEntry.Set( cb );

    }

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

// CMceReliableSender::Rseq

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

//

TUint CMceReliableSender::Rseq( CSIPServerTransaction& aTransaction )

    {

    TInt tInProcess = 0;

	if  ( iTransactionStatus )

	    {

	    MCESRV_DEBUG( "CMceReliableSender::Rseq: Transsaction in Process");

	    return tInProcess;

	    }

   	else if( &aTransaction == iServerTransaction )

	    {

		iSequenceNumber = iSequenceNumber + 1;

		return iSequenceNumber;

	    }

	else

	    {

	    return iSequenceNumber;

	    }

    }

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

// CMceReliableSender::SendResponseL

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

//

void CMceReliableSender::SendResponseL( CSIPServerTransaction& aTransaction, 

                                        CSIPResponseElements* aElements )

    {

	if  ( iTransactionStatus )

	    {

        User::Leave( KErrInUse );

	    }

    iServerTransaction = &aTransaction;

	CSIPResponseElements* xResponses;

	// Set the Transaction in progree Flag  

	iTransactionStatus = ETrue;

    TUint queueTimer = 0;

	xResponses = ResponseCloneL( *aElements );

	CleanupStack::PushL( xResponses );

    iServerTransaction->SendResponseL( xResponses );

    MCESRV_DEBUG_DVALUE( 

        "CMceReliableSender::SendResponseL - timer value:", iRetransTimer );

    CleanupStack::Pop( xResponses );

   	iResponseElements = aElements;  

   	queueTimer = iRetransTimer * iT1 *KConversionMilliToMicro;

	iDTimer->Queue( queueTimer, iDeltaEntry );

    iRetransTimer = iRetransTimer * KTransInterval;    

    }

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

// CMceReliableSender::ResponseCloneL

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

//

CSIPResponseElements* CMceReliableSender::ResponseCloneL( 

                                            CSIPResponseElements& aElements )

    {

	CSIPResponseElements* cElements = 

	    CSIPResponseElements::NewLC( aElements.StatusCode(), 

	                                 aElements.ReasonPhrase() );

	// Creating messge Elements

	CSIPMessageElements& msgElements = aElements.MessageElements();

	CSIPMessageElements& cloneMsgElements = cElements->MessageElements();

	// Copying Contents 

	if  ( msgElements.Content().Length() )

	    {

    	const CSIPContentTypeHeader* contentType = msgElements.ContentType();

		CSIPContentTypeHeader* cloneContentType = 

		    static_cast<CSIPContentTypeHeader *>( contentType->CloneL() );

		CleanupStack::PushL( cloneContentType );

		HBufC8* contentBuffer = HBufC8::NewLC( msgElements.Content().Length() );

		TPtr8 contentsPtr = contentBuffer->Des();

		contentsPtr.Append( msgElements.Content() );

		cloneMsgElements.SetContentL( contentBuffer, cloneContentType );

		CleanupStack::Pop( contentBuffer );

		CleanupStack::Pop( cloneContentType );

    	}

  	// User Headers

	const RPointerArray<CSIPHeaderBase>& headers = msgElements.UserHeaders();

	if  ( headers.Count() )

	    {

		RPointerArray<CSIPHeaderBase> tmpHeaders;

		CSIPHeaderBase::PushLC( &tmpHeaders );

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

		    {

			CSIPHeaderBase* userHeader = headers[i]->CloneL();

			CleanupStack::PushL( userHeader );

			tmpHeaders.AppendL( userHeader );

			CleanupStack::Pop( userHeader );

		    }

		cloneMsgElements.SetUserHeadersL( tmpHeaders );

		CleanupStack::Pop( &tmpHeaders );

	    }

    CleanupStack::Pop( cElements );

	return cElements;

    }

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

// CMceReliableSender::PrackReceived

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

//

TBool CMceReliableSender::PrackReceived( CSIPServerTransaction& aPrack )

    {

	TBool transactionMatched = EFalse;

	RStringF rackHeaderStr = SIPStrings::StringF( SipStrConsts::ERAckHeader );

	RStringF rseqStr = SIPStrings::StringF( SipStrConsts::ERSeqHeader );

	const CSIPRequestElements* reqElements = aPrack.RequestElements();

	CSIPHeaderBase*	headerBase = 

	    MceSip::FindHeader( reqElements->MessageElements(), rackHeaderStr );

	const CSIPRAckHeader* rackHeader = static_cast<CSIPRAckHeader *>( headerBase );

	const CSIPRequestElements* sReqElements = iServerTransaction->RequestElements();    

    const CSIPCSeqHeader* cseqHeader = sReqElements->CSeqHeader();

    CSIPHeaderBase* headerBase3 =  

        MceSip::FindHeader( iResponseElements->MessageElements(), rseqStr );

    const CSIPRSeqHeader* rseqHeader = static_cast<CSIPRSeqHeader *> ( headerBase3 );

   	if  ( ( rackHeader && cseqHeader && rseqHeader ) && 

   	    ( rackHeader->CSeqNum() == cseqHeader->Seq() ) &&

	    ( rackHeader->Method() == sReqElements->Method() ) && 

	    ( rackHeader->Seq() == rseqHeader->Value()) )

	    {

	    MCESRV_DEBUG( "CMceReliableSender::PrackReceived: prack matched");

	    transactionMatched = ETrue;

        }

    if  ( transactionMatched )

	    {

        // Cease the Re-Transmission of Reliable Response 

        iDTimer->Remove( iDeltaEntry ); 

        iTransactionMatched = ETrue;

        iTransactionStatus = EFalse;    

      	return ETrue;

  	    }

    MCESRV_DEBUG( "CMceReliableSender::PrackReceived: no prack matched");

    return EFalse;

    }

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

// CMceReliableSender::TimerExpire

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

//

TInt CMceReliableSender::TimerExpire( TAny *aSelf )

    { 

    TInt error;

    TUint queueTimer;

    TUint tmpTotalTime;

    CMceReliableSender* me = static_cast<CMceReliableSender *>( aSelf );

    if ( !me->iTransTimeoutFlag )        

        {

        TRAP(error, me->CloneAndSendResponseL());

        if ( error )

            {

            me->iObserver->ReliableFailed( *me->iServerTransaction, error );

            }

        }

    else 

        {

        me->TimeOut( me->iServerTransaction );    

        }

	if ( me->iRetransTimer <= KMaxTransTimeOut && me->iTransactionStatus )

		{

	    tmpTotalTime = me->iTotaltime;

		me->iTotaltime = me->iTotaltime + me->iRetransTimer; // acumlated time

		if ( me->iTotaltime <= KMaxTransTimeOut )

		    {

		    queueTimer = me->iRetransTimer * me->iT1 * KConversionMilliToMicro;

		    }

        else 

           {

            me->iTotaltime = tmpTotalTime;

            queueTimer = ( KMaxTransTimeOut - me->iTotaltime ) * me->iT1 * KConversionMilliToMicro;

            me->iTransTimeoutFlag = ETrue;

            }

        me->iDTimer->Queue( queueTimer, me->iDeltaEntry );

        me->iRetransTimer = me->iRetransTimer * KTransInterval;

        MCESRV_DEBUG_DVALUE( 

		"CMceReliableSender::TimerExpire: timer added", me->iRetransTimer );

		}

	return KErrNone;

    }

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

// CMceReliableSender::CloneAndSendResponseL 

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

//

void CMceReliableSender::CloneAndSendResponseL()

    {

    CSIPResponseElements* oResponses;

    oResponses = ResponseCloneL( *iResponseElements );

    MCESRV_DEBUG( 

        "CMceReliableSender::CloneAndSendResponseL: responseElements cloned");

    CleanupStack::PushL( oResponses );

    iServerTransaction->SendResponseL( oResponses );

    MCESRV_DEBUG( 

        "CMceReliableSender::CloneAndSendResponseL: reliableResponse sent");

    CleanupStack::Pop( oResponses );

    }

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

// CMceReliableSender::TimeOut

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

//

void CMceReliableSender::TimeOut( CSIPServerTransaction* aTransaction )

    {  

	iObserver->NoPrackReceived( *aTransaction ); 

	}

// End of File