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