source: tools/tracesplit/tracesplit.c @ 41816bf

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

Cleanup on signal

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