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

// 

//

/**

 @file DHCPControl.cpp

 @internalTechnology

*/

#include "DHCPControl.h"

#include "DHCPStates.h"

#include "DHCPStateMachine.h"

#include "DHCPConfigListener.h"

#include "DNSUpdateIf.h"

#include "DHCPDb.h"

#include "DHCPMsg.h"

#include "NetCfgExtDhcpControl.h"

#include <nifman.h>

#include <comms-infras/es_config.h>

#ifdef _DEBUG

#include "DHCPServer.h"

#endif

#include "DHCPStatesDebug.h"

#ifdef SYMBIAN_NETWORKING_PLATSEC

#include <comms-infras/rconfigdaemonmess.h>

#else

#include <comms-infras\cs_daemonmess.h>

#endif

#ifdef SYMBIAN_NETWORKING_ADDRESS_PROVISION

#include "dhcphwaddrmanager.h"

const TInt KEightBit = 8;

#endif //SYMBIAN_NETWORKING_ADDRESS_PROVISION

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <nifman_internal.h>

#endif

CDHCPControl::~CDHCPControl()

	{

  	CompleteClientMessage( KErrCancel ); // complete all. must be before the rest to avoid deadlock with ESOCK

	delete iDhcpStateMachine;

	delete iTimer;

	iConnection.Close();

	delete iDhcpDb;

	iValidMsg.Close();

	delete iDhcpConfigListener;

#ifdef SYMBIAN_NETWORKING_DHCPSERVER

	delete iDNSRawOption;

#ifdef SYMBIAN_NETWORKING_ADDRESS_PROVISION

	delete iDhcpHwAddrManager;

#endif //SYMBIAN_NETWORKING_ADDRESS_PROVISION

#endif 	// SYMBIAN_NETWORKING_DHCPSERVER	

	}

//_LIT(KIp6Interface1,"ipcp6");

//_LIT(KIp6Interface2,"eth6");

void CDHCPControl::FindInterfaceNameL(const TConnectionInfo& aInfo, TInt aFamily)

/**

  * Finds the interface name by querying

  * the connection for the name

  *

  * @internalTechnology

  */

	{

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPControl::FindInterfaceName")));

	TConnectionInfoBuf connInfo = aInfo;

	// store IAP for later so we can access CommDB

	iDhcpDb->iIapId = connInfo().iIapId;

	User::LeaveIfError(iConnection.Open(iEsock));

	User::LeaveIfError(iConnection.Attach(connInfo, RConnection::EAttachTypeMonitor));

	TInt err = KErrNotFound;	// to ensure we can check that we found connection info

	TPckgBuf<TConnInterfaceName> name;

	name().iIndex=1;

	//this is somethig unheard of in OO environment that we cannot get hold of a simple object relations

	//forced to do this horrible stuff

	RSocket socket;

	User::LeaveIfError(socket.Open(iEsock, KAfInet, KSockDatagram, KProtocolInetUdp,iConnection));

	// make socket invisible for interface counting

	User::LeaveIfError(socket.SetOpt(KSoKeepInterfaceUp, KSolInetIp, 0));

	CleanupClosePushL( socket );

	TPckgBuf<TSoInet6InterfaceInfo> info;

	while ( err == KErrNotFound && iConnection.Control(KCOLProvider, KConnGetInterfaceName, name) == KErrNone )

		{

		TSoInet6InterfaceInfo& q = info();

		User::LeaveIfError(socket.SetOpt(KSoInetEnumInterfaces, KSolInetIfCtrl, 0));

		do

			{

			User::LeaveIfError(socket.GetOpt(KSoInetNextInterface, KSolInetIfCtrl, info));

			}

		while ( q.iName != name().iName );

		if ( q.iState == EIfUp &&

			q.iAddress.Family() == KAfInet6 && !q.iAddress.IsV4Mapped() )

			{

			if ( (TUint)aFamily == KAfInet6 )

				{

				err = KErrNone;

				}

			}

		else if ( (TUint)aFamily == KAfInet )

			{

			err = KErrNone;

			}

#if 0

			switch (aFamily)

			{

			case KAfInet6:

				if ( name().iName.FindF( KIp6Interface1 ) != KErrNotFound ||

					name().iName.FindF( KIp6Interface2 ) != KErrNotFound )

					{

					err = KErrNone;

					}

				break;

			case KAfInet:

				if ( name().iName.FindF( KIp6Interface1 ) == KErrNotFound &&

					name().iName.FindF( KIp6Interface2 ) == KErrNotFound )

					{

					err = KErrNone;

					}

				break;

			};

#endif

			name().iIndex++;

		}

	User::LeaveIfError(err);	// make sure we found something useful

	CleanupStack::PopAndDestroy( 1 ); //socket

	iInterfaceName = name().iName;

	}

void CDHCPControl::Cancel()

{

   CompleteClientMessage( KErrCancel ); //cancel all. must be before the rest to avoid deadlock with ESOCK

    if(iDhcpStateMachine)

        {

        iDhcpStateMachine->Cancel();

        }

   iInitStartedByRenew = EFalse;

}

TBool CDHCPControl::CompleteClientMessage(TInt aError, TInt aFunctionToCancel)

/** 

  * If necessary then complete client.

  *   If complete is performed, true is returned

  */

	{

	if (iMessage &&

		 !iMessage->IsNull() &&

		  ( aFunctionToCancel == -1 || aFunctionToCancel == iMessage->Function() || EConfigDaemonDeregister == iMessage->Function() ) )

		{

		iMessage->Complete(aError);

		iMessage = NULL;

		return ETrue;

		}

	return EFalse;

	}

void CDHCPControl::BindingFinishedL()

   {

   //cancel any pending timer

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPControl::BindingFinishedL")));

	iTimer->Cancel();

	UpdateDns(iDhcpStateMachine->iHostName, iDhcpStateMachine->iDomainName);

	iDhcpStateMachine->iStartedAquisitionAt.HomeTime(); //remember acquisition time

	/** A compromise til we have implemented the "lifetime" option (#42) for

	  *  stateless configuration mode - if iRenewalTimeT1 hasn't been read (because we

	  *   didn't read IA information), we don't attempt a renew later.

	  *    This prevents entry to the renew functionality which acts as though we are

	  *     in stateful mode (attempting a full renew / rebind / re-lease)

	  */

	if(iDhcpStateMachine->iRenewalTimeT1)

		{

		//Start renewal timer

		iTimer->After(static_cast<TTimeIntervalSeconds>(iDhcpStateMachine->iRenewalTimeT1), *this);

		}

	SaveMessageBufferForLaterReference();

	ServiceAnyOutstandingIoctlL();

	CompleteClientConfigureMessage(KErrNone);

	DHCP_DEBUG_PUBLISH_READY(DHCPDebug::EReady);

	}

void CDHCPControl::ServiceAnyOutstandingIoctlL()

	{

	if(iMessage && !iMessage->IsNull() && (iMessage->Function() == EConfigDaemonIoctl || iMessage->Function() == EConfigDaemonDeregister))

		{

		TInt err = KErrNone;

		// Run the request again, this time service it (because iMessage is set).  We need

		// to check to make sure the IOCTL is not a renew which has caused a reinitialisation

		// - we don't want to restart the IOCTL!.

		if( ( ( iState != EInitInProgress ) && ( iState != EInformInProgress ) ) || !iInitStartedByRenew )

			{

			TRAP(err,HandleClientRequestL(*iMessage));

			}

		iInitStartedByRenew = EFalse;

		CompleteClientIoctlMessage(err);

		}

	}

#ifdef SYMBIAN_NETWORKING_DHCPSERVER	

void CDHCPControl::ServiceAnyOutstandingServerIoctlL()

	{

	if(iMessage && !iMessage->IsNull() && iMessage->Function() == EConfigDaemonIoctl)

		{

		// run the request again, this time service it (because iMessage is set)

		TRAPD(err,HandleClientRequestL(*iMessage));

		CompleteServerIoctlMessage(err);

		}

	}

#endif // SYMBIAN_NETWORKING_DHCPSERVER			

void CDHCPControl::SaveMessageBufferForLaterReference()

	{

	//save the msg buffer in case user wants to retrieve any info

	TPtr8 messageBuf = iDhcpStateMachine->Message()->Message().Des();

	TInt len = messageBuf.Length();

	TInt err = KErrNone;

	if ( iValidMsg.MaxLength() < len )

			{

			//we cannot use any other buffer (e.g ~CMessageSender one) unfortunately since the

			//message options are valid over potential renew/rebind initalised manualy, by

			//timeout or reconfigure.

			iValidMsg.Close();

			err = iValidMsg.Create(len);

			}

		//if we cannot create the iValidMsg then, well, bad luck

		if ( err == KErrNone )

			{

			iValidMsg.Copy(messageBuf); 

			}

		else

			{

			__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPControl::SaveMessageBufferForLaterReference Error %d: couldn't store received message"),err));

			}

#ifdef SYMBIAN_NETWORKING_DHCP_MSG_HEADERS

		if (iDhcpStateMachine->iDhcpInformAckPending && iMessage)

			{

			TRAPD(err,InformCompleteRequestHandlerL());

			CompleteClientIoctlMessage(err);

			iDhcpStateMachine->iDhcpInformAckPending=EFalse;

			}	

#endif // SYMBIAN_NETWORKING_DHCP_MSG_HEADERS

#ifdef SYMBIAN_NETWORKING_DHCPSERVER

	if(iDHCPServerImpl)

		{

		if(iDNSRawOption)

			{

			TPtr8 ptr = iDNSRawOption->Des();

			HandleSetRawOptionCodeL(&ptr);

			}

		}

#endif // 	SYMBIAN_NETWORKING_DHCPSERVER

	}

TBool CDHCPControl::OnCompletion( CStateMachine* aStateMachine )

/**

  * OnCompletion 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

  */

	{

	TRAPD(err, TaskCompleteL(aStateMachine->LastError()));

	if (err != KErrNone)

		{

		// complete the client if this release was prompted by them

		if(CompleteClientConfigureMessage(err))

			{

			// i.e. only if client is waiting for a configure action (not ioctl)

			if(err != KErrNoMemory )

				{

				// by doing this we will make sockets get errored as there is no src addr

				iDhcpStateMachine->RemoveConfiguredAddress();

				iValidMsg.Close();

				}

			}

		}

	return EFalse; //Always!!!

	}

void CDHCPControl::SaveAndHandleClientRequestL(const RMessage2& aMessage,TUint aOptionName,TInt aValue )

	{

	TInt deferRequest=0;

	deferRequest = CDHCPControl::HandleClientRequestL(aOptionName,aValue);

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPControl::SaveAndHandleClientRequestL")));

	iMessage = &aMessage;

	if( !deferRequest )

		{

		CompleteClientIoctlMessage(KErrNone);

		}

	else

 		{

 		if (deferRequest < KErrNone )

 			{

 			//return the err Value and  complete immediately

			CompleteClientIoctlMessage(deferRequest);

			}

		}

	}

void CDHCPControl::HandleClientRequestL(const RMessage2& aMessage)

/**

  * Receives client requests from RConnection.

  * 

  * This is the base implementation that is called

  * to service client requests.  It handles the 

  * reading and writing of data into the message

  * and passes control to the derived implementation

  * to provide the correct info, then completes the message

  * when done.  If there is an error the message

  * is completed by the session.

  *

  * DEFERRING:

  *

  * When the request is first made, and it's possible to defer the request.

  *  This is done by setting iMessage to the message.

  *

  * @internalTechnology

  */

	{

	if (aMessage.Function() == EConfigDaemonDeregister)

		{

		iDhcpDaemonDeregister = ETrue;

		SaveAndHandleClientRequestL(aMessage,KConnAddrRelease);	

		return;	

		}

	if(aMessage.Function() != EConfigDaemonIoctl ||

	   iMessage != 0 && iMessage != &aMessage)

		{

		User::Leave(KErrUnknown);

		}

	TUint optionName = aMessage.Int1();

	TInt length      = aMessage.Int3();

#ifdef SYMBIAN_NETWORKING_DHCP_MSG_HEADERS

	TInt desLength= aMessage.GetDesLength(2);

#endif // SYMBIAN_NETWORKING_DHCP_MSG_HEADERS

#if _DEBUG

    if(optionName & KDhcpInterfaceDbgIoctl)

    	{

    	HandleInterfaceDebugL(aMessage);

    	}

	else

#endif

	if (length>0)

		{

#ifdef SYMBIAN_NETWORKING_DHCPSERVER			

			//Only below commands are supported by DHCP server implementation.

			//Any other commands are not supported.

			if(iDHCPServerImpl)

				{

#ifndef SYMBIAN_NETWORKING_ADDRESS_PROVISION

				if(optionName != KConnSetDhcpRawOptionData )

#else

				if((optionName != KConnSetDhcpRawOptionData ) && (optionName != KConnDhcpSetHwAddressParams))

#endif //SYMBIAN_NETWORKING_ADDRESS_PROVISION

					{

					CompleteClientIoctlMessage(KErrNotSupported);

					}

				}

#endif // SYMBIAN_NETWORKING_DHCPSERVER	

		if(optionName == KConnAddrRenew)

			{

			//processing renew with user defined timeout

			TInt secValue;

			TPckg<TInt> val(secValue);

			aMessage.ReadL(2, val,0);

			SaveAndHandleClientRequestL(aMessage, optionName,secValue);	

			}

		else

			{

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

			TPtr8 ptr = buffer->Des();

			aMessage.ReadL(2, ptr);

#ifdef SYMBIAN_NETWORKING_DHCP_MSG_HEADERS

			ptr.SetLength(desLength);

#endif // SYMBIAN_NETWORKING_DHCP_MSG_HEADERS

			TInt deferRequest =  HandleClientRequestL(optionName, &ptr);

			iMessage = &aMessage;

			if( !deferRequest )

				{

				// request was serviced.. complete immediately

				aMessage.WriteL(2, ptr);

				CompleteClientIoctlMessage(KErrNone);

#ifdef SYMBIAN_NETWORKING_DHCP_MSG_HEADERS

				iDhcpStateMachine->iDhcpInformAckPending=EFalse;

#endif//SYMBIAN_NETWORKING_DHCP_MSG_HEADERS					

				}

			else

				{

				if (deferRequest < KErrNone)

					{

					//return the err Value and  complete immediately

					CompleteClientIoctlMessage(deferRequest);

					}

				}	

			CleanupStack::PopAndDestroy(buffer);

			}

		}

	else

		{

		SaveAndHandleClientRequestL(aMessage,optionName);

		}

	}

void CDHCPControl::HandleInterfaceDebugL(const RMessage2& aMessage)

/**

  * Receives client requests for Debug on this interface.

  * 

  * @internalTechnology

  */

	{

#ifdef _DEBUG

//-- perform debug control from the client side.

//-- Enabled for debug builds only.

	TUint optionName = aMessage.Int1();

	TInt length      = aMessage.Int3();

    TInt nResult     = KErrNone;

    if(optionName & KDhcpInterfaceDbgIoctl)

    	{

        TPckgBuf<TInt> ctlParamBuf;

        TInt ctlParam = 0;

        //-- read IOCTL parameter if appropriate

        if(optionName & KConnReadUserDataBit)

            {

            //-- the parameter should be TUint as it is a debug control parameter

            if(length != static_cast<TInt>(sizeof(TUint)))

    			{

        		nResult = KErrArgument; //-- wrong parameter type

        		}

        	else

        		{

            	aMessage.ReadL(2, ctlParamBuf);

				ctlParam = ctlParamBuf();

				}

			}

		if(nResult == KErrNone)

		{

	        //-- perform IOCTL functon

	        switch(optionName)

	        	{

	            case KDHCP_GetPubSubMonitorHandle:    

	                //-- easy handle.. state machine pointer.

	                ctlParam = (TInt)iDhcpStateMachine;

	                nResult = KErrNone;

	            	break;

	            default:

	                nResult = KErrArgument; //-- wrong function

	       	 	}//switch

			//-- write IOCTL result if appropriate

			if(optionName & KConnWriteUserDataBit)

				{

				ctlParamBuf() = ctlParam;

				aMessage.WriteL(2,ctlParamBuf);

				}

    	}

        aMessage.Complete(nResult);

    	}

#else

	aMessage.Complete(KErrNotSupported);

#endif

	}

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

/**

  * Open and attach to the RConnection

  *

  * @internalTechnology

  */

	{

	// This ConfigureL is called at the start of the derived class ConfigureL.

	iMessage = aMessage;