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