sys/net/if_fwsubr.c

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