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

FreeBSD/Linux Kernel Cross Reference
sys/net/if_fwsubr.c

Version: -  FREEBSD  -  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  -  cheribsd  -  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  -  FREEBSD-LIBC  -  FREEBSD8-LIBC  -  FREEBSD7-LIBC  -  FREEBSD6-LIBC  -  GLIBC27 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 2004 Doug Rabson
    3  * Copyright (c) 1982, 1989, 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  * 4. Neither the name of the University nor the names of its contributors
   15  *    may be used to endorse or promote products derived from this software
   16  *    without specific prior written permission.
   17  *
   18  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   28  * SUCH DAMAGE.
   29  *
   30  * $FreeBSD: src/sys/net/if_fwsubr.c,v 1.12.2.2.2.1 2005/10/28 22:52:31 avatar Exp $
   31  */
   32 
   33 #include "opt_inet.h"
   34 #include "opt_inet6.h"
   35 #include "opt_mac.h"
   36 
   37 #include <sys/param.h>
   38 #include <sys/systm.h>
   39 #include <sys/kernel.h>
   40 #include <sys/mac.h>
   41 #include <sys/malloc.h>
   42 #include <sys/mbuf.h>
   43 #include <sys/module.h>
   44 #include <sys/socket.h>
   45 #include <sys/sockio.h>
   46 
   47 #include <net/if.h>
   48 #include <net/netisr.h>
   49 #include <net/route.h>
   50 #include <net/if_llc.h>
   51 #include <net/if_dl.h>
   52 #include <net/if_types.h>
   53 #include <net/bpf.h>
   54 #include <net/firewire.h>
   55 
   56 #if defined(INET) || defined(INET6)
   57 #include <netinet/in.h>
   58 #include <netinet/in_var.h>
   59 #include <netinet/if_ether.h>
   60 #endif
   61 #ifdef INET6
   62 #include <netinet6/nd6.h>
   63 #endif
   64 
   65 #define IFP2FC(IFP) ((struct fw_com *)IFP)
   66 
   67 MALLOC_DEFINE(M_FWCOM, "fw_com", "firewire interface internals");
   68 
   69 struct fw_hwaddr firewire_broadcastaddr = {
   70         0xffffffff,
   71         0xffffffff,
   72         0xff,
   73         0xff,
   74         0xffff,
   75         0xffffffff
   76 };
   77 
   78 static int
   79 firewire_output(struct ifnet *ifp, struct mbuf *m, struct sockaddr *dst,
   80     struct rtentry *rt0)
   81 {
   82         struct fw_com *fc = IFP2FC(ifp);
   83         int error, type;
   84         struct rtentry *rt = NULL;
   85         struct m_tag *mtag;
   86         union fw_encap *enc;
   87         struct fw_hwaddr *destfw;
   88         uint8_t speed;
   89         uint16_t psize, fsize, dsize;
   90         struct mbuf *mtail;
   91         int unicast, dgl, foff;
   92         static int next_dgl;
   93 
   94 #ifdef MAC
   95         error = mac_check_ifnet_transmit(ifp, m);
   96         if (error)
   97                 goto bad;
   98 #endif
   99 
  100         if (!((ifp->if_flags & IFF_UP) &&
  101            (ifp->if_drv_flags & IFF_DRV_RUNNING))) {
  102                 error = ENETDOWN;
  103                 goto bad;
  104         }
  105 
  106         if (rt0 != NULL) {
  107                 error = rt_check(&rt, &rt0, dst);
  108                 if (error)
  109                         goto bad;
  110                 RT_UNLOCK(rt);
  111         }
  112 
  113         /*
  114          * For unicast, we make a tag to store the lladdr of the
  115          * destination. This might not be the first time we have seen
  116          * the packet (for instance, the arp code might be trying to
  117          * re-send it after receiving an arp reply) so we only
  118          * allocate a tag if there isn't one there already. For
  119          * multicast, we will eventually use a different tag to store
  120          * the channel number.
  121          */
  122         unicast = !(m->m_flags & (M_BCAST | M_MCAST));
  123         if (unicast) {
  124                 mtag = m_tag_locate(m, MTAG_FIREWIRE, MTAG_FIREWIRE_HWADDR, NULL);
  125                 if (!mtag) {
  126                         mtag = m_tag_alloc(MTAG_FIREWIRE, MTAG_FIREWIRE_HWADDR,
  127                             sizeof (struct fw_hwaddr), M_NOWAIT);
  128                         if (!mtag) {
  129                                 error = ENOMEM;
  130                                 goto bad;
  131                         }
  132                         m_tag_prepend(m, mtag);
  133                 }
  134                 destfw = (struct fw_hwaddr *)(mtag + 1);
  135         } else {
  136                 destfw = 0;
  137         }
  138 
  139         switch (dst->sa_family) {
  140 #ifdef AF_INET
  141         case AF_INET:
  142                 /*
  143                  * Only bother with arp for unicast. Allocation of
  144                  * channels etc. for firewire is quite different and
  145                  * doesn't fit into the arp model.
  146                  */
  147                 if (unicast) {
  148                         error = arpresolve(ifp, rt, m, dst, (u_char *) destfw);
  149                         if (error)
  150                                 return (error == EWOULDBLOCK ? 0 : error);
  151                 }
  152                 type = ETHERTYPE_IP;
  153                 break;
  154 
  155         case AF_ARP:
  156         {
  157                 struct arphdr *ah;
  158                 ah = mtod(m, struct arphdr *);
  159                 ah->ar_hrd = htons(ARPHRD_IEEE1394);
  160                 type = ETHERTYPE_ARP;
  161                 if (unicast)
  162                         *destfw = *(struct fw_hwaddr *) ar_tha(ah);
  163 
  164                 /*
  165                  * The standard arp code leaves a hole for the target
  166                  * hardware address which we need to close up.
  167                  */
  168                 bcopy(ar_tpa(ah), ar_tha(ah), ah->ar_pln);
  169                 m_adj(m, -ah->ar_hln);
  170                 break;
  171         }
  172 #endif
  173 
  174 #ifdef INET6
  175         case AF_INET6:
  176                 if (unicast) {
  177                         error = nd6_storelladdr(fc->fc_ifp, rt, m, dst,
  178                             (u_char *) destfw);
  179                         if (error)
  180                                 return (error);
  181                 }
  182                 type = ETHERTYPE_IPV6;
  183                 break;
  184 #endif
  185 
  186         default:
  187                 if_printf(ifp, "can't handle af%d\n", dst->sa_family);
  188                 error = EAFNOSUPPORT;
  189                 goto bad;
  190         }
  191 
  192         /*
  193          * Let BPF tap off a copy before we encapsulate.
  194          */
  195         if (ifp->if_bpf) {
  196                 struct fw_bpfhdr h;
  197                 if (unicast)
  198                         bcopy(destfw, h.firewire_dhost, 8);
  199                 else
  200                         bcopy(&firewire_broadcastaddr, h.firewire_dhost, 8);
  201                 bcopy(&fc->fc_hwaddr, h.firewire_shost, 8);
  202                 h.firewire_type = htons(type);
  203                 bpf_mtap2(ifp->if_bpf, &h, sizeof(h), m);
  204         }
  205 
  206         /*
  207          * Punt on MCAP for now and send all multicast packets on the
  208          * broadcast channel.
  209          */
  210         if (m->m_flags & M_MCAST)
  211                 m->m_flags |= M_BCAST;
  212 
  213         /*
  214          * Figure out what speed to use and what the largest supported
  215          * packet size is. For unicast, this is the minimum of what we
  216          * can speak and what they can hear. For broadcast, lets be
  217          * conservative and use S100. We could possibly improve that
  218          * by examining the bus manager's speed map or similar. We
  219          * also reduce the packet size for broadcast to account for
  220          * the GASP header.
  221          */
  222         if (unicast) {
  223                 speed = min(fc->fc_speed, destfw->sspd);
  224                 psize = min(512 << speed, 2 << destfw->sender_max_rec);
  225         } else {
  226                 speed = 0;
  227                 psize = 512 - 2*sizeof(uint32_t);
  228         }
  229 
  230         /*
  231          * Next, we encapsulate, possibly fragmenting the original
  232          * datagram if it won't fit into a single packet.
  233          */
  234         if (m->m_pkthdr.len <= psize - sizeof(uint32_t)) {
  235                 /*
  236                  * No fragmentation is necessary.
  237                  */
  238                 M_PREPEND(m, sizeof(uint32_t), M_DONTWAIT);
  239                 if (!m) {
  240                         error = ENOBUFS;
  241                         goto bad;
  242                 }
  243                 enc = mtod(m, union fw_encap *);
  244                 enc->unfrag.ether_type = type;
  245                 enc->unfrag.lf = FW_ENCAP_UNFRAG;
  246                 enc->unfrag.reserved = 0;
  247 
  248                 /*
  249                  * Byte swap the encapsulation header manually.
  250                  */
  251                 enc->ul[0] = htonl(enc->ul[0]);
  252 
  253                 IFQ_HANDOFF(ifp, m, error);
  254                 return (error);
  255         } else {
  256                 /*
  257                  * Fragment the datagram, making sure to leave enough
  258                  * space for the encapsulation header in each packet.
  259                  */
  260                 fsize = psize - 2*sizeof(uint32_t);
  261                 dgl = next_dgl++;
  262                 dsize = m->m_pkthdr.len;
  263                 foff = 0;
  264                 while (m) {
  265                         if (m->m_pkthdr.len > fsize) {
  266                                 /*
  267                                  * Split off the tail segment from the
  268                                  * datagram, copying our tags over.
  269                                  */
  270                                 mtail = m_split(m, fsize, M_DONTWAIT);
  271                                 m_tag_copy_chain(mtail, m, M_NOWAIT);
  272                         } else {
  273                                 mtail = 0;
  274                         }
  275 
  276                         /*
  277                          * Add our encapsulation header to this
  278                          * fragment and hand it off to the link.
  279                          */
  280                         M_PREPEND(m, 2*sizeof(uint32_t), M_DONTWAIT);
  281                         if (!m) {
  282                                 error = ENOBUFS;
  283                                 goto bad;
  284                         }
  285                         enc = mtod(m, union fw_encap *);
  286                         if (foff == 0) {
  287                                 enc->firstfrag.lf = FW_ENCAP_FIRST;
  288                                 enc->firstfrag.reserved1 = 0;
  289                                 enc->firstfrag.reserved2 = 0;
  290                                 enc->firstfrag.datagram_size = dsize - 1;
  291                                 enc->firstfrag.ether_type = type;
  292                                 enc->firstfrag.dgl = dgl;
  293                         } else {
  294                                 if (mtail)
  295                                         enc->nextfrag.lf = FW_ENCAP_NEXT;
  296                                 else
  297                                         enc->nextfrag.lf = FW_ENCAP_LAST;
  298                                 enc->nextfrag.reserved1 = 0;
  299                                 enc->nextfrag.reserved2 = 0;
  300                                 enc->nextfrag.reserved3 = 0;
  301                                 enc->nextfrag.datagram_size = dsize - 1;
  302                                 enc->nextfrag.fragment_offset = foff;
  303                                 enc->nextfrag.dgl = dgl;
  304                         }
  305                         foff += m->m_pkthdr.len - 2*sizeof(uint32_t);
  306 
  307                         /*
  308                          * Byte swap the encapsulation header manually.
  309                          */
  310                         enc->ul[0] = htonl(enc->ul[0]);
  311                         enc->ul[1] = htonl(enc->ul[1]);
  312 
  313                         IFQ_HANDOFF(ifp, m, error);
  314                         if (error) {
  315                                 if (mtail)
  316                                         m_freem(mtail);
  317                                 return (ENOBUFS);
  318                         }
  319 
  320                         m = mtail;
  321                 }
  322 
  323                 return (0);
  324         }
  325 
  326 bad:
  327         if (m)
  328                 m_freem(m);
  329         return (error);
  330 }
  331 
  332 static struct mbuf *
  333 firewire_input_fragment(struct fw_com *fc, struct mbuf *m, int src)
  334 {
  335         union fw_encap *enc;
  336         struct fw_reass *r;
  337         struct mbuf *mf, *mprev;
  338         int dsize;
  339         int fstart, fend, start, end, islast;
  340         uint32_t id;
  341 
  342         GIANT_REQUIRED;
  343 
  344         /*
  345          * Find an existing reassembly buffer or create a new one.
  346          */
  347         enc = mtod(m, union fw_encap *);
  348         id = enc->firstfrag.dgl | (src << 16);
  349         STAILQ_FOREACH(r, &fc->fc_frags, fr_link)
  350                 if (r->fr_id == id)
  351                         break;
  352         if (!r) {
  353                 r = malloc(sizeof(struct fw_reass), M_TEMP, M_NOWAIT);
  354                 if (!r) {
  355                         m_freem(m);
  356                         return 0;
  357                 }
  358                 r->fr_id = id;
  359                 r->fr_frags = 0;
  360                 STAILQ_INSERT_HEAD(&fc->fc_frags, r, fr_link);
  361         }
  362 
  363         /*
  364          * If this fragment overlaps any other fragment, we must discard
  365          * the partial reassembly and start again.
  366          */
  367         if (enc->firstfrag.lf == FW_ENCAP_FIRST)
  368                 fstart = 0;
  369         else
  370                 fstart = enc->nextfrag.fragment_offset;
  371         fend = fstart + m->m_pkthdr.len - 2*sizeof(uint32_t);
  372         dsize = enc->nextfrag.datagram_size;
  373         islast = (enc->nextfrag.lf == FW_ENCAP_LAST);
  374 
  375         for (mf = r->fr_frags; mf; mf = mf->m_nextpkt) {
  376                 enc = mtod(mf, union fw_encap *);
  377                 if (enc->nextfrag.datagram_size != dsize) {
  378                         /*
  379                          * This fragment must be from a different
  380                          * packet.
  381                          */
  382                         goto bad;
  383                 }
  384                 if (enc->firstfrag.lf == FW_ENCAP_FIRST)
  385                         start = 0;
  386                 else
  387                         start = enc->nextfrag.fragment_offset;
  388                 end = start + mf->m_pkthdr.len - 2*sizeof(uint32_t);
  389                 if ((fstart < end && fend > start) ||
  390                     (islast && enc->nextfrag.lf == FW_ENCAP_LAST)) {
  391                         /*
  392                          * Overlap - discard reassembly buffer and start
  393                          * again with this fragment.
  394                          */
  395                         goto bad;
  396                 }
  397         }
  398 
  399         /*
  400          * Find where to put this fragment in the list.
  401          */
  402         for (mf = r->fr_frags, mprev = NULL; mf;
  403             mprev = mf, mf = mf->m_nextpkt) {
  404                 enc = mtod(mf, union fw_encap *);
  405                 if (enc->firstfrag.lf == FW_ENCAP_FIRST)
  406                         start = 0;
  407                 else
  408                         start = enc->nextfrag.fragment_offset;
  409                 if (start >= fend)
  410                         break;
  411         }
  412 
  413         /*
  414          * If this is a last fragment and we are not adding at the end
  415          * of the list, discard the buffer.
  416          */
  417         if (islast && mprev && mprev->m_nextpkt)
  418                 goto bad;
  419 
  420         if (mprev) {
  421                 m->m_nextpkt = mprev->m_nextpkt;
  422                 mprev->m_nextpkt = m;
  423 
  424                 /*
  425                  * Coalesce forwards and see if we can make a whole
  426                  * datagram.
  427                  */
  428                 enc = mtod(mprev, union fw_encap *);
  429                 if (enc->firstfrag.lf == FW_ENCAP_FIRST)
  430                         start = 0;
  431                 else
  432                         start = enc->nextfrag.fragment_offset;
  433                 end = start + mprev->m_pkthdr.len - 2*sizeof(uint32_t);
  434                 while (end == fstart) {
  435                         /*
  436                          * Strip off the encap header from m and
  437                          * append it to mprev, freeing m.
  438                          */
  439                         m_adj(m, 2*sizeof(uint32_t));
  440                         mprev->m_nextpkt = m->m_nextpkt;
  441                         mprev->m_pkthdr.len += m->m_pkthdr.len;
  442                         m_cat(mprev, m);
  443 
  444                         if (mprev->m_pkthdr.len == dsize + 1 + 2*sizeof(uint32_t)) {
  445                                 /*
  446                                  * We have assembled a complete packet
  447                                  * we must be finished. Make sure we have
  448                                  * merged the whole chain.
  449                                  */
  450                                 STAILQ_REMOVE(&fc->fc_frags, r, fw_reass, fr_link);
  451                                 free(r, M_TEMP);
  452                                 m = mprev->m_nextpkt;
  453                                 while (m) {
  454                                         mf = m->m_nextpkt;
  455                                         m_freem(m);
  456                                         m = mf;
  457                                 }
  458                                 mprev->m_nextpkt = NULL;
  459 
  460                                 return (mprev);
  461                         }
  462 
  463                         /*
  464                          * See if we can continue merging forwards.
  465                          */
  466                         end = fend;
  467                         m = mprev->m_nextpkt;
  468                         if (m) {
  469                                 enc = mtod(m, union fw_encap *);
  470                                 if (enc->firstfrag.lf == FW_ENCAP_FIRST)
  471                                         fstart = 0;
  472                                 else
  473                                         fstart = enc->nextfrag.fragment_offset;
  474                                 fend = fstart + m->m_pkthdr.len
  475                                     - 2*sizeof(uint32_t);
  476                         } else {
  477                                 break;
  478                         }
  479                 }
  480         } else {
  481                 m->m_nextpkt = 0;
  482                 r->fr_frags = m;
  483         }
  484 
  485         return (0);
  486 
  487 bad:
  488         while (r->fr_frags) {
  489                 mf = r->fr_frags;
  490                 r->fr_frags = mf->m_nextpkt;
  491                 m_freem(mf);
  492         }
  493         m->m_nextpkt = 0;
  494         r->fr_frags = m;
  495 
  496         return (0);
  497 }
  498 
  499 void
  500 firewire_input(struct ifnet *ifp, struct mbuf *m, uint16_t src)
  501 {
  502         struct fw_com *fc = IFP2FC(ifp);
  503         union fw_encap *enc;
  504         int type, isr;
  505 
  506         GIANT_REQUIRED;
  507 
  508         /*
  509          * The caller has already stripped off the packet header
  510          * (stream or wreqb) and marked the mbuf's M_BCAST flag
  511          * appropriately. We de-encapsulate the IP packet and pass it
  512          * up the line after handling link-level fragmentation.
  513          */
  514         if (m->m_pkthdr.len < sizeof(uint32_t)) {
  515                 if_printf(ifp, "discarding frame without "
  516                     "encapsulation header (len %u pkt len %u)\n",
  517                     m->m_len, m->m_pkthdr.len);
  518         }
  519 
  520         m = m_pullup(m, sizeof(uint32_t));
  521         enc = mtod(m, union fw_encap *);
  522 
  523         /*
  524          * Byte swap the encapsulation header manually.
  525          */
  526         enc->ul[0] = htonl(enc->ul[0]);
  527 
  528         if (enc->unfrag.lf != 0) {
  529                 m = m_pullup(m, 2*sizeof(uint32_t));
  530                 if (!m)
  531                         return;
  532                 enc = mtod(m, union fw_encap *);
  533                 enc->ul[1] = htonl(enc->ul[1]);
  534                 m = firewire_input_fragment(fc, m, src);
  535                 if (!m)
  536                         return;
  537                 enc = mtod(m, union fw_encap *);
  538                 type = enc->firstfrag.ether_type;
  539                 m_adj(m, 2*sizeof(uint32_t));
  540         } else {
  541                 type = enc->unfrag.ether_type;
  542                 m_adj(m, sizeof(uint32_t));
  543         }
  544 
  545         if (m->m_pkthdr.rcvif == NULL) {
  546                 if_printf(ifp, "discard frame w/o interface pointer\n");
  547                 ifp->if_ierrors++;
  548                 m_freem(m);
  549                 return;
  550         }
  551 #ifdef DIAGNOSTIC
  552         if (m->m_pkthdr.rcvif != ifp) {
  553                 if_printf(ifp, "Warning, frame marked as received on %s\n",
  554                         m->m_pkthdr.rcvif->if_xname);
  555         }
  556 #endif
  557 
  558 #ifdef MAC
  559         /*
  560          * Tag the mbuf with an appropriate MAC label before any other
  561          * consumers can get to it.
  562          */
  563         mac_create_mbuf_from_ifnet(ifp, m);
  564 #endif
  565 
  566         /*
  567          * Give bpf a chance at the packet. The link-level driver
  568          * should have left us a tag with the EUID of the sender.
  569          */
  570         if (ifp->if_bpf) {
  571                 struct fw_bpfhdr h;
  572                 struct m_tag *mtag;
  573 
  574                 mtag = m_tag_locate(m, MTAG_FIREWIRE, MTAG_FIREWIRE_SENDER_EUID, 0);
  575                 if (mtag)
  576                         bcopy(mtag + 1, h.firewire_shost, 8);
  577                 else
  578                         bcopy(&firewire_broadcastaddr, h.firewire_dhost, 8);
  579                 bcopy(&fc->fc_hwaddr, h.firewire_dhost, 8);
  580                 h.firewire_type = htons(type);
  581                 bpf_mtap2(ifp->if_bpf, &h, sizeof(h), m);
  582         }
  583 
  584         if (ifp->if_flags & IFF_MONITOR) {
  585                 /*
  586                  * Interface marked for monitoring; discard packet.
  587                  */
  588                 m_freem(m);
  589                 return;
  590         }
  591 
  592         ifp->if_ibytes += m->m_pkthdr.len;
  593 
  594         /* Discard packet if interface is not up */
  595         if ((ifp->if_flags & IFF_UP) == 0) {
  596                 m_freem(m);
  597                 return;
  598         }
  599 
  600         if (m->m_flags & (M_BCAST|M_MCAST))
  601                 ifp->if_imcasts++;
  602 
  603         switch (type) {
  604 #ifdef INET
  605         case ETHERTYPE_IP:
  606                 if (ip_fastforward(m))
  607                         return;
  608                 isr = NETISR_IP;
  609                 break;
  610 
  611         case ETHERTYPE_ARP:
  612         {
  613                 struct arphdr *ah;
  614                 ah = mtod(m, struct arphdr *);
  615 
  616                 /*
  617                  * Adjust the arp packet to insert an empty tha slot.
  618                  */
  619                 m->m_len += ah->ar_hln;
  620                 m->m_pkthdr.len += ah->ar_hln;
  621                 bcopy(ar_tha(ah), ar_tpa(ah), ah->ar_pln);
  622                 isr = NETISR_ARP;
  623                 break;
  624         }
  625 #endif
  626 
  627 #ifdef INET6
  628         case ETHERTYPE_IPV6:
  629                 isr = NETISR_IPV6;
  630                 break;
  631 #endif
  632 
  633         default:
  634                 m_freem(m);
  635                 return;
  636         }
  637 
  638         netisr_dispatch(isr, m);
  639 }
  640 
  641 int
  642 firewire_ioctl(struct ifnet *ifp, int command, caddr_t data)
  643 {
  644         struct ifaddr *ifa = (struct ifaddr *) data;
  645         struct ifreq *ifr = (struct ifreq *) data;
  646         int error = 0;
  647 
  648         switch (command) {
  649         case SIOCSIFADDR:
  650                 ifp->if_flags |= IFF_UP;
  651 
  652                 switch (ifa->ifa_addr->sa_family) {
  653 #ifdef INET
  654                 case AF_INET:
  655                         ifp->if_init(ifp->if_softc);    /* before arpwhohas */
  656                         arp_ifinit(ifp, ifa);
  657                         break;
  658 #endif
  659                 default:
  660                         ifp->if_init(ifp->if_softc);
  661                         break;
  662                 }
  663                 break;
  664 
  665         case SIOCGIFADDR:
  666                 {
  667                         struct sockaddr *sa;
  668 
  669                         sa = (struct sockaddr *) & ifr->ifr_data;
  670                         bcopy(&IFP2FC(ifp)->fc_hwaddr,
  671                             (caddr_t) sa->sa_data, sizeof(struct fw_hwaddr));
  672                 }
  673                 break;
  674 
  675         case SIOCSIFMTU:
  676                 /*
  677                  * Set the interface MTU.
  678                  */
  679                 if (ifr->ifr_mtu > 1500) {
  680                         error = EINVAL;
  681                 } else {
  682                         ifp->if_mtu = ifr->ifr_mtu;
  683                 }
  684                 break;
  685         default:
  686                 error = EINVAL;                 /* XXX netbsd has ENOTTY??? */
  687                 break;
  688         }
  689         return (error);
  690 }
  691 
  692 static int
  693 firewire_resolvemulti(struct ifnet *ifp, struct sockaddr **llsa,
  694     struct sockaddr *sa)
  695 {
  696 #ifdef INET
  697         struct sockaddr_in *sin;
  698 #endif
  699 #ifdef INET6
  700         struct sockaddr_in6 *sin6;
  701 #endif
  702 
  703         switch(sa->sa_family) {
  704         case AF_LINK:
  705                 /*
  706                  * No mapping needed.
  707                  */
  708                 *llsa = 0;
  709                 return 0;
  710 
  711 #ifdef INET
  712         case AF_INET:
  713                 sin = (struct sockaddr_in *)sa;
  714                 if (!IN_MULTICAST(ntohl(sin->sin_addr.s_addr)))
  715                         return EADDRNOTAVAIL;
  716                 *llsa = 0;
  717                 return 0;
  718 #endif
  719 #ifdef INET6
  720         case AF_INET6:
  721                 sin6 = (struct sockaddr_in6 *)sa;
  722                 if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
  723                         /*
  724                          * An IP6 address of 0 means listen to all
  725                          * of the Ethernet multicast address used for IP6.
  726                          * (This is used for multicast routers.)
  727                          */
  728                         ifp->if_flags |= IFF_ALLMULTI;
  729                         *llsa = 0;
  730                         return 0;
  731                 }
  732                 if (!IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr))
  733                         return EADDRNOTAVAIL;
  734                 *llsa = 0;
  735                 return 0;
  736 #endif
  737 
  738         default:
  739                 /*
  740                  * Well, the text isn't quite right, but it's the name
  741                  * that counts...
  742                  */
  743                 return EAFNOSUPPORT;
  744         }
  745 }
  746 
  747 void
  748 firewire_ifattach(struct ifnet *ifp, struct fw_hwaddr *llc)
  749 {
  750         struct fw_com *fc = IFP2FC(ifp);
  751         struct ifaddr *ifa;
  752         struct sockaddr_dl *sdl;
  753         static const char* speeds[] = {
  754                 "S100", "S200", "S400", "S800",
  755                 "S1600", "S3200"
  756         };
  757 
  758         fc->fc_speed = llc->sspd;
  759         STAILQ_INIT(&fc->fc_frags);
  760 
  761         ifp->if_addrlen = sizeof(struct fw_hwaddr);
  762         ifp->if_hdrlen = 0;
  763         if_attach(ifp);
  764         ifp->if_mtu = 1500;     /* XXX */
  765         ifp->if_output = firewire_output;
  766         ifp->if_resolvemulti = firewire_resolvemulti;
  767         ifp->if_broadcastaddr = (u_char *) &firewire_broadcastaddr;
  768 
  769         ifa = ifaddr_byindex(ifp->if_index);
  770         KASSERT(ifa != NULL, ("%s: no lladdr!\n", __func__));
  771         sdl = (struct sockaddr_dl *)ifa->ifa_addr;
  772         sdl->sdl_type = IFT_IEEE1394;
  773         sdl->sdl_alen = ifp->if_addrlen;
  774         bcopy(llc, LLADDR(sdl), ifp->if_addrlen);
  775 
  776         bpfattach(ifp, DLT_APPLE_IP_OVER_IEEE1394,
  777             sizeof(struct fw_hwaddr));
  778 
  779         if_printf(ifp, "Firewire address: %8D @ 0x%04x%08x, %s, maxrec %d\n",
  780             (uint8_t *) &llc->sender_unique_ID_hi, ":",
  781             ntohs(llc->sender_unicast_FIFO_hi),
  782             ntohl(llc->sender_unicast_FIFO_lo),
  783             speeds[llc->sspd],
  784             (2 << llc->sender_max_rec));
  785 }
  786 
  787 void
  788 firewire_ifdetach(struct ifnet *ifp)
  789 {
  790         bpfdetach(ifp);
  791         if_detach(ifp);
  792 }
  793 
  794 void
  795 firewire_busreset(struct ifnet *ifp)
  796 {
  797         struct fw_com *fc = IFP2FC(ifp);
  798         struct fw_reass *r;
  799         struct mbuf *m;
  800 
  801         /*
  802          * Discard any partial datagrams since the host ids may have changed.
  803          */
  804         while ((r = STAILQ_FIRST(&fc->fc_frags))) {
  805                 STAILQ_REMOVE_HEAD(&fc->fc_frags, fr_link);
  806                 while (r->fr_frags) {
  807                         m = r->fr_frags;
  808                         r->fr_frags = m->m_nextpkt;
  809                         m_freem(m);
  810                 }
  811                 free(r, M_TEMP);
  812         }
  813 }
  814 
  815 static void *
  816 firewire_alloc(u_char type, struct ifnet *ifp)
  817 {
  818         struct fw_com   *fc;
  819 
  820         fc = malloc(sizeof(struct fw_com), M_FWCOM, M_WAITOK | M_ZERO);
  821         fc->fc_ifp = ifp;
  822 
  823         return (fc);
  824 }
  825 
  826 static void
  827 firewire_free(void *com, u_char type)
  828 {
  829 
  830         free(com, M_FWCOM);
  831 }
  832 
  833 static int
  834 firewire_modevent(module_t mod, int type, void *data)
  835 {
  836 
  837         switch (type) {
  838         case MOD_LOAD:
  839                 if_register_com_alloc(IFT_IEEE1394,
  840                     firewire_alloc, firewire_free);
  841                 break;
  842         case MOD_UNLOAD:
  843                 if_deregister_com_alloc(IFT_IEEE1394);
  844                 break;
  845         default:
  846                 return (EOPNOTSUPP);
  847         }
  848 
  849         return (0);
  850 }
  851 
  852 static moduledata_t firewire_mod = {
  853         "if_firewire",
  854         firewire_modevent,
  855         0
  856 };
  857 
  858 DECLARE_MODULE(if_firewire, firewire_mod, SI_SUB_INIT_IF, SI_ORDER_ANY);
  859 MODULE_VERSION(if_firewire, 1);

Cache object: 9357fae8e365bc2c92c36cdbc0fec72c


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