advpack: Forward SetPerUserSecValuesA to its Unicode counterpart.
[wine] / dlls / iphlpapi / ipstats.c
1 /* Copyright (C) 2003,2006 Juan Lang
2  *
3  * This library is free software; you can redistribute it and/or
4  * modify it under the terms of the GNU Lesser General Public
5  * License as published by the Free Software Foundation; either
6  * version 2.1 of the License, or (at your option) any later version.
7  *
8  * This library is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11  * Lesser General Public License for more details.
12  *
13  * You should have received a copy of the GNU Lesser General Public
14  * License along with this library; if not, write to the Free Software
15  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16  *
17  * This file implements statistics getting using the /proc filesystem exported
18  * by Linux, and maybe other OSes.
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 <sys/types.h>
29 #ifdef HAVE_SYS_SOCKET_H
30 #include <sys/socket.h>
31 #endif
32 #ifdef HAVE_NETINET_IN_H
33 #include <netinet/in.h>
34 #endif
35 #ifdef HAVE_ARPA_INET_H
36 #include <arpa/inet.h>
37 #endif
38 #ifdef HAVE_NET_IF_H
39 #include <net/if.h>
40 #endif
41 #ifdef HAVE_NET_ROUTE_H
42 #include <net/route.h>
43 #endif
44 #ifdef HAVE_NET_IF_ARP_H
45 #include <net/if_arp.h>
46 #endif
47 #ifdef HAVE_NETINET_TCP_H
48 #include <netinet/tcp.h>
49 #endif
50 #ifdef HAVE_NETINET_TCP_FSM_H
51 #include <netinet/tcp_fsm.h>
52 #endif
53
54 #include "windef.h"
55 #include "winbase.h"
56 #include "iprtrmib.h"
57 #include "ifenum.h"
58 #include "ipstats.h"
59
60 #ifdef linux
61 #define TCPS_ESTABLISHED  1
62 #define TCPS_SYN_SENT     2
63 #define TCPS_SYN_RECEIVED 3
64 #define TCPS_FIN_WAIT_1   4
65 #define TCPS_FIN_WAIT_2   5
66 #define TCPS_TIME_WAIT    6
67 #define TCPS_CLOSED       7
68 #define TCPS_CLOSE_WAIT   8
69 #define TCPS_LAST_ACK     9
70 #define TCPS_LISTEN      10
71 #define TCPS_CLOSING     11
72 #endif
73
74 DWORD getInterfaceStatsByName(const char *name, PMIB_IFROW entry)
75 {
76   FILE *fp;
77
78   if (!name)
79     return ERROR_INVALID_PARAMETER;
80   if (!entry)
81     return ERROR_INVALID_PARAMETER;
82
83   /* get interface stats from /proc/net/dev, no error if can't
84      no inUnknownProtos, outNUcastPkts, outQLen */
85   fp = fopen("/proc/net/dev", "r");
86   if (fp) {
87     char buf[512] = { 0 }, *ptr;
88     int nameLen = strlen(name), nameFound = 0;
89
90
91     ptr = fgets(buf, sizeof(buf), fp);
92     while (ptr && !nameFound) {
93       while (*ptr && isspace(*ptr))
94         ptr++;
95       if (strncasecmp(ptr, name, nameLen) == 0 && *(ptr + nameLen) == ':')
96         nameFound = 1;
97       else
98         ptr = fgets(buf, sizeof(buf), fp);
99     }
100     if (nameFound) {
101       char *endPtr;
102
103       ptr += nameLen + 1;
104       if (ptr && *ptr) {
105         entry->dwInOctets = strtoul(ptr, &endPtr, 10);
106         ptr = endPtr;
107       }
108       if (ptr && *ptr) {
109         entry->dwInUcastPkts = strtoul(ptr, &endPtr, 10);
110         ptr = endPtr;
111       }
112       if (ptr && *ptr) {
113         entry->dwInErrors = strtoul(ptr, &endPtr, 10);
114         ptr = endPtr;
115       }
116       if (ptr && *ptr) {
117         entry->dwInDiscards = strtoul(ptr, &endPtr, 10);
118         ptr = endPtr;
119       }
120       if (ptr && *ptr) {
121         strtoul(ptr, &endPtr, 10); /* skip */
122         ptr = endPtr;
123       }
124       if (ptr && *ptr) {
125         strtoul(ptr, &endPtr, 10); /* skip */
126         ptr = endPtr;
127       }
128       if (ptr && *ptr) {
129         strtoul(ptr, &endPtr, 10); /* skip */
130         ptr = endPtr;
131       }
132       if (ptr && *ptr) {
133         entry->dwInNUcastPkts = strtoul(ptr, &endPtr, 10);
134         ptr = endPtr;
135       }
136       if (ptr && *ptr) {
137         entry->dwOutOctets = strtoul(ptr, &endPtr, 10);
138         ptr = endPtr;
139       }
140       if (ptr && *ptr) {
141         entry->dwOutUcastPkts = strtoul(ptr, &endPtr, 10);
142         ptr = endPtr;
143       }
144       if (ptr && *ptr) {
145         entry->dwOutErrors = strtoul(ptr, &endPtr, 10);
146         ptr = endPtr;
147       }
148       if (ptr && *ptr) {
149         entry->dwOutDiscards = strtoul(ptr, &endPtr, 10);
150         ptr = endPtr;
151       }
152     }
153     fclose(fp);
154   }
155   return NO_ERROR;
156 }
157
158 DWORD getICMPStats(MIB_ICMP *stats)
159 {
160   FILE *fp;
161
162   if (!stats)
163     return ERROR_INVALID_PARAMETER;
164
165   memset(stats, 0, sizeof(MIB_ICMP));
166   /* get most of these stats from /proc/net/snmp, no error if can't */
167   fp = fopen("/proc/net/snmp", "r");
168   if (fp) {
169     static const char hdr[] = "Icmp:";
170     char buf[512] = { 0 }, *ptr;
171
172     do {
173       ptr = fgets(buf, sizeof(buf), fp);
174     } while (ptr && strncasecmp(buf, hdr, sizeof(hdr) - 1));
175     if (ptr) {
176       /* last line was a header, get another */
177       ptr = fgets(buf, sizeof(buf), fp);
178       if (ptr && strncasecmp(buf, hdr, sizeof(hdr) - 1) == 0) {
179         char *endPtr;
180
181         ptr += sizeof(hdr);
182         if (ptr && *ptr) {
183           stats->stats.icmpInStats.dwMsgs = strtoul(ptr, &endPtr, 10);
184           ptr = endPtr;
185         }
186         if (ptr && *ptr) {
187           stats->stats.icmpInStats.dwErrors = strtoul(ptr, &endPtr, 10);
188           ptr = endPtr;
189         }
190         if (ptr && *ptr) {
191           stats->stats.icmpInStats.dwDestUnreachs = strtoul(ptr, &endPtr, 10);
192           ptr = endPtr;
193         }
194         if (ptr && *ptr) {
195           stats->stats.icmpInStats.dwTimeExcds = strtoul(ptr, &endPtr, 10);
196           ptr = endPtr;
197         }
198         if (ptr && *ptr) {
199           stats->stats.icmpInStats.dwParmProbs = strtoul(ptr, &endPtr, 10);
200           ptr = endPtr;
201         }
202         if (ptr && *ptr) {
203           stats->stats.icmpInStats.dwSrcQuenchs = strtoul(ptr, &endPtr, 10);
204           ptr = endPtr;
205         }
206         if (ptr && *ptr) {
207           stats->stats.icmpInStats.dwRedirects = strtoul(ptr, &endPtr, 10);
208           ptr = endPtr;
209         }
210         if (ptr && *ptr) {
211           stats->stats.icmpInStats.dwEchoReps = strtoul(ptr, &endPtr, 10);
212           ptr = endPtr;
213         }
214         if (ptr && *ptr) {
215           stats->stats.icmpInStats.dwTimestamps = strtoul(ptr, &endPtr, 10);
216           ptr = endPtr;
217         }
218         if (ptr && *ptr) {
219           stats->stats.icmpInStats.dwTimestampReps = strtoul(ptr, &endPtr, 10);
220           ptr = endPtr;
221         }
222         if (ptr && *ptr) {
223           stats->stats.icmpInStats.dwAddrMasks = strtoul(ptr, &endPtr, 10);
224           ptr = endPtr;
225         }
226         if (ptr && *ptr) {
227           stats->stats.icmpInStats.dwAddrMaskReps = strtoul(ptr, &endPtr, 10);
228           ptr = endPtr;
229         }
230         if (ptr && *ptr) {
231           stats->stats.icmpOutStats.dwMsgs = strtoul(ptr, &endPtr, 10);
232           ptr = endPtr;
233         }
234         if (ptr && *ptr) {
235           stats->stats.icmpOutStats.dwErrors = strtoul(ptr, &endPtr, 10);
236           ptr = endPtr;
237         }
238         if (ptr && *ptr) {
239           stats->stats.icmpOutStats.dwDestUnreachs = strtoul(ptr, &endPtr, 10);
240           ptr = endPtr;
241         }
242         if (ptr && *ptr) {
243           stats->stats.icmpOutStats.dwTimeExcds = strtoul(ptr, &endPtr, 10);
244           ptr = endPtr;
245         }
246         if (ptr && *ptr) {
247           stats->stats.icmpOutStats.dwParmProbs = strtoul(ptr, &endPtr, 10);
248           ptr = endPtr;
249         }
250         if (ptr && *ptr) {
251           stats->stats.icmpOutStats.dwSrcQuenchs = strtoul(ptr, &endPtr, 10);
252           ptr = endPtr;
253         }
254         if (ptr && *ptr) {
255           stats->stats.icmpOutStats.dwRedirects = strtoul(ptr, &endPtr, 10);
256           ptr = endPtr;
257         }
258         if (ptr && *ptr) {
259           stats->stats.icmpOutStats.dwEchoReps = strtoul(ptr, &endPtr, 10);
260           ptr = endPtr;
261         }
262         if (ptr && *ptr) {
263           stats->stats.icmpOutStats.dwTimestamps = strtoul(ptr, &endPtr, 10);
264           ptr = endPtr;
265         }
266         if (ptr && *ptr) {
267           stats->stats.icmpOutStats.dwTimestampReps = strtoul(ptr, &endPtr, 10);
268           ptr = endPtr;
269         }
270         if (ptr && *ptr) {
271           stats->stats.icmpOutStats.dwAddrMasks = strtoul(ptr, &endPtr, 10);
272           ptr = endPtr;
273         }
274         if (ptr && *ptr) {
275           stats->stats.icmpOutStats.dwAddrMaskReps = strtoul(ptr, &endPtr, 10);
276           ptr = endPtr;
277         }
278       }
279     }
280     fclose(fp);
281   }
282   return NO_ERROR;
283 }
284
285 DWORD getIPStats(PMIB_IPSTATS stats)
286 {
287   FILE *fp;
288
289   if (!stats)
290     return ERROR_INVALID_PARAMETER;
291
292   memset(stats, 0, sizeof(MIB_IPSTATS));
293   stats->dwNumIf = stats->dwNumAddr = getNumInterfaces();
294   stats->dwNumRoutes = getNumRoutes();
295
296   /* get most of these stats from /proc/net/snmp, no error if can't */
297   fp = fopen("/proc/net/snmp", "r");
298   if (fp) {
299     static const char hdr[] = "Ip:";
300     char buf[512] = { 0 }, *ptr;
301
302     do {
303       ptr = fgets(buf, sizeof(buf), fp);
304     } while (ptr && strncasecmp(buf, hdr, sizeof(hdr) - 1));
305     if (ptr) {
306       /* last line was a header, get another */
307       ptr = fgets(buf, sizeof(buf), fp);
308       if (ptr && strncasecmp(buf, hdr, sizeof(hdr) - 1) == 0) {
309         char *endPtr;
310
311         ptr += sizeof(hdr);
312         if (ptr && *ptr) {
313           stats->dwForwarding = strtoul(ptr, &endPtr, 10);
314           ptr = endPtr;
315         }
316         if (ptr && *ptr) {
317           stats->dwDefaultTTL = strtoul(ptr, &endPtr, 10);
318           ptr = endPtr;
319         }
320         if (ptr && *ptr) {
321           stats->dwInReceives = strtoul(ptr, &endPtr, 10);
322           ptr = endPtr;
323         }
324         if (ptr && *ptr) {
325           stats->dwInHdrErrors = strtoul(ptr, &endPtr, 10);
326           ptr = endPtr;
327         }
328         if (ptr && *ptr) {
329           stats->dwInAddrErrors = strtoul(ptr, &endPtr, 10);
330           ptr = endPtr;
331         }
332         if (ptr && *ptr) {
333           stats->dwForwDatagrams = strtoul(ptr, &endPtr, 10);
334           ptr = endPtr;
335         }
336         if (ptr && *ptr) {
337           stats->dwInUnknownProtos = strtoul(ptr, &endPtr, 10);
338           ptr = endPtr;
339         }
340         if (ptr && *ptr) {
341           stats->dwInDiscards = strtoul(ptr, &endPtr, 10);
342           ptr = endPtr;
343         }
344         if (ptr && *ptr) {
345           stats->dwInDelivers = strtoul(ptr, &endPtr, 10);
346           ptr = endPtr;
347         }
348         if (ptr && *ptr) {
349           stats->dwOutRequests = strtoul(ptr, &endPtr, 10);
350           ptr = endPtr;
351         }
352         if (ptr && *ptr) {
353           stats->dwOutDiscards = strtoul(ptr, &endPtr, 10);
354           ptr = endPtr;
355         }
356         if (ptr && *ptr) {
357           stats->dwOutNoRoutes = strtoul(ptr, &endPtr, 10);
358           ptr = endPtr;
359         }
360         if (ptr && *ptr) {
361           stats->dwReasmTimeout = strtoul(ptr, &endPtr, 10);
362           ptr = endPtr;
363         }
364         if (ptr && *ptr) {
365           stats->dwReasmReqds = strtoul(ptr, &endPtr, 10);
366           ptr = endPtr;
367         }
368         if (ptr && *ptr) {
369           stats->dwReasmOks = strtoul(ptr, &endPtr, 10);
370           ptr = endPtr;
371         }
372         if (ptr && *ptr) {
373           stats->dwReasmFails = strtoul(ptr, &endPtr, 10);
374           ptr = endPtr;
375         }
376         if (ptr && *ptr) {
377           stats->dwFragOks = strtoul(ptr, &endPtr, 10);
378           ptr = endPtr;
379         }
380         if (ptr && *ptr) {
381           stats->dwFragFails = strtoul(ptr, &endPtr, 10);
382           ptr = endPtr;
383         }
384         if (ptr && *ptr) {
385           stats->dwFragCreates = strtoul(ptr, &endPtr, 10);
386           ptr = endPtr;
387         }
388         /* hmm, no routingDiscards */
389       }
390     }
391     fclose(fp);
392   }
393   return NO_ERROR;
394 }
395
396 DWORD getTCPStats(MIB_TCPSTATS *stats)
397 {
398   FILE *fp;
399
400   if (!stats)
401     return ERROR_INVALID_PARAMETER;
402
403   memset(stats, 0, sizeof(MIB_TCPSTATS));
404
405   /* get from /proc/net/snmp, no error if can't */
406   fp = fopen("/proc/net/snmp", "r");
407   if (fp) {
408     static const char hdr[] = "Tcp:";
409     char buf[512] = { 0 }, *ptr;
410
411
412     do {
413       ptr = fgets(buf, sizeof(buf), fp);
414     } while (ptr && strncasecmp(buf, hdr, sizeof(hdr) - 1));
415     if (ptr) {
416       /* last line was a header, get another */
417       ptr = fgets(buf, sizeof(buf), fp);
418       if (ptr && strncasecmp(buf, hdr, sizeof(hdr) - 1) == 0) {
419         char *endPtr;
420
421         ptr += sizeof(hdr);
422         if (ptr && *ptr) {
423           stats->dwRtoAlgorithm = strtoul(ptr, &endPtr, 10);
424           ptr = endPtr;
425         }
426         if (ptr && *ptr) {
427           stats->dwRtoMin = strtoul(ptr, &endPtr, 10);
428           ptr = endPtr;
429         }
430         if (ptr && *ptr) {
431           stats->dwRtoMin = strtoul(ptr, &endPtr, 10);
432           ptr = endPtr;
433         }
434         if (ptr && *ptr) {
435           stats->dwMaxConn = strtoul(ptr, &endPtr, 10);
436           ptr = endPtr;
437         }
438         if (ptr && *ptr) {
439           stats->dwActiveOpens = strtoul(ptr, &endPtr, 10);
440           ptr = endPtr;
441         }
442         if (ptr && *ptr) {
443           stats->dwPassiveOpens = strtoul(ptr, &endPtr, 10);
444           ptr = endPtr;
445         }
446         if (ptr && *ptr) {
447           stats->dwAttemptFails = strtoul(ptr, &endPtr, 10);
448           ptr = endPtr;
449         }
450         if (ptr && *ptr) {
451           stats->dwEstabResets = strtoul(ptr, &endPtr, 10);
452           ptr = endPtr;
453         }
454         if (ptr && *ptr) {
455           stats->dwCurrEstab = strtoul(ptr, &endPtr, 10);
456           ptr = endPtr;
457         }
458         if (ptr && *ptr) {
459           stats->dwInSegs = strtoul(ptr, &endPtr, 10);
460           ptr = endPtr;
461         }
462         if (ptr && *ptr) {
463           stats->dwOutSegs = strtoul(ptr, &endPtr, 10);
464           ptr = endPtr;
465         }
466         if (ptr && *ptr) {
467           stats->dwRetransSegs = strtoul(ptr, &endPtr, 10);
468           ptr = endPtr;
469         }
470         if (ptr && *ptr) {
471           stats->dwInErrs = strtoul(ptr, &endPtr, 10);
472           ptr = endPtr;
473         }
474         if (ptr && *ptr) {
475           stats->dwOutRsts = strtoul(ptr, &endPtr, 10);
476           ptr = endPtr;
477         }
478         stats->dwNumConns = getNumTcpEntries();
479       }
480     }
481     fclose(fp);
482   }
483   return NO_ERROR;
484 }
485
486 DWORD getUDPStats(MIB_UDPSTATS *stats)
487 {
488   FILE *fp;
489
490   if (!stats)
491     return ERROR_INVALID_PARAMETER;
492
493   memset(stats, 0, sizeof(MIB_UDPSTATS));
494
495   /* get from /proc/net/snmp, no error if can't */
496   fp = fopen("/proc/net/snmp", "r");
497   if (fp) {
498     static const char hdr[] = "Udp:";
499     char buf[512] = { 0 }, *ptr;
500
501
502     do {
503       ptr = fgets(buf, sizeof(buf), fp);
504     } while (ptr && strncasecmp(buf, hdr, sizeof(hdr) - 1));
505     if (ptr) {
506       /* last line was a header, get another */
507       ptr = fgets(buf, sizeof(buf), fp);
508       if (ptr && strncasecmp(buf, hdr, sizeof(hdr) - 1) == 0) {
509         char *endPtr;
510
511         ptr += sizeof(hdr);
512         if (ptr && *ptr) {
513           stats->dwInDatagrams = strtoul(ptr, &endPtr, 10);
514           ptr = endPtr;
515         }
516         if (ptr && *ptr) {
517           stats->dwNoPorts = strtoul(ptr, &endPtr, 10);
518           ptr = endPtr;
519         }
520         if (ptr && *ptr) {
521           stats->dwInErrors = strtoul(ptr, &endPtr, 10);
522           ptr = endPtr;
523         }
524         if (ptr && *ptr) {
525           stats->dwOutDatagrams = strtoul(ptr, &endPtr, 10);
526           ptr = endPtr;
527         }
528         if (ptr && *ptr) {
529           stats->dwNumAddrs = strtoul(ptr, &endPtr, 10);
530           ptr = endPtr;
531         }
532       }
533     }
534     fclose(fp);
535   }
536   return NO_ERROR;
537 }
538
539 static DWORD getNumWithOneHeader(const char *filename)
540 {
541   FILE *fp;
542   int ret = 0;
543
544   fp = fopen(filename, "r");
545   if (fp) {
546     char buf[512] = { 0 }, *ptr;
547
548
549     ptr = fgets(buf, sizeof(buf), fp);
550     if (ptr) {
551       do {
552         ptr = fgets(buf, sizeof(buf), fp);
553         if (ptr)
554           ret++;
555       } while (ptr);
556     }
557     fclose(fp);
558   }
559   return ret;
560 }
561
562 DWORD getNumRoutes(void)
563 {
564   return getNumWithOneHeader("/proc/net/route");
565 }
566
567 DWORD getRouteTable(PMIB_IPFORWARDTABLE *ppIpForwardTable, HANDLE heap,
568  DWORD flags)
569 {
570   DWORD ret;
571
572   if (!ppIpForwardTable)
573     ret = ERROR_INVALID_PARAMETER;
574   else {
575     DWORD numRoutes = getNumRoutes();
576     PMIB_IPFORWARDTABLE table = HeapAlloc(heap, flags,
577      sizeof(MIB_IPFORWARDTABLE) + (numRoutes - 1) * sizeof(MIB_IPFORWARDROW));
578
579     if (table) {
580       FILE *fp;
581
582       ret = NO_ERROR;
583       *ppIpForwardTable = table;
584       table->dwNumEntries = 0;
585       /* get from /proc/net/route, no error if can't */
586       fp = fopen("/proc/net/route", "r");
587       if (fp) {
588         char buf[512] = { 0 }, *ptr;
589
590         /* skip header line */
591         ptr = fgets(buf, sizeof(buf), fp);
592         while (ptr && table->dwNumEntries < numRoutes) {
593           memset(&table->table[table->dwNumEntries], 0,
594            sizeof(MIB_IPFORWARDROW));
595           ptr = fgets(buf, sizeof(buf), fp);
596           if (ptr) {
597             DWORD index;
598
599             while (!isspace(*ptr))
600               ptr++;
601             *ptr = '\0';
602             ptr++;
603             if (getInterfaceIndexByName(buf, &index) == NO_ERROR) {
604               char *endPtr;
605
606               table->table[table->dwNumEntries].dwForwardIfIndex = index;
607               if (*ptr) {
608                 table->table[table->dwNumEntries].dwForwardDest =
609                  strtoul(ptr, &endPtr, 16);
610                 ptr = endPtr;
611               }
612               if (ptr && *ptr) {
613                 table->table[table->dwNumEntries].dwForwardNextHop =
614                  strtoul(ptr, &endPtr, 16);
615                 ptr = endPtr;
616               }
617               if (ptr && *ptr) {
618                 DWORD flags = strtoul(ptr, &endPtr, 16);
619
620                 if (!(flags & RTF_UP))
621                   table->table[table->dwNumEntries].dwForwardType =
622                    MIB_IPROUTE_TYPE_INVALID;
623                 else if (flags & RTF_GATEWAY)
624                   table->table[table->dwNumEntries].dwForwardType =
625                    MIB_IPROUTE_TYPE_INDIRECT;
626                 else
627                   table->table[table->dwNumEntries].dwForwardType =
628                    MIB_IPROUTE_TYPE_DIRECT;
629                 ptr = endPtr;
630               }
631               if (ptr && *ptr) {
632                 strtoul(ptr, &endPtr, 16); /* refcount, skip */
633                 ptr = endPtr;
634               }
635               if (ptr && *ptr) {
636                 strtoul(ptr, &endPtr, 16); /* use, skip */
637                 ptr = endPtr;
638               }
639               if (ptr && *ptr) {
640                 table->table[table->dwNumEntries].dwForwardMetric1 =
641                  strtoul(ptr, &endPtr, 16);
642                 ptr = endPtr;
643               }
644               if (ptr && *ptr) {
645                 table->table[table->dwNumEntries].dwForwardMask =
646                  strtoul(ptr, &endPtr, 16);
647                 ptr = endPtr;
648               }
649               /* FIXME: other protos might be appropriate, e.g. the default
650                * route is typically set with MIB_IPPROTO_NETMGMT instead */
651               table->table[table->dwNumEntries].dwForwardProto =
652                MIB_IPPROTO_LOCAL;
653               table->dwNumEntries++;
654             }
655           }
656         }
657         fclose(fp);
658       }
659     }
660     else
661       ret = ERROR_OUTOFMEMORY;
662   }
663   return ret;
664 }
665
666 DWORD getNumArpEntries(void)
667 {
668   return getNumWithOneHeader("/proc/net/arp");
669 }
670
671 DWORD getArpTable(PMIB_IPNETTABLE *ppIpNetTable, HANDLE heap, DWORD flags)
672 {
673   DWORD ret;
674
675   if (!ppIpNetTable)
676     ret = ERROR_INVALID_PARAMETER;
677   else {
678     DWORD numEntries = getNumArpEntries();
679     PMIB_IPNETTABLE table = HeapAlloc(heap, flags,
680      sizeof(MIB_IPNETTABLE) + (numEntries - 1) * sizeof(MIB_IPNETROW));
681
682     if (table) {
683       FILE *fp;
684
685       ret = NO_ERROR;
686       *ppIpNetTable = table;
687       table->dwNumEntries = 0;
688       /* get from /proc/net/arp, no error if can't */
689       fp = fopen("/proc/net/arp", "r");
690       if (fp) {
691         char buf[512] = { 0 }, *ptr;
692
693         /* skip header line */
694         ptr = fgets(buf, sizeof(buf), fp);
695         while (ptr && table->dwNumEntries < numEntries) {
696           ptr = fgets(buf, sizeof(buf), fp);
697           if (ptr) {
698             char *endPtr;
699
700             memset(&table->table[table->dwNumEntries], 0, sizeof(MIB_IPNETROW));
701             table->table[table->dwNumEntries].dwAddr = inet_addr(ptr);
702             while (ptr && *ptr && !isspace(*ptr))
703               ptr++;
704
705             if (ptr && *ptr) {
706               strtoul(ptr, &endPtr, 16); /* hw type (skip) */
707               ptr = endPtr;
708             }
709             if (ptr && *ptr) {
710               DWORD flags = strtoul(ptr, &endPtr, 16);
711
712 #ifdef ATF_COM
713               if (flags & ATF_COM)
714                 table->table[table->dwNumEntries].dwType =
715                  MIB_IPNET_TYPE_DYNAMIC;
716               else
717 #endif
718 #ifdef ATF_PERM
719               if (flags & ATF_PERM)
720                 table->table[table->dwNumEntries].dwType =
721                  MIB_IPNET_TYPE_STATIC;
722               else
723 #endif
724                 table->table[table->dwNumEntries].dwType = MIB_IPNET_TYPE_OTHER;
725
726               ptr = endPtr;
727             }
728             while (ptr && *ptr && isspace(*ptr))
729               ptr++;
730             while (ptr && *ptr && !isspace(*ptr)) {
731               DWORD byte = strtoul(ptr, &endPtr, 16);
732
733               if (endPtr && *endPtr) {
734                 endPtr++;
735                 table->table[table->dwNumEntries].bPhysAddr[
736                  table->table[table->dwNumEntries].dwPhysAddrLen++] =
737                  byte & 0x0ff;
738               }
739               ptr = endPtr;
740             }
741             if (ptr && *ptr) {
742               strtoul(ptr, &endPtr, 16); /* mask (skip) */
743               ptr = endPtr;
744             }
745             getInterfaceIndexByName(ptr,
746              &table->table[table->dwNumEntries].dwIndex);
747             table->dwNumEntries++;
748           }
749         }
750         fclose(fp);
751       }
752     }
753     else
754       ret = ERROR_OUTOFMEMORY;
755   }
756   return ret;
757 }
758
759 DWORD getNumUdpEntries(void)
760 {
761   return getNumWithOneHeader("/proc/net/udp");
762 }
763
764 DWORD getUdpTable(PMIB_UDPTABLE *ppUdpTable, HANDLE heap, DWORD flags)
765 {
766   DWORD ret;
767
768   if (!ppUdpTable)
769     ret = ERROR_INVALID_PARAMETER;
770   else {
771     DWORD numEntries = getNumUdpEntries();
772     PMIB_UDPTABLE table = HeapAlloc(heap, flags,
773      sizeof(MIB_UDPTABLE) + (numEntries - 1) * sizeof(MIB_UDPROW));
774
775     if (table) {
776       FILE *fp;
777
778       ret = NO_ERROR;
779       *ppUdpTable = table;
780       table->dwNumEntries = 0;
781       /* get from /proc/net/udp, no error if can't */
782       fp = fopen("/proc/net/udp", "r");
783       if (fp) {
784         char buf[512] = { 0 }, *ptr;
785
786         /* skip header line */
787         ptr = fgets(buf, sizeof(buf), fp);
788         while (ptr && table->dwNumEntries < numEntries) {
789           memset(&table->table[table->dwNumEntries], 0, sizeof(MIB_UDPROW));
790           ptr = fgets(buf, sizeof(buf), fp);
791           if (ptr) {
792             char *endPtr;
793
794             if (ptr && *ptr) {
795               strtoul(ptr, &endPtr, 16); /* skip */
796               ptr = endPtr;
797             }
798             if (ptr && *ptr) {
799               ptr++;
800               table->table[table->dwNumEntries].dwLocalAddr = strtoul(ptr,
801                &endPtr, 16);
802               ptr = endPtr;
803             }
804             if (ptr && *ptr) {
805               ptr++;
806               table->table[table->dwNumEntries].dwLocalPort = strtoul(ptr,
807                &endPtr, 16);
808               ptr = endPtr;
809             }
810             table->dwNumEntries++;
811           }
812         }
813         fclose(fp);
814       }
815     }
816     else
817       ret = ERROR_OUTOFMEMORY;
818   }
819   return ret;
820 }
821
822 DWORD getNumTcpEntries(void)
823 {
824   return getNumWithOneHeader("/proc/net/tcp");
825 }
826
827 DWORD getTcpTable(PMIB_TCPTABLE *ppTcpTable, HANDLE heap, DWORD flags)
828 {
829   DWORD ret;
830
831   if (!ppTcpTable)
832     ret = ERROR_INVALID_PARAMETER;
833   else {
834     DWORD numEntries = getNumTcpEntries();
835     PMIB_TCPTABLE table = HeapAlloc(heap, flags,
836      sizeof(MIB_TCPTABLE) + (numEntries - 1) * sizeof(MIB_TCPROW));
837
838     if (table) {
839       FILE *fp;
840
841       ret = NO_ERROR;
842       *ppTcpTable = table;
843       table->dwNumEntries = 0;
844       /* get from /proc/net/tcp, no error if can't */
845       fp = fopen("/proc/net/tcp", "r");
846       if (fp) {
847         char buf[512] = { 0 }, *ptr;
848
849         /* skip header line */
850         ptr = fgets(buf, sizeof(buf), fp);
851         while (ptr && table->dwNumEntries < numEntries) {
852           memset(&table->table[table->dwNumEntries], 0, sizeof(MIB_TCPROW));
853           ptr = fgets(buf, sizeof(buf), fp);
854           if (ptr) {
855             char *endPtr;
856
857             while (ptr && *ptr && *ptr != ':')
858               ptr++;
859             if (ptr && *ptr)
860               ptr++;
861             if (ptr && *ptr) {
862               table->table[table->dwNumEntries].dwLocalAddr = strtoul(ptr,
863                &endPtr, 16);
864               ptr = endPtr;
865             }
866             if (ptr && *ptr) {
867               ptr++;
868               table->table[table->dwNumEntries].dwLocalPort = strtoul(ptr,
869                &endPtr, 16);
870               ptr = endPtr;
871             }
872             if (ptr && *ptr) {
873               table->table[table->dwNumEntries].dwRemoteAddr = strtoul(ptr,
874                &endPtr, 16);
875               ptr = endPtr;
876             }
877             if (ptr && *ptr) {
878               ptr++;
879               table->table[table->dwNumEntries].dwRemotePort = strtoul(ptr,
880                &endPtr, 16);
881               ptr = endPtr;
882             }
883             if (ptr && *ptr) {
884               DWORD state = strtoul(ptr, &endPtr, 16);
885
886               switch (state)
887               {
888                 case TCPS_ESTABLISHED:
889                   table->table[table->dwNumEntries].dwState =
890                    MIB_TCP_STATE_ESTAB;
891                   break;
892                 case TCPS_SYN_SENT:
893                   table->table[table->dwNumEntries].dwState =
894                    MIB_TCP_STATE_SYN_SENT;
895                   break;
896                 case TCPS_SYN_RECEIVED:
897                   table->table[table->dwNumEntries].dwState =
898                    MIB_TCP_STATE_SYN_RCVD;
899                   break;
900                 case TCPS_FIN_WAIT_1:
901                   table->table[table->dwNumEntries].dwState =
902                    MIB_TCP_STATE_FIN_WAIT1;
903                   break;
904                 case TCPS_FIN_WAIT_2:
905                   table->table[table->dwNumEntries].dwState =
906                    MIB_TCP_STATE_FIN_WAIT2;
907                   break;
908                 case TCPS_TIME_WAIT:
909                   table->table[table->dwNumEntries].dwState =
910                    MIB_TCP_STATE_TIME_WAIT;
911                   break;
912                 case TCPS_CLOSED:
913                   table->table[table->dwNumEntries].dwState =
914                    MIB_TCP_STATE_CLOSED;
915                   break;
916                 case TCPS_CLOSE_WAIT:
917                   table->table[table->dwNumEntries].dwState =
918                    MIB_TCP_STATE_CLOSE_WAIT;
919                   break;
920                 case TCPS_LAST_ACK:
921                   table->table[table->dwNumEntries].dwState =
922                    MIB_TCP_STATE_LAST_ACK;
923                   break;
924                 case TCPS_LISTEN:
925                   table->table[table->dwNumEntries].dwState =
926                    MIB_TCP_STATE_LISTEN;
927                   break;
928                 case TCPS_CLOSING:
929                   table->table[table->dwNumEntries].dwState =
930                    MIB_TCP_STATE_CLOSING;
931                   break;
932               }
933               ptr = endPtr;
934             }
935             table->dwNumEntries++;
936           }
937         }
938         fclose(fp);
939       }
940     }
941     else
942       ret = ERROR_OUTOFMEMORY;
943   }
944   return ret;
945 }