// 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 highest level control plain

// 

//

/**

 @file DHCPIP6Control.cpp

 @internalTechnology

*/

#include "DHCPIP6Control.h"

#include "DHCPIP6States.h"

#include "DHCPServer.h"

#include "DHCPDb.h"

#include "NetCfgExtDhcpControl.h"

#include "DhcpIP6Msg.h"

#include "ExpireTimer.h"

#include "DomainNameDecoder.h"

#include <comms-infras/es_config.h>

#include "netcfgextndhcpmsg.h"

#include <nifman.h>

#include <f32file.h>

#include <comms-infras/metatype.h>

#include <comms-infras/metadata.h>

#ifdef SYMBIAN_NETWORKING_ADDRESS_PROVISION

#include "dhcphwaddrmanager.h"

#endif //SYMBIAN_NETWORKING_ADDRESS_PROVISION

using namespace DHCPv6;

struct TDHCPv6Persistent : public Meta::SMetaData

{

	TDHCPv6Persistent( SIdentityAssociationConfigInfoNA& aIdentityAssociationConfigInfoNA ) :

		iIdentityAssociationConfigInfoNA( &aIdentityAssociationConfigInfoNA )

		{

		iTaskStartedAt.HomeTime();

		}

	TTime iTaskStartedAt;

	SIdentityAssociationConfigInfoNA* iIdentityAssociationConfigInfoNA;

	DATA_VTABLE

};

START_ATTRIBUTE_TABLE( TDHCPv6Persistent, KDHCPv6Persinstence, KDHCPv6PersinstenceId )

	REGISTER_ATTRIBUTE( TDHCPv6Persistent, iIdentityAssociationConfigInfoNA, TMetaObjectPtr<SIdentityAssociationConfigInfoNA> )

	REGISTER_ATTRIBUTE( TDHCPv6Persistent, iTaskStartedAt, TMetaTime )

END_ATTRIBUTE_TABLE()

CDHCPIP6Control::~CDHCPIP6Control()

	{

	}

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

/**

  * Open and attach to the RConnection

  *

  * @internalTechnology

  */

	{

   CDHCPControl::ConfigureL( aInfo, aMessage );

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

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

													TPtrC( SERVICE_IP6_NAME_SERVER1 ),

													TPtrC( SERVICE_IP6_NAME_SERVER2 )); //for both version for the time being see the class TDHCPIP4Db comments

	TRAPD( err, FindInterfaceNameL(aInfo,KAfInet6) );

	if( err == KErrNone )

		{

		TBuf8<KMaxName> tempBuf;

		tempBuf.Copy( iInterfaceName );

		__CFLOG_1(KLogSubSysDHCP, KLogCode, _L8("CDHCPIP6Control::ConfigureL - FindInterfaceNameL found \"%S\""), &tempBuf);

		}

	else

		{

		__CFLOG_1(KLogSubSysDHCP, KLogCode, _L8("CDHCPIP6Control::ConfigureL - FindInterfaceNameL failed with error %d"), err);

		User::Leave( err );

		}

#ifdef SYMBIAN_NETWORKING_ADDRESS_PROVISION

	iDhcpHwAddrManager = CDhcpHwAddrManager::NewL();

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

#else

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

#endif //SYMBIAN_NETWORKING_ADDRESS_PROVISION

	CDHCPIP6StateMachine* sm6 = static_cast<CDHCPIP6StateMachine*>(iDhcpStateMachine);

 	TDHCPv6Persistent pers(sm6->iInterfaceConfigInfo.iSIdentityAssociationConfigInfoNA);

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

	//initialise relevant data

	TInt pos = 0;

	const SIPAddressInfo* info = pers.iIdentityAssociationConfigInfoNA->GetValidAddressInfo( pos );

	TTimeIntervalSeconds seconds = info ? static_cast<TInt>(info->iValidLifeTime) : 0 ;

	iDhcpDb->iLeaseExpiresAt = pers.iTaskStartedAt + seconds;

	//the rest of the data we'll get back in reply msg

	CDHCPControl::ConfigureL(bStaticAddress);	

	}

void CDHCPIP6Control::BindingFinishedL()

 	{

	CDHCPControl::BindingFinishedL();

	//see case EDeclineInitialisedInProgress as to how the persistent

	//data is written

  	}

void CDHCPIP6Control::TaskCompleteL(TInt aError)

/**

  * Signals the end of a task

  * and decides what we should do when

  *

  * @internalTechnology

  */

	{

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, 

				 _L8("CDHCPIP6Control::TaskCompleteL (%d) with error = %d") ,

				 iState, aError));

	DhcpStateMachine()->Cancel();

	TState prevState = iState;

	switch (iState)

		{

		case EDeclineInitialisedInProgress:

			{

			TDHCPv6Persistent pers(DhcpStateMachine()->iInterfaceConfigInfo.iSIdentityAssociationConfigInfoNA);

			//get relevant data from statemachine

			pers.iTaskStartedAt = DhcpStateMachine()->iStartedAquisitionAt;

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

			if (ret!=KErrNone)

				{

				__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP6Control::TaskCompleteL error: %d"),ret));

				}

			iState = EInitialised;

			break;

			}

		case EReconfigureInProgress:

			//in the case the following fn leave we've run out of memory => we will not respond

			//to the reconfigure message. However we can still use our address(es) and wait

			//for renew timer to expire

			if ( aError == KErrNone )

				{

				CDHCPMessageHeaderIP6* v6Msg = DhcpStateMachine()->DhcpMessage();

				COptionNode* pNode = v6Msg->GetOptions().FindOption( EReconfMsg );

				if (pNode)

					{

					TInt nCode = pNode->GetBigEndian();

					switch ( nCode )

						{

						case EReconfigureInformRequest:

							DhcpStateMachine()->StartInformL( this, EFalse /*static address is either already set or not used*/ );

							iState = EInformInProgress;

							//cancel the renew timer (if any) after succesfully starting the above tasks

							iTimer->Cancel();

							break;

						case EReconfigureRenew:

							DhcpStateMachine()->StartRenewL( this,0 );

							iState = ERenewInProgress;

							//cancel the renew timer (if any) after succesfully starting the above tasks

							iTimer->Cancel();

							break;

						default:

							// keep restarting reconfigure

							DhcpStateMachine()->StartReconfigureL( this );

						}

					}

				else

					{

					// keep restarting reconfigure

					DhcpStateMachine()->StartReconfigureL( this );

					}

			}

			else

				{

				//keep restarting reconfigure until a valid reconfigure arrives or

				//renew timer expires or interface goes down

				DhcpStateMachine()->StartReconfigureL( this );

				}

			break;

		case ERebindInProgress:

		case EInitInProgress:

			iTimer->Cancel();

			if ( aError != KErrNone )

				{//decline all

				DhcpStateMachine()->iInterfaceConfigInfo.SetAddressStatus( KAddrIndexAll, EMarkForDecline );

				}

			iState = EInitInProgress; //take the same action as for EInitInProgress

			CDHCPControl::TaskCompleteL(aError);

			break;

		case ERenewInProgress:

			iTimer->Cancel();

			if (KErrNone != aError)

				{

				//Renew process has failed => start rebind

				DhcpStateMachine()->StartRebindL( this );

				iState = ERebindInProgress;

				break;

				}

			//fall through if no error

		default:

			{

			CDHCPControl::TaskCompleteL(aError);

			}

		};

	//if the statemachine history indicates CDHCPState::EBinding and aError==KErrNone we have to check whether to

	//decline any addresses that haven't been verified by the stack as valid ones. If so we initiate decline

	//to decline the invalid addresses. In case at least one address is valid we go to reconfigure state after the decline.

	//=> amend UML and doc accordingly.

	if (DhcpStateMachine()->History() & CDHCPState::EBinding && aError == KErrNone )

		{//see CDHCPIP6StateMachine::StartDeclineL

		DhcpStateMachine()->StartDeclineL( this );

		iState = EDeclineInitialisedInProgress;

		//not changing CDHCPIP6Control state we are initialised and timer is running

		}

	else if ( iState == EInitialised || (iState == EEnd && prevState == EInformInProgress))

		{//we don't want this to leave

#if defined(DHCP_RECONFIGURE_NO_AUTHENTICATION)

		//we don't support reconfigure until we've sorted out authentication

		TRAPD(ret, DhcpStateMachine()->StartReconfigureL( this ));

		if (ret!=KErrNone)

			{

			__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPIP6Control::TaskCompleteL error: %d"),ret));

			}

		iState = EReconfigureInProgress;

#endif

		}

	}

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

	{

	TBool deferAllowed = !iMessage;

	if (iDhcpStateMachine)

		{

	   	switch (aName)

			{

			case KConnAddrRenew:

				if (deferAllowed && iDhcpStateMachine->IsGettingCfgInfoOnly())

					{

					iTimer->Cancel();

					iDhcpStateMachine->Cancel();

					iDhcpStateMachine->StartInformL(this,EFalse);

					iState = EInformInProgress;

					return ETrue;

					}

				break;

			default:

				break;

			}

		}

	return CDHCPControl::HandleClientRequestL(aName,aValue);		

	}

TInt CDHCPIP6Control::HandleClientRequestL(TUint aName)

	{

	return CDHCPIP6Control::HandleClientRequestL(aName,0);

	}

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

	{

	HBufC8* buf = NULL;

	DHCPv6::CDHCPMessageHeaderIP6 msg(buf);

	CleanupClosePushL(msg);

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

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

    DHCPv6::COptionNode* pOption = msg.GetOptions().FindOption(aOpCode);

    if (!pOption)

      {

#ifdef SYMBIAN_TCPIPDHCP_UPDATE

      // The option is not found try to get the option through DHCP INFORM message 

      //by calling RequestInformOrCompleteCallL

      CleanupStack::PopAndDestroy();

	  TUint opcode = aOpCode;

	  TPtr8 optPtr(reinterpret_cast<TUint8*>(&opcode),1,1);

	  return(RequestInformOrCompleteCallL(optPtr));

#else	  

	  User::Leave(KErrNotFound);  

#endif //SYMBIAN_TCPIPDHCP_UPDATE	  

      }

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

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

      {

      User::Leave(KErrOverflow);

      }

    aPtr.Copy(ptr);

    CleanupStack::PopAndDestroy();

	}

/**

    Get raw option data (IP6 version).

    @param  pointer to the buffer descriptor for getting option data

*/

void CDHCPIP6Control::HandleGetRawOptionDataL(TDes8* aDes)

	{

	TDhcp6RawOptionDataPckg pckg(*aDes);

	TUint16 opCode = pckg.OpCode();

	TPtr8 buf(pckg.Buf());

	GetRawOptionDataL(opCode, buf);

	pckg.SetBufLengthL(buf.Length());

	}

#ifdef SYMBIAN_NETWORKING_DHCP_MSG_HEADERS

void CDHCPIP6Control::GetDhcpHdrSiaddrL(TDes8& /*aNxtAddress*/)

	{

	//presently empty implementation.

	//PREQ 1647& 1648 implmentation is only for IPv4

	}

void CDHCPIP6Control::GetDhcpHdrSnameL(TDes8& /*aHdrSvrName*/)

	{

	//presently empty implementation.

	//PREQ 1647& 1648 implmentation is only for IPv4

	}

void CDHCPIP6Control::HandleGetTftpServerNameL(TDes8& /*aDes*/)

	{

	//presently empty implementation.

	//PREQ 1647& 1648 implmentation is only for IPv4

	}

void CDHCPIP6Control::HandleGetTftpServerAddrL(TDes8& /*aDes*/)

	{

	//presently empty implementation.

	//PREQ 1647& 1648 implmentation is only for IPv4

	}

#endif

#ifdef SYMBIAN_TCPIPDHCP_UPDATE

void CDHCPIP6Control::RequestInformOrCompleteCallL(TDes8& aOpcodePtr)	

/**

  * The RequestInformOrCompleteCallL function

  *

  * Checks DHCPINFORM message should be sent or not

  * @param aOpcodePtr  pointer to the opcode list to be updated  in iSavedExtraParameters

  * @internalTechnology

  */

	{

	if (!iDhcpStateMachine->iDhcpInformAckPending)

		{

		if (!iDhcpStateMachine->iSavedExtraParameters.Length())

			{

			iDhcpStateMachine->iSavedExtraParameters.CreateL(aOpcodePtr);

			}

		else

			{

			iDhcpStateMachine->iSavedExtraParameters.ReAllocL(iDhcpStateMachine->iSavedExtraParameters.Length()+aOpcodePtr.Length());

			iDhcpStateMachine->iSavedExtraParameters.Append(aOpcodePtr);

			}

		//Cancel if there is any outstanding request(DHCP reconfigure will cancelled)

		iDhcpStateMachine->Cancel();

		static_cast<CDHCPIP6StateMachine*>(iDhcpStateMachine)->StartInformL( this);

		iDhcpStateMachine->iDhcpInformAckPending=ETrue;

  		iState = EInformInProgress;

		}

	else

		{

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

		iDhcpStateMachine->iDhcpInformAckPending=EFalse;

		User::Leave(KErrNotFound);	

		}

	}

#endif //SYMBIAN_TCPIPDHCP_UPDATE

#ifdef SYMBIAN_TCPIPDHCP_UPDATE 

void CDHCPIP6Control::HandleGetMultipleParamsL(TDes8& aDes)

#else

void CDHCPIP6Control::HandleGetMultipleParamsL(TDes8& /*aDes */)

#endif //SYMBIAN_TCPIPDHCP_UPDATE

/**

  * This function will be called when the application want to retrieve multiple 

  * options from the server by using option ORO(option 6) 

  *

  * @see RFC 3315 sec 22.7

  * @internalTechnology

  */

	{

#ifdef SYMBIAN_TCPIPDHCP_UPDATE	

	HBufC8 *saveBuf=NULL, *buffer=NULL;

	TUint16 *headerPtr;

	TInt numOfOpcodes=0;

	TInt totalLength=0,opcodeLength=aDes.Length();

	TInt maxLength=aDes.MaxLength();

	TUint16 opcode;

	TBool allFound=ETrue;

	DHCPv6::CDHCPMessageHeaderIP6 msgSaved(saveBuf);

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

	CleanupClosePushL(msgSaved);

	msgSaved.iRecord.ParseL(savedPtr);

	//The below for loop checks all the required opcode data is present or not

	//The message opcode data is not present in the iValidMsg buffer,the corresponding 

	//opcodes are stored in iCurrentParameters for sending it in DHCPINFORM message

	for(TInt i=0;i<opcodeLength;i++)

		{

		opcode=*(aDes.Ptr()+i); //search required opcode is present or not, one by one

		DHCPv6::COptionNode* findNode = msgSaved.GetOptions().FindOption(opcode);

		if (findNode )

			{

			//get the opcode length

			TInt bufLength=findNode->GetItemLength();

			totalLength+=bufLength;

			//The opcode buffer length is greater than maximum length through overflow error

			if ((totalLength+1) > maxLength)

				{

				totalLength-=bufLength;

				continue; //current buffer is too big..so hope next buffer is small

				}

			if (!buffer)

				{

				buffer=HBufC8::NewLC(totalLength + 1);//+1 is extra byte to store number of opcodes

				buffer->Des().Append(KNoChar);

				}

			else

				{

				buffer=buffer->ReAllocL(totalLength + 1);

				CleanupStack::Pop();//buffer as ptr address has changed

		        CleanupStack::PushL(buffer);

				}

			headerPtr = reinterpret_cast<TUint16*>(findNode->Ptr()); 

			++numOfOpcodes;

			//Append the opcode information to the buffer

			buffer->Des().Append(reinterpret_cast<const TUint8*>(headerPtr),bufLength);

			}

		else

			{

			//If atleast one opcode, among the requested, is not found then request through 

			//DHCP INFORM message by calling RequestInformOrCompleteCallL

			allFound=EFalse;

			}

		}

	if (allFound ) //everything is present..just return call now itself..

		{

		if ((totalLength + 1) > maxLength || totalLength<=0)

			{

			User::Leave(KErrOverflow);

			}

		if(buffer) // buffer would be NULL only when aDes.Length = 0 which is a rare scenario. But still check it to avoid NULL pointer dereference.

			{

			aDes.Copy(buffer->Ptr(), buffer->Length());

			TBuf8<1> dummy;

			dummy.FillZ(1);

			dummy[0]=numOfOpcodes;

			aDes.Replace(0,1,dummy);//update number of opcodes collected

			}

		}

	else

		{

		//If the option is not found then trigger the information request

		TPtr8 opcodePtr(const_cast<TUint8*>(aDes.Ptr()),opcodeLength);

		opcodePtr.SetLength(opcodeLength);

		RequestInformOrCompleteCallL(opcodePtr);	

		}	

	if (buffer)

		{

		CleanupStack::PopAndDestroy(buffer);

		}

	CleanupStack::PopAndDestroy(&msgSaved);

#endif //SYMBIAN_TCPIPDHCP_UPDATE

	}

TInt CDHCPIP6Control::InformCompleteRequestHandlerL()

/**

  * The InformCompleteRequestHandlerL function

  * 

  * The function will be called after the DHCPACK message is received, and 

  * iValidMsg buffer has been updated. 

  * Looks for the requested options present or not and appropriately calls 

  * the function handlers

  *

  * @return KErrNone if the required data option is found else corresponding error code.

  * @internalTechnology

  */

	{

#ifdef SYMBIAN_TCPIPDHCP_UPDATE

	TUint optionName = iMessage->Int1();

	TInt length      = iMessage->Int3();

	HBufC8 *buff=HBufC8::NewMaxLC(length) ;

	TPtr8 ptr(buff->Des());

	iMessage->ReadL(2, ptr);

	switch(optionName)

		{

		case KConnGetDhcpRawOptionData:

			{

			HandleGetRawOptionDataL(&ptr);

			iMessage->WriteL(2,ptr);

			break;

			}

		case KConnDhcpGetMultipleParams :

			{

			HandleGetMultipleParamsL(ptr);

			iMessage->WriteL(2,ptr);

			break;

			}

	default:

		__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("InformCompleteRequestHandlerL : default unhandled optino Name")));

		break;	

		}

		iDhcpStateMachine->iDhcpInformAckPending=EFalse;

		CleanupStack::PopAndDestroy(buff);

		return KErrNone;

#else

		return EFalse;

#endif //SYMBIAN_TCPIPDHCP_UPDATE

	}

void CDHCPIP6Control::HandleGetSipServerAddrL(TDes8* aDes)

	{	

	SSipServerAddr* sipServerAddr =