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>
45 #include "wine/debug.h"
47 WINE_DEFAULT_DEBUG_CHANNEL(iphlpapi
);
50 #define INADDR_NONE ~0UL
53 static int resolver_initialised
;
55 /* call res_init() just once because of a bug in Mac OS X 10.4 */
56 static void initialise_resolver(void)
58 if (!resolver_initialised
)
61 resolver_initialised
= 1;
65 BOOL WINAPI
DllMain (HINSTANCE hinstDLL
, DWORD fdwReason
, LPVOID lpvReserved
)
68 case DLL_PROCESS_ATTACH
:
69 DisableThreadLibraryCalls( hinstDLL
);
72 case DLL_PROCESS_DETACH
:
78 /******************************************************************
79 * AddIPAddress (IPHLPAPI.@)
81 * Add an IP address to an adapter.
84 * Address [In] IP address to add to the adapter
85 * IpMask [In] subnet mask for the IP address
86 * IfIndex [In] adapter index to add the address
87 * NTEContext [Out] Net Table Entry (NTE) context for the IP address
88 * NTEInstance [Out] NTE instance for the IP address
92 * Failure: error code from winerror.h
95 * Stub. Currently returns ERROR_NOT_SUPPORTED.
97 DWORD WINAPI
AddIPAddress(IPAddr Address
, IPMask IpMask
, DWORD IfIndex
, PULONG NTEContext
, PULONG NTEInstance
)
100 return ERROR_NOT_SUPPORTED
;
104 /******************************************************************
105 * AllocateAndGetIfTableFromStack (IPHLPAPI.@)
107 * Get table of local interfaces.
108 * Like GetIfTable(), but allocate the returned table from heap.
111 * ppIfTable [Out] pointer into which the MIB_IFTABLE is
112 * allocated and returned.
113 * bOrder [In] whether to sort the table
114 * heap [In] heap from which the table is allocated
115 * flags [In] flags to HeapAlloc
118 * ERROR_INVALID_PARAMETER if ppIfTable is NULL, whatever
119 * GetIfTable() returns otherwise.
121 DWORD WINAPI
AllocateAndGetIfTableFromStack(PMIB_IFTABLE
*ppIfTable
,
122 BOOL bOrder
, HANDLE heap
, DWORD flags
)
126 TRACE("ppIfTable %p, bOrder %d, heap %p, flags 0x%08x\n", ppIfTable
,
127 bOrder
, heap
, flags
);
129 ret
= ERROR_INVALID_PARAMETER
;
133 ret
= GetIfTable(*ppIfTable
, &dwSize
, bOrder
);
134 if (ret
== ERROR_INSUFFICIENT_BUFFER
) {
135 *ppIfTable
= HeapAlloc(heap
, flags
, dwSize
);
136 ret
= GetIfTable(*ppIfTable
, &dwSize
, bOrder
);
139 TRACE("returning %d\n", ret
);
144 static int IpAddrTableSorter(const void *a
, const void *b
)
149 ret
= ((const MIB_IPADDRROW
*)a
)->dwAddr
- ((const MIB_IPADDRROW
*)b
)->dwAddr
;
156 /******************************************************************
157 * AllocateAndGetIpAddrTableFromStack (IPHLPAPI.@)
159 * Get interface-to-IP address mapping table.
160 * Like GetIpAddrTable(), but allocate the returned table from heap.
163 * ppIpAddrTable [Out] pointer into which the MIB_IPADDRTABLE is
164 * allocated and returned.
165 * bOrder [In] whether to sort the table
166 * heap [In] heap from which the table is allocated
167 * flags [In] flags to HeapAlloc
170 * ERROR_INVALID_PARAMETER if ppIpAddrTable is NULL, other error codes on
171 * failure, NO_ERROR on success.
173 DWORD WINAPI
AllocateAndGetIpAddrTableFromStack(PMIB_IPADDRTABLE
*ppIpAddrTable
,
174 BOOL bOrder
, HANDLE heap
, DWORD flags
)
178 TRACE("ppIpAddrTable %p, bOrder %d, heap %p, flags 0x%08x\n",
179 ppIpAddrTable
, bOrder
, heap
, flags
);
180 ret
= getIPAddrTable(ppIpAddrTable
, heap
, flags
);
182 qsort((*ppIpAddrTable
)->table
, (*ppIpAddrTable
)->dwNumEntries
,
183 sizeof(MIB_IPADDRROW
), IpAddrTableSorter
);
184 TRACE("returning %d\n", ret
);
189 static int IpForwardTableSorter(const void *a
, const void *b
)
194 const MIB_IPFORWARDROW
* rowA
= (const MIB_IPFORWARDROW
*)a
;
195 const MIB_IPFORWARDROW
* rowB
= (const MIB_IPFORWARDROW
*)b
;
197 ret
= rowA
->dwForwardDest
- rowB
->dwForwardDest
;
199 ret
= rowA
->dwForwardProto
- rowB
->dwForwardProto
;
201 ret
= rowA
->dwForwardPolicy
- rowB
->dwForwardPolicy
;
203 ret
= rowA
->dwForwardNextHop
- rowB
->dwForwardNextHop
;
213 /******************************************************************
214 * AllocateAndGetIpForwardTableFromStack (IPHLPAPI.@)
216 * Get the route table.
217 * Like GetIpForwardTable(), but allocate the returned table from heap.
220 * ppIpForwardTable [Out] pointer into which the MIB_IPFORWARDTABLE is
221 * allocated and returned.
222 * bOrder [In] whether to sort the table
223 * heap [In] heap from which the table is allocated
224 * flags [In] flags to HeapAlloc
227 * ERROR_INVALID_PARAMETER if ppIfTable is NULL, other error codes
228 * on failure, NO_ERROR on success.
230 DWORD WINAPI
AllocateAndGetIpForwardTableFromStack(PMIB_IPFORWARDTABLE
*
231 ppIpForwardTable
, BOOL bOrder
, HANDLE heap
, DWORD flags
)
235 TRACE("ppIpForwardTable %p, bOrder %d, heap %p, flags 0x%08x\n",
236 ppIpForwardTable
, bOrder
, heap
, flags
);
237 ret
= getRouteTable(ppIpForwardTable
, heap
, flags
);
239 qsort((*ppIpForwardTable
)->table
, (*ppIpForwardTable
)->dwNumEntries
,
240 sizeof(MIB_IPFORWARDROW
), IpForwardTableSorter
);
241 TRACE("returning %d\n", ret
);
246 static int IpNetTableSorter(const void *a
, const void *b
)
251 ret
= ((const MIB_IPNETROW
*)a
)->dwAddr
- ((const MIB_IPNETROW
*)b
)->dwAddr
;
258 /******************************************************************
259 * AllocateAndGetIpNetTableFromStack (IPHLPAPI.@)
261 * Get the IP-to-physical address mapping table.
262 * Like GetIpNetTable(), but allocate the returned table from heap.
265 * ppIpNetTable [Out] pointer into which the MIB_IPNETTABLE is
266 * allocated and returned.
267 * bOrder [In] whether to sort the table
268 * heap [In] heap from which the table is allocated
269 * flags [In] flags to HeapAlloc
272 * ERROR_INVALID_PARAMETER if ppIpNetTable is NULL, other error codes
273 * on failure, NO_ERROR on success.
275 DWORD WINAPI
AllocateAndGetIpNetTableFromStack(PMIB_IPNETTABLE
*ppIpNetTable
,
276 BOOL bOrder
, HANDLE heap
, DWORD flags
)
280 TRACE("ppIpNetTable %p, bOrder %d, heap %p, flags 0x%08x\n",
281 ppIpNetTable
, bOrder
, heap
, flags
);
282 ret
= getArpTable(ppIpNetTable
, heap
, flags
);
284 qsort((*ppIpNetTable
)->table
, (*ppIpNetTable
)->dwNumEntries
,
285 sizeof(MIB_IPADDRROW
), IpNetTableSorter
);
286 TRACE("returning %d\n", ret
);
291 static int TcpTableSorter(const void *a
, const void *b
)
296 const MIB_TCPROW
* rowA
= a
;
297 const MIB_TCPROW
* rowB
= b
;
299 ret
= ntohl (rowA
->dwLocalAddr
) - ntohl (rowB
->dwLocalAddr
);
301 ret
= ntohs ((unsigned short)rowA
->dwLocalPort
) -
302 ntohs ((unsigned short)rowB
->dwLocalPort
);
304 ret
= ntohl (rowA
->dwRemoteAddr
) - ntohl (rowB
->dwRemoteAddr
);
306 ret
= ntohs ((unsigned short)rowA
->dwRemotePort
) -
307 ntohs ((unsigned short)rowB
->dwRemotePort
);
317 /******************************************************************
318 * AllocateAndGetTcpTableFromStack (IPHLPAPI.@)
320 * Get the TCP connection table.
321 * Like GetTcpTable(), but allocate the returned table from heap.
324 * ppTcpTable [Out] pointer into which the MIB_TCPTABLE is
325 * allocated and returned.
326 * bOrder [In] whether to sort the table
327 * heap [In] heap from which the table is allocated
328 * flags [In] flags to HeapAlloc
331 * ERROR_INVALID_PARAMETER if ppTcpTable is NULL, whatever GetTcpTable()
334 DWORD WINAPI
AllocateAndGetTcpTableFromStack(PMIB_TCPTABLE
*ppTcpTable
,
335 BOOL bOrder
, HANDLE heap
, DWORD flags
)
339 TRACE("ppTcpTable %p, bOrder %d, heap %p, flags 0x%08x\n",
340 ppTcpTable
, bOrder
, heap
, flags
);
343 ret
= getTcpTable(ppTcpTable
, 0, heap
, flags
);
345 qsort((*ppTcpTable
)->table
, (*ppTcpTable
)->dwNumEntries
,
346 sizeof(MIB_TCPROW
), TcpTableSorter
);
347 TRACE("returning %d\n", ret
);
352 static int UdpTableSorter(const void *a
, const void *b
)
357 const MIB_UDPROW
* rowA
= (const MIB_UDPROW
*)a
;
358 const MIB_UDPROW
* rowB
= (const MIB_UDPROW
*)b
;
360 ret
= rowA
->dwLocalAddr
- rowB
->dwLocalAddr
;
362 ret
= rowA
->dwLocalPort
- rowB
->dwLocalPort
;
370 /******************************************************************
371 * AllocateAndGetUdpTableFromStack (IPHLPAPI.@)
373 * Get the UDP listener table.
374 * Like GetUdpTable(), but allocate the returned table from heap.
377 * ppUdpTable [Out] pointer into which the MIB_UDPTABLE is
378 * allocated and returned.
379 * bOrder [In] whether to sort the table
380 * heap [In] heap from which the table is allocated
381 * flags [In] flags to HeapAlloc
384 * ERROR_INVALID_PARAMETER if ppUdpTable is NULL, whatever GetUdpTable()
387 DWORD WINAPI
AllocateAndGetUdpTableFromStack(PMIB_UDPTABLE
*ppUdpTable
,
388 BOOL bOrder
, HANDLE heap
, DWORD flags
)
392 TRACE("ppUdpTable %p, bOrder %d, heap %p, flags 0x%08x\n",
393 ppUdpTable
, bOrder
, heap
, flags
);
394 ret
= getUdpTable(ppUdpTable
, heap
, flags
);
396 qsort((*ppUdpTable
)->table
, (*ppUdpTable
)->dwNumEntries
,
397 sizeof(MIB_UDPROW
), UdpTableSorter
);
398 TRACE("returning %d\n", ret
);
403 /******************************************************************
404 * CreateIpForwardEntry (IPHLPAPI.@)
406 * Create a route in the local computer's IP table.
409 * pRoute [In] new route information
413 * Failure: error code from winerror.h
416 * Stub, always returns NO_ERROR.
418 DWORD WINAPI
CreateIpForwardEntry(PMIB_IPFORWARDROW pRoute
)
420 FIXME("(pRoute %p): stub\n", pRoute
);
421 /* could use SIOCADDRT, not sure I want to */
426 /******************************************************************
427 * CreateIpNetEntry (IPHLPAPI.@)
429 * Create entry in the ARP table.
432 * pArpEntry [In] new ARP entry
436 * Failure: error code from winerror.h
439 * Stub, always returns NO_ERROR.
441 DWORD WINAPI
CreateIpNetEntry(PMIB_IPNETROW pArpEntry
)
443 FIXME("(pArpEntry %p)\n", pArpEntry
);
444 /* could use SIOCSARP on systems that support it, not sure I want to */
449 /******************************************************************
450 * CreateProxyArpEntry (IPHLPAPI.@)
452 * Create a Proxy ARP (PARP) entry for an IP address.
455 * dwAddress [In] IP address for which this computer acts as a proxy.
456 * dwMask [In] subnet mask for dwAddress
457 * dwIfIndex [In] interface index
461 * Failure: error code from winerror.h
464 * Stub, returns ERROR_NOT_SUPPORTED.
466 DWORD WINAPI
CreateProxyArpEntry(DWORD dwAddress
, DWORD dwMask
, DWORD dwIfIndex
)
468 FIXME("(dwAddress 0x%08x, dwMask 0x%08x, dwIfIndex 0x%08x): stub\n",
469 dwAddress
, dwMask
, dwIfIndex
);
470 return ERROR_NOT_SUPPORTED
;
474 /******************************************************************
475 * DeleteIPAddress (IPHLPAPI.@)
477 * Delete an IP address added with AddIPAddress().
480 * NTEContext [In] NTE context from AddIPAddress();
484 * Failure: error code from winerror.h
487 * Stub, returns ERROR_NOT_SUPPORTED.
489 DWORD WINAPI
DeleteIPAddress(ULONG NTEContext
)
491 FIXME("(NTEContext %d): stub\n", NTEContext
);
492 return ERROR_NOT_SUPPORTED
;
496 /******************************************************************
497 * DeleteIpForwardEntry (IPHLPAPI.@)
502 * pRoute [In] route to delete
506 * Failure: error code from winerror.h
509 * Stub, returns NO_ERROR.
511 DWORD WINAPI
DeleteIpForwardEntry(PMIB_IPFORWARDROW pRoute
)
513 FIXME("(pRoute %p): stub\n", pRoute
);
514 /* could use SIOCDELRT, not sure I want to */
519 /******************************************************************
520 * DeleteIpNetEntry (IPHLPAPI.@)
522 * Delete an ARP entry.
525 * pArpEntry [In] ARP entry to delete
529 * Failure: error code from winerror.h
532 * Stub, returns NO_ERROR.
534 DWORD WINAPI
DeleteIpNetEntry(PMIB_IPNETROW pArpEntry
)
536 FIXME("(pArpEntry %p): stub\n", pArpEntry
);
537 /* could use SIOCDARP on systems that support it, not sure I want to */
542 /******************************************************************
543 * DeleteProxyArpEntry (IPHLPAPI.@)
545 * Delete a Proxy ARP entry.
548 * dwAddress [In] IP address for which this computer acts as a proxy.
549 * dwMask [In] subnet mask for dwAddress
550 * dwIfIndex [In] interface index
554 * Failure: error code from winerror.h
557 * Stub, returns ERROR_NOT_SUPPORTED.
559 DWORD WINAPI
DeleteProxyArpEntry(DWORD dwAddress
, DWORD dwMask
, DWORD dwIfIndex
)
561 FIXME("(dwAddress 0x%08x, dwMask 0x%08x, dwIfIndex 0x%08x): stub\n",
562 dwAddress
, dwMask
, dwIfIndex
);
563 return ERROR_NOT_SUPPORTED
;
567 /******************************************************************
568 * EnableRouter (IPHLPAPI.@)
570 * Turn on ip forwarding.
574 * pOverlapped [In/Out] hEvent member should contain a valid handle.
577 * Success: ERROR_IO_PENDING
578 * Failure: error code from winerror.h
581 * Stub, returns ERROR_NOT_SUPPORTED.
583 DWORD WINAPI
EnableRouter(HANDLE
* pHandle
, OVERLAPPED
* pOverlapped
)
585 FIXME("(pHandle %p, pOverlapped %p): stub\n", pHandle
, pOverlapped
);
586 /* could echo "1" > /proc/net/sys/net/ipv4/ip_forward, not sure I want to
587 could map EACCESS to ERROR_ACCESS_DENIED, I suppose
589 return ERROR_NOT_SUPPORTED
;
593 /******************************************************************
594 * FlushIpNetTable (IPHLPAPI.@)
596 * Delete all ARP entries of an interface
599 * dwIfIndex [In] interface index
603 * Failure: error code from winerror.h
606 * Stub, returns ERROR_NOT_SUPPORTED.
608 DWORD WINAPI
FlushIpNetTable(DWORD dwIfIndex
)
610 FIXME("(dwIfIndex 0x%08x): stub\n", dwIfIndex
);
611 /* this flushes the arp cache of the given index */
612 return ERROR_NOT_SUPPORTED
;
616 /******************************************************************
617 * GetAdapterIndex (IPHLPAPI.@)
619 * Get interface index from its name.
622 * AdapterName [In] unicode string with the adapter name
623 * IfIndex [Out] returns found interface index
627 * Failure: error code from winerror.h
629 DWORD WINAPI
GetAdapterIndex(LPWSTR AdapterName
, PULONG IfIndex
)
631 char adapterName
[MAX_ADAPTER_NAME
];
635 TRACE("(AdapterName %p, IfIndex %p)\n", AdapterName
, IfIndex
);
636 /* The adapter name is guaranteed not to have any unicode characters, so
637 * this translation is never lossy */
638 for (i
= 0; i
< sizeof(adapterName
) - 1 && AdapterName
[i
]; i
++)
639 adapterName
[i
] = (char)AdapterName
[i
];
640 adapterName
[i
] = '\0';
641 ret
= getInterfaceIndexByName(adapterName
, IfIndex
);
642 TRACE("returning %d\n", ret
);
647 /******************************************************************
648 * GetAdaptersInfo (IPHLPAPI.@)
650 * Get information about adapters.
653 * pAdapterInfo [Out] buffer for adapter infos
654 * pOutBufLen [In] length of output buffer
658 * Failure: error code from winerror.h
660 DWORD WINAPI
GetAdaptersInfo(PIP_ADAPTER_INFO pAdapterInfo
, PULONG pOutBufLen
)
664 TRACE("pAdapterInfo %p, pOutBufLen %p\n", pAdapterInfo
, pOutBufLen
);
666 ret
= ERROR_INVALID_PARAMETER
;
668 DWORD numNonLoopbackInterfaces
= getNumNonLoopbackInterfaces();
670 if (numNonLoopbackInterfaces
> 0) {
671 DWORD numIPAddresses
= getNumIPAddresses();
674 /* This may slightly overestimate the amount of space needed, because
675 * the IP addresses include the loopback address, but it's easier
676 * to make sure there's more than enough space than to make sure there's
677 * precisely enough space.
679 size
= sizeof(IP_ADAPTER_INFO
) * numNonLoopbackInterfaces
;
680 size
+= numIPAddresses
* sizeof(IP_ADDR_STRING
);
681 if (!pAdapterInfo
|| *pOutBufLen
< size
) {
683 ret
= ERROR_BUFFER_OVERFLOW
;
686 InterfaceIndexTable
*table
= NULL
;
687 PMIB_IPADDRTABLE ipAddrTable
= NULL
;
688 PMIB_IPFORWARDTABLE routeTable
= NULL
;
690 ret
= getIPAddrTable(&ipAddrTable
, GetProcessHeap(), 0);
692 ret
= getRouteTable(&routeTable
, GetProcessHeap(), 0);
694 table
= getNonLoopbackInterfaceIndexTable();
696 size
= sizeof(IP_ADAPTER_INFO
) * table
->numIndexes
;
697 size
+= ipAddrTable
->dwNumEntries
* sizeof(IP_ADDR_STRING
);
698 if (*pOutBufLen
< size
) {
700 ret
= ERROR_INSUFFICIENT_BUFFER
;
705 BOOL winsEnabled
= FALSE
;
706 IP_ADDRESS_STRING primaryWINS
, secondaryWINS
;
707 PIP_ADDR_STRING nextIPAddr
= (PIP_ADDR_STRING
)((LPBYTE
)pAdapterInfo
708 + numNonLoopbackInterfaces
* sizeof(IP_ADAPTER_INFO
));
710 memset(pAdapterInfo
, 0, size
);
711 /* @@ Wine registry key: HKCU\Software\Wine\Network */
712 if (RegOpenKeyA(HKEY_CURRENT_USER
, "Software\\Wine\\Network",
713 &hKey
) == ERROR_SUCCESS
) {
714 DWORD size
= sizeof(primaryWINS
.String
);
717 RegQueryValueExA(hKey
, "WinsServer", NULL
, NULL
,
718 (LPBYTE
)primaryWINS
.String
, &size
);
719 addr
= inet_addr(primaryWINS
.String
);
720 if (addr
!= INADDR_NONE
&& addr
!= INADDR_ANY
)
722 size
= sizeof(secondaryWINS
.String
);
723 RegQueryValueExA(hKey
, "BackupWinsServer", NULL
, NULL
,
724 (LPBYTE
)secondaryWINS
.String
, &size
);
725 addr
= inet_addr(secondaryWINS
.String
);
726 if (addr
!= INADDR_NONE
&& addr
!= INADDR_ANY
)
730 for (ndx
= 0; ndx
< table
->numIndexes
; ndx
++) {
731 PIP_ADAPTER_INFO ptr
= &pAdapterInfo
[ndx
];
733 PIP_ADDR_STRING currentIPAddr
= &ptr
->IpAddressList
;
734 BOOL firstIPAddr
= TRUE
;
736 /* on Win98 this is left empty, but whatever */
737 getInterfaceNameByIndex(table
->indexes
[ndx
], ptr
->AdapterName
);
738 ptr
->AddressLength
= sizeof(ptr
->Address
);
739 getInterfacePhysicalByIndex(table
->indexes
[ndx
],
740 &ptr
->AddressLength
, ptr
->Address
, &ptr
->Type
);
741 ptr
->Index
= table
->indexes
[ndx
];
742 for (i
= 0; i
< ipAddrTable
->dwNumEntries
; i
++) {
743 if (ipAddrTable
->table
[i
].dwIndex
== ptr
->Index
) {
745 toIPAddressString(ipAddrTable
->table
[i
].dwAddr
,
746 ptr
->IpAddressList
.IpAddress
.String
);
747 toIPAddressString(ipAddrTable
->table
[i
].dwMask
,
748 ptr
->IpAddressList
.IpMask
.String
);
752 currentIPAddr
->Next
= nextIPAddr
;
753 currentIPAddr
= nextIPAddr
;
754 toIPAddressString(ipAddrTable
->table
[i
].dwAddr
,
755 currentIPAddr
->IpAddress
.String
);
756 toIPAddressString(ipAddrTable
->table
[i
].dwMask
,
757 currentIPAddr
->IpMask
.String
);
762 /* Find first router through this interface, which we'll assume
763 * is the default gateway for this adapter */
764 for (i
= 0; i
< routeTable
->dwNumEntries
; i
++)
765 if (routeTable
->table
[i
].dwForwardIfIndex
== ptr
->Index
766 && routeTable
->table
[i
].dwForwardType
==
767 MIB_IPROUTE_TYPE_INDIRECT
)
768 toIPAddressString(routeTable
->table
[i
].dwForwardNextHop
,
769 ptr
->GatewayList
.IpAddress
.String
);
771 ptr
->HaveWins
= TRUE
;
772 memcpy(ptr
->PrimaryWinsServer
.IpAddress
.String
,
773 primaryWINS
.String
, sizeof(primaryWINS
.String
));
774 memcpy(ptr
->SecondaryWinsServer
.IpAddress
.String
,
775 secondaryWINS
.String
, sizeof(secondaryWINS
.String
));
777 if (ndx
< table
->numIndexes
- 1)
778 ptr
->Next
= &pAdapterInfo
[ndx
+ 1];
784 HeapFree(GetProcessHeap(), 0, table
);
787 ret
= ERROR_OUTOFMEMORY
;
788 HeapFree(GetProcessHeap(), 0, routeTable
);
789 HeapFree(GetProcessHeap(), 0, ipAddrTable
);
795 TRACE("returning %d\n", ret
);
800 /******************************************************************
801 * GetBestInterface (IPHLPAPI.@)
803 * Get the interface, with the best route for the given IP address.
806 * dwDestAddr [In] IP address to search the interface for
807 * pdwBestIfIndex [Out] found best interface
811 * Failure: error code from winerror.h
813 DWORD WINAPI
GetBestInterface(IPAddr dwDestAddr
, PDWORD pdwBestIfIndex
)
817 TRACE("dwDestAddr 0x%08lx, pdwBestIfIndex %p\n", dwDestAddr
, pdwBestIfIndex
);
819 ret
= ERROR_INVALID_PARAMETER
;
821 MIB_IPFORWARDROW ipRow
;
823 ret
= GetBestRoute(dwDestAddr
, 0, &ipRow
);
824 if (ret
== ERROR_SUCCESS
)
825 *pdwBestIfIndex
= ipRow
.dwForwardIfIndex
;
827 TRACE("returning %d\n", ret
);
832 /******************************************************************
833 * GetBestRoute (IPHLPAPI.@)
835 * Get the best route for the given IP address.
838 * dwDestAddr [In] IP address to search the best route for
839 * dwSourceAddr [In] optional source IP address
840 * pBestRoute [Out] found best route
844 * Failure: error code from winerror.h
846 DWORD WINAPI
GetBestRoute(DWORD dwDestAddr
, DWORD dwSourceAddr
, PMIB_IPFORWARDROW pBestRoute
)
848 PMIB_IPFORWARDTABLE table
;
851 TRACE("dwDestAddr 0x%08x, dwSourceAddr 0x%08x, pBestRoute %p\n", dwDestAddr
,
852 dwSourceAddr
, pBestRoute
);
854 return ERROR_INVALID_PARAMETER
;
856 ret
= AllocateAndGetIpForwardTableFromStack(&table
, FALSE
, GetProcessHeap(), 0);
858 DWORD ndx
, matchedBits
, matchedNdx
= table
->dwNumEntries
;
860 for (ndx
= 0, matchedBits
= 0; ndx
< table
->dwNumEntries
; ndx
++) {
861 if (table
->table
[ndx
].dwForwardType
!= MIB_IPROUTE_TYPE_INVALID
&&
862 (dwDestAddr
& table
->table
[ndx
].dwForwardMask
) ==
863 (table
->table
[ndx
].dwForwardDest
& table
->table
[ndx
].dwForwardMask
)) {
864 DWORD numShifts
, mask
;
866 for (numShifts
= 0, mask
= table
->table
[ndx
].dwForwardMask
;
867 mask
&& !(mask
& 1); mask
>>= 1, numShifts
++)
869 if (numShifts
> matchedBits
) {
870 matchedBits
= numShifts
;
873 else if (!matchedBits
&& table
->table
[ndx
].dwForwardType
==
874 MIB_IPROUTE_TYPE_INDIRECT
) {
875 /* default to a default gateway */
880 if (matchedNdx
< table
->dwNumEntries
) {
881 memcpy(pBestRoute
, &table
->table
[matchedNdx
], sizeof(MIB_IPFORWARDROW
));
885 /* No route matches, which can happen if there's no default route. */
886 ret
= ERROR_HOST_UNREACHABLE
;
888 HeapFree(GetProcessHeap(), 0, table
);
890 TRACE("returning %d\n", ret
);
895 /******************************************************************
896 * GetFriendlyIfIndex (IPHLPAPI.@)
898 * Get a "friendly" version of IfIndex, which is one that doesn't
899 * have the top byte set. Doesn't validate whether IfIndex is a valid
903 * IfIndex [In] interface index to get the friendly one for
906 * A friendly version of IfIndex.
908 DWORD WINAPI
GetFriendlyIfIndex(DWORD IfIndex
)
910 /* windows doesn't validate these, either, just makes sure the top byte is
911 cleared. I assume my ifenum module never gives an index with the top
913 TRACE("returning %d\n", IfIndex
);
918 /******************************************************************
919 * GetIcmpStatistics (IPHLPAPI.@)
921 * Get the ICMP statistics for the local computer.
924 * pStats [Out] buffer for ICMP statistics
928 * Failure: error code from winerror.h
930 DWORD WINAPI
GetIcmpStatistics(PMIB_ICMP pStats
)
934 TRACE("pStats %p\n", pStats
);
935 ret
= getICMPStats(pStats
);
936 TRACE("returning %d\n", ret
);
941 /******************************************************************
942 * GetIfEntry (IPHLPAPI.@)
944 * Get information about an interface.
947 * pIfRow [In/Out] In: dwIndex of MIB_IFROW selects the interface.
948 * Out: interface information
952 * Failure: error code from winerror.h
954 DWORD WINAPI
GetIfEntry(PMIB_IFROW pIfRow
)
957 char nameBuf
[MAX_ADAPTER_NAME
];
960 TRACE("pIfRow %p\n", pIfRow
);
962 return ERROR_INVALID_PARAMETER
;
964 name
= getInterfaceNameByIndex(pIfRow
->dwIndex
, nameBuf
);
966 ret
= getInterfaceEntryByName(name
, pIfRow
);
968 ret
= getInterfaceStatsByName(name
, pIfRow
);
971 ret
= ERROR_INVALID_DATA
;
972 TRACE("returning %d\n", ret
);
977 static int IfTableSorter(const void *a
, const void *b
)
982 ret
= ((const MIB_IFROW
*)a
)->dwIndex
- ((const MIB_IFROW
*)b
)->dwIndex
;
989 /******************************************************************
990 * GetIfTable (IPHLPAPI.@)
992 * Get a table of local interfaces.
995 * pIfTable [Out] buffer for local interfaces table
996 * pdwSize [In/Out] length of output buffer
997 * bOrder [In] whether to sort the table
1001 * Failure: error code from winerror.h
1004 * If pdwSize is less than required, the function will return
1005 * ERROR_INSUFFICIENT_BUFFER, and *pdwSize will be set to the required byte
1007 * If bOrder is true, the returned table will be sorted by interface index.
1009 DWORD WINAPI
GetIfTable(PMIB_IFTABLE pIfTable
, PULONG pdwSize
, BOOL bOrder
)
1013 TRACE("pIfTable %p, pdwSize %p, bOrder %d\n", pdwSize
, pdwSize
,
1016 ret
= ERROR_INVALID_PARAMETER
;
1018 DWORD numInterfaces
= getNumInterfaces();
1019 ULONG size
= sizeof(MIB_IFTABLE
);
1021 if (numInterfaces
> 1)
1022 size
+= (numInterfaces
- 1) * sizeof(MIB_IFROW
);
1023 if (!pIfTable
|| *pdwSize
< size
) {
1025 ret
= ERROR_INSUFFICIENT_BUFFER
;
1028 InterfaceIndexTable
*table
= getInterfaceIndexTable();
1031 size
= sizeof(MIB_IFTABLE
);
1032 if (table
->numIndexes
> 1)
1033 size
+= (table
->numIndexes
- 1) * sizeof(MIB_IFROW
);
1034 if (*pdwSize
< size
) {
1036 ret
= ERROR_INSUFFICIENT_BUFFER
;
1042 pIfTable
->dwNumEntries
= 0;
1043 for (ndx
= 0; ndx
< table
->numIndexes
; ndx
++) {
1044 pIfTable
->table
[ndx
].dwIndex
= table
->indexes
[ndx
];
1045 GetIfEntry(&pIfTable
->table
[ndx
]);
1046 pIfTable
->dwNumEntries
++;
1049 qsort(pIfTable
->table
, pIfTable
->dwNumEntries
, sizeof(MIB_IFROW
),
1053 HeapFree(GetProcessHeap(), 0, table
);
1056 ret
= ERROR_OUTOFMEMORY
;
1059 TRACE("returning %d\n", ret
);
1064 /******************************************************************
1065 * GetInterfaceInfo (IPHLPAPI.@)
1067 * Get a list of network interface adapters.
1070 * pIfTable [Out] buffer for interface adapters
1071 * dwOutBufLen [Out] if buffer is too small, returns required size
1075 * Failure: error code from winerror.h
1078 * MSDN states this should return non-loopback interfaces only.
1080 DWORD WINAPI
GetInterfaceInfo(PIP_INTERFACE_INFO pIfTable
, PULONG dwOutBufLen
)
1084 TRACE("pIfTable %p, dwOutBufLen %p\n", pIfTable
, dwOutBufLen
);
1086 ret
= ERROR_INVALID_PARAMETER
;
1088 DWORD numInterfaces
= getNumInterfaces();
1089 ULONG size
= sizeof(IP_INTERFACE_INFO
);
1091 if (numInterfaces
> 1)
1092 size
+= (numInterfaces
- 1) * sizeof(IP_ADAPTER_INDEX_MAP
);
1093 if (!pIfTable
|| *dwOutBufLen
< size
) {
1094 *dwOutBufLen
= size
;
1095 ret
= ERROR_INSUFFICIENT_BUFFER
;
1098 InterfaceIndexTable
*table
= getInterfaceIndexTable();
1101 size
= sizeof(IP_INTERFACE_INFO
);
1102 if (table
->numIndexes
> 1)
1103 size
+= (table
->numIndexes
- 1) * sizeof(IP_ADAPTER_INDEX_MAP
);
1104 if (*dwOutBufLen
< size
) {
1105 *dwOutBufLen
= size
;
1106 ret
= ERROR_INSUFFICIENT_BUFFER
;
1110 char nameBuf
[MAX_ADAPTER_NAME
];
1112 *dwOutBufLen
= size
;
1113 pIfTable
->NumAdapters
= 0;
1114 for (ndx
= 0; ndx
< table
->numIndexes
; ndx
++) {
1115 const char *walker
, *name
;
1118 pIfTable
->Adapter
[ndx
].Index
= table
->indexes
[ndx
];
1119 name
= getInterfaceNameByIndex(table
->indexes
[ndx
], nameBuf
);
1120 for (walker
= name
, assigner
= pIfTable
->Adapter
[ndx
].Name
;
1121 walker
&& *walker
&&
1122 assigner
- pIfTable
->Adapter
[ndx
].Name
< MAX_ADAPTER_NAME
- 1;
1123 walker
++, assigner
++)
1124 *assigner
= *walker
;
1126 pIfTable
->NumAdapters
++;
1130 HeapFree(GetProcessHeap(), 0, table
);
1133 ret
= ERROR_OUTOFMEMORY
;
1136 TRACE("returning %d\n", ret
);
1141 /******************************************************************
1142 * GetIpAddrTable (IPHLPAPI.@)
1144 * Get interface-to-IP address mapping table.
1147 * pIpAddrTable [Out] buffer for mapping table
1148 * pdwSize [In/Out] length of output buffer
1149 * bOrder [In] whether to sort the table
1153 * Failure: error code from winerror.h
1156 * If pdwSize is less than required, the function will return
1157 * ERROR_INSUFFICIENT_BUFFER, and *pdwSize will be set to the required byte
1159 * If bOrder is true, the returned table will be sorted by the next hop and
1160 * an assortment of arbitrary parameters.
1162 DWORD WINAPI
GetIpAddrTable(PMIB_IPADDRTABLE pIpAddrTable
, PULONG pdwSize
, BOOL bOrder
)
1166 TRACE("pIpAddrTable %p, pdwSize %p, bOrder %d\n", pIpAddrTable
, pdwSize
,
1169 ret
= ERROR_INVALID_PARAMETER
;
1171 PMIB_IPADDRTABLE table
;
1173 ret
= getIPAddrTable(&table
, GetProcessHeap(), 0);
1174 if (ret
== NO_ERROR
)
1176 ULONG size
= sizeof(MIB_IPADDRTABLE
);
1178 if (table
->dwNumEntries
> 1)
1179 size
+= (table
->dwNumEntries
- 1) * sizeof(MIB_IPADDRROW
);
1180 if (!pIpAddrTable
|| *pdwSize
< size
) {
1182 ret
= ERROR_INSUFFICIENT_BUFFER
;
1186 memcpy(pIpAddrTable
, table
, size
);
1188 qsort(pIpAddrTable
->table
, pIpAddrTable
->dwNumEntries
,
1189 sizeof(MIB_IPADDRROW
), IpAddrTableSorter
);
1192 HeapFree(GetProcessHeap(), 0, table
);
1195 TRACE("returning %d\n", ret
);
1200 /******************************************************************
1201 * GetIpForwardTable (IPHLPAPI.@)
1203 * Get the route table.
1206 * pIpForwardTable [Out] buffer for route table
1207 * pdwSize [In/Out] length of output buffer
1208 * bOrder [In] whether to sort the table
1212 * Failure: error code from winerror.h
1215 * If pdwSize is less than required, the function will return
1216 * ERROR_INSUFFICIENT_BUFFER, and *pdwSize will be set to the required byte
1218 * If bOrder is true, the returned table will be sorted by the next hop and
1219 * an assortment of arbitrary parameters.
1221 DWORD WINAPI
GetIpForwardTable(PMIB_IPFORWARDTABLE pIpForwardTable
, PULONG pdwSize
, BOOL bOrder
)
1225 TRACE("pIpForwardTable %p, pdwSize %p, bOrder %d\n", pIpForwardTable
,
1226 pdwSize
, (DWORD
)bOrder
);
1228 ret
= ERROR_INVALID_PARAMETER
;
1230 DWORD numRoutes
= getNumRoutes();
1231 ULONG sizeNeeded
= sizeof(MIB_IPFORWARDTABLE
);
1234 sizeNeeded
+= (numRoutes
- 1) * sizeof(MIB_IPFORWARDROW
);
1235 if (!pIpForwardTable
|| *pdwSize
< sizeNeeded
) {
1236 *pdwSize
= sizeNeeded
;
1237 ret
= ERROR_INSUFFICIENT_BUFFER
;
1240 PMIB_IPFORWARDTABLE table
;
1242 ret
= getRouteTable(&table
, GetProcessHeap(), 0);
1244 sizeNeeded
= sizeof(MIB_IPFORWARDTABLE
);
1245 if (table
->dwNumEntries
> 1)
1246 sizeNeeded
+= (table
->dwNumEntries
- 1) * sizeof(MIB_IPFORWARDROW
);
1247 if (*pdwSize
< sizeNeeded
) {
1248 *pdwSize
= sizeNeeded
;
1249 ret
= ERROR_INSUFFICIENT_BUFFER
;
1252 *pdwSize
= sizeNeeded
;
1253 memcpy(pIpForwardTable
, table
, sizeNeeded
);
1255 qsort(pIpForwardTable
->table
, pIpForwardTable
->dwNumEntries
,
1256 sizeof(MIB_IPFORWARDROW
), IpForwardTableSorter
);
1259 HeapFree(GetProcessHeap(), 0, table
);
1263 TRACE("returning %d\n", ret
);
1268 /******************************************************************
1269 * GetIpNetTable (IPHLPAPI.@)
1271 * Get the IP-to-physical address mapping table.
1274 * pIpNetTable [Out] buffer for mapping table
1275 * pdwSize [In/Out] length of output buffer
1276 * bOrder [In] whether to sort the table
1280 * Failure: error code from winerror.h
1283 * If pdwSize is less than required, the function will return
1284 * ERROR_INSUFFICIENT_BUFFER, and *pdwSize will be set to the required byte
1286 * If bOrder is true, the returned table will be sorted by IP address.
1288 DWORD WINAPI
GetIpNetTable(PMIB_IPNETTABLE pIpNetTable
, PULONG pdwSize
, BOOL bOrder
)
1292 TRACE("pIpNetTable %p, pdwSize %p, bOrder %d\n", pIpNetTable
, pdwSize
,
1295 ret
= ERROR_INVALID_PARAMETER
;
1297 DWORD numEntries
= getNumArpEntries();
1298 ULONG size
= sizeof(MIB_IPNETTABLE
);
1301 size
+= (numEntries
- 1) * sizeof(MIB_IPNETROW
);
1302 if (!pIpNetTable
|| *pdwSize
< size
) {
1304 ret
= ERROR_INSUFFICIENT_BUFFER
;
1307 PMIB_IPNETTABLE table
;
1309 ret
= getArpTable(&table
, GetProcessHeap(), 0);
1311 size
= sizeof(MIB_IPNETTABLE
);
1312 if (table
->dwNumEntries
> 1)
1313 size
+= (table
->dwNumEntries
- 1) * sizeof(MIB_IPNETROW
);
1314 if (*pdwSize
< size
) {
1316 ret
= ERROR_INSUFFICIENT_BUFFER
;
1320 memcpy(pIpNetTable
, table
, size
);
1322 qsort(pIpNetTable
->table
, pIpNetTable
->dwNumEntries
,
1323 sizeof(MIB_IPNETROW
), IpNetTableSorter
);
1326 HeapFree(GetProcessHeap(), 0, table
);
1330 TRACE("returning %d\n", ret
);
1335 /******************************************************************
1336 * GetIpStatistics (IPHLPAPI.@)
1338 * Get the IP statistics for the local computer.
1341 * pStats [Out] buffer for IP statistics
1345 * Failure: error code from winerror.h
1347 DWORD WINAPI
GetIpStatistics(PMIB_IPSTATS pStats
)
1351 TRACE("pStats %p\n", pStats
);
1352 ret
= getIPStats(pStats
);
1353 TRACE("returning %d\n", ret
);
1358 /******************************************************************
1359 * GetNetworkParams (IPHLPAPI.@)
1361 * Get the network parameters for the local computer.
1364 * pFixedInfo [Out] buffer for network parameters
1365 * pOutBufLen [In/Out] length of output buffer
1369 * Failure: error code from winerror.h
1372 * If pOutBufLen is less than required, the function will return
1373 * ERROR_INSUFFICIENT_BUFFER, and pOutBufLen will be set to the required byte
1376 DWORD WINAPI
GetNetworkParams(PFIXED_INFO pFixedInfo
, PULONG pOutBufLen
)
1382 TRACE("pFixedInfo %p, pOutBufLen %p\n", pFixedInfo
, pOutBufLen
);
1384 return ERROR_INVALID_PARAMETER
;
1386 initialise_resolver();
1387 size
= sizeof(FIXED_INFO
) + (_res
.nscount
> 0 ? (_res
.nscount
- 1) *
1388 sizeof(IP_ADDR_STRING
) : 0);
1389 if (!pFixedInfo
|| *pOutBufLen
< size
) {
1391 return ERROR_BUFFER_OVERFLOW
;
1394 memset(pFixedInfo
, 0, size
);
1395 size
= sizeof(pFixedInfo
->HostName
);
1396 GetComputerNameExA(ComputerNameDnsHostname
, pFixedInfo
->HostName
, &size
);
1397 size
= sizeof(pFixedInfo
->DomainName
);
1398 GetComputerNameExA(ComputerNameDnsDomain
, pFixedInfo
->DomainName
, &size
);
1399 if (_res
.nscount
> 0) {
1400 PIP_ADDR_STRING ptr
;
1403 for (i
= 0, ptr
= &pFixedInfo
->DnsServerList
; i
< _res
.nscount
&& ptr
;
1404 i
++, ptr
= ptr
->Next
) {
1405 toIPAddressString(_res
.nsaddr_list
[i
].sin_addr
.s_addr
,
1406 ptr
->IpAddress
.String
);
1407 if (i
== _res
.nscount
- 1)
1410 ptr
->Next
= (PIP_ADDR_STRING
)((LPBYTE
)pFixedInfo
+ sizeof(FIXED_INFO
));
1412 ptr
->Next
= (PIP_ADDR_STRING
)((PBYTE
)ptr
+ sizeof(IP_ADDR_STRING
));
1415 pFixedInfo
->NodeType
= HYBRID_NODETYPE
;
1416 regReturn
= RegOpenKeyExA(HKEY_LOCAL_MACHINE
,
1417 "SYSTEM\\CurrentControlSet\\Services\\VxD\\MSTCP", 0, KEY_READ
, &hKey
);
1418 if (regReturn
!= ERROR_SUCCESS
)
1419 regReturn
= RegOpenKeyExA(HKEY_LOCAL_MACHINE
,
1420 "SYSTEM\\CurrentControlSet\\Services\\NetBT\\Parameters", 0, KEY_READ
,
1422 if (regReturn
== ERROR_SUCCESS
)
1424 DWORD size
= sizeof(pFixedInfo
->ScopeId
);
1426 RegQueryValueExA(hKey
, "ScopeID", NULL
, NULL
, (LPBYTE
)pFixedInfo
->ScopeId
, &size
);
1430 /* FIXME: can check whether routing's enabled in /proc/sys/net/ipv4/ip_forward
1431 I suppose could also check for a listener on port 53 to set EnableDns */
1433 TRACE("returning %d\n", ret
);
1438 /******************************************************************
1439 * GetNumberOfInterfaces (IPHLPAPI.@)
1441 * Get the number of interfaces.
1444 * pdwNumIf [Out] number of interfaces
1447 * NO_ERROR on success, ERROR_INVALID_PARAMETER if pdwNumIf is NULL.
1449 DWORD WINAPI
GetNumberOfInterfaces(PDWORD pdwNumIf
)
1453 TRACE("pdwNumIf %p\n", pdwNumIf
);
1455 ret
= ERROR_INVALID_PARAMETER
;
1457 *pdwNumIf
= getNumInterfaces();
1460 TRACE("returning %d\n", ret
);
1465 /******************************************************************
1466 * GetPerAdapterInfo (IPHLPAPI.@)
1468 * Get information about an adapter corresponding to an interface.
1471 * IfIndex [In] interface info
1472 * pPerAdapterInfo [Out] buffer for per adapter info
1473 * pOutBufLen [In/Out] length of output buffer
1477 * Failure: error code from winerror.h
1480 * Stub, returns empty IP_PER_ADAPTER_INFO in every case.
1482 DWORD WINAPI
GetPerAdapterInfo(ULONG IfIndex
, PIP_PER_ADAPTER_INFO pPerAdapterInfo
, PULONG pOutBufLen
)
1484 ULONG bytesNeeded
= sizeof(IP_PER_ADAPTER_INFO
);
1487 TRACE("(IfIndex %d, pPerAdapterInfo %p, pOutBufLen %p)\n", IfIndex
,
1488 pPerAdapterInfo
, pOutBufLen
);
1490 ret
= ERROR_INVALID_PARAMETER
;
1491 else if (!pPerAdapterInfo
)
1493 *pOutBufLen
= bytesNeeded
;
1496 else if (*pOutBufLen
< bytesNeeded
)
1498 *pOutBufLen
= bytesNeeded
;
1499 ret
= ERROR_BUFFER_OVERFLOW
;
1503 memset(pPerAdapterInfo
, 0, bytesNeeded
);
1510 /******************************************************************
1511 * GetRTTAndHopCount (IPHLPAPI.@)
1513 * Get round-trip time (RTT) and hop count.
1517 * DestIpAddress [In] destination address to get the info for
1518 * HopCount [Out] retrieved hop count
1519 * MaxHops [In] maximum hops to search for the destination
1520 * RTT [Out] RTT in milliseconds
1527 * Stub, returns FALSE.
1529 BOOL WINAPI
GetRTTAndHopCount(IPAddr DestIpAddress
, PULONG HopCount
, ULONG MaxHops
, PULONG RTT
)
1531 FIXME("(DestIpAddress 0x%08lx, HopCount %p, MaxHops %d, RTT %p): stub\n",
1532 DestIpAddress
, HopCount
, MaxHops
, RTT
);
1537 /******************************************************************
1538 * GetTcpStatistics (IPHLPAPI.@)
1540 * Get the TCP statistics for the local computer.
1543 * pStats [Out] buffer for TCP statistics
1547 * Failure: error code from winerror.h
1549 DWORD WINAPI
GetTcpStatistics(PMIB_TCPSTATS pStats
)
1553 TRACE("pStats %p\n", pStats
);
1554 ret
= getTCPStats(pStats
);
1555 TRACE("returning %d\n", ret
);
1560 /******************************************************************
1561 * GetTcpTable (IPHLPAPI.@)
1563 * Get the table of active TCP connections.
1566 * pTcpTable [Out] buffer for TCP connections table
1567 * pdwSize [In/Out] length of output buffer
1568 * bOrder [In] whether to order the table
1572 * Failure: error code from winerror.h
1575 * If pdwSize is less than required, the function will return
1576 * ERROR_INSUFFICIENT_BUFFER, and *pdwSize will be set to
1577 * the required byte size.
1578 * If bOrder is true, the returned table will be sorted, first by
1579 * local address and port number, then by remote address and port
1582 DWORD WINAPI
GetTcpTable(PMIB_TCPTABLE pTcpTable
, PDWORD pdwSize
, BOOL bOrder
)
1586 TRACE("pTcpTable %p, pdwSize %p, bOrder %d\n", pTcpTable
, pdwSize
,
1589 ret
= ERROR_INVALID_PARAMETER
;
1591 DWORD numEntries
= getNumTcpEntries();
1592 DWORD size
= sizeof(MIB_TCPTABLE
);
1595 size
+= (numEntries
- 1) * sizeof(MIB_TCPROW
);
1596 if (!pTcpTable
|| *pdwSize
< size
) {
1598 ret
= ERROR_INSUFFICIENT_BUFFER
;
1601 ret
= getTcpTable(&pTcpTable
, numEntries
, 0, 0);
1603 size
= sizeof(MIB_TCPTABLE
);
1604 if (pTcpTable
->dwNumEntries
> 1)
1605 size
+= (pTcpTable
->dwNumEntries
- 1) * sizeof(MIB_TCPROW
);
1609 qsort(pTcpTable
->table
, pTcpTable
->dwNumEntries
,
1610 sizeof(MIB_TCPROW
), TcpTableSorter
);
1615 TRACE("returning %d\n", ret
);
1620 /******************************************************************
1621 * GetUdpStatistics (IPHLPAPI.@)
1623 * Get the UDP statistics for the local computer.
1626 * pStats [Out] buffer for UDP statistics
1630 * Failure: error code from winerror.h
1632 DWORD WINAPI
GetUdpStatistics(PMIB_UDPSTATS pStats
)
1636 TRACE("pStats %p\n", pStats
);
1637 ret
= getUDPStats(pStats
);
1638 TRACE("returning %d\n", ret
);
1643 /******************************************************************
1644 * GetUdpTable (IPHLPAPI.@)
1646 * Get a table of active UDP connections.
1649 * pUdpTable [Out] buffer for UDP connections table
1650 * pdwSize [In/Out] length of output buffer
1651 * bOrder [In] whether to order the table
1655 * Failure: error code from winerror.h
1658 * If pdwSize is less than required, the function will return
1659 * ERROR_INSUFFICIENT_BUFFER, and *pdwSize will be set to the
1660 * required byte size.
1661 * If bOrder is true, the returned table will be sorted, first by
1662 * local address, then by local port number.
1664 DWORD WINAPI
GetUdpTable(PMIB_UDPTABLE pUdpTable
, PDWORD pdwSize
, BOOL bOrder
)
1668 TRACE("pUdpTable %p, pdwSize %p, bOrder %d\n", pUdpTable
, pdwSize
,
1671 ret
= ERROR_INVALID_PARAMETER
;
1673 DWORD numEntries
= getNumUdpEntries();
1674 DWORD size
= sizeof(MIB_UDPTABLE
);
1677 size
+= (numEntries
- 1) * sizeof(MIB_UDPROW
);
1678 if (!pUdpTable
|| *pdwSize
< size
) {
1680 ret
= ERROR_INSUFFICIENT_BUFFER
;
1683 PMIB_UDPTABLE table
;
1685 ret
= getUdpTable(&table
, GetProcessHeap(), 0);
1687 size
= sizeof(MIB_UDPTABLE
);
1688 if (table
->dwNumEntries
> 1)
1689 size
+= (table
->dwNumEntries
- 1) * sizeof(MIB_UDPROW
);
1690 if (*pdwSize
< size
) {
1692 ret
= ERROR_INSUFFICIENT_BUFFER
;
1696 memcpy(pUdpTable
, table
, size
);
1698 qsort(pUdpTable
->table
, pUdpTable
->dwNumEntries
,
1699 sizeof(MIB_UDPROW
), UdpTableSorter
);
1702 HeapFree(GetProcessHeap(), 0, table
);
1705 ret
= ERROR_OUTOFMEMORY
;
1708 TRACE("returning %d\n", ret
);
1713 /******************************************************************
1714 * GetUniDirectionalAdapterInfo (IPHLPAPI.@)
1716 * This is a Win98-only function to get information on "unidirectional"
1717 * adapters. Since this is pretty nonsensical in other contexts, it
1718 * never returns anything.
1721 * pIPIfInfo [Out] buffer for adapter infos
1722 * dwOutBufLen [Out] length of the output buffer
1726 * Failure: error code from winerror.h
1729 * Stub, returns ERROR_NOT_SUPPORTED.
1731 DWORD WINAPI
GetUniDirectionalAdapterInfo(PIP_UNIDIRECTIONAL_ADAPTER_ADDRESS pIPIfInfo
, PULONG dwOutBufLen
)
1733 TRACE("pIPIfInfo %p, dwOutBufLen %p\n", pIPIfInfo
, dwOutBufLen
);
1734 /* a unidirectional adapter?? not bloody likely! */
1735 return ERROR_NOT_SUPPORTED
;
1739 /******************************************************************
1740 * IpReleaseAddress (IPHLPAPI.@)
1742 * Release an IP optained through DHCP,
1745 * AdapterInfo [In] adapter to release IP address
1749 * Failure: error code from winerror.h
1752 * Since GetAdaptersInfo never returns adapters that have DHCP enabled,
1753 * this function does nothing.
1756 * Stub, returns ERROR_NOT_SUPPORTED.
1758 DWORD WINAPI
IpReleaseAddress(PIP_ADAPTER_INDEX_MAP AdapterInfo
)
1760 TRACE("AdapterInfo %p\n", AdapterInfo
);
1761 /* not a stub, never going to support this (and I never mark an adapter as
1762 DHCP enabled, see GetAdaptersInfo, so this should never get called) */
1763 return ERROR_NOT_SUPPORTED
;
1767 /******************************************************************
1768 * IpRenewAddress (IPHLPAPI.@)
1770 * Renew an IP optained through DHCP.
1773 * AdapterInfo [In] adapter to renew IP address
1777 * Failure: error code from winerror.h
1780 * Since GetAdaptersInfo never returns adapters that have DHCP enabled,
1781 * this function does nothing.
1784 * Stub, returns ERROR_NOT_SUPPORTED.
1786 DWORD WINAPI
IpRenewAddress(PIP_ADAPTER_INDEX_MAP AdapterInfo
)
1788 TRACE("AdapterInfo %p\n", AdapterInfo
);
1789 /* not a stub, never going to support this (and I never mark an adapter as
1790 DHCP enabled, see GetAdaptersInfo, so this should never get called) */
1791 return ERROR_NOT_SUPPORTED
;
1795 /******************************************************************
1796 * NotifyAddrChange (IPHLPAPI.@)
1798 * Notify caller whenever the ip-interface map is changed.
1801 * Handle [Out] handle useable in asynchronus notification
1802 * overlapped [In] overlapped structure that notifies the caller
1806 * Failure: error code from winerror.h
1809 * Stub, returns ERROR_NOT_SUPPORTED.
1811 DWORD WINAPI
NotifyAddrChange(PHANDLE Handle
, LPOVERLAPPED overlapped
)
1813 FIXME("(Handle %p, overlapped %p): stub\n", Handle
, overlapped
);
1814 return ERROR_NOT_SUPPORTED
;
1818 /******************************************************************
1819 * NotifyRouteChange (IPHLPAPI.@)
1821 * Notify caller whenever the ip routing table is changed.
1824 * Handle [Out] handle useable in asynchronus notification
1825 * overlapped [In] overlapped structure that notifies the caller
1829 * Failure: error code from winerror.h
1832 * Stub, returns ERROR_NOT_SUPPORTED.
1834 DWORD WINAPI
NotifyRouteChange(PHANDLE Handle
, LPOVERLAPPED overlapped
)
1836 FIXME("(Handle %p, overlapped %p): stub\n", Handle
, overlapped
);
1837 return ERROR_NOT_SUPPORTED
;
1841 /******************************************************************
1842 * SendARP (IPHLPAPI.@)
1844 * Send an ARP request.
1847 * DestIP [In] attempt to obtain this IP
1848 * SrcIP [In] optional sender IP address
1849 * pMacAddr [Out] buffer for the mac address
1850 * PhyAddrLen [In/Out] length of the output buffer
1854 * Failure: error code from winerror.h
1857 * Stub, returns ERROR_NOT_SUPPORTED.
1859 DWORD WINAPI
SendARP(IPAddr DestIP
, IPAddr SrcIP
, PULONG pMacAddr
, PULONG PhyAddrLen
)
1861 FIXME("(DestIP 0x%08lx, SrcIP 0x%08lx, pMacAddr %p, PhyAddrLen %p): stub\n",
1862 DestIP
, SrcIP
, pMacAddr
, PhyAddrLen
);
1863 return ERROR_NOT_SUPPORTED
;
1867 /******************************************************************
1868 * SetIfEntry (IPHLPAPI.@)
1870 * Set the administrative status of an interface.
1873 * pIfRow [In] dwAdminStatus member specifies the new status.
1877 * Failure: error code from winerror.h
1880 * Stub, returns ERROR_NOT_SUPPORTED.
1882 DWORD WINAPI
SetIfEntry(PMIB_IFROW pIfRow
)
1884 FIXME("(pIfRow %p): stub\n", pIfRow
);
1885 /* this is supposed to set an interface administratively up or down.
1886 Could do SIOCSIFFLAGS and set/clear IFF_UP, but, not sure I want to, and
1887 this sort of down is indistinguishable from other sorts of down (e.g. no
1889 return ERROR_NOT_SUPPORTED
;
1893 /******************************************************************
1894 * SetIpForwardEntry (IPHLPAPI.@)
1896 * Modify an existing route.
1899 * pRoute [In] route with the new information
1903 * Failure: error code from winerror.h
1906 * Stub, returns NO_ERROR.
1908 DWORD WINAPI
SetIpForwardEntry(PMIB_IPFORWARDROW pRoute
)
1910 FIXME("(pRoute %p): stub\n", pRoute
);
1911 /* this is to add a route entry, how's it distinguishable from
1912 CreateIpForwardEntry?
1913 could use SIOCADDRT, not sure I want to */
1918 /******************************************************************
1919 * SetIpNetEntry (IPHLPAPI.@)
1921 * Modify an existing ARP entry.
1924 * pArpEntry [In] ARP entry with the new information
1928 * Failure: error code from winerror.h
1931 * Stub, returns NO_ERROR.
1933 DWORD WINAPI
SetIpNetEntry(PMIB_IPNETROW pArpEntry
)
1935 FIXME("(pArpEntry %p): stub\n", pArpEntry
);
1936 /* same as CreateIpNetEntry here, could use SIOCSARP, not sure I want to */
1941 /******************************************************************
1942 * SetIpStatistics (IPHLPAPI.@)
1944 * Toggle IP forwarding and det the default TTL value.
1947 * pIpStats [In] IP statistics with the new information
1951 * Failure: error code from winerror.h
1954 * Stub, returns NO_ERROR.
1956 DWORD WINAPI
SetIpStatistics(PMIB_IPSTATS pIpStats
)
1958 FIXME("(pIpStats %p): stub\n", pIpStats
);
1963 /******************************************************************
1964 * SetIpTTL (IPHLPAPI.@)
1966 * Set the default TTL value.
1969 * nTTL [In] new TTL value
1973 * Failure: error code from winerror.h
1976 * Stub, returns NO_ERROR.
1978 DWORD WINAPI
SetIpTTL(UINT nTTL
)
1980 FIXME("(nTTL %d): stub\n", nTTL
);
1981 /* could echo nTTL > /proc/net/sys/net/ipv4/ip_default_ttl, not sure I
1982 want to. Could map EACCESS to ERROR_ACCESS_DENIED, I suppose */
1987 /******************************************************************
1988 * SetTcpEntry (IPHLPAPI.@)
1990 * Set the state of a TCP connection.
1993 * pTcpRow [In] specifies connection with new state
1997 * Failure: error code from winerror.h
2000 * Stub, returns NO_ERROR.
2002 DWORD WINAPI
SetTcpEntry(PMIB_TCPROW pTcpRow
)
2004 FIXME("(pTcpRow %p): stub\n", pTcpRow
);
2009 /******************************************************************
2010 * UnenableRouter (IPHLPAPI.@)
2012 * Decrement the IP-forwarding reference count. Turn off IP-forwarding
2013 * if it reaches zero.
2016 * pOverlapped [In/Out] should be the same as in EnableRouter()
2017 * lpdwEnableCount [Out] optional, receives reference count
2021 * Failure: error code from winerror.h
2024 * Stub, returns ERROR_NOT_SUPPORTED.
2026 DWORD WINAPI
UnenableRouter(OVERLAPPED
* pOverlapped
, LPDWORD lpdwEnableCount
)
2028 FIXME("(pOverlapped %p, lpdwEnableCount %p): stub\n", pOverlapped
,
2030 /* could echo "0" > /proc/net/sys/net/ipv4/ip_forward, not sure I want to
2031 could map EACCESS to ERROR_ACCESS_DENIED, I suppose
2033 return ERROR_NOT_SUPPORTED
;