ReactOS 0.4.15-dev-6055-g36cdd34
iphlpapi_main.c
Go to the documentation of this file.
1/*
2 * iphlpapi dll implementation
3 *
4 * Copyright (C) 2003 Juan Lang
5 * 2018 Pierre Schweitzer
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 Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22#define DEBUG
23
24#include <config.h>
25#include "iphlpapi_private.h"
26#include <strsafe.h>
27#include <psapi.h>
28
29WINE_DEFAULT_DEBUG_CHANNEL(iphlpapi);
30
31typedef struct _NAME_SERVER_LIST_CONTEXT {
32 ULONG uSizeAvailable;
33 ULONG uSizeRequired;
34 PIP_PER_ADAPTER_INFO pData;
35 UINT NumServers;
36 IP_ADDR_STRING *pLastAddr;
37} NAME_SERVER_LIST_CONTEXT, *PNAME_SERVER_LIST_CONTEXT;
38
39BOOL WINAPI DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
40{
41 switch (fdwReason) {
42 case DLL_PROCESS_ATTACH:
43 DisableThreadLibraryCalls( hinstDLL );
44 interfaceMapInit();
45 break;
46
47 case DLL_PROCESS_DETACH:
48 interfaceMapFree();
49 break;
50 }
51 return TRUE;
52}
53
54/******************************************************************
55 * AddIPAddress (IPHLPAPI.@)
56 *
57 *
58 * PARAMS
59 *
60 * Address [In]
61 * IpMask [In]
62 * IfIndex [In]
63 * NTEContext [In/Out]
64 * NTEInstance [In/Out]
65 *
66 * RETURNS
67 *
68 * DWORD
69 *
70 */
71DWORD WINAPI AddIPAddress(IPAddr Address, IPMask Netmask, DWORD IfIndex, PULONG NteContext, PULONG NteInstance)
72{
73 return RtlNtStatusToDosError(addIPAddress(Address, Netmask, IfIndex, NteContext, NteInstance));
74}
75
76DWORD getInterfaceGatewayByIndex(DWORD index)
77{
78 DWORD ndx, retVal = 0, numRoutes = getNumRoutes();
79 RouteTable *table = getRouteTable();
80 if (!table) return 0;
81
82 for (ndx = 0; ndx < numRoutes; ndx++)
83 {
84 if ((table->routes[ndx].ifIndex == (index)) && (table->routes[ndx].dest == 0))
85 retVal = table->routes[ndx].gateway;
86 }
87 HeapFree(GetProcessHeap(), 0, table);
88 return retVal;
89}
90
91/******************************************************************
92 * AllocateAndGetIfTableFromStack (IPHLPAPI.@)
93 *
94 *
95 * PARAMS
96 *
97 * ppIfTable [Out] -- pointer into which the MIB_IFTABLE is
98 * allocated and returned.
99 * bOrder [In] -- passed to GetIfTable to order the table
100 * heap [In] -- heap from which the table is allocated
101 * flags [In] -- flags to HeapAlloc
102 *
103 * RETURNS -- ERROR_INVALID_PARAMETER if ppIfTable is NULL, whatever
104 * GetIfTable returns otherwise
105 *
106 */
107DWORD WINAPI AllocateAndGetIfTableFromStack(PMIB_IFTABLE *ppIfTable,
108 BOOL bOrder, HANDLE heap, DWORD flags)
109{
110 DWORD ret;
111
112 TRACE("ppIfTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx\n", ppIfTable,
113 (DWORD)bOrder, heap, flags);
114 if (!ppIfTable)
115 ret = ERROR_INVALID_PARAMETER;
116 else {
117 DWORD dwSize = 0;
118
119 *ppIfTable = NULL;
120 ret = GetIfTable(*ppIfTable, &dwSize, bOrder);
121 if (ret == ERROR_INSUFFICIENT_BUFFER) {
122 *ppIfTable = (PMIB_IFTABLE)HeapAlloc(heap, flags, dwSize);
123 ret = GetIfTable(*ppIfTable, &dwSize, bOrder);
124 if (ret != NO_ERROR) {
125 HeapFree(heap, flags, *ppIfTable);
126 *ppIfTable = NULL;
127 }
128 }
129 }
130 TRACE("returning %ld\n", ret);
131 return ret;
132}
133
134
135/******************************************************************
136 * AllocateAndGetIpAddrTableFromStack (IPHLPAPI.@)
137 *
138 *
139 * PARAMS
140 *
141 * ppIpAddrTable [Out]
142 * bOrder [In] -- passed to GetIpAddrTable to order the table
143 * heap [In] -- heap from which the table is allocated
144 * flags [In] -- flags to HeapAlloc
145 *
146 * RETURNS
147 *
148 * DWORD
149 *
150 */
151DWORD WINAPI AllocateAndGetIpAddrTableFromStack(PMIB_IPADDRTABLE *ppIpAddrTable,
152 BOOL bOrder, HANDLE heap, DWORD flags)
153{
154 DWORD ret;
155
156 TRACE("ppIpAddrTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx\n",
157 ppIpAddrTable, (DWORD)bOrder, heap, flags);
158 if (!ppIpAddrTable)
159 ret = ERROR_INVALID_PARAMETER;
160 else {
161 DWORD dwSize = 0;
162
163 *ppIpAddrTable = NULL;
164 ret = GetIpAddrTable(*ppIpAddrTable, &dwSize, bOrder);
165 if (ret == ERROR_INSUFFICIENT_BUFFER) {
166 *ppIpAddrTable = (PMIB_IPADDRTABLE)HeapAlloc(heap, flags, dwSize);
167 ret = GetIpAddrTable(*ppIpAddrTable, &dwSize, bOrder);
168 if (ret != NO_ERROR) {
169 HeapFree(heap, flags, *ppIpAddrTable);
170 *ppIpAddrTable = NULL;
171 }
172 }
173 }
174 TRACE("returning %ld\n", ret);
175 return ret;
176}
177
178
179/******************************************************************
180 * AllocateAndGetIpForwardTableFromStack (IPHLPAPI.@)
181 *
182 *
183 * ppIpForwardTable [Out] -- pointer into which the MIB_IPFORWARDTABLE is
184 * allocated and returned.
185 * bOrder [In] -- passed to GetIfTable to order the table
186 * heap [In] -- heap from which the table is allocated
187 * flags [In] -- flags to HeapAlloc
188 *
189 * RETURNS -- ERROR_INVALID_PARAMETER if ppIfTable is NULL, whatever
190 * GetIpForwardTable returns otherwise
191 *
192 */
193DWORD WINAPI AllocateAndGetIpForwardTableFromStack(PMIB_IPFORWARDTABLE *
194 ppIpForwardTable, BOOL bOrder, HANDLE heap, DWORD flags)
195{
196 DWORD ret;
197
198 TRACE("ppIpForwardTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx\n",
199 ppIpForwardTable, (DWORD)bOrder, heap, flags);
200 if (!ppIpForwardTable)
201 ret = ERROR_INVALID_PARAMETER;
202 else {
203 DWORD dwSize = 0;
204
205 *ppIpForwardTable = NULL;
206 ret = GetIpForwardTable(*ppIpForwardTable, &dwSize, bOrder);
207 if (ret == ERROR_INSUFFICIENT_BUFFER) {
208 *ppIpForwardTable = (PMIB_IPFORWARDTABLE)HeapAlloc(heap, flags, dwSize);
209 ret = GetIpForwardTable(*ppIpForwardTable, &dwSize, bOrder);
210 if (ret != NO_ERROR) {
211 HeapFree(heap, flags, *ppIpForwardTable);
212 *ppIpForwardTable = NULL;
213 }
214 }
215 }
216 TRACE("returning %ld\n", ret);
217 return ret;
218}
219
220
221/******************************************************************
222 * AllocateAndGetIpNetTableFromStack (IPHLPAPI.@)
223 *
224 *
225 * PARAMS
226 *
227 * ppIpNetTable [Out]
228 * bOrder [In] -- passed to GetIpNetTable to order the table
229 * heap [In] -- heap from which the table is allocated
230 * flags [In] -- flags to HeapAlloc
231 *
232 * RETURNS
233 *
234 * DWORD
235 *
236 */
237DWORD WINAPI AllocateAndGetIpNetTableFromStack(PMIB_IPNETTABLE *ppIpNetTable,
238 BOOL bOrder, HANDLE heap, DWORD flags)
239{
240 DWORD ret;
241
242 TRACE("ppIpNetTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx\n",
243 ppIpNetTable, (DWORD)bOrder, heap, flags);
244 if (!ppIpNetTable)
245 ret = ERROR_INVALID_PARAMETER;
246 else {
247 DWORD dwSize = 0;
248
249 *ppIpNetTable = NULL;
250 ret = GetIpNetTable(*ppIpNetTable, &dwSize, bOrder);
251 if (ret == ERROR_INSUFFICIENT_BUFFER) {
252 *ppIpNetTable = (PMIB_IPNETTABLE)HeapAlloc(heap, flags, dwSize);
253 ret = GetIpNetTable(*ppIpNetTable, &dwSize, bOrder);
254 if (ret != NO_ERROR) {
255 HeapFree(heap, flags, *ppIpNetTable);
256 *ppIpNetTable = NULL;
257 }
258 }
259 }
260 TRACE("returning %ld\n", ret);
261 return ret;
262}
263
264
265/******************************************************************
266 * AllocateAndGetTcpTableFromStack (IPHLPAPI.@)
267 *
268 *
269 * PARAMS
270 *
271 * ppTcpTable [Out]
272 * bOrder [In] -- passed to GetTcpTable to order the table
273 * heap [In] -- heap from which the table is allocated
274 * flags [In] -- flags to HeapAlloc
275 *
276 * RETURNS
277 *
278 * DWORD
279 *
280 */
281DWORD WINAPI AllocateAndGetTcpTableFromStack(PMIB_TCPTABLE *ppTcpTable,
282 BOOL bOrder, HANDLE heap, DWORD flags)
283{
284 DWORD ret;
285
286 TRACE("ppTcpTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx\n",
287 ppTcpTable, (DWORD)bOrder, heap, flags);
288 if (!ppTcpTable)
289 ret = ERROR_INVALID_PARAMETER;
290 else {
291 DWORD dwSize = 0;
292
293 *ppTcpTable = NULL;
294 ret = GetTcpTable(*ppTcpTable, &dwSize, bOrder);
295 if (ret == ERROR_INSUFFICIENT_BUFFER) {
296 *ppTcpTable = (PMIB_TCPTABLE)HeapAlloc(heap, flags, dwSize);
297 ret = GetTcpTable(*ppTcpTable, &dwSize, bOrder);
298 if (ret != NO_ERROR) {
299 HeapFree(heap, flags, *ppTcpTable);
300 *ppTcpTable = NULL;
301 }
302 }
303 }
304 TRACE("returning %ld\n", ret);
305 return ret;
306}
307
308
309/******************************************************************
310 * AllocateAndGetTcpExTableFromStack (IPHLPAPI.@)
311 *
312 *
313 * PARAMS
314 *
315 * ppTcpTable [Out]
316 * bOrder [In] -- passed to GetExtendedTcpTable to order the table
317 * heap [In] -- heap from which the table is allocated
318 * flags [In] -- flags to HeapAlloc
319 * family [In] -- passed to GetExtendedTcpTable to select INET family
320 *
321 * RETURNS
322 *
323 * DWORD
324 *
325 */
326DWORD WINAPI AllocateAndGetTcpExTableFromStack(PVOID *ppTcpTable,
327 BOOL bOrder, HANDLE heap, DWORD flags, DWORD family)
328{
329 DWORD ret;
330
331 TRACE("ppTcpTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx, family 0x%08lx\n",
332 ppTcpTable, (DWORD)bOrder, heap, flags, family);
333 if (!ppTcpTable)
334 ret = ERROR_INVALID_PARAMETER;
335 else {
336 DWORD dwSize = 0;
337
338 *ppTcpTable = NULL;
339 ret = GetExtendedTcpTable(*ppTcpTable, &dwSize, bOrder, family, TCP_TABLE_OWNER_PID_ALL, 0);
340 if (ret == ERROR_INSUFFICIENT_BUFFER) {
341 *ppTcpTable = (PMIB_TCPTABLE_OWNER_PID)HeapAlloc(heap, flags, dwSize);
342 ret = GetExtendedTcpTable(*ppTcpTable, &dwSize, bOrder, family, TCP_TABLE_OWNER_PID_ALL, 0);
343 if (ret != NO_ERROR) {
344 HeapFree(heap, flags, *ppTcpTable);
345 *ppTcpTable = NULL;
346 }
347 }
348 }
349 TRACE("returning %ld\n", ret);
350 return ret;
351}
352
353
354/******************************************************************
355 * AllocateAndGetTcpExTable2FromStack (IPHLPAPI.@)
356 *
357 *
358 * PARAMS
359 *
360 * ppTcpTable [Out]
361 * bOrder [In] -- passed to GetExtendedTcpTable to order the table
362 * heap [In] -- heap from which the table is allocated
363 * flags [In] -- flags to HeapAlloc
364 * family [In] -- passed to GetExtendedTcpTable to select INET family
365 * class [In] -- passed to GetExtendedTcpTable to select information
366 *
367 * RETURNS
368 *
369 * DWORD
370 *
371 */
372DWORD WINAPI AllocateAndGetTcpExTable2FromStack(PVOID *ppTcpTable,
373 BOOL bOrder, HANDLE heap, DWORD flags, DWORD family, TCP_TABLE_CLASS class)
374{
375 DWORD ret;
376
377 TRACE("ppTcpTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx, family %ld, class %ld\n",
378 ppTcpTable, (DWORD)bOrder, heap, flags, family, class);
379 if (!ppTcpTable)
380 ret = ERROR_INVALID_PARAMETER;
381 else {
382 DWORD dwSize = 0;
383
384 *ppTcpTable = NULL;
385 ret = GetExtendedTcpTable(*ppTcpTable, &dwSize, bOrder, family, class, 0);
386 if (ret == ERROR_INSUFFICIENT_BUFFER) {
387 *ppTcpTable = HeapAlloc(heap, flags, dwSize);
388 ret = GetExtendedTcpTable(*ppTcpTable, &dwSize, bOrder, family, class, 0);
389 if (ret != NO_ERROR) {
390 HeapFree(heap, flags, *ppTcpTable);
391 *ppTcpTable = NULL;
392 }
393 }
394 }
395 TRACE("returning %ld\n", ret);
396 return ret;
397}
398
399
400/******************************************************************
401 * AllocateAndGetUdpTableFromStack (IPHLPAPI.@)
402 *
403 *
404 * PARAMS
405 *
406 * ppUdpTable [Out]
407 * bOrder [In] -- passed to GetUdpTable to order the table
408 * heap [In] -- heap from which the table is allocated
409 * flags [In] -- flags to HeapAlloc
410 *
411 * RETURNS
412 *
413 * DWORD
414 *
415 */
416DWORD WINAPI AllocateAndGetUdpTableFromStack(PMIB_UDPTABLE *ppUdpTable,
417 BOOL bOrder, HANDLE heap, DWORD flags)
418{
419 DWORD ret;
420
421 TRACE("ppUdpTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx\n",
422 ppUdpTable, (DWORD)bOrder, heap, flags);
423 if (!ppUdpTable)
424 ret = ERROR_INVALID_PARAMETER;
425 else {
426 DWORD dwSize = 0;
427
428 *ppUdpTable = NULL;
429 ret = GetUdpTable(*ppUdpTable, &dwSize, bOrder);
430 if (ret == ERROR_INSUFFICIENT_BUFFER) {
431 *ppUdpTable = (PMIB_UDPTABLE)HeapAlloc(heap, flags, dwSize);
432 ret = GetUdpTable(*ppUdpTable, &dwSize, bOrder);
433 if (ret != NO_ERROR) {
434 HeapFree(heap, flags, *ppUdpTable);
435 *ppUdpTable = NULL;
436 }
437 }
438 }
439 TRACE("returning %ld\n", ret);
440 return ret;
441}
442
443
444/******************************************************************
445 * AllocateAndGetUdpExTableFromStack (IPHLPAPI.@)
446 *
447 *
448 * PARAMS
449 *
450 * ppUdpTable [Out]
451 * bOrder [In] -- passed to GetExtendedUdpTable to order the table
452 * heap [In] -- heap from which the table is allocated
453 * flags [In] -- flags to HeapAlloc
454 * family [In] -- passed to GetExtendedUdpTable to select INET family
455 *
456 * RETURNS
457 *
458 * DWORD
459 *
460 */
461DWORD WINAPI AllocateAndGetUdpExTableFromStack(PVOID *ppUdpTable,
462 BOOL bOrder, HANDLE heap, DWORD flags, DWORD family)
463{
464 DWORD ret;
465
466 TRACE("ppUdpTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx, family 0x%08lx\n",
467 ppUdpTable, (DWORD)bOrder, heap, flags, family);
468 if (!ppUdpTable)
469 ret = ERROR_INVALID_PARAMETER;
470 else {
471 DWORD dwSize = 0;
472
473 *ppUdpTable = NULL;
474 ret = GetExtendedUdpTable(*ppUdpTable, &dwSize, bOrder, family, UDP_TABLE_OWNER_PID, 0);
475 if (ret == ERROR_INSUFFICIENT_BUFFER) {
476 *ppUdpTable = (PMIB_UDPTABLE_OWNER_PID)HeapAlloc(heap, flags, dwSize);
477 ret = GetExtendedUdpTable(*ppUdpTable, &dwSize, bOrder, family, UDP_TABLE_OWNER_PID, 0);
478 if (ret != NO_ERROR) {
479 HeapFree(heap, flags, *ppUdpTable);
480 *ppUdpTable = NULL;
481 }
482 }
483 }
484 TRACE("returning %ld\n", ret);
485 return ret;
486}
487
488
489/******************************************************************
490 * AllocateAndGetUdpExTable2FromStack (IPHLPAPI.@)
491 *
492 *
493 * PARAMS
494 *
495 * ppUdpTable [Out]
496 * bOrder [In] -- passed to GetExtendedUdpTable to order the table
497 * heap [In] -- heap from which the table is allocated
498 * flags [In] -- flags to HeapAlloc
499 * family [In] -- passed to GetExtendedUdpTable to select INET family
500 * class [In] -- passed to GetExtendedUdpTable to select information
501 *
502 * RETURNS
503 *
504 * DWORD
505 *
506 */
507DWORD WINAPI AllocateAndGetUdpExTable2FromStack(PVOID *ppUdpTable,
508 BOOL bOrder, HANDLE heap, DWORD flags, DWORD family, UDP_TABLE_CLASS class)
509{
510 DWORD ret;
511
512 TRACE("ppUdpTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx, family %ld, class %ld\n",
513 ppUdpTable, (DWORD)bOrder, heap, flags, family, class);
514 if (!ppUdpTable)
515 ret = ERROR_INVALID_PARAMETER;
516 else {
517 DWORD dwSize = 0;
518
519 *ppUdpTable = NULL;
520 ret = GetExtendedUdpTable(*ppUdpTable, &dwSize, bOrder, family, class, 0);
521 if (ret == ERROR_INSUFFICIENT_BUFFER) {
522 *ppUdpTable = HeapAlloc(heap, flags, dwSize);
523 ret = GetExtendedUdpTable(*ppUdpTable, &dwSize, bOrder, family, class, 0);
524 if (ret != NO_ERROR) {
525 HeapFree(heap, flags, *ppUdpTable);
526 *ppUdpTable = NULL;
527 }
528 }
529 }
530 TRACE("returning %ld\n", ret);
531 return ret;
532}
533
534
535/******************************************************************
536 * CreateIpForwardEntry (IPHLPAPI.@)
537 *
538 *
539 * PARAMS
540 *
541 * pRoute [In/Out]
542 *
543 * RETURNS
544 *
545 * DWORD
546 *
547 */
548DWORD WINAPI CreateIpForwardEntry(PMIB_IPFORWARDROW pRoute)
549{
550 return createIpForwardEntry( pRoute );
551}
552
553
554/******************************************************************
555 * CreateIpNetEntry (IPHLPAPI.@)
556 *
557 *
558 * PARAMS
559 *
560 * pArpEntry [In/Out]
561 *
562 * RETURNS
563 *
564 * DWORD
565 *
566 */
567DWORD WINAPI CreateIpNetEntry(PMIB_IPNETROW pArpEntry)
568{
569 TRACE("pArpEntry %p\n", pArpEntry);
570 /* could use SIOCSARP on systems that support it, not sure I want to */
571 FIXME(":stub\n");
572 return (DWORD) 0;
573}
574
575
576/******************************************************************
577 * CreateProxyArpEntry (IPHLPAPI.@)
578 *
579 *
580 * PARAMS
581 *
582 * dwAddress [In]
583 * dwMask [In]
584 * dwIfIndex [In]
585 *
586 * RETURNS
587 *
588 * DWORD
589 *
590 */
591DWORD WINAPI CreateProxyArpEntry(DWORD dwAddress, DWORD dwMask, DWORD dwIfIndex)
592{
593 TRACE("dwAddress 0x%08lx, dwMask 0x%08lx, dwIfIndex 0x%08lx\n", dwAddress,
594 dwMask, dwIfIndex);
595 FIXME(":stub\n");
596 /* marking Win2K+ functions not supported */
597 return ERROR_NOT_SUPPORTED;
598}
599
600
601/******************************************************************
602 * DeleteIPAddress (IPHLPAPI.@)
603 *
604 *
605 * PARAMS
606 *
607 * NTEContext [In]
608 *
609 * RETURNS
610 *
611 * DWORD
612 *
613 */
614DWORD WINAPI DeleteIPAddress(ULONG NTEContext)
615{
616 TRACE("NTEContext %ld\n", NTEContext);
617 return RtlNtStatusToDosError(deleteIpAddress(NTEContext));
618}
619
620
621/******************************************************************
622 * DeleteIpForwardEntry (IPHLPAPI.@)
623 *
624 *
625 * PARAMS
626 *
627 * pRoute [In/Out]
628 *
629 * RETURNS
630 *
631 * DWORD
632 *
633 */
634DWORD WINAPI DeleteIpForwardEntry(PMIB_IPFORWARDROW pRoute)
635{
636 return deleteIpForwardEntry( pRoute );
637}
638
639
640/******************************************************************
641 * DeleteIpNetEntry (IPHLPAPI.@)
642 *
643 *
644 * PARAMS
645 *
646 * pArpEntry [In/Out]
647 *
648 * RETURNS
649 *
650 * DWORD
651 *
652 */
653DWORD WINAPI DeleteIpNetEntry(PMIB_IPNETROW pArpEntry)
654{
655 TRACE("pArpEntry %p\n", pArpEntry);
656 /* could use SIOCDARP on systems that support it, not sure I want to */
657 FIXME(":stub\n");
658 return (DWORD) 0;
659}
660
661
662/******************************************************************
663 * DeleteProxyArpEntry (IPHLPAPI.@)
664 *
665 *
666 * PARAMS
667 *
668 * dwAddress [In]
669 * dwMask [In]
670 * dwIfIndex [In]
671 *
672 * RETURNS
673 *
674 * DWORD
675 *
676 */
677DWORD WINAPI DeleteProxyArpEntry(DWORD dwAddress, DWORD dwMask, DWORD dwIfIndex)
678{
679 TRACE("dwAddress 0x%08lx, dwMask 0x%08lx, dwIfIndex 0x%08lx\n", dwAddress,
680 dwMask, dwIfIndex);
681 FIXME(":stub\n");
682 /* marking Win2K+ functions not supported */
683 return ERROR_NOT_SUPPORTED;
684}
685
686/******************************************************************
687 * EnableRouter (IPHLPAPI.@)
688 *
689 *
690 * PARAMS
691 *
692 * pHandle [In/Out]
693 * pOverlapped [In/Out]
694 *
695 * RETURNS
696 *
697 * DWORD
698 *
699 */
700DWORD WINAPI EnableRouter(HANDLE * pHandle, OVERLAPPED * pOverlapped)
701{
702 TRACE("pHandle %p, pOverlapped %p\n", pHandle, pOverlapped);
703 FIXME(":stub\n");
704 /* could echo "1" > /proc/net/sys/net/ipv4/ip_forward, not sure I want to
705 could map EACCESS to ERROR_ACCESS_DENIED, I suppose
706 marking Win2K+ functions not supported */
707 return ERROR_NOT_SUPPORTED;
708}
709
710
711/******************************************************************
712 * FlushIpNetTable (IPHLPAPI.@)
713 *
714 *
715 * PARAMS
716 *
717 * dwIfIndex [In]
718 *
719 * RETURNS
720 *
721 * DWORD
722 *
723 */
724DWORD WINAPI FlushIpNetTable(DWORD dwIfIndex)
725{
726 TRACE("dwIfIndex 0x%08lx\n", dwIfIndex);
727 FIXME(":stub\n");
728 /* this flushes the arp cache of the given index
729 marking Win2K+ functions not supported */
730 return ERROR_NOT_SUPPORTED;
731}
732
733
734/******************************************************************
735 * GetAdapterIndex (IPHLPAPI.@)
736 *
737 *
738 * PARAMS
739 *
740 * AdapterName [In/Out]
741 * IfIndex [In/Out]
742 *
743 * RETURNS
744 *
745 * DWORD
746 *
747 */
748DWORD WINAPI GetAdapterIndex(LPWSTR AdapterName, PULONG IfIndex)
749{
750 TRACE("AdapterName %p, IfIndex %p\n", AdapterName, IfIndex);
751 FIXME(":stub\n");
752 /* marking Win2K+ functions not supported */
753 return ERROR_NOT_SUPPORTED;
754}
755
756
757/******************************************************************
758 * GetAdaptersInfo (IPHLPAPI.@)
759 *
760 *
761 * PARAMS
762 *
763 * pAdapterInfo [In/Out]
764 * pOutBufLen [In/Out]
765 *
766 * RETURNS
767 *
768 * DWORD
769 *
770 */
771DWORD WINAPI GetAdaptersInfo(PIP_ADAPTER_INFO pAdapterInfo, PULONG pOutBufLen)
772{
773 DWORD ret;
774 BOOL dhcpEnabled;
775 DWORD dhcpServer;
776
777 TRACE("pAdapterInfo %p, pOutBufLen %p\n", pAdapterInfo, pOutBufLen);
778 if (!pOutBufLen)
779 ret = ERROR_INVALID_PARAMETER;
780 else {
781 DWORD numNonLoopbackInterfaces = getNumNonLoopbackInterfaces();
782
783 if (numNonLoopbackInterfaces > 0) {
784 /* this calculation assumes only one address in the IP_ADDR_STRING lists.
785 that's okay, because:
786 - we don't get multiple addresses per adapter anyway
787 - we don't know about per-adapter gateways
788 - DHCP and WINS servers can have max one entry per list */
789 ULONG size = sizeof(IP_ADAPTER_INFO) * numNonLoopbackInterfaces;
790
791 if (!pAdapterInfo || *pOutBufLen < size) {
792 *pOutBufLen = size;
793 ret = ERROR_BUFFER_OVERFLOW;
794 }
795 else {
796 InterfaceIndexTable *table = getNonLoopbackInterfaceIndexTable();
797
798 if (table) {
799 size = sizeof(IP_ADAPTER_INFO) * table->numIndexes;
800 if (*pOutBufLen < size) {
801 *pOutBufLen = size;
802 ret = ERROR_INSUFFICIENT_BUFFER;
803 }
804 else {
805 DWORD ndx;
806 HKEY hKey;
807 BOOL winsEnabled = FALSE;
808 IP_ADDRESS_STRING primaryWINS, secondaryWINS;
809
810 memset(pAdapterInfo, 0, size);
811 /* @@ Wine registry key: HKCU\Software\Wine\Network */
812 if (RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Network", &hKey) == ERROR_SUCCESS) {
813 DWORD size = sizeof(primaryWINS.String);
814 unsigned long addr;
815
816 RegQueryValueExA(hKey, "WinsServer", NULL, NULL,
817 (PBYTE)primaryWINS.String, &size);
818 addr = inet_addr(primaryWINS.String);
819 if (addr != INADDR_NONE && addr != INADDR_ANY)
820 winsEnabled = TRUE;
821 size = sizeof(secondaryWINS.String);
822 RegQueryValueExA(hKey, "BackupWinsServer", NULL, NULL,
823 (PBYTE)secondaryWINS.String, &size);
824 addr = inet_addr(secondaryWINS.String);
825 if (addr != INADDR_NONE && addr != INADDR_ANY)
826 winsEnabled = TRUE;
827 RegCloseKey(hKey);
828 }
829 TRACE("num of index is %lu\n", table->numIndexes);
830 for (ndx = 0; ndx < table->numIndexes; ndx++) {
831 PIP_ADAPTER_INFO ptr = &pAdapterInfo[ndx];
832 DWORD addrLen = sizeof(ptr->Address), type;
833 const char *ifname =
834 getInterfaceNameByIndex(table->indexes[ndx]);
835 if (!ifname) {
836 ret = ERROR_OUTOFMEMORY;
837 break;
838 }
839
840 /* on Win98 this is left empty, but whatever */
841 strncpy(ptr->AdapterName,ifname,sizeof(ptr->AdapterName));
842 consumeInterfaceName(ifname);
843 ptr->AdapterName[MAX_ADAPTER_NAME_LENGTH] = '\0';
844 getInterfacePhysicalByIndex(table->indexes[ndx], &addrLen,
845 ptr->Address, &type);
846 /* MS defines address length and type as UINT in some places and
847 DWORD in others, **sigh**. Don't want to assume that PUINT and
848 PDWORD are equiv (64-bit?) */
849 ptr->AddressLength = addrLen;
850 ptr->Type = type;
851 ptr->Index = table->indexes[ndx];
852 toIPAddressString(getInterfaceIPAddrByIndex(table->indexes[ndx]),
853 ptr->IpAddressList.IpAddress.String);
854 toIPAddressString(getInterfaceMaskByIndex(table->indexes[ndx]),
855 ptr->IpAddressList.IpMask.String);
856 ptr->IpAddressList.Context = ptr->Index;
857 toIPAddressString(getInterfaceGatewayByIndex(table->indexes[ndx]),
858 ptr->GatewayList.IpAddress.String);
859 getDhcpInfoForAdapter(table->indexes[ndx], &dhcpEnabled,
860 &dhcpServer, &ptr->LeaseObtained,
861 &ptr->LeaseExpires);
862 ptr->DhcpEnabled = (DWORD) dhcpEnabled;
863 toIPAddressString(dhcpServer,
864 ptr->DhcpServer.IpAddress.String);
865 if (winsEnabled) {
866 ptr->HaveWins = TRUE;
867 memcpy(ptr->PrimaryWinsServer.IpAddress.String,
868 primaryWINS.String, sizeof(primaryWINS.String));
869 memcpy(ptr->SecondaryWinsServer.IpAddress.String,
870 secondaryWINS.String, sizeof(secondaryWINS.String));
871 }
872 if (ndx < table->numIndexes - 1)
873 ptr->Next = &pAdapterInfo[ndx + 1];
874 else
875 ptr->Next = NULL;
876 }
877 ret = NO_ERROR;
878 }
879 free(table);
880 }
881 else
882 ret = ERROR_OUTOFMEMORY;
883 }
884 }
885 else
886 ret = ERROR_NO_DATA;
887 }
888 TRACE("returning %ld\n", ret);
889 return ret;
890}
891
892
893/******************************************************************
894 * GetBestInterface (IPHLPAPI.@)
895 *
896 *
897 * PARAMS
898 *
899 * dwDestAddr [In]
900 * pdwBestIfIndex [In/Out]
901 *
902 * RETURNS
903 *
904 * DWORD
905 *
906 */
907DWORD WINAPI GetBestInterface(IPAddr dwDestAddr, PDWORD pdwBestIfIndex)
908{
909 DWORD ret;
910
911 TRACE("dwDestAddr 0x%08lx, pdwBestIfIndex %p\n", dwDestAddr, pdwBestIfIndex);
912 if (!pdwBestIfIndex)
913 ret = ERROR_INVALID_PARAMETER;
914 else {
915 MIB_IPFORWARDROW ipRow;
916
917 ret = GetBestRoute(dwDestAddr, 0, &ipRow);
918 if (ret == ERROR_SUCCESS)
919 *pdwBestIfIndex = ipRow.dwForwardIfIndex;
920 }
921 TRACE("returning %ld\n", ret);
922 return ret;
923}
924
925
926/******************************************************************
927 * GetBestRoute (IPHLPAPI.@)
928 *
929 *
930 * PARAMS
931 *
932 * dwDestAddr [In]
933 * dwSourceAddr [In]
934 * OUT [In]
935 *
936 * RETURNS
937 *
938 * DWORD
939 *
940 */
941DWORD WINAPI GetBestRoute(DWORD dwDestAddr, DWORD dwSourceAddr, PMIB_IPFORWARDROW pBestRoute)
942{
943 PMIB_IPFORWARDTABLE table;
944 DWORD ret;
945
946 TRACE("dwDestAddr 0x%08lx, dwSourceAddr 0x%08lx, pBestRoute %p\n", dwDestAddr,
947 dwSourceAddr, pBestRoute);
948 if (!pBestRoute)
949 return ERROR_INVALID_PARAMETER;
950
951 AllocateAndGetIpForwardTableFromStack(&table, FALSE, GetProcessHeap(), 0);
952 if (table) {
953 DWORD ndx, minMaskSize, matchedNdx = 0;
954
955 for (ndx = 0, minMaskSize = 255; ndx < table->dwNumEntries; ndx++) {
956 if ((dwDestAddr & table->table[ndx].dwForwardMask) ==
957 (table->table[ndx].dwForwardDest & table->table[ndx].dwForwardMask)) {
958 DWORD hostMaskSize;
959
960 if (!_BitScanForward(&hostMaskSize, ntohl(table->table[ndx].dwForwardMask)))
961 {
962 hostMaskSize = 32;
963 }
964 if (hostMaskSize < minMaskSize) {
965 minMaskSize = hostMaskSize;
966 matchedNdx = ndx;
967 }
968 }
969 }
970 memcpy(pBestRoute, &table->table[matchedNdx], sizeof(MIB_IPFORWARDROW));
971 HeapFree(GetProcessHeap(), 0, table);
972 ret = ERROR_SUCCESS;
973 }
974 else
975 ret = ERROR_OUTOFMEMORY;
976 TRACE("returning %ld\n", ret);
977 return ret;
978}
979
980static int TcpTableSorter(const void *a, const void *b)
981{
982 int ret;
983
984 if (a && b) {
985 PMIB_TCPROW rowA = (PMIB_TCPROW)a, rowB = (PMIB_TCPROW)b;
986
987 ret = rowA->dwLocalAddr - rowB->dwLocalAddr;
988 if (ret == 0) {
989 ret = rowA->dwLocalPort - rowB->dwLocalPort;
990 if (ret == 0) {
991 ret = rowA->dwRemoteAddr - rowB->dwRemoteAddr;
992 if (ret == 0)
993 ret = rowA->dwRemotePort - rowB->dwRemotePort;
994 }
995 }
996 }
997 else
998 ret = 0;
999 return ret;
1000}
1001
1002/******************************************************************
1003 * GetExtendedTcpTable (IPHLPAPI.@)
1004 *
1005 * Get the table of TCP endpoints available to the application.
1006 *
1007 * PARAMS
1008 * pTcpTable [Out] table struct with the filtered TCP endpoints available to application
1009 * pdwSize [In/Out] estimated size of the structure returned in pTcpTable, in bytes
1010 * bOrder [In] whether to order the table
1011 * ulAf [in] version of IP used by the TCP endpoints
1012 * TableClass [in] type of the TCP table structure from TCP_TABLE_CLASS
1013 * Reserved [in] reserved - this value must be zero
1014 *
1015 * RETURNS
1016 * Success: NO_ERROR
1017 * Failure: either ERROR_INSUFFICIENT_BUFFER or ERROR_INVALID_PARAMETER
1018 *
1019 * NOTES
1020 */
1021
1022DWORD WINAPI GetExtendedTcpTable(PVOID pTcpTable, PDWORD pdwSize, BOOL bOrder, ULONG ulAf, TCP_TABLE_CLASS TableClass, ULONG Reserved)
1023{
1024 DWORD i, count, size;
1025 DWORD ret = NO_ERROR;
1026
1027 if (!pdwSize)
1028 {
1029 return ERROR_INVALID_PARAMETER;
1030 }
1031
1032 if (ulAf != AF_INET)
1033 {
1034 UNIMPLEMENTED;
1035 return ERROR_INVALID_PARAMETER;
1036 }
1037
1038 switch (TableClass)
1039 {
1040 case TCP_TABLE_BASIC_ALL:
1041 {
1042 PMIB_TCPTABLE pOurTcpTable = getTcpTable(ClassBasic);
1043 PMIB_TCPTABLE pTheirTcpTable = pTcpTable;
1044
1045 if (pOurTcpTable)
1046 {
1047 size = FIELD_OFFSET(MIB_TCPTABLE, table) + pOurTcpTable->dwNumEntries * sizeof(MIB_TCPROW);
1048 if (size > *pdwSize || !pTheirTcpTable)
1049 {
1050 *pdwSize = size;
1051 ret = ERROR_INSUFFICIENT_BUFFER;
1052 }
1053 else
1054 {
1055 memcpy(pTheirTcpTable, pOurTcpTable, size);
1056
1057 if (bOrder)
1058 qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
1059 sizeof(MIB_TCPROW), TcpTableSorter);
1060 }
1061
1062 HeapFree(GetProcessHeap(),0, pOurTcpTable);
1063 }
1064 }
1065 break;
1066
1067 case TCP_TABLE_BASIC_CONNECTIONS:
1068 {
1069 PMIB_TCPTABLE pOurTcpTable = getTcpTable(ClassBasic);
1070 PMIB_TCPTABLE pTheirTcpTable = pTcpTable;
1071
1072 if (pOurTcpTable)
1073 {
1074 for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1075 {
1076 if (pOurTcpTable->table[i].State != MIB_TCP_STATE_LISTEN)
1077 {
1078 ++count;
1079 }
1080 }
1081
1082 size = FIELD_OFFSET(MIB_TCPTABLE, table) + count * sizeof(MIB_TCPROW);
1083 if (size > *pdwSize || !pTheirTcpTable)
1084 {
1085 *pdwSize = size;
1086 ret = ERROR_INSUFFICIENT_BUFFER;
1087 }
1088 else
1089 {
1090 pTheirTcpTable->dwNumEntries = count;
1091
1092 for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1093 {
1094 if (pOurTcpTable->table[i].State != MIB_TCP_STATE_LISTEN)
1095 {
1096 memcpy(&pTheirTcpTable->table[count], &pOurTcpTable->table[i], sizeof(MIB_TCPROW));
1097 ++count;
1098 }
1099 }
1100 ASSERT(count == pTheirTcpTable->dwNumEntries);
1101
1102 if (bOrder)
1103 qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
1104 sizeof(MIB_TCPROW), TcpTableSorter);
1105 }
1106
1107 HeapFree(GetProcessHeap(), 0, pOurTcpTable);
1108 }
1109 }
1110 break;
1111
1112 case TCP_TABLE_BASIC_LISTENER:
1113 {
1114 PMIB_TCPTABLE pOurTcpTable = getTcpTable(ClassBasic);
1115 PMIB_TCPTABLE pTheirTcpTable = pTcpTable;
1116
1117 if (pOurTcpTable)
1118 {
1119 for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1120 {
1121 if (pOurTcpTable->table[i].State == MIB_TCP_STATE_LISTEN)
1122 {
1123 ++count;
1124 }
1125 }
1126
1127 size = FIELD_OFFSET(MIB_TCPTABLE, table) + count * sizeof(MIB_TCPROW);
1128 if (size > *pdwSize || !pTheirTcpTable)
1129 {
1130 *pdwSize = size;
1131 ret = ERROR_INSUFFICIENT_BUFFER;
1132 }
1133 else
1134 {
1135 pTheirTcpTable->dwNumEntries = count;
1136
1137 for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1138 {
1139 if (pOurTcpTable->table[i].State == MIB_TCP_STATE_LISTEN)
1140 {
1141 memcpy(&pTheirTcpTable->table[count], &pOurTcpTable->table[i], sizeof(MIB_TCPROW));
1142 ++count;
1143 }
1144 }
1145 ASSERT(count == pTheirTcpTable->dwNumEntries);
1146
1147 if (bOrder)
1148 qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
1149 sizeof(MIB_TCPROW), TcpTableSorter);
1150 }
1151
1152 HeapFree(GetProcessHeap(), 0, pOurTcpTable);
1153 }
1154 }
1155 break;
1156
1157 case TCP_TABLE_OWNER_PID_ALL:
1158 {
1159 PMIB_TCPTABLE_OWNER_PID pOurTcpTable = getTcpTable(ClassModulePid);
1160 PMIB_TCPTABLE_OWNER_PID pTheirTcpTable = pTcpTable;
1161
1162 if (pOurTcpTable)
1163 {
1164 size = FIELD_OFFSET(MIB_TCPTABLE_OWNER_PID, table) + pOurTcpTable->dwNumEntries * sizeof(MIB_TCPROW_OWNER_PID);
1165 if (size > *pdwSize || !pTheirTcpTable)
1166 {
1167 *pdwSize = size;
1168 ret = ERROR_INSUFFICIENT_BUFFER;
1169 }
1170 else
1171 {
1172 memcpy(pTheirTcpTable, pOurTcpTable, size);
1173
1174 /* Don't sort on PID, so use basic helper */
1175 if (bOrder)
1176 qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
1177 sizeof(MIB_TCPROW_OWNER_PID), TcpTableSorter);
1178 }
1179
1180 HeapFree(GetProcessHeap(), 0, pOurTcpTable);
1181 }
1182 }
1183 break;
1184
1185 case TCP_TABLE_OWNER_PID_CONNECTIONS:
1186 {
1187 PMIB_TCPTABLE_OWNER_PID pOurTcpTable = getTcpTable(ClassModulePid);
1188 PMIB_TCPTABLE_OWNER_PID pTheirTcpTable = pTcpTable;
1189
1190 if (pOurTcpTable)
1191 {
1192 for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1193 {
1194 if (pOurTcpTable->table[i].dwState != MIB_TCP_STATE_LISTEN)
1195 {
1196 ++count;
1197 }
1198 }
1199
1200 size = FIELD_OFFSET(MIB_TCPTABLE_OWNER_PID, table) + count * sizeof(MIB_TCPROW_OWNER_PID);
1201 if (size > *pdwSize || !pTheirTcpTable)
1202 {
1203 *pdwSize = size;
1204 ret = ERROR_INSUFFICIENT_BUFFER;
1205 }
1206 else
1207 {
1208 pTheirTcpTable->dwNumEntries = count;
1209
1210 for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1211 {
1212 if (pOurTcpTable->table[i].dwState != MIB_TCP_STATE_LISTEN)
1213 {
1214 memcpy(&pTheirTcpTable->table[count], &pOurTcpTable->table[i], sizeof(MIB_TCPROW_OWNER_PID));
1215 ++count;
1216 }
1217 }
1218 ASSERT(count == pTheirTcpTable->dwNumEntries);
1219
1220 /* Don't sort on PID, so use basic helper */
1221 if (bOrder)
1222 qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
1223 sizeof(MIB_TCPROW_OWNER_PID), TcpTableSorter);
1224 }
1225
1226 HeapFree(GetProcessHeap(), 0, pOurTcpTable);
1227 }
1228 }
1229 break;
1230
1231 case TCP_TABLE_OWNER_PID_LISTENER:
1232 {
1233 PMIB_TCPTABLE_OWNER_PID pOurTcpTable = getTcpTable(ClassModulePid);
1234 PMIB_TCPTABLE_OWNER_PID pTheirTcpTable = pTcpTable;
1235
1236 if (pOurTcpTable)
1237 {
1238 for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1239 {
1240 if (pOurTcpTable->table[i].dwState == MIB_TCP_STATE_LISTEN)
1241 {
1242 ++count;
1243 }
1244 }
1245
1246 size = FIELD_OFFSET(MIB_TCPTABLE_OWNER_PID, table) + count * sizeof(MIB_TCPROW_OWNER_PID);
1247 if (size > *pdwSize || !pTheirTcpTable)
1248 {
1249 *pdwSize = size;
1250 ret = ERROR_INSUFFICIENT_BUFFER;
1251 }
1252 else
1253 {
1254 pTheirTcpTable->dwNumEntries = count;
1255
1256 for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1257 {
1258 if (pOurTcpTable->table[i].dwState == MIB_TCP_STATE_LISTEN)
1259 {
1260 memcpy(&pTheirTcpTable->table[count], &pOurTcpTable->table[i], sizeof(MIB_TCPROW_OWNER_PID));
1261 ++count;
1262 }
1263 }
1264 ASSERT(count == pTheirTcpTable->dwNumEntries);
1265
1266 /* Don't sort on PID, so use basic helper */
1267 if (bOrder)
1268 qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
1269 sizeof(MIB_TCPROW_OWNER_PID), TcpTableSorter);
1270 }
1271
1272 HeapFree(GetProcessHeap(), 0, pOurTcpTable);
1273 }
1274 }
1275 break;
1276
1277 case TCP_TABLE_OWNER_MODULE_ALL:
1278 {
1279 PMIB_TCPTABLE_OWNER_MODULE pOurTcpTable = getTcpTable(ClassModule);
1280 PMIB_TCPTABLE_OWNER_MODULE pTheirTcpTable = pTcpTable;
1281
1282 if (pOurTcpTable)
1283 {
1284 size = FIELD_OFFSET(MIB_TCPTABLE_OWNER_MODULE, table) + pOurTcpTable->dwNumEntries * sizeof(MIB_TCPROW_OWNER_MODULE);
1285 if (size > *pdwSize || !pTheirTcpTable)
1286 {
1287 *pdwSize = size;
1288 ret = ERROR_INSUFFICIENT_BUFFER;
1289 }
1290 else
1291 {
1292 memcpy(pTheirTcpTable, pOurTcpTable, size);
1293
1294 /* Don't sort on PID, so use basic helper */
1295 if (bOrder)
1296 qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
1297 sizeof(MIB_TCPROW_OWNER_MODULE), TcpTableSorter);
1298 }
1299
1300 HeapFree(GetProcessHeap(), 0, pOurTcpTable);
1301 }
1302 }
1303 break;
1304
1305 case TCP_TABLE_OWNER_MODULE_CONNECTIONS:
1306 {
1307 PMIB_TCPTABLE_OWNER_MODULE pOurTcpTable = getTcpTable(ClassModule);
1308 PMIB_TCPTABLE_OWNER_MODULE pTheirTcpTable = pTcpTable;
1309
1310 if (pOurTcpTable)
1311 {
1312 for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1313 {
1314 if (pOurTcpTable->table[i].dwState != MIB_TCP_STATE_LISTEN)
1315 {
1316 ++count;
1317 }
1318 }
1319
1320 size = FIELD_OFFSET(MIB_TCPTABLE_OWNER_MODULE, table) + count * sizeof(MIB_TCPROW_OWNER_MODULE);
1321 if (size > *pdwSize || !pTheirTcpTable)
1322 {
1323 *pdwSize = size;
1324 ret = ERROR_INSUFFICIENT_BUFFER;
1325 }
1326 else
1327 {
1328 pTheirTcpTable->dwNumEntries = count;
1329
1330 for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1331 {
1332 if (pOurTcpTable->table[i].dwState != MIB_TCP_STATE_LISTEN)
1333 {
1334 memcpy(&pTheirTcpTable->table[count], &pOurTcpTable->table[i], sizeof(MIB_TCPROW_OWNER_MODULE));
1335 ++count;
1336 }
1337 }
1338 ASSERT(count == pTheirTcpTable->dwNumEntries);
1339
1340 /* Don't sort on PID, so use basic helper */
1341 if (bOrder)
1342 qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
1343 sizeof(MIB_TCPROW_OWNER_MODULE), TcpTableSorter);
1344 }
1345
1346 HeapFree(GetProcessHeap(), 0, pOurTcpTable);
1347 }
1348 }
1349 break;
1350
1351 case TCP_TABLE_OWNER_MODULE_LISTENER:
1352 {
1353 PMIB_TCPTABLE_OWNER_MODULE pOurTcpTable = getTcpTable(ClassModule);
1354 PMIB_TCPTABLE_OWNER_MODULE pTheirTcpTable = pTcpTable;
1355
1356 if (pOurTcpTable)
1357 {
1358 for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1359 {
1360 if (pOurTcpTable->table[i].dwState == MIB_TCP_STATE_LISTEN)
1361 {
1362 ++count;
1363 }
1364 }
1365
1366 size = FIELD_OFFSET(MIB_TCPTABLE_OWNER_MODULE, table) + count * sizeof(MIB_TCPROW_OWNER_MODULE);
1367 if (size > *pdwSize || !pTheirTcpTable)
1368 {
1369 *pdwSize = size;
1370 ret = ERROR_INSUFFICIENT_BUFFER;
1371 }
1372 else
1373 {
1374 pTheirTcpTable->dwNumEntries = count;
1375
1376 for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1377 {
1378 if (pOurTcpTable->table[i].dwState == MIB_TCP_STATE_LISTEN)
1379 {
1380 memcpy(&pTheirTcpTable->table[count], &pOurTcpTable->table[i], sizeof(MIB_TCPROW_OWNER_MODULE));
1381 ++count;
1382 }
1383 }
1384 ASSERT(count == pTheirTcpTable->dwNumEntries);
1385
1386 /* Don't sort on PID, so use basic helper */
1387 if (bOrder)
1388 qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
1389 sizeof(MIB_TCPROW_OWNER_MODULE), TcpTableSorter);
1390 }
1391
1392 HeapFree(GetProcessHeap(), 0, pOurTcpTable);
1393 }
1394 }
1395 break;
1396
1397 default:
1398 ret = ERROR_INVALID_PARAMETER;
1399 break;
1400 }
1401
1402 return ret;
1403}
1404
1405
1406static int UdpTableSorter(const void *a, const void *b)
1407{
1408 int ret;
1409
1410 if (a && b) {
1411 PMIB_UDPROW rowA = (PMIB_UDPROW)a, rowB = (PMIB_UDPROW)b;
1412
1413 ret = rowA->dwLocalAddr - rowB->dwLocalAddr;
1414 if (ret == 0)
1415 ret = rowA->dwLocalPort - rowB->dwLocalPort;
1416 }
1417 else
1418 ret = 0;
1419 return ret;
1420}
1421
1422/******************************************************************
1423 * GetExtendedUdpTable (IPHLPAPI.@)
1424 *
1425 * Get the table of UDP endpoints available to the application.
1426 *
1427 * PARAMS
1428 * pUdpTable [Out] table struct with the filtered UDP endpoints available to application
1429 * pdwSize [In/Out] estimated size of the structure returned in pUdpTable, in bytes
1430 * bOrder [In] whether to order the table
1431 * ulAf [in] version of IP used by the UDP endpoints
1432 * TableClass [in] type of the UDP table structure from UDP_TABLE_CLASS
1433 * Reserved [in] reserved - this value must be zero
1434 *
1435 * RETURNS
1436 * Success: NO_ERROR
1437 * Failure: either ERROR_INSUFFICIENT_BUFFER or ERROR_INVALID_PARAMETER
1438 *
1439 * NOTES
1440 */
1441
1442DWORD WINAPI GetExtendedUdpTable(PVOID pUdpTable, PDWORD pdwSize, BOOL bOrder, ULONG ulAf, UDP_TABLE_CLASS TableClass, ULONG Reserved)
1443{
1444 DWORD size;
1445 DWORD ret = NO_ERROR;
1446
1447 if (!pdwSize)
1448 {
1449 return ERROR_INVALID_PARAMETER;
1450 }
1451
1452 if (ulAf != AF_INET)
1453 {
1454 UNIMPLEMENTED;
1455 return ERROR_INVALID_PARAMETER;
1456 }
1457
1458 switch (TableClass)
1459 {
1460 case UDP_TABLE_BASIC:
1461 {
1462 PMIB_UDPTABLE pOurUdpTable = getUdpTable(ClassBasic);
1463 PMIB_UDPTABLE pTheirUdpTable = pUdpTable;
1464
1465 if (pOurUdpTable)
1466 {
1467 size = FIELD_OFFSET(MIB_UDPTABLE, table) + pOurUdpTable->dwNumEntries * sizeof(MIB_UDPROW);
1468 if (size > *pdwSize || !pTheirUdpTable)
1469 {
1470 *pdwSize = size;
1471 ret = ERROR_INSUFFICIENT_BUFFER;
1472 }
1473 else
1474 {
1475 memcpy(pTheirUdpTable, pOurUdpTable, size);
1476
1477 if (bOrder)
1478 qsort(pTheirUdpTable->table, pTheirUdpTable->dwNumEntries,
1479 sizeof(MIB_UDPROW), UdpTableSorter);
1480 }
1481
1482 HeapFree(GetProcessHeap(), 0, pOurUdpTable);
1483 }
1484 }
1485 break;
1486
1487 case UDP_TABLE_OWNER_PID:
1488 {
1489 PMIB_UDPTABLE_OWNER_PID pOurUdpTable = getUdpTable(ClassModulePid);
1490 PMIB_UDPTABLE_OWNER_PID pTheirUdpTable = pUdpTable;
1491
1492 if (pOurUdpTable)
1493 {
1494 size = FIELD_OFFSET(MIB_UDPTABLE_OWNER_PID, table) + pOurUdpTable->dwNumEntries * sizeof(MIB_UDPROW_OWNER_PID);
1495 if (size > *pdwSize || !pTheirUdpTable)
1496 {
1497 *pdwSize = size;
1498 ret = ERROR_INSUFFICIENT_BUFFER;
1499 }
1500 else
1501 {
1502 memcpy(pTheirUdpTable, pOurUdpTable, size);
1503
1504 if (bOrder)
1505 qsort(pTheirUdpTable->table, pTheirUdpTable->dwNumEntries,
1506 sizeof(MIB_UDPROW_OWNER_PID), UdpTableSorter);
1507 }
1508
1509 HeapFree(GetProcessHeap(), 0, pOurUdpTable);
1510 }
1511 }
1512 break;
1513
1514 case UDP_TABLE_OWNER_MODULE:
1515 {
1516 PMIB_UDPTABLE_OWNER_MODULE pOurUdpTable = getUdpTable(ClassModule);
1517 PMIB_UDPTABLE_OWNER_MODULE pTheirUdpTable = pUdpTable;
1518
1519 if (pOurUdpTable)
1520 {
1521 size = FIELD_OFFSET(MIB_UDPTABLE_OWNER_MODULE, table) + pOurUdpTable->dwNumEntries * sizeof(MIB_UDPROW_OWNER_MODULE);
1522 if (size > *pdwSize || !pTheirUdpTable)
1523 {
1524 *pdwSize = size;
1525 ret = ERROR_INSUFFICIENT_BUFFER;
1526 }
1527 else
1528 {
1529 memcpy(pTheirUdpTable, pOurUdpTable, size);
1530
1531 if (bOrder)
1532 qsort(pTheirUdpTable->table, pTheirUdpTable->dwNumEntries,
1533 sizeof(MIB_UDPROW_OWNER_MODULE), UdpTableSorter);
1534 }
1535
1536 HeapFree(GetProcessHeap(), 0, pOurUdpTable);
1537 }
1538 }
1539 break;
1540
1541 default:
1542 ret = ERROR_INVALID_PARAMETER;
1543 break;
1544 }
1545
1546 return ret;
1547}
1548
1549
1550/******************************************************************
1551 * GetFriendlyIfIndex (IPHLPAPI.@)
1552 *
1553 *
1554 * PARAMS
1555 *
1556 * IfIndex [In]
1557 *
1558 * RETURNS
1559 *
1560 * DWORD
1561 *
1562 */
1563DWORD WINAPI GetFriendlyIfIndex(DWORD IfIndex)
1564{
1565 /* windows doesn't validate these, either, just makes sure the top byte is
1566 cleared. I assume my ifenum module never gives an index with the top
1567 byte set. */
1568 TRACE("returning %ld\n", IfIndex);
1569 return IfIndex;
1570}
1571
1572
1573/******************************************************************
1574 * GetIcmpStatistics (IPHLPAPI.@)
1575 *
1576 *
1577 * PARAMS
1578 *
1579 * pStats [In/Out]
1580 *
1581 * RETURNS
1582 *
1583 * DWORD
1584 *
1585 */
1586DWORD WINAPI GetIcmpStatistics(PMIB_ICMP pStats)
1587{
1588 DWORD ret;
1589
1590 TRACE("pStats %p\n", pStats);
1591 ret = getICMPStats(pStats);
1592 TRACE("returning %ld\n", ret);
1593 return ret;
1594}
1595
1596
1597/******************************************************************
1598 * GetIfEntry (IPHLPAPI.@)
1599 *
1600 *
1601 * PARAMS
1602 *
1603 * pIfRow [In/Out]
1604 *
1605 * RETURNS
1606 *
1607 * DWORD
1608 *
1609 */
1610DWORD WINAPI GetIfEntry(PMIB_IFROW pIfRow)
1611{
1612 DWORD ret;
1613 const char *name;
1614
1615 TRACE("pIfRow %p\n", pIfRow);
1616 if (!pIfRow)
1617 return ERROR_INVALID_PARAMETER;
1618
1619 name = getInterfaceNameByIndex(pIfRow->dwIndex);
1620 if (name) {
1621 ret = getInterfaceEntryByIndex(pIfRow->dwIndex, pIfRow);
1622 if (ret == NO_ERROR)
1623 ret = getInterfaceStatsByName(name, pIfRow);
1624 consumeInterfaceName(name);
1625 }
1626 else
1627 ret = ERROR_INVALID_DATA;
1628 TRACE("returning %ld\n", ret);
1629 return ret;
1630}
1631
1632
1633static int IfTableSorter(const void *a, const void *b)
1634{
1635 int ret;
1636
1637 if (a && b)
1638 ret = ((PMIB_IFROW)a)->dwIndex - ((PMIB_IFROW)b)->dwIndex;
1639 else
1640 ret = 0;
1641 return ret;
1642}
1643
1644
1645/******************************************************************
1646 * GetIfTable (IPHLPAPI.@)
1647 *
1648 *
1649 * PARAMS
1650 *
1651 * pIfTable [In/Out]
1652 * pdwSize [In/Out]
1653 * bOrder [In]
1654 *
1655 * RETURNS
1656 *
1657 * DWORD
1658 *
1659 */
1660DWORD WINAPI GetIfTable(PMIB_IFTABLE pIfTable, PULONG pdwSize, BOOL bOrder)
1661{
1662 DWORD ret;
1663
1664 TRACE("pIfTable %p, pdwSize %p, bOrder %ld\n", pdwSize, pdwSize,
1665 (DWORD)bOrder);
1666 if (!pdwSize)
1667 ret = ERROR_INVALID_PARAMETER;
1668 else {
1669 DWORD numInterfaces = getNumInterfaces();
1670 ULONG size;
1671 TRACE("GetIfTable: numInterfaces = %d\n", (int)numInterfaces);
1672 size = sizeof(MIB_IFTABLE) + (numInterfaces - 1) * sizeof(MIB_IFROW);
1673
1674 if (!pIfTable || *pdwSize < size) {
1675 *pdwSize = size;
1676 ret = ERROR_INSUFFICIENT_BUFFER;
1677 }
1678 else {
1679 InterfaceIndexTable *table = getInterfaceIndexTable();
1680
1681 if (table) {
1682 size = sizeof(MIB_IFTABLE) + (table->numIndexes - 1) *
1683 sizeof(MIB_IFROW);
1684 if (*pdwSize < size) {
1685 *pdwSize = size;
1686 ret = ERROR_INSUFFICIENT_BUFFER;
1687 }
1688 else {
1689 DWORD ndx;
1690
1691 pIfTable->dwNumEntries = 0;
1692 for (ndx = 0; ndx < table->numIndexes; ndx++) {
1693 pIfTable->table[ndx].dwIndex = table->indexes[ndx];
1694 GetIfEntry(&pIfTable->table[ndx]);
1695 pIfTable->dwNumEntries++;
1696 }
1697 if (bOrder)
1698 qsort(pIfTable->table, pIfTable->dwNumEntries, sizeof(MIB_IFROW),
1699 IfTableSorter);
1700 ret = NO_ERROR;
1701 }
1702 free(table);
1703 }
1704 else
1705 ret = ERROR_OUTOFMEMORY;
1706 }
1707 }
1708 TRACE("returning %ld\n", ret);
1709 return ret;
1710}
1711
1712
1713/******************************************************************
1714 * GetInterfaceInfo (IPHLPAPI.@)
1715 *
1716 *
1717 * PARAMS
1718 *
1719 * pIfTable [In/Out]
1720 * dwOutBufLen [In/Out]
1721 *
1722 * RETURNS
1723 *
1724 * DWORD
1725 *
1726 */
1727DWORD WINAPI GetInterfaceInfo(PIP_INTERFACE_INFO pIfTable, PULONG dwOutBufLen)
1728{
1729 DWORD ret;
1730
1731 TRACE("pIfTable %p, dwOutBufLen %p\n", pIfTable, dwOutBufLen);
1732 if (!dwOutBufLen)
1733 ret = ERROR_INVALID_PARAMETER;
1734 else {
1735 DWORD numNonLoopbackInterfaces = getNumNonLoopbackInterfaces();
1736 ULONG size;
1737 TRACE("numNonLoopbackInterfaces == 0x%x\n", numNonLoopbackInterfaces);
1738 size = sizeof(IP_INTERFACE_INFO) + (numNonLoopbackInterfaces) *
1739 sizeof(IP_ADAPTER_INDEX_MAP);
1740
1741 if (!pIfTable || *dwOutBufLen < size) {
1742 *dwOutBufLen = size;
1743 ret = ERROR_INSUFFICIENT_BUFFER;
1744 }
1745 else {
1746 InterfaceIndexTable *table = getNonLoopbackInterfaceIndexTable();
1747
1748 if (table) {
1749 TRACE("table->numIndexes == 0x%x\n", table->numIndexes);
1750 size = sizeof(IP_INTERFACE_INFO) + (table->numIndexes) *
1751 sizeof(IP_ADAPTER_INDEX_MAP);
1752 if (*dwOutBufLen < size) {
1753 *dwOutBufLen = size;
1754 ret = ERROR_INSUFFICIENT_BUFFER;
1755 }
1756 else {
1757 DWORD ndx;
1758
1759 pIfTable->NumAdapters = 0;
1760 for (ndx = 0; ndx < table->numIndexes; ndx++) {
1761 const char *walker, *name;
1762 WCHAR *assigner;
1763
1764 pIfTable->Adapter[ndx].Index = table->indexes[ndx];
1765 name = getInterfaceNameByIndex(table->indexes[ndx]);
1766 wcscpy(pIfTable->Adapter[ndx].Name, L"\\DEVICE\\TCPIP_");
1767 for (walker = name, assigner = &pIfTable->Adapter[ndx].Name[14];
1768 walker && *walker &&
1769 assigner - pIfTable->Adapter[ndx].Name < MAX_ADAPTER_NAME - 1 - 14;
1770 walker++, assigner++)
1771 *assigner = *walker;
1772 *assigner = 0;
1773 consumeInterfaceName(name);
1774 pIfTable->NumAdapters++;
1775 }
1776 ret = NO_ERROR;
1777 }
1778 free(table);
1779 }
1780 else
1781 ret = ERROR_OUTOFMEMORY;
1782 }
1783 }
1784 TRACE("returning %ld\n", ret);
1785 return ret;
1786}
1787
1788
1789static int IpAddrTableSorter(const void *a, const void *b)
1790{
1791 int ret;
1792
1793 if (a && b)
1794 ret = ((PMIB_IPADDRROW)a)->dwAddr - ((PMIB_IPADDRROW)b)->dwAddr;
1795 else
1796 ret = 0;
1797 return ret;
1798}
1799
1800
1801/******************************************************************
1802 * GetIpAddrTable (IPHLPAPI.@)
1803 *
1804 *
1805 * PARAMS
1806 *
1807 * pIpAddrTable [In/Out]
1808 * pdwSize [In/Out]
1809 * bOrder [In]
1810 *
1811 * RETURNS
1812 *
1813 * DWORD
1814 *
1815 */
1816DWORD WINAPI GetIpAddrTable(PMIB_IPADDRTABLE pIpAddrTable, PULONG pdwSize, BOOL bOrder)
1817{
1818 DWORD ret;
1819
1820 TRACE("pIpAddrTable %p, pdwSize %p, bOrder %ld\n", pIpAddrTable, pdwSize,
1821 (DWORD)bOrder);
1822 if (!pdwSize)
1823 ret = ERROR_INVALID_PARAMETER;
1824 else {
1825 DWORD numInterfaces = getNumInterfaces();
1826 ULONG size = sizeof(MIB_IPADDRTABLE) + (numInterfaces - 1) *
1827 sizeof(MIB_IPADDRROW);
1828
1829 if (!pIpAddrTable || *pdwSize < size) {
1830 *pdwSize = size;
1831 ret = ERROR_INSUFFICIENT_BUFFER;
1832 }
1833 else {
1834 InterfaceIndexTable *table = getInterfaceIndexTable();
1835
1836 if (table) {
1837 size = sizeof(MIB_IPADDRTABLE) + (table->numIndexes - 1) *
1838 sizeof(MIB_IPADDRROW);
1839 if (*pdwSize < size) {
1840 *pdwSize = size;
1841 ret = ERROR_INSUFFICIENT_BUFFER;
1842 }
1843 else {
1844 DWORD ndx, bcast;
1845
1846 pIpAddrTable->dwNumEntries = 0;
1847 for (ndx = 0; ndx < table->numIndexes; ndx++) {
1848 pIpAddrTable->table[ndx].dwIndex = table->indexes[ndx];
1849 pIpAddrTable->table[ndx].dwAddr =
1850 getInterfaceIPAddrByIndex(table->indexes[ndx]);
1851 pIpAddrTable->table[ndx].dwMask =
1852 getInterfaceMaskByIndex(table->indexes[ndx]);
1853 /* the dwBCastAddr member isn't the broadcast address, it indicates
1854 * whether the interface uses the 1's broadcast address (1) or the
1855 * 0's broadcast address (0).
1856 */
1857 bcast = getInterfaceBCastAddrByIndex(table->indexes[ndx]);
1858 pIpAddrTable->table[ndx].dwBCastAddr =
1859 (bcast & pIpAddrTable->table[ndx].dwMask) ? 1 : 0;
1860 /* FIXME: hardcoded reasm size, not sure where to get it */
1861 pIpAddrTable->table[ndx].dwReasmSize = 65535;
1862 pIpAddrTable->table[ndx].unused1 = 0;
1863 pIpAddrTable->table[ndx].wType = 0; /* aka unused2 */
1864 pIpAddrTable->dwNumEntries++;
1865 }
1866 if (bOrder)
1867 qsort(pIpAddrTable->table, pIpAddrTable->dwNumEntries,
1868 sizeof(MIB_IPADDRROW), IpAddrTableSorter);
1869 ret = NO_ERROR;
1870 }
1871 free(table);
1872 }
1873 else
1874 ret = ERROR_OUTOFMEMORY;
1875 }
1876 }
1877 TRACE("returning %ld\n", ret);
1878 return ret;
1879}
1880
1881
1882static int IpForwardTableSorter(const void *a, const void *b)
1883{
1884 int ret;
1885
1886 if (a && b) {
1887 PMIB_IPFORWARDROW rowA = (PMIB_IPFORWARDROW)a, rowB = (PMIB_IPFORWARDROW)b;
1888
1889 ret = rowA->dwForwardDest - rowB->dwForwardDest;
1890 if (ret == 0) {
1891 ret = rowA->dwForwardProto - rowB->dwForwardProto;
1892 if (ret == 0) {
1893 ret = rowA->dwForwardPolicy - rowB->dwForwardPolicy;
1894 if (ret == 0)
1895 ret = rowA->dwForwardNextHop - rowB->dwForwardNextHop;
1896 }
1897 }
1898 }
1899 else
1900 ret = 0;
1901 return ret;
1902}
1903
1904
1905/******************************************************************
1906 * GetIpForwardTable (IPHLPAPI.@)
1907 *
1908 *
1909 * PARAMS
1910 *
1911 * pIpForwardTable [In/Out]
1912 * pdwSize [In/Out]
1913 * bOrder [In]
1914 *
1915 * RETURNS
1916 *
1917 * DWORD
1918 *
1919 */
1920DWORD WINAPI GetIpForwardTable(PMIB_IPFORWARDTABLE pIpForwardTable, PULONG pdwSize, BOOL bOrder)
1921{
1922 DWORD ret;
1923
1924 TRACE("pIpForwardTable %p, pdwSize %p, bOrder %ld\n", pIpForwardTable,
1925 pdwSize, (DWORD)bOrder);
1926 if (!pdwSize)
1927 ret = ERROR_INVALID_PARAMETER;
1928 else {
1929 DWORD numRoutes = getNumRoutes();
1930 ULONG sizeNeeded = sizeof(MIB_IPFORWARDTABLE) + (numRoutes - 1) *
1931 sizeof(MIB_IPFORWARDROW);
1932
1933 if (!pIpForwardTable || *pdwSize < sizeNeeded) {
1934 *pdwSize = sizeNeeded;
1935 ret = ERROR_INSUFFICIENT_BUFFER;
1936 }
1937 else {
1938 RouteTable *table = getRouteTable();
1939 if (table) {
1940 sizeNeeded = sizeof(MIB_IPFORWARDTABLE) + (table->numRoutes - 1) *
1941 sizeof(MIB_IPFORWARDROW);
1942 if (*pdwSize < sizeNeeded) {
1943 *pdwSize = sizeNeeded;
1944 ret = ERROR_INSUFFICIENT_BUFFER;
1945 }
1946 else {
1947 DWORD ndx;
1948
1949 pIpForwardTable->dwNumEntries = table->numRoutes;
1950 for (ndx = 0; ndx < numRoutes; ndx++) {
1951 pIpForwardTable->table[ndx].dwForwardIfIndex =
1952 table->routes[ndx].ifIndex;
1953 pIpForwardTable->table[ndx].dwForwardDest =
1954 table->routes[ndx].dest;
1955 pIpForwardTable->table[ndx].dwForwardMask =
1956 table->routes[ndx].mask;
1957 pIpForwardTable->table[ndx].dwForwardPolicy = 0;
1958 pIpForwardTable->table[ndx].dwForwardNextHop =
1959 table->routes[ndx].gateway;
1960 /* FIXME: this type is appropriate for local interfaces; may not
1961 always be appropriate */
1962 pIpForwardTable->table[ndx].dwForwardType = MIB_IPROUTE_TYPE_DIRECT;
1963 /* FIXME: other protos might be appropriate, e.g. the default route
1964 is typically set with MIB_IPPROTO_NETMGMT instead */
1965 pIpForwardTable->table[ndx].dwForwardProto = MIB_IPPROTO_LOCAL;
1966 /* punt on age and AS */
1967 pIpForwardTable->table[ndx].dwForwardAge = 0;
1968 pIpForwardTable->table[ndx].dwForwardNextHopAS = 0;
1969 pIpForwardTable->table[ndx].dwForwardMetric1 =
1970 table->routes[ndx].metric;
1971 /* rest of the metrics are 0.. */
1972 pIpForwardTable->table[ndx].dwForwardMetric2 = 0;
1973 pIpForwardTable->table[ndx].dwForwardMetric3 = 0;
1974 pIpForwardTable->table[ndx].dwForwardMetric4 = 0;
1975 pIpForwardTable->table[ndx].dwForwardMetric5 = 0;
1976 }
1977 if (bOrder)
1978 qsort(pIpForwardTable->table, pIpForwardTable->dwNumEntries,
1979 sizeof(MIB_IPFORWARDROW), IpForwardTableSorter);
1980 ret = NO_ERROR;
1981 }
1982 HeapFree(GetProcessHeap(), 0, table);
1983 }
1984 else
1985 ret = ERROR_OUTOFMEMORY;
1986 }
1987 }
1988 TRACE("returning %ld\n", ret);
1989 return ret;
1990}
1991
1992
1993static int IpNetTableSorter(const void *a, const void *b)
1994{
1995 int ret;
1996
1997 if (a && b)
1998 ret = ((PMIB_IPNETROW)a)->dwAddr - ((PMIB_IPNETROW)b)->dwAddr;
1999 else
2000 ret = 0;
2001 return ret;
2002}
2003
2004
2005/******************************************************************
2006 * GetIpNetTable (IPHLPAPI.@)
2007 *
2008 *
2009 * PARAMS
2010 *
2011 * pIpNetTable [In/Out]
2012 * pdwSize [In/Out]
2013 * bOrder [In]
2014 *
2015 * RETURNS
2016 *
2017 * DWORD
2018 *
2019 */
2020DWORD WINAPI GetIpNetTable(PMIB_IPNETTABLE pIpNetTable, PULONG pdwSize, BOOL bOrder)
2021{
2022 DWORD ret = NO_ERROR;
2023
2024 TRACE("pIpNetTable %p, pdwSize %p, bOrder %d\n", pIpNetTable, pdwSize,
2025 (DWORD)bOrder);
2026 if (!pdwSize)
2027 ret = ERROR_INVALID_PARAMETER;
2028 else {
2029 DWORD numEntries = getNumArpEntries();
2030 ULONG size = sizeof(MIB_IPNETTABLE);
2031
2032 if (numEntries > 1)
2033 size += (numEntries - 1) * sizeof(MIB_IPNETROW);
2034 if (!pIpNetTable || *pdwSize < size) {
2035 *pdwSize = size;
2036 ret = ERROR_INSUFFICIENT_BUFFER;
2037 }
2038 else {
2039 PMIB_IPNETTABLE table = getArpTable();
2040 if (table) {
2041 size = sizeof(MIB_IPNETTABLE);
2042 if (table->dwNumEntries > 1)
2043 size += (table->dwNumEntries - 1) * sizeof(MIB_IPNETROW);
2044 if (*pdwSize < size) {
2045 *pdwSize = size;
2046 ret = ERROR_INSUFFICIENT_BUFFER;
2047 }
2048 else {
2049 *pdwSize = size;
2050 memcpy(pIpNetTable, table, size);
2051 if (bOrder)
2052 qsort(pIpNetTable->table, pIpNetTable->dwNumEntries,
2053 sizeof(MIB_IPNETROW), IpNetTableSorter);
2054 ret = NO_ERROR;
2055 }
2056 HeapFree(GetProcessHeap(), 0, table);
2057 }
2058 }
2059 }
2060 TRACE("returning %d\n", ret);
2061 return ret;
2062}
2063
2064
2065/******************************************************************
2066 * GetIpStatistics (IPHLPAPI.@)
2067 *
2068 *
2069 * PARAMS
2070 *
2071 * pStats [In/Out]
2072 *
2073 * RETURNS
2074 *
2075 * DWORD
2076 *
2077 */
2078DWORD WINAPI GetIpStatistics(PMIB_IPSTATS pStats)
2079{
2080 return GetIpStatisticsEx(pStats, PF_INET);
2081}
2082
2083/******************************************************************
2084 * GetIpStatisticsEx (IPHLPAPI.@)
2085 *
2086 *
2087 * PARAMS
2088 *
2089 * pStats [In/Out]
2090 * dwFamily [In]
2091 *
2092 * RETURNS
2093 *
2094 * DWORD
2095 *
2096 */
2097DWORD WINAPI GetIpStatisticsEx(PMIB_IPSTATS pStats, DWORD dwFamily)
2098{
2099 DWORD ret;
2100
2101 TRACE("pStats %p\n", pStats);
2102 ret = getIPStats(pStats, dwFamily);
2103 TRACE("returning %ld\n", ret);
2104 return ret;
2105}
2106
2107/******************************************************************
2108 * GetNetworkParams (IPHLPAPI.@)
2109 *
2110 *
2111 * PARAMS
2112 *
2113 * pFixedInfo [In/Out]
2114 * pOutBufLen [In/Out]
2115 *
2116 * RETURNS
2117 *
2118 * DWORD
2119 *
2120 */
2121DWORD WINAPI GetNetworkParams(PFIXED_INFO pFixedInfo, PULONG pOutBufLen)
2122{
2123 DWORD ret, size, type;
2124 LONG regReturn;
2125 HKEY hKey;
2126 PIPHLP_RES_INFO resInfo;
2127
2128 TRACE("pFixedInfo %p, pOutBufLen %p\n", pFixedInfo, pOutBufLen);
2129 if (!pOutBufLen)
2130 return ERROR_INVALID_PARAMETER;
2131
2132 resInfo = getResInfo();
2133 if (!resInfo)
2134 return ERROR_OUTOFMEMORY;
2135
2136 size = sizeof(FIXED_INFO) + (resInfo->riCount > 1 ? (resInfo->riCount-1) *
2137 sizeof(IP_ADDR_STRING) : 0);
2138 if (!pFixedInfo || *pOutBufLen < size) {
2139 *pOutBufLen = size;
2140 disposeResInfo( resInfo );
2141 return ERROR_BUFFER_OVERFLOW;
2142 }
2143
2144 memset(pFixedInfo, 0, size);
2145 /* Check for DhcpHostname and DhcpDomain first */
2146 regReturn = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
2147 "SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters",
2148 0,
2149 KEY_READ,
2150 &hKey);
2151 if (regReturn == ERROR_SUCCESS) {
2152 /* Windows doesn't honor DHCP option 12 even if RFC requires it if it is returned by DHCP server! */
2153#if 0
2154 type = REG_SZ;
2155 size = sizeof(pFixedInfo->HostName);
2156 regReturn = RegQueryValueExA(hKey,
2157 "DhcpHostname",
2158 NULL,
2159 &type,
2160 (LPBYTE)pFixedInfo->HostName,
2161 &size);
2162 if (regReturn == ERROR_FILE_NOT_FOUND || (regReturn == ERROR_SUCCESS && size < 1))
2163 {
2164#endif
2165 type = REG_SZ;
2166 size = sizeof(pFixedInfo->HostName);
2167 regReturn = RegQueryValueExA(hKey,
2168 "Hostname",
2169 NULL,
2170 &type,
2171 (LPBYTE)pFixedInfo->HostName,
2172 &size);
2173#if 0
2174 }
2175#endif
2176
2177 type = REG_SZ;
2178 size = sizeof(pFixedInfo->DomainName);
2179 regReturn = RegQueryValueExA(hKey,
2180 "DhcpDomain",
2181 NULL,
2182 &type,
2183 (LPBYTE)pFixedInfo->DomainName,
2184 &size);
2185 if (regReturn == ERROR_FILE_NOT_FOUND || (regReturn == ERROR_SUCCESS && size < 1))
2186 {
2187 type = REG_SZ;
2188 size = sizeof(pFixedInfo->DomainName);
2189 regReturn = RegQueryValueExA(hKey,
2190 "Domain",
2191 NULL,
2192 &type,
2193 (LPBYTE)pFixedInfo->DomainName,
2194 &size);
2195 }
2196 RegCloseKey(hKey);
2197 }
2198
2199 TRACE("GetComputerNameExA: %s\n", pFixedInfo->DomainName);
2200
2201 if (resInfo->riCount > 0)
2202 {
2203 CopyMemory(&pFixedInfo->DnsServerList, resInfo->DnsList, sizeof(IP_ADDR_STRING));
2204 if (resInfo->riCount > 1)
2205 {
2206 IP_ADDR_STRING *pSrc = resInfo->DnsList->Next;
2207 IP_ADDR_STRING *pTarget = (struct _IP_ADDR_STRING*)((char*)pFixedInfo + sizeof(FIXED_INFO));
2208
2209 pFixedInfo->DnsServerList.Next = pTarget;
2210
2211 do
2212 {
2213 CopyMemory(pTarget, pSrc, sizeof(IP_ADDR_STRING));
2214 resInfo->riCount--;
2215 if (resInfo->riCount > 1)
2216 {
2217 pTarget->Next = (IP_ADDR_STRING*)((char*)pTarget + sizeof(IP_ADDR_STRING));
2218 pTarget = pTarget->Next;
2219 pSrc = pSrc->Next;
2220 }
2221 else
2222 {
2223 pTarget->Next = NULL;
2224 break;
2225 }
2226 }
2227 while(TRUE);
2228 }
2229 else
2230 {
2231 pFixedInfo->DnsServerList.Next = NULL;
2232 }
2233 }
2234
2235 pFixedInfo->NodeType = HYBRID_NODETYPE;
2236 regReturn = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
2237 "SYSTEM\\CurrentControlSet\\Services\\VxD\\MSTCP", 0, KEY_READ, &hKey);
2238 if (regReturn != ERROR_SUCCESS)
2239 regReturn = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
2240 "SYSTEM\\CurrentControlSet\\Services\\NetBT\\Parameters", 0, KEY_READ,
2241 &hKey);
2242 if (regReturn == ERROR_SUCCESS)
2243 {
2244 DWORD size = sizeof(pFixedInfo->ScopeId);
2245
2246 RegQueryValueExA(hKey, "ScopeID", NULL, NULL, (PBYTE)pFixedInfo->ScopeId, &size);
2247 RegCloseKey(hKey);
2248 }
2249
2250 disposeResInfo( resInfo );
2251 /* FIXME: can check whether routing's enabled in /proc/sys/net/ipv4/ip_forward
2252 I suppose could also check for a listener on port 53 to set EnableDns */
2253 ret = NO_ERROR;
2254 TRACE("returning %ld\n", ret);
2255
2256 return ret;
2257}
2258
2259
2260/******************************************************************
2261 * GetNumberOfInterfaces (IPHLPAPI.@)
2262 *
2263 *
2264 * PARAMS
2265 *
2266 * pdwNumIf [In/Out]
2267 *
2268 * RETURNS
2269 *
2270 * DWORD
2271 *
2272 */
2273DWORD WINAPI GetNumberOfInterfaces(PDWORD pdwNumIf)
2274{
2275 DWORD ret;
2276
2277 TRACE("pdwNumIf %p\n", pdwNumIf);
2278 if (!pdwNumIf)
2279 ret = ERROR_INVALID_PARAMETER;
2280 else {
2281 *pdwNumIf = getNumInterfaces();
2282 ret = NO_ERROR;
2283 }
2284 TRACE("returning %ld\n", ret);
2285 return ret;
2286}
2287
2288
2289static DWORD GetOwnerModuleFromPidEntry(DWORD OwningPid, TCPIP_OWNER_MODULE_INFO_CLASS Class, PVOID Buffer, PDWORD pdwSize)
2290{
2291 HANDLE Process;
2292 DWORD FileLen, PathLen, Error;
2293 WCHAR File[MAX_PATH], Path[MAX_PATH];
2294 PTCPIP_OWNER_MODULE_BASIC_INFO BasicInfo;
2295
2296 if (IsBadWritePtr(pdwSize, sizeof(DWORD)) ||
2297 IsBadWritePtr(Buffer, *pdwSize))
2298 {
2299 return ERROR_INVALID_PARAMETER;
2300 }
2301
2302 if (OwningPid == 0)
2303 {
2304 return ERROR_NOT_FOUND;
2305 }
2306
2307 Process = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, OwningPid);
2308 if (Process == NULL)
2309 {
2310 return GetLastError();
2311 }
2312
2313 FileLen = GetModuleBaseNameW(Process, NULL, File, MAX_PATH);
2314 if (FileLen != 0)
2315 {
2316 PathLen = GetModuleFileNameExW(Process, NULL, Path, MAX_PATH);
2317 if (PathLen == 0)
2318 {
2319 CloseHandle(Process);
2320 return GetLastError();
2321 }
2322
2323 /* Add NULL char */
2324 ++FileLen;
2325 ++PathLen;
2326 PathLen *= sizeof(WCHAR);
2327 FileLen *= sizeof(WCHAR);
2328 }
2329 else
2330 {
2331 Error = GetLastError();
2332
2333 if (Error == ERROR_PARTIAL_COPY)
2334 {
2335 wcscpy(File, L"System");
2336 wcscpy(Path, L"System");
2337
2338 PathLen = sizeof(L"System");
2339 FileLen = sizeof(L"System");
2340 }
2341 else
2342 {
2343 CloseHandle(Process);
2344 return Error;
2345 }
2346 }
2347
2348 CloseHandle(Process);
2349
2350 if (*pdwSize < sizeof(TCPIP_OWNER_MODULE_BASIC_INFO) + PathLen + FileLen)
2351 {
2352 *pdwSize = sizeof(TCPIP_OWNER_MODULE_BASIC_INFO) + PathLen + FileLen;
2353 return ERROR_INSUFFICIENT_BUFFER;
2354 }
2355
2356 BasicInfo = Buffer;
2357 BasicInfo->pModuleName = (PVOID)((ULONG_PTR)BasicInfo + sizeof(TCPIP_OWNER_MODULE_BASIC_INFO));
2358 BasicInfo->pModulePath = (PVOID)((ULONG_PTR)BasicInfo->pModuleName + FileLen);
2359 wcscpy(BasicInfo->pModuleName, File);
2360 wcscpy(BasicInfo->pModulePath, Path);
2361 *pdwSize = sizeof(TCPIP_OWNER_MODULE_BASIC_INFO) + PathLen + FileLen;
2362
2363 return NO_ERROR;
2364}
2365
2366static DWORD GetOwnerModuleFromTagEntry(DWORD OwningPid, DWORD OwningTag, TCPIP_OWNER_MODULE_INFO_CLASS Class, PVOID Buffer, PDWORD pdwSize)
2367{
2368 UINT Size;
2369 HRESULT Res;
2370 HANDLE hAdvapi32;
2371 WCHAR SysDir[MAX_PATH];
2372 PTCPIP_OWNER_MODULE_BASIC_INFO BasicInfo;
2373 ULONG (NTAPI *_I_QueryTagInformation)(PVOID, DWORD, PVOID);
2374 struct
2375 {
2376 DWORD ProcessId;
2377 DWORD ServiceTag;
2378 DWORD TagType;
2379 PWSTR Buffer;
2380 } ServiceQuery;
2381
2382 if (IsBadWritePtr(pdwSize, sizeof(DWORD)) ||
2383 IsBadWritePtr(Buffer, *pdwSize))
2384 {
2385 return ERROR_INVALID_PARAMETER;
2386 }
2387
2388 /* First, secure (avoid injections) load advapi32.dll */
2389 Size = GetSystemDirectoryW(SysDir, MAX_PATH);
2390 if (Size == 0)
2391 {
2392 return GetLastError();
2393 }
2394
2395 Res = StringCchCatW(&SysDir[Size], MAX_PATH - Size, L"\\advapi32.dll");
2396 if (FAILED(Res))
2397 {
2398 return Res;
2399 }
2400
2401 hAdvapi32 = GetModuleHandleW(SysDir);
2402 if (hAdvapi32 == NULL)
2403 {
2404 return GetLastError();
2405 }
2406
2407 /* Now, we'll query the service associated with the tag */
2408 _I_QueryTagInformation = (PVOID)GetProcAddress(hAdvapi32, "I_QueryTagInformation");
2409 if (_I_QueryTagInformation == NULL)
2410 {
2411 return GetLastError();
2412 }
2413
2414 /* Set tag and PID for the query */
2415 ServiceQuery.ProcessId = OwningPid;
2416 ServiceQuery.ServiceTag = OwningTag;
2417 ServiceQuery.TagType = 0;
2418 ServiceQuery.Buffer = NULL;
2419
2420 /* And query */
2421 Res = _I_QueryTagInformation(NULL, 1, &ServiceQuery);
2422 if (Res != ERROR_SUCCESS)
2423 {
2424 return Res;
2425 }
2426
2427 /* Compute service name length */
2428 Size = wcslen(ServiceQuery.Buffer) * sizeof(WCHAR) + sizeof(UNICODE_NULL);
2429
2430 /* We'll copy it twice, so make sure we have enough room */
2431 if (*pdwSize < sizeof(TCPIP_OWNER_MODULE_BASIC_INFO) + 2 * Size)
2432 {
2433 *pdwSize = sizeof(TCPIP_OWNER_MODULE_BASIC_INFO) + 2 * Size;
2434 LocalFree(ServiceQuery.Buffer);
2435 return ERROR_INSUFFICIENT_BUFFER;
2436 }
2437
2438 /* Copy back data */
2439 BasicInfo = Buffer;
2440 BasicInfo->pModuleName = (PVOID)((ULONG_PTR)BasicInfo + sizeof(TCPIP_OWNER_MODULE_BASIC_INFO));
2441 BasicInfo->pModulePath = (PVOID)((ULONG_PTR)BasicInfo->pModuleName + Size);
2442 wcscpy(BasicInfo->pModuleName, ServiceQuery.Buffer);
2443 wcscpy(BasicInfo->pModulePath, ServiceQuery.Buffer);
2444 *pdwSize = sizeof(TCPIP_OWNER_MODULE_BASIC_INFO) + 2 * Size;
2445 LocalFree(ServiceQuery.Buffer);
2446
2447 return NO_ERROR;
2448}
2449
2450/******************************************************************
2451 * GetOwnerModuleFromTcpEntry (IPHLPAPI.@)
2452 *
2453 * Get data about the module that issued the context bind for a specific IPv4 TCP endpoint in a MIB table row
2454 *
2455 * PARAMS
2456 * pTcpEntry [in] pointer to a MIB_TCPROW_OWNER_MODULE structure
2457 * Class [in] TCPIP_OWNER_MODULE_INFO_CLASS enumeration value
2458 * Buffer [out] pointer a buffer containing a TCPIP_OWNER_MODULE_BASIC_INFO structure with the owner module data.
2459 * pdwSize [in, out] estimated size of the structure returned in Buffer, in bytes
2460 *
2461 * RETURNS
2462 * Success: NO_ERROR
2463 * Failure: ERROR_INSUFFICIENT_BUFFER, ERROR_INVALID_PARAMETER, ERROR_NOT_ENOUGH_MEMORY
2464 * ERROR_NOT_FOUND or ERROR_PARTIAL_COPY
2465 *
2466 * NOTES
2467 * The type of data returned in Buffer is indicated by the value of the Class parameter.
2468 */
2469DWORD WINAPI GetOwnerModuleFromTcpEntry( PMIB_TCPROW_OWNER_MODULE pTcpEntry, TCPIP_OWNER_MODULE_INFO_CLASS Class, PVOID Buffer, PDWORD pdwSize)
2470{
2471 /* If we have a service tag, that's a service connection */
2472 if (pTcpEntry->OwningModuleInfo[0] != 0)
2473 {
2474 return GetOwnerModuleFromTagEntry(pTcpEntry->dwOwningPid, (DWORD)(pTcpEntry->OwningModuleInfo[0]), Class, Buffer, pdwSize);
2475 }
2476 else
2477 {
2478 return GetOwnerModuleFromPidEntry(pTcpEntry->dwOwningPid, Class, Buffer, pdwSize);
2479 }
2480}
2481
2482/******************************************************************
2483 * GetOwnerModuleFromUdpEntry (IPHLPAPI.@)
2484 *
2485 * Get data about the module that issued the context bind for a specific IPv4 UDP endpoint in a MIB table row
2486 *
2487 * PARAMS
2488 * pUdpEntry [in] pointer to a MIB_UDPROW_OWNER_MODULE structure
2489 * Class [in] TCPIP_OWNER_MODULE_INFO_CLASS enumeration value
2490 * Buffer [out] pointer a buffer containing a TCPIP_OWNER_MODULE_BASIC_INFO structure with the owner module data.
2491 * pdwSize [in, out] estimated size of the structure returned in Buffer, in bytes
2492 *
2493 * RETURNS
2494 * Success: NO_ERROR
2495 * Failure: ERROR_INSUFFICIENT_BUFFER, ERROR_INVALID_PARAMETER, ERROR_NOT_ENOUGH_MEMORY
2496 * ERROR_NOT_FOUND or ERROR_PARTIAL_COPY
2497 *
2498 * NOTES
2499 * The type of data returned in Buffer is indicated by the value of the Class parameter.
2500 */
2501DWORD WINAPI GetOwnerModuleFromUdpEntry( PMIB_UDPROW_OWNER_MODULE pUdpEntry, TCPIP_OWNER_MODULE_INFO_CLASS Class, PVOID Buffer, PDWORD pdwSize)
2502{
2503 /* If we have a service tag, that's a service connection */
2504 if (pUdpEntry->OwningModuleInfo[0] != 0)
2505 {
2506 return GetOwnerModuleFromTagEntry(pUdpEntry->dwOwningPid, (DWORD)(pUdpEntry->OwningModuleInfo[0]), Class, Buffer, pdwSize);
2507 }
2508 else
2509 {
2510 return GetOwnerModuleFromPidEntry(pUdpEntry->dwOwningPid, Class, Buffer, pdwSize);
2511 }
2512}
2513
2514static void CreateNameServerListEnumNamesFunc( PWCHAR Interface, PWCHAR Server, PVOID Data)
2515{
2516 IP_ADDR_STRING *pNext;
2517 PNAME_SERVER_LIST_CONTEXT Context = (PNAME_SERVER_LIST_CONTEXT)Data;
2518
2519 if (!Context->NumServers)
2520 {
2521 if (Context->uSizeAvailable >= Context->uSizeRequired)
2522 {
2523 WideCharToMultiByte(CP_ACP, 0, Server, -1, Context->pData->DnsServerList.IpAddress.String, 16, NULL, NULL);
2524 Context->pData->DnsServerList.IpAddress.String[15] = '\0';
2525 Context->pLastAddr = &Context->pData->DnsServerList;
2526 }
2527 }
2528 else
2529 {
2530 Context->uSizeRequired += sizeof(IP_ADDR_STRING);
2531 if (Context->uSizeAvailable >= Context->uSizeRequired)
2532 {
2533 pNext = (IP_ADDR_STRING*)(((char*)Context->pLastAddr) + sizeof(IP_ADDR_STRING));
2534 WideCharToMultiByte(CP_ACP, 0, Server, -1, pNext->IpAddress.String, 16, NULL, NULL);
2535 pNext->IpAddress.String[15] = '\0';
2536 Context->pLastAddr->Next = pNext;
2537 Context->pLastAddr = pNext;
2538 pNext->Next = NULL;
2539 }
2540 }
2541 Context->NumServers++;
2542}
2543
2544/******************************************************************
2545 * GetPerAdapterInfo (IPHLPAPI.@)
2546 *
2547 *
2548 * PARAMS
2549 *
2550 * IfIndex [In]
2551 * pPerAdapterInfo [In/Out]
2552 * pOutBufLen [In/Out]
2553 *
2554 * RETURNS
2555 *
2556 * DWORD
2557 *
2558 */
2559DWORD WINAPI GetPerAdapterInfo(ULONG IfIndex, PIP_PER_ADAPTER_INFO pPerAdapterInfo, PULONG pOutBufLen)
2560{
2561 HKEY hkey;
2562 DWORD dwSize = 0;
2563 const char *ifName;
2564 NAME_SERVER_LIST_CONTEXT Context;
2565 WCHAR keyname[200] = L"SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Interfaces\\";
2566
2567 if (!pOutBufLen)
2568 return ERROR_INVALID_PARAMETER;
2569
2570 if (!pPerAdapterInfo || *pOutBufLen < sizeof(IP_PER_ADAPTER_INFO))
2571 {
2572 *pOutBufLen = sizeof(IP_PER_ADAPTER_INFO);
2573 return ERROR_BUFFER_OVERFLOW;
2574 }
2575
2576 ifName = getInterfaceNameByIndex(IfIndex);
2577 if (!ifName)
2578 return ERROR_INVALID_PARAMETER;
2579
2580 MultiByteToWideChar(CP_ACP, 0, ifName, -1, &keyname[62], sizeof(keyname)/sizeof(WCHAR) - 63);
2581 HeapFree(GetProcessHeap(), 0, (LPVOID)ifName);
2582
2583 if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, keyname, 0, KEY_READ, &hkey) != ERROR_SUCCESS)
2584 {
2585 return ERROR_NOT_SUPPORTED;
2586 }
2587 Context.NumServers = 0;
2588 Context.uSizeAvailable = *pOutBufLen;
2589 Context.uSizeRequired = sizeof(IP_PER_ADAPTER_INFO);
2590 Context.pData = pPerAdapterInfo;
2591
2592 if (*pOutBufLen >= sizeof(IP_PER_ADAPTER_INFO))
2593 ZeroMemory(pPerAdapterInfo, sizeof(IP_PER_ADAPTER_INFO));
2594
2595 EnumNameServers(hkey, &keyname[62], &Context, CreateNameServerListEnumNamesFunc);
2596
2597 if (Context.uSizeRequired > Context.uSizeAvailable)
2598 {
2599 *pOutBufLen = Context.uSizeRequired;
2600 RegCloseKey(hkey);
2601 return ERROR_BUFFER_OVERFLOW;
2602 }
2603
2604 if(RegQueryValueExW(hkey, L"NameServer", NULL, NULL, NULL, &dwSize) == ERROR_SUCCESS)
2605 {
2606 pPerAdapterInfo->AutoconfigActive = FALSE;
2607 }
2608 else
2609 {
2610 pPerAdapterInfo->AutoconfigActive = TRUE;
2611 }
2612
2613 RegCloseKey(hkey);
2614 return NOERROR;
2615}
2616
2617
2618/******************************************************************
2619 * GetRTTAndHopCount (IPHLPAPI.@)
2620 *
2621 *
2622 * PARAMS
2623 *
2624 * DestIpAddress [In]
2625 * HopCount [In/Out]
2626 * MaxHops [In]
2627 * RTT [In/Out]
2628 *
2629 * RETURNS
2630 *
2631 * BOOL
2632 *
2633 */
2634BOOL WINAPI GetRTTAndHopCount(IPAddr DestIpAddress, PULONG HopCount, ULONG MaxHops, PULONG RTT)
2635{
2636 TRACE("DestIpAddress 0x%08lx, HopCount %p, MaxHops %ld, RTT %p\n",
2637 DestIpAddress, HopCount, MaxHops, RTT);
2638 FIXME(":stub\n");
2639 return (BOOL) 0;
2640}
2641
2642
2643/******************************************************************
2644 * GetTcpStatisticsEx (IPHLPAPI.@)
2645 *
2646 *
2647 * PARAMS
2648 *
2649 * pStats [In/Out]
2650 * dwFamily [In]
2651 *
2652 * RETURNS
2653 *
2654 * DWORD
2655 *
2656 */
2657DWORD WINAPI GetTcpStatisticsEx(PMIB_TCPSTATS pStats, DWORD dwFamily)
2658{
2659 DWORD ret;
2660
2661 TRACE("pStats %p\n", pStats);
2662 ret = getTCPStats(pStats, dwFamily);
2663 TRACE("returning %ld\n", ret);
2664 return ret;
2665}
2666
2667/******************************************************************
2668 * GetTcpStatistics (IPHLPAPI.@)
2669 *
2670 *
2671 * PARAMS
2672 *
2673 * pStats [In/Out]
2674 *
2675 * RETURNS
2676 *
2677 * DWORD
2678 *
2679 */
2680DWORD WINAPI GetTcpStatistics(PMIB_TCPSTATS pStats)
2681{
2682 return GetTcpStatisticsEx(pStats, PF_INET);
2683}
2684
2685
2686/******************************************************************
2687 * GetTcpTable (IPHLPAPI.@)
2688 *
2689 * Get the table of active TCP connections.
2690 *
2691 * PARAMS
2692 * pTcpTable [Out] buffer for TCP connections table
2693 * pdwSize [In/Out] length of output buffer
2694 * bOrder [In] whether to order the table
2695 *
2696 * RETURNS
2697 * Success: NO_ERROR
2698 * Failure: error code from winerror.h
2699 *
2700 * NOTES
2701 * If pdwSize is less than required, the function will return
2702 * ERROR_INSUFFICIENT_BUFFER, and *pdwSize will be set to
2703 * the required byte size.
2704 * If bOrder is true, the returned table will be sorted, first by
2705 * local address and port number, then by remote address and port
2706 * number.
2707 */
2708DWORD WINAPI GetTcpTable(PMIB_TCPTABLE pTcpTable, PDWORD pdwSize, BOOL bOrder)
2709{
2710 return GetExtendedTcpTable(pTcpTable, pdwSize, bOrder, AF_INET, TCP_TABLE_BASIC_ALL, 0);
2711}
2712
2713
2714/******************************************************************
2715 * GetUdpStatisticsEx (IPHLPAPI.@)
2716 *
2717 *
2718 * PARAMS
2719 *
2720 * pStats [In/Out]
2721 * dwFamily [In]
2722 *
2723 * RETURNS
2724 *
2725 * DWORD
2726 *
2727 */
2728DWORD WINAPI GetUdpStatisticsEx(PMIB_UDPSTATS pStats, DWORD dwFamily)
2729{
2730 DWORD ret;
2731
2732 TRACE("pStats %p\n", pStats);
2733 ret = getUDPStats(pStats, dwFamily);
2734 TRACE("returning %ld\n", ret);
2735 return ret;
2736}
2737
2738/******************************************************************
2739 * GetUdpStatistics (IPHLPAPI.@)
2740 *
2741 *
2742 * PARAMS
2743 *
2744 * pStats [In/Out]
2745 *
2746 * RETURNS
2747 *
2748 * DWORD
2749 *
2750 */
2751DWORD WINAPI GetUdpStatistics(PMIB_UDPSTATS pStats)
2752{
2753 return GetUdpStatisticsEx(pStats, PF_INET);
2754}
2755
2756
2757/******************************************************************
2758 * GetUdpTable (IPHLPAPI.@)
2759 *
2760 *
2761 * PARAMS
2762 *
2763 * pUdpTable [In/Out]
2764 * pdwSize [In/Out]
2765 * bOrder [In]
2766 *
2767 * RETURNS
2768 *
2769 * DWORD
2770 *
2771 */
2772DWORD WINAPI GetUdpTable(PMIB_UDPTABLE pUdpTable, PDWORD pdwSize, BOOL bOrder)
2773{
2774 return GetExtendedUdpTable(pUdpTable, pdwSize, bOrder, AF_INET, UDP_TABLE_BASIC, 0);
2775}
2776
2777
2778/******************************************************************
2779 * GetUniDirectionalAdapterInfo (IPHLPAPI.@)
2780 *
2781 * This is a Win98-only function to get information on "unidirectional"
2782 * adapters. Since this is pretty nonsensical in other contexts, it
2783 * never returns anything.
2784 *
2785 * PARAMS
2786 * pIPIfInfo [Out] buffer for adapter infos
2787 * dwOutBufLen [Out] length of the output buffer
2788 *
2789 * RETURNS
2790 * Success: NO_ERROR
2791 * Failure: error code from winerror.h
2792 *
2793 * FIXME
2794 * Stub, returns ERROR_NOT_SUPPORTED.
2795 */
2796DWORD WINAPI GetUniDirectionalAdapterInfo(PIP_UNIDIRECTIONAL_ADAPTER_ADDRESS pIPIfInfo, PULONG dwOutBufLen)
2797{
2798 TRACE("pIPIfInfo %p, dwOutBufLen %p\n", pIPIfInfo, dwOutBufLen);
2799 /* a unidirectional adapter?? not bloody likely! */
2800 return ERROR_NOT_SUPPORTED;
2801}
2802
2803
2804/******************************************************************
2805 * IpReleaseAddress (IPHLPAPI.@)
2806 *
2807 * Release an IP obtained through DHCP,
2808 *
2809 * PARAMS
2810 * AdapterInfo [In] adapter to release IP address
2811 *
2812 * RETURNS
2813 * Success: NO_ERROR
2814 * Failure: error code from winerror.h
2815 *
2816 */
2817DWORD WINAPI IpReleaseAddress(PIP_ADAPTER_INDEX_MAP AdapterInfo)
2818{
2819 DWORD Status, Version = 0;
2820
2821 if (!AdapterInfo)
2822 return ERROR_INVALID_PARAMETER;
2823
2824 /* Maybe we should do this in DllMain */
2825 if (DhcpCApiInitialize(&Version) != ERROR_SUCCESS)
2826 return ERROR_PROC_NOT_FOUND;
2827
2828 if (DhcpReleaseIpAddressLease(AdapterInfo->Index))
2829 Status = ERROR_SUCCESS;
2830 else
2831 Status = ERROR_PROC_NOT_FOUND;
2832
2833 DhcpCApiCleanup();
2834
2835 return Status;
2836}
2837
2838
2839/******************************************************************
2840 * IpRenewAddress (IPHLPAPI.@)
2841 *
2842 * Renew an IP obtained through DHCP.
2843 *
2844 * PARAMS
2845 * AdapterInfo [In] adapter to renew IP address
2846 *
2847 * RETURNS
2848 * Success: NO_ERROR
2849 * Failure: error code from winerror.h
2850 */
2851DWORD WINAPI IpRenewAddress(PIP_ADAPTER_INDEX_MAP AdapterInfo)
2852{
2853 DWORD Status, Version = 0;
2854
2855 if (!AdapterInfo)
2856 return ERROR_INVALID_PARAMETER;
2857
2858 /* Maybe we should do this in DllMain */
2859 if (DhcpCApiInitialize(&Version) != ERROR_SUCCESS)
2860 return ERROR_PROC_NOT_FOUND;
2861
2862 if (DhcpRenewIpAddressLease(AdapterInfo->Index))
2863 Status = ERROR_SUCCESS;
2864 else
2865 Status = ERROR_PROC_NOT_FOUND;
2866
2867 DhcpCApiCleanup();
2868
2869 return Status;
2870}
2871
2872
2873/******************************************************************
2874 * NotifyAddrChange (IPHLPAPI.@)
2875 *
2876 * Notify caller whenever the ip-interface map is changed.
2877 *
2878 * PARAMS
2879 * Handle [Out] handle usable in asynchronous notification
2880 * overlapped [In] overlapped structure that notifies the caller
2881 *
2882 * RETURNS
2883 * Success: NO_ERROR
2884 * Failure: error code from winerror.h
2885 *
2886 * FIXME
2887 * Stub, returns ERROR_NOT_SUPPORTED.
2888 */
2889DWORD WINAPI NotifyAddrChange(PHANDLE Handle, LPOVERLAPPED overlapped)
2890{
2891 FIXME("(Handle %p, overlapped %p): stub\n", Handle, overlapped);
2892 if (Handle) *Handle = INVALID_HANDLE_VALUE;
2893 if (overlapped) ((IO_STATUS_BLOCK *) overlapped)->Status = STATUS_PENDING;
2894 return ERROR_IO_PENDING;
2895}
2896
2897
2898/******************************************************************
2899 * NotifyRouteChange (IPHLPAPI.@)
2900 *
2901 * Notify caller whenever the ip routing table is changed.
2902 *
2903 * PARAMS
2904 * Handle [Out] handle usable in asynchronous notification
2905 * overlapped [In] overlapped structure that notifies the caller
2906 *
2907 * RETURNS
2908 * Success: NO_ERROR
2909 * Failure: error code from winerror.h
2910 *
2911 * FIXME
2912 * Stub, returns ERROR_NOT_SUPPORTED.
2913 */
2914DWORD WINAPI NotifyRouteChange(PHANDLE Handle, LPOVERLAPPED overlapped)
2915{
2916 FIXME("(Handle %p, overlapped %p): stub\n", Handle, overlapped);
2917 return ERROR_NOT_SUPPORTED;
2918}
2919
2920/******************************************************************
2921 * SendARP (IPHLPAPI.@)
2922 *
2923 * Send an ARP request.
2924 *
2925 * PARAMS
2926 * DestIP [In] attempt to obtain this IP
2927 * SrcIP [In] optional sender IP address
2928 * pMacAddr [Out] buffer for the mac address
2929 * PhyAddrLen [In/Out] length of the output buffer
2930 *
2931 * RETURNS
2932 * Success: NO_ERROR
2933 * Failure: error code from winerror.h
2934 */
2935DWORD WINAPI SendARP(IPAddr DestIP, IPAddr SrcIP, PULONG pMacAddr, PULONG PhyAddrLen)
2936{
2937 IPAddr IPs[2];
2938 ULONG Size;
2939
2940 if (IsBadWritePtr(pMacAddr, sizeof(ULONG)) || IsBadWritePtr(PhyAddrLen, sizeof(ULONG)))
2941 return ERROR_INVALID_PARAMETER;
2942
2943 IPs[0] = DestIP;
2944 IPs[1] = SrcIP;
2945 Size = sizeof(IPs);
2946 return TCPSendIoctl(INVALID_HANDLE_VALUE, IOCTL_QUERY_IP_HW_ADDRESS, IPs, &Size, pMacAddr, PhyAddrLen);
2947}
2948
2949
2950/******************************************************************
2951 * SetIfEntry (IPHLPAPI.@)
2952 *
2953 * Set the administrative status of an interface.
2954 *
2955 * PARAMS
2956 * pIfRow [In] dwAdminStatus member specifies the new status.
2957 *
2958 * RETURNS
2959 * Success: NO_ERROR
2960 * Failure: error code from winerror.h
2961 *
2962 * FIXME
2963 * Stub, returns ERROR_NOT_SUPPORTED.
2964 */
2965DWORD WINAPI SetIfEntry(PMIB_IFROW pIfRow)
2966{
2967 FIXME("(pIfRow %p): stub\n", pIfRow);
2968 /* this is supposed to set an interface administratively up or down.
2969 Could do SIOCSIFFLAGS and set/clear IFF_UP, but, not sure I want to, and
2970 this sort of down is indistinguishable from other sorts of down (e.g. no
2971 link). */
2972 return ERROR_NOT_SUPPORTED;
2973}
2974
2975
2976/******************************************************************
2977 * SetIpForwardEntry (IPHLPAPI.@)
2978 *
2979 * Modify an existing route.
2980 *
2981 * PARAMS
2982 * pRoute [In] route with the new information
2983 *
2984 * RETURNS
2985 * Success: NO_ERROR
2986 * Failure: error code from winerror.h
2987 *
2988 */
2989DWORD WINAPI SetIpForwardEntry(PMIB_IPFORWARDROW pRoute)
2990{
2991 return setIpForwardEntry( pRoute );
2992}
2993
2994
2995/******************************************************************
2996 * SetIpNetEntry (IPHLPAPI.@)
2997 *
2998 * Modify an existing ARP entry.
2999 *
3000 * PARAMS
3001 * pArpEntry [In] ARP entry with the new information
3002 *
3003 * RETURNS
3004 * Success: NO_ERROR
3005 * Failure: error code from winerror.h
3006 */
3007DWORD WINAPI SetIpNetEntry(PMIB_IPNETROW pArpEntry)
3008{
3009 HANDLE tcpFile;
3010 NTSTATUS status;
3011 TCP_REQUEST_SET_INFORMATION_EX_ARP_ENTRY req =
3012 TCP_REQUEST_SET_INFORMATION_INIT;
3013 TDIEntityID id;
3014 DWORD returnSize;
3015 PMIB_IPNETROW arpBuff;
3016
3017 if (!pArpEntry)
3018 return ERROR_INVALID_PARAMETER;
3019
3020 if (!NT_SUCCESS(openTcpFile( &tcpFile, FILE_READ_DATA | FILE_WRITE_DATA )))
3021 return ERROR_NOT_SUPPORTED;
3022
3023 if (!NT_SUCCESS(getNthIpEntity( tcpFile, pArpEntry->dwIndex, &id )))
3024 {
3025 closeTcpFile(tcpFile);
3026 return ERROR_INVALID_PARAMETER;
3027 }
3028
3029 req.Req.ID.toi_class = INFO_CLASS_PROTOCOL;
3030 req.Req.ID.toi_type = INFO_TYPE_PROVIDER;
3031 req.Req.ID.toi_id = IP_MIB_ARPTABLE_ENTRY_ID;
3032 req.Req.ID.toi_entity.tei_instance = id.tei_instance;
3033 req.Req.ID.toi_entity.tei_entity = AT_ENTITY;
3034 req.Req.BufferSize = sizeof(MIB_IPNETROW);
3035 arpBuff = (PMIB_IPNETROW)&req.Req.Buffer[0];
3036
3037 RtlCopyMemory(arpBuff, pArpEntry, sizeof(MIB_IPNETROW));
3038
3039 status = DeviceIoControl( tcpFile,
3040 IOCTL_TCP_SET_INFORMATION_EX,
3041 &req,
3042 sizeof(req),
3043 NULL,
3044 0,
3045 &returnSize,
3046 NULL );
3047
3048 closeTcpFile(tcpFile);
3049
3050 if (status)
3051 return NO_ERROR;
3052 else
3053 return ERROR_INVALID_PARAMETER;
3054}
3055
3056
3057/******************************************************************
3058 * SetIpStatistics (IPHLPAPI.@)
3059 *
3060 * Toggle IP forwarding and det the default TTL value.
3061 *
3062 * PARAMS
3063 * pIpStats [In] IP statistics with the new information
3064 *
3065 * RETURNS
3066 * Success: NO_ERROR
3067 * Failure: error code from winerror.h
3068 *
3069 * FIXME
3070 * Stub, returns NO_ERROR.
3071 */
3072DWORD WINAPI SetIpStatistics(PMIB_IPSTATS pIpStats)
3073{
3074 FIXME("(pIpStats %p): stub\n", pIpStats);
3075 return 0;
3076}
3077
3078
3079/******************************************************************
3080 * SetIpTTL (IPHLPAPI.@)
3081 *
3082 * Set the default TTL value.
3083 *
3084 * PARAMS
3085 * nTTL [In] new TTL value
3086 *
3087 * RETURNS
3088 * Success: NO_ERROR
3089 * Failure: error code from winerror.h
3090 *
3091 * FIXME
3092 * Stub, returns NO_ERROR.
3093 */
3094DWORD WINAPI SetIpTTL(UINT nTTL)
3095{
3096 FIXME("(nTTL %d): stub\n", nTTL);
3097 return 0;
3098}
3099
3100
3101/******************************************************************
3102 * SetTcpEntry (IPHLPAPI.@)
3103 *
3104 * Set the state of a TCP connection.
3105 *
3106 * PARAMS
3107 * pTcpRow [In] specifies connection with new state
3108 *
3109 * RETURNS
3110 * Success: NO_ERROR
3111 * Failure: error code from winerror.h
3112 *
3113 * FIXME
3114 * Stub, returns NO_ERROR.
3115 */
3116DWORD WINAPI SetTcpEntry(PMIB_TCPROW pTcpRow)
3117{
3118 FIXME("(pTcpRow %p): stub\n", pTcpRow);
3119 return 0;
3120}
3121
3122
3123/******************************************************************
3124 * UnenableRouter (IPHLPAPI.@)
3125 *
3126 * Decrement the IP-forwarding reference count. Turn off IP-forwarding
3127 * if it reaches zero.
3128 *
3129 * PARAMS
3130 * pOverlapped [In/Out] should be the same as in EnableRouter()
3131 * lpdwEnableCount [Out] optional, receives reference count
3132 *
3133 * RETURNS
3134 * Success: NO_ERROR
3135 * Failure: error code from winerror.h
3136 *
3137 * FIXME
3138 * Stub, returns ERROR_NOT_SUPPORTED.
3139 */
3140DWORD WINAPI UnenableRouter(OVERLAPPED * pOverlapped, LPDWORD lpdwEnableCount)
3141{
3142 FIXME("(pOverlapped %p, lpdwEnableCount %p): stub\n", pOverlapped,
3143 lpdwEnableCount);
3144 return ERROR_NOT_SUPPORTED;
3145}
3146
3147/*
3148 * @unimplemented
3149 */
3150DWORD WINAPI GetIpErrorString(IP_STATUS ErrorCode,PWCHAR Buffer,PDWORD Size)
3151{
3152 FIXME(":stub\n");
3153 return 0L;
3154}
3155
3156
3157/*
3158 * @unimplemented
3159 */
3160PIP_ADAPTER_ORDER_MAP WINAPI GetAdapterOrderMap(VOID)
3161{
3162 FIXME(":stub\n");
3163 return 0L;
3164}
3165
3166/*
3167 * @implemented
3168 */
3169#ifdef GetAdaptersAddressesV1
3170DWORD WINAPI DECLSPEC_HOTPATCH GetAdaptersAddresses(ULONG Family,ULONG Flags,PVOID Reserved,PIP_ADAPTER_ADDRESSES pAdapterAddresses,PULONG pOutBufLen)
3171{
3172 InterfaceIndexTable *indexTable;
3173 IFInfo ifInfo;
3174 int i;
3175 ULONG ret, requiredSize = 0;
3176 PIP_ADAPTER_ADDRESSES currentAddress;
3177 PUCHAR currentLocation;
3178 HANDLE tcpFile;
3179
3180 if (!pOutBufLen) return ERROR_INVALID_PARAMETER;
3181 if (Reserved) return ERROR_INVALID_PARAMETER;
3182
3183 indexTable = getInterfaceIndexTable();
3184 if (!indexTable)
3185 return ERROR_NOT_ENOUGH_MEMORY;
3186
3187 ret = openTcpFile(&tcpFile, FILE_READ_DATA);
3188 if (!NT_SUCCESS(ret))
3189 {
3190 free(indexTable);
3191 return ERROR_NO_DATA;
3192 }
3193
3194 for (i = indexTable->numIndexes; i >= 0; i--)
3195 {
3196 if (NT_SUCCESS(getIPAddrEntryForIf(tcpFile,
3197 NULL,
3198 indexTable->indexes[i],
3199 &ifInfo)))
3200 {
3201 /* The whole struct */
3202 requiredSize += sizeof(IP_ADAPTER_ADDRESSES);
3203
3204 /* Friendly name */
3205 if (!(Flags & GAA_FLAG_SKIP_FRIENDLY_NAME))
3206 requiredSize += ifInfo.if_info.ent.if_descrlen + 1; //FIXME
3207
3208 /* Adapter name */
3209 requiredSize += ifInfo.if_info.ent.if_descrlen + 1;
3210
3211 /* Unicast address */
3212 if (!(Flags & GAA_FLAG_SKIP_UNICAST))
3213 requiredSize += sizeof(IP_ADAPTER_UNICAST_ADDRESS);
3214
3215 /* FIXME: Implement multicast, anycast, and dns server stuff */
3216
3217 /* FIXME: Implement dns suffix and description */
3218 requiredSize += 2 * sizeof(WCHAR);
3219
3220 /* We're only going to implement what's required for XP SP0 */
3221 }
3222 }
3223 TRACE("size: %d, requiredSize: %d\n", *pOutBufLen, requiredSize);
3224 if (!pAdapterAddresses || *pOutBufLen < requiredSize)
3225 {
3226 *pOutBufLen = requiredSize;
3227 closeTcpFile(tcpFile);
3228 free(indexTable);
3229 return ERROR_BUFFER_OVERFLOW;
3230 }
3231
3232 RtlZeroMemory(pAdapterAddresses, requiredSize);
3233
3234 /* Let's set up the pointers */
3235 currentAddress = pAdapterAddresses;
3236 for (i = indexTable->numIndexes; i >= 0; i--)
3237 {
3238 if (NT_SUCCESS(getIPAddrEntryForIf(tcpFile,
3239 NULL,
3240 indexTable->indexes[i],
3241 &ifInfo)))
3242 {
3243 currentLocation = (PUCHAR)currentAddress + (ULONG_PTR)sizeof(IP_ADAPTER_ADDRESSES);
3244
3245 /* FIXME: Friendly name */
3246 if (!(Flags & GAA_FLAG_SKIP_FRIENDLY_NAME))
3247 {
3248 currentAddress->FriendlyName = (PVOID)currentLocation;
3249 currentLocation += sizeof(WCHAR);
3250 }
3251
3252 /* Adapter name */
3253 currentAddress->AdapterName = (PVOID)currentLocation;
3254 currentLocation += ifInfo.if_info.ent.if_descrlen + 1;
3255
3256 /* Unicast address */
3257 if (!(Flags & GAA_FLAG_SKIP_UNICAST))
3258 {
3259 currentAddress->FirstUnicastAddress = (PVOID)currentLocation;
3260 currentLocation += sizeof(IP_ADAPTER_UNICAST_ADDRESS);
3261 currentAddress->FirstUnicastAddress->Address.lpSockaddr = (PVOID)currentLocation;
3262 currentLocation += sizeof(struct sockaddr);
3263 }
3264
3265 /* FIXME: Implement multicast, anycast, and dns server stuff */
3266
3267 /* FIXME: Implement dns suffix and description */
3268 currentAddress->DnsSuffix = (PVOID)currentLocation;
3269 currentLocation += sizeof(WCHAR);
3270
3271 currentAddress->Description = (PVOID)currentLocation;
3272 currentLocation += sizeof(WCHAR);
3273
3274 currentAddress->Next = (PVOID)currentLocation;
3275 /* Terminate the last address correctly */
3276 if(i==0)
3277 currentAddress->Next = NULL;
3278
3279 /* We're only going to implement what's required for XP SP0 */
3280
3281 currentAddress = currentAddress->Next;
3282 }
3283 }
3284
3285 /* Now again, for real this time */
3286
3287 currentAddress = pAdapterAddresses;
3288 for (i = indexTable->numIndexes; i >= 0; i--)
3289 {
3290 if (NT_SUCCESS(getIPAddrEntryForIf(tcpFile,
3291 NULL,
3292 indexTable->indexes[i],
3293 &ifInfo)))
3294 {
3295 /* Make sure we're not looping more than we hoped for */
3296 ASSERT(currentAddress);
3297
3298 /* Alignment information */
3299 currentAddress->Length = sizeof(IP_ADAPTER_ADDRESSES);
3300 currentAddress->IfIndex = indexTable->indexes[i];
3301
3302 /* Adapter name */
3303 memcpy(currentAddress->AdapterName, ifInfo.if_info.ent.if_descr, ifInfo.if_info.ent.if_descrlen);
3304 currentAddress->AdapterName[ifInfo.if_info.ent.if_descrlen] = '\0';
3305
3306 if (!(Flags & GAA_FLAG_SKIP_UNICAST))
3307 {
3308 currentAddress->FirstUnicastAddress->Length = sizeof(IP_ADAPTER_UNICAST_ADDRESS);
3309 currentAddress->FirstUnicastAddress->Flags = 0; //FIXME
3310 currentAddress->FirstUnicastAddress->Next = NULL; //FIXME: Support more than one address per adapter
3311 currentAddress->FirstUnicastAddress->Address.lpSockaddr->sa_family = AF_INET;
3312 memcpy(currentAddress->FirstUnicastAddress->Address.lpSockaddr->sa_data,
3313 &ifInfo.ip_addr.iae_addr,
3314 sizeof(ifInfo.ip_addr.iae_addr));
3315 currentAddress->FirstUnicastAddress->Address.iSockaddrLength = sizeof(ifInfo.ip_addr.iae_addr) + sizeof(USHORT);
3316 currentAddress->FirstUnicastAddress->PrefixOrigin = IpPrefixOriginOther; //FIXME
3317 currentAddress->FirstUnicastAddress->SuffixOrigin = IpPrefixOriginOther; //FIXME
3318 currentAddress->FirstUnicastAddress->DadState = IpDadStatePreferred; //FIXME
3319 currentAddress->FirstUnicastAddress->ValidLifetime = 0xFFFFFFFF; //FIXME
3320 currentAddress->FirstUnicastAddress->PreferredLifetime = 0xFFFFFFFF; //FIXME
3321 currentAddress->FirstUnicastAddress->LeaseLifetime = 0xFFFFFFFF; //FIXME
3322 }
3323
3324 /* FIXME: Implement multicast, anycast, and dns server stuff */
3325 currentAddress->FirstAnycastAddress = NULL;
3326 currentAddress->FirstMulticastAddress = NULL;
3327 currentAddress->FirstDnsServerAddress = NULL;
3328
3329 /* FIXME: Implement dns suffix, description, and friendly name */
3330 currentAddress->DnsSuffix[0] = UNICODE_NULL;
3331 currentAddress->Description[0] = UNICODE_NULL;
3332 currentAddress->FriendlyName[0] = UNICODE_NULL;
3333
3334 /* Physical Address */
3335 memcpy(currentAddress->PhysicalAddress, ifInfo.if_info.ent.if_physaddr, ifInfo.if_info.ent.if_physaddrlen);
3336 currentAddress->PhysicalAddressLength = ifInfo.if_info.ent.if_physaddrlen;
3337
3338 /* Flags */
3339 currentAddress->Flags = 0; //FIXME
3340
3341 /* MTU */
3342 currentAddress->Mtu = ifInfo.if_info.ent.if_mtu;
3343
3344 /* Interface type */
3345 currentAddress->IfType = ifInfo.if_info.ent.if_type;
3346
3347 /* Operational status */
3348 if(ifInfo.if_info.ent.if_operstatus >= IF_OPER_STATUS_CONNECTING)
3349 currentAddress->OperStatus = IfOperStatusUp;
3350 else
3351 currentAddress->OperStatus = IfOperStatusDown;
3352
3353 /* We're only going to implement what's required for XP SP0 */
3354
3355 /* Move to the next address */
3356 currentAddress = currentAddress->Next;
3357 }
3358 }
3359
3360 closeTcpFile(tcpFile);
3361 free(indexTable);
3362
3363 return NO_ERROR;
3364}
3365#endif
3366
3367/*
3368 * @unimplemented
3369 */
3370BOOL WINAPI CancelIPChangeNotify(LPOVERLAPPED notifyOverlapped)
3371{
3372 FIXME(":stub\n");
3373 return 0L;
3374}
3375
3376/*
3377 * @unimplemented
3378 */
3379DWORD WINAPI GetBestInterfaceEx(struct sockaddr *pDestAddr,PDWORD pdwBestIfIndex)
3380{
3381 FIXME(":stub\n");
3382 return 0L;
3383}
3384
3385/*
3386 * @unimplemented
3387 */
3388DWORD WINAPI NhpAllocateAndGetInterfaceInfoFromStack(IP_INTERFACE_NAME_INFO **ppTable,PDWORD pdwCount,BOOL bOrder,HANDLE hHeap,DWORD dwFlags)
3389{
3390 FIXME(":stub\n");
3391 return 0L;
3392}
3393
3394/*
3395 * @unimplemented
3396 */
3397DWORD WINAPI GetIcmpStatisticsEx(PMIB_ICMP_EX pStats,DWORD dwFamily)
3398{
3399 FIXME(":stub\n");
3400
3401 if (!pStats)
3402 return ERROR_INVALID_PARAMETER;
3403
3404 if (dwFamily != AF_INET && dwFamily != AF_INET6)
3405 return ERROR_INVALID_PARAMETER;
3406
3407 return 0L;
3408}
3409
3410DWORD WINAPI
3411SetIpForwardEntryToStack(PMIB_IPFORWARDROW pRoute)
3412{
3413 FIXME("SetIpForwardEntryToStack() stub\n");
3414 return 0L;
3415}
3416
3417DWORD GetInterfaceNameInternal(_In_ const GUID * pInterfaceGUID,
3418 _Out_writes_bytes_to_(*pOutBufLen, *pOutBufLen) PWCHAR pInterfaceName,
3419 _Inout_ PULONG pOutBufLen)
3420{
3421 UNICODE_STRING GuidString;
3422 DWORD result, type;
3423 WCHAR szKeyName[2*MAX_PATH];
3424 HRESULT hr;
3425 HKEY hKey;
3426
3427 if (pInterfaceGUID == NULL || pOutBufLen == NULL)
3428 return ERROR_INVALID_PARAMETER;
3429
3430 result = RtlStringFromGUID(pInterfaceGUID, &GuidString);
3431
3432 if (!NT_SUCCESS(result))
3433 {
3434 // failed to convert guid to string
3435 return RtlNtStatusToDosError(result);
3436 }
3437
3438 hr = StringCbPrintfW(szKeyName, sizeof(szKeyName), L"SYSTEM\\CurrentControlSet\\Control\\Network\\{4D36E972-E325-11CE-BFC1-08002BE10318}\\%s\\Connection", GuidString.Buffer);
3439 RtlFreeUnicodeString(&GuidString);
3440
3441 if (FAILED(hr))
3442 {
3443 // key name is too long
3444 return ERROR_BUFFER_OVERFLOW;
3445 }
3446
3447 result = RegOpenKeyExW(HKEY_LOCAL_MACHINE, szKeyName, 0, KEY_READ, &hKey);
3448
3449 if (result != ERROR_SUCCESS)
3450 {
3451 // failed to find adapter entry
3452 return ERROR_NOT_FOUND;
3453 }
3454
3455 result = RegQueryValueExW(hKey, L"Name", NULL, &type, (PVOID)pInterfaceName, pOutBufLen);
3456
3457 RegCloseKey(hKey);
3458
3459 if (result == ERROR_MORE_DATA)
3460 {
3461 *pOutBufLen = MAX_INTERFACE_NAME_LEN * 2;
3462 return ERROR_INSUFFICIENT_BUFFER;
3463 }
3464
3465 if (result != ERROR_SUCCESS || type != REG_SZ)
3466 {
3467 // failed to read adapter name
3468 return ERROR_NO_DATA;
3469 }
3470 return ERROR_SUCCESS;
3471}
3472
3473/*
3474 * @implemented
3475 */
3476DWORD WINAPI
3477NhGetInterfaceNameFromDeviceGuid(_In_ const GUID * pInterfaceGUID,
3478 _Out_writes_bytes_to_(*pOutBufLen, *pOutBufLen) PWCHAR pInterfaceName,
3479 _Inout_ PULONG pOutBufLen,
3480 DWORD dwUnknown4,
3481 DWORD dwUnknown5)
3482{
3483 SetLastError(ERROR_SUCCESS);
3484
3485 if (pInterfaceName == NULL)
3486 return ERROR_INVALID_PARAMETER;
3487
3488 return GetInterfaceNameInternal(pInterfaceGUID, pInterfaceName, pOutBufLen);
3489}
3490
3491/*
3492 * @implemented
3493 */
3494DWORD WINAPI
3495NhGetInterfaceNameFromGuid(_In_ const GUID * pInterfaceGUID,
3496 _Out_writes_bytes_to_(*pOutBufLen, *pOutBufLen) PWCHAR pInterfaceName,
3497 _Inout_ PULONG pOutBufLen,
3498 DWORD dwUnknown4,
3499 DWORD dwUnknown5)
3500{
3501 DWORD result;
3502
3503 result = GetInterfaceNameInternal(pInterfaceGUID, pInterfaceName, pOutBufLen);
3504
3505 if (result == ERROR_NOT_FOUND)
3506 SetLastError(ERROR_PATH_NOT_FOUND);
3507
3508 return result;
3509}
Path
PRTL_UNICODE_STRING_BUFFER Path
Definition: RtlNtPathNameToDosPathName.c:10
DECLSPEC_HOTPATCH
#define DECLSPEC_HOTPATCH
Definition: _mingw.h:243
strncpy
char * strncpy(char *DstString, const char *SrcString, ACPI_SIZE Count)
Definition: utclib.c:427
WINE_DEFAULT_DEBUG_CHANNEL
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
Definition: precomp.h:23
NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26
INADDR_NONE
#define INADDR_NONE
Definition: tcp.c:42
Error
BOOL Error
Definition: chkdsk.c:66
ServiceTag
static DWORD ServiceTag
Definition: database.c:34
FIXME
#define FIXME(fmt,...)
Definition: debug.h:111
UNIMPLEMENTED
#define UNIMPLEMENTED
Definition: debug.h:115
RegCloseKey
#define RegCloseKey(hKey)
Definition: registry.h:47
Buffer
Definition: bufpool.h:45
File
Definition: File.h:16
ERROR_NOT_ENOUGH_MEMORY
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
NO_ERROR
#define NO_ERROR
Definition: dderror.h:5
ERROR_MORE_DATA
#define ERROR_MORE_DATA
Definition: dderror.h:13
ERROR_INSUFFICIENT_BUFFER
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10
ERROR_IO_PENDING
#define ERROR_IO_PENDING
Definition: dderror.h:15
free
#define free
Definition: debug_ros.c:5
ERROR_OUTOFMEMORY
#define ERROR_OUTOFMEMORY
Definition: deptool.c:13
ERROR_SUCCESS
#define ERROR_SUCCESS
Definition: deptool.c:10
DeviceIoControl
BOOL WINAPI DeviceIoControl(IN HANDLE hDevice, IN DWORD dwIoControlCode, IN LPVOID lpInBuffer OPTIONAL, IN DWORD nInBufferSize OPTIONAL, OUT LPVOID lpOutBuffer OPTIONAL, IN DWORD nOutBufferSize OPTIONAL, OUT LPDWORD lpBytesReturned OPTIONAL, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: deviceio.c:136
DhcpCApiCleanup
void WINAPI DhcpCApiCleanup(void)
Definition: dhcpcsvc.c:71
DhcpCApiInitialize
DWORD APIENTRY DhcpCApiInitialize(LPDWORD Version)
Definition: dhcpcsvc.c:26
DhcpReleaseIpAddressLease
DWORD APIENTRY DhcpReleaseIpAddressLease(DWORD AdapterIndex)
Definition: dhcpcsvc.c:139
DhcpRenewIpAddressLease
DWORD APIENTRY DhcpRenewIpAddressLease(DWORD AdapterIndex)
Definition: dhcpcsvc.c:165
NULL
#define NULL
Definition: types.h:112
TRUE
#define TRUE
Definition: types.h:120
FALSE
#define FALSE
Definition: types.h:117
NT_SUCCESS
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
RegOpenKeyExW
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3353
RegOpenKeyExA
LONG WINAPI RegOpenKeyExA(_In_ HKEY hKey, _In_ LPCSTR lpSubKey, _In_ DWORD ulOptions, _In_ REGSAM samDesired, _Out_ PHKEY phkResult)
Definition: reg.c:3318
RegOpenKeyA
LONG WINAPI RegOpenKeyA(HKEY hKey, LPCSTR lpSubKey, PHKEY phkResult)
Definition: reg.c:3254
RegQueryValueExA
LONG WINAPI RegQueryValueExA(_In_ HKEY hkeyorg, _In_ LPCSTR name, _In_ LPDWORD reserved, _Out_opt_ LPDWORD type, _Out_opt_ LPBYTE data, _Inout_opt_ LPDWORD count)
Definition: reg.c:4024
RegQueryValueExW
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4118
CloseHandle
#define CloseHandle
Definition: compat.h:739
GetProcessHeap
#define GetProcessHeap()
Definition: compat.h:736
ERROR_INVALID_PARAMETER
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
GetModuleFileNameExW
#define GetModuleFileNameExW(w, x, y, z)
Definition: compat.h:922
DLL_PROCESS_ATTACH
#define DLL_PROCESS_ATTACH
Definition: compat.h:131
DLL_PROCESS_DETACH
#define DLL_PROCESS_DETACH
Definition: compat.h:130
CP_ACP
#define CP_ACP
Definition: compat.h:109
SetLastError
#define SetLastError(x)
Definition: compat.h:752
GetProcAddress
#define GetProcAddress(x, y)
Definition: compat.h:753
INVALID_HANDLE_VALUE
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
HeapAlloc
#define HeapAlloc
Definition: compat.h:733
ERROR_NOT_SUPPORTED
#define ERROR_NOT_SUPPORTED
Definition: compat.h:100
MAX_PATH
#define MAX_PATH
Definition: compat.h:34
HeapFree
#define HeapFree(x, y, z)
Definition: compat.h:735
WideCharToMultiByte
#define WideCharToMultiByte
Definition: compat.h:111
MultiByteToWideChar
#define MultiByteToWideChar
Definition: compat.h:110
getDhcpInfoForAdapter
DWORD getDhcpInfoForAdapter(DWORD AdapterIndex, PBOOL DhcpEnabled, PDWORD DhcpServer, time_t *LeaseObtained, time_t *LeaseExpires)
Definition: dhcp_reactos.c:17
deleteIpForwardEntry
DWORD deleteIpForwardEntry(PMIB_IPFORWARDROW pRoute)
Definition: route.c:64
setIpForwardEntry
DWORD setIpForwardEntry(PMIB_IPFORWARDROW pRoute)
Definition: route.c:59
createIpForwardEntry
DWORD createIpForwardEntry(PMIB_IPFORWARDROW pRoute)
Definition: route.c:52
IsBadWritePtr
BOOL NTAPI IsBadWritePtr(IN LPVOID lp, IN UINT_PTR ucb)
Definition: except.c:881
GetModuleHandleW
HMODULE WINAPI GetModuleHandleW(LPCWSTR lpModuleName)
Definition: loader.c:838
DisableThreadLibraryCalls
BOOL WINAPI DisableThreadLibraryCalls(IN HMODULE hLibModule)
Definition: loader.c:85
GetSystemDirectoryW
UINT WINAPI GetSystemDirectoryW(OUT LPWSTR lpBuffer, IN UINT uSize)
Definition: path.c:2313
OpenProcess
HANDLE WINAPI OpenProcess(IN DWORD dwDesiredAccess, IN BOOL bInheritHandle, IN DWORD dwProcessId)
Definition: proc.c:1227
GetModuleBaseNameW
DWORD WINAPI GetModuleBaseNameW(HANDLE hProcess, HMODULE hModule, LPWSTR lpBaseName, DWORD nSize)
Definition: psapi.c:914
AF_INET
#define AF_INET
Definition: tcpip.h:117
ProcessId
IN PLARGE_INTEGER IN PLARGE_INTEGER PEPROCESS ProcessId
Definition: fatprocs.h:2711
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
Process
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ PLARGE_INTEGER _In_ ULONG _In_ PFILE_OBJECT _In_ PVOID Process
Definition: fsrtlfuncs.h:223
pTarget
FxIoTarget * pTarget
Definition: fxdeviceapi.cpp:97
hKey
FxAutoRegKey hKey
Definition: fxdriverapikm.cpp:59
Handle
ULONG Handle
Definition: gdb_input.c:15
Status
Status
Definition: gdiplustypes.h:25
type
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
count
GLuint GLuint GLsizei count
Definition: gl.h:1545
size
GLsizeiptr size
Definition: glext.h:5919
index
GLuint index
Definition: glext.h:6031
b
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
flags
GLbitfield flags
Definition: glext.h:7161
addr
GLenum const GLvoid * addr
Definition: glext.h:9621
a
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204
result
GLuint64EXT * result
Definition: glext.h:11304
id
GLuint id
Definition: glext.h:5910
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
LocalFree
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1594
IfOperStatusUp
@ IfOperStatusUp
Definition: ifdef.h:185
IfOperStatusDown
@ IfOperStatusDown
Definition: ifdef.h:186
interfaceMapFree
void interfaceMapFree(void)
Definition: ifenum_reactos.c:54
getInterfacePhysicalByIndex
DWORD getInterfacePhysicalByIndex(DWORD index, PDWORD len, PBYTE addr, PDWORD type)
Definition: ifenum_reactos.c:545
getNumNonLoopbackInterfaces
DWORD getNumNonLoopbackInterfaces(void)
Definition: ifenum_reactos.c:269
getNumInterfaces
DWORD getNumInterfaces(void)
Definition: ifenum_reactos.c:264
getInterfaceMaskByIndex
DWORD getInterfaceMaskByIndex(DWORD index)
Definition: ifenum_reactos.c:517
getNonLoopbackInterfaceIndexTable
InterfaceIndexTable * getNonLoopbackInterfaceIndexTable(void)
Definition: ifenum_reactos.c:451
getInterfaceEntryByIndex
DWORD getInterfaceEntryByIndex(DWORD index, PMIB_IFROW entry)
Definition: ifenum_reactos.c:608
getInterfaceNameByIndex
const char * getInterfaceNameByIndex(DWORD index)
Definition: ifenum_reactos.c:352
getInterfaceBCastAddrByIndex
DWORD getInterfaceBCastAddrByIndex(DWORD index)
Definition: ifenum_reactos.c:509
interfaceMapInit
void interfaceMapInit(void)
Definition: ifenum_reactos.c:49
getInterfaceIndexTable
InterfaceIndexTable * getInterfaceIndexTable(void)
Definition: ifenum_reactos.c:447
toIPAddressString
char * toIPAddressString(unsigned int addr, char string[16])
Definition: ifenum_reactos.c:631
addIPAddress
NTSTATUS addIPAddress(IPAddr Address, IPMask Mask, DWORD IfIndex, PULONG NteContext, PULONG NteInstance)
Definition: ifenum_reactos.c:643
getInterfaceIPAddrByIndex
DWORD getInterfaceIPAddrByIndex(DWORD index)
Definition: ifenum_reactos.c:501
deleteIpAddress
NTSTATUS deleteIpAddress(ULONG NteContext)
Definition: ifenum_reactos.c:685
consumeInterfaceName
void consumeInterfaceName(const char *ifname)
Definition: ifenum_reactos.c:377
getIPAddrEntryForIf
NTSTATUS getIPAddrEntryForIf(HANDLE tcpFile, char *name, DWORD index, IFInfo *ifInfo)
Definition: ifenum_reactos.c:460
PMIB_IFTABLE
struct _MIB_IFTABLE * PMIB_IFTABLE
PMIB_IFROW
struct _MIB_IFROW * PMIB_IFROW
MIB_IFTABLE
struct _MIB_IFTABLE MIB_IFTABLE
MAX_INTERFACE_NAME_LEN
#define MAX_INTERFACE_NAME_LEN
Definition: ifmib.h:31
MIB_IFROW
struct _MIB_IFROW MIB_IFROW
wcslen
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
PROCESS_VM_READ
#define PROCESS_VM_READ
Definition: pstypes.h:161
PROCESS_QUERY_INFORMATION
#define PROCESS_QUERY_INFORMATION
Definition: pstypes.h:166
RtlStringFromGUID
NTSYSAPI NTSTATUS WINAPI RtlStringFromGUID(REFGUID, PUNICODE_STRING)
RtlNtStatusToDosError
NTSYSAPI ULONG WINAPI RtlNtStatusToDosError(NTSTATUS)
_BitScanForward
unsigned char _BitScanForward(unsigned long *_Index, unsigned long _Mask)
Definition: intrin_arm.h:57
FAILED
#define FAILED(hr)
Definition: intsafe.h:51
IPMask
ULONG IPMask
Definition: ipexport.h:28
MAX_ADAPTER_NAME
#define MAX_ADAPTER_NAME
Definition: ipexport.h:143
IP_STATUS
ULONG IP_STATUS
Definition: ipexport.h:29
IP_ADAPTER_INDEX_MAP
struct _IP_ADAPTER_INDEX_MAP IP_ADAPTER_INDEX_MAP
IP_INTERFACE_INFO
struct _IP_INTERFACE_INFO IP_INTERFACE_INFO
PIP_ADAPTER_ADDRESSES
static PIP_ADAPTER_ADDRESSES
Definition: iphlpapi.c:76
NotifyAddrChange
DWORD WINAPI NotifyAddrChange(PHANDLE Handle, LPOVERLAPPED overlapped)
Definition: iphlpapi_main.c:2889
GetIpErrorString
DWORD WINAPI GetIpErrorString(IP_STATUS ErrorCode, PWCHAR Buffer, PDWORD Size)
Definition: iphlpapi_main.c:3150
NhpAllocateAndGetInterfaceInfoFromStack
DWORD WINAPI NhpAllocateAndGetInterfaceInfoFromStack(IP_INTERFACE_NAME_INFO **ppTable, PDWORD pdwCount, BOOL bOrder, HANDLE hHeap, DWORD dwFlags)
Definition: iphlpapi_main.c:3388
SetTcpEntry
DWORD WINAPI SetTcpEntry(PMIB_TCPROW pTcpRow)
Definition: iphlpapi_main.c:3116
EnableRouter
DWORD WINAPI EnableRouter(HANDLE *pHandle, OVERLAPPED *pOverlapped)
Definition: iphlpapi_main.c:700
GetBestInterfaceEx
DWORD WINAPI GetBestInterfaceEx(struct sockaddr *pDestAddr, PDWORD pdwBestIfIndex)
Definition: iphlpapi_main.c:3379
GetBestInterface
DWORD WINAPI GetBestInterface(IPAddr dwDestAddr, PDWORD pdwBestIfIndex)
Definition: iphlpapi_main.c:907
GetRTTAndHopCount
BOOL WINAPI GetRTTAndHopCount(IPAddr DestIpAddress, PULONG HopCount, ULONG MaxHops, PULONG RTT)
Definition: iphlpapi_main.c:2634
SetIpStatistics
DWORD WINAPI SetIpStatistics(PMIB_IPSTATS pIpStats)
Definition: iphlpapi_main.c:3072
GetFriendlyIfIndex
DWORD WINAPI GetFriendlyIfIndex(DWORD IfIndex)
Definition: iphlpapi_main.c:1563
GetIcmpStatisticsEx
DWORD WINAPI GetIcmpStatisticsEx(PMIB_ICMP_EX pStats, DWORD dwFamily)
Definition: iphlpapi_main.c:3397
GetExtendedUdpTable
DWORD WINAPI GetExtendedUdpTable(PVOID pUdpTable, PDWORD pdwSize, BOOL bOrder, ULONG ulAf, UDP_TABLE_CLASS TableClass, ULONG Reserved)
Definition: iphlpapi_main.c:1442
AllocateAndGetUdpTableFromStack
DWORD WINAPI AllocateAndGetUdpTableFromStack(PMIB_UDPTABLE *ppUdpTable, BOOL bOrder, HANDLE heap, DWORD flags)
Definition: iphlpapi_main.c:416
SetIfEntry
DWORD WINAPI SetIfEntry(PMIB_IFROW pIfRow)
Definition: iphlpapi_main.c:2965
TcpTableSorter
static int TcpTableSorter(const void *a, const void *b)
Definition: iphlpapi_main.c:980
IpNetTableSorter
static int IpNetTableSorter(const void *a, const void *b)
Definition: iphlpapi_main.c:1993
AllocateAndGetIpAddrTableFromStack
DWORD WINAPI AllocateAndGetIpAddrTableFromStack(PMIB_IPADDRTABLE *ppIpAddrTable, BOOL bOrder, HANDLE heap, DWORD flags)
Definition: iphlpapi_main.c:151
GetIfTable
DWORD WINAPI GetIfTable(PMIB_IFTABLE pIfTable, PULONG pdwSize, BOOL bOrder)
Definition: iphlpapi_main.c:1660
NotifyRouteChange
DWORD WINAPI NotifyRouteChange(PHANDLE Handle, LPOVERLAPPED overlapped)
Definition: iphlpapi_main.c:2914
UnenableRouter
DWORD WINAPI UnenableRouter(OVERLAPPED *pOverlapped, LPDWORD lpdwEnableCount)
Definition: iphlpapi_main.c:3140
GetInterfaceNameInternal
DWORD GetInterfaceNameInternal(_In_ const GUID *pInterfaceGUID, _Out_writes_bytes_to_(*pOutBufLen, *pOutBufLen) PWCHAR pInterfaceName, _Inout_ PULONG pOutBufLen)
Definition: iphlpapi_main.c:3417
AllocateAndGetIpNetTableFromStack
DWORD WINAPI AllocateAndGetIpNetTableFromStack(PMIB_IPNETTABLE *ppIpNetTable, BOOL bOrder, HANDLE heap, DWORD flags)
Definition: iphlpapi_main.c:237
AddIPAddress
DWORD WINAPI AddIPAddress(IPAddr Address, IPMask Netmask, DWORD IfIndex, PULONG NteContext, PULONG NteInstance)
Definition: iphlpapi_main.c:71
DllMain
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
Definition: iphlpapi_main.c:39
CreateProxyArpEntry
DWORD WINAPI CreateProxyArpEntry(DWORD dwAddress, DWORD dwMask, DWORD dwIfIndex)
Definition: iphlpapi_main.c:591
IpAddrTableSorter
static int IpAddrTableSorter(const void *a, const void *b)
Definition: iphlpapi_main.c:1789
IpReleaseAddress
DWORD WINAPI IpReleaseAddress(PIP_ADAPTER_INDEX_MAP AdapterInfo)
Definition: iphlpapi_main.c:2817
CreateIpNetEntry
DWORD WINAPI CreateIpNetEntry(PMIB_IPNETROW pArpEntry)
Definition: iphlpapi_main.c:567
DeleteIpNetEntry
DWORD WINAPI DeleteIpNetEntry(PMIB_IPNETROW pArpEntry)
Definition: iphlpapi_main.c:653
GetIpForwardTable
DWORD WINAPI GetIpForwardTable(PMIB_IPFORWARDTABLE pIpForwardTable, PULONG pdwSize, BOOL bOrder)
Definition: iphlpapi_main.c:1920
GetExtendedTcpTable
DWORD WINAPI GetExtendedTcpTable(PVOID pTcpTable, PDWORD pdwSize, BOOL bOrder, ULONG ulAf, TCP_TABLE_CLASS TableClass, ULONG Reserved)
Definition: iphlpapi_main.c:1022
SetIpForwardEntry
DWORD WINAPI SetIpForwardEntry(PMIB_IPFORWARDROW pRoute)
Definition: iphlpapi_main.c:2989
GetAdapterOrderMap
PIP_ADAPTER_ORDER_MAP WINAPI GetAdapterOrderMap(VOID)
Definition: iphlpapi_main.c:3160
GetIpStatistics
DWORD WINAPI GetIpStatistics(PMIB_IPSTATS pStats)
Definition: iphlpapi_main.c:2078
NAME_SERVER_LIST_CONTEXT
struct _NAME_SERVER_LIST_CONTEXT NAME_SERVER_LIST_CONTEXT
FlushIpNetTable
DWORD WINAPI FlushIpNetTable(DWORD dwIfIndex)
Definition: iphlpapi_main.c:724
GetIpNetTable
DWORD WINAPI GetIpNetTable(PMIB_IPNETTABLE pIpNetTable, PULONG pdwSize, BOOL bOrder)
Definition: iphlpapi_main.c:2020
AllocateAndGetUdpExTable2FromStack
DWORD WINAPI AllocateAndGetUdpExTable2FromStack(PVOID *ppUdpTable, BOOL bOrder, HANDLE heap, DWORD flags, DWORD family, UDP_TABLE_CLASS class)
Definition: iphlpapi_main.c:507
DeleteIpForwardEntry
DWORD WINAPI DeleteIpForwardEntry(PMIB_IPFORWARDROW pRoute)
Definition: iphlpapi_main.c:634
GetIfEntry
DWORD WINAPI GetIfEntry(PMIB_IFROW pIfRow)
Definition: iphlpapi_main.c:1610
GetOwnerModuleFromPidEntry
static DWORD GetOwnerModuleFromPidEntry(DWORD OwningPid, TCPIP_OWNER_MODULE_INFO_CLASS Class, PVOID Buffer, PDWORD pdwSize)
Definition: iphlpapi_main.c:2289
GetIcmpStatistics
DWORD WINAPI GetIcmpStatistics(PMIB_ICMP pStats)
Definition: iphlpapi_main.c:1586
GetInterfaceInfo
DWORD WINAPI GetInterfaceInfo(PIP_INTERFACE_INFO pIfTable, PULONG dwOutBufLen)
Definition: iphlpapi_main.c:1727
GetNetworkParams
DWORD WINAPI GetNetworkParams(PFIXED_INFO pFixedInfo, PULONG pOutBufLen)
Definition: iphlpapi_main.c:2121
GetTcpStatisticsEx
DWORD WINAPI GetTcpStatisticsEx(PMIB_TCPSTATS pStats, DWORD dwFamily)
Definition: iphlpapi_main.c:2657
GetAdaptersInfo
DWORD WINAPI GetAdaptersInfo(PIP_ADAPTER_INFO pAdapterInfo, PULONG pOutBufLen)
Definition: iphlpapi_main.c:771
CancelIPChangeNotify
BOOL WINAPI CancelIPChangeNotify(LPOVERLAPPED notifyOverlapped)
Definition: iphlpapi_main.c:3370
SetIpNetEntry
DWORD WINAPI SetIpNetEntry(PMIB_IPNETROW pArpEntry)
Definition: iphlpapi_main.c:3007
GetOwnerModuleFromUdpEntry
DWORD WINAPI GetOwnerModuleFromUdpEntry(PMIB_UDPROW_OWNER_MODULE pUdpEntry, TCPIP_OWNER_MODULE_INFO_CLASS Class, PVOID Buffer, PDWORD pdwSize)
Definition: iphlpapi_main.c:2501
AllocateAndGetTcpExTableFromStack
DWORD WINAPI AllocateAndGetTcpExTableFromStack(PVOID *ppTcpTable, BOOL bOrder, HANDLE heap, DWORD flags, DWORD family)
Definition: iphlpapi_main.c:326
getInterfaceGatewayByIndex
DWORD getInterfaceGatewayByIndex(DWORD index)
Definition: iphlpapi_main.c:76
IfTableSorter
static int IfTableSorter(const void *a, const void *b)
Definition: iphlpapi_main.c:1633
GetPerAdapterInfo
DWORD WINAPI GetPerAdapterInfo(ULONG IfIndex, PIP_PER_ADAPTER_INFO pPerAdapterInfo, PULONG pOutBufLen)
Definition: iphlpapi_main.c:2559
CreateIpForwardEntry
DWORD WINAPI CreateIpForwardEntry(PMIB_IPFORWARDROW pRoute)
Definition: iphlpapi_main.c:548
GetOwnerModuleFromTagEntry
static DWORD GetOwnerModuleFromTagEntry(DWORD OwningPid, DWORD OwningTag, TCPIP_OWNER_MODULE_INFO_CLASS Class, PVOID Buffer, PDWORD pdwSize)
Definition: iphlpapi_main.c:2366
GetUniDirectionalAdapterInfo
DWORD WINAPI GetUniDirectionalAdapterInfo(PIP_UNIDIRECTIONAL_ADAPTER_ADDRESS pIPIfInfo, PULONG dwOutBufLen)
Definition: iphlpapi_main.c:2796
GetUdpStatistics
DWORD WINAPI GetUdpStatistics(PMIB_UDPSTATS pStats)
Definition: iphlpapi_main.c:2751
SetIpForwardEntryToStack
DWORD WINAPI SetIpForwardEntryToStack(PMIB_IPFORWARDROW pRoute)
Definition: iphlpapi_main.c:3411
SetIpTTL
DWORD WINAPI SetIpTTL(UINT nTTL)
Definition: iphlpapi_main.c:3094
GetUdpStatisticsEx
DWORD WINAPI GetUdpStatisticsEx(PMIB_UDPSTATS pStats, DWORD dwFamily)
Definition: iphlpapi_main.c:2728
IpForwardTableSorter
static int IpForwardTableSorter(const void *a, const void *b)
Definition: iphlpapi_main.c:1882
AllocateAndGetTcpTableFromStack
DWORD WINAPI AllocateAndGetTcpTableFromStack(PMIB_TCPTABLE *ppTcpTable, BOOL bOrder, HANDLE heap, DWORD flags)
Definition: iphlpapi_main.c:281
GetOwnerModuleFromTcpEntry
DWORD WINAPI GetOwnerModuleFromTcpEntry(PMIB_TCPROW_OWNER_MODULE pTcpEntry, TCPIP_OWNER_MODULE_INFO_CLASS Class, PVOID Buffer, PDWORD pdwSize)
Definition: iphlpapi_main.c:2469
GetIpAddrTable
DWORD WINAPI GetIpAddrTable(PMIB_IPADDRTABLE pIpAddrTable, PULONG pdwSize, BOOL bOrder)
Definition: iphlpapi_main.c:1816
AllocateAndGetUdpExTableFromStack
DWORD WINAPI AllocateAndGetUdpExTableFromStack(PVOID *ppUdpTable, BOOL bOrder, HANDLE heap, DWORD flags, DWORD family)
Definition: iphlpapi_main.c:461
NhGetInterfaceNameFromDeviceGuid
DWORD WINAPI NhGetInterfaceNameFromDeviceGuid(_In_ const GUID *pInterfaceGUID, _Out_writes_bytes_to_(*pOutBufLen, *pOutBufLen) PWCHAR pInterfaceName, _Inout_ PULONG pOutBufLen, DWORD dwUnknown4, DWORD dwUnknown5)
Definition: iphlpapi_main.c:3477
DeleteIPAddress
DWORD WINAPI DeleteIPAddress(ULONG NTEContext)
Definition: iphlpapi_main.c:614
GetBestRoute
DWORD WINAPI GetBestRoute(DWORD dwDestAddr, DWORD dwSourceAddr, PMIB_IPFORWARDROW pBestRoute)
Definition: iphlpapi_main.c:941
AllocateAndGetIfTableFromStack
DWORD WINAPI AllocateAndGetIfTableFromStack(PMIB_IFTABLE *ppIfTable, BOOL bOrder, HANDLE heap, DWORD flags)
Definition: iphlpapi_main.c:107
PNAME_SERVER_LIST_CONTEXT
struct _NAME_SERVER_LIST_CONTEXT * PNAME_SERVER_LIST_CONTEXT
GetTcpStatistics
DWORD WINAPI GetTcpStatistics(PMIB_TCPSTATS pStats)
Definition: iphlpapi_main.c:2680
GetUdpTable
DWORD WINAPI GetUdpTable(PMIB_UDPTABLE pUdpTable, PDWORD pdwSize, BOOL bOrder)
Definition: iphlpapi_main.c:2772
UdpTableSorter
static int UdpTableSorter(const void *a, const void *b)
Definition: iphlpapi_main.c:1406
SendARP
DWORD WINAPI SendARP(IPAddr DestIP, IPAddr SrcIP, PULONG pMacAddr, PULONG PhyAddrLen)
Definition: iphlpapi_main.c:2935
GetNumberOfInterfaces
DWORD WINAPI GetNumberOfInterfaces(PDWORD pdwNumIf)
Definition: iphlpapi_main.c:2273
CreateNameServerListEnumNamesFunc
static void CreateNameServerListEnumNamesFunc(PWCHAR Interface, PWCHAR Server, PVOID Data)
Definition: iphlpapi_main.c:2514
NhGetInterfaceNameFromGuid
DWORD WINAPI NhGetInterfaceNameFromGuid(_In_ const GUID *pInterfaceGUID, _Out_writes_bytes_to_(*pOutBufLen, *pOutBufLen) PWCHAR pInterfaceName, _Inout_ PULONG pOutBufLen, DWORD dwUnknown4, DWORD dwUnknown5)
Definition: iphlpapi_main.c:3495
AllocateAndGetIpForwardTableFromStack
DWORD WINAPI AllocateAndGetIpForwardTableFromStack(PMIB_IPFORWARDTABLE *ppIpForwardTable, BOOL bOrder, HANDLE heap, DWORD flags)
Definition: iphlpapi_main.c:193
GetTcpTable
DWORD WINAPI GetTcpTable(PMIB_TCPTABLE pTcpTable, PDWORD pdwSize, BOOL bOrder)
Definition: iphlpapi_main.c:2708
GetAdapterIndex
DWORD WINAPI GetAdapterIndex(LPWSTR AdapterName, PULONG IfIndex)
Definition: iphlpapi_main.c:748
DeleteProxyArpEntry
DWORD WINAPI DeleteProxyArpEntry(DWORD dwAddress, DWORD dwMask, DWORD dwIfIndex)
Definition: iphlpapi_main.c:677
AllocateAndGetTcpExTable2FromStack
DWORD WINAPI AllocateAndGetTcpExTable2FromStack(PVOID *ppTcpTable, BOOL bOrder, HANDLE heap, DWORD flags, DWORD family, TCP_TABLE_CLASS class)
Definition: iphlpapi_main.c:372
GetIpStatisticsEx
DWORD WINAPI GetIpStatisticsEx(PMIB_IPSTATS pStats, DWORD dwFamily)
Definition: iphlpapi_main.c:2097
IpRenewAddress
DWORD WINAPI IpRenewAddress(PIP_ADAPTER_INDEX_MAP AdapterInfo)
Definition: iphlpapi_main.c:2851
iphlpapi_private.h
GAA_FLAG_SKIP_FRIENDLY_NAME
#define GAA_FLAG_SKIP_FRIENDLY_NAME
Definition: iphlpapi_private.h:81
GAA_FLAG_SKIP_UNICAST
#define GAA_FLAG_SKIP_UNICAST
Definition: iphlpapi_private.h:77
EnumNameServers
LSTATUS EnumNameServers(HKEY RegHandle, LPWSTR Interface, PVOID Data, EnumNameServersFunc cb)
TCPSendIoctl
DWORD TCPSendIoctl(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, PULONG pInBufferSize, LPVOID lpOutBuffer, PULONG pOutBufferSize)
Definition: iphlpapi_reactos.c:13
getNthIpEntity
NTSTATUS getNthIpEntity(HANDLE tcpFile, DWORD index, TDIEntityID *ent)
Definition: ipstats_reactos.c:65
TCP_REQUEST_SET_INFORMATION_INIT
#define TCP_REQUEST_SET_INFORMATION_INIT
Definition: iphlpapi_private.h:73
IF_OPER_STATUS_CONNECTING
@ IF_OPER_STATUS_CONNECTING
Definition: ipifcons.h:241
PMIB_IPFORWARDTABLE
struct _MIB_IPFORWARDTABLE * PMIB_IPFORWARDTABLE
MIB_IPROUTE_TYPE_DIRECT
@ MIB_IPROUTE_TYPE_DIRECT
Definition: ipmib.h:63
PMIB_IPNETTABLE
struct _MIB_IPNETTABLE * PMIB_IPNETTABLE
MIB_IPNETROW
struct _MIB_IPNETROW MIB_IPNETROW
MIB_IPADDRROW
struct _MIB_IPADDRROW MIB_IPADDRROW
MIB_IPFORWARDTABLE
struct _MIB_IPFORWARDTABLE MIB_IPFORWARDTABLE
MIB_IPADDRTABLE
struct _MIB_IPADDRTABLE MIB_IPADDRTABLE
PMIB_IPNETROW
struct _MIB_IPNETROW * PMIB_IPNETROW
MIB_IPNETTABLE
struct _MIB_IPNETTABLE MIB_IPNETTABLE
PMIB_IPFORWARDROW
struct _MIB_IPFORWARDROW * PMIB_IPFORWARDROW
MIB_IPFORWARDROW
struct _MIB_IPFORWARDROW MIB_IPFORWARDROW
PMIB_IPADDRTABLE
struct _MIB_IPADDRTABLE * PMIB_IPADDRTABLE
PMIB_IPADDRROW
struct _MIB_IPADDRROW * PMIB_IPADDRROW
TCPIP_OWNER_MODULE_BASIC_INFO
struct _TCPIP_OWNER_MODULE_BASIC_INFO TCPIP_OWNER_MODULE_BASIC_INFO
TCP_TABLE_CLASS
enum _TCP_TABLE_CLASS TCP_TABLE_CLASS
TCP_TABLE_OWNER_MODULE_CONNECTIONS
@ TCP_TABLE_OWNER_MODULE_CONNECTIONS
Definition: iprtrmib.h:37
TCP_TABLE_BASIC_CONNECTIONS
@ TCP_TABLE_BASIC_CONNECTIONS
Definition: iprtrmib.h:31
TCP_TABLE_BASIC_LISTENER
@ TCP_TABLE_BASIC_LISTENER
Definition: iprtrmib.h:30
TCP_TABLE_OWNER_MODULE_ALL
@ TCP_TABLE_OWNER_MODULE_ALL
Definition: iprtrmib.h:38
TCP_TABLE_OWNER_PID_LISTENER
@ TCP_TABLE_OWNER_PID_LISTENER
Definition: iprtrmib.h:33
TCP_TABLE_BASIC_ALL
@ TCP_TABLE_BASIC_ALL
Definition: iprtrmib.h:32
TCP_TABLE_OWNER_PID_ALL
@ TCP_TABLE_OWNER_PID_ALL
Definition: iprtrmib.h:35
TCP_TABLE_OWNER_PID_CONNECTIONS
@ TCP_TABLE_OWNER_PID_CONNECTIONS
Definition: iprtrmib.h:34
TCP_TABLE_OWNER_MODULE_LISTENER
@ TCP_TABLE_OWNER_MODULE_LISTENER
Definition: iprtrmib.h:36
TCPIP_OWNER_MODULE_INFO_CLASS
enum _TCPIP_OWNER_MODULE_INFO_CLASS TCPIP_OWNER_MODULE_INFO_CLASS
UDP_TABLE_CLASS
enum _UDP_TABLE_CLASS UDP_TABLE_CLASS
UDP_TABLE_BASIC
@ UDP_TABLE_BASIC
Definition: iprtrmib.h:43
UDP_TABLE_OWNER_MODULE
@ UDP_TABLE_OWNER_MODULE
Definition: iprtrmib.h:45
UDP_TABLE_OWNER_PID
@ UDP_TABLE_OWNER_PID
Definition: iprtrmib.h:44
getTCPStats
DWORD getTCPStats(MIB_TCPSTATS *stats, DWORD family)
Definition: ipstats_reactos.c:344
getTcpTable
PVOID getTcpTable(CLASS_TABLE Class)
Definition: ipstats_reactos.c:778
getICMPStats
DWORD getICMPStats(MIB_ICMP *stats)
Definition: ipstats_reactos.c:206
getUDPStats
DWORD getUDPStats(MIB_UDPSTATS *stats, DWORD family)
Definition: ipstats_reactos.c:355
getInterfaceStatsByName
DWORD getInterfaceStatsByName(const char *name, PMIB_IFROW entry)
Definition: ipstats_reactos.c:191
getNumArpEntries
DWORD getNumArpEntries(void)
Definition: ipstats_reactos.c:495
getRouteTable
RouteTable * getRouteTable(void)
Definition: ipstats_reactos.c:424
getArpTable
PMIB_IPNETTABLE getArpTable(void)
Definition: ipstats_reactos.c:543
ClassModulePid
@ ClassModulePid
Definition: ipstats.h:81
ClassBasic
@ ClassBasic
Definition: ipstats.h:80
ClassModule
@ ClassModule
Definition: ipstats.h:82
getUdpTable
PVOID getUdpTable(CLASS_TABLE Class)
Definition: ipstats_reactos.c:667
getNumRoutes
DWORD getNumRoutes(void)
Definition: ipstats_reactos.c:366
getIPStats
DWORD getIPStats(PMIB_IPSTATS stats, DWORD family)
Definition: ipstats_reactos.c:333
MAX_ADAPTER_NAME_LENGTH
#define MAX_ADAPTER_NAME_LENGTH
Definition: iptypes.h:27
IP_PER_ADAPTER_INFO
struct _IP_PER_ADAPTER_INFO IP_PER_ADAPTER_INFO
IP_ADAPTER_INFO
struct _IP_ADAPTER_INFO IP_ADAPTER_INFO
HYBRID_NODETYPE
#define HYBRID_NODETYPE
Definition: iptypes.h:39
IP_ADDR_STRING
struct _IP_ADDR_STRING IP_ADDR_STRING
inet_addr
#define inet_addr(cp)
Definition: inet.h:98
INADDR_ANY
#define INADDR_ANY
Definition: inet.h:53
b
#define b
Definition: ke_i.h:79
REG_SZ
#define REG_SZ
Definition: layer.c:22
if
if(dx< 0)
Definition: linetemp.h:194
lpvReserved
static IN DWORD IN LPVOID lpvReserved
Definition: load_notifications.c:17
memcpy
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
ASSERT
#define ASSERT(a)
Definition: mode.c:44
ntohl
#define ntohl(x)
Definition: module.h:205
ERROR_FILE_NOT_FOUND
#define ERROR_FILE_NOT_FOUND
Definition: disk.h:79
GuidString
static PWSTR GuidString
Definition: apphelp.c:93
dwSize
PSDBQUERYRESULT_VISTA PVOID DWORD * dwSize
Definition: env.c:56
ptr
static PVOID ptr
Definition: dispmode.c:27
_Inout_
#define _Inout_
Definition: ms_sal.h:378
_Out_writes_bytes_to_
#define _Out_writes_bytes_to_(size, count)
Definition: ms_sal.h:360
_In_
#define _In_
Definition: ms_sal.h:308
UINT
unsigned int UINT
Definition: ndis.h:50
ErrorCode
_In_ NDIS_ERROR_CODE ErrorCode
Definition: ndis.h:4436
AdapterName
_Must_inspect_result_ _Out_ PNDIS_STATUS _Out_ PNDIS_STATUS _Out_ PNDIS_HANDLE _Out_ PUINT _In_ UINT _In_ NDIS_HANDLE _In_ NDIS_HANDLE _In_ PNDIS_STRING AdapterName
Definition: ndis.h:6016
IpDadStatePreferred
@ IpDadStatePreferred
Definition: nldef.h:49
IpPrefixOriginOther
@ IpPrefixOriginOther
Definition: nldef.h:9
FILE_WRITE_DATA
#define FILE_WRITE_DATA
Definition: nt_native.h:631
FILE_READ_DATA
#define FILE_READ_DATA
Definition: nt_native.h:628
KEY_READ
#define KEY_READ
Definition: nt_native.h:1023
RtlFreeUnicodeString
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
DWORD
#define DWORD
Definition: nt_native.h:44
UNICODE_NULL
#define UNICODE_NULL
PHANDLE
PVOID *typedef PHANDLE
Definition: ntsecpkg.h:455
STATUS_PENDING
#define STATUS_PENDING
Definition: ntstatus.h:82
L
#define L(x)
Definition: ntvdm.h:50
PBYTE
BYTE * PBYTE
Definition: pedump.c:66
PDWORD
DWORD * PDWORD
Definition: pedump.c:68
LONG
long LONG
Definition: pedump.c:60
USHORT
unsigned short USHORT
Definition: pedump.c:61
IPAddr
ULONG IPAddr
Definition: pfhook.h:35
Address
static WCHAR Address[46]
Definition: ping.c:68
Family
static int Family
Definition: ping.c:62
disposeResInfo
VOID disposeResInfo(PIPHLP_RES_INFO InfoPtr)
Definition: resinfo.c:60
getResInfo
PIPHLP_RES_INFO getResInfo()
Definition: resinfo.c:54
wcscpy
_CRTIMP wchar_t *__cdecl wcscpy(_Out_writes_z_(_String_length_(_Source)+1) wchar_t *_Dest, _In_z_ const wchar_t *_Source)
heap
static HANDLE heap
Definition: heap.c:65
memset
#define memset(x, y, z)
Definition: compat.h:39
openTcpFile
NTSTATUS openTcpFile(PHANDLE tcpFile, ACCESS_MASK DesiredAccess)
Definition: handle.c:12
closeTcpFile
VOID closeTcpFile(HANDLE h)
Definition: handle.c:43
qsort
void __cdecl qsort(_Inout_updates_bytes_(_NumOfElements *_SizeOfElements) void *_Base, _In_ size_t _NumOfElements, _In_ size_t _SizeOfElements, _In_ int(__cdecl *_PtFuncCompare)(const void *, const void *))
hr
HRESULT hr
Definition: shlfolder.c:183
overlapped
namespace GUID const ADDRINFOEXW ADDRINFOEXW struct timeval OVERLAPPED * overlapped
Definition: sock.c:81
TRACE
#define TRACE(s)
Definition: solgame.cpp:4
Server
static void Server(int port)
Definition: srltest.c:69
StringCchCatW
STRSAFEAPI StringCchCatW(STRSAFE_LPWSTR pszDest, size_t cchDest, STRSAFE_LPCWSTR pszSrc)
Definition: strsafe.h:325
StringCbPrintfW
STRSAFEAPI StringCbPrintfW(STRSAFE_LPWSTR pszDest, size_t cbDest, STRSAFE_LPCWSTR pszFormat,...)
Definition: strsafe.h:557
FIXED_INFO
Definition: iptypes.h:80
FIXED_INFO::DnsServerList
IP_ADDR_STRING DnsServerList
Definition: iptypes.h:84
FIXED_INFO::HostName
char HostName[MAX_HOSTNAME_LEN+4]
Definition: iptypes.h:81
FIXED_INFO::NodeType
UINT NodeType
Definition: iptypes.h:85
FIXED_INFO::ScopeId
char ScopeId[MAX_SCOPE_ID_LEN+4]
Definition: iptypes.h:86
FIXED_INFO::DomainName
char DomainName[MAX_DOMAIN_NAME_LEN+4]
Definition: iptypes.h:82
IFEntry::if_operstatus
ULONG if_operstatus
Definition: tcpioctl.h:115
IFEntry::if_descr
UCHAR if_descr[1]
Definition: tcpioctl.h:130
IFEntry::if_descrlen
ULONG if_descrlen
Definition: tcpioctl.h:129
IFEntry::if_physaddrlen
ULONG if_physaddrlen
Definition: tcpioctl.h:112
IFEntry::if_type
ULONG if_type
Definition: tcpioctl.h:109
IFEntry::if_mtu
ULONG if_mtu
Definition: tcpioctl.h:110
IFEntry::if_physaddr
UCHAR if_physaddr[MAX_PHYSADDR_SIZE]
Definition: tcpioctl.h:113
IPAddrEntry::iae_addr
ULONG iae_addr
Definition: tcpioctl.h:162
IP_ADDRESS_STRING
Definition: iptypes.h:41
IP_ADDRESS_STRING::String
char String[4 *4]
Definition: iptypes.h:42
_IFInfo
Definition: iphlpapi_private.h:127
_IFInfo::if_info
IFEntrySafelySized if_info
Definition: iphlpapi_private.h:129
_IFInfo::ip_addr
IPAddrEntry ip_addr
Definition: iphlpapi_private.h:130
_IO_STATUS_BLOCK
Definition: env_spec_w32.h:870
_IPHLP_RES_INFO
Definition: resinfo.h:24
_IPHLP_RES_INFO::DnsList
IP_ADDR_STRING * DnsList
Definition: resinfo.h:26
_IPHLP_RES_INFO::riCount
DWORD riCount
Definition: resinfo.h:25
_IP_ADAPTER_INDEX_MAP
Definition: ipexport.h:145
_IP_ADAPTER_INDEX_MAP::Index
ULONG Index
Definition: ipexport.h:146
_IP_ADAPTER_INDEX_MAP::Name
WCHAR Name[MAX_ADAPTER_NAME]
Definition: ipexport.h:147
_IP_ADAPTER_INFO
Definition: iptypes.h:52
_IP_ADAPTER_ORDER_MAP
Definition: ipexport.h:162
_IP_ADDR_STRING
Definition: iptypes.h:45
_IP_ADDR_STRING::Next
struct _IP_ADDR_STRING * Next
Definition: iptypes.h:46
_IP_ADDR_STRING::IpAddress
IP_ADDRESS_STRING IpAddress
Definition: iptypes.h:47
_IP_ADDR_STRING::Context
DWORD Context
Definition: iptypes.h:49
_IP_INTERFACE_INFO
Definition: ipexport.h:150
_IP_INTERFACE_INFO::NumAdapters
LONG NumAdapters
Definition: ipexport.h:151
_IP_INTERFACE_INFO::Adapter
IP_ADAPTER_INDEX_MAP Adapter[1]
Definition: ipexport.h:152
_IP_INTERFACE_NAME_INFO
Definition: iptypes.h:98
_IP_PER_ADAPTER_INFO
Definition: iptypes.h:73
_IP_PER_ADAPTER_INFO::AutoconfigActive
UINT AutoconfigActive
Definition: iptypes.h:75
_IP_UNIDIRECTIONAL_ADAPTER_ADDRESS
Definition: ipexport.h:155
_InterfaceIndexTable
Definition: ifenum.h:61
_InterfaceIndexTable::numIndexes
DWORD numIndexes
Definition: ifenum.h:62
_InterfaceIndexTable::indexes
DWORD indexes[1]
Definition: ifenum.h:64
_MIB_ICMP_EX
Definition: ipmib.h:246
_MIB_ICMP
Definition: ipmib.h:198
_MIB_IFROW
Definition: ifmib.h:36
_MIB_IFROW::dwIndex
DWORD dwIndex
Definition: ifmib.h:38
_MIB_IFTABLE
Definition: ifmib.h:64
_MIB_IFTABLE::table
MIB_IFROW table[1]
Definition: ifmib.h:66
_MIB_IFTABLE::dwNumEntries
DWORD dwNumEntries
Definition: ifmib.h:65
_MIB_IPADDRROW
Definition: ipmib.h:35
_MIB_IPADDRROW::unused1
unsigned short unused1
Definition: ipmib.h:41
_MIB_IPADDRROW::dwReasmSize
DWORD dwReasmSize
Definition: ipmib.h:40
_MIB_IPADDRROW::dwBCastAddr
DWORD dwBCastAddr
Definition: ipmib.h:39
_MIB_IPADDRROW::dwMask
DWORD dwMask
Definition: ipmib.h:38
_MIB_IPADDRROW::dwAddr
DWORD dwAddr
Definition: ipmib.h:36
_MIB_IPADDRROW::dwIndex
IF_INDEX dwIndex
Definition: ipmib.h:37
_MIB_IPADDRROW::wType
unsigned short wType
Definition: ipmib.h:42
_MIB_IPADDRTABLE
Definition: ipmib.h:46
_MIB_IPADDRTABLE::table
MIB_IPADDRROW table[1]
Definition: ipmib.h:48
_MIB_IPADDRTABLE::dwNumEntries
DWORD dwNumEntries
Definition: ipmib.h:47
_MIB_IPFORWARDROW
Definition: ipmib.h:70
_MIB_IPFORWARDROW::dwForwardMetric5
DWORD dwForwardMetric5
Definition: ipmib.h:92
_MIB_IPFORWARDROW::dwForwardNextHop
DWORD dwForwardNextHop
Definition: ipmib.h:74
_MIB_IPFORWARDROW::dwForwardMetric2
DWORD dwForwardMetric2
Definition: ipmib.h:89
_MIB_IPFORWARDROW::dwForwardPolicy
DWORD dwForwardPolicy
Definition: ipmib.h:73
_MIB_IPFORWARDROW::dwForwardMetric3
DWORD dwForwardMetric3
Definition: ipmib.h:90
_MIB_IPFORWARDROW::dwForwardProto
DWORD dwForwardProto
Definition: ipmib.h:83
_MIB_IPFORWARDROW::dwForwardMetric1
DWORD dwForwardMetric1
Definition: ipmib.h:88
_MIB_IPFORWARDROW::dwForwardIfIndex
IF_INDEX dwForwardIfIndex
Definition: ipmib.h:75
_MIB_IPFORWARDROW::dwForwardNextHopAS
DWORD dwForwardNextHopAS
Definition: ipmib.h:87
_MIB_IPFORWARDROW::dwForwardDest
DWORD dwForwardDest
Definition: ipmib.h:71
_MIB_IPFORWARDROW::dwForwardMask
DWORD dwForwardMask
Definition: ipmib.h:72
_MIB_IPFORWARDROW::dwForwardMetric4
DWORD dwForwardMetric4
Definition: ipmib.h:91
_MIB_IPFORWARDROW::dwForwardAge
DWORD dwForwardAge
Definition: ipmib.h:86
_MIB_IPFORWARDROW::dwForwardType
DWORD dwForwardType
Definition: ipmib.h:78
_MIB_IPFORWARDTABLE
Definition: ipmib.h:96
_MIB_IPFORWARDTABLE::dwNumEntries
DWORD dwNumEntries
Definition: ipmib.h:97
_MIB_IPFORWARDTABLE::table
MIB_IPFORWARDROW table[1]
Definition: ipmib.h:98
_MIB_IPNETROW
Definition: ipmib.h:113
_MIB_IPNETROW::dwIndex
DWORD dwIndex
Definition: ipmib.h:114
_MIB_IPNETTABLE
Definition: ipmib.h:126
_MIB_IPNETTABLE::dwNumEntries
DWORD dwNumEntries
Definition: ipmib.h:127
_MIB_IPNETTABLE::table
MIB_IPNETROW table[1]
Definition: ipmib.h:128
_MIB_IPSTATS
Definition: ipmib.h:141
_MIB_TCPROW_OWNER_MODULE
Definition: tcpmib.h:119
_MIB_TCPROW_OWNER_MODULE::dwState
DWORD dwState
Definition: tcpmib.h:120
_MIB_TCPROW_OWNER_MODULE::OwningModuleInfo
ULONGLONG OwningModuleInfo[TCPIP_OWNING_MODULE_SIZE]
Definition: tcpmib.h:127
_MIB_TCPROW_OWNER_MODULE::dwOwningPid
DWORD dwOwningPid
Definition: tcpmib.h:125
_MIB_TCPROW_OWNER_PID
Definition: tcpmib.h:103
_MIB_TCPROW_OWNER_PID::dwState
DWORD dwState
Definition: tcpmib.h:104
_MIB_TCPROW
Definition: tcpmib.h:52
_MIB_TCPROW::dwLocalPort
DWORD dwLocalPort
Definition: tcpmib.h:59
_MIB_TCPROW::dwLocalAddr
DWORD dwLocalAddr
Definition: tcpmib.h:58
_MIB_TCPROW::State
MIB_TCP_STATE State
Definition: tcpmib.h:56
_MIB_TCPROW::dwRemotePort
DWORD dwRemotePort
Definition: tcpmib.h:61
_MIB_TCPROW::dwRemoteAddr
DWORD dwRemoteAddr
Definition: tcpmib.h:60
_MIB_TCPSTATS
Definition: tcpmib.h:170
_MIB_TCPTABLE_OWNER_MODULE
Definition: tcpmib.h:131
_MIB_TCPTABLE_OWNER_MODULE::dwNumEntries
DWORD dwNumEntries
Definition: tcpmib.h:132
_MIB_TCPTABLE_OWNER_MODULE::table
MIB_TCPROW_OWNER_MODULE table[1]
Definition: tcpmib.h:133
_MIB_TCPTABLE_OWNER_PID
Definition: tcpmib.h:113
_MIB_TCPTABLE_OWNER_PID::dwNumEntries
DWORD dwNumEntries
Definition: tcpmib.h:114
_MIB_TCPTABLE_OWNER_PID::table
MIB_TCPROW_OWNER_PID table[1]
Definition: tcpmib.h:115
_MIB_TCPTABLE
Definition: tcpmib.h:65
_MIB_TCPTABLE::dwNumEntries
DWORD dwNumEntries
Definition: tcpmib.h:66
_MIB_TCPTABLE::table
MIB_TCPROW table[1]
Definition: tcpmib.h:67
_MIB_UDPROW_OWNER_MODULE
Definition: udpmib.h:52
_MIB_UDPROW_OWNER_MODULE::dwOwningPid
DWORD dwOwningPid
Definition: udpmib.h:55
_MIB_UDPROW_OWNER_MODULE::OwningModuleInfo
ULONGLONG OwningModuleInfo[TCPIP_OWNING_MODULE_SIZE]
Definition: udpmib.h:65
_MIB_UDPROW_OWNER_PID
Definition: udpmib.h:39
_MIB_UDPROW
Definition: udpmib.h:27
_MIB_UDPROW::dwLocalAddr
DWORD dwLocalAddr
Definition: udpmib.h:28
_MIB_UDPROW::dwLocalPort
DWORD dwLocalPort
Definition: udpmib.h:29
_MIB_UDPSTATS
Definition: udpmib.h:77
_MIB_UDPTABLE_OWNER_MODULE
Definition: udpmib.h:69
_MIB_UDPTABLE_OWNER_MODULE::dwNumEntries
DWORD dwNumEntries
Definition: udpmib.h:70
_MIB_UDPTABLE_OWNER_MODULE::table
MIB_UDPROW_OWNER_MODULE table[1]
Definition: udpmib.h:71
_MIB_UDPTABLE_OWNER_PID
Definition: udpmib.h:46
_MIB_UDPTABLE_OWNER_PID::dwNumEntries
DWORD dwNumEntries
Definition: udpmib.h:47
_MIB_UDPTABLE_OWNER_PID::table
MIB_UDPROW_OWNER_PID table[1]
Definition: udpmib.h:48
_MIB_UDPTABLE
Definition: udpmib.h:33
_MIB_UDPTABLE::dwNumEntries
DWORD dwNumEntries
Definition: udpmib.h:34
_MIB_UDPTABLE::table
MIB_UDPROW table[1]
Definition: udpmib.h:35
_NAME_SERVER_LIST_CONTEXT
Definition: iphlpapi_main.c:31
_NAME_SERVER_LIST_CONTEXT::uSizeRequired
ULONG uSizeRequired
Definition: iphlpapi_main.c:33
_NAME_SERVER_LIST_CONTEXT::uSizeAvailable
ULONG uSizeAvailable
Definition: iphlpapi_main.c:32
_NAME_SERVER_LIST_CONTEXT::pData
PIP_PER_ADAPTER_INFO pData
Definition: iphlpapi_main.c:34
_NAME_SERVER_LIST_CONTEXT::NumServers
UINT NumServers
Definition: iphlpapi_main.c:35
_NAME_SERVER_LIST_CONTEXT::pLastAddr
IP_ADDR_STRING * pLastAddr
Definition: iphlpapi_main.c:36
_OVERLAPPED
Definition: winbase.h:810
_RouteTable
Definition: ipstats.h:74
_TCPIP_OWNER_MODULE_BASIC_INFO
Definition: iprtrmib.h:54
_TCPIP_OWNER_MODULE_BASIC_INFO::pModuleName
PWCHAR pModuleName
Definition: iprtrmib.h:55
_TCPIP_OWNER_MODULE_BASIC_INFO::pModulePath
PWCHAR pModulePath
Definition: iprtrmib.h:56
_TCP_REQUEST_SET_INFORMATION_EX::BufferSize
unsigned int BufferSize
Definition: tdiinfo.h:96
_TCP_REQUEST_SET_INFORMATION_EX::ID
TDIObjectID ID
Definition: tdiinfo.h:95
_TCP_REQUEST_SET_INFORMATION_EX::Buffer
unsigned char Buffer[1]
Definition: tdiinfo.h:97
_TDIEntityID
Definition: tdiinfo.h:30
_TDIEntityID::tei_entity
ULONG tei_entity
Definition: tdiinfo.h:31
_TDIEntityID::tei_instance
ULONG tei_instance
Definition: tdiinfo.h:32
_TDIObjectID::toi_id
ULONG toi_id
Definition: tdiinfo.h:77
_TDIObjectID::toi_type
ULONG toi_type
Definition: tdiinfo.h:76
_TDIObjectID::toi_class
ULONG toi_class
Definition: tdiinfo.h:75
_TDIObjectID::toi_entity
TDIEntityID toi_entity
Definition: tdiinfo.h:74
_UNICODE_STRING
Definition: env_spec_w32.h:368
name
Definition: name.c:39
status
Definition: ps.c:97
IP_MIB_ARPTABLE_ENTRY_ID
#define IP_MIB_ARPTABLE_ENTRY_ID
Definition: tcpioctl.h:54
IOCTL_QUERY_IP_HW_ADDRESS
#define IOCTL_QUERY_IP_HW_ADDRESS
Definition: tcpioctl.h:40
PMIB_TCPROW
struct _MIB_TCPROW * PMIB_TCPROW
MIB_TCPROW
struct _MIB_TCPROW MIB_TCPROW
PMIB_TCPTABLE_OWNER_PID
struct _MIB_TCPTABLE_OWNER_PID * PMIB_TCPTABLE_OWNER_PID
PMIB_TCPTABLE
struct _MIB_TCPTABLE * PMIB_TCPTABLE
MIB_TCPROW_OWNER_PID
struct _MIB_TCPROW_OWNER_PID MIB_TCPROW_OWNER_PID
MIB_TCP_STATE_LISTEN
@ MIB_TCP_STATE_LISTEN
Definition: tcpmib.h:29
MIB_TCPROW_OWNER_MODULE
struct _MIB_TCPROW_OWNER_MODULE MIB_TCPROW_OWNER_MODULE
INFO_CLASS_PROTOCOL
#define INFO_CLASS_PROTOCOL
Definition: tdiinfo.h:65
AT_ENTITY
#define AT_ENTITY
Definition: tdiinfo.h:41
INFO_TYPE_PROVIDER
#define INFO_TYPE_PROVIDER
Definition: tdiinfo.h:69
IOCTL_TCP_SET_INFORMATION_EX
#define IOCTL_TCP_SET_INFORMATION_EX
Definition: tditest.h:112
PWSTR
uint16_t * PWSTR
Definition: typedefs.h:56
PULONG
uint32_t * PULONG
Definition: typedefs.h:59
FIELD_OFFSET
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
LPBYTE
unsigned char * LPBYTE
Definition: typedefs.h:53
NTAPI
#define NTAPI
Definition: typedefs.h:36
PVOID
void * PVOID
Definition: typedefs.h:50
LPDWORD
uint32_t * LPDWORD
Definition: typedefs.h:59
RtlCopyMemory
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
RtlZeroMemory
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
ULONG_PTR
uint32_t ULONG_PTR
Definition: typedefs.h:65
PWCHAR
uint16_t * PWCHAR
Definition: typedefs.h:56
PUCHAR
unsigned char * PUCHAR
Definition: typedefs.h:53
ULONG
uint32_t ULONG
Definition: typedefs.h:59
PMIB_UDPTABLE_OWNER_PID
struct _MIB_UDPTABLE_OWNER_PID * PMIB_UDPTABLE_OWNER_PID
MIB_UDPROW_OWNER_MODULE
struct _MIB_UDPROW_OWNER_MODULE MIB_UDPROW_OWNER_MODULE
PMIB_UDPROW
struct _MIB_UDPROW * PMIB_UDPROW
MIB_UDPROW_OWNER_PID
struct _MIB_UDPROW_OWNER_PID MIB_UDPROW_OWNER_PID
MIB_UDPROW
struct _MIB_UDPROW MIB_UDPROW
PMIB_UDPTABLE
struct _MIB_UDPTABLE * PMIB_UDPTABLE
_IFEntrySafelySized::ent
IFEntry ent
Definition: iphlpapi_private.h:109
_TCP_REQUEST_SET_INFORMATION_EX_ARP_ENTRY
Definition: iphlpapi_private.h:119
_TCP_REQUEST_SET_INFORMATION_EX_ARP_ENTRY::Req
TCP_REQUEST_SET_INFORMATION_EX Req
Definition: iphlpapi_private.h:122
ret
int ret
Definition: wcstombs-tests.c:31
Size
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG Size
Definition: wdfdevice.h:4533
Interface
_Must_inspect_result_ _In_ WDFDEVICE _In_ LPCGUID _Out_ PINTERFACE Interface
Definition: wdffdo.h:465
Version
_Must_inspect_result_ _In_ WDFDEVICE _In_ LPCGUID _Out_ PINTERFACE _In_ USHORT _In_ USHORT Version
Definition: wdffdo.h:469
ZeroMemory
#define ZeroMemory
Definition: winbase.h:1670
GetLastError
DWORD WINAPI GetLastError(void)
Definition: except.c:1040
CopyMemory
#define CopyMemory
Definition: winbase.h:1668
dwFlags
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1176
Reserved
_Reserved_ PVOID Reserved
Definition: winddi.h:3974
WINAPI
#define WINAPI
Definition: msvc.h:6
ERROR_PARTIAL_COPY
#define ERROR_PARTIAL_COPY
Definition: winerror.h:303
ERROR_BUFFER_OVERFLOW
#define ERROR_BUFFER_OVERFLOW
Definition: winerror.h:185
ERROR_NO_DATA
#define ERROR_NO_DATA
Definition: winerror.h:284
ERROR_PATH_NOT_FOUND
#define ERROR_PATH_NOT_FOUND
Definition: winerror.h:106
NOERROR
#define NOERROR
Definition: winerror.h:2354
ERROR_PROC_NOT_FOUND
#define ERROR_PROC_NOT_FOUND
Definition: winerror.h:199
ERROR_INVALID_DATA
#define ERROR_INVALID_DATA
Definition: winerror.h:116
ERROR_NOT_FOUND
#define ERROR_NOT_FOUND
Definition: winerror.h:690
HKEY_LOCAL_MACHINE
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12
HKEY_CURRENT_USER
#define HKEY_CURRENT_USER
Definition: winreg.h:11
PF_INET
#define PF_INET
Definition: winsock.h:373
AF_INET6
#define AF_INET6
Definition: winsock.h:369
Flags
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180
LPWSTR
WCHAR * LPWSTR
Definition: xmlstorage.h:184