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/net/if_fddisubr.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, 1996
    3  *      Matt Thomas <matt@3am-software.com>.  All rights reserved.
    4  * Copyright (c) 1982, 1989, 1993
    5  *      The Regents of the University of California.  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  * 3. All advertising materials mentioning features or use of this software
   16  *    must display the following acknowledgement:
   17  *      This product includes software developed by the University of
   18  *      California, Berkeley and its contributors.
   19  * 4. Neither the name of the University nor the names of its contributors
   20  *    may be used to endorse or promote products derived from this software
   21  *    without specific prior written permission.
   22  *
   23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   33  * SUCH DAMAGE.
   34  *
   35  *      from: if_ethersubr.c,v 1.5 1994/12/13 22:31:45 wollman Exp
   36  * $FreeBSD: releng/10.0/sys/net/if_fddisubr.c 254831 2013-08-25 09:41:37Z andre $
   37  */
   38 
   39 #include "opt_atalk.h"
   40 #include "opt_inet.h"
   41 #include "opt_inet6.h"
   42 #include "opt_ipx.h"
   43 
   44 #include <sys/param.h>
   45 #include <sys/systm.h>
   46 #include <sys/kernel.h>
   47 #include <sys/malloc.h>
   48 #include <sys/mbuf.h>
   49 #include <sys/module.h>
   50 #include <sys/socket.h>
   51 #include <sys/sockio.h>
   52 
   53 #include <net/if.h>
   54 #include <net/if_dl.h>
   55 #include <net/if_llc.h>
   56 #include <net/if_types.h>
   57 #include <net/if_llatbl.h>
   58 
   59 #include <net/ethernet.h>
   60 #include <net/netisr.h>
   61 #include <net/route.h>
   62 #include <net/bpf.h>
   63 #include <net/fddi.h>
   64 
   65 #if defined(INET) || defined(INET6)
   66 #include <netinet/in.h>
   67 #include <netinet/in_var.h>
   68 #include <netinet/if_ether.h>
   69 #endif
   70 #ifdef INET6
   71 #include <netinet6/nd6.h>
   72 #endif
   73 
   74 #ifdef IPX
   75 #include <netipx/ipx.h> 
   76 #include <netipx/ipx_if.h>
   77 #endif
   78 
   79 #ifdef DECNET
   80 #include <netdnet/dn.h>
   81 #endif
   82 
   83 #ifdef NETATALK
   84 #include <netatalk/at.h>
   85 #include <netatalk/at_var.h>
   86 #include <netatalk/at_extern.h>
   87 
   88 extern u_char   at_org_code[ 3 ];
   89 extern u_char   aarp_org_code[ 3 ];
   90 #endif /* NETATALK */
   91 
   92 #include <security/mac/mac_framework.h>
   93 
   94 static const u_char fddibroadcastaddr[FDDI_ADDR_LEN] =
   95                         { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
   96 
   97 static int fddi_resolvemulti(struct ifnet *, struct sockaddr **,
   98                               struct sockaddr *);
   99 static int fddi_output(struct ifnet *, struct mbuf *, const struct sockaddr *,
  100                        struct route *); 
  101 static void fddi_input(struct ifnet *ifp, struct mbuf *m);
  102 
  103 #define senderr(e)      do { error = (e); goto bad; } while (0)
  104 
  105 /*
  106  * FDDI output routine.
  107  * Encapsulate a packet of type family for the local net.
  108  * Use trailer local net encapsulation if enough data in first
  109  * packet leaves a multiple of 512 bytes of data in remainder.
  110  * Assumes that ifp is actually pointer to arpcom structure.
  111  */
  112 static int
  113 fddi_output(struct ifnet *ifp, struct mbuf *m, const struct sockaddr *dst,
  114         struct route *ro)
  115 {
  116         u_int16_t type;
  117         int loop_copy = 0, error = 0, hdrcmplt = 0;
  118         u_char esrc[FDDI_ADDR_LEN], edst[FDDI_ADDR_LEN];
  119         struct fddi_header *fh;
  120 #if defined(INET) || defined(INET6)
  121         struct llentry *lle;
  122 #endif
  123 
  124 #ifdef MAC
  125         error = mac_ifnet_check_transmit(ifp, m);
  126         if (error)
  127                 senderr(error);
  128 #endif
  129 
  130         if (ifp->if_flags & IFF_MONITOR)
  131                 senderr(ENETDOWN);
  132         if (!((ifp->if_flags & IFF_UP) &&
  133             (ifp->if_drv_flags & IFF_DRV_RUNNING)))
  134                 senderr(ENETDOWN);
  135         getmicrotime(&ifp->if_lastchange);
  136 
  137         switch (dst->sa_family) {
  138 #ifdef INET
  139         case AF_INET: {
  140                 struct rtentry *rt0 = NULL;
  141 
  142                 if (ro != NULL)
  143                         rt0 = ro->ro_rt;
  144                 error = arpresolve(ifp, rt0, m, dst, edst, &lle);
  145                 if (error)
  146                         return (error == EWOULDBLOCK ? 0 : error);
  147                 type = htons(ETHERTYPE_IP);
  148                 break;
  149         }
  150         case AF_ARP:
  151         {
  152                 struct arphdr *ah;
  153                 ah = mtod(m, struct arphdr *);
  154                 ah->ar_hrd = htons(ARPHRD_ETHER);
  155 
  156                 loop_copy = -1; /* if this is for us, don't do it */
  157 
  158                 switch (ntohs(ah->ar_op)) {
  159                 case ARPOP_REVREQUEST:
  160                 case ARPOP_REVREPLY:
  161                         type = htons(ETHERTYPE_REVARP);
  162                         break;
  163                 case ARPOP_REQUEST:
  164                 case ARPOP_REPLY:
  165                 default:
  166                         type = htons(ETHERTYPE_ARP);
  167                         break;
  168                 }
  169 
  170                 if (m->m_flags & M_BCAST)
  171                         bcopy(ifp->if_broadcastaddr, edst, FDDI_ADDR_LEN);
  172                 else
  173                         bcopy(ar_tha(ah), edst, FDDI_ADDR_LEN);
  174 
  175         }
  176         break;
  177 #endif /* INET */
  178 #ifdef INET6
  179         case AF_INET6:
  180                 error = nd6_storelladdr(ifp, m, dst, (u_char *)edst, &lle);
  181                 if (error)
  182                         return (error); /* Something bad happened */
  183                 type = htons(ETHERTYPE_IPV6);
  184                 break;
  185 #endif /* INET6 */
  186 #ifdef IPX
  187         case AF_IPX:
  188                 type = htons(ETHERTYPE_IPX);
  189                 bcopy(&((const struct sockaddr_ipx *)dst)->sipx_addr.x_host,
  190                     edst, FDDI_ADDR_LEN);
  191                 break;
  192 #endif /* IPX */
  193 #ifdef NETATALK
  194         case AF_APPLETALK: {
  195             struct at_ifaddr *aa;
  196             if (!aarpresolve(ifp, m, (const struct sockaddr_at *)dst, edst))
  197                 return (0);
  198             /*
  199              * ifaddr is the first thing in at_ifaddr
  200              */
  201             if ((aa = at_ifawithnet((const struct sockaddr_at *)dst)) == 0)
  202                 goto bad;
  203             
  204             /*
  205              * In the phase 2 case, we need to prepend an mbuf for the llc header.
  206              * Since we must preserve the value of m, which is passed to us by
  207              * value, we m_copy() the first mbuf, and use it for our llc header.
  208              */
  209             if (aa->aa_flags & AFA_PHASE2) {
  210                 struct llc llc;
  211 
  212                 M_PREPEND(m, LLC_SNAPFRAMELEN, M_WAITOK);
  213                 llc.llc_dsap = llc.llc_ssap = LLC_SNAP_LSAP;
  214                 llc.llc_control = LLC_UI;
  215                 bcopy(at_org_code, llc.llc_snap.org_code, sizeof(at_org_code));
  216                 llc.llc_snap.ether_type = htons(ETHERTYPE_AT);
  217                 bcopy(&llc, mtod(m, caddr_t), LLC_SNAPFRAMELEN);
  218                 type = 0;
  219             } else {
  220                 type = htons(ETHERTYPE_AT);
  221             }
  222             ifa_free(&aa->aa_ifa);
  223             break;
  224         }
  225 #endif /* NETATALK */
  226 
  227         case pseudo_AF_HDRCMPLT:
  228         {
  229                 const struct ether_header *eh;
  230 
  231                 hdrcmplt = 1;
  232                 eh = (const struct ether_header *)dst->sa_data;
  233                 bcopy(eh->ether_shost, esrc, FDDI_ADDR_LEN);
  234                 /* FALLTHROUGH */
  235         }
  236 
  237         case AF_UNSPEC:
  238         {
  239                 const struct ether_header *eh;
  240 
  241                 loop_copy = -1;
  242                 eh = (const struct ether_header *)dst->sa_data;
  243                 bcopy(eh->ether_dhost, edst, FDDI_ADDR_LEN);
  244                 if (*edst & 1)
  245                         m->m_flags |= (M_BCAST|M_MCAST);
  246                 type = eh->ether_type;
  247                 break;
  248         }
  249 
  250         case AF_IMPLINK:
  251         {
  252                 fh = mtod(m, struct fddi_header *);
  253                 error = EPROTONOSUPPORT;
  254                 switch (fh->fddi_fc & (FDDIFC_C|FDDIFC_L|FDDIFC_F)) {
  255                         case FDDIFC_LLC_ASYNC: {
  256                                 /* legal priorities are 0 through 7 */
  257                                 if ((fh->fddi_fc & FDDIFC_Z) > 7)
  258                                         goto bad;
  259                                 break;
  260                         }
  261                         case FDDIFC_LLC_SYNC: {
  262                                 /* FDDIFC_Z bits reserved, must be zero */
  263                                 if (fh->fddi_fc & FDDIFC_Z)
  264                                         goto bad;
  265                                 break;
  266                         }
  267                         case FDDIFC_SMT: {
  268                                 /* FDDIFC_Z bits must be non zero */
  269                                 if ((fh->fddi_fc & FDDIFC_Z) == 0)
  270                                         goto bad;
  271                                 break;
  272                         }
  273                         default: {
  274                                 /* anything else is too dangerous */
  275                                 goto bad;
  276                         }
  277                 }
  278                 error = 0;
  279                 if (fh->fddi_dhost[0] & 1)
  280                         m->m_flags |= (M_BCAST|M_MCAST);
  281                 goto queue_it;
  282         }
  283         default:
  284                 if_printf(ifp, "can't handle af%d\n", dst->sa_family);
  285                 senderr(EAFNOSUPPORT);
  286         }
  287 
  288         /*
  289          * Add LLC header.
  290          */
  291         if (type != 0) {
  292                 struct llc *l;
  293                 M_PREPEND(m, LLC_SNAPFRAMELEN, M_NOWAIT);
  294                 if (m == 0)
  295                         senderr(ENOBUFS);
  296                 l = mtod(m, struct llc *);
  297                 l->llc_control = LLC_UI;
  298                 l->llc_dsap = l->llc_ssap = LLC_SNAP_LSAP;
  299                 l->llc_snap.org_code[0] =
  300                         l->llc_snap.org_code[1] =
  301                         l->llc_snap.org_code[2] = 0;
  302                 l->llc_snap.ether_type = htons(type);
  303         }
  304 
  305         /*
  306          * Add local net header.  If no space in first mbuf,
  307          * allocate another.
  308          */
  309         M_PREPEND(m, FDDI_HDR_LEN, M_NOWAIT);
  310         if (m == 0)
  311                 senderr(ENOBUFS);
  312         fh = mtod(m, struct fddi_header *);
  313         fh->fddi_fc = FDDIFC_LLC_ASYNC|FDDIFC_LLC_PRIO4;
  314         bcopy((caddr_t)edst, (caddr_t)fh->fddi_dhost, FDDI_ADDR_LEN);
  315   queue_it:
  316         if (hdrcmplt)
  317                 bcopy((caddr_t)esrc, (caddr_t)fh->fddi_shost, FDDI_ADDR_LEN);
  318         else
  319                 bcopy(IF_LLADDR(ifp), (caddr_t)fh->fddi_shost,
  320                         FDDI_ADDR_LEN);
  321 
  322         /*
  323          * If a simplex interface, and the packet is being sent to our
  324          * Ethernet address or a broadcast address, loopback a copy.
  325          * XXX To make a simplex device behave exactly like a duplex
  326          * device, we should copy in the case of sending to our own
  327          * ethernet address (thus letting the original actually appear
  328          * on the wire). However, we don't do that here for security
  329          * reasons and compatibility with the original behavior.
  330          */
  331         if ((ifp->if_flags & IFF_SIMPLEX) && (loop_copy != -1)) {
  332                 if ((m->m_flags & M_BCAST) || (loop_copy > 0)) {
  333                         struct mbuf *n;
  334                         n = m_copy(m, 0, (int)M_COPYALL);
  335                         (void) if_simloop(ifp, n, dst->sa_family,
  336                                           FDDI_HDR_LEN);
  337                 } else if (bcmp(fh->fddi_dhost, fh->fddi_shost,
  338                                 FDDI_ADDR_LEN) == 0) {
  339                         (void) if_simloop(ifp, m, dst->sa_family,
  340                                           FDDI_HDR_LEN);
  341                         return (0);     /* XXX */
  342                 }
  343         }
  344 
  345         error = (ifp->if_transmit)(ifp, m);
  346         if (error)
  347                 ifp->if_oerrors++;
  348 
  349         return (error);
  350 
  351 bad:
  352         ifp->if_oerrors++;
  353         if (m)
  354                 m_freem(m);
  355         return (error);
  356 }
  357 
  358 /*
  359  * Process a received FDDI packet.
  360  */
  361 static void
  362 fddi_input(ifp, m)
  363         struct ifnet *ifp;
  364         struct mbuf *m;
  365 {
  366         int isr;
  367         struct llc *l;
  368         struct fddi_header *fh;
  369 
  370         /*
  371          * Do consistency checks to verify assumptions
  372          * made by code past this point.
  373          */
  374         if ((m->m_flags & M_PKTHDR) == 0) {
  375                 if_printf(ifp, "discard frame w/o packet header\n");
  376                 ifp->if_ierrors++;
  377                 m_freem(m);
  378                 return;
  379         }
  380         if (m->m_pkthdr.rcvif == NULL) {
  381                 if_printf(ifp, "discard frame w/o interface pointer\n");
  382                 ifp->if_ierrors++;
  383                 m_freem(m);
  384                 return;
  385         }
  386 
  387         m = m_pullup(m, FDDI_HDR_LEN);
  388         if (m == NULL) {
  389                 ifp->if_ierrors++;
  390                 goto dropanyway;
  391         }
  392         fh = mtod(m, struct fddi_header *);
  393 
  394         /*
  395          * Discard packet if interface is not up.
  396          */
  397         if (!((ifp->if_flags & IFF_UP) &&
  398             (ifp->if_drv_flags & IFF_DRV_RUNNING)))
  399                 goto dropanyway;
  400 
  401         /*
  402          * Give bpf a chance at the packet.
  403          */
  404         BPF_MTAP(ifp, m);
  405 
  406         /*
  407          * Interface marked for monitoring; discard packet.
  408          */
  409         if (ifp->if_flags & IFF_MONITOR) {
  410                 m_freem(m);
  411                 return;
  412         }
  413 
  414 #ifdef MAC
  415         mac_ifnet_create_mbuf(ifp, m);
  416 #endif
  417 
  418         /*
  419          * Update interface statistics.
  420          */
  421         ifp->if_ibytes += m->m_pkthdr.len;
  422         getmicrotime(&ifp->if_lastchange);
  423 
  424         /*
  425          * Discard non local unicast packets when interface
  426          * is in promiscuous mode.
  427          */
  428         if ((ifp->if_flags & IFF_PROMISC) && ((fh->fddi_dhost[0] & 1) == 0) &&
  429             (bcmp(IF_LLADDR(ifp), (caddr_t)fh->fddi_dhost,
  430              FDDI_ADDR_LEN) != 0))
  431                 goto dropanyway;
  432 
  433         /*
  434          * Set mbuf flags for bcast/mcast.
  435          */
  436         if (fh->fddi_dhost[0] & 1) {
  437                 if (bcmp(ifp->if_broadcastaddr, fh->fddi_dhost,
  438                     FDDI_ADDR_LEN) == 0)
  439                         m->m_flags |= M_BCAST;
  440                 else
  441                         m->m_flags |= M_MCAST;
  442                 ifp->if_imcasts++;
  443         }
  444 
  445 #ifdef M_LINK0
  446         /*
  447          * If this has a LLC priority of 0, then mark it so upper
  448          * layers have a hint that it really came via a FDDI/Ethernet
  449          * bridge.
  450          */
  451         if ((fh->fddi_fc & FDDIFC_LLC_PRIO7) == FDDIFC_LLC_PRIO0)
  452                 m->m_flags |= M_LINK0;
  453 #endif
  454 
  455         /* Strip off FDDI header. */
  456         m_adj(m, FDDI_HDR_LEN);
  457 
  458         m = m_pullup(m, LLC_SNAPFRAMELEN);
  459         if (m == 0) {
  460                 ifp->if_ierrors++;
  461                 goto dropanyway;
  462         }
  463         l = mtod(m, struct llc *);
  464 
  465         switch (l->llc_dsap) {
  466         case LLC_SNAP_LSAP:
  467         {
  468                 u_int16_t type;
  469                 if ((l->llc_control != LLC_UI) ||
  470                     (l->llc_ssap != LLC_SNAP_LSAP)) {
  471                         ifp->if_noproto++;
  472                         goto dropanyway;
  473                 }
  474 #ifdef NETATALK
  475                 if (bcmp(&(l->llc_snap.org_code)[0], at_org_code,
  476                     sizeof(at_org_code)) == 0 &&
  477                     ntohs(l->llc_snap.ether_type) == ETHERTYPE_AT) {
  478                         isr = NETISR_ATALK2;
  479                         m_adj(m, LLC_SNAPFRAMELEN);
  480                         break;
  481                 }
  482 
  483                 if (bcmp(&(l->llc_snap.org_code)[0], aarp_org_code,
  484                     sizeof(aarp_org_code)) == 0 &&
  485                     ntohs(l->llc_snap.ether_type) == ETHERTYPE_AARP) {
  486                         m_adj(m, LLC_SNAPFRAMELEN);
  487                         isr = NETISR_AARP;
  488                         break;
  489                 }
  490 #endif /* NETATALK */
  491                 if (l->llc_snap.org_code[0] != 0 ||
  492                     l->llc_snap.org_code[1] != 0 ||
  493                     l->llc_snap.org_code[2] != 0) {
  494                         ifp->if_noproto++;
  495                         goto dropanyway;
  496                 }
  497 
  498                 type = ntohs(l->llc_snap.ether_type);
  499                 m_adj(m, LLC_SNAPFRAMELEN);
  500 
  501                 switch (type) {
  502 #ifdef INET
  503                 case ETHERTYPE_IP:
  504                         if ((m = ip_fastforward(m)) == NULL)
  505                                 return;
  506                         isr = NETISR_IP;
  507                         break;
  508 
  509                 case ETHERTYPE_ARP:
  510                         if (ifp->if_flags & IFF_NOARP)
  511                                 goto dropanyway;
  512                         isr = NETISR_ARP;
  513                         break;
  514 #endif
  515 #ifdef INET6
  516                 case ETHERTYPE_IPV6:
  517                         isr = NETISR_IPV6;
  518                         break;
  519 #endif
  520 #ifdef IPX      
  521                 case ETHERTYPE_IPX: 
  522                         isr = NETISR_IPX;
  523                         break;  
  524 #endif   
  525 #ifdef DECNET
  526                 case ETHERTYPE_DECNET:
  527                         isr = NETISR_DECNET;
  528                         break;
  529 #endif
  530 #ifdef NETATALK 
  531                 case ETHERTYPE_AT:
  532                         isr = NETISR_ATALK1;
  533                         break;
  534                 case ETHERTYPE_AARP:
  535                         isr = NETISR_AARP;
  536                         break;
  537 #endif /* NETATALK */
  538                 default:
  539                         /* printf("fddi_input: unknown protocol 0x%x\n", type); */
  540                         ifp->if_noproto++;
  541                         goto dropanyway;
  542                 }
  543                 break;
  544         }
  545                 
  546         default:
  547                 /* printf("fddi_input: unknown dsap 0x%x\n", l->llc_dsap); */
  548                 ifp->if_noproto++;
  549                 goto dropanyway;
  550         }
  551         M_SETFIB(m, ifp->if_fib);
  552         netisr_dispatch(isr, m);
  553         return;
  554 
  555 dropanyway:
  556         ifp->if_iqdrops++;
  557         if (m)
  558                 m_freem(m);
  559         return;
  560 }
  561 
  562 /*
  563  * Perform common duties while attaching to interface list
  564  */
  565 void
  566 fddi_ifattach(ifp, lla, bpf)
  567         struct ifnet *ifp;
  568         const u_int8_t *lla;
  569         int bpf;
  570 {
  571         struct ifaddr *ifa;
  572         struct sockaddr_dl *sdl;
  573 
  574         ifp->if_type = IFT_FDDI;
  575         ifp->if_addrlen = FDDI_ADDR_LEN;
  576         ifp->if_hdrlen = 21;
  577 
  578         if_attach(ifp);         /* Must be called before additional assignments */
  579 
  580         ifp->if_mtu = FDDIMTU;
  581         ifp->if_output = fddi_output;
  582         ifp->if_input = fddi_input;
  583         ifp->if_resolvemulti = fddi_resolvemulti;
  584         ifp->if_broadcastaddr = fddibroadcastaddr;
  585         ifp->if_baudrate = 100000000;
  586 #ifdef IFF_NOTRAILERS
  587         ifp->if_flags |= IFF_NOTRAILERS;
  588 #endif
  589         ifa = ifp->if_addr;
  590         KASSERT(ifa != NULL, ("%s: no lladdr!\n", __func__));
  591 
  592         sdl = (struct sockaddr_dl *)ifa->ifa_addr;
  593         sdl->sdl_type = IFT_FDDI;
  594         sdl->sdl_alen = ifp->if_addrlen;
  595         bcopy(lla, LLADDR(sdl), ifp->if_addrlen);
  596 
  597         if (bpf)
  598                 bpfattach(ifp, DLT_FDDI, FDDI_HDR_LEN);
  599 
  600         return;
  601 }
  602 
  603 void
  604 fddi_ifdetach(ifp, bpf)
  605         struct ifnet *ifp;
  606         int bpf;
  607 {
  608      
  609         if (bpf)
  610                 bpfdetach(ifp);
  611 
  612         if_detach(ifp);
  613 
  614         return;
  615 }
  616 
  617 int
  618 fddi_ioctl (ifp, command, data)
  619         struct ifnet *ifp;
  620         u_long command;
  621         caddr_t data;
  622 {
  623         struct ifaddr *ifa;
  624         struct ifreq *ifr;
  625         int error;
  626 
  627         ifa = (struct ifaddr *) data;
  628         ifr = (struct ifreq *) data;
  629         error = 0;
  630 
  631         switch (command) {
  632         case SIOCSIFADDR:
  633                 ifp->if_flags |= IFF_UP;
  634 
  635                 switch (ifa->ifa_addr->sa_family) {
  636 #ifdef INET
  637                 case AF_INET:   /* before arpwhohas */
  638                         ifp->if_init(ifp->if_softc);
  639                         arp_ifinit(ifp, ifa);
  640                         break;
  641 #endif
  642 #ifdef IPX
  643                 /*
  644                  * XXX - This code is probably wrong
  645                  */
  646                 case AF_IPX: {
  647                                 struct ipx_addr *ina;
  648 
  649                                 ina = &(IA_SIPX(ifa)->sipx_addr);
  650 
  651                                 if (ipx_nullhost(*ina)) {
  652                                         ina->x_host = *(union ipx_host *)
  653                                                         IF_LLADDR(ifp);
  654                                 } else {
  655                                         bcopy((caddr_t) ina->x_host.c_host,
  656                                               (caddr_t) IF_LLADDR(ifp),
  657                                               ETHER_ADDR_LEN);
  658                                 }
  659         
  660                                 /*
  661                                  * Set new address
  662                                  */
  663                                 ifp->if_init(ifp->if_softc);
  664                         }
  665                         break;
  666 #endif
  667                 default:
  668                         ifp->if_init(ifp->if_softc);
  669                         break;
  670                 }
  671                 break;
  672         case SIOCGIFADDR: {
  673                         struct sockaddr *sa;
  674 
  675                         sa = (struct sockaddr *) & ifr->ifr_data;
  676                         bcopy(IF_LLADDR(ifp),
  677                               (caddr_t) sa->sa_data, FDDI_ADDR_LEN);
  678 
  679                 }
  680                 break;
  681         case SIOCSIFMTU:
  682                 /*
  683                  * Set the interface MTU.
  684                  */
  685                 if (ifr->ifr_mtu > FDDIMTU) {
  686                         error = EINVAL;
  687                 } else {
  688                         ifp->if_mtu = ifr->ifr_mtu;
  689                 }
  690                 break;
  691         default:
  692                 error = EINVAL;
  693                 break;
  694         }
  695 
  696         return (error);
  697 }
  698 
  699 static int
  700 fddi_resolvemulti(ifp, llsa, sa)
  701         struct ifnet *ifp;
  702         struct sockaddr **llsa;
  703         struct sockaddr *sa;
  704 {
  705         struct sockaddr_dl *sdl;
  706 #ifdef INET
  707         struct sockaddr_in *sin;
  708 #endif
  709 #ifdef INET6
  710         struct sockaddr_in6 *sin6;
  711 #endif
  712         u_char *e_addr;
  713 
  714         switch(sa->sa_family) {
  715         case AF_LINK:
  716                 /*
  717                  * No mapping needed. Just check that it's a valid MC address.
  718                  */
  719                 sdl = (struct sockaddr_dl *)sa;
  720                 e_addr = LLADDR(sdl);
  721                 if ((e_addr[0] & 1) != 1)
  722                         return (EADDRNOTAVAIL);
  723                 *llsa = 0;
  724                 return (0);
  725 
  726 #ifdef INET
  727         case AF_INET:
  728                 sin = (struct sockaddr_in *)sa;
  729                 if (!IN_MULTICAST(ntohl(sin->sin_addr.s_addr)))
  730                         return (EADDRNOTAVAIL);
  731                 sdl = malloc(sizeof *sdl, M_IFMADDR,
  732                        M_NOWAIT | M_ZERO);
  733                 if (sdl == NULL)
  734                         return (ENOMEM);
  735                 sdl->sdl_len = sizeof *sdl;
  736                 sdl->sdl_family = AF_LINK;
  737                 sdl->sdl_index = ifp->if_index;
  738                 sdl->sdl_type = IFT_FDDI;
  739                 sdl->sdl_nlen = 0;
  740                 sdl->sdl_alen = FDDI_ADDR_LEN;
  741                 sdl->sdl_slen = 0;
  742                 e_addr = LLADDR(sdl);
  743                 ETHER_MAP_IP_MULTICAST(&sin->sin_addr, e_addr);
  744                 *llsa = (struct sockaddr *)sdl;
  745                 return (0);
  746 #endif
  747 #ifdef INET6
  748         case AF_INET6:
  749                 sin6 = (struct sockaddr_in6 *)sa;
  750                 if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
  751                         /*
  752                          * An IP6 address of 0 means listen to all
  753                          * of the Ethernet multicast address used for IP6.
  754                          * (This is used for multicast routers.)
  755                          */
  756                         ifp->if_flags |= IFF_ALLMULTI;
  757                         *llsa = 0;
  758                         return (0);
  759                 }
  760                 if (!IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr))
  761                         return (EADDRNOTAVAIL);
  762                 sdl = malloc(sizeof *sdl, M_IFMADDR,
  763                        M_NOWAIT | M_ZERO);
  764                 if (sdl == NULL)
  765                         return (ENOMEM);
  766                 sdl->sdl_len = sizeof *sdl;
  767                 sdl->sdl_family = AF_LINK;
  768                 sdl->sdl_index = ifp->if_index;
  769                 sdl->sdl_type = IFT_FDDI;
  770                 sdl->sdl_nlen = 0;
  771                 sdl->sdl_alen = FDDI_ADDR_LEN;
  772                 sdl->sdl_slen = 0;
  773                 e_addr = LLADDR(sdl);
  774                 ETHER_MAP_IPV6_MULTICAST(&sin6->sin6_addr, e_addr);
  775                 *llsa = (struct sockaddr *)sdl;
  776                 return (0);
  777 #endif
  778 
  779         default:
  780                 /*
  781                  * Well, the text isn't quite right, but it's the name
  782                  * that counts...
  783                  */
  784                 return (EAFNOSUPPORT);
  785         }
  786 
  787         return (0);
  788 }
  789 
  790 static moduledata_t fddi_mod = {
  791         "fddi", /* module name */
  792         NULL,   /* event handler */
  793         0       /* extra data */
  794 };
  795 
  796 DECLARE_MODULE(fddi, fddi_mod, SI_SUB_PSEUDO, SI_ORDER_ANY);
  797 MODULE_VERSION(fddi, 1);

Cache object: 7aeb5e72b7c8bd23fbc615743263c4ac


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