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/netatalk/ddp_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) 1990,1994 Regents of The University of Michigan.
    3  * All Rights Reserved.  See COPYRIGHT.
    4  *
    5  * $FreeBSD: releng/5.0/sys/netatalk/ddp_usrreq.c 97658 2002-05-31 11:52:35Z tanimura $
    6  */
    7 
    8 #include <sys/param.h>
    9 #include <sys/systm.h>
   10 #include <sys/malloc.h>
   11 #include <sys/mbuf.h>
   12 #include <sys/socket.h>
   13 #include <sys/socketvar.h>
   14 #include <sys/protosw.h>
   15 #include <net/if.h>
   16 #include <net/route.h>
   17 #include <net/intrq.h>
   18 
   19 #include <netatalk/at.h>
   20 #include <netatalk/at_var.h>
   21 #include <netatalk/ddp_var.h>
   22 #include <netatalk/at_extern.h>
   23 
   24 static void at_pcbdisconnect( struct ddpcb *ddp );
   25 static void at_sockaddr(struct ddpcb *ddp, struct sockaddr **addr);
   26 static int at_pcbsetaddr(struct ddpcb *ddp, struct sockaddr *addr,
   27                           struct thread *td);
   28 static int at_pcbconnect(struct ddpcb *ddp, struct sockaddr *addr, 
   29                          struct thread *td);
   30 static void at_pcbdetach(struct socket *so, struct ddpcb *ddp);
   31 static int at_pcballoc(struct socket *so);
   32 
   33 struct ddpcb    *ddp_ports[ ATPORT_LAST ];
   34 struct ddpcb    *ddpcb = NULL;
   35 static u_long   ddp_sendspace = DDP_MAXSZ; /* Max ddp size + 1 (ddp_type) */
   36 static u_long   ddp_recvspace = 10 * ( 587 + sizeof( struct sockaddr_at ));
   37 
   38 
   39 static int
   40 ddp_attach(struct socket *so, int proto, struct thread *td)
   41 {
   42         struct ddpcb    *ddp;
   43         int             error = 0;
   44         int             s;
   45         
   46 
   47         ddp = sotoddpcb( so );
   48         if ( ddp != NULL ) {
   49             return( EINVAL);
   50         }
   51 
   52         s = splnet();
   53         error = at_pcballoc( so );
   54         splx(s);
   55         if (error) {
   56             return (error);
   57         }
   58         return (soreserve( so, ddp_sendspace, ddp_recvspace ));
   59 }
   60 
   61 static int
   62 ddp_detach(struct socket *so)
   63 {
   64         struct ddpcb    *ddp;
   65         int             s;
   66         
   67         ddp = sotoddpcb( so );
   68         if ( ddp == NULL ) {
   69             return( EINVAL);
   70         }
   71         s = splnet();
   72         at_pcbdetach( so, ddp );
   73         splx(s);
   74         return(0);
   75 }
   76 
   77 static int      
   78 ddp_bind(struct socket *so, struct sockaddr *nam, struct thread *td)
   79 {
   80         struct ddpcb    *ddp;
   81         int             error = 0;
   82         int             s;
   83         
   84         ddp = sotoddpcb( so );
   85         if ( ddp == NULL ) {
   86             return( EINVAL);
   87         }
   88         s = splnet();
   89         error = at_pcbsetaddr(ddp, nam, td);
   90         splx(s);
   91         return (error);
   92 }
   93     
   94 static int
   95 ddp_connect(struct socket *so, struct sockaddr *nam, struct thread *td)
   96 {
   97         struct ddpcb    *ddp;
   98         int             error = 0;
   99         int             s;
  100         
  101         ddp = sotoddpcb( so );
  102         if ( ddp == NULL ) {
  103             return( EINVAL);
  104         }
  105 
  106         if ( ddp->ddp_fsat.sat_port != ATADDR_ANYPORT ) {
  107             return(EISCONN);
  108         }
  109 
  110         s = splnet();
  111         error = at_pcbconnect( ddp, nam, td );
  112         splx(s);
  113         if ( error == 0 )
  114             soisconnected( so );
  115         return(error);
  116 }
  117 
  118 static int
  119 ddp_disconnect(struct socket *so)
  120 {
  121 
  122         struct ddpcb    *ddp;
  123         int             s;
  124         
  125         ddp = sotoddpcb( so );
  126         if ( ddp == NULL ) {
  127             return( EINVAL);
  128         }
  129         if ( ddp->ddp_fsat.sat_addr.s_node == ATADDR_ANYNODE ) {
  130             return(ENOTCONN);
  131         }
  132 
  133         s = splnet();
  134         at_pcbdisconnect( ddp );
  135         ddp->ddp_fsat.sat_addr.s_node = ATADDR_ANYNODE;
  136         splx(s);
  137         soisdisconnected( so );
  138         return(0);
  139 }
  140 
  141 static int
  142 ddp_shutdown(struct socket *so)
  143 {
  144         struct ddpcb    *ddp;
  145 
  146         ddp = sotoddpcb( so );
  147         if ( ddp == NULL ) {
  148                 return( EINVAL);
  149         }
  150         socantsendmore( so );
  151         return(0);
  152 }
  153 
  154 static int
  155 ddp_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr,
  156             struct mbuf *control, struct thread *td)
  157 {
  158         struct ddpcb    *ddp;
  159         int             error = 0;
  160         int             s;
  161         
  162         ddp = sotoddpcb( so );
  163         if ( ddp == NULL ) {
  164                 return(EINVAL);
  165         }
  166 
  167         if ( control && control->m_len ) {
  168                 return(EINVAL);
  169         }
  170 
  171         if ( addr ) {
  172                 if ( ddp->ddp_fsat.sat_port != ATADDR_ANYPORT ) {
  173                         return(EISCONN);
  174                 }
  175 
  176                 s = splnet();
  177                 error = at_pcbconnect(ddp, addr, td);
  178                 splx( s );
  179                 if ( error ) {
  180                         return(error);
  181                 }
  182         } else {
  183                 if ( ddp->ddp_fsat.sat_port == ATADDR_ANYPORT ) {
  184                         return(ENOTCONN);
  185                 }
  186         }
  187 
  188         s = splnet();
  189         error = ddp_output( m, so );
  190         if ( addr ) {
  191             at_pcbdisconnect( ddp );
  192         }
  193         splx(s);
  194         return(error);
  195 }
  196 
  197 static int
  198 ddp_abort(struct socket *so)
  199 {
  200         struct ddpcb    *ddp;
  201         int             s;
  202         
  203         ddp = sotoddpcb( so );
  204         if ( ddp == NULL ) {
  205                 return(EINVAL);
  206         }
  207         soisdisconnected( so );
  208         s = splnet();
  209         at_pcbdetach( so, ddp );
  210         splx(s);
  211         return(0);
  212 }
  213 
  214 
  215 static void
  216 at_sockaddr(struct ddpcb *ddp, struct sockaddr **addr)
  217 {
  218     *addr = dup_sockaddr((struct sockaddr *)&ddp->ddp_lsat, 0);
  219 }
  220 
  221 static int 
  222 at_pcbsetaddr(struct ddpcb *ddp, struct sockaddr *addr, struct thread *td)
  223 {
  224     struct sockaddr_at  lsat, *sat;
  225     struct at_ifaddr    *aa;
  226     struct ddpcb        *ddpp;
  227 
  228     if ( ddp->ddp_lsat.sat_port != ATADDR_ANYPORT ) { /* shouldn't be bound */
  229         return( EINVAL );
  230     }
  231 
  232     if (addr != 0) {                    /* validate passed address */
  233         sat = (struct sockaddr_at *)addr;
  234         if (sat->sat_family != AF_APPLETALK) {
  235             return(EAFNOSUPPORT);
  236         }
  237 
  238         if ( sat->sat_addr.s_node != ATADDR_ANYNODE ||
  239                 sat->sat_addr.s_net != ATADDR_ANYNET ) {
  240             for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
  241                 if (( sat->sat_addr.s_net == AA_SAT( aa )->sat_addr.s_net ) &&
  242                  ( sat->sat_addr.s_node == AA_SAT( aa )->sat_addr.s_node )) {
  243                     break;
  244                 }
  245             }
  246             if ( !aa ) {
  247                 return( EADDRNOTAVAIL );
  248             }
  249         }
  250 
  251         if ( sat->sat_port != ATADDR_ANYPORT ) {
  252             if ( sat->sat_port < ATPORT_FIRST ||
  253                     sat->sat_port >= ATPORT_LAST ) {
  254                 return( EINVAL );
  255             }
  256             if ( sat->sat_port < ATPORT_RESERVED &&
  257                  suser(td) ) {
  258                 return( EACCES );
  259             }
  260         }
  261     } else {
  262         bzero( (caddr_t)&lsat, sizeof( struct sockaddr_at ));
  263         lsat.sat_len = sizeof(struct sockaddr_at);
  264         lsat.sat_addr.s_node = ATADDR_ANYNODE;
  265         lsat.sat_addr.s_net = ATADDR_ANYNET;
  266         lsat.sat_family = AF_APPLETALK;
  267         sat = &lsat;
  268     }
  269 
  270     if ( sat->sat_addr.s_node == ATADDR_ANYNODE &&
  271             sat->sat_addr.s_net == ATADDR_ANYNET ) {
  272         if ( at_ifaddr == NULL ) {
  273             return( EADDRNOTAVAIL );
  274         }
  275         sat->sat_addr = AA_SAT( at_ifaddr )->sat_addr;
  276     }
  277     ddp->ddp_lsat = *sat;
  278 
  279     /*
  280      * Choose port.
  281      */
  282     if ( sat->sat_port == ATADDR_ANYPORT ) {
  283         for ( sat->sat_port = ATPORT_RESERVED;
  284                 sat->sat_port < ATPORT_LAST; sat->sat_port++ ) {
  285             if ( ddp_ports[ sat->sat_port - 1 ] == 0 ) {
  286                 break;
  287             }
  288         }
  289         if ( sat->sat_port == ATPORT_LAST ) {
  290             return( EADDRNOTAVAIL );
  291         }
  292         ddp->ddp_lsat.sat_port = sat->sat_port;
  293         ddp_ports[ sat->sat_port - 1 ] = ddp;
  294     } else {
  295         for ( ddpp = ddp_ports[ sat->sat_port - 1 ]; ddpp;
  296                 ddpp = ddpp->ddp_pnext ) {
  297             if ( ddpp->ddp_lsat.sat_addr.s_net == sat->sat_addr.s_net &&
  298                     ddpp->ddp_lsat.sat_addr.s_node == sat->sat_addr.s_node ) {
  299                 break;
  300             }
  301         }
  302         if ( ddpp != NULL ) {
  303             return( EADDRINUSE );
  304         }
  305         ddp->ddp_pnext = ddp_ports[ sat->sat_port - 1 ];
  306         ddp_ports[ sat->sat_port - 1 ] = ddp;
  307         if ( ddp->ddp_pnext ) {
  308             ddp->ddp_pnext->ddp_pprev = ddp;
  309         }
  310     }
  311 
  312     return( 0 );
  313 }
  314 
  315 static int
  316 at_pcbconnect(struct ddpcb *ddp, struct sockaddr *addr, struct thread *td)
  317 {
  318     struct sockaddr_at  *sat = (struct sockaddr_at *)addr;
  319     struct route        *ro;
  320     struct at_ifaddr    *aa = 0;
  321     struct ifnet        *ifp;
  322     u_short             hintnet = 0, net;
  323 
  324     if (sat->sat_family != AF_APPLETALK) {
  325         return(EAFNOSUPPORT);
  326     }
  327 
  328     /*
  329      * Under phase 2, network 0 means "the network".  We take "the
  330      * network" to mean the network the control block is bound to.
  331      * If the control block is not bound, there is an error.
  332      */
  333     if ( sat->sat_addr.s_net == ATADDR_ANYNET
  334                 && sat->sat_addr.s_node != ATADDR_ANYNODE ) {
  335         if ( ddp->ddp_lsat.sat_port == ATADDR_ANYPORT ) {
  336             return( EADDRNOTAVAIL );
  337         }
  338         hintnet = ddp->ddp_lsat.sat_addr.s_net;
  339     }
  340 
  341     ro = &ddp->ddp_route;
  342     /*
  343      * If we've got an old route for this pcb, check that it is valid.
  344      * If we've changed our address, we may have an old "good looking"
  345      * route here.  Attempt to detect it.
  346      */
  347     if ( ro->ro_rt ) {
  348         if ( hintnet ) {
  349             net = hintnet;
  350         } else {
  351             net = sat->sat_addr.s_net;
  352         }
  353         aa = 0;
  354         if ((ifp = ro->ro_rt->rt_ifp) != NULL) {
  355             for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
  356                 if ( aa->aa_ifp == ifp &&
  357                         ntohs( net ) >= ntohs( aa->aa_firstnet ) &&
  358                         ntohs( net ) <= ntohs( aa->aa_lastnet )) {
  359                     break;
  360                 }
  361             }
  362         }
  363         if ( aa == NULL || ( satosat( &ro->ro_dst )->sat_addr.s_net !=
  364                 ( hintnet ? hintnet : sat->sat_addr.s_net ) ||
  365                 satosat( &ro->ro_dst )->sat_addr.s_node !=
  366                 sat->sat_addr.s_node )) {
  367             RTFREE( ro->ro_rt );
  368             ro->ro_rt = (struct rtentry *)0;
  369         }
  370     }
  371 
  372     /*
  373      * If we've got no route for this interface, try to find one.
  374      */
  375     if ( ro->ro_rt == (struct rtentry *)0 ||
  376          ro->ro_rt->rt_ifp == (struct ifnet *)0 ) {
  377         ro->ro_dst.sa_len = sizeof( struct sockaddr_at );
  378         ro->ro_dst.sa_family = AF_APPLETALK;
  379         if ( hintnet ) {
  380             satosat( &ro->ro_dst )->sat_addr.s_net = hintnet;
  381         } else {
  382             satosat( &ro->ro_dst )->sat_addr.s_net = sat->sat_addr.s_net;
  383         }
  384         satosat( &ro->ro_dst )->sat_addr.s_node = sat->sat_addr.s_node;
  385         rtalloc( ro );
  386     }
  387 
  388     /*
  389      * Make sure any route that we have has a valid interface.
  390      */
  391     aa = 0;
  392     if ( ro->ro_rt && ( ifp = ro->ro_rt->rt_ifp )) {
  393         for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
  394             if ( aa->aa_ifp == ifp ) {
  395                 break;
  396             }
  397         }
  398     }
  399     if ( aa == 0 ) {
  400         return( ENETUNREACH );
  401     }
  402 
  403     ddp->ddp_fsat = *sat;
  404     if ( ddp->ddp_lsat.sat_port == ATADDR_ANYPORT ) {
  405         return(at_pcbsetaddr(ddp, (struct sockaddr *)0, td));
  406     }
  407     return( 0 );
  408 }
  409 
  410 static void 
  411 at_pcbdisconnect( struct ddpcb  *ddp )
  412 {
  413     ddp->ddp_fsat.sat_addr.s_net = ATADDR_ANYNET;
  414     ddp->ddp_fsat.sat_addr.s_node = ATADDR_ANYNODE;
  415     ddp->ddp_fsat.sat_port = ATADDR_ANYPORT;
  416 }
  417 
  418 static int
  419 at_pcballoc( struct socket *so )
  420 {
  421         struct ddpcb    *ddp;
  422 
  423         MALLOC(ddp, struct ddpcb *, sizeof *ddp, M_PCB, M_WAITOK | M_ZERO);
  424         ddp->ddp_lsat.sat_port = ATADDR_ANYPORT;
  425 
  426         ddp->ddp_next = ddpcb;
  427         ddp->ddp_prev = NULL;
  428         ddp->ddp_pprev = NULL;
  429         ddp->ddp_pnext = NULL;
  430         if (ddpcb) {
  431                 ddpcb->ddp_prev = ddp;
  432         }
  433         ddpcb = ddp;
  434 
  435         ddp->ddp_socket = so;
  436         so->so_pcb = (caddr_t)ddp;
  437         return(0);
  438 }
  439 
  440 static void
  441 at_pcbdetach( struct socket *so, struct ddpcb *ddp)
  442 {
  443     soisdisconnected( so );
  444     so->so_pcb = 0;
  445     sotryfree(so);
  446 
  447     /* remove ddp from ddp_ports list */
  448     if ( ddp->ddp_lsat.sat_port != ATADDR_ANYPORT &&
  449             ddp_ports[ ddp->ddp_lsat.sat_port - 1 ] != NULL ) {
  450         if ( ddp->ddp_pprev != NULL ) {
  451             ddp->ddp_pprev->ddp_pnext = ddp->ddp_pnext;
  452         } else {
  453             ddp_ports[ ddp->ddp_lsat.sat_port - 1 ] = ddp->ddp_pnext;
  454         }
  455         if ( ddp->ddp_pnext != NULL ) {
  456             ddp->ddp_pnext->ddp_pprev = ddp->ddp_pprev;
  457         }
  458     }
  459 
  460     if ( ddp->ddp_route.ro_rt ) {
  461         rtfree( ddp->ddp_route.ro_rt );
  462     }
  463 
  464     if ( ddp->ddp_prev ) {
  465         ddp->ddp_prev->ddp_next = ddp->ddp_next;
  466     } else {
  467         ddpcb = ddp->ddp_next;
  468     }
  469     if ( ddp->ddp_next ) {
  470         ddp->ddp_next->ddp_prev = ddp->ddp_prev;
  471     }
  472     FREE(ddp, M_PCB);
  473 }
  474 
  475 /*
  476  * For the moment, this just find the pcb with the correct local address.
  477  * In the future, this will actually do some real searching, so we can use
  478  * the sender's address to do de-multiplexing on a single port to many
  479  * sockets (pcbs).
  480  */
  481 struct ddpcb *
  482 ddp_search( struct sockaddr_at *from, struct sockaddr_at *to,
  483                         struct at_ifaddr *aa)
  484 {
  485     struct ddpcb        *ddp;
  486 
  487     /*
  488      * Check for bad ports.
  489      */
  490     if ( to->sat_port < ATPORT_FIRST || to->sat_port >= ATPORT_LAST ) {
  491         return( NULL );
  492     }
  493 
  494     /*
  495      * Make sure the local address matches the sent address.  What about
  496      * the interface?
  497      */
  498     for ( ddp = ddp_ports[ to->sat_port - 1 ]; ddp; ddp = ddp->ddp_pnext ) {
  499         /* XXX should we handle 0.YY? */
  500 
  501         /* XXXX.YY to socket on destination interface */
  502         if ( to->sat_addr.s_net == ddp->ddp_lsat.sat_addr.s_net &&
  503                 to->sat_addr.s_node == ddp->ddp_lsat.sat_addr.s_node ) {
  504             break;
  505         }
  506 
  507         /* 0.255 to socket on receiving interface */
  508         if ( to->sat_addr.s_node == ATADDR_BCAST && ( to->sat_addr.s_net == 0 ||
  509                 to->sat_addr.s_net == ddp->ddp_lsat.sat_addr.s_net ) &&
  510                 ddp->ddp_lsat.sat_addr.s_net == AA_SAT( aa )->sat_addr.s_net ) {
  511             break;
  512         }
  513 
  514         /* XXXX.0 to socket on destination interface */
  515         if ( to->sat_addr.s_net == aa->aa_firstnet &&
  516                 to->sat_addr.s_node == 0 &&
  517                 ntohs( ddp->ddp_lsat.sat_addr.s_net ) >=
  518                 ntohs( aa->aa_firstnet ) &&
  519                 ntohs( ddp->ddp_lsat.sat_addr.s_net ) <=
  520                 ntohs( aa->aa_lastnet )) {
  521             break;
  522         }
  523     }
  524     return( ddp );
  525 }
  526 static int
  527 at_setpeeraddr(struct socket *so, struct sockaddr **nam)
  528 {
  529         return(EOPNOTSUPP);
  530 }
  531 
  532 static int
  533 at_setsockaddr(struct socket *so, struct sockaddr **nam)
  534 {
  535         struct ddpcb    *ddp;
  536 
  537         ddp = sotoddpcb( so );
  538         if ( ddp == NULL ) {
  539             return( EINVAL);
  540         }
  541         at_sockaddr( ddp, nam );
  542         return(0);
  543 }
  544 
  545 
  546 void 
  547 ddp_init(void )
  548 {
  549     atintrq1.ifq_maxlen = IFQ_MAXLEN;
  550     atintrq2.ifq_maxlen = IFQ_MAXLEN;
  551     atintrq1_present = 1;
  552     atintrq2_present = 1;
  553     mtx_init(&atintrq1.ifq_mtx, "at1_inq", NULL, MTX_DEF);
  554     mtx_init(&atintrq2.ifq_mtx, "at2_inq", NULL, MTX_DEF);
  555 }
  556 
  557 #if 0
  558 static void 
  559 ddp_clean(void )
  560 {
  561     struct ddpcb        *ddp;
  562 
  563     for ( ddp = ddpcb; ddp; ddp = ddp->ddp_next ) {
  564         at_pcbdetach( ddp->ddp_socket, ddp );
  565     }
  566 }
  567 #endif
  568 
  569 struct pr_usrreqs ddp_usrreqs = {
  570         ddp_abort,
  571         pru_accept_notsupp,
  572         ddp_attach,
  573         ddp_bind,
  574         ddp_connect,
  575         pru_connect2_notsupp,
  576         at_control,
  577         ddp_detach,
  578         ddp_disconnect,
  579         pru_listen_notsupp,
  580         at_setpeeraddr,
  581         pru_rcvd_notsupp,
  582         pru_rcvoob_notsupp,
  583         ddp_send,
  584         pru_sense_null,
  585         ddp_shutdown,
  586         at_setsockaddr,
  587         sosend,
  588         soreceive,
  589         sopoll
  590 };

Cache object: 9e628c7cfb278d20df40ee12e8aa15e9


[ 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.