/* tcp_subr.c - TCP routines *//* Copyright 1984 - 2002 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_subr.c	8.2 (Berkeley) 5/24/95 *//*modification history--------------------01e,18apr02,vvv  trigger slow-start in response to ICMP fragmentation-needed		 message (SPR #75058)01d,12oct01,rae  merge from truestack ver 01o, base 01c (SPRs 70049,                 70330, 34005, 31244, etc)01c,31mar97,vin  modified for hash look ups for pcbs(FREEBSD 2.2.1).01b,30oct96,vin  changed tcp_template to return mbuf * instead of tcpiphdr.		 changed m_free(dtom(...)) to m_free(tp->t_template).01a,03mar96,vin  created from BSD4.4 stuff,integrated with 02i.*//*DESCRIPTION*/#include "vxWorks.h"#include "net/systm.h"#include "net/mbuf.h"#include "sys/socket.h"#include "net/socketvar.h"#include "net/protosw.h"#include "errno.h"#include "net/route.h"#include "net/if.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/ip_icmp.h"#include "netinet/tcp.h"#include "netinet/tcp_fsm.h"#include "netinet/tcp_seq.h"#include "netinet/tcp_timer.h"#include "netinet/tcp_var.h"#include "netinet/tcpip.h"#ifdef WV_INSTRUMENTATION#ifdef INCLUDE_WVNET#include "wvNetLib.h"#endif#endif#ifdef VIRTUAL_STACK#include "netinet/vsLib.h"#else/* * Target size of TCP PCB hash table. Will be rounded down to a prime * number. */#ifndef TCBHASHSIZE#define TCBHASHSIZE     128#endif/* patchable/settable parameters for tcp */int 	tcp_mssdflt = TCP_MSS;int 	tcp_rttdflt = TCPTV_SRTTDFLT / PR_SLOWHZ;int	tcp_do_rfc1323 = 1;u_short tcp_pcbhashsize = TCBHASHSIZE;extern	struct inpcb * tcp_last_inpcb;#endif /* VIRTUAL_STACK */extern void _remque();extern int random();#ifdef WV_INSTRUMENTATION#ifdef INCLUDE_WVNET    /* Set common fields of event identifiers for this module. */LOCAL UCHAR wvNetModuleId = WV_NET_TCPSUBR_MODULE;  /* Value for tcp_subr.c */LOCAL UCHAR wvNetLocalFilter = WV_NET_NONE;     /* Available event filter */LOCAL ULONG wvNetEventId;       /* Event identifier: see wvNetLib.h */#endif    /* INCLUDE_WVNET */#endif/* globals */unsigned long (*pTcpRandHook)(void) = (unsigned long (*)(void))random;/********************************************************************************* tcpRandHookAdd - Changes pTcpRandHook to a user defined functioned** The user supplies a random number generator to tcp_init via pTcpRandHook.** RETURNS: OK if the function pointer is not null.*/int tcpRandHookAdd    (    FUNCPTR pTcpRandFunc    )    {    if (pTcpRandFunc != NULL)	{        pTcpRandHook = (unsigned long (*)(void))pTcpRandFunc;	return (OK);	}    else    	return (ERROR);    }/********************************************************************************* tcpRandHookDelete - Changes pTcpRandHook back to the default setting** This routine is not needed.**/void tcpRandHookDelete (void)    {    /*     * XXX     * Since random() returns 31bit random number, the highest bit     * is not set, therefore casting unsigned long will not affect     * against caller badly.         */    pTcpRandHook = (unsigned long (*)(void))random;	/* XXX */    }/* * Tcp initialization */voidtcp_init(){#ifdef WV_INSTRUMENTATION#ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */    WV_NET_MARKER_0 (NET_AUX_EVENT, WV_NET_VERBOSE, 39, 9,                     WV_NETEVENT_TCPINIT_START)#endif  /* INCLUDE_WVNET */#endif	tcp_iss = pTcpRandHook();        LIST_INIT(&tcb);        tcbinfo.listhead = &tcb;        tcbinfo.hashbase = hashinit(tcp_pcbhashsize, MT_PCB, &tcbinfo.hashmask);	if (max_protohdr < sizeof(struct tcpiphdr))		max_protohdr = sizeof(struct tcpiphdr);	if (max_linkhdr + sizeof(struct tcpiphdr) > CL_SIZE_128)            {#ifdef WV_INSTRUMENTATION#ifdef INCLUDE_WVNET    /* WV_NET_EMERGENCY event */        WV_NET_MARKER_0 (NET_AUX_EVENT, WV_NET_EMERGENCY, 30, 1,                         WV_NETEVENT_TCPINIT_HDRPANIC)#endif  /* INCLUDE_WVNET */#endif            panic("tcp_init");            }}/* * Create template to be used to send tcp packets on a connection. * Call after host entry created, allocates an mbuf and fills * in a skeletal tcp/ip header, minimizing the amount of work * necessary when the connection is used. */struct mbuf *tcp_template(tp)	struct tcpcb *tp;{	register struct inpcb *inp = tp->t_inpcb;	register struct mbuf *m;	register struct tcpiphdr *n;	if ((m = tp->t_template) == NULL) {		m = mBufClGet (M_DONTWAIT, MT_HEADER, sizeof (struct tcpiphdr),			       TRUE); 		if (m == NULL)			return (0);		m->m_len = sizeof (struct tcpiphdr);	}	n = mtod (m, struct tcpiphdr *);	n->ti_next = n->ti_prev = 0;	n->ti_x1 = 0;	n->ti_pr = IPPROTO_TCP;	n->ti_len = htons(sizeof (struct tcpiphdr) - sizeof (struct ip));	n->ti_src = inp->inp_laddr;	n->ti_dst = inp->inp_faddr;	n->ti_sport = inp->inp_lport;	n->ti_dport = inp->inp_fport;	n->ti_seq = 0;	n->ti_ack = 0;	n->ti_x2 = 0;	n->ti_off = 5;	n->ti_flags = 0;	n->ti_win = 0;	n->ti_sum = 0;	n->ti_urp = 0;	return (m);}/* * Send a single message to the TCP at address specified by * the given TCP/IP header.  If m == 0, then we make a copy * of the tcpiphdr at ti and send directly to the addressed host. * This is used to force keep alive messages out using the TCP * template for a connection tp->t_template.  If flags are given * then we send a message back to the TCP which originated the * segment ti, and discard the mbuf containing it and any other * attached mbufs. * * In any case the ack and sequence number of the transmitted * segment are as specified by the parameters. */voidtcp_respond(tp, ti, m, ack, seq, flags)	struct tcpcb *tp;	register struct tcpiphdr *ti;	register struct mbuf *m;	tcp_seq ack, seq;	int flags;{	register int tlen;	int win = 0;	struct route *ro = 0;	if (tp) {#ifdef WV_INSTRUMENTATION#ifdef INCLUDE_WVNET    /* WV_NET_NOTICE event */    WV_NET_PORTOUT_EVENT_4 (NET_CORE_EVENT, WV_NET_NOTICE, 20, 2,                            tp->t_inpcb->inp_lport, tp->t_inpcb->inp_fport,                            WV_NETEVENT_TCPRESPOND_START, WV_NET_SEND,                            tp->t_inpcb->inp_socket->so_fd, ack, seq, flags)#endif  /* INCLUDE_WVNET */#endif		win = sbspace(&tp->t_inpcb->inp_socket->so_rcv);		ro = &tp->t_inpcb->inp_route;	}	if (m == 0) {		m = mHdrClGet(M_DONTWAIT, MT_HEADER, CL_SIZE_128, TRUE);		if (m == NULL)			return;#ifdef TCP_COMPAT_42		tlen = 1;#else		tlen = 0;#endif		m->m_data += max_linkhdr;		*mtod(m, struct tcpiphdr *) = *ti;		ti = mtod(m, struct tcpiphdr *);		flags = TH_ACK;	} else {		m_freem(m->m_next);		m->m_next = 0;		m->m_data = (caddr_t)ti;		m->m_len = sizeof (struct tcpiphdr);		tlen = 0;#define xchg(a,b,type) { type t; t=a; a=b; b=t; }		xchg(ti->ti_dst.s_addr, ti->ti_src.s_addr, u_long);		xchg(ti->ti_dport, ti->ti_sport, u_short);#undef xchg	}	ti->ti_len = htons((u_short)(sizeof (struct tcphdr) + tlen));	tlen += sizeof (struct tcpiphdr);	m->m_len = tlen;	m->m_pkthdr.len = tlen;	m->m_pkthdr.rcvif = (struct ifnet *) 0;	ti->ti_next = ti->ti_prev = 0;	ti->ti_x1 = 0;	ti->ti_seq = htonl(seq);	ti->ti_ack = htonl(ack);	ti->ti_x2 = 0;	ti->ti_off = sizeof (struct tcphdr) >> 2;	ti->ti_flags = flags;	if (tp)		ti->ti_win = htons((u_short) (win >> tp->rcv_scale));	else		ti->ti_win = htons((u_short)win);	ti->ti_urp = 0;	ti->ti_sum = 0;	ti->ti_sum = in_cksum(m, tlen);	((struct ip *)ti)->ip_len = tlen;	((struct ip *)ti)->ip_ttl = ip_defttl;	if (tp)	    ((struct ip *)ti)->ip_tos = tp->t_inpcb->inp_ip.ip_tos;	(void) ip_output(m, NULL, ro, 0, NULL);}/* * Create a new TCP control block, making an * empty reassembly queue and hooking it to the argument * protocol control block. */struct tcpcb *tcp_newtcpcb(inp)	struct inpcb *inp;{	register struct tcpcb *tp;	MALLOC(tp, struct tcpcb *, sizeof(*tp), MT_PCB, M_DONTWAIT);	if (tp == NULL)		return ((struct tcpcb *)0);	bzero((char *) tp, sizeof(struct tcpcb));	tp->seg_next = tp->seg_prev = (struct tcpiphdr *)tp;	tp->t_maxseg = tp->t_maxsize = tcp_mssdflt;	tp->t_flags = tcp_do_rfc1323 ? (TF_REQ_SCALE|TF_REQ_TSTMP) : 0;	tp->t_inpcb = inp;	/*	 * Init srtt to TCPTV_SRTTBASE (0), so we can tell that we have no	 * rtt estimate.  Set rttvar so that srtt + 2 * rttvar gives	 * reasonable initial retransmit time.	 */	tp->t_srtt = TCPTV_SRTTBASE;	tp->t_rttvar = tcp_rttdflt * PR_SLOWHZ << 2;	tp->t_rttmin = TCPTV_MIN;	TCPT_RANGESET(tp->t_rxtcur, 	    ((TCPTV_SRTTBASE >> 2) + (TCPTV_SRTTDFLT << 2)) >> 1,	    TCPTV_MIN, TCPTV_REXMTMAX);	tp->snd_cwnd = TCP_MAXWIN << TCP_MAX_WINSHIFT;	tp->snd_ssthresh = TCP_MAXWIN << TCP_MAX_WINSHIFT;	inp->inp_ip.ip_ttl = ip_defttl;	inp->inp_ppcb = (caddr_t)tp;	return (tp);}/* * Drop a TCP connection, reporting * the specified error.  If connection is synchronized, * then send a RST to peer. */struct tcpcb *tcp_drop(tp, error)	register struct tcpcb *tp;	int error;{	struct socket *so = tp->t_inpcb->inp_socket;#ifdef WV_INSTRUMENTATION#ifdef INCLUDE_WVNET    /* WV_NET_INFO event */    WV_NET_PORTOUT_MARKER_1 (NET_AUX_EVENT, WV_NET_INFO, 38, 3,                            tp->t_inpcb->inp_lport, tp->t_inpcb->inp_fport,                            WV_NETEVENT_TCPDROP_START, so->so_fd)#endif  /* INCLUDE_WVNET */#endif	if (TCPS_HAVERCVDSYN(tp->t_state)) {		tp->t_state = TCPS_CLOSED;		(void) tcp_output(tp);		tcpstat.tcps_drops++;	} else		tcpstat.tcps_conndrops++;	if (error == ETIMEDOUT && tp->t_softerror)		error = tp->t_softerror;	so->so_error = error;	return (tcp_close(tp));}/* * Close a TCP control block: *	discard all space held by the tcp