archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 827363a95b
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '827363a95b'
${ noResults }
windows-server-2003/net/mmc/dhcp/server.cpp

8461 lines
280 KiB
Raw Blame History

/**********************************************************************/
/** 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:
OnControlService( pNode, FALSE );
OnControlService( pNode, TRUE );
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);
}
// Refresh the server node
OnRefresh( pNode, NULL, 0, 0, 0 );
return hrOK;
} // CDhcpServer::OnPropertyChange()
/*---------------------------------------------------------------------------
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;
hr = S_FALSE;
}
return hr;
}
STDMETHODIMP_(int)
CDhcpServer::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;
CString str1 = spNode1->GetString( nCol );
CString str2 = spNode2->GetString( nCol );
nCompare = str1.Compare( str2 );
return nCompare;
} // CDhcpServer::CompareItems()
STDMETHODIMP_(int)
CDhcpServer::CompareItems
(
ITFSComponent *pComponent,
RDCOMPARE *prdc
)
{
SPITFSNode spNode1, spNode2;
m_spNodeMgr->FindNode( prdc->prdch1->cookie, &spNode1);
m_spNodeMgr->FindNode( prdc->prdch2->cookie, &spNode2);
int nCompare = 0;
CString str1 = spNode1->GetString( prdc->nColumn );
CString str2 = spNode2->GetString( prdc->nColumn );
nCompare = str1.Compare( str2 );
return nCompare;
}
/*!--------------------------------------------------------------------------
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, 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 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::RestartService
-
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT
CDhcpServer::RestartService
(
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));
}
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)
{
hr = RestartService(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;
OnRefresh( pNode, NULL, 0, 0, 0 );
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( IDS_ERR_RESTORE_FAILED, NULL, MB_OK, 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;
CDhcpServer *pServ;
// Is any property sheet open?
pServ = GETHANDLER( CDhcpServer, pNode );
if ( pServ->HasPropSheetsOpen()) {
AfxMessageBox( IDS_MSG_CLOSE_PROPSHEET );
return S_FALSE;
}
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);
//
// Check if there are any property sheets open
//
if ( pScope->HasPropSheetsOpen()) {
AfxMessageBox( IDS_MSG_CLOSE_PROPSHEET );
return ERROR_INVALID_PARAMETER;
}
//
// 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 [] (( BYTE * ) 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;
do {
pDupMibInfo = new DHCP_MCAST_MIB_INFO;
if ( 0 == pDupMibInfo ) {
break;
}
*pDupMibInfo = *m_pMCastMibInfo;
if ( m_pMCastMibInfo->Scopes > 0 ) {
pDupMibInfo->ScopeInfo =
new MSCOPE_MIB_INFO[ m_pMCastMibInfo->Scopes ];
if ( 0 != pDupMibInfo->ScopeInfo ) {
for ( DWORD i = 0 ; i < m_pMCastMibInfo->Scopes; i++ ) {
pDupMibInfo->ScopeInfo[ i ] = m_pMCastMibInfo->ScopeInfo[ i ];
pDupMibInfo->ScopeInfo[ i ].MScopeName =
::UtilWcstrDup( m_pMCastMibInfo->ScopeInfo[ i ].MScopeName, NULL );
} // for
} // if
else {
pDupMibInfo->Scopes = 0;
pDupMibInfo->ScopeInfo = 0;
}
} // if
} while ( FALSE );
// COM_PROTECT_CATCH
return pDupMibInfo;
} // CDhcpServer::DuplicateMCastMibInfo()
/*---------------------------------------------------------------------------
CDhcpServer::FreeDupMCastMibInfo()
Scan/reconcile database
Author: EricDav
---------------------------------------------------------------------------*/
void
CDhcpServer::FreeDupMCastMibInfo(LPDHCP_MCAST_MIB_INFO pDupMibInfo)
{
for ( DWORD i = 0; i < pDupMibInfo->Scopes; i++ ) {
delete [] pDupMibInfo->ScopeInfo[ i ].MScopeName;
}
delete [] pDupMibInfo->ScopeInfo;
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();
} // else
continue;
} // if
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();
} // if
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);
}
} // else
} // 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
pSuperscope = GETHANDLER(CDhcpSuperscope, spNode);
pSuperscope->InitializeNode(spNode);
AddToQueue(spNode);
spNode.Release();
}
listSuperscopes.RemoveAll();
} // if
//
// 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 2: {
// compare the printable values
CString str1, str2;
str1 = pOpt1->GetString( pComponent, cookieA, nCol );
str2 = pOpt2->GetString( pComponent, cookieB, nCol );
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;
WCHAR * pNewBootpList = NULL;
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
pNewBootpList = (WCHAR *) malloc(pServerConfig->cbBootTableString);
if ( NULL == pNewBootpList ) {
return ERROR_NOT_ENOUGH_MEMORY;
}
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
} // while pos
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
if (pServerConfig)
::DhcpRpcFreeMemory(pServerConfig);
Assert (listNodesToDelete.GetCount() == 0);
END_WAIT_CURSOR;
free( pNewBootpList );
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
)
{
HRESULT hr = hrOK;
if ( CMTDhcpHandler::OnGetResultViewType( pComponent, cookie,
ppViewType, pViewOptions ) != S_OK ) {
*pViewOptions = MMC_VIEW_OPTIONS_MULTISELECT;
// we still want the default MMC result pane view, we just want
// multiselect, so return S_FALSE
hr = S_FALSE;
}
return hr;
} // CDhcpSuperscope::OnGetResultViewType()
STDMETHODIMP_(int)
CDhcpSuperscope::CompareItems
(
ITFSComponent *pComponent,
RDCOMPARE *prdc
)
{
SPITFSNode spNode1, spNode2;
m_spNodeMgr->FindNode( prdc->prdch1->cookie, &spNode1);
m_spNodeMgr->FindNode( prdc->prdch2->cookie, &spNode2);
int nCompare = 0;
CString str1 = spNode1->GetString( prdc->nColumn );
CString str2 = spNode2->GetString( prdc->nColumn );
nCompare = str1.Compare( str2 );
return nCompare;
} // CDhcpSuperScope::CompareItems()
/*!--------------------------------------------------------------------------
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 lhr = 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
);
}