if ((tiflags & TH_SYN) == 0)			goto drop;		if (tiflags & TH_ACK) {			tp->snd_una = ti->ti_ack;			if (SEQ_LT(tp->snd_nxt, tp->snd_una))				tp->snd_nxt = tp->snd_una;                        tp->t_timer[TCPT_REXMT] = 0;		}		tp->irs = ti->ti_seq;		tcp_rcvseqinit(tp);		tp->t_flags |= TF_ACKNOW;		if (tiflags & TH_ACK ) {			tcpstat.tcps_connects++;#ifdef WV_INSTRUMENTATION#ifdef INCLUDE_WVNET    /* WV_NET_INFO event */            WV_NET_PORTIN_EVENT_3 (NET_AUX_EVENT, WV_NET_INFO, 30, 12,                                   ti->ti_sport, ti->ti_dport,                                   WV_NETEVENT_TCPIN_CONNECT, WV_NET_RECV,                                    so->so_fd, tp->snd_nxt, tp->rcv_nxt)#endif  /* INCLUDE_WVNET */#endif			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 tcpiphdr *)0,				(struct mbuf *)0);			/*			 * if we didn't have to retransmit the SYN,			 * use its rtt as our initial srtt & rtt var.			 */			if (tp->t_rtt)				tcp_xmit_timer(tp, tp->t_rtt);		} else			tp->t_state = TCPS_SYN_RECEIVED;trimthenstep6:		/*		 * Advance ti->ti_seq to correspond to first data byte.		 * If data, trim to stay within window,		 * dropping FIN if necessary.		 */		ti->ti_seq++;		if (ti->ti_len > tp->rcv_wnd) {			todrop = ti->ti_len - tp->rcv_wnd;			m_adj(m, -todrop);			ti->ti_len = tp->rcv_wnd;			tiflags &= ~TH_FIN;			tcpstat.tcps_rcvpackafterwin++;			tcpstat.tcps_rcvbyteafterwin += todrop;		}		tp->snd_wl1 = ti->ti_seq - 1;		tp->rcv_up = ti->ti_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 += ti->ti_len;			tcpstat.tcps_pawsdrop++;			goto dropafterack;		}	}	todrop = tp->rcv_nxt - ti->ti_seq;	if (todrop > 0) {		if (tiflags & TH_SYN) {			tiflags &= ~TH_SYN;			ti->ti_seq++;			if (ti->ti_urp > 1) 				ti->ti_urp--;			else				tiflags &= ~TH_URG;			todrop--;		}#if 0  /* simultaneous open bug  */              		if (todrop >= ti->ti_len) {			tcpstat.tcps_rcvduppack++;			tcpstat.tcps_rcvdupbyte += ti->ti_len;			/*			 * If segment is just one to the left of the window,			 * check two special cases:			 * 1. Don't toss RST in response to 4.2-style keepalive.			 * 2. If the only thing to drop is a FIN, we can drop			 *    it, but check the ACK or we will get into FIN			 *    wars if our FINs crossed (both CLOSING).			 * In either case, send ACK to resynchronize,			 * but keep on processing for RST or ACK.			 */			if ((tiflags & TH_FIN && todrop == ti->ti_len + 1)#ifdef TCP_COMPAT_42			  || (tiflags & TH_RST && ti->ti_seq == tp->rcv_nxt - 1)#endif			   ) {				todrop = ti->ti_len;				tiflags &= ~TH_FIN;			} else {				/*				 * Handle the case when a bound socket connects				 * to itself. Allow packets with a SYN and				 * an ACK to continue with the processing.				 */				if (todrop != 0 || (tiflags & TH_ACK) == 0)					goto dropafterack;			}			tp->t_flags |= TF_ACKNOW;		} else {			tcpstat.tcps_rcvpartduppack++;			tcpstat.tcps_rcvpartdupbyte += todrop;		}#else /* XXX  simultaneous open bug fix Steven vol II sec 28.8 fig 28.30 */                if (todrop > ti->ti_len ||                    (todrop == ti->ti_len && (tiflags & TH_FIN) == 0)) {                    /*                     * Any valid Fin must be to the left of the window.                     * At this point the FIN must be a duplicate or                     * out of sequence; drop it.                     */                     tiflags &= ~TH_FIN;                    /*                     * Send an ACK to resynchronize and drop any data.                     * But keep on processing for RST or ACK.                     */                    tp->t_flags |= TF_ACKNOW;                    todrop = ti->ti_len;                }                tcpstat.tcps_rcvdupbyte += todrop;                tcpstat.tcps_rcvduppack++;#endif /* simultaneous open bug fix */                   		m_adj(m, todrop);		ti->ti_seq += todrop;		ti->ti_len -= todrop;		if (ti->ti_urp > todrop)			ti->ti_urp -= todrop;		else {			tiflags &= ~TH_URG;			ti->ti_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 && ti->ti_len) {		tp = tcp_close(tp);		tcpstat.tcps_rcvafterclose++;#ifdef WV_INSTRUMENTATION#ifdef INCLUDE_WVNET    /* WV_NET_INFO event */        WV_NET_PORTIN_EVENT_3 (NET_CORE_EVENT, WV_NET_INFO, 31, 13,                               ti->ti_sport, ti->ti_dport,                               WV_NETEVENT_TCPIN_DATACLOSED, WV_NET_RECV,                                so->so_fd, ti->ti_seq, ti->ti_len)#endif  /* INCLUDE_WVNET */#endif		goto dropwithreset;	}	/*	 * If segment ends after window, drop trailing data	 * (and PUSH and FIN); if nothing left, just ACK.	 */	todrop = (ti->ti_seq+ti->ti_len) - (tp->rcv_nxt+tp->rcv_wnd);	if (todrop > 0) {		tcpstat.tcps_rcvpackafterwin++;		if (todrop >= ti->ti_len) {			tcpstat.tcps_rcvbyteafterwin += ti->ti_len;			/*			 * 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(ti->ti_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 && ti->ti_seq == tp->rcv_nxt) {				tp->t_flags |= TF_ACKNOW;				tcpstat.tcps_rcvwinprobe++;			} else				goto dropafterack;		} else			tcpstat.tcps_rcvbyteafterwin += todrop;		m_adj(m, -todrop);		ti->ti_len -= todrop;		tiflags &= ~(TH_PUSH|TH_FIN);	}	/*	 * If last ACK falls within this segment's sequence numbers,	 * record its timestamp.	 */	if (ts_present && TSTMP_GEQ(ts_val, tp->ts_recent) &&            SEQ_LEQ(ti->ti_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) switch (tp->t_state) {	case TCPS_SYN_RECEIVED:		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:#ifdef WV_INSTRUMENTATION#ifdef INCLUDE_WVNET    /* WV_NET_INFO event */        WV_NET_PORTIN_EVENT_1 (NET_AUX_EVENT, WV_NET_INFO, 32, 14,                               ti->ti_sport, ti->ti_dport,                               WV_NETEVENT_TCPIN_RESET, WV_NET_RECV,                                so->so_fd)#endif  /* INCLUDE_WVNET */#endif		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) {#ifdef WV_INSTRUMENTATION#ifdef INCLUDE_WVNET    /* WV_NET_WARNING event */        WV_NET_PORTIN_EVENT_1 (NET_CORE_EVENT, WV_NET_WARNING, 12, 5,                               ti->ti_sport, ti->ti_dport,                               WV_NETEVENT_TCPIN_BADSYNC, WV_NET_RECV,                                so->so_fd)#endif  /* INCLUDE_WVNET */#endif		tp = tcp_drop(tp, ECONNRESET);		goto dropwithreset;	}	/*	 * If the ACK bit is off we drop the segment and return.	 */	if ((tiflags & TH_ACK) == 0)		goto drop;		/*	 * Ack processing.	 */	switch (tp->t_state) {	/*	 * In SYN_RECEIVED state if the ack ACKs our SYN then enter	 * ESTABLISHED state and continue processing, otherwise	 * send an RST.	 */	case TCPS_SYN_RECEIVED:		if (SEQ_GT(tp->snd_una, ti->ti_ack) ||		    SEQ_GT(ti->ti_ack, tp->snd_max))			goto dropwithreset;#ifdef WV_INSTRUMENTATION#ifdef INCLUDE_WVNET    /* WV_NET_INFO event */            WV_NET_PORTIN_EVENT_3 (NET_AUX_EVENT, WV_NET_INFO, 30, 12,                                   ti->ti_sport, ti->ti_dport,                                   WV_NETEVENT_TCPIN_CONNECT, WV_NET_RECV,                                    so->so_fd, tp->snd_nxt, tp->rcv_nxt)#endif  /* INCLUDE_WVNET */#endif		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 tcpiphdr *)0, (struct mbuf *)0);		tp->snd_wl1 = ti->ti_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 < ti->ti_ack <= tp->snd_max	 * then advance tp->snd_una to ti->ti_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:		if (SEQ_LEQ(ti->ti_ack, tp->snd_una)) {			if (ti->ti_len == 0 && 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 (tp->t_timer[TCPT_REXMT] == 0 ||				    ti->ti_ack != tp->snd_una)					tp->t_dupacks = 0;				else if (++tp->t_dupacks == tcprexmtthresh) {					tcp_seq onxt = tp->snd_nxt;					u_int win =					    min(tp->snd_wnd, tp->snd_cwnd) / 2 /						tp->t_maxseg;					if (win < 2)						win = 2;					tp->snd_ssthresh = win * tp->t_maxseg;					tp->t_timer[TCPT_REXMT] = 0;					tp->t_rtt = 0;					tp->snd_nxt = ti->ti_ack;					tp->snd_cwnd = tp->t_maxseg;#ifdef WV_INSTRUMENTATION#ifdef INCLUDE_WVNET    /* WV_NET_WARNING event */            WV_NET_PORTOUT_EVENT_2 (NET_CORE_EVENT, WV_NET_WARNING, 13, 6,                              tp->t_inpcb->inp_lport, tp->t_inpcb->inp_fport,                                   WV_NETEVENT_TCPIN_SENDFAIL, WV_NET_RECV,                                    so->so_fd, tp->t_dupacks)#endif  /* INCLUDE_WVNET */