bounds checking

[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 43722f0..9250b1f 100644 (file)
--- a/usr/src/sys/netinet/tcp_usrreq.c
+++ b/usr/src/sys/netinet/tcp_usrreq.c
@@ -1,4 +1,4 @@
-/* tcp_usrreq.c 1.31 81/11/20 */
+/* tcp_usrreq.c 1.53 82/03/11 */

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


@@ -6,90 +6,29 @@
 #include "../h/socket.h"
 #include "../h/socketvar.h"
 #include "../h/protosw.h"
 #include "../h/socket.h"
 #include "../h/socketvar.h"
 #include "../h/protosw.h"

-#include "../net/inet.h"
-#include "../net/inet_pcb.h"
-#include "../net/inet_systm.h"
+#include "../net/in.h"
+#include "../net/in_pcb.h"
+#include "../net/in_systm.h"

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

-#include "../net/imp.h"

 #include "../net/ip.h"
 #include "../net/ip_var.h"
 #include "../net/tcp.h"
 #include "../net/ip.h"
 #include "../net/ip_var.h"
 #include "../net/tcp.h"

-#define TCPFSTAB
-#ifdef TCPDEBUG
-#define TCPSTATES
-#endif

 #include "../net/tcp_fsm.h"
 #include "../net/tcp_fsm.h"

+#include "../net/tcp_seq.h"
+#include "../net/tcp_timer.h"

 #include "../net/tcp_var.h"
 #include "../net/tcp_var.h"

-#include "/usr/include/errno.h"
-
-/*
- * Tcp initialization
- */
-tcp_init()
-{
-
-       tcp_iss = 1;            /* wrong */
-       tcb.inp_next = tcb.inp_prev = &tcb;
-}
-
-/*
- * Tcp finite state machine entries for timer and user generated
- * requests.  These routines raise the ipl to that of the network
- * to prevent reentry.  In particluar, this requires that the software
- * clock interrupt have lower priority than the network so that
- * we can enter the network from timeout routines without improperly
- * nesting the interrupt stack.
- */
-
-/*
- * Tcp protocol timeout routine called every 500 ms.
- * Updates the timers in all active tcb's and
- * causes finite state machine actions if timers expire.
- */
-tcp_slowtimo()
-{
-       register struct inpcb *ip;
-       register struct tcpcb *tp;
-       int s = splnet();
-       register short *tmp;
-       register int i;
-COUNT(TCP_TIMEO);
-
-       /*
-        * Search through tcb's and update active timers.
-        */
-       for (ip = tcb.inp_next; ip != &tcb; ip = ip->inp_next) {
-               tp = intotcpcb(ip);
-               tmp = &tp->t_init;
-               for (i = 0; i < TNTIMERS; i++) {
-                       if (*tmp && --*tmp == 0)
-                               (void) tcp_usrreq(tp->t_inpcb->inp_socket,
-                                   PRU_SLOWTIMO, (struct mbuf *)0,
-                                   (caddr_t)i);
-                       tmp++;
-               }
-               tp->t_xmt++;
-       }
-       tcp_iss += ISSINCR/2;           /* increment iss */
-       splx(s);
-}
+#include "../net/tcpip.h"
+#include "../net/tcp_debug.h"
+#include "../errno.h"

 
 /*
 
 /*

- * Cancel all timers for tcp tp.
+ * TCP protocol interface to socket abstraction.

  */
  */

-tcp_tcancel(tp)
-       struct tcpcb *tp;
-{
-       register short *tmp = &tp->t_init;
-       register int i;
-
-       for (i = 0; i < TNTIMERS; i++)
-               *tmp++ = 0;
-}
-
+extern char *tcpstates[];

 struct tcpcb *tcp_newtcpcb();
 struct tcpcb *tcp_newtcpcb();

+

 /*
 /*

- * Process a TCP user request for tcp tb.  If this is a send request
+ * 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.
  */
  * 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.
  */


@@ -102,472 +41,321 @@ tcp_usrreq(so, req, m, addr)
        register struct inpcb *inp = sotoinpcb(so);
        register struct tcpcb *tp;
        int s = splnet();
        register struct inpcb *inp = sotoinpcb(so);
        register struct tcpcb *tp;
        int s = splnet();

-       register int nstate;
-#ifdef TCPDEBUG
-       struct tcp_debug tdb;
-#endif

        int error = 0;
        int error = 0;

+       int ostate;

 COUNT(TCP_USRREQ);
 
        /*
 COUNT(TCP_USRREQ);
 
        /*

-        * Make sure attached.  If not,
-        * only PRU_ATTACH is valid.
+        * 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).
+        * The normal sequence of events is:
+        *      PRU_ATTACH              creating these structures
+        *      PRU_CONNECT             connecting to a remote peer
+        *      (PRU_SEND|PRU_RCVD)*    exchanging data
+        *      PRU_DISCONNECT          disconnecting from remote peer
+        *      PRU_DETACH              deleting the structures
+        * With the operations from PRU_CONNECT through PRU_DISCONNECT
+        * possible repeated several times.
+        *
+        * MULTIPLE CONNECTS ARE NOT YET IMPLEMENTED.

         */
         */

-#ifdef TCPDEBUG
-       tdb.td_tod = 0;
-#endif
-       if (inp == 0) {
-               if (req != PRU_ATTACH) {
-                       splx(s);
-                       return (EINVAL);
-               }
-       } else {
+       if (inp == 0 && req != PRU_ATTACH) {
+               splx(s);
+               return (EINVAL);                /* XXX */
+       }
+       if (inp) {

                tp = intotcpcb(inp);
                tp = intotcpcb(inp);

-               nstate = tp->t_state;

 #ifdef KPROF
 #ifdef KPROF

-               tcp_acounts[nstate][req]++;
-#endif
-#ifdef TCPDEBUG
-               if (((tp->t_socket->so_options & SO_DEBUG) || tcpconsdebug)) {
-                       tdb_setup(tp, (struct tcpiphdr *)0, req, &tdb);
-                       tdb.td_tim = timertype;
-               }
+               tcp_acounts[tp->t_state][req]++;

 #endif
 #endif

-               tp->tc_flags &= ~TC_NET_KEEP;
+               ostate = tp->t_state;

        }
        }

-

        switch (req) {
 
        switch (req) {
 

+       /*
+        * TCP attaches to socket via PRU_ATTACH, reserving space,
+        * and internet and TCP control blocks.
+        * If the socket is to receive connections,
+        * then the LISTEN state is entered.
+        */

        case PRU_ATTACH:
                if (inp) {
                        error = EISCONN;
                        break;
                }
        case PRU_ATTACH:
                if (inp) {
                        error = EISCONN;
                        break;
                }

-               tp = tcp_newtcpcb();
-               if (tp == 0) {
-                       error = ENOBUFS;
-                       break;
-               }
-               error = in_pcballoc(so, &tcb, 2048, 2048, (struct sockaddr_in *)addr);
-               if (error) {
-                       m_free(dtom(tp));
+               error = tcp_attach(so, (struct sockaddr *)addr);
+               if (error)

                        break;
                        break;

-               }
-               inp = (struct inpcb *)so->so_pcb;
-               tp->t_inpcb = inp;
-               inp->inp_ppcb = (caddr_t)tp;
-               if (so->so_options & SO_ACCEPTCONN)
-                       nstate = LISTEN;
-               else
-                       nstate = CLOSED;
+               if ((so->so_options & SO_DONTLINGER) == 0)
+                       so->so_linger = TCP_LINGERTIME;
+               tp = sototcpcb(so);

                break;
 
                break;
 

+       /*
+        * 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:
        case PRU_DETACH:

-               tcp_detach(tp);
+               if (tp->t_state > TCPS_LISTEN)
+                       tcp_disconnect(tp);
+               else {
+                       tcp_close(tp);
+                       tp = 0;
+               }

                break;
 
                break;
 

+       /*
+        * 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:
        case PRU_CONNECT:

-               if (tp->t_state != 0 && tp->t_state != CLOSED)
-                       goto bad;
-               error = in_pcbsetpeer(inp, (struct sockaddr_in *)addr);
+               error = in_pcbconnect(inp, (struct sockaddr_in *)addr);

                if (error)
                        break;
                if (error)
                        break;

-               (void) tcp_sndctl(tp);
-               nstate = SYN_SENT;
+               tp->t_template = tcp_template(tp);
+               if (tp->t_template == 0) {
+                       in_pcbdisconnect(inp);
+                       error = ENOBUFS;
+                       break;
+               }

                soisconnecting(so);
                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);
+               (void) tcp_output(tp);

                break;
 
                break;
 

-       case PRU_ACCEPT:
-               soisconnected(so);
+       /*
+        * 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:
+               tcp_disconnect(tp);

                break;
 
                break;
 

-       case PRU_DISCONNECT:
-               if ((tp->tc_flags & TC_FIN_RCVD) == 0)
-                       goto abort;
-               if (nstate < ESTAB)
-                       tcp_disconnect(tp);
-               else {
-                       tp->tc_flags |= TC_SND_FIN;
-                       (void) tcp_sndctl(tp);
-                       tp->tc_flags |= TC_USR_CLOSED;
-                       soisdisconnecting(so);
+       /*
+        * 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 = (struct sockaddr_in *)addr;
+
+               if (sin) {
+                       bzero((caddr_t)sin, sizeof (*sin));
+                       sin->sin_family = AF_INET;
+                       sin->sin_port = inp->inp_fport;
+                       sin->sin_addr = inp->inp_faddr;
+               }

                }
                break;
 
                }
                break;
 

+       /*
+        * Mark the connection as being incapable of further output.
+        */

        case PRU_SHUTDOWN:
        case PRU_SHUTDOWN:

-               switch (nstate) {
-
-               case LISTEN:
-               case SYN_SENT:
-                       nstate = CLOSED;
-                       break;
-
-               case SYN_RCVD:
-               case L_SYN_RCVD:
-               case ESTAB:     
-               case CLOSE_WAIT:
-                       tp->tc_flags |= TC_SND_FIN;
-                       (void) tcp_sndctl(tp);
-                       tp->tc_flags |= TC_USR_CLOSED;
-                       nstate = nstate != CLOSE_WAIT ? FIN_W1 : LAST_ACK;
-                       break;
-                       
-               case FIN_W1:
-               case FIN_W2:
-               case TIME_WAIT:
-               case CLOSING:
-               case LAST_ACK:
-               case RCV_WAIT:
-                       break;
-
-               default:
-                       goto bad;
-               }
+               socantsendmore(so);
+               tcp_usrclosed(tp);
+               (void) tcp_output(tp);

                break;
 
                break;
 

+       /*
+        * After a receive, possibly send window update to peer.
+        */

        case PRU_RCVD:
        case PRU_RCVD:

-               if (nstate < ESTAB || nstate == CLOSED)
-                       goto bad;
-               tcp_sndwin(tp);
-               if ((tp->tc_flags&TC_FIN_RCVD) &&
-                   (tp->tc_flags&TC_USR_CLOSED) == 0 &&
-                   rcv_empty(tp))
-                       error = ESHUTDOWN;
-               if (nstate == RCV_WAIT && rcv_empty(tp))
-                       nstate = CLOSED;
+               (void) tcp_output(tp);

                break;
 
                break;
 

+       /*
+        * Do a send by putting data in output queue and updating urgent
+        * marker if URG set.  Possibly send more data.
+        */

        case PRU_SEND:
        case PRU_SEND:

-               switch (nstate) {
-
-               case ESTAB:
-               case CLOSE_WAIT:
-                       tcp_usrsend(tp, m);
-                       break;
-               
-               default:
-                       if (nstate < ESTAB)
-                               goto bad;
-                       m_freem(m);
-                       error = ENOTCONN;
-                       break;
-               }
+               sbappend(&so->so_snd, m);
+/*
+               if (tp->t_flags & TF_PUSH)
+                       tp->snd_end = tp->snd_una + so->so_snd.sb_cc;
+ */
+               (void) tcp_output(tp);

                break;
 
                break;
 

-abort:
+       /*
+        * Abort the TCP.
+        */

        case PRU_ABORT:
        case PRU_ABORT:

-               tcp_abort(tp);
-               nstate = CLOSED;
+               tcp_drop(tp, ECONNABORTED);

                break;
 
                break;
 

+/* SOME AS YET UNIMPLEMENTED HOOKS */

        case PRU_CONTROL:
                error = EOPNOTSUPP;
                break;
 
        case PRU_CONTROL:
                error = EOPNOTSUPP;
                break;
 

-       case PRU_SLOWTIMO:
-               switch (nstate) {
-
-               case 0:
-               case CLOSED:
-               case LISTEN:
-                       goto bad;
+       case PRU_SENSE:
+               error = EOPNOTSUPP;
+               break;
+/* END UNIMPLEMENTED HOOKS */

 
 

-               default:
-                       nstate = tcp_timers(tp, (int)addr);
+       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;

                }
                }

+               *mtod(m, caddr_t) = tp->t_iobc;

                break;
 
                break;
 

-       default:
-               panic("tcp_usrreq");
-       bad:
-               printf("tcp: bad state: tcb=%x state=%d input=%d\n",
-                   tp, tp->t_state, req);
-               nstate = EFAILEC;
-               break;
-       }
-#ifdef TCPDEBUG
-       if (tdb.td_tod)
-               tdb_stuff(&tdb, nstate);
+       case PRU_SENDOOB:
+#ifdef TCPTRUEOOB
+               if (tp->t_flags & TF_DOOOB) {
+                       tp->t_oobseq++;
+                       tp->t_oobc = *mtod(m, caddr_t);
+                       tp->t_oobmark = tp->snd_una + so->so_snd.sb_cc;
+printf("sendoob seq now %x oobc %x\n", tp->t_oobseq, tp->t_oobc);
+                       tp->t_oobflags |= TCPOOB_NEEDACK;
+                       (void) tcp_output(tp);
+               }

 #endif
 #endif

-       switch (nstate) {
-
-       case CLOSED:
-       case SAME:
+               if (sbspace(&so->so_snd) < -512) {
+                       error = ENOBUFS;
+                       break;
+               }
+               tp->snd_up = tp->snd_una + so->so_snd.sb_cc + 1;
+               sbappend(&so->so_snd, m);
+/*
+               if (tp->t_flags & TF_PUSH)
+                       tp->snd_end = tp->snd_una + so->so_snd.sb_cc;
+ */
+               tp->t_force = 1;
+               (void) tcp_output(tp);
+               tp->t_force = 0;

                break;
 
                break;
 

-       case EFAILEC:
-               if (m)
-                       m_freem(dtom(m));
+       /*
+        * TCP slow timer went off; going through this
+        * routine for tracing's sake.
+        */
+       case PRU_SLOWTIMO:
+               tcp_timers(tp, (int)addr);
+               req |= (int)addr << 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);
        return (error);
 }
 
        splx(s);
        return (error);
 }
 

-struct tcpcb *
-tcp_newtcpcb()
-{
-       struct mbuf *m = m_getclr(0);
-       register struct tcpcb *tp;
-COUNT(TCP_NEWTCPCB);
-
-       if (m == 0)
-               return (0);
-       tp = mtod(m, struct tcpcb *);
-
-       /*
-        * Make empty reassembly queue.
-        */
-       tp->seg_next = tp->seg_prev = (struct tcpiphdr *)tp;
-
-       /*
-        * Initialize sequence numbers and round trip retransmit timer.
-        */
-       tp->t_xmtime = T_REXMT;
-       tp->snd_end = tp->seq_fin = tp->snd_nxt = tp->snd_hi = tp->snd_una =
-           tp->iss = tcp_iss;
-       tp->snd_off = tp->iss + 1;
-       tcp_iss += (ISSINCR >> 1) + 1;
-       return (tp);
-}
-
-tcp_detach(tp)
-       struct tcpcb *tp;
-{
-COUNT(TCP_DETACH);
-
-       in_pcbfree(tp->t_inpcb);
-       (void) m_free(dtom(tp));
-}
-
-tcp_disconnect(tp)
-       register struct tcpcb *tp;
-{
-       register struct tcpiphdr *t;
-
-COUNT(TCP_DISCONNECT);
-       tcp_tcancel(tp);
-       t = tp->seg_next;
-       for (; t != (struct tcpiphdr *)tp; t = (struct tcpiphdr *)t->ti_next)
-               m_freem(dtom(t));
-       tcp_drainunack(tp);
-       if (tp->t_template) {
-               (void) m_free(dtom(tp->t_template));
-               tp->t_template = 0;
-       }
-       in_pcbfree(tp->t_inpcb);
-}
-
-tcp_abort(tp)
-       register struct tcpcb *tp;
-{
-
-COUNT(TCP_ABORT);
-       switch (tp->t_state) {
-
-       case SYN_RCVD:
-       case ESTAB:
-       case FIN_W1:
-       case FIN_W2:
-       case CLOSE_WAIT:
-               tp->tc_flags |= TC_SND_RST;
-               tcp_sndnull(tp);
-       }
-       soisdisconnected(tp->t_inpcb->inp_socket);
-}
-
+int    tcp_sendspace = 1024*2;
+int    tcp_recvspace = 1024*3;

 /*
 /*

- * Send data queue headed by m0 into the protocol.
+ * Attach TCP protocol to socket, allocating
+ * internet protocol control block, tcp control block,
+ * bufer space, and entering LISTEN state if to accept connections.

  */
  */

-tcp_usrsend(tp, m0)
-       register struct tcpcb *tp;
-       struct mbuf *m0;
+tcp_attach(so, sa)
+       struct socket *so;
+       struct sockaddr *sa;

 {
 {

-       register struct socket *so = tp->t_inpcb->inp_socket;
-COUNT(TCP_USRSEND);
-
-       sbappend(&so->so_snd, m0);
-       if (tp->t_options & TO_EOL)
-               tp->snd_end = tp->snd_off + so->so_snd.sb_cc;
-       if (tp->t_options & TO_URG) {
-               tp->snd_urp = tp->snd_off + so->so_snd.sb_cc + 1;
-               tp->tc_flags |= TC_SND_URG;
-       }
-       (void) tcp_send(tp);
-}
-
-/*
- * TCP timer went off processing.
- */
-tcp_timers(tp, timertype)

        register struct tcpcb *tp;
        register struct tcpcb *tp;

-       int timertype;
-{
-
-COUNT(TCP_TIMERS);
-       switch (timertype) {
-
-       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)) {
-                               tcp_disconnect(tp);
-                               return (CLOSED);
-                       }
-                       return (RCV_WAIT);                      /* 17 */
-
-               case CLOSING:
-                       tp->tc_flags |= TC_WAITED_2_ML;
-                       return (SAME);
-
-               default:
-                       return (SAME);
-               }
-
-       case TREXMT:            /* retransmission timer */
-               if (tp->t_rexmt_val > tp->snd_una) {            /* 34 */
-                       /*
-                        * Set so 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;
-                       (void) tcp_send(tp);
-               }
-               return (SAME);
-
-       case TREXMTTL:          /* retransmit too long */
-               if (tp->t_rtl_val > tp->snd_una)                /* 36 */
-                       tcp_error(tp, EIO);             /* URXTIMO !?! */
-               /*
-                * If user has already closed, abort the connection.
-                */
-               if (tp->tc_flags & TC_USR_CLOSED) {
-                       tcp_abort(tp);
-                       return (CLOSED);
+       struct inpcb *inp;
+       int error;
+
+       error = in_pcbattach(so, &tcb,
+           tcp_sendspace, tcp_recvspace, (struct sockaddr_in *)sa);
+       if (error)
+               return (error);
+       inp = (struct inpcb *)so->so_pcb;
+       tp = tcp_newtcpcb(inp);
+       if (so->so_options & SO_ACCEPTCONN) {
+               if (tp == 0) {
+                       in_pcbdetach(inp);
+                       return (ENOBUFS);

                }
                }

-               return (SAME);
-
-       case TPERSIST:          /* persist timer */
-               /*
-                * Force a byte send through closed window.
-                */
-               tp->tc_flags |= TC_FORCE_ONE;
-               (void) tcp_send(tp);
-               return (SAME);
-       }
-       panic("tcp_timers");
-       /*NOTREACHED*/
-}
-
-/*ARGSUSED*/
-tcp_sense(m)
-       struct mbuf *m;
-{
-
-COUNT(TCP_SENSE);
-       return (EOPNOTSUPP);
+               tp->t_state = TCPS_LISTEN;
+       } else
+               tp->t_state = TCPS_CLOSED;
+       return (0);

 }
 
 }
 

-tcp_error(tp, errno)
+/*
+ * 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).
+ */
+tcp_disconnect(tp)

        struct tcpcb *tp;
        struct tcpcb *tp;

-       int errno;

 {
        struct socket *so = tp->t_inpcb->inp_socket;
 
 {
        struct socket *so = tp->t_inpcb->inp_socket;
 

-COUNT(TCP_ERROR);
-       so->so_error = errno;
-       sorwakeup(so);
-       sowwakeup(so);
+       if (tp->t_state < TCPS_ESTABLISHED)
+               tcp_close(tp);
+       else if (so->so_linger == 0)
+               tcp_drop(tp, 0);
+       else {
+               soisdisconnecting(so);
+               sbflush(&so->so_rcv);
+               tcp_usrclosed(tp);
+               (void) tcp_output(tp);
+       }

 }
 
 }
 

-#ifdef TCPDEBUG

 /*
 /*

- * TCP debugging utility subroutines.
- * THE NAMES OF THE FIELDS USED BY THESE ROUTINES ARE STUPID.
+ * 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.

  */
  */

-tdb_setup(tp, n, input, tdp)
+tcp_usrclosed(tp)

        struct tcpcb *tp;
        struct tcpcb *tp;

-       register struct tcpiphdr *n;
-       int input;
-       register struct tcp_debug *tdp;

 {
 
 {
 

-COUNT(TDB_SETUP);
-       tdp->td_tod = time;
-       tdp->td_tcb = tp;
-       tdp->td_old = tp->t_state;
-       tdp->td_inp = input;
-       tdp->td_tim = 0;
-       tdp->td_new = -1;
-       if (n) {
-               tdp->td_sno = n->ti_seq;
-               tdp->td_ano = n->ti_ackno;
-               tdp->td_wno = n->t_win;
-               tdp->td_lno = n->ti_len;
-               tdp->td_flg = n->ti_flags;
-       } else
-               tdp->td_sno = tdp->td_ano = tdp->td_wno = tdp->td_lno =
-                   tdp->td_flg = 0;
-}
-
-tdb_stuff(tdp, nstate)
-       struct tcp_debug *tdp;
-       int nstate;
-{
-COUNT(TDB_STUFF);
+       switch (tp->t_state) {

 
 

-       tdp->td_new = nstate;
-       tcp_debug[tdbx++ % TDBSIZE] = *tdp;
-       if (tcpconsdebug & 2)
-               tcp_prt(tdp);
-}
+       case TCPS_LISTEN:
+       case TCPS_SYN_SENT:
+               tp->t_state = TCPS_CLOSED;
+               tcp_close(tp);
+               break;

 
 

-tcp_prt(tdp)
-       register struct tcp_debug *tdp;
-{
-COUNT(TCP_PRT);
+       case TCPS_SYN_RECEIVED:
+       case TCPS_ESTABLISHED:
+               tp->t_state = TCPS_FIN_WAIT_1;
+               break;

 
 

-       printf("%x ", ((int)tdp->td_tcb)&0xffffff);
-       if (tdp->td_inp == INSEND) {
-               printf("SEND #%x", tdp->td_sno);
-               tdp->td_lno = ntohs(tdp->td_lno);
-               tdp->td_wno = ntohs(tdp->td_wno);
-       } else {
-               if (tdp->td_inp == INRECV)
-                       printf("RCV #%x ", tdp->td_sno);
-               printf("%s.%s",
-                   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]);
-               if (tdp->td_new == -1)
-                       printf(" (FAILED)");
+       case TCPS_CLOSE_WAIT:
+               tp->t_state = TCPS_LAST_ACK;
+               break;

        }
        }

-       /* GROSS... DEPENDS ON SIGN EXTENSION OF CHARACTERS */
-       if (tdp->td_lno)
-               printf(" len=%d", tdp->td_lno);
-       if (tdp->td_wno)
-               printf(" win=%d", tdp->td_wno);
-       if (tdp->td_flg & TH_FIN) printf(" FIN");
-       if (tdp->td_flg & TH_SYN) printf(" SYN");
-       if (tdp->td_flg & TH_RST) printf(" RST");
-       if (tdp->td_flg & TH_EOL) printf(" EOL");
-       if (tdp->td_flg & TH_ACK)  printf(" ACK %x", tdp->td_ano);
-       if (tdp->td_flg & TH_URG) printf(" URG");
-       printf("\n");
+       if (tp->t_state >= TCPS_FIN_WAIT_2)
+               soisdisconnected(tp->t_inpcb->inp_socket);

 }
 }

-#endif