# 2.11BSD#431 - /usr/src/usr.sbin/trpt/trpt.c

##### Functions

    dotrace           X
    main              X
    numeric           X
    ptime             X
    tcp_trace         X

##### Variables

    aflag             X
    copyright         X
    follow            X
    jflag             X
    nl                X
    sflag             X
    tcp_debug         X
    tcp_debx          X
    tcp_pcbs          X
    tflag             X

##### Macros

    PRUREQUESTS       X
    SUPERVISOR        X
    TANAMES           X
    TCPSTATES         X
    TCPTIMERS         X
    pf                X

       1: /*
       2:  * Copyright (c) 1983 Regents of the University of California.
       3:  * All rights reserved.  The Berkeley software License Agreement
       4:  * specifies the terms and conditions for redistribution.
       5:  */
       6:
       7: #ifndef lint
       8: char copyright[] =
       9: "@(#) Copyright (c) 1983 Regents of the University of California.\n\
      10:  All rights reserved.\n";
      11: #endif not lint
      12:
      13: #ifndef lint
      14: static char sccsid[] = "@(#)trpt.c	5.2 (Berkeley) 9/18/85";
      15: #endif not lint
      16:
      17: #include <sys/param.h>
      18: #include <sys/socket.h>
      19: #include <sys/socketvar.h>
      20: #define PRUREQUESTS
      21: #define SUPERVISOR
      22: #include <sys/protosw.h>
      23: #undef SUPERVISOR
      24:
      25: #include <net/route.h>
      26: #include <net/if.h>
      27:
      28: #include <netinet/in.h>
      29: #include <netinet/in_pcb.h>
      30: #include <netinet/in_systm.h>
      31: #include <netinet/ip.h>
      32: #include <netinet/ip_var.h>
      33: #include <netinet/tcp.h>
      34: #define TCPSTATES
      35: #include <netinet/tcp_fsm.h>
      36: #include <netinet/tcp_seq.h>
      37: #define TCPTIMERS
      38: #include <netinet/tcp_timer.h>
      39: #include <netinet/tcp_var.h>
      40: #include <netinet/tcpip.h>
      41: #define TANAMES
      42: #include <netinet/tcp_debug.h>
      43:
      44: #include <arpa/inet.h>
      45:
      46: #include <stdio.h>
      47: #include <errno.h>
      48: #include <nlist.h>
      49:
      50: n_time  ntime;
      51: int sflag;
      52: int tflag;
      53: int jflag;
      54: int aflag;
      55: int follow;
      56: int numeric();
      57: struct  nlist nl[] = {
      58:     { "_tcp_debug" },
      59:     { "_tcp_debx" },
      60:     0
      61: };
      62: struct  tcp_debug tcp_debug[TCP_NDEBUG];
      63: caddr_t tcp_pcbs[TCP_NDEBUG];
      64: int tcp_debx;
      65:
      66: main(argc, argv)
      67:     int argc;
      68:     char **argv;
      69: {
      70:     int i, mask = 0, npcbs = 0;
      71:     char *system = "/vmunix", *core = "/dev/kmem";
      72:
      73:     argc--, argv++;
      74: again:
      75:     if (argc > 0 && !strcmp(*argv, "-a")) {
      76:         aflag++, argc--, argv++;
      77:         goto again;
      78:     }
      79:     if (argc > 0 && !strcmp(*argv, "-f")) {
      80:         follow++, argc--, argv++;
      81:         goto again;
      82:     }
      83:     if (argc > 0 && !strcmp(*argv, "-s")) {
      84:         sflag++, argc--, argv++;
      85:         goto again;
      86:     }
      87:     if (argc > 0 && !strcmp(*argv, "-t")) {
      88:         tflag++, argc--, argv++;
      89:         goto again;
      90:     }
      91:     if (argc > 0 && !strcmp(*argv, "-j")) {
      92:         jflag++, argc--, argv++;
      93:         goto again;
      94:     }
      95:     if (argc > 0 && !strcmp(*argv, "-p")) {
      96:         argc--, argv++;
      97:         if (argc < 1) {
      98:             fprintf(stderr, "-p: missing tcpcb address\n");
      99:             exit(1);
     100:         }
     101:         if (npcbs >= TCP_NDEBUG) {
     102:             fprintf(stderr, "-p: too many pcb's specified\n");
     103:             exit(1);
     104:         }
     105:         sscanf(*argv, "%x", &tcp_pcbs[npcbs++]);
     106:         argc--, argv++;
     107:         goto again;
     108:     }
     109:     if (argc > 0) {
     110:         system = *argv;
     111:         argc--, argv++;
     112:         mask++;
     113:     }
     114:     if (argc > 0) {
     115:         core = *argv;
     116:         argc--, argv++;
     117:         mask++;
     118:     }
     119:     (void) nlist(system, nl);
     120:     if (nl[0].n_value == 0) {
     121:         fprintf(stderr, "trpt: %s: no namelist\n", system);
     122:         exit(1);
     123:     }
     124:     (void) close(0);
     125:     if (open(core, 0) < 0) {
     126:         fprintf(stderr, "trpt: "); perror(core);
     127:         exit(2);
     128:     }
     129:     if (mask) {
     130:         nl[0].n_value &= 0x7fffffff;
     131:         nl[1].n_value &= 0x7fffffff;
     132:     }
     133:     (void) lseek(0, nl[1].n_value, 0);
     134:     if (read(0, &tcp_debx, sizeof (tcp_debx)) != sizeof (tcp_debx)) {
     135:         fprintf(stderr, "trpt: "); perror("tcp_debx");
     136:         exit(3);
     137:     }
     138:     (void) lseek(0, nl[0].n_value, 0);
     139:     if (read(0, tcp_debug, sizeof (tcp_debug)) != sizeof (tcp_debug)) {
     140:         fprintf(stderr, "trpt: "); perror("tcp_debug");
     141:         exit(3);
     142:     }
     143:     /*
     144: 	 * If no control blocks have been specified, figure
     145: 	 * out how many distinct one we have and summarize
     146: 	 * them in tcp_pcbs for sorting the trace records
     147: 	 * below.
     148: 	 */
     149:     if (npcbs == 0) {
     150:         for (i = 0; i < TCP_NDEBUG; i++) {
     151:             register int j;
     152:             register struct tcp_debug *td = &tcp_debug[i];
     153:
     154:             if (td->td_tcb == 0)
     155:                 continue;
     156:             for (j = 0; j < npcbs; j++)
     157:                 if (tcp_pcbs[j] == td->td_tcb)
     158:                     break;
     159:             if (j >= npcbs)
     160:                 tcp_pcbs[npcbs++] = td->td_tcb;
     161:         }
     162:     }
     163:     qsort(tcp_pcbs, npcbs, sizeof (caddr_t), numeric);
     164:     if (jflag) {
     165:         char *cp = "";
     166:
     167:         for (i = 0; i < npcbs; i++) {
     168:             printf("%s%x", cp, tcp_pcbs[i]);
     169:             cp = ", ";
     170:         }
     171:         if (*cp)
     172:             putchar('\n');
     173:         exit(0);
     174:     }
     175:     for (i = 0; i < npcbs; i++) {
     176:         printf("\n%x:\n", tcp_pcbs[i]);
     177:         dotrace(tcp_pcbs[i]);
     178:     }
     179:     exit(0);
     180: }
     181:
     182: dotrace(tcpcb)
     183:     register caddr_t tcpcb;
     184: {
     185:     register int i;
     186:     register struct tcp_debug *td;
     187:     int prev_debx = tcp_debx;
     188:
     189: again:
     190:     if (--tcp_debx < 0)
     191:         tcp_debx = TCP_NDEBUG - 1;
     192:     for (i = prev_debx % TCP_NDEBUG; i < TCP_NDEBUG; i++) {
     193:         td = &tcp_debug[i];
     194:         if (tcpcb && td->td_tcb != tcpcb)
     195:             continue;
     196:         ntime = ntohl(td->td_time);
     197:         tcp_trace(td->td_act, td->td_ostate, td->td_tcb, &td->td_cb,
     198:             &td->td_ti, td->td_req);
     199:         if (i == tcp_debx)
     200:             goto done;
     201:     }
     202:     for (i = 0; i <= tcp_debx % TCP_NDEBUG; i++) {
     203:         td = &tcp_debug[i];
     204:         if (tcpcb && td->td_tcb != tcpcb)
     205:             continue;
     206:         ntime = ntohl(td->td_time);
     207:         tcp_trace(td->td_act, td->td_ostate, td->td_tcb, &td->td_cb,
     208:             &td->td_ti, td->td_req);
     209:     }
     210: done:
     211:     if (follow) {
     212:         prev_debx = tcp_debx + 1;
     213:         if (prev_debx >= TCP_NDEBUG)
     214:         prev_debx = 0;
     215:         do {
     216:         sleep(1);
     217:         (void) lseek(0, nl[1].n_value, 0);
     218:         if (read(0, &tcp_debx, sizeof(tcp_debx)) != sizeof(tcp_debx)) {
     219:             fprintf(stderr, "trpt: "); perror("tcp_debx");
     220:             exit(3);
     221:         }
     222:         } while (tcp_debx == prev_debx);
     223:         (void) lseek(0, nl[0].n_value, 0);
     224:         if (read(0, tcp_debug, sizeof(tcp_debug)) != sizeof(tcp_debug)) {
     225:             fprintf(stderr, "trpt: "); perror("tcp_debug");
     226:             exit(3);
     227:         }
     228:         goto again;
     229:     }
     230: }
     231:
     232: /*
     233:  * Tcp debug routines
     234:  */
     235: tcp_trace(act, ostate, atp, tp, ti, req)
     236:     short act, ostate;
     237:     struct tcpcb *atp, *tp;
     238:     struct tcpiphdr *ti;
     239:     int req;
     240: {
     241:     tcp_seq seq, ack;
     242:     int len, flags, win, timer;
     243:     char *cp;
     244:
     245:     ptime(ntime);
     246:     printf("%s:%s ", tcpstates[ostate], tanames[act]);
     247:     switch (act) {
     248:
     249:     case TA_INPUT:
     250:     case TA_OUTPUT:
     251:     case TA_DROP:
     252:         if (aflag) {
     253:             printf("(src=%s,%d, ", inet_ntoa(ti->ti_src),
     254:                 ntohs(ti->ti_sport));
     255:             printf("dst=%s,%d)", inet_ntoa(ti->ti_dst),
     256:                 ntohs(ti->ti_dport));
     257:         }
     258:         seq = ti->ti_seq;
     259:         ack = ti->ti_ack;
     260:         len = ti->ti_len;
     261:         win = ti->ti_win;
     262:         if (act == TA_OUTPUT) {
     263:             seq = ntohl(seq);
     264:             ack = ntohl(ack);
     265:             len = ntohs(len);
     266:             win = ntohs(win);
     267:         }
     268:         if (act == TA_OUTPUT)
     269:             len -= sizeof (struct tcphdr);
     270:         if (len)
     271:             printf("[%x..%x)", seq, seq+len);
     272:         else
     273:             printf("%x", seq);
     274:         printf("@%x", ack);
     275:         if (win)
     276:             printf("(win=%x)", win);
     277:         flags = ti->ti_flags;
     278:         if (flags) {
     279:             char *cp = "<";
     280: #define pf(f) { if (ti->ti_flags&TH_/**/f) { printf("%s%s", cp, "f"); cp = ","; } }
     281:             pf(SYN); pf(ACK); pf(FIN); pf(RST); pf(PUSH); pf(URG);
     282:             printf(">");
     283:         }
     284:         break;
     285:
     286:     case TA_USER:
     287:         timer = req >> 8;
     288:         req &= 0xff;
     289:         printf("%s", prurequests[req]);
     290:         if (req == PRU_SLOWTIMO || req == PRU_FASTTIMO)
     291:             printf("<%s>", tcptimers[timer]);
     292:         break;
     293:     }
     294:     printf(" -> %s", tcpstates[tp->t_state]);
     295:     /* print out internal state of tp !?! */
     296:     printf("\n");
     297:     if (sflag) {
     298:         printf("\trcv_nxt %x rcv_wnd %x snd_una %x snd_nxt %x snd_max %x\n",
     299:             tp->rcv_nxt, tp->rcv_wnd, tp->snd_una, tp->snd_nxt,
     300:             tp->snd_max);
     301:         printf("\tsnd_wl1 %x snd_wl2 %x snd_wnd %x\n", tp->snd_wl1,
     302:             tp->snd_wl2, tp->snd_wnd);
     303:     }
     304:     /* print out timers? */
     305:     if (tflag) {
     306:         char *cp = "\t";
     307:         register int i;
     308:
     309:         for (i = 0; i < TCPT_NTIMERS; i++) {
     310:             if (tp->t_timer[i] == 0)
     311:                 continue;
     312:             printf("%s%s=%d", cp, tcptimers[i], tp->t_timer[i]);
     313:             if (i == TCPT_REXMT)
     314:                 printf(" (t_rxtshft=%d)", tp->t_rxtshift);
     315:             cp = ", ";
     316:         }
     317:         if (*cp != '\t')
     318:             putchar('\n');
     319:     }
     320: }
     321:
     322: ptime(ms)
     323:     int ms;
     324: {
     325:
     326:     printf("%03d ", (ms/10) % 1000);
     327: }
     328:
     329: numeric(c1, c2)
     330:     caddr_t *c1, *c2;
     331: {
     332:
     333:     return (*c1 - *c2);
     334: }

#### Defined functions

dotrace defined in line 182; used 1 times

- in line 177

main defined in line 66; never used
numeric defined in line 329; used 2 times

- in line 56, 163

ptime defined in line 322; used 1 times

- in line 245

tcp_trace defined in line 235; used 2 times

- in line 197, 207

#### Defined variables

aflag defined in line 54; used 2 times

- in line 76, 252

copyright defined in line 8; never used
follow defined in line 55; used 2 times

- in line 80, 211

jflag defined in line 53; used 2 times

- in line 92, 164

nl defined in line 57; used 8 times

- in line 119-120(2), 130-138(4), 217, 223

sccsid defined in line 14; never used
sflag defined in line 51; used 2 times

- in line 84, 297

tcp_debug defined in line 62; used 9 times

- in line 139(3), 152, 193, 203, 224(3)

tcp_debx defined in line 64; used 13 times

- in line 134(3), 187-191(3), 199-202(2), 212, 218-222(4)

tcp_pcbs defined in line 63; used 7 times

- in line 105, 157-168(4), 176-177(2)

tflag defined in line 52; used 2 times

- in line 88, 305

#### Defined macros

PRUREQUESTS defined in line 20; never used
SUPERVISOR defined in line 21; used 1 times

- in line 23

TANAMES defined in line 41; never used
TCPSTATES defined in line 34; never used
TCPTIMERS defined in line 37; never used
pf defined in line 280; used 6 times

- in line 281(6)

Last modified: 1988-07-04 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 1901 |