ReactOS  0.4.13-dev-464-g6b95727
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 
30 
31 typedef struct _NAME_SERVER_LIST_CONTEXT {
38 
40 {
41  switch (fdwReason) {
42  case DLL_PROCESS_ATTACH:
43  DisableThreadLibraryCalls( hinstDLL );
45  break;
46 
47  case DLL_PROCESS_DETACH:
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  */
71 DWORD WINAPI AddIPAddress(IPAddr Address, IPMask Netmask, DWORD IfIndex, PULONG NteContext, PULONG NteInstance)
72 {
73  return RtlNtStatusToDosError(addIPAddress(Address, Netmask, IfIndex, NteContext, NteInstance));
74 }
75 
77 {
78  DWORD ndx, retVal = 0, numRoutes = getNumRoutes();
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  }
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  */
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)
116  else {
117  DWORD dwSize = 0;
118 
119  *ppIfTable = NULL;
120  ret = GetIfTable(*ppIfTable, &dwSize, bOrder);
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  */
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)
160  else {
161  DWORD dwSize = 0;
162 
163  *ppIpAddrTable = NULL;
164  ret = GetIpAddrTable(*ppIpAddrTable, &dwSize, bOrder);
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  */
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)
202  else {
203  DWORD dwSize = 0;
204 
205  *ppIpForwardTable = NULL;
206  ret = GetIpForwardTable(*ppIpForwardTable, &dwSize, bOrder);
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  */
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)
246  else {
247  DWORD dwSize = 0;
248 
249  *ppIpNetTable = NULL;
250  ret = GetIpNetTable(*ppIpNetTable, &dwSize, bOrder);
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  */
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)
290  else {
291  DWORD dwSize = 0;
292 
293  *ppTcpTable = NULL;
294  ret = GetTcpTable(*ppTcpTable, &dwSize, bOrder);
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  */
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)
335  else {
336  DWORD dwSize = 0;
337 
338  *ppTcpTable = NULL;
339  ret = GetExtendedTcpTable(*ppTcpTable, &dwSize, bOrder, family, TCP_TABLE_OWNER_PID_ALL, 0);
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  */
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)
381  else {
382  DWORD dwSize = 0;
383 
384  *ppTcpTable = NULL;
385  ret = GetExtendedTcpTable(*ppTcpTable, &dwSize, bOrder, family, class, 0);
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  */
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)
425  else {
426  DWORD dwSize = 0;
427 
428  *ppUdpTable = NULL;
429  ret = GetUdpTable(*ppUdpTable, &dwSize, bOrder);
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  */
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)
470  else {
471  DWORD dwSize = 0;
472 
473  *ppUdpTable = NULL;
474  ret = GetExtendedUdpTable(*ppUdpTable, &dwSize, bOrder, family, UDP_TABLE_OWNER_PID, 0);
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  */
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)
516  else {
517  DWORD dwSize = 0;
518 
519  *ppUdpTable = NULL;
520  ret = GetExtendedUdpTable(*ppUdpTable, &dwSize, bOrder, family, class, 0);
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  */
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  */
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  */
591 DWORD 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  */
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  */
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  */
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  */
677 DWORD 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  */
700 DWORD 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  */
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  */
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  */
772 {
773  DWORD ret;
774  BOOL dhcpEnabled;
775  DWORD dhcpServer;
776 
777  TRACE("pAdapterInfo %p, pOutBufLen %p\n", pAdapterInfo, pOutBufLen);
778  if (!pOutBufLen)
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;
794  }
795  else {
797 
798  if (table) {
799  size = sizeof(IP_ADAPTER_INFO) * table->numIndexes;
800  if (*pOutBufLen < size) {
801  *pOutBufLen = size;
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);
812  "Software\\Wine\\Wine\\Config\\Network", 0, KEY_READ,
813  &hKey) == ERROR_SUCCESS) {
814  DWORD size = sizeof(primaryWINS.String);
815  unsigned long addr;
816 
817  RegQueryValueExA(hKey, "WinsServer", NULL, NULL,
818  (PBYTE)primaryWINS.String, &size);
819  addr = inet_addr(primaryWINS.String);
820  if (addr != INADDR_NONE && addr != INADDR_ANY)
821  winsEnabled = TRUE;
822  size = sizeof(secondaryWINS.String);
823  RegQueryValueExA(hKey, "BackupWinsServer", NULL, NULL,
824  (PBYTE)secondaryWINS.String, &size);
825  addr = inet_addr(secondaryWINS.String);
826  if (addr != INADDR_NONE && addr != INADDR_ANY)
827  winsEnabled = TRUE;
828  RegCloseKey(hKey);
829  }
830  TRACE("num of index is %lu\n", table->numIndexes);
831  for (ndx = 0; ndx < table->numIndexes; ndx++) {
832  PIP_ADAPTER_INFO ptr = &pAdapterInfo[ndx];
833  DWORD addrLen = sizeof(ptr->Address), type;
834  const char *ifname =
835  getInterfaceNameByIndex(table->indexes[ndx]);
836  if (!ifname) {
838  break;
839  }
840 
841  /* on Win98 this is left empty, but whatever */
842  strncpy(ptr->AdapterName,ifname,sizeof(ptr->AdapterName));
843  consumeInterfaceName(ifname);
844  ptr->AdapterName[MAX_ADAPTER_NAME_LENGTH] = '\0';
845  getInterfacePhysicalByIndex(table->indexes[ndx], &addrLen,
846  ptr->Address, &type);
847  /* MS defines address length and type as UINT in some places and
848  DWORD in others, **sigh**. Don't want to assume that PUINT and
849  PDWORD are equiv (64-bit?) */
850  ptr->AddressLength = addrLen;
851  ptr->Type = type;
852  ptr->Index = table->indexes[ndx];
854  ptr->IpAddressList.IpAddress.String);
856  ptr->IpAddressList.IpMask.String);
857  ptr->IpAddressList.Context = ptr->Index;
859  ptr->GatewayList.IpAddress.String);
860  getDhcpInfoForAdapter(table->indexes[ndx], &dhcpEnabled,
861  &dhcpServer, &ptr->LeaseObtained,
862  &ptr->LeaseExpires);
863  ptr->DhcpEnabled = (DWORD) dhcpEnabled;
864  toIPAddressString(dhcpServer,
865  ptr->DhcpServer.IpAddress.String);
866  if (winsEnabled) {
867  ptr->HaveWins = TRUE;
868  memcpy(ptr->PrimaryWinsServer.IpAddress.String,
869  primaryWINS.String, sizeof(primaryWINS.String));
870  memcpy(ptr->SecondaryWinsServer.IpAddress.String,
871  secondaryWINS.String, sizeof(secondaryWINS.String));
872  }
873  if (ndx < table->numIndexes - 1)
874  ptr->Next = &pAdapterInfo[ndx + 1];
875  else
876  ptr->Next = NULL;
877  }
878  ret = NO_ERROR;
879  }
880  free(table);
881  }
882  else
884  }
885  }
886  else
887  ret = ERROR_NO_DATA;
888  }
889  TRACE("returning %ld\n", ret);
890  return ret;
891 }
892 
893 
894 /******************************************************************
895  * GetBestInterface (IPHLPAPI.@)
896  *
897  *
898  * PARAMS
899  *
900  * dwDestAddr [In]
901  * pdwBestIfIndex [In/Out]
902  *
903  * RETURNS
904  *
905  * DWORD
906  *
907  */
908 DWORD WINAPI GetBestInterface(IPAddr dwDestAddr, PDWORD pdwBestIfIndex)
909 {
910  DWORD ret;
911 
912  TRACE("dwDestAddr 0x%08lx, pdwBestIfIndex %p\n", dwDestAddr, pdwBestIfIndex);
913  if (!pdwBestIfIndex)
915  else {
916  MIB_IPFORWARDROW ipRow;
917 
918  ret = GetBestRoute(dwDestAddr, 0, &ipRow);
919  if (ret == ERROR_SUCCESS)
920  *pdwBestIfIndex = ipRow.dwForwardIfIndex;
921  }
922  TRACE("returning %ld\n", ret);
923  return ret;
924 }
925 
926 
927 /******************************************************************
928  * GetBestRoute (IPHLPAPI.@)
929  *
930  *
931  * PARAMS
932  *
933  * dwDestAddr [In]
934  * dwSourceAddr [In]
935  * OUT [In]
936  *
937  * RETURNS
938  *
939  * DWORD
940  *
941  */
942 DWORD WINAPI GetBestRoute(DWORD dwDestAddr, DWORD dwSourceAddr, PMIB_IPFORWARDROW pBestRoute)
943 {
945  DWORD ret;
946 
947  TRACE("dwDestAddr 0x%08lx, dwSourceAddr 0x%08lx, pBestRoute %p\n", dwDestAddr,
948  dwSourceAddr, pBestRoute);
949  if (!pBestRoute)
951 
953  if (table) {
954  DWORD ndx, minMaskSize, matchedNdx = 0;
955 
956  for (ndx = 0, minMaskSize = 255; ndx < table->dwNumEntries; ndx++) {
957  if ((dwDestAddr & table->table[ndx].dwForwardMask) ==
958  (table->table[ndx].dwForwardDest & table->table[ndx].dwForwardMask)) {
959  DWORD hostMaskSize;
960 
961  if (!_BitScanForward(&hostMaskSize, ntohl(table->table[ndx].dwForwardMask)))
962  {
963  hostMaskSize = 32;
964  }
965  if (hostMaskSize < minMaskSize) {
966  minMaskSize = hostMaskSize;
967  matchedNdx = ndx;
968  }
969  }
970  }
971  memcpy(pBestRoute, &table->table[matchedNdx], sizeof(MIB_IPFORWARDROW));
973  ret = ERROR_SUCCESS;
974  }
975  else
977  TRACE("returning %ld\n", ret);
978  return ret;
979 }
980 
981 static int TcpTableSorter(const void *a, const void *b)
982 {
983  int ret;
984 
985  if (a && b) {
986  PMIB_TCPROW rowA = (PMIB_TCPROW)a, rowB = (PMIB_TCPROW)b;
987 
988  ret = rowA->dwLocalAddr - rowB->dwLocalAddr;
989  if (ret == 0) {
990  ret = rowA->dwLocalPort - rowB->dwLocalPort;
991  if (ret == 0) {
992  ret = rowA->dwRemoteAddr - rowB->dwRemoteAddr;
993  if (ret == 0)
994  ret = rowA->dwRemotePort - rowB->dwRemotePort;
995  }
996  }
997  }
998  else
999  ret = 0;
1000  return ret;
1001 }
1002 
1003 /******************************************************************
1004  * GetExtendedTcpTable (IPHLPAPI.@)
1005  *
1006  * Get the table of TCP endpoints available to the application.
1007  *
1008  * PARAMS
1009  * pTcpTable [Out] table struct with the filtered TCP endpoints available to application
1010  * pdwSize [In/Out] estimated size of the structure returned in pTcpTable, in bytes
1011  * bOrder [In] whether to order the table
1012  * ulAf [in] version of IP used by the TCP endpoints
1013  * TableClass [in] type of the TCP table structure from TCP_TABLE_CLASS
1014  * Reserved [in] reserved - this value must be zero
1015  *
1016  * RETURNS
1017  * Success: NO_ERROR
1018  * Failure: either ERROR_INSUFFICIENT_BUFFER or ERROR_INVALID_PARAMETER
1019  *
1020  * NOTES
1021  */
1022 
1023 DWORD WINAPI GetExtendedTcpTable(PVOID pTcpTable, PDWORD pdwSize, BOOL bOrder, ULONG ulAf, TCP_TABLE_CLASS TableClass, ULONG Reserved)
1024 {
1025  DWORD i, count, size;
1026  DWORD ret = NO_ERROR;
1027 
1028  if (!pdwSize)
1029  {
1030  return ERROR_INVALID_PARAMETER;
1031  }
1032 
1033  if (ulAf != AF_INET)
1034  {
1035  UNIMPLEMENTED;
1036  return ERROR_INVALID_PARAMETER;
1037  }
1038 
1039  switch (TableClass)
1040  {
1041  case TCP_TABLE_BASIC_ALL:
1042  {
1043  PMIB_TCPTABLE pOurTcpTable = getTcpTable(ClassBasic);
1044  PMIB_TCPTABLE pTheirTcpTable = pTcpTable;
1045 
1046  if (pOurTcpTable)
1047  {
1048  size = FIELD_OFFSET(MIB_TCPTABLE, table) + pOurTcpTable->dwNumEntries * sizeof(MIB_TCPROW);
1049  if (size > *pdwSize || !pTheirTcpTable)
1050  {
1051  *pdwSize = size;
1053  }
1054  else
1055  {
1056  memcpy(pTheirTcpTable, pOurTcpTable, size);
1057 
1058  if (bOrder)
1059  qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
1060  sizeof(MIB_TCPROW), TcpTableSorter);
1061  }
1062 
1063  free(pOurTcpTable);
1064  }
1065  }
1066  break;
1067 
1069  {
1070  PMIB_TCPTABLE pOurTcpTable = getTcpTable(ClassBasic);
1071  PMIB_TCPTABLE pTheirTcpTable = pTcpTable;
1072 
1073  if (pOurTcpTable)
1074  {
1075  for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1076  {
1077  if (pOurTcpTable->table[i].State != MIB_TCP_STATE_LISTEN)
1078  {
1079  ++count;
1080  }
1081  }
1082 
1084  if (size > *pdwSize || !pTheirTcpTable)
1085  {
1086  *pdwSize = size;
1088  }
1089  else
1090  {
1091  pTheirTcpTable->dwNumEntries = count;
1092 
1093  for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1094  {
1095  if (pOurTcpTable->table[i].State != MIB_TCP_STATE_LISTEN)
1096  {
1097  memcpy(&pTheirTcpTable->table[count], &pOurTcpTable->table[i], sizeof(MIB_TCPROW));
1098  ++count;
1099  }
1100  }
1101  ASSERT(count == pTheirTcpTable->dwNumEntries);
1102 
1103  if (bOrder)
1104  qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
1105  sizeof(MIB_TCPROW), TcpTableSorter);
1106  }
1107 
1108  free(pOurTcpTable);
1109  }
1110  }
1111  break;
1112 
1114  {
1115  PMIB_TCPTABLE pOurTcpTable = getTcpTable(ClassBasic);
1116  PMIB_TCPTABLE pTheirTcpTable = pTcpTable;
1117 
1118  if (pOurTcpTable)
1119  {
1120  for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1121  {
1122  if (pOurTcpTable->table[i].State == MIB_TCP_STATE_LISTEN)
1123  {
1124  ++count;
1125  }
1126  }
1127 
1129  if (size > *pdwSize || !pTheirTcpTable)
1130  {
1131  *pdwSize = size;
1133  }
1134  else
1135  {
1136  pTheirTcpTable->dwNumEntries = count;
1137 
1138  for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1139  {
1140  if (pOurTcpTable->table[i].State == MIB_TCP_STATE_LISTEN)
1141  {
1142  memcpy(&pTheirTcpTable->table[count], &pOurTcpTable->table[i], sizeof(MIB_TCPROW));
1143  ++count;
1144  }
1145  }
1146  ASSERT(count == pTheirTcpTable->dwNumEntries);
1147 
1148  if (bOrder)
1149  qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
1150  sizeof(MIB_TCPROW), TcpTableSorter);
1151  }
1152 
1153  free(pOurTcpTable);
1154  }
1155  }
1156  break;
1157 
1159  {
1161  PMIB_TCPTABLE_OWNER_PID pTheirTcpTable = pTcpTable;
1162 
1163  if (pOurTcpTable)
1164  {
1166  if (size > *pdwSize || !pTheirTcpTable)
1167  {
1168  *pdwSize = size;
1170  }
1171  else
1172  {
1173  memcpy(pTheirTcpTable, pOurTcpTable, size);
1174 
1175  /* Don't sort on PID, so use basic helper */
1176  if (bOrder)
1177  qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
1179  }
1180 
1181  free(pOurTcpTable);
1182  }
1183  }
1184  break;
1185 
1187  {
1189  PMIB_TCPTABLE_OWNER_PID pTheirTcpTable = pTcpTable;
1190 
1191  if (pOurTcpTable)
1192  {
1193  for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1194  {
1195  if (pOurTcpTable->table[i].dwState != MIB_TCP_STATE_LISTEN)
1196  {
1197  ++count;
1198  }
1199  }
1200 
1202  if (size > *pdwSize || !pTheirTcpTable)
1203  {
1204  *pdwSize = size;
1206  }
1207  else
1208  {
1209  pTheirTcpTable->dwNumEntries = count;
1210 
1211  for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1212  {
1213  if (pOurTcpTable->table[i].dwState != MIB_TCP_STATE_LISTEN)
1214  {
1215  memcpy(&pTheirTcpTable->table[count], &pOurTcpTable->table[i], sizeof(MIB_TCPROW_OWNER_PID));
1216  ++count;
1217  }
1218  }
1219  ASSERT(count == pTheirTcpTable->dwNumEntries);
1220 
1221  /* Don't sort on PID, so use basic helper */
1222  if (bOrder)
1223  qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
1225  }
1226 
1227  free(pOurTcpTable);
1228  }
1229  }
1230  break;
1231 
1233  {
1235  PMIB_TCPTABLE_OWNER_PID pTheirTcpTable = pTcpTable;
1236 
1237  if (pOurTcpTable)
1238  {
1239  for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1240  {
1241  if (pOurTcpTable->table[i].dwState == MIB_TCP_STATE_LISTEN)
1242  {
1243  ++count;
1244  }
1245  }
1246 
1248  if (size > *pdwSize || !pTheirTcpTable)
1249  {
1250  *pdwSize = size;
1252  }
1253  else
1254  {
1255  pTheirTcpTable->dwNumEntries = count;
1256 
1257  for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1258  {
1259  if (pOurTcpTable->table[i].dwState == MIB_TCP_STATE_LISTEN)
1260  {
1261  memcpy(&pTheirTcpTable->table[count], &pOurTcpTable->table[i], sizeof(MIB_TCPROW_OWNER_PID));
1262  ++count;
1263  }
1264  }
1265  ASSERT(count == pTheirTcpTable->dwNumEntries);
1266 
1267  /* Don't sort on PID, so use basic helper */
1268  if (bOrder)
1269  qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
1271  }
1272 
1273  free(pOurTcpTable);
1274  }
1275  }
1276  break;
1277 
1279  {
1281  PMIB_TCPTABLE_OWNER_MODULE pTheirTcpTable = pTcpTable;
1282 
1283  if (pOurTcpTable)
1284  {
1286  if (size > *pdwSize || !pTheirTcpTable)
1287  {
1288  *pdwSize = size;
1290  }
1291  else
1292  {
1293  memcpy(pTheirTcpTable, pOurTcpTable, size);
1294 
1295  /* Don't sort on PID, so use basic helper */
1296  if (bOrder)
1297  qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
1299  }
1300 
1301  free(pOurTcpTable);
1302  }
1303  }
1304  break;
1305 
1307  {
1309  PMIB_TCPTABLE_OWNER_MODULE pTheirTcpTable = pTcpTable;
1310 
1311  if (pOurTcpTable)
1312  {
1313  for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1314  {
1315  if (pOurTcpTable->table[i].dwState != MIB_TCP_STATE_LISTEN)
1316  {
1317  ++count;
1318  }
1319  }
1320 
1322  if (size > *pdwSize || !pTheirTcpTable)
1323  {
1324  *pdwSize = size;
1326  }
1327  else
1328  {
1329  pTheirTcpTable->dwNumEntries = count;
1330 
1331  for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1332  {
1333  if (pOurTcpTable->table[i].dwState != MIB_TCP_STATE_LISTEN)
1334  {
1335  memcpy(&pTheirTcpTable->table[count], &pOurTcpTable->table[i], sizeof(MIB_TCPROW_OWNER_MODULE));
1336  ++count;
1337  }
1338  }
1339  ASSERT(count == pTheirTcpTable->dwNumEntries);
1340 
1341  /* Don't sort on PID, so use basic helper */
1342  if (bOrder)
1343  qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
1345  }
1346 
1347  free(pOurTcpTable);
1348  }
1349  }
1350  break;
1351 
1353  {
1355  PMIB_TCPTABLE_OWNER_MODULE pTheirTcpTable = pTcpTable;
1356 
1357  if (pOurTcpTable)
1358  {
1359  for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1360  {
1361  if (pOurTcpTable->table[i].dwState == MIB_TCP_STATE_LISTEN)
1362  {
1363  ++count;
1364  }
1365  }
1366 
1368  if (size > *pdwSize || !pTheirTcpTable)
1369  {
1370  *pdwSize = size;
1372  }
1373  else
1374  {
1375  pTheirTcpTable->dwNumEntries = count;
1376 
1377  for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1378  {
1379  if (pOurTcpTable->table[i].dwState == MIB_TCP_STATE_LISTEN)
1380  {
1381  memcpy(&pTheirTcpTable->table[count], &pOurTcpTable->table[i], sizeof(MIB_TCPROW_OWNER_MODULE));
1382  ++count;
1383  }
1384  }
1385  ASSERT(count == pTheirTcpTable->dwNumEntries);
1386 
1387  /* Don't sort on PID, so use basic helper */
1388  if (bOrder)
1389  qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
1391  }
1392 
1393  free(pOurTcpTable);
1394  }
1395  }
1396  break;
1397 
1398  default:
1400  break;
1401  }
1402 
1403  return ret;
1404 }
1405 
1406 
1407 static int UdpTableSorter(const void *a, const void *b)
1408 {
1409  int ret;
1410 
1411  if (a && b) {
1412  PMIB_UDPROW rowA = (PMIB_UDPROW)a, rowB = (PMIB_UDPROW)b;
1413 
1414  ret = rowA->dwLocalAddr - rowB->dwLocalAddr;
1415  if (ret == 0)
1416  ret = rowA->dwLocalPort - rowB->dwLocalPort;
1417  }
1418  else
1419  ret = 0;
1420  return ret;
1421 }
1422 
1423 /******************************************************************
1424  * GetExtendedUdpTable (IPHLPAPI.@)
1425  *
1426  * Get the table of UDP endpoints available to the application.
1427  *
1428  * PARAMS
1429  * pUdpTable [Out] table struct with the filtered UDP endpoints available to application
1430  * pdwSize [In/Out] estimated size of the structure returned in pUdpTable, in bytes
1431  * bOrder [In] whether to order the table
1432  * ulAf [in] version of IP used by the UDP endpoints
1433  * TableClass [in] type of the UDP table structure from UDP_TABLE_CLASS
1434  * Reserved [in] reserved - this value must be zero
1435  *
1436  * RETURNS
1437  * Success: NO_ERROR
1438  * Failure: either ERROR_INSUFFICIENT_BUFFER or ERROR_INVALID_PARAMETER
1439  *
1440  * NOTES
1441  */
1442 
1443 DWORD WINAPI GetExtendedUdpTable(PVOID pUdpTable, PDWORD pdwSize, BOOL bOrder, ULONG ulAf, UDP_TABLE_CLASS TableClass, ULONG Reserved)
1444 {
1445  DWORD size;
1446  DWORD ret = NO_ERROR;
1447 
1448  if (!pdwSize)
1449  {
1450  return ERROR_INVALID_PARAMETER;
1451  }
1452 
1453  if (ulAf != AF_INET)
1454  {
1455  UNIMPLEMENTED;
1456  return ERROR_INVALID_PARAMETER;
1457  }
1458 
1459  switch (TableClass)
1460  {
1461  case UDP_TABLE_BASIC:
1462  {
1463  PMIB_UDPTABLE pOurUdpTable = getUdpTable(ClassBasic);
1464  PMIB_UDPTABLE pTheirUdpTable = pUdpTable;
1465 
1466  if (pOurUdpTable)
1467  {
1468  size = FIELD_OFFSET(MIB_UDPTABLE, table) + pOurUdpTable->dwNumEntries * sizeof(MIB_UDPROW);
1469  if (size > *pdwSize || !pTheirUdpTable)
1470  {
1471  *pdwSize = size;
1473  }
1474  else
1475  {
1476  memcpy(pTheirUdpTable, pOurUdpTable, size);
1477 
1478  if (bOrder)
1479  qsort(pTheirUdpTable->table, pTheirUdpTable->dwNumEntries,
1480  sizeof(MIB_UDPROW), UdpTableSorter);
1481  }
1482 
1483  free(pOurUdpTable);
1484  }
1485  }
1486  break;
1487 
1488  case UDP_TABLE_OWNER_PID:
1489  {
1491  PMIB_UDPTABLE_OWNER_PID pTheirUdpTable = pUdpTable;
1492 
1493  if (pOurUdpTable)
1494  {
1496  if (size > *pdwSize || !pTheirUdpTable)
1497  {
1498  *pdwSize = size;
1500  }
1501  else
1502  {
1503  memcpy(pTheirUdpTable, pOurUdpTable, size);
1504 
1505  if (bOrder)
1506  qsort(pTheirUdpTable->table, pTheirUdpTable->dwNumEntries,
1508  }
1509 
1510  free(pOurUdpTable);
1511  }
1512  }
1513  break;
1514 
1516  {
1518  PMIB_UDPTABLE_OWNER_MODULE pTheirUdpTable = pUdpTable;
1519 
1520  if (pOurUdpTable)
1521  {
1523  if (size > *pdwSize || !pTheirUdpTable)
1524  {
1525  *pdwSize = size;
1527  }
1528  else
1529  {
1530  memcpy(pTheirUdpTable, pOurUdpTable, size);
1531 
1532  if (bOrder)
1533  qsort(pTheirUdpTable->table, pTheirUdpTable->dwNumEntries,
1535  }
1536 
1537  free(pOurUdpTable);
1538  }
1539  }
1540  break;
1541 
1542  default:
1544  break;
1545  }
1546 
1547  return ret;
1548 }
1549 
1550 
1551 /******************************************************************
1552  * GetFriendlyIfIndex (IPHLPAPI.@)
1553  *
1554  *
1555  * PARAMS
1556  *
1557  * IfIndex [In]
1558  *
1559  * RETURNS
1560  *
1561  * DWORD
1562  *
1563  */
1565 {
1566  /* windows doesn't validate these, either, just makes sure the top byte is
1567  cleared. I assume my ifenum module never gives an index with the top
1568  byte set. */
1569  TRACE("returning %ld\n", IfIndex);
1570  return IfIndex;
1571 }
1572 
1573 
1574 /******************************************************************
1575  * GetIcmpStatistics (IPHLPAPI.@)
1576  *
1577  *
1578  * PARAMS
1579  *
1580  * pStats [In/Out]
1581  *
1582  * RETURNS
1583  *
1584  * DWORD
1585  *
1586  */
1588 {
1589  DWORD ret;
1590 
1591  TRACE("pStats %p\n", pStats);
1592  ret = getICMPStats(pStats);
1593  TRACE("returning %ld\n", ret);
1594  return ret;
1595 }
1596 
1597 
1598 /******************************************************************
1599  * GetIfEntry (IPHLPAPI.@)
1600  *
1601  *
1602  * PARAMS
1603  *
1604  * pIfRow [In/Out]
1605  *
1606  * RETURNS
1607  *
1608  * DWORD
1609  *
1610  */
1612 {
1613  DWORD ret;
1614  const char *name;
1615 
1616  TRACE("pIfRow %p\n", pIfRow);
1617  if (!pIfRow)
1618  return ERROR_INVALID_PARAMETER;
1619 
1621  if (name) {
1622  ret = getInterfaceEntryByIndex(pIfRow->dwIndex, pIfRow);
1623  if (ret == NO_ERROR)
1624  ret = getInterfaceStatsByName(name, pIfRow);
1626  }
1627  else
1629  TRACE("returning %ld\n", ret);
1630  return ret;
1631 }
1632 
1633 
1634 static int IfTableSorter(const void *a, const void *b)
1635 {
1636  int ret;
1637 
1638  if (a && b)
1639  ret = ((PMIB_IFROW)a)->dwIndex - ((PMIB_IFROW)b)->dwIndex;
1640  else
1641  ret = 0;
1642  return ret;
1643 }
1644 
1645 
1646 /******************************************************************
1647  * GetIfTable (IPHLPAPI.@)
1648  *
1649  *
1650  * PARAMS
1651  *
1652  * pIfTable [In/Out]
1653  * pdwSize [In/Out]
1654  * bOrder [In]
1655  *
1656  * RETURNS
1657  *
1658  * DWORD
1659  *
1660  */
1661 DWORD WINAPI GetIfTable(PMIB_IFTABLE pIfTable, PULONG pdwSize, BOOL bOrder)
1662 {
1663  DWORD ret;
1664 
1665  TRACE("pIfTable %p, pdwSize %p, bOrder %ld\n", pdwSize, pdwSize,
1666  (DWORD)bOrder);
1667  if (!pdwSize)
1669  else {
1670  DWORD numInterfaces = getNumInterfaces();
1671  ULONG size;
1672  TRACE("GetIfTable: numInterfaces = %d\n", (int)numInterfaces);
1673  size = sizeof(MIB_IFTABLE) + (numInterfaces - 1) * sizeof(MIB_IFROW);
1674 
1675  if (!pIfTable || *pdwSize < size) {
1676  *pdwSize = size;
1678  }
1679  else {
1681 
1682  if (table) {
1683  size = sizeof(MIB_IFTABLE) + (table->numIndexes - 1) *
1684  sizeof(MIB_IFROW);
1685  if (*pdwSize < size) {
1686  *pdwSize = size;
1688  }
1689  else {
1690  DWORD ndx;
1691 
1692  pIfTable->dwNumEntries = 0;
1693  for (ndx = 0; ndx < table->numIndexes; ndx++) {
1694  pIfTable->table[ndx].dwIndex = table->indexes[ndx];
1695  GetIfEntry(&pIfTable->table[ndx]);
1696  pIfTable->dwNumEntries++;
1697  }
1698  if (bOrder)
1699  qsort(pIfTable->table, pIfTable->dwNumEntries, sizeof(MIB_IFROW),
1700  IfTableSorter);
1701  ret = NO_ERROR;
1702  }
1703  free(table);
1704  }
1705  else
1707  }
1708  }
1709  TRACE("returning %ld\n", ret);
1710  return ret;
1711 }
1712 
1713 
1714 /******************************************************************
1715  * GetInterfaceInfo (IPHLPAPI.@)
1716  *
1717  *
1718  * PARAMS
1719  *
1720  * pIfTable [In/Out]
1721  * dwOutBufLen [In/Out]
1722  *
1723  * RETURNS
1724  *
1725  * DWORD
1726  *
1727  */
1729 {
1730  DWORD ret;
1731 
1732  TRACE("pIfTable %p, dwOutBufLen %p\n", pIfTable, dwOutBufLen);
1733  if (!dwOutBufLen)
1735  else {
1736  DWORD numNonLoopbackInterfaces = getNumNonLoopbackInterfaces();
1737  ULONG size;
1738  TRACE("numNonLoopbackInterfaces == 0x%x\n", numNonLoopbackInterfaces);
1739  size = sizeof(IP_INTERFACE_INFO) + (numNonLoopbackInterfaces) *
1740  sizeof(IP_ADAPTER_INDEX_MAP);
1741 
1742  if (!pIfTable || *dwOutBufLen < size) {
1743  *dwOutBufLen = size;
1745  }
1746  else {
1748 
1749  if (table) {
1750  TRACE("table->numIndexes == 0x%x\n", table->numIndexes);
1751  size = sizeof(IP_INTERFACE_INFO) + (table->numIndexes) *
1752  sizeof(IP_ADAPTER_INDEX_MAP);
1753  if (*dwOutBufLen < size) {
1754  *dwOutBufLen = size;
1756  }
1757  else {
1758  DWORD ndx;
1759 
1760  pIfTable->NumAdapters = 0;
1761  for (ndx = 0; ndx < table->numIndexes; ndx++) {
1762  const char *walker, *name;
1763  WCHAR *assigner;
1764 
1765  pIfTable->Adapter[ndx].Index = table->indexes[ndx];
1766  name = getInterfaceNameByIndex(table->indexes[ndx]);
1767  for (walker = name, assigner = pIfTable->Adapter[ndx].Name;
1768  walker && *walker &&
1769  assigner - pIfTable->Adapter[ndx].Name < MAX_ADAPTER_NAME - 1;
1770  walker++, assigner++)
1771  *assigner = *walker;
1772  *assigner = 0;
1774  pIfTable->NumAdapters++;
1775  }
1776  ret = NO_ERROR;
1777  }
1778  free(table);
1779  }
1780  else
1782  }
1783  }
1784  TRACE("returning %ld\n", ret);
1785  return ret;
1786 }
1787 
1788 
1789 static 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  */
1816 DWORD 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)
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;
1832  }
1833  else {
1835 
1836  if (table) {
1837  size = sizeof(MIB_IPADDRTABLE) + (table->numIndexes - 1) *
1838  sizeof(MIB_IPADDRROW);
1839  if (*pdwSize < size) {
1840  *pdwSize = size;
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
1875  }
1876  }
1877  TRACE("returning %ld\n", ret);
1878  return ret;
1879 }
1880 
1881 
1882 static int IpForwardTableSorter(const void *a, const void *b)
1883 {
1884  int ret;
1885 
1886  if (a && 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  */
1921 {
1922  DWORD ret;
1923 
1924  TRACE("pIpForwardTable %p, pdwSize %p, bOrder %ld\n", pIpForwardTable,
1925  pdwSize, (DWORD)bOrder);
1926  if (!pdwSize)
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;
1936  }
1937  else {
1939  if (table) {
1940  sizeNeeded = sizeof(MIB_IPFORWARDTABLE) + (table->numRoutes - 1) *
1941  sizeof(MIB_IPFORWARDROW);
1942  if (*pdwSize < sizeNeeded) {
1943  *pdwSize = sizeNeeded;
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,
1980  ret = NO_ERROR;
1981  }
1982  HeapFree(GetProcessHeap(), 0, table);
1983  }
1984  else
1986  }
1987  }
1988  TRACE("returning %ld\n", ret);
1989  return ret;
1990 }
1991 
1992 
1993 static 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  */
2020 DWORD 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)
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;
2037  }
2038  else {
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;
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  */
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  */
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  */
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  */
2274 {
2275  DWORD ret;
2276 
2277  TRACE("pdwNumIf %p\n", pdwNumIf);
2278  if (!pdwNumIf)
2280  else {
2281  *pdwNumIf = getNumInterfaces();
2282  ret = NO_ERROR;
2283  }
2284  TRACE("returning %ld\n", ret);
2285  return ret;
2286 }
2287 
2288 
2290 {
2291  HANDLE Process;
2292  DWORD FileLen, PathLen, Error;
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 
2308  if (Process == NULL)
2309  {
2310  return GetLastError();
2311  }
2312 
2314  if (FileLen != 0)
2315  {
2317  if (PathLen == 0)
2318  {
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  {
2344  return Error;
2345  }
2346  }
2347 
2349 
2350  if (*pdwSize < sizeof(TCPIP_OWNER_MODULE_BASIC_INFO) + PathLen + FileLen)
2351  {
2352  *pdwSize = sizeof(TCPIP_OWNER_MODULE_BASIC_INFO) + PathLen + FileLen;
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 
2367 {
2368  UINT Size;
2369  HRESULT Res;
2370  HANDLE hAdvapi32;
2371  WCHAR SysDir[MAX_PATH];
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);
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  */
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  */
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 
2515 {
2516  IP_ADDR_STRING *pNext;
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  */
2559 DWORD WINAPI GetPerAdapterInfo(ULONG IfIndex, PIP_PER_ADAPTER_INFO pPerAdapterInfo, PULONG pOutBufLen)
2560 {
2561  HKEY hkey;
2562  DWORD dwSize = 0;
2563  const char *ifName;
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 
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  */
2634 BOOL 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  */
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  */
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  */
2708 DWORD 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  */
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  */
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  */
2772 DWORD 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  */
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  */
2818 {
2819  DWORD Status, Version = 0;
2820 
2821  if (!AdapterInfo)
2822  return ERROR_INVALID_PARAMETER;
2823 
2824  /* Maybe we should do this in DllMain */
2826  return ERROR_PROC_NOT_FOUND;
2827 
2828  if (DhcpReleaseIpAddressLease(AdapterInfo->Index))
2830  else
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  */
2852 {
2853  DWORD Status, Version = 0;
2854 
2855  if (!AdapterInfo)
2856  return ERROR_INVALID_PARAMETER;
2857 
2858  /* Maybe we should do this in DllMain */
2860  return ERROR_PROC_NOT_FOUND;
2861 
2862  if (DhcpRenewIpAddressLease(AdapterInfo->Index))
2864  else
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  */
2890 {
2891  FIXME("(Handle %p, overlapped %p): stub\n", Handle, overlapped);
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  */
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  */
2935 DWORD 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  */
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  */
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  */
3008 {
3009  HANDLE tcpFile;
3010  NTSTATUS status;
3013  TDIEntityID id;
3014  DWORD returnSize;
3015  PMIB_IPNETROW arpBuff;
3016 
3017  if (!pArpEntry)
3018  return ERROR_INVALID_PARAMETER;
3019 
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 
3032  req.Req.ID.toi_entity.tei_instance = id.tei_instance;
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,
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  */
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  */
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  */
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  */
3140 DWORD 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  */
3151 {
3152  FIXME(":stub\n");
3153  return 0L;
3154 }
3155 
3156 
3157 /*
3158  * @unimplemented
3159  */
3161 {
3162  FIXME(":stub\n");
3163  return 0L;
3164 }
3165 
3166 /*
3167  * @implemented
3168  */
3169 #ifdef GetAdaptersAddressesV1
3170 DWORD 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  return ERROR_NO_DATA;
3190 
3191  for (i = indexTable->numIndexes; i >= 0; i--)
3192  {
3193  if (NT_SUCCESS(getIPAddrEntryForIf(tcpFile,
3194  NULL,
3195  indexTable->indexes[i],
3196  &ifInfo)))
3197  {
3198  /* The whole struct */
3199  requiredSize += sizeof(IP_ADAPTER_ADDRESSES);
3200 
3201  /* Friendly name */
3203  requiredSize += strlen((char *)ifInfo.if_info.ent.if_descr) + 1; //FIXME
3204 
3205  /* Adapter name */
3206  requiredSize += strlen((char *)ifInfo.if_info.ent.if_descr) + 1;
3207 
3208  /* Unicast address */
3209  if (!(Flags & GAA_FLAG_SKIP_UNICAST))
3210  requiredSize += sizeof(IP_ADAPTER_UNICAST_ADDRESS);
3211 
3212  /* FIXME: Implement multicast, anycast, and dns server stuff */
3213 
3214  /* FIXME: Implement dns suffix and description */
3215  requiredSize += 2 * sizeof(WCHAR);
3216 
3217  /* We're only going to implement what's required for XP SP0 */
3218  }
3219  }
3220  TRACE("size: %d, requiredSize: %d\n", *pOutBufLen, requiredSize);
3221  if (!pAdapterAddresses || *pOutBufLen < requiredSize)
3222  {
3223  *pOutBufLen = requiredSize;
3224  closeTcpFile(tcpFile);
3225  free(indexTable);
3226  return ERROR_BUFFER_OVERFLOW;
3227  }
3228 
3229  RtlZeroMemory(pAdapterAddresses, requiredSize);
3230 
3231  /* Let's set up the pointers */
3232  currentAddress = pAdapterAddresses;
3233  for (i = indexTable->numIndexes; i >= 0; i--)
3234  {
3235  if (NT_SUCCESS(getIPAddrEntryForIf(tcpFile,
3236  NULL,
3237  indexTable->indexes[i],
3238  &ifInfo)))
3239  {
3240  currentLocation = (PUCHAR)currentAddress + (ULONG_PTR)sizeof(IP_ADAPTER_ADDRESSES);
3241 
3242  /* FIXME: Friendly name */
3244  {
3245  currentAddress->FriendlyName = (PVOID)currentLocation;
3246  currentLocation += sizeof(WCHAR);
3247  }
3248 
3249  /* Adapter name */
3250  currentAddress->AdapterName = (PVOID)currentLocation;
3251  currentLocation += strlen((char *)ifInfo.if_info.ent.if_descr) + 1;
3252 
3253  /* Unicast address */
3254  if (!(Flags & GAA_FLAG_SKIP_UNICAST))
3255  {
3256  currentAddress->FirstUnicastAddress = (PVOID)currentLocation;
3257  currentLocation += sizeof(IP_ADAPTER_UNICAST_ADDRESS);
3258  currentAddress->FirstUnicastAddress->Address.lpSockaddr = (PVOID)currentLocation;
3259  currentLocation += sizeof(struct sockaddr);
3260  }
3261 
3262  /* FIXME: Implement multicast, anycast, and dns server stuff */
3263 
3264  /* FIXME: Implement dns suffix and description */
3265  currentAddress->DnsSuffix = (PVOID)currentLocation;
3266  currentLocation += sizeof(WCHAR);
3267 
3268  currentAddress->Description = (PVOID)currentLocation;
3269  currentLocation += sizeof(WCHAR);
3270 
3271  currentAddress->Next = (PVOID)currentLocation;
3272  /* Terminate the last address correctly */
3273  if(i==0)
3274  currentAddress->Next = NULL;
3275 
3276  /* We're only going to implement what's required for XP SP0 */
3277 
3278  currentAddress = currentAddress->Next;
3279  }
3280  }
3281 
3282  /* Now again, for real this time */
3283 
3284  currentAddress = pAdapterAddresses;
3285  for (i = indexTable->numIndexes; i >= 0; i--)
3286  {
3287  if (NT_SUCCESS(getIPAddrEntryForIf(tcpFile,
3288  NULL,
3289  indexTable->indexes[i],
3290  &ifInfo)))
3291  {
3292  /* Make sure we're not looping more than we hoped for */
3293  ASSERT(currentAddress);
3294 
3295  /* Alignment information */
3296  currentAddress->Length = sizeof(IP_ADAPTER_ADDRESSES);
3297  currentAddress->IfIndex = indexTable->indexes[i];
3298 
3299  /* Adapter name */
3300  strcpy(currentAddress->AdapterName, (char *)ifInfo.if_info.ent.if_descr);
3301 
3302  if (!(Flags & GAA_FLAG_SKIP_UNICAST))
3303  {
3304  currentAddress->FirstUnicastAddress->Length = sizeof(IP_ADAPTER_UNICAST_ADDRESS);
3305  currentAddress->FirstUnicastAddress->Flags = 0; //FIXME
3306  currentAddress->FirstUnicastAddress->Next = NULL; //FIXME: Support more than one address per adapter
3307  currentAddress->FirstUnicastAddress->Address.lpSockaddr->sa_family = AF_INET;
3308  memcpy(currentAddress->FirstUnicastAddress->Address.lpSockaddr->sa_data,
3309  &ifInfo.ip_addr.iae_addr,
3310  sizeof(ifInfo.ip_addr.iae_addr));
3311  currentAddress->FirstUnicastAddress->Address.iSockaddrLength = sizeof(ifInfo.ip_addr.iae_addr) + sizeof(USHORT);
3312  currentAddress->FirstUnicastAddress->PrefixOrigin = IpPrefixOriginOther; //FIXME
3313  currentAddress->FirstUnicastAddress->SuffixOrigin = IpPrefixOriginOther; //FIXME
3314  currentAddress->FirstUnicastAddress->DadState = IpDadStatePreferred; //FIXME
3315  currentAddress->FirstUnicastAddress->ValidLifetime = 0xFFFFFFFF; //FIXME
3316  currentAddress->FirstUnicastAddress->PreferredLifetime = 0xFFFFFFFF; //FIXME
3317  currentAddress->FirstUnicastAddress->LeaseLifetime = 0xFFFFFFFF; //FIXME
3318  }
3319 
3320  /* FIXME: Implement multicast, anycast, and dns server stuff */
3321  currentAddress->FirstAnycastAddress = NULL;
3322  currentAddress->FirstMulticastAddress = NULL;
3323  currentAddress->FirstDnsServerAddress = NULL;
3324 
3325  /* FIXME: Implement dns suffix, description, and friendly name */
3326  currentAddress->DnsSuffix[0] = UNICODE_NULL;
3327  currentAddress->Description[0] = UNICODE_NULL;
3328  currentAddress->FriendlyName[0] = UNICODE_NULL;
3329 
3330  /* Physical Address */
3331  memcpy(currentAddress->PhysicalAddress, ifInfo.if_info.ent.if_physaddr, ifInfo.if_info.ent.if_physaddrlen);
3332  currentAddress->PhysicalAddressLength = ifInfo.if_info.ent.if_physaddrlen;
3333 
3334  /* Flags */
3335  currentAddress->Flags = 0; //FIXME
3336 
3337  /* MTU */
3338  currentAddress->Mtu = ifInfo.if_info.ent.if_mtu;
3339 
3340  /* Interface type */
3341  currentAddress->IfType = ifInfo.if_info.ent.if_type;
3342 
3343  /* Operational status */
3345  currentAddress->OperStatus = IfOperStatusUp;
3346  else
3347  currentAddress->OperStatus = IfOperStatusDown;
3348 
3349  /* We're only going to implement what's required for XP SP0 */
3350 
3351  /* Move to the next address */
3352  currentAddress = currentAddress->Next;
3353  }
3354  }
3355 
3356  closeTcpFile(tcpFile);
3357  free(indexTable);
3358 
3359  return NO_ERROR;
3360 }
3361 #endif
3362 
3363 /*
3364  * @unimplemented
3365  */
3367 {
3368  FIXME(":stub\n");
3369  return 0L;
3370 }
3371 
3372 /*
3373  * @unimplemented
3374  */
3375 DWORD WINAPI GetBestInterfaceEx(struct sockaddr *pDestAddr,PDWORD pdwBestIfIndex)
3376 {
3377  FIXME(":stub\n");
3378  return 0L;
3379 }
3380 
3381 /*
3382  * @unimplemented
3383  */
3385 {
3386  FIXME(":stub\n");
3387  return 0L;
3388 }
3389 
3390 /*
3391  * @unimplemented
3392  */
3394 {
3395  FIXME(":stub\n");
3396 
3397  if (!pStats)
3398  return ERROR_INVALID_PARAMETER;
3399 
3400  if (dwFamily != AF_INET && dwFamily != AF_INET6)
3401  return ERROR_INVALID_PARAMETER;
3402 
3403  return 0L;
3404 }
3405 
3406 DWORD WINAPI
3408 {
3409  FIXME("SetIpForwardEntryToStack() stub\n");
3410  return 0L;
3411 }
3412 
3413 DWORD GetInterfaceNameInternal(_In_ const GUID * pInterfaceGUID,
3414  _Out_writes_bytes_to_(*pOutBufLen, *pOutBufLen) PWCHAR pInterfaceName,
3415  _Inout_ PULONG pOutBufLen)
3416 {
3418  DWORD result, type;
3419  WCHAR szKeyName[2*MAX_PATH];
3420  HRESULT hr;
3421  HKEY hKey;
3422 
3423  if (pInterfaceGUID == NULL || pOutBufLen == NULL)
3424  return ERROR_INVALID_PARAMETER;
3425 
3426  result = RtlStringFromGUID(pInterfaceGUID, &GuidString);
3427 
3428  if (!NT_SUCCESS(result))
3429  {
3430  // failed to convert guid to string
3431  return RtlNtStatusToDosError(result);
3432  }
3433 
3434  hr = StringCbPrintfW(szKeyName, sizeof(szKeyName), L"SYSTEM\\CurrentControlSet\\Control\\Network\\{4D36E972-E325-11CE-BFC1-08002BE10318}\\%s\\Connection", GuidString.Buffer);
3436 
3437  if (FAILED(hr))
3438  {
3439  // key name is too long
3440  return ERROR_BUFFER_OVERFLOW;
3441  }
3442 
3443  result = RegOpenKeyExW(HKEY_LOCAL_MACHINE, szKeyName, 0, KEY_READ, &hKey);
3444 
3445  if (result != ERROR_SUCCESS)
3446  {
3447  // failed to find adapter entry
3448  return ERROR_NOT_FOUND;
3449  }
3450 
3451  result = RegQueryValueExW(hKey, L"Name", NULL, &type, (PVOID)pInterfaceName, pOutBufLen);
3452 
3453  RegCloseKey(hKey);
3454 
3455  if (result == ERROR_MORE_DATA)
3456  {
3457  *pOutBufLen = MAX_INTERFACE_NAME_LEN * 2;
3459  }
3460 
3461  if (result != ERROR_SUCCESS || type != REG_SZ)
3462  {
3463  // failed to read adapter name
3464  return ERROR_NO_DATA;
3465  }
3466  return ERROR_SUCCESS;
3467 }
3468 
3469 /*
3470  * @implemented
3471  */
3472 DWORD WINAPI
3474  _Out_writes_bytes_to_(*pOutBufLen, *pOutBufLen) PWCHAR pInterfaceName,
3475  _Inout_ PULONG pOutBufLen,
3476  DWORD dwUnknown4,
3477  DWORD dwUnknown5)
3478 {
3480 
3481  if (pInterfaceName == NULL)
3482  return ERROR_INVALID_PARAMETER;
3483 
3484  return GetInterfaceNameInternal(pInterfaceGUID, pInterfaceName, pOutBufLen);
3485 }
3486 
3487 /*
3488  * @implemented
3489  */
3490 DWORD WINAPI
3491 NhGetInterfaceNameFromGuid(_In_ const GUID * pInterfaceGUID,
3492  _Out_writes_bytes_to_(*pOutBufLen, *pOutBufLen) PWCHAR pInterfaceName,
3493  _Inout_ PULONG pOutBufLen,
3494  DWORD dwUnknown4,
3495  DWORD dwUnknown5)
3496 {
3497  DWORD result;
3498 
3499  result = GetInterfaceNameInternal(pInterfaceGUID, pInterfaceName, pOutBufLen);
3500 
3501  if (result == ERROR_NOT_FOUND)
3503 
3504  return result;
3505 }
TDIEntityID toi_entity
Definition: tdiinfo.h:74
DWORD WINAPI GetOwnerModuleFromUdpEntry(PMIB_UDPROW_OWNER_MODULE pUdpEntry, TCPIP_OWNER_MODULE_INFO_CLASS Class, PVOID Buffer, PDWORD pdwSize)
DWORD WINAPI IpReleaseAddress(PIP_ADAPTER_INDEX_MAP AdapterInfo)
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
MIB_IFROW table[1]
Definition: ifmib.h:66
DWORD WINAPI AllocateAndGetIpNetTableFromStack(PMIB_IPNETTABLE *ppIpNetTable, BOOL bOrder, HANDLE heap, DWORD flags)
struct _MIB_IPADDRTABLE MIB_IPADDRTABLE
DWORD WINAPI AllocateAndGetUdpTableFromStack(PMIB_UDPTABLE *ppUdpTable, BOOL bOrder, HANDLE heap, DWORD flags)
static PWSTR GuidString
Definition: apphelp.c:91
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:4023
#define AT_ENTITY
Definition: tdiinfo.h:41
DWORD WINAPI GetUdpTable(PMIB_UDPTABLE pUdpTable, PDWORD pdwSize, BOOL bOrder)
struct _MIB_IPNETROW * PMIB_IPNETROW
IP_ADAPTER_INDEX_MAP Adapter[1]
Definition: ipexport.h:141
IN PLARGE_INTEGER IN PLARGE_INTEGER PEPROCESS ProcessId
Definition: fatprocs.h:2697
DWORD riCount
Definition: resinfo.h:25
DWORD WINAPI CreateIpForwardEntry(PMIB_IPFORWARDROW pRoute)
#define TRUE
Definition: types.h:120
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
unsigned char _BitScanForward(unsigned long *_Index, unsigned long _Mask)
Definition: intrin_arm.h:57
#define CloseHandle
Definition: compat.h:398
PIP_ADAPTER_ORDER_MAP WINAPI GetAdapterOrderMap(VOID)
IN PVOID IN PVOID IN USHORT Version
Definition: pci.h:359
DWORD dwForwardMetric4
Definition: ipmib.h:91
struct _MIB_UDPROW MIB_UDPROW
_In_ NDIS_ERROR_CODE ErrorCode
Definition: ndis.h:4436
DWORD dwLocalPort
Definition: tcpmib.h:59
DWORD WINAPI AllocateAndGetIfTableFromStack(PMIB_IFTABLE *ppIfTable, BOOL bOrder, HANDLE heap, DWORD flags)
InterfaceIndexTable * getInterfaceIndexTable(void)
BOOL NTAPI IsBadWritePtr(IN LPVOID lp, IN UINT_PTR ucb)
Definition: except.c:885
#define inet_addr(cp)
Definition: inet.h:98
ULONG toi_class
Definition: tdiinfo.h:75
#define ERROR_SUCCESS
Definition: deptool.c:10
struct _NAME_SERVER_LIST_CONTEXT NAME_SERVER_LIST_CONTEXT
#define _Out_writes_bytes_to_(size, count)
Definition: no_sal2.h:374
DWORD WINAPI AllocateAndGetIpForwardTableFromStack(PMIB_IPFORWARDTABLE *ppIpForwardTable, BOOL bOrder, HANDLE heap, DWORD flags)
#define WideCharToMultiByte
Definition: compat.h:101
DWORD WINAPI DeleteIpForwardEntry(PMIB_IPFORWARDROW pRoute)
HRESULT hr
Definition: shlfolder.c:183
PVOID getTcpTable(CLASS_TABLE Class)
DWORD WINAPI FlushIpNetTable(DWORD dwIfIndex)
DWORD WINAPI CreateProxyArpEntry(DWORD dwAddress, DWORD dwMask, DWORD dwIfIndex)
#define PROCESS_QUERY_INFORMATION
Definition: pstypes.h:158
DWORD WINAPI SetIfEntry(PMIB_IFROW pIfRow)
#define NOERROR
Definition: winerror.h:2354
DWORD WINAPI SetIpForwardEntryToStack(PMIB_IPFORWARDROW pRoute)
struct _MIB_TCPROW_OWNER_MODULE MIB_TCPROW_OWNER_MODULE
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
#define KEY_READ
Definition: nt_native.h:1023
unsigned char Buffer[1]
Definition: tdiinfo.h:97
DWORD dwForwardType
Definition: ipmib.h:78
#define ERROR_BUFFER_OVERFLOW
Definition: winerror.h:185
uint16_t * PWSTR
Definition: typedefs.h:54
VOID disposeResInfo(PIPHLP_RES_INFO InfoPtr)
Definition: resinfo.c:60
#define CP_ACP
Definition: compat.h:99
MIB_TCPROW table[1]
Definition: tcpmib.h:67
GLuint GLuint GLsizei count
Definition: gl.h:1545
static int TcpTableSorter(const void *a, const void *b)
char * strncpy(char *DstString, const char *SrcString, ACPI_SIZE Count)
Definition: utclib.c:427
unsigned char * PUCHAR
Definition: retypes.h:3
DWORD APIENTRY DhcpReleaseIpAddressLease(DWORD AdapterIndex)
Definition: dhcpcsvc.c:137
#define free
Definition: debug_ros.c:5
DWORD WINAPI GetInterfaceInfo(PIP_INTERFACE_INFO pIfTable, PULONG dwOutBufLen)
IP_ADDRESS_STRING IpAddress
Definition: iptypes.h:47
struct _IP_ADDR_STRING * Next
Definition: iptypes.h:46
ULONGLONG OwningModuleInfo[TCPIP_OWNING_MODULE_SIZE]
Definition: udpmib.h:65
#define INADDR_NONE
Definition: tcp.c:42
LONG NTSTATUS
Definition: precomp.h:26
DWORD dwRemoteAddr
Definition: tcpmib.h:60
ULONG if_physaddrlen
Definition: tcpioctl.h:109
RouteTable * getRouteTable(void)
struct _MIB_UDPROW_OWNER_PID MIB_UDPROW_OWNER_PID
DWORD getNumArpEntries(void)
DWORD dwNumEntries
Definition: tcpmib.h:66
NTSTATUS getNthIpEntity(HANDLE tcpFile, DWORD index, TDIEntityID *ent)
BOOL WINAPI DisableThreadLibraryCalls(IN HMODULE hLibModule)
Definition: loader.c:85
DWORD dwLocalAddr
Definition: udpmib.h:28
struct _MIB_IPNETTABLE MIB_IPNETTABLE
DWORD dwForwardNextHopAS
Definition: ipmib.h:87
DWORD WINAPI GetIpNetTable(PMIB_IPNETTABLE pIpNetTable, PULONG pdwSize, BOOL bOrder)
LONG WINAPI RegOpenKeyExA(_In_ HKEY hKey, _In_ LPCSTR lpSubKey, _In_ DWORD ulOptions, _In_ REGSAM samDesired, _Out_ PHKEY phkResult)
Definition: reg.c:3331
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
#define INVALID_HANDLE_VALUE
Definition: compat.h:391
struct _MIB_UDPROW * PMIB_UDPROW
#define INADDR_ANY
Definition: StrAddr.c:4
char String[4 *4]
Definition: iptypes.h:42
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1059
#define ZeroMemory
Definition: winbase.h:1635
DWORD dwForwardMask
Definition: ipmib.h:72
GLenum GLsizei GLenum GLenum const GLvoid * table
Definition: glext.h:5644
WINE_DEFAULT_DEBUG_CHANNEL(iphlpapi)
DWORD dwForwardMetric5
Definition: ipmib.h:92
DWORD WINAPI GetAdapterIndex(LPWSTR AdapterName, PULONG IfIndex)
DWORD WINAPI NhpAllocateAndGetInterfaceInfoFromStack(IP_INTERFACE_NAME_INFO **ppTable, PDWORD pdwCount, BOOL bOrder, HANDLE hHeap, DWORD dwFlags)
void interfaceMapInit(void)
struct _MIB_IPFORWARDROW * PMIB_IPFORWARDROW
DWORD WINAPI SetIpTTL(UINT nTTL)
#define DLL_PROCESS_ATTACH
Definition: compat.h:120
ULONG if_operstatus
Definition: tcpioctl.h:112
static int IpAddrTableSorter(const void *a, const void *b)
struct _MIB_UDPTABLE * PMIB_UDPTABLE
uint16_t * PWCHAR
Definition: typedefs.h:54
static void Server(int port)
Definition: srltest.c:69
IPAddrEntry ip_addr
#define ERROR_IO_PENDING
Definition: dderror.h:15
#define NO_ERROR
Definition: dderror.h:5
InterfaceIndexTable * getNonLoopbackInterfaceIndexTable(void)
DWORD dwReasmSize
Definition: ipmib.h:40
DWORD getNumNonLoopbackInterfaces(void)
#define DWORD
Definition: nt_native.h:44
struct _IP_ADAPTER_INFO IP_ADAPTER_INFO
static DWORD GetOwnerModuleFromPidEntry(DWORD OwningPid, TCPIP_OWNER_MODULE_INFO_CLASS Class, PVOID Buffer, PDWORD pdwSize)
struct _MIB_IPNETTABLE * PMIB_IPNETTABLE
MIB_UDPROW_OWNER_PID table[1]
Definition: udpmib.h:48
DWORD WINAPI GetIpStatistics(PMIB_IPSTATS pStats)
static IN DWORD IN LPVOID lpvReserved
#define IP_MIB_ARPTABLE_ENTRY_ID
Definition: tcpioctl.h:51
void consumeInterfaceName(const char *ifname)
struct _MIB_UDPTABLE_OWNER_PID * PMIB_UDPTABLE_OWNER_PID
STRSAFEAPI StringCchCatW(STRSAFE_LPWSTR pszDest, size_t cchDest, STRSAFE_LPCWSTR pszSrc)
Definition: strsafe.h:325
uint32_t ULONG_PTR
Definition: typedefs.h:63
const char * getInterfaceNameByIndex(DWORD index)
DWORD WINAPI NhGetInterfaceNameFromDeviceGuid(_In_ const GUID *pInterfaceGUID, _Out_writes_bytes_to_(*pOutBufLen, *pOutBufLen) PWCHAR pInterfaceName, _Inout_ PULONG pOutBufLen, DWORD dwUnknown4, DWORD dwUnknown5)
static int IfTableSorter(const void *a, const void *b)
DWORD WINAPI IpRenewAddress(PIP_ADAPTER_INDEX_MAP AdapterInfo)
DWORD dwForwardMetric3
Definition: ipmib.h:90
NTSTATUS addIPAddress(IPAddr Address, IPMask Mask, DWORD IfIndex, PULONG NteContext, PULONG NteInstance)
DWORD WINAPI AllocateAndGetUdpExTable2FromStack(PVOID *ppUdpTable, BOOL bOrder, HANDLE heap, DWORD flags, DWORD family, UDP_TABLE_CLASS class)
DWORD WINAPI GetIfTable(PMIB_IFTABLE pIfTable, PULONG pdwSize, BOOL bOrder)
IP_ADDR_STRING * DnsList
Definition: resinfo.h:26
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
DWORD getUDPStats(MIB_UDPSTATS *stats, DWORD family)
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
DWORD dwNumEntries
Definition: udpmib.h:34
DWORD getInterfaceBCastAddrByIndex(DWORD index)
struct _NAME_SERVER_LIST_CONTEXT * PNAME_SERVER_LIST_CONTEXT
LONG WINAPI RegCloseKey(HKEY hKey)
Definition: reg.c:423
unsigned char * LPBYTE
Definition: typedefs.h:52
DWORD getDhcpInfoForAdapter(DWORD AdapterIndex, PBOOL DhcpEnabled, PDWORD DhcpServer, time_t *LeaseObtained, time_t *LeaseExpires)
Definition: dhcp_reactos.c:17
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
static int Family
Definition: ping.c:62
char * toIPAddressString(unsigned int addr, char string[16])
#define UNICODE_NULL
#define GAA_FLAG_SKIP_FRIENDLY_NAME
NTSTATUS deleteIpAddress(ULONG NteContext)
unsigned int BOOL
Definition: ntddk_ex.h:94
MIB_UDPROW_OWNER_MODULE table[1]
Definition: udpmib.h:71
DWORD WINAPI GetIpAddrTable(PMIB_IPADDRTABLE pIpAddrTable, PULONG pdwSize, BOOL bOrder)
long LONG
Definition: pedump.c:60
DWORD dwForwardAge
Definition: ipmib.h:86
DWORD WINAPI SetIpForwardEntry(PMIB_IPFORWARDROW pRoute)
#define FILE_READ_DATA
Definition: nt_native.h:628
#define ERROR_PARTIAL_COPY
Definition: winerror.h:303
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 *))
#define FIXME(fmt,...)
Definition: debug.h:110
DWORD WINAPI CreateIpNetEntry(PMIB_IPNETROW pArpEntry)
static PVOID ptr
Definition: dispmode.c:27
ULONG toi_id
Definition: tdiinfo.h:77
DWORD WINAPI GetOwnerModuleFromTcpEntry(PMIB_TCPROW_OWNER_MODULE pTcpEntry, TCPIP_OWNER_MODULE_INFO_CLASS Class, PVOID Buffer, PDWORD pdwSize)
DWORD dwForwardMetric2
Definition: ipmib.h:89
DWORD WINAPI GetNetworkParams(PFIXED_INFO pFixedInfo, PULONG pOutBufLen)
ULONG if_type
Definition: tcpioctl.h:106
DWORD WINAPI GetIpStatisticsEx(PMIB_IPSTATS pStats, DWORD dwFamily)
#define IOCTL_TCP_SET_INFORMATION_EX
Definition: ticonsts.h:45
DWORD createIpForwardEntry(PMIB_IPFORWARDROW pRoute)
Definition: route.c:52
TCP_REQUEST_SET_INFORMATION_EX Req
DWORD WINAPI AllocateAndGetUdpExTableFromStack(PVOID *ppUdpTable, BOOL bOrder, HANDLE heap, DWORD flags, DWORD family)
unsigned short wType
Definition: ipmib.h:42
#define GetModuleFileNameExW(w, x, y, z)
Definition: compat.h:571
DWORD getInterfaceStatsByName(const char *name, PMIB_IFROW entry)
smooth NULL
Definition: ftsmooth.c:416
static WCHAR Address[46]
Definition: ping.c:68
STRSAFEAPI StringCbPrintfW(STRSAFE_LPWSTR pszDest, size_t cbDest, STRSAFE_LPCWSTR pszFormat,...)
Definition: strsafe.h:557
#define AF_INET6
Definition: winsock.h:369
enum _UDP_TABLE_CLASS UDP_TABLE_CLASS
char DomainName[MAX_DOMAIN_NAME_LEN+4]
Definition: iptypes.h:82
_Reserved_ PVOID Reserved
Definition: winddi.h:3974
DWORD indexes[1]
Definition: ifenum.h:64
Definition: bufpool.h:45
DWORD getNumRoutes(void)
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
Definition: iphlpapi_main.c:39
GLuint index
Definition: glext.h:6031
void * PVOID
Definition: retypes.h:9
static int UdpTableSorter(const void *a, const void *b)
#define PF_INET
Definition: winsock.h:373
DWORD WINAPI GetModuleBaseNameW(HANDLE hProcess, HMODULE hModule, LPWSTR lpBaseName, DWORD nSize)
Definition: psapi.c:930
ULONG IPAddr
Definition: pfhook.h:35
ULONG if_mtu
Definition: tcpioctl.h:107
#define ERROR_FILE_NOT_FOUND
Definition: disk.h:79
WCHAR Name[MAX_ADAPTER_NAME]
Definition: ipexport.h:136
#define FILE_WRITE_DATA
Definition: nt_native.h:631
#define b
Definition: ke_i.h:79
#define DLL_PROCESS_DETACH
Definition: compat.h:119
IF_INDEX dwForwardIfIndex
Definition: ipmib.h:75
#define DECLSPEC_HOTPATCH
Definition: _mingw.h:240
DWORD getInterfacePhysicalByIndex(DWORD index, PDWORD len, PBYTE addr, PDWORD type)
enum _TCP_TABLE_CLASS TCP_TABLE_CLASS
_In_ HANDLE Handle
Definition: extypes.h:390
IN PVOID IN PVOID IN USHORT IN USHORT IN PINTERFACE Interface
Definition: pci.h:359
DWORD WINAPI GetIcmpStatisticsEx(PMIB_ICMP_EX pStats, DWORD dwFamily)
ULONG tei_entity
Definition: tdiinfo.h:31
DWORD WINAPI GetUdpStatistics(PMIB_UDPSTATS pStats)
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
DWORD WINAPI AddIPAddress(IPAddr Address, IPMask Netmask, DWORD IfIndex, PULONG NteContext, PULONG NteInstance)
Definition: iphlpapi_main.c:71
#define TRACE(s)
Definition: solgame.cpp:4
DWORD WINAPI GetTcpTable(PMIB_TCPTABLE pTcpTable, PDWORD pdwSize, BOOL bOrder)
GLsizeiptr size
Definition: glext.h:5919
ULONGLONG OwningModuleInfo[TCPIP_OWNING_MODULE_SIZE]
Definition: tcpmib.h:127
DWORD dwForwardNextHop
Definition: ipmib.h:74
#define GetProcessHeap()
Definition: compat.h:395
MIB_UDPROW table[1]
Definition: udpmib.h:35
DWORD dwBCastAddr
Definition: ipmib.h:39
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4116
if(!(yy_init))
Definition: macro.lex.yy.c:714
BOOL WINAPI CancelIPChangeNotify(LPOVERLAPPED notifyOverlapped)
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
LONG HRESULT
Definition: typedefs.h:77
DWORD WINAPI GetIcmpStatistics(PMIB_ICMP pStats)
struct _IP_PER_ADAPTER_INFO IP_PER_ADAPTER_INFO
static int IpForwardTableSorter(const void *a, const void *b)
#define ERROR_NO_DATA
Definition: winerror.h:284
DWORD WINAPI GetPerAdapterInfo(ULONG IfIndex, PIP_PER_ADAPTER_INFO pPerAdapterInfo, PULONG pOutBufLen)
struct _MIB_IFTABLE MIB_IFTABLE
ULONG tei_instance
Definition: tdiinfo.h:32
#define MAX_PATH
Definition: compat.h:26
#define WINAPI
Definition: msvc.h:8
DWORD dwNumEntries
Definition: ipmib.h:97
DWORD getNumInterfaces(void)
#define CopyMemory
Definition: winbase.h:1633
DWORD dwForwardDest
Definition: ipmib.h:71
UINT NodeType
Definition: iptypes.h:85
unsigned long DWORD
Definition: ntddk_ex.h:95
DWORD getInterfaceMaskByIndex(DWORD index)
PMIB_IPNETTABLE getArpTable(void)
DWORD WINAPI AllocateAndGetIpAddrTableFromStack(PMIB_IPADDRTABLE *ppIpAddrTable, BOOL bOrder, HANDLE heap, DWORD flags)
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
BOOL Error
Definition: chkdsk.c:66
DWORD getTCPStats(MIB_TCPSTATS *stats, DWORD family)
#define SetLastError(x)
Definition: compat.h:409
#define _Inout_
Definition: no_sal2.h:244
MIB_IPFORWARDROW table[1]
Definition: ipmib.h:98
DWORD getInterfaceGatewayByIndex(DWORD index)
Definition: iphlpapi_main.c:76
#define TCP_REQUEST_SET_INFORMATION_INIT
GLbitfield flags
Definition: glext.h:7161
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
DWORD getIPStats(PMIB_IPSTATS stats, DWORD family)
MIB_TCP_STATE State
Definition: tcpmib.h:56
unsigned short unused1
Definition: ipmib.h:41
VOID closeTcpFile(HANDLE h)
Definition: handle.c:43
struct _MIB_TCPROW_OWNER_PID MIB_TCPROW_OWNER_PID
static DWORD GetOwnerModuleFromTagEntry(DWORD OwningPid, DWORD OwningTag, TCPIP_OWNER_MODULE_INFO_CLASS Class, PVOID Buffer, PDWORD pdwSize)
DWORD dwLocalAddr
Definition: tcpmib.h:58
ULONG iae_addr
Definition: tcpioctl.h:159
int ret
struct _MIB_IFROW * PMIB_IFROW
#define MAX_ADAPTER_NAME_LENGTH
Definition: iptypes.h:27
_CRTIMP wchar_t *__cdecl wcscpy(_Out_writes_z_(_String_length_(_Source)+1) wchar_t *_Dest, _In_z_ const wchar_t *_Source)
GLenum const GLvoid * addr
Definition: glext.h:9621
static const WCHAR L[]
Definition: oid.c:1250
#define MAX_INTERFACE_NAME_LEN
Definition: ifmib.h:31
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1175
PIPHLP_RES_INFO getResInfo()
Definition: resinfo.c:54
PVOID *typedef PHANDLE
Definition: ntsecpkg.h:414
DWORD WINAPI SetIpNetEntry(PMIB_IPNETROW pArpEntry)
struct _MIB_IPADDRROW * PMIB_IPADDRROW
static void CreateNameServerListEnumNamesFunc(PWCHAR Interface, PWCHAR Server, PVOID Data)
struct _MIB_UDPROW_OWNER_MODULE MIB_UDPROW_OWNER_MODULE
DWORD WINAPI NhGetInterfaceNameFromGuid(_In_ const GUID *pInterfaceGUID, _Out_writes_bytes_to_(*pOutBufLen, *pOutBufLen) PWCHAR pInterfaceName, _Inout_ PULONG pOutBufLen, DWORD dwUnknown4, DWORD dwUnknown5)
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
struct _TCPIP_OWNER_MODULE_BASIC_INFO TCPIP_OWNER_MODULE_BASIC_INFO
DWORD APIENTRY DhcpCApiInitialize(LPDWORD Version)
Definition: dhcpcsvc.c:24
char HostName[MAX_HOSTNAME_LEN+4]
Definition: iptypes.h:81
DWORD WINAPI AllocateAndGetTcpExTable2FromStack(PVOID *ppTcpTable, BOOL bOrder, HANDLE heap, DWORD flags, DWORD family, TCP_TABLE_CLASS class)
NTSYSAPI NTSTATUS WINAPI RtlStringFromGUID(REFGUID, PUNICODE_STRING)
#define HYBRID_NODETYPE
Definition: iptypes.h:39
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:359
#define ERROR_MORE_DATA
Definition: dderror.h:13
DWORD GetInterfaceNameInternal(_In_ const GUID *pInterfaceGUID, _Out_writes_bytes_to_(*pOutBufLen, *pOutBufLen) PWCHAR pInterfaceName, _Inout_ PULONG pOutBufLen)
BOOL WINAPI GetRTTAndHopCount(IPAddr DestIpAddress, PULONG HopCount, ULONG MaxHops, PULONG RTT)
DWORD WINAPI NotifyAddrChange(PHANDLE Handle, LPOVERLAPPED overlapped)
Status
Definition: gdiplustypes.h:24
DWORD getInterfaceEntryByIndex(DWORD index, PMIB_IFROW entry)
MIB_IPNETROW table[1]
Definition: ipmib.h:128
#define ERROR_INVALID_DATA
Definition: winerror.h:116
DWORD dwMask
Definition: ipmib.h:38
struct _MIB_IFTABLE * PMIB_IFTABLE
DWORD WINAPI DeleteProxyArpEntry(DWORD dwAddress, DWORD dwMask, DWORD dwIfIndex)
NTSYSAPI ULONG WINAPI RtlNtStatusToDosError(NTSTATUS)
#define _In_
Definition: no_sal2.h:204
struct _MIB_IPNETROW MIB_IPNETROW
struct _MIB_IPFORWARDTABLE * PMIB_IPFORWARDTABLE
IP_ADDR_STRING * pLastAddr
Definition: iphlpapi_main.c:36
DWORD getICMPStats(MIB_ICMP *stats)
DWORD WINAPI EnableRouter(HANDLE *pHandle, OVERLAPPED *pOverlapped)
namespace GUID const ADDRINFOEXW ADDRINFOEXW struct timeval OVERLAPPED * overlapped
Definition: sock.c:82
MIB_TCPROW_OWNER_MODULE table[1]
Definition: tcpmib.h:133
HANDLE WINAPI OpenProcess(IN DWORD dwDesiredAccess, IN BOOL bInheritHandle, IN DWORD dwProcessId)
Definition: proc.c:1257
DWORD dwForwardPolicy
Definition: ipmib.h:73
DWORD WINAPI GetBestInterface(IPAddr dwDestAddr, PDWORD pdwBestIfIndex)
PRTL_UNICODE_STRING_BUFFER Path
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
#define ERROR_PROC_NOT_FOUND
Definition: winerror.h:199
struct _MIB_TCPTABLE_OWNER_PID * PMIB_TCPTABLE_OWNER_PID
DWORD WINAPI DeleteIPAddress(ULONG NTEContext)
DWORD WINAPI GetIpForwardTable(PMIB_IPFORWARDTABLE pIpForwardTable, PULONG pdwSize, BOOL bOrder)
DWORD WINAPI AllocateAndGetTcpTableFromStack(PMIB_TCPTABLE *ppTcpTable, BOOL bOrder, HANDLE heap, DWORD flags)
struct _MIB_IPADDRROW MIB_IPADDRROW
unsigned short USHORT
Definition: pedump.c:61
DWORD setIpForwardEntry(PMIB_IPFORWARDROW pRoute)
Definition: route.c:59
struct _MIB_IPADDRTABLE * PMIB_IPADDRTABLE
PIP_PER_ADAPTER_INFO pData
Definition: iphlpapi_main.c:34
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1577
DWORD dwNumEntries
Definition: ipmib.h:47
struct _MIB_TCPTABLE * PMIB_TCPTABLE
DWORD WINAPI GetExtendedUdpTable(PVOID pUdpTable, PDWORD pdwSize, BOOL bOrder, ULONG ulAf, UDP_TABLE_CLASS TableClass, ULONG Reserved)
DWORD dwNumEntries
Definition: ifmib.h:65
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:254
UINT WINAPI GetSystemDirectoryW(OUT LPWSTR lpBuffer, IN UINT uSize)
Definition: path.c:2312
ULONG IP_STATUS
Definition: ipexport.h:29
DWORD WINAPI GetIpErrorString(IP_STATUS ErrorCode, PWCHAR Buffer, PDWORD Size)
DWORD WINAPI GetIfEntry(PMIB_IFROW pIfRow)
DWORD WINAPI GetBestInterfaceEx(struct sockaddr *pDestAddr, PDWORD pdwBestIfIndex)
unsigned int * PULONG
Definition: retypes.h:1
DWORD WINAPI GetFriendlyIfIndex(DWORD IfIndex)
struct _MIB_IPFORWARDTABLE MIB_IPFORWARDTABLE
unsigned int UINT
Definition: ndis.h:50
#define GAA_FLAG_SKIP_UNICAST
#define ERROR_NOT_FOUND
Definition: winerror.h:690
DWORD * PDWORD
Definition: pedump.c:68
#define MultiByteToWideChar
Definition: compat.h:100
struct _IP_ADAPTER_INDEX_MAP IP_ADAPTER_INDEX_MAP
DWORD dwRemotePort
Definition: tcpmib.h:61
IF_INDEX dwIndex
Definition: ipmib.h:37
#define INFO_TYPE_PROVIDER
Definition: tdiinfo.h:69
NTSTATUS openTcpFile(PHANDLE tcpFile, ACCESS_MASK DesiredAccess)
Definition: handle.c:12
void interfaceMapFree(void)
DWORD WINAPI GetExtendedTcpTable(PVOID pTcpTable, PDWORD pdwSize, BOOL bOrder, ULONG ulAf, TCP_TABLE_CLASS TableClass, ULONG Reserved)
#define PROCESS_VM_READ
Definition: pstypes.h:153
DWORD WINAPI UnenableRouter(OVERLAPPED *pOverlapped, LPDWORD lpdwEnableCount)
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ PLARGE_INTEGER _In_ ULONG _In_ PFILE_OBJECT _In_ PVOID Process
Definition: fsrtlfuncs.h:219
#define ERROR_NOT_SUPPORTED
Definition: compat.h:90
DWORD WINAPI GetUniDirectionalAdapterInfo(PIP_UNIDIRECTIONAL_ADAPTER_ADDRESS pIPIfInfo, PULONG dwOutBufLen)
DWORD WINAPI GetAdaptersInfo(PIP_ADAPTER_INFO pAdapterInfo, PULONG pOutBufLen)
Definition: name.c:36
struct _MIB_IPFORWARDROW MIB_IPFORWARDROW
#define MAX_ADAPTER_NAME
Definition: ipexport.h:132
uint32_t * LPDWORD
Definition: typedefs.h:57
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388
LSTATUS EnumNameServers(HKEY RegHandle, LPWSTR Interface, PVOID Data, EnumNameServersFunc cb)
struct tagContext Context
Definition: acpixf.h:1012
DWORD APIENTRY DhcpRenewIpAddressLease(DWORD AdapterIndex)
Definition: dhcpcsvc.c:163
unsigned int ULONG
Definition: retypes.h:1
GLenum GLuint id
Definition: glext.h:5579
#define AF_INET
Definition: tcpip.h:117
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3366
HMODULE WINAPI GetModuleHandleW(LPCWSTR lpModuleName)
Definition: loader.c:845
DWORD WINAPI DeleteIpNetEntry(PMIB_IPNETROW pArpEntry)
#define UNIMPLEMENTED
Definition: debug.h:114
DWORD WINAPI GetTcpStatisticsEx(PMIB_TCPSTATS pStats, DWORD dwFamily)
DWORD dwLocalPort
Definition: udpmib.h:29
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
IFEntrySafelySized if_info
DWORD dwForwardProto
Definition: ipmib.h:83
#define GetProcAddress(x, y)
Definition: compat.h:410
DWORD WINAPI GetBestRoute(DWORD dwDestAddr, DWORD dwSourceAddr, PMIB_IPFORWARDROW pBestRoute)
DWORD dwAddr
Definition: ipmib.h:36
DWORD dwIndex
Definition: ifmib.h:38
#define ERROR_PATH_NOT_FOUND
Definition: winerror.h:106
enum _TCPIP_OWNER_MODULE_INFO_CLASS TCPIP_OWNER_MODULE_INFO_CLASS
Definition: File.h:15
DWORD dwIndex
Definition: ipmib.h:114
DWORD WINAPI AllocateAndGetTcpExTableFromStack(PVOID *ppTcpTable, BOOL bOrder, HANDLE heap, DWORD flags, DWORD family)
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204
static int IpNetTableSorter(const void *a, const void *b)
DWORD dwForwardMetric1
Definition: ipmib.h:88
WCHAR * LPWSTR
Definition: xmlstorage.h:184
IP_ADDR_STRING DnsServerList
Definition: iptypes.h:84
ULONG IPMask
Definition: ipexport.h:28
IN BOOLEAN OUT PSTR Buffer
Definition: progress.h:34
_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:6013
UCHAR if_physaddr[MAX_PHYSADDR_SIZE]
Definition: tcpioctl.h:110
DWORD WINAPI SetTcpEntry(PMIB_TCPROW pTcpRow)
GLuint64EXT * result
Definition: glext.h:11304
#define memset(x, y, z)
Definition: compat.h:39
PVOID getUdpTable(CLASS_TABLE Class)
static SERVICE_STATUS status
Definition: service.c:31
char ScopeId[MAX_SCOPE_ID_LEN+4]
Definition: iptypes.h:86
BYTE * PBYTE
Definition: pedump.c:66
static PIP_ADAPTER_ADDRESSES
Definition: iphlpapi.c:76
DWORD getInterfaceIPAddrByIndex(DWORD index)
DWORD WINAPI GetNumberOfInterfaces(PDWORD pdwNumIf)
struct _MIB_TCPROW * PMIB_TCPROW
size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
#define HeapFree(x, y, z)
Definition: compat.h:394
MIB_IPADDRROW table[1]
Definition: ipmib.h:48
PSDBQUERYRESULT_VISTA PVOID DWORD * dwSize
Definition: env.c:54
DWORD dwNumEntries
Definition: ipmib.h:127
#define IOCTL_QUERY_IP_HW_ADDRESS
Definition: tcpioctl.h:40
UCHAR if_descr[1]
Definition: tcpioctl.h:127
DWORD deleteIpForwardEntry(PMIB_IPFORWARDROW pRoute)
Definition: route.c:64
DWORD WINAPI SetIpStatistics(PMIB_IPSTATS pIpStats)
VOID APIENTRY DhcpCApiCleanup(VOID)
Definition: dhcpcsvc.c:69
ULONG toi_type
Definition: tdiinfo.h:76
DWORD WINAPI SendARP(IPAddr DestIP, IPAddr SrcIP, PULONG pMacAddr, PULONG PhyAddrLen)
static DWORD ServiceTag
Definition: database.c:34
DWORD WINAPI GetTcpStatistics(PMIB_TCPSTATS pStats)
DWORD WINAPI NotifyRouteChange(PHANDLE Handle, LPOVERLAPPED overlapped)
struct _IP_INTERFACE_INFO IP_INTERFACE_INFO
struct _MIB_IFROW MIB_IFROW
#define ERROR_OUTOFMEMORY
Definition: deptool.c:13
NTSTATUS getIPAddrEntryForIf(HANDLE tcpFile, char *name, DWORD index, IFInfo *ifInfo)
MIB_TCPROW_OWNER_PID table[1]
Definition: tcpmib.h:115
struct _MIB_TCPROW MIB_TCPROW
DWORD WINAPI GetUdpStatisticsEx(PMIB_UDPSTATS pStats, DWORD dwFamily)
DWORD TCPSendIoctl(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, PULONG pInBufferSize, LPVOID lpOutBuffer, PULONG pOutBufferSize)
struct _IP_ADDR_STRING IP_ADDR_STRING
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12
#define INFO_CLASS_PROTOCOL
Definition: tdiinfo.h:65
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10
#define REG_SZ
Definition: layer.c:22
#define ntohl(x)
Definition: module.h:203
Definition: ps.c:97
GLuint const GLchar * name
Definition: glext.h:6031