// 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 DHCP IP4 control plain

// 

//

/**

 @file DHCPIP4Control.cpp

 @internalTechnology

*/

#include "DHCPIP4Control.h"

#include "DHCPIP4States.h"

#include "DHCPIP4Msg.h"

#include "DHCPServer.h"

#include "DHCPConfigListener.h"

#include "DHCPDb.h"

#include "ExpireTimer.h"

#include "NetCfgExtDhcpControl.h"

#include "DomainNameDecoder.h"

#include <nifman.h>

#include <comms-infras/es_config.h>

#include <f32file.h>

#include <comms-infras/metatype.h>

#include <comms-infras/metadata.h>

#ifdef SYMBIAN_NETWORKING_DHCP_MSG_HEADERS

#include "DHCPIP4Msg.h" 

#ifdef SYMBIAN_NETWORKING_ADDRESS_PROVISION

#include "dhcphwaddrmanager.h"

#endif //SYMBIAN_NETWORKING_ADDRESS_PROVISION

using namespace DHCPv4;

#endif//SYMBIAN_NETWORKING_DHCP_MSG_HEADERS			

struct TDHCPv4Persistent : public Meta::SMetaData

{

	TDHCPv4Persistent() : 

		iTaskStartedAt( 0 ),

		iCurrentAddress(KInetAddrNone,KInetPortNone),

		iLeaseTime(0)

		{

		}

	TTime iTaskStartedAt;

	TInetAddr iCurrentAddress;

	TUint32 iLeaseTime;

	DATA_VTABLE

};

START_ATTRIBUTE_TABLE( TDHCPv4Persistent, KDHCPv4Persinstence, KDHCPv4PersinstenceId )

	REGISTER_ATTRIBUTE( TDHCPv4Persistent, iTaskStartedAt, TMetaTime )

	REGISTER_ATTRIBUTE( TDHCPv4Persistent, iCurrentAddress, TMeta<TInetAddr> )

	REGISTER_ATTRIBUTE( TDHCPv4Persistent, iLeaseTime, TMetaNumber )

END_ATTRIBUTE_TABLE()

CDHCPIP4Control::~CDHCPIP4Control()

	{

	}

void CDHCPIP4Control::ConfigureL(const TConnectionInfo& aInfo, const RMessage2* aMessage)

/**

  * Open and attach to the RConnection

  *

  * @internalTechnology

  */

	{

   CDHCPControl::ConfigureL( aInfo, aMessage );

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP4Control::ConfigureL")));

	iDhcpDb = new (ELeave) CDHCPDb( TPtrC( SERVICE_IP_DNS_ADDR_FROM_SERVER ),

													TPtrC( SERVICE_IP_NAME_SERVER1 ),

													TPtrC( SERVICE_IP_NAME_SERVER2 )); //for both version for the time being see the class TDHCPIP4Db coments

	FindInterfaceNameL(aInfo,KAfInet);

#ifdef SYMBIAN_NETWORKING_DHCPSERVER

#ifndef SYMBIAN_NETWORKING_ADDRESS_PROVISION

	iDhcpStateMachine = CDHCPIP4StateMachine::NewL(iEsock, iConnection, iInterfaceName,iDHCPServerImpl);

#else

	iDhcpHwAddrManager = CDhcpHwAddrManager::NewL();

	iDhcpStateMachine = CDHCPIP4StateMachine::NewL(iEsock, iConnection, iInterfaceName,iDhcpHwAddrManager, iDHCPServerImpl);

#endif //SYMBIAN_NETWORKING_ADDRESS_PROVISION

#else 

	iDhcpStateMachine = CDHCPIP4StateMachine::NewL(iEsock, iConnection, iInterfaceName);

#endif 	// SYMBIAN_NETWORKING_DHCPSERVER		

	TDHCPv4Persistent pers;

	iStaticAddress = !iDhcpDb->ReadL(*iDhcpStateMachine, pers);

	//initialise relevant data

	TTimeIntervalSeconds seconds = static_cast<TInt>(pers.iLeaseTime);

	iDhcpDb->iLeaseExpiresAt = pers.iTaskStartedAt + seconds;

	DhcpStateMachine()->iLeaseTime = pers.iLeaseTime;

	iDhcpStateMachine->SetCurrentAddress( pers.iCurrentAddress );

	DhcpStateMachine()->iMaxRetryCount = 2; //Max retry count for the first run is set to 2

	TInetAddr existingGlobalAddr = iDhcpStateMachine->GetInterfaceGlobalAddress();

	if( ! existingGlobalAddr.IsUnspecified() )

		{

		// there was an existing address on the interface, regardless of commsdat preference..

		//  so force inform.

		__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("Interface already has global address. Forcing inform mode.")));

		iDhcpStateMachine->SetCurrentAddress( existingGlobalAddr );

		iStaticAddress = ETrue;

		}

	else

		{

		if(iStaticAddress)

			{

			__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("Interface has a static address from commsdat. Proceeding in inform mode.")));

			}

		else

			{

			__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("Interface has no global address yet. Proceeding in discover mode.")));

			}

		}

	CDHCPControl::ConfigureL(iStaticAddress);

	}

void CDHCPIP4Control::Cancel()

	{

	iClientShouldCompleteWhenLinkLocalCreated = EFalse;

	// Call the base class.

	CDHCPControl::Cancel();

   }

void CDHCPIP4Control::BindingFinishedL()

	{

	CDHCPControl::BindingFinishedL();

	TDHCPv4Persistent pers;

	//get relevant data from statemachine

	pers.iTaskStartedAt = DhcpStateMachine()->iStartedAquisitionAt;

	pers.iCurrentAddress = DhcpStateMachine()->iCurrentAddress;

	pers.iLeaseTime = DhcpStateMachine()->iLeaseTime;

	TRAPD( ret, iDhcpDb->WriteL(*iDhcpStateMachine, pers) );

	if (ret!=KErrNone)

		{

		__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP4Control::BindingFinishedL error: %d"),ret));

		}

	}

void CDHCPIP4Control::TimerExpired()

/**

  * Called by the timer to signal that the timer has expired

  *

  * @internalTechnology

  */

	{

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

    CDHCPControl::TimerExpired();

	// In response to the rebind operation timing out, try to create

	// a link local to allow local addressing (may not be supported

	// by current interface's IPv4 link local option).  We cannot

	// create the link local earlier (e.g., after a renew attempt

	// times-out) because the link local will not be usable until

	// the DHCP assigned address has been removed (randomly

	// generated addresses are prioritised below non-randomly

	// generated addresses during selection in the TCP/IP stack).

	if( ( iState == EInitInProgress ) && iDhcpConfigListener && !iDhcpConfigListener->HaveLinkLocal() )

		{

		DhcpStateMachine()->CreateIPv4LinkLocal();

		}

	}

TInt CDHCPIP4Control::HandleClientRequestL(TUint aName, TInt aValue)

/**

  * Handles client requests made through RConnection

  * are handled here.  Currently its for renewing the lease time 

  * where client passes in a required timeout 

  * @see CDHCPControl::HandleClientRequestL

  *

  * @internalTechnology

  */

	{

	TBool deferAllowed = !iMessage;

	TBool defer = EFalse;

  	defer = CDHCPControl::HandleClientRequestL(aName, aValue);

	if (aName == KConnAddrRenew && iState == ERenewInProgress && deferAllowed)

		{//Rebind timeout

		TTimeIntervalSeconds timeOut;

		if(aValue > 0)

			{

			timeOut = aValue;

			}

		else

			{

			timeOut = (DhcpStateMachine()->iRebindTimeT2 - DhcpStateMachine()->iRenewalTimeT1 + 1);

			}

      	iTimer->After(timeOut, *this);

      	defer = ETrue;

		}

	return defer;

	}	

TInt CDHCPIP4Control::HandleClientRequestL(TUint aName)

/**

  * Handles client requests specific for IP4

  *

  * @see CDHCPControl::HandleClientRequestL

  * @internalTechnology

  */

	{

	return CDHCPIP4Control::HandleClientRequestL(aName,0);

	}

/**

    Get raw option data (IP4 version).

    @param  pointer to the buffer descriptor for getting option data

*/

void CDHCPIP4Control::HandleGetRawOptionDataL(TDes8* aDes)

{

	TDhcp4RawOptionDataPckg pckg(*aDes);

	TUint8 opCode = pckg.OpCode();

	TPtr8 buf(pckg.Buf());

	GetRawOptionDataL(opCode, buf);

#ifdef SYMBIAN_NETWORKING_DHCP_MSG_HEADERS

	if (!iDhcpStateMachine->iDhcpInformAckPending)   

		{

#endif // SYMBIAN_NETWORKING_DHCP_MSG_HEADERS

	pckg.SetBufLengthL(buf.Length());

#ifdef SYMBIAN_NETWORKING_DHCP_MSG_HEADERS

		}

#endif // SYMBIAN_NETWORKING_DHCP_MSG_HEADERS

}

void CDHCPIP4Control::TaskCompleteL( TInt aError )

/**

  * TaskCompleteL function

  *

  * if this method returns ETrue then aStateMachine deletes itself.

  * In this case it does not ever return ETrue.

  * Called upon completion or when suspended.

  *

  * @see CStateMachine::iSuspendRequest comment

  * @internalTechnology

  */

	{

	// In response to the initialisation operation timing out,

	// try to create a link local to allow local addressing (may

	// not be supported by current interface's IPv4 link local

	// option).

	if( ( aError == KErrTimedOut ) &&

		( iState == EInitInProgress ) &&

		!iStaticAddress &&

		iDhcpConfigListener &&

		!iDhcpConfigListener->HaveLinkLocal() )

		{

		if( DhcpStateMachine()->CreateIPv4LinkLocal() == KErrNone )

			{

			iClientShouldCompleteWhenLinkLocalCreated = ETrue;

			//Link Local Address has been taken & return here itself

			CDHCPControl::TaskCompleteL(aError);

			return;

			}

		}

	if((DhcpStateMachine()->iRetryDhcpIpCount >= KDHCPv4MaxRetryCount) && iState == EDeclineInProgress )

		{

		if( DhcpStateMachine()->CreateIPv4LinkLocal() == KErrNone )

			{

			iClientShouldCompleteWhenLinkLocalCreated = ETrue;

			//Link Local Address has been taken & return here itself

 			CDHCPControl::TaskCompleteL(KErrNone);

 			return;

			}

		}

	// Call the base class.

	CDHCPControl::TaskCompleteL( aError );

	}

void CDHCPIP4Control::LinkLocalCreated()

/**

  * LinkLocalCreated function

  *

  * If iClientShouldCompleteWhenLinkLocalCreated is ETrue we need to complete the

  * client messages as the link local has been created and the interface is now

  * ready for use.

  *

  * @internalTechnology

  */

	{

	if( iClientShouldCompleteWhenLinkLocalCreated )

		{

		iClientShouldCompleteWhenLinkLocalCreated = EFalse;

		CompleteClientConfigureMessage(KErrNone);

		// don't complete any outstanding ioctl yet..

		}

	}

void CDHCPIP4Control::GetRawOptionDataL(TUint aOpCode, TPtr8& aPtr)

	{

#ifdef SYMBIAN_NETWORKING_DHCPSERVER

	if(iValidMsg.Length()==0 && iDHCPServerImpl)

		{

		GetRawOptionDataFromDNSBufL(aPtr);

		return;

		}

#endif // SYMBIAN_NETWORKING_DHCPSERVER

	HBufC8* buf = NULL;

	DHCPv4::CDHCPMessageHeaderIP4 msg(buf);

	CleanupClosePushL(msg);

	TPtr8 ptr( const_cast<TUint8*>(iValidMsg.Ptr()), iValidMsg.Length(), iValidMsg.Length() );

	msg.iRecord.ParseL(ptr); //no check necessary

	DHCPv4::COptionNode* pOption = msg.iOptions.FindOption(static_cast<TUint8>(aOpCode));

	if (!pOption)

		{

#ifdef SYMBIAN_NETWORKING_DHCP_MSG_HEADERS

		CleanupStack::PopAndDestroy();

		TUint8 tempOpt=aOpCode;

		TPtr8 optPtr(&tempOpt,1,1);

		return(RequestInformOrCompleteCallL(optPtr));

#else

		User::Leave(KErrNotFound);

#endif // SYMBIAN_NETWORKING_DHCP_MSG_HEADERS

		}

	ptr.Set(pOption->GetBodyDes());

	if (ptr.Length() > aPtr.MaxLength())

		{

		User::Leave(KErrOverflow);

		}

	aPtr.Copy(ptr);

	CleanupStack::PopAndDestroy();

	}

#ifdef SYMBIAN_NETWORKING_DHCPSERVER

void CDHCPIP4Control::GetRawOptionDataFromDNSBufL(TPtr8& aPtr)

	{

	if(iValidMsg.Length() == 0)

		{

		if (iDNSRawOption->Des().Length() > aPtr.MaxLength())

			{

			User::Leave(KErrOverflow);

			}

		aPtr.Copy(iDNSRawOption->Des());

		}

	}

void CDHCPIP4Control::HandleSetRawOptionCodeL(TDes8* aDes)

	{

	if(iValidMsg.Length() == 0)

		{

		iDNSRawOption = HBufC8::NewL(aDes->Length());

		iDNSRawOption->Des() = *aDes;

		}

	else

		{

		SetRawOptionCodeL(aDes);	

		}

	}

void CDHCPIP4Control::SetRawOptionCodeL(TDes8* aDes)

	{

	HBufC8* buf = NULL;

	DHCPv4::CDHCPMessageHeaderIP4 msg(buf);

	CleanupClosePushL(msg);

	TPtr8 ptr( const_cast<TUint8*>(iValidMsg.Ptr()), iValidMsg.Length(), iValidMsg.Length() );

	msg.iRecord.ParseL(ptr); //no check necessary

	TDhcp4RawOptionDataPckg pckg(*aDes);

	DHCPv4::TDHCPOptionCodes opcode = static_cast<DHCPv4::TDHCPOptionCodes>(pckg.OpCode());

	DHCPv4::COptionNode* pOption = msg.iOptions.FindOption(opcode);

	if (!pOption)

		{

		User::Leave(KErrNotFound);

		}

	TPtr8 ptr2(reinterpret_cast<TUint8*>(aDes),aDes->Length());

	pOption->SetBody(ptr2);	

	CleanupStack::PopAndDestroy(); // msg

	}

#endif // SYMBIAN_NETWORKING_DHCPSERVER

void CDHCPIP4Control::HandleGetSipServerAddrL(TDes8* aDes)

	{	

	if (aDes->Length() < static_cast<TInt>(sizeof(SSipServerAddr)))

		{

		User::Leave(KErrArgument);

		}

	SSipServerAddr* sipServerAddr = 

		reinterpret_cast<SSipServerAddr*>(const_cast<TUint8*>(aDes->Ptr()));

	HBufC8* buf = NULL;

	DHCPv4::CDHCPMessageHeaderIP4 msg(buf);

	CleanupClosePushL(msg);

	TPtr8 ptr(const_cast<TUint8*>(iValidMsg.Ptr()), iValidMsg.Length(), iValidMsg.Length());

	msg.iRecord.ParseL(ptr);

	DHCPv4::COptionNode* sipServerOption = msg.iOptions.FindOption(DHCPv4::EDHCPSIPServers);

	if(sipServerOption)

		{

		TUint8* headerPtr = sipServerOption->Ptr();		

		TUint encoding = headerPtr[DHCPv4::KDhcpSipEncodingOffset];

		TUint length = headerPtr[DHCPv4::KDhcpSipLengthOffset];

		if(encoding != DHCPv4::KDhcpSipEncodingAddresses)

			{

			__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("HandleGetSipServerAddrL: Client trying to fetch a SIP address when only a SIP domain is known")));

			User::Leave( KErrNotFound );

			}

		if((TUint)sipServerAddr->index >= (length / KIp4AddrByteLength))

			{

			__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("HandleGetSipServerAddrL: Client tried to fetch an out-of-range SIP address %d (I only know about %d)"),(TUint)sipServerAddr->index, (length / KIp4AddrByteLength)));

			User::Leave( KErrNotFound );

			}

		TUint addrOffset = sipServerAddr->index * KIp4AddrByteLength;

		TUint8* bodyPtr = sipServerOption->GetBodyPtr();

		TUint32 copiedValue;

		// Grab ip address from option body at given offset, +1 used to skip the encoding boolean used for sip

		Mem::Copy(&copiedValue,(bodyPtr + addrOffset+1),4);  

		// swap around ip address as in BigEndian form

		copiedValue = ByteOrder::Swap32(copiedValue); 

		sipServerAddr->address.SetAddress(copiedValue);   

		}

	else

		{

		__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("HandleGetSipServerAddrL: Client tried to fetch a SIP option but none has (yet) been received")));

		User::Leave(KErrNotFound);

		}	

	CleanupStack::PopAndDestroy();

	}

#ifdef SYMBIAN_NETWORKING_DHCP_MSG_HEADERS

void CDHCPIP4Control::GetDhcpHdrSiaddrL(TDes8& aNxtAddress)

/**

  * The GetDhcpHdrSiaddr function

  *

  * Fetches the Siaddr

  *

  * @param aNxtAddress Next server IPAddress fetched from the DHCP Server

  * @internalTechnology

  */

	{

	if (aNxtAddress.Length() < static_cast<TInt>(sizeof(TConnectionAddress)))

		{

		User::Leave(KErrArgument);

		}

	TConnectionAddress* ptr = (TConnectionAddress*)aNxtAddress.Ptr();

	TInetAddr* addrPtr = new(&(ptr->iAddr))TInetAddr;	

	//ptr->iAddr is just some memory in aDes. There is no guarantee that it will be a

	//valid TInetAddr (or even a valid TDes) so what we do here is just run a constructor

	//on this already valid memory block and we are now guaranteed to have a valid 

	//TInetAddr - NO MEMORY IS ACTUALLY ALLOCATED BY NEW HERE - see base code for more 

	//details	

	//Parse the iValidMsg

	HBufC8* buf = NULL;

	DHCPv4::CDHCPMessageHeaderIP4 msg(buf);

	CleanupClosePushL(msg);

	TPtr8 msgPtr(const_cast<TUint8*>(iValidMsg.Ptr()), iValidMsg.Length(), iValidMsg.Length());

	msg.iRecord.ParseL(msgPtr);

	//Extract the server address

	addrPtr->SetAddress(msg.GetSIAddr());

	CleanupStack::PopAndDestroy();

	}

void CDHCPIP4Control::GetDhcpHdrSnameL(TDes8& aHdrSvrName)

/**

  * The GetDhcpHdrSname function

  *

  * Fetches the Sname

  *

  * @param aHdrSvrName Next server name fetched from the DHCP Server. 

  * @internalTechnology

  */

	{

	HBufC8* buf = NULL;

	DHCPv4::CDHCPMessageHeaderIP4 msg(buf);

	CleanupClosePushL(msg);

	TPtr8 ptr(const_cast<TUint8*>(iValidMsg.Ptr()), iValidMsg.Length(), iValidMsg.Length());

	msg.iRecord.ParseL(ptr);

	if (msg.GetSName().Length() > aHdrSvrName.MaxLength())

	{

		User::Leave(KErrOverflow);

	}

	aHdrSvrName=msg.GetSName();

	//SetLength otherwise received string length will be 64 by default, truncate to end of string.

	aHdrSvrName.SetLength(aHdrSvrName.Locate('\0'));

	CleanupStack::PopAndDestroy(&msg);

	}

void CDHCPIP4Control::HandleGetTftpServerAddrL(TDes8& aDes) 

/**

  * The HandleGetTftpServerAddrL function

  *

  * Fetches the Tftp Server Address

  * @param aDes Buffer returned contains a list of ip addresses each of 4 bytes.

  *

  * @internalTechnology

  */

	{

	if (aDes.Length() < static_cast<TInt>(sizeof(STftpServerAddr)))

		{

		User::Leave(KErrArgument);

		}

	STftpServerAddr* tftpServerAddr = 

		reinterpret_cast<STftpServerAddr*>(const_cast<TUint8*>(aDes.Ptr()));