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.
2593 lines
76 KiB
2593 lines
76 KiB
//=============================================================================
|
|
// Copyright (c) 1999 Microsoft Corporation
|
|
// File: ifip1.c
|
|
// Abstract:
|
|
// This module implements the helpers for if/ip apis
|
|
//
|
|
// Author: K.S.Lokesh (lokeshs@) 8-1-99
|
|
//=============================================================================
|
|
|
|
|
|
#include "precomp.h"
|
|
#include <iphlpapi.h>
|
|
#include <iptypes.h>
|
|
#include <llinfo.h>
|
|
#include "ifip.h"
|
|
#include "ifstring.h"
|
|
|
|
const WCHAR c_wszListSeparatorComma[] = L",";
|
|
const WCHAR c_wListSeparatorComma = L',';
|
|
const WCHAR c_wListSeparatorSC = L';';
|
|
const WCHAR c_wszListSeparatorSC[] = L";";
|
|
const WCHAR c_wcsDefGateway[] = L"DefGw=";
|
|
const WCHAR c_wcsGwMetric[] = L"GwMetric=";
|
|
const WCHAR c_wcsIfMetric[] = L"IfMetric=";
|
|
const WCHAR c_wcsDns[] = L"DNS=";
|
|
const WCHAR c_wcsDdns[] = L"DynamicUpdate=";
|
|
const WCHAR c_wcsDdnsSuffix[] = L"NameRegistration=";
|
|
const WCHAR c_wcsWins[] = L"WINS=";
|
|
const WCHAR c_wEqual = L'=';
|
|
|
|
|
|
BOOL g_fInitCom = TRUE;
|
|
|
|
HRESULT
|
|
HrUninitializeAndUnlockINetCfg (
|
|
INetCfg* pnc
|
|
)
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Uninitializes and unlocks the INetCfg object
|
|
|
|
Arguments
|
|
|
|
pnc [in] INetCfg to uninitialize and unlock
|
|
|
|
Return Value
|
|
|
|
S_OK if success, OLE or Win32 error otherwise
|
|
|
|
Author: danielwe 13 Nov 1997
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
hr = pnc->lpVtbl->Uninitialize(pnc);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
INetCfgLock * pnclock;
|
|
|
|
// Get the locking interface
|
|
hr = pnc->lpVtbl->QueryInterface(pnc, &IID_INetCfgLock,
|
|
(LPVOID *)(&pnclock));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Attempt to lock the INetCfg for read/write
|
|
hr = pnclock->lpVtbl->ReleaseWriteLock(pnclock);
|
|
|
|
if (pnclock)
|
|
{
|
|
pnclock->lpVtbl->Release(pnclock);
|
|
}
|
|
pnclock = NULL;
|
|
}
|
|
}
|
|
|
|
// TraceResult("HrUninitializeAndUnlockINetCfg", hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrUninitializeAndReleaseINetCfg
|
|
//
|
|
// Purpose: Unintialize and release an INetCfg object. This will
|
|
// optionally uninitialize COM for the caller too.
|
|
//
|
|
// Arguments:
|
|
// fUninitCom [in] TRUE to uninitialize COM after the INetCfg is
|
|
// uninitialized and released.
|
|
// pnc [in] The INetCfg object.
|
|
// fHasLock [in] TRUE if the INetCfg was locked for write and
|
|
// must be unlocked.
|
|
//
|
|
// Returns: S_OK or an error code.
|
|
//
|
|
// Author: shaunco 7 May 1997
|
|
//
|
|
// Notes: The return value is the value returned from
|
|
// INetCfg::Uninitialize. Even if this fails, the INetCfg
|
|
// is still released. Therefore, the return value is for
|
|
// informational purposes only. You can't touch the INetCfg
|
|
// object after this call returns.
|
|
//
|
|
HRESULT
|
|
HrUninitializeAndReleaseINetCfg (
|
|
BOOL fUninitCom,
|
|
INetCfg* pnc,
|
|
BOOL fHasLock
|
|
)
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Arguments
|
|
|
|
Return Value
|
|
|
|
--*/
|
|
{
|
|
// Assert (pnc);
|
|
HRESULT hr = S_OK;
|
|
|
|
if (fHasLock)
|
|
{
|
|
hr = HrUninitializeAndUnlockINetCfg(pnc);
|
|
}
|
|
else
|
|
{
|
|
hr = pnc->lpVtbl->Uninitialize (pnc);
|
|
}
|
|
|
|
if (pnc)
|
|
{
|
|
pnc->lpVtbl->Release(pnc);
|
|
}
|
|
|
|
pnc = NULL;
|
|
|
|
if (fUninitCom)
|
|
{
|
|
CoUninitialize ();
|
|
}
|
|
// TraceResult("HrUninitializeAndReleaseINetCfg", hr);
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
HrGetIpPrivateInterface
|
|
-
|
|
Author: TongLu, KennT
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT HrGetIpPrivateInterface(INetCfg* pNetCfg,
|
|
ITcpipProperties **ppTcpProperties
|
|
)
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Arguments
|
|
|
|
Return Value
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr;
|
|
INetCfgClass* pncclass = NULL;
|
|
|
|
if ((pNetCfg == NULL) || (ppTcpProperties == NULL))
|
|
return E_INVALIDARG;
|
|
|
|
hr = pNetCfg->lpVtbl->QueryNetCfgClass (pNetCfg, &GUID_DEVCLASS_NETTRANS, &IID_INetCfgClass,
|
|
(void**)(&pncclass));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
INetCfgComponent * pnccItem = NULL;
|
|
|
|
// Find the component.
|
|
hr = pncclass->lpVtbl->FindComponent(pncclass, TEXT("MS_TCPIP"), &pnccItem);
|
|
//AssertSz (SUCCEEDED(hr), "pncclass->Find failed.");
|
|
if (S_OK == hr)
|
|
{
|
|
INetCfgComponentPrivate* pinccp = NULL;
|
|
hr = pnccItem->lpVtbl->QueryInterface(pnccItem, &IID_INetCfgComponentPrivate,
|
|
(void**)(&pinccp));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pinccp->lpVtbl->QueryNotifyObject(pinccp, &IID_ITcpipProperties,
|
|
(void**)(ppTcpProperties));
|
|
pinccp->lpVtbl->Release(pinccp);
|
|
}
|
|
}
|
|
|
|
if (pnccItem)
|
|
pnccItem->lpVtbl->Release(pnccItem);
|
|
}
|
|
|
|
if (pncclass)
|
|
pncclass->lpVtbl->Release(pncclass);
|
|
|
|
// S_OK indicates success (interface returned)
|
|
// S_FALSE indicates Ipx not installed
|
|
// other values are errors
|
|
// TraceResult("HrGetIpPrivateInterface", hr);
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
HRESULT
|
|
HrCreateAndInitializeINetCfg (
|
|
BOOL* pfInitCom,
|
|
INetCfg** ppnc,
|
|
BOOL fGetWriteLock,
|
|
DWORD cmsTimeout,
|
|
LPCWSTR szwClientDesc,
|
|
LPWSTR * ppszwClientDesc
|
|
)
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Cocreate and initialize the root INetCfg object. This will
|
|
optionally initialize COM for the caller too.
|
|
|
|
Arguments
|
|
|
|
pfInitCom [in,out] TRUE to call CoInitialize before creating.
|
|
returns TRUE if COM was successfully
|
|
initialized FALSE if not. If NULL, means
|
|
don't initialize COM.
|
|
ppnc [out] The returned INetCfg object.
|
|
fGetWriteLock [in] TRUE if a writable INetCfg is needed
|
|
cmsTimeout [in] See INetCfg::LockForWrite
|
|
szwClientDesc [in] See INetCfg::LockForWrite
|
|
ppszwClientDesc [out] See INetCfg::LockForWrite
|
|
|
|
Return Value
|
|
|
|
S_OK or an error code.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr;
|
|
|
|
|
|
// Initialize the output parameter.
|
|
*ppnc = NULL;
|
|
|
|
if (ppszwClientDesc)
|
|
*ppszwClientDesc = NULL;
|
|
|
|
// Initialize COM if the caller requested.
|
|
hr = S_OK;
|
|
if (pfInitCom && *pfInitCom)
|
|
{
|
|
hr = CoInitializeEx( NULL,
|
|
COINIT_DISABLE_OLE1DDE | COINIT_APARTMENTTHREADED );
|
|
if (RPC_E_CHANGED_MODE == hr)
|
|
{
|
|
hr = S_OK;
|
|
if (pfInitCom)
|
|
{
|
|
*pfInitCom = FALSE;
|
|
}
|
|
}
|
|
}
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Create the object implementing INetCfg.
|
|
//
|
|
INetCfg* pnc;
|
|
hr = CoCreateInstance(&CLSID_CNetCfg, NULL, CLSCTX_INPROC_SERVER,
|
|
&IID_INetCfg, (void**)(&pnc));
|
|
// TraceResult("HrCreateAndInitializeINetCfg - CoCreateInstance(CLSID_CNetCfg)", hr);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
INetCfgLock* pnclock = NULL;
|
|
if (fGetWriteLock)
|
|
{
|
|
// Get the locking interface
|
|
hr = pnc->lpVtbl->QueryInterface(pnc, &IID_INetCfgLock,
|
|
(LPVOID *)(&pnclock));
|
|
// TraceResult("HrCreateAndInitializeINetCfg - QueryInterface(IID_INetCfgLock", hr);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Attempt to lock the INetCfg for read/write
|
|
hr = pnclock->lpVtbl->AcquireWriteLock(pnclock, cmsTimeout, szwClientDesc,
|
|
ppszwClientDesc);
|
|
// TraceResult("HrCreateAndInitializeINetCfg - INetCfgLock::LockForWrite", hr);
|
|
if (S_FALSE == hr)
|
|
{
|
|
// Couldn't acquire the lock
|
|
hr = NETCFG_E_NO_WRITE_LOCK;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Initialize the INetCfg object.
|
|
//
|
|
hr = pnc->lpVtbl->Initialize (pnc, NULL);
|
|
// TraceResult("HrCreateAndInitializeINetCfg - Initialize", hr);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
*ppnc = pnc;
|
|
if (pnc)
|
|
pnc->lpVtbl->AddRef(pnc);
|
|
}
|
|
else
|
|
{
|
|
if (pnclock)
|
|
{
|
|
pnclock->lpVtbl->ReleaseWriteLock(pnclock);
|
|
}
|
|
}
|
|
// Transfer reference to caller.
|
|
}
|
|
|
|
if (pnclock)
|
|
{
|
|
pnclock->lpVtbl->Release(pnclock);
|
|
}
|
|
|
|
pnclock = NULL;
|
|
|
|
|
|
if (pnc)
|
|
{
|
|
pnc->lpVtbl->Release(pnc);
|
|
}
|
|
|
|
pnc = NULL;
|
|
}
|
|
|
|
// If we failed anything above, and we've initialized COM,
|
|
// be sure an uninitialize it.
|
|
//
|
|
if (FAILED(hr) && pfInitCom && *pfInitCom)
|
|
{
|
|
CoUninitialize ();
|
|
}
|
|
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
DWORD
|
|
GetTransportConfig(
|
|
INetCfg ** pNetCfg,
|
|
ITcpipProperties ** pTcpipProperties,
|
|
REMOTE_IPINFO **pRemoteIpInfo,
|
|
GUID *pGuid,
|
|
LPCWSTR pwszIfFriendlyName
|
|
)
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Arguments
|
|
|
|
Return Value
|
|
|
|
--*/
|
|
{
|
|
WCHAR wszDesc[] = L"Test of Change IP settings";
|
|
HRESULT hr;
|
|
|
|
// Create the INetCfg, we get the write lock because we need read and write
|
|
hr = HrCreateAndInitializeINetCfg(&g_fInitCom, /* &g_fInitCom, */
|
|
pNetCfg,
|
|
TRUE /* fGetWriteLock */,
|
|
500 /* cmsTimeout */,
|
|
wszDesc/* swzClientDesc */,
|
|
NULL /* ppszwClientDesc */);
|
|
|
|
if (hr == S_OK)
|
|
{
|
|
hr = HrGetIpPrivateInterface(*pNetCfg, pTcpipProperties);
|
|
}
|
|
|
|
if (hr == NETCFG_E_NO_WRITE_LOCK) {
|
|
|
|
DisplayMessage( g_hModule, EMSG_NETCFG_WRITE_LOCK );
|
|
return ERROR_SUPPRESS_OUTPUT;
|
|
}
|
|
|
|
if (hr == S_OK)
|
|
{
|
|
hr = (*pTcpipProperties)->lpVtbl->GetIpInfoForAdapter(*pTcpipProperties, pGuid, pRemoteIpInfo);
|
|
|
|
if (hr != S_OK)
|
|
{
|
|
DisplayMessage(g_hModule, EMSG_PROPERTIES, pwszIfFriendlyName);
|
|
hr = ERROR_SUPPRESS_OUTPUT;
|
|
}
|
|
}
|
|
|
|
return (hr==S_OK) ? NO_ERROR : hr;
|
|
}
|
|
|
|
|
|
VOID
|
|
UninitializeTransportConfig(
|
|
INetCfg * pNetCfg,
|
|
ITcpipProperties * pTcpipProperties,
|
|
REMOTE_IPINFO *pRemoteIpInfo
|
|
)
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Arguments
|
|
|
|
Return Value
|
|
|
|
--*/
|
|
{
|
|
if (pTcpipProperties)
|
|
pTcpipProperties->lpVtbl->Release(pTcpipProperties);
|
|
|
|
if (pNetCfg)
|
|
{
|
|
HrUninitializeAndReleaseINetCfg(FALSE,
|
|
pNetCfg,
|
|
TRUE /* fHasLock */);
|
|
}
|
|
|
|
if (pRemoteIpInfo) CoTaskMemFree(pRemoteIpInfo);
|
|
|
|
return;
|
|
}
|
|
|
|
DWORD
|
|
IfIpAddSetAddress(
|
|
LPCWSTR pwszIfFriendlyName,
|
|
GUID *pGuid,
|
|
LPCWSTR wszIp,
|
|
LPCWSTR wszMask,
|
|
DWORD Flags
|
|
)
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Arguments
|
|
|
|
Return Value
|
|
|
|
--*/
|
|
{
|
|
INetCfg * pNetCfg = NULL;
|
|
ITcpipProperties * pTcpipProperties = NULL;
|
|
DWORD dwNetwork;
|
|
DWORD dwErr = NO_ERROR;
|
|
REMOTE_IPINFO *pRemoteIpInfo = NULL;
|
|
REMOTE_IPINFO newIPInfo;
|
|
|
|
|
|
if (pGuid == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
|
|
dwErr = HRESULT_CODE(GetTransportConfig(
|
|
&pNetCfg,
|
|
&pTcpipProperties,
|
|
&pRemoteIpInfo,
|
|
pGuid,
|
|
pwszIfFriendlyName
|
|
));
|
|
|
|
|
|
while (dwErr == NO_ERROR) { //breakout block
|
|
|
|
PWCHAR ptrAddr, ptrMask;
|
|
DWORD Found = FALSE;
|
|
PWCHAR pszwRemoteIpAddrList=NULL, pszwRemoteIpSubnetMaskList=NULL,
|
|
pszwRemoteOptionList=pRemoteIpInfo->pszwOptionList;//i copy options list
|
|
PWCHAR IpAddrListEnd;
|
|
ULONG Length = wcslen(wszIp);
|
|
|
|
// currently in static mode
|
|
|
|
if (pRemoteIpInfo->dwEnableDhcp == FALSE) {
|
|
|
|
pszwRemoteIpAddrList = pRemoteIpInfo->pszwIpAddrList;
|
|
pszwRemoteIpSubnetMaskList = pRemoteIpInfo->pszwSubnetMaskList;
|
|
IpAddrListEnd = pszwRemoteIpAddrList + wcslen(pszwRemoteIpAddrList);
|
|
}
|
|
|
|
|
|
//
|
|
// if adding ipaddr, check if the IpAddr and Mask is already present
|
|
//
|
|
|
|
if (Flags & ADD_FLAG) {
|
|
|
|
//
|
|
// make sure it is in static mode
|
|
//
|
|
|
|
if (pRemoteIpInfo->dwEnableDhcp == TRUE) {
|
|
|
|
DisplayMessage(g_hModule,
|
|
EMSG_ADD_IPADDR_DHCP);
|
|
|
|
dwErr = ERROR_SUPPRESS_OUTPUT;
|
|
break;
|
|
}
|
|
|
|
ptrAddr = pszwRemoteIpAddrList;
|
|
ptrMask = pszwRemoteIpSubnetMaskList;
|
|
|
|
while (ptrAddr && (ptrAddr + Length <= IpAddrListEnd) ){
|
|
|
|
if (wcsncmp(ptrAddr, wszIp, Length) == 0) {
|
|
|
|
if ( *(ptrAddr+Length)==0 || *(ptrAddr+Length)==c_wListSeparatorComma){
|
|
|
|
Found = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
ptrAddr = wcschr(ptrAddr, c_wListSeparatorComma);
|
|
ptrMask = wcschr(ptrMask, c_wListSeparatorComma);
|
|
|
|
if (ptrAddr){
|
|
ptrAddr++;
|
|
ptrMask++;
|
|
}
|
|
}
|
|
|
|
if (Found) {
|
|
|
|
PWCHAR MaskEnd;
|
|
MaskEnd = wcschr(ptrMask, c_wListSeparatorComma);
|
|
if (MaskEnd)
|
|
*MaskEnd = 0;
|
|
|
|
DisplayMessage(g_hModule,
|
|
EMSG_IPADDR_PRESENT,
|
|
wszIp, ptrMask);
|
|
|
|
if (MaskEnd)
|
|
*MaskEnd = c_wListSeparatorComma;
|
|
|
|
dwErr = ERROR_SUPPRESS_OUTPUT;
|
|
break;
|
|
}
|
|
}
|
|
memcpy(&newIPInfo, pRemoteIpInfo, sizeof(newIPInfo));
|
|
newIPInfo.dwEnableDhcp = FALSE;
|
|
|
|
//
|
|
// copy ip addr list
|
|
//
|
|
|
|
if (Flags & ADD_FLAG) {
|
|
|
|
ULONG IpAddrListLength = 0;
|
|
|
|
if (pszwRemoteIpAddrList)
|
|
IpAddrListLength = wcslen(pszwRemoteIpAddrList);
|
|
|
|
newIPInfo.pszwIpAddrList = IfutlAlloc (sizeof(WCHAR) *
|
|
(IpAddrListLength +
|
|
Length + 2), TRUE);
|
|
|
|
if (!newIPInfo.pszwIpAddrList)
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
|
|
newIPInfo.pszwIpAddrList[0] = 0;
|
|
|
|
if (pszwRemoteIpAddrList) {
|
|
wcscat(newIPInfo.pszwIpAddrList, pszwRemoteIpAddrList);
|
|
wcscat(newIPInfo.pszwIpAddrList, c_wszListSeparatorComma);
|
|
}
|
|
|
|
wcscat(newIPInfo.pszwIpAddrList, wszIp);
|
|
}
|
|
else {
|
|
newIPInfo.pszwIpAddrList = IfutlAlloc (sizeof(WCHAR) *
|
|
(Length + 1), FALSE);
|
|
|
|
if (!newIPInfo.pszwIpAddrList)
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
|
|
wcscpy(newIPInfo.pszwIpAddrList, wszIp);
|
|
}
|
|
|
|
//
|
|
// copy subnet mask list
|
|
//
|
|
|
|
if (Flags & ADD_FLAG) {
|
|
|
|
ULONG RemoteIpSubnetMaskListLen = 0;
|
|
|
|
if (pszwRemoteIpSubnetMaskList)
|
|
RemoteIpSubnetMaskListLen = wcslen(pszwRemoteIpSubnetMaskList);
|
|
|
|
newIPInfo.pszwSubnetMaskList = IfutlAlloc (sizeof(WCHAR) *
|
|
(RemoteIpSubnetMaskListLen +
|
|
wcslen(wszMask) + 2), TRUE);
|
|
|
|
if (!newIPInfo.pszwSubnetMaskList)
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
|
|
newIPInfo.pszwSubnetMaskList[0]= 0;
|
|
|
|
if (pszwRemoteIpSubnetMaskList) {
|
|
wcscpy(newIPInfo.pszwSubnetMaskList, pszwRemoteIpSubnetMaskList);
|
|
wcscat(newIPInfo.pszwSubnetMaskList, c_wszListSeparatorComma);
|
|
}
|
|
|
|
wcscat(newIPInfo.pszwSubnetMaskList, wszMask);
|
|
}
|
|
else {
|
|
newIPInfo.pszwSubnetMaskList = IfutlAlloc (sizeof(WCHAR) *
|
|
(wcslen(wszMask) + 1), FALSE);
|
|
|
|
if (!newIPInfo.pszwSubnetMaskList)
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
|
|
wcscpy(newIPInfo.pszwSubnetMaskList, wszMask);
|
|
}
|
|
|
|
|
|
|
|
// copy old options list
|
|
|
|
newIPInfo.pszwOptionList = _wcsdup(pszwRemoteOptionList);
|
|
|
|
DEBUG_PRINT_CONFIG(&newIPInfo);
|
|
|
|
//
|
|
// set the ip address
|
|
//
|
|
dwErr = HRESULT_CODE(pTcpipProperties->lpVtbl->SetIpInfoForAdapter(
|
|
pTcpipProperties, pGuid, &newIPInfo));
|
|
|
|
if (dwErr == NO_ERROR)
|
|
dwErr = HRESULT_CODE(pNetCfg->lpVtbl->Apply(pNetCfg));
|
|
|
|
|
|
if (newIPInfo.pszwIpAddrList) IfutlFree(newIPInfo.pszwIpAddrList);
|
|
if (newIPInfo.pszwSubnetMaskList) IfutlFree(newIPInfo.pszwSubnetMaskList);
|
|
if (newIPInfo.pszwOptionList) free(newIPInfo.pszwOptionList);
|
|
|
|
break; //breakout block
|
|
|
|
} //breakout block
|
|
|
|
|
|
UninitializeTransportConfig(
|
|
pNetCfg,
|
|
pTcpipProperties,
|
|
pRemoteIpInfo
|
|
);
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
VOID
|
|
AppendDdnsOptions(
|
|
PWCHAR ptrDstn,
|
|
PWCHAR ptrOptionList,
|
|
DWORD Flags,
|
|
DWORD dwRegisterMode
|
|
)
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Adds the appropriate "DynamicUpdate=...;NameRegistration=...;"
|
|
string to a net config option list.
|
|
|
|
Arguments
|
|
|
|
ptrDstn [in] Buffer to which to append DDNS options.
|
|
ptrOptionList [in] Old option list.
|
|
Flags [in] Used to tell whether this is in a SET or ADD.
|
|
dwRegisterMode [in] New mode to convert to options values.
|
|
|
|
Return Value
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
PWCHAR ptrBegin, ptrEnd;
|
|
|
|
//
|
|
// Insert DynamicUpdate=...;
|
|
//
|
|
wcscat(ptrDstn, c_wcsDdns);
|
|
if ((Flags & SET_FLAG) && (dwRegisterMode != REGISTER_UNCHANGED)) {
|
|
//
|
|
// Insert the new value.
|
|
//
|
|
if (dwRegisterMode == REGISTER_NONE) {
|
|
wcscat(ptrDstn, L"0");
|
|
} else {
|
|
wcscat(ptrDstn, L"1");
|
|
}
|
|
} else {
|
|
//
|
|
// Copy the previous value.
|
|
//
|
|
ptrBegin = wcsstr(ptrOptionList, c_wcsDdns) +
|
|
wcslen(c_wcsDdns);
|
|
ptrEnd = wcschr(ptrBegin, c_wListSeparatorSC);
|
|
|
|
ptrDstn += wcslen(ptrDstn);
|
|
wcsncpy(ptrDstn, ptrBegin, (DWORD)(ptrEnd - ptrBegin));
|
|
ptrDstn += (ULONG)(ptrEnd - ptrBegin);
|
|
*ptrDstn = 0;
|
|
}
|
|
wcscat(ptrDstn, c_wszListSeparatorSC);
|
|
|
|
//
|
|
// Insert NameRegistration=...;
|
|
//
|
|
wcscat(ptrDstn, c_wcsDdnsSuffix);
|
|
if ((Flags & SET_FLAG) && (dwRegisterMode != REGISTER_UNCHANGED)) {
|
|
//
|
|
// Insert the new value.
|
|
//
|
|
if (dwRegisterMode == REGISTER_BOTH) {
|
|
wcscat(ptrDstn, L"1");
|
|
} else {
|
|
wcscat(ptrDstn, L"0");
|
|
}
|
|
} else {
|
|
//
|
|
// Copy the previous value.
|
|
//
|
|
ptrBegin = wcsstr(ptrOptionList, c_wcsDdnsSuffix) +
|
|
wcslen(c_wcsDdnsSuffix);
|
|
ptrEnd = wcschr(ptrBegin, c_wListSeparatorSC);
|
|
|
|
ptrDstn += wcslen(ptrDstn);
|
|
wcsncpy(ptrDstn, ptrBegin, (DWORD)(ptrEnd - ptrBegin));
|
|
ptrDstn += (ULONG)(ptrEnd - ptrBegin);
|
|
*ptrDstn = 0;
|
|
}
|
|
wcscat(ptrDstn, c_wszListSeparatorSC);
|
|
}
|
|
|
|
DWORD
|
|
IfIpSetDhcpModeMany(
|
|
LPCWSTR pwszIfFriendlyName,
|
|
GUID *pGuid,
|
|
DWORD dwRegisterMode,
|
|
DISPLAY_TYPE Type
|
|
)
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Arguments
|
|
|
|
Return Value
|
|
|
|
--*/
|
|
{
|
|
INetCfg * pNetCfg = NULL;
|
|
ITcpipProperties * pTcpipProperties = NULL;
|
|
DWORD dwNetwork;
|
|
HRESULT hr = S_OK;
|
|
REMOTE_IPINFO *pRemoteIpInfo = NULL;
|
|
REMOTE_IPINFO newIPInfo;
|
|
|
|
if (pGuid == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
|
|
hr = GetTransportConfig(
|
|
&pNetCfg,
|
|
&pTcpipProperties,
|
|
&pRemoteIpInfo,
|
|
pGuid,
|
|
pwszIfFriendlyName
|
|
);
|
|
|
|
|
|
while (hr == NO_ERROR) { //breakout block
|
|
|
|
PWCHAR pszwBuffer;
|
|
PWCHAR ptr, newPtr;
|
|
|
|
PWCHAR pszwRemoteOptionList=pRemoteIpInfo->pszwOptionList;
|
|
|
|
try {
|
|
#pragma prefast(suppress:263, "This is a breakout block, not while loop")
|
|
pszwBuffer = (PWCHAR) _alloca(sizeof(WCHAR) *
|
|
(wcslen(pszwRemoteOptionList) + 100)) ;
|
|
} except (EXCEPTION_EXECUTE_HANDLER) {
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
|
|
|
|
|
|
// if setting ipaddr, check if dhcp already enabled. return.
|
|
|
|
if (Type==TYPE_IPADDR && pRemoteIpInfo->dwEnableDhcp) {
|
|
|
|
DisplayMessage(g_hModule,
|
|
EMSG_DHCP_MODE);
|
|
|
|
hr = ERROR_SUPPRESS_OUTPUT;
|
|
break;
|
|
}
|
|
|
|
|
|
memcpy(&newIPInfo, pRemoteIpInfo, sizeof(REMOTE_IPINFO));
|
|
newIPInfo.dwEnableDhcp = pRemoteIpInfo->dwEnableDhcp;
|
|
newIPInfo.pszwOptionList = pszwBuffer;
|
|
|
|
|
|
pszwBuffer[0] = 0;
|
|
switch(Type) {
|
|
case TYPE_DNS:
|
|
wcscpy(pszwBuffer, c_wcsDns);
|
|
wcscat(pszwBuffer, c_wszListSeparatorSC);
|
|
|
|
AppendDdnsOptions(pszwBuffer + wcslen(pszwBuffer),
|
|
pRemoteIpInfo->pszwOptionList,
|
|
SET_FLAG, dwRegisterMode);
|
|
break;
|
|
|
|
case TYPE_WINS:
|
|
wcscpy(pszwBuffer, c_wcsWins);
|
|
wcscat(pszwBuffer, c_wszListSeparatorSC);
|
|
break;
|
|
|
|
|
|
case TYPE_IPADDR:
|
|
|
|
newIPInfo.dwEnableDhcp = TRUE;
|
|
|
|
newIPInfo.pszwIpAddrList = NULL;
|
|
newIPInfo.pszwSubnetMaskList = NULL;
|
|
|
|
wcscpy(pszwBuffer, c_wcsDefGateway);
|
|
wcscat(pszwBuffer, c_wszListSeparatorSC);
|
|
wcscat(pszwBuffer, c_wcsGwMetric);
|
|
wcscat(pszwBuffer, c_wszListSeparatorSC);
|
|
break;
|
|
}
|
|
|
|
DEBUG_PRINT_CONFIG(&newIPInfo);
|
|
|
|
|
|
|
|
//
|
|
// set the ip address
|
|
//
|
|
hr = pTcpipProperties->lpVtbl->SetIpInfoForAdapter(pTcpipProperties, pGuid, &newIPInfo);
|
|
|
|
if (hr == S_OK)
|
|
hr = pNetCfg->lpVtbl->Apply(pNetCfg);
|
|
|
|
break;
|
|
|
|
} //breakout block
|
|
|
|
|
|
UninitializeTransportConfig(
|
|
pNetCfg,
|
|
pTcpipProperties,
|
|
pRemoteIpInfo
|
|
);
|
|
|
|
return (hr == S_OK) ? NO_ERROR : hr;
|
|
}
|
|
|
|
|
|
DWORD
|
|
IfIpAddSetDelMany(
|
|
PWCHAR wszIfFriendlyName,
|
|
GUID *pGuid,
|
|
PWCHAR pwszAddress,
|
|
DWORD dwIndex,
|
|
DWORD dwRegisterMode,
|
|
DISPLAY_TYPE Type,
|
|
DWORD Flags
|
|
)
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Arguments
|
|
|
|
Return Value
|
|
|
|
--*/
|
|
{
|
|
INetCfg * pNetCfg = NULL;
|
|
ITcpipProperties * pTcpipProperties = NULL;
|
|
DWORD dwNetwork;
|
|
HRESULT hr = S_OK;
|
|
REMOTE_IPINFO * pRemoteIpInfo = NULL;
|
|
REMOTE_IPINFO newIPInfo;
|
|
|
|
if (pGuid == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
hr = GetTransportConfig(
|
|
&pNetCfg,
|
|
&pTcpipProperties,
|
|
&pRemoteIpInfo,
|
|
pGuid,
|
|
wszIfFriendlyName
|
|
);
|
|
|
|
|
|
while (hr==NO_ERROR) { //breakout block
|
|
|
|
PWCHAR ptrBegin, ptrEnd, ptrTmp, ptrDstn, ptrDel=NULL;
|
|
const WCHAR * Token;
|
|
|
|
switch (Type) {
|
|
|
|
case TYPE_DNS:
|
|
Token = c_wcsDns;
|
|
break;
|
|
|
|
case TYPE_WINS:
|
|
Token = c_wcsWins;
|
|
break;
|
|
}
|
|
|
|
ptrBegin = wcsstr(pRemoteIpInfo->pszwOptionList, Token) + wcslen(Token);
|
|
ptrEnd = wcschr(ptrBegin, c_wListSeparatorSC);
|
|
|
|
//
|
|
// check if the address is already present
|
|
//
|
|
if ( (Flags & (ADD_FLAG | DEL_FLAG)) && (pwszAddress)) {
|
|
|
|
ULONG Length = wcslen(pwszAddress), Found = FALSE;
|
|
|
|
ptrTmp = ptrBegin;
|
|
|
|
while (ptrTmp && (ptrTmp+Length <= ptrEnd) ){
|
|
|
|
if (ptrTmp = wcsstr(ptrTmp, pwszAddress)) {
|
|
|
|
if ( ((*(ptrTmp+Length)==c_wListSeparatorComma)
|
|
|| (*(ptrTmp+Length)==c_wListSeparatorSC) )
|
|
&& ( (*(ptrTmp-1)==c_wListSeparatorComma)
|
|
|| (*(ptrTmp-1)==c_wEqual)) )
|
|
{
|
|
Found = TRUE;
|
|
ptrDel = ptrTmp;
|
|
break;
|
|
}
|
|
else {
|
|
ptrTmp = wcschr(ptrTmp, c_wListSeparatorComma);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (Found && (Flags & ADD_FLAG)) {
|
|
|
|
DisplayMessage(g_hModule,
|
|
EMSG_SERVER_PRESENT,
|
|
pwszAddress);
|
|
hr = ERROR_SUPPRESS_OUTPUT;
|
|
break; //from breakout block
|
|
}
|
|
else if (!Found && (Flags & DEL_FLAG)) {
|
|
|
|
DisplayMessage(g_hModule,
|
|
EMSG_SERVER_ABSENT,
|
|
pwszAddress);
|
|
hr = ERROR_SUPPRESS_OUTPUT;
|
|
break; //from breakout block
|
|
|
|
}
|
|
|
|
} // breakout block
|
|
|
|
memcpy(&newIPInfo, pRemoteIpInfo, sizeof(newIPInfo));
|
|
|
|
// copy ip addr list
|
|
{
|
|
newIPInfo.pszwIpAddrList = pRemoteIpInfo->pszwIpAddrList;
|
|
}
|
|
|
|
// copy subnet mask list
|
|
{
|
|
newIPInfo.pszwSubnetMaskList = pRemoteIpInfo->pszwSubnetMaskList;
|
|
}
|
|
|
|
try {
|
|
#pragma prefast(suppress:263, "This is a breakout block, not while loop")
|
|
newIPInfo.pszwOptionList =
|
|
(PWCHAR) _alloca(sizeof(PWCHAR) *
|
|
(wcslen(pRemoteIpInfo->pszwOptionList)+
|
|
(pwszAddress?wcslen(pwszAddress):0) + 1));
|
|
|
|
} except (EXCEPTION_EXECUTE_HANDLER) {
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
|
|
|
|
// copy token in all cases
|
|
|
|
ptrDstn = newIPInfo.pszwOptionList;
|
|
ptrDstn[0] = 0;
|
|
wcscpy(ptrDstn, Token);
|
|
ptrDstn += wcslen(Token);
|
|
|
|
if (Flags & ADD_FLAG) {
|
|
|
|
DWORD i;
|
|
|
|
ptrTmp = ptrBegin;
|
|
|
|
for (i=0; i<dwIndex-1 && ptrTmp && ptrTmp<ptrEnd; i++) {
|
|
|
|
ptrTmp = wcschr(ptrTmp, c_wListSeparatorComma);
|
|
if (ptrTmp) ptrTmp++;
|
|
}
|
|
|
|
if (!ptrTmp || (ptrTmp > ptrEnd)) {
|
|
ptrTmp = ptrEnd;
|
|
}
|
|
|
|
if (*(ptrTmp-1) == c_wListSeparatorComma)
|
|
ptrTmp--;
|
|
|
|
// copy addresses before index
|
|
|
|
if (ptrTmp>ptrBegin) {
|
|
wcsncpy(ptrDstn, ptrBegin, (DWORD)(ptrTmp-ptrBegin));
|
|
ptrDstn += (ULONG) (ptrTmp - ptrBegin);
|
|
|
|
ptrTmp++;
|
|
*ptrDstn++ = c_wListSeparatorComma;
|
|
*ptrDstn = 0;
|
|
}
|
|
|
|
}
|
|
|
|
// copy new address
|
|
|
|
if (Flags & (ADD_FLAG|SET_FLAG) ) {
|
|
|
|
if (pwszAddress) {
|
|
wcscat(ptrDstn, pwszAddress);
|
|
ptrDstn += wcslen(pwszAddress);
|
|
}
|
|
}
|
|
|
|
// copy addresses after index
|
|
|
|
if (Flags & ADD_FLAG) {
|
|
|
|
if (ptrTmp < ptrEnd) {
|
|
*ptrDstn++ = c_wListSeparatorComma;
|
|
*ptrDstn = 0;
|
|
|
|
wcsncpy(ptrDstn, ptrTmp, (DWORD)(ptrEnd - ptrTmp));
|
|
ptrDstn += (ULONG)(ptrEnd - ptrTmp);
|
|
*ptrDstn = 0;
|
|
}
|
|
}
|
|
|
|
if (Flags & (ADD_FLAG|SET_FLAG) ) {
|
|
wcscat(ptrDstn, c_wszListSeparatorSC);
|
|
}
|
|
|
|
|
|
if (Flags & DEL_FLAG) {
|
|
|
|
if (pwszAddress && ptrDel) {//ptrDel to make prefast happy
|
|
//if ptrDel not set, then I would have
|
|
//got out of breakout block.
|
|
|
|
BOOL AddrPrepend = FALSE;
|
|
|
|
if (ptrDel > ptrBegin) {
|
|
wcsncat(ptrDstn, ptrBegin, (DWORD)(ptrDel-ptrBegin));
|
|
ptrDstn += (ULONG)(ptrDel-ptrBegin);
|
|
AddrPrepend = TRUE;
|
|
if ( *(ptrDstn-1) == c_wListSeparatorComma) {
|
|
*(--ptrDstn) = 0;
|
|
}
|
|
}
|
|
|
|
ptrTmp = ptrDel + wcslen(pwszAddress);
|
|
if (*ptrTmp == c_wListSeparatorComma)
|
|
ptrTmp++;
|
|
|
|
if (AddrPrepend && *ptrTmp!=c_wListSeparatorSC)
|
|
*ptrDstn++ = c_wListSeparatorComma;
|
|
|
|
wcsncat(ptrDstn, ptrTmp, (DWORD)(ptrEnd - ptrTmp));
|
|
ptrDstn += (ULONG)(ptrEnd - ptrTmp);
|
|
*ptrDstn = 0;
|
|
}
|
|
|
|
wcscat(ptrDstn, c_wszListSeparatorSC);
|
|
}
|
|
|
|
if (Type == TYPE_DNS) {
|
|
AppendDdnsOptions(ptrDstn, pRemoteIpInfo->pszwOptionList,
|
|
Flags, dwRegisterMode);
|
|
}
|
|
|
|
DEBUG_PRINT_CONFIG(&newIPInfo);
|
|
|
|
|
|
//
|
|
// set the ip address
|
|
//
|
|
hr = pTcpipProperties->lpVtbl->SetIpInfoForAdapter(pTcpipProperties, pGuid, &newIPInfo);
|
|
|
|
if (hr == S_OK)
|
|
hr = pNetCfg->lpVtbl->Apply(pNetCfg);
|
|
|
|
break;
|
|
|
|
} //breakout block
|
|
|
|
|
|
UninitializeTransportConfig(
|
|
pNetCfg,
|
|
pTcpipProperties,
|
|
pRemoteIpInfo
|
|
);
|
|
|
|
return (hr == S_OK) ? NO_ERROR : hr;
|
|
}
|
|
|
|
|
|
DWORD
|
|
IfIpAddSetGateway(
|
|
LPCWSTR pwszIfFriendlyName,
|
|
GUID *pGuid,
|
|
LPCWSTR pwszGateway,
|
|
LPCWSTR pwszGwMetric,
|
|
DWORD Flags
|
|
)
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Arguments
|
|
|
|
Return Value
|
|
|
|
--*/
|
|
{
|
|
INetCfg * pNetCfg = NULL;
|
|
ITcpipProperties * pTcpipProperties = NULL;
|
|
DWORD dwNetwork;
|
|
HRESULT hr = S_OK;
|
|
REMOTE_IPINFO *pRemoteIpInfo = NULL;
|
|
REMOTE_IPINFO newIPInfo;
|
|
PWCHAR Gateways, GatewaysEnd, GwMetrics, GwMetricsEnd;
|
|
|
|
if (pGuid == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
hr = GetTransportConfig(
|
|
&pNetCfg,
|
|
&pTcpipProperties,
|
|
&pRemoteIpInfo,
|
|
pGuid,
|
|
pwszIfFriendlyName
|
|
);
|
|
|
|
while (hr==NO_ERROR) { //breakout block
|
|
|
|
PWCHAR ptrAddr, ptrMask;
|
|
DWORD bFound = FALSE;
|
|
PWCHAR pszwRemoteIpAddrList=NULL, pszwRemoteIpSubnetMaskList=NULL,
|
|
pszwRemoteOptionList=NULL;
|
|
|
|
|
|
pszwRemoteIpAddrList = pRemoteIpInfo->pszwIpAddrList;
|
|
pszwRemoteIpSubnetMaskList = pRemoteIpInfo->pszwSubnetMaskList;
|
|
pszwRemoteOptionList = pRemoteIpInfo->pszwOptionList;
|
|
|
|
Gateways = wcsstr(pszwRemoteOptionList, c_wcsDefGateway) + wcslen(c_wcsDefGateway);
|
|
GatewaysEnd = wcschr(Gateways, c_wListSeparatorSC);
|
|
GwMetrics = wcsstr(pszwRemoteOptionList, c_wcsGwMetric) + wcslen(c_wcsGwMetric);
|
|
GwMetricsEnd = wcschr(GwMetrics, c_wListSeparatorSC);
|
|
|
|
|
|
|
|
//
|
|
// check if the gateway is already present
|
|
//
|
|
|
|
if (Flags & ADD_FLAG) {
|
|
|
|
ULONG Length = wcslen(pwszGateway), Found = FALSE;
|
|
PWCHAR TmpPtr;
|
|
|
|
TmpPtr = Gateways;
|
|
|
|
while (TmpPtr && (TmpPtr+Length <= GatewaysEnd) ){
|
|
|
|
if (TmpPtr = wcsstr(TmpPtr, pwszGateway)) {
|
|
|
|
if ( ((*(TmpPtr+Length)==c_wListSeparatorComma)
|
|
|| (*(TmpPtr+Length)==c_wListSeparatorSC) )
|
|
&& ( (*(TmpPtr-1)==c_wListSeparatorComma)
|
|
|| (*(TmpPtr-1)==c_wEqual)) )
|
|
{
|
|
Found = TRUE;
|
|
break;
|
|
}
|
|
else {
|
|
TmpPtr = wcschr(TmpPtr, c_wListSeparatorComma);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (Found) {
|
|
DisplayMessage(g_hModule,
|
|
EMSG_DEFGATEWAY_PRESENT,
|
|
pwszGateway);
|
|
hr = ERROR_SUPPRESS_OUTPUT;
|
|
break; //from breakout block
|
|
}
|
|
}
|
|
|
|
memcpy(&newIPInfo, pRemoteIpInfo, sizeof(newIPInfo));
|
|
|
|
|
|
// copy ip addr list
|
|
newIPInfo.pszwIpAddrList = pRemoteIpInfo->pszwIpAddrList;
|
|
|
|
|
|
// copy subnet mask list
|
|
newIPInfo.pszwSubnetMaskList = pRemoteIpInfo->pszwSubnetMaskList;
|
|
|
|
// copy old options list
|
|
|
|
if (Flags & ADD_FLAG) {
|
|
|
|
newIPInfo.pszwOptionList = IfutlAlloc (sizeof(WCHAR) *
|
|
(wcslen(pszwRemoteOptionList) +
|
|
wcslen(pwszGateway) +
|
|
wcslen(pwszGwMetric) +
|
|
3), TRUE);
|
|
if (!newIPInfo.pszwOptionList) {
|
|
hr = ERROR_NOT_ENOUGH_MEMORY;
|
|
break; //from breakout block
|
|
}
|
|
|
|
wcsncpy(newIPInfo.pszwOptionList, pszwRemoteOptionList,
|
|
(DWORD)(GatewaysEnd - pszwRemoteOptionList));
|
|
|
|
*(newIPInfo.pszwOptionList + (GatewaysEnd - pszwRemoteOptionList)) = 0;
|
|
if (*(GatewaysEnd-1) != c_wEqual) {
|
|
wcscat(newIPInfo.pszwOptionList, c_wszListSeparatorComma);
|
|
}
|
|
wcscat(newIPInfo.pszwOptionList, pwszGateway);
|
|
wcscat(newIPInfo.pszwOptionList, c_wszListSeparatorSC);
|
|
|
|
{
|
|
ULONG Length;
|
|
Length = wcslen(newIPInfo.pszwOptionList);
|
|
|
|
wcsncat(newIPInfo.pszwOptionList, GatewaysEnd+1,
|
|
(DWORD)(GwMetricsEnd - (GatewaysEnd+1)));
|
|
Length += (DWORD) (GwMetricsEnd - (GatewaysEnd+1));
|
|
|
|
newIPInfo.pszwOptionList[Length] = 0;
|
|
}
|
|
|
|
if (*(GwMetricsEnd-1) != c_wEqual) {
|
|
wcscat(newIPInfo.pszwOptionList, c_wszListSeparatorComma);
|
|
}
|
|
|
|
wcscat(newIPInfo.pszwOptionList, pwszGwMetric);
|
|
wcscat(newIPInfo.pszwOptionList, c_wszListSeparatorSC);
|
|
wcscat(newIPInfo.pszwOptionList, GwMetricsEnd+1);
|
|
}
|
|
else {
|
|
|
|
ULONG Length;
|
|
|
|
Length = sizeof(WCHAR) * (wcslen(c_wcsDefGateway) + wcslen(c_wcsGwMetric) + 3);
|
|
if (pwszGateway)
|
|
Length += sizeof(WCHAR) * (wcslen(pwszGateway) + wcslen(pwszGwMetric));
|
|
|
|
newIPInfo.pszwOptionList = (PWCHAR) IfutlAlloc (Length, FALSE);
|
|
if (newIPInfo.pszwOptionList == NULL) {
|
|
hr = ERROR_NOT_ENOUGH_MEMORY;
|
|
break; //from breakout block
|
|
}
|
|
newIPInfo.pszwOptionList[0] = 0;
|
|
|
|
// cat gateway
|
|
|
|
wcscat(newIPInfo.pszwOptionList, c_wcsDefGateway);
|
|
if (pwszGateway)
|
|
wcscat(newIPInfo.pszwOptionList, pwszGateway);
|
|
|
|
wcscat(newIPInfo.pszwOptionList, c_wszListSeparatorSC);
|
|
|
|
// cat gwmetric
|
|
|
|
wcscat(newIPInfo.pszwOptionList, c_wcsGwMetric);
|
|
if (pwszGateway)
|
|
wcscat(newIPInfo.pszwOptionList, pwszGwMetric);
|
|
|
|
wcscat(newIPInfo.pszwOptionList, c_wszListSeparatorSC);
|
|
}
|
|
|
|
|
|
DEBUG_PRINT_CONFIG(&newIPInfo);
|
|
|
|
|
|
//
|
|
// set the ip address
|
|
//
|
|
hr = pTcpipProperties->lpVtbl->SetIpInfoForAdapter(pTcpipProperties, pGuid, &newIPInfo);
|
|
|
|
if (hr == S_OK)
|
|
hr = pNetCfg->lpVtbl->Apply(pNetCfg);
|
|
|
|
|
|
if (newIPInfo.pszwOptionList) IfutlFree(newIPInfo.pszwOptionList);
|
|
|
|
break;
|
|
|
|
} //breakout block
|
|
|
|
|
|
UninitializeTransportConfig(
|
|
pNetCfg,
|
|
pTcpipProperties,
|
|
pRemoteIpInfo
|
|
);
|
|
|
|
return (hr == S_OK) ? NO_ERROR : hr;
|
|
}
|
|
|
|
//
|
|
// Display an IP address in Unicode form. If First is false,
|
|
// a string of spaces will first be printed so that the list lines up.
|
|
// For the first address, the caller is responsible for printing the
|
|
// header before calling this function.
|
|
//
|
|
VOID
|
|
ShowUnicodeAddress(
|
|
BOOL *pFirst,
|
|
PWCHAR pwszAddress)
|
|
{
|
|
if (*pFirst) {
|
|
*pFirst = FALSE;
|
|
} else {
|
|
DisplayMessage(g_hModule, MSG_ADDR2);
|
|
}
|
|
DisplayMessage(g_hModule, MSG_ADDR1, pwszAddress);
|
|
}
|
|
|
|
// Same as ShowUnicodeAddress, except that the address is passed
|
|
// in multibyte form, such as is used by IPHLPAPI
|
|
VOID
|
|
ShowCharAddress(
|
|
BOOL *pFirst,
|
|
char *chAddress)
|
|
{
|
|
WCHAR pwszBuffer[16];
|
|
|
|
if (!chAddress[0]) {
|
|
return;
|
|
}
|
|
|
|
MultiByteToWideChar(GetConsoleOutputCP(), 0, chAddress, strlen(chAddress)+1,
|
|
pwszBuffer, 16);
|
|
|
|
ShowUnicodeAddress(pFirst, pwszBuffer);
|
|
}
|
|
|
|
DWORD
|
|
IfIpShowManyExEx(
|
|
LPCWSTR pwszMachineName,
|
|
ULONG IfIndex,
|
|
PWCHAR pFriendlyIfName,
|
|
GUID *pGuid,
|
|
ULONG Flags,
|
|
HANDLE hFile
|
|
)
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Arguments
|
|
|
|
Return Value
|
|
|
|
--*/
|
|
{
|
|
INetCfg * pNetCfg = NULL;
|
|
ITcpipProperties * pTcpipProperties = NULL;
|
|
DWORD dwNetwork, dwSize = 0, dwErr;
|
|
HRESULT hr = S_OK;
|
|
REMOTE_IPINFO *pRemoteIpInfo = NULL;
|
|
REMOTE_IPINFO newIPInfo;
|
|
PWCHAR pQuotedFriendlyIfName = NULL;
|
|
PIP_PER_ADAPTER_INFO pPerAdapterInfo = NULL;
|
|
PIP_ADAPTER_INFO pAdaptersInfo = NULL, pAdapterInfo = NULL;
|
|
DWORD dwRegisterMode;
|
|
|
|
if (pGuid == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
if (hFile && pwszMachineName) {
|
|
// not currently remotable
|
|
return NO_ERROR;
|
|
}
|
|
|
|
if (!hFile && !pwszMachineName) {
|
|
//
|
|
// If we're not doing a "dump", and we're looking at the local
|
|
// machine, then get active per-adapter information such as the
|
|
// current DNS and WINS server addresses
|
|
//
|
|
|
|
GetPerAdapterInfo(IfIndex, NULL, &dwSize);
|
|
pPerAdapterInfo = (PIP_PER_ADAPTER_INFO)IfutlAlloc(dwSize,FALSE);
|
|
if (!pPerAdapterInfo) {
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
dwErr = GetPerAdapterInfo(IfIndex, pPerAdapterInfo, &dwSize);
|
|
if (dwErr != NO_ERROR) {
|
|
IfutlFree(pPerAdapterInfo);
|
|
pPerAdapterInfo = NULL;
|
|
}
|
|
|
|
dwSize = 0;
|
|
GetAdaptersInfo(NULL, &dwSize);
|
|
pAdaptersInfo = (PIP_ADAPTER_INFO)IfutlAlloc(dwSize,FALSE);
|
|
if (!pAdaptersInfo) {
|
|
IfutlFree(pPerAdapterInfo);
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
dwErr = GetAdaptersInfo(pAdaptersInfo, &dwSize);
|
|
if (dwErr != NO_ERROR) {
|
|
IfutlFree(pAdaptersInfo);
|
|
pAdaptersInfo = NULL;
|
|
}
|
|
if (pAdaptersInfo) {
|
|
for (pAdapterInfo = pAdaptersInfo;
|
|
pAdapterInfo && pAdapterInfo->Index != IfIndex;
|
|
pAdapterInfo = pAdapterInfo->Next);
|
|
}
|
|
}
|
|
|
|
hr = GetTransportConfig(
|
|
&pNetCfg,
|
|
&pTcpipProperties,
|
|
&pRemoteIpInfo,
|
|
pGuid,
|
|
pFriendlyIfName
|
|
);
|
|
|
|
while (hr==NO_ERROR) { //breakout block
|
|
|
|
PWCHAR ptrAddr, ptrMask, ptrAddrNew, ptrMaskNew;
|
|
|
|
|
|
if (hr != NO_ERROR)
|
|
break;
|
|
|
|
|
|
pQuotedFriendlyIfName = MakeQuotedString( pFriendlyIfName );
|
|
|
|
if ( pQuotedFriendlyIfName == NULL ) {
|
|
hr = ERROR_NOT_ENOUGH_MEMORY;
|
|
break;
|
|
}
|
|
|
|
|
|
DEBUG_PRINT_CONFIG(pRemoteIpInfo);
|
|
|
|
|
|
if (hFile) {
|
|
DisplayMessage(g_hModule,
|
|
DMP_IFIP_INTERFACE_HEADER,
|
|
pQuotedFriendlyIfName);
|
|
}
|
|
else {
|
|
|
|
DisplayMessage(g_hModule,
|
|
MSG_IFIP_HEADER,
|
|
pQuotedFriendlyIfName);
|
|
}
|
|
|
|
|
|
//
|
|
// display ipaddress list
|
|
//
|
|
|
|
if (Flags & TYPE_IPADDR) {
|
|
|
|
if (hFile) {
|
|
DisplayMessageT(
|
|
(pRemoteIpInfo->dwEnableDhcp) ? DMP_DHCP : DMP_STATIC,
|
|
pQuotedFriendlyIfName
|
|
);
|
|
}
|
|
else {
|
|
DisplayMessage(g_hModule,
|
|
(pRemoteIpInfo->dwEnableDhcp) ? MSG_DHCP : MSG_STATIC);
|
|
}
|
|
|
|
|
|
if (!pRemoteIpInfo->dwEnableDhcp) {
|
|
|
|
ptrAddr = pRemoteIpInfo->pszwIpAddrList;
|
|
ptrMask = pRemoteIpInfo->pszwSubnetMaskList;
|
|
} else if (!pwszMachineName) {
|
|
// If on the local machine, get the active list
|
|
ptrAddr = NULL;
|
|
ptrMask = NULL;
|
|
}
|
|
|
|
if (ptrAddr && ptrMask) {
|
|
|
|
DWORD First = TRUE;
|
|
|
|
while (ptrAddr && ptrMask && *ptrAddr!=0 && *ptrMask != 0) {
|
|
|
|
ptrAddrNew = wcschr(ptrAddr, c_wListSeparatorComma);
|
|
ptrMaskNew = wcschr(ptrMask, c_wListSeparatorComma);
|
|
|
|
if (ptrAddrNew)
|
|
*ptrAddrNew = 0;
|
|
if (ptrMaskNew)
|
|
*ptrMaskNew = 0;
|
|
|
|
if (hFile) {
|
|
|
|
if (First) {
|
|
DisplayMessageT(
|
|
DMP_IPADDR1,
|
|
ptrAddr, ptrMask
|
|
);
|
|
First = FALSE;
|
|
}
|
|
else {
|
|
DisplayMessageT(
|
|
DMP_IPADDR2,
|
|
pQuotedFriendlyIfName,
|
|
ptrAddr, ptrMask
|
|
);
|
|
}
|
|
}
|
|
else {
|
|
DisplayMessage(g_hModule,
|
|
MSG_IPADDR_LIST1,
|
|
ptrAddr, ptrMask);
|
|
}
|
|
|
|
ptrAddr = ptrAddrNew ? ++ptrAddrNew : NULL;
|
|
ptrMask = ptrMaskNew ? ++ptrMaskNew : NULL;
|
|
}
|
|
}
|
|
|
|
} // end display ipaddr
|
|
|
|
|
|
//
|
|
// display options list
|
|
//
|
|
|
|
{
|
|
PWCHAR IfMetric1, Gateways1, GwMetrics1, Dns1, Wins1,
|
|
Ptr1, Ptr2, Equal, SemiColon, Ddns1, DdnsSuffix1,
|
|
End1;
|
|
|
|
if (hr != NO_ERROR)
|
|
break;
|
|
|
|
Ptr1 = pRemoteIpInfo->pszwOptionList;
|
|
IfMetric1 = wcsstr(Ptr1, c_wcsIfMetric);
|
|
Gateways1 = wcsstr(Ptr1, c_wcsDefGateway);
|
|
GwMetrics1 = wcsstr(Ptr1, c_wcsGwMetric);
|
|
Dns1 = wcsstr(Ptr1, c_wcsDns);
|
|
Wins1 = wcsstr(Ptr1, c_wcsWins);
|
|
Ddns1 = wcsstr(Ptr1, c_wcsDdns);
|
|
DdnsSuffix1 = wcsstr(Ptr1, c_wcsDdnsSuffix);
|
|
|
|
while (*Ptr1) {
|
|
|
|
Equal = wcschr(Ptr1, c_wEqual);
|
|
SemiColon = wcschr(Ptr1, c_wListSeparatorSC);
|
|
if (!Equal || !SemiColon)
|
|
break;
|
|
|
|
Ptr2 = Ptr1;
|
|
Ptr1 = SemiColon + 1;
|
|
*SemiColon = 0;
|
|
|
|
|
|
// display IfMetric
|
|
|
|
if (Ptr2 == IfMetric1) {
|
|
|
|
if (! (Flags & TYPE_IPADDR))
|
|
continue;
|
|
|
|
if (hFile) {
|
|
}
|
|
else {
|
|
DisplayMessage(g_hModule,
|
|
MSG_IFMETRIC,
|
|
Equal+1);
|
|
}
|
|
|
|
}
|
|
|
|
// display Gateways
|
|
|
|
else if (Ptr2 == Gateways1) {
|
|
|
|
PWCHAR Gateway, GwMetric, GatewayEnd, GwMetricEnd,
|
|
Comma1, Comma2;
|
|
BOOL First = TRUE;
|
|
|
|
|
|
if (! (Flags & TYPE_IPADDR))
|
|
continue;
|
|
|
|
|
|
// gateways list null
|
|
|
|
if (SemiColon == (Ptr2 + wcslen(c_wcsDefGateway)))
|
|
continue;
|
|
|
|
|
|
Gateway = Equal + 1;
|
|
GatewayEnd = SemiColon;
|
|
|
|
GwMetric = wcschr(GwMetrics1, c_wEqual) + 1;
|
|
GwMetricEnd = wcschr(GwMetrics1, c_wListSeparatorSC);
|
|
*GwMetricEnd = 0;
|
|
|
|
|
|
do {
|
|
|
|
Comma1 = wcschr(Gateway, c_wListSeparatorComma);
|
|
if (Comma1) *Comma1 = 0;
|
|
|
|
Comma2 = wcschr(GwMetric, c_wListSeparatorComma);
|
|
if (Comma2) *Comma2 = 0;
|
|
|
|
if (hFile) {
|
|
|
|
if (First) {
|
|
DisplayMessageT(
|
|
DMP_GATEWAY2,
|
|
pQuotedFriendlyIfName,
|
|
Gateway, GwMetric
|
|
);
|
|
First = FALSE;
|
|
}
|
|
else {
|
|
DisplayMessageT(
|
|
DMP_GATEWAY3,
|
|
pQuotedFriendlyIfName,
|
|
Gateway, GwMetric
|
|
);
|
|
}
|
|
}
|
|
else {
|
|
DisplayMessage(g_hModule,
|
|
MSG_GATEWAY,
|
|
Gateway, GwMetric);
|
|
}
|
|
|
|
if (Comma1) *Comma1 = c_wListSeparatorComma;
|
|
if (Comma2) *Comma2 = c_wListSeparatorComma;
|
|
|
|
Gateway = Comma1 + 1;
|
|
GwMetric = Comma2 + 1;
|
|
|
|
} while (Comma1 && Gateway<GatewayEnd);
|
|
|
|
if (hFile && First) {
|
|
DisplayMessageT(
|
|
DMP_GATEWAY1,
|
|
pQuotedFriendlyIfName
|
|
);
|
|
}
|
|
|
|
*GwMetricEnd = c_wListSeparatorSC;
|
|
}
|
|
|
|
else if (Ptr2 == GwMetrics1) {
|
|
|
|
}
|
|
|
|
// display wins and dns
|
|
|
|
else if ( (Ptr2 == Dns1) || (Ptr2==Wins1)) {
|
|
|
|
PWCHAR BeginPtr, EndPtr;
|
|
BOOL bDns = Ptr2==Dns1;
|
|
|
|
if (Ptr2==Dns1) {
|
|
if (! (Flags & TYPE_DNS))
|
|
continue;
|
|
}
|
|
else {
|
|
if (! (Flags & TYPE_WINS))
|
|
continue;
|
|
}
|
|
|
|
BeginPtr = Equal + 1;
|
|
EndPtr = SemiColon;
|
|
|
|
|
|
// empty list
|
|
|
|
if (BeginPtr==EndPtr) {
|
|
|
|
if (hFile) {
|
|
DisplayMessageT(
|
|
pRemoteIpInfo->dwEnableDhcp
|
|
? (bDns?DMP_DNS_DHCP:DMP_WINS_DHCP)
|
|
: (bDns?DMP_DNS_STATIC_NONE:DMP_WINS_STATIC_NONE),
|
|
pQuotedFriendlyIfName
|
|
);
|
|
|
|
if (bDns) {
|
|
//
|
|
// When generating a DNS (not WINS) line,
|
|
// also include the REGISTER=... argument.
|
|
// We need to look ahead in the option list
|
|
// since the DDNS info may occur after the
|
|
// WINS info, but we have to output it before.
|
|
//
|
|
if (!wcstol(Ddns1+wcslen(c_wcsDdns), &End1, 10)) {
|
|
DisplayMessageT(DMP_STRING_ARG,
|
|
TOKEN_REGISTER, TOKEN_VALUE_NONE);
|
|
} else if (!wcstol(DdnsSuffix1+wcslen(
|
|
c_wcsDdnsSuffix), &End1, 10)) {
|
|
DisplayMessageT(DMP_STRING_ARG,
|
|
TOKEN_REGISTER, TOKEN_VALUE_PRIMARY);
|
|
} else {
|
|
DisplayMessageT(DMP_STRING_ARG,
|
|
TOKEN_REGISTER, TOKEN_VALUE_BOTH);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (pRemoteIpInfo->dwEnableDhcp) {
|
|
IP_ADDR_STRING *pAddr;
|
|
BOOL First = TRUE;
|
|
|
|
if (!pwszMachineName) {
|
|
DisplayMessage(g_hModule,
|
|
(bDns?MSG_DNS_DHCP_HDR:MSG_WINS_DHCP_HDR)
|
|
);
|
|
|
|
// Display active list
|
|
|
|
if (bDns && pPerAdapterInfo) {
|
|
for (pAddr = &pPerAdapterInfo->DnsServerList;
|
|
pAddr;
|
|
pAddr = pAddr->Next)
|
|
{
|
|
ShowCharAddress(&First, pAddr->IpAddress.String);
|
|
}
|
|
} else if (!bDns && pAdapterInfo) {
|
|
if (strcmp(pAdapterInfo->PrimaryWinsServer.IpAddress.String, "0.0.0.0")) {
|
|
ShowCharAddress(&First, pAdapterInfo->PrimaryWinsServer.IpAddress.String);
|
|
}
|
|
if (strcmp(pAdapterInfo->SecondaryWinsServer.IpAddress.String, "0.0.0.0")) {
|
|
ShowCharAddress(&First, pAdapterInfo->SecondaryWinsServer.IpAddress.String);
|
|
}
|
|
}
|
|
|
|
if (First) {
|
|
DisplayMessage(g_hModule, MSG_NONE);
|
|
}
|
|
} else {
|
|
DisplayMessage(g_hModule,
|
|
(bDns?MSG_DNS_DHCP:MSG_WINS_DHCP)
|
|
);
|
|
}
|
|
}
|
|
else {
|
|
DisplayMessage(g_hModule,
|
|
bDns?MSG_DNS_HDR:MSG_WINS_HDR);
|
|
DisplayMessage(g_hModule,
|
|
MSG_NONE);
|
|
}
|
|
|
|
//
|
|
// For show commands, we output either DNS or WINS
|
|
// information but not both, so we can wait until
|
|
// we process the DDNS information normally,
|
|
// before outputting the DDNS state.
|
|
//
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
{
|
|
PWCHAR Comma1;
|
|
BOOL First = TRUE;
|
|
DWORD Index = 0;
|
|
|
|
if (!hFile) {
|
|
DisplayMessage(g_hModule,
|
|
bDns?MSG_DNS_HDR:MSG_WINS_HDR);
|
|
}
|
|
|
|
do {
|
|
Index++;
|
|
Comma1 = wcschr(BeginPtr, c_wListSeparatorComma);
|
|
if (Comma1) *Comma1 = 0;
|
|
|
|
if (hFile) {
|
|
DisplayMessageT(
|
|
First
|
|
? (First=FALSE,(bDns?DMP_DNS_STATIC_ADDR1:DMP_WINS_STATIC_ADDR1))
|
|
: (bDns?DMP_DNS_STATIC_ADDR2:DMP_WINS_STATIC_ADDR2),
|
|
pQuotedFriendlyIfName,
|
|
BeginPtr);
|
|
|
|
if (bDns && (Index == 1)) {
|
|
//
|
|
// When generating a DNS (not WINS) line,
|
|
// also include the REGISTER=... argument.
|
|
// We need to look ahead in the option list
|
|
// since the DDNS info may occur after the
|
|
// WINS info, but we have to output it
|
|
// before.
|
|
//
|
|
if (!wcstol(Ddns1+wcslen(c_wcsDdns), &End1, 10)) {
|
|
DisplayMessageT(DMP_STRING_ARG,
|
|
TOKEN_REGISTER, TOKEN_VALUE_NONE);
|
|
} else if (!wcstol(DdnsSuffix1+wcslen(
|
|
c_wcsDdnsSuffix), &End1, 10)) {
|
|
DisplayMessageT(DMP_STRING_ARG,
|
|
TOKEN_REGISTER, TOKEN_VALUE_PRIMARY);
|
|
} else {
|
|
DisplayMessageT(DMP_STRING_ARG,
|
|
TOKEN_REGISTER, TOKEN_VALUE_BOTH);
|
|
}
|
|
} else if (Index > 1) {
|
|
DisplayMessageT(DMP_INTEGER_ARG,
|
|
TOKEN_INDEX, Index);
|
|
}
|
|
} else {
|
|
ShowUnicodeAddress(&First, BeginPtr);
|
|
}
|
|
|
|
if (Comma1) *Comma1 = c_wListSeparatorComma;
|
|
BeginPtr = Comma1 + 1;
|
|
|
|
} while (Comma1 && BeginPtr<EndPtr);
|
|
}
|
|
}
|
|
|
|
else if (Ptr2 == Ddns1) {
|
|
if (! (Flags & TYPE_DNS))
|
|
continue;
|
|
|
|
//
|
|
// When we see DynamicUpdate=..., save the value.
|
|
// We won't know the complete register mode until
|
|
// we see the subsequent NameRegistration=... value.
|
|
// NetConfig guarantees that DynamicUpdate will occur
|
|
// first.
|
|
//
|
|
dwRegisterMode = wcstol(Equal+1, &End1, 10)? REGISTER_PRIMARY : REGISTER_NONE;
|
|
}
|
|
else if (Ptr2 == DdnsSuffix1) {
|
|
if (! (Flags & TYPE_DNS))
|
|
continue;
|
|
if (hFile) {
|
|
//
|
|
// If this is a dump, we've already looked at
|
|
// this value, when we processed the DNS=... option.
|
|
//
|
|
} else {
|
|
PWCHAR pwszValue;
|
|
|
|
//
|
|
// Now that we've seen NameRegistration=...,
|
|
// we know the complete register mode and can
|
|
// output it accordingly.
|
|
//
|
|
if ((dwRegisterMode == REGISTER_PRIMARY) &&
|
|
wcstol(Equal+1, &End1, 10)) {
|
|
pwszValue = MakeString(g_hModule, STRING_BOTH);
|
|
} else if (dwRegisterMode == REGISTER_PRIMARY) {
|
|
pwszValue = MakeString(g_hModule, STRING_PRIMARY);
|
|
} else {
|
|
pwszValue = MakeString(g_hModule, STRING_NONE);
|
|
}
|
|
|
|
DisplayMessage(g_hModule, MSG_DDNS_SUFFIX, pwszValue);
|
|
|
|
FreeString(pwszValue);
|
|
}
|
|
}
|
|
|
|
// any other option
|
|
|
|
else {
|
|
|
|
*Equal = 0;
|
|
|
|
if (!hFile) {
|
|
DisplayMessage(g_hModule,
|
|
MSG_OPTION,
|
|
Ptr2, Equal+1);
|
|
}
|
|
}
|
|
}
|
|
} //end options list
|
|
|
|
break;
|
|
|
|
} // breakout block
|
|
|
|
if ( pQuotedFriendlyIfName ) {
|
|
FreeQuotedString( pQuotedFriendlyIfName );
|
|
}
|
|
|
|
UninitializeTransportConfig(
|
|
pNetCfg,
|
|
pTcpipProperties,
|
|
pRemoteIpInfo
|
|
);
|
|
|
|
|
|
IfutlFree(pPerAdapterInfo);
|
|
IfutlFree(pAdaptersInfo);
|
|
|
|
return (hr == S_OK) ? NO_ERROR : hr;
|
|
}
|
|
|
|
|
|
|
|
DWORD
|
|
IfIpHandleDelIpaddrEx(
|
|
LPCWSTR pwszIfFriendlyName,
|
|
GUID *pGuid,
|
|
LPCWSTR pwszIpAddr,
|
|
LPCWSTR pwszGateway,
|
|
ULONG Flags
|
|
)
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Arguments
|
|
|
|
Return Value
|
|
|
|
--*/
|
|
{
|
|
INetCfg * pNetCfg = NULL;
|
|
ITcpipProperties * pTcpipProperties = NULL;
|
|
DWORD dwNetwork;
|
|
HRESULT hr = S_OK;
|
|
REMOTE_IPINFO *pRemoteIpInfo = NULL;
|
|
|
|
if (pGuid == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
hr = GetTransportConfig(
|
|
&pNetCfg,
|
|
&pTcpipProperties,
|
|
&pRemoteIpInfo,
|
|
pGuid,
|
|
pwszIfFriendlyName
|
|
);
|
|
|
|
while (hr==NO_ERROR) { //breakout block
|
|
|
|
if (Flags & TYPE_ADDR) {
|
|
|
|
PWCHAR IpAddr, IpAddrEnd;
|
|
PWCHAR Mask, MaskEnd;
|
|
PWCHAR pszwRemoteIpAddrList = pRemoteIpInfo->pszwIpAddrList;
|
|
PWCHAR pszwRemoteSubnetMaskList = pRemoteIpInfo->pszwSubnetMaskList;
|
|
PWCHAR EndIpAddrList = pszwRemoteIpAddrList + wcslen(pszwRemoteIpAddrList);
|
|
BOOL Found = FALSE;
|
|
ULONG Length = wcslen(pwszIpAddr);
|
|
|
|
|
|
IpAddr = pszwRemoteIpAddrList;
|
|
Mask = pszwRemoteSubnetMaskList;
|
|
|
|
while (IpAddr && (IpAddr + Length <= EndIpAddrList) ){
|
|
|
|
if (wcsncmp(IpAddr, pwszIpAddr, Length) == 0) {
|
|
|
|
if ( *(IpAddr+Length)==0 || *(IpAddr+Length)==c_wListSeparatorComma){
|
|
|
|
Found = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
IpAddr = wcschr(IpAddr, c_wListSeparatorComma);
|
|
Mask = wcschr(Mask, c_wListSeparatorComma);
|
|
|
|
if (IpAddr){
|
|
IpAddr++;
|
|
Mask++;
|
|
}
|
|
}
|
|
|
|
|
|
// IpAddr not present
|
|
|
|
if (!Found) {
|
|
DisplayMessage(g_hModule,
|
|
EMSG_ADDRESS_NOT_PRESENT);
|
|
|
|
hr = ERROR_SUPPRESS_OUTPUT;
|
|
break;
|
|
}
|
|
|
|
|
|
// cannot delete addr in dhcp mode
|
|
|
|
if (pRemoteIpInfo->dwEnableDhcp == TRUE) {
|
|
|
|
DisplayMessage(g_hModule,
|
|
EMSG_DHCP_DELETEADDR);
|
|
|
|
hr = ERROR_SUPPRESS_OUTPUT;
|
|
break;
|
|
}
|
|
|
|
|
|
|
|
IpAddrEnd = wcschr(IpAddr, c_wListSeparatorComma);
|
|
MaskEnd = wcschr(Mask, c_wListSeparatorComma);
|
|
|
|
if (*(IpAddr-1) == c_wListSeparatorComma) {
|
|
IpAddr --;
|
|
Mask --;
|
|
}
|
|
else if (IpAddrEnd) {
|
|
IpAddrEnd++;
|
|
MaskEnd++;
|
|
}
|
|
|
|
|
|
pszwRemoteIpAddrList[IpAddr - pszwRemoteIpAddrList] = 0;
|
|
pszwRemoteSubnetMaskList[Mask - pszwRemoteSubnetMaskList] = 0;
|
|
|
|
if (IpAddrEnd) {
|
|
wcscat(pszwRemoteIpAddrList, IpAddrEnd);
|
|
wcscat(pszwRemoteSubnetMaskList, MaskEnd);
|
|
}
|
|
|
|
|
|
// should have at least one addr in static mode
|
|
|
|
if (wcslen(pszwRemoteIpAddrList)==0 &&
|
|
pRemoteIpInfo->dwEnableDhcp == FALSE)
|
|
{
|
|
DisplayMessage(g_hModule,
|
|
EMSG_MIN_ONE_ADDR);
|
|
|
|
hr = ERROR_SUPPRESS_OUTPUT;
|
|
break;
|
|
|
|
}
|
|
} //end delete ipaddr
|
|
|
|
|
|
if (Flags & TYPE_GATEWAY) {
|
|
|
|
PWCHAR pszwRemoteOptionList = pRemoteIpInfo->pszwOptionList;
|
|
PWCHAR Gateways, GatewaysEnd, GwMetrics, GwMetricsEnd, GwMetrics1;
|
|
BOOL Found = FALSE;
|
|
|
|
Gateways = wcsstr(pszwRemoteOptionList, c_wcsDefGateway)
|
|
+ wcslen(c_wcsDefGateway);
|
|
GwMetrics1 = GwMetrics = wcsstr(pszwRemoteOptionList, c_wcsGwMetric)
|
|
+ wcslen(c_wcsGwMetric);
|
|
GatewaysEnd = wcschr(Gateways, c_wListSeparatorSC);
|
|
|
|
// check if the gateway is present
|
|
|
|
if (pwszGateway) {
|
|
|
|
ULONG Length = wcslen(pwszGateway);
|
|
|
|
while ((Gateways+Length) <= GatewaysEnd) {
|
|
|
|
if ( (wcsncmp(pwszGateway, Gateways, Length)==0)
|
|
&& ( (*(Gateways+Length)==c_wListSeparatorComma)
|
|
|| (*(Gateways+Length)==c_wListSeparatorSC)) )
|
|
{
|
|
|
|
Found = TRUE;
|
|
break;
|
|
}
|
|
else {
|
|
|
|
if (Gateways = wcschr(Gateways, c_wListSeparatorComma)) {
|
|
|
|
Gateways++;
|
|
GwMetrics = wcschr(GwMetrics, c_wListSeparatorComma) + 1;
|
|
}
|
|
else {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!Found) {
|
|
|
|
DisplayMessage(g_hModule,
|
|
EMSG_GATEWAY_NOT_PRESENT);
|
|
|
|
hr = ERROR_SUPPRESS_OUTPUT;
|
|
|
|
break; //from breakout block
|
|
}
|
|
}
|
|
|
|
if (!pwszGateway) {
|
|
|
|
wcscpy(pszwRemoteOptionList, c_wcsDefGateway);
|
|
wcscat(pszwRemoteOptionList, c_wszListSeparatorSC);
|
|
wcscat(pszwRemoteOptionList, c_wcsGwMetric);
|
|
wcscat(pszwRemoteOptionList, c_wszListSeparatorSC);
|
|
}
|
|
else {
|
|
PWCHAR GatewaysListEnd, GwMetricsListEnd, TmpPtr;
|
|
|
|
GatewaysListEnd = wcschr(Gateways, c_wListSeparatorSC);
|
|
GwMetricsListEnd = wcschr(GwMetrics, c_wListSeparatorSC);
|
|
|
|
GatewaysEnd = Gateways + wcslen(pwszGateway);
|
|
GwMetricsEnd = wcschr(GwMetrics, c_wListSeparatorComma);
|
|
if (!GwMetricsEnd || GwMetricsEnd>GwMetricsListEnd)
|
|
GwMetricsEnd = wcschr(GwMetrics, c_wListSeparatorSC);
|
|
|
|
|
|
if (*(Gateways-1)==c_wListSeparatorComma) {
|
|
Gateways--;
|
|
GwMetrics--;
|
|
|
|
} else if (*GatewaysEnd==c_wListSeparatorComma) {
|
|
GatewaysEnd++;
|
|
GwMetricsEnd++;
|
|
}
|
|
|
|
wcsncpy(Gateways, GatewaysEnd, (DWORD)(GwMetrics - GatewaysEnd));
|
|
TmpPtr = Gateways + (GwMetrics - GatewaysEnd);
|
|
*TmpPtr = 0;
|
|
wcscat(TmpPtr, GwMetricsEnd);
|
|
}
|
|
} //end delete gateway
|
|
|
|
|
|
//
|
|
// set the config
|
|
//
|
|
|
|
if (hr == S_OK)
|
|
hr = pTcpipProperties->lpVtbl->SetIpInfoForAdapter(pTcpipProperties, pGuid, pRemoteIpInfo);
|
|
|
|
if (hr == S_OK)
|
|
hr = pNetCfg->lpVtbl->Apply(pNetCfg);
|
|
|
|
break;
|
|
|
|
}//end breakout block
|
|
|
|
|
|
UninitializeTransportConfig(
|
|
pNetCfg,
|
|
pTcpipProperties,
|
|
pRemoteIpInfo
|
|
);
|
|
|
|
return (hr == S_OK) ? NO_ERROR : hr;
|
|
}
|
|
|
|
DWORD
|
|
OpenDriver(
|
|
HANDLE *Handle,
|
|
LPWSTR DriverName
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function opens a specified IO drivers.
|
|
|
|
Arguments:
|
|
|
|
Handle - pointer to location where the opened drivers handle is
|
|
returned.
|
|
|
|
DriverName - name of the driver to be opened.
|
|
|
|
Return Value:
|
|
|
|
Windows Error Code.
|
|
Notes: copied from net\sockets\tcpcmd\ipcfgapi\ipcfgapi.c
|
|
|
|
--*/
|
|
{
|
|
OBJECT_ATTRIBUTES objectAttributes;
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
UNICODE_STRING nameString;
|
|
NTSTATUS status;
|
|
|
|
*Handle = NULL;
|
|
|
|
//
|
|
// Open a Handle to the IP driver.
|
|
//
|
|
|
|
RtlInitUnicodeString(&nameString, DriverName);
|
|
|
|
InitializeObjectAttributes(
|
|
&objectAttributes,
|
|
&nameString,
|
|
OBJ_CASE_INSENSITIVE,
|
|
(HANDLE) NULL,
|
|
(PSECURITY_DESCRIPTOR) NULL
|
|
);
|
|
|
|
status = NtCreateFile(
|
|
Handle,
|
|
SYNCHRONIZE | FILE_READ_DATA | FILE_WRITE_DATA,
|
|
&objectAttributes,
|
|
&ioStatusBlock,
|
|
NULL,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
FILE_OPEN_IF,
|
|
0,
|
|
NULL,
|
|
0
|
|
);
|
|
|
|
return( RtlNtStatusToDosError( status ) );
|
|
}
|
|
|
|
NTSTATUS
|
|
DoIoctl(
|
|
HANDLE Handle,
|
|
DWORD IoctlCode,
|
|
PVOID Request,
|
|
DWORD RequestSize,
|
|
PVOID Response,
|
|
PDWORD ResponseSize
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Utility routine used to issue a filtering ioctl to the tcpip driver.
|
|
|
|
Arguments:
|
|
|
|
Handle - An open file handle on which to issue the request.
|
|
|
|
IoctlCode - The IOCTL opcode.
|
|
|
|
Request - A pointer to the input buffer.
|
|
|
|
RequestSize - Size of the input buffer.
|
|
|
|
Response - A pointer to the output buffer.
|
|
|
|
ResponseSize - On input, the size in bytes of the output buffer.
|
|
On output, the number of bytes returned in the output
|
|
buffer.
|
|
|
|
Return Value:
|
|
|
|
NT Status Code.
|
|
Notes: copied from net\sockets\tcpcmd\ipcfgapi\ipcfgapi.c
|
|
--*/
|
|
{
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
NTSTATUS status;
|
|
|
|
|
|
ioStatusBlock.Information = 0;
|
|
|
|
status = NtDeviceIoControlFile(
|
|
Handle, // Driver handle
|
|
NULL, // Event
|
|
NULL, // APC Routine
|
|
NULL, // APC context
|
|
&ioStatusBlock, // Status block
|
|
IoctlCode, // Control code
|
|
Request, // Input buffer
|
|
RequestSize, // Input buffer size
|
|
Response, // Output buffer
|
|
*ResponseSize // Output buffer size
|
|
);
|
|
|
|
if (status == STATUS_PENDING) {
|
|
status = NtWaitForSingleObject(
|
|
Handle,
|
|
TRUE,
|
|
NULL
|
|
);
|
|
}
|
|
|
|
|
|
if (status == STATUS_SUCCESS) {
|
|
status = ioStatusBlock.Status;
|
|
*ResponseSize = (ULONG)ioStatusBlock.Information;
|
|
}
|
|
else {
|
|
*ResponseSize = 0;
|
|
}
|
|
|
|
return(status);
|
|
}
|
|
|
|
|
|
DWORD
|
|
IfIpGetInfoOffload(
|
|
ULONG IfIndex,
|
|
IFOffloadCapability* IFOC
|
|
)
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Arguments
|
|
|
|
Return Value
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS Status;
|
|
HANDLE Handle;
|
|
ULONG ResponseBufferSize = sizeof(*IFOC);
|
|
|
|
Status = OpenDriver(&Handle, L"\\Device\\Ip");
|
|
if (!NT_SUCCESS(Status)) {
|
|
return(RtlNtStatusToDosError(Status));
|
|
}
|
|
|
|
Status = DoIoctl(
|
|
Handle,
|
|
IOCTL_IP_GET_OFFLOAD_CAPABILITY,
|
|
&IfIndex,
|
|
sizeof(IfIndex),
|
|
IFOC,
|
|
&ResponseBufferSize
|
|
);
|
|
|
|
CloseHandle(Handle);
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
return(RtlNtStatusToDosError(Status));
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
|
|
DWORD
|
|
IfIpShowManyEx(
|
|
LPCWSTR pwszMachineName,
|
|
ULONG IfIndex,
|
|
PWCHAR wszIfFriendlyName,
|
|
GUID *guid,
|
|
DISPLAY_TYPE dtType,
|
|
HANDLE hFile
|
|
)
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Arguments
|
|
|
|
Return Value
|
|
|
|
--*/
|
|
{
|
|
switch (dtType) {
|
|
|
|
case TYPE_IPADDR:
|
|
case TYPE_DNS:
|
|
case TYPE_WINS:
|
|
case TYPE_IP_ALL:
|
|
return IfIpShowManyExEx(pwszMachineName, IfIndex, wszIfFriendlyName, guid, dtType, hFile);
|
|
|
|
case TYPE_OFFLOAD:
|
|
return IfIpShowInfoOffload(IfIndex, wszIfFriendlyName);
|
|
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
DWORD
|
|
IfIpShowInfoOffload(
|
|
ULONG IfIndex,
|
|
PWCHAR wszIfFriendlyName
|
|
)
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Arguments
|
|
|
|
Return Value
|
|
|
|
--*/
|
|
{
|
|
IFOffloadCapability IFOC;
|
|
DWORD dwErr;
|
|
PWCHAR pQuotedFriendlyIfName = NULL;
|
|
|
|
|
|
pQuotedFriendlyIfName = MakeQuotedString( wszIfFriendlyName );
|
|
if ( pQuotedFriendlyIfName == NULL ) {
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
|
|
|
|
dwErr = IfIpGetInfoOffload(IfIndex, &IFOC);
|
|
if (dwErr != NO_ERROR)
|
|
return dwErr;
|
|
|
|
|
|
DisplayMessage(g_hModule,
|
|
MSG_OFFLOAD_HDR, pQuotedFriendlyIfName, IfIndex);
|
|
|
|
if (IFOC.ifoc_OffloadFlags & TCP_XMT_CHECKSUM_OFFLOAD) {
|
|
DisplayMessage(g_hModule,
|
|
MSG_TCP_XMT_CHECKSUM_OFFLOAD);
|
|
}
|
|
|
|
if (IFOC.ifoc_OffloadFlags & IP_XMT_CHECKSUM_OFFLOAD) {
|
|
DisplayMessage(g_hModule,
|
|
MSG_IP_XMT_CHECKSUM_OFFLOAD);
|
|
}
|
|
|
|
if (IFOC.ifoc_OffloadFlags & TCP_RCV_CHECKSUM_OFFLOAD) {
|
|
DisplayMessage(g_hModule,
|
|
MSG_TCP_RCV_CHECKSUM_OFFLOAD);
|
|
}
|
|
|
|
if (IFOC.ifoc_OffloadFlags & IP_RCV_CHECKSUM_OFFLOAD) {
|
|
DisplayMessage(g_hModule,
|
|
MSG_IP_RCV_CHECKSUM_OFFLOAD);
|
|
}
|
|
|
|
if (IFOC.ifoc_OffloadFlags & TCP_LARGE_SEND_OFFLOAD) {
|
|
DisplayMessage(g_hModule,
|
|
MSG_TCP_LARGE_SEND_OFFLOAD);
|
|
}
|
|
|
|
|
|
|
|
if (IFOC.ifoc_IPSecOffloadFlags & IPSEC_OFFLOAD_CRYPTO_ONLY) {
|
|
DisplayMessage(g_hModule,
|
|
MSG_IPSEC_OFFLOAD_CRYPTO_ONLY);
|
|
}
|
|
|
|
if (IFOC.ifoc_IPSecOffloadFlags & IPSEC_OFFLOAD_AH_ESP) {
|
|
DisplayMessage(g_hModule,
|
|
MSG_IPSEC_OFFLOAD_AH_ESP);
|
|
}
|
|
|
|
if (IFOC.ifoc_IPSecOffloadFlags & IPSEC_OFFLOAD_TPT_TUNNEL) {
|
|
DisplayMessage(g_hModule,
|
|
MSG_IPSEC_OFFLOAD_TPT_TUNNEL);
|
|
}
|
|
|
|
if (IFOC.ifoc_IPSecOffloadFlags & IPSEC_OFFLOAD_V4_OPTIONS) {
|
|
DisplayMessage(g_hModule,
|
|
MSG_IPSEC_OFFLOAD_V4_OPTIONS);
|
|
}
|
|
|
|
if (IFOC.ifoc_IPSecOffloadFlags & IPSEC_OFFLOAD_QUERY_SPI) {
|
|
DisplayMessage(g_hModule,
|
|
MSG_IPSEC_OFFLOAD_QUERY_SPI);
|
|
}
|
|
|
|
|
|
|
|
if (IFOC.ifoc_IPSecOffloadFlags & IPSEC_OFFLOAD_AH_XMT) {
|
|
DisplayMessage(g_hModule,
|
|
MSG_IPSEC_OFFLOAD_AH_XMT);
|
|
}
|
|
|
|
if (IFOC.ifoc_IPSecOffloadFlags & IPSEC_OFFLOAD_AH_RCV) {
|
|
DisplayMessage(g_hModule,
|
|
MSG_IPSEC_OFFLOAD_AH_RCV);
|
|
}
|
|
|
|
if (IFOC.ifoc_IPSecOffloadFlags & IPSEC_OFFLOAD_AH_TPT) {
|
|
DisplayMessage(g_hModule,
|
|
MSG_IPSEC_OFFLOAD_AH_TPT);
|
|
}
|
|
|
|
if (IFOC.ifoc_IPSecOffloadFlags & IPSEC_OFFLOAD_AH_TUNNEL) {
|
|
DisplayMessage(g_hModule,
|
|
MSG_IPSEC_OFFLOAD_AH_TUNNEL);
|
|
}
|
|
|
|
if (IFOC.ifoc_IPSecOffloadFlags & IPSEC_OFFLOAD_AH_MD5) {
|
|
DisplayMessage(g_hModule,
|
|
MSG_IPSEC_OFFLOAD_AH_MD5);
|
|
}
|
|
|
|
if (IFOC.ifoc_IPSecOffloadFlags & IPSEC_OFFLOAD_AH_SHA_1) {
|
|
DisplayMessage(g_hModule,
|
|
MSG_IPSEC_OFFLOAD_AH_SHA_1);
|
|
}
|
|
|
|
|
|
|
|
if (IFOC.ifoc_IPSecOffloadFlags & IPSEC_OFFLOAD_ESP_XMT) {
|
|
DisplayMessage(g_hModule,
|
|
MSG_IPSEC_OFFLOAD_ESP_XMT);
|
|
}
|
|
|
|
if (IFOC.ifoc_IPSecOffloadFlags & IPSEC_OFFLOAD_ESP_RCV) {
|
|
DisplayMessage(g_hModule,
|
|
MSG_IPSEC_OFFLOAD_ESP_RCV);
|
|
}
|
|
|
|
if (IFOC.ifoc_IPSecOffloadFlags & IPSEC_OFFLOAD_ESP_TPT) {
|
|
DisplayMessage(g_hModule,
|
|
MSG_IPSEC_OFFLOAD_ESP_TPT);
|
|
}
|
|
|
|
if (IFOC.ifoc_IPSecOffloadFlags & IPSEC_OFFLOAD_ESP_TUNNEL) {
|
|
DisplayMessage(g_hModule,
|
|
MSG_IPSEC_OFFLOAD_ESP_TUNNEL);
|
|
}
|
|
|
|
if (IFOC.ifoc_IPSecOffloadFlags & IPSEC_OFFLOAD_ESP_DES) {
|
|
DisplayMessage(g_hModule,
|
|
MSG_IPSEC_OFFLOAD_ESP_DES);
|
|
}
|
|
|
|
if (IFOC.ifoc_IPSecOffloadFlags & IPSEC_OFFLOAD_ESP_DES_40) {
|
|
DisplayMessage(g_hModule,
|
|
MSG_IPSEC_OFFLOAD_ESP_DES_40);
|
|
}
|
|
|
|
if (IFOC.ifoc_IPSecOffloadFlags & IPSEC_OFFLOAD_ESP_3_DES) {
|
|
DisplayMessage(g_hModule,
|
|
MSG_IPSEC_OFFLOAD_ESP_3_DES);
|
|
}
|
|
|
|
if (IFOC.ifoc_IPSecOffloadFlags & IPSEC_OFFLOAD_ESP_NONE) {
|
|
DisplayMessage(g_hModule,
|
|
MSG_IPSEC_OFFLOAD_ESP_NONE);
|
|
}
|
|
|
|
if ( pQuotedFriendlyIfName ) {
|
|
FreeQuotedString( pQuotedFriendlyIfName );
|
|
}
|
|
|
|
return dwErr;
|
|
}
|