text: /*
   * Copyright (c) 2004 Doug Rabson
   * Copyright (c) 1982, 1989, 1993
   *	The Regents of the University of California.  All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
   * are met:
   * 1. Redistributions of source code must retain the above copyright
   *    notice, this list of conditions and the following disclaimer.
   * 2. Redistributions in binary form must reproduce the above copyright
   *    notice, this list of conditions and the following disclaimer in the
   *    documentation and/or other materials provided with the distribution.
   * 4. Neither the name of the University nor the names of its contributors
   *    may be used to endorse or promote products derived from this software
   *    without specific prior written permission.
   *
   * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   * SUCH DAMAGE.
   *
   * $FreeBSD: src/sys/net/if_fwsubr.c,v 1.5.2.1 2004/08/24 14:19:33 rwatson Exp $
   */
  
  #include "opt_inet.h"
  #include "opt_inet6.h"
  #include "opt_mac.h"
  
  #include <sys/param.h>
  #include <sys/systm.h>
  #include <sys/kernel.h>
  #include <sys/mac.h>
  #include <sys/malloc.h>
  #include <sys/mbuf.h>
  #include <sys/socket.h>
  #include <sys/sockio.h>
  
  #include <net/if.h>
  #include <net/netisr.h>
  #include <net/route.h>
  #include <net/if_llc.h>
  #include <net/if_dl.h>
  #include <net/if_types.h>
  #include <net/bpf.h>
  #include <net/firewire.h>
  
  #if defined(INET) || defined(INET6)
  #include <netinet/in.h>
  #include <netinet/in_var.h>
  #include <netinet/if_ether.h>
  #include <netinet/ip_fw.h>
  #include <netinet/ip_dummynet.h>
  #endif
  #ifdef INET6
  #include <netinet6/nd6.h>
  #endif
  
  #define IFP2FC(IFP) ((struct fw_com *)IFP)
  
  struct fw_hwaddr firewire_broadcastaddr = {
  	0xffffffff,
  	0xffffffff,
  	0xff,
  	0xff,
  	0xffff,
  	0xffffffff
  };
  
  static int
  firewire_output(struct ifnet *ifp, struct mbuf *m, struct sockaddr *dst,
      struct rtentry *rt0)
  {
  	struct fw_com *fc = (struct fw_com *) ifp;
  	int error, type;
  	struct rtentry *rt;
  	struct m_tag *mtag;
  	union fw_encap *enc;
  	struct fw_hwaddr *destfw;
  	uint8_t speed;
  	uint16_t psize, fsize, dsize;
  	struct mbuf *mtail;
  	int unicast, dgl, foff;
  	static int next_dgl;
  
  #ifdef MAC
  	error = mac_check_ifnet_transmit(ifp, m);
  	if (error)
  		goto bad;
  #endif
  
  	if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) {
  		error = ENETDOWN;
  		goto bad;
  	}
  
  	error = rt_check(&rt, &rt0, dst);
  	if (error)
  		goto bad;
  
  	/*
  	 * For unicast, we make a tag to store the lladdr of the
  	 * destination. This might not be the first time we have seen
  	 * the packet (for instance, the arp code might be trying to
  	 * re-send it after receiving an arp reply) so we only
  	 * allocate a tag if there isn't one there already. For
  	 * multicast, we will eventually use a different tag to store
  	 * the channel number.
  	 */
  	unicast = !(m->m_flags & (M_BCAST | M_MCAST));
  	if (unicast) {
  		mtag = m_tag_locate(m, MTAG_FIREWIRE, MTAG_FIREWIRE_HWADDR, NULL);
  		if (!mtag) {
  			mtag = m_tag_alloc(MTAG_FIREWIRE, MTAG_FIREWIRE_HWADDR,
  			    sizeof (struct fw_hwaddr), M_NOWAIT);
  			if (!mtag) {
  				error = ENOMEM;
  				goto bad;
  			}
  			m_tag_prepend(m, mtag);
  		}
  		destfw = (struct fw_hwaddr *)(mtag + 1);
  	} else {
  		destfw = 0;
  	}
  
  	switch (dst->sa_family) {
  #ifdef AF_INET
  	case AF_INET:
  		/*
  		 * Only bother with arp for unicast. Allocation of
  		 * channels etc. for firewire is quite different and
  		 * doesn't fit into the arp model.
  		 */
  		if (unicast) {
  			error = arpresolve(ifp, rt, m, dst, (u_char *) destfw);
  			if (error)
  				return (error == EWOULDBLOCK ? 0 : error);
  		}
  		type = ETHERTYPE_IP;
  		break;
  
  	case AF_ARP:
  	{
  		struct arphdr *ah;
  		ah = mtod(m, struct arphdr *);
  		ah->ar_hrd = htons(ARPHRD_IEEE1394);
  		type = ETHERTYPE_ARP;
  		if (unicast)
  			*destfw = *(struct fw_hwaddr *) ar_tha(ah);
  
  		/*
  		 * The standard arp code leaves a hole for the target
  		 * hardware address which we need to close up.
  		 */
  		bcopy(ar_tpa(ah), ar_tha(ah), ah->ar_pln);
  		m_adj(m, -ah->ar_hln);
  		break;
  	}
  #endif
  
  #ifdef INET6
  	case AF_INET6:
  		if (unicast) {
  			/*
  			 * XXX: nd6_storelladdr()'s return value has different 
  			 * meaning between FreeBSD and KAME.
  			 */
  			if (!nd6_storelladdr(&fc->fc_if, rt, m, dst,
  			    (u_char *) destfw))
  				return (EINVAL);	/* XXX */
  		}
  		type = ETHERTYPE_IPV6;
  		break;
  #endif
  
  	default:
  		if_printf(ifp, "can't handle af%d\n", dst->sa_family);
  		error = EAFNOSUPPORT;
  		goto bad;
  	}
  
  	/*
  	 * Let BPF tap off a copy before we encapsulate.
  	 */
  	if (ifp->if_bpf) {
  		struct fw_bpfhdr h;
  		if (unicast)
  			bcopy(destfw, h.firewire_dhost, 8);
  		else
  			bcopy(&firewire_broadcastaddr, h.firewire_dhost, 8);
  		bcopy(&fc->fc_hwaddr, h.firewire_shost, 8);
  		h.firewire_type = htons(type);
  		bpf_mtap2(ifp->if_bpf, &h, sizeof(h), m);
  	}
  
  	/*
  	 * Punt on MCAP for now and send all multicast packets on the
  	 * broadcast channel.
  	 */
  	if (m->m_flags & M_MCAST)
  		m->m_flags |= M_BCAST;
  
  	/*
  	 * Figure out what speed to use and what the largest supported
  	 * packet size is. For unicast, this is the minimum of what we
  	 * can speak and what they can hear. For broadcast, lets be
  	 * conservative and use S100. We could possibly improve that
  	 * by examining the bus manager's speed map or similar. We
  	 * also reduce the packet size for broadcast to account for
  	 * the GASP header.
  	 */
  	if (unicast) {
  		speed = min(fc->fc_speed, destfw->sspd);
  		psize = min(512 << speed, 2 << destfw->sender_max_rec);
  	} else {
  		speed = 0;
  		psize = 512 - 2*sizeof(uint32_t);
  	}
  
  	/*
  	 * Next, we encapsulate, possibly fragmenting the original
  	 * datagram if it won't fit into a single packet.
  	 */
  	if (m->m_pkthdr.len <= psize - sizeof(uint32_t)) {
  		/*
  		 * No fragmentation is necessary.
  		 */
  		M_PREPEND(m, sizeof(uint32_t), M_DONTWAIT);
  		if (!m) {
  			error = ENOBUFS;
  			goto bad;
  		}
  		enc = mtod(m, union fw_encap *);
  		enc->unfrag.ether_type = type;
  		enc->unfrag.lf = FW_ENCAP_UNFRAG;
  
  		/*
  		 * Byte swap the encapsulation header manually.
  		 */
  		enc->ul[0] = htonl(enc->ul[0]);
  
  		IFQ_HANDOFF(ifp, m, error);
  		return (error);
  	} else {
  		/*
  		 * Fragment the datagram, making sure to leave enough
  		 * space for the encapsulation header in each packet.
  		 */
  		fsize = psize - 2*sizeof(uint32_t);
  		dgl = next_dgl++;
  		dsize = m->m_pkthdr.len;
  		foff = 0;
  		while (m) {
  			if (m->m_pkthdr.len > fsize) {
  				/*
  				 * Split off the tail segment from the
  				 * datagram, copying our tags over.
  				 */
  				mtail = m_split(m, fsize, M_DONTWAIT);
  				m_tag_copy_chain(mtail, m);
  			} else {
  				mtail = 0;
  			}
  
  			/*
  			 * Add our encapsulation header to this
  			 * fragment and hand it off to the link.
  			 */
  			M_PREPEND(m, 2*sizeof(uint32_t), M_DONTWAIT);
  			if (!m) {
  				error = ENOBUFS;
  				goto bad;
  			}
  			enc = mtod(m, union fw_encap *);
  			if (foff == 0) {
  				enc->firstfrag.lf = FW_ENCAP_FIRST;
  				enc->firstfrag.datagram_size = dsize - 1;
  				enc->firstfrag.ether_type = type;
  				enc->firstfrag.dgl = dgl;
  			} else {
  				if (mtail)
  					enc->nextfrag.lf = FW_ENCAP_NEXT;
  				else
  					enc->nextfrag.lf = FW_ENCAP_LAST;
  				enc->nextfrag.datagram_size = dsize - 1;
  				enc->nextfrag.fragment_offset = foff;
  				enc->nextfrag.dgl = dgl;
  			}
  			foff += m->m_pkthdr.len - 2*sizeof(uint32_t);
  
  			/*
  			 * Byte swap the encapsulation header manually.
  			 */
  			enc->ul[0] = htonl(enc->ul[0]);
  			enc->ul[1] = htonl(enc->ul[1]);
  
  			IFQ_HANDOFF(ifp, m, error);
  			if (error) {
  				if (mtail)
  					m_freem(mtail);
  				return (ENOBUFS);
  			}
  
  			m = mtail;
  		}
  
  		return (0);
  	}
  
  bad:
  	if (m)
  		m_freem(m);
  	return (error);
  }
  
  static struct mbuf *
  firewire_input_fragment(struct fw_com *fc, struct mbuf *m, int src)
  {
  	union fw_encap *enc;
  	struct fw_reass *r;
  	struct mbuf *mf, *mprev;
  	int dsize;
  	int fstart, fend, start, end, islast;
  	uint32_t id;
  
  	GIANT_REQUIRED;
  
  	/*
  	 * Find an existing reassembly buffer or create a new one.
  	 */
  	enc = mtod(m, union fw_encap *);
  	id = enc->firstfrag.dgl | (src << 16);
  	STAILQ_FOREACH(r, &fc->fc_frags, fr_link)
  		if (r->fr_id == id)
  			break;
  	if (!r) {
  		r = malloc(sizeof(struct fw_reass), M_TEMP, M_NOWAIT);
  		if (!r) {
  			m_freem(m);
  			return 0;
  		}
  		r->fr_id = id;
  		r->fr_frags = 0;
  		STAILQ_INSERT_HEAD(&fc->fc_frags, r, fr_link);
  	}
  
  	/*
  	 * If this fragment overlaps any other fragment, we must discard
  	 * the partial reassembly and start again.
  	 */
  	if (enc->firstfrag.lf == FW_ENCAP_FIRST)
  		fstart = 0;
  	else
  		fstart = enc->nextfrag.fragment_offset;
  	fend = fstart + m->m_pkthdr.len - 2*sizeof(uint32_t);
  	dsize = enc->nextfrag.datagram_size;
  	islast = (enc->nextfrag.lf == FW_ENCAP_LAST);
  
  	for (mf = r->fr_frags; mf; mf = mf->m_nextpkt) {
  		enc = mtod(mf, union fw_encap *);
  		if (enc->nextfrag.datagram_size != dsize) {
  			/*
  			 * This fragment must be from a different
  			 * packet.
  			 */
  			goto bad;
  		}
  		if (enc->firstfrag.lf == FW_ENCAP_FIRST)
  			start = 0;
  		else
  			start = enc->nextfrag.fragment_offset;
  		end = start + mf->m_pkthdr.len - 2*sizeof(uint32_t);
  		if ((fstart < end && fend > start) ||
  		    (islast && enc->nextfrag.lf == FW_ENCAP_LAST)) {
  			/*
  			 * Overlap - discard reassembly buffer and start
  			 * again with this fragment.
  			 */
  			goto bad;
  		}
  	}
  
  	/*
  	 * Find where to put this fragment in the list.
  	 */
  	for (mf = r->fr_frags, mprev = NULL; mf;
  	    mprev = mf, mf = mf->m_nextpkt) {
  		enc = mtod(mf, union fw_encap *);
  		if (enc->firstfrag.lf == FW_ENCAP_FIRST)
  			start = 0;
  		else
  			start = enc->nextfrag.fragment_offset;
  		if (start >= fend)
  			break;
  	}
  
  	/*
  	 * If this is a last fragment and we are not adding at the end
  	 * of the list, discard the buffer.
  	 */
  	if (islast && mprev && mprev->m_nextpkt)
  		goto bad;
  
  	if (mprev) {
  		m->m_nextpkt = mprev->m_nextpkt;
  		mprev->m_nextpkt = m;
  
  		/*
  		 * Coalesce forwards and see if we can make a whole
  		 * datagram.
  		 */
  		enc = mtod(mprev, union fw_encap *);
  		if (enc->firstfrag.lf == FW_ENCAP_FIRST)
  			start = 0;
  		else
  			start = enc->nextfrag.fragment_offset;
  		end = start + mprev->m_pkthdr.len - 2*sizeof(uint32_t);
  		while (end == fstart) {
  			/*
  			 * Strip off the encap header from m and
  			 * append it to mprev, freeing m.
  			 */
  			m_adj(m, 2*sizeof(uint32_t));
  			mprev->m_nextpkt = m->m_nextpkt;
  			mprev->m_pkthdr.len += m->m_pkthdr.len;
  			m_cat(mprev, m);
  
  			if (mprev->m_pkthdr.len == dsize + 1 + 2*sizeof(uint32_t)) {
  				/*
  				 * We have assembled a complete packet
  				 * we must be finished. Make sure we have
  				 * merged the whole chain.
  				 */
  				STAILQ_REMOVE(&fc->fc_frags, r, fw_reass, fr_link);
  				free(r, M_TEMP);
  				m = mprev->m_nextpkt;
  				while (m) {
  					mf = m->m_nextpkt;
  					m_freem(m);
  					m = mf;
  				}
  				mprev->m_nextpkt = NULL;
  
  				return (mprev);
  			}
  
  			/*
  			 * See if we can continue merging forwards.
  			 */
  			end = fend;
  			m = mprev->m_nextpkt;
  			if (m) {
  				enc = mtod(m, union fw_encap *);
  				if (enc->firstfrag.lf == FW_ENCAP_FIRST)
  					fstart = 0;
  				else
  					fstart = enc->nextfrag.fragment_offset;
  				fend = fstart + m->m_pkthdr.len
  				    - 2*sizeof(uint32_t);
  			} else {
  				break;
  			}
  		}
  	} else {
  		m->m_nextpkt = 0;
  		r->fr_frags = m;
  	}
  
  	return (0);
  
  bad:
  	while (r->fr_frags) {
  		mf = r->fr_frags;
  		r->fr_frags = mf->m_nextpkt;
  		m_freem(mf);
  	}
  	m->m_nextpkt = 0;
  	r->fr_frags = m;
  
  	return (0);
  }
  
  void
  firewire_input(struct ifnet *ifp, struct mbuf *m, uint16_t src)
  {
  	struct fw_com *fc = (struct fw_com *) ifp;
  	union fw_encap *enc;
  	int type, isr;
  
  	GIANT_REQUIRED;
  
  	/*
  	 * The caller has already stripped off the packet header
  	 * (stream or wreqb) and marked the mbuf's M_BCAST flag
  	 * appropriately. We de-encapsulate the IP packet and pass it
  	 * up the line after handling link-level fragmentation.
  	 */
  	if (m->m_pkthdr.len < sizeof(uint32_t)) {
  		if_printf(ifp, "discarding frame without "
  		    "encapsulation header (len %u pkt len %u)\n",
  		    m->m_len, m->m_pkthdr.len);
  	}
  
  	m = m_pullup(m, sizeof(uint32_t));
  	enc = mtod(m, union fw_encap *);
  
  	/*
  	 * Byte swap the encapsulation header manually.
  	 */
  	enc->ul[0] = htonl(enc->ul[0]);
  
  	if (enc->unfrag.lf != 0) {
  		m = m_pullup(m, 2*sizeof(uint32_t));
  		if (!m)
  			return;
  		enc = mtod(m, union fw_encap *);
  		enc->ul[1] = htonl(enc->ul[1]);
  		m = firewire_input_fragment(fc, m, src);
  		if (!m)
  			return;
  		enc = mtod(m, union fw_encap *);
  		type = enc->firstfrag.ether_type;
  		m_adj(m, 2*sizeof(uint32_t));
  	} else {
  		type = enc->unfrag.ether_type;
  		m_adj(m, sizeof(uint32_t));
  	}
  
  	if (m->m_pkthdr.rcvif == NULL) {
  		if_printf(ifp, "discard frame w/o interface pointer\n");
  		ifp->if_ierrors++;
  		m_freem(m);
  		return;
  	}
  #ifdef DIAGNOSTIC
  	if (m->m_pkthdr.rcvif != ifp) {
  		if_printf(ifp, "Warning, frame marked as received on %s\n",
  			m->m_pkthdr.rcvif->if_xname);
  	}
  #endif
  
  #ifdef MAC
  	/*
  	 * Tag the mbuf with an appropriate MAC label before any other
  	 * consumers can get to it.
  	 */
  	mac_create_mbuf_from_ifnet(ifp, m);
  #endif
  
  	/*
  	 * Give bpf a chance at the packet. The link-level driver
  	 * should have left us a tag with the EUID of the sender.
  	 */
  	if (ifp->if_bpf) {
  		struct fw_bpfhdr h;
  		struct m_tag *mtag;
  
  		mtag = m_tag_locate(m, MTAG_FIREWIRE, MTAG_FIREWIRE_SENDER_EUID, 0);
  		if (mtag)
  			bcopy(mtag + 1, h.firewire_shost, 8);
  		else
  			bcopy(&firewire_broadcastaddr, h.firewire_dhost, 8);
  		bcopy(&fc->fc_hwaddr, h.firewire_dhost, 8);
  		h.firewire_type = htons(type);
  		bpf_mtap2(ifp->if_bpf, &h, sizeof(h), m);
  	}
  
  	if (ifp->if_flags & IFF_MONITOR) {
  		/*
  		 * Interface marked for monitoring; discard packet.
  		 */
  		m_freem(m);
  		return;
  	}
  
  	ifp->if_ibytes += m->m_pkthdr.len;
  
  	/* Discard packet if interface is not up */
  	if ((ifp->if_flags & IFF_UP) == 0) {
  		m_freem(m);
  		return;
  	}
  
  	if (m->m_flags & (M_BCAST|M_MCAST))
  		ifp->if_imcasts++;
  
  	switch (type) {
  #ifdef INET
  	case ETHERTYPE_IP:
  		if (ip_fastforward(m))
  			return;
  		isr = NETISR_IP;
  		break;
  
  	case ETHERTYPE_ARP:
  	{
  		struct arphdr *ah;
  		ah = mtod(m, struct arphdr *);
  
  		/*
  		 * Adjust the arp packet to insert an empty tha slot.
  		 */
  		m->m_len += ah->ar_hln;
  		m->m_pkthdr.len += ah->ar_hln;
  		bcopy(ar_tha(ah), ar_tpa(ah), ah->ar_pln);
  		isr = NETISR_ARP;
  		break;
  	}
  #endif
  
  #ifdef INET6
  	case ETHERTYPE_IPV6:
  		isr = NETISR_IPV6;
  		break;
  #endif
  
  	default:
  		m_freem(m);
  		return;
  	}
  
  	netisr_dispatch(isr, m);
  }
  
  int
  firewire_ioctl(struct ifnet *ifp, int command, caddr_t data)
  {
  	struct ifaddr *ifa = (struct ifaddr *) data;
  	struct ifreq *ifr = (struct ifreq *) data;
  	int error = 0;
  
  	switch (command) {
  	case SIOCSIFADDR:
  		ifp->if_flags |= IFF_UP;
  
  		switch (ifa->ifa_addr->sa_family) {
  #ifdef INET
  		case AF_INET:
  			ifp->if_init(ifp->if_softc);	/* before arpwhohas */
  			arp_ifinit(ifp, ifa);
  			break;
  #endif
  		default:
  			ifp->if_init(ifp->if_softc);
  			break;
  		}
  		break;
  
  	case SIOCGIFADDR:
  		{
  			struct sockaddr *sa;
  
  			sa = (struct sockaddr *) & ifr->ifr_data;
  			bcopy(&IFP2FC(ifp)->fc_hwaddr,
  			    (caddr_t) sa->sa_data, sizeof(struct fw_hwaddr));
  		}
  		break;
  
  	case SIOCSIFMTU:
  		/*
  		 * Set the interface MTU.
  		 */
  		if (ifr->ifr_mtu > 1500) {
  			error = EINVAL;
  		} else {
  			ifp->if_mtu = ifr->ifr_mtu;
  		}
  		break;
  	default:
  		error = EINVAL;			/* XXX netbsd has ENOTTY??? */
  		break;
  	}
  	return (error);
  }
  
  static int
  firewire_resolvemulti(struct ifnet *ifp, struct sockaddr **llsa,
      struct sockaddr *sa)
  {
  #ifdef INET
  	struct sockaddr_in *sin;
  #endif
  #ifdef INET6
  	struct sockaddr_in6 *sin6;
  #endif
  
  	switch(sa->sa_family) {
  	case AF_LINK:
  		/*
  		 * No mapping needed.
  		 */
  		*llsa = 0;
  		return 0;
  
  #ifdef INET
  	case AF_INET:
  		sin = (struct sockaddr_in *)sa;
  		if (!IN_MULTICAST(ntohl(sin->sin_addr.s_addr)))
  			return EADDRNOTAVAIL;
  		*llsa = 0;
  		return 0;
  #endif
  #ifdef INET6
  	case AF_INET6:
  		sin6 = (struct sockaddr_in6 *)sa;
  		if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
  			/*
  			 * An IP6 address of 0 means listen to all
  			 * of the Ethernet multicast address used for IP6.
  			 * (This is used for multicast routers.)
  			 */
  			ifp->if_flags |= IFF_ALLMULTI;
  			*llsa = 0;
  			return 0;
  		}
  		if (!IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr))
  			return EADDRNOTAVAIL;
  		*llsa = 0;
  		return 0;
  #endif
  
  	default:
  		/*
  		 * Well, the text isn't quite right, but it's the name
  		 * that counts...
  		 */
  		return EAFNOSUPPORT;
  	}
  }
  
  void
  firewire_ifattach(struct ifnet *ifp, struct fw_hwaddr *llc)
  {
  	struct fw_com *fc = (struct fw_com *) ifp;
  	struct ifaddr *ifa;
  	struct sockaddr_dl *sdl;
  	static const char* speeds[] = {
  		"S100", "S200", "S400", "S800",
  		"S1600", "S3200"
  	};
  
  	fc->fc_speed = llc->sspd;
  	STAILQ_INIT(&fc->fc_frags);
  
  	ifp->if_type = IFT_IEEE1394;
  	ifp->if_addrlen = sizeof(struct fw_hwaddr);
  	ifp->if_hdrlen = 0;
  	if_attach(ifp);
  	ifp->if_mtu = 1500;	/* XXX */
  	ifp->if_output = firewire_output;
  	ifp->if_resolvemulti = firewire_resolvemulti;
  	ifp->if_broadcastaddr = (u_char *) &firewire_broadcastaddr;
  
  	ifa = ifaddr_byindex(ifp->if_index);
  	KASSERT(ifa != NULL, ("%s: no lladdr!\n", __func__));
  	sdl = (struct sockaddr_dl *)ifa->ifa_addr;
  	sdl->sdl_type = IFT_IEEE1394;
  	sdl->sdl_alen = ifp->if_addrlen;
  	bcopy(llc, LLADDR(sdl), ifp->if_addrlen);
  
  	bpfattach(ifp, DLT_APPLE_IP_OVER_IEEE1394,
  	    sizeof(struct fw_hwaddr));
  
  	if_printf(ifp, "Firewire address: %8D @ 0x%04x%08x, %s, maxrec %d\n",
  	    (uint8_t *) &llc->sender_unique_ID_hi, ":",
  	    ntohs(llc->sender_unicast_FIFO_hi),
  	    ntohl(llc->sender_unicast_FIFO_lo),
  	    speeds[llc->sspd],
  	    (2 << llc->sender_max_rec));
  }
  
  void
  firewire_ifdetach(struct ifnet *ifp)
  {
  	bpfdetach(ifp);
  	if_detach(ifp);
  }
  
  void
  firewire_busreset(struct ifnet *ifp)
  {
  	struct fw_com *fc = (struct fw_com *) ifp;
  	struct fw_reass *r;
  	struct mbuf *m;
  
  	/*
  	 * Discard any partial datagrams since the host ids may have changed.
  	 */
  	while ((r = STAILQ_FIRST(&fc->fc_frags))) {
  		STAILQ_REMOVE_HEAD(&fc->fc_frags, fr_link);
  		while (r->fr_frags) {
  			m = r->fr_frags;
  			r->fr_frags = m->m_nextpkt;
  			m_freem(m);
  		}
  		free(r, M_TEMP);
  	}
  }
  