// 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:
// The DHCPStateMachine header file
// 
//

/**
 @file DHCPStateMachine.h
*/

#ifndef DHCPSTATEMACHINE_H
#define DHCPSTATEMACHINE_H

#include <e32base.h>
#include <comms-infras/statemachine.h>

#include "MsgSender.h"
#include "DHCP_Std.h"

class CExpireTimer;
class CDHCPMessageHeader;
class CDHCPState;
#ifdef SYMBIAN_NETWORKING_ADDRESS_PROVISION
class CDhcpHwAddrManager;
#endif //SYMBIAN_NETWORKING_ADDRESS_PROVISION

#ifdef SYMBIAN_NETWORKING_DHCPSERVER
enum TSvrState
	{
	ESvrBinding,
	ESvrWaitForAnyDHCPMsgs,
	ESvrWaitForDiscoverInform,
	ESvrEnd
	};

enum TSvrSpecificState
	{
	ESvrDiscoverInProgress,
	ESvrInformInProgress,
	ESvrRenewInProgress,
	ESvrRebindInProgress,
	ESvrDeclineInProgress,
	ESvrReleaseInProgress,
	};
#endif // SYMBIAN_NETWORKING_DHCPSERVER	
	
class CDHCPStateMachine : public CStateMachine, public MMSListener
/**
  * Implements helper function abstractions
  *
  * @internalTechnology
  */
	{
friend class CDHCPControl;
friend class CDHCPDb;
friend class CDHCPAddressAcquisition;
friend class CDHCPSelect;
friend class CDHCPRebootConfirm;
friend class CDHCPInformationConfig;
friend class CDHCPRequest;
friend class CDHCPRenew;
friend class CDHCPRebind;
friend class CDHCPWaitForClientMsgs;

public:
   enum EAddressType
      {
      EAllAvailableServers,
      EUnicast
      };

	enum EInitialisationContext
		{
		EFirstCall,
		ESubsequentCalls
		};

public:
	~CDHCPStateMachine();

	void Cancel();

	virtual void GetServerAddress( TInetAddr& aAddress ) = 0;
  	virtual void SetCurrentAddress(const TInetAddr& aCurrentAddress, const TInetAddr& aSubnetMask) = 0;
	void SetCurrentAddress(const TInetAddr& aCurrentAddress);
#ifdef SYMBIAN_NETWORKING_DHCPSERVER	
	virtual void GetClientAddress(TInetAddr& aAddress);
	virtual void InitServerStateMachineL(MStateMachineNotify* aStateMachineNotify);
	virtual void InitServerBinding(MStateMachineNotify* aStateMachineNotify);	
	virtual void CloseNSendServerMsgL(TRequestStatus& aStatus, CDHCPStateMachine::EAddressType aEAddressType);
	void CloseNSendSvrMsgL(TTimeIntervalSeconds aSecs, TInt aMaxRetryCount, CDHCPStateMachine::EAddressType aEAddressType);
	virtual CDHCPState* ReceiveOnPort67L( TRequestStatus* aStatus ) = 0;
	virtual void InitialiseServerSocketL() = 0;
   	virtual void CreateOfferMsgL() = 0;
   	virtual void HandleRequestMsgL() = 0;
   	virtual void HandleInformMsgL() = 0;   	
   	void SetClientIdentified(TBool aClientIdentified);
   	TBool IsClientIdentified();
   	void SetServerState(TBool aServerImpl);
   	void FetchServerAddressL();
	TBool CheckNetworkId();
	TInt BindServerInterface();
	TInetAddr GetInterfaceServerGlobalAddress();
	void SetDNSInformation(TDes8* aDNSInfo);
#endif // SYMBIAN_NETWORKING_DHCPSERVER	
	// returns unspecified address if no global address present
	TInetAddr GetInterfaceGlobalAddress();
	
	TBool DoesInterfaceKnowAnyDNSServers();

   //dhcpIPX tasks
   virtual void StartInitL(MStateMachineNotify* aStateMachineNotify, EInitialisationContext aInitialisationContext, TInt aUserTimeOut = 0 ) = 0;
   virtual void StartInformL(MStateMachineNotify* aStateMachineNotify, TBool aStaticAddress) = 0;
   virtual void StartRebootL(MStateMachineNotify* aStateMachineNotify) = 0;
   virtual void StartRenewL(MStateMachineNotify* aStateMachineNotify, TInt aUserTimeOut) = 0;
   virtual void StartDeclineL(MStateMachineNotify* aStateMachineNotify) = 0;
   virtual void StartReleaseL(MStateMachineNotify* aStateMachineNotify) = 0;
   virtual void StartRebindL(MStateMachineNotify* aStateMachineNotify) = 0;

   virtual void RemoveConfiguredAddress(const TInetAddr *aInetAddr = NULL ) = 0;
   void RemoveConfiguredAddress( const TSoInet6InterfaceInfo& aSoInet6InterfaceInfo );

   //interface used by CDHCPXXStates derivatives
	virtual void CloseNSendMsgL(TRequestStatus& aStatus, CDHCPStateMachine::EAddressType aEAddressType);
   void CloseNSendMsgL(TTimeIntervalSeconds aSecs, TInt aMaxRetryCount, CDHCPStateMachine::EAddressType aEAddressType);
   virtual CDHCPState* ReceiveL( TRequestStatus* aStatus ) = 0;
   void CancelMessageSender();

   virtual void InitialiseSocketL() = 0;
   virtual void CreateDiscoverMsgL() = 0;                //discover IP4 solicit IP6
   virtual void CreateOfferAcceptanceRequestMsgL() = 0;  //request after offer IP4 advertise IP6
   virtual void CreateRebootRequestMsgL() = 0;           //reboot IP4 confirm IP6
   virtual void CreateInformMsgL() = 0;                  //no IP address is required (static address IP4 stateless neg. IP6)
   virtual void CreateDeclineMsgL() = 0;
   virtual void CreateRenewRequestMsgL() = 0;
   virtual void CreateRebindRequestMsgL() = 0;
   virtual void CreateReleaseMsgL() = 0;
   virtual void HandleOfferL() = 0;                      //after discover IP4 solicit IP6 or rebind(IP4/IP6)
   virtual CDHCPState* HandleReplyL( TRequestStatus* aStatus ) = 0;//after request
   TInt BindToSource();
   virtual void BindSocketForUnicastL() = 0;

   //interface used by both CDHCPXXStates derivatives & CDHCPXXControl
   void StartTimer(TTimeIntervalSeconds aSeconds, MExpireTimer& aExpireTimer);
   void StartTimer( TTimeIntervalMicroSeconds32 aMicroSeconds, MExpireTimer& aExpireTimer);
   void CancelTimer();
   TBool TimerActive() const;
   TBool IsGettingCfgInfoOnly() const;
   void SetAsyncCancelHandler(CDHCPState* aStateOwner);

   virtual TInt MSReportError(TInt aError);
   
	CDHCPMessageHeader* Message() const;
	const TName& InterfaceName() const
		{
		return iInterfaceName;
		}
	void SetIdle( TBool aIdle );
	TBool Idle();
	void SetFastTimeoutDuringInform();
	TBool FastTimeoutDuringInform();
	void SetCompleteClientRequestTrue();
	void SetCompleteClientRequestFalse();
	TBool CompleteClientRequest();
#ifdef SYMBIAN_DNS_PROXY	
	TInetAddr GetListenerAddress();
#endif // SYMBIAN_DNS_PROXY
	
protected:
   
#ifdef SYMBIAN_NETWORKING_DHCPSERVER
#ifdef SYMBIAN_NETWORKING_ADDRESS_PROVISION
   CDHCPStateMachine(RSocketServ& aEsock, RConnection& aConnection, const TName& aInterfaceName, CDhcpHwAddrManager* aDhcpHwAddrManager, TBool aDHCPServerImpl);
#else
   CDHCPStateMachine(RSocketServ& aEsock, RConnection& aConnection, const TName& aInterfaceName,TBool aDHCPServerImpl);
#endif //SYMBIAN_NETWORKING_ADDRESS_PROVISION
#else   
   CDHCPStateMachine(RSocketServ& aEsock, RConnection& aConnection, const TName& aInterfaceName);
#endif //  SYMBIAN_NETWORKING_DHCPSERVER
   void ConstructL();
   void Start(MStateMachineNotify* aStateMachineNotify);

   virtual void DoCancel();

   virtual void AssembleClientIDsL() = 0;
   void FetchHWAddress();

   void ConfigureInterfaceL( const TSoInet6InterfaceInfo& aInterfaceInfo );
   virtual void PrepareToSendL(CDHCPStateMachine::EAddressType aEAddressType) = 0;
#ifdef SYMBIAN_NETWORKING_DHCPSERVER   
   	virtual void PrepareToSendServerMsgL(CDHCPStateMachine::EAddressType aEAddressType) = 0;
	void AddScopeToClientAddrL(TInetAddr& addr);
#endif // SYMBIAN_NETWORKING_DHCPSERVER	
   virtual void AssignAddresses( TInetAddr& aDest, const TInetAddr& aSrc ) const = 0;
   TUint32 GetNetworkIdL() const;
   void AddScopeToAddrL(TInetAddr& addr);

protected:
	const TName& iInterfaceName;
	RSocketServ& iEsock;
	RConnection& iConnection;
	CDHCPMessageHeader* iDhcpMessage;
	CMessageSender* iMessageSender;
	CExpireTimer* iTimer;

	TSockAddr iHardwareAddr;
#ifdef SYMBIAN_NETWORKING_DHCPSERVER	
	TSockAddr iClientHWAddr;
	TInetAddr iInformClientAddr;
#ifdef SYMBIAN_NETWORKING_ADDRESS_PROVISION
	CDhcpHwAddrManager* iDhcpHwAddrManager;
#endif //SYMBIAN_NETWORKING_ADDRESS_PROVISION
	
#endif // SYMBIAN_NETWORKING_DHCPSERVER	
	CDHCPState* iAsyncCancelHandler; //iAsyncCancelHandler is set by the DHCP State that assumes ownership of the RequestStatus object of CDHCPStateMachine 

public: 
   //accessed by CDHCPIP6MessageReader
	RSocket iSocket;
	TInetAddr iSocketAddr;
#ifdef SYMBIAN_NETWORKING_DHCPSERVER	
	RSocket iSvrSocket;//For the Server Impl
	TInetAddr iSrvSocketAddr;
	TSvrState iSvrState;
	TSvrSpecificState iSvrSpecificState;
	HBufC8* 	iDNSInformation;
#endif // SYMBIAN_NETWORKING_DHCPSERVER	

#ifdef SYMBIAN_DNS_PROXY
	TBuf8<KMaxName>   iProxyHostName;
	TBuf8<KMaxName>   iProxyDomainName;
	TInetAddr   iProxyDnsSrvAddr;
	TInetAddr   iClientStaticAddr;
	TUint32     iOfferedAddress;
	TBuf8<KMaxName>     iClientHostName;
#endif // SYMBIAN_DNS_PROXY
		
protected:
	TDhcpRnd iXid;
	TBool iCfgInfoOnly; //if ETrue then:
							  //for IP4 indicates that a static address is used
							  //for IP6 if set during negotiation it indicates the same as for IP4
							  //			if set by CDHCPIP6Reconfigure states it indicates that the server wants us
							  //			to start inform-request rather than renew request
	TBool iMakeIdle;		  // used only for IP6, when RA recvd, with both 'M' and 'O' flags as false, this flag makes statemachine idle
	TBool iFastTimeout;
	TBool iCompleteClientRequest;	//used only for IP6, set to ETrue when 'O' flag in RA is set
   
	//data read from CommDb &&|| stored in persistent storage
	//the "public" should be replaced by some more inteligent way of dealing with persistent & init data
	//common for IP4 & IP6(maybe EPOC wide persistent storage?)
    //for IP6 it's the first address from the first IA option in the reply message
  	TInetAddr iCurrentAddress;
	TTime iTaskStartedAt;			// Time that task started. If sucessful it is copied to iStartedAquisitionAt
	TTime iStartedAquisitionAt;	// Time that lease period started

	TInetAddr iDefGateway;

	TBool iNameServerAddressesFromServer;
	TInetAddr iNameServer1;
	TInetAddr iNameServer2;

	//DNS client names
	HBufC8*   iHostName;
	HBufC8*   iDomainName;

	TUint32 iRenewalTimeT1;			// number of seconds after iStartedAquisitionAt when we send a renew request
	TUint32 iRebindTimeT2;			// number of seconds after iStartedAquisitionAt when we send a rebind request (only if any renew fails)
	TUint32 iLeaseTime;				// number of seconds after iStartedAquisitionAt when the lease expires

	TBool iReceiving;				//ETrue if we are waiting to receive data from socket

	CDHCPState* iFirstState; //accessed by CDHCPIP6ListenToNeighbor
	RBuf8 iClientId;  //accessed from CDhcpDb
	
	TInt iMaxRetryCount;	//IPv6 calculates its own retry values..so iMaxRetryCount is ignored
	TInt iRetryDhcpIpCount;	//number of retry for DHCP IP in case a DAD is detected.

#ifdef SYMBIAN_NETWORKING_DHCPSERVER
	TUint32 iYiaddr;
	TUint32 iCiaddr;
	TUint16 iFlag;							  
	TUint8 iMesgType;							  
	TBool iClientIdentified;
	TBool iServerImpl;
#endif // 	SYMBIAN_NETWORKING_DHCPSERVER	
#ifdef SYMBIAN_NETWORKING_DHCP_MSG_HEADERS
public:	
	TBool iDhcpInformAckPending;
	RBuf8 iSavedExtraParameters;
#endif //SYMBIAN_NETWORKING_DHCP_MSG_HEADERS	
	};
	
#ifdef SYMBIAN_NETWORKING_DHCPSERVER
#ifndef SYMBIAN_NETWORKING_ADDRESS_PROVISION
inline CDHCPStateMachine::CDHCPStateMachine(RSocketServ& aEsock, RConnection& aConnection, const TName& aInterfaceName,TBool aDHCPServerImpl):
                     iInterfaceName(aInterfaceName),
                     iEsock(aEsock),
                     iConnection(aConnection),
                     iCfgInfoOnly( EFalse ),iMaxRetryCount(KInfinity),
					 iMakeIdle (EFalse),
					 iFastTimeout (EFalse),
					 iServerImpl(aDHCPServerImpl),
					 iRetryDhcpIpCount(0)
#else
inline CDHCPStateMachine::CDHCPStateMachine(RSocketServ& aEsock, RConnection& aConnection, const TName& aInterfaceName, CDhcpHwAddrManager* aDhcpHwAddrManager, TBool aDHCPServerImpl):
                     iInterfaceName(aInterfaceName),
                     iEsock(aEsock),
                     iConnection(aConnection),
                     iCfgInfoOnly( EFalse ),iMaxRetryCount(KInfinity),
					 iMakeIdle (EFalse),
					 iFastTimeout (EFalse),
					 iServerImpl(aDHCPServerImpl),
					 iRetryDhcpIpCount(0),
					 iDhcpHwAddrManager(aDhcpHwAddrManager)
#endif //SYMBIAN_NETWORKING_ADDRESS_PROVISION
/**
  * Constructor of the DHCPStateMachine
  *
  * @internalTechnology
  *
  */
	{
	}
#else 

inline CDHCPStateMachine::CDHCPStateMachine(RSocketServ& aEsock, RConnection& aConnection, const TName& aInterfaceName):
	iInterfaceName(aInterfaceName),
	iEsock(aEsock),
	iConnection(aConnection),
	iCfgInfoOnly( EFalse ),iMaxRetryCount(KInfinity),
	iMessageSender(NULL),
	iMakeIdle(EFalse),
	iFastTimeout(EFalse),
	iRetryDhcpIpCount(0)
/**
  * Constructor of the DHCPStateMachine
  *
  * @internalTechnology
  *
  */
	{
	}
#endif // SYMBIAN_NETWORKING_DHCPSERVER
inline CDHCPMessageHeader* CDHCPStateMachine::Message() const
	{
	return iDhcpMessage;
	}
	
inline void CDHCPStateMachine::CancelMessageSender()
   {
	if (iMessageSender != NULL)
		iMessageSender->Cancel();
   }

inline TBool CDHCPStateMachine::TimerActive() const
	{
	return iTimer != NULL ? iTimer->IsActive() : EFalse;
	}

inline void CDHCPStateMachine::CancelTimer()
	{
	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPStateMachine::CancelTimer")));

	if (iTimer != NULL)
		iTimer->Cancel();
	}

inline TBool CDHCPStateMachine::IsGettingCfgInfoOnly() const
	{
	return iCfgInfoOnly;
	}

inline void CDHCPStateMachine::SetAsyncCancelHandler(CDHCPState* aStateOwner) 
	{	
	iAsyncCancelHandler =  aStateOwner;
	}	

inline void CDHCPStateMachine::SetCurrentAddress(const TInetAddr& aCurrentAddress)
/**
  * The SetCurrentAddress function
  *
  * Stores ip address
  *
  * @internalTechnology
  */
	{
	iCurrentAddress = aCurrentAddress;
	}

inline void CDHCPStateMachine::SetIdle ( TBool aIdle )
	{
	iMakeIdle = aIdle;
	}

inline TBool CDHCPStateMachine::Idle ()
	{
	return iMakeIdle;
	}

inline void CDHCPStateMachine::SetFastTimeoutDuringInform()
	{
	iFastTimeout = ETrue;
	}

inline TBool CDHCPStateMachine::FastTimeoutDuringInform()
	{
	return iFastTimeout;
	}


inline void CDHCPStateMachine::SetCompleteClientRequestTrue()
	{
	iCompleteClientRequest = ETrue;
	}

inline void CDHCPStateMachine::SetCompleteClientRequestFalse()
	{
	iCompleteClientRequest = EFalse;
	}

inline TBool CDHCPStateMachine::CompleteClientRequest()
	{
	return iCompleteClientRequest;
	}


#ifdef SYMBIAN_NETWORKING_DHCPSERVER	
inline void CDHCPStateMachine::SetClientIdentified(TBool aClientIdentified)
	{
	iClientIdentified = aClientIdentified;
	}

inline TBool CDHCPStateMachine::IsClientIdentified()
	{
	return iClientIdentified;
	}

#endif 	// SYMBIAN_NETWORKING_DHCPSERVER	

#endif