Archipelago » qemu

/*

 * 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 min(x,y) ((x) < (y) ? (x) : (y))

#define max(x,y) ((x) > (y) ? (x) : (y))

int        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; \

               tcpstat.tcps_rcvpack++;\

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

                tcpstat.tcps_rcvpack++;\

                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

int

tcp_reass(tp, ti, m)

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

                                tcpstat.tcps_rcvduppack++;

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

        }

        tcpstat.tcps_rcvoopack++;

        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;

        }

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

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

          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;

                ++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] = tcp_keepintvl;

        else

           tp->t_timer[TCPT_KEEP] = tcp_keepidle;

        /*

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

                                 */

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

                                tcpstat.tcps_rcvackpack++;

                                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.

                                 */

                                if (tp->snd_una == tp->snd_max)

                                        tp->t_timer[TCPT_REXMT] = 0;

                                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 (so->so_snd.sb_cc)

                                        (void) tcp_output(tp);

                                return;

                        }

                } else if (ti->ti_ack == tp->snd_una &&

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

                    ti->ti_len <= 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.

                         */

                        ++tcpstat.tcps_preddat;

                        tp->rcv_nxt += ti->ti_len;

                        tcpstat.tcps_rcvpack++;

                        tcpstat.tcps_rcvbyte += ti->ti_len;

                        /*

                         * Add data to socket buffer.

                         */

                        if (so->so_emu) {

                                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.

                         * 

                         * Here are 3 interpretations of what should happen.

                         * The best (for me) is to delay-ack everything except

                         * if it's a one-byte packet containing an ESC

                         * (this means it's an arrow key (or similar) sent using

                         * Nagel, hence there will be no echo)

                         * The first of these is the original, the second is the

                         * middle ground between the other 2

                         */ 

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

 */                             

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

 *                             (so->so_iptos & IPTOS_LOWDELAY) == 0) ||

 *                            ((so->so_iptos & IPTOS_LOWDELAY) && 

 *                             ((struct tcpiphdr_2 *)ti)->first_char == (char)27)) {

 */

                        if ((unsigned)ti->ti_len == 1 &&

                            ((struct tcpiphdr_2 *)ti)->first_char == (char)27) {

                                tp->t_flags |= TF_ACKNOW;

                                tcp_output(tp);

                        } else {

                                tp->t_flags |= TF_DELACK;

                        }

                        return;

                }

        } /* header prediction */

        /*

         * 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 = max(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.

         * 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: {

          if (tiflags & TH_RST)

            goto drop;

          if (tiflags & TH_ACK)

            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 ((so->so_faddr.s_addr&htonl(0xffffff00)) == special_addr.s_addr) {

            int lastbyte=ntohl(so->so_faddr.s_addr) & 0xff;

            if (lastbyte!=CTL_ALIAS && lastbyte!=CTL_DNS) {

#if 0

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

                /* Command or exec adress */

                so->so_state |= SS_CTL;

              } else {

                /* May be an add exec */

                struct ex_list *ex_ptr;

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

                  if(ex_ptr->ex_fport == so->so_fport && 

                     lastbyte == ex_ptr->ex_addr) {

                    so->so_state |= SS_CTL;

                    break;

                  }

                }

              }

              if(so->so_state & SS_CTL) goto cont_input;

#endif

            }

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

            u_char code=ICMP_UNREACH_NET;

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

                        errno,strerror(errno)));

            if(errno == ECONNREFUSED) {

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

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

                          TH_RST|TH_ACK); 

            } else {

              if(errno == EHOSTUNREACH) code=ICMP_UNREACH_HOST;

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

              HTONL(ti->ti_ack);

              HTONS(ti->ti_win);

              HTONS(ti->ti_urp);

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

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

              *ip=save_ip;

              icmp_error(m, ICMP_UNREACH,code, 0,strerror(errno));

            }

            tp = tcp_close(tp);

            m_free(m);

          } else {

            /*

             * Haven't connected yet, save the current mbuf

             * and ti, and return

             * XXX Some OS's don't tell us whether the connect()

             * succeeded or not.  So we must time it out.

             */

            so->so_m = m;

            so->so_ti = ti;

            tp->t_timer[TCPT_KEEP] = TCPTV_KEEP_INIT;

            tp->t_state = TCPS_SYN_RECEIVED;

          }

          return;

        cont_conn:     

          /* m==NULL 

           * Check if the connect succeeded

           */

          if (so->so_state & SS_NOFDREF) {

            tp = tcp_close(tp);

            goto dropwithreset;

          }

        cont_input:                

          tcp_template(tp);

          if (optp)

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

          /* , */

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

          if (iss)

            tp->iss = iss;

          else 

            tp->iss = tcp_iss;

          tcp_iss += TCP_ISSINCR/2;

          tp->irs = ti->ti_seq;

          tcp_sendseqinit(tp);

          tcp_rcvseqinit(tp);

          tp->t_flags |= TF_ACKNOW;

          tp->t_state = TCPS_SYN_RECEIVED;

          tp->t_timer[TCPT_KEEP] = TCPTV_KEEP_INIT;

          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.

         *        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(ti->ti_ack, tp->iss) ||

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

                        goto dropwithreset;

                if (tiflags & TH_RST) {

                        if (tiflags & TH_ACK)

                                tp = tcp_drop(tp,0); /* XXX Check t_softerror! */

                        goto drop;

                }

                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 && SEQ_GT(tp->snd_una, tp->iss)) {

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

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

        } /* switch tp->t_state */

        /*

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

                }

                /*

                 * Following if statement from Stevens, vol. 2, p. 960.

                 */

                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_rcvduppack++;

                        tcpstat.tcps_rcvdupbyte += todrop;

                } else {

                        tcpstat.tcps_rcvpartduppack++;