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 BOOL WINAPI
DllMain (HINSTANCE hinstDLL
, DWORD fdwReason
, LPVOID lpvReserved
)
56 case DLL_PROCESS_ATTACH
:
57 DisableThreadLibraryCalls( hinstDLL
);
60 case DLL_PROCESS_DETACH
:
66 /******************************************************************
67 * AddIPAddress (IPHLPAPI.@)
69 * Add an IP address to an adapter.
72 * Address [In] IP address to add to the adapter
73 * IpMask [In] subnet mask for the IP address
74 * IfIndex [In] adapter index to add the address
75 * NTEContext [Out] Net Table Entry (NTE) context for the IP address
76 * NTEInstance [Out] NTE instance for the IP address
80 * Failure: error code from winerror.h
83 * Stub. Currently returns ERROR_NOT_SUPPORTED.
85 DWORD WINAPI
AddIPAddress(IPAddr Address
, IPMask IpMask
, DWORD IfIndex
, PULONG NTEContext
, PULONG NTEInstance
)
88 return ERROR_NOT_SUPPORTED
;
92 /******************************************************************
93 * AllocateAndGetIfTableFromStack (IPHLPAPI.@)
95 * Get table of local interfaces.
96 * Like GetIfTable(), but allocate the returned table from heap.
99 * ppIfTable [Out] pointer into which the MIB_IFTABLE is
100 * allocated and returned.
101 * bOrder [In] whether to sort the table
102 * heap [In] heap from which the table is allocated
103 * flags [In] flags to HeapAlloc
106 * ERROR_INVALID_PARAMETER if ppIfTable is NULL, whatever
107 * GetIfTable() returns otherwise.
109 DWORD WINAPI
AllocateAndGetIfTableFromStack(PMIB_IFTABLE
*ppIfTable
,
110 BOOL bOrder
, HANDLE heap
, DWORD flags
)
114 TRACE("ppIfTable %p, bOrder %d, heap %p, flags 0x%08x\n", ppIfTable
,
115 bOrder
, heap
, flags
);
117 ret
= ERROR_INVALID_PARAMETER
;
121 ret
= GetIfTable(*ppIfTable
, &dwSize
, bOrder
);
122 if (ret
== ERROR_INSUFFICIENT_BUFFER
) {
123 *ppIfTable
= HeapAlloc(heap
, flags
, dwSize
);
124 ret
= GetIfTable(*ppIfTable
, &dwSize
, bOrder
);
127 TRACE("returning %d\n", ret
);
132 static int IpAddrTableSorter(const void *a
, const void *b
)
137 ret
= ((const MIB_IPADDRROW
*)a
)->dwAddr
- ((const MIB_IPADDRROW
*)b
)->dwAddr
;
144 /******************************************************************
145 * AllocateAndGetIpAddrTableFromStack (IPHLPAPI.@)
147 * Get interface-to-IP address mapping table.
148 * Like GetIpAddrTable(), but allocate the returned table from heap.
151 * ppIpAddrTable [Out] pointer into which the MIB_IPADDRTABLE is
152 * allocated and returned.
153 * bOrder [In] whether to sort the table
154 * heap [In] heap from which the table is allocated
155 * flags [In] flags to HeapAlloc
158 * ERROR_INVALID_PARAMETER if ppIpAddrTable is NULL, other error codes on
159 * failure, NO_ERROR on success.
161 DWORD WINAPI
AllocateAndGetIpAddrTableFromStack(PMIB_IPADDRTABLE
*ppIpAddrTable
,
162 BOOL bOrder
, HANDLE heap
, DWORD flags
)
166 TRACE("ppIpAddrTable %p, bOrder %d, heap %p, flags 0x%08x\n",
167 ppIpAddrTable
, bOrder
, heap
, flags
);
168 ret
= getIPAddrTable(ppIpAddrTable
, heap
, flags
);
170 qsort((*ppIpAddrTable
)->table
, (*ppIpAddrTable
)->dwNumEntries
,
171 sizeof(MIB_IPADDRROW
), IpAddrTableSorter
);
172 TRACE("returning %d\n", ret
);
177 static int IpForwardTableSorter(const void *a
, const void *b
)
182 const MIB_IPFORWARDROW
* rowA
= (const MIB_IPFORWARDROW
*)a
;
183 const MIB_IPFORWARDROW
* rowB
= (const MIB_IPFORWARDROW
*)b
;
185 ret
= rowA
->dwForwardDest
- rowB
->dwForwardDest
;
187 ret
= rowA
->dwForwardProto
- rowB
->dwForwardProto
;
189 ret
= rowA
->dwForwardPolicy
- rowB
->dwForwardPolicy
;
191 ret
= rowA
->dwForwardNextHop
- rowB
->dwForwardNextHop
;
201 /******************************************************************
202 * AllocateAndGetIpForwardTableFromStack (IPHLPAPI.@)
204 * Get the route table.
205 * Like GetIpForwardTable(), but allocate the returned table from heap.
208 * ppIpForwardTable [Out] pointer into which the MIB_IPFORWARDTABLE is
209 * allocated and returned.
210 * bOrder [In] whether to sort the table
211 * heap [In] heap from which the table is allocated
212 * flags [In] flags to HeapAlloc
215 * ERROR_INVALID_PARAMETER if ppIfTable is NULL, other error codes
216 * on failure, NO_ERROR on success.
218 DWORD WINAPI
AllocateAndGetIpForwardTableFromStack(PMIB_IPFORWARDTABLE
*
219 ppIpForwardTable
, BOOL bOrder
, HANDLE heap
, DWORD flags
)
223 TRACE("ppIpForwardTable %p, bOrder %d, heap %p, flags 0x%08x\n",
224 ppIpForwardTable
, bOrder
, heap
, flags
);
225 ret
= getRouteTable(ppIpForwardTable
, heap
, flags
);
227 qsort((*ppIpForwardTable
)->table
, (*ppIpForwardTable
)->dwNumEntries
,
228 sizeof(MIB_IPFORWARDROW
), IpForwardTableSorter
);
229 TRACE("returning %d\n", ret
);
234 static int IpNetTableSorter(const void *a
, const void *b
)
239 ret
= ((const MIB_IPNETROW
*)a
)->dwAddr
- ((const MIB_IPNETROW
*)b
)->dwAddr
;
246 /******************************************************************
247 * AllocateAndGetIpNetTableFromStack (IPHLPAPI.@)
249 * Get the IP-to-physical address mapping table.
250 * Like GetIpNetTable(), but allocate the returned table from heap.
253 * ppIpNetTable [Out] pointer into which the MIB_IPNETTABLE is
254 * allocated and returned.
255 * bOrder [In] whether to sort the table
256 * heap [In] heap from which the table is allocated
257 * flags [In] flags to HeapAlloc
260 * ERROR_INVALID_PARAMETER if ppIpNetTable is NULL, other error codes
261 * on failure, NO_ERROR on success.
263 DWORD WINAPI
AllocateAndGetIpNetTableFromStack(PMIB_IPNETTABLE
*ppIpNetTable
,
264 BOOL bOrder
, HANDLE heap
, DWORD flags
)
268 TRACE("ppIpNetTable %p, bOrder %d, heap %p, flags 0x%08x\n",
269 ppIpNetTable
, bOrder
, heap
, flags
);
270 ret
= getArpTable(ppIpNetTable
, heap
, flags
);
272 qsort((*ppIpNetTable
)->table
, (*ppIpNetTable
)->dwNumEntries
,
273 sizeof(MIB_IPADDRROW
), IpNetTableSorter
);
274 TRACE("returning %d\n", ret
);
279 static int TcpTableSorter(const void *a
, const void *b
)
284 const MIB_TCPROW
* rowA
= a
;
285 const MIB_TCPROW
* rowB
= b
;
287 ret
= rowA
->dwLocalAddr
- rowB
->dwLocalAddr
;
289 ret
= rowA
->dwLocalPort
- rowB
->dwLocalPort
;
291 ret
= rowA
->dwRemoteAddr
- rowB
->dwRemoteAddr
;
293 ret
= rowA
->dwRemotePort
- rowB
->dwRemotePort
;
303 /******************************************************************
304 * AllocateAndGetTcpTableFromStack (IPHLPAPI.@)
306 * Get the TCP connection table.
307 * Like GetTcpTable(), but allocate the returned table from heap.
310 * ppTcpTable [Out] pointer into which the MIB_TCPTABLE is
311 * allocated and returned.
312 * bOrder [In] whether to sort the table
313 * heap [In] heap from which the table is allocated
314 * flags [In] flags to HeapAlloc
317 * ERROR_INVALID_PARAMETER if ppTcpTable is NULL, whatever GetTcpTable()
320 DWORD WINAPI
AllocateAndGetTcpTableFromStack(PMIB_TCPTABLE
*ppTcpTable
,
321 BOOL bOrder
, HANDLE heap
, DWORD flags
)
325 TRACE("ppTcpTable %p, bOrder %d, heap %p, flags 0x%08x\n",
326 ppTcpTable
, bOrder
, heap
, flags
);
327 ret
= getTcpTable(ppTcpTable
, heap
, flags
);
329 qsort((*ppTcpTable
)->table
, (*ppTcpTable
)->dwNumEntries
,
330 sizeof(MIB_TCPROW
), TcpTableSorter
);
331 TRACE("returning %d\n", ret
);
336 static int UdpTableSorter(const void *a
, const void *b
)
341 const MIB_UDPROW
* rowA
= (const MIB_UDPROW
*)a
;
342 const MIB_UDPROW
* rowB
= (const MIB_UDPROW
*)b
;
344 ret
= rowA
->dwLocalAddr
- rowB
->dwLocalAddr
;
346 ret
= rowA
->dwLocalPort
- rowB
->dwLocalPort
;
354 /******************************************************************
355 * AllocateAndGetUdpTableFromStack (IPHLPAPI.@)
357 * Get the UDP listener table.
358 * Like GetUdpTable(), but allocate the returned table from heap.
361 * ppUdpTable [Out] pointer into which the MIB_UDPTABLE is
362 * allocated and returned.
363 * bOrder [In] whether to sort the table
364 * heap [In] heap from which the table is allocated
365 * flags [In] flags to HeapAlloc
368 * ERROR_INVALID_PARAMETER if ppUdpTable is NULL, whatever GetUdpTable()
371 DWORD WINAPI
AllocateAndGetUdpTableFromStack(PMIB_UDPTABLE
*ppUdpTable
,
372 BOOL bOrder
, HANDLE heap
, DWORD flags
)
376 TRACE("ppUdpTable %p, bOrder %d, heap %p, flags 0x%08x\n",
377 ppUdpTable
, bOrder
, heap
, flags
);
378 ret
= getUdpTable(ppUdpTable
, heap
, flags
);
380 qsort((*ppUdpTable
)->table
, (*ppUdpTable
)->dwNumEntries
,
381 sizeof(MIB_UDPROW
), UdpTableSorter
);
382 TRACE("returning %d\n", ret
);
387 /******************************************************************
388 * CreateIpForwardEntry (IPHLPAPI.@)
390 * Create a route in the local computer's IP table.
393 * pRoute [In] new route information
397 * Failure: error code from winerror.h
400 * Stub, always returns NO_ERROR.
402 DWORD WINAPI
CreateIpForwardEntry(PMIB_IPFORWARDROW pRoute
)
404 FIXME("(pRoute %p): stub\n", pRoute
);
405 /* could use SIOCADDRT, not sure I want to */
410 /******************************************************************
411 * CreateIpNetEntry (IPHLPAPI.@)
413 * Create entry in the ARP table.
416 * pArpEntry [In] new ARP entry
420 * Failure: error code from winerror.h
423 * Stub, always returns NO_ERROR.
425 DWORD WINAPI
CreateIpNetEntry(PMIB_IPNETROW pArpEntry
)
427 FIXME("(pArpEntry %p)\n", pArpEntry
);
428 /* could use SIOCSARP on systems that support it, not sure I want to */
433 /******************************************************************
434 * CreateProxyArpEntry (IPHLPAPI.@)
436 * Create a Proxy ARP (PARP) entry for an IP address.
439 * dwAddress [In] IP address for which this computer acts as a proxy.
440 * dwMask [In] subnet mask for dwAddress
441 * dwIfIndex [In] interface index
445 * Failure: error code from winerror.h
448 * Stub, returns ERROR_NOT_SUPPORTED.
450 DWORD WINAPI
CreateProxyArpEntry(DWORD dwAddress
, DWORD dwMask
, DWORD dwIfIndex
)
452 FIXME("(dwAddress 0x%08x, dwMask 0x%08x, dwIfIndex 0x%08x): stub\n",
453 dwAddress
, dwMask
, dwIfIndex
);
454 return ERROR_NOT_SUPPORTED
;
458 /******************************************************************
459 * DeleteIPAddress (IPHLPAPI.@)
461 * Delete an IP address added with AddIPAddress().
464 * NTEContext [In] NTE context from AddIPAddress();
468 * Failure: error code from winerror.h
471 * Stub, returns ERROR_NOT_SUPPORTED.
473 DWORD WINAPI
DeleteIPAddress(ULONG NTEContext
)
475 FIXME("(NTEContext %d): stub\n", NTEContext
);
476 return ERROR_NOT_SUPPORTED
;
480 /******************************************************************
481 * DeleteIpForwardEntry (IPHLPAPI.@)
486 * pRoute [In] route to delete
490 * Failure: error code from winerror.h
493 * Stub, returns NO_ERROR.
495 DWORD WINAPI
DeleteIpForwardEntry(PMIB_IPFORWARDROW pRoute
)
497 FIXME("(pRoute %p): stub\n", pRoute
);
498 /* could use SIOCDELRT, not sure I want to */
503 /******************************************************************
504 * DeleteIpNetEntry (IPHLPAPI.@)
506 * Delete an ARP entry.
509 * pArpEntry [In] ARP entry to delete
513 * Failure: error code from winerror.h
516 * Stub, returns NO_ERROR.
518 DWORD WINAPI
DeleteIpNetEntry(PMIB_IPNETROW pArpEntry
)
520 FIXME("(pArpEntry %p): stub\n", pArpEntry
);
521 /* could use SIOCDARP on systems that support it, not sure I want to */
526 /******************************************************************
527 * DeleteProxyArpEntry (IPHLPAPI.@)
529 * Delete a Proxy ARP entry.
532 * dwAddress [In] IP address for which this computer acts as a proxy.
533 * dwMask [In] subnet mask for dwAddress
534 * dwIfIndex [In] interface index
538 * Failure: error code from winerror.h
541 * Stub, returns ERROR_NOT_SUPPORTED.
543 DWORD WINAPI
DeleteProxyArpEntry(DWORD dwAddress
, DWORD dwMask
, DWORD dwIfIndex
)
545 FIXME("(dwAddress 0x%08x, dwMask 0x%08x, dwIfIndex 0x%08x): stub\n",
546 dwAddress
, dwMask
, dwIfIndex
);
547 return ERROR_NOT_SUPPORTED
;
551 /******************************************************************
552 * EnableRouter (IPHLPAPI.@)
554 * Turn on ip forwarding.
558 * pOverlapped [In/Out] hEvent member should contain a valid handle.
561 * Success: ERROR_IO_PENDING
562 * Failure: error code from winerror.h
565 * Stub, returns ERROR_NOT_SUPPORTED.
567 DWORD WINAPI
EnableRouter(HANDLE
* pHandle
, OVERLAPPED
* pOverlapped
)
569 FIXME("(pHandle %p, pOverlapped %p): stub\n", pHandle
, pOverlapped
);
570 /* could echo "1" > /proc/net/sys/net/ipv4/ip_forward, not sure I want to
571 could map EACCESS to ERROR_ACCESS_DENIED, I suppose
573 return ERROR_NOT_SUPPORTED
;
577 /******************************************************************
578 * FlushIpNetTable (IPHLPAPI.@)
580 * Delete all ARP entries of an interface
583 * dwIfIndex [In] interface index
587 * Failure: error code from winerror.h
590 * Stub, returns ERROR_NOT_SUPPORTED.
592 DWORD WINAPI
FlushIpNetTable(DWORD dwIfIndex
)
594 FIXME("(dwIfIndex 0x%08x): stub\n", dwIfIndex
);
595 /* this flushes the arp cache of the given index */
596 return ERROR_NOT_SUPPORTED
;
600 /******************************************************************
601 * GetAdapterIndex (IPHLPAPI.@)
603 * Get interface index from its name.
606 * AdapterName [In] unicode string with the adapter name
607 * IfIndex [Out] returns found interface index
611 * Failure: error code from winerror.h
614 * Stub, returns ERROR_NOT_SUPPORTED.
616 DWORD WINAPI
GetAdapterIndex(LPWSTR AdapterName
, PULONG IfIndex
)
618 FIXME("(AdapterName %p, IfIndex %p): stub\n", AdapterName
, IfIndex
);
619 /* FIXME: implement using getInterfaceIndexByName */
620 return ERROR_NOT_SUPPORTED
;
624 /******************************************************************
625 * GetAdaptersInfo (IPHLPAPI.@)
627 * Get information about adapters.
630 * pAdapterInfo [Out] buffer for adapter infos
631 * pOutBufLen [In] length of output buffer
635 * Failure: error code from winerror.h
637 DWORD WINAPI
GetAdaptersInfo(PIP_ADAPTER_INFO pAdapterInfo
, PULONG pOutBufLen
)
641 TRACE("pAdapterInfo %p, pOutBufLen %p\n", pAdapterInfo
, pOutBufLen
);
643 ret
= ERROR_INVALID_PARAMETER
;
645 DWORD numNonLoopbackInterfaces
= getNumNonLoopbackInterfaces();
647 if (numNonLoopbackInterfaces
> 0) {
648 DWORD numIPAddresses
= getNumIPAddresses();
651 /* This may slightly overestimate the amount of space needed, because
652 * the IP addresses include the loopback address, but it's easier
653 * to make sure there's more than enough space than to make sure there's
654 * precisely enough space.
656 size
= sizeof(IP_ADAPTER_INFO
) * numNonLoopbackInterfaces
;
657 size
+= numIPAddresses
* sizeof(IP_ADDR_STRING
);
658 if (!pAdapterInfo
|| *pOutBufLen
< size
) {
660 ret
= ERROR_BUFFER_OVERFLOW
;
663 InterfaceIndexTable
*table
= NULL
;
664 PMIB_IPADDRTABLE ipAddrTable
= NULL
;
666 ret
= getIPAddrTable(&ipAddrTable
, GetProcessHeap(), 0);
668 table
= getNonLoopbackInterfaceIndexTable();
670 size
= sizeof(IP_ADAPTER_INFO
) * table
->numIndexes
;
671 size
+= ipAddrTable
->dwNumEntries
* sizeof(IP_ADDR_STRING
);
672 if (*pOutBufLen
< size
) {
674 ret
= ERROR_INSUFFICIENT_BUFFER
;
679 BOOL winsEnabled
= FALSE
;
680 IP_ADDRESS_STRING primaryWINS
, secondaryWINS
;
681 PIP_ADDR_STRING nextIPAddr
= (PIP_ADDR_STRING
)((LPBYTE
)pAdapterInfo
682 + numNonLoopbackInterfaces
* sizeof(IP_ADAPTER_INFO
));
684 memset(pAdapterInfo
, 0, size
);
685 /* @@ Wine registry key: HKCU\Software\Wine\Network */
686 if (RegOpenKeyA(HKEY_CURRENT_USER
, "Software\\Wine\\Network",
687 &hKey
) == ERROR_SUCCESS
) {
688 DWORD size
= sizeof(primaryWINS
.String
);
691 RegQueryValueExA(hKey
, "WinsServer", NULL
, NULL
,
692 (LPBYTE
)primaryWINS
.String
, &size
);
693 addr
= inet_addr(primaryWINS
.String
);
694 if (addr
!= INADDR_NONE
&& addr
!= INADDR_ANY
)
696 size
= sizeof(secondaryWINS
.String
);
697 RegQueryValueExA(hKey
, "BackupWinsServer", NULL
, NULL
,
698 (LPBYTE
)secondaryWINS
.String
, &size
);
699 addr
= inet_addr(secondaryWINS
.String
);
700 if (addr
!= INADDR_NONE
&& addr
!= INADDR_ANY
)
704 for (ndx
= 0; ndx
< table
->numIndexes
; ndx
++) {
705 PIP_ADAPTER_INFO ptr
= &pAdapterInfo
[ndx
];
706 DWORD addrLen
= sizeof(ptr
->Address
), type
, i
;
707 PIP_ADDR_STRING currentIPAddr
= &ptr
->IpAddressList
;
708 BOOL firstIPAddr
= TRUE
;
710 /* on Win98 this is left empty, but whatever */
711 getInterfaceNameByIndex(table
->indexes
[ndx
], ptr
->AdapterName
);
712 getInterfacePhysicalByIndex(table
->indexes
[ndx
], &addrLen
,
713 ptr
->Address
, &type
);
714 /* MS defines address length and type as UINT in some places and
715 DWORD in others, **sigh**. Don't want to assume that PUINT and
716 PDWORD are equiv (64-bit?) */
717 ptr
->AddressLength
= addrLen
;
719 ptr
->Index
= table
->indexes
[ndx
];
720 for (i
= 0; i
< ipAddrTable
->dwNumEntries
; i
++) {
721 if (ipAddrTable
->table
[i
].dwIndex
== ptr
->Index
) {
723 toIPAddressString(ipAddrTable
->table
[i
].dwAddr
,
724 ptr
->IpAddressList
.IpAddress
.String
);
725 toIPAddressString(ipAddrTable
->table
[i
].dwMask
,
726 ptr
->IpAddressList
.IpMask
.String
);
730 currentIPAddr
->Next
= nextIPAddr
;
731 currentIPAddr
= nextIPAddr
;
732 toIPAddressString(ipAddrTable
->table
[i
].dwAddr
,
733 currentIPAddr
->IpAddress
.String
);
734 toIPAddressString(ipAddrTable
->table
[i
].dwMask
,
735 currentIPAddr
->IpMask
.String
);
741 ptr
->HaveWins
= TRUE
;
742 memcpy(ptr
->PrimaryWinsServer
.IpAddress
.String
,
743 primaryWINS
.String
, sizeof(primaryWINS
.String
));
744 memcpy(ptr
->SecondaryWinsServer
.IpAddress
.String
,
745 secondaryWINS
.String
, sizeof(secondaryWINS
.String
));
747 if (ndx
< table
->numIndexes
- 1)
748 ptr
->Next
= &pAdapterInfo
[ndx
+ 1];
754 HeapFree(GetProcessHeap(), 0, table
);
757 ret
= ERROR_OUTOFMEMORY
;
758 HeapFree(GetProcessHeap(), 0, ipAddrTable
);
764 TRACE("returning %d\n", ret
);
769 /******************************************************************
770 * GetBestInterface (IPHLPAPI.@)
772 * Get the interface, with the best route for the given IP address.
775 * dwDestAddr [In] IP address to search the interface for
776 * pdwBestIfIndex [Out] found best interface
780 * Failure: error code from winerror.h
782 DWORD WINAPI
GetBestInterface(IPAddr dwDestAddr
, PDWORD pdwBestIfIndex
)
786 TRACE("dwDestAddr 0x%08lx, pdwBestIfIndex %p\n", dwDestAddr
, pdwBestIfIndex
);
788 ret
= ERROR_INVALID_PARAMETER
;
790 MIB_IPFORWARDROW ipRow
;
792 ret
= GetBestRoute(dwDestAddr
, 0, &ipRow
);
793 if (ret
== ERROR_SUCCESS
)
794 *pdwBestIfIndex
= ipRow
.dwForwardIfIndex
;
796 TRACE("returning %d\n", ret
);
801 /******************************************************************
802 * GetBestRoute (IPHLPAPI.@)
804 * Get the best route for the given IP address.
807 * dwDestAddr [In] IP address to search the best route for
808 * dwSourceAddr [In] optional source IP address
809 * pBestRoute [Out] found best route
813 * Failure: error code from winerror.h
815 DWORD WINAPI
GetBestRoute(DWORD dwDestAddr
, DWORD dwSourceAddr
, PMIB_IPFORWARDROW pBestRoute
)
817 PMIB_IPFORWARDTABLE table
;
820 TRACE("dwDestAddr 0x%08x, dwSourceAddr 0x%08x, pBestRoute %p\n", dwDestAddr
,
821 dwSourceAddr
, pBestRoute
);
823 return ERROR_INVALID_PARAMETER
;
825 AllocateAndGetIpForwardTableFromStack(&table
, FALSE
, GetProcessHeap(), 0);
827 DWORD ndx
, matchedBits
, matchedNdx
= 0;
829 for (ndx
= 0, matchedBits
= 0; ndx
< table
->dwNumEntries
; ndx
++) {
830 if (table
->table
[ndx
].dwForwardType
!= MIB_IPROUTE_TYPE_INVALID
&&
831 (dwDestAddr
& table
->table
[ndx
].dwForwardMask
) ==
832 (table
->table
[ndx
].dwForwardDest
& table
->table
[ndx
].dwForwardMask
)) {
833 DWORD numShifts
, mask
;
835 for (numShifts
= 0, mask
= table
->table
[ndx
].dwForwardMask
;
836 mask
&& !(mask
& 1); mask
>>= 1, numShifts
++)
838 if (numShifts
> matchedBits
) {
839 matchedBits
= numShifts
;
844 if (matchedNdx
< table
->dwNumEntries
) {
845 memcpy(pBestRoute
, &table
->table
[matchedNdx
], sizeof(MIB_IPFORWARDROW
));
849 /* No route matches, which can happen if there's no default route. */
850 ret
= ERROR_HOST_UNREACHABLE
;
852 HeapFree(GetProcessHeap(), 0, table
);
855 ret
= ERROR_OUTOFMEMORY
;
856 TRACE("returning %d\n", ret
);
861 /******************************************************************
862 * GetFriendlyIfIndex (IPHLPAPI.@)
864 * Get a "friendly" version of IfIndex, which is one that doesn't
865 * have the top byte set. Doesn't validate whether IfIndex is a valid
869 * IfIndex [In] interface index to get the friendly one for
872 * A friendly version of IfIndex.
874 DWORD WINAPI
GetFriendlyIfIndex(DWORD IfIndex
)
876 /* windows doesn't validate these, either, just makes sure the top byte is
877 cleared. I assume my ifenum module never gives an index with the top
879 TRACE("returning %d\n", IfIndex
);
884 /******************************************************************
885 * GetIcmpStatistics (IPHLPAPI.@)
887 * Get the ICMP statistics for the local computer.
890 * pStats [Out] buffer for ICMP statistics
894 * Failure: error code from winerror.h
896 DWORD WINAPI
GetIcmpStatistics(PMIB_ICMP pStats
)
900 TRACE("pStats %p\n", pStats
);
901 ret
= getICMPStats(pStats
);
902 TRACE("returning %d\n", ret
);
907 /******************************************************************
908 * GetIfEntry (IPHLPAPI.@)
910 * Get information about an interface.
913 * pIfRow [In/Out] In: dwIndex of MIB_IFROW selects the interface.
914 * Out: interface information
918 * Failure: error code from winerror.h
920 DWORD WINAPI
GetIfEntry(PMIB_IFROW pIfRow
)
923 char nameBuf
[MAX_ADAPTER_NAME
];
926 TRACE("pIfRow %p\n", pIfRow
);
928 return ERROR_INVALID_PARAMETER
;
930 name
= getInterfaceNameByIndex(pIfRow
->dwIndex
, nameBuf
);
932 ret
= getInterfaceEntryByName(name
, pIfRow
);
934 ret
= getInterfaceStatsByName(name
, pIfRow
);
937 ret
= ERROR_INVALID_DATA
;
938 TRACE("returning %d\n", ret
);
943 static int IfTableSorter(const void *a
, const void *b
)
948 ret
= ((const MIB_IFROW
*)a
)->dwIndex
- ((const MIB_IFROW
*)b
)->dwIndex
;
955 /******************************************************************
956 * GetIfTable (IPHLPAPI.@)
958 * Get a table of local interfaces.
961 * pIfTable [Out] buffer for local interfaces table
962 * pdwSize [In/Out] length of output buffer
963 * bOrder [In] whether to sort the table
967 * Failure: error code from winerror.h
970 * If pdwSize is less than required, the function will return
971 * ERROR_INSUFFICIENT_BUFFER, and *pdwSize will be set to the required byte
973 * If bOrder is true, the returned table will be sorted by interface index.
975 DWORD WINAPI
GetIfTable(PMIB_IFTABLE pIfTable
, PULONG pdwSize
, BOOL bOrder
)
979 TRACE("pIfTable %p, pdwSize %p, bOrder %d\n", pdwSize
, pdwSize
,
982 ret
= ERROR_INVALID_PARAMETER
;
984 DWORD numInterfaces
= getNumInterfaces();
985 ULONG size
= sizeof(MIB_IFTABLE
) + (numInterfaces
- 1) * sizeof(MIB_IFROW
);
987 if (!pIfTable
|| *pdwSize
< size
) {
989 ret
= ERROR_INSUFFICIENT_BUFFER
;
992 InterfaceIndexTable
*table
= getInterfaceIndexTable();
995 size
= sizeof(MIB_IFTABLE
) + (table
->numIndexes
- 1) *
997 if (*pdwSize
< size
) {
999 ret
= ERROR_INSUFFICIENT_BUFFER
;
1005 pIfTable
->dwNumEntries
= 0;
1006 for (ndx
= 0; ndx
< table
->numIndexes
; ndx
++) {
1007 pIfTable
->table
[ndx
].dwIndex
= table
->indexes
[ndx
];
1008 GetIfEntry(&pIfTable
->table
[ndx
]);
1009 pIfTable
->dwNumEntries
++;
1012 qsort(pIfTable
->table
, pIfTable
->dwNumEntries
, sizeof(MIB_IFROW
),
1016 HeapFree(GetProcessHeap(), 0, table
);
1019 ret
= ERROR_OUTOFMEMORY
;
1022 TRACE("returning %d\n", ret
);
1027 /******************************************************************
1028 * GetInterfaceInfo (IPHLPAPI.@)
1030 * Get a list of network interface adapters.
1033 * pIfTable [Out] buffer for interface adapters
1034 * dwOutBufLen [Out] if buffer is too small, returns required size
1038 * Failure: error code from winerror.h
1041 * MSDN states this should return non-loopback interfaces only.
1043 DWORD WINAPI
GetInterfaceInfo(PIP_INTERFACE_INFO pIfTable
, PULONG dwOutBufLen
)
1047 TRACE("pIfTable %p, dwOutBufLen %p\n", pIfTable
, dwOutBufLen
);
1049 ret
= ERROR_INVALID_PARAMETER
;
1051 DWORD numInterfaces
= getNumInterfaces();
1052 ULONG size
= sizeof(IP_INTERFACE_INFO
) + (numInterfaces
- 1) *
1053 sizeof(IP_ADAPTER_INDEX_MAP
);
1055 if (!pIfTable
|| *dwOutBufLen
< size
) {
1056 *dwOutBufLen
= size
;
1057 ret
= ERROR_INSUFFICIENT_BUFFER
;
1060 InterfaceIndexTable
*table
= getInterfaceIndexTable();
1063 size
= sizeof(IP_INTERFACE_INFO
) + (table
->numIndexes
- 1) *
1064 sizeof(IP_ADAPTER_INDEX_MAP
);
1065 if (*dwOutBufLen
< size
) {
1066 *dwOutBufLen
= size
;
1067 ret
= ERROR_INSUFFICIENT_BUFFER
;
1071 char nameBuf
[MAX_ADAPTER_NAME
];
1073 *dwOutBufLen
= size
;
1074 pIfTable
->NumAdapters
= 0;
1075 for (ndx
= 0; ndx
< table
->numIndexes
; ndx
++) {
1076 const char *walker
, *name
;
1079 pIfTable
->Adapter
[ndx
].Index
= table
->indexes
[ndx
];
1080 name
= getInterfaceNameByIndex(table
->indexes
[ndx
], nameBuf
);
1081 for (walker
= name
, assigner
= pIfTable
->Adapter
[ndx
].Name
;
1082 walker
&& *walker
&&
1083 assigner
- pIfTable
->Adapter
[ndx
].Name
< MAX_ADAPTER_NAME
- 1;
1084 walker
++, assigner
++)
1085 *assigner
= *walker
;
1087 pIfTable
->NumAdapters
++;
1091 HeapFree(GetProcessHeap(), 0, table
);
1094 ret
= ERROR_OUTOFMEMORY
;
1097 TRACE("returning %d\n", ret
);
1102 /******************************************************************
1103 * GetIpAddrTable (IPHLPAPI.@)
1105 * Get interface-to-IP address mapping table.
1108 * pIpAddrTable [Out] buffer for mapping table
1109 * pdwSize [In/Out] length of output buffer
1110 * bOrder [In] whether to sort the table
1114 * Failure: error code from winerror.h
1117 * If pdwSize is less than required, the function will return
1118 * ERROR_INSUFFICIENT_BUFFER, and *pdwSize will be set to the required byte
1120 * If bOrder is true, the returned table will be sorted by the next hop and
1121 * an assortment of arbitrary parameters.
1123 DWORD WINAPI
GetIpAddrTable(PMIB_IPADDRTABLE pIpAddrTable
, PULONG pdwSize
, BOOL bOrder
)
1127 TRACE("pIpAddrTable %p, pdwSize %p, bOrder %d\n", pIpAddrTable
, pdwSize
,
1130 ret
= ERROR_INVALID_PARAMETER
;
1132 PMIB_IPADDRTABLE table
;
1134 ret
= getIPAddrTable(&table
, GetProcessHeap(), 0);
1135 if (ret
== NO_ERROR
)
1137 ULONG size
= sizeof(MIB_IPADDRTABLE
) + (table
->dwNumEntries
- 1) *
1138 sizeof(MIB_IPADDRROW
);
1140 if (!pIpAddrTable
|| *pdwSize
< size
) {
1142 ret
= ERROR_INSUFFICIENT_BUFFER
;
1146 memcpy(pIpAddrTable
, table
, sizeof(MIB_IPADDRTABLE
) +
1147 (table
->dwNumEntries
- 1) * sizeof(MIB_IPADDRROW
));
1149 qsort(pIpAddrTable
->table
, pIpAddrTable
->dwNumEntries
,
1150 sizeof(MIB_IPADDRROW
), IpAddrTableSorter
);
1153 HeapFree(GetProcessHeap(), 0, table
);
1156 TRACE("returning %d\n", ret
);
1161 /******************************************************************
1162 * GetIpForwardTable (IPHLPAPI.@)
1164 * Get the route table.
1167 * pIpForwardTable [Out] buffer for route table
1168 * pdwSize [In/Out] length of output buffer
1169 * bOrder [In] whether to sort the table
1173 * Failure: error code from winerror.h
1176 * If pdwSize is less than required, the function will return
1177 * ERROR_INSUFFICIENT_BUFFER, and *pdwSize will be set to the required byte
1179 * If bOrder is true, the returned table will be sorted by the next hop and
1180 * an assortment of arbitrary parameters.
1182 DWORD WINAPI
GetIpForwardTable(PMIB_IPFORWARDTABLE pIpForwardTable
, PULONG pdwSize
, BOOL bOrder
)
1186 TRACE("pIpForwardTable %p, pdwSize %p, bOrder %d\n", pIpForwardTable
,
1187 pdwSize
, (DWORD
)bOrder
);
1189 ret
= ERROR_INVALID_PARAMETER
;
1191 DWORD numRoutes
= getNumRoutes();
1192 ULONG sizeNeeded
= sizeof(MIB_IPFORWARDTABLE
) + (numRoutes
- 1) *
1193 sizeof(MIB_IPFORWARDROW
);
1195 if (!pIpForwardTable
|| *pdwSize
< sizeNeeded
) {
1196 *pdwSize
= sizeNeeded
;
1197 ret
= ERROR_INSUFFICIENT_BUFFER
;
1200 PMIB_IPFORWARDTABLE table
;
1202 ret
= getRouteTable(&table
, GetProcessHeap(), 0);
1204 sizeNeeded
= sizeof(MIB_IPFORWARDTABLE
) + (table
->dwNumEntries
- 1) *
1205 sizeof(MIB_IPFORWARDROW
);
1206 if (*pdwSize
< sizeNeeded
) {
1207 *pdwSize
= sizeNeeded
;
1208 ret
= ERROR_INSUFFICIENT_BUFFER
;
1211 *pdwSize
= sizeNeeded
;
1212 memcpy(pIpForwardTable
, table
, sizeNeeded
);
1214 qsort(pIpForwardTable
->table
, pIpForwardTable
->dwNumEntries
,
1215 sizeof(MIB_IPFORWARDROW
), IpForwardTableSorter
);
1218 HeapFree(GetProcessHeap(), 0, table
);
1222 TRACE("returning %d\n", ret
);
1227 /******************************************************************
1228 * GetIpNetTable (IPHLPAPI.@)
1230 * Get the IP-to-physical address mapping table.
1233 * pIpNetTable [Out] buffer for mapping table
1234 * pdwSize [In/Out] length of output buffer
1235 * bOrder [In] whether to sort the table
1239 * Failure: error code from winerror.h
1242 * If pdwSize is less than required, the function will return
1243 * ERROR_INSUFFICIENT_BUFFER, and *pdwSize will be set to the required byte
1245 * If bOrder is true, the returned table will be sorted by IP address.
1247 DWORD WINAPI
GetIpNetTable(PMIB_IPNETTABLE pIpNetTable
, PULONG pdwSize
, BOOL bOrder
)
1251 TRACE("pIpNetTable %p, pdwSize %p, bOrder %d\n", pIpNetTable
, pdwSize
,
1254 ret
= ERROR_INVALID_PARAMETER
;
1256 DWORD numEntries
= getNumArpEntries();
1257 ULONG size
= sizeof(MIB_IPNETTABLE
) + (numEntries
- 1) *
1258 sizeof(MIB_IPNETROW
);
1260 if (!pIpNetTable
|| *pdwSize
< size
) {
1262 ret
= ERROR_INSUFFICIENT_BUFFER
;
1265 PMIB_IPNETTABLE table
;
1267 ret
= getArpTable(&table
, GetProcessHeap(), 0);
1269 size
= sizeof(MIB_IPNETTABLE
) + (table
->dwNumEntries
- 1) *
1270 sizeof(MIB_IPNETROW
);
1271 if (*pdwSize
< size
) {
1273 ret
= ERROR_INSUFFICIENT_BUFFER
;
1277 memcpy(pIpNetTable
, table
, size
);
1279 qsort(pIpNetTable
->table
, pIpNetTable
->dwNumEntries
,
1280 sizeof(MIB_IPNETROW
), IpNetTableSorter
);
1283 HeapFree(GetProcessHeap(), 0, table
);
1287 TRACE("returning %d\n", ret
);
1292 /******************************************************************
1293 * GetIpStatistics (IPHLPAPI.@)
1295 * Get the IP statistics for the local computer.
1298 * pStats [Out] buffer for IP statistics
1302 * Failure: error code from winerror.h
1304 DWORD WINAPI
GetIpStatistics(PMIB_IPSTATS pStats
)
1308 TRACE("pStats %p\n", pStats
);
1309 ret
= getIPStats(pStats
);
1310 TRACE("returning %d\n", ret
);
1315 /******************************************************************
1316 * GetNetworkParams (IPHLPAPI.@)
1318 * Get the network parameters for the local computer.
1321 * pFixedInfo [Out] buffer for network parameters
1322 * pOutBufLen [In/Out] length of output buffer
1326 * Failure: error code from winerror.h
1329 * If pOutBufLen is less than required, the function will return
1330 * ERROR_INSUFFICIENT_BUFFER, and pOutBufLen will be set to the required byte
1333 DWORD WINAPI
GetNetworkParams(PFIXED_INFO pFixedInfo
, PULONG pOutBufLen
)
1339 TRACE("pFixedInfo %p, pOutBufLen %p\n", pFixedInfo
, pOutBufLen
);
1341 return ERROR_INVALID_PARAMETER
;
1344 size
= sizeof(FIXED_INFO
) + (_res
.nscount
> 0 ? (_res
.nscount
- 1) *
1345 sizeof(IP_ADDR_STRING
) : 0);
1346 if (!pFixedInfo
|| *pOutBufLen
< size
) {
1348 return ERROR_BUFFER_OVERFLOW
;
1351 memset(pFixedInfo
, 0, size
);
1352 size
= sizeof(pFixedInfo
->HostName
);
1353 GetComputerNameExA(ComputerNameDnsHostname
, pFixedInfo
->HostName
, &size
);
1354 size
= sizeof(pFixedInfo
->DomainName
);
1355 GetComputerNameExA(ComputerNameDnsDomain
, pFixedInfo
->DomainName
, &size
);
1356 if (_res
.nscount
> 0) {
1357 PIP_ADDR_STRING ptr
;
1360 for (i
= 0, ptr
= &pFixedInfo
->DnsServerList
; i
< _res
.nscount
&& ptr
;
1361 i
++, ptr
= ptr
->Next
) {
1362 toIPAddressString(_res
.nsaddr_list
[i
].sin_addr
.s_addr
,
1363 ptr
->IpAddress
.String
);
1364 if (i
== _res
.nscount
- 1)
1367 ptr
->Next
= (PIP_ADDR_STRING
)((LPBYTE
)pFixedInfo
+ sizeof(FIXED_INFO
));
1369 ptr
->Next
= (PIP_ADDR_STRING
)((PBYTE
)ptr
+ sizeof(IP_ADDR_STRING
));
1372 pFixedInfo
->NodeType
= HYBRID_NODETYPE
;
1373 regReturn
= RegOpenKeyExA(HKEY_LOCAL_MACHINE
,
1374 "SYSTEM\\CurrentControlSet\\Services\\VxD\\MSTCP", 0, KEY_READ
, &hKey
);
1375 if (regReturn
!= ERROR_SUCCESS
)
1376 regReturn
= RegOpenKeyExA(HKEY_LOCAL_MACHINE
,
1377 "SYSTEM\\CurrentControlSet\\Services\\NetBT\\Parameters", 0, KEY_READ
,
1379 if (regReturn
== ERROR_SUCCESS
)
1381 DWORD size
= sizeof(pFixedInfo
->ScopeId
);
1383 RegQueryValueExA(hKey
, "ScopeID", NULL
, NULL
, (LPBYTE
)pFixedInfo
->ScopeId
, &size
);
1387 /* FIXME: can check whether routing's enabled in /proc/sys/net/ipv4/ip_forward
1388 I suppose could also check for a listener on port 53 to set EnableDns */
1390 TRACE("returning %d\n", ret
);
1395 /******************************************************************
1396 * GetNumberOfInterfaces (IPHLPAPI.@)
1398 * Get the number of interfaces.
1401 * pdwNumIf [Out] number of interfaces
1404 * NO_ERROR on success, ERROR_INVALID_PARAMETER if pdwNumIf is NULL.
1406 DWORD WINAPI
GetNumberOfInterfaces(PDWORD pdwNumIf
)
1410 TRACE("pdwNumIf %p\n", pdwNumIf
);
1412 ret
= ERROR_INVALID_PARAMETER
;
1414 *pdwNumIf
= getNumInterfaces();
1417 TRACE("returning %d\n", ret
);
1422 /******************************************************************
1423 * GetPerAdapterInfo (IPHLPAPI.@)
1425 * Get information about an adapter corresponding to an interface.
1428 * IfIndex [In] interface info
1429 * pPerAdapterInfo [Out] buffer for per adapter info
1430 * pOutBufLen [In/Out] length of output buffer
1434 * Failure: error code from winerror.h
1437 * Stub, returns ERROR_NOT_SUPPORTED.
1439 DWORD WINAPI
GetPerAdapterInfo(ULONG IfIndex
, PIP_PER_ADAPTER_INFO pPerAdapterInfo
, PULONG pOutBufLen
)
1441 TRACE("(IfIndex %d, pPerAdapterInfo %p, pOutBufLen %p)\n", IfIndex
,
1442 pPerAdapterInfo
, pOutBufLen
);
1443 return ERROR_NOT_SUPPORTED
;
1447 /******************************************************************
1448 * GetRTTAndHopCount (IPHLPAPI.@)
1450 * Get round-trip time (RTT) and hop count.
1454 * DestIpAddress [In] destination address to get the info for
1455 * HopCount [Out] retrieved hop count
1456 * MaxHops [In] maximum hops to search for the destination
1457 * RTT [Out] RTT in milliseconds
1464 * Stub, returns FALSE.
1466 BOOL WINAPI
GetRTTAndHopCount(IPAddr DestIpAddress
, PULONG HopCount
, ULONG MaxHops
, PULONG RTT
)
1468 FIXME("(DestIpAddress 0x%08lx, HopCount %p, MaxHops %d, RTT %p): stub\n",
1469 DestIpAddress
, HopCount
, MaxHops
, RTT
);
1474 /******************************************************************
1475 * GetTcpStatistics (IPHLPAPI.@)
1477 * Get the TCP statistics for the local computer.
1480 * pStats [Out] buffer for TCP statistics
1484 * Failure: error code from winerror.h
1486 DWORD WINAPI
GetTcpStatistics(PMIB_TCPSTATS pStats
)
1490 TRACE("pStats %p\n", pStats
);
1491 ret
= getTCPStats(pStats
);
1492 TRACE("returning %d\n", ret
);
1497 /******************************************************************
1498 * GetTcpTable (IPHLPAPI.@)
1500 * Get the table of active TCP connections.
1503 * pTcpTable [Out] buffer for TCP connections table
1504 * pdwSize [In/Out] length of output buffer
1505 * bOrder [In] whether to order the table
1509 * Failure: error code from winerror.h
1512 * If pdwSize is less than required, the function will return
1513 * ERROR_INSUFFICIENT_BUFFER, and *pdwSize will be set to
1514 * the required byte size.
1515 * If bOrder is true, the returned table will be sorted, first by
1516 * local address and port number, then by remote address and port
1519 DWORD WINAPI
GetTcpTable(PMIB_TCPTABLE pTcpTable
, PDWORD pdwSize
, BOOL bOrder
)
1523 TRACE("pTcpTable %p, pdwSize %p, bOrder %d\n", pTcpTable
, pdwSize
,
1526 ret
= ERROR_INVALID_PARAMETER
;
1528 DWORD numEntries
= getNumTcpEntries();
1529 DWORD size
= sizeof(MIB_TCPTABLE
) + (numEntries
- 1) * sizeof(MIB_TCPROW
);
1531 if (!pTcpTable
|| *pdwSize
< size
) {
1533 ret
= ERROR_INSUFFICIENT_BUFFER
;
1536 PMIB_TCPTABLE table
;
1538 ret
= getTcpTable(&table
, GetProcessHeap(), 0);
1540 size
= sizeof(MIB_TCPTABLE
) + (table
->dwNumEntries
- 1) *
1542 if (*pdwSize
< size
) {
1544 ret
= ERROR_INSUFFICIENT_BUFFER
;
1548 memcpy(pTcpTable
, table
, size
);
1550 qsort(pTcpTable
->table
, pTcpTable
->dwNumEntries
,
1551 sizeof(MIB_TCPROW
), TcpTableSorter
);
1554 HeapFree(GetProcessHeap(), 0, table
);
1557 ret
= ERROR_OUTOFMEMORY
;
1560 TRACE("returning %d\n", ret
);
1565 /******************************************************************
1566 * GetUdpStatistics (IPHLPAPI.@)
1568 * Get the UDP statistics for the local computer.
1571 * pStats [Out] buffer for UDP statistics
1575 * Failure: error code from winerror.h
1577 DWORD WINAPI
GetUdpStatistics(PMIB_UDPSTATS pStats
)
1581 TRACE("pStats %p\n", pStats
);
1582 ret
= getUDPStats(pStats
);
1583 TRACE("returning %d\n", ret
);
1588 /******************************************************************
1589 * GetUdpTable (IPHLPAPI.@)
1591 * Get a table of active UDP connections.
1594 * pUdpTable [Out] buffer for UDP connections table
1595 * pdwSize [In/Out] length of output buffer
1596 * bOrder [In] whether to order the table
1600 * Failure: error code from winerror.h
1603 * If pdwSize is less than required, the function will return
1604 * ERROR_INSUFFICIENT_BUFFER, and *pdwSize will be set to the
1605 * required byte size.
1606 * If bOrder is true, the returned table will be sorted, first by
1607 * local address, then by local port number.
1609 DWORD WINAPI
GetUdpTable(PMIB_UDPTABLE pUdpTable
, PDWORD pdwSize
, BOOL bOrder
)
1613 TRACE("pUdpTable %p, pdwSize %p, bOrder %d\n", pUdpTable
, pdwSize
,
1616 ret
= ERROR_INVALID_PARAMETER
;
1618 DWORD numEntries
= getNumUdpEntries();
1619 DWORD size
= sizeof(MIB_UDPTABLE
) + (numEntries
- 1) * sizeof(MIB_UDPROW
);
1621 if (!pUdpTable
|| *pdwSize
< size
) {
1623 ret
= ERROR_INSUFFICIENT_BUFFER
;
1626 PMIB_UDPTABLE table
;
1628 ret
= getUdpTable(&table
, GetProcessHeap(), 0);
1630 size
= sizeof(MIB_UDPTABLE
) + (table
->dwNumEntries
- 1) *
1632 if (*pdwSize
< size
) {
1634 ret
= ERROR_INSUFFICIENT_BUFFER
;
1638 memcpy(pUdpTable
, table
, size
);
1640 qsort(pUdpTable
->table
, pUdpTable
->dwNumEntries
,
1641 sizeof(MIB_UDPROW
), UdpTableSorter
);
1644 HeapFree(GetProcessHeap(), 0, table
);
1647 ret
= ERROR_OUTOFMEMORY
;
1650 TRACE("returning %d\n", ret
);
1655 /******************************************************************
1656 * GetUniDirectionalAdapterInfo (IPHLPAPI.@)
1658 * This is a Win98-only function to get information on "unidirectional"
1659 * adapters. Since this is pretty nonsensical in other contexts, it
1660 * never returns anything.
1663 * pIPIfInfo [Out] buffer for adapter infos
1664 * dwOutBufLen [Out] length of the output buffer
1668 * Failure: error code from winerror.h
1671 * Stub, returns ERROR_NOT_SUPPORTED.
1673 DWORD WINAPI
GetUniDirectionalAdapterInfo(PIP_UNIDIRECTIONAL_ADAPTER_ADDRESS pIPIfInfo
, PULONG dwOutBufLen
)
1675 TRACE("pIPIfInfo %p, dwOutBufLen %p\n", pIPIfInfo
, dwOutBufLen
);
1676 /* a unidirectional adapter?? not bloody likely! */
1677 return ERROR_NOT_SUPPORTED
;
1681 /******************************************************************
1682 * IpReleaseAddress (IPHLPAPI.@)
1684 * Release an IP optained through DHCP,
1687 * AdapterInfo [In] adapter to release IP address
1691 * Failure: error code from winerror.h
1694 * Since GetAdaptersInfo never returns adapters that have DHCP enabled,
1695 * this function does nothing.
1698 * Stub, returns ERROR_NOT_SUPPORTED.
1700 DWORD WINAPI
IpReleaseAddress(PIP_ADAPTER_INDEX_MAP AdapterInfo
)
1702 TRACE("AdapterInfo %p\n", AdapterInfo
);
1703 /* not a stub, never going to support this (and I never mark an adapter as
1704 DHCP enabled, see GetAdaptersInfo, so this should never get called) */
1705 return ERROR_NOT_SUPPORTED
;
1709 /******************************************************************
1710 * IpRenewAddress (IPHLPAPI.@)
1712 * Renew an IP optained through DHCP.
1715 * AdapterInfo [In] adapter to renew IP address
1719 * Failure: error code from winerror.h
1722 * Since GetAdaptersInfo never returns adapters that have DHCP enabled,
1723 * this function does nothing.
1726 * Stub, returns ERROR_NOT_SUPPORTED.
1728 DWORD WINAPI
IpRenewAddress(PIP_ADAPTER_INDEX_MAP AdapterInfo
)
1730 TRACE("AdapterInfo %p\n", AdapterInfo
);
1731 /* not a stub, never going to support this (and I never mark an adapter as
1732 DHCP enabled, see GetAdaptersInfo, so this should never get called) */
1733 return ERROR_NOT_SUPPORTED
;
1737 /******************************************************************
1738 * NotifyAddrChange (IPHLPAPI.@)
1740 * Notify caller whenever the ip-interface map is changed.
1743 * Handle [Out] handle useable in asynchronus notification
1744 * overlapped [In] overlapped structure that notifies the caller
1748 * Failure: error code from winerror.h
1751 * Stub, returns ERROR_NOT_SUPPORTED.
1753 DWORD WINAPI
NotifyAddrChange(PHANDLE Handle
, LPOVERLAPPED overlapped
)
1755 FIXME("(Handle %p, overlapped %p): stub\n", Handle
, overlapped
);
1756 return ERROR_NOT_SUPPORTED
;
1760 /******************************************************************
1761 * NotifyRouteChange (IPHLPAPI.@)
1763 * Notify caller whenever the ip routing table is changed.
1766 * Handle [Out] handle useable in asynchronus notification
1767 * overlapped [In] overlapped structure that notifies the caller
1771 * Failure: error code from winerror.h
1774 * Stub, returns ERROR_NOT_SUPPORTED.
1776 DWORD WINAPI
NotifyRouteChange(PHANDLE Handle
, LPOVERLAPPED overlapped
)
1778 FIXME("(Handle %p, overlapped %p): stub\n", Handle
, overlapped
);
1779 return ERROR_NOT_SUPPORTED
;
1783 /******************************************************************
1784 * SendARP (IPHLPAPI.@)
1786 * Send an ARP request.
1789 * DestIP [In] attempt to obtain this IP
1790 * SrcIP [In] optional sender IP address
1791 * pMacAddr [Out] buffer for the mac address
1792 * PhyAddrLen [In/Out] length of the output buffer
1796 * Failure: error code from winerror.h
1799 * Stub, returns ERROR_NOT_SUPPORTED.
1801 DWORD WINAPI
SendARP(IPAddr DestIP
, IPAddr SrcIP
, PULONG pMacAddr
, PULONG PhyAddrLen
)
1803 FIXME("(DestIP 0x%08lx, SrcIP 0x%08lx, pMacAddr %p, PhyAddrLen %p): stub\n",
1804 DestIP
, SrcIP
, pMacAddr
, PhyAddrLen
);
1805 return ERROR_NOT_SUPPORTED
;
1809 /******************************************************************
1810 * SetIfEntry (IPHLPAPI.@)
1812 * Set the administrative status of an interface.
1815 * pIfRow [In] dwAdminStatus member specifies the new status.
1819 * Failure: error code from winerror.h
1822 * Stub, returns ERROR_NOT_SUPPORTED.
1824 DWORD WINAPI
SetIfEntry(PMIB_IFROW pIfRow
)
1826 FIXME("(pIfRow %p): stub\n", pIfRow
);
1827 /* this is supposed to set an interface administratively up or down.
1828 Could do SIOCSIFFLAGS and set/clear IFF_UP, but, not sure I want to, and
1829 this sort of down is indistinguishable from other sorts of down (e.g. no
1831 return ERROR_NOT_SUPPORTED
;
1835 /******************************************************************
1836 * SetIpForwardEntry (IPHLPAPI.@)
1838 * Modify an existing route.
1841 * pRoute [In] route with the new information
1845 * Failure: error code from winerror.h
1848 * Stub, returns NO_ERROR.
1850 DWORD WINAPI
SetIpForwardEntry(PMIB_IPFORWARDROW pRoute
)
1852 FIXME("(pRoute %p): stub\n", pRoute
);
1853 /* this is to add a route entry, how's it distinguishable from
1854 CreateIpForwardEntry?
1855 could use SIOCADDRT, not sure I want to */
1860 /******************************************************************
1861 * SetIpNetEntry (IPHLPAPI.@)
1863 * Modify an existing ARP entry.
1866 * pArpEntry [In] ARP entry with the new information
1870 * Failure: error code from winerror.h
1873 * Stub, returns NO_ERROR.
1875 DWORD WINAPI
SetIpNetEntry(PMIB_IPNETROW pArpEntry
)
1877 FIXME("(pArpEntry %p): stub\n", pArpEntry
);
1878 /* same as CreateIpNetEntry here, could use SIOCSARP, not sure I want to */
1883 /******************************************************************
1884 * SetIpStatistics (IPHLPAPI.@)
1886 * Toggle IP forwarding and det the default TTL value.
1889 * pIpStats [In] IP statistics with the new information
1893 * Failure: error code from winerror.h
1896 * Stub, returns NO_ERROR.
1898 DWORD WINAPI
SetIpStatistics(PMIB_IPSTATS pIpStats
)
1900 FIXME("(pIpStats %p): stub\n", pIpStats
);
1905 /******************************************************************
1906 * SetIpTTL (IPHLPAPI.@)
1908 * Set the default TTL value.
1911 * nTTL [In] new TTL value
1915 * Failure: error code from winerror.h
1918 * Stub, returns NO_ERROR.
1920 DWORD WINAPI
SetIpTTL(UINT nTTL
)
1922 FIXME("(nTTL %d): stub\n", nTTL
);
1923 /* could echo nTTL > /proc/net/sys/net/ipv4/ip_default_ttl, not sure I
1924 want to. Could map EACCESS to ERROR_ACCESS_DENIED, I suppose */
1929 /******************************************************************
1930 * SetTcpEntry (IPHLPAPI.@)
1932 * Set the state of a TCP connection.
1935 * pTcpRow [In] specifies connection with new state
1939 * Failure: error code from winerror.h
1942 * Stub, returns NO_ERROR.
1944 DWORD WINAPI
SetTcpEntry(PMIB_TCPROW pTcpRow
)
1946 FIXME("(pTcpRow %p): stub\n", pTcpRow
);
1951 /******************************************************************
1952 * UnenableRouter (IPHLPAPI.@)
1954 * Decrement the IP-forwarding reference count. Turn off IP-forwarding
1955 * if it reaches zero.
1958 * pOverlapped [In/Out] should be the same as in EnableRouter()
1959 * lpdwEnableCount [Out] optional, receives reference count
1963 * Failure: error code from winerror.h
1966 * Stub, returns ERROR_NOT_SUPPORTED.
1968 DWORD WINAPI
UnenableRouter(OVERLAPPED
* pOverlapped
, LPDWORD lpdwEnableCount
)
1970 FIXME("(pOverlapped %p, lpdwEnableCount %p): stub\n", pOverlapped
,
1972 /* could echo "0" > /proc/net/sys/net/ipv4/ip_forward, not sure I want to
1973 could map EACCESS to ERROR_ACCESS_DENIED, I suppose
1975 return ERROR_NOT_SUPPORTED
;