// Copyright (c) 2003-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:

// Implements the Message sender that just

// resends messages until  max retry or max count has been reached

// max retry and max count are constants

// 

//

/**

 @file MsgSender.cpp

 @internalTechnology

*/

#include "DHCP_Std.h"

#include "DHCPServer.h"

#include "MsgSender.h"

#include <in_sock.h>

#include <es_sock.h>

#include "DHCPAuthentication.h"

#include "DHCPIP4StateMachine.h"

CMessageSender::~CMessageSender()

/**

  * Destructor for message sender

  *

  * @internalTechnology

  */

	{

	Cancel();

	delete iMsg;

	delete iExpireTimer;

	}

void CMessageSender::DoCancel()

/**

  * Specific cancel implementation for message sender

  *

  * @internalTechnology

  */

	{

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CMessageSender::DoCancel")));

	iSocket.CancelSend();

	}

void CMessageSender::Cancel()

/**

  * Specific cancel implementation overriding CActive's implemention

  *

  * @internalTechnology

  */

	{

	if (iExpireTimer)

		{

		iExpireTimer->Cancel();

		}

	CActive::Cancel();

	if (IsAdded())

		{

		Deque();

		}

	}

void CMessageSender::TimerExpired()

/**

  * Ticking timer expired so resend the message

  *

  * @internalTechnology

  */

	{

    iRetryCount++;

    iRetryDuration += iMicroSecs.Int();

	TTime now;

	TTimeIntervalSeconds tempSecs;

	now.HomeTime(); 

	(void)now.SecondsFrom(iTaskStartedAtCopy, tempSecs);

	TUint16 time =static_cast<TUint16>(tempSecs.Int());

	if(CMessageSender::GetFamilyType() == KAfInet)

		{

		TUint8* elapsedOptionBody = const_cast<TUint8*>(iMsg->Des().Ptr()) + DHCPv4::KLengthUptoSecs;

		TBigEndian::SetValue( elapsedOptionBody, DHCPv4::KSecsElapsedLength, time );

		}

    if ( SendingContinues() )

        {

		__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CMessageSender::TimerExpired - SendTo")));

    	iSocket.SendTo(*iMsg, iAddr, 0, iStatus);

	    SetActive();

        }

    else

        {

		__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CMessageSender::TimerExpired - RunError")));

        RunError(KErrTimedOut);

        }

	}

void CMessageSender::SendL(TInetAddr& aAddr, const TDesC8& aMsg, TTimeIntervalMicroSeconds aSecs, TInt aRetryCount)

/**

  * Copy message and send the first time

  *

  * @internalTechnology

  */

	{

	iMaxRetryCount = aRetryCount;

   iRetryCount = -1; //the very first send doesn't count as a retry

   iRetryDuration = 0;

	iAddr = aAddr;

	if (!iMsg || iMsg->Des().MaxLength() < aMsg.Length())

		{

		delete iMsg;

		iMsg = NULL;

		iMsg = HBufC8::NewL(aMsg.Length());

		}

	iMsg->Des().Copy(aMsg);

	ASSERT(!IsAdded());

	CActiveScheduler::Add(this);

   	iMicroSecs = aSecs.Int64();

   if ( CalculateDelay() )

      {

      StartTimerL();

      }

   else

      {

      TimerExpired();

      }

	}

void CMessageSender::StartTimerL()

   {

	if (!iExpireTimer)

		{

		iExpireTimer = CExpireTimer::NewL();

		}

	iExpireTimer->After(iMicroSecs, *this);

   }

TBool CMessageSender::SendingContinues() const

   {

   if(iRetryCount == iMaxRetryCount /*DHCPv4::KReqMaxRetry*/)

   	{

   	return EFalse;

   	}

#ifdef _DEBUG

   TTimeIntervalMicroSeconds32 msec = KWaitForResponseTime * KMicrosecondsInSecs;

   if (CDHCPServer::DebugFlags() & KDHCP_SetShortRetryTimeOut)

      {

      msec = KDHCP_ShortRetryTimeOut * KMicrosecondsInSecs;

      }

   return iMicroSecs.Int()<=msec.Int();

#else

   return iMicroSecs.Int()<=static_cast<TInt>(KWaitForResponseTime * KMicrosecondsInSecs);

#endif

   }

TBool CMessageSender::CalculateDelay()

   {

   if ( iRetryCount > -1 )

      {// exponential backoff algorithm

	   //iMicroSecs = iMicroSecs.Int()*2;	

	   	iMicroSecs = iMicroSecs.Int() * 2;

      }

    return iRetryCount > -1;

   }

void CMessageSender::RunL()

/**

  * RunL called when the message has been sent. It checks the retransmition conditions

  * and either ends with timeout or re-sets the timer accordingly.

  *

  * @internalTechnology

  */

	{

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CMessageSender::RunL - %d"), iStatus.Int()));

	if ( !iMMSListener || iStatus.Int() == KErrNone 

			|| iMMSListener->MSReportError(iStatus.Int()) == KErrNone )

		{

        CalculateDelay();

        StartTimerL();

		}

	else

	    {

	    User::Leave(iStatus.Int());    

	    }

	}

TInt CMessageSender::RunError(TInt aError)

/**

  * RunError performs some cleanup after RunL leaves

  *

  * @internalTechnology

  */

	{

	if (iMMSListener)

		{

		if ( (aError = iMMSListener->MSReportError(aError)) == KErrNone )

         {//continue, no check for max values we assume that the listener knows what

         //it's doing

         ASSERT( iExpireTimer );

         ++iRetryCount;

         CalculateDelay();

			iExpireTimer->After(iMicroSecs, *this);

         }

		}

	return KErrNone;

	}