hdroptlen = iphlen + off;
hdroptlen = toff + off;
tcp_input(struct mbuf *m, ...){	struct ip *ip;	struct inpcb *inp;	u_int8_t *optp = NULL;	int optlen = 0;	int len, tlen, off;	struct tcpcb *tp = 0;	int tiflags;	struct socket *so = NULL;	int todrop, acked, ourfinisacked, needoutput = 0;	int hdroptlen = 0;	short ostate = 0;	struct in_addr laddr;	int dropsocket = 0;	int iss = 0;	u_long tiwin;	u_int32_t ts_val, ts_ecr;	int ts_present = 0;	int iphlen;	va_list ap;	struct tcphdr *th;#ifdef INET6	struct in6_addr laddr6;	struct ip6_hdr *ip6 = NULL;#endif /* INET6 */#ifdef IPSEC	struct m_tag *mtag;	struct tdb_ident *tdbi;	struct tdb *tdb;	int error, s;#endif /* IPSEC */	int af;#ifdef TCP_ECN	u_char iptos;#endif	va_start(ap, m);	iphlen = va_arg(ap, int);	va_end(ap);	tcpstat.tcps_rcvtotal++;	/*	 * Before we do ANYTHING, we have to figure out if it's TCP/IPv6 or	 * TCP/IPv4.	 */	switch (mtod(m, struct ip *)->ip_v) {#ifdef INET6	case 6:		af = AF_INET6;		break;#endif	case 4:		af = AF_INET;		break;	default:		m_freem(m);		return;	/*EAFNOSUPPORT*/	}	/*	 * Get IP and TCP header together in first mbuf.	 * Note: IP leaves IP header in first mbuf.	 */	switch (af) {	case AF_INET:#ifdef DIAGNOSTIC		if (iphlen < sizeof(struct ip)) {			m_freem(m);			return;		}#endif /* DIAGNOSTIC */		if (iphlen > sizeof(struct ip)) {#if 0	/*XXX*/			ip_stripoptions(m, (struct mbuf *)0);			iphlen = sizeof(struct ip);#else			m_freem(m);			return;#endif		}		break;#ifdef INET6	case AF_INET6:#ifdef DIAGNOSTIC		if (iphlen < sizeof(struct ip6_hdr)) {			m_freem(m);			return;		}#endif /* DIAGNOSTIC */		if (iphlen > sizeof(struct ip6_hdr)) {#if 0 /*XXX*/			ipv6_stripoptions(m, iphlen);			iphlen = sizeof(struct ip6_hdr);#else			m_freem(m);			return;#endif		}		break;#endif	default:		m_freem(m);		return;	}	if (m->m_len < iphlen + sizeof(struct tcphdr)) {		m = m_pullup2(m, iphlen + sizeof(struct tcphdr));		if (m == NULL) {			tcpstat.tcps_rcvshort++;			return;		}	}	ip = NULL;#ifdef INET6	ip6 = NULL;#endif	switch (af) {	case AF_INET:	    {		struct tcpiphdr *ti;		ip = mtod(m, struct ip *);#if 1		tlen = m->m_pkthdr.len - iphlen;#else		tlen = ((struct ip *)ti)->ip_len;#endif		ti = mtod(m, struct tcpiphdr *);#ifdef TCP_ECN		/* save ip_tos before clearing it for checksum */		iptos = ip->ip_tos;#endif		/*		 * Checksum extended TCP header and data.		 */		len = sizeof(struct ip) + tlen;		bzero(ti->ti_x1, sizeof ti->ti_x1);		ti->ti_len = (u_int16_t)tlen;		HTONS(ti->ti_len);		if ((m->m_pkthdr.csum & M_TCP_CSUM_IN_OK) == 0) {			if (m->m_pkthdr.csum & M_TCP_CSUM_IN_BAD) {				tcpstat.tcps_inhwcsum++;				tcpstat.tcps_rcvbadsum++;				goto drop;			}			if ((ti->ti_sum = in_cksum(m, len)) != 0) {				tcpstat.tcps_rcvbadsum++;				goto drop;			}		} else {			m->m_pkthdr.csum &= ~M_TCP_CSUM_IN_OK;			tcpstat.tcps_inhwcsum++;		}		break;	    }#ifdef INET6	case AF_INET6:		ip6 = mtod(m, struct ip6_hdr *);		tlen = m->m_pkthdr.len - iphlen;#ifdef TCP_ECN		iptos = (ntohl(ip6->ip6_flow) >> 20) & 0xff;#endif		/* Be proactive about malicious use of IPv4 mapped address */		if (IN6_IS_ADDR_V4MAPPED(&ip6->ip6_src) ||		    IN6_IS_ADDR_V4MAPPED(&ip6->ip6_dst)) {			/* XXX stat */			goto drop;		}		/*		 * Be proactive about unspecified IPv6 address in source.		 * As we use all-zero to indicate unbounded/unconnected pcb,		 * unspecified IPv6 address can be used to confuse us.		 *		 * Note that packets with unspecified IPv6 destination is		 * already dropped in ip6_input.		 */		if (IN6_IS_ADDR_UNSPECIFIED(&ip6->ip6_src)) {			/* XXX stat */			goto drop;		}		/*		 * Checksum extended TCP header and data.		 */		if (in6_cksum(m, IPPROTO_TCP, sizeof(struct ip6_hdr), tlen)) {			tcpstat.tcps_rcvbadsum++;			goto drop;		}		break;#endif	}#endif /* TUBA_INCLUDE */	th = (struct tcphdr *)(mtod(m, caddr_t) + iphlen);	/*	 * Check that TCP offset makes sense,	 * pull out TCP options and adjust length.		XXX	 */	off = th->th_off << 2;	if (off < sizeof(struct tcphdr) || off > tlen) {		tcpstat.tcps_rcvbadoff++;		goto drop;	}	tlen -= off;	if (off > sizeof(struct tcphdr)) {		if (m->m_len < iphlen + off) {			if ((m = m_pullup2(m, iphlen + off)) == NULL) {				tcpstat.tcps_rcvshort++;				return;			}			switch (af) {			case AF_INET:				ip = mtod(m, struct ip *);				break;#ifdef INET6			case AF_INET6:				ip6 = mtod(m, struct ip6_hdr *);				break;#endif			}			th = (struct tcphdr *)(mtod(m, caddr_t) + iphlen);		}		optlen = off - sizeof(struct tcphdr);		optp = mtod(m, u_int8_t *) + iphlen + sizeof(struct tcphdr);		/*		 * Do quick retrieval of timestamp options ("options		 * prediction?").  If timestamp is the only option and it's		 * formatted as recommended in RFC 1323 appendix A, we		 * quickly get the values now and not bother calling		 * tcp_dooptions(), etc.		 */		if ((optlen == TCPOLEN_TSTAMP_APPA ||		     (optlen > TCPOLEN_TSTAMP_APPA &&			optp[TCPOLEN_TSTAMP_APPA] == TCPOPT_EOL)) &&		     *(u_int32_t *)optp == htonl(TCPOPT_TSTAMP_HDR) &&		     (th->th_flags & TH_SYN) == 0) {			ts_present = 1;			ts_val = ntohl(*(u_int32_t *)(optp + 4));			ts_ecr = ntohl(*(u_int32_t *)(optp + 8));			optp = NULL;	/* we've parsed the options */		}	}	tiflags = th->th_flags;	/*	 * Convert TCP protocol specific fields to host format.	 */	NTOHL(th->th_seq);	NTOHL(th->th_ack);	NTOHS(th->th_win);	NTOHS(th->th_urp);	/*	 * Locate pcb for segment.	 */findpcb:	switch (af) {#ifdef INET6	case AF_INET6:		inp = in6_pcbhashlookup(&tcbtable, &ip6->ip6_src, th->th_sport,		    &ip6->ip6_dst, th->th_dport);		break;#endif	case AF_INET:		inp = in_pcbhashlookup(&tcbtable, ip->ip_src, th->th_sport,		    ip->ip_dst, th->th_dport);		break;	}	if (inp == 0) {		++tcpstat.tcps_pcbhashmiss;		switch (af) {#ifdef INET6		case AF_INET6:			inp = in_pcblookup(&tcbtable, &ip6->ip6_src,			    th->th_sport, &ip6->ip6_dst, th->th_dport,			    INPLOOKUP_WILDCARD | INPLOOKUP_IPV6);			break;#endif /* INET6 */		case AF_INET:			inp = in_pcblookup(&tcbtable, &ip->ip_src, th->th_sport,			    &ip->ip_dst, th->th_dport, INPLOOKUP_WILDCARD);			break;		}		/*		 * If the state is CLOSED (i.e., TCB does not exist) then		 * all data in the incoming segment is discarded.		 * If the TCB exists but is in CLOSED state, it is embryonic,		 * but should either do a listen or a connect soon.		 */		if (inp == 0) {			++tcpstat.tcps_noport;			goto dropwithreset_ratelim;		}	}	tp = intotcpcb(inp);	if (tp == 0)		goto dropwithreset_ratelim;	if (tp->t_state == TCPS_CLOSED)		goto drop;	/* Unscale the window into a 32-bit value. */	if ((tiflags & TH_SYN) == 0)		tiwin = th->th_win << tp->snd_scale;	else		tiwin = th->th_win;	so = inp->inp_socket;	if (so->so_options & (SO_DEBUG|SO_ACCEPTCONN)) {		if (so->so_options & SO_DEBUG) {			ostate = tp->t_state;			switch (af) {#ifdef INET6			case AF_INET6:				tcp_saveti6 = *(mtod(m, struct tcpipv6hdr *));				break;#endif			case AF_INET:				tcp_saveti = *(mtod(m, struct tcpiphdr *));				break;			}		}		if (so->so_options & SO_ACCEPTCONN) {			struct socket *so1;#ifdef INET6			/*			 * If deprecated address is forbidden,			 * we do not accept SYN to deprecated interface			 * address to prevent any new inbound connection from			 * getting established.  So drop the SYN packet.			 * When we do not accept SYN, we send a TCP RST,			 * with deprecated source address (instead of dropping			 * it).  We compromise it as it is much better for peer			 * to send a RST, and RST will be the final packet			 * for the exchange.			 *			 * If we do not forbid deprecated addresses, we accept			 * the SYN packet.  RFC2462 does not suggest dropping			 * SYN in this case.			 * If we decipher RFC2462 5.5.4, it says like this:			 * 1. use of deprecated addr with existing			 *    communication is okay - "SHOULD continue to be			 *    used"			 * 2. use of it with new communication:			 *   (2a) "SHOULD NOT be used if alternate address			 *        with sufficient scope is available"			 *   (2b) nothing mentioned otherwise.			 * Here we fall into (2b) case as we have no choice in			 * our source address selection - we must obey the peer.			 *			 * The wording in RFC2462 is confusing, and there are			 * multiple description text for deprecated address			 * handling - worse, they are not exactly the same.			 * I believe 5.5.4 is the best one, so we follow 5.5.4.			 */			if (ip6 && !ip6_use_deprecated) {				struct in6_ifaddr *ia6;				if ((ia6 = in6ifa_ifpwithaddr(m->m_pkthdr.rcvif, &ip6->ip6_dst)) &&				    (ia6->ia6_flags & IN6_IFF_DEPRECATED)) {					tp = NULL;					goto dropwithreset;				}			}#endif			so1 = sonewconn(so, 0);			if (so1 == NULL) {				tcpdropoldhalfopen(tp, th->th_dport);				so1 = sonewconn(so, 0);				if (so1 == NULL)					goto drop;			}			so = so1;			/*			 * This is ugly, but ....			 *			 * Mark socket as temporary until we're			 * committed to keeping it.  The code at			 * ``drop'' and ``dropwithreset'' check the			 * flag dropsocket to see if the temporary			 * socket created here should be discarded.			 * We mark the socket as discardable until			 * we're committed to it below in TCPS_LISTEN.			 */			dropsocket++;#ifdef IPSEC			/*			 * We need to copy the required security levels			 * from the old pcb. Ditto for any other			 * IPsec-related information.			 */			{			  struct inpcb *newinp = (struct inpcb *)so->so_pcb;			  bcopy(inp->inp_seclevel, newinp->inp_seclevel,				sizeof(inp->inp_seclevel));			  newinp->inp_secrequire = inp->inp_secrequire;			  if (inp->inp_ipo != NULL) {				  newinp->inp_ipo = inp->inp_ipo;				  inp->inp_ipo->ipo_ref_count++;			  }			  if (inp->inp_ipsec_remotecred != NULL) {				  newinp->inp_ipsec_remotecred = inp->inp_ipsec_remotecred;				  inp->inp_ipsec_remotecred->ref_count++;			  }			  if (inp->inp_ipsec_remoteauth != NULL) {				  newinp->inp_ipsec_remoteauth				      = inp->inp_ipsec_remoteauth;				  inp->inp_ipsec_remoteauth->ref_count++;			  }			}#endif /* IPSEC */#ifdef INET6			/*			 * inp still has the OLD in_pcb stuff, set the			 * v6-related flags on the new guy, too.   This is			 * done particularly for the case where an AF_INET6			 * socket is bound only to a port, and a v4 connection			 * comes in on that port.			 * we also copy the flowinfo from the original pcb			 * to the new one.			 */			{			  int flags = inp->inp_flags;			  struct inpcb *oldinpcb = inp;			  inp = (struct inpcb *)so->so_pcb;			  inp->inp_flags |= (flags & INP_IPV6);			  if ((inp->inp_flags & INP_IPV6) != 0) {			    inp->inp_ipv6.ip6_hlim =			      oldinpcb->inp_ipv6.ip6_hlim;			    inp->inp_ipv6.ip6_flow =			      oldinpcb->inp_ipv6.ip6_flow;			  }			}#else /* INET6 */			inp = (struct inpcb *)so->so_pcb;#endif /* INET6 */			inp->inp_lport = th->th_dport;			switch (af) {#ifdef INET6			case AF_INET6:				inp->inp_laddr6 = ip6->ip6_dst;				/*inp->inp_options = ip6_srcroute();*/ /* soon. */				/*				 * still need to tweak outbound options				 * processing to include this mbuf in				 * the right place and put the correct				 * NextHdr values in the right places.				 * XXX  rja				 */				break;#endif /* INET6 */			case AF_INET:				inp->inp_laddr = ip->ip_dst;				inp->inp_options = ip_srcroute();				break;			}			in_pcbrehash(inp);			tp = intotcpcb(inp);			tp->t_state = TCPS_LISTEN;			/* Compute proper scaling value from buffer space */			tcp_rscale(tp, so->so_rcv.sb_hiwat);		}	}#ifdef IPSEC	/* Find most recent IPsec tag */	mtag = m_tag_find(m, PACKET_TAG_IPSEC_IN_DONE, NULL);        s = splnet();	if (mtag != NULL) {		tdbi = (struct tdb_ident *)(mtag + 1);	        tdb = gettdb(tdbi->spi, &tdbi->dst, tdbi->proto);	} else		tdb = NULL;	ipsp_spd_lookup(m, af, iphlen, &error, IPSP_DIRECTION_IN,	    tdb, inp);	if (error) {		splx(s);		goto drop;	}	/* Latch SA */	if (inp->inp_tdb_in != tdb) {		if (tdb) {		        tdb_add_inp(tdb, inp, 1);			if (inp->inp_ipo == NULL) {				inp->inp_ipo = ipsec_add_policy(inp, af,				    IPSP_DIRECTION_OUT);				if (inp->inp_ipo == NULL) {					splx(s);					goto drop;				}			}			if (inp->inp_ipo->ipo_dstid == NULL &&			    tdb->tdb_srcid != NULL) {				inp->inp_ipo->ipo_dstid = tdb->tdb_srcid;				tdb->tdb_srcid->ref_count++;			}			if (inp->inp_ipsec_remotecred == NULL &&			    tdb->tdb_remote_cred != NULL) {				inp->inp_ipsec_remotecred =				    tdb->tdb_remote_cred;				tdb->tdb_remote_cred->ref_count++;			}			if (inp->inp_ipsec_remoteauth == NULL &&			    tdb->tdb_remote_auth != NULL) {				inp->inp_ipsec_remoteauth =				    tdb->tdb_remote_auth;				tdb->tdb_remote_auth->ref_count++;			}		} else { /* Just reset */		        TAILQ_REMOVE(&inp->inp_tdb_in->tdb_inp_in, inp,				     inp_tdb_in_next);			inp->inp_tdb_in = NULL;		}	}        splx(s);#endif /* IPSEC */	/*	 * Segment received on connection.	 * Reset idle time and keep-alive timer.	 */	tp->t_rcvtime = tcp_now;	if (tp->t_state != TCPS_SYN_RECEIVED)		TCP_TIMER_ARM(tp, TCPT_KEEP, tcp_keepidle);#ifdef TCP_SACK	if (!tp->sack_disable)		tcp_del_sackholes(tp, th); /* Delete stale SACK holes */#endif /* TCP_SACK */	/*	 * Process options if not in LISTEN state,	 * else do it below (after getting remote address).	 */	if (optp && tp->t_state != TCPS_LISTEN)		tcp_dooptions(tp, optp, optlen, th,			&ts_present, &ts_val, &ts_ecr);#ifdef TCP_SACK	if (!tp->sack_disable) {		tp->rcv_laststart = th->th_seq; /* last rec'vd segment*/		tp->rcv_lastend = th->th_seq + tlen;	}#endif /* TCP_SACK */#ifdef TCP_ECN	/* if congestion experienced, set ECE bit in subsequent packets. */	if ((iptos & IPTOS_ECN_MASK) == IPTOS_ECN_CE) {		tp->t_flags |= TF_RCVD_CE;		tcpstat.tcps_ecn_rcvce++;	}#endif	/*	 * Header prediction: check for the two common cases	 * of a uni-directional data xfer.  If the packet has	 * no control flags, is in-sequence, the window didn't	 * change and we're not retransmitting, it's a	 * candidate.  If the length is zero and the ack moved	 * forward, we're the sender side of the xfer.  Just	 * free the data acked & wake any higher level process	 * that was blocked waiting for space.  If the length	 * is non-zero and the ack didn't move, we're the	 * receiver side.  If we're getting packets in-order	 * (the reassembly queue is empty), add the data to	 * the socket buffer and note that we need a delayed ack.	 */	if (tp->t_state == TCPS_ESTABLISHED &&#ifdef TCP_ECN	    (tiflags & (TH_SYN|TH_FIN|TH_RST|TH_URG|TH_ECE|TH_CWR|TH_ACK)) == TH_ACK &&#else	    (tiflags & (TH_SYN|TH_FIN|TH_RST|TH_URG|TH_ACK)) == TH_ACK &&#endif	    (!ts_present || TSTMP_GEQ(ts_val, tp->ts_recent)) &&	    th->th_seq == tp->rcv_nxt &&	    tiwin && tiwin == tp->snd_wnd &&	    tp->snd_nxt == tp->snd_max) {		/*		 * If last ACK falls within this segment's sequence numbers,		 *  record the timestamp.		 * Fix from Braden, see Stevens p. 870		 */		if (ts_present && SEQ_LEQ(th->th_seq, tp->last_ack_sent)) {			tp->ts_recent_age = tcp_now;			tp->ts_recent = ts_val;		}		if (tlen == 0) {			if (SEQ_GT(th->th_ack, tp->snd_una) &&			    SEQ_LEQ(th->th_ack, tp->snd_max) &&			    tp->snd_cwnd >= tp->snd_wnd &&			    tp->t_dupacks == 0) {				/*				 * this is a pure ack for outstanding data.				 */				++tcpstat.tcps_predack;				if (ts_present)					tcp_xmit_timer(tp, tcp_now-ts_ecr+1);				else if (tp->t_rtttime &&					    SEQ_GT(th->th_ack, tp->t_rtseq))					tcp_xmit_timer(tp,					    tcp_now - tp->t_rtttime);				acked = th->th_ack - tp->snd_una;				tcpstat.tcps_rcvackpack++;				tcpstat.tcps_rcvackbyte += acked;				ND6_HINT(tp);				sbdrop(&so->so_snd, acked);				tp->snd_una = th->th_ack;#if defined(TCP_SACK) || defined(TCP_ECN)				/*				 * We want snd_last to track snd_una so				 * as to avoid sequence wraparound problems				 * for very large transfers.				 */#ifdef TCP_ECN				if (SEQ_GT(tp->snd_una, tp->snd_last))#endif				tp->snd_last = tp->snd_una;#endif /* TCP_SACK */#if defined(TCP_SACK) && defined(TCP_FACK)				tp->snd_fack = tp->snd_una;				tp->retran_data = 0;#endif /* TCP_FACK */				m_freem(m);				/*				 * If all outstanding data are acked, stop				 * retransmit timer, otherwise restart timer				 * using current (possibly backed-off) value.				 * If process is waiting for space,				 * wakeup/selwakeup/signal.  If data				 * are ready to send, let tcp_output				 * decide between more output or persist.				 */				if (tp->snd_una == tp->snd_max)					TCP_TIMER_DISARM(tp, TCPT_REXMT);				else if (TCP_TIMER_ISARMED(tp, TCPT_PERSIST) == 0)					TCP_TIMER_ARM(tp, TCPT_REXMT, tp->t_rxtcur);				if (sb_notify(&so->so_snd))					sowwakeup(so);				if (so->so_snd.sb_cc)					(void) tcp_output(tp);				return;			}		} else if (th->th_ack == tp->snd_una &&		    tp->segq.lh_first == NULL &&		    tlen <= sbspace(&so->so_rcv)) {			/*			 * This is a pure, in-sequence data packet			 * with nothing on the reassembly queue and			 * we have enough buffer space to take it.			 */#ifdef TCP_SACK			/* Clean receiver SACK report if present */			if (!tp->sack_disable && tp->rcv_numsacks)				tcp_clean_sackreport(tp);#endif /* TCP_SACK */			++tcpstat.tcps_preddat;			tp->rcv_nxt += tlen;			tcpstat.tcps_rcvpack++;			tcpstat.tcps_rcvbyte += tlen;			ND6_HINT(tp);			/*			 * Drop TCP, IP headers and TCP options then add data			 * to socket buffer.			 */			if (so->so_state & SS_CANTRCVMORE)				m_freem(m);			else {				m_adj(m, iphlen + off);				sbappendstream(&so->so_rcv, m);			}			sorwakeup(so);			TCP_SETUP_ACK(tp, tiflags);			if (tp->t_flags & TF_ACKNOW)				(void) tcp_output(tp);			return;		}	}	/*	 * Compute mbuf offset to TCP data segment.	 */	hdroptlen = iphlen + off;	/*	 * Calculate amount of space in receive window,	 * and then do TCP input processing.	 * Receive window is amount of space in rcv queue,	 * but not less than advertised window.	 */	{ int win;	win = sbspace(&so->so_rcv);	if (win < 0)		win = 0;	tp->rcv_wnd = imax(win, (int)(tp->rcv_adv - tp->rcv_nxt));	}	switch (tp->t_state) {	/*	 * If the state is LISTEN then ignore segment if it contains an RST.	 * If the segment contains an ACK then it is bad and send a RST.	 * If it does not contain a SYN then it is not interesting; drop it.	 * If it is from this socket, drop it, it must be forged.	 * Don't bother responding if the destination was a broadcast.	 * Otherwise initialize tp->rcv_nxt, and tp->irs, select an initial	 * tp->iss, and send a segment:	 *     <SEQ=ISS><ACK=RCV_NXT><CTL=SYN,ACK>	 * Also initialize tp->snd_nxt to tp->iss+1 and tp->snd_una to tp->iss.	 * Fill in remote peer address fields if not previously specified.	 * Enter SYN_RECEIVED state, and process any other fields of this	 * segment in this state.	 */	case TCPS_LISTEN: {		struct mbuf *am;		struct sockaddr_in *sin;#ifdef INET6		struct sockaddr_in6 *sin6;#endif /* INET6 */		if (tiflags & TH_RST)			goto drop;		if (tiflags & TH_ACK)			goto dropwithreset;		if ((tiflags & TH_SYN) == 0)			goto drop;		if (th->th_dport == th->th_sport) {			switch (af) {#ifdef INET6			case AF_INET6:				if (IN6_ARE_ADDR_EQUAL(&ip6->ip6_src,				    &ip6->ip6_dst))					goto drop;				break;#endif /* INET6 */			case AF_INET:				if (ip->ip_dst.s_addr == ip->ip_src.s_addr)					goto drop;				break;			}		}		/*		 * RFC1122 4.2.3.10, p. 104: discard bcast/mcast SYN		 */		if (m->m_flags & (M_BCAST|M_MCAST))			goto drop;		switch (af) {#ifdef INET6		case AF_INET6:			if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst))				goto drop;			break;#endif /* INET6 */		case AF_INET:			if (IN_MULTICAST(ip->ip_dst.s_addr) ||			    in_broadcast(ip->ip_dst, m->m_pkthdr.rcvif))				goto drop;			break;		}		am = m_get(M_DONTWAIT, MT_SONAME);	/* XXX */		if (am == NULL)			goto drop;		switch (af) {#ifdef INET6		case AF_INET6:			/*			 * This is probably the place to set the tp->pf value.			 * (Don't forget to do it in the v4 code as well!)			 *			 * Also, remember to blank out things like flowlabel, or			 * set flowlabel for accepted sockets in v6.			 *			 * FURTHERMORE, this is PROBABLY the place where the			 * whole business of key munging is set up for passive			 * connections.			 */			am->m_len = sizeof(struct sockaddr_in6);			sin6 = mtod(am, struct sockaddr_in6 *);			bzero(sin6, sizeof(*sin6));			sin6->sin6_family = AF_INET6;			sin6->sin6_len = sizeof(struct sockaddr_in6);			sin6->sin6_addr = ip6->ip6_src;			sin6->sin6_port = th->th_sport;			sin6->sin6_flowinfo = htonl(0x0fffffff) &				inp->inp_ipv6.ip6_flow;			laddr6 = inp->inp_laddr6;			if (IN6_IS_ADDR_UNSPECIFIED(&inp->inp_laddr6))				inp->inp_laddr6 = ip6->ip6_dst;			/* This is a good optimization. */			if (in6_pcbconnect(inp, am)) {				inp->inp_laddr6 = laddr6;				(void) m_free(am);				goto drop;			}			break;#endif		case AF_INET:			/* drop IPv4 packet to AF_INET6 socket */			if (inp->inp_flags & INP_IPV6) {				(void) m_free(am);				goto drop;			}			am->m_len = sizeof(struct sockaddr_in);			sin = mtod(am, struct sockaddr_in *);			bzero(sin, sizeof(*sin));			sin->sin_family = AF_INET;			sin->sin_len = sizeof(*sin);			sin->sin_addr = ip->ip_src;			sin->sin_port = th->th_sport;			bzero((caddr_t)sin->sin_zero, sizeof(sin->sin_zero));			laddr = inp->inp_laddr;			if (inp->inp_laddr.s_addr == INADDR_ANY)				inp->inp_laddr = ip->ip_dst;			if (in_pcbconnect(inp, am)) {				inp->inp_laddr = laddr;				(void) m_free(am);				goto drop;			}			break;		}		(void) m_free(am);		tp->t_template = tcp_template(tp);		if (tp->t_template == 0) {			tp = tcp_drop(tp, ENOBUFS);			dropsocket = 0;		/* socket is already gone */			goto drop;		}		if (optp)			tcp_dooptions(tp, optp, optlen, th,				&ts_present, &ts_val, &ts_ecr);#ifdef TCP_SACK		/*		 * If peer did not send a SACK_PERMITTED option (i.e., if		 * tcp_dooptions() did not set TF_SACK_PERMIT), set                 * sack_disable to 1 if it is currently 0.                 */                if (!tp->sack_disable)                        if ((tp->t_flags & TF_SACK_PERMIT) == 0)                                tp->sack_disable = 1;#endif		if (iss)			tp->iss = iss;		else {#ifdef TCP_COMPAT_42			tcp_iss += TCP_ISSINCR/2;			tp->iss = tcp_iss;#else /* TCP_COMPAT_42 */			tp->iss = tcp_rndiss_next();#endif /* !TCP_COMPAT_42 */		}		tp->irs = th->th_seq;		tcp_sendseqinit(tp);#if defined (TCP_SACK) || defined(TCP_ECN)		tp->snd_last = tp->snd_una;#endif /* TCP_SACK */#if defined(TCP_SACK) && defined(TCP_FACK)		tp->snd_fack = tp->snd_una;		tp->retran_data = 0;		tp->snd_awnd = 0;#endif /* TCP_FACK */#ifdef TCP_ECN		/*		 * if both ECE and CWR flag bits are set, peer is ECN capable.		 */		if (tcp_do_ecn &&		    (tiflags & (TH_ECE|TH_CWR)) == (TH_ECE|TH_CWR)) {			tp->t_flags |= TF_ECN_PERMIT;			tcpstat.tcps_ecn_accepts++;		}#endif		tcp_rcvseqinit(tp);		tp->t_flags |= TF_ACKNOW;		tp->t_state = TCPS_SYN_RECEIVED;		TCP_TIMER_ARM(tp, TCPT_KEEP, tcptv_keep_init);		dropsocket = 0;		/* committed to socket */		tcpstat.tcps_accepts++;		goto trimthenstep6;		}	/*	 * If the state is SYN_RECEIVED:	 * 	if seg contains SYN/ACK, send an RST.	 *	if seg contains an ACK, but not for our SYN/ACK, send an RST	 */	case TCPS_SYN_RECEIVED:		if (tiflags & TH_ACK) {			if (tiflags & TH_SYN) {				tcpstat.tcps_badsyn++;				goto dropwithreset;			}			if (SEQ_LEQ(th->th_ack, tp->snd_una) ||			    SEQ_GT(th->th_ack, tp->snd_max))				goto dropwithreset;		}		break;	/*	 * If the state is SYN_SENT:	 *	if seg contains an ACK, but not for our SYN, drop the input.	 *	if seg contains a RST, then drop the connection.	 *	if seg does not contain SYN, then drop it.	 * Otherwise this is an acceptable SYN segment	 *	initialize tp->rcv_nxt and tp->irs	 *	if seg contains ack then advance tp->snd_una	 *	if SYN has been acked change to ESTABLISHED else SYN_RCVD state	 *	arrange for segment to be acked (eventually)	 *	continue processing rest of data/controls, beginning with URG	 */	case TCPS_SYN_SENT:		if ((tiflags & TH_ACK) &&		    (SEQ_LEQ(th->th_ack, tp->iss) ||		     SEQ_GT(th->th_ack, tp->snd_max)))			goto dropwithreset;		if (tiflags & TH_RST) {#ifdef TCP_ECN			/* if ECN is enabled, fall back to non-ecn at rexmit */			if (tcp_do_ecn && !(tp->t_flags & TF_DISABLE_ECN))				goto drop;#endif			if (tiflags & TH_ACK)				tp = tcp_drop(tp, ECONNREFUSED);			goto drop;		}		if ((tiflags & TH_SYN) == 0)			goto drop;		if (tiflags & TH_ACK) {			tp->snd_una = th->th_ack;			if (SEQ_LT(tp->snd_nxt, tp->snd_una))				tp->snd_nxt = tp->snd_una;		}		TCP_TIMER_DISARM(tp, TCPT_REXMT);		tp->irs = th->th_seq;		tcp_rcvseqinit(tp);		tp->t_flags |= TF_ACKNOW;#ifdef TCP_SACK                /*                 * If we've sent a SACK_PERMITTED option, and the peer                 * also replied with one, then TF_SACK_PERMIT should have                 * been set in tcp_dooptions().  If it was not, disable SACKs.                 */                if (!tp->sack_disable)                        if ((tp->t_flags & TF_SACK_PERMIT) == 0)                                tp->sack_disable = 1;#endif#ifdef TCP_ECN		/*		 * if ECE is set but CWR is not set for SYN-ACK, or		 * both ECE and CWR are set for simultaneous open,		 * peer is ECN capable.		 */		if (tcp_do_ecn) {			if ((tiflags & (TH_ACK|TH_ECE|TH_CWR))			    == (TH_ACK|TH_ECE) ||			    (tiflags & (TH_ACK|TH_ECE|TH_CWR))			    == (TH_ECE|TH_CWR)) {				tp->t_flags |= TF_ECN_PERMIT;				tiflags &= ~(TH_ECE|TH_CWR);				tcpstat.tcps_ecn_accepts++;			}		}#endif		if (tiflags & TH_ACK && SEQ_GT(tp->snd_una, tp->iss)) {			tcpstat.tcps_connects++;			soisconnected(so);			tp->t_state = TCPS_ESTABLISHED;			/* Do window scaling on this connection? */			if ((tp->t_flags & (TF_RCVD_SCALE|TF_REQ_SCALE)) ==				(TF_RCVD_SCALE|TF_REQ_SCALE)) {				tp->snd_scale = tp->requested_s_scale;				tp->rcv_scale = tp->request_r_scale;			}			(void) tcp_reass(tp, (struct tcphdr *)0,				(struct mbuf *)0, &tlen);			/*			 * if we didn't have to retransmit the SYN,			 * use its rtt as our initial srtt & rtt var.			 */			if (tp->t_rtttime)				tcp_xmit_timer(tp, tcp_now - tp->t_rtttime);			/*			 * Since new data was acked (the SYN), open the			 * congestion window by one MSS.  We do this			 * here, because we won't go through the normal			 * ACK processing below.  And since this is the			 * start of the connection, we know we are in			 * the exponential phase of slow-start.			 */			tp->snd_cwnd += tp->t_maxseg;		} else			tp->t_state = TCPS_SYN_RECEIVED;trimthenstep6:		/*		 * Advance th->th_seq to correspond to first data byte.		 * If data, trim to stay within window,		 * dropping FIN if necessary.		 */		th->th_seq++;		if (tlen > tp->rcv_wnd) {			todrop = tlen - tp->rcv_wnd;			m_adj(m, -todrop);			tlen = tp->rcv_wnd;			tiflags &= ~TH_FIN;			tcpstat.tcps_rcvpackafterwin++;			tcpstat.tcps_rcvbyteafterwin += todrop;		}		tp->snd_wl1 = th->th_seq - 1;		tp->rcv_up = th->th_seq;		goto step6;	}	/*	 * States other than LISTEN or SYN_SENT.	 * First check timestamp, if present.	 * Then check that at least some bytes of segment are within	 * receive window.  If segment begins before rcv_nxt,	 * drop leading data (and SYN); if nothing left, just ack.	 *	 * RFC 1323 PAWS: If we have a timestamp reply on this segment	 * and it's less than ts_recent, drop it.	 */	if (ts_present && (tiflags & TH_RST) == 0 && tp->ts_recent &&	    TSTMP_LT(ts_val, tp->ts_recent)) {		/* Check to see if ts_recent is over 24 days old.  */		if ((int)(tcp_now - tp->ts_recent_age) > TCP_PAWS_IDLE) {			/*			 * Invalidate ts_recent.  If this segment updates			 * ts_recent, the age will be reset later and ts_recent			 * will get a valid value.  If it does not, setting			 * ts_recent to zero will at least satisfy the			 * requirement that zero be placed in the timestamp			 * echo reply when ts_recent isn't valid.  The			 * age isn't reset until we get a valid ts_recent			 * because we don't want out-of-order segments to be			 * dropped when ts_recent is old.			 */			tp->ts_recent = 0;		} else {			tcpstat.tcps_rcvduppack++;			tcpstat.tcps_rcvdupbyte += tlen;			tcpstat.tcps_pawsdrop++;			goto dropafterack;		}	}	todrop = tp->rcv_nxt - th->th_seq;	if (todrop > 0) {		if (tiflags & TH_SYN) {			tiflags &= ~TH_SYN;			th->th_seq++;			if (th->th_urp > 1)				th->th_urp--;			else				tiflags &= ~TH_URG;			todrop--;		}		if (todrop > tlen ||		    (todrop == tlen && (tiflags & TH_FIN) == 0)) {			/*			 * Any valid FIN must be to the left of the			 * window.  At this point, FIN must be a			 * duplicate or out-of-sequence, so drop it.			 */			tiflags &= ~TH_FIN;			/*			 * Send ACK to resynchronize, and drop any data,			 * but keep on processing for RST or ACK.			 */			tp->t_flags |= TF_ACKNOW;			tcpstat.tcps_rcvdupbyte += todrop = tlen;			tcpstat.tcps_rcvduppack++;		} else {			tcpstat.tcps_rcvpartduppack++;			tcpstat.tcps_rcvpartdupbyte += todrop;		}		hdroptlen += todrop;	/* drop from head afterwards */		th->th_seq += todrop;		tlen -= todrop;		if (th->th_urp > todrop)			th->th_urp -= todrop;		else {			tiflags &= ~TH_URG;			th->th_urp = 0;		}	}	/*	 * If new data are received on a connection after the	 * user processes are gone, then RST the other end.	 */	if ((so->so_state & SS_NOFDREF) &&	    tp->t_state > TCPS_CLOSE_WAIT && tlen) {		tp = tcp_close(tp);		tcpstat.tcps_rcvafterclose++;		goto dropwithreset;	}	/*	 * If segment ends after window, drop trailing data	 * (and PUSH and FIN); if nothing left, just ACK.	 */	todrop = (th->th_seq + tlen) - (tp->rcv_nxt+tp->rcv_wnd);	if (todrop > 0) {		tcpstat.tcps_rcvpackafterwin++;		if (todrop >= tlen) {			tcpstat.tcps_rcvbyteafterwin += tlen;			/*			 * If a new connection request is received			 * while in TIME_WAIT, drop the old connection			 * and start over if the sequence numbers			 * are above the previous ones.			 */			if (tiflags & TH_SYN &&			    tp->t_state == TCPS_TIME_WAIT &&			    SEQ_GT(th->th_seq, tp->rcv_nxt)) {				iss = tp->snd_nxt + TCP_ISSINCR;				tp = tcp_close(tp);				goto findpcb;			}			/*			 * If window is closed can only take segments at			 * window edge, and have to drop data and PUSH from			 * incoming segments.  Continue processing, but			 * remember to ack.  Otherwise, drop segment			 * and ack.			 */			if (tp->rcv_wnd == 0 && th->th_seq == tp->rcv_nxt) {				tp->t_flags |= TF_ACKNOW;				tcpstat.tcps_rcvwinprobe++;			} else				goto dropafterack;		} else			tcpstat.tcps_rcvbyteafterwin += todrop;		m_adj(m, -todrop);		tlen -= todrop;		tiflags &= ~(TH_PUSH|TH_FIN);	}	/*	 * If last ACK falls within this segment's sequence numbers,	 * record its timestamp.	 * Fix from Braden, see Stevens p. 870	 */	if (ts_present && TSTMP_GEQ(ts_val, tp->ts_recent) &&	    SEQ_LEQ(th->th_seq, tp->last_ack_sent)) {		tp->ts_recent_age = tcp_now;		tp->ts_recent = ts_val;	}	/*	 * If the RST bit is set examine the state:	 *    SYN_RECEIVED STATE:	 *	If passive open, return to LISTEN state.	 *	If active open, inform user that connection was refused.	 *    ESTABLISHED, FIN_WAIT_1, FIN_WAIT2, CLOSE_WAIT STATES:	 *	Inform user that connection was reset, and close tcb.	 *    CLOSING, LAST_ACK, TIME_WAIT STATES	 *	Close the tcb.	 */	if (tiflags & TH_RST) {		if (th->th_seq != tp->last_ack_sent)			goto drop;		switch (tp->t_state) {		case TCPS_SYN_RECEIVED:#ifdef TCP_ECN			/* if ECN is enabled, fall back to non-ecn at rexmit */			if (tcp_do_ecn && !(tp->t_flags & TF_DISABLE_ECN))				goto drop;#endif			so->so_error = ECONNREFUSED;			goto close;		case TCPS_ESTABLISHED:		case TCPS_FIN_WAIT_1:		case TCPS_FIN_WAIT_2:		case TCPS_CLOSE_WAIT:			so->so_error = ECONNRESET;		close:			tp->t_state = TCPS_CLOSED;			tcpstat.tcps_drops++;			tp = tcp_close(tp);			goto drop;		case TCPS_CLOSING:		case TCPS_LAST_ACK:		case TCPS_TIME_WAIT:			tp = tcp_close(tp);			goto drop;		}	}	/*	 * If a SYN is in the window, then this is an	 * error and we send an RST and drop the connection.	 */	if (tiflags & TH_SYN) {		tp = tcp_drop(tp, ECONNRESET);		goto dropwithreset;	}	/*	 * If the ACK bit is off we drop the segment and return.	 */	if ((tiflags & TH_ACK) == 0) {		if (tp->t_flags & TF_ACKNOW)			goto dropafterack;		else			goto drop;	}	/*	 * Ack processing.	 */	switch (tp->t_state) {	/*	 * In SYN_RECEIVED state, the ack ACKs our SYN, so enter	 * ESTABLISHED state and continue processing.	 * The ACK was checked above.	 */	case TCPS_SYN_RECEIVED:		tcpstat.tcps_connects++;		soisconnected(so);		tp->t_state = TCPS_ESTABLISHED;		/* Do window scaling? */		if ((tp->t_flags & (TF_RCVD_SCALE|TF_REQ_SCALE)) ==			(TF_RCVD_SCALE|TF_REQ_SCALE)) {			tp->snd_scale = tp->requested_s_scale;			tp->rcv_scale = tp->request_r_scale;		}		(void) tcp_reass(tp, (struct tcphdr *)0, (struct mbuf *)0,				 &tlen);		tp->snd_wl1 = th->th_seq - 1;		/* fall into ... */	/*	 * In ESTABLISHED state: drop duplicate ACKs; ACK out of range	 * ACKs.  If the ack is in the range	 *	tp->snd_una < th->th_ack <= tp->snd_max	 * then advance tp->snd_una to th->th_ack and drop	 * data from the retransmission queue.  If this ACK reflects	 * more up to date window information we update our window information.	 */	case TCPS_ESTABLISHED:	case TCPS_FIN_WAIT_1:	case TCPS_FIN_WAIT_2:	case TCPS_CLOSE_WAIT:	case TCPS_CLOSING:	case TCPS_LAST_ACK:	case TCPS_TIME_WAIT:#ifdef TCP_ECN		/*		 * if we receive ECE and are not already in recovery phase,		 * reduce cwnd by half but don't slow-start.		 * advance snd_last to snd_max not to reduce cwnd again		 * until all outstanding packets are acked.		 */		if (tcp_do_ecn && (tiflags & TH_ECE)) {			if ((tp->t_flags & TF_ECN_PERMIT) &&			    SEQ_GEQ(tp->snd_una, tp->snd_last)) {				u_int win;				win = min(tp->snd_wnd, tp->snd_cwnd) / tp->t_maxseg;				if (win > 1) {					tp->snd_ssthresh = win / 2 * tp->t_maxseg;					tp->snd_cwnd = tp->snd_ssthresh;					tp->snd_last = tp->snd_max;					tp->t_flags |= TF_SEND_CWR;					tcpstat.tcps_cwr_ecn++;				}			}			tcpstat.tcps_ecn_rcvece++;		}		/*		 * if we receive CWR, we know that the peer has reduced		 * its congestion window.  stop sending ecn-echo.		 */		if ((tiflags & TH_CWR)) {			tp->t_flags &= ~TF_RCVD_CE;			tcpstat.tcps_ecn_rcvcwr++;		}#endif /* TCP_ECN */		if (SEQ_LEQ(th->th_ack, tp->snd_una)) {			/*			 * Duplicate/old ACK processing.			 * Increments t_dupacks:			 *	Pure duplicate (same seq/ack/window, no data)			 * Doesn't affect t_dupacks:			 *	Data packets.			 *	Normal window updates (window opens)			 * Resets t_dupacks:			 *	New data ACKed.			 *	Window shrinks			 *	Old ACK			 */			if (tlen)				break;			/*			 * If we get an old ACK, there is probably packet			 * reordering going on.  Be conservative and reset			 * t_dupacks so that we are less agressive in			 * doing a fast retransmit.			 */			if (th->th_ack != tp->snd_una) {				tp->t_dupacks = 0;				break;			}			if (tiwin == tp->snd_wnd) {				tcpstat.tcps_rcvdupack++;				/*				 * If we have outstanding data (other than				 * a window probe), this is a completely				 * duplicate ack (ie, window info didn't				 * change), the ack is the biggest we've				 * seen and we've seen exactly our rexmt				 * threshhold of them, assume a packet				 * has been dropped and retransmit it.				 * Kludge snd_nxt & the congestion				 * window so we send only this one				 * packet.				 *				 * We know we're losing at the current				 * window size so do congestion avoidance				 * (set ssthresh to half the current window				 * and pull our congestion window back to				 * the new ssthresh).				 *				 * Dup acks mean that packets have left the				 * network (they're now cached at the receiver)				 * so bump cwnd by the amount in the receiver				 * to keep a constant cwnd packets in the				 * network.				 */				if (TCP_TIMER_ISARMED(tp, TCPT_REXMT) == 0)					tp->t_dupacks = 0;#if defined(TCP_SACK) && defined(TCP_FACK)				/*				 * In FACK, can enter fast rec. if the receiver				 * reports a reass. queue longer than 3 segs.				 */				else if (++tp->t_dupacks == tcprexmtthresh ||				    ((SEQ_GT(tp->snd_fack, tcprexmtthresh *				    tp->t_maxseg + tp->snd_una)) &&				    SEQ_GT(tp->snd_una, tp->snd_last))) {#else				else if (++tp->t_dupacks == tcprexmtthresh) {#endif /* TCP_FACK */					tcp_seq onxt = tp->snd_nxt;					u_long win =					    ulmin(tp->snd_wnd, tp->snd_cwnd) /						2 / tp->t_maxseg;#if defined(TCP_SACK) || defined(TCP_ECN)					if (SEQ_LT(th->th_ack, tp->snd_last)){					    	/*						 * False fast retx after						 * timeout.  Do not cut window.						 */						tp->t_dupacks = 0;						goto drop;					}#endif					if (win < 2)						win = 2;					tp->snd_ssthresh = win * tp->t_maxseg;#if defined(TCP_SACK)					tp->snd_last = tp->snd_max;#endif#ifdef TCP_SACK                    			if (!tp->sack_disable) {						TCP_TIMER_DISARM(tp, TCPT_REXMT);						tp->t_rtttime = 0;#ifdef TCP_ECN						tp->t_flags |= TF_SEND_CWR;#endif#if 1 /* TCP_ECN */						tcpstat.tcps_cwr_frecovery++;#endif						tcpstat.tcps_sndrexmitfast++;#if defined(TCP_SACK) && defined(TCP_FACK)						tp->t_dupacks = tcprexmtthresh;						(void) tcp_output(tp);						/*						 * During FR, snd_cwnd is held						 * constant for FACK.						 */						tp->snd_cwnd = tp->snd_ssthresh;#else						/*						 * tcp_output() will send						 * oldest SACK-eligible rtx.						 */						(void) tcp_output(tp);						tp->snd_cwnd = tp->snd_ssthresh+					           tp->t_maxseg * tp->t_dupacks;#endif /* TCP_FACK */						goto drop;					}#endif /* TCP_SACK */					TCP_TIMER_DISARM(tp, TCPT_REXMT);					tp->t_rtttime = 0;					tp->snd_nxt = th->th_ack;					tp->snd_cwnd = tp->t_maxseg;#ifdef TCP_ECN					tp->t_flags |= TF_SEND_CWR;#endif#if 1 /* TCP_ECN */					tcpstat.tcps_cwr_frecovery++;#endif					tcpstat.tcps_sndrexmitfast++;					(void) tcp_output(tp);					tp->snd_cwnd = tp->snd_ssthresh +					    tp->t_maxseg * tp->t_dupacks;					if (SEQ_GT(onxt, tp->snd_nxt))						tp->snd_nxt = onxt;					goto drop;				} else if (tp->t_dupacks > tcprexmtthresh) {#if defined(TCP_SACK) && defined(TCP_FACK)					/*					 * while (awnd < cwnd)					 *         sendsomething();					 */					if (!tp->sack_disable) {						if (tp->snd_awnd < tp->snd_cwnd)							tcp_output(tp);						goto drop;					}#endif /* TCP_FACK */					tp->snd_cwnd += tp->t_maxseg;					(void) tcp_output(tp);					goto drop;				}			} else if (tiwin < tp->snd_wnd) {				/*				 * The window was retracted!  Previous dup				 * ACKs may have been due to packets arriving				 * after the shrunken window, not a missing				 * packet, so play it safe and reset t_dupacks				 */				tp->t_dupacks = 0;			}			break;		}		/*		 * If the congestion window was inflated to account		 * for the other side's cached packets, retract it.		 */#if defined(TCP_SACK)		if (!tp->sack_disable) {			if (tp->t_dupacks >= tcprexmtthresh) {				/* Check for a partial ACK */				if (tcp_sack_partialack(tp, th)) {#if defined(TCP_SACK) && defined(TCP_FACK)					/* Force call to tcp_output */					if (tp->snd_awnd < tp->snd_cwnd)						needoutput = 1;#else					tp->snd_cwnd += tp->t_maxseg;					needoutput = 1;#endif /* TCP_FACK */				} else {					/* Out of fast recovery */					tp->snd_cwnd = tp->snd_ssthresh;					if (tcp_seq_subtract(tp->snd_max,					    th->th_ack) < tp->snd_ssthresh)						tp->snd_cwnd =						   tcp_seq_subtract(tp->snd_max,					           th->th_ack);					tp->t_dupacks = 0;#if defined(TCP_SACK) && defined(TCP_FACK)					if (SEQ_GT(th->th_ack, tp->snd_fack))						tp->snd_fack = th->th_ack;#endif /* TCP_FACK */				}			}		} else {			if (tp->t_dupacks >= tcprexmtthresh &&			    !tcp_newreno(tp, th)) {				/* Out of fast recovery */				tp->snd_cwnd = tp->snd_ssthresh;				if (tcp_seq_subtract(tp->snd_max, th->th_ack) <			  	    tp->snd_ssthresh)					tp->snd_cwnd =					    tcp_seq_subtract(tp->snd_max,					    th->th_ack);				tp->t_dupacks = 0;			}		}		if (tp->t_dupacks < tcprexmtthresh)			tp->t_dupacks = 0;#else /* else no TCP_SACK */		if (tp->t_dupacks >= tcprexmtthresh &&		    tp->snd_cwnd > tp->snd_ssthresh)			tp->snd_cwnd = tp->snd_ssthresh;		tp->t_dupacks = 0;#endif		if (SEQ_GT(th->th_ack, tp->snd_max)) {			tcpstat.tcps_rcvacktoomuch++;			goto dropafterack;		}		acked = th->th_ack - tp->snd_una;		tcpstat.tcps_rcvackpack++;		tcpstat.tcps_rcvackbyte += acked;		/*		 * If we have a timestamp reply, update smoothed		 * round trip time.  If no timestamp is present but		 * transmit timer is running and timed sequence		 * number was acked, update smoothed round trip time.		 * Since we now have an rtt measurement, cancel the		 * timer backoff (cf., Phil Karn's retransmit alg.).		 * Recompute the initial retransmit timer.		 */		if (ts_present)			tcp_xmit_timer(tp, tcp_now-ts_ecr+1);		else if (tp->t_rtttime && SEQ_GT(th->th_ack, tp->t_rtseq))			tcp_xmit_timer(tp, tcp_now - tp->t_rtttime);		/*		 * If all outstanding data is acked, stop retransmit		 * timer and remember to restart (more output or persist).		 * If there is more data to be acked, restart retransmit		 * timer, using current (possibly backed-off) value.		 */		if (th->th_ack == tp->snd_max) {			TCP_TIMER_DISARM(tp, TCPT_REXMT);			needoutput = 1;		} else if (TCP_TIMER_ISARMED(tp, TCPT_PERSIST) == 0)			TCP_TIMER_ARM(tp, TCPT_REXMT, tp->t_rxtcur);		/*		 * When new data is acked, open the congestion window.		 * If the window gives us less than ssthresh packets		 * in flight, open exponentially (maxseg per packet).		 * Otherwise open linearly: maxseg per window		 * (maxseg^2 / cwnd per packet).		 */		{		u_int cw = tp->snd_cwnd;		u_int incr = tp->t_maxseg;		if (cw > tp->snd_ssthresh)			incr = incr * incr / cw;#if defined (TCP_SACK)		if (tp->t_dupacks < tcprexmtthresh)#endif		tp->snd_cwnd = ulmin(cw + incr, TCP_MAXWIN<<tp->snd_scale);		}		ND6_HINT(tp);		if (acked > so->so_snd.sb_cc) {			tp->snd_wnd -= so->so_snd.sb_cc;			sbdrop(&so->so_snd, (int)so->so_snd.sb_cc);			ourfinisacked = 1;		} else {			sbdrop(&so->so_snd, acked);			tp->snd_wnd -= acked;			ourfinisacked = 0;		}		if (sb_notify(&so->so_snd))			sowwakeup(so);		tp->snd_una = th->th_ack;#ifdef TCP_ECN		/* sync snd_last with snd_una */		if (SEQ_GT(tp->snd_una, tp->snd_last))			tp->snd_last = tp->snd_una;#endif		if (SEQ_LT(tp->snd_nxt, tp->snd_una))			tp->snd_nxt = tp->snd_una;#if defined (TCP_SACK) && defined (TCP_FACK)		if (SEQ_GT(tp->snd_una, tp->snd_fack)) {			tp->snd_fack = tp->snd_una;			/* Update snd_awnd for partial ACK			 * without any SACK blocks.			 */			tp->snd_awnd = tcp_seq_subtract(tp->snd_nxt,				tp->snd_fack) + tp->retran_data;		}#endif		switch (tp->t_state) {		/*		 * In FIN_WAIT_1 STATE in addition to the processing		 * for the ESTABLISHED state if our FIN is now acknowledged		 * then enter FIN_WAIT_2.		 */		case TCPS_FIN_WAIT_1:			if (ourfinisacked) {				/*				 * If we can't receive any more				 * data, then closing user can proceed.				 * Starting the timer is contrary to the				 * specification, but if we don't get a FIN				 * we'll hang forever.				 */				if (so->so_state & SS_CANTRCVMORE) {					soisdisconnected(so);					TCP_TIMER_ARM(tp, TCPT_2MSL, tcp_maxidle);				}				tp->t_state = TCPS_FIN_WAIT_2;			}			break;		/*		 * In CLOSING STATE in addition to the processing for		 * the ESTABLISHED state if the ACK acknowledges our FIN		 * then enter the TIME-WAIT state, otherwise ignore		 * the segment.		 */		case TCPS_CLOSING:			if (ourfinisacked) {				tp->t_state = TCPS_TIME_WAIT;				tcp_canceltimers(tp);				TCP_TIMER_ARM(tp, TCPT_2MSL, 2 * TCPTV_MSL);				soisdisconnected(so);			}			break;		/*		 * In LAST_ACK, we may still be waiting for data to drain		 * and/or to be acked, as well as for the ack of our FIN.		 * If our FIN is now acknowledged, delete the TCB,		 * enter the closed state and return.		 */		case TCPS_LAST_ACK:			if (ourfinisacked) {				tp = tcp_close(tp);				goto drop;			}			break;		/*		 * In TIME_WAIT state the only thing that should arrive		 * is a retransmission of the remote FIN.  Acknowledge		 * it and restart the finack timer.		 */		case TCPS_TIME_WAIT:			TCP_TIMER_ARM(tp, TCPT_2MSL, 2 * TCPTV_MSL);			goto dropafterack;		}	}step6:	/*	 * Update window information.	 * Don't look at window if no ACK: TAC's send garbage on first SYN.	 */	if ((tiflags & TH_ACK) && (SEQ_LT(tp->snd_wl1, th->th_seq) ||	    (tp->snd_wl1 == th->th_seq && SEQ_LT(tp->snd_wl2, th->th_ack)) ||	    (tp->snd_wl2 == th->th_ack && tiwin > tp->snd_wnd))) {		/* keep track of pure window updates */		if (tlen == 0 &&		    tp->snd_wl2 == th->th_ack && tiwin > tp->snd_wnd)			tcpstat.tcps_rcvwinupd++;		tp->snd_wnd = tiwin;		tp->snd_wl1 = th->th_seq;		tp->snd_wl2 = th->th_ack;		if (tp->snd_wnd > tp->max_sndwnd)			tp->max_sndwnd = tp->snd_wnd;		needoutput = 1;	}	/*	 * Process segments with URG.	 */	if ((tiflags & TH_URG) && th->th_urp &&	    TCPS_HAVERCVDFIN(tp->t_state) == 0) {		/*		 * This is a kludge, but if we receive and accept		 * random urgent pointers, we'll crash in		 * soreceive.  It's hard to imagine someone		 * actually wanting to send this much urgent data.		 */		if (th->th_urp + so->so_rcv.sb_cc > sb_max) {			th->th_urp = 0;			/* XXX */			tiflags &= ~TH_URG;		/* XXX */			goto dodata;			/* XXX */		}		/*		 * If this segment advances the known urgent pointer,		 * then mark the data stream.  This should not happen		 * in CLOSE_WAIT, CLOSING, LAST_ACK or TIME_WAIT STATES since		 * a FIN has been received from the remote side.		 * In these states we ignore the URG.		 *		 * According to RFC961 (Assigned Protocols),		 * the urgent pointer points to the last octet		 * of urgent data.  We continue, however,		 * to consider it to indicate the first octet		 * of data past the urgent section as the original		 * spec states (in one of two places).		 */		if (SEQ_GT(th->th_seq+th->th_urp, tp->rcv_up)) {			tp->rcv_up = th->th_seq + th->th_urp;			so->so_oobmark = so->so_rcv.sb_cc +			    (tp->rcv_up - tp->rcv_nxt) - 1;			if (so->so_oobmark == 0)				so->so_state |= SS_RCVATMARK;			sohasoutofband(so);			tp->t_oobflags &= ~(TCPOOB_HAVEDATA | TCPOOB_HADDATA);		}		/*		 * Remove out of band data so doesn't get presented to user.		 * This can happen independent of advancing the URG pointer,		 * but if two URG's are pending at once, some out-of-band		 * data may creep in... ick.		 */		if (th->th_urp <= (u_int16_t) tlen#ifdef SO_OOBINLINE		     && (so->so_options & SO_OOBINLINE) == 0#endif		     )		        tcp_pulloutofband(so, th->th_urp, m, hdroptlen);	} else		/*		 * If no out of band data is expected,		 * pull receive urgent pointer along		 * with the receive window.		 */		if (SEQ_GT(tp->rcv_nxt, tp->rcv_up))			tp->rcv_up = tp->rcv_nxt;dodata:							/* XXX */	/*	 * Process the segment text, merging it into the TCP sequencing queue,	 * and arranging for acknowledgment of receipt if necessary.	 * This process logically involves adjusting tp->rcv_wnd as data	 * is presented to the user (this happens in tcp_usrreq.c,	 * case PRU_RCVD).  If a FIN has already been received on this	 * connection then we just ignore the text.	 */	if ((tlen || (tiflags & TH_FIN)) &&	    TCPS_HAVERCVDFIN(tp->t_state) == 0) {		if (th->th_seq == tp->rcv_nxt && tp->segq.lh_first == NULL &&		    tp->t_state == TCPS_ESTABLISHED) {			TCP_SETUP_ACK(tp, tiflags);			tp->rcv_nxt += tlen;			tiflags = th->th_flags & TH_FIN;			tcpstat.tcps_rcvpack++;			tcpstat.tcps_rcvbyte += tlen;			ND6_HINT(tp);			if (so->so_state & SS_CANTRCVMORE)				m_freem(m);			else {				m_adj(m, hdroptlen);				sbappendstream(&so->so_rcv, m);			}			sorwakeup(so);		} else {			m_adj(m, hdroptlen);			tiflags = tcp_reass(tp, th, m, &tlen);			tp->t_flags |= TF_ACKNOW;		}#ifdef TCP_SACK		if (!tp->sack_disable)			tcp_update_sack_list(tp);#endif		/*		 * variable len never referenced again in modern BSD,		 * so why bother computing it ??		 */#if 0		/*		 * Note the amount of data that peer has sent into		 * our window, in order to estimate the sender's		 * buffer size.		 */		len = so->so_rcv.sb_hiwat - (tp->rcv_adv - tp->rcv_nxt);#endif /* 0 */	} else {		m_freem(m);		tiflags &= ~TH_FIN;	}	/*	 * If FIN is received ACK the FIN and let the user know	 * that the connection is closing.  Ignore a FIN received before	 * the connection is fully established.	 */	if ((tiflags & TH_FIN) && TCPS_HAVEESTABLISHED(tp->t_state)) {		if (TCPS_HAVERCVDFIN(tp->t_state) == 0) {			socantrcvmore(so);			tp->t_flags |= TF_ACKNOW;			tp->rcv_nxt++;		}		switch (tp->t_state) {		/*		 * In ESTABLISHED STATE enter the CLOSE_WAIT state.		 */		case TCPS_ESTABLISHED:			tp->t_state = TCPS_CLOSE_WAIT;			break;		/*		 * If still in FIN_WAIT_1 STATE FIN has not been acked so		 * enter the CLOSING state.		 */		case TCPS_FIN_WAIT_1:			tp->t_state = TCPS_CLOSING;			break;		/*		 * In FIN_WAIT_2 state enter the TIME_WAIT state,		 * starting the time-wait timer, turning off the other		 * standard timers.		 */		case TCPS_FIN_WAIT_2:			tp->t_state = TCPS_TIME_WAIT;			tcp_canceltimers(tp);			TCP_TIMER_ARM(tp, TCPT_2MSL, 2 * TCPTV_MSL);			soisdisconnected(so);			break;		/*		 * In TIME_WAIT state restart the 2 MSL time_wait timer.		 */		case TCPS_TIME_WAIT:			TCP_TIMER_ARM(tp, TCPT_2MSL, 2 * TCPTV_MSL);			break;		}	}	if (so->so_options & SO_DEBUG) {		switch (tp->pf) {#ifdef INET6		case PF_INET6:			tcp_trace(TA_INPUT, ostate, tp, (caddr_t) &tcp_saveti6,			    0, tlen);			break;#endif /* INET6 */		case PF_INET:			tcp_trace(TA_INPUT, ostate, tp, (caddr_t) &tcp_saveti,			    0, tlen);			break;		}	}	/*	 * Return any desired output.	 */	if (needoutput || (tp->t_flags & TF_ACKNOW)) {		(void) tcp_output(tp);	}	return;dropafterack:	/*	 * Generate an ACK dropping incoming segment if it occupies	 * sequence space, where the ACK reflects our state.	 */	if (tiflags & TH_RST)		goto drop;	m_freem(m);	tp->t_flags |= TF_ACKNOW;	(void) tcp_output(tp);	return;dropwithreset_ratelim:	/*	 * We may want to rate-limit RSTs in certain situations,	 * particularly if we are sending an RST in response to	 * an attempt to connect to or otherwise communicate with	 * a port for which we have no socket.	 */	if (ppsratecheck(&tcp_rst_ppslim_last, &tcp_rst_ppslim_count,	    tcp_rst_ppslim) == 0) {		/* XXX stat */		goto drop;	}	/* ...fall into dropwithreset... */dropwithreset:	/*	 * Generate a RST, dropping incoming segment.	 * Make ACK acceptable to originator of segment.	 * Don't bother to respond if destination was broadcast/multicast.	 */	if ((tiflags & TH_RST) || m->m_flags & (M_BCAST|M_MCAST))		goto drop;	switch (af) {#ifdef INET6	case AF_INET6:		/* For following calls to tcp_respond */		if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst))			goto drop;		break;#endif /* INET6 */	case AF_INET:		if (IN_MULTICAST(ip->ip_dst.s_addr) ||		    in_broadcast(ip->ip_dst, m->m_pkthdr.rcvif))			goto drop;	}	if (tiflags & TH_ACK) {		tcp_respond(tp, mtod(m, caddr_t), m, (tcp_seq)0, th->th_ack,		    TH_RST);	} else {		if (tiflags & TH_SYN)			tlen++;		tcp_respond(tp, mtod(m, caddr_t), m, th->th_seq + tlen,		    (tcp_seq)0, TH_RST|TH_ACK);	}	/* destroy temporarily created socket */	if (dropsocket)		(void) soabort(so);	return;drop:	/*	 * Drop space held by incoming segment and return.	 */	if (tp && (tp->t_inpcb->inp_socket->so_options & SO_DEBUG)) {		switch (tp->pf) {#ifdef INET6		case PF_INET6:			tcp_trace(TA_DROP, ostate, tp, (caddr_t) &tcp_saveti6,			    0, tlen);			break;#endif /* INET6 */		case PF_INET:			tcp_trace(TA_DROP, ostate, tp, (caddr_t) &tcp_saveti,			    0, tlen);			break;		}	}	m_freem(m);	/* destroy temporarily created socket */	if (dropsocket)		(void) soabort(so);	return;#ifndef TUBA_INCLUDE}