usr/src/sys/deprecated/bbnnet/tcp_states.c

#ifdef RCSIDENT
static char rcsident[] = "$Header: tcp_states.c,v 1.21 85/07/31 09:42:53 walsh Exp $";
#endif


#include "../h/param.h"
#include "../h/mbuf.h"
#include "../h/socket.h"
#include "../h/socketvar.h"
#include "../h/errno.h"
#include "../h/systm.h"

#include "../net/if.h"
#include "../net/route.h"

#include "../bbnnet/in.h"
#include "../bbnnet/in_pcb.h"
#include "../bbnnet/in_var.h"
#include "../bbnnet/net.h"
#include "../bbnnet/fsm.h"
#include "../bbnnet/tcp.h"
#include "../bbnnet/seq.h"
#include "../bbnnet/ip.h"
#include "../bbnnet/macros.h"
#include "../bbnnet/sws.h"
#ifdef HMPTRAPS
#include "../bbnnet/hmp_traps.h"
#endif

extern struct rtentry *ip_route();

/*
 * These are the action routines of the TCP finite state machine.  They are
 * called from the TCP fsm dispatcher action().  These routines call
 * on the routines in tcp_procs.c to do the actual segment processing.
 */

/*
 * UNOPENED x IUOPENA == passive open == listen()
 */
lis_cls(wp)
struct work *wp;
{
    register struct tcpcb *tp = wp->w_tcb;

    /* listen() system call */

    /*
     * Don't know who we're talking to yet, so we don't have a route
     * or mtu yet.
     */
    tp->t_maxseg = TCPMAXSND;
    tp->t_timers[TINIT] = tp->t_itimeo;

    return(LISTEN);
}

/*
 * UNOPENED x IUOPENR == active open == connect()
 */
sys_cls(wp)
register struct work *wp;
{
    register struct tcpcb *tp;
    register struct inpcb *inp;

    /* connect() system call */

    tp = wp->w_tcb;
    inp = tp->t_in_pcb;
    /*
     * Know foreign host and have a route to there.
     */
#ifdef NOTCPOPTS
    tp->t_maxseg =  inp->inp_route.ro_rt->rt_ifp->if_mtu - TCPIPMAX;
#else
    /*
     * Best can do until other guy tells us otherwise.
     */
    tp->t_maxseg =
        MIN(inp->inp_route.ro_rt->rt_ifp->if_mtu - TCPIPMAX, TCPMAXSND);
#endif
    tp->t_maxseg -= inp->inp_optlen;

    tp->t_timers[TINIT] = (tp->t_itimeo ? tp->t_itimeo : TCP_tvINIT);

    send_tcp(tp, TCP_CTL);      /* send SYN */
    return(SYN_SENT);
}

/*
 * UNOPENED x IUCLOSE
 * LISTEN   x IUCLOSE
 * SYN_SENT x IUCLOSE
 *
 * User close request before receiving foreign SYN
 */
cls_opn(wp)
struct work *wp;
{
    t_close(wp->w_tcb, ECONNABORTED);
    return(CLOSED);
}

/*
 * SYN_RCVD   x IUCLOSE
 * L_SYN_RCVD x IUCLOSE
 * ESTAB      x IUCLOSE
 *
 * close request on synched connection
 */
fw1_syr(wp)
struct work *wp;
{
    register struct tcpcb *tp = wp->w_tcb;

    tp->snd_fin = TRUE; /* send FIN */
    send_tcp(tp, TCP_CTL);
    tp->usr_closed = TRUE;
    tp->t_noact = TCP_tvNOACT;
    tp->t_timers[TNOACT] = TCP_tvNOACT;
    return(FIN_W1);
}

/*
 * CLOSE_WAIT x IUCLOSE
 *
 * close request after received foreign FIN
 */
cl2_clw(wp)
struct work *wp;
{
    register struct tcpcb *tp = wp->w_tcb;

    tp->snd_fin = TRUE; /* send our own FIN */
    send_tcp(tp, TCP_CTL);
    tp->usr_closed = TRUE;
    tp->t_noact = TCP_tvNOACT;
    tp->t_timers[TNOACT] = TCP_tvNOACT;
    return(CLOSING2);
}

/*
 * UNOPENED   x IUABORT
 * LISTEN     x IUABORT
 * SYN_SENT   x IUABORT
 * SYN_RCVD   x IUABORT
 * L_SYN_RCVD x IUABORT
 *
 * User abort request on unsynched connection
 */
cls_nsy(wp)
struct work *wp;
{
    t_close(wp->w_tcb, ECONNABORTED);
    return(CLOSED);
}

/*
 * ESTAB      x IUABORT
 * FIN_WAIT_1 x IUABORT
 * FIN_WAIT_2 x IUABORT
 * TIME_WAIT  x IUABORT
 * CLOSE_WAIT x IUABORT
 * CLOSING_1  x IUABORT
 * CLOSING_2  x IUABORT
 * RCV_WAIT   x IUABORT
 *
 * User abort request on synched connection
 */
cls_syn(wp)
struct work *wp;
{
    register struct tcpcb *tp = wp->w_tcb;

    tp->snd_rst = TRUE; /* send reset */
    (void) send_pkt(tp, 0, 0);
    /* tp->ack_due = FALSE; don't since about to throw tcpcb away */
    t_close(tp, ECONNABORTED);
    return(CLOSED);
}

/*
 * LISTEN x INRECV
 *
 * From tcp_input/netprepr, we know the packet is a well formed SYN
 */
lis_netr(wp)
struct work *wp;
{
    register struct tcpcb *tp;
    register struct th *n;
    register struct inpcb *inp;
    register struct socket *so, *newso;
    struct rtentry *rt;
    struct tcpcb *newtp;
    struct inpcb *newinp;

    struct in_addr firsthop;
    extern int  ip_nhops;
    extern struct in_addr ip_hops[];

    n = (struct th *)wp->w_dat;

    /*
     * Need to route on basis of IP destination -- see ip_send()
     * ### What if loose routing and 1st hop not on local net and reroute?
     */
    if (ip_nhops == 0)
        firsthop = n->t_s;
    else
        /* source routed SYN packet */
        firsthop = ip_hops[ip_nhops];

    /*
     * O.k., let's get a route back to him
     */
    if (!(rt = ip_route(&n->t_d, &firsthop)))
    {
        /*
         * Can't talk to him.  Leave socket in receive state
         * so we can connect to someone else, since we haven't
         * been committed to anything yet anyway.
         * ### Drop his info on the floor.
         * Let the other machine just figure out on it's own that
         * it can't reach us that way.
         */
        no_route ("tcp", n->t_d, firsthop);
        return(LISTEN);
    }

    tp = wp->w_tcb;
    inp = tp->t_in_pcb;
    so = inp->inp_socket;

    /*
     * This socket is in the listen state, so the socket should have
     * so_options & SO_ACCEPTCONN set (solisten()).
     *
     * The order of sonewconn() and soisconnected() is
     * important, in order for the process to be woken up
     * at a time when the sleep condition is fulfilled.
     * sonewconn() is done here on the original socket, and
     * soisconnected() is done later in syr_netr() on the new
     * socket.
     */
    if (newso = sonewconn(so))
    {
        newinp = (struct inpcb *) newso->so_pcb;
        newtp = (struct tcpcb *) newinp->inp_ppcb;
        /*
         * Remember our peer for this connection.
         */
        newinp->inp_faddr = n->t_s;
        newinp->inp_fport = n->t_src;
        newinp->inp_laddr = n->t_d;
        if (ip_nhops > 0)
        {
            /*
             * optlen includes the source route to be copied
             * to the outgoing IP header, not the firsthop
             * which replaces ip_dst.
             */
            bcopy((caddr_t)ip_hops,newinp->inp_options, (unsigned)(ip_nhops+1)*4);
            newinp->inp_optlen = ip_nhops * 4;
        }
        /*
         * and copy fields into the new inpcb
         */
        newinp->inp_lport = inp->inp_lport;
        newinp->inp_route.ro_rt = rt;

        /*
         * and copy fields to the new tcpcb
         */
        newtp->t_maxfrag = tp->t_maxfrag;       /* set in tcp_input() */
        newtp->t_itimeo  = tp->t_itimeo;
        newtp->t_noact   = tp->t_noact;
        newtp->t_push    = tp->t_push;
        newtp->t_noactsig = tp->t_noactsig;
        newtp->t_noactprobe = tp->t_noactprobe;

        /*
         * and initialize others with new info
         * Upward negotiation of t_maxseg in tcp_opt() done
         * on socket in LISTEN.
         */
        newtp->t_maxseg = MIN(rt->rt_ifp->if_mtu - TCPIPMAX, tp->t_maxseg);
        newtp->t_maxseg -= newinp->inp_optlen;
        /*
         * In case next client doesn't negotiate maxseg.
         */
        tp->t_maxseg = TCPMAXSND;


        if (!(newtp->t_template = tcp_template(newtp)))
        {
            soabort (newso);
            return (LISTEN);
        }

        newtp->sws_qff = SWS_QFF_DEF;

        /*
         * So can debug connection problems without having to change
         * every program or apply debugging flag to each program every
         * time run it.
         */
        dowedebug(newinp, newso, &tcp_dfilter);

        /*
         * rcv_tcp may set fin_rcvd.  If so, We went up and down or
         * we got a garbage/misrouted packet.  If it's set, it's
         * meant for some other socket or some other instantiation
         * of it.  In any case, ignore it and listen for other
         * talkers.
         */
        rcv_tcp(newtp, n, TCP_DATA);

        if (newtp->fin_rcvd)
            soabort (newso);
        else
        {
            /*
             * no FIN (4)
             * start init timer now that we have foreign host.
             * Parent socket might have init timer as zero to
             * avoid getting ETIMEDOUT, but we do want this
             * child socket to time out on synchronization
             * just in case other host just went down.
             */
            newtp->t_timers[TINIT] = (newtp->t_itimeo != 0
                ? newtp->t_itimeo
                : TCP_tvINIT/2);
            newtp->t_state = L_SYN_RCVD;
        }
    }
    else
        rtfree(rt);

    return(LISTEN);     /* original file descriptor stays in LISTEN state */
}

/*
 * SYN_SENT x INRECV
 *
 * from tcp_input/netprepr, we know its a SYN, with perhaps a well formed ACK
 */
sys_netr(wp)
struct work *wp;
{
    register struct tcpcb *tp = wp->w_tcb;
    register struct th *n = (struct th *)wp->w_dat;

    rcv_tcp(tp, n, TCP_DATA);
    if (tp->fin_rcvd)
    {             /* got a FIN */

        /* if good ACK, present any data */

        if (n->t_flags&T_ACK)
        {
            if (SEQ_GT(n->t_ackno, tp->iss))    /* 32 */
                present_data(tp);
        }
        else
        {                                /* 9 */
            tp->t_timers[TFINACK] = TCP_tv2ML;
            tp->waited_2_ml = FALSE;
        }
        tp->t_timers[TNOACT] = tp->t_noact;
        return (CLOSE_WAIT);
    }
    else                   /* no FIN */
        /* if good ACK, open connection, otherwise wait for one */
        if (n->t_flags&T_ACK)
        {                       /* 11 */
            present_data(tp);
            tp->t_timers[TNOACT] = tp->t_noact;
            soisconnected (tp->t_in_pcb->inp_socket);
            return(ESTAB);
        }

    return(SYN_RCVD); /* 8 */
}

/*
 * SYN_RCVD   x INRECV
 * L_SYN_RCVD x INRECV
 *
 * from tcp_input/netprepr, we know its an ACK of our SYN
 */
syr_netr(wp)
struct work *wp;
{
    register struct tcpcb *tp = wp->w_tcb;
    register struct th *n = (struct th *)wp->w_dat;

    rcv_tcp(tp, n, TCP_DATA);
    present_data(tp);

    /* if no FIN, open connection, otherwise wait for user close */

    tp->t_timers[TNOACT] = tp->t_noact;
    if (tp->fin_rcvd)                               /* 33 */
        return(CLOSE_WAIT);
    else
    {
        /* 5 */
        soisconnected (tp->t_in_pcb->inp_socket);
        return(ESTAB);
    }
}

/*
 * ESTAB x INRECV
 */
est_netr(wp)
struct work *wp;
{
    register struct tcpcb *tp = wp->w_tcb;

    rcv_tcp(tp, (struct th *)wp->w_dat, TCP_DATA);
    PRESENT_DATA(tp);

    /* if no FIN, remain open, otherwise wait for user close */

    if (tp->fin_rcvd)                       /* 12 */
        return(CLOSE_WAIT);
    else /* 39 */
        return(SAME);
}

/*
 * FIN_WAIT_1 x INRECV
 *
 * incoming segment after user has closed
 */
fw1_netr(wp)
struct work *wp;
{
    register struct tcpcb *tp = wp->w_tcb;
    register struct th *n = (struct th *)wp->w_dat;

    /* process any incoming data, since we closed but they didn't */

    rcv_tcp(tp, n, TCP_DATA);
    present_data(tp);

    /* send any data remaining on send buffer */

    send_tcp(tp, TCP_DATA);
    if (ack_fin(tp, n))
    {                   /* our FIN got ACKed */
        if (tp->fin_rcvd)
        {                     /* got for FIN (28) */
            tp->t_timers[TFINACK] = TCP_tv2ML;
            tp->waited_2_ml = FALSE;
            return(TIME_WAIT);
        }
        else                   /* no FIN, wait (27) */
            return(FIN_W2);
    }
    else
    {                           /* no ACK of FIN */
        if (tp->fin_rcvd)
        {                     /* got for FIN (26) */
            tp->t_timers[TFINACK] = TCP_tv2ML;
            tp->waited_2_ml = FALSE;
            return(CLOSING1);
        }
    }
    return(SAME); /* 39 */
}

/*
 * FIN_WAIT_2 x INRECV
 *
 * incoming segment while waiting for foreign FIN
 */
fw2_netr(wp)
struct work *wp;
{
    register struct tcpcb *tp = wp->w_tcb;
    register struct th *n = (struct th *)wp->w_dat;

    /* process data since we closed, but they may not have */

    rcv_tcp(tp, n, TCP_DATA);
    present_data(tp);

    /* if we get the FIN, start the finack timer, else keep waiting */

    if (tp->fin_rcvd)
    {                     /* got for FIN (29) */
        tp->t_timers[TFINACK] = TCP_tv2ML;
        tp->waited_2_ml = FALSE;
        return(TIME_WAIT);
    }
    else                   /* 39 */
        return(SAME);
}

/*
 * TIME_WAIT x INRECV
 *
 * The close protocol (exchange of FINs) has progressed as far as it can.
 * We do not enter CLOSED immediately, but use TIME_WAIT so that if our ack
 * of other guys FIN didn't reach him, he can retransmit and we'll ack his
 * fin rather than respond with an rst.
 *
 * Since we received a packet, apparently our ack of his fin didn't get
 * there and we'll have to try again.  Restart finack timer in case this
 * one fails too.
 */
sss_syn(wp)
struct work *wp;
{
    register struct tcpcb *tp = wp->w_tcb;

    rcv_tcp(tp, (struct th *) wp->w_dat, TCP_DATA);
    present_data(tp);
    tp->t_timers[TFINACK] = TCP_tv2ML;
    return(SAME);
}

/*
 * CLOSE_WAIT x INRECV
 *
 * incoming segment after receipt of foreign FIN (local end still open)
 */
cwt_netr(wp)
struct work *wp;
{
    register struct tcpcb *tp = wp->w_tcb;
    register struct th *n = (struct th *)wp->w_dat;

    /* either duplicate FIN or data */

    if (n->t_flags&T_FIN)
    {
        if (n->t_flags&T_ACK && SEQ_LEQ(n->t_ackno, tp->seq_fin))
        {
            rcv_tcp(tp, n, TCP_CTL);
            tp->t_timers[TFINACK] = TCP_tv2ML;
            tp->waited_2_ml = FALSE;
        }
        else                   /* 31 */
            send_tcp(tp, TCP_CTL);
    }
    else
    {                           /* duplicate data (39) */
        rcv_tcp(tp, n, TCP_DATA);
        present_data(tp);
    }
    return(SAME);
}

/*
 * CLOSING_1 x INRECV
 *
 * incoming segment after we closed
 */
cl1_netr(wp)
struct work *wp;
{
    register struct tcpcb *tp = wp->w_tcb;
    register struct th *n = (struct th *)wp->w_dat;

    if (ack_fin(tp, n))
    {                   /* got ACK of our FIN */
        if (n->t_flags&T_FIN)
        {               /* got for FIN (23) */
            rcv_tcp(tp, n, TCP_CTL);
            tp->t_timers[TFINACK] = TCP_tv2ML;
            tp->waited_2_ml = FALSE;
            return(TIME_WAIT);
        }
        else
        {

            /* if wait done, see if any data left for user */

            if (tp->waited_2_ml)
                if (rcv_empty(tp))
                {    /* 15 */
                    t_close(tp, ECONNABORTED);
                    return(CLOSED);
                }
                else
                    return(RCV_WAIT); /* 18 */
            else
                return(TIME_WAIT); /* 22 */
        }
    }
    else
    {                           /* our FIN not ACKed yet */
        if (n->t_flags&T_FIN)
        {               /* rcvd for FIN (30) */
            rcv_tcp(tp, n, TCP_CTL);
            tp->t_timers[TFINACK] = TCP_tv2ML;
            tp->waited_2_ml = FALSE;
        }
        else
        {               /* no FIN, just proc new data (39) */
            rcv_tcp(tp, n, TCP_DATA);
            present_data(tp);
        }
    }
    return(SAME);
}

/*
 * CLOSING_2 x INRECV
 *
 * incoming segment after both of us have started closing
 */
cl2_netr(wp)
struct work *wp;
{
    register struct tcpcb *tp = wp->w_tcb;
    register struct th *n = (struct th *)wp->w_dat;

    if (ack_fin(tp, n))
    {                   /* this is ACK of our fin */

        /* if no data left for user, close; otherwise wait */

        if (rcv_empty(tp))
        {                            /* 16 */
            t_close(tp, ECONNABORTED);
            return(CLOSED);
        }
        else                   /* 19 */
            return(RCV_WAIT);
    }
    else
    {                           /* no ACK of our FIN */
        /* duplicate FIN or data */

        if (n->t_flags&T_FIN)                           /* 31 */
            send_tcp(tp, TCP_CTL);      /* ACK duplicate FIN */
        else
        {
            /* 39 */
            rcv_tcp(tp, n, TCP_DATA);
            present_data(tp);
        }
    }
    return(SAME);
}

/*
 * RCV_WAIT x INRECV
 */
rwt_netr(wp)            /* incoming seg while waiting for user rcv (30,21) */
struct work *wp;
{
    register struct tcpcb *tp = wp->w_tcb;
    register struct th *n = (struct th *)wp->w_dat;

    /* handle duplicate ACK of our FIN */

    if (n->t_flags&T_FIN && n->t_flags&T_ACK && SEQ_LEQ(n->t_ackno, tp->seq_fin))
    {           /* 30 */
        rcv_tcp(tp, n, TCP_CTL);
        tp->t_timers[TFINACK] = TCP_tv2ML;
        tp->waited_2_ml = FALSE;
    }
    return(SAME);
}

/*
 *      ESTAB      x IURECV
 *      CLOSE_WAIT x IURECV
 *
 * and allowing for shutdown()
 *
 *      FIN_WAIT_1 x IURECV
 *      FIN_WAIT_2 x IURECV
 *      TIME_WAIT  x IURECV
 *      CLOSING_1  x IURECV
 *      CLOSING_2  x IURECV
 */
sss_rcv(wp)             /* rcv request on open connection (42) */
struct work *wp;
{
    register struct tcpcb *tp = wp->w_tcb;

    PRESENT_DATA(tp);

    /* if last window sent was zero, send an ACK to update window */

    if (tp->sent_zero)
    {
        tp->force_ack = TRUE;   /* don't delay ACK here */
        send_tcp(tp, TCP_CTL);
    }
    return(SAME);
}

/*
 * RCV_WAIT x IURECV
 */
cls_rwt(wp)             /* rcv request after foreign close (20) */
struct work *wp;
{
    register struct tcpcb *tp = wp->w_tcb;

    present_data(tp); /* present any remaining data */
    if (rcv_empty(tp))
    {
        t_close(tp, ECONNABORTED);
        return(CLOSED);
    }
    else
        return(RCV_WAIT);
}

/*
 * SYN_SENT   x IUSEND
 * SYN_RCVD   x IUSEND
 * ESTAB      x IUSEND
 * CLOSE_WAIT x IUSEND
 *
 * For SYN_SENT and SYN_RCVD, just want to buffer data until connected.
 */
sss_snd(wp)             /* send request on open connection (40,41) */
struct work *wp;
{
    register struct tcpcb *tcp = wp->w_tcb;
    register struct inpcb *inp = tcp->t_in_pcb;
    sequence last;

    sbappend(&inp->inp_socket->so_snd, (struct mbuf *) wp->w_dat);
    last = tcp->snd_una + inp->inp_socket->so_snd.sb_cc;

    if (tcp->t_push)
        tcp->snd_end = last;
    if (tcp->t_urg)
    {
        tcp->snd_urp = last;    /* this byte is not urgent */
        tcp->snd_urg = TRUE;
    }
    send_tcp(tcp, TCP_DATA);
    return(SAME);
}

cls_act(wp)             /* net closing open connection (47) */
struct work *wp;
{
    t_close(wp->w_tcb, ECONNABORTED);
    return(CLOSED);
}

cls_err(wp)             /* invalid user request in closing states */
struct work *wp;
{
    advise_user(tcpcbtoso(wp->w_tcb), ECONNABORTED);
    return(SAME);
}


timers(wp)              /* timer processor (14,17,34,35,36,37,38) */
struct work *wp;
{
    register struct tcpcb *tp = wp->w_tcb;
    register type = wp->w_stype;

    switch (type)
    {

      case TINIT: /* initialization timer */
        /*
         * Haven't got an ACK of our SYN yet
         */
        if (tp->t_in_pcb->inp_socket->so_state & SS_NOFDREF)
        {
            /*
             * was a child socket of a listen(2)er trying to
             * establish connection with other end.
             * (state L_SYN_RCVD)
             */
            t_close(tp, ETIMEDOUT);
            return(CLOSED);
        }
        /* socket in connect(2) */
        advise_user(tcpcbtoso(tp), ETIMEDOUT);
        tp->t_timers[TINIT] = tp->t_itimeo;
        break;

      case TFINACK: /* fin-ack timer */

        if (tp->t_state == TIME_WAIT)
        {

            /* can be sure our ACK of for FIN was rcvd,
               can close if no data left for user */

            if (rcv_empty(tp))
            {            /* 14 */
                t_close(tp, ECONNABORTED);
                return(CLOSED);
            }
            else                   /* 17 */
                return(RCV_WAIT);

        }
        else if (tp->t_state == CLOSING1)     /* 37 */

            /* safe to close */

            tp->waited_2_ml = TRUE;

        break;

      case TREXMT: /* retransmission timer */

        if (is_unacked(tp))
        {
            /* statistics */
            tp->t_rxtct++;
            tcpstat.t_retransmit ++;

            /*
             * If we're retransmitting, then the network
             * may be dropping packets because it is overloaded.
             * Therefore, increase the retransmission time for
             * successive retransmissions.  When we get an ACK,
             * the srtt and rxmitime will be recalculated.
             */
            tp->t_rxmitime = tp->t_rxmitime << 1;
            if (tp->t_rxmitime > TCP_tvRXMAX)
                tp->t_rxmitime = TCP_tvRXMAX;

            tp->snd_nxt = tp->snd_una;
            tp->rexmt = TRUE;
            send_tcp(tp, TCP_DATA);
            tp->rexmt = FALSE;
        }
        break;

      case TREXMTTL: /* retransmit too long */

#ifdef HMPTRAPS
        /* hmp_trap(T_TCP_REXMTTL, (caddr_t)0, 0); */
#endif
        if (tp->usr_abort)
        {
            /* user has already closed for r/w so abort connection
             * usr_closed == closed for w (close or shutdown).
             */
            t_close(tp, ETIMEDOUT);
            return(CLOSED);
        }
        advise_user(tcpcbtoso(tp), ETIMEDOUT);
        tp->t_timers[TREXMTTL] = tp->t_rttltimeo;
        break;

      case TPERSIST: /* persist timer */

        /* force a byte send through closed window */

        tp->force_one = TRUE; /* 38 */
        send_tcp(tp, TCP_DATA); /* restarts timer */
        tp->force_one = FALSE;
        break;

      case TDELACK:     /* ack-delay timer */

        /* make sure an ack gets sent now */

        tp->force_ack = TRUE;
        send_tcp(tp, TCP_CTL);
        break;

      case TNOACT:      /* no activity timer */
        /*
         * This timer is used for 2 reasons:
         * 1) by the user to determine if the connection is idle or if the
         *    other side has aborted/rebooted...  This is open states entry.
         *    See tcp_newtcpcb()
         * 2) by the system to timeout on receipt of ACK of our FIN.
         *    This is separate from use of FINACK timer for other guy
         *    to get our ACK of his FIN.  If closing has started, finish it.
         */

        /*
         * if its a shutdown(),
         *      usr_closed == TRUE, usr_abort == FALSE
         *      the user will find out about any problems getting an ACK of our
         *          FIN through the retransmit took too long timer
         *      the connection could be idle because it takes the remote end a
         *          while to compute and produce a reply
         *      user only gets to crank up protocol close once, but he can
         *          shutdown and then close, thereby adjusting usr_abort so
         *          that things get cleaned up if the remote host died.
         *
         * if its a close(),
         *      usr_closed == TRUE, usr_abort == TRUE
         *      user could be lingering (and SS_NOFDREF will still be false)
         *      connection could be idle because the other host failed, and it
         *          could be down for days.  We don't want to wait for it to
         *          come back up and give us a reset.  Release resources now.
         */
        if (tp->usr_abort)
        {
            t_close(tp, ETIMEDOUT);
            return(CLOSED);
        }

        if (tp->t_noactprobe)
            send_tcp(tp, TCP_CTL);

        if (tp->t_noactsig)
            advise_user(tcpcbtoso(tp), ETIMEDOUT);

        tp->t_timers[TNOACT] = tp->t_noact;
        break;

    }
    return(SAME);
}