able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/tcpip/commands/ipconfig/info.c

1727 lines
48 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1999 Microsoft Corporation
Module Name:
info.c
Abstract:
exports GetNetworkInformation routine
--*/
#include <precomp.h>
//
// seems that if WINS addresses not specified, NetBT reports 127.0.0.0 so if
// this value is returned, we won't display them
//
#define LOCAL_WINS_ADDRESS 0x0000007f // 127.0.0.0
#define New(Size) LocalAlloc( LPTR, Size)
#define Delete(Ptr) if( NULL != Ptr ) LocalFree( Ptr )
#define CheckBoolError(Internal) if( FALSE == fSuccess ) {\
(*InternalError) = Internal; Error = GetLastError(); break; }
#define CheckError(Internal) if( NO_ERROR != Error ) {\
(*InternalError) = Internal; break; }
VOID
FreeIfInfo(
IN OUT PINTERFACE_NETWORK_INFO IfInfo
)
{
if( NULL == IfInfo ) return;
Delete( IfInfo->FriendlyName );
Delete( IfInfo->ConnectionName );
Delete( IfInfo->DhcpClassId );
Delete( IfInfo->IpAddress );
Delete( IfInfo->Ipv6Address );
Delete( IfInfo->IpMask );
Delete( IfInfo->Router );
Delete( IfInfo->WinsServer );
Delete( IfInfo->DnsServer );
Delete( IfInfo->Ipv6DnsServer );
Delete( IfInfo );
}
VOID
FreeNetworkInfo(
IN OUT PNETWORK_INFO NetInfo
)
{
DWORD i;
if( NULL == NetInfo ) return;
for( i = 0; i < NetInfo->nInterfaces ; i ++ ) {
FreeIfInfo( NetInfo->IfInfo[i] );
}
Delete( NetInfo->SuffixSearchList );
Delete( NetInfo );
}
DWORD
MapIfType(
IN OUT PINTERFACE_NETWORK_INFO IfInfo,
IN ULONG IfType
)
{
DWORD i;
DWORD Map[][2] = {
IF_TYPE_OTHER, IfTypeOther,
IF_TYPE_ETHERNET_CSMACD, IfTypeEthernet,
IF_TYPE_ISO88025_TOKENRING, IfTypeTokenring,
IF_TYPE_FDDI, IfTypeFddi,
IF_TYPE_PPP, IfTypePPP,
IF_TYPE_SOFTWARE_LOOPBACK, IfTypeLoopback,
IF_TYPE_SLIP, IfTypeSlip,
IF_TYPE_TUNNEL, IfTypeTunnel,
IF_TYPE_IEEE1394, IfType1394
};
for( i = 0; i < sizeof(Map)/sizeof(Map[0]); i ++ ) {
if( Map[i][0] == IfType ) {
IfInfo->IfType = Map[i][1];
return NO_ERROR;
}
}
return ERROR_NOT_FOUND;
}
LPWSTR
GetProperty(
IN HDEVINFO hdi,
IN SP_DEVINFO_DATA *deid,
IN ULONG Property
)
{
BOOL fSuccess;
ULONG Error, cbSize;
LPWSTR RetVal;
cbSize = 0;
fSuccess = SetupDiGetDeviceRegistryPropertyW(
hdi, deid, Property, NULL, NULL, 0, &cbSize
);
if( fSuccess ) {
RetVal = LocalAlloc(LPTR, sizeof(WCHAR));
if( NULL == RetVal ) return NULL;
(*RetVal) = L'\0';
return RetVal;
}
Error = GetLastError();
if( ERROR_INSUFFICIENT_BUFFER != Error ) return NULL;
RetVal = New( cbSize * sizeof(WCHAR) );
if( NULL == RetVal ) return NULL ;
fSuccess = SetupDiGetDeviceRegistryPropertyW(
hdi, deid, Property, NULL, (PVOID)RetVal, cbSize, NULL
);
if( FALSE == fSuccess ) {
Error = GetLastError();
Delete( RetVal );
SetLastError(Error);
return NULL;
}
return RetVal;
}
LPWSTR
GetDescriptionFromGuid(
IN GUID *Guid
)
{
WCHAR InstanceIdBuf[1000];
ULONG BufSizeInWChars = sizeof(InstanceIdBuf)/sizeof(WCHAR);
HRESULT hr;
HDEVINFO hdi;
SP_DEVINFO_DATA deid;
BOOL fSuccess;
ULONG Error;
LPWSTR DescrName = NULL;
deid.cbSize = sizeof(SP_DEVINFO_DATA);
hr = HrPnpInstanceIdFromGuid(Guid, InstanceIdBuf, BufSizeInWChars);
if( !SUCCEEDED(hr) ) {
SetLastError( HRESULT_CODE(hr) );
IPCFG_TRACE(IPCFG_TRACE_TCPIP, ("HrPnpInstanceIdFromGuid returns 0x%lx (%d)\n", hr, hr));
return NULL;
}
hdi = SetupDiCreateDeviceInfoList(&GUID_DEVCLASS_NET, NULL);
if( INVALID_HANDLE_VALUE != hdi ) {
fSuccess = SetupDiOpenDeviceInfoW(hdi, InstanceIdBuf, NULL, 0, &deid);
if( fSuccess ) {
DescrName = GetProperty(hdi, &deid, SPDRP_FRIENDLYNAME);
if( NULL == DescrName ) {
Error = GetLastError();
if( ERROR_SUCCESS != Error ) {
DescrName = GetProperty( hdi, &deid, SPDRP_DEVICEDESC );
if( NULL == DescrName ) {
Error = GetLastError();
} else {
Error = ERROR_SUCCESS;
}
} else {
//
// Error already set.
//
}
} else {
//
// We succeeded..
//
Error = ERROR_SUCCESS;
}
} else {
Error = GetLastError();
}
SetupDiDestroyDeviceInfoList(hdi);
} else {
Error = GetLastError();
}
SetLastError(Error);
return (ERROR_SUCCESS == Error)?DescrName:NULL;
}
LPWSTR
GetDescription(
IN GUID *Guid,
IN LPWSTR GuidString
)
{
LPWSTR RetVal = GetDescriptionFromGuid(Guid);
WCHAR GuidStringBuf[500];
GUID GuidStruct;
ULONG Status;
if( NULL != RetVal ) return RetVal;
SetLastError( ERROR_CAN_NOT_COMPLETE );
if( NULL == GuidString ) return NULL;
if( wcslen(GuidString)*sizeof(WCHAR) >= sizeof(GuidStringBuf)) {
return NULL;
}
if( GuidString[0] != L'{' ) return NULL;
wcscpy(GuidStringBuf, &GuidString[1]);
if( L'}' != GuidStringBuf[wcslen(GuidStringBuf)-1] ) {
return NULL;
}
GuidStringBuf[wcslen(GuidStringBuf)-1] = L'\0';
Status = UuidFromStringW(GuidStringBuf, &GuidStruct);
if( RPC_S_OK != Status ) {
SetLastError( Status );
return NULL;
}
return GetDescriptionFromGuid(&GuidStruct);
}
VOID
GetInterfaceGuidAndDeviceName(
IN PMIB_IFROW IfRow,
IN PIP_INTERFACE_INFO InterfaceInfo,
IN PIP_INTERFACE_NAME_INFO IfNameInfo,
IN ULONG IfNameCount,
OUT GUID *IfGuid,
OUT LPWSTR *IfDeviceName
)
{
DWORD i;
//
// Search interface name info to get the interface guid for
// this interface. Also, search the InterfaceInfo to get the
// devicename for this interface.
//
ZeroMemory( IfGuid, sizeof(*IfGuid) );
for( i = 0; i < IfNameCount ; i ++ ) {
if( IfRow->dwIndex != IfNameInfo[i].Index ) continue;
(*IfGuid) = IfNameInfo[i].InterfaceGuid;
break;
}
(*IfDeviceName) = NULL;
for( i = 0; i < (DWORD)InterfaceInfo->NumAdapters; i ++ ) {
if( InterfaceInfo->Adapter[i].Index != IfRow->dwIndex ) continue;
(*IfDeviceName) = InterfaceInfo->Adapter[i].Name + strlen(
"\\Device\\Tcpip_" );
break;
}
}
DWORD
MapFriendlyAndConnectionNames(
IN OUT PINTERFACE_NETWORK_INFO IfInfo,
IN PMIB_IFROW IfRow,
IN GUID IfGuid,
IN LPWSTR IfDeviceName
)
{
DWORD Size, Error;
WCHAR ConnName[500];
//
// Try to get friendly device name from IfGuid or DeviceName
// or failing both just use the description provided by tcpip
//
IfInfo->FriendlyName = GetDescription( &IfGuid, IfDeviceName );
IPCFG_TRACE(IPCFG_TRACE_TCPIP, ("GetDescription returns %p for %ws\n", IfInfo->FriendlyName, IfDeviceName));
if( NULL == IfInfo->FriendlyName ) {
Size = MultiByteToWideChar(
CP_ACP, 0, (LPSTR)IfRow->bDescr, IfRow->dwDescrLen, NULL, 0 );
if( Size == 0 ) return GetLastError();
Size ++;
IfInfo->FriendlyName = New( Size * sizeof(WCHAR) );
if (IfInfo->FriendlyName == NULL) return GetLastError();
Size = MultiByteToWideChar(
CP_ACP, 0, (LPSTR)IfRow->bDescr, IfRow->dwDescrLen,
IfInfo->FriendlyName, Size );
if( 0 == Size ) return GetLastError();
}
IPCFG_TRACE(IPCFG_TRACE_TCPIP, ("\tFriendly Name: %ws\n", IfInfo->FriendlyName));
//
// Now get the connection name. First try with LAN, then RAS
//
Size = sizeof(ConnName)/sizeof(WCHAR);
Error = HrLanConnectionNameFromGuidOrPath(
NULL, IfDeviceName, ConnName, &Size );
if( NO_ERROR != Error ) {
Size = sizeof(ConnName)/sizeof(WCHAR);
IPCFG_TRACE(IPCFG_TRACE_TCPIP, ("HrLanConnectionNameFromGuidOrPath fails 0x%lx(%d)", Error, Error));
Error = NhGetInterfaceNameFromGuid(
&IfGuid, ConnName, &Size, FALSE, FALSE );
if( NO_ERROR != Error ) {
ConnName[0] = L'\0';
IPCFG_TRACE(IPCFG_TRACE_TCPIP, (" NhGetInterfaceNameFromGuid fails 0x%lx(%d)", Error, Error));
//return Error;
}
}
IPCFG_TRACE(IPCFG_TRACE_TCPIP, ("\tConnection Name: %ws\n", ConnName));
IfInfo->ConnectionName = New( sizeof(WCHAR)*(1+wcslen(ConnName)));
if( NULL == IfInfo->ConnectionName ) return GetLastError();
wcscpy(IfInfo->ConnectionName, ConnName );
return NO_ERROR;
}
DWORD
GetMediaStatus(
IN LPWSTR IfDeviceName,
OUT BOOL *fDisconnected
)
{
WCHAR NdisDeviceString[512];
UNICODE_STRING NdisDevice;
NIC_STATISTICS NdisStats;
wcscpy((LPWSTR)NdisDeviceString, (LPWSTR)L"\\Device\\" );
wcscat((LPWSTR)NdisDeviceString, IfDeviceName );
ZeroMemory(&NdisStats, sizeof(NdisStats));
NdisStats.Size = sizeof(NdisStats);
RtlInitUnicodeString(&NdisDevice, (LPWSTR)NdisDeviceString);
if( FALSE == NdisQueryStatistics(&NdisDevice, &NdisStats) ) {
ULONG Error;
//
// Could not get statistics.. use default answer.
//
Error = GetLastError();
if( ERROR_NOT_READY == Error ) {
*fDisconnected = TRUE;
return NO_ERROR;
}
return Error;
}
if( NdisStats.MediaState == MEDIA_STATE_DISCONNECTED ) {
*fDisconnected = TRUE;
} else {
*fDisconnected = FALSE;
}
return NO_ERROR;
}
BOOL
IsMediaSenseDisabled(
HKEY RegKey
)
{
LPTSTR regValueName = (LPTSTR)(TEXT ("DisableDHCPMediaSense") );
DWORD regValueData;
DWORD regValueDataType;
DWORD regValueDataLen = sizeof(DWORD);
DWORD Error;
Error = RegQueryValueEx(
RegKey,
regValueName,
NULL,
&regValueDataType,
(LPBYTE)&regValueData,
&regValueDataLen);
return (Error == NO_ERROR) &&
(regValueDataType == REG_DWORD) &&
(regValueData != 0);
}
DWORD
OpenRegKey(
IN LPCWSTR Device,
IN DWORD KeyType,
IN DWORD AccessType,
OUT HKEY *phKey
)
{
DWORD Access;
WCHAR KeyLoc[256];
LPTSTR TcpipParmLoc = (LPTSTR)(TEXT( "SYSTEM\\CurrentControlSet\\Services" )
TEXT( "\\Tcpip\\Parameters" ) );
LPTSTR TcpipLoc = (LPTSTR)(TEXT( "SYSTEM\\CurrentControlSet\\Services" )
TEXT( "\\Tcpip\\Parameters\\Interfaces\\") );
LPTSTR NbtLoc = (LPTSTR)(TEXT("SYSTEM\\CurrentControlSet\\Services")
TEXT("\\Netbt\\Parameters\\Interfaces\\Tcpip_"));
switch (KeyType)
{
case OpenTcpipParmKey:
wcscpy(KeyLoc, TcpipParmLoc);
break;
case OpenTcpipKey:
wcscpy(KeyLoc, TcpipLoc);
wcscat(KeyLoc, Device);
break;
case OpenNbtKey:
wcscpy(KeyLoc, NbtLoc);
wcscat(KeyLoc, Device);
break;
}
Access = KEY_READ;
if( AccessType & OpenKeyForWrite ) Access |= KEY_WRITE;
return RegOpenKeyEx(
HKEY_LOCAL_MACHINE, KeyLoc, 0, Access, phKey );
}
VOID
SecondsToAbsolute(
OUT FILETIME *SysTime,
IN LONGLONG SecondsDifference
)
{
LONGLONG Diff = SecondsDifference;
Diff *= 10000; Diff *= 1000;
GetSystemTimeAsFileTime( SysTime );
(*((LONGLONG UNALIGNED64 *)SysTime)) -= Diff;
}
DWORD
GetDhcpValues(
IN PNETWORK_INFO NetInfo,
IN OUT PINTERFACE_NETWORK_INFO IfInfo,
IN HKEY hKey
)
{
WCHAR ClassId[200];
LPSTR DhcpServer;
DWORD Error, Value, Size, Type;
time_t CurrentTime, Obtained, Expires;
//
// First check if dhcp is enabled
//
do {
Size = sizeof(Value);
Error = RegQueryValueEx(
hKey, (LPTSTR)TEXT("EnableDHCP"), NULL, &Type,
(LPBYTE)&Value, &Size );
if( NO_ERROR != Error ) return Error;
if( Type != REG_DWORD ) return ERROR_INVALID_DATA;
IfInfo->EnableDhcp = (Value != 0 );
} while ( 0 );
//
// Now check for class id
//
do {
Size = sizeof(ClassId);
Error = RegQueryValueExW(
hKey, (LPWSTR)L"DhcpClassId", NULL, &Type, (LPBYTE)ClassId,
&Size );
if( ERROR_FILE_NOT_FOUND == Error ) {
Error = NO_ERROR;
Size = 0;
}
if( NO_ERROR != Error ) return Error;
if( Size == 0 ) break;
if( Type != REG_SZ ) return ERROR_INVALID_DATA;
Size = sizeof(WCHAR)*(1+wcslen(ClassId));
IfInfo->DhcpClassId = New( Size );
if( NULL == IfInfo->DhcpClassId ) return GetLastError();
wcscpy(IfInfo->DhcpClassId, ClassId );
} while( 0 );
//
// Now check if autoconfiguration is enabled
//
if( IfInfo->EnableDhcp ) do {
Size = sizeof(Value);
Error = RegQueryValueEx(
hKey, (LPTSTR)TEXT("IPAutoconfigurationEnabled"),
NULL, &Type, (LPBYTE)&Value, &Size );
if( ERROR_FILE_NOT_FOUND == Error ) {
IfInfo->EnableAutoconfig = NetInfo->GlobalEnableAutoconfig;
} else if( NO_ERROR != Error ) return Error;
else if( REG_DWORD != Type ) return ERROR_INVALID_DATA;
else IfInfo->EnableAutoconfig = (Value != 0 );
} while ( 0 );
//
// Get Dhcp server value
//
if( IfInfo->EnableDhcp ) do {
Size = sizeof(ClassId);
DhcpServer = (LPSTR)ClassId;
Error = RegQueryValueExA(
hKey, "DhcpServer", NULL, &Type,
(LPBYTE)DhcpServer, &Size );
if( ERROR_FILE_NOT_FOUND == Error ) break;
if( NO_ERROR != Error ) return Error;
if( REG_SZ != Type ) return ERROR_INVALID_DATA;
IfInfo->DhcpServer = inet_addr(DhcpServer);
} while( 0 );
//
// Now get lease expired and obtained times
//
CurrentTime = time(NULL);
if( IfInfo->EnableDhcp ) do {
Size = sizeof(Value);
Error = RegQueryValueEx(
hKey, (LPTSTR)TEXT("LeaseObtainedTime"),
NULL, &Type, (LPBYTE)&Value, &Size );
if( ERROR_FILE_NOT_FOUND == Error ) break;
if( NO_ERROR != Error ) return Error;
if( REG_DWORD != Type ) return ERROR_INVALID_DATA;
Obtained = (time_t)Value;
SecondsToAbsolute(
(FILETIME *)(&IfInfo->LeaseObtainedTime),
((LONGLONG)CurrentTime) - ((LONGLONG)Obtained) );
} while ( 0 );
if( IfInfo->EnableDhcp ) do {
Size = sizeof(Value);
Error = RegQueryValueEx(
hKey, (LPTSTR)TEXT("LeaseTerminatesTime"),
NULL, &Type, (LPBYTE)&Value, &Size );
if( ERROR_FILE_NOT_FOUND == Error ) break;
if( NO_ERROR != Error ) return Error;
if( REG_DWORD != Type ) return ERROR_INVALID_DATA;
Expires = (time_t)Value;
SecondsToAbsolute(
(FILETIME *)(&IfInfo->LeaseExpiresTime),
((LONGLONG)CurrentTime) - ((LONGLONG)Expires) );
} while ( 0 );
return NO_ERROR;
}
DWORD
GetDnsValues(
IN OUT PINTERFACE_NETWORK_INFO IfInfo,
IN HKEY hKey
)
{
CHAR *Servers = NULL, *Str;
DWORD Error, BufferSize, Size, Type, i, Count, *ThisAddr;
//
// First get DnsSuffix for the interface
//
Size = sizeof(IfInfo->DnsSuffix)/sizeof(WCHAR);
Error = RegQueryValueExW(
hKey, (LPWSTR)L"Domain", NULL, &Type,
(LPBYTE)IfInfo->DnsSuffix, &Size );
if( NO_ERROR != Error ) {
if( ERROR_FILE_NOT_FOUND != Error ) return Error;
Size = 0;
Type = REG_SZ;
}
if( REG_SZ != Type ) return ERROR_INVALID_DATA;
if( 0 == Size || 0 == wcslen(IfInfo->DnsSuffix) ) {
Size = sizeof(IfInfo->DnsSuffix)/sizeof(WCHAR);
Error = RegQueryValueExW(
hKey, (LPWSTR)L"DhcpDomain", NULL, &Type,
(LPBYTE)IfInfo->DnsSuffix, &Size );
if( NO_ERROR != Error ) {
if( ERROR_FILE_NOT_FOUND != Error ) return Error;
Size = 0;
IfInfo->DnsSuffix[0] = L'\0';
}
}
//
// Now attempt to read the DnsServers list
//
BufferSize = 800;
do {
Servers = New( BufferSize );
if( NULL == Servers) return GetLastError();
ZeroMemory(Servers, BufferSize);
Size = BufferSize;
Error = RegQueryValueExA(
hKey, (LPSTR)"NameServer", NULL, &Type, (LPBYTE)Servers,
&Size );
if( NO_ERROR == Error ) {
break;
}
Delete(Servers);
Servers = NULL;
if( ERROR_FILE_NOT_FOUND == Error ) {
Size = 0;
Type = REG_SZ;
break;
}
if (Error != ERROR_MORE_DATA) {
return Error;
}
BufferSize *= 2;
} while(1);
if( REG_SZ != Type ) return ERROR_INVALID_DATA;
if( 0 == Size || NULL == Servers || 0 == strlen(Servers) ) {
if (Servers) Delete(Servers);
BufferSize = 800;
do {
Servers = New( BufferSize );
if( NULL == Servers) return GetLastError();
ZeroMemory(Servers, BufferSize);
Size = BufferSize;
Error = RegQueryValueExA(
hKey, (LPSTR)"DhcpNameServer", NULL, &Type,
(LPBYTE)Servers, &Size );
if( NO_ERROR == Error ) {
break;
}
Delete(Servers);
Servers = NULL;
if( ERROR_FILE_NOT_FOUND == Error ) {
Size = 0;
Type = REG_SZ;
break;
}
if (Error != ERROR_MORE_DATA) {
return Error;
}
BufferSize *= 2;
} while(1);
}
//
// If there are any DNS Servers, convert them to IPaddr
//
if( 0 != Size && NULL != Servers && strlen(Servers) ) {
for( i = 0; i < Size; i ++ ) {
if( Servers[i] == ' ' || Servers[i] == ','
|| Servers[i] == ';' ) {
Servers[i] = '\0';
}
}
Servers[Size] = '\0';
Count = 0; Str = (LPSTR)Servers;
while( strlen(Str) ) {
Count ++;
Str += strlen(Str); Str ++;
}
ThisAddr = New( sizeof(IPV4_ADDRESS) * Count );
if( NULL == ThisAddr ) return GetLastError();
IfInfo->DnsServer = ThisAddr;
for (i = 0, Str = (LPSTR)Servers;
*Str != '\0';
Str += strlen(Str) + 1)
{
IfInfo->DnsServer[i] = inet_addr( Str );
if (IfInfo->DnsServer[i] != 0)
i++;
}
IfInfo->nDnsServers = i;
}
if (Servers) {
Delete (Servers);
}
return NO_ERROR;
}
DWORD
GetWinsValues(
IN OUT PINTERFACE_NETWORK_INFO IfInfo,
IN LPCWSTR DeviceName,
IN OUT ULONG *NodeType
)
{
WCHAR NbtDevice[MAX_PATH];
UNICODE_STRING NbtDeviceString;
HANDLE h;
OBJECT_ATTRIBUTES objAttr;
IO_STATUS_BLOCK iosb;
NTSTATUS status;
tWINS_NODE_INFO NodeInfo;
DWORD Count;
INT i;
wcscpy(NbtDevice, (LPWSTR)L"\\Device\\NetBT_Tcpip_");
wcscat(NbtDevice, DeviceName);
RtlInitUnicodeString( &NbtDeviceString, (LPWSTR)NbtDevice );
InitializeObjectAttributes(
&objAttr,
&NbtDeviceString,
OBJ_CASE_INSENSITIVE,
(HANDLE)NULL,
(PSECURITY_DESCRIPTOR)NULL
);
status = NtCreateFile(
&h, SYNCHRONIZE | GENERIC_EXECUTE, &objAttr, &iosb, NULL,
FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ | FILE_SHARE_WRITE,
FILE_OPEN_IF, 0, NULL, 0 );
if (!NT_SUCCESS(status)) {
DWORD w32error = RtlNtStatusToDosError( status );
IfInfo->EnableNbtOverTcpip = FALSE;
(*NodeType) = NodeTypeUnknown;
return w32error == ERROR_FILE_NOT_FOUND ? NO_ERROR : w32error;
}
status = NtDeviceIoControlFile(
h, NULL, NULL, NULL, &iosb, IOCTL_NETBT_GET_WINS_ADDR,
NULL, 0, (PVOID)&NodeInfo, sizeof(NodeInfo) );
if (status == STATUS_PENDING) {
status = NtWaitForSingleObject(h, TRUE, NULL);
if (NT_SUCCESS(status)) {
status = iosb.Status;
}
}
NtClose(h);
if (!NT_SUCCESS(status)) {
return RtlNtStatusToDosError( status );
}
//
// for some reason, NetBT returns the addresses in low-byte order. We have
// to swap them
//
Count = 0;
for( i = 0; i < 2+MAX_NUM_OTHER_NAME_SERVERS; i ++ ) {
NodeInfo.AllNameServers[i] = htonl(NodeInfo.AllNameServers[i]);
if( LOCAL_WINS_ADDRESS == NodeInfo.AllNameServers[i] ||
INADDR_ANY == NodeInfo.AllNameServers[i] ||
INADDR_BROADCAST == NodeInfo.AllNameServers[i] ) {
break;
}
Count ++;
}
for ( i = IfInfo->nIpAddresses-1; i >= 0; i--)
if (IfInfo->IpAddress[i] != 0)
break;
if (Count > (DWORD)(NodeInfo.NumOtherServers + 2)) {
Count = (DWORD)(NodeInfo.NumOtherServers + 2);
}
if( i != -1 && Count != 0 ) {
IfInfo->WinsServer = New( sizeof(IPV4_ADDRESS)*Count );
if( NULL == IfInfo->WinsServer ) return GetLastError();
IfInfo->nWinsServers = Count;
for( i = 0; (DWORD)i < Count; i ++ ) {
IfInfo->WinsServer[i] = NodeInfo.AllNameServers[i];
}
}
IfInfo->EnableNbtOverTcpip = NodeInfo.NetbiosEnabled;
#define NODE_TYPE_BROADCAST 1
#define NODE_TYPE_PEER_PEER 2
#define NODE_TYPE_MIXED 4
#define NODE_TYPE_HYBRID 8
switch( NodeInfo.NodeType ) {
case NODE_TYPE_BROADCAST : (*NodeType) = NodeTypeBroadcast; break;
case NODE_TYPE_PEER_PEER : (*NodeType) = NodeTypePeerPeer; break;
case NODE_TYPE_MIXED : (*NodeType) = NodeTypeMixed; break;
case NODE_TYPE_HYBRID : (*NodeType) = NodeTypeHybrid ; break;
default: (*NodeType) = NodeTypeUnknown; break;
}
return NO_ERROR;
}
DWORD
GetAddressValues(
IN OUT PINTERFACE_NETWORK_INFO IfInfo,
IN PMIB_IPADDRTABLE AddrTable,
IN ULONG IfIndex
)
{
DWORD i, Count;
if( NULL == AddrTable ) return ERROR_NOT_FOUND;
Count = 0;
for( i = 0; i < AddrTable->dwNumEntries ; i ++ ) {
if( AddrTable->table[i].dwIndex == IfIndex ) {
Count ++;
}
}
if( 0 == Count ) return NO_ERROR;
//
// Allocate space for this
//
IfInfo->IpAddress = New( sizeof(IPV4_ADDRESS)*Count );
if( NULL == IfInfo->IpAddress ) return GetLastError();
IfInfo->IpMask = New( sizeof(IPV4_ADDRESS)*Count );
if( NULL == IfInfo->IpMask ) return GetLastError();
IfInfo->nIpAddresses = IfInfo->nIpMasks = Count;
//
// First add the primary addresses
//
Count = 0;
for( i = 0; i < AddrTable->dwNumEntries; i ++ ) {
if( AddrTable->table[i].dwIndex != IfIndex ) continue;
if( !(AddrTable->table[i].wType & MIB_IPADDR_PRIMARY)) continue;
IfInfo->IpAddress[Count] = AddrTable->table[i].dwAddr;
IfInfo->IpMask[Count] = AddrTable->table[i].dwMask;
Count ++;
}
//
// Now add just the non-primary addresses
//
for( i = 0; i < AddrTable->dwNumEntries; i ++ ) {
if( AddrTable->table[i].dwIndex != IfIndex ) continue;
if(AddrTable->table[i].wType & MIB_IPADDR_PRIMARY) continue;
IfInfo->IpAddress[Count] = AddrTable->table[i].dwAddr;
IfInfo->IpMask[Count] = AddrTable->table[i].dwMask;
Count ++;
}
return NO_ERROR;
}
DWORD
GetRouteValues(
IN OUT PINTERFACE_NETWORK_INFO IfInfo,
IN PMIB_IPFORWARDTABLE RouteTable,
IN ULONG IfIndex
)
{
DWORD i, Count;
if( NULL == RouteTable ) return ERROR_NOT_FOUND;
Count = 0;
for( i = 0; i < RouteTable->dwNumEntries; i ++ ) {
if( RouteTable->table[i].dwForwardIfIndex == IfIndex &&
INADDR_ANY == RouteTable->table[i].dwForwardDest &&
MIB_IPROUTE_TYPE_INVALID !=
RouteTable->table[i].dwForwardType ) {
Count ++;
}
}
if( 0 == Count ) return NO_ERROR;
IfInfo->Router = New( sizeof(IPV4_ADDRESS)*Count);
if( NULL == IfInfo->Router ) return GetLastError();
IfInfo->nRouters = Count;
Count = 0;
for( i = 0; i < RouteTable->dwNumEntries; i ++ ) {
if( RouteTable->table[i].dwForwardIfIndex == IfIndex &&
INADDR_ANY == RouteTable->table[i].dwForwardDest &&
MIB_IPROUTE_TYPE_INVALID !=
RouteTable->table[i].dwForwardType ) {
IfInfo->Router[Count] = RouteTable->table[i].dwForwardNextHop;
Count ++;
}
}
return NO_ERROR;
}
VOID
IncrementCount(
IN IPV6_INFO_ROUTE_TABLE *RTE,
IN PVOID Arg1,
IN OUT PVOID Count
)
{
PIP_ADAPTER_ADDRESSES If = (PIP_ADAPTER_ADDRESSES)Arg1;
if ((RTE->This.PrefixLength == 0) &&
(RTE->This.Neighbor.IF.Index == If->Ipv6IfIndex)) {
(*(ULONG *)Count)++;
}
}
VOID
AddRouter(
IN IPV6_INFO_ROUTE_TABLE *RTE,
IN PVOID Arg1,
IN OUT PVOID Arg2
)
{
PIP_ADAPTER_ADDRESSES If = (PIP_ADAPTER_ADDRESSES)Arg1;
PINTERFACE_NETWORK_INFO pIfInfo = (PINTERFACE_NETWORK_INFO)Arg2;
ULONG Index;
LPSOCKADDR_IN6 Addr;
if (RTE->This.PrefixLength != 0) {
return;
}
if (RTE->This.Neighbor.IF.Index != If->Ipv6IfIndex) {
return;
}
//
// We now have a default router to add to the list.
//
Index = pIfInfo->nIpv6Routers++;
Addr = &pIfInfo->Ipv6Router[Index];
Addr->sin6_family = AF_INET6;
Addr->sin6_addr = RTE->This.Neighbor.Address;
Addr->sin6_port = 0;
if (IN6_IS_ADDR_LINKLOCAL(&Addr->sin6_addr)) {
Addr->sin6_scope_id = If->ZoneIndices[ScopeLevelLink];
} else if (IN6_IS_ADDR_SITELOCAL(&Addr->sin6_addr)) {
Addr->sin6_scope_id = If->ZoneIndices[ScopeLevelSite];
} else {
Addr->sin6_scope_id = 0;
}
}
ULONG
ForEachRoute(
IN VOID (*Func)(IPV6_INFO_ROUTE_TABLE *, PVOID, PVOID),
IN PVOID Arg1,
IN OUT PVOID Arg2
)
{
IPV6_QUERY_ROUTE_TABLE Query, NextQuery;
IPV6_INFO_ROUTE_TABLE RTE;
ULONG BytesReturned;
static HANDLE Ipv6Handle = INVALID_HANDLE_VALUE;
if (Ipv6Handle == INVALID_HANDLE_VALUE) {
//
// Open a handle to the IPv6 device on our first invocation.
// Keep it open until the process terminates, since we'll
// terminate once we've generated the output.
//
Ipv6Handle = CreateFileW(WIN_IPV6_DEVICE_NAME,
0,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL, // security attributes
OPEN_EXISTING,
0, // flags & attributes
NULL); // template file
}
NextQuery.Neighbor.IF.Index = 0;
for (;;) {
Query = NextQuery;
if (!DeviceIoControl(Ipv6Handle, IOCTL_IPV6_QUERY_ROUTE_TABLE,
&Query, sizeof Query,
&RTE, sizeof RTE, &BytesReturned,
NULL)) {
return GetLastError();
}
NextQuery = RTE.Next;
if (Query.Neighbor.IF.Index != 0) {
RTE.This = Query;
(*Func)(&RTE, Arg1, Arg2);
}
if (NextQuery.Neighbor.IF.Index == 0)
break;
}
return NO_ERROR;
}
VOID
AddIpv6PerInterfaceInfo(
IN DWORD IfIndex,
IN PINTERFACE_NETWORK_INFO pIfInfo,
IN PIP_ADAPTER_ADDRESSES IfList
)
{
PIP_ADAPTER_ADDRESSES If;
PIP_ADAPTER_UNICAST_ADDRESS Addr;
PIP_ADAPTER_DNS_SERVER_ADDRESS Dns;
ULONG Count, BytesReturned;
LPSOCKADDR_IN6 SockAddr;
IPV6_QUERY_ROUTE_TABLE Query, NextQuery;
IPV6_INFO_ROUTE_TABLE RTE;
//
// Find matching entry in the IPv6 interface list.
//
for (If = IfList; If; If = If->Next) {
if (IfIndex == If->IfIndex) {
break;
}
}
if ((If == NULL) || (If->Ipv6IfIndex == 0)) {
return;
}
//
// Append IPv6 unicast addresses.
//
Count = 0;
for (Addr = If->FirstUnicastAddress; Addr; Addr = Addr->Next) {
if ((Addr->Address.lpSockaddr->sa_family == AF_INET6) &&
(Addr->DadState >= IpDadStateDeprecated)) {
Count++;
}
}
pIfInfo->Ipv6Address = New(Count * sizeof(SOCKADDR_IN6));
if (pIfInfo->Ipv6Address != NULL) {
Count = 0;
for (Addr = If->FirstUnicastAddress; Addr; Addr = Addr->Next) {
if ((Addr->Address.lpSockaddr->sa_family == AF_INET6) &&
(Addr->DadState >= IpDadStateDeprecated)) {
CopyMemory(&pIfInfo->Ipv6Address[Count++],
Addr->Address.lpSockaddr,
sizeof(SOCKADDR_IN6));
}
}
pIfInfo->nIpv6Addresses = Count;
} else {
pIfInfo->nIpv6Addresses = 0;
}
//
// Append IPv6 DNS server addresses.
//
Count = 0;
for (Dns = If->FirstDnsServerAddress; Dns; Dns = Dns->Next) {
if (Dns->Address.lpSockaddr->sa_family == AF_INET6) {
Count++;
}
}
pIfInfo->Ipv6DnsServer = New(Count * sizeof(SOCKADDR_IN6));
if (pIfInfo->Ipv6DnsServer != NULL) {
Count = 0;
for (Dns = If->FirstDnsServerAddress; Dns; Dns = Dns->Next) {
if (Dns->Address.lpSockaddr->sa_family == AF_INET6) {
CopyMemory(&pIfInfo->Ipv6DnsServer[Count++],
Dns->Address.lpSockaddr,
sizeof(SOCKADDR_IN6));
}
}
pIfInfo->nIpv6DnsServers = Count;
} else {
pIfInfo->nIpv6DnsServers = 0;
}
//
// Append IPv6 default router addresses.
//
Count = 0;
ForEachRoute(IncrementCount, If, &Count);
pIfInfo->nIpv6Routers = 0;
pIfInfo->Ipv6Router = New(Count * sizeof(SOCKADDR_IN6));
if (pIfInfo->Ipv6Router != NULL) {
ForEachRoute(AddRouter, If, pIfInfo);
}
}
DWORD
GetPerInterfaceInfo(
IN OUT PNETWORK_INFO NetInfo,
OUT PINTERFACE_NETWORK_INFO *pIfInfo,
IN PMIB_IFROW IfRow,
IN PIP_INTERFACE_INFO InterfaceInfo,
IN PIP_INTERFACE_NAME_INFO IfNameInfo,
IN ULONG IfNameCount,
IN PMIB_IPADDRTABLE AddrTable,
IN PMIB_IPFORWARDTABLE RouteTable,
IN PIP_ADAPTER_ADDRESSES IfList,
IN OUT DWORD *InternalError
)
{
DWORD Error, NodeType;
PINTERFACE_NETWORK_INFO IfInfo = New( sizeof(*IfInfo) );
GUID IfGuid;
LPWSTR IfDeviceName;
HKEY TcpipKey = NULL;
HKEY TcpipParmKey = NULL;
if( NULL == IfInfo ) return GetLastError();
(*pIfInfo) = IfInfo;
ZeroMemory( &IfGuid, sizeof(IfGuid) );
IfDeviceName = NULL;
GetInterfaceGuidAndDeviceName(
IfRow, InterfaceInfo, IfNameInfo, IfNameCount,
&IfGuid, &IfDeviceName );
if( NULL == IfDeviceName ) {
(*InternalError) = InterfaceUnknownTcpipDevice;
return ERROR_NOT_FOUND;
}
IPCFG_TRACE(IPCFG_TRACE_TCPIP, ("\tDeviceName: %ws\n", IfDeviceName));
wcscpy(IfInfo->DeviceGuidName, IfDeviceName );
Error = OpenRegKey(
IfDeviceName, OpenTcpipKey, OpenKeyForRead, &TcpipKey );
if (Error == NO_ERROR)
Error = OpenRegKey(
IfDeviceName, OpenTcpipParmKey, OpenKeyForRead, &TcpipParmKey );
if( NO_ERROR != Error ) {
(*InternalError) = InterfaceOpenTcpipKeyReadFailure;
}
while (Error == NO_ERROR)
{
Error = MapIfType( IfInfo, IfRow->dwType);
CheckError( InterfaceUnknownType );
IfInfo->PhysicalNameLength = IfRow->dwPhysAddrLen;
CopyMemory(
IfInfo->PhysicalName,IfRow->bPhysAddr,
IfRow->dwPhysAddrLen );
Error = MapFriendlyAndConnectionNames(
IfInfo, IfRow, IfGuid, IfDeviceName );
CheckError( InterfaceUnknownFriendlyName );
if( IfRow->dwType == IF_TYPE_PPP ||
IfRow->dwType == IF_TYPE_TUNNEL ||
IsMediaSenseDisabled(TcpipParmKey)) {
IfInfo->MediaDisconnected = FALSE;
} else {
Error = GetMediaStatus(
IfDeviceName, &IfInfo->MediaDisconnected );
CheckError( InterfaceUnknownMediaStatus );
}
Error = GetDhcpValues( NetInfo, IfInfo, TcpipKey );
CheckError( InterfaceDhcpValuesFailure );
Error = GetDnsValues( IfInfo, TcpipKey );
CheckError( InterfaceDnsValuesFailure );
Error = GetAddressValues(
IfInfo, AddrTable, IfRow->dwIndex );
CheckError( InterfaceAddressValuesFailure );
Error = GetRouteValues(
IfInfo, RouteTable, IfRow->dwIndex );
CheckError( InterfaceRouteValuesFailure );
Error = GetWinsValues( IfInfo, IfDeviceName, &NodeType );
CheckError( InterfaceWinsValuesFailure );
//
// Now set the node type as well
//
NetInfo->NodeType = NodeType;
//
// Now write out if autoconfig is active. The way this
// works is to check if dhcp is enabled and dhcpserver
// address is zero or all ones
//
if( IfInfo->EnableDhcp && IfInfo->EnableAutoconfig
&& IfInfo->nIpAddresses
&& IfInfo->IpAddress[0] != INADDR_ANY
&& ( IfInfo->DhcpServer == INADDR_BROADCAST ||
IfInfo->DhcpServer == INADDR_ANY ) ) {
IfInfo->AutoconfigActive = TRUE;
}
break;
}
if (TcpipKey != NULL)
RegCloseKey( TcpipKey );
if (TcpipParmKey != NULL)
RegCloseKey( TcpipParmKey );
AddIpv6PerInterfaceInfo( IfRow->dwIndex, IfInfo, IfList );
return Error;
}
DWORD
GetIpv6OnlyPerInterfaceInfo(
OUT PINTERFACE_NETWORK_INFO *pIfInfo,
IN PIP_ADAPTER_ADDRESSES If
)
{
DWORD Error = NO_ERROR;
PINTERFACE_NETWORK_INFO IfInfo;
IfInfo = New( sizeof(*IfInfo) );
if( NULL == IfInfo ) return GetLastError();
(*pIfInfo) = IfInfo;
ZeroMemory(IfInfo, sizeof(*IfInfo));
MapIfType(IfInfo, If->IfType);
IfInfo->PhysicalNameLength = If->PhysicalAddressLength;
CopyMemory(IfInfo->PhysicalName, If->PhysicalAddress,
If->PhysicalAddressLength);
//
// INTERFACE_NETWORK_INFO has weird field names compared to
// IP_ADAPTER_ADDRESSES. The former puts the description in its
// "friendly name" field.
//
IfInfo->FriendlyName = New((wcslen(If->Description) + 1) * sizeof(WCHAR));
if( NULL != IfInfo->FriendlyName ) {
wcscpy(IfInfo->FriendlyName, If->Description);
}
IfInfo->ConnectionName = New((wcslen(If->FriendlyName) + 1) * sizeof(WCHAR));
if( NULL != IfInfo->ConnectionName ) {
wcscpy(IfInfo->ConnectionName, If->FriendlyName);
}
IfInfo->MediaDisconnected = (If->OperStatus == IfOperStatusLowerLayerDown);
IfInfo->EnableAutoconfig = TRUE;
wcscpy(IfInfo->DnsSuffix, If->DnsSuffix);
AddIpv6PerInterfaceInfo(0, IfInfo, If);
return Error;
}
BOOL
GetGlobalTcpipAutoconfigFlag()
{
HKEY hKey;
BOOL rtn;
DWORD Error;
DWORD Type, Value, Size;
rtn = TRUE;
Error = OpenRegKey(
NULL, OpenTcpipParmKey, OpenKeyForRead, &hKey );
if (Error != NO_ERROR) {
return TRUE;
}
Error = RegQueryValueEx(
hKey, (LPTSTR)TEXT("IPAutoconfigurationEnabled"),
NULL, &Type, (LPBYTE)&Value, &Size );
if (Error == NO_ERROR && Type == REG_DWORD) {
rtn = (Value)? TRUE: FALSE;
}
RegCloseKey( hKey );
return rtn;
}
ULONG
CountIpv6OnlyInterfaces(
IN PIP_ADAPTER_ADDRESSES IfList
)
{
PIP_ADAPTER_ADDRESSES If;
ULONG Count = 0;
for (If = IfList; If; If = If->Next) {
if ((If->IfIndex == 0) && (If->Ipv6IfIndex != 0) &&
(If->IfType != IF_TYPE_SOFTWARE_LOOPBACK) &&
((If->IfType != IF_TYPE_TUNNEL) || (If->FirstUnicastAddress != NULL))) {
Count++;
}
}
return Count;
}
DWORD
GetNetworkInformation(
OUT PNETWORK_INFO *pNetInfo,
IN OUT DWORD *InternalError
)
{
DWORD Size, Length, Error, i, j, k, IfNameCount, IfCount;
BOOL fSuccess;
PNETWORK_INFO NetInfo;
MIB_IPSTATS IpStats;
FIXED_INFO *FixedInfo;
PDNS_SEARCH_INFORMATION SearchInfo;
PMIB_IFTABLE pIfTable;
PIP_INTERFACE_INFO InterfaceInfo;
PIP_INTERFACE_NAME_INFO IfNameInfo;
PMIB_IPADDRTABLE AddrTable;
PMIB_IPFORWARDTABLE RouteTable;
PIP_ADAPTER_ADDRESSES IfList, If;
ULONG BufferLength, Flags;
//
// Allocate main structure
//
(*InternalError) = NO_ERROR;
(*pNetInfo) = NetInfo = New( sizeof(NETWORK_INFO ) );
if( NULL == NetInfo ) return GetLastError();
Flags = GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST;
GetAdaptersAddresses(AF_UNSPEC, Flags, NULL, NULL, &BufferLength);
IfList = (PIP_ADAPTER_ADDRESSES)New(BufferLength);
if( NULL == IfList ) return GetLastError();
Error = GetAdaptersAddresses(AF_UNSPEC, Flags, NULL, IfList, &BufferLength);
if( Error != NO_ERROR ) {
Delete(IfList);
return Error;
}
SearchInfo = NULL;
pIfTable = NULL;
InterfaceInfo = NULL;
IfNameInfo = NULL;
AddrTable = NULL;
RouteTable = NULL;
do {
//
// Fill important fields of the main structure
//
Length = MaxHostNameSize;
fSuccess = GetComputerNameExW(
ComputerNameDnsHostname, NetInfo->HostName, &Length );
CheckBoolError( GlobalHostNameFailure );
Length = MaxDomainNameSize;
fSuccess = GetComputerNameExW(
ComputerNameDnsDomain, NetInfo->DomainName, &Length );
if( FALSE == fSuccess ) NetInfo->DomainName[0] = L'\0';
Error = GetIpStatistics( &IpStats );
CheckError( GlobalEnableRouterFailure );
NetInfo->EnableRouting = (
IpStats.dwForwarding == MIB_IP_FORWARDING );
//
// EnableProxy and EnableDnsForNetbios both come from the
// registry directly? We will use the GetNetworkParams
// API for this instead.
//
Size = 1000;
FixedInfo = NULL;
do {
Delete(FixedInfo);
FixedInfo = (PFIXED_INFO)New(Size);
if (NULL == FixedInfo) {
Error = ERROR_NOT_ENOUGH_MEMORY;
break;
}
Length = Size;
Error = GetNetworkParams( FixedInfo, &Length );
Size = Length;
} while (Error == ERROR_BUFFER_OVERFLOW);
CheckError( GlobalEnableDnsFailure );
NetInfo->EnableProxy = FixedInfo->EnableProxy;
NetInfo->EnableDnsForNetbios = FixedInfo->EnableDns;
Delete(FixedInfo);
FixedInfo = NULL;
//
// Now get the suffix search list from Dns
//
SearchInfo = DnsQueryConfigAlloc(
DnsConfigSearchInformation,
NULL );
if( NULL != SearchInfo ) {
Length = 0;
for( i = 0; i < SearchInfo->cNameCount ; i ++ ) {
Length += MultiByteToWideChar(
CP_UTF8, 0, SearchInfo->aSearchListNames[i],
-1, NULL, 0 );
}
if( Length != 0 ) {
Length ++;
NetInfo->SuffixSearchList = New( sizeof(WCHAR)*Length);
if( NULL == NetInfo->SuffixSearchList ) {
Error = GetLastError(); break;
}
Size = Length; Length = 0;
for( i = 0; i < SearchInfo->cNameCount ; i ++ ) {
Length += MultiByteToWideChar(
CP_UTF8, 0, SearchInfo->aSearchListNames[i],
-1, &NetInfo->SuffixSearchList[Length],
Size - Length );
}
}
}
//
// Now go for the interface specific stuff.
//
Error = NhpAllocateAndGetInterfaceInfoFromStack(
&IfNameInfo, &IfNameCount, TRUE, GetProcessHeap(),
HEAP_NO_SERIALIZE );
CheckError( GlobalIfNameInfoFailure );
#ifdef __IPCFG_ENABLE_LOG__
IPCFG_TRACE(IPCFG_TRACE_TCPIP, ("NhpAllocateAndGetInterfaceInfoFromStack returns 0x%lx (%d) %d Interfaces\n",
Error, Error, IfNameCount));
for (i = 0; i < IfNameCount; i++) {
LPWSTR DeviceGuid, InterfaceGuid;
DeviceGuid = InterfaceGuid = NULL;
UuidToStringW(&IfNameInfo[i].DeviceGuid, &DeviceGuid);
UuidToStringW(&IfNameInfo[i].InterfaceGuid, &InterfaceGuid);
if (DeviceGuid == NULL || InterfaceGuid == NULL) {
if (DeviceGuid) RpcStringFree(&DeviceGuid);
if (InterfaceGuid) RpcStringFree(&InterfaceGuid);
IPCFG_TRACE(IPCFG_TRACE_TCPIP, ("\t%2d. Index=0x%x DeviceGUID=<fail> InterfaceGUID=<fail>\n",
i + 1, IfNameInfo[i].Index));
} else {
IPCFG_TRACE(IPCFG_TRACE_TCPIP, ("\t%2d. Index=0x%x\n\t DeviceGUID=%ws\n\t InterfaceGUID=%ws\n",
i + 1, IfNameInfo[i].Index, DeviceGuid, InterfaceGuid));
RpcStringFree(&DeviceGuid);
RpcStringFree(&InterfaceGuid);
}
}
#endif
Size = 1000;
do {
Delete( RouteTable );
RouteTable = New( Size );
if( NULL == RouteTable ) {
Error = GetLastError();
} else {
Error = GetIpForwardTable(
RouteTable, &Size, FALSE );
}
} while( ERROR_INSUFFICIENT_BUFFER == Error );
#ifdef __IPCFG_ENABLE_LOG__
if (RouteTable) {
IPCFG_TRACE(IPCFG_TRACE_TCPIP, ("GetIpForwardTable returns 0x%lx (%d) %d routing entries\n",
Error, Error, RouteTable->dwNumEntries));
for (i = 0; i < RouteTable->dwNumEntries; i++) {
IPCFG_TRACE(IPCFG_TRACE_TCPIP, ("\t%2d. Index=0x%x Next Hop=%s ",
i + 1, RouteTable->table[i].dwForwardIfIndex,
inet_ntoa(*(struct in_addr*)&RouteTable->table[i].dwForwardNextHop)));
IPCFG_TRACE(IPCFG_TRACE_TCPIP, ("Mask=%s Type=0x%x\n",
inet_ntoa(*(struct in_addr*)&RouteTable->table[i].dwForwardMask),
RouteTable->table[i].dwForwardType));
}
}
#endif
Size = 1000;
do {
Delete( AddrTable );
AddrTable = New( Size );
if( NULL == AddrTable ) {
Error = GetLastError();
} else {
Error = GetIpAddrTable( AddrTable, &Size, TRUE );
}
} while( ERROR_INSUFFICIENT_BUFFER == Error );
CheckError( GlobalAddrTableFailure );
#ifdef __IPCFG_ENABLE_LOG__
IPCFG_TRACE(IPCFG_TRACE_TCPIP, ("GetIpAddrTable returns 0x%lx (%d) %d IP entries\n",
Error, Error, AddrTable->dwNumEntries));
for (i = 0; i < AddrTable->dwNumEntries; i++) {
IPCFG_TRACE(IPCFG_TRACE_TCPIP, ("\t%2d. Index=0x%x IP=%s",
i + 1, AddrTable->table[i].dwIndex,
inet_ntoa(*(struct in_addr*)&AddrTable->table[i].dwAddr)));
IPCFG_TRACE(IPCFG_TRACE_TCPIP, (" mask=%s Type=0x%x\n",
inet_ntoa(*(struct in_addr*)&AddrTable->table[i].dwMask),
AddrTable->table[i].wType));
}
#endif
Size = 1000;
do {
Delete( pIfTable );
pIfTable = New( Size );
if( NULL == pIfTable ) {
Error = GetLastError();
} else {
Error = GetIfTable( pIfTable, &Size, TRUE );
}
} while( ERROR_INSUFFICIENT_BUFFER == Error );
CheckError( GlobalIfTableFailure );
#ifdef __IPCFG_ENABLE_LOG__
IPCFG_TRACE(IPCFG_TRACE_TCPIP, ("GetIfTable returns 0x%lx (%d) %d Interfaces\n",
Error, Error, pIfTable->dwNumEntries));
for( i = 0; i < pIfTable->dwNumEntries; i ++ ) {
IPCFG_TRACE(IPCFG_TRACE_TCPIP, ("\t%2d. IfIndex=0x%x Name=%ws IfType=0x%x\n",
i + 1, pIfTable->table[i].dwIndex, pIfTable->table[i].wszName, pIfTable->table[i].dwType));
}
#endif
Size = 1000;
do {
Delete( InterfaceInfo );
InterfaceInfo = New( Size );
if( NULL == InterfaceInfo ) {
Error = GetLastError();
} else {
Error = GetInterfaceInfo( InterfaceInfo, &Size );
}
} while( ERROR_INSUFFICIENT_BUFFER == Error );
CheckError( GlobalIfInfoFailure );
#ifdef __IPCFG_ENABLE_LOG__
IPCFG_TRACE(IPCFG_TRACE_TCPIP, ("GetInterfaceInfo returns 0x%lx (%d) %d Interfaces\n",
Error, Error, InterfaceInfo->NumAdapters));
for( i = 0; i < (DWORD)InterfaceInfo->NumAdapters; i ++ ) {
IPCFG_TRACE(IPCFG_TRACE_TCPIP, ("\t%2d. Index=0x%x\n\t Name=%ws\n",
i + 1, InterfaceInfo->Adapter[i].Index, InterfaceInfo->Adapter[i].Name));
}
#endif
//
// Get global AutoConfig settings
//
NetInfo->GlobalEnableAutoconfig = GetGlobalTcpipAutoconfigFlag();
IPCFG_TRACE(IPCFG_TRACE_TCPIP, ("GlobalAutoConfigFlag: %d\n", NetInfo->GlobalEnableAutoconfig));
//
// Check for number of interfaces and allocate required
// space in the IfInfo field
//
IfCount = pIfTable->dwNumEntries;
IfCount += CountIpv6OnlyInterfaces(IfList);
if( IfCount > 1 ) {
NetInfo->nInterfaces = IfCount-1;
NetInfo->IfInfo = New(
NetInfo->nInterfaces * sizeof(PVOID) );
if( NULL == NetInfo->IfInfo ) {
Error = GetLastError(); break;
}
//
// First add interfaces running IPv4.
//
j = 0;
for( i = 0; i < pIfTable->dwNumEntries ; i ++ ) {
BOOL fFound = FALSE;
for( k = 0; k <
(DWORD)InterfaceInfo->NumAdapters; k ++ ) {
if( pIfTable->table[i].dwIndex ==
InterfaceInfo->Adapter[k].Index ) {
fFound = TRUE;
break;
}
}
if( fFound &&
pIfTable->table[i].dwType != IF_TYPE_SOFTWARE_LOOPBACK ) {
IPCFG_TRACE(IPCFG_TRACE_TCPIP, ("\n\n************ GetPerInterfaceInfo for "
"IfIndex=0x%x Name=%ws IfType=0x%x\n",
pIfTable->table[i].dwIndex, pIfTable->table[i].wszName, pIfTable->table[i].dwType));
Error = GetPerInterfaceInfo(
NetInfo, &NetInfo->IfInfo[j],
&pIfTable->table[i], InterfaceInfo,
IfNameInfo, IfNameCount, AddrTable,
RouteTable, IfList, InternalError );
if( NO_ERROR != Error ) break;
j ++;
}
}
//
// Now add any IPv6-only interfaces.
//
for (If = IfList; If; If = If->Next) {
if ((If->IfIndex == 0) && (If->Ipv6IfIndex != 0) &&
(If->IfType != IF_TYPE_SOFTWARE_LOOPBACK) &&
((If->IfType != IF_TYPE_TUNNEL) || (If->FirstUnicastAddress != NULL))) {
Error = GetIpv6OnlyPerInterfaceInfo(&NetInfo->IfInfo[j],
If);
if( NO_ERROR != Error ) break;
j ++;
}
}
NetInfo->nInterfaces = j;
if( NO_ERROR != Error ) break;
}
} while ( 0 );
Delete( pIfTable );
Delete( InterfaceInfo );
Delete( IfNameInfo );
Delete( AddrTable );
Delete( RouteTable );
Delete( FixedInfo );
Delete( IfList );
if ( SearchInfo ) {
DnsFreeConfigStructure(
SearchInfo,
DnsConfigSearchInformation );
}
return Error;
}
Reference in a new issue Copy permalink