?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dmime: Include dmobject.h in dmime_private.h.
[wine.git] / dlls / iphlpapi / iphlpapi_main.c
blobf30ed03d5e6ef7fd92e8f1add980389368a08bb6
1 /*
2 * iphlpapi dll implementation
3 *
4 * Copyright (C) 2003,2006 Juan Lang
5 * Copyright 2021 Huw Davies
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21 #include <stdarg.h>
22
23 #include "windef.h"
24 #include "winbase.h"
25 #include "winreg.h"
26 #include "winsock2.h"
27 #include "winternl.h"
28 #include "ws2ipdef.h"
29 #include "windns.h"
30 #include "iphlpapi.h"
31 #include "ipifcons.h"
32 #include "fltdefs.h"
33 #include "ifdef.h"
34 #include "netioapi.h"
35 #include "ip2string.h"
36 #include "netiodef.h"
37 #include "icmpapi.h"
38
39 #include "wine/nsi.h"
40 #include "wine/debug.h"
41 #include "wine/heap.h"
42
43 WINE_DEFAULT_DEBUG_CHANNEL(iphlpapi);
44
45 #define CHARS_IN_GUID 39
46
47 static const WCHAR *device_tcpip = L"\\DEVICE\\TCPIP_";
48
49 DWORD WINAPI AllocateAndGetIpAddrTableFromStack( MIB_IPADDRTABLE **table, BOOL sort, HANDLE heap, DWORD flags );
50
51 static const NPI_MODULEID *ip_module_id( USHORT family )
52 {
53 if (family == AF_INET) return &NPI_MS_IPV4_MODULEID;
54 if (family == AF_INET6) return &NPI_MS_IPV6_MODULEID;
55 return NULL;
56 }
57
58 DWORD WINAPI ConvertGuidToStringA( const GUID *guid, char *str, DWORD len )
59 {
60 if (len < CHARS_IN_GUID) return ERROR_INSUFFICIENT_BUFFER;
61 sprintf( str, "{%08lX-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
62 guid->Data1, guid->Data2, guid->Data3, guid->Data4[0], guid->Data4[1], guid->Data4[2],
63 guid->Data4[3], guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7] );
64 return ERROR_SUCCESS;
65 }
66
67 DWORD WINAPI ConvertGuidToStringW( const GUID *guid, WCHAR *str, DWORD len )
68 {
69 if (len < CHARS_IN_GUID) return ERROR_INSUFFICIENT_BUFFER;
70 swprintf( str, len, L"{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
71 guid->Data1, guid->Data2, guid->Data3, guid->Data4[0], guid->Data4[1], guid->Data4[2],
72 guid->Data4[3], guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7] );
73 return ERROR_SUCCESS;
74 }
75
76 DWORD WINAPI ConvertStringToGuidW( const WCHAR *str, GUID *guid )
77 {
78 UNICODE_STRING ustr;
79
80 RtlInitUnicodeString( &ustr, str );
81 return RtlNtStatusToDosError( RtlGUIDFromString( &ustr, guid ) );
82 }
83
84 static void if_counted_string_copy( WCHAR *dst, unsigned int len, IF_COUNTED_STRING *src )
85 {
86 unsigned int copy = src->Length;
87
88 if (copy >= len * sizeof(WCHAR)) copy = 0;
89 memcpy( dst, src->String, copy );
90 memset( (char *)dst + copy, 0, len * sizeof(WCHAR) - copy );
91 }
92
93 /******************************************************************
94 * AddIPAddress (IPHLPAPI.@)
95 *
96 * Add an IP address to an adapter.
97 *
98 * PARAMS
99 * Address [In] IP address to add to the adapter
100 * IpMask [In] subnet mask for the IP address
101 * IfIndex [In] adapter index to add the address
102 * NTEContext [Out] Net Table Entry (NTE) context for the IP address
103 * NTEInstance [Out] NTE instance for the IP address
104 *
105 * RETURNS
106 * Success: NO_ERROR
107 * Failure: error code from winerror.h
108 *
109 * FIXME
110 * Stub. Currently returns ERROR_NOT_SUPPORTED.
111 */
112 DWORD WINAPI AddIPAddress(IPAddr Address, IPMask IpMask, DWORD IfIndex, PULONG NTEContext, PULONG NTEInstance)
113 {
114 FIXME(":stub\n");
115 return ERROR_NOT_SUPPORTED;
116 }
117
118 /******************************************************************
119 * CancelIPChangeNotify (IPHLPAPI.@)
120 *
121 * Cancel a previous notification created by NotifyAddrChange or
122 * NotifyRouteChange.
123 *
124 * PARAMS
125 * overlapped [In] overlapped structure that notifies the caller
126 *
127 * RETURNS
128 * Success: TRUE
129 * Failure: FALSE
130 */
131 BOOL WINAPI CancelIPChangeNotify(LPOVERLAPPED overlapped)
132 {
133 DWORD err;
134
135 TRACE("overlapped %p.\n", overlapped);
136
137 if ((err = NsiCancelChangeNotification( overlapped ))) SetLastError( err );
138 return !err;
139 }
140
141
142 /******************************************************************
143 * CancelMibChangeNotify2 (IPHLPAPI.@)
144 */
145 DWORD WINAPI CancelMibChangeNotify2(HANDLE handle)
146 {
147 FIXME("(handle %p): stub\n", handle);
148 return NO_ERROR;
149 }
150
151
152 /******************************************************************
153 * CreateIpForwardEntry (IPHLPAPI.@)
154 *
155 * Create a route in the local computer's IP table.
156 *
157 * PARAMS
158 * pRoute [In] new route information
159 *
160 * RETURNS
161 * Success: NO_ERROR
162 * Failure: error code from winerror.h
163 *
164 * FIXME
165 * Stub, always returns NO_ERROR.
166 */
167 DWORD WINAPI CreateIpForwardEntry(PMIB_IPFORWARDROW pRoute)
168 {
169 FIXME("(pRoute %p): stub\n", pRoute);
170 /* could use SIOCADDRT, not sure I want to */
171 return 0;
172 }
173
174
175 /******************************************************************
176 * CreateIpNetEntry (IPHLPAPI.@)
177 *
178 * Create entry in the ARP table.
179 *
180 * PARAMS
181 * pArpEntry [In] new ARP entry
182 *
183 * RETURNS
184 * Success: NO_ERROR
185 * Failure: error code from winerror.h
186 *
187 * FIXME
188 * Stub, always returns NO_ERROR.
189 */
190 DWORD WINAPI CreateIpNetEntry(PMIB_IPNETROW pArpEntry)
191 {
192 FIXME("(pArpEntry %p)\n", pArpEntry);
193 /* could use SIOCSARP on systems that support it, not sure I want to */
194 return 0;
195 }
196
197
198 /******************************************************************
199 * CreateProxyArpEntry (IPHLPAPI.@)
200 *
201 * Create a Proxy ARP (PARP) entry for an IP address.
202 *
203 * PARAMS
204 * dwAddress [In] IP address for which this computer acts as a proxy.
205 * dwMask [In] subnet mask for dwAddress
206 * dwIfIndex [In] interface index
207 *
208 * RETURNS
209 * Success: NO_ERROR
210 * Failure: error code from winerror.h
211 *
212 * FIXME
213 * Stub, returns ERROR_NOT_SUPPORTED.
214 */
215 DWORD WINAPI CreateProxyArpEntry(DWORD dwAddress, DWORD dwMask, DWORD dwIfIndex)
216 {
217 FIXME("(dwAddress 0x%08lx, dwMask 0x%08lx, dwIfIndex 0x%08lx): stub\n",
218 dwAddress, dwMask, dwIfIndex);
219 return ERROR_NOT_SUPPORTED;
220 }
221
222 static char *debugstr_ipv6(const struct sockaddr_in6 *sin, char *buf)
223 {
224 const IN6_ADDR *addr = &sin->sin6_addr;
225 char *p = buf;
226 int i;
227 BOOL in_zero = FALSE;
228
229 for (i = 0; i < 7; i++)
230 {
231 if (!addr->u.Word[i])
232 {
233 if (i == 0)
234 *p++ = ':';
235 if (!in_zero)
236 {
237 *p++ = ':';
238 in_zero = TRUE;
239 }
240 }
241 else
242 {
243 p += sprintf(p, "%x:", ntohs(addr->u.Word[i]));
244 in_zero = FALSE;
245 }
246 }
247 sprintf(p, "%x", ntohs(addr->u.Word[7]));
248 return buf;
249 }
250
251 static BOOL map_address_6to4( const SOCKADDR_IN6 *addr6, SOCKADDR_IN *addr4 )
252 {
253 ULONG i;
254
255 if (addr6->sin6_family != AF_INET6) return FALSE;
256
257 for (i = 0; i < 5; i++)
258 if (addr6->sin6_addr.u.Word[i]) return FALSE;
259
260 if (addr6->sin6_addr.u.Word[5] != 0xffff) return FALSE;
261
262 addr4->sin_family = AF_INET;
263 addr4->sin_port = addr6->sin6_port;
264 addr4->sin_addr.S_un.S_addr = addr6->sin6_addr.u.Word[6] << 16 | addr6->sin6_addr.u.Word[7];
265 memset( &addr4->sin_zero, 0, sizeof(addr4->sin_zero) );
266
267 return TRUE;
268 }
269
270 static BOOL find_src_address( MIB_IPADDRTABLE *table, const SOCKADDR_IN *dst, SOCKADDR_IN6 *src )
271 {
272 MIB_IPFORWARDROW row;
273 DWORD i, j;
274
275 if (GetBestRoute( dst->sin_addr.S_un.S_addr, 0, &row )) return FALSE;
276
277 for (i = 0; i < table->dwNumEntries; i++)
278 {
279 /* take the first address */
280 if (table->table[i].dwIndex == row.dwForwardIfIndex)
281 {
282 src->sin6_family = AF_INET6;
283 src->sin6_port = 0;
284 src->sin6_flowinfo = 0;
285 for (j = 0; j < 5; j++) src->sin6_addr.u.Word[j] = 0;
286 src->sin6_addr.u.Word[5] = 0xffff;
287 src->sin6_addr.u.Word[6] = table->table[i].dwAddr & 0xffff;
288 src->sin6_addr.u.Word[7] = table->table[i].dwAddr >> 16;
289 return TRUE;
290 }
291 }
292
293 return FALSE;
294 }
295
296 /******************************************************************
297 * CreateSortedAddressPairs (IPHLPAPI.@)
298 */
299 DWORD WINAPI CreateSortedAddressPairs( const PSOCKADDR_IN6 src_list, DWORD src_count,
300 const PSOCKADDR_IN6 dst_list, DWORD dst_count,
301 DWORD options, PSOCKADDR_IN6_PAIR *pair_list,
302 DWORD *pair_count )
303 {
304 DWORD i, size, ret;
305 SOCKADDR_IN6_PAIR *pairs;
306 SOCKADDR_IN6 *ptr;
307 SOCKADDR_IN addr4;
308 MIB_IPADDRTABLE *table;
309
310 FIXME( "(src_list %p src_count %lu dst_list %p dst_count %lu options %lx pair_list %p pair_count %p): stub\n",
311 src_list, src_count, dst_list, dst_count, options, pair_list, pair_count );
312
313 if (src_list || src_count || !dst_list || !pair_list || !pair_count || dst_count > 500)
314 return ERROR_INVALID_PARAMETER;
315
316 for (i = 0; i < dst_count; i++)
317 {
318 if (!map_address_6to4( &dst_list[i], &addr4 ))
319 {
320 FIXME("only mapped IPv4 addresses are supported\n");
321 return ERROR_NOT_SUPPORTED;
322 }
323 }
324
325 size = dst_count * sizeof(*pairs);
326 size += dst_count * sizeof(SOCKADDR_IN6) * 2; /* source address + destination address */
327 if (!(pairs = HeapAlloc( GetProcessHeap(), 0, size ))) return ERROR_NOT_ENOUGH_MEMORY;
328 ptr = (SOCKADDR_IN6 *)&pairs[dst_count];
329
330 if ((ret = AllocateAndGetIpAddrTableFromStack( &table, FALSE, GetProcessHeap(), 0 )))
331 {
332 HeapFree( GetProcessHeap(), 0, pairs );
333 return ret;
334 }
335
336 for (i = 0; i < dst_count; i++)
337 {
338 pairs[i].SourceAddress = ptr++;
339 if (!map_address_6to4( &dst_list[i], &addr4 ) ||
340 !find_src_address( table, &addr4, pairs[i].SourceAddress ))
341 {
342 char buf[46];
343 FIXME( "source address for %s not found\n", debugstr_ipv6(&dst_list[i], buf) );
344 memset( pairs[i].SourceAddress, 0, sizeof(*pairs[i].SourceAddress) );
345 pairs[i].SourceAddress->sin6_family = AF_INET6;
346 }
347
348 pairs[i].DestinationAddress = ptr++;
349 memcpy( pairs[i].DestinationAddress, &dst_list[i], sizeof(*pairs[i].DestinationAddress) );
350 }
351 *pair_list = pairs;
352 *pair_count = dst_count;
353
354 HeapFree( GetProcessHeap(), 0, table );
355 return NO_ERROR;
356 }
357
358
359 /******************************************************************
360 * DeleteIPAddress (IPHLPAPI.@)
361 *
362 * Delete an IP address added with AddIPAddress().
363 *
364 * PARAMS
365 * NTEContext [In] NTE context from AddIPAddress();
366 *
367 * RETURNS
368 * Success: NO_ERROR
369 * Failure: error code from winerror.h
370 *
371 * FIXME
372 * Stub, returns ERROR_NOT_SUPPORTED.
373 */
374 DWORD WINAPI DeleteIPAddress(ULONG NTEContext)
375 {
376 FIXME("(NTEContext %ld): stub\n", NTEContext);
377 return ERROR_NOT_SUPPORTED;
378 }
379
380
381 /******************************************************************
382 * DeleteIpForwardEntry (IPHLPAPI.@)
383 *
384 * Delete a route.
385 *
386 * PARAMS
387 * pRoute [In] route to delete
388 *
389 * RETURNS
390 * Success: NO_ERROR
391 * Failure: error code from winerror.h
392 *
393 * FIXME
394 * Stub, returns NO_ERROR.
395 */
396 DWORD WINAPI DeleteIpForwardEntry(PMIB_IPFORWARDROW pRoute)
397 {
398 FIXME("(pRoute %p): stub\n", pRoute);
399 /* could use SIOCDELRT, not sure I want to */
400 return 0;
401 }
402
403
404 /******************************************************************
405 * DeleteIpNetEntry (IPHLPAPI.@)
406 *
407 * Delete an ARP entry.
408 *
409 * PARAMS
410 * pArpEntry [In] ARP entry to delete
411 *
412 * RETURNS
413 * Success: NO_ERROR
414 * Failure: error code from winerror.h
415 *
416 * FIXME
417 * Stub, returns NO_ERROR.
418 */
419 DWORD WINAPI DeleteIpNetEntry(PMIB_IPNETROW pArpEntry)
420 {
421 FIXME("(pArpEntry %p): stub\n", pArpEntry);
422 /* could use SIOCDARP on systems that support it, not sure I want to */
423 return 0;
424 }
425
426
427 /******************************************************************
428 * DeleteProxyArpEntry (IPHLPAPI.@)
429 *
430 * Delete a Proxy ARP entry.
431 *
432 * PARAMS
433 * dwAddress [In] IP address for which this computer acts as a proxy.
434 * dwMask [In] subnet mask for dwAddress
435 * dwIfIndex [In] interface index
436 *
437 * RETURNS
438 * Success: NO_ERROR
439 * Failure: error code from winerror.h
440 *
441 * FIXME
442 * Stub, returns ERROR_NOT_SUPPORTED.
443 */
444 DWORD WINAPI DeleteProxyArpEntry(DWORD dwAddress, DWORD dwMask, DWORD dwIfIndex)
445 {
446 FIXME("(dwAddress 0x%08lx, dwMask 0x%08lx, dwIfIndex 0x%08lx): stub\n",
447 dwAddress, dwMask, dwIfIndex);
448 return ERROR_NOT_SUPPORTED;
449 }
450
451
452 /******************************************************************
453 * EnableRouter (IPHLPAPI.@)
454 *
455 * Turn on ip forwarding.
456 *
457 * PARAMS
458 * pHandle [In/Out]
459 * pOverlapped [In/Out] hEvent member should contain a valid handle.
460 *
461 * RETURNS
462 * Success: ERROR_IO_PENDING
463 * Failure: error code from winerror.h
464 *
465 * FIXME
466 * Stub, returns ERROR_NOT_SUPPORTED.
467 */
468 DWORD WINAPI EnableRouter(HANDLE * pHandle, OVERLAPPED * pOverlapped)
469 {
470 FIXME("(pHandle %p, pOverlapped %p): stub\n", pHandle, pOverlapped);
471 /* could echo "1" > /proc/net/sys/net/ipv4/ip_forward, not sure I want to
472 could map EACCESS to ERROR_ACCESS_DENIED, I suppose
473 */
474 return ERROR_NOT_SUPPORTED;
475 }
476
477
478 /******************************************************************
479 * FlushIpNetTable (IPHLPAPI.@)
480 *
481 * Delete all ARP entries of an interface
482 *
483 * PARAMS
484 * dwIfIndex [In] interface index
485 *
486 * RETURNS
487 * Success: NO_ERROR
488 * Failure: error code from winerror.h
489 *
490 * FIXME
491 * Stub, returns ERROR_NOT_SUPPORTED.
492 */
493 DWORD WINAPI FlushIpNetTable(DWORD dwIfIndex)
494 {
495 FIXME("(dwIfIndex 0x%08lx): stub\n", dwIfIndex);
496 /* this flushes the arp cache of the given index */
497 return ERROR_NOT_SUPPORTED;
498 }
499
500 /******************************************************************
501 * FreeMibTable (IPHLPAPI.@)
502 *
503 * Free buffer allocated by network functions
504 *
505 * PARAMS
506 * ptr [In] pointer to the buffer to free
507 *
508 */
509 void WINAPI FreeMibTable( void *ptr )
510 {
511 TRACE( "(%p)\n", ptr );
512 heap_free( ptr );
513 }
514
515 /******************************************************************
516 * GetAdapterIndex (IPHLPAPI.@)
517 *
518 * Get interface index from its name.
519 *
520 * PARAMS
521 * adapter_name [In] unicode string with the adapter name
522 * index [Out] returns found interface index
523 */
524 DWORD WINAPI GetAdapterIndex( WCHAR *adapter_name, ULONG *index )
525 {
526 NET_LUID luid;
527 GUID guid;
528 DWORD err;
529
530 TRACE( "name %s, index %p\n", debugstr_w( adapter_name ), index );
531
532 if (wcslen( adapter_name ) < wcslen( device_tcpip )) return ERROR_INVALID_PARAMETER;
533 err = ConvertStringToGuidW( adapter_name + wcslen( device_tcpip ), &guid );
534 if (err) return err;
535 err = ConvertInterfaceGuidToLuid( &guid, &luid );
536 if (err) return err;
537 return ConvertInterfaceLuidToIndex( &luid, index );
538 }
539
540 static DWORD get_wins_servers( SOCKADDR_INET **servers )
541 {
542 HKEY key;
543 char buf[4 * 4];
544 DWORD size, i, count = 0;
545 static const char *values[] = { "WinsServer", "BackupWinsServer" };
546 IN_ADDR addrs[ARRAY_SIZE(values)];
547
548 *servers = NULL;
549 /* @@ Wine registry key: HKCU\Software\Wine\Network */
550 if (RegOpenKeyA( HKEY_CURRENT_USER, "Software\\Wine\\Network", &key )) return 0;
551
552 for (i = 0; i < ARRAY_SIZE(values); i++)
553 {
554 size = sizeof(buf);
555 if (!RegQueryValueExA( key, values[i], NULL, NULL, (LPBYTE)buf, &size ))
556 if (!RtlIpv4StringToAddressA( buf, TRUE, NULL, addrs + count ) &&
557 addrs[count].s_addr != INADDR_NONE && addrs[count].s_addr != INADDR_ANY)
558 count++;
559 }
560 RegCloseKey( key );
561
562 if (count)
563 {
564 *servers = heap_alloc_zero( count * sizeof(**servers) );
565 if (!*servers) return 0;
566 for (i = 0; i < count; i++)
567 {
568 (*servers)[i].Ipv4.sin_family = AF_INET;
569 (*servers)[i].Ipv4.sin_addr = addrs[i];
570 }
571 }
572 return count;
573 }
574
575 static void ip_addr_string_init( IP_ADDR_STRING *s, const IN_ADDR *addr, const IN_ADDR *mask, DWORD ctxt )
576 {
577 s->Next = NULL;
578
579 if (addr) RtlIpv4AddressToStringA( addr, s->IpAddress.String );
580 else s->IpAddress.String[0] = '\0';
581 if (mask) RtlIpv4AddressToStringA( mask, s->IpMask.String );
582 else s->IpMask.String[0] = '\0';
583 s->Context = ctxt;
584 }
585
586 /******************************************************************
587 * GetAdaptersInfo (IPHLPAPI.@)
588 *
589 * Get information about adapters.
590 *
591 * PARAMS
592 * info [Out] buffer for adapter infos
593 * size [In] length of output buffer
594 */
595 DWORD WINAPI GetAdaptersInfo( IP_ADAPTER_INFO *info, ULONG *size )
596 {
597 DWORD err, if_count, if_num = 0, uni_count, fwd_count, needed, wins_server_count;
598 DWORD len, i, uni, fwd;
599 NET_LUID *if_keys = NULL;
600 struct nsi_ndis_ifinfo_rw *if_rw = NULL;
601 struct nsi_ndis_ifinfo_static *if_stat = NULL;
602 struct nsi_ipv4_unicast_key *uni_keys = NULL;
603 struct nsi_ip_unicast_rw *uni_rw = NULL;
604 struct nsi_ipv4_forward_key *fwd_keys = NULL;
605 SOCKADDR_INET *wins_servers = NULL;
606 IP_ADDR_STRING *extra_ip_addrs, *cursor;
607 IN_ADDR gw, mask;
608
609 TRACE( "info %p, size %p\n", info, size );
610 if (!size) return ERROR_INVALID_PARAMETER;
611
612 err = NsiAllocateAndGetTable( 1, &NPI_MS_NDIS_MODULEID, NSI_NDIS_IFINFO_TABLE,
613 (void **)&if_keys, sizeof(*if_keys), (void **)&if_rw, sizeof(*if_rw),
614 NULL, 0, (void **)&if_stat, sizeof(*if_stat), &if_count, 0 );
615
616 if (err) return err;
617 for (i = 0; i < if_count; i++)
618 {
619 if (if_stat[i].type == IF_TYPE_SOFTWARE_LOOPBACK) continue;
620 if_num++;
621 }
622
623 if (!if_num)
624 {
625 err = ERROR_NO_DATA;
626 goto err;
627 }
628
629 err = NsiAllocateAndGetTable( 1, &NPI_MS_IPV4_MODULEID, NSI_IP_UNICAST_TABLE,
630 (void **)&uni_keys, sizeof(*uni_keys), (void **)&uni_rw, sizeof(*uni_rw),
631 NULL, 0, NULL, 0, &uni_count, 0 );
632 if (err) goto err;
633
634 /* Slightly overestimate the needed size by assuming that all
635 unicast addresses require a separate IP_ADDR_STRING. */
636
637 needed = if_num * sizeof(*info) + uni_count * sizeof(IP_ADDR_STRING);
638 if (!info || *size < needed)
639 {
640 *size = needed;
641 err = ERROR_BUFFER_OVERFLOW;
642 goto err;
643 }
644
645 err = NsiAllocateAndGetTable( 1, &NPI_MS_IPV4_MODULEID, NSI_IP_FORWARD_TABLE,
646 (void **)&fwd_keys, sizeof(*fwd_keys), NULL, 0,
647 NULL, 0, NULL, 0, &fwd_count, 0 );
648 if (err) goto err;
649
650 wins_server_count = get_wins_servers( &wins_servers );
651
652 extra_ip_addrs = (IP_ADDR_STRING *)(info + if_num);
653 for (i = 0; i < if_count; i++)
654 {
655 if (if_stat[i].type == IF_TYPE_SOFTWARE_LOOPBACK) continue;
656
657 info->Next = info + 1;
658 info->ComboIndex = 0;
659 ConvertGuidToStringA( &if_stat[i].if_guid, info->AdapterName, sizeof(info->AdapterName) );
660 len = WideCharToMultiByte( CP_ACP, 0, if_stat[i].descr.String, if_stat[i].descr.Length / sizeof(WCHAR),
661 info->Description, sizeof(info->Description) - 1, NULL, NULL );
662 info->Description[len] = '\0';
663 info->AddressLength = if_rw[i].phys_addr.Length;
664 if (info->AddressLength > sizeof(info->Address)) info->AddressLength = 0;
665 memcpy( info->Address, if_rw[i].phys_addr.Address, info->AddressLength );
666 memset( info->Address + info->AddressLength, 0, sizeof(info->Address) - info->AddressLength );
667 info->Index = if_stat[i].if_index;
668 info->Type = if_stat[i].type;
669 info->DhcpEnabled = TRUE; /* FIXME */
670 info->CurrentIpAddress = NULL;
671
672 cursor = NULL;
673 for (uni = 0; uni < uni_count; uni++)
674 {
675 if (uni_keys[uni].luid.Value != if_keys[i].Value) continue;
676 if (!cursor) cursor = &info->IpAddressList;
677 else
678 {
679 cursor->Next = extra_ip_addrs++;
680 cursor = cursor->Next;
681 }
682 ConvertLengthToIpv4Mask( uni_rw[uni].on_link_prefix, &mask.s_addr );
683 ip_addr_string_init( cursor, &uni_keys[uni].addr, &mask, 0 );
684 }
685 if (!cursor)
686 {
687 mask.s_addr = INADDR_ANY;
688 ip_addr_string_init( &info->IpAddressList, &mask, &mask, 0 );
689 }
690
691 gw.s_addr = INADDR_ANY;
692 mask.s_addr = INADDR_NONE;
693 for (fwd = 0; fwd < fwd_count; fwd++)
694 { /* find the first router on this interface */
695 if (fwd_keys[fwd].luid.Value == if_keys[i].Value &&
696 fwd_keys[fwd].next_hop.s_addr != INADDR_ANY &&
697 !fwd_keys[fwd].prefix_len)
698 {
699 gw = fwd_keys[fwd].next_hop;
700 break;
701 }
702 }
703 ip_addr_string_init( &info->GatewayList, &gw, &mask, 0 );
704
705 ip_addr_string_init( &info->DhcpServer, NULL, NULL, 0 );
706
707 info->HaveWins = !!wins_server_count;
708 ip_addr_string_init( &info->PrimaryWinsServer, NULL, NULL, 0 );
709 ip_addr_string_init( &info->SecondaryWinsServer, NULL, NULL, 0 );
710 if (info->HaveWins)
711 {
712 mask.s_addr = INADDR_NONE;
713 ip_addr_string_init( &info->PrimaryWinsServer, &wins_servers[0].Ipv4.sin_addr, &mask, 0 );
714 if (wins_server_count > 1)
715 ip_addr_string_init( &info->SecondaryWinsServer, &wins_servers[1].Ipv4.sin_addr, &mask, 0 );
716 }
717
718 info->LeaseObtained = 0;
719 info->LeaseExpires = 0;
720
721 info++;
722 }
723 info[-1].Next = NULL;
724
725 err:
726 heap_free( wins_servers );
727 NsiFreeTable( fwd_keys, NULL, NULL, NULL );
728 NsiFreeTable( uni_keys, uni_rw, NULL, NULL );
729 NsiFreeTable( if_keys, if_rw, NULL, if_stat );
730 return err;
731 }
732
733 static void address_entry_free( void *ptr, ULONG offset, void *ctxt )
734 {
735 heap_free( ptr );
736 }
737
738 static void address_entry_size( void *ptr, ULONG offset, void *ctxt )
739 {
740 IP_ADAPTER_DNS_SERVER_ADDRESS *src_addr = ptr; /* all list types are super-sets of this type */
741 ULONG *total = (ULONG *)ctxt, align = sizeof(ULONGLONG) - 1;
742
743 *total = (*total + src_addr->Length + src_addr->Address.iSockaddrLength + align) & ~align;
744 }
745
746 struct address_entry_copy_params
747 {
748 IP_ADAPTER_ADDRESSES *src, *dst;
749 char *ptr;
750 void *next;
751 ULONG cur_offset;
752 };
753
754 static void address_entry_copy( void *ptr, ULONG offset, void *ctxt )
755 {
756 struct address_entry_copy_params *params = ctxt;
757 IP_ADAPTER_DNS_SERVER_ADDRESS *src_addr = ptr; /* all list types are super-sets of this type */
758 IP_ADAPTER_DNS_SERVER_ADDRESS *dst_addr = (IP_ADAPTER_DNS_SERVER_ADDRESS *)params->ptr;
759 ULONG align = sizeof(ULONGLONG) - 1;
760
761 memcpy( dst_addr, src_addr, src_addr->Length );
762 params->ptr += src_addr->Length;
763 dst_addr->Address.lpSockaddr = (SOCKADDR *)params->ptr;
764 memcpy( dst_addr->Address.lpSockaddr, src_addr->Address.lpSockaddr, src_addr->Address.iSockaddrLength );
765 params->ptr += (src_addr->Address.iSockaddrLength + align) & ~align;
766
767 if (params->cur_offset != offset) /* new list */
768 {
769 params->next = (BYTE *)params->dst + offset;
770 params->cur_offset = offset;
771 }
772 *(IP_ADAPTER_DNS_SERVER_ADDRESS **)params->next = dst_addr;
773 params->next = &dst_addr->Next;
774 }
775
776 static void address_lists_iterate( IP_ADAPTER_ADDRESSES *aa, void (*fn)(void *entry, ULONG offset, void *ctxt), void *ctxt )
777 {
778 IP_ADAPTER_UNICAST_ADDRESS *uni;
779 IP_ADAPTER_DNS_SERVER_ADDRESS *dns;
780 IP_ADAPTER_GATEWAY_ADDRESS *gw;
781 IP_ADAPTER_PREFIX *prefix;
782 void *next;
783
784 for (uni = aa->FirstUnicastAddress; uni; uni = next)
785 {
786 next = uni->Next;
787 fn( uni, FIELD_OFFSET( IP_ADAPTER_ADDRESSES, FirstUnicastAddress ), ctxt );
788 }
789
790 for (dns = aa->FirstDnsServerAddress; dns; dns = next)
791 {
792 next = dns->Next;
793 fn( dns, FIELD_OFFSET( IP_ADAPTER_ADDRESSES, FirstDnsServerAddress ), ctxt );
794 }
795
796 for (gw = aa->FirstGatewayAddress; gw; gw = next)
797 {
798 next = gw->Next;
799 fn( gw, FIELD_OFFSET( IP_ADAPTER_ADDRESSES, FirstGatewayAddress ), ctxt );
800 }
801
802 for (prefix = aa->FirstPrefix; prefix; prefix = next)
803 {
804 next = prefix->Next;
805 fn( prefix, FIELD_OFFSET( IP_ADAPTER_ADDRESSES, FirstPrefix ), ctxt );
806 }
807 }
808
809 static void adapters_addresses_free( IP_ADAPTER_ADDRESSES *info )
810 {
811 IP_ADAPTER_ADDRESSES *aa;
812
813 for (aa = info; aa; aa = aa->Next)
814 {
815 address_lists_iterate( aa, address_entry_free, NULL );
816
817 heap_free( aa->DnsSuffix );
818 }
819 heap_free( info );
820 }
821
822 static ULONG adapters_addresses_size( IP_ADAPTER_ADDRESSES *info )
823 {
824 IP_ADAPTER_ADDRESSES *aa;
825 ULONG size = 0, align = sizeof(ULONGLONG) - 1;
826
827 for (aa = info; aa; aa = aa->Next)
828 {
829 size += sizeof(*aa) + ((strlen( aa->AdapterName ) + 1 + 1) & ~1);
830 size += (wcslen( aa->Description ) + 1 + wcslen( aa->DnsSuffix ) + 1) * sizeof(WCHAR);
831 if (aa->FriendlyName) size += (wcslen( aa->FriendlyName ) + 1) * sizeof(WCHAR);
832 size = (size + align) & ~align;
833 address_lists_iterate( aa, address_entry_size, &size );
834 }
835 return size;
836 }
837
838 static void adapters_addresses_copy( IP_ADAPTER_ADDRESSES *dst, IP_ADAPTER_ADDRESSES *src )
839 {
840 char *ptr;
841 DWORD len;
842 UINT_PTR align = sizeof(ULONGLONG) - 1;
843 struct address_entry_copy_params params;
844
845 while (src)
846 {
847 ptr = (char *)(dst + 1);
848 *dst = *src;
849 dst->AdapterName = ptr;
850 len = strlen( src->AdapterName ) + 1;
851 memcpy( dst->AdapterName, src->AdapterName, len );
852 ptr += (len + 1) & ~1;
853 dst->Description = (WCHAR *)ptr;
854 len = (wcslen( src->Description ) + 1) * sizeof(WCHAR);
855 memcpy( dst->Description, src->Description, len );
856 ptr += len;
857 dst->DnsSuffix = (WCHAR *)ptr;
858 len = (wcslen( src->DnsSuffix ) + 1) * sizeof(WCHAR);
859 memcpy( dst->DnsSuffix, src->DnsSuffix, len );
860 ptr += len;
861 if (src->FriendlyName)
862 {
863 dst->FriendlyName = (WCHAR *)ptr;
864 len = (wcslen( src->FriendlyName ) + 1) * sizeof(WCHAR);
865 memcpy( dst->FriendlyName, src->FriendlyName, len );
866 ptr += len;
867 }
868 ptr = (char *)(((UINT_PTR)ptr + align) & ~align);
869
870 params.src = src;
871 params.dst = dst;
872 params.ptr = ptr;
873 params.next = NULL;
874 params.cur_offset = ~0u;
875 address_lists_iterate( src, address_entry_copy, &params );
876 ptr = params.ptr;
877
878 if (src->Next)
879 {
880 dst->Next = (IP_ADAPTER_ADDRESSES *)ptr;
881 dst = dst->Next;
882 }
883 src = src->Next;
884 }
885 }
886
887 static BOOL sockaddr_is_loopback( SOCKADDR *sock )
888 {
889 if (sock->sa_family == AF_INET)
890 {
891 SOCKADDR_IN *sin = (SOCKADDR_IN *)sock;
892 return (sin->sin_addr.s_addr & 0xff) == 127;
893 }
894 else if (sock->sa_family == AF_INET6)
895 {
896 SOCKADDR_IN6 *sin6 = (SOCKADDR_IN6 *)sock;
897 return IN6_IS_ADDR_LOOPBACK( &sin6->sin6_addr );
898 }
899 return FALSE;
900 }
901
902 static BOOL sockaddr_is_linklocal( SOCKADDR *sock )
903 {
904 if (sock->sa_family == AF_INET6)
905 {
906 SOCKADDR_IN6 *sin6 = (SOCKADDR_IN6 *)sock;
907 return IN6_IS_ADDR_LINKLOCAL( &sin6->sin6_addr );
908 }
909 return FALSE;
910 }
911
912 static BOOL unicast_is_dns_eligible( IP_ADAPTER_UNICAST_ADDRESS *uni )
913 {
914 return !sockaddr_is_loopback( uni->Address.lpSockaddr ) &&
915 !sockaddr_is_linklocal( uni->Address.lpSockaddr );
916 }
917
918 static DWORD unicast_addresses_alloc( IP_ADAPTER_ADDRESSES *aa, ULONG family, ULONG flags )
919 {
920 struct nsi_ipv4_unicast_key *key4;
921 struct nsi_ipv6_unicast_key *key6;
922 struct nsi_ip_unicast_rw *rw;
923 struct nsi_ip_unicast_dynamic *dyn;
924 struct nsi_ip_unicast_static *stat;
925 IP_ADAPTER_UNICAST_ADDRESS *addr, **next;
926 DWORD err, count, i, key_size = (family == AF_INET) ? sizeof(*key4) : sizeof(*key6);
927 DWORD sockaddr_size = (family == AF_INET) ? sizeof(SOCKADDR_IN) : sizeof(SOCKADDR_IN6);
928 NET_LUID *luid;
929 void *key;
930
931 err = NsiAllocateAndGetTable( 1, ip_module_id( family ), NSI_IP_UNICAST_TABLE, &key, key_size,
932 (void **)&rw, sizeof(*rw), (void **)&dyn, sizeof(*dyn),
933 (void **)&stat, sizeof(*stat), &count, 0 );
934 if (err) return err;
935
936
937 while (aa)
938 {
939 for (next = &aa->FirstUnicastAddress; *next; next = &(*next)->Next)
940 ;
941
942 for (i = 0; i < count; i++)
943 {
944 key4 = (struct nsi_ipv4_unicast_key *)key + i;
945 key6 = (struct nsi_ipv6_unicast_key *)key + i;
946 luid = (family == AF_INET) ? &key4->luid : &key6->luid;
947 if (luid->Value != aa->Luid.Value) continue;
948 addr = heap_alloc_zero( sizeof(*addr) + sockaddr_size );
949 if (!addr)
950 {
951 err = ERROR_NOT_ENOUGH_MEMORY;
952 goto err;
953 }
954 addr->Length = sizeof(*addr);
955 addr->Address.lpSockaddr = (SOCKADDR *)(addr + 1);
956 addr->Address.iSockaddrLength = sockaddr_size;
957 addr->Address.lpSockaddr->sa_family = family;
958 if (family == AF_INET)
959 {
960 SOCKADDR_IN *in = (SOCKADDR_IN *)addr->Address.lpSockaddr;
961 in->sin_addr = key4->addr;
962 aa->Ipv4Enabled = TRUE;
963 }
964 else
965 {
966 SOCKADDR_IN6 *in6 = (SOCKADDR_IN6 *)addr->Address.lpSockaddr;
967 in6->sin6_addr = key6->addr;
968 in6->sin6_scope_id = dyn[i].scope_id;
969 aa->Ipv6Enabled = TRUE;
970 }
971 addr->PrefixOrigin = rw[i].prefix_origin;
972 addr->SuffixOrigin = rw[i].suffix_origin;
973 addr->DadState = dyn[i].dad_state;
974 addr->ValidLifetime = rw[i].valid_lifetime;
975 addr->PreferredLifetime = rw[i].preferred_lifetime;
976 addr->LeaseLifetime = rw[i].valid_lifetime; /* FIXME */
977 addr->OnLinkPrefixLength = rw[i].on_link_prefix;
978 if (unicast_is_dns_eligible( addr )) addr->Flags |= IP_ADAPTER_ADDRESS_DNS_ELIGIBLE;
979
980 *next = addr;
981 next = &addr->Next;
982 }
983 aa = aa->Next;
984 }
985
986 err:
987 NsiFreeTable( key, rw, dyn, stat );
988 return err;
989 }
990
991 static DWORD gateway_and_prefix_addresses_alloc( IP_ADAPTER_ADDRESSES *aa, ULONG family, ULONG flags )
992 {
993 struct nsi_ipv4_forward_key *key4;
994 struct nsi_ipv6_forward_key *key6;
995 IP_ADAPTER_GATEWAY_ADDRESS *gw, **gw_next;
996 IP_ADAPTER_PREFIX *prefix, **prefix_next;
997 DWORD err, count, i, prefix_len, key_size = (family == AF_INET) ? sizeof(*key4) : sizeof(*key6);
998 DWORD sockaddr_size = (family == AF_INET) ? sizeof(SOCKADDR_IN) : sizeof(SOCKADDR_IN6);
999 SOCKADDR_INET sockaddr;
1000 NET_LUID *luid;
1001 void *key;
1002
1003 err = NsiAllocateAndGetTable( 1, ip_module_id( family ), NSI_IP_FORWARD_TABLE, &key, key_size,
1004 NULL, 0, NULL, 0, NULL, 0, &count, 0 );
1005 if (err) return err;
1006
1007 while (aa)
1008 {
1009 for (gw_next = &aa->FirstGatewayAddress; *gw_next; gw_next = &(*gw_next)->Next)
1010 ;
1011 for (prefix_next = &aa->FirstPrefix; *prefix_next; prefix_next = &(*prefix_next)->Next)
1012 ;
1013
1014 for (i = 0; i < count; i++)
1015 {
1016 key4 = (struct nsi_ipv4_forward_key *)key + i;
1017 key6 = (struct nsi_ipv6_forward_key *)key + i;
1018 luid = (family == AF_INET) ? &key4->luid : &key6->luid;
1019 if (luid->Value != aa->Luid.Value) continue;
1020
1021 if (flags & GAA_FLAG_INCLUDE_GATEWAYS)
1022 {
1023 memset( &sockaddr, 0, sizeof(sockaddr) );
1024 if (family == AF_INET)
1025 {
1026 if (key4->next_hop.s_addr != 0)
1027 {
1028 sockaddr.si_family = family;
1029 sockaddr.Ipv4.sin_addr = key4->next_hop;
1030 }
1031 }
1032 else
1033 {
1034 static const IN6_ADDR zero;
1035 if (memcmp( &key6->next_hop, &zero, sizeof(zero) ))
1036 {
1037 sockaddr.si_family = family;
1038 sockaddr.Ipv6.sin6_addr = key6->next_hop;
1039 }
1040 }
1041
1042 if (sockaddr.si_family)
1043 {
1044 gw = heap_alloc_zero( sizeof(*gw) + sockaddr_size );
1045 if (!gw)
1046 {
1047 err = ERROR_NOT_ENOUGH_MEMORY;
1048 goto err;
1049 }
1050 gw->Length = sizeof(*gw);
1051 gw->Address.lpSockaddr = (SOCKADDR *)(gw + 1);
1052 gw->Address.iSockaddrLength = sockaddr_size;
1053 memcpy( gw->Address.lpSockaddr, &sockaddr, sockaddr_size );
1054 *gw_next = gw;
1055 gw_next = &gw->Next;
1056 }
1057 }
1058
1059 if (flags & GAA_FLAG_INCLUDE_PREFIX)
1060 {
1061 memset( &sockaddr, 0, sizeof(sockaddr) );
1062 prefix_len = 0;
1063 if (family == AF_INET)
1064 {
1065 if (!key4->next_hop.s_addr)
1066 {
1067 sockaddr.si_family = family;
1068 sockaddr.Ipv4.sin_addr = key4->prefix;
1069 prefix_len = key4->prefix_len;
1070 }
1071 }
1072 else
1073 {
1074 static const IN6_ADDR zero;
1075 if (!memcmp( &key6->next_hop, &zero, sizeof(zero) ))
1076 {
1077 sockaddr.si_family = family;
1078 sockaddr.Ipv6.sin6_addr = key6->prefix;
1079 prefix_len = key6->prefix_len;
1080 }
1081 }
1082
1083 if (sockaddr.si_family)
1084 {
1085 prefix = heap_alloc_zero( sizeof(*prefix) + sockaddr_size );
1086 if (!prefix)
1087 {
1088 err = ERROR_NOT_ENOUGH_MEMORY;
1089 goto err;
1090 }
1091 prefix->Length = sizeof(*prefix);
1092 prefix->Address.lpSockaddr = (SOCKADDR *)(prefix + 1);
1093 prefix->Address.iSockaddrLength = sockaddr_size;
1094 memcpy( prefix->Address.lpSockaddr, &sockaddr, sockaddr_size );
1095 prefix->PrefixLength = prefix_len;
1096 *prefix_next = prefix;
1097 prefix_next = &prefix->Next;
1098 }
1099 }
1100 }
1101 aa = aa->Next;
1102 }
1103
1104 err:
1105 NsiFreeTable( key, NULL, NULL, NULL );
1106 return err;
1107 }
1108
1109 static DWORD call_families( DWORD (*fn)( IP_ADAPTER_ADDRESSES *aa, ULONG family, ULONG flags ),
1110 IP_ADAPTER_ADDRESSES *aa, ULONG family, ULONG flags )
1111 {
1112 DWORD err;
1113
1114 if (family != AF_INET)
1115 {
1116 err = fn( aa, AF_INET6, flags );
1117 if (err) return err;
1118 }
1119
1120 if (family != AF_INET6)
1121 {
1122 err = fn( aa, AF_INET, flags );
1123 if (err) return err;
1124 }
1125 return err;
1126 }
1127
1128 static DWORD dns_servers_query_code( ULONG family )
1129 {
1130 if (family == AF_INET) return DnsConfigDnsServersIpv4;
1131 if (family == AF_INET6) return DnsConfigDnsServersIpv6;
1132 return DnsConfigDnsServersUnspec;
1133 }
1134
1135 static DWORD dns_info_alloc( IP_ADAPTER_ADDRESSES *aa, ULONG family, ULONG flags )
1136 {
1137 char buf[FIELD_OFFSET(DNS_ADDR_ARRAY, AddrArray[3])];
1138 IP_ADAPTER_DNS_SERVER_ADDRESS *dns, **next;
1139 DWORD query = dns_servers_query_code( family );
1140 DWORD err, i, size, attempt, sockaddr_len;
1141 WCHAR name[MAX_ADAPTER_NAME_LENGTH + 1];
1142 DNS_ADDR_ARRAY *servers;
1143 WCHAR *search;
1144
1145 while (aa)
1146 {
1147 MultiByteToWideChar( CP_ACP, 0, aa->AdapterName, -1, name, ARRAY_SIZE(name) );
1148 if (!(flags & GAA_FLAG_SKIP_DNS_SERVER))
1149 {
1150 servers = (DNS_ADDR_ARRAY *)buf;
1151 for (attempt = 0; attempt < 5; attempt++)
1152 {
1153 err = DnsQueryConfig( query, 0, name, NULL, servers, &size );
1154 if (err != ERROR_MORE_DATA) break;
1155 if (servers != (DNS_ADDR_ARRAY *)buf) heap_free( servers );
1156 servers = heap_alloc( size );
1157 if (!servers)
1158 {
1159 err = ERROR_NOT_ENOUGH_MEMORY;
1160 break;
1161 }
1162 }
1163 if (!err)
1164 {
1165 next = &aa->FirstDnsServerAddress;
1166 for (i = 0; i < servers->AddrCount; i++)
1167 {
1168 sockaddr_len = servers->AddrArray[i].Data.DnsAddrUserDword[0];
1169 if (sockaddr_len > sizeof(servers->AddrArray[i].MaxSa))
1170 sockaddr_len = sizeof(servers->AddrArray[i].MaxSa);
1171 dns = heap_alloc_zero( sizeof(*dns) + sockaddr_len );
1172 if (!dns)
1173 {
1174 err = ERROR_NOT_ENOUGH_MEMORY;
1175 break;
1176 }
1177 dns->Length = sizeof(*dns);
1178 dns->Address.lpSockaddr = (SOCKADDR *)(dns + 1);
1179 dns->Address.iSockaddrLength = sockaddr_len;
1180 memcpy( dns->Address.lpSockaddr, servers->AddrArray[i].MaxSa, sockaddr_len );
1181 *next = dns;
1182 next = &dns->Next;
1183 }
1184 }
1185 if (servers != (DNS_ADDR_ARRAY *)buf) heap_free( servers );
1186 if (err) return err;
1187 }
1188
1189 aa->DnsSuffix = heap_alloc( MAX_DNS_SUFFIX_STRING_LENGTH * sizeof(WCHAR) );
1190 if (!aa->DnsSuffix) return ERROR_NOT_ENOUGH_MEMORY;
1191 aa->DnsSuffix[0] = '\0';
1192
1193 if (!DnsQueryConfig( DnsConfigSearchList, 0, name, NULL, NULL, &size ) &&
1194 (search = heap_alloc( size )))
1195 {
1196 if (!DnsQueryConfig( DnsConfigSearchList, 0, name, NULL, search, &size ) &&
1197 search[0] && wcslen( search ) < MAX_DNS_SUFFIX_STRING_LENGTH)
1198 {
1199 wcscpy( aa->DnsSuffix, search );
1200 }
1201 heap_free( search );
1202 }
1203
1204 aa = aa->Next;
1205 }
1206
1207 return ERROR_SUCCESS;
1208 }
1209
1210 static DWORD adapters_addresses_alloc( ULONG family, ULONG flags, IP_ADAPTER_ADDRESSES **info )
1211 {
1212 IP_ADAPTER_ADDRESSES *aa;
1213 NET_LUID *luids;
1214 struct nsi_ndis_ifinfo_rw *rw;
1215 struct nsi_ndis_ifinfo_dynamic *dyn;
1216 struct nsi_ndis_ifinfo_static *stat;
1217 DWORD err, i, count, needed;
1218 GUID guid;
1219 char *str_ptr;
1220
1221 err = NsiAllocateAndGetTable( 1, &NPI_MS_NDIS_MODULEID, NSI_NDIS_IFINFO_TABLE, (void **)&luids, sizeof(*luids),
1222 (void **)&rw, sizeof(*rw), (void **)&dyn, sizeof(*dyn),
1223 (void **)&stat, sizeof(*stat), &count, 0 );
1224 if (err) return err;
1225
1226 needed = count * (sizeof(*aa) + ((CHARS_IN_GUID + 1) & ~1) + sizeof(stat->descr.String));
1227 needed += count * sizeof(rw->alias.String); /* GAA_FLAG_SKIP_FRIENDLY_NAME is ignored */
1228
1229 aa = heap_alloc_zero( needed );
1230 if (!aa)
1231 {
1232 err = ERROR_NOT_ENOUGH_MEMORY;
1233 goto err;
1234 }
1235
1236 str_ptr = (char *)(aa + count);
1237 for (i = 0; i < count; i++)
1238 {
1239 aa[i].Length = sizeof(*aa);
1240 aa[i].IfIndex = stat[i].if_index;
1241 if (i < count - 1) aa[i].Next = aa + i + 1;
1242 ConvertInterfaceLuidToGuid( luids + i, &guid );
1243 ConvertGuidToStringA( &guid, str_ptr, CHARS_IN_GUID );
1244 aa[i].AdapterName = str_ptr;
1245 str_ptr += (CHARS_IN_GUID + 1) & ~1;
1246 if_counted_string_copy( (WCHAR *)str_ptr, ARRAY_SIZE(stat[i].descr.String), &stat[i].descr );
1247 aa[i].Description = (WCHAR *)str_ptr;
1248 str_ptr += sizeof(stat[i].descr.String);
1249 if_counted_string_copy( (WCHAR *)str_ptr, ARRAY_SIZE(rw[i].alias.String), &rw[i].alias );
1250 aa[i].FriendlyName = (WCHAR *)str_ptr;
1251 str_ptr += sizeof(rw[i].alias.String);
1252 aa[i].PhysicalAddressLength = rw[i].phys_addr.Length;
1253 if (aa[i].PhysicalAddressLength > sizeof(aa[i].PhysicalAddress)) aa[i].PhysicalAddressLength = 0;
1254 memcpy( aa[i].PhysicalAddress, rw[i].phys_addr.Address, aa[i].PhysicalAddressLength );
1255 aa[i].Mtu = dyn[i].mtu;
1256 aa[i].IfType = stat[i].type;
1257 aa[i].OperStatus = dyn[i].oper_status;
1258 aa[i].TransmitLinkSpeed = dyn[i].xmit_speed;
1259 aa[i].ReceiveLinkSpeed = dyn[i].rcv_speed;
1260 aa[i].Luid = luids[i];
1261 aa[i].NetworkGuid = rw[i].network_guid;
1262 aa[i].ConnectionType = stat[i].conn_type;
1263 }
1264
1265 if (!(flags & GAA_FLAG_SKIP_UNICAST))
1266 {
1267 err = call_families( unicast_addresses_alloc, aa, family, flags );
1268 if (err) goto err;
1269 }
1270
1271 if (flags & (GAA_FLAG_INCLUDE_GATEWAYS | GAA_FLAG_INCLUDE_PREFIX))
1272 {
1273 err = call_families( gateway_and_prefix_addresses_alloc, aa, family, flags );
1274 if (err) goto err;
1275 }
1276
1277 err = dns_info_alloc( aa, family, flags );
1278 if (err) goto err;
1279
1280 err:
1281 NsiFreeTable( luids, rw, dyn, stat );
1282 if (!err) *info = aa;
1283 else adapters_addresses_free( aa );
1284 return err;
1285 }
1286
1287 ULONG WINAPI DECLSPEC_HOTPATCH GetAdaptersAddresses( ULONG family, ULONG flags, void *reserved,
1288 IP_ADAPTER_ADDRESSES *aa, ULONG *size )
1289 {
1290 IP_ADAPTER_ADDRESSES *info;
1291 DWORD err, needed;
1292
1293 TRACE( "(%ld, %08lx, %p, %p, %p)\n", family, flags, reserved, aa, size );
1294
1295 if (!size) return ERROR_INVALID_PARAMETER;
1296
1297 err = adapters_addresses_alloc( family, flags, &info );
1298 if (err) return err;
1299
1300 needed = adapters_addresses_size( info );
1301 if (!aa || *size < needed)
1302 {
1303 *size = needed;
1304 err = ERROR_BUFFER_OVERFLOW;
1305 }
1306 else
1307 adapters_addresses_copy( aa, info );
1308
1309 adapters_addresses_free( info );
1310 return err;
1311 }
1312
1313 /******************************************************************
1314 * GetBestInterface (IPHLPAPI.@)
1315 *
1316 * Get the interface, with the best route for the given IP address.
1317 *
1318 * PARAMS
1319 * dwDestAddr [In] IP address to search the interface for
1320 * pdwBestIfIndex [Out] found best interface
1321 *
1322 * RETURNS
1323 * Success: NO_ERROR
1324 * Failure: error code from winerror.h
1325 */
1326 DWORD WINAPI GetBestInterface(IPAddr dwDestAddr, PDWORD pdwBestIfIndex)
1327 {
1328 struct sockaddr_in sa_in;
1329 memset(&sa_in, 0, sizeof(sa_in));
1330 sa_in.sin_family = AF_INET;
1331 sa_in.sin_addr.S_un.S_addr = dwDestAddr;
1332 return GetBestInterfaceEx((struct sockaddr *)&sa_in, pdwBestIfIndex);
1333 }
1334
1335 /******************************************************************
1336 * GetBestInterfaceEx (IPHLPAPI.@)
1337 *
1338 * Get the interface, with the best route for the given IP address.
1339 *
1340 * PARAMS
1341 * dwDestAddr [In] IP address to search the interface for
1342 * pdwBestIfIndex [Out] found best interface
1343 *
1344 * RETURNS
1345 * Success: NO_ERROR
1346 * Failure: error code from winerror.h
1347 */
1348 DWORD WINAPI GetBestInterfaceEx(struct sockaddr *pDestAddr, PDWORD pdwBestIfIndex)
1349 {
1350 DWORD ret;
1351
1352 TRACE("pDestAddr %p, pdwBestIfIndex %p\n", pDestAddr, pdwBestIfIndex);
1353 if (!pDestAddr || !pdwBestIfIndex)
1354 ret = ERROR_INVALID_PARAMETER;
1355 else {
1356 MIB_IPFORWARDROW ipRow;
1357
1358 if (pDestAddr->sa_family == AF_INET) {
1359 ret = GetBestRoute(((struct sockaddr_in *)pDestAddr)->sin_addr.S_un.S_addr, 0, &ipRow);
1360 if (ret == ERROR_SUCCESS)
1361 *pdwBestIfIndex = ipRow.dwForwardIfIndex;
1362 } else {
1363 FIXME("address family %d not supported\n", pDestAddr->sa_family);
1364 ret = ERROR_NOT_SUPPORTED;
1365 }
1366 }
1367 TRACE("returning %ld\n", ret);
1368 return ret;
1369 }
1370
1371
1372 /******************************************************************
1373 * GetBestRoute (IPHLPAPI.@)
1374 *
1375 * Get the best route for the given IP address.
1376 *
1377 * PARAMS
1378 * dwDestAddr [In] IP address to search the best route for
1379 * dwSourceAddr [In] optional source IP address
1380 * pBestRoute [Out] found best route
1381 *
1382 * RETURNS
1383 * Success: NO_ERROR
1384 * Failure: error code from winerror.h
1385 */
1386 DWORD WINAPI GetBestRoute(DWORD dwDestAddr, DWORD dwSourceAddr, PMIB_IPFORWARDROW pBestRoute)
1387 {
1388 PMIB_IPFORWARDTABLE table;
1389 DWORD ret;
1390
1391 TRACE("dwDestAddr 0x%08lx, dwSourceAddr 0x%08lx, pBestRoute %p\n", dwDestAddr,
1392 dwSourceAddr, pBestRoute);
1393 if (!pBestRoute)
1394 return ERROR_INVALID_PARAMETER;
1395
1396 ret = AllocateAndGetIpForwardTableFromStack(&table, FALSE, GetProcessHeap(), 0);
1397 if (!ret) {
1398 DWORD ndx, matchedBits, matchedNdx = table->dwNumEntries;
1399
1400 for (ndx = 0, matchedBits = 0; ndx < table->dwNumEntries; ndx++) {
1401 if (table->table[ndx].ForwardType != MIB_IPROUTE_TYPE_INVALID &&
1402 (dwDestAddr & table->table[ndx].dwForwardMask) ==
1403 (table->table[ndx].dwForwardDest & table->table[ndx].dwForwardMask)) {
1404 DWORD numShifts, mask;
1405
1406 for (numShifts = 0, mask = table->table[ndx].dwForwardMask;
1407 mask && mask & 1; mask >>= 1, numShifts++)
1408 ;
1409 if (numShifts > matchedBits) {
1410 matchedBits = numShifts;
1411 matchedNdx = ndx;
1412 }
1413 else if (!matchedBits) {
1414 matchedNdx = ndx;
1415 }
1416 }
1417 }
1418 if (matchedNdx < table->dwNumEntries) {
1419 memcpy(pBestRoute, &table->table[matchedNdx], sizeof(MIB_IPFORWARDROW));
1420 ret = ERROR_SUCCESS;
1421 }
1422 else {
1423 /* No route matches, which can happen if there's no default route. */
1424 ret = ERROR_HOST_UNREACHABLE;
1425 }
1426 HeapFree(GetProcessHeap(), 0, table);
1427 }
1428 TRACE("returning %ld\n", ret);
1429 return ret;
1430 }
1431
1432
1433 /******************************************************************
1434 * GetFriendlyIfIndex (IPHLPAPI.@)
1435 *
1436 * Get a "friendly" version of IfIndex, which is one that doesn't
1437 * have the top byte set. Doesn't validate whether IfIndex is a valid
1438 * adapter index.
1439 *
1440 * PARAMS
1441 * IfIndex [In] interface index to get the friendly one for
1442 *
1443 * RETURNS
1444 * A friendly version of IfIndex.
1445 */
1446 DWORD WINAPI GetFriendlyIfIndex(DWORD IfIndex)
1447 {
1448 /* windows doesn't validate these, either, just makes sure the top byte is
1449 cleared. I assume my ifenum module never gives an index with the top
1450 byte set. */
1451 TRACE("returning %ld\n", IfIndex);
1452 return IfIndex;
1453 }
1454
1455 static void icmp_stats_ex_to_icmp_stats( MIBICMPSTATS_EX *stats_ex, MIBICMPSTATS *stats )
1456 {
1457 stats->dwMsgs = stats_ex->dwMsgs;
1458 stats->dwErrors = stats_ex->dwErrors;
1459 stats->dwDestUnreachs = stats_ex->rgdwTypeCount[ICMP4_DST_UNREACH];
1460 stats->dwTimeExcds = stats_ex->rgdwTypeCount[ICMP4_TIME_EXCEEDED];
1461 stats->dwParmProbs = stats_ex->rgdwTypeCount[ICMP4_PARAM_PROB];
1462 stats->dwSrcQuenchs = stats_ex->rgdwTypeCount[ICMP4_SOURCE_QUENCH];
1463 stats->dwRedirects = stats_ex->rgdwTypeCount[ICMP4_REDIRECT];
1464 stats->dwEchos = stats_ex->rgdwTypeCount[ICMP4_ECHO_REQUEST];
1465 stats->dwEchoReps = stats_ex->rgdwTypeCount[ICMP4_ECHO_REPLY];
1466 stats->dwTimestamps = stats_ex->rgdwTypeCount[ICMP4_TIMESTAMP_REQUEST];
1467 stats->dwTimestampReps = stats_ex->rgdwTypeCount[ICMP4_TIMESTAMP_REPLY];
1468 stats->dwAddrMasks = stats_ex->rgdwTypeCount[ICMP4_MASK_REQUEST];
1469 stats->dwAddrMaskReps = stats_ex->rgdwTypeCount[ICMP4_MASK_REPLY];
1470 }
1471
1472 /******************************************************************
1473 * GetIcmpStatistics (IPHLPAPI.@)
1474 *
1475 * Get the ICMP statistics for the local computer.
1476 *
1477 * PARAMS
1478 * stats [Out] buffer for ICMP statistics
1479 *
1480 * RETURNS
1481 * Success: NO_ERROR
1482 * Failure: error code from winerror.h
1483 */
1484 DWORD WINAPI GetIcmpStatistics( MIB_ICMP *stats )
1485 {
1486 MIB_ICMP_EX stats_ex;
1487 DWORD err = GetIcmpStatisticsEx( &stats_ex, AF_INET );
1488
1489 if (err) return err;
1490
1491 icmp_stats_ex_to_icmp_stats( &stats_ex.icmpInStats, &stats->stats.icmpInStats );
1492 icmp_stats_ex_to_icmp_stats( &stats_ex.icmpOutStats, &stats->stats.icmpOutStats );
1493 return err;
1494 }
1495
1496 /******************************************************************
1497 * GetIcmpStatisticsEx (IPHLPAPI.@)
1498 *
1499 * Get the IPv4 and IPv6 ICMP statistics for the local computer.
1500 *
1501 * PARAMS
1502 * stats [Out] buffer for ICMP statistics
1503 * family [In] specifies whether IPv4 or IPv6 statistics are returned
1504 *
1505 * RETURNS
1506 * Success: NO_ERROR
1507 * Failure: error code from winerror.h
1508 */
1509 DWORD WINAPI GetIcmpStatisticsEx( MIB_ICMP_EX *stats, DWORD family )
1510 {
1511 const NPI_MODULEID *mod = ip_module_id( family );
1512 struct nsi_ip_icmpstats_dynamic dyn;
1513 DWORD err;
1514
1515 if (!stats || !mod) return ERROR_INVALID_PARAMETER;
1516 memset( stats, 0, sizeof(*stats) );
1517
1518 err = NsiGetAllParameters( 1, mod, NSI_IP_ICMPSTATS_TABLE, NULL, 0, NULL, 0,
1519 &dyn, sizeof(dyn), NULL, 0 );
1520 if (err) return err;
1521
1522 stats->icmpInStats.dwMsgs = dyn.in_msgs;
1523 stats->icmpInStats.dwErrors = dyn.in_errors;
1524 memcpy( stats->icmpInStats.rgdwTypeCount, dyn.in_type_counts, sizeof( dyn.in_type_counts ) );
1525 stats->icmpOutStats.dwMsgs = dyn.out_msgs;
1526 stats->icmpOutStats.dwErrors = dyn.out_errors;
1527 memcpy( stats->icmpOutStats.rgdwTypeCount, dyn.out_type_counts, sizeof( dyn.out_type_counts ) );
1528
1529 return ERROR_SUCCESS;
1530 }
1531
1532 static void if_row_fill( MIB_IFROW *row, struct nsi_ndis_ifinfo_rw *rw, struct nsi_ndis_ifinfo_dynamic *dyn,
1533 struct nsi_ndis_ifinfo_static *stat )
1534 {
1535 wcscpy( row->wszName, device_tcpip );
1536 ConvertGuidToStringW( &stat->if_guid, row->wszName + wcslen( device_tcpip ), CHARS_IN_GUID );
1537 row->dwIndex = stat->if_index;
1538 row->dwType = stat->type;
1539 row->dwMtu = dyn->mtu;
1540 row->dwSpeed = dyn->rcv_speed;
1541 row->dwPhysAddrLen = rw->phys_addr.Length;
1542 if (row->dwPhysAddrLen > sizeof(row->bPhysAddr)) row->dwPhysAddrLen = 0;
1543 memcpy( row->bPhysAddr, rw->phys_addr.Address, row->dwPhysAddrLen );
1544 row->dwAdminStatus = rw->admin_status;
1545 row->dwOperStatus = (dyn->oper_status == IfOperStatusUp) ? MIB_IF_OPER_STATUS_OPERATIONAL : MIB_IF_OPER_STATUS_NON_OPERATIONAL;
1546 row->dwLastChange = 0;
1547 row->dwInOctets = dyn->in_octets;
1548 row->dwInUcastPkts = dyn->in_ucast_pkts;
1549 row->dwInNUcastPkts = dyn->in_bcast_pkts + dyn->in_mcast_pkts;
1550 row->dwInDiscards = dyn->in_discards;
1551 row->dwInErrors = dyn->in_errors;
1552 row->dwInUnknownProtos = 0;
1553 row->dwOutOctets = dyn->out_octets;
1554 row->dwOutUcastPkts = dyn->out_ucast_pkts;
1555 row->dwOutNUcastPkts = dyn->out_bcast_pkts + dyn->out_mcast_pkts;
1556 row->dwOutDiscards = dyn->out_discards;
1557 row->dwOutErrors = dyn->out_errors;
1558 row->dwOutQLen = 0;
1559 row->dwDescrLen = WideCharToMultiByte( CP_ACP, 0, stat->descr.String, stat->descr.Length / sizeof(WCHAR),
1560 (char *)row->bDescr, sizeof(row->bDescr) - 1, NULL, NULL );
1561 row->bDescr[row->dwDescrLen] = '\0';
1562 }
1563
1564 /******************************************************************
1565 * GetIfEntry (IPHLPAPI.@)
1566 *
1567 * Get information about an interface.
1568 *
1569 * PARAMS
1570 * pIfRow [In/Out] In: dwIndex of MIB_IFROW selects the interface.
1571 * Out: interface information
1572 *
1573 * RETURNS
1574 * Success: NO_ERROR
1575 * Failure: error code from winerror.h
1576 */
1577 DWORD WINAPI GetIfEntry( MIB_IFROW *row )
1578 {
1579 struct nsi_ndis_ifinfo_rw rw;
1580 struct nsi_ndis_ifinfo_dynamic dyn;
1581 struct nsi_ndis_ifinfo_static stat;
1582 NET_LUID luid;
1583 DWORD err;
1584
1585 TRACE( "row %p\n", row );
1586 if (!row) return ERROR_INVALID_PARAMETER;
1587
1588 err = ConvertInterfaceIndexToLuid( row->dwIndex, &luid );
1589 if (err) return err;
1590
1591 err = NsiGetAllParameters( 1, &NPI_MS_NDIS_MODULEID, NSI_NDIS_IFINFO_TABLE,
1592 &luid, sizeof(luid), &rw, sizeof(rw),
1593 &dyn, sizeof(dyn), &stat, sizeof(stat) );
1594 if (!err) if_row_fill( row, &rw, &dyn, &stat );
1595 return err;
1596 }
1597
1598 static int DWORD_cmp( DWORD a, DWORD b )
1599 {
1600 return a < b ? -1 : a > b ? 1 : 0; /* a subtraction would overflow */
1601 }
1602
1603 static int ifrow_cmp( const void *a, const void *b )
1604 {
1605 const MIB_IFROW *rowA = a, *rowB = b;
1606 return DWORD_cmp(rowA->dwIndex, rowB->dwIndex);
1607 }
1608
1609 /******************************************************************
1610 * GetIfTable (IPHLPAPI.@)
1611 *
1612 * Get a table of local interfaces.
1613 *
1614 * PARAMS
1615 * table [Out] buffer for local interfaces table
1616 * size [In/Out] length of output buffer
1617 * sort [In] whether to sort the table
1618 *
1619 * RETURNS
1620 * Success: NO_ERROR
1621 * Failure: error code from winerror.h
1622 *
1623 * NOTES
1624 * If size is less than required, the function will return
1625 * ERROR_INSUFFICIENT_BUFFER, and *pdwSize will be set to the required byte
1626 * size.
1627 * If sort is true, the returned table will be sorted by interface index.
1628 */
1629 DWORD WINAPI GetIfTable( MIB_IFTABLE *table, ULONG *size, BOOL sort )
1630 {
1631 DWORD i, count, needed, err;
1632 NET_LUID *keys;
1633 struct nsi_ndis_ifinfo_rw *rw;
1634 struct nsi_ndis_ifinfo_dynamic *dyn;
1635 struct nsi_ndis_ifinfo_static *stat;
1636
1637 if (!size) return ERROR_INVALID_PARAMETER;
1638
1639 /* While this could be implemented on top of GetIfTable2(), it would require
1640 an additional copy of the data */
1641 err = NsiAllocateAndGetTable( 1, &NPI_MS_NDIS_MODULEID, NSI_NDIS_IFINFO_TABLE, (void **)&keys, sizeof(*keys),
1642 (void **)&rw, sizeof(*rw), (void **)&dyn, sizeof(*dyn),
1643 (void **)&stat, sizeof(*stat), &count, 0 );
1644 if (err) return err;
1645
1646 needed = FIELD_OFFSET( MIB_IFTABLE, table[count] );
1647
1648 if (!table || *size < needed)
1649 {
1650 *size = needed;
1651 err = ERROR_INSUFFICIENT_BUFFER;
1652 goto err;
1653 }
1654
1655 table->dwNumEntries = count;
1656 for (i = 0; i < count; i++)
1657 {
1658 MIB_IFROW *row = table->table + i;
1659
1660 if_row_fill( row, rw + i, dyn + i, stat + i );
1661 }
1662
1663 if (sort) qsort( table->table, count, sizeof(MIB_IFROW), ifrow_cmp );
1664
1665 err:
1666 NsiFreeTable( keys, rw, dyn, stat );
1667 return err;
1668 }
1669
1670 /******************************************************************
1671 * AllocateAndGetIfTableFromStack (IPHLPAPI.@)
1672 *
1673 * Get table of local interfaces.
1674 * Like GetIfTable(), but allocate the returned table from heap.
1675 *
1676 * PARAMS
1677 * table [Out] pointer into which the MIB_IFTABLE is
1678 * allocated and returned.
1679 * sort [In] whether to sort the table
1680 * heap [In] heap from which the table is allocated
1681 * flags [In] flags to HeapAlloc
1682 *
1683 * RETURNS
1684 * ERROR_INVALID_PARAMETER if ppIfTable is NULL, whatever
1685 * GetIfTable() returns otherwise.
1686 */
1687 DWORD WINAPI AllocateAndGetIfTableFromStack( MIB_IFTABLE **table, BOOL sort, HANDLE heap, DWORD flags )
1688 {
1689 DWORD i, count, size, err;
1690 NET_LUID *keys;
1691 struct nsi_ndis_ifinfo_rw *rw;
1692 struct nsi_ndis_ifinfo_dynamic *dyn;
1693 struct nsi_ndis_ifinfo_static *stat;
1694
1695 if (!table) return ERROR_INVALID_PARAMETER;
1696
1697 /* While this could be implemented on top of GetIfTable(), it would require
1698 an additional call to retrieve the size */
1699 err = NsiAllocateAndGetTable( 1, &NPI_MS_NDIS_MODULEID, NSI_NDIS_IFINFO_TABLE, (void **)&keys, sizeof(*keys),
1700 (void **)&rw, sizeof(*rw), (void **)&dyn, sizeof(*dyn),
1701 (void **)&stat, sizeof(*stat), &count, 0 );
1702 if (err) return err;
1703
1704 size = FIELD_OFFSET( MIB_IFTABLE, table[count] );
1705 *table = HeapAlloc( heap, flags, size );
1706 if (!*table)
1707 {
1708 err = ERROR_NOT_ENOUGH_MEMORY;
1709 goto err;
1710 }
1711
1712 (*table)->dwNumEntries = count;
1713 for (i = 0; i < count; i++)
1714 {
1715 MIB_IFROW *row = (*table)->table + i;
1716
1717 if_row_fill( row, rw + i, dyn + i, stat + i );
1718 }
1719 if (sort) qsort( (*table)->table, count, sizeof(MIB_IFROW), ifrow_cmp );
1720
1721 err:
1722 NsiFreeTable( keys, rw, dyn, stat );
1723 return err;
1724 }
1725
1726 static void if_row2_fill( MIB_IF_ROW2 *row, struct nsi_ndis_ifinfo_rw *rw, struct nsi_ndis_ifinfo_dynamic *dyn,
1727 struct nsi_ndis_ifinfo_static *stat )
1728 {
1729 row->InterfaceIndex = stat->if_index;
1730 row->InterfaceGuid = stat->if_guid;
1731 if_counted_string_copy( row->Alias, ARRAY_SIZE(row->Alias), &rw->alias );
1732 if_counted_string_copy( row->Description, ARRAY_SIZE(row->Description), &stat->descr );
1733 row->PhysicalAddressLength = rw->phys_addr.Length;
1734 if (row->PhysicalAddressLength > sizeof(row->PhysicalAddress)) row->PhysicalAddressLength = 0;
1735 memcpy( row->PhysicalAddress, rw->phys_addr.Address, row->PhysicalAddressLength );
1736 memcpy( row->PermanentPhysicalAddress, stat->perm_phys_addr.Address, row->PhysicalAddressLength );
1737 row->Mtu = dyn->mtu;
1738 row->Type = stat->type;
1739 row->TunnelType = TUNNEL_TYPE_NONE; /* fixme */
1740 row->MediaType = stat->media_type;
1741 row->PhysicalMediumType = stat->phys_medium_type;
1742 row->AccessType = stat->access_type;
1743 row->DirectionType = NET_IF_DIRECTION_SENDRECEIVE; /* fixme */
1744 row->InterfaceAndOperStatusFlags.HardwareInterface = stat->flags.hw;
1745 row->InterfaceAndOperStatusFlags.FilterInterface = stat->flags.filter;
1746 row->InterfaceAndOperStatusFlags.ConnectorPresent = !!stat->conn_present;
1747 row->InterfaceAndOperStatusFlags.NotAuthenticated = 0; /* fixme */
1748 row->InterfaceAndOperStatusFlags.NotMediaConnected = dyn->flags.not_media_conn;
1749 row->InterfaceAndOperStatusFlags.Paused = 0; /* fixme */
1750 row->InterfaceAndOperStatusFlags.LowPower = 0; /* fixme */
1751 row->InterfaceAndOperStatusFlags.EndPointInterface = 0; /* fixme */
1752 row->OperStatus = dyn->oper_status;
1753 row->AdminStatus = rw->admin_status;
1754 row->MediaConnectState = dyn->media_conn_state;
1755 row->NetworkGuid = rw->network_guid;
1756 row->ConnectionType = stat->conn_type;
1757 row->TransmitLinkSpeed = dyn->xmit_speed;
1758 row->ReceiveLinkSpeed = dyn->rcv_speed;
1759 row->InOctets = dyn->in_octets;
1760 row->InUcastPkts = dyn->in_ucast_pkts;
1761 row->InNUcastPkts = dyn->in_bcast_pkts + dyn->in_mcast_pkts;
1762 row->InDiscards = dyn->in_discards;
1763 row->InErrors = dyn->in_errors;
1764 row->InUnknownProtos = 0; /* fixme */
1765 row->InUcastOctets = dyn->in_ucast_octs;
1766 row->InMulticastOctets = dyn->in_mcast_octs;
1767 row->InBroadcastOctets = dyn->in_bcast_octs;
1768 row->OutOctets = dyn->out_octets;
1769 row->OutUcastPkts = dyn->out_ucast_pkts;
1770 row->OutNUcastPkts = dyn->out_bcast_pkts + dyn->out_mcast_pkts;
1771 row->OutDiscards = dyn->out_discards;
1772 row->OutErrors = dyn->out_errors;
1773 row->OutUcastOctets = dyn->out_ucast_octs;
1774 row->OutMulticastOctets = dyn->out_mcast_octs;
1775 row->OutBroadcastOctets = dyn->out_bcast_octs;
1776 row->OutQLen = 0; /* fixme */
1777 }
1778
1779 /******************************************************************
1780 * GetIfEntry2Ex (IPHLPAPI.@)
1781 */
1782 DWORD WINAPI GetIfEntry2Ex( MIB_IF_TABLE_LEVEL level, MIB_IF_ROW2 *row )
1783 {
1784 DWORD err;
1785 struct nsi_ndis_ifinfo_rw rw;
1786 struct nsi_ndis_ifinfo_dynamic dyn;
1787 struct nsi_ndis_ifinfo_static stat;
1788
1789 TRACE( "(%d, %p)\n", level, row );
1790
1791 if (level != MibIfTableNormal) FIXME( "level %u not fully supported\n", level );
1792 if (!row) return ERROR_INVALID_PARAMETER;
1793
1794 if (!row->InterfaceLuid.Value)
1795 {
1796 if (!row->InterfaceIndex) return ERROR_INVALID_PARAMETER;
1797 err = ConvertInterfaceIndexToLuid( row->InterfaceIndex, &row->InterfaceLuid );
1798 if (err) return err;
1799 }
1800
1801 err = NsiGetAllParameters( 1, &NPI_MS_NDIS_MODULEID, NSI_NDIS_IFINFO_TABLE,
1802 &row->InterfaceLuid, sizeof(row->InterfaceLuid),
1803 &rw, sizeof(rw), &dyn, sizeof(dyn), &stat, sizeof(stat) );
1804 if (!err) if_row2_fill( row, &rw, &dyn, &stat );
1805 return err;
1806 }
1807
1808 /******************************************************************
1809 * GetIfEntry2 (IPHLPAPI.@)
1810 */
1811 DWORD WINAPI GetIfEntry2( MIB_IF_ROW2 *row )
1812 {
1813 return GetIfEntry2Ex( MibIfTableNormal, row );
1814 }
1815
1816 /******************************************************************
1817 * GetIfTable2Ex (IPHLPAPI.@)
1818 */
1819 DWORD WINAPI GetIfTable2Ex( MIB_IF_TABLE_LEVEL level, MIB_IF_TABLE2 **table )
1820 {
1821 DWORD i, count, size, err;
1822 NET_LUID *keys;
1823 struct nsi_ndis_ifinfo_rw *rw;
1824 struct nsi_ndis_ifinfo_dynamic *dyn;
1825 struct nsi_ndis_ifinfo_static *stat;
1826
1827 TRACE( "level %u, table %p\n", level, table );
1828
1829 if (!table || level > MibIfTableNormalWithoutStatistics)
1830 return ERROR_INVALID_PARAMETER;
1831
1832 if (level != MibIfTableNormal)
1833 FIXME("level %u not fully supported\n", level);
1834
1835 err = NsiAllocateAndGetTable( 1, &NPI_MS_NDIS_MODULEID, NSI_NDIS_IFINFO_TABLE, (void **)&keys, sizeof(*keys),
1836 (void **)&rw, sizeof(*rw), (void **)&dyn, sizeof(*dyn),
1837 (void **)&stat, sizeof(*stat), &count, 0 );
1838 if (err) return err;
1839
1840 size = FIELD_OFFSET( MIB_IF_TABLE2, Table[count] );
1841
1842 if (!(*table = heap_alloc_zero( size )))
1843 {
1844 err = ERROR_OUTOFMEMORY;
1845 goto err;
1846 }
1847
1848 (*table)->NumEntries = count;
1849 for (i = 0; i < count; i++)
1850 {
1851 MIB_IF_ROW2 *row = (*table)->Table + i;
1852
1853 row->InterfaceLuid.Value = keys[i].Value;
1854 if_row2_fill( row, rw + i, dyn + i, stat + i );
1855 }
1856 err:
1857 NsiFreeTable( keys, rw, dyn, stat );
1858 return err;
1859 }
1860
1861 /******************************************************************
1862 * GetIfTable2 (IPHLPAPI.@)
1863 */
1864 DWORD WINAPI GetIfTable2( MIB_IF_TABLE2 **table )
1865 {
1866 TRACE( "table %p\n", table );
1867 return GetIfTable2Ex( MibIfTableNormal, table );
1868 }
1869
1870 /******************************************************************
1871 * GetInterfaceInfo (IPHLPAPI.@)
1872 *
1873 * Get a list of network interface adapters.
1874 *
1875 * PARAMS
1876 * pIfTable [Out] buffer for interface adapters
1877 * dwOutBufLen [Out] if buffer is too small, returns required size
1878 *
1879 * RETURNS
1880 * Success: NO_ERROR
1881 * Failure: error code from winerror.h
1882 *
1883 * BUGS
1884 * MSDN states this should return non-loopback interfaces only.
1885 */
1886 DWORD WINAPI GetInterfaceInfo( IP_INTERFACE_INFO *table, ULONG *size )
1887 {
1888 NET_LUID *keys;
1889 struct nsi_ndis_ifinfo_static *stat;
1890 DWORD err, count, num = 0, needed, i;
1891
1892 TRACE( "table %p, size %p\n", table, size );
1893 if (!size) return ERROR_INVALID_PARAMETER;
1894
1895 err = NsiAllocateAndGetTable( 1, &NPI_MS_NDIS_MODULEID, NSI_NDIS_IFINFO_TABLE,
1896 (void **)&keys, sizeof(*keys), NULL, 0, NULL, 0,
1897 (void **)&stat, sizeof(*stat), &count, 0 );
1898 if (err) return err;
1899
1900 for (i = 0; i < count; i++)
1901 {
1902 if (stat[i].type == IF_TYPE_SOFTWARE_LOOPBACK) continue;
1903 num++;
1904 }
1905
1906 needed = FIELD_OFFSET(IP_INTERFACE_INFO, Adapter[num]);
1907 if (!table || *size < needed)
1908 {
1909 *size = needed;
1910 err = ERROR_INSUFFICIENT_BUFFER;
1911 goto done;
1912 }
1913
1914 table->NumAdapters = num;
1915 for (i = 0, num = 0; i < count; i++)
1916 {
1917 IP_ADAPTER_INDEX_MAP *row;
1918
1919 if (stat[i].type == IF_TYPE_SOFTWARE_LOOPBACK) continue;
1920 row = table->Adapter + num++;
1921 row->Index = stat[i].if_index;
1922 wcscpy( row->Name, device_tcpip );
1923 ConvertGuidToStringW( &stat[i].if_guid, row->Name + wcslen( device_tcpip ), CHARS_IN_GUID );
1924 }
1925 done:
1926 NsiFreeTable( keys, NULL, NULL, stat );
1927 return err;
1928 }
1929
1930 static int ipaddrrow_cmp( const void *a, const void *b )
1931 {
1932 const MIB_IPADDRROW *rowA = a, *rowB = b;
1933 return DWORD_cmp(RtlUlongByteSwap( rowA->dwAddr ), RtlUlongByteSwap( rowB->dwAddr ));
1934 }
1935
1936 /******************************************************************
1937 * GetIpAddrTable (IPHLPAPI.@)
1938 *
1939 * Get interface-to-IP address mapping table.
1940 *
1941 * PARAMS
1942 * table [Out] buffer for mapping table
1943 * size [In/Out] length of output buffer
1944 * sort [In] whether to sort the table
1945 *
1946 * RETURNS
1947 * Success: NO_ERROR
1948 * Failure: error code from winerror.h
1949 *
1950 */
1951 DWORD WINAPI GetIpAddrTable( MIB_IPADDRTABLE *table, ULONG *size, BOOL sort )
1952 {
1953 DWORD err, count, needed, i, loopback, row_num = 0;
1954 struct nsi_ipv4_unicast_key *keys;
1955 struct nsi_ip_unicast_rw *rw;
1956
1957 TRACE( "table %p, size %p, sort %d\n", table, size, sort );
1958 if (!size) return ERROR_INVALID_PARAMETER;
1959
1960 err = NsiAllocateAndGetTable( 1, &NPI_MS_IPV4_MODULEID, NSI_IP_UNICAST_TABLE, (void **)&keys, sizeof(*keys),
1961 (void **)&rw, sizeof(*rw), NULL, 0, NULL, 0, &count, 0 );
1962 if (err) return err;
1963
1964 needed = FIELD_OFFSET( MIB_IPADDRTABLE, table[count] );
1965
1966 if (!table || *size < needed)
1967 {
1968 *size = needed;
1969 err = ERROR_INSUFFICIENT_BUFFER;
1970 goto err;
1971 }
1972
1973 table->dwNumEntries = count;
1974
1975 for (loopback = 0; loopback < 2; loopback++) /* Move the loopback addresses to the end */
1976 {
1977 for (i = 0; i < count; i++)
1978 {
1979 MIB_IPADDRROW *row = table->table + row_num;
1980
1981 if (!!loopback != (keys[i].luid.Info.IfType == MIB_IF_TYPE_LOOPBACK)) continue;
1982
1983 row->dwAddr = keys[i].addr.s_addr;
1984 ConvertInterfaceLuidToIndex( &keys[i].luid, &row->dwIndex );
1985 ConvertLengthToIpv4Mask( rw[i].on_link_prefix, &row->dwMask );
1986 row->dwBCastAddr = 1;
1987 row->dwReasmSize = 0xffff;
1988 row->unused1 = 0;
1989 row->wType = MIB_IPADDR_PRIMARY;
1990 row_num++;
1991 }
1992 }
1993
1994 if (sort) qsort( table->table, count, sizeof(MIB_IPADDRROW), ipaddrrow_cmp );
1995 err:
1996 NsiFreeTable( keys, rw, NULL, NULL );
1997
1998 return err;
1999 }
2000
2001
2002 /******************************************************************
2003 * AllocateAndGetIpAddrTableFromStack (IPHLPAPI.@)
2004 *
2005 * Get interface-to-IP address mapping table.
2006 * Like GetIpAddrTable(), but allocate the returned table from heap.
2007 *
2008 * PARAMS
2009 * table [Out] pointer into which the MIB_IPADDRTABLE is
2010 * allocated and returned.
2011 * sort [In] whether to sort the table
2012 * heap [In] heap from which the table is allocated
2013 * flags [In] flags to HeapAlloc
2014 *
2015 */
2016 DWORD WINAPI AllocateAndGetIpAddrTableFromStack( MIB_IPADDRTABLE **table, BOOL sort, HANDLE heap, DWORD flags )
2017 {
2018 DWORD err, size = FIELD_OFFSET(MIB_IPADDRTABLE, table[2]), attempt;
2019
2020 TRACE( "table %p, sort %d, heap %p, flags 0x%08lx\n", table, sort, heap, flags );
2021
2022 for (attempt = 0; attempt < 5; attempt++)
2023 {
2024 *table = HeapAlloc( heap, flags, size );
2025 if (!*table) return ERROR_NOT_ENOUGH_MEMORY;
2026
2027 err = GetIpAddrTable( *table, &size, sort );
2028 if (!err) break;
2029 HeapFree( heap, flags, *table );
2030 if (err != ERROR_INSUFFICIENT_BUFFER) break;
2031 }
2032
2033 return err;
2034 }
2035
2036 static int ipforward_row_cmp( const void *a, const void *b )
2037 {
2038 const MIB_IPFORWARDROW *rowA = a, *rowB = b;
2039 return DWORD_cmp(RtlUlongByteSwap( rowA->dwForwardDest ), RtlUlongByteSwap( rowB->dwForwardDest )) ||
2040 DWORD_cmp(rowA->dwForwardProto, rowB->dwForwardProto) ||
2041 DWORD_cmp(rowA->dwForwardPolicy, rowB->dwForwardPolicy) ||
2042 DWORD_cmp(RtlUlongByteSwap( rowA->dwForwardNextHop ), RtlUlongByteSwap( rowB->dwForwardNextHop ));
2043 }
2044
2045 /******************************************************************
2046 * GetIpForwardTable (IPHLPAPI.@)
2047 *
2048 * Get the route table.
2049 *
2050 * PARAMS
2051 * table [Out] buffer for route table
2052 * size [In/Out] length of output buffer
2053 * sort [In] whether to sort the table
2054 *
2055 * RETURNS
2056 * Success: NO_ERROR
2057 * Failure: error code from winerror.h
2058 */
2059 DWORD WINAPI GetIpForwardTable( MIB_IPFORWARDTABLE *table, ULONG *size, BOOL sort )
2060 {
2061 DWORD err, count, uni_count, needed, i, addr;
2062 struct nsi_ipv4_forward_key *keys;
2063 struct nsi_ip_forward_rw *rw;
2064 struct nsi_ipv4_forward_dynamic *dyn;
2065 struct nsi_ip_forward_static *stat;
2066 struct nsi_ipv4_unicast_key *uni_keys = NULL;
2067
2068 TRACE( "table %p, size %p, sort %d\n", table, size, sort );
2069 if (!size) return ERROR_INVALID_PARAMETER;
2070
2071 err = NsiAllocateAndGetTable( 1, &NPI_MS_IPV4_MODULEID, NSI_IP_FORWARD_TABLE, (void **)&keys, sizeof(*keys),
2072 (void **)&rw, sizeof(*rw), (void **)&dyn, sizeof(*dyn),
2073 (void **)&stat, sizeof(*stat), &count, 0 );
2074 if (err) return err;
2075
2076 needed = FIELD_OFFSET( MIB_IPFORWARDTABLE, table[count] );
2077
2078 if (!table || *size < needed)
2079 {
2080 *size = needed;
2081 err = ERROR_INSUFFICIENT_BUFFER;
2082 goto err;
2083 }
2084
2085 err = NsiAllocateAndGetTable( 1, &NPI_MS_IPV4_MODULEID, NSI_IP_UNICAST_TABLE, (void **)&uni_keys, sizeof(*uni_keys),
2086 NULL, 0, NULL, 0, NULL, 0, &uni_count, 0 );
2087 if (err) goto err;
2088
2089 table->dwNumEntries = count;
2090 for (i = 0; i < count; i++)
2091 {
2092 MIB_IPFORWARDROW *row = table->table + i;
2093
2094 row->dwForwardDest = keys[i].prefix.s_addr;
2095 ConvertLengthToIpv4Mask( keys[i].prefix_len, &row->dwForwardMask );
2096 row->dwForwardPolicy = 0;
2097 row->dwForwardNextHop = keys[i].next_hop.s_addr;
2098 row->dwForwardType = row->dwForwardNextHop ? MIB_IPROUTE_TYPE_INDIRECT : MIB_IPROUTE_TYPE_DIRECT;
2099 if (!row->dwForwardNextHop) /* find the interface's addr */
2100 {
2101 for (addr = 0; addr < uni_count; addr++)
2102 {
2103 if (uni_keys[addr].luid.Value == keys[i].luid.Value)
2104 {
2105 row->dwForwardNextHop = uni_keys[addr].addr.s_addr;
2106 break;
2107 }
2108 }
2109 }
2110 row->dwForwardIfIndex = stat[i].if_index;
2111 row->dwForwardProto = rw[i].protocol;
2112 row->dwForwardAge = dyn[i].age;
2113 row->dwForwardNextHopAS = 0;
2114 row->dwForwardMetric1 = rw[i].metric; /* FIXME: add interface metric */
2115 row->dwForwardMetric2 = 0;
2116 row->dwForwardMetric3 = 0;
2117 row->dwForwardMetric4 = 0;
2118 row->dwForwardMetric5 = 0;
2119 }
2120
2121 if (sort) qsort( table->table, count, sizeof(MIB_IPFORWARDROW), ipforward_row_cmp );
2122 err:
2123 NsiFreeTable( uni_keys, NULL, NULL, NULL );
2124 NsiFreeTable( keys, rw, dyn, stat );
2125
2126 return err;
2127 }
2128
2129 /******************************************************************
2130 * AllocateAndGetIpForwardTableFromStack (IPHLPAPI.@)
2131 *
2132 * Get the route table.
2133 * Like GetIpForwardTable(), but allocate the returned table from heap.
2134 *
2135 * PARAMS
2136 * table [Out] pointer into which the MIB_IPFORWARDTABLE is
2137 * allocated and returned.
2138 * sort [In] whether to sort the table
2139 * heap [In] heap from which the table is allocated
2140 * flags [In] flags to HeapAlloc
2141 *
2142 * RETURNS
2143 * ERROR_INVALID_PARAMETER if ppIfTable is NULL, other error codes
2144 * on failure, NO_ERROR on success.
2145 */
2146 DWORD WINAPI AllocateAndGetIpForwardTableFromStack( MIB_IPFORWARDTABLE **table, BOOL sort, HANDLE heap, DWORD flags )
2147 {
2148 DWORD err, size = FIELD_OFFSET(MIB_IPFORWARDTABLE, table[2]), attempt;
2149
2150 TRACE( "table %p, sort %d, heap %p, flags 0x%08lx\n", table, sort, heap, flags );
2151
2152 for (attempt = 0; attempt < 5; attempt++)
2153 {
2154 *table = HeapAlloc( heap, flags, size );
2155 if (!*table) return ERROR_NOT_ENOUGH_MEMORY;
2156
2157 err = GetIpForwardTable( *table, &size, sort );
2158 if (!err) break;
2159 HeapFree( heap, flags, *table );
2160 if (err != ERROR_INSUFFICIENT_BUFFER) break;
2161 }
2162
2163 return err;
2164 }
2165
2166 static void forward_row2_fill( MIB_IPFORWARD_ROW2 *row, USHORT fam, void *key, struct nsi_ip_forward_rw *rw,
2167 void *dyn, struct nsi_ip_forward_static *stat )
2168 {
2169 struct nsi_ipv4_forward_key *key4 = (struct nsi_ipv4_forward_key *)key;
2170 struct nsi_ipv6_forward_key *key6 = (struct nsi_ipv6_forward_key *)key;
2171 struct nsi_ipv4_forward_dynamic *dyn4 = (struct nsi_ipv4_forward_dynamic *)dyn;
2172 struct nsi_ipv6_forward_dynamic *dyn6 = (struct nsi_ipv6_forward_dynamic *)dyn;
2173
2174 if (fam == AF_INET)
2175 {
2176 row->InterfaceLuid = key4->luid;
2177 row->DestinationPrefix.Prefix.Ipv4.sin_family = fam;
2178 row->DestinationPrefix.Prefix.Ipv4.sin_port = 0;
2179 row->DestinationPrefix.Prefix.Ipv4.sin_addr = key4->prefix;
2180 memset( &row->DestinationPrefix.Prefix.Ipv4.sin_zero, 0, sizeof(row->DestinationPrefix.Prefix.Ipv4.sin_zero) );
2181 row->DestinationPrefix.PrefixLength = key4->prefix_len;
2182 row->NextHop.Ipv4.sin_family = fam;
2183 row->NextHop.Ipv4.sin_port = 0;
2184 row->NextHop.Ipv4.sin_addr = key4->next_hop;
2185 memset( &row->NextHop.Ipv4.sin_zero, 0, sizeof(row->NextHop.Ipv4.sin_zero) );
2186
2187 row->Age = dyn4->age;
2188 }
2189 else
2190 {
2191 row->InterfaceLuid = key6->luid;
2192
2193 row->DestinationPrefix.Prefix.Ipv6.sin6_family = fam;
2194 row->DestinationPrefix.Prefix.Ipv6.sin6_port = 0;
2195 row->DestinationPrefix.Prefix.Ipv6.sin6_flowinfo = 0;
2196 row->DestinationPrefix.Prefix.Ipv6.sin6_addr = key6->prefix;
2197 row->DestinationPrefix.Prefix.Ipv6.sin6_scope_id = 0;
2198 row->DestinationPrefix.PrefixLength = key6->prefix_len;
2199 row->NextHop.Ipv6.sin6_family = fam;
2200 row->NextHop.Ipv6.sin6_port = 0;
2201 row->NextHop.Ipv6.sin6_flowinfo = 0;
2202 row->NextHop.Ipv6.sin6_addr = key6->next_hop;
2203 row->NextHop.Ipv6.sin6_scope_id = 0;
2204
2205 row->Age = dyn6->age;
2206 }
2207
2208 row->InterfaceIndex = stat->if_index;
2209
2210 row->SitePrefixLength = rw->site_prefix_len;
2211 row->ValidLifetime = rw->valid_lifetime;
2212 row->PreferredLifetime = rw->preferred_lifetime;
2213 row->Metric = rw->metric;
2214 row->Protocol = rw->protocol;
2215 row->Loopback = rw->loopback;
2216 row->AutoconfigureAddress = rw->autoconf;
2217 row->Publish = rw->publish;
2218 row->Immortal = rw->immortal;
2219
2220 row->Origin = stat->origin;
2221 }
2222
2223 /******************************************************************
2224 * GetIpForwardTable2 (IPHLPAPI.@)
2225 */
2226 DWORD WINAPI GetIpForwardTable2( ADDRESS_FAMILY family, MIB_IPFORWARD_TABLE2 **table )
2227 {
2228 void *key[2] = { NULL, NULL };
2229 struct nsi_ip_forward_rw *rw[2] = { NULL, NULL };
2230 void *dyn[2] = { NULL, NULL };
2231 struct nsi_ip_forward_static *stat[2] = { NULL, NULL };
2232 static const USHORT fam[2] = { AF_INET, AF_INET6 };
2233 static const DWORD key_size[2] = { sizeof(struct nsi_ipv4_forward_key), sizeof(struct nsi_ipv6_forward_key) };
2234 static const DWORD dyn_size[2] = { sizeof(struct nsi_ipv4_forward_dynamic), sizeof(struct nsi_ipv6_forward_dynamic) };
2235 DWORD err = ERROR_SUCCESS, i, size, count[2] = { 0, 0 };
2236
2237 TRACE( "%u, %p\n", family, table );
2238
2239 if (!table || (family != AF_INET && family != AF_INET6 && family != AF_UNSPEC))
2240 return ERROR_INVALID_PARAMETER;
2241
2242 for (i = 0; i < 2; i++)
2243 {
2244 if (family != AF_UNSPEC && family != fam[i]) continue;
2245
2246 err = NsiAllocateAndGetTable( 1, ip_module_id( fam[i] ), NSI_IP_FORWARD_TABLE, key + i, key_size[i],
2247 (void **)rw + i, sizeof(**rw), dyn + i, dyn_size[i],
2248 (void **)stat + i, sizeof(**stat), count + i, 0 );
2249 if (err) count[i] = 0;
2250 }
2251
2252 size = FIELD_OFFSET(MIB_IPFORWARD_TABLE2, Table[ count[0] + count[1] ]);
2253 *table = heap_alloc( size );
2254 if (!*table)
2255 {
2256 err = ERROR_NOT_ENOUGH_MEMORY;
2257 goto err;
2258 }
2259
2260 (*table)->NumEntries = count[0] + count[1];
2261 for (i = 0; i < count[0]; i++)
2262 {
2263 MIB_IPFORWARD_ROW2 *row = (*table)->Table + i;
2264 struct nsi_ipv4_forward_key *key4 = (struct nsi_ipv4_forward_key *)key[0];
2265 struct nsi_ipv4_forward_dynamic *dyn4 = (struct nsi_ipv4_forward_dynamic *)dyn[0];
2266
2267 forward_row2_fill( row, fam[0], key4 + i, rw[0] + i, dyn4 + i, stat[0] + i );
2268 }
2269
2270 for (i = 0; i < count[1]; i++)
2271 {
2272 MIB_IPFORWARD_ROW2 *row = (*table)->Table + count[0] + i;
2273 struct nsi_ipv6_forward_key *key6 = (struct nsi_ipv6_forward_key *)key[1];
2274 struct nsi_ipv6_forward_dynamic *dyn6 = (struct nsi_ipv6_forward_dynamic *)dyn[1];
2275
2276 forward_row2_fill( row, fam[1], key6 + i, rw[1] + i, dyn6 + i, stat[1] + i );
2277 }
2278
2279 err:
2280 for (i = 0; i < 2; i++) NsiFreeTable( key[i], rw[i], dyn[i], stat[i] );
2281 return err;
2282 }
2283
2284 static int ipnetrow_cmp( const void *a, const void *b )
2285 {
2286 const MIB_IPNETROW *rowA = a, *rowB = b;
2287
2288 if (rowA->dwIndex != rowB->dwIndex) return DWORD_cmp( rowA->dwIndex, rowB->dwIndex );
2289
2290 return DWORD_cmp(RtlUlongByteSwap( rowA->dwAddr ), RtlUlongByteSwap( rowB->dwAddr ));
2291 }
2292
2293 /******************************************************************
2294 * GetIpNetTable (IPHLPAPI.@)
2295 *
2296 * Get the IP-to-physical address mapping table.
2297 *
2298 * PARAMS
2299 * table [Out] buffer for mapping table
2300 * size [In/Out] length of output buffer
2301 * sort [In] whether to sort the table
2302 *
2303 * RETURNS
2304 * Success: NO_ERROR
2305 * Failure: error code from winerror.h
2306 *
2307 */
2308 DWORD WINAPI GetIpNetTable( MIB_IPNETTABLE *table, ULONG *size, BOOL sort )
2309 {
2310 DWORD err, count, needed, i;
2311 struct nsi_ipv4_neighbour_key *keys;
2312 struct nsi_ip_neighbour_rw *rw;
2313 struct nsi_ip_neighbour_dynamic *dyn;
2314
2315 TRACE( "table %p, size %p, sort %d\n", table, size, sort );
2316
2317 if (!size) return ERROR_INVALID_PARAMETER;
2318
2319 err = NsiAllocateAndGetTable( 1, &NPI_MS_IPV4_MODULEID, NSI_IP_NEIGHBOUR_TABLE, (void **)&keys, sizeof(*keys),
2320 (void **)&rw, sizeof(*rw), (void **)&dyn, sizeof(*dyn),
2321 NULL, 0, &count, 0 );
2322 if (err) return err;
2323
2324 needed = FIELD_OFFSET( MIB_IPNETTABLE, table[count] );
2325
2326 if (!table || *size < needed)
2327 {
2328 *size = needed;
2329 err = ERROR_INSUFFICIENT_BUFFER;
2330 goto err;
2331 }
2332
2333 table->dwNumEntries = count;
2334
2335 if (!count)
2336 {
2337 err = ERROR_NO_DATA;
2338 goto err;
2339 }
2340
2341 for (i = 0; i < count; i++)
2342 {
2343 MIB_IPNETROW *row = table->table + i;
2344
2345 ConvertInterfaceLuidToIndex( &keys[i].luid, &row->dwIndex );
2346 row->dwPhysAddrLen = dyn[i].phys_addr_len;
2347 if (row->dwPhysAddrLen > sizeof(row->bPhysAddr)) row->dwPhysAddrLen = 0;
2348 memcpy( row->bPhysAddr, rw[i].phys_addr, row->dwPhysAddrLen );
2349 memset( row->bPhysAddr + row->dwPhysAddrLen, 0,
2350 sizeof(row->bPhysAddr) - row->dwPhysAddrLen );
2351 row->dwAddr = keys[i].addr.s_addr;
2352
2353 switch (dyn[i].state)
2354 {
2355 case NlnsUnreachable:
2356 case NlnsIncomplete:
2357 row->Type = MIB_IPNET_TYPE_INVALID;
2358 break;
2359 case NlnsProbe:
2360 case NlnsDelay:
2361 case NlnsStale:
2362 case NlnsReachable:
2363 row->Type = MIB_IPNET_TYPE_DYNAMIC;
2364 break;
2365 case NlnsPermanent:
2366 row->Type = MIB_IPNET_TYPE_STATIC;
2367 break;
2368 default:
2369 row->Type = MIB_IPNET_TYPE_OTHER;
2370 }
2371 }
2372
2373 if (sort) qsort( table->table, table->dwNumEntries, sizeof(*table->table), ipnetrow_cmp );
2374
2375 err:
2376 NsiFreeTable( keys, rw, dyn, NULL );
2377 return err;
2378 }
2379
2380 /******************************************************************
2381 * AllocateAndGetIpNetTableFromStack (IPHLPAPI.@)
2382 */
2383 DWORD WINAPI AllocateAndGetIpNetTableFromStack( MIB_IPNETTABLE **table, BOOL sort, HANDLE heap, DWORD flags )
2384 {
2385 DWORD err, size = FIELD_OFFSET(MIB_IPNETTABLE, table[2]), attempt;
2386
2387 TRACE( "table %p, sort %d, heap %p, flags 0x%08lx\n", table, sort, heap, flags );
2388
2389 for (attempt = 0; attempt < 5; attempt++)
2390 {
2391 *table = HeapAlloc( heap, flags, size );
2392 if (!*table) return ERROR_NOT_ENOUGH_MEMORY;
2393
2394 err = GetIpNetTable( *table, &size, sort );
2395 if (!err) break;
2396 HeapFree( heap, flags, *table );
2397 if (err != ERROR_INSUFFICIENT_BUFFER) break;
2398 }
2399
2400 return err;
2401 }
2402
2403 static void ipnet_row2_fill( MIB_IPNET_ROW2 *row, USHORT fam, void *key, struct nsi_ip_neighbour_rw *rw,
2404 struct nsi_ip_neighbour_dynamic *dyn )
2405 {
2406 struct nsi_ipv4_neighbour_key *key4 = (struct nsi_ipv4_neighbour_key *)key;
2407 struct nsi_ipv6_neighbour_key *key6 = (struct nsi_ipv6_neighbour_key *)key;
2408
2409 if (fam == AF_INET)
2410 {
2411 row->Address.Ipv4.sin_family = fam;
2412 row->Address.Ipv4.sin_port = 0;
2413 row->Address.Ipv4.sin_addr = key4->addr;
2414 memset( &row->Address.Ipv4.sin_zero, 0, sizeof(row->Address.Ipv4.sin_zero) );
2415 row->InterfaceLuid = key4->luid;
2416 }
2417 else
2418 {
2419 row->Address.Ipv6.sin6_family = fam;
2420 row->Address.Ipv6.sin6_port = 0;
2421 row->Address.Ipv6.sin6_flowinfo = 0;
2422 row->Address.Ipv6.sin6_addr = key6->addr;
2423 row->Address.Ipv6.sin6_scope_id = 0;
2424 row->InterfaceLuid = key6->luid;
2425 }
2426
2427 ConvertInterfaceLuidToIndex( &row->InterfaceLuid, &row->InterfaceIndex );
2428
2429 row->PhysicalAddressLength = dyn->phys_addr_len;
2430 if (row->PhysicalAddressLength > sizeof(row->PhysicalAddress))
2431 row->PhysicalAddressLength = 0;
2432 memcpy( row->PhysicalAddress, rw->phys_addr, row->PhysicalAddressLength );
2433 memset( row->PhysicalAddress + row->PhysicalAddressLength, 0,
2434 sizeof(row->PhysicalAddress) - row->PhysicalAddressLength );
2435 row->State = dyn->state;
2436 row->Flags = 0;
2437 row->IsRouter = dyn->flags.is_router;
2438 row->IsUnreachable = dyn->flags.is_unreachable;
2439 row->ReachabilityTime.LastReachable = dyn->time;
2440 }
2441
2442 /******************************************************************
2443 * GetIpNetTable2 (IPHLPAPI.@)
2444 */
2445 DWORD WINAPI GetIpNetTable2( ADDRESS_FAMILY family, MIB_IPNET_TABLE2 **table )
2446 {
2447 void *key[2] = { NULL, NULL };
2448 struct nsi_ip_neighbour_rw *rw[2] = { NULL, NULL };
2449 struct nsi_ip_neighbour_dynamic *dyn[2] = { NULL, NULL };
2450 static const USHORT fam[2] = { AF_INET, AF_INET6 };
2451 static const DWORD key_size[2] = { sizeof(struct nsi_ipv4_neighbour_key), sizeof(struct nsi_ipv6_neighbour_key) };
2452 DWORD err = ERROR_SUCCESS, i, size, count[2] = { 0, 0 };
2453
2454 TRACE( "%u, %p\n", family, table );
2455
2456 if (!table || (family != AF_INET && family != AF_INET6 && family != AF_UNSPEC))
2457 return ERROR_INVALID_PARAMETER;
2458
2459 for (i = 0; i < 2; i++)
2460 {
2461 if (family != AF_UNSPEC && family != fam[i]) continue;
2462
2463 err = NsiAllocateAndGetTable( 1, ip_module_id( fam[i] ), NSI_IP_NEIGHBOUR_TABLE, key + i, key_size[i],
2464 (void **)rw + i, sizeof(**rw), (void **)dyn + i, sizeof(**dyn),
2465 NULL, 0, count + i, 0 );
2466 if (err) count[i] = 0;
2467 }
2468
2469 size = FIELD_OFFSET(MIB_IPNET_TABLE2, Table[ count[0] + count[1] ]);
2470 *table = heap_alloc( size );
2471 if (!*table)
2472 {
2473 err = ERROR_NOT_ENOUGH_MEMORY;
2474 goto err;
2475 }
2476
2477 (*table)->NumEntries = count[0] + count[1];
2478 for (i = 0; i < count[0]; i++)
2479 {
2480 MIB_IPNET_ROW2 *row = (*table)->Table + i;
2481 struct nsi_ipv4_neighbour_key *key4 = (struct nsi_ipv4_neighbour_key *)key[0];
2482
2483 ipnet_row2_fill( row, fam[0], key4 + i, rw[0] + i, dyn[0] + i );
2484 }
2485
2486 for (i = 0; i < count[1]; i++)
2487 {
2488 MIB_IPNET_ROW2 *row = (*table)->Table + count[0] + i;
2489 struct nsi_ipv6_neighbour_key *key6 = (struct nsi_ipv6_neighbour_key *)key[1];
2490
2491 ipnet_row2_fill( row, fam[1], key6 + i, rw[1] + i, dyn[1] + i );
2492 }
2493
2494 err:
2495 for (i = 0; i < 2; i++) NsiFreeTable( key[i], rw[i], dyn[i], NULL );
2496 return err;
2497 }
2498
2499 /******************************************************************
2500 * GetIpStatistics (IPHLPAPI.@)
2501 *
2502 * Get the IP statistics for the local computer.
2503 *
2504 * PARAMS
2505 * stats [Out] buffer for IP statistics
2506 *
2507 * RETURNS
2508 * Success: NO_ERROR
2509 * Failure: error code from winerror.h
2510 */
2511 DWORD WINAPI GetIpStatistics( MIB_IPSTATS *stats )
2512 {
2513 return GetIpStatisticsEx( stats, AF_INET );
2514 }
2515
2516 /******************************************************************
2517 * GetIpStatisticsEx (IPHLPAPI.@)
2518 *
2519 * Get the IPv4 and IPv6 statistics for the local computer.
2520 *
2521 * PARAMS
2522 * stats [Out] buffer for IP statistics
2523 * family [In] specifies whether IPv4 or IPv6 statistics are returned
2524 *
2525 * RETURNS
2526 * Success: NO_ERROR
2527 * Failure: error code from winerror.h
2528 */
2529 DWORD WINAPI GetIpStatisticsEx( MIB_IPSTATS *stats, DWORD family )
2530 {
2531 struct nsi_ip_ipstats_dynamic dyn;
2532 struct nsi_ip_ipstats_static stat;
2533 struct nsi_ip_cmpt_rw cmpt_rw;
2534 struct nsi_ip_cmpt_dynamic cmpt_dyn;
2535 const NPI_MODULEID *mod;
2536 DWORD err, cmpt = 1;
2537
2538 TRACE( "%p %ld\n", stats, family );
2539
2540 if (!stats) return ERROR_INVALID_PARAMETER;
2541 mod = ip_module_id( family );
2542 if (!mod) return ERROR_INVALID_PARAMETER;
2543
2544 memset( stats, 0, sizeof(*stats) );
2545
2546 err = NsiGetAllParameters( 1, mod, NSI_IP_IPSTATS_TABLE, NULL, 0, NULL, 0,
2547 &dyn, sizeof(dyn), &stat, sizeof(stat) );
2548 if (err) return err;
2549
2550 err = NsiGetAllParameters( 1, mod, NSI_IP_COMPARTMENT_TABLE, &cmpt, sizeof(cmpt), &cmpt_rw, sizeof(cmpt_rw),
2551 &cmpt_dyn, sizeof(cmpt_dyn), NULL, 0 );
2552 if (err) return err;
2553
2554 stats->Forwarding = cmpt_rw.not_forwarding + 1;
2555 stats->dwDefaultTTL = cmpt_rw.default_ttl;
2556 stats->dwInReceives = dyn.in_recv;
2557 stats->dwInHdrErrors = dyn.in_hdr_errs;
2558 stats->dwInAddrErrors = dyn.in_addr_errs;
2559 stats->dwForwDatagrams = dyn.fwd_dgrams;
2560 stats->dwInUnknownProtos = dyn.in_unk_protos;
2561 stats->dwInDiscards = dyn.in_discards;
2562 stats->dwInDelivers = dyn.in_delivers;
2563 stats->dwOutRequests = dyn.out_reqs;
2564 stats->dwRoutingDiscards = dyn.routing_discards;
2565 stats->dwOutDiscards = dyn.out_discards;
2566 stats->dwOutNoRoutes = dyn.out_no_routes;
2567 stats->dwReasmTimeout = stat.reasm_timeout;
2568 stats->dwReasmReqds = dyn.reasm_reqds;
2569 stats->dwReasmOks = dyn.reasm_oks;
2570 stats->dwReasmFails = dyn.reasm_fails;
2571 stats->dwFragOks = dyn.frag_oks;
2572 stats->dwFragFails = dyn.frag_fails;
2573 stats->dwFragCreates = dyn.frag_creates;
2574 stats->dwNumIf = cmpt_dyn.num_ifs;
2575 stats->dwNumAddr = cmpt_dyn.num_addrs;
2576 stats->dwNumRoutes = cmpt_dyn.num_routes;
2577
2578 return err;
2579 }
2580
2581 /* Gets the DNS server list into the list beginning at list. Assumes that
2582 * a single server address may be placed at list if *len is at least
2583 * sizeof(IP_ADDR_STRING) long. Otherwise, list->Next is set to firstDynamic,
2584 * and assumes that all remaining DNS servers are contiguously located
2585 * beginning at second. On input, *len is assumed to be the total number
2586 * of bytes available for all DNS servers, and is ignored if list is NULL.
2587 * On return, *len is set to the total number of bytes required for all DNS
2588 * servers.
2589 * Returns ERROR_BUFFER_OVERFLOW if *len is insufficient,
2590 * ERROR_SUCCESS otherwise.
2591 */
2592 static DWORD get_dns_server_list( const NET_LUID *luid, IP_ADDR_STRING *list, IP_ADDR_STRING *second, DWORD *len )
2593 {
2594 char buf[FIELD_OFFSET(IP4_ARRAY, AddrArray[3])];
2595 IP4_ARRAY *servers = (IP4_ARRAY *)buf;
2596 DWORD needed, num, err, i, array_len = sizeof(buf);
2597 IP_ADDR_STRING *ptr;
2598
2599 if (luid && luid->Info.IfType == MIB_IF_TYPE_LOOPBACK) return ERROR_NO_DATA;
2600
2601 for (;;)
2602 {
2603 err = DnsQueryConfig( DnsConfigDnsServerList, 0, NULL, NULL, servers, &array_len );
2604 if (err != ERROR_SUCCESS && err != ERROR_MORE_DATA) goto err;
2605 num = (array_len - FIELD_OFFSET(IP4_ARRAY, AddrArray[0])) / sizeof(IP4_ADDRESS);
2606 needed = num * sizeof(IP_ADDR_STRING);
2607 if (!list || *len < needed)
2608 {
2609 *len = needed;
2610 err = ERROR_BUFFER_OVERFLOW;
2611 goto err;
2612 }
2613 if (!err) break;
2614
2615 if ((char *)servers != buf) heap_free( servers );
2616 servers = heap_alloc( array_len );
2617 if (!servers)
2618 {
2619 err = ERROR_NOT_ENOUGH_MEMORY;
2620 goto err;
2621 }
2622 }
2623
2624 *len = needed;
2625
2626 for (i = 0, ptr = list; i < num; i++, ptr = ptr->Next)
2627 {
2628 RtlIpv4AddressToStringA( (IN_ADDR *)&servers->AddrArray[i], ptr->IpAddress.String );
2629 if (i == num - 1) ptr->Next = NULL;
2630 else if (i == 0) ptr->Next = second;
2631 else ptr->Next = ptr + 1;
2632 }
2633
2634 err:
2635 if ((char *)servers != buf) heap_free( servers );
2636 return err;
2637 }
2638
2639 /******************************************************************
2640 * GetNetworkParams (IPHLPAPI.@)
2641 *
2642 * Get the network parameters for the local computer.
2643 *
2644 * PARAMS
2645 * info [Out] buffer for network parameters
2646 * size [In/Out] length of output buffer
2647 *
2648 * RETURNS
2649 * Success: NO_ERROR
2650 * Failure: error code from winerror.h
2651 *
2652 * NOTES
2653 * If size is less than required, the function will return
2654 * ERROR_INSUFFICIENT_BUFFER, and size will be set to the required byte
2655 * size.
2656 */
2657 DWORD WINAPI GetNetworkParams( FIXED_INFO *info, ULONG *size )
2658 {
2659 DWORD needed = sizeof(*info), dns_size, err;
2660 MIB_IPSTATS ip_stats;
2661 HKEY key;
2662
2663 TRACE( "info %p, size %p\n", info, size );
2664 if (!size) return ERROR_INVALID_PARAMETER;
2665
2666 if (get_dns_server_list( NULL, NULL, NULL, &dns_size ) == ERROR_BUFFER_OVERFLOW)
2667 needed += dns_size - sizeof(IP_ADDR_STRING);
2668 if (!info || *size < needed)
2669 {
2670 *size = needed;
2671 return ERROR_BUFFER_OVERFLOW;
2672 }
2673
2674 *size = needed;
2675 memset( info, 0, needed );
2676 needed = sizeof(info->HostName);
2677 GetComputerNameExA( ComputerNameDnsHostname, info->HostName, &needed );
2678 needed = sizeof(info->DomainName);
2679 GetComputerNameExA( ComputerNameDnsDomain, info->DomainName, &needed );
2680 get_dns_server_list( NULL, &info->DnsServerList, (IP_ADDR_STRING *)(info + 1), &dns_size );
2681 info->CurrentDnsServer = &info->DnsServerList;
2682 info->NodeType = HYBRID_NODETYPE;
2683 err = RegOpenKeyExA( HKEY_LOCAL_MACHINE, "SYSTEM\\CurrentControlSet\\Services\\VxD\\MSTCP",
2684 0, KEY_READ, &key );
2685 if (err)
2686 err = RegOpenKeyExA( HKEY_LOCAL_MACHINE, "SYSTEM\\CurrentControlSet\\Services\\NetBT\\Parameters",
2687 0, KEY_READ, &key );
2688 if (!err)
2689 {
2690 needed = sizeof(info->ScopeId);
2691 RegQueryValueExA( key, "ScopeID", NULL, NULL, (BYTE *)info->ScopeId, &needed );
2692 RegCloseKey( key );
2693 }
2694
2695 if (!GetIpStatistics( &ip_stats ))
2696 info->EnableRouting = (ip_stats.Forwarding == MIB_IP_FORWARDING);
2697
2698 return ERROR_SUCCESS;
2699 }
2700
2701
2702 /******************************************************************
2703 * GetNumberOfInterfaces (IPHLPAPI.@)
2704 *
2705 * Get the number of interfaces.
2706 *
2707 * PARAMS
2708 * pdwNumIf [Out] number of interfaces
2709 *
2710 * RETURNS
2711 * NO_ERROR on success, ERROR_INVALID_PARAMETER if pdwNumIf is NULL.
2712 */
2713 DWORD WINAPI GetNumberOfInterfaces( DWORD *count )
2714 {
2715 DWORD err, num;
2716
2717 TRACE( "count %p\n", count );
2718 if (!count) return ERROR_INVALID_PARAMETER;
2719
2720 err = NsiEnumerateObjectsAllParameters( 1, 1, &NPI_MS_NDIS_MODULEID, NSI_NDIS_IFINFO_TABLE, NULL, 0,
2721 NULL, 0, NULL, 0, NULL, 0, &num );
2722 *count = err ? 0 : num;
2723 return err;
2724 }
2725
2726 /******************************************************************
2727 * GetPerAdapterInfo (IPHLPAPI.@)
2728 *
2729 * Get information about an adapter corresponding to an interface.
2730 *
2731 * PARAMS
2732 * IfIndex [In] interface info
2733 * pPerAdapterInfo [Out] buffer for per adapter info
2734 * pOutBufLen [In/Out] length of output buffer
2735 *
2736 * RETURNS
2737 * Success: NO_ERROR
2738 * Failure: error code from winerror.h
2739 */
2740 DWORD WINAPI GetPerAdapterInfo( ULONG index, IP_PER_ADAPTER_INFO *info, ULONG *size )
2741 {
2742 DWORD needed = sizeof(*info), dns_size;
2743 NET_LUID luid;
2744
2745 TRACE( "(index %ld, info %p, size %p)\n", index, info, size );
2746
2747 if (!size) return ERROR_INVALID_PARAMETER;
2748 if (ConvertInterfaceIndexToLuid( index, &luid )) return ERROR_NO_DATA;
2749
2750 if (get_dns_server_list( &luid, NULL, NULL, &dns_size ) == ERROR_BUFFER_OVERFLOW)
2751 needed += dns_size - sizeof(IP_ADDR_STRING);
2752
2753 if (!info || *size < needed)
2754 {
2755 *size = needed;
2756 return ERROR_BUFFER_OVERFLOW;
2757 }
2758
2759 memset( info, 0, needed );
2760 get_dns_server_list( &luid, &info->DnsServerList, (IP_ADDR_STRING *)(info + 1), &dns_size );
2761 info->CurrentDnsServer = &info->DnsServerList;
2762
2763 /* FIXME Autoconfig: get unicast addresses and compare to 169.254.x.x */
2764 return ERROR_SUCCESS;
2765 }
2766
2767
2768 /******************************************************************
2769 * GetRTTAndHopCount (IPHLPAPI.@)
2770 *
2771 * Get round-trip time (RTT) and hop count.
2772 *
2773 * PARAMS
2774 *
2775 * DestIpAddress [In] destination address to get the info for
2776 * HopCount [Out] retrieved hop count
2777 * MaxHops [In] maximum hops to search for the destination
2778 * RTT [Out] RTT in milliseconds
2779 *
2780 * RETURNS
2781 * Success: TRUE
2782 * Failure: FALSE
2783 *
2784 * FIXME
2785 * Stub, returns FALSE.
2786 */
2787 BOOL WINAPI GetRTTAndHopCount(IPAddr DestIpAddress, PULONG HopCount, ULONG MaxHops, PULONG RTT)
2788 {
2789 FIXME("(DestIpAddress 0x%08lx, HopCount %p, MaxHops %ld, RTT %p): stub\n",
2790 DestIpAddress, HopCount, MaxHops, RTT);
2791 return FALSE;
2792 }
2793
2794 /******************************************************************
2795 * GetTcpStatistics (IPHLPAPI.@)
2796 *
2797 * Get the TCP statistics for the local computer.
2798 *
2799 * PARAMS
2800 * stats [Out] buffer for TCP statistics
2801 *
2802 * RETURNS
2803 * Success: NO_ERROR
2804 * Failure: error code from winerror.h
2805 */
2806 DWORD WINAPI GetTcpStatistics( MIB_TCPSTATS *stats )
2807 {
2808 return GetTcpStatisticsEx( stats, AF_INET );
2809 }
2810
2811 /******************************************************************
2812 * GetTcpStatisticsEx (IPHLPAPI.@)
2813 *
2814 * Get the IPv4 and IPv6 TCP statistics for the local computer.
2815 *
2816 * PARAMS
2817 * stats [Out] buffer for TCP statistics
2818 * family [In] specifies whether IPv4 or IPv6 statistics are returned
2819 *
2820 * RETURNS
2821 * Success: NO_ERROR
2822 * Failure: error code from winerror.h
2823 */
2824 DWORD WINAPI GetTcpStatisticsEx( MIB_TCPSTATS *stats, DWORD family )
2825 {
2826 struct nsi_tcp_stats_dynamic dyn;
2827 struct nsi_tcp_stats_static stat;
2828 USHORT key = (USHORT)family;
2829 DWORD err;
2830
2831 if (!stats || !ip_module_id( family )) return ERROR_INVALID_PARAMETER;
2832 memset( stats, 0, sizeof(*stats) );
2833
2834 err = NsiGetAllParameters( 1, &NPI_MS_TCP_MODULEID, NSI_TCP_STATS_TABLE, &key, sizeof(key), NULL, 0,
2835 &dyn, sizeof(dyn), &stat, sizeof(stat) );
2836 if (err) return err;
2837
2838 stats->RtoAlgorithm = stat.rto_algo;
2839 stats->dwRtoMin = stat.rto_min;
2840 stats->dwRtoMax = stat.rto_max;
2841 stats->dwMaxConn = stat.max_conns;
2842 stats->dwActiveOpens = dyn.active_opens;
2843 stats->dwPassiveOpens = dyn.passive_opens;
2844 stats->dwAttemptFails = dyn.attempt_fails;
2845 stats->dwEstabResets = dyn.est_rsts;
2846 stats->dwCurrEstab = dyn.cur_est;
2847 stats->dwInSegs = (DWORD)dyn.in_segs;
2848 stats->dwOutSegs = (DWORD)dyn.out_segs;
2849 stats->dwRetransSegs = dyn.retrans_segs;
2850 stats->dwInErrs = dyn.in_errs;
2851 stats->dwOutRsts = dyn.out_rsts;
2852 stats->dwNumConns = dyn.num_conns;
2853
2854 return err;
2855 }
2856
2857 #define TCP_TABLE2 ~0u /* Internal tcp table for GetTcp(6)Table2() */
2858
2859 static DWORD tcp_table_id( ULONG table_class )
2860 {
2861 switch (table_class)
2862 {
2863 case TCP_TABLE_BASIC_LISTENER:
2864 case TCP_TABLE_OWNER_PID_LISTENER:
2865 case TCP_TABLE_OWNER_MODULE_LISTENER:
2866 return NSI_TCP_LISTEN_TABLE;
2867
2868 case TCP_TABLE_BASIC_CONNECTIONS:
2869 case TCP_TABLE_OWNER_PID_CONNECTIONS:
2870 case TCP_TABLE_OWNER_MODULE_CONNECTIONS:
2871 return NSI_TCP_ESTAB_TABLE;
2872
2873 case TCP_TABLE_BASIC_ALL:
2874 case TCP_TABLE_OWNER_PID_ALL:
2875 case TCP_TABLE_OWNER_MODULE_ALL:
2876 case TCP_TABLE2:
2877 return NSI_TCP_ALL_TABLE;
2878
2879 default:
2880 ERR( "unhandled class %lu\n", table_class );
2881 return ~0u;
2882 }
2883 }
2884
2885 static DWORD tcp_table_size( ULONG family, ULONG table_class, DWORD row_count, DWORD *row_size )
2886 {
2887 switch (table_class)
2888 {
2889 case TCP_TABLE_BASIC_LISTENER:
2890 case TCP_TABLE_BASIC_CONNECTIONS:
2891 case TCP_TABLE_BASIC_ALL:
2892 *row_size = (family == AF_INET) ? sizeof(MIB_TCPROW) : sizeof(MIB_TCP6ROW);
2893 return (family == AF_INET) ? FIELD_OFFSET(MIB_TCPTABLE, table[row_count]) :
2894 FIELD_OFFSET(MIB_TCP6TABLE, table[row_count]);
2895
2896 case TCP_TABLE_OWNER_PID_LISTENER:
2897 case TCP_TABLE_OWNER_PID_CONNECTIONS:
2898 case TCP_TABLE_OWNER_PID_ALL:
2899 *row_size = (family == AF_INET) ? sizeof(MIB_TCPROW_OWNER_PID) : sizeof(MIB_TCP6ROW_OWNER_PID);
2900 return (family == AF_INET) ? FIELD_OFFSET(MIB_TCPTABLE_OWNER_PID, table[row_count]) :
2901 FIELD_OFFSET(MIB_TCP6TABLE_OWNER_PID, table[row_count]);
2902
2903 case TCP_TABLE_OWNER_MODULE_LISTENER:
2904 case TCP_TABLE_OWNER_MODULE_CONNECTIONS:
2905 case TCP_TABLE_OWNER_MODULE_ALL:
2906 *row_size = (family == AF_INET) ? sizeof(MIB_TCPROW_OWNER_MODULE) : sizeof(MIB_TCP6ROW_OWNER_MODULE);
2907 return (family == AF_INET) ? FIELD_OFFSET(MIB_TCPTABLE_OWNER_MODULE, table[row_count]) :
2908 FIELD_OFFSET(MIB_TCP6TABLE_OWNER_MODULE, table[row_count]);
2909
2910 case TCP_TABLE2:
2911 *row_size = (family == AF_INET) ? sizeof(MIB_TCPROW2) : sizeof(MIB_TCP6ROW2);
2912 return (family == AF_INET) ? FIELD_OFFSET(MIB_TCPTABLE2, table[row_count]) :
2913 FIELD_OFFSET(MIB_TCP6TABLE2, table[row_count]);
2914
2915 default:
2916 ERR( "unhandled class %lu\n", table_class );
2917 return 0;
2918 }
2919 }
2920
2921 static void tcp_row_fill( void *table, DWORD num, ULONG family, ULONG table_class,
2922 struct nsi_tcp_conn_key *key, struct nsi_tcp_conn_dynamic *dyn,
2923 struct nsi_tcp_conn_static *stat )
2924 {
2925 if (family == AF_INET)
2926 {
2927 switch (table_class)
2928 {
2929 case TCP_TABLE_BASIC_LISTENER:
2930 case TCP_TABLE_BASIC_CONNECTIONS:
2931 case TCP_TABLE_BASIC_ALL:
2932 {
2933 MIB_TCPROW *row = ((MIB_TCPTABLE *)table)->table + num;
2934 row->dwState = dyn->state;
2935 row->dwLocalAddr = key->local.Ipv4.sin_addr.s_addr;
2936 row->dwLocalPort = key->local.Ipv4.sin_port;
2937 row->dwRemoteAddr = key->remote.Ipv4.sin_addr.s_addr;
2938 row->dwRemotePort = key->remote.Ipv4.sin_port;
2939 return;
2940 }
2941 case TCP_TABLE_OWNER_PID_LISTENER:
2942 case TCP_TABLE_OWNER_PID_CONNECTIONS:
2943 case TCP_TABLE_OWNER_PID_ALL:
2944 {
2945 MIB_TCPROW_OWNER_PID *row = ((MIB_TCPTABLE_OWNER_PID *)table)->table + num;
2946 row->dwState = dyn->state;
2947 row->dwLocalAddr = key->local.Ipv4.sin_addr.s_addr;
2948 row->dwLocalPort = key->local.Ipv4.sin_port;
2949 row->dwRemoteAddr = key->remote.Ipv4.sin_addr.s_addr;
2950 row->dwRemotePort = key->remote.Ipv4.sin_port;
2951 row->dwOwningPid = stat->pid;
2952 return;
2953 }
2954 case TCP_TABLE_OWNER_MODULE_LISTENER:
2955 case TCP_TABLE_OWNER_MODULE_CONNECTIONS:
2956 case TCP_TABLE_OWNER_MODULE_ALL:
2957 {
2958 MIB_TCPROW_OWNER_MODULE *row = ((MIB_TCPTABLE_OWNER_MODULE *)table)->table + num;
2959 row->dwState = dyn->state;
2960 row->dwLocalAddr = key->local.Ipv4.sin_addr.s_addr;
2961 row->dwLocalPort = key->local.Ipv4.sin_port;
2962 row->dwRemoteAddr = key->remote.Ipv4.sin_addr.s_addr;
2963 row->dwRemotePort = key->remote.Ipv4.sin_port;
2964 row->dwOwningPid = stat->pid;
2965 row->liCreateTimestamp.QuadPart = stat->create_time;
2966 row->OwningModuleInfo[0] = stat->mod_info;
2967 memset( row->OwningModuleInfo + 1, 0, sizeof(row->OwningModuleInfo) - sizeof(row->OwningModuleInfo[0]) );
2968 return;
2969 }
2970 case TCP_TABLE2:
2971 {
2972 MIB_TCPROW2 *row = ((MIB_TCPTABLE2 *)table)->table + num;
2973 row->dwState = dyn->state;
2974 row->dwLocalAddr = key->local.Ipv4.sin_addr.s_addr;
2975 row->dwLocalPort = key->local.Ipv4.sin_port;
2976 row->dwRemoteAddr = key->remote.Ipv4.sin_addr.s_addr;
2977 row->dwRemotePort = key->remote.Ipv4.sin_port;
2978 row->dwOwningPid = stat->pid;
2979 row->dwOffloadState = 0; /* FIXME */
2980 return;
2981 }
2982 default:
2983 ERR( "Unknown class %ld\n", table_class );
2984 return;
2985 }
2986 }
2987 else
2988 {
2989 switch (table_class)
2990 {
2991 case TCP_TABLE_BASIC_LISTENER:
2992 case TCP_TABLE_BASIC_CONNECTIONS:
2993 case TCP_TABLE_BASIC_ALL:
2994 {
2995 MIB_TCP6ROW *row = ((MIB_TCP6TABLE *)table)->table + num;
2996 row->State = dyn->state;
2997 memcpy( &row->LocalAddr, &key->local.Ipv6.sin6_addr, sizeof(row->LocalAddr) );
2998 row->dwLocalScopeId = key->local.Ipv6.sin6_scope_id;
2999 row->dwLocalPort = key->local.Ipv6.sin6_port;
3000 memcpy( &row->RemoteAddr, &key->remote.Ipv6.sin6_addr, sizeof(row->RemoteAddr) );
3001 row->dwRemoteScopeId = key->remote.Ipv6.sin6_scope_id;
3002 row->dwRemotePort = key->remote.Ipv6.sin6_port;
3003 return;
3004 }
3005 case TCP_TABLE_OWNER_PID_LISTENER:
3006 case TCP_TABLE_OWNER_PID_CONNECTIONS:
3007 case TCP_TABLE_OWNER_PID_ALL:
3008 {
3009 MIB_TCP6ROW_OWNER_PID *row = ((MIB_TCP6TABLE_OWNER_PID *)table)->table + num;
3010 memcpy( &row->ucLocalAddr, &key->local.Ipv6.sin6_addr, sizeof(row->ucLocalAddr) );
3011 row->dwLocalScopeId = key->local.Ipv6.sin6_scope_id;
3012 row->dwLocalPort = key->local.Ipv6.sin6_port;
3013 memcpy( &row->ucRemoteAddr, &key->remote.Ipv6.sin6_addr, sizeof(row->ucRemoteAddr) );
3014 row->dwRemoteScopeId = key->remote.Ipv6.sin6_scope_id;
3015 row->dwRemotePort = key->remote.Ipv6.sin6_port;
3016 row->dwState = dyn->state;
3017 row->dwOwningPid = stat->pid;
3018 return;
3019 }
3020 case TCP_TABLE_OWNER_MODULE_LISTENER:
3021 case TCP_TABLE_OWNER_MODULE_CONNECTIONS:
3022 case TCP_TABLE_OWNER_MODULE_ALL:
3023 {
3024 MIB_TCP6ROW_OWNER_MODULE *row = ((MIB_TCP6TABLE_OWNER_MODULE *)table)->table + num;
3025 memcpy( &row->ucLocalAddr, &key->local.Ipv6.sin6_addr, sizeof(row->ucLocalAddr) );
3026 row->dwLocalScopeId = key->local.Ipv6.sin6_scope_id;
3027 row->dwLocalPort = key->local.Ipv6.sin6_port;
3028 memcpy( &row->ucRemoteAddr, &key->remote.Ipv6.sin6_addr, sizeof(row->ucRemoteAddr) );
3029 row->dwRemoteScopeId = key->remote.Ipv6.sin6_scope_id;
3030 row->dwRemotePort = key->remote.Ipv6.sin6_port;
3031 row->dwState = dyn->state;
3032 row->dwOwningPid = stat->pid;
3033 row->liCreateTimestamp.QuadPart = stat->create_time;
3034 row->OwningModuleInfo[0] = stat->mod_info;
3035 memset( row->OwningModuleInfo + 1, 0, sizeof(row->OwningModuleInfo) - sizeof(row->OwningModuleInfo[0]) );
3036 return;
3037 }
3038 case TCP_TABLE2:
3039 {
3040 MIB_TCP6ROW2 *row = ((MIB_TCP6TABLE2 *)table)->table + num;
3041 memcpy( &row->LocalAddr, &key->local.Ipv6.sin6_addr, sizeof(row->LocalAddr) );
3042 row->dwLocalScopeId = key->local.Ipv6.sin6_scope_id;
3043 row->dwLocalPort = key->local.Ipv6.sin6_port;
3044 memcpy( &row->RemoteAddr, &key->remote.Ipv6.sin6_addr, sizeof(row->RemoteAddr) );
3045 row->dwRemoteScopeId = key->remote.Ipv6.sin6_scope_id;
3046 row->dwRemotePort = key->remote.Ipv6.sin6_port;
3047 row->State = dyn->state;
3048 row->dwOwningPid = stat->pid;
3049 row->dwOffloadState = 0; /* FIXME */
3050 return;
3051 }
3052 default:
3053 ERR( "Unknown class %ld\n", table_class );
3054 return;
3055 }
3056 }
3057 ERR( "Unknown family %ld\n", family );
3058 }
3059
3060 static int tcp_row_cmp( const void *a, const void *b )
3061 {
3062 const MIB_TCPROW *rowA = a, *rowB = b;
3063 int ret;
3064
3065 if ((ret = DWORD_cmp(RtlUshortByteSwap( rowA->dwLocalAddr ), RtlUshortByteSwap( rowB->dwLocalAddr ))) != 0) return ret;
3066 if ((ret = RtlUshortByteSwap( rowA->dwLocalPort ) - RtlUshortByteSwap( rowB->dwLocalPort )) != 0) return ret;
3067 if ((ret = DWORD_cmp(RtlUshortByteSwap( rowA->dwRemoteAddr ), RtlUshortByteSwap( rowB->dwRemoteAddr ))) != 0) return ret;
3068 return RtlUshortByteSwap( rowA->dwRemotePort ) - RtlUshortByteSwap( rowB->dwRemotePort );
3069 }
3070
3071 static int tcp6_row_basic_cmp( const void *a, const void *b )
3072 {
3073 const MIB_TCP6ROW *rowA = a;
3074 const MIB_TCP6ROW *rowB = b;
3075 int ret;
3076
3077 if ((ret = memcmp( &rowA->LocalAddr, &rowB->LocalAddr, sizeof(rowA->LocalAddr) )) != 0) return ret;
3078 if ((ret = rowA->dwLocalScopeId - rowB->dwLocalScopeId) != 0) return ret;
3079 if ((ret = RtlUshortByteSwap( rowA->dwLocalPort ) - RtlUshortByteSwap( rowB->dwLocalPort )) != 0) return ret;
3080 if ((ret = memcmp( &rowA->RemoteAddr, &rowB->RemoteAddr, sizeof(rowA->RemoteAddr) )) != 0) return ret;
3081 if ((ret = rowA->dwRemoteScopeId - rowB->dwRemoteScopeId) != 0) return ret;
3082 return RtlUshortByteSwap( rowA->dwRemotePort ) - RtlUshortByteSwap( rowB->dwRemotePort );
3083 }
3084
3085 static int tcp6_row_owner_cmp( const void *a, const void *b )
3086 {
3087 const MIB_TCP6ROW_OWNER_PID *rowA = a;
3088 const MIB_TCP6ROW_OWNER_PID *rowB = b;
3089 int ret;
3090
3091 if ((ret = memcmp( &rowA->ucLocalAddr, &rowB->ucLocalAddr, sizeof(rowA->ucLocalAddr) )) != 0) return ret;
3092 if ((ret = rowA->dwLocalScopeId - rowB->dwLocalScopeId) != 0) return ret;
3093 if ((ret = RtlUshortByteSwap( rowA->dwLocalPort ) - RtlUshortByteSwap( rowB->dwLocalPort )) != 0) return ret;
3094 if ((ret = memcmp( &rowA->ucRemoteAddr, &rowB->ucRemoteAddr, sizeof(rowA->ucRemoteAddr) )) != 0) return ret;
3095 if ((ret = rowA->dwRemoteScopeId - rowB->dwRemoteScopeId) != 0) return ret;
3096 return RtlUshortByteSwap( rowA->dwRemotePort ) - RtlUshortByteSwap( rowB->dwRemotePort );
3097 }
3098
3099 static BOOL tcp_table_needs_pids( ULONG table_class )
3100 {
3101 switch (table_class)
3102 {
3103 case TCP_TABLE_BASIC_LISTENER:
3104 case TCP_TABLE_BASIC_CONNECTIONS:
3105 case TCP_TABLE_BASIC_ALL:
3106 return FALSE;
3107
3108 }
3109 return TRUE;
3110 }
3111
3112 /*************************************************************************************
3113 * get_extended_tcp_table
3114 *
3115 * Implementation of GetExtendedTcpTable() which additionally handles TCP_TABLE2
3116 * corresponding to GetTcp(6)Table2()
3117 */
3118 static DWORD get_extended_tcp_table( void *table, DWORD *size, BOOL sort, ULONG family, ULONG table_class )
3119 {
3120 DWORD err, count, needed, i, num = 0, row_size = 0;
3121 struct nsi_tcp_conn_key *key;
3122 struct nsi_tcp_conn_dynamic *dyn;
3123 struct nsi_tcp_conn_static *stat = NULL;
3124
3125 if (!size) return ERROR_INVALID_PARAMETER;
3126
3127 if (tcp_table_needs_pids( table_class ))
3128 err = NsiAllocateAndGetTable( 1, &NPI_MS_TCP_MODULEID, tcp_table_id( table_class ), (void **)&key, sizeof(*key),
3129 NULL, 0, (void **)&dyn, sizeof(*dyn),
3130 (void **)&stat, sizeof(*stat), &count, 0 );
3131 else /* Don't retrieve the static data if not required as this is expensive to compute */
3132 err = NsiAllocateAndGetTable( 1, &NPI_MS_TCP_MODULEID, tcp_table_id( table_class ), (void **)&key, sizeof(*key),
3133 NULL, 0, (void **)&dyn, sizeof(*dyn),
3134 NULL, 0, &count, 0 );
3135
3136 if (err) return err;
3137
3138 for (i = 0; i < count; i++)
3139 if (key[i].local.si_family == family)
3140 num++;
3141
3142 needed = tcp_table_size( family, table_class, num, &row_size );
3143 if (!table || *size < needed)
3144 {
3145 *size = needed;
3146 err = ERROR_INSUFFICIENT_BUFFER;
3147 }
3148 else
3149 {
3150 *size = needed;
3151 *(DWORD *)table = num;
3152 num = 0;
3153 for (i = 0; i < count; i++)
3154 {
3155 if (key[i].local.si_family != family) continue;
3156 tcp_row_fill( table, num++, family, table_class, key + i, dyn + i, stat + i );
3157 }
3158 }
3159
3160 if (!err && sort)
3161 {
3162 int (*fn)(const void *, const void *);
3163 DWORD offset;
3164
3165 if (family == AF_INET) fn = tcp_row_cmp;
3166 else if (row_size == sizeof(MIB_TCP6ROW)) fn = tcp6_row_basic_cmp;
3167 else fn = tcp6_row_owner_cmp;
3168
3169 offset = tcp_table_size( family, table_class, 0, &row_size );
3170 qsort( (BYTE *)table + offset, num, row_size, fn );
3171 }
3172
3173 NsiFreeTable( key, NULL, dyn, stat );
3174 return err;
3175 }
3176
3177 /******************************************************************
3178 * GetExtendedTcpTable (IPHLPAPI.@)
3179 */
3180 DWORD WINAPI GetExtendedTcpTable( void *table, DWORD *size, BOOL sort, ULONG family,
3181 TCP_TABLE_CLASS table_class, ULONG reserved )
3182 {
3183 TRACE( "table %p, size %p, sort %d, family %lu, class %u, reserved %lu\n",
3184 table, size, sort, family, table_class, reserved );
3185
3186 if (!ip_module_id( family )) return ERROR_INVALID_PARAMETER;
3187 return get_extended_tcp_table( table, size, sort, family, table_class );
3188 }
3189
3190 /******************************************************************
3191 * GetTcpTable (IPHLPAPI.@)
3192 *
3193 * Get the table of active TCP connections.
3194 *
3195 * PARAMS
3196 * table [Out] buffer for TCP connections table
3197 * size [In/Out] length of output buffer
3198 * sort [In] whether to order the table
3199 *
3200 * RETURNS
3201 * Success: NO_ERROR
3202 * Failure: error code from winerror.h
3203 *
3204 * NOTES
3205 * If size is less than required, the function will return
3206 * ERROR_INSUFFICIENT_BUFFER, and *size will be set to
3207 * the required byte size.
3208 * If sort is true, the returned table will be sorted, first by
3209 * local address and port number, then by remote address and port
3210 * number.
3211 */
3212 DWORD WINAPI GetTcpTable( MIB_TCPTABLE *table, DWORD *size, BOOL sort )
3213 {
3214 TRACE( "table %p, size %p, sort %d\n", table, size, sort );
3215 return get_extended_tcp_table( table, size, sort, AF_INET, TCP_TABLE_BASIC_ALL );
3216 }
3217
3218 /******************************************************************
3219 * GetTcp6Table (IPHLPAPI.@)
3220 */
3221 ULONG WINAPI GetTcp6Table( MIB_TCP6TABLE *table, ULONG *size, BOOL sort )
3222 {
3223 TRACE( "table %p, size %p, sort %d\n", table, size, sort );
3224 return get_extended_tcp_table( table, size, sort, AF_INET6, TCP_TABLE_BASIC_ALL );
3225 }
3226
3227 /******************************************************************
3228 * GetTcpTable2 (IPHLPAPI.@)
3229 */
3230 ULONG WINAPI GetTcpTable2( MIB_TCPTABLE2 *table, ULONG *size, BOOL sort )
3231 {
3232 TRACE( "table %p, size %p, sort %d\n", table, size, sort );
3233 return get_extended_tcp_table( table, size, sort, AF_INET, TCP_TABLE2 );
3234 }
3235
3236 /******************************************************************
3237 * GetTcp6Table2 (IPHLPAPI.@)
3238 */
3239 ULONG WINAPI GetTcp6Table2( MIB_TCP6TABLE2 *table, ULONG *size, BOOL sort )
3240 {
3241 TRACE( "table %p, size %p, sort %d\n", table, size, sort );
3242 return get_extended_tcp_table( table, size, sort, AF_INET6, TCP_TABLE2 );
3243 }
3244
3245 static DWORD allocate_tcp_table( void **table, BOOL sort, HANDLE heap, DWORD flags,
3246 ULONG family, ULONG table_class )
3247 {
3248 DWORD err, size = 0x100, attempt;
3249
3250 for (attempt = 0; attempt < 5; attempt++)
3251 {
3252 *table = HeapAlloc( heap, flags, size );
3253 if (!*table) return ERROR_NOT_ENOUGH_MEMORY;
3254 err = get_extended_tcp_table( *table, &size, sort, family, table_class );
3255 if (!err) break;
3256 HeapFree( heap, flags, *table );
3257 *table = NULL;
3258 if (err != ERROR_INSUFFICIENT_BUFFER) break;
3259 }
3260 return err;
3261 }
3262
3263 /******************************************************************
3264 * AllocateAndGetTcpTableFromStack (IPHLPAPI.@)
3265 */
3266 DWORD WINAPI AllocateAndGetTcpTableFromStack( MIB_TCPTABLE **table, BOOL sort, HANDLE heap, DWORD flags )
3267 {
3268 TRACE( "table %p, sort %d, heap %p, flags 0x%08lx\n", table, sort, heap, flags );
3269
3270 if (!table) return ERROR_INVALID_PARAMETER;
3271
3272 return allocate_tcp_table( (void **)table, sort, heap, flags, AF_INET, TCP_TABLE_BASIC_ALL );
3273 }
3274
3275 /******************************************************************
3276 * AllocateAndGetTcpExTableFromStack (IPHLPAPI.@)
3277 */
3278 DWORD WINAPI AllocateAndGetTcpExTableFromStack( void **table, BOOL sort, HANDLE heap, DWORD flags, DWORD family )
3279 {
3280 TRACE( "table %p, sort %d, heap %p, flags 0x%08lx, family %lu\n", table, sort, heap, flags, family );
3281
3282 if (!table || !ip_module_id( family )) return ERROR_INVALID_PARAMETER;
3283 if (family == AF_INET6) return ERROR_NOT_SUPPORTED;
3284
3285 return allocate_tcp_table( table, sort, heap, flags, family, TCP_TABLE_OWNER_PID_ALL );
3286 }
3287
3288 /******************************************************************
3289 * GetUdpStatistics (IPHLPAPI.@)
3290 *
3291 * Get the UDP statistics for the local computer.
3292 *
3293 * PARAMS
3294 * stats [Out] buffer for UDP statistics
3295 */
3296 DWORD WINAPI GetUdpStatistics( MIB_UDPSTATS *stats )
3297 {
3298 return GetUdpStatisticsEx( stats, AF_INET );
3299 }
3300
3301 /******************************************************************
3302 * GetUdpStatisticsEx (IPHLPAPI.@)
3303 *
3304 * Get the IPv4 and IPv6 UDP statistics for the local computer.
3305 *
3306 * PARAMS
3307 * stats [Out] buffer for UDP statistics
3308 * family [In] specifies whether IPv4 or IPv6 statistics are returned
3309 *
3310 * RETURNS
3311 * Success: NO_ERROR
3312 * Failure: error code from winerror.h
3313 */
3314 DWORD WINAPI GetUdpStatisticsEx( MIB_UDPSTATS *stats, DWORD family )
3315 {
3316 struct nsi_udp_stats_dynamic dyn;
3317 USHORT key = (USHORT)family;
3318 DWORD err;
3319
3320 if (!stats || !ip_module_id( family )) return ERROR_INVALID_PARAMETER;
3321 memset( stats, 0, sizeof(*stats) );
3322
3323 err = NsiGetAllParameters( 1, &NPI_MS_UDP_MODULEID, NSI_UDP_STATS_TABLE, &key, sizeof(key), NULL, 0,
3324 &dyn, sizeof(dyn), NULL, 0 );
3325 if (err) return err;
3326
3327 stats->dwInDatagrams = dyn.in_dgrams;
3328 stats->dwNoPorts = dyn.no_ports;
3329 stats->dwInErrors = dyn.in_errs;
3330 stats->dwOutDatagrams = dyn.out_dgrams;
3331 stats->dwNumAddrs = dyn.num_addrs;
3332 return err;
3333 }
3334
3335 /******************************************************************
3336 * GetUdpTable (IPHLPAPI.@)
3337 *
3338 * Get a table of active UDP connections.
3339 *
3340 * PARAMS
3341 * table [Out] buffer for UDP connections table
3342 * size [In/Out] length of output buffer
3343 * sort [In] whether to order the table
3344 *
3345 */
3346 DWORD WINAPI GetUdpTable( MIB_UDPTABLE *table, DWORD *size, BOOL sort )
3347 {
3348 return GetExtendedUdpTable( table, size, sort, AF_INET, UDP_TABLE_BASIC, 0 );
3349 }
3350
3351 /******************************************************************
3352 * GetUdp6Table (IPHLPAPI.@)
3353 */
3354 DWORD WINAPI GetUdp6Table( MIB_UDP6TABLE *table, DWORD *size, BOOL sort )
3355 {
3356 return GetExtendedUdpTable( table, size, sort, AF_INET6, UDP_TABLE_BASIC, 0 );
3357 }
3358
3359 static DWORD udp_table_size( ULONG family, ULONG table_class, DWORD row_count, DWORD *row_size )
3360 {
3361 switch (table_class)
3362 {
3363 case UDP_TABLE_BASIC:
3364 *row_size = (family == AF_INET) ? sizeof(MIB_UDPROW) : sizeof(MIB_UDP6ROW);
3365 return (family == AF_INET) ? FIELD_OFFSET(MIB_UDPTABLE, table[row_count]) :
3366 FIELD_OFFSET(MIB_UDP6TABLE, table[row_count]);
3367
3368 case UDP_TABLE_OWNER_PID:
3369 *row_size = (family == AF_INET) ? sizeof(MIB_UDPROW_OWNER_PID) : sizeof(MIB_UDP6ROW_OWNER_PID);
3370 return (family == AF_INET) ? FIELD_OFFSET(MIB_UDPTABLE_OWNER_PID, table[row_count]) :
3371 FIELD_OFFSET(MIB_UDP6TABLE_OWNER_PID, table[row_count]);
3372
3373 case UDP_TABLE_OWNER_MODULE:
3374 *row_size = (family == AF_INET) ? sizeof(MIB_UDPROW_OWNER_MODULE) : sizeof(MIB_UDP6ROW_OWNER_MODULE);
3375 return (family == AF_INET) ? FIELD_OFFSET(MIB_UDPTABLE_OWNER_MODULE, table[row_count]) :
3376 FIELD_OFFSET(MIB_UDP6TABLE_OWNER_MODULE, table[row_count]);
3377
3378 default:
3379 ERR( "unhandled class %lu\n", table_class );
3380 return 0;
3381 }
3382 }
3383
3384 static void udp_row_fill( void *table, DWORD num, ULONG family, ULONG table_class,
3385 struct nsi_udp_endpoint_key *key,
3386 struct nsi_udp_endpoint_static *stat )
3387 {
3388 if (family == AF_INET)
3389 {
3390 switch (table_class)
3391 {
3392 case UDP_TABLE_BASIC:
3393 {
3394 MIB_UDPROW *row = ((MIB_UDPTABLE *)table)->table + num;
3395 row->dwLocalAddr = key->local.Ipv4.sin_addr.s_addr;
3396 row->dwLocalPort = key->local.Ipv4.sin_port;
3397 return;
3398 }
3399 case UDP_TABLE_OWNER_PID:
3400 {
3401 MIB_UDPROW_OWNER_PID *row = ((MIB_UDPTABLE_OWNER_PID *)table)->table + num;
3402 row->dwLocalAddr = key->local.Ipv4.sin_addr.s_addr;
3403 row->dwLocalPort = key->local.Ipv4.sin_port;
3404 row->dwOwningPid = stat->pid;
3405 return;
3406 }
3407 case UDP_TABLE_OWNER_MODULE:
3408 {
3409 MIB_UDPROW_OWNER_MODULE *row = ((MIB_UDPTABLE_OWNER_MODULE *)table)->table + num;
3410 row->dwLocalAddr = key->local.Ipv4.sin_addr.s_addr;
3411 row->dwLocalPort = key->local.Ipv4.sin_port;
3412 row->dwOwningPid = stat->pid;
3413 row->liCreateTimestamp.QuadPart = stat->create_time;
3414 row->dwFlags = stat->flags;
3415 row->OwningModuleInfo[0] = stat->mod_info;
3416 memset( row->OwningModuleInfo + 1, 0, sizeof(row->OwningModuleInfo) - sizeof(row->OwningModuleInfo[0]) );
3417 return;
3418 }
3419 default:
3420 ERR( "Unknown class %ld\n", table_class );
3421 return;
3422 }
3423 }
3424 else
3425 {
3426 switch (table_class)
3427 {
3428 case UDP_TABLE_BASIC:
3429 {
3430 MIB_UDP6ROW *row = ((MIB_UDP6TABLE *)table)->table + num;
3431 memcpy( &row->dwLocalAddr, &key->local.Ipv6.sin6_addr, sizeof(row->dwLocalAddr) );
3432 row->dwLocalScopeId = key->local.Ipv6.sin6_scope_id;
3433 row->dwLocalPort = key->local.Ipv6.sin6_port;
3434 return;
3435 }
3436 case UDP_TABLE_OWNER_PID:
3437 {
3438 MIB_UDP6ROW_OWNER_PID *row = ((MIB_UDP6TABLE_OWNER_PID *)table)->table + num;
3439 memcpy( &row->ucLocalAddr, &key->local.Ipv6.sin6_addr, sizeof(row->ucLocalAddr) );
3440 row->dwLocalScopeId = key->local.Ipv6.sin6_scope_id;
3441 row->dwLocalPort = key->local.Ipv6.sin6_port;
3442 row->dwOwningPid = stat->pid;
3443 return;
3444 }
3445 case UDP_TABLE_OWNER_MODULE:
3446 {
3447 MIB_UDP6ROW_OWNER_MODULE *row = ((MIB_UDP6TABLE_OWNER_MODULE *)table)->table + num;
3448 memcpy( &row->ucLocalAddr, &key->local.Ipv6.sin6_addr, sizeof(row->ucLocalAddr) );
3449 row->dwLocalScopeId = key->local.Ipv6.sin6_scope_id;
3450 row->dwLocalPort = key->local.Ipv6.sin6_port;
3451 row->dwOwningPid = stat->pid;
3452 row->liCreateTimestamp.QuadPart = stat->create_time;
3453 row->dwFlags = stat->flags;
3454 row->OwningModuleInfo[0] = stat->mod_info;
3455 memset( row->OwningModuleInfo + 1, 0, sizeof(row->OwningModuleInfo) - sizeof(row->OwningModuleInfo[0]) );
3456 return;
3457 }
3458 default:
3459 ERR( "Unknown class %ld\n", table_class );
3460 return;
3461 }
3462 }
3463 ERR( "Unknown family %ld\n", family );
3464 return;
3465 }
3466
3467 static int udp_row_cmp( const void *a, const void *b )
3468 {
3469 const MIB_UDPROW *rowA = a, *rowB = b;
3470
3471 return DWORD_cmp(RtlUlongByteSwap( rowA->dwLocalAddr), RtlUlongByteSwap( rowB->dwLocalAddr )) ||
3472 RtlUshortByteSwap( rowA->dwLocalPort ) - RtlUshortByteSwap( rowB->dwLocalPort );
3473 }
3474
3475 static int udp6_row_cmp( const void *a, const void *b )
3476 {
3477 const MIB_UDP6ROW *rowA = a;
3478 const MIB_UDP6ROW *rowB = b;
3479 int ret;
3480
3481 if ((ret = memcmp( &rowA->dwLocalAddr, &rowB->dwLocalAddr, sizeof(rowA->dwLocalAddr) )) != 0) return ret;
3482 if ((ret = rowA->dwLocalScopeId - rowB->dwLocalScopeId) != 0) return ret;
3483 return RtlUshortByteSwap( rowA->dwLocalPort ) - RtlUshortByteSwap( rowB->dwLocalPort );
3484 }
3485
3486 /******************************************************************
3487 * GetExtendedUdpTable (IPHLPAPI.@)
3488 */
3489 DWORD WINAPI GetExtendedUdpTable( void *table, DWORD *size, BOOL sort, ULONG family,
3490 UDP_TABLE_CLASS table_class, ULONG reserved )
3491 {
3492 DWORD err, count, needed, i, num = 0, row_size = 0;
3493 struct nsi_udp_endpoint_key *key;
3494 struct nsi_udp_endpoint_static *stat;
3495
3496 TRACE( "table %p, size %p, sort %d, family %lu, table_class %u, reserved %lu\n",
3497 table, size, sort, family, table_class, reserved );
3498
3499 if (!size || !ip_module_id( family )) return ERROR_INVALID_PARAMETER;
3500
3501 err = NsiAllocateAndGetTable( 1, &NPI_MS_UDP_MODULEID, NSI_UDP_ENDPOINT_TABLE, (void **)&key, sizeof(*key),
3502 NULL, 0, NULL, 0, (void **)&stat, sizeof(*stat), &count, 0 );
3503 if (err) return err;
3504
3505 for (i = 0; i < count; i++)
3506 if (key[i].local.si_family == family)
3507 num++;
3508
3509 needed = udp_table_size( family, table_class, num, &row_size );
3510 if (!table || *size < needed)
3511 {
3512 *size = needed;
3513 err = ERROR_INSUFFICIENT_BUFFER;
3514 }
3515 else
3516 {
3517 *size = needed;
3518 *(DWORD *)table = num;
3519 num = 0;
3520 for (i = 0; i < count; i++)
3521 {
3522 if (key[i].local.si_family != family) continue;
3523 udp_row_fill( table, num++, family, table_class, key + i, stat + i );
3524 }
3525 }
3526
3527 if (!err && sort)
3528 {
3529 int (*fn)(const void *, const void *);
3530 DWORD offset = udp_table_size( family, table_class, 0, &row_size );
3531
3532 if (family == AF_INET) fn = udp_row_cmp;
3533 else fn = udp6_row_cmp;
3534
3535 qsort( (BYTE *)table + offset, num, row_size, fn );
3536 }
3537
3538 NsiFreeTable( key, NULL, NULL, stat );
3539 return err;
3540 }
3541
3542 DWORD WINAPI AllocateAndGetUdpTableFromStack( MIB_UDPTABLE **table, BOOL sort, HANDLE heap, DWORD flags )
3543 {
3544 DWORD err, size = 0x100, attempt;
3545
3546 TRACE("table %p, sort %d, heap %p, flags 0x%08lx\n", table, sort, heap, flags );
3547
3548 if (!table) return ERROR_INVALID_PARAMETER;
3549
3550 for (attempt = 0; attempt < 5; attempt++)
3551 {
3552 *table = HeapAlloc( heap, flags, size );
3553 if (!*table) return ERROR_NOT_ENOUGH_MEMORY;
3554 err = GetExtendedUdpTable( *table, &size, sort, AF_INET, UDP_TABLE_BASIC, 0 );
3555 if (!err) break;
3556 HeapFree( heap, flags, *table );
3557 *table = NULL;
3558 if (err != ERROR_INSUFFICIENT_BUFFER) break;
3559 }
3560 return err;
3561 }
3562
3563 static void unicast_row_fill( MIB_UNICASTIPADDRESS_ROW *row, USHORT fam, void *key, struct nsi_ip_unicast_rw *rw,
3564 struct nsi_ip_unicast_dynamic *dyn, struct nsi_ip_unicast_static *stat )
3565 {
3566 struct nsi_ipv4_unicast_key *key4 = (struct nsi_ipv4_unicast_key *)key;
3567 struct nsi_ipv6_unicast_key *key6 = (struct nsi_ipv6_unicast_key *)key;
3568
3569 if (fam == AF_INET)
3570 {
3571 row->Address.Ipv4.sin_family = fam;
3572 row->Address.Ipv4.sin_port = 0;
3573 row->Address.Ipv4.sin_addr = key4->addr;
3574 memset( row->Address.Ipv4.sin_zero, 0, sizeof(row->Address.Ipv4.sin_zero) );
3575 row->InterfaceLuid.Value = key4->luid.Value;
3576 }
3577 else
3578 {
3579 row->Address.Ipv6.sin6_family = fam;
3580 row->Address.Ipv6.sin6_port = 0;
3581 row->Address.Ipv6.sin6_flowinfo = 0;
3582 row->Address.Ipv6.sin6_addr = key6->addr;
3583 row->Address.Ipv6.sin6_scope_id = dyn->scope_id;
3584 row->InterfaceLuid.Value = key6->luid.Value;
3585 }
3586
3587 ConvertInterfaceLuidToIndex( &row->InterfaceLuid, &row->InterfaceIndex );
3588 row->PrefixOrigin = rw->prefix_origin;
3589 row->SuffixOrigin = rw->suffix_origin;
3590 row->ValidLifetime = rw->valid_lifetime;
3591 row->PreferredLifetime = rw->preferred_lifetime;
3592 row->OnLinkPrefixLength = rw->on_link_prefix;
3593 row->SkipAsSource = 0;
3594 row->DadState = dyn->dad_state;
3595 row->ScopeId.Value = dyn->scope_id;
3596 row->CreationTimeStamp.QuadPart = stat->creation_time;
3597 }
3598
3599 DWORD WINAPI GetUnicastIpAddressEntry(MIB_UNICASTIPADDRESS_ROW *row)
3600 {
3601 struct nsi_ipv4_unicast_key key4;
3602 struct nsi_ipv6_unicast_key key6;
3603 struct nsi_ip_unicast_rw rw;
3604 struct nsi_ip_unicast_dynamic dyn;
3605 struct nsi_ip_unicast_static stat;
3606 const NPI_MODULEID *mod;
3607 DWORD err, key_size;
3608 void *key;
3609
3610 TRACE( "%p\n", row );
3611
3612 if (!row) return ERROR_INVALID_PARAMETER;
3613 mod = ip_module_id( row->Address.si_family );
3614 if (!mod) return ERROR_INVALID_PARAMETER;
3615
3616 if (!row->InterfaceLuid.Value)
3617 {
3618 err = ConvertInterfaceIndexToLuid( row->InterfaceIndex, &row->InterfaceLuid );
3619 if (err) return err;
3620 }
3621
3622 if (row->Address.si_family == AF_INET)
3623 {
3624 key4.luid = row->InterfaceLuid;
3625 key4.addr = row->Address.Ipv4.sin_addr;
3626 key4.pad = 0;
3627 key = &key4;
3628 key_size = sizeof(key4);
3629 }
3630 else if (row->Address.si_family == AF_INET6)
3631 {
3632 key6.luid = row->InterfaceLuid;
3633 key6.addr = row->Address.Ipv6.sin6_addr;
3634 key = &key6;
3635 key_size = sizeof(key6);
3636 }
3637 else return ERROR_INVALID_PARAMETER;
3638
3639 err = NsiGetAllParameters( 1, mod, NSI_IP_UNICAST_TABLE, key, key_size, &rw, sizeof(rw),
3640 &dyn, sizeof(dyn), &stat, sizeof(stat) );
3641 if (!err) unicast_row_fill( row, row->Address.si_family, key, &rw, &dyn, &stat );
3642 return err;
3643 }
3644
3645 DWORD WINAPI GetUnicastIpAddressTable(ADDRESS_FAMILY family, MIB_UNICASTIPADDRESS_TABLE **table)
3646 {
3647 void *key[2] = { NULL, NULL };
3648 struct nsi_ip_unicast_rw *rw[2] = { NULL, NULL };
3649 struct nsi_ip_unicast_dynamic *dyn[2] = { NULL, NULL };
3650 struct nsi_ip_unicast_static *stat[2] = { NULL, NULL };
3651 static const USHORT fam[2] = { AF_INET, AF_INET6 };
3652 static const DWORD key_size[2] = { sizeof(struct nsi_ipv4_unicast_key), sizeof(struct nsi_ipv6_unicast_key) };
3653 DWORD err, i, size, count[2] = { 0, 0 };
3654
3655 TRACE( "%u, %p\n", family, table );
3656
3657 if (!table || (family != AF_INET && family != AF_INET6 && family != AF_UNSPEC))
3658 return ERROR_INVALID_PARAMETER;
3659
3660 for (i = 0; i < 2; i++)
3661 {
3662 if (family != AF_UNSPEC && family != fam[i]) continue;
3663
3664 err = NsiAllocateAndGetTable( 1, ip_module_id( fam[i] ), NSI_IP_UNICAST_TABLE, key + i, key_size[i],
3665 (void **)rw + i, sizeof(**rw), (void **)dyn + i, sizeof(**dyn),
3666 (void **)stat + i, sizeof(**stat), count + i, 0 );
3667 if (err) goto err;
3668 }
3669
3670 size = FIELD_OFFSET(MIB_UNICASTIPADDRESS_TABLE, Table[ count[0] + count[1] ]);
3671 *table = heap_alloc( size );
3672 if (!*table)
3673 {
3674 err = ERROR_NOT_ENOUGH_MEMORY;
3675 goto err;
3676 }
3677
3678 (*table)->NumEntries = count[0] + count[1];
3679 for (i = 0; i < count[0]; i++)
3680 {
3681 MIB_UNICASTIPADDRESS_ROW *row = (*table)->Table + i;
3682 struct nsi_ipv4_unicast_key *key4 = (struct nsi_ipv4_unicast_key *)key[0];
3683
3684 unicast_row_fill( row, fam[0], (void *)(key4 + i), rw[0] + i, dyn[0] + i, stat[0] + i );
3685 }
3686
3687 for (i = 0; i < count[1]; i++)
3688 {
3689 MIB_UNICASTIPADDRESS_ROW *row = (*table)->Table + count[0] + i;
3690 struct nsi_ipv6_unicast_key *key6 = (struct nsi_ipv6_unicast_key *)key[1];
3691
3692 unicast_row_fill( row, fam[1], (void *)(key6 + i), rw[1] + i, dyn[1] + i, stat[1] + i );
3693 }
3694
3695 err:
3696 for (i = 0; i < 2; i++) NsiFreeTable( key[i], rw[i], dyn[i], stat[i] );
3697 return err;
3698 }
3699
3700 /******************************************************************
3701 * GetUniDirectionalAdapterInfo (IPHLPAPI.@)
3702 *
3703 * This is a Win98-only function to get information on "unidirectional"
3704 * adapters. Since this is pretty nonsensical in other contexts, it
3705 * never returns anything.
3706 *
3707 * PARAMS
3708 * pIPIfInfo [Out] buffer for adapter infos
3709 * dwOutBufLen [Out] length of the output buffer
3710 *
3711 * RETURNS
3712 * Success: NO_ERROR
3713 * Failure: error code from winerror.h
3714 *
3715 * FIXME
3716 * Stub, returns ERROR_NOT_SUPPORTED.
3717 */
3718 DWORD WINAPI GetUniDirectionalAdapterInfo(PIP_UNIDIRECTIONAL_ADAPTER_ADDRESS pIPIfInfo, PULONG dwOutBufLen)
3719 {
3720 TRACE("pIPIfInfo %p, dwOutBufLen %p\n", pIPIfInfo, dwOutBufLen);
3721 /* a unidirectional adapter?? not bloody likely! */
3722 return ERROR_NOT_SUPPORTED;
3723 }
3724
3725
3726 /******************************************************************
3727 * IpReleaseAddress (IPHLPAPI.@)
3728 *
3729 * Release an IP obtained through DHCP,
3730 *
3731 * PARAMS
3732 * AdapterInfo [In] adapter to release IP address
3733 *
3734 * RETURNS
3735 * Success: NO_ERROR
3736 * Failure: error code from winerror.h
3737 *
3738 * NOTES
3739 * Since GetAdaptersInfo never returns adapters that have DHCP enabled,
3740 * this function does nothing.
3741 *
3742 * FIXME
3743 * Stub, returns ERROR_NOT_SUPPORTED.
3744 */
3745 DWORD WINAPI IpReleaseAddress(PIP_ADAPTER_INDEX_MAP AdapterInfo)
3746 {
3747 FIXME("Stub AdapterInfo %p\n", AdapterInfo);
3748 return ERROR_NOT_SUPPORTED;
3749 }
3750
3751
3752 /******************************************************************
3753 * IpRenewAddress (IPHLPAPI.@)
3754 *
3755 * Renew an IP obtained through DHCP.
3756 *
3757 * PARAMS
3758 * AdapterInfo [In] adapter to renew IP address
3759 *
3760 * RETURNS
3761 * Success: NO_ERROR
3762 * Failure: error code from winerror.h
3763 *
3764 * NOTES
3765 * Since GetAdaptersInfo never returns adapters that have DHCP enabled,
3766 * this function does nothing.
3767 *
3768 * FIXME
3769 * Stub, returns ERROR_NOT_SUPPORTED.
3770 */
3771 DWORD WINAPI IpRenewAddress(PIP_ADAPTER_INDEX_MAP AdapterInfo)
3772 {
3773 FIXME("Stub AdapterInfo %p\n", AdapterInfo);
3774 return ERROR_NOT_SUPPORTED;
3775 }
3776
3777
3778 /******************************************************************
3779 * NotifyAddrChange (IPHLPAPI.@)
3780 *
3781 * Notify caller whenever the ip-interface map is changed.
3782 *
3783 * PARAMS
3784 * Handle [Out] handle usable in asynchronous notification
3785 * overlapped [In] overlapped structure that notifies the caller
3786 *
3787 * RETURNS
3788 * Success: NO_ERROR
3789 * Failure: error code from winerror.h
3790 */
3791 DWORD WINAPI NotifyAddrChange(PHANDLE Handle, LPOVERLAPPED overlapped)
3792 {
3793 TRACE("Handle %p, overlapped %p.\n", Handle, overlapped);
3794
3795 return NsiRequestChangeNotification(0, &NPI_MS_IPV4_MODULEID, NSI_IP_UNICAST_TABLE, overlapped, Handle);
3796 }
3797
3798
3799 /******************************************************************
3800 * NotifyIpInterfaceChange (IPHLPAPI.@)
3801 */
3802 DWORD WINAPI NotifyIpInterfaceChange(ADDRESS_FAMILY family, PIPINTERFACE_CHANGE_CALLBACK callback,
3803 PVOID context, BOOLEAN init_notify, PHANDLE handle)
3804 {
3805 FIXME("(family %d, callback %p, context %p, init_notify %d, handle %p): stub\n",
3806 family, callback, context, init_notify, handle);
3807 if (handle) *handle = NULL;
3808 return NO_ERROR;
3809 }
3810
3811 /******************************************************************
3812 * NotifyRouteChange2 (IPHLPAPI.@)
3813 */
3814 DWORD WINAPI NotifyRouteChange2(ADDRESS_FAMILY family, PIPFORWARD_CHANGE_CALLBACK callback, VOID* context,
3815 BOOLEAN init_notify, HANDLE* handle)
3816 {
3817 FIXME("(family %d, callback %p, context %p, init_notify %d, handle %p): stub\n",
3818 family, callback, context, init_notify, handle);
3819 if (handle) *handle = NULL;
3820 return NO_ERROR;
3821 }
3822
3823
3824 /******************************************************************
3825 * NotifyRouteChange (IPHLPAPI.@)
3826 *
3827 * Notify caller whenever the ip routing table is changed.
3828 *
3829 * PARAMS
3830 * Handle [Out] handle usable in asynchronous notification
3831 * overlapped [In] overlapped structure that notifies the caller
3832 *
3833 * RETURNS
3834 * Success: NO_ERROR
3835 * Failure: error code from winerror.h
3836 *
3837 * FIXME
3838 * Stub, returns ERROR_NOT_SUPPORTED.
3839 */
3840 DWORD WINAPI NotifyRouteChange(PHANDLE Handle, LPOVERLAPPED overlapped)
3841 {
3842 FIXME("(Handle %p, overlapped %p): stub\n", Handle, overlapped);
3843 return ERROR_NOT_SUPPORTED;
3844 }
3845
3846
3847 /******************************************************************
3848 * NotifyUnicastIpAddressChange (IPHLPAPI.@)
3849 */
3850 DWORD WINAPI NotifyUnicastIpAddressChange(ADDRESS_FAMILY family, PUNICAST_IPADDRESS_CHANGE_CALLBACK callback,
3851 PVOID context, BOOLEAN init_notify, PHANDLE handle)
3852 {
3853 FIXME("(family %d, callback %p, context %p, init_notify %d, handle %p): semi-stub\n",
3854 family, callback, context, init_notify, handle);
3855 if (handle) *handle = NULL;
3856
3857 if (init_notify)
3858 callback(context, NULL, MibInitialNotification);
3859
3860 return NO_ERROR;
3861 }
3862
3863 /******************************************************************
3864 * SendARP (IPHLPAPI.@)
3865 *
3866 * Send an ARP request.
3867 *
3868 * PARAMS
3869 * DestIP [In] attempt to obtain this IP
3870 * SrcIP [In] optional sender IP address
3871 * pMacAddr [Out] buffer for the mac address
3872 * PhyAddrLen [In/Out] length of the output buffer
3873 *
3874 * RETURNS
3875 * Success: NO_ERROR
3876 * Failure: error code from winerror.h
3877 *
3878 * FIXME
3879 * Stub, returns ERROR_NOT_SUPPORTED.
3880 */
3881 DWORD WINAPI SendARP(IPAddr DestIP, IPAddr SrcIP, PULONG pMacAddr, PULONG PhyAddrLen)
3882 {
3883 FIXME("(DestIP 0x%08lx, SrcIP 0x%08lx, pMacAddr %p, PhyAddrLen %p): stub\n",
3884 DestIP, SrcIP, pMacAddr, PhyAddrLen);
3885 return ERROR_NOT_SUPPORTED;
3886 }
3887
3888
3889 /******************************************************************
3890 * SetIfEntry (IPHLPAPI.@)
3891 *
3892 * Set the administrative status of an interface.
3893 *
3894 * PARAMS
3895 * pIfRow [In] dwAdminStatus member specifies the new status.
3896 *
3897 * RETURNS
3898 * Success: NO_ERROR
3899 * Failure: error code from winerror.h
3900 *
3901 * FIXME
3902 * Stub, returns ERROR_NOT_SUPPORTED.
3903 */
3904 DWORD WINAPI SetIfEntry(PMIB_IFROW pIfRow)
3905 {
3906 FIXME("(pIfRow %p): stub\n", pIfRow);
3907 /* this is supposed to set an interface administratively up or down.
3908 Could do SIOCSIFFLAGS and set/clear IFF_UP, but, not sure I want to, and
3909 this sort of down is indistinguishable from other sorts of down (e.g. no
3910 link). */
3911 return ERROR_NOT_SUPPORTED;
3912 }
3913
3914
3915 /******************************************************************
3916 * SetIpForwardEntry (IPHLPAPI.@)
3917 *
3918 * Modify an existing route.
3919 *
3920 * PARAMS
3921 * pRoute [In] route with the new information
3922 *
3923 * RETURNS
3924 * Success: NO_ERROR
3925 * Failure: error code from winerror.h
3926 *
3927 * FIXME
3928 * Stub, returns NO_ERROR.
3929 */
3930 DWORD WINAPI SetIpForwardEntry(PMIB_IPFORWARDROW pRoute)
3931 {
3932 FIXME("(pRoute %p): stub\n", pRoute);
3933 /* this is to add a route entry, how's it distinguishable from
3934 CreateIpForwardEntry?
3935 could use SIOCADDRT, not sure I want to */
3936 return 0;
3937 }
3938
3939
3940 /******************************************************************
3941 * SetIpNetEntry (IPHLPAPI.@)
3942 *
3943 * Modify an existing ARP entry.
3944 *
3945 * PARAMS
3946 * pArpEntry [In] ARP entry with the new information
3947 *
3948 * RETURNS
3949 * Success: NO_ERROR
3950 * Failure: error code from winerror.h
3951 *
3952 * FIXME
3953 * Stub, returns NO_ERROR.
3954 */
3955 DWORD WINAPI SetIpNetEntry(PMIB_IPNETROW pArpEntry)
3956 {
3957 FIXME("(pArpEntry %p): stub\n", pArpEntry);
3958 /* same as CreateIpNetEntry here, could use SIOCSARP, not sure I want to */
3959 return 0;
3960 }
3961
3962
3963 /******************************************************************
3964 * SetIpStatistics (IPHLPAPI.@)
3965 *
3966 * Toggle IP forwarding and det the default TTL value.
3967 *
3968 * PARAMS
3969 * pIpStats [In] IP statistics with the new information
3970 *
3971 * RETURNS
3972 * Success: NO_ERROR
3973 * Failure: error code from winerror.h
3974 *
3975 * FIXME
3976 * Stub, returns NO_ERROR.
3977 */
3978 DWORD WINAPI SetIpStatistics(PMIB_IPSTATS pIpStats)
3979 {
3980 FIXME("(pIpStats %p): stub\n", pIpStats);
3981 return 0;
3982 }
3983
3984
3985 /******************************************************************
3986 * SetIpTTL (IPHLPAPI.@)
3987 *
3988 * Set the default TTL value.
3989 *
3990 * PARAMS
3991 * nTTL [In] new TTL value
3992 *
3993 * RETURNS
3994 * Success: NO_ERROR
3995 * Failure: error code from winerror.h
3996 *
3997 * FIXME
3998 * Stub, returns NO_ERROR.
3999 */
4000 DWORD WINAPI SetIpTTL(UINT nTTL)
4001 {
4002 FIXME("(nTTL %d): stub\n", nTTL);
4003 /* could echo nTTL > /proc/net/sys/net/ipv4/ip_default_ttl, not sure I
4004 want to. Could map EACCESS to ERROR_ACCESS_DENIED, I suppose */
4005 return 0;
4006 }
4007
4008
4009 /******************************************************************
4010 * SetTcpEntry (IPHLPAPI.@)
4011 *
4012 * Set the state of a TCP connection.
4013 *
4014 * PARAMS
4015 * pTcpRow [In] specifies connection with new state
4016 *
4017 * RETURNS
4018 * Success: NO_ERROR
4019 * Failure: error code from winerror.h
4020 *
4021 * FIXME
4022 * Stub, returns NO_ERROR.
4023 */
4024 DWORD WINAPI SetTcpEntry(PMIB_TCPROW pTcpRow)
4025 {
4026 FIXME("(pTcpRow %p): stub\n", pTcpRow);
4027 return 0;
4028 }
4029
4030 /***********************************************************************
4031 * GetPerTcpConnectionEStats (IPHLPAPI.@)
4032 */
4033 ULONG WINAPI GetPerTcpConnectionEStats(MIB_TCPROW *row, TCP_ESTATS_TYPE stats, UCHAR *rw, ULONG rw_version,
4034 ULONG rw_size, UCHAR *ro_static, ULONG ro_static_version,
4035 ULONG ro_static_size, UCHAR *ro_dynamic, ULONG ro_dynamic_version,
4036 ULONG ro_dynamic_size)
4037 {
4038 FIXME( "(%p, %d, %p, %ld, %ld, %p, %ld, %ld, %p, %ld, %ld): stub\n", row, stats, rw, rw_version, rw_size,
4039 ro_static, ro_static_version, ro_static_size, ro_dynamic, ro_dynamic_version, ro_dynamic_size );
4040 return ERROR_CALL_NOT_IMPLEMENTED;
4041 }
4042
4043 /******************************************************************
4044 * SetPerTcpConnectionEStats (IPHLPAPI.@)
4045 */
4046 DWORD WINAPI SetPerTcpConnectionEStats(PMIB_TCPROW row, TCP_ESTATS_TYPE state, PBYTE rw,
4047 ULONG version, ULONG size, ULONG offset)
4048 {
4049 FIXME("(row %p, state %d, rw %p, version %lu, size %lu, offset %lu): stub\n",
4050 row, state, rw, version, size, offset);
4051 return ERROR_NOT_SUPPORTED;
4052 }
4053
4054
4055 /******************************************************************
4056 * UnenableRouter (IPHLPAPI.@)
4057 *
4058 * Decrement the IP-forwarding reference count. Turn off IP-forwarding
4059 * if it reaches zero.
4060 *
4061 * PARAMS
4062 * pOverlapped [In/Out] should be the same as in EnableRouter()
4063 * lpdwEnableCount [Out] optional, receives reference count
4064 *
4065 * RETURNS
4066 * Success: NO_ERROR
4067 * Failure: error code from winerror.h
4068 *
4069 * FIXME
4070 * Stub, returns ERROR_NOT_SUPPORTED.
4071 */
4072 DWORD WINAPI UnenableRouter(OVERLAPPED * pOverlapped, LPDWORD lpdwEnableCount)
4073 {
4074 FIXME("(pOverlapped %p, lpdwEnableCount %p): stub\n", pOverlapped,
4075 lpdwEnableCount);
4076 /* could echo "0" > /proc/net/sys/net/ipv4/ip_forward, not sure I want to
4077 could map EACCESS to ERROR_ACCESS_DENIED, I suppose
4078 */
4079 return ERROR_NOT_SUPPORTED;
4080 }
4081
4082 /******************************************************************
4083 * PfCreateInterface (IPHLPAPI.@)
4084 */
4085 DWORD WINAPI PfCreateInterface(DWORD dwName, PFFORWARD_ACTION inAction, PFFORWARD_ACTION outAction,
4086 BOOL bUseLog, BOOL bMustBeUnique, INTERFACE_HANDLE *ppInterface)
4087 {
4088 FIXME("(%ld %d %d %x %x %p) stub\n", dwName, inAction, outAction, bUseLog, bMustBeUnique, ppInterface);
4089 return ERROR_CALL_NOT_IMPLEMENTED;
4090 }
4091
4092 /******************************************************************
4093 * PfUnBindInterface (IPHLPAPI.@)
4094 */
4095 DWORD WINAPI PfUnBindInterface(INTERFACE_HANDLE interface)
4096 {
4097 FIXME("(%p) stub\n", interface);
4098 return ERROR_CALL_NOT_IMPLEMENTED;
4099 }
4100
4101 /******************************************************************
4102 * PfDeleteInterface(IPHLPAPI.@)
4103 */
4104 DWORD WINAPI PfDeleteInterface(INTERFACE_HANDLE interface)
4105 {
4106 FIXME("(%p) stub\n", interface);
4107 return ERROR_CALL_NOT_IMPLEMENTED;
4108 }
4109
4110 /******************************************************************
4111 * PfBindInterfaceToIPAddress(IPHLPAPI.@)
4112 */
4113 DWORD WINAPI PfBindInterfaceToIPAddress(INTERFACE_HANDLE interface, PFADDRESSTYPE type, PBYTE ip)
4114 {
4115 FIXME("(%p %d %p) stub\n", interface, type, ip);
4116 return ERROR_CALL_NOT_IMPLEMENTED;
4117 }
4118
4119 /******************************************************************
4120 * ConvertInterfaceAliasToLuid (IPHLPAPI.@)
4121 */
4122 DWORD WINAPI ConvertInterfaceAliasToLuid( const WCHAR *alias, NET_LUID *luid )
4123 {
4124 struct nsi_ndis_ifinfo_rw *data;
4125 DWORD err, count, i, len;
4126 NET_LUID *keys;
4127
4128 TRACE( "(%s %p)\n", debugstr_w(alias), luid );
4129
4130 if (!alias || !*alias || !luid) return ERROR_INVALID_PARAMETER;
4131 luid->Value = 0;
4132 len = wcslen( alias );
4133
4134 err = NsiAllocateAndGetTable( 1, &NPI_MS_NDIS_MODULEID, NSI_NDIS_IFINFO_TABLE, (void **)&keys, sizeof(*keys),
4135 (void **)&data, sizeof(*data), NULL, 0, NULL, 0, &count, 0 );
4136 if (err) return err;
4137
4138 err = ERROR_INVALID_PARAMETER;
4139 for (i = 0; i < count; i++)
4140 {
4141 if (data[i].alias.Length == len * 2 && !memcmp( data[i].alias.String, alias, len * 2 ))
4142 {
4143 luid->Value = keys[i].Value;
4144 err = ERROR_SUCCESS;
4145 break;
4146 }
4147 }
4148 NsiFreeTable( keys, data, NULL, NULL );
4149 return err;
4150 }
4151
4152 /******************************************************************
4153 * ConvertInterfaceGuidToLuid (IPHLPAPI.@)
4154 */
4155 DWORD WINAPI ConvertInterfaceGuidToLuid(const GUID *guid, NET_LUID *luid)
4156 {
4157 struct nsi_ndis_ifinfo_static *data;
4158 DWORD err, count, i;
4159 NET_LUID *keys;
4160
4161 TRACE( "(%s %p)\n", debugstr_guid(guid), luid );
4162
4163 if (!guid || !luid) return ERROR_INVALID_PARAMETER;
4164 luid->Value = 0;
4165
4166 err = NsiAllocateAndGetTable( 1, &NPI_MS_NDIS_MODULEID, NSI_NDIS_IFINFO_TABLE, (void **)&keys, sizeof(*keys),
4167 NULL, 0, NULL, 0, (void **)&data, sizeof(*data), &count, 0 );
4168 if (err) return err;
4169
4170 err = ERROR_INVALID_PARAMETER;
4171 for (i = 0; i < count; i++)
4172 {
4173 if (IsEqualGUID( &data[i].if_guid, guid ))
4174 {
4175 luid->Value = keys[i].Value;
4176 err = ERROR_SUCCESS;
4177 break;
4178 }
4179 }
4180 NsiFreeTable( keys, NULL, NULL, data );
4181 return err;
4182 }
4183
4184 /******************************************************************
4185 * ConvertInterfaceIndexToLuid (IPHLPAPI.@)
4186 */
4187 DWORD WINAPI ConvertInterfaceIndexToLuid(NET_IFINDEX index, NET_LUID *luid)
4188 {
4189 DWORD err;
4190
4191 TRACE( "(%lu %p)\n", index, luid );
4192
4193 if (!luid) return ERROR_INVALID_PARAMETER;
4194
4195 err = NsiGetParameter( 1, &NPI_MS_NDIS_MODULEID, NSI_NDIS_INDEX_LUID_TABLE, &index, sizeof(index),
4196 NSI_PARAM_TYPE_STATIC, luid, sizeof(*luid), 0 );
4197 if (err) luid->Value = 0;
4198 return err;
4199 }
4200
4201 /******************************************************************
4202 * ConvertInterfaceLuidToAlias (IPHLPAPI.@)
4203 */
4204 DWORD WINAPI ConvertInterfaceLuidToAlias( const NET_LUID *luid, WCHAR *alias, SIZE_T len )
4205 {
4206 DWORD err;
4207 IF_COUNTED_STRING name;
4208
4209 TRACE( "(%p %p %Iu)\n", luid, alias, len );
4210
4211 if (!luid || !alias) return ERROR_INVALID_PARAMETER;
4212
4213 err = NsiGetParameter( 1, &NPI_MS_NDIS_MODULEID, NSI_NDIS_IFINFO_TABLE, luid, sizeof(*luid),
4214 NSI_PARAM_TYPE_RW, &name, sizeof(name),
4215 FIELD_OFFSET(struct nsi_ndis_ifinfo_rw, alias) );
4216 if (err) return err;
4217
4218 if (len <= name.Length / sizeof(WCHAR)) return ERROR_NOT_ENOUGH_MEMORY;
4219 memcpy( alias, name.String, name.Length );
4220 alias[name.Length / sizeof(WCHAR)] = '\0';
4221
4222 return err;
4223 }
4224
4225 /******************************************************************
4226 * ConvertInterfaceLuidToGuid (IPHLPAPI.@)
4227 */
4228 DWORD WINAPI ConvertInterfaceLuidToGuid(const NET_LUID *luid, GUID *guid)
4229 {
4230 DWORD err;
4231
4232 TRACE( "(%p %p)\n", luid, guid );
4233
4234 if (!luid || !guid) return ERROR_INVALID_PARAMETER;
4235
4236 err = NsiGetParameter( 1, &NPI_MS_NDIS_MODULEID, NSI_NDIS_IFINFO_TABLE, luid, sizeof(*luid),
4237 NSI_PARAM_TYPE_STATIC, guid, sizeof(*guid),
4238 FIELD_OFFSET(struct nsi_ndis_ifinfo_static, if_guid) );
4239 if (err) memset( guid, 0, sizeof(*guid) );
4240 return err;
4241 }
4242
4243 /******************************************************************
4244 * ConvertInterfaceLuidToIndex (IPHLPAPI.@)
4245 */
4246 DWORD WINAPI ConvertInterfaceLuidToIndex(const NET_LUID *luid, NET_IFINDEX *index)
4247 {
4248 DWORD err;
4249
4250 TRACE( "(%p %p)\n", luid, index );
4251
4252 if (!luid || !index) return ERROR_INVALID_PARAMETER;
4253
4254 err = NsiGetParameter( 1, &NPI_MS_NDIS_MODULEID, NSI_NDIS_IFINFO_TABLE, luid, sizeof(*luid),
4255 NSI_PARAM_TYPE_STATIC, index, sizeof(*index),
4256 FIELD_OFFSET(struct nsi_ndis_ifinfo_static, if_index) );
4257 if (err) *index = 0;
4258 return err;
4259 }
4260
4261 /******************************************************************
4262 * ConvertInterfaceLuidToNameA (IPHLPAPI.@)
4263 */
4264 DWORD WINAPI ConvertInterfaceLuidToNameA(const NET_LUID *luid, char *name, SIZE_T len)
4265 {
4266 DWORD err;
4267 WCHAR nameW[IF_MAX_STRING_SIZE + 1];
4268
4269 TRACE( "(%p %p %Iu)\n", luid, name, len );
4270
4271 if (!luid) return ERROR_INVALID_PARAMETER;
4272 if (!name || !len) return ERROR_NOT_ENOUGH_MEMORY;
4273
4274 err = ConvertInterfaceLuidToNameW( luid, nameW, ARRAY_SIZE(nameW) );
4275 if (err) return err;
4276
4277 if (!WideCharToMultiByte( CP_ACP, 0, nameW, -1, name, len, NULL, NULL ))
4278 err = GetLastError();
4279 return err;
4280 }
4281
4282 struct name_prefix
4283 {
4284 const WCHAR *prefix;
4285 DWORD type;
4286 };
4287 static const struct name_prefix name_prefixes[] =
4288 {
4289 { L"other", IF_TYPE_OTHER },
4290 { L"ethernet", IF_TYPE_ETHERNET_CSMACD },
4291 { L"tokenring", IF_TYPE_ISO88025_TOKENRING },
4292 { L"ppp", IF_TYPE_PPP },
4293 { L"loopback", IF_TYPE_SOFTWARE_LOOPBACK },
4294 { L"atm", IF_TYPE_ATM },
4295 { L"wireless", IF_TYPE_IEEE80211 },
4296 { L"tunnel", IF_TYPE_TUNNEL },
4297 { L"ieee1394", IF_TYPE_IEEE1394 }
4298 };
4299
4300 /******************************************************************
4301 * ConvertInterfaceLuidToNameW (IPHLPAPI.@)
4302 */
4303 DWORD WINAPI ConvertInterfaceLuidToNameW(const NET_LUID *luid, WCHAR *name, SIZE_T len)
4304 {
4305 DWORD i, needed;
4306 const WCHAR *prefix = NULL;
4307 WCHAR buf[IF_MAX_STRING_SIZE + 1];
4308
4309 TRACE( "(%p %p %Iu)\n", luid, name, len );
4310
4311 if (!luid || !name) return ERROR_INVALID_PARAMETER;
4312
4313 for (i = 0; i < ARRAY_SIZE(name_prefixes); i++)
4314 {
4315 if (luid->Info.IfType == name_prefixes[i].type)
4316 {
4317 prefix = name_prefixes[i].prefix;
4318 break;
4319 }
4320 }
4321
4322 if (prefix) needed = swprintf( buf, len, L"%s_%d", prefix, luid->Info.NetLuidIndex );
4323 else needed = swprintf( buf, len, L"iftype%d_%d", luid->Info.IfType, luid->Info.NetLuidIndex );
4324
4325 if (needed >= len) return ERROR_NOT_ENOUGH_MEMORY;
4326 memcpy( name, buf, (needed + 1) * sizeof(WCHAR) );
4327 return ERROR_SUCCESS;
4328 }
4329
4330 /******************************************************************
4331 * ConvertInterfaceNameToLuidA (IPHLPAPI.@)
4332 */
4333 DWORD WINAPI ConvertInterfaceNameToLuidA(const char *name, NET_LUID *luid)
4334 {
4335 WCHAR nameW[IF_MAX_STRING_SIZE];
4336
4337 TRACE( "(%s %p)\n", debugstr_a(name), luid );
4338
4339 if (!name) return ERROR_INVALID_NAME;
4340 if (!MultiByteToWideChar( CP_ACP, 0, name, -1, nameW, ARRAY_SIZE(nameW) ))
4341 return GetLastError();
4342
4343 return ConvertInterfaceNameToLuidW( nameW, luid );
4344 }
4345
4346 /******************************************************************
4347 * ConvertInterfaceNameToLuidW (IPHLPAPI.@)
4348 */
4349 DWORD WINAPI ConvertInterfaceNameToLuidW(const WCHAR *name, NET_LUID *luid)
4350 {
4351 const WCHAR *sep;
4352 DWORD type = ~0u, i;
4353 int iftype_len = wcslen( L"iftype" );
4354 WCHAR buf[IF_MAX_STRING_SIZE + 1];
4355
4356 TRACE( "(%s %p)\n", debugstr_w(name), luid );
4357
4358 if (!luid) return ERROR_INVALID_PARAMETER;
4359 memset( luid, 0, sizeof(*luid) );
4360
4361 if (!name || !(sep = wcschr( name, '_' )) || sep >= name + ARRAY_SIZE(buf)) return ERROR_INVALID_NAME;
4362 memcpy( buf, name, (sep - name) * sizeof(WCHAR) );
4363 buf[sep - name] = '\0';
4364
4365 if (sep - name > iftype_len && !memcmp( buf, L"iftype", iftype_len * sizeof(WCHAR) ))
4366 {
4367 type = wcstol( buf + iftype_len, NULL, 10 );
4368 }
4369 else
4370 {
4371 for (i = 0; i < ARRAY_SIZE(name_prefixes); i++)
4372 {
4373 if (!wcscmp( buf, name_prefixes[i].prefix ))
4374 {
4375 type = name_prefixes[i].type;
4376 break;
4377 }
4378 }
4379 }
4380 if (type == ~0u) return ERROR_INVALID_NAME;
4381
4382 luid->Info.NetLuidIndex = wcstol( sep + 1, NULL, 10 );
4383 luid->Info.IfType = type;
4384 return ERROR_SUCCESS;
4385 }
4386
4387 /******************************************************************
4388 * ConvertLengthToIpv4Mask (IPHLPAPI.@)
4389 */
4390 DWORD WINAPI ConvertLengthToIpv4Mask(ULONG mask_len, ULONG *mask)
4391 {
4392 if (mask_len > 32)
4393 {
4394 *mask = INADDR_NONE;
4395 return ERROR_INVALID_PARAMETER;
4396 }
4397
4398 if (mask_len == 0)
4399 *mask = 0;
4400 else
4401 *mask = htonl(~0u << (32 - mask_len));
4402
4403 return NO_ERROR;
4404 }
4405
4406 /******************************************************************
4407 * if_nametoindex (IPHLPAPI.@)
4408 */
4409 IF_INDEX WINAPI IPHLP_if_nametoindex(const char *name)
4410 {
4411 IF_INDEX index;
4412 NET_LUID luid;
4413 DWORD err;
4414
4415 TRACE( "(%s)\n", name );
4416
4417 err = ConvertInterfaceNameToLuidA( name, &luid );
4418 if (err) return 0;
4419
4420 err = ConvertInterfaceLuidToIndex( &luid, &index );
4421 if (err) index = 0;
4422 return index;
4423 }
4424
4425 /******************************************************************
4426 * if_indextoname (IPHLPAPI.@)
4427 */
4428 char *WINAPI IPHLP_if_indextoname( NET_IFINDEX index, char *name )
4429 {
4430 NET_LUID luid;
4431 DWORD err;
4432
4433 TRACE( "(%lu, %p)\n", index, name );
4434
4435 err = ConvertInterfaceIndexToLuid( index, &luid );
4436 if (err) return NULL;
4437
4438 err = ConvertInterfaceLuidToNameA( &luid, name, IF_MAX_STRING_SIZE );
4439 if (err) return NULL;
4440 return name;
4441 }
4442
4443 /******************************************************************
4444 * GetIpInterfaceTable (IPHLPAPI.@)
4445 */
4446 DWORD WINAPI GetIpInterfaceTable(ADDRESS_FAMILY family, PMIB_IPINTERFACE_TABLE *table)
4447 {
4448 FIXME("(%u %p): stub\n", family, table);
4449 return ERROR_NOT_SUPPORTED;
4450 }
4451
4452 /******************************************************************
4453 * GetBestRoute2 (IPHLPAPI.@)
4454 */
4455 DWORD WINAPI GetBestRoute2(NET_LUID *luid, NET_IFINDEX index,
4456 const SOCKADDR_INET *source, const SOCKADDR_INET *destination,
4457 ULONG options, PMIB_IPFORWARD_ROW2 bestroute,
4458 SOCKADDR_INET *bestaddress)
4459 {
4460 static int once;
4461
4462 if (!once++)
4463 FIXME("(%p, %ld, %p, %p, 0x%08lx, %p, %p): stub\n", luid, index, source,
4464 destination, options, bestroute, bestaddress);
4465
4466 if (!destination || !bestroute || !bestaddress)
4467 return ERROR_INVALID_PARAMETER;
4468
4469 return ERROR_NOT_SUPPORTED;
4470 }
4471
4472 /******************************************************************
4473 * ParseNetworkString (IPHLPAPI.@)
4474 */
4475 DWORD WINAPI ParseNetworkString(const WCHAR *str, DWORD type,
4476 NET_ADDRESS_INFO *info, USHORT *port, BYTE *prefix_len)
4477 {
4478 IN_ADDR temp_addr4;
4479 IN6_ADDR temp_addr6;
4480 ULONG temp_scope;
4481 USHORT temp_port = 0;
4482 NTSTATUS status;
4483
4484 TRACE("(%s, %ld, %p, %p, %p)\n", debugstr_w(str), type, info, port, prefix_len);
4485
4486 if (!str)
4487 return ERROR_INVALID_PARAMETER;
4488
4489 if (type & NET_STRING_IPV4_ADDRESS)
4490 {
4491 status = RtlIpv4StringToAddressExW(str, TRUE, &temp_addr4, &temp_port);
4492 if (SUCCEEDED(status) && !temp_port)
4493 {
4494 if (info)
4495 {
4496 info->Format = NET_ADDRESS_IPV4;
4497 info->Ipv4Address.sin_addr = temp_addr4;
4498 info->Ipv4Address.sin_port = 0;
4499 }
4500 if (port) *port = 0;
4501 if (prefix_len) *prefix_len = 255;
4502 return ERROR_SUCCESS;
4503 }
4504 }
4505 if (type & NET_STRING_IPV4_SERVICE)
4506 {
4507 status = RtlIpv4StringToAddressExW(str, TRUE, &temp_addr4, &temp_port);
4508 if (SUCCEEDED(status) && temp_port)
4509 {
4510 if (info)
4511 {
4512 info->Format = NET_ADDRESS_IPV4;
4513 info->Ipv4Address.sin_addr = temp_addr4;
4514 info->Ipv4Address.sin_port = temp_port;
4515 }
4516 if (port) *port = ntohs(temp_port);
4517 if (prefix_len) *prefix_len = 255;
4518 return ERROR_SUCCESS;
4519 }
4520 }
4521 if (type & NET_STRING_IPV6_ADDRESS)
4522 {
4523 status = RtlIpv6StringToAddressExW(str, &temp_addr6, &temp_scope, &temp_port);
4524 if (SUCCEEDED(status) && !temp_port)
4525 {
4526 if (info)
4527 {
4528 info->Format = NET_ADDRESS_IPV6;
4529 info->Ipv6Address.sin6_addr = temp_addr6;
4530 info->Ipv6Address.sin6_scope_id = temp_scope;
4531 info->Ipv6Address.sin6_port = 0;
4532 }
4533 if (port) *port = 0;
4534 if (prefix_len) *prefix_len = 255;
4535 return ERROR_SUCCESS;
4536 }
4537 }
4538 if (type & NET_STRING_IPV6_SERVICE)
4539 {
4540 status = RtlIpv6StringToAddressExW(str, &temp_addr6, &temp_scope, &temp_port);
4541 if (SUCCEEDED(status) && temp_port)
4542 {
4543 if (info)
4544 {
4545 info->Format = NET_ADDRESS_IPV6;
4546 info->Ipv6Address.sin6_addr = temp_addr6;
4547 info->Ipv6Address.sin6_scope_id = temp_scope;
4548 info->Ipv6Address.sin6_port = temp_port;
4549 }
4550 if (port) *port = ntohs(temp_port);
4551 if (prefix_len) *prefix_len = 255;
4552 return ERROR_SUCCESS;
4553 }
4554 }
4555
4556 if (info) info->Format = NET_ADDRESS_FORMAT_UNSPECIFIED;
4557
4558 if (type & ~(NET_STRING_IPV4_ADDRESS|NET_STRING_IPV4_SERVICE|NET_STRING_IPV6_ADDRESS|NET_STRING_IPV6_SERVICE))
4559 {
4560 FIXME("Unimplemented type 0x%lx\n", type);
4561 return ERROR_NOT_SUPPORTED;
4562 }
4563
4564 return ERROR_INVALID_PARAMETER;
4565 }
4566
4567 struct icmp_handle_data
4568 {
4569 HANDLE nsi_device;
4570 };
4571
4572 /***********************************************************************
4573 * IcmpCloseHandle (IPHLPAPI.@)
4574 */
4575 BOOL WINAPI IcmpCloseHandle( HANDLE handle )
4576 {
4577 struct icmp_handle_data *data;
4578
4579 if (handle == NULL || handle == INVALID_HANDLE_VALUE)
4580 return FALSE;
4581
4582 data = (struct icmp_handle_data *)handle;
4583
4584 CloseHandle( data->nsi_device );
4585 heap_free( data );
4586 return TRUE;
4587 }
4588
4589 /***********************************************************************
4590 * IcmpCreateFile (IPHLPAPI.@)
4591 */
4592 HANDLE WINAPI IcmpCreateFile( void )
4593 {
4594 struct icmp_handle_data *data = heap_alloc( sizeof(*data) );
4595
4596 if (!data)
4597 {
4598 SetLastError( IP_NO_RESOURCES );
4599 return INVALID_HANDLE_VALUE;
4600 }
4601
4602 data->nsi_device = CreateFileW( L"\\\\.\\Nsi", 0, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
4603 FILE_FLAG_OVERLAPPED, NULL );
4604 if (data->nsi_device == INVALID_HANDLE_VALUE)
4605 {
4606 heap_free( data );
4607 return INVALID_HANDLE_VALUE;
4608 }
4609
4610 return (HANDLE)data;
4611 }
4612
4613 /******************************************************************
4614 * IcmpParseReplies (IPHLPAPI.@)
4615 */
4616 DWORD WINAPI IcmpParseReplies( void *reply, DWORD reply_size )
4617 {
4618 ICMP_ECHO_REPLY *icmp_reply = reply;
4619 DWORD num_pkts = icmp_reply->Reserved;
4620
4621 icmp_reply->Reserved = 0;
4622 if (!num_pkts) SetLastError( icmp_reply->Status );
4623 return num_pkts;
4624 }
4625
4626 /***********************************************************************
4627 * IcmpSendEcho (IPHLPAPI.@)
4628 */
4629 DWORD WINAPI IcmpSendEcho( HANDLE handle, IPAddr dst, void *request, WORD request_size,
4630 IP_OPTION_INFORMATION *opts, void *reply, DWORD reply_size,
4631 DWORD timeout )
4632 {
4633 return IcmpSendEcho2Ex( handle, NULL, NULL, NULL, INADDR_ANY, dst, request, request_size,
4634 opts, reply, reply_size, timeout );
4635 }
4636
4637 /***********************************************************************
4638 * IcmpSendEcho2 (IPHLPAPI.@)
4639 */
4640 DWORD WINAPI IcmpSendEcho2( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc_routine, void *apc_ctxt,
4641 IPAddr dst, void *request, WORD request_size, IP_OPTION_INFORMATION *opts,
4642 void *reply, DWORD reply_size, DWORD timeout )
4643 {
4644 return IcmpSendEcho2Ex( handle, event, apc_routine, apc_ctxt, INADDR_ANY, dst, request, request_size,
4645 opts, reply, reply_size, timeout );
4646 }
4647
4648 struct icmp_apc_ctxt
4649 {
4650 void *apc_ctxt;
4651 PIO_APC_ROUTINE apc_routine;
4652 IO_STATUS_BLOCK iosb;
4653 };
4654
4655 void WINAPI icmp_apc_routine( void *context, IO_STATUS_BLOCK *iosb, ULONG reserved )
4656 {
4657 struct icmp_apc_ctxt *ctxt = context;
4658
4659 ctxt->apc_routine( ctxt->apc_ctxt, iosb, reserved );
4660 heap_free( ctxt );
4661 }
4662
4663 /***********************************************************************
4664 * IcmpSendEcho2Ex (IPHLPAPI.@)
4665 */
4666 DWORD WINAPI IcmpSendEcho2Ex( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc_routine, void *apc_ctxt,
4667 IPAddr src, IPAddr dst, void *request, WORD request_size, IP_OPTION_INFORMATION *opts,
4668 void *reply, DWORD reply_size, DWORD timeout )
4669 {
4670 struct icmp_handle_data *data = (struct icmp_handle_data *)handle;
4671 struct icmp_apc_ctxt *ctxt = heap_alloc( sizeof(*ctxt) );
4672 IO_STATUS_BLOCK *iosb = &ctxt->iosb;
4673 DWORD opt_size, in_size, ret = 0;
4674 struct nsiproxy_icmp_echo *in;
4675 HANDLE request_event;
4676 NTSTATUS status;
4677
4678 if (handle == INVALID_HANDLE_VALUE || !reply)
4679 {
4680 heap_free( ctxt );
4681 SetLastError( ERROR_INVALID_PARAMETER );
4682 return 0;
4683 }
4684
4685 ctxt->apc_routine = apc_routine;
4686 ctxt->apc_ctxt = apc_ctxt;
4687
4688 opt_size = opts ? (opts->OptionsSize + 3) & ~3 : 0;
4689 in_size = FIELD_OFFSET(struct nsiproxy_icmp_echo, data[opt_size + request_size]);
4690 in = heap_alloc_zero( in_size );
4691
4692 if (!in)
4693 {
4694 heap_free( ctxt );
4695 SetLastError( IP_NO_RESOURCES );
4696 return 0;
4697 }
4698
4699 in->user_reply_ptr = (ULONG_PTR)reply;
4700 in->bits = sizeof(void*) * 8;
4701 in->src.Ipv4.sin_family = AF_INET;
4702 in->src.Ipv4.sin_addr.s_addr = src;
4703 in->dst.Ipv4.sin_family = AF_INET;
4704 in->dst.Ipv4.sin_addr.s_addr = dst;
4705 if (opts)
4706 {
4707 in->ttl = opts->Ttl;
4708 in->tos = opts->Tos;
4709 in->flags = opts->Flags;
4710 memcpy( in->data, opts->OptionsData, opts->OptionsSize );
4711 in->opt_size = opts->OptionsSize;
4712 }
4713 in->req_size = request_size;
4714 in->timeout = timeout;
4715 memcpy( in->data + opt_size, request, request_size );
4716
4717 request_event = event ? event : (apc_routine ? NULL : CreateEventW( NULL, 0, 0, NULL ));
4718
4719 status = NtDeviceIoControlFile( data->nsi_device, request_event, apc_routine ? icmp_apc_routine : NULL,
4720 apc_routine ? ctxt : apc_ctxt, iosb, IOCTL_NSIPROXY_WINE_ICMP_ECHO,
4721 in, in_size, reply, reply_size );
4722
4723 if (status == STATUS_PENDING)
4724 {
4725 if (!event && !apc_routine && !WaitForSingleObject( request_event, INFINITE ))
4726 status = iosb->Status;
4727 }
4728
4729 if (!status)
4730 ret = IcmpParseReplies( reply, reply_size );
4731
4732 if (!event && request_event) CloseHandle( request_event );
4733 if (!apc_routine || status != STATUS_PENDING) heap_free( ctxt );
4734 heap_free( in );
4735
4736 if (status) SetLastError( RtlNtStatusToDosError( status ) );
4737 return ret;
4738 }
4739
4740 /***********************************************************************
4741 * Icmp6CreateFile (IPHLPAPI.@)
4742 */
4743 HANDLE WINAPI Icmp6CreateFile( void )
4744 {
4745 FIXME( "stub\n" );
4746 SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
4747 return INVALID_HANDLE_VALUE;
4748 }
4749
4750 /***********************************************************************
4751 * Icmp6SendEcho2 (IPHLPAPI.@)
4752 */
4753 DWORD WINAPI Icmp6SendEcho2( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc_routine, void *apc_ctxt,
4754 struct sockaddr_in6 *src, struct sockaddr_in6 *dst, void *request, WORD request_size,
4755 IP_OPTION_INFORMATION *opts, void *reply, DWORD reply_size, DWORD timeout )
4756 {
4757 FIXME( "(%p, %p, %p, %p, %p, %p, %p, %d, %p, %p, %ld, %ld): stub\n", handle, event,
4758 apc_routine, apc_ctxt, src, dst, request, request_size, opts, reply, reply_size, timeout );
4759 SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
4760 return 0;
4761 }
4762
4763 /***********************************************************************
4764 * GetCurrentThreadCompartmentId (IPHLPAPI.@)
4765 */
4766 NET_IF_COMPARTMENT_ID WINAPI GetCurrentThreadCompartmentId( void )
4767 {
4768 FIXME( "stub\n" );
4769 return NET_IF_COMPARTMENT_ID_PRIMARY;
4770 }
Windows API implementation