2 * iphlpapi dll implementation
4 * Copyright (C) 2003,2006 Juan Lang
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
25 #include <sys/types.h>
26 #ifdef HAVE_NETINET_IN_H
27 # include <netinet/in.h>
29 #ifdef HAVE_ARPA_INET_H
30 # include <arpa/inet.h>
32 #ifdef HAVE_ARPA_NAMESER_H
33 # include <arpa/nameser.h>
39 #define NONAMELESSUNION
40 #define NONAMELESSSTRUCT
54 #include "wine/debug.h"
56 WINE_DEFAULT_DEBUG_CHANNEL(iphlpapi
);
59 #define IF_NAMESIZE 16
63 #define INADDR_NONE ~0UL
66 /* call res_init() just once because of a bug in Mac OS X 10.4 */
67 /* Call once per thread on systems that have per-thread _res. */
68 static void initialise_resolver(void)
70 if ((_res
.options
& RES_INIT
) == 0)
74 BOOL WINAPI
DllMain (HINSTANCE hinstDLL
, DWORD fdwReason
, LPVOID lpvReserved
)
77 case DLL_PROCESS_ATTACH
:
78 DisableThreadLibraryCalls( hinstDLL
);
81 case DLL_PROCESS_DETACH
:
87 /******************************************************************
88 * AddIPAddress (IPHLPAPI.@)
90 * Add an IP address to an adapter.
93 * Address [In] IP address to add to the adapter
94 * IpMask [In] subnet mask for the IP address
95 * IfIndex [In] adapter index to add the address
96 * NTEContext [Out] Net Table Entry (NTE) context for the IP address
97 * NTEInstance [Out] NTE instance for the IP address
101 * Failure: error code from winerror.h
104 * Stub. Currently returns ERROR_NOT_SUPPORTED.
106 DWORD WINAPI
AddIPAddress(IPAddr Address
, IPMask IpMask
, DWORD IfIndex
, PULONG NTEContext
, PULONG NTEInstance
)
109 return ERROR_NOT_SUPPORTED
;
113 /******************************************************************
114 * AllocateAndGetIfTableFromStack (IPHLPAPI.@)
116 * Get table of local interfaces.
117 * Like GetIfTable(), but allocate the returned table from heap.
120 * ppIfTable [Out] pointer into which the MIB_IFTABLE is
121 * allocated and returned.
122 * bOrder [In] whether to sort the table
123 * heap [In] heap from which the table is allocated
124 * flags [In] flags to HeapAlloc
127 * ERROR_INVALID_PARAMETER if ppIfTable is NULL, whatever
128 * GetIfTable() returns otherwise.
130 DWORD WINAPI
AllocateAndGetIfTableFromStack(PMIB_IFTABLE
*ppIfTable
,
131 BOOL bOrder
, HANDLE heap
, DWORD flags
)
135 TRACE("ppIfTable %p, bOrder %d, heap %p, flags 0x%08x\n", ppIfTable
,
136 bOrder
, heap
, flags
);
138 ret
= ERROR_INVALID_PARAMETER
;
142 ret
= GetIfTable(*ppIfTable
, &dwSize
, bOrder
);
143 if (ret
== ERROR_INSUFFICIENT_BUFFER
) {
144 *ppIfTable
= HeapAlloc(heap
, flags
, dwSize
);
145 ret
= GetIfTable(*ppIfTable
, &dwSize
, bOrder
);
148 TRACE("returning %d\n", ret
);
153 static int IpAddrTableSorter(const void *a
, const void *b
)
158 ret
= ((const MIB_IPADDRROW
*)a
)->dwAddr
- ((const MIB_IPADDRROW
*)b
)->dwAddr
;
165 /******************************************************************
166 * AllocateAndGetIpAddrTableFromStack (IPHLPAPI.@)
168 * Get interface-to-IP address mapping table.
169 * Like GetIpAddrTable(), but allocate the returned table from heap.
172 * ppIpAddrTable [Out] pointer into which the MIB_IPADDRTABLE is
173 * allocated and returned.
174 * bOrder [In] whether to sort the table
175 * heap [In] heap from which the table is allocated
176 * flags [In] flags to HeapAlloc
179 * ERROR_INVALID_PARAMETER if ppIpAddrTable is NULL, other error codes on
180 * failure, NO_ERROR on success.
182 DWORD WINAPI
AllocateAndGetIpAddrTableFromStack(PMIB_IPADDRTABLE
*ppIpAddrTable
,
183 BOOL bOrder
, HANDLE heap
, DWORD flags
)
187 TRACE("ppIpAddrTable %p, bOrder %d, heap %p, flags 0x%08x\n",
188 ppIpAddrTable
, bOrder
, heap
, flags
);
189 ret
= getIPAddrTable(ppIpAddrTable
, heap
, flags
);
191 qsort((*ppIpAddrTable
)->table
, (*ppIpAddrTable
)->dwNumEntries
,
192 sizeof(MIB_IPADDRROW
), IpAddrTableSorter
);
193 TRACE("returning %d\n", ret
);
198 /******************************************************************
199 * CancelIPChangeNotify (IPHLPAPI.@)
201 * Cancel a previous notification created by NotifyAddrChange or
205 * overlapped [In] overlapped structure that notifies the caller
212 * Stub, returns FALSE.
214 BOOL WINAPI
CancelIPChangeNotify(LPOVERLAPPED overlapped
)
216 FIXME("(overlapped %p): stub\n", overlapped
);
222 /******************************************************************
223 * CreateIpForwardEntry (IPHLPAPI.@)
225 * Create a route in the local computer's IP table.
228 * pRoute [In] new route information
232 * Failure: error code from winerror.h
235 * Stub, always returns NO_ERROR.
237 DWORD WINAPI
CreateIpForwardEntry(PMIB_IPFORWARDROW pRoute
)
239 FIXME("(pRoute %p): stub\n", pRoute
);
240 /* could use SIOCADDRT, not sure I want to */
245 /******************************************************************
246 * CreateIpNetEntry (IPHLPAPI.@)
248 * Create entry in the ARP table.
251 * pArpEntry [In] new ARP entry
255 * Failure: error code from winerror.h
258 * Stub, always returns NO_ERROR.
260 DWORD WINAPI
CreateIpNetEntry(PMIB_IPNETROW pArpEntry
)
262 FIXME("(pArpEntry %p)\n", pArpEntry
);
263 /* could use SIOCSARP on systems that support it, not sure I want to */
268 /******************************************************************
269 * CreateProxyArpEntry (IPHLPAPI.@)
271 * Create a Proxy ARP (PARP) entry for an IP address.
274 * dwAddress [In] IP address for which this computer acts as a proxy.
275 * dwMask [In] subnet mask for dwAddress
276 * dwIfIndex [In] interface index
280 * Failure: error code from winerror.h
283 * Stub, returns ERROR_NOT_SUPPORTED.
285 DWORD WINAPI
CreateProxyArpEntry(DWORD dwAddress
, DWORD dwMask
, DWORD dwIfIndex
)
287 FIXME("(dwAddress 0x%08x, dwMask 0x%08x, dwIfIndex 0x%08x): stub\n",
288 dwAddress
, dwMask
, dwIfIndex
);
289 return ERROR_NOT_SUPPORTED
;
293 /******************************************************************
294 * DeleteIPAddress (IPHLPAPI.@)
296 * Delete an IP address added with AddIPAddress().
299 * NTEContext [In] NTE context from AddIPAddress();
303 * Failure: error code from winerror.h
306 * Stub, returns ERROR_NOT_SUPPORTED.
308 DWORD WINAPI
DeleteIPAddress(ULONG NTEContext
)
310 FIXME("(NTEContext %d): stub\n", NTEContext
);
311 return ERROR_NOT_SUPPORTED
;
315 /******************************************************************
316 * DeleteIpForwardEntry (IPHLPAPI.@)
321 * pRoute [In] route to delete
325 * Failure: error code from winerror.h
328 * Stub, returns NO_ERROR.
330 DWORD WINAPI
DeleteIpForwardEntry(PMIB_IPFORWARDROW pRoute
)
332 FIXME("(pRoute %p): stub\n", pRoute
);
333 /* could use SIOCDELRT, not sure I want to */
338 /******************************************************************
339 * DeleteIpNetEntry (IPHLPAPI.@)
341 * Delete an ARP entry.
344 * pArpEntry [In] ARP entry to delete
348 * Failure: error code from winerror.h
351 * Stub, returns NO_ERROR.
353 DWORD WINAPI
DeleteIpNetEntry(PMIB_IPNETROW pArpEntry
)
355 FIXME("(pArpEntry %p): stub\n", pArpEntry
);
356 /* could use SIOCDARP on systems that support it, not sure I want to */
361 /******************************************************************
362 * DeleteProxyArpEntry (IPHLPAPI.@)
364 * Delete a Proxy ARP entry.
367 * dwAddress [In] IP address for which this computer acts as a proxy.
368 * dwMask [In] subnet mask for dwAddress
369 * dwIfIndex [In] interface index
373 * Failure: error code from winerror.h
376 * Stub, returns ERROR_NOT_SUPPORTED.
378 DWORD WINAPI
DeleteProxyArpEntry(DWORD dwAddress
, DWORD dwMask
, DWORD dwIfIndex
)
380 FIXME("(dwAddress 0x%08x, dwMask 0x%08x, dwIfIndex 0x%08x): stub\n",
381 dwAddress
, dwMask
, dwIfIndex
);
382 return ERROR_NOT_SUPPORTED
;
386 /******************************************************************
387 * EnableRouter (IPHLPAPI.@)
389 * Turn on ip forwarding.
393 * pOverlapped [In/Out] hEvent member should contain a valid handle.
396 * Success: ERROR_IO_PENDING
397 * Failure: error code from winerror.h
400 * Stub, returns ERROR_NOT_SUPPORTED.
402 DWORD WINAPI
EnableRouter(HANDLE
* pHandle
, OVERLAPPED
* pOverlapped
)
404 FIXME("(pHandle %p, pOverlapped %p): stub\n", pHandle
, pOverlapped
);
405 /* could echo "1" > /proc/net/sys/net/ipv4/ip_forward, not sure I want to
406 could map EACCESS to ERROR_ACCESS_DENIED, I suppose
408 return ERROR_NOT_SUPPORTED
;
412 /******************************************************************
413 * FlushIpNetTable (IPHLPAPI.@)
415 * Delete all ARP entries of an interface
418 * dwIfIndex [In] interface index
422 * Failure: error code from winerror.h
425 * Stub, returns ERROR_NOT_SUPPORTED.
427 DWORD WINAPI
FlushIpNetTable(DWORD dwIfIndex
)
429 FIXME("(dwIfIndex 0x%08x): stub\n", dwIfIndex
);
430 /* this flushes the arp cache of the given index */
431 return ERROR_NOT_SUPPORTED
;
435 /******************************************************************
436 * GetAdapterIndex (IPHLPAPI.@)
438 * Get interface index from its name.
441 * AdapterName [In] unicode string with the adapter name
442 * IfIndex [Out] returns found interface index
446 * Failure: error code from winerror.h
448 DWORD WINAPI
GetAdapterIndex(LPWSTR AdapterName
, PULONG IfIndex
)
450 char adapterName
[MAX_ADAPTER_NAME
];
454 TRACE("(AdapterName %p, IfIndex %p)\n", AdapterName
, IfIndex
);
455 /* The adapter name is guaranteed not to have any unicode characters, so
456 * this translation is never lossy */
457 for (i
= 0; i
< sizeof(adapterName
) - 1 && AdapterName
[i
]; i
++)
458 adapterName
[i
] = (char)AdapterName
[i
];
459 adapterName
[i
] = '\0';
460 ret
= getInterfaceIndexByName(adapterName
, IfIndex
);
461 TRACE("returning %d\n", ret
);
466 /******************************************************************
467 * GetAdaptersInfo (IPHLPAPI.@)
469 * Get information about adapters.
472 * pAdapterInfo [Out] buffer for adapter infos
473 * pOutBufLen [In] length of output buffer
477 * Failure: error code from winerror.h
479 DWORD WINAPI
GetAdaptersInfo(PIP_ADAPTER_INFO pAdapterInfo
, PULONG pOutBufLen
)
483 TRACE("pAdapterInfo %p, pOutBufLen %p\n", pAdapterInfo
, pOutBufLen
);
485 ret
= ERROR_INVALID_PARAMETER
;
487 DWORD numNonLoopbackInterfaces
= getNumNonLoopbackInterfaces();
489 if (numNonLoopbackInterfaces
> 0) {
490 DWORD numIPAddresses
= getNumIPAddresses();
493 /* This may slightly overestimate the amount of space needed, because
494 * the IP addresses include the loopback address, but it's easier
495 * to make sure there's more than enough space than to make sure there's
496 * precisely enough space.
498 size
= sizeof(IP_ADAPTER_INFO
) * numNonLoopbackInterfaces
;
499 size
+= numIPAddresses
* sizeof(IP_ADDR_STRING
);
500 if (!pAdapterInfo
|| *pOutBufLen
< size
) {
502 ret
= ERROR_BUFFER_OVERFLOW
;
505 InterfaceIndexTable
*table
= NULL
;
506 PMIB_IPADDRTABLE ipAddrTable
= NULL
;
507 PMIB_IPFORWARDTABLE routeTable
= NULL
;
509 ret
= getIPAddrTable(&ipAddrTable
, GetProcessHeap(), 0);
511 ret
= AllocateAndGetIpForwardTableFromStack(&routeTable
, FALSE
, GetProcessHeap(), 0);
513 table
= getNonLoopbackInterfaceIndexTable();
515 size
= sizeof(IP_ADAPTER_INFO
) * table
->numIndexes
;
516 size
+= ipAddrTable
->dwNumEntries
* sizeof(IP_ADDR_STRING
);
517 if (*pOutBufLen
< size
) {
519 ret
= ERROR_INSUFFICIENT_BUFFER
;
524 BOOL winsEnabled
= FALSE
;
525 IP_ADDRESS_STRING primaryWINS
, secondaryWINS
;
526 PIP_ADDR_STRING nextIPAddr
= (PIP_ADDR_STRING
)((LPBYTE
)pAdapterInfo
527 + numNonLoopbackInterfaces
* sizeof(IP_ADAPTER_INFO
));
529 memset(pAdapterInfo
, 0, size
);
530 /* @@ Wine registry key: HKCU\Software\Wine\Network */
531 if (RegOpenKeyA(HKEY_CURRENT_USER
, "Software\\Wine\\Network",
532 &hKey
) == ERROR_SUCCESS
) {
533 DWORD size
= sizeof(primaryWINS
.String
);
536 RegQueryValueExA(hKey
, "WinsServer", NULL
, NULL
,
537 (LPBYTE
)primaryWINS
.String
, &size
);
538 addr
= inet_addr(primaryWINS
.String
);
539 if (addr
!= INADDR_NONE
&& addr
!= INADDR_ANY
)
541 size
= sizeof(secondaryWINS
.String
);
542 RegQueryValueExA(hKey
, "BackupWinsServer", NULL
, NULL
,
543 (LPBYTE
)secondaryWINS
.String
, &size
);
544 addr
= inet_addr(secondaryWINS
.String
);
545 if (addr
!= INADDR_NONE
&& addr
!= INADDR_ANY
)
549 for (ndx
= 0; ndx
< table
->numIndexes
; ndx
++) {
550 PIP_ADAPTER_INFO ptr
= &pAdapterInfo
[ndx
];
552 PIP_ADDR_STRING currentIPAddr
= &ptr
->IpAddressList
;
553 BOOL firstIPAddr
= TRUE
;
555 /* on Win98 this is left empty, but whatever */
556 getInterfaceNameByIndex(table
->indexes
[ndx
], ptr
->AdapterName
);
557 getInterfaceNameByIndex(table
->indexes
[ndx
], ptr
->Description
);
558 ptr
->AddressLength
= sizeof(ptr
->Address
);
559 getInterfacePhysicalByIndex(table
->indexes
[ndx
],
560 &ptr
->AddressLength
, ptr
->Address
, &ptr
->Type
);
561 ptr
->Index
= table
->indexes
[ndx
];
562 for (i
= 0; i
< ipAddrTable
->dwNumEntries
; i
++) {
563 if (ipAddrTable
->table
[i
].dwIndex
== ptr
->Index
) {
565 toIPAddressString(ipAddrTable
->table
[i
].dwAddr
,
566 ptr
->IpAddressList
.IpAddress
.String
);
567 toIPAddressString(ipAddrTable
->table
[i
].dwMask
,
568 ptr
->IpAddressList
.IpMask
.String
);
572 currentIPAddr
->Next
= nextIPAddr
;
573 currentIPAddr
= nextIPAddr
;
574 toIPAddressString(ipAddrTable
->table
[i
].dwAddr
,
575 currentIPAddr
->IpAddress
.String
);
576 toIPAddressString(ipAddrTable
->table
[i
].dwMask
,
577 currentIPAddr
->IpMask
.String
);
582 /* Find first router through this interface, which we'll assume
583 * is the default gateway for this adapter */
584 for (i
= 0; i
< routeTable
->dwNumEntries
; i
++)
585 if (routeTable
->table
[i
].dwForwardIfIndex
== ptr
->Index
586 && routeTable
->table
[i
].dwForwardType
==
587 MIB_IPROUTE_TYPE_INDIRECT
)
588 toIPAddressString(routeTable
->table
[i
].dwForwardNextHop
,
589 ptr
->GatewayList
.IpAddress
.String
);
591 ptr
->HaveWins
= TRUE
;
592 memcpy(ptr
->PrimaryWinsServer
.IpAddress
.String
,
593 primaryWINS
.String
, sizeof(primaryWINS
.String
));
594 memcpy(ptr
->SecondaryWinsServer
.IpAddress
.String
,
595 secondaryWINS
.String
, sizeof(secondaryWINS
.String
));
597 if (ndx
< table
->numIndexes
- 1)
598 ptr
->Next
= &pAdapterInfo
[ndx
+ 1];
604 HeapFree(GetProcessHeap(), 0, table
);
607 ret
= ERROR_OUTOFMEMORY
;
608 HeapFree(GetProcessHeap(), 0, routeTable
);
609 HeapFree(GetProcessHeap(), 0, ipAddrTable
);
615 TRACE("returning %d\n", ret
);
619 static DWORD
typeFromMibType(DWORD mib_type
)
623 case MIB_IF_TYPE_ETHERNET
: return IF_TYPE_ETHERNET_CSMACD
;
624 case MIB_IF_TYPE_TOKENRING
: return IF_TYPE_ISO88025_TOKENRING
;
625 case MIB_IF_TYPE_PPP
: return IF_TYPE_PPP
;
626 case MIB_IF_TYPE_LOOPBACK
: return IF_TYPE_SOFTWARE_LOOPBACK
;
627 default: return IF_TYPE_OTHER
;
631 static DWORD
connectionTypeFromMibType(DWORD mib_type
)
635 case MIB_IF_TYPE_PPP
: return NET_IF_CONNECTION_DEMAND
;
636 case MIB_IF_TYPE_SLIP
: return NET_IF_CONNECTION_DEMAND
;
637 default: return NET_IF_CONNECTION_DEDICATED
;
641 static ULONG
v4addressesFromIndex(DWORD index
, DWORD
**addrs
, ULONG
*num_addrs
)
647 if ((ret
= getIPAddrTable(&at
, GetProcessHeap(), 0))) return ret
;
648 for (i
= 0; i
< at
->dwNumEntries
; i
++)
650 if (at
->table
[i
].dwIndex
== index
) (*num_addrs
)++;
652 if (!(*addrs
= HeapAlloc(GetProcessHeap(), 0, *num_addrs
* sizeof(DWORD
))))
654 HeapFree(GetProcessHeap(), 0, at
);
655 return ERROR_OUTOFMEMORY
;
657 for (i
= 0, j
= 0; i
< at
->dwNumEntries
; i
++)
659 if (at
->table
[i
].dwIndex
== index
) (*addrs
)[j
++] = at
->table
[i
].dwAddr
;
661 HeapFree(GetProcessHeap(), 0, at
);
662 return ERROR_SUCCESS
;
665 static char *debugstr_ipv4(const in_addr_t
*in_addr
, char *buf
)
670 for (addrp
= (const BYTE
*)in_addr
;
671 addrp
- (const BYTE
*)in_addr
< sizeof(*in_addr
);
674 if (addrp
== (const BYTE
*)in_addr
+ sizeof(*in_addr
) - 1)
675 sprintf(p
, "%d", *addrp
);
677 p
+= sprintf(p
, "%d.", *addrp
);
682 static char *debugstr_ipv6(const struct WS_sockaddr_in6
*sin
, char *buf
)
684 const IN6_ADDR
*addr
= &sin
->sin6_addr
;
687 BOOL in_zero
= FALSE
;
689 for (i
= 0; i
< 7; i
++)
691 if (!addr
->u
.Word
[i
])
703 p
+= sprintf(p
, "%x:", ntohs(addr
->u
.Word
[i
]));
707 sprintf(p
, "%x", ntohs(addr
->u
.Word
[7]));
711 static ULONG
count_v4_gateways(DWORD index
, PMIB_IPFORWARDTABLE routeTable
)
713 DWORD i
, num_gateways
= 0;
715 for (i
= 0; i
< routeTable
->dwNumEntries
; i
++)
717 if (routeTable
->table
[i
].dwForwardIfIndex
== index
&&
718 routeTable
->table
[i
].dwForwardType
== MIB_IPROUTE_TYPE_INDIRECT
)
724 static PMIB_IPFORWARDROW
findIPv4Gateway(DWORD index
,
725 PMIB_IPFORWARDTABLE routeTable
)
728 PMIB_IPFORWARDROW row
= NULL
;
730 for (i
= 0; !row
&& i
< routeTable
->dwNumEntries
; i
++)
732 if (routeTable
->table
[i
].dwForwardIfIndex
== index
&&
733 routeTable
->table
[i
].dwForwardType
== MIB_IPROUTE_TYPE_INDIRECT
)
734 row
= &routeTable
->table
[i
];
739 static ULONG
adapterAddressesFromIndex(ULONG family
, ULONG flags
, DWORD index
,
740 IP_ADAPTER_ADDRESSES
*aa
, ULONG
*size
)
742 ULONG ret
= ERROR_SUCCESS
, i
, num_v4addrs
= 0, num_v4_gateways
= 0, num_v6addrs
= 0, total_size
;
743 DWORD
*v4addrs
= NULL
;
744 SOCKET_ADDRESS
*v6addrs
= NULL
;
745 PMIB_IPFORWARDTABLE routeTable
= NULL
;
747 if (family
== WS_AF_INET
)
749 if (!(flags
& GAA_FLAG_SKIP_UNICAST
))
750 ret
= v4addressesFromIndex(index
, &v4addrs
, &num_v4addrs
);
751 if (!ret
&& flags
& GAA_FLAG_INCLUDE_ALL_GATEWAYS
)
753 ret
= AllocateAndGetIpForwardTableFromStack(&routeTable
, FALSE
,
754 GetProcessHeap(), 0);
756 num_v4_gateways
= count_v4_gateways(index
, routeTable
);
759 else if (family
== WS_AF_INET6
)
761 if (!(flags
& GAA_FLAG_SKIP_UNICAST
))
762 ret
= v6addressesFromIndex(index
, &v6addrs
, &num_v6addrs
);
764 else if (family
== WS_AF_UNSPEC
)
766 if (!(flags
& GAA_FLAG_SKIP_UNICAST
))
767 ret
= v4addressesFromIndex(index
, &v4addrs
, &num_v4addrs
);
768 if (!ret
&& flags
& GAA_FLAG_INCLUDE_ALL_GATEWAYS
)
770 ret
= AllocateAndGetIpForwardTableFromStack(&routeTable
, FALSE
,
771 GetProcessHeap(), 0);
774 num_v4_gateways
= count_v4_gateways(index
, routeTable
);
775 if (!(flags
& GAA_FLAG_SKIP_UNICAST
))
776 ret
= v6addressesFromIndex(index
, &v6addrs
, &num_v6addrs
);
782 FIXME("address family %u unsupported\n", family
);
787 HeapFree(GetProcessHeap(), 0, routeTable
);
791 total_size
= sizeof(IP_ADAPTER_ADDRESSES
);
792 total_size
+= IF_NAMESIZE
;
793 total_size
+= IF_NAMESIZE
* sizeof(WCHAR
);
794 if (!(flags
& GAA_FLAG_SKIP_FRIENDLY_NAME
))
795 total_size
+= IF_NAMESIZE
* sizeof(WCHAR
);
796 total_size
+= sizeof(IP_ADAPTER_UNICAST_ADDRESS
) * num_v4addrs
;
797 total_size
+= sizeof(struct sockaddr_in
) * num_v4addrs
;
798 total_size
+= (sizeof(IP_ADAPTER_GATEWAY_ADDRESS
) + sizeof(SOCKADDR_IN
)) * num_v4_gateways
;
799 total_size
+= sizeof(IP_ADAPTER_UNICAST_ADDRESS
) * num_v6addrs
;
800 total_size
+= sizeof(SOCKET_ADDRESS
) * num_v6addrs
;
801 for (i
= 0; i
< num_v6addrs
; i
++)
802 total_size
+= v6addrs
[i
].iSockaddrLength
;
804 if (aa
&& *size
>= total_size
)
806 char name
[IF_NAMESIZE
], *ptr
= (char *)aa
+ sizeof(IP_ADAPTER_ADDRESSES
), *src
;
808 DWORD buflen
, type
, status
;
810 memset(aa
, 0, sizeof(IP_ADAPTER_ADDRESSES
));
811 aa
->u
.s
.Length
= sizeof(IP_ADAPTER_ADDRESSES
);
812 aa
->u
.s
.IfIndex
= index
;
814 getInterfaceNameByIndex(index
, name
);
815 memcpy(ptr
, name
, IF_NAMESIZE
);
816 aa
->AdapterName
= ptr
;
818 if (!(flags
& GAA_FLAG_SKIP_FRIENDLY_NAME
))
820 aa
->FriendlyName
= (WCHAR
*)ptr
;
821 for (src
= name
, dst
= (WCHAR
*)ptr
; *src
; src
++, dst
++)
826 aa
->Description
= (WCHAR
*)ptr
;
827 for (src
= name
, dst
= (WCHAR
*)ptr
; *src
; src
++, dst
++)
832 TRACE("%s: %d IPv4 addresses, %d IPv6 addresses:\n", name
, num_v4addrs
,
836 PMIB_IPFORWARDROW adapterRow
;
838 if ((adapterRow
= findIPv4Gateway(index
, routeTable
)))
840 PIP_ADAPTER_GATEWAY_ADDRESS gw
;
843 gw
= (PIP_ADAPTER_GATEWAY_ADDRESS
)ptr
;
844 aa
->FirstGatewayAddress
= gw
;
846 gw
->u
.s
.Length
= sizeof(IP_ADAPTER_GATEWAY_ADDRESS
);
847 ptr
+= sizeof(IP_ADAPTER_GATEWAY_ADDRESS
);
848 sin
= (PSOCKADDR_IN
)ptr
;
849 sin
->sin_family
= AF_INET
;
851 memcpy(&sin
->sin_addr
, &adapterRow
->dwForwardNextHop
,
853 gw
->Address
.lpSockaddr
= (LPSOCKADDR
)sin
;
854 gw
->Address
.iSockaddrLength
= sizeof(SOCKADDR_IN
);
856 ptr
+= sizeof(SOCKADDR_IN
);
861 IP_ADAPTER_UNICAST_ADDRESS
*ua
;
862 struct sockaddr_in
*sa
;
863 aa
->Flags
|= IP_ADAPTER_IPV4_ENABLED
;
864 ua
= aa
->FirstUnicastAddress
= (IP_ADAPTER_UNICAST_ADDRESS
*)ptr
;
865 for (i
= 0; i
< num_v4addrs
; i
++)
869 memset(ua
, 0, sizeof(IP_ADAPTER_UNICAST_ADDRESS
));
870 ua
->u
.s
.Length
= sizeof(IP_ADAPTER_UNICAST_ADDRESS
);
871 ua
->Address
.iSockaddrLength
= sizeof(struct sockaddr_in
);
872 ua
->Address
.lpSockaddr
= (SOCKADDR
*)((char *)ua
+ ua
->u
.s
.Length
);
874 sa
= (struct sockaddr_in
*)ua
->Address
.lpSockaddr
;
875 sa
->sin_family
= AF_INET
;
876 sa
->sin_addr
.s_addr
= v4addrs
[i
];
878 TRACE("IPv4 %d/%d: %s\n", i
+ 1, num_v4addrs
,
879 debugstr_ipv4(&sa
->sin_addr
.s_addr
, addr_buf
));
881 ptr
+= ua
->u
.s
.Length
+ ua
->Address
.iSockaddrLength
;
882 if (i
< num_v4addrs
- 1)
884 ua
->Next
= (IP_ADAPTER_UNICAST_ADDRESS
*)ptr
;
891 IP_ADAPTER_UNICAST_ADDRESS
*ua
;
892 struct WS_sockaddr_in6
*sa
;
894 aa
->Flags
|= IP_ADAPTER_IPV6_ENABLED
;
895 if (aa
->FirstUnicastAddress
)
897 for (ua
= aa
->FirstUnicastAddress
; ua
->Next
; ua
= ua
->Next
)
899 ua
->Next
= (IP_ADAPTER_UNICAST_ADDRESS
*)ptr
;
900 ua
= (IP_ADAPTER_UNICAST_ADDRESS
*)ptr
;
903 ua
= aa
->FirstUnicastAddress
= (IP_ADAPTER_UNICAST_ADDRESS
*)ptr
;
904 for (i
= 0; i
< num_v6addrs
; i
++)
908 memset(ua
, 0, sizeof(IP_ADAPTER_UNICAST_ADDRESS
));
909 ua
->u
.s
.Length
= sizeof(IP_ADAPTER_UNICAST_ADDRESS
);
910 ua
->Address
.iSockaddrLength
= v6addrs
[i
].iSockaddrLength
;
911 ua
->Address
.lpSockaddr
= (SOCKADDR
*)((char *)ua
+ ua
->u
.s
.Length
);
913 sa
= (struct WS_sockaddr_in6
*)ua
->Address
.lpSockaddr
;
914 memcpy(sa
, v6addrs
[i
].lpSockaddr
, sizeof(*sa
));
915 TRACE("IPv6 %d/%d: %s\n", i
+ 1, num_v6addrs
,
916 debugstr_ipv6(sa
, addr_buf
));
918 ptr
+= ua
->u
.s
.Length
+ ua
->Address
.iSockaddrLength
;
919 if (i
< num_v6addrs
- 1)
921 ua
->Next
= (IP_ADAPTER_UNICAST_ADDRESS
*)ptr
;
927 buflen
= MAX_INTERFACE_PHYSADDR
;
928 getInterfacePhysicalByIndex(index
, &buflen
, aa
->PhysicalAddress
, &type
);
929 aa
->PhysicalAddressLength
= buflen
;
930 aa
->IfType
= typeFromMibType(type
);
931 aa
->ConnectionType
= connectionTypeFromMibType(type
);
933 getInterfaceMtuByName(name
, &aa
->Mtu
);
935 getInterfaceStatusByName(name
, &status
);
936 if (status
== MIB_IF_OPER_STATUS_OPERATIONAL
) aa
->OperStatus
= IfOperStatusUp
;
937 else if (status
== MIB_IF_OPER_STATUS_NON_OPERATIONAL
) aa
->OperStatus
= IfOperStatusDown
;
938 else aa
->OperStatus
= IfOperStatusUnknown
;
941 HeapFree(GetProcessHeap(), 0, routeTable
);
942 HeapFree(GetProcessHeap(), 0, v6addrs
);
943 HeapFree(GetProcessHeap(), 0, v4addrs
);
944 return ERROR_SUCCESS
;
947 static ULONG
get_dns_server_addresses(PIP_ADAPTER_DNS_SERVER_ADDRESS address
, ULONG
*len
)
951 initialise_resolver();
952 /* FIXME: no support for IPv6 DNS server addresses. Doing so requires
953 * sizeof SOCKADDR_STORAGE instead, and using _res._u._ext.nsaddrs when
956 size
= _res
.nscount
* (sizeof(IP_ADAPTER_DNS_SERVER_ADDRESS
) + sizeof(SOCKADDR
));
957 if (!address
|| *len
< size
)
960 return ERROR_BUFFER_OVERFLOW
;
963 if (_res
.nscount
> 0)
965 PIP_ADAPTER_DNS_SERVER_ADDRESS addr
;
968 for (i
= 0, addr
= address
; i
< _res
.nscount
&& addr
;
969 i
++, addr
= addr
->Next
)
973 addr
->Address
.iSockaddrLength
= sizeof(SOCKADDR
);
974 addr
->Address
.lpSockaddr
=
975 (LPSOCKADDR
)((PBYTE
)addr
+ sizeof(IP_ADAPTER_DNS_SERVER_ADDRESS
));
976 sin
= (SOCKADDR_IN
*)addr
->Address
.lpSockaddr
;
977 sin
->sin_family
= WS_AF_INET
;
978 sin
->sin_port
= _res
.nsaddr_list
[i
].sin_port
;
979 memcpy(&sin
->sin_addr
, &_res
.nsaddr_list
[i
].sin_addr
, sizeof(sin
->sin_addr
));
980 if (i
== _res
.nscount
- 1)
984 (PIP_ADAPTER_DNS_SERVER_ADDRESS
)((PBYTE
)addr
+
985 sizeof(IP_ADAPTER_DNS_SERVER_ADDRESS
) + sizeof(SOCKADDR
));
988 return ERROR_SUCCESS
;
991 static BOOL
is_ip_address_string(const char *str
)
996 ret
= inet_aton(str
, &in
);
1000 static ULONG
get_dns_suffix(WCHAR
*suffix
, ULONG
*len
)
1003 char *found_suffix
= NULL
;
1005 initialise_resolver();
1006 /* Always return a NULL-terminated string, even if it's empty. */
1007 size
= sizeof(WCHAR
);
1008 for (i
= 0, found_suffix
= NULL
;
1009 !found_suffix
&& i
< MAXDNSRCH
+ 1 && _res
.dnsrch
[i
]; i
++)
1011 /* This uses a heuristic to select a DNS suffix:
1012 * the first, non-IP address string is selected.
1014 if (!is_ip_address_string(_res
.dnsrch
[i
]))
1015 found_suffix
= _res
.dnsrch
[i
];
1018 size
+= strlen(found_suffix
) * sizeof(WCHAR
);
1019 if (!suffix
|| *len
< size
)
1022 return ERROR_BUFFER_OVERFLOW
;
1029 for (p
= found_suffix
; *p
; p
++)
1033 return ERROR_SUCCESS
;
1036 ULONG WINAPI
GetAdaptersAddresses(ULONG family
, ULONG flags
, PVOID reserved
,
1037 PIP_ADAPTER_ADDRESSES aa
, PULONG buflen
)
1039 InterfaceIndexTable
*table
;
1040 ULONG i
, size
, dns_server_size
, dns_suffix_size
, total_size
, ret
= ERROR_NO_DATA
;
1042 TRACE("(%d, %08x, %p, %p, %p)\n", family
, flags
, reserved
, aa
, buflen
);
1044 if (!buflen
) return ERROR_INVALID_PARAMETER
;
1046 table
= getInterfaceIndexTable();
1047 if (!table
|| !table
->numIndexes
)
1049 HeapFree(GetProcessHeap(), 0, table
);
1050 return ERROR_NO_DATA
;
1053 for (i
= 0; i
< table
->numIndexes
; i
++)
1056 if ((ret
= adapterAddressesFromIndex(family
, flags
, table
->indexes
[i
], NULL
, &size
)))
1058 HeapFree(GetProcessHeap(), 0, table
);
1063 if (!(flags
& GAA_FLAG_SKIP_DNS_SERVER
))
1065 /* Since DNS servers aren't really per adapter, get enough space for a
1066 * single copy of them.
1068 get_dns_server_addresses(NULL
, &dns_server_size
);
1069 total_size
+= dns_server_size
;
1071 /* Since DNS suffix also isn't really per adapter, get enough space for a
1072 * single copy of it.
1074 get_dns_suffix(NULL
, &dns_suffix_size
);
1075 total_size
+= dns_suffix_size
;
1076 if (aa
&& *buflen
>= total_size
)
1078 ULONG bytes_left
= size
= total_size
;
1079 PIP_ADAPTER_ADDRESSES first_aa
= aa
;
1080 PIP_ADAPTER_DNS_SERVER_ADDRESS firstDns
;
1083 for (i
= 0; i
< table
->numIndexes
; i
++)
1085 if ((ret
= adapterAddressesFromIndex(family
, flags
, table
->indexes
[i
], aa
, &size
)))
1087 HeapFree(GetProcessHeap(), 0, table
);
1090 if (i
< table
->numIndexes
- 1)
1092 aa
->Next
= (IP_ADAPTER_ADDRESSES
*)((char *)aa
+ size
);
1094 size
= bytes_left
-= size
;
1097 if (!(flags
& GAA_FLAG_SKIP_DNS_SERVER
))
1099 firstDns
= (PIP_ADAPTER_DNS_SERVER_ADDRESS
)((BYTE
*)first_aa
+ total_size
- dns_server_size
- dns_suffix_size
);
1100 get_dns_server_addresses(firstDns
, &dns_server_size
);
1101 for (aa
= first_aa
; aa
; aa
= aa
->Next
)
1103 if (aa
->IfType
!= IF_TYPE_SOFTWARE_LOOPBACK
&& aa
->OperStatus
== IfOperStatusUp
)
1104 aa
->FirstDnsServerAddress
= firstDns
;
1108 dnsSuffix
= (WCHAR
*)((BYTE
*)aa
+ total_size
- dns_suffix_size
);
1109 get_dns_suffix(dnsSuffix
, &dns_suffix_size
);
1110 for (; aa
; aa
= aa
->Next
)
1112 if (aa
->IfType
!= IF_TYPE_SOFTWARE_LOOPBACK
&& aa
->OperStatus
== IfOperStatusUp
)
1113 aa
->DnsSuffix
= dnsSuffix
;
1115 aa
->DnsSuffix
= (WCHAR
*)((BYTE
*)dnsSuffix
+ dns_suffix_size
- 2);
1117 ret
= ERROR_SUCCESS
;
1120 ret
= ERROR_BUFFER_OVERFLOW
;
1121 *buflen
= total_size
;
1123 TRACE("num adapters %u\n", table
->numIndexes
);
1124 HeapFree(GetProcessHeap(), 0, table
);
1128 /******************************************************************
1129 * GetBestInterface (IPHLPAPI.@)
1131 * Get the interface, with the best route for the given IP address.
1134 * dwDestAddr [In] IP address to search the interface for
1135 * pdwBestIfIndex [Out] found best interface
1139 * Failure: error code from winerror.h
1141 DWORD WINAPI
GetBestInterface(IPAddr dwDestAddr
, PDWORD pdwBestIfIndex
)
1143 struct WS_sockaddr_in sa_in
;
1144 memset(&sa_in
, 0, sizeof(sa_in
));
1145 sa_in
.sin_family
= AF_INET
;
1146 sa_in
.sin_addr
.S_un
.S_addr
= dwDestAddr
;
1147 return GetBestInterfaceEx((struct WS_sockaddr
*)&sa_in
, pdwBestIfIndex
);
1150 /******************************************************************
1151 * GetBestInterfaceEx (IPHLPAPI.@)
1153 * Get the interface, with the best route for the given IP address.
1156 * dwDestAddr [In] IP address to search the interface for
1157 * pdwBestIfIndex [Out] found best interface
1161 * Failure: error code from winerror.h
1163 DWORD WINAPI
GetBestInterfaceEx(struct WS_sockaddr
*pDestAddr
, PDWORD pdwBestIfIndex
)
1167 TRACE("pDestAddr %p, pdwBestIfIndex %p\n", pDestAddr
, pdwBestIfIndex
);
1168 if (!pDestAddr
|| !pdwBestIfIndex
)
1169 ret
= ERROR_INVALID_PARAMETER
;
1171 MIB_IPFORWARDROW ipRow
;
1173 if (pDestAddr
->sa_family
== AF_INET
) {
1174 ret
= GetBestRoute(((struct WS_sockaddr_in
*)pDestAddr
)->sin_addr
.S_un
.S_addr
, 0, &ipRow
);
1175 if (ret
== ERROR_SUCCESS
)
1176 *pdwBestIfIndex
= ipRow
.dwForwardIfIndex
;
1178 FIXME("address family %d not supported\n", pDestAddr
->sa_family
);
1179 ret
= ERROR_NOT_SUPPORTED
;
1182 TRACE("returning %d\n", ret
);
1187 /******************************************************************
1188 * GetBestRoute (IPHLPAPI.@)
1190 * Get the best route for the given IP address.
1193 * dwDestAddr [In] IP address to search the best route for
1194 * dwSourceAddr [In] optional source IP address
1195 * pBestRoute [Out] found best route
1199 * Failure: error code from winerror.h
1201 DWORD WINAPI
GetBestRoute(DWORD dwDestAddr
, DWORD dwSourceAddr
, PMIB_IPFORWARDROW pBestRoute
)
1203 PMIB_IPFORWARDTABLE table
;
1206 TRACE("dwDestAddr 0x%08x, dwSourceAddr 0x%08x, pBestRoute %p\n", dwDestAddr
,
1207 dwSourceAddr
, pBestRoute
);
1209 return ERROR_INVALID_PARAMETER
;
1211 ret
= AllocateAndGetIpForwardTableFromStack(&table
, FALSE
, GetProcessHeap(), 0);
1213 DWORD ndx
, matchedBits
, matchedNdx
= table
->dwNumEntries
;
1215 for (ndx
= 0, matchedBits
= 0; ndx
< table
->dwNumEntries
; ndx
++) {
1216 if (table
->table
[ndx
].dwForwardType
!= MIB_IPROUTE_TYPE_INVALID
&&
1217 (dwDestAddr
& table
->table
[ndx
].dwForwardMask
) ==
1218 (table
->table
[ndx
].dwForwardDest
& table
->table
[ndx
].dwForwardMask
)) {
1219 DWORD numShifts
, mask
;
1221 for (numShifts
= 0, mask
= table
->table
[ndx
].dwForwardMask
;
1222 mask
&& mask
& 1; mask
>>= 1, numShifts
++)
1224 if (numShifts
> matchedBits
) {
1225 matchedBits
= numShifts
;
1228 else if (!matchedBits
) {
1233 if (matchedNdx
< table
->dwNumEntries
) {
1234 memcpy(pBestRoute
, &table
->table
[matchedNdx
], sizeof(MIB_IPFORWARDROW
));
1235 ret
= ERROR_SUCCESS
;
1238 /* No route matches, which can happen if there's no default route. */
1239 ret
= ERROR_HOST_UNREACHABLE
;
1241 HeapFree(GetProcessHeap(), 0, table
);
1243 TRACE("returning %d\n", ret
);
1248 /******************************************************************
1249 * GetFriendlyIfIndex (IPHLPAPI.@)
1251 * Get a "friendly" version of IfIndex, which is one that doesn't
1252 * have the top byte set. Doesn't validate whether IfIndex is a valid
1256 * IfIndex [In] interface index to get the friendly one for
1259 * A friendly version of IfIndex.
1261 DWORD WINAPI
GetFriendlyIfIndex(DWORD IfIndex
)
1263 /* windows doesn't validate these, either, just makes sure the top byte is
1264 cleared. I assume my ifenum module never gives an index with the top
1266 TRACE("returning %d\n", IfIndex
);
1271 /******************************************************************
1272 * GetIfEntry (IPHLPAPI.@)
1274 * Get information about an interface.
1277 * pIfRow [In/Out] In: dwIndex of MIB_IFROW selects the interface.
1278 * Out: interface information
1282 * Failure: error code from winerror.h
1284 DWORD WINAPI
GetIfEntry(PMIB_IFROW pIfRow
)
1287 char nameBuf
[MAX_ADAPTER_NAME
];
1290 TRACE("pIfRow %p\n", pIfRow
);
1292 return ERROR_INVALID_PARAMETER
;
1294 name
= getInterfaceNameByIndex(pIfRow
->dwIndex
, nameBuf
);
1296 ret
= getInterfaceEntryByName(name
, pIfRow
);
1297 if (ret
== NO_ERROR
)
1298 ret
= getInterfaceStatsByName(name
, pIfRow
);
1301 ret
= ERROR_INVALID_DATA
;
1302 TRACE("returning %d\n", ret
);
1307 static int IfTableSorter(const void *a
, const void *b
)
1312 ret
= ((const MIB_IFROW
*)a
)->dwIndex
- ((const MIB_IFROW
*)b
)->dwIndex
;
1319 /******************************************************************
1320 * GetIfTable (IPHLPAPI.@)
1322 * Get a table of local interfaces.
1325 * pIfTable [Out] buffer for local interfaces table
1326 * pdwSize [In/Out] length of output buffer
1327 * bOrder [In] whether to sort the table
1331 * Failure: error code from winerror.h
1334 * If pdwSize is less than required, the function will return
1335 * ERROR_INSUFFICIENT_BUFFER, and *pdwSize will be set to the required byte
1337 * If bOrder is true, the returned table will be sorted by interface index.
1339 DWORD WINAPI
GetIfTable(PMIB_IFTABLE pIfTable
, PULONG pdwSize
, BOOL bOrder
)
1343 TRACE("pIfTable %p, pdwSize %p, bOrder %d\n", pdwSize
, pdwSize
,
1346 ret
= ERROR_INVALID_PARAMETER
;
1348 DWORD numInterfaces
= getNumInterfaces();
1349 ULONG size
= sizeof(MIB_IFTABLE
);
1351 if (numInterfaces
> 1)
1352 size
+= (numInterfaces
- 1) * sizeof(MIB_IFROW
);
1353 if (!pIfTable
|| *pdwSize
< size
) {
1355 ret
= ERROR_INSUFFICIENT_BUFFER
;
1358 InterfaceIndexTable
*table
= getInterfaceIndexTable();
1361 size
= sizeof(MIB_IFTABLE
);
1362 if (table
->numIndexes
> 1)
1363 size
+= (table
->numIndexes
- 1) * sizeof(MIB_IFROW
);
1364 if (*pdwSize
< size
) {
1366 ret
= ERROR_INSUFFICIENT_BUFFER
;
1372 pIfTable
->dwNumEntries
= 0;
1373 for (ndx
= 0; ndx
< table
->numIndexes
; ndx
++) {
1374 pIfTable
->table
[ndx
].dwIndex
= table
->indexes
[ndx
];
1375 GetIfEntry(&pIfTable
->table
[ndx
]);
1376 pIfTable
->dwNumEntries
++;
1379 qsort(pIfTable
->table
, pIfTable
->dwNumEntries
, sizeof(MIB_IFROW
),
1383 HeapFree(GetProcessHeap(), 0, table
);
1386 ret
= ERROR_OUTOFMEMORY
;
1389 TRACE("returning %d\n", ret
);
1394 /******************************************************************
1395 * GetInterfaceInfo (IPHLPAPI.@)
1397 * Get a list of network interface adapters.
1400 * pIfTable [Out] buffer for interface adapters
1401 * dwOutBufLen [Out] if buffer is too small, returns required size
1405 * Failure: error code from winerror.h
1408 * MSDN states this should return non-loopback interfaces only.
1410 DWORD WINAPI
GetInterfaceInfo(PIP_INTERFACE_INFO pIfTable
, PULONG dwOutBufLen
)
1414 TRACE("pIfTable %p, dwOutBufLen %p\n", pIfTable
, dwOutBufLen
);
1416 ret
= ERROR_INVALID_PARAMETER
;
1418 DWORD numInterfaces
= getNumInterfaces();
1419 ULONG size
= sizeof(IP_INTERFACE_INFO
);
1421 if (numInterfaces
> 1)
1422 size
+= (numInterfaces
- 1) * sizeof(IP_ADAPTER_INDEX_MAP
);
1423 if (!pIfTable
|| *dwOutBufLen
< size
) {
1424 *dwOutBufLen
= size
;
1425 ret
= ERROR_INSUFFICIENT_BUFFER
;
1428 InterfaceIndexTable
*table
= getInterfaceIndexTable();
1431 size
= sizeof(IP_INTERFACE_INFO
);
1432 if (table
->numIndexes
> 1)
1433 size
+= (table
->numIndexes
- 1) * sizeof(IP_ADAPTER_INDEX_MAP
);
1434 if (*dwOutBufLen
< size
) {
1435 *dwOutBufLen
= size
;
1436 ret
= ERROR_INSUFFICIENT_BUFFER
;
1440 char nameBuf
[MAX_ADAPTER_NAME
];
1442 *dwOutBufLen
= size
;
1443 pIfTable
->NumAdapters
= 0;
1444 for (ndx
= 0; ndx
< table
->numIndexes
; ndx
++) {
1445 const char *walker
, *name
;
1448 pIfTable
->Adapter
[ndx
].Index
= table
->indexes
[ndx
];
1449 name
= getInterfaceNameByIndex(table
->indexes
[ndx
], nameBuf
);
1450 for (walker
= name
, assigner
= pIfTable
->Adapter
[ndx
].Name
;
1451 walker
&& *walker
&&
1452 assigner
- pIfTable
->Adapter
[ndx
].Name
< MAX_ADAPTER_NAME
- 1;
1453 walker
++, assigner
++)
1454 *assigner
= *walker
;
1456 pIfTable
->NumAdapters
++;
1460 HeapFree(GetProcessHeap(), 0, table
);
1463 ret
= ERROR_OUTOFMEMORY
;
1466 TRACE("returning %d\n", ret
);
1471 /******************************************************************
1472 * GetIpAddrTable (IPHLPAPI.@)
1474 * Get interface-to-IP address mapping table.
1477 * pIpAddrTable [Out] buffer for mapping table
1478 * pdwSize [In/Out] length of output buffer
1479 * bOrder [In] whether to sort the table
1483 * Failure: error code from winerror.h
1486 * If pdwSize is less than required, the function will return
1487 * ERROR_INSUFFICIENT_BUFFER, and *pdwSize will be set to the required byte
1489 * If bOrder is true, the returned table will be sorted by the next hop and
1490 * an assortment of arbitrary parameters.
1492 DWORD WINAPI
GetIpAddrTable(PMIB_IPADDRTABLE pIpAddrTable
, PULONG pdwSize
, BOOL bOrder
)
1496 TRACE("pIpAddrTable %p, pdwSize %p, bOrder %d\n", pIpAddrTable
, pdwSize
,
1499 ret
= ERROR_INVALID_PARAMETER
;
1501 PMIB_IPADDRTABLE table
;
1503 ret
= getIPAddrTable(&table
, GetProcessHeap(), 0);
1504 if (ret
== NO_ERROR
)
1506 ULONG size
= sizeof(MIB_IPADDRTABLE
);
1508 if (table
->dwNumEntries
> 1)
1509 size
+= (table
->dwNumEntries
- 1) * sizeof(MIB_IPADDRROW
);
1510 if (!pIpAddrTable
|| *pdwSize
< size
) {
1512 ret
= ERROR_INSUFFICIENT_BUFFER
;
1516 memcpy(pIpAddrTable
, table
, size
);
1518 qsort(pIpAddrTable
->table
, pIpAddrTable
->dwNumEntries
,
1519 sizeof(MIB_IPADDRROW
), IpAddrTableSorter
);
1522 HeapFree(GetProcessHeap(), 0, table
);
1525 TRACE("returning %d\n", ret
);
1530 /******************************************************************
1531 * GetIpForwardTable (IPHLPAPI.@)
1533 * Get the route table.
1536 * pIpForwardTable [Out] buffer for route table
1537 * pdwSize [In/Out] length of output buffer
1538 * bOrder [In] whether to sort the table
1542 * Failure: error code from winerror.h
1545 * If pdwSize is less than required, the function will return
1546 * ERROR_INSUFFICIENT_BUFFER, and *pdwSize will be set to the required byte
1548 * If bOrder is true, the returned table will be sorted by the next hop and
1549 * an assortment of arbitrary parameters.
1551 DWORD WINAPI
GetIpForwardTable(PMIB_IPFORWARDTABLE pIpForwardTable
, PULONG pdwSize
, BOOL bOrder
)
1554 PMIB_IPFORWARDTABLE table
;
1556 TRACE("pIpForwardTable %p, pdwSize %p, bOrder %d\n", pIpForwardTable
, pdwSize
, bOrder
);
1558 if (!pdwSize
) return ERROR_INVALID_PARAMETER
;
1560 ret
= AllocateAndGetIpForwardTableFromStack(&table
, bOrder
, GetProcessHeap(), 0);
1562 DWORD size
= FIELD_OFFSET( MIB_IPFORWARDTABLE
, table
[table
->dwNumEntries
] );
1563 if (!pIpForwardTable
|| *pdwSize
< size
) {
1565 ret
= ERROR_INSUFFICIENT_BUFFER
;
1569 memcpy(pIpForwardTable
, table
, size
);
1571 HeapFree(GetProcessHeap(), 0, table
);
1573 TRACE("returning %d\n", ret
);
1578 /******************************************************************
1579 * GetIpNetTable (IPHLPAPI.@)
1581 * Get the IP-to-physical address mapping table.
1584 * pIpNetTable [Out] buffer for mapping table
1585 * pdwSize [In/Out] length of output buffer
1586 * bOrder [In] whether to sort the table
1590 * Failure: error code from winerror.h
1593 * If pdwSize is less than required, the function will return
1594 * ERROR_INSUFFICIENT_BUFFER, and *pdwSize will be set to the required byte
1596 * If bOrder is true, the returned table will be sorted by IP address.
1598 DWORD WINAPI
GetIpNetTable(PMIB_IPNETTABLE pIpNetTable
, PULONG pdwSize
, BOOL bOrder
)
1601 PMIB_IPNETTABLE table
;
1603 TRACE("pIpNetTable %p, pdwSize %p, bOrder %d\n", pIpNetTable
, pdwSize
, bOrder
);
1605 if (!pdwSize
) return ERROR_INVALID_PARAMETER
;
1607 ret
= AllocateAndGetIpNetTableFromStack( &table
, bOrder
, GetProcessHeap(), 0 );
1609 DWORD size
= FIELD_OFFSET( MIB_IPNETTABLE
, table
[table
->dwNumEntries
] );
1610 if (!pIpNetTable
|| *pdwSize
< size
) {
1612 ret
= ERROR_INSUFFICIENT_BUFFER
;
1616 memcpy(pIpNetTable
, table
, size
);
1618 HeapFree(GetProcessHeap(), 0, table
);
1620 TRACE("returning %d\n", ret
);
1624 /* Gets the DNS server list into the list beginning at list. Assumes that
1625 * a single server address may be placed at list if *len is at least
1626 * sizeof(IP_ADDR_STRING) long. Otherwise, list->Next is set to firstDynamic,
1627 * and assumes that all remaining DNS servers are contiguously located
1628 * beginning at firstDynamic. On input, *len is assumed to be the total number
1629 * of bytes available for all DNS servers, and is ignored if list is NULL.
1630 * On return, *len is set to the total number of bytes required for all DNS
1632 * Returns ERROR_BUFFER_OVERFLOW if *len is insufficient,
1633 * ERROR_SUCCESS otherwise.
1635 static DWORD
get_dns_server_list(PIP_ADDR_STRING list
,
1636 PIP_ADDR_STRING firstDynamic
, DWORD
*len
)
1640 initialise_resolver();
1641 size
= _res
.nscount
* sizeof(IP_ADDR_STRING
);
1642 if (!list
|| *len
< size
) {
1644 return ERROR_BUFFER_OVERFLOW
;
1647 if (_res
.nscount
> 0) {
1648 PIP_ADDR_STRING ptr
;
1651 for (i
= 0, ptr
= list
; i
< _res
.nscount
&& ptr
; i
++, ptr
= ptr
->Next
) {
1652 toIPAddressString(_res
.nsaddr_list
[i
].sin_addr
.s_addr
,
1653 ptr
->IpAddress
.String
);
1654 if (i
== _res
.nscount
- 1)
1657 ptr
->Next
= firstDynamic
;
1659 ptr
->Next
= (PIP_ADDR_STRING
)((PBYTE
)ptr
+ sizeof(IP_ADDR_STRING
));
1662 return ERROR_SUCCESS
;
1665 /******************************************************************
1666 * GetNetworkParams (IPHLPAPI.@)
1668 * Get the network parameters for the local computer.
1671 * pFixedInfo [Out] buffer for network parameters
1672 * pOutBufLen [In/Out] length of output buffer
1676 * Failure: error code from winerror.h
1679 * If pOutBufLen is less than required, the function will return
1680 * ERROR_INSUFFICIENT_BUFFER, and pOutBufLen will be set to the required byte
1683 DWORD WINAPI
GetNetworkParams(PFIXED_INFO pFixedInfo
, PULONG pOutBufLen
)
1685 DWORD ret
, size
, serverListSize
;
1689 TRACE("pFixedInfo %p, pOutBufLen %p\n", pFixedInfo
, pOutBufLen
);
1691 return ERROR_INVALID_PARAMETER
;
1693 get_dns_server_list(NULL
, NULL
, &serverListSize
);
1694 size
= sizeof(FIXED_INFO
) + serverListSize
- sizeof(IP_ADDR_STRING
);
1695 if (!pFixedInfo
|| *pOutBufLen
< size
) {
1697 return ERROR_BUFFER_OVERFLOW
;
1700 memset(pFixedInfo
, 0, size
);
1701 size
= sizeof(pFixedInfo
->HostName
);
1702 GetComputerNameExA(ComputerNameDnsHostname
, pFixedInfo
->HostName
, &size
);
1703 size
= sizeof(pFixedInfo
->DomainName
);
1704 GetComputerNameExA(ComputerNameDnsDomain
, pFixedInfo
->DomainName
, &size
);
1705 get_dns_server_list(&pFixedInfo
->DnsServerList
,
1706 (PIP_ADDR_STRING
)((BYTE
*)pFixedInfo
+ sizeof(FIXED_INFO
)),
1708 /* Assume the first DNS server in the list is the "current" DNS server: */
1709 pFixedInfo
->CurrentDnsServer
= &pFixedInfo
->DnsServerList
;
1710 pFixedInfo
->NodeType
= HYBRID_NODETYPE
;
1711 regReturn
= RegOpenKeyExA(HKEY_LOCAL_MACHINE
,
1712 "SYSTEM\\CurrentControlSet\\Services\\VxD\\MSTCP", 0, KEY_READ
, &hKey
);
1713 if (regReturn
!= ERROR_SUCCESS
)
1714 regReturn
= RegOpenKeyExA(HKEY_LOCAL_MACHINE
,
1715 "SYSTEM\\CurrentControlSet\\Services\\NetBT\\Parameters", 0, KEY_READ
,
1717 if (regReturn
== ERROR_SUCCESS
)
1719 DWORD size
= sizeof(pFixedInfo
->ScopeId
);
1721 RegQueryValueExA(hKey
, "ScopeID", NULL
, NULL
, (LPBYTE
)pFixedInfo
->ScopeId
, &size
);
1725 /* FIXME: can check whether routing's enabled in /proc/sys/net/ipv4/ip_forward
1726 I suppose could also check for a listener on port 53 to set EnableDns */
1728 TRACE("returning %d\n", ret
);
1733 /******************************************************************
1734 * GetNumberOfInterfaces (IPHLPAPI.@)
1736 * Get the number of interfaces.
1739 * pdwNumIf [Out] number of interfaces
1742 * NO_ERROR on success, ERROR_INVALID_PARAMETER if pdwNumIf is NULL.
1744 DWORD WINAPI
GetNumberOfInterfaces(PDWORD pdwNumIf
)
1748 TRACE("pdwNumIf %p\n", pdwNumIf
);
1750 ret
= ERROR_INVALID_PARAMETER
;
1752 *pdwNumIf
= getNumInterfaces();
1755 TRACE("returning %d\n", ret
);
1760 /******************************************************************
1761 * GetPerAdapterInfo (IPHLPAPI.@)
1763 * Get information about an adapter corresponding to an interface.
1766 * IfIndex [In] interface info
1767 * pPerAdapterInfo [Out] buffer for per adapter info
1768 * pOutBufLen [In/Out] length of output buffer
1772 * Failure: error code from winerror.h
1774 DWORD WINAPI
GetPerAdapterInfo(ULONG IfIndex
, PIP_PER_ADAPTER_INFO pPerAdapterInfo
, PULONG pOutBufLen
)
1776 ULONG bytesNeeded
= sizeof(IP_PER_ADAPTER_INFO
), serverListSize
= 0;
1777 DWORD ret
= NO_ERROR
;
1779 TRACE("(IfIndex %d, pPerAdapterInfo %p, pOutBufLen %p)\n", IfIndex
, pPerAdapterInfo
, pOutBufLen
);
1781 if (!pOutBufLen
) return ERROR_INVALID_PARAMETER
;
1783 if (!isIfIndexLoopback(IfIndex
)) {
1784 get_dns_server_list(NULL
, NULL
, &serverListSize
);
1785 if (serverListSize
> sizeof(IP_ADDR_STRING
))
1786 bytesNeeded
+= serverListSize
- sizeof(IP_ADDR_STRING
);
1788 if (!pPerAdapterInfo
|| *pOutBufLen
< bytesNeeded
)
1790 *pOutBufLen
= bytesNeeded
;
1791 return ERROR_BUFFER_OVERFLOW
;
1794 memset(pPerAdapterInfo
, 0, bytesNeeded
);
1795 if (!isIfIndexLoopback(IfIndex
)) {
1796 ret
= get_dns_server_list(&pPerAdapterInfo
->DnsServerList
,
1797 (PIP_ADDR_STRING
)((PBYTE
)pPerAdapterInfo
+ sizeof(IP_PER_ADAPTER_INFO
)),
1799 /* Assume the first DNS server in the list is the "current" DNS server: */
1800 pPerAdapterInfo
->CurrentDnsServer
= &pPerAdapterInfo
->DnsServerList
;
1806 /******************************************************************
1807 * GetRTTAndHopCount (IPHLPAPI.@)
1809 * Get round-trip time (RTT) and hop count.
1813 * DestIpAddress [In] destination address to get the info for
1814 * HopCount [Out] retrieved hop count
1815 * MaxHops [In] maximum hops to search for the destination
1816 * RTT [Out] RTT in milliseconds
1823 * Stub, returns FALSE.
1825 BOOL WINAPI
GetRTTAndHopCount(IPAddr DestIpAddress
, PULONG HopCount
, ULONG MaxHops
, PULONG RTT
)
1827 FIXME("(DestIpAddress 0x%08x, HopCount %p, MaxHops %d, RTT %p): stub\n",
1828 DestIpAddress
, HopCount
, MaxHops
, RTT
);
1833 /******************************************************************
1834 * GetTcpTable (IPHLPAPI.@)
1836 * Get the table of active TCP connections.
1839 * pTcpTable [Out] buffer for TCP connections table
1840 * pdwSize [In/Out] length of output buffer
1841 * bOrder [In] whether to order the table
1845 * Failure: error code from winerror.h
1848 * If pdwSize is less than required, the function will return
1849 * ERROR_INSUFFICIENT_BUFFER, and *pdwSize will be set to
1850 * the required byte size.
1851 * If bOrder is true, the returned table will be sorted, first by
1852 * local address and port number, then by remote address and port
1855 DWORD WINAPI
GetTcpTable(PMIB_TCPTABLE pTcpTable
, PDWORD pdwSize
, BOOL bOrder
)
1858 PMIB_TCPTABLE table
;
1860 TRACE("pTcpTable %p, pdwSize %p, bOrder %d\n", pTcpTable
, pdwSize
, bOrder
);
1862 if (!pdwSize
) return ERROR_INVALID_PARAMETER
;
1864 ret
= AllocateAndGetTcpTableFromStack(&table
, bOrder
, GetProcessHeap(), 0);
1866 DWORD size
= FIELD_OFFSET( MIB_TCPTABLE
, table
[table
->dwNumEntries
] );
1867 if (!pTcpTable
|| *pdwSize
< size
) {
1869 ret
= ERROR_INSUFFICIENT_BUFFER
;
1873 memcpy(pTcpTable
, table
, size
);
1875 HeapFree(GetProcessHeap(), 0, table
);
1877 TRACE("returning %d\n", ret
);
1882 /******************************************************************
1883 * GetUdpTable (IPHLPAPI.@)
1885 * Get a table of active UDP connections.
1888 * pUdpTable [Out] buffer for UDP connections table
1889 * pdwSize [In/Out] length of output buffer
1890 * bOrder [In] whether to order the table
1894 * Failure: error code from winerror.h
1897 * If pdwSize is less than required, the function will return
1898 * ERROR_INSUFFICIENT_BUFFER, and *pdwSize will be set to the
1899 * required byte size.
1900 * If bOrder is true, the returned table will be sorted, first by
1901 * local address, then by local port number.
1903 DWORD WINAPI
GetUdpTable(PMIB_UDPTABLE pUdpTable
, PDWORD pdwSize
, BOOL bOrder
)
1906 PMIB_UDPTABLE table
;
1908 TRACE("pUdpTable %p, pdwSize %p, bOrder %d\n", pUdpTable
, pdwSize
, bOrder
);
1910 if (!pdwSize
) return ERROR_INVALID_PARAMETER
;
1912 ret
= AllocateAndGetUdpTableFromStack( &table
, bOrder
, GetProcessHeap(), 0 );
1914 DWORD size
= FIELD_OFFSET( MIB_UDPTABLE
, table
[table
->dwNumEntries
] );
1915 if (!pUdpTable
|| *pdwSize
< size
) {
1917 ret
= ERROR_INSUFFICIENT_BUFFER
;
1921 memcpy(pUdpTable
, table
, size
);
1923 HeapFree(GetProcessHeap(), 0, table
);
1925 TRACE("returning %d\n", ret
);
1930 /******************************************************************
1931 * GetUniDirectionalAdapterInfo (IPHLPAPI.@)
1933 * This is a Win98-only function to get information on "unidirectional"
1934 * adapters. Since this is pretty nonsensical in other contexts, it
1935 * never returns anything.
1938 * pIPIfInfo [Out] buffer for adapter infos
1939 * dwOutBufLen [Out] length of the output buffer
1943 * Failure: error code from winerror.h
1946 * Stub, returns ERROR_NOT_SUPPORTED.
1948 DWORD WINAPI
GetUniDirectionalAdapterInfo(PIP_UNIDIRECTIONAL_ADAPTER_ADDRESS pIPIfInfo
, PULONG dwOutBufLen
)
1950 TRACE("pIPIfInfo %p, dwOutBufLen %p\n", pIPIfInfo
, dwOutBufLen
);
1951 /* a unidirectional adapter?? not bloody likely! */
1952 return ERROR_NOT_SUPPORTED
;
1956 /******************************************************************
1957 * IpReleaseAddress (IPHLPAPI.@)
1959 * Release an IP obtained through DHCP,
1962 * AdapterInfo [In] adapter to release IP address
1966 * Failure: error code from winerror.h
1969 * Since GetAdaptersInfo never returns adapters that have DHCP enabled,
1970 * this function does nothing.
1973 * Stub, returns ERROR_NOT_SUPPORTED.
1975 DWORD WINAPI
IpReleaseAddress(PIP_ADAPTER_INDEX_MAP AdapterInfo
)
1977 TRACE("AdapterInfo %p\n", AdapterInfo
);
1978 /* not a stub, never going to support this (and I never mark an adapter as
1979 DHCP enabled, see GetAdaptersInfo, so this should never get called) */
1980 return ERROR_NOT_SUPPORTED
;
1984 /******************************************************************
1985 * IpRenewAddress (IPHLPAPI.@)
1987 * Renew an IP obtained through DHCP.
1990 * AdapterInfo [In] adapter to renew IP address
1994 * Failure: error code from winerror.h
1997 * Since GetAdaptersInfo never returns adapters that have DHCP enabled,
1998 * this function does nothing.
2001 * Stub, returns ERROR_NOT_SUPPORTED.
2003 DWORD WINAPI
IpRenewAddress(PIP_ADAPTER_INDEX_MAP AdapterInfo
)
2005 TRACE("AdapterInfo %p\n", AdapterInfo
);
2006 /* not a stub, never going to support this (and I never mark an adapter as
2007 DHCP enabled, see GetAdaptersInfo, so this should never get called) */
2008 return ERROR_NOT_SUPPORTED
;
2012 /******************************************************************
2013 * NotifyAddrChange (IPHLPAPI.@)
2015 * Notify caller whenever the ip-interface map is changed.
2018 * Handle [Out] handle usable in asynchronous notification
2019 * overlapped [In] overlapped structure that notifies the caller
2023 * Failure: error code from winerror.h
2026 * Stub, returns ERROR_NOT_SUPPORTED.
2028 DWORD WINAPI
NotifyAddrChange(PHANDLE Handle
, LPOVERLAPPED overlapped
)
2030 FIXME("(Handle %p, overlapped %p): stub\n", Handle
, overlapped
);
2031 if (Handle
) *Handle
= INVALID_HANDLE_VALUE
;
2032 if (overlapped
) ((IO_STATUS_BLOCK
*) overlapped
)->u
.Status
= STATUS_PENDING
;
2033 return ERROR_IO_PENDING
;
2037 /******************************************************************
2038 * NotifyRouteChange (IPHLPAPI.@)
2040 * Notify caller whenever the ip routing table is changed.
2043 * Handle [Out] handle usable in asynchronous notification
2044 * overlapped [In] overlapped structure that notifies the caller
2048 * Failure: error code from winerror.h
2051 * Stub, returns ERROR_NOT_SUPPORTED.
2053 DWORD WINAPI
NotifyRouteChange(PHANDLE Handle
, LPOVERLAPPED overlapped
)
2055 FIXME("(Handle %p, overlapped %p): stub\n", Handle
, overlapped
);
2056 return ERROR_NOT_SUPPORTED
;
2060 /******************************************************************
2061 * SendARP (IPHLPAPI.@)
2063 * Send an ARP request.
2066 * DestIP [In] attempt to obtain this IP
2067 * SrcIP [In] optional sender IP address
2068 * pMacAddr [Out] buffer for the mac address
2069 * PhyAddrLen [In/Out] length of the output buffer
2073 * Failure: error code from winerror.h
2076 * Stub, returns ERROR_NOT_SUPPORTED.
2078 DWORD WINAPI
SendARP(IPAddr DestIP
, IPAddr SrcIP
, PULONG pMacAddr
, PULONG PhyAddrLen
)
2080 FIXME("(DestIP 0x%08x, SrcIP 0x%08x, pMacAddr %p, PhyAddrLen %p): stub\n",
2081 DestIP
, SrcIP
, pMacAddr
, PhyAddrLen
);
2082 return ERROR_NOT_SUPPORTED
;
2086 /******************************************************************
2087 * SetIfEntry (IPHLPAPI.@)
2089 * Set the administrative status of an interface.
2092 * pIfRow [In] dwAdminStatus member specifies the new status.
2096 * Failure: error code from winerror.h
2099 * Stub, returns ERROR_NOT_SUPPORTED.
2101 DWORD WINAPI
SetIfEntry(PMIB_IFROW pIfRow
)
2103 FIXME("(pIfRow %p): stub\n", pIfRow
);
2104 /* this is supposed to set an interface administratively up or down.
2105 Could do SIOCSIFFLAGS and set/clear IFF_UP, but, not sure I want to, and
2106 this sort of down is indistinguishable from other sorts of down (e.g. no
2108 return ERROR_NOT_SUPPORTED
;
2112 /******************************************************************
2113 * SetIpForwardEntry (IPHLPAPI.@)
2115 * Modify an existing route.
2118 * pRoute [In] route with the new information
2122 * Failure: error code from winerror.h
2125 * Stub, returns NO_ERROR.
2127 DWORD WINAPI
SetIpForwardEntry(PMIB_IPFORWARDROW pRoute
)
2129 FIXME("(pRoute %p): stub\n", pRoute
);
2130 /* this is to add a route entry, how's it distinguishable from
2131 CreateIpForwardEntry?
2132 could use SIOCADDRT, not sure I want to */
2137 /******************************************************************
2138 * SetIpNetEntry (IPHLPAPI.@)
2140 * Modify an existing ARP entry.
2143 * pArpEntry [In] ARP entry with the new information
2147 * Failure: error code from winerror.h
2150 * Stub, returns NO_ERROR.
2152 DWORD WINAPI
SetIpNetEntry(PMIB_IPNETROW pArpEntry
)
2154 FIXME("(pArpEntry %p): stub\n", pArpEntry
);
2155 /* same as CreateIpNetEntry here, could use SIOCSARP, not sure I want to */
2160 /******************************************************************
2161 * SetIpStatistics (IPHLPAPI.@)
2163 * Toggle IP forwarding and det the default TTL value.
2166 * pIpStats [In] IP statistics with the new information
2170 * Failure: error code from winerror.h
2173 * Stub, returns NO_ERROR.
2175 DWORD WINAPI
SetIpStatistics(PMIB_IPSTATS pIpStats
)
2177 FIXME("(pIpStats %p): stub\n", pIpStats
);
2182 /******************************************************************
2183 * SetIpTTL (IPHLPAPI.@)
2185 * Set the default TTL value.
2188 * nTTL [In] new TTL value
2192 * Failure: error code from winerror.h
2195 * Stub, returns NO_ERROR.
2197 DWORD WINAPI
SetIpTTL(UINT nTTL
)
2199 FIXME("(nTTL %d): stub\n", nTTL
);
2200 /* could echo nTTL > /proc/net/sys/net/ipv4/ip_default_ttl, not sure I
2201 want to. Could map EACCESS to ERROR_ACCESS_DENIED, I suppose */
2206 /******************************************************************
2207 * SetTcpEntry (IPHLPAPI.@)
2209 * Set the state of a TCP connection.
2212 * pTcpRow [In] specifies connection with new state
2216 * Failure: error code from winerror.h
2219 * Stub, returns NO_ERROR.
2221 DWORD WINAPI
SetTcpEntry(PMIB_TCPROW pTcpRow
)
2223 FIXME("(pTcpRow %p): stub\n", pTcpRow
);
2228 /******************************************************************
2229 * UnenableRouter (IPHLPAPI.@)
2231 * Decrement the IP-forwarding reference count. Turn off IP-forwarding
2232 * if it reaches zero.
2235 * pOverlapped [In/Out] should be the same as in EnableRouter()
2236 * lpdwEnableCount [Out] optional, receives reference count
2240 * Failure: error code from winerror.h
2243 * Stub, returns ERROR_NOT_SUPPORTED.
2245 DWORD WINAPI
UnenableRouter(OVERLAPPED
* pOverlapped
, LPDWORD lpdwEnableCount
)
2247 FIXME("(pOverlapped %p, lpdwEnableCount %p): stub\n", pOverlapped
,
2249 /* could echo "0" > /proc/net/sys/net/ipv4/ip_forward, not sure I want to
2250 could map EACCESS to ERROR_ACCESS_DENIED, I suppose
2252 return ERROR_NOT_SUPPORTED
;
2255 /******************************************************************
2256 * PfCreateInterface (IPHLPAPI.@)
2258 DWORD WINAPI
PfCreateInterface(DWORD dwName
, PFFORWARD_ACTION inAction
, PFFORWARD_ACTION outAction
,
2259 BOOL bUseLog
, BOOL bMustBeUnique
, INTERFACE_HANDLE
*ppInterface
)
2261 FIXME("(%d %d %d %x %x %p) stub\n", dwName
, inAction
, outAction
, bUseLog
, bMustBeUnique
, ppInterface
);
2262 return ERROR_CALL_NOT_IMPLEMENTED
;