?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
msvcrt: Import fmod implementation from musl.
[wine.git] / dlls / iphlpapi / iphlpapi_main.c
blob09414d26dde60d2bc12b557b9f318eea74d7db4c
1 /*
2 * iphlpapi dll implementation
3 *
4 * Copyright (C) 2003,2006 Juan Lang
5 *
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.
10 *
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.
15 *
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
19 */
20
21 #include "config.h"
22
23 #include <stdarg.h>
24 #include <stdlib.h>
25 #include <stdio.h>
26 #include <sys/types.h>
27 #ifdef HAVE_NETINET_IN_H
28 # include <netinet/in.h>
29 #endif
30 #ifdef HAVE_ARPA_INET_H
31 # include <arpa/inet.h>
32 #endif
33 #ifdef HAVE_ARPA_NAMESER_H
34 # include <arpa/nameser.h>
35 #endif
36 #ifdef HAVE_RESOLV_H
37 # include <resolv.h>
38 #endif
39
40 #define NONAMELESSUNION
41 #define NONAMELESSSTRUCT
42 #include "windef.h"
43 #include "winbase.h"
44 #include "winreg.h"
45 #define USE_WS_PREFIX
46 #include "winsock2.h"
47 #include "winternl.h"
48 #include "ws2ipdef.h"
49 #include "windns.h"
50 #include "iphlpapi.h"
51 #include "ifenum.h"
52 #include "ipstats.h"
53 #include "ipifcons.h"
54 #include "fltdefs.h"
55 #include "ifdef.h"
56 #include "netioapi.h"
57 #include "tcpestats.h"
58 #include "ip2string.h"
59
60 #include "wine/debug.h"
61 #include "wine/unicode.h"
62
63 WINE_DEFAULT_DEBUG_CHANNEL(iphlpapi);
64
65 #ifndef IF_NAMESIZE
66 #define IF_NAMESIZE 16
67 #endif
68
69 #ifndef INADDR_NONE
70 #define INADDR_NONE ~0UL
71 #endif
72
73 /******************************************************************
74 * AddIPAddress (IPHLPAPI.@)
75 *
76 * Add an IP address to an adapter.
77 *
78 * PARAMS
79 * Address [In] IP address to add to the adapter
80 * IpMask [In] subnet mask for the IP address
81 * IfIndex [In] adapter index to add the address
82 * NTEContext [Out] Net Table Entry (NTE) context for the IP address
83 * NTEInstance [Out] NTE instance for the IP address
84 *
85 * RETURNS
86 * Success: NO_ERROR
87 * Failure: error code from winerror.h
88 *
89 * FIXME
90 * Stub. Currently returns ERROR_NOT_SUPPORTED.
91 */
92 DWORD WINAPI AddIPAddress(IPAddr Address, IPMask IpMask, DWORD IfIndex, PULONG NTEContext, PULONG NTEInstance)
93 {
94 FIXME(":stub\n");
95 return ERROR_NOT_SUPPORTED;
96 }
97
98
99 /******************************************************************
100 * AllocateAndGetIfTableFromStack (IPHLPAPI.@)
101 *
102 * Get table of local interfaces.
103 * Like GetIfTable(), but allocate the returned table from heap.
104 *
105 * PARAMS
106 * ppIfTable [Out] pointer into which the MIB_IFTABLE is
107 * allocated and returned.
108 * bOrder [In] whether to sort the table
109 * heap [In] heap from which the table is allocated
110 * flags [In] flags to HeapAlloc
111 *
112 * RETURNS
113 * ERROR_INVALID_PARAMETER if ppIfTable is NULL, whatever
114 * GetIfTable() returns otherwise.
115 */
116 DWORD WINAPI AllocateAndGetIfTableFromStack(PMIB_IFTABLE *ppIfTable,
117 BOOL bOrder, HANDLE heap, DWORD flags)
118 {
119 DWORD ret;
120
121 TRACE("ppIfTable %p, bOrder %d, heap %p, flags 0x%08x\n", ppIfTable,
122 bOrder, heap, flags);
123 if (!ppIfTable)
124 ret = ERROR_INVALID_PARAMETER;
125 else {
126 DWORD dwSize = 0;
127
128 ret = GetIfTable(*ppIfTable, &dwSize, bOrder);
129 if (ret == ERROR_INSUFFICIENT_BUFFER) {
130 *ppIfTable = HeapAlloc(heap, flags, dwSize);
131 ret = GetIfTable(*ppIfTable, &dwSize, bOrder);
132 }
133 }
134 TRACE("returning %d\n", ret);
135 return ret;
136 }
137
138
139 static int IpAddrTableNumericSorter(const void *a, const void *b)
140 {
141 int ret = 0;
142
143 if (a && b)
144 ret = ((const MIB_IPADDRROW*)a)->dwAddr - ((const MIB_IPADDRROW*)b)->dwAddr;
145 return ret;
146 }
147
148 static int IpAddrTableLoopbackSorter(const void *a, const void *b)
149 {
150 const MIB_IPADDRROW *left = a, *right = b;
151 int ret = 0;
152
153 if (isIfIndexLoopback(left->dwIndex))
154 ret = 1;
155 else if (isIfIndexLoopback(right->dwIndex))
156 ret = -1;
157
158 return ret;
159 }
160
161 /******************************************************************
162 * AllocateAndGetIpAddrTableFromStack (IPHLPAPI.@)
163 *
164 * Get interface-to-IP address mapping table.
165 * Like GetIpAddrTable(), but allocate the returned table from heap.
166 *
167 * PARAMS
168 * ppIpAddrTable [Out] pointer into which the MIB_IPADDRTABLE is
169 * allocated and returned.
170 * bOrder [In] whether to sort the table
171 * heap [In] heap from which the table is allocated
172 * flags [In] flags to HeapAlloc
173 *
174 * RETURNS
175 * ERROR_INVALID_PARAMETER if ppIpAddrTable is NULL, other error codes on
176 * failure, NO_ERROR on success.
177 */
178 DWORD WINAPI AllocateAndGetIpAddrTableFromStack(PMIB_IPADDRTABLE *ppIpAddrTable,
179 BOOL bOrder, HANDLE heap, DWORD flags)
180 {
181 DWORD ret;
182
183 TRACE("ppIpAddrTable %p, bOrder %d, heap %p, flags 0x%08x\n",
184 ppIpAddrTable, bOrder, heap, flags);
185 ret = getIPAddrTable(ppIpAddrTable, heap, flags);
186 if (!ret && bOrder)
187 qsort((*ppIpAddrTable)->table, (*ppIpAddrTable)->dwNumEntries,
188 sizeof(MIB_IPADDRROW), IpAddrTableNumericSorter);
189 TRACE("returning %d\n", ret);
190 return ret;
191 }
192
193
194 /******************************************************************
195 * CancelIPChangeNotify (IPHLPAPI.@)
196 *
197 * Cancel a previous notification created by NotifyAddrChange or
198 * NotifyRouteChange.
199 *
200 * PARAMS
201 * overlapped [In] overlapped structure that notifies the caller
202 *
203 * RETURNS
204 * Success: TRUE
205 * Failure: FALSE
206 *
207 * FIXME
208 * Stub, returns FALSE.
209 */
210 BOOL WINAPI CancelIPChangeNotify(LPOVERLAPPED overlapped)
211 {
212 FIXME("(overlapped %p): stub\n", overlapped);
213 return FALSE;
214 }
215
216
217 /******************************************************************
218 * CancelMibChangeNotify2 (IPHLPAPI.@)
219 */
220 DWORD WINAPI CancelMibChangeNotify2(HANDLE handle)
221 {
222 FIXME("(handle %p): stub\n", handle);
223 return NO_ERROR;
224 }
225
226
227 /******************************************************************
228 * CreateIpForwardEntry (IPHLPAPI.@)
229 *
230 * Create a route in the local computer's IP table.
231 *
232 * PARAMS
233 * pRoute [In] new route information
234 *
235 * RETURNS
236 * Success: NO_ERROR
237 * Failure: error code from winerror.h
238 *
239 * FIXME
240 * Stub, always returns NO_ERROR.
241 */
242 DWORD WINAPI CreateIpForwardEntry(PMIB_IPFORWARDROW pRoute)
243 {
244 FIXME("(pRoute %p): stub\n", pRoute);
245 /* could use SIOCADDRT, not sure I want to */
246 return 0;
247 }
248
249
250 /******************************************************************
251 * CreateIpNetEntry (IPHLPAPI.@)
252 *
253 * Create entry in the ARP table.
254 *
255 * PARAMS
256 * pArpEntry [In] new ARP entry
257 *
258 * RETURNS
259 * Success: NO_ERROR
260 * Failure: error code from winerror.h
261 *
262 * FIXME
263 * Stub, always returns NO_ERROR.
264 */
265 DWORD WINAPI CreateIpNetEntry(PMIB_IPNETROW pArpEntry)
266 {
267 FIXME("(pArpEntry %p)\n", pArpEntry);
268 /* could use SIOCSARP on systems that support it, not sure I want to */
269 return 0;
270 }
271
272
273 /******************************************************************
274 * CreateProxyArpEntry (IPHLPAPI.@)
275 *
276 * Create a Proxy ARP (PARP) entry for an IP address.
277 *
278 * PARAMS
279 * dwAddress [In] IP address for which this computer acts as a proxy.
280 * dwMask [In] subnet mask for dwAddress
281 * dwIfIndex [In] interface index
282 *
283 * RETURNS
284 * Success: NO_ERROR
285 * Failure: error code from winerror.h
286 *
287 * FIXME
288 * Stub, returns ERROR_NOT_SUPPORTED.
289 */
290 DWORD WINAPI CreateProxyArpEntry(DWORD dwAddress, DWORD dwMask, DWORD dwIfIndex)
291 {
292 FIXME("(dwAddress 0x%08x, dwMask 0x%08x, dwIfIndex 0x%08x): stub\n",
293 dwAddress, dwMask, dwIfIndex);
294 return ERROR_NOT_SUPPORTED;
295 }
296
297 static char *debugstr_ipv6(const struct WS_sockaddr_in6 *sin, char *buf)
298 {
299 const IN6_ADDR *addr = &sin->sin6_addr;
300 char *p = buf;
301 int i;
302 BOOL in_zero = FALSE;
303
304 for (i = 0; i < 7; i++)
305 {
306 if (!addr->u.Word[i])
307 {
308 if (i == 0)
309 *p++ = ':';
310 if (!in_zero)
311 {
312 *p++ = ':';
313 in_zero = TRUE;
314 }
315 }
316 else
317 {
318 p += sprintf(p, "%x:", ntohs(addr->u.Word[i]));
319 in_zero = FALSE;
320 }
321 }
322 sprintf(p, "%x", ntohs(addr->u.Word[7]));
323 return buf;
324 }
325
326 static BOOL map_address_6to4( const SOCKADDR_IN6 *addr6, SOCKADDR_IN *addr4 )
327 {
328 ULONG i;
329
330 if (addr6->sin6_family != WS_AF_INET6) return FALSE;
331
332 for (i = 0; i < 5; i++)
333 if (addr6->sin6_addr.u.Word[i]) return FALSE;
334
335 if (addr6->sin6_addr.u.Word[5] != 0xffff) return FALSE;
336
337 addr4->sin_family = WS_AF_INET;
338 addr4->sin_port = addr6->sin6_port;
339 addr4->sin_addr.S_un.S_addr = addr6->sin6_addr.u.Word[6] << 16 | addr6->sin6_addr.u.Word[7];
340 memset( &addr4->sin_zero, 0, sizeof(addr4->sin_zero) );
341
342 return TRUE;
343 }
344
345 static BOOL find_src_address( MIB_IPADDRTABLE *table, const SOCKADDR_IN *dst, SOCKADDR_IN6 *src )
346 {
347 MIB_IPFORWARDROW row;
348 DWORD i, j;
349
350 if (GetBestRoute( dst->sin_addr.S_un.S_addr, 0, &row )) return FALSE;
351
352 for (i = 0; i < table->dwNumEntries; i++)
353 {
354 /* take the first address */
355 if (table->table[i].dwIndex == row.dwForwardIfIndex)
356 {
357 src->sin6_family = WS_AF_INET6;
358 src->sin6_port = 0;
359 src->sin6_flowinfo = 0;
360 for (j = 0; j < 5; j++) src->sin6_addr.u.Word[j] = 0;
361 src->sin6_addr.u.Word[5] = 0xffff;
362 src->sin6_addr.u.Word[6] = table->table[i].dwAddr & 0xffff;
363 src->sin6_addr.u.Word[7] = table->table[i].dwAddr >> 16;
364 return TRUE;
365 }
366 }
367
368 return FALSE;
369 }
370
371 /******************************************************************
372 * CreateSortedAddressPairs (IPHLPAPI.@)
373 */
374 DWORD WINAPI CreateSortedAddressPairs( const PSOCKADDR_IN6 src_list, DWORD src_count,
375 const PSOCKADDR_IN6 dst_list, DWORD dst_count,
376 DWORD options, PSOCKADDR_IN6_PAIR *pair_list,
377 DWORD *pair_count )
378 {
379 DWORD i, size, ret;
380 SOCKADDR_IN6_PAIR *pairs;
381 SOCKADDR_IN6 *ptr;
382 SOCKADDR_IN addr4;
383 MIB_IPADDRTABLE *table;
384
385 FIXME( "(src_list %p src_count %u dst_list %p dst_count %u options %x pair_list %p pair_count %p): stub\n",
386 src_list, src_count, dst_list, dst_count, options, pair_list, pair_count );
387
388 if (src_list || src_count || !dst_list || !pair_list || !pair_count || dst_count > 500)
389 return ERROR_INVALID_PARAMETER;
390
391 for (i = 0; i < dst_count; i++)
392 {
393 if (!map_address_6to4( &dst_list[i], &addr4 ))
394 {
395 FIXME("only mapped IPv4 addresses are supported\n");
396 return ERROR_NOT_SUPPORTED;
397 }
398 }
399
400 size = dst_count * sizeof(*pairs);
401 size += dst_count * sizeof(SOCKADDR_IN6) * 2; /* source address + destination address */
402 if (!(pairs = HeapAlloc( GetProcessHeap(), 0, size ))) return ERROR_NOT_ENOUGH_MEMORY;
403 ptr = (SOCKADDR_IN6 *)&pairs[dst_count];
404
405 if ((ret = getIPAddrTable( &table, GetProcessHeap(), 0 )))
406 {
407 HeapFree( GetProcessHeap(), 0, pairs );
408 return ret;
409 }
410
411 for (i = 0; i < dst_count; i++)
412 {
413 pairs[i].SourceAddress = ptr++;
414 if (!map_address_6to4( &dst_list[i], &addr4 ) ||
415 !find_src_address( table, &addr4, pairs[i].SourceAddress ))
416 {
417 char buf[46];
418 FIXME( "source address for %s not found\n", debugstr_ipv6(&dst_list[i], buf) );
419 memset( pairs[i].SourceAddress, 0, sizeof(*pairs[i].SourceAddress) );
420 pairs[i].SourceAddress->sin6_family = WS_AF_INET6;
421 }
422
423 pairs[i].DestinationAddress = ptr++;
424 memcpy( pairs[i].DestinationAddress, &dst_list[i], sizeof(*pairs[i].DestinationAddress) );
425 }
426 *pair_list = pairs;
427 *pair_count = dst_count;
428
429 HeapFree( GetProcessHeap(), 0, table );
430 return NO_ERROR;
431 }
432
433
434 /******************************************************************
435 * DeleteIPAddress (IPHLPAPI.@)
436 *
437 * Delete an IP address added with AddIPAddress().
438 *
439 * PARAMS
440 * NTEContext [In] NTE context from AddIPAddress();
441 *
442 * RETURNS
443 * Success: NO_ERROR
444 * Failure: error code from winerror.h
445 *
446 * FIXME
447 * Stub, returns ERROR_NOT_SUPPORTED.
448 */
449 DWORD WINAPI DeleteIPAddress(ULONG NTEContext)
450 {
451 FIXME("(NTEContext %d): stub\n", NTEContext);
452 return ERROR_NOT_SUPPORTED;
453 }
454
455
456 /******************************************************************
457 * DeleteIpForwardEntry (IPHLPAPI.@)
458 *
459 * Delete a route.
460 *
461 * PARAMS
462 * pRoute [In] route to delete
463 *
464 * RETURNS
465 * Success: NO_ERROR
466 * Failure: error code from winerror.h
467 *
468 * FIXME
469 * Stub, returns NO_ERROR.
470 */
471 DWORD WINAPI DeleteIpForwardEntry(PMIB_IPFORWARDROW pRoute)
472 {
473 FIXME("(pRoute %p): stub\n", pRoute);
474 /* could use SIOCDELRT, not sure I want to */
475 return 0;
476 }
477
478
479 /******************************************************************
480 * DeleteIpNetEntry (IPHLPAPI.@)
481 *
482 * Delete an ARP entry.
483 *
484 * PARAMS
485 * pArpEntry [In] ARP entry to delete
486 *
487 * RETURNS
488 * Success: NO_ERROR
489 * Failure: error code from winerror.h
490 *
491 * FIXME
492 * Stub, returns NO_ERROR.
493 */
494 DWORD WINAPI DeleteIpNetEntry(PMIB_IPNETROW pArpEntry)
495 {
496 FIXME("(pArpEntry %p): stub\n", pArpEntry);
497 /* could use SIOCDARP on systems that support it, not sure I want to */
498 return 0;
499 }
500
501
502 /******************************************************************
503 * DeleteProxyArpEntry (IPHLPAPI.@)
504 *
505 * Delete a Proxy ARP entry.
506 *
507 * PARAMS
508 * dwAddress [In] IP address for which this computer acts as a proxy.
509 * dwMask [In] subnet mask for dwAddress
510 * dwIfIndex [In] interface index
511 *
512 * RETURNS
513 * Success: NO_ERROR
514 * Failure: error code from winerror.h
515 *
516 * FIXME
517 * Stub, returns ERROR_NOT_SUPPORTED.
518 */
519 DWORD WINAPI DeleteProxyArpEntry(DWORD dwAddress, DWORD dwMask, DWORD dwIfIndex)
520 {
521 FIXME("(dwAddress 0x%08x, dwMask 0x%08x, dwIfIndex 0x%08x): stub\n",
522 dwAddress, dwMask, dwIfIndex);
523 return ERROR_NOT_SUPPORTED;
524 }
525
526
527 /******************************************************************
528 * EnableRouter (IPHLPAPI.@)
529 *
530 * Turn on ip forwarding.
531 *
532 * PARAMS
533 * pHandle [In/Out]
534 * pOverlapped [In/Out] hEvent member should contain a valid handle.
535 *
536 * RETURNS
537 * Success: ERROR_IO_PENDING
538 * Failure: error code from winerror.h
539 *
540 * FIXME
541 * Stub, returns ERROR_NOT_SUPPORTED.
542 */
543 DWORD WINAPI EnableRouter(HANDLE * pHandle, OVERLAPPED * pOverlapped)
544 {
545 FIXME("(pHandle %p, pOverlapped %p): stub\n", pHandle, pOverlapped);
546 /* could echo "1" > /proc/net/sys/net/ipv4/ip_forward, not sure I want to
547 could map EACCESS to ERROR_ACCESS_DENIED, I suppose
548 */
549 return ERROR_NOT_SUPPORTED;
550 }
551
552
553 /******************************************************************
554 * FlushIpNetTable (IPHLPAPI.@)
555 *
556 * Delete all ARP entries of an interface
557 *
558 * PARAMS
559 * dwIfIndex [In] interface index
560 *
561 * RETURNS
562 * Success: NO_ERROR
563 * Failure: error code from winerror.h
564 *
565 * FIXME
566 * Stub, returns ERROR_NOT_SUPPORTED.
567 */
568 DWORD WINAPI FlushIpNetTable(DWORD dwIfIndex)
569 {
570 FIXME("(dwIfIndex 0x%08x): stub\n", dwIfIndex);
571 /* this flushes the arp cache of the given index */
572 return ERROR_NOT_SUPPORTED;
573 }
574
575 /******************************************************************
576 * FreeMibTable (IPHLPAPI.@)
577 *
578 * Free buffer allocated by network functions
579 *
580 * PARAMS
581 * ptr [In] pointer to the buffer to free
582 *
583 */
584 void WINAPI FreeMibTable(void *ptr)
585 {
586 TRACE("(%p)\n", ptr);
587 HeapFree(GetProcessHeap(), 0, ptr);
588 }
589
590 /******************************************************************
591 * GetAdapterIndex (IPHLPAPI.@)
592 *
593 * Get interface index from its name.
594 *
595 * PARAMS
596 * AdapterName [In] unicode string with the adapter name
597 * IfIndex [Out] returns found interface index
598 *
599 * RETURNS
600 * Success: NO_ERROR
601 * Failure: error code from winerror.h
602 */
603 DWORD WINAPI GetAdapterIndex(LPWSTR AdapterName, PULONG IfIndex)
604 {
605 char adapterName[MAX_ADAPTER_NAME];
606 unsigned int i;
607 DWORD ret;
608
609 TRACE("(AdapterName %p, IfIndex %p)\n", AdapterName, IfIndex);
610 /* The adapter name is guaranteed not to have any unicode characters, so
611 * this translation is never lossy */
612 for (i = 0; i < sizeof(adapterName) - 1 && AdapterName[i]; i++)
613 adapterName[i] = (char)AdapterName[i];
614 adapterName[i] = '\0';
615 ret = getInterfaceIndexByName(adapterName, IfIndex);
616 TRACE("returning %d\n", ret);
617 return ret;
618 }
619
620
621 /******************************************************************
622 * GetAdaptersInfo (IPHLPAPI.@)
623 *
624 * Get information about adapters.
625 *
626 * PARAMS
627 * pAdapterInfo [Out] buffer for adapter infos
628 * pOutBufLen [In] length of output buffer
629 *
630 * RETURNS
631 * Success: NO_ERROR
632 * Failure: error code from winerror.h
633 */
634 DWORD WINAPI GetAdaptersInfo(PIP_ADAPTER_INFO pAdapterInfo, PULONG pOutBufLen)
635 {
636 DWORD ret;
637
638 TRACE("pAdapterInfo %p, pOutBufLen %p\n", pAdapterInfo, pOutBufLen);
639 if (!pOutBufLen)
640 ret = ERROR_INVALID_PARAMETER;
641 else {
642 DWORD numNonLoopbackInterfaces = get_interface_indices( TRUE, NULL );
643
644 if (numNonLoopbackInterfaces > 0) {
645 DWORD numIPAddresses = getNumIPAddresses();
646 ULONG size;
647
648 /* This may slightly overestimate the amount of space needed, because
649 * the IP addresses include the loopback address, but it's easier
650 * to make sure there's more than enough space than to make sure there's
651 * precisely enough space.
652 */
653 size = sizeof(IP_ADAPTER_INFO) * numNonLoopbackInterfaces;
654 size += numIPAddresses * sizeof(IP_ADDR_STRING);
655 if (!pAdapterInfo || *pOutBufLen < size) {
656 *pOutBufLen = size;
657 ret = ERROR_BUFFER_OVERFLOW;
658 }
659 else {
660 InterfaceIndexTable *table = NULL;
661 PMIB_IPADDRTABLE ipAddrTable = NULL;
662 PMIB_IPFORWARDTABLE routeTable = NULL;
663
664 ret = getIPAddrTable(&ipAddrTable, GetProcessHeap(), 0);
665 if (!ret)
666 ret = AllocateAndGetIpForwardTableFromStack(&routeTable, FALSE, GetProcessHeap(), 0);
667 if (!ret)
668 get_interface_indices( TRUE, &table );
669 if (table) {
670 size = sizeof(IP_ADAPTER_INFO) * table->numIndexes;
671 size += ipAddrTable->dwNumEntries * sizeof(IP_ADDR_STRING);
672 if (*pOutBufLen < size) {
673 *pOutBufLen = size;
674 ret = ERROR_INSUFFICIENT_BUFFER;
675 }
676 else {
677 DWORD ndx;
678 HKEY hKey;
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));
683
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);
689 unsigned long addr;
690
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)
695 winsEnabled = TRUE;
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)
701 winsEnabled = TRUE;
702 RegCloseKey(hKey);
703 }
704 for (ndx = 0; ndx < table->numIndexes; ndx++) {
705 PIP_ADAPTER_INFO ptr = &pAdapterInfo[ndx];
706 DWORD i;
707 PIP_ADDR_STRING currentIPAddr = &ptr->IpAddressList;
708 BOOL firstIPAddr = TRUE;
709
710 /* on Win98 this is left empty, but whatever */
711 getInterfaceNameByIndex(table->indexes[ndx], ptr->AdapterName);
712 getInterfaceNameByIndex(table->indexes[ndx], ptr->Description);
713 ptr->AddressLength = sizeof(ptr->Address);
714 getInterfacePhysicalByIndex(table->indexes[ndx],
715 &ptr->AddressLength, ptr->Address, &ptr->Type);
716 ptr->Index = table->indexes[ndx];
717 for (i = 0; i < ipAddrTable->dwNumEntries; i++) {
718 if (ipAddrTable->table[i].dwIndex == ptr->Index) {
719 if (firstIPAddr) {
720 RtlIpv4AddressToStringA((IN_ADDR *)&ipAddrTable->table[i].dwAddr,
721 ptr->IpAddressList.IpAddress.String);
722 RtlIpv4AddressToStringA((IN_ADDR *)&ipAddrTable->table[i].dwMask,
723 ptr->IpAddressList.IpMask.String);
724 firstIPAddr = FALSE;
725 }
726 else {
727 currentIPAddr->Next = nextIPAddr;
728 currentIPAddr = nextIPAddr;
729 RtlIpv4AddressToStringA((IN_ADDR *)&ipAddrTable->table[i].dwAddr,
730 currentIPAddr->IpAddress.String);
731 RtlIpv4AddressToStringA((IN_ADDR *)&ipAddrTable->table[i].dwMask,
732 currentIPAddr->IpMask.String);
733 nextIPAddr++;
734 }
735 }
736 }
737 /* If no IP was found it probably means that the interface is not
738 * configured. In this case we have to return a zeroed IP and mask. */
739 if (firstIPAddr) {
740 strcpy(ptr->IpAddressList.IpAddress.String, "0.0.0.0");
741 strcpy(ptr->IpAddressList.IpMask.String, "0.0.0.0");
742 }
743 /* Find first router through this interface, which we'll assume
744 * is the default gateway for this adapter */
745 strcpy(ptr->GatewayList.IpAddress.String, "0.0.0.0");
746 strcpy(ptr->GatewayList.IpMask.String, "255.255.255.255");
747 for (i = 0; i < routeTable->dwNumEntries; i++)
748 if (routeTable->table[i].dwForwardIfIndex == ptr->Index
749 && routeTable->table[i].u1.ForwardType ==
750 MIB_IPROUTE_TYPE_INDIRECT)
751 {
752 RtlIpv4AddressToStringA((IN_ADDR *)&routeTable->table[i].dwForwardNextHop,
753 ptr->GatewayList.IpAddress.String);
754 RtlIpv4AddressToStringA((IN_ADDR *)&routeTable->table[i].dwForwardMask,
755 ptr->GatewayList.IpMask.String);
756 }
757 if (winsEnabled) {
758 ptr->HaveWins = TRUE;
759 memcpy(ptr->PrimaryWinsServer.IpAddress.String,
760 primaryWINS.String, sizeof(primaryWINS.String));
761 memcpy(ptr->SecondaryWinsServer.IpAddress.String,
762 secondaryWINS.String, sizeof(secondaryWINS.String));
763 }
764 if (ndx < table->numIndexes - 1)
765 ptr->Next = &pAdapterInfo[ndx + 1];
766 else
767 ptr->Next = NULL;
768
769 ptr->DhcpEnabled = TRUE;
770 }
771 ret = NO_ERROR;
772 }
773 HeapFree(GetProcessHeap(), 0, table);
774 }
775 else
776 ret = ERROR_OUTOFMEMORY;
777 HeapFree(GetProcessHeap(), 0, routeTable);
778 HeapFree(GetProcessHeap(), 0, ipAddrTable);
779 }
780 }
781 else
782 ret = ERROR_NO_DATA;
783 }
784 TRACE("returning %d\n", ret);
785 return ret;
786 }
787
788 static DWORD typeFromMibType(DWORD mib_type)
789 {
790 switch (mib_type)
791 {
792 case MIB_IF_TYPE_ETHERNET: return IF_TYPE_ETHERNET_CSMACD;
793 case MIB_IF_TYPE_TOKENRING: return IF_TYPE_ISO88025_TOKENRING;
794 case MIB_IF_TYPE_PPP: return IF_TYPE_PPP;
795 case MIB_IF_TYPE_LOOPBACK: return IF_TYPE_SOFTWARE_LOOPBACK;
796 default: return IF_TYPE_OTHER;
797 }
798 }
799
800 static NET_IF_CONNECTION_TYPE connectionTypeFromMibType(DWORD mib_type)
801 {
802 switch (mib_type)
803 {
804 case MIB_IF_TYPE_PPP: return NET_IF_CONNECTION_DEMAND;
805 case MIB_IF_TYPE_SLIP: return NET_IF_CONNECTION_DEMAND;
806 default: return NET_IF_CONNECTION_DEDICATED;
807 }
808 }
809
810 static ULONG v4addressesFromIndex(IF_INDEX index, DWORD **addrs, ULONG *num_addrs, DWORD **masks)
811 {
812 ULONG ret, i, j;
813 MIB_IPADDRTABLE *at;
814
815 *num_addrs = 0;
816 if ((ret = getIPAddrTable(&at, GetProcessHeap(), 0))) return ret;
817 for (i = 0; i < at->dwNumEntries; i++)
818 {
819 if (at->table[i].dwIndex == index) (*num_addrs)++;
820 }
821 if (!(*addrs = HeapAlloc(GetProcessHeap(), 0, *num_addrs * sizeof(DWORD))))
822 {
823 HeapFree(GetProcessHeap(), 0, at);
824 return ERROR_OUTOFMEMORY;
825 }
826 if (!(*masks = HeapAlloc(GetProcessHeap(), 0, *num_addrs * sizeof(DWORD))))
827 {
828 HeapFree(GetProcessHeap(), 0, *addrs);
829 HeapFree(GetProcessHeap(), 0, at);
830 return ERROR_OUTOFMEMORY;
831 }
832 for (i = 0, j = 0; i < at->dwNumEntries; i++)
833 {
834 if (at->table[i].dwIndex == index)
835 {
836 (*addrs)[j] = at->table[i].dwAddr;
837 (*masks)[j] = at->table[i].dwMask;
838 j++;
839 }
840 }
841 HeapFree(GetProcessHeap(), 0, at);
842 return ERROR_SUCCESS;
843 }
844
845 static char *debugstr_ipv4(const in_addr_t *in_addr, char *buf)
846 {
847 const BYTE *addrp;
848 char *p = buf;
849
850 for (addrp = (const BYTE *)in_addr;
851 addrp - (const BYTE *)in_addr < sizeof(*in_addr);
852 addrp++)
853 {
854 if (addrp == (const BYTE *)in_addr + sizeof(*in_addr) - 1)
855 sprintf(p, "%d", *addrp);
856 else
857 p += sprintf(p, "%d.", *addrp);
858 }
859 return buf;
860 }
861
862 static ULONG count_v4_gateways(DWORD index, PMIB_IPFORWARDTABLE routeTable)
863 {
864 DWORD i, num_gateways = 0;
865
866 for (i = 0; i < routeTable->dwNumEntries; i++)
867 {
868 if (routeTable->table[i].dwForwardIfIndex == index &&
869 routeTable->table[i].u1.ForwardType == MIB_IPROUTE_TYPE_INDIRECT)
870 num_gateways++;
871 }
872 return num_gateways;
873 }
874
875 static DWORD mask_v4_to_prefix(DWORD m)
876 {
877 #ifdef HAVE___BUILTIN_POPCOUNT
878 return __builtin_popcount(m);
879 #else
880 m -= m >> 1 & 0x55555555;
881 m = (m & 0x33333333) + (m >> 2 & 0x33333333);
882 return ((m + (m >> 4)) & 0x0f0f0f0f) * 0x01010101 >> 24;
883 #endif
884 }
885
886 static DWORD mask_v6_to_prefix(SOCKET_ADDRESS *m)
887 {
888 const IN6_ADDR *mask = &((struct WS_sockaddr_in6 *)m->lpSockaddr)->sin6_addr;
889 DWORD ret = 0, i;
890
891 for (i = 0; i < 8; i++)
892 ret += mask_v4_to_prefix(mask->u.Word[i]);
893 return ret;
894 }
895
896 static PMIB_IPFORWARDROW findIPv4Gateway(DWORD index,
897 PMIB_IPFORWARDTABLE routeTable)
898 {
899 DWORD i;
900 PMIB_IPFORWARDROW row = NULL;
901
902 for (i = 0; !row && i < routeTable->dwNumEntries; i++)
903 {
904 if (routeTable->table[i].dwForwardIfIndex == index &&
905 routeTable->table[i].u1.ForwardType == MIB_IPROUTE_TYPE_INDIRECT)
906 row = &routeTable->table[i];
907 }
908 return row;
909 }
910
911 static void fill_unicast_addr_data(IP_ADAPTER_ADDRESSES *aa, IP_ADAPTER_UNICAST_ADDRESS *ua)
912 {
913 /* Actually this information should be read somewhere from the system
914 * but it doesn't matter much for the bugs found so far.
915 * This information is required for DirectPlay8 games. */
916 if (aa->IfType != IF_TYPE_SOFTWARE_LOOPBACK)
917 {
918 ua->PrefixOrigin = IpPrefixOriginDhcp;
919 ua->SuffixOrigin = IpSuffixOriginDhcp;
920 }
921 else
922 {
923 ua->PrefixOrigin = IpPrefixOriginManual;
924 ua->SuffixOrigin = IpSuffixOriginManual;
925 }
926
927 /* The address is not duplicated in the network */
928 ua->DadState = IpDadStatePreferred;
929
930 /* Some address life time values, required even for non-dhcp addresses */
931 ua->ValidLifetime = 60000;
932 ua->PreferredLifetime = 60000;
933 ua->LeaseLifetime = 60000;
934 }
935
936 static ULONG adapterAddressesFromIndex(ULONG family, ULONG flags, IF_INDEX index,
937 IP_ADAPTER_ADDRESSES *aa, ULONG *size)
938 {
939 ULONG ret = ERROR_SUCCESS, i, j, num_v4addrs = 0, num_v4_gateways = 0, num_v6addrs = 0, total_size;
940 DWORD *v4addrs = NULL, *v4masks = NULL;
941 SOCKET_ADDRESS *v6addrs = NULL, *v6masks = NULL;
942 PMIB_IPFORWARDTABLE routeTable = NULL;
943 BOOL output_gateways;
944
945 if ((flags & GAA_FLAG_INCLUDE_ALL_GATEWAYS) || !(flags & GAA_FLAG_SKIP_UNICAST))
946 {
947 ret = AllocateAndGetIpForwardTableFromStack(&routeTable, FALSE, GetProcessHeap(), 0);
948 if (ret) return ret;
949 num_v4_gateways = count_v4_gateways(index, routeTable);
950 }
951 output_gateways = (flags & GAA_FLAG_INCLUDE_ALL_GATEWAYS) && (family == WS_AF_INET || family == WS_AF_UNSPEC);
952
953 if (family == WS_AF_INET)
954 {
955 ret = v4addressesFromIndex(index, &v4addrs, &num_v4addrs, &v4masks);
956 }
957 else if (family == WS_AF_INET6)
958 {
959 ret = v6addressesFromIndex(index, &v6addrs, &num_v6addrs, &v6masks);
960 }
961 else if (family == WS_AF_UNSPEC)
962 {
963 ret = v4addressesFromIndex(index, &v4addrs, &num_v4addrs, &v4masks);
964 if (!ret) ret = v6addressesFromIndex(index, &v6addrs, &num_v6addrs, &v6masks);
965 }
966 else
967 {
968 FIXME("address family %u unsupported\n", family);
969 ret = ERROR_NO_DATA;
970 }
971 if (ret)
972 {
973 HeapFree(GetProcessHeap(), 0, v4addrs);
974 HeapFree(GetProcessHeap(), 0, v4masks);
975 HeapFree(GetProcessHeap(), 0, v6addrs);
976 HeapFree(GetProcessHeap(), 0, v6masks);
977 HeapFree(GetProcessHeap(), 0, routeTable);
978 return ret;
979 }
980
981 total_size = sizeof(IP_ADAPTER_ADDRESSES);
982 total_size += 39; /* "{00000000-0000-0000-0000-000000000000}" */
983 total_size += IF_NAMESIZE * sizeof(WCHAR);
984 if (!(flags & GAA_FLAG_SKIP_FRIENDLY_NAME))
985 total_size += IF_NAMESIZE * sizeof(WCHAR);
986 if (flags & GAA_FLAG_INCLUDE_PREFIX)
987 {
988 total_size += sizeof(IP_ADAPTER_PREFIX) * num_v4addrs;
989 total_size += sizeof(IP_ADAPTER_PREFIX) * num_v6addrs;
990 total_size += sizeof(struct sockaddr_in) * num_v4addrs;
991 for (i = 0; i < num_v6addrs; i++)
992 total_size += v6masks[i].iSockaddrLength;
993 }
994 total_size += sizeof(IP_ADAPTER_UNICAST_ADDRESS) * num_v4addrs;
995 total_size += sizeof(struct sockaddr_in) * num_v4addrs;
996 if (output_gateways)
997 total_size += (sizeof(IP_ADAPTER_GATEWAY_ADDRESS) + sizeof(SOCKADDR_IN)) * num_v4_gateways;
998 total_size += sizeof(IP_ADAPTER_UNICAST_ADDRESS) * num_v6addrs;
999 total_size += sizeof(SOCKET_ADDRESS) * num_v6addrs;
1000 for (i = 0; i < num_v6addrs; i++)
1001 total_size += v6addrs[i].iSockaddrLength;
1002
1003 if (aa && *size >= total_size)
1004 {
1005 char name[IF_NAMESIZE], *ptr = (char *)aa + sizeof(IP_ADAPTER_ADDRESSES), *src;
1006 WCHAR *dst;
1007 DWORD buflen, type;
1008 INTERNAL_IF_OPER_STATUS status;
1009 NET_LUID luid;
1010 GUID guid;
1011
1012 memset(aa, 0, sizeof(IP_ADAPTER_ADDRESSES));
1013 aa->u.s.Length = sizeof(IP_ADAPTER_ADDRESSES);
1014 aa->u.s.IfIndex = index;
1015
1016 ConvertInterfaceIndexToLuid(index, &luid);
1017 ConvertInterfaceLuidToGuid(&luid, &guid);
1018 sprintf(ptr, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
1019 guid.Data1, guid.Data2, guid.Data3, guid.Data4[0], guid.Data4[1],
1020 guid.Data4[2], guid.Data4[3], guid.Data4[4], guid.Data4[5],
1021 guid.Data4[6], guid.Data4[7]);
1022 aa->AdapterName = ptr;
1023 ptr += 39;
1024
1025 getInterfaceNameByIndex(index, name);
1026 if (!(flags & GAA_FLAG_SKIP_FRIENDLY_NAME))
1027 {
1028 aa->FriendlyName = (WCHAR *)ptr;
1029 for (src = name, dst = (WCHAR *)ptr; *src; src++, dst++)
1030 *dst = *src;
1031 *dst++ = 0;
1032 ptr = (char *)dst;
1033 }
1034 aa->Description = (WCHAR *)ptr;
1035 for (src = name, dst = (WCHAR *)ptr; *src; src++, dst++)
1036 *dst = *src;
1037 *dst++ = 0;
1038 ptr = (char *)dst;
1039
1040 TRACE("%s: %d IPv4 addresses, %d IPv6 addresses:\n", name, num_v4addrs,
1041 num_v6addrs);
1042
1043 buflen = MAX_INTERFACE_PHYSADDR;
1044 getInterfacePhysicalByIndex(index, &buflen, aa->PhysicalAddress, &type);
1045 aa->PhysicalAddressLength = buflen;
1046 aa->IfType = typeFromMibType(type);
1047 aa->ConnectionType = connectionTypeFromMibType(type);
1048 aa->Luid.Info.NetLuidIndex = index;
1049 aa->Luid.Info.IfType = aa->IfType;
1050
1051 if (output_gateways && num_v4_gateways)
1052 {
1053 PMIB_IPFORWARDROW adapterRow;
1054
1055 if ((adapterRow = findIPv4Gateway(index, routeTable)))
1056 {
1057 PIP_ADAPTER_GATEWAY_ADDRESS gw;
1058 PSOCKADDR_IN sin;
1059
1060 gw = (PIP_ADAPTER_GATEWAY_ADDRESS)ptr;
1061 aa->FirstGatewayAddress = gw;
1062
1063 gw->u.s.Length = sizeof(IP_ADAPTER_GATEWAY_ADDRESS);
1064 ptr += sizeof(IP_ADAPTER_GATEWAY_ADDRESS);
1065 sin = (PSOCKADDR_IN)ptr;
1066 sin->sin_family = WS_AF_INET;
1067 sin->sin_port = 0;
1068 memcpy(&sin->sin_addr, &adapterRow->dwForwardNextHop,
1069 sizeof(DWORD));
1070 gw->Address.lpSockaddr = (LPSOCKADDR)sin;
1071 gw->Address.iSockaddrLength = sizeof(SOCKADDR_IN);
1072 gw->Next = NULL;
1073 ptr += sizeof(SOCKADDR_IN);
1074 }
1075 }
1076 if (num_v4addrs && !(flags & GAA_FLAG_SKIP_UNICAST))
1077 {
1078 IP_ADAPTER_UNICAST_ADDRESS *ua;
1079 struct WS_sockaddr_in *sa;
1080 aa->u1.s1.Ipv4Enabled = TRUE;
1081 ua = aa->FirstUnicastAddress = (IP_ADAPTER_UNICAST_ADDRESS *)ptr;
1082 for (i = 0; i < num_v4addrs; i++)
1083 {
1084 char addr_buf[16];
1085
1086 memset(ua, 0, sizeof(IP_ADAPTER_UNICAST_ADDRESS));
1087 ua->u.s.Length = sizeof(IP_ADAPTER_UNICAST_ADDRESS);
1088 ua->Address.iSockaddrLength = sizeof(struct sockaddr_in);
1089 ua->Address.lpSockaddr = (SOCKADDR *)((char *)ua + ua->u.s.Length);
1090 if (num_v4_gateways)
1091 ua->u.s.Flags |= IP_ADAPTER_ADDRESS_DNS_ELIGIBLE;
1092
1093 sa = (struct WS_sockaddr_in *)ua->Address.lpSockaddr;
1094 sa->sin_family = WS_AF_INET;
1095 sa->sin_addr.S_un.S_addr = v4addrs[i];
1096 sa->sin_port = 0;
1097 TRACE("IPv4 %d/%d: %s\n", i + 1, num_v4addrs,
1098 debugstr_ipv4(&sa->sin_addr.S_un.S_addr, addr_buf));
1099 fill_unicast_addr_data(aa, ua);
1100
1101 ua->OnLinkPrefixLength = mask_v4_to_prefix(v4masks[i]);
1102
1103 ptr += ua->u.s.Length + ua->Address.iSockaddrLength;
1104 if (i < num_v4addrs - 1)
1105 {
1106 ua->Next = (IP_ADAPTER_UNICAST_ADDRESS *)ptr;
1107 ua = ua->Next;
1108 }
1109 }
1110 }
1111 if (num_v6addrs && !(flags & GAA_FLAG_SKIP_UNICAST))
1112 {
1113 IP_ADAPTER_UNICAST_ADDRESS *ua;
1114 struct WS_sockaddr_in6 *sa;
1115
1116 aa->u1.s1.Ipv6Enabled = TRUE;
1117 if (aa->FirstUnicastAddress)
1118 {
1119 for (ua = aa->FirstUnicastAddress; ua->Next; ua = ua->Next)
1120 ;
1121 ua->Next = (IP_ADAPTER_UNICAST_ADDRESS *)ptr;
1122 ua = (IP_ADAPTER_UNICAST_ADDRESS *)ptr;
1123 }
1124 else
1125 ua = aa->FirstUnicastAddress = (IP_ADAPTER_UNICAST_ADDRESS *)ptr;
1126 for (i = 0; i < num_v6addrs; i++)
1127 {
1128 char addr_buf[46];
1129
1130 memset(ua, 0, sizeof(IP_ADAPTER_UNICAST_ADDRESS));
1131 ua->u.s.Length = sizeof(IP_ADAPTER_UNICAST_ADDRESS);
1132 ua->Address.iSockaddrLength = v6addrs[i].iSockaddrLength;
1133 ua->Address.lpSockaddr = (SOCKADDR *)((char *)ua + ua->u.s.Length);
1134
1135 sa = (struct WS_sockaddr_in6 *)ua->Address.lpSockaddr;
1136 memcpy(sa, v6addrs[i].lpSockaddr, sizeof(*sa));
1137 TRACE("IPv6 %d/%d: %s\n", i + 1, num_v6addrs,
1138 debugstr_ipv6(sa, addr_buf));
1139 fill_unicast_addr_data(aa, ua);
1140
1141 ua->OnLinkPrefixLength = mask_v6_to_prefix(&v6masks[i]);
1142
1143 ptr += ua->u.s.Length + ua->Address.iSockaddrLength;
1144 if (i < num_v6addrs - 1)
1145 {
1146 ua->Next = (IP_ADAPTER_UNICAST_ADDRESS *)ptr;
1147 ua = ua->Next;
1148 }
1149 }
1150 }
1151 if (num_v4addrs && (flags & GAA_FLAG_INCLUDE_PREFIX))
1152 {
1153 IP_ADAPTER_PREFIX *prefix;
1154
1155 prefix = aa->FirstPrefix = (IP_ADAPTER_PREFIX *)ptr;
1156 for (i = 0; i < num_v4addrs; i++)
1157 {
1158 char addr_buf[16];
1159 struct WS_sockaddr_in *sa;
1160
1161 prefix->u.s.Length = sizeof(*prefix);
1162 prefix->u.s.Flags = 0;
1163 prefix->Next = NULL;
1164 prefix->Address.iSockaddrLength = sizeof(struct sockaddr_in);
1165 prefix->Address.lpSockaddr = (SOCKADDR *)((char *)prefix + prefix->u.s.Length);
1166
1167 sa = (struct WS_sockaddr_in *)prefix->Address.lpSockaddr;
1168 sa->sin_family = WS_AF_INET;
1169 sa->sin_addr.S_un.S_addr = v4addrs[i] & v4masks[i];
1170 sa->sin_port = 0;
1171
1172 prefix->PrefixLength = mask_v4_to_prefix(v4masks[i]);
1173
1174 TRACE("IPv4 network: %s/%u\n",
1175 debugstr_ipv4((const in_addr_t *)&sa->sin_addr.S_un.S_addr, addr_buf),
1176 prefix->PrefixLength);
1177
1178 ptr += prefix->u.s.Length + prefix->Address.iSockaddrLength;
1179 if (i < num_v4addrs - 1)
1180 {
1181 prefix->Next = (IP_ADAPTER_PREFIX *)ptr;
1182 prefix = prefix->Next;
1183 }
1184 }
1185 }
1186 if (num_v6addrs && (flags & GAA_FLAG_INCLUDE_PREFIX))
1187 {
1188 IP_ADAPTER_PREFIX *prefix;
1189
1190 if (aa->FirstPrefix)
1191 {
1192 for (prefix = aa->FirstPrefix; prefix->Next; prefix = prefix->Next)
1193 ;
1194 prefix->Next = (IP_ADAPTER_PREFIX *)ptr;
1195 prefix = (IP_ADAPTER_PREFIX *)ptr;
1196 }
1197 else
1198 prefix = aa->FirstPrefix = (IP_ADAPTER_PREFIX *)ptr;
1199 for (i = 0; i < num_v6addrs; i++)
1200 {
1201 char addr_buf[46];
1202 struct WS_sockaddr_in6 *sa;
1203 const IN6_ADDR *addr, *mask;
1204
1205 prefix->u.s.Length = sizeof(*prefix);
1206 prefix->u.s.Flags = 0;
1207 prefix->Next = NULL;
1208 prefix->Address.iSockaddrLength = sizeof(struct sockaddr_in6);
1209 prefix->Address.lpSockaddr = (SOCKADDR *)((char *)prefix + prefix->u.s.Length);
1210
1211 sa = (struct WS_sockaddr_in6 *)prefix->Address.lpSockaddr;
1212 sa->sin6_family = WS_AF_INET6;
1213 sa->sin6_port = 0;
1214 sa->sin6_flowinfo = 0;
1215 addr = &((struct WS_sockaddr_in6 *)v6addrs[i].lpSockaddr)->sin6_addr;
1216 mask = &((struct WS_sockaddr_in6 *)v6masks[i].lpSockaddr)->sin6_addr;
1217 for (j = 0; j < 8; j++) sa->sin6_addr.u.Word[j] = addr->u.Word[j] & mask->u.Word[j];
1218 sa->sin6_scope_id = 0;
1219
1220 prefix->PrefixLength = mask_v6_to_prefix(&v6masks[i]);
1221
1222 TRACE("IPv6 network: %s/%u\n", debugstr_ipv6(sa, addr_buf), prefix->PrefixLength);
1223
1224 ptr += prefix->u.s.Length + prefix->Address.iSockaddrLength;
1225 if (i < num_v6addrs - 1)
1226 {
1227 prefix->Next = (IP_ADAPTER_PREFIX *)ptr;
1228 prefix = prefix->Next;
1229 }
1230 }
1231 }
1232
1233 getInterfaceMtuByName(name, &aa->Mtu);
1234
1235 getInterfaceStatusByName(name, &status);
1236 if (status == MIB_IF_OPER_STATUS_OPERATIONAL) aa->OperStatus = IfOperStatusUp;
1237 else if (status == MIB_IF_OPER_STATUS_NON_OPERATIONAL) aa->OperStatus = IfOperStatusDown;
1238 else aa->OperStatus = IfOperStatusUnknown;
1239 }
1240 *size = total_size;
1241 HeapFree(GetProcessHeap(), 0, routeTable);
1242 HeapFree(GetProcessHeap(), 0, v6addrs);
1243 HeapFree(GetProcessHeap(), 0, v6masks);
1244 HeapFree(GetProcessHeap(), 0, v4addrs);
1245 HeapFree(GetProcessHeap(), 0, v4masks);
1246 return ERROR_SUCCESS;
1247 }
1248
1249 static void sockaddr_in_to_WS_storage( SOCKADDR_STORAGE *dst, const struct sockaddr_in *src )
1250 {
1251 SOCKADDR_IN *s = (SOCKADDR_IN *)dst;
1252
1253 s->sin_family = WS_AF_INET;
1254 s->sin_port = src->sin_port;
1255 memcpy( &s->sin_addr, &src->sin_addr, sizeof(IN_ADDR) );
1256 memset( (char *)s + FIELD_OFFSET( SOCKADDR_IN, sin_zero ), 0,
1257 sizeof(SOCKADDR_STORAGE) - FIELD_OFFSET( SOCKADDR_IN, sin_zero) );
1258 }
1259
1260 #if defined(HAVE_STRUCT___RES_STATE__U__EXT_NSCOUNT6) || \
1261 (defined(HAVE___RES_GET_STATE) && defined(HAVE___RES_GETSERVERS)) || \
1262 defined(HAVE_RES_GETSERVERS)
1263 static void sockaddr_in6_to_WS_storage( SOCKADDR_STORAGE *dst, const struct sockaddr_in6 *src )
1264 {
1265 SOCKADDR_IN6 *s = (SOCKADDR_IN6 *)dst;
1266
1267 s->sin6_family = WS_AF_INET6;
1268 s->sin6_port = src->sin6_port;
1269 s->sin6_flowinfo = src->sin6_flowinfo;
1270 memcpy( &s->sin6_addr, &src->sin6_addr, sizeof(IN6_ADDR) );
1271 s->sin6_scope_id = src->sin6_scope_id;
1272 memset( (char *)s + sizeof(SOCKADDR_IN6), 0,
1273 sizeof(SOCKADDR_STORAGE) - sizeof(SOCKADDR_IN6) );
1274 }
1275 #endif
1276
1277 #ifdef HAVE_STRUCT___RES_STATE
1278 /* call res_init() just once because of a bug in Mac OS X 10.4 */
1279 /* Call once per thread on systems that have per-thread _res. */
1280
1281 static CRITICAL_SECTION res_init_cs;
1282 static CRITICAL_SECTION_DEBUG res_init_cs_debug = {
1283 0, 0, &res_init_cs,
1284 { &res_init_cs_debug.ProcessLocksList, &res_init_cs_debug.ProcessLocksList },
1285 0, 0, { (DWORD_PTR)(__FILE__ ": res_init_cs") }
1286 };
1287 static CRITICAL_SECTION res_init_cs = { &res_init_cs_debug, -1, 0, 0, 0, 0 };
1288
1289 static void initialise_resolver(void)
1290 {
1291 EnterCriticalSection(&res_init_cs);
1292 if ((_res.options & RES_INIT) == 0)
1293 res_init();
1294 LeaveCriticalSection(&res_init_cs);
1295 }
1296
1297 #ifdef HAVE_RES_GETSERVERS
1298 static int get_dns_servers( SOCKADDR_STORAGE *servers, int num, BOOL ip4_only )
1299 {
1300 struct __res_state *state = &_res;
1301 int i, found = 0, total;
1302 SOCKADDR_STORAGE *addr = servers;
1303 union res_sockaddr_union *buf;
1304
1305 initialise_resolver();
1306
1307 total = res_getservers( state, NULL, 0 );
1308
1309 if ((!servers || !num) && !ip4_only) return total;
1310
1311 buf = HeapAlloc( GetProcessHeap(), 0, total * sizeof(union res_sockaddr_union) );
1312 total = res_getservers( state, buf, total );
1313
1314 for (i = 0; i < total; i++)
1315 {
1316 if (buf[i].sin6.sin6_family == AF_INET6 && ip4_only) continue;
1317 if (buf[i].sin.sin_family != AF_INET && buf[i].sin6.sin6_family != AF_INET6) continue;
1318
1319 found++;
1320 if (!servers || !num) continue;
1321
1322 if (buf[i].sin6.sin6_family == AF_INET6)
1323 {
1324 sockaddr_in6_to_WS_storage( addr, &buf[i].sin6 );
1325 }
1326 else
1327 {
1328 sockaddr_in_to_WS_storage( addr, &buf[i].sin );
1329 }
1330 if (++addr >= servers + num) break;
1331 }
1332
1333 HeapFree( GetProcessHeap(), 0, buf );
1334 return found;
1335 }
1336 #else
1337
1338 static int get_dns_servers( SOCKADDR_STORAGE *servers, int num, BOOL ip4_only )
1339 {
1340 int i, ip6_count = 0;
1341 SOCKADDR_STORAGE *addr;
1342
1343 initialise_resolver();
1344
1345 #ifdef HAVE_STRUCT___RES_STATE__U__EXT_NSCOUNT6
1346 ip6_count = _res._u._ext.nscount6;
1347 #endif
1348
1349 if (!servers || !num)
1350 {
1351 num = _res.nscount;
1352 if (ip4_only) num -= ip6_count;
1353 return num;
1354 }
1355
1356 for (i = 0, addr = servers; addr < (servers + num) && i < _res.nscount; i++)
1357 {
1358 #ifdef HAVE_STRUCT___RES_STATE__U__EXT_NSCOUNT6
1359 if (_res._u._ext.nsaddrs[i] && _res._u._ext.nsaddrs[i]->sin6_family == AF_INET6)
1360 {
1361 if (ip4_only) continue;
1362 sockaddr_in6_to_WS_storage( addr, _res._u._ext.nsaddrs[i] );
1363 }
1364 else
1365 #endif
1366 {
1367 sockaddr_in_to_WS_storage( addr, _res.nsaddr_list + i );
1368 }
1369 addr++;
1370 }
1371 return addr - servers;
1372 }
1373 #endif
1374 #elif defined(HAVE___RES_GET_STATE) && defined(HAVE___RES_GETSERVERS)
1375
1376 static int get_dns_servers( SOCKADDR_STORAGE *servers, int num, BOOL ip4_only )
1377 {
1378 extern struct res_state *__res_get_state( void );
1379 extern int __res_getservers( struct res_state *, struct sockaddr_storage *, int );
1380 struct res_state *state = __res_get_state();
1381 int i, found = 0, total = __res_getservers( state, NULL, 0 );
1382 SOCKADDR_STORAGE *addr = servers;
1383 struct sockaddr_storage *buf;
1384
1385 if ((!servers || !num) && !ip4_only) return total;
1386
1387 buf = HeapAlloc( GetProcessHeap(), 0, total * sizeof(struct sockaddr_storage) );
1388 total = __res_getservers( state, buf, total );
1389
1390 for (i = 0; i < total; i++)
1391 {
1392 if (buf[i].ss_family == AF_INET6 && ip4_only) continue;
1393 if (buf[i].ss_family != AF_INET && buf[i].ss_family != AF_INET6) continue;
1394
1395 found++;
1396 if (!servers || !num) continue;
1397
1398 if (buf[i].ss_family == AF_INET6)
1399 {
1400 sockaddr_in6_to_WS_storage( addr, (struct sockaddr_in6 *)(buf + i) );
1401 }
1402 else
1403 {
1404 sockaddr_in_to_WS_storage( addr, (struct sockaddr_in *)(buf + i) );
1405 }
1406 if (++addr >= servers + num) break;
1407 }
1408
1409 HeapFree( GetProcessHeap(), 0, buf );
1410 return found;
1411 }
1412 #else
1413
1414 static int get_dns_servers( SOCKADDR_STORAGE *servers, int num, BOOL ip4_only )
1415 {
1416 FIXME("Unimplemented on this system\n");
1417 return 0;
1418 }
1419 #endif
1420
1421 static ULONG get_dns_server_addresses(PIP_ADAPTER_DNS_SERVER_ADDRESS address, ULONG *len)
1422 {
1423 int num = get_dns_servers( NULL, 0, FALSE );
1424 DWORD size;
1425
1426 size = num * (sizeof(IP_ADAPTER_DNS_SERVER_ADDRESS) + sizeof(SOCKADDR_STORAGE));
1427 if (!address || *len < size)
1428 {
1429 *len = size;
1430 return ERROR_BUFFER_OVERFLOW;
1431 }
1432 *len = size;
1433 if (num > 0)
1434 {
1435 PIP_ADAPTER_DNS_SERVER_ADDRESS addr = address;
1436 SOCKADDR_STORAGE *sock_addrs = (SOCKADDR_STORAGE *)(address + num);
1437 int i;
1438
1439 get_dns_servers( sock_addrs, num, FALSE );
1440
1441 for (i = 0; i < num; i++, addr = addr->Next)
1442 {
1443 addr->u.s.Length = sizeof(*addr);
1444 if (sock_addrs[i].ss_family == WS_AF_INET6)
1445 addr->Address.iSockaddrLength = sizeof(SOCKADDR_IN6);
1446 else
1447 addr->Address.iSockaddrLength = sizeof(SOCKADDR_IN);
1448 addr->Address.lpSockaddr = (SOCKADDR *)(sock_addrs + i);
1449 if (i == num - 1)
1450 addr->Next = NULL;
1451 else
1452 addr->Next = addr + 1;
1453 }
1454 }
1455 return ERROR_SUCCESS;
1456 }
1457
1458 #ifdef HAVE_STRUCT___RES_STATE
1459 static BOOL is_ip_address_string(const char *str)
1460 {
1461 struct in_addr in;
1462 int ret;
1463
1464 ret = inet_aton(str, &in);
1465 return ret != 0;
1466 }
1467 #endif
1468
1469 static ULONG get_dns_suffix(WCHAR *suffix, ULONG *len)
1470 {
1471 ULONG size;
1472 const char *found_suffix = "";
1473 /* Always return a NULL-terminated string, even if it's empty. */
1474
1475 #ifdef HAVE_STRUCT___RES_STATE
1476 {
1477 ULONG i;
1478 initialise_resolver();
1479 for (i = 0; !*found_suffix && i < MAXDNSRCH + 1 && _res.dnsrch[i]; i++)
1480 {
1481 /* This uses a heuristic to select a DNS suffix:
1482 * the first, non-IP address string is selected.
1483 */
1484 if (!is_ip_address_string(_res.dnsrch[i]))
1485 found_suffix = _res.dnsrch[i];
1486 }
1487 }
1488 #endif
1489
1490 size = MultiByteToWideChar( CP_UNIXCP, 0, found_suffix, -1, NULL, 0 ) * sizeof(WCHAR);
1491 if (!suffix || *len < size)
1492 {
1493 *len = size;
1494 return ERROR_BUFFER_OVERFLOW;
1495 }
1496 *len = MultiByteToWideChar( CP_UNIXCP, 0, found_suffix, -1, suffix, *len / sizeof(WCHAR) ) * sizeof(WCHAR);
1497 return ERROR_SUCCESS;
1498 }
1499
1500 ULONG WINAPI DECLSPEC_HOTPATCH GetAdaptersAddresses(ULONG family, ULONG flags, PVOID reserved,
1501 PIP_ADAPTER_ADDRESSES aa, PULONG buflen)
1502 {
1503 InterfaceIndexTable *table;
1504 ULONG i, size, dns_server_size = 0, dns_suffix_size, total_size, ret = ERROR_NO_DATA;
1505
1506 TRACE("(%d, %08x, %p, %p, %p)\n", family, flags, reserved, aa, buflen);
1507
1508 if (!buflen) return ERROR_INVALID_PARAMETER;
1509
1510 get_interface_indices( FALSE, &table );
1511 if (!table || !table->numIndexes)
1512 {
1513 HeapFree(GetProcessHeap(), 0, table);
1514 return ERROR_NO_DATA;
1515 }
1516 total_size = 0;
1517 for (i = 0; i < table->numIndexes; i++)
1518 {
1519 size = 0;
1520 if ((ret = adapterAddressesFromIndex(family, flags, table->indexes[i], NULL, &size)))
1521 {
1522 HeapFree(GetProcessHeap(), 0, table);
1523 return ret;
1524 }
1525 total_size += size;
1526 }
1527 if (!(flags & GAA_FLAG_SKIP_DNS_SERVER))
1528 {
1529 /* Since DNS servers aren't really per adapter, get enough space for a
1530 * single copy of them.
1531 */
1532 get_dns_server_addresses(NULL, &dns_server_size);
1533 total_size += dns_server_size;
1534 }
1535 /* Since DNS suffix also isn't really per adapter, get enough space for a
1536 * single copy of it.
1537 */
1538 get_dns_suffix(NULL, &dns_suffix_size);
1539 total_size += dns_suffix_size;
1540 if (aa && *buflen >= total_size)
1541 {
1542 ULONG bytes_left = size = total_size;
1543 PIP_ADAPTER_ADDRESSES first_aa = aa;
1544 PIP_ADAPTER_DNS_SERVER_ADDRESS firstDns;
1545 WCHAR *dnsSuffix;
1546
1547 for (i = 0; i < table->numIndexes; i++)
1548 {
1549 if ((ret = adapterAddressesFromIndex(family, flags, table->indexes[i], aa, &size)))
1550 {
1551 HeapFree(GetProcessHeap(), 0, table);
1552 return ret;
1553 }
1554 if (i < table->numIndexes - 1)
1555 {
1556 aa->Next = (IP_ADAPTER_ADDRESSES *)((char *)aa + size);
1557 aa = aa->Next;
1558 size = bytes_left -= size;
1559 }
1560 }
1561 if (dns_server_size)
1562 {
1563 firstDns = (PIP_ADAPTER_DNS_SERVER_ADDRESS)((BYTE *)first_aa + total_size - dns_server_size - dns_suffix_size);
1564 get_dns_server_addresses(firstDns, &dns_server_size);
1565 for (aa = first_aa; aa; aa = aa->Next)
1566 {
1567 if (aa->IfType != IF_TYPE_SOFTWARE_LOOPBACK && aa->OperStatus == IfOperStatusUp)
1568 aa->FirstDnsServerAddress = firstDns;
1569 }
1570 }
1571 aa = first_aa;
1572 dnsSuffix = (WCHAR *)((BYTE *)aa + total_size - dns_suffix_size);
1573 get_dns_suffix(dnsSuffix, &dns_suffix_size);
1574 for (; aa; aa = aa->Next)
1575 {
1576 if (aa->IfType != IF_TYPE_SOFTWARE_LOOPBACK && aa->OperStatus == IfOperStatusUp)
1577 aa->DnsSuffix = dnsSuffix;
1578 else
1579 aa->DnsSuffix = dnsSuffix + dns_suffix_size / sizeof(WCHAR) - 1;
1580 }
1581 ret = ERROR_SUCCESS;
1582 }
1583 else
1584 {
1585 ret = ERROR_BUFFER_OVERFLOW;
1586 *buflen = total_size;
1587 }
1588
1589 TRACE("num adapters %u\n", table->numIndexes);
1590 HeapFree(GetProcessHeap(), 0, table);
1591 return ret;
1592 }
1593
1594 /******************************************************************
1595 * GetBestInterface (IPHLPAPI.@)
1596 *
1597 * Get the interface, with the best route for the given IP address.
1598 *
1599 * PARAMS
1600 * dwDestAddr [In] IP address to search the interface for
1601 * pdwBestIfIndex [Out] found best interface
1602 *
1603 * RETURNS
1604 * Success: NO_ERROR
1605 * Failure: error code from winerror.h
1606 */
1607 DWORD WINAPI GetBestInterface(IPAddr dwDestAddr, PDWORD pdwBestIfIndex)
1608 {
1609 struct WS_sockaddr_in sa_in;
1610 memset(&sa_in, 0, sizeof(sa_in));
1611 sa_in.sin_family = WS_AF_INET;
1612 sa_in.sin_addr.S_un.S_addr = dwDestAddr;
1613 return GetBestInterfaceEx((struct WS_sockaddr *)&sa_in, pdwBestIfIndex);
1614 }
1615
1616 /******************************************************************
1617 * GetBestInterfaceEx (IPHLPAPI.@)
1618 *
1619 * Get the interface, with the best route for the given IP address.
1620 *
1621 * PARAMS
1622 * dwDestAddr [In] IP address to search the interface for
1623 * pdwBestIfIndex [Out] found best interface
1624 *
1625 * RETURNS
1626 * Success: NO_ERROR
1627 * Failure: error code from winerror.h
1628 */
1629 DWORD WINAPI GetBestInterfaceEx(struct WS_sockaddr *pDestAddr, PDWORD pdwBestIfIndex)
1630 {
1631 DWORD ret;
1632
1633 TRACE("pDestAddr %p, pdwBestIfIndex %p\n", pDestAddr, pdwBestIfIndex);
1634 if (!pDestAddr || !pdwBestIfIndex)
1635 ret = ERROR_INVALID_PARAMETER;
1636 else {
1637 MIB_IPFORWARDROW ipRow;
1638
1639 if (pDestAddr->sa_family == WS_AF_INET) {
1640 ret = GetBestRoute(((struct WS_sockaddr_in *)pDestAddr)->sin_addr.S_un.S_addr, 0, &ipRow);
1641 if (ret == ERROR_SUCCESS)
1642 *pdwBestIfIndex = ipRow.dwForwardIfIndex;
1643 } else {
1644 FIXME("address family %d not supported\n", pDestAddr->sa_family);
1645 ret = ERROR_NOT_SUPPORTED;
1646 }
1647 }
1648 TRACE("returning %d\n", ret);
1649 return ret;
1650 }
1651
1652
1653 /******************************************************************
1654 * GetBestRoute (IPHLPAPI.@)
1655 *
1656 * Get the best route for the given IP address.
1657 *
1658 * PARAMS
1659 * dwDestAddr [In] IP address to search the best route for
1660 * dwSourceAddr [In] optional source IP address
1661 * pBestRoute [Out] found best route
1662 *
1663 * RETURNS
1664 * Success: NO_ERROR
1665 * Failure: error code from winerror.h
1666 */
1667 DWORD WINAPI GetBestRoute(DWORD dwDestAddr, DWORD dwSourceAddr, PMIB_IPFORWARDROW pBestRoute)
1668 {
1669 PMIB_IPFORWARDTABLE table;
1670 DWORD ret;
1671
1672 TRACE("dwDestAddr 0x%08x, dwSourceAddr 0x%08x, pBestRoute %p\n", dwDestAddr,
1673 dwSourceAddr, pBestRoute);
1674 if (!pBestRoute)
1675 return ERROR_INVALID_PARAMETER;
1676
1677 ret = AllocateAndGetIpForwardTableFromStack(&table, FALSE, GetProcessHeap(), 0);
1678 if (!ret) {
1679 DWORD ndx, matchedBits, matchedNdx = table->dwNumEntries;
1680
1681 for (ndx = 0, matchedBits = 0; ndx < table->dwNumEntries; ndx++) {
1682 if (table->table[ndx].u1.ForwardType != MIB_IPROUTE_TYPE_INVALID &&
1683 (dwDestAddr & table->table[ndx].dwForwardMask) ==
1684 (table->table[ndx].dwForwardDest & table->table[ndx].dwForwardMask)) {
1685 DWORD numShifts, mask;
1686
1687 for (numShifts = 0, mask = table->table[ndx].dwForwardMask;
1688 mask && mask & 1; mask >>= 1, numShifts++)
1689 ;
1690 if (numShifts > matchedBits) {
1691 matchedBits = numShifts;
1692 matchedNdx = ndx;
1693 }
1694 else if (!matchedBits) {
1695 matchedNdx = ndx;
1696 }
1697 }
1698 }
1699 if (matchedNdx < table->dwNumEntries) {
1700 memcpy(pBestRoute, &table->table[matchedNdx], sizeof(MIB_IPFORWARDROW));
1701 ret = ERROR_SUCCESS;
1702 }
1703 else {
1704 /* No route matches, which can happen if there's no default route. */
1705 ret = ERROR_HOST_UNREACHABLE;
1706 }
1707 HeapFree(GetProcessHeap(), 0, table);
1708 }
1709 TRACE("returning %d\n", ret);
1710 return ret;
1711 }
1712
1713
1714 /******************************************************************
1715 * GetFriendlyIfIndex (IPHLPAPI.@)
1716 *
1717 * Get a "friendly" version of IfIndex, which is one that doesn't
1718 * have the top byte set. Doesn't validate whether IfIndex is a valid
1719 * adapter index.
1720 *
1721 * PARAMS
1722 * IfIndex [In] interface index to get the friendly one for
1723 *
1724 * RETURNS
1725 * A friendly version of IfIndex.
1726 */
1727 DWORD WINAPI GetFriendlyIfIndex(DWORD IfIndex)
1728 {
1729 /* windows doesn't validate these, either, just makes sure the top byte is
1730 cleared. I assume my ifenum module never gives an index with the top
1731 byte set. */
1732 TRACE("returning %d\n", IfIndex);
1733 return IfIndex;
1734 }
1735
1736
1737 /******************************************************************
1738 * GetIfEntry (IPHLPAPI.@)
1739 *
1740 * Get information about an interface.
1741 *
1742 * PARAMS
1743 * pIfRow [In/Out] In: dwIndex of MIB_IFROW selects the interface.
1744 * Out: interface information
1745 *
1746 * RETURNS
1747 * Success: NO_ERROR
1748 * Failure: error code from winerror.h
1749 */
1750 DWORD WINAPI GetIfEntry(PMIB_IFROW pIfRow)
1751 {
1752 DWORD ret;
1753 char nameBuf[MAX_ADAPTER_NAME];
1754 char *name;
1755
1756 TRACE("pIfRow %p\n", pIfRow);
1757 if (!pIfRow)
1758 return ERROR_INVALID_PARAMETER;
1759
1760 name = getInterfaceNameByIndex(pIfRow->dwIndex, nameBuf);
1761 if (name) {
1762 ret = getInterfaceEntryByName(name, pIfRow);
1763 if (ret == NO_ERROR)
1764 ret = getInterfaceStatsByName(name, pIfRow);
1765 }
1766 else
1767 ret = ERROR_INVALID_DATA;
1768 TRACE("returning %d\n", ret);
1769 return ret;
1770 }
1771
1772 /******************************************************************
1773 * GetIfEntry2 (IPHLPAPI.@)
1774 */
1775 DWORD WINAPI GetIfEntry2( MIB_IF_ROW2 *row2 )
1776 {
1777 DWORD ret, len = ARRAY_SIZE(row2->Description);
1778 char buf[MAX_ADAPTER_NAME], *name;
1779 MIB_IFROW row;
1780
1781 TRACE("%p\n", row2);
1782
1783 if (!row2 || (!(name = getInterfaceNameByIndex( row2->InterfaceIndex, buf )) &&
1784 !(name = getInterfaceNameByIndex( row2->InterfaceLuid.Info.NetLuidIndex, buf ))))
1785 {
1786 return ERROR_INVALID_PARAMETER;
1787 }
1788 if ((ret = getInterfaceEntryByName( name, &row ))) return ret;
1789 if ((ret = getInterfaceStatsByName( name, &row ))) return ret;
1790
1791 memset( row2, 0, sizeof(*row2) );
1792 row2->InterfaceLuid.Info.Reserved = 0;
1793 row2->InterfaceLuid.Info.NetLuidIndex = row.dwIndex;
1794 row2->InterfaceLuid.Info.IfType = row.dwType;
1795 row2->InterfaceIndex = row.dwIndex;
1796 ConvertInterfaceLuidToGuid( &row2->InterfaceLuid, &row2->InterfaceGuid );
1797 row2->Type = row.dwType;
1798 row2->Mtu = row.dwMtu;
1799 MultiByteToWideChar( CP_UNIXCP, 0, (const char *)row.bDescr, -1, row2->Description, len );
1800 row2->PhysicalAddressLength = row.dwPhysAddrLen;
1801 memcpy( &row2->PhysicalAddress, &row.bPhysAddr, row.dwPhysAddrLen );
1802 memcpy( &row2->PermanentPhysicalAddress, &row.bPhysAddr, row.dwPhysAddrLen );
1803 row2->OperStatus = IfOperStatusUp;
1804 row2->AdminStatus = NET_IF_ADMIN_STATUS_UP;
1805 row2->MediaConnectState = MediaConnectStateConnected;
1806 row2->ConnectionType = NET_IF_CONNECTION_DEDICATED;
1807
1808 /* stats */
1809 row2->InOctets = row.dwInOctets;
1810 row2->InUcastPkts = row.dwInUcastPkts;
1811 row2->InNUcastPkts = row.dwInNUcastPkts;
1812 row2->InDiscards = row.dwInDiscards;
1813 row2->InErrors = row.dwInErrors;
1814 row2->InUnknownProtos = row.dwInUnknownProtos;
1815 row2->OutOctets = row.dwOutOctets;
1816 row2->OutUcastPkts = row.dwOutUcastPkts;
1817 row2->OutNUcastPkts = row.dwOutNUcastPkts;
1818 row2->OutDiscards = row.dwOutDiscards;
1819 row2->OutErrors = row.dwOutErrors;
1820
1821 return NO_ERROR;
1822 }
1823
1824 static int IfTableSorter(const void *a, const void *b)
1825 {
1826 int ret;
1827
1828 if (a && b)
1829 ret = ((const MIB_IFROW*)a)->dwIndex - ((const MIB_IFROW*)b)->dwIndex;
1830 else
1831 ret = 0;
1832 return ret;
1833 }
1834
1835
1836 /******************************************************************
1837 * GetIfTable (IPHLPAPI.@)
1838 *
1839 * Get a table of local interfaces.
1840 *
1841 * PARAMS
1842 * pIfTable [Out] buffer for local interfaces table
1843 * pdwSize [In/Out] length of output buffer
1844 * bOrder [In] whether to sort the table
1845 *
1846 * RETURNS
1847 * Success: NO_ERROR
1848 * Failure: error code from winerror.h
1849 *
1850 * NOTES
1851 * If pdwSize is less than required, the function will return
1852 * ERROR_INSUFFICIENT_BUFFER, and *pdwSize will be set to the required byte
1853 * size.
1854 * If bOrder is true, the returned table will be sorted by interface index.
1855 */
1856 DWORD WINAPI GetIfTable(PMIB_IFTABLE pIfTable, PULONG pdwSize, BOOL bOrder)
1857 {
1858 DWORD ret;
1859
1860 TRACE("pIfTable %p, pdwSize %p, bOrder %d\n", pIfTable, pdwSize, bOrder);
1861
1862 if (!pdwSize)
1863 ret = ERROR_INVALID_PARAMETER;
1864 else {
1865 DWORD numInterfaces = get_interface_indices( FALSE, NULL );
1866 ULONG size = sizeof(MIB_IFTABLE);
1867
1868 if (numInterfaces > 1)
1869 size += (numInterfaces - 1) * sizeof(MIB_IFROW);
1870 if (!pIfTable || *pdwSize < size) {
1871 *pdwSize = size;
1872 ret = ERROR_INSUFFICIENT_BUFFER;
1873 }
1874 else {
1875 InterfaceIndexTable *table;
1876 get_interface_indices( FALSE, &table );
1877
1878 if (table) {
1879 size = sizeof(MIB_IFTABLE);
1880 if (table->numIndexes > 1)
1881 size += (table->numIndexes - 1) * sizeof(MIB_IFROW);
1882 if (*pdwSize < size) {
1883 *pdwSize = size;
1884 ret = ERROR_INSUFFICIENT_BUFFER;
1885 }
1886 else {
1887 DWORD ndx;
1888
1889 *pdwSize = size;
1890 pIfTable->dwNumEntries = 0;
1891 for (ndx = 0; ndx < table->numIndexes; ndx++) {
1892 pIfTable->table[ndx].dwIndex = table->indexes[ndx];
1893 GetIfEntry(&pIfTable->table[ndx]);
1894 pIfTable->dwNumEntries++;
1895 }
1896 if (bOrder)
1897 qsort(pIfTable->table, pIfTable->dwNumEntries, sizeof(MIB_IFROW),
1898 IfTableSorter);
1899 ret = NO_ERROR;
1900 }
1901 HeapFree(GetProcessHeap(), 0, table);
1902 }
1903 else
1904 ret = ERROR_OUTOFMEMORY;
1905 }
1906 }
1907 TRACE("returning %d\n", ret);
1908 return ret;
1909 }
1910
1911 /******************************************************************
1912 * GetIfTable2Ex (IPHLPAPI.@)
1913 */
1914 DWORD WINAPI GetIfTable2Ex( MIB_IF_TABLE_LEVEL level, MIB_IF_TABLE2 **table )
1915 {
1916 DWORD i, nb_interfaces, size = sizeof(MIB_IF_TABLE2);
1917 InterfaceIndexTable *index_table;
1918 MIB_IF_TABLE2 *ret;
1919
1920 TRACE( "level %u, table %p\n", level, table );
1921
1922 if (!table || level > MibIfTableNormalWithoutStatistics)
1923 return ERROR_INVALID_PARAMETER;
1924
1925 if (level != MibIfTableNormal)
1926 FIXME("level %u not fully supported\n", level);
1927
1928 if ((nb_interfaces = get_interface_indices( FALSE, NULL )) > 1)
1929 size += (nb_interfaces - 1) * sizeof(MIB_IF_ROW2);
1930
1931 if (!(ret = HeapAlloc( GetProcessHeap(), 0, size ))) return ERROR_OUTOFMEMORY;
1932
1933 get_interface_indices( FALSE, &index_table );
1934 if (!index_table)
1935 {
1936 HeapFree( GetProcessHeap(), 0, ret );
1937 return ERROR_OUTOFMEMORY;
1938 }
1939
1940 ret->NumEntries = 0;
1941 for (i = 0; i < index_table->numIndexes; i++)
1942 {
1943 ret->Table[i].InterfaceIndex = index_table->indexes[i];
1944 GetIfEntry2( &ret->Table[i] );
1945 ret->NumEntries++;
1946 }
1947
1948 HeapFree( GetProcessHeap(), 0, index_table );
1949 *table = ret;
1950 return NO_ERROR;
1951 }
1952
1953 /******************************************************************
1954 * GetIfTable2 (IPHLPAPI.@)
1955 */
1956 DWORD WINAPI GetIfTable2( MIB_IF_TABLE2 **table )
1957 {
1958 TRACE( "table %p\n", table );
1959 return GetIfTable2Ex(MibIfTableNormal, table);
1960 }
1961
1962 /******************************************************************
1963 * GetInterfaceInfo (IPHLPAPI.@)
1964 *
1965 * Get a list of network interface adapters.
1966 *
1967 * PARAMS
1968 * pIfTable [Out] buffer for interface adapters
1969 * dwOutBufLen [Out] if buffer is too small, returns required size
1970 *
1971 * RETURNS
1972 * Success: NO_ERROR
1973 * Failure: error code from winerror.h
1974 *
1975 * BUGS
1976 * MSDN states this should return non-loopback interfaces only.
1977 */
1978 DWORD WINAPI GetInterfaceInfo(PIP_INTERFACE_INFO pIfTable, PULONG dwOutBufLen)
1979 {
1980 DWORD ret;
1981
1982 TRACE("pIfTable %p, dwOutBufLen %p\n", pIfTable, dwOutBufLen);
1983 if (!dwOutBufLen)
1984 ret = ERROR_INVALID_PARAMETER;
1985 else {
1986 DWORD numInterfaces = get_interface_indices( FALSE, NULL );
1987 ULONG size = sizeof(IP_INTERFACE_INFO);
1988
1989 if (numInterfaces > 1)
1990 size += (numInterfaces - 1) * sizeof(IP_ADAPTER_INDEX_MAP);
1991 if (!pIfTable || *dwOutBufLen < size) {
1992 *dwOutBufLen = size;
1993 ret = ERROR_INSUFFICIENT_BUFFER;
1994 }
1995 else {
1996 InterfaceIndexTable *table;
1997 get_interface_indices( FALSE, &table );
1998
1999 if (table) {
2000 size = sizeof(IP_INTERFACE_INFO);
2001 if (table->numIndexes > 1)
2002 size += (table->numIndexes - 1) * sizeof(IP_ADAPTER_INDEX_MAP);
2003 if (*dwOutBufLen < size) {
2004 *dwOutBufLen = size;
2005 ret = ERROR_INSUFFICIENT_BUFFER;
2006 }
2007 else {
2008 DWORD ndx;
2009 char nameBuf[MAX_ADAPTER_NAME];
2010
2011 *dwOutBufLen = size;
2012 pIfTable->NumAdapters = 0;
2013 for (ndx = 0; ndx < table->numIndexes; ndx++) {
2014 const char *walker, *name;
2015 WCHAR *assigner;
2016
2017 pIfTable->Adapter[ndx].Index = table->indexes[ndx];
2018 name = getInterfaceNameByIndex(table->indexes[ndx], nameBuf);
2019 for (walker = name, assigner = pIfTable->Adapter[ndx].Name;
2020 walker && *walker &&
2021 assigner - pIfTable->Adapter[ndx].Name < MAX_ADAPTER_NAME - 1;
2022 walker++, assigner++)
2023 *assigner = *walker;
2024 *assigner = 0;
2025 pIfTable->NumAdapters++;
2026 }
2027 ret = NO_ERROR;
2028 }
2029 HeapFree(GetProcessHeap(), 0, table);
2030 }
2031 else
2032 ret = ERROR_OUTOFMEMORY;
2033 }
2034 }
2035 TRACE("returning %d\n", ret);
2036 return ret;
2037 }
2038
2039
2040 /******************************************************************
2041 * GetIpAddrTable (IPHLPAPI.@)
2042 *
2043 * Get interface-to-IP address mapping table.
2044 *
2045 * PARAMS
2046 * pIpAddrTable [Out] buffer for mapping table
2047 * pdwSize [In/Out] length of output buffer
2048 * bOrder [In] whether to sort the table
2049 *
2050 * RETURNS
2051 * Success: NO_ERROR
2052 * Failure: error code from winerror.h
2053 *
2054 * NOTES
2055 * If pdwSize is less than required, the function will return
2056 * ERROR_INSUFFICIENT_BUFFER, and *pdwSize will be set to the required byte
2057 * size.
2058 * If bOrder is true, the returned table will be sorted by the next hop and
2059 * an assortment of arbitrary parameters.
2060 */
2061 DWORD WINAPI GetIpAddrTable(PMIB_IPADDRTABLE pIpAddrTable, PULONG pdwSize, BOOL bOrder)
2062 {
2063 DWORD ret;
2064
2065 TRACE("pIpAddrTable %p, pdwSize %p, bOrder %d\n", pIpAddrTable, pdwSize,
2066 (DWORD)bOrder);
2067 if (!pdwSize)
2068 ret = ERROR_INVALID_PARAMETER;
2069 else {
2070 PMIB_IPADDRTABLE table;
2071
2072 ret = getIPAddrTable(&table, GetProcessHeap(), 0);
2073 if (ret == NO_ERROR)
2074 {
2075 ULONG size = FIELD_OFFSET(MIB_IPADDRTABLE, table[table->dwNumEntries]);
2076
2077 if (!pIpAddrTable || *pdwSize < size) {
2078 *pdwSize = size;
2079 ret = ERROR_INSUFFICIENT_BUFFER;
2080 }
2081 else {
2082 *pdwSize = size;
2083 memcpy(pIpAddrTable, table, size);
2084 /* sort by numeric IP value */
2085 if (bOrder)
2086 qsort(pIpAddrTable->table, pIpAddrTable->dwNumEntries,
2087 sizeof(MIB_IPADDRROW), IpAddrTableNumericSorter);
2088 /* sort ensuring loopback interfaces are in the end */
2089 else
2090 qsort(pIpAddrTable->table, pIpAddrTable->dwNumEntries,
2091 sizeof(MIB_IPADDRROW), IpAddrTableLoopbackSorter);
2092 ret = NO_ERROR;
2093 }
2094 HeapFree(GetProcessHeap(), 0, table);
2095 }
2096 }
2097 TRACE("returning %d\n", ret);
2098 return ret;
2099 }
2100
2101
2102 /******************************************************************
2103 * GetIpForwardTable (IPHLPAPI.@)
2104 *
2105 * Get the route table.
2106 *
2107 * PARAMS
2108 * pIpForwardTable [Out] buffer for route table
2109 * pdwSize [In/Out] length of output buffer
2110 * bOrder [In] whether to sort the table
2111 *
2112 * RETURNS
2113 * Success: NO_ERROR
2114 * Failure: error code from winerror.h
2115 *
2116 * NOTES
2117 * If pdwSize is less than required, the function will return
2118 * ERROR_INSUFFICIENT_BUFFER, and *pdwSize will be set to the required byte
2119 * size.
2120 * If bOrder is true, the returned table will be sorted by the next hop and
2121 * an assortment of arbitrary parameters.
2122 */
2123 DWORD WINAPI GetIpForwardTable(PMIB_IPFORWARDTABLE pIpForwardTable, PULONG pdwSize, BOOL bOrder)
2124 {
2125 DWORD ret;
2126 PMIB_IPFORWARDTABLE table;
2127
2128 TRACE("pIpForwardTable %p, pdwSize %p, bOrder %d\n", pIpForwardTable, pdwSize, bOrder);
2129
2130 if (!pdwSize) return ERROR_INVALID_PARAMETER;
2131
2132 ret = AllocateAndGetIpForwardTableFromStack(&table, bOrder, GetProcessHeap(), 0);
2133 if (!ret) {
2134 DWORD size = FIELD_OFFSET( MIB_IPFORWARDTABLE, table[table->dwNumEntries] );
2135 if (!pIpForwardTable || *pdwSize < size) {
2136 *pdwSize = size;
2137 ret = ERROR_INSUFFICIENT_BUFFER;
2138 }
2139 else {
2140 *pdwSize = size;
2141 memcpy(pIpForwardTable, table, size);
2142 }
2143 HeapFree(GetProcessHeap(), 0, table);
2144 }
2145 TRACE("returning %d\n", ret);
2146 return ret;
2147 }
2148
2149
2150 /******************************************************************
2151 * GetIpNetTable (IPHLPAPI.@)
2152 *
2153 * Get the IP-to-physical address mapping table.
2154 *
2155 * PARAMS
2156 * pIpNetTable [Out] buffer for mapping table
2157 * pdwSize [In/Out] length of output buffer
2158 * bOrder [In] whether to sort the table
2159 *
2160 * RETURNS
2161 * Success: NO_ERROR
2162 * Failure: error code from winerror.h
2163 *
2164 * NOTES
2165 * If pdwSize is less than required, the function will return
2166 * ERROR_INSUFFICIENT_BUFFER, and *pdwSize will be set to the required byte
2167 * size.
2168 * If bOrder is true, the returned table will be sorted by IP address.
2169 */
2170 DWORD WINAPI GetIpNetTable(PMIB_IPNETTABLE pIpNetTable, PULONG pdwSize, BOOL bOrder)
2171 {
2172 DWORD ret;
2173 PMIB_IPNETTABLE table;
2174
2175 TRACE("pIpNetTable %p, pdwSize %p, bOrder %d\n", pIpNetTable, pdwSize, bOrder);
2176
2177 if (!pdwSize) return ERROR_INVALID_PARAMETER;
2178
2179 ret = AllocateAndGetIpNetTableFromStack( &table, bOrder, GetProcessHeap(), 0 );
2180 if (!ret) {
2181 DWORD size = FIELD_OFFSET( MIB_IPNETTABLE, table[table->dwNumEntries] );
2182 if (!pIpNetTable || *pdwSize < size) {
2183 *pdwSize = size;
2184 ret = ERROR_INSUFFICIENT_BUFFER;
2185 }
2186 else {
2187 *pdwSize = size;
2188 memcpy(pIpNetTable, table, size);
2189 }
2190 HeapFree(GetProcessHeap(), 0, table);
2191 }
2192 TRACE("returning %d\n", ret);
2193 return ret;
2194 }
2195
2196 /* Gets the DNS server list into the list beginning at list. Assumes that
2197 * a single server address may be placed at list if *len is at least
2198 * sizeof(IP_ADDR_STRING) long. Otherwise, list->Next is set to firstDynamic,
2199 * and assumes that all remaining DNS servers are contiguously located
2200 * beginning at firstDynamic. On input, *len is assumed to be the total number
2201 * of bytes available for all DNS servers, and is ignored if list is NULL.
2202 * On return, *len is set to the total number of bytes required for all DNS
2203 * servers.
2204 * Returns ERROR_BUFFER_OVERFLOW if *len is insufficient,
2205 * ERROR_SUCCESS otherwise.
2206 */
2207 static DWORD get_dns_server_list(PIP_ADDR_STRING list,
2208 PIP_ADDR_STRING firstDynamic, DWORD *len)
2209 {
2210 DWORD size;
2211 int num = get_dns_servers( NULL, 0, TRUE );
2212
2213 size = num * sizeof(IP_ADDR_STRING);
2214 if (!list || *len < size) {
2215 *len = size;
2216 return ERROR_BUFFER_OVERFLOW;
2217 }
2218 *len = size;
2219 if (num > 0) {
2220 PIP_ADDR_STRING ptr;
2221 int i;
2222 SOCKADDR_STORAGE *addr = HeapAlloc( GetProcessHeap(), 0, num * sizeof(SOCKADDR_STORAGE) );
2223
2224 get_dns_servers( addr, num, TRUE );
2225
2226 for (i = 0, ptr = list; i < num; i++, ptr = ptr->Next) {
2227 RtlIpv4AddressToStringA((IN_ADDR *)&((struct sockaddr_in *)(addr + i))->sin_addr.s_addr,
2228 ptr->IpAddress.String);
2229 if (i == num - 1)
2230 ptr->Next = NULL;
2231 else if (i == 0)
2232 ptr->Next = firstDynamic;
2233 else
2234 ptr->Next = (PIP_ADDR_STRING)((PBYTE)ptr + sizeof(IP_ADDR_STRING));
2235 }
2236 HeapFree( GetProcessHeap(), 0, addr );
2237 }
2238 return ERROR_SUCCESS;
2239 }
2240
2241 /******************************************************************
2242 * GetNetworkParams (IPHLPAPI.@)
2243 *
2244 * Get the network parameters for the local computer.
2245 *
2246 * PARAMS
2247 * pFixedInfo [Out] buffer for network parameters
2248 * pOutBufLen [In/Out] length of output buffer
2249 *
2250 * RETURNS
2251 * Success: NO_ERROR
2252 * Failure: error code from winerror.h
2253 *
2254 * NOTES
2255 * If pOutBufLen is less than required, the function will return
2256 * ERROR_INSUFFICIENT_BUFFER, and pOutBufLen will be set to the required byte
2257 * size.
2258 */
2259 DWORD WINAPI GetNetworkParams(PFIXED_INFO pFixedInfo, PULONG pOutBufLen)
2260 {
2261 DWORD ret, size, serverListSize;
2262 LONG regReturn;
2263 HKEY hKey;
2264
2265 TRACE("pFixedInfo %p, pOutBufLen %p\n", pFixedInfo, pOutBufLen);
2266 if (!pOutBufLen)
2267 return ERROR_INVALID_PARAMETER;
2268
2269 get_dns_server_list(NULL, NULL, &serverListSize);
2270 size = sizeof(FIXED_INFO) + serverListSize - sizeof(IP_ADDR_STRING);
2271 if (!pFixedInfo || *pOutBufLen < size) {
2272 *pOutBufLen = size;
2273 return ERROR_BUFFER_OVERFLOW;
2274 }
2275
2276 memset(pFixedInfo, 0, size);
2277 size = sizeof(pFixedInfo->HostName);
2278 GetComputerNameExA(ComputerNameDnsHostname, pFixedInfo->HostName, &size);
2279 size = sizeof(pFixedInfo->DomainName);
2280 GetComputerNameExA(ComputerNameDnsDomain, pFixedInfo->DomainName, &size);
2281 get_dns_server_list(&pFixedInfo->DnsServerList,
2282 (PIP_ADDR_STRING)((BYTE *)pFixedInfo + sizeof(FIXED_INFO)),
2283 &serverListSize);
2284 /* Assume the first DNS server in the list is the "current" DNS server: */
2285 pFixedInfo->CurrentDnsServer = &pFixedInfo->DnsServerList;
2286 pFixedInfo->NodeType = HYBRID_NODETYPE;
2287 regReturn = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
2288 "SYSTEM\\CurrentControlSet\\Services\\VxD\\MSTCP", 0, KEY_READ, &hKey);
2289 if (regReturn != ERROR_SUCCESS)
2290 regReturn = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
2291 "SYSTEM\\CurrentControlSet\\Services\\NetBT\\Parameters", 0, KEY_READ,
2292 &hKey);
2293 if (regReturn == ERROR_SUCCESS)
2294 {
2295 DWORD size = sizeof(pFixedInfo->ScopeId);
2296
2297 RegQueryValueExA(hKey, "ScopeID", NULL, NULL, (LPBYTE)pFixedInfo->ScopeId, &size);
2298 RegCloseKey(hKey);
2299 }
2300
2301 /* FIXME: can check whether routing's enabled in /proc/sys/net/ipv4/ip_forward
2302 I suppose could also check for a listener on port 53 to set EnableDns */
2303 ret = NO_ERROR;
2304 TRACE("returning %d\n", ret);
2305 return ret;
2306 }
2307
2308
2309 /******************************************************************
2310 * GetNumberOfInterfaces (IPHLPAPI.@)
2311 *
2312 * Get the number of interfaces.
2313 *
2314 * PARAMS
2315 * pdwNumIf [Out] number of interfaces
2316 *
2317 * RETURNS
2318 * NO_ERROR on success, ERROR_INVALID_PARAMETER if pdwNumIf is NULL.
2319 */
2320 DWORD WINAPI GetNumberOfInterfaces(PDWORD pdwNumIf)
2321 {
2322 DWORD ret;
2323
2324 TRACE("pdwNumIf %p\n", pdwNumIf);
2325 if (!pdwNumIf)
2326 ret = ERROR_INVALID_PARAMETER;
2327 else {
2328 *pdwNumIf = get_interface_indices( FALSE, NULL );
2329 ret = NO_ERROR;
2330 }
2331 TRACE("returning %d\n", ret);
2332 return ret;
2333 }
2334
2335
2336 /******************************************************************
2337 * GetPerAdapterInfo (IPHLPAPI.@)
2338 *
2339 * Get information about an adapter corresponding to an interface.
2340 *
2341 * PARAMS
2342 * IfIndex [In] interface info
2343 * pPerAdapterInfo [Out] buffer for per adapter info
2344 * pOutBufLen [In/Out] length of output buffer
2345 *
2346 * RETURNS
2347 * Success: NO_ERROR
2348 * Failure: error code from winerror.h
2349 */
2350 DWORD WINAPI GetPerAdapterInfo(ULONG IfIndex, PIP_PER_ADAPTER_INFO pPerAdapterInfo, PULONG pOutBufLen)
2351 {
2352 ULONG bytesNeeded = sizeof(IP_PER_ADAPTER_INFO), serverListSize = 0;
2353 DWORD ret = NO_ERROR;
2354
2355 TRACE("(IfIndex %d, pPerAdapterInfo %p, pOutBufLen %p)\n", IfIndex, pPerAdapterInfo, pOutBufLen);
2356
2357 if (!pOutBufLen) return ERROR_INVALID_PARAMETER;
2358
2359 if (!isIfIndexLoopback(IfIndex)) {
2360 get_dns_server_list(NULL, NULL, &serverListSize);
2361 if (serverListSize > sizeof(IP_ADDR_STRING))
2362 bytesNeeded += serverListSize - sizeof(IP_ADDR_STRING);
2363 }
2364 if (!pPerAdapterInfo || *pOutBufLen < bytesNeeded)
2365 {
2366 *pOutBufLen = bytesNeeded;
2367 return ERROR_BUFFER_OVERFLOW;
2368 }
2369
2370 memset(pPerAdapterInfo, 0, bytesNeeded);
2371 if (!isIfIndexLoopback(IfIndex)) {
2372 ret = get_dns_server_list(&pPerAdapterInfo->DnsServerList,
2373 (PIP_ADDR_STRING)((PBYTE)pPerAdapterInfo + sizeof(IP_PER_ADAPTER_INFO)),
2374 &serverListSize);
2375 /* Assume the first DNS server in the list is the "current" DNS server: */
2376 pPerAdapterInfo->CurrentDnsServer = &pPerAdapterInfo->DnsServerList;
2377 }
2378 return ret;
2379 }
2380
2381
2382 /******************************************************************
2383 * GetRTTAndHopCount (IPHLPAPI.@)
2384 *
2385 * Get round-trip time (RTT) and hop count.
2386 *
2387 * PARAMS
2388 *
2389 * DestIpAddress [In] destination address to get the info for
2390 * HopCount [Out] retrieved hop count
2391 * MaxHops [In] maximum hops to search for the destination
2392 * RTT [Out] RTT in milliseconds
2393 *
2394 * RETURNS
2395 * Success: TRUE
2396 * Failure: FALSE
2397 *
2398 * FIXME
2399 * Stub, returns FALSE.
2400 */
2401 BOOL WINAPI GetRTTAndHopCount(IPAddr DestIpAddress, PULONG HopCount, ULONG MaxHops, PULONG RTT)
2402 {
2403 FIXME("(DestIpAddress 0x%08x, HopCount %p, MaxHops %d, RTT %p): stub\n",
2404 DestIpAddress, HopCount, MaxHops, RTT);
2405 return FALSE;
2406 }
2407
2408
2409 /******************************************************************
2410 * GetTcpTable (IPHLPAPI.@)
2411 *
2412 * Get the table of active TCP connections.
2413 *
2414 * PARAMS
2415 * pTcpTable [Out] buffer for TCP connections table
2416 * pdwSize [In/Out] length of output buffer
2417 * bOrder [In] whether to order the table
2418 *
2419 * RETURNS
2420 * Success: NO_ERROR
2421 * Failure: error code from winerror.h
2422 *
2423 * NOTES
2424 * If pdwSize is less than required, the function will return
2425 * ERROR_INSUFFICIENT_BUFFER, and *pdwSize will be set to
2426 * the required byte size.
2427 * If bOrder is true, the returned table will be sorted, first by
2428 * local address and port number, then by remote address and port
2429 * number.
2430 */
2431 DWORD WINAPI GetTcpTable(PMIB_TCPTABLE pTcpTable, PDWORD pdwSize, BOOL bOrder)
2432 {
2433 TRACE("pTcpTable %p, pdwSize %p, bOrder %d\n", pTcpTable, pdwSize, bOrder);
2434 return GetExtendedTcpTable(pTcpTable, pdwSize, bOrder, WS_AF_INET, TCP_TABLE_BASIC_ALL, 0);
2435 }
2436
2437 /******************************************************************
2438 * GetExtendedTcpTable (IPHLPAPI.@)
2439 */
2440 DWORD WINAPI GetExtendedTcpTable(PVOID pTcpTable, PDWORD pdwSize, BOOL bOrder,
2441 ULONG ulAf, TCP_TABLE_CLASS TableClass, ULONG Reserved)
2442 {
2443 DWORD ret, size;
2444 void *table;
2445
2446 TRACE("pTcpTable %p, pdwSize %p, bOrder %d, ulAf %u, TableClass %u, Reserved %u\n",
2447 pTcpTable, pdwSize, bOrder, ulAf, TableClass, Reserved);
2448
2449 if (!pdwSize) return ERROR_INVALID_PARAMETER;
2450
2451 if (TableClass >= TCP_TABLE_OWNER_MODULE_LISTENER)
2452 FIXME("module classes not fully supported\n");
2453
2454 switch (ulAf)
2455 {
2456 case WS_AF_INET:
2457 ret = build_tcp_table(TableClass, &table, bOrder, GetProcessHeap(), 0, &size);
2458 break;
2459
2460 case WS_AF_INET6:
2461 ret = build_tcp6_table(TableClass, &table, bOrder, GetProcessHeap(), 0, &size);
2462 break;
2463
2464 default:
2465 FIXME("ulAf = %u not supported\n", ulAf);
2466 ret = ERROR_NOT_SUPPORTED;
2467 }
2468
2469 if (ret)
2470 return ret;
2471
2472 if (!pTcpTable || *pdwSize < size)
2473 {
2474 *pdwSize = size;
2475 ret = ERROR_INSUFFICIENT_BUFFER;
2476 }
2477 else
2478 {
2479 *pdwSize = size;
2480 memcpy(pTcpTable, table, size);
2481 }
2482 HeapFree(GetProcessHeap(), 0, table);
2483 return ret;
2484 }
2485
2486 /******************************************************************
2487 * GetUdpTable (IPHLPAPI.@)
2488 *
2489 * Get a table of active UDP connections.
2490 *
2491 * PARAMS
2492 * pUdpTable [Out] buffer for UDP connections table
2493 * pdwSize [In/Out] length of output buffer
2494 * bOrder [In] whether to order the table
2495 *
2496 * RETURNS
2497 * Success: NO_ERROR
2498 * Failure: error code from winerror.h
2499 *
2500 * NOTES
2501 * If pdwSize is less than required, the function will return
2502 * ERROR_INSUFFICIENT_BUFFER, and *pdwSize will be set to the
2503 * required byte size.
2504 * If bOrder is true, the returned table will be sorted, first by
2505 * local address, then by local port number.
2506 */
2507 DWORD WINAPI GetUdpTable(PMIB_UDPTABLE pUdpTable, PDWORD pdwSize, BOOL bOrder)
2508 {
2509 return GetExtendedUdpTable(pUdpTable, pdwSize, bOrder, WS_AF_INET, UDP_TABLE_BASIC, 0);
2510 }
2511
2512 /******************************************************************
2513 * GetUdp6Table (IPHLPAPI.@)
2514 */
2515 DWORD WINAPI GetUdp6Table(PMIB_UDP6TABLE pUdpTable, PDWORD pdwSize, BOOL bOrder)
2516 {
2517 return GetExtendedUdpTable(pUdpTable, pdwSize, bOrder, WS_AF_INET6, UDP_TABLE_BASIC, 0);
2518 }
2519
2520 /******************************************************************
2521 * GetExtendedUdpTable (IPHLPAPI.@)
2522 */
2523 DWORD WINAPI GetExtendedUdpTable(PVOID pUdpTable, PDWORD pdwSize, BOOL bOrder,
2524 ULONG ulAf, UDP_TABLE_CLASS TableClass, ULONG Reserved)
2525 {
2526 DWORD ret, size;
2527 void *table;
2528
2529 TRACE("pUdpTable %p, pdwSize %p, bOrder %d, ulAf %u, TableClass %u, Reserved %u\n",
2530 pUdpTable, pdwSize, bOrder, ulAf, TableClass, Reserved);
2531
2532 if (!pdwSize) return ERROR_INVALID_PARAMETER;
2533
2534 if (TableClass == UDP_TABLE_OWNER_MODULE)
2535 FIXME("UDP_TABLE_OWNER_MODULE not fully supported\n");
2536
2537 switch (ulAf)
2538 {
2539 case WS_AF_INET:
2540 ret = build_udp_table(TableClass, &table, bOrder, GetProcessHeap(), 0, &size);
2541 break;
2542
2543 case WS_AF_INET6:
2544 ret = build_udp6_table(TableClass, &table, bOrder, GetProcessHeap(), 0, &size);
2545 break;
2546
2547 default:
2548 FIXME("ulAf = %u not supported\n", ulAf);
2549 ret = ERROR_NOT_SUPPORTED;
2550 }
2551
2552 if (ret)
2553 return ret;
2554
2555 if (!pUdpTable || *pdwSize < size)
2556 {
2557 *pdwSize = size;
2558 ret = ERROR_INSUFFICIENT_BUFFER;
2559 }
2560 else
2561 {
2562 *pdwSize = size;
2563 memcpy(pUdpTable, table, size);
2564 }
2565 HeapFree(GetProcessHeap(), 0, table);
2566 return ret;
2567 }
2568
2569 DWORD WINAPI GetUnicastIpAddressEntry(MIB_UNICASTIPADDRESS_ROW *row)
2570 {
2571 IP_ADAPTER_ADDRESSES *aa, *ptr;
2572 ULONG size = 0;
2573 DWORD ret;
2574
2575 TRACE("%p\n", row);
2576
2577 if (!row)
2578 return ERROR_INVALID_PARAMETER;
2579
2580 ret = GetAdaptersAddresses(row->Address.si_family, 0, NULL, NULL, &size);
2581 if (ret != ERROR_BUFFER_OVERFLOW)
2582 return ret;
2583 if (!(ptr = HeapAlloc(GetProcessHeap(), 0, size)))
2584 return ERROR_OUTOFMEMORY;
2585 if ((ret = GetAdaptersAddresses(row->Address.si_family, 0, NULL, ptr, &size)))
2586 {
2587 HeapFree(GetProcessHeap(), 0, ptr);
2588 return ret;
2589 }
2590
2591 ret = ERROR_FILE_NOT_FOUND;
2592 for (aa = ptr; aa; aa = aa->Next)
2593 {
2594 IP_ADAPTER_UNICAST_ADDRESS *ua;
2595
2596 if (aa->u.s.IfIndex != row->InterfaceIndex &&
2597 memcmp(&aa->Luid, &row->InterfaceLuid, sizeof(row->InterfaceLuid)))
2598 continue;
2599 ret = ERROR_NOT_FOUND;
2600
2601 ua = aa->FirstUnicastAddress;
2602 while (ua)
2603 {
2604 SOCKADDR_INET *uaaddr = (SOCKADDR_INET *)ua->Address.lpSockaddr;
2605
2606 if ((row->Address.si_family == WS_AF_INET6 &&
2607 !memcmp(&row->Address.Ipv6.sin6_addr, &uaaddr->Ipv6.sin6_addr, sizeof(uaaddr->Ipv6.sin6_addr))) ||
2608 (row->Address.si_family == WS_AF_INET &&
2609 row->Address.Ipv4.sin_addr.S_un.S_addr == uaaddr->Ipv4.sin_addr.S_un.S_addr))
2610 {
2611 memcpy(&row->InterfaceLuid, &aa->Luid, sizeof(aa->Luid));
2612 row->InterfaceIndex = aa->u.s.IfIndex;
2613 row->PrefixOrigin = ua->PrefixOrigin;
2614 row->SuffixOrigin = ua->SuffixOrigin;
2615 row->ValidLifetime = ua->ValidLifetime;
2616 row->PreferredLifetime = ua->PreferredLifetime;
2617 row->OnLinkPrefixLength = ua->OnLinkPrefixLength;
2618 row->SkipAsSource = 0;
2619 row->DadState = ua->DadState;
2620 if (row->Address.si_family == WS_AF_INET6)
2621 row->ScopeId.u.Value = row->Address.Ipv6.sin6_scope_id;
2622 else
2623 row->ScopeId.u.Value = 0;
2624 NtQuerySystemTime(&row->CreationTimeStamp);
2625 HeapFree(GetProcessHeap(), 0, ptr);
2626 return NO_ERROR;
2627 }
2628 ua = ua->Next;
2629 }
2630 }
2631 HeapFree(GetProcessHeap(), 0, ptr);
2632
2633 return ret;
2634 }
2635
2636 DWORD WINAPI GetUnicastIpAddressTable(ADDRESS_FAMILY family, MIB_UNICASTIPADDRESS_TABLE **table)
2637 {
2638 IP_ADAPTER_ADDRESSES *aa, *ptr;
2639 MIB_UNICASTIPADDRESS_TABLE *data;
2640 DWORD ret, count = 0;
2641 ULONG size, flags;
2642
2643 TRACE("%u, %p\n", family, table);
2644
2645 if (!table || (family != WS_AF_INET && family != WS_AF_INET6 && family != WS_AF_UNSPEC))
2646 return ERROR_INVALID_PARAMETER;
2647
2648 flags = GAA_FLAG_SKIP_ANYCAST |
2649 GAA_FLAG_SKIP_MULTICAST |
2650 GAA_FLAG_SKIP_DNS_SERVER |
2651 GAA_FLAG_SKIP_FRIENDLY_NAME;
2652
2653 ret = GetAdaptersAddresses(family, flags, NULL, NULL, &size);
2654 if (ret != ERROR_BUFFER_OVERFLOW)
2655 return ret;
2656 if (!(ptr = HeapAlloc(GetProcessHeap(), 0, size)))
2657 return ERROR_OUTOFMEMORY;
2658 if ((ret = GetAdaptersAddresses(family, flags, NULL, ptr, &size)))
2659 {
2660 HeapFree(GetProcessHeap(), 0, ptr);
2661 return ret;
2662 }
2663
2664 for (aa = ptr; aa; aa = aa->Next)
2665 {
2666 IP_ADAPTER_UNICAST_ADDRESS *ua = aa->FirstUnicastAddress;
2667 while (ua)
2668 {
2669 count++;
2670 ua = ua->Next;
2671 }
2672 }
2673
2674 if (!(data = HeapAlloc(GetProcessHeap(), 0, sizeof(*data) + (count - 1) * sizeof(data->Table[0]))))
2675 {
2676 HeapFree(GetProcessHeap(), 0, ptr);
2677 return ERROR_OUTOFMEMORY;
2678 }
2679
2680 data->NumEntries = 0;
2681 for (aa = ptr; aa; aa = aa->Next)
2682 {
2683 IP_ADAPTER_UNICAST_ADDRESS *ua = aa->FirstUnicastAddress;
2684 while (ua)
2685 {
2686 MIB_UNICASTIPADDRESS_ROW *row = &data->Table[data->NumEntries];
2687 memcpy(&row->Address, ua->Address.lpSockaddr, ua->Address.iSockaddrLength);
2688 memcpy(&row->InterfaceLuid, &aa->Luid, sizeof(aa->Luid));
2689 row->InterfaceIndex = aa->u.s.IfIndex;
2690 row->PrefixOrigin = ua->PrefixOrigin;
2691 row->SuffixOrigin = ua->SuffixOrigin;
2692 row->ValidLifetime = ua->ValidLifetime;
2693 row->PreferredLifetime = ua->PreferredLifetime;
2694 row->OnLinkPrefixLength = ua->OnLinkPrefixLength;
2695 row->SkipAsSource = 0;
2696 row->DadState = ua->DadState;
2697 if (row->Address.si_family == WS_AF_INET6)
2698 row->ScopeId.u.Value = row->Address.Ipv6.sin6_scope_id;
2699 else
2700 row->ScopeId.u.Value = 0;
2701 NtQuerySystemTime(&row->CreationTimeStamp);
2702
2703 data->NumEntries++;
2704 ua = ua->Next;
2705 }
2706 }
2707
2708 HeapFree(GetProcessHeap(), 0, ptr);
2709
2710 *table = data;
2711 return ret;
2712 }
2713
2714 /******************************************************************
2715 * GetUniDirectionalAdapterInfo (IPHLPAPI.@)
2716 *
2717 * This is a Win98-only function to get information on "unidirectional"
2718 * adapters. Since this is pretty nonsensical in other contexts, it
2719 * never returns anything.
2720 *
2721 * PARAMS
2722 * pIPIfInfo [Out] buffer for adapter infos
2723 * dwOutBufLen [Out] length of the output buffer
2724 *
2725 * RETURNS
2726 * Success: NO_ERROR
2727 * Failure: error code from winerror.h
2728 *
2729 * FIXME
2730 * Stub, returns ERROR_NOT_SUPPORTED.
2731 */
2732 DWORD WINAPI GetUniDirectionalAdapterInfo(PIP_UNIDIRECTIONAL_ADAPTER_ADDRESS pIPIfInfo, PULONG dwOutBufLen)
2733 {
2734 TRACE("pIPIfInfo %p, dwOutBufLen %p\n", pIPIfInfo, dwOutBufLen);
2735 /* a unidirectional adapter?? not bloody likely! */
2736 return ERROR_NOT_SUPPORTED;
2737 }
2738
2739
2740 /******************************************************************
2741 * IpReleaseAddress (IPHLPAPI.@)
2742 *
2743 * Release an IP obtained through DHCP,
2744 *
2745 * PARAMS
2746 * AdapterInfo [In] adapter to release IP address
2747 *
2748 * RETURNS
2749 * Success: NO_ERROR
2750 * Failure: error code from winerror.h
2751 *
2752 * NOTES
2753 * Since GetAdaptersInfo never returns adapters that have DHCP enabled,
2754 * this function does nothing.
2755 *
2756 * FIXME
2757 * Stub, returns ERROR_NOT_SUPPORTED.
2758 */
2759 DWORD WINAPI IpReleaseAddress(PIP_ADAPTER_INDEX_MAP AdapterInfo)
2760 {
2761 FIXME("Stub AdapterInfo %p\n", AdapterInfo);
2762 return ERROR_NOT_SUPPORTED;
2763 }
2764
2765
2766 /******************************************************************
2767 * IpRenewAddress (IPHLPAPI.@)
2768 *
2769 * Renew an IP obtained through DHCP.
2770 *
2771 * PARAMS
2772 * AdapterInfo [In] adapter to renew IP address
2773 *
2774 * RETURNS
2775 * Success: NO_ERROR
2776 * Failure: error code from winerror.h
2777 *
2778 * NOTES
2779 * Since GetAdaptersInfo never returns adapters that have DHCP enabled,
2780 * this function does nothing.
2781 *
2782 * FIXME
2783 * Stub, returns ERROR_NOT_SUPPORTED.
2784 */
2785 DWORD WINAPI IpRenewAddress(PIP_ADAPTER_INDEX_MAP AdapterInfo)
2786 {
2787 FIXME("Stub AdapterInfo %p\n", AdapterInfo);
2788 return ERROR_NOT_SUPPORTED;
2789 }
2790
2791
2792 /******************************************************************
2793 * NotifyAddrChange (IPHLPAPI.@)
2794 *
2795 * Notify caller whenever the ip-interface map is changed.
2796 *
2797 * PARAMS
2798 * Handle [Out] handle usable in asynchronous notification
2799 * overlapped [In] overlapped structure that notifies the caller
2800 *
2801 * RETURNS
2802 * Success: NO_ERROR
2803 * Failure: error code from winerror.h
2804 *
2805 * FIXME
2806 * Stub, returns ERROR_NOT_SUPPORTED.
2807 */
2808 DWORD WINAPI NotifyAddrChange(PHANDLE Handle, LPOVERLAPPED overlapped)
2809 {
2810 FIXME("(Handle %p, overlapped %p): stub\n", Handle, overlapped);
2811 if (Handle) *Handle = INVALID_HANDLE_VALUE;
2812 if (overlapped) ((IO_STATUS_BLOCK *) overlapped)->u.Status = STATUS_PENDING;
2813 return ERROR_IO_PENDING;
2814 }
2815
2816
2817 /******************************************************************
2818 * NotifyIpInterfaceChange (IPHLPAPI.@)
2819 */
2820 DWORD WINAPI NotifyIpInterfaceChange(ADDRESS_FAMILY family, PIPINTERFACE_CHANGE_CALLBACK callback,
2821 PVOID context, BOOLEAN init_notify, PHANDLE handle)
2822 {
2823 FIXME("(family %d, callback %p, context %p, init_notify %d, handle %p): stub\n",
2824 family, callback, context, init_notify, handle);
2825 if (handle) *handle = NULL;
2826 return NO_ERROR;
2827 }
2828
2829 /******************************************************************
2830 * NotifyRouteChange2 (IPHLPAPI.@)
2831 */
2832 DWORD WINAPI NotifyRouteChange2(ADDRESS_FAMILY family, PIPFORWARD_CHANGE_CALLBACK callback, VOID* context,
2833 BOOLEAN init_notify, HANDLE* handle)
2834 {
2835 FIXME("(family %d, callback %p, context %p, init_notify %d, handle %p): stub\n",
2836 family, callback, context, init_notify, handle);
2837 if (handle) *handle = NULL;
2838 return NO_ERROR;
2839 }
2840
2841
2842 /******************************************************************
2843 * NotifyRouteChange (IPHLPAPI.@)
2844 *
2845 * Notify caller whenever the ip routing table is changed.
2846 *
2847 * PARAMS
2848 * Handle [Out] handle usable in asynchronous notification
2849 * overlapped [In] overlapped structure that notifies the caller
2850 *
2851 * RETURNS
2852 * Success: NO_ERROR
2853 * Failure: error code from winerror.h
2854 *
2855 * FIXME
2856 * Stub, returns ERROR_NOT_SUPPORTED.
2857 */
2858 DWORD WINAPI NotifyRouteChange(PHANDLE Handle, LPOVERLAPPED overlapped)
2859 {
2860 FIXME("(Handle %p, overlapped %p): stub\n", Handle, overlapped);
2861 return ERROR_NOT_SUPPORTED;
2862 }
2863
2864
2865 /******************************************************************
2866 * NotifyUnicastIpAddressChange (IPHLPAPI.@)
2867 */
2868 DWORD WINAPI NotifyUnicastIpAddressChange(ADDRESS_FAMILY family, PUNICAST_IPADDRESS_CHANGE_CALLBACK callback,
2869 PVOID context, BOOLEAN init_notify, PHANDLE handle)
2870 {
2871 FIXME("(family %d, callback %p, context %p, init_notify %d, handle %p): semi-stub\n",
2872 family, callback, context, init_notify, handle);
2873 if (handle) *handle = NULL;
2874
2875 if (init_notify)
2876 callback(context, NULL, MibInitialNotification);
2877
2878 return NO_ERROR;
2879 }
2880
2881 /******************************************************************
2882 * SendARP (IPHLPAPI.@)
2883 *
2884 * Send an ARP request.
2885 *
2886 * PARAMS
2887 * DestIP [In] attempt to obtain this IP
2888 * SrcIP [In] optional sender IP address
2889 * pMacAddr [Out] buffer for the mac address
2890 * PhyAddrLen [In/Out] length of the output buffer
2891 *
2892 * RETURNS
2893 * Success: NO_ERROR
2894 * Failure: error code from winerror.h
2895 *
2896 * FIXME
2897 * Stub, returns ERROR_NOT_SUPPORTED.
2898 */
2899 DWORD WINAPI SendARP(IPAddr DestIP, IPAddr SrcIP, PULONG pMacAddr, PULONG PhyAddrLen)
2900 {
2901 FIXME("(DestIP 0x%08x, SrcIP 0x%08x, pMacAddr %p, PhyAddrLen %p): stub\n",
2902 DestIP, SrcIP, pMacAddr, PhyAddrLen);
2903 return ERROR_NOT_SUPPORTED;
2904 }
2905
2906
2907 /******************************************************************
2908 * SetIfEntry (IPHLPAPI.@)
2909 *
2910 * Set the administrative status of an interface.
2911 *
2912 * PARAMS
2913 * pIfRow [In] dwAdminStatus member specifies the new status.
2914 *
2915 * RETURNS
2916 * Success: NO_ERROR
2917 * Failure: error code from winerror.h
2918 *
2919 * FIXME
2920 * Stub, returns ERROR_NOT_SUPPORTED.
2921 */
2922 DWORD WINAPI SetIfEntry(PMIB_IFROW pIfRow)
2923 {
2924 FIXME("(pIfRow %p): stub\n", pIfRow);
2925 /* this is supposed to set an interface administratively up or down.
2926 Could do SIOCSIFFLAGS and set/clear IFF_UP, but, not sure I want to, and
2927 this sort of down is indistinguishable from other sorts of down (e.g. no
2928 link). */
2929 return ERROR_NOT_SUPPORTED;
2930 }
2931
2932
2933 /******************************************************************
2934 * SetIpForwardEntry (IPHLPAPI.@)
2935 *
2936 * Modify an existing route.
2937 *
2938 * PARAMS
2939 * pRoute [In] route with the new information
2940 *
2941 * RETURNS
2942 * Success: NO_ERROR
2943 * Failure: error code from winerror.h
2944 *
2945 * FIXME
2946 * Stub, returns NO_ERROR.
2947 */
2948 DWORD WINAPI SetIpForwardEntry(PMIB_IPFORWARDROW pRoute)
2949 {
2950 FIXME("(pRoute %p): stub\n", pRoute);
2951 /* this is to add a route entry, how's it distinguishable from
2952 CreateIpForwardEntry?
2953 could use SIOCADDRT, not sure I want to */
2954 return 0;
2955 }
2956
2957
2958 /******************************************************************
2959 * SetIpNetEntry (IPHLPAPI.@)
2960 *
2961 * Modify an existing ARP entry.
2962 *
2963 * PARAMS
2964 * pArpEntry [In] ARP entry with the new information
2965 *
2966 * RETURNS
2967 * Success: NO_ERROR
2968 * Failure: error code from winerror.h
2969 *
2970 * FIXME
2971 * Stub, returns NO_ERROR.
2972 */
2973 DWORD WINAPI SetIpNetEntry(PMIB_IPNETROW pArpEntry)
2974 {
2975 FIXME("(pArpEntry %p): stub\n", pArpEntry);
2976 /* same as CreateIpNetEntry here, could use SIOCSARP, not sure I want to */
2977 return 0;
2978 }
2979
2980
2981 /******************************************************************
2982 * SetIpStatistics (IPHLPAPI.@)
2983 *
2984 * Toggle IP forwarding and det the default TTL value.
2985 *
2986 * PARAMS
2987 * pIpStats [In] IP statistics with the new information
2988 *
2989 * RETURNS
2990 * Success: NO_ERROR
2991 * Failure: error code from winerror.h
2992 *
2993 * FIXME
2994 * Stub, returns NO_ERROR.
2995 */
2996 DWORD WINAPI SetIpStatistics(PMIB_IPSTATS pIpStats)
2997 {
2998 FIXME("(pIpStats %p): stub\n", pIpStats);
2999 return 0;
3000 }
3001
3002
3003 /******************************************************************
3004 * SetIpTTL (IPHLPAPI.@)
3005 *
3006 * Set the default TTL value.
3007 *
3008 * PARAMS
3009 * nTTL [In] new TTL value
3010 *
3011 * RETURNS
3012 * Success: NO_ERROR
3013 * Failure: error code from winerror.h
3014 *
3015 * FIXME
3016 * Stub, returns NO_ERROR.
3017 */
3018 DWORD WINAPI SetIpTTL(UINT nTTL)
3019 {
3020 FIXME("(nTTL %d): stub\n", nTTL);
3021 /* could echo nTTL > /proc/net/sys/net/ipv4/ip_default_ttl, not sure I
3022 want to. Could map EACCESS to ERROR_ACCESS_DENIED, I suppose */
3023 return 0;
3024 }
3025
3026
3027 /******************************************************************
3028 * SetTcpEntry (IPHLPAPI.@)
3029 *
3030 * Set the state of a TCP connection.
3031 *
3032 * PARAMS
3033 * pTcpRow [In] specifies connection with new state
3034 *
3035 * RETURNS
3036 * Success: NO_ERROR
3037 * Failure: error code from winerror.h
3038 *
3039 * FIXME
3040 * Stub, returns NO_ERROR.
3041 */
3042 DWORD WINAPI SetTcpEntry(PMIB_TCPROW pTcpRow)
3043 {
3044 FIXME("(pTcpRow %p): stub\n", pTcpRow);
3045 return 0;
3046 }
3047
3048 /******************************************************************
3049 * SetPerTcpConnectionEStats (IPHLPAPI.@)
3050 */
3051 DWORD WINAPI SetPerTcpConnectionEStats(PMIB_TCPROW row, TCP_ESTATS_TYPE state, PBYTE rw,
3052 ULONG version, ULONG size, ULONG offset)
3053 {
3054 FIXME("(row %p, state %d, rw %p, version %u, size %u, offset %u): stub\n",
3055 row, state, rw, version, size, offset);
3056 return ERROR_NOT_SUPPORTED;
3057 }
3058
3059
3060 /******************************************************************
3061 * UnenableRouter (IPHLPAPI.@)
3062 *
3063 * Decrement the IP-forwarding reference count. Turn off IP-forwarding
3064 * if it reaches zero.
3065 *
3066 * PARAMS
3067 * pOverlapped [In/Out] should be the same as in EnableRouter()
3068 * lpdwEnableCount [Out] optional, receives reference count
3069 *
3070 * RETURNS
3071 * Success: NO_ERROR
3072 * Failure: error code from winerror.h
3073 *
3074 * FIXME
3075 * Stub, returns ERROR_NOT_SUPPORTED.
3076 */
3077 DWORD WINAPI UnenableRouter(OVERLAPPED * pOverlapped, LPDWORD lpdwEnableCount)
3078 {
3079 FIXME("(pOverlapped %p, lpdwEnableCount %p): stub\n", pOverlapped,
3080 lpdwEnableCount);
3081 /* could echo "0" > /proc/net/sys/net/ipv4/ip_forward, not sure I want to
3082 could map EACCESS to ERROR_ACCESS_DENIED, I suppose
3083 */
3084 return ERROR_NOT_SUPPORTED;
3085 }
3086
3087 /******************************************************************
3088 * PfCreateInterface (IPHLPAPI.@)
3089 */
3090 DWORD WINAPI PfCreateInterface(DWORD dwName, PFFORWARD_ACTION inAction, PFFORWARD_ACTION outAction,
3091 BOOL bUseLog, BOOL bMustBeUnique, INTERFACE_HANDLE *ppInterface)
3092 {
3093 FIXME("(%d %d %d %x %x %p) stub\n", dwName, inAction, outAction, bUseLog, bMustBeUnique, ppInterface);
3094 return ERROR_CALL_NOT_IMPLEMENTED;
3095 }
3096
3097 /******************************************************************
3098 * PfUnBindInterface (IPHLPAPI.@)
3099 */
3100 DWORD WINAPI PfUnBindInterface(INTERFACE_HANDLE interface)
3101 {
3102 FIXME("(%p) stub\n", interface);
3103 return ERROR_CALL_NOT_IMPLEMENTED;
3104 }
3105
3106 /******************************************************************
3107 * PfDeleteInterface(IPHLPAPI.@)
3108 */
3109 DWORD WINAPI PfDeleteInterface(INTERFACE_HANDLE interface)
3110 {
3111 FIXME("(%p) stub\n", interface);
3112 return ERROR_CALL_NOT_IMPLEMENTED;
3113 }
3114
3115 /******************************************************************
3116 * PfBindInterfaceToIPAddress(IPHLPAPI.@)
3117 */
3118 DWORD WINAPI PfBindInterfaceToIPAddress(INTERFACE_HANDLE interface, PFADDRESSTYPE type, PBYTE ip)
3119 {
3120 FIXME("(%p %d %p) stub\n", interface, type, ip);
3121 return ERROR_CALL_NOT_IMPLEMENTED;
3122 }
3123
3124 /******************************************************************
3125 * GetTcpTable2 (IPHLPAPI.@)
3126 */
3127 ULONG WINAPI GetTcpTable2(PMIB_TCPTABLE2 table, PULONG size, BOOL order)
3128 {
3129 FIXME("pTcpTable2 %p, pdwSize %p, bOrder %d: stub\n", table, size, order);
3130 return ERROR_NOT_SUPPORTED;
3131 }
3132
3133 /******************************************************************
3134 * GetTcp6Table (IPHLPAPI.@)
3135 */
3136 ULONG WINAPI GetTcp6Table(PMIB_TCP6TABLE table, PULONG size, BOOL order)
3137 {
3138 TRACE("(table %p, size %p, order %d)\n", table, size, order);
3139 return GetExtendedTcpTable(table, size, order, WS_AF_INET6, TCP_TABLE_BASIC_ALL, 0);
3140 }
3141
3142 /******************************************************************
3143 * GetTcp6Table2 (IPHLPAPI.@)
3144 */
3145 ULONG WINAPI GetTcp6Table2(PMIB_TCP6TABLE2 table, PULONG size, BOOL order)
3146 {
3147 FIXME("pTcp6Table2 %p, size %p, order %d: stub\n", table, size, order);
3148 return ERROR_NOT_SUPPORTED;
3149 }
3150
3151 /******************************************************************
3152 * ConvertInterfaceGuidToLuid (IPHLPAPI.@)
3153 */
3154 DWORD WINAPI ConvertInterfaceGuidToLuid(const GUID *guid, NET_LUID *luid)
3155 {
3156 DWORD ret;
3157 MIB_IFROW row;
3158
3159 TRACE("(%s %p)\n", debugstr_guid(guid), luid);
3160
3161 if (!guid || !luid) return ERROR_INVALID_PARAMETER;
3162
3163 row.dwIndex = guid->Data1;
3164 if ((ret = GetIfEntry( &row ))) return ret;
3165
3166 luid->Info.Reserved = 0;
3167 luid->Info.NetLuidIndex = guid->Data1;
3168 luid->Info.IfType = row.dwType;
3169 return NO_ERROR;
3170 }
3171
3172 /******************************************************************
3173 * ConvertInterfaceIndexToLuid (IPHLPAPI.@)
3174 */
3175 DWORD WINAPI ConvertInterfaceIndexToLuid(NET_IFINDEX index, NET_LUID *luid)
3176 {
3177 MIB_IFROW row;
3178
3179 TRACE("(%u %p)\n", index, luid);
3180
3181 if (!luid) return ERROR_INVALID_PARAMETER;
3182 memset( luid, 0, sizeof(*luid) );
3183
3184 row.dwIndex = index;
3185 if (GetIfEntry( &row )) return ERROR_FILE_NOT_FOUND;
3186
3187 luid->Info.Reserved = 0;
3188 luid->Info.NetLuidIndex = index;
3189 luid->Info.IfType = row.dwType;
3190 return NO_ERROR;
3191 }
3192
3193 /******************************************************************
3194 * ConvertInterfaceLuidToGuid (IPHLPAPI.@)
3195 */
3196 DWORD WINAPI ConvertInterfaceLuidToGuid(const NET_LUID *luid, GUID *guid)
3197 {
3198 DWORD ret;
3199 MIB_IFROW row;
3200
3201 TRACE("(%p %p)\n", luid, guid);
3202
3203 if (!luid || !guid) return ERROR_INVALID_PARAMETER;
3204
3205 row.dwIndex = luid->Info.NetLuidIndex;
3206 if ((ret = GetIfEntry( &row ))) return ret;
3207
3208 memset( guid, 0, sizeof(*guid) );
3209 guid->Data1 = luid->Info.NetLuidIndex;
3210 memcpy( guid->Data4+2, "NetDev", 6 );
3211 return NO_ERROR;
3212 }
3213
3214 /******************************************************************
3215 * ConvertInterfaceLuidToIndex (IPHLPAPI.@)
3216 */
3217 DWORD WINAPI ConvertInterfaceLuidToIndex(const NET_LUID *luid, NET_IFINDEX *index)
3218 {
3219 DWORD ret;
3220 MIB_IFROW row;
3221
3222 TRACE("(%p %p)\n", luid, index);
3223
3224 if (!luid || !index) return ERROR_INVALID_PARAMETER;
3225
3226 row.dwIndex = luid->Info.NetLuidIndex;
3227 if ((ret = GetIfEntry( &row ))) return ret;
3228
3229 *index = luid->Info.NetLuidIndex;
3230 return NO_ERROR;
3231 }
3232
3233 /******************************************************************
3234 * ConvertInterfaceLuidToNameA (IPHLPAPI.@)
3235 */
3236 DWORD WINAPI ConvertInterfaceLuidToNameA(const NET_LUID *luid, char *name, SIZE_T len)
3237 {
3238 DWORD ret;
3239 MIB_IFROW row;
3240
3241 TRACE("(%p %p %u)\n", luid, name, (DWORD)len);
3242
3243 if (!luid) return ERROR_INVALID_PARAMETER;
3244
3245 row.dwIndex = luid->Info.NetLuidIndex;
3246 if ((ret = GetIfEntry( &row ))) return ret;
3247
3248 if (!name || len < WideCharToMultiByte( CP_UNIXCP, 0, row.wszName, -1, NULL, 0, NULL, NULL ))
3249 return ERROR_NOT_ENOUGH_MEMORY;
3250
3251 WideCharToMultiByte( CP_UNIXCP, 0, row.wszName, -1, name, len, NULL, NULL );
3252 return NO_ERROR;
3253 }
3254
3255 /******************************************************************
3256 * ConvertInterfaceLuidToNameW (IPHLPAPI.@)
3257 */
3258 DWORD WINAPI ConvertInterfaceLuidToNameW(const NET_LUID *luid, WCHAR *name, SIZE_T len)
3259 {
3260 DWORD ret;
3261 MIB_IFROW row;
3262
3263 TRACE("(%p %p %u)\n", luid, name, (DWORD)len);
3264
3265 if (!luid || !name) return ERROR_INVALID_PARAMETER;
3266
3267 row.dwIndex = luid->Info.NetLuidIndex;
3268 if ((ret = GetIfEntry( &row ))) return ret;
3269
3270 if (len < strlenW( row.wszName ) + 1) return ERROR_NOT_ENOUGH_MEMORY;
3271 strcpyW( name, row.wszName );
3272 return NO_ERROR;
3273 }
3274
3275 /******************************************************************
3276 * ConvertInterfaceNameToLuidA (IPHLPAPI.@)
3277 */
3278 DWORD WINAPI ConvertInterfaceNameToLuidA(const char *name, NET_LUID *luid)
3279 {
3280 DWORD ret;
3281 IF_INDEX index;
3282 MIB_IFROW row;
3283
3284 TRACE("(%s %p)\n", debugstr_a(name), luid);
3285
3286 if ((ret = getInterfaceIndexByName( name, &index ))) return ERROR_INVALID_NAME;
3287 if (!luid) return ERROR_INVALID_PARAMETER;
3288
3289 row.dwIndex = index;
3290 if ((ret = GetIfEntry( &row ))) return ret;
3291
3292 luid->Info.Reserved = 0;
3293 luid->Info.NetLuidIndex = index;
3294 luid->Info.IfType = row.dwType;
3295 return NO_ERROR;
3296 }
3297
3298 /******************************************************************
3299 * ConvertInterfaceNameToLuidW (IPHLPAPI.@)
3300 */
3301 DWORD WINAPI ConvertInterfaceNameToLuidW(const WCHAR *name, NET_LUID *luid)
3302 {
3303 DWORD ret;
3304 IF_INDEX index;
3305 MIB_IFROW row;
3306 char nameA[IF_MAX_STRING_SIZE + 1];
3307
3308 TRACE("(%s %p)\n", debugstr_w(name), luid);
3309
3310 if (!luid) return ERROR_INVALID_PARAMETER;
3311 memset( luid, 0, sizeof(*luid) );
3312
3313 if (!WideCharToMultiByte( CP_UNIXCP, 0, name, -1, nameA, sizeof(nameA), NULL, NULL ))
3314 return ERROR_INVALID_NAME;
3315
3316 if ((ret = getInterfaceIndexByName( nameA, &index ))) return ret;
3317
3318 row.dwIndex = index;
3319 if ((ret = GetIfEntry( &row ))) return ret;
3320
3321 luid->Info.Reserved = 0;
3322 luid->Info.NetLuidIndex = index;
3323 luid->Info.IfType = row.dwType;
3324 return NO_ERROR;
3325 }
3326
3327 /******************************************************************
3328 * ConvertLengthToIpv4Mask (IPHLPAPI.@)
3329 */
3330 DWORD WINAPI ConvertLengthToIpv4Mask(ULONG mask_len, ULONG *mask)
3331 {
3332 if (mask_len > 32)
3333 {
3334 *mask = INADDR_NONE;
3335 return ERROR_INVALID_PARAMETER;
3336 }
3337
3338 if (mask_len == 0)
3339 *mask = 0;
3340 else
3341 *mask = htonl(~0u << (32 - mask_len));
3342
3343 return NO_ERROR;
3344 }
3345
3346 /******************************************************************
3347 * if_nametoindex (IPHLPAPI.@)
3348 */
3349 IF_INDEX WINAPI IPHLP_if_nametoindex(const char *name)
3350 {
3351 IF_INDEX idx;
3352
3353 TRACE("(%s)\n", name);
3354 if (getInterfaceIndexByName(name, &idx) == NO_ERROR)
3355 return idx;
3356
3357 return 0;
3358 }
3359
3360 /******************************************************************
3361 * if_indextoname (IPHLPAPI.@)
3362 */
3363 PCHAR WINAPI IPHLP_if_indextoname(NET_IFINDEX index, PCHAR name)
3364 {
3365 TRACE("(%u, %p)\n", index, name);
3366
3367 return getInterfaceNameByIndex(index, name);
3368 }
3369
3370 /******************************************************************
3371 * GetIpForwardTable2 (IPHLPAPI.@)
3372 */
3373 DWORD WINAPI GetIpForwardTable2(ADDRESS_FAMILY family, PMIB_IPFORWARD_TABLE2 *table)
3374 {
3375 static int once;
3376
3377 if (!once++) FIXME("(%u %p): stub\n", family, table);
3378 return ERROR_NOT_SUPPORTED;
3379 }
3380
3381 /******************************************************************
3382 * GetIpNetTable2 (IPHLPAPI.@)
3383 */
3384 DWORD WINAPI GetIpNetTable2(ADDRESS_FAMILY family, PMIB_IPNET_TABLE2 *table)
3385 {
3386 static int once;
3387
3388 if (!once++) FIXME("(%u %p): stub\n", family, table);
3389 return ERROR_NOT_SUPPORTED;
3390 }
3391
3392 /******************************************************************
3393 * GetIpInterfaceTable (IPHLPAPI.@)
3394 */
3395 DWORD WINAPI GetIpInterfaceTable(ADDRESS_FAMILY family, PMIB_IPINTERFACE_TABLE *table)
3396 {
3397 FIXME("(%u %p): stub\n", family, table);
3398 return ERROR_NOT_SUPPORTED;
3399 }
3400
3401 /******************************************************************
3402 * GetBestRoute2 (IPHLPAPI.@)
3403 */
3404 DWORD WINAPI GetBestRoute2(NET_LUID *luid, NET_IFINDEX index,
3405 const SOCKADDR_INET *source, const SOCKADDR_INET *destination,
3406 ULONG options, PMIB_IPFORWARD_ROW2 bestroute,
3407 SOCKADDR_INET *bestaddress)
3408 {
3409 static int once;
3410
3411 if (!once++)
3412 FIXME("(%p, %d, %p, %p, 0x%08x, %p, %p): stub\n", luid, index, source,
3413 destination, options, bestroute, bestaddress);
3414
3415 if (!destination || !bestroute || !bestaddress)
3416 return ERROR_INVALID_PARAMETER;
3417
3418 return ERROR_NOT_SUPPORTED;
3419 }
3420
3421 /******************************************************************
3422 * ParseNetworkString (IPHLPAPI.@)
3423 */
3424 DWORD WINAPI ParseNetworkString(const WCHAR *str, DWORD type,
3425 NET_ADDRESS_INFO *info, USHORT *port, BYTE *prefix_len)
3426 {
3427 IN_ADDR temp_addr4;
3428 IN6_ADDR temp_addr6;
3429 ULONG temp_scope;
3430 USHORT temp_port = 0;
3431 NTSTATUS status;
3432
3433 TRACE("(%s, %d, %p, %p, %p)\n", debugstr_w(str), type, info, port, prefix_len);
3434
3435 if (!str)
3436 return ERROR_INVALID_PARAMETER;
3437
3438 if (type & NET_STRING_IPV4_ADDRESS)
3439 {
3440 status = RtlIpv4StringToAddressExW(str, TRUE, &temp_addr4, &temp_port);
3441 if (SUCCEEDED(status) && !temp_port)
3442 {
3443 if (info)
3444 {
3445 info->Format = NET_ADDRESS_IPV4;
3446 info->u.Ipv4Address.sin_addr = temp_addr4;
3447 info->u.Ipv4Address.sin_port = 0;
3448 }
3449 if (port) *port = 0;
3450 if (prefix_len) *prefix_len = 255;
3451 return ERROR_SUCCESS;
3452 }
3453 }
3454 if (type & NET_STRING_IPV4_SERVICE)
3455 {
3456 status = RtlIpv4StringToAddressExW(str, TRUE, &temp_addr4, &temp_port);
3457 if (SUCCEEDED(status) && temp_port)
3458 {
3459 if (info)
3460 {
3461 info->Format = NET_ADDRESS_IPV4;
3462 info->u.Ipv4Address.sin_addr = temp_addr4;
3463 info->u.Ipv4Address.sin_port = temp_port;
3464 }
3465 if (port) *port = ntohs(temp_port);
3466 if (prefix_len) *prefix_len = 255;
3467 return ERROR_SUCCESS;
3468 }
3469 }
3470 if (type & NET_STRING_IPV6_ADDRESS)
3471 {
3472 status = RtlIpv6StringToAddressExW(str, &temp_addr6, &temp_scope, &temp_port);
3473 if (SUCCEEDED(status) && !temp_port)
3474 {
3475 if (info)
3476 {
3477 info->Format = NET_ADDRESS_IPV6;
3478 info->u.Ipv6Address.sin6_addr = temp_addr6;
3479 info->u.Ipv6Address.sin6_scope_id = temp_scope;
3480 info->u.Ipv6Address.sin6_port = 0;
3481 }
3482 if (port) *port = 0;
3483 if (prefix_len) *prefix_len = 255;
3484 return ERROR_SUCCESS;
3485 }
3486 }
3487 if (type & NET_STRING_IPV6_SERVICE)
3488 {
3489 status = RtlIpv6StringToAddressExW(str, &temp_addr6, &temp_scope, &temp_port);
3490 if (SUCCEEDED(status) && temp_port)
3491 {
3492 if (info)
3493 {
3494 info->Format = NET_ADDRESS_IPV6;
3495 info->u.Ipv6Address.sin6_addr = temp_addr6;
3496 info->u.Ipv6Address.sin6_scope_id = temp_scope;
3497 info->u.Ipv6Address.sin6_port = temp_port;
3498 }
3499 if (port) *port = ntohs(temp_port);
3500 if (prefix_len) *prefix_len = 255;
3501 return ERROR_SUCCESS;
3502 }
3503 }
3504
3505 if (info) info->Format = NET_ADDRESS_FORMAT_UNSPECIFIED;
3506
3507 if (type & ~(NET_STRING_IPV4_ADDRESS|NET_STRING_IPV4_SERVICE|NET_STRING_IPV6_ADDRESS|NET_STRING_IPV6_SERVICE))
3508 {
3509 FIXME("Unimplemented type 0x%x\n", type);
3510 return ERROR_NOT_SUPPORTED;
3511 }
3512
3513 return ERROR_INVALID_PARAMETER;
3514 }
Windows API implementation