merge wnj changes plus lint

[unix-history] / usr / src / sys / netinet / tcp_usrreq.c

diff --git a/usr/src/sys/netinet/tcp_usrreq.c b/usr/src/sys/netinet/tcp_usrreq.c
index feeb1f9..229cbfc 100644 (file)
--- a/usr/src/sys/netinet/tcp_usrreq.c
+++ b/usr/src/sys/netinet/tcp_usrreq.c
@@ -1,441 +1,384 @@
-/* tcp_usrreq.c 1.7 81/10/22 */
+/*     tcp_usrreq.c    1.78    83/05/27        */

 
 #include "../h/param.h"
 #include "../h/systm.h"
 
 #include "../h/param.h"
 #include "../h/systm.h"

-#include "../bbnnet/net.h"
-#include "../bbnnet/mbuf.h"
-#include "../bbnnet/tcp.h"
-#include "../bbnnet/ip.h"
-#include "../bbnnet/imp.h"
-#include "../bbnnet/ucb.h"
-#define TCPFSTAB
-#ifdef TCPDEBUG
-#define TCPSTATES
-#endif
-#include "../bbnnet/fsm.h"
-
-tcp_timeo()
+#include "../h/mbuf.h"
+#include "../h/socket.h"
+#include "../h/socketvar.h"
+#include "../h/protosw.h"
+#include "../h/errno.h"
+
+#include "../net/if.h"
+#include "../net/route.h"
+
+#include "../netinet/in.h"
+#include "../netinet/in_pcb.h"
+#include "../netinet/in_systm.h"
+#include "../netinet/ip.h"
+#include "../netinet/ip_var.h"
+#include "../netinet/tcp.h"
+#include "../netinet/tcp_fsm.h"
+#include "../netinet/tcp_seq.h"
+#include "../netinet/tcp_timer.h"
+#include "../netinet/tcp_var.h"
+#include "../netinet/tcpip.h"
+#include "../netinet/tcp_debug.h"
+
+/*
+ * TCP protocol interface to socket abstraction.
+ */
+extern char *tcpstates[];
+struct tcpcb *tcp_newtcpcb();
+int    tcpsenderrors;
+
+/*
+ * Process a TCP user request for TCP tb.  If this is a send request
+ * then m is the mbuf chain of send data.  If this is a timer expiration
+ * (called from the software clock routine), then timertype tells which timer.
+ */
+/*ARGSUSED*/
+tcp_usrreq(so, req, m, nam, rights)
+       struct socket *so;
+       int req;
+       struct mbuf *m, *nam, *rights;

 {
 {

-       register struct tcb *tp;
+       register struct inpcb *inp = sotoinpcb(so);
+       register struct tcpcb *tp;

        int s = splnet();
        int s = splnet();

-COUNT(TCP_TIMEO);
+       int error = 0;
+       int ostate;

 
 

+       if (rights && rights->m_len) {
+               splx(s);
+               return (EINVAL);
+       }

        /*
        /*

-        * Search through tcb's and update active timers.
+        * When a TCP is attached to a socket, then there will be
+        * a (struct inpcb) pointed at by the socket, and this
+        * structure will point at a subsidary (struct tcpcb).

         */
         */

-       for (tp = netcb.n_tcb_head; tp != NULL; tp = tp->t_tcb_next) {
-               if (tp->t_init != 0 && --tp->t_init == 0)
-                       tcp_usrreq(ISTIMER, TINIT, tp, 0);
-               if (tp->t_rexmt != 0 && --tp->t_rexmt == 0)
-                       tcp_usrreq(ISTIMER, TREXMT, tp, 0);
-               if (tp->t_rexmttl != 0 && --tp->t_rexmttl == 0)
-                       tcp_usrreq(ISTIMER, TREXMTTL, tp, 0);
-               if (tp->t_persist != 0 && --tp->t_persist == 0)
-                       tcp_usrreq(ISTIMER, TPERSIST, tp, 0);
-               if (tp->t_finack != 0 && --tp->t_finack == 0)
-                       tcp_usrreq(ISTIMER, TFINACK, tp, 0);
-               tp->t_xmt++;
+       if (inp == 0 && req != PRU_ATTACH) {
+               splx(s);
+               return (EINVAL);                /* XXX */

        }
        }

-       netcb.n_iss += ISSINCR;         /* increment iss */
-       timeout(tcp_timeo, 0, hz);      /* reschedule every second */
-       splx(s);
-}
-
-tcp_usrreq(input, timertype, tp, mp)
-       int input, timertype;
-       register struct tcb *tp;
-       struct mbuf *mp;
-{
-       int s = splnet();
-       register int nstate;
-#ifdef TCPDEBUG
-       struct tcp_debug tdb;
+       if (inp) {
+               tp = intotcpcb(inp);
+               /* WHAT IF TP IS 0? */
+#ifdef KPROF
+               tcp_acounts[tp->t_state][req]++;

 #endif
 #endif

-COUNT(TCP_USRREQ);
-
-       nstate = tp->t_state;
-       tp->tc_flags &= ~TC_NET_KEEP;
-       acounts[nstate][input]++;
-#ifdef TCPDEBUG
-       if ((tp->t_ucb->uc_flags & UDEBUG) || tcpconsdebug) {
-               tdb.td_tod = time;
-               tdb.td_tcb = tp;
-               tdb.td_old = nstate;
-               tdb.td_inp = input;
-               tdb.td_tim = timertype;
+               ostate = tp->t_state;

        } else
        } else

-               tdb.td_tod = 0;
-#endif
-       switch (tcp_fstab[nstate][input]) {
+               ostate = 0;
+       switch (req) {

 
 

-       default:
-               printf("tcp: bad state: tcb=%x state=%d input=%d\n",
-                   tp, tp->t_state, input);
-               nstate = EFAILEC;
+       /*
+        * TCP attaches to socket via PRU_ATTACH, reserving space,
+        * and an internet control block.
+        */
+       case PRU_ATTACH:
+               if (inp) {
+                       error = EISCONN;
+                       break;
+               }
+               error = tcp_attach(so);
+               if (error)
+                       break;
+               if ((so->so_options & SO_LINGER) && so->so_linger == 0)
+                       so->so_linger = TCP_LINGERTIME;
+               tp = sototcpcb(so);

                break;
 
                break;
 

-       case LIS_CLS:                           /* 1 */
-               t_open(tp, PASSIVE);
-               nstate = LISTEN;
+       /*
+        * PRU_DETACH detaches the TCP protocol from the socket.
+        * If the protocol state is non-embryonic, then can't
+        * do this directly: have to initiate a PRU_DISCONNECT,
+        * which may finish later; embryonic TCB's can just
+        * be discarded here.
+        */
+       case PRU_DETACH:
+               if (tp->t_state > TCPS_LISTEN)
+                       tp = tcp_disconnect(tp);
+               else
+                       tp = tcp_close(tp);

                break;
 
                break;
 

-       case SYS_CLS:                           /* 2 */
-               t_open(tp, ACTIVE);
-               send_ctl(tp);
-               nstate = SYN_SENT;
+       /*
+        * Give the socket an address.
+        */
+       case PRU_BIND:
+               error = in_pcbbind(inp, nam);
+               if (error)
+                       break;

                break;
 
                break;
 

-       case CLS_OPN:                           /* 10 */
-               t_close(tp, UCLOSED);
-               nstate = CLOSED;
+       /*
+        * Prepare to accept connections.
+        */
+       case PRU_LISTEN:
+               if (inp->inp_lport == 0)
+                       error = in_pcbbind(inp, (struct mbuf *)0);
+               if (error == 0)
+                       tp->t_state = TCPS_LISTEN;

                break;
 
                break;
 

-       case CL2_CLW:                           /* 10 */
-               tp->tc_flags |= TC_SND_FIN;
-               send_ctl(tp);
-               tp->tc_flags |= TC_USR_CLOSED;
-               nstate = CLOSING2;
+       /*
+        * Initiate connection to peer.
+        * Create a template for use in transmissions on this connection.
+        * Enter SYN_SENT state, and mark socket as connecting.
+        * Start keep-alive timer, and seed output sequence space.
+        * Send initial segment on connection.
+        */
+       case PRU_CONNECT:
+               if (inp->inp_lport == 0) {
+                       error = in_pcbbind(inp, (struct mbuf *)0);
+                       if (error)
+                               break;
+               }
+               error = in_pcbconnect(inp, nam);
+               if (error)
+                       break;
+               tp->t_template = tcp_template(tp);
+               if (tp->t_template == 0) {
+                       in_pcbdisconnect(inp);
+                       error = ENOBUFS;
+                       break;
+               }
+               soisconnecting(so);
+               tp->t_state = TCPS_SYN_SENT;
+               tp->t_timer[TCPT_KEEP] = TCPTV_KEEP;
+               tp->iss = tcp_iss; tcp_iss += TCP_ISSINCR/2;
+               tcp_sendseqinit(tp);
+               error = tcp_output(tp);

                break;
 
                break;
 

-       case TIMERS:                            /* 14,17,34,35,36,37,38 */
-               nstate = tcp_timers(tp, timertype);
+       /*
+        * Initiate disconnect from peer.
+        * If connection never passed embryonic stage, just drop;
+        * else if don't need to let data drain, then can just drop anyways,
+        * else have to begin TCP shutdown process: mark socket disconnecting,
+        * drain unread data, state switch to reflect user close, and
+        * send segment (e.g. FIN) to peer.  Socket will be really disconnected
+        * when peer sends FIN and acks ours.
+        *
+        * SHOULD IMPLEMENT LATER PRU_CONNECT VIA REALLOC TCPCB.
+        */
+       case PRU_DISCONNECT:
+               tp = tcp_disconnect(tp);

                break;
 
                break;
 

-       case CLS_RWT:                           /* 20 */
-               present_data(tp);
-               if (rcv_empty(tp)) {
-                       t_close(tp, UCLOSED);
-                       nstate = CLOSED;
-               } else
-                       nstate = RCV_WAIT;
+       /*
+        * Accept a connection.  Essentially all the work is
+        * done at higher levels; just return the address
+        * of the peer, storing through addr.
+        */
+       case PRU_ACCEPT: {
+               struct sockaddr_in *sin = mtod(nam, struct sockaddr_in *);
+
+               nam->m_len = sizeof (struct sockaddr_in);
+               sin->sin_family = AF_INET;
+               sin->sin_port = inp->inp_fport;
+               sin->sin_addr = inp->inp_faddr;

                break;
                break;

+               }

 
 

-       case FW1_SYR:                           /* 24,25 */
-               tp->tc_flags |= TC_SND_FIN;
-               send_ctl(tp);
-               tp->tc_flags |= TC_USR_CLOSED;
-               nstate = FIN_W1;
+       /*
+        * Mark the connection as being incapable of further output.
+        */
+       case PRU_SHUTDOWN:
+               socantsendmore(so);
+               tp = tcp_usrclosed(tp);
+               if (tp)
+                       error = tcp_output(tp);

                break;
 
                break;
 

-       case SSS_SND:                           /* 40,41 */
-               nstate = sss_snd(tp, mp);
+       /*
+        * After a receive, possibly send window update to peer.
+        */
+       case PRU_RCVD:
+               (void) tcp_output(tp);

                break;
 
                break;
 

-       case SSS_RCV:                           /* 42 */
-               send_ctl(tp);           /* send new window */
-               present_data(tp);
+       /*
+        * Do a send by putting data in output queue and updating urgent
+        * marker if URG set.  Possibly send more data.
+        */
+       case PRU_SEND:
+               sbappend(&so->so_snd, m);
+#ifdef notdef
+               if (tp->t_flags & TF_PUSH)
+                       tp->snd_end = tp->snd_una + so->so_snd.sb_cc;
+#endif
+               error = tcp_output(tp);
+               if (error) {            /* XXX fix to use other path */
+                       if (error == ENOBUFS)           /* XXX */
+                               error = 0;              /* XXX */
+                       tcpsenderrors++;
+               }

                break;
 
                break;
 

-       case CLS_NSY:                           /* 44 */
-               t_close(tp, UABORT);
-               nstate = CLOSED;
+       /*
+        * Abort the TCP.
+        */
+       case PRU_ABORT:
+               tp = tcp_drop(tp, ECONNABORTED);

                break;
 
                break;
 

-       case CLS_SYN:                           /* 45 */
-               tp->tc_flags |= TC_SND_RST;
-               send_null(tp);
-               t_close(tp, UABORT);
-               nstate = CLOSED;
+/* SOME AS YET UNIMPLEMENTED HOOKS */
+       case PRU_CONTROL:
+               error = EOPNOTSUPP;

                break;
 
                break;
 

-       case CLS_ACT:                           /* 47 */
-               t_close(tp, UNETDWN);
-               nstate = CLOSED;
+       case PRU_SENSE:
+               error = EOPNOTSUPP;

                break;
                break;

+/* END UNIMPLEMENTED HOOKS */

 
 

-       case NOP:
+       case PRU_RCVOOB:
+               if (so->so_oobmark == 0 &&
+                   (so->so_state & SS_RCVATMARK) == 0) {
+                       error = EINVAL;
+                       break;
+               }
+               if ((tp->t_oobflags & TCPOOB_HAVEDATA) == 0) {
+                       error = EWOULDBLOCK;
+                       break;
+               }
+               m->m_len = 1;
+               *mtod(m, caddr_t) = tp->t_iobc;

                break;
 
                break;
 

-       case CLS_ERR:
-               to_user(tp->t_ucb, UCLSERR);
+       case PRU_SENDOOB:
+               if (sbspace(&so->so_snd) < -512) {
+                       m_freem(m);
+                       error = ENOBUFS;
+                       break;
+               }
+               tp->snd_up = tp->snd_una + so->so_snd.sb_cc + 1;
+               sbappend(&so->so_snd, m);
+               tp->t_force = 1;
+               error = tcp_output(tp);
+               tp->t_force = 0;

                break;
                break;

-       }
-#ifdef TCPDEBUG
-       if (tdb.td_tod) {
-               tdb.td_new = nstate;
-               tcp_debug[tdbx++ % TDBSIZE] = tdb;
-               if (tcpconsdebug)
-                       tcp_prt(&tdb);
-       }
-#endif
-       /* YECH */
-       switch (nstate) {

 
 

-       case CLOSED:
-       case SAME:
+       case PRU_SOCKADDR:
+               in_setsockaddr(inp, nam);

                break;
 
                break;
 

-       case EFAILEC:
-               if (mp)
-                       m_freem(dtom(mp));
+       /*
+        * TCP slow timer went off; going through this
+        * routine for tracing's sake.
+        */
+       case PRU_SLOWTIMO:
+               tp = tcp_timers(tp, (int)nam);
+               req |= (int)nam << 8;           /* for debug's sake */

                break;
 
        default:
                break;
 
        default:

-               tp->t_state = nstate;
-               break;
+               panic("tcp_usrreq");

        }
        }

+       if (tp && (so->so_options & SO_DEBUG))
+               tcp_trace(TA_USER, ostate, tp, (struct tcpiphdr *)0, req);

        splx(s);
        splx(s);

+       return (error);

 }
 
 }
 

-t_open(tp, mode)                /* set up a tcb for a connection */
-       register struct tcb *tp;
-       int mode;
+int    tcp_sendspace = 1024*2;
+int    tcp_recvspace = 1024*2;
+/*
+ * Attach TCP protocol to socket, allocating
+ * internet protocol control block, tcp control block,
+ * bufer space, and entering LISTEN state if to accept connections.
+ */
+tcp_attach(so)
+       struct socket *so;

 {
 {

-       register struct ucb *up;
-COUNT(T_OPEN);
-
-       /* enqueue the tcb */
-
-       if (netcb.n_tcb_head == NULL) {
-               netcb.n_tcb_head = tp;
-               netcb.n_tcb_tail = tp;
-       } else {
-               tp->t_tcb_next = netcb.n_tcb_head;
-               netcb.n_tcb_head->t_tcb_prev = tp;
-               netcb.n_tcb_head = tp;
+       register struct tcpcb *tp;
+       struct inpcb *inp;
+       int error;
+
+       error = soreserve(so, tcp_sendspace, tcp_recvspace);
+       if (error)
+               goto bad;
+       error = in_pcballoc(so, &tcb);
+       if (error)
+               goto bad;
+       inp = sotoinpcb(so);
+       tp = tcp_newtcpcb(inp);
+       if (tp == 0) {
+               error = ENOBUFS;
+               goto bad2;

        }
        }

-
-       /* initialize non-zero tcb fields */
-
-       tp->t_rcv_next = (struct th *)tp;
-       tp->t_rcv_prev = (struct th *)tp;
-       tp->t_xmtime = T_REXMT;
-       tp->snd_end = tp->seq_fin = tp->snd_nxt = tp->snd_hi =
-                     tp->snd_una = tp->iss = netcb.n_iss;
-       tp->snd_off = tp->iss + 1;
-       netcb.n_iss += (ISSINCR >> 1) + 1;
-
-       /* set timeout for open */
-
-       up = tp->t_ucb;
-       tp->t_init = (up->uc_timeo != 0 ? up->uc_timeo :
-                                       (mode == ACTIVE ? T_INIT : 0));
-       up->uc_timeo = 0;       /* overlays uc_ssize */
+       tp->t_state = TCPS_CLOSED;
+       return (0);
+bad2:
+       in_pcbdetach(inp);
+bad:
+       return (error);

 }
 
 }
 

-t_close(tp, state)
-       register struct tcb *tp;
-       short state;
+/*
+ * Initiate (or continue) disconnect.
+ * If embryonic state, just send reset (once).
+ * If not in ``let data drain'' option, just drop.
+ * Otherwise (hard), mark socket disconnecting and drop
+ * current input data; switch states based on user close, and
+ * send segment to peer (with FIN).
+ */
+struct tcpcb *
+tcp_disconnect(tp)
+       register struct tcpcb *tp;

 {
 {

-       register struct ucb *up;
-       register struct th *t;
-       register struct mbuf *m;
-COUNT(T_CLOSE);
-
-       up = tp->t_ucb;
-
-       tp->t_init = tp->t_rexmt = tp->t_rexmttl = tp->t_persist = 
-           tp->t_finack = 0;
-
-       /* delete tcb */
-
-       if (tp->t_tcb_prev == NULL)
-               netcb.n_tcb_head = tp->t_tcb_next;
-       else
-               tp->t_tcb_prev->t_tcb_next = tp->t_tcb_next;
-       if (tp->t_tcb_next == NULL)
-               netcb.n_tcb_tail = tp->t_tcb_prev;
-       else
-               tp->t_tcb_next->t_tcb_prev = tp->t_tcb_prev;
-
-       /* free all data on receive and send buffers */
-
-       for (t = tp->t_rcv_next; t != (struct th *)tp; t = t->t_next)
-               m_freem(dtom(t));
-
-       if (up->uc_rbuf != NULL) {
-               m_freem(up->uc_rbuf);
-               up->uc_rbuf = NULL;
+       struct socket *so = tp->t_inpcb->inp_socket;
+
+       if (tp->t_state < TCPS_ESTABLISHED)
+               tp = tcp_close(tp);
+       else if (so->so_linger == 0)
+               tp = tcp_drop(tp, 0);
+       else {
+               soisdisconnecting(so);
+               sbflush(&so->so_rcv);
+               tp = tcp_usrclosed(tp);
+               if (tp)
+                       (void) tcp_output(tp);

        }
        }

-       if (up->uc_sbuf != NULL) {
-               m_freem(up->uc_sbuf);
-               up->uc_sbuf = NULL;
-       }
-       for (m = tp->t_rcv_unack; m != NULL; m = m->m_act) {
-               m_freem(m);
-               tp->t_rcv_unack = NULL;
-       }
-       m_free(dtom(tp));
-       up->uc_tcb = NULL;
-
-       /* lower buffer allocation and decrement host entry */
-
-       netcb.n_lowat -= up->uc_snd + up->uc_rcv + 2;
-       netcb.n_hiwat = 2 * netcb.n_lowat;
-       if (up->uc_host != NULL) {
-               h_free(up->uc_host);
-               up->uc_host = NULL;
-       }
-
-       /* if user has initiated close (via close call), delete ucb
-          entry, otherwise just wakeup so user can issue close call */
-
-       if (tp->tc_flags&TC_USR_ABORT)
-               up->uc_proc = NULL;
-       else
-               to_user(up, state);
+       return (tp);

 }
 
 }
 

-sss_snd(tp, m0)
-       register struct tcb *tp;
-       struct mbuf *m0;
+/*
+ * User issued close, and wish to trail through shutdown states:
+ * if never received SYN, just forget it.  If got a SYN from peer,
+ * but haven't sent FIN, then go to FIN_WAIT_1 state to send peer a FIN.
+ * If already got a FIN from peer, then almost done; go to LAST_ACK
+ * state.  In all other cases, have already sent FIN to peer (e.g.
+ * after PRU_SHUTDOWN), and just have to play tedious game waiting
+ * for peer to send FIN or not respond to keep-alives, etc.
+ * We can let the user exit from the close as soon as the FIN is acked.
+ */
+struct tcpcb *
+tcp_usrclosed(tp)
+       register struct tcpcb *tp;

 {
 {

-       register struct mbuf *m, *n;
-       register struct ucb *up = tp->t_ucb;
-       register off;
-       seq_t last;
-
-       last = tp->snd_off;
-
-       /* count number of mbufs in send data */
-
-       for (m = n = m0; m != NULL; m = m->m_next) {
-               up->uc_ssize++;
-               last += m->m_len;
-       }
-
-       /* find end of send buffer and append data */
-
-       if ((m = up->uc_sbuf) != NULL) {                /* something in send buffer */
-               while (m->m_next != NULL) {             /* find the end */
-                       m = m->m_next;
-                       last += m->m_len;
-               }
-               last += m->m_len;
-
-               /* if there's room in old buffer for new data, consolidate */
-
-               off = m->m_off + m->m_len;
-               while (n != NULL && (MSIZE - off) >= n->m_len) {
-                       bcopy((caddr_t)((int)n + n->m_off),
-                             (caddr_t)((int)m + off), n->m_len);
-                       m->m_len += n->m_len;
-                       off += n->m_len;
-                       up->uc_ssize--;
-                       n = m_free(n);
-               }
-               m->m_next = n;

 
 

-       } else          /* nothing in send buffer */
-               up->uc_sbuf = n;
+       switch (tp->t_state) {

 
 

-       if (up->uc_flags & UEOL) {              /* set EOL */
-               tp->snd_end = last;
-       }
-
-       if (up->uc_flags & UURG) {              /* urgent data */
-               tp->snd_urp = last+1;
-               tp->tc_flags |= TC_SND_URG;
-       }
-
-       send(tp);
-
-       return (SAME);
-}
-
-tcp_timers(tp, timertype)
-       register struct tcb *tp;
-       int timertype;
-{
-
-COUNT(TCP_TIMERS);
-       switch (timertype) {
+       case TCPS_CLOSED:
+       case TCPS_LISTEN:
+       case TCPS_SYN_SENT:
+               tp->t_state = TCPS_CLOSED;
+               tp = tcp_close(tp);
+               break;

 
 

-       case TINIT:             /* initialization timer */
-               if ((tp->tc_flags&TC_SYN_ACKED) == 0) {         /* 35 */
-                       t_close(tp, UINTIMO);
-                       return (CLOSED);
-               }
-               return (SAME);
-
-       case TFINACK:           /* fin-ack timer */
-               switch (tp->t_state) {
-
-               case TIME_WAIT:
-                       /*
-                        * We can be sure our ACK of foreign FIN was rcvd,
-                        * and can close if no data left for user.
-                        */
-                       if (rcv_empty(tp)) {
-                               t_close(tp, UCLOSED);           /* 14 */
-                               return (CLOSED);
-                       }
-                       return (RCV_WAIT);                      /* 17 */
-
-               case CLOSING1:
-                       tp->tc_flags |= TC_WAITED_2_ML;
-                       return (SAME);
-
-               default:
-                       return (SAME);
-               }
+       case TCPS_SYN_RECEIVED:
+       case TCPS_ESTABLISHED:
+               tp->t_state = TCPS_FIN_WAIT_1;
+               break;

 
 

-       case TREXMT:            /* retransmission timer */
-               if (tp->t_rexmt_val > tp->snd_una) {            /* 34 */
-                       /*
-                        * Set up for a retransmission, increase rexmt time
-                        * in case of multiple retransmissions.
-                        */
-                       tp->snd_nxt = tp->snd_una;
-                       tp->tc_flags |= TC_REXMT;
-                       tp->t_xmtime = tp->t_xmtime << 1;
-                       if (tp->t_xmtime > T_REMAX)
-                               tp->t_xmtime = T_REMAX;
-                       send(tp);
-               }
-               return (SAME);
-
-       case TREXMTTL:          /* retransmit too long */
-               if (tp->t_rtl_val > tp->snd_una)                /* 36 */
-                       to_user(tp->t_ucb, URXTIMO);
-               /*
-                * If user has already closed, abort the connection.
-                */
-               if (tp->tc_flags & TC_USR_CLOSED) {
-                       t_close(tp, URXTIMO);
-                       return (CLOSED);
-               }
-               return (SAME);
-
-       case TPERSIST:          /* persist timer */
-               /*
-                * Force a byte send through closed window.
-                */
-               tp->tc_flags |= TC_FORCE_ONE;
-               send(tp);
-               return (SAME);
+       case TCPS_CLOSE_WAIT:
+               tp->t_state = TCPS_LAST_ACK;
+               break;

        }
        }

-       panic("tcp_timers");
-}
-
-/* THIS ROUTINE IS A CROCK */
-to_user(up, state)
-       register struct ucb *up;
-       register short state;
-{
-COUNT(TO_USER);
-
-       up->uc_state |= state;
-       netwakeup(up);
-       if (state == UURGENT)
-               psignal(up->uc_proc, SIGURG);
-}
-
-#ifdef TCPDEBUG
-tcp_prt(tdp)
-       register struct tcp_debug *tdp;
-{
-COUNT(TCP_PRT);
-
-       printf("TCP(%X) %s X %s",
-           tdp->td_tcb, tcpstates[tdp->td_old], tcpinputs[tdp->td_inp]);
-       if (tdp->td_inp == ISTIMER)
-               printf("(%s)", tcptimers[tdp->td_tim]);
-       printf(" --> %s",
-           tcpstates[(tdp->td_new > 0) ? tdp->td_new : tdp->td_old]);
-       /* GROSS... DEPENDS ON SIGN EXTENSION OF CHARACTERS */
-       if (tdp->td_new < 0)
-               printf(" (FAILED)");
-       printf("\n");
+       if (tp && tp->t_state >= TCPS_FIN_WAIT_2)
+               soisdisconnected(tp->t_inpcb->inp_socket);
+       return (tp);

 }
 }

-#endif