source: tools/tracesplit/tracesplit.c @ cbce651

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

Squash some more warnings.

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