mshtml: Added IHTMLElement::get_parentElement implementation.
[wine] / dlls / iphlpapi / iphlpapi_main.c
1 /*
2  * iphlpapi dll implementation
3  *
4  * Copyright (C) 2003,2006 Juan Lang
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include "config.h"
22
23 #include <stdarg.h>
24 #include <stdlib.h>
25 #include <sys/types.h>
26 #ifdef HAVE_NETINET_IN_H
27 # include <netinet/in.h>
28 #endif
29 #ifdef HAVE_ARPA_INET_H
30 # include <arpa/inet.h>
31 #endif
32 #ifdef HAVE_ARPA_NAMESER_H
33 # include <arpa/nameser.h>
34 #endif
35 #ifdef HAVE_RESOLV_H
36 # include <resolv.h>
37 #endif
38
39 #include "windef.h"
40 #include "winbase.h"
41 #include "winreg.h"
42 #define USE_WS_PREFIX
43 #include "winsock2.h"
44 #include "iphlpapi.h"
45 #include "ifenum.h"
46 #include "ipstats.h"
47
48 #include "wine/debug.h"
49
50 WINE_DEFAULT_DEBUG_CHANNEL(iphlpapi);
51
52 #ifndef INADDR_NONE
53 #define INADDR_NONE ~0UL
54 #endif
55
56 static int resolver_initialised;
57
58 /* call res_init() just once because of a bug in Mac OS X 10.4 */
59 static void initialise_resolver(void)
60 {
61     if (!resolver_initialised)
62     {
63         res_init();
64         resolver_initialised = 1;
65     }
66 }
67
68 BOOL WINAPI DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
69 {
70   switch (fdwReason) {
71     case DLL_PROCESS_ATTACH:
72       DisableThreadLibraryCalls( hinstDLL );
73       break;
74
75     case DLL_PROCESS_DETACH:
76       break;
77   }
78   return TRUE;
79 }
80
81 /******************************************************************
82  *    AddIPAddress (IPHLPAPI.@)
83  *
84  * Add an IP address to an adapter.
85  *
86  * PARAMS
87  *  Address     [In]  IP address to add to the adapter
88  *  IpMask      [In]  subnet mask for the IP address
89  *  IfIndex     [In]  adapter index to add the address
90  *  NTEContext  [Out] Net Table Entry (NTE) context for the IP address
91  *  NTEInstance [Out] NTE instance for the IP address
92  *
93  * RETURNS
94  *  Success: NO_ERROR
95  *  Failure: error code from winerror.h
96  *
97  * FIXME
98  *  Stub. Currently returns ERROR_NOT_SUPPORTED.
99  */
100 DWORD WINAPI AddIPAddress(IPAddr Address, IPMask IpMask, DWORD IfIndex, PULONG NTEContext, PULONG NTEInstance)
101 {
102   FIXME(":stub\n");
103   return ERROR_NOT_SUPPORTED;
104 }
105
106
107 /******************************************************************
108  *    AllocateAndGetIfTableFromStack (IPHLPAPI.@)
109  *
110  * Get table of local interfaces.
111  * Like GetIfTable(), but allocate the returned table from heap.
112  *
113  * PARAMS
114  *  ppIfTable [Out] pointer into which the MIB_IFTABLE is
115  *                  allocated and returned.
116  *  bOrder    [In]  whether to sort the table
117  *  heap      [In]  heap from which the table is allocated
118  *  flags     [In]  flags to HeapAlloc
119  *
120  * RETURNS
121  *  ERROR_INVALID_PARAMETER if ppIfTable is NULL, whatever
122  *  GetIfTable() returns otherwise.
123  */
124 DWORD WINAPI AllocateAndGetIfTableFromStack(PMIB_IFTABLE *ppIfTable,
125  BOOL bOrder, HANDLE heap, DWORD flags)
126 {
127   DWORD ret;
128
129   TRACE("ppIfTable %p, bOrder %d, heap %p, flags 0x%08x\n", ppIfTable,
130         bOrder, heap, flags);
131   if (!ppIfTable)
132     ret = ERROR_INVALID_PARAMETER;
133   else {
134     DWORD dwSize = 0;
135
136     ret = GetIfTable(*ppIfTable, &dwSize, bOrder);
137     if (ret == ERROR_INSUFFICIENT_BUFFER) {
138       *ppIfTable = HeapAlloc(heap, flags, dwSize);
139       ret = GetIfTable(*ppIfTable, &dwSize, bOrder);
140     }
141   }
142   TRACE("returning %d\n", ret);
143   return ret;
144 }
145
146
147 static int IpAddrTableSorter(const void *a, const void *b)
148 {
149   int ret;
150
151   if (a && b)
152     ret = ((const MIB_IPADDRROW*)a)->dwAddr - ((const MIB_IPADDRROW*)b)->dwAddr;
153   else
154     ret = 0;
155   return ret;
156 }
157
158
159 /******************************************************************
160  *    AllocateAndGetIpAddrTableFromStack (IPHLPAPI.@)
161  *
162  * Get interface-to-IP address mapping table. 
163  * Like GetIpAddrTable(), but allocate the returned table from heap.
164  *
165  * PARAMS
166  *  ppIpAddrTable [Out] pointer into which the MIB_IPADDRTABLE is
167  *                      allocated and returned.
168  *  bOrder        [In]  whether to sort the table
169  *  heap          [In]  heap from which the table is allocated
170  *  flags         [In]  flags to HeapAlloc
171  *
172  * RETURNS
173  *  ERROR_INVALID_PARAMETER if ppIpAddrTable is NULL, other error codes on
174  *  failure, NO_ERROR on success.
175  */
176 DWORD WINAPI AllocateAndGetIpAddrTableFromStack(PMIB_IPADDRTABLE *ppIpAddrTable,
177  BOOL bOrder, HANDLE heap, DWORD flags)
178 {
179   DWORD ret;
180
181   TRACE("ppIpAddrTable %p, bOrder %d, heap %p, flags 0x%08x\n",
182    ppIpAddrTable, bOrder, heap, flags);
183   ret = getIPAddrTable(ppIpAddrTable, heap, flags);
184   if (!ret && bOrder)
185     qsort((*ppIpAddrTable)->table, (*ppIpAddrTable)->dwNumEntries,
186      sizeof(MIB_IPADDRROW), IpAddrTableSorter);
187   TRACE("returning %d\n", ret);
188   return ret;
189 }
190
191
192 static int IpForwardTableSorter(const void *a, const void *b)
193 {
194   int ret;
195
196   if (a && b) {
197    const MIB_IPFORWARDROW* rowA = (const MIB_IPFORWARDROW*)a;
198    const MIB_IPFORWARDROW* rowB = (const MIB_IPFORWARDROW*)b;
199
200     ret = rowA->dwForwardDest - rowB->dwForwardDest;
201     if (ret == 0) {
202       ret = rowA->dwForwardProto - rowB->dwForwardProto;
203       if (ret == 0) {
204         ret = rowA->dwForwardPolicy - rowB->dwForwardPolicy;
205         if (ret == 0)
206           ret = rowA->dwForwardNextHop - rowB->dwForwardNextHop;
207       }
208     }
209   }
210   else
211     ret = 0;
212   return ret;
213 }
214
215
216 /******************************************************************
217  *    AllocateAndGetIpForwardTableFromStack (IPHLPAPI.@)
218  *
219  * Get the route table.
220  * Like GetIpForwardTable(), but allocate the returned table from heap.
221  *
222  * PARAMS
223  *  ppIpForwardTable [Out] pointer into which the MIB_IPFORWARDTABLE is
224  *                         allocated and returned.
225  *  bOrder           [In]  whether to sort the table
226  *  heap             [In]  heap from which the table is allocated
227  *  flags            [In]  flags to HeapAlloc
228  *
229  * RETURNS
230  *  ERROR_INVALID_PARAMETER if ppIfTable is NULL, other error codes
231  *  on failure, NO_ERROR on success.
232  */
233 DWORD WINAPI AllocateAndGetIpForwardTableFromStack(PMIB_IPFORWARDTABLE *
234  ppIpForwardTable, BOOL bOrder, HANDLE heap, DWORD flags)
235 {
236   DWORD ret;
237
238   TRACE("ppIpForwardTable %p, bOrder %d, heap %p, flags 0x%08x\n",
239    ppIpForwardTable, bOrder, heap, flags);
240   ret = getRouteTable(ppIpForwardTable, heap, flags);
241   if (!ret && bOrder)
242     qsort((*ppIpForwardTable)->table, (*ppIpForwardTable)->dwNumEntries,
243      sizeof(MIB_IPFORWARDROW), IpForwardTableSorter);
244   TRACE("returning %d\n", ret);
245   return ret;
246 }
247
248
249 static int IpNetTableSorter(const void *a, const void *b)
250 {
251   int ret;
252
253   if (a && b)
254     ret = ((const MIB_IPNETROW*)a)->dwAddr - ((const MIB_IPNETROW*)b)->dwAddr;
255   else
256     ret = 0;
257   return ret;
258 }
259
260
261 /******************************************************************
262  *    AllocateAndGetIpNetTableFromStack (IPHLPAPI.@)
263  *
264  * Get the IP-to-physical address mapping table.
265  * Like GetIpNetTable(), but allocate the returned table from heap.
266  *
267  * PARAMS
268  *  ppIpNetTable [Out] pointer into which the MIB_IPNETTABLE is
269  *                     allocated and returned.
270  *  bOrder       [In]  whether to sort the table
271  *  heap         [In]  heap from which the table is allocated
272  *  flags        [In]  flags to HeapAlloc
273  *
274  * RETURNS
275  *  ERROR_INVALID_PARAMETER if ppIpNetTable is NULL, other error codes
276  *  on failure, NO_ERROR on success.
277  */
278 DWORD WINAPI AllocateAndGetIpNetTableFromStack(PMIB_IPNETTABLE *ppIpNetTable,
279  BOOL bOrder, HANDLE heap, DWORD flags)
280 {
281   DWORD ret;
282
283   TRACE("ppIpNetTable %p, bOrder %d, heap %p, flags 0x%08x\n",
284    ppIpNetTable, bOrder, heap, flags);
285   ret = getArpTable(ppIpNetTable, heap, flags);
286   if (!ret && bOrder)
287     qsort((*ppIpNetTable)->table, (*ppIpNetTable)->dwNumEntries,
288      sizeof(MIB_IPADDRROW), IpNetTableSorter);
289   TRACE("returning %d\n", ret);
290   return ret;
291 }
292
293
294 static int TcpTableSorter(const void *a, const void *b)
295 {
296   int ret;
297
298   if (a && b) {
299     const MIB_TCPROW* rowA = a;
300     const MIB_TCPROW* rowB = b;
301
302     ret = ntohl (rowA->dwLocalAddr) - ntohl (rowB->dwLocalAddr);
303     if (ret == 0) {
304        ret = ntohs ((unsigned short)rowA->dwLocalPort) -
305           ntohs ((unsigned short)rowB->dwLocalPort);
306       if (ret == 0) {
307          ret = ntohl (rowA->dwRemoteAddr) - ntohl (rowB->dwRemoteAddr);
308         if (ret == 0)
309            ret = ntohs ((unsigned short)rowA->dwRemotePort) -
310               ntohs ((unsigned short)rowB->dwRemotePort);
311       }
312     }
313   }
314   else
315     ret = 0;
316   return ret;
317 }
318
319
320 /******************************************************************
321  *    AllocateAndGetTcpTableFromStack (IPHLPAPI.@)
322  *
323  * Get the TCP connection table.
324  * Like GetTcpTable(), but allocate the returned table from heap.
325  *
326  * PARAMS
327  *  ppTcpTable [Out] pointer into which the MIB_TCPTABLE is
328  *                   allocated and returned.
329  *  bOrder     [In]  whether to sort the table
330  *  heap       [In]  heap from which the table is allocated
331  *  flags      [In]  flags to HeapAlloc
332  *
333  * RETURNS
334  *  ERROR_INVALID_PARAMETER if ppTcpTable is NULL, whatever GetTcpTable()
335  *  returns otherwise.
336  */
337 DWORD WINAPI AllocateAndGetTcpTableFromStack(PMIB_TCPTABLE *ppTcpTable,
338  BOOL bOrder, HANDLE heap, DWORD flags)
339 {
340   DWORD ret;
341
342   TRACE("ppTcpTable %p, bOrder %d, heap %p, flags 0x%08x\n",
343    ppTcpTable, bOrder, heap, flags);
344
345   *ppTcpTable = NULL;
346   ret = getTcpTable(ppTcpTable, 0, heap, flags);
347   if (!ret && bOrder)
348     qsort((*ppTcpTable)->table, (*ppTcpTable)->dwNumEntries,
349      sizeof(MIB_TCPROW), TcpTableSorter);
350   TRACE("returning %d\n", ret);
351   return ret;
352 }
353
354
355 static int UdpTableSorter(const void *a, const void *b)
356 {
357   int ret;
358
359   if (a && b) {
360     const MIB_UDPROW* rowA = (const MIB_UDPROW*)a;
361     const MIB_UDPROW* rowB = (const MIB_UDPROW*)b;
362
363     ret = rowA->dwLocalAddr - rowB->dwLocalAddr;
364     if (ret == 0)
365       ret = rowA->dwLocalPort - rowB->dwLocalPort;
366   }
367   else
368     ret = 0;
369   return ret;
370 }
371
372
373 /******************************************************************
374  *    AllocateAndGetUdpTableFromStack (IPHLPAPI.@)
375  *
376  * Get the UDP listener table.
377  * Like GetUdpTable(), but allocate the returned table from heap.
378  *
379  * PARAMS
380  *  ppUdpTable [Out] pointer into which the MIB_UDPTABLE is
381  *                   allocated and returned.
382  *  bOrder     [In]  whether to sort the table
383  *  heap       [In]  heap from which the table is allocated
384  *  flags      [In]  flags to HeapAlloc
385  *
386  * RETURNS
387  *  ERROR_INVALID_PARAMETER if ppUdpTable is NULL, whatever GetUdpTable()
388  *  returns otherwise.
389  */
390 DWORD WINAPI AllocateAndGetUdpTableFromStack(PMIB_UDPTABLE *ppUdpTable,
391  BOOL bOrder, HANDLE heap, DWORD flags)
392 {
393   DWORD ret;
394
395   TRACE("ppUdpTable %p, bOrder %d, heap %p, flags 0x%08x\n",
396    ppUdpTable, bOrder, heap, flags);
397   ret = getUdpTable(ppUdpTable, heap, flags);
398   if (!ret && bOrder)
399     qsort((*ppUdpTable)->table, (*ppUdpTable)->dwNumEntries,
400      sizeof(MIB_UDPROW), UdpTableSorter);
401   TRACE("returning %d\n", ret);
402   return ret;
403 }
404
405
406 /******************************************************************
407  *    CreateIpForwardEntry (IPHLPAPI.@)
408  *
409  * Create a route in the local computer's IP table.
410  *
411  * PARAMS
412  *  pRoute [In] new route information
413  *
414  * RETURNS
415  *  Success: NO_ERROR
416  *  Failure: error code from winerror.h
417  *
418  * FIXME
419  *  Stub, always returns NO_ERROR.
420  */
421 DWORD WINAPI CreateIpForwardEntry(PMIB_IPFORWARDROW pRoute)
422 {
423   FIXME("(pRoute %p): stub\n", pRoute);
424   /* could use SIOCADDRT, not sure I want to */
425   return (DWORD) 0;
426 }
427
428
429 /******************************************************************
430  *    CreateIpNetEntry (IPHLPAPI.@)
431  *
432  * Create entry in the ARP table.
433  *
434  * PARAMS
435  *  pArpEntry [In] new ARP entry
436  *
437  * RETURNS
438  *  Success: NO_ERROR
439  *  Failure: error code from winerror.h
440  *
441  * FIXME
442  *  Stub, always returns NO_ERROR.
443  */
444 DWORD WINAPI CreateIpNetEntry(PMIB_IPNETROW pArpEntry)
445 {
446   FIXME("(pArpEntry %p)\n", pArpEntry);
447   /* could use SIOCSARP on systems that support it, not sure I want to */
448   return (DWORD) 0;
449 }
450
451
452 /******************************************************************
453  *    CreateProxyArpEntry (IPHLPAPI.@)
454  *
455  * Create a Proxy ARP (PARP) entry for an IP address.
456  *
457  * PARAMS
458  *  dwAddress [In] IP address for which this computer acts as a proxy. 
459  *  dwMask    [In] subnet mask for dwAddress
460  *  dwIfIndex [In] interface index
461  *
462  * RETURNS
463  *  Success: NO_ERROR
464  *  Failure: error code from winerror.h
465  *
466  * FIXME
467  *  Stub, returns ERROR_NOT_SUPPORTED.
468  */
469 DWORD WINAPI CreateProxyArpEntry(DWORD dwAddress, DWORD dwMask, DWORD dwIfIndex)
470 {
471   FIXME("(dwAddress 0x%08x, dwMask 0x%08x, dwIfIndex 0x%08x): stub\n",
472    dwAddress, dwMask, dwIfIndex);
473   return ERROR_NOT_SUPPORTED;
474 }
475
476
477 /******************************************************************
478  *    DeleteIPAddress (IPHLPAPI.@)
479  *
480  * Delete an IP address added with AddIPAddress().
481  *
482  * PARAMS
483  *  NTEContext [In] NTE context from AddIPAddress();
484  *
485  * RETURNS
486  *  Success: NO_ERROR
487  *  Failure: error code from winerror.h
488  *
489  * FIXME
490  *  Stub, returns ERROR_NOT_SUPPORTED.
491  */
492 DWORD WINAPI DeleteIPAddress(ULONG NTEContext)
493 {
494   FIXME("(NTEContext %d): stub\n", NTEContext);
495   return ERROR_NOT_SUPPORTED;
496 }
497
498
499 /******************************************************************
500  *    DeleteIpForwardEntry (IPHLPAPI.@)
501  *
502  * Delete a route.
503  *
504  * PARAMS
505  *  pRoute [In] route to delete
506  *
507  * RETURNS
508  *  Success: NO_ERROR
509  *  Failure: error code from winerror.h
510  *
511  * FIXME
512  *  Stub, returns NO_ERROR.
513  */
514 DWORD WINAPI DeleteIpForwardEntry(PMIB_IPFORWARDROW pRoute)
515 {
516   FIXME("(pRoute %p): stub\n", pRoute);
517   /* could use SIOCDELRT, not sure I want to */
518   return (DWORD) 0;
519 }
520
521
522 /******************************************************************
523  *    DeleteIpNetEntry (IPHLPAPI.@)
524  *
525  * Delete an ARP entry.
526  *
527  * PARAMS
528  *  pArpEntry [In] ARP entry to delete
529  *
530  * RETURNS
531  *  Success: NO_ERROR
532  *  Failure: error code from winerror.h
533  *
534  * FIXME
535  *  Stub, returns NO_ERROR.
536  */
537 DWORD WINAPI DeleteIpNetEntry(PMIB_IPNETROW pArpEntry)
538 {
539   FIXME("(pArpEntry %p): stub\n", pArpEntry);
540   /* could use SIOCDARP on systems that support it, not sure I want to */
541   return (DWORD) 0;
542 }
543
544
545 /******************************************************************
546  *    DeleteProxyArpEntry (IPHLPAPI.@)
547  *
548  * Delete a Proxy ARP entry.
549  *
550  * PARAMS
551  *  dwAddress [In] IP address for which this computer acts as a proxy. 
552  *  dwMask    [In] subnet mask for dwAddress
553  *  dwIfIndex [In] interface index
554  *
555  * RETURNS
556  *  Success: NO_ERROR
557  *  Failure: error code from winerror.h
558  *
559  * FIXME
560  *  Stub, returns ERROR_NOT_SUPPORTED.
561  */
562 DWORD WINAPI DeleteProxyArpEntry(DWORD dwAddress, DWORD dwMask, DWORD dwIfIndex)
563 {
564   FIXME("(dwAddress 0x%08x, dwMask 0x%08x, dwIfIndex 0x%08x): stub\n",
565    dwAddress, dwMask, dwIfIndex);
566   return ERROR_NOT_SUPPORTED;
567 }
568
569
570 /******************************************************************
571  *    EnableRouter (IPHLPAPI.@)
572  *
573  * Turn on ip forwarding.
574  *
575  * PARAMS
576  *  pHandle     [In/Out]
577  *  pOverlapped [In/Out] hEvent member should contain a valid handle.
578  *
579  * RETURNS
580  *  Success: ERROR_IO_PENDING
581  *  Failure: error code from winerror.h
582  *
583  * FIXME
584  *  Stub, returns ERROR_NOT_SUPPORTED.
585  */
586 DWORD WINAPI EnableRouter(HANDLE * pHandle, OVERLAPPED * pOverlapped)
587 {
588   FIXME("(pHandle %p, pOverlapped %p): stub\n", pHandle, pOverlapped);
589   /* could echo "1" > /proc/net/sys/net/ipv4/ip_forward, not sure I want to
590      could map EACCESS to ERROR_ACCESS_DENIED, I suppose
591    */
592   return ERROR_NOT_SUPPORTED;
593 }
594
595
596 /******************************************************************
597  *    FlushIpNetTable (IPHLPAPI.@)
598  *
599  * Delete all ARP entries of an interface
600  *
601  * PARAMS
602  *  dwIfIndex [In] interface index
603  *
604  * RETURNS
605  *  Success: NO_ERROR
606  *  Failure: error code from winerror.h
607  *
608  * FIXME
609  *  Stub, returns ERROR_NOT_SUPPORTED.
610  */
611 DWORD WINAPI FlushIpNetTable(DWORD dwIfIndex)
612 {
613   FIXME("(dwIfIndex 0x%08x): stub\n", dwIfIndex);
614   /* this flushes the arp cache of the given index */
615   return ERROR_NOT_SUPPORTED;
616 }
617
618
619 /******************************************************************
620  *    GetAdapterIndex (IPHLPAPI.@)
621  *
622  * Get interface index from its name.
623  *
624  * PARAMS
625  *  AdapterName [In]  unicode string with the adapter name
626  *  IfIndex     [Out] returns found interface index
627  *
628  * RETURNS
629  *  Success: NO_ERROR
630  *  Failure: error code from winerror.h
631  */
632 DWORD WINAPI GetAdapterIndex(LPWSTR AdapterName, PULONG IfIndex)
633 {
634   char adapterName[MAX_ADAPTER_NAME];
635   int i;
636   DWORD ret;
637
638   TRACE("(AdapterName %p, IfIndex %p)\n", AdapterName, IfIndex);
639   /* The adapter name is guaranteed not to have any unicode characters, so
640    * this translation is never lossy */
641   for (i = 0; i < sizeof(adapterName) - 1 && AdapterName[i]; i++)
642     adapterName[i] = (char)AdapterName[i];
643   adapterName[i] = '\0';
644   ret = getInterfaceIndexByName(adapterName, IfIndex);
645   TRACE("returning %d\n", ret);
646   return ret;
647 }
648
649
650 /******************************************************************
651  *    GetAdaptersInfo (IPHLPAPI.@)
652  *
653  * Get information about adapters.
654  *
655  * PARAMS
656  *  pAdapterInfo [Out] buffer for adapter infos
657  *  pOutBufLen   [In]  length of output buffer
658  *
659  * RETURNS
660  *  Success: NO_ERROR
661  *  Failure: error code from winerror.h
662  */
663 DWORD WINAPI GetAdaptersInfo(PIP_ADAPTER_INFO pAdapterInfo, PULONG pOutBufLen)
664 {
665   DWORD ret;
666
667   TRACE("pAdapterInfo %p, pOutBufLen %p\n", pAdapterInfo, pOutBufLen);
668   if (!pOutBufLen)
669     ret = ERROR_INVALID_PARAMETER;
670   else {
671     DWORD numNonLoopbackInterfaces = getNumNonLoopbackInterfaces();
672
673     if (numNonLoopbackInterfaces > 0) {
674       DWORD numIPAddresses = getNumIPAddresses();
675       ULONG size;
676
677       /* This may slightly overestimate the amount of space needed, because
678        * the IP addresses include the loopback address, but it's easier
679        * to make sure there's more than enough space than to make sure there's
680        * precisely enough space.
681        */
682       size = sizeof(IP_ADAPTER_INFO) * numNonLoopbackInterfaces;
683       size += numIPAddresses  * sizeof(IP_ADDR_STRING); 
684       if (!pAdapterInfo || *pOutBufLen < size) {
685         *pOutBufLen = size;
686         ret = ERROR_BUFFER_OVERFLOW;
687       }
688       else {
689         InterfaceIndexTable *table = NULL;
690         PMIB_IPADDRTABLE ipAddrTable = NULL;
691         PMIB_IPFORWARDTABLE routeTable = NULL;
692
693         ret = getIPAddrTable(&ipAddrTable, GetProcessHeap(), 0);
694         if (!ret)
695           ret = getRouteTable(&routeTable, GetProcessHeap(), 0);
696         if (!ret)
697           table = getNonLoopbackInterfaceIndexTable();
698         if (table) {
699           size = sizeof(IP_ADAPTER_INFO) * table->numIndexes;
700           size += ipAddrTable->dwNumEntries * sizeof(IP_ADDR_STRING); 
701           if (*pOutBufLen < size) {
702             *pOutBufLen = size;
703             ret = ERROR_INSUFFICIENT_BUFFER;
704           }
705           else {
706             DWORD ndx;
707             HKEY hKey;
708             BOOL winsEnabled = FALSE;
709             IP_ADDRESS_STRING primaryWINS, secondaryWINS;
710             PIP_ADDR_STRING nextIPAddr = (PIP_ADDR_STRING)((LPBYTE)pAdapterInfo
711              + numNonLoopbackInterfaces * sizeof(IP_ADAPTER_INFO));
712
713             memset(pAdapterInfo, 0, size);
714             /* @@ Wine registry key: HKCU\Software\Wine\Network */
715             if (RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Network",
716              &hKey) == ERROR_SUCCESS) {
717               DWORD size = sizeof(primaryWINS.String);
718               unsigned long addr;
719
720               RegQueryValueExA(hKey, "WinsServer", NULL, NULL,
721                (LPBYTE)primaryWINS.String, &size);
722               addr = inet_addr(primaryWINS.String);
723               if (addr != INADDR_NONE && addr != INADDR_ANY)
724                 winsEnabled = TRUE;
725               size = sizeof(secondaryWINS.String);
726               RegQueryValueExA(hKey, "BackupWinsServer", NULL, NULL,
727                (LPBYTE)secondaryWINS.String, &size);
728               addr = inet_addr(secondaryWINS.String);
729               if (addr != INADDR_NONE && addr != INADDR_ANY)
730                 winsEnabled = TRUE;
731               RegCloseKey(hKey);
732             }
733             for (ndx = 0; ndx < table->numIndexes; ndx++) {
734               PIP_ADAPTER_INFO ptr = &pAdapterInfo[ndx];
735               DWORD i;
736               PIP_ADDR_STRING currentIPAddr = &ptr->IpAddressList;
737               BOOL firstIPAddr = TRUE;
738
739               /* on Win98 this is left empty, but whatever */
740               getInterfaceNameByIndex(table->indexes[ndx], ptr->AdapterName);
741               getInterfaceNameByIndex(table->indexes[ndx], ptr->Description);
742               ptr->AddressLength = sizeof(ptr->Address);
743               getInterfacePhysicalByIndex(table->indexes[ndx],
744                &ptr->AddressLength, ptr->Address, &ptr->Type);
745               ptr->Index = table->indexes[ndx];
746               for (i = 0; i < ipAddrTable->dwNumEntries; i++) {
747                 if (ipAddrTable->table[i].dwIndex == ptr->Index) {
748                   if (firstIPAddr) {
749                     toIPAddressString(ipAddrTable->table[i].dwAddr,
750                      ptr->IpAddressList.IpAddress.String);
751                     toIPAddressString(ipAddrTable->table[i].dwMask,
752                      ptr->IpAddressList.IpMask.String);
753                     firstIPAddr = FALSE;
754                   }
755                   else {
756                     currentIPAddr->Next = nextIPAddr;
757                     currentIPAddr = nextIPAddr;
758                     toIPAddressString(ipAddrTable->table[i].dwAddr,
759                      currentIPAddr->IpAddress.String);
760                     toIPAddressString(ipAddrTable->table[i].dwMask,
761                      currentIPAddr->IpMask.String);
762                     nextIPAddr++;
763                   }
764                 }
765               }
766               /* Find first router through this interface, which we'll assume
767                * is the default gateway for this adapter */
768               for (i = 0; i < routeTable->dwNumEntries; i++)
769                 if (routeTable->table[i].dwForwardIfIndex == ptr->Index
770                  && routeTable->table[i].dwForwardType ==
771                  MIB_IPROUTE_TYPE_INDIRECT)
772                   toIPAddressString(routeTable->table[i].dwForwardNextHop,
773                    ptr->GatewayList.IpAddress.String);
774               if (winsEnabled) {
775                 ptr->HaveWins = TRUE;
776                 memcpy(ptr->PrimaryWinsServer.IpAddress.String,
777                  primaryWINS.String, sizeof(primaryWINS.String));
778                 memcpy(ptr->SecondaryWinsServer.IpAddress.String,
779                  secondaryWINS.String, sizeof(secondaryWINS.String));
780               }
781               if (ndx < table->numIndexes - 1)
782                 ptr->Next = &pAdapterInfo[ndx + 1];
783               else
784                 ptr->Next = NULL;
785             }
786             ret = NO_ERROR;
787           }
788           HeapFree(GetProcessHeap(), 0, table);
789         }
790         else
791           ret = ERROR_OUTOFMEMORY;
792         HeapFree(GetProcessHeap(), 0, routeTable);
793         HeapFree(GetProcessHeap(), 0, ipAddrTable);
794       }
795     }
796     else
797       ret = ERROR_NO_DATA;
798   }
799   TRACE("returning %d\n", ret);
800   return ret;
801 }
802
803
804 /******************************************************************
805  *    GetBestInterface (IPHLPAPI.@)
806  *
807  * Get the interface, with the best route for the given IP address.
808  *
809  * PARAMS
810  *  dwDestAddr     [In]  IP address to search the interface for
811  *  pdwBestIfIndex [Out] found best interface
812  *
813  * RETURNS
814  *  Success: NO_ERROR
815  *  Failure: error code from winerror.h
816  */
817 DWORD WINAPI GetBestInterface(IPAddr dwDestAddr, PDWORD pdwBestIfIndex)
818 {
819     struct WS_sockaddr_in sa_in;
820     memset(&sa_in, 0, sizeof(sa_in));
821     sa_in.sin_family = AF_INET;
822     sa_in.sin_addr.S_un.S_addr = dwDestAddr;
823     return GetBestInterfaceEx((struct WS_sockaddr *)&sa_in, pdwBestIfIndex);
824 }
825
826 /******************************************************************
827  *    GetBestInterfaceEx (IPHLPAPI.@)
828  *
829  * Get the interface, with the best route for the given IP address.
830  *
831  * PARAMS
832  *  dwDestAddr     [In]  IP address to search the interface for
833  *  pdwBestIfIndex [Out] found best interface
834  *
835  * RETURNS
836  *  Success: NO_ERROR
837  *  Failure: error code from winerror.h
838  */
839 DWORD WINAPI GetBestInterfaceEx(struct WS_sockaddr *pDestAddr, PDWORD pdwBestIfIndex)
840 {
841   DWORD ret;
842
843   TRACE("pDestAddr %p, pdwBestIfIndex %p\n", pDestAddr, pdwBestIfIndex);
844   if (!pDestAddr || !pdwBestIfIndex)
845     ret = ERROR_INVALID_PARAMETER;
846   else {
847     MIB_IPFORWARDROW ipRow;
848
849     if (pDestAddr->sa_family == AF_INET) {
850       ret = GetBestRoute(((struct WS_sockaddr_in *)pDestAddr)->sin_addr.S_un.S_addr, 0, &ipRow);
851       if (ret == ERROR_SUCCESS)
852         *pdwBestIfIndex = ipRow.dwForwardIfIndex;
853     } else {
854       FIXME("address family %d not supported\n", pDestAddr->sa_family);
855       ret = ERROR_NOT_SUPPORTED;
856     }
857   }
858   TRACE("returning %d\n", ret);
859   return ret;
860 }
861
862
863 /******************************************************************
864  *    GetBestRoute (IPHLPAPI.@)
865  *
866  * Get the best route for the given IP address.
867  *
868  * PARAMS
869  *  dwDestAddr   [In]  IP address to search the best route for
870  *  dwSourceAddr [In]  optional source IP address
871  *  pBestRoute   [Out] found best route
872  *
873  * RETURNS
874  *  Success: NO_ERROR
875  *  Failure: error code from winerror.h
876  */
877 DWORD WINAPI GetBestRoute(DWORD dwDestAddr, DWORD dwSourceAddr, PMIB_IPFORWARDROW pBestRoute)
878 {
879   PMIB_IPFORWARDTABLE table;
880   DWORD ret;
881
882   TRACE("dwDestAddr 0x%08x, dwSourceAddr 0x%08x, pBestRoute %p\n", dwDestAddr,
883    dwSourceAddr, pBestRoute);
884   if (!pBestRoute)
885     return ERROR_INVALID_PARAMETER;
886
887   ret = AllocateAndGetIpForwardTableFromStack(&table, FALSE, GetProcessHeap(), 0);
888   if (!ret) {
889     DWORD ndx, matchedBits, matchedNdx = table->dwNumEntries;
890
891     for (ndx = 0, matchedBits = 0; ndx < table->dwNumEntries; ndx++) {
892       if (table->table[ndx].dwForwardType != MIB_IPROUTE_TYPE_INVALID &&
893        (dwDestAddr & table->table[ndx].dwForwardMask) ==
894        (table->table[ndx].dwForwardDest & table->table[ndx].dwForwardMask)) {
895         DWORD numShifts, mask;
896
897         for (numShifts = 0, mask = table->table[ndx].dwForwardMask;
898          mask && !(mask & 1); mask >>= 1, numShifts++)
899           ;
900         if (numShifts > matchedBits) {
901           matchedBits = numShifts;
902           matchedNdx = ndx;
903         }
904         else if (!matchedBits && table->table[ndx].dwForwardType ==
905          MIB_IPROUTE_TYPE_INDIRECT) {
906           /* default to a default gateway */
907           matchedNdx = ndx;
908         }
909       }
910     }
911     if (matchedNdx < table->dwNumEntries) {
912       memcpy(pBestRoute, &table->table[matchedNdx], sizeof(MIB_IPFORWARDROW));
913       ret = ERROR_SUCCESS;
914     }
915     else {
916       /* No route matches, which can happen if there's no default route. */
917       ret = ERROR_HOST_UNREACHABLE;
918     }
919     HeapFree(GetProcessHeap(), 0, table);
920   }
921   TRACE("returning %d\n", ret);
922   return ret;
923 }
924
925
926 /******************************************************************
927  *    GetFriendlyIfIndex (IPHLPAPI.@)
928  *
929  * Get a "friendly" version of IfIndex, which is one that doesn't
930  * have the top byte set.  Doesn't validate whether IfIndex is a valid
931  * adapter index.
932  *
933  * PARAMS
934  *  IfIndex [In] interface index to get the friendly one for
935  *
936  * RETURNS
937  *  A friendly version of IfIndex.
938  */
939 DWORD WINAPI GetFriendlyIfIndex(DWORD IfIndex)
940 {
941   /* windows doesn't validate these, either, just makes sure the top byte is
942      cleared.  I assume my ifenum module never gives an index with the top
943      byte set. */
944   TRACE("returning %d\n", IfIndex);
945   return IfIndex;
946 }
947
948
949 /******************************************************************
950  *    GetIcmpStatistics (IPHLPAPI.@)
951  *
952  * Get the ICMP statistics for the local computer.
953  *
954  * PARAMS
955  *  pStats [Out] buffer for ICMP statistics
956  *
957  * RETURNS
958  *  Success: NO_ERROR
959  *  Failure: error code from winerror.h
960  */
961 DWORD WINAPI GetIcmpStatistics(PMIB_ICMP pStats)
962 {
963   DWORD ret;
964
965   TRACE("pStats %p\n", pStats);
966   ret = getICMPStats(pStats);
967   TRACE("returning %d\n", ret);
968   return ret;
969 }
970
971
972 /******************************************************************
973  *    GetIfEntry (IPHLPAPI.@)
974  *
975  * Get information about an interface.
976  *
977  * PARAMS
978  *  pIfRow [In/Out] In:  dwIndex of MIB_IFROW selects the interface.
979  *                  Out: interface information
980  *
981  * RETURNS
982  *  Success: NO_ERROR
983  *  Failure: error code from winerror.h
984  */
985 DWORD WINAPI GetIfEntry(PMIB_IFROW pIfRow)
986 {
987   DWORD ret;
988   char nameBuf[MAX_ADAPTER_NAME];
989   char *name;
990
991   TRACE("pIfRow %p\n", pIfRow);
992   if (!pIfRow)
993     return ERROR_INVALID_PARAMETER;
994
995   name = getInterfaceNameByIndex(pIfRow->dwIndex, nameBuf);
996   if (name) {
997     ret = getInterfaceEntryByName(name, pIfRow);
998     if (ret == NO_ERROR)
999       ret = getInterfaceStatsByName(name, pIfRow);
1000   }
1001   else
1002     ret = ERROR_INVALID_DATA;
1003   TRACE("returning %d\n", ret);
1004   return ret;
1005 }
1006
1007
1008 static int IfTableSorter(const void *a, const void *b)
1009 {
1010   int ret;
1011
1012   if (a && b)
1013     ret = ((const MIB_IFROW*)a)->dwIndex - ((const MIB_IFROW*)b)->dwIndex;
1014   else
1015     ret = 0;
1016   return ret;
1017 }
1018
1019
1020 /******************************************************************
1021  *    GetIfTable (IPHLPAPI.@)
1022  *
1023  * Get a table of local interfaces.
1024  *
1025  * PARAMS
1026  *  pIfTable [Out]    buffer for local interfaces table
1027  *  pdwSize  [In/Out] length of output buffer
1028  *  bOrder   [In]     whether to sort the table
1029  *
1030  * RETURNS
1031  *  Success: NO_ERROR
1032  *  Failure: error code from winerror.h
1033  *
1034  * NOTES
1035  *  If pdwSize is less than required, the function will return
1036  *  ERROR_INSUFFICIENT_BUFFER, and *pdwSize will be set to the required byte
1037  *  size.
1038  *  If bOrder is true, the returned table will be sorted by interface index.
1039  */
1040 DWORD WINAPI GetIfTable(PMIB_IFTABLE pIfTable, PULONG pdwSize, BOOL bOrder)
1041 {
1042   DWORD ret;
1043
1044   TRACE("pIfTable %p, pdwSize %p, bOrder %d\n", pdwSize, pdwSize,
1045    (DWORD)bOrder);
1046   if (!pdwSize)
1047     ret = ERROR_INVALID_PARAMETER;
1048   else {
1049     DWORD numInterfaces = getNumInterfaces();
1050     ULONG size = sizeof(MIB_IFTABLE);
1051
1052     if (numInterfaces > 1)
1053       size += (numInterfaces - 1) * sizeof(MIB_IFROW);
1054     if (!pIfTable || *pdwSize < size) {
1055       *pdwSize = size;
1056       ret = ERROR_INSUFFICIENT_BUFFER;
1057     }
1058     else {
1059       InterfaceIndexTable *table = getInterfaceIndexTable();
1060
1061       if (table) {
1062         size = sizeof(MIB_IFTABLE);
1063         if (table->numIndexes > 1)
1064           size += (table->numIndexes - 1) * sizeof(MIB_IFROW);
1065         if (*pdwSize < size) {
1066           *pdwSize = size;
1067           ret = ERROR_INSUFFICIENT_BUFFER;
1068         }
1069         else {
1070           DWORD ndx;
1071
1072           *pdwSize = size;
1073           pIfTable->dwNumEntries = 0;
1074           for (ndx = 0; ndx < table->numIndexes; ndx++) {
1075             pIfTable->table[ndx].dwIndex = table->indexes[ndx];
1076             GetIfEntry(&pIfTable->table[ndx]);
1077             pIfTable->dwNumEntries++;
1078           }
1079           if (bOrder)
1080             qsort(pIfTable->table, pIfTable->dwNumEntries, sizeof(MIB_IFROW),
1081              IfTableSorter);
1082           ret = NO_ERROR;
1083         }
1084         HeapFree(GetProcessHeap(), 0, table);
1085       }
1086       else
1087         ret = ERROR_OUTOFMEMORY;
1088     }
1089   }
1090   TRACE("returning %d\n", ret);
1091   return ret;
1092 }
1093
1094
1095 /******************************************************************
1096  *    GetInterfaceInfo (IPHLPAPI.@)
1097  *
1098  * Get a list of network interface adapters.
1099  *
1100  * PARAMS
1101  *  pIfTable    [Out] buffer for interface adapters
1102  *  dwOutBufLen [Out] if buffer is too small, returns required size
1103  *
1104  * RETURNS
1105  *  Success: NO_ERROR
1106  *  Failure: error code from winerror.h
1107  *
1108  * BUGS
1109  *  MSDN states this should return non-loopback interfaces only.
1110  */
1111 DWORD WINAPI GetInterfaceInfo(PIP_INTERFACE_INFO pIfTable, PULONG dwOutBufLen)
1112 {
1113   DWORD ret;
1114
1115   TRACE("pIfTable %p, dwOutBufLen %p\n", pIfTable, dwOutBufLen);
1116   if (!dwOutBufLen)
1117     ret = ERROR_INVALID_PARAMETER;
1118   else {
1119     DWORD numInterfaces = getNumInterfaces();
1120     ULONG size = sizeof(IP_INTERFACE_INFO);
1121
1122     if (numInterfaces > 1)
1123       size += (numInterfaces - 1) * sizeof(IP_ADAPTER_INDEX_MAP);
1124     if (!pIfTable || *dwOutBufLen < size) {
1125       *dwOutBufLen = size;
1126       ret = ERROR_INSUFFICIENT_BUFFER;
1127     }
1128     else {
1129       InterfaceIndexTable *table = getInterfaceIndexTable();
1130
1131       if (table) {
1132         size = sizeof(IP_INTERFACE_INFO);
1133         if (table->numIndexes > 1)
1134           size += (table->numIndexes - 1) * sizeof(IP_ADAPTER_INDEX_MAP);
1135         if (*dwOutBufLen < size) {
1136           *dwOutBufLen = size;
1137           ret = ERROR_INSUFFICIENT_BUFFER;
1138         }
1139         else {
1140           DWORD ndx;
1141           char nameBuf[MAX_ADAPTER_NAME];
1142
1143           *dwOutBufLen = size;
1144           pIfTable->NumAdapters = 0;
1145           for (ndx = 0; ndx < table->numIndexes; ndx++) {
1146             const char *walker, *name;
1147             WCHAR *assigner;
1148
1149             pIfTable->Adapter[ndx].Index = table->indexes[ndx];
1150             name = getInterfaceNameByIndex(table->indexes[ndx], nameBuf);
1151             for (walker = name, assigner = pIfTable->Adapter[ndx].Name;
1152              walker && *walker &&
1153              assigner - pIfTable->Adapter[ndx].Name < MAX_ADAPTER_NAME - 1;
1154              walker++, assigner++)
1155               *assigner = *walker;
1156             *assigner = 0;
1157             pIfTable->NumAdapters++;
1158           }
1159           ret = NO_ERROR;
1160         }
1161         HeapFree(GetProcessHeap(), 0, table);
1162       }
1163       else
1164         ret = ERROR_OUTOFMEMORY;
1165     }
1166   }
1167   TRACE("returning %d\n", ret);
1168   return ret;
1169 }
1170
1171
1172 /******************************************************************
1173  *    GetIpAddrTable (IPHLPAPI.@)
1174  *
1175  * Get interface-to-IP address mapping table. 
1176  *
1177  * PARAMS
1178  *  pIpAddrTable [Out]    buffer for mapping table
1179  *  pdwSize      [In/Out] length of output buffer
1180  *  bOrder       [In]     whether to sort the table
1181  *
1182  * RETURNS
1183  *  Success: NO_ERROR
1184  *  Failure: error code from winerror.h
1185  *
1186  * NOTES
1187  *  If pdwSize is less than required, the function will return
1188  *  ERROR_INSUFFICIENT_BUFFER, and *pdwSize will be set to the required byte
1189  *  size.
1190  *  If bOrder is true, the returned table will be sorted by the next hop and
1191  *  an assortment of arbitrary parameters.
1192  */
1193 DWORD WINAPI GetIpAddrTable(PMIB_IPADDRTABLE pIpAddrTable, PULONG pdwSize, BOOL bOrder)
1194 {
1195   DWORD ret;
1196
1197   TRACE("pIpAddrTable %p, pdwSize %p, bOrder %d\n", pIpAddrTable, pdwSize,
1198    (DWORD)bOrder);
1199   if (!pdwSize)
1200     ret = ERROR_INVALID_PARAMETER;
1201   else {
1202     PMIB_IPADDRTABLE table;
1203
1204     ret = getIPAddrTable(&table, GetProcessHeap(), 0);
1205     if (ret == NO_ERROR)
1206     {
1207       ULONG size = sizeof(MIB_IPADDRTABLE);
1208
1209       if (table->dwNumEntries > 1)
1210         size += (table->dwNumEntries - 1) * sizeof(MIB_IPADDRROW);
1211       if (!pIpAddrTable || *pdwSize < size) {
1212         *pdwSize = size;
1213         ret = ERROR_INSUFFICIENT_BUFFER;
1214       }
1215       else {
1216         *pdwSize = size;
1217         memcpy(pIpAddrTable, table, size);
1218         if (bOrder)
1219           qsort(pIpAddrTable->table, pIpAddrTable->dwNumEntries,
1220            sizeof(MIB_IPADDRROW), IpAddrTableSorter);
1221         ret = NO_ERROR;
1222       }
1223       HeapFree(GetProcessHeap(), 0, table);
1224     }
1225   }
1226   TRACE("returning %d\n", ret);
1227   return ret;
1228 }
1229
1230
1231 /******************************************************************
1232  *    GetIpForwardTable (IPHLPAPI.@)
1233  *
1234  * Get the route table.
1235  *
1236  * PARAMS
1237  *  pIpForwardTable [Out]    buffer for route table
1238  *  pdwSize         [In/Out] length of output buffer
1239  *  bOrder          [In]     whether to sort the table
1240  *
1241  * RETURNS
1242  *  Success: NO_ERROR
1243  *  Failure: error code from winerror.h
1244  *
1245  * NOTES
1246  *  If pdwSize is less than required, the function will return
1247  *  ERROR_INSUFFICIENT_BUFFER, and *pdwSize will be set to the required byte
1248  *  size.
1249  *  If bOrder is true, the returned table will be sorted by the next hop and
1250  *  an assortment of arbitrary parameters.
1251  */
1252 DWORD WINAPI GetIpForwardTable(PMIB_IPFORWARDTABLE pIpForwardTable, PULONG pdwSize, BOOL bOrder)
1253 {
1254   DWORD ret;
1255
1256   TRACE("pIpForwardTable %p, pdwSize %p, bOrder %d\n", pIpForwardTable,
1257    pdwSize, (DWORD)bOrder);
1258   if (!pdwSize)
1259     ret = ERROR_INVALID_PARAMETER;
1260   else {
1261     DWORD numRoutes = getNumRoutes();
1262     ULONG sizeNeeded = sizeof(MIB_IPFORWARDTABLE);
1263
1264     if (numRoutes > 1)
1265       sizeNeeded += (numRoutes - 1) * sizeof(MIB_IPFORWARDROW);
1266     if (!pIpForwardTable || *pdwSize < sizeNeeded) {
1267       *pdwSize = sizeNeeded;
1268       ret = ERROR_INSUFFICIENT_BUFFER;
1269     }
1270     else {
1271       PMIB_IPFORWARDTABLE table;
1272
1273       ret = getRouteTable(&table, GetProcessHeap(), 0);
1274       if (!ret) {
1275         sizeNeeded = sizeof(MIB_IPFORWARDTABLE);
1276         if (table->dwNumEntries > 1)
1277           sizeNeeded += (table->dwNumEntries - 1) * sizeof(MIB_IPFORWARDROW);
1278         if (*pdwSize < sizeNeeded) {
1279           *pdwSize = sizeNeeded;
1280           ret = ERROR_INSUFFICIENT_BUFFER;
1281         }
1282         else {
1283           *pdwSize = sizeNeeded;
1284           memcpy(pIpForwardTable, table, sizeNeeded);
1285           if (bOrder)
1286             qsort(pIpForwardTable->table, pIpForwardTable->dwNumEntries,
1287              sizeof(MIB_IPFORWARDROW), IpForwardTableSorter);
1288           ret = NO_ERROR;
1289         }
1290         HeapFree(GetProcessHeap(), 0, table);
1291       }
1292     }
1293   }
1294   TRACE("returning %d\n", ret);
1295   return ret;
1296 }
1297
1298
1299 /******************************************************************
1300  *    GetIpNetTable (IPHLPAPI.@)
1301  *
1302  * Get the IP-to-physical address mapping table.
1303  *
1304  * PARAMS
1305  *  pIpNetTable [Out]    buffer for mapping table
1306  *  pdwSize     [In/Out] length of output buffer
1307  *  bOrder      [In]     whether to sort the table
1308  *
1309  * RETURNS
1310  *  Success: NO_ERROR
1311  *  Failure: error code from winerror.h
1312  *
1313  * NOTES
1314  *  If pdwSize is less than required, the function will return
1315  *  ERROR_INSUFFICIENT_BUFFER, and *pdwSize will be set to the required byte
1316  *  size.
1317  *  If bOrder is true, the returned table will be sorted by IP address.
1318  */
1319 DWORD WINAPI GetIpNetTable(PMIB_IPNETTABLE pIpNetTable, PULONG pdwSize, BOOL bOrder)
1320 {
1321   DWORD ret;
1322
1323   TRACE("pIpNetTable %p, pdwSize %p, bOrder %d\n", pIpNetTable, pdwSize,
1324    (DWORD)bOrder);
1325   if (!pdwSize)
1326     ret = ERROR_INVALID_PARAMETER;
1327   else {
1328     DWORD numEntries = getNumArpEntries();
1329     ULONG size = sizeof(MIB_IPNETTABLE);
1330
1331     if (numEntries > 1)
1332       size += (numEntries - 1) * sizeof(MIB_IPNETROW);
1333     if (!pIpNetTable || *pdwSize < size) {
1334       *pdwSize = size;
1335       ret = ERROR_INSUFFICIENT_BUFFER;
1336     }
1337     else {
1338       PMIB_IPNETTABLE table;
1339
1340       ret = getArpTable(&table, GetProcessHeap(), 0);
1341       if (!ret) {
1342         size = sizeof(MIB_IPNETTABLE);
1343         if (table->dwNumEntries > 1)
1344           size += (table->dwNumEntries - 1) * sizeof(MIB_IPNETROW);
1345         if (*pdwSize < size) {
1346           *pdwSize = size;
1347           ret = ERROR_INSUFFICIENT_BUFFER;
1348         }
1349         else {
1350           *pdwSize = size;
1351           memcpy(pIpNetTable, table, size);
1352           if (bOrder)
1353             qsort(pIpNetTable->table, pIpNetTable->dwNumEntries,
1354              sizeof(MIB_IPNETROW), IpNetTableSorter);
1355           ret = NO_ERROR;
1356         }
1357         HeapFree(GetProcessHeap(), 0, table);
1358       }
1359     }
1360   }
1361   TRACE("returning %d\n", ret);
1362   return ret;
1363 }
1364
1365
1366 /******************************************************************
1367  *    GetIpStatistics (IPHLPAPI.@)
1368  *
1369  * Get the IP statistics for the local computer.
1370  *
1371  * PARAMS
1372  *  pStats [Out] buffer for IP statistics
1373  *
1374  * RETURNS
1375  *  Success: NO_ERROR
1376  *  Failure: error code from winerror.h
1377  */
1378 DWORD WINAPI GetIpStatistics(PMIB_IPSTATS pStats)
1379 {
1380   DWORD ret;
1381
1382   TRACE("pStats %p\n", pStats);
1383   ret = getIPStats(pStats);
1384   TRACE("returning %d\n", ret);
1385   return ret;
1386 }
1387
1388
1389 /******************************************************************
1390  *    GetNetworkParams (IPHLPAPI.@)
1391  *
1392  * Get the network parameters for the local computer.
1393  *
1394  * PARAMS
1395  *  pFixedInfo [Out]    buffer for network parameters
1396  *  pOutBufLen [In/Out] length of output buffer
1397  *
1398  * RETURNS
1399  *  Success: NO_ERROR
1400  *  Failure: error code from winerror.h
1401  *
1402  * NOTES
1403  *  If pOutBufLen is less than required, the function will return
1404  *  ERROR_INSUFFICIENT_BUFFER, and pOutBufLen will be set to the required byte
1405  *  size.
1406  */
1407 DWORD WINAPI GetNetworkParams(PFIXED_INFO pFixedInfo, PULONG pOutBufLen)
1408 {
1409   DWORD ret, size;
1410   LONG regReturn;
1411   HKEY hKey;
1412
1413   TRACE("pFixedInfo %p, pOutBufLen %p\n", pFixedInfo, pOutBufLen);
1414   if (!pOutBufLen)
1415     return ERROR_INVALID_PARAMETER;
1416
1417   initialise_resolver();
1418   size = sizeof(FIXED_INFO) + (_res.nscount > 0 ? (_res.nscount  - 1) *
1419    sizeof(IP_ADDR_STRING) : 0);
1420   if (!pFixedInfo || *pOutBufLen < size) {
1421     *pOutBufLen = size;
1422     return ERROR_BUFFER_OVERFLOW;
1423   }
1424
1425   memset(pFixedInfo, 0, size);
1426   size = sizeof(pFixedInfo->HostName);
1427   GetComputerNameExA(ComputerNameDnsHostname, pFixedInfo->HostName, &size);
1428   size = sizeof(pFixedInfo->DomainName);
1429   GetComputerNameExA(ComputerNameDnsDomain, pFixedInfo->DomainName, &size);
1430   if (_res.nscount > 0) {
1431     PIP_ADDR_STRING ptr;
1432     int i;
1433
1434     for (i = 0, ptr = &pFixedInfo->DnsServerList; i < _res.nscount && ptr;
1435      i++, ptr = ptr->Next) {
1436       toIPAddressString(_res.nsaddr_list[i].sin_addr.s_addr,
1437        ptr->IpAddress.String);
1438       if (i == _res.nscount - 1)
1439         ptr->Next = NULL;
1440       else if (i == 0)
1441         ptr->Next = (PIP_ADDR_STRING)((LPBYTE)pFixedInfo + sizeof(FIXED_INFO));
1442       else
1443         ptr->Next = (PIP_ADDR_STRING)((PBYTE)ptr + sizeof(IP_ADDR_STRING));
1444     }
1445   }
1446   pFixedInfo->NodeType = HYBRID_NODETYPE;
1447   regReturn = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
1448    "SYSTEM\\CurrentControlSet\\Services\\VxD\\MSTCP", 0, KEY_READ, &hKey);
1449   if (regReturn != ERROR_SUCCESS)
1450     regReturn = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
1451      "SYSTEM\\CurrentControlSet\\Services\\NetBT\\Parameters", 0, KEY_READ,
1452      &hKey);
1453   if (regReturn == ERROR_SUCCESS)
1454   {
1455     DWORD size = sizeof(pFixedInfo->ScopeId);
1456
1457     RegQueryValueExA(hKey, "ScopeID", NULL, NULL, (LPBYTE)pFixedInfo->ScopeId, &size);
1458     RegCloseKey(hKey);
1459   }
1460
1461   /* FIXME: can check whether routing's enabled in /proc/sys/net/ipv4/ip_forward
1462      I suppose could also check for a listener on port 53 to set EnableDns */
1463   ret = NO_ERROR;
1464   TRACE("returning %d\n", ret);
1465   return ret;
1466 }
1467
1468
1469 /******************************************************************
1470  *    GetNumberOfInterfaces (IPHLPAPI.@)
1471  *
1472  * Get the number of interfaces.
1473  *
1474  * PARAMS
1475  *  pdwNumIf [Out] number of interfaces
1476  *
1477  * RETURNS
1478  *  NO_ERROR on success, ERROR_INVALID_PARAMETER if pdwNumIf is NULL.
1479  */
1480 DWORD WINAPI GetNumberOfInterfaces(PDWORD pdwNumIf)
1481 {
1482   DWORD ret;
1483
1484   TRACE("pdwNumIf %p\n", pdwNumIf);
1485   if (!pdwNumIf)
1486     ret = ERROR_INVALID_PARAMETER;
1487   else {
1488     *pdwNumIf = getNumInterfaces();
1489     ret = NO_ERROR;
1490   }
1491   TRACE("returning %d\n", ret);
1492   return ret;
1493 }
1494
1495
1496 /******************************************************************
1497  *    GetPerAdapterInfo (IPHLPAPI.@)
1498  *
1499  * Get information about an adapter corresponding to an interface.
1500  *
1501  * PARAMS
1502  *  IfIndex         [In]     interface info
1503  *  pPerAdapterInfo [Out]    buffer for per adapter info
1504  *  pOutBufLen      [In/Out] length of output buffer
1505  *
1506  * RETURNS
1507  *  Success: NO_ERROR
1508  *  Failure: error code from winerror.h
1509  *
1510  * FIXME
1511  *  Stub, returns empty IP_PER_ADAPTER_INFO in every case.
1512  */
1513 DWORD WINAPI GetPerAdapterInfo(ULONG IfIndex, PIP_PER_ADAPTER_INFO pPerAdapterInfo, PULONG pOutBufLen)
1514 {
1515   ULONG bytesNeeded = sizeof(IP_PER_ADAPTER_INFO);
1516
1517   TRACE("(IfIndex %d, pPerAdapterInfo %p, pOutBufLen %p)\n", IfIndex, pPerAdapterInfo, pOutBufLen);
1518
1519   if (!pOutBufLen) return ERROR_INVALID_PARAMETER;
1520
1521   if (!pPerAdapterInfo || *pOutBufLen < bytesNeeded)
1522   {
1523     *pOutBufLen = bytesNeeded;
1524     return ERROR_BUFFER_OVERFLOW;
1525   }
1526
1527   memset(pPerAdapterInfo, 0, bytesNeeded);
1528   return NO_ERROR;
1529 }
1530
1531
1532 /******************************************************************
1533  *    GetRTTAndHopCount (IPHLPAPI.@)
1534  *
1535  * Get round-trip time (RTT) and hop count.
1536  *
1537  * PARAMS
1538  *
1539  *  DestIpAddress [In]  destination address to get the info for
1540  *  HopCount      [Out] retrieved hop count
1541  *  MaxHops       [In]  maximum hops to search for the destination
1542  *  RTT           [Out] RTT in milliseconds
1543  *
1544  * RETURNS
1545  *  Success: TRUE
1546  *  Failure: FALSE
1547  *
1548  * FIXME
1549  *  Stub, returns FALSE.
1550  */
1551 BOOL WINAPI GetRTTAndHopCount(IPAddr DestIpAddress, PULONG HopCount, ULONG MaxHops, PULONG RTT)
1552 {
1553   FIXME("(DestIpAddress 0x%08lx, HopCount %p, MaxHops %d, RTT %p): stub\n",
1554    DestIpAddress, HopCount, MaxHops, RTT);
1555   return FALSE;
1556 }
1557
1558
1559 /******************************************************************
1560  *    GetTcpStatistics (IPHLPAPI.@)
1561  *
1562  * Get the TCP statistics for the local computer.
1563  *
1564  * PARAMS
1565  *  pStats [Out] buffer for TCP statistics
1566  *
1567  * RETURNS
1568  *  Success: NO_ERROR
1569  *  Failure: error code from winerror.h
1570  */
1571 DWORD WINAPI GetTcpStatistics(PMIB_TCPSTATS pStats)
1572 {
1573   DWORD ret;
1574
1575   TRACE("pStats %p\n", pStats);
1576   ret = getTCPStats(pStats);
1577   TRACE("returning %d\n", ret);
1578   return ret;
1579 }
1580
1581
1582 /******************************************************************
1583  *    GetTcpTable (IPHLPAPI.@)
1584  *
1585  * Get the table of active TCP connections.
1586  *
1587  * PARAMS
1588  *  pTcpTable [Out]    buffer for TCP connections table
1589  *  pdwSize   [In/Out] length of output buffer
1590  *  bOrder    [In]     whether to order the table
1591  *
1592  * RETURNS
1593  *  Success: NO_ERROR
1594  *  Failure: error code from winerror.h
1595  *
1596  * NOTES
1597  *  If pdwSize is less than required, the function will return 
1598  *  ERROR_INSUFFICIENT_BUFFER, and *pdwSize will be set to 
1599  *  the required byte size.
1600  *  If bOrder is true, the returned table will be sorted, first by
1601  *  local address and port number, then by remote address and port
1602  *  number.
1603  */
1604 DWORD WINAPI GetTcpTable(PMIB_TCPTABLE pTcpTable, PDWORD pdwSize, BOOL bOrder)
1605 {
1606   DWORD ret;
1607
1608   TRACE("pTcpTable %p, pdwSize %p, bOrder %d\n", pTcpTable, pdwSize,
1609    (DWORD)bOrder);
1610   if (!pdwSize)
1611     ret = ERROR_INVALID_PARAMETER;
1612   else {
1613     DWORD numEntries = getNumTcpEntries();
1614     DWORD size = sizeof(MIB_TCPTABLE);
1615
1616     if (numEntries > 1)
1617       size += (numEntries - 1) * sizeof(MIB_TCPROW);
1618     if (!pTcpTable || *pdwSize < size) {
1619       *pdwSize = size;
1620       ret = ERROR_INSUFFICIENT_BUFFER;
1621     }
1622     else {
1623       ret = getTcpTable(&pTcpTable, numEntries, 0, 0);
1624       if (!ret) {
1625         size = sizeof(MIB_TCPTABLE);
1626         if (pTcpTable->dwNumEntries > 1)
1627           size += (pTcpTable->dwNumEntries - 1) * sizeof(MIB_TCPROW);
1628         *pdwSize = size;
1629
1630         if (bOrder)
1631            qsort(pTcpTable->table, pTcpTable->dwNumEntries,
1632                  sizeof(MIB_TCPROW), TcpTableSorter);
1633         ret = NO_ERROR;
1634       }
1635     }
1636   }
1637   TRACE("returning %d\n", ret);
1638   return ret;
1639 }
1640
1641
1642 /******************************************************************
1643  *    GetUdpStatistics (IPHLPAPI.@)
1644  *
1645  * Get the UDP statistics for the local computer.
1646  *
1647  * PARAMS
1648  *  pStats [Out] buffer for UDP statistics
1649  *
1650  * RETURNS
1651  *  Success: NO_ERROR
1652  *  Failure: error code from winerror.h
1653  */
1654 DWORD WINAPI GetUdpStatistics(PMIB_UDPSTATS pStats)
1655 {
1656   DWORD ret;
1657
1658   TRACE("pStats %p\n", pStats);
1659   ret = getUDPStats(pStats);
1660   TRACE("returning %d\n", ret);
1661   return ret;
1662 }
1663
1664
1665 /******************************************************************
1666  *    GetUdpTable (IPHLPAPI.@)
1667  *
1668  * Get a table of active UDP connections.
1669  *
1670  * PARAMS
1671  *  pUdpTable [Out]    buffer for UDP connections table
1672  *  pdwSize   [In/Out] length of output buffer
1673  *  bOrder    [In]     whether to order the table
1674  *
1675  * RETURNS
1676  *  Success: NO_ERROR
1677  *  Failure: error code from winerror.h
1678  *
1679  * NOTES
1680  *  If pdwSize is less than required, the function will return 
1681  *  ERROR_INSUFFICIENT_BUFFER, and *pdwSize will be set to the
1682  *  required byte size.
1683  *  If bOrder is true, the returned table will be sorted, first by
1684  *  local address, then by local port number.
1685  */
1686 DWORD WINAPI GetUdpTable(PMIB_UDPTABLE pUdpTable, PDWORD pdwSize, BOOL bOrder)
1687 {
1688   DWORD ret;
1689
1690   TRACE("pUdpTable %p, pdwSize %p, bOrder %d\n", pUdpTable, pdwSize,
1691    (DWORD)bOrder);
1692   if (!pdwSize)
1693     ret = ERROR_INVALID_PARAMETER;
1694   else {
1695     DWORD numEntries = getNumUdpEntries();
1696     DWORD size = sizeof(MIB_UDPTABLE);
1697
1698     if (numEntries > 1)
1699       size += (numEntries - 1) * sizeof(MIB_UDPROW);
1700     if (!pUdpTable || *pdwSize < size) {
1701       *pdwSize = size;
1702       ret = ERROR_INSUFFICIENT_BUFFER;
1703     }
1704     else {
1705       PMIB_UDPTABLE table;
1706
1707       ret = getUdpTable(&table, GetProcessHeap(), 0);
1708       if (!ret) {
1709         size = sizeof(MIB_UDPTABLE);
1710         if (table->dwNumEntries > 1)
1711           size += (table->dwNumEntries - 1) * sizeof(MIB_UDPROW);
1712         if (*pdwSize < size) {
1713           *pdwSize = size;
1714           ret = ERROR_INSUFFICIENT_BUFFER;
1715         }
1716         else {
1717           *pdwSize = size;
1718           memcpy(pUdpTable, table, size);
1719           if (bOrder)
1720             qsort(pUdpTable->table, pUdpTable->dwNumEntries,
1721              sizeof(MIB_UDPROW), UdpTableSorter);
1722           ret = NO_ERROR;
1723         }
1724         HeapFree(GetProcessHeap(), 0, table);
1725       }
1726       else
1727         ret = ERROR_OUTOFMEMORY;
1728     }
1729   }
1730   TRACE("returning %d\n", ret);
1731   return ret;
1732 }
1733
1734
1735 /******************************************************************
1736  *    GetUniDirectionalAdapterInfo (IPHLPAPI.@)
1737  *
1738  * This is a Win98-only function to get information on "unidirectional"
1739  * adapters.  Since this is pretty nonsensical in other contexts, it
1740  * never returns anything.
1741  *
1742  * PARAMS
1743  *  pIPIfInfo   [Out] buffer for adapter infos
1744  *  dwOutBufLen [Out] length of the output buffer
1745  *
1746  * RETURNS
1747  *  Success: NO_ERROR
1748  *  Failure: error code from winerror.h
1749  *
1750  * FIXME
1751  *  Stub, returns ERROR_NOT_SUPPORTED.
1752  */
1753 DWORD WINAPI GetUniDirectionalAdapterInfo(PIP_UNIDIRECTIONAL_ADAPTER_ADDRESS pIPIfInfo, PULONG dwOutBufLen)
1754 {
1755   TRACE("pIPIfInfo %p, dwOutBufLen %p\n", pIPIfInfo, dwOutBufLen);
1756   /* a unidirectional adapter?? not bloody likely! */
1757   return ERROR_NOT_SUPPORTED;
1758 }
1759
1760
1761 /******************************************************************
1762  *    IpReleaseAddress (IPHLPAPI.@)
1763  *
1764  * Release an IP obtained through DHCP,
1765  *
1766  * PARAMS
1767  *  AdapterInfo [In] adapter to release IP address
1768  *
1769  * RETURNS
1770  *  Success: NO_ERROR
1771  *  Failure: error code from winerror.h
1772  *
1773  * NOTES
1774  *  Since GetAdaptersInfo never returns adapters that have DHCP enabled,
1775  *  this function does nothing.
1776  *
1777  * FIXME
1778  *  Stub, returns ERROR_NOT_SUPPORTED.
1779  */
1780 DWORD WINAPI IpReleaseAddress(PIP_ADAPTER_INDEX_MAP AdapterInfo)
1781 {
1782   TRACE("AdapterInfo %p\n", AdapterInfo);
1783   /* not a stub, never going to support this (and I never mark an adapter as
1784      DHCP enabled, see GetAdaptersInfo, so this should never get called) */
1785   return ERROR_NOT_SUPPORTED;
1786 }
1787
1788
1789 /******************************************************************
1790  *    IpRenewAddress (IPHLPAPI.@)
1791  *
1792  * Renew an IP obtained through DHCP.
1793  *
1794  * PARAMS
1795  *  AdapterInfo [In] adapter to renew IP address
1796  *
1797  * RETURNS
1798  *  Success: NO_ERROR
1799  *  Failure: error code from winerror.h
1800  *
1801  * NOTES
1802  *  Since GetAdaptersInfo never returns adapters that have DHCP enabled,
1803  *  this function does nothing.
1804  *
1805  * FIXME
1806  *  Stub, returns ERROR_NOT_SUPPORTED.
1807  */
1808 DWORD WINAPI IpRenewAddress(PIP_ADAPTER_INDEX_MAP AdapterInfo)
1809 {
1810   TRACE("AdapterInfo %p\n", AdapterInfo);
1811   /* not a stub, never going to support this (and I never mark an adapter as
1812      DHCP enabled, see GetAdaptersInfo, so this should never get called) */
1813   return ERROR_NOT_SUPPORTED;
1814 }
1815
1816
1817 /******************************************************************
1818  *    NotifyAddrChange (IPHLPAPI.@)
1819  *
1820  * Notify caller whenever the ip-interface map is changed.
1821  *
1822  * PARAMS
1823  *  Handle     [Out] handle usable in asynchronous notification
1824  *  overlapped [In]  overlapped structure that notifies the caller
1825  *
1826  * RETURNS
1827  *  Success: NO_ERROR
1828  *  Failure: error code from winerror.h
1829  *
1830  * FIXME
1831  *  Stub, returns ERROR_NOT_SUPPORTED.
1832  */
1833 DWORD WINAPI NotifyAddrChange(PHANDLE Handle, LPOVERLAPPED overlapped)
1834 {
1835   FIXME("(Handle %p, overlapped %p): stub\n", Handle, overlapped);
1836   return ERROR_NOT_SUPPORTED;
1837 }
1838
1839
1840 /******************************************************************
1841  *    NotifyRouteChange (IPHLPAPI.@)
1842  *
1843  * Notify caller whenever the ip routing table is changed.
1844  *
1845  * PARAMS
1846  *  Handle     [Out] handle usable in asynchronous notification
1847  *  overlapped [In]  overlapped structure that notifies the caller
1848  *
1849  * RETURNS
1850  *  Success: NO_ERROR
1851  *  Failure: error code from winerror.h
1852  *
1853  * FIXME
1854  *  Stub, returns ERROR_NOT_SUPPORTED.
1855  */
1856 DWORD WINAPI NotifyRouteChange(PHANDLE Handle, LPOVERLAPPED overlapped)
1857 {
1858   FIXME("(Handle %p, overlapped %p): stub\n", Handle, overlapped);
1859   return ERROR_NOT_SUPPORTED;
1860 }
1861
1862
1863 /******************************************************************
1864  *    SendARP (IPHLPAPI.@)
1865  *
1866  * Send an ARP request.
1867  *
1868  * PARAMS
1869  *  DestIP     [In]     attempt to obtain this IP
1870  *  SrcIP      [In]     optional sender IP address
1871  *  pMacAddr   [Out]    buffer for the mac address
1872  *  PhyAddrLen [In/Out] length of the output buffer
1873  *
1874  * RETURNS
1875  *  Success: NO_ERROR
1876  *  Failure: error code from winerror.h
1877  *
1878  * FIXME
1879  *  Stub, returns ERROR_NOT_SUPPORTED.
1880  */
1881 DWORD WINAPI SendARP(IPAddr DestIP, IPAddr SrcIP, PULONG pMacAddr, PULONG PhyAddrLen)
1882 {
1883   FIXME("(DestIP 0x%08lx, SrcIP 0x%08lx, pMacAddr %p, PhyAddrLen %p): stub\n",
1884    DestIP, SrcIP, pMacAddr, PhyAddrLen);
1885   return ERROR_NOT_SUPPORTED;
1886 }
1887
1888
1889 /******************************************************************
1890  *    SetIfEntry (IPHLPAPI.@)
1891  *
1892  * Set the administrative status of an interface.
1893  *
1894  * PARAMS
1895  *  pIfRow [In] dwAdminStatus member specifies the new status.
1896  *
1897  * RETURNS
1898  *  Success: NO_ERROR
1899  *  Failure: error code from winerror.h
1900  *
1901  * FIXME
1902  *  Stub, returns ERROR_NOT_SUPPORTED.
1903  */
1904 DWORD WINAPI SetIfEntry(PMIB_IFROW pIfRow)
1905 {
1906   FIXME("(pIfRow %p): stub\n", pIfRow);
1907   /* this is supposed to set an interface administratively up or down.
1908      Could do SIOCSIFFLAGS and set/clear IFF_UP, but, not sure I want to, and
1909      this sort of down is indistinguishable from other sorts of down (e.g. no
1910      link). */
1911   return ERROR_NOT_SUPPORTED;
1912 }
1913
1914
1915 /******************************************************************
1916  *    SetIpForwardEntry (IPHLPAPI.@)
1917  *
1918  * Modify an existing route.
1919  *
1920  * PARAMS
1921  *  pRoute [In] route with the new information
1922  *
1923  * RETURNS
1924  *  Success: NO_ERROR
1925  *  Failure: error code from winerror.h
1926  *
1927  * FIXME
1928  *  Stub, returns NO_ERROR.
1929  */
1930 DWORD WINAPI SetIpForwardEntry(PMIB_IPFORWARDROW pRoute)
1931 {
1932   FIXME("(pRoute %p): stub\n", pRoute);
1933   /* this is to add a route entry, how's it distinguishable from
1934      CreateIpForwardEntry?
1935      could use SIOCADDRT, not sure I want to */
1936   return (DWORD) 0;
1937 }
1938
1939
1940 /******************************************************************
1941  *    SetIpNetEntry (IPHLPAPI.@)
1942  *
1943  * Modify an existing ARP entry.
1944  *
1945  * PARAMS
1946  *  pArpEntry [In] ARP entry with the new information
1947  *
1948  * RETURNS
1949  *  Success: NO_ERROR
1950  *  Failure: error code from winerror.h
1951  *
1952  * FIXME
1953  *  Stub, returns NO_ERROR.
1954  */
1955 DWORD WINAPI SetIpNetEntry(PMIB_IPNETROW pArpEntry)
1956 {
1957   FIXME("(pArpEntry %p): stub\n", pArpEntry);
1958   /* same as CreateIpNetEntry here, could use SIOCSARP, not sure I want to */
1959   return (DWORD) 0;
1960 }
1961
1962
1963 /******************************************************************
1964  *    SetIpStatistics (IPHLPAPI.@)
1965  *
1966  * Toggle IP forwarding and det the default TTL value.
1967  *
1968  * PARAMS
1969  *  pIpStats [In] IP statistics with the new information
1970  *
1971  * RETURNS
1972  *  Success: NO_ERROR
1973  *  Failure: error code from winerror.h
1974  *
1975  * FIXME
1976  *  Stub, returns NO_ERROR.
1977  */
1978 DWORD WINAPI SetIpStatistics(PMIB_IPSTATS pIpStats)
1979 {
1980   FIXME("(pIpStats %p): stub\n", pIpStats);
1981   return (DWORD) 0;
1982 }
1983
1984
1985 /******************************************************************
1986  *    SetIpTTL (IPHLPAPI.@)
1987  *
1988  * Set the default TTL value.
1989  *
1990  * PARAMS
1991  *  nTTL [In] new TTL value
1992  *
1993  * RETURNS
1994  *  Success: NO_ERROR
1995  *  Failure: error code from winerror.h
1996  *
1997  * FIXME
1998  *  Stub, returns NO_ERROR.
1999  */
2000 DWORD WINAPI SetIpTTL(UINT nTTL)
2001 {
2002   FIXME("(nTTL %d): stub\n", nTTL);
2003   /* could echo nTTL > /proc/net/sys/net/ipv4/ip_default_ttl, not sure I
2004      want to.  Could map EACCESS to ERROR_ACCESS_DENIED, I suppose */
2005   return (DWORD) 0;
2006 }
2007
2008
2009 /******************************************************************
2010  *    SetTcpEntry (IPHLPAPI.@)
2011  *
2012  * Set the state of a TCP connection.
2013  *
2014  * PARAMS
2015  *  pTcpRow [In] specifies connection with new state
2016  *
2017  * RETURNS
2018  *  Success: NO_ERROR
2019  *  Failure: error code from winerror.h
2020  *
2021  * FIXME
2022  *  Stub, returns NO_ERROR.
2023  */
2024 DWORD WINAPI SetTcpEntry(PMIB_TCPROW pTcpRow)
2025 {
2026   FIXME("(pTcpRow %p): stub\n", pTcpRow);
2027   return (DWORD) 0;
2028 }
2029
2030
2031 /******************************************************************
2032  *    UnenableRouter (IPHLPAPI.@)
2033  *
2034  * Decrement the IP-forwarding reference count. Turn off IP-forwarding
2035  * if it reaches zero.
2036  *
2037  * PARAMS
2038  *  pOverlapped     [In/Out] should be the same as in EnableRouter()
2039  *  lpdwEnableCount [Out]    optional, receives reference count
2040  *
2041  * RETURNS
2042  *  Success: NO_ERROR
2043  *  Failure: error code from winerror.h
2044  *
2045  * FIXME
2046  *  Stub, returns ERROR_NOT_SUPPORTED.
2047  */
2048 DWORD WINAPI UnenableRouter(OVERLAPPED * pOverlapped, LPDWORD lpdwEnableCount)
2049 {
2050   FIXME("(pOverlapped %p, lpdwEnableCount %p): stub\n", pOverlapped,
2051    lpdwEnableCount);
2052   /* could echo "0" > /proc/net/sys/net/ipv4/ip_forward, not sure I want to
2053      could map EACCESS to ERROR_ACCESS_DENIED, I suppose
2054    */
2055   return ERROR_NOT_SUPPORTED;
2056 }