ipx_usrreq.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*
    2  * Copyright (c) 1995, Mike Mitchell
    3  * Copyright (c) 1984, 1985, 1986, 1987, 1993
    4  *      The Regents of the University of California.  All rights reserved.
    5  *
    6  * Redistribution and use in source and binary forms, with or without
    7  * modification, are permitted provided that the following conditions
    8  * are met:
    9  * 1. Redistributions of source code must retain the above copyright
   10  *    notice, this list of conditions and the following disclaimer.
   11  * 2. Redistributions in binary form must reproduce the above copyright
   12  *    notice, this list of conditions and the following disclaimer in the
   13  *    documentation and/or other materials provided with the distribution.
   14  * 3. All advertising materials mentioning features or use of this software
   15  *    must display the following acknowledgement:
   16  *      This product includes software developed by the University of
   17  *      California, Berkeley and its contributors.
   18  * 4. Neither the name of the University nor the names of its contributors
   19  *    may be used to endorse or promote products derived from this software
   20  *    without specific prior written permission.
   21  *
   22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   32  * SUCH DAMAGE.
   33  *
   34  *      @(#)ipx_usrreq.c
   35  *
   36  * $FreeBSD: releng/5.0/sys/netipx/ipx_usrreq.c 97658 2002-05-31 11:52:35Z tanimura $
   37  */
   38 
   39 #include "opt_ipx.h"
   40 
   41 #include <sys/param.h>
   42 #include <sys/kernel.h>
   43 #include <sys/lock.h>
   44 #include <sys/mbuf.h>
   45 #include <sys/protosw.h>
   46 #include <sys/signalvar.h>
   47 #include <sys/socket.h>
   48 #include <sys/socketvar.h>
   49 #include <sys/sx.h>
   50 #include <sys/sysctl.h>
   51 #include <sys/systm.h>
   52 
   53 #include <net/if.h>
   54 #include <net/route.h>
   55 
   56 #include <netinet/in.h>
   57 
   58 #include <netipx/ipx.h>
   59 #include <netipx/ipx_if.h>
   60 #include <netipx/ipx_ip.h>
   61 #include <netipx/ipx_pcb.h>
   62 #include <netipx/ipx_var.h>
   63 
   64 /*
   65  * IPX protocol implementation.
   66  */
   67 
   68 static int ipxsendspace = IPXSNDQ;
   69 SYSCTL_INT(_net_ipx_ipx, OID_AUTO, ipxsendspace, CTLFLAG_RW,
   70             &ipxsendspace, 0, "");
   71 static int ipxrecvspace = IPXRCVQ;
   72 SYSCTL_INT(_net_ipx_ipx, OID_AUTO, ipxrecvspace, CTLFLAG_RW,
   73             &ipxrecvspace, 0, "");
   74 
   75 static  int ipx_usr_abort(struct socket *so);
   76 static  int ipx_attach(struct socket *so, int proto, struct thread *td);
   77 static  int ipx_bind(struct socket *so, struct sockaddr *nam, struct thread *td);
   78 static  int ipx_connect(struct socket *so, struct sockaddr *nam,
   79                         struct thread *td);
   80 static  int ipx_detach(struct socket *so);
   81 static  int ipx_disconnect(struct socket *so);
   82 static  int ipx_send(struct socket *so, int flags, struct mbuf *m,
   83                      struct sockaddr *addr, struct mbuf *control, 
   84                      struct thread *td);
   85 static  int ipx_shutdown(struct socket *so);
   86 static  int ripx_attach(struct socket *so, int proto, struct thread *td);
   87 static  int ipx_output(struct ipxpcb *ipxp, struct mbuf *m0);
   88 
   89 struct  pr_usrreqs ipx_usrreqs = {
   90         ipx_usr_abort, pru_accept_notsupp, ipx_attach, ipx_bind,
   91         ipx_connect, pru_connect2_notsupp, ipx_control, ipx_detach,
   92         ipx_disconnect, pru_listen_notsupp, ipx_peeraddr, pru_rcvd_notsupp,
   93         pru_rcvoob_notsupp, ipx_send, pru_sense_null, ipx_shutdown,
   94         ipx_sockaddr, sosend, soreceive, sopoll
   95 };
   96 
   97 struct  pr_usrreqs ripx_usrreqs = {
   98         ipx_usr_abort, pru_accept_notsupp, ripx_attach, ipx_bind,
   99         ipx_connect, pru_connect2_notsupp, ipx_control, ipx_detach,
  100         ipx_disconnect, pru_listen_notsupp, ipx_peeraddr, pru_rcvd_notsupp,
  101         pru_rcvoob_notsupp, ipx_send, pru_sense_null, ipx_shutdown,
  102         ipx_sockaddr, sosend, soreceive, sopoll
  103 };
  104 
  105 /*
  106  *  This may also be called for raw listeners.
  107  */
  108 void
  109 ipx_input(m, ipxp)
  110         struct mbuf *m;
  111         register struct ipxpcb *ipxp;
  112 {
  113         register struct ipx *ipx = mtod(m, struct ipx *);
  114         struct ifnet *ifp = m->m_pkthdr.rcvif;
  115         struct sockaddr_ipx ipx_ipx;
  116 
  117         if (ipxp == NULL)
  118                 panic("No ipxpcb");
  119         /*
  120          * Construct sockaddr format source address.
  121          * Stuff source address and datagram in user buffer.
  122          */
  123         ipx_ipx.sipx_len = sizeof(ipx_ipx);
  124         ipx_ipx.sipx_family = AF_IPX;
  125         ipx_ipx.sipx_addr = ipx->ipx_sna;
  126         ipx_ipx.sipx_zero[0] = '\0';
  127         ipx_ipx.sipx_zero[1] = '\0';
  128         if (ipx_neteqnn(ipx->ipx_sna.x_net, ipx_zeronet) && ifp != NULL) {
  129                 register struct ifaddr *ifa;
  130 
  131                 for (ifa = TAILQ_FIRST(&ifp->if_addrhead); ifa != NULL; 
  132                      ifa = TAILQ_NEXT(ifa, ifa_link)) {
  133                         if (ifa->ifa_addr->sa_family == AF_IPX) {
  134                                 ipx_ipx.sipx_addr.x_net =
  135                                         IA_SIPX(ifa)->sipx_addr.x_net;
  136                                 break;
  137                         }
  138                 }
  139         }
  140         ipxp->ipxp_rpt = ipx->ipx_pt;
  141         if (!(ipxp->ipxp_flags & IPXP_RAWIN) ) {
  142                 m->m_len -= sizeof(struct ipx);
  143                 m->m_pkthdr.len -= sizeof(struct ipx);
  144                 m->m_data += sizeof(struct ipx);
  145         }
  146         if (sbappendaddr(&ipxp->ipxp_socket->so_rcv, (struct sockaddr *)&ipx_ipx,
  147             m, (struct mbuf *)NULL) == 0)
  148                 goto bad;
  149         sorwakeup(ipxp->ipxp_socket);
  150         return;
  151 bad:
  152         m_freem(m);
  153 }
  154 
  155 void
  156 ipx_abort(ipxp)
  157         struct ipxpcb *ipxp;
  158 {
  159         struct socket *so = ipxp->ipxp_socket;
  160 
  161         ipx_pcbdisconnect(ipxp);
  162         soisdisconnected(so);
  163 }
  164 
  165 /*
  166  * Drop connection, reporting
  167  * the specified error.
  168  */
  169 void
  170 ipx_drop(ipxp, errno)
  171         register struct ipxpcb *ipxp;
  172         int errno;
  173 {
  174         struct socket *so = ipxp->ipxp_socket;
  175 
  176         /*
  177          * someday, in the IPX world
  178          * we will generate error protocol packets
  179          * announcing that the socket has gone away.
  180          *
  181          * XXX Probably never. IPX does not have error packets.
  182          */
  183         /*if (TCPS_HAVERCVDSYN(tp->t_state)) {
  184                 tp->t_state = TCPS_CLOSED;
  185                 tcp_output(tp);
  186         }*/
  187         so->so_error = errno;
  188         ipx_pcbdisconnect(ipxp);
  189         soisdisconnected(so);
  190 }
  191 
  192 static int
  193 ipx_output(ipxp, m0)
  194         struct ipxpcb *ipxp;
  195         struct mbuf *m0;
  196 {
  197         register struct ipx *ipx;
  198         register struct socket *so;
  199         register int len = 0;
  200         register struct route *ro;
  201         struct mbuf *m;
  202         struct mbuf *mprev = NULL;
  203 
  204         /*
  205          * Calculate data length.
  206          */
  207         for (m = m0; m != NULL; m = m->m_next) {
  208                 mprev = m;
  209                 len += m->m_len;
  210         }
  211         /*
  212          * Make sure packet is actually of even length.
  213          */
  214         
  215         if (len & 1) {
  216                 m = mprev;
  217                 if ((m->m_flags & M_EXT) == 0 &&
  218                         (m->m_len + m->m_data < &m->m_dat[MLEN])) {
  219                         mtod(m, char*)[m->m_len++] = 0;
  220                 } else {
  221                         struct mbuf *m1 = m_get(M_DONTWAIT, MT_DATA);
  222 
  223                         if (m1 == NULL) {
  224                                 m_freem(m0);
  225                                 return (ENOBUFS);
  226                         }
  227                         m1->m_len = 1;
  228                         * mtod(m1, char *) = 0;
  229                         m->m_next = m1;
  230                 }
  231                 m0->m_pkthdr.len++;
  232         }
  233 
  234         /*
  235          * Fill in mbuf with extended IPX header
  236          * and addresses and length put into network format.
  237          */
  238         m = m0;
  239         if (ipxp->ipxp_flags & IPXP_RAWOUT) {
  240                 ipx = mtod(m, struct ipx *);
  241         } else {
  242                 M_PREPEND(m, sizeof(struct ipx), M_DONTWAIT);
  243                 if (m == NULL)
  244                         return (ENOBUFS);
  245                 ipx = mtod(m, struct ipx *);
  246                 ipx->ipx_tc = 0;
  247                 ipx->ipx_pt = ipxp->ipxp_dpt;
  248                 ipx->ipx_sna = ipxp->ipxp_laddr;
  249                 ipx->ipx_dna = ipxp->ipxp_faddr;
  250                 len += sizeof(struct ipx);
  251         }
  252 
  253         ipx->ipx_len = htons((u_short)len);
  254 
  255         if (ipxp->ipxp_flags & IPXP_CHECKSUM) {
  256                 ipx->ipx_sum = ipx_cksum(m, len);
  257         } else
  258                 ipx->ipx_sum = 0xffff;
  259 
  260         /*
  261          * Output datagram.
  262          */
  263         so = ipxp->ipxp_socket;
  264         if (so->so_options & SO_DONTROUTE)
  265                 return (ipx_outputfl(m, (struct route *)NULL,
  266                     (so->so_options & SO_BROADCAST) | IPX_ROUTETOIF));
  267         /*
  268          * Use cached route for previous datagram if
  269          * possible.  If the previous net was the same
  270          * and the interface was a broadcast medium, or
  271          * if the previous destination was identical,
  272          * then we are ok.
  273          *
  274          * NB: We don't handle broadcasts because that
  275          *     would require 3 subroutine calls.
  276          */
  277         ro = &ipxp->ipxp_route;
  278 #ifdef ancient_history
  279         /*
  280          * I think that this will all be handled in ipx_pcbconnect!
  281          */
  282         if (ro->ro_rt != NULL) {
  283                 if(ipx_neteq(ipxp->ipxp_lastdst, ipx->ipx_dna)) {
  284                         /*
  285                          * This assumes we have no GH type routes
  286                          */
  287                         if (ro->ro_rt->rt_flags & RTF_HOST) {
  288                                 if (!ipx_hosteq(ipxp->ipxp_lastdst, ipx->ipx_dna))
  289                                         goto re_route;
  290 
  291                         }
  292                         if ((ro->ro_rt->rt_flags & RTF_GATEWAY) == 0) {
  293                                 register struct ipx_addr *dst =
  294                                                 &satoipx_addr(ro->ro_dst);
  295                                 dst->x_host = ipx->ipx_dna.x_host;
  296                         }
  297                         /* 
  298                          * Otherwise, we go through the same gateway
  299                          * and dst is already set up.
  300                          */
  301                 } else {
  302                 re_route:
  303                         RTFREE(ro->ro_rt);
  304                         ro->ro_rt = NULL;
  305                 }
  306         }
  307         ipxp->ipxp_lastdst = ipx->ipx_dna;
  308 #endif /* ancient_history */
  309         return (ipx_outputfl(m, ro, so->so_options & SO_BROADCAST));
  310 }
  311 
  312 int
  313 ipx_ctloutput(so, sopt)
  314         struct socket *so;
  315         struct sockopt *sopt;
  316 {
  317         struct ipxpcb *ipxp = sotoipxpcb(so);
  318         int mask, error, optval;
  319         short soptval;
  320         struct ipx ioptval;
  321 
  322         error = 0;
  323         if (ipxp == NULL)
  324                 return (EINVAL);
  325 
  326         switch (sopt->sopt_dir) {
  327         case SOPT_GET:
  328                 switch (sopt->sopt_name) {
  329                 case SO_ALL_PACKETS:
  330                         mask = IPXP_ALL_PACKETS;
  331                         goto get_flags;
  332 
  333                 case SO_HEADERS_ON_INPUT:
  334                         mask = IPXP_RAWIN;
  335                         goto get_flags;
  336 
  337                 case SO_IPX_CHECKSUM:
  338                         mask = IPXP_CHECKSUM;
  339                         goto get_flags;
  340                         
  341                 case SO_HEADERS_ON_OUTPUT:
  342                         mask = IPXP_RAWOUT;
  343                 get_flags:
  344                         soptval = ipxp->ipxp_flags & mask;
  345                         error = sooptcopyout(sopt, &soptval, sizeof soptval);
  346                         break;
  347 
  348                 case SO_DEFAULT_HEADERS:
  349                         ioptval.ipx_len = 0;
  350                         ioptval.ipx_sum = 0;
  351                         ioptval.ipx_tc = 0;
  352                         ioptval.ipx_pt = ipxp->ipxp_dpt;
  353                         ioptval.ipx_dna = ipxp->ipxp_faddr;
  354                         ioptval.ipx_sna = ipxp->ipxp_laddr;
  355                         error = sooptcopyout(sopt, &soptval, sizeof soptval);
  356                         break;
  357 
  358                 case SO_SEQNO:
  359                         error = sooptcopyout(sopt, &ipx_pexseq, 
  360                                              sizeof ipx_pexseq);
  361                         ipx_pexseq++;
  362                         break;
  363 
  364                 default:
  365                         error = EINVAL;
  366                 }
  367                 break;
  368 
  369         case SOPT_SET:
  370                 switch (sopt->sopt_name) {
  371                 case SO_ALL_PACKETS:
  372                         mask = IPXP_ALL_PACKETS;
  373                         goto set_head;
  374 
  375                 case SO_HEADERS_ON_INPUT:
  376                         mask = IPXP_RAWIN;
  377                         goto set_head;
  378 
  379                 case SO_IPX_CHECKSUM:
  380                         mask = IPXP_CHECKSUM;
  381 
  382                 case SO_HEADERS_ON_OUTPUT:
  383                         mask = IPXP_RAWOUT;
  384                 set_head:
  385                         error = sooptcopyin(sopt, &optval, sizeof optval,
  386                                             sizeof optval);
  387                         if (error)
  388                                 break;
  389                         if (optval)
  390                                 ipxp->ipxp_flags |= mask;
  391                         else
  392                                 ipxp->ipxp_flags &= ~mask;
  393                         break;
  394 
  395                 case SO_DEFAULT_HEADERS:
  396                         error = sooptcopyin(sopt, &ioptval, sizeof ioptval,
  397                                             sizeof ioptval);
  398                         if (error)
  399                                 break;
  400                         ipxp->ipxp_dpt = ioptval.ipx_pt;
  401                         break;
  402 #ifdef IPXIP
  403                 case SO_IPXIP_ROUTE:
  404                         error = ipxip_route(so, sopt);
  405                         break;
  406 #endif /* IPXIP */
  407 #ifdef IPTUNNEL
  408 #if 0
  409                 case SO_IPXTUNNEL_ROUTE:
  410                         error = ipxtun_route(so, sopt);
  411                         break;
  412 #endif
  413 #endif
  414                 default:
  415                         error = EINVAL;
  416                 }
  417                 break;
  418         }
  419         return (error);
  420 }
  421 
  422 static int
  423 ipx_usr_abort(so)
  424         struct socket *so;
  425 {
  426         int s;
  427         struct ipxpcb *ipxp = sotoipxpcb(so);
  428 
  429         s = splnet();
  430         ipx_pcbdetach(ipxp);
  431         splx(s);
  432         sotryfree(so);
  433         soisdisconnected(so);
  434         return (0);
  435 }
  436 
  437 static int
  438 ipx_attach(so, proto, td)
  439         struct socket *so;
  440         int proto;
  441         struct thread *td;
  442 {
  443         int error;
  444         int s;
  445         struct ipxpcb *ipxp = sotoipxpcb(so);
  446 
  447         if (ipxp != NULL)
  448                 return (EINVAL);
  449         s = splnet();
  450         error = ipx_pcballoc(so, &ipxpcb, td);
  451         splx(s);
  452         if (error == 0)
  453                 error = soreserve(so, ipxsendspace, ipxrecvspace);
  454         return (error);
  455 }
  456 
  457 static int
  458 ipx_bind(so, nam, td)
  459         struct socket *so;
  460         struct sockaddr *nam;
  461         struct thread *td;
  462 {
  463         struct ipxpcb *ipxp = sotoipxpcb(so);
  464 
  465         return (ipx_pcbbind(ipxp, nam, td));
  466 }
  467 
  468 static int
  469 ipx_connect(so, nam, td)
  470         struct socket *so;
  471         struct sockaddr *nam;
  472         struct thread *td;
  473 {
  474         int error;
  475         int s;
  476         struct ipxpcb *ipxp = sotoipxpcb(so);
  477 
  478         if (!ipx_nullhost(ipxp->ipxp_faddr))
  479                 return (EISCONN);
  480         s = splnet();
  481         error = ipx_pcbconnect(ipxp, nam, td);
  482         splx(s);
  483         if (error == 0)
  484                 soisconnected(so);
  485         return (error);
  486 }
  487 
  488 static int
  489 ipx_detach(so)
  490         struct socket *so;
  491 {
  492         int s;
  493         struct ipxpcb *ipxp = sotoipxpcb(so);
  494 
  495         if (ipxp == NULL)
  496                 return (ENOTCONN);
  497         s = splnet();
  498         ipx_pcbdetach(ipxp);
  499         splx(s);
  500         return (0);
  501 }
  502 
  503 static int
  504 ipx_disconnect(so)
  505         struct socket *so;
  506 {
  507         int s;
  508         struct ipxpcb *ipxp = sotoipxpcb(so);
  509 
  510         if (ipx_nullhost(ipxp->ipxp_faddr))
  511                 return (ENOTCONN);
  512         s = splnet();
  513         ipx_pcbdisconnect(ipxp);
  514         splx(s);
  515         soisdisconnected(so);
  516         return (0);
  517 }
  518 
  519 int
  520 ipx_peeraddr(so, nam)
  521         struct socket *so;
  522         struct sockaddr **nam;
  523 {
  524         struct ipxpcb *ipxp = sotoipxpcb(so);
  525 
  526         ipx_setpeeraddr(ipxp, nam); /* XXX what if alloc fails? */
  527         return (0);
  528 }
  529 
  530 static int
  531 ipx_send(so, flags, m, nam, control, td)
  532         struct socket *so;
  533         int flags;
  534         struct mbuf *m;
  535         struct sockaddr *nam;
  536         struct mbuf *control;
  537         struct thread *td;
  538 {
  539         int error;
  540         struct ipxpcb *ipxp = sotoipxpcb(so);
  541         struct ipx_addr laddr;
  542         int s = 0;
  543 
  544         if (nam != NULL) {
  545                 laddr = ipxp->ipxp_laddr;
  546                 if (!ipx_nullhost(ipxp->ipxp_faddr)) {
  547                         error = EISCONN;
  548                         goto send_release;
  549                 }
  550                 /*
  551                  * Must block input while temporarily connected.
  552                  */
  553                 s = splnet();
  554                 error = ipx_pcbconnect(ipxp, nam, td);
  555                 if (error) {
  556                         splx(s);
  557                         goto send_release;
  558                 }
  559         } else {
  560                 if (ipx_nullhost(ipxp->ipxp_faddr)) {
  561                         error = ENOTCONN;
  562                         goto send_release;
  563                 }
  564         }
  565         error = ipx_output(ipxp, m);
  566         m = NULL;
  567         if (nam != NULL) {
  568                 ipx_pcbdisconnect(ipxp);
  569                 splx(s);
  570                 ipxp->ipxp_laddr = laddr;
  571         }
  572 
  573 send_release:
  574         if (m != NULL)
  575                 m_freem(m);
  576         return (error);
  577 }
  578 
  579 static int
  580 ipx_shutdown(so)
  581         struct socket *so;
  582 {
  583         socantsendmore(so);
  584         return (0);
  585 }
  586 
  587 int
  588 ipx_sockaddr(so, nam)
  589         struct socket *so;
  590         struct sockaddr **nam;
  591 {
  592         struct ipxpcb *ipxp = sotoipxpcb(so);
  593 
  594         ipx_setsockaddr(ipxp, nam); /* XXX what if alloc fails? */
  595         return (0);
  596 }
  597 
  598 static int
  599 ripx_attach(so, proto, td)
  600         struct socket *so;
  601         int proto;
  602         struct thread *td;
  603 {
  604         int error = 0;
  605         int s;
  606         struct ipxpcb *ipxp = sotoipxpcb(so);
  607 
  608         if (td != NULL && (error = suser(td)) != 0)
  609                 return (error);
  610         s = splnet();
  611         error = ipx_pcballoc(so, &ipxrawpcb, td);
  612         splx(s);
  613         if (error)
  614                 return (error);
  615         error = soreserve(so, ipxsendspace, ipxrecvspace);
  616         if (error)
  617                 return (error);
  618         ipxp = sotoipxpcb(so);
  619         ipxp->ipxp_faddr.x_host = ipx_broadhost;
  620         ipxp->ipxp_flags = IPXP_RAWIN | IPXP_RAWOUT;
  621         return (error);
  622 }
Cache object: 8a154484d1c0b00890aa666ca1dbe6ae
[ 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.
FreeBSD/Linux Kernel Cross Reference sys/netipx/ipx_usrreq.c

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