/*
* Copyright (c) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
* 2002, 2003, 2004
* Ohio University.
*
* ---
*
* Starting with the release of tcptrace version 6 in 2001, tcptrace
* is licensed under the GNU General Public License (GPL). We believe
* that, among the available licenses, the GPL will do the best job of
* allowing tcptrace to continue to be a valuable, freely-available
* and well-maintained tool for the networking community.
*
* Previous versions of tcptrace were released under a license that
* was much less restrictive with respect to how tcptrace could be
* used in commercial products. Because of this, I am willing to
* consider alternate license arrangements as allowed in Section 10 of
* the GNU GPL. Before I would consider licensing tcptrace under an
* alternate agreement with a particular individual or company,
* however, I would have to be convinced that such an alternative
* would be to the greater benefit of the networking community.
*
* ---
*
* This file is part of Tcptrace.
*
* Tcptrace was originally written and continues to be maintained by
* Shawn Ostermann with the help of a group of devoted students and
* users (see the file 'THANKS'). The work on tcptrace has been made
* possible over the years through the generous support of NASA GRC,
* the National Science Foundation, and Sun Microsystems.
*
* Tcptrace is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* Tcptrace is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Tcptrace (in the file 'COPYING'); if not, write to the
* Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
* Author: Shawn Ostermann
* School of Electrical Engineering and Computer Science
* Ohio University
* Athens, OH
* ostermann@cs.ohiou.edu
* http://www.tcptrace.org/
*/
#include "tcptrace.h"
static char const GCC_UNUSED copyright[] =
"@(#)Copyright (c) 2004 -- Ohio University.\n";
static char const GCC_UNUSED rcsid[] =
"@(#)$Header: /usr/local/cvs/tcptrace/output.c,v 5.25 2003/11/19 14:38:04 sdo Exp $";
#include "gcache.h"
/* local routines */
static double Average(double, int);
static double Stdev(double, double, int);
static void StatLineP(char *, char *, char *, void *, void *);
static void StatLineI_L(char *, char *, u_long, u_long);
#ifdef HAVE_LONG_LONG
static void StatLineI_LL(char *, char *, u_llong, u_llong);
static void StatLineFieldL(char *, char *, char *, u_llong, int);
#endif /* HAVE_LONG_LONG */
static void StatLineF(char *, char *, char *, double, double);
static void StatLineField(char *, char *, char *, u_long, int);
static void StatLineFieldF(char *, char *, char *, double, int);
static void StatLineOne(char *, char *, char *);
static char *FormatBrief(tcp_pair *ptp);
static char *UDPFormatBrief(udp_pair *pup);
/* locally global variables*/
static u_int sv_print_count = 0;
static u_int sv_expected_count = 0;
/* global variables */
char *sp; /* Separator used for long output with <SP>-separated-values */
/* to support some of the counters being long long on some platforms, use this */
/* macro... */
#ifdef HAVE_LONG_LONG
#define StatLineI(label,units,ul1,ul2) \
(sizeof((ul1)) == SIZEOF_UNSIGNED_LONG_LONG_INT)?\
StatLineI_LL((label),(units),(ul1),(ul2)):\
StatLineI_L ((label),(units),(ul1),(ul2))
#else /* HAVE_LONG_LONG */
#define StatLineI StatLineI_L
#endif /* HAVE_LONG_LONG */
u_int
SynCount(
tcp_pair *ptp)
{
tcb *pab = &ptp->a2b;
tcb *pba = &ptp->b2a;
return(((pab->syn_count >= 1)?1:0) +
((pba->syn_count >= 1)?1:0));
}
u_int
FinCount(
tcp_pair *ptp)
{
tcb *pab = &ptp->a2b;
tcb *pba = &ptp->b2a;
return(((pab->fin_count >= 1)?1:0) +
((pba->fin_count >= 1)?1:0));
}
int
ConnComplete(
tcp_pair *ptp)
{
return(SynCount(ptp) >= 2 && FinCount(ptp) >= 2);
}
int
ConnReset(
tcp_pair *ptp)
{
return(ptp->a2b.reset_count + ptp->b2a.reset_count != 0);
}
static double
Average(
double sum,
int count)
{
return((double) sum / ((double)count+.0001));
}
static double
Stdev(
double sum,
double sum2,
int n)
{
double term;
double term1;
double term2;
double retval;
if (n<=2)
return(0.0);
term1 = sum2;
term2 = (sum * sum) / (double)n;
term = term1-term2;
term /= (double)(n-1);
retval = sqrt(term);
/* printf("Stdev(%f,%f,%d) is %f\n", sum,sum2,n,retval); */
return(retval);
}
static char *
FormatBrief(
tcp_pair *ptp)
{
tcb *pab = &ptp->a2b;
tcb *pba = &ptp->b2a;
static char infobuf[100];
snprintf(infobuf,sizeof(infobuf),"%s - %s (%s2%s)",
ptp->a_endpoint, ptp->b_endpoint,
pab->host_letter, pba->host_letter);
return(infobuf);
}
void
PrintTrace(
tcp_pair *ptp)
{
double etime;
u_long etime_secs;
u_long etime_usecs;
double etime_data1;
double etime_data2;
tcb *pab = &ptp->a2b;
tcb *pba = &ptp->b2a;
char *host1 = pab->host_letter;
char *host2 = pba->host_letter;
char bufl[40],bufr[40];
/* counters to use for seq. space wrap around calculations
*/
u_llong stream_length_pab=0, stream_length_pba=0;
u_long pab_last, pba_last;
/* Reset the counter for each connection */
sv_print_count = 1; /* The first field (conn_#) gets printed in trace.c */
/* calculate elapsed time */
etime = elapsed(ptp->first_time,ptp->last_time);
etime_secs = etime / 1000000.0;
etime_usecs = 1000000 * (etime/1000000.0 - (double)etime_secs);
/* Check if comma-separated-values or tab-separated-values
* has been requested.
*/
if(csv || tsv || (sv != NULL)) {
fprintf(stdout,"%s%s%s%s%s%s%s%s",
ptp->a_hostname, sp, ptp->b_hostname, sp,
ptp->a_portname, sp, ptp->b_portname, sp);
sv_print_count += 4;
/* Print the start and end times. In other words,
* print the time of the first and the last packet
*/
fprintf(stdout,"%ld.%ld %s %ld.%ld %s",
(long)ptp->first_time.tv_sec, (long)ptp->first_time.tv_usec, sp,
(long)ptp->last_time.tv_sec, (long)ptp->last_time.tv_usec, sp);
sv_print_count += 2;
}
else {
fprintf(stdout,"\thost %-4s %s\n",
(snprintf(bufl,sizeof(bufl),"%s:", host1),bufl), ptp->a_endpoint);
fprintf(stdout,"\thost %-4s %s\n",
(snprintf(bufl,sizeof(bufl),"%s:", host2),bufl), ptp->b_endpoint);
fprintf(stdout,"\tcomplete conn: %s",
ConnReset(ptp)?"RESET":(
ConnComplete(ptp)?"yes":"no"));
if (ConnComplete(ptp))
fprintf(stdout,"\n");
else
fprintf(stdout,"\t(SYNs: %u) (FINs: %u)\n",
SynCount(ptp), FinCount(ptp));
fprintf(stdout,"\tfirst packet: %s\n", ts2ascii(&ptp->first_time));
fprintf(stdout,"\tlast packet: %s\n", ts2ascii(&ptp->last_time));
fprintf(stdout,"\telapsed time: %s\n", elapsed2str(etime));
fprintf(stdout,"\ttotal packets: %" FS_ULL "\n", ptp->packets);
fprintf(stdout,"\tfilename: %s\n", ptp->filename);
fprintf(stdout," %s->%s: %s->%s:\n",
host1,host2,host2,host1);
}
StatLineI("total packets","", pab->packets, pba->packets);
if (pab->reset_count || pba->reset_count || csv || tsv || (sv != NULL))
StatLineI("resets sent","", pab->reset_count, pba->reset_count);
StatLineI("ack pkts sent","", pab->ack_pkts, pba->ack_pkts);
StatLineI("pure acks sent","", pab->pureack_pkts, pba->pureack_pkts);
StatLineI("sack pkts sent","", pab->num_sacks, pba->num_sacks);
StatLineI("dsack pkts sent","", pab->num_dsacks, pba->num_dsacks);
StatLineI("max sack blks/ack","", pab->max_sack_blocks, pba->max_sack_blocks);
StatLineI("unique bytes sent","",
pab->unique_bytes, pba->unique_bytes);
StatLineI("actual data pkts","", pab->data_pkts, pba->data_pkts);
StatLineI("actual data bytes","", pab->data_bytes, pba->data_bytes);
StatLineI("rexmt data pkts","", pab->rexmit_pkts, pba->rexmit_pkts);
StatLineI("rexmt data bytes","",
pab->rexmit_bytes, pba->rexmit_bytes);
StatLineI("zwnd probe pkts","",
pab->num_zwnd_probes, pba->num_zwnd_probes);
StatLineI("zwnd probe bytes","",
pab->zwnd_probe_bytes, pba->zwnd_probe_bytes);
StatLineI("outoforder pkts","",
pab->out_order_pkts, pba->out_order_pkts);
StatLineI("pushed data pkts","", pab->data_pkts_push, pba->data_pkts_push);
StatLineP("SYN/FIN pkts sent","","%s",
(snprintf(bufl,sizeof(bufl),"%d/%d",
pab->syn_count, pab->fin_count),bufl),
(snprintf(bufr,sizeof(bufr),"%d/%d",
pba->syn_count, pba->fin_count),bufr));
if (pab->f1323_ws || pba->f1323_ws || pab->f1323_ts || pba->f1323_ts || csv || tsv || (sv != NULL)) {
StatLineP("req 1323 ws/ts","","%s",
(snprintf(bufl,sizeof(bufl),"%c/%c",
pab->f1323_ws?'Y':'N',pab->f1323_ts?'Y':'N'),bufl),
(snprintf(bufr,sizeof(bufr),"%c/%c",
pba->f1323_ws?'Y':'N',pba->f1323_ts?'Y':'N'),bufr));
}
if (pab->f1323_ws || pba->f1323_ws || csv || tsv || (sv != NULL)) {
StatLineI("adv wind scale","",
(u_long)pab->window_scale, (u_long)pba->window_scale);
}
if (pab->fsack_req || pba->fsack_req || csv || tsv || (sv != NULL)) {
StatLineP("req sack","","%s",
pab->fsack_req?"Y":"N",
pba->fsack_req?"Y":"N");
StatLineI("sacks sent","",
pab->sacks_sent,
pba->sacks_sent);
}
StatLineI("urgent data pkts", "pkts",
pab->urg_data_pkts,
pba->urg_data_pkts);
StatLineI("urgent data bytes", "bytes",
pab->urg_data_bytes,
pba->urg_data_bytes);
StatLineI("mss requested","bytes", pab->mss, pba->mss);
StatLineI("max segm size","bytes",
pab->max_seg_size,
pba->max_seg_size);
StatLineI("min segm size","bytes",
pab->min_seg_size,
pba->min_seg_size);
StatLineI("avg segm size","bytes",
(int)((double)pab->data_bytes / ((double)pab->data_pkts+.001)),
(int)((double)pba->data_bytes / ((double)pba->data_pkts+.001)));
StatLineI("max win adv","bytes", pab->win_max, pba->win_max);
StatLineI("min win adv","bytes", pab->win_min, pba->win_min);
StatLineI("zero win adv","times",
pab->win_zero_ct, pba->win_zero_ct);
// Average window advertisement is calculated only for window scaled pkts
// if we have seen this connection using window scaling.
// Otherwise, it is just the regular way of dividing the sum of
// all window advertisements by the total number of packets.
if (pab->window_stats_updated_for_scaling &&
pba->window_stats_updated_for_scaling)
StatLineI("avg win adv","bytes",
pab->win_scaled_pkts==0?0:
(pab->win_tot/pab->win_scaled_pkts),
pba->win_scaled_pkts==0?0:
(pba->win_tot/pba->win_scaled_pkts));
else
StatLineI("avg win adv","bytes",
pab->packets==0?0:pab->win_tot/pab->packets,
pba->packets==0?0:pba->win_tot/pba->packets);
if (print_owin) {
StatLineI("max owin","bytes", pab->owin_max, pba->owin_max);
StatLineI("min non-zero owin","bytes", pab->owin_min, pba->owin_min);
StatLineI("avg owin","bytes",
pab->owin_count==0?0:pab->owin_tot/pab->owin_count,
pba->owin_count==0?0:pba->owin_tot/pba->owin_count);
if (etime == 0.0) {
StatLineP("wavg owin", "", "%s", "NA", "NA");
}
else {
StatLineI("wavg owin","bytes",
(u_llong)(pab->owin_wavg/((double)etime/1000000)),
(u_llong)(pba->owin_wavg/((double)etime/1000000)));
}
}
StatLineI("initial window","bytes",
pab->initialwin_bytes, pba->initialwin_bytes);
StatLineI("initial window","pkts",
pab->initialwin_segs, pba->initialwin_segs);
/* compare to theoretical length of the stream (not just what
we saw) using the SYN and FIN
* Seq. Space wrap around calculations:
* Calculate stream length using last_seq_num seen, first_seq_num
* seen and wrap_count.
* first_seq_num = syn
* If reset_set, last_seq_num = latest_seq
* else last_seq_num = fin
*/
pab_last = (pab->reset_count>0)?pab->latest_seq:pab->fin;
pba_last = (pba->reset_count>0)?pba->latest_seq:pba->fin;
/* calculating stream length for direction pab */
if ((pab->syn_count > 0) && (pab->fin_count > 0)) {
if (pab->seq_wrap_count > 0) {
if (pab_last > pab->syn) {
stream_length_pab = pab_last + (MAX_32 * pab->seq_wrap_count) - pab->syn - 1;
}
else {
stream_length_pab = pab_last + (MAX_32 * (pab->seq_wrap_count+1)) - pab->syn - 1;
}
}
else {
if (pab_last > pab->syn) {
stream_length_pab = pab_last - pab->syn - 1;
}
else {
stream_length_pab = MAX_32 + pab_last - pab->syn - 1;
}
}
}
/* calculating stream length for direction pba */
if ((pba->syn_count > 0) && (pba->fin_count > 0)) {
if (pba->seq_wrap_count > 0) {
if (pba_last > pba->syn) {
stream_length_pba = pba_last + (MAX_32 * pba->seq_wrap_count) - pba->syn - 1;
}
else {
stream_length_pba = pba_last + (MAX_32 * (pba->seq_wrap_count+1)) - pba->syn - 1;
}
}
else {
if (pba_last > pba->syn) {
stream_length_pba = pba_last - pba->syn - 1;
}
else {
stream_length_pba = MAX_32 + pba_last - pba->syn - 1;
}
}
}
/* print out values */
if ((pab->fin_count > 0) && (pab->syn_count > 0)) {
char *format = "%8" FS_ULL;
StatLineFieldL("ttl stream length", "bytes", format, stream_length_pab, 0);
}
else {
StatLineField("ttl stream length", "", "%s", (u_long)"NA", 0);
}
if ((pba->fin_count > 0) && (pba->syn_count > 0)) {
char *format = "%8" FS_ULL;
StatLineFieldL("ttl stream length", "bytes", format, stream_length_pba, 1);
}
else {
StatLineField("ttl stream length", "", "%s", (u_long)"NA", 1);
}
if ((pab->fin_count > 0) && (pab->syn_count > 0)) {
char *format = "%8" FS_ULL;
StatLineFieldL("missed data", "bytes", format, (stream_length_pab - pab->unique_bytes), 0);
}
else {
StatLineField("missed data", "", "%s", (u_long)"NA", 0);
}
if ((pba->fin_count > 0) && (pba->syn_count > 0)) {
char *format = "%8" FS_ULL;
StatLineFieldL("missed data", "bytes", format, (stream_length_pba - pba->unique_bytes), 1);
}
else {
StatLineField("missed data", "", "%s", (u_long)"NA", 1);
}
/* tell how much data was NOT captured in the files */
StatLineI("truncated data","bytes",
pab->trunc_bytes, pba->trunc_bytes);
StatLineI("truncated packets","pkts",
pab->trunc_segs, pba->trunc_segs);
/* stats on just the data */
etime_data1 = elapsed(pab->first_data_time,
pab->last_data_time); /* in usecs */
etime_data2 = elapsed(pba->first_data_time,
pba->last_data_time); /* in usecs */
/* fix from Rob Austein */
StatLineF("data xmit time","secs","%7.3f",
etime_data1 / 1000000.0,
etime_data2 / 1000000.0);
StatLineP("idletime max","ms","%s",
ZERO_TIME(&pab->last_time)?"NA":
(snprintf(bufl,sizeof(bufl),"%8.1f",(double)pab->idle_max/1000.0),bufl),
ZERO_TIME(&pba->last_time)?"NA":
(snprintf(bufr,sizeof(bufr),"%8.1f",(double)pba->idle_max/1000.0),bufr));
if ((pab->num_hardware_dups != 0) || (pba->num_hardware_dups != 0) || csv || tsv || (sv != NULL)) {
StatLineI("hardware dups","segs",
pab->num_hardware_dups, pba->num_hardware_dups);
if(!(csv || tsv || (sv != NULL)))
fprintf(stdout,
" ** WARNING: presence of hardware duplicates makes these figures suspect!\n");
}
/* do the throughput calcs */
etime /= 1000000.0; /* convert to seconds */
if (etime == 0.0)
StatLineP("throughput","","%s","NA","NA");
else
StatLineF("throughput","Bps","%8.0f",
(double) (pab->unique_bytes) / etime,
(double) (pba->unique_bytes) / etime);
if (print_rtt) {
if(!(csv || tsv || (sv != NULL)))
fprintf(stdout,"\n");
StatLineI("RTT samples","", pab->rtt_count, pba->rtt_count);
StatLineF("RTT min","ms","%8.1f",
(double)pab->rtt_min/1000.0,
(double)pba->rtt_min/1000.0);
StatLineF("RTT max","ms","%8.1f",
(double)pab->rtt_max/1000.0,
(double)pba->rtt_max/1000.0);
StatLineF("RTT avg","ms","%8.1f",
Average(pab->rtt_sum, pab->rtt_count) / 1000.0,
Average(pba->rtt_sum, pba->rtt_count) / 1000.0);
StatLineF("RTT stdev","ms","%8.1f",
Stdev(pab->rtt_sum, pab->rtt_sum2, pab->rtt_count) / 1000.0,
Stdev(pba->rtt_sum, pba->rtt_sum2, pba->rtt_count) / 1000.0);
if(!(csv || tsv || (sv != NULL)))
fprintf(stdout,"\n");
StatLineF("RTT from 3WHS","ms","%8.1f",
(double)pab->rtt_3WHS/1000.0,
(double)pba->rtt_3WHS/1000.0);
if(!(csv || tsv || (sv != NULL)))
fprintf(stdout,"\n");
StatLineI("RTT full_sz smpls","",
pab->rtt_full_count, pba->rtt_full_count);
StatLineF("RTT full_sz min","ms","%8.1f",
(double)pab->rtt_full_min/1000.0,
(double)pba->rtt_full_min/1000.0);
StatLineF("RTT full_sz max","ms","%8.1f",
(double)pab->rtt_full_max/1000.0,
(double)pba->rtt_full_max/1000.0);
StatLineF("RTT full_sz avg","ms","%8.1f",
Average(pab->rtt_full_sum, pab->rtt_full_count) / 1000.0,
Average(pba->rtt_full_sum, pba->rtt_full_count) / 1000.0);
StatLineF("RTT full_sz stdev","ms","%8.1f",
Stdev(pab->rtt_full_sum, pab->rtt_full_sum2, pab->rtt_full_count) / 1000.0,
Stdev(pba->rtt_full_sum, pba->rtt_full_sum2, pba->rtt_full_count) / 1000.0);
if(!(csv || tsv || (sv != NULL)))
fprintf(stdout,"\n");
StatLineI("post-loss acks","",
pab->rtt_nosample, pba->rtt_nosample);
if (pab->rtt_amback || pba->rtt_amback || csv || tsv || (sv != NULL)) {
if(!(csv || tsv || (sv != NULL)))
fprintf(stdout, "\
\t For the following 5 RTT statistics, only ACKs for\n\
\t multiply-transmitted segments (ambiguous ACKs) were\n\
\t considered. Times are taken from the last instance\n\
\t of a segment.\n\
");
StatLineI("ambiguous acks","",
pab->rtt_amback, pba->rtt_amback);
StatLineF("RTT min (last)","ms","%8.1f",
(double)pab->rtt_min_last/1000.0,
(double)pba->rtt_min_last/1000.0);
StatLineF("RTT max (last)","ms","%8.1f",
(double)pab->rtt_max_last/1000.0,
(double)pba->rtt_max_last/1000.0);
StatLineF("RTT avg (last)","ms","%8.1f",
Average(pab->rtt_sum_last, pab->rtt_count_last) / 1000.0,
Average(pba->rtt_sum_last, pba->rtt_count_last) / 1000.0);
StatLineF("RTT sdv (last)","ms","%8.1f",
Stdev(pab->rtt_sum_last, pab->rtt_sum2_last, pab->rtt_count_last) / 1000.0,
Stdev(pba->rtt_sum_last, pba->rtt_sum2_last, pba->rtt_count_last) / 1000.0);
}
StatLineI("segs cum acked","",
pab->rtt_cumack, pba->rtt_cumack);
StatLineI("duplicate acks","",
pab->rtt_dupack, pba->rtt_dupack);
StatLineI("triple dupacks","",
pab->rtt_triple_dupack, pba->rtt_triple_dupack);
if (debug)
StatLineI("unknown acks:","",
pab->rtt_unkack, pba->rtt_unkack);
StatLineI("max # retrans","",
pab->retr_max, pba->retr_max);
StatLineF("min retr time","ms","%8.1f",
(double)((double)pab->retr_min_tm/1000.0),
(double)((double)pba->retr_min_tm/1000.0));
StatLineF("max retr time","ms","%8.1f",
(double)((double)pab->retr_max_tm/1000.0),
(double)((double)pba->retr_max_tm/1000.0));
StatLineF("avg retr time","ms","%8.1f",
Average(pab->retr_tm_sum, pab->retr_tm_count) / 1000.0,
Average(pba->retr_tm_sum, pba->retr_tm_count) / 1000.0);
StatLineF("sdv retr time","ms","%8.1f",
Stdev(pab->retr_tm_sum, pab->retr_tm_sum2,
pab->retr_tm_count) / 1000.0,
Stdev(pba->retr_tm_sum, pba->retr_tm_sum2,
pba->retr_tm_count) / 1000.0);
}
if(csv || tsv || (sv != NULL)) {
printf("\n");
/* Error checking: print an error message if the count of printed fields
* doesn't correspond to the actual fields expected.
*/
if(sv_print_count != sv_expected_count) {
fprintf(stderr, "output.c: Count of printed fields does not correspond to count of header fields for long output with comma/tab/<SP>-separated values.\n");
fprintf(stderr,"sv_print_count=%u, sv_expected_count=%u\n",
sv_print_count, sv_expected_count);
exit(-1);
}
}
}
void
PrintBrief(
tcp_pair *ptp)
{
tcb *pab = &ptp->a2b;
tcb *pba = &ptp->b2a;
static int max_width = -1;
/* determine the maximum connection name width to make it nice */
if (max_width == -1) {
int ix;
int len;
tcp_pair *tmp_ptp;
for (ix = 0; ix <= num_tcp_pairs; ++ix) {
tmp_ptp = ttp[ix];
if (tmp_ptp->ignore_pair)
continue;
len = strlen(FormatBrief(tmp_ptp));
if (len > max_width)
max_width = len;
}
if (debug > 2)
fprintf(stderr,"Max name width: %d\n", max_width);
}
if (TRUE) {
/* new version */
fprintf(stdout,"%*s", -max_width, FormatBrief(ptp));
fprintf(stdout," %4" FS_ULL ">", pab->packets);
fprintf(stdout," %4" FS_ULL "<", pba->packets);
} else {
/* old version */
fprintf(stdout,"%s <==> %s",
ptp->a_endpoint,
ptp->b_endpoint);
fprintf(stdout," %s2%s:%"FS_ULL,
pab->host_letter,
pba->host_letter,
pab->packets);
fprintf(stdout," %s2%s:%"FS_ULL,
pba->host_letter,
pab->host_letter,
pba->packets);
}
if (ConnComplete(ptp))
fprintf(stdout," (complete)");
if (ConnReset(ptp))
fprintf(stdout," (reset)");
if ((ptp->a2b.packets == 0) || (ptp->b2a.packets == 0))
fprintf(stdout," (unidirectional)");
fprintf(stdout,"\n");
/* warning for hardware duplicates */
if (pab->num_hardware_dups != 0) {
fprintf(stdout,
" ** Warning, %s2%s: detected %lu hardware duplicate(s) (same seq # and IP ID)\n",
pab->host_letter, pba->host_letter,
pab->num_hardware_dups);
}
if (pba->num_hardware_dups != 0) {
fprintf(stdout,
" ** Warning, %s2%s: detected %lu hardware duplicate(s) (same seq # and IP ID)\n",
pba->host_letter, pab->host_letter,
pba->num_hardware_dups);
}
}
void
UDPPrintTrace(
udp_pair *pup)
{
double etime;
u_long etime_secs;
u_long etime_usecs;
ucb *pab = &pup->a2b;
ucb *pba = &pup->b2a;
char *host1 = pab->host_letter;
char *host2 = pba->host_letter;
char bufl[40];
fprintf(stdout,"\thost %-4s %s\n",
(snprintf(bufl,sizeof(bufl),"%s:", host1),bufl), pup->a_endpoint);
fprintf(stdout,"\thost %-4s %s\n",
(snprintf(bufl,sizeof(bufl),"%s:", host2),bufl), pup->b_endpoint);
fprintf(stdout,"\n");
fprintf(stdout,"\tfirst packet: %s\n", ts2ascii(&pup->first_time));
fprintf(stdout,"\tlast packet: %s\n", ts2ascii(&pup->last_time));
etime = elapsed(pup->first_time,pup->last_time);
etime_secs = etime / 1000000.0;
etime_usecs = 1000000 * (etime/1000000.0 - (double)etime_secs);
fprintf(stdout,"\telapsed time: %s\n", elapsed2str(etime));
fprintf(stdout,"\ttotal packets: %" FS_ULL "\n", pup->packets);
fprintf(stdout,"\tfilename: %s\n", pup->filename);
fprintf(stdout," %s->%s: %s->%s:\n",
host1,host2,host2,host1);
StatLineI("total packets","", pab->packets, pba->packets);
StatLineI("data bytes sent","",
pab->data_bytes, pba->data_bytes);
/* do the throughput calcs */
etime /= 1000000.0; /* convert to seconds */
if (etime == 0.0)
StatLineP("throughput","","%s","NA","NA");
else
StatLineF("throughput","Bps","%8.0f",
(double) (pab->data_bytes) / etime,
(double) (pba->data_bytes) / etime);
}
/* with pointer args */
static void
StatLineP(
char *label,
char *units,
char *format,
void *argleft,
void *argright)
{
StatLineField(label,units,format,(u_long)argleft,0);
StatLineField(label,units,format,(u_long)argright,1);
}
/* with u_long args */
static void
StatLineI_L(
char *label,
char *units,
u_long argleft,
u_long argright)
{
char *format = "%8lu";
StatLineField(label,units,format,argleft,0);
StatLineField(label,units,format,argright,1);
}
#ifdef HAVE_LONG_LONG
/* with u_llong (long long) args, if supported */
static void
StatLineI_LL(
char *label,
char *units,
u_llong argleft,
u_llong argright)
{
char *format = "%8" FS_ULL;
StatLineFieldL(label,units,format,argleft,0);
StatLineFieldL(label,units,format,argright,1);
}
static void
StatLineFieldL(
char *label,
char *units,
char *format,
u_llong arg,
int f_rightside)
{
/* bug fix: Theo Snelleman */
/* "The biggest number possible is 18446744073709551615 (20 digits) and
is too big for valbuf[20] ('\0' is the 21th character)." */
/* it was originally an array of [20] */
char valbuf[21];
/* determine the value to print */
snprintf(valbuf,sizeof(valbuf),format,arg);
/* print the field */
if(!(csv || tsv || (sv != NULL)))
printf(" ");
StatLineOne(label, units, valbuf);
if (f_rightside && !(csv || tsv || (sv != NULL)))
printf("\n");
}
#endif /* HAVE_LONG_LONG */
static void
StatLineF(
char *label,
char *units,
char *format,
double argleft,
double argright)
{
StatLineFieldF(label,units,format,argleft,0);
StatLineFieldF(label,units,format,argright,1);
}
static void
StatLineField(
char *label,
char *units,
char *format,
u_long arg,
int f_rightside)
{
char valbuf[20];
/* determine the value to print */
snprintf(valbuf,sizeof(valbuf),format,arg);
/* print the field */
if(!(csv || tsv || (sv != NULL)))
printf(" ");
StatLineOne(label, units, valbuf);
if (f_rightside && !(csv || tsv || (sv != NULL)))
printf("\n");
}
static void
StatLineFieldF(
char *label,
char *units,
char *format,
double arg,
int f_rightside)
{
int printable;
char valbuf[20];
/* see if the float argument is printable */
printable = finite(arg);
/* determine the value to print */
if (printable)
snprintf(valbuf,sizeof(valbuf),format,arg);
/* print the field */
if(!(csv || tsv || (sv != NULL)))
printf(" ");
if (printable)
StatLineOne(label, units, valbuf);
else
StatLineOne(label, "", "NA");
if (f_rightside && !(csv || tsv || (sv != NULL)))
printf("\n");
}
static void
StatLineOne(
char *label,
char *units,
char *value)
{
char labbuf[20];
/* format the label */
snprintf(labbuf,sizeof(labbuf), "%s:", label);
/* print the field */
if(csv || tsv || (sv != NULL)) {
printf("%15s%s", value, sp);
/* Count the fields printed until this point. Used as a guard with the
* <SP>-separated-values option to ensure correct alignment of headers
* and field values.
*/
sv_print_count++;
}
else
printf("%-18s %9s %-5s", labbuf, value, units);
}
char *
elapsed2str(
double etime)
{
static char buf[80];
u_long etime_secs;
u_long etime_usecs;
etime_secs = etime / 1000000.0;
etime_usecs = 1000000 * (etime/1000000.0 - (double)etime_secs);
snprintf(buf,sizeof(buf),"%lu:%02lu:%02lu.%06lu",
etime_secs / (60 * 60),
etime_secs % (60 * 60) / 60,
(etime_secs % (60 * 60)) % 60,
etime_usecs);
return(buf);
}
void
UDPPrintBrief(
udp_pair *pup)
{
ucb *pab = &pup->a2b;
ucb *pba = &pup->b2a;
static int max_width = -1;
/* determine the maximum connection name width to make it nice */
if (max_width == -1) {
int ix;
int len;
udp_pair *tmp_pup;
for (ix = 0; ix <= num_udp_pairs; ++ix) {
tmp_pup = utp[ix];
len = strlen(UDPFormatBrief(tmp_pup));
if (len > max_width)
max_width = len;
}
if (debug > 2)
fprintf(stderr,"Max name width: %d\n", max_width);
}
/* new version */
fprintf(stdout,"%*s", -max_width, UDPFormatBrief(pup));
fprintf(stdout," %4" FS_ULL ">", pab->packets);
fprintf(stdout," %4" FS_ULL "<", pba->packets);
fprintf(stdout,"\n");
}
static char *
UDPFormatBrief(
udp_pair *pup)
{
ucb *pab = &pup->a2b;
ucb *pba = &pup->b2a;
static char infobuf[100];
snprintf(infobuf,sizeof(infobuf),"%s - %s (%s2%s)",
pup->a_endpoint, pup->b_endpoint,
pab->host_letter, pba->host_letter);
return(infobuf);
}
/* Print the header if comma-separated-values or tab-separated-values
* has been requested.
*/
void
PrintSVHeader(
void)
{
/* NOTE: If you have added new fields of output to be printed in
* PrintTrace(), make sure you update the header-list here too, so that the
* new field you have added also has a header in the --csv/--tsv/--sv
* output.
*/
/* Headers for long output requested with comma/tab/<SP>-separated- values
* Split up into two headers, since the OWIN stats printed when the
* -lW option is given, generates fields of output that get printed in the
* middle of the output generated with just the -l option.
*/
char *svHeader1[] = {
"conn_#" ,
"host_a" , "host_b",
"port_a" , "port_b",
"first_packet" , "last_packet",
"total_packets_a2b" , "total_packets_b2a",
"resets_sent_a2b" , "resets_sent_b2a",
"ack_pkts_sent_a2b" , "ack_pkts_sent_b2a",
"pure_acks_sent_a2b" , "pure_acks_sent_b2a",
"sack_pkts_sent_a2b" , "sack_pkts_sent_b2a",
"dsack_pkts_sent_a2b" , "dsack_pkts_sent_b2a",
"max_sack_blks/ack_a2b" , "max_sack_blks/ack_b2a",
"unique_bytes_sent_a2b" , "unique_bytes_sent_b2a",
"actual_data_pkts_a2b" , "actual_data_pkts_b2a",
"actual_data_bytes_a2b" , "actual_data_bytes_b2a",
"rexmt_data_pkts_a2b" , "rexmt_data_pkts_b2a",
"rexmt_data_bytes_a2b" , "rexmt_data_bytes_b2a",
"zwnd_probe_pkts_a2b" , "zwnd_probe_pkts_b2a",
"zwnd_probe_bytes_a2b" , "zwnd_probe_bytes_b2a",
"outoforder_pkts_a2b" , "outoforder_pkts_b2a",
"pushed_data_pkts_a2b" , "pushed_data_pkts_b2a",
"SYN/FIN_pkts_sent_a2b" , "SYN/FIN_pkts_sent_b2a",
"req_1323_ws/ts_a2b" , "req_1323_ws/ts_b2a",
"adv_wind_scale_a2b" , "adv_wind_scale_b2a",
"req_sack_a2b" , "req_sack_b2a",
"sacks_sent_a2b" , "sacks_sent_b2a",
"urgent_data_pkts_a2b" , "urgent_data_pkts_b2a",
"urgent_data_bytes_a2b" , "urgent_data_bytes_b2a",
"mss_requested_a2b" , "mss_requested_b2a",
"max_segm_size_a2b" , "max_segm_size_b2a",
"min_segm_size_a2b" , "min_segm_size_b2a",
"avg_segm_size_a2b" , "avg_segm_size_b2a",
"max_win_adv_a2b" , "max_win_adv_b2a",
"min_win_adv_a2b" , "min_win_adv_b2a",
"zero_win_adv_a2b" , "zero_win_adv_b2a",
"avg_win_adv_a2b" , "avg_win_adv_b2a"
};
#define SV_HEADER1_COLUMN_COUNT (sizeof(svHeader1)/sizeof(char*))
char *svHeader2[] = {
"initial_window_bytes_a2b" , "initial_window_bytes_b2a",
"initial_window_pkts_a2b" , "initial_window_pkts_b2a",
"ttl_stream_length_a2b" , "ttl_stream_length_b2a",
"missed_data_a2b" , "missed_data_b2a",
"truncated_data_a2b" , "truncated_data_b2a",
"truncated_packets_a2b" , "truncated_packets_b2a",
"data_xmit_time_a2b" , "data_xmit_time_b2a",
"idletime_max_a2b" , "idletime_max_b2a",
"hardware_dups_a2b" , "hardware_dups_b2a",
"throughput_a2b" , "throughput_b2a"
};
#define SV_HEADER2_COLUMN_COUNT (sizeof(svHeader2)/sizeof(char*))
/* Headers to be printed if the OWIN stats are requested.
*/
char *svOWINHeader[] = {
"max_owin_a2b" , "max_owin_b2a",
"min_non-zero_owin_a2b" , "min_non-zero_owin_b2a",
"avg_owin_a2b" , "avg_owin_b2a",
"wavg_owin_a2b" , "wavg_owin_b2a"
};
#define SV_OWIN_HEADER_COLUMN_COUNT (sizeof(svOWINHeader)/sizeof(char*))
/* Headers for RTT, to be printed for long output requested with
* comma/tab/<SP>-separated- values.
*/
char *svRTTHeader[] = {
"RTT_samples_a2b" , "RTT_samples_b2a",
"RTT_min_a2b" , "RTT_min_b2a",
"RTT_max_a2b" , "RTT_max_b2a",
"RTT_avg_a2b" , "RTT_avg_b2a",
"RTT_stdev_a2b" , "RTT_stdev_b2a",
"RTT_from_3WHS_a2b" , "RTT_from_3WHS_b2a",
"RTT_full_sz_smpls_a2b" , "RTT_full_sz_smpls_b2a",
"RTT_full_sz_min_a2b" , "RTT_full_sz_min_b2a",
"RTT_full_sz_max_a2b" , "RTT_full_sz_max_b2a",
"RTT_full_sz_avg_a2b" , "RTT_full_sz_avg_b2a",
"RTT full_sz_stdev_a2b" , "RTT_full_sz_stdev_b2a",
"post-loss_acks_a2b" , "post-loss_acks_b2a",
"ambiguous_acks_a2b" , "ambiguous_acks_b2a",
"RTT_min_(last)_a2b" , "RTT_min_(last)_b2a",
"RTT_max_(last)_a2b" , "RTT_max_(last)_b2a",
"RTT_avg_(last)_a2b" , "RTT_avg_(last)_b2a",
"RTT_sdv_(last)_a2b" , "RTT_sdv_(last)_b2a",
"segs_cum_acked_a2b" , "segs_cum_acked_b2a",
"duplicate_acks_a2b" , "duplicate_acks_b2a",
"triple_dupacks_a2b" , "triple_dupacks_b2a",
"max_#_retrans_a2b" , "max_#_retrans_b2a",
"min_retr_time_a2b" , "min_retr_time_b2a",
"max_retr_time_a2b" , "max_retr_time_b2a",
"avg_retr_time_a2b" , "avg_retr_time_b2a",
"sdv_retr_time_a2b" , "sdv_retr_time_b2a"
};
#define SV_RTT_HEADER_COLUMN_COUNT (sizeof(svRTTHeader)/sizeof(char*))
/* Local Variables */
u_int i = 0; /* Counter */
/* Set the separator */
if(csv || tsv) {
/* Initialize the separator buffer */
sp = (char *)malloc(sizeof(char *) * 2);
memset(sp, 0, sizeof(sp));
/* Set it */
if(csv)
snprintf(sp, sizeof(sp), ",");
else if(tsv)
snprintf(sp, sizeof(sp), "\t");
}
else if (sv != NULL)
{
/* Look for escape sequence and remove the extra '\',
* the shell puts it in there.
* We will do this only for the escape sequence '\t' since that is
* the only useful one, else the user probably meant something
* else and things get messy.
*/
if(strncmp(sv, "\\t", 2) == 0) {
/* Initialize the separator buffer and set it */
sp = (char *)malloc(sizeof(char *) * 2);
memset(sp, 0, sizeof(sp));
snprintf(sp, sizeof(sp), "\t");
}
else /* Just use the string the user has provided */
sp = strdup(sv);
}
/* Print the column headings (the field names) */
for (i=0; i<SV_HEADER1_COLUMN_COUNT; i++)
fprintf(stdout, "%s%s", svHeader1[i], sp);
if (print_owin) {
for(i=0; i<SV_OWIN_HEADER_COLUMN_COUNT; i++)
fprintf(stdout, "%s%s", svOWINHeader[i], sp);
}
for (i=0; i<SV_HEADER2_COLUMN_COUNT; i++)
fprintf(stdout, "%s%s", svHeader2[i], sp);
/* Print the RTT column headings (the field names) */
if(print_rtt)
for(i = 0; i < SV_RTT_HEADER_COLUMN_COUNT; i++)
fprintf(stdout, "%s%s", svRTTHeader[i], sp);
/* Improve readability */
fprintf(stdout, "\n\n");
/* Set the number of columns expected to be printed. */
sv_expected_count=SV_HEADER1_COLUMN_COUNT + SV_HEADER2_COLUMN_COUNT;
if (print_rtt)
sv_expected_count += SV_RTT_HEADER_COLUMN_COUNT;
if (print_owin)
sv_expected_count += SV_OWIN_HEADER_COLUMN_COUNT;
if (debug>3) {
fprintf(stderr,"SV_HEADER_COUNT : -l alone = %d\n", \
(int)(SV_HEADER1_COLUMN_COUNT + SV_HEADER2_COLUMN_COUNT));
fprintf(stderr," : -W alone = %d\n", \
(int)SV_OWIN_HEADER_COLUMN_COUNT);
fprintf(stderr," : -r alone = %d\n", \
(int)SV_RTT_HEADER_COLUMN_COUNT);
fprintf(stderr,"sv_expected_count=%u\n",sv_expected_count);
}
}
syntax highlighted by Code2HTML, v. 0.9.1