|
|
/*++
Copyright (c) 1994 Microsoft Corporation
Module Name: //KERNEL/RAZZLE3/src/sockets/tcpcmd/ipconfigext/ipcfgdll/ipconfig.c
SYNOPSIS: IPCFGDLL.DLL exports routines
Abstract:
Author: Richard L Firth (rfirth) 05-Feb-1994
Revision History:
05-Feb-1994 rfirth Created
04-Mar-1994 rfirth * Pick non-Dhcp registry values if DHCP not enabled * TCP and IP have been consolidated
27-Apr-1994 rfirth * added /release and /renew
06-Aug-1994 rfirth * Get IP address values from TCP/IP stack, not registry
30-Apr-97 MohsinA * Cleaning up for NT50.
17-Jan-98 RameshV * Removed ScopeId display as new UI does not have this... * Made ReadRegistryIpAddrString read both MULTI_SZ and REG_SZ * Changed domainname and Dns server list from global to per-adapter * Display DhcpServer only if address is NOT autoconfigured.. * AutoconfigEnabled is decided based on regval "AddressType" * Friendly names stubs are used.... * Error codes are converted first thru system library..
06-Mar-98 chunye * Made this a DLL for support IPHLPAPI etc.--*/
#include "precomp.h"
#include "ipcfgmsg.h"
#include <iprtrmib.h>
#include <ws2tcpip.h> // for in6addr_any
#include <ntddip.h>
#include <ntddip6.h>
#include <iphlpstk.h>
#include <nhapi.h>
#include <netconp.h>
//
// manifests
//
#define DEVICE_PREFIX "\\Device\\"
#define TCPIP_DEVICE_PREFIX "\\Device\\Tcpip_"
const CHAR c_szDevice[] = "\\Device\\";const CHAR c_szDeviceTcpip[] = "\\Device\\Tcpip_";const WCHAR c_szDeviceNdiswanIp[] = L"\\Device\\NdiswanIp";
#define INITIAL_CAPABILITY 0x00000001
#define TCPIP_CAPABILITY 0x00000002
#define NETBT_CAPABILITY 0x00000004
#define STRING_ARRAY_DELIMITERS " \t,;"
#define MSG_NO_MESSAGE 0
#define KEY_TCP 1
#define KEY_NBT 2
#define KEY_TCP6 3
#define BNODE BROADCAST_NODETYPE
#define PNODE PEER_TO_PEER_NODETYPE
#define MNODE MIXED_NODETYPE
#define HNODE HYBRID_NODETYPE
#define MAX_FRIENDLY_NAME_LENGTH 80
#ifdef DBG
#define SET_DHCP_MODE 1
#define SET_AUTO_MODE 2
#endif
// ========================================================================
// macros
// ========================================================================
#define REG_OPEN_KEY(_hKey, _lpSubKey, _phkResult) \
RegOpenKeyEx(_hKey, _lpSubKey, 0, KEY_READ, _phkResult)
#define ALIGN_DOWN(length, type) \
((ULONG)(length) & ~(sizeof(type) - 1))
#define ALIGN_UP(length, type) \
(ALIGN_DOWN(((ULONG)(length) + sizeof(type) - 1), type))
#define ALIGN_DOWN_PTR(length, type) \
((ULONG_PTR)(length) & ~(sizeof(type) - 1))
#define ALIGN_UP_PTR(length, type) \
(ALIGN_DOWN_PTR(((ULONG_PTR)(length) + sizeof(type) - 1), type))
// ========================================================================
// types
// ========================================================================
typedef struct { DWORD Message; LPSTR String;} MESSAGE_STRING, *PMESSAGE_STRING;
#define MAX_STRING_LIST_LENGTH 32 // arbitrary
// ========================================================================
// macros
// ========================================================================
// #define IS_ARG(c) (((c) == '-') || ((c) == '/'))
// #define ReleaseMemory(p) LocalFree((HLOCAL)(p))
// #define MAP_YES_NO(i) ((i) ? MISC_MESSAGE(MI_YES) : MISC_MESSAGE(MI_NO))
#define ZERO_IP_ADDRESS(a) !strcmp((a), "0.0.0.0")
// ========================================================================
// prototypes
// ========================================================================
BOOL Initialize(PDWORD);VOID LoadMessages(VOID);VOID LoadMessageTable(PMESSAGE_STRING, UINT);BOOL ConvertOemToUnicode(LPSTR, LPWSTR);
BOOL WriteRegistryDword(HKEY hKey, LPSTR szParameter, DWORD *pdwValue );BOOL WriteRegistryMultiString(HKEY, LPSTR, LPSTR);
staticBOOL OpenAdapterKey(DWORD, const LPSTR, REGSAM, PHKEY);BOOL MyReadRegistryDword(HKEY, LPSTR, LPDWORD);BOOL ReadRegistryString(HKEY, LPSTR, LPSTR, LPDWORD);BOOL ReadRegistryOemString(HKEY, LPWSTR, LPSTR, LPDWORD);BOOL ReadRegistryIpAddrString(HKEY, LPSTR, PIP_ADDR_STRING);BOOL GetDnsServerList(PIP_ADDR_STRING);
LPSTR* GetBoundAdapterList(HKEY);LPSTR MapNodeType(UINT);LPSTR MapNodeTypeEx(UINT);LPSTR MapAdapterType(UINT);LPSTR MapAdapterTypeEx(UINT);LPSTR MapAdapterAddress(PIP_ADAPTER_INFO, LPSTR);LPSTR MapTime(PIP_ADAPTER_INFO, DWORD_PTR);LPSTR MapTimeEx(PPIP_ADAPTER_INFO, DWORD_PTR);LPSTR MapScopeId(PVOID);VOID KillFixedInfo(PFIXED_INFO);VOID KillPerAdapterInfo(PIP_PER_ADAPTER_INFO);VOID KillAdapterAddresses(PIP_ADAPTER_ADDRESSES);
VOID Terminate(VOID);LPVOID GrabMemory(DWORD);VOID DisplayMessage(BOOL, DWORD, ...);
BOOL IsIncluded(DWORD Context, DWORD contextlist[], int len_contextlist);BOOL ReadRegistryList(HKEY Key, LPSTR ParameterName, DWORD NumList[], int *MaxList);
DWORD GetIgmpList(DWORD NTEAddr, DWORD *pIgmpList, PULONG dwOutBufLen);DWORD WINAPI GetIpAddrTable(PMIB_IPADDRTABLE, PULONG, BOOL);
// ========================================================================
// data
// ========================================================================
HKEY TcpipLinkageKey = INVALID_HANDLE_VALUE;HKEY TcpipParametersKey = INVALID_HANDLE_VALUE;HKEY NetbtParametersKey = INVALID_HANDLE_VALUE;HKEY NetbtInterfacesKey = INVALID_HANDLE_VALUE;// PHRLANCONNECTIONNAMEFROMGUIDORPATH HrLanConnectionNameFromGuid = NULL;
// HANDLE hNetMan = NULL;
//
// Note: The following variable caches whether IPv6 was installed and running
// at the time GetAdaptersAddresses() was called. If multiple threads
// are calling GetAdaptersAddresses() during an install/uninstall, its
// value may change. However, this is not really a problem. The set of
// IPv6 DNS server addresses may or may not be present on an interface,
// but this is the same as the behavior of the set of IPv6 addresses, which
// doesn't use this variable.
//
BOOL bIp6DriverInstalled;
#ifdef DBG
UINT uChangeMode = 0;#endif
#define FIELD_JUSTIFICATION_TEXT " "
// ========================================================================
// MESSAGE_STRING arrays - contain internationalizable strings loaded from this
// module. If a load error occurs, we use the English language defaults
// ========================================================================
LPSTR NodeTypesEx[] = { "", "Broadcast", "Peer-Peer", "Mixed", "Hybrid"};
MESSAGE_STRING NodeTypes[] ={ MSG_NO_MESSAGE, TEXT(""), MSG_BNODE, TEXT("Broadcast"), MSG_PNODE, TEXT("Peer-Peer"), MSG_MNODE, TEXT("Mixed"), MSG_HNODE, TEXT("Hybrid")};
#define NUMBER_OF_NODE_TYPES (sizeof(NodeTypes)/sizeof(NodeTypes[0]))
#define FIRST_NODE_TYPE 1
#define LAST_NODE_TYPE 4
LPSTR AdapterTypesEx[] = { "Other", "Ethernet", "Token Ring", "FDDI", "PPP", "Loopback", "SLIP"};
MESSAGE_STRING AdapterTypes[] ={ MSG_IF_TYPE_OTHER, TEXT("Other"), MSG_IF_TYPE_ETHERNET, TEXT("Ethernet"), MSG_IF_TYPE_TOKEN_RING, TEXT("Token Ring"), MSG_IF_TYPE_FDDI, TEXT("FDDI"), MSG_IF_TYPE_PPP, TEXT("PPP"), MSG_IF_TYPE_LOOPBACK, TEXT("Loopback"), MSG_IF_TYPE_SLIP, TEXT("SLIP")};
#define NUMBER_OF_ADAPTER_TYPES (sizeof(AdapterTypes)/sizeof(AdapterTypes[0]))
MESSAGE_STRING MiscMessages[] ={ MSG_YES, TEXT("Yes"), MSG_NO, TEXT("No"), MSG_INIT_FAILED, TEXT("Failed to initialize"), MSG_TCP_NOT_RUNNING, TEXT("TCP/IP is not running on this system"), MSG_REG_BINDINGS_ERROR, TEXT("Cannot access adapter bindings registry key"), MSG_REG_INCONSISTENT_ERROR, TEXT("Inconsistent registry contents"), MSG_TCP_BINDING_ERROR, TEXT("TCP/IP not bound to any adapters"), MSG_MEMORY_ERROR, TEXT("Allocating memory"), MSG_ALL, TEXT("all"), MSG_RELEASE, TEXT("Release"), MSG_RENEW, TEXT("Renew"), MSG_ACCESS_DENIED, TEXT("Access Denied"), MSG_SERVER_UNAVAILABLE, TEXT("DHCP Server Unavailable"), MSG_ADDRESS_CONFLICT, TEXT("The DHCP client obtained an address that is already in use on the network.")};
#define NUMBER_OF_MISC_MESSAGES (sizeof(MiscMessages)/sizeof(MiscMessages[0]))
#define MISC_MESSAGE(i) MiscMessages[i].String
#define ADAPTER_TYPE(i) AdapterTypes[i].String
#define ADAPTER_TYPE_EX(i) AdapterTypesEx[i]
#define MI_IF_OTHER 0
#define MI_IF_ETHERNET 1
#define MI_IF_TOKEN_RING 2
#define MI_IF_FDDI 3
#define MI_IF_PPP 4
#define MI_IF_LOOPBACK 5
#define MI_IF_SLIP 6
#define MI_YES 0
#define MI_NO 1
#define MI_INIT_FAILED 2
#define MI_TCP_NOT_RUNNING 3
#define MI_REG_BINDINGS_ERROR 4
#define MI_REG_INCONSISTENT_ERROR 5
#define MI_TCP_BINDINGS_ERROR 6
#define MI_MEMORY_ERROR 7
#define MI_ALL 8
#define MI_RELEASE 9
#define MI_RENEW 10
#define MI_ACCESS_DENIED 11
#define MI_SERVER_UNAVAILABLE 12
#define MI_ADDRESS_CONFLICT 13
//
// Debugging
//
#if defined(DEBUG)
BOOL Debugging = FALSE;int MyTrace = 0;
#endif
// ========================================================================
// functions
// ========================================================================
BOOLIpcfgdllInit( HINSTANCE hInstDll, DWORD fdwReason, LPVOID pReserved ){
DWORD capability;
switch (fdwReason) {
case DLL_PROCESS_ATTACH:
// DisableThreadLibraryCalls(hInstDll);
//
// load all possible internationalizable strings
//
LoadMessages();
//
// what debug version is this?
//
DEBUG_PRINT(("IpcfgdllInit" __DATE__ " " __TIME__ "\n"));
//
// opens all the required registry keys
//
if (!Initialize(&capability)) {
LPSTR str = NULL;
//
// exit if we couldn't open the registry services key or
// IP or TCP keys.
// We will continue if the NetBT key couldn't be opened
//
if (!(capability & INITIAL_CAPABILITY)) {
str = MISC_MESSAGE(MI_INIT_FAILED);
} else if (!(capability & TCPIP_CAPABILITY)) {
str = MISC_MESSAGE(MI_TCP_NOT_RUNNING);
}
if (str) {
//DisplayMessage(FALSE, MSG_ERROR_STRING, str);
Terminate(); return FALSE;
} }
break;
case DLL_PROCESS_DETACH:
Terminate(); break;
default:
break;
}
return TRUE;}
/*******************************************************************************
* * Initialize * * Opens all the required registry keys * * ENTRY Capability * Pointer to returned set of capabilities (bitmap) * * EXIT *Capability * INITIAL_CAPABILITY * * TCPIP_CAPABILITY * we could open the Tcpip\Linkage and Tcpip\Parameters keys * TcpipLinkageKey and TcpipParametersKey contain the open handles * * NETBT_CAPABILITY * we could open the NetBT\Parameters key * NetbtInterfacesKey contains the open handle * * * RETURNS TRUE = success * FALSE = failure * * ASSUMES * ******************************************************************************/
#define TCPIP_LINKAGE_KEY "SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Linkage"
#define TCPIP_PARAMS_KEY "SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\"
#define TCPIP_PARAMS_INTER_KEY "SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Interfaces\\"
#define TCPIP6_PARAMS_INTER_KEY "SYSTEM\\CurrentControlSet\\Services\\Tcpip6\\Parameters\\Interfaces\\"
#define NETBT_PARAMS_KEY "SYSTEM\\CurrentControlSet\\Services\\NetBT\\Parameters"
#define NETBT_INTERFACE_KEY "SYSTEM\\CurrentControlSet\\Services\\NetBT\\Parameters\\Interfaces"
#define NETBT_ADAPTER_KEY "SYSTEM\\CurrentControlSet\\Services\\NetBT\\Adapters\\"
BOOL Initialize(PDWORD Capability){
LONG err; char * name;
*Capability = INITIAL_CAPABILITY;
name = TCPIP_LINKAGE_KEY; TRACE_PRINT(("Initialize: RegOpenKey TcpipLinkageKey %s\n", name )); err = REG_OPEN_KEY(HKEY_LOCAL_MACHINE, name, &TcpipLinkageKey );
if (err == ERROR_SUCCESS) {
*Capability |= TCPIP_CAPABILITY;
name = TCPIP_PARAMS_KEY; TRACE_PRINT(("Initialize: RegOpenKey TcpipParametersKey %s\n", name )); err = REG_OPEN_KEY(HKEY_LOCAL_MACHINE, name, &TcpipParametersKey );
if (err == ERROR_SUCCESS) {
name = NETBT_INTERFACE_KEY; TRACE_PRINT(("Initialize: RegOpenKey NetbtInterfacesKey %s\n", name )); err = REG_OPEN_KEY(HKEY_LOCAL_MACHINE, name, &NetbtInterfacesKey );
if (err == ERROR_SUCCESS) { *Capability |= NETBT_CAPABILITY; } else { NetbtInterfacesKey = INVALID_HANDLE_VALUE; } } else { *Capability &= ~TCPIP_CAPABILITY; TcpipParametersKey = INVALID_HANDLE_VALUE; } } else { TcpipLinkageKey = INVALID_HANDLE_VALUE; }
// =======================================================
name = NETBT_PARAMS_KEY; TRACE_PRINT(("Initialize: RegOpenKey NetbtParametersKey %s.\n", name )); err = REG_OPEN_KEY(HKEY_LOCAL_MACHINE, name, &NetbtParametersKey ); // ======================================================
if( err != ERROR_SUCCESS ){ DEBUG_PRINT(("Initialize: RegOpenKey %s failed, err=%d\n", name, GetLastError() )); }
TRACE_PRINT(("Initialize RegOpenKey ok: \n" " TcpipLinkageKey = %p\n" " TcpipParametersKey = %p\n" " NetbtInterfacesKey = %p\n" " NetbtParametersKey = %p\n", TcpipLinkageKey, TcpipParametersKey, NetbtInterfacesKey, NetbtParametersKey ));
return err == ERROR_SUCCESS;}
/*******************************************************************************
* * LoadMessages * * Loads all internationalizable messages into the various tables * * ENTRY * * EXIT AdapterTypes, MiscMessages updated * * RETURNS * * ASSUMES * * COHESION Temporal * ******************************************************************************/
VOID LoadMessages(){ LoadMessageTable(NodeTypes, NUMBER_OF_NODE_TYPES); LoadMessageTable(AdapterTypes, NUMBER_OF_ADAPTER_TYPES); LoadMessageTable(MiscMessages, NUMBER_OF_MISC_MESSAGES);}
/*******************************************************************************
* * LoadMessageTable * * Loads internationalizable strings into a table, replacing the default for * each. If an error occurs, the English language default is left in place * * ENTRY Table * Pointer to table containing message ID and pointer to string * * MessageCount * Number of messages in Table * * EXIT Table updated * * RETURNS * * ASSUMES * ******************************************************************************/
VOID LoadMessageTable(PMESSAGE_STRING Table, UINT MessageCount){
LPSTR string; DWORD count;
//
// for all messages in a MESSAGE_STRING table, load the string from this
// module, replacing the default string in the table (only there in case
// we get an error while loading the string, so we at least have English
// to fall back on)
//
while (MessageCount--) { if (Table->Message != MSG_NO_MESSAGE) {
//
// we really want LoadString here, but LoadString doesn't indicate
// how big the string is, so it doesn't give us an opportunity to
// allocate exactly the right buffer size. FormatMessage does the
// right thing
//
count = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_HMODULE, NULL, // use default hModule
Table->Message, 0, // use default language
(LPTSTR)&string, 0, // minimum size to allocate
NULL // no arguments for inclusion in strings
); if (count) {
//
// Format message returned the string: replace the English
// language default
//
Table->String = string; } else {
DEBUG_PRINT(("FormatMessage(%d) failed: %d\n", Table->Message, GetLastError()));
//
// this is ok if there is no string (e.g. just %0) in the .mc
// file
//
Table->String = ""; } } ++Table; }}
/*******************************************************************************
* * ConvertOemToUnicode * * Title says it all. Required because DhcpAcquireParameters etc. require the * adapter name to be UNICODE * * ENTRY OemString * Pointer to ANSI/OEM string to convert * * UnicodeString * Pointer to place to store converted results * * EXIT UnicodeString contains converted string if successful * * RETURNS TRUE - it worked * FALSE - it failed * * ASSUMES * ******************************************************************************/
BOOL ConvertOemToUnicode(LPSTR OemString, LPWSTR UnicodeString){
OEM_STRING oString; UNICODE_STRING uString;
RtlInitString(&oString, OemString); uString.Buffer = UnicodeString; uString.MaximumLength = (USHORT)RtlOemStringToUnicodeSize(&oString); if (NT_SUCCESS(RtlOemStringToUnicodeString(&uString, &oString, FALSE))) { return TRUE; } return FALSE;}
/*******************************************************************************
* * GetFixedInfo * * Retrieves the fixed information we wish to display by querying it from the * various registry keys * * ENTRY nothing * * EXIT nothing * * RETURNS pointer to allocated FIXED_INFO structure * * ASSUMES * ******************************************************************************/
PFIXED_INFO GetFixedInfo(){ PFIXED_INFO fixedInfo = NEW(FIXED_INFO);
TRACE_PRINT(("Entered GetFixedInfo\n"));
if (fixedInfo) {
DWORD length; BOOL ok; HKEY transientKey;
length = sizeof(fixedInfo->HostName); ok = ReadRegistryOemString(TcpipParametersKey, L"Hostname", fixedInfo->HostName, &length );
//
// domain: first try Domain then DhcpDomain
//
length = sizeof(fixedInfo->DomainName); ok = ReadRegistryOemString(TcpipParametersKey, L"Domain", fixedInfo->DomainName, &length ); if (!ok) { length = sizeof(fixedInfo->DomainName); ok = ReadRegistryOemString(TcpipParametersKey, L"DhcpDomain", fixedInfo->DomainName, &length ); }
//
// DNS Server list: first try NameServer and then DhcpNameServer
//
#if 0
ok = ReadRegistryIpAddrString(TcpipParametersKey, TEXT("NameServer"), &fixedInfo->DnsServerList ); if (ok) { TRACE_PRINT(("GetFixedInfo: NameServer %s\n", fixedInfo->DnsServerList )); }
if (!ok) { ok = ReadRegistryIpAddrString(TcpipParametersKey, TEXT("DhcpNameServer"), &fixedInfo->DnsServerList ); if (ok) { TRACE_PRINT(("GetFixedInfo: DhcpNameServer %s\n", fixedInfo->DnsServerList)); } }#else
ok = GetDnsServerList(&fixedInfo->DnsServerList); if (ok) { TRACE_PRINT(("GetFixedInfo: DnsServerList %s\n", fixedInfo->DnsServerList)); }#endif
//
// NodeType: static then DHCP
//
ok = MyReadRegistryDword(NetbtParametersKey, TEXT("NodeType"), &fixedInfo->NodeType ); if (!ok) { ok = MyReadRegistryDword(NetbtParametersKey, TEXT("DhcpNodeType"), &fixedInfo->NodeType ); }
//
// ScopeId: static then DHCP
//
length = sizeof(fixedInfo->ScopeId); ok = ReadRegistryString(NetbtParametersKey, TEXT("ScopeId"), fixedInfo->ScopeId, &length ); if (!ok) { length = sizeof(fixedInfo->ScopeId); ok = ReadRegistryString(NetbtParametersKey, TEXT("DhcpScopeId"), fixedInfo->ScopeId, &length ); } ok = MyReadRegistryDword(TcpipParametersKey, TEXT("IPEnableRouter"), &fixedInfo->EnableRouting ); ok = MyReadRegistryDword(NetbtParametersKey, TEXT("EnableProxy"), &fixedInfo->EnableProxy ); ok = MyReadRegistryDword(NetbtParametersKey, TEXT("EnableDNS"), &fixedInfo->EnableDns ); }else{ DEBUG_PRINT(("No memory for fixedInfo\n")); }
TRACE_PRINT(("Exit GetFixedInfo @ %p\n", fixedInfo ));
return fixedInfo;}
/*******************************************************************************
* * GetAdapterNameToIndexInfo * * Gets the mapping between IP if_index and AdapterName. * * RETURNS pointer to a PIP_INTERFACE_INFO structure that has been allocated. * ******************************************************************************/
PIP_INTERFACE_INFO GetAdapterNameToIndexInfo( VOID ){ PIP_INTERFACE_INFO pInfo; ULONG dwSize, dwError;
dwSize = 0; pInfo = NULL;
while( 1 ) {
dwError = GetInterfaceInfo( pInfo, &dwSize ); if( (ERROR_INSUFFICIENT_BUFFER != dwError) && (ERROR_BUFFER_OVERFLOW != dwError) ) break;
if( NULL != pInfo ) ReleaseMemory(pInfo); if( 0 == dwSize ) return NULL;
pInfo = GrabMemory(dwSize); if( NULL == pInfo ) return NULL;
}
if( ERROR_SUCCESS != dwError || 0 == pInfo->NumAdapters ) { if( NULL != pInfo ) ReleaseMemory(pInfo); return NULL; }
return pInfo;}
/*******************************************************************************
* * GetAdapterInfo * * Gets a list of all adapters to which TCP/IP is bound and reads the per- * adapter information that we want to display. Most of the information now * comes from the TCP/IP stack itself. In order to keep the 'short' names that * exist in the registry to refer to the individual adapters, we read the names * from the registry then match them to the adapters returned by TCP/IP by * matching the IPInterfaceContext value with the adapter which owns the IP * address with that context value * * ENTRY nothing * * EXIT nothing * * RETURNS pointer to linked list of IP_ADAPTER_INFO structures * * ASSUMES * ******************************************************************************/
PIP_ADAPTER_INFO GetAdapterInfo(VOID){
PIP_ADAPTER_INFO adapterList; PIP_ADAPTER_INFO adapter; PIP_INTERFACE_INFO currentAdapterNames; LPSTR name; int i;
HKEY key;
TRACE_PRINT(("Entered GetAdapterInfo\n"));
if (currentAdapterNames = GetAdapterNameToIndexInfo()) { if (adapterList = GetAdapterList()) {
//
// apply the short name to the right adapter info by comparing
// the IPInterfaceContext value in the adapter\Parameters\Tcpip
// section with the context values read from the stack for the
// IP addresses
//
for (i = 0; i < currentAdapterNames->NumAdapters; ++i) { ULONG dwLength; DWORD dwIfIndex = currentAdapterNames->Adapter[i].Index;
TRACE_PRINT(("currentAdapterNames[%d]=%ws (if_index 0x%lx)\n", i, currentAdapterNames->Adapter[i].Name, dwIfIndex ));
//
// now search through the list of adapters, looking for the one
// that has the IP address with the same index value as that
// just read. When found, apply the short name to that adapter
//
for (adapter = adapterList; adapter ; adapter = adapter->Next ) {
if( adapter->Index == dwIfIndex ) {
dwLength = wcslen(currentAdapterNames->Adapter[i].Name) + 1 - strlen(TCPIP_DEVICE_PREFIX); dwLength = wcstombs(adapter->AdapterName, currentAdapterNames->Adapter[i].Name + strlen(TCPIP_DEVICE_PREFIX), dwLength); if( -1 == dwLength ) { adapter->AdapterName[0] = '\0'; }
break; }
} } } else { DEBUG_PRINT(("GetAdapterInfo: GetAdapterInfo gave NULL\n")); } ReleaseMemory(currentAdapterNames);
//
// now get the other pieces of info from the registry for each adapter
//
for (adapter = adapterList; adapter; adapter = adapter->Next) {
TRACE_PRINT(("GetAdapterInfo: '%s'\n", adapter->AdapterName ));
if (adapter->AdapterName[0] && OpenAdapterKey(KEY_TCP, adapter->AdapterName, KEY_READ, &key)) {
char dhcpServerAddress[4 * 4]; DWORD addressLength; ULONG length; BOOL ok;
MyReadRegistryDword(key, TEXT("EnableDHCP"), &adapter->DhcpEnabled );
TRACE_PRINT(("..'EnableDHCP' %d\n", adapter->DhcpEnabled ));
#ifdef DBG
if ( uChangeMode ) { DWORD dwAutoconfigEnabled = ( uChangeMode == SET_AUTO_MODE );
WriteRegistryDword( key, "IPAutoconfigurationEnabled", &dwAutoconfigEnabled ); }#endif
if (adapter->DhcpEnabled) { DWORD Temp; MyReadRegistryDword(key, TEXT("LeaseObtainedTime"), &Temp );
adapter->LeaseObtained = Temp;
MyReadRegistryDword(key, TEXT("LeaseTerminatesTime"), &Temp );
adapter->LeaseExpires = Temp; }
addressLength = sizeof( dhcpServerAddress ); if (ReadRegistryString(key, TEXT("DhcpServer"), dhcpServerAddress, &addressLength )) { AddIpAddressString(&adapter->DhcpServer, dhcpServerAddress, "" ); }
RegCloseKey(key);
} else {
DEBUG_PRINT(("Cannot OpenAdapterKey KEY_TCP '%s', gle=%d\n", adapter->AdapterName, GetLastError())); }
//
// get the info from the NetBT key - the WINS addresses
//
GetWinsServers(adapter); }
} else {
DEBUG_PRINT(("GetAdapterInfo: GetBoundAdapterList gave NULL\n")); adapterList = NULL; }
TRACE_PRINT(("Exit GetAdapterInfo %p\n", adapterList));
return adapterList;}
/*******************************************************************************
* AddIPv6UnicastAddressInfo * * This routine adds an IP_ADAPTER_UNICAST_ADDRESS entry for an IPv6 address * to a list of entries. * * ENTRY IF - IPv6 interface information * ADE - IPv6 address entry * ppNext - Previous unicast entry's "next" pointer to update * * EXIT Entry added and args updated * * RETURNS Error status * ******************************************************************************/
DWORD AddIPv6UnicastAddressInfo(IPV6_INFO_INTERFACE *IF, IPV6_INFO_ADDRESS *ADE, PIP_ADAPTER_UNICAST_ADDRESS **ppNext){ DWORD dwErr = NO_ERROR; PIP_ADAPTER_UNICAST_ADDRESS pCurr; SOCKADDR_IN6 *pAddr;
ASSERT(ADE->Type == ADE_UNICAST);
pCurr = MALLOC(sizeof(IP_ADAPTER_UNICAST_ADDRESS)); if (!pCurr) { return ERROR_NOT_ENOUGH_MEMORY; }
pAddr = MALLOC(sizeof(SOCKADDR_IN6)); if (!pAddr) { FREE(pCurr); return ERROR_NOT_ENOUGH_MEMORY; }
memset(pAddr, 0, sizeof(SOCKADDR_IN6)); pAddr->sin6_family = AF_INET6; pAddr->sin6_scope_id = ADE->ScopeId; memcpy(&pAddr->sin6_addr, &ADE->This.Address, sizeof(ADE->This.Address));
// Add address to linked list
**ppNext = pCurr; *ppNext = &pCurr->Next;
pCurr->Next = NULL; pCurr->Length = sizeof(IP_ADAPTER_UNICAST_ADDRESS); pCurr->ValidLifetime = ADE->ValidLifetime; pCurr->PreferredLifetime = ADE->PreferredLifetime; pCurr->LeaseLifetime = 0xFFFFFFFF; pCurr->Flags = 0; pCurr->Address.iSockaddrLength = sizeof(SOCKADDR_IN6); pCurr->Address.lpSockaddr = (LPSOCKADDR)pAddr; pCurr->PrefixOrigin = ADE->PrefixConf; pCurr->SuffixOrigin = ADE->InterfaceIdConf; pCurr->DadState = ADE->DADState;
// Only use DDNS on auto-configured addresses
// (either auto-configured by the system or from an RA)
// but NOT anonymous addresses.
// Also do not use DDNS on link-local addresses
// or the loopback address.
if ((ADE->DADState == DAD_STATE_PREFERRED) && (pCurr->SuffixOrigin != IpSuffixOriginRandom) && !IN6_IS_ADDR_LOOPBACK(&ADE->This.Address) && !IN6_IS_ADDR_LINKLOCAL(&ADE->This.Address)) { pCurr->Flags |= IP_ADAPTER_ADDRESS_DNS_ELIGIBLE; }
return dwErr;}
/*******************************************************************************
* AddIPv6AnycastAddressInfo * * This routine adds an IP_ADAPTER_ANYCAST_ADDRESS entry for an IPv6 address * to a list of entries. * * ENTRY IF - IPv6 interface information * ADE - IPv6 address entry * ppNext - Previous anycast entry's "next" pointer to update * * EXIT Entry added and args updated * * RETURNS Error status * ******************************************************************************/
DWORD AddIPv6AnycastAddressInfo(IPV6_INFO_INTERFACE *IF, IPV6_INFO_ADDRESS *ADE, PIP_ADAPTER_ANYCAST_ADDRESS **ppNext){ DWORD dwErr = NO_ERROR; PIP_ADAPTER_ANYCAST_ADDRESS pCurr; SOCKADDR_IN6 *pAddr;
ASSERT(ADE->Type == ADE_ANYCAST);
pCurr = MALLOC(sizeof(IP_ADAPTER_ANYCAST_ADDRESS)); if (!pCurr) { return ERROR_NOT_ENOUGH_MEMORY; }
pAddr = MALLOC(sizeof(SOCKADDR_IN6)); if (!pAddr) { FREE(pCurr); return ERROR_NOT_ENOUGH_MEMORY; }
memset(pAddr, 0, sizeof(SOCKADDR_IN6)); pAddr->sin6_family = AF_INET6; pAddr->sin6_scope_id = ADE->ScopeId; memcpy(&pAddr->sin6_addr, &ADE->This.Address, sizeof(ADE->This.Address));
// Add address to linked list
**ppNext = pCurr; *ppNext = &pCurr->Next;
pCurr->Next = NULL; pCurr->Length = sizeof(IP_ADAPTER_ANYCAST_ADDRESS); pCurr->Flags = 0; pCurr->Address.iSockaddrLength = sizeof(SOCKADDR_IN6); pCurr->Address.lpSockaddr = (LPSOCKADDR)pAddr;
return dwErr;}
/*******************************************************************************
* AddIPv6MulticastAddressInfo * * This routine adds an IP_ADAPTER_MULTICAST_ADDRESS entry for an IPv6 address * to a list of entries. * * ENTRY IF - IPv6 interface information * ADE - IPv6 address entry * ppNext - Previous multicast entry's "next" pointer to update * * EXIT Entry added and args updated * * RETURNS Error status * ******************************************************************************/
DWORD AddIPv6MulticastAddressInfo(IPV6_INFO_INTERFACE *IF, IPV6_INFO_ADDRESS *ADE, PIP_ADAPTER_MULTICAST_ADDRESS **ppNext){ DWORD dwErr = NO_ERROR; PIP_ADAPTER_MULTICAST_ADDRESS pCurr; SOCKADDR_IN6 *pAddr;
ASSERT(ADE->Type == ADE_MULTICAST);
pCurr = MALLOC(sizeof(IP_ADAPTER_MULTICAST_ADDRESS)); if (!pCurr) { return ERROR_NOT_ENOUGH_MEMORY; }
pAddr = MALLOC(sizeof(SOCKADDR_IN6)); if (!pAddr) { FREE(pCurr); return ERROR_NOT_ENOUGH_MEMORY; }
memset(pAddr, 0, sizeof(SOCKADDR_IN6)); pAddr->sin6_family = AF_INET6; pAddr->sin6_scope_id = ADE->ScopeId; memcpy(&pAddr->sin6_addr, &ADE->This.Address, sizeof(ADE->This.Address));
// Add address to linked list
**ppNext = pCurr; *ppNext = &pCurr->Next;
pCurr->Next = NULL; pCurr->Length = sizeof(IP_ADAPTER_MULTICAST_ADDRESS); pCurr->Flags = 0; pCurr->Address.iSockaddrLength = sizeof(SOCKADDR_IN6); pCurr->Address.lpSockaddr = (LPSOCKADDR)pAddr;
return dwErr;}
/*******************************************************************************
* AddIPv6AddressInfo * * This routine adds an IP_ADAPTER_UNICAST_ADDRESS entry for an IPv6 address * to a list of entries. * * ENTRY IF - IPv6 interface information * ADE - IPv6 address entry * arg1 - Previous unicast entry's "next" pointer to update * arg2 - Previous anycast entry's "next" pointer to update * arg3 - Previous multicast entry's "next" pointer to update * Flags - Flags specified by application * Family - Address family constraint (for DNS server addresses) * * EXIT Entry added and args updated * * RETURNS Error status * ******************************************************************************/
DWORD AddIPv6AddressInfo(IPV6_INFO_INTERFACE *IF, IPV6_INFO_ADDRESS *ADE, PVOID arg1, PVOID arg2, PVOID arg3, DWORD Flags, DWORD Family){ switch (ADE->Type) { case ADE_UNICAST: if (Flags & GAA_FLAG_SKIP_UNICAST) { return NO_ERROR; } return AddIPv6UnicastAddressInfo(IF, ADE, (PIP_ADAPTER_UNICAST_ADDRESS**)arg1); case ADE_ANYCAST: if (Flags & GAA_FLAG_SKIP_ANYCAST) { return NO_ERROR; } return AddIPv6AnycastAddressInfo(IF, ADE, (PIP_ADAPTER_ANYCAST_ADDRESS**)arg2); case ADE_MULTICAST: if (Flags & GAA_FLAG_SKIP_MULTICAST) { return NO_ERROR; } return AddIPv6MulticastAddressInfo(IF, ADE, (PIP_ADAPTER_MULTICAST_ADDRESS**)arg3); default: ASSERT(0); } return NO_ERROR;}
/*******************************************************************************
* ForEachIPv6Address * * This routine walks a set of IPv6 addresses and invokes a given function * on each one. * * ENTRY IF - IPv6 interface information * func - Function to invoke on each address * arg1 - Argument to pass to func * arg2 - Argument to pass to func * arg3 - Argument to pass to func * Flags - Flags to pass to func * Family - Address family constraint (for DNS server addresses) * * EXIT Nothing * * RETURNS Error status * ******************************************************************************/
DWORD ForEachIPv6Address(IPV6_INFO_INTERFACE *IF, DWORD (*func)(IPV6_INFO_INTERFACE *,IPV6_INFO_ADDRESS *, PVOID, PVOID, PVOID, DWORD, DWORD), PVOID arg1, PVOID arg2, PVOID arg3, DWORD Flags, DWORD Family){ IPV6_QUERY_ADDRESS Query; IPV6_INFO_ADDRESS ADE; u_int BytesReturned, BytesIn; DWORD dwErr;
Query.IF = IF->This; Query.Address = in6addr_any;
for (;;) { BytesIn = sizeof Query; BytesReturned = sizeof ADE;
dwErr = WsControl( IPPROTO_IPV6, IOCTL_IPV6_QUERY_ADDRESS, &Query, &BytesIn, &ADE, &BytesReturned);
if (dwErr != NO_ERROR) { return dwErr; }
if (!IN6_ADDR_EQUAL(&Query.Address, &in6addr_any)) {
dwErr = (*func)(IF, &ADE, arg1, arg2, arg3, Flags, Family); if (dwErr != NO_ERROR) { return dwErr; } }
if (IN6_ADDR_EQUAL(&ADE.Next.Address, &in6addr_any)) break; Query = ADE.Next; }
return NO_ERROR;}
/*******************************************************************************
* MapIpv4AddressToName * * This routine finds the name and description of the adapter which * has a given IPv4 address on it. * * ENTRY pAdapterInfo - Buffer obtained from GetAdaptersInfo * Ipv4Address - IPv4 address to search for * pDescription - Where to place a pointer to the description text * * EXIT pDescription updated, if found * * RETURNS Adapter name, or NULL if not found * ******************************************************************************/
LPSTRMapIpv4AddressToName(IP_ADAPTER_INFO *pAdapterInfo, DWORD Ipv4Address, PCHAR *pDescription){ IP_ADAPTER_INFO *pAdapter; IP_ADDR_STRING *pAddr;
for (pAdapter = pAdapterInfo; pAdapter != NULL; pAdapter = pAdapter->Next) {
for (pAddr = &pAdapter->IpAddressList; pAddr; pAddr=pAddr->Next) { if (inet_addr(pAddr->IpAddress.String) == Ipv4Address) { *pDescription = pAdapter->Description; return pAdapter->AdapterName; } } }
return NULL;}
#define GUID_FORMAT_A "{%08lX-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}"
/*******************************************************************************
* ConvertGuidToStringA * * This routine converts a GUID to a character string. * * ENTRY pGuid - Contains the GUID to translate. * pszBuffer - Space for storing the string. * Must be >= 39 * sizeof(CHAR). * * EXIT pszBuffer updated * * RETURNS Whatever sprintf returns * ******************************************************************************/
DWORDConvertGuidToStringA(GUID *pGuid, PCHAR pszBuffer){ return sprintf(pszBuffer, GUID_FORMAT_A, pGuid->Data1, pGuid->Data2, pGuid->Data3, pGuid->Data4[0], pGuid->Data4[1], pGuid->Data4[2], pGuid->Data4[3], pGuid->Data4[4], pGuid->Data4[5], pGuid->Data4[6], pGuid->Data4[7]);}
/*******************************************************************************
* ConvertStringToGuidA * * This routine converts a character string to a GUID. * * ENTRY pszGuid - Contains the string to translate * pGuid - Space for storing the GUID * * EXIT pGuid updated * * RETURNS Error status * ******************************************************************************/
DWORDConvertStringToGuidA(PCHAR pszGuid, GUID *pGuid){ UNICODE_STRING Temp; WCHAR wszGuid[40+1];
MultiByteToWideChar(CP_ACP, 0, pszGuid, -1, wszGuid, 40);
RtlInitUnicodeString(&Temp, wszGuid); if(RtlGUIDFromString(&Temp, pGuid) != STATUS_SUCCESS) { return ERROR_INVALID_PARAMETER; }
return NO_ERROR;}
/*******************************************************************************
* MapGuidToAdapterName * * This routine gets an adapter name and description, given a GUID. * * ENTRY pAdapterInfo - Buffer obtained from GetAdaptersInfo * Guid - GUID of the adapter * pwszDescription - Buffer in which to place description text. * Must be at least MAX_ADAPTER_DESCRIPTION_LENGTH * WCHAR's long. * * EXIT pwszDescription buffer filled in, if found * * RETURNS Adapter name, or NULL if not found * ******************************************************************************/
LPSTRMapGuidToAdapterName(IP_ADAPTER_INFO *pAdapterInfo, GUID *Guid, PWCHAR pwszDescription){ IP_ADAPTER_INFO *pAdapter; CHAR szGuid[40];
ConvertGuidToStringA(Guid, szGuid);
for (pAdapter = pAdapterInfo; pAdapter != NULL; pAdapter = pAdapter->Next) {
if (!strcmp(szGuid, pAdapter->AdapterName)) { MultiByteToWideChar(CP_ACP, 0, pAdapter->Description, -1, pwszDescription, MAX_ADAPTER_DESCRIPTION_LENGTH); return pAdapter->AdapterName; } }
pwszDescription[0] = L'\0'; return NULL;}
/*******************************************************************************
* AddDnsServerAddressInfo * * This routine adds an IP_ADAPTER_DNS_SERVER_ADDRESS entry for an address * to a list of entries. * * ENTRY IF - interface information * Addr - Address in sockaddr format * AddrLen- Size of sockaddr * pFirst - First DNS server entry * ppNext - Previous DNS server entry's "next" pointer to update * * EXIT Entry added and args updated * * RETURNS Error status * ******************************************************************************/
DWORD AddDnsServerAddressInfo(PIP_ADAPTER_DNS_SERVER_ADDRESS **ppNext, LPSOCKADDR Addr, ULONG AddrLen){ DWORD dwErr = NO_ERROR; PIP_ADAPTER_DNS_SERVER_ADDRESS pCurr; LPSOCKADDR pAddr;
pCurr = MALLOC(sizeof(IP_ADAPTER_DNS_SERVER_ADDRESS)); if (!pCurr) { return ERROR_NOT_ENOUGH_MEMORY; }
pAddr = MALLOC(AddrLen); if (!pAddr) { FREE(pCurr); return ERROR_NOT_ENOUGH_MEMORY; }
memcpy(pAddr, Addr, AddrLen);
// Add address to linked list
**ppNext = pCurr; *ppNext = &pCurr->Next;
pCurr->Next = NULL; pCurr->Length = sizeof(IP_ADAPTER_DNS_SERVER_ADDRESS); pCurr->Address.iSockaddrLength = AddrLen; pCurr->Address.lpSockaddr = (LPSOCKADDR)pAddr;
return dwErr;}
/*******************************************************************************
* GetAdapterDnsServers * * This routine reads a list of DNS server addresses from a registry key. * * ENTRY TcpipKey - Registry key to look under * pCurr - Interface entry to add servers to * * EXIT Entry updated * * RETURNS Error status * ******************************************************************************/
DWORDGetAdapterDnsServers(HKEY TcpipKey, PIP_ADAPTER_ADDRESSES pCurr){ DWORD Size, Type, dwErr, i; CHAR Servers[800], *Str; PIP_ADAPTER_DNS_SERVER_ADDRESS pD, *ppDNext; ADDRINFO hints, *ai; static LONG Initialized = FALSE;
if (InterlockedExchange(&Initialized, TRUE) == FALSE) { WSADATA WsaData;
dwErr = WSAStartup(MAKEWORD(2, 0), &WsaData); if (NO_ERROR != dwErr) { return dwErr; } }
//
// Read DNS Server addresses.
//
Size = sizeof(Servers); ZeroMemory(Servers, Size); dwErr = RegQueryValueExA(TcpipKey, (LPSTR)"NameServer", NULL, &Type, (LPBYTE)Servers, &Size); if (NO_ERROR != dwErr) { if (ERROR_FILE_NOT_FOUND != dwErr) { return dwErr; } Size = 0; Type = REG_SZ; }
if (REG_SZ != Type) { return ERROR_INVALID_DATA; } if ((0 == Size) || (0 == strlen(Servers))) { Size = sizeof(Servers); dwErr = RegQueryValueExA(TcpipKey, (LPSTR)"DhcpNameServer", NULL, &Type, (LPBYTE)Servers, &Size); if (NO_ERROR != dwErr) { if (ERROR_FILE_NOT_FOUND != dwErr) { return dwErr; } Size = 0; Type = REG_SZ; } }
//
// If there are any DNS Servers, convert them to sockaddrs
//
ZeroMemory(&hints, sizeof(hints)); hints.ai_flags = AI_NUMERICHOST; ppDNext = &pCurr->FirstDnsServerAddress; while (*ppDNext) { ppDNext = &(*ppDNext)->Next; } if ((0 != Size) && strlen(Servers)) { for (i = 0; i < Size; i ++) { if (Servers[i] == ' ' || Servers[i] == ',' || Servers[i] == ';') { Servers[i] = '\0'; } } Servers[Size] = '\0';
for (Str = (LPSTR)Servers; *Str != '\0'; Str += strlen(Str) + 1) { if (getaddrinfo(Str, NULL, &hints, &ai) == NO_ERROR) { AddDnsServerAddressInfo(&ppDNext, ai->ai_addr, ai->ai_addrlen); } } }
return NO_ERROR;}
/*******************************************************************************
* GetAdapterDnsInfo * * This routine reads DNS configuration information for an interface. * * ENTRY dwFamily - Address family constraint * name - Adapter name * pCurr - Interface entry to update * AppFlags - Flags controlling what fields to skip, if any * * EXIT Entry updated * * RETURNS Error status * ******************************************************************************/
DWORDGetAdapterDnsInfo(DWORD dwFamily, char *name, PIP_ADAPTER_ADDRESSES pCurr, DWORD AppFlags){ WCHAR Buffer[MAX_DOMAIN_NAME_LEN+1]; DWORD dwErr = NO_ERROR, Size, Type, Value; DWORD DnsSuffixSize = sizeof(Buffer); HKEY TcpipKey = NULL; PIP_ADAPTER_DNS_SERVER_ADDRESS DnsServerAddr; LPSOCKADDR_IN6 Sockaddr;
Buffer[0] = L'\0'; pCurr->DnsSuffix = NULL; pCurr->Flags = IP_ADAPTER_DDNS_ENABLED;
if (name == NULL) { //
// If we couldn't find an adapter name, just use the default settings.
//
goto Done; }
do { if (!OpenAdapterKey(KEY_TCP, name, KEY_READ, &TcpipKey)) { dwErr = ERROR_CAN_NOT_COMPLETE; break; }
//
// Get DnsSuffix for the interface
//
Size = DnsSuffixSize; dwErr = RegQueryValueExW(TcpipKey, (LPWSTR)L"Domain", NULL, &Type, (LPBYTE)Buffer, &Size ); if (NO_ERROR != dwErr) { if (ERROR_FILE_NOT_FOUND != dwErr) { break; }
Size = 0; Type = REG_SZ; }
if (REG_SZ != Type) { dwErr = ERROR_INVALID_DATA; break; } if ((0 == Size) || (0 == wcslen(Buffer))) { Size = DnsSuffixSize; dwErr = RegQueryValueExW(TcpipKey, (LPWSTR)L"DhcpDomain", NULL, &Type, (LPBYTE)Buffer, &Size ); if (NO_ERROR != dwErr) { if (ERROR_FILE_NOT_FOUND != dwErr) { break; }
Size = 0; Buffer[0] = L'\0'; } }
if (MyReadRegistryDword(TcpipKey, "RegistrationEnabled", &Value) && (Value == 0)) { pCurr->Flags &= ~IP_ADAPTER_DDNS_ENABLED; } if (MyReadRegistryDword(TcpipKey, "RegisterAdapterName", &Value) && Value) { pCurr->Flags |= IP_ADAPTER_REGISTER_ADAPTER_SUFFIX; }
//
// Now attempt to read the DnsServers list
//
if (!(AppFlags & GAA_FLAG_SKIP_DNS_SERVER)) { if ((dwFamily != AF_INET) && bIp6DriverInstalled) { //
// First look for IPv6 servers.
//
HKEY Tcpip6Key = NULL; if (OpenAdapterKey(KEY_TCP6, name, KEY_READ, &Tcpip6Key)) { GetAdapterDnsServers(Tcpip6Key, pCurr); RegCloseKey(Tcpip6Key); } if (pCurr->FirstDnsServerAddress == NULL) { //
// None are configured, so use the default list of
// well-known addresses.
//
SOCKADDR_IN6 Addr; PIP_ADAPTER_DNS_SERVER_ADDRESS *ppDNext; BYTE i; ZeroMemory(&Addr, sizeof(Addr)); Addr.sin6_family = AF_INET6; Addr.sin6_addr.s6_words[0] = 0xC0FE; Addr.sin6_addr.s6_words[3] = 0xFFFF; ppDNext = &pCurr->FirstDnsServerAddress; while (*ppDNext) { ppDNext = &(*ppDNext)->Next; } for (i=1; i<=3; i++) { Addr.sin6_addr.s6_bytes[15] = i; AddDnsServerAddressInfo(&ppDNext, (LPSOCKADDR)&Addr, sizeof(Addr)); } } // Now we need to go through any non-global IPv6 DNS server
// addresses and fill in the scope id.
for (DnsServerAddr = pCurr->FirstDnsServerAddress; DnsServerAddr; DnsServerAddr = DnsServerAddr->Next) { if (DnsServerAddr->Address.lpSockaddr->sa_family != AF_INET6) continue; Sockaddr = (LPSOCKADDR_IN6)DnsServerAddr->Address.lpSockaddr; if (IN6_IS_ADDR_LINKLOCAL(&Sockaddr->sin6_addr)) Sockaddr->sin6_scope_id = pCurr->ZoneIndices[ADE_LINK_LOCAL]; else if (IN6_IS_ADDR_SITELOCAL(&Sockaddr->sin6_addr)) Sockaddr->sin6_scope_id = pCurr->ZoneIndices[ADE_SITE_LOCAL]; } }
if (dwFamily != AF_INET6) { //
// Finally, add IPv4 servers.
//
GetAdapterDnsServers(TcpipKey, pCurr); } }
} while (FALSE);
if (TcpipKey) { RegCloseKey(TcpipKey); }
Done: pCurr->DnsSuffix = MALLOC((wcslen(Buffer)+1) * sizeof(WCHAR)); if (pCurr->DnsSuffix) { wcscpy(pCurr->DnsSuffix, Buffer); }
return dwErr;}
/*******************************************************************************
* NewIpAdapter * * This routine allocates an IP_ADAPTER_ADDRESSES entry and appends it to * a list of such entries. * * ENTRY ppCurr - Location in which to return new entry * ppNext - Previous entry's "next" pointer to update * name - Adapter name * Ipv4IfIndex - IPv4 Interface index * Ipv6IfIndex - IPv6 Interface index * AppFlags - Flags controlling what fields to skip, if any * IfType - IANA ifType value * Mtu - Maximum transmission unit * PhysAddr - MAC address * PhysAddrLen - Byte count of PhysAddr * Description - Adapter description * FriendlyName - User-friendly interface name * Family - Address family constraint for DNS servers * * EXIT ppCurr and ppNext updated * * RETURNS Error status * ******************************************************************************/
DWORD NewIpAdapter(PIP_ADAPTER_ADDRESSES *ppCurr, PIP_ADAPTER_ADDRESSES **ppNext, char *AdapterName, char *NameForDnsInfo, UINT Ipv4IfIndex, UINT Ipv6IfIndex, DWORD AppFlags, DWORD IfType, SIZE_T Mtu, BYTE *PhysAddr, DWORD PhysAddrLen, PWCHAR Description, PWCHAR FriendlyName, DWORD *ZoneIndices, DWORD Family){ DWORD i;
*ppCurr = MALLOC(sizeof(IP_ADAPTER_ADDRESSES)); if (!*ppCurr) { return ERROR_NOT_ENOUGH_MEMORY; } ZeroMemory(*ppCurr, sizeof(IP_ADAPTER_ADDRESSES)); (*ppCurr)->AdapterName = MALLOC(strlen(AdapterName)+1); if (!(*ppCurr)->AdapterName) { goto Fail; } (*ppCurr)->Description = MALLOC((wcslen(Description)+1) * sizeof(WCHAR)); if (!(*ppCurr)->Description) { goto Fail; } (*ppCurr)->FriendlyName = MALLOC((wcslen(FriendlyName)+1) * sizeof(WCHAR)); if (!(*ppCurr)->FriendlyName) { goto Fail; }
(*ppCurr)->Next = NULL; (*ppCurr)->Length = sizeof(IP_ADAPTER_ADDRESSES); strcpy((*ppCurr)->AdapterName, AdapterName); (*ppCurr)->IfIndex = Ipv4IfIndex; (*ppCurr)->Ipv6IfIndex = Ipv6IfIndex; (*ppCurr)->FirstUnicastAddress = NULL; (*ppCurr)->FirstAnycastAddress = NULL; (*ppCurr)->FirstMulticastAddress = NULL; (*ppCurr)->FirstDnsServerAddress = NULL; (*ppCurr)->OperStatus = IfOperStatusUp;
CopyMemory((*ppCurr)->ZoneIndices, ZoneIndices, ADE_GLOBAL * sizeof(DWORD)); (*ppCurr)->ZoneIndices[ADE_GLOBAL] = 0; (*ppCurr)->ZoneIndices[ADE_LARGEST_SCOPE] = 0;
//(*ppCurr)->Mtu = Mtu; "dword should be enough for MTU"
(*ppCurr)->Mtu = (DWORD)Mtu;
(*ppCurr)->IfType = IfType; (*ppCurr)->PhysicalAddressLength = PhysAddrLen; memcpy((*ppCurr)->PhysicalAddress, PhysAddr, PhysAddrLen); wcscpy((*ppCurr)->Description, Description); wcscpy((*ppCurr)->FriendlyName, FriendlyName);
GetAdapterDnsInfo(Family, (NameForDnsInfo != NULL)? NameForDnsInfo : AdapterName, *ppCurr, AppFlags); if ((*ppCurr)->DnsSuffix == NULL) { goto Fail; }
**ppNext = *ppCurr; *ppNext = &(*ppCurr)->Next;
return NO_ERROR;
Fail: if ((*ppCurr)->AdapterName) { FREE((*ppCurr)->AdapterName); } if ((*ppCurr)->FriendlyName) { FREE((*ppCurr)->FriendlyName); } if ((*ppCurr)->Description) { FREE((*ppCurr)->Description); } FREE(*ppCurr); return ERROR_NOT_ENOUGH_MEMORY;}
/*******************************************************************************
* FindOrCreateIpAdapter * * This routine finds an existing IP_ADAPTER_ADDRESSES entry (if any), or * creates a new one and appends it to a list of such entries. * * ENTRY pFirst - Pointer to start of list to search * ppCurr - Location in which to return new entry * ppNext - Previous entry's "next" pointer to update * name - Adapter name * Ipv4IfIndex - IPv4 Interface index * Ipv6IfIndex - IPv6 Interface index * AppFlags - Flags controlling what fields to skip, if any * IfType - IANA ifType value * Mtu - Maximum transmission unit * PhysAddr - MAC address * PhysAddrLen - Byte count of PhysAddr * Description - Adapter description * FriendlyName - User-friendly interface name * Family - Address family constraint (for DNS servers) * * EXIT ppCurr and ppNext updated * * RETURNS Error status * ******************************************************************************/
DWORD FindOrCreateIpAdapter(PIP_ADAPTER_ADDRESSES pFirst, PIP_ADAPTER_ADDRESSES *ppCurr, PIP_ADAPTER_ADDRESSES **ppNext, char *AdapterName, char *NameForDnsInfo, UINT Ipv4IfIndex, UINT Ipv6IfIndex, DWORD AppFlags, DWORD IfType, SIZE_T Mtu, BYTE *PhysAddr, DWORD PhysAddrLen, PWCHAR Description, PWCHAR FriendlyName, DWORD *ZoneIndices, DWORD Family){ PIP_ADAPTER_ADDRESSES pIf; DWORD dwErr;
// Look for an existing entry for the GUID.
for (pIf = pFirst; pIf; pIf = pIf->Next) { if (!strcmp(AdapterName, pIf->AdapterName)) { if (Ipv4IfIndex != 0) { ASSERT(pIf->IfIndex == 0); pIf->IfIndex = Ipv4IfIndex; } if (Ipv6IfIndex != 0) { ASSERT(pIf->Ipv6IfIndex == 0); pIf->Ipv6IfIndex = Ipv6IfIndex;
CopyMemory(pIf->ZoneIndices, ZoneIndices, ADE_GLOBAL * sizeof(DWORD)); } *ppCurr = pIf; return NO_ERROR; } }
return NewIpAdapter(ppCurr, ppNext, AdapterName, NameForDnsInfo, Ipv4IfIndex, Ipv6IfIndex, AppFlags, IfType, Mtu, PhysAddr, PhysAddrLen, Description, FriendlyName, ZoneIndices, Family);}
__inline int IN6_IS_ADDR_6TO4(const struct in6_addr *a){ return ((a->s6_bytes[0] == 0x20) && (a->s6_bytes[1] == 0x02));}
__inline int IN6_IS_ADDR_ISATAP(const struct in6_addr *a){ return (((a->s6_words[4] & 0xfffd) == 0) && (a->s6_words[5] == 0xfe5e));}
//
// This array is used to convert from an internal IPv6 interface type value,
// as defined in ntddip6.h, to an IANA ifType value as defined in ipifcons.h.
//
DWORDIPv6ToMibIfType[] = { IF_TYPE_SOFTWARE_LOOPBACK, IF_TYPE_ETHERNET_CSMACD, IF_TYPE_FDDI, IF_TYPE_TUNNEL, IF_TYPE_TUNNEL, IF_TYPE_TUNNEL, IF_TYPE_TUNNEL, IF_TYPE_TUNNEL};#define NUM_IPV6_IFTYPES (sizeof(IPv6ToMibIfType)/sizeof(DWORD))
/*******************************************************************************
* AddIPv6Prefix * * This routine adds an IP_ADAPTER_PREFIX entry for an IPv6 prefix * to a list of entries. * * ENTRY Addr - IPv6 prefix (network byte order) * MaskLen - IPv6 prefix length * arg1 - Initial prefix entry, for duplicate avoidance * arg2 - Previous prefix entry's "next" pointer to update * * EXIT Entry added and arg2 updated * * RETURNS Error status * ******************************************************************************/
DWORD AddIPv6Prefix(IN6_ADDR *Addr, DWORD MaskLen, PVOID arg1, PVOID arg2){ PIP_ADAPTER_PREFIX pFirst = *(PIP_ADAPTER_PREFIX*)arg1; PIP_ADAPTER_PREFIX **ppNext = (PIP_ADAPTER_PREFIX**)arg2; PIP_ADAPTER_PREFIX pCurr; LPSOCKADDR_IN6 pAddr;
// Check if already in the list
for (pCurr = pFirst; pCurr; pCurr = pCurr->Next) { if ((pCurr->PrefixLength == MaskLen) && (pCurr->Address.lpSockaddr->sa_family == AF_INET6) && IN6_ADDR_EQUAL(&((LPSOCKADDR_IN6)pCurr->Address.lpSockaddr)->sin6_addr, Addr)) { return NO_ERROR; } }
pCurr = MALLOC(sizeof(IP_ADAPTER_PREFIX)); if (!pCurr) { return ERROR_NOT_ENOUGH_MEMORY; }
pAddr = MALLOC(sizeof(SOCKADDR_IN6)); if (!pAddr) { FREE(pCurr); return ERROR_NOT_ENOUGH_MEMORY; }
memset(pAddr, 0, sizeof(SOCKADDR_IN6)); pAddr->sin6_family = AF_INET6; pAddr->sin6_addr = *Addr;
// Add address to linked list
**ppNext = pCurr; *ppNext = &pCurr->Next;
pCurr->Length = sizeof(IP_ADAPTER_PREFIX); pCurr->Flags = 0; pCurr->Next = NULL; pCurr->Address.lpSockaddr = (LPSOCKADDR)pAddr; pCurr->Address.iSockaddrLength = sizeof(SOCKADDR_IN6); pCurr->PrefixLength = MaskLen;
return NO_ERROR;}
/*******************************************************************************
* AddIPv6AutoAddressInfo * * This routine adds an IP_ADAPTER_UNICAST_ADDRESS entry for an IPv6 address * on an "automatic tunnel" interface to a list of entries. * * ENTRY IF - IPv6 interface information * ADE - IPv6 address entry * arg1 - Previous entry's "next" pointer to update * arg2 - Adapter info structure * arg3 - "First" entry pointer to update * Flags - flags specified by application * Family - Address family constraint (for DNS) * * EXIT Entry added and arg1 updated * * RETURNS Error status * ******************************************************************************/
DWORD AddIPv6AutoAddressInfo(IPV6_INFO_INTERFACE *IF, IPV6_INFO_ADDRESS *ADE, PVOID arg1, PVOID arg2, PVOID arg3, DWORD Flags, DWORD Family){ PIP_ADAPTER_ADDRESSES **ppNext = (PIP_ADAPTER_ADDRESSES**)arg1; IP_ADAPTER_INFO *pAdapterInfo = (IP_ADAPTER_INFO *)arg2; PIP_ADAPTER_ADDRESSES pCurr, *ppFirst = (PIP_ADAPTER_ADDRESSES*)arg3; PIP_ADAPTER_UNICAST_ADDRESS *pNextUnicastAddr; PIP_ADAPTER_ANYCAST_ADDRESS *pNextAnycastAddr; PIP_ADAPTER_MULTICAST_ADDRESS *pNextMulticastAddr; PIP_ADAPTER_PREFIX *pNextPrefix; CHAR szGuid[80]; char *NameForDnsInfo, *pszDescription; DWORD Ipv4Address, dwErr, dwIfType; WCHAR wszFriendlyName[MAX_FRIENDLY_NAME_LENGTH+1], *pwszDescription; ULONG PrefixLength = 64; IN6_ADDR Prefix;
if (ADE->Type != ADE_UNICAST) { return NO_ERROR; }
ConvertGuidToStringA(&IF->This.Guid, szGuid);
//
// We need the GUID ("NameForDnsInfo") of an interface which we
// can use to find additional relevant configuration information.
// For IPv6 pseudo-interfaces, we'll extract the IPv4 address, and
// find the GUID of the interface it's on, and use that, which assumes
// that configuration information (e.g. the DNS server to use) will
// still apply.
//
if (IF->Type == IPV6_IF_TYPE_TUNNEL_6TO4) { if (IN6_IS_ADDR_6TO4(&ADE->This.Address)) { // Extract IPv4 address from middle of IPv6 address
memcpy(&Ipv4Address, &ADE->This.Address.s6_bytes[2], sizeof(Ipv4Address)); } else { return NO_ERROR; } pwszDescription = L"6to4 Tunneling Pseudo-Interface"; } else { if (IN6_IS_ADDR_V4COMPAT(&ADE->This.Address) || IN6_IS_ADDR_ISATAP(&ADE->This.Address)) {
// Extract IPv4 address from last 4 bytes of IPv6 address
memcpy(&Ipv4Address, &ADE->This.Address.s6_bytes[12], sizeof(Ipv4Address)); } else { return NO_ERROR; } pwszDescription = L"Automatic Tunneling Pseudo-Interface";
if (IN6_IS_ADDR_V4COMPAT(&ADE->This.Address)) { PrefixLength = 96; } }
// Look for an existing interface with same physical address and index.
for (pCurr = *ppFirst; pCurr; pCurr = pCurr->Next) { if ((pCurr->Ipv6IfIndex == ADE->This.IF.Index) && (*(DWORD*)pCurr->PhysicalAddress == Ipv4Address)) { break; } }
if (pCurr == NULL) { // Add an interface
NameForDnsInfo = MapIpv4AddressToName(pAdapterInfo, Ipv4Address, &pszDescription); if (NameForDnsInfo == NULL) { return NO_ERROR; }
wcscpy(wszFriendlyName, pwszDescription);
dwIfType = (IF->Type < NUM_IPV6_IFTYPES)? IPv6ToMibIfType[IF->Type] : MIB_IF_TYPE_OTHER;
dwErr = NewIpAdapter(&pCurr, ppNext, szGuid, NameForDnsInfo, 0, ADE->This.IF.Index, Flags, dwIfType, IF->LinkMTU, (BYTE*)&Ipv4Address, sizeof(Ipv4Address), pwszDescription, wszFriendlyName, IF->ZoneIndices, Family); if (dwErr != NO_ERROR) { return dwErr; }
// 6to4 and automatic tunneling interfaces don't support multicast
// today.
pCurr->Flags |= IP_ADAPTER_NO_MULTICAST;
if (*ppFirst == NULL) { *ppFirst = pCurr; } }
// Add the address to the interface
pNextUnicastAddr = &pCurr->FirstUnicastAddress; while (*pNextUnicastAddr) { pNextUnicastAddr = &(*pNextUnicastAddr)->Next; }
pNextAnycastAddr = &pCurr->FirstAnycastAddress; while (*pNextAnycastAddr) { pNextAnycastAddr = &(*pNextAnycastAddr)->Next; }
pNextMulticastAddr = &pCurr->FirstMulticastAddress; while (*pNextMulticastAddr) { pNextMulticastAddr = &(*pNextMulticastAddr)->Next; }
dwErr = AddIPv6AddressInfo(IF, ADE, &pNextUnicastAddr, &pNextAnycastAddr, &pNextMulticastAddr, Flags, Family); if (dwErr != NO_ERROR) { return dwErr; }
// Add the prefix to the interface
if (Flags & GAA_FLAG_INCLUDE_PREFIX) { ZeroMemory(&Prefix, sizeof(Prefix)); CopyMemory(&Prefix, &ADE->This.Address, PrefixLength / 8); pNextPrefix = &pCurr->FirstPrefix; while (*pNextPrefix) { pNextPrefix = &(*pNextPrefix)->Next; } dwErr = AddIPv6Prefix(&Prefix, PrefixLength, &pCurr->FirstPrefix, &pNextPrefix); }
return dwErr;}
/*******************************************************************************
* GetString * * This routine reads a string value from the registry. * * ENTRY hKey - Handle to registry key * lpName - Name of value to read * pwszBuff - Buffer in which to place value read * ulBytes - Size of buffer * * EXIT pwszBuff filled in * * RETURNS TRUE on success, FALSE on failure * ******************************************************************************/
BOOLGetString(HKEY hKey, LPCWSTR lpName, PWCHAR pwszBuff, SIZE_T ulBytes){ DWORD dwErr, dwType; ULONG ulSize, ulValue; WCHAR buff[NI_MAXHOST];
ulSize = sizeof(ulValue); dwErr = RegQueryValueExW(hKey, lpName, NULL, &dwType, (PBYTE)pwszBuff, (LPDWORD)&ulBytes);
if (dwErr != ERROR_SUCCESS) { return FALSE; }
if (dwType != REG_SZ) { return FALSE; }
return TRUE;}
BOOL MapAdapterNameToFriendlyName(GUID *Guid, char *name, PWCHAR pwszFriendlyName, ULONG ulNumChars){ DWORD dwErr, dwTemp;
dwTemp = ulNumChars;
//
// The following call can be time-consuming the first time it is called.
// If the caller doesn't need the friendly name, it should use the
// GAA_FLAG_SKIP_FRIENDLY_NAME flag, in which case we won't get called.
//
dwErr = HrLanConnectionNameFromGuidOrPath(Guid, NULL, pwszFriendlyName, &dwTemp); if (dwErr == NO_ERROR) { return TRUE; }
dwTemp = ulNumChars;
dwErr = NhGetInterfaceNameFromDeviceGuid(Guid, pwszFriendlyName, &dwTemp, TRUE, FALSE ); if (dwErr == NO_ERROR) { return TRUE; }
MultiByteToWideChar(CP_ACP, 0, name, -1, pwszFriendlyName, ulNumChars);
return FALSE;}
#define KEY_TCPIP6_IF L"System\\CurrentControlSet\\Services\\Tcpip6\\Parameters\\Interfaces"
VOID MapIpv6AdapterNameToFriendlyName(GUID *Guid, char *name, PWCHAR pwszFriendlyName, ULONG ulBytes){ DWORD dwErr; HKEY hInterfaces = NULL, hIf = NULL; CHAR szGuid[40];
if (MapAdapterNameToFriendlyName(Guid, name, pwszFriendlyName, ulBytes/sizeof(WCHAR))) { return; }
dwErr = RegOpenKeyExW(HKEY_LOCAL_MACHINE, KEY_TCPIP6_IF, 0, GENERIC_READ, &hInterfaces); if (dwErr != NO_ERROR) { goto Fail; }
dwErr = RegOpenKeyEx(hInterfaces, name, 0, GENERIC_READ, &hIf); if (dwErr != NO_ERROR) { goto Fail; }
if (GetString(hIf, L"FriendlyName", pwszFriendlyName, ulBytes)) { goto Cleanup; }
Fail: ConvertGuidToStringA(Guid, szGuid); MultiByteToWideChar(CP_ACP, 0, szGuid, -1, pwszFriendlyName, ulBytes / sizeof(WCHAR)); Cleanup: if (hInterfaces) { RegCloseKey(hInterfaces); } if (hIf) { RegCloseKey(hIf); }}
IN6_ADDR Ipv6LinkLocalPrefix = { 0xfe, 0x80 };
/*******************************************************************************
* ForEachIPv6Prefix * * This routine walks the IPv6 routing table and invokes a given function * on each prefix on a given interface. * * ENTRY Ipv6IfIndex - IPv6 interface index * func - Function to invoke on each address * arg1 - Argument to pass to func * arg2 - Argument to pass to func * * EXIT Nothing * * RETURNS Error status * ******************************************************************************/
DWORD ForEachIPv6Prefix(ULONG Ipv6IfIndex, DWORD (*func)(IN6_ADDR *, DWORD, PVOID, PVOID), PVOID arg1, PVOID arg2){ IPV6_QUERY_ROUTE_TABLE Query, NextQuery; IPV6_INFO_ROUTE_TABLE RTE; DWORD BytesIn, BytesReturned, dwCount = 0; ULONG MaskLen, dwErr = NO_ERROR; BOOL SawLinkLocal = FALSE;
ZeroMemory(&NextQuery, sizeof(NextQuery));
for (;;) { Query = NextQuery;
BytesIn = sizeof Query; BytesReturned = sizeof RTE; dwErr = WsControl(IPPROTO_IPV6, IOCTL_IPV6_QUERY_ROUTE_TABLE, &Query, &BytesIn, &RTE, &BytesReturned); if (dwErr != NO_ERROR) { return dwErr; }
NextQuery = RTE.Next; RTE.This = Query;
// Skip if it's not an onlink prefix for this interface.
if ((RTE.This.Neighbor.IF.Index == Ipv6IfIndex) && !IN6_IS_ADDR_MULTICAST(&RTE.This.Prefix)) {
if (IN6_IS_ADDR_LINKLOCAL(&RTE.This.Prefix)) { // This interface has link-local addresses
// (the 6to4 interface, for example, does not).
SawLinkLocal = TRUE; }
if ((RTE.Type != RTE_TYPE_SYSTEM) && IN6_IS_ADDR_UNSPECIFIED(&RTE.This.Neighbor.Address)) {
dwErr = func(&RTE.This.Prefix, RTE.This.PrefixLength, arg1, arg2); if (dwErr != NO_ERROR) { return dwErr; } } }
if (NextQuery.Neighbor.IF.Index == 0) { break; } }
if (SawLinkLocal) { dwErr = func(&Ipv6LinkLocalPrefix, 64, arg1, arg2); }
return dwErr;}
//
// This array is used to convert from an internal IPv6 media status value,
// as defined in ntddip6.h, to a MIB ifOperStatus value as defined in
// iptypes.h.
//
DWORDIPv6ToMibOperStatus[] = { IfOperStatusDown, // IPV6_IF_MEDIA_STATUS_DISCONNECTED
IfOperStatusUp, // IPV6_IF_MEDIA_STATUS_RECONNECTED
IfOperStatusUp, // IPV6_IF_MEDIA_STATUS_CONNECTED
};#define NUM_IPV6_MEDIA_STATUSES (sizeof(IPv6ToMibOperStatus)/sizeof(DWORD))
#define IPV6_LOOPBACK_NAME L"Loopback Pseudo-Interface"
#define IPV6_TEREDO_NAME L"Teredo Tunneling Pseudo-Interface"
/*******************************************************************************
* AddIPv6InterfaceInfo * * This routine adds an IP_ADAPTER_ADDRESSES entry for an IPv6 interface * to a list of such entries. * * ENTRY IF - IPv6 interface information * arg1 - Previous entry's "next" pointer to update * arg2 - Pointer to start of interface list * pAdapterInfo - Additional adapter information * Flags - Flags specified by application * Family - Address family constraint (for DNS servers) * * EXIT Entry added and arg1 updated * * RETURNS Error status * ******************************************************************************/
DWORD AddIPv6InterfaceInfo(IPV6_INFO_INTERFACE *IF, PVOID arg1, PVOID arg2, IP_ADAPTER_INFO *pAdapterInfo, DWORD Flags, DWORD Family){ DWORD dwErr = NO_ERROR; PIP_ADAPTER_ADDRESSES **ppNext = (PIP_ADAPTER_ADDRESSES**)arg1; PIP_ADAPTER_ADDRESSES pFirst = *(PIP_ADAPTER_ADDRESSES*)arg2; PIP_ADAPTER_ADDRESSES pCurr; PIP_ADAPTER_UNICAST_ADDRESS *pNextUnicastAddr; PIP_ADAPTER_ANYCAST_ADDRESS *pNextAnycastAddr; PIP_ADAPTER_MULTICAST_ADDRESS *pNextMulticastAddr; PIP_ADAPTER_PREFIX *pNextPrefix; char *NameForDnsInfo = NULL, *pszDescription; u_char *LinkLayerAddress; DWORD Ipv4Address, dwIfType; WCHAR wszDescription[MAX_ADAPTER_DESCRIPTION_LENGTH + 4]; WCHAR wszFriendlyName[MAX_FRIENDLY_NAME_LENGTH + 1]; CHAR AdapterName[MAX_ADAPTER_NAME_LENGTH + 1];
LinkLayerAddress = (u_char *)(IF + 1);
ConvertGuidToStringA(&IF->This.Guid, AdapterName);
//
// Get a description and adapter name.
//
switch (IF->Type) { case IPV6_IF_TYPE_TUNNEL_6TO4: wcscpy(wszDescription, L"6to4 Pseudo-Interface"); NameForDnsInfo = AdapterName; pCurr = NULL; dwErr = ForEachIPv6Address(IF, AddIPv6AutoAddressInfo, ppNext, pAdapterInfo, (PVOID)&pCurr, Flags, Family); if (dwErr != NO_ERROR) { return dwErr; }
//
// Ensure that there exists an entry for the 6to4 interface.
//
if (pCurr == NULL) { dwErr = NewIpAdapter(&pCurr, ppNext, AdapterName, NameForDnsInfo, 0, IF->This.Index, Flags, IF_TYPE_TUNNEL, IF->LinkMTU, LinkLayerAddress, IF->LinkLayerAddressLength, wszDescription, wszDescription, IF->ZoneIndices, Family); }
return dwErr;
case IPV6_IF_TYPE_TUNNEL_AUTO: wcscpy(wszDescription, L"Automatic Tunneling Pseudo-Interface"); NameForDnsInfo = AdapterName; pCurr = NULL; dwErr = ForEachIPv6Address(IF, AddIPv6AutoAddressInfo, ppNext, pAdapterInfo, (PVOID)&pCurr, Flags, Family);
if (dwErr != NO_ERROR) { return dwErr; }
//
// Ensure that there exists an entry for the ISATAP interface.
//
if (pCurr == NULL) { dwErr = NewIpAdapter(&pCurr, ppNext, AdapterName, NameForDnsInfo, 0, IF->This.Index, Flags, IF_TYPE_TUNNEL, IF->LinkMTU, LinkLayerAddress, IF->LinkLayerAddressLength, wszDescription, wszDescription, IF->ZoneIndices, Family); }
return dwErr;
case IPV6_IF_TYPE_TUNNEL_6OVER4: wcscpy(wszDescription, L"6over4 Pseudo-Interface"); memcpy(&Ipv4Address, LinkLayerAddress, sizeof(Ipv4Address)); NameForDnsInfo = MapIpv4AddressToName(pAdapterInfo, Ipv4Address, &pszDescription); if (NameForDnsInfo == NULL) { //
// IPv4 address does not exist, so just use the interface GUID.
//
NameForDnsInfo = AdapterName; } break;
case IPV6_IF_TYPE_TUNNEL_V6V4: wcscpy(wszDescription, L"Configured Tunnel Interface"); memcpy(&Ipv4Address, LinkLayerAddress, sizeof(Ipv4Address)); NameForDnsInfo = MapIpv4AddressToName(pAdapterInfo, Ipv4Address, &pszDescription); if (NameForDnsInfo == NULL) { //
// IPv4 address does not exist, so just use the interface GUID.
//
NameForDnsInfo = AdapterName; } break;
case IPV6_IF_TYPE_TUNNEL_TEREDO: wcscpy(wszDescription, IPV6_TEREDO_NAME); NameForDnsInfo = AdapterName; break; case IPV6_IF_TYPE_LOOPBACK: wcscpy(wszDescription, IPV6_LOOPBACK_NAME); NameForDnsInfo = AdapterName; break;
default: NameForDnsInfo = MapGuidToAdapterName(pAdapterInfo, &IF->This.Guid, wszDescription); if (NameForDnsInfo != NULL) { strcpy(AdapterName, NameForDnsInfo); } }
if (Flags & GAA_FLAG_SKIP_FRIENDLY_NAME) { wszFriendlyName[0] = L'\0'; } else if (IF->Type == IPV6_IF_TYPE_TUNNEL_TEREDO) { //
// The Teredo interface does not have a friendly name.
//
wcscpy(wszFriendlyName, IPV6_TEREDO_NAME); } else if (IF->Type == IPV6_IF_TYPE_LOOPBACK) { //
// The IPv6 loopback interface will not have a friendly name,
// so use the same string as the description we set above.
//
wcscpy(wszFriendlyName, IPV6_LOOPBACK_NAME); } else { MapIpv6AdapterNameToFriendlyName(&IF->This.Guid, AdapterName, wszFriendlyName, sizeof(wszFriendlyName)); }
dwIfType = (IF->Type < NUM_IPV6_IFTYPES)? IPv6ToMibIfType[IF->Type] : MIB_IF_TYPE_OTHER;
dwErr = FindOrCreateIpAdapter(pFirst, &pCurr, ppNext, AdapterName, NameForDnsInfo, 0, IF->This.Index, Flags, dwIfType, IF->LinkMTU, LinkLayerAddress, IF->LinkLayerAddressLength, wszDescription, wszFriendlyName, IF->ZoneIndices, Family); if (dwErr != NO_ERROR) { return dwErr; }
if (IF->OtherStatefulConfig != 0) { pCurr->Flags |= IP_ADAPTER_IPV6_OTHER_STATEFUL_CONFIG; }
pCurr->OperStatus = (IF->MediaStatus < NUM_IPV6_MEDIA_STATUSES) ? IPv6ToMibOperStatus[IF->MediaStatus] : IfOperStatusUnknown;
// Add addresses
pNextUnicastAddr = &pCurr->FirstUnicastAddress; while (*pNextUnicastAddr) { pNextUnicastAddr = &(*pNextUnicastAddr)->Next; }
pNextAnycastAddr = &pCurr->FirstAnycastAddress; while (*pNextAnycastAddr) { pNextAnycastAddr = &(*pNextAnycastAddr)->Next; }
pNextMulticastAddr = &pCurr->FirstMulticastAddress; while (*pNextMulticastAddr) { pNextMulticastAddr = &(*pNextMulticastAddr)->Next; }
dwErr = ForEachIPv6Address(IF, AddIPv6AddressInfo, &pNextUnicastAddr, &pNextAnycastAddr, &pNextMulticastAddr, Flags, Family); if (dwErr != NO_ERROR) { return dwErr; }
// Add prefixes
if (Flags & GAA_FLAG_INCLUDE_PREFIX) { pNextPrefix = &pCurr->FirstPrefix; while (*pNextPrefix) { pNextPrefix = &(*pNextPrefix)->Next; }
dwErr = ForEachIPv6Prefix(IF->This.Index, AddIPv6Prefix, &pCurr->FirstPrefix, &pNextPrefix); }
return dwErr;}
#define MAX_LINK_LEVEL_ADDRESS_LENGTH 64
/*******************************************************************************
* ForEachIPv6Interface * * This routine walks a set of IPv6 interfaces and invokes a given function * on each one. * * ENTRY func - Function to invoke on each interface * arg1 - Argument to pass to func * arg2 - Argument to pass to func * pAdapterInfo - List of adapter information * Flags - Flags to pass to func * Family - Address family constraint (for DNS servers) * * EXIT Nothing * * RETURNS Error status * ******************************************************************************/
DWORD ForEachIPv6Interface(DWORD (*func)(IPV6_INFO_INTERFACE *, PVOID, PVOID, IP_ADAPTER_INFO *, DWORD, DWORD), PVOID arg1, PVOID arg2, IP_ADAPTER_INFO *pAdapterInfo, DWORD Flags, DWORD Family){ IPV6_QUERY_INTERFACE Query; IPV6_INFO_INTERFACE *IF; u_int InfoSize, BytesReturned, BytesIn; DWORD dwErr;
InfoSize = sizeof *IF + 2 * MAX_LINK_LEVEL_ADDRESS_LENGTH; IF = (IPV6_INFO_INTERFACE *) MALLOC(InfoSize); if (IF == NULL) { return ERROR_NOT_ENOUGH_MEMORY; }
Query.Index = (u_int) -1;
for (;;) { BytesIn = sizeof Query; BytesReturned = InfoSize;
dwErr = WsControl( IPPROTO_IPV6, IOCTL_IPV6_QUERY_INTERFACE, &Query, &BytesIn, IF, &BytesReturned);
if (dwErr != NO_ERROR) { if (dwErr == ERROR_FILE_NOT_FOUND) { // IPv6 is not installed
dwErr = NO_ERROR; } break; }
if (Query.Index != (u_int) -1) {
if ((BytesReturned < sizeof *IF) || (IF->Length < sizeof *IF) || (BytesReturned != IF->Length + ((IF->LocalLinkLayerAddress != 0) ? IF->LinkLayerAddressLength : 0) + ((IF->RemoteLinkLayerAddress != 0) ? IF->LinkLayerAddressLength : 0))) {
dwErr = ERROR_INVALID_PARAMETER; break; }
dwErr = (*func)(IF, arg1, arg2, pAdapterInfo, Flags, Family); if (dwErr != NO_ERROR) { break; } }
if (IF->Next.Index == (u_int) -1) break; Query = IF->Next; }
FREE(IF);
return dwErr;}
//
// IPv4 equivalents of some standard IN6_* macros
//
#define IN_IS_ADDR_LOOPBACK(x) (*(x) == INADDR_LOOPBACK)
#define IN_IS_ADDR_LINKLOCAL(x) ((*(x) & 0x0000ffff) == 0x0000fea9)
/*******************************************************************************
* AddIPv4MulticastAddressInfo * * This routine adds an IP_ADAPTER_MULTICAST_ADDRESS entry for an IPv4 address * to a list of entries. * * ENTRY IF - interface information * Addr - IPv4 address * pFirst - First multicast entry * ppNext - Previous multicast entry's "next" pointer to update * * EXIT Entry added and args updated * * RETURNS Error status * ******************************************************************************/
DWORD AddIPv4MulticastAddressInfo(IP_ADAPTER_INFO *IF, DWORD Addr, PIP_ADAPTER_MULTICAST_ADDRESS *pFirst, PIP_ADAPTER_MULTICAST_ADDRESS **ppNext){ DWORD dwErr = NO_ERROR; PIP_ADAPTER_MULTICAST_ADDRESS pCurr; SOCKADDR_IN *pAddr;
for (pCurr=*pFirst; pCurr; pCurr=pCurr->Next) { pAddr = (SOCKADDR_IN *)pCurr->Address.lpSockaddr; if (pAddr->sin_family == AF_INET && pAddr->sin_addr.s_addr == Addr) { return NO_ERROR; } }
pCurr = MALLOC(sizeof(IP_ADAPTER_MULTICAST_ADDRESS)); if (!pCurr) { return ERROR_NOT_ENOUGH_MEMORY; }
pAddr = MALLOC(sizeof(SOCKADDR_IN)); if (!pAddr) { FREE(pCurr); return ERROR_NOT_ENOUGH_MEMORY; }
memset(pAddr, 0, sizeof(SOCKADDR_IN)); pAddr->sin_family = AF_INET; pAddr->sin_addr.s_addr = Addr;
// Add address to linked list
**ppNext = pCurr; *ppNext = &pCurr->Next;
pCurr->Next = NULL; pCurr->Length = sizeof(IP_ADAPTER_MULTICAST_ADDRESS); pCurr->Flags = 0; pCurr->Address.iSockaddrLength = sizeof(SOCKADDR_IN); pCurr->Address.lpSockaddr = (LPSOCKADDR)pAddr;
return dwErr;}
/*******************************************************************************
* AddIPv4UnicastAddressInfo * * This routine adds an IP_ADAPTER_UNICAST_ADDRESS entry for an IPv4 address * to a list of entries. * * ENTRY IF - IPv4 interface information * ADE - IPv4 address entry * arg1 - Previous unicast entry's "next" pointer to update * arg2 - Initial multicast entry, for duplicate avoidance * arg3 - Previous multicast entry's "next" pointer to update * AppFlags - Flags specified by application * * EXIT Entry added and arg1 updated * * RETURNS Error status * ******************************************************************************/
DWORD AddIPv4UnicastAddressInfo(IP_ADAPTER_INFO *IF, MIB_IPADDRROW *ADE, PVOID arg1, PVOID arg2, PVOID arg3, PVOID arg4, DWORD AppFlags){ PIP_ADAPTER_UNICAST_ADDRESS **ppNext = (PIP_ADAPTER_UNICAST_ADDRESS**)arg1; PIP_ADAPTER_UNICAST_ADDRESS pCurr; SOCKADDR_IN *pAddr; DWORD Address, *pIfFlags = (DWORD *)arg4; time_t Curtime; DWORD dwStatus = NO_ERROR, i;
Address = ADE->dwAddr; if (!Address) { // Do nothing if address is 0.0.0.0
return NO_ERROR; }
if ((Address & 0x000000FF) == 0) { //
// An address in 0/8 isn't a real IP address, it's a fake one that
// the IPv4 stack sticks on a receive-only adapter.
//
(*pIfFlags) |= IP_ADAPTER_RECEIVE_ONLY; return NO_ERROR; }
if (!(AppFlags & GAA_FLAG_SKIP_UNICAST)) { pCurr = MALLOC(sizeof(IP_ADAPTER_UNICAST_ADDRESS)); if (!pCurr) { return ERROR_NOT_ENOUGH_MEMORY; }
pAddr = MALLOC(sizeof(SOCKADDR_IN)); if (!pAddr) { FREE(pCurr); return ERROR_NOT_ENOUGH_MEMORY; }
memset(pAddr, 0, sizeof(SOCKADDR_IN)); pAddr->sin_family = AF_INET; memcpy(&pAddr->sin_addr, &Address, sizeof(Address));
// Add address to linked list
**ppNext = pCurr; *ppNext = &pCurr->Next;
time(&Curtime);
pCurr->Next = NULL; pCurr->Length = sizeof(IP_ADAPTER_UNICAST_ADDRESS); pCurr->LeaseLifetime = (ULONG)(IF->LeaseExpires - Curtime); pCurr->ValidLifetime = pCurr->PreferredLifetime = pCurr->LeaseLifetime; pCurr->Flags = 0; pCurr->Address.iSockaddrLength = sizeof(SOCKADDR_IN); pCurr->Address.lpSockaddr = (LPSOCKADDR)pAddr;
pCurr->PrefixOrigin = IpPrefixOriginManual; pCurr->SuffixOrigin = IpSuffixOriginManual; if (IF->DhcpEnabled) { if (IN_IS_ADDR_LINKLOCAL(&Address)) { pCurr->PrefixOrigin = IpPrefixOriginWellKnown; pCurr->SuffixOrigin = IpSuffixOriginRandom; } else { pCurr->PrefixOrigin = IpPrefixOriginDhcp; pCurr->SuffixOrigin = IpSuffixOriginDhcp; } } pCurr->DadState = IpDadStatePreferred;
if ((pCurr->DadState == IpDadStatePreferred) && (pCurr->SuffixOrigin != IpSuffixOriginRandom) && !IN_IS_ADDR_LOOPBACK(&Address) && !IN_IS_ADDR_LINKLOCAL(&Address)) { pCurr->Flags |= IP_ADAPTER_ADDRESS_DNS_ELIGIBLE; }
if (ADE->wType & MIB_IPADDR_TRANSIENT) { pCurr->Flags |= IP_ADAPTER_ADDRESS_TRANSIENT; } }
// Now add any new multicast addresses
if (!(AppFlags & GAA_FLAG_SKIP_MULTICAST)) { DWORD *pIgmpList = NULL; DWORD dwTotal, dwOutBufLen = 0;
dwStatus = GetIgmpList(Address, pIgmpList, &dwOutBufLen);
if (dwStatus == ERROR_INSUFFICIENT_BUFFER) { pIgmpList = MALLOC(dwOutBufLen); if (!pIgmpList) { return ERROR_NOT_ENOUGH_MEMORY; } dwStatus = GetIgmpList(Address, pIgmpList, &dwOutBufLen); }
if (dwStatus != NO_ERROR) { if (pIgmpList) { FREE(pIgmpList); } return dwStatus; }
dwTotal = dwOutBufLen/sizeof(Address);
for (i=0; (i<dwTotal) && (dwStatus == NO_ERROR); i++) { dwStatus = AddIPv4MulticastAddressInfo(IF, pIgmpList[i], (PIP_ADAPTER_MULTICAST_ADDRESS *)arg2, (PIP_ADAPTER_MULTICAST_ADDRESS **)arg3); }
if (pIgmpList) { FREE(pIgmpList); } }
return dwStatus;}
/*******************************************************************************
* ForEachIPv4Address * * This routine walks a set of IPv4 addresses and invokes a given function * on each one. * * ENTRY IF - IPv4 interface information * func - Function to invoke on each address * arg1 - Argument to pass to func * arg2 - Argument to pass to func * arg3 - Argument to pass to func * Flags - Flags to pass to func * pIpAddrTable - IPv4 address table with per-address flags * * EXIT Nothing * * RETURNS Error status * ******************************************************************************/
DWORD ForEachIPv4Address(IP_ADAPTER_INFO *IF, DWORD (*func)(IP_ADAPTER_INFO *,PMIB_IPADDRROW, PVOID, PVOID, PVOID, PVOID, DWORD), PVOID arg1, PVOID arg2, PVOID arg3, PVOID arg4, DWORD Flags, PMIB_IPADDRTABLE pIpAddrTable){ DWORD dwErr, i; PMIB_IPADDRROW ADE;
for (i=0; i<pIpAddrTable->dwNumEntries; i++) { ADE = &pIpAddrTable->table[i]; if (ADE->dwIndex != IF->Index) { continue; }
dwErr = (*func)(IF, ADE, arg1, arg2, arg3, arg4, Flags); if (dwErr != NO_ERROR) { return dwErr; } }
return NO_ERROR;}
DWORDMaskToMaskLen( DWORD dwMask ){ register int i;
for (i=0; i<32 && !(dwMask & (1<<i)); i++);
return 32-i;}
/*******************************************************************************
* AddIPv4Prefix * * This routine adds an IP_ADAPTER_PREFIX entry for an IPv4 prefix * to a list of entries. * * ENTRY IF - IPv4 interface information * Addr - IPv4 prefix (network byte order) * MaskLen - IPv4 prefix length * arg1 - Initial prefix entry, for duplicate avoidance * arg2 - Previous prefix entry's "next" pointer to update * * EXIT Entry added and arg2 updated * * RETURNS Error status * ******************************************************************************/
DWORD AddIPv4Prefix(DWORD Addr, DWORD MaskLen, PVOID arg1, PVOID arg2){ PIP_ADAPTER_PREFIX pFirst = *(PIP_ADAPTER_PREFIX*)arg1; PIP_ADAPTER_PREFIX **ppNext = (PIP_ADAPTER_PREFIX**)arg2; PIP_ADAPTER_PREFIX pCurr; LPSOCKADDR_IN pAddr;
// Check if already in the list
for (pCurr = pFirst; pCurr; pCurr = pCurr->Next) { if ((pCurr->PrefixLength == MaskLen) && (pCurr->Address.lpSockaddr->sa_family == AF_INET) && (((LPSOCKADDR_IN)pCurr->Address.lpSockaddr)->sin_addr.s_addr == Addr)) { return NO_ERROR; } }
pCurr = MALLOC(sizeof(IP_ADAPTER_PREFIX)); if (!pCurr) { return ERROR_NOT_ENOUGH_MEMORY; }
pAddr = MALLOC(sizeof(SOCKADDR_IN)); if (!pAddr) { FREE(pCurr); return ERROR_NOT_ENOUGH_MEMORY; }
memset(pAddr, 0, sizeof(SOCKADDR_IN)); pAddr->sin_family = AF_INET; pAddr->sin_addr.s_addr = Addr;
// Add address to linked list
**ppNext = pCurr; *ppNext = &pCurr->Next; pCurr->Length = sizeof(IP_ADAPTER_PREFIX); pCurr->Flags = 0; pCurr->Next = NULL; pCurr->Address.lpSockaddr = (LPSOCKADDR)pAddr; pCurr->Address.iSockaddrLength = sizeof(SOCKADDR_IN); pCurr->PrefixLength = MaskLen;
return NO_ERROR;}
/*******************************************************************************
* ForEachIPv4Prefix * * This routine walks a set of IPv4 prefixes and invokes a given function * on each one. * * ENTRY IF - IPv4 interface information * func - Function to invoke on each address * arg1 - Argument to pass to func * arg2 - Argument to pass to func * * EXIT Nothing * * RETURNS Error status * ******************************************************************************/
DWORD ForEachIPv4Prefix(IP_ADAPTER_INFO *IF, DWORD (*func)(DWORD, DWORD, PVOID, PVOID), PVOID arg1, PVOID arg2){ PIP_ADDR_STRING Prefix; DWORD Addr, Mask, MaskLen, dwErr; for (Prefix = &IF->IpAddressList; Prefix; Prefix = Prefix->Next) { if (Prefix->IpAddress.String[0] == '\0') { continue; } Mask = inet_addr(Prefix->IpMask.String); Addr = inet_addr(Prefix->IpAddress.String) & Mask; MaskLen = MaskToMaskLen(ntohl(Mask));
dwErr = func(Addr, MaskLen, arg1, arg2); if (dwErr != NO_ERROR) { return dwErr; } }
return NO_ERROR;}
//
// This array is used to convert from an internal IPv4 oper status value,
// as defined in ipifcons.h, to a MIB ifOperStatus value as defined in
// iptypes.h.
//
DWORDIPv4ToMibOperStatus[] = { IfOperStatusDown, // IF_OPER_STATUS_NON_OPERATIONAL
IfOperStatusDown, // IF_OPER_STATUS_UNREACHABLE
IfOperStatusDormant, // IF_OPER_STATUS_DISCONNECTED
IfOperStatusDormant, // IF_OPER_STATUS_CONNECTING
IfOperStatusUp, // IF_OPER_STATUS_CONNECTED
IfOperStatusUp, // IF_OPER_STATUS_OPERATIONAL
};#define NUM_IPV4_OPER_STATUSES (sizeof(IPv4ToMibOperStatus)/sizeof(DWORD))
/*******************************************************************************
* AddIPv4InterfaceInfo * * This routine adds an IP_ADAPTER_ADDRESSES entry for an IPv4 interface * to a list of such entries. * * ENTRY IF - IPv4 interface information * arg1 - Previous entry's "next" pointer to update * arg2 - Pointer to start of interface list * Flags - Flags controlling what fields to skip, if any * Family - Address family constraint (for DNS server addresses) * pAddrTable - IPv4 address table * * EXIT Entry added and arg updated * * RETURNS Error status * ******************************************************************************/
DWORD AddIPv4InterfaceInfo(IP_ADAPTER_INFO *IF, PVOID arg1, PVOID arg2, DWORD Flags, DWORD Family, PMIB_IPADDRTABLE pAddrTable){ DWORD dwErr = NO_ERROR, i; PIP_ADAPTER_ADDRESSES **ppNext = (PIP_ADAPTER_ADDRESSES**)arg1; PIP_ADAPTER_ADDRESSES pFirst = *(PIP_ADAPTER_ADDRESSES*)arg2; PIP_ADAPTER_ADDRESSES pCurr; PIP_ADAPTER_UNICAST_ADDRESS *pNextUAddr; PIP_ADAPTER_MULTICAST_ADDRESS *pNextMAddr; PIP_ADAPTER_PREFIX *pNextPrefix; WCHAR wszDescription[MAX_ADAPTER_DESCRIPTION_LENGTH + 4]; WCHAR wszFriendlyName[MAX_FRIENDLY_NAME_LENGTH + 1]; MIB_IFROW IfEntry; GUID Guid; DWORD ZoneIndices[ADE_NUM_SCOPES];
MultiByteToWideChar(CP_ACP, 0, IF->Description, -1, wszDescription, MAX_ADAPTER_DESCRIPTION_LENGTH);
//
// Get information which isn't in IP_ADAPTER_INFO.
//
dwErr = GetIfEntryFromStack(&IfEntry, IF->Index, FALSE); if (dwErr != NO_ERROR) { return dwErr; }
if (ConvertStringToGuidA(IF->AdapterName, &Guid) != NO_ERROR) { ZeroMemory(&Guid, sizeof(Guid)); }
//
// Fill in some dummy zone indices.
//
ZoneIndices[0] = ZoneIndices[1] = ZoneIndices[2] = ZoneIndices[3] = IF->Index; for (i=ADE_ADMIN_LOCAL; i<ADE_NUM_SCOPES; i++) { ZoneIndices[i] = 1; }
if (Flags & GAA_FLAG_SKIP_FRIENDLY_NAME) { wszFriendlyName[0] = L'\0'; } else { MapAdapterNameToFriendlyName(&Guid, IF->AdapterName, wszFriendlyName, MAX_FRIENDLY_NAME_LENGTH); }
dwErr = FindOrCreateIpAdapter(pFirst, &pCurr, ppNext, IF->AdapterName, IF->AdapterName, IF->Index, 0, Flags, IF->Type, IfEntry.dwMtu, IF->Address, IF->AddressLength, wszDescription, wszFriendlyName, ZoneIndices, Family); if (dwErr != NO_ERROR) { return dwErr; }
pCurr->OperStatus = (IfEntry.dwOperStatus < NUM_IPV4_OPER_STATUSES) ? IPv4ToMibOperStatus[IfEntry.dwOperStatus] : IfOperStatusUnknown; if (IF->DhcpEnabled) { pCurr->Flags |= IP_ADAPTER_DHCP_ENABLED; }
// Add addresses
pNextUAddr = &pCurr->FirstUnicastAddress; pNextMAddr = &pCurr->FirstMulticastAddress; dwErr = ForEachIPv4Address(IF, AddIPv4UnicastAddressInfo, &pNextUAddr, pNextMAddr, &pNextMAddr, &pCurr->Flags, Flags, pAddrTable); if (dwErr != NO_ERROR) { return dwErr; }
// Add prefixes
if (Flags & GAA_FLAG_INCLUDE_PREFIX) { pNextPrefix = &pCurr->FirstPrefix; dwErr = ForEachIPv4Prefix(IF, AddIPv4Prefix, &pCurr->FirstPrefix, &pNextPrefix); }
return dwErr;}
IP_ADAPTER_INFO IPv4LoopbackInterfaceInfo = { NULL, // Next
1, // ComboIndex
"MS TCP Loopback interface", // AdapterName
"MS TCP Loopback interface", // Description
0, // Address Length
{0}, // Address
1, // Index
MIB_IF_TYPE_LOOPBACK, // Type
FALSE, // DhcpEnabled
NULL, // CurrentIpAddress,
{NULL}, // IpAddressList,
{NULL}, // GatewayList,
{NULL}, // DhcpServer,
FALSE, // HaveWins
{NULL}, // PrimaryWinsServer,
{NULL}, // SecondaryWinsServer,
0, // LeaseObtained
0 // LeaseExpires
};
/*******************************************************************************
* ForEachIPv4Interface * * This routine walks a set of IPv4 interfaces and invokes a given function * on each one. * * ENTRY func - Function to invoke on each interface * arg1 - Argument to pass to func * arg2 - Argument to pass to func * pAdapterInfo - List of IPv4 interfaces * Flags - Flags to pass to func * Family - Address family constraint (for DNS server addresses) * * EXIT Nothing * * RETURNS Error status * ******************************************************************************/
DWORD ForEachIPv4Interface(DWORD (*func)(IP_ADAPTER_INFO *, PVOID, PVOID, DWORD, DWORD, PMIB_IPADDRTABLE), PVOID arg1, PVOID arg2, IP_ADAPTER_INFO *pAdapterInfo, DWORD Flags, DWORD Family, PMIB_IPADDRTABLE pIpAddrTable){ PIP_ADAPTER_INFO IF; DWORD dwErr;
//
// The IPv4 loopback interface is missing from the pAdapterInfo list,
// so we special case it here.
//
dwErr = (*func)(&IPv4LoopbackInterfaceInfo, arg1, arg2, Flags, Family, pIpAddrTable); if (dwErr != NO_ERROR) { return dwErr; }
for (IF=pAdapterInfo; IF; IF=IF->Next) { dwErr = (*func)(IF, arg1, arg2, Flags, Family, pIpAddrTable); if (dwErr != NO_ERROR) { return dwErr; } }
return NO_ERROR;}
DWORD GetAdapterAddresses(ULONG Family, DWORD Flags, PIP_ADAPTER_ADDRESSES *pAddresses){ IP_ADAPTER_INFO *pAdapterInfo = NULL; PIP_ADAPTER_ADDRESSES adapterList, *pCurr; DWORD dwErr = NO_ERROR; PMIB_IPADDRTABLE pIpAddrTable = NULL;
TRACE_PRINT(("Entered GetAdapterAddresses\n"));
pAdapterInfo = GetAdapterInfo();
*pAddresses = adapterList = NULL; pCurr = &adapterList; //
// If we want to return IPv6 DNS servers, find out now whether the
// IPv6 stack is installed.
//
if ((Family != AF_INET) && !(Flags & GAA_FLAG_SKIP_DNS_SERVER)) { IPV6_GLOBAL_PARAMETERS Params; u_int BytesReturned = sizeof(Params); DWORD InputBufferLength = 0;
dwErr = WsControl(IPPROTO_IPV6, IOCTL_IPV6_QUERY_GLOBAL_PARAMETERS, NULL, &InputBufferLength, &Params, &BytesReturned);
bIp6DriverInstalled = (dwErr == NO_ERROR); dwErr = NO_ERROR; }
if ((Family == AF_UNSPEC) || (Family == AF_INET)) { DWORD dwSize = 0;
//
// GetAdapterInfo alone isn't sufficient since it doesn't get
// per-address flags whereas GetIpAddrTable does.
// GetIpAddrTable doesn't get per-interface info however,
// so this is why we have to do both. We use pAdapterInfo
// for per-interface info and pIpAddrTable for
// per-address info.
//
dwErr = GetIpAddrTable(NULL, &dwSize, TRUE); if (dwErr == ERROR_INSUFFICIENT_BUFFER) { pIpAddrTable = MALLOC(dwSize); if (!pIpAddrTable) { dwErr = ERROR_NOT_ENOUGH_MEMORY; goto Cleanup; }
dwErr = GetIpAddrTable(pIpAddrTable, &dwSize, TRUE); } if (dwErr != NO_ERROR) { goto Cleanup; }
dwErr = ForEachIPv4Interface(AddIPv4InterfaceInfo, &pCurr, &adapterList, pAdapterInfo, Flags, Family, pIpAddrTable); if (dwErr != NO_ERROR) { goto Cleanup; } } if ((Family == AF_UNSPEC) || (Family == AF_INET6)) { dwErr = ForEachIPv6Interface(AddIPv6InterfaceInfo, &pCurr, &adapterList, pAdapterInfo, Flags, Family); if (dwErr != NO_ERROR) { goto Cleanup; } } *pAddresses = adapterList;
Cleanup: if (pIpAddrTable) { FREE(pIpAddrTable); } if (pAdapterInfo) { KillAdapterInfo(pAdapterInfo); }
TRACE_PRINT(("Exit GetAdapterAddresses %p\n", adapterList));
return dwErr;}
/*******************************************************************************
* * InternalGetPerAdapterInfo * * Gets per-adapter special information. * * ENTRY IfIndex * * EXIT nothing * * RETURNS pointer to the IP_PER_ADAPTER_INFO structure * * ASSUMES * ******************************************************************************/
PIP_PER_ADAPTER_INFO InternalGetPerAdapterInfo(ULONG IfIndex){
PIP_ADAPTER_INFO adapterList; PIP_ADAPTER_INFO adapter; PIP_PER_ADAPTER_INFO perAdapterInfo = NULL; HKEY key; BOOL ok;
TRACE_PRINT(("Entered GetPerAdapterList\n"));
if ((adapterList = GetAdapterInfo()) != NULL) {
//
// scan the adapter list and find one that matches IfIndex
//
for (adapter = adapterList; adapter; adapter = adapter->Next) {
TRACE_PRINT(("GetPerAdapterInfo: '%s'\n", adapter->AdapterName));
if (adapter->Index == IfIndex && adapter->AdapterName[0] && OpenAdapterKey(KEY_TCP, adapter->AdapterName, KEY_READ, &key)) {
//
// found the right adapter so let's fill up the perAdapterInfo
//
perAdapterInfo = NEW(IP_PER_ADAPTER_INFO); if (perAdapterInfo == NULL) {
DEBUG_PRINT(("GetPerAdapterInfo: no memory for perAdapterInfo\n")); KillAdapterInfo(adapterList); RegCloseKey(key); return NULL; }
ZeroMemory(perAdapterInfo, sizeof(IP_PER_ADAPTER_INFO));
if (!MyReadRegistryDword(key, TEXT("IPAutoconfigurationEnabled"), &perAdapterInfo->AutoconfigEnabled)) {
//
// autoconfig is enabled if no regval exists for this
// adapter
//
perAdapterInfo->AutoconfigEnabled = TRUE; TRACE_PRINT(("IPAutoconfigurationEnabled not read\n")); }
TRACE_PRINT(("IPAutoconfigurationEnableda = %d\n", perAdapterInfo->AutoconfigEnabled));
if (perAdapterInfo->AutoconfigEnabled) {
MyReadRegistryDword(key, TEXT("AddressType"), &perAdapterInfo->AutoconfigActive);
TRACE_PRINT(("AddressType !%s\n", perAdapterInfo->AutoconfigActive)); }
//
// DNS Server list: first NameServer and then DhcpNameServer
//
ok = ReadRegistryIpAddrString(key, TEXT("NameServer"), &perAdapterInfo->DnsServerList); if (ok) { TRACE_PRINT(("GetPerAdapterInfo: DhcpNameServer %s\n", perAdapterInfo->DnsServerList)); }
if (!ok) {
ok = ReadRegistryIpAddrString(key, TEXT("DhcpNameServer"), &perAdapterInfo->DnsServerList); if (ok) { TRACE_PRINT(("GetPerAdapterInfo: DhcpNameServer %s\n", perAdapterInfo->DnsServerList)); } }
//
// we are done so let's exit the loop
//
RegCloseKey(key); break;
} else { DEBUG_PRINT(("Cannot OpenAdapterKey KEY_TCP '%s', gle=%d\n", adapter->AdapterName, GetLastError())); } }
KillAdapterInfo(adapterList); } else { DEBUG_PRINT(("GetPerAdapterInfo: GetAdapterInfo returns NULL\n")); }
TRACE_PRINT(("Exit GetPerAdapterInfo %p\n", perAdapterInfo));
return perAdapterInfo;}
/*******************************************************************************
* * OpenAdapterKey * * Opens one of the 3 per-adapter registry keys: * Tcpip\\Parameters"\<adapter> * or NetBT\Adapters\<Adapter> * or Tcpip6\Paramters\<adapter> * * ENTRY KeyType - KEY_TCP or KEY_NBT or KEY_TCP6 * Name - pointer to adapter name to use * Key - pointer to returned key * * EXIT Key updated * * RETURNS TRUE if success * * ASSUMES * HISTORY: MohsinA, 16-May-97. Fixing for PNP. * ******************************************************************************/
staticBOOL OpenAdapterKey(DWORD KeyType, const LPSTR Name, REGSAM Access, PHKEY Key){
LONG err; CHAR keyName[MAX_ADAPTER_NAME_LENGTH + sizeof(TCPIP_PARAMS_INTER_KEY)];
switch (KeyType) { case KEY_TCP:
//
// open the handle to this adapter's TCPIP parameter key
//
strcpy(keyName, TCPIP_PARAMS_INTER_KEY ); strcat(keyName, Name); break;
case KEY_TCP6:
//
// open the handle to this adapter's TCPIP6 parameter key
//
strcpy(keyName, TCPIP6_PARAMS_INTER_KEY ); strcat(keyName, Name); break;
case KEY_NBT:
//
// open the handle to the NetBT\Adapters\<Adapter> handle
//
strcpy(keyName, NETBT_ADAPTER_KEY ); strcat(keyName, Name); break;
default: return FALSE; }
TRACE_PRINT(("OpenAdapterKey: %s\n", keyName ));
err = RegOpenKeyEx(HKEY_LOCAL_MACHINE, keyName, 0, Access, Key );
if( err != ERROR_SUCCESS ){ DEBUG_PRINT(("OpenAdapterKey: RegOpenKey %s, err=%d\n", keyName, GetLastError() )); }else{ TRACE_PRINT(("Exit OpenAdapterKey: %s ok\n", keyName )); }
return (err == ERROR_SUCCESS);}
BOOL WriteRegistryDword(HKEY hKey, LPSTR szParameter, DWORD *pdwValue ){ DWORD dwResult;
TRACE_PRINT(("WriteRegistryDword: %s %d\n", szParameter, *pdwValue ));
dwResult = RegSetValueEx( hKey, szParameter, 0, REG_DWORD, (CONST BYTE *) pdwValue, sizeof( *pdwValue ) );
return ( ERROR_SUCCESS == dwResult );}
BOOL WriteRegistryMultiString(HKEY hKey, LPSTR szParameter, LPSTR szValue ){ DWORD dwResult; LPSTR psz;
for (psz = szValue; *psz; psz += lstrlen(szValue) + 1) { }
dwResult = RegSetValueEx( hKey, szParameter, 0, REG_MULTI_SZ, (CONST BYTE *) szValue, (DWORD)(psz - szValue) + 1 );
return ( ERROR_SUCCESS == dwResult );}
/*******************************************************************************
* * MyReadRegistryDword * * Reads a registry value that is stored as a DWORD * * ENTRY Key - open registry key where value resides * ParameterName - name of value to read from registry * Value - pointer to returned value * * EXIT *Value = value read * * RETURNS TRUE if success * * ASSUMES * ******************************************************************************/
BOOL MyReadRegistryDword(HKEY Key, LPSTR ParameterName, LPDWORD Value){
LONG err; DWORD valueLength; DWORD valueType;
valueLength = sizeof(*Value); err = RegQueryValueEx(Key, ParameterName, NULL, // reserved
&valueType, (LPBYTE)Value, &valueLength ); if ((err == ERROR_SUCCESS) && (valueType == REG_DWORD) && (valueLength == sizeof(DWORD))) {
DEBUG_PRINT(("MyReadRegistryDword(%s): val = %d, type = %d, len = %d\n", ParameterName, *Value, valueType, valueLength ));
} else {
DEBUG_PRINT(("MyReadRegistryDword(%p,%s): err = %d\n", Key, ParameterName, err));
err = !ERROR_SUCCESS; }
return (err == ERROR_SUCCESS);}
// ========================================================================
// Was DWORD IPInterfaceContext, now CHAR NTEContextList[][].
// Reads in a REG_MULTI_SZ and converts it into a list of numbers.
// MohsinA, 21-May-97.
// ========================================================================
// max length of REG_MULTI_SZ.
#define MAX_VALUE 5002
BOOLReadRegistryList(HKEY Key, LPSTR ParameterName, DWORD NumList[], int *MaxList){
LONG err; DWORD valueType; BYTE Value[MAX_VALUE]; DWORD valueLength = MAX_VALUE; int i = 0, k = 0;
err = RegQueryValueEx(Key, ParameterName, NULL, &valueType, &Value[0], &valueLength );
if( ( err == ERROR_SUCCESS) && ( valueType == REG_MULTI_SZ ) && ((valueLength+2) < MAX_VALUE) ){ TRACE_PRINT(("ReadRegistryList %s ok\n", ParameterName )); Value[MAX_VALUE-1] = '\0'; Value[MAX_VALUE-2] = '\0';
while( (i < MAX_VALUE) && Value[i] && (k < (*MaxList)) ){ NumList[k] = strtoul( &Value[i], NULL, 0 ); TRACE_PRINT((" NumList[%d] = '%s' => %d\n", k, &Value[i], NumList[k] )); k++; i += strlen( &Value[i] ) + 1; } assert( (i < MAX_VALUE) && !Value[i] && (k < MaxList) ); *MaxList = k; } else { *MaxList = 0; DEBUG_PRINT(("ReadRegistryList %s failed\n", ParameterName )); err = !ERROR_SUCCESS; }
return (err == ERROR_SUCCESS);}
BOOLIsIncluded( DWORD Context, DWORD contextlist[], int len_contextlist ){ int i;
for( i = 0; i < len_contextlist; i++ ) { if( Context == contextlist[i] ){ return TRUE; } }
return FALSE;}
/*******************************************************************************
* * ReadRegistryString * * Reads a registry value that is stored as a string * * ENTRY Key - open registry key * ParameterName - name of value to read from registry * String - pointer to returned string * Length - IN: length of String buffer. OUT: length of returned string * * EXIT String contains string read * * RETURNS TRUE if success * * ASSUMES * ******************************************************************************/
BOOL ReadRegistryString(HKEY Key, LPSTR ParameterName, LPSTR String, LPDWORD Length){
LONG err; DWORD valueType;
*String = '\0'; err = RegQueryValueEx(Key, ParameterName, NULL, // reserved
&valueType, (LPBYTE)String, Length );
if (err == ERROR_SUCCESS) {
ASSERT(valueType == REG_SZ || valueType == REG_MULTI_SZ);
DEBUG_PRINT(("ReadRegistryString(%s): val = \"%s\", type = %d, len = %d\n", ParameterName, String, valueType, *Length ));
} else {
DEBUG_PRINT(("ReadRegistryString(%s): err = %d\n", ParameterName, err));
}
return ((err == ERROR_SUCCESS) && (*Length > sizeof('\0')));}
/*******************************************************************************
* * ReadRegistryOemString * * Reads a registry value as a wide character string * * ENTRY Key - open registry key * ParameterName - name of value to read from registry * String - pointer to returned string * Length - IN: length of String buffer. OUT: length of returned string * * EXIT String contains string read * * RETURNS TRUE if success * * ASSUMES * ******************************************************************************/
BOOL ReadRegistryOemString(HKEY Key, LPWSTR ParameterName, LPSTR String, LPDWORD Length){
LONG err; DWORD valueType; DWORD valueLength;
//
// first, get the length of the string
//
*String = '\0'; err = RegQueryValueExW(Key, ParameterName, NULL, // reserved
&valueType, NULL, &valueLength ); if ((err == ERROR_SUCCESS) && (valueType == REG_SZ)) { if ((valueLength <= *Length) && (valueLength > sizeof(L'\0'))) {
UNICODE_STRING unicodeString; OEM_STRING oemString; LPWSTR str = (LPWSTR)GrabMemory(valueLength);
if (!str) { return FALSE; }
//
// read the UNICODE string into allocated memory
//
err = RegQueryValueExW(Key, ParameterName, NULL, &valueType, (LPBYTE)str, &valueLength ); if (err == ERROR_SUCCESS) {
NTSTATUS Status;
//
// convert the UNICODE string to OEM character set
//
RtlInitUnicodeString(&unicodeString, str); Status = RtlUnicodeStringToOemString(&oemString, &unicodeString, TRUE);
if (NT_SUCCESS(Status)) { strcpy(String, oemString.Buffer); RtlFreeOemString(&oemString); } else { err = !ERROR_SUCCESS; }
DEBUG_PRINT(("ReadRegistryOemString(%ws): val = \"%s\", len = %d\n", ParameterName, String, valueLength ));
} else {
DEBUG_PRINT(("ReadRegistryOemString(%ws): err = %d, type = %d, len = %d\n", ParameterName, err, valueType, valueLength ));
} ReleaseMemory(str); } else {
DEBUG_PRINT(("ReadRegistryOemString(%ws): err = %d, type = %d, len = %d\n", ParameterName, err, valueType, valueLength ));
err = !ERROR_SUCCESS; } } else {
DEBUG_PRINT(("ReadRegistryOemString(%ws): err = %d, type = %d, len = %d\n", ParameterName, err, valueType, valueLength ));
err = !ERROR_SUCCESS; } return (err == ERROR_SUCCESS);}
/*******************************************************************************
* * ReadRegistryIpAddrString * * Reads zero or more IP addresses from a space-delimited string in a registry * parameter and converts them to a list of IP_ADDR_STRINGs * * ENTRY Key - registry key * ParameterName - name of value entry under Key to read from * IpAddr - pointer to IP_ADDR_STRING to update * * EXIT IpAddr updated if success * * RETURNS TRUE if success * * ASSUMES * ******************************************************************************/
BOOL ReadRegistryIpAddrString(HKEY Key, LPSTR ParameterName, PIP_ADDR_STRING IpAddr){
LONG err; DWORD valueLength; DWORD valueType; LPBYTE valueBuffer;
err = RegQueryValueEx(Key, ParameterName, NULL, // reserved
&valueType, NULL, &valueLength ); if ((err == ERROR_SUCCESS)) { if((valueLength > 1) && (valueType == REG_SZ) || (valueLength > 2) && (valueType == REG_MULTI_SZ) ) { valueBuffer = GrabMemory(valueLength); if (!valueBuffer) { return FALSE; } err = RegQueryValueEx(Key, ParameterName, NULL, // reserved
&valueType, valueBuffer, &valueLength ); if ((err == ERROR_SUCCESS) && (valueLength > 1)) {
UINT stringCount; LPSTR stringPointer = valueBuffer; LPSTR *stringAddress; UINT i;
DEBUG_PRINT(("ReadRegistryIpAddrString(%s): \"%s\", len = %d\n", ParameterName, valueBuffer, valueLength ));
stringAddress = GrabMemory(valueLength / 2 * sizeof(LPSTR));
if (stringAddress) { if( REG_SZ == valueType ) { stringPointer += strspn(stringPointer, STRING_ARRAY_DELIMITERS); stringAddress[0] = stringPointer; stringCount = 1; while (stringPointer = strpbrk(stringPointer, STRING_ARRAY_DELIMITERS)) { *stringPointer++ = '\0'; stringPointer += strspn(stringPointer, STRING_ARRAY_DELIMITERS); stringAddress[stringCount] = stringPointer; if (*stringPointer) { ++stringCount; } }
for (i = 0; i < stringCount; ++i) { AddIpAddressString(IpAddr, stringAddress[i], ""); } } else if( REG_MULTI_SZ == valueType ) { stringCount = 0; while(strlen(stringPointer)) { AddIpAddressString(IpAddr, stringPointer, ""); stringPointer += 1+strlen(stringPointer); stringCount ++; } if( 0 == stringCount ) err = ERROR_PATH_NOT_FOUND; } else { err = ERROR_PATH_NOT_FOUND; } ReleaseMemory(stringAddress); } else { err = ERROR_NOT_ENOUGH_MEMORY; } } else {
DEBUG_PRINT(("ReadRegistryIpAddrString(%s): err = %d, len = %d\n", ParameterName, err, valueLength ));
err = ERROR_PATH_NOT_FOUND; } ReleaseMemory(valueBuffer); } else {
DEBUG_PRINT(("ReadRegistryIpAddrString(%s): err = %d, type = %d, len = %d\n", ParameterName, err, valueType, valueLength ));
err = ERROR_PATH_NOT_FOUND; } } return (err == ERROR_SUCCESS);}
/*******************************************************************************
* * GetBoundAdapterList * * Gets a list of names of all adapters bound to a protocol (TCP/IP). Returns * a pointer to an array of pointers to strings - basically an argv list. The * memory for the strings is concatenated to the array and the array is NULL * terminated. If Elnkii1 and IbmTok2 are bound to TCP/IP then this function * will return: * * ---> addr of string1 \ * addr of string2 \ * NULL > allocated as one block * &string1: "Elnkii1" / * &string2: "IbmTok2" / * * ENTRY BindingsSectionKey * - Open registry handle to a linkage key (e.g. Tcpip\Linkage) * * EXIT * * RETURNS pointer to argv[] style array, or NULL * * ASSUMES * ******************************************************************************/
LPSTR* GetBoundAdapterList(HKEY BindingsSectionKey){
LONG err; DWORD valueType; PBYTE valueBuffer; DWORD valueLength; LPSTR* resultBuffer; LPSTR* nextResult; int len; DWORD resultLength; LPSTR nextValue; LPSTR variableData; DWORD numberOfBindings;
//
// get required size of value buffer
//
valueLength = 0; err = RegQueryValueEx(BindingsSectionKey, TEXT("Bind"), NULL, // reserved
&valueType, NULL, &valueLength ); if (err != ERROR_SUCCESS) { return NULL; } if (valueType != REG_MULTI_SZ) { return NULL; } if (!valueLength) { return NULL; } valueBuffer = (PBYTE)GrabMemory(valueLength); if (!valueBuffer) { return NULL; } err = RegQueryValueEx(BindingsSectionKey, TEXT("Bind"), NULL, // reserved
&valueType, valueBuffer, &valueLength ); if (err != ERROR_SUCCESS) { DEBUG_PRINT(("GetBoundAdapterList: RegQueryValueEx 'Bind' failed\n")); ReleaseMemory(valueBuffer); return NULL; } resultLength = sizeof(LPSTR); // the NULL at the end of the list
numberOfBindings = 0; nextValue = (LPSTR)valueBuffer; while (len = strlen(nextValue)) { resultLength += sizeof(LPSTR) + len + 1; if (!_strnicmp(nextValue, DEVICE_PREFIX, sizeof(DEVICE_PREFIX) - 1)) { resultLength -= sizeof(DEVICE_PREFIX) - 1; } nextValue += len + 1; ++numberOfBindings; } resultBuffer = (LPSTR*)GrabMemory(resultLength); if (!resultBuffer) { return NULL; } nextValue = (LPSTR)valueBuffer; nextResult = resultBuffer; variableData = (LPSTR)(((LPSTR*)resultBuffer) + numberOfBindings + 1); while (numberOfBindings--) {
LPSTR adapterName;
adapterName = nextValue; if (!_strnicmp(adapterName, DEVICE_PREFIX, sizeof(DEVICE_PREFIX) - 1)) { adapterName += sizeof(DEVICE_PREFIX) - 1; } *nextResult++ = variableData; strcpy(variableData, adapterName); TRACE_PRINT(("GetBoundAdapterList: adapterName=%s\n", adapterName )); while (*variableData) { ++variableData; } ++variableData; while (*nextValue) { ++nextValue; } ++nextValue; } *nextResult = NULL; ReleaseMemory(valueBuffer); return resultBuffer;}
/*******************************************************************************
* * MapNodeType * * Converts node type to descriptive string * * ENTRY * * EXIT * * RETURNS pointer to string * * ASSUMES * ******************************************************************************/
LPSTR MapNodeType(UINT Parm){
DWORD dwParm = LAST_NODE_TYPE + 1;
//
// 1, 2, 4, 8 => log2(n) + 1 [1, 2, 3, 4]
//
switch (Parm) { case 0:
//
// according to JStew value of 0 will be treated as BNode (default)
//
case BNODE: dwParm = 1; break;
case PNODE: dwParm = 2; break;
case MNODE: dwParm = 3; break;
case HNODE: dwParm = 4; break; } if ((dwParm >= FIRST_NODE_TYPE) && (dwParm <= LAST_NODE_TYPE)) { return NodeTypes[dwParm].String; }
//
// if no node type is defined then we default to Hybrid
//
return NodeTypes[LAST_NODE_TYPE].String;}
/*******************************************************************************
* * MapNodeTypeEx * * Converts node type to descriptive string * * ENTRY * * EXIT * * RETURNS pointer to string * * ASSUMES * ******************************************************************************/
LPSTR MapNodeTypeEx(UINT Parm){
DWORD dwParm = LAST_NODE_TYPE + 1; LPSTR Buf;
Buf = GrabMemory(10);
if (!Buf) { return NULL; }
//
// 1, 2, 4, 8 => log2(n) + 1 [1, 2, 3, 4]
//
switch (Parm) { case 0:
//
// according to JStew value of 0 will be treated as BNode (default)
//
case BNODE: dwParm = 1; break;
case PNODE: dwParm = 2; break;
case MNODE: dwParm = 3; break;
case HNODE: dwParm = 4; break; } if ((dwParm >= FIRST_NODE_TYPE) && (dwParm <= LAST_NODE_TYPE)) { strcpy(Buf, NodeTypesEx[dwParm]); return Buf; }
//
// if no node type is defined then we default to Hybrid
//
strcpy(Buf, NodeTypesEx[LAST_NODE_TYPE]); return Buf;}
/*******************************************************************************
* * MapAdapterType * * Returns a string describing the type of adapter, based on the type retrieved * from TCP/IP * * ENTRY type - type of adapter * * EXIT nothing * * RETURNS pointer to mapped type or pointer to NUL string * * ASSUMES * ******************************************************************************/
LPSTR MapAdapterType(UINT type){ switch (type) { case IF_TYPE_OTHER: return ADAPTER_TYPE(MI_IF_OTHER); // ?
case IF_TYPE_ETHERNET_CSMACD: return ADAPTER_TYPE(MI_IF_ETHERNET);
case IF_TYPE_ISO88025_TOKENRING: return ADAPTER_TYPE(MI_IF_TOKEN_RING);
case IF_TYPE_FDDI: return ADAPTER_TYPE(MI_IF_FDDI);
case IF_TYPE_PPP: return ADAPTER_TYPE(MI_IF_PPP);
case IF_TYPE_SOFTWARE_LOOPBACK: return ADAPTER_TYPE(MI_IF_LOOPBACK);
case IF_TYPE_SLIP: return ADAPTER_TYPE(MI_IF_SLIP); } return "";}
/*******************************************************************************
* * MapAdapterTypeEx * * Returns a string describing the type of adapter, based on the type retrieved * from TCP/IP * * ENTRY type - type of adapter * * EXIT nothing * * RETURNS pointer to mapped type or pointer to NUL string * * ASSUMES * ******************************************************************************/
LPSTR MapAdapterTypeEx(UINT type){ LPSTR Buf;
Buf = GrabMemory(12);
if (!Buf) { return NULL; }
switch (type) { case IF_TYPE_OTHER: strcpy(Buf, ADAPTER_TYPE_EX(MI_IF_OTHER)); // ?
return Buf;
case IF_TYPE_ETHERNET_CSMACD: strcpy(Buf, ADAPTER_TYPE_EX(MI_IF_ETHERNET)); return Buf;
case IF_TYPE_ISO88025_TOKENRING: strcpy(Buf, ADAPTER_TYPE_EX(MI_IF_TOKEN_RING)); return Buf;
case IF_TYPE_FDDI: strcpy(Buf, ADAPTER_TYPE_EX(MI_IF_FDDI)); return Buf;
case IF_TYPE_PPP: strcpy(Buf, ADAPTER_TYPE_EX(MI_IF_PPP)); return Buf;
case IF_TYPE_SOFTWARE_LOOPBACK: strcpy(Buf, ADAPTER_TYPE_EX(MI_IF_LOOPBACK)); return Buf;
case IF_TYPE_SLIP: strcpy(Buf, ADAPTER_TYPE_EX(MI_IF_SLIP)); return Buf; } strcpy(Buf, ""); return Buf;}
/*******************************************************************************
* * MapAdapterAddress * * Converts the binary adapter address retrieved from TCP/IP into an ASCII * string. Allows for various conversions based on adapter type. The only * mapping we do currently is basic 6-byte MAC address (e.g. 02-60-8C-4C-97-0E) * * ENTRY pAdapterInfo - pointer to IP_ADAPTER_INFO containing address info * Buffer - pointer to buffer where address will be put * * EXIT Buffer - contains converted address * * RETURNS pointer to Buffer * * ASSUMES * ******************************************************************************/
LPSTR MapAdapterAddress(PIP_ADAPTER_INFO pAdapterInfo, LPSTR Buffer){
LPSTR format; int separator; int len; int i; LPSTR pbuf = Buffer; UINT mask;
len = min((int)pAdapterInfo->AddressLength, sizeof(pAdapterInfo->Address));
switch (pAdapterInfo->Type) { case IF_TYPE_ETHERNET_CSMACD: case IF_TYPE_ISO88025_TOKENRING: case IF_TYPE_FDDI: format = "%02X"; mask = 0xff; separator = TRUE; break;
default: format = "%02x"; mask = 0xff; separator = TRUE; break; } for (i = 0; i < len; ++i) { pbuf += sprintf(pbuf, format, pAdapterInfo->Address[i] & mask); if (separator && (i != len - 1)) { pbuf += sprintf(pbuf, "-"); } } return Buffer;}
/*******************************************************************************
* * MapTime * * Converts IP lease time to more human-sensible string * * ENTRY AdapterInfo - pointer to IP_ADAPTER_INFO owning time variable * TimeVal - DWORD (time_t) time value (number of milliseconds since * virtual year dot) * * EXIT static buffer updated * * RETURNS pointer to string * * ASSUMES 1. The caller realizes this function returns a pointer to a static * buffer, hence calling this function a second time, but before * the results from the previous call have been used, will destroy * the previous results * ******************************************************************************/
LPSTR MapTime(PIP_ADAPTER_INFO AdapterInfo, DWORD_PTR TimeVal){
struct tm* pTime; static char timeBuf[128]; static char oemTimeBuf[256];
if (pTime = localtime(&TimeVal)) {
SYSTEMTIME systemTime; char* pTimeBuf = timeBuf; int n;
systemTime.wYear = pTime->tm_year + 1900; systemTime.wMonth = pTime->tm_mon + 1; systemTime.wDayOfWeek = (WORD)pTime->tm_wday; systemTime.wDay = (WORD)pTime->tm_mday; systemTime.wHour = (WORD)pTime->tm_hour; systemTime.wMinute = (WORD)pTime->tm_min; systemTime.wSecond = (WORD)pTime->tm_sec; systemTime.wMilliseconds = 0; n = GetDateFormat(0, DATE_LONGDATE, &systemTime, NULL, timeBuf, sizeof(timeBuf)); timeBuf[n - 1] = ' '; GetTimeFormat(0, 0, &systemTime, NULL, &timeBuf[n], sizeof(timeBuf) - n);
//
// we have to convert the returned ANSI string to the OEM charset
//
//
if (CharToOem(timeBuf, oemTimeBuf)) { return oemTimeBuf; }
return timeBuf; } return "";}
/*******************************************************************************
* * MapTimeEx * * Converts IP lease time to more human-sensible string * * ENTRY AdapterInfo - pointer to IP_ADAPTER_INFO owning time variable * TimeVal - DWORD (time_t) time value (number of milliseconds since * virtual year dot) * * EXIT buffer allocated * * RETURNS pointer to string * * ASSUMES 1. The caller realizes this function returns a pointer to a static * buffer, hence calling this function a second time, but before * the results from the previous call have been used, will destroy * the previous results * ******************************************************************************/
LPSTR MapTimeEx(PIP_ADAPTER_INFO AdapterInfo, DWORD_PTR TimeVal){ LPSTR rettime, rettimeBuf;
rettimeBuf = GrabMemory(128); if (!rettimeBuf) { return NULL; }
rettime = MapTime(AdapterInfo, TimeVal);
if (strcmp(rettime, "") == 0) { rettimeBuf[0] = '\0'; } else { strcpy(rettimeBuf, rettime); } return rettimeBuf;}
/*******************************************************************************
* * MapScopeId * * Converts scope id value. Input is a string. If it is "*" then this denotes * that the scope id is really a null string, so we return an empty string. * Otherwise, the input string is returned * * ENTRY * * EXIT * * RETURNS pointer to string * * ASSUMES * ******************************************************************************/
LPSTR MapScopeId(PVOID Param){ return !strcmp((LPSTR)Param, "*") ? "" : (LPSTR)Param;}
/*******************************************************************************
* * Terminate * * Cleans up - closes the registry handles, ready for process exit * * ENTRY * * EXIT * * RETURNS * * ASSUMES * ******************************************************************************/
VOID Terminate(){
//
// this function probably isn't even necessary - I'm sure the system will
// clean up these handles if we just fall out
//
if (NetbtParametersKey != INVALID_HANDLE_VALUE) { RegCloseKey(NetbtParametersKey); } if (NetbtInterfacesKey != INVALID_HANDLE_VALUE) { RegCloseKey(NetbtInterfacesKey); } if (TcpipParametersKey != INVALID_HANDLE_VALUE) { RegCloseKey(TcpipParametersKey); } if (TcpipLinkageKey != INVALID_HANDLE_VALUE) { RegCloseKey(TcpipLinkageKey); }
}
/*******************************************************************************
* * GrabMemory * * Allocates memory. Exits with a fatal error if LocalAlloc fails, since on NT * I don't expect this ever to occur * * ENTRY size * Number of bytes to allocate * * EXIT * * RETURNS pointer to allocated memory * * ASSUMES * ******************************************************************************/
LPVOID GrabMemory(DWORD size){
LPVOID p;
p = (LPVOID)LocalAlloc(LMEM_FIXED, size); if (!p) { return NULL; } return p;}
/*******************************************************************************
* * DisplayMessage * * Outputs a message retrieved from the string resource attached to the exe. * Mainly for internationalizable reasons * * ENTRY * * EXIT * * RETURNS * * ASSUMES * ******************************************************************************/
VOID DisplayMessage(BOOL Tabbed, DWORD MessageId, ...){
va_list argptr; char messageBuffer[2048]; int count;
va_start(argptr, MessageId); count = FormatMessage(FORMAT_MESSAGE_FROM_HMODULE, NULL, // use default hModule
MessageId, 0, // use default Language
messageBuffer, sizeof(messageBuffer), &argptr );
if (count == 0) { DEBUG_PRINT(("DisplayMessage: GetLastError() returns %d\n", GetLastError())); }
va_end(argptr); if (Tabbed) { putchar('\t'); } printf(messageBuffer);}
/*******************************************************************************
* * KillFixedInfo * * ENTRY * * EXIT * * RETURNS * * ASSUMES * ******************************************************************************/
VOID KillFixedInfo(PFIXED_INFO Info){
PIP_ADDR_STRING p; PIP_ADDR_STRING next;
for (p = Info->DnsServerList.Next; p != NULL; p = next) { next = p->Next; ReleaseMemory(p); } ReleaseMemory(Info);}
/*******************************************************************************
* * KillAdapterInfo * * ENTRY * * EXIT * * RETURNS * * ASSUMES * ******************************************************************************/
VOID KillAdapterInfo(PIP_ADAPTER_INFO Info){ PIP_ADDR_STRING p; PIP_ADDR_STRING next; PIP_ADAPTER_INFO CurrAdapter; PIP_ADAPTER_INFO NextAdapter;
for (CurrAdapter=Info; CurrAdapter != NULL; CurrAdapter = NextAdapter) { for (p = CurrAdapter->IpAddressList.Next; p != NULL; p = next) { next = p->Next; ReleaseMemory(p); } for (p = CurrAdapter->GatewayList.Next; p != NULL; p = next) { next = p->Next; ReleaseMemory(p); } for (p = CurrAdapter->SecondaryWinsServer.Next; p != NULL; p = next) { next = p->Next; ReleaseMemory(p); } NextAdapter = CurrAdapter->Next; ReleaseMemory(CurrAdapter); }}
VOID KillAdapterAddresses(PIP_ADAPTER_ADDRESSES Info){ PIP_ADAPTER_UNICAST_ADDRESS pU; PIP_ADAPTER_UNICAST_ADDRESS nextU; PIP_ADAPTER_ANYCAST_ADDRESS pA; PIP_ADAPTER_ANYCAST_ADDRESS nextA; PIP_ADAPTER_MULTICAST_ADDRESS pM; PIP_ADAPTER_MULTICAST_ADDRESS nextM; PIP_ADAPTER_DNS_SERVER_ADDRESS pD; PIP_ADAPTER_DNS_SERVER_ADDRESS nextD; PIP_ADAPTER_PREFIX pP; PIP_ADAPTER_PREFIX nextP; PIP_ADAPTER_ADDRESSES CurrAdapter; PIP_ADAPTER_ADDRESSES NextAdapter;
for (CurrAdapter=Info; CurrAdapter != NULL; CurrAdapter = NextAdapter) { FREE(CurrAdapter->Description); FREE(CurrAdapter->FriendlyName); FREE(CurrAdapter->DnsSuffix); FREE(CurrAdapter->AdapterName);
for (pU = CurrAdapter->FirstUnicastAddress; pU != NULL; pU = nextU) { FREE(pU->Address.lpSockaddr); nextU = pU->Next; FREE(pU); } for (pA = CurrAdapter->FirstAnycastAddress; pA != NULL; pA = nextA) { FREE(pA->Address.lpSockaddr); nextA = pA->Next; FREE(pA); } for (pM = CurrAdapter->FirstMulticastAddress; pM != NULL; pM = nextM) { FREE(pM->Address.lpSockaddr); nextM = pM->Next; FREE(pM); } for (pD = CurrAdapter->FirstDnsServerAddress; pD != NULL; pD = nextD) { FREE(pD->Address.lpSockaddr); nextD = pD->Next; FREE(pD); } for (pP = CurrAdapter->FirstPrefix; pP != NULL; pP = nextP) { FREE(pP->Address.lpSockaddr); nextP = pP->Next; FREE(pP); } NextAdapter = CurrAdapter->Next;
FREE(CurrAdapter); }}
/*******************************************************************************
* * KillPerAdapterInfo * * ENTRY * * EXIT * * RETURNS * * ASSUMES * ******************************************************************************/
VOID KillPerAdapterInfo(PIP_PER_ADAPTER_INFO Info){
PIP_ADDR_STRING p; PIP_ADDR_STRING next;
for (p = Info->DnsServerList.Next; p != NULL; p = next) { next = p->Next; ReleaseMemory(p); } ReleaseMemory(Info);}
/*******************************************************************************
* * GetIPAddrStringLen * * ENTRY * * EXIT * * RETURNS * * ASSUMES * ******************************************************************************/
DWORDGetIPAddrStringLen(PIP_ADDR_STRING pIPAddrString){ PIP_ADDR_STRING Curr=pIPAddrString->Next; int len = 0;
while (Curr != NULL) { Curr=Curr->Next; len++; } return len;}
/*******************************************************************************
* * GetSizeofFixedInfo * * ENTRY * * EXIT * * RETURNS * * ASSUMES * ******************************************************************************/
DWORDGetSizeofFixedInfo(PFIXED_INFO pFixedInfo){ return (sizeof(FIXED_INFO) + (GetIPAddrStringLen(&pFixedInfo->DnsServerList) * sizeof(IP_ADDR_STRING)));}
/*******************************************************************************
* * GetFixedInfoEx * * ENTRY * * EXIT * * RETURNS * * ASSUMES * ******************************************************************************/
DWORDGetFixedInfoEx(PFIXED_INFO pFixedInfo, PULONG pOutBufLen){
PFIXED_INFO getinfo; PIP_ADDR_STRING DnsServerList, CurrDnsServerList; uint len;
if (pOutBufLen == NULL) { return ERROR_INVALID_PARAMETER; }
getinfo = GetFixedInfo();
try {
if (!pFixedInfo || (*pOutBufLen < GetSizeofFixedInfo(getinfo)) ) { *pOutBufLen = GetSizeofFixedInfo(getinfo); KillFixedInfo(getinfo); return ERROR_BUFFER_OVERFLOW; }
ZeroMemory(pFixedInfo, *pOutBufLen); CopyMemory(pFixedInfo, getinfo, sizeof(FIXED_INFO));
DnsServerList = getinfo->DnsServerList.Next; CurrDnsServerList = &pFixedInfo->DnsServerList; CurrDnsServerList->Next = NULL; len = sizeof(FIXED_INFO);
while (DnsServerList != NULL) { CurrDnsServerList->Next = (PIP_ADDR_STRING)((ULONG_PTR)pFixedInfo + len); CopyMemory(CurrDnsServerList->Next, DnsServerList, sizeof(IP_ADDR_STRING)); CurrDnsServerList = CurrDnsServerList->Next; DnsServerList = DnsServerList->Next; len = len + sizeof(IP_ADDR_STRING); }
KillFixedInfo(getinfo); return ERROR_SUCCESS; }
except (EXCEPTION_EXECUTE_HANDLER) {
// printf("Exception %d \n", GetExceptionCode());
return ERROR_INVALID_PARAMETER; }}
/*******************************************************************************
* * GetSizeofAdapterInfo * * ENTRY * * EXIT * * RETURNS * * ASSUMES * ******************************************************************************/
DWORDGetSizeofAdapterInfo(PIP_ADAPTER_INFO pAdapterInfo){ DWORD size = 0;
while (pAdapterInfo != NULL) { size += sizeof(IP_ADAPTER_INFO) + (GetIPAddrStringLen(&pAdapterInfo->IpAddressList) * sizeof(IP_ADDR_STRING)) + (GetIPAddrStringLen(&pAdapterInfo->GatewayList) * sizeof(IP_ADDR_STRING)) + (GetIPAddrStringLen(&pAdapterInfo->SecondaryWinsServer) * sizeof(IP_ADDR_STRING)); pAdapterInfo = pAdapterInfo->Next; } return size;}
/*******************************************************************************
* GetSizeofAdapterAddresses * * This routine determines how much memory is used by data organized in a set * of IP_ADAPTER_ADDRESSES information. * * ENTRY pAdapterInfo - information to get total size for * * EXIT * * RETURNS amount of memory used * ******************************************************************************/
DWORD GetSizeofAdapterAddresses(PIP_ADAPTER_ADDRESSES pAdapterInfo){ DWORD size = 0; PIP_ADAPTER_UNICAST_ADDRESS pUAddress; PIP_ADAPTER_ANYCAST_ADDRESS pAAddress; PIP_ADAPTER_MULTICAST_ADDRESS pMAddress; PIP_ADAPTER_DNS_SERVER_ADDRESS pDAddress; PIP_ADAPTER_PREFIX pPrefix;
while (pAdapterInfo != NULL) { size += sizeof(IP_ADAPTER_ADDRESSES); size += (wcslen(pAdapterInfo->FriendlyName)+1) * sizeof(WCHAR); size += (wcslen(pAdapterInfo->Description)+1) * sizeof(WCHAR); size += (wcslen(pAdapterInfo->DnsSuffix)+1) * sizeof(WCHAR); size += (strlen(pAdapterInfo->AdapterName)+1);
size = ALIGN_UP(size, PVOID); for ( pUAddress = pAdapterInfo->FirstUnicastAddress; pUAddress; pUAddress = pUAddress->Next) { size += sizeof(IP_ADAPTER_UNICAST_ADDRESS) + ALIGN_UP(pUAddress->Address.iSockaddrLength, PVOID); } for ( pAAddress = pAdapterInfo->FirstAnycastAddress; pAAddress; pAAddress = pAAddress->Next) { size += sizeof(IP_ADAPTER_ANYCAST_ADDRESS) + ALIGN_UP(pAAddress->Address.iSockaddrLength, PVOID); } for ( pMAddress = pAdapterInfo->FirstMulticastAddress; pMAddress; pMAddress = pMAddress->Next) { size += sizeof(IP_ADAPTER_MULTICAST_ADDRESS) + ALIGN_UP(pMAddress->Address.iSockaddrLength, PVOID); } for ( pDAddress = pAdapterInfo->FirstDnsServerAddress; pDAddress; pDAddress = pDAddress->Next) { size += sizeof(IP_ADAPTER_DNS_SERVER_ADDRESS) + ALIGN_UP(pDAddress->Address.iSockaddrLength, PVOID); } for ( pPrefix = pAdapterInfo->FirstPrefix; pPrefix; pPrefix = pPrefix->Next) { size += sizeof(IP_ADAPTER_PREFIX) + ALIGN_UP(pPrefix->Address.iSockaddrLength, PVOID); } pAdapterInfo = pAdapterInfo->Next; } return size;}
/*******************************************************************************
* * GetSizeofPerAdapterInfo * * ENTRY * * EXIT * * RETURNS * * ASSUMES * ******************************************************************************/
DWORDGetSizeofPerAdapterInfo(PIP_PER_ADAPTER_INFO pPerAdapterInfo){ return (sizeof(IP_PER_ADAPTER_INFO) + (GetIPAddrStringLen(&pPerAdapterInfo->DnsServerList) * sizeof(IP_ADDR_STRING)));}
/*******************************************************************************
* * GetAdapterInfoEx * * ENTRY * * EXIT * * RETURNS * * ASSUMES * ******************************************************************************/
DWORDGetAdapterInfoEx(PIP_ADAPTER_INFO pAdapterInfo, PULONG pOutBufLen){
PIP_ADAPTER_INFO getinfo, orginfoptr, CurrAdapterInfo; PIP_ADDR_STRING IpAddressList, CurrIpAddressList; PIP_ADDR_STRING GatewayList, CurrGatewayList; PIP_ADDR_STRING SecondaryWinsServer, CurrSecondaryWinsServer; uint len;
if (pOutBufLen == NULL) { return ERROR_INVALID_PARAMETER; }
getinfo = GetAdapterInfo();
if (getinfo == NULL) { return ERROR_NO_DATA; }
orginfoptr = getinfo;
try { if (!pAdapterInfo || (*pOutBufLen < GetSizeofAdapterInfo(getinfo)) ) { *pOutBufLen = GetSizeofAdapterInfo(getinfo); KillAdapterInfo(getinfo); return ERROR_BUFFER_OVERFLOW; }
ZeroMemory(pAdapterInfo, *pOutBufLen);
CurrAdapterInfo = pAdapterInfo;
while (getinfo != NULL) { // pAdapterInfo->Next = (PIP_ADAPTER_INFO)((uint)pAdapterInfo + len);
// copy the adapter info structure
CopyMemory(CurrAdapterInfo, getinfo, sizeof(IP_ADAPTER_INFO));
// copy the IPAddressList & GatewayList
IpAddressList = getinfo->IpAddressList.Next; CurrIpAddressList = &CurrAdapterInfo->IpAddressList; CurrIpAddressList->Next = NULL; len = sizeof(IP_ADAPTER_INFO);
while (IpAddressList != NULL) { CurrIpAddressList->Next = (PIP_ADDR_STRING)((ULONG_PTR)CurrAdapterInfo + len); CopyMemory(CurrIpAddressList->Next, IpAddressList, sizeof(IP_ADDR_STRING)); CurrIpAddressList = CurrIpAddressList->Next; IpAddressList = IpAddressList->Next; len = len + sizeof(IP_ADDR_STRING); }
GatewayList = getinfo->GatewayList.Next; CurrGatewayList = &CurrAdapterInfo->GatewayList; CurrGatewayList->Next = NULL;
while (GatewayList != NULL) { CurrGatewayList->Next = (PIP_ADDR_STRING) ((ULONG_PTR)CurrAdapterInfo + len); CopyMemory(CurrGatewayList->Next, GatewayList, sizeof(IP_ADDR_STRING)); CurrGatewayList = CurrGatewayList->Next; GatewayList = GatewayList->Next; len = len + sizeof(IP_ADDR_STRING); }
SecondaryWinsServer = getinfo->SecondaryWinsServer.Next; CurrSecondaryWinsServer = &CurrAdapterInfo->SecondaryWinsServer; CurrSecondaryWinsServer->Next = NULL;
while (SecondaryWinsServer != NULL) { CurrSecondaryWinsServer->Next = (PIP_ADDR_STRING) ((ULONG_PTR)CurrAdapterInfo + len); CopyMemory(CurrSecondaryWinsServer->Next, SecondaryWinsServer, sizeof(IP_ADDR_STRING)); CurrSecondaryWinsServer = CurrSecondaryWinsServer->Next; SecondaryWinsServer = SecondaryWinsServer->Next; len = len + sizeof(IP_ADDR_STRING); }
pAdapterInfo = CurrAdapterInfo; CurrAdapterInfo->Next = (PIP_ADAPTER_INFO)((ULONG_PTR)CurrAdapterInfo + len); CurrAdapterInfo = CurrAdapterInfo->Next; getinfo = getinfo->Next; }
pAdapterInfo->Next = NULL; KillAdapterInfo(orginfoptr); return ERROR_SUCCESS; } except (EXCEPTION_EXECUTE_HANDLER) {
// printf("Exception %d \n", GetExceptionCode());
KillAdapterInfo(orginfoptr); return ERROR_INVALID_PARAMETER; }}
DWORDGetAdapterAddressesEx(ULONG Family, DWORD Flags, PIP_ADAPTER_ADDRESSES pAdapterInfo, PULONG pOutBufLen){
PIP_ADAPTER_ADDRESSES getinfo, orginfoptr, CurrAdapterInfo; PIP_ADAPTER_UNICAST_ADDRESS SrcUAddress, *pDestUAddress; PIP_ADAPTER_ANYCAST_ADDRESS SrcAAddress, *pDestAAddress; PIP_ADAPTER_MULTICAST_ADDRESS SrcMAddress, *pDestMAddress; PIP_ADAPTER_DNS_SERVER_ADDRESS SrcDAddress, *pDestDAddress; ULONG_PTR pDestBuffer; uint len; DWORD dwErr;
if (pOutBufLen == NULL) { return ERROR_INVALID_PARAMETER; }
dwErr = GetAdapterAddresses(Family, Flags, &getinfo); if (dwErr != NO_ERROR) { if (getinfo) { KillAdapterAddresses(getinfo); } return dwErr; }
if (getinfo == NULL) { return ERROR_NO_DATA; }
orginfoptr = getinfo;
try { if (!pAdapterInfo || (*pOutBufLen < GetSizeofAdapterAddresses(getinfo)) ) { *pOutBufLen = GetSizeofAdapterAddresses(getinfo); KillAdapterAddresses(getinfo); return ERROR_BUFFER_OVERFLOW; }
ZeroMemory(pAdapterInfo, *pOutBufLen);
CurrAdapterInfo = pAdapterInfo;
while (getinfo != NULL) { // pAdapterInfo->Next = (PIP_ADAPTER_ADDRESSES)((uint)pAdapterInfo + len);
// copy the adapter info structure
CopyMemory(CurrAdapterInfo, getinfo, sizeof(IP_ADAPTER_ADDRESSES)); pDestBuffer = (ULONG_PTR)CurrAdapterInfo + sizeof(IP_ADAPTER_ADDRESSES);
CurrAdapterInfo->FriendlyName = (PWCHAR)pDestBuffer; wcscpy(CurrAdapterInfo->FriendlyName, getinfo->FriendlyName); pDestBuffer += (wcslen(CurrAdapterInfo->FriendlyName)+1) * sizeof(WCHAR);
CurrAdapterInfo->Description = (PWCHAR)pDestBuffer; wcscpy(CurrAdapterInfo->Description, getinfo->Description); pDestBuffer += (wcslen(CurrAdapterInfo->Description)+1) * sizeof(WCHAR);
CurrAdapterInfo->DnsSuffix = (PWCHAR)pDestBuffer; wcscpy(CurrAdapterInfo->DnsSuffix, getinfo->DnsSuffix); pDestBuffer += (wcslen(CurrAdapterInfo->DnsSuffix)+1) * sizeof(WCHAR);
CurrAdapterInfo->AdapterName = (PCHAR)pDestBuffer; strcpy(CurrAdapterInfo->AdapterName, getinfo->AdapterName); pDestBuffer += (strlen(CurrAdapterInfo->AdapterName)+1);
pDestBuffer = ALIGN_UP_PTR(pDestBuffer, PVOID);
// copy the address lists
if (!(Flags & GAA_FLAG_SKIP_UNICAST)) { SrcUAddress = getinfo->FirstUnicastAddress; pDestUAddress = &CurrAdapterInfo->FirstUnicastAddress; while (SrcUAddress != NULL) { *pDestUAddress = (PIP_ADAPTER_UNICAST_ADDRESS)pDestBuffer;
// copy address structure
CopyMemory((PVOID)pDestBuffer, SrcUAddress, sizeof(IP_ADAPTER_UNICAST_ADDRESS)); pDestBuffer += sizeof(IP_ADAPTER_UNICAST_ADDRESS);
(*pDestUAddress)->Address.lpSockaddr = (LPSOCKADDR)pDestBuffer;
// copy sockaddr
CopyMemory((PVOID)pDestBuffer, SrcUAddress->Address.lpSockaddr, SrcUAddress->Address.iSockaddrLength); pDestBuffer += SrcUAddress->Address.iSockaddrLength; pDestBuffer = ALIGN_UP_PTR(pDestBuffer, PVOID);
pDestUAddress = &(*pDestUAddress)->Next; SrcUAddress = SrcUAddress->Next; } }
if (!(Flags & GAA_FLAG_SKIP_ANYCAST)) { SrcAAddress = getinfo->FirstAnycastAddress; pDestAAddress = &CurrAdapterInfo->FirstAnycastAddress; while (SrcAAddress != NULL) { *pDestAAddress = (PIP_ADAPTER_ANYCAST_ADDRESS)pDestBuffer;
// copy address structure
CopyMemory((PVOID)pDestBuffer, SrcAAddress, sizeof(IP_ADAPTER_ANYCAST_ADDRESS)); pDestBuffer += sizeof(IP_ADAPTER_ANYCAST_ADDRESS);
(*pDestAAddress)->Address.lpSockaddr = (LPSOCKADDR)pDestBuffer;
// copy sockaddr
CopyMemory((PVOID)pDestBuffer, SrcAAddress->Address.lpSockaddr, SrcAAddress->Address.iSockaddrLength); pDestBuffer += SrcAAddress->Address.iSockaddrLength; pDestBuffer = ALIGN_UP_PTR(pDestBuffer, PVOID);
pDestAAddress = &(*pDestAAddress)->Next; SrcAAddress = SrcAAddress->Next; } }
if (!(Flags & GAA_FLAG_SKIP_MULTICAST)) { SrcMAddress = getinfo->FirstMulticastAddress; pDestMAddress = &CurrAdapterInfo->FirstMulticastAddress; while (SrcMAddress != NULL) { *pDestMAddress = (PIP_ADAPTER_MULTICAST_ADDRESS)pDestBuffer;
// copy address structure
CopyMemory((PVOID)pDestBuffer, SrcMAddress, sizeof(IP_ADAPTER_MULTICAST_ADDRESS)); pDestBuffer += sizeof(IP_ADAPTER_MULTICAST_ADDRESS);
(*pDestMAddress)->Address.lpSockaddr = (LPSOCKADDR)pDestBuffer;
// copy sockaddr
CopyMemory((PVOID)pDestBuffer, SrcMAddress->Address.lpSockaddr, SrcMAddress->Address.iSockaddrLength); pDestBuffer += SrcMAddress->Address.iSockaddrLength; pDestBuffer = ALIGN_UP_PTR(pDestBuffer, PVOID);
pDestMAddress = &(*pDestMAddress)->Next; SrcMAddress = SrcMAddress->Next; } }
if (!(Flags & GAA_FLAG_SKIP_DNS_SERVER)) { SrcDAddress = getinfo->FirstDnsServerAddress; pDestDAddress = &CurrAdapterInfo->FirstDnsServerAddress; while (SrcDAddress != NULL) { *pDestDAddress = (PIP_ADAPTER_DNS_SERVER_ADDRESS)pDestBuffer;
// copy address structure
CopyMemory((PVOID)pDestBuffer, SrcDAddress, sizeof(IP_ADAPTER_DNS_SERVER_ADDRESS)); pDestBuffer += sizeof(IP_ADAPTER_DNS_SERVER_ADDRESS);
(*pDestDAddress)->Address.lpSockaddr = (LPSOCKADDR)pDestBuffer;
// copy sockaddr
CopyMemory((PVOID)pDestBuffer, SrcDAddress->Address.lpSockaddr, SrcDAddress->Address.iSockaddrLength); pDestBuffer += SrcDAddress->Address.iSockaddrLength; pDestBuffer = ALIGN_UP_PTR(pDestBuffer, PVOID);
pDestDAddress = &(*pDestDAddress)->Next; SrcDAddress = SrcDAddress->Next; } }
if (Flags & GAA_FLAG_INCLUDE_PREFIX) { PIP_ADAPTER_PREFIX SrcPrefix, *pDestPrefix;
SrcPrefix = getinfo->FirstPrefix; pDestPrefix = &CurrAdapterInfo->FirstPrefix; while (SrcPrefix != NULL) { *pDestPrefix = (PIP_ADAPTER_PREFIX)pDestBuffer;
// copy structure
CopyMemory((PVOID)pDestBuffer, SrcPrefix, sizeof(IP_ADAPTER_PREFIX)); pDestBuffer += sizeof(IP_ADAPTER_PREFIX); (*pDestPrefix)->Address.lpSockaddr = (LPSOCKADDR)pDestBuffer; // copy sockaddr
CopyMemory((PVOID)pDestBuffer, SrcPrefix->Address.lpSockaddr, SrcPrefix->Address.iSockaddrLength); pDestBuffer += SrcPrefix->Address.iSockaddrLength; pDestBuffer = ALIGN_UP_PTR(pDestBuffer, PVOID);
pDestPrefix = &(*pDestPrefix)->Next; SrcPrefix = SrcPrefix->Next; } }
pAdapterInfo = CurrAdapterInfo; CurrAdapterInfo->Next = (PIP_ADAPTER_ADDRESSES)pDestBuffer; CurrAdapterInfo = CurrAdapterInfo->Next; getinfo = getinfo->Next; }
pAdapterInfo->Next = NULL; KillAdapterAddresses(orginfoptr); return ERROR_SUCCESS; }
except (EXCEPTION_EXECUTE_HANDLER) {
// printf("Exception %d \n", GetExceptionCode());
KillAdapterAddresses(orginfoptr); return ERROR_INVALID_PARAMETER; }}
/*******************************************************************************
* * GetPerAdapterInfoEx * * ENTRY * * EXIT * * RETURNS * * ASSUMES * ******************************************************************************/
DWORDGetPerAdapterInfoEx(ULONG IfIndex, PIP_PER_ADAPTER_INFO pPerAdapterInfo, PULONG pOutBufLen )
{
PIP_PER_ADAPTER_INFO getinfo; PIP_ADDR_STRING DnsServerList, CurrDnsServerList; UINT len;
if (pOutBufLen == NULL) { return ERROR_INVALID_PARAMETER; }
getinfo = InternalGetPerAdapterInfo(IfIndex);
if (getinfo == NULL) { return ERROR_NO_DATA; }
try {
if (!pPerAdapterInfo || *pOutBufLen < GetSizeofPerAdapterInfo(getinfo)) {
*pOutBufLen = GetSizeofPerAdapterInfo(getinfo); KillPerAdapterInfo(getinfo); return ERROR_BUFFER_OVERFLOW; }
ZeroMemory(pPerAdapterInfo, *pOutBufLen); CopyMemory(pPerAdapterInfo, getinfo, sizeof(IP_PER_ADAPTER_INFO));
DnsServerList = getinfo->DnsServerList.Next; CurrDnsServerList = &pPerAdapterInfo->DnsServerList; CurrDnsServerList->Next = NULL; len = sizeof(IP_PER_ADAPTER_INFO);
while (DnsServerList != NULL) { CurrDnsServerList->Next = (PIP_ADDR_STRING)((ULONG_PTR)pPerAdapterInfo + len); CopyMemory(CurrDnsServerList->Next, DnsServerList, sizeof(IP_ADDR_STRING)); CurrDnsServerList = CurrDnsServerList->Next; DnsServerList = DnsServerList->Next; len = len + sizeof(IP_ADDR_STRING); }
KillPerAdapterInfo(getinfo); return ERROR_SUCCESS; }
except (EXCEPTION_EXECUTE_HANDLER) {
// printf("Exception %d \n", GetExceptionCode());
return ERROR_INVALID_PARAMETER; }}
/*******************************************************************************
* * ReleaseAdapterIpAddress * * ENTRY * * EXIT * * RETURNS * * ASSUMES * ******************************************************************************/
BOOLReleaseAdapterIpAddress(PIP_ADAPTER_INFO adapterInfo){
WCHAR wAdapter[MAX_ALLOWED_ADAPTER_NAME_LENGTH + 1]; DWORD status;
//
// check adapter pointer and name
//
if (adapterInfo == NULL || strcmp(adapterInfo->AdapterName, "") == 0) { return FALSE; }
//
// don't bother releasing if the address is already released (0.0.0.0).
//
if (ZERO_IP_ADDRESS(adapterInfo->IpAddressList.IpAddress.String)) { return FALSE; }
//
// convert adapter name to unicode and call DhcpReleaseParameters
//
ConvertOemToUnicode(adapterInfo->AdapterName, wAdapter);
status = DhcpReleaseParameters(wAdapter); TRACE_PRINT(("DhcpReleaseParameters(%ws) returns %d\n", wAdapter, status));
return status == ERROR_SUCCESS;}
/*******************************************************************************
* * RenewAdapterIpAddress * * ENTRY * * EXIT * * RETURNS * * ASSUMES * ******************************************************************************/
BOOLRenewAdapterIpAddress(PIP_ADAPTER_INFO adapterInfo){
WCHAR wAdapter[MAX_ALLOWED_ADAPTER_NAME_LENGTH + 1]; DWORD status;
//
// check adapter pointer and name
//
if (adapterInfo == NULL || strcmp(adapterInfo->AdapterName, "") == 0) { return FALSE; }
//
// convert adapter name to unicode and call DhcpAcquireParameters
//
ConvertOemToUnicode(adapterInfo->AdapterName, wAdapter);
status = DhcpAcquireParameters(wAdapter); TRACE_PRINT(("DhcpAcquireParameters(%ws) returns %d\n", wAdapter, status));
return status == ERROR_SUCCESS;}
/*******************************************************************************
* * SetAdapterIpAddress * * ENTRY * * EXIT * * RETURNS * * ASSUMES * ******************************************************************************/
DWORD APIENTRYSetAdapterIpAddress(LPSTR AdapterName, BOOL EnableDHCP, ULONG IPAddress, ULONG SubnetMask, ULONG DefaultGateway ){ DWORD dwEnableDHCP; DWORD dwDHCPEnabled; IP_ADDR_STRING IpAddrString; HKEY key; WCHAR Name[MAX_ADAPTER_NAME_LENGTH + 1]; CHAR String[20]; DWORD status;
if (!OpenAdapterKey(KEY_TCP, AdapterName, KEY_ALL_ACCESS, &key)) { return ERROR_CAN_NOT_COMPLETE; }
//
// We cannot handle netcards with multiple addresses,
// so check for that case up front
//
ZeroMemory(&IpAddrString, sizeof(IpAddrString)); if (!ReadRegistryIpAddrString(key, "IPAddress", &IpAddrString)) { return ERROR_CAN_NOT_COMPLETE; }
if (IpAddrString.Next) { PIP_ADDR_STRING p; for (p = IpAddrString.Next; p != NULL; p = IpAddrString.Next) { IpAddrString.Next = p->Next; ReleaseMemory(p); } return ERROR_TOO_MANY_NAMES; }
//
// If we're setting a static address, check to see if the adapter
// currently has a static or DHCP address.
//
if (!EnableDHCP) { if (!MyReadRegistryDword(key, "EnableDHCP", &dwDHCPEnabled)) {
//
// If an error occurs assume that DHCP was NOT enabled.
//
dwDHCPEnabled = FALSE; } }
//
// Update the address, mask, and gateway in the registry
//
dwEnableDHCP = !!EnableDHCP; WriteRegistryDword(key, "EnableDHCP", &dwEnableDHCP);
if (EnableDHCP) { IPAddress = SubnetMask = DefaultGateway = 0; }
ZeroMemory(String, sizeof(String)); lstrcpy(String, inet_ntoa(*(struct in_addr*)&IPAddress)); WriteRegistryMultiString(key, "IPAddress", String);
ZeroMemory(String, sizeof(String)); lstrcpy(String, inet_ntoa(*(struct in_addr*)&SubnetMask)); WriteRegistryMultiString(key, "SubnetMask", String);
ZeroMemory(String, sizeof(String)); if (DefaultGateway) { lstrcpy(String, inet_ntoa(*(struct in_addr*)&DefaultGateway)); } WriteRegistryMultiString(key, "DefaultGateway", String); RegCloseKey(key);
//
// Notify DHCP of the change
//
mbstowcs(Name, AdapterName, MAX_ADAPTER_NAME_LENGTH); if (EnableDHCP) { status = DhcpNotifyConfigChange(NULL, Name, FALSE, 0, 0, 0, DhcpEnable ); } else { //
// If the netcard previously had a static address we need
// to remove it before setting the new address.
//
if (!dwDHCPEnabled) { DhcpNotifyConfigChange(NULL, Name, TRUE, 0, 0, 0, IgnoreFlag ); }
status = DhcpNotifyConfigChange(NULL, Name, TRUE, 0, IPAddress, SubnetMask, DhcpDisable ); } return status;}
/*******************************************************************************
* * GetDnsServerList * * Gets DNS server List * * ENTRY * * EXIT * * RETURNS * * ASSUMES * ******************************************************************************/
BOOLGetDnsServerList(PIP_ADDR_STRING IpAddr){
PIP_ADAPTER_INFO adapterList; PIP_ADAPTER_INFO adapter; PIP_PER_ADAPTER_INFO perAdapterInfo = NULL; LONG err = ERROR_PATH_NOT_FOUND; HKEY key; BOOL ok;
TRACE_PRINT(("Entered GetDnsServerList\n"));
if ((adapterList = GetAdapterInfo()) != NULL) {
//
// scan the adapter list and try to insert DNS names to IpAddr
//
for (adapter = adapterList; adapter; adapter = adapter->Next) {
if (adapter->AdapterName[0] && OpenAdapterKey(KEY_TCP, adapter->AdapterName, KEY_READ, &key)) {
//
// DNS Server list: first NameServer and then DhcpNameServer
//
ok = ReadRegistryIpAddrString(key, TEXT("NameServer"), IpAddr);
if (!ok) {
ok = ReadRegistryIpAddrString(key, TEXT("DhcpNameServer"), IpAddr);
}
if (ok) { err = ERROR_SUCCESS; }
RegCloseKey(key);
} else { DEBUG_PRINT(("Cannot OpenAdapterKey KEY_TCP '%s', gle=%d\n", adapter->AdapterName, GetLastError())); } }
KillAdapterInfo(adapterList); } else { DEBUG_PRINT(("GetDnsServerList: GetAdapterInfo returns NULL\n")); }
TRACE_PRINT(("Exit GetDnsServerList\n"));
return (err == ERROR_SUCCESS);}
/*******************************************************************************
* GetAdapterOrderMap * * This routine builds an array which maps interface indices to their * respective adapter orderings. * * ENTRY nothing * * EXIT nothing * * RETURNS IP_ADAPTER_ORDER_MAP * ******************************************************************************/
PIP_ADAPTER_ORDER_MAP APIENTRY GetAdapterOrderMap(){ LPWSTR AdapterOrder = NULL; LPWSTR Adapter; PIP_ADAPTER_ORDER_MAP AdapterOrderMap = NULL; DWORD dwErr; DWORD dwType; DWORD dwSize; DWORD i; DWORD j; PIP_INTERFACE_INFO InterfaceInfo = NULL;
do {
//
// Retrieve the 'Bind' REG_MULTI_SZ from the Tcpip\Linkage key.
// This string-list tells us the current adapter order,
// with each entry being of the form \Device\{GUID}.
//
dwSize = 0; dwErr = RegQueryValueExW(TcpipLinkageKey, L"Bind", NULL, &dwType, NULL, &dwSize); if (dwErr != NO_ERROR || dwType != REG_MULTI_SZ) { break; } AdapterOrder = (LPWSTR)GrabMemory(dwSize); if (!AdapterOrder) { break; } dwErr = RegQueryValueExW(TcpipLinkageKey, L"Bind", NULL, &dwType, (LPBYTE)AdapterOrder, &dwSize); if (dwErr != NO_ERROR || dwType != REG_MULTI_SZ) { break; }
//
// Retrieve the IP interface information from TCP/IP.
// This information tells us the interface index
// for each adapter GUID,
//
dwSize = 0; dwErr = GetInterfaceInfo(NULL, &dwSize); if (dwErr != ERROR_INSUFFICIENT_BUFFER && dwErr != ERROR_BUFFER_OVERFLOW) { break; } InterfaceInfo = GrabMemory(dwSize); if (!InterfaceInfo) { break; } dwErr = GetInterfaceInfo(InterfaceInfo, &dwSize); if (dwErr != NO_ERROR) { break; }
//
// Construct a mapping from the interfaces in 'InterfaceInfo'
// to their positions in 'AdapterOrder'. In other words,
// construct an array of interface indices in which location i
// contains the index of the interface which is in location i
// in 'AdapterOrder'.
//
AdapterOrderMap = GrabMemory(FIELD_OFFSET(IP_ADAPTER_ORDER_MAP, AdapterOrder[InterfaceInfo->NumAdapters])); if (!AdapterOrderMap) { break; }
for (i = 0, Adapter = AdapterOrder; *Adapter && i < (DWORD)InterfaceInfo->NumAdapters; Adapter += lstrlenW(Adapter) + 1) {
//
// See if this is the NdiswanIp device, which corresponds to
// all Ndiswan interfaces. To implement adapter ordering
// for Ndiswan interfaces, we store their indices
// into successive locations in the adapter-order map
// based on the location of the string '\Device\NdiswanIp'
// in the adapter-order list.
//
if (lstrcmpiW(c_szDeviceNdiswanIp, Adapter) == 0) {
//
// This is the \Device\NdiswanIp entry, so list all Ndiswan
// interfaces in the adapter-order map now.
// Unfortunately, 'InterfaceInfo' does not tell us the type
// of each interface. In order to figure out which interfaces
// are Ndiswan interfaces, we enumerate all interfaces (again)
// and look for entries whose type is 'IF_TYPE_PPP'.
//
PMIB_IFTABLE IfTable; dwErr = AllocateAndGetIfTableFromStack(&IfTable, FALSE, GetProcessHeap(), 0, FALSE); if (dwErr == NO_ERROR) { for (j = 0; j < IfTable->dwNumEntries && i < (DWORD)InterfaceInfo->NumAdapters; j++) { if (IfTable->table[j].dwType == IF_TYPE_PPP) { AdapterOrderMap->AdapterOrder[i++] = IfTable->table[j].dwIndex; } } HeapFree(GetProcessHeap(), 0, IfTable); } continue; }
//
// Now handle all other interfaces by matching the GUID
// in 'Adapter' to the GUID of an interface in 'InterfaceInfo'.
// We then store the index of the interface found, if any,
// in the next location in 'AdapterOrderMap'.
//
for (j = 0; j < (DWORD)InterfaceInfo->NumAdapters; j++) { if (lstrcmpiW(InterfaceInfo->Adapter[j].Name + sizeof(c_szDeviceTcpip) - 1, Adapter + sizeof(c_szDevice) - 1) == 0) { AdapterOrderMap->AdapterOrder[i++] = InterfaceInfo->Adapter[j].Index; break; } } } AdapterOrderMap->NumAdapters = i; ReleaseMemory(InterfaceInfo); ReleaseMemory(AdapterOrder); return AdapterOrderMap;
} while(FALSE); if (InterfaceInfo) { ReleaseMemory(InterfaceInfo); } if (AdapterOrder) { ReleaseMemory(AdapterOrder); } return NULL;}
|
