File:  [DragonFly] / src / sys / netinet / tcp_output.c
Revision 1.7: download - view: text, annotated - select for diffs
Thu Sep 18 18:32:55 2003 UTC (11 years, 1 month ago) by hsu
Branches: MAIN
CVS tags: HEAD
Reset the retransmit counter when setting the timer on a failed
ip_output().  This prevents ENOBUFS errors from later inadvertently
timing out a connection prematurely.

Switch over to the persist timer while we're at it.

Problem reported by:	Jayanth Vijayaraghavan <jayanth@yahoo-inc.com>
Obtained from:		BSD/OS

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