mirror of https://github.com/tongzx/nt5src
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.
3318 lines
81 KiB
3318 lines
81 KiB
/**********************************************************************/
|
|
/** Microsoft Windows/NT **/
|
|
/** Copyright(c) Microsoft Corporation, 1997 - 1999 **/
|
|
/**********************************************************************/
|
|
|
|
/*
|
|
scopewiz.cpp
|
|
DHCP scope creation dialog
|
|
|
|
FILE HISTORY:
|
|
|
|
*/
|
|
|
|
#include "stdafx.h"
|
|
#include "server.h"
|
|
#include "scopewiz.h"
|
|
|
|
#ifdef _DEBUG
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
#define MASK_MIN 1
|
|
#define MASK_MAX 31
|
|
|
|
#define SCOPE_WARNING_COUNT 20
|
|
|
|
int CScopeWizLeaseTime::m_nDaysDefault = SCOPE_DFAULT_LEASE_DAYS;
|
|
int CScopeWizLeaseTime::m_nHoursDefault = SCOPE_DFAULT_LEASE_HOURS;
|
|
int CScopeWizLeaseTime::m_nMinutesDefault = SCOPE_DFAULT_LEASE_MINUTES;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CScopeWiz holder
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
CScopeWiz::CScopeWiz
|
|
(
|
|
ITFSNode * pNode,
|
|
IComponentData * pComponentData,
|
|
ITFSComponentData * pTFSCompData,
|
|
LPCTSTR pSuperscopeName,
|
|
LPCTSTR pszSheetName
|
|
) : CPropertyPageHolderBase(pNode, pComponentData, pszSheetName)
|
|
{
|
|
//ASSERT(pFolderNode == GetContainerNode());
|
|
|
|
m_bAutoDeletePages = FALSE; // we have the pages as embedded members
|
|
|
|
AddPageToList((CPropertyPageBase*) &m_pageWelcome);
|
|
AddPageToList((CPropertyPageBase*) &m_pageName);
|
|
AddPageToList((CPropertyPageBase*) &m_pageInvalidName);
|
|
AddPageToList((CPropertyPageBase*) &m_pageSetRange);
|
|
AddPageToList((CPropertyPageBase*) &m_pageSetExclusions);
|
|
AddPageToList((CPropertyPageBase*) &m_pageLeaseTime);
|
|
AddPageToList((CPropertyPageBase*) &m_pageCreateSuperscope);
|
|
AddPageToList((CPropertyPageBase*) &m_pageConfigOptions);
|
|
AddPageToList((CPropertyPageBase*) &m_pageRouter);
|
|
AddPageToList((CPropertyPageBase*) &m_pageDNS);
|
|
AddPageToList((CPropertyPageBase*) &m_pageWINS);
|
|
AddPageToList((CPropertyPageBase*) &m_pageActivate);
|
|
AddPageToList((CPropertyPageBase*) &m_pageFinished);
|
|
|
|
Assert(pTFSCompData != NULL);
|
|
|
|
m_spTFSCompData.Set(pTFSCompData);
|
|
m_strSuperscopeName = pSuperscopeName;
|
|
|
|
m_fCreateSuperscope = FALSE;
|
|
m_fOptionsConfigured = FALSE;
|
|
m_fActivateScope = FALSE;
|
|
|
|
m_pDefaultOptions = NULL;
|
|
m_poptDomainName = NULL;
|
|
m_poptDNSServers = NULL;
|
|
m_poptRouters = NULL;
|
|
m_poptWINSNodeType = NULL;
|
|
m_poptWINSServers = NULL;
|
|
|
|
m_bWiz97 = TRUE;
|
|
|
|
m_spTFSCompData->SetWatermarkInfo(&g_WatermarkInfoScope);
|
|
}
|
|
|
|
CScopeWiz::~CScopeWiz()
|
|
{
|
|
RemovePageFromList((CPropertyPageBase*) &m_pageName, FALSE);
|
|
RemovePageFromList((CPropertyPageBase*) &m_pageInvalidName, FALSE);
|
|
RemovePageFromList((CPropertyPageBase*) &m_pageSetRange, FALSE);
|
|
RemovePageFromList((CPropertyPageBase*) &m_pageSetExclusions, FALSE);
|
|
RemovePageFromList((CPropertyPageBase*) &m_pageLeaseTime, FALSE);
|
|
RemovePageFromList((CPropertyPageBase*) &m_pageCreateSuperscope, FALSE);
|
|
RemovePageFromList((CPropertyPageBase*) &m_pageConfigOptions, FALSE);
|
|
RemovePageFromList((CPropertyPageBase*) &m_pageRouter, FALSE);
|
|
RemovePageFromList((CPropertyPageBase*) &m_pageDNS, FALSE);
|
|
RemovePageFromList((CPropertyPageBase*) &m_pageWINS, FALSE);
|
|
RemovePageFromList((CPropertyPageBase*) &m_pageActivate, FALSE);
|
|
RemovePageFromList((CPropertyPageBase*) &m_pageFinished, FALSE);
|
|
}
|
|
|
|
//
|
|
// Called from the OnWizardFinish to add the DHCP Server to the list
|
|
//
|
|
DWORD
|
|
CScopeWiz::OnFinish()
|
|
{
|
|
if (m_fCreateSuperscope)
|
|
{
|
|
return CreateSuperscope();
|
|
}
|
|
else
|
|
{
|
|
return CreateScope();
|
|
}
|
|
}
|
|
|
|
BOOL
|
|
CScopeWiz::GetScopeRange(CDhcpIpRange * pdhcpIpRange)
|
|
{
|
|
return m_pageSetRange.GetScopeRange(pdhcpIpRange);
|
|
}
|
|
|
|
DWORD
|
|
CScopeWiz::CreateSuperscope()
|
|
{
|
|
LONG err = 0;
|
|
LONG dwErrReturn = 0;
|
|
BOOL fScopeCreated = FALSE;
|
|
BOOL fFinished = FALSE;
|
|
DHCP_IP_ADDRESS dhcpSubnetId ;
|
|
DHCP_IP_ADDRESS dhcpSubnetMask ;
|
|
CDhcpScope * pobScope = NULL ;
|
|
CDhcpIpRange dhcpIpRange;
|
|
CDhcpServer * pServer;
|
|
SPITFSNode spServerNode, spSuperscopeNode;
|
|
CString strSuperscopeTemplate = _T("Superscope %d");
|
|
CString strSuperscopeName;
|
|
CString strFinishText;
|
|
int nSuperscopeSuffix = 0;
|
|
int nScopesCreated = 0;
|
|
int nScopesTotal = 0;
|
|
SPITFSComponentData spTFSCompData;
|
|
SPITFSNodeMgr spNodeMgr;
|
|
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
|
|
// Get the server node depending upon how we were called
|
|
if (m_strSuperscopeName.IsEmpty())
|
|
{
|
|
spServerNode = GetNode();
|
|
}
|
|
else
|
|
{
|
|
SPITFSNode spSscopeNode;
|
|
spSscopeNode = GetNode();
|
|
spSscopeNode->GetParent(&spServerNode);
|
|
}
|
|
|
|
spServerNode->GetNodeMgr(&spNodeMgr);
|
|
spTFSCompData = GetTFSCompData();
|
|
|
|
// setup some necessary things for the superscope object for the UI
|
|
CDhcpSuperscope * pSuperscope = new CDhcpSuperscope(spTFSCompData);
|
|
pSuperscope->SetServer(spServerNode);
|
|
|
|
// find a superscope name that doesn't already exist
|
|
strSuperscopeName.Format(strSuperscopeTemplate, nSuperscopeSuffix);
|
|
while (pSuperscope->DoesSuperscopeExist(strSuperscopeName))
|
|
{
|
|
nSuperscopeSuffix++;
|
|
strSuperscopeName.Format(strSuperscopeTemplate, nSuperscopeSuffix);
|
|
}
|
|
|
|
// Set the new name in the superscope object
|
|
pSuperscope->SetName(strSuperscopeName);
|
|
|
|
CreateContainerTFSNode(&spSuperscopeNode,
|
|
&GUID_DhcpSuperscopeNodeType,
|
|
pSuperscope,
|
|
pSuperscope,
|
|
spNodeMgr);
|
|
|
|
// Tell the handler to initialize any specific data
|
|
if (m_fOptionsConfigured && m_fActivateScope)
|
|
pSuperscope->SetState(DhcpSubnetEnabled);
|
|
|
|
pSuperscope->InitializeNode((ITFSNode *) spSuperscopeNode);
|
|
pServer = GETHANDLER(CDhcpServer, spServerNode);
|
|
|
|
// Ok, now the fun begins...
|
|
CDhcpIpRange ipRangeTotal, ipRangeCurrent;
|
|
m_pageSetRange.GetScopeRange(&ipRangeTotal);
|
|
|
|
dhcpSubnetMask = m_pageSetRange.GetSubnetMask();
|
|
|
|
// Set the start address for the first scope
|
|
ipRangeCurrent.SetAddr(ipRangeTotal.QueryAddr(TRUE), TRUE);
|
|
|
|
while (!fFinished)
|
|
{
|
|
SPITFSNode spNode;
|
|
|
|
nScopesTotal++;
|
|
|
|
// Calculate the subnet ID
|
|
dhcpSubnetId = ipRangeCurrent.QueryAddr(TRUE) & dhcpSubnetMask;
|
|
|
|
// 0 is an invalid start address for a range. Check to make sure
|
|
// that the starting address of the range isn't 0, if it is, then add 1
|
|
DWORD startAddr = ipRangeCurrent.QueryAddr(TRUE);
|
|
if ((startAddr & ~dhcpSubnetMask) == 0)
|
|
{
|
|
ipRangeCurrent.SetAddr(startAddr+1, TRUE);
|
|
}
|
|
|
|
// set the ending address of the (subnetId + ~subnetmask) - 1. Just adding the subnet
|
|
// mask gives us the broadcast address for that subnet. We don't want that!
|
|
ipRangeCurrent.SetAddr((dhcpSubnetId + ~dhcpSubnetMask) - 1, FALSE);
|
|
|
|
|
|
// check to see if we are at the last scope, if so make sure we don't
|
|
// go over what the range the user specified and set the flag so we'll quit
|
|
if (ipRangeCurrent.QueryAddr(FALSE) >= ipRangeTotal.QueryAddr(FALSE))
|
|
{
|
|
// set the ending address to what the user specified
|
|
ipRangeCurrent.SetAddr(ipRangeTotal.QueryAddr(FALSE), FALSE);
|
|
fFinished = TRUE;
|
|
}
|
|
|
|
// Create the scope on the server and then we can
|
|
// create our internal object.
|
|
err = pServer->CreateScope(dhcpSubnetId,
|
|
dhcpSubnetMask,
|
|
m_pageName.m_strName,
|
|
m_pageName.m_strComment);
|
|
|
|
if (err != ERROR_SUCCESS)
|
|
{
|
|
Trace1("CScopeWiz::CreateScope() - Couldn't create scope! Error = %d\n", err);
|
|
|
|
dwErrReturn = err;
|
|
|
|
// increment the scope address by 2. +1 gets us the network broadcast address,
|
|
// the next +1 gets us to the next subnet.
|
|
ipRangeCurrent.SetAddr(ipRangeCurrent.QueryAddr(FALSE) + 2, TRUE);
|
|
continue;
|
|
}
|
|
|
|
// now create our object that represents the scope for the UI
|
|
pobScope = new CDhcpScope(spTFSCompData,
|
|
dhcpSubnetId,
|
|
dhcpSubnetMask,
|
|
m_pageName.m_strName,
|
|
m_pageName.m_strComment);
|
|
|
|
if ( pobScope == NULL )
|
|
{
|
|
err = ERROR_NOT_ENOUGH_MEMORY ;
|
|
break ;
|
|
}
|
|
|
|
// Store the server object in the holder
|
|
CreateContainerTFSNode(&spNode,
|
|
&GUID_DhcpScopeNodeType,
|
|
pobScope,
|
|
pobScope,
|
|
spNodeMgr);
|
|
|
|
// Tell the handler to initialize any specific data
|
|
pobScope->SetServer(spServerNode);
|
|
pobScope->InitializeNode((ITFSNode *) spNode);
|
|
|
|
pobScope->Release();
|
|
|
|
// Finish creating the scope. First, the IP address range
|
|
// from which to allocate addresses.
|
|
if ( err = pobScope->SetIpRange( ipRangeCurrent, TRUE ) )
|
|
{
|
|
Trace2("SetIpRange on scope %lx failed!! %d\n", dhcpSubnetId, err);
|
|
dwErrReturn = err;
|
|
pServer->DeleteSubnet(pobScope->GetAddress());
|
|
goto Cleanup;
|
|
}
|
|
|
|
// set the lease time
|
|
DWORD dwLeaseTime;
|
|
|
|
dwLeaseTime = m_pageLeaseTime.GetLeaseTime();
|
|
|
|
err = pobScope->SetLeaseTime(dwLeaseTime);
|
|
if (err != ERROR_SUCCESS)
|
|
{
|
|
Trace2("SetLeaseTime on Scope %lx failed!! %d\n", dhcpSubnetId, err);
|
|
dwErrReturn = err;
|
|
pServer->DeleteSubnet(pobScope->GetAddress());
|
|
goto Cleanup;
|
|
}
|
|
|
|
// Set this scope as part of the superscope
|
|
err = pobScope->SetSuperscope(strSuperscopeName, FALSE);
|
|
if (err != ERROR_SUCCESS)
|
|
{
|
|
Trace2("SetSuperscope on scope %lx failed!! %d\n", dhcpSubnetId, err);
|
|
dwErrReturn = err;
|
|
pServer->DeleteSubnet(pobScope->GetAddress());
|
|
goto Cleanup;
|
|
}
|
|
|
|
pobScope->SetInSuperscope(TRUE);
|
|
|
|
// now set any optional options the user may want
|
|
if (m_fOptionsConfigured)
|
|
{
|
|
err = SetScopeOptions(pobScope);
|
|
if (err != ERROR_SUCCESS)
|
|
{
|
|
Trace1("SetScopeOptions failed!! %d\n", err);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// increment our counter
|
|
nScopesCreated++;
|
|
|
|
// cleanup this node and handler... they were only temporary
|
|
Cleanup:
|
|
// we add two to the ending address to get the next starting address. This
|
|
// is because the ending adddress is one less than the maximum address for the
|
|
// subnet. The maximum address is reserved as the broadcast address. So to get
|
|
// the starting address of the next subnet we add one to get us to the broadcast
|
|
// address, and one more to get us to the beginning of the next subnet.
|
|
// This gives us a total of 2.
|
|
ipRangeCurrent.SetAddr(ipRangeCurrent.QueryAddr(FALSE) + 2, TRUE);
|
|
spNode->DeleteAllChildren(FALSE);
|
|
spNode->Destroy();
|
|
}
|
|
|
|
pSuperscope->Release();
|
|
|
|
// let the user know how many scopes were created and if there was an error;
|
|
CString strTemp;
|
|
if (nScopesCreated == 0)
|
|
{
|
|
strFinishText.LoadString(IDS_SUPERSCOPE_CREATE_FAILED);
|
|
}
|
|
else
|
|
if (nScopesCreated < nScopesTotal)
|
|
{
|
|
strTemp.LoadString(IDS_SUPERSCOPE_CREATE_STATUS);
|
|
strFinishText.Format(strTemp, strSuperscopeName, nScopesCreated, nScopesTotal);
|
|
}
|
|
|
|
if (dwErrReturn != ERROR_SUCCESS)
|
|
{
|
|
LPTSTR pBuf;
|
|
|
|
strFinishText += _T("\n\n");
|
|
strTemp.LoadString(IDS_POSSIBLE_ERROR);
|
|
|
|
strFinishText += strTemp;
|
|
|
|
pBuf = strTemp.GetBuffer(4000);
|
|
::LoadMessage(dwErrReturn, pBuf, 4000);
|
|
strTemp.ReleaseBuffer();
|
|
|
|
strFinishText += strTemp;
|
|
}
|
|
|
|
if (nScopesCreated)
|
|
{
|
|
// add the superscope to the UI
|
|
pServer->AddSuperscopeSorted(spServerNode, spSuperscopeNode);
|
|
}
|
|
|
|
if (!strFinishText.IsEmpty())
|
|
AfxMessageBox(strFinishText);
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
DWORD
|
|
CScopeWiz::CreateScope()
|
|
{
|
|
LONG err = 0,
|
|
err2 ;
|
|
BOOL fScopeCreated = FALSE;
|
|
DHCP_IP_ADDRESS dhcpSubnetId ;
|
|
DHCP_IP_ADDRESS dhcpSubnetMask ;
|
|
CDhcpScope * pobScope = NULL ;
|
|
CDhcpIpRange dhcpIpRange;
|
|
CDhcpServer * pServer;
|
|
SPITFSNode spNode, spServerNode, spSuperscopeNode;
|
|
|
|
// Get the correct node depending up how the wizard was launched
|
|
// ie. either from the Server node or the superscope node.
|
|
if (m_strSuperscopeName.IsEmpty())
|
|
{
|
|
spServerNode = GetNode();
|
|
}
|
|
else
|
|
{
|
|
spSuperscopeNode = GetNode();
|
|
spSuperscopeNode->GetParent(&spServerNode);
|
|
}
|
|
|
|
do
|
|
{
|
|
pServer = GETHANDLER(CDhcpServer, spServerNode);
|
|
//
|
|
// Create the scope on the server and then we can
|
|
// create our internal object.
|
|
//
|
|
dhcpSubnetId = m_pageSetRange.DetermineSubnetId(TRUE);
|
|
dhcpSubnetMask = m_pageSetRange.GetSubnetMask();
|
|
|
|
err = pServer->CreateScope(dhcpSubnetId,
|
|
dhcpSubnetMask,
|
|
m_pageName.m_strName,
|
|
m_pageName.m_strComment);
|
|
|
|
if (err != 0)
|
|
{
|
|
Trace1("CScopeWiz::CreateScope() - Couldn't create scope! Error = %d\n", err);
|
|
break;
|
|
}
|
|
|
|
SPITFSComponentData spTFSCompData;
|
|
spTFSCompData = GetTFSCompData();
|
|
|
|
pobScope = new CDhcpScope(spTFSCompData,
|
|
dhcpSubnetId,
|
|
dhcpSubnetMask,
|
|
m_pageName.m_strName,
|
|
m_pageName.m_strComment);
|
|
|
|
if ( pobScope == NULL )
|
|
{
|
|
err = ERROR_NOT_ENOUGH_MEMORY ;
|
|
break ;
|
|
}
|
|
|
|
SPITFSNodeMgr spNodeMgr;
|
|
spServerNode->GetNodeMgr(&spNodeMgr);
|
|
|
|
//
|
|
// Store the server object in the holder
|
|
//
|
|
CreateContainerTFSNode(&spNode,
|
|
&GUID_DhcpServerNodeType,
|
|
pobScope,
|
|
pobScope,
|
|
spNodeMgr);
|
|
|
|
// Tell the handler to initialize any specific data
|
|
pobScope->SetServer(spServerNode);
|
|
pobScope->InitializeNode((ITFSNode *) spNode);
|
|
|
|
if (m_strSuperscopeName.IsEmpty())
|
|
{
|
|
CDhcpServer * pServer1 = GETHANDLER(CDhcpServer, spServerNode);
|
|
pServer1->AddScopeSorted(spServerNode, spNode);
|
|
}
|
|
else
|
|
{
|
|
CDhcpSuperscope * pSuperscope = GETHANDLER(CDhcpSuperscope, spSuperscopeNode);
|
|
pSuperscope->AddScopeSorted(spSuperscopeNode, spNode);
|
|
}
|
|
|
|
pobScope->Release();
|
|
|
|
fScopeCreated = TRUE;
|
|
|
|
//
|
|
// Finish updating the scope. First, the IP address range
|
|
// from which to allocate addresses.
|
|
//
|
|
m_pageSetRange.GetScopeRange(&dhcpIpRange);
|
|
|
|
if ( err = pobScope->SetIpRange( dhcpIpRange, TRUE ) )
|
|
{
|
|
Trace1("SetIpRange failed!! %d\n", err);
|
|
break ;
|
|
}
|
|
|
|
//
|
|
// Next, see if any exclusions were specified.
|
|
//
|
|
err = pobScope->StoreExceptionList( m_pageSetExclusions.GetExclusionList() ) ;
|
|
if (err != ERROR_SUCCESS)
|
|
{
|
|
Trace1("StoreExceptionList failed!! %d\n", err);
|
|
break;
|
|
}
|
|
|
|
//
|
|
// set the lease time
|
|
//
|
|
DWORD dwLeaseTime;
|
|
|
|
dwLeaseTime = m_pageLeaseTime.GetLeaseTime();
|
|
|
|
err = pobScope->SetLeaseTime(dwLeaseTime);
|
|
if (err != ERROR_SUCCESS)
|
|
{
|
|
Trace1("SetLeaseTime failed!! %d\n", err);
|
|
break;
|
|
}
|
|
|
|
if (!m_strSuperscopeName.IsEmpty())
|
|
{
|
|
// Set this scope as part of the superscope
|
|
err = pobScope->SetSuperscope(m_strSuperscopeName, FALSE);
|
|
|
|
if (err != ERROR_SUCCESS)
|
|
{
|
|
Trace1("SetSuperscope failed!! %d\n", err);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// now set any optional options the user may want
|
|
if (m_fOptionsConfigured)
|
|
{
|
|
err = SetScopeOptions(pobScope);
|
|
if (err != ERROR_SUCCESS)
|
|
{
|
|
Trace1("SetScopeOptions failed!! %d\n", err);
|
|
break;
|
|
}
|
|
|
|
if (m_fActivateScope)
|
|
{
|
|
// update the icon
|
|
spNode->SetData(TFS_DATA_IMAGEINDEX, pobScope->GetImageIndex(FALSE));
|
|
spNode->SetData(TFS_DATA_OPENIMAGEINDEX, pobScope->GetImageIndex(TRUE));
|
|
|
|
spNode->ChangeNode(SCOPE_PANE_CHANGE_ITEM_ICON);
|
|
}
|
|
}
|
|
}
|
|
while ( FALSE ) ;
|
|
|
|
if ( err )
|
|
{
|
|
//
|
|
// CODEWORK:: The scope should never have been added
|
|
// to the remote registry in the first place.
|
|
//
|
|
if (pobScope != NULL)
|
|
{
|
|
if (fScopeCreated)
|
|
{
|
|
Trace0("Bad scope nevertheless was created\n");
|
|
err2 = pServer->DeleteSubnet(pobScope->GetAddress());
|
|
if (err2 != ERROR_SUCCESS)
|
|
{
|
|
Trace1("Couldn't remove the bad scope! Error = %d\n", err2);
|
|
}
|
|
}
|
|
|
|
if (m_strSuperscopeName.IsEmpty())
|
|
{
|
|
spServerNode->RemoveChild(spNode);
|
|
}
|
|
else
|
|
{
|
|
spSuperscopeNode->RemoveChild(spNode);
|
|
}
|
|
}
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
DWORD
|
|
CScopeWiz::SetScopeOptions(CDhcpScope * pScope)
|
|
{
|
|
DWORD dwErr = ERROR_SUCCESS;
|
|
|
|
if (m_poptRouters)
|
|
{
|
|
dwErr = pScope->SetOptionValue(m_poptRouters, DhcpSubnetOptions);
|
|
if (dwErr)
|
|
return dwErr;
|
|
}
|
|
|
|
if (m_poptDomainName)
|
|
{
|
|
dwErr = pScope->SetOptionValue(m_poptDomainName, DhcpSubnetOptions);
|
|
if (dwErr)
|
|
return dwErr;
|
|
}
|
|
|
|
if (m_poptDNSServers)
|
|
{
|
|
dwErr = pScope->SetOptionValue(m_poptDNSServers, DhcpSubnetOptions);
|
|
if (dwErr)
|
|
return dwErr;
|
|
}
|
|
|
|
if (m_poptWINSServers)
|
|
{
|
|
dwErr = pScope->SetOptionValue(m_poptWINSServers, DhcpSubnetOptions);
|
|
if (dwErr)
|
|
return dwErr;
|
|
}
|
|
|
|
if (m_poptWINSNodeType)
|
|
{
|
|
dwErr = pScope->SetOptionValue(m_poptWINSNodeType, DhcpSubnetOptions);
|
|
if (dwErr)
|
|
return dwErr;
|
|
}
|
|
|
|
if (m_fActivateScope)
|
|
{
|
|
pScope->SetState(DhcpSubnetEnabled);
|
|
dwErr = pScope->SetInfo();
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CScopeWizName property page
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
IMPLEMENT_DYNCREATE(CScopeWizName, CPropertyPageBase)
|
|
|
|
CScopeWizName::CScopeWizName() : CPropertyPageBase(CScopeWizName::IDD)
|
|
{
|
|
//{{AFX_DATA_INIT(CScopeWizName)
|
|
m_strName = _T("");
|
|
m_strComment = _T("");
|
|
//}}AFX_DATA_INIT
|
|
|
|
InitWiz97(FALSE, IDS_SCOPE_WIZ_NAME_TITLE, IDS_SCOPE_WIZ_NAME_SUBTITLE);
|
|
}
|
|
|
|
CScopeWizName::~CScopeWizName()
|
|
{
|
|
}
|
|
|
|
void CScopeWizName::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CPropertyPageBase::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CScopeWizName)
|
|
DDX_Control(pDX, IDC_EDIT_SCOPE_NAME, m_editScopeName);
|
|
DDX_Control(pDX, IDC_EDIT_SCOPE_COMMENT, m_editScopeComment);
|
|
DDX_Text(pDX, IDC_EDIT_SCOPE_NAME, m_strName);
|
|
DDX_Text(pDX, IDC_EDIT_SCOPE_COMMENT, m_strComment);
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CScopeWizName, CPropertyPageBase)
|
|
//{{AFX_MSG_MAP(CScopeWizName)
|
|
ON_EN_CHANGE(IDC_EDIT_SCOPE_NAME, OnChangeEditScopeName)
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CScopeWizName message handlers
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL CScopeWizName::OnInitDialog()
|
|
{
|
|
CPropertyPageBase::OnInitDialog();
|
|
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
LRESULT CScopeWizName::OnWizardNext()
|
|
{
|
|
UpdateData();
|
|
|
|
return IDW_SCOPE_SET_SCOPE;
|
|
}
|
|
|
|
BOOL CScopeWizName::OnSetActive()
|
|
{
|
|
UpdateButtons();
|
|
|
|
return CPropertyPageBase::OnSetActive();
|
|
}
|
|
|
|
void CScopeWizName::OnChangeEditScopeName()
|
|
{
|
|
UpdateButtons();
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CScopeWizName implementation specific
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void
|
|
CScopeWizName::UpdateButtons()
|
|
{
|
|
BOOL bValid = FALSE;
|
|
|
|
UpdateData();
|
|
|
|
if (m_strName.GetLength() > 0)
|
|
bValid = TRUE;
|
|
|
|
GetHolder()->SetWizardButtonsMiddle(bValid);
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CScopeWizInvalidName property page
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
IMPLEMENT_DYNCREATE(CScopeWizInvalidName, CPropertyPageBase)
|
|
|
|
CScopeWizInvalidName::CScopeWizInvalidName() : CPropertyPageBase(CScopeWizInvalidName::IDD)
|
|
{
|
|
//{{AFX_DATA_INIT(CScopeWizInvalidName)
|
|
// NOTE: the ClassWizard will add member initialization here
|
|
//}}AFX_DATA_INIT
|
|
|
|
InitWiz97(FALSE, IDS_SCOPE_WIZ_INVALID_NAME_TITLE, IDS_SCOPE_WIZ_INVALID_NAME_SUBTITLE);
|
|
}
|
|
|
|
CScopeWizInvalidName::~CScopeWizInvalidName()
|
|
{
|
|
}
|
|
|
|
void CScopeWizInvalidName::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CPropertyPageBase::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CScopeWizInvalidName)
|
|
// NOTE: the ClassWizard will add DDX and DDV calls here
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CScopeWizInvalidName, CPropertyPageBase)
|
|
//{{AFX_MSG_MAP(CScopeWizInvalidName)
|
|
// NOTE: the ClassWizard will add message map macros here
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CScopeWizInvalidName message handlers
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL CScopeWizInvalidName::OnInitDialog()
|
|
{
|
|
CPropertyPageBase::OnInitDialog();
|
|
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
LRESULT CScopeWizInvalidName::OnWizardBack()
|
|
{
|
|
// TODO: Add your specialized code here and/or call the base class
|
|
|
|
return IDW_SCOPE_NAME;
|
|
}
|
|
|
|
BOOL CScopeWizInvalidName::OnSetActive()
|
|
{
|
|
GetHolder()->SetWizardButtonsLast(FALSE);
|
|
|
|
return CPropertyPageBase::OnSetActive();
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CScopeWizSetRange property page
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
IMPLEMENT_DYNCREATE(CScopeWizSetRange, CPropertyPageBase)
|
|
|
|
CScopeWizSetRange::CScopeWizSetRange() : CPropertyPageBase(CScopeWizSetRange::IDD)
|
|
{
|
|
//{{AFX_DATA_INIT(CScopeWizSetRange)
|
|
// NOTE: the ClassWizard will add member initialization here
|
|
//}}AFX_DATA_INIT
|
|
|
|
m_bAutoUpdateMask = FALSE;
|
|
|
|
InitWiz97(FALSE, IDS_SCOPE_WIZ_SCOPE_TITLE, IDS_SCOPE_WIZ_SCOPE_SUBTITLE);
|
|
}
|
|
|
|
CScopeWizSetRange::~CScopeWizSetRange()
|
|
{
|
|
}
|
|
|
|
void CScopeWizSetRange::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CPropertyPageBase::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CScopeWizSetRange)
|
|
DDX_Control(pDX, IDC_SPIN_MASK_LENGTH, m_spinMaskLength);
|
|
DDX_Control(pDX, IDC_EDIT_MASK_LENGTH, m_editMaskLength);
|
|
//}}AFX_DATA_MAP
|
|
|
|
DDX_Control(pDX, IDC_IPADDR_POOL_START, m_ipaStart);
|
|
DDX_Control(pDX, IDC_IPADDR_POOL_STOP, m_ipaEnd);
|
|
DDX_Control(pDX, IDC_IPADDR_SUBNET_MASK, m_ipaSubnetMask);
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CScopeWizSetRange, CPropertyPageBase)
|
|
//{{AFX_MSG_MAP(CScopeWizSetRange)
|
|
ON_EN_KILLFOCUS(IDC_IPADDR_POOL_START, OnKillfocusPoolStart)
|
|
ON_EN_KILLFOCUS(IDC_IPADDR_POOL_STOP, OnKillfocusPoolStop)
|
|
ON_EN_CHANGE(IDC_EDIT_MASK_LENGTH, OnChangeEditMaskLength)
|
|
ON_EN_KILLFOCUS(IDC_IPADDR_SUBNET_MASK, OnKillfocusSubnetMask)
|
|
ON_EN_CHANGE(IDC_IPADDR_POOL_START, OnChangePoolStart)
|
|
ON_EN_CHANGE(IDC_IPADDR_POOL_STOP, OnChangePoolStop)
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CScopeWizSetRange message handlers
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL CScopeWizSetRange::OnInitDialog()
|
|
{
|
|
CPropertyPageBase::OnInitDialog();
|
|
|
|
m_spinMaskLength.SetRange(MASK_MIN, MASK_MAX);
|
|
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
LRESULT CScopeWizSetRange::OnWizardNext()
|
|
{
|
|
// check to make sure the address range is not in the multicast area
|
|
CDhcpIpRange rangeScope, rangeMulticast;
|
|
DWORD dwSubnetMask;
|
|
|
|
GetScopeRange(&rangeScope);
|
|
|
|
rangeMulticast.SetAddr(MCAST_ADDRESS_MIN, TRUE);
|
|
rangeMulticast.SetAddr(MCAST_ADDRESS_MAX, FALSE);
|
|
|
|
dwSubnetMask = GetSubnetMask();
|
|
|
|
// make sure the starting < ending
|
|
if (rangeScope.QueryAddr(TRUE) > rangeScope.QueryAddr(FALSE))
|
|
{
|
|
AfxMessageBox(IDS_ERR_IP_RANGE_INV_START);
|
|
m_ipaStart.SetFocus();
|
|
return -1;
|
|
}
|
|
|
|
if (rangeScope.IsOverlap(rangeMulticast))
|
|
{
|
|
AfxMessageBox(IDS_SCOPE_CONTAINS_MULTICAST);
|
|
m_ipaStart.SetFocus();
|
|
return -1;
|
|
}
|
|
|
|
// make sure that the starting address != subnet address
|
|
if ((rangeScope.QueryAddr(TRUE) & ~dwSubnetMask) == (DWORD) 0)
|
|
{
|
|
Trace0("CScopeWizSetRange::OnWizardNext() - starting range is 0 for subnet\n");
|
|
AfxMessageBox(IDS_ERR_IP_RANGE_INV_START);
|
|
m_ipaStart.SetFocus();
|
|
return -1;
|
|
}
|
|
|
|
// make sure that the subnet broadcast address is not the ending address
|
|
if ((rangeScope.QueryAddr(FALSE) & ~dwSubnetMask) == ~dwSubnetMask)
|
|
{
|
|
Trace0("CScopeWizSetRange::OnWizardNext() - ending range is subnet broadcast addr\n");
|
|
AfxMessageBox(IDS_ERR_IP_RANGE_INV_END);
|
|
m_ipaEnd.SetFocus();
|
|
return -1;
|
|
}
|
|
|
|
if (FScopeExists(rangeScope, dwSubnetMask))
|
|
{
|
|
// tell the user this scope exists
|
|
Trace0("CScopeWizSetRange::OnWizardNext() - scope already exists\n");
|
|
AfxMessageBox(IDS_ERR_SCOPE_EXISTS);
|
|
m_ipaStart.SetFocus();
|
|
return -1;
|
|
}
|
|
|
|
// now figure out where to go...
|
|
if (DetermineSubnetId(TRUE) != DetermineSubnetId(FALSE))
|
|
{
|
|
//
|
|
// The subnet range that was entered spans more than
|
|
// one subnet. Query the user to create a superscope.
|
|
//
|
|
return IDW_SCOPE_CREATE_SUPERSCOPE;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// The range is only one subnet. Proceed as normal.
|
|
//
|
|
CScopeWiz * pScopeWiz = reinterpret_cast<CScopeWiz *>(GetHolder());
|
|
pScopeWiz->SetCreateSuperscope(FALSE);
|
|
|
|
return IDW_SCOPE_SET_EXCLUSIONS;
|
|
}
|
|
}
|
|
|
|
BOOL CScopeWizSetRange::FScopeExists(CDhcpIpRange & rangeScope, DWORD dwMask)
|
|
{
|
|
BOOL fFound = FALSE;
|
|
DWORD dwScopeId = rangeScope.QueryAddr(TRUE) & dwMask;
|
|
|
|
CScopeWiz * pScopeWiz = reinterpret_cast<CScopeWiz *>(GetHolder());
|
|
|
|
SPITFSNode spServerNode, spSuperscopeNode;
|
|
|
|
// Get the correct node depending up how the wizard was launched
|
|
// ie. either from the Server node or the superscope node.
|
|
if (pScopeWiz->m_strSuperscopeName.IsEmpty())
|
|
{
|
|
spServerNode = pScopeWiz->GetNode();
|
|
}
|
|
else
|
|
{
|
|
spSuperscopeNode = pScopeWiz->GetNode();
|
|
spSuperscopeNode->GetParent(&spServerNode);
|
|
}
|
|
|
|
CDhcpServer * pServer = GETHANDLER(CDhcpServer, spServerNode);
|
|
|
|
CSubnetInfo subnetInfo;
|
|
|
|
if (pServer->m_pSubnetInfoCache->Lookup(dwScopeId, subnetInfo))
|
|
{
|
|
fFound = TRUE;
|
|
}
|
|
|
|
return fFound;
|
|
}
|
|
|
|
LRESULT CScopeWizSetRange::OnWizardBack()
|
|
{
|
|
return IDW_SCOPE_NAME;
|
|
}
|
|
|
|
BOOL CScopeWizSetRange::OnSetActive()
|
|
{
|
|
m_fPageActive = TRUE;
|
|
|
|
UpdateButtons();
|
|
|
|
return CPropertyPageBase::OnSetActive();
|
|
}
|
|
|
|
BOOL CScopeWizSetRange::OnKillActive()
|
|
{
|
|
m_fPageActive = FALSE;
|
|
|
|
UpdateButtons();
|
|
|
|
return CPropertyPageBase::OnKillActive();
|
|
}
|
|
|
|
void CScopeWizSetRange::OnKillfocusPoolStart()
|
|
{
|
|
if (m_fPageActive)
|
|
{
|
|
SuggestSubnetMask();
|
|
}
|
|
}
|
|
|
|
void CScopeWizSetRange::OnKillfocusPoolStop()
|
|
{
|
|
if (m_fPageActive)
|
|
{
|
|
SuggestSubnetMask();
|
|
}
|
|
}
|
|
|
|
void CScopeWizSetRange::OnChangeEditMaskLength()
|
|
{
|
|
if (m_bAutoUpdateMask)
|
|
{
|
|
CString strText;
|
|
m_editMaskLength.GetWindowText(strText);
|
|
|
|
int nLength = _ttoi(strText);
|
|
|
|
if (nLength < MASK_MIN)
|
|
{
|
|
LPTSTR pBuf = strText.GetBuffer(5);
|
|
|
|
_itot(MASK_MIN, pBuf, 10);
|
|
strText.ReleaseBuffer();
|
|
|
|
m_editMaskLength.SetWindowText(strText);
|
|
m_spinMaskLength.SetPos(MASK_MIN);
|
|
|
|
MessageBeep(MB_ICONEXCLAMATION);
|
|
}
|
|
else
|
|
if (nLength > MASK_MAX)
|
|
{
|
|
LPTSTR pBuf = strText.GetBuffer(5);
|
|
|
|
_itot(MASK_MAX, pBuf, 10);
|
|
strText.ReleaseBuffer();
|
|
|
|
m_editMaskLength.SetWindowText(strText);
|
|
m_spinMaskLength.SetPos(MASK_MAX);
|
|
|
|
MessageBeep(MB_ICONEXCLAMATION);
|
|
}
|
|
|
|
UpdateMask(TRUE);
|
|
UpdateButtons();
|
|
}
|
|
}
|
|
|
|
void CScopeWizSetRange::OnKillfocusSubnetMask()
|
|
{
|
|
if (m_bAutoUpdateMask)
|
|
{
|
|
UpdateMask(FALSE);
|
|
}
|
|
}
|
|
|
|
void CScopeWizSetRange::OnChangePoolStop()
|
|
{
|
|
UpdateButtons();
|
|
}
|
|
|
|
void CScopeWizSetRange::OnChangePoolStart()
|
|
{
|
|
UpdateButtons();
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CScopeWizSetRange implementation specific
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL
|
|
CScopeWizSetRange::GetScopeRange(CDhcpIpRange * pdhcpIpRange)
|
|
{
|
|
DHCP_IP_RANGE dhcpIpRange;
|
|
|
|
if ( !m_ipaStart.GetAddress( & dhcpIpRange.StartAddress ) )
|
|
{
|
|
return FALSE ;
|
|
}
|
|
|
|
if ( !m_ipaEnd.GetAddress( & dhcpIpRange.EndAddress ) )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
*pdhcpIpRange = dhcpIpRange;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
DHCP_IP_ADDRESS
|
|
CScopeWizSetRange::GetSubnetMask()
|
|
{
|
|
DWORD dwAddress;
|
|
m_ipaSubnetMask.GetAddress(&dwAddress);
|
|
|
|
return dwAddress;
|
|
}
|
|
|
|
void
|
|
CScopeWizSetRange::UpdateButtons()
|
|
{
|
|
DWORD lStart, lEnd, lMask;
|
|
|
|
m_ipaStart.GetAddress(&lStart);
|
|
m_ipaEnd.GetAddress(&lEnd);
|
|
m_ipaSubnetMask.GetAddress(&lMask);
|
|
|
|
if (lStart && lEnd)
|
|
GetHolder()->SetWizardButtonsMiddle(TRUE);
|
|
else
|
|
GetHolder()->SetWizardButtonsMiddle(FALSE);
|
|
|
|
}
|
|
|
|
//
|
|
// Update the subnet mask field using either the length identifier or
|
|
// the acutal address as the base
|
|
//
|
|
void
|
|
CScopeWizSetRange::UpdateMask(BOOL bUseLength)
|
|
{
|
|
if (bUseLength)
|
|
{
|
|
DWORD dwAddress = 0xFFFFFFFF;
|
|
|
|
int nLength = m_spinMaskLength.GetPos();
|
|
if (nLength)
|
|
dwAddress = dwAddress << (32 - (DWORD) nLength);
|
|
else
|
|
dwAddress = 0;
|
|
|
|
m_ipaSubnetMask.SetAddress(dwAddress);
|
|
}
|
|
else
|
|
{
|
|
DWORD dwAddress, dwTestMask = 0x80000000;
|
|
int nLength = 0;
|
|
|
|
m_ipaSubnetMask.GetAddress(&dwAddress);
|
|
|
|
while (TRUE)
|
|
{
|
|
if (dwAddress & dwTestMask)
|
|
{
|
|
nLength++;
|
|
dwTestMask = dwTestMask >> 1;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
m_spinMaskLength.SetPos(nLength);
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Given the start and end IP addresses, suggest a good subnet mask
|
|
// (unless the latter has been filled in already, of course)
|
|
//
|
|
void
|
|
CScopeWizSetRange::SuggestSubnetMask()
|
|
{
|
|
DWORD lStart, lEnd, lMask, lMask2;
|
|
|
|
m_ipaSubnetMask.GetAddress(&lMask);
|
|
if (lMask != 0L)
|
|
{
|
|
//
|
|
// Already has an address, do nothing
|
|
//
|
|
return;
|
|
}
|
|
|
|
m_ipaStart.GetAddress(&lStart);
|
|
m_ipaEnd.GetAddress(&lEnd);
|
|
|
|
lMask = DefaultNetMaskForIpAddress( lStart );
|
|
lMask2 = DefaultNetMaskForIpAddress( lEnd );
|
|
/*
|
|
if (lMask != lMask2)
|
|
{
|
|
//
|
|
// Forget about suggesting a subnet mask
|
|
//
|
|
lMask = 0;
|
|
}
|
|
*/
|
|
m_bAutoUpdateMask = TRUE;
|
|
|
|
if (lMask != 0)
|
|
{
|
|
m_ipaSubnetMask.SetAddress(lMask);
|
|
UpdateMask(FALSE);
|
|
}
|
|
}
|
|
|
|
DWORD
|
|
CScopeWizSetRange::DefaultNetMaskForIpAddress
|
|
(
|
|
DWORD dwAddress
|
|
)
|
|
{
|
|
DWORD dwMask = 0L;
|
|
|
|
if (!(dwAddress & 0x80000000))
|
|
{
|
|
//
|
|
// Class A - mask 255.0.0.0
|
|
//
|
|
dwMask = 0xFF000000;
|
|
}
|
|
else
|
|
if (!(dwAddress & 0x40000000))
|
|
{
|
|
//
|
|
// Class B - mask 255.255.0.0
|
|
//
|
|
dwMask = 0xFFFF0000;
|
|
}
|
|
else
|
|
if (!(dwAddress & 0x20000000))
|
|
{
|
|
//
|
|
// Class C - mask 255.255.255.0
|
|
//
|
|
dwMask = 0xFFFFFF00;
|
|
}
|
|
|
|
return dwMask;
|
|
}
|
|
|
|
//
|
|
// Returns the Subnet IP identifier of either the
|
|
// scope's starting or ending IP Address.
|
|
//
|
|
DWORD
|
|
CScopeWizSetRange::DetermineSubnetId
|
|
(
|
|
BOOL bStartIpAddress
|
|
)
|
|
{
|
|
DWORD lAddress, lMask;
|
|
|
|
m_ipaSubnetMask.GetAddress(&lMask);
|
|
|
|
if (bStartIpAddress)
|
|
m_ipaStart.GetAddress(&lAddress);
|
|
else
|
|
m_ipaEnd.GetAddress(&lAddress);
|
|
|
|
return (lAddress & lMask);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CScopeWizSetExclusions property page
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
IMPLEMENT_DYNCREATE(CScopeWizSetExclusions, CPropertyPageBase)
|
|
|
|
CScopeWizSetExclusions::CScopeWizSetExclusions() : CPropertyPageBase(CScopeWizSetExclusions::IDD)
|
|
{
|
|
//{{AFX_DATA_INIT(CScopeWizSetExclusions)
|
|
//}}AFX_DATA_INIT
|
|
|
|
InitWiz97(FALSE, IDS_SCOPE_WIZ_EXCLUSIONS_TITLE, IDS_SCOPE_WIZ_EXCLUSIONS_SUBTITLE);
|
|
}
|
|
|
|
CScopeWizSetExclusions::~CScopeWizSetExclusions()
|
|
{
|
|
while (m_listExclusions.GetCount())
|
|
delete m_listExclusions.RemoveHead();
|
|
}
|
|
|
|
void CScopeWizSetExclusions::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CPropertyPageBase::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CScopeWizSetExclusions)
|
|
DDX_Control(pDX, IDC_LIST_EXCLUSION_RANGES, m_listboxExclusions);
|
|
DDX_Control(pDX, IDC_BUTTON_EXCLUSION_DELETE, m_buttonExclusionDelete);
|
|
DDX_Control(pDX, IDC_BUTTON_EXCLUSION_ADD, m_buttonExclusionAdd);
|
|
//}}AFX_DATA_MAP
|
|
|
|
//
|
|
// IP Address custom controls
|
|
//
|
|
DDX_Control(pDX, IDC_IPADDR_EXCLUSION_START, m_ipaStart);
|
|
DDX_Control(pDX, IDC_IPADDR_EXCLUSION_END, m_ipaEnd);
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CScopeWizSetExclusions, CPropertyPageBase)
|
|
//{{AFX_MSG_MAP(CScopeWizSetExclusions)
|
|
ON_BN_CLICKED(IDC_BUTTON_EXCLUSION_ADD, OnButtonExclusionAdd)
|
|
ON_BN_CLICKED(IDC_BUTTON_EXCLUSION_DELETE, OnButtonExclusionDelete)
|
|
//}}AFX_MSG_MAP
|
|
|
|
ON_EN_CHANGE(IDC_IPADDR_EXCLUSION_START, OnChangeExclusionStart)
|
|
ON_EN_CHANGE(IDC_IPADDR_EXCLUSION_END, OnChangeExclusionEnd)
|
|
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CScopeWizSetExclusions message handlers
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL CScopeWizSetExclusions::OnInitDialog()
|
|
{
|
|
CPropertyPageBase::OnInitDialog();
|
|
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
LRESULT CScopeWizSetExclusions::OnWizardNext()
|
|
{
|
|
return IDW_SCOPE_LEASE_TIME;
|
|
}
|
|
|
|
LRESULT CScopeWizSetExclusions::OnWizardBack()
|
|
{
|
|
return IDW_SCOPE_SET_SCOPE;
|
|
}
|
|
|
|
BOOL CScopeWizSetExclusions::OnSetActive()
|
|
{
|
|
GetHolder()->SetWizardButtonsMiddle(TRUE);
|
|
|
|
UpdateButtons();
|
|
|
|
return CPropertyPageBase::OnSetActive();
|
|
}
|
|
|
|
void CScopeWizSetExclusions::OnChangeExclusionStart()
|
|
{
|
|
UpdateButtons();
|
|
}
|
|
|
|
void CScopeWizSetExclusions::OnChangeExclusionEnd()
|
|
{
|
|
UpdateButtons();
|
|
}
|
|
|
|
void CScopeWizSetExclusions::OnButtonExclusionAdd()
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
|
|
DWORD err = 0;
|
|
CDhcpIpRange dhcpExclusionRange;
|
|
CDhcpIpRange dhcpScopeRange;
|
|
|
|
((CScopeWiz *)GetHolder())->GetScopeRange(&dhcpScopeRange);
|
|
|
|
//
|
|
// Get the data into a range object.
|
|
//
|
|
if ( !GetExclusionRange(dhcpExclusionRange) )
|
|
{
|
|
err = IDS_ERR_IP_RANGE_INVALID ;
|
|
}
|
|
else if ( IsOverlappingRange( dhcpExclusionRange ) )
|
|
{
|
|
//
|
|
// Walk the current list, determining if the new range is valid.
|
|
// Then, if OK, verify that it's really a sub-range of the current range.
|
|
//
|
|
err = IDS_ERR_IP_RANGE_OVERLAP ;
|
|
m_ipaStart.SetFocus();
|
|
}
|
|
else if ( ! dhcpExclusionRange.IsSubset( dhcpScopeRange ) )
|
|
{
|
|
//
|
|
// Guarantee that the new range is an (improper) subset of the scope's range
|
|
//
|
|
err = IDS_ERR_IP_RANGE_NOT_SUBSET ;
|
|
m_ipaStart.SetFocus();
|
|
}
|
|
if ( err == 0 )
|
|
{
|
|
//TRY
|
|
{
|
|
//
|
|
// Create a new IP range object and add it to the current list
|
|
//
|
|
CDhcpIpRange * pIpRange = new CDhcpIpRange( dhcpExclusionRange ) ;
|
|
|
|
m_listExclusions.AddTail(pIpRange);
|
|
|
|
//
|
|
// Refill the exclusions listbox including the new item.
|
|
//
|
|
Fill( (int) (m_listExclusions.GetCount() - 1) ) ;
|
|
}
|
|
//CATCH_ALL(e)
|
|
//{
|
|
// err = ERROR_NOT_ENOUGH_MEMORY ;
|
|
//}
|
|
//END_CATCH_ALL
|
|
}
|
|
|
|
if ( err )
|
|
{
|
|
::DhcpMessageBox( err ) ;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Succesfully added the exlusion range, now blank out the
|
|
// ip controls
|
|
//
|
|
m_ipaStart.ClearAddress();
|
|
m_ipaEnd.ClearAddress();
|
|
m_ipaStart.SetFocus();
|
|
}
|
|
}
|
|
|
|
void CScopeWizSetExclusions::OnButtonExclusionDelete()
|
|
{
|
|
//
|
|
// Index into the listbox, delete the item from the active list
|
|
// and move its data into the edit controls
|
|
//
|
|
int index = m_listboxExclusions.GetCurSel() ;
|
|
|
|
ASSERT( index >= 0 ) ; // Button should not be enabled if no selection.
|
|
if ( index < 0 )
|
|
{
|
|
return ;
|
|
}
|
|
|
|
POSITION pos = m_listExclusions.FindIndex(index);
|
|
CDhcpIpRange * pdhcRange = (CDhcpIpRange *) m_listExclusions.GetAt(pos);
|
|
|
|
m_listExclusions.RemoveAt(pos);
|
|
|
|
ASSERT( pdhcRange != NULL ) ;
|
|
|
|
//
|
|
// Put the deleted range into the exclusions controls
|
|
//
|
|
FillExcl( pdhcRange ) ;
|
|
|
|
//
|
|
// Refill the list box and call HandleActivation()
|
|
//
|
|
if ( index >= m_listboxExclusions.GetCount() )
|
|
{
|
|
index-- ;
|
|
}
|
|
|
|
Fill( index ) ;
|
|
|
|
m_ipaStart.SetFocus();
|
|
|
|
UpdateButtons();
|
|
}
|
|
|
|
//
|
|
// Format the IP range pair into the exclusion edit controls
|
|
//
|
|
void
|
|
CScopeWizSetExclusions::FillExcl
|
|
(
|
|
CDhcpIpRange * pdhcIpRange
|
|
)
|
|
{
|
|
LONG lStart = pdhcIpRange->QueryAddr( TRUE );
|
|
LONG lEnd = pdhcIpRange->QueryAddr( FALSE );
|
|
|
|
m_ipaStart.SetAddress( lStart ) ;
|
|
m_ipaStart.SetModify( TRUE ) ;
|
|
m_ipaStart.Invalidate() ;
|
|
|
|
//
|
|
// If the ending address is the same as the starting address,
|
|
// do not fill in the ending address.
|
|
//
|
|
if (lStart != lEnd)
|
|
{
|
|
m_ipaEnd.SetAddress( lEnd ) ;
|
|
}
|
|
else
|
|
{
|
|
m_ipaEnd.ClearAddress();
|
|
}
|
|
|
|
m_ipaEnd.SetModify( TRUE ) ;
|
|
m_ipaEnd.Invalidate() ;
|
|
}
|
|
|
|
//
|
|
// Convert the IP address range controls to a range.
|
|
//
|
|
BOOL
|
|
CScopeWizSetExclusions::GetExclusionRange
|
|
(
|
|
CDhcpIpRange & dhcIpRange
|
|
)
|
|
{
|
|
DHCP_IP_RANGE dhipr ;
|
|
|
|
if ( !m_ipaStart.GetAddress( & dhipr.StartAddress ) )
|
|
{
|
|
m_ipaStart.SetFocus();
|
|
return FALSE ;
|
|
}
|
|
if ( !m_ipaEnd.GetAddress( & dhipr.EndAddress ) )
|
|
{
|
|
//
|
|
// If no ending range was specified, assume a singular exlusion
|
|
// (the starting address) was requested.
|
|
//
|
|
m_ipaEnd.SetFocus();
|
|
dhipr.EndAddress = dhipr.StartAddress;
|
|
}
|
|
|
|
dhcIpRange = dhipr ;
|
|
return (BOOL) dhcIpRange ;
|
|
}
|
|
|
|
BOOL
|
|
CScopeWizSetExclusions::IsOverlappingRange
|
|
(
|
|
CDhcpIpRange & dhcpIpRange
|
|
)
|
|
{
|
|
POSITION pos;
|
|
CDhcpIpRange * pdhcpRange ;
|
|
BOOL bOverlap = FALSE ;
|
|
|
|
pos = m_listExclusions.GetHeadPosition();
|
|
while ( pos )
|
|
{
|
|
pdhcpRange = m_listExclusions.GetNext(pos);
|
|
if ( bOverlap = pdhcpRange->IsOverlap( dhcpIpRange ) )
|
|
{
|
|
break ;
|
|
}
|
|
}
|
|
|
|
return bOverlap ;
|
|
}
|
|
|
|
//
|
|
// Fill the exclusions listbox from the current list
|
|
//
|
|
void
|
|
CScopeWizSetExclusions::Fill
|
|
(
|
|
int nCurSel,
|
|
BOOL bToggleRedraw
|
|
)
|
|
{
|
|
POSITION pos;
|
|
CDhcpIpRange * pIpRange ;
|
|
CString strIp1 ;
|
|
CString strIp2 ;
|
|
CString strFormatPair ;
|
|
CString strFormatSingleton ;
|
|
TCHAR chBuff [STRING_LENGTH_MAX] ;
|
|
|
|
if ( ! strFormatPair.LoadString( IDS_INFO_FORMAT_IP_RANGE ) )
|
|
{
|
|
return ;
|
|
}
|
|
|
|
if ( ! strFormatSingleton.LoadString( IDS_INFO_FORMAT_IP_UNITARY ) )
|
|
{
|
|
return ;
|
|
}
|
|
|
|
if ( bToggleRedraw )
|
|
{
|
|
m_listboxExclusions.SetRedraw( FALSE ) ;
|
|
}
|
|
|
|
m_listboxExclusions.ResetContent() ;
|
|
pos = m_listExclusions.GetHeadPosition();
|
|
|
|
while ( pos )
|
|
{
|
|
pIpRange = m_listExclusions.GetNext(pos);
|
|
|
|
DHCP_IP_RANGE dhipr = *pIpRange ;
|
|
|
|
CString & strFmt = dhipr.StartAddress == dhipr.EndAddress
|
|
? strFormatSingleton
|
|
: strFormatPair ;
|
|
|
|
//
|
|
// Format the IP addresses
|
|
//
|
|
UtilCvtIpAddrToWstr( dhipr.StartAddress, &strIp1 ) ;
|
|
UtilCvtIpAddrToWstr( dhipr.EndAddress, &strIp2 ) ;
|
|
|
|
//
|
|
// Construct the display line
|
|
//
|
|
::wsprintf( chBuff,
|
|
(LPCTSTR) strFmt,
|
|
(LPCTSTR) strIp1,
|
|
(LPCTSTR) strIp2 ) ;
|
|
|
|
//
|
|
// Add it to the list box.
|
|
//
|
|
if ( m_listboxExclusions.AddString( chBuff ) < 0 )
|
|
{
|
|
break ;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Check that we loaded the list box successfully.
|
|
//
|
|
if ( pos != NULL )
|
|
{
|
|
AfxMessageBox( IDS_ERR_DLG_UPDATE ) ;
|
|
}
|
|
|
|
if ( bToggleRedraw )
|
|
{
|
|
m_listboxExclusions.SetRedraw( TRUE ) ;
|
|
m_listboxExclusions.Invalidate() ;
|
|
}
|
|
|
|
if ( nCurSel >= 0 )
|
|
{
|
|
m_listboxExclusions.SetCurSel( nCurSel ) ;
|
|
}
|
|
}
|
|
|
|
void CScopeWizSetExclusions::UpdateButtons()
|
|
{
|
|
DWORD dwAddress;
|
|
BOOL bEnable;
|
|
|
|
m_ipaStart.GetAddress(&dwAddress);
|
|
|
|
if (dwAddress)
|
|
{
|
|
bEnable = TRUE;
|
|
}
|
|
else
|
|
{
|
|
bEnable = FALSE;
|
|
if (m_buttonExclusionAdd.GetButtonStyle() & BS_DEFPUSHBUTTON)
|
|
{
|
|
m_buttonExclusionAdd.SetButtonStyle(BS_PUSHBUTTON);
|
|
}
|
|
}
|
|
m_buttonExclusionAdd.EnableWindow(bEnable);
|
|
|
|
if (m_listboxExclusions.GetCurSel() != LB_ERR)
|
|
{
|
|
bEnable = TRUE;
|
|
}
|
|
else
|
|
{
|
|
bEnable = FALSE;
|
|
if (m_buttonExclusionDelete.GetButtonStyle() & BS_DEFPUSHBUTTON)
|
|
{
|
|
m_buttonExclusionDelete.SetButtonStyle(BS_PUSHBUTTON);
|
|
}
|
|
}
|
|
m_buttonExclusionDelete.EnableWindow(bEnable);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CScopeWizLeaseTime property page
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
IMPLEMENT_DYNCREATE(CScopeWizLeaseTime, CPropertyPageBase)
|
|
|
|
CScopeWizLeaseTime::CScopeWizLeaseTime() : CPropertyPageBase(CScopeWizLeaseTime::IDD)
|
|
{
|
|
//{{AFX_DATA_INIT(CScopeWizLeaseTime)
|
|
//}}AFX_DATA_INIT
|
|
|
|
InitWiz97(FALSE, IDS_SCOPE_WIZ_LEASE_TITLE, IDS_SCOPE_WIZ_LEASE_SUBTITLE);
|
|
}
|
|
|
|
CScopeWizLeaseTime::~CScopeWizLeaseTime()
|
|
{
|
|
}
|
|
|
|
void CScopeWizLeaseTime::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CPropertyPageBase::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CScopeWizLeaseTime)
|
|
DDX_Control(pDX, IDC_SPIN_LEASE_MINUTES, m_spinMinutes);
|
|
DDX_Control(pDX, IDC_SPIN_LEASE_HOURS, m_spinHours);
|
|
DDX_Control(pDX, IDC_SPIN_LEASE_DAYS, m_spinDays);
|
|
DDX_Control(pDX, IDC_EDIT_LEASE_MINUTES, m_editMinutes);
|
|
DDX_Control(pDX, IDC_EDIT_LEASE_HOURS, m_editHours);
|
|
DDX_Control(pDX, IDC_EDIT_LEASE_DAYS, m_editDays);
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CScopeWizLeaseTime, CPropertyPageBase)
|
|
//{{AFX_MSG_MAP(CScopeWizLeaseTime)
|
|
ON_EN_CHANGE(IDC_EDIT_LEASE_HOURS, OnChangeEditLeaseHours)
|
|
ON_EN_CHANGE(IDC_EDIT_LEASE_MINUTES, OnChangeEditLeaseMinutes)
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CScopeWizLeaseTime message handlers
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL CScopeWizLeaseTime::OnInitDialog()
|
|
{
|
|
CPropertyPageBase::OnInitDialog();
|
|
|
|
m_spinMinutes.SetRange(0, MINUTES_MAX);
|
|
m_spinHours.SetRange(0, HOURS_MAX);
|
|
m_spinDays.SetRange(0, 999);
|
|
|
|
m_editMinutes.LimitText(2);
|
|
m_editHours.LimitText(2);
|
|
m_editDays.LimitText(3);
|
|
|
|
m_spinMinutes.SetPos(CScopeWizLeaseTime::m_nMinutesDefault);
|
|
m_spinHours.SetPos(CScopeWizLeaseTime::m_nHoursDefault);
|
|
m_spinDays.SetPos(CScopeWizLeaseTime::m_nDaysDefault);
|
|
|
|
ActivateDuration(TRUE);
|
|
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
LRESULT CScopeWizLeaseTime::OnWizardNext()
|
|
{
|
|
DWORD dwLeaseTime = GetLeaseTime();
|
|
if (dwLeaseTime == 0)
|
|
{
|
|
AfxMessageBox(IDS_ERR_NO_DURATION_SPECIFIED);
|
|
return -1;
|
|
}
|
|
else
|
|
{
|
|
return IDW_SCOPE_CONFIGURE_OPTIONS;
|
|
}
|
|
}
|
|
|
|
LRESULT CScopeWizLeaseTime::OnWizardBack()
|
|
{
|
|
CScopeWiz * pScopeWiz = reinterpret_cast<CScopeWiz *>(GetHolder());
|
|
if (pScopeWiz->GetCreateSuperscope())
|
|
{
|
|
return IDW_SCOPE_CREATE_SUPERSCOPE;
|
|
}
|
|
else
|
|
{
|
|
return IDW_SCOPE_SET_EXCLUSIONS;
|
|
}
|
|
}
|
|
|
|
BOOL CScopeWizLeaseTime::OnSetActive()
|
|
{
|
|
GetHolder()->SetWizardButtonsMiddle(TRUE);
|
|
|
|
return CPropertyPageBase::OnSetActive();
|
|
}
|
|
|
|
void CScopeWizLeaseTime::OnChangeEditLeaseHours()
|
|
{
|
|
if (IsWindow(m_editHours.GetSafeHwnd()))
|
|
{
|
|
CString strText;
|
|
m_editHours.GetWindowText(strText);
|
|
|
|
// check to see if the value is greater than the max
|
|
if (_ttoi(strText) > HOURS_MAX)
|
|
{
|
|
LPTSTR pBuf = strText.GetBuffer(5);
|
|
|
|
_itot(HOURS_MAX, pBuf, 10);
|
|
strText.ReleaseBuffer();
|
|
|
|
m_editHours.SetWindowText(strText);
|
|
m_spinHours.SetPos(HOURS_MAX);
|
|
|
|
MessageBeep(MB_ICONEXCLAMATION);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CScopeWizLeaseTime::OnChangeEditLeaseMinutes()
|
|
{
|
|
if (IsWindow(m_editMinutes.GetSafeHwnd()))
|
|
{
|
|
CString strText;
|
|
m_editMinutes.GetWindowText(strText);
|
|
|
|
// check to see if the value is greater than the max
|
|
if (_ttoi(strText) > MINUTES_MAX)
|
|
{
|
|
LPTSTR pBuf = strText.GetBuffer(5);
|
|
|
|
_itot(MINUTES_MAX, pBuf, 10);
|
|
strText.ReleaseBuffer();
|
|
|
|
m_editMinutes.SetWindowText(strText);
|
|
m_spinMinutes.SetPos(MINUTES_MAX);
|
|
|
|
MessageBeep(MB_ICONEXCLAMATION);
|
|
}
|
|
}
|
|
}
|
|
|
|
DWORD
|
|
CScopeWizLeaseTime::GetLeaseTime()
|
|
{
|
|
DWORD dwLeaseTime = 0;
|
|
|
|
int nDays, nHours, nMinutes;
|
|
|
|
nDays = m_spinDays.GetPos();
|
|
nHours = m_spinHours.GetPos();
|
|
nMinutes = m_spinMinutes.GetPos();
|
|
|
|
//
|
|
// Lease time is in minutes so convert
|
|
//
|
|
dwLeaseTime = UtilConvertLeaseTime(nDays, nHours, nMinutes);
|
|
|
|
return dwLeaseTime;
|
|
}
|
|
|
|
void
|
|
CScopeWizLeaseTime::ActivateDuration
|
|
(
|
|
BOOL fActive
|
|
)
|
|
{
|
|
m_spinMinutes.EnableWindow(fActive);
|
|
m_spinHours.EnableWindow(fActive);
|
|
m_spinDays.EnableWindow(fActive);
|
|
|
|
m_editMinutes.EnableWindow(fActive);
|
|
m_editHours.EnableWindow(fActive);
|
|
m_editDays.EnableWindow(fActive);
|
|
|
|
GetDlgItem(IDC_STATIC_DAYS)->EnableWindow(fActive);
|
|
GetDlgItem(IDC_STATIC_HOURS)->EnableWindow(fActive);
|
|
GetDlgItem(IDC_STATIC_MINUTES)->EnableWindow(fActive);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CScopeWizCreateSuperscope property page
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
IMPLEMENT_DYNCREATE(CScopeWizCreateSuperscope, CPropertyPageBase)
|
|
|
|
CScopeWizCreateSuperscope::CScopeWizCreateSuperscope() : CPropertyPageBase(CScopeWizCreateSuperscope::IDD)
|
|
{
|
|
//{{AFX_DATA_INIT(CScopeWizCreateSuperscope)
|
|
// NOTE: the ClassWizard will add member initialization here
|
|
//}}AFX_DATA_INIT
|
|
|
|
InitWiz97(FALSE, IDS_SCOPE_WIZ_SUPERSCOPE_TITLE, IDS_SCOPE_WIZ_SUPERSCOPE_SUBTITLE);
|
|
}
|
|
|
|
CScopeWizCreateSuperscope::~CScopeWizCreateSuperscope()
|
|
{
|
|
}
|
|
|
|
void CScopeWizCreateSuperscope::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CPropertyPageBase::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CScopeWizCreateSuperscope)
|
|
DDX_Control(pDX, IDC_STATIC_SUPERSCOPE_INFO, m_staticInfo);
|
|
DDX_Control(pDX, IDC_STATIC_WARNING_TEXT, m_staticWarning);
|
|
DDX_Control(pDX, IDC_STATIC_ICON_WARNING, m_staticIcon);
|
|
DDX_Control(pDX, IDC_RADIO_SUPERSCOPE_NO, m_radioNo);
|
|
DDX_Control(pDX, IDC_RADIO_SUPERSCOPE_YES, m_radioYes);
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CScopeWizCreateSuperscope, CPropertyPageBase)
|
|
//{{AFX_MSG_MAP(CScopeWizCreateSuperscope)
|
|
ON_BN_CLICKED(IDC_RADIO_SUPERSCOPE_NO, OnRadioSuperscopeNo)
|
|
ON_BN_CLICKED(IDC_RADIO_SUPERSCOPE_YES, OnRadioSuperscopeYes)
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CScopeWizCreateSuperscope message handlers
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL CScopeWizCreateSuperscope::OnInitDialog()
|
|
{
|
|
CPropertyPageBase::OnInitDialog();
|
|
|
|
m_radioNo.SetCheck(1);
|
|
m_radioYes.SetCheck(0);
|
|
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
LRESULT CScopeWizCreateSuperscope::OnWizardNext()
|
|
{
|
|
CScopeWiz * pScopeWiz = reinterpret_cast<CScopeWiz *>(GetHolder());
|
|
pScopeWiz->SetCreateSuperscope(TRUE);
|
|
|
|
return IDW_SCOPE_LEASE_TIME;
|
|
}
|
|
|
|
LRESULT CScopeWizCreateSuperscope::OnWizardBack()
|
|
{
|
|
return IDW_SCOPE_SET_SCOPE;
|
|
}
|
|
|
|
BOOL CScopeWizCreateSuperscope::OnSetActive()
|
|
{
|
|
UpdateButtons();
|
|
|
|
UpdateWarning();
|
|
|
|
return CPropertyPageBase::OnSetActive();
|
|
}
|
|
|
|
void CScopeWizCreateSuperscope::OnRadioSuperscopeNo()
|
|
{
|
|
m_radioNo.SetCheck(1);
|
|
m_radioYes.SetCheck(0);
|
|
|
|
UpdateButtons();
|
|
}
|
|
|
|
void CScopeWizCreateSuperscope::OnRadioSuperscopeYes()
|
|
{
|
|
m_radioNo.SetCheck(0);
|
|
m_radioYes.SetCheck(1);
|
|
|
|
UpdateButtons();
|
|
}
|
|
|
|
void
|
|
CScopeWizCreateSuperscope::UpdateButtons()
|
|
{
|
|
if (m_radioYes.GetCheck())
|
|
{
|
|
GetHolder()->SetWizardButtonsMiddle(TRUE);
|
|
}
|
|
else
|
|
{
|
|
GetHolder()->SetWizardButtonsMiddle(FALSE);
|
|
}
|
|
}
|
|
|
|
void
|
|
CScopeWizCreateSuperscope::UpdateWarning()
|
|
{
|
|
CScopeWiz * pScopeWiz = reinterpret_cast<CScopeWiz *>(GetHolder());
|
|
CString strText;
|
|
|
|
CDhcpIpRange ipRange;
|
|
DHCP_IP_ADDRESS dhcpSubnetMask;
|
|
DHCP_IP_ADDRESS startAddr, endAddr;
|
|
|
|
// get the range and mask the user entered
|
|
pScopeWiz->m_pageSetRange.GetScopeRange(&ipRange);
|
|
dhcpSubnetMask = pScopeWiz->m_pageSetRange.GetSubnetMask();
|
|
|
|
startAddr = ipRange.QueryAddr(TRUE);
|
|
endAddr = ipRange.QueryAddr(FALSE);
|
|
|
|
// now calculate how many addresses per scope
|
|
int nLength = pScopeWiz->m_pageSetRange.m_spinMaskLength.GetPos();
|
|
int nCount = 32 - nLength;
|
|
|
|
DWORD dwAddrCount = 1;
|
|
|
|
int nAddrCount = (int) (dwAddrCount << (nCount));
|
|
|
|
// calculate how many scopes are there
|
|
int nScopeCount = ((endAddr & dhcpSubnetMask) - (startAddr & dhcpSubnetMask)) >> nCount;
|
|
|
|
nScopeCount ++;
|
|
|
|
// put up the informative text
|
|
strText.Format(IDS_CREATE_SUPERSCOPE_INFO, nScopeCount, nAddrCount);
|
|
m_staticInfo.SetWindowText(strText);
|
|
|
|
// check to seee if we need to warn the user
|
|
BOOL fShowWarning = FALSE;
|
|
|
|
if (nScopeCount > SCOPE_WARNING_COUNT)
|
|
{
|
|
fShowWarning = TRUE;
|
|
|
|
HICON hIcon = AfxGetApp()->LoadStandardIcon(IDI_EXCLAMATION);
|
|
if (hIcon)
|
|
{
|
|
m_staticIcon.ShowWindow(TRUE);
|
|
m_staticIcon.SetIcon(hIcon);
|
|
}
|
|
|
|
strText.Format(IDS_CREATE_SUPERSCOPE_WARNING, SCOPE_WARNING_COUNT);
|
|
m_staticWarning.SetWindowText(strText);
|
|
}
|
|
|
|
m_staticIcon.ShowWindow(fShowWarning);
|
|
m_staticWarning.ShowWindow(fShowWarning);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CScopeWizFinished property page
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
IMPLEMENT_DYNCREATE(CScopeWizFinished, CPropertyPageBase)
|
|
|
|
CScopeWizFinished::CScopeWizFinished() : CPropertyPageBase(CScopeWizFinished::IDD)
|
|
{
|
|
//{{AFX_DATA_INIT(CScopeWizFinished)
|
|
// NOTE: the ClassWizard will add member initialization here
|
|
//}}AFX_DATA_INIT
|
|
|
|
InitWiz97(TRUE, 0, 0);
|
|
}
|
|
|
|
CScopeWizFinished::~CScopeWizFinished()
|
|
{
|
|
}
|
|
|
|
void CScopeWizFinished::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CPropertyPageBase::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CScopeWizFinished)
|
|
DDX_Control(pDX, IDC_STATIC_FINISHED_TITLE, m_staticTitle);
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CScopeWizFinished, CPropertyPageBase)
|
|
//{{AFX_MSG_MAP(CScopeWizFinished)
|
|
// NOTE: the ClassWizard will add message map macros here
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CScopeWizFinished message handlers
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL CScopeWizFinished::OnInitDialog()
|
|
{
|
|
CPropertyPageBase::OnInitDialog();
|
|
|
|
CString strFontName;
|
|
CString strFontSize;
|
|
|
|
strFontName.LoadString(IDS_BIG_BOLD_FONT_NAME);
|
|
strFontSize.LoadString(IDS_BIG_BOLD_FONT_SIZE);
|
|
|
|
CClientDC dc(this);
|
|
|
|
int nFontSize = _ttoi(strFontSize) * 10;
|
|
if (m_fontBig.CreatePointFont(nFontSize, strFontName, &dc))
|
|
m_staticTitle.SetFont(&m_fontBig);
|
|
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
LRESULT CScopeWizFinished::OnWizardBack()
|
|
{
|
|
CScopeWiz * pScopeWiz = reinterpret_cast<CScopeWiz *>(GetHolder());
|
|
if (pScopeWiz->m_fOptionsConfigured)
|
|
{
|
|
return IDW_SCOPE_CONFIGURE_ACTIVATE;
|
|
}
|
|
else
|
|
{
|
|
return IDW_SCOPE_CONFIGURE_OPTIONS;
|
|
}
|
|
}
|
|
|
|
BOOL CScopeWizFinished::OnWizardFinish()
|
|
{
|
|
DWORD err;
|
|
|
|
BEGIN_WAIT_CURSOR;
|
|
|
|
err = GetHolder()->OnFinish();
|
|
|
|
END_WAIT_CURSOR;
|
|
|
|
if (err)
|
|
{
|
|
::DhcpMessageBox(err);
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
BOOL CScopeWizFinished::OnSetActive()
|
|
{
|
|
GetHolder()->SetWizardButtonsLast(TRUE);
|
|
|
|
CScopeWiz * pScopeWiz = reinterpret_cast<CScopeWiz *>(GetHolder());
|
|
GetDlgItem(IDC_STATIC_FINISHED_MORE)->ShowWindow(!pScopeWiz->m_fOptionsConfigured);
|
|
GetDlgItem(IDC_STATIC_FINISHED_MORE2)->ShowWindow(!pScopeWiz->m_fOptionsConfigured);
|
|
GetDlgItem(IDC_STATIC_FINISHED_MORE3)->ShowWindow(!pScopeWiz->m_fOptionsConfigured);
|
|
|
|
return CPropertyPageBase::OnSetActive();
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CScopeWizWelcome property page
|
|
|
|
IMPLEMENT_DYNCREATE(CScopeWizWelcome, CPropertyPageBase)
|
|
|
|
CScopeWizWelcome::CScopeWizWelcome() : CPropertyPageBase(CScopeWizWelcome::IDD)
|
|
{
|
|
//{{AFX_DATA_INIT(CScopeWizWelcome)
|
|
// NOTE: the ClassWizard will add member initialization here
|
|
//}}AFX_DATA_INIT
|
|
|
|
InitWiz97(TRUE, 0, 0);
|
|
}
|
|
|
|
CScopeWizWelcome::~CScopeWizWelcome()
|
|
{
|
|
}
|
|
|
|
void CScopeWizWelcome::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CPropertyPageBase::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CScopeWizWelcome)
|
|
DDX_Control(pDX, IDC_STATIC_WELCOME_TITLE, m_staticTitle);
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CScopeWizWelcome, CPropertyPageBase)
|
|
//{{AFX_MSG_MAP(CScopeWizWelcome)
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CScopeWizWelcome message handlers
|
|
BOOL CScopeWizWelcome::OnInitDialog()
|
|
{
|
|
CPropertyPageBase::OnInitDialog();
|
|
|
|
CString strFontName;
|
|
CString strFontSize;
|
|
|
|
strFontName.LoadString(IDS_BIG_BOLD_FONT_NAME);
|
|
strFontSize.LoadString(IDS_BIG_BOLD_FONT_SIZE);
|
|
|
|
CClientDC dc(this);
|
|
|
|
int nFontSize = _ttoi(strFontSize) * 10;
|
|
if (m_fontBig.CreatePointFont(nFontSize, strFontName, &dc))
|
|
m_staticTitle.SetFont(&m_fontBig);
|
|
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
BOOL CScopeWizWelcome::OnSetActive()
|
|
{
|
|
GetHolder()->SetWizardButtonsFirst(TRUE);
|
|
|
|
return CPropertyPageBase::OnSetActive();
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CScopeWizConfigOptions property page
|
|
|
|
IMPLEMENT_DYNCREATE(CScopeWizConfigOptions, CPropertyPageBase)
|
|
|
|
CScopeWizConfigOptions::CScopeWizConfigOptions() : CPropertyPageBase(CScopeWizConfigOptions::IDD)
|
|
{
|
|
//{{AFX_DATA_INIT(CScopeWizConfigOptions)
|
|
// NOTE: the ClassWizard will add member initialization here
|
|
//}}AFX_DATA_INIT
|
|
InitWiz97(FALSE, IDS_SCOPE_WIZ_CONFIG_TITLE, IDS_SCOPE_WIZ_CONFIG_SUBTITLE);
|
|
}
|
|
|
|
CScopeWizConfigOptions::~CScopeWizConfigOptions()
|
|
{
|
|
}
|
|
|
|
void CScopeWizConfigOptions::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CPropertyPageBase::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CScopeWizConfigOptions)
|
|
// NOTE: the ClassWizard will add DDX and DDV calls here
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CScopeWizConfigOptions, CPropertyPageBase)
|
|
//{{AFX_MSG_MAP(CScopeWizConfigOptions)
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CScopeWizConfigOptions message handlers
|
|
|
|
BOOL CScopeWizConfigOptions::OnInitDialog()
|
|
{
|
|
CPropertyPageBase::OnInitDialog();
|
|
|
|
((CButton *) GetDlgItem(IDC_RADIO_YES))->SetCheck(TRUE);
|
|
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
LRESULT CScopeWizConfigOptions::OnWizardNext()
|
|
{
|
|
CScopeWiz * pScopeWiz = reinterpret_cast<CScopeWiz *>(GetHolder());
|
|
LRESULT lNextPage = IDW_SCOPE_FINISHED;
|
|
BOOL fConfigureOptionsNow = FALSE;
|
|
|
|
if (((CButton *) GetDlgItem(IDC_RADIO_YES))->GetCheck())
|
|
{
|
|
fConfigureOptionsNow = TRUE;
|
|
lNextPage = IDW_SCOPE_CONFIGURE_ROUTER;
|
|
}
|
|
|
|
pScopeWiz->m_fOptionsConfigured = fConfigureOptionsNow;
|
|
|
|
return lNextPage;
|
|
}
|
|
|
|
LRESULT CScopeWizConfigOptions::OnWizardBack()
|
|
{
|
|
return IDW_SCOPE_LEASE_TIME;
|
|
}
|
|
|
|
BOOL CScopeWizConfigOptions::OnSetActive()
|
|
{
|
|
GetHolder()->SetWizardButtonsMiddle(TRUE);
|
|
|
|
return CPropertyPageBase::OnSetActive();
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CScopeWizRouter property page
|
|
|
|
IMPLEMENT_DYNCREATE(CScopeWizRouter, CPropertyPageBase)
|
|
|
|
CScopeWizRouter::CScopeWizRouter() : CPropertyPageBase(CScopeWizRouter::IDD)
|
|
{
|
|
//{{AFX_DATA_INIT(CScopeWizRouter)
|
|
// NOTE: the ClassWizard will add member initialization here
|
|
//}}AFX_DATA_INIT
|
|
InitWiz97(FALSE, IDS_SCOPE_WIZ_ROUTER_TITLE, IDS_SCOPE_WIZ_ROUTER_SUBTITLE);
|
|
}
|
|
|
|
CScopeWizRouter::~CScopeWizRouter()
|
|
{
|
|
}
|
|
|
|
void CScopeWizRouter::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CPropertyPageBase::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CScopeWizRouter)
|
|
DDX_Control(pDX, IDC_LIST_DEFAULT_GW_LIST, m_listboxRouters);
|
|
DDX_Control(pDX, IDC_BUTTON_DEFAULT_GW_DELETE, m_buttonDelete);
|
|
DDX_Control(pDX, IDC_BUTTON_DEFAULT_GW_ADD, m_buttonAdd);
|
|
DDX_Control(pDX, IDC_BUTTON_IPADDR_UP, m_buttonIpAddrUp);
|
|
DDX_Control(pDX, IDC_BUTTON_IPADDR_DOWN, m_buttonIpAddrDown);
|
|
//}}AFX_DATA_MAP
|
|
|
|
DDX_Control(pDX, IDC_IPADDR_DEFAULT_GW, m_ipaRouter);
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CScopeWizRouter, CPropertyPageBase)
|
|
//{{AFX_MSG_MAP(CScopeWizRouter)
|
|
ON_BN_CLICKED(IDC_BUTTON_DEFAULT_GW_ADD, OnButtonDefaultGwAdd)
|
|
ON_BN_CLICKED(IDC_BUTTON_DEFAULT_GW_DELETE, OnButtonDefaultGwDelete)
|
|
ON_LBN_SELCHANGE(IDC_LIST_DEFAULT_GW_LIST, OnSelchangeListDefaultGwList)
|
|
ON_EN_CHANGE(IDC_IPADDR_DEFAULT_GW, OnChangeRouter)
|
|
ON_WM_DESTROY()
|
|
//}}AFX_MSG_MAP
|
|
|
|
ON_BN_CLICKED(IDC_BUTTON_IPADDR_UP, OnButtonIpAddrUp)
|
|
ON_BN_CLICKED(IDC_BUTTON_IPADDR_DOWN, OnButtonIpAddrDown)
|
|
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CScopeWizRouter message handlers
|
|
|
|
BOOL CScopeWizRouter::OnInitDialog()
|
|
{
|
|
CPropertyPageBase::OnInitDialog();
|
|
|
|
m_buttonDelete.EnableWindow(FALSE);
|
|
m_buttonAdd.EnableWindow(FALSE);
|
|
|
|
UpdateButtons();
|
|
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
void CScopeWizRouter::OnDestroy()
|
|
{
|
|
CPropertyPageBase::OnDestroy();
|
|
}
|
|
|
|
LRESULT CScopeWizRouter::OnWizardNext()
|
|
{
|
|
CScopeWiz * pScopeWiz = reinterpret_cast<CScopeWiz *>(GetHolder());
|
|
|
|
// now build the option info for the routers
|
|
if (m_listboxRouters.GetCount() == 0)
|
|
{
|
|
if (pScopeWiz->m_poptRouters)
|
|
{
|
|
delete pScopeWiz->m_poptRouters;
|
|
pScopeWiz->m_poptRouters = NULL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// we have some DNS servers, get the option info from the master list and build an
|
|
// option info struct we can use later
|
|
CDhcpOption * pRoutersOption = pScopeWiz->m_pDefaultOptions->Find(DHCP_OPTION_ID_ROUTERS, NULL);
|
|
if (pRoutersOption)
|
|
{
|
|
CDhcpOption * pNewRouters;
|
|
|
|
if (pScopeWiz->m_poptRouters)
|
|
pNewRouters = pScopeWiz->m_poptRouters;
|
|
else
|
|
pNewRouters = new CDhcpOption(*pRoutersOption);
|
|
|
|
if (pNewRouters)
|
|
{
|
|
CDhcpOptionValue optValue = pNewRouters->QueryValue();
|
|
|
|
optValue.SetUpperBound(m_listboxRouters.GetCount());
|
|
|
|
// grab stuff from the listbox and store it in the option value
|
|
for (int i = 0; i < m_listboxRouters.GetCount(); i++)
|
|
{
|
|
DWORD dwIp = (DWORD) m_listboxRouters.GetItemData(i);
|
|
optValue.SetIpAddr(dwIp, i);
|
|
}
|
|
|
|
pNewRouters->Update(optValue);
|
|
|
|
pScopeWiz->m_poptRouters = pNewRouters;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
return CPropertyPageBase::OnWizardNext();
|
|
}
|
|
|
|
LRESULT CScopeWizRouter::OnWizardBack()
|
|
{
|
|
return CPropertyPageBase::OnWizardBack();
|
|
}
|
|
|
|
BOOL CScopeWizRouter::OnSetActive()
|
|
{
|
|
return CPropertyPageBase::OnSetActive();
|
|
}
|
|
|
|
void CScopeWizRouter::OnButtonDefaultGwAdd()
|
|
{
|
|
DWORD dwIp;
|
|
m_ipaRouter.GetAddress(&dwIp);
|
|
|
|
if (dwIp)
|
|
{
|
|
CString strText;
|
|
|
|
UtilCvtIpAddrToWstr(dwIp, &strText);
|
|
int nIndex = m_listboxRouters.AddString(strText);
|
|
m_listboxRouters.SetItemData(nIndex, dwIp);
|
|
}
|
|
|
|
m_ipaRouter.ClearAddress();
|
|
m_ipaRouter.SetFocus();
|
|
}
|
|
|
|
void CScopeWizRouter::OnButtonDefaultGwDelete()
|
|
{
|
|
int nSel = m_listboxRouters.GetCurSel();
|
|
if (nSel != LB_ERR)
|
|
{
|
|
m_ipaRouter.SetAddress((DWORD)m_listboxRouters.GetItemData(nSel));
|
|
m_listboxRouters.DeleteString(nSel);
|
|
m_ipaRouter.SetFocus();
|
|
}
|
|
|
|
UpdateButtons();
|
|
}
|
|
|
|
void CScopeWizRouter::OnSelchangeListDefaultGwList()
|
|
{
|
|
UpdateButtons();
|
|
}
|
|
|
|
void CScopeWizRouter::OnChangeRouter()
|
|
{
|
|
UpdateButtons();
|
|
}
|
|
|
|
void CScopeWizRouter::UpdateButtons()
|
|
{
|
|
DWORD dwAddress;
|
|
BOOL bEnable;
|
|
|
|
m_ipaRouter.GetAddress(&dwAddress);
|
|
|
|
if (dwAddress)
|
|
{
|
|
bEnable = TRUE;
|
|
}
|
|
else
|
|
{
|
|
bEnable = FALSE;
|
|
if (m_buttonAdd.GetButtonStyle() & BS_DEFPUSHBUTTON)
|
|
{
|
|
m_buttonAdd.SetButtonStyle(BS_PUSHBUTTON);
|
|
}
|
|
}
|
|
m_buttonAdd.EnableWindow(bEnable);
|
|
|
|
if (m_listboxRouters.GetCurSel() != LB_ERR)
|
|
{
|
|
bEnable = TRUE;
|
|
}
|
|
else
|
|
{
|
|
bEnable = FALSE;
|
|
if (m_buttonDelete.GetButtonStyle() & BS_DEFPUSHBUTTON)
|
|
{
|
|
m_buttonDelete.SetButtonStyle(BS_PUSHBUTTON);
|
|
}
|
|
}
|
|
m_buttonDelete.EnableWindow(bEnable);
|
|
|
|
// up and down buttons
|
|
BOOL bEnableUp = (m_listboxRouters.GetCurSel() >= 0) && (m_listboxRouters.GetCurSel() != 0);
|
|
m_buttonIpAddrUp.EnableWindow(bEnableUp);
|
|
|
|
BOOL bEnableDown = (m_listboxRouters.GetCurSel() >= 0) && (m_listboxRouters.GetCurSel() < m_listboxRouters.GetCount() - 1);
|
|
m_buttonIpAddrDown.EnableWindow(bEnableDown);
|
|
}
|
|
|
|
void CScopeWizRouter::OnButtonIpAddrDown()
|
|
{
|
|
MoveValue(FALSE);
|
|
if (m_buttonIpAddrDown.IsWindowEnabled())
|
|
m_buttonIpAddrDown.SetFocus();
|
|
else
|
|
m_buttonIpAddrUp.SetFocus();
|
|
}
|
|
|
|
void CScopeWizRouter::OnButtonIpAddrUp()
|
|
{
|
|
MoveValue(TRUE);
|
|
if (m_buttonIpAddrUp.IsWindowEnabled())
|
|
m_buttonIpAddrUp.SetFocus();
|
|
else
|
|
m_buttonIpAddrDown.SetFocus();
|
|
}
|
|
|
|
void CScopeWizRouter::MoveValue(BOOL bUp)
|
|
{
|
|
// now get which item is selected in the listbox
|
|
int cFocus = m_listboxRouters.GetCurSel();
|
|
int cNewFocus;
|
|
DWORD err;
|
|
|
|
// make sure it's valid for this operation
|
|
if ( (bUp && cFocus <= 0) ||
|
|
(!bUp && cFocus >= m_listboxRouters.GetCount()) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
// move the value up/down
|
|
CATCH_MEM_EXCEPTION
|
|
{
|
|
if (bUp)
|
|
{
|
|
cNewFocus = cFocus - 1;
|
|
}
|
|
else
|
|
{
|
|
cNewFocus = cFocus + 1;
|
|
}
|
|
|
|
// remove the old one
|
|
DWORD dwIp = (DWORD) m_listboxRouters.GetItemData(cFocus);
|
|
m_listboxRouters.DeleteString(cFocus);
|
|
|
|
// re-add it in it's new home
|
|
CString strText;
|
|
UtilCvtIpAddrToWstr(dwIp, &strText);
|
|
m_listboxRouters.InsertString(cNewFocus, strText);
|
|
m_listboxRouters.SetItemData(cNewFocus, dwIp);
|
|
|
|
m_listboxRouters.SetCurSel(cNewFocus);
|
|
}
|
|
END_MEM_EXCEPTION(err)
|
|
|
|
UpdateButtons();
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CScopeWizDNS property page
|
|
|
|
IMPLEMENT_DYNCREATE(CScopeWizDNS, CPropertyPageBase)
|
|
|
|
CScopeWizDNS::CScopeWizDNS() : CPropertyPageBase(CScopeWizDNS::IDD)
|
|
{
|
|
//{{AFX_DATA_INIT(CScopeWizDNS)
|
|
//}}AFX_DATA_INIT
|
|
InitWiz97(FALSE, IDS_SCOPE_WIZ_DNS_TITLE, IDS_SCOPE_WIZ_DNS_SUBTITLE);
|
|
}
|
|
|
|
CScopeWizDNS::~CScopeWizDNS()
|
|
{
|
|
}
|
|
|
|
void CScopeWizDNS::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CPropertyPageBase::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CScopeWizDNS)
|
|
DDX_Control(pDX, IDC_EDIT_SERVER_NAME, m_editServerName);
|
|
DDX_Control(pDX, IDC_BUTTON_RESOLVE, m_buttonResolve);
|
|
DDX_Control(pDX, IDC_BUTTON_DNS_DELETE, m_buttonDelete);
|
|
DDX_Control(pDX, IDC_BUTTON_DNS_ADD, m_buttonAdd);
|
|
DDX_Control(pDX, IDC_EDIT_DOMAIN_NAME, m_editDomainName);
|
|
DDX_Control(pDX, IDC_LIST_DNS_LIST, m_listboxDNSServers);
|
|
DDX_Control(pDX, IDC_BUTTON_IPADDR_UP, m_buttonIpAddrUp);
|
|
DDX_Control(pDX, IDC_BUTTON_IPADDR_DOWN, m_buttonIpAddrDown);
|
|
//}}AFX_DATA_MAP
|
|
|
|
DDX_Control(pDX, IDC_IPADDR_DNS_SERVER, m_ipaDNS);
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CScopeWizDNS, CPropertyPageBase)
|
|
//{{AFX_MSG_MAP(CScopeWizDNS)
|
|
ON_BN_CLICKED(IDC_BUTTON_DNS_ADD, OnButtonDnsAdd)
|
|
ON_BN_CLICKED(IDC_BUTTON_DNS_DELETE, OnButtonDnsDelete)
|
|
ON_LBN_SELCHANGE(IDC_LIST_DNS_LIST, OnSelchangeListDnsList)
|
|
ON_EN_CHANGE(IDC_IPADDR_DNS_SERVER, OnChangeDnsServer)
|
|
ON_WM_DESTROY()
|
|
ON_EN_CHANGE(IDC_EDIT_SERVER_NAME, OnChangeEditServerName)
|
|
ON_BN_CLICKED(IDC_BUTTON_RESOLVE, OnButtonResolve)
|
|
//}}AFX_MSG_MAP
|
|
|
|
ON_BN_CLICKED(IDC_BUTTON_IPADDR_UP, OnButtonIpAddrUp)
|
|
ON_BN_CLICKED(IDC_BUTTON_IPADDR_DOWN, OnButtonIpAddrDown)
|
|
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CScopeWizDNS message handlers
|
|
|
|
BOOL CScopeWizDNS::OnInitDialog()
|
|
{
|
|
CPropertyPageBase::OnInitDialog();
|
|
|
|
m_buttonDelete.EnableWindow(FALSE);
|
|
m_buttonAdd.EnableWindow(FALSE);
|
|
|
|
UpdateButtons();
|
|
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
void CScopeWizDNS::OnDestroy()
|
|
{
|
|
CPropertyPageBase::OnDestroy();
|
|
}
|
|
|
|
LRESULT CScopeWizDNS::OnWizardNext()
|
|
{
|
|
// build the option stuff for the domain name
|
|
CScopeWiz * pScopeWiz = reinterpret_cast<CScopeWiz *>(GetHolder());
|
|
CString strText;
|
|
|
|
m_editDomainName.GetWindowText(strText);
|
|
if (strText.IsEmpty())
|
|
{
|
|
if (pScopeWiz->m_poptDomainName)
|
|
{
|
|
delete pScopeWiz->m_poptDomainName;
|
|
pScopeWiz->m_poptDomainName = NULL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// we have a domain name, get the option info from the master list and build an
|
|
// option info struct we can use later
|
|
CDhcpOption * pDomainNameOption = pScopeWiz->m_pDefaultOptions->Find(DHCP_OPTION_ID_DOMAIN_NAME, NULL);
|
|
if (pDomainNameOption)
|
|
{
|
|
CDhcpOption * pNewDomainName;
|
|
|
|
if (pScopeWiz->m_poptDomainName)
|
|
pNewDomainName = pScopeWiz->m_poptDomainName;
|
|
else
|
|
pNewDomainName = new CDhcpOption(*pDomainNameOption);
|
|
|
|
if (pNewDomainName)
|
|
{
|
|
CDhcpOptionValue optValue = pNewDomainName->QueryValue();
|
|
|
|
optValue.SetString(strText);
|
|
pNewDomainName->Update(optValue);
|
|
|
|
pScopeWiz->m_poptDomainName = pNewDomainName;
|
|
}
|
|
}
|
|
}
|
|
|
|
// now build the option info for the DNS servers
|
|
if (m_listboxDNSServers.GetCount() == 0)
|
|
{
|
|
if (pScopeWiz->m_poptDNSServers)
|
|
{
|
|
delete pScopeWiz->m_poptDNSServers;
|
|
pScopeWiz->m_poptDNSServers = NULL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// we have some DNS servers, get the option info from the master list and build an
|
|
// option info struct we can use later
|
|
CDhcpOption * pDNSServersOption = pScopeWiz->m_pDefaultOptions->Find(DHCP_OPTION_ID_DNS_SERVERS, NULL);
|
|
if (pDNSServersOption)
|
|
{
|
|
CDhcpOption * pNewDNS;
|
|
|
|
if (pScopeWiz->m_poptDNSServers)
|
|
pNewDNS = pScopeWiz->m_poptDNSServers;
|
|
else
|
|
pNewDNS = new CDhcpOption(*pDNSServersOption);
|
|
|
|
if (pNewDNS)
|
|
{
|
|
CDhcpOptionValue optValue = pNewDNS->QueryValue();
|
|
|
|
optValue.SetUpperBound(m_listboxDNSServers.GetCount());
|
|
|
|
// grab stuff from the listbox and store it in the option value
|
|
for (int i = 0; i < m_listboxDNSServers.GetCount(); i++)
|
|
{
|
|
DWORD dwIp = (DWORD)m_listboxDNSServers.GetItemData(i);
|
|
optValue.SetIpAddr(dwIp, i);
|
|
}
|
|
|
|
pNewDNS->Update(optValue);
|
|
|
|
pScopeWiz->m_poptDNSServers = pNewDNS;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
return CPropertyPageBase::OnWizardNext();
|
|
}
|
|
|
|
LRESULT CScopeWizDNS::OnWizardBack()
|
|
{
|
|
return CPropertyPageBase::OnWizardBack();
|
|
}
|
|
|
|
BOOL CScopeWizDNS::OnSetActive()
|
|
{
|
|
return CPropertyPageBase::OnSetActive();
|
|
}
|
|
|
|
void CScopeWizDNS::OnButtonDnsAdd()
|
|
{
|
|
DWORD dwIp;
|
|
m_ipaDNS.GetAddress(&dwIp);
|
|
|
|
if (dwIp)
|
|
{
|
|
CString strText;
|
|
|
|
UtilCvtIpAddrToWstr(dwIp, &strText);
|
|
int nIndex = m_listboxDNSServers.AddString(strText);
|
|
m_listboxDNSServers.SetItemData(nIndex, dwIp);
|
|
}
|
|
|
|
m_ipaDNS.ClearAddress();
|
|
m_ipaDNS.SetFocus();
|
|
}
|
|
|
|
void CScopeWizDNS::OnButtonDnsDelete()
|
|
{
|
|
int nSel = m_listboxDNSServers.GetCurSel();
|
|
if (nSel != LB_ERR)
|
|
{
|
|
m_ipaDNS.SetAddress((DWORD)m_listboxDNSServers.GetItemData(nSel));
|
|
m_listboxDNSServers.DeleteString(nSel);
|
|
m_ipaDNS.SetFocus();
|
|
}
|
|
|
|
UpdateButtons();
|
|
}
|
|
|
|
void CScopeWizDNS::OnSelchangeListDnsList()
|
|
{
|
|
UpdateButtons();
|
|
}
|
|
|
|
void CScopeWizDNS::OnChangeDnsServer()
|
|
{
|
|
UpdateButtons();
|
|
}
|
|
|
|
void CScopeWizDNS::UpdateButtons()
|
|
{
|
|
DWORD dwAddress;
|
|
BOOL bEnable;
|
|
CString strServerName;
|
|
|
|
// update the resolve button
|
|
m_editServerName.GetWindowText(strServerName);
|
|
m_buttonResolve.EnableWindow(strServerName.GetLength() > 0);
|
|
|
|
m_ipaDNS.GetAddress(&dwAddress);
|
|
|
|
if (dwAddress)
|
|
{
|
|
bEnable = TRUE;
|
|
}
|
|
else
|
|
{
|
|
bEnable = FALSE;
|
|
if (m_buttonAdd.GetButtonStyle() & BS_DEFPUSHBUTTON)
|
|
{
|
|
m_buttonAdd.SetButtonStyle(BS_PUSHBUTTON);
|
|
}
|
|
}
|
|
m_buttonAdd.EnableWindow(bEnable);
|
|
|
|
if (m_listboxDNSServers.GetCurSel() != LB_ERR)
|
|
{
|
|
bEnable = TRUE;
|
|
}
|
|
else
|
|
{
|
|
bEnable = FALSE;
|
|
if (m_buttonDelete.GetButtonStyle() & BS_DEFPUSHBUTTON)
|
|
{
|
|
m_buttonDelete.SetButtonStyle(BS_PUSHBUTTON);
|
|
}
|
|
}
|
|
m_buttonDelete.EnableWindow(bEnable);
|
|
|
|
// up and down buttons
|
|
BOOL bEnableUp = (m_listboxDNSServers.GetCurSel() >= 0) && (m_listboxDNSServers.GetCurSel() != 0);
|
|
m_buttonIpAddrUp.EnableWindow(bEnableUp);
|
|
|
|
BOOL bEnableDown = (m_listboxDNSServers.GetCurSel() >= 0) && (m_listboxDNSServers.GetCurSel() < m_listboxDNSServers.GetCount() - 1);
|
|
m_buttonIpAddrDown.EnableWindow(bEnableDown);
|
|
}
|
|
|
|
void CScopeWizDNS::OnButtonIpAddrDown()
|
|
{
|
|
MoveValue(FALSE);
|
|
if (m_buttonIpAddrDown.IsWindowEnabled())
|
|
m_buttonIpAddrDown.SetFocus();
|
|
else
|
|
m_buttonIpAddrUp.SetFocus();
|
|
}
|
|
|
|
void CScopeWizDNS::OnButtonIpAddrUp()
|
|
{
|
|
MoveValue(TRUE);
|
|
if (m_buttonIpAddrUp.IsWindowEnabled())
|
|
m_buttonIpAddrUp.SetFocus();
|
|
else
|
|
m_buttonIpAddrDown.SetFocus();
|
|
}
|
|
|
|
void CScopeWizDNS::MoveValue(BOOL bUp)
|
|
{
|
|
// now get which item is selected in the listbox
|
|
int cFocus = m_listboxDNSServers.GetCurSel();
|
|
int cNewFocus;
|
|
DWORD err;
|
|
|
|
// make sure it's valid for this operation
|
|
if ( (bUp && cFocus <= 0) ||
|
|
(!bUp && cFocus >= m_listboxDNSServers.GetCount()) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
// move the value up/down
|
|
CATCH_MEM_EXCEPTION
|
|
{
|
|
if (bUp)
|
|
{
|
|
cNewFocus = cFocus - 1;
|
|
}
|
|
else
|
|
{
|
|
cNewFocus = cFocus + 1;
|
|
}
|
|
|
|
// remove the old one
|
|
DWORD dwIp = (DWORD) m_listboxDNSServers.GetItemData(cFocus);
|
|
m_listboxDNSServers.DeleteString(cFocus);
|
|
|
|
// re-add it in it's new home
|
|
CString strText;
|
|
UtilCvtIpAddrToWstr(dwIp, &strText);
|
|
m_listboxDNSServers.InsertString(cNewFocus, strText);
|
|
m_listboxDNSServers.SetItemData(cNewFocus, dwIp);
|
|
|
|
m_listboxDNSServers.SetCurSel(cNewFocus);
|
|
}
|
|
END_MEM_EXCEPTION(err)
|
|
|
|
UpdateButtons();
|
|
}
|
|
|
|
void CScopeWizDNS::OnChangeEditServerName()
|
|
{
|
|
UpdateButtons();
|
|
}
|
|
|
|
void CScopeWizDNS::OnButtonResolve()
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
|
|
CString strServer;
|
|
DHCP_IP_ADDRESS dhipa = 0;
|
|
DWORD err = 0;
|
|
|
|
m_editServerName.GetWindowText(strServer);
|
|
|
|
//
|
|
// See what type of name it is.
|
|
//
|
|
BEGIN_WAIT_CURSOR
|
|
|
|
switch (UtilCategorizeName(strServer))
|
|
{
|
|
case HNM_TYPE_IP:
|
|
dhipa = ::UtilCvtWstrToIpAddr( strServer ) ;
|
|
break ;
|
|
|
|
case HNM_TYPE_NB:
|
|
case HNM_TYPE_DNS:
|
|
err = ::UtilGetHostAddress( strServer, & dhipa ) ;
|
|
if (!err)
|
|
UtilCvtIpAddrToWstr(dhipa, &strServer);
|
|
break ;
|
|
|
|
default:
|
|
err = IDS_ERR_BAD_HOST_NAME ;
|
|
break ;
|
|
}
|
|
|
|
END_WAIT_CURSOR
|
|
|
|
if (err)
|
|
{
|
|
::DhcpMessageBox(err);
|
|
}
|
|
else
|
|
{
|
|
m_ipaDNS.SetAddress(dhipa);
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CScopeWizWINS property page
|
|
|
|
IMPLEMENT_DYNCREATE(CScopeWizWINS, CPropertyPageBase)
|
|
|
|
CScopeWizWINS::CScopeWizWINS() : CPropertyPageBase(CScopeWizWINS::IDD)
|
|
{
|
|
//{{AFX_DATA_INIT(CScopeWizWINS)
|
|
//}}AFX_DATA_INIT
|
|
InitWiz97(FALSE, IDS_SCOPE_WIZ_WINS_TITLE, IDS_SCOPE_WIZ_WINS_SUBTITLE);
|
|
}
|
|
|
|
CScopeWizWINS::~CScopeWizWINS()
|
|
{
|
|
}
|
|
|
|
void CScopeWizWINS::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CPropertyPageBase::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CScopeWizWINS)
|
|
DDX_Control(pDX, IDC_BUTTON_RESOLVE, m_buttonResolve);
|
|
DDX_Control(pDX, IDC_EDIT_SERVER_NAME, m_editServerName);
|
|
DDX_Control(pDX, IDC_LIST_WINS_LIST, m_listboxWINSServers);
|
|
DDX_Control(pDX, IDC_BUTTON_WINS_DELETE, m_buttonDelete);
|
|
DDX_Control(pDX, IDC_BUTTON_WINS_ADD, m_buttonAdd);
|
|
DDX_Control(pDX, IDC_BUTTON_IPADDR_UP, m_buttonIpAddrUp);
|
|
DDX_Control(pDX, IDC_BUTTON_IPADDR_DOWN, m_buttonIpAddrDown);
|
|
//}}AFX_DATA_MAP
|
|
|
|
DDX_Control(pDX, IDC_IPADDR_WINS_SERVER, m_ipaWINS);
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CScopeWizWINS, CPropertyPageBase)
|
|
//{{AFX_MSG_MAP(CScopeWizWINS)
|
|
ON_BN_CLICKED(IDC_BUTTON_WINS_ADD, OnButtonWinsAdd)
|
|
ON_BN_CLICKED(IDC_BUTTON_WINS_DELETE, OnButtonWinsDelete)
|
|
ON_LBN_SELCHANGE(IDC_LIST_WINS_LIST, OnSelchangeListWinsList)
|
|
ON_EN_CHANGE(IDC_IPADDR_WINS_SERVER, OnChangeWinsServer)
|
|
ON_WM_DESTROY()
|
|
ON_BN_CLICKED(IDC_BUTTON_RESOLVE, OnButtonResolve)
|
|
ON_EN_CHANGE(IDC_EDIT_SERVER_NAME, OnChangeEditServerName)
|
|
//}}AFX_MSG_MAP
|
|
|
|
ON_BN_CLICKED(IDC_BUTTON_IPADDR_UP, OnButtonIpAddrUp)
|
|
ON_BN_CLICKED(IDC_BUTTON_IPADDR_DOWN, OnButtonIpAddrDown)
|
|
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CScopeWizWINS message handlers
|
|
|
|
BOOL CScopeWizWINS::OnInitDialog()
|
|
{
|
|
CPropertyPageBase::OnInitDialog();
|
|
|
|
m_buttonAdd.EnableWindow(FALSE);
|
|
m_buttonDelete.EnableWindow(FALSE);
|
|
|
|
UpdateButtons();
|
|
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
void CScopeWizWINS::OnDestroy()
|
|
{
|
|
CPropertyPageBase::OnDestroy();
|
|
}
|
|
|
|
LRESULT CScopeWizWINS::OnWizardNext()
|
|
{
|
|
CScopeWiz * pScopeWiz = reinterpret_cast<CScopeWiz *>(GetHolder());
|
|
|
|
// now build the option info for the routers
|
|
if (m_listboxWINSServers.GetCount() == 0)
|
|
{
|
|
// get rid of the servers option if it is there
|
|
if (pScopeWiz->m_poptWINSServers)
|
|
{
|
|
delete pScopeWiz->m_poptWINSServers;
|
|
pScopeWiz->m_poptWINSServers = NULL;
|
|
}
|
|
|
|
// get rid of the node type option as well
|
|
if (pScopeWiz->m_poptWINSNodeType)
|
|
{
|
|
delete pScopeWiz->m_poptWINSNodeType;
|
|
pScopeWiz->m_poptWINSNodeType = NULL;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
// we have some DNS servers, get the option info from the master list and build an
|
|
// option info struct we can use later
|
|
CDhcpOption * pWINSServersOption = pScopeWiz->m_pDefaultOptions->Find(DHCP_OPTION_ID_WINS_SERVERS, NULL);
|
|
if (pWINSServersOption)
|
|
{
|
|
CDhcpOption * pNewWINS;
|
|
|
|
if (pScopeWiz->m_poptWINSServers)
|
|
pNewWINS = pScopeWiz->m_poptWINSServers;
|
|
else
|
|
pNewWINS = new CDhcpOption(*pWINSServersOption);
|
|
|
|
if (pNewWINS)
|
|
{
|
|
CDhcpOptionValue optValue = pNewWINS->QueryValue();
|
|
|
|
optValue.SetUpperBound(m_listboxWINSServers.GetCount());
|
|
|
|
// grab stuff from the listbox and store it in the option value
|
|
for (int i = 0; i < m_listboxWINSServers.GetCount(); i++)
|
|
{
|
|
DWORD dwIp = (DWORD)m_listboxWINSServers.GetItemData(i);
|
|
optValue.SetIpAddr(dwIp, i);
|
|
}
|
|
|
|
pNewWINS->Update(optValue);
|
|
|
|
pScopeWiz->m_poptWINSServers = pNewWINS;
|
|
}
|
|
}
|
|
|
|
// if we are configuring WINS, then we also need to set the node type option.
|
|
// we don't ask the user what type they want, the default should cover 95% of the cases
|
|
CDhcpOption * pNodeTypeOption = pScopeWiz->m_pDefaultOptions->Find(DHCP_OPTION_ID_WINS_NODE_TYPE, NULL);
|
|
if (pNodeTypeOption)
|
|
{
|
|
CDhcpOption * pNewNodeType;
|
|
|
|
if (pScopeWiz->m_poptWINSNodeType)
|
|
pNewNodeType = pScopeWiz->m_poptWINSNodeType;
|
|
else
|
|
pNewNodeType = new CDhcpOption(*pNodeTypeOption);
|
|
|
|
if (pNewNodeType)
|
|
{
|
|
CDhcpOptionValue optValue = pNewNodeType->QueryValue();
|
|
optValue.SetNumber(WINS_DEFAULT_NODE_TYPE);
|
|
|
|
pNewNodeType->Update(optValue);
|
|
|
|
pScopeWiz->m_poptWINSNodeType = pNewNodeType;
|
|
}
|
|
}
|
|
}
|
|
|
|
return CPropertyPageBase::OnWizardNext();
|
|
}
|
|
|
|
LRESULT CScopeWizWINS::OnWizardBack()
|
|
{
|
|
return CPropertyPageBase::OnWizardBack();
|
|
}
|
|
|
|
BOOL CScopeWizWINS::OnSetActive()
|
|
{
|
|
return CPropertyPageBase::OnSetActive();
|
|
}
|
|
|
|
void CScopeWizWINS::OnButtonWinsAdd()
|
|
{
|
|
DWORD dwIp;
|
|
m_ipaWINS.GetAddress(&dwIp);
|
|
|
|
if (dwIp)
|
|
{
|
|
CString strText;
|
|
|
|
UtilCvtIpAddrToWstr(dwIp, &strText);
|
|
int nIndex = m_listboxWINSServers.AddString(strText);
|
|
m_listboxWINSServers.SetItemData(nIndex, dwIp);
|
|
}
|
|
|
|
m_ipaWINS.ClearAddress();
|
|
m_ipaWINS.SetFocus();
|
|
}
|
|
|
|
void CScopeWizWINS::OnButtonWinsDelete()
|
|
{
|
|
int nSel = m_listboxWINSServers.GetCurSel();
|
|
if (nSel != LB_ERR)
|
|
{
|
|
m_ipaWINS.SetAddress((DWORD)m_listboxWINSServers.GetItemData(nSel));
|
|
m_listboxWINSServers.DeleteString(nSel);
|
|
m_ipaWINS.SetFocus();
|
|
}
|
|
|
|
UpdateButtons();
|
|
}
|
|
|
|
void CScopeWizWINS::OnSelchangeListWinsList()
|
|
{
|
|
UpdateButtons();
|
|
}
|
|
|
|
void CScopeWizWINS::OnChangeWinsServer()
|
|
{
|
|
UpdateButtons();
|
|
}
|
|
|
|
void CScopeWizWINS::UpdateButtons()
|
|
{
|
|
DWORD dwAddress;
|
|
BOOL bEnable;
|
|
CString strServerName;
|
|
|
|
// update the resolve button
|
|
m_editServerName.GetWindowText(strServerName);
|
|
m_buttonResolve.EnableWindow(strServerName.GetLength() > 0);
|
|
|
|
m_ipaWINS.GetAddress(&dwAddress);
|
|
|
|
if (dwAddress)
|
|
{
|
|
bEnable = TRUE;
|
|
}
|
|
else
|
|
{
|
|
bEnable = FALSE;
|
|
if (m_buttonAdd.GetButtonStyle() & BS_DEFPUSHBUTTON)
|
|
{
|
|
m_buttonAdd.SetButtonStyle(BS_PUSHBUTTON);
|
|
}
|
|
}
|
|
m_buttonAdd.EnableWindow(bEnable);
|
|
|
|
if (m_listboxWINSServers.GetCurSel() != LB_ERR)
|
|
{
|
|
bEnable = TRUE;
|
|
}
|
|
else
|
|
{
|
|
bEnable = FALSE;
|
|
if (m_buttonDelete.GetButtonStyle() & BS_DEFPUSHBUTTON)
|
|
{
|
|
m_buttonDelete.SetButtonStyle(BS_PUSHBUTTON);
|
|
}
|
|
}
|
|
m_buttonDelete.EnableWindow(bEnable);
|
|
|
|
// up and down buttons
|
|
BOOL bEnableUp = (m_listboxWINSServers.GetCurSel() >= 0) && (m_listboxWINSServers.GetCurSel() != 0);
|
|
m_buttonIpAddrUp.EnableWindow(bEnableUp);
|
|
|
|
BOOL bEnableDown = (m_listboxWINSServers.GetCurSel() >= 0) && (m_listboxWINSServers.GetCurSel() < m_listboxWINSServers.GetCount() - 1);
|
|
m_buttonIpAddrDown.EnableWindow(bEnableDown);
|
|
}
|
|
|
|
void CScopeWizWINS::OnButtonIpAddrDown()
|
|
{
|
|
MoveValue(FALSE);
|
|
if (m_buttonIpAddrDown.IsWindowEnabled())
|
|
m_buttonIpAddrDown.SetFocus();
|
|
else
|
|
m_buttonIpAddrUp.SetFocus();
|
|
}
|
|
|
|
void CScopeWizWINS::OnButtonIpAddrUp()
|
|
{
|
|
MoveValue(TRUE);
|
|
if (m_buttonIpAddrUp.IsWindowEnabled())
|
|
m_buttonIpAddrUp.SetFocus();
|
|
else
|
|
m_buttonIpAddrDown.SetFocus();
|
|
}
|
|
|
|
void CScopeWizWINS::MoveValue(BOOL bUp)
|
|
{
|
|
// now get which item is selected in the listbox
|
|
int cFocus = m_listboxWINSServers.GetCurSel();
|
|
int cNewFocus;
|
|
DWORD err;
|
|
|
|
// make sure it's valid for this operation
|
|
if ( (bUp && cFocus <= 0) ||
|
|
(!bUp && cFocus >= m_listboxWINSServers.GetCount()) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
// move the value up/down
|
|
CATCH_MEM_EXCEPTION
|
|
{
|
|
if (bUp)
|
|
{
|
|
cNewFocus = cFocus - 1;
|
|
}
|
|
else
|
|
{
|
|
cNewFocus = cFocus + 1;
|
|
}
|
|
|
|
// remove the old one
|
|
DWORD dwIp = (DWORD) m_listboxWINSServers.GetItemData(cFocus);
|
|
m_listboxWINSServers.DeleteString(cFocus);
|
|
|
|
// re-add it in it's new home
|
|
CString strText;
|
|
UtilCvtIpAddrToWstr(dwIp, &strText);
|
|
m_listboxWINSServers.InsertString(cNewFocus, strText);
|
|
m_listboxWINSServers.SetItemData(cNewFocus, dwIp);
|
|
|
|
m_listboxWINSServers.SetCurSel(cNewFocus);
|
|
}
|
|
END_MEM_EXCEPTION(err)
|
|
|
|
UpdateButtons();
|
|
}
|
|
|
|
void CScopeWizWINS::OnButtonResolve()
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
|
|
CString strServer;
|
|
DHCP_IP_ADDRESS dhipa = 0;
|
|
DWORD err = 0;
|
|
|
|
m_editServerName.GetWindowText(strServer);
|
|
|
|
//
|
|
// See what type of name it is.
|
|
//
|
|
BEGIN_WAIT_CURSOR
|
|
|
|
switch (UtilCategorizeName(strServer))
|
|
{
|
|
case HNM_TYPE_IP:
|
|
dhipa = ::UtilCvtWstrToIpAddr( strServer ) ;
|
|
break ;
|
|
|
|
case HNM_TYPE_NB:
|
|
case HNM_TYPE_DNS:
|
|
err = ::UtilGetHostAddress( strServer, & dhipa ) ;
|
|
if (!err)
|
|
UtilCvtIpAddrToWstr(dhipa, &strServer);
|
|
break ;
|
|
|
|
default:
|
|
err = IDS_ERR_BAD_HOST_NAME ;
|
|
break ;
|
|
}
|
|
|
|
END_WAIT_CURSOR
|
|
|
|
if (err)
|
|
{
|
|
::DhcpMessageBox(err);
|
|
}
|
|
else
|
|
{
|
|
m_ipaWINS.SetAddress(dhipa);
|
|
}
|
|
}
|
|
|
|
void CScopeWizWINS::OnChangeEditServerName()
|
|
{
|
|
UpdateButtons();
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CScopeWizActivate property page
|
|
|
|
IMPLEMENT_DYNCREATE(CScopeWizActivate, CPropertyPageBase)
|
|
|
|
CScopeWizActivate::CScopeWizActivate() : CPropertyPageBase(CScopeWizActivate::IDD)
|
|
{
|
|
//{{AFX_DATA_INIT(CScopeWizActivate)
|
|
// NOTE: the ClassWizard will add member initialization here
|
|
//}}AFX_DATA_INIT
|
|
InitWiz97(FALSE, IDS_SCOPE_WIZ_ACTIVATE_TITLE, IDS_SCOPE_WIZ_ACTIVATE_SUBTITLE);
|
|
}
|
|
|
|
CScopeWizActivate::~CScopeWizActivate()
|
|
{
|
|
}
|
|
|
|
void CScopeWizActivate::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CPropertyPageBase::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CScopeWizActivate)
|
|
// NOTE: the ClassWizard will add DDX and DDV calls here
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CScopeWizActivate, CPropertyPageBase)
|
|
//{{AFX_MSG_MAP(CScopeWizActivate)
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CScopeWizActivate message handlers
|
|
|
|
BOOL CScopeWizActivate::OnInitDialog()
|
|
{
|
|
CPropertyPageBase::OnInitDialog();
|
|
|
|
((CButton *) GetDlgItem(IDC_RADIO_YES))->SetCheck(TRUE);
|
|
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
LRESULT CScopeWizActivate::OnWizardNext()
|
|
{
|
|
CScopeWiz * pScopeWiz = reinterpret_cast<CScopeWiz *>(GetHolder());
|
|
|
|
pScopeWiz->m_fActivateScope = (((CButton *) GetDlgItem(IDC_RADIO_YES))->GetCheck()) ? TRUE : FALSE;
|
|
|
|
return CPropertyPageBase::OnWizardNext();
|
|
}
|
|
|
|
LRESULT CScopeWizActivate::OnWizardBack()
|
|
{
|
|
// TODO: Add your specialized code here and/or call the base class
|
|
|
|
return CPropertyPageBase::OnWizardBack();
|
|
}
|
|
|
|
BOOL CScopeWizActivate::OnSetActive()
|
|
{
|
|
GetHolder()->SetWizardButtonsMiddle(TRUE);
|
|
|
|
return CPropertyPageBase::OnSetActive();
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|