From: Stephen Hemminger <[email protected]>
Newsgroups: net.sources
Subject: Re: TCP debugging aid for 4.2BSD
Date: 31 May 85 18:26:27 GMT

Chris, I already had one of these based on your Window library....

I didn't write any documentation for it but it should be pretty obvious.. 8-)

---- cut here ---
/*
* Tcp Debug - visual picture of Tcp connections
*
* Simple menu driven display of information about Tcp based connections.
* This combines the information of netstat + trpt.
*/

#ifndef lint
static char _rcsid[] = "$Header: tcpic.c,v 1.1 85/04/09 15:25:00 steveh Exp $$Locker:  $";
#endif

#include <stdio.h>
#include <netdb.h>
#include <nlist.h>
#include <local/window.h>

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
#define PRUREQUESTS
#include <sys/protosw.h>
#include <sys/ioctl.h>
#include <sys/mbuf.h>

#include <net/route.h>
#include <net/if.h>

#include <netinet/in.h>
#include <netinet/in_pcb.h>
#include <netinet/in_systm.h>
#include <netinet/ip.h>
#include <netinet/ip_var.h>
#include <netinet/tcp.h>
#define TCPSTATES
#include <netinet/tcp_fsm.h>
#include <netinet/tcp_seq.h>
#define TCPTIMERS
#include <netinet/tcp_timer.h>
#include <netinet/tcp_var.h>
#include <netinet/tcpip.h>
#define TANAMES
#include <netinet/tcp_debug.h>


struct nlist nml[] = {
#define N_TCB           0
       { "_tcb" },
#define N_TCP_DEBUG     1
       { "_tcp_debug" },
#define N_TCP_DEBX      2
       { "_tcp_debx" },
#define N_MBSTAT        3
       { "_mbstat" },
#define N_TCPSTAT       4
       { "_tcpstat" },
       0
};


char    Tf_flags[] = "\1ACKNOW\2DELACK\3DONTKEEP\4NOOPT";
char    Th_flags[] = "\1FIN\2SYN\3RST\4PUSH\5ACK\6URG";

int     kmem;
int     aflag = 0;
int     iflag = 0;
int     mflag = 0;
int     dflag = 0;
int     interval = 10;

/* This determines what windows to display */
/* The 4 ints specify the position & size;
  the two strings are optional, and
  are the label and initial contents for the window
*/
struct initscreen {
       int     i_x, i_y, i_xe, i_ye;
       char    *i_lbl, *i_str;
} InitScreen[] = {
#define W_NETSTAT (wins[0])
/*0*/   0, 0,   80, 23, 0,
                       0,
#define W_SOCK  (wins[1])
/*1*/   0, 0,   16, 4,  "Socket",
                       "SendQ\nRecvQ",
#define W_BYTES (wins[2])
/*2*/   0, 4,   16, 4,  "Data Xfer",
                       "Sent\nRcvd",
#define W_RECV (wins[3])
/*3*/   0, 9,   16, 6,  "Recv Seq",
                       "Wind\nNext\nUrg\nAdv",
#define W_TIMER (wins[4])
/*4*/   17, 0,  16, 6, "Tcp Timers",
                       0,
#define W_SEND  (wins[5])
/*5*/   17, 6,  16, 9,  "Send Seq",
                       "Wind\nNext\nUrg\nMax\nUna\nSeq#\nAck#",
#define W_RETRY (wins[6])
/*6*/   35, 0,  16, 7,  "Retransmit",
                       "Shift\nIdle\nRtt\nRtseq\nSrtt",
#define W_PARAM (wins[7])
/*7*/   34, 9,  20,  6, "Parameters",
                       "State\nMax seg size\nForce\nFlags",
#define W_IFNET (wins[8])
/*8*/   56, 0,  20, 7,  "",
                       "In packets\nIn error\nOut packets\nOut errors\nCollisions",
#define W_MBSTAT (wins[9])
/*9*/   56, 8,  20, 6,  "Mbuf stat",
                       "In use\nFree\nPages\nFree Pages",
#define W_TCPSTAT (wins[10])
/*10*/  56, 8,  20, 7,  "Tcp stat",
                       "Bad Sum\nBad Off\nHdr Drop\nBad Segs\nUnack",
#define W_DEBUG (wins[11])
/*11*/  0, 15,  80, 8,  0, 0,
#define W_HELP  (wins[12])
/*12*/  0, 23,  80, 1,  0, 0
};

#define NWINS   (sizeof InitScreen/sizeof *InitScreen)

static char buf[BUFSIZ];

#define WPR(w,y,x,fmt,n)        WAcursor (w, y, x),     \
                               (void) sprintf (buf, fmt, n),   \
                               Wputs (buf, w)

Win     *wins[NWINS];
int     Maxrows, Maxcols;

struct inpcb    *GetInpcb();
char            *strsave();
extern char     *strcpy(), *malloc(), *calloc(), *index(),
               *inet_ntoa();
extern long     lseek();

/*
* Main program
*  Parse arguments, choose connection and display it.
*/
main(argc, argv)
       int argc;
       char *argv[];
{
       register struct inpcb *inp;

       while(--argc && **++argv == '-') {
               switch(argv[0][1]) {
               case 'a': ++aflag;              break;
               case 'd': ++dflag;              break;
               case 'i': ++iflag;              break;
               case 'm': ++mflag;              break;
               default:
                       fprintf(stderr, "tcpic: unknown arg %s\n", argv[1]);
                       fprintf(stderr,"Usage: tcpic  [flags] [ interval ]\n");
                       fprintf(stderr,"flags: %s\n%s\n%s\n%s\n",
                               "\t-a\tall (include) servers",
                               "\t-d\tshow debug trace (trpt)",
                               "\t-i\tshow interfaces",
                               "\t-m\tshow mbuf stats");
                       exit(1);
               }
       }

       if(argc)
               interval = atoi(*++argv);


       nlist("/vmunix", nml);

       if(nml[0].n_value == 0) {
               fprintf(stderr,"tcpic: can't read kernel symbol table\n");
               exit(1);
       }

       if( (kmem = open("/dev/kmem", 0)) < 0) {
               perror("/dev/kmem");
               exit(1);
       }

       SetupWindows();
       Wfront(W_NETSTAT);
       Wsetmode(W_HELP, WBOLD);
       Wnewline(W_HELP, 0);
       Wlabel( W_NETSTAT,
               "# Local Address        Foreign Address   State",
               0, 0);

       if(!iflag)
               Whide(W_IFNET);
       if(!mflag)
               Whide(W_MBSTAT);
       else
               Whide(W_TCPSTAT);
       BuildPortTable();

       sethostent(1);

       while( (inp = GetInpcb()) != NULL) {
               Whide(W_NETSTAT);
               Display(inp);
               Wunhide(W_NETSTAT);
       }

       Wexit(0);
}

/*
* Set up the initial window display.
*/
SetupWindows()
{
       register struct initscreen *ip;
       register char *str;
       register Win *w;
       register int n;

       if(Winit(0,0))  {
               fprintf(stderr, "This terminal doesn't support windows\n");
               exit(1);
       }
       Wscreensize(&Maxrows, &Maxcols);

       /* initialize windows */
       for(n = 0, ip = InitScreen; n < NWINS; n++, ip++) {
               /*  adjust size of some windows to fit screen */

               if(n == &W_NETSTAT - wins) {
                       ip->i_ye = Maxrows-1;   /* netstat takes full screen */
                       ip->i_xe = Maxcols;
               } else if(n == &W_HELP - wins) {
                       ip->i_y = Maxrows-1;    /* help at bottom */
                       ip->i_xe = Maxcols;
               } else if(n == &W_DEBUG - wins) {/* debug takes what is left on screen */
                       ip->i_ye = Maxrows - ip->i_y - 2;
                       ip->i_xe = Maxcols;
               }

               w = Wopen(0, ip->i_x, ip->i_y, ip->i_xe, ip->i_ye, 0, 0);
               if (w == 0) {
                       Wcleanup();
                       fprintf(stderr, "can't fit window '%s' at %d,%d of %d,%d\n",
                               ip->i_lbl, ip->i_x, ip->i_y, ip->i_xe, ip->i_ye);
                       fprintf(stderr, "Screen is too small\n");
                       exit(1);
               }
               wins[ip - InitScreen] = w;
               Woncursor(w, 0);
               Wnewline(w, 1);
               Wwrap(w, 0);
               if(ip->i_lbl) {
                       Wframe(w);
                       Wlabel(w, ip->i_lbl, 0, 1);
               }
               if(str = ip ->i_str) {
                       if(*str == '$') {
                               Wsetmode(w, WINVERSE);
                               str++;
                       }
                       Wputs(str, w);
                       Wsetmode(w,0);
               }
       }
}

/*
* Read the port names out of /etc/services and store in memory
*  for faster access.
*/
char *PortTable[IPPORT_RESERVED];

BuildPortTable() {
       register struct servent *sp;
       u_short port;

       setservent();
       while( (sp = getservent()) != NULL)  {
               if(strcmp(sp->s_proto, "tcp") != 0)
                       continue;
               port = ntohs((u_short) sp->s_port);
               if(port < IPPORT_RESERVED)
                       PortTable[port] = strsave(sp->s_name);
       }
       endservent();
}

/*
* Lookup a port name
*/
char *inetport(port)
       u_short port;
{
       u_short p = ntohs(port);
       static char portbuf[10];

       if(p == 0)
               return "*";
       else if(p >= IPPORT_RESERVED || PortTable[p] == NULL) {
               (void) sprintf(portbuf, "%d", p);
               return portbuf;
       } else
               return PortTable[p];
}

/*
* Host address to name translation
*   keep already looked up entries around to speed things up.
*/

struct hosts {
       struct hosts *ho_next;
       char    *ho_name;
       u_long  ho_addr;
} *headhost = NULL;

char *inethost(in)
       struct in_addr in;
{
       register struct hosts *ho;
       register struct hostent *hp;

       if (inet_lnaof(in) == INADDR_ANY)
               return "*";

       /* look in save list */
       for(ho = headhost; ho != NULL; ho = ho->ho_next)
               if(ho->ho_addr == in.s_addr)
                       return ho->ho_name;
       hp = gethostbyaddr(&in, sizeof (struct in_addr), AF_INET);
       if (hp == NULL)
               return inet_ntoa(in);

       /* add to save list */
       ho = (struct hosts *) malloc(sizeof(struct hosts));
       ho->ho_addr = in.s_addr;
       ho->ho_name = strsave(hp->h_name);
       ho->ho_next = headhost;
       headhost = ho;

       return hp->h_name;
}
/*
* Pretty print an Internet address (net address + port).
*/
char *
inetprint(in, port)
       struct in_addr in;
       u_short port;
{
       static char line[80];

       (void) sprintf(line, "%s.%s", inethost(in), inetport(port));
       return line;
}

/*
* Print a value a la the %b format of the kernel's printf
*/
char *
flagprint(v, bits)
       register char *bits;
       u_short v;
{
       register char *cp;
       register int i, any = 0;
       static char obuf[128];

       (void) sprintf(obuf,"%x", v);
       cp = obuf + strlen(obuf);
       if (v) {
               *cp++ = '<';
               while (i = *bits++) {
               if (v & (1 << (i-1))) {
                               if (any)
                                       *cp++ = ',';
                               any = 1;
                               for (; *bits > 32; bits++)
                                       *cp++ = *bits;
                       } else
                               for (; *bits > 32; bits++)
                                       ;
               }
               *cp++ = '>';
               *cp = '\0';
       }
       return obuf;
}

/*
* Print out tcp state
*/
char *
inetstate(off)
       long off;
{
       static char line[40];
       struct tcpcb tcpcb;

       (void) lseek(kmem, off, 0);
       (void) read(kmem, (char *) &tcpcb, sizeof (tcpcb));

       if (tcpcb.t_state < 0 || tcpcb.t_state >= TCP_NSTATES)
               (void) sprintf(line, "%d", tcpcb.t_state);
       else
               (void) strcpy(line, tcpstates[tcpcb.t_state]);
       return line;
}

ReadChar() {
       char c;

       if(read(0, &c, 1) != 1)
               Wexit(0);
       c &= 0x7f;
       ioctl(0, FIONREAD, (char *) &InputPending);

       return c;
}

struct inpcb *
GetInpcb() {
       register struct inpcb *next, *prev;
       register int n;
       char c, *cp;
       struct inpcb inpcb;
       long off = nml[N_TCB].n_value;
       static int npcbs = 0;
       static struct inpcb **inpcbs;
       static char keys[] =
               "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";

       if(npcbs == 0) {
               npcbs = Maxrows - 2;
               inpcbs = (struct inpcb **)
                        calloc(npcbs, sizeof (struct inpcb *));
       }

reread:
       WAcursor(W_NETSTAT, 0, 0);
       Wclear(W_NETSTAT, 2);

       (void) lseek(kmem, off, 0);
       (void) read(kmem, (char *) &inpcb, sizeof (struct inpcb));

       prev = (struct inpcb *) off;

       n = 0;
       /* follow around circular list */
       while(inpcb.inp_next != (struct inpcb *)off && n < npcbs) {
               next = inpcb.inp_next;

               (void) lseek(kmem, (long) next, 0);
               (void) read(kmem, (char *) &inpcb, sizeof(struct inpcb));
               if(inpcb.inp_prev != prev) {
                       Wputs("??? (lost sync)\n", W_NETSTAT);
                       break;
               }

               if(!aflag && inet_lnaof(inpcb.inp_laddr) == INADDR_ANY) {
                       prev = next;
                       continue;
               }

               WAcursor(W_NETSTAT, n, 0);
               Wsetmode(W_NETSTAT, WBOLD);
               Wputc( keys[n], W_NETSTAT);
               Wsetmode(W_NETSTAT, 0);
               (void) sprintf(buf, " %-18.18s",
                       inetprint(inpcb.inp_laddr,inpcb.inp_lport));
               Wputs(buf, W_NETSTAT);
               (void) sprintf(buf, " %-18.18s %s",
                       inetprint(inpcb.inp_faddr,inpcb.inp_fport),
                       inetstate((long)inpcb.inp_ppcb));
               Wputs(buf, W_NETSTAT);

               prev = next;
               if(inpcbs[n] == 0)
                       inpcbs[n] = (struct inpcb *) malloc(sizeof(inpcb));
               *inpcbs[n] = inpcb;
               ++n;
       }

       Wclearline(W_HELP, 2);
       Wputs("<letter> => show conn, <SPACE> => reread, <ESC> => quit, '^L' => redraw\r",
                W_HELP);
       Wrefresh(0);

       for(;;) {
               switch(c = ReadChar()) {
               case CTRL(l):
                       ++ScreenGarbaged;
                       /* fall into */
               case ' ':
                       goto reread;
               case CTRL([):
                       return NULL;
               default:
                       cp = index(keys, c);
               }
               if(cp == NULL || cp >= &keys[n])
                       Ding();
               else
                       break;
       }

       return inpcbs[cp - keys];
}

struct socket sockstr;
struct rtentry rtentry;
struct ifnet iflast;
struct tcpstat tcplast;
struct mbuf mtcpcb;             /* mbuf containing tcpcb */
char    ifname[10];

Display(inp)
       register struct inpcb *inp;
{
       register struct mbuf *mptr;
       register int i;

       Wclearline(W_HELP,2);
       Wputs("<ESC> => quit back to menu, '^L' => redraw\r", W_HELP);


       for(i = 0; i < TCPT_NTIMERS; ++i) {
               WPR(W_TIMER, i, 0, "%s", tcptimers[i]);
       }

       if(iflag) {
               (void) lseek(kmem, (long) inp->inp_route.ro_rt, 0);
               (void) read(kmem, (char *) &rtentry, sizeof(rtentry));

               (void) lseek(kmem, (long) rtentry.rt_ifp, 0);
               (void) read(kmem, (char *) &iflast, sizeof(struct ifnet));

               (void) lseek(kmem, (long) iflast.if_name, 0);
               (void) read(kmem, ifname, sizeof(ifname));

               (void) sprintf(buf, "If %s%d", ifname, iflast.if_unit);
               Wlabel(W_IFNET, buf, 0, 1);
       }

       if(!mflag) {
               (void) lseek(kmem, nml[N_TCPSTAT].n_value, 0);
               (void) read(kmem, (caddr_t) &tcplast, sizeof tcplast);
       }

       Whide(W_DEBUG);

       mptr = dtom(inp->inp_ppcb);

       for(;;) {
               (void) lseek(kmem, (long) mptr, 0);
               (void) read(kmem, (char *) &mtcpcb, sizeof(mtcpcb));

               if(mtcpcb.m_type != MT_PCB ) {
                       Wclearline(W_HELP, 2);
                       Wputs("Connection closed\r", W_HELP);
                       Wrefresh(0);
                       sleep(1);
                       break;
               }

               (void) lseek(kmem, (long) inp->inp_socket, 0);
               (void) read(kmem, (char *) &sockstr, sizeof(sockstr));

               DisplayTcp(mtod(&mtcpcb,struct tcpcb *));
               if(iflag)
                       DisplayIf();
               if(mflag)
                       DisplayMbuf();
               else
                       DisplayStat();

               Wrefresh (0);
               if(dflag && sockstr.so_options & SO_DEBUG) {
                       Wunhide(W_DEBUG);
                       DoDebug(inp->inp_ppcb);
               }

               /* Refresh and redisplay */
               while (InputPending) {
                       switch( ReadChar() ) {
                       case CTRL(l):
                               ScreenGarbaged++;
                               break;
                       case 'q':
                       case 'Q':
                       case CTRL([):
                               return;
                       }
               }

               if(interval)
                       sleep(interval);

       }
}

DisplayStat()
{
       struct tcpstat tcpcur;

       (void) lseek(kmem, nml[N_TCPSTAT].n_value, 0);
       (void) read(kmem, (char *) &tcpcur, sizeof tcpcur);

       WPR(W_TCPSTAT, 0, 10, "%8d", tcpcur.tcps_badsum-tcplast.tcps_badsum);
       WPR(W_TCPSTAT, 1, 10, "%8d", tcpcur.tcps_badoff-tcplast.tcps_badoff);
       WPR(W_TCPSTAT, 2, 10, "%8d", tcpcur.tcps_hdrops-tcplast.tcps_hdrops);
       WPR(W_TCPSTAT, 3, 10, "%8d", tcpcur.tcps_badsegs-tcplast.tcps_badsegs);
       WPR(W_TCPSTAT, 4, 10, "%8d", tcpcur.tcps_unack-tcplast.tcps_unack);
       tcplast = tcpcur;
}

DisplayMbuf()
{
       struct mbstat mbstat;

       if(nml[N_MBSTAT].n_type == 0)
               return;

       (void) lseek(kmem, nml[N_MBSTAT].n_value, 0);
       (void) read(kmem, (char *) &mbstat, sizeof mbstat);

       WPR(W_MBSTAT, 0, 10, "%8d", mbstat.m_mbufs - mbstat.m_mbfree);
       WPR(W_MBSTAT, 1, 10, "%8d", mbstat.m_mbfree);
       WPR(W_MBSTAT, 2, 10, "%8d", mbstat.m_clusters - mbstat.m_clfree);
       WPR(W_MBSTAT, 3, 10, "%8d", mbstat.m_clfree);
}

DisplayIf()
{
       struct ifnet ifcur;

       (void) lseek(kmem, (long) rtentry.rt_ifp, 0);
       (void) read(kmem, (char *) &ifcur, sizeof(struct ifnet));

       WPR(W_IFNET, 0, 11, "%8d", ifcur.if_ipackets - iflast.if_ipackets);
       WPR(W_IFNET, 1, 11, "%8d", ifcur.if_ierrors - iflast.if_ierrors);
       WPR(W_IFNET, 2, 11, "%8d", ifcur.if_opackets - iflast.if_opackets);
       WPR(W_IFNET, 3, 11, "%8d", ifcur.if_ierrors - iflast.if_ierrors);
       WPR(W_IFNET, 4, 11, "%8d", ifcur.if_collisions - iflast.if_collisions);
       iflast = ifcur;
}

DisplayTcp(tcp)
       register struct tcpcb *tcp;
{
       register int i;

       for(i = 0; i < TCPT_NTIMERS; i++) {
               WPR(W_TIMER, i, 8, "%6d", tcp->t_timer[i]);
       }

       WPR(W_RETRY, 0, 6, "%8d", tcp->t_rxtshift);
       WPR(W_RETRY, 1, 6, "%8d", tcp->t_idle);
       WPR(W_RETRY, 2, 6, "%8d", tcp->t_rtt);
       WPR(W_RETRY, 3, 6, "%8x", tcp->t_rtseq);
#ifdef NOFLOAT
       WPR(W_RETRY, 4, 6, "%8.2f", (double) tcp->t_srtt/((double) TCPT_SCALE));
#else
       WPR(W_RETRY, 4, 6, "%8.2f", tcp->t_srtt);
#endif

       WAcursor(W_PARAM, 0, 6);
       if (tcp->t_state < 0 || tcp->t_state >= TCP_NSTATES)
               (void) sprintf(buf, "%12d" , tcp->t_state);
       else
               (void) sprintf(buf, "%12s", tcpstates[tcp->t_state]);
       Wputs(buf, W_PARAM);
       WPR(W_PARAM, 1, 13, "%5d", tcp->t_maxseg);
       WPR(W_PARAM, 2, 14, "%4d", tcp->t_force);
       WPR(W_PARAM, 3, 6, "%12s", flagprint((u_short)tcp->t_flags, Tf_flags));

       WPR(W_SEND, 0, 6, "%8d", tcp->snd_wnd);
       WPR(W_SEND, 1, 6, "%8x", tcp->snd_nxt);
       WPR(W_SEND, 2, 6, "%8x", tcp->snd_up);
       WPR(W_SEND, 3, 6, "%8x", tcp->snd_max);
       WPR(W_SEND, 4, 6, "%8x", tcp->snd_una);
       WPR(W_SEND, 5, 6, "%8x", tcp->snd_wl1);
       WPR(W_SEND, 6, 6, "%8x", tcp->snd_wl2);

       WPR(W_RECV, 0, 6, "%8d", tcp->rcv_wnd);
       WPR(W_RECV, 1, 6, "%8x", tcp->rcv_nxt);
       WPR(W_RECV, 2, 6, "%8x", tcp->rcv_up);
       WPR(W_RECV, 3, 6, "%8x", tcp->rcv_adv);

       WPR(W_BYTES, 0, 5, "%10d", (u_long)tcp->snd_nxt - (u_long)tcp->iss);
       WPR(W_BYTES, 1, 5, "%10d", (u_long)tcp->rcv_nxt - (u_long)tcp->irs);

       WPR(W_SOCK, 0, 5, "%10d", sockstr.so_snd.sb_cc);
       WPR(W_SOCK, 1, 5, "%10d", sockstr.so_rcv.sb_cc);

}

char *strsave(str)
       register char *str;
{
       register int len = strlen(str);
       register char *new;
       extern char *malloc();

       new = malloc(++len);
       (void) strcpy(new, str);
       return new;
}

/*
* Tcp debug routines
*/

DoDebug(tcp)
       caddr_t tcp;
{
       static int last_debx = -1;
       register int debx;

       if(nml[N_TCP_DEBUG].n_type == 0)
               return;
       (void) lseek(kmem, nml[N_TCP_DEBX].n_value, 0);
       (void) read(kmem, (char *) &tcp_debx, sizeof(tcp_debx));

       (void) lseek(kmem, nml[N_TCP_DEBUG].n_value, 0);
       (void) read(kmem, (char *) tcp_debug, sizeof(tcp_debug));

       Wunhide(W_DEBUG);
       if(last_debx == -1) {
               last_debx = tcp_debx;
               return;
       }

       for(debx = last_debx; debx != tcp_debx; debx = ++debx % TCP_NDEBUG) {
               if(tcp != tcp_debug[debx].td_tcb)
                       continue;
               tcp_trace(&tcp_debug[debx]);
               Wrefresh(0);
               if(InputPending)
                       break;
       }
       last_debx = debx;
}

/*
* Print out a Tcp debug record
*/
tcp_trace(td)
       register struct tcp_debug *td;
{
       register struct tcpiphdr *ti = &td->td_ti;
       tcp_seq seq, ack;
       short act = td->td_act;
       short req = td->td_req;
       int len, flags, win, timer;

       (void) sprintf(buf,"%03d %s:%s ", (ntohl(td->td_time)/10) % 1000,
                       tcpstates[td->td_ostate], tanames[act]);
       Wputs(buf, W_DEBUG);

       switch (act) {
       case TA_INPUT:
       case TA_OUTPUT:
       case TA_DROP:
               (void) sprintf(buf,"(src=%s,%d, dst=%s,%d)\n\t",
                       inet_ntoa(ti->ti_src), ntohs(ti->ti_sport),
                       inet_ntoa(ti->ti_dst), ntohs(ti->ti_dport));
               Wputs(buf, W_DEBUG);

               seq = ti->ti_seq;
               ack = ti->ti_ack;
               len = ti->ti_len;
               win = ti->ti_win;
               if (act == TA_OUTPUT) {
                       seq = ntohl(seq);
                       ack = ntohl(ack);
                       len = ntohs(len);
                       win = ntohs(win);
               }
               if (act == TA_OUTPUT)
                       len -= sizeof (struct tcphdr);
               if (len)
                       (void) sprintf(buf,"[%x..%x)@%x", seq, seq+len, ack);
               else
                       (void) sprintf(buf,"%x@%x", seq, ack);

               Wputs(buf, W_DEBUG);
               if (win) {
                       (void) sprintf(buf,"(win=%x)", win);
                       Wputs(buf, W_DEBUG);
               }

               if (flags = ti->ti_flags) {
                       Wputs(" flags=",W_DEBUG);
                       Wputs(flagprint((u_short)flags, Th_flags), W_DEBUG);
               }
               break;

       case TA_USER:
               timer = req >> 8;
               req &= 0xff;
               (void) sprintf(buf,"%s", prurequests[req]);
               Wputs(buf, W_DEBUG);
               if (req == PRU_SLOWTIMO || req == PRU_FASTTIMO) {
                       (void) sprintf(buf,"<%s>", tcptimers[timer]);
                       Wputs(buf, W_DEBUG);
               }
               break;
       }
       (void) sprintf(buf," -> %s\n", tcpstates[td->td_cb.t_state]);
       Wputs(buf,W_DEBUG);
}

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.