Home | History | Annotate | Line # | Download | only in net
if_ethersubr.c revision 1.287
      1 /*	$NetBSD: if_ethersubr.c,v 1.287 2020/08/28 06:27:16 ozaki-r Exp $	*/
      2 
      3 /*
      4  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
      5  * All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  * 3. Neither the name of the project nor the names of its contributors
     16  *    may be used to endorse or promote products derived from this software
     17  *    without specific prior written permission.
     18  *
     19  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
     20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
     23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     29  * SUCH DAMAGE.
     30  */
     31 
     32 /*
     33  * Copyright (c) 1982, 1989, 1993
     34  *	The Regents of the University of California.  All rights reserved.
     35  *
     36  * Redistribution and use in source and binary forms, with or without
     37  * modification, are permitted provided that the following conditions
     38  * are met:
     39  * 1. Redistributions of source code must retain the above copyright
     40  *    notice, this list of conditions and the following disclaimer.
     41  * 2. Redistributions in binary form must reproduce the above copyright
     42  *    notice, this list of conditions and the following disclaimer in the
     43  *    documentation and/or other materials provided with the distribution.
     44  * 3. Neither the name of the University nor the names of its contributors
     45  *    may be used to endorse or promote products derived from this software
     46  *    without specific prior written permission.
     47  *
     48  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     49  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     50  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     51  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     52  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     53  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     54  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     55  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     56  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     57  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     58  * SUCH DAMAGE.
     59  *
     60  *	@(#)if_ethersubr.c	8.2 (Berkeley) 4/4/96
     61  */
     62 
     63 #include <sys/cdefs.h>
     64 __KERNEL_RCSID(0, "$NetBSD: if_ethersubr.c,v 1.287 2020/08/28 06:27:16 ozaki-r Exp $");
     65 
     66 #ifdef _KERNEL_OPT
     67 #include "opt_inet.h"
     68 #include "opt_atalk.h"
     69 #include "opt_mbuftrace.h"
     70 #include "opt_mpls.h"
     71 #include "opt_gateway.h"
     72 #include "opt_pppoe.h"
     73 #include "opt_net_mpsafe.h"
     74 #endif
     75 
     76 #include "vlan.h"
     77 #include "pppoe.h"
     78 #include "bridge.h"
     79 #include "arp.h"
     80 #include "agr.h"
     81 
     82 #include <sys/sysctl.h>
     83 #include <sys/mbuf.h>
     84 #include <sys/mutex.h>
     85 #include <sys/ioctl.h>
     86 #include <sys/errno.h>
     87 #include <sys/device.h>
     88 #include <sys/entropy.h>
     89 #include <sys/rndsource.h>
     90 #include <sys/cpu.h>
     91 #include <sys/kmem.h>
     92 
     93 #include <net/if.h>
     94 #include <net/netisr.h>
     95 #include <net/route.h>
     96 #include <net/if_llc.h>
     97 #include <net/if_dl.h>
     98 #include <net/if_types.h>
     99 #include <net/pktqueue.h>
    100 
    101 #include <net/if_media.h>
    102 #include <dev/mii/mii.h>
    103 #include <dev/mii/miivar.h>
    104 
    105 #if NARP == 0
    106 /*
    107  * XXX there should really be a way to issue this warning from within config(8)
    108  */
    109 #error You have included NETATALK or a pseudo-device in your configuration that depends on the presence of ethernet interfaces, but have no such interfaces configured. Check if you really need pseudo-device bridge, pppoe, vlan or options NETATALK.
    110 #endif
    111 
    112 #include <net/bpf.h>
    113 
    114 #include <net/if_ether.h>
    115 #include <net/if_vlanvar.h>
    116 
    117 #if NPPPOE > 0
    118 #include <net/if_pppoe.h>
    119 #endif
    120 
    121 #if NAGR > 0
    122 #include <net/agr/ieee8023_slowprotocols.h>	/* XXX */
    123 #include <net/agr/ieee8023ad.h>
    124 #include <net/agr/if_agrvar.h>
    125 #endif
    126 
    127 #if NBRIDGE > 0
    128 #include <net/if_bridgevar.h>
    129 #endif
    130 
    131 #include <netinet/in.h>
    132 #ifdef INET
    133 #include <netinet/in_var.h>
    134 #endif
    135 #include <netinet/if_inarp.h>
    136 
    137 #ifdef INET6
    138 #ifndef INET
    139 #include <netinet/in.h>
    140 #endif
    141 #include <netinet6/in6_var.h>
    142 #include <netinet6/nd6.h>
    143 #endif
    144 
    145 #include "carp.h"
    146 #if NCARP > 0
    147 #include <netinet/ip_carp.h>
    148 #endif
    149 
    150 #ifdef NETATALK
    151 #include <netatalk/at.h>
    152 #include <netatalk/at_var.h>
    153 #include <netatalk/at_extern.h>
    154 
    155 #define llc_snap_org_code llc_un.type_snap.org_code
    156 #define llc_snap_ether_type llc_un.type_snap.ether_type
    157 
    158 extern u_char	at_org_code[3];
    159 extern u_char	aarp_org_code[3];
    160 #endif /* NETATALK */
    161 
    162 #ifdef MPLS
    163 #include <netmpls/mpls.h>
    164 #include <netmpls/mpls_var.h>
    165 #endif
    166 
    167 #ifdef DIAGNOSTIC
    168 static struct timeval bigpktppslim_last;
    169 static int bigpktppslim = 2;	/* XXX */
    170 static int bigpktpps_count;
    171 static kmutex_t bigpktpps_lock __cacheline_aligned;
    172 #endif
    173 
    174 const uint8_t etherbroadcastaddr[ETHER_ADDR_LEN] =
    175     { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
    176 const uint8_t ethermulticastaddr_slowprotocols[ETHER_ADDR_LEN] =
    177     { 0x01, 0x80, 0xc2, 0x00, 0x00, 0x02 };
    178 #define senderr(e) { error = (e); goto bad;}
    179 
    180 static int ether_output(struct ifnet *, struct mbuf *,
    181     const struct sockaddr *, const struct rtentry *);
    182 
    183 /*
    184  * Ethernet output routine.
    185  * Encapsulate a packet of type family for the local net.
    186  * Assumes that ifp is actually pointer to ethercom structure.
    187  */
    188 static int
    189 ether_output(struct ifnet * const ifp0, struct mbuf * const m0,
    190     const struct sockaddr * const dst, const struct rtentry *rt)
    191 {
    192 	uint8_t esrc[ETHER_ADDR_LEN], edst[ETHER_ADDR_LEN];
    193 	uint16_t etype = 0;
    194 	int error = 0, hdrcmplt = 0;
    195 	struct mbuf *m = m0;
    196 	struct mbuf *mcopy = NULL;
    197 	struct ether_header *eh;
    198 	struct ifnet *ifp = ifp0;
    199 #ifdef INET
    200 	struct arphdr *ah;
    201 #endif
    202 #ifdef NETATALK
    203 	struct at_ifaddr *aa;
    204 #endif
    205 
    206 #ifdef MBUFTRACE
    207 	m_claimm(m, ifp->if_mowner);
    208 #endif
    209 
    210 #if NCARP > 0
    211 	if (ifp->if_type == IFT_CARP) {
    212 		struct ifaddr *ifa;
    213 		int s = pserialize_read_enter();
    214 
    215 		/* loop back if this is going to the carp interface */
    216 		if (dst != NULL && ifp0->if_link_state == LINK_STATE_UP &&
    217 		    (ifa = ifa_ifwithaddr(dst)) != NULL) {
    218 			if (ifa->ifa_ifp == ifp0) {
    219 				pserialize_read_exit(s);
    220 				return looutput(ifp0, m, dst, rt);
    221 			}
    222 		}
    223 		pserialize_read_exit(s);
    224 
    225 		ifp = ifp->if_carpdev;
    226 		/* ac = (struct arpcom *)ifp; */
    227 
    228 		if ((ifp0->if_flags & (IFF_UP | IFF_RUNNING)) !=
    229 		    (IFF_UP | IFF_RUNNING))
    230 			senderr(ENETDOWN);
    231 	}
    232 #endif
    233 
    234 	if ((ifp->if_flags & (IFF_UP | IFF_RUNNING)) != (IFF_UP | IFF_RUNNING))
    235 		senderr(ENETDOWN);
    236 
    237 	switch (dst->sa_family) {
    238 
    239 #ifdef INET
    240 	case AF_INET:
    241 		if (m->m_flags & M_BCAST) {
    242 			memcpy(edst, etherbroadcastaddr, sizeof(edst));
    243 		} else if (m->m_flags & M_MCAST) {
    244 			ETHER_MAP_IP_MULTICAST(&satocsin(dst)->sin_addr, edst);
    245 		} else {
    246 			error = arpresolve(ifp0, rt, m, dst, edst, sizeof(edst));
    247 			if (error)
    248 				return (error == EWOULDBLOCK) ? 0 : error;
    249 		}
    250 		/* If broadcasting on a simplex interface, loopback a copy */
    251 		if ((m->m_flags & M_BCAST) && (ifp->if_flags & IFF_SIMPLEX))
    252 			mcopy = m_copypacket(m, M_DONTWAIT);
    253 		etype = htons(ETHERTYPE_IP);
    254 		break;
    255 
    256 	case AF_ARP:
    257 		ah = mtod(m, struct arphdr *);
    258 		if (m->m_flags & M_BCAST) {
    259 			memcpy(edst, etherbroadcastaddr, sizeof(edst));
    260 		} else {
    261 			void *tha = ar_tha(ah);
    262 
    263 			if (tha == NULL) {
    264 				/* fake with ARPHRD_IEEE1394 */
    265 				m_freem(m);
    266 				return 0;
    267 			}
    268 			memcpy(edst, tha, sizeof(edst));
    269 		}
    270 
    271 		ah->ar_hrd = htons(ARPHRD_ETHER);
    272 
    273 		switch (ntohs(ah->ar_op)) {
    274 		case ARPOP_REVREQUEST:
    275 		case ARPOP_REVREPLY:
    276 			etype = htons(ETHERTYPE_REVARP);
    277 			break;
    278 
    279 		case ARPOP_REQUEST:
    280 		case ARPOP_REPLY:
    281 		default:
    282 			etype = htons(ETHERTYPE_ARP);
    283 		}
    284 		break;
    285 #endif
    286 
    287 #ifdef INET6
    288 	case AF_INET6:
    289 		if (m->m_flags & M_BCAST) {
    290 			memcpy(edst, etherbroadcastaddr, sizeof(edst));
    291 		} else if (m->m_flags & M_MCAST) {
    292 			ETHER_MAP_IPV6_MULTICAST(&satocsin6(dst)->sin6_addr,
    293 			    edst);
    294 		} else {
    295 			error = nd6_resolve(ifp0, rt, m, dst, edst,
    296 			    sizeof(edst));
    297 			if (error)
    298 				return (error == EWOULDBLOCK) ? 0 : error;
    299 		}
    300 		etype = htons(ETHERTYPE_IPV6);
    301 		break;
    302 #endif
    303 
    304 #ifdef NETATALK
    305 	case AF_APPLETALK: {
    306 		struct ifaddr *ifa;
    307 		int s;
    308 
    309 		KERNEL_LOCK(1, NULL);
    310 
    311 		if (!aarpresolve(ifp, m, (const struct sockaddr_at *)dst, edst)) {
    312 			KERNEL_UNLOCK_ONE(NULL);
    313 			return 0;
    314 		}
    315 
    316 		/*
    317 		 * ifaddr is the first thing in at_ifaddr
    318 		 */
    319 		s = pserialize_read_enter();
    320 		ifa = at_ifawithnet((const struct sockaddr_at *)dst, ifp);
    321 		if (ifa == NULL) {
    322 			pserialize_read_exit(s);
    323 			KERNEL_UNLOCK_ONE(NULL);
    324 			senderr(EADDRNOTAVAIL);
    325 		}
    326 		aa = (struct at_ifaddr *)ifa;
    327 
    328 		/*
    329 		 * In the phase 2 case, we need to prepend an mbuf for the
    330 		 * llc header.
    331 		 */
    332 		if (aa->aa_flags & AFA_PHASE2) {
    333 			struct llc llc;
    334 
    335 			M_PREPEND(m, sizeof(struct llc), M_DONTWAIT);
    336 			if (m == NULL) {
    337 				pserialize_read_exit(s);
    338 				KERNEL_UNLOCK_ONE(NULL);
    339 				senderr(ENOBUFS);
    340 			}
    341 
    342 			llc.llc_dsap = llc.llc_ssap = LLC_SNAP_LSAP;
    343 			llc.llc_control = LLC_UI;
    344 			memcpy(llc.llc_snap_org_code, at_org_code,
    345 			    sizeof(llc.llc_snap_org_code));
    346 			llc.llc_snap_ether_type = htons(ETHERTYPE_ATALK);
    347 			memcpy(mtod(m, void *), &llc, sizeof(struct llc));
    348 		} else {
    349 			etype = htons(ETHERTYPE_ATALK);
    350 		}
    351 		pserialize_read_exit(s);
    352 		KERNEL_UNLOCK_ONE(NULL);
    353 		break;
    354 	}
    355 #endif /* NETATALK */
    356 
    357 	case pseudo_AF_HDRCMPLT:
    358 		hdrcmplt = 1;
    359 		memcpy(esrc,
    360 		    ((const struct ether_header *)dst->sa_data)->ether_shost,
    361 		    sizeof(esrc));
    362 		/* FALLTHROUGH */
    363 
    364 	case AF_UNSPEC:
    365 		memcpy(edst,
    366 		    ((const struct ether_header *)dst->sa_data)->ether_dhost,
    367 		    sizeof(edst));
    368 		/* AF_UNSPEC doesn't swap the byte order of the ether_type. */
    369 		etype = ((const struct ether_header *)dst->sa_data)->ether_type;
    370 		break;
    371 
    372 	default:
    373 		printf("%s: can't handle af%d\n", ifp->if_xname,
    374 		    dst->sa_family);
    375 		senderr(EAFNOSUPPORT);
    376 	}
    377 
    378 #ifdef MPLS
    379 	{
    380 		struct m_tag *mtag;
    381 		mtag = m_tag_find(m, PACKET_TAG_MPLS);
    382 		if (mtag != NULL) {
    383 			/* Having the tag itself indicates it's MPLS */
    384 			etype = htons(ETHERTYPE_MPLS);
    385 			m_tag_delete(m, mtag);
    386 		}
    387 	}
    388 #endif
    389 
    390 	if (mcopy)
    391 		(void)looutput(ifp, mcopy, dst, rt);
    392 
    393 	KASSERT((m->m_flags & M_PKTHDR) != 0);
    394 
    395 	/*
    396 	 * If no ether type is set, this must be a 802.2 formatted packet.
    397 	 */
    398 	if (etype == 0)
    399 		etype = htons(m->m_pkthdr.len);
    400 
    401 	/*
    402 	 * Add local net header. If no space in first mbuf, allocate another.
    403 	 */
    404 	M_PREPEND(m, sizeof(struct ether_header), M_DONTWAIT);
    405 	if (m == NULL)
    406 		senderr(ENOBUFS);
    407 
    408 	eh = mtod(m, struct ether_header *);
    409 	/* Note: etype is already in network byte order. */
    410 	memcpy(&eh->ether_type, &etype, sizeof(eh->ether_type));
    411 	memcpy(eh->ether_dhost, edst, sizeof(edst));
    412 	if (hdrcmplt) {
    413 		memcpy(eh->ether_shost, esrc, sizeof(eh->ether_shost));
    414 	} else {
    415 	 	memcpy(eh->ether_shost, CLLADDR(ifp->if_sadl),
    416 		    sizeof(eh->ether_shost));
    417 	}
    418 
    419 #if NCARP > 0
    420 	if (ifp0 != ifp && ifp0->if_type == IFT_CARP) {
    421 	 	memcpy(eh->ether_shost, CLLADDR(ifp0->if_sadl),
    422 		    sizeof(eh->ether_shost));
    423 	}
    424 #endif
    425 
    426 	if ((error = pfil_run_hooks(ifp->if_pfil, &m, ifp, PFIL_OUT)) != 0)
    427 		return error;
    428 	if (m == NULL)
    429 		return 0;
    430 
    431 #if NBRIDGE > 0
    432 	/*
    433 	 * Bridges require special output handling.
    434 	 */
    435 	if (ifp->if_bridge)
    436 		return bridge_output(ifp, m, NULL, NULL);
    437 #endif
    438 
    439 #if NCARP > 0
    440 	if (ifp != ifp0)
    441 		if_statadd(ifp0, if_obytes, m->m_pkthdr.len + ETHER_HDR_LEN);
    442 #endif
    443 
    444 #ifdef ALTQ
    445 	KERNEL_LOCK(1, NULL);
    446 	/*
    447 	 * If ALTQ is enabled on the parent interface, do
    448 	 * classification; the queueing discipline might not
    449 	 * require classification, but might require the
    450 	 * address family/header pointer in the pktattr.
    451 	 */
    452 	if (ALTQ_IS_ENABLED(&ifp->if_snd))
    453 		altq_etherclassify(&ifp->if_snd, m);
    454 	KERNEL_UNLOCK_ONE(NULL);
    455 #endif
    456 	return ifq_enqueue(ifp, m);
    457 
    458 bad:
    459 	if (m)
    460 		m_freem(m);
    461 	return error;
    462 }
    463 
    464 #ifdef ALTQ
    465 /*
    466  * This routine is a slight hack to allow a packet to be classified
    467  * if the Ethernet headers are present.  It will go away when ALTQ's
    468  * classification engine understands link headers.
    469  *
    470  * XXX: We may need to do m_pullups here. First to ensure struct ether_header
    471  * is indeed contiguous, then to read the LLC and so on.
    472  */
    473 void
    474 altq_etherclassify(struct ifaltq *ifq, struct mbuf *m)
    475 {
    476 	struct ether_header *eh;
    477 	struct mbuf *mtop = m;
    478 	uint16_t ether_type;
    479 	int hlen, af, hdrsize;
    480 	void *hdr;
    481 
    482 	KASSERT((mtop->m_flags & M_PKTHDR) != 0);
    483 
    484 	hlen = ETHER_HDR_LEN;
    485 	eh = mtod(m, struct ether_header *);
    486 
    487 	ether_type = htons(eh->ether_type);
    488 
    489 	if (ether_type < ETHERMTU) {
    490 		/* LLC/SNAP */
    491 		struct llc *llc = (struct llc *)(eh + 1);
    492 		hlen += 8;
    493 
    494 		if (m->m_len < hlen ||
    495 		    llc->llc_dsap != LLC_SNAP_LSAP ||
    496 		    llc->llc_ssap != LLC_SNAP_LSAP ||
    497 		    llc->llc_control != LLC_UI) {
    498 			/* Not SNAP. */
    499 			goto bad;
    500 		}
    501 
    502 		ether_type = htons(llc->llc_un.type_snap.ether_type);
    503 	}
    504 
    505 	switch (ether_type) {
    506 	case ETHERTYPE_IP:
    507 		af = AF_INET;
    508 		hdrsize = 20;		/* sizeof(struct ip) */
    509 		break;
    510 
    511 	case ETHERTYPE_IPV6:
    512 		af = AF_INET6;
    513 		hdrsize = 40;		/* sizeof(struct ip6_hdr) */
    514 		break;
    515 
    516 	default:
    517 		af = AF_UNSPEC;
    518 		hdrsize = 0;
    519 		break;
    520 	}
    521 
    522 	while (m->m_len <= hlen) {
    523 		hlen -= m->m_len;
    524 		m = m->m_next;
    525 		if (m == NULL)
    526 			goto bad;
    527 	}
    528 
    529 	if (m->m_len < (hlen + hdrsize)) {
    530 		/*
    531 		 * protocol header not in a single mbuf.
    532 		 * We can't cope with this situation right
    533 		 * now (but it shouldn't ever happen, really, anyhow).
    534 		 */
    535 #ifdef DEBUG
    536 		printf("altq_etherclassify: headers span multiple mbufs: "
    537 		    "%d < %d\n", m->m_len, (hlen + hdrsize));
    538 #endif
    539 		goto bad;
    540 	}
    541 
    542 	m->m_data += hlen;
    543 	m->m_len -= hlen;
    544 
    545 	hdr = mtod(m, void *);
    546 
    547 	if (ALTQ_NEEDS_CLASSIFY(ifq)) {
    548 		mtop->m_pkthdr.pattr_class =
    549 		    (*ifq->altq_classify)(ifq->altq_clfier, m, af);
    550 	}
    551 	mtop->m_pkthdr.pattr_af = af;
    552 	mtop->m_pkthdr.pattr_hdr = hdr;
    553 
    554 	m->m_data -= hlen;
    555 	m->m_len += hlen;
    556 
    557 	return;
    558 
    559 bad:
    560 	mtop->m_pkthdr.pattr_class = NULL;
    561 	mtop->m_pkthdr.pattr_hdr = NULL;
    562 	mtop->m_pkthdr.pattr_af = AF_UNSPEC;
    563 }
    564 #endif /* ALTQ */
    565 
    566 #if defined (LLC) || defined (NETATALK)
    567 static void
    568 ether_input_llc(struct ifnet *ifp, struct mbuf *m, struct ether_header *eh)
    569 {
    570 	struct ifqueue *inq = NULL;
    571 	int isr = 0;
    572 	struct llc *l;
    573 
    574 	if (m->m_len < sizeof(*eh) + sizeof(struct llc))
    575 		goto drop;
    576 
    577 	l = (struct llc *)(eh+1);
    578 	switch (l->llc_dsap) {
    579 #ifdef NETATALK
    580 	case LLC_SNAP_LSAP:
    581 		switch (l->llc_control) {
    582 		case LLC_UI:
    583 			if (l->llc_ssap != LLC_SNAP_LSAP)
    584 				goto drop;
    585 
    586 			if (memcmp(&(l->llc_snap_org_code)[0],
    587 			    at_org_code, sizeof(at_org_code)) == 0 &&
    588 			    ntohs(l->llc_snap_ether_type) ==
    589 			    ETHERTYPE_ATALK) {
    590 				inq = &atintrq2;
    591 				m_adj(m, sizeof(struct ether_header)
    592 				    + sizeof(struct llc));
    593 				isr = NETISR_ATALK;
    594 				break;
    595 			}
    596 
    597 			if (memcmp(&(l->llc_snap_org_code)[0],
    598 			    aarp_org_code,
    599 			    sizeof(aarp_org_code)) == 0 &&
    600 			    ntohs(l->llc_snap_ether_type) ==
    601 			    ETHERTYPE_AARP) {
    602 				m_adj(m, sizeof(struct ether_header)
    603 				    + sizeof(struct llc));
    604 				aarpinput(ifp, m); /* XXX queue? */
    605 				return;
    606 			}
    607 
    608 		default:
    609 			goto drop;
    610 		}
    611 		break;
    612 #endif
    613 	default:
    614 		goto drop;
    615 	}
    616 
    617 	KASSERT(inq != NULL);
    618 	IFQ_ENQUEUE_ISR(inq, m, isr);
    619 	return;
    620 
    621 drop:
    622 	m_freem(m);
    623 	if_statinc(ifp, if_ierrors); /* XXX should have a dedicated counter? */
    624 	return;
    625 }
    626 #endif /* defined (LLC) || defined (NETATALK) */
    627 
    628 /*
    629  * Process a received Ethernet packet;
    630  * the packet is in the mbuf chain m with
    631  * the ether header.
    632  */
    633 void
    634 ether_input(struct ifnet *ifp, struct mbuf *m)
    635 {
    636 	struct ethercom *ec = (struct ethercom *) ifp;
    637 	pktqueue_t *pktq = NULL;
    638 	struct ifqueue *inq = NULL;
    639 	uint16_t etype;
    640 	struct ether_header *eh;
    641 	size_t ehlen;
    642 	static int earlypkts;
    643 	int isr = 0;
    644 
    645 	KASSERT(!cpu_intr_p());
    646 	KASSERT((m->m_flags & M_PKTHDR) != 0);
    647 
    648 	if ((ifp->if_flags & IFF_UP) == 0)
    649 		goto drop;
    650 	if (m->m_len < sizeof(*eh)) {
    651 		m = m_pullup(m, sizeof(*eh));
    652 		if (m == NULL)
    653 			goto dropped;
    654 	}
    655 
    656 #ifdef MBUFTRACE
    657 	m_claimm(m, &ec->ec_rx_mowner);
    658 #endif
    659 	eh = mtod(m, struct ether_header *);
    660 	etype = ntohs(eh->ether_type);
    661 	ehlen = sizeof(*eh);
    662 
    663 	if (__predict_false(earlypkts < 100 ||
    664 		entropy_epoch() == (unsigned)-1)) {
    665 		rnd_add_data(NULL, eh, ehlen, 0);
    666 		earlypkts++;
    667 	}
    668 
    669 	/*
    670 	 * Determine if the packet is within its size limits. For MPLS the
    671 	 * header length is variable, so we skip the check.
    672 	 */
    673 	if (etype != ETHERTYPE_MPLS && m->m_pkthdr.len >
    674 	    ETHER_MAX_FRAME(ifp, etype, m->m_flags & M_HASFCS)) {
    675 #ifdef DIAGNOSTIC
    676 		mutex_enter(&bigpktpps_lock);
    677 		if (ppsratecheck(&bigpktppslim_last, &bigpktpps_count,
    678 		    bigpktppslim)) {
    679 			printf("%s: discarding oversize frame (len=%d)\n",
    680 			    ifp->if_xname, m->m_pkthdr.len);
    681 		}
    682 		mutex_exit(&bigpktpps_lock);
    683 #endif
    684 		goto drop;
    685 	}
    686 
    687 	if (ETHER_IS_MULTICAST(eh->ether_dhost)) {
    688 		/*
    689 		 * If this is not a simplex interface, drop the packet
    690 		 * if it came from us.
    691 		 */
    692 		if ((ifp->if_flags & IFF_SIMPLEX) == 0 &&
    693 		    memcmp(CLLADDR(ifp->if_sadl), eh->ether_shost,
    694 		    ETHER_ADDR_LEN) == 0) {
    695 			goto drop;
    696 		}
    697 
    698 		if (memcmp(etherbroadcastaddr,
    699 		    eh->ether_dhost, ETHER_ADDR_LEN) == 0)
    700 			m->m_flags |= M_BCAST;
    701 		else
    702 			m->m_flags |= M_MCAST;
    703 		if_statinc(ifp, if_imcasts);
    704 	}
    705 
    706 	/* If the CRC is still on the packet, trim it off. */
    707 	if (m->m_flags & M_HASFCS) {
    708 		m_adj(m, -ETHER_CRC_LEN);
    709 		m->m_flags &= ~M_HASFCS;
    710 	}
    711 
    712 	if_statadd(ifp, if_ibytes, m->m_pkthdr.len);
    713 
    714 #if NCARP > 0
    715 	if (__predict_false(ifp->if_carp && ifp->if_type != IFT_CARP)) {
    716 		/*
    717 		 * Clear M_PROMISC, in case the packet comes from a
    718 		 * vlan.
    719 		 */
    720 		m->m_flags &= ~M_PROMISC;
    721 		if (carp_input(m, (uint8_t *)&eh->ether_shost,
    722 		    (uint8_t *)&eh->ether_dhost, eh->ether_type) == 0)
    723 			return;
    724 	}
    725 #endif
    726 
    727 	if ((m->m_flags & (M_BCAST | M_MCAST | M_PROMISC)) == 0 &&
    728 	    (ifp->if_flags & IFF_PROMISC) != 0 &&
    729 	    memcmp(CLLADDR(ifp->if_sadl), eh->ether_dhost,
    730 	     ETHER_ADDR_LEN) != 0) {
    731 		m->m_flags |= M_PROMISC;
    732 	}
    733 
    734 	if ((m->m_flags & M_PROMISC) == 0) {
    735 		if (pfil_run_hooks(ifp->if_pfil, &m, ifp, PFIL_IN) != 0)
    736 			return;
    737 		if (m == NULL)
    738 			return;
    739 
    740 		eh = mtod(m, struct ether_header *);
    741 		etype = ntohs(eh->ether_type);
    742 	}
    743 
    744 #if NAGR > 0
    745 	if (ifp->if_agrprivate &&
    746 	    __predict_true(etype != ETHERTYPE_SLOWPROTOCOLS)) {
    747 		m->m_flags &= ~M_PROMISC;
    748 		agr_input(ifp, m);
    749 		return;
    750 	}
    751 #endif
    752 
    753 	/*
    754 	 * If VLANs are configured on the interface, check to
    755 	 * see if the device performed the decapsulation and
    756 	 * provided us with the tag.
    757 	 */
    758 	if (ec->ec_nvlans && vlan_has_tag(m)) {
    759 #if NVLAN > 0
    760 		/*
    761 		 * vlan_input() will either recursively call ether_input()
    762 		 * or drop the packet.
    763 		 */
    764 		vlan_input(ifp, m);
    765 		return;
    766 #else
    767 		goto drop;
    768 #endif
    769 	}
    770 
    771 	/*
    772 	 * Handle protocols that expect to have the Ethernet header
    773 	 * (and possibly FCS) intact.
    774 	 */
    775 	switch (etype) {
    776 	case ETHERTYPE_VLAN: {
    777 		struct ether_vlan_header *evl = (void *)eh;
    778 
    779 		/*
    780 		 * If there is a tag of 0, then the VLAN header was probably
    781 		 * just being used to store the priority.  Extract the ether
    782 		 * type, and if IP or IPV6, let them deal with it.
    783 		 */
    784 		if (m->m_len >= sizeof(*evl) &&
    785 		    EVL_VLANOFTAG(evl->evl_tag) == 0) {
    786 			etype = ntohs(evl->evl_proto);
    787 			ehlen = sizeof(*evl);
    788 			if ((m->m_flags & M_PROMISC) == 0 &&
    789 			    (etype == ETHERTYPE_IP ||
    790 			     etype == ETHERTYPE_IPV6))
    791 				break;
    792 		}
    793 
    794 #if NVLAN > 0
    795 		/*
    796 		 * vlan_input() will either recursively call ether_input()
    797 		 * or drop the packet.
    798 		 */
    799 		if (ec->ec_nvlans != 0) {
    800 			vlan_input(ifp, m);
    801 			return;
    802 		} else
    803 #endif
    804 			goto drop;
    805 	}
    806 
    807 #if NPPPOE > 0
    808 	case ETHERTYPE_PPPOEDISC:
    809 		pppoedisc_input(ifp, m);
    810 		return;
    811 
    812 	case ETHERTYPE_PPPOE:
    813 		pppoe_input(ifp, m);
    814 		return;
    815 #endif
    816 
    817 	case ETHERTYPE_SLOWPROTOCOLS: {
    818 		uint8_t subtype;
    819 
    820 		if (m->m_pkthdr.len < sizeof(*eh) + sizeof(subtype))
    821 			goto drop;
    822 
    823 		m_copydata(m, sizeof(*eh), sizeof(subtype), &subtype);
    824 		switch (subtype) {
    825 #if NAGR > 0
    826 		case SLOWPROTOCOLS_SUBTYPE_LACP:
    827 			if (ifp->if_agrprivate) {
    828 				ieee8023ad_lacp_input(ifp, m);
    829 				return;
    830 			}
    831 			break;
    832 
    833 		case SLOWPROTOCOLS_SUBTYPE_MARKER:
    834 			if (ifp->if_agrprivate) {
    835 				ieee8023ad_marker_input(ifp, m);
    836 				return;
    837 			}
    838 			break;
    839 #endif
    840 
    841 		default:
    842 			if (subtype == 0 || subtype > 10) {
    843 				/* illegal value */
    844 				goto drop;
    845 			}
    846 			/* unknown subtype */
    847 			break;
    848 		}
    849 	}
    850 	/* FALLTHROUGH */
    851 	default:
    852 		if (m->m_flags & M_PROMISC)
    853 			goto drop;
    854 	}
    855 
    856 	/* If the CRC is still on the packet, trim it off. */
    857 	if (m->m_flags & M_HASFCS) {
    858 		m_adj(m, -ETHER_CRC_LEN);
    859 		m->m_flags &= ~M_HASFCS;
    860 	}
    861 
    862 	/* etype represents the size of the payload in this case */
    863 	if (etype <= ETHERMTU + sizeof(struct ether_header)) {
    864 		KASSERT(ehlen == sizeof(*eh));
    865 #if defined (LLC) || defined (NETATALK)
    866 		ether_input_llc(ifp, m, eh);
    867 		return;
    868 #else
    869 		goto drop;
    870 #endif
    871 	}
    872 
    873 	/* Strip off the Ethernet header. */
    874 	m_adj(m, ehlen);
    875 
    876 	switch (etype) {
    877 #ifdef INET
    878 	case ETHERTYPE_IP:
    879 #ifdef GATEWAY
    880 		if (ipflow_fastforward(m))
    881 			return;
    882 #endif
    883 		pktq = ip_pktq;
    884 		break;
    885 
    886 	case ETHERTYPE_ARP:
    887 		isr = NETISR_ARP;
    888 		inq = &arpintrq;
    889 		break;
    890 
    891 	case ETHERTYPE_REVARP:
    892 		revarpinput(m);	/* XXX queue? */
    893 		return;
    894 #endif
    895 
    896 #ifdef INET6
    897 	case ETHERTYPE_IPV6:
    898 		if (__predict_false(!in6_present))
    899 			goto drop;
    900 #ifdef GATEWAY
    901 		if (ip6flow_fastforward(&m))
    902 			return;
    903 #endif
    904 		pktq = ip6_pktq;
    905 		break;
    906 #endif
    907 
    908 #ifdef NETATALK
    909 	case ETHERTYPE_ATALK:
    910 		isr = NETISR_ATALK;
    911 		inq = &atintrq1;
    912 		break;
    913 
    914 	case ETHERTYPE_AARP:
    915 		aarpinput(ifp, m); /* XXX queue? */
    916 		return;
    917 #endif
    918 
    919 #ifdef MPLS
    920 	case ETHERTYPE_MPLS:
    921 		isr = NETISR_MPLS;
    922 		inq = &mplsintrq;
    923 		break;
    924 #endif
    925 
    926 	default:
    927 		goto drop;
    928 	}
    929 
    930 	if (__predict_true(pktq)) {
    931 #ifdef NET_MPSAFE
    932 		const u_int h = curcpu()->ci_index;
    933 #else
    934 		const uint32_t h = pktq_rps_hash(m);
    935 #endif
    936 		if (__predict_false(!pktq_enqueue(pktq, m, h))) {
    937 			m_freem(m);
    938 		}
    939 		return;
    940 	}
    941 
    942 	if (__predict_false(!inq)) {
    943 		/* Should not happen. */
    944 		goto drop;
    945 	}
    946 
    947 	IFQ_ENQUEUE_ISR(inq, m, isr);
    948 	return;
    949 
    950 drop:
    951 	m_freem(m);
    952 dropped:
    953 	if_statinc(ifp, if_ierrors); /* XXX should have a dedicated counter? */
    954 }
    955 
    956 /*
    957  * Convert Ethernet address to printable (loggable) representation.
    958  */
    959 char *
    960 ether_sprintf(const u_char *ap)
    961 {
    962 	static char etherbuf[3 * ETHER_ADDR_LEN];
    963 	return ether_snprintf(etherbuf, sizeof(etherbuf), ap);
    964 }
    965 
    966 char *
    967 ether_snprintf(char *buf, size_t len, const u_char *ap)
    968 {
    969 	char *cp = buf;
    970 	size_t i;
    971 
    972 	for (i = 0; i < len / 3; i++) {
    973 		*cp++ = hexdigits[*ap >> 4];
    974 		*cp++ = hexdigits[*ap++ & 0xf];
    975 		*cp++ = ':';
    976 	}
    977 	*--cp = '\0';
    978 	return buf;
    979 }
    980 
    981 /*
    982  * Perform common duties while attaching to interface list
    983  */
    984 void
    985 ether_ifattach(struct ifnet *ifp, const uint8_t *lla)
    986 {
    987 	struct ethercom *ec = (struct ethercom *)ifp;
    988 
    989 	ifp->if_type = IFT_ETHER;
    990 	ifp->if_hdrlen = ETHER_HDR_LEN;
    991 	ifp->if_dlt = DLT_EN10MB;
    992 	ifp->if_mtu = ETHERMTU;
    993 	ifp->if_output = ether_output;
    994 	ifp->_if_input = ether_input;
    995 	if (ifp->if_baudrate == 0)
    996 		ifp->if_baudrate = IF_Mbps(10);		/* just a default */
    997 
    998 	if (lla != NULL)
    999 		if_set_sadl(ifp, lla, ETHER_ADDR_LEN, !ETHER_IS_LOCAL(lla));
   1000 
   1001 	LIST_INIT(&ec->ec_multiaddrs);
   1002 	SIMPLEQ_INIT(&ec->ec_vids);
   1003 	ec->ec_lock = mutex_obj_alloc(MUTEX_DEFAULT, IPL_NET);
   1004 	ec->ec_flags = 0;
   1005 	ifp->if_broadcastaddr = etherbroadcastaddr;
   1006 	bpf_attach(ifp, DLT_EN10MB, sizeof(struct ether_header));
   1007 #ifdef MBUFTRACE
   1008 	mowner_init_owner(&ec->ec_tx_mowner, ifp->if_xname, "tx");
   1009 	mowner_init_owner(&ec->ec_rx_mowner, ifp->if_xname, "rx");
   1010 	MOWNER_ATTACH(&ec->ec_tx_mowner);
   1011 	MOWNER_ATTACH(&ec->ec_rx_mowner);
   1012 	ifp->if_mowner = &ec->ec_tx_mowner;
   1013 #endif
   1014 }
   1015 
   1016 void
   1017 ether_ifdetach(struct ifnet *ifp)
   1018 {
   1019 	struct ethercom *ec = (void *) ifp;
   1020 	struct ether_multi *enm;
   1021 
   1022 	IFNET_ASSERT_UNLOCKED(ifp);
   1023 	/*
   1024 	 * Prevent further calls to ioctl (for example turning off
   1025 	 * promiscuous mode from the bridge code), which eventually can
   1026 	 * call if_init() which can cause panics because the interface
   1027 	 * is in the process of being detached. Return device not configured
   1028 	 * instead.
   1029 	 */
   1030 	ifp->if_ioctl = __FPTRCAST(int (*)(struct ifnet *, u_long, void *),
   1031 	    enxio);
   1032 
   1033 #if NBRIDGE > 0
   1034 	if (ifp->if_bridge)
   1035 		bridge_ifdetach(ifp);
   1036 #endif
   1037 	bpf_detach(ifp);
   1038 #if NVLAN > 0
   1039 	if (ec->ec_nvlans)
   1040 		vlan_ifdetach(ifp);
   1041 #endif
   1042 
   1043 	ETHER_LOCK(ec);
   1044 	KASSERT(ec->ec_nvlans == 0);
   1045 	while ((enm = LIST_FIRST(&ec->ec_multiaddrs)) != NULL) {
   1046 		LIST_REMOVE(enm, enm_list);
   1047 		kmem_free(enm, sizeof(*enm));
   1048 		ec->ec_multicnt--;
   1049 	}
   1050 	ETHER_UNLOCK(ec);
   1051 
   1052 	mutex_obj_free(ec->ec_lock);
   1053 	ec->ec_lock = NULL;
   1054 
   1055 	ifp->if_mowner = NULL;
   1056 	MOWNER_DETACH(&ec->ec_rx_mowner);
   1057 	MOWNER_DETACH(&ec->ec_tx_mowner);
   1058 }
   1059 
   1060 #if 0
   1061 /*
   1062  * This is for reference.  We have a table-driven version
   1063  * of the little-endian crc32 generator, which is faster
   1064  * than the double-loop.
   1065  */
   1066 uint32_t
   1067 ether_crc32_le(const uint8_t *buf, size_t len)
   1068 {
   1069 	uint32_t c, crc, carry;
   1070 	size_t i, j;
   1071 
   1072 	crc = 0xffffffffU;	/* initial value */
   1073 
   1074 	for (i = 0; i < len; i++) {
   1075 		c = buf[i];
   1076 		for (j = 0; j < 8; j++) {
   1077 			carry = ((crc & 0x01) ? 1 : 0) ^ (c & 0x01);
   1078 			crc >>= 1;
   1079 			c >>= 1;
   1080 			if (carry)
   1081 				crc = (crc ^ ETHER_CRC_POLY_LE);
   1082 		}
   1083 	}
   1084 
   1085 	return (crc);
   1086 }
   1087 #else
   1088 uint32_t
   1089 ether_crc32_le(const uint8_t *buf, size_t len)
   1090 {
   1091 	static const uint32_t crctab[] = {
   1092 		0x00000000, 0x1db71064, 0x3b6e20c8, 0x26d930ac,
   1093 		0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c,
   1094 		0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c,
   1095 		0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c
   1096 	};
   1097 	uint32_t crc;
   1098 	size_t i;
   1099 
   1100 	crc = 0xffffffffU;	/* initial value */
   1101 
   1102 	for (i = 0; i < len; i++) {
   1103 		crc ^= buf[i];
   1104 		crc = (crc >> 4) ^ crctab[crc & 0xf];
   1105 		crc = (crc >> 4) ^ crctab[crc & 0xf];
   1106 	}
   1107 
   1108 	return (crc);
   1109 }
   1110 #endif
   1111 
   1112 uint32_t
   1113 ether_crc32_be(const uint8_t *buf, size_t len)
   1114 {
   1115 	uint32_t c, crc, carry;
   1116 	size_t i, j;
   1117 
   1118 	crc = 0xffffffffU;	/* initial value */
   1119 
   1120 	for (i = 0; i < len; i++) {
   1121 		c = buf[i];
   1122 		for (j = 0; j < 8; j++) {
   1123 			carry = ((crc & 0x80000000U) ? 1 : 0) ^ (c & 0x01);
   1124 			crc <<= 1;
   1125 			c >>= 1;
   1126 			if (carry)
   1127 				crc = (crc ^ ETHER_CRC_POLY_BE) | carry;
   1128 		}
   1129 	}
   1130 
   1131 	return (crc);
   1132 }
   1133 
   1134 #ifdef INET
   1135 const uint8_t ether_ipmulticast_min[ETHER_ADDR_LEN] =
   1136     { 0x01, 0x00, 0x5e, 0x00, 0x00, 0x00 };
   1137 const uint8_t ether_ipmulticast_max[ETHER_ADDR_LEN] =
   1138     { 0x01, 0x00, 0x5e, 0x7f, 0xff, 0xff };
   1139 #endif
   1140 #ifdef INET6
   1141 const uint8_t ether_ip6multicast_min[ETHER_ADDR_LEN] =
   1142     { 0x33, 0x33, 0x00, 0x00, 0x00, 0x00 };
   1143 const uint8_t ether_ip6multicast_max[ETHER_ADDR_LEN] =
   1144     { 0x33, 0x33, 0xff, 0xff, 0xff, 0xff };
   1145 #endif
   1146 
   1147 /*
   1148  * ether_aton implementation, not using a static buffer.
   1149  */
   1150 int
   1151 ether_aton_r(u_char *dest, size_t len, const char *str)
   1152 {
   1153 	const u_char *cp = (const void *)str;
   1154 	u_char *ep;
   1155 
   1156 #define atox(c)	(((c) <= '9') ? ((c) - '0') : ((toupper(c) - 'A') + 10))
   1157 
   1158 	if (len < ETHER_ADDR_LEN)
   1159 		return ENOSPC;
   1160 
   1161 	ep = dest + ETHER_ADDR_LEN;
   1162 
   1163 	while (*cp) {
   1164 		if (!isxdigit(*cp))
   1165 			return EINVAL;
   1166 
   1167 		*dest = atox(*cp);
   1168 		cp++;
   1169 		if (isxdigit(*cp)) {
   1170 			*dest = (*dest << 4) | atox(*cp);
   1171 			cp++;
   1172 		}
   1173 		dest++;
   1174 
   1175 		if (dest == ep)
   1176 			return (*cp == '\0') ? 0 : ENAMETOOLONG;
   1177 
   1178 		switch (*cp) {
   1179 		case ':':
   1180 		case '-':
   1181 		case '.':
   1182 			cp++;
   1183 			break;
   1184 		}
   1185 	}
   1186 	return ENOBUFS;
   1187 }
   1188 
   1189 /*
   1190  * Convert a sockaddr into an Ethernet address or range of Ethernet
   1191  * addresses.
   1192  */
   1193 int
   1194 ether_multiaddr(const struct sockaddr *sa, uint8_t addrlo[ETHER_ADDR_LEN],
   1195     uint8_t addrhi[ETHER_ADDR_LEN])
   1196 {
   1197 #ifdef INET
   1198 	const struct sockaddr_in *sin;
   1199 #endif
   1200 #ifdef INET6
   1201 	const struct sockaddr_in6 *sin6;
   1202 #endif
   1203 
   1204 	switch (sa->sa_family) {
   1205 
   1206 	case AF_UNSPEC:
   1207 		memcpy(addrlo, sa->sa_data, ETHER_ADDR_LEN);
   1208 		memcpy(addrhi, addrlo, ETHER_ADDR_LEN);
   1209 		break;
   1210 
   1211 #ifdef INET
   1212 	case AF_INET:
   1213 		sin = satocsin(sa);
   1214 		if (sin->sin_addr.s_addr == INADDR_ANY) {
   1215 			/*
   1216 			 * An IP address of INADDR_ANY means listen to
   1217 			 * or stop listening to all of the Ethernet
   1218 			 * multicast addresses used for IP.
   1219 			 * (This is for the sake of IP multicast routers.)
   1220 			 */
   1221 			memcpy(addrlo, ether_ipmulticast_min, ETHER_ADDR_LEN);
   1222 			memcpy(addrhi, ether_ipmulticast_max, ETHER_ADDR_LEN);
   1223 		} else {
   1224 			ETHER_MAP_IP_MULTICAST(&sin->sin_addr, addrlo);
   1225 			memcpy(addrhi, addrlo, ETHER_ADDR_LEN);
   1226 		}
   1227 		break;
   1228 #endif
   1229 #ifdef INET6
   1230 	case AF_INET6:
   1231 		sin6 = satocsin6(sa);
   1232 		if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
   1233 			/*
   1234 			 * An IP6 address of 0 means listen to or stop
   1235 			 * listening to all of the Ethernet multicast
   1236 			 * address used for IP6.
   1237 			 * (This is used for multicast routers.)
   1238 			 */
   1239 			memcpy(addrlo, ether_ip6multicast_min, ETHER_ADDR_LEN);
   1240 			memcpy(addrhi, ether_ip6multicast_max, ETHER_ADDR_LEN);
   1241 		} else {
   1242 			ETHER_MAP_IPV6_MULTICAST(&sin6->sin6_addr, addrlo);
   1243 			memcpy(addrhi, addrlo, ETHER_ADDR_LEN);
   1244 		}
   1245 		break;
   1246 #endif
   1247 
   1248 	default:
   1249 		return EAFNOSUPPORT;
   1250 	}
   1251 	return 0;
   1252 }
   1253 
   1254 /*
   1255  * Add an Ethernet multicast address or range of addresses to the list for a
   1256  * given interface.
   1257  */
   1258 int
   1259 ether_addmulti(const struct sockaddr *sa, struct ethercom *ec)
   1260 {
   1261 	struct ether_multi *enm, *_enm;
   1262 	u_char addrlo[ETHER_ADDR_LEN];
   1263 	u_char addrhi[ETHER_ADDR_LEN];
   1264 	int error = 0;
   1265 
   1266 	/* Allocate out of lock */
   1267 	enm = kmem_alloc(sizeof(*enm), KM_SLEEP);
   1268 
   1269 	ETHER_LOCK(ec);
   1270 	error = ether_multiaddr(sa, addrlo, addrhi);
   1271 	if (error != 0)
   1272 		goto out;
   1273 
   1274 	/*
   1275 	 * Verify that we have valid Ethernet multicast addresses.
   1276 	 */
   1277 	if (!ETHER_IS_MULTICAST(addrlo) || !ETHER_IS_MULTICAST(addrhi)) {
   1278 		error = EINVAL;
   1279 		goto out;
   1280 	}
   1281 
   1282 	/*
   1283 	 * See if the address range is already in the list.
   1284 	 */
   1285 	_enm = ether_lookup_multi(addrlo, addrhi, ec);
   1286 	if (_enm != NULL) {
   1287 		/*
   1288 		 * Found it; just increment the reference count.
   1289 		 */
   1290 		++_enm->enm_refcount;
   1291 		error = 0;
   1292 		goto out;
   1293 	}
   1294 
   1295 	/*
   1296 	 * Link a new multicast record into the interface's multicast list.
   1297 	 */
   1298 	memcpy(enm->enm_addrlo, addrlo, ETHER_ADDR_LEN);
   1299 	memcpy(enm->enm_addrhi, addrhi, ETHER_ADDR_LEN);
   1300 	enm->enm_refcount = 1;
   1301 	LIST_INSERT_HEAD(&ec->ec_multiaddrs, enm, enm_list);
   1302 	ec->ec_multicnt++;
   1303 
   1304 	/*
   1305 	 * Return ENETRESET to inform the driver that the list has changed
   1306 	 * and its reception filter should be adjusted accordingly.
   1307 	 */
   1308 	error = ENETRESET;
   1309 	enm = NULL;
   1310 
   1311 out:
   1312 	ETHER_UNLOCK(ec);
   1313 	if (enm != NULL)
   1314 		kmem_free(enm, sizeof(*enm));
   1315 	return error;
   1316 }
   1317 
   1318 /*
   1319  * Delete a multicast address record.
   1320  */
   1321 int
   1322 ether_delmulti(const struct sockaddr *sa, struct ethercom *ec)
   1323 {
   1324 	struct ether_multi *enm;
   1325 	u_char addrlo[ETHER_ADDR_LEN];
   1326 	u_char addrhi[ETHER_ADDR_LEN];
   1327 	int error;
   1328 
   1329 	ETHER_LOCK(ec);
   1330 	error = ether_multiaddr(sa, addrlo, addrhi);
   1331 	if (error != 0)
   1332 		goto error;
   1333 
   1334 	/*
   1335 	 * Look up the address in our list.
   1336 	 */
   1337 	enm = ether_lookup_multi(addrlo, addrhi, ec);
   1338 	if (enm == NULL) {
   1339 		error = ENXIO;
   1340 		goto error;
   1341 	}
   1342 	if (--enm->enm_refcount != 0) {
   1343 		/*
   1344 		 * Still some claims to this record.
   1345 		 */
   1346 		error = 0;
   1347 		goto error;
   1348 	}
   1349 
   1350 	/*
   1351 	 * No remaining claims to this record; unlink and free it.
   1352 	 */
   1353 	LIST_REMOVE(enm, enm_list);
   1354 	ec->ec_multicnt--;
   1355 	ETHER_UNLOCK(ec);
   1356 	kmem_free(enm, sizeof(*enm));
   1357 
   1358 	/*
   1359 	 * Return ENETRESET to inform the driver that the list has changed
   1360 	 * and its reception filter should be adjusted accordingly.
   1361 	 */
   1362 	return ENETRESET;
   1363 
   1364 error:
   1365 	ETHER_UNLOCK(ec);
   1366 	return error;
   1367 }
   1368 
   1369 void
   1370 ether_set_ifflags_cb(struct ethercom *ec, ether_cb_t cb)
   1371 {
   1372 	ec->ec_ifflags_cb = cb;
   1373 }
   1374 
   1375 void
   1376 ether_set_vlan_cb(struct ethercom *ec, ether_vlancb_t cb)
   1377 {
   1378 
   1379 	ec->ec_vlan_cb = cb;
   1380 }
   1381 
   1382 static int
   1383 ether_ioctl_reinit(struct ethercom *ec)
   1384 {
   1385 	struct ifnet *ifp = &ec->ec_if;
   1386 	int error;
   1387 
   1388 	switch (ifp->if_flags & (IFF_UP | IFF_RUNNING)) {
   1389 	case IFF_RUNNING:
   1390 		/*
   1391 		 * If interface is marked down and it is running,
   1392 		 * then stop and disable it.
   1393 		 */
   1394 		(*ifp->if_stop)(ifp, 1);
   1395 		break;
   1396 	case IFF_UP:
   1397 		/*
   1398 		 * If interface is marked up and it is stopped, then
   1399 		 * start it.
   1400 		 */
   1401 		return (*ifp->if_init)(ifp);
   1402 	case IFF_UP | IFF_RUNNING:
   1403 		error = 0;
   1404 		if (ec->ec_ifflags_cb != NULL) {
   1405 			error = (*ec->ec_ifflags_cb)(ec);
   1406 			if (error == ENETRESET) {
   1407 				/*
   1408 				 * Reset the interface to pick up
   1409 				 * changes in any other flags that
   1410 				 * affect the hardware state.
   1411 				 */
   1412 				return (*ifp->if_init)(ifp);
   1413 			}
   1414 		} else
   1415 			error = (*ifp->if_init)(ifp);
   1416 		return error;
   1417 	case 0:
   1418 		break;
   1419 	}
   1420 
   1421 	return 0;
   1422 }
   1423 
   1424 /*
   1425  * Common ioctls for Ethernet interfaces.  Note, we must be
   1426  * called at splnet().
   1427  */
   1428 int
   1429 ether_ioctl(struct ifnet *ifp, u_long cmd, void *data)
   1430 {
   1431 	struct ethercom *ec = (void *)ifp;
   1432 	struct eccapreq *eccr;
   1433 	struct ifreq *ifr = (struct ifreq *)data;
   1434 	struct if_laddrreq *iflr = data;
   1435 	const struct sockaddr_dl *sdl;
   1436 	static const uint8_t zero[ETHER_ADDR_LEN];
   1437 	int error;
   1438 
   1439 	switch (cmd) {
   1440 	case SIOCINITIFADDR:
   1441 	    {
   1442 		struct ifaddr *ifa = (struct ifaddr *)data;
   1443 		if (ifa->ifa_addr->sa_family != AF_LINK
   1444 		    && (ifp->if_flags & (IFF_UP | IFF_RUNNING)) !=
   1445 		       (IFF_UP | IFF_RUNNING)) {
   1446 			ifp->if_flags |= IFF_UP;
   1447 			if ((error = (*ifp->if_init)(ifp)) != 0)
   1448 				return error;
   1449 		}
   1450 #ifdef INET
   1451 		if (ifa->ifa_addr->sa_family == AF_INET)
   1452 			arp_ifinit(ifp, ifa);
   1453 #endif
   1454 		return 0;
   1455 	    }
   1456 
   1457 	case SIOCSIFMTU:
   1458 	    {
   1459 		int maxmtu;
   1460 
   1461 		if (ec->ec_capabilities & ETHERCAP_JUMBO_MTU)
   1462 			maxmtu = ETHERMTU_JUMBO;
   1463 		else
   1464 			maxmtu = ETHERMTU;
   1465 
   1466 		if (ifr->ifr_mtu < ETHERMIN || ifr->ifr_mtu > maxmtu)
   1467 			return EINVAL;
   1468 		else if ((error = ifioctl_common(ifp, cmd, data)) != ENETRESET)
   1469 			return error;
   1470 		else if (ifp->if_flags & IFF_UP) {
   1471 			/* Make sure the device notices the MTU change. */
   1472 			return (*ifp->if_init)(ifp);
   1473 		} else
   1474 			return 0;
   1475 	    }
   1476 
   1477 	case SIOCSIFFLAGS:
   1478 		if ((error = ifioctl_common(ifp, cmd, data)) != 0)
   1479 			return error;
   1480 		return ether_ioctl_reinit(ec);
   1481 	case SIOCGIFFLAGS:
   1482 		error = ifioctl_common(ifp, cmd, data);
   1483 		if (error == 0) {
   1484 			/* Set IFF_ALLMULTI for backcompat */
   1485 			ifr->ifr_flags |= (ec->ec_flags & ETHER_F_ALLMULTI) ?
   1486 			    IFF_ALLMULTI : 0;
   1487 		}
   1488 		return error;
   1489 	case SIOCGETHERCAP:
   1490 		eccr = (struct eccapreq *)data;
   1491 		eccr->eccr_capabilities = ec->ec_capabilities;
   1492 		eccr->eccr_capenable = ec->ec_capenable;
   1493 		return 0;
   1494 	case SIOCSETHERCAP:
   1495 		eccr = (struct eccapreq *)data;
   1496 		if ((eccr->eccr_capenable & ~ec->ec_capabilities) != 0)
   1497 			return EINVAL;
   1498 		if (eccr->eccr_capenable == ec->ec_capenable)
   1499 			return 0;
   1500 #if 0 /* notyet */
   1501 		ec->ec_capenable = (ec->ec_capenable & ETHERCAP_CANTCHANGE)
   1502 		    | (eccr->eccr_capenable & ~ETHERCAP_CANTCHANGE);
   1503 #else
   1504 		ec->ec_capenable = eccr->eccr_capenable;
   1505 #endif
   1506 		return ether_ioctl_reinit(ec);
   1507 	case SIOCADDMULTI:
   1508 		return ether_addmulti(ifreq_getaddr(cmd, ifr), ec);
   1509 	case SIOCDELMULTI:
   1510 		return ether_delmulti(ifreq_getaddr(cmd, ifr), ec);
   1511 	case SIOCSIFMEDIA:
   1512 	case SIOCGIFMEDIA:
   1513 		if (ec->ec_mii != NULL)
   1514 			return ifmedia_ioctl(ifp, ifr, &ec->ec_mii->mii_media,
   1515 			    cmd);
   1516 		else if (ec->ec_ifmedia != NULL)
   1517 			return ifmedia_ioctl(ifp, ifr, ec->ec_ifmedia, cmd);
   1518 		else
   1519 			return ENOTTY;
   1520 		break;
   1521 	case SIOCALIFADDR:
   1522 		sdl = satocsdl(sstocsa(&iflr->addr));
   1523 		if (sdl->sdl_family != AF_LINK)
   1524 			;
   1525 		else if (ETHER_IS_MULTICAST(CLLADDR(sdl)))
   1526 			return EINVAL;
   1527 		else if (memcmp(zero, CLLADDR(sdl), sizeof(zero)) == 0)
   1528 			return EINVAL;
   1529 		/*FALLTHROUGH*/
   1530 	default:
   1531 		return ifioctl_common(ifp, cmd, data);
   1532 	}
   1533 	return 0;
   1534 }
   1535 
   1536 /*
   1537  * Enable/disable passing VLAN packets if the parent interface supports it.
   1538  * Return:
   1539  * 	 0: Ok
   1540  *	-1: Parent interface does not support vlans
   1541  *	>0: Error
   1542  */
   1543 int
   1544 ether_enable_vlan_mtu(struct ifnet *ifp)
   1545 {
   1546 	int error;
   1547 	struct ethercom *ec = (void *)ifp;
   1548 
   1549 	/* Parent does not support VLAN's */
   1550 	if ((ec->ec_capabilities & ETHERCAP_VLAN_MTU) == 0)
   1551 		return -1;
   1552 
   1553 	/*
   1554 	 * Parent supports the VLAN_MTU capability,
   1555 	 * i.e. can Tx/Rx larger than ETHER_MAX_LEN frames;
   1556 	 * enable it.
   1557 	 */
   1558 	ec->ec_capenable |= ETHERCAP_VLAN_MTU;
   1559 
   1560 	/* Interface is down, defer for later */
   1561 	if ((ifp->if_flags & IFF_UP) == 0)
   1562 		return 0;
   1563 
   1564 	if ((error = if_flags_set(ifp, ifp->if_flags)) == 0)
   1565 		return 0;
   1566 
   1567 	ec->ec_capenable &= ~ETHERCAP_VLAN_MTU;
   1568 	return error;
   1569 }
   1570 
   1571 int
   1572 ether_disable_vlan_mtu(struct ifnet *ifp)
   1573 {
   1574 	int error;
   1575 	struct ethercom *ec = (void *)ifp;
   1576 
   1577 	/* We still have VLAN's, defer for later */
   1578 	if (ec->ec_nvlans != 0)
   1579 		return 0;
   1580 
   1581 	/* Parent does not support VLAB's, nothing to do. */
   1582 	if ((ec->ec_capenable & ETHERCAP_VLAN_MTU) == 0)
   1583 		return -1;
   1584 
   1585 	/*
   1586 	 * Disable Tx/Rx of VLAN-sized frames.
   1587 	 */
   1588 	ec->ec_capenable &= ~ETHERCAP_VLAN_MTU;
   1589 
   1590 	/* Interface is down, defer for later */
   1591 	if ((ifp->if_flags & IFF_UP) == 0)
   1592 		return 0;
   1593 
   1594 	if ((error = if_flags_set(ifp, ifp->if_flags)) == 0)
   1595 		return 0;
   1596 
   1597 	ec->ec_capenable |= ETHERCAP_VLAN_MTU;
   1598 	return error;
   1599 }
   1600 
   1601 static int
   1602 ether_multicast_sysctl(SYSCTLFN_ARGS)
   1603 {
   1604 	struct ether_multi *enm;
   1605 	struct ifnet *ifp;
   1606 	struct ethercom *ec;
   1607 	int error = 0;
   1608 	size_t written;
   1609 	struct psref psref;
   1610 	int bound;
   1611 	unsigned int multicnt;
   1612 	struct ether_multi_sysctl *addrs;
   1613 	int i;
   1614 
   1615 	if (namelen != 1)
   1616 		return EINVAL;
   1617 
   1618 	bound = curlwp_bind();
   1619 	ifp = if_get_byindex(name[0], &psref);
   1620 	if (ifp == NULL) {
   1621 		error = ENODEV;
   1622 		goto out;
   1623 	}
   1624 	if (ifp->if_type != IFT_ETHER) {
   1625 		if_put(ifp, &psref);
   1626 		*oldlenp = 0;
   1627 		goto out;
   1628 	}
   1629 	ec = (struct ethercom *)ifp;
   1630 
   1631 	if (oldp == NULL) {
   1632 		if_put(ifp, &psref);
   1633 		*oldlenp = ec->ec_multicnt * sizeof(*addrs);
   1634 		goto out;
   1635 	}
   1636 
   1637 	/*
   1638 	 * ec->ec_lock is a spin mutex so we cannot call sysctl_copyout, which
   1639 	 * is sleepable, while holding it. Copy data to a local buffer first
   1640 	 * with the lock taken and then call sysctl_copyout without holding it.
   1641 	 */
   1642 retry:
   1643 	multicnt = ec->ec_multicnt;
   1644 
   1645 	if (multicnt == 0) {
   1646 		if_put(ifp, &psref);
   1647 		*oldlenp = 0;
   1648 		goto out;
   1649 	}
   1650 
   1651 	addrs = kmem_zalloc(sizeof(*addrs) * multicnt, KM_SLEEP);
   1652 
   1653 	ETHER_LOCK(ec);
   1654 	if (multicnt != ec->ec_multicnt) {
   1655 		/* The number of multicast addresses has changed */
   1656 		ETHER_UNLOCK(ec);
   1657 		kmem_free(addrs, sizeof(*addrs) * multicnt);
   1658 		goto retry;
   1659 	}
   1660 
   1661 	i = 0;
   1662 	LIST_FOREACH(enm, &ec->ec_multiaddrs, enm_list) {
   1663 		struct ether_multi_sysctl *addr = &addrs[i];
   1664 		addr->enm_refcount = enm->enm_refcount;
   1665 		memcpy(addr->enm_addrlo, enm->enm_addrlo, ETHER_ADDR_LEN);
   1666 		memcpy(addr->enm_addrhi, enm->enm_addrhi, ETHER_ADDR_LEN);
   1667 		i++;
   1668 	}
   1669 	ETHER_UNLOCK(ec);
   1670 
   1671 	error = 0;
   1672 	written = 0;
   1673 	for (i = 0; i < multicnt; i++) {
   1674 		struct ether_multi_sysctl *addr = &addrs[i];
   1675 
   1676 		if (written + sizeof(*addr) > *oldlenp)
   1677 			break;
   1678 		error = sysctl_copyout(l, addr, oldp, sizeof(*addr));
   1679 		if (error)
   1680 			break;
   1681 		written += sizeof(*addr);
   1682 		oldp = (char *)oldp + sizeof(*addr);
   1683 	}
   1684 	kmem_free(addrs, sizeof(*addrs) * multicnt);
   1685 
   1686 	if_put(ifp, &psref);
   1687 
   1688 	*oldlenp = written;
   1689 out:
   1690 	curlwp_bindx(bound);
   1691 	return error;
   1692 }
   1693 
   1694 static void
   1695 ether_sysctl_setup(struct sysctllog **clog)
   1696 {
   1697 	const struct sysctlnode *rnode = NULL;
   1698 
   1699 	sysctl_createv(clog, 0, NULL, &rnode,
   1700 		       CTLFLAG_PERMANENT,
   1701 		       CTLTYPE_NODE, "ether",
   1702 		       SYSCTL_DESCR("Ethernet-specific information"),
   1703 		       NULL, 0, NULL, 0,
   1704 		       CTL_NET, CTL_CREATE, CTL_EOL);
   1705 
   1706 	sysctl_createv(clog, 0, &rnode, NULL,
   1707 		       CTLFLAG_PERMANENT,
   1708 		       CTLTYPE_NODE, "multicast",
   1709 		       SYSCTL_DESCR("multicast addresses"),
   1710 		       ether_multicast_sysctl, 0, NULL, 0,
   1711 		       CTL_CREATE, CTL_EOL);
   1712 }
   1713 
   1714 void
   1715 etherinit(void)
   1716 {
   1717 
   1718 #ifdef DIAGNOSTIC
   1719 	mutex_init(&bigpktpps_lock, MUTEX_DEFAULT, IPL_NET);
   1720 #endif
   1721 	ether_sysctl_setup(NULL);
   1722 }
   1723