/* tcp_output.c - TCP output routines *//* Copyright 1984 - 1999 Wind River Systems, Inc. */#include "copyright_wrs.h"/* * Copyright (c) 1982, 1986, 1988, 1990, 1993, 1995 *	The Regents of the University of California.  All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright *    notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright *    notice, this list of conditions and the following disclaimer in the *    documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software *    must display the following acknowledgement: *	This product includes software developed by the University of *	California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors *    may be used to endorse or promote products derived from this software *    without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * *	@(#)tcp_output.c	8.4 (Berkeley) 5/24/95 *//*modification history--------------------01d,16mar99,spm  recovered orphaned code from tor2_0_x branch (SPR #25770)01c,10dec98,n_s  fixed state machine update for ENOBUFs error. spr 2331601b,22nov96,vin  added cluster support replaced m_gethdr(..) with 		 mHdrClGet(..).01a,03mar96,vin  created from BSD4.4lite2. Integrated with 02n of tcp_output.c*//*DESCRIPTION*/#include "vxWorks.h"#include "net/mbuf.h"#include "net/protosw.h"#include "sys/socket.h"#include "net/socketvar.h"#include "errno.h"#include "net/route.h"#include "netinet/in.h"#include "netinet/in_pcb.h"#include "netinet/in_systm.h"#include "netinet/ip.h"#include "netinet/ip_var.h"#include "netinet/tcp.h"#define	TCPOUTFLAGS#include "netinet/tcp_fsm.h"#include "netinet/tcp_seq.h"#include "netinet/tcp_timer.h"#include "netinet/tcp_var.h"#include "netinet/tcpip.h"#include "net/systm.h"#ifdef	BSDDEBUG#include "netinet/tcp_debug.h"#endif	/* BSDDEBUG */#ifdef notyetextern struct mbuf *m_copypack();#endif#define MAX_TCPOPTLEN	32	/* max # bytes that go in options *//* * Tcp output routine: figure out what should be sent and send it. */inttcp_output(tp)	register struct tcpcb *tp;{	register struct socket *so = tp->t_inpcb->inp_socket;	register long len, win;	int off, flags, error;	register struct mbuf *m;	register struct tcpiphdr *ti;	u_char opt[MAX_TCPOPTLEN];	unsigned optlen, hdrlen;	int idle, sendalot;		BOOL     pktSent = FALSE;   /* TRUE if a packet has been sent to IP */	/*	 * Determine length of data that should be transmitted,	 * and flags that will be used.	 * If there is some data or critical controls (SYN, RST)	 * to send, then transmit; otherwise, investigate further.	 */	idle = (tp->snd_max == tp->snd_una);	if (idle && tp->t_idle >= tp->t_rxtcur)		/*		 * We have been idle for "a while" and no acks are		 * expected to clock out any data we send --		 * slow start to get ack "clock" running again.		 */		tp->snd_cwnd = tp->t_maxseg;again:	sendalot = 0;	off = tp->snd_nxt - tp->snd_una;	win = min(tp->snd_wnd, tp->snd_cwnd);	flags = tcp_outflags[tp->t_state];	/*	 * If in persist timeout with window of 0, send 1 byte.	 * Otherwise, if window is small but nonzero	 * and timer expired, we will send what we can	 * and go to transmit state.	 */	if (tp->t_force) {		if (win == 0) {			/*			 * If we still have some data to send, then			 * clear the FIN bit.  Usually this would			 * happen below when it realizes that we			 * aren't sending all the data.  However,			 * if we have exactly 1 byte of unset data,			 * then it won't clear the FIN bit below,			 * and if we are in persist state, we wind			 * up sending the packet without recording			 * that we sent the FIN bit.			 *			 * We can't just blindly clear the FIN bit,			 * because if we don't have any more data			 * to send then the probe will be the FIN			 * itself.			 */			if (off < so->so_snd.sb_cc)				flags &= ~TH_FIN;			win = 1;		} else {			tp->t_timer[TCPT_PERSIST] = 0;			tp->t_rxtshift = 0;		}	}	len = min(so->so_snd.sb_cc, win) - off;	if (len < 0) {		/*		 * If FIN has been sent but not acked,		 * but we haven't been called to retransmit,		 * len will be -1.  Otherwise, window shrank		 * after we sent into it.  If window shrank to 0,		 * cancel pending retransmit and pull snd_nxt		 * back to (closed) window.  We will enter persist		 * state below.  If the window didn't close completely,		 * just wait for an ACK.		 */		len = 0;		if (win == 0) {			tp->t_timer[TCPT_REXMT] = 0;			tp->snd_nxt = tp->snd_una;		}	}	if (len > tp->t_maxseg) {		len = tp->t_maxseg;		sendalot = 1;	}	if (SEQ_LT(tp->snd_nxt + len, tp->snd_una + so->so_snd.sb_cc))		flags &= ~TH_FIN;	win = sbspace(&so->so_rcv);	/*	 * Sender silly window avoidance.  If connection is idle	 * and can send all data, a maximum segment,	 * at least a maximum default-size segment do it,	 * or are forced, do it; otherwise don't bother.	 * If peer's buffer is tiny, then send	 * when window is at least half open.	 * If retransmitting (possibly after persist timer forced us	 * to send into a small window), then must resend.	 */	if (len) {		if (len == tp->t_maxseg)			goto send;		if ((idle || tp->t_flags & TF_NODELAY) &&		    len + off >= so->so_snd.sb_cc)			goto send;		if (tp->t_force)			goto send;		if (len >= tp->max_sndwnd / 2)			goto send;		if (SEQ_LT(tp->snd_nxt, tp->snd_max))			goto send;	}	/*	 * Compare available window to amount of window	 * known to peer (as advertised window less	 * next expected input).  If the difference is at least two	 * max size segments, or at least 50% of the maximum possible	 * window, then want to send a window update to peer.	 */	if (win > 0) {		/* 		 * "adv" is the amount we can increase the window,		 * taking into account that we are limited by		 * TCP_MAXWIN << tp->rcv_scale.		 */		long adv = min(win, (long)TCP_MAXWIN << tp->rcv_scale) -			(tp->rcv_adv - tp->rcv_nxt);		if (adv >= (long) (2 * tp->t_maxseg))			goto send;		if (2 * adv >= (long) so->so_rcv.sb_hiwat)			goto send;	}	/*	 * Send if we owe peer an ACK.	 */	if (tp->t_flags & TF_ACKNOW)		goto send;	if (flags & (TH_SYN|TH_RST))		goto send;	if (SEQ_GT(tp->snd_up, tp->snd_una))		goto send;	/*	 * If our state indicates that FIN should be sent	 * and we have not yet done so, or we're retransmitting the FIN,	 * then we need to send.	 */	if (flags & TH_FIN &&	    ((tp->t_flags & TF_SENTFIN) == 0 || tp->snd_nxt == tp->snd_una))		goto send;	/*	 * TCP window updates are not reliable, rather a polling protocol	 * using ``persist'' packets is used to insure receipt of window	 * updates.  The three ``states'' for the output side are:	 *	idle			not doing retransmits or persists	 *	persisting		to move a small or zero window	 *	(re)transmitting	and thereby not persisting	 *	 * tp->t_timer[TCPT_PERSIST]	 *	is set when we are in persist state.	 * tp->t_force	 *	is set when we are called to send a persist packet.	 * tp->t_timer[TCPT_REXMT]	 *	is set when we are retransmitting	 * The output side is idle when both timers are zero.	 *	 * If send window is too small, there is data to transmit, and no	 * retransmit or persist is pending, then go to persist state.	 * If nothing happens soon, send when timer expires:	 * if window is nonzero, transmit what we can,	 * otherwise force out a byte.	 */	if (so->so_snd.sb_cc && tp->t_timer[TCPT_REXMT] == 0 &&	    tp->t_timer[TCPT_PERSIST] == 0) {		tp->t_rxtshift = 0;		tcp_setpersist(tp);	}	/*	 * No reason to send a segment, just return.	 */	return (0);send:	/*	 * Before ESTABLISHED, force sending of initial options	 * unless TCP set not to do any options.	 * NOTE: we assume that the IP/TCP header plus TCP options	 * always fit in a single mbuf, leaving room for a maximum	 * link header, i.e.	 *	max_linkhdr + sizeof (struct tcpiphdr) + optlen <= MHLEN	 */	optlen = 0;	hdrlen = sizeof (struct tcpiphdr);	if (flags & TH_SYN) {		tp->snd_nxt = tp->iss;		if ((tp->t_flags & TF_NOOPT) == 0) {			u_short mss;			opt[0] = TCPOPT_MAXSEG;			opt[1] = 4;			mss = htons((u_short) tcp_mss(tp, 0));			bcopy((caddr_t)&mss, (caddr_t)(opt + 2), sizeof(mss));			optlen = 4;	 			if ((tp->t_flags & TF_REQ_SCALE) &&			    ((flags & TH_ACK) == 0 ||			    (tp->t_flags & TF_RCVD_SCALE))) {				*((u_long *) (opt + optlen)) = htonl(					TCPOPT_NOP << 24 |					TCPOPT_WINDOW << 16 |					TCPOLEN_WINDOW << 8 |					tp->request_r_scale);				optlen += 4;			}		} 	}  	/*	 * Send a timestamp and echo-reply if this is a SYN and our side 	 * wants to use timestamps (TF_REQ_TSTMP is set) or both our side	 * and our peer have sent timestamps in our SYN's. 	 */ 	if ((tp->t_flags & (TF_REQ_TSTMP|TF_NOOPT)) == TF_REQ_TSTMP && 	     (flags & TH_RST) == 0 && 	    ((flags & (TH_SYN|TH_ACK)) == TH_SYN ||	     (tp->t_flags & TF_RCVD_TSTMP))) {		u_long *lp = (u_long *)(opt + optlen);  		/* Form timestamp option as shown in appendix A of RFC 1323. */ 		*lp++ = htonl(TCPOPT_TSTAMP_HDR); 		*lp++ = htonl(tcp_now); 		*lp   = htonl(tp->ts_recent); 		optlen += TCPOLEN_TSTAMP_APPA; 	} 	hdrlen += optlen; 	/*	 * Adjust data length if insertion of options will	 * bump the packet length beyond the t_maxseg length.	 */	if (len > tp->t_maxseg - optlen) {		len = tp->t_maxseg - optlen;		sendalot = 1;		flags &= ~TH_FIN;	 }#ifdef DIAGNOSTIC 	if (max_linkhdr + hdrlen > CL_SIZE_128)		panic("tcphdr too big");#endif	/*	 * Grab a header mbuf, attaching a copy of data to