File:  [DragonFly] / src / sys / netinet / tcp_output.c
Revision 1.8: download - view: text, annotated - select for diffs
Sun Feb 8 00:11:02 2004 UTC (10 years, 6 months ago) by hsu
Branches: MAIN
CVS tags: HEAD
Cosmetic code cleanup.

    1: /*
    2:  * Copyright (c) 1982, 1986, 1988, 1990, 1993, 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_output.c	8.4 (Berkeley) 5/24/95
   34:  * $FreeBSD: src/sys/netinet/tcp_output.c,v 1.39.2.20 2003/01/29 22:45:36 hsu Exp $
   35:  * $DragonFly: src/sys/netinet/tcp_output.c,v 1.8 2004/02/08 00:11:02 hsu Exp $
   36:  */
   37: 
   38: #include "opt_inet6.h"
   39: #include "opt_ipsec.h"
   40: #include "opt_tcpdebug.h"
   41: 
   42: #include <sys/param.h>
   43: #include <sys/systm.h>
   44: #include <sys/kernel.h>
   45: #include <sys/sysctl.h>
   46: #include <sys/mbuf.h>
   47: #include <sys/domain.h>
   48: #include <sys/protosw.h>
   49: #include <sys/socket.h>
   50: #include <sys/socketvar.h>
   51: 
   52: #include <net/route.h>
   53: 
   54: #include <netinet/in.h>
   55: #include <netinet/in_systm.h>
   56: #include <netinet/ip.h>
   57: #include <netinet/in_pcb.h>
   58: #include <netinet/ip_var.h>
   59: #include <netinet6/in6_pcb.h>
   60: #include <netinet/ip6.h>
   61: #include <netinet6/ip6_var.h>
   62: #include <netinet/tcp.h>
   63: #define	TCPOUTFLAGS
   64: #include <netinet/tcp_fsm.h>
   65: #include <netinet/tcp_seq.h>
   66: #include <netinet/tcp_timer.h>
   67: #include <netinet/tcp_var.h>
   68: #include <netinet/tcpip.h>
   69: #ifdef TCPDEBUG
   70: #include <netinet/tcp_debug.h>
   71: #endif
   72: 
   73: #ifdef IPSEC
   74: #include <netinet6/ipsec.h>
   75: #endif /*IPSEC*/
   76: 
   77: #ifdef FAST_IPSEC
   78: #include <netipsec/ipsec.h>
   79: #define	IPSEC
   80: #endif /*FAST_IPSEC*/
   81: 
   82: #include <machine/in_cksum.h>
   83: 
   84: #ifdef notyet
   85: extern struct mbuf *m_copypack();
   86: #endif
   87: 
   88: int path_mtu_discovery = 1;
   89: SYSCTL_INT(_net_inet_tcp, OID_AUTO, path_mtu_discovery, CTLFLAG_RW,
   90: 	&path_mtu_discovery, 1, "Enable Path MTU Discovery");
   91: 
   92: int ss_fltsz = 1;
   93: SYSCTL_INT(_net_inet_tcp, OID_AUTO, slowstart_flightsize, CTLFLAG_RW,
   94: 	&ss_fltsz, 1, "Slow start flight size");
   95: 
   96: int ss_fltsz_local = 4;
   97: SYSCTL_INT(_net_inet_tcp, OID_AUTO, local_slowstart_flightsize, CTLFLAG_RW,
   98: 	&ss_fltsz_local, 1, "Slow start flight size for local networks");
   99: 
  100: int	tcp_do_newreno = 1;
  101: SYSCTL_INT(_net_inet_tcp, OID_AUTO, newreno, CTLFLAG_RW, &tcp_do_newreno,
  102: 	0, "Enable NewReno Algorithms");
  103: 
  104: /*
  105:  * Tcp output routine: figure out what should be sent and send it.
  106:  */
  107: int
  108: tcp_output(tp)
  109: 	struct tcpcb *tp;
  110: {
  111: 	struct inpcb * const inp = tp->t_inpcb;
  112: 	struct socket *so = inp->inp_socket;
  113: 	long len, recvwin, sendwin;
  114: 	int off, flags, error;
  115: 	struct mbuf *m;
  116: 	struct ip *ip = NULL;
  117: 	struct ipovly *ipov = NULL;
  118: 	struct tcphdr *th;
  119: 	u_char opt[TCP_MAXOLEN];
  120: 	unsigned ipoptlen, optlen, hdrlen;
  121: 	int idle, sendalot;
  122: 	struct ip6_hdr *ip6 = NULL;
  123: #ifdef INET6
  124: 	const boolean_t isipv6 = (inp->inp_vflag & INP_IPV6) != 0;
  125: #else
  126: 	const boolean_t isipv6 = FALSE;
  127: #endif
  128: 	struct rmxp_tao *taop;
  129: 
  130: 	/*
  131: 	 * Determine length of data that should be transmitted,
  132: 	 * and flags that will be used.
  133: 	 * If there is some data or critical controls (SYN, RST)
  134: 	 * to send, then transmit; otherwise, investigate further.
  135: 	 */
  136: 	if ((tp->snd_max == tp->snd_una) &&
  137: 	    (ticks - tp->t_rcvtime) >= tp->t_rxtcur) {
  138: 		/*
  139: 		 * We have been idle for "a while" and no acks are
  140: 		 * expected to clock out any data we send --
  141: 		 * slow start to get ack "clock" running again.
  142: 		 *
  143: 		 * Set the slow-start flight size depending on whether
  144: 		 * this is a local network or not.
  145: 		 */
  146: 		if ((isipv6 && in6_localaddr(&inp->in6p_faddr)) ||
  147: 		    (!isipv6 && in_localaddr(inp->inp_faddr)))
  148: 			tp->snd_cwnd = tp->t_maxseg * ss_fltsz_local;
  149: 		else
  150: 			tp->snd_cwnd = tp->t_maxseg * ss_fltsz;
  151: 	}
  152: 	idle = (tp->t_flags & TF_LASTIDLE) || (tp->snd_max == tp->snd_una);
  153: 	if (idle && (tp->t_flags & TF_MORETOCOME))
  154: 		tp->t_flags |= TF_LASTIDLE;
  155: 	else
  156: 		tp->t_flags &= ~TF_LASTIDLE;
  157: again:
  158: 	sendalot = 0;
  159: 	off = tp->snd_nxt - tp->snd_una;
  160: 	sendwin = min(tp->snd_wnd, tp->snd_cwnd);
  161: 	sendwin = min(sendwin, tp->snd_bwnd);
  162: 
  163: 	flags = tcp_outflags[tp->t_state];
  164: 	/*
  165: 	 * Get standard flags, and add SYN or FIN if requested by 'hidden'
  166: 	 * state flags.
  167: 	 */
  168: 	if (tp->t_flags & TF_NEEDFIN)
  169: 		flags |= TH_FIN;
  170: 	if (tp->t_flags & TF_NEEDSYN)
  171: 		flags |= TH_SYN;
  172: 
  173: 	/*
  174: 	 * If in persist timeout with window of 0, send 1 byte.
  175: 	 * Otherwise, if window is small but nonzero
  176: 	 * and timer expired, we will send what we can
  177: 	 * and go to transmit state.
  178: 	 */
  179: 	if (tp->t_force) {
  180: 		if (sendwin == 0) {
  181: 			/*
  182: 			 * If we still have some data to send, then
  183: 			 * clear the FIN bit.  Usually this would
  184: 			 * happen below when it realizes that we
  185: 			 * aren't sending all the data.  However,
  186: 			 * if we have exactly 1 byte of unsent data,
  187: 			 * then it won't clear the FIN bit below,
  188: 			 * and if we are in persist state, we wind
  189: 			 * up sending the packet without recording
  190: 			 * that we sent the FIN bit.
  191: 			 *
  192: 			 * We can't just blindly clear the FIN bit,
  193: 			 * because if we don't have any more data
  194: 			 * to send then the probe will be the FIN
  195: 			 * itself.
  196: 			 */
  197: 			if (off < so->so_snd.sb_cc)
  198: 				flags &= ~TH_FIN;
  199: 			sendwin = 1;
  200: 		} else {
  201: 			callout_stop(tp->tt_persist);
  202: 			tp->t_rxtshift = 0;
  203: 		}
  204: 	}
  205: 
  206: 	/*
  207: 	 * If snd_nxt == snd_max and we have transmitted a FIN, the
  208: 	 * offset will be > 0 even if so_snd.sb_cc is 0, resulting in
  209: 	 * a negative length.  This can also occur when TCP opens up
  210: 	 * its congestion window while receiving additional duplicate
  211: 	 * acks after fast-retransmit because TCP will reset snd_nxt
  212: 	 * to snd_max after the fast-retransmit.
  213: 	 *
  214: 	 * In the normal retransmit-FIN-only case, however, snd_nxt will
  215: 	 * be set to snd_una, the offset will be 0, and the length may
  216: 	 * wind up 0.
  217: 	 */
  218: 	len = (long)ulmin(so->so_snd.sb_cc, sendwin) - off;
  219: 
  220: 	/*
  221: 	 * Lop off SYN bit if it has already been sent.  However, if this
  222: 	 * is SYN-SENT state and if segment contains data and if we don't
  223: 	 * know that foreign host supports TAO, suppress sending segment.
  224: 	 */
  225: 	if ((flags & TH_SYN) && SEQ_GT(tp->snd_nxt, tp->snd_una)) {
  226: 		flags &= ~TH_SYN;
  227: 		off--, len++;
  228: 		if (len > 0 && tp->t_state == TCPS_SYN_SENT &&
  229: 		    ((taop = tcp_gettaocache(&inp->inp_inc)) == NULL ||
  230: 		     taop->tao_ccsent == 0))
  231: 			return 0;
  232: 	}
  233: 
  234: 	/*
  235: 	 * Be careful not to send data and/or FIN on SYN segments
  236: 	 * in cases when no CC option will be sent.
  237: 	 * This measure is needed to prevent interoperability problems
  238: 	 * with not fully conformant TCP implementations.
  239: 	 */
  240: 	if ((flags & TH_SYN) &&
  241: 	    ((tp->t_flags & TF_NOOPT) || !(tp->t_flags & TF_REQ_CC) ||
  242: 	     ((flags & TH_ACK) && !(tp->t_flags & TF_RCVD_CC)))) {
  243: 		len = 0;
  244: 		flags &= ~TH_FIN;
  245: 	}
  246: 
  247: 	if (len < 0) {
  248: 		/*
  249: 		 * If FIN has been sent but not acked,
  250: 		 * but we haven't been called to retransmit,
  251: 		 * len will be < 0.  Otherwise, window shrank
  252: 		 * after we sent into it.  If window shrank to 0,
  253: 		 * cancel pending retransmit, pull snd_nxt back
  254: 		 * to (closed) window, and set the persist timer
  255: 		 * if it isn't already going.  If the window didn't
  256: 		 * close completely, just wait for an ACK.
  257: 		 */
  258: 		len = 0;
  259: 		if (sendwin == 0) {
  260: 			callout_stop(tp->tt_rexmt);
  261: 			tp->t_rxtshift = 0;
  262: 			tp->snd_nxt = tp->snd_una;
  263: 			if (!callout_active(tp->tt_persist))
  264: 				tcp_setpersist(tp);
  265: 		}
  266: 	}
  267: 
  268: 	/*
  269: 	 * len will be >= 0 after this point.  Truncate to the maximum
  270: 	 * segment length and ensure that FIN is removed if the length
  271: 	 * no longer contains the last data byte.
  272: 	 */
  273: 	if (len > tp->t_maxseg) {
  274: 		len = tp->t_maxseg;
  275: 		sendalot = 1;
  276: 	}
  277: 	if (SEQ_LT(tp->snd_nxt + len, tp->snd_una + so->so_snd.sb_cc))
  278: 		flags &= ~TH_FIN;
  279: 
  280: 	recvwin = sbspace(&so->so_rcv);
  281: 
  282: 	/*
  283: 	 * Sender silly window avoidance.   We transmit under the following
  284: 	 * conditions when len is non-zero:
  285: 	 *
  286: 	 *	- We have a full segment
  287: 	 *	- This is the last buffer in a write()/send() and we are
  288: 	 *	  either idle or running NODELAY
  289: 	 *	- we've timed out (e.g. persist timer)
  290: 	 *	- we have more then 1/2 the maximum send window's worth of
  291: 	 *	  data (receiver may be limited the window size)
  292: 	 *	- we need to retransmit
  293: 	 */
  294: 	if (len) {
  295: 		if (len == tp->t_maxseg)
  296: 			goto send;
  297: 		/*
  298: 		 * NOTE! on localhost connections an 'ack' from the remote
  299: 		 * end may occur synchronously with the output and cause
  300: 		 * us to flush a buffer queued with moretocome.  XXX
  301: 		 *
  302: 		 * note: the len + off check is almost certainly unnecessary.
  303: 		 */
  304: 		if (!(tp->t_flags & TF_MORETOCOME) &&	/* normal case */
  305: 		    (idle || (tp->t_flags & TF_NODELAY)) &&
  306: 		    len + off >= so->so_snd.sb_cc &&
  307: 		    !(tp->t_flags & TF_NOPUSH)) {
  308: 			goto send;
  309: 		}
  310: 		if (tp->t_force)			/* typ. timeout case */
  311: 			goto send;
  312: 		if (len >= tp->max_sndwnd / 2 && tp->max_sndwnd > 0)
  313: 			goto send;
  314: 		if (SEQ_LT(tp->snd_nxt, tp->snd_max))	/* retransmit case */
  315: 			goto send;
  316: 	}
  317: 
  318: 	/*
  319: 	 * Compare available window to amount of window
  320: 	 * known to peer (as advertised window less
  321: 	 * next expected input).  If the difference is at least two
  322: 	 * max size segments, or at least 50% of the maximum possible
  323: 	 * window, then want to send a window update to peer.
  324: 	 */
  325: 	if (recvwin > 0) {
  326: 		/*
  327: 		 * "adv" is the amount we can increase the window,
  328: 		 * taking into account that we are limited by
  329: 		 * TCP_MAXWIN << tp->rcv_scale.
  330: 		 */
  331: 		long adv = min(recvwin, (long)TCP_MAXWIN << tp->rcv_scale) -
  332: 			(tp->rcv_adv - tp->rcv_nxt);
  333: 
  334: 		if (adv >= (long) (2 * tp->t_maxseg))
  335: 			goto send;
  336: 		if (2 * adv >= (long) so->so_rcv.sb_hiwat)
  337: 			goto send;
  338: 	}
  339: 
  340: 	/*
  341: 	 * Send if we owe the peer an ACK, RST, SYN, or urgent data.  ACKNOW
  342: 	 * is also a catch-all for the retransmit timer timeout case.
  343: 	 */
  344: 	if (tp->t_flags & TF_ACKNOW)
  345: 		goto send;
  346: 	if ((flags & TH_RST) ||
  347: 	    ((flags & TH_SYN) && !(tp->t_flags & TF_NEEDSYN)))
  348: 		goto send;
  349: 	if (SEQ_GT(tp->snd_up, tp->snd_una))
  350: 		goto send;
  351: 	/*
  352: 	 * If our state indicates that FIN should be sent
  353: 	 * and we have not yet done so, then we need to send.
  354: 	 */
  355: 	if (flags & TH_FIN &&
  356: 	    (!(tp->t_flags & TF_SENTFIN) || tp->snd_nxt == tp->snd_una))
  357: 		goto send;
  358: 
  359: 	/*
  360: 	 * TCP window updates are not reliable, rather a polling protocol
  361: 	 * using ``persist'' packets is used to insure receipt of window
  362: 	 * updates.  The three ``states'' for the output side are:
  363: 	 *	idle			not doing retransmits or persists
  364: 	 *	persisting		to move a small or zero window
  365: 	 *	(re)transmitting	and thereby not persisting
  366: 	 *
  367: 	 * callout_active(tp->tt_persist)
  368: 	 *	is true when we are in persist state.
  369: 	 * tp->t_force
  370: 	 *	is set when we are called to send a persist packet.
  371: 	 * callout_active(tp->tt_rexmt)
  372: 	 *	is set when we are retransmitting
  373: 	 * The output side is idle when both timers are zero.
  374: 	 *
  375: 	 * If send window is too small, there is data to transmit, and no
  376: 	 * retransmit or persist is pending, then go to persist state.
  377: 	 * If nothing happens soon, send when timer expires:
  378: 	 * if window is nonzero, transmit what we can,
  379: 	 * otherwise force out a byte.
  380: 	 */
  381: 	if (so->so_snd.sb_cc && !callout_active(tp->tt_rexmt) &&
  382: 	    !callout_active(tp->tt_persist)) {
  383: 		tp->t_rxtshift = 0;
  384: 		tcp_setpersist(tp);
  385: 	}
  386: 
  387: 	/*
  388: 	 * No reason to send a segment, just return.
  389: 	 */
  390: 	return (0);
  391: 
  392: send:
  393: 	/*
  394: 	 * Before ESTABLISHED, force sending of initial options
  395: 	 * unless TCP set not to do any options.
  396: 	 * NOTE: we assume that the IP/TCP header plus TCP options
  397: 	 * always fit in a single mbuf, leaving room for a maximum
  398: 	 * link header, i.e.
  399: 	 *	max_linkhdr + sizeof (struct tcpiphdr) + optlen <= MCLBYTES
  400: 	 */
  401: 	optlen = 0;
  402: 	if (isipv6)
  403: 		hdrlen = sizeof (struct ip6_hdr) + sizeof (struct tcphdr);
  404: 	else
  405: 		hdrlen = sizeof (struct tcpiphdr);
  406: 	if (flags & TH_SYN) {
  407: 		tp->snd_nxt = tp->iss;
  408: 		if (!(tp->t_flags & TF_NOOPT)) {
  409: 			u_short mss;
  410: 
  411: 			opt[0] = TCPOPT_MAXSEG;
  412: 			opt[1] = TCPOLEN_MAXSEG;
  413: 			mss = htons((u_short) tcp_mssopt(tp));
  414: 			(void)memcpy(opt + 2, &mss, sizeof(mss));
  415: 			optlen = TCPOLEN_MAXSEG;
  416: 
  417: 			if ((tp->t_flags & TF_REQ_SCALE) &&
  418: 			    (!(flags & TH_ACK) ||
  419: 			     (tp->t_flags & TF_RCVD_SCALE))) {
  420: 				*((u_int32_t *)(opt + optlen)) = htonl(
  421: 					TCPOPT_NOP << 24 |
  422: 					TCPOPT_WINDOW << 16 |
  423: 					TCPOLEN_WINDOW << 8 |
  424: 					tp->request_r_scale);
  425: 				optlen += 4;
  426: 			}
  427: 		}
  428: 	}
  429: 
  430: 	/*
  431: 	 * Send a timestamp and echo-reply if this is a SYN and our side
  432: 	 * wants to use timestamps (TF_REQ_TSTMP is set) or both our side
  433: 	 * and our peer have sent timestamps in our SYN's.
  434: 	 */
  435: 	if ((tp->t_flags & (TF_REQ_TSTMP|TF_NOOPT)) == TF_REQ_TSTMP &&
  436: 	    !(flags & TH_RST) &&
  437: 	    (!(flags & TH_ACK) || (tp->t_flags & TF_RCVD_TSTMP))) {
  438: 		u_int32_t *lp = (u_int32_t *)(opt + optlen);
  439: 
  440: 		/* Form timestamp option as shown in appendix A of RFC 1323. */
  441: 		*lp++ = htonl(TCPOPT_TSTAMP_HDR);
  442: 		*lp++ = htonl(ticks);
  443: 		*lp   = htonl(tp->ts_recent);
  444: 		optlen += TCPOLEN_TSTAMP_APPA;
  445: 	}
  446: 
  447: 	/*
  448: 	 * Send `CC-family' options if our side wants to use them (TF_REQ_CC),
  449: 	 * options are allowed (!TF_NOOPT) and it's not a RST.
  450: 	 */
  451: 	if ((tp->t_flags & (TF_REQ_CC|TF_NOOPT)) == TF_REQ_CC &&
  452: 	     !(flags & TH_RST)) {
  453: 		switch (flags & (TH_SYN|TH_ACK)) {
  454: 		/*
  455: 		 * This is a normal ACK, send CC if we received CC before
  456: 		 * from our peer.
  457: 		 */
  458: 		case TH_ACK:
  459: 			if (!(tp->t_flags & TF_RCVD_CC))
  460: 				break;
  461: 			/*FALLTHROUGH*/
  462: 
  463: 		/*
  464: 		 * We can only get here in T/TCP's SYN_SENT* state, when
  465: 		 * we're a sending a non-SYN segment without waiting for
  466: 		 * the ACK of our SYN.  A check above assures that we only
  467: 		 * do this if our peer understands T/TCP.
  468: 		 */
  469: 		case 0:
  470: 			opt[optlen++] = TCPOPT_NOP;
  471: 			opt[optlen++] = TCPOPT_NOP;
  472: 			opt[optlen++] = TCPOPT_CC;
  473: 			opt[optlen++] = TCPOLEN_CC;
  474: 			*(u_int32_t *)&opt[optlen] = htonl(tp->cc_send);
  475: 
  476: 			optlen += 4;
  477: 			break;
  478: 
  479: 		/*
  480: 		 * This is our initial SYN, check whether we have to use
  481: 		 * CC or CC.new.
  482: 		 */
  483: 		case TH_SYN:
  484: 			opt[optlen++] = TCPOPT_NOP;
  485: 			opt[optlen++] = TCPOPT_NOP;
  486: 			opt[optlen++] = tp->t_flags & TF_SENDCCNEW ?
  487: 						TCPOPT_CCNEW : TCPOPT_CC;
  488: 			opt[optlen++] = TCPOLEN_CC;
  489: 			*(u_int32_t *)&opt[optlen] = htonl(tp->cc_send);
  490: 			optlen += 4;
  491: 			break;
  492: 
  493: 		/*
  494: 		 * This is a SYN,ACK; send CC and CC.echo if we received
  495: 		 * CC from our peer.
  496: 		 */
  497: 		case (TH_SYN|TH_ACK):
  498: 			if (tp->t_flags & TF_RCVD_CC) {
  499: 				opt[optlen++] = TCPOPT_NOP;
  500: 				opt[optlen++] = TCPOPT_NOP;
  501: 				opt[optlen++] = TCPOPT_CC;
  502: 				opt[optlen++] = TCPOLEN_CC;
  503: 				*(u_int32_t *)&opt[optlen] =
  504: 					htonl(tp->cc_send);
  505: 				optlen += 4;
  506: 				opt[optlen++] = TCPOPT_NOP;
  507: 				opt[optlen++] = TCPOPT_NOP;
  508: 				opt[optlen++] = TCPOPT_CCECHO;
  509: 				opt[optlen++] = TCPOLEN_CC;
  510: 				*(u_int32_t *)&opt[optlen] =
  511: 					htonl(tp->cc_recv);
  512: 				optlen += 4;
  513: 			}
  514: 			break;
  515: 		}
  516: 	}
  517: 
  518: 	hdrlen += optlen;
  519: 
  520: 	if (isipv6)
  521: 		ipoptlen = ip6_optlen(inp);
  522: 	else {
  523: 		if (inp->inp_options) {
  524: 			ipoptlen = inp->inp_options->m_len -
  525: 			    offsetof(struct ipoption, ipopt_list);
  526: 		} else {
  527: 			ipoptlen = 0;
  528: 		}
  529: 	}
  530: #ifdef IPSEC
  531: 	ipoptlen += ipsec_hdrsiz_tcp(tp);
  532: #endif
  533: 
  534: 	/*
  535: 	 * Adjust data length if insertion of options will
  536: 	 * bump the packet length beyond the t_maxopd length.
  537: 	 * Clear the FIN bit because we cut off the tail of
  538: 	 * the segment.
  539: 	 */
  540: 	if (len + optlen + ipoptlen > tp->t_maxopd) {
  541: 		/*
  542: 		 * If there is still more to send, don't close the connection.
  543: 		 */
  544: 		flags &= ~TH_FIN;
  545: 		len = tp->t_maxopd - optlen - ipoptlen;
  546: 		sendalot = 1;
  547: 	}
  548: 
  549: #ifdef INET6
  550: 	KASSERT(max_linkhdr + hdrlen <= MCLBYTES, ("tcphdr too big"));
  551: #else
  552: 	KASSERT(max_linkhdr + hdrlen <= MHLEN, ("tcphdr too big"));
  553: #endif
  554: 
  555: 	/*
  556: 	 * Grab a header mbuf, attaching a copy of data to
  557: 	 * be transmitted, and initialize the header from
  558: 	 * the template for sends on this connection.
  559: 	 */
  560: 	if (len) {
  561: 		if (tp->t_force && len == 1)
  562: 			tcpstat.tcps_sndprobe++;
  563: 		else if (SEQ_LT(tp->snd_nxt, tp->snd_max)) {
  564: 			tcpstat.tcps_sndrexmitpack++;
  565: 			tcpstat.tcps_sndrexmitbyte += len;
  566: 		} else {
  567: 			tcpstat.tcps_sndpack++;
  568: 			tcpstat.tcps_sndbyte += len;
  569: 		}
  570: #ifdef notyet
  571: 		if ((m = m_copypack(so->so_snd.sb_mb, off,
  572: 		    (int)len, max_linkhdr + hdrlen)) == 0) {
  573: 			error = ENOBUFS;
  574: 			goto out;
  575: 		}
  576: 		/*
  577: 		 * m_copypack left space for our hdr; use it.
  578: 		 */
  579: 		m->m_len += hdrlen;
  580: 		m->m_data -= hdrlen;
  581: #else
  582: 		MGETHDR(m, M_DONTWAIT, MT_HEADER);
  583: 		if (m == NULL) {
  584: 			error = ENOBUFS;
  585: 			goto out;
  586: 		}
  587: #ifdef INET6
  588: 		if (MHLEN < hdrlen + max_linkhdr) {
  589: 			MCLGET(m, M_DONTWAIT);
  590: 			if (!(m->m_flags & M_EXT)) {
  591: 				m_freem(m);
  592: 				error = ENOBUFS;
  593: 				goto out;
  594: 			}
  595: 		}
  596: #endif
  597: 		m->m_data += max_linkhdr;
  598: 		m->m_len = hdrlen;
  599: 		if (len <= MHLEN - hdrlen - max_linkhdr) {
  600: 			m_copydata(so->so_snd.sb_mb, off, (int) len,
  601: 			    mtod(m, caddr_t) + hdrlen);
  602: 			m->m_len += len;
  603: 		} else {
  604: 			m->m_next = m_copy(so->so_snd.sb_mb, off, (int) len);
  605: 			if (m->m_next == 0) {
  606: 				(void) m_free(m);
  607: 				error = ENOBUFS;
  608: 				goto out;
  609: 			}
  610: 		}
  611: #endif
  612: 		/*
  613: 		 * If we're sending everything we've got, set PUSH.
  614: 		 * (This will keep happy those implementations which only
  615: 		 * give data to the user when a buffer fills or
  616: 		 * a PUSH comes in.)
  617: 		 */
  618: 		if (off + len == so->so_snd.sb_cc)
  619: 			flags |= TH_PUSH;
  620: 	} else {
  621: 		if (tp->t_flags & TF_ACKNOW)
  622: 			tcpstat.tcps_sndacks++;
  623: 		else if (flags & (TH_SYN|TH_FIN|TH_RST))
  624: 			tcpstat.tcps_sndctrl++;
  625: 		else if (SEQ_GT(tp->snd_up, tp->snd_una))
  626: 			tcpstat.tcps_sndurg++;
  627: 		else
  628: 			tcpstat.tcps_sndwinup++;
  629: 
  630: 		MGETHDR(m, M_DONTWAIT, MT_HEADER);
  631: 		if (m == NULL) {
  632: 			error = ENOBUFS;
  633: 			goto out;
  634: 		}
  635: 		if (isipv6 &&
  636: 		    (hdrlen + max_linkhdr > MHLEN) && hdrlen <= MHLEN)
  637: 			MH_ALIGN(m, hdrlen);
  638: 		else
  639: 			m->m_data += max_linkhdr;
  640: 		m->m_len = hdrlen;
  641: 	}
  642: 	m->m_pkthdr.rcvif = (struct ifnet *)0;
  643: 	if (isipv6) {
  644: 		ip6 = mtod(m, struct ip6_hdr *);
  645: 		th = (struct tcphdr *)(ip6 + 1);
  646: 		tcp_fillheaders(tp, ip6, th);
  647: 	} else {
  648: 		ip = mtod(m, struct ip *);
  649: 		ipov = (struct ipovly *)ip;
  650: 		th = (struct tcphdr *)(ip + 1);
  651: 		/* this picks up the pseudo header (w/o the length) */
  652: 		tcp_fillheaders(tp, ip, th);
  653: 	}
  654: 
  655: 	/*
  656: 	 * Fill in fields, remembering maximum advertised
  657: 	 * window for use in delaying messages about window sizes.
  658: 	 * If resending a FIN, be sure not to use a new sequence number.
  659: 	 */
  660: 	if (flags & TH_FIN && tp->t_flags & TF_SENTFIN &&
  661: 	    tp->snd_nxt == tp->snd_max)
  662: 		tp->snd_nxt--;
  663: 	/*
  664: 	 * If we are doing retransmissions, then snd_nxt will
  665: 	 * not reflect the first unsent octet.  For ACK only
  666: 	 * packets, we do not want the sequence number of the
  667: 	 * retransmitted packet, we want the sequence number
  668: 	 * of the next unsent octet.  So, if there is no data
  669: 	 * (and no SYN or FIN), use snd_max instead of snd_nxt
  670: 	 * when filling in ti_seq.  But if we are in persist
  671: 	 * state, snd_max might reflect one byte beyond the
  672: 	 * right edge of the window, so use snd_nxt in that
  673: 	 * case, since we know we aren't doing a retransmission.
  674: 	 * (retransmit and persist are mutually exclusive...)
  675: 	 */
  676: 	if (len || (flags & (TH_SYN|TH_FIN)) || callout_active(tp->tt_persist))
  677: 		th->th_seq = htonl(tp->snd_nxt);
  678: 	else
  679: 		th->th_seq = htonl(tp->snd_max);
  680: 	th->th_ack = htonl(tp->rcv_nxt);
  681: 	if (optlen) {
  682: 		bcopy(opt, th + 1, optlen);
  683: 		th->th_off = (sizeof (struct tcphdr) + optlen) >> 2;
  684: 	}
  685: 	th->th_flags = flags;
  686: 	/*
  687: 	 * Calculate receive window.  Don't shrink window,
  688: 	 * but avoid silly window syndrome.
  689: 	 */
  690: 	if (recvwin < (long)(so->so_rcv.sb_hiwat / 4) &&
  691: 	    recvwin < (long)tp->t_maxseg)
  692: 		recvwin = 0;
  693: 	if (recvwin < (long)(tp->rcv_adv - tp->rcv_nxt))
  694: 		recvwin = (long)(tp->rcv_adv - tp->rcv_nxt);
  695: 	if (recvwin > (long)TCP_MAXWIN << tp->rcv_scale)
  696: 		recvwin = (long)TCP_MAXWIN << tp->rcv_scale;
  697: 	th->th_win = htons((u_short) (recvwin>>tp->rcv_scale));
  698: 
  699: 	/*
  700: 	 * Adjust the RXWIN0SENT flag - indicate that we have advertised
  701: 	 * a 0 window.  This may cause the remote transmitter to stall.  This
  702: 	 * flag tells soreceive() to disable delayed acknowledgements when
  703: 	 * draining the buffer.  This can occur if the receiver is attempting
  704: 	 * to read more data then can be buffered prior to transmitting on
  705: 	 * the connection.
  706: 	 */
  707: 	if (recvwin == 0)
  708: 		tp->t_flags |= TF_RXWIN0SENT;
  709: 	else
  710: 		tp->t_flags &= ~TF_RXWIN0SENT;
  711: 
  712: 	if (SEQ_GT(tp->snd_up, tp->snd_nxt)) {
  713: 		th->th_urp = htons((u_short)(tp->snd_up - tp->snd_nxt));
  714: 		th->th_flags |= TH_URG;
  715: 	} else
  716: 		/*
  717: 		 * If no urgent pointer to send, then we pull
  718: 		 * the urgent pointer to the left edge of the send window
  719: 		 * so that it doesn't drift into the send window on sequence
  720: 		 * number wraparound.
  721: 		 */
  722: 		tp->snd_up = tp->snd_una;		/* drag it along */
  723: 
  724: 	/*
  725: 	 * Put TCP length in extended header, and then
  726: 	 * checksum extended header and data.
  727: 	 */
  728: 	m->m_pkthdr.len = hdrlen + len; /* in6_cksum() need this */
  729: 	if (isipv6) {
  730: 		/*
  731: 		 * ip6_plen is not need to be filled now, and will be filled
  732: 		 * in ip6_output.
  733: 		 */
  734: 		th->th_sum = in6_cksum(m, IPPROTO_TCP, sizeof(struct ip6_hdr),
  735: 				       sizeof(struct tcphdr) + optlen + len);
  736: 	} else {
  737: 		m->m_pkthdr.csum_flags = CSUM_TCP;
  738: 		m->m_pkthdr.csum_data = offsetof(struct tcphdr, th_sum);
  739: 		if (len + optlen)
  740: 			th->th_sum = in_addword(th->th_sum,
  741: 						htons((u_short)(optlen + len)));
  742: 
  743: 		/* IP version must be set here for ipv4/ipv6 checking later */
  744: 		KASSERT(ip->ip_v == IPVERSION,
  745: 		    ("%s: IP version incorrect: %d", __func__, ip->ip_v));
  746: 	}
  747: 
  748: 	/*
  749: 	 * In transmit state, time the transmission and arrange for
  750: 	 * the retransmit.  In persist state, just set snd_max.
  751: 	 */
  752: 	if (tp->t_force == 0 || !callout_active(tp->tt_persist)) {
  753: 		tcp_seq startseq = tp->snd_nxt;
  754: 
  755: 		/*
  756: 		 * Advance snd_nxt over sequence space of this segment.
  757: 		 */
  758: 		if (flags & (TH_SYN|TH_FIN)) {
  759: 			if (flags & TH_SYN)
  760: 				tp->snd_nxt++;
  761: 			if (flags & TH_FIN) {
  762: 				tp->snd_nxt++;
  763: 				tp->t_flags |= TF_SENTFIN;
  764: 			}
  765: 		}
  766: 		tp->snd_nxt += len;
  767: 		if (SEQ_GT(tp->snd_nxt, tp->snd_max)) {
  768: 			tp->snd_max = tp->snd_nxt;
  769: 			/*
  770: 			 * Time this transmission if not a retransmission and
  771: 			 * not currently timing anything.
  772: 			 */
  773: 			if (tp->t_rtttime == 0) {
  774: 				tp->t_rtttime = ticks;
  775: 				tp->t_rtseq = startseq;
  776: 				tcpstat.tcps_segstimed++;
  777: 			}
  778: 		}
  779: 
  780: 		/*
  781: 		 * Set retransmit timer if not currently set,
  782: 		 * and not doing a pure ack or a keep-alive probe.
  783: 		 * Initial value for retransmit timer is smoothed
  784: 		 * round-trip time + 2 * round-trip time variance.
  785: 		 * Initialize shift counter which is used for backoff
  786: 		 * of retransmit time.
  787: 		 */
  788: 		if (!callout_active(tp->tt_rexmt) &&
  789: 		    tp->snd_nxt != tp->snd_una) {
  790: 			if (callout_active(tp->tt_persist)) {
  791: 				callout_stop(tp->tt_persist);
  792: 				tp->t_rxtshift = 0;
  793: 			}
  794: 			callout_reset(tp->tt_rexmt, tp->t_rxtcur,
  795: 				      tcp_timer_rexmt, tp);
  796: 		}
  797: 	} else {
  798: 		/*
  799: 		 * Persist case, update snd_max but since we are in
  800: 		 * persist mode (no window) we do not update snd_nxt.
  801: 		 */
  802: 		int xlen = len;
  803: 		if (flags & TH_SYN)
  804: 			++xlen;
  805: 		if (flags & TH_FIN) {
  806: 			++xlen;
  807: 			tp->t_flags |= TF_SENTFIN;
  808: 		}
  809: 		if (SEQ_GT(tp->snd_nxt + xlen, tp->snd_max))
  810: 			tp->snd_max = tp->snd_nxt + xlen;
  811: 	}
  812: 
  813: #ifdef TCPDEBUG
  814: 	/*
  815: 	 * Trace.
  816: 	 */
  817: 	if (so->so_options & SO_DEBUG)
  818: 		tcp_trace(TA_OUTPUT, tp->t_state, tp, mtod(m, void *), th, 0);
  819: #endif
  820: 
  821: 	/*
  822: 	 * Fill in IP length and desired time to live and
  823: 	 * send to IP level.  There should be a better way
  824: 	 * to handle ttl and tos; we could keep them in
  825: 	 * the template, but need a way to checksum without them.
  826: 	 */
  827: 	/*
  828: 	 * m->m_pkthdr.len should have been set before cksum calcuration,
  829: 	 * because in6_cksum() need it.
  830: 	 */
  831: 	if (isipv6) {
  832: 		/*
  833: 		 * we separately set hoplimit for every segment, since the
  834: 		 * user might want to change the value via setsockopt.
  835: 		 * Also, desired default hop limit might be changed via
  836: 		 * Neighbor Discovery.
  837: 		 */
  838: 		ip6->ip6_hlim = in6_selecthlim(inp,
  839: 		    (inp->in6p_route.ro_rt ?
  840: 		     inp->in6p_route.ro_rt->rt_ifp : NULL));
  841: 
  842: 		/* TODO: IPv6 IP6TOS_ECT bit on */
  843: 		error = ip6_output(m, inp->in6p_outputopts, &inp->in6p_route,
  844: 		    (so->so_options & SO_DONTROUTE), NULL, NULL, inp);
  845: 	} else {
  846: 		struct rtentry *rt;
  847: 		ip->ip_len = m->m_pkthdr.len;
  848: #ifdef INET6
  849: 		if (INP_CHECK_SOCKAF(so, AF_INET6))
  850: 			ip->ip_ttl = in6_selecthlim(inp,
  851: 			    (inp->in6p_route.ro_rt ?
  852: 			     inp->in6p_route.ro_rt->rt_ifp : NULL));
  853: 		else
  854: #endif
  855: 			ip->ip_ttl = inp->inp_ip_ttl;	/* XXX */
  856: 
  857: 		ip->ip_tos = inp->inp_ip_tos;	/* XXX */
  858: 		/*
  859: 		 * See if we should do MTU discovery.
  860: 		 * We do it only if the following are true:
  861: 		 *	1) we have a valid route to the destination
  862: 		 *	2) the MTU is not locked (if it is,
  863: 		 *	   then discovery has been disabled)
  864: 		 */
  865: 		if (path_mtu_discovery &&
  866: 		    (rt = inp->inp_route.ro_rt) && (rt->rt_flags & RTF_UP) &&
  867: 		    !(rt->rt_rmx.rmx_locks & RTV_MTU))
  868: 			ip->ip_off |= IP_DF;
  869: 
  870: 		error = ip_output(m, inp->inp_options, &inp->inp_route,
  871: 		    (so->so_options & SO_DONTROUTE), NULL, inp);
  872: 	}
  873: 	if (error) {
  874: 
  875: 		/*
  876: 		 * We know that the packet was lost, so back out the
  877: 		 * sequence number advance, if any.
  878: 		 */
  879: 		if (tp->t_force == 0 || !callout_active(tp->tt_persist)) {
  880: 			/*
  881: 			 * No need to check for TH_FIN here because
  882: 			 * the TF_SENTFIN flag handles that case.
  883: 			 */
  884: 			if (!(flags & TH_SYN))
  885: 				tp->snd_nxt -= len;
  886: 		}
  887: 
  888: out:
  889: 		if (error == ENOBUFS) {
  890: 			/*
  891: 			 * If we can't send, make sure there is something
  892: 			 * to get us going again later.  Persist state
  893: 			 * is not necessarily right, but it is close enough.
  894: 			 */
  895: 			if (!callout_active(tp->tt_rexmt) &&
  896: 			    !callout_active(tp->tt_persist)) {
  897: 				tp->t_rxtshift = 0;
  898: 				tcp_setpersist(tp);
  899: 			}
  900: 			tcp_quench(inp, 0);
  901: 			return (0);
  902: 		}
  903: 		if (error == EMSGSIZE) {
  904: 			/*
  905: 			 * ip_output() will have already fixed the route
  906: 			 * for us.  tcp_mtudisc() will, as its last action,
  907: 			 * initiate retransmission, so it is important to
  908: 			 * not do so here.
  909: 			 */
  910: 			tcp_mtudisc(inp, 0);
  911: 			return 0;
  912: 		}
  913: 		if ((error == EHOSTUNREACH || error == ENETDOWN) &&
  914: 		    TCPS_HAVERCVDSYN(tp->t_state)) {
  915: 			tp->t_softerror = error;
  916: 			return (0);
  917: 		}
  918: 		return (error);
  919: 	}
  920: 	tcpstat.tcps_sndtotal++;
  921: 
  922: 	/*
  923: 	 * Data sent (as far as we can tell).
  924: 	 * If this advertises a larger window than any other segment,
  925: 	 * then remember the size of the advertised window.
  926: 	 * Any pending ACK has now been sent.
  927: 	 */
  928: 	if (recvwin > 0 && SEQ_GT(tp->rcv_nxt + recvwin, tp->rcv_adv))
  929: 		tp->rcv_adv = tp->rcv_nxt + recvwin;
  930: 	tp->last_ack_sent = tp->rcv_nxt;
  931: 	tp->t_flags &= ~TF_ACKNOW;
  932: 	if (tcp_delack_enabled)
  933: 		callout_stop(tp->tt_delack);
  934: 	if (sendalot)
  935: 		goto again;
  936: 	return (0);
  937: }
  938: 
  939: void
  940: tcp_setpersist(tp)
  941: 	struct tcpcb *tp;
  942: {
  943: 	int t = ((tp->t_srtt >> 2) + tp->t_rttvar) >> 1;
  944: 	int tt;
  945: 
  946: 	if (callout_active(tp->tt_rexmt))
  947: 		panic("tcp_setpersist: retransmit pending");
  948: 	/*
  949: 	 * Start/restart persistance timer.
  950: 	 */
  951: 	TCPT_RANGESET(tt, t * tcp_backoff[tp->t_rxtshift],
  952: 		      TCPTV_PERSMIN, TCPTV_PERSMAX);
  953: 	callout_reset(tp->tt_persist, tt, tcp_timer_persist, tp);
  954: 	if (tp->t_rxtshift < TCP_MAXRXTSHIFT)
  955: 		tp->t_rxtshift++;
  956: }