int main(int argc, char *argv[])
{
char *compress_type_str=NULL;
struct libtrace_filter_t *filter=NULL;
struct libtrace_t *input = NULL;
struct libtrace_packet_t *packet = trace_create_packet();
struct sigaction sigact;
int i;
if (argc<2) {
usage(argv[0]);
return 1;
}
/* Parse command line options */
while(1) {
int option_index;
struct option long_options[] = {
{ "filter", 1, 0, 'f' },
{ "count", 1, 0, 'c' },
{ "bytes", 1, 0, 'b' },
{ "starttime", 1, 0, 's' },
{ "endtime", 1, 0, 'e' },
{ "interval", 1, 0, 'i' },
{ "libtrace-help", 0, 0, 'H' },
{ "maxfiles", 1, 0, 'm' },
{ "snaplen", 1, 0, 'S' },
{ "verbose", 0, 0, 'v' },
{ "compress-level", 1, 0, 'z' },
{ "compress-type", 1, 0, 'Z' },
{ NULL, 0, 0, 0 },
};
int c=getopt_long(argc, argv, "f:c:b:s:e:i:m:S:Hvz:Z:",
long_options, &option_index);
if (c==-1)
break;
switch (c) {
case 'f': filter=trace_create_filter(optarg);
break;
case 'c': count=atoi(optarg);
break;
case 'b': bytes=atoi(optarg);
break;
case 's': starttime=atof(optarg); /* FIXME: use getdate */
break;
case 'e': endtime=atof(optarg);
break;
case 'i': interval=atoi(optarg);
break;
case 'm': maxfiles=atoi(optarg);
break;
case 'S': snaplen=atoi(optarg);
break;
case 'H':
trace_help();
exit(1);
break;
case 'v':
verbose++;
break;
case 'z':
compress_level=atoi(optarg);
if (compress_level<0 || compress_level>9) {
usage(argv[0]);
exit(1);
}
break;
case 'Z':
compress_type_str=optarg;
break;
default:
fprintf(stderr,"Unknown option: %c\n",c);
usage(argv[0]);
return 1;
}
}
if (compress_type_str == NULL && compress_level >= 0) {
fprintf(stderr, "Compression level set, but no compression type was defined, setting to gzip\n");
compress_type = TRACE_OPTION_COMPRESSTYPE_ZLIB;
}
else if (compress_type_str == NULL) {
/* If a level or type is not specified, use the "none"
* compression module */
compress_type = TRACE_OPTION_COMPRESSTYPE_NONE;
}
/* I decided to be fairly generous in what I accept for the
* compression type string */
else if (strncmp(compress_type_str, "gz", 2) == 0 ||
strncmp(compress_type_str, "zlib", 4) == 0) {
compress_type = TRACE_OPTION_COMPRESSTYPE_ZLIB;
} else if (strncmp(compress_type_str, "bz", 2) == 0) {
compress_type = TRACE_OPTION_COMPRESSTYPE_BZ2;
} else if (strncmp(compress_type_str, "lzo", 3) == 0) {
compress_type = TRACE_OPTION_COMPRESSTYPE_LZO;
} else if (strncmp(compress_type_str, "no", 2) == 0) {
compress_type = TRACE_OPTION_COMPRESSTYPE_NONE;
} else {
fprintf(stderr, "Unknown compression type: %s\n",
compress_type_str);
return 1;
}
if (optind+2>argc) {
fprintf(stderr,"missing inputuri or outputuri\n");
usage(argv[0]);
}
output_base = argv[argc - 1];
sigact.sa_handler = cleanup_signal;
sigemptyset(&sigact.sa_mask);
sigact.sa_flags = SA_RESTART;
sigaction(SIGINT, &sigact, NULL);
sigaction(SIGTERM, &sigact, NULL);
output=NULL;
signal(SIGINT,&cleanup_signal);
signal(SIGTERM,&cleanup_signal);
for (i = optind; i < argc - 1; i++) {
input = trace_create(argv[i]);
if (trace_is_err(input)) {
trace_perror(input,"%s",argv[i]);
return 1;
}
if (filter && trace_config(input, TRACE_OPTION_FILTER, filter) == 1) {
trace_perror(input, "Configuring filter for %s",
argv[i]);
return 1;
}
if (trace_start(input)==-1) {
trace_perror(input,"%s",argv[i]);
return 1;
}
while (trace_read_packet(input,packet)>0) {
if (per_packet(packet) < 1)
done = 1;
if (done)
break;
}
if (done)
break;
if (trace_is_err(input)) {
trace_perror(input,"Reading packets");
trace_destroy(input);
break;
}
trace_destroy(input);
}
if (verbose) {
uint64_t f;
f=trace_get_received_packets(input);
if (f!=UINT64_MAX)
fprintf(stderr,"%" PRIu64 " packets on input\n",f);
f=trace_get_filtered_packets(input);
if (f!=UINT64_MAX)
fprintf(stderr,"%" PRIu64 " packets filtered\n",f);
f=trace_get_dropped_packets(input);
if (f!=UINT64_MAX)
fprintf(stderr,"%" PRIu64 " packets dropped\n",f);
f=trace_get_accepted_packets(input);
if (f!=UINT64_MAX)
fprintf(stderr,"%" PRIu64 " packets accepted\n",f);
}
if (output)
trace_destroy_output(output);
trace_destroy_packet(packet);
return 0;
}
/* Process a trace, counting packets that match filter(s) */
static void run_trace(char *uri)
{
struct libtrace_packet_t *packet = trace_create_packet();
int i;
uint64_t count = 0;
uint64_t bytes = 0;
uint64_t packets;
fprintf(stderr,"%s:\n",uri);
trace = trace_create(uri);
if (trace_is_err(trace)) {
trace_perror(trace,"Failed to create trace");
return;
}
if (trace_start(trace)==-1) {
trace_perror(trace,"Failed to start trace");
return;
}
for (;;) {
int psize;
int wlen;
int match = 0;
if ((psize = trace_read_packet(trace, packet)) <1) {
break;
}
if (done)
break;
wlen = trace_get_wire_length(packet);
for(i=0; i<filter_count; ++i) {
if (filters[i].filter == NULL)
continue;
if(trace_apply_filter(filters[i].filter,packet) > 0) {
++filters[i].count;
filters[i].bytes+=wlen;
match = 1;
}
if (trace_is_err(trace)) {
trace_perror(trace, "trace_apply_filter");
fprintf(stderr, "Removing filter from filterlist\n");
filters[i].filter = NULL;
}
}
if(match == 1 || filter_count == 0)
{
libtrace_ip_t *ip_hdr = trace_get_ip(packet);
if(ip_hdr != NULL)
{
char src_ip[INET_ADDRSTRLEN];
char dst_ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &ip_hdr->ip_src, &src_ip[0], INET_ADDRSTRLEN);
inet_ntop(AF_INET, &ip_hdr->ip_dst, &dst_ip[0], INET_ADDRSTRLEN);
printf("%f\t%s\t%s\t%"PRIu16"\t%"PRIu16"\t"
"%"PRIu8"\t%"PRIu16"\t%"PRIu16"\n",
trace_get_seconds(packet), src_ip, dst_ip,
trace_get_source_port(packet),
trace_get_destination_port(packet),
ip_hdr->ip_p,
ntohs(ip_hdr->ip_id),
ntohs(ip_hdr->ip_len)
);
}
}
++count;
bytes+=wlen;
}
fprintf(stderr, "%-30s\t%12s\t%12s\t%7s\n","filter","count","bytes","%");
for(i=0; i<filter_count; ++i) {
fprintf(stderr, "%30s:\t%12"PRIu64"\t%12"PRIu64"\t%7.03f\n",
filters[i].expr,filters[i].count,
filters[i].bytes,filters[i].count*100.0/count);
filters[i].bytes=0;
filters[i].count=0;
}
packets=trace_get_received_packets(trace);
if (packets!=UINT64_MAX)
fprintf(stderr,"%30s:\t%12" PRIu64"\n",
"Input packets", packets);
packets=trace_get_filtered_packets(trace);
if (packets!=UINT64_MAX)
fprintf(stderr,"%30s:\t%12" PRIu64"\n",
"Filtered packets", packets);
packets=trace_get_dropped_packets(trace);
if (packets!=UINT64_MAX)
fprintf(stderr,"%30s:\t%12" PRIu64"\n",
"Dropped packets",packets);
packets=trace_get_accepted_packets(trace);
if (packets!=UINT64_MAX)
fprintf(stderr,"%30s:\t%12" PRIu64 "\n",
"Accepted Packets",packets);
fprintf(stderr, "%30s:\t%12"PRIu64"\t%12" PRIu64 "\n","Total",count,bytes);
totcount+=count;
totbytes+=bytes;
if (trace_is_err(trace))
trace_perror(trace,"%s",uri);
trace_destroy(trace);
}
int main(int argc, char *argv[])
{
libtrace_t *trace;
libtrace_packet_t *packet;
libtrace_filter_t *filter=NULL;
session_manager_t *sm;
uint64_t f;
while(1) {
int option_index;
struct option long_options[] = {
{ "filter", 1, 0, 'f' },
{ "interval", 1, 0, 'i' },
{ "count", 1, 0, 'c' },
{ "exit", 1, 0, 'e' },
{ "relative", 0, 0, 'r' },
{ "help", 0, 0, 'h' },
{ "libtrace-help",0, 0, 'H' },
{ NULL, 0, 0, 0 }
};
int c= getopt_long(argc, argv, "c:e:f:i:hHr",
long_options, &option_index);
if (c==-1)
break;
switch (c) {
case 'f':
filter=trace_create_filter(optarg);
break;
case 'i':
packet_interval=atof(optarg);
break;
case 'c':
packet_count=atoi(optarg);
packet_interval=UINT32_MAX; // make sure only one is defined
break;
case 'e':
report_periods=atoi(optarg);
break;
case 'r':
report_rel_time = 1;
break;
case 'H':
trace_help();
return 1;
default:
fprintf(stderr,"Unknown option: %c\n",c);
/* FALL THRU */
case 'h':
usage(argv[0]);
return 1;
}
}
if (optind>=argc) {
fprintf(stderr,"Missing input uri\n");
usage(argv[0]);
return 1;
}
while (optind<argc) {
// create tcp session manager
sm = session_manager_create();
// create and register the data-ack based RTT module
session_manager_register_module(sm,rtt_n_sequence_module());
fprintf(stderr, "Processing %s\n",argv[optind]);
trace = trace_create(argv[optind]);
++optind;
if (trace_is_err(trace)) {
trace_perror(trace,"Opening trace file");
return 1;
}
if (filter && trace_config(trace,TRACE_OPTION_FILTER,filter)==1) {
trace_perror(trace,"Configuring filter");
}
if (trace_start(trace)) {
trace_perror(trace,"Starting trace");
trace_destroy(trace);
return 1;
}
packet = trace_create_packet();
print_report_hdr();
reset_report();
last_report_ts = 0;
last_packet_ts = 0;
while (trace_read_packet(trace,packet)>0) {
per_packet(packet,session_manager_update(sm,packet));
if (report_periods != UINT64_MAX && reported >= report_periods) {
break;
}
}
// remaining pkts (or all if no period set)
if ((reports[OUT].count+reports[IN].count) > 0 ||
(packet_interval == UINT32_MAX && packet_count == UINT64_MAX)) {
double ts = trace_get_seconds(packet);
if (report_rel_time) {
print_report(ts-last_report_ts);
} else {
print_report(ts);
}
}
trace_destroy_packet(packet);
if (trace_is_err(trace)) {
trace_perror(trace,"Reading packets");
}
// some stats
f=trace_get_received_packets(trace);
if (f!=UINT64_MAX)
fprintf(stderr,"%" PRIu64 " packets on input\n",f);
f=trace_get_filtered_packets(trace);
if (f!=UINT64_MAX)
fprintf(stderr,"%" PRIu64 " packets filtered\n",f);
f=trace_get_dropped_packets(trace);
if (f!=UINT64_MAX)
fprintf(stderr,"%" PRIu64 " packets dropped\n",f);
f=trace_get_accepted_packets(trace);
if (f!=UINT64_MAX)
fprintf(stderr,"%" PRIu64 " packets accepted\n",f);
trace_destroy(trace);
session_manager_destroy(sm);
}
return 0;
}
static void qfTraceUpdateStats(qfTraceSource_t *lts) {
yaf_trace_drop = (uint32_t) trace_get_dropped_packets(lts->trace);
if (yaf_trace_drop == (uint32_t)-1) yaf_trace_drop = 0;
}