windows-xp/Source/XPSP1/NT/net/mmc/dhcp/server.h

/**********************************************************************/
/**                       Microsoft Windows/NT                       **/
/**                Copyright(c) Microsoft Corporation, 1997 - 1999 **/
/**********************************************************************/

/*
	server.h
		This file contains the prototypes for a DHCP Server
		object and the Bootp and Global Options objects
		contained within it.  The other object that a can be
		within a DHCP server is a superscope, which is defined is
		in cdhcpss.cpp and cdhcpss.h.
		
    FILE HISTORY:
        
*/

#ifndef _SERVER_H
#define _SERVER_H

#ifndef _DHCPHAND_H
#include "dhcphand.h"
#endif

#ifndef _SERVSTAT_H
#include "servstat.h"   // Server statistics
#endif

#ifndef _SSCPSTAT_H
#include "sscpstat.h"   // Superscope statistics
#endif

#ifndef _CLASSMOD_H
#include "classmod.h"    // Class Stuff
#endif

#define SERVER_OPTION_AUTO_REFRESH      0x00000001
#define SERVER_OPTION_AUDIT_LOGGING     0x00000002
#define SERVER_OPTION_SHOW_BOOTP        0x00000004
#define SERVER_OPTION_EXTENSION         0x00000008 // this server was added as an extension
#define SERVER_OPTION_SHOW_ROGUE        0x00000010

#define AUTO_REFRESH_HOURS_MAX		    23
#define AUTO_REFRESH_MINUTES_MAX	    59
#define AUTO_REFRESH_SECONDS_MAX	    59

#define DHCP_QDATA_VERSION			    0x00000001
#define DHCP_QDATA_SERVER_INFO		    0x00000002
#define DHCP_QDATA_STATS                0x00000003
#define DHCP_QDATA_CLASS_INFO           0x00000004
#define DHCP_QDATA_MCAST_STATS          0x00000005
#define DHCP_QDATA_OPTION_VALUES        0x00000006
#define DHCP_QDATA_ROGUE_INFO           0x00000007
#define DHCP_QDATA_SERVER_ID            0x00000008
#define DHCP_QDATA_SUBNET_INFO_CACHE    0x00000009

typedef struct DhcpRogueInfo_tag
{
    BOOL    fIsRogue;
    BOOL    fIsInNt5Domain;
}
DHCP_ROGUE_INFO, * LPDHCP_ROGUE_INFO;

typedef struct DhcpServerInfo_tag
{
	BOOL	fAuditLog;
	DWORD	dwPingRetries;
    CString strDatabasePath;
    CString strBackupPath;

    // audit logging stuff
    CString strAuditLogDir;
    DWORD   dwDiskCheckInterval;
    DWORD   dwMaxLogFilesSize;
    DWORD   dwMinSpaceOnDisk;
    
	// Does it support DynamicBOOTP?
	BOOL	fSupportsDynBootp;

	// Does it support Bindings?
	BOOL    fSupportsBindings;
}
DHCP_SERVER_CONFIG, * LPDHCP_SERVER_CONFIG;

typedef struct DhcpServerId_tag
{
	CString				strIp;
	CString				strName;
}
DHCP_SERVER_ID, * LPDHCP_SERVER_ID;

class CDhcpGlobalOptions;
class CSubnetInfoCache;

/*---------------------------------------------------------------------------
	Class:	CDhcpServer
 ---------------------------------------------------------------------------*/
class CDhcpServer : public CMTDhcpHandler
{
public:
    CDhcpServer(ITFSComponentData* pTFSComponentData, LPCWSTR pServerName = NULL);
	~CDhcpServer();

// Interface
public:
	// base handler functionality we override
	OVERRIDE_NodeHandler_HasPropertyPages();
    OVERRIDE_NodeHandler_CreatePropertyPages();
	OVERRIDE_NodeHandler_OnAddMenuItems();
	OVERRIDE_NodeHandler_OnCommand();
	OVERRIDE_NodeHandler_GetString();
    
    OVERRIDE_BaseHandlerNotify_OnCreateNodeId2();

    OVERRIDE_NodeHandler_DestroyHandler();

	// Choose which messages we want to handle
    OVERRIDE_BaseHandlerNotify_OnDelete();
    OVERRIDE_BaseHandlerNotify_OnPropertyChange();

    // Result handler functionality 
    OVERRIDE_BaseResultHandlerNotify_OnResultSelect();
    OVERRIDE_BaseResultHandlerNotify_OnResultDelete();

    OVERRIDE_ResultHandler_OnGetResultViewType();

public:
	// CMTDhcpHandler functionality
	virtual HRESULT  InitializeNode(ITFSNode * pNode);
	virtual int      GetImageIndex(BOOL bOpenImage);
	ITFSQueryObject* OnCreateQuery(ITFSNode * pNode);
    virtual void     OnHaveData(ITFSNode * pParentNode, ITFSNode * pNode);
	virtual void     OnHaveData(ITFSNode * pParentNode, LPARAM Data, LPARAM Type);
    virtual DWORD    UpdateStatistics(ITFSNode * pNode);
    ITFSQueryObject* OnCreateStatsQuery(ITFSNode *pNode);
    virtual void     UpdateToolbar(IToolbar * pToolbar, LONG_PTR dwNodeType, BOOL bSelect);
    
    void     UpdateConsoleVerbs(ITFSComponent* pComponent, IConsoleVerb * pConsoleVerb, LONG_PTR dwNodeType, BOOL bMultiSelect = FALSE);
	
    STDMETHOD(OnNotifyExiting)(LPARAM);

    HRESULT OnUpdateToolbarButtons(ITFSNode * pNode, LPDHCPTOOLBARNOTIFY pToolbarNotify);

public:
	// implementation specific	
    BOOL    FEnableCreateSuperscope(ITFSNode * pNode);
    void    UpdateToolbarStates(ITFSNode * pNode);
    void    SetExtensionName();
    HRESULT BuildDisplayName(CString * pstrDisplayName);

    LPCWSTR	GetIpAddress();
	void    GetIpAddress(DHCP_IP_ADDRESS *pdhcpIpAddress);

    LPCTSTR GetName() { return m_strDnsName; }
    void    SetName(LPCTSTR pName) { m_strDnsName = pName; }

    BOOL    GetDefaultOptions();
	CDhcpOption * FindOption(DHCP_OPTION_ID dhcpOptionId, LPCTSTR pszVendor);

	void    SetVersion(LARGE_INTEGER & liVersion)
		        { m_liDhcpVersion.QuadPart = liVersion.QuadPart; }
	void    GetVersion(LARGE_INTEGER & liVersion) 
		        { liVersion.QuadPart = m_liDhcpVersion.QuadPart; } 

	DWORD   CreateScope(DHCP_IP_ADDRESS dhcpSubnetAddress,
					    DHCP_IP_ADDRESS dhcpSubnetMask,
					    LPCTSTR		    pName,
					    LPCTSTR	        pComment);
	
	DWORD   CreateMScope(LPDHCP_MSCOPE_INFO pMScopeInfo);

    DWORD   DeleteScope(ITFSNode * pScopeNode, BOOL * pfWantCancel = NULL);
    DWORD   DeleteSubnet(DWORD dwScopeId, BOOL bForce = FALSE);

    DWORD   DeleteSuperscope(ITFSNode * pNode, BOOL * pfRefresh = NULL);
    DWORD   RemoveSuperscope(LPCTSTR pszName);

    DWORD   DeleteMScope(ITFSNode * pScopeNode, BOOL * pfWantCancel = NULL);
    DWORD   DeleteMSubnet(LPCTSTR pszName, BOOL bForce = FALSE);

    DWORD   SetConfigInfo(BOOL bAuditLogging, DWORD dwPingRetries, LPCTSTR pszDatabasePath = NULL, LPCTSTR pszBackupPath = NULL);
	DWORD   SetConfigInfo(DWORD dwSetFlags, LPDHCP_SERVER_CONFIG_INFO pServerConfigInfo);
	DWORD   SetConfigInfo(DWORD dwSetFlags, LPDHCP_SERVER_CONFIG_INFO_V4 pServerConfigInfo);

	DWORD   SetAutoRefresh(ITFSNode * pNode, BOOL bAutoRefreshOn, DWORD dwRefreshInterval);
    BOOL    IsAutoRefreshEnabled() { return m_dwServerOptions & SERVER_OPTION_AUTO_REFRESH; }
    void    GetAutoRefresh(BOOL * pbAutoRefreshOn, LPDWORD pdwRefreshInterval)
	{ 
		if (pbAutoRefreshOn) *pbAutoRefreshOn = m_dwServerOptions & SERVER_OPTION_AUTO_REFRESH;
		if (pdwRefreshInterval) *pdwRefreshInterval = m_dwRefreshInterval;
	}

	// default option functions
	LONG    CreateOption(CDhcpOption * pdhcType);
	LONG    DeleteOption(DHCP_OPTION_ID dhcid, LPCTSTR pszVendor);
	LONG    UpdateOptionList(COptionList * poblValues, COptionList * poblDefunct, CWnd *pwndMsgParent);
	void    DisplayUpdateErrors(COptionList * poblValues, COptionList * poblDefunct, CWnd *pwndMsgParent);

	// Functions to get and set the DNS reg option
	DWORD	GetDnsRegistration(LPDWORD pDnsRegOption);
	DWORD	SetDnsRegistration(DWORD DnsRegOption);
	
	LONG    ScanDatabase(DWORD FixFlag, LPDHCP_SCAN_LIST *ScanList, DHCP_IP_ADDRESS dhcpSubnetAddress);
	LONG    ScanDatabase(DWORD FixFlag, LPDHCP_SCAN_LIST *ScanList, LPWSTR pMScopeName);

    CDhcpDefaultOptionsOnServer * GetDefaultOptionsList() { return m_pDefaultOptionsOnServer; }
	CDhcpGlobalOptions * GetGlobalOptionsContainer();

	// These funtions allow initialization of cached values in the server object.
	// use SetConfigInfo to actually set them on the server
	BOOL    SetAuditLogging(BOOL bNewAuditLogging) 
    { 
        BOOL bOld = m_dwServerOptions & SERVER_OPTION_AUDIT_LOGGING; 
        m_dwServerOptions = bNewAuditLogging ? m_dwServerOptions | SERVER_OPTION_AUDIT_LOGGING :
                                               m_dwServerOptions & ~SERVER_OPTION_AUDIT_LOGGING; 
        return bOld; 
    }
    BOOL    GetAuditLogging() { return m_dwServerOptions & SERVER_OPTION_AUDIT_LOGGING; }
	DWORD   SetPingRetries(DWORD dwNewCount) { DWORD dwOld = m_dwPingRetries; m_dwPingRetries = dwNewCount; return dwOld; }
    DWORD   GetPingRetries() { return m_dwPingRetries; }

    void    SetAuditLogPath(LPCTSTR pszPath) { m_strAuditLogPath = pszPath; }

    // determine if the server has superscopes
    BOOL    HasSuperscopes(ITFSNode * pNode);

    // statistics information
    LPDHCP_MIB_INFO SetMibInfo(LPDHCP_MIB_INFO pMibInfo);
    LPDHCP_MIB_INFO DuplicateMibInfo();
    void            FreeDupMibInfo(LPDHCP_MIB_INFO pDupMibInfo);

    LPDHCP_MCAST_MIB_INFO SetMCastMibInfo(LPDHCP_MCAST_MIB_INFO pMibInfo);
    LPDHCP_MCAST_MIB_INFO DuplicateMCastMibInfo();
    void                  FreeDupMCastMibInfo(LPDHCP_MCAST_MIB_INFO pDupMibInfo);

    // adding child nodes sorted
    HRESULT AddScopeSorted(ITFSNode * pServerNode, ITFSNode * pScopeNode);
    HRESULT AddSuperscopeSorted(ITFSNode * pServerNode, ITFSNode * pScopeNode);
    HRESULT AddMScopeSorted(ITFSNode * pServerNode, ITFSNode * pScopeNode);
    HRESULT GetBootpPosition(ITFSNode * pServerNode, LONG_PTR * puRelativeFlag, LONG_PTR * puRelativeID);

    // hide/show/query bootp folders
    BOOL    IsBootpVisible() { return m_dwServerOptions & SERVER_OPTION_SHOW_BOOTP; }

    HRESULT ShowNode(ITFSNode * pServerNode, UINT uNodeType, BOOL bVisible);

    // access to the server options for save/restore
    DWORD   GetServerOptions() { return m_dwServerOptions; }
    void    SetServerOptions(DWORD dwServerOptions) { m_dwServerOptions = dwServerOptions; }
    
    HRESULT TriggerStatsRefresh(ITFSNode * pNode);

    void DisplayRogueWarning();

    // multicast scope stuff
    BOOL    DoesMScopeExist(ITFSNode * pServerNode, DWORD dwScopeId);

	// Dynamic Bootp support
	BOOL	FSupportsDynBootp() { return m_fSupportsDynBootp; }

	// Bindings support
	BOOL    FSupportsBindings() { return m_fSupportsBindings; }
    
	// Access to the classInfoarray
    void SetClassInfoArray(CClassInfoArray * pClassInfoArray)
    {
        CSingleLock sl(&m_csMibInfo);
        sl.Lock();

        m_ClassInfoArray.RemoveAll();
        m_ClassInfoArray.Copy(*pClassInfoArray);
    }

    void GetClassInfoArray(CClassInfoArray & ClassInfoArray)
    {
        CSingleLock sl(&m_csMibInfo);
        sl.Lock();

        ClassInfoArray.Copy(m_ClassInfoArray);
    }

    CClassInfoArray * GetClassInfoArray()
    {
        CSingleLock sl(&m_csMibInfo);
        sl.Lock();

        return &m_ClassInfoArray;
    }

    BOOL RemoveClass(LPCTSTR pClassName)
    {
        CSingleLock sl(&m_csMibInfo);
        sl.Lock();

        return m_ClassInfoArray.RemoveClass(pClassName);
    }

    void AddClass(LPCTSTR pName, LPCTSTR pComment, CByteArray & baData)
    {
        CSingleLock sl(&m_csMibInfo);
        sl.Lock();

        CClassInfo ClassInfo;

        ClassInfo.strName = pName;
        ClassInfo.strComment = pComment;
        ClassInfo.baData.Copy(baData);

        m_ClassInfoArray.Add(ClassInfo);
    }

    void SetOptionValueEnum(COptionValueEnum * pEnum)
    {
        CSingleLock sl(&m_csMibInfo);
        sl.Lock();

        m_ServerOptionValues.DeleteAll();
        m_ServerOptionValues.Copy(pEnum);
    }

    COptionValueEnum * GetOptionValueEnum()
    {
        CSingleLock sl(&m_csMibInfo);
        sl.Lock();

        return &m_ServerOptionValues;
    }

// Implementation
private:
	// Command handlers
	HRESULT OnDefineUserClasses(ITFSNode * pNode);
	HRESULT OnDefineVendorClasses(ITFSNode * pNode);
	HRESULT OnCreateNewSuperscope(ITFSNode * pNode);
	HRESULT OnCreateNewScope(ITFSNode * pNode);
	HRESULT OnCreateNewMScope(ITFSNode * pNode);
	HRESULT OnShowServerStats(ITFSNode * pNode);
	HRESULT OnSetDefaultOptions(ITFSNode * pNode);
	HRESULT OnReconcileAll(ITFSNode * pNode);
	HRESULT OnServerAuthorize(ITFSNode * pNode);
	HRESULT OnServerDeauthorize(ITFSNode * pNode);
	HRESULT OnDelete(ITFSNode * pNode);
    HRESULT OnControlService(ITFSNode * pNode, BOOL fStart);
    HRESULT OnPauseResumeService(ITFSNode * pNode, BOOL fPause);
    HRESULT OnRestartService(ITFSNode * pNode);
    HRESULT OnServerBackup(ITFSNode * pNode);
    HRESULT OnServerRestore(ITFSNode * pNode);

// Attributes
public:
	DWORD SetBindings(LPDHCP_BIND_ELEMENT_ARRAY BindArray);
	DWORD GetBindings(LPDHCP_BIND_ELEMENT_ARRAY &BindArray);
    BOOL                m_bStatsOnly;
    CSubnetInfoCache *  m_pSubnetInfoCache;

protected:
    void    UpdateResultMessage(ITFSNode * pNode);
    
    // we override this because we handle the error messages ourselves in UpdateResultMessage
    // by not returning anything the base class won't put up a result pane message
    void    GetErrorMessages(CString & strTitle, CString & strBody, IconIdentifier * icon) {};

private:
	BOOL				m_bNetbios;			    //  Name is a NetBIOS name

    DHCP_IP_ADDRESS		m_dhcpServerAddress;    //  Standard 32-bit value (eg: 0x7f000001)
	
    CString				m_strServerAddress;
	CString             m_strDnsName;
    CString             m_strState;             // rogue or not
    LARGE_INTEGER		m_liDhcpVersion;
	
    DWORD               m_dwServerOptions;      // Any of the SERVER_OPTIONS
    DWORD				m_dwRefreshInterval;
	DWORD				m_dwPingRetries;
    CString             m_strAuditLogPath;
    CString             m_strDatabasePath;
    CString             m_strBackupPath;

	BOOL				m_fSupportsDynBootp;
	BOOL				m_fSupportsBindings;

    int                 m_StatsTimerId;

    LPDHCP_MIB_INFO       m_pMibInfo;           // for statistics
    LPDHCP_MCAST_MIB_INFO m_pMCastMibInfo;

    DHCP_ROGUE_INFO     m_RogueInfo;

    CCriticalSection    m_csMibInfo;

	CDhcpDefaultOptionsOnServer	* m_pDefaultOptionsOnServer;

    CServerStats        m_dlgStats;
    CClassInfoArray     m_ClassInfoArray;
    COptionValueEnum    m_ServerOptionValues;
};


/*---------------------------------------------------------------------------
	Class:	CDhcpGlobalOptions
 ---------------------------------------------------------------------------*/
class CDhcpGlobalOptions : public CMTDhcpHandler
{
public:
    CDhcpGlobalOptions(ITFSComponentData * pComponentData);
	~CDhcpGlobalOptions();

// Interface
public:
	// base handler functionality we override
	OVERRIDE_NodeHandler_OnAddMenuItems();
	OVERRIDE_NodeHandler_HasPropertyPages();
    OVERRIDE_NodeHandler_CreatePropertyPages();
	OVERRIDE_NodeHandler_OnCommand();
	OVERRIDE_NodeHandler_GetString()
			{ return (nCol == 0) ? GetDisplayName() : NULL; }
    
    OVERRIDE_BaseHandlerNotify_OnCreateNodeId2();
    OVERRIDE_BaseHandlerNotify_OnPropertyChange();

    virtual HRESULT EnumerateResultPane(ITFSComponent *, MMC_COOKIE, LPARAM, LPARAM);

    // Result handler functionality we override
    OVERRIDE_BaseResultHandlerNotify_OnResultSelect();
    OVERRIDE_BaseResultHandlerNotify_OnResultDelete();
    OVERRIDE_BaseResultHandlerNotify_OnResultUpdateView();
    OVERRIDE_BaseResultHandlerNotify_OnResultPropertyChange();
    OVERRIDE_ResultHandler_CompareItems();
    OVERRIDE_ResultHandler_OnGetResultViewType();

public:
	// CMTDhcpHandler functionality
	virtual HRESULT InitializeNode(ITFSNode * pNode);
	virtual int GetImageIndex(BOOL bOpenImage);
	ITFSQueryObject* OnCreateQuery(ITFSNode * pNode);
    virtual void OnHaveData(ITFSNode * pParentNode, LPARAM Data, LPARAM Type);

    STDMETHOD(OnNotifyExiting)(LPARAM);

    CDhcpServer* GetServerObject(ITFSNode * pNode)
	{ 
		SPITFSNode spServerNode;
		pNode->GetParent(&spServerNode);
		return GETHANDLER(CDhcpServer, spServerNode);
	}

private:
	// command handlers
	HRESULT OnCreateNewOptions(ITFSNode * pNode);

// Attributes
private:
    void    UpdateResultMessage(ITFSNode * pNode);

};


/*---------------------------------------------------------------------------
	Class:	CDhcpBootp
 ---------------------------------------------------------------------------*/
class CDhcpBootp : public CMTDhcpHandler
{
public:
    CDhcpBootp(ITFSComponentData * pComponentData);
	~CDhcpBootp();

// Interface
public:
	// base handler functionality we override
	OVERRIDE_NodeHandler_OnAddMenuItems();
	OVERRIDE_NodeHandler_OnCommand();
	OVERRIDE_NodeHandler_GetString()
			{ return (nCol == 0) ? GetDisplayName() : NULL; }
    
    OVERRIDE_BaseHandlerNotify_OnCreateNodeId2();

	// Result handler functionality we override
    OVERRIDE_BaseResultHandlerNotify_OnResultDelete();

    OVERRIDE_ResultHandler_CompareItems();
    OVERRIDE_ResultHandler_OnGetResultViewType();

public:
	// CMTDhcpHandler functionality
	virtual HRESULT InitializeNode(ITFSNode * pNode);
	virtual int GetImageIndex(BOOL bOpenImage);
	ITFSQueryObject* OnCreateQuery(ITFSNode * pNode);

	CDhcpServer* GetServerObject(ITFSNode * pNode)
	{ 
		SPITFSNode spServerNode;
		pNode->GetParent(&spServerNode);
		return GETHANDLER(CDhcpServer, spServerNode);
	}

private:
	// command handlers
	DWORD OnCreateNewBootpEntry(ITFSNode *		pNode);

// Implementation
private:

// Attributes
private:
};


/*---------------------------------------------------------------------------
	Class:	CDhcpSuperscope
 ---------------------------------------------------------------------------*/
class CDhcpSuperscope : public CMTDhcpHandler
{
public:
    CDhcpSuperscope(ITFSComponentData * pComponentData, LPCWSTR pSuperscopeName = NULL);
	~CDhcpSuperscope();

public:
	// base handler functionality we override
	OVERRIDE_NodeHandler_HasPropertyPages() { return hrOK; }
    OVERRIDE_NodeHandler_CreatePropertyPages();
	OVERRIDE_NodeHandler_OnAddMenuItems();
	OVERRIDE_NodeHandler_OnCommand();
	OVERRIDE_NodeHandler_GetString();
    
    OVERRIDE_NodeHandler_DestroyHandler();

    // Choose which messages we want to handle
    OVERRIDE_BaseHandlerNotify_OnCreateNodeId2();
    OVERRIDE_BaseHandlerNotify_OnDelete();
    OVERRIDE_BaseHandlerNotify_OnPropertyChange();

	// Result handler functionality we override
    OVERRIDE_BaseResultHandlerNotify_OnResultDelete();
    OVERRIDE_ResultHandler_OnGetResultViewType();

// Implementation
private:
	// Command handlers
	HRESULT OnActivateSuperscope(ITFSNode * pNode);
	HRESULT OnCreateNewScope(ITFSNode * pNode);
	HRESULT OnDelete(ITFSNode * pNode);
	HRESULT OnShowSuperscopeStats(ITFSNode * pNode);

public:
	// public functions for superscope manipulation
	LPCWSTR GetName() { return m_strName; };
	void    SetName(LPCWSTR pName) { m_strName = pName; }
	
	HRESULT DoesSuperscopeExist(LPCWSTR szName);
	HRESULT AddScope(DHCP_IP_ADDRESS scopeAddress);
	HRESULT RemoveScope(DHCP_IP_ADDRESS scopeAddress);
	HRESULT Rename(ITFSNode * pNode, LPCWSTR szNewName);
	HRESULT GetSuperscopeInfo(LPDHCP_SUPER_SCOPE_TABLE *pSuperscopeTable);
	HRESULT SetSuperscope(DHCP_IP_ADDRESS SubnetAddress, BOOL ChangeExisting);

public:
	// helpers
	void	SetServer(ITFSNode * pServerNode) { m_spServerNode.Set(pServerNode); }
	HRESULT BuildDisplayName(CString * pstrDisplayName, LPCTSTR	pName);
    void    UpdateToolbarStates();
    void    SetState(DHCP_SUBNET_STATE dhcpState) { m_SuperscopeState = dhcpState; }
    void    NotifyScopeStateChange(ITFSNode * pNode, DHCP_SUBNET_STATE newScopeState);
    
    // adding child nodes sorted
    HRESULT AddScopeSorted(ITFSNode * pServerNode, ITFSNode * pScopeNode);

public:
	// CMTDhcpHandler functionality
	virtual HRESULT InitializeNode(ITFSNode * pNode);
	virtual void	OnHaveData(ITFSNode * pParentNode, ITFSNode * pNode);
	virtual int		GetImageIndex(BOOL bOpenImage);
    virtual DWORD   UpdateStatistics(ITFSNode * pNode);
	ITFSQueryObject* OnCreateQuery(ITFSNode * pNode);

	STDMETHOD(OnNotifyExiting)(LPARAM lParam);

	CDhcpServer* GetServerObject()
	{ 
		return GETHANDLER(CDhcpServer, m_spServerNode);
	}

    HRESULT OnUpdateToolbarButtons(ITFSNode * pNode, LPDHCPTOOLBARNOTIFY pToolbarNotify);

// Implementation
private:

// Attributes
private:
	CString				m_strName;
    CString             m_strState;
    DHCP_SUBNET_STATE	m_SuperscopeState;
	SPITFSNode			m_spServerNode;
    CSuperscopeStats    m_dlgStats;
};


/*---------------------------------------------------------------------------
	Class:	CHostInfo
 ---------------------------------------------------------------------------*/
class CHostInfo
{
public:
    CHostInfo()
    {
        IpAddress = 0;
    }

    CHostInfo(LPDHCP_HOST_INFO pDhcpHostInfo)
    {
        Set(pDhcpHostInfo);
    }

    CHostInfo(CHostInfo & hostInfo)
    {
        *this = hostInfo;
    }

    CHostInfo & operator = (const CHostInfo & hostInfo)
    {
        if (this != &hostInfo)
        {
            IpAddress = hostInfo.IpAddress;
            NetBiosName = hostInfo.NetBiosName;
            HostName = hostInfo.HostName;
        }
        
        return *this;
    }

    void Set(LPDHCP_HOST_INFO pDhcpHostInfo)
    {
        IpAddress = pDhcpHostInfo->IpAddress;
        NetBiosName = pDhcpHostInfo->NetBiosName;
        HostName = pDhcpHostInfo->HostName;
    }

public:
    DHCP_IP_ADDRESS     IpAddress;      // minimum information always available
    CString             NetBiosName;             // optional information
    CString             HostName;                // optional information
};

/*---------------------------------------------------------------------------
	Class:	CSubnetInfo
 ---------------------------------------------------------------------------*/
class CSubnetInfo
{
public:
    CSubnetInfo()
    {
        SubnetAddress = 0;
        SubnetMask = 0;
        SubnetState = DhcpSubnetDisabled;

        // multicast specific fields
        MScopeAddressPolicy = 0;
        MScopeFlags = 0;
        TTL = 0;
        ExpiryTime.dwLowDateTime = 0;
        ExpiryTime.dwHighDateTime = 0;
    }

    CSubnetInfo(LPDHCP_SUBNET_INFO pDhcpSubnetInfo)
    {
        Set(pDhcpSubnetInfo);
    }

    CSubnetInfo(CSubnetInfo & subnetInfo)
    {
        *this = subnetInfo;
    }

    CSubnetInfo & operator = (const CSubnetInfo & subnetInfo)
    {
        if (this != &subnetInfo)
        {
            SubnetAddress = subnetInfo.SubnetAddress;
            SubnetMask = subnetInfo.SubnetMask;
            SubnetName = subnetInfo.SubnetName;
            SubnetComment = subnetInfo.SubnetComment;
            PrimaryHost = subnetInfo.PrimaryHost;
            SubnetState = subnetInfo.SubnetState;

            MScopeAddressPolicy = subnetInfo.MScopeAddressPolicy;
            MScopeFlags = subnetInfo.MScopeFlags;
            TTL = subnetInfo.TTL;
            ExpiryTime = subnetInfo.ExpiryTime;
            LangTag = subnetInfo.LangTag;
        }

        return *this;
    }

    void Set(LPDHCP_SUBNET_INFO pDhcpSubnetInfo)
    {
        SubnetAddress = pDhcpSubnetInfo->SubnetAddress;
        SubnetMask = pDhcpSubnetInfo->SubnetMask;
        SubnetName = pDhcpSubnetInfo->SubnetName;
        SubnetComment = pDhcpSubnetInfo->SubnetComment;
        PrimaryHost.Set(&pDhcpSubnetInfo->PrimaryHost);
        SubnetState = pDhcpSubnetInfo->SubnetState;
    
        MScopeAddressPolicy = 0;
        MScopeFlags = 0;
        TTL = 0;
        ExpiryTime.dwLowDateTime = 0;
        ExpiryTime.dwHighDateTime = 0;
    }

    void Set(LPDHCP_MSCOPE_INFO pMScopeInfo)
    {
        SubnetName = pMScopeInfo->MScopeName;
        SubnetComment = pMScopeInfo->MScopeComment;
        SubnetAddress = pMScopeInfo->MScopeId;
        MScopeAddressPolicy = pMScopeInfo->MScopeAddressPolicy;
        PrimaryHost.Set(&pMScopeInfo->PrimaryHost);
        SubnetState = pMScopeInfo->MScopeState;
        MScopeFlags = pMScopeInfo->MScopeFlags;
        TTL = pMScopeInfo->TTL;
        ExpiryTime = pMScopeInfo->ExpiryTime;
        LangTag = pMScopeInfo->LangTag;

        SubnetMask = 0;
    }

public:
    // common fields
    DHCP_IP_ADDRESS     SubnetAddress;
    DHCP_IP_MASK        SubnetMask;
    CString             SubnetName;
    CString             SubnetComment;
    CHostInfo           PrimaryHost;
    DHCP_SUBNET_STATE   SubnetState;

    // multicast specific fields
    DWORD               MScopeAddressPolicy;
    DWORD               MScopeFlags;
    BYTE                TTL;
    DATE_TIME           ExpiryTime;
    CString             LangTag;
};

typedef CArray<CSubnetInfo, CSubnetInfo&> CSubnetInfoArrayBase;
typedef CMap<DHCP_IP_ADDRESS, DHCP_IP_ADDRESS, CSubnetInfo, CSubnetInfo &> CSubnetInfoCacheBase;

 /*---------------------------------------------------------------------------
	Class:	CSubnetInfoCache
 ---------------------------------------------------------------------------*/
class CSubnetInfoCache : public CSubnetInfoCacheBase
{
public:
    DWORD GetInfo(CString & strServer, DHCP_IP_ADDRESS ipAddress, CSubnetInfo & subnetInfo);
};

class CMScopeInfoCache : public CSubnetInfoArrayBase
{
public:
    DWORD GetInfo(CString & strServer, LPCTSTR pszName, CSubnetInfo & subnetInfo);
    BOOL  Lookup(LPCTSTR pszName, CSubnetInfo & subnetInfo)
    {   
        BOOL fFound = FALSE;

        for (int i = 0; i < GetSize(); i++)
        {
            if (GetAt(i).SubnetName.Compare(pszName) == 0)
            {
                subnetInfo = GetAt(i);
                fFound = TRUE;
            }
        }

        return fFound;
    }
};

/*---------------------------------------------------------------------------
	Class:	CDhcpServerQueryObj
 ---------------------------------------------------------------------------*/
class CDhcpServerQueryObj : public CDHCPQueryObj
{
public:
	CDhcpServerQueryObj(ITFSComponentData * pTFSComponentData,
						ITFSNodeMgr *	    pNodeMgr) 
			: CDHCPQueryObj(pTFSComponentData, pNodeMgr) 
    {
        // default to the cache in this object
        m_pSubnetInfoCache = &m_SubnetInfoCache;
    };
	
	STDMETHODIMP Execute();
	
	virtual void OnEventAbort(LPARAM Data, LPARAM Type);

	LONG CreateOption(CDhcpOption * pOption);
	void UpdateDefaultOptionsOnServer(CDhcpDefaultOptionsOnServer *	pOptionsOnServer,
									  CDhcpDefaultOptionsMasterList * pMasterList);
    void EnumSubnetsV4();
	void EnumSubnets();
    void EnumMScopes();  //Multicast scopes

	CDhcpSuperscope * FindSuperscope(CNodeListBase & listSuperscopes, LPWSTR pSuperScopeName);
	
	DWORD SetVersion();
	DWORD GetConfigInfo();
	DWORD GetStatistics();
	DWORD GetStatus();

	BOOL  VerifyDhcpServer();

public:
	DHCP_RESUME_HANDLE				m_dhcpResumeHandle;
	DWORD							m_dwPreferredMax;
	LARGE_INTEGER					m_liDhcpVersion;

	DWORD							m_dwPingRetries;
	BOOL							m_fAuditLog;
    BOOL                            m_bStatsOnly;
	BOOL							m_fSupportsDynBootp;
	BOOL							m_fSupportsBindings;
    CString                         m_strDatabasePath;
    CString                         m_strBackupPath;
	CString							m_strAuditLogPath;
	CString							m_strServerName;

	CDhcpDefaultOptionsOnServer *	m_pDefaultOptionsOnServer;

    CSubnetInfoCache *              m_pSubnetInfoCache;
    CSubnetInfoCache                m_SubnetInfoCache;
    CMScopeInfoCache                m_MScopeInfoCache;
};

/*---------------------------------------------------------------------------
	Class:	CDhcpSuperscopeQueryObj
 ---------------------------------------------------------------------------*/
class CDhcpSuperscopeQueryObj : public CDHCPQueryObj
{
public:
	CDhcpSuperscopeQueryObj
	(
		ITFSComponentData* pTFSComponentData,
		ITFSNodeMgr*	   pNodeMgr
	) : CDHCPQueryObj(pTFSComponentData, pNodeMgr) {};
	STDMETHODIMP Execute();

public:
	CString		m_strSuperscopeName;	
};

/*---------------------------------------------------------------------------
	Class:	CDhcpBootpQueryObj
 ---------------------------------------------------------------------------*/
class CDhcpBootpQueryObj : public CDHCPQueryObj
{
public:
	CDhcpBootpQueryObj
	(
		ITFSComponentData* pTFSComponentData,
		ITFSNodeMgr*	   pNodeMgr
	) : CDHCPQueryObj(pTFSComponentData, pNodeMgr) {};
	
	STDMETHODIMP Execute();
};

/*---------------------------------------------------------------------------
	Class:	CDhcpGlobalOptionsQueryObj
 ---------------------------------------------------------------------------*/
class CDhcpGlobalOptionsQueryObj : public CDHCPQueryObj
{
public:
	CDhcpGlobalOptionsQueryObj
	(
		ITFSComponentData* pTFSComponentData,
		ITFSNodeMgr*	   pNodeMgr
	) : CDHCPQueryObj(pTFSComponentData, pNodeMgr) {};

	STDMETHODIMP Execute();

public:
	DHCP_RESUME_HANDLE	m_dhcpResumeHandle;
	DWORD				m_dwPreferredMax;
    LARGE_INTEGER       m_liDhcpVersion;
};


/*---------------------------------------------------------------------------
	Class:	COptionNodeEnum
 ---------------------------------------------------------------------------*/
class COptionNodeEnum : public CTFSNodeList
{
public:
    COptionNodeEnum(ITFSComponentData * pTFSCompData, ITFSNodeMgr * pNodeMgr);
    
    DWORD Enum(LPCTSTR pServer, LARGE_INTEGER & liVersion, DHCP_OPTION_SCOPE_INFO & dhcpOptionScopeInfo);

protected:
    DWORD EnumOptions(LPCTSTR pServer, DHCP_OPTION_SCOPE_INFO & dhcpOptionScopeInfo);
    DWORD EnumOptionsV5(LPCTSTR pServer, DHCP_OPTION_SCOPE_INFO & dhcpOptionScopeInfo);

    // V5 Helper
    HRESULT CreateOptions(LPDHCP_OPTION_VALUE_ARRAY pOptionValues, LPCTSTR pClassName, LPCTSTR pszVendor);

protected:
    SPITFSComponentData     m_spTFSCompData;
    SPITFSNodeMgr           m_spNodeMgr;
};


#endif _SERVER_H