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

3341 lines
97 KiB
Raw Blame History

/**********************************************************************/
/** 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_fWizardCancelled = TRUE;
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_pageWelcome, FALSE );
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);
// Set the registry key used by the CYS wizard to detect cancel
// HKCU\Software\Microsoft\Windows NT\CurrentVersion\srvWiz\DHCPWizResult
// should be set to "The wizard was cancelled"
if ( m_fWizardCancelled ) {
LONG Error;
HKEY hKey;
LPWSTR SrvWizKey = L"Software\\Microsoft\\Windows NT\\CurrentVersion\\srvWiz";
LPWSTR ValueName = L"DhcpWizResult";
DWORD ValueType = REG_SZ;
LPWSTR Value = L"The wizard was canceled";
DWORD ValueLen = sizeof( WCHAR ) * wcslen( Value );
Error = RegOpenKey( HKEY_CURRENT_USER, SrvWizKey, &hKey );
if ( ERROR_SUCCESS == Error ) {
Error = RegSetValueEx( hKey, ValueName, 0, ValueType,
( const BYTE * ) Value, ValueLen );
} // if
RegCloseKey( hKey );
} // if
}
//
// Called from the OnWizardFinish to add the DHCP Server to the list
//
DWORD
CScopeWiz::OnFinish()
{
m_fWizardCancelled = FALSE;
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 (S_OK != 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();
// Limit the size of the name
m_editScopeName.LimitText( MAX_NAME_LENGTH );
m_editScopeComment.LimitText( MAX_NAME_LENGTH );
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();
}