windows-xp/Source/XPSP1/NT/net/mmc/mprsnap/rraswiz.cpp

/**********************************************************************/
/**                       Microsoft Windows/NT                       **/
/**                Copyright(c) Microsoft Corporation, 1997 - 1999 **/
/**********************************************************************/

#include "stdafx.h"
#include "root.h"
#include "machine.h"
#include "rtrutilp.h"   // InitiateServerConnection
#include "rtrcfg.h"
#include "rraswiz.h"
#include "rtrres.h"
#include "rtrcomn.h"
#include "addrpool.h"
#include "rrasutil.h"
#include "radbal.h"     // RADIUSSERVER
#include "radcfg.h"     // SaveRadiusServers
#include "lsa.h"
#include "helper.h"     // HrIsStandaloneServer
#include "ifadmin.h"    // GetPhoneBookPath
#include "infoi.h"      // InterfaceInfo::FindInterfaceTitle
#include "rtrerr.h"
#include "rtrui.h"      // NatConflictExists
#define _USTRINGP_NO_UNICODE_STRING
#include "ustringp.h"
#include <ntddip.h>     // to resolve ipfltdrv dependancies
#include "ipfltdrv.h"   // for the filter stuff
#include "raputil.h"    // for UpdateDefaultPolicy


extern "C" {
#define _NOUIUTIL_H_
#include "dtl.h"
#include "pbuser.h"
};


WATERMARKINFO       g_wmi = {0};


#ifdef UNICODE
    #define SZROUTERENTRYDLG    "RouterEntryDlgW"
#else
    #define SZROUTERENTRYDLG    "RouterEntryDlgA"
#endif

// Useful functions

// defines for the flags parameter
HRESULT CallRouterEntryDlg(HWND hWnd, NewRtrWizData *pWizData, LPARAM flags);
HRESULT RouterEntryLoadInfoBase(LPCTSTR pszServerName,
                                LPCTSTR pszIfName,
                                DWORD dwTransportId,
                                IInfoBase *pInfoBase);
HRESULT RouterEntrySaveInfoBase(LPCTSTR pszServerName,
                                LPCTSTR pszIfName,
                                IInfoBase *pInfoBase,
                                DWORD dwTransportId);
void LaunchHelpTopic(LPCTSTR pszHelpString);
HRESULT AddVPNFiltersToInterface(IRouterInfo *pRouter, LPCTSTR pszIfId, RtrWizInterface*    pIf);
HRESULT DisableDDNSandNetBtOnInterface ( IRouterInfo *pRouter, LPCTSTR pszIfName, RtrWizInterface*    pIf);

// This is the command line that I use to launch the Connections UI shell
const TCHAR s_szConnectionUICommandLine[] =
      _T("\"%SystemRoot%\\explorer.exe\" ::{20D04FE0-3AEA-1069-A2D8-08002B30309D}\\::{21EC2020-3AEA-1069-A2DD-08002B30309D}\\::{7007acc7-3202-11d1-aad2-00805fc1270e}");

// Help strings
const TCHAR s_szHowToAddICS[] =
            _T("%systemdir%\\help\\netcfg.chm::/howto_share_conn.htm");
const TCHAR s_szHowToAddAProtocol[] =
            _T("%systemdir%\\help\\netcfg.chm::/HowTo_Add_Component.htm");
const TCHAR s_szHowToAddInboundConnections[] =
            _T("%systemdir%\\help\\netcfg.chm::/howto_conn_incoming.htm");
const TCHAR s_szGeneralNATHelp[] =
            _T("%systemdir%\\help\\RRASconcepts.chm::/sag_RRAS-Ch2_16.htm");
const TCHAR s_szGeneralRASHelp[] =
            _T("%systemdir%\\help\\RRASconcepts.chm::/sag_RRAS-Ch1_1.htm");


/*---------------------------------------------------------------------------
    This enum defines the columns for the Interface list controls.
 ---------------------------------------------------------------------------*/
enum
{
    IFLISTCOL_NAME = 0,
    IFLISTCOL_DESC,
    IFLISTCOL_IPADDRESS,
    IFLISTCOL_COUNT
};

// This array must match the column indices above
INT s_rgIfListColumnHeaders[] =
{
    IDS_IFLIST_COL_NAME,
    IDS_IFLIST_COL_DESC,
    IDS_IFLIST_COL_IPADDRESS,
    0
};




/*!--------------------------------------------------------------------------
    MachineHandler::OnNewRtrRASConfigWiz
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT MachineHandler::OnNewRtrRASConfigWiz(ITFSNode *pNode, BOOL fTest)
{
    Assert(pNode);
    HRESULT        hr = hrOK;
    CString strRtrWizTitle;
    SPIComponentData spComponentData;
    COSERVERINFO            csi;
    COAUTHINFO              cai;
    COAUTHIDENTITY          caid;
    SPIRemoteNetworkConfig    spNetwork;
    IUnknown *                punk = NULL;
    CNewRtrWiz *            pRtrWiz = NULL;

    AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

    // Windows NT Bug : 407878
    // We need to reset the registry information (to ensure
    // that it is reasonably accurate).
    // ----------------------------------------------------------------
    ZeroMemory(&csi, sizeof(csi));
    ZeroMemory(&cai, sizeof(cai));
    ZeroMemory(&caid, sizeof(caid));

    csi.pAuthInfo = &cai;
    cai.pAuthIdentityData = &caid;

    // Create the remote config object
    // ----------------------------------------------------------------
    hr = CoCreateRouterConfig(m_spRouterInfo->GetMachineName(),
                              m_spRouterInfo,
                              &csi,
                              IID_IRemoteNetworkConfig,
                              &punk);

    if (FHrOK(hr))
    {
        spNetwork = (IRemoteNetworkConfig *) punk;
        punk = NULL;

        // Upgrade the configuration (ensure that the registry keys
        // are populated correctly).
        // ------------------------------------------------------------
        spNetwork->UpgradeRouterConfig();
    }


    hr = SecureRouterInfo(pNode, TRUE /* fShowUI */);
    if(FAILED(hr))    return hr;

    m_spNodeMgr->GetComponentData(&spComponentData);
    strRtrWizTitle.LoadString(IDS_MENU_RTRWIZ);

    //Load the watermark and
    //set it in  m_spTFSCompData

    InitWatermarkInfo(AfxGetInstanceHandle(),
                       &g_wmi,
                       IDB_WIZBANNER,        // Header ID
                       IDB_WIZWATERMARK,     // Watermark ID
                       NULL,                 // hPalette
                       FALSE);                // bStretch

    m_spTFSCompData->SetWatermarkInfo(&g_wmi);


    //
    //we dont have to free handles.  MMC does it for us
    //

    pRtrWiz = new CNewRtrWiz(pNode,
                             m_spRouterInfo,
                             spComponentData,
                             m_spTFSCompData,
                             strRtrWizTitle);

    if (fTest)
    {
        // Pure TEST code
        if (!FHrOK(pRtrWiz->QueryForTestData()))
        {
            delete pRtrWiz;
            return S_FALSE;
        }
    }

    if ( FAILED(pRtrWiz->Init( m_spRouterInfo->GetMachineName())) )
    {
        delete pRtrWiz;
        return S_FALSE;
    }
    else
    {
        return pRtrWiz->DoModalWizard();
    }

    if (csi.pAuthInfo)
        delete csi.pAuthInfo->pAuthIdentityData->Password;

    return hr;
}



NewRtrWizData::~NewRtrWizData()
{
    POSITION    pos;
    CString     st;
    RtrWizInterface *   pRtrWizIf;

    pos = m_ifMap.GetStartPosition();
    while (pos)
    {
        m_ifMap.GetNextAssoc(pos, st, pRtrWizIf);
        delete pRtrWizIf;
    }

    m_ifMap.RemoveAll();

    // Clear out the RADIUS secret
    ZeroMemory(m_stRadiusSecret.GetBuffer(0),
               m_stRadiusSecret.GetLength() * sizeof(TCHAR));
    m_stRadiusSecret.ReleaseBuffer(-1);
}


/*!--------------------------------------------------------------------------
    NewRtrWizData::Init
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT NewRtrWizData::Init(LPCTSTR pszServerName, IRouterInfo *pRouter)
{
    DWORD   dwServiceStatus = 0;
    DWORD   dwErrorCode = 0;

    m_stServerName = pszServerName;

    // Initialize internal wizard data
    m_RtrConfigData.Init(pszServerName, pRouter);
    m_RtrConfigData.m_fIpSetup = TRUE;

    // Move some of the RtrConfigData info over
    m_fIpInstalled = m_RtrConfigData.m_fUseIp;
    m_fIpxInstalled = m_RtrConfigData.m_fUseIpx;
    m_fNbfInstalled = m_RtrConfigData.m_fUseNbf;
    m_fAppletalkInstalled = m_RtrConfigData.m_fUseArap;

    m_fIpInUse = m_fIpInstalled;
    m_fIpxInUse = m_fIpxInstalled;
    m_fAppletalkInUse = m_fAppletalkInstalled;
    m_fNbfInUse = m_fNbfInstalled;

    // Test the server to see if DNS/DHCP is installed
    m_fIsDNSRunningOnServer = FALSE;
    m_fIsDHCPRunningOnServer = FALSE;

    // Get the status of the DHCP service
    // ----------------------------------------------------------------
    if (FHrSucceeded(TFSGetServiceStatus(pszServerName,
                                         _T("DHCPServer"),
                                         &dwServiceStatus,
                                         &dwErrorCode)))
    {
        // Note, if the service is not running, we assume it will
        // stay off and not assume that it will be turned on.
        // ------------------------------------------------------------
        m_fIsDHCPRunningOnServer = (dwServiceStatus == SERVICE_RUNNING);
    }

    //$ TODO : is this the correct name for the DNS Server?

    // Get the status of the DNS service
    // ----------------------------------------------------------------
    if (FHrSucceeded(TFSGetServiceStatus(pszServerName,
                                         _T("DNSServer"),
                                         &dwServiceStatus,
                                         &dwErrorCode)))
    {
        // Note, if the service is not running, we assume it will
        // stay off and not assume that it will be turned on.
        // ------------------------------------------------------------
        m_fIsDNSRunningOnServer = (dwServiceStatus == SERVICE_RUNNING);
    }


    LoadInterfaceData(pRouter);

    return hrOK;
}


/*!--------------------------------------------------------------------------
    NewRtrWizData::QueryForTestData
        -
    Author: KennT
 ---------------------------------------------------------------------------*/

BOOL NewRtrWizData::s_fIpInstalled = FALSE;
BOOL NewRtrWizData::s_fIpxInstalled = FALSE;
BOOL NewRtrWizData::s_fAppletalkInstalled = FALSE;
BOOL NewRtrWizData::s_fNbfInstalled = FALSE;
BOOL NewRtrWizData::s_fIsLocalMachine = FALSE;
BOOL NewRtrWizData::s_fIsDNSRunningOnPrivateInterface = FALSE;
BOOL NewRtrWizData::s_fIsDHCPRunningOnPrivateInterface = FALSE;
BOOL NewRtrWizData::s_fIsSharedAccessRunningOnServer = FALSE;
BOOL NewRtrWizData::s_fIsMemberOfDomain = FALSE;
DWORD NewRtrWizData::s_dwNumberOfNICs = 0;

/*!--------------------------------------------------------------------------
    NewRtrWizData::QueryForTestData
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT NewRtrWizData::QueryForTestData()
{
    HRESULT hr = hrOK;
    CNewWizTestParams   dlgParams;

    m_fTest = TRUE;

    // Get the initial parameters
    // ----------------------------------------------------------------
    dlgParams.SetData(this);
    if (dlgParams.DoModal() == IDCANCEL)
    {
        return S_FALSE;
    }
    return hr;
}

/*!--------------------------------------------------------------------------
    NewRtrWizData::HrIsIPInstalled
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT NewRtrWizData::HrIsIPInstalled()
{
    if (m_fTest)
        return s_fIpInstalled ? S_OK : S_FALSE;
    else
        return m_fIpInstalled ? S_OK : S_FALSE;
}

/*!--------------------------------------------------------------------------
    NewRtrWizData::HrIsIPInUse
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT NewRtrWizData::HrIsIPInUse()
{
    HRESULT hr = hrOK;

    hr = HrIsIPInstalled();
    if (FHrOK(hr))
        return m_fIpInUse ? S_OK : S_FALSE;
    else
        return hr;
}

/*!--------------------------------------------------------------------------
    NewRtrWizData::HrIsIPXInstalled
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT NewRtrWizData::HrIsIPXInstalled()
{
    if (m_fTest)
        return s_fIpxInstalled ? S_OK : S_FALSE;
    else
        return m_fIpxInstalled ? S_OK : S_FALSE;
}

/*!--------------------------------------------------------------------------
    NewRtrWizData::HrIsIPXInUse
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT NewRtrWizData::HrIsIPXInUse()
{
    HRESULT hr = hrOK;

    hr = HrIsIPXInstalled();
    if (FHrOK(hr))
        return m_fIpxInUse ? S_OK : S_FALSE;
    else
        return hr;
}

/*!--------------------------------------------------------------------------
    NewRtrWizData::HrIsAppletalkInstalled
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT NewRtrWizData::HrIsAppletalkInstalled()
{
    if (m_fTest)
        return s_fAppletalkInstalled ? S_OK : S_FALSE;
    else
        return m_fAppletalkInstalled ? S_OK : S_FALSE;
}

/*!--------------------------------------------------------------------------
    NewRtrWizData::HrIsAppletalkInUse
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT NewRtrWizData::HrIsAppletalkInUse()
{
    HRESULT hr = hrOK;

    hr = HrIsAppletalkInstalled();
    if (FHrOK(hr))
        return m_fAppletalkInUse ? S_OK : S_FALSE;
    else
        return hr;
}

/*!--------------------------------------------------------------------------
    NewRtrWizData::HrIsNbfInstalled
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT NewRtrWizData::HrIsNbfInstalled()
{
    if (m_fTest)
        return s_fNbfInstalled ? S_OK : S_FALSE;
    else
        return m_fNbfInstalled ? S_OK : S_FALSE;
}

/*!--------------------------------------------------------------------------
    NewRtrWizData::HrIsNbfInUse
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT NewRtrWizData::HrIsNbfInUse()
{
    HRESULT hr = hrOK;

    hr = HrIsNbfInstalled();
    if (FHrOK(hr))
        return m_fNbfInUse ? S_OK : S_FALSE;
    else
        return hr;
}


/*!--------------------------------------------------------------------------
    NewRtrWizData::HrIsLocalMachine
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT NewRtrWizData::HrIsLocalMachine()
{
    if (m_fTest)
        return s_fIsLocalMachine ? S_OK : S_FALSE;
    else
        return IsLocalMachine(m_stServerName) ? S_OK : S_FALSE;
}

/*!--------------------------------------------------------------------------
    NewRtrWizData::HrIsDNSRunningOnInterface
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT NewRtrWizData::HrIsDNSRunningOnInterface()
{
    if (m_fTest)
        return s_fIsDNSRunningOnPrivateInterface ? S_OK : S_FALSE;
    else
    {
        // Search for the private interface in our list
        // ------------------------------------------------------------
        RtrWizInterface *   pRtrWizIf = NULL;

        m_ifMap.Lookup(m_stPrivateInterfaceId, pRtrWizIf);
        if (pRtrWizIf)
            return pRtrWizIf->m_fIsDnsEnabled ? S_OK : S_FALSE;
        else
            return S_FALSE;
    }
}

/*!--------------------------------------------------------------------------
    NewRtrWizData::HrIsDHCPRunningOnInterface
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT NewRtrWizData::HrIsDHCPRunningOnInterface()
{
    if (m_fTest)
        return s_fIsDHCPRunningOnPrivateInterface ? S_OK : S_FALSE;
    else
    {
        // Search for the private interface in our list
        // ------------------------------------------------------------
        RtrWizInterface *   pRtrWizIf = NULL;

        m_ifMap.Lookup(m_stPrivateInterfaceId, pRtrWizIf);
        if (pRtrWizIf)
            return pRtrWizIf->m_fIsDhcpEnabled ? S_OK : S_FALSE;
        else
            return S_FALSE;
    }
}

/*!--------------------------------------------------------------------------
    NewRtrWizData::HrIsDNSRunningOnServer
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT NewRtrWizData::HrIsDNSRunningOnServer()
{
    return m_fIsDNSRunningOnServer ? S_OK : S_FALSE;
}

/*!--------------------------------------------------------------------------
    NewRtrWizData::HrIsDHCPRunningOnServer
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT NewRtrWizData::HrIsDHCPRunningOnServer()
{
    return m_fIsDHCPRunningOnServer ? S_OK : S_FALSE;
}

/*!--------------------------------------------------------------------------
    NewRtrWizData::HrIsSharedAccessRunningOnServer
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT NewRtrWizData::HrIsSharedAccessRunningOnServer()
{
    if (m_fTest)
        return s_fIsSharedAccessRunningOnServer ? S_OK : S_FALSE;
    else
        return NatConflictExists(m_stServerName) ? S_OK : S_FALSE;
}

/*!--------------------------------------------------------------------------
    NewRtrWizData::HrIsMemberOfDomain
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT NewRtrWizData::HrIsMemberOfDomain()
{
    if (m_fTest)
        return s_fIsMemberOfDomain ? S_OK : S_FALSE;
    else
    {
        // flip the meaning
        HRESULT hr = HrIsStandaloneServer(m_stServerName);
        if (FHrSucceeded(hr))
            return FHrOK(hr) ? S_FALSE : S_OK;
        else
            return hr;
    }
}

/*!--------------------------------------------------------------------------
    NewRtrWizData::GetNextPage
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
LRESULT NewRtrWizData::GetNextPage(UINT uDialogId)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
    LRESULT lNextPage = 0;
    DWORD   dwNICs;
    CString st;

    switch (uDialogId)
    {
        default:
            Panic0("We should not be here, this is a finish page!");
            break;

        case IDD_NEWRTRWIZ_WELCOME:
            lNextPage = IDD_NEWRTRWIZ_COMMONCONFIG;
            break;
        case IDD_NEWRTRWIZ_COMMONCONFIG:
            switch (m_wizType)
            {
                case WizardRouterType_NAT:
                    if ( !FHrOK(HrIsIPInstalled()) )
                    {
                        if (FHrOK(HrIsLocalMachine()))
                            lNextPage = IDD_NEWRTRWIZ_NAT_NOIP;
                        else
                            lNextPage = IDD_NEWRTRWIZ_NAT_NOIP_NONLOCAL;
                    }
                    else
                        lNextPage = IDD_NEWRTRWIZ_NAT_CHOOSE;
                    break;

                case WizardRouterType_RAS:
                    {
                        DWORD    dwNICs = 0;
                        GetNumberOfNICS_IPorIPX(&dwNICs);

                        if ((dwNICs > 1) ||
                            FHrOK(HrIsMemberOfDomain()))
                        {
                            m_fAdvanced = TRUE;
                            lNextPage = IDD_NEWRTRWIZ_RAS_A_PROTOCOLS;
                        }
                        else
                            lNextPage = IDD_NEWRTRWIZ_RAS_CHOOSE;
                    }
                    break;

                case WizardRouterType_VPN:
                    if (FHrOK(HrIsIPInstalled()))
                    {
                        GetNumberOfNICS_IP(&dwNICs);
                        if (dwNICs < 1)
                            lNextPage = IDD_NEWRTRWIZ_VPN_A_FINISH_NONICS;
                        else
                            lNextPage = IDD_NEWRTRWIZ_VPN_A_PROTOCOLS;
                    }
                    else
                    {
                        if (FHrOK(HrIsLocalMachine()))
                            lNextPage = IDD_NEWRTRWIZ_VPN_NOIP;
                        else
                            lNextPage = IDD_NEWRTRWIZ_VPN_NOIP_NONLOCAL;
                    }

                    // There is no simple path
                    m_fAdvanced = TRUE;
                    break;

                case WizardRouterType_Router:
                    lNextPage = IDD_NEWRTRWIZ_ROUTER_PROTOCOLS;

                    // There is no simple path
                    m_fAdvanced = TRUE;
                    break;
                case WizardRouterType_Manual:
                    lNextPage = IDD_NEWRTRWIZ_MANUAL_FINISH;

                    m_fAdvanced = TRUE;
                    break;
            }
            break;
        case IDD_NEWRTRWIZ_NAT_CHOOSE:
            // Check to see if SharedAccess is running, if so we
            // have to abort the process here.
            if (FHrOK(HrIsSharedAccessRunningOnServer()))
            {
                if (m_fAdvanced)
                {
                    if (FHrOK(HrIsLocalMachine()))
                        lNextPage = IDD_NEWRTRWIZ_NAT_A_CONFLICT;
                    else
                        lNextPage = IDD_NEWRTRWIZ_NAT_A_CONFLICT_NONLOCAL;
                }
                else
                {
                    if (FHrOK(HrIsLocalMachine()))
                        lNextPage = IDD_NEWRTRWIZ_NAT_S_CONFLICT;
                    else
                        lNextPage = IDD_NEWRTRWIZ_NAT_S_CONFLICT_NONLOCAL;
                }
            }
            else if (m_fAdvanced)
            {
                lNextPage = IDD_NEWRTRWIZ_NAT_A_PUBLIC;
            }
            else
            {
                // Stay at the same page
                lNextPage = -1;

                if ( FHrOK( HrIsLocalMachine() ) )
                {
                    if (AfxMessageBox(IDS_WRN_RTRWIZ_NAT_S_FINISH,
                                  MB_OKCANCEL | MB_ICONINFORMATION) == IDOK)
                    {
                        // Fix the save and help flags
                        m_HelpFlag = HelpFlag_ICS;
                        m_SaveFlag = SaveFlag_DoNothing;

                        // Have it finish the wizard
                        lNextPage = ERR_IDD_FINISH_WIZARD;
                    }
                }
                else
                {
                    st.Format(IDS_WRN_RTRWIZ_NAT_S_FINISH_NONLOCAL,
                              (LPCTSTR) m_stServerName);
                    if (AfxMessageBox(st,
                                  MB_OKCANCEL | MB_ICONINFORMATION) == IDOK)
                    {
                        // Fix the save and help flags
                        m_HelpFlag = HelpFlag_Nothing;
                        m_SaveFlag = SaveFlag_DoNothing;

                        // Have it finish the wizard
                        lNextPage = ERR_IDD_FINISH_WIZARD;
                    }
                }
            }
            break;

        case IDD_NEWRTRWIZ_NAT_A_PUBLIC:
            {
                // Determine the number of NICs
                GetNumberOfNICS_IP(&dwNICs);

                // Adjust the number of NICs (depending on whether
                // we selected to create a DD or not).
                if (dwNICs)
                {
                    if (!m_fCreateDD)
                        dwNICs--;
                }

                // Now switch depending on the number of NICs
                if (dwNICs == 0)
                    lNextPage = IDD_NEWRTRWIZ_NAT_A_NONICS_FINISH;
                else if (dwNICs > 1)
                    lNextPage = IDD_NEWRTRWIZ_NAT_A_PRIVATE;

                if (lNextPage)
                    break;
            }
            // Fall through to the next case
            // At this stage, we now have the case that the
            // remaining number of NICs == 1, and we need to
            // autoselect the NIC and go on to the next test.
            AutoSelectPrivateInterface();

        case IDD_NEWRTRWIZ_NAT_A_PRIVATE:
            if (FHrOK(HrIsDNSRunningOnInterface()) ||
                FHrOK(HrIsDHCPRunningOnInterface()) ||
                FHrOK(HrIsDNSRunningOnServer()) ||
                FHrOK(HrIsDHCPRunningOnServer()))
            {
                // Popup a warning box
                // AfxMessageBox(IDS_WRN_RTRWIZ_NAT_DHCPDNS_FOUND,
                // MB_ICONEXCLAMATION);
                m_fNatUseSimpleServers = FALSE;
                //continue on down, and fall through
            }
            else
            {
                lNextPage = IDD_NEWRTRWIZ_NAT_A_DHCPDNS;
                break;
            }

        case IDD_NEWRTRWIZ_NAT_A_DHCPDNS:
            if (m_fNatUseSimpleServers)
                lNextPage = IDD_NEWRTRWIZ_NAT_A_DHCP_WARNING;
            else
            {
                if (m_fCreateDD)
                    lNextPage = IDD_NEWRTRWIZ_NAT_A_DD_WARNING;
                else
                    lNextPage = IDD_NEWRTRWIZ_NAT_A_EXTERNAL_FINISH;
            }
            break;

        case IDD_NEWRTRWIZ_NAT_A_DHCP_WARNING:
            Assert(m_fNatUseSimpleServers);
            if (m_fCreateDD)
                lNextPage = IDD_NEWRTRWIZ_NAT_A_DD_WARNING;
            else
                lNextPage = IDD_NEWRTRWIZ_NAT_A_FINISH;
            break;

        case IDD_NEWRTRWIZ_NAT_A_DD_WARNING:
            if (!FHrSucceeded(m_hrDDError))
                lNextPage = IDD_NEWRTRWIZ_NAT_A_DD_ERROR;
            else
            {
                if (m_fNatUseSimpleServers)
                    lNextPage = IDD_NEWRTRWIZ_NAT_A_FINISH;
                else
                    lNextPage = IDD_NEWRTRWIZ_NAT_A_EXTERNAL_FINISH;
            }
            break;

        case IDD_NEWRTRWIZ_RAS_CHOOSE:
            if (m_fAdvanced)
                lNextPage = IDD_NEWRTRWIZ_RAS_A_PROTOCOLS;
            else
            {
                // Stay at the same page
                lNextPage = -1;

                if ( FHrOK( HrIsLocalMachine() ) )
                {
                    // lNextPage = IDD_NEWRTRWIZ_RAS_S_FINISH;
                    // Pop the current page so that we stay in sync
                    if (AfxMessageBox(IDS_WRN_RTRWIZ_RAS_S_FINISH,
                                  MB_OKCANCEL | MB_ICONINFORMATION) == IDOK)
                    {
                        // Fix the save and help flags
                        m_HelpFlag = HelpFlag_InboundConnections;
                        m_SaveFlag = SaveFlag_DoNothing;

                        // Have it finish the wizard
                        lNextPage = ERR_IDD_FINISH_WIZARD;
                    }
                }
                else
                {
                    st.Format(IDS_WRN_RTRWIZ_RAS_S_FINISH_NONLOCAL,
                              (LPCTSTR) m_stServerName);
                    // lNextPage = IDD_NEWRTRWIZ_RAS_S_NONLOCAL;
                    if (AfxMessageBox(st,
                                  MB_OKCANCEL | MB_ICONINFORMATION) == IDOK)
                    {
                        // Fix the save and help flags
                        m_HelpFlag = HelpFlag_Nothing;
                        m_SaveFlag = SaveFlag_DoNothing;

                        // Have it finish the wizard
                        lNextPage = ERR_IDD_FINISH_WIZARD;
                    }
                }
            }
            break;

        case IDD_NEWRTRWIZ_RAS_A_PROTOCOLS:
            if (m_fNeedMoreProtocols)
            {
                if (FHrOK(HrIsLocalMachine()))
                    lNextPage = IDD_NEWRTRWIZ_RAS_A_NEED_PROT;
                else
                    lNextPage = IDD_NEWRTRWIZ_RAS_A_NEED_PROT_NONLOCAL;
                break;
            }
            /*
            if (FHrOK(HrIsAppletalkInUse()))
            {
                lNextPage = IDD_NEWRTRWIZ_RAS_A_ATALK;
                break;
            }
            */

            // fall through
        case IDD_NEWRTRWIZ_RAS_A_ATALK:
            if (FHrOK(HrIsIPInUse()))
            {
                GetNumberOfNICS_IP(&dwNICs);

                if (dwNICs > 1)
                    lNextPage = IDD_NEWRTRWIZ_RAS_A_NETWORK;
                else if (dwNICs == 0)
                    lNextPage = IDD_NEWRTRWIZ_RAS_A_NONICS;
                else
                {
                    AutoSelectPrivateInterface();
                    lNextPage = IDD_NEWRTRWIZ_RAS_A_ADDRESSING;
                }
                break;
            }

            // default catch
            lNextPage = IDD_NEWRTRWIZ_RAS_A_FINISH;
            break;

        case IDD_NEWRTRWIZ_RAS_A_NONICS:
            if (m_fNoNicsAreOk)
                lNextPage = IDD_NEWRTRWIZ_RAS_A_ADDRESSING_NONICS;
            else
                lNextPage = IDD_NEWRTRWIZ_RAS_A_FINISH_NONICS;
            break;

        case IDD_NEWRTRWIZ_RAS_A_NETWORK:
            lNextPage = IDD_NEWRTRWIZ_RAS_A_ADDRESSING;
            break;

        case IDD_NEWRTRWIZ_RAS_A_ADDRESSING:
            if (m_fUseDHCP)
            {
                GetNumberOfNICS_IP(&dwNICs);

                if (dwNICs &&
                    !FHrOK(HrIsDHCPRunningOnInterface()) &&
                    !FHrOK(HrIsDHCPRunningOnServer()))
                    AfxMessageBox(IDS_WRN_RTRWIZ_RAS_NODHCP,
                                  MB_ICONEXCLAMATION);

                lNextPage = IDD_NEWRTRWIZ_RAS_A_USERADIUS;
            }
            else
                lNextPage = IDD_NEWRTRWIZ_RAS_A_ADDRESSPOOL;
            break;

        case IDD_NEWRTRWIZ_RAS_A_ADDRESSING_NONICS:
            if (m_fUseDHCP)
            {
                lNextPage = IDD_NEWRTRWIZ_RAS_A_FINISH;
            }
            else
                lNextPage = IDD_NEWRTRWIZ_RAS_A_ADDRESSPOOL;
            break;

        case IDD_NEWRTRWIZ_RAS_A_ADDRESSPOOL:
            GetNumberOfNICS_IP(&dwNICs);
            if (dwNICs == 0)
                lNextPage = IDD_NEWRTRWIZ_RAS_A_FINISH;
            else
                lNextPage = IDD_NEWRTRWIZ_RAS_A_USERADIUS;
            break;

        case IDD_NEWRTRWIZ_RAS_A_USERADIUS:
            if (m_fUseRadius)
                lNextPage = IDD_NEWRTRWIZ_RAS_A_RADIUS_CONFIG;
            else
                lNextPage = IDD_NEWRTRWIZ_RAS_A_FINISH;
            break;

        case IDD_NEWRTRWIZ_RAS_A_RADIUS_CONFIG:
            lNextPage = IDD_NEWRTRWIZ_RAS_A_FINISH;
            break;


        case IDD_NEWRTRWIZ_VPN_A_PROTOCOLS:
            if (m_fNeedMoreProtocols)
            {
                if (FHrOK(HrIsLocalMachine()))
                    lNextPage = IDD_NEWRTRWIZ_RAS_A_NEED_PROT;
                else
                    lNextPage = IDD_NEWRTRWIZ_RAS_A_NEED_PROT_NONLOCAL;
                break;
            }
            /*
            if (FHrOK(HrIsAppletalkInUse()))
            {
                lNextPage = IDD_NEWRTRWIZ_VPN_A_ATALK;
                break;
            }
            */
            // fall through
        case IDD_NEWRTRWIZ_VPN_A_ATALK:

            GetNumberOfNICS_IP(&dwNICs);
            Assert(dwNICs >= 1);

            lNextPage = IDD_NEWRTRWIZ_VPN_A_PUBLIC;
            break;

        case IDD_NEWRTRWIZ_VPN_A_PUBLIC:
            GetNumberOfNICS_IP(&dwNICs);

            // Are there any NICs left?
            if (((dwNICs == 1) && m_stPublicInterfaceId.IsEmpty()) ||
                ((dwNICs == 2) && !m_stPublicInterfaceId.IsEmpty()))
            {
                AutoSelectPrivateInterface();
                lNextPage = IDD_NEWRTRWIZ_VPN_A_ADDRESSING;
            }
            else
                lNextPage = IDD_NEWRTRWIZ_VPN_A_PRIVATE;
            break;

        case IDD_NEWRTRWIZ_VPN_A_PRIVATE:
            Assert(!m_stPrivateInterfaceId.IsEmpty());
            lNextPage = IDD_NEWRTRWIZ_VPN_A_ADDRESSING;
            break;

        case IDD_NEWRTRWIZ_VPN_A_ADDRESSING:
            if (m_fUseDHCP)
            {
                GetNumberOfNICS_IP(&dwNICs);

                if (dwNICs &&
                    !FHrOK(HrIsDHCPRunningOnInterface()) &&
                    !FHrOK(HrIsDHCPRunningOnServer()))
                    AfxMessageBox(IDS_WRN_RTRWIZ_VPN_NODHCP,
                                  MB_ICONEXCLAMATION);

                lNextPage = IDD_NEWRTRWIZ_VPN_A_USERADIUS;
            }
            else
                lNextPage = IDD_NEWRTRWIZ_VPN_A_ADDRESSPOOL;
            break;

        case IDD_NEWRTRWIZ_VPN_A_ADDRESSPOOL:
            lNextPage = IDD_NEWRTRWIZ_VPN_A_USERADIUS;
            break;

        case IDD_NEWRTRWIZ_VPN_A_USERADIUS:
            if (m_fUseRadius)
                lNextPage = IDD_NEWRTRWIZ_VPN_A_RADIUS_CONFIG;
            else
                lNextPage = IDD_NEWRTRWIZ_VPN_A_FINISH;
            break;

        case IDD_NEWRTRWIZ_VPN_A_RADIUS_CONFIG:
            lNextPage = IDD_NEWRTRWIZ_VPN_A_FINISH;
            break;

        case IDD_NEWRTRWIZ_ROUTER_PROTOCOLS:
            if (m_fNeedMoreProtocols)
            {
                if (FHrOK(HrIsLocalMachine()))
                    lNextPage = IDD_NEWRTRWIZ_ROUTER_NEED_PROT;
                else
                    lNextPage = IDD_NEWRTRWIZ_ROUTER_NEED_PROT_NONLOCAL;
                break;
            }

            lNextPage = IDD_NEWRTRWIZ_ROUTER_USEDD;
            break;

        case IDD_NEWRTRWIZ_ROUTER_USEDD:
            if (m_fUseDD)
                lNextPage = IDD_NEWRTRWIZ_ROUTER_ADDRESSING;
            else
                lNextPage = IDD_NEWRTRWIZ_ROUTER_FINISH;
            break;
        case IDD_NEWRTRWIZ_ROUTER_ADDRESSING:
            if (m_fUseDHCP)
                lNextPage = IDD_NEWRTRWIZ_ROUTER_FINISH_DD;
            else
                lNextPage = IDD_NEWRTRWIZ_ROUTER_ADDRESSPOOL;
            break;
        case IDD_NEWRTRWIZ_ROUTER_ADDRESSPOOL:
            lNextPage = IDD_NEWRTRWIZ_ROUTER_FINISH_DD;
            break;

    }

    return lNextPage;
}

/*!--------------------------------------------------------------------------
    NewRtrWizData::GetNumberOfNICS
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT NewRtrWizData::GetNumberOfNICS_IP(DWORD *pdwNumber)
{
    if (m_fTest)
    {
        Assert(s_dwNumberOfNICs == m_ifMap.GetCount());
    }
    *pdwNumber = m_ifMap.GetCount();
    return hrOK;
}

/*!--------------------------------------------------------------------------
    NewRtrWizData::GetNumberOfNICS_IPorIPX
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT NewRtrWizData::GetNumberOfNICS_IPorIPX(DWORD *pdwNumber)
{
    *pdwNumber = m_dwNumberOfNICs_IPorIPX;
    return hrOK;
}

/*!--------------------------------------------------------------------------
    NewRtrWizData::AutoSelectPrivateInterface
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
void NewRtrWizData::AutoSelectPrivateInterface()
{
    POSITION    pos;
    RtrWizInterface *   pRtrWizIf = NULL;
    CString     st;

    m_stPrivateInterfaceId.Empty();

    pos = m_ifMap.GetStartPosition();
    while (pos)
    {
        m_ifMap.GetNextAssoc(pos, st, pRtrWizIf);

        if (m_stPublicInterfaceId != st)
        {
            m_stPrivateInterfaceId = st;
            break;
        }
    }

    Assert(!m_stPrivateInterfaceId.IsEmpty());

    return;
}

/*!--------------------------------------------------------------------------
    NewRtrWizData::LoadInterfaceData
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
void NewRtrWizData::LoadInterfaceData(IRouterInfo *pRouter)
{
    HRESULT     hr = hrOK;
    HKEY        hkeyMachine = NULL;

    if (!m_fTest)
    {
        // Try to get the real information
        SPIEnumInterfaceInfo        spEnumIf;
        SPIInterfaceInfo            spIf;
        RtrWizInterface *           pRtrWizIf = NULL;
        CStringList                 listAddress;
        CStringList                 listMask;
        BOOL                        fDhcp;
        BOOL                        fDns;

        pRouter->EnumInterface(&spEnumIf);

        CWRg( ConnectRegistry(pRouter->GetMachineName(), &hkeyMachine) );

        for (; hrOK == spEnumIf->Next(1, &spIf, NULL); spIf.Release())
        {
            // Only look at NICs
            if (spIf->GetInterfaceType() != ROUTER_IF_TYPE_DEDICATED)
                continue;

            // count the interface bound to IP or IPX
            if (FHrOK(spIf->FindRtrMgrInterface(PID_IP, NULL)) || FHrOK(spIf->FindRtrMgrInterface(PID_IPX, NULL)))
            {
                m_dwNumberOfNICs_IPorIPX++;
            }

            // Only allow those interfaces bound to IP to show up
            if (!FHrOK(spIf->FindRtrMgrInterface(PID_IP, NULL)))
            {
                continue;
            }

            pRtrWizIf = new RtrWizInterface;

            pRtrWizIf->m_stName = spIf->GetTitle();
            pRtrWizIf->m_stId = spIf->GetId();
            pRtrWizIf->m_stDesc = spIf->GetDeviceName();

            if (FHrOK(HrIsIPInstalled()))
            {
                POSITION    pos;
                DWORD       netAddress, dwAddress;
                CString     stAddress, stDhcpServer;

                // Clear the lists before getting them again.
                // ----------------------------------------------------
                listAddress.RemoveAll();
                listMask.RemoveAll();
                fDhcp = fDns = FALSE;

                QueryIpAddressList(pRouter->GetMachineName(),
                                   hkeyMachine,
                                   spIf->GetId(),
                                   &listAddress,
                                   &listMask,
                                   &fDhcp,
                                   &fDns,
                                   &stDhcpServer);

                // Iterate through the list of strings looking
                // for an autonet address
                // ----------------------------------------------------
                pos = listAddress.GetHeadPosition();
                while (pos)
                {
                    stAddress = listAddress.GetNext(pos);
                    netAddress = INET_ADDR((LPCTSTR) stAddress);
                    dwAddress = ntohl(netAddress);

                    // Check for reserved address ranges, this indicates
                    // an autonet address
                    // ------------------------------------------------
                    if ((dwAddress & 0xFFFF0000) == MAKEIPADDRESS(169,254,0,0))
                    {
                        // This is not a DHCP address, it is an
                        // autonet address.
                        // --------------------------------------------
                        fDhcp = FALSE;
                        break;
                    }
                }

                FormatListString(listAddress, pRtrWizIf->m_stIpAddress,
                                 _T(","));
                FormatListString(listMask, pRtrWizIf->m_stMask,
                                 _T(","));

                stDhcpServer.TrimLeft();
                stDhcpServer.TrimRight();
                pRtrWizIf->m_stDhcpServer = stDhcpServer;

                pRtrWizIf->m_fDhcpObtained = fDhcp;
                pRtrWizIf->m_fIsDhcpEnabled = fDhcp;
                pRtrWizIf->m_fIsDnsEnabled = fDns;
            }

            m_ifMap.SetAt(pRtrWizIf->m_stId, pRtrWizIf);
            pRtrWizIf = NULL;
        }

        delete pRtrWizIf;
    }
    else
    {
        CString             st;
        RtrWizInterface *   pRtrWizIf;

        // For now just the debug data
        for (DWORD i=0; i<s_dwNumberOfNICs; i++)
        {
            pRtrWizIf = new RtrWizInterface;

            pRtrWizIf->m_stName.Format(_T("Local Area Connection #%d"), i);
            pRtrWizIf->m_stId.Format(_T("{%d-GUID...}"), i);
            pRtrWizIf->m_stDesc = _T("Generic Intel hardware");

            if (FHrOK(HrIsIPInstalled()))
            {
                pRtrWizIf->m_stIpAddress = _T("11.22.33.44");
                pRtrWizIf->m_stMask = _T("255.255.0.0");

                // These parameters are dependent on other things
                pRtrWizIf->m_fDhcpObtained = FALSE;
                pRtrWizIf->m_fIsDhcpEnabled = FALSE;
                pRtrWizIf->m_fIsDnsEnabled = FALSE;
            }

            m_ifMap.SetAt(pRtrWizIf->m_stId, pRtrWizIf);
            pRtrWizIf = NULL;
        }
    }

Error:
    if (hkeyMachine)
        DisconnectRegistry(hkeyMachine);
}


/*!--------------------------------------------------------------------------
    NewRtrWizData::SaveToRtrConfigData
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT NewRtrWizData::SaveToRtrConfigData()
{
    HRESULT     hr = hrOK;
    POSITION    pos;
    AddressPoolInfo poolInfo;

    // Sync up with the general structure
    // ----------------------------------------------------------------
    switch (m_wizType)
    {
        case WizardRouterType_NAT:
            m_dwRouterType = ROUTER_TYPE_LAN;

            // If we have been told to create a DD interface
            // then we must have a WAN router.
            if (m_fCreateDD)
                m_dwRouterType |= ROUTER_TYPE_WAN;
            break;
        case WizardRouterType_RAS:
            m_dwRouterType = ROUTER_TYPE_RAS;
            break;
        case WizardRouterType_VPN:
            m_dwRouterType = ROUTER_TYPE_LAN | ROUTER_TYPE_WAN | ROUTER_TYPE_RAS;
            break;
        case WizardRouterType_Manual:
            m_dwRouterType = ROUTER_TYPE_LAN | ROUTER_TYPE_WAN | ROUTER_TYPE_RAS;
            break;
        default:
        case WizardRouterType_Router:
            Assert(m_wizType == WizardRouterType_Router);
            m_dwRouterType = ROUTER_TYPE_LAN;

            // If we have chosen to use a DD interface, then we do
            // WAN routing.
            if (m_fUseDD)
                m_dwRouterType |= ROUTER_TYPE_WAN;
            break;
    }
    m_RtrConfigData.m_dwRouterType = m_dwRouterType;


    // Setup the NAT-specific information
    // ----------------------------------------------------------------
    if (m_wizType == WizardRouterType_NAT)
    {
        m_RtrConfigData.m_dwConfigFlags |= RTRCONFIG_SETUP_NAT;

        if (m_fNatUseSimpleServers)
        {
            m_RtrConfigData.m_dwConfigFlags |= RTRCONFIG_SETUP_DNS_PROXY;
            m_RtrConfigData.m_dwConfigFlags |= RTRCONFIG_SETUP_DHCP_ALLOCATOR;
        }

        m_RtrConfigData.m_dwConfigFlags |= RTRCONFIG_SETUP_H323; // deonb added
        m_RtrConfigData.m_dwConfigFlags |= RTRCONFIG_SETUP_FTP;
    }

    // Sync up with the IP structure
    // ----------------------------------------------------------------
    if (m_fIpInstalled)
    {
        DWORD   dwNICs;

        // Set the private interface id into the IP structure
        Assert(!m_stPrivateInterfaceId.IsEmpty());

        m_RtrConfigData.m_ipData.m_dwAllowNetworkAccess = TRUE;
        m_RtrConfigData.m_ipData.m_dwUseDhcp = m_fUseDHCP;

        // If there is only one NIC, leave this the way it is (RAS
        // to select the adapter).  Otherwise, people can get stuck.
        // Install 1, remove it and install a new one.
        // 
        // ------------------------------------------------------------
        GetNumberOfNICS_IP(&dwNICs);
        if (dwNICs > 1)
            m_RtrConfigData.m_ipData.m_stNetworkAdapterGUID = m_stPrivateInterfaceId;
        m_RtrConfigData.m_ipData.m_stPrivateAdapterGUID = m_stPrivateInterfaceId;
        m_RtrConfigData.m_ipData.m_stPublicAdapterGUID = m_stPublicInterfaceId;
        m_RtrConfigData.m_ipData.m_dwEnableIn = TRUE;

        // copy over the address pool list
        m_RtrConfigData.m_ipData.m_addressPoolList.RemoveAll();
        if (m_addressPoolList.GetCount())
        {
            pos = m_addressPoolList.GetHeadPosition();
            while (pos)
            {
                poolInfo = m_addressPoolList.GetNext(pos);
                m_RtrConfigData.m_ipData.m_addressPoolList.AddTail(poolInfo);
            }
        }
    }


    // Sync up with the IPX structure
    // ----------------------------------------------------------------
    if (m_fIpxInstalled)
    {
        m_RtrConfigData.m_ipxData.m_dwAllowNetworkAccess = TRUE;
        m_RtrConfigData.m_ipxData.m_dwEnableIn = TRUE;
        m_RtrConfigData.m_ipxData.m_fEnableType20Broadcasts = m_fUseIpxType20Broadcasts;

        // The other parameters will be left at their defaults
    }


    // Sync up with the Appletalk structure
    // ----------------------------------------------------------------
    if (m_fAppletalkInstalled)
    {
        m_RtrConfigData.m_arapData.m_dwEnableIn = TRUE;
    }

    // Sync up with the NBF structure
    // ----------------------------------------------------------------
    if (m_fNbfInstalled)
    {
        m_RtrConfigData.m_nbfData.m_dwAllowNetworkAccess = TRUE;
        m_RtrConfigData.m_nbfData.m_dwEnableIn = TRUE;
    }

    // Sync up with the PPP structure
    // ----------------------------------------------------------------
    // Use the defaults


    // Sync up with the Error log structure
    // ----------------------------------------------------------------
    // Use the defaults


    // Sync up with the Auth structure
    // ----------------------------------------------------------------
    m_RtrConfigData.m_authData.m_dwFlags =
                                          PPPCFG_NegotiateMSCHAP |
                                          PPPCFG_NegotiateStrongMSCHAP;
    if (m_fAppletalkUseNoAuth)
        m_RtrConfigData.m_authData.m_dwFlags |=
                                               PPPCFG_AllowNoAuthentication;

    if (m_fUseRadius)
    {
        TCHAR   szGuid[128];

        // Setup the active auth/acct providers to be RADIUS
        StringFromGUID2(CLSID_RouterAuthRADIUS, szGuid, DimensionOf(szGuid));
        m_RtrConfigData.m_authData.m_stGuidActiveAuthProv = szGuid;

        StringFromGUID2(CLSID_RouterAcctRADIUS, szGuid, DimensionOf(szGuid));
        m_RtrConfigData.m_authData.m_stGuidActiveAcctProv = szGuid;
    }
    // Other parameters left at their defaults

    return hr;
}


// --------------------------------------------------------------------
// Windows NT Bug : 408722
// Use this code to grab the WM_HELP message from the property sheet.
// --------------------------------------------------------------------
static WNDPROC s_lpfnOldWindowProc = NULL;

LONG FAR PASCAL HelpSubClassWndFunc(HWND hWnd,
                                    UINT uMsg,
                                    WPARAM wParam,
                                    LPARAM lParam)
{
    if (uMsg == WM_HELP)
    {
        HWND hWndOwner = PropSheet_GetCurrentPageHwnd(hWnd);
        HELPINFO *  pHelpInfo = (HELPINFO *) lParam;

        // Reset the context ID, since we know exactly what we're
        // sending (ahem, unless someone reuses this).
        // ------------------------------------------------------------
        pHelpInfo->dwContextId = 0xdeadbeef;

        // Send the WM_HELP message to the prop page
        // ------------------------------------------------------------
        ::SendMessage(hWndOwner, uMsg, wParam, lParam);
        return TRUE;
    }
    return CallWindowProc(s_lpfnOldWindowProc, hWnd, uMsg, wParam, lParam);
}



/*!--------------------------------------------------------------------------
    NewRtrWizData::FinishTheDamnWizard
        This is the code that actually does the work of saving the
        data and doing all the operations.
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT NewRtrWizData::FinishTheDamnWizard(HWND hwndOwner,
                                           IRouterInfo *pRouter)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

    DWORD dwError = ERROR_SUCCESS;
    SPIRemoteNetworkConfig    spNetwork;
    IUnknown *                punk = NULL;
    CWaitCursor                wait;
    COSERVERINFO            csi;
    COAUTHINFO              cai;
    COAUTHIDENTITY          caid;
    HRESULT                 hr = hrOK;

    if (m_fSaved)
        return hr;

    // Synchronize the RtrConfigData with this structure
    // ----------------------------------------------------------------
    CORg( SaveToRtrConfigData() );


    // Ok, we now have the synchronized RtrConfigData.
    // We can do everything else that we did before to save the
    // information.

    ZeroMemory(&csi, sizeof(csi));
    ZeroMemory(&cai, sizeof(cai));
    ZeroMemory(&caid, sizeof(caid));

    csi.pAuthInfo = &cai;
    cai.pAuthIdentityData = &caid;

    // Create the remote config object
    // ----------------------------------------------------------------
    CORg( CoCreateRouterConfig(m_RtrConfigData.m_stServerName,
                               pRouter,
                               &csi,
                               IID_IRemoteNetworkConfig,
                               &punk) );

    spNetwork = (IRemoteNetworkConfig *) punk;
    punk = NULL;

    // Upgrade the configuration (ensure that the registry keys
    // are populated correctly).
    // ------------------------------------------------------------
    CORg( spNetwork->UpgradeRouterConfig() );

    // Remove the IP-in-IP tunnel names (since the registry has
    // been cleared).
    // ------------------------------------------------------------
    CleanupTunnelFriendlyNames(pRouter);

    // At this point, the current IRouterInfo pointer is invalid.
    // We will need to release the pointer and reload the info.
    // ------------------------------------------------------------
    if (pRouter)
    {
        pRouter->DoDisconnect();
        pRouter->Unload();
        pRouter->Load(m_stServerName, NULL);
    }


    dwError = RtrWizFinish( &m_RtrConfigData, pRouter );
    hr = HResultFromWin32(dwError);

    // Windows NT Bug : 173564
    // Depending on the router type, we will go through and enable the
    // devices.
    //    If routing only is enabled : set devices to ROUTING
    //  If ras-only : set devices to RAS
    //    If ras/routing : set devices to RAS/ROUTING
    //    5/19/98 - need some resolution from DavidEi on what to do here.
    // ------------------------------------------------------------

    // Setup the entries in the list
    // ------------------------------------------------------------
    if (m_wizType == WizardRouterType_VPN)
        SetDeviceType(m_stServerName, m_dwRouterType, 256);
    else
        SetDeviceType(m_stServerName, m_dwRouterType, 10);


    // Update the RADIUS config
    // ----------------------------------------------------------------
    SaveRadiusConfig();

	//
	//Add the NAT protocol if tcpip routing is selected
	//
	if ( m_RtrConfigData.m_ipData.m_dwAllowNetworkAccess )
		AddNATToServer(this, &m_RtrConfigData, pRouter, m_fCreateDD, TRUE);

    // Ok at this point we try to establish the server in the domain
    // If this fails, we ignore the error and popup a warning message.
    //
    // Windows NT Bug : 202776
    // Do not register the router if we are a LAN-only router.
    // ----------------------------------------------------------------
    if ( FHrSucceeded(hr) &&
         (m_dwRouterType != ROUTER_TYPE_LAN) &&
         (!m_fUseRadius))
    {
        HRESULT hrT = hrOK;

        hrT = ::RegisterRouterInDomain(m_stServerName, TRUE);

        if (hrT != ERROR_NO_SUCH_DOMAIN)
        {
            if (!FHrSucceeded(hrT))
            {
                CString    st;
                CString stTitle;

                st.Format(IDS_ERR_CANNOT_REGISTER_IN_DS,
                          m_stServerName);
                stTitle.LoadString(AFX_IDS_APP_TITLE);

                // Windows NT Bug : 408722
                //
                // NOTE: This code only works as long as this wizard
                // blocks the main thread!
                //
                // We want the help message to be sent to the
                // correct place (the property page)

                // So let us subclass the sheet window (temporarily)
                // ----------------------------------------------------
                HWND hwndSheet = ::GetParent(hwndOwner);

                if (hwndSheet)
                {
                    s_lpfnOldWindowProc = (WNDPROC) SetWindowLongPtr(hwndSheet,
                        GWLP_WNDPROC, (LPARAM) HelpSubClassWndFunc);

                    if (s_lpfnOldWindowProc)
                    {
                        MessageBox(hwndOwner,
                                   (LPCTSTR) st,
                                   (LPCTSTR) stTitle,
                                   MB_ICONWARNING | MB_OK | MB_HELP);

                        SetWindowLongPtr(hwndSheet, GWLP_WNDPROC,
                                         (LPARAM) s_lpfnOldWindowProc);

                        s_lpfnOldWindowProc = NULL;
                    }
                }
            }
        }
    }
    // NT Bug : 239384
    // Install IGMP on the router by default (for RAS server only)
    // Boing!, Change to whenever RAS is installed.
    // ----------------------------------------------------------------

    // We do NOT do this if we are using NAT.  The reason is that
    // NAT may want to be added to a demand dial interface.
    // ----------------------------------------------------------------
    if ((m_wizType != WizardRouterType_NAT) ||
        ((m_wizType == WizardRouterType_NAT) && !m_fCreateDD))
    {
        // The path that NAT takes when creating the DD interface
        // is somewhere else.
        // ------------------------------------------------------------
        Assert(m_fCreateDD == FALSE);

        if (pRouter)
        {
            if (m_wizType == WizardRouterType_NAT)
            {
                AddIGMPToNATServer(&m_RtrConfigData, pRouter);
            }
            else if (m_RtrConfigData.m_dwRouterType & ROUTER_TYPE_RAS)
            {
                AddIGMPToRasServer(&m_RtrConfigData, pRouter);
            }
        }

        if (m_RtrConfigData.m_dwConfigFlags & RTRCONFIG_SETUP_NAT)
        {
            AddNATToServer(this, &m_RtrConfigData, pRouter, m_fCreateDD, FALSE);
        }

        // Windows NT Bug : 371493
        // Add the DHCP relay agent protocol
        if (m_RtrConfigData.m_dwRouterType & ROUTER_TYPE_RAS)
        {
            DWORD   dwDhcpServer = 0;

            if (!m_stPrivateInterfaceId.IsEmpty())
            {
                RtrWizInterface *   pRtrWizIf = NULL;

                m_ifMap.Lookup(m_stPrivateInterfaceId, pRtrWizIf);
                if (pRtrWizIf)
                {
                    if (!pRtrWizIf->m_stDhcpServer.IsEmpty())
                        dwDhcpServer = INET_ADDR((LPCTSTR) pRtrWizIf->m_stDhcpServer);

                    // If we have a value of 0, or if the address
                    // is all 1's then we have a bogus address.
                    if ((dwDhcpServer == 0) ||
                        (dwDhcpServer == MAKEIPADDRESS(255,255,255,255)))
                        AfxMessageBox(IDS_WRN_RTRWIZ_NO_DHCP_SERVER);

                }
            }

            AddIPBOOTPToServer(&m_RtrConfigData, pRouter, dwDhcpServer);
        }
    }


    // If this is a VPN, add the filters to the public interface
    // ----------------------------------------------------------------
    if (m_wizType == WizardRouterType_VPN)
    {
        if (!m_stPublicInterfaceId.IsEmpty())
        {
#if __USE_ICF__
            m_RtrConfigData.m_dwConfigFlags |= RTRCONFIG_SETUP_NAT;
            AddNATToServer(this, &m_RtrConfigData, pRouter, m_fCreateDD, FALSE);
#else            
            RtrWizInterface*    pIf = NULL;
            m_ifMap.Lookup(m_stPublicInterfaceId, pIf);
            AddVPNFiltersToInterface(pRouter, m_stPublicInterfaceId, pIf);
			DisableDDNSandNetBtOnInterface ( pRouter, m_stPublicInterfaceId, pIf);
#endif
        }
    }

    // Try to update the policy.
    // ----------------------------------------------------------------

    // This should check the auth flags and the value of the flags
    // should follow that.
    // ----------------------------------------------------------------
    if ((m_RtrConfigData.m_dwRouterType & ROUTER_TYPE_RAS) && !m_fUseRadius)
    {
        LPWSTR  pswzServerName = NULL;
        DWORD   dwFlags;
        BOOL    fRequireEncryption;

        if (!IsLocalMachine(m_stServerName))
            pswzServerName = (LPTSTR)(LPCTSTR) m_stServerName;

        dwFlags = m_RtrConfigData.m_authData.m_dwFlags;

        // Only require encryption if this is a VPN server
        // do not set the PPPCFG_RequireEncryption flag
        // ------------------------------------------------------------
        fRequireEncryption = (m_wizType == WizardRouterType_VPN);

        hr = UpdateDefaultPolicy(pswzServerName,
                                 !!(dwFlags & PPPCFG_NegotiateMSCHAP),
                                 !!(dwFlags & PPPCFG_NegotiateStrongMSCHAP),
                                 fRequireEncryption);

        if (!FHrSucceeded(hr))
        {
            if (hr == ERROR_NO_DEFAULT_PROFILE)
            {
                // Do one thing
                AfxMessageBox(IDS_ERR_CANNOT_FIND_DEFAULT_RAP, MB_OK | MB_ICONEXCLAMATION);

                // since we already displayed the warning
                hr = S_OK;
            }
            else
            {
                // Format the message
                AddSystemErrorMessage(hr);

                // popup a warning dialog
                AddHighLevelErrorStringId(IDS_ERR_CANNOT_SYNC_WITH_RAP);
                DisplayTFSErrorMessage(NULL);
            }
        }
    }



    // Always start the router.
    // ----------------------------------------------------------------
    SetRouterServiceStartType(m_stServerName,
                              SERVICE_AUTO_START);
    {
        // If this is manual start, we need to prompt them
        // ------------------------------------------------------------
        if ((m_wizType != WizardRouterType_Manual) ||
            (AfxMessageBox(IDS_PROMPT_START_ROUTER_AFTER_INSTALL,
                           MB_YESNO | MB_TASKMODAL | MB_SETFOREGROUND) == IDYES))
        {
            CWaitCursor        wait;
            StartRouterService(m_RtrConfigData.m_stServerName);
        }
    }


    // Mark this data structure as been saved.  This way, when we
    // reennter this function it doesn't get run again.
    // ----------------------------------------------------------------
    m_fSaved = TRUE;

Error:

    // Force a router reconfiguration
    // ----------------------------------------------------------------

    // Force a full disconnect
    // This will force the handles to be released
    // ----------------------------------------------------------------
    pRouter->DoDisconnect();

    // ForceGlobalRefresh(m_spRouter);

    // Get the error back
    // ----------------------------------------------------------------
    if (!FHrSucceeded(hr))
    {
        AddSystemErrorMessage(hr);
        AddHighLevelErrorStringId(IDS_ERR_CANNOT_INSTALL_ROUTER);
        DisplayTFSErrorMessage(NULL);
    }

    if (csi.pAuthInfo)
        delete csi.pAuthInfo->pAuthIdentityData->Password;

    return hr;
}


/*!--------------------------------------------------------------------------
    NewRtrWizData::SaveRadiusConfig
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT NewRtrWizData::SaveRadiusConfig()
{
    HRESULT     hr = hrOK;
    HKEY        hkeyMachine = NULL;
    RADIUSSERVER    rgServers[2];
    RADIUSSERVER *  pServers = NULL;
    CRadiusServers  oldServers;
    BOOL        fServerAdded = FALSE;

    CWRg( ConnectRegistry((LPTSTR) (LPCTSTR) m_stServerName, &hkeyMachine) );

    if (m_fUseRadius)
    {
        pServers = rgServers;

        Assert(!m_stRadius1.IsEmpty() || !m_stRadius2.IsEmpty());

        // Setup the pServers
        if (!m_stRadius1.IsEmpty() && m_stRadius1.GetLength())
        {
            pServers->UseDefaults();

            pServers->cScore = MAXSCORE;

            // For compatibility with other RADIUS servers, we
            // default this to OFF.
            pServers->fUseDigitalSignatures = FALSE;

            StrnCpy(pServers->szName, (LPCTSTR) m_stRadius1, MAX_PATH);
            StrnCpy(pServers->wszSecret, (LPCTSTR) m_stRadiusSecret, MAX_PATH);
            pServers->cchSecret = m_stRadiusSecret.GetLength();
            pServers->IPAddress.sin_addr.s_addr = m_netRadius1IpAddress;

            pServers->ucSeed = m_uSeed;

            pServers->pNext = NULL;

            fServerAdded = TRUE;
        }

        if (!m_stRadius2.IsEmpty() && m_stRadius2.GetLength())
        {
            // Have the previous one point here
            if (fServerAdded)
            {
                pServers->pNext = pServers+1;
                pServers++;
            }

            pServers->UseDefaults();

            pServers->cScore = MAXSCORE - 1;

            // For compatibility with other RADIUS servers, we
            // default this to OFF.
            pServers->fUseDigitalSignatures = FALSE;

            StrnCpy(pServers->szName, (LPCTSTR) m_stRadius2, MAX_PATH);
            StrnCpy(pServers->wszSecret, (LPCTSTR) m_stRadiusSecret, MAX_PATH);
            pServers->cchSecret = m_stRadiusSecret.GetLength();
            pServers->IPAddress.sin_addr.s_addr = m_netRadius2IpAddress;

            pServers->ucSeed = m_uSeed;

            pServers->pNext = NULL;

            fServerAdded = TRUE;
        }

        // Ok, reset pServers
        if (fServerAdded)
            pServers = rgServers;

    }

    // Load the original server list and remove it from the
    // LSA database.
    LoadRadiusServers(m_stServerName,
                      hkeyMachine,
                      TRUE,
                      &oldServers,
                      RADIUS_FLAG_NOUI | RADIUS_FLAG_NOIP);
    DeleteRadiusServers(m_stServerName,
                        oldServers.GetNextServer(TRUE));
    oldServers.FreeAllServers();


    LoadRadiusServers(m_stServerName,
                      hkeyMachine,
                      FALSE,
                      &oldServers,
                      RADIUS_FLAG_NOUI | RADIUS_FLAG_NOIP);
    DeleteRadiusServers(m_stServerName,
                        oldServers.GetNextServer(TRUE));


    // Save the authentication servers
    CORg( SaveRadiusServers(m_stServerName,
                            hkeyMachine,
                            TRUE,
                            pServers) );

    // Save the accounting servers
    CORg( SaveRadiusServers(m_stServerName,
                            hkeyMachine,
                            FALSE,
                            pServers) );

Error:
    if (hkeyMachine)
        DisconnectRegistry(hkeyMachine);
    return hr;
}



/*---------------------------------------------------------------------------
    CNewRtrWizPageBase Implementation
 ---------------------------------------------------------------------------*/

PageStack CNewRtrWizPageBase::m_pagestack;

CNewRtrWizPageBase::CNewRtrWizPageBase(UINT idd, PageType pt)
    : CPropertyPageBase(idd),
    m_pagetype(pt),
    m_pRtrWizData(NULL),
    m_uDialogId(idd)
{
}

BEGIN_MESSAGE_MAP(CNewRtrWizPageBase, CPropertyPageBase)
//{{AFX_MSG_MAP(CNewWizTestParams)
    ON_MESSAGE(WM_HELP, OnHelp)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()

static DWORD    s_rgBulletId[] =
{
    IDC_NEWWIZ_BULLET_1,
    IDC_NEWWIZ_BULLET_2,
    IDC_NEWWIZ_BULLET_3,
    IDC_NEWWIZ_BULLET_4,
    0
};

BOOL CNewRtrWizPageBase::OnInitDialog()
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

    CWnd *  pWnd = GetDlgItem(IDC_NEWWIZ_BIGTEXT);
    HICON   hIcon;
    CWnd *  pBulletWnd;
    CString strFontName;
    CString strFontSize;
    BOOL    fCreateFont = FALSE;

    CPropertyPageBase::OnInitDialog();

    if (pWnd)
    {
        // Ok we have to create the font
        strFontName.LoadString(IDS_LARGEFONTNAME);
        strFontSize.LoadString(IDS_LARGEFONTSIZE);

        if (m_fontBig.CreatePointFont(10*_ttoi(strFontSize), strFontName))
        {
            pWnd->SetFont(&m_fontBig);
        }
    }

    // Set the fonts to show up as bullets
    for (int i=0; s_rgBulletId[i] != 0; i++)
    {
        pBulletWnd = GetDlgItem(s_rgBulletId[i]);
        if (pBulletWnd)
        {
            // Only create the font if needed
            if (!fCreateFont)
            {
                strFontName.LoadString(IDS_BULLETFONTNAME);
                strFontSize.LoadString(IDS_BULLETFONTSIZE);

                m_fontBullet.CreatePointFont(10*_ttoi(strFontSize), strFontName);
                fCreateFont = TRUE;
            }
            pBulletWnd->SetFont(&m_fontBullet);
        }
    }


    pWnd = GetDlgItem(IDC_NEWWIZ_ICON_WARNING);
    if (pWnd)
    {
        hIcon = AfxGetApp()->LoadStandardIcon(IDI_EXCLAMATION);
        ((CStatic *) pWnd)->SetIcon(hIcon);
    }

    pWnd = GetDlgItem(IDC_NEWWIZ_ICON_INFORMATION);
    if (pWnd)
    {
        hIcon = AfxGetApp()->LoadStandardIcon(IDI_INFORMATION);
        ((CStatic *) pWnd)->SetIcon(hIcon);
    }

    return TRUE;
}


/*!--------------------------------------------------------------------------
    CNewRtrWizPageBase::PushPage
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
void CNewRtrWizPageBase::PushPage(UINT idd)
{
    m_pagestack.AddHead(idd);
}

/*!--------------------------------------------------------------------------
    CNewRtrWizPageBase::PopPage
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
UINT CNewRtrWizPageBase::PopPage()
{
    if (m_pagestack.IsEmpty())
        return 0;

    return m_pagestack.RemoveHead();
}

/*!--------------------------------------------------------------------------
    CNewRtrWizPageBase::OnSetActive
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
BOOL CNewRtrWizPageBase::OnSetActive()
{
    switch (m_pagetype)
    {
        case Start:
            GetHolder()->SetWizardButtonsFirst(TRUE);
            break;
        case Middle:
            GetHolder()->SetWizardButtonsMiddle(TRUE);
            break;
        default:
        case Finish:
            GetHolder()->SetWizardButtonsLast(TRUE);
            break;
    }

    return CPropertyPageBase::OnSetActive();
}

/*!--------------------------------------------------------------------------
    CNewRtrWizPageBase::OnWizardNext
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
LRESULT CNewRtrWizPageBase::OnWizardNext()
{
    HRESULT hr = hrOK;
    LRESULT lResult;

    // Tell the page to save it's state
    hr = OnSavePage();
    if (FHrSucceeded(hr))
    {
        // Now figure out where to go next
        Assert(m_pRtrWizData);
        lResult = m_pRtrWizData->GetNextPage(m_uDialogId);

        switch (lResult)
        {
            case ERR_IDD_FINISH_WIZARD:
                OnWizardFinish();

                // fall through to the cancel case

            case ERR_IDD_CANCEL_WIZARD:
                GetHolder()->PressButton(PSBTN_CANCEL);
                lResult = -1;
                break;

            default:
                // Push the page only if we are going to another page
                // The other cases will cause the wizard to exit, and
                // we don't need the page stack.
                // ----------------------------------------------------
                if (lResult != -1)
                    PushPage(m_uDialogId);
                break;
        }

        return lResult;
    }
    else
        return (LRESULT) -1;    // error! do not change the page
}

/*!--------------------------------------------------------------------------
    CNewRtrWizPageBase::OnWizardBack
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
LRESULT CNewRtrWizPageBase::OnWizardBack()
{
    Assert(!m_pagestack.IsEmpty());
    return PopPage();
}

/*!--------------------------------------------------------------------------
    CNewRtrWizPageBase::OnWizardFinish
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
BOOL CNewRtrWizPageBase::OnWizardFinish()
{
    GetHolder()->OnFinish();
    return TRUE;
}

HRESULT CNewRtrWizPageBase::OnSavePage()
{
    return hrOK;
}

LRESULT CNewRtrWizPageBase::OnHelp(WPARAM, LPARAM lParam)
{
    HELPINFO *  pHelpInfo = (HELPINFO *) lParam;

    // Windows NT Bug : 408722
    // Put the help call here, this should only come in from
    // the call from the dialog.
    if (pHelpInfo->dwContextId == 0xdeadbeef)
    {
        HtmlHelpA(NULL, c_sazRRASDomainHelpTopic, HH_DISPLAY_TOPIC, 0);
        return TRUE;
    }
    return FALSE;
}




/*---------------------------------------------------------------------------
    CNewRtrWizFinishPageBase Implementation
 ---------------------------------------------------------------------------*/

CNewRtrWizFinishPageBase::CNewRtrWizFinishPageBase(UINT idd,
    RtrWizFinishSaveFlag SaveFlag,
    RtrWizFinishHelpFlag HelpFlag)
    : CNewRtrWizPageBase(idd, CNewRtrWizPageBase::Finish),
    m_SaveFlag(SaveFlag),
    m_HelpFlag(HelpFlag)
{
}

BEGIN_MESSAGE_MAP(CNewRtrWizFinishPageBase, CNewRtrWizPageBase)
//{{AFX_MSG_MAP(CNewWizTestParams)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()


/*!--------------------------------------------------------------------------
    CNewRtrWizFinishPageBase::OnSetActive
        -
    Author: KennT
 ---------------------------------------------------------------------------*/

static DWORD    s_rgServerNameId[] =
{
   IDC_NEWWIZ_TEXT_SERVER_NAME,
   IDC_NEWWIZ_TEXT_SERVER_NAME_2,
   0
};

static DWORD   s_rgInterfaceId[] =
{
    IDC_NEWWIZ_TEXT_INTERFACE_1, IDS_RTRWIZ_INTERFACE_NAME_1,
    IDC_NEWWIZ_TEXT_INTERFACE_2, IDS_RTRWIZ_INTERFACE_2,
    0,0
};

/*!--------------------------------------------------------------------------
    CNewRtrWizFinishPageBase::OnInitDialog
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
BOOL CNewRtrWizFinishPageBase::OnInitDialog()
{
    CString st, stBase;

    CNewRtrWizPageBase::OnInitDialog();

    // If there is a control that wants a server name, replace it
    for (int i=0; s_rgServerNameId[i]; i++)
    {
        if (GetDlgItem(s_rgServerNameId[i]))
        {
            GetDlgItemText(s_rgServerNameId[i], stBase);
            st.Format((LPCTSTR) stBase,
                      (LPCTSTR) m_pRtrWizData->m_stServerName);
            SetDlgItemText(s_rgServerNameId[i], st);
            }
    }

    if (GetDlgItem(IDC_NEWWIZ_TEXT_ERROR))
    {
        TCHAR   szErr[2048];

        Assert(!FHrOK(m_pRtrWizData->m_hrDDError));

        FormatRasError(m_pRtrWizData->m_hrDDError, szErr, DimensionOf(szErr));

        GetDlgItemText(IDC_NEWWIZ_TEXT_ERROR, stBase);
        st.Format((LPCTSTR) stBase,
                  szErr);
        SetDlgItemText(IDC_NEWWIZ_TEXT_ERROR, (LPCTSTR) st);
    }

    return TRUE;
}

/*!--------------------------------------------------------------------------
    CNewRtrWizFinishPageBase::OnSetActive
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
BOOL CNewRtrWizFinishPageBase::OnSetActive()
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
    DWORD   i;
    CString st;
    CString stIfName;
    RtrWizInterface *   pRtrWizIf = NULL;

    // Handle support for displaying the interface name on the
    // finish page.  We need to do it in the OnSetActive() rather
    // than the OnInitDialog() since the interface chosen can change.

    // Try to find the inteface name
    m_pRtrWizData->m_ifMap.Lookup(m_pRtrWizData->m_stPublicInterfaceId,
                                  pRtrWizIf);

    if (pRtrWizIf)
        stIfName = pRtrWizIf->m_stName;
    else
    {
        // This may be the dd interface case.  If we are creating
        // a DD interface the name will never have been added to the
        // interface map.
        stIfName = m_pRtrWizData->m_stPublicInterfaceId;
    }
    for (i=0; s_rgInterfaceId[i] != 0; i+=2)
    {
        if (GetDlgItem(s_rgInterfaceId[i]))
        {
            st.Format(s_rgInterfaceId[i+1], (LPCTSTR) stIfName);
            SetDlgItemText(s_rgInterfaceId[i], st);
        }
    }

    return CNewRtrWizPageBase::OnSetActive();
}

/*!--------------------------------------------------------------------------
    CNewRtrWizFinishPageBase::OnWizardFinish
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
BOOL CNewRtrWizFinishPageBase::OnWizardFinish()
{
    m_pRtrWizData->m_SaveFlag = m_SaveFlag;

    // If there is a help button and it is not checked,
    // then do not bring up the help.
    if (GetDlgItem(IDC_NEWWIZ_CHK_HELP) &&
        !IsDlgButtonChecked(IDC_NEWWIZ_CHK_HELP))
        m_pRtrWizData->m_HelpFlag = HelpFlag_Nothing;
    else
        m_pRtrWizData->m_HelpFlag = m_HelpFlag;

    return CNewRtrWizPageBase::OnWizardFinish();
}

/////////////////////////////////////////////////////////////////////////////
//
// CNewRtrWiz holder
//
/////////////////////////////////////////////////////////////////////////////


CNewRtrWiz::CNewRtrWiz(
                       ITFSNode *        pNode,
                       IRouterInfo *      pRouter,
                       IComponentData *  pComponentData,
                       ITFSComponentData * pTFSCompData,
                       LPCTSTR           pszSheetName
                      ) :
   CPropertyPageHolderBase(pNode, pComponentData, pszSheetName)
{
   //ASSERT(pFolderNode == GetContainerNode());

    m_bAutoDeletePages = FALSE; // we have the pages as embedded members

    Assert(pTFSCompData != NULL);
    m_spTFSCompData.Set(pTFSCompData);
    m_bWiz97 = TRUE;

    m_spRouter.Set(pRouter);

}


CNewRtrWiz::~CNewRtrWiz()
{
    POSITION    pos;
    CNewRtrWizPageBase  *pPageBase;

    pos = m_pagelist.GetHeadPosition();
    while (pos)
    {
        pPageBase = m_pagelist.GetNext(pos);

        RemovePageFromList(static_cast<CPropertyPageBase *>(pPageBase), FALSE);
    }

    m_pagelist.RemoveAll();
}


/*!--------------------------------------------------------------------------
    CNewRtrWiz::Init
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT CNewRtrWiz::Init(LPCTSTR pServerName)
{
    HRESULT hr = hrOK;
    POSITION    pos;
    CNewRtrWizPageBase  *pPageBase;

    // Setup the list of pages
    m_pagelist.AddTail(&m_pageWelcome);
    m_pagelist.AddTail(&m_pageCommonConfig);
    m_pagelist.AddTail(&m_pageNatFinishSConflict);
    m_pagelist.AddTail(&m_pageNatFinishSConflictNonLocal);
    m_pagelist.AddTail(&m_pageNatFinishAConflict);
    m_pagelist.AddTail(&m_pageNatFinishAConflictNonLocal);
    m_pagelist.AddTail(&m_pageNatFinishNoIP);
    m_pagelist.AddTail(&m_pageNatFinishNoIPNonLocal);
    m_pagelist.AddTail(&m_pageNatChoice);
    m_pagelist.AddTail(&m_pageNatSelectPublic);
    m_pagelist.AddTail(&m_pageNatSelectPrivate);
    m_pagelist.AddTail(&m_pageNatFinishAdvancedNoNICs);
    m_pagelist.AddTail(&m_pageNatDHCPDNS);
    m_pagelist.AddTail(&m_pageNatDHCPWarning);
    m_pagelist.AddTail(&m_pageNatDDWarning);
    m_pagelist.AddTail(&m_pageNatFinish);
    m_pagelist.AddTail(&m_pageNatFinishExternal);
    m_pagelist.AddTail(&m_pageNatFinishDDError);
    m_pagelist.AddTail(&m_pageRasChoice);
    m_pagelist.AddTail(&m_pageRasFinishNeedProtocols);
    m_pagelist.AddTail(&m_pageRasFinishNeedProtocolsNonLocal);
    m_pagelist.AddTail(&m_pageRasProtocols);
    //m_pagelist.AddTail(&m_pageRasAppletalk);
    m_pagelist.AddTail(&m_pageRasNoNICs);
    m_pagelist.AddTail(&m_pageRasFinishNoNICs);
    m_pagelist.AddTail(&m_pageRasNetwork);
    m_pagelist.AddTail(&m_pageRasAddressing);
    m_pagelist.AddTail(&m_pageRasAddressingNoNICs);
    m_pagelist.AddTail(&m_pageRasAddressPool);
    m_pagelist.AddTail(&m_pageRasRadius);
    m_pagelist.AddTail(&m_pageRasRadiusConfig);
    m_pagelist.AddTail(&m_pageRasFinishAdvanced);

    m_pagelist.AddTail(&m_pageVpnFinishNoNICs);
    m_pagelist.AddTail(&m_pageVpnFinishNoIP);
    m_pagelist.AddTail(&m_pageVpnFinishNoIPNonLocal);
    m_pagelist.AddTail(&m_pageVpnProtocols);
    m_pagelist.AddTail(&m_pageVpnFinishNeedProtocols);
    m_pagelist.AddTail(&m_pageVpnFinishNeedProtocolsNonLocal);
    //m_pagelist.AddTail(&m_pageVpnAppletalk);
    m_pagelist.AddTail(&m_pageVpnSelectPublic);
    m_pagelist.AddTail(&m_pageVpnSelectPrivate);
    m_pagelist.AddTail(&m_pageVpnAddressing);
    m_pagelist.AddTail(&m_pageVpnAddressPool);
    m_pagelist.AddTail(&m_pageVpnRadius);
    m_pagelist.AddTail(&m_pageVpnRadiusConfig);
    m_pagelist.AddTail(&m_pageVpnFinishAdvanced);

    m_pagelist.AddTail(&m_pageRouterProtocols);
    m_pagelist.AddTail(&m_pageRouterFinishNeedProtocols);
    m_pagelist.AddTail(&m_pageRouterFinishNeedProtocolsNonLocal);
    m_pagelist.AddTail(&m_pageRouterUseDD);
    m_pagelist.AddTail(&m_pageRouterAddressing);
    m_pagelist.AddTail(&m_pageRouterAddressPool);
    m_pagelist.AddTail(&m_pageRouterFinish);
    m_pagelist.AddTail(&m_pageRouterFinishDD);

    m_pagelist.AddTail(&m_pageManualFinish);


    m_RtrWizData.Init(pServerName, m_spRouter);
    m_RtrWizData.m_stServerName = pServerName;


    // Initialize all of the pages
    pos = m_pagelist.GetHeadPosition();
    while (pos)
    {
        pPageBase = m_pagelist.GetNext(pos);

        pPageBase->Init(&m_RtrWizData, this);
    }


    // Add all of the pages to the property sheet
    pos = m_pagelist.GetHeadPosition();
    while (pos)
    {
        pPageBase = m_pagelist.GetNext(pos);

        AddPageToList(static_cast<CPropertyPageBase *>(pPageBase));
    }

    return hr;
}



/*!--------------------------------------------------------------------------
    CNewRtrWiz::OnFinish
        Called from the OnWizardFinish
    Author: KennT
 ---------------------------------------------------------------------------*/
DWORD CNewRtrWiz::OnFinish()
{
    DWORD dwError = ERROR_SUCCESS;
    RtrWizInterface *   pRtrWizIf = NULL;
    TCHAR               szBuffer[1024];
    CString st;
    LPCTSTR              pszHelpString = NULL;
    STARTUPINFO             si;
    PROCESS_INFORMATION     pi;


#if defined(DEBUG) && defined(kennt)
    if (m_RtrWizData.m_SaveFlag != SaveFlag_Advanced)
        st += _T("NO configuration change required\n\n");

    // For now, just display the test parameter output
    switch (m_RtrWizData.m_wizType)
    {
        case NewRtrWizData::WizardRouterType_NAT:
            st += _T("NAT\n");
            break;
        case NewRtrWizData::WizardRouterType_RAS:
            st += _T("RAS\n");
            break;
        case NewRtrWizData::WizardRouterType_VPN:
            st += _T("VPN\n");
            break;
        case NewRtrWizData::WizardRouterType_Router:
            st += _T("Router\n");
            break;
        case NewRtrWizData::WizardRouterType_Manual:
            st += _T("Manual\n");
            break;
    }
    if (m_RtrWizData.m_fAdvanced)
        st += _T("Advanced path\n");
    else
        st += _T("Simple path\n");

    if (m_RtrWizData.m_fNeedMoreProtocols)
        st += _T("Need to install more protocols\n");

    if (m_RtrWizData.m_fCreateDD)
        st += _T("Need to create a DD interface\n");

    st += _T("Public interface : ");
    m_RtrWizData.m_ifMap.Lookup(m_RtrWizData.m_stPublicInterfaceId, pRtrWizIf);
    if (pRtrWizIf)
        st += pRtrWizIf->m_stName;
    st += _T("\n");

    st += _T("Private interface : ");
    m_RtrWizData.m_ifMap.Lookup(m_RtrWizData.m_stPrivateInterfaceId, pRtrWizIf);
    if (pRtrWizIf)
        st += pRtrWizIf->m_stName;
    st += _T("\n");

    if (m_RtrWizData.m_wizType == NewRtrWizData::WizardRouterType_NAT)
    {
        if (m_RtrWizData.m_fNatUseSimpleServers)
            st += _T("NAT - use simple DHCP and DNS\n");
        else
            st += _T("NAT - use external DHCP and DNS\n");
    }

    if (m_RtrWizData.m_fWillBeInDomain)
        st += _T("Will be in a domain\n");

    if (m_RtrWizData.m_fNoNicsAreOk)
        st += _T("No NICs is ok\n");

    if (m_RtrWizData.m_fUseIpxType20Broadcasts)
        st += _T("IPX should deliver Type20 broadcasts\n");

    if (m_RtrWizData.m_fAppletalkUseNoAuth)
        st += _T("Use unauthenticated access\n");

    if (m_RtrWizData.m_fUseDHCP)
        st += _T("Use DHCP for addressing\n");
    else
        st += _T("Use Static pools for addressing\n");

    if (m_RtrWizData.m_fUseRadius)
    {
        st += _T("Use RADIUS\n");
        st += _T("Server 1 : ");
        st += m_RtrWizData.m_stRadius1;
        st += _T("\n");
        st += _T("Server 2 : ");
        st += m_RtrWizData.m_stRadius2;
        st += _T("\n");
    }

    if (m_RtrWizData.m_fTest)
    {
        if (AfxMessageBox(st, MB_OKCANCEL) == IDCANCEL)
            return 0;
    }
#endif

    // else continue on, saving the real data

    if (m_RtrWizData.m_SaveFlag == SaveFlag_Simple)
    {
        ::ZeroMemory(&si, sizeof(STARTUPINFO));
        si.cb = sizeof(STARTUPINFO);
        si.dwX = si.dwY = si.dwXSize = si.dwYSize = 0L;
        si.wShowWindow = SW_SHOW;
        ::ZeroMemory(&pi, sizeof(PROCESS_INFORMATION));

        ExpandEnvironmentStrings(s_szConnectionUICommandLine,
                                 szBuffer,
                                 DimensionOf(szBuffer));


        ::CreateProcess(NULL,          // ptr to name of executable
                        szBuffer,       // pointer to command line string
                        NULL,            // process security attributes
                        NULL,            // thread security attributes
                        FALSE,            // handle inheritance flag
                        CREATE_NEW_CONSOLE,// creation flags
                        NULL,            // ptr to new environment block
                        NULL,            // ptr to current directory name
                        &si,
                        &pi);
        ::CloseHandle(pi.hProcess);
        ::CloseHandle(pi.hThread);
    }
    else if (m_RtrWizData.m_SaveFlag == SaveFlag_Advanced)
    {
        // Ok, we're done!
        if (!m_RtrWizData.m_fTest)
        {
            // Get the owner window (i.e. the page)
            // --------------------------------------------------------
            HWND hWndOwner = PropSheet_GetCurrentPageHwnd(m_hSheetWindow);
            m_RtrWizData.FinishTheDamnWizard(hWndOwner, m_spRouter);
        }
    }


    if (m_RtrWizData.m_HelpFlag != HelpFlag_Nothing)
    {
        switch (m_RtrWizData.m_HelpFlag)
        {
            case HelpFlag_Nothing:
                break;
            case HelpFlag_ICS:
                pszHelpString = s_szHowToAddICS;
                break;
            case HelpFlag_AddIp:
            case HelpFlag_AddProtocol:
                pszHelpString = s_szHowToAddAProtocol;
                break;
            case HelpFlag_InboundConnections:
                pszHelpString = s_szHowToAddInboundConnections;
                break;
            case HelpFlag_GeneralNAT:
                pszHelpString = s_szGeneralNATHelp;
                break;
            case HelpFlag_GeneralRAS:
                pszHelpString = s_szGeneralRASHelp;
                break;
            default:
                Panic0("Unknown help flag specified!");
                break;
        }

        LaunchHelpTopic(pszHelpString);
    }



    return dwError;
}



/*---------------------------------------------------------------------------
    CNewWizTestParams Implementation
 ---------------------------------------------------------------------------*/

BEGIN_MESSAGE_MAP(CNewWizTestParams, CBaseDialog)
//{{AFX_MSG_MAP(CNewWizTestParams)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()


BOOL CNewWizTestParams::OnInitDialog()
{
    CBaseDialog::OnInitDialog();

    CheckDlgButton(IDC_NEWWIZ_TEST_LOCAL, m_pWizData->s_fIsLocalMachine);
    CheckDlgButton(IDC_NEWWIZ_TEST_USE_IP, m_pWizData->s_fIpInstalled);
    CheckDlgButton(IDC_NEWWIZ_TEST_USE_IPX, m_pWizData->s_fIpxInstalled);
    CheckDlgButton(IDC_NEWWIZ_TEST_USE_ATLK, m_pWizData->s_fAppletalkInstalled);
    CheckDlgButton(IDC_NEWWIZ_TEST_DNS, m_pWizData->s_fIsDNSRunningOnPrivateInterface);
    CheckDlgButton(IDC_NEWWIZ_TEST_DHCP, m_pWizData->s_fIsDHCPRunningOnPrivateInterface);
    CheckDlgButton(IDC_NEWWIZ_TEST_DOMAIN, m_pWizData->s_fIsMemberOfDomain);
    CheckDlgButton(IDC_NEWWIZ_TEST_SHAREDACCESS, m_pWizData->s_fIsSharedAccessRunningOnServer);

    SetDlgItemInt(IDC_NEWWIZ_TEST_EDIT_NUMNICS, m_pWizData->s_dwNumberOfNICs);

    return TRUE;
}

void CNewWizTestParams::OnOK()
{
    m_pWizData->s_fIsLocalMachine = IsDlgButtonChecked(IDC_NEWWIZ_TEST_LOCAL);
    m_pWizData->s_fIpInstalled = IsDlgButtonChecked(IDC_NEWWIZ_TEST_USE_IP);
    m_pWizData->s_fIpxInstalled = IsDlgButtonChecked(IDC_NEWWIZ_TEST_USE_IPX);
    m_pWizData->s_fAppletalkInstalled = IsDlgButtonChecked(IDC_NEWWIZ_TEST_USE_ATLK);

    m_pWizData->s_fIsDNSRunningOnPrivateInterface = IsDlgButtonChecked(IDC_NEWWIZ_TEST_DNS);
    m_pWizData->s_fIsDHCPRunningOnPrivateInterface = IsDlgButtonChecked(IDC_NEWWIZ_TEST_DHCP);
    m_pWizData->s_fIsMemberOfDomain = IsDlgButtonChecked(IDC_NEWWIZ_TEST_DOMAIN);
    m_pWizData->s_dwNumberOfNICs = GetDlgItemInt(IDC_NEWWIZ_TEST_EDIT_NUMNICS);
    m_pWizData->s_fIsSharedAccessRunningOnServer = IsDlgButtonChecked(IDC_NEWWIZ_TEST_SHAREDACCESS);

    CBaseDialog::OnOK();
}


/*---------------------------------------------------------------------------
    CNewRtrWizWelcome Implementation
 ---------------------------------------------------------------------------*/
CNewRtrWizWelcome::CNewRtrWizWelcome() :
   CNewRtrWizPageBase(CNewRtrWizWelcome::IDD, CNewRtrWizPageBase::Start)
{
    InitWiz97(TRUE, 0, 0);
}


BEGIN_MESSAGE_MAP(CNewRtrWizWelcome, CNewRtrWizPageBase)
END_MESSAGE_MAP()


/*---------------------------------------------------------------------------
    CNewRtrWizCommonConfig Implementation
 ---------------------------------------------------------------------------*/
CNewRtrWizCommonConfig::CNewRtrWizCommonConfig() :
   CNewRtrWizPageBase(CNewRtrWizCommonConfig::IDD, CNewRtrWizPageBase::Middle)
{
    InitWiz97(FALSE,
              IDS_NEWWIZ_COMMONCONFIG_TITLE,
              IDS_NEWWIZ_COMMONCONFIG_SUBTITLE);
}

BEGIN_MESSAGE_MAP(CNewRtrWizCommonConfig, CNewRtrWizPageBase)
END_MESSAGE_MAP()

// This list of IDs will have their controls made bold.
const DWORD s_rgCommonConfigOptionIds[] =
{
    IDC_NEWWIZ_CONFIG_BTN_NAT,
    IDC_NEWWIZ_CONFIG_BTN_RAS,
    IDC_NEWWIZ_CONFIG_BTN_VPN,
    IDC_NEWWIZ_CONFIG_BTN_ROUTER,
    IDC_NEWWIZ_CONFIG_BTN_MANUAL,
    0
};

BOOL CNewRtrWizCommonConfig::OnInitDialog()
{
    Assert(m_pRtrWizData);
    UINT    idSelection;
    LOGFONT LogFont;
    CFont * pOldFont;

    CNewRtrWizPageBase::OnInitDialog();

    // Create a bold text font for the options
    pOldFont = GetDlgItem(s_rgCommonConfigOptionIds[0])->GetFont();
    pOldFont->GetLogFont(&LogFont);
    LogFont.lfWeight = 700;         // make this a bold font
    m_boldFont.CreateFontIndirect(&LogFont);

    // Set all of the options to use the bold font
    for (int i=0; s_rgCommonConfigOptionIds[i]; i++)
    {
        GetDlgItem(s_rgCommonConfigOptionIds[i])->SetFont(&m_boldFont);
    }

    // Need to set the proper value
    switch (m_pRtrWizData->m_wizType)
    {
        case NewRtrWizData::WizardRouterType_NAT:
            idSelection = IDC_NEWWIZ_CONFIG_BTN_NAT;
            break;
        case NewRtrWizData::WizardRouterType_RAS:
            idSelection = IDC_NEWWIZ_CONFIG_BTN_RAS;
            break;
        case NewRtrWizData::WizardRouterType_VPN:
            idSelection = IDC_NEWWIZ_CONFIG_BTN_VPN;
            break;
        case NewRtrWizData::WizardRouterType_Router:
            idSelection = IDC_NEWWIZ_CONFIG_BTN_ROUTER;
            break;
        case NewRtrWizData::WizardRouterType_Manual:
            idSelection = IDC_NEWWIZ_CONFIG_BTN_MANUAL;
            break;
        default:
            Panic1("Unknown Wizard Router Type : %d",
                   m_pRtrWizData->m_wizType);
            idSelection = IDC_NEWWIZ_CONFIG_BTN_NAT;
            break;
    }

    CheckRadioButton(IDC_NEWWIZ_CONFIG_BTN_NAT,
                     IDC_NEWWIZ_CONFIG_BTN_ROUTER,
                     idSelection);

    return TRUE;  // return TRUE unless you set the focus to a control
                  // EXCEPTION: OCX Property Pages should return FALSE
}



HRESULT CNewRtrWizCommonConfig::OnSavePage()
{
    // Record the change
    if (IsDlgButtonChecked(IDC_NEWWIZ_CONFIG_BTN_NAT))
    {
        m_pRtrWizData->m_wizType = NewRtrWizData::WizardRouterType_NAT;
    }
    else if (IsDlgButtonChecked(IDC_NEWWIZ_CONFIG_BTN_RAS))
        m_pRtrWizData->m_wizType = NewRtrWizData::WizardRouterType_RAS;
    else if (IsDlgButtonChecked(IDC_NEWWIZ_CONFIG_BTN_VPN))
        m_pRtrWizData->m_wizType = NewRtrWizData::WizardRouterType_VPN;
    else if (IsDlgButtonChecked(IDC_NEWWIZ_CONFIG_BTN_MANUAL))
        m_pRtrWizData->m_wizType = NewRtrWizData::WizardRouterType_Manual;
    else
    {
        Assert(IsDlgButtonChecked(IDC_NEWWIZ_CONFIG_BTN_ROUTER));
        m_pRtrWizData->m_wizType = NewRtrWizData::WizardRouterType_Router;
    }

    return hrOK;
}


/*---------------------------------------------------------------------------
    CNewRtrWizNatFinishSConflict Implementation
 ---------------------------------------------------------------------------*/
IMPLEMENT_NEWRTRWIZ_FINISH_PAGE(CNewRtrWizNatFinishSConflict,
                                SaveFlag_DoNothing,
                                HelpFlag_Nothing);


/*---------------------------------------------------------------------------
    CNewRtrWizNatFinishSConflictNonLocal Implementation
 ---------------------------------------------------------------------------*/
IMPLEMENT_NEWRTRWIZ_FINISH_PAGE(CNewRtrWizNatFinishSConflictNonLocal,
                                SaveFlag_DoNothing,
                                HelpFlag_Nothing);


/*---------------------------------------------------------------------------
    CNewRtrWizNatFinishAConflict Implementation
 ---------------------------------------------------------------------------*/
IMPLEMENT_NEWRTRWIZ_FINISH_PAGE(CNewRtrWizNatFinishAConflict,
                                SaveFlag_DoNothing,
                                HelpFlag_Nothing);


/*---------------------------------------------------------------------------
    CNewRtrWizNatFinishAConflictNonLocal Implementation
 ---------------------------------------------------------------------------*/
IMPLEMENT_NEWRTRWIZ_FINISH_PAGE(CNewRtrWizNatFinishAConflictNonLocal,
                                SaveFlag_DoNothing,
                                HelpFlag_Nothing);


/*---------------------------------------------------------------------------
    CNewRtrWizNatFinishNoIP Implementation
 ---------------------------------------------------------------------------*/
IMPLEMENT_NEWRTRWIZ_FINISH_PAGE(CNewRtrWizNatFinishNoIP,
                                SaveFlag_DoNothing,
                                HelpFlag_AddIp);


/*---------------------------------------------------------------------------
    CNewRtrWizNatFinishNoIPNonLocal Implementation
 ---------------------------------------------------------------------------*/
IMPLEMENT_NEWRTRWIZ_FINISH_PAGE(CNewRtrWizNatFinishNoIPNonLocal,
                                SaveFlag_DoNothing,
                                HelpFlag_Nothing);


/*---------------------------------------------------------------------------
    CNewRtrWizNatChoice Implementation
 ---------------------------------------------------------------------------*/
CNewRtrWizNatChoice::CNewRtrWizNatChoice() :
   CNewRtrWizPageBase(CNewRtrWizNatChoice::IDD, CNewRtrWizPageBase::Middle)
{
    InitWiz97(FALSE,
              IDS_NEWWIZ_NAT_CHOICE_TITLE,
              IDS_NEWWIZ_NAT_CHOICE_SUBTITLE);
}


BEGIN_MESSAGE_MAP(CNewRtrWizNatChoice, CNewRtrWizPageBase)
END_MESSAGE_MAP()


/*!--------------------------------------------------------------------------
    CNewRtrWizNatChoice::OnInitDialog
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
BOOL CNewRtrWizNatChoice::OnInitDialog()
{
    DWORD   dwNICs;
    UINT    uSelection;

    OSVERSIONINFOEX osInfo;

    
    CNewRtrWizPageBase::OnInitDialog();

    osInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
    ::GetVersionEx((POSVERSIONINFO) &osInfo);

    if ((osInfo.wProductType == VER_NT_SERVER) &&
        (osInfo.wSuiteMask &
            (VER_SUITE_ENTERPRISE | VER_SUITE_DATACENTER)))
    {
        GetDlgItem(IDC_NEWWIZ_BTN_SIMPLE)->EnableWindow(FALSE);
        GetDlgItem(IDC_ICS_TEXT)->EnableWindow(FALSE);
        GetDlgItem(IDC_NEWWIZ_NO_ICS)->ShowWindow(SW_SHOW);
        uSelection = IDC_NEWWIZ_BTN_ADVANCED;
    }
    
    else
    {
        m_pRtrWizData->GetNumberOfNICS_IP(&dwNICs);
        if (dwNICs == 1)
            uSelection = IDC_NEWWIZ_BTN_SIMPLE;
        else
            uSelection = IDC_NEWWIZ_BTN_ADVANCED;
    }
    
    CheckRadioButton(IDC_NEWWIZ_BTN_SIMPLE,
                     IDC_NEWWIZ_BTN_ADVANCED,
                     uSelection);
    return TRUE;
}

HRESULT CNewRtrWizNatChoice::OnSavePage()
{
    // Record the data change
    if (IsDlgButtonChecked(IDC_NEWWIZ_BTN_SIMPLE))
        m_pRtrWizData->m_fAdvanced = FALSE;
    else
    {
        Assert(IsDlgButtonChecked(IDC_NEWWIZ_BTN_ADVANCED));
        m_pRtrWizData->m_fAdvanced = TRUE;
    }

    return hrOK;
}



/*---------------------------------------------------------------------------
    CNewRtrWizNatSelectPublic implementation
 ---------------------------------------------------------------------------*/
CNewRtrWizNatSelectPublic::CNewRtrWizNatSelectPublic() :
   CNewRtrWizPageBase(CNewRtrWizNatSelectPublic::IDD, CNewRtrWizPageBase::Middle)
{
    InitWiz97(FALSE,
              IDS_NEWWIZ_NAT_A_PUBLIC_TITLE,
              IDS_NEWWIZ_NAT_A_PUBLIC_SUBTITLE);
}


void CNewRtrWizNatSelectPublic::DoDataExchange(CDataExchange *pDX)
{
    CNewRtrWizPageBase::DoDataExchange(pDX);

    DDX_Control(pDX, IDC_NEWWIZ_LIST, m_listCtrl);

}

BEGIN_MESSAGE_MAP(CNewRtrWizNatSelectPublic, CNewRtrWizPageBase)
    ON_BN_CLICKED(IDC_NEWWIZ_BTN_NEW, OnBtnClicked)
    ON_BN_CLICKED(IDC_NEWWIZ_BTN_EXISTING, OnBtnClicked)
END_MESSAGE_MAP()


/*!--------------------------------------------------------------------------
    CNewRtrWizNatSelectPublic::OnInitDialog
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
BOOL CNewRtrWizNatSelectPublic::OnInitDialog()
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

    DWORD   dwNICs;
    UINT    uSelection;

    CNewRtrWizPageBase::OnInitDialog();

    // Setup the dialog and add the NICs
    m_pRtrWizData->GetNumberOfNICS_IP(&dwNICs);

    if (dwNICs == 0)
    {
        // Have to use new, there is no other choice.
        CheckRadioButton(IDC_NEWWIZ_BTN_NEW, IDC_NEWWIZ_BTN_EXISTING,
                         IDC_NEWWIZ_BTN_NEW);

        // There are no NICs, so just disable the entire listbox
        MultiEnableWindow(GetSafeHwnd(),
                          FALSE,
                          IDC_NEWWIZ_LIST,
                          IDC_NEWWIZ_BTN_EXISTING,
                          0);
    }
    else
    {
        // The default is to use an existing connection.
        CheckRadioButton(IDC_NEWWIZ_BTN_NEW, IDC_NEWWIZ_BTN_EXISTING,
                         IDC_NEWWIZ_BTN_EXISTING);


        InitializeInterfaceListControl(NULL,
                                       &m_listCtrl,
                                       NULL,
                                       0,
                                       m_pRtrWizData);
        RefreshInterfaceListControl(NULL,
                                    &m_listCtrl,
                                    NULL,
                                    0,
                                    m_pRtrWizData);
        OnBtnClicked();
    }

    return TRUE;
}

HRESULT CNewRtrWizNatSelectPublic::OnSavePage()
{
    if (IsDlgButtonChecked(IDC_NEWWIZ_BTN_NEW))
    {
        m_pRtrWizData->m_fCreateDD = TRUE;
        m_pRtrWizData->m_stPublicInterfaceId.Empty();
    }
    else
    {
        INT     iSel;

        // Check to see that we actually selected an item
        iSel = m_listCtrl.GetNextItem(-1, LVNI_SELECTED);
        if (iSel == -1)
        {
            // We did not select an item
            AfxMessageBox(IDS_PROMPT_PLEASE_SELECT_INTERFACE);
            return E_FAIL;
        }
        m_pRtrWizData->m_fCreateDD = FALSE;

        m_pRtrWizData->m_stPublicInterfaceId = (LPCTSTR) m_listCtrl.GetItemData(iSel);
    }

    return hrOK;
}

void CNewRtrWizNatSelectPublic::OnBtnClicked()
{
    MultiEnableWindow(GetSafeHwnd(),
                      IsDlgButtonChecked(IDC_NEWWIZ_BTN_EXISTING),
                      IDC_NEWWIZ_LIST,
                      0);

    // If the use an existing button is checked,
    // auto-select the first item.
    if (IsDlgButtonChecked(IDC_NEWWIZ_BTN_EXISTING))
        m_listCtrl.SetItemState(0, LVIS_SELECTED, LVIS_SELECTED );

}


/*---------------------------------------------------------------------------
    CNewRtrWizNatFinishAdvancedNoNICs
 ---------------------------------------------------------------------------*/
IMPLEMENT_NEWRTRWIZ_FINISH_PAGE(CNewRtrWizNatFinishAdvancedNoNICs,
                                SaveFlag_DoNothing,
                                HelpFlag_Nothing);


/*---------------------------------------------------------------------------
    CNewRtrWizNatSelectPrivate
 ---------------------------------------------------------------------------*/
CNewRtrWizNatSelectPrivate::CNewRtrWizNatSelectPrivate() :
   CNewRtrWizPageBase(CNewRtrWizNatSelectPrivate::IDD, CNewRtrWizPageBase::Middle)
{
    InitWiz97(FALSE,
              IDS_NEWWIZ_NAT_A_PRIVATE_TITLE,
              IDS_NEWWIZ_NAT_A_PRIVATE_SUBTITLE);
}


void CNewRtrWizNatSelectPrivate::DoDataExchange(CDataExchange *pDX)
{
    CNewRtrWizPageBase::DoDataExchange(pDX);

    DDX_Control(pDX, IDC_NEWWIZ_LIST, m_listCtrl);

}

BEGIN_MESSAGE_MAP(CNewRtrWizNatSelectPrivate, CNewRtrWizPageBase)
END_MESSAGE_MAP()


/*!--------------------------------------------------------------------------
    CNewRtrWizNatSelectPrivate::OnInitDialog
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
BOOL CNewRtrWizNatSelectPrivate::OnInitDialog()
{
    DWORD   dwNICs;

    CNewRtrWizPageBase::OnInitDialog();

    m_pRtrWizData->GetNumberOfNICS_IP(&dwNICs);

    InitializeInterfaceListControl(NULL,
                                   &m_listCtrl,
                                   NULL,
                                   0,
                                   m_pRtrWizData);
    return TRUE;
}

BOOL CNewRtrWizNatSelectPrivate::OnSetActive()
{
    DWORD   dwNICs;
    int     iSel = 0;

    CNewRtrWizPageBase::OnSetActive();

    m_pRtrWizData->GetNumberOfNICS_IP(&dwNICs);

    RefreshInterfaceListControl(NULL,
                                &m_listCtrl,
                                (LPCTSTR) m_pRtrWizData->m_stPublicInterfaceId,
                                0,
                                m_pRtrWizData);

    if (!m_pRtrWizData->m_stPrivateInterfaceId.IsEmpty())
    {
        // Try to reselect the previously selected NIC
        LV_FINDINFO lvfi;

        lvfi.flags = LVFI_PARTIAL | LVFI_STRING;
        lvfi.psz = (LPCTSTR) m_pRtrWizData->m_stPrivateInterfaceId;
        iSel = m_listCtrl.FindItem(&lvfi, -1);
        if (iSel == -1)
            iSel = 0;
    }

    m_listCtrl.SetItemState(iSel, LVIS_SELECTED, LVIS_SELECTED );

    return TRUE;
}

HRESULT CNewRtrWizNatSelectPrivate::OnSavePage()
{
    INT     iSel;

    // Check to see that we actually selected an item
    iSel = m_listCtrl.GetNextItem(-1, LVNI_SELECTED);
    if (iSel == -1)
    {
        // We did not select an item
        AfxMessageBox(IDS_PROMPT_PLEASE_SELECT_INTERFACE);
        return E_FAIL;
    }

    m_pRtrWizData->m_stPrivateInterfaceId = (LPCTSTR) m_listCtrl.GetItemData(iSel);

    return hrOK;
}



/*---------------------------------------------------------------------------
    CNewRtrWizNatDHCPDNS
 ---------------------------------------------------------------------------*/
CNewRtrWizNatDHCPDNS::CNewRtrWizNatDHCPDNS() :
   CNewRtrWizPageBase(CNewRtrWizNatDHCPDNS::IDD, CNewRtrWizPageBase::Middle)
{
    InitWiz97(FALSE,
              IDS_NEWWIZ_NAT_A_DHCPDNS_TITLE,
              IDS_NEWWIZ_NAT_A_DHCPDNS_SUBTITLE);
}


BEGIN_MESSAGE_MAP(CNewRtrWizNatDHCPDNS, CNewRtrWizPageBase)
END_MESSAGE_MAP()


BOOL CNewRtrWizNatDHCPDNS::OnInitDialog()
{
    CheckRadioButton(IDC_NEWWIZ_NAT_USE_SIMPLE,
                     IDC_NEWWIZ_NAT_USE_EXTERNAL,
                     m_pRtrWizData->m_fNatUseSimpleServers ? IDC_NEWWIZ_NAT_USE_SIMPLE : IDC_NEWWIZ_NAT_USE_EXTERNAL);
    return TRUE;
}

HRESULT CNewRtrWizNatDHCPDNS::OnSavePage()
{
    m_pRtrWizData->m_fNatUseSimpleServers = IsDlgButtonChecked(IDC_NEWWIZ_NAT_USE_SIMPLE);
    return hrOK;
}


/*---------------------------------------------------------------------------
    CNewRtrWizNatDHCPWarning
 ---------------------------------------------------------------------------*/
CNewRtrWizNatDHCPWarning::CNewRtrWizNatDHCPWarning() :
   CNewRtrWizPageBase(CNewRtrWizNatDHCPWarning::IDD, CNewRtrWizPageBase::Middle)
{
    InitWiz97(FALSE,
              IDS_NEWWIZ_NAT_A_DHCP_WARNING_TITLE,
              IDS_NEWWIZ_NAT_A_DHCP_WARNING_SUBTITLE);
}


BEGIN_MESSAGE_MAP(CNewRtrWizNatDHCPWarning, CNewRtrWizPageBase)
END_MESSAGE_MAP()


BOOL CNewRtrWizNatDHCPWarning::OnSetActive()
{
    CNewRtrWizPageBase::OnSetActive();
    RtrWizInterface *   pRtrWizIf = NULL;

    // Get the information for the private interface
    m_pRtrWizData->m_ifMap.Lookup(m_pRtrWizData->m_stPrivateInterfaceId,
                                  pRtrWizIf);

    if (pRtrWizIf)
    {
        DWORD   netAddress, netMask;
        CString st;

        // We have to calculate the beginning of the subnet
        netAddress = INET_ADDR(pRtrWizIf->m_stIpAddress);
        netMask = INET_ADDR(pRtrWizIf->m_stMask);

        netAddress = netAddress & netMask;

        st = INET_NTOA(netAddress);

        // Now write out the subnet information for the page
        SetDlgItemText(IDC_NEWWIZ_TEXT_SUBNET, st);
        SetDlgItemText(IDC_NEWWIZ_TEXT_MASK, pRtrWizIf->m_stMask);
    }
    else
    {
        // An error! we do not have a private interface
        // Just leave things blank
        SetDlgItemText(IDC_NEWWIZ_TEXT_SUBNET, _T(""));
        SetDlgItemText(IDC_NEWWIZ_TEXT_MASK, _T(""));
    }

    return TRUE;
}

/*---------------------------------------------------------------------------
    CNewRtrWizNatDDWarning
 ---------------------------------------------------------------------------*/
CNewRtrWizNatDDWarning::CNewRtrWizNatDDWarning() :
   CNewRtrWizPageBase(CNewRtrWizNatDDWarning::IDD, CNewRtrWizPageBase::Middle)
{
    InitWiz97(FALSE,
              IDS_NEWWIZ_NAT_A_DD_WARNING_TITLE,
              IDS_NEWWIZ_NAT_A_DD_WARNING_SUBTITLE);
}


BEGIN_MESSAGE_MAP(CNewRtrWizNatDDWarning, CNewRtrWizPageBase)
END_MESSAGE_MAP()


BOOL CNewRtrWizNatDDWarning::OnSetActive()
{
    CNewRtrWizPageBase::OnSetActive();

    // If we came back here from the DD error page, then
    // we don't allow them to go anywhere else.
    if (!FHrOK(m_pRtrWizData->m_hrDDError))
    {
        CancelToClose();
        GetHolder()->SetWizardButtons(PSWIZB_NEXT);
    }

    return TRUE;
}


HRESULT CNewRtrWizNatDDWarning::OnSavePage()
{
    HRESULT     hr = hrOK;
    CWaitCursor wait;

    if (m_pRtrWizData->m_fTest)
        return hr;

    // Save the wizard data, the service will be started
    OnWizardFinish();

    // Ok, at this point, all of the changes have been committed
    // so we can't go away or go back
    CancelToClose();
    GetHolder()->SetWizardButtons(PSWIZB_NEXT);

    // Start the DD wizard
    Assert(m_pRtrWizData->m_fCreateDD);

    hr = CallRouterEntryDlg(GetSafeHwnd(),
                            m_pRtrWizData,
                            0);

    // We need to force the RouterInfo to reload it's information
    // ----------------------------------------------------------------
    if (m_pRtrWiz && m_pRtrWiz->m_spRouter)
    {
        m_pRtrWiz->m_spRouter->DoDisconnect();
        m_pRtrWiz->m_spRouter->Unload();
        m_pRtrWiz->m_spRouter->Load(m_pRtrWiz->m_spRouter->GetMachineName(), NULL);
    }

    if (FHrSucceeded(hr))
    {
        // If we're setting up NAT, we can now add IGMP/NAT because
        // the dd interface will have been created.
        // ----------------------------------------------------------------
        if (m_pRtrWizData->m_wizType == NewRtrWizData::WizardRouterType_NAT)
        {
            // Setup the data structure for the next couple of functions
            m_pRtrWizData->m_RtrConfigData.m_ipData.m_stPrivateAdapterGUID = m_pRtrWizData->m_stPrivateInterfaceId;
            m_pRtrWizData->m_RtrConfigData.m_ipData.m_stPublicAdapterGUID = m_pRtrWizData->m_stPublicInterfaceId;

            AddIGMPToNATServer(&m_pRtrWizData->m_RtrConfigData, m_pRtrWiz->m_spRouter);
            AddNATToServer(m_pRtrWizData, &m_pRtrWizData->m_RtrConfigData, m_pRtrWiz->m_spRouter, m_pRtrWizData->m_fCreateDD, FALSE);
        }

    }

    m_pRtrWizData->m_hrDDError = hr;

    // Ignore the error, always go on to the next page
    return hrOK;
}



/*---------------------------------------------------------------------------
    CNewRtrWizNatFinish
 ---------------------------------------------------------------------------*/
CNewRtrWizNatFinish::CNewRtrWizNatFinish() :
   CNewRtrWizFinishPageBase(CNewRtrWizNatFinish::IDD, SaveFlag_Advanced, HelpFlag_Nothing)
{
    InitWiz97(TRUE, 0, 0);
}

BEGIN_MESSAGE_MAP(CNewRtrWizNatFinish, CNewRtrWizFinishPageBase)
END_MESSAGE_MAP()

BOOL CNewRtrWizNatFinish::OnSetActive()
{
    CNewRtrWizFinishPageBase::OnSetActive();

    // If we just got here because we created a DD interface
    // we can't go back.
    if (m_pRtrWizData->m_fCreateDD)
    {
        CancelToClose();
        GetHolder()->SetWizardButtons(PSWIZB_FINISH);
    }

    return TRUE;
}


/*---------------------------------------------------------------------------
    CNewRtrWizNatFinishExternal
 ---------------------------------------------------------------------------*/
CNewRtrWizNatFinishExternal::CNewRtrWizNatFinishExternal() :
   CNewRtrWizFinishPageBase(CNewRtrWizNatFinishExternal::IDD, SaveFlag_Advanced, HelpFlag_GeneralNAT)
{
    InitWiz97(TRUE, 0, 0);
}

BEGIN_MESSAGE_MAP(CNewRtrWizNatFinishExternal, CNewRtrWizFinishPageBase)
END_MESSAGE_MAP()

BOOL CNewRtrWizNatFinishExternal::OnSetActive()
{
    CNewRtrWizFinishPageBase::OnSetActive();

    // If we just got here because we created a DD interface
    // we can't go back.
    if (m_pRtrWizData->m_fCreateDD)
    {
        CancelToClose();
        GetHolder()->SetWizardButtons(PSWIZB_FINISH);
    }

    return TRUE;
}


/*---------------------------------------------------------------------------
    CNewRtrWizNatDDError
 ---------------------------------------------------------------------------*/
IMPLEMENT_NEWRTRWIZ_FINISH_PAGE(CNewRtrWizNatFinishDDError,
                                SaveFlag_DoNothing,
                                HelpFlag_Nothing);



/*---------------------------------------------------------------------------
    CNewRtrWizRasChoice Implementation
 ---------------------------------------------------------------------------*/
CNewRtrWizRasChoice::CNewRtrWizRasChoice() :
   CNewRtrWizPageBase(CNewRtrWizRasChoice::IDD, CNewRtrWizPageBase::Middle)
{
    InitWiz97(FALSE,
              IDS_NEWWIZ_RAS_CHOICE_TITLE,
              IDS_NEWWIZ_RAS_CHOICE_SUBTITLE);
}


BEGIN_MESSAGE_MAP(CNewRtrWizRasChoice, CNewRtrWizPageBase)
END_MESSAGE_MAP()


/*!--------------------------------------------------------------------------
    CNewRtrWizRasChoice::OnInitDialog
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
BOOL CNewRtrWizRasChoice::OnInitDialog()
{
    DWORD   dwNICs;
    UINT    uSelection;

    CNewRtrWizPageBase::OnInitDialog();

    m_pRtrWizData->GetNumberOfNICS_IP(&dwNICs);
    if (dwNICs == 1)
        uSelection = IDC_NEWWIZ_BTN_SIMPLE;
    else
        uSelection = IDC_NEWWIZ_BTN_ADVANCED;
    CheckRadioButton(IDC_NEWWIZ_BTN_SIMPLE,
                     IDC_NEWWIZ_BTN_ADVANCED,
                     uSelection);

    return TRUE;
}

HRESULT CNewRtrWizRasChoice::OnSavePage()
{
    // Record the data change
    if (IsDlgButtonChecked(IDC_NEWWIZ_BTN_SIMPLE))
        m_pRtrWizData->m_fAdvanced = FALSE;
    else
    {
        Assert(IsDlgButtonChecked(IDC_NEWWIZ_BTN_ADVANCED));
        m_pRtrWizData->m_fAdvanced = TRUE;
    }

    return hrOK;
}

/*---------------------------------------------------------------------------
    CNewRtrWizProtocols implementation
 ---------------------------------------------------------------------------*/
CNewRtrWizProtocols::CNewRtrWizProtocols(UINT uDialogId) :
   CNewRtrWizPageBase(uDialogId, CNewRtrWizPageBase::Middle),
   m_fUseChecks(TRUE)
{
    // Turn off use of the checkboxes for everyone.
    m_fUseChecks = FALSE;
}


void CNewRtrWizProtocols::DoDataExchange(CDataExchange *pDX)
{
    CNewRtrWizPageBase::DoDataExchange(pDX);

    DDX_Control(pDX, IDC_NEWWIZ_LIST, m_listCtrl);

}

BEGIN_MESSAGE_MAP(CNewRtrWizProtocols, CNewRtrWizPageBase)
END_MESSAGE_MAP()


void CNewRtrWizProtocols::AddProtocolItem(UINT idsProto,
                                          RtrWizProtocolId pid,
                                          INT   nCount)
{
    CString     st;
    INT         iPos;
    LV_ITEM     lvItem;

    st.LoadString(idsProto);

    lvItem.mask = LVIF_TEXT | LVIF_PARAM;
    lvItem.stateMask = LVIS_FOCUSED | LVIS_SELECTED;
    lvItem.state = 0;
    lvItem.iSubItem = 0;

    lvItem.iItem = nCount;
    lvItem.pszText = (LPTSTR)(LPCTSTR) st;
    lvItem.lParam = pid; //same functionality as SetItemData()
    iPos = m_listCtrl.InsertItem(&lvItem);

    m_listCtrl.SetItemText(iPos, 0, st);

    if (m_fUseChecks)
        m_listCtrl.SetCheck(iPos, TRUE);
}


/*!--------------------------------------------------------------------------
    CNewRtrWizProtocols::OnInitDialog
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
BOOL CNewRtrWizProtocols::OnInitDialog()
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

    DWORD   dwNICs;
    UINT    uSelection;
    INT     nCount = 0;
    LV_COLUMN   lvCol;
    RECT        rect;

    CNewRtrWizPageBase::OnInitDialog();

    // add our single column, there is no header
      m_listCtrl.GetClientRect(&rect);
    lvCol.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT;
    lvCol.fmt = LVCFMT_LEFT;
    lvCol.cx = rect.right;
    m_listCtrl.InsertColumn(0, &lvCol);

    if (m_fUseChecks)
        m_listCtrl.InstallChecks();

    // Setup the dialog by adding all of the protocols
    if ( FHrOK(m_pRtrWizData->HrIsIPInstalled()) )
        AddProtocolItem(IDS_RTRWIZ_PROTO_IP, RtrWizProtocol_Ip, nCount++);

    if ( FHrOK(m_pRtrWizData->HrIsIPXInstalled()) )
        AddProtocolItem(IDS_RTRWIZ_PROTO_IPX, RtrWizProtocol_Ipx, nCount++);

    if ( FHrOK(m_pRtrWizData->HrIsAppletalkInstalled()) )
        AddProtocolItem(IDS_RTRWIZ_PROTO_APPLETALK, RtrWizProtocol_Appletalk, nCount++);

//no more netbuei for us in the product:  bugid:153752
#if 0
    if ( FHrOK(m_pRtrWizData->HrIsNbfInstalled()) )
        AddProtocolItem(IDS_RTRWIZ_PROTO_NETBEUI, RtrWizProtocol_Nbf, nCount++);
#endif

    // Note the reversed order.  The question is, do
    // you have all the protocols?
    CheckRadioButton(IDC_NEWWIZ_BTN_YES, IDC_NEWWIZ_BTN_NO,
                     m_pRtrWizData->m_fNeedMoreProtocols ? IDC_NEWWIZ_BTN_NO : IDC_NEWWIZ_BTN_YES);


    return TRUE;
}

/*!--------------------------------------------------------------------------
    CNewRtrWizProtocols::OnSavePage
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT CNewRtrWizProtocols::OnSavePage()
{
    m_pRtrWizData->m_fNeedMoreProtocols = IsDlgButtonChecked(IDC_NEWWIZ_BTN_NO);

    if (m_fUseChecks)
    {
        LV_FINDINFO lvFind;
        INT         iPos;

        lvFind.flags = LVFI_PARAM;
        lvFind.psz = NULL;

        // Is IP in use?
        lvFind.lParam = RtrWizProtocol_Ip;
        iPos = m_listCtrl.FindItem(&lvFind, -1);
        if (iPos != -1)
            m_pRtrWizData->m_fIpInUse = m_listCtrl.GetCheck(iPos);

        // Is IPX in use?
        lvFind.lParam = RtrWizProtocol_Ipx;
        iPos = m_listCtrl.FindItem(&lvFind, -1);
        if (iPos != -1)
            m_pRtrWizData->m_fIpxInUse = m_listCtrl.GetCheck(iPos);

        // Is Appletalk in use?
        lvFind.lParam = RtrWizProtocol_Appletalk;
        iPos = m_listCtrl.FindItem(&lvFind, -1);
        if (iPos != -1)
            m_pRtrWizData->m_fAppletalkInUse = m_listCtrl.GetCheck(iPos);

        // Is Nbf in use?
        lvFind.lParam = RtrWizProtocol_Nbf;
        iPos = m_listCtrl.FindItem(&lvFind, -1);
        if (iPos != -1)
            m_pRtrWizData->m_fNbfInUse = m_listCtrl.GetCheck(iPos);
    }

    return hrOK;
}



/*---------------------------------------------------------------------------
    CNewRtrWizRasProtocols implementation
 ---------------------------------------------------------------------------*/
CNewRtrWizRasProtocols::CNewRtrWizRasProtocols() :
   CNewRtrWizProtocols(CNewRtrWizRasProtocols::IDD)
{
    InitWiz97(FALSE,
              IDS_NEWWIZ_RAS_A_PROTOCOLS_TITLE,
              IDS_NEWWIZ_RAS_A_PROTOCOLS_SUBTITLE);
}

/*---------------------------------------------------------------------------
    CNewRtrWizRasFinishNeedProtocols Implementation
 ---------------------------------------------------------------------------*/
IMPLEMENT_NEWRTRWIZ_FINISH_PAGE(CNewRtrWizRasFinishNeedProtocols,
                                SaveFlag_DoNothing,
                                HelpFlag_AddProtocol);

/*---------------------------------------------------------------------------
    CNewRtrWizRasFinishNeedProtocolsNonLocal Implementation
 ---------------------------------------------------------------------------*/
IMPLEMENT_NEWRTRWIZ_FINISH_PAGE(CNewRtrWizRasFinishNeedProtocolsNonLocal,
                                SaveFlag_DoNothing,
                                HelpFlag_Nothing);


/*---------------------------------------------------------------------------
    CNewRtrWizVpnProtocols implementation
 ---------------------------------------------------------------------------*/
CNewRtrWizVpnProtocols::CNewRtrWizVpnProtocols() :
   CNewRtrWizProtocols(CNewRtrWizVpnProtocols::IDD)
{
    InitWiz97(FALSE,
              IDS_NEWWIZ_VPN_A_PROTOCOLS_TITLE,
              IDS_NEWWIZ_VPN_A_PROTOCOLS_SUBTITLE);
}

/*!--------------------------------------------------------------------------
    CNewRtrWizVpnProtocols::OnSavePage
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT CNewRtrWizVpnProtocols::OnSavePage()
{
    HRESULT     hr = hrOK;

    // First, check to see that IP is checked

    if (m_fUseChecks)
    {
        LV_FINDINFO lvFind;
        INT         iPos;

        lvFind.flags = LVFI_PARAM;
        lvFind.psz = NULL;

        // Is IP in use?
        lvFind.lParam = RtrWizProtocol_Ip;
        iPos = m_listCtrl.FindItem(&lvFind, -1);
        if (iPos != -1)
            m_pRtrWizData->m_fIpInUse = m_listCtrl.GetCheck(iPos);

        // IP must be installed for the VPN Case
        if (!m_pRtrWizData->m_fIpInUse)
        {
            AfxMessageBox(IDS_ERR_RTRWIZ_VPN_REQUIRES_IP);
            hr = E_FAIL;
        }
    }

    if (FHrSucceeded(hr))
        hr = CNewRtrWizProtocols::OnSavePage();

    return hr;
}

/*---------------------------------------------------------------------------
    CNewRtrWizVpnFinishNeedProtocols Implementation
 ---------------------------------------------------------------------------*/
IMPLEMENT_NEWRTRWIZ_FINISH_PAGE(CNewRtrWizVpnFinishNeedProtocols,
                                SaveFlag_DoNothing,
                                HelpFlag_AddProtocol);

/*---------------------------------------------------------------------------
    CNewRtrWizVpnFinishNeedProtocolsNonLocal Implementation
 ---------------------------------------------------------------------------*/
IMPLEMENT_NEWRTRWIZ_FINISH_PAGE(CNewRtrWizVpnFinishNeedProtocolsNonLocal,
                                SaveFlag_DoNothing,
                                HelpFlag_Nothing);




/*---------------------------------------------------------------------------
    CNewRtrWizRouterProtocols implementation
 ---------------------------------------------------------------------------*/
CNewRtrWizRouterProtocols::CNewRtrWizRouterProtocols() :
   CNewRtrWizProtocols(CNewRtrWizRouterProtocols::IDD)
{
    InitWiz97(FALSE,
              IDS_NEWWIZ_ROUTER_PROTOCOLS_TITLE,
              IDS_NEWWIZ_ROUTER_PROTOCOLS_SUBTITLE);

    // For the router, we do not want to show the checkboxes (it doesn't
    // make sense).
    m_fUseChecks = FALSE;
}

/*---------------------------------------------------------------------------
    CNewRtrWizRouterFinishNeedProtocols Implementation
 ---------------------------------------------------------------------------*/
IMPLEMENT_NEWRTRWIZ_FINISH_PAGE(CNewRtrWizRouterFinishNeedProtocols,
                                SaveFlag_DoNothing,
                                HelpFlag_AddProtocol);

/*---------------------------------------------------------------------------
    CNewRtrWizRouterFinishNeedProtocolsNonLocal Implementation
 ---------------------------------------------------------------------------*/
IMPLEMENT_NEWRTRWIZ_FINISH_PAGE(CNewRtrWizRouterFinishNeedProtocolsNonLocal,
                                SaveFlag_DoNothing,
                                HelpFlag_Nothing);


/*---------------------------------------------------------------------------
    CNewRtrWizAppletalk implementation
 ---------------------------------------------------------------------------*/
CNewRtrWizAppletalk::CNewRtrWizAppletalk(UINT uDialogId) :
   CNewRtrWizPageBase(uDialogId, CNewRtrWizPageBase::Middle)
{
}


BEGIN_MESSAGE_MAP(CNewRtrWizAppletalk, CNewRtrWizPageBase)
END_MESSAGE_MAP()


/*!--------------------------------------------------------------------------
    CNewRtrWizAppletalk::OnInitDialog
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
BOOL CNewRtrWizAppletalk::OnInitDialog()
{
    CNewRtrWizPageBase::OnInitDialog();

    // The default is to leave the box unchecked.
    CheckDlgButton(IDC_NEWWIZ_CHECKBOX,
                   m_pRtrWizData->m_fAppletalkUseNoAuth);

    return TRUE;
}

HRESULT CNewRtrWizAppletalk::OnSavePage()
{
    m_pRtrWizData->m_fAppletalkUseNoAuth = IsDlgButtonChecked(IDC_NEWWIZ_CHECKBOX);
    return hrOK;
}


/*---------------------------------------------------------------------------
    CNewRtrWizRasAppletalk implementation
 ---------------------------------------------------------------------------*/
CNewRtrWizRasAppletalk::CNewRtrWizRasAppletalk() :
   CNewRtrWizAppletalk(CNewRtrWizRasAppletalk::IDD)
{
    InitWiz97(FALSE,
              IDS_NEWWIZ_RAS_A_ATALK_TITLE,
              IDS_NEWWIZ_RAS_A_ATALK_SUBTITLE);
}


/*---------------------------------------------------------------------------
    CNewRtrWizVpnAppletalk implementation
 ---------------------------------------------------------------------------*/
CNewRtrWizVpnAppletalk::CNewRtrWizVpnAppletalk() :
   CNewRtrWizAppletalk(CNewRtrWizVpnAppletalk::IDD)
{
    InitWiz97(FALSE,
              IDS_NEWWIZ_VPN_A_ATALK_TITLE,
              IDS_NEWWIZ_VPN_A_ATALK_SUBTITLE);
}



/*---------------------------------------------------------------------------
    CNewRtrWizSelectNetwork implementation
 ---------------------------------------------------------------------------*/
CNewRtrWizSelectNetwork::CNewRtrWizSelectNetwork(UINT uDialogId) :
   CNewRtrWizPageBase(uDialogId, CNewRtrWizPageBase::Middle)
{
}


void CNewRtrWizSelectNetwork::DoDataExchange(CDataExchange *pDX)
{
    CNewRtrWizPageBase::DoDataExchange(pDX);

    DDX_Control(pDX, IDC_NEWWIZ_LIST, m_listCtrl);
}

BEGIN_MESSAGE_MAP(CNewRtrWizSelectNetwork, CNewRtrWizPageBase)
END_MESSAGE_MAP()


/*!--------------------------------------------------------------------------
    CNewRtrWizSelectNetwork::OnInitDialog
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
BOOL CNewRtrWizSelectNetwork::OnInitDialog()
{
//    DWORD   dwNICs;

    CNewRtrWizPageBase::OnInitDialog();

//    m_pRtrWizData->GetNumberOfNICS(&dwNICs);

    InitializeInterfaceListControl(NULL,
                                   &m_listCtrl,
                                   NULL,
                                   0,
                                   m_pRtrWizData);
    RefreshInterfaceListControl(NULL,
                                &m_listCtrl,
                                NULL,
                                0,
                                m_pRtrWizData);

    m_listCtrl.SetItemState(0, LVIS_SELECTED, LVIS_SELECTED );

    return TRUE;
}

HRESULT CNewRtrWizSelectNetwork::OnSavePage()
{
    INT     iSel;

    // Check to see that we actually selected an item
    iSel = m_listCtrl.GetNextItem(-1, LVNI_SELECTED);
    if (iSel == -1)
    {
        // We did not select an item
        AfxMessageBox(IDS_PROMPT_PLEASE_SELECT_INTERFACE);
        return E_FAIL;
    }
    m_pRtrWizData->m_fCreateDD = FALSE;

    m_pRtrWizData->m_stPrivateInterfaceId = (LPCTSTR) m_listCtrl.GetItemData(iSel);

    return hrOK;
}

/*---------------------------------------------------------------------------
    CNewRtrWizRasSelectNetwork implementation
 ---------------------------------------------------------------------------*/
CNewRtrWizRasSelectNetwork::CNewRtrWizRasSelectNetwork() :
   CNewRtrWizSelectNetwork(CNewRtrWizRasSelectNetwork::IDD)
{
    InitWiz97(FALSE,
              IDS_NEWWIZ_RAS_A_SELECT_NETWORK_TITLE,
              IDS_NEWWIZ_RAS_A_SELECT_NETWORK_SUBTITLE);
}


/*---------------------------------------------------------------------------
    CNewRtrWizRasNoNICs implementation
 ---------------------------------------------------------------------------*/
CNewRtrWizRasNoNICs::CNewRtrWizRasNoNICs() :
   CNewRtrWizPageBase(CNewRtrWizRasNoNICs::IDD, CNewRtrWizPageBase::Middle)
{
    InitWiz97(FALSE,
              IDS_NEWWIZ_RAS_NONICS_TITLE,
              IDS_NEWWIZ_RAS_NONICS_SUBTITLE);
}


void CNewRtrWizRasNoNICs::DoDataExchange(CDataExchange *pDX)
{
    CNewRtrWizPageBase::DoDataExchange(pDX);
}

BEGIN_MESSAGE_MAP(CNewRtrWizRasNoNICs, CNewRtrWizPageBase)
END_MESSAGE_MAP()


/*!--------------------------------------------------------------------------
    CNewRtrWizRasNoNICs::OnInitDialog
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
BOOL CNewRtrWizRasNoNICs::OnInitDialog()
{

    CNewRtrWizPageBase::OnInitDialog();

    CheckRadioButton(IDC_NEWWIZ_BTN_YES, IDC_NEWWIZ_BTN_NO,
                     IDC_NEWWIZ_BTN_YES);

    // The default is to create a new connection
    // That is, to leave the button unchecked.
    return TRUE;
}

HRESULT CNewRtrWizRasNoNICs::OnSavePage()
{
    m_pRtrWizData->m_fNoNicsAreOk = IsDlgButtonChecked(IDC_NEWWIZ_BTN_NO);
    return hrOK;
}


/*---------------------------------------------------------------------------
    CNewRtrWizRasFinishNoNICs Implementation
 ---------------------------------------------------------------------------*/
IMPLEMENT_NEWRTRWIZ_FINISH_PAGE(CNewRtrWizRasFinishNoNICs,
                                SaveFlag_DoNothing,
                                HelpFlag_Nothing);





/*---------------------------------------------------------------------------
    CNewRtrWizAddressing implementation
 ---------------------------------------------------------------------------*/
CNewRtrWizAddressing::CNewRtrWizAddressing(UINT uDialogId) :
   CNewRtrWizPageBase(uDialogId, CNewRtrWizPageBase::Middle)
{
}


void CNewRtrWizAddressing::DoDataExchange(CDataExchange *pDX)
{
    CNewRtrWizPageBase::DoDataExchange(pDX);
}

BEGIN_MESSAGE_MAP(CNewRtrWizAddressing, CNewRtrWizPageBase)
END_MESSAGE_MAP()


/*!--------------------------------------------------------------------------
    CNewRtrWizAddressing::OnInitDialog
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
BOOL CNewRtrWizAddressing::OnInitDialog()
{
    CNewRtrWizPageBase::OnInitDialog();

    CheckRadioButton(IDC_NEWWIZ_BTN_YES, IDC_NEWWIZ_BTN_NO,
                     m_pRtrWizData->m_fUseDHCP ? IDC_NEWWIZ_BTN_YES : IDC_NEWWIZ_BTN_NO);

    return TRUE;
}

/*!--------------------------------------------------------------------------
    CNewRtrWizAddressing::OnSavePage
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT CNewRtrWizAddressing::OnSavePage()
{
    m_pRtrWizData->m_fUseDHCP = IsDlgButtonChecked(IDC_NEWWIZ_BTN_YES);

    return hrOK;
}

/*---------------------------------------------------------------------------
    CNewRtrWizRasAddressing implementation
 ---------------------------------------------------------------------------*/
CNewRtrWizRasAddressing::CNewRtrWizRasAddressing() :
   CNewRtrWizAddressing(CNewRtrWizRasAddressing::IDD)
{
    InitWiz97(FALSE,
              IDS_NEWWIZ_RAS_A_ADDRESS_ASSIGNMENT_TITLE,
              IDS_NEWWIZ_RAS_A_ADDRESS_ASSIGNMENT_SUBTITLE);
}


/*---------------------------------------------------------------------------
    CNewRtrWizRasAddressingNoNICs implementation
 ---------------------------------------------------------------------------*/
CNewRtrWizRasAddressingNoNICs::CNewRtrWizRasAddressingNoNICs() :
   CNewRtrWizAddressing(CNewRtrWizRasAddressingNoNICs::IDD)
{
    InitWiz97(FALSE,
              IDS_NEWWIZ_RAS_A_ADDRESSING_NONICS_TITLE,
              IDS_NEWWIZ_RAS_A_ADDRESSING_NONICS_SUBTITLE);
}


/*---------------------------------------------------------------------------
    CNewRtrWizVpnAddressing implementation
 ---------------------------------------------------------------------------*/
CNewRtrWizVpnAddressing::CNewRtrWizVpnAddressing() :
   CNewRtrWizAddressing(CNewRtrWizVpnAddressing::IDD)
{
    InitWiz97(FALSE,
              IDS_NEWWIZ_VPN_A_ADDRESS_ASSIGNMENT_TITLE,
              IDS_NEWWIZ_VPN_A_ADDRESS_ASSIGNMENT_SUBTITLE);
}


/*---------------------------------------------------------------------------
    CNewRtrWizRouterAddressing implementation
 ---------------------------------------------------------------------------*/
CNewRtrWizRouterAddressing::CNewRtrWizRouterAddressing() :
   CNewRtrWizAddressing(CNewRtrWizRouterAddressing::IDD)
{
    InitWiz97(FALSE,
              IDS_NEWWIZ_ROUTER_ADDRESS_ASSIGNMENT_TITLE,
              IDS_NEWWIZ_ROUTER_ADDRESS_ASSIGNMENT_SUBTITLE);
}




/*---------------------------------------------------------------------------
    CNewRtrWizAddressPool implementation
 ---------------------------------------------------------------------------*/
CNewRtrWizAddressPool::CNewRtrWizAddressPool(UINT uDialogId) :
   CNewRtrWizPageBase(uDialogId, CNewRtrWizPageBase::Middle)
{
}


void CNewRtrWizAddressPool::DoDataExchange(CDataExchange *pDX)
{
    CNewRtrWizPageBase::DoDataExchange(pDX);

    DDX_Control(pDX, IDC_NEWWIZ_LIST, m_listCtrl);
}

BEGIN_MESSAGE_MAP(CNewRtrWizAddressPool, CNewRtrWizPageBase)
ON_BN_CLICKED(IDC_NEWWIZ_BTN_NEW, OnBtnNew)
ON_BN_CLICKED(IDC_NEWWIZ_BTN_EDIT, OnBtnEdit)
ON_BN_CLICKED(IDC_NEWWIZ_BTN_DELETE, OnBtnDelete)
ON_NOTIFY(NM_DBLCLK, IDC_NEWWIZ_LIST, OnListDblClk)
ON_NOTIFY(LVN_ITEMCHANGED, IDC_NEWWIZ_LIST, OnNotifyListItemChanged)
END_MESSAGE_MAP()




/*!--------------------------------------------------------------------------
    CNewRtrWizAddressPool::OnInitDialog
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
BOOL CNewRtrWizAddressPool::OnInitDialog()
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

    CNewRtrWizPageBase::OnInitDialog();

    InitializeAddressPoolListControl(&m_listCtrl,
                                     0,
                                     &(m_pRtrWizData->m_addressPoolList));

    MultiEnableWindow(GetSafeHwnd(),
                      FALSE,
                      IDC_NEWWIZ_BTN_EDIT,
                      IDC_NEWWIZ_BTN_DELETE,
                      0);

    Assert(m_pRtrWizData->m_addressPoolList.GetCount() == 0);
    return TRUE;
}

BOOL CNewRtrWizAddressPool::OnSetActive()
{
    CNewRtrWizPageBase::OnSetActive();

    if (m_listCtrl.GetItemCount() == 0)
        GetHolder()->SetWizardButtons(PSWIZB_BACK);
    else
        GetHolder()->SetWizardButtons(PSWIZB_BACK | PSWIZB_NEXT);

    return TRUE;
}

HRESULT CNewRtrWizAddressPool::OnSavePage()
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
    // No need to save the information, the list should be kept
    // up to date.

    if (m_pRtrWizData->m_addressPoolList.GetCount() == 0)
    {
        AfxMessageBox(IDS_ERR_ADDRESS_POOL_IS_EMPTY);
        return E_FAIL;
    }
    return hrOK;
}

void CNewRtrWizAddressPool::OnBtnNew()
{
    OnNewAddressPool(GetSafeHwnd(),
                     &m_listCtrl,
                     0,
                     &(m_pRtrWizData->m_addressPoolList));

    if (m_listCtrl.GetItemCount() > 0)
        GetHolder()->SetWizardButtons(PSWIZB_BACK | PSWIZB_NEXT);

    // Reset the focus
    if (m_listCtrl.GetNextItem(-1, LVIS_SELECTED) != -1)
    {
        MultiEnableWindow(GetSafeHwnd(),
                          TRUE,
                          IDC_NEWWIZ_BTN_EDIT,
                          IDC_NEWWIZ_BTN_DELETE,
                          0);
    }
}

void CNewRtrWizAddressPool::OnListDblClk(NMHDR *pNMHdr, LRESULT *pResult)
{
    OnBtnEdit();

    *pResult = 0;
}

void CNewRtrWizAddressPool::OnNotifyListItemChanged(NMHDR *pNmHdr, LRESULT *pResult)
{
    NMLISTVIEW *    pnmlv = reinterpret_cast<NMLISTVIEW *>(pNmHdr);
    BOOL            fEnable = !!(pnmlv->uNewState & LVIS_SELECTED);

    MultiEnableWindow(GetSafeHwnd(),
                      fEnable,
                      IDC_NEWWIZ_BTN_EDIT,
                      IDC_NEWWIZ_BTN_DELETE,
                      0);
    *pResult = 0;
}

void CNewRtrWizAddressPool::OnBtnEdit()
{
    INT     iPos;

    OnEditAddressPool(GetSafeHwnd(),
                      &m_listCtrl,
                      0,
                      &(m_pRtrWizData->m_addressPoolList));

    // reset the selection
    if ((iPos = m_listCtrl.GetNextItem(-1, LVNI_SELECTED)) != -1)
    {
        MultiEnableWindow(GetSafeHwnd(),
                          TRUE,
                          IDC_NEWWIZ_BTN_EDIT,
                          IDC_NEWWIZ_BTN_DELETE,
                          0);
    }

}

void CNewRtrWizAddressPool::OnBtnDelete()
{
    OnDeleteAddressPool(GetSafeHwnd(),
                        &m_listCtrl,
                        0,
                        &(m_pRtrWizData->m_addressPoolList));

    // There are no items, don't let them go forward
    if (m_listCtrl.GetItemCount() == 0)
        GetHolder()->SetWizardButtons(PSWIZB_BACK);
}

/*---------------------------------------------------------------------------
    CNewRtrWizRasAddressPool implementation
 ---------------------------------------------------------------------------*/
CNewRtrWizRasAddressPool::CNewRtrWizRasAddressPool() :
   CNewRtrWizAddressPool(CNewRtrWizRasAddressPool::IDD)
{
    InitWiz97(FALSE,
              IDS_NEWWIZ_RAS_A_ADDRESS_POOL_TITLE,
              IDS_NEWWIZ_RAS_A_ADDRESS_POOL_SUBTITLE);
}

/*---------------------------------------------------------------------------
    CNewRtrWizVpnAddressPool implementation
 ---------------------------------------------------------------------------*/
CNewRtrWizVpnAddressPool::CNewRtrWizVpnAddressPool() :
   CNewRtrWizAddressPool(CNewRtrWizVpnAddressPool::IDD)
{
    InitWiz97(FALSE,
              IDS_NEWWIZ_VPN_A_ADDRESS_POOL_TITLE,
              IDS_NEWWIZ_VPN_A_ADDRESS_POOL_SUBTITLE);
}

/*---------------------------------------------------------------------------
    CNewRtrWizRouterAddressPool implementation
 ---------------------------------------------------------------------------*/
CNewRtrWizRouterAddressPool::CNewRtrWizRouterAddressPool() :
   CNewRtrWizAddressPool(CNewRtrWizRouterAddressPool::IDD)
{
    InitWiz97(FALSE,
              IDS_NEWWIZ_ROUTER_ADDRESS_POOL_TITLE,
              IDS_NEWWIZ_ROUTER_ADDRESS_POOL_SUBTITLE);
}



/*---------------------------------------------------------------------------
    CNewRtrWizRadius implementation
 ---------------------------------------------------------------------------*/
CNewRtrWizRadius::CNewRtrWizRadius(UINT uDialogId) :
   CNewRtrWizPageBase(uDialogId, CNewRtrWizPageBase::Middle)
{
}


void CNewRtrWizRadius::DoDataExchange(CDataExchange *pDX)
{
    CNewRtrWizPageBase::DoDataExchange(pDX);
}

BEGIN_MESSAGE_MAP(CNewRtrWizRadius, CNewRtrWizPageBase)
END_MESSAGE_MAP()


/*!--------------------------------------------------------------------------
    CNewRtrWizRadius::OnInitDialog
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
BOOL CNewRtrWizRadius::OnInitDialog()
{
    CNewRtrWizPageBase::OnInitDialog();

    CheckRadioButton(IDC_NEWWIZ_BTN_YES, IDC_NEWWIZ_BTN_NO,
                     m_pRtrWizData->m_fUseRadius ? IDC_NEWWIZ_BTN_YES : IDC_NEWWIZ_BTN_NO);

    return TRUE;
}

/*!--------------------------------------------------------------------------
    CNewRtrWizRadius::OnSavePage
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT CNewRtrWizRadius::OnSavePage()
{
    m_pRtrWizData->m_fUseRadius = IsDlgButtonChecked(IDC_NEWWIZ_BTN_YES);

    return hrOK;
}

/*---------------------------------------------------------------------------
    CNewRtrWizRasRadius implementation
 ---------------------------------------------------------------------------*/
CNewRtrWizRasRadius::CNewRtrWizRasRadius() :
   CNewRtrWizRadius(CNewRtrWizRasRadius::IDD)
{
    InitWiz97(FALSE,
              IDS_NEWWIZ_RAS_A_USERADIUS_TITLE,
              IDS_NEWWIZ_RAS_A_USERADIUS_SUBTITLE);
}

/*---------------------------------------------------------------------------
    CNewRtrWizVpnRadius implementation
 ---------------------------------------------------------------------------*/
CNewRtrWizVpnRadius::CNewRtrWizVpnRadius() :
   CNewRtrWizRadius(CNewRtrWizVpnRadius::IDD)
{
    InitWiz97(FALSE,
              IDS_NEWWIZ_VPN_A_USERADIUS_TITLE,
              IDS_NEWWIZ_VPN_A_USERADIUS_SUBTITLE);
}



/*---------------------------------------------------------------------------
    CNewRtrWizRadiusConfig implementation
 ---------------------------------------------------------------------------*/
CNewRtrWizRadiusConfig::CNewRtrWizRadiusConfig(UINT uDialogId) :
   CNewRtrWizPageBase(uDialogId, CNewRtrWizPageBase::Middle)
{
}


void CNewRtrWizRadiusConfig::DoDataExchange(CDataExchange *pDX)
{
    CNewRtrWizPageBase::DoDataExchange(pDX);
}

BEGIN_MESSAGE_MAP(CNewRtrWizRadiusConfig, CNewRtrWizPageBase)
END_MESSAGE_MAP()


/*!--------------------------------------------------------------------------
    CNewRtrWizRadiusConfig::OnInitDialog
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
BOOL CNewRtrWizRadiusConfig::OnInitDialog()
{
    CNewRtrWizPageBase::OnInitDialog();

    return TRUE;
}

/*!--------------------------------------------------------------------------
    CNewRtrWizRadiusConfig::OnSavePage
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT CNewRtrWizRadiusConfig::OnSavePage()
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

    CString st;
    DWORD   netAddress;
    CWaitCursor wait;
    WSADATA             wsadata;
    DWORD               wsaerr = 0;
    HRESULT             hr = hrOK;
    BOOL                fWSInitialized = FALSE;

    // Check to see that we have non-blank names
    // ----------------------------------------------------------------
    GetDlgItemText(IDC_NEWWIZ_EDIT_PRIMARY, m_pRtrWizData->m_stRadius1);
    m_pRtrWizData->m_stRadius1.TrimLeft();
    m_pRtrWizData->m_stRadius1.TrimRight();

    GetDlgItemText(IDC_NEWWIZ_EDIT_SECONDARY, m_pRtrWizData->m_stRadius2);
    m_pRtrWizData->m_stRadius2.TrimLeft();
    m_pRtrWizData->m_stRadius2.TrimRight();

    if (m_pRtrWizData->m_stRadius1.IsEmpty() &&
        m_pRtrWizData->m_stRadius2.IsEmpty())
    {
        AfxMessageBox(IDS_ERR_NO_RADIUS_SERVERS_SPECIFIED);
        return E_FAIL;
    }


    // Start up winsock (for the ResolveName())
    // ----------------------------------------------------------------
    wsaerr = WSAStartup(0x0101, &wsadata);
    if (wsaerr)
        CORg( E_FAIL );
    fWSInitialized = TRUE;

    // Convert name into an IP address
    if (!m_pRtrWizData->m_stRadius1.IsEmpty())
    {
        m_pRtrWizData->m_netRadius1IpAddress = ResolveName(m_pRtrWizData->m_stRadius1);
        if (m_pRtrWizData->m_netRadius1IpAddress == INADDR_NONE)
        {
            CString st;
            st.Format(IDS_WRN_RTRWIZ_CANNOT_RESOLVE_RADIUS,
                      (LPCTSTR) m_pRtrWizData->m_stRadius1);
            if (AfxMessageBox(st, MB_OKCANCEL) == IDCANCEL)
            {
                GetDlgItem(IDC_NEWWIZ_EDIT_PRIMARY)->SetFocus();
                return E_FAIL;
            }
        }
    }


    // Convert name into an IP address
    if (!m_pRtrWizData->m_stRadius2.IsEmpty())
    {
        m_pRtrWizData->m_netRadius2IpAddress = ResolveName(m_pRtrWizData->m_stRadius2);
        if (m_pRtrWizData->m_netRadius2IpAddress == INADDR_NONE)
        {
            CString st;
            st.Format(IDS_WRN_RTRWIZ_CANNOT_RESOLVE_RADIUS,
                      (LPCTSTR) m_pRtrWizData->m_stRadius2);
            if (AfxMessageBox(st, MB_OKCANCEL) == IDCANCEL)
            {
                GetDlgItem(IDC_NEWWIZ_EDIT_SECONDARY)->SetFocus();
                return E_FAIL;
            }
        }
    }

    // Now get the password and encode it
    // ----------------------------------------------------------------
    GetDlgItemText(IDC_NEWWIZ_EDIT_SECRET, m_pRtrWizData->m_stRadiusSecret);

    // Pick a seed value
    m_pRtrWizData->m_uSeed = 0x9a;
    RtlEncodeW(&m_pRtrWizData->m_uSeed,
               m_pRtrWizData->m_stRadiusSecret.GetBuffer(0));
    m_pRtrWizData->m_stRadiusSecret.ReleaseBuffer(-1);

Error:
    if (fWSInitialized)
        WSACleanup();

    return hr;
}

DWORD CNewRtrWizRadiusConfig::ResolveName(LPCTSTR pszServerName)
{
    CHAR    szName[MAX_PATH+1];
    DWORD   netAddress = INADDR_NONE;

    StrnCpyAFromT(szName, pszServerName, MAX_PATH);
    netAddress = inet_addr(szName);
    if (netAddress == INADDR_NONE)
    {
        // resolve name
        struct hostent *    phe = gethostbyname(szName);
        if (phe != NULL)
        {
            if (phe->h_addr_list[0] != NULL)
                netAddress = *((PDWORD) phe->h_addr_list[0]);
        }
        else
        {
            Assert(::WSAGetLastError() != WSANOTINITIALISED);
        }
    }
    return netAddress;
}



/*---------------------------------------------------------------------------
    CNewRtrWizRasRadiusConfig implementation
 ---------------------------------------------------------------------------*/
CNewRtrWizRasRadiusConfig::CNewRtrWizRasRadiusConfig() :
   CNewRtrWizRadiusConfig(CNewRtrWizRasRadiusConfig::IDD)
{
    InitWiz97(FALSE,
              IDS_NEWWIZ_RAS_A_RADIUS_CONFIG_TITLE,
              IDS_NEWWIZ_RAS_A_RADIUS_CONFIG_SUBTITLE);
}

/*---------------------------------------------------------------------------
    CNewRtrWizVpnRadiusConfig implementation
 ---------------------------------------------------------------------------*/
CNewRtrWizVpnRadiusConfig::CNewRtrWizVpnRadiusConfig() :
   CNewRtrWizRadiusConfig(CNewRtrWizVpnRadiusConfig::IDD)
{
    InitWiz97(FALSE,
              IDS_NEWWIZ_VPN_A_RADIUS_CONFIG_TITLE,
              IDS_NEWWIZ_VPN_A_RADIUS_CONFIG_SUBTITLE);
}



/*---------------------------------------------------------------------------
    CNewRtrWizRasFinishAdvanced Implementation
 ---------------------------------------------------------------------------*/
IMPLEMENT_NEWRTRWIZ_FINISH_PAGE(CNewRtrWizRasFinishAdvanced,
                                SaveFlag_Advanced,
                                HelpFlag_GeneralRAS);


/*---------------------------------------------------------------------------
    CNewRtrWizVpnFinishNoNICs Implementation
 ---------------------------------------------------------------------------*/
IMPLEMENT_NEWRTRWIZ_FINISH_PAGE(CNewRtrWizVpnFinishNoNICs,
                                SaveFlag_DoNothing,
                                HelpFlag_Nothing);


/*---------------------------------------------------------------------------
    CNewRtrWizVpnFinishNoIP Implementation
 ---------------------------------------------------------------------------*/
IMPLEMENT_NEWRTRWIZ_FINISH_PAGE(CNewRtrWizVpnFinishNoIP,
                                SaveFlag_DoNothing,
                                HelpFlag_AddIp);


/*---------------------------------------------------------------------------
    CNewRtrWizVpnFinishNoIPNonLocal Implementation
 ---------------------------------------------------------------------------*/
IMPLEMENT_NEWRTRWIZ_FINISH_PAGE(CNewRtrWizVpnFinishNoIPNonLocal,
                                SaveFlag_DoNothing,
                                HelpFlag_Nothing);


/*---------------------------------------------------------------------------
    CNewRtrWizVpnFinishAdvanced Implementation
 ---------------------------------------------------------------------------*/
IMPLEMENT_NEWRTRWIZ_FINISH_PAGE(CNewRtrWizVpnFinishAdvanced,
                                SaveFlag_Advanced,
                                HelpFlag_Nothing);


/*---------------------------------------------------------------------------
    CNewRtrWizVpnSelectPublic implementation
 ---------------------------------------------------------------------------*/
CNewRtrWizVpnSelectPublic::CNewRtrWizVpnSelectPublic() :
   CNewRtrWizPageBase(CNewRtrWizVpnSelectPublic::IDD, CNewRtrWizPageBase::Middle)
{
    InitWiz97(FALSE,
              IDS_NEWWIZ_VPN_A_SELECT_PUBLIC_TITLE,
              IDS_NEWWIZ_VPN_A_SELECT_PUBLIC_SUBTITLE);
}


void CNewRtrWizVpnSelectPublic::DoDataExchange(CDataExchange *pDX)
{
    CNewRtrWizPageBase::DoDataExchange(pDX);

    DDX_Control(pDX, IDC_NEWWIZ_LIST, m_listCtrl);
}

BEGIN_MESSAGE_MAP(CNewRtrWizVpnSelectPublic, CNewRtrWizPageBase)
//{{AFX_MSG_MAP(CNewRtrWizVpnSelectPublic)
ON_BN_CLICKED(IDC_NEWWIZ_VPN_BTN_YES, OnButtonClick)
ON_BN_CLICKED(IDC_NEWWIZ_VPN_BTN_NO, OnButtonClick)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()


/*!--------------------------------------------------------------------------
    CNewRtrWizVpnSelectPublic::OnInitDialog
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
BOOL CNewRtrWizVpnSelectPublic::OnInitDialog()
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

    DWORD   dwNICs;
    CString st;

    CNewRtrWizPageBase::OnInitDialog();

    // Setup the dialog and add the NICs
    m_pRtrWizData->m_fSetVPNFilter = TRUE;
    m_pRtrWizData->GetNumberOfNICS_IP(&dwNICs);

    InitializeInterfaceListControl(NULL,
                                   &m_listCtrl,
                                   NULL,
                                   0,
                                   m_pRtrWizData);
    RefreshInterfaceListControl(NULL,
                                &m_listCtrl,
                                NULL,
                                0,
                                m_pRtrWizData);


    if (dwNICs == 0)
    {
        //
        // There are no NICS, you cannot set an interface
        // pointing to the Internet, and hence no filters
        // on it.
        //

        m_pRtrWizData->m_fSetVPNFilter = FALSE;

        GetDlgItem(IDC_NEWWIZ_VPN_BTN_YES)->EnableWindow(FALSE);
        GetDlgItem(IDC_VPN_YES_TEXT)->EnableWindow(FALSE);
    }

    
#if 0
    // Windows NT Bug : 389587 - for the VPN case, we have to allow
    // for the case where they want only a single VPN connection (private
    // and no public connection).
    // Thus I add a <<None>> option to the list of interfaces.
    // ----------------------------------------------------------------
    st.LoadString(IDS_NO_PUBLIC_INTERFACE);
    {
        LV_ITEM     lvItem;
        int         iPos;

        lvItem.mask = LVIF_TEXT | LVIF_PARAM;
        lvItem.stateMask = LVIS_FOCUSED | LVIS_SELECTED;
        lvItem.state = 0;

        lvItem.iItem = 0;
        lvItem.iSubItem = 0;
        lvItem.pszText = (LPTSTR)(LPCTSTR) st;
        lvItem.lParam = NULL; //same functionality as SetItemData()

        iPos = m_listCtrl.InsertItem(&lvItem);

        if (iPos != -1)
        {
            m_listCtrl.SetItemText(iPos, IFLISTCOL_NAME,
                                   (LPCTSTR) st);
            m_listCtrl.SetItemData(iPos, NULL);
        }
    }

    m_listCtrl.SetItemState(0, LVIS_SELECTED, LVIS_SELECTED );
#endif

    CheckRadioButton(
        IDC_NEWWIZ_VPN_BTN_YES,
        IDC_NEWWIZ_VPN_BTN_NO,
        m_pRtrWizData-> m_fSetVPNFilter ?
            IDC_NEWWIZ_VPN_BTN_YES : IDC_NEWWIZ_VPN_BTN_NO
        );

    //
    // If this is NOT a VPN only server, disable the list of 
    // interfaces to set filters on
    //

    GetDlgItem(IDC_NEWWIZ_LIST)->EnableWindow(
        m_pRtrWizData-> m_fSetVPNFilter
        );

    return TRUE;
}

void CNewRtrWizVpnSelectPublic::OnButtonClick()
{
    m_pRtrWizData->m_fSetVPNFilter = 
        IsDlgButtonChecked(IDC_NEWWIZ_VPN_BTN_YES);

    GetDlgItem(IDC_NEWWIZ_LIST)->EnableWindow(
        m_pRtrWizData-> m_fSetVPNFilter
        );
}


HRESULT CNewRtrWizVpnSelectPublic::OnSavePage()
{
    INT     iSel;


    if (m_pRtrWizData->m_fSetVPNFilter)
    {
        DWORD   dwNics = 0;
        
        // Check to see that we actually selected an item
        iSel = m_listCtrl.GetNextItem(-1, LVNI_SELECTED);
        if (iSel == -1)
        {
            // We did not select an item
            AfxMessageBox(IDS_PROMPT_PLEASE_SELECT_INTERFACE);
            return E_FAIL;
        }
        m_pRtrWizData->m_fCreateDD = FALSE;

        m_pRtrWizData->m_stPublicInterfaceId = (LPCTSTR) m_listCtrl.GetItemData(iSel);

        // If the user has selected the non-blank interface, then
        // we need to check that there is at least one non-private
        // interface.
        // ------------------------------------------------------------

        m_pRtrWizData->GetNumberOfNICS_IP(&dwNics);

        if (dwNics <= 1)
        {
            // oops, there aren't any NICs left over for the private
            // interface.
            AfxMessageBox(IDS_ERR_VPN_NO_NICS_LEFT_FOR_PRIVATE_IF);
            return E_FAIL;
        }
    }

    else
    {
        m_pRtrWizData->m_stPublicInterfaceId.Empty();
    }

    return hrOK;
}


/*---------------------------------------------------------------------------
    CNewRtrWizVpnSelectPrivate
 ---------------------------------------------------------------------------*/
CNewRtrWizVpnSelectPrivate::CNewRtrWizVpnSelectPrivate() :
   CNewRtrWizPageBase(CNewRtrWizVpnSelectPrivate::IDD, CNewRtrWizPageBase::Middle)
{
    InitWiz97(FALSE,
              IDS_NEWWIZ_VPN_A_SELECT_PRIVATE_TITLE,
              IDS_NEWWIZ_VPN_A_SELECT_PRIVATE_SUBTITLE);
}


void CNewRtrWizVpnSelectPrivate::DoDataExchange(CDataExchange *pDX)
{
    CNewRtrWizPageBase::DoDataExchange(pDX);

    DDX_Control(pDX, IDC_NEWWIZ_LIST, m_listCtrl);

}

BEGIN_MESSAGE_MAP(CNewRtrWizVpnSelectPrivate, CNewRtrWizPageBase)
END_MESSAGE_MAP()


/*!--------------------------------------------------------------------------
    CNewRtrWizVpnSelectPrivate::OnInitDialog
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
BOOL CNewRtrWizVpnSelectPrivate::OnInitDialog()
{
    DWORD   dwNICs;

    CNewRtrWizPageBase::OnInitDialog();

    m_pRtrWizData->GetNumberOfNICS_IP(&dwNICs);

    InitializeInterfaceListControl(NULL,
                                   &m_listCtrl,
                                   NULL,
                                   0,
                                   m_pRtrWizData);
    return TRUE;
}

/*!--------------------------------------------------------------------------
    CNewRtrWizVpnSelectPrivate::OnSetActive
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
BOOL CNewRtrWizVpnSelectPrivate::OnSetActive()
{
    DWORD   dwNICs;
    int     iSel = 0;

    CNewRtrWizPageBase::OnSetActive();

    m_pRtrWizData->GetNumberOfNICS_IP(&dwNICs);

    RefreshInterfaceListControl(NULL,
                                &m_listCtrl,
                                (LPCTSTR) m_pRtrWizData->m_stPublicInterfaceId,
                                0,
                                m_pRtrWizData);

    if (!m_pRtrWizData->m_stPrivateInterfaceId.IsEmpty())
    {
        // Try to reselect the previously selected NIC
        LV_FINDINFO lvfi;

        lvfi.flags = LVFI_PARTIAL | LVFI_STRING;
        lvfi.psz = (LPCTSTR) m_pRtrWizData->m_stPrivateInterfaceId;
        iSel = m_listCtrl.FindItem(&lvfi, -1);
        if (iSel == -1)
            iSel = 0;
    }

    m_listCtrl.SetItemState(iSel, LVIS_SELECTED, LVIS_SELECTED );

    return TRUE;
}

/*!--------------------------------------------------------------------------
    CNewRtrWizVpnSelectPrivate::OnSavePage
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT CNewRtrWizVpnSelectPrivate::OnSavePage()
{
    INT     iSel;

    // Check to see that we actually selected an item
    iSel = m_listCtrl.GetNextItem(-1, LVNI_SELECTED);
    if (iSel == LB_ERR)
    {
        // We did not select an item
        AfxMessageBox(IDS_PROMPT_PLEASE_SELECT_INTERFACE);
        return E_FAIL;
    }

    m_pRtrWizData->m_stPrivateInterfaceId = (LPCTSTR) m_listCtrl.GetItemData(iSel);

    return hrOK;
}

/*---------------------------------------------------------------------------
    CNewRtrWizRouterUseDD implementation
 ---------------------------------------------------------------------------*/
CNewRtrWizRouterUseDD::CNewRtrWizRouterUseDD() :
   CNewRtrWizPageBase(CNewRtrWizRouterUseDD::IDD, CNewRtrWizPageBase::Middle)
{
    InitWiz97(FALSE,
              IDS_NEWWIZ_ROUTER_USEDD_TITLE,
              IDS_NEWWIZ_ROUTER_USEDD_SUBTITLE);
}


void CNewRtrWizRouterUseDD::DoDataExchange(CDataExchange *pDX)
{
    CNewRtrWizPageBase::DoDataExchange(pDX);
}

BEGIN_MESSAGE_MAP(CNewRtrWizRouterUseDD, CNewRtrWizPageBase)
END_MESSAGE_MAP()


/*!--------------------------------------------------------------------------
    CNewRtrWizRouterUseDD::OnInitDialog
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
BOOL CNewRtrWizRouterUseDD::OnInitDialog()
{

    CNewRtrWizPageBase::OnInitDialog();

    CheckRadioButton(IDC_NEWWIZ_BTN_YES, IDC_NEWWIZ_BTN_NO,
                     m_pRtrWizData->m_fUseDD ? IDC_NEWWIZ_BTN_YES : IDC_NEWWIZ_BTN_NO);

    // The default is to create a new connection
    // That is, to leave the button unchecked.
    return TRUE;
}

HRESULT CNewRtrWizRouterUseDD::OnSavePage()
{
    m_pRtrWizData->m_fUseDD = IsDlgButtonChecked(IDC_NEWWIZ_BTN_YES);
    return hrOK;
}



/*---------------------------------------------------------------------------
    CNewRtrWizRouterFinish Implementation
 ---------------------------------------------------------------------------*/
IMPLEMENT_NEWRTRWIZ_FINISH_PAGE(CNewRtrWizRouterFinish,
                                SaveFlag_Advanced,
                                HelpFlag_Nothing);


/*---------------------------------------------------------------------------
    CNewRtrWizRouterFinishDD Implementation
 ---------------------------------------------------------------------------*/
IMPLEMENT_NEWRTRWIZ_FINISH_PAGE(CNewRtrWizRouterFinishDD,
                                SaveFlag_Advanced,
                                HelpFlag_Nothing);


/*---------------------------------------------------------------------------
    CNewRtrWizManualFinish Implementation
 ---------------------------------------------------------------------------*/
IMPLEMENT_NEWRTRWIZ_FINISH_PAGE(CNewRtrWizManualFinish,
                                SaveFlag_Advanced,
                                HelpFlag_Nothing);



/*!--------------------------------------------------------------------------
    InitializeInterfaceListControl
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT InitializeInterfaceListControl(IRouterInfo *pRouter,
                                       CListCtrl *pListCtrl,
                                       LPCTSTR pszExcludedIf,
                                       LPARAM flags,
                                       NewRtrWizData *pWizData)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
    HRESULT     hr = hrOK;
    LV_COLUMN   lvCol;  // list view column struct for radius servers
    RECT        rect;
    CString     stColCaption;
    LV_ITEM     lvItem;
    int         iPos;
    CString     st;
    int         nColWidth;

    Assert(pListCtrl);

    ListView_SetExtendedListViewStyle(pListCtrl->GetSafeHwnd(),
                                      LVS_EX_FULLROWSELECT);

    // Add the columns to the list control
      pListCtrl->GetClientRect(&rect);

    if (!FHrOK(pWizData->HrIsIPInstalled()))
        flags |= IFLIST_FLAGS_NOIP;

    // Determine the width of the columns (we assume three equal width columns)

    if (flags & IFLIST_FLAGS_NOIP)
        nColWidth = rect.right / (IFLISTCOL_COUNT - 1 );
    else
        nColWidth = rect.right / IFLISTCOL_COUNT;

    lvCol.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT;
    lvCol.fmt = LVCFMT_LEFT;
    lvCol.cx = nColWidth;

    for(int index = 0; index < IFLISTCOL_COUNT; index++)
    {
        // If IP is not installed, do not add the column
        if ((index == IFLISTCOL_IPADDRESS) &&
            (flags & IFLIST_FLAGS_NOIP))
            continue;

        stColCaption.LoadString( s_rgIfListColumnHeaders[index] );
        lvCol.pszText = (LPTSTR)((LPCTSTR) stColCaption);
        pListCtrl->InsertColumn(index, &lvCol);
    }
    return hr;
}


/*!--------------------------------------------------------------------------
    RefreshInterfaceListControl
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT RefreshInterfaceListControl(IRouterInfo *pRouter,
                                    CListCtrl *pListCtrl,
                                    LPCTSTR pszExcludedIf,
                                    LPARAM flags,
                                    NewRtrWizData *pWizData)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
    HRESULT     hr = hrOK;
    LV_COLUMN   lvCol;  // list view column struct for radius servers
    LV_ITEM     lvItem;
    int         iPos;
    CString     st;
    POSITION    pos;
    RtrWizInterface *   pRtrWizIf;

    Assert(pListCtrl);

    // If a pointer to a blank string was passed in, set the
    // pointer to NULL.
    if (pszExcludedIf && (*pszExcludedIf == 0))
        pszExcludedIf = NULL;

    // Clear the list control
    pListCtrl->DeleteAllItems();

    // This means that we should use the test data, rather
    // than the actual machine data
    {
        lvItem.mask = LVIF_TEXT | LVIF_PARAM;
        lvItem.stateMask = LVIS_FOCUSED | LVIS_SELECTED;
        lvItem.state = 0;

        int nCount = 0;

        pos = pWizData->m_ifMap.GetStartPosition();

        while (pos)
        {
            pWizData->m_ifMap.GetNextAssoc(pos, st, pRtrWizIf);

            if (pszExcludedIf &&
                (pRtrWizIf->m_stId.CompareNoCase(pszExcludedIf) == 0))
                continue;

            lvItem.iItem = nCount;
            lvItem.iSubItem = 0;
            lvItem.pszText = (LPTSTR)(LPCTSTR) pRtrWizIf->m_stName;
            lvItem.lParam = NULL; //same functionality as SetItemData()

            iPos = pListCtrl->InsertItem(&lvItem);

            if (iPos != -1)
            {
                pListCtrl->SetItemText(iPos, IFLISTCOL_NAME,
                                       (LPCTSTR) pRtrWizIf->m_stName);
                pListCtrl->SetItemText(iPos, IFLISTCOL_DESC,
                                       (LPCTSTR) pRtrWizIf->m_stDesc);

                if (FHrOK(pWizData->HrIsIPInstalled()))
                {
                    CString stAddr;

                    stAddr = pRtrWizIf->m_stIpAddress;

                    if (pRtrWizIf->m_fDhcpObtained)
                        stAddr += _T(" (DHCP)");

                    pListCtrl->SetItemText(iPos, IFLISTCOL_IPADDRESS,
                                           (LPCTSTR) stAddr);
                }

                pListCtrl->SetItemData(iPos,
                                       (LPARAM) (LPCTSTR) pRtrWizIf->m_stId);
            }

            nCount++;
        }
    }


    return hr;
}



/*!--------------------------------------------------------------------------
    CallRouterEntryDlg
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT CallRouterEntryDlg(HWND hWnd, NewRtrWizData *pWizData, LPARAM flags)
{
    HRESULT hr = hrOK;
    HINSTANCE   hInstanceRasDlg = NULL;
    PROUTERENTRYDLG pfnRouterEntry = NULL;
    CString     stRouter, stPhoneBook;
    BOOL    bStatus;
    RASENTRYDLG info;
    SPSZ        spsz;
    SPIInterfaceInfo    spIf;
    SPIInfoBase spInfoBase;
    LPCTSTR     pszServerName = pWizData->m_stServerName;

    // Get the library (we are dynamically linking to the function).
    // ----------------------------------------------------------------
    hInstanceRasDlg = AfxLoadLibrary(_T("rasdlg.dll"));
    if (hInstanceRasDlg == NULL)
        CORg( E_FAIL );

    pfnRouterEntry = (PROUTERENTRYDLG) ::GetProcAddress(hInstanceRasDlg,
        SZROUTERENTRYDLG);
    if (pfnRouterEntry == NULL)
        CORg( E_FAIL );

    // First create the phone book entry.
    ZeroMemory( &info, sizeof(info) );
    info.dwSize = sizeof(info);
    info.hwndOwner = hWnd;
    info.dwFlags |= RASEDFLAG_NewEntry;

    stRouter = pszServerName;
    IfAdminNodeHandler::GetPhoneBookPath(stRouter, &stPhoneBook);

    if (stRouter.GetLength() == 0)
    {
        stRouter = CString(_T("\\\\")) + GetLocalMachineName();
    }

    bStatus = pfnRouterEntry((LPTSTR)(LPCTSTR)stRouter,
                             (LPTSTR)(LPCTSTR)stPhoneBook,
                             NULL,
                             &info);
    Trace2("RouterEntryDlg=%f,e=%d\n", bStatus, info.dwError);

    if (!bStatus)
    {
        if (info.dwError != NO_ERROR)
        {
            AddHighLevelErrorStringId(IDS_ERR_UNABLETOCONFIGPBK);
            CWRg( info.dwError );
        }

        //$ ASSUMPTION
        // If the dwError field has not been filled, we assume that
        // the user cancelled out of the wizard.
        CWRg( ERROR_CANCELLED );
    }


    // Ok, at this point we have an interface
    // We need to add the IP/IPX routermangers to the interface

    // Create a dummy InterfaceInfo
    CORg( CreateInterfaceInfo(&spIf,
                              info.szEntry,
                              ROUTER_IF_TYPE_FULL_ROUTER) );

    // This call to get the name doesn't matter (for now).  The
    // reason is that DD interfaces do not return GUIDs, but this
    // will work when they do return a GUID.
    // ----------------------------------------------------------------
    hr = InterfaceInfo::FindInterfaceTitle(pszServerName,
                                           info.szEntry,
                                           &spsz);
    if (!FHrOK(hr))
    {
        spsz.Free();
        spsz = StrDup(info.szEntry);
    }

    CORg( spIf->SetTitle(spsz) );
    CORg( spIf->SetMachineName(pszServerName) );

    // Load an infobase for use by the routines
    CORg( CreateInfoBase(&spInfoBase) );

    if (info.reserved2 & RASNP_Ip)
    {
        AddIpPerInterfaceBlocks(spIf, spInfoBase);

        // Save this back to the IP RmIf
        RouterEntrySaveInfoBase(pszServerName,
                                spIf->GetId(),
                                spInfoBase,
                                PID_IP);
    }

    if (info.reserved2 & RASNP_Ipx)
    {
        // Remove anything that was loaded previously
        spInfoBase->Unload();

        AddIpxPerInterfaceBlocks(spIf, spInfoBase);

        // Save this back to the IPX RmIf
        RouterEntrySaveInfoBase(pszServerName,
                                spIf->GetId(),
                                spInfoBase,
                                PID_IPX);
    }

    // ok, setup the public interface
    Assert(pWizData->m_stPublicInterfaceId.IsEmpty());
    pWizData->m_stPublicInterfaceId = spIf->GetTitle();


Error:

    if (!FHrSucceeded(hr) && (hr != HRESULT_FROM_WIN32(ERROR_CANCELLED)))
    {
        TCHAR    szErr[2048] = _T(" ");

        if (hr != E_FAIL)    // E_FAIL doesn't give user any information
        {
            FormatRasError(hr, szErr, DimensionOf(szErr));
        }
        AddLowLevelErrorString(szErr);

        // If there is no high level error string, add a
        // generic error string.  This will be used if no other
        // high level error string is set.
        SetDefaultHighLevelErrorStringId(IDS_ERR_GENERIC_ERROR);

        DisplayTFSErrorMessage(NULL);
    }

    if (hInstanceRasDlg)
        ::FreeLibrary(hInstanceRasDlg);
    return hr;
}


/*!--------------------------------------------------------------------------
    RouterEntrySaveInfoBase
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT RouterEntrySaveInfoBase(LPCTSTR pszServerName,
                                LPCTSTR pszIfName,
                                IInfoBase *pInfoBase,
                                DWORD dwTransportId)
{
    HRESULT hr = hrOK;
    MPR_SERVER_HANDLE   hMprServer = NULL;
    HANDLE              hInterface = NULL;
    DWORD               dwErr = ERROR_SUCCESS;
    MPR_INTERFACE_0     mprInterface;
    LPBYTE              pInfoData = NULL;
    DWORD               dwInfoSize = 0;
    MPR_CONFIG_HANDLE   hMprConfig = NULL;
    HANDLE              hIfTransport = NULL;

    Assert(pInfoBase);

    // Convert the infobase into a byte array
    // ----------------------------------------------------------------
    CWRg( pInfoBase->WriteTo(&pInfoData, &dwInfoSize) );


    // Connect to the server
    // ----------------------------------------------------------------
    dwErr = MprAdminServerConnect((LPWSTR) pszServerName, &hMprServer);

    if (dwErr == ERROR_SUCCESS)
    {
        // Get a handle to the interface
        // ------------------------------------------------------------
        dwErr = MprAdminInterfaceGetHandle(hMprServer,
                                           (LPWSTR) pszIfName,
                                           &hInterface,
                                           FALSE);
        if (dwErr != ERROR_SUCCESS)
        {
            // We couldn't get a handle the interface, so let's try
            // to create the interface.
            // --------------------------------------------------------
            ZeroMemory(&mprInterface, sizeof(mprInterface));

            StrCpyWFromT(mprInterface.wszInterfaceName, pszIfName);
            mprInterface.dwIfType = ROUTER_IF_TYPE_FULL_ROUTER;
            mprInterface.fEnabled = TRUE;

            CWRg( MprAdminInterfaceCreate(hMprServer,
                                          0,
                                          (LPBYTE) &mprInterface,
                                          &hInterface) );

        }

        // Try to write the info out
        // ------------------------------------------------------------
        dwErr = MprAdminInterfaceTransportSetInfo(hMprServer,
            hInterface,
            dwTransportId,
            pInfoData,
            dwInfoSize);
        if (dwErr != NO_ERROR && dwErr != RPC_S_SERVER_UNAVAILABLE)
        {
            // Attempt to add the router-manager on the interface
            // --------------------------------------------------------
            dwErr = ::MprAdminInterfaceTransportAdd(hMprServer,
                hInterface,
                dwTransportId,
                pInfoData,
                dwInfoSize);
            CWRg( dwErr );
        }
    }

    // Ok, now that we've written the info out to the running router,
    // let's try to write the info to the store.
    // ----------------------------------------------------------------
    dwErr = MprConfigServerConnect((LPWSTR) pszServerName, &hMprConfig);
    if (dwErr == ERROR_SUCCESS)
    {
        dwErr = MprConfigInterfaceGetHandle(hMprConfig,
                                            (LPWSTR) pszIfName,
                                            &hInterface);
        if (dwErr != ERROR_SUCCESS)
        {
            // We couldn't get a handle the interface, so let's try
            // to create the interface.
            // --------------------------------------------------------
            ZeroMemory(&mprInterface, sizeof(mprInterface));

            StrCpyWFromT(mprInterface.wszInterfaceName, pszIfName);
            mprInterface.dwIfType = ROUTER_IF_TYPE_FULL_ROUTER;
            mprInterface.fEnabled = TRUE;

            CWRg( MprConfigInterfaceCreate(hMprConfig,
                                           0,
                                           (LPBYTE) &mprInterface,
                                           &hInterface) );
        }

        dwErr = MprConfigInterfaceTransportGetHandle(hMprConfig,
            hInterface,
            dwTransportId,
            &hIfTransport);
        if (dwErr != ERROR_SUCCESS)
        {
            CWRg( MprConfigInterfaceTransportAdd(hMprConfig,
                hInterface,
                dwTransportId,
                NULL,
                pInfoData,
                dwInfoSize,
                &hIfTransport) );
        }
        else
        {
            CWRg( MprConfigInterfaceTransportSetInfo(hMprConfig,
                hInterface,
                hIfTransport,
                pInfoData,
                dwInfoSize) );
        }
    }

Error:
    if (hMprConfig)
        MprConfigServerDisconnect(hMprConfig);

    if (hMprServer)
        MprAdminServerDisconnect(hMprServer);

    if (pInfoData)
        CoTaskMemFree(pInfoData);

    return hr;
}


/*!--------------------------------------------------------------------------
    RouterEntryLoadInfoBase
        This will load the RtrMgrInterfaceInfo infobase.
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT RouterEntryLoadInfoBase(LPCTSTR pszServerName,
                                LPCTSTR pszIfName,
                                DWORD dwTransportId,
                                IInfoBase *pInfoBase)
{
    HRESULT hr = hrOK;
    MPR_SERVER_HANDLE   hMprServer = NULL;
    HANDLE              hInterface = NULL;
    DWORD               dwErr = ERROR_SUCCESS;
    MPR_INTERFACE_0     mprInterface;
    LPBYTE              pByte = NULL;
    DWORD               dwSize = 0;
    MPR_CONFIG_HANDLE   hMprConfig = NULL;
    HANDLE              hIfTransport = NULL;

    Assert(pInfoBase);

    // Connect to the server
    // ----------------------------------------------------------------
    dwErr = MprAdminServerConnect((LPWSTR) pszServerName, &hMprServer);
    if (dwErr == ERROR_SUCCESS)
    {
        // Get a handle to the interface
        // ------------------------------------------------------------
        dwErr = MprAdminInterfaceGetHandle(hMprServer,
                                           (LPWSTR) pszIfName,
                                           &hInterface,
                                           FALSE);
        if (dwErr != ERROR_SUCCESS)
        {
            // We couldn't get a handle the interface, so let's try
            // to create the interface.
            // --------------------------------------------------------
            ZeroMemory(&mprInterface, sizeof(mprInterface));

            StrCpyWFromT(mprInterface.wszInterfaceName, pszIfName);
            mprInterface.dwIfType = ROUTER_IF_TYPE_FULL_ROUTER;
            mprInterface.fEnabled = TRUE;

            CWRg( MprAdminInterfaceCreate(hMprServer,
                                          0,
                                          (LPBYTE) &mprInterface,
                                          &hInterface) );

        }

        // Try to read the info
        // ------------------------------------------------------------
        dwErr = MprAdminInterfaceTransportGetInfo(hMprServer,
            hInterface,
            dwTransportId,
            &pByte,
            &dwSize);

        if (dwErr == ERROR_SUCCESS)
            pInfoBase->LoadFrom(dwSize, pByte);

        if (pByte)
            MprAdminBufferFree(pByte);
        pByte = NULL;
        dwSize = 0;
    }

    if (dwErr != ERROR_SUCCESS)
    {
        // Ok, we've tried to use the running router but that
        // failed, let's try to read the info from the store.
        // ----------------------------------------------------------------
        dwErr = MprConfigServerConnect((LPWSTR) pszServerName, &hMprConfig);
        if (dwErr == ERROR_SUCCESS)
        {

            dwErr = MprConfigInterfaceGetHandle(hMprConfig,
                                                (LPWSTR) pszIfName,
                                                &hInterface);
            if (dwErr != ERROR_SUCCESS)
            {
                // We couldn't get a handle the interface, so let's try
                // to create the interface.
                // --------------------------------------------------------
                ZeroMemory(&mprInterface, sizeof(mprInterface));

                StrCpyWFromT(mprInterface.wszInterfaceName, pszIfName);
                mprInterface.dwIfType = ROUTER_IF_TYPE_FULL_ROUTER;
                mprInterface.fEnabled = TRUE;

                CWRg( MprConfigInterfaceCreate(hMprConfig,
                                               0,
                                               (LPBYTE) &mprInterface,
                                               &hInterface) );
            }

            CWRg( MprConfigInterfaceTransportGetHandle(hMprConfig,
                hInterface,
                dwTransportId,
                &hIfTransport) );

            CWRg( MprConfigInterfaceTransportGetInfo(hMprConfig,
                hInterface,
                hIfTransport,
                &pByte,
                &dwSize) );

            pInfoBase->LoadFrom(dwSize, pByte);

            if (pByte)
                MprConfigBufferFree(pByte);
            pByte = NULL;
            dwSize = 0;
        }
    }

    CWRg(dwErr);

Error:
    if (hMprConfig)
        MprConfigServerDisconnect(hMprConfig);

    if (hMprServer)
        MprAdminServerDisconnect(hMprServer);

    return hr;
}



/*!--------------------------------------------------------------------------
    LaunchHelpTopic
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
void LaunchHelpTopic(LPCTSTR pszHelpString)
{
    TCHAR               szBuffer[1024];
    CString             st;
    STARTUPINFO            si;
    PROCESS_INFORMATION    pi;

    if ((pszHelpString == NULL) || (*pszHelpString == 0))
        return;

    ::ZeroMemory(&si, sizeof(STARTUPINFO));
    si.cb = sizeof(STARTUPINFO);
    si.dwX = si.dwY = si.dwXSize = si.dwYSize = 0L;
    si.wShowWindow = SW_SHOW;
    ::ZeroMemory(&pi, sizeof(PROCESS_INFORMATION));

    ExpandEnvironmentStrings(pszHelpString,
                             szBuffer,
                             DimensionOf(szBuffer));

    st.Format(_T("hh.exe %s"), pszHelpString);

    ::CreateProcess(NULL,          // ptr to name of executable
                    (LPTSTR) (LPCTSTR) st,   // pointer to command line string
                    NULL,            // process security attributes
                    NULL,            // thread security attributes
                    FALSE,            // handle inheritance flag
                    CREATE_NEW_CONSOLE,// creation flags
                    NULL,            // ptr to new environment block
                    NULL,            // ptr to current directory name
                    &si,
                    &pi);
    ::CloseHandle(pi.hProcess);
    ::CloseHandle(pi.hThread);
}

#define REGKEY_NETBT_PARAM_W        L"System\\CurrentControlSet\\Services\\NetBT\\Parameters\\Interfaces\\Tcpip_%s"
#define REGVAL_DISABLE_NETBT        2
#define TCPIP_PARAMETERS_KEY        L"System\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Interfaces\\%s"
#define REGISTRATION_ENABLED        L"RegistrationEnabled"
#define REGVAL_NETBIOSOPTIONS_W     L"NetbiosOptions"

HRESULT DisableDDNSandNetBtOnInterface ( IRouterInfo *pRouter, LPCTSTR pszIfName, RtrWizInterface*    pIf)
{
	HRESULT		hr = hrOK;
	DWORD		dwErr = ERROR_SUCCESS;
	RegKey		regkey;
	DWORD		dw = 0;
	WCHAR		szKey[1024] = {0};
	
	//SPIRouter	spRouter = pRouter;
	
	wsprintf ( szKey, TCPIP_PARAMETERS_KEY, pszIfName);
	//Disable Dynamic DNS
	dwErr = regkey.Open(	HKEY_LOCAL_MACHINE, 
						szKey, 
						KEY_ALL_ACCESS, 
						pRouter->GetMachineName()
					  );
	if ( ERROR_SUCCESS != dwErr )
		goto done;
	
	dwErr = regkey.SetValue ( REGISTRATION_ENABLED, dw );
	if ( ERROR_SUCCESS != dwErr )
		goto done;

	dwErr = regkey.Close();
	if ( ERROR_SUCCESS != dwErr )
		goto done;

	//Disable netbt on this interface
	wsprintf ( szKey, REGKEY_NETBT_PARAM_W, pszIfName );
	dwErr = regkey.Open (	HKEY_LOCAL_MACHINE,
							szKey,
							KEY_ALL_ACCESS,
							pRouter->GetMachineName()
						);

	if ( ERROR_SUCCESS != dwErr )
		goto done;

	dw = REGVAL_DISABLE_NETBT;
	dwErr = regkey.SetValue ( REGVAL_NETBIOSOPTIONS_W, dw );
	if ( ERROR_SUCCESS != dwErr )
		goto done;
	
done:
	regkey.Close();   
    return hr;
}
/*!--------------------------------------------------------------------------
    AddVPNFiltersToInterface
        This will the PPTP and L2TP filters to the public interface.

        This code will OVERWRITE any filters currently in the filter list.

        (for PPTP)
            input/output    IP protocol ID 47
            input/output    TCP source port 1723
            input/output    TCP destination port 1723

        (for L2TP)
            input/output    UDP port 500 (for IPSEC)
            input/output    UDP port 1701
    Author: KennT
 ---------------------------------------------------------------------------*/


// Look at the code below.  After copying the filter over, we will
// convert the source/dest port fields from host to network order!!


static const FILTER_INFO    s_rgVpnFilters[] =
{
    // PPTP filter (protocol ID 47)
    { 0, 0, 0, 0, 47,               0,  0,      0 },

    // PPTP filter (source port 1723)
    { 0, 0, 0, 0, FILTER_PROTO_TCP, 0,  1723,   0 },

    // PPTP filter (dest port 1723)
    { 0, 0, 0, 0, FILTER_PROTO_TCP, 0,  0,      1723 },

    // L2TP filter source/dest port = 500
    { 0, 0, 0, 0, FILTER_PROTO_UDP, 0,  500,    500 },

    // L2TP filter source/dest port = 1701
    { 0, 0, 0, 0, FILTER_PROTO_UDP, 0,  1701,   1701 }
};


HRESULT AddVPNFiltersToInterface(IRouterInfo *pRouter, LPCTSTR pszIfName, RtrWizInterface*    pIf)
{
    HRESULT     hr = hrOK;
    SPIInfoBase spInfoBase;
    DWORD       dwSize = 0;
    DWORD       cFilters = 0;
    DWORD        dwIpAddress = 0;
    LPBYTE      pData = NULL;
    FILTER_DESCRIPTOR * pIpfDescriptor = NULL;
    CString        tempAddrList;
    CString        singleAddr;
    FILTER_INFO *pIpfInfo = NULL;
    CDWordArray    arrIpAddr;
    int         i, j;
    USES_CONVERSION;

    CORg( CreateInfoBase( &spInfoBase ) );

    // First, get the proper infobase (the RmIf)
    // ----------------------------------------------------------------
    CORg( RouterEntryLoadInfoBase(pRouter->GetMachineName(),
                                  pszIfName,
                                  PID_IP,
                                  spInfoBase) );

    // collect all the ip addresses on the interface
    tempAddrList = pIf->m_stIpAddress;
    while (!tempAddrList.IsEmpty())
    {
        i = tempAddrList.Find(_T(','));

        if ( i != -1 )
        {
            singleAddr = tempAddrList.Left(i);
            tempAddrList = tempAddrList.Mid(i + 1);
        }
        else
        {
            singleAddr = tempAddrList;
            tempAddrList.Empty();
        }

        dwIpAddress = inet_addr(T2A((LPCTSTR)singleAddr));

        if (INADDR_NONE != dwIpAddress)    // successful
            arrIpAddr.Add(dwIpAddress);
    }

    // Setup the data structure
    // ----------------------------------------------------------------

    // Calculate the size needed
    // ----------------------------------------------------------------
    cFilters = DimensionOf(s_rgVpnFilters);

    // cFilters-1 because FILTER_DESCRIPTOR has one FILTER_INFO object
    // ----------------------------------------------------------------
    dwSize = sizeof(FILTER_DESCRIPTOR) +
                 (cFilters * arrIpAddr.GetSize() - 1) * sizeof(FILTER_INFO);
    pData = new BYTE[dwSize];

    ::ZeroMemory(pData, dwSize);

    // Setup the filter descriptor
    // ----------------------------------------------------------------
    pIpfDescriptor = (FILTER_DESCRIPTOR *) pData;
    pIpfDescriptor->faDefaultAction = DROP;
    pIpfDescriptor->dwNumFilters = cFilters * arrIpAddr.GetSize();
    pIpfDescriptor->dwVersion = IP_FILTER_DRIVER_VERSION_1;


    // Add the various filters to the list
    // input filters
    pIpfInfo = (FILTER_INFO *) pIpfDescriptor->fiFilter;

    // for each ip address on the interface
    for ( j = 0; j < arrIpAddr.GetSize(); j++)
    {

        dwIpAddress = arrIpAddr.GetAt(j);

        for (i=0; i<cFilters; i++, pIpfInfo++)
        {
            *pIpfInfo = s_rgVpnFilters[i];

            // Now we convert the appropriate fields from host to
            // network order.
            pIpfInfo->wSrcPort = htons(pIpfInfo->wSrcPort);
            pIpfInfo->wDstPort = htons(pIpfInfo->wDstPort);

            // change dest address and mask
            pIpfInfo->dwDstAddr = dwIpAddress;
            pIpfInfo->dwDstMask = 0xffffffff;
        }


        // inet_addr
    }
    // This will overwrite any of the current filters in the
    // filter list.
    // ----------------------------------------------------------------
    CORg( spInfoBase->AddBlock(IP_IN_FILTER_INFO, dwSize, pData, 1, TRUE) );

    // output filters
    // ----------------------------------------------------------------
    pIpfInfo = (FILTER_INFO *) pIpfDescriptor->fiFilter;
    // for each ip address on the interface
    for ( j = 0; j < arrIpAddr.GetSize(); j++)
    {

        dwIpAddress = arrIpAddr.GetAt(j);

        for (i=0; i<cFilters; i++, pIpfInfo++)
        {
            *pIpfInfo = s_rgVpnFilters[i];

            // Now we convert the appropriate fields from host to
            // network order.
            pIpfInfo->wSrcPort = htons(pIpfInfo->wSrcPort);
            pIpfInfo->wDstPort = htons(pIpfInfo->wDstPort);

            // change source address and mask
            pIpfInfo->dwSrcAddr = dwIpAddress;
            pIpfInfo->dwSrcMask = 0xffffffff;
        }




    }    // loop for each ip address on the interface

    // This will overwrite any of the current filters in the
    // filter list.
    // ----------------------------------------------------------------
    CORg( spInfoBase->AddBlock(IP_OUT_FILTER_INFO, dwSize, pData, 1, TRUE) );

    // Save the infobase back
    // ----------------------------------------------------------------
    CORg( RouterEntrySaveInfoBase(pRouter->GetMachineName(),
                                  pszIfName,
                                  spInfoBase,
                                  PID_IP) );

Error:
    delete [] pData;
    return hr;
}