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

// 

//

/**

 @file DHCPIP4StateMachine.cpp

 @internalTechnology

*/

#include <babitflags.h>

#include <e32math.h>

#include "DHCPIP4States.h"

#include "DHCPServer.h"

#ifndef SYMBIAN_COMMS_REPOSITORY

#include <commdb.h>

#else

#include <metadatabase.h>

#include <commsdattypesv1_1.h>

#endif

#ifdef SYMBIAN_NETWORKING_ADDRESS_PROVISION

#include "dhcphwaddrmanager.h"

#endif //SYMBIAN_NETWORKING_ADDRESS_PROVISION

using namespace DHCPv4;

#ifdef SYMBIAN_COMMS_REPOSITORY

using namespace CommsDat;

#endif

#ifdef SYMBIAN_NETWORKING_DHCPSERVER

const TUint16 KBroadCastFlagMask = 0x8000;

#endif

CDHCPIP4StateMachine::~CDHCPIP4StateMachine()

/**

  * Destructor of the If base class

  *

  * @internalTechnology

  *

  */

	{

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

	}

#ifndef SYMBIAN_NETWORKING_DHCPSERVER

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

/**

  * Creates a new instance of this class

  *

  * @internalTechnology

  *

  */

	{

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

	CleanupStack::PushL(stateMachine);

	stateMachine->ConstructL();

	CleanupStack::Pop(stateMachine);

	return stateMachine;

	}

#endif // SYMBIAN_NETWORKING_DHCPSERVER

void CDHCPIP4StateMachine::ConstructL()

/**

  * Creates socket and connections for the object

  *

  *

  *	@internalTechnology

  *

  */

	{

   CDHCPStateMachine::ConstructL();

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

  	ReAllocL(KDhcpMaxMsgSizeIP4);

  	iDhcpMessage = new(ELeave)CDHCPMessageHeaderIP4(iFragment);

	iMessageSender = new(ELeave)CMessageSender(this,iSocket,&iTaskStartedAt,KAfInet);

	}

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

/**

  * StartInitL

  *

  * This function is called to start the init state machine

  *

  * @internalTechnology

  */

	{

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP4StateMachine::StartInitL")));

	ASSERT(!iFirstState);

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

	CDHCPState* select = new(ELeave) CDHCPIP4Select(*this);

	iFirstState->SetNext( select );

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

	select->SetNext( request );

	request->SetNext( new(ELeave) CDHCPIP4WaitForDAD(*this) );

	CDHCPStateMachine::Start(aStateMachineNotify);

	}

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

/**

  * StartIniformL

  *

  * This function is called to start the inform static address state machine

  *

  * @internalTechnology

  */

	{

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP4StateMachine::StartInformL")));

	ASSERT(!iFirstState);

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

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

   iFirstState->SetNext( request );

   request->SetNext( new(ELeave) CDHCPIP4WaitForDAD(*this) );

	CDHCPStateMachine::Start(aStateMachineNotify);

	iCfgInfoOnly = ETrue;

	}

#ifdef SYMBIAN_NETWORKING_DHCP_MSG_HEADERS

void CDHCPIP4StateMachine::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("CDHCPIP4StateMachine::StartInformL Dynamic Inform Request")));

	ASSERT(!iFirstState);

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

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

	iFirstState->SetNext( request );

	CDHCPStateMachine::Start(aStateMachineNotify);

	}

#endif // SYMBIAN_NETWORKING_DHCP_MSG_HEADERS

void CDHCPIP4StateMachine::StartRebootL(MStateMachineNotify* aStateMachineNotify)

/**

  * StartRebootL

  *

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

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

  * with valid lease.

  *

  * @internalTechnology

  */

	{

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP4StateMachine::StartRebootL")));

	ASSERT(!iFirstState);

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

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

   iFirstState->SetNext( request );

   request->SetNext( new(ELeave) CDHCPIP4WaitForDAD(*this) );

	CDHCPStateMachine::Start(aStateMachineNotify);

	}

void CDHCPIP4StateMachine::StartRenewL(MStateMachineNotify* aStateMachineNotify,TInt /*aUserTimeOut*/)

/**

  * StartRenewL

  *

  * This function is called to start the renew of lease state machine

  *

  * @internalTechnology

  */

	{

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP4StateMachine::StartRenew")));

	ASSERT(!iFirstState);

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

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

   CDHCPStateMachine::Start(aStateMachineNotify);

	}

void CDHCPIP4StateMachine::StartRebindL(MStateMachineNotify* aStateMachineNotify)

/**

  * StartRebindL

  *

  * This function is called to start the rebind state machine

  *

  * @internalTechnology

  */	

	{

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

	ASSERT(!iFirstState);

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

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

	CDHCPStateMachine::Start(aStateMachineNotify);

	}

void CDHCPIP4StateMachine::StartDeclineL(MStateMachineNotify* aStateMachineNotify)

/**

  * StartDeclineL

  *

  * This function is called to start the decline state machine

  *

  * @internalTechnology

  */

	{

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

	ASSERT(!iFirstState);

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

	CDHCPStateMachine::Start(aStateMachineNotify);

	}

void CDHCPIP4StateMachine::StartReleaseL(MStateMachineNotify* aStateMachineNotify)

/**

  * StartReleaseL

  *

  * This function is called to start the release state machine

  *

  * @internalTechnology

  */

	{

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

	ASSERT(!iFirstState);

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

	//iFirstState->SetNext( new(ELeave) CDHCPRemoveConfiguredAddress(*this));

	CDHCPStateMachine::Start(aStateMachineNotify);

	}

CDHCPState* CDHCPIP4StateMachine::ReceiveL(TRequestStatus* aStatus)

/**

  * Posts receive from on socket

  *

  * @note The iDHCPServerAddr in param 2 of the socket receivefrom

  * is written into by the socket to say where the received message

  * came from.

  * @internalTechnology

  *

  */

	{

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

	DhcpMessage()->InitialiseL();

  	iIncomingMsgDataPtr.Set(iDhcpMessage->Message().Des());

   ASSERT( iReceiving == EFalse );

 	iReceiving = ETrue;

	iSocket.RecvFrom(iIncomingMsgDataPtr, iDHCPServerAddr, 0, *aStatus);

   return static_cast<CDHCPState*>(iActiveEvent);

	}

#ifdef SYMBIAN_NETWORKING_DHCPSERVER

#ifdef SYMBIAN_NETWORKING_ADDRESS_PROVISION

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

#else

CDHCPIP4StateMachine* CDHCPIP4StateMachine::NewL(RSocketServ& aEsock, RConnection& aConnection, const TName& aInterfaceName,TBool aDHCPServerImpl)

#endif //SYMBIAN_NETWORKING_ADDRESS_PROVISION

/**

  * Creates a new instance of this class

  *

  * @internalTechnology

  *

  */

	{

#ifdef SYMBIAN_NETWORKING_ADDRESS_PROVISION

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

#else

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

#endif //SYMBIAN_NETWORKING_ADDRESS_PROVISION	

	CleanupStack::PushL(stateMachine);

	stateMachine->ConstructL();

	CleanupStack::Pop(stateMachine);

	return stateMachine;

	}

TUint8 CDHCPIP4StateMachine::GetClientMessageTypeL() const

/**

  * Returns the message type from the DHCP message

  * i.e. whether the message is an offer, ack, nak...

  *

  * @internalTechnology 

  */

	{

	CDHCPMessageHeaderIP4* v4Msg = DhcpMessage();

	v4Msg->ParseClientMsgL();

	v4Msg->Dump();	

	return v4Msg->iOptions.GetMessageType();

	}

CDHCPState* CDHCPIP4StateMachine::ReceiveOnPort67L(TRequestStatus* aStatus)

/**

  * Posts receive from on socket

  *

  * @note The iDHCPClientAddr in param 2 of the socket receivefrom

  * is written into by the socket to say where the received message

  * came from.

  * @internalTechnology

  *

  */

	{

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP4StateMachine::ReceiveOnPort67L")));

	DhcpMessage()->InitialiseL();

  	iIncomingMsgDataPtr.Set(iDhcpMessage->Message().Des());

	ASSERT( iReceiving == EFalse );

 	iReceiving = ETrue;

	iSvrSocket.RecvFrom(iIncomingMsgDataPtr, iDHCPClientAddr, 0, *aStatus);

	return static_cast<CDHCPState*>(iActiveEvent);

	}

void CDHCPIP4StateMachine::PrepareToSendServerMsgL( CDHCPStateMachine::EAddressType aEAddressType)

/**

  * PrepareToSendServerMsgL

  *

  * This function is called to set the correct destination address

  * for messages before they are sent.

  *

  * @internalTechnology

  */	

	{

	// nothing is done with iClientId in server implementation

	// but it is passed to reuse the existing function.

	DhcpMessage()->FinishL(iClientId); 

	DhcpMessage()->Dump();

	if (aEAddressType==EUnicast)

		{

		if(iBroadCastFlag)

			{

			__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP4StateMachine::SetDestination - broadcast")));

			iDHCPClientAddr.SetV4MappedAddress(KInetAddrBroadcast);		

			}

		else

			{

			__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP4StateMachine::SetDestination - unicast")));

			iDHCPClientAddr.SetV4MappedAddress(iYiaddr);// client ip address

			}

		}

	else

		{

		__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP4StateMachine::SetDestination - broadcast")));

		iDHCPClientAddr.SetV4MappedAddress(KInetAddrBroadcast);	

		}

// While DHCP server listens on a custom port, the server message for client

// needs to be the custom server port + 1 and not the default client port (i.e., 68)

#ifdef _DEBUG

	iDHCPClientAddr.SetPort(GetDestPort()+1);

#else

	iDHCPClientAddr.SetPort(KDhcpClientPort);

#endif

	}

void CDHCPIP4StateMachine::GetClientAddress( TInetAddr& aAddress )

/**

  * GetClientAddress

  *

  * Gets the assigned client address

  *

  * @internalTechnology	

*/

	{

	aAddress = iDHCPClientAddr;

	}

TUint32 CDHCPIP4StateMachine::GenerateClientIPAddress()

/**

  * GenerateClientIPAddress

  *

  * Generate valid IP address to be offered to the client

  *

  *@internalTechnology	

*/

	{

	// get the server IP address	

	TUint32 serverAddr = iCurrentAddress.Address();

	TUint32 hostId = (serverAddr & ~KInetAddrNetMaskC) + 1;

	if (hostId >= 255)

	 {

	 hostId = 1;

	 }

	return (serverAddr & KInetAddrNetMaskC) | hostId;

	}

void CDHCPIP4StateMachine::SetMessageHeaderAsServerL( TDHCPv4MessageType aMsgType )

/**

  * SetMessageHeaderAsServerL

  *

  * Fills in the DHCP header information to be sent to the client

  *

  * @internalTechnology

  */

	{

	TTime now;

	TTimeIntervalSeconds secs;

	now.HomeTime();	

	(void)now.SecondsFrom(iTaskStartedAt, secs);

	CDHCPMessageHeaderIP4* v4Msg = DhcpMessage();

	v4Msg->InitialiseL();

	v4Msg->SetSecs(static_cast<TUint16>(secs.Int()));	// time field is 16 bits, time elapsed will be less than 16 bits, hence no data loss

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

	// set to indicate we are using DHCP server implementation

	v4Msg->iDHCPServerImpl = ETrue; 

	v4Msg->SetCIAddr(iCiaddr);

	// +++++++++++++++++++++ Message Type (1 byte) ++++++++++++++++++++++++++++++++/

	v4Msg->AddOptionL(EDHCPMessageType, 1)->SetBigEndian(aMsgType);

	switch(aMsgType)

		{

		case EDHCPOffer:

		case EDHCPAck:

			// ++++++++Subnet mask, Router and Server IP set with server address ++++++++++/			

			v4Msg->AddOptionL(EDHCPSubnetMask,KIp4AddrByteLength)->SetBigEndian(KInetAddrNetMaskC); // 255.255.255.0

			v4Msg->AddOptionL(EDHCPRouter,KIp4AddrByteLength)->SetBigEndian(iCurrentAddress.Address());

			v4Msg->AddOptionL(EDHCPServerID,KIp4AddrByteLength)->SetBigEndian(iCurrentAddress.Address());	

			break;

		case EDHCPNak:

			// ++++++++Server IP set with server address ++++++++++/

			v4Msg->AddOptionL(EDHCPServerID,KIp4AddrByteLength)->SetBigEndian(iCurrentAddress.Address());	

			break;

		}

	TUint8 htype,hlen;

	//  fill in something "traditional" so as not to upset a stupid server.

	//  This is a best guess based on lack of specs in this area

	htype = 1; // ethernet

	hlen = 6; // mac address length

	v4Msg->SetCHAddr(iClientHWAddr);

	v4Msg->SetHeader(EDHCPBootReply,  htype /*hardware addr type*/,  hlen /*hardware addr length*/,  0 /*hops*/);

	v4Msg->SetFlags(iFlag);

#ifdef _DEBUG

	if (CDHCPServer::DebugFlags() & KDHCP_RequestIP4BroadcastOffer)

		{

		v4Msg->SetFlags(0x8000); // force broadcast

		}

#endif

	}

#endif // SYMBIAN_NETWORKING_DHCPSERVER

void CDHCPIP4StateMachine::PrepareToSendL( CDHCPStateMachine::EAddressType aEAddressType )

/**

  * PrepareToSendL

  *

  * This function is called to set the correct destination address

  * for messages before they are sent.

  *

  * @internalTechnology

  */	

	{

#ifdef SYMBIAN_NETWORKING_DHCP_MSG_HEADERS

	if (iDhcpInformAckPending)

		{

		DhcpMessage()->FinishL(iClientId,&iSavedExtraParameters);

		}

	else

		{

#endif // SYMBIAN_NETWORKING_DHCP_MSG_HEADERS

#ifdef SYMBIAN_NETWORKING_DHCP_MSG_HEADERS

		}	

#endif // SYMBIAN_NETWORKING_DHCP_MSG_HEADERS

	DhcpMessage()->Dump();

	if (aEAddressType==EUnicast)

		{

		__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP4StateMachine::SetDestination - unicast")));

		iDHCPServerAddr.SetV4MappedAddress(iServerAddress);

		}

	else

		{

		__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP4StateMachine::SetDestination - broadcast")));

		iDHCPServerAddr.SetV4MappedAddress(KInetAddrBroadcast);	

		}

#ifndef _DEBUG

	iDHCPServerAddr.SetPort(KDhcpDestPort);

#else

	// Simulate initialisation, renewal or rebind failure by using the wrong port.

	if( ( CDHCPServer::DebugFlags() & KDHCP_FailDiscover ) || ( CDHCPServer::DebugFlags() & KDHCP_FailRenew ) || ( CDHCPServer::DebugFlags() & KDHCP_FailRebind ) )

		{

		iDHCPServerAddr.SetPort(KDhcpWrongDestPort);

		}

	else

		{

		iDHCPServerAddr.SetPort(GetDestPort());

		}

#endif

	}

void CDHCPIP4StateMachine::AssembleClientIDsL()

/**

  * Sets the client id - this just has to be a cookie for the server to use for indexing.

  * 

  *   On an addressed link (e.g. ethernet), hardware address type/value pair is a good combo to use

  *      as it mirrors a few other popular implementations..

  */

	{

    FetchHWAddress();

    iClientId.CreateL(KMaxSockAddrSize);

    iClientId.SetLength(1);		// set length to 1 byte

	if(iHardwareAddr.Family()!=KAFUnspec)

		{

		// we're on a link with hardware addressing e.g. ethernet

		__CFLOG_VAR((KLogSubSysDHCP, KLogCode,

						_L8("CDHCPIP4StateMachine::AssembleClientIDsL - hardware address type=%d, length=%d"),

						iHardwareAddr.Port(), iHardwareAddr.Length() - KHwAddrOffset));