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