// 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 DHCP IP6 statemachine helper functions

// 

//

/**

 @file DHCPIP6StateMachine.cpp

 @internalTechnology

*/

#include "DHCPIP6States.h"

#include "DhcpIP6MsgRcvr.h"

#include "DHCPServer.h"

#ifdef _DEBUG

#include <e32property.h>

#endif

using namespace DHCPv6;

CDHCPIP6StateMachine::~CDHCPIP6StateMachine()

/**

  * Destructor of the If base class

  *

  * @internalTechnology

  *

  */

	{

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP6StateMachine::~CDHCPIP6StateMachine")));

   delete iMessageReader;

   iServerId.Close();

	}

#ifdef SYMBIAN_NETWORKING_ADDRESS_PROVISION

CDHCPIP6StateMachine* CDHCPIP6StateMachine::NewL(RSocketServ& aEsock, RConnection& aConnection, const TName& aInterfaceName, CDhcpHwAddrManager* aDhcpHwAddrManager)

/**

  * Creates a new instance of this class

  *

  * @internalTechnology

  *

  */

	{

	CDHCPIP6StateMachine* stateMachine = new (ELeave) CDHCPIP6StateMachine(aEsock, aConnection, aInterfaceName, aDhcpHwAddrManager);

	CleanupStack::PushL(stateMachine);

	stateMachine->ConstructL();

	CleanupStack::Pop(stateMachine);

	return stateMachine;

	}

#else

CDHCPIP6StateMachine* CDHCPIP6StateMachine::NewL(RSocketServ& aEsock, RConnection& aConnection, const TName& aInterfaceName)

/**

  * Creates a new instance of this class

  *

  * @internalTechnology

  *

  */

	{

	CDHCPIP6StateMachine* stateMachine = new (ELeave) CDHCPIP6StateMachine(aEsock, aConnection, aInterfaceName);

	CleanupStack::PushL(stateMachine);

	stateMachine->ConstructL();

	CleanupStack::Pop(stateMachine);

	return stateMachine;

	}

#endif //SYMBIAN_NETWORKING_ADDRESS_PROVISION

void CDHCPIP6StateMachine::ConstructL()

/**

  * Creates socket and connections for the object

  *

  *

  *	@internalTechnology

  *

  */

	{

   CDHCPStateMachine::ConstructL();

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP6StateMachine::ConstructL")));

  	ReAllocL(KDhcpInitMsgSizeIP6);

  	iDhcpMessage = new(ELeave)CDHCPMessageHeaderIP6(iFragment);

	iMessageReader = new(ELeave)CDhcpIP6MessageReader( *this );

	iMessageSender = new(ELeave)CDHCPIP6MessageSender(this,iSocket,&iTaskStartedAt,KAfInet6);

	}

void CDHCPIP6StateMachine::GetServerAddress( TInetAddr& aAddress )

{

	iInterfaceConfigInfo.GetServerAddress( aAddress );

}

void CDHCPIP6StateMachine::SetCurrentAddress(const TInetAddr& aCurrentAddress, const TInetAddr& /*aSubnetMask*/)

   {

   CDHCPStateMachine::SetCurrentAddress( aCurrentAddress );

   }

void CDHCPIP6StateMachine::StartInitL(MStateMachineNotify* aStateMachineNotify, EInitialisationContext aInitialisationContext, TInt aUserTimeOut )

/**

  * StartInitL

  *

  * This function is called to start the IP address solicitation state machine

  * we don't support rapid commit option for now

  *

  * @internalTechnology

  */

	{

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP6StateMachine::StartSolicitationL")));

	ASSERT(!iFirstState);//the states should be deleted by now or we are starting off

	SetIdle( EFalse );

	iInterfaceConfigInfo.Reset();

#ifdef SYMBIAN_ESOCK_V3

	if ( aInitialisationContext == CDHCPStateMachine::EFirstCall )

		{

		iFirstState = new(ELeave) CDHCPIP6ListenToNeighbor(*this);

		}

	else

#else

	(void)aInitialisationContext;

#endif

		{

		iFirstState = new(ELeave) CDHCPIP6Solicit(*this, aUserTimeOut);

		CDHCPState* state1 = new(ELeave)CDHCPIP6Select(*this);

		iFirstState->SetNext( state1 );

		CDHCPState* state2 = new(ELeave) CDHCPIP6Request(*this);

		state1->SetNext( state2 );

		state2->SetNext( new(ELeave) CDHCPIP6WaitForDAD(*this) );

		if (iStartInitCalls == CDHCPStateMachine::EFirstCall)

			{

			//This is the first time we're going to wait for a DCHP server. 

			//If there is no server it we will complete the client after one attempt 

			iStartInitCalls = aInitialisationContext;

			static_cast<CDHCPIP6Select*>(state1)->SetMaxRetryCount(1);

			}

		else

			{

			//We never found a DCHP server the first time, but this time try harder.

			static_cast<CDHCPIP6Select*>(state1)->SetMaxRetryCount(INT_MAX);

			}

		}

	CDHCPStateMachine::Start(aStateMachineNotify);

	}

#ifdef SYMBIAN_TCPIPDHCP_UPDATE

void CDHCPIP6StateMachine::StartInformL(MStateMachineNotify* aStateMachineNotify)

/**

  * This function is called to send inform message if options are not 

  * found in iValidMsg buffer

  *

  * @internalTechnology

  */

	{

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP6StateMachine::StartInformL Dynamic Inform Request")));

	ASSERT(!iFirstState);

	iFirstState = new(ELeave) CDHCPIP6InformRequest(*this);

	CDHCPState* request = new(ELeave) CDHCPIP6Request(*this);

	iFirstState->SetNext( request );

	CDHCPStateMachine::Start(aStateMachineNotify);

	}

#endif //SYMBIAN_TCPIPDHCP_UPDATE

void CDHCPIP6StateMachine::StartInformL(MStateMachineNotify* aStateMachineNotify, TBool /*aStaticAddress*/)

/**

  * StartInformL

  *

  * This function is called to start the inform for state-less configuration

  *

  * @internalTechnology

  */

	{

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP6StateMachine::EInformRequest")));

	ASSERT(!iFirstState); //the states should be deleted by now or we are starting off

    if (!iServerId.Length())

        {

	    iInterfaceConfigInfo.Reset();

        }

	iFirstState = new(ELeave) CDHCPIP6InformRequest(*this);

   CDHCPState* state1 = new(ELeave) CDHCPIP6Request(*this);

   iFirstState->SetNext( state1 );

	//static address is set but no wait for DAD here

	CDHCPStateMachine::Start(aStateMachineNotify);

	iCfgInfoOnly = ETrue;

	}

#ifdef SYMBIAN_NETWORKING_DHCPSERVER

void CDHCPIP6StateMachine::CreateOfferMsgL()

	{

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP6StateMachine::CreateOfferMsgL")));	

	}

void CDHCPIP6StateMachine::HandleRequestMsgL()//CreateRequestResponseMsgL()

	{

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP6StateMachine::CreateRequestResponseMsgL")));	

	}

void CDHCPIP6StateMachine::HandleInformMsgL()

	{

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP6StateMachine::HandleInformMsgL")));		

	}	

void CDHCPIP6StateMachine::PrepareToSendServerMsgL( CDHCPStateMachine::EAddressType /*aEAddressType*/)

/**

  * PrepareToSendL

  *

  * This function is called to set the correct destination address

  * for messages before they are sent.

  *

  * @internalTechnology

  */	

	{

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP6StateMachine::PrepareToSendL")));

	DhcpMessage()->Dump();

	iMessageSender->Cancel();

	}

void CDHCPIP6StateMachine::CloseNSendServerMsgL(TRequestStatus& /*aStatus*/, CDHCPStateMachine::EAddressType /*aEAddressType*/)

	{

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP6StateMachine::CloseNSendServerMsgL")));			

	}

CDHCPState* CDHCPIP6StateMachine::ReceiveOnPort67L( TRequestStatus* aStatus )

	{

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP6StateMachine::ReceiveOn67")));

	iDhcpMessage->InitialiseL();

   	iMessageReader->SetNext( iActiveEvent );

   	ASSERT( iReceiving == EFalse );

   	iReceiving = ETrue;

   	return static_cast<CDHCPState*>(iMessageReader->ProcessL( *aStatus ));

	}

void CDHCPIP6StateMachine::InitialiseServerSocketL()

	{

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP6StateMachine::InitialiseServerSocketL")));	

	}	

#endif // SYMBIAN_NETWORKING_DHCPSERVER

void CDHCPIP6StateMachine::StartRebootL(MStateMachineNotify* aStateMachineNotify)

/**

  * StartRebootL

  *

  * This function is called to start the confirm request state machine

  * used when trying to start using a previously assigned address still

  * with valid lease.

  *

  * @internalTechnology

  */

	{

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP6StateMachine::StartConfirmL")));

	ASSERT(!iFirstState);//the states should be deleted by now or we are starting off

   iFirstState = new(ELeave) CDHCPIP6Confirm(*this);

   CDHCPState* state1 = new(ELeave) CDHCPIP6Request(*this);

   iFirstState->SetNext( state1 );

   state1->SetNext( new(ELeave) CDHCPIP6WaitForDAD(*this) );

	CDHCPStateMachine::Start(aStateMachineNotify);

	}

void CDHCPIP6StateMachine::StartRenewL(MStateMachineNotify* aStateMachineNotify,TInt aUserTimeOut)

   {

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP6StateMachine::StartRenewL")));

	ASSERT(!iFirstState);

   iUserRebindTimeout = aUserTimeOut;

   iFirstState = new(ELeave) CDHCPIP6Renew(*this,aUserTimeOut);

   iFirstState->SetNext( new(ELeave) CDHCPIP6WaitForDAD(*this) );

	CDHCPStateMachine::Start(aStateMachineNotify);	

   }

void CDHCPIP6StateMachine::StartRebindL(MStateMachineNotify* aStateMachineNotify)

/**

  * StartRebindL

  *

  * This function is called to start the rebind state machine

  *

  * @internalTechnology

  */	

	{

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP6StateMachine::StartRebindL")));

	ASSERT(!iFirstState);//the states should be deleted by now or we are starting off

	iFirstState = new(ELeave) CDHCPIP6Rebind(*this,iUserRebindTimeout);

   iFirstState->SetNext( new(ELeave) CDHCPIP6WaitForDAD(*this) );

	CDHCPStateMachine::Start(aStateMachineNotify);

	}

void CDHCPIP6StateMachine::StartReconfigureL(MStateMachineNotify* aStateMachineNotify)

/**

  * StartReconfigureL

  *

  * This function is called to initialise waiting for the server reconfigure message.

  * The task ends once a valid reconfigure messageg's been received

  *

  * @internalTechnology

  */

{

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP6StateMachine::StartReconfigureL")));

	ASSERT(!iFirstState);//the states should be deleted by now or we are starting off

	iXid.SetXid( 0 );

	iFirstState = new(ELeave) CDHCPIP6Reconfigure(*this);

	CDHCPStateMachine::Start(aStateMachineNotify);

}

void CDHCPIP6StateMachine::StartDeclineL(MStateMachineNotify* aStateMachineNotify)

/**

  * StartDeclineL

  *

  * This function is called to start the decline task

  *

  * @internalTechnology

  */

	{

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP6StateMachine::StartDeclineL")));

	ASSERT(!iFirstState);//the states should be deleted by now or we are starting off

	if ( iInterfaceConfigInfo.AnyAddressToDecline() )

		{

		iFirstState = new(ELeave) CDHCPIP6Decline(*this);

   	iFirstState->SetNext( new CDHCPIP6ReplyNoBinding(*this) );	

		}

  	CDHCPStateMachine::Start(aStateMachineNotify);

	}

void CDHCPIP6StateMachine::StartReleaseL(MStateMachineNotify* aStateMachineNotify)

/**

  * StartReleaseL

  *

  * This function is called to start the release state machine

  *

  * @internalTechnology

  */

	{

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP6StateMachine::StartReleaseL")));

	ASSERT(!iFirstState);//the states should be deleted by now or we are starting off

	iFirstState = new(ELeave) CDHCPIP6Release(*this);

   iFirstState->SetNext( new(ELeave)CDHCPIP6ReplyNoBinding(*this) );	

	CDHCPStateMachine::Start(aStateMachineNotify);

	}

void CDHCPIP6StateMachine::PrepareToSendL( CDHCPStateMachine::EAddressType /*aEAddressType*/ )

/**

  * PrepareToSendL

  *

  * This function is called to set the correct destination address

  * for messages before they are sent.

  *

  * @internalTechnology

  */	

	{

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP6StateMachine::PrepareToSendL")));

	DhcpMessage()->Dump();

	iMessageSender->Cancel();

	}

void CDHCPIP6StateMachine::CloseNSendMsgL(TRequestStatus& /*aStatus*/, CDHCPStateMachine::EAddressType aEAddressType)

/**

  * Handles sending of packets for this object

  *

  * @internalTechnology

  *

  */

	{

	CDHCPStateMachine::CloseNSendMsgL(0,KInfinity,aEAddressType); //IPv6 calculates its own delay and retry values..so KInfinity is ignored

	}

void CDHCPIP6StateMachine::CancelMessageReceiver()

   {//doesn't cancel statemachine only the reader state

   if ( IsActive() && iReceiving )

      {

      ASSERT( !iErrorEvent );

   	CStateMachine::Cancel(KErrNone);//waits for the cancel to complete

      iActiveEvent = iMessageReader->Next();

      iReceiving = EFalse;

      //restart the state machine

      CStateMachine::Start(NULL, NULL, iStateMachineNotify);

      }

   }

CDHCPState* CDHCPIP6StateMachine::ReceiveL(TRequestStatus* aStatus)

/**

  * Starts iMessageReader state

  *

  * @internalTechnology

  *

  */

	{

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP6StateMachine::Receive")));

	iDhcpMessage->InitialiseL();

   iMessageReader->SetNext( iActiveEvent );

   ASSERT( iReceiving == EFalse );

   iReceiving = ETrue;

   return static_cast<CDHCPState*>(iMessageReader->ProcessL( *aStatus ));

	}

void CDHCPIP6StateMachine::OnCompletion()

{

   if (LastError() == KErrEof && iReceiving)

      {//end of datagram while reading a message => not an error => restart state machine

      iActiveEvent = iMessageReader->Next();

      CStateMachine::Start(NULL, NULL, iStateMachineNotify); //sets last error to KErrNone

      }

   else

      {

      CDHCPStateMachine::OnCompletion();

      }

}

void CDHCPIP6StateMachine::AssembleClientIDsL()

/**

  * Sets the client id - hardware address and type pair

  * 

  *

  */

	{

   /*client id and the way we generate it

     0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1

    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

    |               3               |    hardware type (16 bits)    |

    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

    .                                                               .

    .             link-layer address (variable length)              .

    .                                                               .

    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

   */

	FetchHWAddress();

	TUint htype = 0;

	if(iHardwareAddr.Family() != KAFUnspec)

		{

		iClientId.CreateL(KDuidTypeLen + KDuidHardwareTypeLen + iHardwareAddr.Length() - KHwAddrOffset);

		htype = iHardwareAddr.Family();		// should this be Port() ?

		}

	else 

		{

    	// This means we're on a point-to-point link (i.e. one with no hardware addressing).

    	//  We'll make client id look like an ethernet/mac address combo to reduce the chance of stupid servers getting upset

		__CFLOG_VAR((KLogSubSysDHCP, KLogCode,

						_L8("CDHCPIP6StateMachine::AssembleClientIDsL - no hardware address (suggesting point-to-point)"

						     " so generating a random 6 byte client id")));

		iClientId.CreateL(KDuidTypeLen + KDuidHardwareTypeLen + KDuidEthMacAddrSize);

		htype = 1;		// fake up as Ethernet

		}

	TBigEndian::SetValue(const_cast<TUint8*>(iClientId.Ptr()), KDuidTypeLen, KDuidLLTypeCode);	

	TBigEndian::SetValue(const_cast<TUint8*>(iClientId.Ptr()) + KDuidTypeLen, KDuidHardwareTypeLen, htype);

	iClientId.SetLength(KDuidTypeLen + KDuidHardwareTypeLen);

	if(iHardwareAddr.Family()!=KAFUnspec)

		{

	    iClientId.Append(iHardwareAddr.Mid(KHwAddrOffset, iHardwareAddr.Length() - KHwAddrOffset));

		}

	else 

		{

		// Note: if you increase the number of bytes appended here, then be sure to

		// increase the size passed to iClientId.CreateL() above.

    	TUint32 data = Math::Random();

		iClientId.Append(TPckgC<TUint32>(data));

		iClientId.Append(TPckgC<TUint16>(data));

		}

	}

TUint CDHCPIP6StateMachine::GetMessageType() const

/**

  * Parses the message and returns the message type from the DHCP message

  * i.e. whether the message is an advertise. reply, reconfigure

  *

  * @internalTechnology 

  */

	{

	CDHCPMessageHeaderIP6* v6Msg = DhcpMessage();

	if ( v6Msg->Parse(iXid,iClientId,iServerId) == KErrNone )

      {

	   v6Msg->Dump();	

   	return v6Msg->GetMessageType();

      }

   return EUnknown;

	}

void CDHCPIP6StateMachine::SetMessageHeaderL( TMessageType aMsgType )

/**

  * Sets the message header

  *

  * @internalTechnology

  */

	{

	iXid.Init6(); //generate random transaction Id

	iTaskStartedAt.HomeTime();	// set time stamp to now

	CDHCPMessageHeaderIP6* v6Msg = DhcpMessage();

	v6Msg->InitialiseL();

	v6Msg->SetXid(iXid.Xid());

	v6Msg->SetMessageType(static_cast<TUint8>(aMsgType));

	// +++++++++++++++++++++++ Elapsed Time +++++++++++++++++++++++++++++++++++++++++/	

	//EElapsedTime option MUST be the first option in the option part of the message

	//see CDHCPIP6MessageSender::SendingContinues fn

   v6Msg->AddOptionL(EElapsedTime, KElapsedTimeOptionLen)->SetBigEndian( 0 );

	// +++++++++++++++++++++++ Client Id +++++++++++++++++++++++++++++++++++++++++/	

	v6Msg->AddOptionL(EClientId, iClientId.Length())->GetBodyDes().Copy(iClientId);

	// +++++++++++++++++++++++ Server ID +++++++++++++++++++++++++++++++++++++++++/

   //included only when it exists

   if ( iServerId.Length() )

      {

      v6Msg->AddOptionL(EServerId, iServerId.Length())->GetBodyDes().Copy(iServerId);