|
|
/**********************************************************************//** 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
#include "rrasqry.h"
#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
#include "iphlpapi.h"
#include "dnsapi.h" // for dns stuff
extern "C" {#define _NOUIUTIL_H_
#include "dtl.h"
#include "pbuser.h"
#include "shlobjp.h"
};extern BOOL WINAPI LinkWindow_RegisterClass();
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-Ch3_06b.htm");const TCHAR s_szGeneralRASHelp[] = _T("%systemdir%\\help\\RRASconcepts.chm::/sag_RRAS-Ch1_1.htm");const TCHAR s_szUserAccounts[] = _T("%systemdir%\\help\\RRASconcepts.chm::/sag_RRAS-Ch1_46.htm");const TCHAR s_szDhcp[] = _T("%systemdir%\\help\\dhcpconcepts.chm");const TCHAR s_szDemandDialHelp[] = _T("%systemdir%\\help\\RRASconcepts.chm::/sag_RRAS-Ch3_08d.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};
/*
IsIcsIcfIcEnabled: This fucntion returns TRUE if ICS (connection sharing) or ICF (connection firewall) or IC (incoming connections) is enabled on the machine
author: kmurthy*/BOOL IsIcsIcfIcEnabled(IRouterInfo * spRouterInfo, BOOL suppressMesg){ HRESULT hr = hrOK; COSERVERINFO csi; COAUTHINFO cai; COAUTHIDENTITY caid; SPIRemoteICFICSConfig spConfig; IUnknown * punk = NULL; BOOL fwEnabled=FALSE, csEnabled=FALSE, icEnabled = FALSE; RegKey regkey; CString szKey = "SYSTEM\\CurrentControlSet\\Services\\RemoteAccess\\Parameters"; CString szValue = "IcConfigured"; CString szMachineName; DWORD dwErr, szResult=0;
ZeroMemory(&csi, sizeof(csi)); ZeroMemory(&cai, sizeof(cai)); ZeroMemory(&caid, sizeof(caid));
csi.pAuthInfo = &cai; cai.pAuthIdentityData = &caid; szMachineName = spRouterInfo->GetMachineName(); // Create the remote config object
hr = CoCreateRouterConfig(szMachineName , spRouterInfo, &csi, IID_IRemoteICFICSConfig, &punk);
if (FHrOK(hr)) { spConfig = (IRemoteICFICSConfig *)punk; punk = NULL; //Is ICF enabled?
hr = spConfig->GetIcfEnabled(&fwEnabled); if(FHrOK(hr)) { if(fwEnabled) { if(!suppressMesg){ CString stErr, st; stErr.LoadString(IDS_NEWWIZ_ICF_ERROR); st.Format(stErr, ((szMachineName.GetLength() == 0) ? GetLocalMachineName() : szMachineName)); AfxMessageBox(st); } spConfig->Release(); return TRUE; } }
//Is ICS enabled?
hr = spConfig->GetIcsEnabled(&csEnabled); if(FHrOK(hr)) { if(csEnabled) { if(!suppressMesg){ CString stErr, st; stErr.LoadString(IDS_NEWWIZ_ICS_ERROR); st.Format(stErr, ((szMachineName.GetLength() == 0) ? GetLocalMachineName() : szMachineName)); AfxMessageBox(st); } spConfig->Release(); return TRUE; } }
}
//Now check to see if IC is enabled
dwErr = regkey.Open( HKEY_LOCAL_MACHINE, szKey, KEY_QUERY_VALUE, szMachineName );
if ( ERROR_SUCCESS == dwErr ){ dwErr = regkey.QueryValue( szValue, szResult); if(ERROR_SUCCESS == dwErr ){ if(szResult == 1){ //IC is enabled!
if(!suppressMesg){ CString stErr, st; stErr.LoadString(IDS_NEWWIZ_IC_ERROR); st.Format(stErr, ((szMachineName.GetLength() == 0) ? GetLocalMachineName() : szMachineName)); AfxMessageBox(st); } regkey.Close(); return TRUE; } } }
regkey.Close();
return FALSE;
}
/*!--------------------------------------------------------------------------
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; DWORD dwErr, szResult=0; CString szMachineName;
AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
szMachineName = m_spRouterInfo->GetMachineName();
//kmurthy: We should not let the wizard run, if ICF/ICS/IC is already enabled on the machine
if(IsIcsIcfIcEnabled(m_spRouterInfo)){ return S_FALSE; } // 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(szMachineName , 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( szMachineName )) ) { 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
::SecureZeroMemory(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 dwExpressType){ DWORD dwServiceStatus = 0; DWORD dwErrorCode = 0;
m_stServerName = pszServerName; m_dwExpressType = dwExpressType;
// 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); }
//Based on the express type set some of the parameters upfront here
switch ( m_dwExpressType ) { case MPRSNAP_CYS_EXPRESS_NAT: m_fAdvanced = TRUE; m_wizType = NewRtrWizData::NewWizardRouterType_NAT; m_dwNewRouterType = NEWWIZ_ROUTER_TYPE_NAT; break; case MPRSNAP_CYS_EXPRESS_NONE: default: //do nothing here
break; }
LoadInterfaceData(pRouter);
return hrOK;}
UINT NewRtrWizData::GetStartPageId (){
// Get a better scheme in place for this stuff. This
// is the index into the array m_pagelist.
switch ( m_dwExpressType ) { case MPRSNAP_CYS_EXPRESS_NAT: return (6); break; case MPRSNAP_CYS_EXPRESS_NONE: default: return (0); break; } return 0;}
/*!--------------------------------------------------------------------------
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; }}
HRESULT NewRtrWizData::HrIsDNSRunningOnGivenInterface(CString InterfaceId){ if (m_fTest) return s_fIsDNSRunningOnPrivateInterface ? S_OK : S_FALSE; else { // Search for the interface in our list
// ------------------------------------------------------------
RtrWizInterface * pRtrWizIf = NULL;
m_ifMap.Lookup(InterfaceId, pRtrWizIf); if (pRtrWizIf) return pRtrWizIf->m_fIsDnsEnabled ? S_OK : S_FALSE; else return S_FALSE; }}
HRESULT NewRtrWizData::HrIsDNSRunningOnNATInterface(){ 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_stNATPrivateInterfaceId, 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; }}
HRESULT NewRtrWizData::HrIsDHCPRunningOnGivenInterface(CString InterfaceId){ 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(InterfaceId, pRtrWizIf); if (pRtrWizIf) return pRtrWizIf->m_fIsDhcpEnabled ? S_OK : S_FALSE; else return S_FALSE; }}
HRESULT NewRtrWizData::HrIsDHCPRunningOnNATInterface(){ 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_stNATPrivateInterfaceId, 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 stTemp;
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 NewWizardRouterType_DialupOrVPN: if (FHrOK(HrIsIPInstalled())) { lNextPage = IDD_NEWRTRWIZ_RRASVPN; } else { if (FHrOK(HrIsLocalMachine())) lNextPage = IDD_NEWRTRWIZ_VPN_NOIP; else lNextPage = IDD_NEWRTRWIZ_VPN_NOIP_NONLOCAL; }
break; case NewWizardRouterType_NAT: if ( !FHrOK(HrIsIPInstalled()) ) { if (FHrOK(HrIsLocalMachine())) lNextPage = IDD_NEWRTRWIZ_NAT_NOIP; else lNextPage = IDD_NEWRTRWIZ_NAT_NOIP_NONLOCAL; } else { // This is always in advanced mode of operation.
if (FHrOK(HrIsSharedAccessRunningOnServer())) { if (FHrOK(HrIsLocalMachine())) lNextPage = IDD_NEWRTRWIZ_NAT_A_CONFLICT; else lNextPage = IDD_NEWRTRWIZ_NAT_A_CONFLICT_NONLOCAL; } else { lNextPage = IDD_NEWRTRWIZ_NAT_A_PUBLIC; } } break; case NewWizardRouterType_VPNandNAT:
GetNumberOfNICS_IP(&dwNICs); if ( dwNICs < 1 ) { lNextPage = IDD_NEWRTRWIZ_VPN_A_FINISH_NONICS; } else { m_dwNewRouterType |= (NEWWIZ_ROUTER_TYPE_VPN|NEWWIZ_ROUTER_TYPE_NAT); lNextPage = IDD_NEWRTRWIZ_VPN_A_PUBLIC; }
break; case NewWizardRouterType_DOD: //Use demand dial
lNextPage = IDD_NEWRTRWIZ_ROUTER_USEDD; break; case NewWizardRouterType_Custom: lNextPage = IDD_NEWRTRWIZ_CUSTOM_CONFIG; break; } break; case IDD_NEWRTRWIZ_CUSTOM_CONFIG: lNextPage = IDD_NEWRTRWIZ_MANUAL_FINISH; break; case IDD_NEWRTRWIZ_RRASVPN:
//
//Check to see what the router type is set to.
//based on that make a decision what page is next
//
GetNumberOfNICS_IP(&dwNICs); if ( dwNICs > 1 ) { //
//There are more than one nics
//So check to see if it is RAS or VPN or both
//
lNextPage = IDD_NEWRTRWIZ_VPN_A_FINISH_NONICS; if ( m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_VPN && m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_DIALUP ) { //
//This is both a dialup and VPN server
//
//So show the public private network page
//as the next page.
//
lNextPage = IDD_NEWRTRWIZ_VPN_A_PUBLIC;
} else if ( m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_VPN ) { //
//This is only a VPN server. So show the public
//private network page next
//
lNextPage = IDD_NEWRTRWIZ_VPN_A_PUBLIC; } else if ( m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_DIALUP ) { //
//This is only a dialup server. So show the private
//network page next.
//
lNextPage = IDD_NEWRTRWIZ_RAS_A_NETWORK; }
} else if ( dwNICs == 0 ) { //
//No Nics. So this if this is a VPN,
//this is an error state. If RAS then
//we should be able to install dialup
//even without a NIC.
//Since we dont Enable VPN if there are
//no nics in the machine, this will
//only have a dialup case.
//
lNextPage = IDD_NEWRTRWIZ_RAS_A_NONICS; } else { //
//Only one nic so in either case, show
//the addressing page. Collapse addressing
//into one page
AutoSelectPrivateInterface(); lNextPage = IDD_NEWRTRWIZ_ADDRESSING; } 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 ( m_wizType == NewWizardRouterType_VPNandNAT ) { stTemp = m_stNATPrivateInterfaceId; } else { stTemp = m_stPrivateInterfaceId; } if (FHrOK(HrIsDNSRunningOnGivenInterface(stTemp)) || FHrOK(HrIsDHCPRunningOnGivenInterface(stTemp)) || 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 { //
//check to see if we are in express path
//if so, we fall thru' again. no showing
//this page.
if ( MPRSNAP_CYS_EXPRESS_NAT == m_dwExpressType ) { m_fNatUseSimpleServers = FALSE; } 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 { if ( m_wizType == NewWizardRouterType_VPNandNAT ) { lNextPage = IDD_NEWRTRWIZ_USERADIUS; } 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 { if ( m_wizType == NewWizardRouterType_VPNandNAT ) { lNextPage = IDD_NEWRTRWIZ_USERADIUS; } 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_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_ADDRESSING; } break; }
// default catch
lNextPage = IDD_NEWRTRWIZ_RAS_A_FINISH; break;
case IDD_NEWRTRWIZ_RAS_A_NONICS: if (m_fNoNicsAreOk) lNextPage = IDD_NEWRTRWIZ_ADDRESSING; else lNextPage = IDD_NEWRTRWIZ_RAS_A_FINISH_NONICS; break;
case IDD_NEWRTRWIZ_RAS_A_NETWORK: lNextPage = IDD_NEWRTRWIZ_ADDRESSING; break;
case IDD_NEWRTRWIZ_ADDRESSING:
GetNumberOfNICS_IP(&dwNICs); if ( m_wizType == NewWizardRouterType_VPNandNAT ) { //This is a VPN and NAT case
if ( m_fUseDHCP ) { // Determine how many choices are available for
// NAT private interface
// The public interface cannot be used as a NAT private
if ( !m_stPublicInterfaceId.IsEmpty() ) dwNICs --;
// If there is only one NIC left, then pick that as the
// NAT private interface. By now that same NIC has already
// been selected as VPN private interface
// After that, goto the DHCP/DNS page
// Or else show the nat private interface selection page
// At this point dwNICs should never be less than 1
Assert(dwNICs > 0); if ( dwNICs == 1 ) { m_stNATPrivateInterfaceId = m_stPrivateInterfaceId;
if (FHrOK(HrIsDNSRunningOnNATInterface()) || FHrOK(HrIsDHCPRunningOnNATInterface()) || FHrOK(HrIsDNSRunningOnServer()) || FHrOK(HrIsDHCPRunningOnServer())) { m_fNatUseSimpleServers = FALSE;
//
//Continue on with the VPN wizard part
//
lNextPage = IDD_NEWRTRWIZ_USERADIUS;
} else { lNextPage = IDD_NEWRTRWIZ_NAT_A_DHCPDNS; } } else { lNextPage = IDD_NEWRTRWIZ_NAT_A_PRIVATE; } } else { //
//Since static address pool was selected, show the
//addressing page.
//
lNextPage = IDD_NEWRTRWIZ_ADDRESSPOOL; } } else if ( ( m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_VPN) || ( m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_DIALUP ) ) { if ( !dwNICs && m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_DIALUP ) { //No NICS. This should happen only in case of dialup.
if (m_fUseDHCP) { lNextPage = IDD_NEWRTRWIZ_RAS_A_FINISH; } else lNextPage = IDD_NEWRTRWIZ_ADDRESSPOOL; } else if (m_fUseDHCP) { //
//Logic is the same irrespective of whether it is
//VPN or DIALUP.
//
lNextPage = IDD_NEWRTRWIZ_USERADIUS; } else lNextPage = IDD_NEWRTRWIZ_ADDRESSPOOL;
} else if ( m_dwNewRouterType && NEWWIZ_ROUTER_TYPE_DOD ) { if (m_fUseDHCP) lNextPage = IDD_NEWRTRWIZ_ROUTER_FINISH_DD; else lNextPage = IDD_NEWRTRWIZ_ADDRESSPOOL; } break;
case IDD_NEWRTRWIZ_ADDRESSPOOL:
GetNumberOfNICS_IP(&dwNICs);
if ( m_wizType == NewWizardRouterType_VPNandNAT ) { // Determine how many choices are available for
// NAT private interface
// The public interface cannot be used as a NAT private
if ( !m_stPublicInterfaceId.IsEmpty() ) dwNICs --;
// If there is only one NIC left, then pick that as the
// NAT private interface. By now that same NIC has already
// been selected as VPN private interface
// After that, goto the DHCP/DNS page
// Or else show the nat private interface selection page
// At this point dwNICs should never be less than 1
Assert(dwNICs > 0); if ( dwNICs == 1 ) { m_stNATPrivateInterfaceId = m_stPrivateInterfaceId;
if (FHrOK(HrIsDNSRunningOnNATInterface()) || FHrOK(HrIsDHCPRunningOnNATInterface()) || FHrOK(HrIsDNSRunningOnServer()) || FHrOK(HrIsDHCPRunningOnServer())) { m_fNatUseSimpleServers = FALSE;
//
//Continue on with the VPN wizard part
//
lNextPage = IDD_NEWRTRWIZ_USERADIUS;
} else { lNextPage = IDD_NEWRTRWIZ_NAT_A_DHCPDNS; } } else { lNextPage = IDD_NEWRTRWIZ_NAT_A_PRIVATE; }
} else if ( ( m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_VPN) || ( m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_DIALUP ) ) { if (dwNICs == 0) lNextPage = IDD_NEWRTRWIZ_RAS_A_FINISH; else lNextPage = IDD_NEWRTRWIZ_USERADIUS; } else if ( m_dwNewRouterType && NEWWIZ_ROUTER_TYPE_DOD ) { lNextPage = IDD_NEWRTRWIZ_ROUTER_FINISH_DD; } break;
case IDD_NEWRTRWIZ_USERADIUS: if (m_fUseRadius) lNextPage = IDD_NEWRTRWIZ_RADIUS_CONFIG; else if ( m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_VPN && m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_NAT ) { //NAT and VPN
lNextPage = IDD_NEWRTRWIZ_NAT_VPN_A_FINISH; } else if ( m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_DIALUP && m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_VPN ) { //RAS and VPN
lNextPage = IDD_NEWRTRWIZ_RAS_VPN_A_FINISH; } else if ( m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_DIALUP ) { //RAS only
lNextPage = IDD_NEWRTRWIZ_RAS_A_FINISH; } else { //VPN only
lNextPage = IDD_NEWRTRWIZ_VPN_A_FINISH; } break;
case IDD_NEWRTRWIZ_RADIUS_CONFIG: if ( m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_VPN && m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_NAT ) { //NAT and VPN
lNextPage = IDD_NEWRTRWIZ_NAT_VPN_A_FINISH; } else if ( m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_DIALUP && m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_VPN ) { //RAS and VPN
lNextPage = IDD_NEWRTRWIZ_RAS_VPN_A_FINISH; } else if ( m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_DIALUP ) { //RAS only
lNextPage = IDD_NEWRTRWIZ_RAS_A_FINISH; } else { //VPN only
lNextPage = IDD_NEWRTRWIZ_VPN_A_FINISH; } break;
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_ADDRESSING; } else lNextPage = IDD_NEWRTRWIZ_VPN_A_PRIVATE; break;
case IDD_NEWRTRWIZ_VPN_A_PRIVATE: Assert(!m_stPrivateInterfaceId.IsEmpty()); lNextPage = IDD_NEWRTRWIZ_ADDRESSING; break;
case IDD_NEWRTRWIZ_VPN_A_ADDRESSPOOL: break;
case IDD_NEWRTRWIZ_ROUTER_USEDD: if (m_fUseDD) lNextPage = IDD_NEWRTRWIZ_ADDRESSING; else lNextPage = IDD_NEWRTRWIZ_ROUTER_FINISH; 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;}
void NewRtrWizData::AutoSelectNATPrivateInterface(){ POSITION pos; RtrWizInterface * pRtrWizIf = NULL; CString st;
m_stNATPrivateInterfaceId.Empty();
pos = m_ifMap.GetStartPosition(); while (pos) { m_ifMap.GetNextAssoc(pos, st, pRtrWizIf);
if (m_stPublicInterfaceId != st && m_stPrivateInterfaceId != st ) { m_stNATPrivateInterfaceId = st; break; } }
Assert(!m_stNATPrivateInterfaceId.IsEmpty());
return;}/*!--------------------------------------------------------------------------
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; m_dwRouterType = 0;
// Sync up with the general structure
// ----------------------------------------------------------------
if ( m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_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; }
if ( m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_DIALUP ) { m_dwRouterType |= ROUTER_TYPE_RAS; }
if ( m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_VPN ) { m_dwRouterType |= (ROUTER_TYPE_LAN | ROUTER_TYPE_WAN | ROUTER_TYPE_RAS); }
if ( m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_DOD ) { m_dwRouterType |= ROUTER_TYPE_WAN; }
if ( m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_LAN_ROUTING ) { m_dwRouterType |= ROUTER_TYPE_LAN; }
m_RtrConfigData.m_dwRouterType = m_dwRouterType;
// Setup the NAT-specific information
// ----------------------------------------------------------------
if ((m_wizType != NewWizardRouterType_Custom) && (m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_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_ALG; // savasg added
}
// 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 = USE_PPPCFG_DEFAULT_METHODS;
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, BOOL mesgflag){ AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
DWORD dwError = ERROR_SUCCESS; SPIRemoteNetworkConfig spNetwork; SPIRemoteSetDnsConfig spDns; IUnknown * punk = NULL; CWaitCursor wait; COSERVERINFO csi; COAUTHINFO cai; COAUTHIDENTITY caid; HRESULT hr = hrOK, dnsHr = hrOK; CString sTempPrivateIfID = m_stPrivateInterfaceId; 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() );
if ( !m_stPublicInterfaceId.IsEmpty()){ //kmurthy: Mark the public interface selected as uninteresting to DNS. Bug:380423
dnsHr = CoCreateRouterConfig(m_RtrConfigData.m_stServerName, pRouter, &csi, IID_IRemoteSetDnsConfig, &punk);
if(FHrSucceeded(dnsHr)){ spDns = (IRemoteSetDnsConfig *)punk; CORg(spDns->SetDnsConfig((DWORD)DnsConfigWaitForNameErrorOnAll, NULL)); }
punk = NULL; }
#ifdef KSL_IPINIP
// Remove the IP-in-IP tunnel names (since the registry has
// been cleared).
// ------------------------------------------------------------
CleanupTunnelFriendlyNames(pRouter);#endif //KSL_IPINIP
// 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_dwNewRouterType & NEWWIZ_ROUTER_TYPE_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_wizType != NewWizardRouterType_Custom) && (m_wizType != NewWizardRouterType_DialupOrVPN) && 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)) { CRasWarning dlg((char *)c_sazRRASDomainHelpTopic, IDS_ERR_CANNOT_REGISTER_IN_DS); dlg.DoModal(); } } } // 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 == NewWizardRouterType_VPNandNAT )
// m_stPrivateInterfaceId = m_stNATPrivateInterfaceId;
//
if (!(m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_NAT ) || ((m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_NAT ) && !m_fCreateDD)) { // The path that NAT takes when creating the DD interface
// is somewhere else.
// ------------------------------------------------------------
Assert(m_fCreateDD == FALSE);
if (pRouter) { if (m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_NAT ) { AddIGMPToNATServer(this, &m_RtrConfigData, pRouter, (m_wizType == NewWizardRouterType_VPNandNAT)); } 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); } else if ( m_wizType == NewWizardRouterType_Custom ) { //
//If this is custom config and NAT is selected. Just add the protocol and
//nothing else.
//
AddNATToServer(this, &m_RtrConfigData, pRouter, m_fCreateDD, TRUE); }
// 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))){ CRasWarning dlg("RRASconcepts.chm::/mpr_how_dhcprelay.htm", IDS_WRN_RTRWIZ_NO_DHCP_SERVER); dlg.DoModal(); } } }
AddIPBOOTPToServer(&m_RtrConfigData, pRouter, dwDhcpServer); } }
// if ( m_wizType == NewWizardRouterType_VPNandNAT )
// m_stPrivateInterfaceId = sTempPrivateIfID;
// If this is a VPN, add the filters to the public interface
// ----------------------------------------------------------------
if ( (m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_VPN) && (m_wizType == NewWizardRouterType_DialupOrVPN) && m_fSetVPNFilter ) { if ((!m_stPublicInterfaceId.IsEmpty()) && (m_fSetVPNFilter == TRUE)) {#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
} }
//
// Bug 519414
// Since IAS now has a Microsoft policy with the appropriate settings,
// there is no longer a single default policy. In addition there is
// no need to update any policy to have the required settings since the
// Microsoft VPN server policy does the job.
//
#if __DEFAULT_POLICY
// 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_dwNewRouterType & NEWWIZ_ROUTER_TYPE_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); } } }#endif
// Always start the router.
// ----------------------------------------------------------------
SetRouterServiceStartType(m_stServerName, SERVICE_AUTO_START); {
if(!mesgflag){ //If the mesgflag is TRUE, all UI should be suppressed and service need not be started.
// If this is manual start, we need to prompt them
// ------------------------------------------------------------
if ((m_wizType != NewWizardRouterType_Custom) || (AfxMessageBox(IDS_PROMPT_START_ROUTER_AFTER_INSTALL, MB_YESNO | MB_TASKMODAL | MB_SETFOREGROUND) == IDYES)) { CWaitCursor wait; StartRouterService(m_RtrConfigData.m_stServerName); } } }
if ( m_fUseDD && m_wizType == NewWizardRouterType_DOD) { HRESULT hr; hr = CallRouterEntryDlg(NULL, this, 0); if (!FHrSucceeded(hr)){ DisableRRAS((TCHAR *)(LPCTSTR)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;
m_hr = hr; 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); m_hr = hr; 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::OnCancel - Author: KennT ---------------------------------------------------------------------------*/
void CNewRtrWizPageBase::OnCancel(){ m_pRtrWizData->m_hr = HResultFromWin32(ERROR_CANCELLED);}
/*!--------------------------------------------------------------------------
CNewRtrWizPageBase::OnWizardNext - Author: KennT ---------------------------------------------------------------------------*/LRESULT CNewRtrWizPageBase::OnWizardNext(){ HRESULT hr = hrOK; LRESULT lResult;
// Tell the page to save it's state
m_pRtrWizData->m_hr = 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); m_pRtrWizData->m_hr = HResultFromWin32(ERROR_CANCELLED); 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());
// a special case
if(m_uDialogId == IDD_NEWRTRWIZ_USERADIUS){ m_pRtrWizData->m_fUseRadius = FALSE; }
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()
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) || (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, BOOL fInvokedInMMC, DWORD dwExpressType ) : CPropertyPageHolderBase(pNode, pComponentData, pszSheetName){ LinkWindow_RegisterClass(); //ASSERT(pFolderNode == GetContainerNode());
//if this is not done, deadlock can happen
EnablePeekMessageDuringNotifyConsole(TRUE);
m_bAutoDeletePages = FALSE; // we have the pages as embedded members
Assert(pTFSCompData != NULL); m_spTFSCompData.Set(pTFSCompData); m_bWiz97 = TRUE; m_fInvokedInMMC = fInvokedInMMC; m_dwExpressType = dwExpressType; m_spRouter.Set(pRouter); if ( MPRSNAP_CYS_EXPRESS_NONE != dwExpressType ) m_bAutoDelete = FALSE;
}
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;
m_RtrWizData.Init(pServerName, m_spRouter, m_dwExpressType); m_RtrWizData.m_stServerName = pServerName;
// Setup the list of pages
//0
m_pagelist.AddTail(&m_pageWelcome); //1
m_pagelist.AddTail(&m_pageCommonConfig); //2
m_pagelist.AddTail(&m_pageNatFinishAConflict); //3
m_pagelist.AddTail(&m_pageNatFinishAConflictNonLocal); //4
m_pagelist.AddTail(&m_pageNatFinishNoIP); //5
m_pagelist.AddTail(&m_pageNatFinishNoIPNonLocal); //6
m_pagelist.AddTail(&m_pageNatSelectPublic); // 7
m_pagelist.AddTail ( &m_pageCustomConfig); // 8
m_pagelist.AddTail ( &m_pageRRasVPN); // 9
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_pageRasFinishNeedProtocols); m_pagelist.AddTail(&m_pageRasFinishNeedProtocolsNonLocal);
m_pagelist.AddTail(&m_pageRasNoNICs); m_pagelist.AddTail(&m_pageRasFinishNoNICs); m_pagelist.AddTail(&m_pageRasNetwork);
m_pagelist.AddTail(&m_pageRasFinishAdvanced);
m_pagelist.AddTail(&m_pageVpnFinishNoNICs); m_pagelist.AddTail(&m_pageVpnFinishNoIP); m_pagelist.AddTail(&m_pageVpnFinishNoIPNonLocal); m_pagelist.AddTail(&m_pageVpnFinishNeedProtocols); m_pagelist.AddTail(&m_pageVpnFinishNeedProtocolsNonLocal);
m_pagelist.AddTail(&m_pageVpnSelectPublic); m_pagelist.AddTail(&m_pageVpnSelectPrivate); m_pagelist.AddTail(&m_pageVpnFinishAdvanced); m_pagelist.AddTail(&m_pageRASVpnFinishAdvanced); m_pagelist.AddTail(&m_pageNATVpnFinishAdvanced);
m_pagelist.AddTail(&m_pageRouterFinishNeedProtocols); m_pagelist.AddTail(&m_pageRouterFinishNeedProtocolsNonLocal); m_pagelist.AddTail(&m_pageRouterUseDD); m_pagelist.AddTail(&m_pageRouterFinish); m_pagelist.AddTail(&m_pageRouterFinishDD);
m_pagelist.AddTail(&m_pageManualFinish); m_pagelist.AddTail(&m_pageAddressing); m_pagelist.AddTail(&m_pageAddressPool); m_pagelist.AddTail(&m_pageRadius); m_pagelist.AddTail(&m_pageRadiusConfig);
// 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;}//
//This is the real Wiz97 flag. Dont use PSH_WIZARD97.
//You'll get unpredictable results.
#define REAL_PSH_WIZARD97 0x01000000
HRESULT CNewRtrWiz::DoModalWizard(){ AFX_MANAGE_STATE(AfxGetStaticModuleState()); HRESULT hr = hrOK; if ( m_fInvokedInMMC ) { return CPropertyPageHolderBase::DoModalWizard(); } else {
m_fSetDefaultSheetPos = NULL; PROPSHEETHEADER psh; ZeroMemory ( &psh, sizeof(psh) ); psh.dwSize = sizeof(psh); psh.dwFlags = REAL_PSH_WIZARD97| PSH_USEHBMHEADER| PSH_USEHBMWATERMARK| PSH_WATERMARK| PSH_HEADER| PSH_NOAPPLYNOW;
psh.hwndParent = GetActiveWindow();
psh.hInstance = AfxGetInstanceHandle();
psh.pszCaption = (LPCTSTR)m_stSheetTitle.GetBuffer(m_stSheetTitle.GetLength()+1); psh.hbmHeader = g_wmi.hHeader; psh.hbmWatermark = g_wmi.hWatermark; psh.hplWatermark = g_wmi.hPalette; psh.nStartPage = m_RtrWizData.GetStartPageId(); psh.nPages = m_pageList.GetCount(); psh.phpage = new HPROPSHEETPAGE[psh.nPages ]; if ( NULL == psh.phpage ) { m_RtrWizData.m_hr = E_OUTOFMEMORY; return m_RtrWizData.m_hr; }
//now setup all the pages in the psh structure
POSITION pos; DWORD dw=0; //For cys we do only wiz97 standard
for( pos = m_pageList.GetHeadPosition(); pos != NULL; ) { CPropertyPageBase* pPage = m_pageList.GetNext(pos);
pPage->m_psp97.dwFlags &= ~PSP_HASHELP;
HPROPSHEETPAGE hPage;
hPage = ::CreatePropertySheetPage(&pPage->m_psp97); if (hPage == NULL) { m_RtrWizData.m_hr = E_UNEXPECTED; return m_RtrWizData.m_hr; } else { pPage->m_hPage = hPage;
*(psh.phpage+dw) = hPage; dw++; } }
if ( PropertySheet (&psh ) == -1 ) { m_RtrWizData.m_hr = HResultFromWin32(GetLastError()); } } return m_RtrWizData.m_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; case HelpFlag_UserAccounts: pszHelpString = s_szUserAccounts; break; case HelpFlag_DemandDial: pszHelpString = s_szDemandDialHelp; break; default: Panic0("Unknown help flag specified!"); break; }
LaunchHelpTopic(pszHelpString); }
//
//Now for a special case
//check to see if the dhcp help has been set.
//if so show that help.
//
if ( m_RtrWizData.m_fShowDhcpHelp ) { LaunchHelpTopic(s_szDhcp); }
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()
/*---------------------------------------------------------------------------
CNewRtrWizCustomConfig Implementation ---------------------------------------------------------------------------*/
CNewRtrWizCustomConfig::CNewRtrWizCustomConfig() : CNewRtrWizPageBase( CNewRtrWizCustomConfig::IDD, CNewRtrWizPageBase::Middle ){ InitWiz97(FALSE, IDS_NEWWIZ_CUSTOMCONFIG_TITLE, IDS_NEWWIZ_CUSTOMCONFIG_SUBTITLE);}
BEGIN_MESSAGE_MAP(CNewRtrWizCustomConfig, CNewRtrWizPageBase)END_MESSAGE_MAP()
BOOL CNewRtrWizCustomConfig::OnInitDialog(){ //
//Based on what has already been selected by the user,
//setup the new buttons.
//
if ( !m_pRtrWizData->m_dwNewRouterType ) { if ( m_pRtrWizData->m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_NAT && m_pRtrWizData->m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_BASIC_FIREWALL ) { CheckDlgButton ( IDC_NEWWIZ_BTN_NAT, BST_CHECKED ); } if ( m_pRtrWizData->m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_DIALUP ) { CheckDlgButton ( IDC_NEWWIZ_BTN_DIALUP_ACCESS, BST_CHECKED ); } if ( m_pRtrWizData->m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_VPN ) { CheckDlgButton ( IDC_NEWWIZ_BTN_VPN_ACCESS, BST_CHECKED ); } if ( m_pRtrWizData->m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_DOD ) { CheckDlgButton ( IDC_NEWWIZ_BTN_DOD, BST_CHECKED ); } if ( m_pRtrWizData->m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_LAN_ROUTING ) { CheckDlgButton ( IDC_NEWWIZ_BTN_LAN_ROUTING, BST_CHECKED ); } } return TRUE;}
HRESULT CNewRtrWizCustomConfig::OnSavePage(){ DWORD dwNewRouterType = NEWWIZ_ROUTER_TYPE_UNKNOWN;
//
//Based on what the user has selected, setup
//the selection.
//
if ( IsDlgButtonChecked( IDC_NEWWIZ_BTN_NAT ) ) { dwNewRouterType |= NEWWIZ_ROUTER_TYPE_NAT | NEWWIZ_ROUTER_TYPE_BASIC_FIREWALL; }
if ( IsDlgButtonChecked( IDC_NEWWIZ_BTN_DIALUP_ACCESS ) ) { dwNewRouterType |= NEWWIZ_ROUTER_TYPE_DIALUP; }
if ( IsDlgButtonChecked( IDC_NEWWIZ_BTN_VPN_ACCESS ) ) { dwNewRouterType |= NEWWIZ_ROUTER_TYPE_VPN; }
if ( IsDlgButtonChecked( IDC_NEWWIZ_BTN_DOD ) ) { dwNewRouterType |= NEWWIZ_ROUTER_TYPE_DOD; }
if ( IsDlgButtonChecked( IDC_NEWWIZ_BTN_LAN_ROUTING ) ) { dwNewRouterType |= NEWWIZ_ROUTER_TYPE_LAN_ROUTING; }
//Check to see if at least one of the types is selected
if ( NEWWIZ_ROUTER_TYPE_UNKNOWN == dwNewRouterType ) { AfxMessageBox(IDS_PROMPT_PLEASE_SELECT_OPTION); return E_FAIL; } m_pRtrWizData->m_dwNewRouterType = dwNewRouterType;
return hrOK;}
/*---------------------------------------------------------------------------
CNewRtrWizRRasVPN Implementation ---------------------------------------------------------------------------*/
CNewRtrWizRRasVPN::CNewRtrWizRRasVPN() : CNewRtrWizPageBase( CNewRtrWizRRasVPN::IDD, CNewRtrWizPageBase::Middle ){ InitWiz97(FALSE, IDS_NEWWIZ_RRASVPN_TITLE, IDS_NEWWIZ_RRASVPN_SUBTITLE);}
BEGIN_MESSAGE_MAP(CNewRtrWizRRasVPN, CNewRtrWizPageBase) ON_BN_CLICKED(IDC_NEWWIZ_BTN_VPN, OnChkBtnClicked) ON_BN_CLICKED(IDC_NEWWIZ_BTN_DIALUP_RAS, OnChkBtnClicked)END_MESSAGE_MAP()
BOOL CNewRtrWizRRasVPN::OnInitDialog(){ DWORD dwNICs=0; CWnd * pVpnCheck = GetDlgItem ( IDC_NEWWIZ_BTN_VPN ); DWORD dwRouterType = m_pRtrWizData->m_dwNewRouterType;
if ( dwRouterType & NEWWIZ_ROUTER_TYPE_DIALUP ) { CheckDlgButton( IDC_NEWWIZ_BTN_DIALUP_RAS, BST_CHECKED ); } //Check to see if there is no NIC. If no NIC then
//gray out the VPN option
m_pRtrWizData->GetNumberOfNICS_IP(&dwNICs); if ( dwNICs < 1 ) { //
//Gray out the VPN button since there is only
//one NIC in the machine.
//
pVpnCheck->EnableWindow(FALSE); } else if ( dwRouterType & NEWWIZ_ROUTER_TYPE_VPN ) { CheckDlgButton( IDC_NEWWIZ_BTN_VPN, BST_CHECKED ); }
return TRUE;}
BOOL CNewRtrWizRRasVPN::OnSetActive(){ CWnd * pVpnCheck = GetDlgItem ( IDC_NEWWIZ_BTN_VPN ); BOOL bRet = CNewRtrWizPageBase::OnSetActive();
if ((pVpnCheck->IsWindowEnabled() && IsDlgButtonChecked(IDC_NEWWIZ_BTN_VPN)) || IsDlgButtonChecked(IDC_NEWWIZ_BTN_DIALUP_RAS)) { //Next button should be enabled in this case
GetHolder()->SetWizardButtons(PSWIZB_BACK | PSWIZB_NEXT); } else { //Next button is disabled
GetHolder()->SetWizardButtons(PSWIZB_BACK); }
return bRet;}
void CNewRtrWizRRasVPN::OnChkBtnClicked(){ CWnd * pVpnCheck = GetDlgItem ( IDC_NEWWIZ_BTN_VPN );
if ((pVpnCheck->IsWindowEnabled() && IsDlgButtonChecked(IDC_NEWWIZ_BTN_VPN)) || IsDlgButtonChecked(IDC_NEWWIZ_BTN_DIALUP_RAS)) { //Next button should be enabled in this case
GetHolder()->SetWizardButtons(PSWIZB_BACK | PSWIZB_NEXT); } else { //Next button is disabled
GetHolder()->SetWizardButtons(PSWIZB_BACK); }}
HRESULT CNewRtrWizRRasVPN::OnSavePage(){ DWORD dwRouterType = NEWWIZ_ROUTER_TYPE_UNKNOWN; CWnd * pVpnCheck = GetDlgItem ( IDC_NEWWIZ_BTN_VPN ); //
//check to see which buttons are set and based on that
//set the router type.
//
if ( pVpnCheck->IsWindowEnabled() && IsDlgButtonChecked(IDC_NEWWIZ_BTN_VPN) ) { DWORD dwNics = 0; m_pRtrWizData->GetNumberOfNICS_IP(&dwNics); if (dwNics <= 1) { //Not enough for VPN standard config
AfxMessageBox(IDS_ERR_VPN_NO_NICS_LEFT_FOR_PRIVATE_IF); return E_FAIL; } dwRouterType |= NEWWIZ_ROUTER_TYPE_VPN; } if ( IsDlgButtonChecked(IDC_NEWWIZ_BTN_DIALUP_RAS) ) { dwRouterType |= NEWWIZ_ROUTER_TYPE_DIALUP; }
if ( dwRouterType == NEWWIZ_ROUTER_TYPE_UNKNOWN ) { AfxMessageBox(IDS_PROMPT_PLEASE_SELECT_OPTION); return E_FAIL; } m_pRtrWizData->m_dwNewRouterType = dwRouterType; return hrOK;}
/*---------------------------------------------------------------------------
CNewRtrWizCommonConfig Implementation ---------------------------------------------------------------------------*/CNewRtrWizCommonConfig::CNewRtrWizCommonConfig() : CNewRtrWizPageBase(CNewRtrWizCommonConfig::IDD, CNewRtrWizPageBase::Middle){ InitWiz97(FALSE, IDS_NEWWIZ_COMMONCONFIG_TITLE, IDS_NEWWIZ_COMMONCONFIG_SUBTITLE);}
BEGIN_MESSAGE_MAP(CNewRtrWizCommonConfig, CNewRtrWizPageBase) ON_NOTIFY( NM_CLICK, IDC_HELP_LINK, CNewRtrWizCommonConfig::OnHelpClick ) ON_NOTIFY( NM_RETURN, IDC_HELP_LINK, CNewRtrWizCommonConfig::OnHelpClick )END_MESSAGE_MAP()
// This list of IDs will have their controls made bold.
const DWORD s_rgCommonConfigOptionIds[] ={ IDC_NEWWIZ_CONFIG_BTN_RAS_DIALUP_VPN, IDC_NEWWIZ_CONFIG_BTN_NAT1, IDC_NEWWIZ_CONFIG_BTN_VPNNAT, IDC_NEWWIZ_CONFIG_BTN_DOD, IDC_NEWWIZ_CONFIG_BTN_CUSTOM, 0};
void CNewRtrWizCommonConfig::OnHelpClick( NMHDR* pNMHDR, LRESULT* pResult){ if(!pNMHDR || !pResult) return; if((pNMHDR->idFrom != IDC_HELP_LINK) ||((pNMHDR->code != NM_CLICK) && (pNMHDR->code != NM_RETURN))) return; HtmlHelpA(NULL, "RRASconcepts.chm::/ras_common_configuration.htm", HH_DISPLAY_TOPIC, 0); *pResult = 0;}
BOOL CNewRtrWizCommonConfig::OnInitDialog(){ Assert(m_pRtrWizData); UINT idSelection; LOGFONT LogFont; CFont * pOldFont;
CNewRtrWizPageBase::OnInitDialog();#if 0
//No need to bold the font in this new wizard.
// 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); }#endif
switch (m_pRtrWizData->m_wizType) { case NewRtrWizData::NewWizardRouterType_DialupOrVPN: idSelection = IDC_NEWWIZ_CONFIG_BTN_RAS_DIALUP_VPN; break; case NewRtrWizData::NewWizardRouterType_NAT: idSelection = IDC_NEWWIZ_CONFIG_BTN_NAT1; break; case NewRtrWizData::NewWizardRouterType_VPNandNAT: idSelection = IDC_NEWWIZ_CONFIG_BTN_VPNNAT; break; case NewRtrWizData::NewWizardRouterType_DOD: idSelection = IDC_NEWWIZ_CONFIG_BTN_DOD; break; case NewRtrWizData::NewWizardRouterType_Custom: idSelection = IDC_NEWWIZ_CONFIG_BTN_CUSTOM; break; default: Panic1("Unknown Wizard Router Type : %d", m_pRtrWizData->m_wizType); idSelection = IDC_NEWWIZ_CONFIG_BTN_RAS_DIALUP_VPN; break; }
CheckRadioButton(IDC_NEWWIZ_CONFIG_BTN_RAS_DIALUP_VPN, IDC_NEWWIZ_CONFIG_BTN_CUSTOM, 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_RAS_DIALUP_VPN)) { m_pRtrWizData->m_wizType = NewRtrWizData::NewWizardRouterType_DialupOrVPN; //Dont know yet what the router type is
} else if (IsDlgButtonChecked(IDC_NEWWIZ_CONFIG_BTN_NAT1)) { m_pRtrWizData->m_wizType = NewRtrWizData::NewWizardRouterType_NAT; m_pRtrWizData->m_dwNewRouterType = NEWWIZ_ROUTER_TYPE_NAT; } else if (IsDlgButtonChecked(IDC_NEWWIZ_CONFIG_BTN_VPNNAT)) { DWORD dwNics = 0; m_pRtrWizData->GetNumberOfNICS_IP(&dwNics); if (dwNics <= 1) { //Not enough for VPN standard config
AfxMessageBox(IDS_ERR_VPN_NO_NICS_LEFT_FOR_PRIVATE_IF); return E_FAIL; } m_pRtrWizData->m_wizType = NewRtrWizData::NewWizardRouterType_VPNandNAT; m_pRtrWizData->m_dwNewRouterType = NEWWIZ_ROUTER_TYPE_NAT|NEWWIZ_ROUTER_TYPE_VPN; } else if (IsDlgButtonChecked(IDC_NEWWIZ_CONFIG_BTN_DOD)) { m_pRtrWizData->m_wizType = NewRtrWizData::NewWizardRouterType_DOD; m_pRtrWizData->m_dwNewRouterType = NEWWIZ_ROUTER_TYPE_DOD; } else { //
//Router type is still unknown here. next property page will tell
//what should be the actual type.
//
Assert(IsDlgButtonChecked(IDC_NEWWIZ_CONFIG_BTN_CUSTOM)); m_pRtrWizData->m_wizType = NewRtrWizData::NewWizardRouterType_Custom; }
return hrOK;}
/*---------------------------------------------------------------------------
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);
/*---------------------------------------------------------------------------
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) ON_NOTIFY( NM_CLICK, IDC_HELP_LINK, CNewRtrWizNatSelectPublic::OnHelpClick ) ON_NOTIFY( NM_RETURN, IDC_HELP_LINK, CNewRtrWizNatSelectPublic::OnHelpClick )END_MESSAGE_MAP()
void CNewRtrWizNatSelectPublic::OnHelpClick( NMHDR* pNMHDR, LRESULT* pResult){ if(!pNMHDR || !pResult) return; if((pNMHDR->idFrom != IDC_HELP_LINK) ||((pNMHDR->code != NM_CLICK) && (pNMHDR->code != NM_RETURN))) return; HtmlHelpA(NULL, "RRASconcepts.chm::/mpr_und_interfaces.htm", HH_DISPLAY_TOPIC, 0); *pResult = 0;}
BOOL CNewRtrWizNatSelectPublic::OnSetActive(){ //Need a generic way of finding out if
//this is the start page or not. But for now
//just use the hard coded value
//$TODO: Need to find a generic way of doing this.
if ( m_pRtrWizData->m_dwExpressType == MPRSNAP_CYS_EXPRESS_NAT ) m_pagetype = CNewRtrWizPageBase::Start; return CNewRtrWizPageBase::OnSetActive();}/*!--------------------------------------------------------------------------
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); //::PostMessage( ::GetParent(m_hWnd), PSM_SETWIZBUTTONS, 0 , PSWIZB_NEXT);
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 if (dwNICs == 1) { // Have to use new, there is no other choice because the single
// available interface can't be both the public and the private.
CheckRadioButton(IDC_NEWWIZ_BTN_NEW, IDC_NEWWIZ_BTN_EXISTING, IDC_NEWWIZ_BTN_NEW);
InitializeInterfaceListControl(NULL, &m_listCtrl, NULL, 0, m_pRtrWizData); RefreshInterfaceListControl(NULL, &m_listCtrl, NULL, 0, m_pRtrWizData);
// disable the 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(); }
if ( m_pRtrWizData->m_fNATEnableFireWall < 0 ) { //
//This is the first time that this dialog has
//been entered. So check the box and set
//the flag
m_pRtrWizData->m_fNATEnableFireWall = TRUE;
}
if (m_pRtrWizData->m_fNATEnableFireWall == TRUE) CheckDlgButton(IDC_CHK_BASIC_FIREWALL, TRUE); else CheckDlgButton(IDC_CHK_BASIC_FIREWALL, FALSE);
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); //This is not an error that we would return to user
return E_FAIL; } m_pRtrWizData->m_fCreateDD = FALSE;
m_pRtrWizData->m_stPublicInterfaceId = (LPCTSTR) m_listCtrl.GetItemData(iSel);
} if ( IsDlgButtonChecked(IDC_CHK_BASIC_FIREWALL) ) m_pRtrWizData->m_fNATEnableFireWall = TRUE; else m_pRtrWizData->m_fNATEnableFireWall = FALSE;
return hrOK;}
void CNewRtrWizNatSelectPublic::OnBtnClicked(){ int iSel = 0; DWORD status; MIB_IFROW ifRow; CString stRouter; ULONG index; HANDLE mprConfig; WCHAR guidName[64] = L"\\DEVICE\\TCPIP_";
MultiEnableWindow(GetSafeHwnd(), IsDlgButtonChecked(IDC_NEWWIZ_BTN_EXISTING), IDC_NEWWIZ_LIST, 0);
// If use an existing button is checked,
// auto-select the interface that is enabled and plugged.
if (IsDlgButtonChecked(IDC_NEWWIZ_BTN_EXISTING)) { //Get name of machine if local.
stRouter = m_pRtrWizData->m_stServerName; if (stRouter.GetLength() == 0) { stRouter = CString(_T("\\\\")) + GetLocalMachineName(); }
status = MprConfigServerConnect((LPWSTR)(LPCTSTR)stRouter, &mprConfig ); if ( status == NO_ERROR ) { //Check each interface, looking for a plugged, enabled interface
for (int i=0;i < m_listCtrl.GetItemCount();i++) { //Get guid from friendly name
status = MprConfigGetGuidName(mprConfig, (PWCHAR)(LPCTSTR)m_listCtrl.GetItemText(i, IFLISTCOL_NAME), &guidName[14], sizeof(guidName )); if (status != NO_ERROR ) { continue; } status = GetAdapterIndex( guidName, &index ); if ( status != NO_ERROR ) { continue; } //Now get info abt the Interface
ifRow.dwIndex = index; status = GetIfEntry(&ifRow); if(status != NO_ERROR){ continue; } if((ifRow.dwAdminStatus == TRUE) && (ifRow.dwOperStatus != MIB_IF_OPER_STATUS_NON_OPERATIONAL) && (ifRow.dwOperStatus != MIB_IF_OPER_STATUS_UNREACHABLE) && (ifRow.dwOperStatus != MIB_IF_OPER_STATUS_DISCONNECTED)) { //Found the default
iSel = i; break; } } }
m_listCtrl.SetItemState(iSel, 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) ON_NOTIFY( NM_CLICK, IDC_HELP_LINK, CNewRtrWizNatSelectPrivate::OnHelpClick ) ON_NOTIFY( NM_RETURN, IDC_HELP_LINK, CNewRtrWizNatSelectPrivate::OnHelpClick )END_MESSAGE_MAP()
void CNewRtrWizNatSelectPrivate::OnHelpClick( NMHDR* pNMHDR, LRESULT* pResult){ if(!pNMHDR || !pResult) return; if((pNMHDR->idFrom != IDC_HELP_LINK) ||((pNMHDR->code != NM_CLICK) && (pNMHDR->code != NM_RETURN))) return; HtmlHelpA(NULL, "dhcpconcepts.chm", HH_DISPLAY_TOPIC, 0); *pResult = 0;}
/*!--------------------------------------------------------------------------
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; DWORD dwErr, status; MIB_IFROW ifRow; CString stRouter; CString stPreviousId; ULONG index; HANDLE mprConfig; WCHAR guidName[64] = L"\\DEVICE\\TCPIP_";
CNewRtrWizPageBase::OnSetActive();
m_pRtrWizData->GetNumberOfNICS_IP(&dwNICs);
RefreshInterfaceListControl(NULL, &m_listCtrl, (LPCTSTR) m_pRtrWizData->m_stPublicInterfaceId, 0, m_pRtrWizData);
// Try to reselect the previously selected NIC
if (m_pRtrWizData->m_wizType == NewRtrWizData::NewWizardRouterType_VPNandNAT) { // If this page has come up as a part of VPN and NAT wizard, then we
// should see if NAT private interface selection has been made.
// If yes, use that
// If not then default to the VPN private interface
if ( !m_pRtrWizData->m_stNATPrivateInterfaceId.IsEmpty() ) { stPreviousId = m_pRtrWizData->m_stNATPrivateInterfaceId; } else if ( !m_pRtrWizData->m_stPrivateInterfaceId.IsEmpty() ) { stPreviousId = m_pRtrWizData->m_stPrivateInterfaceId; } } else { if ( !m_pRtrWizData->m_stPrivateInterfaceId.IsEmpty() ) { stPreviousId = m_pRtrWizData->m_stPrivateInterfaceId; } } if (!stPreviousId.IsEmpty()) { CString data;
for (int i=0;i < m_listCtrl.GetItemCount();i++) { data = (LPCTSTR) m_listCtrl.GetItemData(i); if(data == stPreviousId) { iSel = i; break; } }
/*
LV_FINDINFO lvfi;
lvfi.flags = LVFI_STRING; lvfi.psz = (LPCTSTR) m_pRtrWizData->m_stPrivateInterfaceId; iSel = m_listCtrl.FindItem(&lvfi, -1); if (iSel == -1) iSel = 0; */ } else { // Make an interface that is not disabled or unplugged as default-selected.
// Get name of machine if local.
stRouter = m_pRtrWizData->m_stServerName; if (stRouter.GetLength() == 0) { stRouter = CString(_T("\\\\")) + GetLocalMachineName(); }
status = MprConfigServerConnect((LPWSTR)(LPCTSTR)stRouter, &mprConfig ); if ( status == NO_ERROR ) { //Check each interface, looking for a plugged, enabled interface
for (int i=0;i < m_listCtrl.GetItemCount();i++) { //Get guid from friendly name
status = MprConfigGetGuidName(mprConfig, (PWCHAR)(LPCTSTR)m_listCtrl.GetItemText(i, IFLISTCOL_NAME), &guidName[14], sizeof(guidName )); if (status != NO_ERROR ) { continue; } status = GetAdapterIndex( guidName, &index ); if ( status != NO_ERROR ) { continue; } //Now get info abt the Interface
ifRow.dwIndex = index; status = GetIfEntry(&ifRow); if(status != NO_ERROR) { continue; } if((ifRow.dwAdminStatus == TRUE) && (ifRow.dwOperStatus != MIB_IF_OPER_STATUS_NON_OPERATIONAL) && (ifRow.dwOperStatus != MIB_IF_OPER_STATUS_UNREACHABLE) && (ifRow.dwOperStatus != MIB_IF_OPER_STATUS_DISCONNECTED)) { //Found the default
iSel = i; break; } } } }
m_listCtrl.SetItemState(iSel, LVIS_SELECTED, LVIS_SELECTED );// CheckDlgButton( IDC_CHK_DHCP_HELP, m_pRtrWizData->m_fShowDhcpHelp );
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);
//this is not an error we send back to the client
return E_FAIL; }
if ( m_pRtrWizData->m_wizType == NewRtrWizData::NewWizardRouterType_VPNandNAT) m_pRtrWizData->m_stNATPrivateInterfaceId = (LPCTSTR) m_listCtrl.GetItemData(iSel); else m_pRtrWizData->m_stPrivateInterfaceId = (LPCTSTR) m_listCtrl.GetItemData(iSel);
// m_pRtrWizData->m_fShowDhcpHelp = IsDlgButtonChecked( IDC_CHK_DHCP_HELP );
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); if ( !m_pRtrWizData->m_fNatUseSimpleServers ) m_pRtrWizData->m_fNatUseExternal = TRUE; 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
// If we are in "VPN and NAT" wizard, use m_stNATPrivateInterfaceId
// else use the m_stPrivateInterfaceId
if (m_pRtrWizData->m_wizType == NewRtrWizData::NewWizardRouterType_VPNandNAT) { m_pRtrWizData->m_ifMap.Lookup(m_pRtrWizData->m_stNATPrivateInterfaceId, pRtrWizIf); } else { 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; BOOL fDhcpHelp = m_pRtrWizData->m_fShowDhcpHelp;
CWaitCursor wait;
if (m_pRtrWizData->m_fTest) return hr; m_pRtrWizData->m_fShowDhcpHelp = FALSE; //Save the Dhcp Flag in a temp va
// 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, RASEDFLAG_NAT);
// 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_dwNewRouterType & NEWWIZ_ROUTER_TYPE_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_pRtrWizData->m_RtrConfigData, m_pRtrWiz->m_spRouter, ( m_pRtrWizData->m_wizType == NewRtrWizData::NewWizardRouterType_VPNandNAT)); AddNATToServer(m_pRtrWizData, &m_pRtrWizData->m_RtrConfigData, m_pRtrWiz->m_spRouter, m_pRtrWizData->m_fCreateDD, FALSE); }
} else { //Disable RRAS
DisableRRAS((TCHAR *)(LPCTSTR)m_pRtrWizData->m_stServerName); }
m_pRtrWizData->m_fShowDhcpHelp = fDhcpHelp;
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_GeneralNAT){ InitWiz97(TRUE, 0, 0);}
BEGIN_MESSAGE_MAP(CNewRtrWizNatFinish, CNewRtrWizFinishPageBase) ON_NOTIFY( NM_CLICK, IDC_HELP_LINK, CNewRtrWizNatFinish::OnHelpClick ) ON_NOTIFY( NM_RETURN, IDC_HELP_LINK, CNewRtrWizNatFinish::OnHelpClick )END_MESSAGE_MAP()
void CNewRtrWizNatFinish::OnHelpClick( NMHDR* pNMHDR, LRESULT* pResult){ if(!pNMHDR || !pResult) return; if((pNMHDR->idFrom != IDC_HELP_LINK) ||((pNMHDR->code != NM_CLICK) && (pNMHDR->code != NM_RETURN))) return; HtmlHelpA(NULL, "RRASconcepts.chm::/sag_RRAS-Ch3_06b.htm", HH_DISPLAY_TOPIC, 0); *pResult = 0;}
BOOL CNewRtrWizNatFinish::OnSetActive(){ CNewRtrWizFinishPageBase::OnSetActive(); RtrWizInterface * pRtrWizIf = NULL; CString sFormat; CString sText; CString sPublicInterfaceName; CString sFirewall;
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); }
//Setup the text that goes in the summary box
m_pRtrWizData->m_ifMap.Lookup(m_pRtrWizData->m_stPublicInterfaceId, pRtrWizIf);
if (pRtrWizIf) sPublicInterfaceName = 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.
sPublicInterfaceName = m_pRtrWizData->m_stPublicInterfaceId; }
CString sIPAddr; CString sIPMask; // 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;
sIPAddr = INET_NTOA(netAddress); sIPMask = pRtrWizIf->m_stMask; } else { // An error! we do not have a private interface
// Just leave things blank
sIPAddr = L"192.168.0.0"; sIPMask = L"255.255.0.0"; }/*
if ( m_pRtrWizData->m_fNatUseExternal ) { sFormat.LoadString(IDS_NAT_A_FINISH_SUMMARY_SIMPLE); sText.Format(sFormat, (m_pRtrWizData->m_fNATEnableFireWall?sFirewall:""), sPublicInterfaceName );
} else {*/ sFirewall.LoadString(IDS_NAT_SUMMARY_BASIC_FIREWALL);
if ( m_pRtrWizData->m_dwExpressType == MPRSNAP_CYS_EXPRESS_NAT ) { sFormat.LoadString(IDS_NAT_EXTERNAL_FINISH_SUMMARY_CYS); sText.Format(sFormat, (m_pRtrWizData->m_fNATEnableFireWall?sFirewall:""), sPublicInterfaceName ); } else { sFormat.LoadString(IDS_NAT_A_FINISH_SUMMARY); sText.Format(sFormat, (m_pRtrWizData->m_fNATEnableFireWall?sFirewall:""), sPublicInterfaceName, sIPAddr, sIPMask ); }
SetDlgItemText(IDC_TXT_NAT_SUMMARY, sText);
// GetDlgItem(IDC_NEWWIZ_CHK_HELP)->SetFocus();
SetFocus(); return TRUE;}
/*---------------------------------------------------------------------------
CNewRtrWizNatFinishExternal ---------------------------------------------------------------------------*/CNewRtrWizNatFinishExternal::CNewRtrWizNatFinishExternal() : CNewRtrWizFinishPageBase(CNewRtrWizNatFinishExternal::IDD, SaveFlag_Advanced, HelpFlag_GeneralNAT){ InitWiz97(TRUE, 0, 0);}
BEGIN_MESSAGE_MAP(CNewRtrWizNatFinishExternal, CNewRtrWizFinishPageBase) ON_NOTIFY( NM_CLICK, IDC_HELP_LINK, CNewRtrWizNatFinishExternal::OnHelpClick ) ON_NOTIFY( NM_RETURN, IDC_HELP_LINK, CNewRtrWizNatFinishExternal::OnHelpClick )END_MESSAGE_MAP()
void CNewRtrWizNatFinishExternal::OnHelpClick( NMHDR* pNMHDR, LRESULT* pResult){ if(!pNMHDR || !pResult) return; if((pNMHDR->idFrom != IDC_HELP_LINK) ||((pNMHDR->code != NM_CLICK) && (pNMHDR->code != NM_RETURN))) return; HtmlHelpA(NULL, "RRASconcepts.chm::/sag_RRAS-Ch3_06b.htm", HH_DISPLAY_TOPIC, 0); *pResult = 0;}
BOOL CNewRtrWizNatFinishExternal::OnSetActive(){ CNewRtrWizFinishPageBase::OnSetActive(); RtrWizInterface * pRtrWizIf = NULL; CString sFormat; CString sText; CString sPublicInterfaceName; CString sFirewall;
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); } //Setup the text that goes in the summary box
m_pRtrWizData->m_ifMap.Lookup(m_pRtrWizData->m_stPublicInterfaceId, pRtrWizIf);
if (pRtrWizIf) sPublicInterfaceName = 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.
sPublicInterfaceName = m_pRtrWizData->m_stPublicInterfaceId; }
sFirewall.LoadString(IDS_NAT_SUMMARY_BASIC_FIREWALL);
if ( m_pRtrWizData->m_dwExpressType == MPRSNAP_CYS_EXPRESS_NAT ) { sFormat.LoadString(IDS_NAT_EXTERNAL_FINISH_SUMMARY_CYS); sText.Format(sFormat, (m_pRtrWizData->m_fNATEnableFireWall?sFirewall:""), sPublicInterfaceName );
} else if ( m_pRtrWizData->m_fNatUseExternal ) { sFormat.LoadString(IDS_NAT_A_FINISH_SUMMARY_SIMPLE); sText.Format(sFormat, (m_pRtrWizData->m_fNATEnableFireWall?sFirewall:""), sPublicInterfaceName );
} else if (FHrOK(m_pRtrWizData->HrIsDHCPRunningOnInterface()) || FHrOK(m_pRtrWizData->HrIsDNSRunningOnInterface()) ) { //
//Dhcp enabled on private interface.
//
sFormat.LoadString(IDS_NAT_EXTERNAL_FINISH_SUMMARY_DHCP_PRIVATE); sText.Format(sFormat, (m_pRtrWizData->m_fNATEnableFireWall?sFirewall:""), sPublicInterfaceName );
} else {
sFormat.LoadString(IDS_NAT_EXTERNAL_FINISH_SUMMARY);
sText.Format(sFormat, (m_pRtrWizData->m_fNATEnableFireWall?sFirewall:""), sPublicInterfaceName );
}
SetDlgItemText(IDC_TXT_NAT_EXTERNAL_FINISH_SUMMARY, sText);
// GetDlgItem(IDC_NEWWIZ_CHK_HELP)->SetFocus();
SetFocus();
return TRUE;}
/*---------------------------------------------------------------------------
CNewRtrWizNatDDError ---------------------------------------------------------------------------*/
CNewRtrWizNatFinishDDError::CNewRtrWizNatFinishDDError() : CNewRtrWizFinishPageBase(CNewRtrWizNatFinishDDError::IDD, SaveFlag_DoNothing, HelpFlag_Nothing){ InitWiz97(TRUE, 0, 0);}
BEGIN_MESSAGE_MAP(CNewRtrWizNatFinishDDError, CNewRtrWizFinishPageBase)END_MESSAGE_MAP()
BOOL CNewRtrWizNatFinishDDError::OnInitDialog(){ CFont font; CWnd * wnd; CNewRtrWizFinishPageBase::OnInitDialog();
font.CreatePointFont( 120, TEXT("Verdana Bold"), NULL);
if(wnd = GetDlgItem(IDC_COMPLETE_ERROR)){ wnd->SetFont(&font); }
return TRUE;}
BOOL CNewRtrWizNatFinishDDError::OnSetActive(){ CNewRtrWizFinishPageBase::OnSetActive(); GetHolder()->SetWizardButtons(PSWIZB_FINISH);
return TRUE;}
/*---------------------------------------------------------------------------
CNewRtrWizRasFinishNeedProtocols Implementation ---------------------------------------------------------------------------*/IMPLEMENT_NEWRTRWIZ_FINISH_PAGE(CNewRtrWizRasFinishNeedProtocols, SaveFlag_DoNothing, HelpFlag_AddProtocol);
/*---------------------------------------------------------------------------
CNewRtrWizRasFinishNeedProtocolsNonLocal Implementation ---------------------------------------------------------------------------*/IMPLEMENT_NEWRTRWIZ_FINISH_PAGE(CNewRtrWizRasFinishNeedProtocolsNonLocal, SaveFlag_DoNothing, HelpFlag_Nothing);
/*---------------------------------------------------------------------------
CNewRtrWizVpnFinishNeedProtocols Implementation ---------------------------------------------------------------------------*/IMPLEMENT_NEWRTRWIZ_FINISH_PAGE(CNewRtrWizVpnFinishNeedProtocols, SaveFlag_DoNothing, HelpFlag_AddProtocol);
/*---------------------------------------------------------------------------
CNewRtrWizVpnFinishNeedProtocolsNonLocal Implementation ---------------------------------------------------------------------------*/IMPLEMENT_NEWRTRWIZ_FINISH_PAGE(CNewRtrWizVpnFinishNeedProtocolsNonLocal, SaveFlag_DoNothing, HelpFlag_Nothing);
/*---------------------------------------------------------------------------
CNewRtrWizRouterFinishNeedProtocols Implementation ---------------------------------------------------------------------------*/IMPLEMENT_NEWRTRWIZ_FINISH_PAGE(CNewRtrWizRouterFinishNeedProtocols, SaveFlag_DoNothing, HelpFlag_AddProtocol);
/*---------------------------------------------------------------------------
CNewRtrWizRouterFinishNeedProtocolsNonLocal Implementation ---------------------------------------------------------------------------*/IMPLEMENT_NEWRTRWIZ_FINISH_PAGE(CNewRtrWizRouterFinishNeedProtocolsNonLocal, SaveFlag_DoNothing, HelpFlag_Nothing);
/*---------------------------------------------------------------------------
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() :CNewRtrWizPageBase(CNewRtrWizAddressing::IDD, CNewRtrWizPageBase::Middle){ InitWiz97(FALSE, IDS_NEWWIZ_ADDRESS_ASSIGNMENT_TITLE, IDS_NEWWIZ_ADDRESS_ASSIGNMENT_SUBTITLE);
}
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;}
/*---------------------------------------------------------------------------
CNewRtrWizAddressPool implementation ---------------------------------------------------------------------------*/CNewRtrWizAddressPool::CNewRtrWizAddressPool() :CNewRtrWizPageBase(CNewRtrWizAddressPool::IDD, CNewRtrWizPageBase::Middle){ InitWiz97(FALSE, IDS_NEWWIZ_ADDRESS_POOL_TITLE, IDS_NEWWIZ_ADDRESS_POOL_SUBTITLE);
}
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); //we dont return this to client
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); }
SetFocus();
}
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);
SetFocus();
}
/*---------------------------------------------------------------------------
CNewRtrWizRadius implementation ---------------------------------------------------------------------------*/CNewRtrWizRadius::CNewRtrWizRadius() :CNewRtrWizPageBase(CNewRtrWizRadius::IDD, CNewRtrWizPageBase::Middle){ InitWiz97(FALSE, IDS_NEWWIZ_USERADIUS_TITLE, IDS_NEWWIZ_USERADIUS_SUBTITLE);}
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;}
/*---------------------------------------------------------------------------
CNewRtrWizRadiusConfig implementation ---------------------------------------------------------------------------*/CNewRtrWizRadiusConfig::CNewRtrWizRadiusConfig() : CNewRtrWizPageBase(IDD_NEWRTRWIZ_RADIUS_CONFIG, CNewRtrWizPageBase::Middle){ InitWiz97(FALSE, IDS_NEWWIZ_RADIUS_CONFIG_TITLE, IDS_NEWWIZ_RADIUS_CONFIG_SUBTITLE);
}
void CNewRtrWizRadiusConfig::DoDataExchange(CDataExchange *pDX){ CNewRtrWizPageBase::DoDataExchange(pDX);}
BEGIN_MESSAGE_MAP(CNewRtrWizRadiusConfig, CNewRtrWizPageBase)END_MESSAGE_MAP()
#define MAX_RADIUS_SRV_LEN 255
/*!--------------------------------------------------------------------------
CNewRtrWizRadiusConfig::OnInitDialog - Author: KennT ---------------------------------------------------------------------------*/BOOL CNewRtrWizRadiusConfig::OnInitDialog(){ CNewRtrWizPageBase::OnInitDialog();
GetDlgItem(IDC_NEWWIZ_EDIT_PRIMARY)->SendMessage(EM_LIMITTEXT, MAX_RADIUS_SRV_LEN, 0L); GetDlgItem(IDC_NEWWIZ_EDIT_SECONDARY)->SendMessage(EM_LIMITTEXT, MAX_RADIUS_SRV_LEN, 0L);
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;}
/*---------------------------------------------------------------------------
CNewRtrWizRasFinishAdvanced Implementation ---------------------------------------------------------------------------*/CNewRtrWizRasFinishAdvanced::CNewRtrWizRasFinishAdvanced() : CNewRtrWizFinishPageBase(CNewRtrWizRasFinishAdvanced::IDD, SaveFlag_Advanced, HelpFlag_GeneralRAS) { InitWiz97(TRUE, 0, 0); } BEGIN_MESSAGE_MAP(CNewRtrWizRasFinishAdvanced, CNewRtrWizFinishPageBase) ON_NOTIFY( NM_CLICK, IDC_HELP_LINK, CNewRtrWizRasFinishAdvanced::OnHelpClick ) ON_NOTIFY( NM_RETURN, IDC_HELP_LINK, CNewRtrWizRasFinishAdvanced::OnHelpClick )END_MESSAGE_MAP()
void CNewRtrWizRasFinishAdvanced::OnHelpClick( NMHDR* pNMHDR, LRESULT* pResult){ if(!pNMHDR || !pResult) return; if((pNMHDR->idFrom != IDC_HELP_LINK) ||((pNMHDR->code != NM_CLICK) && (pNMHDR->code != NM_RETURN))) return; HtmlHelpA(NULL, "RRASconcepts.chm::/sag_RRAS-Ch1_1.htm", HH_DISPLAY_TOPIC, 0); *pResult = 0;}
BOOL CNewRtrWizRasFinishAdvanced::OnSetActive(){ CString sText = L""; CString sFormat; CString sPolicy; CString sPrivateInterfaceName; RtrWizInterface * pRtrWizIf = NULL;
CNewRtrWizFinishPageBase::OnSetActive(); sFormat.LoadString(IDS_RAS_A_FINISH_SUMMARY); if ( m_pRtrWizData->m_fUseRadius ) { sPolicy.LoadString(IDS_VPN_A_FINISH_RADIUS); } else { sPolicy.LoadString(IDS_VPN_A_FINISH_POLICIES); } m_pRtrWizData->m_ifMap.Lookup(m_pRtrWizData->m_stPrivateInterfaceId, pRtrWizIf);
if (pRtrWizIf) sPrivateInterfaceName = 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.
sPrivateInterfaceName = m_pRtrWizData->m_stPrivateInterfaceId; }
sText.Format ( sFormat, sPrivateInterfaceName, sPolicy );
SetDlgItemText(IDC_TXT_RAS_SUMMARY, sText);
DestroyCaret(); return TRUE;}
/*---------------------------------------------------------------------------
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);
/*---------------------------------------------------------------------------
CNewRtrWizNATVpnFinishAdvanced Implementation ---------------------------------------------------------------------------*/CNewRtrWizNATVpnFinishAdvanced::CNewRtrWizNATVpnFinishAdvanced() : CNewRtrWizFinishPageBase(CNewRtrWizNATVpnFinishAdvanced::IDD, SaveFlag_Advanced, HelpFlag_Nothing) { InitWiz97(TRUE, 0, 0); } BEGIN_MESSAGE_MAP(CNewRtrWizNATVpnFinishAdvanced, CNewRtrWizFinishPageBase) ON_NOTIFY( NM_CLICK, IDC_HELP_LINK, CNewRtrWizNATVpnFinishAdvanced::OnHelpClick ) ON_NOTIFY( NM_RETURN, IDC_HELP_LINK, CNewRtrWizNATVpnFinishAdvanced::OnHelpClick )END_MESSAGE_MAP()
void CNewRtrWizNATVpnFinishAdvanced::OnHelpClick( NMHDR* pNMHDR, LRESULT* pResult){ if(!pNMHDR || !pResult) return; if((pNMHDR->idFrom != IDC_HELP_LINK) ||((pNMHDR->code != NM_CLICK) && (pNMHDR->code != NM_RETURN))) return; HtmlHelpA(NULL, "RRASconcepts.chm::/sag_RRAS-Ch1_46.htm", HH_DISPLAY_TOPIC, 0); *pResult = 0;}
BOOL CNewRtrWizNATVpnFinishAdvanced::OnSetActive(){ CString sText = L""; CString sTextNAT;
CString sFormat; CString sPolicy; CString sPrivateInterfaceName; CString sPublicInterfaceName; RtrWizInterface * pRtrWizIf = NULL;
CNewRtrWizFinishPageBase::OnSetActive(); sFormat.LoadString(IDS_RAS_VPN_A_FINISH_SUMMARY); if ( m_pRtrWizData->m_fUseRadius ) { sPolicy.LoadString(IDS_VPN_A_FINISH_RADIUS); } else { sPolicy.LoadString(IDS_VPN_A_FINISH_POLICIES); } m_pRtrWizData->m_ifMap.Lookup(m_pRtrWizData->m_stPublicInterfaceId, pRtrWizIf);
if (pRtrWizIf) sPublicInterfaceName = 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.
sPublicInterfaceName = m_pRtrWizData->m_stPublicInterfaceId; }
m_pRtrWizData->m_ifMap.Lookup(m_pRtrWizData->m_stPrivateInterfaceId, pRtrWizIf);
if (pRtrWizIf) sPrivateInterfaceName = 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.
sPrivateInterfaceName = m_pRtrWizData->m_stPrivateInterfaceId; }
sText.Format ( sFormat, sPublicInterfaceName, sPrivateInterfaceName, sPolicy );
CString sIPAddr; CString sIPMask;
// Now generate the NAT related information
// Get the information for the private interface
m_pRtrWizData->m_ifMap.Lookup(m_pRtrWizData->m_stNATPrivateInterfaceId, 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;
sIPAddr = INET_NTOA(netAddress); sIPMask = pRtrWizIf->m_stMask; } else { // An error! we do not have a private interface
// Just leave things blank
sIPAddr = L"192.168.0.0"; sIPMask = L"255.255.0.0"; }
sFormat.LoadString(IDS_NAT_A_FINISH_SUMMARY); sTextNAT.Format(sFormat, "", sPublicInterfaceName, sIPAddr, sIPMask ); sText = sText + L"\r\n" + sTextNAT; SetDlgItemText(IDC_TXT_NAT_VPN_SUMMARY, sText);
return TRUE;}
/*---------------------------------------------------------------------------
CNewRtrWizRASVpnFinishAdvanced Implementation ---------------------------------------------------------------------------*/CNewRtrWizRASVpnFinishAdvanced::CNewRtrWizRASVpnFinishAdvanced() : CNewRtrWizFinishPageBase(CNewRtrWizRASVpnFinishAdvanced::IDD, SaveFlag_Advanced, HelpFlag_UserAccounts) { InitWiz97(TRUE, 0, 0);}
BEGIN_MESSAGE_MAP(CNewRtrWizRASVpnFinishAdvanced, CNewRtrWizFinishPageBase) ON_NOTIFY( NM_CLICK, IDC_HELP_LINK, CNewRtrWizRASVpnFinishAdvanced::OnHelpClick ) ON_NOTIFY( NM_RETURN, IDC_HELP_LINK, CNewRtrWizRASVpnFinishAdvanced::OnHelpClick )END_MESSAGE_MAP()
void CNewRtrWizRASVpnFinishAdvanced::OnHelpClick( NMHDR* pNMHDR, LRESULT* pResult){ if(!pNMHDR || !pResult) return; if((pNMHDR->idFrom != IDC_HELP_LINK) ||((pNMHDR->code != NM_CLICK) && (pNMHDR->code != NM_RETURN))) return; HtmlHelpA(NULL, "RRASconcepts.chm::/sag_RRAS-Ch1_46.htm", HH_DISPLAY_TOPIC, 0); *pResult = 0;}
BOOL CNewRtrWizRASVpnFinishAdvanced::OnSetActive(){ CString sText = L""; CString sFormat; CString sPolicy; CString sPrivateInterfaceName; CString sPublicInterfaceName; RtrWizInterface * pRtrWizIf = NULL;
CNewRtrWizFinishPageBase::OnSetActive();
sFormat.LoadString(IDS_RAS_VPN_A_FINISH_SUMMARY); if ( m_pRtrWizData->m_fUseRadius ) { sPolicy.LoadString(IDS_VPN_A_FINISH_RADIUS); } else { sPolicy.LoadString(IDS_VPN_A_FINISH_POLICIES); } m_pRtrWizData->m_ifMap.Lookup(m_pRtrWizData->m_stPublicInterfaceId, pRtrWizIf);
if (pRtrWizIf) sPublicInterfaceName = 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.
sPublicInterfaceName = m_pRtrWizData->m_stPublicInterfaceId; }
m_pRtrWizData->m_ifMap.Lookup(m_pRtrWizData->m_stPrivateInterfaceId, pRtrWizIf);
if (pRtrWizIf) sPrivateInterfaceName = 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.
sPrivateInterfaceName = m_pRtrWizData->m_stPrivateInterfaceId; }
sText.Format ( sFormat, sPublicInterfaceName, sPrivateInterfaceName, sPolicy ); SetDlgItemText(IDC_TXT_RAS_VPN_SUMMARY, sText); GetDlgItem(IDC_DUMMY_CONTROL)->SetFocus(); return TRUE;}
/*---------------------------------------------------------------------------
CNewRtrWizVpnFinishAdvanced Implementation ---------------------------------------------------------------------------*/CNewRtrWizVpnFinishAdvanced::CNewRtrWizVpnFinishAdvanced() : CNewRtrWizFinishPageBase(CNewRtrWizVpnFinishAdvanced::IDD, SaveFlag_Advanced, HelpFlag_UserAccounts) { InitWiz97(TRUE, 0, 0); } BEGIN_MESSAGE_MAP(CNewRtrWizVpnFinishAdvanced, CNewRtrWizFinishPageBase) ON_NOTIFY( NM_CLICK, IDC_HELP_LINK, CNewRtrWizVpnFinishAdvanced::OnHelpClick ) ON_NOTIFY( NM_RETURN, IDC_HELP_LINK, CNewRtrWizVpnFinishAdvanced::OnHelpClick )END_MESSAGE_MAP()
void CNewRtrWizVpnFinishAdvanced::OnHelpClick( NMHDR* pNMHDR, LRESULT* pResult){ if(!pNMHDR || !pResult) return; if((pNMHDR->idFrom != IDC_HELP_LINK) ||((pNMHDR->code != NM_CLICK) && (pNMHDR->code != NM_RETURN))) return; HtmlHelpA(NULL, "RRASconcepts.chm::/sag_RRAS-Ch1_46.htm", HH_DISPLAY_TOPIC, 0); *pResult = 0;}
BOOL CNewRtrWizVpnFinishAdvanced::OnSetActive(){ CString sText = L""; CString sFormat; CString sPolicy; CString sPrivateInterfaceName; CString sPublicInterfaceName; RtrWizInterface * pRtrWizIf = NULL;
CNewRtrWizFinishPageBase::OnSetActive(); sFormat.LoadString(IDS_VPN_A_FINISH_SUMMARY); if ( m_pRtrWizData->m_fUseRadius ) { sPolicy.LoadString(IDS_VPN_A_FINISH_RADIUS); } else { sPolicy.LoadString(IDS_VPN_A_FINISH_POLICIES); } m_pRtrWizData->m_ifMap.Lookup(m_pRtrWizData->m_stPublicInterfaceId, pRtrWizIf);
if (pRtrWizIf) sPublicInterfaceName = 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.
sPublicInterfaceName = m_pRtrWizData->m_stPublicInterfaceId; }
m_pRtrWizData->m_ifMap.Lookup(m_pRtrWizData->m_stPrivateInterfaceId, pRtrWizIf);
if (pRtrWizIf) sPrivateInterfaceName = 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.
sPrivateInterfaceName = m_pRtrWizData->m_stPrivateInterfaceId; }
sText.Format ( sFormat, sPublicInterfaceName, sPrivateInterfaceName, sPolicy ); SetDlgItemText(IDC_TXT_VPN_SUMMARY, sText);// GetDlgItem(IDC_NEWWIZ_CHK_HELP)->SetFocus();
SetFocus(); return TRUE;}
/*---------------------------------------------------------------------------
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_CHK_ENABLE_SECURITY, OnButtonClick)ON_NOTIFY( NM_CLICK, IDC_HELP_LINK, CNewRtrWizVpnSelectPublic::OnHelpClick )ON_NOTIFY( NM_RETURN, IDC_HELP_LINK, CNewRtrWizVpnSelectPublic::OnHelpClick )//}}AFX_MSG_MAP
END_MESSAGE_MAP()
void CNewRtrWizVpnSelectPublic::OnHelpClick( NMHDR* pNMHDR, LRESULT* pResult){ if(!pNMHDR || !pResult) return; if((pNMHDR->idFrom != IDC_HELP_LINK) ||((pNMHDR->code != NM_CLICK) && (pNMHDR->code != NM_RETURN))) return; HtmlHelpA(NULL, "RRASconcepts.chm::/mpr_und_interfaces.htm", HH_DISPLAY_TOPIC, 0); *pResult = 0;}
/*!--------------------------------------------------------------------------
CNewRtrWizVpnSelectPublic::OnInitDialog - Author: KennT ---------------------------------------------------------------------------*/BOOL CNewRtrWizVpnSelectPublic::OnInitDialog(){ AFX_MANAGE_STATE(AfxGetStaticModuleState( )); CString st;
CNewRtrWizPageBase::OnInitDialog();
// Setup the dialog and add the NICs
m_pRtrWizData->m_fSetVPNFilter = TRUE;
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
CheckDlgButton(IDC_CHK_ENABLE_SECURITY, m_pRtrWizData-> m_fSetVPNFilter );
//
//Preselect an interface if there is no public interface yet
//
if( m_pRtrWizData->m_stPublicInterfaceId.IsEmpty() ) m_listCtrl.SetItemState(0, LVIS_SELECTED, LVIS_SELECTED ); return TRUE;}
BOOL CNewRtrWizVpnSelectPublic::OnSetActive(){ CNewRtrWizPageBase::OnSetActive();
if(m_pRtrWizData->m_wizType == NewRtrWizData::NewWizardRouterType_VPNandNAT) { CString st; st.LoadString(IDS_BASIC_FIREWALL); SetDlgItemText(IDC_CHK_ENABLE_SECURITY, st); st.LoadString(IDS_BASIC_FIREWALL_TEXT); SetDlgItemText(IDC_VPN_PUBLIC_TEXT, st); } else { CString st; st.LoadString(IDS_STATIC_FILTER); SetDlgItemText(IDC_CHK_ENABLE_SECURITY, st); st.LoadString(IDS_STATIC_FILTER_TEXT); SetDlgItemText(IDC_VPN_PUBLIC_TEXT, st); }
return TRUE;}
void CNewRtrWizVpnSelectPublic::OnButtonClick(){ m_pRtrWizData->m_fSetVPNFilter = IsDlgButtonChecked(IDC_CHK_ENABLE_SECURITY); }
HRESULT CNewRtrWizVpnSelectPublic::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_stPublicInterfaceId = (LPCTSTR) m_listCtrl.GetItemData(iSel);
if ( m_pRtrWizData->m_wizType == NewRtrWizData::NewWizardRouterType_VPNandNAT ) { m_pRtrWizData->m_fNATEnableFireWall = m_pRtrWizData->m_fSetVPNFilter; }
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 ---------------------------------------------------------------------------*/CNewRtrWizRouterFinish::CNewRtrWizRouterFinish () : CNewRtrWizFinishPageBase(CNewRtrWizRouterFinish::IDD, SaveFlag_Advanced, HelpFlag_Nothing) { InitWiz97(TRUE, 0, 0); }
BEGIN_MESSAGE_MAP(CNewRtrWizRouterFinish, CNewRtrWizFinishPageBase) END_MESSAGE_MAP()
BOOL CNewRtrWizRouterFinish::OnSetActive (){ CString sText; CNewRtrWizFinishPageBase::OnSetActive(); sText.LoadString(IDS_ROUTER_FINISH_DD_SUMMARY); SetDlgItemText(IDC_TXT_ROUTER_FINISH_SUMMARY, sText); return TRUE;}
/*---------------------------------------------------------------------------
CNewRtrWizRouterFinishDD Implementation ---------------------------------------------------------------------------*/
CNewRtrWizRouterFinishDD::CNewRtrWizRouterFinishDD () : CNewRtrWizFinishPageBase(CNewRtrWizRouterFinishDD::IDD, SaveFlag_Advanced, HelpFlag_DemandDial) { InitWiz97(TRUE, 0, 0); }
BEGIN_MESSAGE_MAP(CNewRtrWizRouterFinishDD, CNewRtrWizFinishPageBase) ON_NOTIFY( NM_CLICK, IDC_HELP_LINK, CNewRtrWizRouterFinishDD::OnHelpClick ) ON_NOTIFY( NM_RETURN, IDC_HELP_LINK, CNewRtrWizRouterFinishDD::OnHelpClick )END_MESSAGE_MAP()
void CNewRtrWizRouterFinishDD::OnHelpClick( NMHDR* pNMHDR, LRESULT* pResult){ if(!pNMHDR || !pResult) return; if((pNMHDR->idFrom != IDC_HELP_LINK) ||((pNMHDR->code != NM_CLICK) && (pNMHDR->code != NM_RETURN))) return; HtmlHelpA(NULL, "RRASconcepts.chm::/sag_RRAS-Ch3_08d.htm", HH_DISPLAY_TOPIC, 0); *pResult = 0;}
BOOL CNewRtrWizRouterFinishDD::OnSetActive (){ CString sText; CNewRtrWizFinishPageBase::OnSetActive(); sText.LoadString(IDS_ROUTER_FINISH_DD_SUMMARY); SetDlgItemText(IDC_TXT_ROUTER_FINISH_DD_SUMMARY, sText); return TRUE;}
/*---------------------------------------------------------------------------
CNewRtrWizManualFinish Implementation ---------------------------------------------------------------------------*/
CNewRtrWizManualFinish::CNewRtrWizManualFinish () : CNewRtrWizFinishPageBase(CNewRtrWizManualFinish ::IDD, SaveFlag_Advanced, HelpFlag_Nothing) { InitWiz97(TRUE, 0, 0); } BEGIN_MESSAGE_MAP(CNewRtrWizManualFinish, CNewRtrWizFinishPageBase) END_MESSAGE_MAP()
BOOL CNewRtrWizManualFinish ::OnSetActive(){ CString sText = L""; CString sTemp = L""; CString sBullet = L""; WCHAR * pwszLineBreak = L"\r\n"; //
//Check to see which options are set and based on that,
//make the display message
//
CNewRtrWizFinishPageBase::OnSetActive(); if ( m_pRtrWizData->m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_VPN ) { sText += sBullet; sTemp.LoadString(IDS_SUMMARY_VPN_ACCESS); sText += sTemp; sText += pwszLineBreak; }
if ( m_pRtrWizData->m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_DIALUP ) { sText += sBullet; sTemp.LoadString(IDS_SUMMARY_DIALUP_ACCESS); sText += sTemp; sText += pwszLineBreak; }
if ( m_pRtrWizData->m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_DOD ) { sText += sBullet; sTemp.LoadString(IDS_SUMMARY_DEMAND_DIAL); sText += sTemp; sText += pwszLineBreak; }
if ( m_pRtrWizData->m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_NAT ) { sText += sBullet; sTemp.LoadString(IDS_SUMMARY_NAT); sText += sTemp; } if ( m_pRtrWizData->m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_BASIC_FIREWALL ) { //kmurthy: this should always come with type NAT
sTemp.LoadString(IDS_SUMMARY_BASIC_FIREWALL); sText += sTemp; sText += pwszLineBreak; } if ( m_pRtrWizData->m_dwNewRouterType & NEWWIZ_ROUTER_TYPE_LAN_ROUTING ) { sText += sBullet; sTemp.LoadString(IDS_SUMMARY_LAN_ROUTING); sText += sTemp; sText += pwszLineBreak; } SetDlgItemText(IDC_TXT_SUMMARY, sText); GetDlgItem(IDC_STATIC_DUMMY)->SetFocus(); return TRUE;}
CRasWarning::CRasWarning(char * helpTopic, int strId, CWnd* pParent /*=NULL*/) :CDialog(CRasWarning::IDD, pParent){ m_helpTopic = helpTopic; m_strId = strId;}
void CRasWarning::DoDataExchange(CDataExchange* pDX){ CDialog::DoDataExchange(pDX);}
BEGIN_MESSAGE_MAP(CRasWarning, CDialog) //{{AFX_MSG_MAP(CDhcp)
ON_BN_CLICKED(ID_OK, OnOkBtn) ON_BN_CLICKED(ID_HELP_BTN, OnHelpBtn) //}}AFX_MSG_MAP
END_MESSAGE_MAP()
BOOL CRasWarning::OnInitDialog(){ CString stText; CDialog::OnInitDialog();
stText.LoadString(m_strId); SetDlgItemText(IDC_RAS_WARNING, stText); return TRUE;}
void CRasWarning::OnOkBtn(){ CDialog::OnOK();}
void CRasWarning::OnHelpBtn(){ if(m_helpTopic) HtmlHelpA(NULL, m_helpTopic, HH_DISPLAY_TOPIC, 0); CDialog::OnOK();}
//This function disables RRAS on the server(basically what cliking Disable RRAs on menu does)
HRESULT DisableRRAS(TCHAR * szMachineName){ AFX_MANAGE_STATE(AfxGetStaticModuleState()); DWORD dwErr = ERROR_SUCCESS; RtrConfigData wizData; NewRtrWizData rtrWizData; IRouterInfo * pRouterInfo = NULL; TCHAR szLocalName[MAX_COMPUTERNAME_LENGTH + 1] ={0}; DWORD dw = MAX_COMPUTERNAME_LENGTH; GUID guidConfig = GUID_RouterNull; IRouterProtocolConfig * spRouterConfig = NULL; IRtrMgrProtocolInfo * spRmProt = NULL; RtrMgrProtocolCB RmProtCB; CWaitCursor wait; HRESULT hr = hrOK; RouterVersionInfo RVI;
if(!szMachineName || szMachineName[0] == 0){ //Get local Machine Name
GetComputerName ( szLocalName, &dw ); szMachineName = szLocalName; }
//Create the RouterInfo
hr = CreateRouterInfo(&pRouterInfo, NULL, szMachineName); Assert(pRouterInfo != NULL);
// Stop the router service
hr = StopRouterService((LPCTSTR) szMachineName); if (!FHrSucceeded(hr)) { AddHighLevelErrorStringId(IDS_ERR_COULD_NOT_REMOVE_ROUTER); CORg(hr); }
//
//Do some of the SecureRouterInfo functionality here
//
CORg(InitiateServerConnection(szMachineName, NULL, FALSE, pRouterInfo));
CORg(pRouterInfo->Load(T2COLE(szMachineName), NULL)); { USES_CONVERSION; if(S_OK == pRouterInfo->GetRouterVersionInfo(&RVI) && RVI.dwRouterVersion >= 5) { hr = RRASDelRouterIdObj(T2W(szMachineName)); Assert(hr == S_OK); } }
// Windows NT Bug : 389469
// This is hardcoded for NAT (not to change too much).
// Find the config GUID for NAT, and then remove the protocol.
hr = LookupRtrMgrProtocol(pRouterInfo, PID_IP, MS_IP_NAT, &spRmProt); // If the lookup returns S_FALSE, then it couldn't find the
// protocol.
if (FHrOK(hr)) { spRmProt->CopyCB(&RmProtCB); CORg( CoCreateProtocolConfig(RmProtCB.guidConfig, pRouterInfo, PID_IP, MS_IP_NAT, &spRouterConfig) ); if (spRouterConfig) hr = spRouterConfig->RemoveProtocol(pRouterInfo->GetMachineName(), PID_IP, MS_IP_NAT, NULL, 0, pRouterInfo, 0); } // Perform any removal/cleanup action
UninstallGlobalSettings(szMachineName, pRouterInfo, RVI.dwRouterVersion == 4, TRUE);
// Remove the router from the domain
if (pRouterInfo->GetRouterType() != ROUTER_TYPE_LAN) RegisterRouterInDomain(szMachineName, FALSE); // Disable the service
SetRouterServiceStartType((LPCTSTR) szMachineName, SERVICE_DISABLED);
//
// Bug 519414
// Since IAS now has a Microsoft policy with the appropriate settings,
// there is no longer a single default policy. In addition there is
// no need to update any policy to have the required settings since the
// Microsoft VPN server policy does the job.
//
#if __DEFAULT_POLICY
//Now update the default policy
CORg( UpdateDefaultPolicy(szMachineName, FALSE, FALSE, 0 ) );
#endif
Error: if (!FHrSucceeded(hr)) { AddSystemErrorMessage(hr); }
return hr; }
/*!--------------------------------------------------------------------------
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;
if(flags == RASEDFLAG_NAT) info.dwFlags |= RASEDFLAG_NAT;
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);
// ok, setup the public interface
Assert(pWizData->m_stPublicInterfaceId.IsEmpty()); pWizData->m_stPublicInterfaceId = spIf->GetTitle();
HANDLE hMachine = INVALID_HANDLE_VALUE; HKEY hkeyMachine = NULL; RouterVersionInfo routerversion; InfoBlock * pBlock;
DWORD dwErr = ::MprConfigServerConnect((LPWSTR)pszServerName, &hMachine);
if(dwErr != NOERROR || hMachine == INVALID_HANDLE_VALUE) goto Error;
if (ERROR_SUCCESS == ConnectRegistry(pszServerName, &hkeyMachine)) QueryRouterVersionInfo(hkeyMachine, &routerversion); else routerversion.dwRouterVersion = 5;
if (hkeyMachine) DisconnectRegistry(hkeyMachine);
// Get the IP_ROUTE_INFO block from the interface
spInfoBase->GetBlock(IP_ROUTE_INFO, &pBlock, 0);
//
//Add static routes here if any
//
SROUTEINFOLIST * pSRouteList = (SROUTEINFOLIST * )info.reserved; MIB_IPFORWARDROW * pForwardRow = NULL; MIB_IPFORWARDROW * pRoute = NULL; DWORD dwItemCount = 0;
while ( pSRouteList ) { LPVOID pTemp;
dwItemCount ++; if ( pForwardRow == NULL ) { pTemp = LocalAlloc(LPTR, sizeof(MIB_IPFORWARDROW)); } else { pTemp = LocalReAlloc(pForwardRow , sizeof(MIB_IPFORWARDROW) * dwItemCount, LMEM_ZEROINIT|LMEM_MOVEABLE); }
if(pTemp) { pForwardRow = (MIB_IPFORWARDROW *)pTemp; pRoute = pForwardRow + ( dwItemCount - 1 );
pRoute->dwForwardDest = INET_ADDR(pSRouteList->RouteInfo.pszDestIP); pRoute->dwForwardMask = INET_ADDR(pSRouteList->RouteInfo.pszNetworkMask); pRoute->dwForwardMetric1 = _ttol(pSRouteList->RouteInfo.pszMetric ); pRoute->dwForwardMetric5 = RTM_VIEW_MASK_UCAST | RTM_VIEW_MASK_MCAST; pRoute->dwForwardNextHop = 0;
if (routerversion.dwRouterVersion < 5) pRoute->dwForwardProto = PROTO_IP_LOCAL; else pRoute->dwForwardProto = PROTO_IP_NT_STATIC; } else { dwItemCount--; }
//Free all the entry items
pTemp = pSRouteList->pNext; GlobalFree(pSRouteList->RouteInfo.pszDestIP); GlobalFree(pSRouteList->RouteInfo.pszNetworkMask); GlobalFree(pSRouteList->RouteInfo.pszMetric); GlobalFree(pSRouteList); pSRouteList = (SROUTEINFOLIST *)pTemp; } if ( dwItemCount ) { CORg( AddStaticRoute(pForwardRow, spInfoBase, pBlock, dwItemCount) ); LocalFree(pForwardRow); }
// Save this back to the IP RmIf
RouterEntrySaveInfoBase(pszServerName, spIf->GetId(), spInfoBase, PID_IP);
// disconnect it
if(hMachine != INVALID_HANDLE_VALUE) { ::MprAdminServerDisconnect(hMachine); } } 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); }
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 Error; dwErr = regkey.SetValue ( REGISTRATION_ENABLED, dw ); if ( ERROR_SUCCESS != dwErr ) goto Error;
dwErr = regkey.Close(); if ( ERROR_SUCCESS != dwErr ) goto Error;
//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 Error;
dw = REGVAL_DISABLE_NETBT; dwErr = regkey.SetValue ( REGVAL_NETBIOSOPTIONS_W, dw ); if ( ERROR_SUCCESS != dwErr ) goto Error; CWRg(dwErr);Error:
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_rgVpnInputFilters[] ={ // GRE PPTP filter (protocol ID 47)
{ 0, 0, 0, 0, 47, 0, 0, 0 },
// PPTP filter (source port 1723), TCP established (0x40)
{ 0, 0, 0, 0, FILTER_PROTO_TCP, 0x40, 1723, 0 },
// PPTP filter (dest port 1723)
{ 0, 0, 0, 0, FILTER_PROTO_TCP, 0, 0, 1723 },
// IKE filter (dest port = 500)
{ 0, 0, 0, 0, FILTER_PROTO_UDP, 0, 0, 500 },
// L2TP filter (dest port = 1701)
{ 0, 0, 0, 0, FILTER_PROTO_UDP, 0, 0, 1701 },
// IKE NAT-T filter (dest port = 4500)
{ 0, 0, 0, 0, FILTER_PROTO_UDP, 0, 0, 4500 } };
static const FILTER_INFO s_rgVpnOutputFilters[] ={ // GRE 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 },
// IKE filter (source port = 500)
{ 0, 0, 0, 0, FILTER_PROTO_UDP, 0, 500, 0 },
// L2TP filter (source port = 1701
{ 0, 0, 0, 0, FILTER_PROTO_UDP, 0, 1701, 0 },
// IKE NAT-T filter (source port = 4500)
{ 0, 0, 0, 0, FILTER_PROTO_UDP, 0, 4500, 0 }
};
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 for input filters
// ----------------------------------------------------------------
// Calculate the size needed
// ----------------------------------------------------------------
cFilters = DimensionOf(s_rgVpnInputFilters);
// 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_rgVpnInputFilters[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) );
delete [] pData;
// output filters
// ----------------------------------------------------------------
// Setup the data structure for output filters
// ----------------------------------------------------------------
// Calculate the size needed
// ----------------------------------------------------------------
cFilters = DimensionOf(s_rgVpnOutputFilters);
// 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_rgVpnOutputFilters[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;}
HRESULT WINAPI SetupWithCYS (DWORD dwType, PVOID * pOutData){ AFX_MANAGE_STATE(AfxGetStaticModuleState()); IRemoteNetworkConfig * spNetwork; IRouterInfo * spRouterInfo; COSERVERINFO csi; COAUTHINFO cai; COAUTHIDENTITY caid; IUnknown * punk = NULL; CNewRtrWiz * pRtrWiz = NULL; HRESULT hr = hrOK; TCHAR szMachineName[MAX_COMPUTERNAME_LENGTH + 1] ={0}; CString strRtrWizTitle; DWORD dw = MAX_COMPUTERNAME_LENGTH; NewRtrWizData * pRtrWizData = NULL;
if ( MPRSNAP_CYS_EXPRESS_NAT != dwType && MPRSNAP_CYS_EXPRESS_NONE != dwType ) { hr = HResultFromWin32(ERROR_INVALID_PARAMETER); goto Error; }
hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE); if (FAILED(hr) && (RPC_E_CHANGED_MODE != hr)) { return hr; }
//Get Machine Name
GetComputerName ( szMachineName, &dw );
//Create the RouterInfo
hr = CreateRouterInfo(&spRouterInfo, NULL, szMachineName); Assert(spRouterInfo != NULL);
ZeroMemory(&csi, sizeof(csi)); ZeroMemory(&cai, sizeof(cai)); ZeroMemory(&caid, sizeof(caid));
csi.pAuthInfo = &cai; cai.pAuthIdentityData = &caid;
hr = CoCreateRouterConfig(szMachineName, 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(); } else { goto Error; }
//
//Do some of the SecureRouterInfo functionality here
//
hr = InitiateServerConnection(szMachineName, NULL, FALSE, spRouterInfo); if (!FHrOK(hr)) { // though this case when user chooses cancel on user/password dlg,
// this is considered as FAIL to connect
if (hr == S_FALSE) hr = HResultFromWin32(ERROR_CANCELLED); goto Error; }
hr = spRouterInfo->Load(T2COLE(szMachineName), NULL);
if ( hrOK != hr ) { goto Error; }
//If ICS/ICF/IC is enabled, then do not allow RRAS to be configured
if(IsIcsIcfIcEnabled(spRouterInfo)){ hr = HResultFromWin32(ERROR_CANCELLED); goto Error; }
//Create a new router wizard and show it here
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
//
//we dont have to free handles. MMC does it for us
//
pRtrWiz = new CNewRtrWiz(NULL, spRouterInfo, NULL, NULL, strRtrWizTitle, FALSE, MPRSNAP_CYS_EXPRESS_NAT);
hr = pRtrWiz->Init( spRouterInfo->GetMachineName() ); if ( hrOK != hr ) { hr = S_FALSE; goto Error; } else { hr = pRtrWiz->DoModalWizard(); //
//now if the error is S_OK then
//send the interface information back to cys
//
if ( hrOK == hr ) { //get the interface id and send it back
if ( MPRSNAP_CYS_EXPRESS_NAT == dwType ) { pRtrWizData = pRtrWiz->GetWizData(); //
//get the private interface id
//and send it back to CYS
//$TODO: Find a better way of doing this
//
//ppvoid that comes in get's the private interface back if any
//
if ( !pRtrWizData->m_stPrivateInterfaceId.IsEmpty() ) { *pOutData = LocalAlloc(LPTR, (pRtrWizData->m_stPrivateInterfaceId.GetLength()+ 1) * sizeof(WCHAR) ); if ( NULL == *pOutData ) { hr = E_OUTOFMEMORY; goto Error; } lstrcpy ( (LPTSTR)(*pOutData), (LPTSTR)(LPCTSTR)pRtrWizData->m_stPrivateInterfaceId ); } } } }Error: if ( spNetwork ) spNetwork->Release();
if ( spRouterInfo) spRouterInfo->Release(); if ( csi.pAuthInfo && csi.pAuthInfo->pAuthIdentityData->Password ) { delete csi.pAuthInfo->pAuthIdentityData->Password; } if (pRtrWiz) delete pRtrWiz; CoUninitialize(); return hr;}
|
