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

Cache object: 24f0da198dd2aa40125b2014578b390b


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