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

/**********************************************************************/
/**                       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();
}