git.oblomov.eu Git - wine/blob - dlls/iphlpapi/ipstats.c

   1 /*
   2  * Copyright (C) 2003,2006 Juan Lang
   3  * Copyright (C) 2007 TransGaming Technologies Inc.
   4  * Copyright (C) 2009 Alexandre Julliard
   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 #include "wine/port.h"
  23
  24 #include <stdarg.h>
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <errno.h>
  29 #include <sys/types.h>
  30 #ifdef HAVE_ALIAS_H
  31 #include <alias.h>
  32 #endif
  33 #ifdef HAVE_SYS_SOCKET_H
  34 #include <sys/socket.h>
  35 #endif
  36 #ifdef HAVE_SYS_SOCKETVAR_H
  37 #include <sys/socketvar.h>
  38 #endif
  39 #ifdef HAVE_SYS_TIMEOUT_H
  40 #include <sys/timeout.h>
  41 #endif
  42 #ifdef HAVE_NETINET_IN_H
  43 #include <netinet/in.h>
  44 #endif
  45 #ifdef HAVE_NETINET_IN_SYSTM_H
  46 #include <netinet/in_systm.h>
  47 #endif
  48 #ifdef HAVE_ARPA_INET_H
  49 #include <arpa/inet.h>
  50 #endif
  51 #ifdef HAVE_NET_IF_H
  52 #include <net/if.h>
  53 #endif
  54 #ifdef HAVE_NET_IF_DL_H
  55 #include <net/if_dl.h>
  56 #endif
  57 #ifdef HAVE_NET_IF_TYPES_H
  58 #include <net/if_types.h>
  59 #endif
  60 #ifdef HAVE_NET_ROUTE_H
  61 #include <net/route.h>
  62 #endif
  63 #ifdef HAVE_NET_IF_ARP_H
  64 #include <net/if_arp.h>
  65 #endif
  66 #ifdef HAVE_NETINET_IF_ETHER_H
  67 #include <netinet/if_ether.h>
  68 #endif
  69 #ifdef HAVE_NETINET_IF_INARP_H
  70 #include <netinet/if_inarp.h>
  71 #endif
  72 #ifdef HAVE_NETINET_IP_H
  73 #include <netinet/ip.h>
  74 #endif
  75 #ifdef HAVE_NETINET_TCP_H
  76 #include <netinet/tcp.h>
  77 #endif
  78 #ifdef HAVE_NETINET_IP_VAR_H
  79 #include <netinet/ip_var.h>
  80 #endif
  81 #ifdef HAVE_NETINET_TCP_FSM_H
  82 #include <netinet/tcp_fsm.h>
  83 #endif
  84 #ifdef HAVE_NETINET_IN_PCB_H
  85 #include <netinet/in_pcb.h>
  86 #endif
  87 #ifdef HAVE_NETINET_TCP_TIMER_H
  88 #include <netinet/tcp_timer.h>
  89 #endif
  90 #ifdef HAVE_NETINET_TCP_VAR_H
  91 #include <netinet/tcp_var.h>
  92 #endif
  93 #ifdef HAVE_NETINET_IP_ICMP_H
  94 #include <netinet/ip_icmp.h>
  95 #endif
  96 #ifdef HAVE_NETINET_ICMP_VAR_H
  97 #include <netinet/icmp_var.h>
  98 #endif
  99 #ifdef HAVE_NETINET_UDP_H
 100 #include <netinet/udp.h>
 101 #endif
 102 #ifdef HAVE_NETINET_UDP_VAR_H
 103 #include <netinet/udp_var.h>
 104 #endif
 105 #ifdef HAVE_SYS_PROTOSW_H
 106 #include <sys/protosw.h>
 107 #endif
 108 #ifdef HAVE_SYS_SYSCTL_H
 109 #include <sys/sysctl.h>
 110 #endif
 111 #ifdef HAVE_KSTAT_H
 112 #include <kstat.h>
 113 #endif
 114 #ifdef HAVE_INET_MIB2_H
 115 #include <inet/mib2.h>
 116 #endif
 117 #ifdef HAVE_STROPTS_H
 118 #include <stropts.h>
 119 #endif
 120 #ifdef HAVE_SYS_TIHDR_H
 121 #include <sys/tihdr.h>
 122 #endif
 123
 124 #ifndef ROUNDUP
 125 #define ROUNDUP(a) \
 126         ((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long))
 127 #endif
 128 #ifndef ADVANCE
 129 #define ADVANCE(x, n) (x += ROUNDUP(((struct sockaddr *)n)->sa_len))
 130 #endif
 131
 132 #include "windef.h"
 133 #include "winbase.h"
 134 #include "iprtrmib.h"
 135 #include "ifenum.h"
 136 #include "ipstats.h"
 137
 138 #include "wine/debug.h"
 139
 140 #ifndef HAVE_NETINET_TCP_FSM_H
 141 #define TCPS_ESTABLISHED  1
 142 #define TCPS_SYN_SENT     2
 143 #define TCPS_SYN_RECEIVED 3
 144 #define TCPS_FIN_WAIT_1   4
 145 #define TCPS_FIN_WAIT_2   5
 146 #define TCPS_TIME_WAIT    6
 147 #define TCPS_CLOSED       7
 148 #define TCPS_CLOSE_WAIT   8
 149 #define TCPS_LAST_ACK     9
 150 #define TCPS_LISTEN      10
 151 #define TCPS_CLOSING     11
 152 #endif
 153
 154 #ifndef RTF_MULTICAST
 155 #define RTF_MULTICAST 0 /* Not available on NetBSD/OpenBSD */
 156 #endif
 157
 158 #ifndef RTF_LLINFO
 159 #define RTF_LLINFO 0 /* Not available on FreeBSD 8 and above */
 160 #endif
 161
 162 WINE_DEFAULT_DEBUG_CHANNEL(iphlpapi);
 163
 164 #ifdef HAVE_LIBKSTAT
 165 static DWORD kstat_get_ui32( kstat_t *ksp, const char *name )
 166 {
 167     unsigned int i;
 168     kstat_named_t *data = ksp->ks_data;
 169
 170     for (i = 0; i < ksp->ks_ndata; i++)
 171         if (!strcmp( data[i].name, name )) return data[i].value.ui32;
 172     return 0;
 173 }
 174
 175 static ULONGLONG kstat_get_ui64( kstat_t *ksp, const char *name )
 176 {
 177     unsigned int i;
 178     kstat_named_t *data = ksp->ks_data;
 179
 180     for (i = 0; i < ksp->ks_ndata; i++)
 181         if (!strcmp( data[i].name, name )) return data[i].value.ui64;
 182     return 0;
 183 }
 184 #endif
 185
 186 #if defined(HAVE_SYS_TIHDR_H) && defined(T_OPTMGMT_ACK)
 187 static int open_streams_mib( const char *proto )
 188 {
 189     int fd;
 190     struct strbuf buf;
 191     struct request
 192     {
 193         struct T_optmgmt_req req_header;
 194         struct opthdr        opt_header;
 195     } request;
 196
 197     if ((fd = open( "/dev/arp", O_RDWR )) == -1)
 198     {
 199         WARN( "could not open /dev/arp: %s\n", strerror(errno) );
 200         return -1;
 201     }
 202     if (proto) ioctl( fd, I_PUSH, proto );
 203
 204     request.req_header.PRIM_type  = T_SVR4_OPTMGMT_REQ;
 205     request.req_header.OPT_length = sizeof(request.opt_header);
 206     request.req_header.OPT_offset = FIELD_OFFSET( struct request, opt_header );
 207     request.req_header.MGMT_flags = T_CURRENT;
 208     request.opt_header.level      = MIB2_IP;
 209     request.opt_header.name       = 0;
 210     request.opt_header.len        = 0;
 211
 212     buf.len = sizeof(request);
 213     buf.buf = (caddr_t)&request;
 214     if (putmsg( fd, &buf, NULL, 0 ) == -1)
 215     {
 216         WARN( "putmsg: %s\n", strerror(errno) );
 217         close( fd );
 218         fd = -1;
 219     }
 220     return fd;
 221 }
 222
 223 static void *read_mib_entry( int fd, int level, int name, int *len )
 224 {
 225     struct strbuf buf;
 226     void *data;
 227     int ret, flags = 0;
 228
 229     struct reply
 230     {
 231         struct T_optmgmt_ack ack_header;
 232         struct opthdr        opt_header;
 233     } reply;
 234
 235     for (;;)
 236     {
 237         buf.maxlen = sizeof(reply);
 238         buf.buf = (caddr_t)&reply;
 239         if ((ret = getmsg( fd, &buf, NULL, &flags )) < 0) return NULL;
 240         if (!(ret & MOREDATA)) return NULL;
 241         if (reply.ack_header.PRIM_type != T_OPTMGMT_ACK) return NULL;
 242         if (buf.len < sizeof(reply.ack_header)) return NULL;
 243         if (reply.ack_header.OPT_length < sizeof(reply.opt_header)) return NULL;
 244
 245         if (!(data = HeapAlloc( GetProcessHeap(), 0, reply.opt_header.len ))) return NULL;
 246         buf.maxlen = reply.opt_header.len;
 247         buf.buf = (caddr_t)data;
 248         flags = 0;
 249         if (getmsg( fd, NULL, &buf, &flags ) >= 0 &&
 250             reply.opt_header.level == level &&
 251             reply.opt_header.name == name)
 252         {
 253             *len = buf.len;
 254             return data;
 255         }
 256         HeapFree( GetProcessHeap(), 0, data );
 257     }
 258 }
 259 #endif /* HAVE_SYS_TIHDR_H && T_OPTMGMT_ACK */
 260
 261 DWORD getInterfaceStatsByName(const char *name, PMIB_IFROW entry)
 262 {
 263     DWORD ret = ERROR_NOT_SUPPORTED;
 264
 265     if (!name || !entry) return ERROR_INVALID_PARAMETER;
 266
 267 #ifdef __linux__
 268     {
 269         FILE *fp;
 270
 271         if ((fp = fopen("/proc/net/dev", "r")))
 272         {
 273             DWORD skip;
 274             char buf[512], *ptr;
 275             int nameLen = strlen(name);
 276
 277             while ((ptr = fgets(buf, sizeof(buf), fp)))
 278             {
 279                 while (*ptr && isspace(*ptr)) ptr++;
 280                 if (strncasecmp(ptr, name, nameLen) == 0 && *(ptr + nameLen) == ':')
 281                 {
 282                     ptr += nameLen + 1;
 283                     sscanf( ptr, "%u %u %u %u %u %u %u %u %u %u %u %u",
 284                             &entry->dwInOctets, &entry->dwInUcastPkts,
 285                             &entry->dwInErrors, &entry->dwInDiscards,
 286                             &skip, &skip, &skip,
 287                             &entry->dwInNUcastPkts, &entry->dwOutOctets,
 288                             &entry->dwOutUcastPkts, &entry->dwOutErrors,
 289                             &entry->dwOutDiscards );
 290                     break;
 291                 }
 292             }
 293             fclose(fp);
 294             ret = NO_ERROR;
 295         }
 296     }
 297 #elif defined(HAVE_LIBKSTAT)
 298     {
 299         kstat_ctl_t *kc;
 300         kstat_t *ksp;
 301
 302         if ((kc = kstat_open()) &&
 303             (ksp = kstat_lookup( kc, NULL, -1, (char *)name )) &&
 304             kstat_read( kc, ksp, NULL ) != -1 &&
 305             ksp->ks_type == KSTAT_TYPE_NAMED)
 306         {
 307             entry->dwMtu             = 1500;  /* FIXME */
 308             entry->dwSpeed           = min( kstat_get_ui64( ksp, "ifspeed" ), ~0u );
 309             entry->dwInOctets        = kstat_get_ui32( ksp, "rbytes" );
 310             entry->dwInNUcastPkts    = kstat_get_ui32( ksp, "multircv" );
 311             entry->dwInNUcastPkts   += kstat_get_ui32( ksp, "brdcstrcv" );
 312             entry->dwInUcastPkts     = kstat_get_ui32( ksp, "ipackets" ) - entry->dwInNUcastPkts;
 313             entry->dwInDiscards      = kstat_get_ui32( ksp, "norcvbuf" );
 314             entry->dwInErrors        = kstat_get_ui32( ksp, "ierrors" );
 315             entry->dwInUnknownProtos = kstat_get_ui32( ksp, "unknowns" );
 316             entry->dwOutOctets       = kstat_get_ui32( ksp, "obytes" );
 317             entry->dwOutNUcastPkts   = kstat_get_ui32( ksp, "multixmt" );
 318             entry->dwOutNUcastPkts  += kstat_get_ui32( ksp, "brdcstxmt" );
 319             entry->dwOutUcastPkts    = kstat_get_ui32( ksp, "opackets" ) - entry->dwOutNUcastPkts;
 320             entry->dwOutDiscards     = 0;  /* FIXME */
 321             entry->dwOutErrors       = kstat_get_ui32( ksp, "oerrors" );
 322             entry->dwOutQLen         = kstat_get_ui32( ksp, "noxmtbuf" );
 323             ret = NO_ERROR;
 324         }
 325         if (kc) kstat_close( kc );
 326     }
 327 #elif defined(HAVE_SYS_SYSCTL_H) && defined(NET_RT_IFLIST)
 328     {
 329         int mib[] = {CTL_NET, PF_ROUTE, 0, AF_INET, NET_RT_IFLIST, if_nametoindex(name)};
 330 #define MIB_LEN (sizeof(mib) / sizeof(mib[0]))
 331
 332         size_t needed;
 333         char *buf = NULL, *end;
 334         struct if_msghdr *ifm;
 335         struct if_data ifdata;
 336
 337         if(sysctl(mib, MIB_LEN, NULL, &needed, NULL, 0) == -1)
 338         {
 339             ERR ("failed to get size of iflist\n");
 340             goto done;
 341         }
 342         buf = HeapAlloc (GetProcessHeap (), 0, needed);
 343         if (!buf)
 344         {
 345             ret = ERROR_OUTOFMEMORY;
 346             goto done;
 347         }
 348         if(sysctl(mib, MIB_LEN, buf, &needed, NULL, 0) == -1)
 349         {
 350             ERR ("failed to get iflist\n");
 351             goto done;
 352         }
 353         for ( end = buf + needed; buf < end; buf += ifm->ifm_msglen)
 354         {
 355             ifm = (struct if_msghdr *) buf;
 356             if(ifm->ifm_type == RTM_IFINFO && ifm->ifm_data.ifi_type == IFT_ETHER)
 357             {
 358                 ifdata = ifm->ifm_data;
 359                 entry->dwMtu = ifdata.ifi_mtu;
 360                 entry->dwSpeed = ifdata.ifi_baudrate;
 361                 entry->dwInOctets = ifdata.ifi_ibytes;
 362                 entry->dwInErrors = ifdata.ifi_ierrors;
 363                 entry->dwInDiscards = ifdata.ifi_iqdrops;
 364                 entry->dwInUcastPkts = ifdata.ifi_ipackets;
 365                 entry->dwInNUcastPkts = ifdata.ifi_imcasts;
 366                 entry->dwOutOctets = ifdata.ifi_obytes;
 367                 entry->dwOutUcastPkts = ifdata.ifi_opackets;
 368                 entry->dwOutErrors = ifdata.ifi_oerrors;
 369                 ret = NO_ERROR;
 370                 break;
 371             }
 372         }
 373     done:
 374         HeapFree (GetProcessHeap (), 0, buf);
 375     }
 376 #else
 377     FIXME( "unimplemented\n" );
 378 #endif
 379     return ret;
 380 }
 381
 382
 383 /******************************************************************
 384  *    GetIcmpStatistics (IPHLPAPI.@)
 385  *
 386  * Get the ICMP statistics for the local computer.
 387  *
 388  * PARAMS
 389  *  stats [Out] buffer for ICMP statistics
 390  *
 391  * RETURNS
 392  *  Success: NO_ERROR
 393  *  Failure: error code from winerror.h
 394  */
 395 DWORD WINAPI GetIcmpStatistics(PMIB_ICMP stats)
 396 {
 397     DWORD ret = ERROR_NOT_SUPPORTED;
 398
 399     if (!stats) return ERROR_INVALID_PARAMETER;
 400     memset( stats, 0, sizeof(MIB_ICMP) );
 401
 402 #ifdef __linux__
 403     {
 404         FILE *fp;
 405
 406         if ((fp = fopen("/proc/net/snmp", "r")))
 407         {
 408             static const char hdr[] = "Icmp:";
 409             char buf[512], *ptr;
 410
 411             while ((ptr = fgets(buf, sizeof(buf), fp)))
 412             {
 413                 if (strncasecmp(buf, hdr, sizeof(hdr) - 1)) continue;
 414                 /* last line was a header, get another */
 415                 if (!(ptr = fgets(buf, sizeof(buf), fp))) break;
 416                 if (!strncasecmp(buf, hdr, sizeof(hdr) - 1))
 417                 {
 418                     ptr += sizeof(hdr);
 419                     sscanf( ptr, "%u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u",
 420                             &stats->stats.icmpInStats.dwMsgs,
 421                             &stats->stats.icmpInStats.dwErrors,
 422                             &stats->stats.icmpInStats.dwDestUnreachs,
 423                             &stats->stats.icmpInStats.dwTimeExcds,
 424                             &stats->stats.icmpInStats.dwParmProbs,
 425                             &stats->stats.icmpInStats.dwSrcQuenchs,
 426                             &stats->stats.icmpInStats.dwRedirects,
 427                             &stats->stats.icmpInStats.dwEchoReps,
 428                             &stats->stats.icmpInStats.dwTimestamps,
 429                             &stats->stats.icmpInStats.dwTimestampReps,
 430                             &stats->stats.icmpInStats.dwAddrMasks,
 431                             &stats->stats.icmpInStats.dwAddrMaskReps,
 432                             &stats->stats.icmpOutStats.dwMsgs,
 433                             &stats->stats.icmpOutStats.dwErrors,
 434                             &stats->stats.icmpOutStats.dwDestUnreachs,
 435                             &stats->stats.icmpOutStats.dwTimeExcds,
 436                             &stats->stats.icmpOutStats.dwParmProbs,
 437                             &stats->stats.icmpOutStats.dwSrcQuenchs,
 438                             &stats->stats.icmpOutStats.dwRedirects,
 439                             &stats->stats.icmpOutStats.dwEchoReps,
 440                             &stats->stats.icmpOutStats.dwTimestamps,
 441                             &stats->stats.icmpOutStats.dwTimestampReps,
 442                             &stats->stats.icmpOutStats.dwAddrMasks,
 443                             &stats->stats.icmpOutStats.dwAddrMaskReps );
 444                     break;
 445                 }
 446             }
 447             fclose(fp);
 448             ret = NO_ERROR;
 449         }
 450     }
 451 #elif defined(HAVE_LIBKSTAT)
 452     {
 453         static char ip[] = "ip", icmp[] = "icmp";
 454         kstat_ctl_t *kc;
 455         kstat_t *ksp;
 456
 457         if ((kc = kstat_open()) &&
 458             (ksp = kstat_lookup( kc, ip, 0, icmp )) &&
 459             kstat_read( kc, ksp, NULL ) != -1 &&
 460             ksp->ks_type == KSTAT_TYPE_NAMED)
 461         {
 462             stats->stats.icmpInStats.dwMsgs           = kstat_get_ui32( ksp, "inMsgs" );
 463             stats->stats.icmpInStats.dwErrors         = kstat_get_ui32( ksp, "inErrors" );
 464             stats->stats.icmpInStats.dwDestUnreachs   = kstat_get_ui32( ksp, "inDestUnreachs" );
 465             stats->stats.icmpInStats.dwTimeExcds      = kstat_get_ui32( ksp, "inTimeExcds" );
 466             stats->stats.icmpInStats.dwParmProbs      = kstat_get_ui32( ksp, "inParmProbs" );
 467             stats->stats.icmpInStats.dwSrcQuenchs     = kstat_get_ui32( ksp, "inSrcQuenchs" );
 468             stats->stats.icmpInStats.dwRedirects      = kstat_get_ui32( ksp, "inRedirects" );
 469             stats->stats.icmpInStats.dwEchos          = kstat_get_ui32( ksp, "inEchos" );
 470             stats->stats.icmpInStats.dwEchoReps       = kstat_get_ui32( ksp, "inEchoReps" );
 471             stats->stats.icmpInStats.dwTimestamps     = kstat_get_ui32( ksp, "inTimestamps" );
 472             stats->stats.icmpInStats.dwTimestampReps  = kstat_get_ui32( ksp, "inTimestampReps" );
 473             stats->stats.icmpInStats.dwAddrMasks      = kstat_get_ui32( ksp, "inAddrMasks" );
 474             stats->stats.icmpInStats.dwAddrMaskReps   = kstat_get_ui32( ksp, "inAddrMaskReps" );
 475             stats->stats.icmpOutStats.dwMsgs          = kstat_get_ui32( ksp, "outMsgs" );
 476             stats->stats.icmpOutStats.dwErrors        = kstat_get_ui32( ksp, "outErrors" );
 477             stats->stats.icmpOutStats.dwDestUnreachs  = kstat_get_ui32( ksp, "outDestUnreachs" );
 478             stats->stats.icmpOutStats.dwTimeExcds     = kstat_get_ui32( ksp, "outTimeExcds" );
 479             stats->stats.icmpOutStats.dwParmProbs     = kstat_get_ui32( ksp, "outParmProbs" );
 480             stats->stats.icmpOutStats.dwSrcQuenchs    = kstat_get_ui32( ksp, "outSrcQuenchs" );
 481             stats->stats.icmpOutStats.dwRedirects     = kstat_get_ui32( ksp, "outRedirects" );
 482             stats->stats.icmpOutStats.dwEchos         = kstat_get_ui32( ksp, "outEchos" );
 483             stats->stats.icmpOutStats.dwEchoReps      = kstat_get_ui32( ksp, "outEchoReps" );
 484             stats->stats.icmpOutStats.dwTimestamps    = kstat_get_ui32( ksp, "outTimestamps" );
 485             stats->stats.icmpOutStats.dwTimestampReps = kstat_get_ui32( ksp, "outTimestampReps" );
 486             stats->stats.icmpOutStats.dwAddrMasks     = kstat_get_ui32( ksp, "outAddrMasks" );
 487             stats->stats.icmpOutStats.dwAddrMaskReps  = kstat_get_ui32( ksp, "outAddrMaskReps" );
 488             ret = NO_ERROR;
 489         }
 490         if (kc) kstat_close( kc );
 491     }
 492 #elif defined(HAVE_SYS_SYSCTL_H) && defined(ICMPCTL_STATS)
 493     {
 494         int mib[] = {CTL_NET, PF_INET, IPPROTO_ICMP, ICMPCTL_STATS};
 495 #define MIB_LEN (sizeof(mib) / sizeof(mib[0]))
 496         struct icmpstat icmp_stat;
 497         size_t needed  = sizeof(icmp_stat);
 498         int i;
 499
 500         if(sysctl(mib, MIB_LEN, &icmp_stat, &needed, NULL, 0) != -1)
 501         {
 502             /*in stats */
 503             stats->stats.icmpInStats.dwMsgs = icmp_stat.icps_badcode + icmp_stat.icps_checksum + icmp_stat.icps_tooshort + icmp_stat.icps_badlen;
 504             for(i = 0; i <= ICMP_MAXTYPE; i++)
 505                 stats->stats.icmpInStats.dwMsgs += icmp_stat.icps_inhist[i];
 506
 507             stats->stats.icmpInStats.dwErrors = icmp_stat.icps_badcode + icmp_stat.icps_tooshort + icmp_stat.icps_checksum + icmp_stat.icps_badlen;
 508
 509             stats->stats.icmpInStats.dwDestUnreachs = icmp_stat.icps_inhist[ICMP_UNREACH];
 510             stats->stats.icmpInStats.dwTimeExcds = icmp_stat.icps_inhist[ICMP_TIMXCEED];
 511             stats->stats.icmpInStats.dwParmProbs = icmp_stat.icps_inhist[ICMP_PARAMPROB];
 512             stats->stats.icmpInStats.dwSrcQuenchs = icmp_stat.icps_inhist[ICMP_SOURCEQUENCH];
 513             stats->stats.icmpInStats.dwRedirects = icmp_stat.icps_inhist[ICMP_REDIRECT];
 514             stats->stats.icmpInStats.dwEchos = icmp_stat.icps_inhist[ICMP_ECHO];
 515             stats->stats.icmpInStats.dwEchoReps = icmp_stat.icps_inhist[ICMP_ECHOREPLY];
 516             stats->stats.icmpInStats.dwTimestamps = icmp_stat.icps_inhist[ICMP_TSTAMP];
 517             stats->stats.icmpInStats.dwTimestampReps = icmp_stat.icps_inhist[ICMP_TSTAMPREPLY];
 518             stats->stats.icmpInStats.dwAddrMasks = icmp_stat.icps_inhist[ICMP_MASKREQ];
 519             stats->stats.icmpInStats.dwAddrMaskReps = icmp_stat.icps_inhist[ICMP_MASKREPLY];
 520
 521 #ifdef HAVE_ICPS_OUTHIST
 522             /* out stats */
 523             stats->stats.icmpOutStats.dwMsgs = icmp_stat.icps_oldshort + icmp_stat.icps_oldicmp;
 524             for(i = 0; i <= ICMP_MAXTYPE; i++)
 525                 stats->stats.icmpOutStats.dwMsgs += icmp_stat.icps_outhist[i];
 526
 527             stats->stats.icmpOutStats.dwErrors = icmp_stat.icps_oldshort + icmp_stat.icps_oldicmp;
 528
 529             stats->stats.icmpOutStats.dwDestUnreachs = icmp_stat.icps_outhist[ICMP_UNREACH];
 530             stats->stats.icmpOutStats.dwTimeExcds = icmp_stat.icps_outhist[ICMP_TIMXCEED];
 531             stats->stats.icmpOutStats.dwParmProbs = icmp_stat.icps_outhist[ICMP_PARAMPROB];
 532             stats->stats.icmpOutStats.dwSrcQuenchs = icmp_stat.icps_outhist[ICMP_SOURCEQUENCH];
 533             stats->stats.icmpOutStats.dwRedirects = icmp_stat.icps_outhist[ICMP_REDIRECT];
 534             stats->stats.icmpOutStats.dwEchos = icmp_stat.icps_outhist[ICMP_ECHO];
 535             stats->stats.icmpOutStats.dwEchoReps = icmp_stat.icps_outhist[ICMP_ECHOREPLY];
 536             stats->stats.icmpOutStats.dwTimestamps = icmp_stat.icps_outhist[ICMP_TSTAMP];
 537             stats->stats.icmpOutStats.dwTimestampReps = icmp_stat.icps_outhist[ICMP_TSTAMPREPLY];
 538             stats->stats.icmpOutStats.dwAddrMasks = icmp_stat.icps_outhist[ICMP_MASKREQ];
 539             stats->stats.icmpOutStats.dwAddrMaskReps = icmp_stat.icps_outhist[ICMP_MASKREPLY];
 540 #endif /* ICPS_OUTHIST */
 541             ret = NO_ERROR;
 542         }
 543     }
 544 #else /* ICMPCTL_STATS */
 545     FIXME( "unimplemented\n" );
 546 #endif
 547     return ret;
 548 }
 549
 550
 551 /******************************************************************
 552  *    GetIpStatistics (IPHLPAPI.@)
 553  *
 554  * Get the IP statistics for the local computer.
 555  *
 556  * PARAMS
 557  *  stats [Out] buffer for IP statistics
 558  *
 559  * RETURNS
 560  *  Success: NO_ERROR
 561  *  Failure: error code from winerror.h
 562  */
 563 DWORD WINAPI GetIpStatistics(PMIB_IPSTATS stats)
 564 {
 565     DWORD ret = ERROR_NOT_SUPPORTED;
 566     MIB_IPFORWARDTABLE *fwd_table;
 567
 568     if (!stats) return ERROR_INVALID_PARAMETER;
 569     memset( stats, 0, sizeof(*stats) );
 570
 571     stats->dwNumIf = stats->dwNumAddr = getNumInterfaces();
 572     if (!AllocateAndGetIpForwardTableFromStack( &fwd_table, FALSE, GetProcessHeap(), 0 ))
 573     {
 574         stats->dwNumRoutes = fwd_table->dwNumEntries;
 575         HeapFree( GetProcessHeap(), 0, fwd_table );
 576     }
 577
 578 #ifdef __linux__
 579     {
 580         FILE *fp;
 581
 582         if ((fp = fopen("/proc/net/snmp", "r")))
 583         {
 584             static const char hdr[] = "Ip:";
 585             char buf[512], *ptr;
 586
 587             while ((ptr = fgets(buf, sizeof(buf), fp)))
 588             {
 589                 if (strncasecmp(buf, hdr, sizeof(hdr) - 1)) continue;
 590                 /* last line was a header, get another */
 591                 if (!(ptr = fgets(buf, sizeof(buf), fp))) break;
 592                 if (!strncasecmp(buf, hdr, sizeof(hdr) - 1))
 593                 {
 594                     ptr += sizeof(hdr);
 595                     sscanf( ptr, "%u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u",
 596                             &stats->dwForwarding,
 597                             &stats->dwDefaultTTL,
 598                             &stats->dwInReceives,
 599                             &stats->dwInHdrErrors,
 600                             &stats->dwInAddrErrors,
 601                             &stats->dwForwDatagrams,
 602                             &stats->dwInUnknownProtos,
 603                             &stats->dwInDiscards,
 604                             &stats->dwInDelivers,
 605                             &stats->dwOutRequests,
 606                             &stats->dwOutDiscards,
 607                             &stats->dwOutNoRoutes,
 608                             &stats->dwReasmTimeout,
 609                             &stats->dwReasmReqds,
 610                             &stats->dwReasmOks,
 611                             &stats->dwReasmFails,
 612                             &stats->dwFragOks,
 613                             &stats->dwFragFails,
 614                             &stats->dwFragCreates );
 615                     /* hmm, no routingDiscards */
 616                     break;
 617                 }
 618             }
 619             fclose(fp);
 620             ret = NO_ERROR;
 621         }
 622     }
 623 #elif defined(HAVE_LIBKSTAT)
 624     {
 625         static char ip[] = "ip";
 626         kstat_ctl_t *kc;
 627         kstat_t *ksp;
 628
 629         if ((kc = kstat_open()) &&
 630             (ksp = kstat_lookup( kc, ip, 0, ip )) &&
 631             kstat_read( kc, ksp, NULL ) != -1 &&
 632             ksp->ks_type == KSTAT_TYPE_NAMED)
 633         {
 634             stats->dwForwarding      = kstat_get_ui32( ksp, "forwarding" );
 635             stats->dwDefaultTTL      = kstat_get_ui32( ksp, "defaultTTL" );
 636             stats->dwInReceives      = kstat_get_ui32( ksp, "inReceives" );
 637             stats->dwInHdrErrors     = kstat_get_ui32( ksp, "inHdrErrors" );
 638             stats->dwInAddrErrors    = kstat_get_ui32( ksp, "inAddrErrors" );
 639             stats->dwForwDatagrams   = kstat_get_ui32( ksp, "forwDatagrams" );
 640             stats->dwInUnknownProtos = kstat_get_ui32( ksp, "inUnknownProtos" );
 641             stats->dwInDiscards      = kstat_get_ui32( ksp, "inDiscards" );
 642             stats->dwInDelivers      = kstat_get_ui32( ksp, "inDelivers" );
 643             stats->dwOutRequests     = kstat_get_ui32( ksp, "outRequests" );
 644             stats->dwRoutingDiscards = kstat_get_ui32( ksp, "routingDiscards" );
 645             stats->dwOutDiscards     = kstat_get_ui32( ksp, "outDiscards" );
 646             stats->dwOutNoRoutes     = kstat_get_ui32( ksp, "outNoRoutes" );
 647             stats->dwReasmTimeout    = kstat_get_ui32( ksp, "reasmTimeout" );
 648             stats->dwReasmReqds      = kstat_get_ui32( ksp, "reasmReqds" );
 649             stats->dwReasmOks        = kstat_get_ui32( ksp, "reasmOKs" );
 650             stats->dwReasmFails      = kstat_get_ui32( ksp, "reasmFails" );
 651             stats->dwFragOks         = kstat_get_ui32( ksp, "fragOKs" );
 652             stats->dwFragFails       = kstat_get_ui32( ksp, "fragFails" );
 653             stats->dwFragCreates     = kstat_get_ui32( ksp, "fragCreates" );
 654             ret = NO_ERROR;
 655         }
 656         if (kc) kstat_close( kc );
 657     }
 658 #elif defined(HAVE_SYS_SYSCTL_H) && defined(IPCTL_STATS)
 659     {
 660         int mib[] = {CTL_NET, PF_INET, IPPROTO_IP, IPCTL_STATS};
 661 #define MIB_LEN (sizeof(mib) / sizeof(mib[0]))
 662         int ip_ttl, ip_forwarding;
 663         struct ipstat ip_stat;
 664         size_t needed;
 665
 666         needed = sizeof(ip_stat);
 667         if(sysctl(mib, MIB_LEN, &ip_stat, &needed, NULL, 0) == -1)
 668         {
 669             ERR ("failed to get ipstat\n");
 670             return ERROR_NOT_SUPPORTED;
 671         }
 672
 673         needed = sizeof(ip_ttl);
 674         if (sysctlbyname ("net.inet.ip.ttl", &ip_ttl, &needed, NULL, 0) == -1)
 675         {
 676             ERR ("failed to get ip Default TTL\n");
 677             return ERROR_NOT_SUPPORTED;
 678         }
 679
 680         needed = sizeof(ip_forwarding);
 681         if (sysctlbyname ("net.inet.ip.forwarding", &ip_forwarding, &needed, NULL, 0) == -1)
 682         {
 683             ERR ("failed to get ip forwarding\n");
 684             return ERROR_NOT_SUPPORTED;
 685         }
 686
 687         stats->dwForwarding = ip_forwarding;
 688         stats->dwDefaultTTL = ip_ttl;
 689         stats->dwInDelivers = ip_stat.ips_delivered;
 690         stats->dwInHdrErrors = ip_stat.ips_badhlen + ip_stat.ips_badsum + ip_stat.ips_tooshort + ip_stat.ips_badlen;
 691         stats->dwInAddrErrors = ip_stat.ips_cantforward;
 692         stats->dwInReceives = ip_stat.ips_total;
 693         stats->dwForwDatagrams = ip_stat.ips_forward;
 694         stats->dwInUnknownProtos = ip_stat.ips_noproto;
 695         stats->dwInDiscards = ip_stat.ips_fragdropped;
 696         stats->dwOutDiscards = ip_stat.ips_odropped;
 697         stats->dwReasmOks = ip_stat.ips_reassembled;
 698         stats->dwFragOks = ip_stat.ips_fragmented;
 699         stats->dwFragFails = ip_stat.ips_cantfrag;
 700         stats->dwReasmTimeout = ip_stat.ips_fragtimeout;
 701         stats->dwOutNoRoutes = ip_stat.ips_noroute;
 702         stats->dwOutRequests = ip_stat.ips_localout;
 703         stats->dwReasmReqds = ip_stat.ips_fragments;
 704         ret = NO_ERROR;
 705     }
 706 #else
 707     FIXME( "unimplemented\n" );
 708 #endif
 709     return ret;
 710 }
 711
 712
 713 /******************************************************************
 714  *    GetTcpStatistics (IPHLPAPI.@)
 715  *
 716  * Get the TCP statistics for the local computer.
 717  *
 718  * PARAMS
 719  *  stats [Out] buffer for TCP statistics
 720  *
 721  * RETURNS
 722  *  Success: NO_ERROR
 723  *  Failure: error code from winerror.h
 724  */
 725 DWORD WINAPI GetTcpStatistics(PMIB_TCPSTATS stats)
 726 {
 727     DWORD ret = ERROR_NOT_SUPPORTED;
 728
 729     if (!stats) return ERROR_INVALID_PARAMETER;
 730     memset( stats, 0, sizeof(*stats) );
 731
 732 #ifdef __linux__
 733     {
 734         FILE *fp;
 735
 736         if ((fp = fopen("/proc/net/snmp", "r")))
 737         {
 738             static const char hdr[] = "Tcp:";
 739             MIB_TCPTABLE *tcp_table;
 740             char buf[512], *ptr;
 741
 742             while ((ptr = fgets(buf, sizeof(buf), fp)))
 743             {
 744                 if (strncasecmp(buf, hdr, sizeof(hdr) - 1)) continue;
 745                 /* last line was a header, get another */
 746                 if (!(ptr = fgets(buf, sizeof(buf), fp))) break;
 747                 if (!strncasecmp(buf, hdr, sizeof(hdr) - 1))
 748                 {
 749                     ptr += sizeof(hdr);
 750                     sscanf( ptr, "%u %u %u %u %u %u %u %u %u %u %u %u %u %u",
 751                             &stats->dwRtoAlgorithm,
 752                             &stats->dwRtoMin,
 753                             &stats->dwRtoMax,
 754                             &stats->dwMaxConn,
 755                             &stats->dwActiveOpens,
 756                             &stats->dwPassiveOpens,
 757                             &stats->dwAttemptFails,
 758                             &stats->dwEstabResets,
 759                             &stats->dwCurrEstab,
 760                             &stats->dwInSegs,
 761                             &stats->dwOutSegs,
 762                             &stats->dwRetransSegs,
 763                             &stats->dwInErrs,
 764                             &stats->dwOutRsts );
 765                     break;
 766                 }
 767             }
 768             if (!AllocateAndGetTcpTableFromStack( &tcp_table, FALSE, GetProcessHeap(), 0 ))
 769             {
 770                 stats->dwNumConns = tcp_table->dwNumEntries;
 771                 HeapFree( GetProcessHeap(), 0, tcp_table );
 772             }
 773             fclose(fp);
 774             ret = NO_ERROR;
 775         }
 776     }
 777 #elif defined(HAVE_LIBKSTAT)
 778     {
 779         static char tcp[] = "tcp";
 780         kstat_ctl_t *kc;
 781         kstat_t *ksp;
 782
 783         if ((kc = kstat_open()) &&
 784             (ksp = kstat_lookup( kc, tcp, 0, tcp )) &&
 785             kstat_read( kc, ksp, NULL ) != -1 &&
 786             ksp->ks_type == KSTAT_TYPE_NAMED)
 787         {
 788             stats->dwRtoAlgorithm = kstat_get_ui32( ksp, "rtoAlgorithm" );
 789             stats->dwRtoMin       = kstat_get_ui32( ksp, "rtoMin" );
 790             stats->dwRtoMax       = kstat_get_ui32( ksp, "rtoMax" );
 791             stats->dwMaxConn      = kstat_get_ui32( ksp, "maxConn" );
 792             stats->dwActiveOpens  = kstat_get_ui32( ksp, "activeOpens" );
 793             stats->dwPassiveOpens = kstat_get_ui32( ksp, "passiveOpens" );
 794             stats->dwAttemptFails = kstat_get_ui32( ksp, "attemptFails" );
 795             stats->dwEstabResets  = kstat_get_ui32( ksp, "estabResets" );
 796             stats->dwCurrEstab    = kstat_get_ui32( ksp, "currEstab" );
 797             stats->dwInSegs       = kstat_get_ui32( ksp, "inSegs" );
 798             stats->dwOutSegs      = kstat_get_ui32( ksp, "outSegs" );
 799             stats->dwRetransSegs  = kstat_get_ui32( ksp, "retransSegs" );
 800             stats->dwInErrs       = kstat_get_ui32( ksp, "inErrs" );
 801             stats->dwOutRsts      = kstat_get_ui32( ksp, "outRsts" );
 802             stats->dwNumConns     = kstat_get_ui32( ksp, "connTableSize" );
 803             ret = NO_ERROR;
 804         }
 805         if (kc) kstat_close( kc );
 806     }
 807 #elif defined(HAVE_SYS_SYSCTL_H) && defined(UDPCTL_STATS)
 808     {
 809 #ifndef TCPTV_MIN  /* got removed in Mac OS X for some reason */
 810 #define TCPTV_MIN 2
 811 #define TCPTV_REXMTMAX 128
 812 #endif
 813         int mib[] = {CTL_NET, PF_INET, IPPROTO_TCP, TCPCTL_STATS};
 814 #define MIB_LEN (sizeof(mib) / sizeof(mib[0]))
 815 #define hz 1000
 816         struct tcpstat tcp_stat;
 817         size_t needed = sizeof(tcp_stat);
 818
 819         if(sysctl(mib, MIB_LEN, &tcp_stat, &needed, NULL, 0) != -1)
 820         {
 821             stats->dwRtoAlgorithm = MIB_TCP_RTO_VANJ;
 822             stats->dwRtoMin = TCPTV_MIN;
 823             stats->dwRtoMax = TCPTV_REXMTMAX;
 824             stats->dwMaxConn = -1;
 825             stats->dwActiveOpens = tcp_stat.tcps_connattempt;
 826             stats->dwPassiveOpens = tcp_stat.tcps_accepts;
 827             stats->dwAttemptFails = tcp_stat.tcps_conndrops;
 828             stats->dwEstabResets = tcp_stat.tcps_drops;
 829             stats->dwCurrEstab = 0;
 830             stats->dwInSegs = tcp_stat.tcps_rcvtotal;
 831             stats->dwOutSegs = tcp_stat.tcps_sndtotal - tcp_stat.tcps_sndrexmitpack;
 832             stats->dwRetransSegs = tcp_stat.tcps_sndrexmitpack;
 833             stats->dwInErrs = tcp_stat.tcps_rcvbadsum + tcp_stat.tcps_rcvbadoff + tcp_stat.tcps_rcvmemdrop + tcp_stat.tcps_rcvshort;
 834             stats->dwOutRsts = tcp_stat.tcps_sndctrl - tcp_stat.tcps_closed;
 835             stats->dwNumConns = tcp_stat.tcps_connects;
 836             ret = NO_ERROR;
 837         }
 838         else ERR ("failed to get tcpstat\n");
 839     }
 840 #else
 841     FIXME( "unimplemented\n" );
 842 #endif
 843     return ret;
 844 }
 845
 846
 847 /******************************************************************
 848  *    GetUdpStatistics (IPHLPAPI.@)
 849  *
 850  * Get the UDP statistics for the local computer.
 851  *
 852  * PARAMS
 853  *  stats [Out] buffer for UDP statistics
 854  *
 855  * RETURNS
 856  *  Success: NO_ERROR
 857  *  Failure: error code from winerror.h
 858  */
 859 DWORD WINAPI GetUdpStatistics(PMIB_UDPSTATS stats)
 860 {
 861     DWORD ret = ERROR_NOT_SUPPORTED;
 862
 863     if (!stats) return ERROR_INVALID_PARAMETER;
 864     memset( stats, 0, sizeof(*stats) );
 865
 866 #ifdef __linux__
 867     {
 868         FILE *fp;
 869
 870         if ((fp = fopen("/proc/net/snmp", "r")))
 871         {
 872             static const char hdr[] = "Udp:";
 873             char buf[512], *ptr;
 874
 875             while ((ptr = fgets(buf, sizeof(buf), fp)))
 876             {
 877                 if (strncasecmp(buf, hdr, sizeof(hdr) - 1)) continue;
 878                 /* last line was a header, get another */
 879                 if (!(ptr = fgets(buf, sizeof(buf), fp))) break;
 880                 if (!strncasecmp(buf, hdr, sizeof(hdr) - 1))
 881                 {
 882                     ptr += sizeof(hdr);
 883                     sscanf( ptr, "%u %u %u %u %u",
 884                             &stats->dwInDatagrams, &stats->dwNoPorts,
 885                             &stats->dwInErrors, &stats->dwOutDatagrams, &stats->dwNumAddrs );
 886                     break;
 887                 }
 888             }
 889             fclose(fp);
 890             ret = NO_ERROR;
 891         }
 892     }
 893 #elif defined(HAVE_LIBKSTAT)
 894     {
 895         static char udp[] = "udp";
 896         kstat_ctl_t *kc;
 897         kstat_t *ksp;
 898         MIB_UDPTABLE *udp_table;
 899
 900         if ((kc = kstat_open()) &&
 901             (ksp = kstat_lookup( kc, udp, 0, udp )) &&
 902             kstat_read( kc, ksp, NULL ) != -1 &&
 903             ksp->ks_type == KSTAT_TYPE_NAMED)
 904         {
 905             stats->dwInDatagrams  = kstat_get_ui32( ksp, "inDatagrams" );
 906             stats->dwNoPorts      = 0;  /* FIXME */
 907             stats->dwInErrors     = kstat_get_ui32( ksp, "inErrors" );
 908             stats->dwOutDatagrams = kstat_get_ui32( ksp, "outDatagrams" );
 909             if (!AllocateAndGetUdpTableFromStack( &udp_table, FALSE, GetProcessHeap(), 0 ))
 910             {
 911                 stats->dwNumAddrs = udp_table->dwNumEntries;
 912                 HeapFree( GetProcessHeap(), 0, udp_table );
 913             }
 914             ret = NO_ERROR;
 915         }
 916         if (kc) kstat_close( kc );
 917     }
 918 #elif defined(HAVE_SYS_SYSCTL_H) && defined(UDPCTL_STATS)
 919     {
 920         int mib[] = {CTL_NET, PF_INET, IPPROTO_UDP, UDPCTL_STATS};
 921 #define MIB_LEN (sizeof(mib) / sizeof(mib[0]))
 922         struct udpstat udp_stat;
 923         MIB_UDPTABLE *udp_table;
 924         size_t needed = sizeof(udp_stat);
 925
 926         if(sysctl(mib, MIB_LEN, &udp_stat, &needed, NULL, 0) != -1)
 927         {
 928             stats->dwInDatagrams = udp_stat.udps_ipackets;
 929             stats->dwOutDatagrams = udp_stat.udps_opackets;
 930             stats->dwNoPorts = udp_stat.udps_noport;
 931             stats->dwInErrors = udp_stat.udps_hdrops + udp_stat.udps_badsum + udp_stat.udps_fullsock + udp_stat.udps_badlen;
 932             if (!AllocateAndGetUdpTableFromStack( &udp_table, FALSE, GetProcessHeap(), 0 ))
 933             {
 934                 stats->dwNumAddrs = udp_table->dwNumEntries;
 935                 HeapFree( GetProcessHeap(), 0, udp_table );
 936             }
 937             ret = NO_ERROR;
 938         }
 939         else ERR ("failed to get udpstat\n");
 940     }
 941 #else
 942     FIXME( "unimplemented\n" );
 943 #endif
 944     return ret;
 945 }
 946
 947
 948 static MIB_IPFORWARDTABLE *append_ipforward_row( HANDLE heap, DWORD flags, MIB_IPFORWARDTABLE *table,
 949                                                  DWORD *count, const MIB_IPFORWARDROW *row )
 950 {
 951     if (table->dwNumEntries >= *count)
 952     {
 953         MIB_IPFORWARDTABLE *new_table;
 954         DWORD new_count = table->dwNumEntries * 2;
 955
 956         if (!(new_table = HeapReAlloc( heap, flags, table,
 957                                        FIELD_OFFSET(MIB_IPFORWARDTABLE, table[new_count] ))))
 958         {
 959             HeapFree( heap, 0, table );
 960             return NULL;
 961         }
 962         *count = new_count;
 963         table = new_table;
 964     }
 965     memcpy( &table->table[table->dwNumEntries++], row, sizeof(*row) );
 966     return table;
 967 }
 968
 969 static int compare_ipforward_rows(const void *a, const void *b)
 970 {
 971     const MIB_IPFORWARDROW *rowA = a;
 972     const MIB_IPFORWARDROW *rowB = b;
 973     int ret;
 974
 975     if ((ret = rowA->dwForwardDest - rowB->dwForwardDest) != 0) return ret;
 976     if ((ret = rowA->dwForwardProto - rowB->dwForwardProto) != 0) return ret;
 977     if ((ret = rowA->dwForwardPolicy - rowB->dwForwardPolicy) != 0) return ret;
 978     return rowA->dwForwardNextHop - rowB->dwForwardNextHop;
 979 }
 980
 981 /******************************************************************
 982  *    AllocateAndGetIpForwardTableFromStack (IPHLPAPI.@)
 983  *
 984  * Get the route table.
 985  * Like GetIpForwardTable(), but allocate the returned table from heap.
 986  *
 987  * PARAMS
 988  *  ppIpForwardTable [Out] pointer into which the MIB_IPFORWARDTABLE is
 989  *                         allocated and returned.
 990  *  bOrder           [In]  whether to sort the table
 991  *  heap             [In]  heap from which the table is allocated
 992  *  flags            [In]  flags to HeapAlloc
 993  *
 994  * RETURNS
 995  *  ERROR_INVALID_PARAMETER if ppIfTable is NULL, other error codes
 996  *  on failure, NO_ERROR on success.
 997  */
 998 DWORD WINAPI AllocateAndGetIpForwardTableFromStack(PMIB_IPFORWARDTABLE *ppIpForwardTable, BOOL bOrder,
 999                                                    HANDLE heap, DWORD flags)
1000 {
1001     MIB_IPFORWARDTABLE *table;
1002     MIB_IPFORWARDROW row;
1003     DWORD ret = NO_ERROR, count = 16;
1004
1005     TRACE("table %p, bOrder %d, heap %p, flags 0x%08x\n", ppIpForwardTable, bOrder, heap, flags);
1006
1007     if (!ppIpForwardTable) return ERROR_INVALID_PARAMETER;
1008
1009     if (!(table = HeapAlloc( heap, flags, FIELD_OFFSET(MIB_IPFORWARDTABLE, table[count] ))))
1010         return ERROR_OUTOFMEMORY;
1011
1012     table->dwNumEntries = 0;
1013
1014 #ifdef __linux__
1015     {
1016         FILE *fp;
1017
1018         if ((fp = fopen("/proc/net/route", "r")))
1019         {
1020             char buf[512], *ptr;
1021             DWORD flags;
1022
1023             /* skip header line */
1024             ptr = fgets(buf, sizeof(buf), fp);
1025             while ((ptr = fgets(buf, sizeof(buf), fp)))
1026             {
1027                 memset( &row, 0, sizeof(row) );
1028
1029                 while (!isspace(*ptr)) ptr++;
1030                 *ptr++ = 0;
1031                 if (getInterfaceIndexByName(buf, &row.dwForwardIfIndex) != NO_ERROR)
1032                     continue;
1033
1034                 row.dwForwardDest = strtoul(ptr, &ptr, 16);
1035                 row.dwForwardNextHop = strtoul(ptr + 1, &ptr, 16);
1036                 flags = strtoul(ptr + 1, &ptr, 16);
1037
1038                 if (!(flags & RTF_UP)) row.dwForwardType = MIB_IPROUTE_TYPE_INVALID;
1039                 else if (flags & RTF_GATEWAY) row.dwForwardType = MIB_IPROUTE_TYPE_INDIRECT;
1040                 else row.dwForwardType = MIB_IPROUTE_TYPE_DIRECT;
1041
1042                 strtoul(ptr + 1, &ptr, 16); /* refcount, skip */
1043                 strtoul(ptr + 1, &ptr, 16); /* use, skip */
1044                 row.dwForwardMetric1 = strtoul(ptr + 1, &ptr, 16);
1045                 row.dwForwardMask = strtoul(ptr + 1, &ptr, 16);
1046                 /* FIXME: other protos might be appropriate, e.g. the default
1047                  * route is typically set with MIB_IPPROTO_NETMGMT instead */
1048                 row.dwForwardProto = MIB_IPPROTO_LOCAL;
1049
1050                 if (!(table = append_ipforward_row( heap, flags, table, &count, &row )))
1051                     break;
1052             }
1053             fclose(fp);
1054         }
1055         else ret = ERROR_NOT_SUPPORTED;
1056     }
1057 #elif defined(HAVE_SYS_TIHDR_H) && defined(T_OPTMGMT_ACK)
1058     {
1059         void *data;
1060         int fd, len, namelen;
1061         mib2_ipRouteEntry_t *entry;
1062         char name[64];
1063
1064         if ((fd = open_streams_mib( NULL )) != -1)
1065         {
1066             if ((data = read_mib_entry( fd, MIB2_IP, MIB2_IP_ROUTE, &len )))
1067             {
1068                 for (entry = data; (char *)(entry + 1) <= (char *)data + len; entry++)
1069                 {
1070                     row.dwForwardDest      = entry->ipRouteDest;
1071                     row.dwForwardMask      = entry->ipRouteMask;
1072                     row.dwForwardPolicy    = 0;
1073                     row.dwForwardNextHop   = entry->ipRouteNextHop;
1074                     row.dwForwardType      = entry->ipRouteType;
1075                     row.dwForwardProto     = entry->ipRouteProto;
1076                     row.dwForwardAge       = entry->ipRouteAge;
1077                     row.dwForwardNextHopAS = 0;
1078                     row.dwForwardMetric1   = entry->ipRouteMetric1;
1079                     row.dwForwardMetric2   = entry->ipRouteMetric2;
1080                     row.dwForwardMetric3   = entry->ipRouteMetric3;
1081                     row.dwForwardMetric4   = entry->ipRouteMetric4;
1082                     row.dwForwardMetric5   = entry->ipRouteMetric5;
1083                     namelen = min( sizeof(name) - 1, entry->ipRouteIfIndex.o_length );
1084                     memcpy( name, entry->ipRouteIfIndex.o_bytes, namelen );
1085                     name[namelen] = 0;
1086                     getInterfaceIndexByName( name, &row.dwForwardIfIndex );
1087                     if (!(table = append_ipforward_row( heap, flags, table, &count, &row ))) break;
1088                 }
1089                 HeapFree( GetProcessHeap(), 0, data );
1090             }
1091             close( fd );
1092         }
1093         else ret = ERROR_NOT_SUPPORTED;
1094     }
1095 #elif defined(HAVE_SYS_SYSCTL_H) && defined(NET_RT_DUMP)
1096     {
1097        int mib[6] = {CTL_NET, PF_ROUTE, 0, PF_INET, NET_RT_DUMP, 0};
1098        size_t needed;
1099        char *buf = NULL, *lim, *next, *addrPtr;
1100        struct rt_msghdr *rtm;
1101
1102        if (sysctl (mib, 6, NULL, &needed, NULL, 0) < 0)
1103        {
1104           ERR ("sysctl 1 failed!\n");
1105           ret = ERROR_NOT_SUPPORTED;
1106           goto done;
1107        }
1108
1109        buf = HeapAlloc (GetProcessHeap (), 0, needed);
1110        if (!buf)
1111        {
1112           ret = ERROR_OUTOFMEMORY;
1113           goto done;
1114        }
1115
1116        if (sysctl (mib, 6, buf, &needed, NULL, 0) < 0)
1117        {
1118           ret = ERROR_NOT_SUPPORTED;
1119           goto done;
1120        }
1121
1122        lim = buf + needed;
1123        for (next = buf; next < lim; next += rtm->rtm_msglen)
1124        {
1125           int i;
1126
1127           rtm = (struct rt_msghdr *)next;
1128
1129           if (rtm->rtm_type != RTM_GET)
1130           {
1131              WARN ("Got unexpected message type 0x%x!\n",
1132                    rtm->rtm_type);
1133              continue;
1134           }
1135
1136           /* Ignore all entries except for gateway routes which aren't
1137              multicast */
1138           if (!(rtm->rtm_flags & RTF_GATEWAY) ||
1139               (rtm->rtm_flags & RTF_MULTICAST))
1140              continue;
1141
1142           memset( &row, 0, sizeof(row) );
1143           row.dwForwardIfIndex = rtm->rtm_index;
1144           row.dwForwardType = MIB_IPROUTE_TYPE_INDIRECT;
1145           row.dwForwardMetric1 = rtm->rtm_rmx.rmx_hopcount;
1146           row.dwForwardProto = MIB_IPPROTO_LOCAL;
1147
1148           addrPtr = (char *)(rtm + 1);
1149
1150           for (i = 1; i; i <<= 1)
1151           {
1152              struct sockaddr *sa;
1153              DWORD addr;
1154
1155              if (!(i & rtm->rtm_addrs))
1156                 continue;
1157
1158              sa = (struct sockaddr *)addrPtr;
1159              ADVANCE (addrPtr, sa);
1160
1161              /* default routes are encoded by length-zero sockaddr */
1162              if (sa->sa_len == 0)
1163                 addr = 0;
1164              else if (sa->sa_family != AF_INET)
1165              {
1166                 WARN ("Received unsupported sockaddr family 0x%x\n",
1167                      sa->sa_family);
1168                 addr = 0;
1169              }
1170              else
1171              {
1172                 struct sockaddr_in *sin = (struct sockaddr_in *)sa;
1173
1174                 addr = sin->sin_addr.s_addr;
1175              }
1176
1177              switch (i)
1178              {
1179                 case RTA_DST:     row.dwForwardDest = addr; break;
1180                 case RTA_GATEWAY: row.dwForwardNextHop = addr; break;
1181                 case RTA_NETMASK: row.dwForwardMask = addr; break;
1182                 default:
1183                    WARN ("Unexpected address type 0x%x\n", i);
1184              }
1185           }
1186
1187           if (!(table = append_ipforward_row( heap, flags, table, &count, &row )))
1188               break;
1189        }
1190 done:
1191       HeapFree( GetProcessHeap (), 0, buf );
1192     }
1193 #else
1194     FIXME( "not implemented\n" );
1195     ret = ERROR_NOT_SUPPORTED;
1196 #endif
1197
1198     if (!table) return ERROR_OUTOFMEMORY;
1199     if (!ret)
1200     {
1201         if (bOrder && table->dwNumEntries)
1202             qsort( table->table, table->dwNumEntries, sizeof(row), compare_ipforward_rows );
1203         *ppIpForwardTable = table;
1204     }
1205     else HeapFree( heap, flags, table );
1206     TRACE( "returning ret %u table %p\n", ret, table );
1207     return ret;
1208 }
1209
1210 static MIB_IPNETTABLE *append_ipnet_row( HANDLE heap, DWORD flags, MIB_IPNETTABLE *table,
1211                                          DWORD *count, const MIB_IPNETROW *row )
1212 {
1213     if (table->dwNumEntries >= *count)
1214     {
1215         MIB_IPNETTABLE *new_table;
1216         DWORD new_count = table->dwNumEntries * 2;
1217
1218         if (!(new_table = HeapReAlloc( heap, flags, table,
1219                                        FIELD_OFFSET(MIB_IPNETTABLE, table[new_count] ))))
1220         {
1221             HeapFree( heap, 0, table );
1222             return NULL;
1223         }
1224         *count = new_count;
1225         table = new_table;
1226     }
1227     memcpy( &table->table[table->dwNumEntries++], row, sizeof(*row) );
1228     return table;
1229 }
1230
1231 static int compare_ipnet_rows(const void *a, const void *b)
1232 {
1233     const MIB_IPNETROW *rowA = a;
1234     const MIB_IPNETROW *rowB = b;
1235
1236     return ntohl(rowA->dwAddr) - ntohl(rowB->dwAddr);
1237 }
1238
1239
1240 /******************************************************************
1241  *    AllocateAndGetIpNetTableFromStack (IPHLPAPI.@)
1242  *
1243  * Get the IP-to-physical address mapping table.
1244  * Like GetIpNetTable(), but allocate the returned table from heap.
1245  *
1246  * PARAMS
1247  *  ppIpNetTable [Out] pointer into which the MIB_IPNETTABLE is
1248  *                     allocated and returned.
1249  *  bOrder       [In]  whether to sort the table
1250  *  heap         [In]  heap from which the table is allocated
1251  *  flags        [In]  flags to HeapAlloc
1252  *
1253  * RETURNS
1254  *  ERROR_INVALID_PARAMETER if ppIpNetTable is NULL, other error codes
1255  *  on failure, NO_ERROR on success.
1256  */
1257 DWORD WINAPI AllocateAndGetIpNetTableFromStack(PMIB_IPNETTABLE *ppIpNetTable, BOOL bOrder,
1258                                                HANDLE heap, DWORD flags)
1259 {
1260     MIB_IPNETTABLE *table;
1261     MIB_IPNETROW row;
1262     DWORD ret = NO_ERROR, count = 16;
1263
1264     TRACE("table %p, bOrder %d, heap %p, flags 0x%08x\n", ppIpNetTable, bOrder, heap, flags);
1265
1266     if (!ppIpNetTable) return ERROR_INVALID_PARAMETER;
1267
1268     if (!(table = HeapAlloc( heap, flags, FIELD_OFFSET(MIB_IPNETTABLE, table[count] ))))
1269         return ERROR_OUTOFMEMORY;
1270
1271     table->dwNumEntries = 0;
1272
1273 #ifdef __linux__
1274     {
1275         FILE *fp;
1276
1277         if ((fp = fopen("/proc/net/arp", "r")))
1278         {
1279             char buf[512], *ptr;
1280             DWORD flags;
1281
1282             /* skip header line */
1283             ptr = fgets(buf, sizeof(buf), fp);
1284             while ((ptr = fgets(buf, sizeof(buf), fp)))
1285             {
1286                 memset( &row, 0, sizeof(row) );
1287
1288                 row.dwAddr = inet_addr(ptr);
1289                 while (*ptr && !isspace(*ptr)) ptr++;
1290                 strtoul(ptr + 1, &ptr, 16); /* hw type (skip) */
1291                 flags = strtoul(ptr + 1, &ptr, 16);
1292
1293 #ifdef ATF_COM
1294                 if (flags & ATF_COM) row.dwType = MIB_IPNET_TYPE_DYNAMIC;
1295                 else
1296 #endif
1297 #ifdef ATF_PERM
1298                 if (flags & ATF_PERM) row.dwType = MIB_IPNET_TYPE_STATIC;
1299                 else
1300 #endif
1301                     row.dwType = MIB_IPNET_TYPE_OTHER;
1302
1303                 while (*ptr && isspace(*ptr)) ptr++;
1304                 while (*ptr && !isspace(*ptr))
1305                 {
1306                     row.bPhysAddr[row.dwPhysAddrLen++] = strtoul(ptr, &ptr, 16);
1307                     if (*ptr) ptr++;
1308                 }
1309                 while (*ptr && isspace(*ptr)) ptr++;
1310                 while (*ptr && !isspace(*ptr)) ptr++;   /* mask (skip) */
1311                 while (*ptr && isspace(*ptr)) ptr++;
1312                 getInterfaceIndexByName(ptr, &row.dwIndex);
1313
1314                 if (!(table = append_ipnet_row( heap, flags, table, &count, &row )))
1315                     break;
1316             }
1317             fclose(fp);
1318         }
1319         else ret = ERROR_NOT_SUPPORTED;
1320     }
1321 #elif defined(HAVE_SYS_TIHDR_H) && defined(T_OPTMGMT_ACK)
1322     {
1323         void *data;
1324         int fd, len, namelen;
1325         mib2_ipNetToMediaEntry_t *entry;
1326         char name[64];
1327
1328         if ((fd = open_streams_mib( NULL )) != -1)
1329         {
1330             if ((data = read_mib_entry( fd, MIB2_IP, MIB2_IP_MEDIA, &len )))
1331             {
1332                 for (entry = data; (char *)(entry + 1) <= (char *)data + len; entry++)
1333                 {
1334                     row.dwPhysAddrLen = min( entry->ipNetToMediaPhysAddress.o_length, MAXLEN_PHYSADDR );
1335                     memcpy( row.bPhysAddr, entry->ipNetToMediaPhysAddress.o_bytes, row.dwPhysAddrLen );
1336                     row.dwAddr = entry->ipNetToMediaNetAddress;
1337                     row.dwType = entry->ipNetToMediaType;
1338                     namelen = min( sizeof(name) - 1, entry->ipNetToMediaIfIndex.o_length );
1339                     memcpy( name, entry->ipNetToMediaIfIndex.o_bytes, namelen );
1340                     name[namelen] = 0;
1341                     getInterfaceIndexByName( name, &row.dwIndex );
1342                     if (!(table = append_ipnet_row( heap, flags, table, &count, &row ))) break;
1343                 }
1344                 HeapFree( GetProcessHeap(), 0, data );
1345             }
1346             close( fd );
1347         }
1348         else ret = ERROR_NOT_SUPPORTED;
1349     }
1350 #elif defined(HAVE_SYS_SYSCTL_H) && defined(NET_RT_DUMP)
1351     {
1352       int mib[] = {CTL_NET, PF_ROUTE, 0, AF_INET, NET_RT_FLAGS, RTF_LLINFO};
1353 #define MIB_LEN (sizeof(mib) / sizeof(mib[0]))
1354       size_t needed;
1355       char *buf = NULL, *lim, *next;
1356       struct rt_msghdr *rtm;
1357       struct sockaddr_inarp *sinarp;
1358       struct sockaddr_dl *sdl;
1359
1360       if (sysctl (mib, MIB_LEN,  NULL, &needed, NULL, 0) == -1)
1361       {
1362          ERR ("failed to get arp table\n");
1363          ret = ERROR_NOT_SUPPORTED;
1364          goto done;
1365       }
1366
1367       buf = HeapAlloc (GetProcessHeap (), 0, needed);
1368       if (!buf)
1369       {
1370           ret = ERROR_OUTOFMEMORY;
1371           goto done;
1372       }
1373
1374       if (sysctl (mib, MIB_LEN, buf, &needed, NULL, 0) == -1)
1375       {
1376          ret = ERROR_NOT_SUPPORTED;
1377          goto done;
1378       }
1379
1380       lim = buf + needed;
1381       next = buf;
1382       while(next < lim)
1383       {
1384           rtm = (struct rt_msghdr *)next;
1385           sinarp=(struct sockaddr_inarp *)(rtm + 1);
1386           sdl = (struct sockaddr_dl *)((char *)sinarp + ROUNDUP(sinarp->sin_len));
1387           if(sdl->sdl_alen) /* arp entry */
1388           {
1389               memset( &row, 0, sizeof(row) );
1390               row.dwAddr = sinarp->sin_addr.s_addr;
1391               row.dwIndex = sdl->sdl_index;
1392               row.dwPhysAddrLen = min( 8, sdl->sdl_alen );
1393               memcpy( row.bPhysAddr, &sdl->sdl_data[sdl->sdl_nlen], row.dwPhysAddrLen );
1394               if(rtm->rtm_rmx.rmx_expire == 0) row.dwType = MIB_IPNET_TYPE_STATIC;
1395               else if(sinarp->sin_other & SIN_PROXY) row.dwType = MIB_IPNET_TYPE_OTHER;
1396               else if(rtm->rtm_rmx.rmx_expire != 0) row.dwType = MIB_IPNET_TYPE_DYNAMIC;
1397               else row.dwType = MIB_IPNET_TYPE_INVALID;
1398
1399               if (!(table = append_ipnet_row( heap, flags, table, &count, &row )))
1400                   break;
1401           }
1402           next += rtm->rtm_msglen;
1403       }
1404 done:
1405       HeapFree( GetProcessHeap (), 0, buf );
1406     }
1407 #else
1408     FIXME( "not implemented\n" );
1409     ret = ERROR_NOT_SUPPORTED;
1410 #endif
1411
1412     if (!table) return ERROR_OUTOFMEMORY;
1413     if (!ret)
1414     {
1415         if (bOrder && table->dwNumEntries)
1416             qsort( table->table, table->dwNumEntries, sizeof(row), compare_ipnet_rows );
1417         *ppIpNetTable = table;
1418     }
1419     else HeapFree( heap, flags, table );
1420     TRACE( "returning ret %u table %p\n", ret, table );
1421     return ret;
1422 }
1423
1424
1425 static MIB_UDPTABLE *append_udp_row( HANDLE heap, DWORD flags, MIB_UDPTABLE *table,
1426                                      DWORD *count, const MIB_UDPROW *row )
1427 {
1428     if (table->dwNumEntries >= *count)
1429     {
1430         MIB_UDPTABLE *new_table;
1431         DWORD new_count = table->dwNumEntries * 2;
1432
1433         if (!(new_table = HeapReAlloc( heap, flags, table, FIELD_OFFSET(MIB_UDPTABLE, table[new_count] ))))
1434         {
1435             HeapFree( heap, 0, table );
1436             return NULL;
1437         }
1438         *count = new_count;
1439         table = new_table;
1440     }
1441     memcpy( &table->table[table->dwNumEntries++], row, sizeof(*row) );
1442     return table;
1443 }
1444
1445 static int compare_udp_rows(const void *a, const void *b)
1446 {
1447     const MIB_UDPROW *rowA = a;
1448     const MIB_UDPROW *rowB = b;
1449     int ret;
1450
1451     if ((ret = rowA->dwLocalAddr - rowB->dwLocalAddr) != 0) return ret;
1452     return rowA->dwLocalPort - rowB->dwLocalPort;
1453 }
1454
1455
1456 /******************************************************************
1457  *    AllocateAndGetUdpTableFromStack (IPHLPAPI.@)
1458  *
1459  * Get the UDP listener table.
1460  * Like GetUdpTable(), but allocate the returned table from heap.
1461  *
1462  * PARAMS
1463  *  ppUdpTable [Out] pointer into which the MIB_UDPTABLE is
1464  *                   allocated and returned.
1465  *  bOrder     [In]  whether to sort the table
1466  *  heap       [In]  heap from which the table is allocated
1467  *  flags      [In]  flags to HeapAlloc
1468  *
1469  * RETURNS
1470  *  ERROR_INVALID_PARAMETER if ppUdpTable is NULL, whatever GetUdpTable()
1471  *  returns otherwise.
1472  */
1473 DWORD WINAPI AllocateAndGetUdpTableFromStack(PMIB_UDPTABLE *ppUdpTable, BOOL bOrder,
1474                                              HANDLE heap, DWORD flags)
1475 {
1476     MIB_UDPTABLE *table;
1477     MIB_UDPROW row;
1478     DWORD ret = NO_ERROR, count = 16;
1479
1480     TRACE("table %p, bOrder %d, heap %p, flags 0x%08x\n", ppUdpTable, bOrder, heap, flags);
1481
1482     if (!ppUdpTable) return ERROR_INVALID_PARAMETER;
1483
1484     if (!(table = HeapAlloc( heap, flags, FIELD_OFFSET(MIB_UDPTABLE, table[count] ))))
1485         return ERROR_OUTOFMEMORY;
1486
1487     table->dwNumEntries = 0;
1488
1489 #ifdef __linux__
1490     {
1491         FILE *fp;
1492
1493         if ((fp = fopen("/proc/net/udp", "r")))
1494         {
1495             char buf[512], *ptr;
1496             DWORD dummy;
1497
1498             /* skip header line */
1499             ptr = fgets(buf, sizeof(buf), fp);
1500             while ((ptr = fgets(buf, sizeof(buf), fp)))
1501             {
1502                 if (sscanf( ptr, "%u: %x:%x", &dummy, &row.dwLocalAddr, &row.dwLocalPort ) != 3)
1503                     continue;
1504                 row.dwLocalPort = htons( row.dwLocalPort );
1505                 if (!(table = append_udp_row( heap, flags, table, &count, &row )))
1506                     break;
1507             }
1508             fclose(fp);
1509         }
1510         else ret = ERROR_NOT_SUPPORTED;
1511     }
1512 #elif defined(HAVE_SYS_TIHDR_H) && defined(T_OPTMGMT_ACK)
1513     {
1514         void *data;
1515         int fd, len;
1516         mib2_udpEntry_t *entry;
1517
1518         if ((fd = open_streams_mib( "udp" )) != -1)
1519         {
1520             if ((data = read_mib_entry( fd, MIB2_UDP, MIB2_UDP_ENTRY, &len )))
1521             {
1522                 for (entry = data; (char *)(entry + 1) <= (char *)data + len; entry++)
1523                 {
1524                     row.dwLocalAddr = entry->udpLocalAddress;
1525                     row.dwLocalPort = htons( entry->udpLocalPort );
1526                     if (!(table = append_udp_row( heap, flags, table, &count, &row ))) break;
1527                 }
1528                 HeapFree( GetProcessHeap(), 0, data );
1529             }
1530             close( fd );
1531         }
1532         else ret = ERROR_NOT_SUPPORTED;
1533     }
1534 #else
1535     FIXME( "not implemented\n" );
1536     ret = ERROR_NOT_SUPPORTED;
1537 #endif
1538
1539     if (!table) return ERROR_OUTOFMEMORY;
1540     if (!ret)
1541     {
1542         if (bOrder && table->dwNumEntries)
1543             qsort( table->table, table->dwNumEntries, sizeof(row), compare_udp_rows );
1544         *ppUdpTable = table;
1545     }
1546     else HeapFree( heap, flags, table );
1547     TRACE( "returning ret %u table %p\n", ret, table );
1548     return ret;
1549 }
1550
1551
1552 static MIB_TCPTABLE *append_tcp_row( HANDLE heap, DWORD flags, MIB_TCPTABLE *table,
1553                                      DWORD *count, const MIB_TCPROW *row )
1554 {
1555     if (table->dwNumEntries >= *count)
1556     {
1557         MIB_TCPTABLE *new_table;
1558         DWORD new_count = table->dwNumEntries * 2;
1559
1560         if (!(new_table = HeapReAlloc( heap, flags, table, FIELD_OFFSET(MIB_TCPTABLE, table[new_count] ))))
1561         {
1562             HeapFree( heap, 0, table );
1563             return NULL;
1564         }
1565         *count = new_count;
1566         table = new_table;
1567     }
1568     memcpy( &table->table[table->dwNumEntries++], row, sizeof(*row) );
1569     return table;
1570 }
1571
1572
1573 /* Why not a lookup table? Because the TCPS_* constants are different
1574    on different platforms */
1575 static inline DWORD TCPStateToMIBState (int state)
1576 {
1577    switch (state)
1578    {
1579       case TCPS_ESTABLISHED: return MIB_TCP_STATE_ESTAB;
1580       case TCPS_SYN_SENT: return MIB_TCP_STATE_SYN_SENT;
1581       case TCPS_SYN_RECEIVED: return MIB_TCP_STATE_SYN_RCVD;
1582       case TCPS_FIN_WAIT_1: return MIB_TCP_STATE_FIN_WAIT1;
1583       case TCPS_FIN_WAIT_2: return MIB_TCP_STATE_FIN_WAIT2;
1584       case TCPS_TIME_WAIT: return MIB_TCP_STATE_TIME_WAIT;
1585       case TCPS_CLOSE_WAIT: return MIB_TCP_STATE_CLOSE_WAIT;
1586       case TCPS_LAST_ACK: return MIB_TCP_STATE_LAST_ACK;
1587       case TCPS_LISTEN: return MIB_TCP_STATE_LISTEN;
1588       case TCPS_CLOSING: return MIB_TCP_STATE_CLOSING;
1589       default:
1590       case TCPS_CLOSED: return MIB_TCP_STATE_CLOSED;
1591    }
1592 }
1593
1594
1595 static int compare_tcp_rows(const void *a, const void *b)
1596 {
1597     const MIB_TCPROW *rowA = a;
1598     const MIB_TCPROW *rowB = b;
1599     int ret;
1600
1601     if ((ret = ntohl (rowA->dwLocalAddr) - ntohl (rowB->dwLocalAddr)) != 0) return ret;
1602     if ((ret = ntohs ((unsigned short)rowA->dwLocalPort) -
1603                ntohs ((unsigned short)rowB->dwLocalPort)) != 0) return ret;
1604     if ((ret = ntohl (rowA->dwRemoteAddr) - ntohl (rowB->dwRemoteAddr)) != 0) return ret;
1605     return ntohs ((unsigned short)rowA->dwRemotePort) - ntohs ((unsigned short)rowB->dwRemotePort);
1606 }
1607
1608
1609 /******************************************************************
1610  *    AllocateAndGetTcpTableFromStack (IPHLPAPI.@)
1611  *
1612  * Get the TCP connection table.
1613  * Like GetTcpTable(), but allocate the returned table from heap.
1614  *
1615  * PARAMS
1616  *  ppTcpTable [Out] pointer into which the MIB_TCPTABLE is
1617  *                   allocated and returned.
1618  *  bOrder     [In]  whether to sort the table
1619  *  heap       [In]  heap from which the table is allocated
1620  *  flags      [In]  flags to HeapAlloc
1621  *
1622  * RETURNS
1623  *  ERROR_INVALID_PARAMETER if ppTcpTable is NULL, whatever GetTcpTable()
1624  *  returns otherwise.
1625  */
1626 DWORD WINAPI AllocateAndGetTcpTableFromStack( PMIB_TCPTABLE *ppTcpTable, BOOL bOrder,
1627                                               HANDLE heap, DWORD flags)
1628 {
1629     MIB_TCPTABLE *table;
1630     MIB_TCPROW row;
1631     DWORD ret = NO_ERROR, count = 16;
1632
1633     TRACE("table %p, bOrder %d, heap %p, flags 0x%08x\n", ppTcpTable, bOrder, heap, flags);
1634
1635     if (!ppTcpTable) return ERROR_INVALID_PARAMETER;
1636
1637     if (!(table = HeapAlloc( heap, flags, FIELD_OFFSET(MIB_TCPTABLE, table[count] ))))
1638         return ERROR_OUTOFMEMORY;
1639
1640     table->dwNumEntries = 0;
1641
1642 #ifdef __linux__
1643     {
1644         FILE *fp;
1645
1646         if ((fp = fopen("/proc/net/tcp", "r")))
1647         {
1648             char buf[512], *ptr;
1649             DWORD dummy;
1650
1651             /* skip header line */
1652             ptr = fgets(buf, sizeof(buf), fp);
1653             while ((ptr = fgets(buf, sizeof(buf), fp)))
1654             {
1655                 if (sscanf( ptr, "%x: %x:%x %x:%x %x", &dummy, &row.dwLocalAddr, &row.dwLocalPort,
1656                             &row.dwRemoteAddr, &row.dwRemotePort, &row.dwState ) != 6)
1657                     continue;
1658                 row.dwLocalPort = htons( row.dwLocalPort );
1659                 row.dwRemotePort = htons( row.dwRemotePort );
1660                 row.dwState = TCPStateToMIBState( row.dwState );
1661                 if (!(table = append_tcp_row( heap, flags, table, &count, &row )))
1662                     break;
1663             }
1664             fclose( fp );
1665         }
1666         else ret = ERROR_NOT_SUPPORTED;
1667     }
1668 #elif defined(HAVE_SYS_TIHDR_H) && defined(T_OPTMGMT_ACK)
1669     {
1670         void *data;
1671         int fd, len;
1672         mib2_tcpConnEntry_t *entry;
1673
1674         if ((fd = open_streams_mib( "tcp" )) != -1)
1675         {
1676             if ((data = read_mib_entry( fd, MIB2_TCP, MIB2_TCP_CONN, &len )))
1677             {
1678                 for (entry = data; (char *)(entry + 1) <= (char *)data + len; entry++)
1679                 {
1680                     row.dwLocalAddr = entry->tcpConnLocalAddress;
1681                     row.dwLocalPort = htons( entry->tcpConnLocalPort );
1682                     row.dwRemoteAddr = entry->tcpConnRemAddress;
1683                     row.dwRemotePort = htons( entry->tcpConnRemPort );
1684                     row.dwState = entry->tcpConnState;
1685                     if (!(table = append_tcp_row( heap, flags, table, &count, &row ))) break;
1686                 }
1687                 HeapFree( GetProcessHeap(), 0, data );
1688             }
1689             close( fd );
1690         }
1691         else ret = ERROR_NOT_SUPPORTED;
1692     }
1693 #elif defined(HAVE_SYS_SYSCTL_H) && defined(HAVE_STRUCT_XINPGEN)
1694     {
1695         size_t Len = 0;
1696         char *Buf = NULL;
1697         struct xinpgen *pXIG, *pOrigXIG;
1698
1699         if (sysctlbyname ("net.inet.tcp.pcblist", NULL, &Len, NULL, 0) < 0)
1700         {
1701             ERR ("Failure to read net.inet.tcp.pcblist via sysctlbyname!\n");
1702             ret = ERROR_NOT_SUPPORTED;
1703             goto done;
1704         }
1705
1706         Buf = HeapAlloc (GetProcessHeap (), 0, Len);
1707         if (!Buf)
1708         {
1709             ret = ERROR_OUTOFMEMORY;
1710             goto done;
1711         }
1712
1713         if (sysctlbyname ("net.inet.tcp.pcblist", Buf, &Len, NULL, 0) < 0)
1714         {
1715             ERR ("Failure to read net.inet.tcp.pcblist via sysctlbyname!\n");
1716             ret = ERROR_NOT_SUPPORTED;
1717             goto done;
1718         }
1719
1720         /* Might be nothing here; first entry is just a header it seems */
1721         if (Len <= sizeof (struct xinpgen)) goto done;
1722
1723         pOrigXIG = (struct xinpgen *)Buf;
1724         pXIG = pOrigXIG;
1725
1726         for (pXIG = (struct xinpgen *)((char *)pXIG + pXIG->xig_len);
1727              pXIG->xig_len > sizeof (struct xinpgen);
1728              pXIG = (struct xinpgen *)((char *)pXIG + pXIG->xig_len))
1729         {
1730             struct tcpcb *pTCPData = NULL;
1731             struct inpcb *pINData;
1732             struct xsocket *pSockData;
1733
1734             pTCPData = &((struct xtcpcb *)pXIG)->xt_tp;
1735             pINData = &((struct xtcpcb *)pXIG)->xt_inp;
1736             pSockData = &((struct xtcpcb *)pXIG)->xt_socket;
1737
1738             /* Ignore sockets for other protocols */
1739             if (pSockData->xso_protocol != IPPROTO_TCP)
1740                 continue;
1741
1742             /* Ignore PCBs that were freed while generating the data */
1743             if (pINData->inp_gencnt > pOrigXIG->xig_gen)
1744                 continue;
1745
1746             /* we're only interested in IPv4 addresses */
1747             if (!(pINData->inp_vflag & INP_IPV4) ||
1748                 (pINData->inp_vflag & INP_IPV6))
1749                 continue;
1750
1751             /* If all 0's, skip it */
1752             if (!pINData->inp_laddr.s_addr &&
1753                 !pINData->inp_lport &&
1754                 !pINData->inp_faddr.s_addr &&
1755                 !pINData->inp_fport)
1756                 continue;
1757
1758             /* Fill in structure details */
1759             row.dwLocalAddr = pINData->inp_laddr.s_addr;
1760             row.dwLocalPort = pINData->inp_lport;
1761             row.dwRemoteAddr = pINData->inp_faddr.s_addr;
1762             row.dwRemotePort = pINData->inp_fport;
1763             row.dwState = TCPStateToMIBState (pTCPData->t_state);
1764             if (!(table = append_tcp_row( heap, flags, table, &count, &row ))) break;
1765         }
1766
1767     done:
1768         HeapFree (GetProcessHeap (), 0, Buf);
1769     }
1770 #else
1771     FIXME( "not implemented\n" );
1772     ret = ERROR_NOT_SUPPORTED;
1773 #endif
1774
1775     if (!table) return ERROR_OUTOFMEMORY;
1776     if (!ret)
1777     {
1778         if (bOrder && table->dwNumEntries)
1779             qsort( table->table, table->dwNumEntries, sizeof(row), compare_tcp_rows );
1780         *ppTcpTable = table;
1781     }
1782     else HeapFree( heap, flags, table );
1783     TRACE( "returning ret %u table %p\n", ret, table );
1784     return ret;
1785 }