Archipelago » qemu

/*

 * Changes and additions relating to SLiRP

 * Copyright (c) 1995 Danny Gasparovski.

 * terms and conditions of the copyright.

 */

	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.

/*	int ts_present = 0; */

	DEBUG_CALL("tcp_input");

		    (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;

		ti = so->so_ti;

		tiwin = ti->ti_win;

		tiflags = ti->ti_flags;

		goto cont_conn;

	}

	tcpstat.tcps_rcvtotal++;

	/*

	 * Get IP and TCP header together in first mbuf.

	  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_len+= iphlen;

	/*

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

	len = sizeof(struct ip ) + tlen;

	/* keep checksum for ICMP reply

	 * if (ti->ti_sum) { */

	if(cksum(m, len)) {

	  tcpstat.tcps_rcvbadsum++;

	  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

 */

	}

	tiflags = ti->ti_flags;

	/*

	 * Convert TCP protocol specific fields to host format.

	 */

	 */

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

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

	/*

	 * Locate pcb for segment.

	 */

	 * but should either do a listen or a connect soon.

	 *

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

	 * 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

                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 do it below (after getting remote address).

	 */

	if (optp && tp->t_state != TCPS_LISTEN)

/* , */

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

	    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.

		 */

				++tcpstat.tcps_predack;

/*				if (ts_present)

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

 */				     if (tp->t_rtt &&

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

					tcp_xmit_timer(tp, tp->t_rtt);

				else if (tp->t_timer[TCPT_PERSIST] == 0)

					tp->t_timer[TCPT_REXMT] = tp->t_rxtcur;

				 * There's room in so_snd, sowwakup will read()

				 * from the socket if we can

				 */

/*				if (so->so_snd.sb_flags & SB_NOTIFY)

 *					sowwakeup(so);

 */

				 * This is called because sowwakeup might have

				 * put data into so_snd.  Since we don't so sowwakeup,

				 * we don't need this.. XXX???

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

			} else

				sbappend(so, m);

			 * XXX This is called when data arrives.  Later, check

			 * if we can actually write() to the socket

			 * XXX Need to check? It's be NON_BLOCKING

			 */

/*			sorwakeup(so); */

			/*

			 * If this is a short packet, then ACK now - with Nagel

			 *	congestion avoidance sender won't send more until

			 *	he gets an ACK.

			 * It is better to not delay acks at all to maximize

			 * TCP throughput.  See RFC 2581.

			tp->t_flags |= TF_ACKNOW;

			tcp_output(tp);

			return;

	    goto dropwithreset;

	  if ((tiflags & TH_SYN) == 0)

	    goto drop;

	  /*

	   * This has way too many gotos...

	   * But a bit of spaghetti code never hurt anybody :)

	   */

	  /*

	   * If this is destined for the control address, then flag to

	   * tcp_ctl once connected, otherwise connect

	      if(lastbyte==CTL_CMD || lastbyte==CTL_EXEC) {

		/* Command or exec adress */

		so->so_state |= SS_CTL;

#endif

              {

		/* May be an add exec */

		struct ex_list *ex_ptr;

		for(ex_ptr = exec_list; ex_ptr; ex_ptr = ex_ptr->ex_next) {

		     lastbyte == ex_ptr->ex_addr) {

		    so->so_state |= SS_CTL;

		    break;

	    }

	    /* CTL_ALIAS: Do nothing, tcp_fconnect will be called on it */

	  }

	  if (so->so_emu & EMU_NOCONNECT) {

	    so->so_emu &= ~EMU_NOCONNECT;

	    goto cont_input;

	  }

	  if((tcp_fconnect(so) == -1) && (errno != EINPROGRESS) && (errno != EWOULDBLOCK)) {

	    u_char code=ICMP_UNREACH_NET;

	    DEBUG_MISC((dfd," tcp fconnect errno = %d-%s\n",

	    if(errno == ECONNREFUSED) {

	      /* ACK the SYN, send RST to refuse the connection */

	      tcp_respond(tp, ti, m, ti->ti_seq+1, (tcp_seq)0,

	    } else {

	      if(errno == EHOSTUNREACH) code=ICMP_UNREACH_HOST;

	      HTONL(ti->ti_seq);             /* restore tcp header */

	  }

	  return;

	   * Check if the connect succeeded

	   */

	  if (so->so_state & SS_NOFDREF) {

	    tp = tcp_close(tp);

	    goto dropwithreset;

	  }

	  tcp_template(tp);

	  if (optp)

	    tcp_dooptions(tp, (u_char *)optp, optlen, ti);

	  /* , */

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

	  if (iss)

	    tp->iss = iss;

	    tp->iss = tcp_iss;

	  tcp_iss += TCP_ISSINCR/2;

	  tp->irs = ti->ti_seq;

	  tcpstat.tcps_accepts++;

	  goto trimthenstep6;

	} /* case TCPS_LISTEN */

	/*

	 * If the state is SYN_SENT:

	 *	if seg contains an ACK, but not for our SYN, drop the input.

			tcpstat.tcps_connects++;

			soisfconnected(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)) {

	/*

	 * States other than LISTEN or SYN_SENT.

	 * First check timestamp, if present.

	 * 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 (tiflags & TH_SYN) {

			tiflags &= ~TH_SYN;

			ti->ti_seq++;

				ti->ti_urp--;

			else

				tiflags &= ~TH_URG;

			 * of sequence; drop it.

			 */

			tiflags &= ~TH_FIN;

			/*

			 * Send an ACK to resynchronize and drop any data.

			 * But keep on processing for RST or ACK.

			goto dropwithreset;

		tcpstat.tcps_connects++;

		tp->t_state = TCPS_ESTABLISHED;

		 * lost if no correction is made.  This is only needed for

		 * SS_CTL since the buffer is empty otherwise.

		 */

		tp->snd_una=ti->ti_ack;

		if (so->so_state & SS_CTL) {

		} else {

		  soisfconnected(so);

		}

		/* Do window scaling? */

/*		if ((tp->t_flags & (TF_RCVD_SCALE|TF_REQ_SCALE)) ==

 *			(TF_RCVD_SCALE|TF_REQ_SCALE)) {

				 * the new ssthresh).

				 *

				 * Dup acks mean that packets have left the

				 * so bump cwnd by the amount in the receiver

				 * to keep a constant cwnd packets in the

				 * network.

/*		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);

		}

		/*

		 * XXX sowwakup is called when data is acked and there's room for

		 */

/*		if (so->so_snd.sb_flags & SB_NOTIFY)

 *			sowwakeup(so);

	 * Don't look at window if no ACK: TAC's send garbage on first SYN.

	 */

	if ((tiflags & TH_ACK) &&

	    (tp->snd_wl1 == ti->ti_seq && (SEQ_LT(tp->snd_wl2, ti->ti_ack) ||

	    (tp->snd_wl2 == ti->ti_ack && tiwin > tp->snd_wnd))))) {

		/* keep track of pure window updates */

		 * 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

		 * 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

		 * spec states (in one of two places).

		 */

		if (SEQ_GT(ti->ti_seq+ti->ti_urp, tp->rcv_up)) {

			so->so_urgc =  so->so_rcv.sb_cc +

				(tp->rcv_up - tp->rcv_nxt); /* -1; */

			tp->rcv_up = ti->ti_seq + ti->ti_urp;

		}

	} else

		/*

			 */

/*			sofcantrcvmore(so); */

			sofwdrain(so);

			tp->t_flags |= TF_ACKNOW;

			tp->rcv_nxt++;

		}

		case TCPS_ESTABLISHED:

		  if(so->so_emu == EMU_CTL)        /* no shutdown on socket */

		    tp->t_state = TCPS_LAST_ACK;

		    tp->t_state = TCPS_CLOSE_WAIT;

		  break;

	 	/*

		 * In FIN_WAIT_2 state enter the TIME_WAIT state,

		 * standard timers.

		 */

		case TCPS_FIN_WAIT_2:

	 * If this is a small packet, then ACK now - with Nagel

	 *      congestion avoidance sender won't send more until

	 *      he gets an ACK.

	 * See above.

	 */

/*	if (ti->ti_len && (unsigned)ti->ti_len < tp->t_maxseg) {

 *			memcpy((char *) ts_ecr, (char *)cp + 6, sizeof(*ts_ecr));

 *			NTOHL(*ts_ecr);

 *

 *			 * A timestamp received in a SYN makes

 *			 * it ok to send timestamp requests and replies.

 *			 */

	register struct mbuf *m;

{

	int cnt = ti->ti_urp - 1;

	while (cnt >= 0) {

		if (m->m_len > cnt) {

			char *cp = mtod(m, caddr_t) + cnt;

	DEBUG_CALL("tcp_xmit_timer");

	DEBUG_ARG("tp = %lx", (long)tp);

	DEBUG_ARG("rtt = %d", rtt);

	tcpstat.tcps_rttupdated++;

	if (tp->t_srtt != 0) {

		/*

		if ((tp->t_rttvar += delta) <= 0)

			tp->t_rttvar = 1;

	} else {

		 * No rtt measurement yet - use the unsmoothed rtt.

		 * Set the variance to half the rtt (so our first

		 * retransmit happens at 3*rtt).

	 */

	TCPT_RANGESET(tp->t_rxtcur, TCP_REXMTVAL(tp),

	    (short)tp->t_rttmin, TCPTV_REXMTMAX); /* XXX */

	/*

	 * We received an ack for a packet that wasn't retransmitted;

	 * it is probably safe to discard any error indications we've

{

	struct socket *so = tp->t_socket;

	int mss;

	DEBUG_CALL("tcp_mss");

	DEBUG_ARG("tp = %lx", (long)tp);

	DEBUG_ARG("offer = %d", offer);

	mss = min(if_mtu, if_mru) - sizeof(struct tcpiphdr);

	if (offer)

		mss = min(mss, offer);

	mss = max(mss, 32);

	if (mss < tp->t_maxseg || offer != 0)

	   tp->t_maxseg = mss;

	tp->snd_cwnd = mss;

	sbreserve(&so->so_snd, tcp_sndspace+((tcp_sndspace%mss)?(mss-(tcp_sndspace%mss)):0));

	sbreserve(&so->so_rcv, tcp_rcvspace+((tcp_rcvspace%mss)?(mss-(tcp_rcvspace%mss)):0));

	DEBUG_MISC((dfd, " returning mss = %d\n", mss));

	return mss;

}