// 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:

// Implements the DHCPv4 States representing each interface

// 

//

/**

 @file DHCPIP6States.cpp

 @internalTechnology

*/

#include "DHCPIP6States.h"

#include "DhcpIP6Msg.h"

#include "DHCPIP6MsgSender.h"

#include "DHCPServer.h"

#include "DHCPStatesDebug.h"

using namespace DHCPv6;

#ifdef SYMBIAN_ESOCK_V3

CDHCPIP6ListenToNeighbor::~CDHCPIP6ListenToNeighbor()

	{

	if ( iNetSubscribe )

		{

		iEvent.Cancel(*iNetSubscribe);

		}

	}

CAsynchEvent* CDHCPIP6ListenToNeighbor::ProcessL(TRequestStatus& aStatus)

	{

	DHCP_DEBUG_PUBLISH_STATE(DHCPDebug::EDHCPIP6ListenToNeighbor);

	//(static_cast<TEvent*>(this)->*iHandler)();

	CDHCPIP6StateMachine& stmachine = DHCPIPv6();

	//set us as an error event as well so that we catch the leave and can deregister if needed

	stmachine.SetErrorEvent( this );

	stmachine.CancelTimer();

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP6ListenToNeighbor::ProcessL err %d"), stmachine.LastError()));

	if ( iErr == KErrNone )

		{

		iErr = stmachine.LastError();

		if ( iErr == KErrNone || (iQuery && iQuery->iHandle) )

			{//we can get here only when we want to subscribe or unsubscribe

			SubscribeL( stmachine.InterfaceName(), IPEvent::EMFlagReceived, iEvent );

			}

		}

	if ( iErr == KErrNone && iQuery && iQuery->iHandle )

		{//start timer in case we never get the signal

		__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP6ListenToNeighbor::ProcessL wait signal StartTimer")));

		// The 14 second timeout comes from the 3x4 seconds the IP stack waits for RouterAdvs once it's sent out

		// its 3 RouterSols ... plus a bit for processing. Search for iRtrSolicitationInterval in tcpip/src/iface.cpp

		stmachine.StartTimer( TTimeIntervalSeconds(14)/*seconds*/, *this );

		aStatus = KRequestPending;

		stmachine.SetAsyncCancelHandler(this);

		}

	else

		{//we're deregistered => start statemachine based on 'M' flag value

		ASSERT( this == DHCPIPv6().iFirstState );

	    CleanupStack::PushL(this);

		stmachine.iFirstState = NULL;

		stmachine.SetErrorEvent( NULL );

		if (iErr == KErrTimedOut)

			{

			TimerExpired();

			}

		else 

			{

			// RA received

			if ( iMFlag )

				{

				__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("MFlag true. - Proceeding with Stateful")));

				stmachine.StartInitL( NULL, CDHCPStateMachine::ESubsequentCalls );

				}

			else

				{

				if( iOFlag )

					{

					__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("MFlag false, OFlag True - stateful autoconfiguration to get non-IPv6-address information")));

					CompleteClientAndStartInform();		// complete client, as 'O' flag set - stateful autoconfiguration to get non-IPv6-address information

					}

				else 

					{

					BecomeIdle();	// 'M' and 'O' flags are false	

					}

				}

			}

		CleanupStack::PopAndDestroy(this);

		return stmachine.iFirstState;

		}

	stmachine.SetLastError( KErrNone ); //ignore the error

	return this;

	}

/*static*/

void CDHCPIP6ListenToNeighbor::SignalHandlerFn( TAny* aThis, const Meta::SMetaData* aData )

	{

	//Router Advt received, decide upon 'M' and 'O' flags

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP6ListenToNeighbor::SignalHandlerFn()")));

	CDHCPIP6ListenToNeighbor* inst = reinterpret_cast<CDHCPIP6ListenToNeighbor*>(aThis);

	CDHCPIP6StateMachine& stmachine = inst->DHCPIPv6();

	inst->iMFlag = static_cast<const IPEvent::CMFlagReceived*>(aData)->GetMFlag();

	inst->iOFlag = static_cast<const IPEvent::CMFlagReceived*>(aData)->GetOFlag();

	stmachine.CancelTimer();

	TRequestStatus* p = &stmachine.iStatus;

	User::RequestComplete( p, KErrNone );

    stmachine.SetAsyncCancelHandler(NULL);

	}

void CDHCPIP6ListenToNeighbor::Cancel()

	{	

	CDHCPIP6StateMachine& stmachine = DHCPIPv6();

	stmachine.CancelTimer();

	TRequestStatus* p = &stmachine.iStatus;

   	User::RequestComplete( p, KErrCancel );

	stmachine.SetAsyncCancelHandler(NULL);

	}

void CDHCPIP6ListenToNeighbor::BecomeIdle()

	{

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP6ListenToNeighbor::BecomeIdle()")));

	CDHCPIP6StateMachine& stmachine = DHCPIPv6();

	TRequestStatus* p = &stmachine.iStatus;

	stmachine.SetIdle( ETrue );

   	User::RequestComplete( p, KErrNone );

   	stmachine.SetAsyncCancelHandler(NULL);

	}

void CDHCPIP6ListenToNeighbor::CompleteClientAndStartInform()

	{

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP6ListenToNeighbor::CompleteClientAndStartInform()")));

	CDHCPIP6StateMachine& stmachine = DHCPIPv6();

	TRequestStatus* p = &stmachine.iStatus;

	stmachine.SetCompleteClientRequestTrue();

   	User::RequestComplete( p, KErrNone );

   	stmachine.SetAsyncCancelHandler(NULL);

	}

void CDHCPIP6ListenToNeighbor::TimerExpired()

	{

	//start state-ful config since no signal received

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP6ListenToNeighbor::TimerExpired()")));

	CDHCPIP6StateMachine& stmachine = DHCPIPv6();

	TRequestStatus* p = &stmachine.iStatus;

   	User::RequestComplete( p, KErrTimedOut );

   	stmachine.SetAsyncCancelHandler(NULL);

	}

#endif

/** our selection criteria so far

 *  -  the first advertise msg received or the one with the highest

 *     preference value

 *

 *  some smarter selection criteria for server advertisements:

 *  -  Within a group of Advertise messages with the same server

 *     preference value, a client MAY select those servers whose

 *     Advertise messages advertise information of interest to the

 *     client.  For example, the client may choose a server that returned

 *     an advertisement with configuration options of interest to the

 *     client.

 *

 *  -  The client MAY choose a less-preferred server if that server has a

 *     better set of advertised parameters, such as the available

 *     addresses advertised in IAs.

*/

CAsynchEvent* CDHCPIP6Solicit::ProcessL(TRequestStatus& aStatus)

   {

   DHCP_DEBUG_PUBLISH_STATE(DHCPDebug::EDHCPIP6Solicit);

   CDHCPIP6MessageSender* pSender = DHCPIPv6().MessageSender();

   //ask for a signal after the first RT elapses

   pSender->SetMaxRetryCount( 1 );

   pSender->SetMaxRetryTimeout( DHCPv6::KSolMaxRt );

   TInt n = KIP6MaxSecs;

   if( iUserDefinedTimeout != 0 )

	   	{

	   	n = iUserDefinedTimeout;

	   	}   	

   pSender->SetMaxRetryDuration( n );

   pSender->SetInitialRetryTimeout( DHCPv6::KSolTimeout );

   pSender->SetFirstSendDelay( DHCPv6::KSolMaxDelay );

   //here we know that select follows after solicit

   pSender->SetListener(static_cast<CDHCPIP6Select*>(iNext));

   return CDHCPAddressAcquisition::ProcessL( aStatus );

   }

void CDHCPIP6Select::SetMaxRetryCount(TInt aMaxRetryCount)

	{

	iMaxRetryCount = aMaxRetryCount;

	}

const TInt KAdvertOverridePref = 255;

CAsynchEvent* CDHCPIP6Select::ProcessL(TRequestStatus& aStatus)

   {//called when a message's been received or state's changed for us

   DHCP_DEBUG_PUBLISH_STATE(DHCPDebug::EDHCPIP6Select);

   CDHCPIP6StateMachine& rDHCP = DHCPIPv6();

   CDHCPIP6MessageSender* pSender = rDHCP.MessageSender();

   CDHCPMessageHeaderIP6* v6Msg = rDHCP.DhcpMessage();

	if(rDHCP.iReceiving || iDone)

		{	// we're waiting to receive data from the socket

		/*

		collect advertisements so long we are waiting for the first retransmition timeout.

		Keep the first one and check the others for

		preference option with a pref value of 255. If the client receives an Advertise message 

		that does not include a Preference option with a preference value of 255, the

		client continues to wait until the first RT elapses 

		if pSender->Notifier() != this than the first RT's elapsed => we're happy

		with any message that is a valid advertisement

		*/

     	rDHCP.iReceiving = EFalse;

		if(rDHCP.GetMessageType() == DHCPv6::EAdvertise)

			{	

			/* 

			examine the message and make decision based on the aforementioned 

         	selection criteria

         	*/         	

         DHCPv6::COptionNode* option = v6Msg->GetOptions().FindOption(DHCPv6::EPreference);

         	 TInt serverPreference;

	         if (option)

	         	{

	         	serverPreference = option->GetBigEndian();

	         	}

	         else

	         	{

	         	serverPreference = 0;

	         	}           	

         	if(pSender->EventListener() != this || iDone || serverPreference == KAdvertOverridePref)

					{

					// We're not interested in further notifications

					pSender->SetListener( &rDHCP );

					// Set-up sender, consume selected advertisement & initiate request

					// message

					pSender->SetMaxRetryCount(DHCPv6::KReqMaxRc);

					pSender->SetMaxRetryTimeout(DHCPv6::KReqMaxRt);

					pSender->SetMaxRetryDuration(KIP6MaxSecs);

					pSender->SetInitialRetryTimeout(DHCPv6::KReqTimeout);

					pSender->SetFirstSendDelay(0);

					if ( !iDone/*see CDHCPIP6Select::MSReportError*/ && iSelectedMessage.Length() )

						{

						// Copy the selected message back the max length must be enough since we've read

						//iSelectedMessage into the v6Msg buffer

            		v6Msg->Message().Des().Copy(iSelectedMessage);

						}

            	return CDHCPSelect::ProcessL(aStatus);

					}

				else

					{	// Work out if this advertisment's better for us

					if(serverPreference > iBestServerPreference )

						{

						iBestServerPreference = serverPreference;

						// Store a copy away for later

						TInt ret= iSelectedMessage.ReAlloc(v6Msg->Message().Length());

						if (ret == KErrNone)

							iSelectedMessage.Copy(v6Msg->Message());

						else

							User::LeaveIfError(ret);						

						}

					}

			}

		}

   	// wait for a message (next or the first)

	return rDHCP.ReceiveL(&aStatus);

   }

/*

	This method is called when the retransmission timer expires.

*/

TInt CDHCPIP6Select::MSReportError(TInt aError)

   {//called when the first RT's expired

   CDHCPIP6StateMachine& rDHCP = DHCPIPv6();

   CDHCPIP6MessageSender* pSender = rDHCP.MessageSender();

	if(aError == KErrTimedOut)

		{

		/*

		the first RT's elapsed so check the collected messages

		if we have one (the first one) we're done if not we start the sender again

		*/

		if (iBestServerPreference != -1)

			{

			pSender->Cancel();

			iDone = ETrue;

			rDHCP.CancelMessageReceiver();

			// Copy the selected message back the max length must be enough since we've read

			//iSelectedMessage into the v6Msg buffer

         rDHCP.DhcpMessage()->Message().Des().Copy(iSelectedMessage);

			return aError;

			}

		else

			{

			// We're not interested in further notifications

			pSender->SetListener(&rDHCP);

			pSender->SetMaxRetryCount(iMaxRetryCount);

			return KErrNone; // Causes the sender to continue

			}

		}

	// Something else's gone wrong => report it up

	pSender->SetListener(&rDHCP);

	return rDHCP.MSReportError(aError);

	}

CDHCPIP6Select::~CDHCPIP6Select()

	{

	iSelectedMessage.Close();

	}

CAsynchEvent* CDHCPIP6InformRequest::ProcessL(TRequestStatus& aStatus)

   {

   DHCP_DEBUG_PUBLISH_STATE(DHCPDebug::EDHCPIP6InformRequest);

   CDHCPIP6MessageSender* pSender = DHCPIPv6().MessageSender();

   pSender->SetMaxRetryCount( INT_MAX );

   pSender->SetMaxRetryTimeout( DHCPv6::KInfMaxRt );

   pSender->SetMaxRetryDuration( KIP6MaxSecs );

   pSender->SetInitialRetryTimeout( DHCPv6::KInfTimeout );

   pSender->SetFirstSendDelay( DHCPv6::KInfMaxDelay );

   return CDHCPInformationConfig::ProcessL( aStatus );

   }

CAsynchEvent* CDHCPIP6Release::ProcessL(TRequestStatus& aStatus)

   {

   DHCP_DEBUG_PUBLISH_STATE(DHCPDebug::EDHCPIP6Release);

   CDHCPIP6MessageSender* pSender = DHCPIPv6().MessageSender();

   pSender->SetMaxRetryCount( DHCPv6::KRelMaxRc );

   pSender->SetMaxRetryTimeout( KIP6MaxSecs );

   pSender->SetMaxRetryDuration( KIP6MaxSecs );

   pSender->SetInitialRetryTimeout( DHCPv6::KRelTimeout );

   pSender->SetFirstSendDelay( 0 );

   CDHCPRelease::ProcessL( aStatus ); //this fn doesn't actually complete status for v6

   iStateMachine->SetActiveEvent( iNext ); //to shift the state after the receiver is ready

	return DHCPIPv6().ReceiveL( &aStatus );

   }

CAsynchEvent* CDHCPIP6Decline::ProcessL(TRequestStatus& aStatus)

   {

   DHCP_DEBUG_PUBLISH_STATE(DHCPDebug::EDHCPIP6Decline);

   CDHCPIP6MessageSender* pSender = DHCPIPv6().MessageSender();

   pSender->SetMaxRetryCount( DHCPv6::KDecMaxRc );

   pSender->SetMaxRetryTimeout( KIP6MaxSecs );

   pSender->SetMaxRetryDuration( KIP6MaxSecs );

   pSender->SetInitialRetryTimeout( DHCPv6::KDecTimeout );

   pSender->SetFirstSendDelay( 0 );

   CDHCPDecline::ProcessL( aStatus );  //this fn doesn't actually complete status for v6

   iStateMachine->SetActiveEvent( iNext ); //to shift the state after the receiver is ready

	return DHCPIPv6().ReceiveL( &aStatus );

   }

CDHCPState* CDHCPIP6ReplyNoBinding::ProcessAckNakL(TRequestStatus* aStatus)

   {

   CDHCPIP6StateMachine& rDHCP = DHCPIPv6();

   if ( rDHCP.GetMessageType() == DHCPv6::EReply )

      {

      rDHCP.CancelMessageSender();

		rDHCP.iReceiving = EFalse;

		User::RequestComplete(aStatus, KErrNone);

      return static_cast<CDHCPState*>(iNext);

      }

   return rDHCP.ReceiveL( aStatus );

   }

CAsynchEvent* CDHCPIP6Confirm::ProcessL(TRequestStatus& aStatus)

   {

   DHCP_DEBUG_PUBLISH_STATE(DHCPDebug::EDHCPIP6Confirm);

   CDHCPIP6MessageSender* pSender = DHCPIPv6().MessageSender();

   pSender->SetMaxRetryCount( INT_MAX );

   pSender->SetMaxRetryTimeout( DHCPv6::KCnfMaxRt );

   pSender->SetMaxRetryDuration( DHCPv6::KCnfMaxRd );

   pSender->SetInitialRetryTimeout( DHCPv6::KCnfTimeout );

   pSender->SetFirstSendDelay( DHCPv6::KCnfMaxDelay );

   return CDHCPRebootConfirm::ProcessL( aStatus );

   }

#if 0

CAsynchEvent* CDHCPIP6WaitForDAD::ProcessL(TRequestStatus& aStatus)

	{

   DHCP_DEBUG_PUBLISH_STATE(DHCPDebug::EDHCPIP6WaitForDAD);

   CDHCPIP6StateMachine& rDHCP = DHCPIPv6();

	rDHCP.StartTimer(KOneSecond*20, *this); // 20 secs timer in case there's no response from IPNotifier.

	if (iAddressIndex == 1 && !CSubscribeChannel::ListenL(aStatus,event,rDHCP.C32Root()))

		{

		return this;

		}

	else 

		{

		//read channel data and if success then attempt to bind to verify the result

		if ( rDHCP.ConfigureInterface( iAddressIndex++ ) )

			{//set the next address as iCurrentAddress

			//and listen for DAD

			CSubscribeChannel::ListenL(aStatus,event,rDHCP.C32Root());

			return this;

			}

		}

	return iNext;

	}

#else

CAsynchEvent* CDHCPIP6WaitForDAD::ProcessL(TRequestStatus& aStatus)

	{

   DHCP_DEBUG_PUBLISH_STATE(DHCPDebug::EDHCPIP6WaitForDAD);

   CDHCPIP6StateMachine& rDHCP = DHCPIPv6();

	if (iAddressIndex == 0)

		{//start the first wait

		iAddressIndex++;

		CDHCPWaitForDADBind::ProcessL( aStatus );

		return this;

		}

	else if ( iErr != KErrNone )

		{//Mark the iAddressIndex as invalid and attempt to bind the next one

		rDHCP.iInterfaceConfigInfo.SetAddressStatus( iAddressIndex -1, DHCPv6::EMarkForDecline );

		rDHCP.ConfigureInterfaceL( iAddressIndex++ );

		//listen for DAD

		CDHCPWaitForDADBind::ProcessL( aStatus );

		return this;

		}

	else

		{//Mark all but iAddressIndex as invalid

		}

	TRequestStatus* p = &aStatus;

	User::RequestComplete(p, iErr);

	return iNext;

	}

void CDHCPIP6WaitForDAD::TimerExpired()

	{

	CDHCPWaitForDADBind::TimerExpired();

	CDHCPStateMachine& rDHCP = Dhcp();

	if ( !rDHCP.TimerActive() )

		{

		//finish either => bound or not => bouncwe back to CDHCPIP6WaitForDAD::ProcessL

		TRequestStatus* p = &iStateMachine->iStatus;

		User::RequestComplete(p, KErrNone); //proceed back to the process function

		rDHCP.SetAsyncCancelHandler(NULL);

		}

	}

#endif

CAsynchEvent* CDHCPIP6Renew::ProcessL(TRequestStatus& aStatus)

   {

   DHCP_DEBUG_PUBLISH_STATE(DHCPDebug::EDHCPIP6Renew);

   CDHCPIP6StateMachine& rDHCP = DHCPIPv6();

   CDHCPIP6MessageSender* pSender = rDHCP.MessageSender();

   pSender->SetMaxRetryCount( INT_MAX );

   pSender->SetMaxRetryTimeout( DHCPv6::KRenMaxRt );

   TInt n = rDHCP.iRebindTimeT2 - rDHCP.iRenewalTimeT1;

   if(iUserDefinedTimeout)

	   	{

	   	n = iUserDefinedTimeout;

	   	}

   else if ( n <= 0 )

	   	{

	   	n = 2; //2 seconds

	   	}   	

   pSender->SetMaxRetryDuration( n );

   pSender->SetInitialRetryTimeout( DHCPv6::KRenTimeout );

   pSender->SetFirstSendDelay( 0 );

   return CDHCPRenew::ProcessL( aStatus );

   }

CAsynchEvent* CDHCPIP6Rebind::ProcessL(TRequestStatus& aStatus)

   {

   DHCP_DEBUG_PUBLISH_STATE(DHCPDebug::EDHCPIP6Rebind);

   CDHCPIP6StateMachine& rDHCP = DHCPIPv6();

   CDHCPIP6MessageSender* pSender = rDHCP.MessageSender();

   pSender->SetMaxRetryCount( INT_MAX );

   pSender->SetMaxRetryTimeout( DHCPv6::KRebMaxRt );

   TInt n = rDHCP.iLeaseTime - rDHCP.iRebindTimeT2;

   if(iUserDefinedTimeout)

	   	{

	   	n = iUserDefinedTimeout;

	   	}

   else if ( n <= 0 )

	   	{

	   	n = 2; //2 seconds

	   	}   

   pSender->SetMaxRetryDuration( n );

   pSender->SetInitialRetryTimeout( DHCPv6::KRebTimeout );

   pSender->SetFirstSendDelay( 0 );

   return CDHCPRebind::ProcessL( aStatus );

   }

CAsynchEvent* CDHCPIP6Reconfigure::ProcessL(TRequestStatus& aStatus)

    {

	DHCP_DEBUG_PUBLISH_STATE(DHCPDebug::EDHCPIP6Reconfigure);

	CDHCPIP6StateMachine& rDHCP = DHCPIPv6();

	if (!rDHCP.iReceiving)

	    {

        rDHCP.InitialiseSocketL();

	    }

	return CDHCPRequest::ProcessL(aStatus);

    }

CDHCPState* CDHCPIP6Reconfigure::ProcessAckNakL(TRequestStatus* aStatus)

   {//check for reconfigure reply msg

   CDHCPIP6StateMachine& rDHCP = DHCPIPv6();

   if ( rDHCP.GetMessageType() == DHCPv6::EReconfigure )

      {

		rDHCP.iReceiving = EFalse;

		User::RequestComplete(aStatus, KErrNone);

      return static_cast<CDHCPState*>(iNext);

      }