able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/mmc/dhcp/nodes.cpp
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

1960 lines
52 KiB
C++
Raw Permalink Blame History

/**********************************************************************/
/** Microsoft Windows/NT **/
/** Copyright(c) Microsoft Corporation, 1997 - 1999 **/
/**********************************************************************/
/*
nodes.h
This file contains all of the implementation for the DHCP
objects that appear in the result pane of the MMC framework.
The objects are:
CDhcpActiveLease
CDhcpConflicAddress
CDhcpAllocationRange
CDhcpExclusionRange
CDhcpBootpTableEntry
CDhcpOption
FILE HISTORY:
*/
#include "stdafx.h"
#include "nodes.h"
#include "server.h"
#include "scope.h"
#include "bootppp.h"
#include "optcfg.h"
#include "intltime.h"
CString g_szClientTypeUnspecified;
CString g_szClientTypeNone;
CString g_szClientTypeUnknown;
const TCHAR g_szClientTypeDhcp[] = _T("DHCP");
const TCHAR g_szClientTypeBootp[] = _T("BOOTP");
const TCHAR g_szClientTypeBoth[] = _T("DHCP/BOOTP");
/*---------------------------------------------------------------------------
Class CDhcpActiveLease implementation
---------------------------------------------------------------------------*/
DEBUG_DECLARE_INSTANCE_COUNTER(CDhcpActiveLease);
/*---------------------------------------------------------------------------
CDhcpActiveLease constructor/destructor
Takes the NT5 client info struct
Author: EricDav
---------------------------------------------------------------------------*/
CDhcpActiveLease::CDhcpActiveLease
(
ITFSComponentData * pTFSCompData,
LPDHCP_CLIENT_INFO_V5 pDhcpClientInfo
) : CDhcpHandler(pTFSCompData)
{
DEBUG_INCREMENT_INSTANCE_COUNTER(CDhcpActiveLease);
if (g_szClientTypeUnspecified.IsEmpty())
{
g_szClientTypeUnspecified.LoadString(IDS_UNSPECIFIED);
g_szClientTypeNone.LoadString(IDS_NONE);
g_szClientTypeUnknown.LoadString(IDS_UNKNOWN);
}
//
// Reset our flags for this lease
//
m_dwTypeFlags = 0;
//
// Intialize our client type variable
//
m_bClientType = pDhcpClientInfo->bClientType;
//
// Initialize does everything but initialize the client type
// since there are two versions of the client info struct, one
// contains the type, the other doesn't. So we need to save it
// away after the call.
//
InitInfo((LPDHCP_CLIENT_INFO) pDhcpClientInfo);
// now check NT5 specific flags
if (pDhcpClientInfo->AddressState & V5_ADDRESS_BIT_UNREGISTERED)
{
if (pDhcpClientInfo->AddressState & V5_ADDRESS_BIT_DELETED)
{
// this lease is pending DNS unregistration
m_dwTypeFlags |= TYPE_FLAG_DNS_UNREG;
}
else
{
// this lease is pending DNS registration
m_dwTypeFlags |= TYPE_FLAG_DNS_REG;
}
}
else
if ((pDhcpClientInfo->AddressState & 0x03) == V5_ADDRESS_STATE_DOOM)
{
m_dwTypeFlags |= TYPE_FLAG_DOOMED;
}
}
/*---------------------------------------------------------------------------
CDhcpActiveLease constructor/destructor
Takes the NT4 SP2 client info struct
Author: EricDav
---------------------------------------------------------------------------*/
CDhcpActiveLease::CDhcpActiveLease
(
ITFSComponentData * pTFSCompData,
LPDHCP_CLIENT_INFO_V4 pDhcpClientInfo
) : CDhcpHandler(pTFSCompData)
{
DEBUG_INCREMENT_INSTANCE_COUNTER(CDhcpActiveLease);
//
// Reset our flags for this lease
//
m_dwTypeFlags = 0;
//
// Intialize our client type variable
//
m_bClientType = pDhcpClientInfo->bClientType;
//
// Initialize does everything but initialize the client type
// since there are two versions of the client info struct, one
// contains the type, the other doesn't. So we need to save it
// away after the call.
//
InitInfo((LPDHCP_CLIENT_INFO) pDhcpClientInfo);
}
/*---------------------------------------------------------------------------
CDhcpActiveLease constructor/destructor
Takes the pre-NT4 SP2 client info struct
Author: EricDav
---------------------------------------------------------------------------*/
CDhcpActiveLease::CDhcpActiveLease
(
ITFSComponentData * pTFSCompData,
LPDHCP_CLIENT_INFO pDhcpClientInfo
) : CDhcpHandler(pTFSCompData)
{
DEBUG_INCREMENT_INSTANCE_COUNTER(CDhcpActiveLease);
//m_verbDefault = MMC_VERB_PROPERTIES;
//
// Reset our flags for this lease
//
m_dwTypeFlags = 0;
//
// Intialize our client type variable
//
m_bClientType = CLIENT_TYPE_DHCP;
InitInfo((LPDHCP_CLIENT_INFO) pDhcpClientInfo);
}
CDhcpActiveLease::CDhcpActiveLease
(
ITFSComponentData * pTFSCompData,
CDhcpClient & dhcpClient
) : CDhcpHandler(pTFSCompData)
{
DEBUG_INCREMENT_INSTANCE_COUNTER(CDhcpActiveLease);
//
// Reset our flags for this lease
//
m_dwTypeFlags = 0;
//
// Intialize our client type variable
//
m_bClientType = CLIENT_TYPE_NONE;
m_dhcpClientIpAddress = dhcpClient.QueryIpAddress();
m_strClientName = dhcpClient.QueryName();
m_strComment = dhcpClient.QueryComment();
//
// Check to see if this lease has an infinite expiration. If so, it's
// an active reservation. If the expiration is zero, then it's an inactive reservation.
//
DATE_TIME dt = dhcpClient.QueryExpiryDateTime();
m_leaseExpires.dwLowDateTime = dt.dwLowDateTime;
m_leaseExpires.dwHighDateTime = dt.dwHighDateTime;
if ( (dhcpClient.QueryExpiryDateTime().dwLowDateTime == DHCP_DATE_TIME_INFINIT_LOW) &&
(dhcpClient.QueryExpiryDateTime().dwHighDateTime == DHCP_DATE_TIME_INFINIT_HIGH) )
{
CString strBadAddress;
strBadAddress.LoadString(IDS_DHCP_BAD_ADDRESS);
//
// Bad addresses show up as active reservations, so we need to do the right thing.
//
if (strBadAddress.Compare(m_strClientName) == 0)
{
m_dwTypeFlags |= TYPE_FLAG_RESERVATION;
m_dwTypeFlags |= TYPE_FLAG_BAD_ADDRESS;
m_strLeaseExpires.LoadString(IDS_DHCP_LEASE_NOT_APPLICABLE);
}
else
{
//
// Assume infinite lease clients
//
m_strLeaseExpires.LoadString(IDS_INFINTE);
}
}
else
if ( (dhcpClient.QueryExpiryDateTime().dwLowDateTime == 0) &&
(dhcpClient.QueryExpiryDateTime().dwHighDateTime == 0) )
{
//
// This is an inactive reservation
//
m_dwTypeFlags |= TYPE_FLAG_RESERVATION;
m_strLeaseExpires.LoadString(IDS_DHCP_INFINITE_LEASE_INACTIVE);
}
else
{
//
// Generate the time the lease expires in a nicely formatted string
//
CTime timeTemp(m_leaseExpires);
m_timeLeaseExpires = timeTemp;
FormatDateTime(m_strLeaseExpires, &m_leaseExpires);
SYSTEMTIME st;
GetLocalTime(&st);
CTime systemTime(st);
if (systemTime > m_timeLeaseExpires)
m_dwTypeFlags |= TYPE_FLAG_GHOST;
}
if (dhcpClient.QueryHardwareAddress().GetSize() >= 3 &&
dhcpClient.QueryHardwareAddress()[0] == 'R' &&
dhcpClient.QueryHardwareAddress()[1] == 'A' &&
dhcpClient.QueryHardwareAddress()[2] == 'S')
{
m_dwTypeFlags |= TYPE_FLAG_RAS;
m_strUID = RAS_UID;
}
else
{
// build the client UID string
UtilCvtByteArrayToString(dhcpClient.QueryHardwareAddress(), m_strUID);
}
}
CDhcpActiveLease::~CDhcpActiveLease()
{
DEBUG_DECREMENT_INSTANCE_COUNTER(CDhcpActiveLease);
}
/*!--------------------------------------------------------------------------
CDhcpActiveLease::InitializeNode
Initializes node specific data
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT
CDhcpActiveLease::InitializeNode
(
ITFSNode * pNode
)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
CString strTemp;
BOOL bIsRes, bActive, bBad;
UtilCvtIpAddrToWstr (m_dhcpClientIpAddress,
&strTemp);
SetDisplayName(strTemp);
bIsRes = IsReservation(&bActive, &bBad);
// Make the node immediately visible
pNode->SetVisibilityState(TFS_VIS_SHOW);
pNode->SetData(TFS_DATA_COOKIE, (LPARAM) pNode);
pNode->SetData(TFS_DATA_USER, (LPARAM) this);
pNode->SetData(TFS_DATA_TYPE, DHCPSNAP_ACTIVE_LEASE);
int nImage = ICON_IDX_CLIENT;
// Figure out if we need a different icon for this lease
if (m_dwTypeFlags & TYPE_FLAG_RAS)
{
nImage = ICON_IDX_CLIENT_RAS;
}
else
if (m_dwTypeFlags & TYPE_FLAG_DNS_REG)
{
nImage = ICON_IDX_CLIENT_DNS_REGISTERING;
}
else
if (m_dwTypeFlags & TYPE_FLAG_DNS_UNREG)
{
nImage = ICON_IDX_CLIENT_EXPIRED;
}
else
if (m_dwTypeFlags & TYPE_FLAG_DOOMED)
{
nImage = ICON_IDX_CLIENT_EXPIRED;
}
else
if (bIsRes)
{
nImage = ICON_IDX_RES_CLIENT;
}
else
if (m_dwTypeFlags & TYPE_FLAG_GHOST)
{
nImage = ICON_IDX_CLIENT_EXPIRED;
}
pNode->SetData(TFS_DATA_IMAGEINDEX, nImage);
pNode->SetData(TFS_DATA_OPENIMAGEINDEX, nImage);
//SetColumnStringIDs(&aColumns[DHCPSNAP_ACTIVE_LEASES][0]);
//SetColumnWidths(&aColumnWidths[DHCPSNAP_ACTIVE_LEASES][0]);
return hrOK;
}
/*!--------------------------------------------------------------------------
CDhcpActiveLease::InitInfo
Helper to initialize data
Author: EricDav
---------------------------------------------------------------------------*/
void
CDhcpActiveLease::InitInfo(LPDHCP_CLIENT_INFO pDhcpClientInfo)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
m_dhcpClientIpAddress = pDhcpClientInfo->ClientIpAddress;
//
// Copy the client name if it has one
//
if (pDhcpClientInfo->ClientName)
{
m_strClientName = pDhcpClientInfo->ClientName;
//m_strClientName.MakeLower();
}
if (pDhcpClientInfo->ClientComment)
{
m_strComment = pDhcpClientInfo->ClientComment;
}
//
// Check to see if this lease has an infinite expiration. If so, it's
// an active reservation. If the expiration is zero, then it's an inactive reservation.
//
DATE_TIME dt = pDhcpClientInfo->ClientLeaseExpires;
m_leaseExpires.dwLowDateTime = dt.dwLowDateTime;
m_leaseExpires.dwHighDateTime = dt.dwHighDateTime;
if ( (pDhcpClientInfo->ClientLeaseExpires.dwLowDateTime == DHCP_DATE_TIME_INFINIT_LOW) &&
(pDhcpClientInfo->ClientLeaseExpires.dwHighDateTime == DHCP_DATE_TIME_INFINIT_HIGH) )
{
CString strBadAddress;
strBadAddress.LoadString(IDS_DHCP_BAD_ADDRESS);
//
// Bad addresses show up as active reservations, so we need to do the right thing.
//
if (strBadAddress.Compare(m_strClientName) == 0)
{
m_dwTypeFlags |= TYPE_FLAG_RESERVATION;
m_dwTypeFlags |= TYPE_FLAG_BAD_ADDRESS;
m_strLeaseExpires.LoadString(IDS_DHCP_LEASE_NOT_APPLICABLE);
}
else
{
//
// Assume infinite lease clients
//
m_strLeaseExpires.LoadString(IDS_INFINTE);
}
}
else
if ( (pDhcpClientInfo->ClientLeaseExpires.dwLowDateTime == 0) &&
(pDhcpClientInfo->ClientLeaseExpires.dwHighDateTime == 0) )
{
//
// This is an inactive reservation
//
m_dwTypeFlags |= TYPE_FLAG_RESERVATION;
m_strLeaseExpires.LoadString(IDS_DHCP_INFINITE_LEASE_INACTIVE);
}
else
{
//
// Generate the time the lease expires in a nicely formatted string
//
CTime timeTemp(m_leaseExpires);
m_timeLeaseExpires = timeTemp;
FormatDateTime(m_strLeaseExpires, &m_leaseExpires);
CTime timeCurrent = CTime::GetCurrentTime();
if (timeCurrent > m_timeLeaseExpires)
m_dwTypeFlags |= TYPE_FLAG_GHOST;
}
if (pDhcpClientInfo->ClientHardwareAddress.DataLength >= 3 &&
pDhcpClientInfo->ClientHardwareAddress.Data[0] == 'R' &&
pDhcpClientInfo->ClientHardwareAddress.Data[1] == 'A' &&
pDhcpClientInfo->ClientHardwareAddress.Data[2] == 'S')
{
m_dwTypeFlags |= TYPE_FLAG_RAS;
m_strUID = RAS_UID;
}
else
{
// build the client UID string
CByteArray baUID;
for (DWORD i = 0; i < pDhcpClientInfo->ClientHardwareAddress.DataLength; i++)
{
baUID.Add(pDhcpClientInfo->ClientHardwareAddress.Data[i]);
}
UtilCvtByteArrayToString(baUID, m_strUID);
}
}
/*!--------------------------------------------------------------------------
CDhcpActiveLease::AddMenuItems
Implementation of ITFSResultHandler::AddMenuItems
Author: EricDav
---------------------------------------------------------------------------*/
STDMETHODIMP
CDhcpActiveLease::AddMenuItems
(
ITFSComponent * pComponent,
MMC_COOKIE cookie,
LPDATAOBJECT pDataObject,
LPCONTEXTMENUCALLBACK pContextMenuCallback,
long * pInsertionAllowed
)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
HRESULT hr;
return hrOK;
}
/*!--------------------------------------------------------------------------
CDhcpActiveLease::Command
Implementation of ITFSResultHandler::Command
Author: EricDav
---------------------------------------------------------------------------*/
STDMETHODIMP
CDhcpActiveLease::Command
(
ITFSComponent * pComponent,
MMC_COOKIE cookie,
int nCommandID,
LPDATAOBJECT pDataObject
)
{
return hrOK;
}
/*!--------------------------------------------------------------------------
CDhcpActiveLease::CreatePropertyPages
Description
Author: EricDav
---------------------------------------------------------------------------*/
STDMETHODIMP
CDhcpActiveLease::CreatePropertyPages
(
ITFSComponent * pComponent,
MMC_COOKIE cookie,
LPPROPERTYSHEETCALLBACK lpProvider,
LPDATAOBJECT pDataObject,
LONG_PTR handle
)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
HRESULT hr = hrOK;
SPITFSNode spNode;
m_spNodeMgr->FindNode(cookie, &spNode);
hr = DoPropSheet(spNode, lpProvider, handle);
return hr;
}
/*!--------------------------------------------------------------------------
Function
Description
Author: EricDav
---------------------------------------------------------------------------*/
STDMETHODIMP_(LPCTSTR)
CDhcpActiveLease::GetString
(
ITFSComponent * pComponent,
MMC_COOKIE cookie,
int nCol
)
{
switch (nCol)
{
case 0:
return GetDisplayName();
case 1:
return m_strClientName;
case 2:
return (LPCWSTR)m_strLeaseExpires;
case 3:
return GetClientType();
case 4:
return m_strUID;
case 5:
return m_strComment;
}
return NULL;
}
/*!--------------------------------------------------------------------------
Function
Description
Author: EricDav
---------------------------------------------------------------------------*/
LPCTSTR
CDhcpActiveLease::GetClientType()
{
// set the default return value
LPCTSTR pszReturn = g_szClientTypeUnknown;
// this one must come before the check for DHCP or BOOTP
// because it is a combination of both flags
if ((m_bClientType & CLIENT_TYPE_BOTH) == CLIENT_TYPE_BOTH)
{
pszReturn = g_szClientTypeBoth;
}
else
if (m_bClientType & CLIENT_TYPE_DHCP)
{
pszReturn = g_szClientTypeDhcp;
}
else
if (m_bClientType & CLIENT_TYPE_BOOTP)
{
pszReturn = g_szClientTypeBootp;
}
else
if (m_bClientType & CLIENT_TYPE_NONE)
{
pszReturn = g_szClientTypeNone;
}
else
if (m_bClientType & CLIENT_TYPE_UNSPECIFIED)
{
pszReturn = g_szClientTypeUnspecified;
}
else
{
Assert1(FALSE, "CDhcpActiveLease::GetClientType - Unknown client type %d", m_bClientType);
}
return pszReturn;
}
/*!--------------------------------------------------------------------------
Function
Description
Author: EricDav
---------------------------------------------------------------------------*/
void
CDhcpActiveLease::GetLeaseExpirationTime
(
CTime & time
)
{
time = m_timeLeaseExpires;
}
/*!--------------------------------------------------------------------------
Function
Description
Author: EricDav
---------------------------------------------------------------------------*/
BOOL
CDhcpActiveLease::IsReservation
(
BOOL * pbIsActive,
BOOL * pbIsBad
)
{
BOOL bIsReservation = FALSE;
*pbIsBad = FALSE;
/* if ( (m_dhcpClientInfo.ClientLeaseExpires.dwLowDateTime == DHCP_DATE_TIME_INFINIT_LOW) &&
(m_dhcpClientInfo.ClientLeaseExpires.dwHighDateTime == DHCP_DATE_TIME_INFINIT_HIGH) )
{
//
// This is an active reservation
//
bIsReservation = TRUE;
*pbIsActive = TRUE;
*pbIsBad = IsBadAddress();
}
else
if ( (m_dhcpClientInfo.ClientLeaseExpires.dwLowDateTime == 0) &&
(m_dhcpClientInfo.ClientLeaseExpires.dwHighDateTime == 0) )
{
//
// This is an inactive reservation
//
bIsReservation = TRUE;
*pbIsActive = FALSE;
}
*/
*pbIsActive = m_dwTypeFlags & TYPE_FLAG_ACTIVE;
*pbIsBad = m_dwTypeFlags & TYPE_FLAG_BAD_ADDRESS;
return bIsReservation = m_dwTypeFlags & TYPE_FLAG_RESERVATION;
}
/*!--------------------------------------------------------------------------
Function
Description
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT
CDhcpActiveLease::DoPropSheet
(
ITFSNode * pNode,
LPPROPERTYSHEETCALLBACK lpProvider,
LONG_PTR handle
)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
HRESULT hr = hrOK;
return hr;
}
/*!--------------------------------------------------------------------------
Function
Description
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT
CDhcpActiveLease::SetClientName
(
LPCTSTR pName
)
{
if (pName != NULL)
{
m_strClientName = pName;
}
else
{
m_strClientName.Empty();
}
return hrOK;
}
/*!--------------------------------------------------------------------------
CDhcpActiveLease::SetReservation
Description
Author: EricDav
---------------------------------------------------------------------------*/
void
CDhcpActiveLease::SetReservation(BOOL fReservation)
{
if (fReservation)
{
if ( (m_leaseExpires.dwLowDateTime == DHCP_DATE_TIME_INFINIT_LOW) &&
(m_leaseExpires.dwHighDateTime == DHCP_DATE_TIME_INFINIT_HIGH) )
{
//
// This is an active reservation
//
m_dwTypeFlags |= TYPE_FLAG_RESERVATION;
m_dwTypeFlags |= TYPE_FLAG_ACTIVE;
m_strLeaseExpires.LoadString(IDS_DHCP_INFINITE_LEASE_ACTIVE);
}
else
if ( (m_leaseExpires.dwLowDateTime == 0) &&
(m_leaseExpires.dwHighDateTime == 0) )
{
m_dwTypeFlags |= TYPE_FLAG_RESERVATION;
m_strLeaseExpires.LoadString(IDS_DHCP_INFINITE_LEASE_INACTIVE);
}
else
{
Trace1("CDhcpActiveLease::SetReservation - %lx does not have a valid reservation lease time!", m_dhcpClientIpAddress);
}
}
else
{
m_dwTypeFlags &= ~TYPE_FLAG_RESERVATION;
m_dwTypeFlags &= ~TYPE_FLAG_ACTIVE;
}
}
/*!--------------------------------------------------------------------------
CDhcpActiveLease::OnResultRefresh
Forwards refresh to parent to handle
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT CDhcpActiveLease::OnResultRefresh(ITFSComponent * pComponent, LPDATAOBJECT pDataObject, MMC_COOKIE cookie, LPARAM arg, LPARAM lParam)
{
HRESULT hr = hrOK;
SPITFSNode spNode, spParent;
SPITFSResultHandler spParentRH;
m_spNodeMgr->FindNode(cookie, &spNode);
// forward this command to the parent to handle
CORg (spNode->GetParent(&spParent));
CORg (spParent->GetResultHandler(&spParentRH));
CORg (spParentRH->Notify(pComponent, spParent->GetData(TFS_DATA_COOKIE), pDataObject, MMCN_REFRESH, arg, lParam));
Error:
return hrOK;
}
/*---------------------------------------------------------------------------
Class CDhcpAllocationRange implementation
---------------------------------------------------------------------------*/
/*!--------------------------------------------------------------------------
Function
Description
Author: EricDav
---------------------------------------------------------------------------*/
CDhcpAllocationRange::CDhcpAllocationRange
(
ITFSComponentData * pTFSCompData,
DHCP_IP_RANGE * pdhcpIpRange
) : CDhcpHandler(pTFSCompData)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
SetAddr (pdhcpIpRange->StartAddress, TRUE);
SetAddr (pdhcpIpRange->EndAddress, FALSE);
// now do the ending IP address
//
UtilCvtIpAddrToWstr (pdhcpIpRange->EndAddress,
&m_strEndIpAddress);
// and finally the description
//
m_strDescription.LoadString(IDS_ALLOCATION_RANGE_DESCRIPTION);
}
/*!--------------------------------------------------------------------------
Function
Description
Author: EricDav
---------------------------------------------------------------------------*/
CDhcpAllocationRange::CDhcpAllocationRange
(
ITFSComponentData * pTFSCompData,
DHCP_BOOTP_IP_RANGE * pdhcpIpRange
) : CDhcpHandler(pTFSCompData)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
SetAddr (pdhcpIpRange->StartAddress, TRUE);
SetAddr (pdhcpIpRange->EndAddress, FALSE);
m_BootpAllocated = pdhcpIpRange->BootpAllocated;
m_MaxBootpAllowed = pdhcpIpRange->MaxBootpAllowed;
// now do the ending IP address
//
UtilCvtIpAddrToWstr (pdhcpIpRange->EndAddress,
&m_strEndIpAddress);
// and finally the description
//
m_strDescription.LoadString(IDS_ALLOCATION_RANGE_DESCRIPTION);
}
/*!--------------------------------------------------------------------------
CDhcpAllocationRange::InitializeNode
Initializes node specific data
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT
CDhcpAllocationRange::InitializeNode
(
ITFSNode * pNode
)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
CString strTemp;
UtilCvtIpAddrToWstr (QueryAddr(TRUE), &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, ICON_IDX_ALLOCATION_RANGE);
pNode->SetData(TFS_DATA_OPENIMAGEINDEX, ICON_IDX_ALLOCATION_RANGE);
pNode->SetData(TFS_DATA_USER, (LPARAM) this);
pNode->SetData(TFS_DATA_TYPE, DHCPSNAP_ALLOCATION_RANGE);
//SetColumnStringIDs(&aColumns[DHCPSNAP_ACTIVE_LEASES][0]);
//SetColumnWidths(&aColumnWidths[DHCPSNAP_ACTIVE_LEASES][0]);
return hrOK;
}
/*!--------------------------------------------------------------------------
Function
Description
Author: EricDav
---------------------------------------------------------------------------*/
STDMETHODIMP_(LPCTSTR)
CDhcpAllocationRange::GetString
(
ITFSComponent * pComponent,
MMC_COOKIE cookie,
int nCol
)
{
switch (nCol)
{
case 0:
return GetDisplayName();
case 1:
return (LPCWSTR)m_strEndIpAddress;
case 2:
return (LPCWSTR)m_strDescription;
}
return NULL;
}
/*!--------------------------------------------------------------------------
CDhcpAllocationRange::OnResultRefresh
Forwards refresh to parent to handle
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT CDhcpAllocationRange::OnResultRefresh(ITFSComponent * pComponent, LPDATAOBJECT pDataObject, MMC_COOKIE cookie, LPARAM arg, LPARAM lParam)
{
HRESULT hr = hrOK;
SPITFSNode spNode, spParent;
SPITFSResultHandler spParentRH;
m_spNodeMgr->FindNode(cookie, &spNode);
// forward this command to the parent to handle
CORg (spNode->GetParent(&spParent));
CORg (spParent->GetResultHandler(&spParentRH));
CORg (spParentRH->Notify(pComponent, spParent->GetData(TFS_DATA_COOKIE), pDataObject, MMCN_REFRESH, arg, lParam));
Error:
return hrOK;
}
/*---------------------------------------------------------------------------
Class CDhcpExclusionRange implementation
---------------------------------------------------------------------------*/
/*!--------------------------------------------------------------------------
Function
Description
Author: EricDav
---------------------------------------------------------------------------*/
CDhcpExclusionRange::CDhcpExclusionRange
(
ITFSComponentData * pTFSCompData,
DHCP_IP_RANGE * pdhcpIpRange
) : CDhcpHandler(pTFSCompData)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
SetAddr (pdhcpIpRange->StartAddress, TRUE);
SetAddr (pdhcpIpRange->EndAddress, FALSE);
// now do the ending IP address
//
UtilCvtIpAddrToWstr (pdhcpIpRange->EndAddress,
&m_strEndIpAddress);
// and finally the description
//
m_strDescription.LoadString(IDS_EXCLUSION_RANGE_DESCRIPTION);
}
/*!--------------------------------------------------------------------------
CDhcpExclusionRange::InitializeNode
Initializes node specific data
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT
CDhcpExclusionRange::InitializeNode
(
ITFSNode * pNode
)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
CString strTemp;
UtilCvtIpAddrToWstr (QueryAddr(TRUE), &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, ICON_IDX_EXCLUSION_RANGE);
pNode->SetData(TFS_DATA_OPENIMAGEINDEX, ICON_IDX_EXCLUSION_RANGE);
pNode->SetData(TFS_DATA_USER, (LPARAM) this);
pNode->SetData(TFS_DATA_TYPE, DHCPSNAP_EXCLUSION_RANGE);
//SetColumnStringIDs(&aColumns[DHCPSNAP_ACTIVE_LEASES][0]);
//SetColumnWidths(&aColumnWidths[DHCPSNAP_ACTIVE_LEASES][0]);
return hrOK;
}
/*!--------------------------------------------------------------------------
CDhcpExclusionRange::OnResultSelect
Description
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT
CDhcpExclusionRange::OnResultSelect
(
ITFSComponent * pComponent,
LPDATAOBJECT pDataObject,
MMC_COOKIE cookie,
LPARAM arg,
LPARAM lParam
)
{
HRESULT hr = hrOK;
SPIConsoleVerb spConsoleVerb;
SPITFSNode spNode;
CTFSNodeList listSelectedNodes;
BOOL bEnable = FALSE;
BOOL bStates[ARRAYLEN(g_ConsoleVerbs)];
int i;
CORg (pComponent->GetConsoleVerb(&spConsoleVerb));
CORg (m_spNodeMgr->FindNode(cookie, &spNode));
// build the list of selected nodes
hr = BuildSelectedItemList(pComponent, &listSelectedNodes);
// walk the list of selected items. Make sure an allocation range isn't
// selected. If it is, don't enable the delete key
if (listSelectedNodes.GetCount() > 0)
{
BOOL bAllocRangeSelected = FALSE;
POSITION pos;
ITFSNode * pNode;
pos = listSelectedNodes.GetHeadPosition();
while (pos)
{
pNode = listSelectedNodes.GetNext(pos);
if (pNode->GetData(TFS_DATA_TYPE) == DHCPSNAP_ALLOCATION_RANGE)
{
bAllocRangeSelected = TRUE;
break;
}
}
if (!bAllocRangeSelected)
bEnable = TRUE;
}
for (i = 0; i < ARRAYLEN(g_ConsoleVerbs); bStates[i++] = bEnable);
EnableVerbs(spConsoleVerb, g_ConsoleVerbStates[spNode->GetData(TFS_DATA_TYPE)], bStates);
Error:
return hr;
}
/*!--------------------------------------------------------------------------
Function
Description
Author: EricDav
---------------------------------------------------------------------------*/
STDMETHODIMP_(LPCTSTR)
CDhcpExclusionRange::GetString
(
ITFSComponent * pComponent,
MMC_COOKIE cookie,
int nCol
)
{
switch (nCol)
{
case 0:
return GetDisplayName();
case 1:
return (LPCWSTR)m_strEndIpAddress;
case 2:
return (LPCWSTR)m_strDescription;
}
return NULL;
}
/*!--------------------------------------------------------------------------
CDhcpExclusionRange::OnResultRefresh
Forwards refresh to parent to handle
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT CDhcpExclusionRange::OnResultRefresh(ITFSComponent * pComponent, LPDATAOBJECT pDataObject, MMC_COOKIE cookie, LPARAM arg, LPARAM lParam)
{
HRESULT hr = hrOK;
SPITFSNode spNode, spParent;
SPITFSResultHandler spParentRH;
m_spNodeMgr->FindNode(cookie, &spNode);
// forward this command to the parent to handle
CORg (spNode->GetParent(&spParent));
CORg (spParent->GetResultHandler(&spParentRH));
CORg (spParentRH->Notify(pComponent, spParent->GetData(TFS_DATA_COOKIE), pDataObject, MMCN_REFRESH, arg, lParam));
Error:
return hrOK;
}
/*---------------------------------------------------------------------------
Class CDhcpBootpEntry implementation
---------------------------------------------------------------------------*/
/*!--------------------------------------------------------------------------
Constructor
Description
Author: EricDav
---------------------------------------------------------------------------*/
CDhcpBootpEntry::CDhcpBootpEntry
(
ITFSComponentData * pTFSCompData
) : CDhcpHandler(pTFSCompData)
{
}
/*!--------------------------------------------------------------------------
CDhcpBootpEntry::InitializeNode
Initializes node specific data
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT
CDhcpBootpEntry::InitializeNode
(
ITFSNode * pNode
)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
SetDisplayName(m_strBootImage);
// Make the node immediately visible
pNode->SetVisibilityState(TFS_VIS_SHOW);
pNode->SetData(TFS_DATA_COOKIE, (LPARAM) pNode);
pNode->SetData(TFS_DATA_IMAGEINDEX, ICON_IDX_BOOTP_ENTRY);
pNode->SetData(TFS_DATA_OPENIMAGEINDEX, ICON_IDX_BOOTP_ENTRY);
pNode->SetData(TFS_DATA_USER, (LPARAM) this);
pNode->SetData(TFS_DATA_TYPE, DHCPSNAP_BOOTP_ENTRY);
//SetColumnStringIDs(&aColumns[DHCPSNAP_ACTIVE_LEASES][0]);
//SetColumnWidths(&aColumnWidths[DHCPSNAP_ACTIVE_LEASES][0]);
return hrOK;
}
/*!--------------------------------------------------------------------------
Function
Description
Author: EricDav
---------------------------------------------------------------------------*/
STDMETHODIMP
CDhcpBootpEntry::CreatePropertyPages
(
ITFSComponent * pComponent,
MMC_COOKIE cookie,
LPPROPERTYSHEETCALLBACK lpProvider,
LPDATAOBJECT pDataObject,
LONG_PTR handle
)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
//
// Create the property page
//
SPITFSNode spNode;
m_spNodeMgr->FindNode(cookie, &spNode);
SPIComponentData spComponentData;
m_spNodeMgr->GetComponentData(&spComponentData);
CBootpProperties * pBootpProp =
new CBootpProperties(spNode, spComponentData, m_spTFSCompData, NULL);
pBootpProp->m_pageGeneral.m_strFileName = QueryFileName();
pBootpProp->m_pageGeneral.m_strFileServer = QueryFileServer();
pBootpProp->m_pageGeneral.m_strImageName = QueryBootImage();
//
// Object gets deleted when the page is destroyed
//
Assert(lpProvider != NULL);
return pBootpProp->CreateModelessSheet(lpProvider, handle);
}
/*---------------------------------------------------------------------------
CDhcpBootpEntry::OnPropertyChange
Description
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT
CDhcpBootpEntry::OnResultPropertyChange
(
ITFSComponent * pComponent,
LPDATAOBJECT pDataObject,
MMC_COOKIE cookie,
LPARAM arg,
LPARAM param
)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
SPITFSNode spNode;
m_spNodeMgr->FindNode(cookie, &spNode);
CBootpProperties * pBootpProp = reinterpret_cast<CBootpProperties *>(param);
LONG_PTR changeMask = 0;
// tell the property page to do whatever now that we are back on the
// main thread
pBootpProp->OnPropertyChange(TRUE, &changeMask);
pBootpProp->AcknowledgeNotify();
if (changeMask)
spNode->ChangeNode(changeMask);
return hrOK;
}
/*!--------------------------------------------------------------------------
CDhcpBootpEntry::GetString
Description
Author: EricDav
---------------------------------------------------------------------------*/
STDMETHODIMP_(LPCTSTR)
CDhcpBootpEntry::GetString
(
ITFSComponent * pComponent,
MMC_COOKIE cookie,
int nCol
)
{
switch (nCol)
{
case 0:
return QueryBootImage();
case 1:
return QueryFileName();
case 2:
return QueryFileServer();
}
return NULL;
}
/*!--------------------------------------------------------------------------
CDhcpBootpEntry::OnResultRefresh
Forwards refresh to parent to handle
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT CDhcpBootpEntry::OnResultRefresh(ITFSComponent * pComponent, LPDATAOBJECT pDataObject, MMC_COOKIE cookie, LPARAM arg, LPARAM lParam)
{
HRESULT hr = hrOK;
SPITFSNode spNode, spParent;
SPITFSResultHandler spParentRH;
m_spNodeMgr->FindNode(cookie, &spNode);
// forward this command to the parent to handle
CORg (spNode->GetParent(&spParent));
CORg (spParent->GetResultHandler(&spParentRH));
CORg (spParentRH->Notify(pComponent, spParent->GetData(TFS_DATA_COOKIE), pDataObject, MMCN_REFRESH, arg, lParam));
Error:
return hrOK;
}
/*!--------------------------------------------------------------------------
CDhcpBootpEntry::operator ==
Description
Author: EricDav
---------------------------------------------------------------------------*/
BOOL
CDhcpBootpEntry::operator ==
(
CDhcpBootpEntry & bootpEntry
)
{
CString strBootImage, strFileName, strFileServer;
strBootImage = bootpEntry.QueryBootImage();
strFileName = bootpEntry.QueryFileName();
strFileServer = bootpEntry.QueryFileServer();
if ( (m_strBootImage.CompareNoCase(strBootImage) == 0) &&
(m_strFileName.CompareNoCase(strFileName) == 0) &&
(m_strFileServer.CompareNoCase(strFileServer) == 0) )
{
return TRUE;
}
else
{
return FALSE;
}
}
/*!--------------------------------------------------------------------------
CDhcpBootpEntry::InitData
Description
Author: EricDav
---------------------------------------------------------------------------*/
WCHAR *
CDhcpBootpEntry::InitData
(
CONST WCHAR grszwBootTable[], // IN: Group of strings for the boot table
DWORD dwLength
)
{
ASSERT(grszwBootTable != NULL);
CONST WCHAR * pszw;
pszw = PchParseUnicodeString(IN grszwBootTable, dwLength, OUT m_strBootImage);
ASSERT(*pszw == BOOT_FILE_STRING_DELIMITER_W);
dwLength -= ((m_strBootImage.GetLength() + 1) * sizeof(TCHAR));
pszw = PchParseUnicodeString(IN pszw + 1, dwLength, OUT m_strFileServer);
ASSERT(*pszw == BOOT_FILE_STRING_DELIMITER_W);
dwLength -= ((m_strFileServer.GetLength() + 1) * sizeof(TCHAR));
pszw = PchParseUnicodeString(IN pszw + 1, dwLength, OUT m_strFileName);
ASSERT(*pszw == '\0');
dwLength -= (m_strFileName.GetLength() * sizeof(TCHAR));
Assert(dwLength >= 0);
return const_cast<WCHAR *>(pszw + 1);
}
/*!--------------------------------------------------------------------------
Function
Compute the length (number of characters) necessary
to store the BOOTP entry. Additional characters
are added for extra security.
Author: EricDav
---------------------------------------------------------------------------*/
int
CDhcpBootpEntry::CchGetDataLength()
{
return 16 + m_strBootImage.GetLength() + m_strFileName.GetLength() + m_strFileServer.GetLength();
}
/*!--------------------------------------------------------------------------
Function
Write the data into a formatted string.
Author: EricDav
---------------------------------------------------------------------------*/
WCHAR *
CDhcpBootpEntry::PchStoreData
(
OUT WCHAR szwBuffer[]
)
{
int cch;
cch = wsprintfW(OUT szwBuffer, L"%s,%s,%s",
(LPCTSTR)m_strBootImage,
(LPCTSTR)m_strFileServer,
(LPCTSTR)m_strFileName);
ASSERT(cch > 0);
ASSERT(cch + 4 < CchGetDataLength());
return const_cast<WCHAR *>(szwBuffer + cch + 1);
}
/*---------------------------------------------------------------------------
Class CDhcpOptionItem implementation
---------------------------------------------------------------------------*/
DEBUG_DECLARE_INSTANCE_COUNTER(CDhcpOptionItem);
/*!--------------------------------------------------------------------------
Function
Description
Author: EricDav
---------------------------------------------------------------------------*/
CDhcpOptionItem::CDhcpOptionItem
(
ITFSComponentData * pTFSCompData,
LPDHCP_OPTION_VALUE pOptionValue,
int nOptionImage
) : CDhcpOptionValue(*pOptionValue),
CDhcpHandler(pTFSCompData)
{
DEBUG_INCREMENT_INSTANCE_COUNTER(CDhcpOptionItem);
//
// initialize this node
//
m_nOptionImage = nOptionImage;
m_dhcpOptionId = pOptionValue->OptionID;
// assume non-vendor option
SetVendor(NULL);
m_verbDefault = MMC_VERB_PROPERTIES;
}
/*!--------------------------------------------------------------------------
Function
Description
Author: EricDav
---------------------------------------------------------------------------*/
CDhcpOptionItem::CDhcpOptionItem
(
ITFSComponentData * pTFSCompData,
CDhcpOption * pOption,
int nOptionImage
) : CDhcpOptionValue(pOption->QueryValue()),
CDhcpHandler(pTFSCompData)
{
DEBUG_INCREMENT_INSTANCE_COUNTER(CDhcpOptionItem);
//
// initialize this node
//
m_nOptionImage = nOptionImage;
m_dhcpOptionId = pOption->QueryId();
// assume non-vendor option
if (pOption->IsVendor())
SetVendor(pOption->GetVendor());
else
SetVendor(NULL);
SetClassName(pOption->GetClassName());
m_verbDefault = MMC_VERB_PROPERTIES;
}
CDhcpOptionItem::~CDhcpOptionItem()
{
DEBUG_DECREMENT_INSTANCE_COUNTER(CDhcpOptionItem);
}
/*!--------------------------------------------------------------------------
CDhcpOptionItem::InitializeNode
Initializes node specific data
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT
CDhcpOptionItem::InitializeNode
(
ITFSNode * pNode
)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
// Make the node immediately visible
pNode->SetVisibilityState(TFS_VIS_SHOW);
pNode->SetData(TFS_DATA_COOKIE, (LPARAM) pNode);
pNode->SetData(TFS_DATA_IMAGEINDEX, m_nOptionImage);
pNode->SetData(TFS_DATA_OPENIMAGEINDEX, m_nOptionImage);
pNode->SetData(TFS_DATA_USER, (LPARAM) this);
pNode->SetData(TFS_DATA_TYPE, DHCPSNAP_OPTION_ITEM);
//SetColumnStringIDs(&aColumns[DHCPSNAP_ACTIVE_LEASES][0]);
//SetColumnWidths(&aColumnWidths[DHCPSNAP_ACTIVE_LEASES][0]);
return hrOK;
}
/*!--------------------------------------------------------------------------
Function
Description
Author: EricDav
---------------------------------------------------------------------------*/
STDMETHODIMP_(LPCTSTR)
CDhcpOptionItem::GetString
(
ITFSComponent * pComponent,
MMC_COOKIE cookie,
int nCol
)
{
SPITFSNode spNode;
m_spNodeMgr->FindNode(cookie, &spNode);
CDhcpOption * pOptionInfo = FindOptionDefinition(pComponent, spNode);
switch (nCol)
{
case 0:
{
if (pOptionInfo)
pOptionInfo->QueryDisplayName(m_strName);
else
m_strName.LoadString(IDS_UNKNOWN);
return m_strName;
}
case 1:
return m_strVendorDisplay;
case 2:
{
if (pOptionInfo)
{
// special case the CSR option
BOOL fRouteArray = (
!pOptionInfo->IsClassOption() &&
(DHCP_OPTION_ID_CSR == pOptionInfo->QueryId()) &&
DhcpUnaryElementTypeOption ==
pOptionInfo->QueryOptType() &&
DhcpBinaryDataOption == pOptionInfo->QueryDataType()
);
if( !fRouteArray )
QueryDisplayString(m_strValue, FALSE);
else
QueryRouteArrayDisplayString(m_strValue);
}
else
m_strName.LoadString(IDS_UNKNOWN);
return m_strValue;
}
case 3:
if (IsClassOption())
return m_strClassName;
else
{
if (g_szClientTypeNone.IsEmpty())
g_szClientTypeNone.LoadString(IDS_NONE);
return g_szClientTypeNone;
}
}
return NULL;
}
/*!--------------------------------------------------------------------------
Function
Description
Author: EricDav
---------------------------------------------------------------------------*/
STDMETHODIMP
CDhcpOptionItem::CreatePropertyPages
(
ITFSComponent * pComponent,
MMC_COOKIE cookie,
LPPROPERTYSHEETCALLBACK lpProvider,
LPDATAOBJECT pDataObject,
LONG_PTR handle
)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
//
// Create the property page
//
CPropertyPageHolderBase * pPropSheet;
SPITFSNode spSelectedNode, spNode, spOptCfgNode, spServerNode;
CString strOptCfgTitle, strOptType;
COptionValueEnum * pOptionValueEnum = NULL;
m_spNodeMgr->FindNode(cookie, &spNode);
SPIComponentData spComponentData;
m_spNodeMgr->GetComponentData(&spComponentData);
pComponent->GetSelectedNode(&spSelectedNode);
switch (spSelectedNode->GetData(TFS_DATA_TYPE))
{
case DHCPSNAP_GLOBAL_OPTIONS:
{
SPITFSNode spGlobalOptions;
// get some node information
spNode->GetParent(&spGlobalOptions);
spGlobalOptions->GetParent(&spServerNode);
CDhcpGlobalOptions * pGlobalOptions = GETHANDLER(CDhcpGlobalOptions, spGlobalOptions);
if (pGlobalOptions->HasPropSheetsOpen())
{
pGlobalOptions->GetOpenPropSheet(0, &pPropSheet);
pPropSheet->SetActiveWindow();
::PostMessage(PropSheet_GetCurrentPageHwnd(pPropSheet->GetSheetWindow()), WM_SELECTOPTION, (WPARAM) this, 0);
return E_FAIL;
}
// get some context info
pOptionValueEnum = pGlobalOptions->GetServerObject(spGlobalOptions)->GetOptionValueEnum();
spOptCfgNode.Set(spGlobalOptions);
// setup the page title
strOptType.LoadString(IDS_CONFIGURE_OPTIONS_GLOBAL);
AfxFormatString1(strOptCfgTitle, IDS_CONFIGURE_OPTIONS_TITLE, strOptType);
}
break;
case DHCPSNAP_SCOPE_OPTIONS:
{
// only the option type of this node can be configured here...
if (spNode->GetData(TFS_DATA_IMAGEINDEX) != ICON_IDX_SCOPE_OPTION_LEAF)
{
AfxMessageBox(IDS_CONNOT_CONFIGURE_OPTION_SCOPE);
return E_FAIL;
}
SPITFSNode spScopeOptions;
spNode->GetParent(&spScopeOptions);
// check to see if the page is already open, if so just activate it and
// set the current option to this one.
CDhcpScopeOptions * pScopeOptions = GETHANDLER(CDhcpScopeOptions, spScopeOptions);
spServerNode = pScopeOptions->GetServerNode(spScopeOptions);
if (pScopeOptions->HasPropSheetsOpen())
{
// found it, activate
pScopeOptions->GetOpenPropSheet(0, &pPropSheet);
pPropSheet->SetActiveWindow();
::PostMessage(PropSheet_GetCurrentPageHwnd(pPropSheet->GetSheetWindow()), WM_SELECTOPTION, (WPARAM) this, 0);
return E_FAIL;
}
// prepare to create a new page
pOptionValueEnum = pScopeOptions->GetScopeObject(spScopeOptions)->GetOptionValueEnum();
spOptCfgNode.Set(spScopeOptions);
strOptType.LoadString(IDS_CONFIGURE_OPTIONS_SCOPE);
AfxFormatString1(strOptCfgTitle, IDS_CONFIGURE_OPTIONS_TITLE, strOptType);
}
break;
case DHCPSNAP_RESERVATION_CLIENT:
{
// only the option type of this node can be configured here...
if (spNode->GetData(TFS_DATA_IMAGEINDEX) != ICON_IDX_CLIENT_OPTION_LEAF)
{
AfxMessageBox(IDS_CONNOT_CONFIGURE_OPTION_RES);
return E_FAIL;
}
SPITFSNode spResClient;
spNode->GetParent(&spResClient);
CDhcpReservationClient * pResClient = GETHANDLER(CDhcpReservationClient, spResClient);
spServerNode = pResClient->GetServerNode(spResClient, TRUE);
strOptType.LoadString(IDS_CONFIGURE_OPTIONS_CLIENT);
AfxFormatString1(strOptCfgTitle, IDS_CONFIGURE_OPTIONS_TITLE, strOptType);
// search the open prop pages to see if the option config page is up
// since the option config page is technically a property sheet for the node.
for (int i = 0; i < pResClient->HasPropSheetsOpen(); i++)
{
pResClient->GetOpenPropSheet(i, &pPropSheet);
HWND hwnd = pPropSheet->GetSheetWindow();
CString strTitle;
::GetWindowText(hwnd, strTitle.GetBuffer(256), 256);
strTitle.ReleaseBuffer();
if (strTitle == strOptCfgTitle)
{
// found it, activate
pPropSheet->SetActiveWindow();
::PostMessage(PropSheet_GetCurrentPageHwnd(pPropSheet->GetSheetWindow()), WM_SELECTOPTION, (WPARAM) this, 0);
return E_FAIL;
}
}
// no page up, get ready to create one
pOptionValueEnum = pResClient->GetOptionValueEnum();
spOptCfgNode.Set(spResClient);
}
break;
}
COptionsConfig * pOptionsConfig =
new COptionsConfig(spOptCfgNode, spServerNode, spComponentData, m_spTFSCompData, pOptionValueEnum, strOptCfgTitle, this);
//
// Object gets deleted when the page is destroyed
//
Assert(lpProvider != NULL);
return pOptionsConfig->CreateModelessSheet(lpProvider, handle);
}
/*!--------------------------------------------------------------------------
Function
Description
Author: EricDav
---------------------------------------------------------------------------*/
CDhcpOption *
CDhcpOptionItem::FindOptionDefinition
(
ITFSComponent * pComponent,
ITFSNode * pNode
)
{
SPITFSNode spSelectedNode;
CDhcpServer * pServer = NULL;
pComponent->GetSelectedNode(&spSelectedNode);
switch (spSelectedNode->GetData(TFS_DATA_TYPE))
{
case DHCPSNAP_GLOBAL_OPTIONS:
{
SPITFSNode spServer;
spSelectedNode->GetParent(&spServer);
pServer = GETHANDLER(CDhcpServer, spServer);
}
break;
case DHCPSNAP_SCOPE_OPTIONS:
{
CDhcpScopeOptions * pScopeOptions = GETHANDLER(CDhcpScopeOptions, spSelectedNode);
CDhcpScope * pScopeObject = pScopeOptions->GetScopeObject(spSelectedNode);
pServer = pScopeObject->GetServerObject();
}
break;
case DHCPSNAP_RESERVATION_CLIENT:
{
CDhcpReservationClient * pResClient = GETHANDLER(CDhcpReservationClient, spSelectedNode);
CDhcpScope * pScopeObject = pResClient->GetScopeObject(spSelectedNode, TRUE);
pServer = pScopeObject->GetServerObject();
}
break;
default:
//ASSERT(FALSE);
break;
}
if (pServer)
{
return pServer->FindOption(m_dhcpOptionId, GetVendor());
}
else
{
return NULL;
}
}
void
CDhcpOptionItem::SetVendor
(
LPCTSTR pszVendor
)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
if (pszVendor == NULL)
m_strVendorDisplay.LoadString (IDS_VENDOR_STANDARD);
else
m_strVendorDisplay = pszVendor;
m_strVendor = pszVendor;
}
/*!--------------------------------------------------------------------------
CDhcpOptionItem::OnResultRefresh
Forwards refresh to parent to handle
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT CDhcpOptionItem::OnResultRefresh(ITFSComponent * pComponent, LPDATAOBJECT pDataObject, MMC_COOKIE cookie, LPARAM arg, LPARAM lParam)
{
HRESULT hr = hrOK;
SPITFSNode spNode, spParent;
SPITFSResultHandler spParentRH;
m_spNodeMgr->FindNode(cookie, &spNode);
// forward this command to the parent to handle
CORg (spNode->GetParent(&spParent));
CORg (spParent->GetResultHandler(&spParentRH));
CORg (spParentRH->Notify(pComponent, spParent->GetData(TFS_DATA_COOKIE), pDataObject, MMCN_REFRESH, arg, lParam));
Error:
return hrOK;
}
/*---------------------------------------------------------------------------
Class CDhcpMCastLease implementation
---------------------------------------------------------------------------*/
/*!--------------------------------------------------------------------------
Function
Description
Author: EricDav
---------------------------------------------------------------------------*/
CDhcpMCastLease::CDhcpMCastLease
(
ITFSComponentData * pTFSCompData
) : CDhcpHandler(pTFSCompData)
{
//m_verbDefault = MMC_VERB_PROPERTIES;
m_dwTypeFlags = 0;
}
/*!--------------------------------------------------------------------------
CDhcpMCastLease::InitializeNode
Initializes node specific data
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT
CDhcpMCastLease::InitializeNode
(
ITFSNode * pNode
)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
int nImageIndex = ICON_IDX_CLIENT;
// Make the node immediately visible
pNode->SetVisibilityState(TFS_VIS_SHOW);
pNode->SetData(TFS_DATA_COOKIE, (LPARAM) pNode);
pNode->SetData(TFS_DATA_USER, (LPARAM) this);
pNode->SetData(TFS_DATA_TYPE, DHCPSNAP_MCAST_LEASE);
if (m_dwTypeFlags & TYPE_FLAG_GHOST)
{
nImageIndex = ICON_IDX_CLIENT_EXPIRED;
}
pNode->SetData(TFS_DATA_IMAGEINDEX, nImageIndex);
pNode->SetData(TFS_DATA_OPENIMAGEINDEX, nImageIndex);
return hrOK;
}
/*!--------------------------------------------------------------------------
CDhcpMCastLease::InitMCastInfo
Initializes node specific data
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT
CDhcpMCastLease::InitMCastInfo
(
LPDHCP_MCLIENT_INFO pMClientInfo
)
{
HRESULT hr = hrOK;
BOOL fInfinite = FALSE;
m_dhcpClientIpAddress = pMClientInfo->ClientIpAddress;
UtilCvtIpAddrToWstr(m_dhcpClientIpAddress, &m_strIp);
m_strName = pMClientInfo->ClientName;
if ( (pMClientInfo->ClientLeaseEnds.dwLowDateTime == DHCP_DATE_TIME_INFINIT_LOW) &&
(pMClientInfo->ClientLeaseEnds.dwHighDateTime == DHCP_DATE_TIME_INFINIT_HIGH) )
{
fInfinite = TRUE;
}
CTime timeStart( (FILETIME&) pMClientInfo->ClientLeaseStarts );
FILETIME ft = {0};
if (!fInfinite)
{
ft.dwLowDateTime = pMClientInfo->ClientLeaseEnds.dwLowDateTime;
ft.dwHighDateTime = pMClientInfo->ClientLeaseEnds.dwHighDateTime;
}
CTime timeStop( ft );
m_timeStart = timeStart;
FormatDateTime(m_strLeaseStart, (FILETIME *) &pMClientInfo->ClientLeaseStarts);
m_timeStop = timeStop;
if (!fInfinite)
{
FormatDateTime(m_strLeaseStop, (FILETIME *) &pMClientInfo->ClientLeaseEnds);
}
else
{
m_strLeaseStop.LoadString(IDS_INFO_TIME_INFINITE);
}
// build the UID string
if (pMClientInfo->ClientId.DataLength >= 3 &&
pMClientInfo->ClientId.Data[0] == 'R' &&
pMClientInfo->ClientId.Data[1] == 'A' &&
pMClientInfo->ClientId.Data[2] == 'S')
{
m_strUID = RAS_UID;
}
else
{
// build the client UID string
CByteArray baUID;
for (DWORD i = 0; i < pMClientInfo->ClientId.DataLength; i++)
{
baUID.Add(pMClientInfo->ClientId.Data[i]);
}
UtilCvtByteArrayToString(baUID, m_strUID);
}
// check to see if this lease has expired
SYSTEMTIME st;
GetLocalTime(&st);
CTime systemTime(st);
if ( (systemTime > timeStop) &&
(!fInfinite) )
{
Trace2("CDhcpMCastLease::InitMCastInfo - expired lease SysTime %s, StopTime %s\n", systemTime.Format(_T("%#c")), m_strLeaseStop);
m_dwTypeFlags |= TYPE_FLAG_GHOST;
}
return hr;
}
/*!--------------------------------------------------------------------------
CDhcpMCastLease::GetString
Description
Author: EricDav
---------------------------------------------------------------------------*/
STDMETHODIMP_(LPCTSTR)
CDhcpMCastLease::GetString
(
ITFSComponent * pComponent,
MMC_COOKIE cookie,
int nCol
)
{
SPITFSNode spNode;
m_spNodeMgr->FindNode(cookie, &spNode);
switch (nCol)
{
case 0:
return m_strIp;
case 1:
return m_strName;
case 2:
return m_strLeaseStart;
case 3:
return m_strLeaseStop;
case 4:
return m_strUID;
}
return NULL;
}
/*!--------------------------------------------------------------------------
CDhcpMCastLease::OnResultRefresh
Forwards refresh to parent to handle
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT CDhcpMCastLease::OnResultRefresh(ITFSComponent * pComponent, LPDATAOBJECT pDataObject, MMC_COOKIE cookie, LPARAM arg, LPARAM lParam)
{
HRESULT hr = hrOK;
SPITFSNode spNode, spParent;
SPITFSResultHandler spParentRH;
m_spNodeMgr->FindNode(cookie, &spNode);
// forward this command to the parent to handle
CORg (spNode->GetParent(&spParent));
CORg (spParent->GetResultHandler(&spParentRH));
CORg (spParentRH->Notify(pComponent, spParent->GetData(TFS_DATA_COOKIE), pDataObject, MMCN_REFRESH, arg, lParam));
Error:
return hrOK;
}
Reference in a new issue View git blame Copy permalink