bostic@OKEEFFE.BERKELEY.EDU (Keith Bostic) (04/05/88)
Subject: (tcp 2 of 2) updated IP/TCP and XNS sources for 4.3BSD
Index: sys 4.3BSD
Description:
This is number 11 of 11 total articles posted to the newsgroup
comp.bugs.4bsd.ucb-fixes. This archive is number 2 of the 2
articles that make up the tcp posting.
# This is a shell archive. Save it in a file, remove anything before
# this line, and then unpack it by entering "sh file". Note, it may
# create directories; files and directories will be owned by you and
# have default permissions.
#
# This archive contains:
#
# netinet
# netinet/tcp_seq.h
# netinet/tcp_subr.c
# netinet/tcp_timer.c
# netinet/tcp_timer.h
# netinet/tcp_usrreq.c
# netinet/tcp_var.h
# netinet/tcpip.h
#
echo c - netinet
mkdir netinet > /dev/null 2>&1
echo x - netinet/tcp_seq.h
sed 's/^X//' >netinet/tcp_seq.h << 'END-of-netinet/tcp_seq.h'
X/*
X * Copyright (c) 1982, 1986 Regents of the University of California.
X * All rights reserved.
X *
X * Redistribution and use in source and binary forms are permitted
X * provided that this notice is preserved and that due credit is given
X * to the University of California at Berkeley. The name of the University
X * may not be used to endorse or promote products derived from this
X * software without specific prior written permission. This software
X * is provided ``as is'' without express or implied warranty.
X *
X * @(#)tcp_seq.h 7.2 (Berkeley) 12/7/87
X */
X
X/*
X * TCP sequence numbers are 32 bit integers operated
X * on with modular arithmetic. These macros can be
X * used to compare such integers.
X */
X#define SEQ_LT(a,b) ((int)((a)-(b)) < 0)
X#define SEQ_LEQ(a,b) ((int)((a)-(b)) <= 0)
X#define SEQ_GT(a,b) ((int)((a)-(b)) > 0)
X#define SEQ_GEQ(a,b) ((int)((a)-(b)) >= 0)
X
X/*
X * Macros to initialize tcp sequence numbers for
X * send and receive from initial send and receive
X * sequence numbers.
X */
X#define tcp_rcvseqinit(tp) \
X (tp)->rcv_adv = (tp)->rcv_nxt = (tp)->irs + 1
X
X#define tcp_sendseqinit(tp) \
X (tp)->snd_una = (tp)->snd_nxt = (tp)->snd_max = (tp)->snd_up = \
X (tp)->iss
X
X#define TCP_ISSINCR (125*1024) /* increment for tcp_iss each second */
X
X#ifdef KERNEL
Xtcp_seq tcp_iss; /* tcp initial send seq # */
X#endif
END-of-netinet/tcp_seq.h
echo x - netinet/tcp_subr.c
sed 's/^X//' >netinet/tcp_subr.c << 'END-of-netinet/tcp_subr.c'
X/*
X * Copyright (c) 1982, 1986 Regents of the University of California.
X * All rights reserved.
X *
X * Redistribution and use in source and binary forms are permitted
X * provided that this notice is preserved and that due credit is given
X * to the University of California at Berkeley. The name of the University
X * may not be used to endorse or promote products derived from this
X * software without specific prior written permission. This software
X * is provided ``as is'' without express or implied warranty.
X *
X * @(#)tcp_subr.c 7.13.1.1 (Berkeley) 2/7/88
X */
X
X#include "param.h"
X#include "systm.h"
X#include "mbuf.h"
X#include "socket.h"
X#include "socketvar.h"
X#include "protosw.h"
X#include "errno.h"
X
X#include "../net/route.h"
X#include "../net/if.h"
X
X#include "in.h"
X#include "in_pcb.h"
X#include "in_systm.h"
X#include "ip.h"
X#include "ip_var.h"
X#include "ip_icmp.h"
X#include "tcp.h"
X#include "tcp_fsm.h"
X#include "tcp_seq.h"
X#include "tcp_timer.h"
X#include "tcp_var.h"
X#include "tcpip.h"
X
Xint tcp_ttl = TCP_TTL;
X
X/*
X * Tcp initialization
X */
Xtcp_init()
X{
X
X tcp_iss = 1; /* wrong */
X tcb.inp_next = tcb.inp_prev = &tcb;
X}
X
X/*
X * Create template to be used to send tcp packets on a connection.
X * Call after host entry created, allocates an mbuf and fills
X * in a skeletal tcp/ip header, minimizing the amount of work
X * necessary when the connection is used.
X */
Xstruct tcpiphdr *
Xtcp_template(tp)
X struct tcpcb *tp;
X{
X register struct inpcb *inp = tp->t_inpcb;
X register struct mbuf *m;
X register struct tcpiphdr *n;
X
X if ((n = tp->t_template) == 0) {
X m = m_get(M_DONTWAIT, MT_HEADER);
X if (m == NULL)
X return (0);
X m->m_off = MMAXOFF - sizeof (struct tcpiphdr);
X m->m_len = sizeof (struct tcpiphdr);
X n = mtod(m, struct tcpiphdr *);
X }
X n->ti_next = n->ti_prev = 0;
X n->ti_x1 = 0;
X n->ti_pr = IPPROTO_TCP;
X n->ti_len = htons(sizeof (struct tcpiphdr) - sizeof (struct ip));
X n->ti_src = inp->inp_laddr;
X n->ti_dst = inp->inp_faddr;
X n->ti_sport = inp->inp_lport;
X n->ti_dport = inp->inp_fport;
X n->ti_seq = 0;
X n->ti_ack = 0;
X n->ti_x2 = 0;
X n->ti_off = 5;
X n->ti_flags = 0;
X n->ti_win = 0;
X n->ti_sum = 0;
X n->ti_urp = 0;
X return (n);
X}
X
X/*
X * Send a single message to the TCP at address specified by
X * the given TCP/IP header. If flags==0, then we make a copy
X * of the tcpiphdr at ti and send directly to the addressed host.
X * This is used to force keep alive messages out using the TCP
X * template for a connection tp->t_template. If flags are given
X * then we send a message back to the TCP which originated the
X * segment ti, and discard the mbuf containing it and any other
X * attached mbufs.
X *
X * In any case the ack and sequence number of the transmitted
X * segment are as specified by the parameters.
X */
Xtcp_respond(tp, ti, ack, seq, flags)
X struct tcpcb *tp;
X register struct tcpiphdr *ti;
X tcp_seq ack, seq;
X int flags;
X{
X register struct mbuf *m;
X int win = 0, tlen;
X struct route *ro = 0;
X
X if (tp) {
X win = sbspace(&tp->t_inpcb->inp_socket->so_rcv);
X ro = &tp->t_inpcb->inp_route;
X }
X if (flags == 0) {
X m = m_get(M_DONTWAIT, MT_HEADER);
X if (m == NULL)
X return;
X#ifdef TCP_COMPAT_42
X tlen = 1;
X#else
X tlen = 0;
X#endif
X m->m_len = sizeof (struct tcpiphdr) + tlen;
X *mtod(m, struct tcpiphdr *) = *ti;
X ti = mtod(m, struct tcpiphdr *);
X flags = TH_ACK;
X } else {
X m = dtom(ti);
X m_freem(m->m_next);
X m->m_next = 0;
X m->m_off = (int)ti - (int)m;
X tlen = 0;
X m->m_len = sizeof (struct tcpiphdr);
X#define xchg(a,b,type) { type t; t=a; a=b; b=t; }
X xchg(ti->ti_dst.s_addr, ti->ti_src.s_addr, u_long);
X xchg(ti->ti_dport, ti->ti_sport, u_short);
X#undef xchg
X }
X ti->ti_next = ti->ti_prev = 0;
X ti->ti_x1 = 0;
X ti->ti_len = htons((u_short)(sizeof (struct tcphdr) + tlen));
X ti->ti_seq = htonl(seq);
X ti->ti_ack = htonl(ack);
X ti->ti_x2 = 0;
X ti->ti_off = sizeof (struct tcphdr) >> 2;
X ti->ti_flags = flags;
X ti->ti_win = htons((u_short)win);
X ti->ti_urp = 0;
X ti->ti_sum = in_cksum(m, sizeof (struct tcpiphdr) + tlen);
X ((struct ip *)ti)->ip_len = sizeof (struct tcpiphdr) + tlen;
X ((struct ip *)ti)->ip_ttl = tcp_ttl;
X (void) ip_output(m, (struct mbuf *)0, ro, 0);
X}
X
X/*
X * Create a new TCP control block, making an
X * empty reassembly queue and hooking it to the argument
X * protocol control block.
X */
Xstruct tcpcb *
Xtcp_newtcpcb(inp)
X struct inpcb *inp;
X{
X struct mbuf *m = m_getclr(M_DONTWAIT, MT_PCB);
X register struct tcpcb *tp;
X
X if (m == NULL)
X return ((struct tcpcb *)0);
X tp = mtod(m, struct tcpcb *);
X tp->seg_next = tp->seg_prev = (struct tcpiphdr *)tp;
X tp->t_maxseg = TCP_MSS;
X tp->t_flags = 0; /* sends options! */
X tp->t_inpcb = inp;
X /*
X * Init srtt to TCPTV_SRTTBASE (0), so we can tell that we have no
X * rtt estimate. Set rttvar so that srtt + 2 * rttvar gives
X * reasonable initial retransmit time.
X */
X tp->t_srtt = TCPTV_SRTTBASE;
X tp->t_rttvar = TCPTV_SRTTDFLT << 2;
X TCPT_RANGESET(tp->t_rxtcur,
X ((TCPTV_SRTTBASE >> 2) + (TCPTV_SRTTDFLT << 2)) >> 1,
X TCPTV_MIN, TCPTV_REXMTMAX);
X tp->snd_cwnd = sbspace(&inp->inp_socket->so_snd);
X tp->snd_ssthresh = 65535; /* XXX */
X inp->inp_ppcb = (caddr_t)tp;
X return (tp);
X}
X
X/*
X * Drop a TCP connection, reporting
X * the specified error. If connection is synchronized,
X * then send a RST to peer.
X */
Xstruct tcpcb *
Xtcp_drop(tp, errno)
X register struct tcpcb *tp;
X int errno;
X{
X struct socket *so = tp->t_inpcb->inp_socket;
X
X if (TCPS_HAVERCVDSYN(tp->t_state)) {
X tp->t_state = TCPS_CLOSED;
X (void) tcp_output(tp);
X tcpstat.tcps_drops++;
X } else
X tcpstat.tcps_conndrops++;
X so->so_error = errno;
X return (tcp_close(tp));
X}
X
X/*
X * Close a TCP control block:
X * discard all space held by the tcp
X * discard internet protocol block
X * wake up any sleepers
X */
Xstruct tcpcb *
Xtcp_close(tp)
X register struct tcpcb *tp;
X{
X register struct tcpiphdr *t;
X struct inpcb *inp = tp->t_inpcb;
X struct socket *so = inp->inp_socket;
X register struct mbuf *m;
X
X t = tp->seg_next;
X while (t != (struct tcpiphdr *)tp) {
X t = (struct tcpiphdr *)t->ti_next;
X m = dtom(t->ti_prev);
X remque(t->ti_prev);
X m_freem(m);
X }
X if (tp->t_template)
X (void) m_free(dtom(tp->t_template));
X (void) m_free(dtom(tp));
X inp->inp_ppcb = 0;
X soisdisconnected(so);
X in_pcbdetach(inp);
X tcpstat.tcps_closed++;
X return ((struct tcpcb *)0);
X}
X
Xtcp_drain()
X{
X
X}
X
X/*
X * Notify a tcp user of an asynchronous error;
X * just wake up so that he can collect error status.
X */
Xtcp_notify(inp)
X register struct inpcb *inp;
X{
X
X wakeup((caddr_t) &inp->inp_socket->so_timeo);
X sorwakeup(inp->inp_socket);
X sowwakeup(inp->inp_socket);
X}
Xtcp_ctlinput(cmd, sa)
X int cmd;
X struct sockaddr *sa;
X{
X extern u_char inetctlerrmap[];
X struct sockaddr_in *sin;
X int tcp_quench(), in_rtchange();
X
X if ((unsigned)cmd > PRC_NCMDS)
X return;
X if (sa->sa_family != AF_INET && sa->sa_family != AF_IMPLINK)
X return;
X sin = (struct sockaddr_in *)sa;
X if (sin->sin_addr.s_addr == INADDR_ANY)
X return;
X
X switch (cmd) {
X
X case PRC_QUENCH:
X in_pcbnotify(&tcb, &sin->sin_addr, 0, tcp_quench);
X break;
X
X case PRC_ROUTEDEAD:
X case PRC_REDIRECT_NET:
X case PRC_REDIRECT_HOST:
X case PRC_REDIRECT_TOSNET:
X case PRC_REDIRECT_TOSHOST:
X#if BSD>=43
X in_pcbnotify(&tcb, &sin->sin_addr, 0, in_rtchange);
X#endif
X break;
X
X default:
X if (inetctlerrmap[cmd] == 0)
X return; /* XXX */
X in_pcbnotify(&tcb, &sin->sin_addr, (int)inetctlerrmap[cmd],
X tcp_notify);
X }
X}
X
X#if BSD<43
X/* XXX fake routine */
Xtcp_abort(inp)
X struct inpcb *inp;
X{
X return;
X}
X#endif
X
X/*
X * When a source quench is received, close congestion window
X * to one segment. We will gradually open it again as we proceed.
X */
Xtcp_quench(inp)
X struct inpcb *inp;
X{
X struct tcpcb *tp = intotcpcb(inp);
X
X if (tp)
X tp->snd_cwnd = tp->t_maxseg;
X}
END-of-netinet/tcp_subr.c
echo x - netinet/tcp_timer.c
sed 's/^X//' >netinet/tcp_timer.c << 'END-of-netinet/tcp_timer.c'
X/*
X * Copyright (c) 1982, 1986 Regents of the University of California.
X * All rights reserved.
X *
X * Redistribution and use in source and binary forms are permitted
X * provided that this notice is preserved and that due credit is given
X * to the University of California at Berkeley. The name of the University
X * may not be used to endorse or promote products derived from this
X * software without specific prior written permission. This software
X * is provided ``as is'' without express or implied warranty.
X *
X * @(#)tcp_timer.c 7.11.1.2 (Berkeley) 3/16/88
X */
X
X#include "param.h"
X#include "systm.h"
X#include "mbuf.h"
X#include "socket.h"
X#include "socketvar.h"
X#include "protosw.h"
X#include "errno.h"
X
X#include "../net/if.h"
X#include "../net/route.h"
X
X#include "in.h"
X#include "in_pcb.h"
X#include "in_systm.h"
X#include "ip.h"
X#include "ip_var.h"
X#include "tcp.h"
X#include "tcp_fsm.h"
X#include "tcp_seq.h"
X#include "tcp_timer.h"
X#include "tcp_var.h"
X#include "tcpip.h"
X
Xint tcpnodelack = 0;
Xint tcp_keepidle = TCPTV_KEEP_IDLE;
Xint tcp_keepintvl = TCPTV_KEEPINTVL;
Xint tcp_maxidle;
X/*
X * Fast timeout routine for processing delayed acks
X */
Xtcp_fasttimo()
X{
X register struct inpcb *inp;
X register struct tcpcb *tp;
X int s = splnet();
X
X inp = tcb.inp_next;
X if (inp)
X for (; inp != &tcb; inp = inp->inp_next)
X if ((tp = (struct tcpcb *)inp->inp_ppcb) &&
X (tp->t_flags & TF_DELACK)) {
X tp->t_flags &= ~TF_DELACK;
X tp->t_flags |= TF_ACKNOW;
X tcpstat.tcps_delack++;
X (void) tcp_output(tp);
X }
X splx(s);
X}
X
X/*
X * Tcp protocol timeout routine called every 500 ms.
X * Updates the timers in all active tcb's and
X * causes finite state machine actions if timers expire.
X */
Xtcp_slowtimo()
X{
X register struct inpcb *ip, *ipnxt;
X register struct tcpcb *tp;
X int s = splnet();
X register int i;
X
X tcp_maxidle = TCPTV_KEEPCNT * tcp_keepintvl;
X /*
X * Search through tcb's and update active timers.
X */
X ip = tcb.inp_next;
X if (ip == 0) {
X splx(s);
X return;
X }
X for (; ip != &tcb; ip = ipnxt) {
X ipnxt = ip->inp_next;
X tp = intotcpcb(ip);
X if (tp == 0)
X continue;
X for (i = 0; i < TCPT_NTIMERS; i++) {
X if (tp->t_timer[i] && --tp->t_timer[i] == 0) {
X (void) tcp_usrreq(tp->t_inpcb->inp_socket,
X PRU_SLOWTIMO, (struct mbuf *)0,
X (struct mbuf *)i, (struct mbuf *)0);
X if (ipnxt->inp_prev != ip)
X goto tpgone;
X }
X }
X tp->t_idle++;
X if (tp->t_rtt)
X tp->t_rtt++;
Xtpgone:
X ;
X }
X tcp_iss += TCP_ISSINCR/PR_SLOWHZ; /* increment iss */
X#ifdef TCP_COMPAT_42
X if ((int)tcp_iss < 0)
X tcp_iss = 0; /* XXX */
X#endif
X splx(s);
X}
X
X/*
X * Cancel all timers for TCP tp.
X */
Xtcp_canceltimers(tp)
X struct tcpcb *tp;
X{
X register int i;
X
X for (i = 0; i < TCPT_NTIMERS; i++)
X tp->t_timer[i] = 0;
X}
X
Xint tcp_backoff[TCP_MAXRXTSHIFT + 1] =
X { 1, 2, 4, 8, 16, 32, 64, 64, 64, 64, 64, 64, 64 };
X
X/*
X * TCP timer processing.
X */
Xstruct tcpcb *
Xtcp_timers(tp, timer)
X register struct tcpcb *tp;
X int timer;
X{
X register int rexmt;
X
X switch (timer) {
X
X /*
X * 2 MSL timeout in shutdown went off. If we're closed but
X * still waiting for peer to close and connection has been idle
X * too long, or if 2MSL time is up from TIME_WAIT, delete connection
X * control block. Otherwise, check again in a bit.
X */
X case TCPT_2MSL:
X if (tp->t_state != TCPS_TIME_WAIT &&
X tp->t_idle <= tcp_maxidle)
X tp->t_timer[TCPT_2MSL] = tcp_keepintvl;
X else
X tp = tcp_close(tp);
X break;
X
X /*
X * Retransmission timer went off. Message has not
X * been acked within retransmit interval. Back off
X * to a longer retransmit interval and retransmit one segment.
X */
X case TCPT_REXMT:
X if (++tp->t_rxtshift > TCP_MAXRXTSHIFT) {
X tp->t_rxtshift = TCP_MAXRXTSHIFT;
X tcpstat.tcps_timeoutdrop++;
X tp = tcp_drop(tp, ETIMEDOUT);
X break;
X }
X tcpstat.tcps_rexmttimeo++;
X rexmt = ((tp->t_srtt >> 2) + tp->t_rttvar) >> 1;
X rexmt *= tcp_backoff[tp->t_rxtshift];
X TCPT_RANGESET(tp->t_rxtcur, rexmt, TCPTV_MIN, TCPTV_REXMTMAX);
X tp->t_timer[TCPT_REXMT] = tp->t_rxtcur;
X /*
X * If losing, let the lower level know and try for
X * a better route. Also, if we backed off this far,
X * our srtt estimate is probably bogus. Clobber it
X * so we'll take the next rtt measurement as our srtt;
X * move the current srtt into rttvar to keep the current
X * retransmit times until then.
X */
X if (tp->t_rxtshift > TCP_MAXRXTSHIFT / 4) {
X#if BSD>=43
X in_losing(tp->t_inpcb);
X#endif
X tp->t_rttvar += (tp->t_srtt >> 2);
X tp->t_srtt = 0;
X }
X tp->snd_nxt = tp->snd_una;
X /*
X * If timing a segment in this window, stop the timer.
X */
X tp->t_rtt = 0;
X /*
X * Close the congestion window down to one segment
X * (we'll open it by one segment for each ack we get).
X * Since we probably have a window's worth of unacked
X * data accumulated, this "slow start" keeps us from
X * dumping all that data as back-to-back packets (which
X * might overwhelm an intermediate gateway).
X *
X * There are two phases to the opening: Initially we
X * open by one mss on each ack. This makes the window
X * size increase exponentially with time. If the
X * window is larger than the path can handle, this
X * exponential growth results in dropped packet(s)
X * almost immediately. To get more time between
X * drops but still "push" the network to take advantage
X * of improving conditions, we switch from exponential
X * to linear window opening at some threshhold size.
X * For a threshhold, we use half the current window
X * size, truncated to a multiple of the mss.
X *
X * (the minimum cwnd that will give us exponential
X * growth is 2 mss. We don't allow the threshhold
X * to go below this.)
X */
X {
X u_int win = MIN(tp->snd_wnd, tp->snd_cwnd) / 2 / tp->t_maxseg;
X if (win < 2)
X win = 2;
X tp->snd_cwnd = tp->t_maxseg;
X tp->snd_ssthresh = win * tp->t_maxseg;
X }
X (void) tcp_output(tp);
X break;
X
X /*
X * Persistance timer into zero window.
X * Force a byte to be output, if possible.
X */
X case TCPT_PERSIST:
X tcpstat.tcps_persisttimeo++;
X tcp_setpersist(tp);
X tp->t_force = 1;
X (void) tcp_output(tp);
X tp->t_force = 0;
X break;
X
X /*
X * Keep-alive timer went off; send something
X * or drop connection if idle for too long.
X */
X case TCPT_KEEP:
X tcpstat.tcps_keeptimeo++;
X if (tp->t_state < TCPS_ESTABLISHED)
X goto dropit;
X if (tp->t_inpcb->inp_socket->so_options & SO_KEEPALIVE &&
X tp->t_state <= TCPS_CLOSE_WAIT) {
X if (tp->t_idle >= tcp_keepidle + tcp_maxidle)
X goto dropit;
X /*
X * Send a packet designed to force a response
X * if the peer is up and reachable:
X * either an ACK if the connection is still alive,
X * or an RST if the peer has closed the connection
X * due to timeout or reboot.
X * Using sequence number tp->snd_una-1
X * causes the transmitted zero-length segment
X * to lie outside the receive window;
X * by the protocol spec, this requires the
X * correspondent TCP to respond.
X */
X tcpstat.tcps_keepprobe++;
X#ifdef TCP_COMPAT_42
X /*
X * The keepalive packet must have nonzero length
X * to get a 4.2 host to respond.
X */
X tcp_respond(tp, tp->t_template,
X tp->rcv_nxt - 1, tp->snd_una - 1, 0);
X#else
X tcp_respond(tp, tp->t_template,
X tp->rcv_nxt, tp->snd_una - 1, 0);
X#endif
X tp->t_timer[TCPT_KEEP] = tcp_keepintvl;
X } else
X tp->t_timer[TCPT_KEEP] = tcp_keepidle;
X break;
X dropit:
X tcpstat.tcps_keepdrops++;
X tp = tcp_drop(tp, ETIMEDOUT);
X break;
X }
X return (tp);
X}
END-of-netinet/tcp_timer.c
echo x - netinet/tcp_timer.h
sed 's/^X//' >netinet/tcp_timer.h << 'END-of-netinet/tcp_timer.h'
X/*
X * Copyright (c) 1982, 1986 Regents of the University of California.
X * All rights reserved.
X *
X * Redistribution and use in source and binary forms are permitted
X * provided that this notice is preserved and that due credit is given
X * to the University of California at Berkeley. The name of the University
X * may not be used to endorse or promote products derived from this
X * software without specific prior written permission. This software
X * is provided ``as is'' without express or implied warranty.
X *
X * @(#)tcp_timer.h 7.5 (Berkeley) 3/16/88
X */
X
X/*
X * Definitions of the TCP timers. These timers are counted
X * down PR_SLOWHZ times a second.
X */
X#define TCPT_NTIMERS 4
X
X#define TCPT_REXMT 0 /* retransmit */
X#define TCPT_PERSIST 1 /* retransmit persistance */
X#define TCPT_KEEP 2 /* keep alive */
X#define TCPT_2MSL 3 /* 2*msl quiet time timer */
X
X/*
X * The TCPT_REXMT timer is used to force retransmissions.
X * The TCP has the TCPT_REXMT timer set whenever segments
X * have been sent for which ACKs are expected but not yet
X * received. If an ACK is received which advances tp->snd_una,
X * then the retransmit timer is cleared (if there are no more
X * outstanding segments) or reset to the base value (if there
X * are more ACKs expected). Whenever the retransmit timer goes off,
X * we retransmit one unacknowledged segment, and do a backoff
X * on the retransmit timer.
X *
X * The TCPT_PERSIST timer is used to keep window size information
X * flowing even if the window goes shut. If all previous transmissions
X * have been acknowledged (so that there are no retransmissions in progress),
X * and the window is too small to bother sending anything, then we start
X * the TCPT_PERSIST timer. When it expires, if the window is nonzero,
X * we go to transmit state. Otherwise, at intervals send a single byte
X * into the peer's window to force him to update our window information.
X * We do this at most as often as TCPT_PERSMIN time intervals,
X * but no more frequently than the current estimate of round-trip
X * packet time. The TCPT_PERSIST timer is cleared whenever we receive
X * a window update from the peer.
X *
X * The TCPT_KEEP timer is used to keep connections alive. If an
X * connection is idle (no segments received) for TCPTV_KEEP_INIT amount of time,
X * but not yet established, then we drop the connection. Once the connection
X * is established, if the connection is idle for TCPTV_KEEP_IDLE time
X * (and keepalives have been enabled on the socket), we begin to probe
X * the connection. We force the peer to send us a segment by sending:
X * <SEQ=SND.UNA-1><ACK=RCV.NXT><CTL=ACK>
X * This segment is (deliberately) outside the window, and should elicit
X * an ack segment in response from the peer. If, despite the TCPT_KEEP
X * initiated segments we cannot elicit a response from a peer in TCPT_MAXIDLE
X * amount of time probing, then we drop the connection.
X */
X
X#define TCP_TTL 30 /* default time to live for TCP segs */
X/*
X * Time constants.
X */
X#define TCPTV_MSL ( 30*PR_SLOWHZ) /* max seg lifetime (hah!) */
X#define TCPTV_SRTTBASE 0 /* base roundtrip time;
X if 0, no idea yet */
X#define TCPTV_SRTTDFLT ( 3*PR_SLOWHZ) /* assumed RTT if no info */
X
X#define TCPTV_PERSMIN ( 5*PR_SLOWHZ) /* retransmit persistance */
X#define TCPTV_PERSMAX ( 60*PR_SLOWHZ) /* maximum persist interval */
X
X#define TCPTV_KEEP_INIT ( 75*PR_SLOWHZ) /* initial connect keep alive */
X#define TCPTV_KEEP_IDLE (120*60*PR_SLOWHZ) /* dflt time before probing */
X#define TCPTV_KEEPINTVL ( 75*PR_SLOWHZ) /* default probe interval */
X#define TCPTV_KEEPCNT 8 /* max probes before drop */
X
X#define TCPTV_MIN ( 1*PR_SLOWHZ) /* minimum allowable value */
X#define TCPTV_REXMTMAX ( 64*PR_SLOWHZ) /* max allowable REXMT value */
X
X#define TCP_LINGERTIME 120 /* linger at most 2 minutes */
X
X#define TCP_MAXRXTSHIFT 12 /* maximum retransmits */
X
X#ifdef TCPTIMERS
Xchar *tcptimers[] =
X { "REXMT", "PERSIST", "KEEP", "2MSL" };
X#endif
X
X/*
X * Force a time value to be in a certain range.
X */
X#define TCPT_RANGESET(tv, value, tvmin, tvmax) { \
X (tv) = (value); \
X if ((tv) < (tvmin)) \
X (tv) = (tvmin); \
X else if ((tv) > (tvmax)) \
X (tv) = (tvmax); \
X}
X
X#ifdef KERNEL
Xextern int tcp_keepidle; /* time before keepalive probes begin */
Xextern int tcp_keepintvl; /* time between keepalive probes */
Xextern int tcp_maxidle; /* time to drop after starting probes */
Xextern int tcp_ttl; /* time to live for TCP segs */
Xextern int tcp_backoff[];
X#endif
END-of-netinet/tcp_timer.h
echo x - netinet/tcp_usrreq.c
sed 's/^X//' >netinet/tcp_usrreq.c << 'END-of-netinet/tcp_usrreq.c'
X/*
X * Copyright (c) 1982, 1986 Regents of the University of California.
X * All rights reserved.
X *
X * Redistribution and use in source and binary forms are permitted
X * provided that this notice is preserved and that due credit is given
X * to the University of California at Berkeley. The name of the University
X * may not be used to endorse or promote products derived from this
X * software without specific prior written permission. This software
X * is provided ``as is'' without express or implied warranty.
X *
X * @(#)tcp_usrreq.c 7.7.1.2 (Berkeley) 3/16/88
X */
X
X#include "param.h"
X#include "systm.h"
X#include "mbuf.h"
X#include "socket.h"
X#include "socketvar.h"
X#include "protosw.h"
X#include "errno.h"
X#include "stat.h"
X
X#include "../net/if.h"
X#include "../net/route.h"
X
X#include "in.h"
X#include "in_pcb.h"
X#include "in_systm.h"
X#include "ip.h"
X#include "ip_var.h"
X#include "tcp.h"
X#include "tcp_fsm.h"
X#include "tcp_seq.h"
X#include "tcp_timer.h"
X#include "tcp_var.h"
X#include "tcpip.h"
X#include "tcp_debug.h"
X
X/*
X * TCP protocol interface to socket abstraction.
X */
Xextern char *tcpstates[];
Xstruct tcpcb *tcp_newtcpcb();
X
X/*
X * Process a TCP user request for TCP tb. If this is a send request
X * then m is the mbuf chain of send data. If this is a timer expiration
X * (called from the software clock routine), then timertype tells which timer.
X */
X/*ARGSUSED*/
Xtcp_usrreq(so, req, m, nam, rights)
X struct socket *so;
X int req;
X struct mbuf *m, *nam, *rights;
X{
X register struct inpcb *inp;
X register struct tcpcb *tp;
X int s;
X int error = 0;
X int ostate;
X
X#if BSD>=43
X if (req == PRU_CONTROL)
X return (in_control(so, (int)m, (caddr_t)nam,
X (struct ifnet *)rights));
X#else
X if (req == PRU_CONTROL)
X return(EOPNOTSUPP);
X#endif
X if (rights && rights->m_len)
X return (EINVAL);
X
X s = splnet();
X inp = sotoinpcb(so);
X /*
X * When a TCP is attached to a socket, then there will be
X * a (struct inpcb) pointed at by the socket, and this
X * structure will point at a subsidary (struct tcpcb).
X */
X if (inp == 0 && req != PRU_ATTACH) {
X splx(s);
X return (EINVAL); /* XXX */
X }
X if (inp) {
X tp = intotcpcb(inp);
X /* WHAT IF TP IS 0? */
X#ifdef KPROF
X tcp_acounts[tp->t_state][req]++;
X#endif
X ostate = tp->t_state;
X } else
X ostate = 0;
X switch (req) {
X
X /*
X * TCP attaches to socket via PRU_ATTACH, reserving space,
X * and an internet control block.
X */
X case PRU_ATTACH:
X if (inp) {
X error = EISCONN;
X break;
X }
X error = tcp_attach(so);
X if (error)
X break;
X if ((so->so_options & SO_LINGER) && so->so_linger == 0)
X so->so_linger = TCP_LINGERTIME;
X tp = sototcpcb(so);
X break;
X
X /*
X * PRU_DETACH detaches the TCP protocol from the socket.
X * If the protocol state is non-embryonic, then can't
X * do this directly: have to initiate a PRU_DISCONNECT,
X * which may finish later; embryonic TCB's can just
X * be discarded here.
X */
X case PRU_DETACH:
X if (tp->t_state > TCPS_LISTEN)
X tp = tcp_disconnect(tp);
X else
X tp = tcp_close(tp);
X break;
X
X /*
X * Give the socket an address.
X */
X case PRU_BIND:
X error = in_pcbbind(inp, nam);
X if (error)
X break;
X break;
X
X /*
X * Prepare to accept connections.
X */
X case PRU_LISTEN:
X if (inp->inp_lport == 0)
X error = in_pcbbind(inp, (struct mbuf *)0);
X if (error == 0)
X tp->t_state = TCPS_LISTEN;
X break;
X
X /*
X * Initiate connection to peer.
X * Create a template for use in transmissions on this connection.
X * Enter SYN_SENT state, and mark socket as connecting.
X * Start keep-alive timer, and seed output sequence space.
X * Send initial segment on connection.
X */
X case PRU_CONNECT:
X if (inp->inp_lport == 0) {
X error = in_pcbbind(inp, (struct mbuf *)0);
X if (error)
X break;
X }
X error = in_pcbconnect(inp, nam);
X if (error)
X break;
X tp->t_template = tcp_template(tp);
X if (tp->t_template == 0) {
X in_pcbdisconnect(inp);
X error = ENOBUFS;
X break;
X }
X soisconnecting(so);
X tcpstat.tcps_connattempt++;
X tp->t_state = TCPS_SYN_SENT;
X tp->t_timer[TCPT_KEEP] = TCPTV_KEEP_INIT;
X tp->iss = tcp_iss; tcp_iss += TCP_ISSINCR/2;
X tcp_sendseqinit(tp);
X error = tcp_output(tp);
X break;
X
X /*
X * Create a TCP connection between two sockets.
X */
X case PRU_CONNECT2:
X error = EOPNOTSUPP;
X break;
X
X /*
X * Initiate disconnect from peer.
X * If connection never passed embryonic stage, just drop;
X * else if don't need to let data drain, then can just drop anyways,
X * else have to begin TCP shutdown process: mark socket disconnecting,
X * drain unread data, state switch to reflect user close, and
X * send segment (e.g. FIN) to peer. Socket will be really disconnected
X * when peer sends FIN and acks ours.
X *
X * SHOULD IMPLEMENT LATER PRU_CONNECT VIA REALLOC TCPCB.
X */
X case PRU_DISCONNECT:
X tp = tcp_disconnect(tp);
X break;
X
X /*
X * Accept a connection. Essentially all the work is
X * done at higher levels; just return the address
X * of the peer, storing through addr.
X */
X case PRU_ACCEPT: {
X struct sockaddr_in *sin = mtod(nam, struct sockaddr_in *);
X
X nam->m_len = sizeof (struct sockaddr_in);
X sin->sin_family = AF_INET;
X sin->sin_port = inp->inp_fport;
X sin->sin_addr = inp->inp_faddr;
X break;
X }
X
X /*
X * Mark the connection as being incapable of further output.
X */
X case PRU_SHUTDOWN:
X socantsendmore(so);
X tp = tcp_usrclosed(tp);
X if (tp)
X error = tcp_output(tp);
X break;
X
X /*
X * After a receive, possibly send window update to peer.
X */
X case PRU_RCVD:
X (void) tcp_output(tp);
X break;
X
X /*
X * Do a send by putting data in output queue and updating urgent
X * marker if URG set. Possibly send more data.
X */
X case PRU_SEND:
X sbappend(&so->so_snd, m);
X error = tcp_output(tp);
X break;
X
X /*
X * Abort the TCP.
X */
X case PRU_ABORT:
X tp = tcp_drop(tp, ECONNABORTED);
X break;
X
X case PRU_SENSE:
X ((struct stat *) m)->st_blksize = so->so_snd.sb_hiwat;
X (void) splx(s);
X return (0);
X
X case PRU_RCVOOB:
X if ((so->so_oobmark == 0 &&
X (so->so_state & SS_RCVATMARK) == 0) ||
X#ifdef SO_OOBINLINE
X so->so_options & SO_OOBINLINE ||
X#endif
X tp->t_oobflags & TCPOOB_HADDATA) {
X error = EINVAL;
X break;
X }
X if ((tp->t_oobflags & TCPOOB_HAVEDATA) == 0) {
X error = EWOULDBLOCK;
X break;
X }
X m->m_len = 1;
X *mtod(m, caddr_t) = tp->t_iobc;
X if (((int)nam & MSG_PEEK) == 0)
X tp->t_oobflags ^= (TCPOOB_HAVEDATA | TCPOOB_HADDATA);
X break;
X
X case PRU_SENDOOB:
X if (sbspace(&so->so_snd) < -512) {
X m_freem(m);
X error = ENOBUFS;
X break;
X }
X /*
X * According to RFC961 (Assigned Protocols),
X * the urgent pointer points to the last octet
X * of urgent data. We continue, however,
X * to consider it to indicate the first octet
X * of data past the urgent section.
X * Otherwise, snd_up should be one lower.
X */
X sbappend(&so->so_snd, m);
X tp->snd_up = tp->snd_una + so->so_snd.sb_cc;
X tp->t_force = 1;
X error = tcp_output(tp);
X tp->t_force = 0;
X break;
X
X case PRU_SOCKADDR:
X in_setsockaddr(inp, nam);
X break;
X
X case PRU_PEERADDR:
X in_setpeeraddr(inp, nam);
X break;
X
X /*
X * TCP slow timer went off; going through this
X * routine for tracing's sake.
X */
X case PRU_SLOWTIMO:
X tp = tcp_timers(tp, (int)nam);
X req |= (int)nam << 8; /* for debug's sake */
X break;
X
X default:
X panic("tcp_usrreq");
X }
X if (tp && (so->so_options & SO_DEBUG))
X tcp_trace(TA_USER, ostate, tp, (struct tcpiphdr *)0, req);
X splx(s);
X return (error);
X}
X
X#if BSD>=43
Xtcp_ctloutput(op, so, level, optname, mp)
X int op;
X struct socket *so;
X int level, optname;
X struct mbuf **mp;
X{
X int error = 0;
X struct inpcb *inp = sotoinpcb(so);
X register struct tcpcb *tp = intotcpcb(inp);
X register struct mbuf *m;
X
X if (level != IPPROTO_TCP)
X return (ip_ctloutput(op, so, level, optname, mp));
X
X switch (op) {
X
X case PRCO_SETOPT:
X m = *mp;
X switch (optname) {
X
X case TCP_NODELAY:
X if (m == NULL || m->m_len < sizeof (int))
X error = EINVAL;
X else if (*mtod(m, int *))
X tp->t_flags |= TF_NODELAY;
X else
X tp->t_flags &= ~TF_NODELAY;
X break;
X
X case TCP_MAXSEG: /* not yet */
X default:
X error = EINVAL;
X break;
X }
X if (m)
X (void) m_free(m);
X break;
X
X case PRCO_GETOPT:
X *mp = m = m_get(M_WAIT, MT_SOOPTS);
X m->m_len = sizeof(int);
X
X switch (optname) {
X case TCP_NODELAY:
X *mtod(m, int *) = tp->t_flags & TF_NODELAY;
X break;
X case TCP_MAXSEG:
X *mtod(m, int *) = tp->t_maxseg;
X break;
X default:
X error = EINVAL;
X break;
X }
X break;
X }
X return (error);
X}
X#endif
X
Xint tcp_sendspace = 1024*4;
Xint tcp_recvspace = 1024*4;
X/*
X * Attach TCP protocol to socket, allocating
X * internet protocol control block, tcp control block,
X * bufer space, and entering LISTEN state if to accept connections.
X */
Xtcp_attach(so)
X struct socket *so;
X{
X register struct tcpcb *tp;
X struct inpcb *inp;
X int error;
X
X error = soreserve(so, tcp_sendspace, tcp_recvspace);
X if (error)
X return (error);
X error = in_pcballoc(so, &tcb);
X if (error)
X return (error);
X inp = sotoinpcb(so);
X tp = tcp_newtcpcb(inp);
X if (tp == 0) {
X int nofd = so->so_state & SS_NOFDREF; /* XXX */
X
X so->so_state &= ~SS_NOFDREF; /* don't free the socket yet */
X in_pcbdetach(inp);
X so->so_state |= nofd;
X return (ENOBUFS);
X }
X tp->t_state = TCPS_CLOSED;
X return (0);
X}
X
X/*
X * Initiate (or continue) disconnect.
X * If embryonic state, just send reset (once).
X * If in ``let data drain'' option and linger null, just drop.
X * Otherwise (hard), mark socket disconnecting and drop
X * current input data; switch states based on user close, and
X * send segment to peer (with FIN).
X */
Xstruct tcpcb *
Xtcp_disconnect(tp)
X register struct tcpcb *tp;
X{
X struct socket *so = tp->t_inpcb->inp_socket;
X
X if (tp->t_state < TCPS_ESTABLISHED)
X tp = tcp_close(tp);
X else if ((so->so_options & SO_LINGER) && so->so_linger == 0)
X tp = tcp_drop(tp, 0);
X else {
X soisdisconnecting(so);
X sbflush(&so->so_rcv);
X tp = tcp_usrclosed(tp);
X if (tp)
X (void) tcp_output(tp);
X }
X return (tp);
X}
X
X/*
X * User issued close, and wish to trail through shutdown states:
X * if never received SYN, just forget it. If got a SYN from peer,
X * but haven't sent FIN, then go to FIN_WAIT_1 state to send peer a FIN.
X * If already got a FIN from peer, then almost done; go to LAST_ACK
X * state. In all other cases, have already sent FIN to peer (e.g.
X * after PRU_SHUTDOWN), and just have to play tedious game waiting
X * for peer to send FIN or not respond to keep-alives, etc.
X * We can let the user exit from the close as soon as the FIN is acked.
X */
Xstruct tcpcb *
Xtcp_usrclosed(tp)
X register struct tcpcb *tp;
X{
X
X switch (tp->t_state) {
X
X case TCPS_CLOSED:
X case TCPS_LISTEN:
X case TCPS_SYN_SENT:
X tp->t_state = TCPS_CLOSED;
X tp = tcp_close(tp);
X break;
X
X case TCPS_SYN_RECEIVED:
X case TCPS_ESTABLISHED:
X tp->t_state = TCPS_FIN_WAIT_1;
X break;
X
X case TCPS_CLOSE_WAIT:
X tp->t_state = TCPS_LAST_ACK;
X break;
X }
X if (tp && tp->t_state >= TCPS_FIN_WAIT_2)
X soisdisconnected(tp->t_inpcb->inp_socket);
X return (tp);
X}
END-of-netinet/tcp_usrreq.c
echo x - netinet/tcp_var.h
sed 's/^X//' >netinet/tcp_var.h << 'END-of-netinet/tcp_var.h'
X/*
X * Copyright (c) 1982, 1986 Regents of the University of California.
X * All rights reserved.
X *
X * Redistribution and use in source and binary forms are permitted
X * provided that this notice is preserved and that due credit is given
X * to the University of California at Berkeley. The name of the University
X * may not be used to endorse or promote products derived from this
X * software without specific prior written permission. This software
X * is provided ``as is'' without express or implied warranty.
X *
X * @(#)tcp_var.h 7.7 (Berkeley) 2/27/88
X */
X
X/*
X * TCP configuration: This is a half-assed attempt to make TCP
X * self-configure for a few varieties of 4.2 and 4.3-based unixes.
X * If you don't have a) a 4.3bsd vax or b) a 3.x Sun (x<6), check
X * this carefully (it's probably not right). Please send me mail
X * if you run into configuration problems.
X * - Van Jacobson (van@lbl-csam.arpa)
X */
X
X#ifndef BSD
X#define BSD 42 /* if we're not 4.3, pretend we're 4.2 */
X#define OLDSTAT /* set if we have to use old netstat binaries */
X#endif
X
X/* #define OLDSTAT /* set if we have to use old netstat binaries */
X
X#if sun || BSD < 43
X#define TCP_COMPAT_42 /* set if we have to interop w/4.2 systems */
X#endif
X
X#ifndef SB_MAX
X#ifdef SB_MAXCOUNT
X#define SB_MAX SB_MAXCOUNT /* Sun has to be a little bit different... */
X#else
X#define SB_MAX 32767 /* XXX */
X#endif SB_MAXCOUNT
X#endif SB_MAX
X
X#ifndef IP_MAXPACKET
X#define IP_MAXPACKET 65535 /* maximum packet size */
X#endif
X
X/*
X * Bill Nowicki pointed out that the page size (CLBYTES) has
X * nothing to do with the mbuf cluster size. So, we followed
X * Sun's lead and made the new define MCLBYTES stand for the mbuf
X * cluster size. The following define makes up backwards compatible
X * with 4.3 and 4.2. If CLBYTES is >1024 on your machine, check
X * this against the mbuf cluster definitions in /usr/include/sys/mbuf.h.
X */
X#ifndef MCLBYTES
X#define MCLBYTES CLBYTES /* XXX */
X#endif
X
X/*
X * The routine in_localaddr is broken in Sun's 3.4. We redefine ours
X * (in tcp_input.c) so we use can it but won't have a name conflict.
X */
X#ifdef sun
X#define in_localaddr tcp_in_localaddr
X#endif
X
X/* --------------- end of TCP config ---------------- */
X
X/*
X * Kernel variables for tcp.
X */
X
X/*
X * Tcp control block, one per tcp; fields:
X */
Xstruct tcpcb {
X struct tcpiphdr *seg_next; /* sequencing queue */
X struct tcpiphdr *seg_prev;
X short t_state; /* state of this connection */
X short t_timer[TCPT_NTIMERS]; /* tcp timers */
X short t_rxtshift; /* log(2) of rexmt exp. backoff */
X short t_rxtcur; /* current retransmit value */
X short t_dupacks; /* consecutive dup acks recd */
X u_short t_maxseg; /* maximum segment size */
X char t_force; /* 1 if forcing out a byte */
X u_char t_flags;
X#define TF_ACKNOW 0x01 /* ack peer immediately */
X#define TF_DELACK 0x02 /* ack, but try to delay it */
X#define TF_NODELAY 0x04 /* don't delay packets to coalesce */
X#define TF_NOOPT 0x08 /* don't use tcp options */
X#define TF_SENTFIN 0x10 /* have sent FIN */
X struct tcpiphdr *t_template; /* skeletal packet for transmit */
X struct inpcb *t_inpcb; /* back pointer to internet pcb */
X/*
X * The following fields are used as in the protocol specification.
X * See RFC783, Dec. 1981, page 21.
X */
X/* send sequence variables */
X tcp_seq snd_una; /* send unacknowledged */
X tcp_seq snd_nxt; /* send next */
X tcp_seq snd_up; /* send urgent pointer */
X tcp_seq snd_wl1; /* window update seg seq number */
X tcp_seq snd_wl2; /* window update seg ack number */
X tcp_seq iss; /* initial send sequence number */
X u_short snd_wnd; /* send window */
X/* receive sequence variables */
X u_short rcv_wnd; /* receive window */
X tcp_seq rcv_nxt; /* receive next */
X tcp_seq rcv_up; /* receive urgent pointer */
X tcp_seq irs; /* initial receive sequence number */
X/*
X * Additional variables for this implementation.
X */
X/* receive variables */
X tcp_seq rcv_adv; /* advertised window */
X/* retransmit variables */
X tcp_seq snd_max; /* highest sequence number sent
X * used to recognize retransmits
X */
X/* congestion control (for slow start, source quench, retransmit after loss) */
X u_short snd_cwnd; /* congestion-controlled window */
X u_short snd_ssthresh; /* snd_cwnd size threshhold for
X * for slow start exponential to
X * linear switch */
X/*
X * transmit timing stuff.
X * srtt and rttvar are stored as fixed point; for convenience in smoothing,
X * srtt has 3 bits to the right of the binary point, rttvar has 2.
X * "Variance" is actually smoothed difference.
X */
X short t_idle; /* inactivity time */
X short t_rtt; /* round trip time */
X tcp_seq t_rtseq; /* sequence number being timed */
X short t_srtt; /* smoothed round-trip time */
X short t_rttvar; /* variance in round-trip time */
X u_short max_rcvd; /* most peer has sent into window */
X u_short max_sndwnd; /* largest window peer has offered */
X/* out-of-band data */
X char t_oobflags; /* have some */
X char t_iobc; /* input character */
X#define TCPOOB_HAVEDATA 0x01
X#define TCPOOB_HADDATA 0x02
X};
X
X#define intotcpcb(ip) ((struct tcpcb *)(ip)->inp_ppcb)
X#define sototcpcb(so) (intotcpcb(sotoinpcb(so)))
X
X/*
X * TCP statistics.
X * Many of these should be kept per connection,
X * but that's inconvenient at the moment.
X */
Xstruct tcpstat {
X#ifdef OLDSTAT
X /*
X * Declare statistics the same as in 4.3
X * at the start of tcpstat (same size and
X * position) for netstat.
X */
X int tcps_rcvbadsum;
X int tcps_rcvbadoff;
X int tcps_rcvshort;
X int tcps_badsegs;
X int tcps_unack;
X#define tcps_badsum tcps_rcvbadsum
X#define tcps_badoff tcps_rcvbadoff
X#define tcps_hdrops tcps_rcvshort
X
X#endif OLDSTAT
X u_long tcps_connattempt; /* connections initiated */
X u_long tcps_accepts; /* connections accepted */
X u_long tcps_connects; /* connections established */
X u_long tcps_drops; /* connections dropped */
X u_long tcps_conndrops; /* embryonic connections dropped */
X u_long tcps_closed; /* conn. closed (includes drops) */
X u_long tcps_segstimed; /* segs where we tried to get rtt */
X u_long tcps_rttupdated; /* times we succeeded */
X u_long tcps_delack; /* delayed acks sent */
X u_long tcps_timeoutdrop; /* conn. dropped in rxmt timeout */
X u_long tcps_rexmttimeo; /* retransmit timeouts */
X u_long tcps_persisttimeo; /* persist timeouts */
X u_long tcps_keeptimeo; /* keepalive timeouts */
X u_long tcps_keepprobe; /* keepalive probes sent */
X u_long tcps_keepdrops; /* connections dropped in keepalive */
X
X u_long tcps_sndtotal; /* total packets sent */
X u_long tcps_sndpack; /* data packets sent */
X u_long tcps_sndbyte; /* data bytes sent */
X u_long tcps_sndrexmitpack; /* data packets retransmitted */
X u_long tcps_sndrexmitbyte; /* data bytes retransmitted */
X u_long tcps_sndacks; /* ack-only packets sent */
X u_long tcps_sndprobe; /* window probes sent */
X u_long tcps_sndurg; /* packets sent with URG only */
X u_long tcps_sndwinup; /* window update-only packets sent */
X u_long tcps_sndctrl; /* control (SYN|FIN|RST) packets sent */
X
X u_long tcps_rcvtotal; /* total packets received */
X u_long tcps_rcvpack; /* packets received in sequence */
X u_long tcps_rcvbyte; /* bytes received in sequence */
X#ifndef OLDSTAT
X u_long tcps_rcvbadsum; /* packets received with ccksum errs */
X u_long tcps_rcvbadoff; /* packets received with bad offset */
X u_long tcps_rcvshort; /* packets received too short */
X#endif
X u_long tcps_rcvduppack; /* duplicate-only packets received */
X u_long tcps_rcvdupbyte; /* duplicate-only bytes received */
X u_long tcps_rcvpartduppack; /* packets with some duplicate data */
X u_long tcps_rcvpartdupbyte; /* dup. bytes in part-dup. packets */
X u_long tcps_rcvoopack; /* out-of-order packets received */
X u_long tcps_rcvoobyte; /* out-of-order bytes received */
X u_long tcps_rcvpackafterwin; /* packets with data after window */
X u_long tcps_rcvbyteafterwin; /* bytes rcvd after window */
X u_long tcps_rcvafterclose; /* packets rcvd after "close" */
X u_long tcps_rcvwinprobe; /* rcvd window probe packets */
X u_long tcps_rcvdupack; /* rcvd duplicate acks */
X u_long tcps_rcvacktoomuch; /* rcvd acks for unsent data */
X u_long tcps_rcvackpack; /* rcvd ack packets */
X u_long tcps_rcvackbyte; /* bytes acked by rcvd acks */
X u_long tcps_rcvwinupd; /* rcvd window update packets */
X};
X
X#ifdef KERNEL
Xstruct inpcb tcb; /* head of queue of active tcpcb's */
Xstruct tcpstat tcpstat; /* tcp statistics */
Xstruct tcpiphdr *tcp_template();
Xstruct tcpcb *tcp_close(), *tcp_drop();
Xstruct tcpcb *tcp_timers(), *tcp_disconnect(), *tcp_usrclosed();
X#endif
END-of-netinet/tcp_var.h
echo x - netinet/tcpip.h
sed 's/^X//' >netinet/tcpip.h << 'END-of-netinet/tcpip.h'
X/*
X * Copyright (c) 1982, 1986 Regents of the University of California.
X * All rights reserved.
X *
X * Redistribution and use in source and binary forms are permitted
X * provided that this notice is preserved and that due credit is given
X * to the University of California at Berkeley. The name of the University
X * may not be used to endorse or promote products derived from this
X * software without specific prior written permission. This software
X * is provided ``as is'' without express or implied warranty.
X *
X * @(#)tcpip.h 7.2 (Berkeley) 12/7/87
X */
X
X/*
X * Tcp+ip header, after ip options removed.
X */
Xstruct tcpiphdr {
X struct ipovly ti_i; /* overlaid ip structure */
X struct tcphdr ti_t; /* tcp header */
X};
X#define ti_next ti_i.ih_next
X#define ti_prev ti_i.ih_prev
X#define ti_x1 ti_i.ih_x1
X#define ti_pr ti_i.ih_pr
X#define ti_len ti_i.ih_len
X#define ti_src ti_i.ih_src
X#define ti_dst ti_i.ih_dst
X#define ti_sport ti_t.th_sport
X#define ti_dport ti_t.th_dport
X#define ti_seq ti_t.th_seq
X#define ti_ack ti_t.th_ack
X#define ti_x2 ti_t.th_x2
X#define ti_off ti_t.th_off
X#define ti_flags ti_t.th_flags
X#define ti_win ti_t.th_win
X#define ti_sum ti_t.th_sum
X#define ti_urp ti_t.th_urp
END-of-netinet/tcpip.h
exit