source: tools/tracesplit/tracesplit.c @ e3b0188

4.0.1-hotfixescachetimestampsdevelopdpdk-ndagetsilivegetfragoffhelplibtrace4ndag_formatpfringrc-4.0.1rc-4.0.2rc-4.0.3rc-4.0.4ringdecrementfixringperformanceringtimestampfixes
Last change on this file since e3b0188 was e3b0188, checked in by Daniel Lawson <dlawson@…>, 16 years ago

a lot of changes for cross-compilation support

  • header ordering
  • os-specific headers
  • an lt_inttypes.h which defines PRIu64 etc for platforms that don't have them
  • removed daglegacy.h, merged with dagformat.h
  • Property mode set to 100644
File size: 3.7 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
12char *strdupcat(char *str,char *app)
13{
14        str=realloc(str,strlen(str)+strlen(app)+1);
15        strcat(str,app);
16        return str;
17}
18
19char *strdupcati(char *str,int i)
20{
21        char buffer[64];
22        snprintf(buffer,sizeof(buffer),"%i",i);
23        return strdupcat(str,buffer);
24}
25
26int usage(char *argv)
27{
28        printf("Usage: %s inputurl [ -c count ] [ -f bpffilter ] [ -b bytes ]\n\t[ -s starttime ] [ -e endtime ] [ -i interval ] outputurl\n",argv);
29        printf("\n");
30        printf("Splits up traces\n");
31        printf("-c count        split every count packets\n");
32        printf("-f bpffilter    only output packets that match filter\n");
33        printf("-b bytes        split every capture bytes\n");
34        printf("-s time         start at starttime\n");
35        printf("-e time         end at endtime\n");
36        printf("-i seconds      create a new trace every <seconds>\n");
37        printf("\n");
38        exit(1);
39}
40
41int main(int argc, char *argv[])
42{
43        struct libtrace_filter_t *filter=NULL;
44        struct libtrace_out_t *output = NULL;
45        struct libtrace_t *input;
46        uint64_t count=UINT64_MAX;
47        uint64_t bytes=UINT64_MAX;
48        uint64_t starttime=0;
49        uint64_t endtime=UINT64_MAX;
50        uint64_t interval=UINT64_MAX;
51        double firsttime=0;
52        uint64_t pktcount=0;
53        uint64_t totbytes=0;
54        uint64_t totbyteslast=0;
55
56        if (argc<2) {
57                usage(argv[0]);
58                return 1;
59        }
60
61        /* Parse command line options */
62        while(1) {
63                int option_index;
64                struct option long_options[] = {
65                        { "filter",     1, 0, 'f' },
66                        { "count",      1, 0, 'c' },
67                        { "bytes",      1, 0, 'b' },
68                        { "starttime",  1, 0, 's' },
69                        { "endtime",    1, 0, 'e' },
70                        { "interval",   1, 0, 'i' },
71                        { NULL,         0, 0, 0   },
72                };
73
74                int c=getopt_long(argc, argv, "f:c:b:s:e:i:",
75                                long_options, &option_index);
76
77                if (c==-1)
78                        break;
79
80                switch (c) {
81                        case 'f': filter=trace_bpf_setfilter(optarg);
82                                break;
83                        case 'c': count=atoi(optarg);
84                                break;
85                        case 'b': bytes=atoi(optarg);
86                                break;
87                        case 's': starttime=atoi(optarg); /* FIXME: use getdate */
88                                  break;
89                        case 'e': endtime=atoi(optarg);
90                                  break;
91                        case 'i': interval=atoi(optarg);
92                                  break;
93                        default:
94                                fprintf(stderr,"Unknown option: %c\n",c);
95                                usage(argv[0]);
96                                return 1;
97                }
98        }
99        if (optind+2<argc) {
100                fprintf(stderr,"missing inputuri or outputuri\n");
101                usage(argv[0]);
102        }
103
104        output=NULL;
105        input=trace_create(argv[optind]);
106
107        while(1) {
108                struct libtrace_packet_t packet;
109                if (trace_read_packet(input,&packet)<1) {
110                        break;
111                }
112
113
114                if (filter && !trace_bpf_filter(filter,&packet)) {
115                        continue;
116                }
117
118                if (trace_get_seconds(&packet)<starttime) {
119                        continue;
120                }
121
122                if (trace_get_seconds(&packet)>endtime) {
123                        break;
124                }
125
126                if (firsttime==0) {
127                        firsttime=trace_get_seconds(&packet);
128                }
129
130                if (output && trace_get_seconds(&packet)>firsttime+interval) {
131                        trace_output_destroy(output);
132                        output=NULL;
133                        firsttime+=interval;
134                }
135
136                pktcount++;
137                if (output && pktcount%count==0) {
138                        trace_output_destroy(output);
139                        output=NULL;
140                }
141
142                totbytes+=trace_get_capture_length(&packet);
143                if (output && totbytes-totbyteslast>=bytes) {
144                        trace_output_destroy(output);
145                        output=NULL;
146                        totbyteslast=totbytes;
147                }
148
149                if (!output) {
150                        char *buffer;
151                        buffer=strdup(argv[optind+1]);
152                        if (interval!=UINT64_MAX) {
153                                buffer=strdupcat(buffer,"-");
154                                buffer=strdupcati(buffer,firsttime);
155                        }
156                        if (count!=UINT64_MAX) {
157                                buffer=strdupcat(buffer,"-");
158                                buffer=strdupcati(buffer,pktcount);
159                        }
160                        if (bytes!=UINT64_MAX) {
161                                static int filenum=0;
162                                buffer=strdupcat(buffer,"-");
163                                buffer=strdupcati(buffer,++filenum);
164                        }
165                        output=trace_output_create(buffer);
166                        free(buffer);
167                }
168
169                trace_write_packet(output,&packet);
170        }
171
172        if (!output)
173                trace_output_destroy(output);
174
175        return 0;
176}
Note: See TracBrowser for help on using the repository browser.