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

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

/*
	server.cpp
		This file contains the implementation for a DHCP Server
		object and the objects that can be contained within it.  
		Those objects are CDhcpBootp, CDhcpGlobalOptions and 
		CDhcpSuperscope.

    FILE HISTORY:
        
*/

#include "stdafx.h"
#include "server.h"		// Server definition
#include "scope.h"		// Scope definition
#include "servpp.h"	    // Server Property page
#include "sscopwiz.h"	// Superscope Wizard
#include "sscoppp.h"    // Scope Property Page
#include "scopewiz.h"	// Scope wizard
#include "addbootp.h"	// Add BOOTP entry dialog
#include "nodes.h"		// Result pane node definitions
#include "optcfg.h"		// Configure options dialog
#include "dlgdval.h"	// default options dialog
#include "sscpstat.h"   // Superscope statistics
#include "modeless.h"   // modeless thread 
#include "mscope.h"     // multicast scope stuff
#include "mscopwiz.h"   // multicast scope wizard
#include "classes.h"    // define classes dialog
#include "dlgrecon.h"   // reconcile dialog
#include "service.h"    // service control functions

#define SERVER_MESSAGE_MAX_STRING  11
typedef enum _SERVER_MESSAGES
{
    SERVER_MESSAGE_CONNECTED_NO_SCOPES,
    SERVER_MESSAGE_CONNECTED_NOT_AUTHORIZED,
    SERVER_MESSAGE_CONNECTED_BOTH,
    SERVER_MESSAGE_ACCESS_DENIED,
    SERVER_MESSAGE_UNABLE_TO_CONNECT,
    SERVER_MESSAGE_MAX
};

UINT g_uServerMessages[SERVER_MESSAGE_MAX][SERVER_MESSAGE_MAX_STRING] =
{
    {IDS_SERVER_MESSAGE_NO_SCOPES_TITLE,        Icon_Information, IDS_SERVER_MESSAGE_NO_SCOPES_BODY1,       IDS_SERVER_MESSAGE_NO_SCOPES_BODY2, 0},
    {IDS_SERVER_MESSAGE_NOT_AUTHORIZED_TITLE,   Icon_Information, IDS_SERVER_MESSAGE_NOT_AUTHORIZED_BODY1,  IDS_SERVER_MESSAGE_NOT_AUTHORIZED_BODY2, 0},
    {IDS_SERVER_MESSAGE_NOT_CONFIGURED_TITLE,   Icon_Information, IDS_SERVER_MESSAGE_NOT_CONFIGURED_BODY1,  IDS_SERVER_MESSAGE_NOT_CONFIGURED_BODY2, 0},
    {IDS_SERVER_MESSAGE_ACCESS_DENIED_TITLE,    Icon_Error,       IDS_SERVER_MESSAGE_ACCESS_DENIED_BODY,    0, 0},
    {IDS_SERVER_MESSAGE_CONNECT_FAILED_TITLE,   Icon_Error,       IDS_SERVER_MESSAGE_CONNECT_FAILED_BODY,   IDS_SERVER_MESSAGE_CONNECT_FAILED_REFRESH, 0},
};

#define SERVER_OPTIONS_MESSAGE_MAX_STRING  5
typedef enum _SERVER_OPTIONS_MESSAGES
{
    SERVER_OPTIONS_MESSAGE_NO_OPTIONS,
    SERVER_OPTIONS_MESSAGE_MAX
};

UINT g_uServerOptionsMessages[SERVER_OPTIONS_MESSAGE_MAX][SERVER_OPTIONS_MESSAGE_MAX_STRING] =
{
    {IDS_SERVER_OPTIONS_MESSAGE_TITLE, Icon_Information, IDS_SERVER_OPTIONS_MESSAGE_BODY, 0, 0}
};


CTimerMgr g_TimerMgr;

VOID CALLBACK 
StatisticsTimerProc
( 
    HWND        hwnd, 
    UINT        uMsg, 
    UINT_PTR    idEvent, 
    DWORD       dwTime 
)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());

    CSingleLock slTimerMgr(&g_TimerMgr.m_csTimerMgr);

    // get a lock on the timer mgr for the scope of this
    // function.
    slTimerMgr.Lock();

    // on the timer, get the timer descriptor for this event
    // Call into the appropriate handler to update the stats.
    CTimerDesc * pTimerDesc;

    pTimerDesc = g_TimerMgr.GetTimerDesc(idEvent);

    pTimerDesc->pServer->TriggerStatsRefresh(pTimerDesc->spNode);
}


/*---------------------------------------------------------------------------
	Class CDhcpServer implementation
 ---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------
	Constructor and destructor
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
CDhcpServer::CDhcpServer
(
	ITFSComponentData *	pComponentData, 
	LPCWSTR				pServerName
) : CMTDhcpHandler(pComponentData)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());

	m_strServerAddress = pServerName;
	m_dhcpServerAddress = UtilCvtWstrToIpAddr(pServerName);

	m_bNetbios = FALSE;
	m_liDhcpVersion.QuadPart = -1;
	m_pDefaultOptionsOnServer = new CDhcpDefaultOptionsOnServer;

    m_dwServerOptions = SERVER_OPTION_SHOW_ROGUE;
    m_dwRefreshInterval = DHCPSNAP_REFRESH_INTERVAL_DEFAULT;
	m_dwPingRetries = 0;

    m_pMibInfo = NULL;
    m_pMCastMibInfo = NULL;

    m_bStatsOnly = FALSE;
    m_StatsTimerId = -1;

	m_fSupportsDynBootp = FALSE;
	m_fSupportsBindings = FALSE;

    m_RogueInfo.fIsRogue = TRUE;
    m_RogueInfo.fIsInNt5Domain = TRUE;

    m_pSubnetInfoCache = NULL;
}

CDhcpServer::~CDhcpServer()
{
	if (m_pDefaultOptionsOnServer)
		delete m_pDefaultOptionsOnServer;
    
    if (IsAutoRefreshEnabled())
		g_TimerMgr.FreeTimer(m_StatsTimerId);

    if (m_pSubnetInfoCache)
        delete m_pSubnetInfoCache;

    // free up the Mib info struct if there is one.
    SetMibInfo(NULL);
    SetMCastMibInfo(NULL);
}

/*!--------------------------------------------------------------------------
	CDhcpServer::InitializeNode
		Initializes node specific data
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CDhcpServer::InitializeNode
(
	ITFSNode * pNode
)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
	
	CString strTemp;
    BuildDisplayName(&strTemp);
    
    SetDisplayName(strTemp);

	// Make the node immediately visible
	pNode->SetVisibilityState(TFS_VIS_SHOW);
	pNode->SetData(TFS_DATA_COOKIE, (LPARAM) pNode);
	pNode->SetData(TFS_DATA_IMAGEINDEX, GetImageIndex(FALSE));
	pNode->SetData(TFS_DATA_OPENIMAGEINDEX, GetImageIndex(FALSE));
	pNode->SetData(TFS_DATA_USER, (LPARAM) this);
    pNode->SetData(TFS_DATA_TYPE, DHCPSNAP_SERVER);

	SetColumnStringIDs(&aColumns[DHCPSNAP_SERVER][0]);
	SetColumnWidths(&aColumnWidths[DHCPSNAP_SERVER][0]);

    // assuming good status
    m_strState.LoadString(IDS_STATUS_UNKNOWN);

    return hrOK;
}

/*---------------------------------------------------------------------------
	CDhcpServer::DestroyHandler
		We need to free up any resources we are holding
	Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP 
CDhcpServer::DestroyHandler(ITFSNode *pNode)
{
	// cleanup the stats dialog
    WaitForStatisticsWindow(&m_dlgStats);

    return CMTDhcpHandler::DestroyHandler(pNode);
}

/*---------------------------------------------------------------------------
	CDhcpServer::OnCreateNodeId2
		Returns a unique string for this node
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT CDhcpServer::OnCreateNodeId2(ITFSNode * pNode, CString & strId, DWORD * dwFlags)
{
    const GUID * pGuid = pNode->GetNodeType();

    CString strGuid;

    StringFromGUID2(*pGuid, strGuid.GetBuffer(256), 256);
    strGuid.ReleaseBuffer();

    strId = GetName() + strGuid;

    return hrOK;
}

/*---------------------------------------------------------------------------
	CDhcpServer::GetImageIndex
		NOTE: the NumPendingOffers field of the scope MIB info is not used
        for display.  It is used to know the current state (active, inactive)
        of the scope.  If the scope is inactive, no warning or alert icons
        are displayed, therefore there should be no indication in the server
        of any inactive scope warnings or alerts.
	Author: EricDav
 ---------------------------------------------------------------------------*/
int 
CDhcpServer::GetImageIndex(BOOL bOpenImage) 
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

	int nIndex = -1;
	switch (m_nState)
	{
        case loading:
            nIndex = ICON_IDX_SERVER_BUSY;
            break;

		case notLoaded:
 	    case loaded:
        {
			if (!m_pMibInfo)
			{
				nIndex = ICON_IDX_SERVER;
			}
			else
			{
	            nIndex = ICON_IDX_SERVER_CONNECTED;

				LPSCOPE_MIB_INFO pScopeMibInfo = m_pMibInfo->ScopeInfo;

				// walk the list of scopes and calculate totals
				for (UINT i = 0; i < m_pMibInfo->Scopes; i++)
				{
					// don't worry about disabled scopes
					if (pScopeMibInfo[i].NumPendingOffers == DhcpSubnetDisabled)
						continue;

					int nPercentInUse;
					if ((pScopeMibInfo[i].NumAddressesInuse + pScopeMibInfo[i].NumAddressesFree) == 0)
						nPercentInUse = 0;
					else
						nPercentInUse = (pScopeMibInfo[i].NumAddressesInuse * 100) / (pScopeMibInfo[i].NumAddressesInuse + pScopeMibInfo[i].NumAddressesFree);
    
					// look to see if any scope meets the warning or red flag case
					if (pScopeMibInfo[i].NumAddressesFree == 0)
					{
						// red flag case, no addresses free, this is the highest
						// level of warning, we don't want to look for anything else
						nIndex = ICON_IDX_SERVER_ALERT;
						break;
					}
					else
					if (nPercentInUse >= SCOPE_WARNING_LEVEL)
					{
						nIndex = ICON_IDX_SERVER_WARNING;
					}
				}

				// now see if this is a rogue server
				if (m_liDhcpVersion.QuadPart >= DHCP_NT5_VERSION && 
					m_RogueInfo.fIsRogue)
				{
					nIndex = ICON_IDX_SERVER_ROGUE;
				}
			}
        }

		case unableToLoad:
            if (m_dwErr == ERROR_ACCESS_DENIED)
            {
			    nIndex = ICON_IDX_SERVER_NO_ACCESS;
            }
            else
			if (m_dwErr)
            {
			    nIndex = ICON_IDX_SERVER_LOST_CONNECTION;
            }
			break;
		
        default:
			ASSERT(FALSE);
	}

	return nIndex;
}

/*---------------------------------------------------------------------------
	CDhcpServer::OnHaveData
		When the background thread enumerates nodes to be added to the UI,
        we get called back here.  We need to figure out where to put these
        darn things, depending on what type of node it is...
	Author: EricDav
 ---------------------------------------------------------------------------*/
void 
CDhcpServer::OnHaveData
(
	ITFSNode * pParentNode, 
	ITFSNode * pNewNode
)
{
    HRESULT             hr = hrOK;
    SPIComponentData	spCompData;
    LPARAM              dwType = pNewNode->GetData(TFS_DATA_TYPE);

    if (pNewNode->IsContainer())
	{
		// assume all the child containers are derived from this class
		//((CDHCPMTContainer*)pNode)->SetServer(GetServer());
	}
	
    CORg (pParentNode->ChangeNode(SCOPE_PANE_STATE_CLEAR) );

    switch (dwType)
    {
        case DHCPSNAP_SCOPE:
        {
		    CDhcpScope * pScope = GETHANDLER(CDhcpScope, pNewNode);
		    pScope->SetServer(pParentNode);
            pScope->InitializeNode(pNewNode);

            AddScopeSorted(pParentNode, pNewNode);
        }
            break;

        case DHCPSNAP_SUPERSCOPE:
        {
		    CDhcpSuperscope * pSuperscope = GETHANDLER(CDhcpSuperscope, pNewNode);
		    pSuperscope->SetServer(pParentNode);
            pSuperscope->InitializeNode(pNewNode);

            AddSuperscopeSorted(pParentNode, pNewNode);
        }
            break;

        case DHCPSNAP_BOOTP_TABLE:
        {
            // the default node visiblity is to show
            if (!IsBootpVisible())
                pNewNode->SetVisibilityState(TFS_VIS_HIDE);

            LONG_PTR uRelativeFlag, uRelativeID;
            GetBootpPosition(pParentNode, &uRelativeFlag, &uRelativeID);

            pNewNode->SetData(TFS_DATA_RELATIVE_FLAGS, uRelativeFlag);
            pNewNode->SetData(TFS_DATA_RELATIVE_SCOPEID, uRelativeID);

            pParentNode->AddChild(pNewNode);
        }
            break;

        case DHCPSNAP_MSCOPE:
        {
		    CDhcpMScope * pMScope = GETHANDLER(CDhcpMScope, pNewNode);
		    pMScope->SetServer(pParentNode);
            pMScope->InitializeNode(pNewNode);

            AddMScopeSorted(pParentNode, pNewNode);
        }
            break;

        default:
            // global options get added here
  	        pNewNode->SetData(TFS_DATA_RELATIVE_FLAGS, SDI_FIRST);
            pParentNode->AddChild(pNewNode);
            break;
    }

    // now tell the view to update themselves
    ExpandNode(pParentNode, TRUE);

Error:
    return;
}

/*---------------------------------------------------------------------------
	CDhcpServer::AddScopeSorted
		Adds a scope node to the UI sorted
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CDhcpServer::AddScopeSorted
(
    ITFSNode * pServerNode,
    ITFSNode * pScopeNode
)
{
    HRESULT hr = hrOK;
    SPITFSNodeEnum  spNodeEnum;
	SPITFSNode      spCurrentNode;
	SPITFSNode      spPrevNode;
	ULONG           nNumReturned = 0;
	DHCP_IP_ADDRESS dhcpIpAddressCurrent = 0;
	DHCP_IP_ADDRESS dhcpIpAddressTarget;

    CDhcpScope *   pScope;

    // get our target address
	pScope = GETHANDLER(CDhcpScope, pScopeNode);
	dhcpIpAddressTarget = pScope->GetAddress();

    // get the enumerator for this node
	CORg(pServerNode->GetEnum(&spNodeEnum));

	CORg(spNodeEnum->Next(1, &spCurrentNode, &nNumReturned));
	while (nNumReturned)
	{
		// walk the list subnodes, first we skip over superscopes
        // since they go at the top of the list.
		if (spCurrentNode->GetData(TFS_DATA_TYPE) == DHCPSNAP_SUPERSCOPE)
        {
            spPrevNode.Set(spCurrentNode);
            spCurrentNode.Release();
    		spNodeEnum->Next(1, &spCurrentNode, &nNumReturned);
            continue;
        }
        
        if (spCurrentNode->GetData(TFS_DATA_TYPE) != DHCPSNAP_SCOPE)
        {
            // we've gone through all the scopes and have now run
            // into either the bootp node or global options.
            // insert before whatever node this is.
            break;
        }

        pScope = GETHANDLER(CDhcpScope, spCurrentNode);
		dhcpIpAddressCurrent = pScope->GetAddress();

		if (dhcpIpAddressCurrent > dhcpIpAddressTarget)
		{
            // Found where we need to put it, break out
            break;
		}

		// get the next node in the list
		spPrevNode.Set(spCurrentNode);

        spCurrentNode.Release();
		spNodeEnum->Next(1, &spCurrentNode, &nNumReturned);
	}

    // Add the node in based on the PrevNode pointer
    if (spPrevNode)
    {
        if (m_bExpanded)
        {
            pScopeNode->SetData(TFS_DATA_RELATIVE_FLAGS, SDI_PREVIOUS);
            pScopeNode->SetData(TFS_DATA_RELATIVE_SCOPEID, spPrevNode->GetData(TFS_DATA_SCOPEID));
        }
        
        CORg(pServerNode->InsertChild(spPrevNode, pScopeNode));
    }
    else
    {   
        // add to the head
        if (m_bExpanded)
            pScopeNode->SetData(TFS_DATA_RELATIVE_FLAGS, SDI_FIRST);

        CORg(pServerNode->AddChild(pScopeNode));
    }

Error:
    return hr;
}

/*---------------------------------------------------------------------------
	CDhcpServer::AddSuperscopeSorted
		Adds a superscope node to the UI sorted
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CDhcpServer::AddSuperscopeSorted
(
    ITFSNode * pServerNode,
    ITFSNode * pSuperscopeNode
)
{
    HRESULT hr = hrOK;
    SPITFSNodeEnum  spNodeEnum;
	SPITFSNode      spCurrentNode;
	SPITFSNode      spPrevNode;
	ULONG           nNumReturned = 0;
    CString         strNameTarget;
    CString         strNameCurrent;
    
    CDhcpSuperscope *   pSuperscope;

    // get our target address
	pSuperscope = GETHANDLER(CDhcpSuperscope, pSuperscopeNode);
	strNameTarget = pSuperscope->GetName();

    // get the enumerator for this node
	CORg(pServerNode->GetEnum(&spNodeEnum));

	CORg(spNodeEnum->Next(1, &spCurrentNode, &nNumReturned));
	while (nNumReturned)
	{
        if (spCurrentNode->GetData(TFS_DATA_TYPE) != DHCPSNAP_SUPERSCOPE)
        {
            // we've gone through all the superscopes and have now run
            // into either a scope node, the bootp node or global options.
            // insert before whatever node this is.
            break;
        }

        pSuperscope = GETHANDLER(CDhcpSuperscope, spCurrentNode);
		strNameCurrent = pSuperscope->GetName();

		if (strNameTarget.Compare(strNameCurrent) < 0)
		{
            // Found where we need to put it, break out
            break;
		}

		// get the next node in the list
		spPrevNode.Set(spCurrentNode);

        spCurrentNode.Release();
		spNodeEnum->Next(1, &spCurrentNode, &nNumReturned);
	}

    // Add the node in based on the PrevNode pointer
    if (spPrevNode)
    {
        if (m_bExpanded)
        {
            pSuperscopeNode->SetData(TFS_DATA_RELATIVE_FLAGS, SDI_PREVIOUS);
            pSuperscopeNode->SetData(TFS_DATA_RELATIVE_SCOPEID, spPrevNode->GetData(TFS_DATA_SCOPEID));
        }
        
        CORg(pServerNode->InsertChild(spPrevNode, pSuperscopeNode));
    }
    else
    {   
        // add to the head
        if (m_bExpanded)
            pSuperscopeNode->SetData(TFS_DATA_RELATIVE_FLAGS, SDI_FIRST);

        CORg(pServerNode->AddChild(pSuperscopeNode));
    }

Error:
    return hr;
}

/*---------------------------------------------------------------------------
	CDhcpServer::AddMScopeSorted
		Adds a scope node to the UI sorted
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CDhcpServer::AddMScopeSorted
(
    ITFSNode * pServerNode,
    ITFSNode * pScopeNode
)
{
    HRESULT hr = hrOK;
    SPITFSNodeEnum  spNodeEnum;
	SPITFSNode      spCurrentNode;
	SPITFSNode      spPrevNode;
	ULONG           nNumReturned = 0;
    CString         strCurrentName;
    CString         strTargetName;

    CDhcpMScope *   pScope;

    // get our target address
	pScope = GETHANDLER(CDhcpMScope, pScopeNode);
	strTargetName = pScope->GetName();

    // get the enumerator for this node
	CORg(pServerNode->GetEnum(&spNodeEnum));

	CORg(spNodeEnum->Next(1, &spCurrentNode, &nNumReturned));
	while (nNumReturned)
	{
		// walk the list subnodes, first we skip over superscopes
        // since they go at the top of the list.
		if (spCurrentNode->GetData(TFS_DATA_TYPE) == DHCPSNAP_SUPERSCOPE ||
            spCurrentNode->GetData(TFS_DATA_TYPE) == DHCPSNAP_SCOPE)
        {
            spPrevNode.Set(spCurrentNode);
            spCurrentNode.Release();
    		spNodeEnum->Next(1, &spCurrentNode, &nNumReturned);
            continue;
        }
        
        if (spCurrentNode->GetData(TFS_DATA_TYPE) != DHCPSNAP_MSCOPE)
        {
            // we've gone through all the scopes and have now run
            // into either the bootp node or global options.
            // insert before whatever node this is.
            break;
        }

        pScope = GETHANDLER(CDhcpMScope, spCurrentNode);
		strCurrentName = pScope->GetName();

		if (strCurrentName.Compare(strTargetName) >= 0)
		{
            // Found where we need to put it, break out
            break;
		}

		// get the next node in the list
		spPrevNode.Set(spCurrentNode);

        spCurrentNode.Release();
		spNodeEnum->Next(1, &spCurrentNode, &nNumReturned);
	}

    // Add the node in based on the PrevNode pointer
    if (spPrevNode)
    {
        if (m_bExpanded)
        {
            pScopeNode->SetData(TFS_DATA_RELATIVE_FLAGS, SDI_PREVIOUS);
            pScopeNode->SetData(TFS_DATA_RELATIVE_SCOPEID, spPrevNode->GetData(TFS_DATA_SCOPEID));
        }
        
        CORg(pServerNode->InsertChild(spPrevNode, pScopeNode));
    }
    else
    {   
        // add to the head
        if (m_bExpanded)
            pScopeNode->SetData(TFS_DATA_RELATIVE_FLAGS, SDI_FIRST);

        CORg(pServerNode->AddChild(pScopeNode));
    }

Error:
    return hr;
}

/*---------------------------------------------------------------------------
	CDhcpServer::GetBootpPosition
		Returns the correct flag and relative ID for adding the BOOTP
        folder to the UI.
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CDhcpServer::GetBootpPosition
(
    ITFSNode * pServerNode,
    LONG_PTR * puRelativeFlag,
    LONG_PTR * puRelativeID
)
{
    HRESULT         hr = hrOK;
    SPITFSNodeEnum  spNodeEnum;
	SPITFSNode      spCurrentNode;
	SPITFSNode      spPrevNode;
	ULONG           nNumReturned = 0;
    
    // get the enumerator for this node
	CORg(pServerNode->GetEnum(&spNodeEnum));

	CORg(spNodeEnum->Next(1, &spCurrentNode, &nNumReturned));
	while (nNumReturned)
	{
        if (spCurrentNode->GetData(TFS_DATA_TYPE) == DHCPSNAP_GLOBAL_OPTIONS)
        {
            // the BOOTP folder goes right before the global options folder
            break;
        }

		// get the next node in the list
		spPrevNode.Set(spCurrentNode);

        spCurrentNode.Release();
		spNodeEnum->Next(1, &spCurrentNode, &nNumReturned);
	}

    if (spCurrentNode)
    {
        if (puRelativeFlag)
            *puRelativeFlag = SDI_NEXT;
        
        if (puRelativeID)
            *puRelativeID = spCurrentNode->GetData(TFS_DATA_SCOPEID);
    }
    else
    {
        if (puRelativeFlag)
            *puRelativeFlag = SDI_FIRST;
        
        if (puRelativeID)
            *puRelativeID = 0;
    }

Error:
    return hr;
}

/*---------------------------------------------------------------------------
	CDhcpServer::OnHaveData
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
void 
CDhcpServer::OnHaveData
(
	ITFSNode * pParentNode, 
	LPARAM	   Data,
	LPARAM	   Type
)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

    // This is how we get non-node data back from the background thread.
    switch (Type)
    {
        case DHCP_QDATA_VERSION:
	    {
		    LARGE_INTEGER * pLI = reinterpret_cast<LARGE_INTEGER *>(Data);
		    m_liDhcpVersion.QuadPart = pLI->QuadPart;

		    delete pLI;
            break;
	    }

	    case DHCP_QDATA_SERVER_ID:
	    {
		    LPDHCP_SERVER_ID pServerId = reinterpret_cast<LPDHCP_SERVER_ID>(Data);

            Trace2("Server IP chagned, updating.  Old name %s, New name %s.\n", m_strServerAddress, pServerId->strIp);

			m_strServerAddress = pServerId->strIp;
			m_dhcpServerAddress = UtilCvtWstrToIpAddr(pServerId->strIp);

			// update the display
			CString strDisplayName;
			BuildDisplayName(&strDisplayName);
			SetDisplayName(strDisplayName);

			// update the node
            pParentNode->ChangeNode(SCOPE_PANE_CHANGE_ITEM_DATA);

		    delete pServerId;
			break;
		}

        case DHCP_QDATA_SERVER_INFO:
	    {
		    LPDHCP_SERVER_CONFIG pServerInfo = reinterpret_cast<LPDHCP_SERVER_CONFIG>(Data);
		    SetAuditLogging(pServerInfo->fAuditLog);
		    SetPingRetries(pServerInfo->dwPingRetries);
            m_strDatabasePath = pServerInfo->strDatabasePath;
            m_strBackupPath = pServerInfo->strBackupPath;
            m_strAuditLogPath = pServerInfo->strAuditLogDir;
			m_fSupportsDynBootp = pServerInfo->fSupportsDynBootp;
			m_fSupportsBindings = pServerInfo->fSupportsBindings;
		
		    delete pServerInfo;
            break;
	    }

        case DHCP_QDATA_STATS:
	    {
            LPDHCP_MIB_INFO pMibInfo = reinterpret_cast<LPDHCP_MIB_INFO>(Data);

            SetMibInfo(pMibInfo);

            UpdateStatistics(pParentNode);
            break;
        }

        case DHCP_QDATA_CLASS_INFO:
	    {
            CClassInfoArray * pClassInfoArray = reinterpret_cast<CClassInfoArray *>(Data);

            SetClassInfoArray(pClassInfoArray);

            delete pClassInfoArray;
            break;
        }

        case DHCP_QDATA_OPTION_VALUES:
        {
            COptionValueEnum * pOptionValueEnum = reinterpret_cast<COptionValueEnum *>(Data);

            SetOptionValueEnum(pOptionValueEnum);
            
            pOptionValueEnum->RemoveAll();
            delete pOptionValueEnum;

            break;
        }

        case DHCP_QDATA_MCAST_STATS:
        {
            LPDHCP_MCAST_MIB_INFO pMibInfo = reinterpret_cast<LPDHCP_MCAST_MIB_INFO>(Data);

            SetMCastMibInfo(pMibInfo);

            UpdateStatistics(pParentNode);
            break;
        }

        case DHCP_QDATA_ROGUE_INFO:
        {
            CString strNewState;
            DHCP_ROGUE_INFO * pRogueInfo = (DHCP_ROGUE_INFO *) Data;

            m_RogueInfo = *pRogueInfo;
            delete pRogueInfo;

			// NT4 servers are never rogue
            if (m_liDhcpVersion.QuadPart <= DHCP_NT5_VERSION)
			{
				m_RogueInfo.fIsRogue = FALSE;
			}

            // if we aren't part of an NT5 domain, then don't display 
            // rogue warning messages
            if (!m_RogueInfo.fIsInNt5Domain)
            {
                m_dwServerOptions &= ~SERVER_OPTION_SHOW_ROGUE;
            }

			if (m_RogueInfo.fIsRogue)
            {
                strNewState.LoadString(IDS_STATUS_ROGUE);

				// put up a warning message
				//DisplayRogueWarning();
            }
            else
            {
                strNewState.LoadString(IDS_STATUS_RUNNING);
            }

			// update the UI if the state has changed
            if (strNewState.Compare(m_strState) != 0)
            {
                m_strState = strNewState;

                // update the icon
                pParentNode->SetData(TFS_DATA_IMAGEINDEX, GetImageIndex(FALSE));
                pParentNode->SetData(TFS_DATA_OPENIMAGEINDEX, GetImageIndex(TRUE));

                pParentNode->ChangeNode(SCOPE_PANE_CHANGE_ITEM);
            }

            break;
        }

        case DHCP_QDATA_SUBNET_INFO_CACHE:
        {
            CSubnetInfoCache * pSubnetInfo = reinterpret_cast<CSubnetInfoCache *>(Data);

            if (m_pSubnetInfoCache)
                delete m_pSubnetInfoCache;

            m_pSubnetInfoCache = pSubnetInfo;

            break;
        }

    }
}

/*!--------------------------------------------------------------------------
	CDhcpServer::OnNotifyExiting
		We override this for the server node because we don't want the 
        icon to change when the thread goes away.  Normal behavior is that
        the node's icon changes to a wait cursor when the background thread
        is running.  If we are only doing stats collection, then we 
        don't want the icon to change.
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CDhcpServer::OnNotifyExiting
(
	LPARAM			lParam
)
{
	CDhcpServerQueryObj * pQuery = (CDhcpServerQueryObj *) lParam;
	
    if (pQuery)
        pQuery->AddRef();

    if (!pQuery->m_bStatsOnly)
        OnChangeState(m_spNode);

    UpdateResultMessage(m_spNode);

    ReleaseThreadHandler();

	Unlock();

    if (pQuery)
        pQuery->Release();

    return hrOK;
}

void
CDhcpServer::DisplayRogueWarning()
{
}

/*---------------------------------------------------------------------------
	Overridden base handler functions
 ---------------------------------------------------------------------------*/

 /*!--------------------------------------------------------------------------
	CMTDhcpHandler::UpdateToolbar
		Updates the toolbar depending upon the state of the node
	Author: EricDav
 ---------------------------------------------------------------------------*/
void
CDhcpServer::UpdateToolbar
(
    IToolbar *  pToolbar,
    LONG_PTR    dwNodeType,
    BOOL        bSelect
)
{
    if (m_liDhcpVersion.QuadPart < DHCP_SP2_VERSION)
    {
        // superscopes not available
        // Enable/disable toolbar buttons
        int i;
        BOOL aEnable[TOOLBAR_IDX_MAX];

        switch (m_nState)
        {
            case loaded:
                for (i = 0; i < TOOLBAR_IDX_MAX; aEnable[i++] = TRUE);
                aEnable[TOOLBAR_IDX_CREATE_SUPERSCOPE] = FALSE;
                break;
        
            case notLoaded:
            case loading:
                for (i = 0; i < TOOLBAR_IDX_MAX; aEnable[i++] = FALSE);
                break;

            case unableToLoad:
                for (i = 0; i < TOOLBAR_IDX_MAX; aEnable[i++] = FALSE);
                aEnable[TOOLBAR_IDX_REFRESH] = TRUE;
                break;
        }

        // if we are deselecting, then disable all
        if (!bSelect)
            for (i = 0; i < TOOLBAR_IDX_MAX; aEnable[i++] = FALSE);

        EnableToolbar(pToolbar,
                      g_SnapinButtons,
                      ARRAYLEN(g_SnapinButtons),
                      g_SnapinButtonStates[dwNodeType],
                      aEnable);
    }
    else
    {
        // just call the base handler
        CMTDhcpHandler::UpdateToolbar(pToolbar, dwNodeType, bSelect);
    }
}

 /*!--------------------------------------------------------------------------
	CDhcpServer::GetString
		Returns string information for display in the result pane columns
	Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP_(LPCTSTR) 
CDhcpServer::GetString
(
    ITFSNode *  pNode,
    int         nCol
)
{
    switch (nCol)
	{
		case 0:
			return GetDisplayName();

		case 1:
            return m_strState;
	}
	
	return NULL;
}

/*---------------------------------------------------------------------------
	CDhcpServer::OnAddMenuItems
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP 
CDhcpServer::OnAddMenuItems
(
	ITFSNode *				pNode,
	LPCONTEXTMENUCALLBACK	pContextMenuCallback, 
	LPDATAOBJECT			lpDataObject, 
	DATA_OBJECT_TYPES		type, 
	DWORD					dwType,
	long *					pInsertionAllowed
)
{ 
	AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

	LONG	fFlags = 0, fLoadingFlags = 0;
	HRESULT hr = S_OK;
	CString strMenuItem;

	if ( m_nState != loaded )
	{
		fFlags |= MF_GRAYED;
	}

	if ( m_nState == loading)
	{
		fLoadingFlags = MF_GRAYED;
	}

	if (type == CCT_SCOPE)
	{
        if (*pInsertionAllowed & CCM_INSERTIONALLOWED_TOP)
        {
            strMenuItem.LoadString(IDS_SHOW_SERVER_STATS);
		    hr = LoadAndAddMenuItem( pContextMenuCallback, 
								     strMenuItem, 
								     IDS_SHOW_SERVER_STATS,
								     CCM_INSERTIONPOINTID_PRIMARY_TOP, 
								     fFlags );
		    ASSERT( SUCCEEDED(hr) );

            // separator
            // all menu Items go at the top now, these were under new
            // insert a separater here
		    hr = LoadAndAddMenuItem( pContextMenuCallback, 
								     strMenuItem, 
								     0,
								     CCM_INSERTIONPOINTID_PRIMARY_TOP, 
								     MF_SEPARATOR);
		    ASSERT( SUCCEEDED(hr) );


            strMenuItem.LoadString(IDS_CREATE_NEW_SCOPE);
		    hr = LoadAndAddMenuItem( pContextMenuCallback, 
								     strMenuItem, 
								     IDS_CREATE_NEW_SCOPE,
								     CCM_INSERTIONPOINTID_PRIMARY_TOP, 
								     fFlags,
                                    _T("_CREATE_NEW_SCOPE") );
		    ASSERT( SUCCEEDED(hr) );

		    // 
		    // Check the version number to see if the server supports
		    // the NT4 sp2 superscoping functionality
		    //
		    if (m_liDhcpVersion.QuadPart >= DHCP_SP2_VERSION &&
                FEnableCreateSuperscope(pNode))
		    {
			    strMenuItem.LoadString(IDS_CREATE_NEW_SUPERSCOPE);
			    hr = LoadAndAddMenuItem( pContextMenuCallback, 
									     strMenuItem, 
									     IDS_CREATE_NEW_SUPERSCOPE,
									     CCM_INSERTIONPOINTID_PRIMARY_TOP, 
									     fFlags );

			    ASSERT( SUCCEEDED(hr) );
		    }

            // multicast scopes only supported on NT5 Servers
            if (m_liDhcpVersion.QuadPart >= DHCP_NT5_VERSION)
		    {
			    strMenuItem.LoadString(IDS_CREATE_NEW_MSCOPE);
			    hr = LoadAndAddMenuItem( pContextMenuCallback, 
									     strMenuItem, 
									     IDS_CREATE_NEW_MSCOPE,
									     CCM_INSERTIONPOINTID_PRIMARY_TOP, 
									     fFlags );
			    ASSERT( SUCCEEDED(hr) );
            }

            if (m_liDhcpVersion.QuadPart >= DHCP_NT51_VERSION)
		    {
                // put a separator
		        hr = LoadAndAddMenuItem( pContextMenuCallback, 
								         strMenuItem, 
								         0,
								         CCM_INSERTIONPOINTID_PRIMARY_TOP, 
								         MF_SEPARATOR);
	            ASSERT( SUCCEEDED(hr) );

			    // backup
                strMenuItem.LoadString(IDS_SERVER_BACKUP);
			    hr = LoadAndAddMenuItem( pContextMenuCallback, 
									     strMenuItem, 
									     IDS_SERVER_BACKUP,
									     CCM_INSERTIONPOINTID_PRIMARY_TOP, 
									     fFlags );
			    ASSERT( SUCCEEDED(hr) );

                // restore
                strMenuItem.LoadString(IDS_SERVER_RESTORE);
                hr = LoadAndAddMenuItem( pContextMenuCallback, 
									     strMenuItem, 
									     IDS_SERVER_RESTORE,
									     CCM_INSERTIONPOINTID_PRIMARY_TOP, 
									     fFlags );
			    ASSERT( SUCCEEDED(hr) );
            }

            // former task menu items now on top
            if (m_liDhcpVersion.QuadPart >= DHCP_SP2_VERSION)
		    {
                // put a separator
		        hr = LoadAndAddMenuItem( pContextMenuCallback, 
								         strMenuItem, 
								         0,
								         CCM_INSERTIONPOINTID_PRIMARY_TOP, 
								         MF_SEPARATOR);
		        ASSERT( SUCCEEDED(hr) );

                strMenuItem.LoadString(IDS_RECONCILE_ALL);
			    hr = LoadAndAddMenuItem( pContextMenuCallback, 
									     strMenuItem, 
									     IDS_RECONCILE_ALL,
									     CCM_INSERTIONPOINTID_PRIMARY_TOP, 
									     fFlags );
			    ASSERT( SUCCEEDED(hr) );
		    }

            // authorization only required for NT5 machines
            if (m_liDhcpVersion.QuadPart >= DHCP_NT5_VERSION)
            {
                // if we haven't initialized yet on the background thread, don't put it up
                if (g_AuthServerList.IsInitialized())
                {
                    UINT uId = IDS_SERVER_AUTHORIZE;

                    if (g_AuthServerList.IsAuthorized(m_dhcpServerAddress))
                    //if (!m_RogueInfo.fIsRogue)
                    {
                        uId = IDS_SERVER_DEAUTHORIZE;
                    }

  		            strMenuItem.LoadString(uId);
                    hr = LoadAndAddMenuItem( pContextMenuCallback, 
									         strMenuItem, 
									         uId,
									         CCM_INSERTIONPOINTID_PRIMARY_TOP, 
									         fFlags );
			        ASSERT( SUCCEEDED(hr) );
                }
            }

            // separator
            hr = LoadAndAddMenuItem( pContextMenuCallback, 
								     strMenuItem, 
								     0,
								     CCM_INSERTIONPOINTID_PRIMARY_TOP, 
								     MF_SEPARATOR);
		    ASSERT( SUCCEEDED(hr) );

            // user/vendor class stuff for nt5
            if (m_liDhcpVersion.QuadPart >= DHCP_NT5_VERSION)
		    {
			    strMenuItem.LoadString(IDS_DEFINE_USER_CLASSES);
			    hr = LoadAndAddMenuItem( pContextMenuCallback, 
									     strMenuItem, 
									     IDS_DEFINE_USER_CLASSES,
									     CCM_INSERTIONPOINTID_PRIMARY_TOP, 
									     fFlags );
			    ASSERT( SUCCEEDED(hr) );

			    strMenuItem.LoadString(IDS_DEFINE_VENDOR_CLASSES);
			    hr = LoadAndAddMenuItem( pContextMenuCallback, 
									     strMenuItem, 
									     IDS_DEFINE_VENDOR_CLASSES,
									     CCM_INSERTIONPOINTID_PRIMARY_TOP, 
									     fFlags );
			    ASSERT( SUCCEEDED(hr) );
		    }

		    strMenuItem.LoadString(IDS_SET_DEFAULT_OPTIONS);
		    hr = LoadAndAddMenuItem( pContextMenuCallback, 
								     strMenuItem, 
								     IDS_SET_DEFAULT_OPTIONS,
								     CCM_INSERTIONPOINTID_PRIMARY_TOP, 
								     fFlags );
		    ASSERT( SUCCEEDED(hr) );
        }

        if (*pInsertionAllowed & CCM_INSERTIONALLOWED_TASK)
        {
            // start/stop service menu items
	        if ( m_nState == notLoaded ||
                 m_nState == loading)
	        {
		        fFlags = MF_GRAYED;
	        }
            else
            {
                fFlags = 0;
            }

            DWORD dwServiceStatus, dwErrorCode, dwErr;
            dwErr = ::TFSGetServiceStatus(m_strServerAddress, _T("dhcpserver"), &dwServiceStatus, &dwErrorCode);
			if (dwErr != ERROR_SUCCESS)
                fFlags |= MF_GRAYED;

            // determining the restart state is the same as the stop flag
            LONG lStartFlag = (dwServiceStatus == SERVICE_STOPPED) ? 0 : MF_GRAYED;
            
            LONG lStopFlag = ( (dwServiceStatus == SERVICE_RUNNING) ||
                               (dwServiceStatus == SERVICE_PAUSED) ) ? 0 : MF_GRAYED;

            LONG lPauseFlag = ( (dwServiceStatus == SERVICE_RUNNING) ||
                                ( (dwServiceStatus != SERVICE_PAUSED) &&
                                  (dwServiceStatus != SERVICE_STOPPED) ) ) ? 0 : MF_GRAYED;
            
            LONG lResumeFlag = (dwServiceStatus == SERVICE_PAUSED) ? 0 : MF_GRAYED;

            strMenuItem.LoadString(IDS_SERVER_START_SERVICE);
		    hr = LoadAndAddMenuItem( pContextMenuCallback, 
								     strMenuItem, 
								     IDS_SERVER_START_SERVICE,
								     CCM_INSERTIONPOINTID_PRIMARY_TASK, 
								     fFlags | lStartFlag);

            strMenuItem.LoadString(IDS_SERVER_STOP_SERVICE);
		    hr = LoadAndAddMenuItem( pContextMenuCallback, 
								     strMenuItem, 
								     IDS_SERVER_STOP_SERVICE,
								     CCM_INSERTIONPOINTID_PRIMARY_TASK, 
								     fFlags | lStopFlag);

            strMenuItem.LoadString(IDS_SERVER_PAUSE_SERVICE);
		    hr = LoadAndAddMenuItem( pContextMenuCallback, 
								     strMenuItem, 
								     IDS_SERVER_PAUSE_SERVICE,
								     CCM_INSERTIONPOINTID_PRIMARY_TASK, 
								     fFlags | lPauseFlag);

            strMenuItem.LoadString(IDS_SERVER_RESUME_SERVICE);
		    hr = LoadAndAddMenuItem( pContextMenuCallback, 
								     strMenuItem, 
								     IDS_SERVER_RESUME_SERVICE,
								     CCM_INSERTIONPOINTID_PRIMARY_TASK, 
                                     fFlags | lResumeFlag);

            strMenuItem.LoadString(IDS_SERVER_RESTART_SERVICE);
		    hr = LoadAndAddMenuItem( pContextMenuCallback, 
								     strMenuItem, 
								     IDS_SERVER_RESTART_SERVICE,
								     CCM_INSERTIONPOINTID_PRIMARY_TASK, 
								     fFlags | lStopFlag);
        }
	}

	return hr; 
}

/*---------------------------------------------------------------------------
	CDhcpServer::OnCommand
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP 
CDhcpServer::OnCommand
(
	ITFSNode *			pNode, 
	long				nCommandId, 
	DATA_OBJECT_TYPES	type, 
	LPDATAOBJECT		pDataObject, 
	DWORD				dwType
)
{
	HRESULT hr = S_OK;

	switch (nCommandId)
	{
		case IDS_DEFINE_USER_CLASSES:
			OnDefineUserClasses(pNode);
			break;

        case IDS_DEFINE_VENDOR_CLASSES:
			OnDefineVendorClasses(pNode);
			break;
    
        case IDS_CREATE_NEW_SUPERSCOPE:
			OnCreateNewSuperscope(pNode);
			break;
		
		case IDS_CREATE_NEW_SCOPE:
			OnCreateNewScope(pNode);
			break;
		
		case IDS_CREATE_NEW_MSCOPE:
			OnCreateNewMScope(pNode);
			break;

        case IDS_SHOW_SERVER_STATS:
			OnShowServerStats(pNode);
			break;
		
		case IDS_REFRESH:
			OnRefresh(pNode, pDataObject, dwType, 0, 0);
			break;
		
		case IDS_SET_DEFAULT_OPTIONS:
			OnSetDefaultOptions(pNode);
			break;

        case IDS_RECONCILE_ALL:
            OnReconcileAll(pNode);
            break;

        case IDS_SERVER_AUTHORIZE:
            OnServerAuthorize(pNode);
            break;

        case IDS_SERVER_DEAUTHORIZE:
            OnServerDeauthorize(pNode);
            break;

	    case IDS_SERVER_STOP_SERVICE:
		    hr = OnControlService(pNode, FALSE);
		    break;

	    case IDS_SERVER_START_SERVICE:
		    hr = OnControlService(pNode, TRUE);
		    break;

	    case IDS_SERVER_PAUSE_SERVICE:
		    hr = OnPauseResumeService(pNode, TRUE);
		    break;

	    case IDS_SERVER_RESUME_SERVICE:
		    hr = OnPauseResumeService(pNode, FALSE);
		    break;
	    
        case IDS_SERVER_RESTART_SERVICE:
		    hr = OnRestartService(pNode);
		    break;

        case IDS_SERVER_BACKUP:
		    hr = OnServerBackup(pNode);
		    break;

        case IDS_SERVER_RESTORE:
		    hr = OnServerRestore(pNode);
		    break;

        default:
			break;
	}

	return hr;
}

/*!--------------------------------------------------------------------------
	CDhcpServer::OnDelete
		The base handler calls this when MMC sends a MMCN_DELETE for a 
		scope pane item.  We just call our delete command handler.
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CDhcpServer::OnDelete
(
	ITFSNode *	pNode, 
	LPARAM		arg, 
	LPARAM		lParam
)
{
	return OnDelete(pNode);
}

/*!--------------------------------------------------------------------------
	CDhcpServer::HasPropertyPages
		Implementation of ITFSNodeHandler::HasPropertyPages
	NOTE: the root node handler has to over-ride this function to 
	handle the snapin manager property page (wizard) case!!!
	
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP 
CDhcpServer::HasPropertyPages
(
	ITFSNode *			pNode,
	LPDATAOBJECT		pDataObject, 
	DATA_OBJECT_TYPES   type, 
	DWORD               dwType
)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());
	
	HRESULT hr = hrOK;
	
	if (dwType & TFS_COMPDATA_CREATE)
	{
		// This is the case where we are asked to bring up property
		// pages when the user is adding a new snapin.  These calls
		// are forwarded to the root node to handle.
		hr = hrOK;
		Assert(FALSE); // should never get here
	}
	else
	{
		// we have property pages in the normal case, but don't put the
		// menu up if we are not loaded yet
		if ( m_nState != loaded )
		{
			hr = hrFalse;
		}
		else
		{
			hr = hrOK;
		}
	}
	return hr;
}

/*---------------------------------------------------------------------------
	CDhcpServer::CreatePropertyPages
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP 
CDhcpServer::CreatePropertyPages
(
	ITFSNode *				pNode,
	LPPROPERTYSHEETCALLBACK lpProvider,
	LPDATAOBJECT			pDataObject, 
	LONG_PTR				handle, 
	DWORD					dwType
)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());

    DWORD		dwError;
    DWORD		dwDynDnsFlags;
    HRESULT     hr = hrOK;
	
    //
	// Create the property page
    //
	SPIComponentData spComponentData;

    COM_PROTECT_TRY
    {
        m_spNodeMgr->GetComponentData(&spComponentData);

	    CServerProperties * pServerProp = new CServerProperties(pNode, spComponentData, m_spTFSCompData, NULL);

        if ( pServerProp == NULL )
            return ( hrFalse );

	    pServerProp->SetVersion(m_liDhcpVersion);

	    GetAutoRefresh(&pServerProp->m_pageGeneral.m_nAutoRefresh, 
                       &pServerProp->m_pageGeneral.m_dwRefreshInterval);
	    pServerProp->m_pageGeneral.m_nAuditLogging = GetAuditLogging();
        pServerProp->m_pageGeneral.m_bShowBootp = IsBootpVisible() ? TRUE : FALSE;
        pServerProp->m_pageGeneral.m_uImage = GetImageIndex(FALSE);
        pServerProp->m_pageGeneral.m_fIsInNt5Domain = m_RogueInfo.fIsInNt5Domain;

	    pServerProp->m_pageAdvanced.m_nConflictAttempts = GetPingRetries();
        pServerProp->m_pageAdvanced.m_strDatabasePath = m_strDatabasePath;
        pServerProp->m_pageAdvanced.m_strAuditLogPath = m_strAuditLogPath;
        pServerProp->m_pageAdvanced.m_strBackupPath = m_strBackupPath;
        pServerProp->m_pageAdvanced.m_dwIp = m_dhcpServerAddress;

        BEGIN_WAIT_CURSOR;

        dwError = GetDnsRegistration(&dwDynDnsFlags);
        if (dwError != ERROR_SUCCESS)
        {
            ::DhcpMessageBox(dwError);
            return hrFalse;
        }
	    
        END_WAIT_CURSOR;

	    pServerProp->SetDnsRegistration(dwDynDnsFlags, DhcpGlobalOptions);
	    
	    //
	    // Object gets deleted when the page is destroyed
        //
	    Assert(lpProvider != NULL);

        hr = pServerProp->CreateModelessSheet(lpProvider, handle);
    }
    COM_PROTECT_CATCH

    return hr;
}

/*---------------------------------------------------------------------------
	CDhcpServer::OnPropertyChange
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CDhcpServer::OnPropertyChange
(	
	ITFSNode *		pNode, 
	LPDATAOBJECT	pDataobject, 
	DWORD			dwType, 
	LPARAM			arg, 
	LPARAM			lParam
)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

	CServerProperties * pServerProp = reinterpret_cast<CServerProperties *>(lParam);

	LPARAM changeMask = 0;

	// tell the property page to do whatever now that we are back on the
	// main thread
	pServerProp->OnPropertyChange(TRUE, &changeMask);

	pServerProp->AcknowledgeNotify();

	if (changeMask)
		pNode->ChangeNode(changeMask);

	return hrOK;
}

/*---------------------------------------------------------------------------
	CDhcpServer::OnGetResultViewType
		Return the result view that this node is going to support
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CDhcpServer::OnGetResultViewType
(
    ITFSComponent * pComponent, 
    MMC_COOKIE      cookie, 
    LPOLESTR *      ppViewType,
    long *          pViewOptions
)
{
    HRESULT hr = hrOK;

    // call the base class to see if it is handling this
    if (CMTDhcpHandler::OnGetResultViewType(pComponent, cookie, ppViewType, pViewOptions) != S_OK)
    {
        *pViewOptions = MMC_VIEW_OPTIONS_MULTISELECT | MMC_VIEW_OPTIONS_LEXICAL_SORT;
		
		hr = S_FALSE;
	}

    return hr;
}

/*!--------------------------------------------------------------------------
	CDhcpServer::OnResultSelect
		Update the verbs and the result pane message
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT CDhcpServer::OnResultSelect(ITFSComponent *pComponent, LPDATAOBJECT pDataObject, MMC_COOKIE cookie, LPARAM arg, LPARAM lParam)
{
    HRESULT         hr = hrOK;
    SPIConsoleVerb  spConsoleVerb;
    SPITFSNode      spNode;
    SPINTERNAL		spInternal;
    BOOL            bMultiSelect = FALSE;

    CORg (pComponent->GetConsoleVerb(&spConsoleVerb));
    
    spInternal = ::ExtractInternalFormat(pDataObject);
    
    if (spInternal && 
        spInternal->m_cookie == MMC_MULTI_SELECT_COOKIE)
    {
        CORg (pComponent->GetSelectedNode(&spNode));
        bMultiSelect = TRUE;
    }
    else
    {
        CORg (m_spNodeMgr->FindNode(cookie, &spNode));
    }

    UpdateConsoleVerbs(pComponent, spConsoleVerb, spNode->GetData(TFS_DATA_TYPE), bMultiSelect);

    UpdateResultMessage(spNode);

Error:
    return hr;
}

/*!--------------------------------------------------------------------------
	CDhcpServer::UpdateResultMessage
        Figures out what message to put in the result pane, if any
	Author: EricDav
 ---------------------------------------------------------------------------*/
void CDhcpServer::UpdateResultMessage(ITFSNode * pNode)
{
    HRESULT hr = hrOK;
    int nMessage = -1;   // default
    int i;
    BOOL fScopes = FALSE, fAuthorized = FALSE;

    CString strTitle, strBody, strTemp;

	if (m_dwErr && m_dwErr != ERROR_ACCESS_DENIED)
    {
        // this is sorta special case as we need to build a special string
        TCHAR chMesg [4000] = {0};
        BOOL bOk ;

        UINT nIdPrompt = (UINT) m_dwErr;

        bOk = LoadMessage(nIdPrompt, chMesg, sizeof(chMesg)/sizeof(chMesg[0]));

        nMessage = SERVER_MESSAGE_UNABLE_TO_CONNECT;

        strTitle.LoadString(g_uServerMessages[nMessage][0]);
        AfxFormatString1(strBody, g_uServerMessages[nMessage][2], chMesg);

        strTemp.LoadString(g_uServerMessages[nMessage][3]);
        strBody += strTemp;
    }
    else
    {   
        // build up some conditions
        if (m_pSubnetInfoCache && m_pSubnetInfoCache->GetCount() > 0) 
        {
            fScopes = TRUE;
        }

        if (!m_RogueInfo.fIsRogue)
        {
            fAuthorized = TRUE;
        }

        // determine what message to display
        if ( (m_nState == notLoaded) || 
             (m_nState == loading) )
        {
            nMessage = -1;
        }
        else
        if (m_dwErr == ERROR_ACCESS_DENIED)
        {       
            nMessage = SERVER_MESSAGE_ACCESS_DENIED;
        }
        else
        if (fScopes && fAuthorized)
        {
            nMessage = -1;
        }
        else
        if (!fScopes && fAuthorized)
        {
            nMessage = SERVER_MESSAGE_CONNECTED_NO_SCOPES;
        }
        else
        if (fScopes && !fAuthorized)
        {
            nMessage = SERVER_MESSAGE_CONNECTED_NOT_AUTHORIZED;
        }
        else
        {
            nMessage = SERVER_MESSAGE_CONNECTED_BOTH;
        }

        // build the strings
        if (nMessage != -1)
        {
            // now build the text strings
            // first entry is the title
            strTitle.LoadString(g_uServerMessages[nMessage][0]);

            // second entry is the icon
            // third ... n entries are the body strings

            for (i = 2; g_uServerMessages[nMessage][i] != 0; i++)
            {
                strTemp.LoadString(g_uServerMessages[nMessage][i]);
                strBody += strTemp;
            }
        }
    }

    // show the message
    if (nMessage == -1)
    {
        ClearMessage(pNode);
    }
    else
    {
        ShowMessage(pNode, strTitle, strBody, (IconIdentifier) g_uServerMessages[nMessage][1]);
    }
}

/*---------------------------------------------------------------------------
	CDhcpServer::OnResultDelete
		This function is called when we are supposed to delete result
		pane items.  We build a list of selected items and then delete them.
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CDhcpServer::OnResultDelete
(
	ITFSComponent * pComponent, 
	LPDATAOBJECT	pDataObject,
	MMC_COOKIE		cookie,
	LPARAM			arg, 
	LPARAM			param
)
{ 
	HRESULT hr = hrOK;

	AFX_MANAGE_STATE(AfxGetStaticModuleState());

	// translate the cookie into a node pointer
	SPITFSNode  spServer, spSelectedNode;
    DWORD       dwError;
    
    m_spNodeMgr->FindNode(cookie, &spServer);
    pComponent->GetSelectedNode(&spSelectedNode);

	Assert(spSelectedNode == spServer);
	if (spSelectedNode != spServer)
		return hr;

	// build the list of selected nodes
	CTFSNodeList listNodesToDelete;
	hr = BuildSelectedItemList(pComponent, &listNodesToDelete);

	//
	// Confirm with the user
	//
	CString strMessage, strTemp;
	int nNodes = (int) listNodesToDelete.GetCount();
	if (nNodes > 1)
	{
		strTemp.Format(_T("%d"), nNodes);
		AfxFormatString1(strMessage, IDS_DELETE_ITEMS, (LPCTSTR) strTemp);
	}
	else
	{
		strMessage.LoadString(IDS_DELETE_ITEM);
	}

	if (AfxMessageBox(strMessage, MB_YESNO) == IDNO)
	{
		return NOERROR;
	}

    BOOL fRefreshServer = FALSE;

    //
	// Loop through all items deleting
	//
    BEGIN_WAIT_CURSOR;
	
    while (listNodesToDelete.GetCount() > 0)
	{
		SPITFSNode   spCurNode;
        const GUID * pGuid;

		spCurNode = listNodesToDelete.RemoveHead();
        pGuid = spCurNode->GetNodeType();

        // do the right thing depending on what is selected
        if (*pGuid == GUID_DhcpSuperscopeNodeType)
        {
            BOOL fRefresh = FALSE;
            DeleteSuperscope(spCurNode, &fRefresh);
            if (fRefresh)
                fRefreshServer = TRUE;
        }
        else
        if (*pGuid == GUID_DhcpScopeNodeType)
        {
            BOOL fWantCancel = TRUE;

            DeleteScope(spCurNode, &fWantCancel);
            
            if (fWantCancel)
                break;  // user canceled out
        }
        else
        if (*pGuid == GUID_DhcpMScopeNodeType)
        {
            BOOL fWantCancel = TRUE;

            DeleteMScope(spCurNode, &fWantCancel);

            if (fWantCancel)
                break;  // user canceled out
        }
        else
        {
            Assert(FALSE);
        }
    }
    
    END_WAIT_CURSOR;

    if (fRefreshServer)
        OnRefresh(spServer, NULL, 0, 0, 0);

    return hr;
}


 /*!--------------------------------------------------------------------------
	CDhcpServer::UpdateConsoleVerbs
		Updates the standard verbs depending upon the state of the node
	Author: EricDav
 ---------------------------------------------------------------------------*/
void
CDhcpServer::UpdateConsoleVerbs
(
    ITFSComponent* pComponent,
    IConsoleVerb * pConsoleVerb,
    LONG_PTR       dwNodeType,
    BOOL           bMultiSelect
)
{
    HRESULT             hr = hrOK;
	CTFSNodeList        listSelectedNodes;
    BOOL                bStates[ARRAYLEN(g_ConsoleVerbs)];	
    MMC_BUTTON_STATE *  ButtonState;
    int                 i;
    
    if (bMultiSelect)
    {
        ButtonState = g_ConsoleVerbStatesMultiSel[dwNodeType];
        for (i = 0; i < ARRAYLEN(g_ConsoleVerbs); bStates[i++] = TRUE);

        hr = BuildSelectedItemList(pComponent, &listSelectedNodes);

        if (SUCCEEDED(hr))
        {
            // collect all of the unique guids
            while (listSelectedNodes.GetCount() > 0)
	        {
		        SPITFSNode   spCurNode;
                const GUID * pGuid;

		        spCurNode = listSelectedNodes.RemoveHead();
                pGuid = spCurNode->GetNodeType();
        
                // if the user selects the global options or BOOTP folder, disable delete
                if ( (*pGuid == GUID_DhcpGlobalOptionsNodeType) ||
                     (*pGuid == GUID_DhcpBootpNodeType) )
                {
                    bStates[MMC_VERB_DELETE & 0x000F] = FALSE;
                }
            }
        }

        EnableVerbs(pConsoleVerb, ButtonState, bStates);
    }
    else
    {
        // default handler
        CMTDhcpHandler::UpdateConsoleVerbs(pConsoleVerb, dwNodeType, bMultiSelect);
    }
}

/*---------------------------------------------------------------------------
	Command handlers
 ---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------
	CDhcpServer::OnDefineUserClasses
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CDhcpServer::OnDefineUserClasses
(
	ITFSNode * pNode
)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

    HRESULT hr = hrOK;
    CClassInfoArray ClassInfoArray;

    GetClassInfoArray(ClassInfoArray);

    CDhcpClasses dlgClasses(&ClassInfoArray, GetIpAddress(), CLASS_TYPE_USER);

    dlgClasses.DoModal();
    SetClassInfoArray(&ClassInfoArray);

    return hr;
}

/*---------------------------------------------------------------------------
	CDhcpServer::OnDefineVendorClasses
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CDhcpServer::OnDefineVendorClasses
(
	ITFSNode * pNode
)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

    HRESULT hr = hrOK;
    CClassInfoArray ClassInfoArray;

    GetClassInfoArray(ClassInfoArray);

    CDhcpClasses dlgClasses(&ClassInfoArray, GetIpAddress(), CLASS_TYPE_VENDOR);

    dlgClasses.DoModal();
    SetClassInfoArray(&ClassInfoArray);

    return hr;
}

/*---------------------------------------------------------------------------
	CDhcpServer::OnCreateNewSuperscope
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CDhcpServer::OnCreateNewSuperscope
(
	ITFSNode * pNode
)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

	CString strSuperscopeWizTitle;
	SPIComponentData spComponentData;
    HRESULT hr = hrOK;

    COM_PROTECT_TRY
    {
        strSuperscopeWizTitle.LoadString(IDS_SUPERSCOPE_WIZ_TITLE);

        m_spNodeMgr->GetComponentData(&spComponentData);
	    CSuperscopeWiz * pSuperscopeWiz = new CSuperscopeWiz(pNode, 
														     spComponentData, 
														     m_spTFSCompData,
														     strSuperscopeWizTitle);
        if ( pSuperscopeWiz == NULL )
            return( hrFalse );

	    BEGIN_WAIT_CURSOR;
        pSuperscopeWiz->GetScopeInfo();
        END_WAIT_CURSOR;

        hr = pSuperscopeWiz->DoModalWizard();
    }
    COM_PROTECT_CATCH

	return hr;
}

/*---------------------------------------------------------------------------
	CDhcpServer::OnCreateNewScope
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CDhcpServer::OnCreateNewScope
(
	ITFSNode * pNode
)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

    HRESULT         hr = hrOK;
	CString         strScopeWizTitle;
	SPIComponentData spComponentData;
    SPIConsole      spConsole;

    COM_PROTECT_TRY
    {
        strScopeWizTitle.LoadString(IDS_SCOPE_WIZ_TITLE);

        m_spNodeMgr->GetComponentData(&spComponentData);
	    CScopeWiz * pScopeWiz = new CScopeWiz(pNode, 
										      spComponentData, 
										      m_spTFSCompData,
										      NULL,
										      strScopeWizTitle);
        
        if ( pScopeWiz == NULL )
        {
            hr = hrFalse;
            return( hr );
        }

        pScopeWiz->m_pDefaultOptions = GetDefaultOptionsList();
        
        hr = pScopeWiz->DoModalWizard();

        // trigger the statistics to refresh
        TriggerStatsRefresh(pNode);
    }
    COM_PROTECT_CATCH

    return hr;
}

/*---------------------------------------------------------------------------
	CDhcpServer::OnCreateNewMScope
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CDhcpServer::OnCreateNewMScope
(
	ITFSNode * pNode
)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

	CString strScopeWizTitle;
	SPIComponentData spComponentData;
    HRESULT hr = hrOK;

    COM_PROTECT_TRY
    {
        strScopeWizTitle.LoadString(IDS_SCOPE_WIZ_TITLE);

        m_spNodeMgr->GetComponentData(&spComponentData);
	    CMScopeWiz * pScopeWiz = new CMScopeWiz(pNode, 
									  	        spComponentData, 
										        m_spTFSCompData,
										        NULL);
	    hr = pScopeWiz->DoModalWizard();
    }
    COM_PROTECT_CATCH

    return hr;
}

/*---------------------------------------------------------------------------
	CDhcpServer::OnShowServerStats()
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CDhcpServer::OnShowServerStats
(
	ITFSNode * pNode
)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

	HRESULT hr = S_OK;

    // Fill in some information in the stats object.
    // CreateNewStatisticsWindow handles the case if the window is 
    // already visible.
    m_dlgStats.SetNode(pNode);
    m_dlgStats.SetServer(GetIpAddress());
    
	CreateNewStatisticsWindow(&m_dlgStats,
							  ::FindMMCMainWindow(),
							  IDD_STATS_NARROW);

    return hr;
}

/*---------------------------------------------------------------------------
	CDhcpServer::OnSetDefaultOptions()
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CDhcpServer::OnSetDefaultOptions(ITFSNode * pNode)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

	HRESULT hr = S_OK;

	COptionList & listOptions = m_pDefaultOptionsOnServer->GetOptionList();

	CDhcpDefValDlg dlgDefVal(pNode, &listOptions);

	dlgDefVal.DoModal();

	return hr;
}

/*---------------------------------------------------------------------------
	CDhcpServer::OnReconcileAll()
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CDhcpServer::OnReconcileAll(ITFSNode * pNode)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

	HRESULT hr = S_OK;

	CReconcileDlg dlgRecon(pNode, TRUE);
	
	dlgRecon.DoModal();

	return hr;
}

/*---------------------------------------------------------------------------
	CDhcpServer::OnServerAuthorize()
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CDhcpServer::OnServerAuthorize(ITFSNode * pNode)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

	HRESULT hr = S_OK;

    hr = g_AuthServerList.AddServer(m_dhcpServerAddress, m_strDnsName);
    if (FAILED(hr))
    {
        ::DhcpMessageBox(WIN32_FROM_HRESULT(hr));
        // TODO: update node state
    }
    else
    {
        UpdateResultMessage(pNode);

        // refresh the node to update the icon
		TriggerStatsRefresh(pNode);
    }

	return S_OK;
}

/*---------------------------------------------------------------------------
	CDhcpServer::OnServerDeauthorize()
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CDhcpServer::OnServerDeauthorize(ITFSNode * pNode)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

	HRESULT hr = S_OK;

    if (AfxMessageBox(IDS_WARNING_DEAUTHORIZE, MB_YESNO) == IDYES)
    {
        hr = g_AuthServerList.RemoveServer(m_dhcpServerAddress);
        if (FAILED(hr))
        {
            ::DhcpMessageBox(WIN32_FROM_HRESULT(hr));
            // TODO: update node state
        }
        else
        {
            UpdateResultMessage(pNode);

            // refresh the node to update the icon
    		TriggerStatsRefresh(pNode);
        }
    }

	return hr;
}

/*---------------------------------------------------------------------------
	CDhcpServer::OnControlService
        -
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CDhcpServer::OnControlService
(
    ITFSNode *  pNode,
    BOOL        fStart
)
{
    HRESULT hr = hrOK;
    DWORD   err = ERROR_SUCCESS;
	CString strServiceDesc;
	
    strServiceDesc.LoadString(IDS_SERVICE_NAME);

    if (fStart)
    {
		err = TFSStartServiceEx(m_strDnsName, _T("dhcpserver"), _T("DHCP Service"), strServiceDesc);
    }
    else
    {
		err = TFSStopServiceEx(m_strDnsName, _T("dhcpserver"), _T("DHCP Service"), strServiceDesc);
    }

    if (err == ERROR_SUCCESS)
    {
        if (!fStart)
            m_fSilent = TRUE;

		OnRefresh(pNode, NULL, 0, 0, 0);
    }
    else
    {
        hr = HRESULT_FROM_WIN32(err);
        ::DhcpMessageBox(err);
    }

    return hr;
}

/*---------------------------------------------------------------------------
	CDhcpServer::OnPauseResumeService
        -
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CDhcpServer::OnPauseResumeService
(
    ITFSNode *  pNode,
    BOOL        fPause
)
{
    HRESULT hr = hrOK;
    DWORD   err = ERROR_SUCCESS;
	CString strServiceDesc;
	
    strServiceDesc.LoadString(IDS_SERVICE_NAME);

    if (fPause)
    {
		err = TFSPauseService(m_strDnsName, _T("dhcpserver"), strServiceDesc);
    }
    else
    {
		err = TFSResumeService(m_strDnsName, _T("dhcpserver"), strServiceDesc);
    }

    if (err != ERROR_SUCCESS)
    {
        hr = HRESULT_FROM_WIN32(err);
        ::DhcpMessageBox(err);
    }
    
    return hr;
}

/*---------------------------------------------------------------------------
	CDhcpServer::OnRestartService
        -
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CDhcpServer::OnRestartService
(
    ITFSNode *  pNode
)
{
    HRESULT hr = hrOK;
    DWORD   err = ERROR_SUCCESS;
	CString strServiceDesc;
	
    strServiceDesc.LoadString(IDS_SERVICE_NAME);

	err = TFSStopServiceEx(m_strDnsName, _T("dhcpserver"), _T("DHCP Service"), strServiceDesc);
    if (err != ERROR_SUCCESS)
    {
        hr = HRESULT_FROM_WIN32(err);
    }

    if (SUCCEEDED(hr))
    {
		err = TFSStartServiceEx(m_strDnsName, _T("dhcpserver"), _T("DHCP Service"), strServiceDesc);
        if (err != ERROR_SUCCESS)
        {
            hr = HRESULT_FROM_WIN32(err);
            ::DhcpMessageBox(err);
        }
    }
    else
    {
        ::DhcpMessageBox(WIN32_FROM_HRESULT(hr));
    }

    // refresh
    OnRefresh(pNode, NULL, 0, 0, 0);

    return hr;
}

/*---------------------------------------------------------------------------
	CDhcpServer::OnServerBackup
        Just need to call the API, don't need to stop/start the service
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CDhcpServer::OnServerBackup
(
    ITFSNode *  pNode
)
{
    HRESULT hr = hrOK;
    DWORD   err = ERROR_SUCCESS;

    CString strHelpText, strPath;

    strHelpText.LoadString(IDS_BACKUP_HELP);

    UtilGetFolderName(m_strBackupPath, strHelpText, strPath);

    BEGIN_WAIT_CURSOR;

    err = ::DhcpServerBackupDatabase((LPWSTR) GetIpAddress(), (LPWSTR) (LPCTSTR) strPath);
    
    END_WAIT_CURSOR;

    if (err != ERROR_SUCCESS)
    {
        ::DhcpMessageBox(err);
    }

    return HRESULT_FROM_WIN32(err);
}

/*---------------------------------------------------------------------------
	CDhcpServer::OnServerRestore
        Calls the DHCP API and then restarts the service to take effect
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CDhcpServer::OnServerRestore
(
    ITFSNode *  pNode
)
{
    HRESULT hr = hrOK;
    DWORD   err = ERROR_SUCCESS;

    CString strHelpText, strPath;

    strHelpText.LoadString(IDS_RESTORE_HELP);

    BOOL fGotPath = UtilGetFolderName(m_strBackupPath, strHelpText, strPath);

    if (fGotPath)
    {
        BEGIN_WAIT_CURSOR;

        err = ::DhcpServerRestoreDatabase((LPWSTR) GetIpAddress(), (LPWSTR) (LPCTSTR) strPath);
        
        END_WAIT_CURSOR;

        if (err != ERROR_SUCCESS)
        {
            ::DhcpMessageBox(err);
        }
        else
        {
            // need to restart the service to take effect.
            if (::AfxMessageBox(IDS_PATH_CHANGE_RESTART_SERVICE, MB_YESNO) == IDYES)
            {
                HRESULT hr = OnRestartService(pNode);   
                if (SUCCEEDED(hr))
                {
                    // call the QueryAttribute API to see if the restore completed
                    // successfully.  The restore is done when the service starts.  The service may
                    // start successfully even if the restore fails.
                    LPDHCP_ATTRIB pdhcpAttrib = NULL;

                    err = ::DhcpServerQueryAttribute((LPWSTR) GetIpAddress(), NULL, DHCP_ATTRIB_ULONG_RESTORE_STATUS, &pdhcpAttrib);
		            if (err == ERROR_SUCCESS)
		            {
    	                Assert(pdhcpAttrib);
			            if (pdhcpAttrib->DhcpAttribUlong != ERROR_SUCCESS)
                        {
                            // the restore failed, but the service is running. tell the user
                            ::DhcpMessageBox(pdhcpAttrib->DhcpAttribUlong);
                        }

                        ::DhcpRpcFreeMemory(pdhcpAttrib);
		            }
                }
            }
        }
    }

    return HRESULT_FROM_WIN32(err);
}

/*---------------------------------------------------------------------------
	CDhcpServer::OnDelete()
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CDhcpServer::OnDelete(ITFSNode * pNode)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

	HRESULT hr = S_OK;

	CString strMessage, strTemp;
	strTemp.LoadString(IDS_WRN_DISCONNECT);
	strMessage.Format(strTemp, GetIpAddress());

	if (AfxMessageBox(strMessage, MB_YESNO) == IDYES)
	{
		// remove this node from the list, there's nothing we need to tell
		// the server, it's just our local list of servers
		SPITFSNode spParent;

		pNode->GetParent(&spParent);
		spParent->RemoveChild(pNode);
	}

	return hr;
}

/*!--------------------------------------------------------------------------
	CDhcpServer::OnUpdateToolbarButtons
		We override this function to show/hide the correct
        activate/deactivate buttons
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CDhcpServer::OnUpdateToolbarButtons
(
    ITFSNode *          pNode,
    LPDHCPTOOLBARNOTIFY pToolbarNotify
)
{
    HRESULT hr = hrOK;

    if (pToolbarNotify->bSelect)
    {
        UpdateToolbarStates(pNode);
    }

    CMTDhcpHandler::OnUpdateToolbarButtons(pNode, pToolbarNotify);

    return hr;
}

/*!--------------------------------------------------------------------------
	CDhcpServer::UpdateToolbarStates
	    Description
    Author: EricDav
 ---------------------------------------------------------------------------*/
void
CDhcpServer::UpdateToolbarStates(ITFSNode * pNode)
{
    g_SnapinButtonStates[DHCPSNAP_SERVER][TOOLBAR_IDX_CREATE_SUPERSCOPE] = FEnableCreateSuperscope(pNode) ? ENABLED : HIDDEN;
}

/*---------------------------------------------------------------------------
	CDhcpServer::FEnableCreateSuperscope()
		Determines whether to enable the create superscope option.  Only 
        enable if there are non-superscoped scopes
	Author: EricDav
 ---------------------------------------------------------------------------*/
BOOL    
CDhcpServer::FEnableCreateSuperscope(ITFSNode * pNode)
{
    SPITFSNodeEnum  spNodeEnum;
	SPITFSNode      spCurrentNode;
	ULONG           nNumReturned = 0;
    BOOL            bEnable = FALSE;
    HRESULT         hr = hrOK;

    // get the enumerator for this node
	CORg(pNode->GetEnum(&spNodeEnum));

	CORg(spNodeEnum->Next(1, &spCurrentNode, &nNumReturned));
	while (nNumReturned)
	{
        if (spCurrentNode->GetData(TFS_DATA_TYPE) == DHCPSNAP_SCOPE)
        {
            // there is a non-superscoped scope
            bEnable = TRUE;
            break;
        }

        spCurrentNode.Release();
		spNodeEnum->Next(1, &spCurrentNode, &nNumReturned);
	}

Error:
    return bEnable;
}

/*---------------------------------------------------------------------------
	Server manipulation functions
 ---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------
	CDhcpServer::CreateScope
		Creates a scope on the DHCP server
	Author: EricDav
 ---------------------------------------------------------------------------*/
DWORD 
CDhcpServer::CreateScope
(
	DHCP_IP_ADDRESS dhcpSubnetAddress,
	DHCP_IP_ADDRESS dhcpSubnetMask,
	LPCTSTR			pName,
	LPCTSTR			pComment
)
{
	DHCP_SUBNET_INFO dhcpSubnetInfo;

	dhcpSubnetInfo.SubnetAddress = dhcpSubnetAddress;
	dhcpSubnetInfo.SubnetMask = dhcpSubnetMask;
	dhcpSubnetInfo.SubnetName = (LPTSTR) pName;
	dhcpSubnetInfo.SubnetComment = (LPTSTR) pComment;
	dhcpSubnetInfo.SubnetState = DhcpSubnetDisabled;
	
	dhcpSubnetInfo.PrimaryHost.IpAddress = m_dhcpServerAddress;

	// Review : ericdav - do we need to fill these in?
	dhcpSubnetInfo.PrimaryHost.NetBiosName = NULL;
	dhcpSubnetInfo.PrimaryHost.HostName = NULL;

	DWORD dwErr =  ::DhcpCreateSubnet(GetIpAddress(),
					  dhcpSubnetAddress,
					  &dhcpSubnetInfo);

    if ( (dwErr == ERROR_SUCCESS) &&
         (m_pSubnetInfoCache) )
    {
        // add to subnet info cache
        CSubnetInfo subnetInfo;

        subnetInfo.Set(&dhcpSubnetInfo);

        m_pSubnetInfoCache->SetAt(dhcpSubnetAddress, subnetInfo);
    }

    return dwErr;
}

/*---------------------------------------------------------------------------
	CDhcpServer::DeleteScope
		Deletes a scope on the DHCP server
	Author: EricDav
 ---------------------------------------------------------------------------*/
DWORD 
CDhcpServer::DeleteScope
(
    ITFSNode * pScopeNode,
    BOOL *     pfWantCancel
)
{
    DWORD        err = 0;
    BOOL         fAbortDelete = FALSE;
    BOOL         fDeactivated = FALSE;
    BOOL         fCancel = FALSE;
    BOOL         fWantCancel = FALSE;
    SPITFSNode   spParentNode;
    CDhcpScope * pScope;

    if (pfWantCancel)
        fWantCancel = *pfWantCancel;

    pScope = GETHANDLER(CDhcpScope, pScopeNode);

    //
    // We do permit the deleting of active scopes, but
    // they do have to be disabled first.
    //
    if (pScope->IsEnabled())
    {
        pScope->SetState(DhcpSubnetDisabled);

		// Tell the scope to update it's state
		pScope->SetInfo();
        fDeactivated = TRUE;
    }

    //
    // First try without forcing
    //
    BEGIN_WAIT_CURSOR;
    err = DeleteSubnet(pScope->GetAddress(), FALSE); // Force = FALSE
    
    Trace1( "CDhcpServer::DeleteScope() : err = %ld\n", err );

    if (err == ERROR_FILE_NOT_FOUND)
    {
        //
        // Someone else already deleted this scope.
        // This is not a serious error.
        //
        UINT uType = (fWantCancel) ? MB_OKCANCEL : MB_OK;
        if (::DhcpMessageBox(IDS_MSG_ALREADY_DELETED, uType | MB_ICONINFORMATION) == IDCANCEL)

        RESTORE_WAIT_CURSOR;

        err = ERROR_SUCCESS;
    }

    if (err != ERROR_SUCCESS)
    {
        //
        // Give them a second shot
        //
        UINT uType = (fWantCancel) ? MB_YESNOCANCEL : MB_YESNO;
        int nRet = ::DhcpMessageBox (IDS_MSG_DELETE_SCOPE_FORCE, 
                                     uType | MB_DEFBUTTON2 | MB_ICONQUESTION);
        if (nRet == IDYES)
        {
            err = DeleteSubnet(pScope->GetAddress(), TRUE); // Force = TRUE
            if (err == ERROR_FILE_NOT_FOUND)
            {
                err = ERROR_SUCCESS;
            }
        }
        else
        {
            //
            // We don't want to delete the active scope.
            //
            fAbortDelete = TRUE;

            if (nRet == IDCANCEL)
                fCancel = TRUE;
        }

        END_WAIT_CURSOR;
    }

    if (err == ERROR_SUCCESS)
    {
		// remove from UI
		pScopeNode->GetParent(&spParentNode);
		spParentNode->RemoveChild(pScopeNode);
    }
    else
    {
        //
        // If we got here because we aborted the active
        // scope deletion, then we don't display the
        // error, and we may have to re-activate
        // the scope.  Otherwise, it's a genuine
        // error, and we put up an error message.
        //
        if (!fAbortDelete)
        {
            UINT uType = (fWantCancel) ? MB_OKCANCEL : MB_OK;
            if (::DhcpMessageBox( err, uType ) == IDCANCEL)
                fCancel = TRUE;

            goto Error;
        }
        else
        {
            if (fDeactivated)
            {
                //
                // We de-activated the scope preperatory to
                // to deleting the scope, but later aborted
                // this, so undo the de-activation now.
                //
                pScope->SetState(DhcpSubnetEnabled);

				// Tell the scope to update it's state
				pScope->SetInfo();
            }
        }
    }

Error:
    if (pfWantCancel)
        *pfWantCancel = fCancel;

    return err;
}

/*---------------------------------------------------------------------------
	CDhcpServer::DeleteSubnet
		Delete's this subnet on the DHCP Server
	Author: EricDav
 ---------------------------------------------------------------------------*/
DWORD 
CDhcpServer::DeleteSubnet
(
    DWORD   dwScopeId,
    BOOL    bForce
)
{
    DWORD dwErr =  ::DhcpDeleteSubnet(GetIpAddress(),
							  dwScopeId,
							  bForce ? DhcpFullForce : DhcpNoForce);

    if ( (dwErr == ERROR_SUCCESS) &&
         (m_pSubnetInfoCache) )
    {
        // remove from subnet info cache
        m_pSubnetInfoCache->RemoveKey(dwScopeId);
    }

    return dwErr;
}

/*---------------------------------------------------------------------------
	CDhcpServer::DeleteSuperscope
		Deletes a superscope on the DHCP server
	Author: EricDav
 ---------------------------------------------------------------------------*/
DWORD 
CDhcpServer::DeleteSuperscope
(
    ITFSNode *  pNode,
    BOOL *      pfRefresh
)
{
    SPITFSNode        spServerNode;
    CDhcpSuperscope * pSuperscope;

    pSuperscope = GETHANDLER(CDhcpSuperscope, pNode);
    pNode->GetParent(&spServerNode);

    DWORD dwError = 0;

    if (pfRefresh)
        *pfRefresh = FALSE;

    BEGIN_WAIT_CURSOR;
    dwError = RemoveSuperscope(pSuperscope->GetName());
    END_WAIT_CURSOR;

	if (dwError != ERROR_SUCCESS)
	{
		::DhcpMessageBox(dwError);
		return dwError;
	}
		
	// remove this node from the list and move all of the subscopes up 
	// one level as a child of the server node.
	SPITFSNodeEnum spNodeEnum;
	SPITFSNode spCurrentNode;
	ULONG nNumReturned = 0;
    int   nScopes = 0;

	pNode->GetEnum(&spNodeEnum);

	spNodeEnum->Next(1, &spCurrentNode, &nNumReturned);
	while (nNumReturned)
	{
		pNode->ExtractChild(spCurrentNode);
		
        CDhcpServer * pServer = GETHANDLER(CDhcpServer, spServerNode);
        pServer->AddScopeSorted(spServerNode, spCurrentNode);

        CDhcpScope * pScope = GETHANDLER(CDhcpScope, spCurrentNode);
        pScope->SetInSuperscope(FALSE);

		spCurrentNode.Release();
		spNodeEnum->Next(1, &spCurrentNode, &nNumReturned);

        nScopes++;
	}
	
    if (nScopes)
    {
        // remove the superscope node
	    spServerNode->RemoveChild(pNode);
    }
    else
    {
        // node wasn't expanded yet, need to refresh the server
        if (pfRefresh)
            *pfRefresh = TRUE;
    }

    return dwError;
}

 /*---------------------------------------------------------------------------
	CDhcpServer::RemoveSuperscope()
		Wrapper for the DhcpDeleteSuperScopeV4 call
	Author: EricDav
 ---------------------------------------------------------------------------*/
DWORD 
CDhcpServer::RemoveSuperscope(LPCTSTR pszName)
{
	return ::DhcpDeleteSuperScopeV4(GetIpAddress(), (LPWSTR) pszName);
}


/*---------------------------------------------------------------------------
	CDhcpServer::CreateMScope
		Creates a scope on the DHCP server
	Author: EricDav
 ---------------------------------------------------------------------------*/
DWORD   
CDhcpServer::CreateMScope
(
    LPDHCP_MSCOPE_INFO pMScopeInfo
)
{
    CString strLangTag;
    DWORD dwErr = ERROR_SUCCESS;

    // fill in the owner host stuff
	pMScopeInfo->PrimaryHost.IpAddress = m_dhcpServerAddress;

    // fill in the language ID
    GetLangTag(strLangTag);
    pMScopeInfo->LangTag = (LPWSTR) ((LPCTSTR) strLangTag);

	// Review : ericdav - do we need to fill these in?
	pMScopeInfo->PrimaryHost.NetBiosName = NULL;
	pMScopeInfo->PrimaryHost.HostName = NULL;

    dwErr = ::DhcpSetMScopeInfo(GetIpAddress(),
                                pMScopeInfo->MScopeName,
                                pMScopeInfo,
                                TRUE);
    return dwErr;
}

/*---------------------------------------------------------------------------
	CDhcpServer::DeleteMScope
		Deletes a scope on the DHCP server
	Author: EricDav
 ---------------------------------------------------------------------------*/
DWORD 
CDhcpServer::DeleteMScope
(
    ITFSNode *  pScopeNode,
    BOOL *      pfWantCancel

)
{
    DWORD        err = 0;
    BOOL         fAbortDelete = FALSE;
    BOOL         fDeactivated = FALSE;
    BOOL         fWantCancel = FALSE;
    BOOL         fCancel = FALSE;
    SPITFSNode   spServerNode;
    CDhcpMScope * pScope;

    if (pfWantCancel)
        fWantCancel = *pfWantCancel;

    pScope = GETHANDLER(CDhcpMScope, pScopeNode);

    //
    // We do permit the deleting of active scopes, but
    // they do have to be disabled first.
    //
    if (pScope->IsEnabled())
    {
        pScope->SetState(DhcpSubnetDisabled);

		// Tell the scope to update it's state
		pScope->SetInfo();
        fDeactivated = TRUE;
    }

    //
    // First try without forcing
    //
    BEGIN_WAIT_CURSOR;
    err = DeleteMSubnet(pScope->GetName(), FALSE); // Force = FALSE

    if (err == ERROR_FILE_NOT_FOUND)
    {
        //
        // Someone else already deleted this scope.
        // This is not a serious error.
        //
        UINT uType = (fWantCancel) ? MB_OKCANCEL : MB_OK;
        if (::DhcpMessageBox(IDS_MSG_ALREADY_DELETED, uType | MB_ICONINFORMATION) == IDCANCEL)
            fCancel = TRUE;

        RESTORE_WAIT_CURSOR;

        err = ERROR_SUCCESS;
    }

    if (err != ERROR_SUCCESS)
    {
        //
        // Give them a second shot
        //
        UINT uType = (fWantCancel) ? MB_YESNOCANCEL : MB_YESNO;
        int nRet = ::DhcpMessageBox (IDS_MSG_DELETE_SCOPE_FORCE, 
                                     uType | MB_DEFBUTTON2 | MB_ICONQUESTION);
        if (nRet == IDYES)
        {
            err = DeleteMSubnet(pScope->GetName(), TRUE); // Force = TRUE
            if (err == ERROR_FILE_NOT_FOUND)
            {
                err = ERROR_SUCCESS;
            }
        }
        else
        {
            //
            // We don't want to delete the active scope.
            //
            fAbortDelete = TRUE;

            if (nRet == IDCANCEL)
                fCancel = TRUE;
        }

        END_WAIT_CURSOR;
    }

    if (err == ERROR_SUCCESS)
    {
		// remove from UI
		pScopeNode->GetParent(&spServerNode);
		spServerNode->RemoveChild(pScopeNode);
    }
    else
    {
        //
        // If we got here because we aborted the active
        // scope deletion, then we don't display the
        // error, and we may have to re-activate
        // the scope.  Otherwise, it's a genuine
        // error, and we put up an error message.
        //
        if (!fAbortDelete)
        {
            UINT uType = (fWantCancel) ? MB_OKCANCEL : MB_OK;
            if (::DhcpMessageBox( err, uType ) == IDCANCEL)
                fCancel = TRUE;

            goto Error;
        }
        else
        {
            if (fDeactivated)
            {
                //
                // We de-activated the scope preperatory to
                // to deleting the scope, but later aborted
                // this, so undo the de-activation now.
                //
                pScope->SetState(DhcpSubnetEnabled);

				// Tell the scope to update it's state
				pScope->SetInfo();
            }
        }
    }

Error:
    if (pfWantCancel)
        *pfWantCancel = fCancel;

    return err;
}

/*---------------------------------------------------------------------------
	CDhcpServer::DeleteMSubnet
		Delete's this scope on the DHCP Server
	Author: EricDav
 ---------------------------------------------------------------------------*/
DWORD 
CDhcpServer::DeleteMSubnet
(
    LPCTSTR pszName,
    BOOL    bForce
)
{
    DWORD dwErr = ERROR_SUCCESS;

    dwErr = ::DhcpDeleteMScope((LPWSTR) GetIpAddress(),
			  				   (LPWSTR) pszName,
							   bForce ? DhcpFullForce : DhcpNoForce);

    return dwErr;
}

/*---------------------------------------------------------------------------
	CDhcpServer::SetConfigInfo
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
DWORD
CDhcpServer::SetConfigInfo
(
	BOOL	bAuditLogging,
	DWORD	dwPingRetries,
    LPCTSTR pszDatabasePath,
    LPCTSTR pszBackupPath
)
{
	DWORD dwError = 0;
	DWORD dwSetFlags = 0;

	Assert(m_liDhcpVersion.QuadPart >= DHCP_SP2_VERSION);

	if (m_liDhcpVersion.QuadPart < DHCP_SP2_VERSION)
		return dwError;

	DHCP_SERVER_CONFIG_INFO_V4 dhcpConfigInfo;
	::ZeroMemory(&dhcpConfigInfo, sizeof(dhcpConfigInfo));

	if (bAuditLogging != GetAuditLogging())
	{
		dwSetFlags |= Set_AuditLogState;
		dhcpConfigInfo.fAuditLog = bAuditLogging;
	}

	if (dwPingRetries != GetPingRetries())
	{
		dwSetFlags |= Set_PingRetries;
		dhcpConfigInfo.dwPingRetries = dwPingRetries;
	}

    if (pszDatabasePath && m_strDatabasePath.Compare(pszDatabasePath) != 0)
    {
		dwSetFlags |= Set_DatabasePath;
        dhcpConfigInfo.DatabasePath = (LPWSTR) pszDatabasePath;
    }

    if (pszBackupPath && m_strBackupPath.Compare(pszBackupPath) != 0)
    {
		dwSetFlags |= Set_BackupPath;
        dhcpConfigInfo.BackupPath = (LPWSTR) pszBackupPath;
    }

    if (dwSetFlags)
	{
        if ( (dwSetFlags & Set_PingRetries) ||
             (dwSetFlags & Set_AuditLogState) )
        {
		    dwError = SetConfigInfo(dwSetFlags, &dhcpConfigInfo);
        }
        else
        {
            // use the old API to set the database path to be backward compatible
            dwError = SetConfigInfo(dwSetFlags, (DHCP_SERVER_CONFIG_INFO *) &dhcpConfigInfo);
        }

		if (dwError == 0)
		{
			if (dwSetFlags & Set_PingRetries)
				SetPingRetries(dhcpConfigInfo.dwPingRetries);

			if (dwSetFlags & Set_AuditLogState)
				SetAuditLogging(dhcpConfigInfo.fAuditLog);

            // update this here because it takes effect immediately and we 
            // don't have to restart the service.

            if (dwSetFlags & Set_BackupPath ) 
                m_strBackupPath = pszBackupPath;
		}
	}

	return dwError;
}

/*---------------------------------------------------------------------------
	CDhcpServer::SetConfigInfo
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
DWORD
CDhcpServer::SetConfigInfo
(
	DWORD	dwSetFlags,
	LPDHCP_SERVER_CONFIG_INFO pServerConfigInfo
)
{
	return ::DhcpServerSetConfig(GetIpAddress(), dwSetFlags, pServerConfigInfo);
}

/*---------------------------------------------------------------------------
	CDhcpServer::SetConfigInfo
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
DWORD
CDhcpServer::SetConfigInfo
(
	DWORD dwSetFlags,
	LPDHCP_SERVER_CONFIG_INFO_V4 pServerConfigInfo
)
{
	return ::DhcpServerSetConfigV4(GetIpAddress(), dwSetFlags, pServerConfigInfo);
}

/*---------------------------------------------------------------------------
	CDhcpServer::SetAutoRefresh
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
DWORD
CDhcpServer::SetAutoRefresh
(
    ITFSNode *  pNode,
	BOOL		bAutoRefreshOn,
	DWORD		dwRefreshInterval
)
{
    BOOL bCurrentAutoRefresh = IsAutoRefreshEnabled();

	if (bCurrentAutoRefresh &&
        !bAutoRefreshOn)
    {
        // turning off the timer
        g_TimerMgr.FreeTimer(m_StatsTimerId);
    }
    else
    if (!bCurrentAutoRefresh &&
        bAutoRefreshOn)
    {
        // gotta turn on the timer
        m_StatsTimerId = g_TimerMgr.AllocateTimer(pNode, this, dwRefreshInterval, StatisticsTimerProc);
    }
    else
    if (bAutoRefreshOn &&
        m_dwRefreshInterval != dwRefreshInterval)
    {
        // time to change the timer
        g_TimerMgr.ChangeInterval(m_StatsTimerId, dwRefreshInterval);
    }

    m_dwServerOptions = bAutoRefreshOn ? m_dwServerOptions | SERVER_OPTION_AUTO_REFRESH : 
                                         m_dwServerOptions & ~SERVER_OPTION_AUTO_REFRESH;
	m_dwRefreshInterval = dwRefreshInterval;

	return 0;
}

/*---------------------------------------------------------------------------
	CDhcpServer::ShowNode()
		Hides/shows either the bootp or classid node
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CDhcpServer::ShowNode
(   
    ITFSNode *  pServerNode, 
    UINT        uNodeType, 
    BOOL        bVisible
)
{
    HRESULT hr = hrOK;

    switch (uNodeType)
    {
        case DHCPSNAP_BOOTP_TABLE:
        {
            if ( (bVisible && IsBootpVisible()) ||
                 (!bVisible && !IsBootpVisible()) )
                return hr;
            
            // find the bootp node
            SPITFSNodeEnum spNodeEnum;
	        SPITFSNode spCurrentNode;
	        ULONG nNumReturned = 0;

	        pServerNode->GetEnum(&spNodeEnum);

	        spNodeEnum->Next(1, &spCurrentNode, &nNumReturned);
	        while (nNumReturned)
	        {
                if (spCurrentNode->GetData(TFS_DATA_TYPE) == DHCPSNAP_BOOTP_TABLE)
                    break;

                spCurrentNode.Release();
		        spNodeEnum->Next(1, &spCurrentNode, &nNumReturned);
	        }

            Assert(spCurrentNode);

            // node doesn't exist... This should never happen because we shouldn't
            // allow the user the option to hide/show the node if the server doesn't
            // support BOOTP
            if (spCurrentNode == NULL)
                return hr;

            if (bVisible)
            {
                spCurrentNode->SetVisibilityState(TFS_VIS_SHOW);
                m_dwServerOptions |= SERVER_OPTION_SHOW_BOOTP;

                LONG_PTR uRelativeFlag, uRelativeID;
                GetBootpPosition(pServerNode, &uRelativeFlag, &uRelativeID);

                spCurrentNode->SetData(TFS_DATA_RELATIVE_FLAGS, uRelativeFlag);
                spCurrentNode->SetData(TFS_DATA_RELATIVE_SCOPEID, uRelativeID);
            }
            else
            {
                spCurrentNode->SetVisibilityState(TFS_VIS_HIDE);
                m_dwServerOptions &= ~SERVER_OPTION_SHOW_BOOTP;
            }

            spCurrentNode->Show();

        }
            break;

        default:
            Panic0("Invalid node type passed to ShowNode");
            break;
    }

    return hr;

}


/*---------------------------------------------------------------------------
	CDhcpServer::DoesMScopeExist()
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
BOOL
CDhcpServer::DoesMScopeExist(ITFSNode * pServerNode, DWORD dwScopeId)
{
    // find all multicast scope nodes and mark the ones as not default
    SPITFSNodeEnum  spNodeEnum;
	SPITFSNode      spCurrentNode;
	ULONG           nNumReturned = 0;
    BOOL            bFound = FALSE;

	pServerNode->GetEnum(&spNodeEnum);

	spNodeEnum->Next(1, &spCurrentNode, &nNumReturned);
	while (nNumReturned)
	{
        if (spCurrentNode->GetData(TFS_DATA_TYPE) == DHCPSNAP_MSCOPE)
        {
            CDhcpMScope * pMScope = GETHANDLER(CDhcpMScope, spCurrentNode);
            if (pMScope->GetScopeId() == dwScopeId)
            {
                bFound = TRUE;
                break;
            }
        }

        spCurrentNode.Release();
		spNodeEnum->Next(1, &spCurrentNode, &nNumReturned);
    }

    return bFound;
}
/*---------------------------------------------------------------------------
	CDhcpServer::GetGlobalOptionsContainer()
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
CDhcpGlobalOptions * 
CDhcpServer::GetGlobalOptionsContainer()
{
//	return reinterpret_cast<CDhcpGlobalOptions*>(GetChildByType(DHCPSNAP_GLOBAL_OPTIONS));
	return NULL;
}

/*---------------------------------------------------------------------------
	CDhcpServer::GetDefaultOptions()
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
BOOL
CDhcpServer::GetDefaultOptions()
{
	if (m_pDefaultOptionsOnServer)
		m_pDefaultOptionsOnServer->Enumerate(m_strServerAddress, m_liDhcpVersion);

	return TRUE;
}

/*---------------------------------------------------------------------------
	CDhcpServer::FindOption
		Finds an option from the list of default options on this server
	Author: EricDav
 ---------------------------------------------------------------------------*/
CDhcpOption *
CDhcpServer::FindOption(DHCP_OPTION_ID dhcpOptionId, LPCTSTR pszVendor)
{
    if (m_pDefaultOptionsOnServer)
	    return m_pDefaultOptionsOnServer->Find(dhcpOptionId, pszVendor);
    else
        return NULL;
}

/*---------------------------------------------------------------------------
	CDhcpServer::GetIpAddress()
		Returns the IP Address for this server in a string
	Author: EricDav
 ---------------------------------------------------------------------------*/
LPCWSTR
CDhcpServer::GetIpAddress()
{
	return m_strServerAddress;
}

/*---------------------------------------------------------------------------
	CDhcpServer::GetIpAddress
		Returns the 32bit address of the server
	Author: EricDav
 ---------------------------------------------------------------------------*/
void
CDhcpServer::GetIpAddress(DHCP_IP_ADDRESS *pdhcpIpAddress)
{
	*pdhcpIpAddress = m_dhcpServerAddress;
}

/*---------------------------------------------------------------------------
	CDhcpServer::BuildDisplayName
		Builds the string that goes in the UI for this server
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CDhcpServer::BuildDisplayName
(
	CString * pstrDisplayName
)
{
	if (pstrDisplayName)
	{
		CString strName, strIp;

		strName = GetName();
        strIp = GetIpAddress();

        strName += _T(" [") + strIp + _T("]");

		*pstrDisplayName = strName;
	}

	return hrOK;
}

/*---------------------------------------------------------------------------
	CDhcpServer::SetExtensionName
		Builds the string that goes in the UI for this server in the 
        extension case
	Author: EricDav
 ---------------------------------------------------------------------------*/
void
CDhcpServer::SetExtensionName()
{
    SetDisplayName(_T("DHCP"));
}

/*---------------------------------------------------------------------------
	CDhcpServer::CreateOption()
		Create a new option type to match the given information
	Author: EricDav
 ---------------------------------------------------------------------------*/
LONG
CDhcpServer::CreateOption 
(
    CDhcpOption * pdhcType
)
{
    DHCP_OPTION dhcOption ;
    DHCP_OPTION_DATA * pOptData;
	LONG err ;
    CDhcpOptionValue * pcOptionValue = NULL ;

    ::ZeroMemory(&dhcOption, sizeof(dhcOption));

    CATCH_MEM_EXCEPTION
    {
        //
        //  Create the structure required for RPC; force inclusion of
        //  at least one data element to define the data type.
        //
        pcOptionValue = new CDhcpOptionValue( &pdhcType->QueryValue() ) ;

        dhcOption.OptionID      = pdhcType->QueryId();
        dhcOption.OptionName    = ::UtilWcstrDup( pdhcType->QueryName() );
        dhcOption.OptionComment = ::UtilWcstrDup( pdhcType->QueryComment() ) ;
        dhcOption.OptionType    = pdhcType->QueryOptType() ;

		pcOptionValue->CreateOptionDataStruct(&pOptData);
		CopyMemory(&dhcOption.DefaultValue, pOptData, sizeof(DHCP_OPTION_DATA));

        if (m_liDhcpVersion.QuadPart >= DHCP_NT5_VERSION)
        {
            err = (LONG) ::DhcpCreateOptionV5((LPTSTR) ((LPCTSTR) m_strServerAddress),
                                              pdhcType->IsVendor() ? DHCP_FLAGS_OPTION_IS_VENDOR : 0,
                                              dhcOption.OptionID,
                                              NULL,
                                              (LPTSTR) pdhcType->GetVendor(),
										      &dhcOption ) ;
        }
        else
        {
            err = (LONG) ::DhcpCreateOption( m_strServerAddress,
										     pdhcType->QueryId(),
										    &dhcOption ) ;
        }

        if (dhcOption.OptionName)
            delete dhcOption.OptionName;
        
        if (dhcOption.OptionComment)
            delete dhcOption.OptionComment;
    }
    END_MEM_EXCEPTION(err)

    if (err != ERROR_SUCCESS)
        Trace3("Create option type %d in scope %s FAILED, error = %d\n", (int) dhcOption.OptionID, m_strServerAddress, err);

    if (pcOptionValue)
        delete pcOptionValue ;
    
    return err ;
}

/*---------------------------------------------------------------------------
	CDhcpServer::DeleteOption()
		Delete the option type associated with this ID
	Author: EricDav
 ---------------------------------------------------------------------------*/
LONG
CDhcpServer::DeleteOption 
(
	DHCP_OPTION_ID  dhcid,
    LPCTSTR         pszVendor
)
{
    if (m_liDhcpVersion.QuadPart >= DHCP_NT5_VERSION)
    {
        DWORD dwFlags = (pszVendor == NULL) ? 0 : DHCP_FLAGS_OPTION_IS_VENDOR;

        return (LONG) ::DhcpRemoveOptionV5((LPTSTR) ((LPCTSTR) m_strServerAddress), 
                                           dwFlags,
                                           dhcid, 
                                           NULL, 
                                           (LPTSTR) pszVendor);   
    }
    else
    {
        return (LONG) ::DhcpRemoveOption(m_strServerAddress, dhcid);
    }
}

/*---------------------------------------------------------------------------
	CDhcpServer::GetDnsRegistration
		Gets the DNS registration option value
	Author: EricDav
 ---------------------------------------------------------------------------*/
DWORD
CDhcpServer::GetDnsRegistration
(
	LPDWORD pDnsRegOption
)
{
    //
    // Check option 81 -- the DNS registration option
    //
    DHCP_OPTION_VALUE * poptValue = NULL;
    DWORD				err = 0 ;

    DHCP_OPTION_SCOPE_INFO dhcScopeInfo ;
    ZeroMemory( &dhcScopeInfo, sizeof(dhcScopeInfo) );

    CATCH_MEM_EXCEPTION
    {
        dhcScopeInfo.ScopeType = DhcpGlobalOptions;

        err = (DWORD) ::DhcpGetOptionValue(m_strServerAddress,
										   OPTION_DNS_REGISTATION,
										   &dhcScopeInfo,
										   &poptValue );
	}
    END_MEM_EXCEPTION(err) ;
	
	// this is the default
	if (pDnsRegOption)
		*pDnsRegOption = DHCP_DYN_DNS_DEFAULT;

	// if this option is defined, then use it's value
	if (err == ERROR_SUCCESS)
	{
		if ((poptValue->Value.Elements != NULL) &&
			(pDnsRegOption))
		{
			*pDnsRegOption = poptValue->Value.Elements[0].Element.DWordOption;
		}
	}
	else
    {
        Trace0("CDhcpServer::GetDnsRegistration - couldn't get DNS reg value -- option may not be defined. Setting default value.\n");

		err = ERROR_SUCCESS;
    }

	// free up the RPC memory
	if (poptValue)
		::DhcpRpcFreeMemory(poptValue);

	return err;
}

/*---------------------------------------------------------------------------
	CDhcpServer::SetDnsRegistration
		Sets the DNS Registration option for this scope
	Author: EricDav
 ---------------------------------------------------------------------------*/
DWORD
CDhcpServer::SetDnsRegistration
(
	DWORD DnsRegOption
)
{
	DWORD err = 0;

	//
    // Set DNS name registration (option 81)
	//
    CDhcpOption dhcpOption (OPTION_DNS_REGISTATION,  DhcpDWordOption , _T(""), _T(""));
    dhcpOption.QueryValue().SetNumber(DnsRegOption);
    
    DHCP_OPTION_DATA *		pdhcOptionData;
    DHCP_OPTION_SCOPE_INFO	dhcScopeInfo;
    CDhcpOptionValue *		pcOptionValue = NULL;

    ZeroMemory( & dhcScopeInfo, sizeof(dhcScopeInfo) );

    CATCH_MEM_EXCEPTION
    {
        pcOptionValue = new CDhcpOptionValue( & dhcpOption.QueryValue() ) ;

        if ( pcOptionValue )
		{
            dhcScopeInfo.ScopeType = DhcpGlobalOptions ;

            pcOptionValue->CreateOptionDataStruct(&pdhcOptionData, TRUE);

            err = (DWORD) ::DhcpSetOptionValue(m_strServerAddress,
											   dhcpOption.QueryId(),
											   &dhcScopeInfo,
											   pdhcOptionData);
        }
    }
    END_MEM_EXCEPTION(err) ;

    delete pcOptionValue ;
	return err;
}

/*---------------------------------------------------------------------------
	CDhcpServer::ScanDatabase()
		Scan/reconcile database
	Author: EricDav
 ---------------------------------------------------------------------------*/
LONG
CDhcpServer::ScanDatabase  
(
    DWORD			  FixFlag,
    LPDHCP_SCAN_LIST *ScanList, 
	DHCP_IP_ADDRESS   dhcpSubnetAddress
)
{
    return (LONG) ::DhcpScanDatabase (m_strServerAddress,
									  dhcpSubnetAddress,
									  FixFlag,
									  ScanList);
}

/*---------------------------------------------------------------------------
	CDhcpServer::ScanDatabase()
		Scan/reconcile database
	Author: EricDav
 ---------------------------------------------------------------------------*/
LONG
CDhcpServer::ScanDatabase  
(
    DWORD			  FixFlag,
    LPDHCP_SCAN_LIST *ScanList, 
	LPWSTR            pMScopeName
)
{
    return (LONG) ::DhcpScanMDatabase(m_strServerAddress,
									  pMScopeName,
									  FixFlag,
									  ScanList);
}

/*---------------------------------------------------------------------------
	CDhcpServer::UpdateTypeList()
		Scan/reconcile database
	Author: EricDav
 ---------------------------------------------------------------------------*/
LONG
CDhcpServer::UpdateOptionList 
(
    COptionList * poblValues,     // The list of types/values
    COptionList * poblDefunct,    // The list of deleted types/values
    CWnd *		  pwndMsgParent   // IF !NULL, window for use for popups
)
{
    LONG err = 0,
         err2 ;
    CDhcpOption * pdhcType;

    //
    //  First, delete the deleted types
    //
    poblDefunct->Reset();
    while ( pdhcType = poblDefunct->Next() )
    {
        err2 = DeleteOption( pdhcType->QueryId(), pdhcType->GetVendor()) ;
        if ( err2 != 0 )
        {
            if ( err == 0 )
            {
                err = err2 ;
            }
        }
        pdhcType->SetApiErr( err2 ) ;
    }

    //
    //  Next, update the altered values. We do this by deleting the old setting
    //  and re adding it.
    //
    poblValues->Reset();
	while ( pdhcType = poblValues->Next() )
    {
        if ( pdhcType->IsDirty() )
        {
            //
            //  Delete the old value.
            //
            DeleteOption( pdhcType->QueryId(), pdhcType->GetVendor() ) ;

            //
            //  Recreate it.
            //
            err2 = CreateOption( pdhcType ) ;
            if ( err2 != 0 )
            {
                if ( err == 0 )
                {
                    err = err2 ;
                }
            }
            else
            {
                pdhcType->SetDirty( FALSE ) ;
            }
            
			pdhcType->SetApiErr( err2 );
        }
    }

    //
    //  If there were errors and we're given a window handle, display
    //  each error message in some detail.
    //
    if ( err && pwndMsgParent )
    {
        DisplayUpdateErrors( poblValues, poblDefunct, pwndMsgParent ) ;
    }

    return err ;
}

/*---------------------------------------------------------------------------
	CDhcpServer::DisplayUpdateErrors()
		Display all the errors associated with a pair of update lists.
	Author: EricDav
 ---------------------------------------------------------------------------*/
void
CDhcpServer::DisplayUpdateErrors 
(
    COptionList * poblValues,
    COptionList * poblDefunct,
    CWnd *		  pwndMsgParent
)
{
    CDhcpOption * pdhcType ;
    DWORD err ;
    TCHAR chBuff [STRING_LENGTH_MAX] ;
    TCHAR chMask [STRING_LENGTH_MAX] ;

    ::LoadString( AfxGetInstanceHandle(), IDS_INFO_OPTION_REFERENCE,
                 chMask, sizeof(chMask)/sizeof(chMask[0]) ) ;

    if ( poblDefunct )
    {
        poblDefunct->Reset();
		while ( pdhcType = poblDefunct->Next() )
        {
            if ( err = pdhcType->QueryApiErr() )
            {
                //
                // If we couldn't find the thing in the registry, that's
                // actually OK, because it may never have been saved in
                // the first place, i.e. it may have been added and deleted
                // in the same session of this dialog.
                //
                if ( err == ERROR_FILE_NOT_FOUND )
                {
                    err = ERROR_SUCCESS;
                }
                else
                {
                    ::wsprintf( chBuff, chMask, (int) pdhcType->QueryId() ) ;
                    ::DhcpMessageBox( err, MB_OK, chBuff ) ;
                }
            }
        }
    }

    if ( poblValues )
    {
		poblValues->Reset();
        while ( pdhcType = poblValues->Next() )
        {
            if ( err = pdhcType->QueryApiErr() )
            {
                ::wsprintf( chBuff, chMask, (int) pdhcType->QueryId() ) ;
                ::DhcpMessageBox( err, MB_OK, chBuff ) ;
            }
        }
    }
}

/*---------------------------------------------------------------------------
	CDhcpServer::HasSuperscopes
		Determines if the server has superscopes (based on cached info)
        Doesn't contact the server
	Author: EricDav
 ---------------------------------------------------------------------------*/
BOOL 
CDhcpServer::HasSuperscopes
(
    ITFSNode * pNode
)
{
    BOOL bHasSuperscopes = FALSE;

	SPITFSNodeEnum spNodeEnum;
	SPITFSNode spCurrentNode;
	ULONG nNumReturned = 0;

	pNode->GetEnum(&spNodeEnum);

	spNodeEnum->Next(1, &spCurrentNode, &nNumReturned);
	while (nNumReturned)
	{
        if (spCurrentNode->GetData(TFS_DATA_TYPE) == DHCPSNAP_SUPERSCOPE)
        {
            bHasSuperscopes = TRUE;
            break;
        }

		spCurrentNode.Release();
		spNodeEnum->Next(1, &spCurrentNode, &nNumReturned);
	}
	
    return bHasSuperscopes;
}

/*---------------------------------------------------------------------------
	CDhcpServer::UpdateStatistics
        Notification that stats are now available.  Update stats for the 
        server node and give all subnodes a chance to update.
	Author: EricDav
 ---------------------------------------------------------------------------*/
DWORD
CDhcpServer::UpdateStatistics
(
    ITFSNode * pNode
)
{
    HRESULT         hr = hrOK;
    SPITFSNodeEnum  spNodeEnum;
    SPITFSNode      spCurrentNode;
    ULONG           nNumReturned;
    HWND            hStatsWnd;
	BOOL			bChangeIcon = FALSE;

    // Check to see if this node has a stats sheet up.
    hStatsWnd = m_dlgStats.GetSafeHwnd();
    if (hStatsWnd != NULL)
    {
        PostMessage(hStatsWnd, WM_NEW_STATS_AVAILABLE, 0, 0);
    }
    
    // Set the icon to whatever is correct based on the state and
    // statistics
    LONG_PTR nOldIndex = pNode->GetData(TFS_DATA_IMAGEINDEX);
    int nNewIndex = GetImageIndex(FALSE);

    if (nOldIndex != nNewIndex)
    {
        pNode->SetData(TFS_DATA_IMAGEINDEX, GetImageIndex(FALSE));
        pNode->SetData(TFS_DATA_OPENIMAGEINDEX, GetImageIndex(TRUE));
        pNode->ChangeNode(SCOPE_PANE_CHANGE_ITEM_ICON);
    }

    // After updating everything for the server node,
    // tell the scope and superscope nodes to update anything
    // they need to based on the new stats.
    CORg(pNode->GetEnum(&spNodeEnum));

	CORg(spNodeEnum->Next(1, &spCurrentNode, &nNumReturned));
	while (nNumReturned)
	{
        if (spCurrentNode->GetData(TFS_DATA_TYPE) == DHCPSNAP_SCOPE)
        {
            CDhcpScope * pScope = GETHANDLER(CDhcpScope, spCurrentNode);

            pScope->UpdateStatistics(spCurrentNode);
        }
        else
        if (spCurrentNode->GetData(TFS_DATA_TYPE) == DHCPSNAP_SUPERSCOPE)
        {
            CDhcpSuperscope * pSuperscope = GETHANDLER(CDhcpSuperscope, spCurrentNode);

            pSuperscope->UpdateStatistics(spCurrentNode);
        }

        spCurrentNode.Release();
		spNodeEnum->Next(1, &spCurrentNode, &nNumReturned);
	}

Error:
    return hr;
}

/*---------------------------------------------------------------------------
	CDhcpServer::SetMibInfo()
		Updates our pointer to the MIB info struct
	Author: EricDav
 ---------------------------------------------------------------------------*/
LPDHCP_MIB_INFO 
CDhcpServer::SetMibInfo
(
    LPDHCP_MIB_INFO pMibInfo
) 
{
    CSingleLock slMibInfo(&m_csMibInfo);

    slMibInfo.Lock();
    
    LPDHCP_MIB_INFO pTemp = NULL;

    if (m_pMibInfo)
    {
        pTemp = m_pMibInfo;
        ::DhcpRpcFreeMemory(m_pMibInfo);
	pTemp = 0;
    }

    m_pMibInfo = pMibInfo;

    return pTemp;
}

/*---------------------------------------------------------------------------
	CDhcpServer::DuplicateMibInfo()
		Makes a copy if the MibInfo struct.  We do this because the MIB info
        struct may get updated in the background.
	Author: EricDav
 ---------------------------------------------------------------------------*/
LPDHCP_MIB_INFO
CDhcpServer::DuplicateMibInfo()
{
    HRESULT         hr = hrOK;
    LPDHCP_MIB_INFO pDupMibInfo = NULL;
    int             nSize = 0;
    CSingleLock     slMibInfo(&m_csMibInfo);
    
    slMibInfo.Lock();

    Assert(m_pMibInfo);
    if (m_pMibInfo == NULL)
        return NULL;

    COM_PROTECT_TRY
    {
        nSize = sizeof(DHCP_MIB_INFO) + m_pMibInfo->Scopes * sizeof(SCOPE_MIB_INFO);
        pDupMibInfo = (LPDHCP_MIB_INFO) new BYTE[nSize];

        *pDupMibInfo = *m_pMibInfo;

		pDupMibInfo->ScopeInfo = (LPSCOPE_MIB_INFO) ((LPBYTE) pDupMibInfo + sizeof(DHCP_MIB_INFO));

		if (m_pMibInfo->ScopeInfo)
		{
			memcpy(pDupMibInfo->ScopeInfo, m_pMibInfo->ScopeInfo, m_pMibInfo->Scopes * sizeof(SCOPE_MIB_INFO));
		}
    }
    COM_PROTECT_CATCH

    return pDupMibInfo;
}

/*---------------------------------------------------------------------------
	CDhcpServer::FreeDupMibInfo()
		Scan/reconcile database
	Author: EricDav
 ---------------------------------------------------------------------------*/
void
CDhcpServer::FreeDupMibInfo(LPDHCP_MIB_INFO pDupMibInfo)
{
    delete pDupMibInfo;
}

/*---------------------------------------------------------------------------
	CDhcpServer::SetMCastMibInfo()
		Updates our pointer to the MIB info struct
	Author: EricDav
 ---------------------------------------------------------------------------*/
LPDHCP_MCAST_MIB_INFO 
CDhcpServer::SetMCastMibInfo
(
    LPDHCP_MCAST_MIB_INFO pMibInfo
) 
{
    CSingleLock slMibInfo(&m_csMibInfo);

    slMibInfo.Lock();
    
    LPDHCP_MCAST_MIB_INFO pTemp = NULL;

    if (m_pMCastMibInfo)
    {
        pTemp = m_pMCastMibInfo;
        ::DhcpRpcFreeMemory(m_pMCastMibInfo);
	pTemp = 0;
    }

    m_pMCastMibInfo = pMibInfo;

    return pTemp;
}

/*---------------------------------------------------------------------------
	CDhcpServer::DuplicateMCastMibInfo()
		Makes a copy if the MibInfo struct.  We do this because the MIB info
        struct may get updated in the background.
	Author: EricDav
 ---------------------------------------------------------------------------*/
LPDHCP_MCAST_MIB_INFO
CDhcpServer::DuplicateMCastMibInfo()
{
    HRESULT                 hr = hrOK;
    LPDHCP_MCAST_MIB_INFO   pDupMibInfo = NULL;
    int                     nSize = 0;
    CSingleLock             slMibInfo(&m_csMibInfo);
    
    slMibInfo.Lock();

    Assert(m_pMCastMibInfo);
    if (m_pMCastMibInfo == NULL)
        return NULL;

    COM_PROTECT_TRY
    {
        nSize = sizeof(DHCP_MCAST_MIB_INFO) + m_pMibInfo->Scopes * sizeof(MSCOPE_MIB_INFO);
        pDupMibInfo = (LPDHCP_MCAST_MIB_INFO) new BYTE[nSize];

        *pDupMibInfo = *m_pMCastMibInfo;
        *pDupMibInfo->ScopeInfo = *m_pMCastMibInfo->ScopeInfo;
    }
    COM_PROTECT_CATCH

    return pDupMibInfo;
}

/*---------------------------------------------------------------------------
	CDhcpServer::FreeDupMCastMibInfo()
		Scan/reconcile database
	Author: EricDav
 ---------------------------------------------------------------------------*/
void
CDhcpServer::FreeDupMCastMibInfo(LPDHCP_MCAST_MIB_INFO pDupMibInfo)
{
    delete pDupMibInfo;
}

/*---------------------------------------------------------------------------
	CDhcpServer::TriggerStatsRefresh()
		Starts the background thread to gather stats only
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CDhcpServer::TriggerStatsRefresh(ITFSNode * pNode)
{
	m_dwErr = 0;
    m_bStatsOnly = TRUE;
	OnRefreshStats(pNode, NULL, NULL, 0, 0);
    m_bStatsOnly = FALSE;

    return hrOK;
}



/*---------------------------------------------------------------------------
	Background thread functionality
 ---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------
	CDhcpServer::OnCreateQuery
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
ITFSQueryObject* 
CDhcpServer::OnCreateQuery(ITFSNode * pNode)
{
	CDhcpServerQueryObj* pQuery = NULL;
    HRESULT hr = hrOK;

    COM_PROTECT_TRY
    {
	    pQuery = new CDhcpServerQueryObj(m_spTFSCompData, m_spNodeMgr);
	    
        if ( pQuery == NULL )
        {
            return pQuery;
        }

	    pQuery->m_strServer = m_strServerAddress;
		pQuery->m_strServerName = m_strDnsName;
		
	    pQuery->m_dhcpResumeHandle = NULL;
	    pQuery->m_dwPreferredMax = 0xFFFFFFFF;
	    pQuery->m_liDhcpVersion.QuadPart = m_liDhcpVersion.QuadPart;
	    pQuery->m_pDefaultOptionsOnServer = m_pDefaultOptionsOnServer;

        pQuery->m_bStatsOnly = m_bStatsOnly;
    }
    COM_PROTECT_CATCH

    return pQuery;
}

/*---------------------------------------------------------------------------
	CDhcpServer::OnCreateStatsQuery
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
ITFSQueryObject* 
CDhcpServer::OnCreateStatsQuery(ITFSNode * pNode)
{
	CDhcpServerQueryObj* pQuery = NULL;
    HRESULT hr = hrOK;

	COM_PROTECT_TRY
    {
        pQuery = new CDhcpServerQueryObj(m_spTFSCompData, m_spNodeMgr);
	    
        if ( pQuery == NULL )
        {
            return pQuery;
        }

	    pQuery->m_strServer = m_strServerAddress;
	    
	    pQuery->m_dhcpResumeHandle = NULL;
	    pQuery->m_dwPreferredMax = 0;
	    pQuery->m_liDhcpVersion.QuadPart = 0;
	    pQuery->m_pDefaultOptionsOnServer = NULL;

        pQuery->m_bStatsOnly = TRUE;
    }
    COM_PROTECT_CATCH

    return pQuery;
}

/*---------------------------------------------------------------------------
    CDhcpServerQueryObj::OnEventAbort
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
void
CDhcpServerQueryObj::OnEventAbort
(
	LPARAM Data,
	LPARAM Type
)
{
	if (Type == DHCP_QDATA_VERSION)
	{
		Trace0("CDhcpServerQueryObj::OnEventAbort - deleting version");
		delete (void *) Data;
	}

	if (Type == DHCP_QDATA_SERVER_INFO)
	{
		Trace0("CDhcpServerQueryObj::OnEventAbort - deleting ServerInfo");
		delete (void *) Data;
	}

   	if (Type == DHCP_QDATA_STATS)
	{
		Trace0("CDhcpServerQueryObj::OnEventAbort - deleting Stats Info");
        ::DhcpRpcFreeMemory((void *) Data);
    }
}

/*---------------------------------------------------------------------------
	Function Name Here
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP
CDhcpServerQueryObj::Execute()
{
    HRESULT                         hr = hrOK;
	DWORD                           err = ERROR_SUCCESS;
    LPDHCP_SERVER_CONFIG            pServerInfo = NULL;
    LPDHCP_SERVER_ID		        pServerId = NULL;
	SPITFSNode                      spGlobalOptionsNode;
	SPITFSNode                      spBootpNode;
    DHCP_OPTION_SCOPE_INFO          dhcpOptionScopeInfo;
    CDhcpDefaultOptionsMasterList   MasterList;
    CDhcpGlobalOptions *            pGlobalOptions = NULL;
    CDhcpBootp *                    pDhcpBootp = NULL;
    CClassInfoArray *               pClassInfoArray = NULL;
    COptionValueEnum *              pOptionValueEnum = NULL;
	LARGE_INTEGER *					pLI = NULL;

    COM_PROTECT_TRY
    {
        m_pSubnetInfoCache = new CSubnetInfoCache;

		// check to see if the ip address has changed
		if (VerifyDhcpServer())
		{
			// ip address has changed...
		    pServerId = new DHCP_SERVER_ID;

			pServerId->strIp = m_strServer;
			pServerId->strName = m_strServerName;

			AddToQueue((LPARAM) pServerId, DHCP_QDATA_SERVER_ID);
		}

        // Get the server's version
	    err = SetVersion();
	    if (err != ERROR_SUCCESS)
	    {
		    PostError(err);

			if (m_bStatsOnly)
			{
				// poke the main thread to update the UI
			  	AddToQueue(NULL, DHCP_QDATA_STATS);
			}

		    return hrFalse;
	    }

		// send the info back to the main thread
		pLI = new LARGE_INTEGER;
		*pLI = m_liDhcpVersion;
		AddToQueue((LPARAM) pLI, DHCP_QDATA_VERSION);

        // Get server stats
        err = GetStatistics();
        if (err != ERROR_SUCCESS)
        { 
            Trace1("CDhcpServerQueryObj: ERROR - GetStatistics returned %d\n", err);
            PostError(err);

			if (m_bStatsOnly)
			{
				// poke the main thread to update the UI
			  	AddToQueue(NULL, DHCP_QDATA_STATS);
			}
            
			return hrFalse;
        }

		// Get rogue and other info
        err = GetStatus();
        if (err != ERROR_SUCCESS)
        { 
            Trace1("CDhcpServerQueryObj: ERROR - GetStatus returned %d\n", err);
            PostError(err);

			if (m_bStatsOnly)
			{
				// poke the main thread to update the UI
			  	AddToQueue(NULL, DHCP_QDATA_STATS);
			}
            
			return hrFalse;
        }
        
        // if we are only querring for stats, exit out.
        if (m_bStatsOnly)
        {
            delete m_pSubnetInfoCache;
            return hrFalse;
        }

        // Get the configuration information
	    err = GetConfigInfo();
	    if (err != ERROR_SUCCESS)
	    {
		    PostError(err);
		    return hrFalse;
	    }

	    pServerInfo = new DHCP_SERVER_CONFIG;
	    pServerInfo->fAuditLog = m_fAuditLog;
	    pServerInfo->dwPingRetries = m_dwPingRetries;
        pServerInfo->strDatabasePath = m_strDatabasePath;
        pServerInfo->strBackupPath = m_strBackupPath;
        pServerInfo->strAuditLogDir = m_strAuditLogPath;
		pServerInfo->fSupportsDynBootp = m_fSupportsDynBootp;
		pServerInfo->fSupportsBindings = m_fSupportsBindings;

        // get the new name
		/*
        DHCP_IP_ADDRESS dhipa = UtilCvtWstrToIpAddr(m_strServer);
        DHC_HOST_INFO_STRUCT hostInfo;
        err = ::UtilGetHostInfo(dhipa, &hostInfo);
        if (err == ERROR_SUCCESS)
        {
            pServerInfo->strDnsName = hostInfo._chHostName;
        }
        */
        
		AddToQueue((LPARAM) pServerInfo, DHCP_QDATA_SERVER_INFO);

	    //
	    // Now enumerate all of the options on the server
	    //
	    m_pDefaultOptionsOnServer->Enumerate(m_strServer, m_liDhcpVersion);
	    Trace2("Server %s has %d default options defined.\n", m_strServer, m_pDefaultOptionsOnServer->GetCount());

        MasterList.BuildList();

	    if (m_pDefaultOptionsOnServer->GetCount() != MasterList.GetCount())
	    {
		    // 
		    // This server doesn't have any options defined or is missing some
		    //
		    UpdateDefaultOptionsOnServer(m_pDefaultOptionsOnServer, &MasterList);
	    }

        // enumerate global options
        Trace0("Enumerating global options.\n");

        // enumerate the classes on the server
        pOptionValueEnum = new COptionValueEnum();

        dhcpOptionScopeInfo.ScopeType = DhcpGlobalOptions;
        dhcpOptionScopeInfo.ScopeInfo.GlobalScopeInfo = NULL;

        pOptionValueEnum->Init(m_strServer, m_liDhcpVersion, dhcpOptionScopeInfo);
        err = pOptionValueEnum->Enum();
        if (err != ERROR_SUCCESS)
        {
            PostError(err);
            delete pOptionValueEnum;
            return hrFalse;
        }
        else
        {
            pOptionValueEnum->SortById();
            AddToQueue((LPARAM) pOptionValueEnum, DHCP_QDATA_OPTION_VALUES);
        }

	    //
	    // Make Global Options folder
	    //
	    pGlobalOptions = new CDhcpGlobalOptions(m_spTFSCompData);
	    CreateContainerTFSNode(&spGlobalOptionsNode,
						       &GUID_DhcpGlobalOptionsNodeType,
						       pGlobalOptions,
						       pGlobalOptions,
						       m_spNodeMgr);

	    // Tell the handler to initialize any specific data
	    pGlobalOptions->InitializeNode(spGlobalOptionsNode);
	    AddToQueue(spGlobalOptionsNode);
	    pGlobalOptions->Release();

        if (m_liDhcpVersion.QuadPart >= DHCP_NT5_VERSION)
        {
		    Trace0("Version is at least NT5, enumerating classes on server.\n");

            // enumerate the classes on the server
            pClassInfoArray = new CClassInfoArray();
            pClassInfoArray->RefreshData(m_strServer);
    	    AddToQueue((LPARAM) pClassInfoArray, DHCP_QDATA_CLASS_INFO);

            EnumMScopes();
        }

        if (m_liDhcpVersion.QuadPart >= DHCP_SP2_VERSION)
	    {
		    //
		    // This server supports the v4 calls
		    //
		    Trace0("Version is at least NT4 SP2, Creating BOOTP Folder.\n");

		    //
		    // Make the BOOTP Table folder
		    //
		    pDhcpBootp = new CDhcpBootp(m_spTFSCompData);
		    CreateContainerTFSNode(&spBootpNode,
							       &GUID_DhcpBootpNodeType,
							       pDhcpBootp,
							       pDhcpBootp,
							       m_spNodeMgr);

		    // Tell the handler to initialize any specific data
		    pDhcpBootp->InitializeNode(spBootpNode);

		    AddToQueue(spBootpNode);
		    pDhcpBootp->Release();

		    EnumSubnetsV4();
	    }
	    else
	    {
		    //
		    // This server doesn't support the V4 calls
		    //
		    EnumSubnets();
	    }

      	AddToQueue((LPARAM) m_pSubnetInfoCache, DHCP_QDATA_SUBNET_INFO_CACHE);

    }
    COM_PROTECT_CATCH

	return hrFalse;
}

/*---------------------------------------------------------------------------
	CDhcpServerQueryObj::VerifyDhcpServer()
		Resolve the IP address and see if the names are the same.  If not,
		get the new IP address.
	Author: EricDav
 ---------------------------------------------------------------------------*/
BOOL
CDhcpServerQueryObj::VerifyDhcpServer()
{
    DHCP_IP_ADDRESS			dhipa = UtilCvtWstrToIpAddr(m_strServer);
    DHC_HOST_INFO_STRUCT	hostInfo;
	BOOL					fChanged = FALSE;
	DWORD					dwErr = ERROR_SUCCESS;

    dwErr = ::UtilGetHostInfo(dhipa, &hostInfo);
    if ( (dwErr != ERROR_SUCCESS) ||
         (m_strServerName.CompareNoCase(hostInfo._chHostName) != 0) )
	{
		// assume the IP address has changed
		// get the IP address associated with the name we had before
		fChanged = TRUE;

        if (m_strServerName.IsEmpty())
        {
            // host name couldn't be resolved when we entered the IP 
            // originally...  So now it can be so lets update the name
            m_strServerName = hostInfo._chHostName;
        }
        else
        {
            // IP resolved to a different name
            // so, let's resolve the name we've stored away to the
            // new IP
		    if (UtilGetHostAddress(m_strServerName, &dhipa) == ERROR_SUCCESS)
            {
		        UtilCvtIpAddrToWstr(dhipa, &m_strServer);
            }
        }
    }
    
	return fChanged;
}

/*---------------------------------------------------------------------------
	CDhcpServerQueryObj::SetVersion()
		 Call the the get version number API,
		 to determine the DHCP version of this
		 host.

		 Return TRUE for success.
	Author: EricDav
 ---------------------------------------------------------------------------*/
DWORD
CDhcpServerQueryObj::SetVersion()
{
    DWORD	dwMajorVersion = 0;
    DWORD	dwMinorVersion = 0;
	LPCWSTR pServerAddress = (LPCWSTR) m_strServer;

    DWORD dw = ::DhcpGetVersion((LPWSTR) pServerAddress, &dwMajorVersion, &dwMinorVersion);
    
	Trace3("DhcpGetVersion returned %lx.  Version is %d.%d\n", dw, dwMajorVersion, dwMinorVersion);

    if (dw == RPC_S_PROCNUM_OUT_OF_RANGE)
    {
        //
        // Only in 3.5 was this API not present, so
        // set the version to 1.0, and reset the error
        //
        Trace0("API Not present, version 1.0 assumed\n");
        dwMajorVersion = 1;
        dwMinorVersion = 0;
        dw = ERROR_SUCCESS;
    }

    if (dw == ERROR_SUCCESS)
    {
        m_liDhcpVersion.LowPart = dwMinorVersion;
        m_liDhcpVersion.HighPart = dwMajorVersion;
	}

	return dw;
} 

/*---------------------------------------------------------------------------
	GetConfigInfo()
		This function gets the conflict detection attempt count and the
		audit logging flag from the server.  These are the only server
		config options we care about.  We store the option values in 
		the query object so that if this object gets used by sometime 
		other than the background thread, the values can just be read 
		out of the object, and we don't have to muck with the data queue.
	Author: EricDav
 ---------------------------------------------------------------------------*/
DWORD
CDhcpServerQueryObj::GetConfigInfo()
{
	DWORD dwError = 0;

	if (m_liDhcpVersion.QuadPart >= DHCP_SP2_VERSION)
	{
    	LPDHCP_SERVER_CONFIG_INFO_V4 pConfigInfo = NULL;
	
        dwError = ::DhcpServerGetConfigV4(m_strServer, &pConfigInfo);
		if (dwError == ERROR_SUCCESS)
		{
			m_fAuditLog = pConfigInfo->fAuditLog;
			m_dwPingRetries = pConfigInfo->dwPingRetries;
            m_strDatabasePath = pConfigInfo->DatabasePath;
            m_strBackupPath = pConfigInfo->BackupPath;

			::DhcpRpcFreeMemory(pConfigInfo);
		}
	}
    else
    {
    	LPDHCP_SERVER_CONFIG_INFO pConfigInfo = NULL;
	
        dwError = ::DhcpServerGetConfig(m_strServer, &pConfigInfo);
		if (dwError == ERROR_SUCCESS)
		{
            m_strDatabasePath = pConfigInfo->DatabasePath;
            m_strBackupPath = pConfigInfo->BackupPath;

			::DhcpRpcFreeMemory(pConfigInfo);
		}
    }

	// audit logging stuff
	if (m_liDhcpVersion.QuadPart >= DHCP_NT5_VERSION)
	{
		LPWSTR		pAuditLogPath = NULL;
		DWORD		dwDiskCheckInterval = 0, dwMaxLogFilesSize = 0, dwMinSpaceOnDisk = 0;

		dwError = ::DhcpAuditLogGetParams((LPWSTR) (LPCTSTR) m_strServer,
										  0,
										  &pAuditLogPath,
										  &dwDiskCheckInterval,
										  &dwMaxLogFilesSize,
										  &dwMinSpaceOnDisk);
		if (dwError == ERROR_SUCCESS)
		{
			m_strAuditLogPath = pAuditLogPath;

			::DhcpRpcFreeMemory(pAuditLogPath);
		}
	}
	
	// dynamic BOOTP supported?
	if (m_liDhcpVersion.QuadPart >= DHCP_NT5_VERSION)
	{
        LPDHCP_ATTRIB pdhcpAttrib = NULL;

        DWORD dwTempError = ::DhcpServerQueryAttribute((LPWSTR) (LPCTSTR) m_strServer, NULL, DHCP_ATTRIB_BOOL_IS_DYNBOOTP, &pdhcpAttrib);
		if (dwTempError == ERROR_SUCCESS)
		{
    	    Assert(pdhcpAttrib);
			m_fSupportsDynBootp = pdhcpAttrib->DhcpAttribBool;
			
            ::DhcpRpcFreeMemory(pdhcpAttrib);
		}
		else
		{
			m_fSupportsDynBootp = FALSE;
		}
	}
	else
	{
		m_fSupportsDynBootp = FALSE;
	}

	// Bindings supported?
	if (m_liDhcpVersion.QuadPart >= DHCP_NT5_VERSION)
    {
        LPDHCP_ATTRIB pdhcpAttrib = NULL;

        DWORD dwTempError = ::DhcpServerQueryAttribute((LPWSTR) (LPCTSTR) m_strServer, NULL, DHCP_ATTRIB_BOOL_IS_BINDING_AWARE, &pdhcpAttrib);
        if (dwTempError == ERROR_SUCCESS)
        {
            Assert(pdhcpAttrib);
            m_fSupportsBindings = pdhcpAttrib->DhcpAttribBool;
			
            ::DhcpRpcFreeMemory(pdhcpAttrib);
        }
        else
        {
            m_fSupportsBindings = FALSE;
        }
    }
    else
    {
        m_fSupportsBindings = FALSE;
    }

    return dwError;
}

/*---------------------------------------------------------------------------
	GetStatus()
        This function gets the rogue status of the DHCP server.  
    Author: EricDav
 ---------------------------------------------------------------------------*/
DWORD
CDhcpServerQueryObj::GetStatus()
{
	DWORD dwError = 0;

    LPDHCP_ATTRIB       pdhcpAttrib = NULL;
    DHCP_ROGUE_INFO  *  pRogueInfo = new DHCP_ROGUE_INFO;

    if (pRogueInfo == NULL)
    {
        return ERROR_NOT_ENOUGH_MEMORY;
    }

    pRogueInfo->fIsInNt5Domain = TRUE;  // assume true

	if (m_liDhcpVersion.QuadPart >= DHCP_NT5_VERSION)
	{
	    pRogueInfo->fIsRogue = TRUE;        // assume the worst here
    
		dwError = ::DhcpServerQueryAttribute((LPWSTR) (LPCTSTR) m_strServer, NULL, DHCP_ATTRIB_BOOL_IS_ROGUE, &pdhcpAttrib);
		if (dwError == ERROR_SUCCESS)
		{
    	    Assert(pdhcpAttrib);

            pRogueInfo->fIsRogue = pdhcpAttrib->DhcpAttribBool;

            ::DhcpRpcFreeMemory(pdhcpAttrib);
			pdhcpAttrib = NULL;
		}

        dwError = ::DhcpServerQueryAttribute((LPWSTR) (LPCTSTR) m_strServer, NULL, DHCP_ATTRIB_BOOL_IS_PART_OF_DSDC, &pdhcpAttrib);
		if (dwError == ERROR_SUCCESS)
		{
    	    Assert(pdhcpAttrib);

            pRogueInfo->fIsInNt5Domain = pdhcpAttrib->DhcpAttribBool;

            ::DhcpRpcFreeMemory(pdhcpAttrib);
			pdhcpAttrib = NULL;
		}
	}
	else
	{
		// pre-NT5 servers are never rogue
		pRogueInfo->fIsRogue = FALSE;
	}

    AddToQueue((LPARAM) pRogueInfo, DHCP_QDATA_ROGUE_INFO);

	return ERROR_SUCCESS;
}

/*---------------------------------------------------------------------------
    CDhcpServerQueryObj::GetStatistics
		Gets stats info from the server.
        WARNING WARNING - I use the NumPendingOffers field of the scope 
        stats for the current state of the scope.  This field is not 
        used in any of the statistics displays. The server node needs to
        know if the scope is active or not.  Because of the way nodes are 
        enumerated, we may not have created all of the scope nodes 
        below a superscope, so there is no way to garuntee we can determine
        the state of all scopes through our internal tree.
        If the scope is not active, then we DO NOT display 
        any warning indicators.
	Author: EricDav
 ---------------------------------------------------------------------------*/
DWORD
CDhcpServerQueryObj::GetStatistics()
{
    DWORD               dwError;
	LPDHCP_MIB_INFO     pMibInfo = NULL;

    dwError = ::DhcpGetMibInfo(m_strServer, &pMibInfo);
    if (dwError != ERROR_SUCCESS)
	{
		return dwError;
	}

    Assert(pMibInfo);
    if (pMibInfo == NULL)
        return ERROR_INVALID_DATA;

    // now loop through and get the state for each scope
    LPSCOPE_MIB_INFO pScopeMibInfo = pMibInfo->ScopeInfo;
    CSubnetInfo     subnetInfo;

    // walk the list of scopes and get the state
    for (UINT i = 0; i < pMibInfo->Scopes; i++)
    {
        // assume the scope is not active
        pScopeMibInfo[i].NumPendingOffers = DhcpSubnetEnabled;

        dwError = m_pSubnetInfoCache->GetInfo(m_strServer, pScopeMibInfo[i].Subnet, subnetInfo);
        if (dwError == ERROR_SUCCESS)
        {
            pScopeMibInfo[i].NumPendingOffers = subnetInfo.SubnetState;
        }
    }
     
  	AddToQueue((LPARAM) pMibInfo, DHCP_QDATA_STATS);

    if (m_liDhcpVersion.QuadPart >= DHCP_NT5_VERSION)
    {
	    LPDHCP_MCAST_MIB_INFO pMCastMibInfo = NULL;
	    
        dwError = ::DhcpGetMCastMibInfo(m_strServer, &pMCastMibInfo);
        if (dwError == ERROR_SUCCESS)
	    {
            LPMSCOPE_MIB_INFO pMScopeMibInfo = pMCastMibInfo->ScopeInfo;

            // walk the list of scopes and get the state
            for (i = 0; i < pMCastMibInfo->Scopes; i++)
            {
                // assume the scope is not active
                pMScopeMibInfo[i].NumPendingOffers = DhcpSubnetEnabled;

                dwError = m_MScopeInfoCache.GetInfo(m_strServer, pMScopeMibInfo[i].MScopeName, subnetInfo);
                if (dwError == ERROR_SUCCESS)
                {
                    pMScopeMibInfo[i].NumPendingOffers = subnetInfo.SubnetState;
                }
            }
	    }

        AddToQueue((LPARAM) pMCastMibInfo, DHCP_QDATA_MCAST_STATS);
    }

    return dwError;
}

/*---------------------------------------------------------------------------
    CDhcpServerQueryObj::UpdateDefaultOptionsOnServer
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
void
CDhcpServerQueryObj::UpdateDefaultOptionsOnServer
(
	CDhcpDefaultOptionsOnServer	*	pOptionsOnServer,
	CDhcpDefaultOptionsMasterList * pMasterList
)
{
    LONG err = ERROR_SUCCESS,
         err2;
    BOOL fAddedTypes = FALSE;
    CString strMasterVendor, strOptionVendor;

	CDhcpOption * pMasterOption;
    CDhcpOption * pServerOption = pOptionsOnServer->Next() ;

    if (pServerOption)
        strOptionVendor = pServerOption->GetVendor();

    while ( pMasterOption = pMasterList->Next() )
    {
        DHCP_OPTION_ID idMaster;

        if (pMasterOption)
        {
            idMaster = pMasterOption->QueryId();
            strMasterVendor = pMasterOption->GetVendor();
        }

        while ( pServerOption != NULL && 
				idMaster > pServerOption->QueryId() )
        {
            //
			// The cached list contains an entry not on the master list.
            // Advance to the next element in the cached list.
            //
			pServerOption = pOptionsOnServer->Next();
            if (pServerOption)
                strOptionVendor = pServerOption->GetVendor();
        }

        if ( pServerOption != NULL && 
			 idMaster == pServerOption->QueryId() &&
             strMasterVendor.CompareNoCase(strOptionVendor) == 0 )
        {
            //
			// This entry is on both the cached list and the master list.
            // Advance to the next element in both lists.
            //
			pServerOption = pOptionsOnServer->Next();
            if (pServerOption)
                strOptionVendor = pServerOption->GetVendor();

            continue;
        }

        //
		// There is no DhcpCreateOptions (plural), and DhcpSetValues
        //  only initializes OptionValue
        //
		err2 = CreateOption( pMasterOption ); // ignore error return
        if ( err2 != ERROR_SUCCESS )
        {
            Trace2("CDhcpServerQueryObj: error %d adding type %d\n", err2, idMaster);
        }

        fAddedTypes = TRUE;
    }

    //
	// Update cache if necessary
    //
	if ( fAddedTypes )
    {
        if (err == ERROR_SUCCESS)
            err = pOptionsOnServer->Enumerate(m_strServer, m_liDhcpVersion);
    }

    if ( err != ERROR_SUCCESS )
    {
        Trace1("UpdateDefaultOptionsOnServer error %d in CreateTypeList\n", err);
    }
}

/*---------------------------------------------------------------------------
	Function Name Here
		Create a new type to match the given information
	Author: EricDav
 ---------------------------------------------------------------------------*/
LONG
CDhcpServerQueryObj::CreateOption 
(
    CDhcpOption * pOption
)
{
    DHCP_OPTION dhcpOption;
    LONG err ;
	LPDHCP_OPTION_DATA pDhcpOptionData;
	CDhcpOptionValue & OptionValue = pOption->QueryValue();

	OptionValue.CreateOptionDataStruct(&pDhcpOptionData, TRUE);
    
	ZeroMemory( &dhcpOption, sizeof(dhcpOption) ) ;

    CATCH_MEM_EXCEPTION
    {
        dhcpOption.OptionID      = pOption->QueryId() ;
        dhcpOption.OptionName    = ((LPWSTR) (LPCTSTR) pOption->QueryName()) ;
        dhcpOption.OptionComment = ((LPWSTR) (LPCTSTR) pOption->QueryComment())  ;
        dhcpOption.DefaultValue  = *pDhcpOptionData ;
        dhcpOption.OptionType    = pOption->QueryOptType() ;

        err = (LONG) ::DhcpCreateOption( m_strServer,
										 pOption->QueryId(),
										 &dhcpOption ) ;
    }
    END_MEM_EXCEPTION(err)

    if (err)
		Trace3("Create option type %d on server %s FAILED, error = %d\n", dhcpOption.OptionID, m_strServer, err); 
		
	OptionValue.FreeOptionDataStruct();
    
	return err ;
}

/*---------------------------------------------------------------------------
    CDhcpServerQueryObj::EnumMScopes()
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
void
CDhcpServerQueryObj::EnumMScopes()
{

	DWORD						dwError = ERROR_MORE_DATA;
	DWORD						dwElementsRead = 0, dwElementsTotal = 0;
	LPDHCP_MSCOPE_TABLE			pMScopeTable = NULL;
    CSubnetInfo                 subnetInfo;

	//
	// for this server, enumerate all of it's subnets
	// 
	while (dwError == ERROR_MORE_DATA)
	{
		dwError = ::DhcpEnumMScopes((LPCTSTR)m_strServer,
									&m_dhcpResumeHandle,
									m_dwPreferredMax, 
									&pMScopeTable,
									&dwElementsRead,
									&dwElementsTotal);
    	
        Trace2("Server %s - DhcpEnumMScopes returned %lx.\n", m_strServer, dwError);

		if (dwElementsRead && dwElementsTotal && pMScopeTable)
		{
			//
			// loop through all of the subnets that were returned
			//
			for (DWORD i = 0; i < pMScopeTable->NumElements; i++)
			{
                DWORD dwReturn = m_MScopeInfoCache.GetInfo(m_strServer,  pMScopeTable->pMScopeNames[i], subnetInfo);
                if (dwReturn != ERROR_SUCCESS)
                {
                    Trace3("Server %s, MScope %s - DhcpGetMScopeInfo returned %lx.\n", m_strServer, pMScopeTable->pMScopeNames[i], dwError);
                }
                else
                {
        		    //
				    // Create the new scope based on the info we querried
				    //

				    SPITFSNode spNode;
				    CDhcpMScope * pDhcpMScope = new CDhcpMScope(m_spTFSCompData);
				    CreateContainerTFSNode(&spNode,
									       &GUID_DhcpMScopeNodeType,
									       pDhcpMScope,
									       pDhcpMScope,
									       m_spNodeMgr);

				    // Tell the handler to initialize any specific data
                    pDhcpMScope->InitMScopeInfo(subnetInfo);
                    pDhcpMScope->InitializeNode(spNode);
			    
				    AddToQueue(spNode);

				    pDhcpMScope->Release();
                }
			}

			//
			// Free up the RPC memory
			//
			::DhcpRpcFreeMemory(pMScopeTable);

			dwElementsRead = 0;
			dwElementsTotal = 0;
			pMScopeTable = NULL;
		}
	}
}

/*---------------------------------------------------------------------------
    CDhcpServerQueryObj::EnumSubnetsV4()
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
void
CDhcpServerQueryObj::EnumSubnetsV4()
{
	DWORD							dwError = ERROR_MORE_DATA;
	LPDHCP_SUPER_SCOPE_TABLE		pSuperscopeTable = NULL;
	DHCP_SUPER_SCOPE_TABLE_ENTRY *	pSuperscopeTableEntry;	// Pointer to a single entry in array
	CDhcpSuperscope *				pSuperscope = NULL;
	CNodeList						listSuperscopes;
    CSubnetInfo                     subnetInfo;

	dwError = ::DhcpGetSuperScopeInfoV4((LPWSTR) ((LPCTSTR)m_strServer),
										&pSuperscopeTable);

	if (dwError != ERROR_SUCCESS)
    {
        PostError(dwError);
        return;
    }

    Trace2("Server %s - DhcpGetSuperScopeInfoV4 returned %lx.\n", m_strServer, dwError);
	
	if (pSuperscopeTable == NULL)
	{
		ASSERT(FALSE);
		return;	// Just in case
	}

	pSuperscopeTableEntry = pSuperscopeTable->pEntries;
	if (pSuperscopeTableEntry == NULL && pSuperscopeTable->cEntries != 0)
	{
		ASSERT(FALSE);
		return; // Just in case
	}

	for (int iSuperscopeEntry = pSuperscopeTable->cEntries;
		 iSuperscopeEntry > 0;
		 iSuperscopeEntry--, pSuperscopeTableEntry++)
	{
		if (pSuperscopeTableEntry->SuperScopeName == NULL)
		{
			//
			// The API lists all the scopes, not just scopes that are members of a superscope.
			// You can tell if a scope is a member of a superscope by looking at the SuperScopeName.
			// If its NULL, the scope is not a member of a superscope.
			//

            DWORD dwReturn = m_pSubnetInfoCache->GetInfo(m_strServer, pSuperscopeTableEntry->SubnetAddress, subnetInfo);
            if (dwReturn != ERROR_SUCCESS)
            {
                Trace2("Server %s - DhcpGetSubnetInfo returned %lx.\n", m_strServer, dwReturn);
            }
            else
            {
			    SPITFSNode spScopeNode;
			    CDhcpScope * pDhcpScope = new CDhcpScope(m_spTFSCompData, subnetInfo);
			    CreateContainerTFSNode(&spScopeNode,
								       &GUID_DhcpScopeNodeType,
								       pDhcpScope,
								       pDhcpScope,
								       m_spNodeMgr);

			    // Tell the handler to initialize any specific data
                pDhcpScope->InitializeNode(spScopeNode);

                AddToQueue(spScopeNode);
    		    pDhcpScope->Release();
            }

			continue;
		}
		else
		{
			//
			// Try to find if the superscope name already exists
			//
            pSuperscope = FindSuperscope(listSuperscopes, pSuperscopeTableEntry->SuperScopeName);
			if (pSuperscope == NULL)
			{
				//
				// Allocate a new superscope object and put it on our internal list
				// so that it we can check it later against other superscopes we may find
				//
				ITFSNode * pSuperscopeNode;
                pSuperscope = new CDhcpSuperscope(m_spTFSCompData, pSuperscopeTableEntry->SuperScopeName);
				CreateContainerTFSNode(&pSuperscopeNode,
									   &GUID_DhcpSuperscopeNodeType,
									   pSuperscope,
									   pSuperscope,
									   m_spNodeMgr);

    			// this gets done when the node is added to the UI on the main thread
                pSuperscope->InitializeNode(pSuperscopeNode);
    
                listSuperscopes.AddTail(pSuperscopeNode);
				pSuperscope->Release();
			}
			else
			{
				// Otherwise keep it
			}

            // now check to see if the scope is enabled.  If it is, then 
            // set the superscope state to enabled.
            // our definition of superscope enabled/disabled is if one scope is
            // enabled then the superscope is considered to be enabled.
            DWORD dwReturn = m_pSubnetInfoCache->GetInfo(m_strServer, pSuperscopeTableEntry->SubnetAddress, subnetInfo);

            if (dwReturn != ERROR_SUCCESS)
            {
                Trace2("Server %s - m_SubnetInfoCache.GetInfo returned %lx.\n", m_strServer, dwReturn);
            }

            if (subnetInfo.SubnetState == DhcpSubnetEnabled)
            {
                Assert(pSuperscope);
                pSuperscope->SetState(DhcpSubnetEnabled);
            }
		}

	} // for
	
	//
	// Now take all of the superscopes and put them on the queue to be added
	//
	if (listSuperscopes.GetCount() > 0)
	{
		POSITION pos = listSuperscopes.GetHeadPosition();
		SPITFSNode spNode;

		while (pos)
		{
			spNode = listSuperscopes.GetNext(pos);
			
            // we re-initialize the node so that the state will be updated correctly
            CDhcpSuperscope * pSuperscope = GETHANDLER(CDhcpSuperscope, spNode);
            
			pSuperscope->InitializeNode(spNode);
            
            AddToQueue(spNode);

			spNode.Release();
		}
	
		listSuperscopes.RemoveAll();
	}

	//
	// Free the memory
	//
	::DhcpRpcFreeMemory(pSuperscopeTable);
}

/*---------------------------------------------------------------------------
	CDhcpServerQueryObj::EnumSubnets()
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
void
CDhcpServerQueryObj::EnumSubnets()
{
	DWORD						dwError = ERROR_MORE_DATA;
	DWORD						dwElementsRead = 0, dwElementsTotal = 0;
	LPDHCP_IP_ARRAY				pdhcpIpArray = NULL;
    CSubnetInfo                 subnetInfo;

	//
	// for this server, enumerate all of it's subnets
	// 
	while (dwError == ERROR_MORE_DATA)
	{
		dwError = ::DhcpEnumSubnets(((LPWSTR) (LPCTSTR)m_strServer),
									&m_dhcpResumeHandle,
									m_dwPreferredMax, 
									&pdhcpIpArray,
									&dwElementsRead,
									&dwElementsTotal);

		if (dwElementsRead && dwElementsTotal && pdhcpIpArray)
		{
			//
			// loop through all of the subnets that were returned
			//
			for (DWORD i = 0; i < pdhcpIpArray->NumElements; i++)
			{
				DWORD	dwReturn;

                dwReturn = m_pSubnetInfoCache->GetInfo(m_strServer, pdhcpIpArray->Elements[i], subnetInfo);

				//
				// Create the new scope based on the info we querried
				//
				SPITFSNode spNode;
				CDhcpScope * pDhcpScope = new CDhcpScope(m_spTFSCompData, subnetInfo);
				CreateContainerTFSNode(&spNode,
									   &GUID_DhcpScopeNodeType,
									   pDhcpScope,
									   pDhcpScope,
									   m_spNodeMgr);

				// Tell the handler to initialize any specific data
                pDhcpScope->InitializeNode(spNode);
			
				AddToQueue(spNode);
				pDhcpScope->Release();
			}

			//
			// Free up the RPC memory
			//
			::DhcpRpcFreeMemory(pdhcpIpArray);

			dwElementsRead = 0;
			dwElementsTotal = 0;
			pdhcpIpArray = NULL;
		}
	}
}

/*---------------------------------------------------------------------------
	CDhcpServerQueryObj::FindSuperscope
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
CDhcpSuperscope * 
CDhcpServerQueryObj::FindSuperscope
(
	CNodeListBase  & listSuperscopes, 
	LPWSTR			 pSuperScopeName
)
{
	CString			strSuperscopeName = pSuperScopeName;
	POSITION		pos = listSuperscopes.GetHeadPosition();
	CDhcpSuperscope *pSuperscope = NULL;

	while (pos)
	{
		ITFSNode * pSuperscopeNode;
		
		pSuperscopeNode = listSuperscopes.GetNext(pos);
		
		CDhcpSuperscope * pCurrentSuperscope = GETHANDLER(CDhcpSuperscope, pSuperscopeNode);
		
		if (strSuperscopeName.Compare(pCurrentSuperscope->GetName()) == 0)
		{
			pSuperscope = pCurrentSuperscope;
			break;
		}
	}

	return pSuperscope;
}



/*---------------------------------------------------------------------------
	Class CDhcpGlobalOptions implementation
 ---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------
	CDhcpGlobalOptions::CDhcpGlobalOptions()
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
CDhcpGlobalOptions::CDhcpGlobalOptions
(
	ITFSComponentData * pComponentData
) : CMTDhcpHandler(pComponentData)
{
}

CDhcpGlobalOptions::~CDhcpGlobalOptions()
{
}

/*!--------------------------------------------------------------------------
	CDhcpGlobalOptions::InitializeNode
		Initializes node specific data
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CDhcpGlobalOptions::InitializeNode
(
	ITFSNode * pNode
)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
	
	CString strTemp;
	strTemp.LoadString(IDS_GLOBAL_OPTIONS_FOLDER);
	SetDisplayName(strTemp);

	// Make the node immediately visible
	pNode->SetVisibilityState(TFS_VIS_SHOW);
	pNode->SetData(TFS_DATA_COOKIE, (LPARAM) pNode);
	pNode->SetData(TFS_DATA_IMAGEINDEX, GetImageIndex(FALSE));
	pNode->SetData(TFS_DATA_OPENIMAGEINDEX, GetImageIndex(TRUE));
	pNode->SetData(TFS_DATA_USER, (LPARAM) this);
    pNode->SetData(TFS_DATA_TYPE, DHCPSNAP_GLOBAL_OPTIONS);
    pNode->SetData(TFS_DATA_SCOPE_LEAF_NODE, TRUE);

	SetColumnStringIDs(&aColumns[DHCPSNAP_GLOBAL_OPTIONS][0]);
	SetColumnWidths(&aColumnWidths[DHCPSNAP_GLOBAL_OPTIONS][0]);

	return hrOK;
}

/*---------------------------------------------------------------------------
	CDhcpGlobalOptions::OnCreateNodeId2
		Returns a unique string for this node
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT CDhcpGlobalOptions::OnCreateNodeId2(ITFSNode * pNode, CString & strId, DWORD * dwFlags)
{
    const GUID * pGuid = pNode->GetNodeType();
    
    CString strGuid;

    StringFromGUID2(*pGuid, strGuid.GetBuffer(256), 256);
    strGuid.ReleaseBuffer();

    strId = GetServerObject(pNode)->GetName() + strGuid;

    return hrOK;
}

/*---------------------------------------------------------------------------
	CDhcpGlobalOptions::GetImageIndex
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
int 
CDhcpGlobalOptions::GetImageIndex(BOOL bOpenImage) 
{
	int nIndex = -1;
	switch (m_nState)
	{
		case notLoaded:
		case loaded:
            if (bOpenImage)
    			nIndex = ICON_IDX_SERVER_OPTION_FOLDER_OPEN;
            else
    			nIndex = ICON_IDX_SERVER_OPTION_FOLDER_CLOSED;
			break;

        case loading:
            if (bOpenImage)
                nIndex = ICON_IDX_SERVER_OPTION_FOLDER_OPEN_BUSY;
            else
                nIndex = ICON_IDX_SERVER_OPTION_FOLDER_CLOSED_BUSY;
            break;

        case unableToLoad:
            if (bOpenImage)
			    nIndex = ICON_IDX_SERVER_OPTION_FOLDER_OPEN_LOST_CONNECTION;
            else
			    nIndex = ICON_IDX_SERVER_OPTION_FOLDER_CLOSED_LOST_CONNECTION;
			break;

		default:
			ASSERT(FALSE);
	}

	return nIndex;
}

/*---------------------------------------------------------------------------
	CDhcpGlobalOptions::OnAddMenuItems
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP 
CDhcpGlobalOptions::OnAddMenuItems
(
	ITFSNode *				pNode,
	LPCONTEXTMENUCALLBACK	pContextMenuCallback, 
	LPDATAOBJECT			lpDataObject, 
	DATA_OBJECT_TYPES		type, 
	DWORD					dwType,
	long *					pInsertionAllowed
)
{ 
	AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

	LONG	fFlags = 0, fLoadingFlags = 0;
	HRESULT hr = S_OK;
	CString strMenuItem;

	if ( m_nState != loaded )
	{
		fFlags |= MF_GRAYED;
	}

	if ( m_nState == loading)
	{
		fLoadingFlags = MF_GRAYED;
	}
	
	if (type == CCT_SCOPE)
	{
		// these menu items go in the new menu, 
		// only visible from scope pane
        if (*pInsertionAllowed & CCM_INSERTIONALLOWED_TOP)
        {
		    strMenuItem.LoadString(IDS_CREATE_OPTION_GLOBAL);
		    hr = LoadAndAddMenuItem( pContextMenuCallback, 
								     strMenuItem, 
								     IDS_CREATE_OPTION_GLOBAL,
								     CCM_INSERTIONPOINTID_PRIMARY_TOP, 
								     fFlags );
		    ASSERT( SUCCEEDED(hr) );
        }
	}

	return hr; 
}

/*---------------------------------------------------------------------------
	CDhcpGlobalOptions::OnCommand
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP 
CDhcpGlobalOptions::OnCommand
(
	ITFSNode *			pNode, 
	long				nCommandId, 
	DATA_OBJECT_TYPES	type, 
	LPDATAOBJECT		pDataObject, 
	DWORD				dwType
)
{
	HRESULT hr = S_OK;

	switch (nCommandId)
	{
		case IDS_CREATE_OPTION_GLOBAL:
			OnCreateNewOptions(pNode);
			break;
	
		case IDS_REFRESH:
			OnRefresh(pNode, pDataObject, dwType, 0, 0);
			break;

		default:
			break;
	}

	return hr;
}

/*!--------------------------------------------------------------------------
	CDhcpGlobalOptions::HasPropertyPages
		Implementation of ITFSNodeHandler::HasPropertyPages
	NOTE: the root node handler has to over-ride this function to 
	handle the snapin manager property page (wizard) case!!!
	
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP 
CDhcpGlobalOptions::HasPropertyPages
(
	ITFSNode *			pNode,
	LPDATAOBJECT		pDataObject, 
	DATA_OBJECT_TYPES   type, 
	DWORD               dwType
)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());
	
	HRESULT hr = hrOK;
	
	// we have property pages in the normal case, but don't put the
	// menu up if we are not loaded yet
	if ( m_nState != loaded )
	{
		hr = hrFalse;
	}
	else
	{
		hr = hrOK;
	}

    return hr;
}

/*---------------------------------------------------------------------------
	CDhcpGlobalOptions::CreatePropertyPages
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP 
CDhcpGlobalOptions::CreatePropertyPages
(
	ITFSNode *				pNode,
	LPPROPERTYSHEETCALLBACK lpProvider,
	LPDATAOBJECT			pDataObject, 
	LONG_PTR				handle, 
	DWORD					dwType
)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());

    DWORD		        dwError;
    DWORD		        dwDynDnsFlags;
    HRESULT             hr = hrOK;
	COptionsConfig *    pOptCfg;
	CString             strOptCfgTitle, strOptType;
	SPITFSNode          spServerNode;
	SPIComponentData    spComponentData;
    COptionValueEnum *  pOptionValueEnum;

    //
	// Create the property page
    //
    COM_PROTECT_TRY
    {
        m_spNodeMgr->GetComponentData(&spComponentData);

        BEGIN_WAIT_CURSOR;

        strOptType.LoadString(IDS_CONFIGURE_OPTIONS_GLOBAL);
		AfxFormatString1(strOptCfgTitle, IDS_CONFIGURE_OPTIONS_TITLE, strOptType);

		pNode->GetParent(&spServerNode);
        pOptionValueEnum = GetServerObject(pNode)->GetOptionValueEnum();

        pOptCfg = new COptionsConfig(pNode, 
		 						     spServerNode,
									 spComponentData, 
									 m_spTFSCompData,
									 pOptionValueEnum,
									 strOptCfgTitle);
      
        END_WAIT_CURSOR;
	    
        if ( pOptCfg == NULL )
        {
            hr = hrFalse;
            return hr;
        }

	    //
	    // Object gets deleted when the page is destroyed
        //
	    Assert(lpProvider != NULL);

        hr = pOptCfg->CreateModelessSheet(lpProvider, handle);
    }
    COM_PROTECT_CATCH

    return hr;
}

/*---------------------------------------------------------------------------
	CDhcpGlobalOptions::OnPropertyChange
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CDhcpGlobalOptions::OnPropertyChange
(	
	ITFSNode *		pNode, 
	LPDATAOBJECT	pDataobject, 
	DWORD			dwType, 
	LPARAM			arg, 
	LPARAM			lParam
)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

	COptionsConfig * pOptCfg = reinterpret_cast<COptionsConfig *>(lParam);

	LPARAM changeMask = 0;

	// tell the property page to do whatever now that we are back on the
	// main thread
	pOptCfg->OnPropertyChange(TRUE, &changeMask);

	pOptCfg->AcknowledgeNotify();

	if (changeMask)
		pNode->ChangeNode(changeMask);

	return hrOK;
}

/*---------------------------------------------------------------------------
	CDhcpGlobalOptions::OnPropertyChange
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CDhcpGlobalOptions::OnResultPropertyChange
(
	ITFSComponent * pComponent,
	LPDATAOBJECT	pDataObject,
	MMC_COOKIE		cookie,
	LPARAM			arg,
	LPARAM			param
)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

	SPITFSNode spNode;
	m_spNodeMgr->FindNode(cookie, &spNode);
	COptionsConfig * pOptCfg = reinterpret_cast<COptionsConfig *>(param);

	LPARAM changeMask = 0;

	// tell the property page to do whatever now that we are back on the
	// main thread
	pOptCfg->OnPropertyChange(TRUE, &changeMask);

	pOptCfg->AcknowledgeNotify();

	if (changeMask)
		spNode->ChangeNode(changeMask);

	return hrOK;
}

/*---------------------------------------------------------------------------
	CDhcpGlobalOptions::CompareItems
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP_(int)
CDhcpGlobalOptions::CompareItems
(
	ITFSComponent * pComponent, 
	MMC_COOKIE		cookieA, 
	MMC_COOKIE		cookieB, 
	int				nCol
) 
{ 
	SPITFSNode spNode1, spNode2;

	m_spNodeMgr->FindNode(cookieA, &spNode1);
	m_spNodeMgr->FindNode(cookieB, &spNode2);
	
	int nCompare = 0; 

	CDhcpOptionItem *pOpt1 = GETHANDLER(CDhcpOptionItem, spNode1);
	CDhcpOptionItem *pOpt2 = GETHANDLER(CDhcpOptionItem, spNode2);

	switch (nCol)
	{
		case 0:
		{
			//
            // Name compare - use the option #
			//
            LONG_PTR uImage1 = spNode1->GetData(TFS_DATA_IMAGEINDEX);
            LONG_PTR uImage2 = spNode2->GetData(TFS_DATA_IMAGEINDEX);

            nCompare = UtilGetOptionPriority((int) uImage1, (int) uImage2);
            if (nCompare == 0)
            {
                // compare the IDs
                DHCP_OPTION_ID	id1 = pOpt1->GetOptionId();
                DHCP_OPTION_ID	id2 = pOpt2->GetOptionId();
    			    
			    if (id1 < id2)
				    nCompare = -1;
			    else
			    if (id1 > id2)
				    nCompare =  1;
            }
		}
		break;

        case 1:
        {
            // compare the vendor strings
            CString str1, str2;
            str1 = pOpt1->GetVendorDisplay();
            str2 = pOpt2->GetVendorDisplay();

            nCompare = str1.CompareNoCase(str2);
        }
        break;

        case 3:
        {
            CString str1, str2;
            str1 = pOpt1->GetClassName();
            str2 = pOpt2->GetClassName();

            nCompare = str1.CompareNoCase(str2);
        }
        break;
	}

	return nCompare;
}

/*!--------------------------------------------------------------------------
	CDhcpGlobalOptions::OnResultSelect
		Update the verbs and the result pane message
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT CDhcpGlobalOptions::OnResultSelect(ITFSComponent *pComponent, LPDATAOBJECT pDataObject, MMC_COOKIE cookie, LPARAM arg, LPARAM lParam)
{
    HRESULT         hr = hrOK;
    SPITFSNode      spNode;

    CORg(CMTDhcpHandler::OnResultSelect(pComponent, pDataObject, cookie, arg, lParam));

    CORg (pComponent->GetSelectedNode(&spNode));

    if (spNode)
        UpdateResultMessage(spNode);

Error:
    return hr;
}

/*---------------------------------------------------------------------------
	CDhcpGlobalOptions::OnResultDelete
		This function is called when we are supposed to delete result
		pane items.  We build a list of selected items and then delete them.
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CDhcpGlobalOptions::OnResultDelete
(
	ITFSComponent * pComponent, 
	LPDATAOBJECT	pDataObject,
	MMC_COOKIE		cookie,
	LPARAM			arg, 
	LPARAM			param
)
{ 
	HRESULT hr = hrOK;

	AFX_MANAGE_STATE(AfxGetStaticModuleState());

	// translate the cookie into a node pointer
	SPITFSNode spGlobalOpt, spSelectedNode;
    m_spNodeMgr->FindNode(cookie, &spGlobalOpt);
    pComponent->GetSelectedNode(&spSelectedNode);

	Assert(spSelectedNode == spGlobalOpt);
	if (spSelectedNode != spGlobalOpt)
		return hr;

	// build the list of selected nodes
	CTFSNodeList listNodesToDelete;
	hr = BuildSelectedItemList(pComponent, &listNodesToDelete);

	//
	// Confirm with the user
	//
	CString strMessage, strTemp;
	int nNodes = (int) listNodesToDelete.GetCount();
	if (nNodes > 1)
	{
		strTemp.Format(_T("%d"), nNodes);
		AfxFormatString1(strMessage, IDS_DELETE_ITEMS, (LPCTSTR) strTemp);
	}
	else
	{
		strMessage.LoadString(IDS_DELETE_ITEM);
	}

	if (AfxMessageBox(strMessage, MB_YESNO) == IDNO)
	{
		return NOERROR;
	}

	CString strServer = GetServerObject(spGlobalOpt)->GetIpAddress();

	DHCP_OPTION_SCOPE_INFO	  dhcpOptionScopeInfo;
	dhcpOptionScopeInfo.ScopeType = DhcpGlobalOptions;
	dhcpOptionScopeInfo.ScopeInfo.GlobalScopeInfo = NULL;

	//
	// Loop through all items deleting
	//
	BEGIN_WAIT_CURSOR;

    while (listNodesToDelete.GetCount() > 0)
	{
		SPITFSNode spOptionNode;
		spOptionNode = listNodesToDelete.RemoveHead();
		
		CDhcpOptionItem * pOptItem = GETHANDLER(CDhcpOptionItem, spOptionNode);

		//
		// Try to remove it from the server
		//
	    DWORD dwError;
        
        if (pOptItem->IsVendorOption() ||
            pOptItem->IsClassOption())
        {
            LPCTSTR pClassName = pOptItem->GetClassName();
            if (lstrlen(pClassName) == 0)
                pClassName = NULL;

            dwError = ::DhcpRemoveOptionValueV5((LPTSTR) ((LPCTSTR) strServer),
                                                pOptItem->IsVendorOption() ? DHCP_FLAGS_OPTION_IS_VENDOR : 0,
                                                pOptItem->GetOptionId(),
                                                (LPTSTR) pClassName,
                                                (LPTSTR) pOptItem->GetVendor(),
                                                &dhcpOptionScopeInfo);
        }
        else
        {
            dwError = ::DhcpRemoveOptionValue(strServer, 
		 								      pOptItem->GetOptionId(), 
										      &dhcpOptionScopeInfo);
        }

		if (dwError != 0)
		{
			::DhcpMessageBox(dwError);
            RESTORE_WAIT_CURSOR;

			hr = E_FAIL;
			continue;
		}

        // 
        // remove from our internal list
        //
        GetServerObject(spGlobalOpt)->GetOptionValueEnum()->Remove(pOptItem->GetOptionId(), pOptItem->GetVendor(), pOptItem->GetClassName());    

        //
		// Remove from UI now
		//
		spGlobalOpt->RemoveChild(spOptionNode);
		spOptionNode.Release();
	}

	END_WAIT_CURSOR;

    UpdateResultMessage(spGlobalOpt);

    return hr;
}

/*!--------------------------------------------------------------------------
	CDhcpGlobalOptions::OnResultUpdateView
		Implementation of ITFSResultHandler::OnResultUpdateView
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT CDhcpGlobalOptions::OnResultUpdateView
(
    ITFSComponent *pComponent, 
    LPDATAOBJECT  pDataObject, 
    LPARAM        data, 
    LPARAM        hint
)
{
    HRESULT    hr = hrOK;
    SPITFSNode spSelectedNode;

    pComponent->GetSelectedNode(&spSelectedNode);
    if (spSelectedNode == NULL)
		return S_OK; // no selection for our IComponentData

    if ( hint == DHCPSNAP_UPDATE_OPTIONS )
    {
        SPINTERNAL spInternal = ExtractInternalFormat(pDataObject);
        ITFSNode * pNode = reinterpret_cast<ITFSNode *>(spInternal->m_cookie);
        SPITFSNode spSelectedNode;

        pComponent->GetSelectedNode(&spSelectedNode);

        EnumerateResultPane(pComponent, (MMC_COOKIE) spSelectedNode.p, 0, 0);
    }
    else
    {
        // we don't handle this message, let the base class do it.
        return CMTDhcpHandler::OnResultUpdateView(pComponent, pDataObject, data, hint);
    }

	return hr;
}

/*!--------------------------------------------------------------------------
	CDhcpGlobalOptions::EnumerateResultPane
		We override this function for the options nodes for one reason.
        Whenever an option class is deleted, then all options defined for
        that class will be removed as well.  Since there are multiple places
        that these options may show up, it's easier to just not show any
        options that don't have a class defined for it.  
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CDhcpGlobalOptions::EnumerateResultPane
(
    ITFSComponent * pComponent, 
    MMC_COOKIE      cookie, 
    LPARAM          arg, 
    LPARAM          lParam
)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());

    HRESULT             hr = hrOK;
    COptionValueEnum *  pEnum;
    CClassInfoArray     ClassInfoArray;
	SPITFSNode          spContainer;
    int                 nImage = ICON_IDX_SERVER_OPTION_LEAF;

    m_spNodeMgr->FindNode(cookie, &spContainer);

	GetServerObject(spContainer)->GetClassInfoArray(ClassInfoArray);
    pEnum = GetServerObject(spContainer)->GetOptionValueEnum();
    pEnum->Reset();

    return OnResultUpdateOptions(pComponent, spContainer, &ClassInfoArray, &pEnum, &nImage, 1);
}

/*!--------------------------------------------------------------------------
	CDhcpGlobalOptions::OnGetResultViewType
        MMC calls this to get the result view information		
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CDhcpGlobalOptions::OnGetResultViewType
(
    ITFSComponent * pComponent, 
    MMC_COOKIE      cookie, 
    LPOLESTR *      ppViewType,
    long *          pViewOptions
)
{
    HRESULT hr = hrOK;

    // call the base class to see if it is handling this
    if (CMTDhcpHandler::OnGetResultViewType(pComponent, cookie, ppViewType, pViewOptions) != S_OK)
    {
        *pViewOptions = MMC_VIEW_OPTIONS_MULTISELECT;
		
		hr = S_FALSE;
	}

    return hr;
}

/*!--------------------------------------------------------------------------
	CDhcpGlobalOptions::UpdateResultMessage
        Figures out what message to put in the result pane, if any
	Author: EricDav
 ---------------------------------------------------------------------------*/
void CDhcpGlobalOptions::UpdateResultMessage(ITFSNode * pNode)
{
    HRESULT hr = hrOK;
    int nMessage = -1;   // default
    int nVisible, nTotal;
    int i;

    CString strTitle, strBody, strTemp;

    if (!m_dwErr)
    {
		pNode->GetChildCount(&nVisible, &nTotal);

        // determine what message to display
        if ( (m_nState == notLoaded) || 
             (m_nState == loading) )
        {
            nMessage = -1;
        }
        else
        if (nTotal == 0)
        {
            nMessage = SERVER_OPTIONS_MESSAGE_NO_OPTIONS;
        }

        // build the strings
        if (nMessage != -1)
        {
            // now build the text strings
            // first entry is the title
            strTitle.LoadString(g_uServerOptionsMessages[nMessage][0]);

            // second entry is the icon
            // third ... n entries are the body strings

            for (i = 2; g_uServerOptionsMessages[nMessage][i] != 0; i++)
            {
                strTemp.LoadString(g_uServerOptionsMessages[nMessage][i]);
                strBody += strTemp;
            }
        }
    }

    // show the message
    if (nMessage == -1)
    {
        ClearMessage(pNode);
    }
    else
    {
        ShowMessage(pNode, strTitle, strBody, (IconIdentifier) g_uServerOptionsMessages[nMessage][1]);
    }
}

/*!--------------------------------------------------------------------------
	CDhcpGlobalOptions::OnHaveData
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
void 
CDhcpGlobalOptions::OnHaveData
(
	ITFSNode * pParentNode, 
	LPARAM	   Data,
	LPARAM	   Type
)
{
	// This is how we get non-node data back from the background thread.
    switch (Type)
    {
        case DHCP_QDATA_OPTION_VALUES:
        {
            HRESULT             hr = hrOK;
	        SPIComponentData	spCompData;
	        SPIConsole			spConsole;
            SPIDataObject       spDataObject;
            IDataObject *       pDataObject;
            CDhcpServer *       pServer = GetServerObject(pParentNode);
            COptionValueEnum *  pOptionValueEnum = reinterpret_cast<COptionValueEnum *>(Data);

            pServer->SetOptionValueEnum(pOptionValueEnum);
            
            pOptionValueEnum->RemoveAll();
            delete pOptionValueEnum;

            // now tell the view to update themselves
	        m_spNodeMgr->GetComponentData(&spCompData);

	        CORg ( spCompData->QueryDataObject((MMC_COOKIE) pParentNode, CCT_SCOPE, &pDataObject) );
            spDataObject = pDataObject;

            CORg ( m_spNodeMgr->GetConsole(&spConsole) );
	        CORg ( spConsole->UpdateAllViews(pDataObject, (LPARAM) pParentNode, DHCPSNAP_UPDATE_OPTIONS) ); 

            break;
        }
    }

Error:
    return;
}

/*---------------------------------------------------------------------------
	CDhcpGlobalOptions::OnCreateQuery()
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
ITFSQueryObject* 
CDhcpGlobalOptions::OnCreateQuery(ITFSNode * pNode)
{
    HRESULT hr = hrOK;
    CDhcpGlobalOptionsQueryObj* pQuery = NULL;

    COM_PROTECT_TRY
    {
        pQuery = new CDhcpGlobalOptionsQueryObj(m_spTFSCompData, m_spNodeMgr);
	    
	    pQuery->m_strServer = GetServerObject(pNode)->GetIpAddress();
        pQuery->m_dwPreferredMax = 0xFFFFFFFF;
	    pQuery->m_dhcpResumeHandle = NULL;
	    
        GetServerObject(pNode)->GetVersion(pQuery->m_liDhcpVersion);
    }
    COM_PROTECT_CATCH

    return pQuery;
}

/*---------------------------------------------------------------------------
	CDhcpGlobalOptionsQueryObj::Execute()
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP
CDhcpGlobalOptionsQueryObj::Execute()
{
    DWORD                   dwErr;
    COptionValueEnum *      pOptionValueEnum = NULL;
    DHCP_OPTION_SCOPE_INFO	dhcpOptionScopeInfo;

    pOptionValueEnum = new COptionValueEnum();
	
    dhcpOptionScopeInfo.ScopeType = DhcpGlobalOptions;
	dhcpOptionScopeInfo.ScopeInfo.GlobalScopeInfo = NULL;

    pOptionValueEnum->Init(m_strServer, m_liDhcpVersion, dhcpOptionScopeInfo);
    dwErr = pOptionValueEnum->Enum();

    if (dwErr != ERROR_SUCCESS)
    {
        Trace1("CDhcpGlobalOptionsQueryObj::Execute - Enum Failed! %d\n", dwErr);
        m_dwErr = dwErr;
        PostError(dwErr);

        delete pOptionValueEnum;
    }
    else
    {
        pOptionValueEnum->SortById();
        AddToQueue((LPARAM) pOptionValueEnum, DHCP_QDATA_OPTION_VALUES);
    }

    return hrFalse;
}

/*!--------------------------------------------------------------------------
	CDhcpGlobalOptions::OnNotifyExiting
		CMTDhcpHandler overridden functionality
		allows us to know when the background thread is done
	Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP 
CDhcpGlobalOptions::OnNotifyExiting
(
	LPARAM			lParam
)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

	SPITFSNode spNode;
	spNode.Set(m_spNode); // save this off because OnNotifyExiting will release it

	HRESULT hr = CMTDhcpHandler::OnNotifyExiting(lParam);

    UpdateResultMessage(spNode);

	return hr;
}

/*---------------------------------------------------------------------------
	Command handlers
 ---------------------------------------------------------------------------*/

 /*---------------------------------------------------------------------------
	CDhcpGlobalOptionsQueryObj::OnCreateNewOptions()
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CDhcpGlobalOptions::OnCreateNewOptions
(
	ITFSNode * pNode
)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

	HRESULT hr = hrOK;
    COptionsConfig * pOptCfg = NULL;

    COM_PROTECT_TRY
    {
        if (HasPropSheetsOpen())
	    {
		    CPropertyPageHolderBase * pPropSheet;
		    GetOpenPropSheet(0, &pPropSheet);

		    pPropSheet->SetActiveWindow();
	    }
	    else
	    {
	        CString             strOptCfgTitle, strOptType;
	        SPIComponentData    spComponentData;

            strOptType.LoadString(IDS_CONFIGURE_OPTIONS_GLOBAL);
	        AfxFormatString1(strOptCfgTitle, IDS_CONFIGURE_OPTIONS_TITLE, strOptType);

            m_spNodeMgr->GetComponentData(&spComponentData);

            hr = DoPropertiesOurselvesSinceMMCSucks(pNode, spComponentData, strOptCfgTitle);
	    }
    }
    COM_PROTECT_CATCH

	return hr;
}

/*---------------------------------------------------------------------------
	Class CDhcpBootp implementation
 ---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------
	Function Name Here
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
CDhcpBootp::CDhcpBootp
(
	ITFSComponentData* pTFSComponentData
) : CMTDhcpHandler(pTFSComponentData)
{
}

CDhcpBootp::~CDhcpBootp()
{
}

/*!--------------------------------------------------------------------------
	CDhcpBootp::InitializeNode
		Initializes node specific data
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CDhcpBootp::InitializeNode
(
	ITFSNode * pNode
)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
	
	CString strDisplayName;

	strDisplayName.LoadString(IDS_BOOTP_TABLE_FOLDER);
	SetDisplayName(strDisplayName);

	// Make the node immediately visible
	pNode->SetVisibilityState(TFS_VIS_SHOW);
	pNode->SetData(TFS_DATA_COOKIE, (LPARAM) pNode);
	pNode->SetData(TFS_DATA_IMAGEINDEX, GetImageIndex(FALSE));
	pNode->SetData(TFS_DATA_OPENIMAGEINDEX, GetImageIndex(TRUE));
	pNode->SetData(TFS_DATA_USER, (LPARAM) this);
    pNode->SetData(TFS_DATA_TYPE, DHCPSNAP_BOOTP_TABLE);
    pNode->SetData(TFS_DATA_SCOPE_LEAF_NODE, TRUE);

	SetColumnStringIDs(&aColumns[DHCPSNAP_BOOTP_TABLE][0]);
	SetColumnWidths(&aColumnWidths[DHCPSNAP_BOOTP_TABLE][0]);

	return hrOK;
}

/*---------------------------------------------------------------------------
	CDhcpBootp::OnCreateNodeId2
		Returns a unique string for this node
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT CDhcpBootp::OnCreateNodeId2(ITFSNode * pNode, CString & strId, DWORD * dwFlags)
{
    const GUID * pGuid = pNode->GetNodeType();
    
    CString strGuid;

    StringFromGUID2(*pGuid, strGuid.GetBuffer(256), 256);
    strGuid.ReleaseBuffer();

    strId = GetServerObject(pNode)->GetName() + strGuid;

    return hrOK;
}

/*---------------------------------------------------------------------------
	CDhcpBootp::GetImageIndex
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
int 
CDhcpBootp::GetImageIndex(BOOL bOpenImage) 
{
	int nIndex = -1;
	switch (m_nState)
	{
		case notLoaded:
		case loaded:
            if (bOpenImage)
    			nIndex = ICON_IDX_BOOTP_TABLE_OPEN;
            else
    			nIndex = ICON_IDX_BOOTP_TABLE_CLOSED;
			break;

        case loading:
            if (bOpenImage)
                nIndex = ICON_IDX_BOOTP_TABLE_OPEN_BUSY;
            else
                nIndex = ICON_IDX_BOOTP_TABLE_CLOSED_BUSY;
            break;

        case unableToLoad:
            if (bOpenImage)
			    nIndex = ICON_IDX_BOOTP_TABLE_OPEN_LOST_CONNECTION;
            else
			    nIndex = ICON_IDX_BOOTP_TABLE_CLOSED_LOST_CONNECTION;
			break;
    
    	default:
			ASSERT(FALSE);
	}

	return nIndex;
}

/*---------------------------------------------------------------------------
	Overridden base handler functions
 ---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------
	CDhcpBootp::OnAddMenuItems
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP 
CDhcpBootp::OnAddMenuItems
(
	ITFSNode *				pNode,
	LPCONTEXTMENUCALLBACK	pContextMenuCallback, 
	LPDATAOBJECT			lpDataObject, 
	DATA_OBJECT_TYPES		type, 
	DWORD					dwType,
	long *					pInsertionAllowed
)
{ 
	AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

	LONG	fFlags = 0, fLoadingFlags = 0;
	HRESULT hr = S_OK;
	CString strMenuItem;

	if ( m_nState != loaded )
	{
		fFlags |= MF_GRAYED;
	}

	if ( m_nState == loading)
	{
		fLoadingFlags = MF_GRAYED;
	}

	if (type == CCT_SCOPE)
	{
		// these menu items go in the new menu, 
		// only visible from scope pane
        if (*pInsertionAllowed & CCM_INSERTIONALLOWED_TOP)
        {
		    strMenuItem.LoadString(IDS_CREATE_NEW_BOOT_IMAGE);
		    hr = LoadAndAddMenuItem( pContextMenuCallback, 
								     strMenuItem, 
								     IDS_CREATE_NEW_BOOT_IMAGE,
								     CCM_INSERTIONPOINTID_PRIMARY_TOP, 
								     fFlags );
		    ASSERT( SUCCEEDED(hr) );
        }
	}

	return hr; 
}

/*---------------------------------------------------------------------------
	CDhcpBootp::OnCommand
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP 
CDhcpBootp::OnCommand
(
	ITFSNode *			pNode, 
	long				nCommandId, 
	DATA_OBJECT_TYPES	type, 
	LPDATAOBJECT		pDataObject, 
	DWORD				dwType
)
{
	HRESULT hr = S_OK;

	switch (nCommandId)
	{
		case IDS_CREATE_NEW_BOOT_IMAGE:
			OnCreateNewBootpEntry(pNode);
			break;

		case IDS_REFRESH:
			OnRefresh(pNode, pDataObject, dwType, 0, 0);
			break;

		default:
			break;
	}

	return hr;
}

/*---------------------------------------------------------------------------
	CDhcpBootp::CompareItems
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP_(int)
CDhcpBootp::CompareItems
(
	ITFSComponent * pComponent, 
	MMC_COOKIE		cookieA, 
	MMC_COOKIE		cookieB, 
	int				nCol
) 
{ 
	SPITFSNode spNode1, spNode2;

	m_spNodeMgr->FindNode(cookieA, &spNode1);
	m_spNodeMgr->FindNode(cookieB, &spNode2);
	
	int nCompare = 0; 

	CDhcpBootpEntry *pDhcpBootp1 = GETHANDLER(CDhcpBootpEntry, spNode1);
	CDhcpBootpEntry *pDhcpBootp2 = GETHANDLER(CDhcpBootpEntry, spNode2);

	CString strNode1;
	CString strNode2;

	switch (nCol)
	{
		case 0:
		{
			// Boot Image compare
			strNode1 = pDhcpBootp1->QueryBootImage();
			strNode2 = pDhcpBootp2->QueryBootImage();
		}
			break;

		case 1:
		{
			// File Name compare
			strNode1 = pDhcpBootp1->QueryFileName();
			strNode2 = pDhcpBootp2->QueryFileName();
		}
			break;
		
		case 2:
		{
			// FileServer compare
			strNode1 = pDhcpBootp1->QueryFileServer();
			strNode2 = pDhcpBootp2->QueryFileServer();
		}
			break;
	}

	nCompare = strNode1.CompareNoCase(strNode2);

	return nCompare;
}

/*---------------------------------------------------------------------------
	CDhcpBootp::OnResultDelete
		This function is called when we are supposed to delete result
		pane items.  We build a list of selected items and then delete them.
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CDhcpBootp::OnResultDelete
(
	ITFSComponent * pComponent, 
	LPDATAOBJECT	pDataObject,
	MMC_COOKIE  	cookie,
	LPARAM			arg, 
	LPARAM			param
)
{ 
	HRESULT hr = hrOK;

	AFX_MANAGE_STATE(AfxGetStaticModuleState());

	// translate the cookie into a node pointer
	SPITFSNode spBootp, spSelectedNode;
    
    m_spNodeMgr->FindNode(cookie, &spBootp);
    pComponent->GetSelectedNode(&spSelectedNode);

	Assert(spSelectedNode == spBootp);
	if (spSelectedNode != spBootp)
		return hr;

	// build the list of selected nodes
	CTFSNodeList listNodesToDelete;
	hr = BuildSelectedItemList(pComponent, &listNodesToDelete);

	//
	// Confirm with the user
	//
	CString strMessage, strTemp;
	int nNodes = (int) listNodesToDelete.GetCount();
	if (nNodes > 1)
	{
		strTemp.Format(_T("%d"), nNodes);
		AfxFormatString1(strMessage, IDS_DELETE_ITEMS, (LPCTSTR) strTemp);
	}
	else
	{
		strMessage.LoadString(IDS_DELETE_ITEM);
	}

	if (AfxMessageBox(strMessage, MB_YESNO) == IDNO)
	{
		return NOERROR;
	}

    BEGIN_WAIT_CURSOR;

    CString strServer = GetServerObject(spBootp)->GetIpAddress();

	// Grab the current list of bootp entries from the server
	DWORD dwError = 0;
	LPDHCP_SERVER_CONFIG_INFO_V4 pServerConfig = NULL;

	dwError = ::DhcpServerGetConfigV4(strServer, &pServerConfig);

	if (dwError != ERROR_SUCCESS)
	{
		::DhcpMessageBox(dwError);
		return dwError;
	}

	if (pServerConfig->cbBootTableString == 0)
	{
		::DhcpRpcFreeMemory(pServerConfig);	
		return hrOK;
	}

	// allocate enough space to hold the new list.  It should be the same
	// size if not smaller
	WCHAR * pNewBootpList = (WCHAR *) alloca(pServerConfig->cbBootTableString);
	WCHAR * pNewBootpListEntry = pNewBootpList;

	ZeroMemory(pNewBootpList, pServerConfig->cbBootTableString);

	// walk the list and copy non-deleted entries to our new list
	BOOL bDelete = FALSE;
	int nItemsRemoved = 0, nNewBootpListLength = 0;
	CDhcpBootpEntry tempBootpEntry(m_spTFSCompData);
	CONST WCHAR * pszwBootpList = pServerConfig->wszBootTableString;
	DWORD dwLength = pServerConfig->cbBootTableString;

	while (*pszwBootpList != '\0')
	{
		bDelete = FALSE;
		WCHAR * pCurEntry = (WCHAR *) pszwBootpList;
		
		// initialize the temp item with data.  We just do this so we can 
		// compare the nodes that were selected for deletion easily
		pszwBootpList = tempBootpEntry.InitData(IN pszwBootpList, dwLength);
        dwLength = pServerConfig->cbBootTableString -
                        (DWORD) ((LPBYTE) pszwBootpList - (LPBYTE) pServerConfig->wszBootTableString);
        
		// Loop through the list of selected bootp entries
		POSITION pos = listNodesToDelete.GetHeadPosition();
		while (pos)
		{
			// the get next call does not addref the pointer, 
			// so don't use a smart pointer.
			ITFSNode * pBootpEntryNode;
			pBootpEntryNode = listNodesToDelete.GetNext(pos);
			
			CDhcpBootpEntry * pSelectedBootpEntry = GETHANDLER(CDhcpBootpEntry, pBootpEntryNode);
			
			if (tempBootpEntry == *pSelectedBootpEntry)
			{
				// don't copy this to our new list, it's being deleted
				// remove from the list
				listNodesToDelete.RemoveNode(pBootpEntryNode);

				// Remove from UI
				spBootp->RemoveChild(pBootpEntryNode);
				pBootpEntryNode->Release();

				bDelete = TRUE;
				nItemsRemoved++;
				break;
			}
		}
	
		if (!bDelete)
		{
			// copy 
			CopyMemory(pNewBootpListEntry, pCurEntry, wcslen(pCurEntry) * sizeof(WCHAR));
			pNewBootpListEntry += wcslen(pCurEntry) + 1; // 1 for null terminator
		}

	} // while
	pNewBootpListEntry++; // increment 1 spot for the entire list terminator

	// calc size of list in bytes
	nNewBootpListLength = (int) (pNewBootpListEntry - pNewBootpList) * sizeof(WCHAR);

	// if we've removed something from the list, then write the new list to the server
	if (nItemsRemoved)
	{
		DHCP_SERVER_CONFIG_INFO_V4 dhcpServerInfo;

		::ZeroMemory(&dhcpServerInfo, sizeof(dhcpServerInfo));

		dhcpServerInfo.cbBootTableString = nNewBootpListLength;
		dhcpServerInfo.wszBootTableString = pNewBootpList;

		dwError = ::DhcpServerSetConfigV4(strServer,
										  Set_BootFileTable,
										  &dhcpServerInfo);

		if (dwError != ERROR_SUCCESS)
		{
			::DhcpMessageBox(dwError);
		}
	}

    if (pServerConfig)
		::DhcpRpcFreeMemory(pServerConfig);

	Assert (listNodesToDelete.GetCount() == 0);

	END_WAIT_CURSOR;

    return hr;
}

/*!--------------------------------------------------------------------------
	CDhcpBootp::OnGetResultViewType
        MMC calls this to get the result view information		
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CDhcpBootp::OnGetResultViewType
(
    ITFSComponent * pComponent, 
    MMC_COOKIE      cookie, 
    LPOLESTR *      ppViewType,
    long *          pViewOptions
)
{
    *pViewOptions = MMC_VIEW_OPTIONS_MULTISELECT;

    // we still want the default MMC result pane view, we just want
    // multiselect, so return S_FALSE

    return S_FALSE;
}

/*---------------------------------------------------------------------------
	Command Handlers
 ---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------
	CDhcpBootp::OnCreateNewBootpEntry
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
DWORD
CDhcpBootp::OnCreateNewBootpEntry
(
	ITFSNode * pNode
)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
 
	CString strServerAddress = GetServerObject(pNode)->GetIpAddress();

	CAddBootpEntry dlgAddBootpEntry(pNode, strServerAddress);

	dlgAddBootpEntry.DoModal();

	return 0;
}

/*---------------------------------------------------------------------------
	Background thread functionality
 ---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------
	CDhcpBootp::OnCreateQuery()
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
ITFSQueryObject* 
CDhcpBootp::OnCreateQuery(ITFSNode * pNode)
{
    HRESULT hr = hrOK;
    CDhcpBootpQueryObj* pQuery = NULL;

    COM_PROTECT_TRY
    {
        pQuery = new CDhcpBootpQueryObj(m_spTFSCompData, m_spNodeMgr);
	
	    pQuery->m_strServer = GetServerObject(pNode)->GetIpAddress();
    }
    COM_PROTECT_CATCH
	
	return pQuery;
}

/*---------------------------------------------------------------------------
	CDhcpBootpQueryObj::Execute()
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP
CDhcpBootpQueryObj::Execute()
{
    HRESULT hr = hrOK;
    DWORD							dwError = 0;
	LPDHCP_SERVER_CONFIG_INFO_V4	pDhcpConfigInfo = NULL;
    CONST WCHAR *                   pszwBootpList = NULL;
	SPITFSNode                      spNode;
    CDhcpBootpEntry *               pBootpEntryNew = NULL;
    DWORD                           dwLength = 0;

	dwError = ::DhcpServerGetConfigV4((LPWSTR) ((LPCTSTR)m_strServer),
	 							      &pDhcpConfigInfo);

	Trace2("Server %s - DhcpServerGetConfigV4 returned %lx.\n", m_strServer, dwError);

	if (pDhcpConfigInfo)
	{
        COM_PROTECT_TRY
        {
            pszwBootpList = pDhcpConfigInfo->wszBootTableString;
            dwLength = pDhcpConfigInfo->cbBootTableString;

		    if (pszwBootpList == NULL || pDhcpConfigInfo->cbBootTableString == 0)
		    {
			    // Empty list -> nothing to do
			    return hrFalse;
		    }
	    
            // Parse the BOOTP list of format "%s,%s,%s","%s,%s,%s",...
		    while (*pszwBootpList != '\0')
		    {
			    pBootpEntryNew = new CDhcpBootpEntry(m_spTFSCompData);
			    CreateLeafTFSNode(&spNode,
							      &GUID_DhcpBootpEntryNodeType,
							      pBootpEntryNew,
							      pBootpEntryNew,
							      m_spNodeMgr);

			    // Tell the handler to initialize any specific data
			    pBootpEntryNew->InitializeNode(spNode);
			    pszwBootpList = pBootpEntryNew->InitData(IN pszwBootpList, dwLength);
                dwLength = pDhcpConfigInfo->cbBootTableString - 
                            (DWORD) ((LPBYTE) pszwBootpList - (LPBYTE) pDhcpConfigInfo->wszBootTableString);

			    // now add it to the queue to be posted back to the main thread
			    AddToQueue(spNode);
			    
                pBootpEntryNew->Release();
                spNode.Set(NULL);

		    } // while
        }
        COM_PROTECT_CATCH
		
		::DhcpRpcFreeMemory(pDhcpConfigInfo);
	}

	if (dwError != ERROR_NO_MORE_ITEMS && 
        dwError != ERROR_SUCCESS)
	{
		m_dwErr = dwError;
		PostError(dwError);
	}

    return hrFalse;
}

/*---------------------------------------------------------------------------
	Class CDhcpSuperscope implementation
 ---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------
	Function Name Here
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
CDhcpSuperscope::CDhcpSuperscope
(
	ITFSComponentData * pComponentData,
	LPCWSTR pSuperscopeName
) : CMTDhcpHandler(pComponentData)
{
	m_strName = pSuperscopeName;
    m_SuperscopeState = DhcpSubnetDisabled;
}

CDhcpSuperscope::~CDhcpSuperscope()
{
}

/*!--------------------------------------------------------------------------
	CDhcpSuperscope::InitializeNode
		Initializes node specific data
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CDhcpSuperscope::InitializeNode
(
	ITFSNode * pNode
)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
	
	int     nIndex;
    CString strDisplayName;

	BuildDisplayName(&strDisplayName, m_strName);
	SetDisplayName(strDisplayName);

	// Make the node immediately visible
	pNode->SetVisibilityState(TFS_VIS_SHOW);
	pNode->SetData(TFS_DATA_COOKIE, (LPARAM) pNode);

    pNode->SetData(TFS_DATA_IMAGEINDEX, GetImageIndex(FALSE));
	pNode->SetData(TFS_DATA_OPENIMAGEINDEX, GetImageIndex(TRUE));

    pNode->SetData(TFS_DATA_USER, (LPARAM) this);
    pNode->SetData(TFS_DATA_TYPE, DHCPSNAP_SUPERSCOPE);

	SetColumnStringIDs(&aColumns[DHCPSNAP_SUPERSCOPE][0]);
	SetColumnWidths(&aColumnWidths[DHCPSNAP_SUPERSCOPE][0]);

	return hrOK;
}

/*---------------------------------------------------------------------------
	CDhcpSuperscope::DestroyHandler
		We need to free up any resources we are holding
	Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP 
CDhcpSuperscope::DestroyHandler(ITFSNode *pNode)
{
	// cleanup the stats dialog
    WaitForStatisticsWindow(&m_dlgStats);

    return CMTDhcpHandler::DestroyHandler(pNode);
}

/*---------------------------------------------------------------------------
	CDhcpSuperscope::OnCreateNodeId2
		Returns a unique string for this node
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT CDhcpSuperscope::OnCreateNodeId2(ITFSNode * pNode, CString & strId, DWORD * dwFlags)
{
    const GUID * pGuid = pNode->GetNodeType();

    CString strGuid;

    StringFromGUID2(*pGuid, strGuid.GetBuffer(256), 256);
    strGuid.ReleaseBuffer();

    strId = GetServerObject()->GetName() + m_strName + strGuid;

    return hrOK;
}

/*---------------------------------------------------------------------------
	CDhcpSuperscope::GetImageIndex
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
int 
CDhcpSuperscope::GetImageIndex(BOOL bOpenImage) 
{
	int nIndex = -1;
	switch (m_nState)
	{
		case notLoaded:
		case loaded:
            if (bOpenImage)
	            nIndex = (m_SuperscopeState == DhcpSubnetEnabled) ?
			            ICON_IDX_SCOPE_FOLDER_OPEN : ICON_IDX_SCOPE_INACTIVE_FOLDER_OPEN;
            else
	            nIndex = (m_SuperscopeState == DhcpSubnetEnabled) ?
			            ICON_IDX_SCOPE_FOLDER_CLOSED : ICON_IDX_SCOPE_INACTIVE_FOLDER_CLOSED;
			break;

        case loading:
            if (bOpenImage)
                nIndex = ICON_IDX_SCOPE_FOLDER_OPEN_BUSY;
            else
                nIndex = ICON_IDX_SCOPE_FOLDER_CLOSED_BUSY;
            break;

        case unableToLoad:
            if (bOpenImage)
	            nIndex = (m_SuperscopeState == DhcpSubnetEnabled) ?
			            ICON_IDX_SCOPE_FOLDER_OPEN_LOST_CONNECTION : ICON_IDX_SCOPE_INACTIVE_FOLDER_OPEN_LOST_CONNECTION;
            else
	            nIndex = (m_SuperscopeState == DhcpSubnetEnabled) ?
			            ICON_IDX_SCOPE_FOLDER_CLOSED_LOST_CONNECTION : ICON_IDX_SCOPE_INACTIVE_FOLDER_CLOSED_LOST_CONNECTION;
			break;

		default:
			ASSERT(FALSE);
	}

	return nIndex;
}

/*---------------------------------------------------------------------------
	CDhcpSuperscope::OnHaveData
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
void 
CDhcpSuperscope::OnHaveData
(
	ITFSNode * pParentNode, 
	ITFSNode * pNewNode
)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

    if (pNewNode->IsContainer())
	{
		// assume all the child containers are derived from this class
		//((CDHCPMTContainer*)pNode)->SetServer(GetServer());
	}
	
	if (pNewNode->GetData(TFS_DATA_TYPE) == DHCPSNAP_SCOPE)
	{
		CDhcpScope * pScope = GETHANDLER(CDhcpScope, pNewNode);
		pScope->SetServer(m_spServerNode);
        pScope->InitializeNode(pNewNode);

        if (pScope->IsEnabled())
        {
            m_SuperscopeState = DhcpSubnetEnabled;
            m_strState.LoadString(IDS_SCOPE_ACTIVE);
        }

        AddScopeSorted(pParentNode, pNewNode);
	}
	
    // now tell the view to update themselves
    ExpandNode(pParentNode, TRUE);
}

/*---------------------------------------------------------------------------
	CDhcpSuperscope::AddScopeSorted
		Adds a scope node to the UI sorted
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CDhcpSuperscope::AddScopeSorted
(
    ITFSNode * pSuperscopeNode,
    ITFSNode * pScopeNode
)
{
    HRESULT         hr = hrOK;
    SPITFSNodeEnum  spNodeEnum;
	SPITFSNode      spCurrentNode;
	SPITFSNode      spPrevNode;
	ULONG           nNumReturned = 0;
	DHCP_IP_ADDRESS dhcpIpAddressCurrent = 0;
	DHCP_IP_ADDRESS dhcpIpAddressTarget;

    CDhcpScope *   pScope;

    // get our target address
	pScope = GETHANDLER(CDhcpScope, pScopeNode);
	dhcpIpAddressTarget = pScope->GetAddress();

    // get the enumerator for this node
	CORg(pSuperscopeNode->GetEnum(&spNodeEnum));

	CORg(spNodeEnum->Next(1, &spCurrentNode, &nNumReturned));
	while (nNumReturned)
	{
        pScope = GETHANDLER(CDhcpScope, spCurrentNode);
		dhcpIpAddressCurrent = pScope->GetAddress();

		if (dhcpIpAddressCurrent > dhcpIpAddressTarget)
		{
            // Found where we need to put it, break out
            break;
		}

		// get the next node in the list
		spPrevNode.Set(spCurrentNode);

        spCurrentNode.Release();
		spNodeEnum->Next(1, &spCurrentNode, &nNumReturned);
	}

    // Add the node in based on the PrevNode pointer
    if (spPrevNode)
    {
        if (m_bExpanded)
        {
            pScopeNode->SetData(TFS_DATA_RELATIVE_FLAGS, SDI_PREVIOUS);
            pScopeNode->SetData(TFS_DATA_RELATIVE_SCOPEID, spPrevNode->GetData(TFS_DATA_SCOPEID));
        }
        
        CORg(pSuperscopeNode->InsertChild(spPrevNode, pScopeNode));
    }
    else
    {   
        // add to the head
        if (m_bExpanded)
        {
            pScopeNode->SetData(TFS_DATA_RELATIVE_FLAGS, SDI_FIRST);
        }

        CORg(pSuperscopeNode->AddChild(pScopeNode));
    }

Error:
    return hr;
}

/*---------------------------------------------------------------------------
	Overridden base handler functions
 ---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------
	CDhcpSuperscope::OnAddMenuItems
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP 
CDhcpSuperscope::OnAddMenuItems
(
	ITFSNode *				pNode,
	LPCONTEXTMENUCALLBACK	pContextMenuCallback, 
	LPDATAOBJECT			lpDataObject, 
	DATA_OBJECT_TYPES		type, 
	DWORD					dwType,
	long *					pInsertionAllowed
)
{ 
	AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

	LONG	fFlags = 0, fLoadingFlags = 0;
	HRESULT hr = S_OK;
	CString strMenuItem;

	if ( m_nState != loaded )
	{
		fFlags |= MF_GRAYED;
	}

	if ( m_nState == loading)
	{
		fLoadingFlags = MF_GRAYED;
	}

	if (type == CCT_SCOPE)
	{
        if (*pInsertionAllowed & CCM_INSERTIONALLOWED_TOP)
        {
		    strMenuItem.LoadString(IDS_SUPERSCOPE_SHOW_STATISTICS);
		    hr = LoadAndAddMenuItem( pContextMenuCallback, 
								     strMenuItem, 
								     IDS_SUPERSCOPE_SHOW_STATISTICS,
								     CCM_INSERTIONPOINTID_PRIMARY_TOP, 
								     fFlags );
		    ASSERT( SUCCEEDED(hr) );

            // separator
		    hr = LoadAndAddMenuItem( pContextMenuCallback, 
								     strMenuItem, 
								     0,
								     CCM_INSERTIONPOINTID_PRIMARY_TOP, 
								     MF_SEPARATOR);
		    ASSERT( SUCCEEDED(hr) );

		    // these menu items go in the new menu, 
		    // only visible from scope pane
		    strMenuItem.LoadString(IDS_CREATE_NEW_SCOPE);
		    hr = LoadAndAddMenuItem( pContextMenuCallback, 
								     strMenuItem, 
								     IDS_CREATE_NEW_SCOPE,
								     CCM_INSERTIONPOINTID_PRIMARY_TOP, 
								     fFlags );
		    ASSERT( SUCCEEDED(hr) );
        
            // separator
		    hr = LoadAndAddMenuItem( pContextMenuCallback, 
								     strMenuItem, 
								     0,
								     CCM_INSERTIONPOINTID_PRIMARY_TOP, 
								     MF_SEPARATOR);
		    ASSERT( SUCCEEDED(hr) );
            
		    // Add Activate/Deactivate depending upon state
		    if (m_SuperscopeState == DhcpSubnetDisabled)
		    {
			    strMenuItem.LoadString(IDS_SUPERSCOPE_ACTIVATE);
			    hr = LoadAndAddMenuItem( pContextMenuCallback, 
									     strMenuItem, 
									     IDS_SUPERSCOPE_ACTIVATE,
									     CCM_INSERTIONPOINTID_PRIMARY_TOP, 
									     fFlags );
			    ASSERT( SUCCEEDED(hr) );
		    }
		    else
		    {
			    strMenuItem.LoadString(IDS_SUPERSCOPE_DEACTIVATE);
			    hr = LoadAndAddMenuItem( pContextMenuCallback, 
									     strMenuItem, 
									     IDS_SUPERSCOPE_DEACTIVATE,
									     CCM_INSERTIONPOINTID_PRIMARY_TOP, 
									     fFlags );
			    ASSERT( SUCCEEDED(hr) );
		    }
        }
	}

	return hr; 
}

/*---------------------------------------------------------------------------
	CDhcpSuperscope::OnCommand
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP 
CDhcpSuperscope::OnCommand
(
	ITFSNode *			pNode, 
	long				nCommandId, 
	DATA_OBJECT_TYPES	type, 
	LPDATAOBJECT		pDataObject, 
	DWORD				dwType
)
{
	HRESULT hr = S_OK;

	switch (nCommandId)
	{
		case IDS_CREATE_NEW_SCOPE:
			OnCreateNewScope(pNode);
			break;

        case IDS_ACTIVATE:
        case IDS_DEACTIVATE:
        case IDS_SUPERSCOPE_ACTIVATE:
		case IDS_SUPERSCOPE_DEACTIVATE:
			OnActivateSuperscope(pNode);
			break;

		case IDS_REFRESH:
            // default state for the superscope is disabled.  If 
            // any active scopes are found, the state will be set to active.
            m_SuperscopeState = DhcpSubnetDisabled;
			OnRefresh(pNode, pDataObject, dwType, 0, 0);
			break;

		case IDS_SUPERSCOPE_SHOW_STATISTICS:
			OnShowSuperscopeStats(pNode);
			break;

		case IDS_DELETE:
			OnDelete(pNode);
			break;

		default:
			break;
	}

	return hr;
}

/*!--------------------------------------------------------------------------
	CDhcpSuperscope::OnDelete
		The base handler calls this when MMC sends a MMCN_DELETE for a 
		scope pane item.  We just call our delete command handler.
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CDhcpSuperscope::OnDelete
(
	ITFSNode *	pNode, 
	LPARAM		arg, 
	LPARAM		lParam
)
{
	return OnDelete(pNode);
}

/*---------------------------------------------------------------------------
	CDhcpSuperscope::CreatePropertyPages
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP 
CDhcpSuperscope::CreatePropertyPages
(
	ITFSNode *				pNode,
	LPPROPERTYSHEETCALLBACK lpProvider,
	LPDATAOBJECT			pDataObject, 
	LONG_PTR				handle, 
	DWORD					dwType
)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());

	//
	// Create the property page
    //
	SPIComponentData spComponentData;
	CSuperscopeProperties * pSuperscopeProp = NULL;
    HRESULT hr = hrOK;
    
    COM_PROTECT_TRY
    {
        m_spNodeMgr->GetComponentData(&spComponentData);

	    pSuperscopeProp = new CSuperscopeProperties(pNode, spComponentData, m_spTFSCompData, NULL);
	    
	    // Set superscope specific data in the prop sheet
	    pSuperscopeProp->m_pageGeneral.m_strSuperscopeName = GetName();
	    pSuperscopeProp->m_pageGeneral.m_uImage = GetImageIndex(FALSE);

	    //
	    // Object gets deleted when the page is destroyed
	    //
	    Assert(lpProvider != NULL);

        hr = pSuperscopeProp->CreateModelessSheet(lpProvider, handle);
    }
    COM_PROTECT_CATCH

    return hr;
}

/*!--------------------------------------------------------------------------
	CDhcpSuperscope::GetString
		Returns string information for display in the result pane columns
	Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP_(LPCTSTR) 
CDhcpSuperscope::GetString
(
    ITFSNode *  pNode,
    int         nCol
)
{
	switch (nCol)
	{
		case 0:
			return GetDisplayName();

		case 1:
            return m_strState;
	}
	
	return NULL;
}


/*---------------------------------------------------------------------------
	CDhcpSuperscope::OnPropertyChange
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CDhcpSuperscope::OnPropertyChange
(	
	ITFSNode *		pNode, 
	LPDATAOBJECT	pDataobject, 
	DWORD			dwType, 
	LPARAM			arg, 
	LPARAM			lParam
)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

	CSuperscopeProperties * pSuperscopeProp = 
		reinterpret_cast<CSuperscopeProperties *>(lParam);

	LONG_PTR changeMask = 0;

	// tell the property page to do whatever now that we are back on the
	// main thread
	pSuperscopeProp->OnPropertyChange(TRUE, &changeMask);

	pSuperscopeProp->AcknowledgeNotify();

	if (changeMask)
		pNode->ChangeNode(changeMask);

	return hrOK;
}

/*!--------------------------------------------------------------------------
	CDhcpSuperscope::OnUpdateToolbarButtons
		We override this function to show/hide the correct
        activate/deactivate buttons
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CDhcpSuperscope::OnUpdateToolbarButtons
(
    ITFSNode *          pNode,
    LPDHCPTOOLBARNOTIFY pToolbarNotify
)
{
    HRESULT hr = hrOK;

    if (pToolbarNotify->bSelect)
    {
        UpdateToolbarStates();
    }

    CMTDhcpHandler::OnUpdateToolbarButtons(pNode, pToolbarNotify);

    return hr;
}

/*---------------------------------------------------------------------------
	CDhcpSuperscope::OnResultDelete
		This function is called when we are supposed to delete result
		pane items.  We build a list of selected items and then delete them.
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CDhcpSuperscope::OnResultDelete
(
	ITFSComponent * pComponent, 
	LPDATAOBJECT	pDataObject,
	MMC_COOKIE		cookie,
	LPARAM			arg, 
	LPARAM			param
)
{ 
	HRESULT hr = hrOK;

	AFX_MANAGE_STATE(AfxGetStaticModuleState());

	// translate the cookie into a node pointer
	SPITFSNode  spSuperscope, spServer, spSelectedNode;
    DWORD       dwError;
    
    m_spNodeMgr->FindNode(cookie, &spSuperscope);
    pComponent->GetSelectedNode(&spSelectedNode);

	Assert(spSelectedNode == spSuperscope);
	if (spSelectedNode != spSuperscope)
		return hr;

    spSuperscope->GetParent(&spServer);

	// build the list of selected nodes
	CTFSNodeList listNodesToDelete;
	hr = BuildSelectedItemList(pComponent, &listNodesToDelete);

	//
	// Confirm with the user
	//
	CString strMessage, strTemp;
	int nNodes = (int) listNodesToDelete.GetCount();
	if (nNodes > 1)
	{
		strTemp.Format(_T("%d"), nNodes);
		AfxFormatString1(strMessage, IDS_DELETE_ITEMS, (LPCTSTR) strTemp);
	}
	else
	{
		strMessage.LoadString(IDS_DELETE_ITEM);
	}

	if (AfxMessageBox(strMessage, MB_YESNO) == IDNO)
	{
		return NOERROR;
	}

    BOOL fRefreshServer = FALSE;

    //
	// Loop through all items deleting
	//
    BEGIN_WAIT_CURSOR;
	
    while (listNodesToDelete.GetCount() > 0)
	{
		SPITFSNode   spCurNode;
        const GUID * pGuid;

        CDhcpServer * pServer = GETHANDLER(CDhcpServer, spServer);

		spCurNode = listNodesToDelete.RemoveHead();

        BOOL fWantCancel = TRUE;

        pServer->DeleteScope(spCurNode, &fWantCancel);
        
        if (fWantCancel)
            break;  // user canceled out
    }
    
    END_WAIT_CURSOR;

    return hr;
}

/*!--------------------------------------------------------------------------
	CDhcpSuperscope::OnGetResultViewType
        MMC calls this to get the result view information		
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CDhcpSuperscope::OnGetResultViewType
(
    ITFSComponent * pComponent, 
    MMC_COOKIE      cookie, 
    LPOLESTR *      ppViewType,
    long *          pViewOptions
)
{
    *pViewOptions = MMC_VIEW_OPTIONS_MULTISELECT | MMC_VIEW_OPTIONS_LEXICAL_SORT;

    // we still want the default MMC result pane view, we just want
    // multiselect, so return S_FALSE

    return S_FALSE;
}


/*!--------------------------------------------------------------------------
	CDhcpSuperscope::UpdateToolbarStates
	    Description
    Author: EricDav
 ---------------------------------------------------------------------------*/
void
CDhcpSuperscope::UpdateToolbarStates()
{
	if (m_SuperscopeState == DhcpSubnetDisabled)
	{
        g_SnapinButtonStates[DHCPSNAP_SUPERSCOPE][TOOLBAR_IDX_ACTIVATE] = ENABLED;
        g_SnapinButtonStates[DHCPSNAP_SUPERSCOPE][TOOLBAR_IDX_DEACTIVATE] = HIDDEN;
    }
    else
    {
        g_SnapinButtonStates[DHCPSNAP_SUPERSCOPE][TOOLBAR_IDX_ACTIVATE] = HIDDEN;
        g_SnapinButtonStates[DHCPSNAP_SUPERSCOPE][TOOLBAR_IDX_DEACTIVATE] = ENABLED;
    }
}

/*---------------------------------------------------------------------------
	Command Handlers
 ---------------------------------------------------------------------------*/

 /*---------------------------------------------------------------------------
	CDhcpSuperscope::OnActivateSuperscope
		handler for the activate superscope menu item
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CDhcpSuperscope::OnActivateSuperscope
(
	ITFSNode * pNode
)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

	HRESULT hr = hrOK;
	DWORD err = 0;
	SPITFSNodeEnum spNodeEnum;
	SPITFSNode spCurrentNode;
	ULONG nNumReturned = 0;

	DHCP_SUBNET_STATE NewSubnetState, OldSubnetState;
	NewSubnetState = (m_SuperscopeState == DhcpSubnetDisabled) ? 
							DhcpSubnetEnabled : DhcpSubnetDisabled;

	// get the enumerator for this node
	pNode->GetEnum(&spNodeEnum);

	spNodeEnum->Next(1, &spCurrentNode, &nNumReturned);
	while (nNumReturned)
	{
		// walk the list of subscopes and activate all of them
		CDhcpScope * pScope = GETHANDLER(CDhcpScope, spCurrentNode);

		OldSubnetState = pScope->GetState();
		if (OldSubnetState != NewSubnetState)
		{
			pScope->SetState(NewSubnetState);
			err = pScope->SetInfo();
			if (err != 0)
			{
                // set the state back
                pScope->SetState(OldSubnetState);

                if (::DhcpMessageBox(err, MB_OKCANCEL) == IDCANCEL)
                    break;
			}
			else
			{
				// Need to update the icon for this scope
                int nOpenImage = pScope->GetImageIndex(TRUE);
                int nClosedImage = pScope->GetImageIndex(FALSE);

				spCurrentNode->SetData(TFS_DATA_IMAGEINDEX, nClosedImage);
				spCurrentNode->SetData(TFS_DATA_OPENIMAGEINDEX, nOpenImage);
				
				VERIFY(SUCCEEDED(spCurrentNode->ChangeNode(SCOPE_PANE_CHANGE_ITEM)));
			}
		}

		// get the next scope in the list
		spCurrentNode.Release();
		spNodeEnum->Next(1, &spCurrentNode, &nNumReturned);
	}

	// update the superscope state and icon
	m_SuperscopeState = NewSubnetState;
	pNode->SetData(TFS_DATA_IMAGEINDEX, GetImageIndex(FALSE));
	pNode->SetData(TFS_DATA_OPENIMAGEINDEX, GetImageIndex(TRUE));
	VERIFY(SUCCEEDED(pNode->ChangeNode(SCOPE_PANE_CHANGE_ITEM_ICON)));

    // Update toolbar buttons
    UpdateToolbarStates();
    SendUpdateToolbar(pNode, m_bSelected);

    GetServerObject()->TriggerStatsRefresh(m_spServerNode);

	return hr;
}

 /*---------------------------------------------------------------------------
	CDhcpSuperscope::OnCreateNewScope
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CDhcpSuperscope::OnCreateNewScope
(
	ITFSNode * pNode
)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

	CString strScopeWizTitle;
	SPIComponentData spComponentData;
    CScopeWiz * pScopeWiz = NULL;

    HRESULT hr = hrOK;

    COM_PROTECT_TRY
    {
        strScopeWizTitle.LoadString(IDS_SCOPE_WIZ_TITLE);

	    m_spNodeMgr->GetComponentData(&spComponentData);
	    pScopeWiz = new CScopeWiz(pNode, 
							      spComponentData, 
		    				      m_spTFSCompData,
							      GetName(),
							      strScopeWizTitle);

        pScopeWiz->m_pDefaultOptions = GetServerObject()->GetDefaultOptionsList();

        hr = pScopeWiz->DoModalWizard();
    }
    COM_PROTECT_CATCH

	return hr;
}

/*---------------------------------------------------------------------------
	CDhcpSuperscope::OnDelete()
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CDhcpSuperscope::OnDelete(ITFSNode * pNode)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

	HRESULT hr = S_OK;

	CString strMessage, strTemp;

	AfxFormatString1(strMessage, IDS_DELETE_SUPERSCOPE, GetName());
	
	if (AfxMessageBox(strMessage, MB_YESNO | MB_ICONQUESTION) == IDYES)
	{
		BOOL    fRefresh = FALSE;
        DWORD   dwError = 0;

        CDhcpServer * pServer = GETHANDLER(CDhcpServer, m_spServerNode);
        pServer->DeleteSuperscope(pNode, &fRefresh);

        // tell the server to refresh the view
        if (fRefresh)
            pServer->OnRefresh(m_spServerNode, NULL, 0, 0, 0);
	}

	return hr;
}

/*---------------------------------------------------------------------------
	CDhcpSuperscope::OnShowSuperscopeStats()
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
CDhcpSuperscope::OnShowSuperscopeStats
(
	ITFSNode * pNode
)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

	HRESULT hr = S_OK;

    // Fill in some information in the stats object.
    // CreateNewStatisticsWindow handles the case if the window is 
    // already visible.
    m_dlgStats.SetNode(pNode);
    m_dlgStats.SetServer(GetServerObject()->GetIpAddress());
    m_dlgStats.SetSuperscopeName(m_strName);

	CreateNewStatisticsWindow(&m_dlgStats,
							  ::FindMMCMainWindow(),
							  IDD_STATS_NARROW);

    return hr;
}

 /*---------------------------------------------------------------------------
	CDhcpSuperscope::DoesSuperscopeExist()
		This function checks to see if the given superscope name already
		exists.  Since there is no API call to do this, we get the superscope
		info which lists all of the scopes and their superscope owners.
		We then check each one to see if a superscope already exists.
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CDhcpSuperscope::DoesSuperscopeExist(LPCWSTR szName)
{
	LPDHCP_SUPER_SCOPE_TABLE pSuperscopeTable = NULL;
	CString strName = szName;

	DWORD dwErr = GetSuperscopeInfo(&pSuperscopeTable);
	if (dwErr != ERROR_SUCCESS)
		return dwErr;

	for (UINT i = 0; i < pSuperscopeTable->cEntries; i++)
	{
		if (pSuperscopeTable->pEntries[i].SuperScopeName)
		{
			if (strName.Compare(pSuperscopeTable->pEntries[i].SuperScopeName) == 0)
				return E_FAIL;
		}
	}

	::DhcpRpcFreeMemory(pSuperscopeTable);

	return S_OK;
}

 /*---------------------------------------------------------------------------
	CDhcpSuperscope::AddScope()
		Adds a scope to this superscope
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CDhcpSuperscope::AddScope(DHCP_IP_ADDRESS scopeAddress)
{
	return SetSuperscope(scopeAddress, FALSE);
}

 /*---------------------------------------------------------------------------
	CDhcpSuperscope::RemoveScope()
		Removes a scope from this superscope
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CDhcpSuperscope::RemoveScope(DHCP_IP_ADDRESS scopeAddress)
{
	return SetSuperscope(scopeAddress, TRUE);
}

 /*---------------------------------------------------------------------------
	CDhcpSuperscope::Rename()
		There is no API to rename a superscope.  What needs to be done is to
		delete the superscope and then re-add all of the scopes that were 
		a part of the superscope.  So, we get the superscope info first.
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CDhcpSuperscope::Rename(ITFSNode * pNode, LPCWSTR szNewName)
{
    SPITFSNode spServerNode;
	CDhcpServer * pServer;
    CDWordArray arrayScopes;
	LPDHCP_SUPER_SCOPE_TABLE pSuperscopeTable = NULL;

    pNode->GetParent(&spServerNode);
    pServer = GETHANDLER(CDhcpServer, spServerNode);

	// initialize the array
	//arrayScopes.SetSize(10);

	// check to see if the new name already exists
	if (FAILED(DoesSuperscopeExist(szNewName)))
		return E_FAIL;

	// Get the info
	DWORD dwErr = GetSuperscopeInfo(&pSuperscopeTable);
	if (dwErr != ERROR_SUCCESS)
		return dwErr;

	// build our array of scopes in this superscope
	for (UINT i = 0; i < pSuperscopeTable->cEntries; i++)
	{
		// if this scope has a superscope and it's the one we're renaming, 
		// then add it to our list.
		if ((pSuperscopeTable->pEntries[i].SuperScopeName != NULL) &&
			(m_strName.Compare(pSuperscopeTable->pEntries[i].SuperScopeName) == 0))
		{
			arrayScopes.Add(pSuperscopeTable->pEntries[i].SubnetAddress);
		}
	}

	// free the RPC memory
	::DhcpRpcFreeMemory(pSuperscopeTable);

	// now we have the info.  Lets delete the old superscope.
	dwErr = pServer->RemoveSuperscope(GetName());

	SetName(szNewName);

	// now we re-add all the scopes
	for (i = 0; i < (UINT) arrayScopes.GetSize(); i++)
	{	
		DHCP_IP_ADDRESS SubnetAddress = arrayScopes[i];
		AddScope(SubnetAddress);
	}

	arrayScopes.RemoveAll();

	// Update the display string
	CString strDisplayName;
	BuildDisplayName(&strDisplayName, GetName());
	SetDisplayName(strDisplayName);

	return S_OK;
}

 /*---------------------------------------------------------------------------
	CDhcpSuperscope::GetSuperscopeInfo()
		Wrapper for the DhcpGetSuperScopeInfoV4 call
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CDhcpSuperscope::GetSuperscopeInfo(LPDHCP_SUPER_SCOPE_TABLE *ppSuperscopeTable)
{
	CDhcpServer * pServer = GetServerObject();
	return ::DhcpGetSuperScopeInfoV4(pServer->GetIpAddress(), ppSuperscopeTable);
}

 /*---------------------------------------------------------------------------
	CDhcpSuperscope::SetSuperscope()
		Wrapper for the DhcpSetSuperScopeV4 call
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT 
CDhcpSuperscope::SetSuperscope(DHCP_IP_ADDRESS SubnetAddress, BOOL ChangeExisting)
{
	CDhcpServer * pServer = GetServerObject();
	return ::DhcpSetSuperScopeV4(pServer->GetIpAddress(), SubnetAddress, (LPWSTR) GetName(), ChangeExisting);
}

/*---------------------------------------------------------------------------
	Background thread functionality
 ---------------------------------------------------------------------------*/

/*!--------------------------------------------------------------------------
	CDhcpSuperscope::OnNotifyExiting
		CMTDhcpHandler overridden functionality
		allows us to know when the background thread is done
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP 
CDhcpSuperscope::OnNotifyExiting
(
	LPARAM			lParam
)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

	SPITFSNode spNode;
	spNode.Set(m_spNode); // save this off because OnNotifyExiting will release it

	HRESULT hr = CMTHandler::OnNotifyExiting(lParam);

	if (m_nState == loaded)
	{
		// count the number of scopes in this superscope.
		// if there are none, ask the user if they want to delete this node.
		int nVisible, nTotal;
		HRESULT hr = spNode->GetChildCount(&nVisible, &nTotal);

		if (nTotal == 0)
		{
            // this superscope is empty and will be removed from the UI
            // notify the user and remove
            ::AfxMessageBox(IDS_SUPERSCOPE_EMPTY, MB_OK);
			
            // remove from UI
			SPITFSNode spParent;

			spNode->GetParent(&spParent);
			spParent->RemoveChild(spNode);
		}
	}

	return hr;
}


 /*---------------------------------------------------------------------------
	CDhcpSuperscope::OnCreateQuery()
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
ITFSQueryObject* 
CDhcpSuperscope::OnCreateQuery(ITFSNode * pNode)
{
	HRESULT hr = hrOK;
    CDhcpSuperscopeQueryObj* pQuery = NULL;

    COM_PROTECT_TRY
    {
        pQuery = new CDhcpSuperscopeQueryObj(m_spTFSCompData, m_spNodeMgr);
	    
	    pQuery->m_strServer = GetServerObject()->GetIpAddress();
	    
	    pQuery->m_strSuperscopeName = GetName();
    }
    COM_PROTECT_CATCH
	
	return pQuery;
}

/*---------------------------------------------------------------------------
	CDhcpSuperscopeQueryObj::Execute()
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
STDMETHODIMP
CDhcpSuperscopeQueryObj::Execute()
{
	DWORD							dwError = ERROR_MORE_DATA;
	LPDHCP_SUPER_SCOPE_TABLE		pSuperscopeTable = NULL;
	DHCP_SUPER_SCOPE_TABLE_ENTRY *	pSuperscopeTableEntry;	// Pointer to a single entry in array

	dwError = ::DhcpGetSuperScopeInfoV4((LPWSTR) ((LPCTSTR)m_strServer),
										&pSuperscopeTable);
	
	if (pSuperscopeTable == NULL ||
        dwError != ERROR_SUCCESS)
	{
		//ASSERT(FALSE);
        PostError(dwError);
		return hrFalse;	// Just in case
	}

	pSuperscopeTableEntry = pSuperscopeTable->pEntries;
	if (pSuperscopeTableEntry == NULL && pSuperscopeTable->cEntries != 0)
	{
		ASSERT(FALSE);
        PostError(dwError);
		return hrFalse; // Just in case
	}

	for (int iSuperscopeEntry = pSuperscopeTable->cEntries;
		 iSuperscopeEntry > 0;
		 iSuperscopeEntry--, pSuperscopeTableEntry++)
	{
		LPDHCP_SUBNET_INFO	pdhcpSubnetInfo;

		if ((pSuperscopeTableEntry->SuperScopeName != NULL) && 
			(m_strSuperscopeName.Compare(pSuperscopeTableEntry->SuperScopeName) == 0))
		{
			//
			// The API list all the scopes, not just scopes that are members of a superscope.
			// You can tell if a scope is a member of a superscope by looking at the SuperScopeName.
			// So, we look to see if the superscope name matches what we are enumerating for...
			//
			DWORD dwReturn = ::DhcpGetSubnetInfo((LPWSTR) ((LPCTSTR)m_strServer),
							  					 pSuperscopeTableEntry->SubnetAddress,
												 &pdhcpSubnetInfo);
			//
			// Create the new scope based on the info we querried
			//
			SPITFSNode spNode;
			CDhcpScope * pDhcpScope = new CDhcpScope(m_spTFSCompData, pdhcpSubnetInfo);
			CreateContainerTFSNode(&spNode,
								   &GUID_DhcpScopeNodeType,
								   pDhcpScope,
								   pDhcpScope,
								   m_spNodeMgr);

			// Tell the handler to initialize any specific data
            pDhcpScope->InitializeNode(spNode);

            // Set some information about the scope
            pDhcpScope->SetInSuperscope(TRUE);

            AddToQueue(spNode);

			pDhcpScope->Release();
		
			::DhcpRpcFreeMemory(pdhcpSubnetInfo);
		}
	}
	
	//
	// Free the memory
	//
	::DhcpRpcFreeMemory(pSuperscopeTable);

	return hrFalse;
}

/*---------------------------------------------------------------------------
	Helper functions
 ---------------------------------------------------------------------------*/
HRESULT
CDhcpSuperscope::BuildDisplayName
(
	CString * pstrDisplayName,
	LPCTSTR	  pName
)
{
	if (pstrDisplayName)
	{
		CString strStandard, strName;

		strName = pName;

		strStandard.LoadString(IDS_SUPERSCOPE_FOLDER);
		
		*pstrDisplayName = strStandard + L" " + strName;
	}

	return hrOK;
}

/*---------------------------------------------------------------------------
	CDhcpSuperscope::NotifyScopeStateChange()
		This function gets called when a sub-scope of a superscope is 
        changing state.  We need to update the state of the superscope.
	Author: EricDav
 ---------------------------------------------------------------------------*/
void
CDhcpSuperscope::NotifyScopeStateChange
(
    ITFSNode *          pNode,
    DHCP_SUBNET_STATE   newScopeState
)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

    if (newScopeState == DhcpSubnetEnabled)
    {
        // A subscope is being enabled.  That means the superscope is active.
        if (m_SuperscopeState == DhcpSubnetDisabled)
        {
            m_SuperscopeState = DhcpSubnetEnabled;
            m_strState.LoadString(IDS_SCOPE_ACTIVE);

            pNode->SetData(TFS_DATA_IMAGEINDEX, GetImageIndex(FALSE));
            pNode->SetData(TFS_DATA_OPENIMAGEINDEX, GetImageIndex(TRUE));
        }

    }
    else
    {
        // a scope is being deactivated.  Walk the list of scopes and make
        // sure at least one is still active.
        DHCP_SUBNET_STATE   dhcpSuperscopeState = DhcpSubnetDisabled;
        SPITFSNodeEnum      spNodeEnum;
        SPITFSNode          spCurrentNode;
        ULONG               nNumReturned = 0;
        int                 nStringId = IDS_SCOPE_INACTIVE;

        pNode->GetEnum(&spNodeEnum);

        spNodeEnum->Next(1, &spCurrentNode, &nNumReturned);
        while (nNumReturned)
        {
            CDhcpScope * pScope = GETHANDLER(CDhcpScope, spCurrentNode);
            DHCP_SUBNET_STATE scopeState = pScope->GetState();

            if (scopeState == DhcpSubnetEnabled)
            {
                // at least one scope is enabled.  This superscope is
                // therefore enabled.
                dhcpSuperscopeState = DhcpSubnetEnabled;
                nStringId = IDS_SCOPE_ACTIVE;
                break;
            }

	        spCurrentNode.Release();
	        spNodeEnum->Next(1, &spCurrentNode, &nNumReturned);
        }

        // set the superscope state based on what we found
        m_strState.LoadString(nStringId);
        m_SuperscopeState = dhcpSuperscopeState;

        pNode->SetData(TFS_DATA_IMAGEINDEX, GetImageIndex(FALSE));
        pNode->SetData(TFS_DATA_OPENIMAGEINDEX, GetImageIndex(TRUE));
    }

	VERIFY(SUCCEEDED(pNode->ChangeNode(SCOPE_PANE_CHANGE_ITEM)));
}

/*---------------------------------------------------------------------------
	CDhcpSuperscope::UpdateStatistics
        Notification that stats are now available.  Update stats for the 
        node and give all subnodes a chance to update.
	Author: EricDav
 ---------------------------------------------------------------------------*/
DWORD
CDhcpSuperscope::UpdateStatistics
(
    ITFSNode * pNode
)
{
    HRESULT         hr = hrOK;
    SPITFSNodeEnum  spNodeEnum;
    SPITFSNode      spCurrentNode;
    ULONG           nNumReturned;
    HWND            hStatsWnd;

    // Check to see if this node has a stats sheet up.
    hStatsWnd = m_dlgStats.GetSafeHwnd();
    if (hStatsWnd != NULL)
    {
        PostMessage(hStatsWnd, WM_NEW_STATS_AVAILABLE, 0, 0);
    }
    
    // tell the scope nodes to update anything
    // they need to based on the new stats.
    CORg(pNode->GetEnum(&spNodeEnum));

	CORg(spNodeEnum->Next(1, &spCurrentNode, &nNumReturned));
	while (nNumReturned)
	{
        if (spCurrentNode->GetData(TFS_DATA_TYPE) == DHCPSNAP_SCOPE)
        {
            CDhcpScope * pScope = GETHANDLER(CDhcpScope, spCurrentNode);

            pScope->UpdateStatistics(spCurrentNode);
        }

        spCurrentNode.Release();
		spNodeEnum->Next(1, &spCurrentNode, &nNumReturned);
	}

Error:
    return hr;
}




/*---------------------------------------------------------------------------
	Class COptionNodeEnum
        Enumerates the options for a given level.  Generates a list of
        nodes.
	Author: EricDav
 ---------------------------------------------------------------------------*/
COptionNodeEnum::COptionNodeEnum
(
    ITFSComponentData * pComponentData,
    ITFSNodeMgr *       pNodeMgr
)
{
    m_spTFSCompData.Set(pComponentData);
    m_spNodeMgr.Set(pNodeMgr);
}

/*---------------------------------------------------------------------------
	COptionNodeEnum::Enum()
		Calls the appropriate enum function depending upon version
	Author: EricDav
 ---------------------------------------------------------------------------*/
DWORD
COptionNodeEnum::Enum
(
    LPCTSTR                  pServer,
    LARGE_INTEGER &          liVersion,
    DHCP_OPTION_SCOPE_INFO & dhcpOptionScopeInfo
)
{
    DWORD dwErr;

    if (liVersion.QuadPart >= DHCP_NT5_VERSION)
    {
        // enumerate standard plus the vendor and class ID based options
        dwErr = EnumOptionsV5(pServer, dhcpOptionScopeInfo);
    }
    else
    {
        // Enumerate the standard options
        dwErr = EnumOptions(pServer, dhcpOptionScopeInfo);
    }

    return dwErr;
}

/*---------------------------------------------------------------------------
	COptionNodeEnum::EnumOptions()
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
DWORD
COptionNodeEnum::EnumOptions
(
    LPCTSTR                  pServer,
    DHCP_OPTION_SCOPE_INFO & dhcpOptionScopeInfo
)
{
    LPDHCP_OPTION_VALUE_ARRAY pOptionValues = NULL;
	DWORD dwOptionsRead = 0, dwOptionsTotal = 0;
	DWORD err = ERROR_SUCCESS;
    HRESULT hr = hrOK;
    DHCP_RESUME_HANDLE dhcpResumeHandle = NULL;

	err = ::DhcpEnumOptionValues((LPWSTR) pServer,
								 &dhcpOptionScopeInfo,
								 &dhcpResumeHandle,
								 0xFFFFFFFF,
								 &pOptionValues,
								 &dwOptionsRead,
								 &dwOptionsTotal);
	
    Trace4("Server %s - DhcpEnumOptionValues returned %lx, read %d, Total %d.\n", pServer, err, dwOptionsRead, dwOptionsTotal);
	
	if (dwOptionsRead && dwOptionsTotal && pOptionValues) 
	{
		for (DWORD i = 0; i < dwOptionsRead; i++)
		{
			// 
			// Filter out the "special" option values that we don't want the
			// user to see.
			//
			// CODEWORK: don't filter vendor specifc options... all vendor 
            // specifc options are visible.
            //
			if (FilterOption(pOptionValues->Values[i].OptionID))
				continue;
			
			//
			// Create the result pane item for this element
			//
			SPITFSNode spNode;
			CDhcpOptionItem * pOptionItem = NULL;
            
            COM_PROTECT_TRY
            {
				pOptionItem = new CDhcpOptionItem(m_spTFSCompData, &pOptionValues->Values[i], ICON_IDX_SERVER_OPTION_LEAF);

			    CreateLeafTFSNode(&spNode,
							      &GUID_DhcpOptionNodeType,
							      pOptionItem,
							      pOptionItem,
							      m_spNodeMgr);

			    // Tell the handler to initialize any specific data
			    pOptionItem->InitializeNode(spNode);
	    		
                // extra addref to keep the node alive while it is on the list
                spNode->AddRef();
                AddTail(spNode);
			    
                pOptionItem->Release();
            }
            COM_PROTECT_CATCH
		}

		::DhcpRpcFreeMemory(pOptionValues);
	}

	if (err == ERROR_NO_MORE_ITEMS)
        err = ERROR_SUCCESS;

    return err;
}

/*---------------------------------------------------------------------------
	COptionNodeEnum::EnumOptionsV5()
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
DWORD
COptionNodeEnum::EnumOptionsV5
(
    LPCTSTR                  pServer,
    DHCP_OPTION_SCOPE_INFO & dhcpOptionScopeInfo
)
{
    LPDHCP_OPTION_VALUE_ARRAY pOptionValues = NULL;
    LPDHCP_ALL_OPTION_VALUES  pAllOptions = NULL;
    DWORD dwNumOptions, err, i;

    err = ::DhcpGetAllOptionValues((LPWSTR) pServer,
                                   0,
								   &dhcpOptionScopeInfo,
								   &pAllOptions);
	
    Trace2("Server %s - DhcpGetAllOptionValues (Global) returned %lx\n", pServer, err);

    if (err == ERROR_NO_MORE_ITEMS || err == ERROR_SUCCESS)
    {
	    if (pAllOptions == NULL)
	    {
		    // This happens when stressing the server.  Perhaps when server is OOM.
		    err = ERROR_OUTOFMEMORY;
            return err;
	    }

        // get the list of options (vendor and non-vendor) defined for
        // the NULL class (no class)
        for (i = 0; i < pAllOptions->NumElements; i++)
        {
            CreateOptions(pAllOptions->Options[i].OptionsArray, 
                          pAllOptions->Options[i].ClassName,
                          pAllOptions->Options[i].VendorName);
        }
        
        if (pAllOptions)
            ::DhcpRpcFreeMemory(pAllOptions);
	}

    if (err == ERROR_NO_MORE_ITEMS)
        err = ERROR_SUCCESS;

	return err;
}

/*---------------------------------------------------------------------------
	COptionNodeEnum::CreateOptions()
		Description
	Author: EricDav
 ---------------------------------------------------------------------------*/
HRESULT
COptionNodeEnum::CreateOptions
(
    LPDHCP_OPTION_VALUE_ARRAY pOptionValues,
    LPCTSTR                   pClassName,
    LPCTSTR                   pszVendor
)
{
    HRESULT hr = hrOK;
    SPITFSNode spNode;
    CDhcpOptionItem * pOptionItem;
    
    if (pOptionValues == NULL)
        return hr;

    Trace1("COptionNodeEnum::CreateOptions - Creating %d options\n", pOptionValues->NumElements);

    COM_PROTECT_TRY
    {
        for (DWORD i = 0; i < pOptionValues->NumElements; i++)
        {
	        // 
	        // Filter out the "special" option values that we don't want the
	        // user to see.
	        //
	        // don't filter vendor specifc options... all vendor 
            // specifc options are visible.
            // 
            // also don't filter out class based options
            //
	        if (FilterOption(pOptionValues->Values[i].OptionID) &&
                pClassName == NULL &&
                !pszVendor)
		        continue;
		                        
	        //
	        // Create the result pane item for this element
	        //
	        pOptionItem = new CDhcpOptionItem(m_spTFSCompData, &pOptionValues->Values[i], ICON_IDX_SERVER_OPTION_LEAF);

	        if (pClassName)
                pOptionItem->SetClassName(pClassName);

            if (pszVendor)
                pOptionItem->SetVendor(pszVendor);

            CORg (CreateLeafTFSNode(&spNode,
      			  		            &GUID_DhcpOptionNodeType,
					                pOptionItem,
					                pOptionItem,
					                m_spNodeMgr));

	        // Tell the handler to initialize any specific data
	        pOptionItem->InitializeNode(spNode);
	        
            // extra addref to keep the node alive while it is on the list
            spNode->AddRef();
            AddTail(spNode);
		                        
            pOptionItem->Release();
            spNode.Set(NULL);

            COM_PROTECT_ERROR_LABEL;
        }
    }
    COM_PROTECT_CATCH

    return hr;
}

DWORD
CSubnetInfoCache::GetInfo
(
    CString &       strServer, 
    DHCP_IP_ADDRESS ipAddressSubnet, 
    CSubnetInfo &   subnetInfo
)
{
    CSubnetInfo subnetInfoCached;
    DWORD       dwError = 0;
    int         i;
    BOOL        fFound = FALSE;

    // look in the cache for it....
    if (Lookup(ipAddressSubnet, subnetInfoCached))
    {
        // found it
        fFound = TRUE;
    }

    if (!fFound)
    {
        // not in cache go get it
        LPDHCP_SUBNET_INFO pSubnetInfo;
        dwError = ::DhcpGetSubnetInfo(strServer, ipAddressSubnet, &pSubnetInfo);
        if (dwError == ERROR_SUCCESS)
        {
            if (pSubnetInfo == NULL)
            {
                // at present this only happens when the user creates a scope in the multicast range
                // without going through the multicast APIs.
                Trace1("Scope %lx DhcpGetSubnetInfo returned null!\n", ipAddressSubnet);
            }
            else
            {
                subnetInfoCached.Set(pSubnetInfo);
                ::DhcpRpcFreeMemory(pSubnetInfo);

                SetAt(ipAddressSubnet, subnetInfoCached);
            }
        }
    }

    subnetInfo = subnetInfoCached;

    return dwError;
}

DWORD
CMScopeInfoCache::GetInfo
(
    CString &       strServer, 
    LPCTSTR         pszName, 
    CSubnetInfo &   subnetInfo
)
{
    CSubnetInfo subnetInfoCached;
    DWORD       dwError = 0;
    int         i;
    BOOL        fFound = FALSE;

    // look in the cache for it....
    if (Lookup(pszName, subnetInfoCached))
    {
        // found it
        fFound = TRUE;
    }

    if (!fFound)
    {
        // try getting multicast scopes
		LPDHCP_MSCOPE_INFO	pdhcpMScopeInfo = NULL;

		dwError = ::DhcpGetMScopeInfo(((LPWSTR) (LPCTSTR)strServer),
									  (LPWSTR) pszName,
									   &pdhcpMScopeInfo);
        if (dwError == ERROR_SUCCESS)
        {
            if (pdhcpMScopeInfo == NULL)
            {
                // at present this only happens when the user creates a scope in the multicast range
                // without going through the multicast APIs.
                Trace1("MScope %s DhcpGetMScopeInfo returned null!\n", pszName);
            }
            else
            {
                subnetInfoCached.Set(pdhcpMScopeInfo);
                ::DhcpRpcFreeMemory(pdhcpMScopeInfo);

                Add(subnetInfoCached);
            }
        }
    }

    subnetInfo = subnetInfoCached;

    return dwError;
}

DWORD CDhcpServer::GetBindings(LPDHCP_BIND_ELEMENT_ARRAY &BindArray)
{
    // check if call supported.
    if( FALSE == m_fSupportsBindings ) return ERROR_NOT_SUPPORTED;

    // now, attempt to do the retrieval..
    BindArray = 0;
    return ::DhcpGetServerBindingInfo(
        m_strServerAddress, 0, &BindArray
        );
}

DWORD CDhcpServer::SetBindings(LPDHCP_BIND_ELEMENT_ARRAY BindArray)
{
    // check again, if atleaset supported...
    if( FALSE == m_fSupportsBindings ) return ERROR_NOT_SUPPORTED;

    // now attempt to set the bindings information..
    return ::DhcpSetServerBindingInfo(
        m_strServerAddress, 0, BindArray
        );
}