The Tcpdump Group git mirrors - tcpdump/blob - linux-include/netinet/tcp_var.h

   1 /*
   2  * Copyright (c) 1982, 1986, 1993, 1994, 1995
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by the University of
  16  *      California, Berkeley and its contributors.
  17  * 4. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  *
  33  *      @(#)tcp_var.h   8.4 (Berkeley) 5/24/95
  34  */
  35
  36 /*
  37  * Kernel variables for tcp.
  38  */
  39
  40 /*
  41  * Tcp control block, one per tcp; fields:
  42  */
  43 struct tcpcb {
  44         struct  tcpiphdr *seg_next;     /* sequencing queue */
  45         struct  tcpiphdr *seg_prev;
  46         short   t_state;                /* state of this connection */
  47         short   t_timer[TCPT_NTIMERS];  /* tcp timers */
  48         short   t_rxtshift;             /* log(2) of rexmt exp. backoff */
  49         short   t_rxtcur;               /* current retransmit value */
  50         short   t_dupacks;              /* consecutive dup acks recd */
  51         u_short t_maxseg;               /* maximum segment size */
  52         char    t_force;                /* 1 if forcing out a byte */
  53         u_short t_flags;
  54 #define TF_ACKNOW       0x0001          /* ack peer immediately */
  55 #define TF_DELACK       0x0002          /* ack, but try to delay it */
  56 #define TF_NODELAY      0x0004          /* don't delay packets to coalesce */
  57 #define TF_NOOPT        0x0008          /* don't use tcp options */
  58 #define TF_SENTFIN      0x0010          /* have sent FIN */
  59 #define TF_REQ_SCALE    0x0020          /* have/will request window scaling */
  60 #define TF_RCVD_SCALE   0x0040          /* other side has requested scaling */
  61 #define TF_REQ_TSTMP    0x0080          /* have/will request timestamps */
  62 #define TF_RCVD_TSTMP   0x0100          /* a timestamp was received in SYN */
  63 #define TF_SACK_PERMIT  0x0200          /* other side said I could SACK */
  64
  65         struct  tcpiphdr *t_template;   /* skeletal packet for transmit */
  66         struct  inpcb *t_inpcb;         /* back pointer to internet pcb */
  67 /*
  68  * The following fields are used as in the protocol specification.
  69  * See RFC783, Dec. 1981, page 21.
  70  */
  71 /* send sequence variables */
  72         tcp_seq snd_una;                /* send unacknowledged */
  73         tcp_seq snd_nxt;                /* send next */
  74         tcp_seq snd_up;                 /* send urgent pointer */
  75         tcp_seq snd_wl1;                /* window update seg seq number */
  76         tcp_seq snd_wl2;                /* window update seg ack number */
  77         tcp_seq iss;                    /* initial send sequence number */
  78         n_long  snd_wnd;                /* send window */
  79 /* receive sequence variables */
  80         n_long  rcv_wnd;                /* receive window */
  81         tcp_seq rcv_nxt;                /* receive next */
  82         tcp_seq rcv_up;                 /* receive urgent pointer */
  83         tcp_seq irs;                    /* initial receive sequence number */
  84 /*
  85  * Additional variables for this implementation.
  86  */
  87 /* receive variables */
  88         tcp_seq rcv_adv;                /* advertised window */
  89 /* retransmit variables */
  90         tcp_seq snd_max;                /* highest sequence number sent;
  91                                          * used to recognize retransmits
  92                                          */
  93 /* congestion control (for slow start, source quench, retransmit after loss) */
  94         n_long  snd_cwnd;               /* congestion-controlled window */
  95         n_long  snd_ssthresh;           /* snd_cwnd size threshhold for
  96                                          * for slow start exponential to
  97                                          * linear switch
  98                                          */
  99 /*
 100  * transmit timing stuff.  See below for scale of srtt and rttvar.
 101  * "Variance" is actually smoothed difference.
 102  */
 103         u_short t_idle;                 /* inactivity time */
 104         short   t_rtt;                  /* round trip time */
 105         tcp_seq t_rtseq;                /* sequence number being timed */
 106         short   t_srtt;                 /* smoothed round-trip time */
 107         short   t_rttvar;               /* variance in round-trip time */
 108         u_short t_rttmin;               /* minimum rtt allowed */
 109         n_long  max_sndwnd;             /* largest window peer has offered */
 110
 111 /* out-of-band data */
 112         char    t_oobflags;             /* have some */
 113         char    t_iobc;                 /* input character */
 114 #define TCPOOB_HAVEDATA 0x01
 115 #define TCPOOB_HADDATA  0x02
 116         short   t_softerror;            /* possible error not yet reported */
 117
 118 /* RFC 1323 variables */
 119         u_char  snd_scale;              /* window scaling for send window */
 120         u_char  rcv_scale;              /* window scaling for recv window */
 121         u_char  request_r_scale;        /* pending window scaling */
 122         u_char  requested_s_scale;
 123         n_long  ts_recent;              /* timestamp echo data */
 124         n_long  ts_recent_age;          /* when last updated */
 125         tcp_seq last_ack_sent;
 126
 127 /* TUBA stuff */
 128         caddr_t t_tuba_pcb;             /* next level down pcb for TCP over z */
 129 };
 130
 131 #define intotcpcb(ip)   ((struct tcpcb *)(ip)->inp_ppcb)
 132 #define sototcpcb(so)   (intotcpcb(sotoinpcb(so)))
 133
 134 /*
 135  * The smoothed round-trip time and estimated variance
 136  * are stored as fixed point numbers scaled by the values below.
 137  * For convenience, these scales are also used in smoothing the average
 138  * (smoothed = (1/scale)sample + ((scale-1)/scale)smoothed).
 139  * With these scales, srtt has 3 bits to the right of the binary point,
 140  * and thus an "ALPHA" of 0.875.  rttvar has 2 bits to the right of the
 141  * binary point, and is smoothed with an ALPHA of 0.75.
 142  */
 143 #define TCP_RTT_SCALE           8       /* multiplier for srtt; 3 bits frac. */
 144 #define TCP_RTT_SHIFT           3       /* shift for srtt; 3 bits frac. */
 145 #define TCP_RTTVAR_SCALE        4       /* multiplier for rttvar; 2 bits */
 146 #define TCP_RTTVAR_SHIFT        2       /* multiplier for rttvar; 2 bits */
 147
 148 /*
 149  * The initial retransmission should happen at rtt + 4 * rttvar.
 150  * Because of the way we do the smoothing, srtt and rttvar
 151  * will each average +1/2 tick of bias.  When we compute
 152  * the retransmit timer, we want 1/2 tick of rounding and
 153  * 1 extra tick because of +-1/2 tick uncertainty in the
 154  * firing of the timer.  The bias will give us exactly the
 155  * 1.5 tick we need.  But, because the bias is
 156  * statistical, we have to test that we don't drop below
 157  * the minimum feasible timer (which is 2 ticks).
 158  * This macro assumes that the value of TCP_RTTVAR_SCALE
 159  * is the same as the multiplier for rttvar.
 160  */
 161 #define TCP_REXMTVAL(tp) \
 162         (((tp)->t_srtt >> TCP_RTT_SHIFT) + (tp)->t_rttvar)
 163
 164 /* XXX
 165  * We want to avoid doing m_pullup on incoming packets but that
 166  * means avoiding dtom on the tcp reassembly code.  That in turn means
 167  * keeping an mbuf pointer in the reassembly queue (since we might
 168  * have a cluster).  As a quick hack, the source & destination
 169  * port numbers (which are no longer needed once we've located the
 170  * tcpcb) are overlayed with an mbuf pointer.
 171  */
 172 #define REASS_MBUF(ti) (*(struct mbuf **)&((ti)->ti_t))
 173
 174 /*
 175  * TCP statistics.
 176  * Many of these should be kept per connection,
 177  * but that's inconvenient at the moment.
 178  */
 179 struct  tcpstat {
 180         n_long  tcps_connattempt;       /* connections initiated */
 181         n_long  tcps_accepts;           /* connections accepted */
 182         n_long  tcps_connects;          /* connections established */
 183         n_long  tcps_drops;             /* connections dropped */
 184         n_long  tcps_conndrops;         /* embryonic connections dropped */
 185         n_long  tcps_closed;            /* conn. closed (includes drops) */
 186         n_long  tcps_segstimed;         /* segs where we tried to get rtt */
 187         n_long  tcps_rttupdated;        /* times we succeeded */
 188         n_long  tcps_delack;            /* delayed acks sent */
 189         n_long  tcps_timeoutdrop;       /* conn. dropped in rxmt timeout */
 190         n_long  tcps_rexmttimeo;        /* retransmit timeouts */
 191         n_long  tcps_persisttimeo;      /* persist timeouts */
 192         n_long  tcps_keeptimeo;         /* keepalive timeouts */
 193         n_long  tcps_keepprobe;         /* keepalive probes sent */
 194         n_long  tcps_keepdrops;         /* connections dropped in keepalive */
 195
 196         n_long  tcps_sndtotal;          /* total packets sent */
 197         n_long  tcps_sndpack;           /* data packets sent */
 198         n_long  tcps_sndbyte;           /* data bytes sent */
 199         n_long  tcps_sndrexmitpack;     /* data packets retransmitted */
 200         n_long  tcps_sndrexmitbyte;     /* data bytes retransmitted */
 201         n_long  tcps_sndacks;           /* ack-only packets sent */
 202         n_long  tcps_sndprobe;          /* window probes sent */
 203         n_long  tcps_sndurg;            /* packets sent with URG only */
 204         n_long  tcps_sndwinup;          /* window update-only packets sent */
 205         n_long  tcps_sndctrl;           /* control (SYN|FIN|RST) packets sent */
 206
 207         n_long  tcps_rcvtotal;          /* total packets received */
 208         n_long  tcps_rcvpack;           /* packets received in sequence */
 209         n_long  tcps_rcvbyte;           /* bytes received in sequence */
 210         n_long  tcps_rcvbadsum;         /* packets received with ccksum errs */
 211         n_long  tcps_rcvbadoff;         /* packets received with bad offset */
 212         n_long  tcps_rcvshort;          /* packets received too short */
 213         n_long  tcps_rcvduppack;        /* duplicate-only packets received */
 214         n_long  tcps_rcvdupbyte;        /* duplicate-only bytes received */
 215         n_long  tcps_rcvpartduppack;    /* packets with some duplicate data */
 216         n_long  tcps_rcvpartdupbyte;    /* dup. bytes in part-dup. packets */
 217         n_long  tcps_rcvoopack;         /* out-of-order packets received */
 218         n_long  tcps_rcvoobyte;         /* out-of-order bytes received */
 219         n_long  tcps_rcvpackafterwin;   /* packets with data after window */
 220         n_long  tcps_rcvbyteafterwin;   /* bytes rcvd after window */
 221         n_long  tcps_rcvafterclose;     /* packets rcvd after "close" */
 222         n_long  tcps_rcvwinprobe;       /* rcvd window probe packets */
 223         n_long  tcps_rcvdupack;         /* rcvd duplicate acks */
 224         n_long  tcps_rcvacktoomuch;     /* rcvd acks for unsent data */
 225         n_long  tcps_rcvackpack;        /* rcvd ack packets */
 226         n_long  tcps_rcvackbyte;        /* bytes acked by rcvd acks */
 227         n_long  tcps_rcvwinupd;         /* rcvd window update packets */
 228         n_long  tcps_pawsdrop;          /* segments dropped due to PAWS */
 229         n_long  tcps_predack;           /* times hdr predict ok for acks */
 230         n_long  tcps_preddat;           /* times hdr predict ok for data pkts */
 231         n_long  tcps_pcbcachemiss;
 232         n_long  tcps_persistdrop;       /* timeout in persist state */
 233         n_long  tcps_badsyn;            /* bogus SYN, e.g. premature ACK */
 234 };
 235
 236 #ifdef KERNEL
 237 struct  inpcb tcb;              /* head of queue of active tcpcb's */
 238 struct  tcpstat tcpstat;        /* tcp statistics */
 239 n_long  tcp_now;                /* for RFC 1323 timestamps */
 240
 241 int      tcp_attach __P((struct socket *));
 242 void     tcp_canceltimers __P((struct tcpcb *));
 243 struct tcpcb *
 244          tcp_close __P((struct tcpcb *));
 245 void     tcp_ctlinput __P((int, struct sockaddr *, struct ip *));
 246 int      tcp_ctloutput __P((int, struct socket *, int, int, struct mbuf **));
 247 struct tcpcb *
 248          tcp_disconnect __P((struct tcpcb *));
 249 struct tcpcb *
 250          tcp_drop __P((struct tcpcb *, int));
 251 void     tcp_dooptions __P((struct tcpcb *,
 252             u_char *, int, struct tcpiphdr *, int *, n_long *, n_long *));
 253 void     tcp_drain __P((void));
 254 void     tcp_fasttimo __P((void));
 255 void     tcp_init __P((void));
 256 void     tcp_input __P((struct mbuf *, int));
 257 int      tcp_mss __P((struct tcpcb *, u_int));
 258 struct tcpcb *
 259          tcp_newtcpcb __P((struct inpcb *));
 260 void     tcp_notify __P((struct inpcb *, int));
 261 int      tcp_output __P((struct tcpcb *));
 262 void     tcp_pulloutofband __P((struct socket *,
 263             struct tcpiphdr *, struct mbuf *));
 264 void     tcp_quench __P((struct inpcb *, int));
 265 int      tcp_reass __P((struct tcpcb *, struct tcpiphdr *, struct mbuf *));
 266 void     tcp_respond __P((struct tcpcb *,
 267             struct tcpiphdr *, struct mbuf *, n_long, n_long, int));
 268 void     tcp_setpersist __P((struct tcpcb *));
 269 void     tcp_slowtimo __P((void));
 270 struct tcpiphdr *
 271          tcp_template __P((struct tcpcb *));
 272 struct tcpcb *
 273          tcp_timers __P((struct tcpcb *, int));
 274 void     tcp_trace __P((int, int, struct tcpcb *, struct tcpiphdr *, int));
 275 struct tcpcb *
 276          tcp_usrclosed __P((struct tcpcb *));
 277 int      tcp_usrreq __P((struct socket *,
 278             int, struct mbuf *, struct mbuf *, struct mbuf *));
 279 void     tcp_xmit_timer __P((struct tcpcb *, int));
 280 #endif