//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1997.
//
// File: T C P D H C P . C P P
//
// Contents: Functions related to Calling Dhcpcsvc.dll entry point
// called from HrSetMisc
//
// HrNotifyDhcp, HrCallDhcpConfig
//
// Notes: These functions are based on what was in ncpa1.1
//
// HrNotifyDHCP is from CTcpGenPage::NotifyDHCP
// HrCallDhcpConfig is from CallDHCPConfig
//
// Author: tongl 11 May 1997
//
//----------------------------------------------------------------------------
#include "pch.h"
#pragma hdrstop
#include "tcpipobj.h"
#include "ncatlui.h"
#include "ncreg.h"
#include "ncsvc.h"
#include "tcpconst.h"
#include "tcputil.h"
#include "atmcommon.h"
#define ConvertIpDword(dwIpOrSubnet) ((dwIpOrSubnet[3]<<24) | (dwIpOrSubnet[2]<<16) | (dwIpOrSubnet[1]<<8) | (dwIpOrSubnet[0]))
//
// CTcpipcfg::HrNotifyDhcp
//
// Makes on the fly IP Address changes for all cards in the system
//
// hkeyTcpipParam Handle to \CCS\Services\Tcpip\Parameters reg key
HRESULT CTcpipcfg::HrNotifyDhcp()
{
HRESULT hr = S_OK;
HRESULT hrTmp = S_OK;
ADAPTER_INFO* pAdapter;
for (VCARD::iterator iterAdapter = m_vcardAdapterInfo.begin();
iterAdapter != m_vcardAdapterInfo.end();
iterAdapter ++)
{
pAdapter = *iterAdapter;
if((pAdapter->m_BindingState == BINDING_ENABLE) &&
(pAdapter->m_InitialBindingState != BINDING_DISABLE) &&
(!pAdapter->m_fIsWanAdapter))
{
// 1) Static IP-> Dhcp
// The new value is enable DHCP,
// but the old value was disable DHCP
if(pAdapter->m_fEnableDhcp &&
!pAdapter->m_fOldEnableDhcp)
{
TraceTag(ttidTcpip,"[HrNotifyDhcp] adapter:%S: Static IP->DHCP",
pAdapter->m_strBindName.c_str());
HKEY hkeyTcpipParam = NULL;
hrTmp = m_pnccTcpip->OpenParamKey(&hkeyTcpipParam);
if SUCCEEDED(hrTmp)
{
// Enable Dhcp
HKEY hkeyInterfaces = NULL;
DWORD dwGarbage;
// Open the interfaces key
hrTmp = HrRegCreateKeyEx(hkeyTcpipParam,
c_szInterfacesRegKey,
REG_OPTION_NON_VOLATILE,
KEY_READ,
NULL,
&hkeyInterfaces,
&dwGarbage);
if(SUCCEEDED(hrTmp))
{
Assert(hkeyInterfaces);
HKEY hkeyInterfaceParam = NULL;
// Open the interface key for the specified interface
hrTmp = HrRegCreateKeyEx(
hkeyInterfaces,
pAdapter->m_strTcpipBindPath.c_str(),
REG_OPTION_NON_VOLATILE,
KEY_READ_WRITE,
NULL,
&hkeyInterfaceParam,
&dwGarbage);
if (SUCCEEDED(hrTmp))
{
// Clear up the IP address and subnet registry entries
Assert(hkeyInterfaceParam);
hrTmp = HrRegSetString(hkeyInterfaceParam,
RGAS_DHCP_IPADDRESS,
tstring(ZERO_ADDRESS));
if(SUCCEEDED(hrTmp))
{
hrTmp = HrRegSetString(hkeyInterfaceParam,
RGAS_DHCP_SUBNETMASK,
tstring(FF_ADDRESS));
if(SUCCEEDED(hrTmp))
{
// Enable Dhcp & remove first static IP address
hrTmp = HrCallDhcpConfig(
NULL,
(PWSTR)pAdapter->m_strTcpipBindPath.c_str(),
pAdapter->m_guidInstanceId,
FALSE, // static->dhcp
0, // index
0, // IP address
0, // Subnet mask
DhcpEnable); //Flag: enable Dhcp
}
}
}
RegSafeCloseKey(hkeyInterfaceParam);
}
RegSafeCloseKey(hkeyInterfaces);
}
RegSafeCloseKey(hkeyTcpipParam);
}
// 2) Static IP change
// DHCP is disabled now, and also used to be disabled before
if(!pAdapter->m_fEnableDhcp &&
!pAdapter->m_fOldEnableDhcp)
{
TraceTag(ttidTcpip,"[HrNotifyDhcp] adapter:%S: Static IP change.",
pAdapter->m_strBindName.c_str());
HRESULT hrTmp2 = S_OK;
BOOL fStaticIpChanged = FALSE;
// We should have equal number of IP addresses & subnet masks
Assert(pAdapter->m_vstrIpAddresses.size() ==
pAdapter->m_vstrSubnetMask.size());
Assert(pAdapter->m_vstrOldIpAddresses.size() ==
pAdapter->m_vstrOldSubnetMask.size());
// We need to check if individual IP addresses are different
// and call HrCallDhcpConfig once for each difference
int iCountNew = pAdapter->m_vstrIpAddresses.size();
int iCountOld = pAdapter->m_vstrOldIpAddresses.size();
int iCount = iCountNew>iCountOld ? iCountOld :iCountNew;
Assert(iCount>0);
int iIp;
// For each static IP address index in both old and new
// Update IP
for (iIp=0; iIp<iCount; iIp++)
{
// Change address if mismatch
if((*pAdapter->m_vstrIpAddresses[iIp] !=
*pAdapter->m_vstrOldIpAddresses[iIp]) ||
(*pAdapter->m_vstrSubnetMask[iIp] !=
*pAdapter->m_vstrOldSubnetMask[iIp]))
{
// if a mismatch found, change it
fStaticIpChanged = TRUE;
break;
}
}
if (fStaticIpChanged)
{
int i;
// blow away the rest of the old addresses in reverse order
for (i= iCountOld-1; i>=iIp; i--)
{
// Remove IP address on the fly
hrTmp2= HrCallDhcpConfig(
NULL,
(PWSTR)pAdapter->m_strTcpipBindPath.c_str(),
pAdapter->m_guidInstanceId,
TRUE, // IsNewIpAddress: TRUE in static->static
i, // Index of old IP address
0, // Ip Address: remove
0, // Subnetmask: remove
IgnoreFlag); // Flag: static->static
TraceError("Ctcpipcfg::HrNotifyDhcp - remove static IP address", hrTmp2);
if SUCCEEDED(hrTmp)
hrTmp = hrTmp2;
}
// add the rest of the new addresses in order
for (i= iIp; i< iCountNew; i++)
{
// Ip Address
DWORD dwIp[4];
GetNodeNum(pAdapter->m_vstrIpAddresses[i]->c_str(),dwIp);
DWORD dwNewIp = ConvertIpDword(dwIp);
// Subnet mask
DWORD dwSubnet[4];
GetNodeNum(pAdapter->m_vstrSubnetMask[i]->c_str(),dwSubnet);
DWORD dwNewSubnet = ConvertIpDword(dwSubnet);
if (0 == i)
{
// $REVIEW(tongl 6/3/98): the first address has to be added differently,
// yet another requirement by the api to change static ip list (bug #180015).
// Bug #180617 had my request to change the API to allow reconfigure whole
// static ip list instead of requiring caller to figure out everything needed
// for the internal data structure change for ip.
// must call "replace" instead of "add"
hrTmp2= HrCallDhcpConfig(
NULL,
(PWSTR)pAdapter->m_strTcpipBindPath.c_str(),
pAdapter->m_guidInstanceId,
TRUE, // IsNewIpAddress: TRUE in static->static
0, // Replace first address
dwNewIp,
dwNewSubnet,
IgnoreFlag); // Flag: static->static
}
else
{
// Add IP address on the fly
hrTmp2= HrCallDhcpConfig(
NULL,
(PWSTR)pAdapter->m_strTcpipBindPath.c_str(),
pAdapter->m_guidInstanceId,
TRUE, // IsNewIpAddress: TRUE in static->static
0xFFFF, // New IP address
dwNewIp,
dwNewSubnet,
IgnoreFlag); // Flag: static->static
}
TraceError("Ctcpipcfg::HrNotifyDhcp - add static IP address", hrTmp2);
if SUCCEEDED(hrTmp)
hrTmp = hrTmp2;
}
}
else
{
// existing addresses all match
if (iIp<iCountNew) // We ust get more new addresses to add
{
fStaticIpChanged = TRUE;
while (iIp<iCountNew)
{
DWORD dwIp[4];
Assert(!pAdapter->m_vstrIpAddresses.empty());
GetNodeNum(pAdapter->m_vstrIpAddresses[iIp]->c_str(),
dwIp);
DWORD dwNewIp = ConvertIpDword(dwIp);
// Subnet mask
DWORD dwSubnet[4];
Assert(!pAdapter->m_vstrSubnetMask.empty());
GetNodeNum(pAdapter->m_vstrSubnetMask[iIp]->c_str(),
dwSubnet);
DWORD dwNewSubnet = ConvertIpDword(dwSubnet);
// Add IP address on the fly
hrTmp2= HrCallDhcpConfig(
NULL,
(PWSTR)pAdapter->m_strTcpipBindPath.c_str(),
pAdapter->m_guidInstanceId,
TRUE, // IsNewIpAddress: TRUE in static->static
0xFFFF, // New IP address
dwNewIp,
dwNewSubnet,
IgnoreFlag); // Flag: static->static
TraceError("Ctcpipcfg::HrNotifyDhcp - add static IP address", hrTmp2);
if SUCCEEDED(hrTmp)
hrTmp = hrTmp2;
iIp++;
}
}
else if (iIp<iCountOld) // We just get more old addresses to remove
{
fStaticIpChanged = TRUE;
int iIp2 = iCountOld-1;
while (iIp2 >= iIp)
{
// Remove IP address on the fly
hrTmp2= HrCallDhcpConfig(
NULL,
(PWSTR)pAdapter->m_strTcpipBindPath.c_str(),
pAdapter->m_guidInstanceId,
TRUE, // IsNewIpAddress: TRUE in static->static
iIp2, // Index of old IP address
0, // Ip Address: remove
0, // Subnetmask: remove
IgnoreFlag); // Flag: static->static
TraceError("Ctcpipcfg::HrNotifyDhcp - remove static IP address", hrTmp2);
if SUCCEEDED(hrTmp)
hrTmp = hrTmp2;
iIp2--;
}
}
}
}
// 3) Dhcp->Static
// DHCP is disabled now, but used to be enabled
if(!pAdapter->m_fEnableDhcp &&
pAdapter->m_fOldEnableDhcp)
{
TraceTag(ttidTcpip,"[HrNotifyDhcp] adapter:%S: DHCP->Static IP",
pAdapter->m_strBindName.c_str());
// Disable Dhcp & add first static Ip address
Assert(!pAdapter->m_vstrIpAddresses.empty());
// Ip Address
DWORD dwIp[4];
GetNodeNum(pAdapter->m_vstrIpAddresses[0]->c_str(),
dwIp);
DWORD dwNewIp = ConvertIpDword(dwIp);
// Subnet Mask
DWORD dwSubnet[4];
Assert(!pAdapter->m_vstrSubnetMask.empty());
GetNodeNum(pAdapter->m_vstrSubnetMask[0]->c_str(),
dwSubnet);
DWORD dwNewSubnet = ConvertIpDword(dwSubnet);
// change IP address on the fly
hrTmp = HrCallDhcpConfig(
NULL,
(PWSTR)pAdapter->m_strTcpipBindPath.c_str(),
pAdapter->m_guidInstanceId,
TRUE,
0, // index: update dhcp address to first static address
dwNewIp,
dwNewSubnet,
DhcpDisable); // Flag: disable Dhcp
if SUCCEEDED(hrTmp)
{
HRESULT hrTmp2 = S_OK;
// Add the rest of new static IP addresses
for (size_t iIp = 1;
iIp < pAdapter->m_vstrIpAddresses.size();
iIp++)
{
// Ip Address
DWORD dwIp[4];
Assert(!pAdapter->m_vstrIpAddresses.empty());
GetNodeNum(pAdapter->m_vstrIpAddresses[iIp]->c_str(),
dwIp);
DWORD dwNewIp = ConvertIpDword(dwIp);
// Subnet Mask
DWORD dwSubnet[4];
Assert(!pAdapter->m_vstrSubnetMask.empty());
GetNodeNum(pAdapter->m_vstrSubnetMask[iIp]->c_str(),
dwSubnet);
DWORD dwNewSubnet = ConvertIpDword(dwSubnet);
// change IP address on the fly
hrTmp2= HrCallDhcpConfig(
NULL,
(PWSTR)pAdapter->m_strTcpipBindPath.c_str(),
pAdapter->m_guidInstanceId,
TRUE,
0xFFFF, // index: new address
dwNewIp,
dwNewSubnet,
IgnoreFlag ); // Flag: static->static
TraceError("CTcpipcfg::HrNotifyDhcp - add static IP address", hrTmp2);
if SUCCEEDED(hrTmp)
hrTmp = hrTmp2;
}
}
}
if (SUCCEEDED(hr))
hr = hrTmp;
// 4) Dhcp Class ID, DNS server list and domain change
// $REVIEW(tongl 6/12): Notify DNS server list and domain changes
// here (Raid #175766)
DHCP_PNP_CHANGE DhcpPnpChange;
ZeroMemory(&DhcpPnpChange, sizeof(DHCP_PNP_CHANGE));
DhcpPnpChange.Version = DHCP_PNP_CHANGE_VERSION_0;
DhcpPnpChange.HostNameChanged = FALSE;
DhcpPnpChange.MaskChanged = FALSE;
//Bug 257868 If there is user specified default gateway, notify dhcp client
DhcpPnpChange.GateWayChanged = !fIsSameVstr(pAdapter->m_vstrDefaultGateway,
pAdapter->m_vstrOldDefaultGateway) ||
!fIsSameVstr(pAdapter->m_vstrDefaultGatewayMetric,
pAdapter->m_vstrOldDefaultGatewayMetric);
DhcpPnpChange.RouteChanged = FALSE;
DhcpPnpChange.OptsChanged = FALSE;
DhcpPnpChange.OptDefsChanged = FALSE;
DhcpPnpChange.DnsListChanged = !fIsSameVstr(pAdapter->m_vstrDnsServerList,
pAdapter->m_vstrOldDnsServerList);
DhcpPnpChange.DomainChanged = pAdapter->m_strDnsDomain != pAdapter->m_strOldDnsDomain;
DhcpPnpChange.ClassIdChanged = FALSE;
DhcpPnpChange.DnsOptionsChanged =
((!!pAdapter->m_fDisableDynamicUpdate) !=
(!!pAdapter->m_fOldDisableDynamicUpdate))
||
((!!pAdapter->m_fEnableNameRegistration) !=
(!!pAdapter->m_fOldEnableNameRegistration));
if(DhcpPnpChange.DnsListChanged ||
DhcpPnpChange.DnsOptionsChanged ||
DhcpPnpChange.DomainChanged ||
(DhcpPnpChange.GateWayChanged && pAdapter->m_fEnableDhcp))
{
hrTmp = HrCallDhcpHandlePnPEvent(pAdapter, &DhcpPnpChange);
if (FAILED(hrTmp))
{
TraceError("HrCallDhcpHandlePnPEvent returns failure, requesting reboot...", hrTmp);
hr = NETCFG_S_REBOOT;
}
}
if (pAdapter->m_fBackUpSettingChanged)
{
hrTmp = HrDhcpRefreshFallbackParams(pAdapter);
if (FAILED(hrTmp))
{
TraceError("HrDhcpRefreshFallbackParams returns failure, requesting reboot...", hrTmp);
hr = NETCFG_S_REBOOT;
}
}
}
}
if (NETCFG_S_REBOOT != hr)
hr = hrTmp;
TraceError("CTcpipcfg::HrNotifyDhcp", hr);
return hr;
}
// Define the export function prototype from dhcpcsvc.dll
typedef DWORD (APIENTRY *T_DhcpNotifyConfigChange)(PWSTR ServerName,
PWSTR AdapterName,
BOOL IsNewIpAddress,
DWORD IpIndex,
DWORD IpAddress,
DWORD SubnetMask,
SERVICE_ENABLE DhcpServiceEnabled);
//
// CTcpipcfg::HrCallDhcpConfig
//
// Sets the IP address on the fly (without re-booting)
//
// ServerName always set to NULL
// AdapterName the adapter BindPathName to tcpip
// IsNewIpAddress set to TRUE if Dhcp->Static or Statis->Static changes
// set to FALSE if Static->Dhcp changes
//
//
// IpIndex the index of the IP Address for the card
// adapters can have more than 1 IP Address
// (as seen in the Advanced dialog)
// (this is causing problem for Munil
// because the use of this index is buggy in his code
// index is always set to 0 if there is only one IP Address
// for the card
//
// IpAddress the new IP Address
// SubnetMask the new SubnetMask
//
// DhcpServiceEnabled enum type, can be set to :
// DhcpEnable -> if DHCP was disabled,
// but now being changed to enabled
// IgnoreFlag -> DHCP was disabled and is still disabled
// DhcpDisable -> DHCP was enabled, but now being changed
// to disabled
//
// For extra reference talk to Munil -> these parameters correspond to the
// DhcpNotifyConfigChange API of the dhcpcsvc.dll file
//
HRESULT CTcpipcfg::HrCallDhcpConfig(PWSTR ServerName,
PWSTR AdapterName,
GUID & guidAdaputer,
BOOL IsNewIpAddress,
DWORD IpIndex,
DWORD IpAddress,
DWORD SubnetMask,
SERVICE_ENABLE DhcpServiceEnabled)
{
HRESULT hr = S_OK;
// Make sure TCP/IP is running.
// Scoping brackets cause service and service controller to be
// closed when we don't need them anymore.
{
CServiceManager smng;
CService serv;
hr = smng.HrOpenService(&serv, c_szTcpip, NO_LOCK,
SC_MANAGER_CONNECT, SERVICE_QUERY_STATUS);
if(SUCCEEDED(hr))
{
DWORD dwState;
hr = serv.HrQueryState(&dwState);
if(SUCCEEDED(hr))
{
if(dwState != SERVICE_RUNNING)
{
//TCPIP must always be running if installed!!!
AssertSz(FALSE, "Tcpip service must always be running if installed!");
hr = E_FAIL;
}
}
}
}
if (SUCCEEDED(hr))
{
HMODULE hDll;
FARPROC pDhcpConfig;
hr = HrLoadLibAndGetProc (L"dhcpcsvc.dll",
"DhcpNotifyConfigChange",
&hDll, &pDhcpConfig);
if (SUCCEEDED(hr))
{
TraceTag(ttidTcpip,"Begin calling DhcpNotifyConfigChange...");
// Parameter dump for debugging
TraceTag(ttidTcpip, "[DhcpNotifyConfigChange] ServerName:%S", ServerName);
TraceTag(ttidTcpip, "[DhcpNotifyConfigChange] AdapterName:%S", AdapterName);
TraceTag(ttidTcpip, "[DhcpNotifyConfigChange] IsNewIpAddress:%d", IsNewIpAddress);
TraceTag(ttidTcpip, "[DhcpNotifyConfigChange] IpIndex:%d", IpIndex);
TraceTag(ttidTcpip, "[DhcpNotifyConfigChange] IpAddress:%d", IpAddress);
TraceTag(ttidTcpip, "[DhcpNotifyConfigChange] SubnetMask:%d", SubnetMask);
TraceTag(ttidTcpip, "[DhcpNotifyConfigChange] DhcpServiceEnabled:%d", DhcpServiceEnabled);
DWORD dwError;
dwError = (*(T_DhcpNotifyConfigChange)pDhcpConfig)(
ServerName,
AdapterName,
IsNewIpAddress,
IpIndex,
IpAddress,
SubnetMask,
DhcpServiceEnabled);
TraceTag(ttidTcpip,"Finished calling DhcpNotifyConfigChange...");
hr = HRESULT_FROM_WIN32(dwError);
if FAILED(hr)
{
// Added as part of fix for #107373
if (ERROR_DUP_NAME == dwError)
{
// Warn the user about duplicate IP address
NcMsgBox(::GetActiveWindow(), IDS_MSFT_TCP_TEXT,
IDS_DUP_NETIP, MB_APPLMODAL | MB_ICONEXCLAMATION | MB_OK);
hr = S_OK;
}
else if (ERROR_FILE_NOT_FOUND == dwError)
{
// The adapter we want to reconfig is not connected
TraceTag(ttidTcpip, "The adater is disconnected or not bound to TCP/IP.");
hr = S_OK;
}
else if (STATUS_DUPLICATE_OBJECTID == dwError)
{
// fix for 320797
TraceTag(ttidTcpip, "The address is already configured for the adapter");
hr = S_OK;
}
else if (ERROR_INVALID_DRIVE == dwError)
{
// fix for 320797
TraceTag(ttidTcpip, "The address has already been deleted from the stack");
hr = S_OK;
}
else
{
TraceError("Error on DhcpNotifyConfigChange from dhcpcsvc.dll", hr);
FARPROC pfnHrGetPnpDeviceStatus = NULL;
HRESULT hrTmp = S_OK;
HMODULE hNetman = NULL;
NETCON_STATUS ncStatus = NCS_CONNECTED;
hrTmp = HrLoadLibAndGetProc(L"netman.dll", "HrGetPnpDeviceStatus",
&hNetman, &pfnHrGetPnpDeviceStatus);
if (SUCCEEDED(hrTmp))
{
Assert(pfnHrGetPnpDeviceStatus);
hrTmp = (*(PHRGETPNPDEVICESTATUS)pfnHrGetPnpDeviceStatus)(
&guidAdaputer,
&ncStatus);
FreeLibrary(hNetman);
}
if (SUCCEEDED(hrTmp) && NCS_MEDIA_DISCONNECTED == ncStatus)
{
TraceTag(ttidTcpip, "The connection is media disconnected. Do not need to reboot");
hr = S_OK;
}
else
{
// Mask the specific error so NCPA does not fail.
hr = NETCFG_S_REBOOT;
}
}
}
FreeLibrary (hDll);
}
}
TraceError("CTcpipcfg::HrCallDhcpConfig", hr);
return hr;
}
typedef DWORD (WINAPI * PFNDhcpHandlePnPEvent) (
IN DWORD Flags,
IN DWORD Caller,
IN PWSTR AdapterName,
IN LPDHCP_PNP_CHANGE Changes,
IN LPVOID Reserved
);
HRESULT CTcpipcfg::HrCallDhcpHandlePnPEvent(ADAPTER_INFO * pAdapterInfo,
LPDHCP_PNP_CHANGE pDhcpPnpChange)
{
// load the dll and get function pointer
HMODULE hDll;
FARPROC pDhcpHandlePnPEvent;
HRESULT hr = HrLoadLibAndGetProc (L"dhcpcsvc.dll",
"DhcpHandlePnPEvent",
&hDll, &pDhcpHandlePnPEvent);
if (SUCCEEDED(hr))
{
TraceTag(ttidTcpip, "[DhcpHandlePnPEvent] Flags: 0");
TraceTag(ttidTcpip, "[DhcpHandlePnPEvent] Caller: DHCP_CALLER_TCPUI");
TraceTag(ttidTcpip, "[DhcpHandlePnPEvent] AdapterName: %S", pAdapterInfo->m_strBindName.c_str());
TraceTag(ttidTcpip, "[DhcpHandlePnPEvent] Changes.DnsListChanged: %d", pDhcpPnpChange->DnsListChanged);
TraceTag(ttidTcpip, "[DhcpHandlePnPEvent] Changes.DomainChanged: %d", pDhcpPnpChange->DomainChanged);
TraceTag(ttidTcpip, "[DhcpHandlePnPEvent] Changes.ClassIdChanged: %d", pDhcpPnpChange->ClassIdChanged);
DWORD dwRet = (*(PFNDhcpHandlePnPEvent)pDhcpHandlePnPEvent)(
0,
DHCP_CALLER_TCPUI,
(PWSTR)pAdapterInfo->m_strBindName.c_str(),
pDhcpPnpChange,
NULL);
hr = HRESULT_FROM_WIN32(dwRet);
if (ERROR_FILE_NOT_FOUND == dwRet)
{
// The adapter we want to reconfig is not connected
TraceTag(ttidTcpip, "DhcpHandlePnPEvent returns ERROR_FILE_NOT_FOUND. The adater is disconnected or not bound to TCP/IP.");
hr = S_OK;
}
FreeLibrary (hDll);
}
TraceError("CTcpipcfg::HrCallDhcpHandlePnPEvent", hr);
return hr;
}
typedef DWORD (WINAPI * PFDhcpFallbackRefreshParams) (
IN LPWSTR AdapterName
);
HRESULT CTcpipcfg::HrDhcpRefreshFallbackParams(ADAPTER_INFO * pAdapterInfo)
{
// load the dll and get function pointer
HMODULE hDll;
FARPROC pDhcpFallbackRefreshParams;
HRESULT hr = HrLoadLibAndGetProc (L"dhcpcsvc.dll",
"DhcpFallbackRefreshParams",
&hDll, &pDhcpFallbackRefreshParams);
if (SUCCEEDED(hr))
{
TraceTag(ttidTcpip, "[DhcpFallbackRefreshParams] AdapterName: %S", pAdapterInfo->m_strBindName.c_str());
DWORD dwRet = (*(PFDhcpFallbackRefreshParams)pDhcpFallbackRefreshParams)(
(LPWSTR)pAdapterInfo->m_strBindName.c_str()
);
hr = HRESULT_FROM_WIN32(dwRet);
if (ERROR_FILE_NOT_FOUND == dwRet)
{
// The adapter we want to reconfig is not connected
TraceTag(ttidTcpip, "DhcpFallbackRefreshParams returns ERROR_FILE_NOT_FOUND. The adater is disconnected or not bound to TCP/IP.");
hr = S_OK;
}
FreeLibrary (hDll);
}
TraceError("CTcpipcfg::HrDhcpRefreshFallbackParams", hr);
return hr;
}