The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/netipx/spx_usrreq.c

Version: -  FREEBSD  -  FREEBSD11  -  FREEBSD10  -  FREEBSD9  -  FREEBSD92  -  FREEBSD91  -  FREEBSD90  -  FREEBSD8  -  FREEBSD82  -  FREEBSD81  -  FREEBSD80  -  FREEBSD7  -  FREEBSD74  -  FREEBSD73  -  FREEBSD72  -  FREEBSD71  -  FREEBSD70  -  FREEBSD6  -  FREEBSD64  -  FREEBSD63  -  FREEBSD62  -  FREEBSD61  -  FREEBSD60  -  FREEBSD5  -  FREEBSD55  -  FREEBSD54  -  FREEBSD53  -  FREEBSD52  -  FREEBSD51  -  FREEBSD50  -  FREEBSD4  -  FREEBSD3  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 1984, 1985, 1986, 1987, 1993
    3  *      The Regents of the University of California.
    4  * Copyright (c) 2004-2009 Robert N. M. Watson
    5  * All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  * 4. Neither the name of the University nor the names of its contributors
   16  *    may be used to endorse or promote products derived from this software
   17  *    without specific prior written permission.
   18  *
   19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   29  * SUCH DAMAGE.
   30  *
   31  * Copyright (c) 1995, Mike Mitchell
   32  * All rights reserved.
   33  *
   34  * Redistribution and use in source and binary forms, with or without
   35  * modification, are permitted provided that the following conditions
   36  * are met:
   37  * 1. Redistributions of source code must retain the above copyright
   38  *    notice, this list of conditions and the following disclaimer.
   39  * 2. Redistributions in binary form must reproduce the above copyright
   40  *    notice, this list of conditions and the following disclaimer in the
   41  *    documentation and/or other materials provided with the distribution.
   42  * 3. All advertising materials mentioning features or use of this software
   43  *    must display the following acknowledgement:
   44  *      This product includes software developed by the University of
   45  *      California, Berkeley and its contributors.
   46  * 4. Neither the name of the University nor the names of its contributors
   47  *    may be used to endorse or promote products derived from this software
   48  *    without specific prior written permission.
   49  *
   50  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   51  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   52  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   53  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   54  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   55  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   56  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   57  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   58  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   59  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   60  * SUCH DAMAGE.
   61  *
   62  *      @(#)spx_usrreq.h
   63  */
   64 
   65 #include <sys/cdefs.h>
   66 __FBSDID("$FreeBSD: stable/8/sys/netipx/spx_usrreq.c 199583 2009-11-20 15:27:52Z jhb $");
   67 
   68 #include <sys/param.h>
   69 #include <sys/lock.h>
   70 #include <sys/malloc.h>
   71 #include <sys/mbuf.h>
   72 #include <sys/mutex.h>
   73 #include <sys/proc.h>
   74 #include <sys/protosw.h>
   75 #include <sys/signalvar.h>
   76 #include <sys/socket.h>
   77 #include <sys/socketvar.h>
   78 #include <sys/sx.h>
   79 #include <sys/systm.h>
   80 
   81 #include <net/route.h>
   82 #include <netinet/tcp_fsm.h>
   83 
   84 #include <netipx/ipx.h>
   85 #include <netipx/ipx_pcb.h>
   86 #include <netipx/ipx_var.h>
   87 #include <netipx/spx.h>
   88 #include <netipx/spx_debug.h>
   89 #include <netipx/spx_timer.h>
   90 #include <netipx/spx_var.h>
   91 
   92 #include <security/mac/mac_framework.h>
   93 
   94 /*
   95  * SPX protocol implementation.
   96  */
   97 static struct   mtx spx_mtx;                    /* Protects only spx_iss. */
   98 static u_short  spx_iss;
   99 u_short         spx_newchecks[50];
  100 static int      spx_hardnosed;
  101 static int      traceallspxs = 0;
  102 struct  spx_istat spx_istat;
  103 
  104 #define SPX_LOCK_INIT() mtx_init(&spx_mtx, "spx_mtx", NULL, MTX_DEF)
  105 #define SPX_LOCK()      mtx_lock(&spx_mtx)
  106 #define SPX_UNLOCK()    mtx_unlock(&spx_mtx)
  107 
  108 static const int spx_backoff[SPX_MAXRXTSHIFT+1] =
  109     { 1, 2, 4, 8, 16, 32, 64, 64, 64, 64, 64, 64, 64 };
  110 
  111 static  void spx_close(struct spxpcb *cb);
  112 static  void spx_disconnect(struct spxpcb *cb);
  113 static  void spx_drop(struct spxpcb *cb, int errno);
  114 static  void spx_setpersist(struct spxpcb *cb);
  115 static  void spx_template(struct spxpcb *cb);
  116 static  void spx_timers(struct spxpcb *cb, int timer);
  117 static  void spx_usrclosed(struct spxpcb *cb);
  118 
  119 static  void spx_usr_abort(struct socket *so);
  120 static  int spx_accept(struct socket *so, struct sockaddr **nam);
  121 static  int spx_attach(struct socket *so, int proto, struct thread *td);
  122 static  int spx_bind(struct socket *so, struct sockaddr *nam, struct thread *td);
  123 static  void spx_usr_close(struct socket *so);
  124 static  int spx_connect(struct socket *so, struct sockaddr *nam,
  125                         struct thread *td);
  126 static  void spx_detach(struct socket *so);
  127 static  void spx_pcbdetach(struct ipxpcb *ipxp);
  128 static  int spx_usr_disconnect(struct socket *so);
  129 static  int spx_listen(struct socket *so, int backlog, struct thread *td);
  130 static  int spx_rcvd(struct socket *so, int flags);
  131 static  int spx_rcvoob(struct socket *so, struct mbuf *m, int flags);
  132 static  int spx_send(struct socket *so, int flags, struct mbuf *m,
  133                      struct sockaddr *addr, struct mbuf *control,
  134                      struct thread *td);
  135 static  int spx_shutdown(struct socket *so);
  136 static  int spx_sp_attach(struct socket *so, int proto, struct thread *td);
  137 
  138 struct  pr_usrreqs spx_usrreqs = {
  139         .pru_abort =            spx_usr_abort,
  140         .pru_accept =           spx_accept,
  141         .pru_attach =           spx_attach,
  142         .pru_bind =             spx_bind,
  143         .pru_connect =          spx_connect,
  144         .pru_control =          ipx_control,
  145         .pru_detach =           spx_detach,
  146         .pru_disconnect =       spx_usr_disconnect,
  147         .pru_listen =           spx_listen,
  148         .pru_peeraddr =         ipx_peeraddr,
  149         .pru_rcvd =             spx_rcvd,
  150         .pru_rcvoob =           spx_rcvoob,
  151         .pru_send =             spx_send,
  152         .pru_shutdown =         spx_shutdown,
  153         .pru_sockaddr =         ipx_sockaddr,
  154         .pru_close =            spx_usr_close,
  155 };
  156 
  157 struct  pr_usrreqs spx_usrreq_sps = {
  158         .pru_abort =            spx_usr_abort,
  159         .pru_accept =           spx_accept,
  160         .pru_attach =           spx_sp_attach,
  161         .pru_bind =             spx_bind,
  162         .pru_connect =          spx_connect,
  163         .pru_control =          ipx_control,
  164         .pru_detach =           spx_detach,
  165         .pru_disconnect =       spx_usr_disconnect,
  166         .pru_listen =           spx_listen,
  167         .pru_peeraddr =         ipx_peeraddr,
  168         .pru_rcvd =             spx_rcvd,
  169         .pru_rcvoob =           spx_rcvoob,
  170         .pru_send =             spx_send,
  171         .pru_shutdown =         spx_shutdown,
  172         .pru_sockaddr =         ipx_sockaddr,
  173         .pru_close =            spx_usr_close,
  174 };
  175 
  176 void
  177 spx_init(void)
  178 {
  179 
  180         SPX_LOCK_INIT();
  181         spx_iss = 1; /* WRONG !! should fish it out of TODR */
  182 }
  183 
  184 void
  185 spx_input(struct mbuf *m, struct ipxpcb *ipxp)
  186 {
  187         struct spxpcb *cb;
  188         struct spx *si = mtod(m, struct spx *);
  189         struct socket *so;
  190         struct spx spx_savesi;
  191         int dropsocket = 0;
  192         short ostate = 0;
  193 
  194         spxstat.spxs_rcvtotal++;
  195         KASSERT(ipxp != NULL, ("spx_input: ipxpcb == NULL"));
  196 
  197         /*
  198          * spx_input() assumes that the caller will hold both the pcb list
  199          * lock and also the ipxp lock.  spx_input() will release both before
  200          * returning, and may in fact trade in the ipxp lock for another pcb
  201          * lock following sonewconn().
  202          */
  203         IPX_LIST_LOCK_ASSERT();
  204         IPX_LOCK_ASSERT(ipxp);
  205 
  206         cb = ipxtospxpcb(ipxp);
  207         KASSERT(cb != NULL, ("spx_input: cb == NULL"));
  208 
  209         if (ipxp->ipxp_flags & IPXP_DROPPED)
  210                 goto drop;
  211 
  212         if (m->m_len < sizeof(*si)) {
  213                 if ((m = m_pullup(m, sizeof(*si))) == NULL) {
  214                         IPX_UNLOCK(ipxp);
  215                         IPX_LIST_UNLOCK();
  216                         spxstat.spxs_rcvshort++;
  217                         return;
  218                 }
  219                 si = mtod(m, struct spx *);
  220         }
  221         si->si_seq = ntohs(si->si_seq);
  222         si->si_ack = ntohs(si->si_ack);
  223         si->si_alo = ntohs(si->si_alo);
  224 
  225         so = ipxp->ipxp_socket;
  226         KASSERT(so != NULL, ("spx_input: so == NULL"));
  227 
  228 #ifdef MAC
  229         if (mac_socket_check_deliver(so, m) != 0)
  230                 goto drop;
  231 #endif
  232 
  233         if (so->so_options & SO_DEBUG || traceallspxs) {
  234                 ostate = cb->s_state;
  235                 spx_savesi = *si;
  236         }
  237         if (so->so_options & SO_ACCEPTCONN) {
  238                 struct spxpcb *ocb = cb;
  239 
  240                 so = sonewconn(so, 0);
  241                 if (so == NULL)
  242                         goto drop;
  243 
  244                 /*
  245                  * This is ugly, but ....
  246                  *
  247                  * Mark socket as temporary until we're committed to keeping
  248                  * it.  The code at ``drop'' and ``dropwithreset'' check the
  249                  * flag dropsocket to see if the temporary socket created
  250                  * here should be discarded.  We mark the socket as
  251                  * discardable until we're committed to it below in
  252                  * TCPS_LISTEN.
  253                  *
  254                  * XXXRW: In the new world order of real kernel parallelism,
  255                  * temporarily allocating the socket when we're "not sure"
  256                  * seems like a bad idea, as we might race to remove it if
  257                  * the listen socket is closed...?
  258                  *
  259                  * We drop the lock of the listen socket ipxp, and acquire
  260                  * the lock of the new socket ippx.
  261                  */
  262                 dropsocket++;
  263                 IPX_UNLOCK(ipxp);
  264                 ipxp = (struct ipxpcb *)so->so_pcb;
  265                 IPX_LOCK(ipxp);
  266                 ipxp->ipxp_laddr = si->si_dna;
  267                 cb = ipxtospxpcb(ipxp);
  268                 cb->s_mtu = ocb->s_mtu;         /* preserve sockopts */
  269                 cb->s_flags = ocb->s_flags;     /* preserve sockopts */
  270                 cb->s_flags2 = ocb->s_flags2;   /* preserve sockopts */
  271                 cb->s_state = TCPS_LISTEN;
  272         }
  273         IPX_LOCK_ASSERT(ipxp);
  274 
  275         /*
  276          * Packet received on connection.  Reset idle time and keep-alive
  277          * timer.
  278          */
  279         cb->s_idle = 0;
  280         cb->s_timer[SPXT_KEEP] = SPXTV_KEEP;
  281 
  282         switch (cb->s_state) {
  283         case TCPS_LISTEN:{
  284                 struct sockaddr_ipx *sipx, ssipx;
  285                 struct ipx_addr laddr;
  286 
  287                 /*
  288                  * If somebody here was carying on a conversation and went
  289                  * away, and his pen pal thinks he can still talk, we get the
  290                  * misdirected packet.
  291                  */
  292                 if (spx_hardnosed && (si->si_did != 0 || si->si_seq != 0)) {
  293                         spx_istat.gonawy++;
  294                         goto dropwithreset;
  295                 }
  296                 sipx = &ssipx;
  297                 bzero(sipx, sizeof *sipx);
  298                 sipx->sipx_len = sizeof(*sipx);
  299                 sipx->sipx_family = AF_IPX;
  300                 sipx->sipx_addr = si->si_sna;
  301                 laddr = ipxp->ipxp_laddr;
  302                 if (ipx_nullhost(laddr))
  303                         ipxp->ipxp_laddr = si->si_dna;
  304                 if (ipx_pcbconnect(ipxp, (struct sockaddr *)sipx, &thread0)) {
  305                         ipxp->ipxp_laddr = laddr;
  306                         spx_istat.noconn++;
  307                         goto drop;
  308                 }
  309                 spx_template(cb);
  310                 dropsocket = 0;         /* committed to socket */
  311                 cb->s_did = si->si_sid;
  312                 cb->s_rack = si->si_ack;
  313                 cb->s_ralo = si->si_alo;
  314 #define THREEWAYSHAKE
  315 #ifdef THREEWAYSHAKE
  316                 cb->s_state = TCPS_SYN_RECEIVED;
  317                 cb->s_force = 1 + SPXT_KEEP;
  318                 spxstat.spxs_accepts++;
  319                 cb->s_timer[SPXT_KEEP] = SPXTV_KEEP;
  320                 }
  321                 break;
  322 
  323          case TCPS_SYN_RECEIVED: {
  324                 /*
  325                  * This state means that we have heard a response to our
  326                  * acceptance of their connection.  It is probably logically
  327                  * unnecessary in this implementation.
  328                  */
  329                 if (si->si_did != cb->s_sid) {
  330                         spx_istat.wrncon++;
  331                         goto drop;
  332                 }
  333 #endif
  334                 ipxp->ipxp_fport =  si->si_sport;
  335                 cb->s_timer[SPXT_REXMT] = 0;
  336                 cb->s_timer[SPXT_KEEP] = SPXTV_KEEP;
  337                 soisconnected(so);
  338                 cb->s_state = TCPS_ESTABLISHED;
  339                 spxstat.spxs_accepts++;
  340                 }
  341                 break;
  342 
  343         case TCPS_SYN_SENT:
  344                 /*
  345                  * This state means that we have gotten a response to our
  346                  * attempt to establish a connection.  We fill in the data
  347                  * from the other side, telling us which port to respond to,
  348                  * instead of the well-known one we might have sent to in the
  349                  * first place.  We also require that this is a response to
  350                  * our connection id.
  351                  */
  352                 if (si->si_did != cb->s_sid) {
  353                         spx_istat.notme++;
  354                         goto drop;
  355                 }
  356                 spxstat.spxs_connects++;
  357                 cb->s_did = si->si_sid;
  358                 cb->s_rack = si->si_ack;
  359                 cb->s_ralo = si->si_alo;
  360                 cb->s_dport = ipxp->ipxp_fport =  si->si_sport;
  361                 cb->s_timer[SPXT_REXMT] = 0;
  362                 cb->s_flags |= SF_ACKNOW;
  363                 soisconnected(so);
  364                 cb->s_state = TCPS_ESTABLISHED;
  365 
  366                 /*
  367                  * Use roundtrip time of connection request for initial rtt.
  368                  */
  369                 if (cb->s_rtt) {
  370                         cb->s_srtt = cb->s_rtt << 3;
  371                         cb->s_rttvar = cb->s_rtt << 1;
  372                         SPXT_RANGESET(cb->s_rxtcur,
  373                             ((cb->s_srtt >> 2) + cb->s_rttvar) >> 1,
  374                             SPXTV_MIN, SPXTV_REXMTMAX);
  375                             cb->s_rtt = 0;
  376                 }
  377         }
  378 
  379         if (so->so_options & SO_DEBUG || traceallspxs)
  380                 spx_trace(SA_INPUT, (u_char)ostate, cb, &spx_savesi, 0);
  381 
  382         m->m_len -= sizeof(struct ipx);
  383         m->m_pkthdr.len -= sizeof(struct ipx);
  384         m->m_data += sizeof(struct ipx);
  385 
  386         if (spx_reass(cb, m, si))
  387                 m_freem(m);
  388         if (cb->s_force || (cb->s_flags & (SF_ACKNOW|SF_WIN|SF_RXT)))
  389                 spx_output(cb, NULL);
  390         cb->s_flags &= ~(SF_WIN|SF_RXT);
  391         IPX_UNLOCK(ipxp);
  392         IPX_LIST_UNLOCK();
  393         return;
  394 
  395 dropwithreset:
  396         IPX_LOCK_ASSERT(ipxp);
  397         if (cb == NULL || (cb->s_ipxpcb->ipxp_socket->so_options & SO_DEBUG ||
  398             traceallspxs))
  399                 spx_trace(SA_DROP, (u_char)ostate, cb, &spx_savesi, 0);
  400         IPX_UNLOCK(ipxp);
  401         if (dropsocket) {
  402                 struct socket *head;
  403                 ACCEPT_LOCK();
  404                 KASSERT((so->so_qstate & SQ_INCOMP) != 0,
  405                     ("spx_input: nascent socket not SQ_INCOMP on soabort()"));
  406                 head = so->so_head;
  407                 TAILQ_REMOVE(&head->so_incomp, so, so_list);
  408                 head->so_incqlen--;
  409                 so->so_qstate &= ~SQ_INCOMP;
  410                 so->so_head = NULL;
  411                 ACCEPT_UNLOCK();
  412                 soabort(so);
  413         }
  414         IPX_LIST_UNLOCK();
  415         m_freem(m);
  416         return;
  417 
  418 drop:
  419         IPX_LOCK_ASSERT(ipxp);
  420         if (cb->s_ipxpcb->ipxp_socket->so_options & SO_DEBUG || traceallspxs)
  421                 spx_trace(SA_DROP, (u_char)ostate, cb, &spx_savesi, 0);
  422         IPX_UNLOCK(ipxp);
  423         IPX_LIST_UNLOCK();
  424         m_freem(m);
  425 }
  426 
  427 void
  428 spx_ctlinput(int cmd, struct sockaddr *arg_as_sa, void *dummy)
  429 {
  430 
  431         /* Currently, nothing. */
  432 }
  433 
  434 int
  435 spx_output(struct spxpcb *cb, struct mbuf *m0)
  436 {
  437         struct socket *so = cb->s_ipxpcb->ipxp_socket;
  438         struct mbuf *m = NULL;
  439         struct spx *si = NULL;
  440         struct sockbuf *sb = &so->so_snd;
  441         int len = 0, win, rcv_win;
  442         short span, off, recordp = 0;
  443         u_short alo;
  444         int error = 0, sendalot;
  445 #ifdef notdef
  446         int idle;
  447 #endif
  448         struct mbuf *mprev;
  449 
  450         IPX_LOCK_ASSERT(cb->s_ipxpcb);
  451 
  452         if (m0 != NULL) {
  453                 int mtu = cb->s_mtu;
  454                 int datalen;
  455 
  456                 /*
  457                  * Make sure that packet isn't too big.
  458                  */
  459                 for (m = m0; m != NULL; m = m->m_next) {
  460                         mprev = m;
  461                         len += m->m_len;
  462                         if (m->m_flags & M_EOR)
  463                                 recordp = 1;
  464                 }
  465                 datalen = (cb->s_flags & SF_HO) ?
  466                                 len - sizeof(struct spxhdr) : len;
  467                 if (datalen > mtu) {
  468                         if (cb->s_flags & SF_PI) {
  469                                 m_freem(m0);
  470                                 return (EMSGSIZE);
  471                         } else {
  472                                 int oldEM = cb->s_cc & SPX_EM;
  473 
  474                                 cb->s_cc &= ~SPX_EM;
  475                                 while (len > mtu) {
  476                                         m = m_copym(m0, 0, mtu, M_DONTWAIT);
  477                                         if (m == NULL) {
  478                                             cb->s_cc |= oldEM;
  479                                             m_freem(m0);
  480                                             return (ENOBUFS);
  481                                         }
  482                                         if (cb->s_flags & SF_NEWCALL) {
  483                                             struct mbuf *mm = m;
  484                                             spx_newchecks[7]++;
  485                                             while (mm != NULL) {
  486                                                 mm->m_flags &= ~M_EOR;
  487                                                 mm = mm->m_next;
  488                                             }
  489                                         }
  490                                         error = spx_output(cb, m);
  491                                         if (error) {
  492                                                 cb->s_cc |= oldEM;
  493                                                 m_freem(m0);
  494                                                 return (error);
  495                                         }
  496                                         m_adj(m0, mtu);
  497                                         len -= mtu;
  498                                 }
  499                                 cb->s_cc |= oldEM;
  500                         }
  501                 }
  502 
  503                 /*
  504                  * Force length even, by adding a "garbage byte" if
  505                  * necessary.
  506                  */
  507                 if (len & 1) {
  508                         m = mprev;
  509                         if (M_TRAILINGSPACE(m) >= 1)
  510                                 m->m_len++;
  511                         else {
  512                                 struct mbuf *m1 = m_get(M_DONTWAIT, MT_DATA);
  513 
  514                                 if (m1 == NULL) {
  515                                         m_freem(m0);
  516                                         return (ENOBUFS);
  517                                 }
  518                                 m1->m_len = 1;
  519                                 *(mtod(m1, u_char *)) = 0;
  520                                 m->m_next = m1;
  521                         }
  522                 }
  523                 m = m_gethdr(M_DONTWAIT, MT_DATA);
  524                 if (m == NULL) {
  525                         m_freem(m0);
  526                         return (ENOBUFS);
  527                 }
  528 
  529                 /*
  530                  * Fill in mbuf with extended SP header and addresses and
  531                  * length put into network format.
  532                  */
  533                 MH_ALIGN(m, sizeof(struct spx));
  534                 m->m_len = sizeof(struct spx);
  535                 m->m_next = m0;
  536                 si = mtod(m, struct spx *);
  537                 si->si_i = cb->s_ipx;
  538                 si->si_s = cb->s_shdr;
  539                 if ((cb->s_flags & SF_PI) && (cb->s_flags & SF_HO)) {
  540                         struct spxhdr *sh;
  541                         if (m0->m_len < sizeof(*sh)) {
  542                                 if((m0 = m_pullup(m0, sizeof(*sh))) == NULL) {
  543                                         m_free(m);
  544                                         m_freem(m0);
  545                                         return (EINVAL);
  546                                 }
  547                                 m->m_next = m0;
  548                         }
  549                         sh = mtod(m0, struct spxhdr *);
  550                         si->si_dt = sh->spx_dt;
  551                         si->si_cc |= sh->spx_cc & SPX_EM;
  552                         m0->m_len -= sizeof(*sh);
  553                         m0->m_data += sizeof(*sh);
  554                         len -= sizeof(*sh);
  555                 }
  556                 len += sizeof(*si);
  557                 if ((cb->s_flags2 & SF_NEWCALL) && recordp) {
  558                         si->si_cc |= SPX_EM;
  559                         spx_newchecks[8]++;
  560                 }
  561                 if (cb->s_oobflags & SF_SOOB) {
  562                         /*
  563                          * Per jqj@cornell: Make sure OB packets convey
  564                          * exactly 1 byte.  If the packet is 1 byte or
  565                          * larger, we have already guaranted there to be at
  566                          * least one garbage byte for the checksum, and extra
  567                          * bytes shouldn't hurt!
  568                          */
  569                         if (len > sizeof(*si)) {
  570                                 si->si_cc |= SPX_OB;
  571                                 len = (1 + sizeof(*si));
  572                         }
  573                 }
  574                 si->si_len = htons((u_short)len);
  575                 m->m_pkthdr.len = ((len - 1) | 1) + 1;
  576 
  577                 /*
  578                  * Queue stuff up for output.
  579                  */
  580                 sbappendrecord(sb, m);
  581                 cb->s_seq++;
  582         }
  583 #ifdef notdef
  584         idle = (cb->s_smax == (cb->s_rack - 1));
  585 #endif
  586 again:
  587         sendalot = 0;
  588         off = cb->s_snxt - cb->s_rack;
  589         win = min(cb->s_swnd, (cb->s_cwnd / CUNIT));
  590 
  591         /*
  592          * If in persist timeout with window of 0, send a probe.  Otherwise,
  593          * if window is small but non-zero and timer expired, send what we
  594          * can and go into transmit state.
  595          */
  596         if (cb->s_force == 1 + SPXT_PERSIST) {
  597                 if (win != 0) {
  598                         cb->s_timer[SPXT_PERSIST] = 0;
  599                         cb->s_rxtshift = 0;
  600                 }
  601         }
  602         span = cb->s_seq - cb->s_rack;
  603         len = min(span, win) - off;
  604 
  605         if (len < 0) {
  606                 /*
  607                  * Window shrank after we went into it.  If window shrank to
  608                  * 0, cancel pending restransmission and pull s_snxt back to
  609                  * (closed) window.  We will enter persist state below.  If
  610                  * the widndow didn't close completely, just wait for an ACK.
  611                  */
  612                 len = 0;
  613                 if (win == 0) {
  614                         cb->s_timer[SPXT_REXMT] = 0;
  615                         cb->s_snxt = cb->s_rack;
  616                 }
  617         }
  618         if (len > 1)
  619                 sendalot = 1;
  620         rcv_win = sbspace(&so->so_rcv);
  621 
  622         /*
  623          * Send if we owe peer an ACK.
  624          */
  625         if (cb->s_oobflags & SF_SOOB) {
  626                 /*
  627                  * Must transmit this out of band packet.
  628                  */
  629                 cb->s_oobflags &= ~ SF_SOOB;
  630                 sendalot = 1;
  631                 spxstat.spxs_sndurg++;
  632                 goto found;
  633         }
  634         if (cb->s_flags & SF_ACKNOW)
  635                 goto send;
  636         if (cb->s_state < TCPS_ESTABLISHED)
  637                 goto send;
  638 
  639         /*
  640          * Silly window can't happen in spx.  Code from TCP deleted.
  641          */
  642         if (len)
  643                 goto send;
  644 
  645         /*
  646          * Compare available window to amount of window known to peer (as
  647          * advertised window less next expected input.)  If the difference is
  648          * at least two packets or at least 35% of the mximum possible
  649          * window, then want to send a window update to peer.
  650          */
  651         if (rcv_win > 0) {
  652                 u_short delta =  1 + cb->s_alo - cb->s_ack;
  653                 int adv = rcv_win - (delta * cb->s_mtu);
  654 
  655                 if ((so->so_rcv.sb_cc == 0 && adv >= (2 * cb->s_mtu)) ||
  656                     (100 * adv / so->so_rcv.sb_hiwat >= 35)) {
  657                         spxstat.spxs_sndwinup++;
  658                         cb->s_flags |= SF_ACKNOW;
  659                         goto send;
  660                 }
  661 
  662         }
  663 
  664         /*
  665          * Many comments from tcp_output.c are appropriate here including ...
  666          * If send window is too small, there is data to transmit, and no
  667          * retransmit or persist is pending, then go to persist state.  If
  668          * nothing happens soon, send when timer expires: if window is
  669          * non-zero, transmit what we can, otherwise send a probe.
  670          */
  671         if (so->so_snd.sb_cc && cb->s_timer[SPXT_REXMT] == 0 &&
  672             cb->s_timer[SPXT_PERSIST] == 0) {
  673                 cb->s_rxtshift = 0;
  674                 spx_setpersist(cb);
  675         }
  676 
  677         /*
  678          * No reason to send a packet, just return.
  679          */
  680         cb->s_outx = 1;
  681         return (0);
  682 
  683 send:
  684         /*
  685          * Find requested packet.
  686          */
  687         si = NULL;
  688         m = NULL;
  689         if (len > 0) {
  690                 cb->s_want = cb->s_snxt;
  691                 for (m = sb->sb_mb; m != NULL; m = m->m_nextpkt) {
  692                         si = mtod(m, struct spx *);
  693                         if (SSEQ_LEQ(cb->s_snxt, si->si_seq))
  694                                 break;
  695                 }
  696         found:
  697                 if (si != NULL) {
  698                         if (si->si_seq != cb->s_snxt) {
  699                                 spxstat.spxs_sndvoid++;
  700                                 si = NULL;
  701                                 m = NULL;
  702                         } else
  703                                 cb->s_snxt++;
  704                 }
  705         }
  706 
  707         /*
  708          * Update window.
  709          */
  710         if (rcv_win < 0)
  711                 rcv_win = 0;
  712         alo = cb->s_ack - 1 + (rcv_win / ((short)cb->s_mtu));
  713         if (SSEQ_LT(alo, cb->s_alo))
  714                 alo = cb->s_alo;
  715 
  716         if (m != NULL) {
  717                 /*
  718                  * Must make a copy of this packet for ipx_output to monkey
  719                  * with.
  720                  */
  721                 m = m_copy(m, 0, M_COPYALL);
  722                 if (m == NULL)
  723                         return (ENOBUFS);
  724                 si = mtod(m, struct spx *);
  725                 if (SSEQ_LT(si->si_seq, cb->s_smax))
  726                         spxstat.spxs_sndrexmitpack++;
  727                 else
  728                         spxstat.spxs_sndpack++;
  729         } else if (cb->s_force || cb->s_flags & SF_ACKNOW) {
  730                 /*
  731                  * Must send an acknowledgement or a probe.
  732                  */
  733                 if (cb->s_force)
  734                         spxstat.spxs_sndprobe++;
  735                 if (cb->s_flags & SF_ACKNOW)
  736                         spxstat.spxs_sndacks++;
  737                 m = m_gethdr(M_DONTWAIT, MT_DATA);
  738                 if (m == NULL)
  739                         return (ENOBUFS);
  740 
  741                 /*
  742                  * Fill in mbuf with extended SP header and addresses and
  743                  * length put into network format.
  744                  */
  745                 MH_ALIGN(m, sizeof(struct spx));
  746                 m->m_len = sizeof(*si);
  747                 m->m_pkthdr.len = sizeof(*si);
  748                 si = mtod(m, struct spx *);
  749                 si->si_i = cb->s_ipx;
  750                 si->si_s = cb->s_shdr;
  751                 si->si_seq = cb->s_smax + 1;
  752                 si->si_len = htons(sizeof(*si));
  753                 si->si_cc |= SPX_SP;
  754         } else {
  755                 cb->s_outx = 3;
  756                 if (so->so_options & SO_DEBUG || traceallspxs)
  757                         spx_trace(SA_OUTPUT, cb->s_state, cb, si, 0);
  758                 return (0);
  759         }
  760 
  761         /*
  762          * Stuff checksum and output datagram.
  763          */
  764         if ((si->si_cc & SPX_SP) == 0) {
  765                 if (cb->s_force != (1 + SPXT_PERSIST) ||
  766                     cb->s_timer[SPXT_PERSIST] == 0) {
  767                         /*
  768                          * If this is a new packet and we are not currently
  769                          * timing anything, time this one.
  770                          */
  771                         if (SSEQ_LT(cb->s_smax, si->si_seq)) {
  772                                 cb->s_smax = si->si_seq;
  773                                 if (cb->s_rtt == 0) {
  774                                         spxstat.spxs_segstimed++;
  775                                         cb->s_rtseq = si->si_seq;
  776                                         cb->s_rtt = 1;
  777                                 }
  778                         }
  779 
  780                         /*
  781                          * Set rexmt timer if not currently set, initial
  782                          * value for retransmit timer is smoothed round-trip
  783                          * time + 2 * round-trip time variance.  Initialize
  784                          * shift counter which is used for backoff of
  785                          * retransmit time.
  786                          */
  787                         if (cb->s_timer[SPXT_REXMT] == 0 &&
  788                             cb->s_snxt != cb->s_rack) {
  789                                 cb->s_timer[SPXT_REXMT] = cb->s_rxtcur;
  790                                 if (cb->s_timer[SPXT_PERSIST]) {
  791                                         cb->s_timer[SPXT_PERSIST] = 0;
  792                                         cb->s_rxtshift = 0;
  793                                 }
  794                         }
  795                 } else if (SSEQ_LT(cb->s_smax, si->si_seq))
  796                         cb->s_smax = si->si_seq;
  797         } else if (cb->s_state < TCPS_ESTABLISHED) {
  798                 if (cb->s_rtt == 0)
  799                         cb->s_rtt = 1; /* Time initial handshake */
  800                 if (cb->s_timer[SPXT_REXMT] == 0)
  801                         cb->s_timer[SPXT_REXMT] = cb->s_rxtcur;
  802         }
  803 
  804         /*
  805          * Do not request acks when we ack their data packets or when we do a
  806          * gratuitous window update.
  807          */
  808         if (((si->si_cc & SPX_SP) == 0) || cb->s_force)
  809                 si->si_cc |= SPX_SA;
  810         si->si_seq = htons(si->si_seq);
  811         si->si_alo = htons(alo);
  812         si->si_ack = htons(cb->s_ack);
  813 
  814         if (ipxcksum)
  815                 si->si_sum = ipx_cksum(m, ntohs(si->si_len));
  816         else
  817                 si->si_sum = 0xffff;
  818 
  819         cb->s_outx = 4;
  820         if (so->so_options & SO_DEBUG || traceallspxs)
  821                 spx_trace(SA_OUTPUT, cb->s_state, cb, si, 0);
  822 
  823 #ifdef MAC
  824         mac_socket_create_mbuf(so, m);
  825 #endif
  826 
  827         if (so->so_options & SO_DONTROUTE)
  828                 error = ipx_outputfl(m, NULL, IPX_ROUTETOIF);
  829         else
  830                 error = ipx_outputfl(m, &cb->s_ipxpcb->ipxp_route, 0);
  831         if (error)
  832                 return (error);
  833         spxstat.spxs_sndtotal++;
  834 
  835         /*
  836          * Data sent (as far as we can tell).  If this advertises a larger
  837          * window than any other segment, then remember the size of the
  838          * advertized window.  Any pending ACK has now been sent.
  839          */
  840         cb->s_force = 0;
  841         cb->s_flags &= ~(SF_ACKNOW|SF_DELACK);
  842         if (SSEQ_GT(alo, cb->s_alo))
  843                 cb->s_alo = alo;
  844         if (sendalot)
  845                 goto again;
  846         cb->s_outx = 5;
  847         return (0);
  848 }
  849 
  850 static int spx_do_persist_panics = 0;
  851 
  852 static void
  853 spx_setpersist(struct spxpcb *cb)
  854 {
  855         int t = ((cb->s_srtt >> 2) + cb->s_rttvar) >> 1;
  856 
  857         IPX_LOCK_ASSERT(cb->s_ipxpcb);
  858 
  859         if (cb->s_timer[SPXT_REXMT] && spx_do_persist_panics)
  860                 panic("spx_output REXMT");
  861 
  862         /*
  863          * Start/restart persistance timer.
  864          */
  865         SPXT_RANGESET(cb->s_timer[SPXT_PERSIST],
  866             t*spx_backoff[cb->s_rxtshift],
  867             SPXTV_PERSMIN, SPXTV_PERSMAX);
  868         if (cb->s_rxtshift < SPX_MAXRXTSHIFT)
  869                 cb->s_rxtshift++;
  870 }
  871 
  872 int
  873 spx_ctloutput(struct socket *so, struct sockopt *sopt)
  874 {
  875         struct spxhdr spxhdr;
  876         struct ipxpcb *ipxp;
  877         struct spxpcb *cb;
  878         int mask, error;
  879         short soptval;
  880         u_short usoptval;
  881         int optval;
  882 
  883         ipxp = sotoipxpcb(so);
  884         KASSERT(ipxp != NULL, ("spx_ctloutput: ipxp == NULL"));
  885 
  886         /*
  887          * This will have to be changed when we do more general stacking of
  888          * protocols.
  889          */
  890         if (sopt->sopt_level != IPXPROTO_SPX)
  891                 return (ipx_ctloutput(so, sopt));
  892 
  893         IPX_LOCK(ipxp);
  894         if (ipxp->ipxp_flags & IPXP_DROPPED) {
  895                 IPX_UNLOCK(ipxp);
  896                 return (ECONNRESET);
  897         }
  898 
  899         IPX_LOCK(ipxp);
  900         cb = ipxtospxpcb(ipxp);
  901         KASSERT(cb != NULL, ("spx_ctloutput: cb == NULL"));
  902 
  903         error = 0;
  904         switch (sopt->sopt_dir) {
  905         case SOPT_GET:
  906                 switch (sopt->sopt_name) {
  907                 case SO_HEADERS_ON_INPUT:
  908                         mask = SF_HI;
  909                         goto get_flags;
  910 
  911                 case SO_HEADERS_ON_OUTPUT:
  912                         mask = SF_HO;
  913                 get_flags:
  914                         soptval = cb->s_flags & mask;
  915                         IPX_UNLOCK(ipxp);
  916                         error = sooptcopyout(sopt, &soptval,
  917                             sizeof(soptval));
  918                         break;
  919 
  920                 case SO_MTU:
  921                         usoptval = cb->s_mtu;
  922                         IPX_UNLOCK(ipxp);
  923                         error = sooptcopyout(sopt, &usoptval,
  924                             sizeof(usoptval));
  925                         break;
  926 
  927                 case SO_LAST_HEADER:
  928                         spxhdr = cb->s_rhdr;
  929                         IPX_UNLOCK(ipxp);
  930                         error = sooptcopyout(sopt, &spxhdr, sizeof(spxhdr));
  931                         break;
  932 
  933                 case SO_DEFAULT_HEADERS:
  934                         spxhdr = cb->s_shdr;
  935                         IPX_UNLOCK(ipxp);
  936                         error = sooptcopyout(sopt, &spxhdr, sizeof(spxhdr));
  937                         break;
  938 
  939                 default:
  940                         IPX_UNLOCK(ipxp);
  941                         error = ENOPROTOOPT;
  942                 }
  943                 break;
  944 
  945         case SOPT_SET:
  946                 /*
  947                  * XXX Why are these shorts on get and ints on set?  That
  948                  * doesn't make any sense...
  949                  *
  950                  * XXXRW: Note, when we re-acquire the ipxp lock, we should
  951                  * re-check that it's not dropped.
  952                  */
  953                 IPX_UNLOCK(ipxp);
  954                 switch (sopt->sopt_name) {
  955                 case SO_HEADERS_ON_INPUT:
  956                         mask = SF_HI;
  957                         goto set_head;
  958 
  959                 case SO_HEADERS_ON_OUTPUT:
  960                         mask = SF_HO;
  961                 set_head:
  962                         error = sooptcopyin(sopt, &optval, sizeof optval,
  963                                             sizeof optval);
  964                         if (error)
  965                                 break;
  966 
  967                         IPX_LOCK(ipxp);
  968                         if (cb->s_flags & SF_PI) {
  969                                 if (optval)
  970                                         cb->s_flags |= mask;
  971                                 else
  972                                         cb->s_flags &= ~mask;
  973                         } else error = EINVAL;
  974                         IPX_UNLOCK(ipxp);
  975                         break;
  976 
  977                 case SO_MTU:
  978                         error = sooptcopyin(sopt, &usoptval, sizeof usoptval,
  979                                             sizeof usoptval);
  980                         if (error)
  981                                 break;
  982                         /* Unlocked write. */
  983                         cb->s_mtu = usoptval;
  984                         break;
  985 
  986 #ifdef SF_NEWCALL
  987                 case SO_NEWCALL:
  988                         error = sooptcopyin(sopt, &optval, sizeof optval,
  989                                             sizeof optval);
  990                         if (error)
  991                                 break;
  992                         IPX_LOCK(ipxp);
  993                         if (optval) {
  994                                 cb->s_flags2 |= SF_NEWCALL;
  995                                 spx_newchecks[5]++;
  996                         } else {
  997                                 cb->s_flags2 &= ~SF_NEWCALL;
  998                                 spx_newchecks[6]++;
  999                         }
 1000                         IPX_UNLOCK(ipxp);
 1001                         break;
 1002 #endif
 1003 
 1004                 case SO_DEFAULT_HEADERS:
 1005                         {
 1006                                 struct spxhdr sp;
 1007 
 1008                                 error = sooptcopyin(sopt, &sp, sizeof sp,
 1009                                                     sizeof sp);
 1010                                 if (error)
 1011                                         break;
 1012                                 IPX_LOCK(ipxp);
 1013                                 cb->s_dt = sp.spx_dt;
 1014                                 cb->s_cc = sp.spx_cc & SPX_EM;
 1015                                 IPX_UNLOCK(ipxp);
 1016                         }
 1017                         break;
 1018 
 1019                 default:
 1020                         error = ENOPROTOOPT;
 1021                 }
 1022                 break;
 1023 
 1024         default:
 1025                 panic("spx_ctloutput: bad socket option direction");
 1026         }
 1027         return (error);
 1028 }
 1029 
 1030 static void
 1031 spx_usr_abort(struct socket *so)
 1032 {
 1033         struct ipxpcb *ipxp;
 1034         struct spxpcb *cb;
 1035 
 1036         ipxp = sotoipxpcb(so);
 1037         KASSERT(ipxp != NULL, ("spx_usr_abort: ipxp == NULL"));
 1038 
 1039         cb = ipxtospxpcb(ipxp);
 1040         KASSERT(cb != NULL, ("spx_usr_abort: cb == NULL"));
 1041 
 1042         IPX_LIST_LOCK();
 1043         IPX_LOCK(ipxp);
 1044         spx_drop(cb, ECONNABORTED);
 1045         IPX_UNLOCK(ipxp);
 1046         IPX_LIST_UNLOCK();
 1047 }
 1048 
 1049 /*
 1050  * Accept a connection.  Essentially all the work is done at higher levels;
 1051  * just return the address of the peer, storing through addr.
 1052  */
 1053 static int
 1054 spx_accept(struct socket *so, struct sockaddr **nam)
 1055 {
 1056         struct ipxpcb *ipxp;
 1057         struct sockaddr_ipx *sipx, ssipx;
 1058 
 1059         ipxp = sotoipxpcb(so);
 1060         KASSERT(ipxp != NULL, ("spx_accept: ipxp == NULL"));
 1061 
 1062         sipx = &ssipx;
 1063         bzero(sipx, sizeof *sipx);
 1064         sipx->sipx_len = sizeof *sipx;
 1065         sipx->sipx_family = AF_IPX;
 1066         IPX_LOCK(ipxp);
 1067         sipx->sipx_addr = ipxp->ipxp_faddr;
 1068         IPX_UNLOCK(ipxp);
 1069         *nam = sodupsockaddr((struct sockaddr *)sipx, M_WAITOK);
 1070         return (0);
 1071 }
 1072 
 1073 static int
 1074 spx_attach(struct socket *so, int proto, struct thread *td)
 1075 {
 1076         struct ipxpcb *ipxp;
 1077         struct spxpcb *cb;
 1078         struct mbuf *mm;
 1079         struct sockbuf *sb;
 1080         int error;
 1081 
 1082         ipxp = sotoipxpcb(so);
 1083         KASSERT(ipxp == NULL, ("spx_attach: ipxp != NULL"));
 1084 
 1085         if (so->so_snd.sb_hiwat == 0 || so->so_rcv.sb_hiwat == 0) {
 1086                 error = soreserve(so, (u_long) 3072, (u_long) 3072);
 1087                 if (error)
 1088                         return (error);
 1089         }
 1090 
 1091         cb = malloc(sizeof *cb, M_PCB, M_NOWAIT | M_ZERO);
 1092         if (cb == NULL)
 1093                 return (ENOBUFS);
 1094         mm = m_getclr(M_DONTWAIT, MT_DATA);
 1095         if (mm == NULL) {
 1096                 free(cb, M_PCB);
 1097                 return (ENOBUFS);
 1098         }
 1099 
 1100         IPX_LIST_LOCK();
 1101         error = ipx_pcballoc(so, &ipxpcb_list, td);
 1102         if (error) {
 1103                 IPX_LIST_UNLOCK();
 1104                 m_free(mm);
 1105                 free(cb, M_PCB);
 1106                 return (error);
 1107         }
 1108         ipxp = sotoipxpcb(so);
 1109         ipxp->ipxp_flags |= IPXP_SPX;
 1110 
 1111         cb->s_state = TCPS_LISTEN;
 1112         cb->s_smax = -1;
 1113         cb->s_swl1 = -1;
 1114         spx_reass_init(cb);
 1115         cb->s_ipxpcb = ipxp;
 1116         cb->s_mtu = 576 - sizeof(struct spx);
 1117         sb = &so->so_snd;
 1118         cb->s_cwnd = sbspace(sb) * CUNIT / cb->s_mtu;
 1119         cb->s_ssthresh = cb->s_cwnd;
 1120         cb->s_cwmx = sbspace(sb) * CUNIT / (2 * sizeof(struct spx));
 1121 
 1122         /*
 1123          * Above is recomputed when connecting to account for changed
 1124          * buffering or mtu's.
 1125          */
 1126         cb->s_rtt = SPXTV_SRTTBASE;
 1127         cb->s_rttvar = SPXTV_SRTTDFLT << 2;
 1128         SPXT_RANGESET(cb->s_rxtcur,
 1129             ((SPXTV_SRTTBASE >> 2) + (SPXTV_SRTTDFLT << 2)) >> 1,
 1130             SPXTV_MIN, SPXTV_REXMTMAX);
 1131         ipxp->ipxp_pcb = (caddr_t)cb;
 1132         IPX_LIST_UNLOCK();
 1133         return (0);
 1134 }
 1135 
 1136 static void
 1137 spx_pcbdetach(struct ipxpcb *ipxp)
 1138 {
 1139         struct spxpcb *cb;
 1140 
 1141         IPX_LOCK_ASSERT(ipxp);
 1142 
 1143         cb = ipxtospxpcb(ipxp);
 1144         KASSERT(cb != NULL, ("spx_pcbdetach: cb == NULL"));
 1145 
 1146         spx_reass_flush(cb);
 1147         free(cb, M_PCB);
 1148         ipxp->ipxp_pcb = NULL;
 1149 }
 1150 
 1151 static int
 1152 spx_bind(struct socket *so, struct sockaddr *nam, struct thread *td)
 1153 {
 1154         struct ipxpcb *ipxp;
 1155         int error;
 1156 
 1157         ipxp = sotoipxpcb(so);
 1158         KASSERT(ipxp != NULL, ("spx_bind: ipxp == NULL"));
 1159 
 1160         IPX_LIST_LOCK();
 1161         IPX_LOCK(ipxp);
 1162         if (ipxp->ipxp_flags & IPXP_DROPPED) {
 1163                 error = EINVAL;
 1164                 goto out;
 1165         }
 1166         error = ipx_pcbbind(ipxp, nam, td);
 1167 out:
 1168         IPX_UNLOCK(ipxp);
 1169         IPX_LIST_UNLOCK();
 1170         return (error);
 1171 }
 1172 
 1173 static void
 1174 spx_usr_close(struct socket *so)
 1175 {
 1176         struct ipxpcb *ipxp;
 1177         struct spxpcb *cb;
 1178 
 1179         ipxp = sotoipxpcb(so);
 1180         KASSERT(ipxp != NULL, ("spx_usr_close: ipxp == NULL"));
 1181 
 1182         cb = ipxtospxpcb(ipxp);
 1183         KASSERT(cb != NULL, ("spx_usr_close: cb == NULL"));
 1184 
 1185         IPX_LIST_LOCK();
 1186         IPX_LOCK(ipxp);
 1187         if (cb->s_state > TCPS_LISTEN)
 1188                 spx_disconnect(cb);
 1189         else
 1190                 spx_close(cb);
 1191         IPX_UNLOCK(ipxp);
 1192         IPX_LIST_UNLOCK();
 1193 }
 1194 
 1195 /*
 1196  * Initiate connection to peer.  Enter SYN_SENT state, and mark socket as
 1197  * connecting.  Start keep-alive timer, setup prototype header, send initial
 1198  * system packet requesting connection.
 1199  */
 1200 static int
 1201 spx_connect(struct socket *so, struct sockaddr *nam, struct thread *td)
 1202 {
 1203         struct ipxpcb *ipxp;
 1204         struct spxpcb *cb;
 1205         int error;
 1206 
 1207         ipxp = sotoipxpcb(so);
 1208         KASSERT(ipxp != NULL, ("spx_connect: ipxp == NULL"));
 1209 
 1210         cb = ipxtospxpcb(ipxp);
 1211         KASSERT(cb != NULL, ("spx_connect: cb == NULL"));
 1212 
 1213         IPX_LIST_LOCK();
 1214         IPX_LOCK(ipxp);
 1215         if (ipxp->ipxp_flags & IPXP_DROPPED) {
 1216                 error = EINVAL;
 1217                 goto spx_connect_end;
 1218         }
 1219         if (ipxp->ipxp_lport == 0) {
 1220                 error = ipx_pcbbind(ipxp, NULL, td);
 1221                 if (error)
 1222                         goto spx_connect_end;
 1223         }
 1224         error = ipx_pcbconnect(ipxp, nam, td);
 1225         if (error)
 1226                 goto spx_connect_end;
 1227         soisconnecting(so);
 1228         spxstat.spxs_connattempt++;
 1229         cb->s_state = TCPS_SYN_SENT;
 1230         cb->s_did = 0;
 1231         spx_template(cb);
 1232         cb->s_timer[SPXT_KEEP] = SPXTV_KEEP;
 1233         cb->s_force = 1 + SPXTV_KEEP;
 1234 
 1235         /*
 1236          * Other party is required to respond to the port I send from, but he
 1237          * is not required to answer from where I am sending to, so allow
 1238          * wildcarding.  Original port I am sending to is still saved in
 1239          * cb->s_dport.
 1240          */
 1241         ipxp->ipxp_fport = 0;
 1242         error = spx_output(cb, NULL);
 1243 spx_connect_end:
 1244         IPX_UNLOCK(ipxp);
 1245         IPX_LIST_UNLOCK();
 1246         return (error);
 1247 }
 1248 
 1249 static void
 1250 spx_detach(struct socket *so)
 1251 {
 1252         struct ipxpcb *ipxp;
 1253         struct spxpcb *cb;
 1254 
 1255         /*
 1256          * XXXRW: Should assert appropriately detached.
 1257          */
 1258         ipxp = sotoipxpcb(so);
 1259         KASSERT(ipxp != NULL, ("spx_detach: ipxp == NULL"));
 1260 
 1261         cb = ipxtospxpcb(ipxp);
 1262         KASSERT(cb != NULL, ("spx_detach: cb == NULL"));
 1263 
 1264         IPX_LIST_LOCK();
 1265         IPX_LOCK(ipxp);
 1266         spx_pcbdetach(ipxp);
 1267         ipx_pcbdetach(ipxp);
 1268         ipx_pcbfree(ipxp);
 1269         IPX_LIST_UNLOCK();
 1270 }
 1271 
 1272 /*
 1273  * We may decide later to implement connection closing handshaking at the spx
 1274  * level optionally.  Here is the hook to do it:
 1275  */
 1276 static int
 1277 spx_usr_disconnect(struct socket *so)
 1278 {
 1279         struct ipxpcb *ipxp;
 1280         struct spxpcb *cb;
 1281         int error;
 1282 
 1283         ipxp = sotoipxpcb(so);
 1284         KASSERT(ipxp != NULL, ("spx_usr_disconnect: ipxp == NULL"));
 1285 
 1286         cb = ipxtospxpcb(ipxp);
 1287         KASSERT(cb != NULL, ("spx_usr_disconnect: cb == NULL"));
 1288 
 1289         IPX_LIST_LOCK();
 1290         IPX_LOCK(ipxp);
 1291         if (ipxp->ipxp_flags & IPXP_DROPPED) {
 1292                 error = EINVAL;
 1293                 goto out;
 1294         }
 1295         spx_disconnect(cb);
 1296         error = 0;
 1297 out:
 1298         IPX_UNLOCK(ipxp);
 1299         IPX_LIST_UNLOCK();
 1300         return (error);
 1301 }
 1302 
 1303 static int
 1304 spx_listen(struct socket *so, int backlog, struct thread *td)
 1305 {
 1306         int error;
 1307         struct ipxpcb *ipxp;
 1308         struct spxpcb *cb;
 1309 
 1310         error = 0;
 1311         ipxp = sotoipxpcb(so);
 1312         KASSERT(ipxp != NULL, ("spx_listen: ipxp == NULL"));
 1313 
 1314         cb = ipxtospxpcb(ipxp);
 1315         KASSERT(cb != NULL, ("spx_listen: cb == NULL"));
 1316 
 1317         IPX_LIST_LOCK();
 1318         IPX_LOCK(ipxp);
 1319         if (ipxp->ipxp_flags & IPXP_DROPPED) {
 1320                 error = EINVAL;
 1321                 goto out;
 1322         }
 1323         SOCK_LOCK(so);
 1324         error = solisten_proto_check(so);
 1325         if (error == 0 && ipxp->ipxp_lport == 0)
 1326                 error = ipx_pcbbind(ipxp, NULL, td);
 1327         if (error == 0) {
 1328                 cb->s_state = TCPS_LISTEN;
 1329                 solisten_proto(so, backlog);
 1330         }
 1331         SOCK_UNLOCK(so);
 1332 out:
 1333         IPX_UNLOCK(ipxp);
 1334         IPX_LIST_UNLOCK();
 1335         return (error);
 1336 }
 1337 
 1338 /*
 1339  * After a receive, possibly send acknowledgment updating allocation.
 1340  */
 1341 static int
 1342 spx_rcvd(struct socket *so, int flags)
 1343 {
 1344         struct ipxpcb *ipxp;
 1345         struct spxpcb *cb;
 1346         int error;
 1347 
 1348         ipxp = sotoipxpcb(so);
 1349         KASSERT(ipxp != NULL, ("spx_rcvd: ipxp == NULL"));
 1350 
 1351         cb = ipxtospxpcb(ipxp);
 1352         KASSERT(cb != NULL, ("spx_rcvd: cb == NULL"));
 1353 
 1354         IPX_LOCK(ipxp);
 1355         if (ipxp->ipxp_flags & IPXP_DROPPED) {
 1356                 error = EINVAL;
 1357                 goto out;
 1358         }
 1359         cb->s_flags |= SF_RVD;
 1360         spx_output(cb, NULL);
 1361         cb->s_flags &= ~SF_RVD;
 1362         error = 0;
 1363 out:
 1364         IPX_UNLOCK(ipxp);
 1365         return (error);
 1366 }
 1367 
 1368 static int
 1369 spx_rcvoob(struct socket *so, struct mbuf *m, int flags)
 1370 {
 1371         struct ipxpcb *ipxp;
 1372         struct spxpcb *cb;
 1373         int error;
 1374 
 1375         ipxp = sotoipxpcb(so);
 1376         KASSERT(ipxp != NULL, ("spx_rcvoob: ipxp == NULL"));
 1377 
 1378         cb = ipxtospxpcb(ipxp);
 1379         KASSERT(cb != NULL, ("spx_rcvoob: cb == NULL"));
 1380 
 1381         IPX_LOCK(ipxp);
 1382         if (ipxp->ipxp_flags & IPXP_DROPPED) {
 1383                 error = EINVAL;
 1384                 goto out;
 1385         }
 1386         SOCKBUF_LOCK(&so->so_rcv);
 1387         if ((cb->s_oobflags & SF_IOOB) || so->so_oobmark ||
 1388             (so->so_rcv.sb_state & SBS_RCVATMARK)) {
 1389                 SOCKBUF_UNLOCK(&so->so_rcv);
 1390                 m->m_len = 1;
 1391                 *mtod(m, caddr_t) = cb->s_iobc;
 1392                 error = 0;
 1393                 goto out;
 1394         }
 1395         SOCKBUF_UNLOCK(&so->so_rcv);
 1396         error = EINVAL;
 1397 out:
 1398         IPX_UNLOCK(ipxp);
 1399         return (error);
 1400 }
 1401 
 1402 static int
 1403 spx_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr,
 1404     struct mbuf *controlp, struct thread *td)
 1405 {
 1406         struct ipxpcb *ipxp;
 1407         struct spxpcb *cb;
 1408         int error;
 1409 
 1410         ipxp = sotoipxpcb(so);
 1411         KASSERT(ipxp != NULL, ("spx_send: ipxp == NULL"));
 1412 
 1413         cb = ipxtospxpcb(ipxp);
 1414         KASSERT(cb != NULL, ("spx_send: cb == NULL"));
 1415 
 1416         error = 0;
 1417         IPX_LOCK(ipxp);
 1418         if (ipxp->ipxp_flags & IPXP_DROPPED) {
 1419                 error = ECONNRESET;
 1420                 goto spx_send_end;
 1421         }
 1422         if (flags & PRUS_OOB) {
 1423                 if (sbspace(&so->so_snd) < -512) {
 1424                         error = ENOBUFS;
 1425                         goto spx_send_end;
 1426                 }
 1427                 cb->s_oobflags |= SF_SOOB;
 1428         }
 1429         if (controlp != NULL) {
 1430                 u_short *p = mtod(controlp, u_short *);
 1431                 spx_newchecks[2]++;
 1432                 if ((p[0] == 5) && (p[1] == 1)) { /* XXXX, for testing */
 1433                         cb->s_shdr.spx_dt = *(u_char *)(&p[2]);
 1434                         spx_newchecks[3]++;
 1435                 }
 1436                 m_freem(controlp);
 1437         }
 1438         controlp = NULL;
 1439         error = spx_output(cb, m);
 1440         m = NULL;
 1441 spx_send_end:
 1442         IPX_UNLOCK(ipxp);
 1443         if (controlp != NULL)
 1444                 m_freem(controlp);
 1445         if (m != NULL)
 1446                 m_freem(m);
 1447         return (error);
 1448 }
 1449 
 1450 static int
 1451 spx_shutdown(struct socket *so)
 1452 {
 1453         struct ipxpcb *ipxp;
 1454         struct spxpcb *cb;
 1455         int error;
 1456 
 1457         ipxp = sotoipxpcb(so);
 1458         KASSERT(ipxp != NULL, ("spx_shutdown: ipxp == NULL"));
 1459 
 1460         cb = ipxtospxpcb(ipxp);
 1461         KASSERT(cb != NULL, ("spx_shutdown: cb == NULL"));
 1462 
 1463         socantsendmore(so);
 1464         IPX_LIST_LOCK();
 1465         IPX_LOCK(ipxp);
 1466         if (ipxp->ipxp_flags & IPXP_DROPPED) {
 1467                 error = EINVAL;
 1468                 goto out;
 1469         }
 1470         spx_usrclosed(cb);
 1471         error = 0;
 1472 out:
 1473         IPX_UNLOCK(ipxp);
 1474         IPX_LIST_UNLOCK();
 1475         return (error);
 1476 }
 1477 
 1478 static int
 1479 spx_sp_attach(struct socket *so, int proto, struct thread *td)
 1480 {
 1481         struct ipxpcb *ipxp;
 1482         struct spxpcb *cb;
 1483         int error;
 1484 
 1485         KASSERT(so->so_pcb == NULL, ("spx_sp_attach: so_pcb != NULL"));
 1486 
 1487         error = spx_attach(so, proto, td);
 1488         if (error)
 1489                 return (error);
 1490 
 1491         ipxp = sotoipxpcb(so);
 1492         KASSERT(ipxp != NULL, ("spx_sp_attach: ipxp == NULL"));
 1493 
 1494         cb = ipxtospxpcb(ipxp);
 1495         KASSERT(cb != NULL, ("spx_sp_attach: cb == NULL"));
 1496 
 1497         IPX_LOCK(ipxp);
 1498         cb->s_flags |= (SF_HI | SF_HO | SF_PI);
 1499         IPX_UNLOCK(ipxp);
 1500         return (0);
 1501 }
 1502 
 1503 /*
 1504  * Create template to be used to send spx packets on a connection.  Called
 1505  * after host entry created, fills in a skeletal spx header (choosing
 1506  * connection id), minimizing the amount of work necessary when the
 1507  * connection is used.
 1508  */
 1509 static void
 1510 spx_template(struct spxpcb *cb)
 1511 {
 1512         struct ipxpcb *ipxp = cb->s_ipxpcb;
 1513         struct sockbuf *sb = &(ipxp->ipxp_socket->so_snd);
 1514 
 1515         IPX_LOCK_ASSERT(ipxp);
 1516 
 1517         cb->s_ipx.ipx_pt = IPXPROTO_SPX;
 1518         cb->s_ipx.ipx_sna = ipxp->ipxp_laddr;
 1519         cb->s_ipx.ipx_dna = ipxp->ipxp_faddr;
 1520         SPX_LOCK();
 1521         cb->s_sid = htons(spx_iss);
 1522         spx_iss += SPX_ISSINCR/2;
 1523         SPX_UNLOCK();
 1524         cb->s_alo = 1;
 1525         cb->s_cwnd = (sbspace(sb) * CUNIT) / cb->s_mtu;
 1526 
 1527         /*
 1528          * Try to expand fast to full complement of large packets.
 1529          */
 1530         cb->s_ssthresh = cb->s_cwnd;
 1531         cb->s_cwmx = (sbspace(sb) * CUNIT) / (2 * sizeof(struct spx));
 1532 
 1533         /*
 1534          * But allow for lots of little packets as well.
 1535          */
 1536         cb->s_cwmx = max(cb->s_cwmx, cb->s_cwnd);
 1537 }
 1538 
 1539 /*
 1540  * Close a SPIP control block.  Wake up any sleepers.  We used to free any
 1541  * queued packets, but now we defer that until the pcb is discarded.
 1542  */
 1543 void
 1544 spx_close(struct spxpcb *cb)
 1545 {
 1546         struct ipxpcb *ipxp = cb->s_ipxpcb;
 1547         struct socket *so = ipxp->ipxp_socket;
 1548 
 1549         KASSERT(ipxp != NULL, ("spx_close: ipxp == NULL"));
 1550         IPX_LIST_LOCK_ASSERT();
 1551         IPX_LOCK_ASSERT(ipxp);
 1552 
 1553         ipxp->ipxp_flags |= IPXP_DROPPED;
 1554         soisdisconnected(so);
 1555         spxstat.spxs_closed++;
 1556 }
 1557 
 1558 /*
 1559  * Someday we may do level 3 handshaking to close a connection or send a
 1560  * xerox style error.  For now, just close.  cb will always be invalid after
 1561  * this call.
 1562  */
 1563 static void
 1564 spx_usrclosed(struct spxpcb *cb)
 1565 {
 1566 
 1567         IPX_LIST_LOCK_ASSERT();
 1568         IPX_LOCK_ASSERT(cb->s_ipxpcb);
 1569 
 1570         spx_close(cb);
 1571 }
 1572 
 1573 /*
 1574  * cb will always be invalid after this call.
 1575  */
 1576 static void
 1577 spx_disconnect(struct spxpcb *cb)
 1578 {
 1579 
 1580         IPX_LIST_LOCK_ASSERT();
 1581         IPX_LOCK_ASSERT(cb->s_ipxpcb);
 1582 
 1583         spx_close(cb);
 1584 }
 1585 
 1586 /*
 1587  * Drop connection, reporting the specified error.  cb will always be invalid
 1588  * after this call.
 1589  */
 1590 static void
 1591 spx_drop(struct spxpcb *cb, int errno)
 1592 {
 1593         struct socket *so = cb->s_ipxpcb->ipxp_socket;
 1594 
 1595         IPX_LIST_LOCK_ASSERT();
 1596         IPX_LOCK_ASSERT(cb->s_ipxpcb);
 1597 
 1598         /*
 1599          * Someday, in the xerox world we will generate error protocol
 1600          * packets announcing that the socket has gone away.
 1601          */
 1602         if (TCPS_HAVERCVDSYN(cb->s_state)) {
 1603                 spxstat.spxs_drops++;
 1604                 cb->s_state = TCPS_CLOSED;
 1605                 /*tcp_output(cb);*/
 1606         } else
 1607                 spxstat.spxs_conndrops++;
 1608         so->so_error = errno;
 1609         spx_close(cb);
 1610 }
 1611 
 1612 /*
 1613  * Fast timeout routine for processing delayed acks.
 1614  */
 1615 void
 1616 spx_fasttimo(void)
 1617 {
 1618         struct ipxpcb *ipxp;
 1619         struct spxpcb *cb;
 1620 
 1621         IPX_LIST_LOCK();
 1622         LIST_FOREACH(ipxp, &ipxpcb_list, ipxp_list) {
 1623                 IPX_LOCK(ipxp);
 1624                 if (!(ipxp->ipxp_flags & IPXP_SPX) ||
 1625                     (ipxp->ipxp_flags & IPXP_DROPPED)) {
 1626                         IPX_UNLOCK(ipxp);
 1627                         continue;
 1628                 }
 1629                 cb = ipxtospxpcb(ipxp);
 1630                 if (cb->s_flags & SF_DELACK) {
 1631                         cb->s_flags &= ~SF_DELACK;
 1632                         cb->s_flags |= SF_ACKNOW;
 1633                         spxstat.spxs_delack++;
 1634                         spx_output(cb, NULL);
 1635                 }
 1636                 IPX_UNLOCK(ipxp);
 1637         }
 1638         IPX_LIST_UNLOCK();
 1639 }
 1640 
 1641 /*
 1642  * spx protocol timeout routine called every 500 ms.  Updates the timers in
 1643  * all active pcb's and causes finite state machine actions if timers expire.
 1644  */
 1645 void
 1646 spx_slowtimo(void)
 1647 {
 1648         struct ipxpcb *ipxp;
 1649         struct spxpcb *cb;
 1650         int i;
 1651 
 1652         /*
 1653          * Search through tcb's and update active timers.  Once, timers could
 1654          * free ipxp's, but now we do that only when detaching a socket.
 1655          */
 1656         IPX_LIST_LOCK();
 1657         LIST_FOREACH(ipxp, &ipxpcb_list, ipxp_list) {
 1658                 IPX_LOCK(ipxp);
 1659                 if (!(ipxp->ipxp_flags & IPXP_SPX) ||
 1660                     (ipxp->ipxp_flags & IPXP_DROPPED)) {
 1661                         IPX_UNLOCK(ipxp);
 1662                         continue;
 1663                 }
 1664 
 1665                 cb = (struct spxpcb *)ipxp->ipxp_pcb;
 1666                 KASSERT(cb != NULL, ("spx_slowtimo: cb == NULL"));
 1667                 for (i = 0; i < SPXT_NTIMERS; i++) {
 1668                         if (cb->s_timer[i] && --cb->s_timer[i] == 0) {
 1669                                 spx_timers(cb, i);
 1670                                 if (ipxp->ipxp_flags & IPXP_DROPPED)
 1671                                         break;
 1672                         }
 1673                 }
 1674                 if (!(ipxp->ipxp_flags & IPXP_DROPPED)) {
 1675                         cb->s_idle++;
 1676                         if (cb->s_rtt)
 1677                                 cb->s_rtt++;
 1678                 }
 1679                 IPX_UNLOCK(ipxp);
 1680         }
 1681         IPX_LIST_UNLOCK();
 1682         SPX_LOCK();
 1683         spx_iss += SPX_ISSINCR/PR_SLOWHZ;               /* increment iss */
 1684         SPX_UNLOCK();
 1685 }
 1686 
 1687 /*
 1688  * SPX timer processing.
 1689  */
 1690 static void
 1691 spx_timers(struct spxpcb *cb, int timer)
 1692 {
 1693         long rexmt;
 1694         int win;
 1695 
 1696         IPX_LIST_LOCK_ASSERT();
 1697         IPX_LOCK_ASSERT(cb->s_ipxpcb);
 1698 
 1699         cb->s_force = 1 + timer;
 1700         switch (timer) {
 1701         case SPXT_2MSL:
 1702                 /*
 1703                  * 2 MSL timeout in shutdown went off.  TCP deletes
 1704                  * connection control block.
 1705                  */
 1706                 printf("spx: SPXT_2MSL went off for no reason\n");
 1707                 cb->s_timer[timer] = 0;
 1708                 break;
 1709 
 1710         case SPXT_REXMT:
 1711                 /*
 1712                  * Retransmission timer went off.  Message has not been acked
 1713                  * within retransmit interval.  Back off to a longer
 1714                  * retransmit interval and retransmit one packet.
 1715                  */
 1716                 if (++cb->s_rxtshift > SPX_MAXRXTSHIFT) {
 1717                         cb->s_rxtshift = SPX_MAXRXTSHIFT;
 1718                         spxstat.spxs_timeoutdrop++;
 1719                         spx_drop(cb, ETIMEDOUT);
 1720                         break;
 1721                 }
 1722                 spxstat.spxs_rexmttimeo++;
 1723                 rexmt = ((cb->s_srtt >> 2) + cb->s_rttvar) >> 1;
 1724                 rexmt *= spx_backoff[cb->s_rxtshift];
 1725                 SPXT_RANGESET(cb->s_rxtcur, rexmt, SPXTV_MIN, SPXTV_REXMTMAX);
 1726                 cb->s_timer[SPXT_REXMT] = cb->s_rxtcur;
 1727 
 1728                 /*
 1729                  * If we have backed off fairly far, our srtt estimate is
 1730                  * probably bogus.  Clobber it so we'll take the next rtt
 1731                  * measurement as our srtt; move the current srtt into rttvar
 1732                  * to keep the current retransmit times until then.
 1733                  */
 1734                 if (cb->s_rxtshift > SPX_MAXRXTSHIFT / 4 ) {
 1735                         cb->s_rttvar += (cb->s_srtt >> 2);
 1736                         cb->s_srtt = 0;
 1737                 }
 1738                 cb->s_snxt = cb->s_rack;
 1739 
 1740                 /*
 1741                  * If timing a packet, stop the timer.
 1742                  */
 1743                 cb->s_rtt = 0;
 1744 
 1745                 /*
 1746                  * See very long discussion in tcp_timer.c about congestion
 1747                  * window and sstrhesh.
 1748                  */
 1749                 win = min(cb->s_swnd, (cb->s_cwnd/CUNIT)) / 2;
 1750                 if (win < 2)
 1751                         win = 2;
 1752                 cb->s_cwnd = CUNIT;
 1753                 cb->s_ssthresh = win * CUNIT;
 1754                 spx_output(cb, NULL);
 1755                 break;
 1756 
 1757         case SPXT_PERSIST:
 1758                 /*
 1759                  * Persistance timer into zero window.  Force a probe to be
 1760                  * sent.
 1761                  */
 1762                 spxstat.spxs_persisttimeo++;
 1763                 spx_setpersist(cb);
 1764                 spx_output(cb, NULL);
 1765                 break;
 1766 
 1767         case SPXT_KEEP:
 1768                 /*
 1769                  * Keep-alive timer went off; send something or drop
 1770                  * connection if idle for too long.
 1771                  */
 1772                 spxstat.spxs_keeptimeo++;
 1773                 if (cb->s_state < TCPS_ESTABLISHED)
 1774                         goto dropit;
 1775                 if (cb->s_ipxpcb->ipxp_socket->so_options & SO_KEEPALIVE) {
 1776                         if (cb->s_idle >= SPXTV_MAXIDLE)
 1777                                 goto dropit;
 1778                         spxstat.spxs_keepprobe++;
 1779                         spx_output(cb, NULL);
 1780                 } else
 1781                         cb->s_idle = 0;
 1782                 cb->s_timer[SPXT_KEEP] = SPXTV_KEEP;
 1783                 break;
 1784 
 1785         dropit:
 1786                 spxstat.spxs_keepdrops++;
 1787                 spx_drop(cb, ETIMEDOUT);
 1788                 break;
 1789 
 1790         default:
 1791                 panic("spx_timers: unknown timer %d", timer);
 1792         }
 1793 }

Cache object: bddae012f42c7f7fc3c26d9e8d40e462


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.