source: tools/tracesplit/tracesplit.c @ 19c6cbe

4.0.1-hotfixescachetimestampsdevelopdpdk-ndagetsilivegetfragoffhelplibtrace4ndag_formatpfringrc-4.0.1rc-4.0.2rc-4.0.3rc-4.0.4ringdecrementfixringperformanceringtimestampfixes
Last change on this file since 19c6cbe was 19c6cbe, checked in by Shane Alcock <salcock@…>, 15 years ago

Fixed bug where tracesplit and associated tools were not flushing remaining data at the end of their execution.
Resolved warning about unsigned/signed comparison in format_erf.
Added/removed a few newlines over the course of my debugging.

  • Property mode set to 100644
File size: 4.4 KB
Line 
1#include <libtrace.h>
2#include <stdio.h>
3#include <stdlib.h>
4#ifdef HAVE_INTTYPES_H
5#  include <inttypes.h>
6#endif
7#include <lt_inttypes.h>
8#include <stdbool.h>
9#include <getopt.h>
10#include <string.h>
11#include <assert.h>
12
13char *strdupcat(char *str,char *app)
14{
15        str=realloc(str,strlen(str)+strlen(app)+1);
16        strcat(str,app);
17        return str;
18}
19
20char *strdupcati(char *str,int i)
21{
22        char buffer[64];
23        snprintf(buffer,sizeof(buffer),"%i",i);
24        return strdupcat(str,buffer);
25}
26
27int usage(char *argv0)
28{
29        printf("Usage:\n"
30        "%s flags inputuri outputuri\n"
31        "-f --filter=bpf        only output packets that match filter\n"
32        "-c --count=n           split every n packets\n"
33        "-b --bytes=n           Split every n bytes received\n"
34        "-i --interval=n        Split every n seconds\n"
35        "-s --starttime=time    Start at time\n"
36        "-e --endtime=time      End at time\n"
37        "-H --libtrace-help     Print libtrace runtime documentation\n"
38        ,argv0);
39        exit(1);
40}
41
42int main(int argc, char *argv[])
43{
44        struct libtrace_filter_t *filter=NULL;
45        struct libtrace_out_t *output = NULL;
46        struct libtrace_t *input;
47        struct libtrace_packet_t *packet = trace_create_packet();
48        uint64_t count=UINT64_MAX;
49        uint64_t bytes=UINT64_MAX;
50        uint64_t starttime=0;
51        uint64_t endtime=UINT64_MAX;
52        uint64_t interval=UINT64_MAX;
53        double firsttime=0;
54        uint64_t pktcount=0;
55        uint64_t totbytes=0;
56        uint64_t totbyteslast=0;
57
58        if (argc<2) {
59                usage(argv[0]);
60                return 1;
61        }
62
63        /* Parse command line options */
64        while(1) {
65                int option_index;
66                struct option long_options[] = {
67                        { "filter",        1, 0, 'f' },
68                        { "count",         1, 0, 'c' },
69                        { "bytes",         1, 0, 'b' },
70                        { "starttime",     1, 0, 's' },
71                        { "endtime",       1, 0, 'e' },
72                        { "interval",      1, 0, 'i' },
73                        { "libtrace-help", 0, 0, 'H' },
74                        { NULL,            0, 0, 0   },
75                };
76
77                int c=getopt_long(argc, argv, "f:c:b:s:e:i:H",
78                                long_options, &option_index);
79
80                if (c==-1)
81                        break;
82
83                switch (c) {
84                        case 'f': filter=trace_create_filter(optarg);
85                                break;
86                        case 'c': count=atoi(optarg);
87                                break;
88                        case 'b': bytes=atoi(optarg);
89                                break;
90                        case 's': starttime=atoi(optarg); /* FIXME: use getdate */
91                                  break;
92                        case 'e': endtime=atoi(optarg);
93                                  break;
94                        case 'i': interval=atoi(optarg);
95                                  break;
96                        case 'H':
97                                  trace_help();
98                                  exit(1);
99                                  break;
100                        default:
101                                fprintf(stderr,"Unknown option: %c\n",c);
102                                usage(argv[0]);
103                                return 1;
104                }
105        }
106        if (optind+2<argc) {
107                fprintf(stderr,"missing inputuri or outputuri\n");
108                usage(argv[0]);
109        }
110
111        output=NULL;
112        input=trace_create(argv[optind]);
113        if (trace_is_err(input)) {
114                trace_perror(input,"");
115                return 1;
116        }
117
118        if (trace_start(input)==-1) {
119                trace_perror(input,"");
120                return 1;
121        }
122
123        while(1) {
124               
125                if (trace_read_packet(input,packet)<1) {
126                        break;
127                }
128               
129                if (filter && !trace_apply_filter(filter,packet)) {
130                        continue;
131                }
132
133                if (trace_get_seconds(packet)<starttime) {
134                        continue;
135                }
136
137                if (trace_get_seconds(packet)>endtime) {
138                        break;
139                }
140
141                if (firsttime==0) {
142                        firsttime=trace_get_seconds(packet);
143                }
144
145                if (output && trace_get_seconds(packet)>firsttime+interval) {
146                        trace_destroy_output(output);
147                        output=NULL;
148                        firsttime+=interval;
149                }
150
151                if (output && pktcount%count==0) {
152                        trace_destroy_output(output);
153                        output=NULL;
154                }
155
156                pktcount++;
157                totbytes+=trace_get_capture_length(packet);
158                if (output && totbytes-totbyteslast>=bytes) {
159                        trace_destroy_output(output);
160                        output=NULL;
161                        totbyteslast=totbytes;
162                }
163                if (!output) {
164                        char *buffer;
165                        buffer=strdup(argv[optind+1]);
166                        if (interval!=UINT64_MAX) {
167                                buffer=strdupcat(buffer,"-");
168                                buffer=strdupcati(buffer,firsttime);
169                        }
170                        if (count!=UINT64_MAX) {
171                                buffer=strdupcat(buffer,"-");
172                                buffer=strdupcati(buffer,pktcount);
173                        }
174                        if (bytes!=UINT64_MAX) {
175                                static int filenum=0;
176                                buffer=strdupcat(buffer,"-");
177                                buffer=strdupcati(buffer,++filenum);
178                        }
179                        output=trace_create_output(buffer);
180                        trace_start_output(output);
181                        free(buffer);
182                }
183
184                /* Some traces we have are padded (usually with 0x00), so
185                 * lets sort that out now and truncate them properly
186                 */
187
188                if (trace_get_capture_length(packet) 
189                        > trace_get_wire_length(packet)) {
190                        trace_set_capture_length(packet,trace_get_wire_length(packet));
191                }
192               
193                if (trace_write_packet(output,packet)==-1) {
194                        trace_perror_output(output,"write_packet");
195                        break;
196                }
197
198        }
199
200        if (trace_is_err(input)) {
201                trace_perror(input, "Reading packets");
202        }
203       
204        trace_destroy(input);
205        trace_destroy_output(output);
206
207        trace_destroy_packet(packet);
208
209        return 0;
210}
Note: See TracBrowser for help on using the repository browser.