mirror of https://github.com/tongzx/nt5src
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.
1573 lines
42 KiB
1573 lines
42 KiB
/*++
|
|
|
|
Copyright (c) 1997 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
netcfg.c
|
|
|
|
Abstract:
|
|
|
|
System network configuration grovelling routines
|
|
|
|
Author:
|
|
|
|
Mike Massa (mikemas) May 19, 1997
|
|
|
|
Revision History:
|
|
|
|
Who When What
|
|
-------- -------- ----------------------------------------------
|
|
mikemas 05-19-97 created
|
|
|
|
|
|
--*/
|
|
|
|
#include <nt.h>
|
|
#include <ntrtl.h>
|
|
#include <nturtl.h>
|
|
#include <windows.h>
|
|
#include <winsock2.h>
|
|
|
|
#include <cluster.h>
|
|
#include <objbase.h>
|
|
#include <devguid.h>
|
|
|
|
#include <netcon.h>
|
|
#include <regstr.h>
|
|
|
|
#include <iphlpapi.h>
|
|
|
|
//
|
|
// Private Constants
|
|
//
|
|
#define TCPIP_INTERFACES_KEY L"System\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Interfaces"
|
|
#define STRING_ARRAY_DELIMITERS " \t,;"
|
|
|
|
//
|
|
// Allocing and cloning helper functions
|
|
//
|
|
|
|
#define AllocGracefully(status, result, len, name) \
|
|
result = LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT, len); \
|
|
if (!result) { \
|
|
status = GetLastError(); \
|
|
ClRtlLogPrint(LOG_CRITICAL, \
|
|
"[ClNet] alloc of %1!hs! (%2!d! bytes) failed, status %3!d!\n", \
|
|
name,len,status); \
|
|
goto exit_gracefully; \
|
|
} else { \
|
|
status = ERROR_SUCCESS; \
|
|
}
|
|
|
|
#define CloneAnsiString(Status,AnsiStr,WideResult) { \
|
|
SIZE_T len = _mbstrlen(AnsiStr) + 1; \
|
|
AllocGracefully(status, WideResult, len * sizeof(WCHAR), # AnsiStr); \
|
|
mbstowcs(WideResult, AnsiStr, len); \
|
|
}
|
|
|
|
#define CloneWideString(Status,WideStr,WideResult) { \
|
|
SIZE_T _size = (wcslen(WideStr) + 1) * sizeof(WCHAR); \
|
|
AllocGracefully(Status, WideResult, _size * sizeof(WCHAR), # WideStr); \
|
|
memcpy(WideResult, WideStr, _size); \
|
|
}
|
|
|
|
VOID
|
|
ClRtlpDeleteInterfaceInfo(
|
|
PCLRTL_NET_INTERFACE_INFO InterfaceInfo
|
|
)
|
|
{
|
|
if (InterfaceInfo) {
|
|
LocalFree(InterfaceInfo->InterfaceAddressString);
|
|
LocalFree(InterfaceInfo->NetworkAddressString);
|
|
LocalFree(InterfaceInfo->NetworkMaskString);
|
|
|
|
LocalFree(InterfaceInfo);
|
|
}
|
|
} // DeleteInterfaceInfo
|
|
|
|
PCLRTL_NET_INTERFACE_INFO
|
|
ClRtlpCreateInterfaceInfo(
|
|
IN CONST PIP_ADDR_STRING IpAddr
|
|
)
|
|
{
|
|
DWORD status;
|
|
PCLRTL_NET_INTERFACE_INFO This = 0;
|
|
ULONG Addr, Mask, Network;
|
|
|
|
Addr = inet_addr(IpAddr->IpAddress.String);
|
|
Mask = inet_addr(IpAddr->IpMask.String);
|
|
Network = Addr & Mask;
|
|
|
|
if ( (INADDR_NONE == Addr) ||
|
|
(INADDR_NONE == Mask) ||
|
|
((0 == Network) && Addr && Mask)
|
|
)
|
|
{
|
|
ClRtlLogPrint(LOG_CRITICAL,
|
|
"[ClNet] Bad ip addr/mask: %1!X! %2!X! %3!X!\n",
|
|
Addr,
|
|
Mask,
|
|
Network
|
|
);
|
|
status = ERROR_INVALID_PARAMETER;
|
|
goto exit_gracefully;
|
|
}
|
|
|
|
AllocGracefully(
|
|
status,
|
|
This,
|
|
sizeof(CLRTL_NET_INTERFACE_INFO),
|
|
"CLRTL_NET_INTERFACE_INFO"
|
|
);
|
|
|
|
This->Context = IpAddr -> Context;
|
|
|
|
This->InterfaceAddress = Addr;
|
|
This->NetworkMask = Mask;
|
|
This->NetworkAddress = Network;
|
|
|
|
CloneAnsiString(
|
|
status,
|
|
IpAddr->IpAddress.String,
|
|
This->InterfaceAddressString
|
|
);
|
|
CloneAnsiString(
|
|
status,
|
|
IpAddr->IpMask.String,
|
|
This->NetworkMaskString
|
|
);
|
|
|
|
status = ClRtlTcpipAddressToString(
|
|
Network,
|
|
&(This->NetworkAddressString)
|
|
);
|
|
if (status != ERROR_SUCCESS) {
|
|
ClRtlLogPrint(LOG_CRITICAL,
|
|
"[ClNet] ClRtlTcpipAddressToString of %1!X! failed, "
|
|
"status %2!d!\n",
|
|
Network,
|
|
status
|
|
);
|
|
goto exit_gracefully;
|
|
}
|
|
|
|
exit_gracefully:
|
|
|
|
if (status != ERROR_SUCCESS) {
|
|
SetLastError(status);
|
|
if (This) {
|
|
ClRtlpDeleteInterfaceInfo(This);
|
|
This = 0;
|
|
}
|
|
}
|
|
|
|
return This;
|
|
} // CreateInterfaceInfo
|
|
|
|
VOID
|
|
ClRtlpDeleteAdapter(
|
|
PCLRTL_NET_ADAPTER_INFO adapterInfo
|
|
)
|
|
{
|
|
if (adapterInfo) {
|
|
PCLRTL_NET_INTERFACE_INFO interfaceInfo;
|
|
|
|
interfaceInfo = adapterInfo->InterfaceList;
|
|
|
|
while (interfaceInfo != NULL) {
|
|
PCLRTL_NET_INTERFACE_INFO next = interfaceInfo->Next;
|
|
|
|
ClRtlpDeleteInterfaceInfo(interfaceInfo);
|
|
|
|
interfaceInfo = next;
|
|
}
|
|
|
|
LocalFree(adapterInfo->DeviceGuid);
|
|
LocalFree(adapterInfo->ConnectoidName);
|
|
LocalFree(adapterInfo->DeviceName);
|
|
LocalFree(adapterInfo->AdapterDomainName);
|
|
LocalFree(adapterInfo->DnsServerList);
|
|
|
|
LocalFree(adapterInfo);
|
|
|
|
return;
|
|
}
|
|
} // DeleteAdapter
|
|
|
|
DWORD
|
|
ClRtlpCreateAdapter(
|
|
IN PIP_ADAPTER_INFO AdapterInfo,
|
|
OUT PCLRTL_NET_ADAPTER_INFO * ppAdapter)
|
|
{
|
|
DWORD status;
|
|
PCLRTL_NET_ADAPTER_INFO adapter = 0;
|
|
*ppAdapter = 0;
|
|
|
|
AllocGracefully(status, adapter, sizeof(*adapter), "NET_ADAPTER_INFO");
|
|
ZeroMemory(adapter, sizeof(*adapter));
|
|
|
|
//
|
|
// Assumption here is that:
|
|
//
|
|
// AdapterName contains Guid in the form {4082164E-A4B5-11D2-89C3-E37CB6BB13FC}
|
|
// We need to store it without curly brackets
|
|
//
|
|
|
|
{
|
|
SIZE_T len = _mbstrlen(AdapterInfo->AdapterName); // not including 0, but including { and } //
|
|
AllocGracefully(status, adapter->DeviceGuid,
|
|
sizeof(WCHAR) * (len - 1), "adapter->DeviceGuid");
|
|
mbstowcs(adapter->DeviceGuid, AdapterInfo->AdapterName+1, len-1);
|
|
adapter->DeviceGuid[len - 2] = UNICODE_NULL;
|
|
}
|
|
|
|
|
|
adapter->Index = AdapterInfo->Index;
|
|
{
|
|
PIP_ADDR_STRING IpAddr = &AdapterInfo->IpAddressList;
|
|
while ( IpAddr ) {
|
|
PCLRTL_NET_INTERFACE_INFO interfaceInfo;
|
|
|
|
interfaceInfo = ClRtlpCreateInterfaceInfo(IpAddr);
|
|
|
|
if (!interfaceInfo) {
|
|
// CreateInterfaceInfo logs the error message //
|
|
// clean up will be done by DeleteAdapter //
|
|
status = GetLastError();
|
|
goto exit_gracefully;
|
|
}
|
|
|
|
interfaceInfo->Next = adapter->InterfaceList;
|
|
adapter->InterfaceList = interfaceInfo;
|
|
++(adapter->InterfaceCount);
|
|
|
|
IpAddr = IpAddr -> Next;
|
|
}
|
|
|
|
if (adapter->InterfaceList) {
|
|
adapter->InterfaceList->Flags |= CLRTL_NET_INTERFACE_PRIMARY;
|
|
}
|
|
}
|
|
|
|
exit_gracefully:
|
|
if (status != ERROR_SUCCESS) {
|
|
ClRtlpDeleteAdapter(adapter);
|
|
} else {
|
|
*ppAdapter = adapter;
|
|
}
|
|
|
|
return status;
|
|
} // CreateAdapter
|
|
|
|
|
|
PCLRTL_NET_ADAPTER_ENUM
|
|
ClRtlpCreateAdapterEnum()
|
|
{
|
|
DWORD status;
|
|
DWORD len;
|
|
|
|
PIP_ADAPTER_INFO SingleAdapter = 0;
|
|
PIP_ADAPTER_INFO AdapterInfo = 0;
|
|
PCLRTL_NET_ADAPTER_ENUM AdapterEnum = 0;
|
|
|
|
len = 0;
|
|
for(;;) {
|
|
status = GetAdaptersInfo(AdapterInfo, &len);
|
|
if (status == ERROR_SUCCESS) {
|
|
break;
|
|
}
|
|
if (status != ERROR_BUFFER_OVERFLOW) {
|
|
ClRtlLogPrint(LOG_CRITICAL,
|
|
"[ClNet] GetAdaptersInfo returned %1!d!\n", status);
|
|
goto exit_gracefully;
|
|
}
|
|
LocalFree(AdapterInfo); // LocalFree(0) is OK //
|
|
AllocGracefully(status, AdapterInfo, len, "IP_ADAPTER_INFO");
|
|
}
|
|
|
|
AllocGracefully(status, AdapterEnum,
|
|
sizeof(*AdapterEnum), "PCLRTL_NET_ADAPTER_ENUM");
|
|
ZeroMemory(AdapterEnum, sizeof(*AdapterEnum));
|
|
|
|
SingleAdapter = AdapterInfo;
|
|
|
|
while (SingleAdapter) {
|
|
if (SingleAdapter->Type != MIB_IF_TYPE_LOOPBACK &&
|
|
SingleAdapter->Type != MIB_IF_TYPE_PPP &&
|
|
SingleAdapter->Type != MIB_IF_TYPE_SLIP )
|
|
{
|
|
PCLRTL_NET_ADAPTER_INFO Adapter = 0;
|
|
|
|
status = ClRtlpCreateAdapter(SingleAdapter, &Adapter);
|
|
if (status != ERROR_SUCCESS) {
|
|
ClRtlLogPrint(LOG_CRITICAL,
|
|
"[ClNet] CreateAdapter %1!d! failed, status %2!d!\n",
|
|
AdapterEnum->AdapterCount, status);
|
|
goto exit_gracefully;
|
|
}
|
|
|
|
//
|
|
// Push the adapter into Enumeration List
|
|
//
|
|
Adapter->Next = AdapterEnum->AdapterList;
|
|
AdapterEnum->AdapterList = Adapter;
|
|
++(AdapterEnum->AdapterCount);
|
|
}
|
|
|
|
SingleAdapter = SingleAdapter->Next;
|
|
}
|
|
|
|
exit_gracefully:
|
|
if (status != ERROR_SUCCESS) {
|
|
SetLastError(status);
|
|
ClRtlFreeNetAdapterEnum(AdapterEnum);
|
|
AdapterEnum = 0;
|
|
}
|
|
|
|
LocalFree(AdapterInfo);
|
|
return AdapterEnum;
|
|
} // CreateAdapterEnum
|
|
|
|
|
|
HKEY
|
|
ClRtlpFindAdapterKey(
|
|
HKEY TcpInterfacesKey,
|
|
LPWSTR AdapterGuidString
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Given the adapter GUID, look through the key names under
|
|
TCP's Interfaces key and see if a match can be found. The
|
|
key names should have the GUID as some part of the name.
|
|
|
|
Arguments:
|
|
|
|
TcpInterfacesKey - handle to TCP's interfaces area
|
|
|
|
AdapterGuidString - pointer to string representing adapter's GUID
|
|
|
|
Return Value:
|
|
|
|
Handle to the interface key; otherwise NULL
|
|
|
|
--*/
|
|
|
|
{
|
|
HKEY AdapterInterfaceKey = NULL;
|
|
WCHAR KeyName[REGSTR_MAX_VALUE_LENGTH + 1];
|
|
DWORD KeyLength = sizeof( KeyName )/sizeof(TCHAR);
|
|
DWORD index = 0;
|
|
BOOL FoundMatch = FALSE;
|
|
size_t SubStringPos;
|
|
DWORD Status;
|
|
FILETIME FileTime;
|
|
|
|
//
|
|
// enum the key names under the interfaces
|
|
//
|
|
do {
|
|
Status = RegEnumKeyEx(TcpInterfacesKey,
|
|
index,
|
|
KeyName,
|
|
&KeyLength,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
&FileTime);
|
|
if ( Status != ERROR_SUCCESS ) {
|
|
break;
|
|
}
|
|
|
|
//
|
|
// find the beginning of the match
|
|
//
|
|
_wcsupr( KeyName );
|
|
if (wcsstr( KeyName, AdapterGuidString )) {
|
|
FoundMatch = TRUE;
|
|
break;
|
|
}
|
|
|
|
++index;
|
|
KeyLength = sizeof( KeyName );
|
|
} while ( TRUE );
|
|
|
|
if ( FoundMatch ) {
|
|
|
|
Status = RegOpenKeyW(TcpInterfacesKey,
|
|
KeyName,
|
|
&AdapterInterfaceKey);
|
|
if ( Status != ERROR_SUCCESS ) {
|
|
AdapterInterfaceKey = NULL;
|
|
}
|
|
}
|
|
|
|
return AdapterInterfaceKey;
|
|
} // FindAdapterKey
|
|
|
|
|
|
DWORD
|
|
ClRtlpConvertIPAddressString(
|
|
LPSTR DnsServerString,
|
|
PDWORD ServerCount,
|
|
PDWORD * ServerList)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Convert the string of DNS server addresses to binary
|
|
|
|
Arguments:
|
|
|
|
DnsServerString - concat'ed string of IP addresses that can be separated
|
|
by white space of commas
|
|
|
|
ServerCount - pointer to DWORD that receives # of addresses detected
|
|
|
|
ServerList - pointer to DWORD array of converted IP addresses
|
|
|
|
Return Value:
|
|
|
|
ERROR_SUCCESS if everything went ok
|
|
|
|
--*/
|
|
|
|
{
|
|
#define MAX_DNS_SERVER_ADDRESSES 100
|
|
|
|
PCHAR stringPointer = DnsServerString;
|
|
DWORD stringCount = 0;
|
|
PDWORD serverList = NULL;
|
|
LPSTR stringAddress[ MAX_DNS_SERVER_ADDRESSES ];
|
|
|
|
//
|
|
// count how many addresses are in the string and null terminate them for
|
|
// inet_addr
|
|
//
|
|
|
|
stringPointer += strspn(stringPointer, STRING_ARRAY_DELIMITERS);
|
|
stringAddress[0] = stringPointer;
|
|
stringCount = 1;
|
|
|
|
while (stringCount < MAX_DNS_SERVER_ADDRESSES &&
|
|
(stringPointer = strpbrk(stringPointer, STRING_ARRAY_DELIMITERS)))
|
|
{
|
|
*stringPointer++ = '\0';
|
|
stringPointer += strspn(stringPointer, STRING_ARRAY_DELIMITERS);
|
|
stringAddress[stringCount] = stringPointer;
|
|
if (*stringPointer) {
|
|
++stringCount;
|
|
}
|
|
}
|
|
|
|
serverList = LocalAlloc( LMEM_FIXED, stringCount * sizeof( DWORD ));
|
|
if ( serverList == NULL ) {
|
|
return GetLastError();
|
|
}
|
|
|
|
*ServerCount = stringCount;
|
|
*ServerList = serverList;
|
|
|
|
while ( stringCount-- ) {
|
|
serverList[ stringCount ] = inet_addr( stringAddress[ stringCount ]);
|
|
}
|
|
|
|
return ERROR_SUCCESS;
|
|
} // ConvertIPAddressString
|
|
|
|
|
|
typedef BOOLEAN (*ENUM_CALLBACK)(NETCON_PROPERTIES *,
|
|
INetConnection*,
|
|
PVOID Context);
|
|
HRESULT
|
|
ClRtlpHrEnumConnections(
|
|
IN ENUM_CALLBACK enumCallback,
|
|
IN PVOID Context
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Enumerate Connection Manager Connections
|
|
|
|
Arguments:
|
|
|
|
enumCallback - callback to be called for every connection
|
|
Context - to be passed to a callback
|
|
|
|
Return Value:
|
|
|
|
S_OK or HRESULT error code
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr;
|
|
INetConnectionManager * NcManager = NULL;
|
|
IEnumNetConnection * EnumNc = NULL;
|
|
INetConnection * NetConnection = NULL;
|
|
NETCON_PROPERTIES * NcProps = NULL;
|
|
DWORD dwNumConnectionsReturned;
|
|
LPWSTR deviceGuidString = NULL;
|
|
|
|
//
|
|
// instantiate a connection mgr object and enum the connections
|
|
//
|
|
hr = CoCreateInstance((REFCLSID)&CLSID_ConnectionManager,
|
|
NULL,
|
|
CLSCTX_LOCAL_SERVER,
|
|
(REFIID)&IID_INetConnectionManager,
|
|
&NcManager);
|
|
if (FAILED(hr)) {
|
|
ClRtlLogPrint(LOG_CRITICAL,
|
|
"[ClNet] INetConnectionManager_CoCreateInstance failed, status %1!X!\n",
|
|
hr);
|
|
goto exit_gracefully;
|
|
}
|
|
|
|
hr = INetConnectionManager_EnumConnections(NcManager,
|
|
NCME_DEFAULT,
|
|
&EnumNc);
|
|
if (FAILED(hr)) {
|
|
ClRtlLogPrint(LOG_CRITICAL,
|
|
"[ClNet] INetConnectionManager_EnumConnections failed, status %1!X!\n",
|
|
hr);
|
|
goto exit_gracefully;
|
|
}
|
|
|
|
IEnumNetConnection_Reset( EnumNc );
|
|
|
|
while (TRUE) {
|
|
hr = IEnumNetConnection_Next(EnumNc,
|
|
1,
|
|
&NetConnection,
|
|
&dwNumConnectionsReturned);
|
|
if (FAILED(hr)) {
|
|
ClRtlLogPrint(LOG_CRITICAL,
|
|
"[ClNet] IEnumNetConnection_Next failed, status %1!X!\n",
|
|
hr);
|
|
goto exit_gracefully;
|
|
}
|
|
|
|
if ( dwNumConnectionsReturned == 0 ) {
|
|
hr = S_OK;
|
|
break;
|
|
}
|
|
|
|
hr = INetConnection_GetProperties(NetConnection, &NcProps);
|
|
if (SUCCEEDED( hr )) {
|
|
BOOLEAN bCont;
|
|
|
|
bCont = enumCallback(NcProps, NetConnection, Context);
|
|
|
|
NcFreeNetconProperties(NcProps);
|
|
NcProps = 0;
|
|
if (!bCont) {
|
|
break;
|
|
}
|
|
}
|
|
INetConnection_Release( NetConnection ); NetConnection = NULL;
|
|
}
|
|
|
|
exit_gracefully:
|
|
|
|
if (EnumNc != NULL) {
|
|
IEnumNetConnection_Release( EnumNc );
|
|
}
|
|
|
|
if (NcManager != NULL) {
|
|
INetConnectionManager_Release( NcManager );
|
|
}
|
|
|
|
return hr;
|
|
|
|
} // HrEnumConnections
|
|
|
|
|
|
VOID
|
|
ClRtlpProcessNetConfigurationAdapter(
|
|
HKEY TcpInterfacesKey,
|
|
PCLRTL_NET_ADAPTER_ENUM adapterEnum,
|
|
NETCON_PROPERTIES * NCProps,
|
|
LPWSTR DeviceGuidString
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
For a given conn mgr object, determine if it is in use by
|
|
TCP. This is acheived by comparing the adapter ID in the tcpip
|
|
adapter enumeration with the connection object's guid.
|
|
|
|
Arguments:
|
|
|
|
TcpInterfacessKey - handle to the root of the TCP\Parameters\Interfaces area
|
|
|
|
adapterEnum - pointer to enumeration of adapters and their interfaces
|
|
actually in use by TCP
|
|
|
|
NCProps - Connectoid properties.
|
|
|
|
DeviceGuidString - Guid for the connectoid (and for the associated adapter).
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
HKEY AdaptersKey;
|
|
HKEY DHCPAdaptersKey = NULL;
|
|
HKEY InterfacesKey = NULL;
|
|
PCLRTL_NET_ADAPTER_INFO adapterInfo = NULL;
|
|
DWORD valueSize;
|
|
DWORD valueType;
|
|
LPWSTR valueName;
|
|
LPSTR ansiValueName;
|
|
BOOL ignoreAdapter = FALSE;
|
|
DWORD NTEContext;
|
|
DWORD Status;
|
|
BOOL dhcpEnabled;
|
|
|
|
//
|
|
// Get the TCP/IP interfaces registry key for this adapter.
|
|
//
|
|
InterfacesKey = ClRtlpFindAdapterKey(
|
|
TcpInterfacesKey,
|
|
DeviceGuidString
|
|
);
|
|
|
|
if (InterfacesKey == NULL) {
|
|
ClRtlLogPrint(LOG_CRITICAL,
|
|
"[ClNet] No Interfaces key for %1!ws!\n",
|
|
DeviceGuidString
|
|
);
|
|
goto exit_gracefully;
|
|
}
|
|
|
|
//
|
|
// see if we should be ignoring this adapter per the registry
|
|
//
|
|
valueSize = sizeof(DWORD);
|
|
Status = RegQueryValueExW(InterfacesKey,
|
|
L"MSCSHidden",
|
|
NULL,
|
|
&valueType,
|
|
(LPBYTE) &ignoreAdapter,
|
|
&valueSize);
|
|
|
|
if ( Status != ERROR_SUCCESS ) {
|
|
ignoreAdapter = FALSE;
|
|
}
|
|
|
|
//
|
|
// Search the enum for this adapter.
|
|
//
|
|
adapterInfo = ClRtlFindNetAdapterById(adapterEnum, DeviceGuidString);
|
|
|
|
if (adapterInfo != NULL) {
|
|
CloneWideString(Status, NCProps->pszwDeviceName, adapterInfo->DeviceName);
|
|
CloneWideString(Status, NCProps->pszwName, adapterInfo->ConnectoidName);
|
|
|
|
//
|
|
// Check if this is a hidden netcard.
|
|
//
|
|
if ( ignoreAdapter ) {
|
|
adapterInfo->Flags |= CLRTL_NET_ADAPTER_HIDDEN;
|
|
}
|
|
|
|
//
|
|
// Store the NCStatus in the adapter info structure
|
|
//
|
|
adapterInfo->NCStatus = NCProps->Status;
|
|
|
|
//
|
|
// get the domain name and DHCP server list (if any) associated
|
|
// with this adapter. The Domain value has precedence over
|
|
// DhcpDomain. If that value is empty/doesn't exist, then use
|
|
// DhcpDomain only if EnableDHCP is set to one.
|
|
//
|
|
Status = ClRtlRegQueryDword(InterfacesKey,
|
|
L"EnableDHCP",
|
|
&dhcpEnabled,
|
|
NULL);
|
|
|
|
if ( Status != ERROR_SUCCESS ) {
|
|
dhcpEnabled = FALSE;
|
|
}
|
|
|
|
valueName = L"Domain";
|
|
valueSize = 0;
|
|
Status = RegQueryValueExW(InterfacesKey,
|
|
valueName,
|
|
NULL,
|
|
&valueType,
|
|
(LPBYTE)NULL,
|
|
&valueSize);
|
|
|
|
if ( Status != ERROR_SUCCESS || valueSize == sizeof(UNICODE_NULL)) {
|
|
|
|
//
|
|
// it didn't exist or the value was NULL. if were using DHCP,
|
|
// then check to see if DHCP supplied domain name was
|
|
// specified
|
|
//
|
|
if ( dhcpEnabled ) {
|
|
valueName = L"DhcpDomain";
|
|
Status = RegQueryValueExW(InterfacesKey,
|
|
valueName,
|
|
NULL,
|
|
&valueType,
|
|
(LPBYTE)NULL,
|
|
&valueSize);
|
|
} else {
|
|
Status = ERROR_FILE_NOT_FOUND;
|
|
}
|
|
}
|
|
|
|
if ( Status == ERROR_SUCCESS && valueSize > sizeof(UNICODE_NULL)) {
|
|
|
|
//
|
|
// legit domain name was found (somewhere). store it in the
|
|
// adapter info
|
|
//
|
|
adapterInfo->AdapterDomainName = LocalAlloc(LMEM_FIXED,
|
|
valueSize +
|
|
sizeof(UNICODE_NULL));
|
|
|
|
if ( adapterInfo->AdapterDomainName != NULL ) {
|
|
|
|
Status = RegQueryValueExW(InterfacesKey,
|
|
valueName,
|
|
NULL,
|
|
&valueType,
|
|
(LPBYTE)adapterInfo->AdapterDomainName,
|
|
&valueSize);
|
|
|
|
if ( Status != ERROR_SUCCESS ) {
|
|
|
|
LocalFree( adapterInfo->AdapterDomainName );
|
|
adapterInfo->AdapterDomainName = NULL;
|
|
}
|
|
#if CLUSTER_BETA
|
|
else {
|
|
ClRtlLogPrint(LOG_NOISE,
|
|
" %1!ws! key: %2!ws!\n",
|
|
valueName,
|
|
adapterInfo->AdapterDomainName);
|
|
}
|
|
#endif
|
|
} else {
|
|
Status = GetLastError();
|
|
}
|
|
}
|
|
|
|
//
|
|
// now get the DNS server list in a similar fashion. The
|
|
// NameServer value has precedence over DhcpNameServer but we only
|
|
// check the DHCP values if DHCP is enabled (just like
|
|
// above). Note that we use the Ansi APIs since we need to convert
|
|
// the IP addresses into binary form and there is no wide char
|
|
// form of inet_addr.
|
|
//
|
|
ansiValueName = "NameServer";
|
|
valueSize = 0;
|
|
Status = RegQueryValueExA(InterfacesKey,
|
|
ansiValueName,
|
|
NULL,
|
|
&valueType,
|
|
(LPBYTE)NULL,
|
|
&valueSize);
|
|
|
|
if ( Status != ERROR_SUCCESS || valueSize == 1 ) {
|
|
if ( dhcpEnabled ) {
|
|
ansiValueName = "DhcpNameServer";
|
|
Status = RegQueryValueExA(InterfacesKey,
|
|
ansiValueName,
|
|
NULL,
|
|
&valueType,
|
|
(LPBYTE)NULL,
|
|
&valueSize);
|
|
} else {
|
|
Status = ERROR_FILE_NOT_FOUND;
|
|
}
|
|
}
|
|
|
|
if ( Status == ERROR_SUCCESS && valueSize > 0 ) {
|
|
PCHAR nameServerString;
|
|
|
|
nameServerString = LocalAlloc( LMEM_FIXED, valueSize + 1 );
|
|
|
|
if ( nameServerString != NULL ) {
|
|
|
|
Status = RegQueryValueExA(InterfacesKey,
|
|
ansiValueName,
|
|
NULL,
|
|
&valueType,
|
|
(LPBYTE)nameServerString,
|
|
&valueSize);
|
|
|
|
if ( Status == ERROR_SUCCESS ) {
|
|
DWORD serverCount;
|
|
PDWORD serverList;
|
|
|
|
#if CLUSTER_BETA
|
|
ClRtlLogPrint(LOG_NOISE,
|
|
" %1!hs! key: %2!hs!\n",
|
|
ansiValueName,
|
|
nameServerString);
|
|
#endif
|
|
Status = ClRtlpConvertIPAddressString(
|
|
nameServerString,
|
|
&serverCount,
|
|
&serverList
|
|
);
|
|
|
|
if ( Status == ERROR_SUCCESS ) {
|
|
adapterInfo->DnsServerCount = serverCount;
|
|
adapterInfo->DnsServerList = serverList;
|
|
} else {
|
|
adapterInfo->DnsServerCount = 0;
|
|
adapterInfo->DnsServerList = NULL;
|
|
}
|
|
} else {
|
|
adapterInfo->DnsServerCount = 0;
|
|
adapterInfo->DnsServerList = NULL;
|
|
}
|
|
|
|
LocalFree( nameServerString );
|
|
} else {
|
|
Status = GetLastError();
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( adapterInfo == NULL ) {
|
|
//
|
|
// TCP/IP is not bound to this adapter right now. PnP?
|
|
//
|
|
ClRtlLogPrint(LOG_UNUSUAL,
|
|
"[ClNet] Tcpip is not bound to adapter %1!ws!.\n",
|
|
DeviceGuidString
|
|
);
|
|
}
|
|
|
|
exit_gracefully:
|
|
|
|
if (InterfacesKey != NULL) {
|
|
RegCloseKey( InterfacesKey );
|
|
}
|
|
|
|
return;
|
|
} // ProcessNetConfigurationAdapter
|
|
|
|
|
|
typedef struct _CONFIGURATION_CONTEXT
|
|
{
|
|
PCLRTL_NET_ADAPTER_ENUM adapterEnum;
|
|
HKEY TcpInterfacesKey;
|
|
}
|
|
CONFIGURATION_CONTEXT, *PCONFIGURATION_CONTEXT;
|
|
|
|
typedef WCHAR GUIDSTR[32 * 3];
|
|
VOID GuidToStr(LPGUID Guid, PWCHAR buf)
|
|
{
|
|
//
|
|
// GUIDs look like this: 4082164E-A4B5-11D2-89C3-E37CB6BB13FC
|
|
//
|
|
wsprintfW(
|
|
buf,
|
|
L"%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X",
|
|
Guid->Data1, Guid->Data2, Guid->Data3,
|
|
Guid->Data4[0], Guid->Data4[1], Guid->Data4[2], Guid->Data4[3],
|
|
Guid->Data4[4], Guid->Data4[5], Guid->Data4[6], Guid->Data4[7]
|
|
);
|
|
}
|
|
|
|
BOOLEAN
|
|
ClRtlpProcessConfigurationCallback(
|
|
NETCON_PROPERTIES * NCProps,
|
|
INetConnection * NetConnection,
|
|
PVOID Context
|
|
)
|
|
{
|
|
PCONFIGURATION_CONTEXT Ctx =
|
|
(PCONFIGURATION_CONTEXT) Context;
|
|
|
|
if ( NCProps->MediaType == NCM_LAN &&
|
|
NCProps->Status != NCS_HARDWARE_NOT_PRESENT &&
|
|
NCProps->Status != NCS_HARDWARE_DISABLED &&
|
|
NCProps->Status != NCS_HARDWARE_MALFUNCTION)
|
|
{
|
|
GUIDSTR deviceGuidString;
|
|
GuidToStr(&NCProps->guidId, deviceGuidString);
|
|
|
|
ClRtlpProcessNetConfigurationAdapter(
|
|
Ctx->TcpInterfacesKey,
|
|
Ctx->adapterEnum,
|
|
NCProps,
|
|
deviceGuidString
|
|
);
|
|
//
|
|
// the strings in the properties struct are either kept or
|
|
// or freed in ProcessNetConfigurationAdapter. If they are
|
|
// used, then they are freed when the adapter enum is freed
|
|
//
|
|
}
|
|
return TRUE;
|
|
} // ProcessConfigurationCallback
|
|
|
|
|
|
PCLRTL_NET_ADAPTER_ENUM
|
|
ClRtlEnumNetAdapters(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Enumerates all of the installed network adapters to which TCP/IP
|
|
is bound.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
A pointer to a network adapter enumeration, if successful.
|
|
NULL if unsuccessful. Extended error information is available from
|
|
GetLastError().
|
|
|
|
--*/
|
|
{
|
|
DWORD status;
|
|
PCLRTL_NET_ADAPTER_INFO adapterInfo = NULL;
|
|
CONFIGURATION_CONTEXT Ctx;
|
|
PVOID wTimer;
|
|
|
|
ZeroMemory(&Ctx, sizeof(Ctx));
|
|
|
|
//
|
|
// First get the list of bound adapters & interfaces from the
|
|
// tcpip stack.
|
|
//
|
|
Ctx.adapterEnum = ClRtlpCreateAdapterEnum();
|
|
if (Ctx.adapterEnum == NULL) {
|
|
status = GetLastError();
|
|
ClRtlLogPrint(LOG_CRITICAL,
|
|
"[ClNet] GetTcpipAdaptersAndInterfaces failed %1!u!\n", status);
|
|
|
|
SetLastError(status);
|
|
return(NULL);
|
|
}
|
|
|
|
//
|
|
// Open the Services portion of the registry
|
|
//
|
|
status = RegOpenKeyW(HKEY_LOCAL_MACHINE,
|
|
TCPIP_INTERFACES_KEY,
|
|
&Ctx.TcpInterfacesKey);
|
|
|
|
if (status != ERROR_SUCCESS) {
|
|
ClRtlLogPrint(LOG_CRITICAL,
|
|
"[ClNet] Open of TCP Params key failed - %1!u!\n",
|
|
status
|
|
);
|
|
|
|
goto exit_gracefully;
|
|
}
|
|
|
|
// This function might hang, so setting the watchdog timer to 2 mins (2 * 60 * 1000) ms
|
|
wTimer = ClRtlSetWatchdogTimer(120000, L"Calling EnumConnections");
|
|
|
|
status = ClRtlpHrEnumConnections(
|
|
ClRtlpProcessConfigurationCallback,
|
|
&Ctx
|
|
);
|
|
|
|
ClRtlCancelWatchdogTimer(wTimer);
|
|
|
|
if (status != S_OK) {
|
|
goto exit_gracefully;
|
|
}
|
|
|
|
//
|
|
// Finally, ensure that we found a name for each adapter in the enum.
|
|
//
|
|
for (adapterInfo = Ctx.adapterEnum->AdapterList;
|
|
adapterInfo != NULL;
|
|
adapterInfo = adapterInfo->Next
|
|
)
|
|
{
|
|
if (adapterInfo->ConnectoidName == NULL) {
|
|
if ( adapterInfo->InterfaceCount > 0 ) {
|
|
ClRtlLogPrint(LOG_CRITICAL,
|
|
"[ClNet] No installed adapter was found for IP address %1!ws!\n",
|
|
adapterInfo->InterfaceList->InterfaceAddressString
|
|
);
|
|
} else {
|
|
ClRtlLogPrint(LOG_CRITICAL,
|
|
"[ClNet] No installed adapter was found for Tcpip IF entity %1!u!\n",
|
|
adapterInfo->Index
|
|
);
|
|
}
|
|
status = ERROR_FILE_NOT_FOUND;
|
|
goto exit_gracefully;
|
|
}
|
|
}
|
|
|
|
#if CLUSTER_BETA
|
|
ClRtlLogPrint(LOG_NOISE,
|
|
"[ClNet] Successfully enumerated all adapters and interfaces\n");
|
|
#endif
|
|
|
|
status = ERROR_SUCCESS;
|
|
|
|
exit_gracefully:
|
|
|
|
if (Ctx.TcpInterfacesKey != NULL) {
|
|
RegCloseKey(Ctx.TcpInterfacesKey);
|
|
}
|
|
|
|
if (status != ERROR_SUCCESS) {
|
|
if (Ctx.adapterEnum != NULL) {
|
|
ClRtlFreeNetAdapterEnum(Ctx.adapterEnum);
|
|
Ctx.adapterEnum = NULL;
|
|
}
|
|
|
|
SetLastError(status);
|
|
}
|
|
|
|
return(Ctx.adapterEnum);
|
|
|
|
} // ClRtlEnumNetAdapters
|
|
|
|
|
|
VOID
|
|
ClRtlFreeNetAdapterEnum(
|
|
IN PCLRTL_NET_ADAPTER_ENUM AdapterEnum
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Frees a network adapter enumeration structure.
|
|
|
|
Arguments:
|
|
|
|
AdapterEnum - A pointer to the structure to be freed.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
if (AdapterEnum) {
|
|
PCLRTL_NET_ADAPTER_INFO p = AdapterEnum -> AdapterList;
|
|
while (p) {
|
|
PCLRTL_NET_ADAPTER_INFO next = p->Next;
|
|
ClRtlpDeleteAdapter(p);
|
|
p = next;
|
|
}
|
|
LocalFree(AdapterEnum);
|
|
}
|
|
} // ClRtlFreeNetAdapterEnum
|
|
|
|
|
|
PCLRTL_NET_ADAPTER_INFO
|
|
ClRtlFindNetAdapterById(
|
|
PCLRTL_NET_ADAPTER_ENUM AdapterEnum,
|
|
LPWSTR AdapterId
|
|
)
|
|
{
|
|
PCLRTL_NET_ADAPTER_INFO adapterInfo;
|
|
|
|
|
|
for ( adapterInfo = AdapterEnum->AdapterList;
|
|
adapterInfo != NULL;
|
|
adapterInfo = adapterInfo->Next
|
|
)
|
|
{
|
|
if (wcscmp(AdapterId, adapterInfo->DeviceGuid) == 0) {
|
|
if (!adapterInfo->Ignore) {
|
|
return(adapterInfo);
|
|
}
|
|
else {
|
|
return(NULL);
|
|
}
|
|
}
|
|
}
|
|
|
|
return(NULL);
|
|
|
|
} // ClRtlFindNetAdapterById
|
|
|
|
|
|
PCLRTL_NET_INTERFACE_INFO
|
|
ClRtlFindNetInterfaceByNetworkAddress(
|
|
IN PCLRTL_NET_ADAPTER_INFO AdapterInfo,
|
|
IN LPWSTR NetworkAddress
|
|
)
|
|
{
|
|
PCLRTL_NET_INTERFACE_INFO interfaceInfo;
|
|
|
|
for (interfaceInfo = AdapterInfo->InterfaceList;
|
|
interfaceInfo != NULL;
|
|
interfaceInfo = interfaceInfo->Next
|
|
)
|
|
{
|
|
if (interfaceInfo->Ignore == FALSE) {
|
|
//
|
|
// We only look at the primary interface on the
|
|
// adapter right now.
|
|
//
|
|
if (interfaceInfo->Flags & CLRTL_NET_INTERFACE_PRIMARY)
|
|
{
|
|
if ( wcscmp(
|
|
interfaceInfo->NetworkAddressString,
|
|
NetworkAddress
|
|
) == 0 )
|
|
{
|
|
return(interfaceInfo);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return(NULL);
|
|
|
|
} // ClRtlFindNetInterfaceByNetworkAddress
|
|
|
|
|
|
PCLRTL_NET_ADAPTER_INFO
|
|
ClRtlFindNetAdapterByNetworkAddress(
|
|
IN PCLRTL_NET_ADAPTER_ENUM AdapterEnum,
|
|
IN LPWSTR NetworkAddress,
|
|
OUT PCLRTL_NET_INTERFACE_INFO * InterfaceInfo
|
|
)
|
|
{
|
|
PCLRTL_NET_ADAPTER_INFO adapterInfo;
|
|
PCLRTL_NET_INTERFACE_INFO interfaceInfo;
|
|
|
|
|
|
for ( adapterInfo = AdapterEnum->AdapterList;
|
|
adapterInfo != NULL;
|
|
adapterInfo = adapterInfo->Next
|
|
)
|
|
{
|
|
if (adapterInfo->Ignore == FALSE) {
|
|
for (interfaceInfo = adapterInfo->InterfaceList;
|
|
interfaceInfo != NULL;
|
|
interfaceInfo = interfaceInfo->Next
|
|
)
|
|
{
|
|
if (interfaceInfo->Ignore == FALSE) {
|
|
//
|
|
// We only look at the primary interface on the
|
|
// adapter right now.
|
|
//
|
|
if (interfaceInfo->Flags & CLRTL_NET_INTERFACE_PRIMARY) {
|
|
if ( wcscmp(
|
|
interfaceInfo->NetworkAddressString,
|
|
NetworkAddress
|
|
) == 0 )
|
|
{
|
|
*InterfaceInfo = interfaceInfo;
|
|
|
|
return(adapterInfo);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
*InterfaceInfo = NULL;
|
|
|
|
return(NULL);
|
|
|
|
} // ClRtlFindNetAdapterByNetworkAddress
|
|
|
|
|
|
PCLRTL_NET_ADAPTER_INFO
|
|
ClRtlFindNetAdapterByInterfaceAddress(
|
|
IN PCLRTL_NET_ADAPTER_ENUM AdapterEnum,
|
|
IN LPWSTR InterfaceAddressString,
|
|
OUT PCLRTL_NET_INTERFACE_INFO * InterfaceInfo
|
|
)
|
|
/*++
|
|
|
|
For a given IP interface address, find the
|
|
adapter that is hosting that address.
|
|
|
|
--*/
|
|
|
|
{
|
|
PCLRTL_NET_ADAPTER_INFO adapterInfo;
|
|
PCLRTL_NET_INTERFACE_INFO interfaceInfo;
|
|
|
|
for ( adapterInfo = AdapterEnum->AdapterList;
|
|
adapterInfo != NULL;
|
|
adapterInfo = adapterInfo->Next
|
|
)
|
|
{
|
|
if (adapterInfo->Ignore == FALSE) {
|
|
for (interfaceInfo = adapterInfo->InterfaceList;
|
|
interfaceInfo != NULL;
|
|
interfaceInfo = interfaceInfo->Next
|
|
)
|
|
{
|
|
if (interfaceInfo->Ignore == FALSE ) {
|
|
|
|
if ( wcscmp( interfaceInfo->InterfaceAddressString,
|
|
InterfaceAddressString ) == 0 ) {
|
|
*InterfaceInfo = interfaceInfo;
|
|
return(adapterInfo);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
*InterfaceInfo = NULL;
|
|
return(NULL);
|
|
|
|
} // ClRtlFindNetAdapterByInterfaceAddress
|
|
|
|
PCLRTL_NET_INTERFACE_INFO
|
|
ClRtlGetPrimaryNetInterface(
|
|
IN PCLRTL_NET_ADAPTER_INFO AdapterInfo
|
|
)
|
|
{
|
|
PCLRTL_NET_INTERFACE_INFO interfaceInfo;
|
|
|
|
|
|
for (interfaceInfo = AdapterInfo->InterfaceList;
|
|
interfaceInfo != NULL;
|
|
interfaceInfo = interfaceInfo->Next
|
|
)
|
|
{
|
|
if (interfaceInfo->Flags & CLRTL_NET_INTERFACE_PRIMARY) {
|
|
if (!interfaceInfo->Ignore) {
|
|
return(interfaceInfo);
|
|
}
|
|
else {
|
|
return(NULL);
|
|
}
|
|
}
|
|
}
|
|
|
|
return(NULL);
|
|
|
|
} // ClRtlGetPrimaryNetInterface
|
|
|
|
|
|
LPWSTR
|
|
ClRtlGetConnectoidName(
|
|
INetConnection * NetConnection
|
|
)
|
|
{
|
|
DWORD status;
|
|
NETCON_PROPERTIES * NcProps = NULL;
|
|
LPWSTR name = NULL;
|
|
|
|
|
|
status = INetConnection_GetProperties(NetConnection, &NcProps);
|
|
|
|
if (SUCCEEDED( status )) {
|
|
DWORD nameLength = (lstrlenW(NcProps->pszwName) * sizeof(WCHAR)) +
|
|
sizeof(UNICODE_NULL);
|
|
|
|
name = LocalAlloc(LMEM_FIXED, nameLength);
|
|
|
|
if (name != NULL) {
|
|
lstrcpyW(name, NcProps->pszwName);
|
|
}
|
|
else {
|
|
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
|
|
}
|
|
|
|
NcFreeNetconProperties( NcProps );
|
|
}
|
|
else {
|
|
SetLastError(status);
|
|
}
|
|
|
|
return(name);
|
|
|
|
} // ClRtlGetConnectoidName
|
|
|
|
|
|
typedef struct _FIND_CONNECTOID_CONTEXT
|
|
{
|
|
GUID ConnectoidGuid;
|
|
LPCWSTR ConnectoidName;
|
|
INetConnection * NetConnection;
|
|
}
|
|
FIND_CONNECTOID_CONTEXT, *PFIND_CONNECTOID_CONTEXT;
|
|
|
|
BOOLEAN
|
|
ClRtlpFindConnectoidByGuidCallback(
|
|
NETCON_PROPERTIES * NcProp,
|
|
INetConnection * NetConnection,
|
|
PVOID Context
|
|
)
|
|
{
|
|
PFIND_CONNECTOID_CONTEXT Ctx =
|
|
(PFIND_CONNECTOID_CONTEXT) Context;
|
|
|
|
if ( IsEqualGUID(&Ctx->ConnectoidGuid, &NcProp->guidId) ) {
|
|
INetConnection_AddRef(NetConnection);
|
|
Ctx->NetConnection = NetConnection;
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
} // FindConnectoidByGuidCallback
|
|
|
|
INetConnection *
|
|
ClRtlFindConnectoidByGuid(
|
|
LPWSTR ConnectoidGuidStr
|
|
)
|
|
{
|
|
FIND_CONNECTOID_CONTEXT Ctx;
|
|
HRESULT hr;
|
|
RPC_STATUS rpcStatus;
|
|
ZeroMemory(&Ctx, sizeof(Ctx));
|
|
|
|
rpcStatus = UuidFromStringW (
|
|
(LPWSTR)ConnectoidGuidStr,
|
|
&Ctx.ConnectoidGuid);
|
|
if (rpcStatus != ERROR_SUCCESS) {
|
|
SetLastError( HRESULT_FROM_WIN32(rpcStatus) );
|
|
return 0;
|
|
}
|
|
|
|
hr = ClRtlpHrEnumConnections(ClRtlpFindConnectoidByGuidCallback, &Ctx);
|
|
if (hr != S_OK) {
|
|
SetLastError(hr);
|
|
return 0;
|
|
} else {
|
|
return Ctx.NetConnection;
|
|
}
|
|
} // ClRtlFindConnectoidByGuid
|
|
|
|
BOOLEAN
|
|
ClRtlpFindConnectoidByNameCallback(
|
|
NETCON_PROPERTIES * NcProp,
|
|
INetConnection * NetConnection,
|
|
PVOID Context
|
|
)
|
|
{
|
|
PFIND_CONNECTOID_CONTEXT Ctx =
|
|
(PFIND_CONNECTOID_CONTEXT) Context;
|
|
|
|
if ( lstrcmpiW(Ctx->ConnectoidName, NcProp->pszwName) == 0 ) {
|
|
INetConnection_AddRef(NetConnection);
|
|
Ctx->NetConnection = NetConnection;
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
} // FindConnectoidByNameCallback
|
|
|
|
INetConnection *
|
|
ClRtlFindConnectoidByName(
|
|
LPCWSTR ConnectoidName
|
|
)
|
|
{
|
|
FIND_CONNECTOID_CONTEXT Ctx;
|
|
HRESULT hr;
|
|
ZeroMemory(&Ctx, sizeof(Ctx));
|
|
|
|
Ctx.ConnectoidName = ConnectoidName;
|
|
|
|
hr = ClRtlpHrEnumConnections(ClRtlpFindConnectoidByNameCallback, &Ctx);
|
|
if (hr != S_OK) {
|
|
SetLastError(hr);
|
|
return 0;
|
|
} else {
|
|
return Ctx.NetConnection;
|
|
}
|
|
} // ClRtlFindConnectoidByName
|
|
|
|
|
|
DWORD
|
|
ClRtlSetConnectoidName(
|
|
INetConnection * NetConnection,
|
|
LPWSTR NewConnectoidName
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Set the conn mgr object in the connections folder to the
|
|
supplied name. This routine must deal with collisions since
|
|
the name change could be the result of a node joining the
|
|
cluster whose conn obj name in the connection folder had
|
|
changed while the cluster service was stopped on that node.
|
|
|
|
If a collision is detected, the existing name is changed to
|
|
have an "(previous)" appended to it.
|
|
|
|
Arguments:
|
|
|
|
NetConnection - Connect object to set.
|
|
|
|
NewConnectoidName - new name
|
|
|
|
Return Value:
|
|
|
|
Win32 error status
|
|
|
|
--*/
|
|
{
|
|
DWORD status = E_UNEXPECTED;
|
|
INetConnection * connectoidObj;
|
|
LPWSTR tempName;
|
|
ULONG iteration = 2;
|
|
GUIDSTR connectoidGuid;
|
|
|
|
//
|
|
// first see if there is a collision with the new name. If so,
|
|
// we'll rename the collided name, since we need to make all
|
|
// the cluster connectoids the same.
|
|
//
|
|
connectoidObj = ClRtlFindConnectoidByName( NewConnectoidName );
|
|
|
|
if ( connectoidObj != NULL ) {
|
|
NETCON_PROPERTIES * NcProps = NULL;
|
|
|
|
|
|
status = INetConnection_GetProperties(connectoidObj, &NcProps);
|
|
|
|
if (SUCCEEDED( status )) {
|
|
|
|
GuidToStr(&NcProps->guidId, connectoidGuid);
|
|
NcFreeNetconProperties( NcProps );
|
|
}
|
|
else {
|
|
wsprintf(
|
|
&(connectoidGuid[0]),
|
|
L"????????-????-????-????-??????????????"
|
|
);
|
|
}
|
|
|
|
ClRtlLogPrint(LOG_UNUSUAL,
|
|
"[ClNet] New connectoid name '%1!ws!' collides with name of "
|
|
"existing connectoid (%2!ws!). Renaming existing connectoid.\n",
|
|
NewConnectoidName,
|
|
connectoidGuid
|
|
);
|
|
|
|
//
|
|
// allocate enough space for the connectoid name with a trailing
|
|
// "(ddd)". 3 digits for the number should be enough
|
|
//
|
|
tempName = LocalAlloc(
|
|
LMEM_FIXED,
|
|
(wcslen( NewConnectoidName ) + 6) * sizeof(WCHAR)
|
|
);
|
|
|
|
if ( tempName == NULL ) {
|
|
INetConnection_Release( connectoidObj );
|
|
return ERROR_OUTOFMEMORY;
|
|
}
|
|
|
|
do {
|
|
wsprintf( tempName, L"%s(%u)", NewConnectoidName, iteration++ );
|
|
status = INetConnection_Rename( connectoidObj, tempName );
|
|
} while ( !SUCCEEDED( status ) && iteration <= 999 );
|
|
|
|
if ( iteration > 999 ) {
|
|
ClRtlLogPrint(LOG_UNUSUAL,
|
|
"[ClNet] Failed to create a unique name for connectoid "
|
|
"'%1!ws!' (%2!ws!)\n",
|
|
NewConnectoidName,
|
|
connectoidGuid
|
|
);
|
|
|
|
INetConnection_Release( connectoidObj );
|
|
|
|
return(ERROR_DUP_NAME);
|
|
}
|
|
|
|
ClRtlLogPrint(LOG_NOISE,
|
|
"[ClNet] Renamed existing connectoid '%1!ws!' (%2!ws!) to '%3!ws!' "
|
|
"due to a collision with the name of cluster network.\n",
|
|
NewConnectoidName,
|
|
connectoidGuid,
|
|
tempName
|
|
);
|
|
|
|
INetConnection_Release( connectoidObj );
|
|
}
|
|
|
|
//
|
|
// now set the connectoid to the new name
|
|
//
|
|
status = INetConnection_Rename( NetConnection, NewConnectoidName );
|
|
|
|
return status;
|
|
|
|
} // ClRtlSetConnectoidName
|
|
|
|
|
|
|
|
DWORD
|
|
ClRtlFindConnectoidByNameAndSetName(
|
|
LPWSTR ConnectoidName,
|
|
LPWSTR NewConnectoidName
|
|
)
|
|
{
|
|
DWORD status = E_UNEXPECTED;
|
|
INetConnection * connectoidObj;
|
|
|
|
connectoidObj = ClRtlFindConnectoidByName( ConnectoidName );
|
|
|
|
if ( connectoidObj != NULL ) {
|
|
status = ClRtlSetConnectoidName(connectoidObj, NewConnectoidName);
|
|
|
|
INetConnection_Release( connectoidObj );
|
|
}
|
|
else {
|
|
status = GetLastError();
|
|
}
|
|
|
|
return(status);
|
|
|
|
} // ClRtlFindConnectoidByNameAndSetName
|
|
|
|
|
|
|
|
DWORD
|
|
ClRtlFindConnectoidByGuidAndSetName(
|
|
LPWSTR ConnectoidGuid,
|
|
LPWSTR NewConnectoidName
|
|
)
|
|
{
|
|
DWORD status = E_UNEXPECTED;
|
|
INetConnection * connectoidObj;
|
|
|
|
connectoidObj = ClRtlFindConnectoidByGuid( ConnectoidGuid );
|
|
|
|
if ( connectoidObj != NULL ) {
|
|
status = ClRtlSetConnectoidName(connectoidObj, NewConnectoidName);
|
|
|
|
INetConnection_Release( connectoidObj );
|
|
}
|
|
else {
|
|
status = GetLastError();
|
|
}
|
|
|
|
return(status);
|
|
|
|
} // ClRtlFindConnectoidByGuidAndSetName
|
|
|
|
|