You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
634 lines
18 KiB
634 lines
18 KiB
//+---------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1997.
|
|
//
|
|
// File: R A S A F . C P P
|
|
//
|
|
// Contents: RAS Answer File objects.
|
|
//
|
|
// Notes:
|
|
//
|
|
// Author: shaunco 19 Apr 1997
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
#include "pch.h"
|
|
#pragma hdrstop
|
|
#include "ncipaddr.h"
|
|
#include "ncmisc.h"
|
|
#include "ncreg.h"
|
|
#include "ncsetup.h"
|
|
#include "rasaf.h"
|
|
#include "rasobj.h"
|
|
|
|
extern const WCHAR c_szAfAppleTalk[];
|
|
extern const WCHAR c_szAfAutoNetworkNumbers[];
|
|
extern const WCHAR c_szAfClientCanReqIpaddr[];
|
|
extern const WCHAR c_szAfClientReqNodeNumber[];
|
|
extern const WCHAR c_szAfDialinProtocols[];
|
|
extern const WCHAR c_szAfForceEncryptedData[];
|
|
extern const WCHAR c_szAfForceStrongEncryption[];
|
|
extern const WCHAR c_szAfForceEncryptedPassword[];
|
|
extern const WCHAR c_szAfWanNetPoolSize[];
|
|
extern const WCHAR c_szAfIpAddressStart[];
|
|
extern const WCHAR c_szAfIpAddressEnd[];
|
|
extern const WCHAR c_szAfIpxClientAccess[];
|
|
extern const WCHAR c_szAfIpx[];
|
|
extern const WCHAR c_szAfL2tpMaxVcs[];
|
|
extern const WCHAR c_szAfL2tpEndpoints[];
|
|
extern const WCHAR c_szAfMultilink[];
|
|
extern const WCHAR c_szAfNetNumberFrom[];
|
|
extern const WCHAR c_szAfNetbeuiClientAccess[];
|
|
extern const WCHAR c_szAfNetbeui[];
|
|
extern const WCHAR c_szAfNetwork[];
|
|
extern const WCHAR c_szAfParamsSection[];
|
|
extern const WCHAR c_szAfPptpEndpoints[];
|
|
extern const WCHAR c_szAfRouterType[];
|
|
extern const WCHAR c_szAfSecureVPN[];
|
|
extern const WCHAR c_szAfSetDialinUsage[];
|
|
extern const WCHAR c_szAfSameNetworkNumber[];
|
|
extern const WCHAR c_szAfTcpipClientAccess[];
|
|
extern const WCHAR c_szAfTcpip[];
|
|
extern const WCHAR c_szAfThisComputer[];
|
|
extern const WCHAR c_szAfUseDhcp[];
|
|
|
|
extern const WCHAR c_szInfId_MS_L2tpMiniport[];
|
|
extern const WCHAR c_szInfId_MS_PptpMiniport[];
|
|
extern const WCHAR c_szInfId_MS_PppoeMiniport[];
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
// CRasSrvAnswerFileData
|
|
//
|
|
HRESULT
|
|
CRasSrvAnswerFileData::HrOpenAndRead (
|
|
PCWSTR pszAnswerFile,
|
|
PCWSTR pszAnswerSection)
|
|
{
|
|
// Open the answer file. It will close itself in it's destructor.
|
|
CSetupInfFile inf;
|
|
UINT unErrorLine;
|
|
|
|
HRESULT hr = inf.HrOpen (
|
|
pszAnswerFile, NULL,
|
|
INF_STYLE_OLDNT | INF_STYLE_WIN4,
|
|
&unErrorLine);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
m_fRouterTypeSpecified = FALSE;
|
|
m_fSetUsageToDialin = FALSE;
|
|
|
|
// Prepare the default values for use when we fail to read.
|
|
// Initializing with defaults also helps to gaurantee that bogus
|
|
// values aren't used when we add items to the structure but fail
|
|
// to provide answer file support for them.
|
|
//
|
|
m_dataSrvCfg.GetDefault ();
|
|
m_dataSrvIp .GetDefault ();
|
|
m_dataSrvIpx.GetDefault ();
|
|
m_dataSrvNbf.GetDefault ();
|
|
|
|
DATA_SRV_CFG defSrvCfg = m_dataSrvCfg;
|
|
DATA_SRV_IP defSrvIp = m_dataSrvIp;
|
|
DATA_SRV_IPX defSrvIpx = m_dataSrvIpx;
|
|
DATA_SRV_NBF defSrvNbf = m_dataSrvNbf;
|
|
|
|
// Get the real parameter section.
|
|
//
|
|
tstring strSection;
|
|
hr = inf.HrGetString (pszAnswerSection,
|
|
c_szAfParamsSection, &strSection);
|
|
if (FAILED(hr))
|
|
{
|
|
// If we failed to find the parameter section, just try
|
|
// this one.
|
|
//
|
|
strSection = pszAnswerSection;
|
|
}
|
|
|
|
static const MAP_SZ_DWORD c_mapProtocols [] =
|
|
{
|
|
{ c_szAfTcpip, RPI_IP },
|
|
{ c_szAfIpx, RPI_IPX },
|
|
{ c_szAfNetbeui, RPI_NBF },
|
|
{ c_szAfAppleTalk, RPI_ATALK },
|
|
};
|
|
// Read the list of dial-in protocols.
|
|
//
|
|
hr = inf.HrGetMultiSzMapToDword (strSection.c_str(),
|
|
c_szAfDialinProtocols,
|
|
c_mapProtocols,
|
|
celems (c_mapProtocols),
|
|
&m_dwDialInProtocolIds);
|
|
if (FAILED(hr) || !m_dwDialInProtocolIds)
|
|
{
|
|
// If its not there, use all possible.
|
|
m_dwDialInProtocolIds = RPI_ALL;
|
|
}
|
|
|
|
hr = inf.HrGetStringAsBool (strSection.c_str(),
|
|
c_szAfMultilink,
|
|
&m_dataSrvCfg.fMultilink);
|
|
if (FAILED(hr))
|
|
{
|
|
m_dataSrvCfg.fMultilink = defSrvCfg.fMultilink;
|
|
}
|
|
|
|
hr = inf.HrGetDword(strSection.c_str(),
|
|
c_szAfRouterType,
|
|
(DWORD*)&m_dataSrvCfg.dwRouterType);
|
|
if (FAILED(hr))
|
|
{
|
|
m_dataSrvCfg.dwRouterType = defSrvCfg.dwRouterType;
|
|
}
|
|
else
|
|
{
|
|
m_fRouterTypeSpecified = TRUE;
|
|
}
|
|
|
|
hr = inf.HrGetDword (strSection.c_str(),
|
|
c_szAfForceEncryptedPassword,
|
|
&m_dataSrvCfg.dwAuthLevel);
|
|
if (FAILED(hr))
|
|
{
|
|
m_dataSrvCfg.dwAuthLevel = defSrvCfg.dwAuthLevel;
|
|
}
|
|
|
|
hr = inf.HrGetStringAsBool (strSection.c_str(),
|
|
c_szAfForceEncryptedData,
|
|
&m_dataSrvCfg.fDataEnc);
|
|
if (FAILED(hr))
|
|
{
|
|
m_dataSrvCfg.fDataEnc = defSrvCfg.fDataEnc;
|
|
}
|
|
|
|
hr = inf.HrGetStringAsBool (strSection.c_str(),
|
|
c_szAfForceStrongEncryption,
|
|
&m_dataSrvCfg.fStrongDataEnc);
|
|
if (FAILED(hr))
|
|
{
|
|
m_dataSrvCfg.fStrongDataEnc = defSrvCfg.fStrongDataEnc;
|
|
}
|
|
|
|
hr = inf.HrGetDword (strSection.c_str(),
|
|
c_szAfSecureVPN,
|
|
&m_dataSrvCfg.dwSecureVPN);
|
|
if (FAILED(hr))
|
|
{
|
|
m_dataSrvCfg.dwSecureVPN = defSrvCfg.dwSecureVPN;
|
|
}
|
|
|
|
// pmay: 251736
|
|
// Discover whether we are to set all port usage to 'dialin'
|
|
//
|
|
DWORD dwSetUsageToDialin;
|
|
|
|
hr = inf.HrGetDword(strSection.c_str(),
|
|
c_szAfSetDialinUsage,
|
|
&dwSetUsageToDialin);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
m_fSetUsageToDialin = !!dwSetUsageToDialin;
|
|
}
|
|
|
|
static const MAP_SZ_DWORD c_mapNetworkAccess [] =
|
|
{
|
|
{ c_szAfNetwork, TRUE },
|
|
{ c_szAfThisComputer, FALSE },
|
|
};
|
|
|
|
// Read the IP values.
|
|
//
|
|
m_dataSrvIp.fEnableIn =
|
|
(m_dwDialInProtocolIds & RPI_IP) ? TRUE : FALSE;
|
|
|
|
hr = inf.HrGetStringMapToDword (strSection.c_str(),
|
|
c_szAfTcpipClientAccess,
|
|
c_mapNetworkAccess,
|
|
celems (c_mapNetworkAccess),
|
|
(DWORD*)&m_dataSrvIp.fAllowNetworkAccess);
|
|
if (FAILED(hr))
|
|
{
|
|
m_dataSrvIp.fAllowNetworkAccess = defSrvIp.fAllowNetworkAccess;
|
|
}
|
|
|
|
hr = inf.HrGetStringAsBool (strSection.c_str(),
|
|
c_szAfUseDhcp,
|
|
&m_dataSrvIp.fUseDhcp);
|
|
if (FAILED(hr))
|
|
{
|
|
m_dataSrvIp.fUseDhcp = defSrvIp.fUseDhcp;
|
|
}
|
|
|
|
hr = inf.HrGetStringAsBool (strSection.c_str(),
|
|
c_szAfClientCanReqIpaddr,
|
|
&m_dataSrvIp.fAllowClientAddr);
|
|
if (FAILED(hr))
|
|
{
|
|
m_dataSrvIp.fAllowClientAddr = defSrvIp.fAllowClientAddr;
|
|
}
|
|
|
|
tstring strIpAddress;
|
|
hr = inf.HrGetString (strSection.c_str(),
|
|
c_szAfIpAddressStart,
|
|
&strIpAddress);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
m_dataSrvIp.dwIpStart = IpPszToHostAddr(strIpAddress.c_str());
|
|
}
|
|
else
|
|
{
|
|
m_dataSrvIp.dwIpStart = defSrvIp.dwIpStart;
|
|
}
|
|
|
|
hr = inf.HrGetString (strSection.c_str(),
|
|
c_szAfIpAddressEnd,
|
|
&strIpAddress);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
m_dataSrvIp.dwIpEnd = IpPszToHostAddr(strIpAddress.c_str());
|
|
}
|
|
else
|
|
{
|
|
m_dataSrvIp.dwIpEnd = defSrvIp.dwIpEnd;
|
|
}
|
|
|
|
|
|
// Read the IPX values.
|
|
//
|
|
m_dataSrvIpx.fEnableIn =
|
|
(m_dwDialInProtocolIds & RPI_IPX) ? TRUE : FALSE;
|
|
|
|
hr = inf.HrGetStringMapToDword (strSection.c_str(),
|
|
c_szAfIpxClientAccess,
|
|
c_mapNetworkAccess,
|
|
celems (c_mapNetworkAccess),
|
|
(DWORD*)&m_dataSrvIpx.fAllowNetworkAccess);
|
|
if (FAILED(hr))
|
|
{
|
|
m_dataSrvIpx.fAllowNetworkAccess = defSrvIpx.fAllowNetworkAccess;
|
|
}
|
|
|
|
hr = inf.HrGetStringAsBool (strSection.c_str(),
|
|
c_szAfAutoNetworkNumbers,
|
|
&m_dataSrvIpx.fUseAutoAddr);
|
|
if (FAILED(hr))
|
|
{
|
|
m_dataSrvIpx.fUseAutoAddr = defSrvIpx.fUseAutoAddr;
|
|
}
|
|
|
|
hr = inf.HrGetStringAsBool (strSection.c_str(),
|
|
c_szAfSameNetworkNumber,
|
|
&m_dataSrvIpx.fUseSameNetNum);
|
|
if (FAILED(hr))
|
|
{
|
|
m_dataSrvIpx.fUseSameNetNum = defSrvIpx.fUseSameNetNum;
|
|
}
|
|
|
|
hr = inf.HrGetStringAsBool (strSection.c_str(),
|
|
c_szAfClientReqNodeNumber,
|
|
&m_dataSrvIpx.fAllowClientNetNum);
|
|
if (FAILED(hr))
|
|
{
|
|
m_dataSrvIpx.fAllowClientNetNum = defSrvIpx.fAllowClientNetNum;
|
|
}
|
|
|
|
hr = inf.HrGetDword (strSection.c_str(),
|
|
c_szAfNetNumberFrom,
|
|
&m_dataSrvIpx.dwIpxNetFirst);
|
|
if (FAILED(hr))
|
|
{
|
|
m_dataSrvIpx.dwIpxNetFirst = defSrvIpx.dwIpxNetFirst;
|
|
}
|
|
|
|
hr = inf.HrGetDword (strSection.c_str(),
|
|
c_szAfWanNetPoolSize,
|
|
&m_dataSrvIpx.dwIpxWanPoolSize);
|
|
if (FAILED(hr))
|
|
{
|
|
m_dataSrvIpx.dwIpxWanPoolSize = defSrvIpx.dwIpxWanPoolSize;
|
|
}
|
|
|
|
// Read the NBF values.
|
|
//
|
|
m_dataSrvNbf.fEnableIn =
|
|
(m_dwDialInProtocolIds & RPI_NBF) ? TRUE : FALSE;
|
|
|
|
hr = inf.HrGetStringMapToDword (strSection.c_str(),
|
|
c_szAfNetbeuiClientAccess,
|
|
c_mapNetworkAccess,
|
|
celems (c_mapNetworkAccess),
|
|
(DWORD*)&m_dataSrvNbf.fAllowNetworkAccess);
|
|
if (FAILED(hr))
|
|
{
|
|
m_dataSrvNbf.fAllowNetworkAccess = defSrvNbf.fAllowNetworkAccess;
|
|
}
|
|
|
|
// Default anything bogus.
|
|
//
|
|
m_dataSrvCfg.CheckAndDefault ();
|
|
m_dataSrvIp .CheckAndDefault ();
|
|
m_dataSrvIpx.CheckAndDefault ();
|
|
m_dataSrvNbf.CheckAndDefault ();
|
|
|
|
hr = S_OK;
|
|
}
|
|
TraceError ("CRasSrvAnswerFileData::HrOpenAndRead", hr);
|
|
return hr;
|
|
}
|
|
|
|
VOID
|
|
CRasSrvAnswerFileData::SaveToRegistry (
|
|
VOID) const
|
|
{
|
|
m_dataSrvCfg.SaveToReg();
|
|
m_dataSrvIp .SaveToReg();
|
|
m_dataSrvIpx.SaveToReg();
|
|
m_dataSrvNbf.SaveToReg();
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
// CL2tpAnswerFileData
|
|
//
|
|
const DWORD c_MaxMaxVcs = 1000;
|
|
const DWORD c_DefMaxVcs = 1000;
|
|
const DWORD c_MaxEndpoints = 1000;
|
|
const DWORD c_DefEndpoints = 5;
|
|
|
|
VOID
|
|
CL2tpAnswerFileData::CheckAndDefault ()
|
|
{
|
|
if (m_cMaxVcs > c_MaxMaxVcs)
|
|
{
|
|
m_cMaxVcs = c_DefMaxVcs;
|
|
}
|
|
|
|
if (m_cEndpoints > c_MaxEndpoints)
|
|
{
|
|
m_cEndpoints = c_DefEndpoints;
|
|
}
|
|
}
|
|
|
|
HRESULT
|
|
CL2tpAnswerFileData::HrOpenAndRead (
|
|
PCWSTR pszAnswerFile,
|
|
PCWSTR pszAnswerSection)
|
|
{
|
|
ZeroMemory (this, sizeof(*this));
|
|
|
|
// Open the answer file. It will close itself in it's destructor.
|
|
CSetupInfFile inf;
|
|
UINT unErrorLine;
|
|
|
|
HRESULT hr = inf.HrOpen (
|
|
pszAnswerFile, NULL,
|
|
INF_STYLE_OLDNT | INF_STYLE_WIN4,
|
|
&unErrorLine);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Read the number of VPNs.
|
|
//
|
|
hr = inf.HrGetDword (pszAnswerSection,
|
|
c_szAfL2tpMaxVcs,
|
|
&m_cMaxVcs);
|
|
if (FAILED(hr))
|
|
{
|
|
m_cMaxVcs = c_DefMaxVcs;
|
|
}
|
|
|
|
hr = inf.HrGetDword (pszAnswerSection,
|
|
c_szAfL2tpEndpoints,
|
|
&m_cEndpoints);
|
|
if (FAILED(hr))
|
|
{
|
|
m_cEndpoints = c_DefEndpoints;
|
|
m_fWriteEndpoints = FALSE;
|
|
}
|
|
else
|
|
{
|
|
m_fWriteEndpoints = TRUE;
|
|
}
|
|
|
|
// Default anything bogus.
|
|
//
|
|
CheckAndDefault ();
|
|
|
|
hr = S_OK;
|
|
}
|
|
TraceError ("CL2tpAnswerFileData::HrOpenAndRead", hr);
|
|
return hr;
|
|
}
|
|
|
|
VOID
|
|
CL2tpAnswerFileData::SaveToRegistry (
|
|
INetCfg* pnc) const
|
|
{
|
|
Assert (pnc);
|
|
|
|
HKEY hkey;
|
|
HRESULT hr;
|
|
|
|
// Update the L2TP miniport's parameter key.
|
|
//
|
|
hr = HrOpenComponentParamKey (
|
|
pnc,
|
|
GUID_DEVCLASS_NET,
|
|
c_szInfId_MS_L2tpMiniport,
|
|
&hkey);
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
(VOID) HrRegSetDword (hkey, L"MaxVcs", m_cMaxVcs);
|
|
|
|
if (m_fWriteEndpoints)
|
|
{
|
|
(VOID) HrRegSetDword (hkey, L"WanEndpoints", m_cEndpoints);
|
|
}
|
|
|
|
RegCloseKey (hkey);
|
|
}
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
// CPptpAnswerFileData
|
|
//
|
|
|
|
// Minimum and maximum number of Virtual Private Networks
|
|
// allowed by PPTP.
|
|
const DWORD c_cPptpVpnsMin = 0;
|
|
const DWORD c_cPptpVpnsMax = 1000;
|
|
|
|
static const DWORD c_cDefPptpVpnsWorkstation = 2;
|
|
static const DWORD c_cDefPptpVpnsServer = 5;
|
|
|
|
|
|
DWORD
|
|
CPptpAnswerFileData::GetDefaultNumberOfVpns ()
|
|
{
|
|
PRODUCT_FLAVOR pf;
|
|
GetProductFlavor(NULL, &pf);
|
|
|
|
DWORD cVpns;
|
|
|
|
// On the server product, default to 5 VPNs, otherwise, default to 2 VPNs.
|
|
//
|
|
if (PF_SERVER == pf)
|
|
{
|
|
cVpns = c_cDefPptpVpnsServer;
|
|
}
|
|
else
|
|
{
|
|
cVpns = c_cDefPptpVpnsWorkstation;
|
|
}
|
|
|
|
return cVpns;
|
|
}
|
|
|
|
#pragma warning(push)
|
|
#pragma warning(disable:4296)
|
|
VOID
|
|
CPptpAnswerFileData::CheckAndDefault ()
|
|
{
|
|
if ((m_cVpns < c_cPptpVpnsMin) || (m_cVpns > c_cPptpVpnsMax))
|
|
{
|
|
m_cVpns = GetDefaultNumberOfVpns ();
|
|
}
|
|
}
|
|
#pragma warning(pop)
|
|
|
|
HRESULT
|
|
CPptpAnswerFileData::HrOpenAndRead (
|
|
PCWSTR pszAnswerFile,
|
|
PCWSTR pszAnswerSection)
|
|
{
|
|
ZeroMemory (this, sizeof(*this));
|
|
|
|
// Open the answer file. It will close itself in it's destructor.
|
|
CSetupInfFile inf;
|
|
UINT unErrorLine;
|
|
|
|
HRESULT hr = inf.HrOpen (
|
|
pszAnswerFile, NULL,
|
|
INF_STYLE_OLDNT | INF_STYLE_WIN4,
|
|
&unErrorLine);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Read the number of VPNs.
|
|
//
|
|
hr = inf.HrGetDword (pszAnswerSection,
|
|
c_szAfPptpEndpoints,
|
|
&m_cVpns);
|
|
if (FAILED(hr))
|
|
{
|
|
m_cVpns = GetDefaultNumberOfVpns ();
|
|
}
|
|
|
|
// Default anything bogus.
|
|
//
|
|
CheckAndDefault ();
|
|
|
|
hr = S_OK;
|
|
}
|
|
TraceError ("CPptpAnswerFileData::HrOpenAndRead", hr);
|
|
return hr;
|
|
}
|
|
|
|
VOID
|
|
CPptpAnswerFileData::SaveToRegistry (
|
|
INetCfg* pnc) const
|
|
{
|
|
Assert (pnc);
|
|
|
|
HKEY hkey;
|
|
HRESULT hr;
|
|
|
|
// Update the PPTP miniport's parameter key.
|
|
//
|
|
hr = HrOpenComponentParamKey (
|
|
pnc,
|
|
GUID_DEVCLASS_NET,
|
|
c_szInfId_MS_PptpMiniport,
|
|
&hkey);
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
(VOID) HrRegSetDword (hkey, L"WanEndpoints", m_cVpns);
|
|
|
|
RegCloseKey (hkey);
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
CPppoeAnswerFileData::CheckAndDefault ()
|
|
{
|
|
m_cVpns = 1;
|
|
}
|
|
|
|
HRESULT
|
|
CPppoeAnswerFileData::HrOpenAndRead (
|
|
PCWSTR pszAnswerFile,
|
|
PCWSTR pszAnswerSection)
|
|
{
|
|
ZeroMemory (this, sizeof(*this));
|
|
|
|
// Open the answer file. It will close itself in it's destructor.
|
|
CSetupInfFile inf;
|
|
UINT unErrorLine;
|
|
|
|
HRESULT hr = inf.HrOpen (
|
|
pszAnswerFile, NULL,
|
|
INF_STYLE_OLDNT | INF_STYLE_WIN4,
|
|
&unErrorLine);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Read the number of VPNs.
|
|
//
|
|
hr = inf.HrGetDword (pszAnswerSection,
|
|
c_szAfL2tpEndpoints,
|
|
&m_cVpns);
|
|
if (FAILED(hr))
|
|
{
|
|
m_cVpns = 1;
|
|
}
|
|
|
|
// Default anything bogus.
|
|
//
|
|
CheckAndDefault ();
|
|
|
|
hr = S_OK;
|
|
}
|
|
TraceError ("CPppoeAnswerFileData::HrOpenAndRead", hr);
|
|
return hr;
|
|
}
|
|
|
|
VOID
|
|
CPppoeAnswerFileData::SaveToRegistry (
|
|
INetCfg* pnc) const
|
|
{
|
|
Assert (pnc);
|
|
|
|
HKEY hkey;
|
|
HRESULT hr;
|
|
|
|
// Update the PPTP miniport's parameter key.
|
|
//
|
|
hr = HrOpenComponentParamKey (
|
|
pnc,
|
|
GUID_DEVCLASS_NET,
|
|
c_szInfId_MS_PppoeMiniport,
|
|
&hkey);
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
(VOID) HrRegSetDword (hkey, L"WanEndpoints", m_cVpns);
|
|
|
|
RegCloseKey (hkey);
|
|
}
|
|
}
|