source: tools/tracesplit/tracesplit.c @ 2132cfb

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

Don't modify the filename if the maximum number of files is 1

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