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