source: tools/tracereport/tracereport.c @ a8f2692

4.0.1-hotfixescachetimestampsdevelopdpdk-ndagetsilivegetfragoffhelplibtrace4ndag_formatpfringrc-4.0.1rc-4.0.2rc-4.0.3rc-4.0.4ringdecrementfixringperformanceringtimestampfixes
Last change on this file since a8f2692 was a8f2692, checked in by Perry Lorier <perry@…>, 11 years ago

Tidy up a bazillion tiny warnings

  • Property mode set to 100644
File size: 7.8 KB
Line 
1/*
2 * This file is part of libtrace
3 *
4 * Copyright (c) 2007 The University of Waikato, Hamilton, New Zealand.
5 * Authors: Daniel Lawson
6 *          Perry Lorier
7 *          Josef Vodanovich
8 *         
9 * All rights reserved.
10 *
11 * This code has been developed by the University of Waikato WAND
12 * research group. For further information please see http://www.wand.net.nz/
13 *
14 * libtrace is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License as published by
16 * the Free Software Foundation; either version 2 of the License, or
17 * (at your option) any later version.
18 *
19 * libtrace is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22 * GNU General Public License for more details.
23 *
24 * You should have received a copy of the GNU General Public License
25 * along with libtrace; if not, write to the Free Software
26 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
27 *
28 * $Id$
29 *
30 */
31
32/* This program takes a series of traces and bpf filters and outputs how many
33 * bytes/packets
34 */
35
36#include <stdio.h>
37#include <stdlib.h>
38#include <assert.h>
39#include <string.h>
40#include <sys/time.h>
41#include <sys/types.h>
42
43#include <getopt.h>
44#include <inttypes.h>
45#include <signal.h>
46
47#include "libtrace.h"
48#include "tracereport.h"
49#include "report.h"
50
51struct libtrace_t *trace;
52uint32_t reports_required = 0;
53int packets_read = 0;
54
55static volatile int done=0;
56
57static void cleanup_signal(int sig UNUSED)
58{
59        done=1;
60}
61
62/* Process a trace, counting packets that match filter(s) */
63static void run_trace(char *uri, libtrace_filter_t *filter, int count) 
64{
65        struct libtrace_packet_t *packet = trace_create_packet();
66
67        /* Already read the maximum number of packets - don't need to read
68         * anything from this trace */
69        if ((count >= 0 && packets_read >= count) || done)
70                return;
71
72        trace = trace_create(uri);
73       
74        if (trace_is_err(trace)) {
75                trace_perror(trace,"trace_create");
76                return;
77        }
78
79        if (filter) {
80                trace_config(trace,TRACE_OPTION_FILTER,filter);
81        }
82
83        if (trace_start(trace)==-1) {
84                trace_perror(trace,"trace_start");
85                return;
86        }
87
88        while (1) {
89                int psize;
90               
91                if (count >= 0 && packets_read >= count)
92                        break;
93                if (done)
94                        break;
95                if ((psize = trace_read_packet(trace, packet)) <1) {
96                        break;
97                }
98                if (reports_required & REPORT_TYPE_MISC)
99                        misc_per_packet(packet);
100                if (reports_required & REPORT_TYPE_ERROR)
101                        error_per_packet(packet);
102                if (reports_required & REPORT_TYPE_PORT)
103                        port_per_packet(packet);
104                if (reports_required & REPORT_TYPE_PROTO)
105                        protocol_per_packet(packet);
106                if (reports_required & REPORT_TYPE_TOS)
107                        tos_per_packet(packet);
108                if (reports_required & REPORT_TYPE_TTL)
109                        ttl_per_packet(packet);
110                if (reports_required & REPORT_TYPE_FLOW)
111                        flow_per_packet(packet);
112                if (reports_required & REPORT_TYPE_TCPOPT)
113                        tcpopt_per_packet(packet);
114                if (reports_required & REPORT_TYPE_SYNOPT)
115                        synopt_per_packet(packet);
116                if (reports_required & REPORT_TYPE_NLP)
117                        nlp_per_packet(packet);
118                if (reports_required & REPORT_TYPE_DIR)
119                        dir_per_packet(packet);
120                if (reports_required & REPORT_TYPE_ECN)
121                        ecn_per_packet(packet);
122                if (reports_required & REPORT_TYPE_TCPSEG)
123                        tcpseg_per_packet(packet);
124
125                packets_read ++;
126        }
127        if (reports_required & REPORT_TYPE_DROPS)
128                drops_per_trace(trace);
129        trace_destroy(trace);
130}
131
132static void usage(char *argv0)
133{
134        fprintf(stderr,"Usage:\n"
135        "%s flags traceuri [traceuri...]\n"
136        "-f --filter=bpf        \tApply BPF filter. Can be specified multiple times\n"
137        "-c --count=N           Stop after reading N packets\n"
138        "-e --error             Report packet errors (e.g. checksum failures, rxerrors)\n"
139        "-F --flow              Report flows\n"
140        "-m --misc              Report misc information (start/end times, duration, pps)\n"
141        "-P --protocol          Report transport protocols\n"
142        "-p --port              Report port numbers\n"
143        "-T --tos               Report IP TOS\n"
144        "-t --ttl               Report IP TTL\n"
145        "-O --tcpoptions        \tReport TCP Options\n"
146        "-o --synoptions        \tReport TCP Options seen on SYNs\n"
147        "-n --nlp               Report network layer protocols\n"
148        "-d --direction         Report direction\n"
149        "-C --ecn               Report TCP ECN information\n"
150        "-s --tcpsegment        \tReport TCP segment size\n"
151        "-H --help              Print libtrace runtime documentation\n"
152        ,argv0);
153        exit(1);
154}
155
156int main(int argc, char *argv[]) {
157
158        int i;
159        int opt;
160        char *filterstring=NULL;
161        struct sigaction sigact;
162        int count = -1;
163
164        libtrace_filter_t *filter = NULL;/*trace_bpf_setfilter(filterstring); */
165
166        while (1) {
167                int option_index;
168                struct option long_options[] = {
169                        { "count",              1, 0, 'c' },
170                        { "ecn",                0, 0, 'C' },
171                        { "direction",          0, 0, 'd' },
172                        { "drops",              0, 0, 'D' },
173                        { "error",              0, 0, 'e' },
174                        { "flow",               0, 0, 'F' },
175                        { "filter",             1, 0, 'f' },
176                        { "help",               0, 0, 'H' },
177                        { "misc",               0, 0, 'm' },
178                        { "nlp",                0, 0, 'n' },
179                        { "tcpoptions",         0, 0, 'O' },
180                        { "synoptions",         0, 0, 'o' },
181                        { "protocol",           0, 0, 'P' },
182                        { "port",               0, 0, 'p' },
183                        { "tcpsegment",         0, 0, 's' },
184                        { "tos",                0, 0, 'T' },
185                        { "ttl",                0, 0, 't' },
186                        { NULL,                 0, 0, 0 }
187                };
188                opt = getopt_long(argc, argv, "Df:HemFPpTtOondCsc:", 
189                                long_options, &option_index);
190                if (opt == -1)
191                        break;
192               
193                switch (opt) {
194                        case 'c':
195                                count = atoi(optarg);
196                                break;
197                        case 'C':
198                                reports_required |= REPORT_TYPE_ECN;
199                                break;
200                        case 'd':
201                                reports_required |= REPORT_TYPE_DIR;
202                                break;
203                        case 'D':
204                                reports_required |= REPORT_TYPE_DROPS;
205                                break;
206                        case 'e':
207                                reports_required |= REPORT_TYPE_ERROR;
208                                break;
209                        case 'F':
210                                reports_required |= REPORT_TYPE_FLOW;
211                                break;
212                        case 'f':
213                                filterstring = optarg;
214                                break;
215                        case 'H':
216                                usage(argv[0]);
217                                break;
218                        case 'm':
219                                reports_required |= REPORT_TYPE_MISC;
220                                break;
221                        case 'n':
222                                reports_required |= REPORT_TYPE_NLP;
223                                break;
224                        case 'O':
225                                reports_required |= REPORT_TYPE_TCPOPT;
226                                break;
227                        case 'o':
228                                reports_required |= REPORT_TYPE_SYNOPT;
229                                break;
230                        case 'P':
231                                reports_required |= REPORT_TYPE_PROTO;
232                                break;
233                        case 'p':
234                                reports_required |= REPORT_TYPE_PORT;
235                                break;
236                        case 's':
237                                reports_required |= REPORT_TYPE_TCPSEG;
238                                break;
239                        case 'T':
240                                reports_required |= REPORT_TYPE_TOS;
241                                break;
242                        case 't':
243                                reports_required |= REPORT_TYPE_TTL;
244                                break;
245                        default:
246                                usage(argv[0]);
247                }
248        }
249
250        /* Default to all reports, instead of no reports at all.  It's annoying
251         * waiting for 10 minutes for a trace to process then discover you
252         * forgot to ask for any reports!
253         */
254        if (reports_required == 0)
255                reports_required = ~0;
256
257        if (filterstring) {
258                filter = trace_create_filter(filterstring);
259        }
260
261        sigact.sa_handler = cleanup_signal;
262        sigemptyset(&sigact.sa_mask);
263        sigact.sa_flags = SA_RESTART;
264
265        sigaction(SIGINT, &sigact, NULL);
266        sigaction(SIGTERM, &sigact, NULL);
267               
268       
269        for(i=optind;i<argc;++i) {
270                /* This is handy for knowing how far through the traceset
271                 * we are - printing to stderr because we use stdout for
272                 * genuine output at the moment */
273                fprintf(stderr, "Reading from trace: %s\n", argv[i]);
274                run_trace(argv[i],filter, count);
275        }
276
277        if (reports_required & REPORT_TYPE_MISC)
278                misc_report();
279        if (reports_required & REPORT_TYPE_ERROR)
280                error_report();
281        if (reports_required & REPORT_TYPE_FLOW)
282                flow_report();
283        if (reports_required & REPORT_TYPE_TOS)
284                tos_report();
285        if (reports_required & REPORT_TYPE_PROTO)
286                protocol_report();
287        if (reports_required & REPORT_TYPE_PORT)
288                port_report();
289        if (reports_required & REPORT_TYPE_TTL)
290                ttl_report();   
291        if (reports_required & REPORT_TYPE_TCPOPT)
292                tcpopt_report();
293        if (reports_required & REPORT_TYPE_SYNOPT)
294                synopt_report();
295        if (reports_required & REPORT_TYPE_NLP)
296                nlp_report();
297        if (reports_required & REPORT_TYPE_DIR)
298                dir_report();
299        if (reports_required & REPORT_TYPE_ECN)
300                ecn_report();
301        if (reports_required & REPORT_TYPE_TCPSEG)
302                tcpseg_report();
303        if (reports_required & REPORT_TYPE_DROPS)
304                drops_report();
305        return 0;
306}
Note: See TracBrowser for help on using the repository browser.