/*

 * Copyright (c) 1982, 1986, 1988, 1990, 1993, 1994

 *	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_input.c	8.5 (Berkeley) 4/10/94

 * tcp_input.c,v 1.10 1994/10/13 18:36:32 wollman Exp

 */

/*

 * Changes and additions relating to SLiRP

 * Copyright (c) 1995 Danny Gasparovski.

 *

 * Please read the file COPYRIGHT for the

 * terms and conditions of the copyright.

 */

#include <slirp.h>

#include "ip_icmp.h"

struct socket tcb;

#define	TCPREXMTTHRESH 3

struct	socket *tcp_last_so = &tcb;

tcp_seq tcp_iss;                /* tcp initial send seq # */

#define TCP_PAWS_IDLE	(24 * 24 * 60 * 60 * PR_SLOWHZ)

/* for modulo comparisons of timestamps */

#define TSTMP_LT(a,b)	((int)((a)-(b)) < 0)

#define TSTMP_GEQ(a,b)	((int)((a)-(b)) >= 0)

/*

 * Insert segment ti into reassembly queue of tcp with

 * control block tp.  Return TH_FIN if reassembly now includes

 * a segment with FIN.  The macro form does the common case inline

 * (segment is the next to be received on an established connection,

 * and the queue is empty), avoiding linkage into and removal

 * from the queue and repetition of various conversions.

 * Set DELACK for segments received in order, but ack immediately

 * when segments are out of order (so fast retransmit can work).

 */

#ifdef TCP_ACK_HACK

#define TCP_REASS(tp, ti, m, so, flags) {\

       if ((ti)->ti_seq == (tp)->rcv_nxt && \

           (tp)->seg_next == (tcpiphdrp_32)(tp) && \

           (tp)->t_state == TCPS_ESTABLISHED) {\

               if (ti->ti_flags & TH_PUSH) \

                       tp->t_flags |= TF_ACKNOW; \

               else \

                       tp->t_flags |= TF_DELACK; \

               (tp)->rcv_nxt += (ti)->ti_len; \

               flags = (ti)->ti_flags & TH_FIN; \

               STAT(tcpstat.tcps_rcvpack++);         \

               STAT(tcpstat.tcps_rcvbyte += (ti)->ti_len);   \

               if (so->so_emu) { \

		       if (tcp_emu((so),(m))) sbappend((so), (m)); \

	       } else \

	       	       sbappend((so), (m)); \

/*               sorwakeup(so); */ \

	} else {\

               (flags) = tcp_reass((tp), (ti), (m)); \

               tp->t_flags |= TF_ACKNOW; \

       } \

}

#else

#define	TCP_REASS(tp, ti, m, so, flags) { \

	if ((ti)->ti_seq == (tp)->rcv_nxt && \

	    (tp)->seg_next == (tcpiphdrp_32)(tp) && \

	    (tp)->t_state == TCPS_ESTABLISHED) { \

		tp->t_flags |= TF_DELACK; \

		(tp)->rcv_nxt += (ti)->ti_len; \

		flags = (ti)->ti_flags & TH_FIN; \

		STAT(tcpstat.tcps_rcvpack++);        \

		STAT(tcpstat.tcps_rcvbyte += (ti)->ti_len);  \

		if (so->so_emu) { \

			if (tcp_emu((so),(m))) sbappend(so, (m)); \

		} else \

			sbappend((so), (m)); \

/*		sorwakeup(so); */ \

	} else { \

		(flags) = tcp_reass((tp), (ti), (m)); \

		tp->t_flags |= TF_ACKNOW; \

	} \

}

#endif

static void tcp_dooptions(struct tcpcb *tp, u_char *cp, int cnt,

                          struct tcpiphdr *ti);

static void tcp_xmit_timer(register struct tcpcb *tp, int rtt);

static int

tcp_reass(register struct tcpcb *tp, register struct tcpiphdr *ti,

          struct mbuf *m)

{

	register struct tcpiphdr *q;

	struct socket *so = tp->t_socket;

	int flags;

	/*

	 * Call with ti==0 after become established to

	 * force pre-ESTABLISHED data up to user socket.

	 */

	if (ti == 0)

		goto present;

	/*

	 * Find a segment which begins after this one does.

	 */

	for (q = (struct tcpiphdr *)tp->seg_next; q != (struct tcpiphdr *)tp;

	    q = (struct tcpiphdr *)q->ti_next)

		if (SEQ_GT(q->ti_seq, ti->ti_seq))

			break;

	/*

	 * If there is a preceding segment, it may provide some of

	 * our data already.  If so, drop the data from the incoming

	 * segment.  If it provides all of our data, drop us.

	 */

	if ((struct tcpiphdr *)q->ti_prev != (struct tcpiphdr *)tp) {

		register int i;

		q = (struct tcpiphdr *)q->ti_prev;

		/* conversion to int (in i) handles seq wraparound */

		i = q->ti_seq + q->ti_len - ti->ti_seq;

		if (i > 0) {

			if (i >= ti->ti_len) {

				STAT(tcpstat.tcps_rcvduppack++);

				STAT(tcpstat.tcps_rcvdupbyte += ti->ti_len);

				m_freem(m);

				/*

				 * Try to present any queued data

				 * at the left window edge to the user.

				 * This is needed after the 3-WHS

				 * completes.

				 */

				goto present;   /* ??? */

			}

			m_adj(m, i);

			ti->ti_len -= i;

			ti->ti_seq += i;

		}

		q = (struct tcpiphdr *)(q->ti_next);

	}

	STAT(tcpstat.tcps_rcvoopack++);

	STAT(tcpstat.tcps_rcvoobyte += ti->ti_len);

	REASS_MBUF(ti) = (mbufp_32) m;		/* XXX */

	/*

	 * While we overlap succeeding segments trim them or,

	 * if they are completely covered, dequeue them.

	 */

	while (q != (struct tcpiphdr *)tp) {

		register int i = (ti->ti_seq + ti->ti_len) - q->ti_seq;

		if (i <= 0)

			break;

		if (i < q->ti_len) {

			q->ti_seq += i;

			q->ti_len -= i;

			m_adj((struct mbuf *) REASS_MBUF(q), i);

			break;

		}

		q = (struct tcpiphdr *)q->ti_next;

		m = (struct mbuf *) REASS_MBUF((struct tcpiphdr *)q->ti_prev);

		remque_32((void *)(q->ti_prev));

		m_freem(m);

	}

	/*

	 * Stick new segment in its place.

	 */

	insque_32(ti, (void *)(q->ti_prev));

present:

	/*

	 * Present data to user, advancing rcv_nxt through

	 * completed sequence space.

	 */

	if (!TCPS_HAVEESTABLISHED(tp->t_state))

		return (0);

	ti = (struct tcpiphdr *) tp->seg_next;

	if (ti == (struct tcpiphdr *)tp || ti->ti_seq != tp->rcv_nxt)

		return (0);

	if (tp->t_state == TCPS_SYN_RECEIVED && ti->ti_len)

		return (0);

	do {

		tp->rcv_nxt += ti->ti_len;

		flags = ti->ti_flags & TH_FIN;

		remque_32(ti);

		m = (struct mbuf *) REASS_MBUF(ti); /* XXX */

		ti = (struct tcpiphdr *)ti->ti_next;

/*		if (so->so_state & SS_FCANTRCVMORE) */

		if (so->so_state & SS_FCANTSENDMORE)

			m_freem(m);

		else {

			if (so->so_emu) {

				if (tcp_emu(so,m)) sbappend(so, m);

			} else

				sbappend(so, m);

		}

	} while (ti != (struct tcpiphdr *)tp && ti->ti_seq == tp->rcv_nxt);

/*	sorwakeup(so); */

	return (flags);

}

/*

 * TCP input routine, follows pages 65-76 of the

 * protocol specification dated September, 1981 very closely.

 */

void

tcp_input(m, iphlen, inso)

	register struct mbuf *m;

	int iphlen;

	struct socket *inso;

{

  	struct ip save_ip, *ip;

	register struct tcpiphdr *ti;

	caddr_t optp = NULL;

	int optlen = 0;

	int len, tlen, off;

	register struct tcpcb *tp = 0;

	register int tiflags;

	struct socket *so = 0;

	int todrop, acked, ourfinisacked, needoutput = 0;

/*	int dropsocket = 0; */

	int iss = 0;

	u_long tiwin;

	int ret;

/*	int ts_present = 0; */

	DEBUG_CALL("tcp_input");

	DEBUG_ARGS((dfd," m = %8lx  iphlen = %2d  inso = %lx\n",

		    (long )m, iphlen, (long )inso ));

	/*

	 * If called with m == 0, then we're continuing the connect

	 */

	if (m == NULL) {

		so = inso;

		/* Re-set a few variables */

		tp = sototcpcb(so);

		m = so->so_m;

		so->so_m = 0;

		ti = so->so_ti;

		tiwin = ti->ti_win;

		tiflags = ti->ti_flags;

		goto cont_conn;

	}

	STAT(tcpstat.tcps_rcvtotal++);

	/*

	 * Get IP and TCP header together in first mbuf.

	 * Note: IP leaves IP header in first mbuf.

	 */

	ti = mtod(m, struct tcpiphdr *);

	if (iphlen > sizeof(struct ip )) {

	  ip_stripoptions(m, (struct mbuf *)0);

	  iphlen=sizeof(struct ip );

	}

	/* XXX Check if too short */

	/*

	 * Save a copy of the IP header in case we want restore it

	 * for sending an ICMP error message in response.

	 */

	ip=mtod(m, struct ip *);

	save_ip = *ip;

	save_ip.ip_len+= iphlen;

	/*

	 * Checksum extended TCP header and data.

	 */

	tlen = ((struct ip *)ti)->ip_len;

	ti->ti_next = ti->ti_prev = 0;

	ti->ti_x1 = 0;

	ti->ti_len = htons((u_int16_t)tlen);

	len = sizeof(struct ip ) + tlen;

	/* keep checksum for ICMP reply

	 * ti->ti_sum = cksum(m, len);

	 * if (ti->ti_sum) { */

	if(cksum(m, len)) {

	  STAT(tcpstat.tcps_rcvbadsum++);

	  goto drop;

	}

	/*

	 * Check that TCP offset makes sense,

	 * pull out TCP options and adjust length.		XXX

	 */

	off = ti->ti_off << 2;

	if (off < sizeof (struct tcphdr) || off > tlen) {

	  STAT(tcpstat.tcps_rcvbadoff++);

	  goto drop;

	}

	tlen -= off;

	ti->ti_len = tlen;

	if (off > sizeof (struct tcphdr)) {

	  optlen = off - sizeof (struct tcphdr);

	  optp = mtod(m, caddr_t) + sizeof (struct tcpiphdr);

		/*

		 * 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) &&

 *		     (ti->ti_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 = ti->ti_flags;

	/*

	 * Convert TCP protocol specific fields to host format.

	 */

	NTOHL(ti->ti_seq);

	NTOHL(ti->ti_ack);

	NTOHS(ti->ti_win);

	NTOHS(ti->ti_urp);

	/*

	 * Drop TCP, IP headers and TCP options.

	 */

	m->m_data += sizeof(struct tcpiphdr)+off-sizeof(struct tcphdr);

	m->m_len  -= sizeof(struct tcpiphdr)+off-sizeof(struct tcphdr);

	/*

	 * Locate pcb for segment.

	 */

findso:

	so = tcp_last_so;

	if (so->so_fport != ti->ti_dport ||

	    so->so_lport != ti->ti_sport ||

	    so->so_laddr.s_addr != ti->ti_src.s_addr ||

	    so->so_faddr.s_addr != ti->ti_dst.s_addr) {

		so = solookup(&tcb, ti->ti_src, ti->ti_sport,

			       ti->ti_dst, ti->ti_dport);

		if (so)

			tcp_last_so = so;

		STAT(tcpstat.tcps_socachemiss++);

	}

	/*

	 * 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.

	 *

	 * state == CLOSED means we've done socreate() but haven't

	 * attached it to a protocol yet...

	 *

	 * XXX If a TCB does not exist, and the TH_SYN flag is

	 * the only flag set, then create a session, mark it

	 * as if it was LISTENING, and continue...

	 */

	if (so == 0) {

	  if ((tiflags & (TH_SYN|TH_FIN|TH_RST|TH_URG|TH_ACK)) != TH_SYN)

	    goto dropwithreset;

	  if ((so = socreate()) == NULL)

	    goto dropwithreset;

	  if (tcp_attach(so) < 0) {

	    free(so); /* Not sofree (if it failed, it's not insqued) */

	    goto dropwithreset;

	  }

	  sbreserve(&so->so_snd, TCP_SNDSPACE);

	  sbreserve(&so->so_rcv, TCP_RCVSPACE);

	  /*		tcp_last_so = so; */  /* XXX ? */

	  /*		tp = sototcpcb(so);    */

	  so->so_laddr = ti->ti_src;

	  so->so_lport = ti->ti_sport;

	  so->so_faddr = ti->ti_dst;

	  so->so_fport = ti->ti_dport;

	  if ((so->so_iptos = tcp_tos(so)) == 0)

	    so->so_iptos = ((struct ip *)ti)->ip_tos;

	  tp = sototcpcb(so);

	  tp->t_state = TCPS_LISTEN;

	}

        /*

         * If this is a still-connecting socket, this probably

         * a retransmit of the SYN.  Whether it's a retransmit SYN

	 * or something else, we nuke it.

         */

        if (so->so_state & SS_ISFCONNECTING)

                goto drop;

	tp = sototcpcb(so);

	/* XXX Should never fail */

	if (tp == 0)

		goto dropwithreset;

	if (tp->t_state == TCPS_CLOSED)

		goto drop;

	/* Unscale the window into a 32-bit value. */

/*	if ((tiflags & TH_SYN) == 0)

 *		tiwin = ti->ti_win << tp->snd_scale;

 *	else

 */

		tiwin = ti->ti_win;

	/*

	 * Segment received on connection.

	 * Reset idle time and keep-alive timer.

	 */

	tp->t_idle = 0;

	if (SO_OPTIONS)

	   tp->t_timer[TCPT_KEEP] = TCPTV_KEEPINTVL;

	else

	   tp->t_timer[TCPT_KEEP] = TCPTV_KEEP_IDLE;

	/*

	 * 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, (u_char *)optp, optlen, ti);

/* , */

/*			&ts_present, &ts_val, &ts_ecr); */

	/*

	 * 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.

	 *

	 * XXX Some of these tests are not needed

	 * eg: the tiwin == tp->snd_wnd prevents many more

	 * predictions.. with no *real* advantage..

	 */

	if (tp->t_state == TCPS_ESTABLISHED &&

	    (tiflags & (TH_SYN|TH_FIN|TH_RST|TH_URG|TH_ACK)) == TH_ACK &&

/*	    (!ts_present || TSTMP_GEQ(ts_val, tp->ts_recent)) && */

	    ti->ti_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.

		 */

/*		if (ts_present && SEQ_LEQ(ti->ti_seq, tp->last_ack_sent) &&

 *		   SEQ_LT(tp->last_ack_sent, ti->ti_seq + ti->ti_len)) {

 *			tp->ts_recent_age = tcp_now;

 *			tp->ts_recent = ts_val;

 *		}

 */

		if (ti->ti_len == 0) {

			if (SEQ_GT(ti->ti_ack, tp->snd_una) &&

			    SEQ_LEQ(ti->ti_ack, tp->snd_max) &&

			    tp->snd_cwnd >= tp->snd_wnd) {

				/*

				 * this is a pure ack for outstanding data.

				 */

				STAT(tcpstat.tcps_predack++);

/*				if (ts_present)

 *					tcp_xmit_timer(tp, tcp_now-ts_ecr+1);

 *				else

 */				     if (tp->t_rtt &&

					    SEQ_GT(ti->ti_ack, tp->t_rtseq))

					tcp_xmit_timer(tp, tp->t_rtt);

				acked = ti->ti_ack - tp->snd_una;

				STAT(tcpstat.tcps_rcvackpack++);

				STAT(tcpstat.tcps_rcvackbyte += acked);

				sbdrop(&so->so_snd, acked);

				tp->snd_una = ti->ti_ack;

				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.