Home | History | Annotate | Line # | Download | only in net
if_ethersubr.c revision 1.80
      1 /*	$NetBSD: if_ethersubr.c,v 1.80 2001/04/27 00:14:02 marcus 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. All advertising materials mentioning features or use of this software
     45  *    must display the following acknowledgement:
     46  *	This product includes software developed by the University of
     47  *	California, Berkeley and its contributors.
     48  * 4. Neither the name of the University nor the names of its contributors
     49  *    may be used to endorse or promote products derived from this software
     50  *    without specific prior written permission.
     51  *
     52  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     53  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     54  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     55  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     56  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     57  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     58  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     59  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     60  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     61  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     62  * SUCH DAMAGE.
     63  *
     64  *	@(#)if_ethersubr.c	8.2 (Berkeley) 4/4/96
     65  */
     66 
     67 #include "opt_inet.h"
     68 #include "opt_atalk.h"
     69 #include "opt_ccitt.h"
     70 #include "opt_llc.h"
     71 #include "opt_iso.h"
     72 #include "opt_ns.h"
     73 #include "opt_gateway.h"
     74 #include "opt_pfil_hooks.h"
     75 #include "vlan.h"
     76 #include "bridge.h"
     77 #include "bpfilter.h"
     78 
     79 #include <sys/param.h>
     80 #include <sys/systm.h>
     81 #include <sys/kernel.h>
     82 #include <sys/malloc.h>
     83 #include <sys/mbuf.h>
     84 #include <sys/protosw.h>
     85 #include <sys/socket.h>
     86 #include <sys/ioctl.h>
     87 #include <sys/errno.h>
     88 #include <sys/syslog.h>
     89 
     90 #include <machine/cpu.h>
     91 
     92 #include <net/if.h>
     93 #include <net/netisr.h>
     94 #include <net/route.h>
     95 #include <net/if_llc.h>
     96 #include <net/if_dl.h>
     97 #include <net/if_types.h>
     98 
     99 #if NBPFILTER > 0
    100 #include <net/bpf.h>
    101 #endif
    102 
    103 #include <net/if_ether.h>
    104 #if NVLAN > 0
    105 #include <net/if_vlanvar.h>
    106 #endif
    107 
    108 #if NBRIDGE > 0
    109 #include <net/if_bridgevar.h>
    110 #endif
    111 
    112 #include <netinet/in.h>
    113 #ifdef INET
    114 #include <netinet/in_var.h>
    115 #endif
    116 #include <netinet/if_inarp.h>
    117 
    118 #ifdef INET6
    119 #ifndef INET
    120 #include <netinet/in.h>
    121 #endif
    122 #include <netinet6/in6_var.h>
    123 #include <netinet6/nd6.h>
    124 #endif
    125 
    126 #ifdef NS
    127 #include <netns/ns.h>
    128 #include <netns/ns_if.h>
    129 #endif
    130 
    131 #ifdef IPX
    132 #include <netipx/ipx.h>
    133 #include <netipx/ipx_if.h>
    134 #endif
    135 
    136 #ifdef ISO
    137 #include <netiso/argo_debug.h>
    138 #include <netiso/iso.h>
    139 #include <netiso/iso_var.h>
    140 #include <netiso/iso_snpac.h>
    141 #endif
    142 
    143 #ifdef LLC
    144 #include <netccitt/dll.h>
    145 #include <netccitt/llc_var.h>
    146 #endif
    147 
    148 #if defined(LLC) && defined(CCITT)
    149 extern struct ifqueue pkintrq;
    150 #endif
    151 
    152 #ifdef NETATALK
    153 #include <netatalk/at.h>
    154 #include <netatalk/at_var.h>
    155 #include <netatalk/at_extern.h>
    156 
    157 #define llc_snap_org_code llc_un.type_snap.org_code
    158 #define llc_snap_ether_type llc_un.type_snap.ether_type
    159 
    160 extern u_char	at_org_code[3];
    161 extern u_char	aarp_org_code[3];
    162 #endif /* NETATALK */
    163 
    164 u_char	etherbroadcastaddr[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
    165 #define senderr(e) { error = (e); goto bad;}
    166 
    167 #define SIN(x) ((struct sockaddr_in *)x)
    168 
    169 static	int ether_output __P((struct ifnet *, struct mbuf *,
    170 	    struct sockaddr *, struct rtentry *));
    171 static	void ether_input __P((struct ifnet *, struct mbuf *));
    172 
    173 /*
    174  * Ethernet output routine.
    175  * Encapsulate a packet of type family for the local net.
    176  * Assumes that ifp is actually pointer to ethercom structure.
    177  */
    178 static int
    179 ether_output(struct ifnet *ifp, struct mbuf *m0, struct sockaddr *dst,
    180 	struct rtentry *rt0)
    181 {
    182 	u_int16_t etype = 0;
    183 	int s, len, error = 0, hdrcmplt = 0;
    184  	u_char esrc[6], edst[6];
    185 	struct mbuf *m = m0;
    186 	struct rtentry *rt;
    187 	struct mbuf *mcopy = (struct mbuf *)0;
    188 	struct ether_header *eh;
    189 	ALTQ_DECL(struct altq_pktattr pktattr;)
    190 #ifdef INET
    191 	struct arphdr *ah;
    192 #endif /* INET */
    193 #ifdef NETATALK
    194 	struct at_ifaddr *aa;
    195 #endif /* NETATALK */
    196 	short mflags;
    197 
    198 	if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING))
    199 		senderr(ENETDOWN);
    200 	ifp->if_lastchange = time;
    201 	if ((rt = rt0) != NULL) {
    202 		if ((rt->rt_flags & RTF_UP) == 0) {
    203 			if ((rt0 = rt = rtalloc1(dst, 1)) != NULL) {
    204 				rt->rt_refcnt--;
    205 				if (rt->rt_ifp != ifp)
    206 					return (*rt->rt_ifp->if_output)
    207 							(ifp, m0, dst, rt);
    208 			} else
    209 				senderr(EHOSTUNREACH);
    210 		}
    211 		if ((rt->rt_flags & RTF_GATEWAY) && dst->sa_family != AF_NS) {
    212 			if (rt->rt_gwroute == 0)
    213 				goto lookup;
    214 			if (((rt = rt->rt_gwroute)->rt_flags & RTF_UP) == 0) {
    215 				rtfree(rt); rt = rt0;
    216 			lookup: rt->rt_gwroute = rtalloc1(rt->rt_gateway, 1);
    217 				if ((rt = rt->rt_gwroute) == 0)
    218 					senderr(EHOSTUNREACH);
    219 				/* the "G" test below also prevents rt == rt0 */
    220 				if ((rt->rt_flags & RTF_GATEWAY) ||
    221 				    (rt->rt_ifp != ifp)) {
    222 					rt->rt_refcnt--;
    223 					rt0->rt_gwroute = 0;
    224 					senderr(EHOSTUNREACH);
    225 				}
    226 			}
    227 		}
    228 		if (rt->rt_flags & RTF_REJECT)
    229 			if (rt->rt_rmx.rmx_expire == 0 ||
    230 			    time.tv_sec < rt->rt_rmx.rmx_expire)
    231 				senderr(rt == rt0 ? EHOSTDOWN : EHOSTUNREACH);
    232 	}
    233 
    234 	switch (dst->sa_family) {
    235 
    236 #ifdef INET
    237 	case AF_INET:
    238 		if (m->m_flags & M_BCAST)
    239                 	bcopy((caddr_t)etherbroadcastaddr, (caddr_t)edst,
    240 				sizeof(edst));
    241 
    242 		else if (m->m_flags & M_MCAST) {
    243 			ETHER_MAP_IP_MULTICAST(&SIN(dst)->sin_addr,
    244 			    (caddr_t)edst)
    245 
    246 		} else if (!arpresolve(ifp, rt, m, dst, edst))
    247 			return (0);	/* if not yet resolved */
    248 		/* If broadcasting on a simplex interface, loopback a copy */
    249 		if ((m->m_flags & M_BCAST) && (ifp->if_flags & IFF_SIMPLEX))
    250 			mcopy = m_copy(m, 0, (int)M_COPYALL);
    251 		etype = htons(ETHERTYPE_IP);
    252 		break;
    253 
    254 	case AF_ARP:
    255 		ah = mtod(m, struct arphdr *);
    256 		if (m->m_flags & M_BCAST)
    257                 	bcopy((caddr_t)etherbroadcastaddr, (caddr_t)edst,
    258 				sizeof(edst));
    259 		else
    260 			bcopy((caddr_t)ar_tha(ah),
    261 				(caddr_t)edst, sizeof(edst));
    262 
    263 		ah->ar_hrd = htons(ARPHRD_ETHER);
    264 
    265 		switch(ntohs(ah->ar_op)) {
    266 		case ARPOP_REVREQUEST:
    267 		case ARPOP_REVREPLY:
    268 			etype = htons(ETHERTYPE_REVARP);
    269 			break;
    270 
    271 		case ARPOP_REQUEST:
    272 		case ARPOP_REPLY:
    273 		default:
    274 			etype = htons(ETHERTYPE_ARP);
    275 		}
    276 
    277 		break;
    278 #endif
    279 #ifdef INET6
    280 	case AF_INET6:
    281 #ifdef OLDIP6OUTPUT
    282 		if (!nd6_resolve(ifp, rt, m, dst, (u_char *)edst))
    283 			return(0);	/* if not yet resolves */
    284 #else
    285 		if (!nd6_storelladdr(ifp, rt, m, dst, (u_char *)edst)){
    286 			/* something bad happened */
    287 			return(0);
    288 		}
    289 #endif /* OLDIP6OUTPUT */
    290 		etype = htons(ETHERTYPE_IPV6);
    291 		break;
    292 #endif
    293 #ifdef NETATALK
    294     case AF_APPLETALK:
    295 		if (!aarpresolve(ifp, m, (struct sockaddr_at *)dst, edst)) {
    296 #ifdef NETATALKDEBUG
    297 			printf("aarpresolv failed\n");
    298 #endif /* NETATALKDEBUG */
    299 			return (0);
    300 		}
    301 		/*
    302 		 * ifaddr is the first thing in at_ifaddr
    303 		 */
    304 		aa = (struct at_ifaddr *) at_ifawithnet(
    305 		    (struct sockaddr_at *)dst, ifp);
    306 		if (aa == NULL)
    307 		    goto bad;
    308 
    309 		/*
    310 		 * In the phase 2 case, we need to prepend an mbuf for the
    311 		 * llc header.  Since we must preserve the value of m,
    312 		 * which is passed to us by value, we m_copy() the first
    313 		 * mbuf, and use it for our llc header.
    314 		 */
    315 		if (aa->aa_flags & AFA_PHASE2) {
    316 			struct llc llc;
    317 
    318 			M_PREPEND(m, sizeof(struct llc), M_DONTWAIT);
    319 			llc.llc_dsap = llc.llc_ssap = LLC_SNAP_LSAP;
    320 			llc.llc_control = LLC_UI;
    321 			bcopy(at_org_code, llc.llc_snap_org_code,
    322 			    sizeof(llc.llc_snap_org_code));
    323 			llc.llc_snap_ether_type = htons(ETHERTYPE_ATALK);
    324 			bcopy(&llc, mtod(m, caddr_t), sizeof(struct llc));
    325 		} else {
    326 			etype = htons(ETHERTYPE_ATALK);
    327 		}
    328 		break;
    329 #endif /* NETATALK */
    330 #ifdef NS
    331 	case AF_NS:
    332 		etype = htons(ETHERTYPE_NS);
    333  		bcopy((caddr_t)&(((struct sockaddr_ns *)dst)->sns_addr.x_host),
    334 		    (caddr_t)edst, sizeof (edst));
    335 		if (!bcmp((caddr_t)edst, (caddr_t)&ns_thishost, sizeof(edst)))
    336 			return (looutput(ifp, m, dst, rt));
    337 		/* If broadcasting on a simplex interface, loopback a copy */
    338 		if ((m->m_flags & M_BCAST) && (ifp->if_flags & IFF_SIMPLEX))
    339 			mcopy = m_copy(m, 0, (int)M_COPYALL);
    340 		break;
    341 #endif
    342 #ifdef IPX
    343 	case AF_IPX:
    344 		etype = htons(ETHERTYPE_IPX);
    345  		bcopy((caddr_t)&(((struct sockaddr_ipx *)dst)->sipx_addr.x_host),
    346 		    (caddr_t)edst, sizeof (edst));
    347 		/* If broadcasting on a simplex interface, loopback a copy */
    348 		if ((m->m_flags & M_BCAST) && (ifp->if_flags & IFF_SIMPLEX))
    349 			mcopy = m_copy(m, 0, (int)M_COPYALL);
    350 		break;
    351 #endif
    352 #ifdef	ISO
    353 	case AF_ISO: {
    354 		int	snpalen;
    355 		struct	llc *l;
    356 		struct sockaddr_dl *sdl;
    357 
    358 		if (rt && (sdl = (struct sockaddr_dl *)rt->rt_gateway) &&
    359 		    sdl->sdl_family == AF_LINK && sdl->sdl_alen > 0) {
    360 			bcopy(LLADDR(sdl), (caddr_t)edst, sizeof(edst));
    361 		} else {
    362 			error = iso_snparesolve(ifp, (struct sockaddr_iso *)dst,
    363 						(char *)edst, &snpalen);
    364 			if (error)
    365 				goto bad; /* Not Resolved */
    366 		}
    367 		/* If broadcasting on a simplex interface, loopback a copy */
    368 		if (*edst & 1)
    369 			m->m_flags |= (M_BCAST|M_MCAST);
    370 		if ((m->m_flags & M_BCAST) && (ifp->if_flags & IFF_SIMPLEX) &&
    371 		    (mcopy = m_copy(m, 0, (int)M_COPYALL))) {
    372 			M_PREPEND(mcopy, sizeof (*eh), M_DONTWAIT);
    373 			if (mcopy) {
    374 				eh = mtod(mcopy, struct ether_header *);
    375 				bcopy((caddr_t)edst,
    376 				      (caddr_t)eh->ether_dhost, sizeof (edst));
    377 				bcopy(LLADDR(ifp->if_sadl),
    378 				      (caddr_t)eh->ether_shost, sizeof (edst));
    379 			}
    380 		}
    381 		M_PREPEND(m, 3, M_DONTWAIT);
    382 		if (m == NULL)
    383 			return (0);
    384 		l = mtod(m, struct llc *);
    385 		l->llc_dsap = l->llc_ssap = LLC_ISO_LSAP;
    386 		l->llc_control = LLC_UI;
    387 #ifdef ARGO_DEBUG
    388 		if (argo_debug[D_ETHER]) {
    389 			int i;
    390 			printf("unoutput: sending pkt to: ");
    391 			for (i=0; i<6; i++)
    392 				printf("%x ", edst[i] & 0xff);
    393 			printf("\n");
    394 		}
    395 #endif
    396 		} break;
    397 #endif /* ISO */
    398 #ifdef	LLC
    399 /*	case AF_NSAP: */
    400 	case AF_CCITT: {
    401 		struct sockaddr_dl *sdl =
    402 			(struct sockaddr_dl *) rt -> rt_gateway;
    403 
    404 		if (sdl && sdl->sdl_family == AF_LINK
    405 		    && sdl->sdl_alen > 0) {
    406 			bcopy(LLADDR(sdl), (char *)edst,
    407 				sizeof(edst));
    408 		} else goto bad; /* Not a link interface ? Funny ... */
    409 		if ((ifp->if_flags & IFF_SIMPLEX) && (*edst & 1) &&
    410 		    (mcopy = m_copy(m, 0, (int)M_COPYALL))) {
    411 			M_PREPEND(mcopy, sizeof (*eh), M_DONTWAIT);
    412 			if (mcopy) {
    413 				eh = mtod(mcopy, struct ether_header *);
    414 				bcopy((caddr_t)edst,
    415 				      (caddr_t)eh->ether_dhost, sizeof (edst));
    416 				bcopy(LLADDR(ifp->if_sadl),
    417 				      (caddr_t)eh->ether_shost, sizeof (edst));
    418 			}
    419 		}
    420 #ifdef LLC_DEBUG
    421 		{
    422 			int i;
    423 			struct llc *l = mtod(m, struct llc *);
    424 
    425 			printf("ether_output: sending LLC2 pkt to: ");
    426 			for (i=0; i<6; i++)
    427 				printf("%x ", edst[i] & 0xff);
    428 			printf(" len 0x%x dsap 0x%x ssap 0x%x control 0x%x\n",
    429 			    m->m_pkthdr.len, l->llc_dsap & 0xff, l->llc_ssap &0xff,
    430 			    l->llc_control & 0xff);
    431 
    432 		}
    433 #endif /* LLC_DEBUG */
    434 		} break;
    435 #endif /* LLC */
    436 
    437 	case pseudo_AF_HDRCMPLT:
    438 		hdrcmplt = 1;
    439 		eh = (struct ether_header *)dst->sa_data;
    440 		bcopy((caddr_t)eh->ether_shost, (caddr_t)esrc, sizeof (esrc));
    441 		/* FALLTHROUGH */
    442 
    443 	case AF_UNSPEC:
    444 		eh = (struct ether_header *)dst->sa_data;
    445  		bcopy((caddr_t)eh->ether_dhost, (caddr_t)edst, sizeof (edst));
    446 		/* AF_UNSPEC doesn't swap the byte order of the ether_type. */
    447 		etype = eh->ether_type;
    448 		break;
    449 
    450 	default:
    451 		printf("%s: can't handle af%d\n", ifp->if_xname,
    452 			dst->sa_family);
    453 		senderr(EAFNOSUPPORT);
    454 	}
    455 
    456 	if (mcopy)
    457 		(void) looutput(ifp, mcopy, dst, rt);
    458 
    459 	/* If no ether type is set, this must be a 802.2 formatted packet.
    460 	 */
    461 	if (etype == 0)
    462 		etype = htons(m->m_pkthdr.len);
    463 	/*
    464 	 * Add local net header.  If no space in first mbuf,
    465 	 * allocate another.
    466 	 */
    467 	M_PREPEND(m, sizeof (struct ether_header), M_DONTWAIT);
    468 	if (m == 0)
    469 		senderr(ENOBUFS);
    470 	eh = mtod(m, struct ether_header *);
    471 	bcopy((caddr_t)&etype,(caddr_t)&eh->ether_type,
    472 		sizeof(eh->ether_type));
    473  	bcopy((caddr_t)edst, (caddr_t)eh->ether_dhost, sizeof (edst));
    474 	if (hdrcmplt)
    475 		bcopy((caddr_t)esrc, (caddr_t)eh->ether_shost,
    476 		    sizeof(eh->ether_shost));
    477 	else
    478 	 	bcopy(LLADDR(ifp->if_sadl), (caddr_t)eh->ether_shost,
    479 		    sizeof(eh->ether_shost));
    480 
    481 #ifdef PFIL_HOOKS
    482 	if ((error = pfil_run_hooks(&ifp->if_pfil, &m, ifp, PFIL_OUT)) != 0)
    483 		return (error);
    484 	if (m == NULL)
    485 		return (0);
    486 #endif
    487 
    488 #if NBRIDGE > 0
    489 	/*
    490 	 * Bridges require special output handling.
    491 	 */
    492 	if (ifp->if_bridge)
    493 		return (bridge_output(ifp, m, NULL, NULL));
    494 #endif
    495 
    496 #ifdef ALTQ
    497 	/*
    498 	 * If ALTQ is enabled on the parent interface, do
    499 	 * classification; the queueing discipline might not
    500 	 * require classification, but might require the
    501 	 * address family/header pointer in the pktattr.
    502 	 */
    503 	if (ALTQ_IS_ENABLED(&ifp->if_snd))
    504 		altq_etherclassify(&ifp->if_snd, m, &pktattr);
    505 #endif
    506 
    507 	mflags = m->m_flags;
    508 	len = m->m_pkthdr.len;
    509 	s = splnet();
    510 	/*
    511 	 * Queue message on interface, and start output if interface
    512 	 * not yet active.
    513 	 */
    514 	IFQ_ENQUEUE(&ifp->if_snd, m, &pktattr, error);
    515 	if (error) {
    516 		/* mbuf is already freed */
    517 		splx(s);
    518 		return (error);
    519 	}
    520 	ifp->if_obytes += len;
    521 	if (mflags & M_MCAST)
    522 		ifp->if_omcasts++;
    523 	if ((ifp->if_flags & IFF_OACTIVE) == 0)
    524 		(*ifp->if_start)(ifp);
    525 	splx(s);
    526 	return (error);
    527 
    528 bad:
    529 	if (m)
    530 		m_freem(m);
    531 	return (error);
    532 }
    533 
    534 #ifdef ALTQ
    535 /*
    536  * This routine is a slight hack to allow a packet to be classified
    537  * if the Ethernet headers are present.  It will go away when ALTQ's
    538  * classification engine understands link headers.
    539  */
    540 void
    541 altq_etherclassify(struct ifaltq *ifq, struct mbuf *m,
    542     struct altq_pktattr *pktattr)
    543 {
    544 	struct ether_header *eh;
    545 	u_int16_t ether_type;
    546 	int hlen, af, hdrsize;
    547 	caddr_t hdr;
    548 
    549 	hlen = ETHER_HDR_LEN;
    550 	eh = mtod(m, struct ether_header *);
    551 
    552 	ether_type = htons(eh->ether_type);
    553 
    554 	if (ether_type < ETHERMTU) {
    555 		/* LLC/SNAP */
    556 		struct llc *llc = (struct llc *)(eh + 1);
    557 		hlen += 8;
    558 
    559 		if (m->m_len < hlen ||
    560 		    llc->llc_dsap != LLC_SNAP_LSAP ||
    561 		    llc->llc_ssap != LLC_SNAP_LSAP ||
    562 		    llc->llc_control != LLC_UI) {
    563 			/* Not SNAP. */
    564 			goto bad;
    565 		}
    566 
    567 		ether_type = htons(llc->llc_un.type_snap.ether_type);
    568 	}
    569 
    570 	switch (ether_type) {
    571 	case ETHERTYPE_IP:
    572 		af = AF_INET;
    573 		hdrsize = 20;		/* sizeof(struct ip) */
    574 		break;
    575 
    576 	case ETHERTYPE_IPV6:
    577 		af = AF_INET6;
    578 		hdrsize = 40;		/* sizeof(struct ip6_hdr) */
    579 		break;
    580 
    581 	default:
    582 		af = AF_UNSPEC;
    583 		hdrsize = 0;
    584 		break;
    585 	}
    586 
    587 	if (m->m_len < (hlen + hdrsize)) {
    588 		/*
    589 		 * Ethernet and protocol header not in a single
    590 		 * mbuf.  We can't cope with this situation right
    591 		 * now (but it shouldn't ever happen, really, anyhow).
    592 		 * XXX Should use m_pulldown().
    593 		 */
    594 		printf("altq_etherclassify: headers span multiple mbufs: "
    595 		    "%d < %d\n", m->m_len, (hlen + hdrsize));
    596 		goto bad;
    597 	}
    598 
    599 	m->m_data += hlen;
    600 	m->m_len -= hlen;
    601 
    602 	hdr = mtod(m, caddr_t);
    603 
    604 	if (ALTQ_NEEDS_CLASSIFY(ifq))
    605 		pktattr->pattr_class =
    606 		    (*ifq->altq_classify)(ifq->altq_clfier, m, af);
    607 	pktattr->pattr_af = af;
    608 	pktattr->pattr_hdr = hdr;
    609 
    610 	m->m_data -= hlen;
    611 	m->m_len += hlen;
    612 
    613 	return;
    614 
    615  bad:
    616 	pktattr->pattr_class = NULL;
    617 	pktattr->pattr_hdr = NULL;
    618 	pktattr->pattr_af = AF_UNSPEC;
    619 }
    620 #endif /* ALTQ */
    621 
    622 /*
    623  * Process a received Ethernet packet;
    624  * the packet is in the mbuf chain m with
    625  * the ether header.
    626  */
    627 static void
    628 ether_input(struct ifnet *ifp, struct mbuf *m)
    629 {
    630 	struct ifqueue *inq;
    631 	u_int16_t etype;
    632 	int s;
    633 	struct ether_header *eh;
    634 	struct mbuf *n;
    635 #if defined (ISO) || defined (LLC) || defined(NETATALK)
    636 	struct llc *l;
    637 #endif
    638 
    639 	if ((ifp->if_flags & IFF_UP) == 0) {
    640 		m_freem(m);
    641 		return;
    642 	}
    643 
    644 	eh = mtod(m, struct ether_header *);
    645 	etype = ntohs(eh->ether_type);
    646 
    647 	/*
    648 	 * Determine if the packet is within its size limits.
    649 	 */
    650 	if (m->m_pkthdr.len > ETHER_MAX_FRAME(etype, m->m_flags & M_HASFCS)) {
    651 		printf("%s: discarding oversize frame (len=%d)\n",
    652 		    ifp->if_xname, m->m_pkthdr.len);
    653 		m_freem(m);
    654 		return;
    655 	}
    656 
    657 	/* If the CRC is still on the packet, trim it off. */
    658 	if (m->m_flags & M_HASFCS) {
    659 		m_adj(m, -ETHER_CRC_LEN);
    660 		m->m_flags &= ~M_HASFCS;
    661 	}
    662 
    663 	ifp->if_lastchange = time;
    664 	ifp->if_ibytes += m->m_pkthdr.len;
    665 	if (ETHER_IS_MULTICAST(eh->ether_dhost)) {
    666 		if (memcmp(etherbroadcastaddr,
    667 		    eh->ether_dhost, ETHER_ADDR_LEN) == 0)
    668 			m->m_flags |= M_BCAST;
    669 		else
    670 			m->m_flags |= M_MCAST;
    671 		ifp->if_imcasts++;
    672 	}
    673 
    674 #if NBRIDGE > 0
    675 	/*
    676 	 * Tap the packet off here for a bridge.  bridge_input()
    677 	 * will return NULL if it has consumed the packet, otherwise
    678 	 * it gets processed as normal.  Note that bridge_input()
    679 	 * will always return the original packet if we need to
    680 	 * process it locally.
    681 	 */
    682 	if (ifp->if_bridge) {
    683 		m = bridge_input(ifp, m);
    684 		if (m == NULL)
    685 			return;
    686 
    687 		/*
    688 		 * Bridge has determined that the packet is for us.
    689 		 * Update our interface pointer -- we may have had
    690 		 * to "bridge" the packet locally.
    691 		 */
    692 		ifp = m->m_pkthdr.rcvif;
    693 	}
    694 #endif /* NBRIDGE > 0 */
    695 
    696 	/*
    697 	 * XXX This comparison is redundant if we are a bridge
    698 	 * XXX and processing the packet locally.
    699 	 */
    700 	if ((m->m_flags & (M_BCAST|M_MCAST)) == 0 &&
    701 	    (ifp->if_flags & IFF_PROMISC) != 0 &&
    702 	    memcmp(LLADDR(ifp->if_sadl), eh->ether_dhost,
    703 		   ETHER_ADDR_LEN) != 0) {
    704 		m_freem(m);
    705 		return;
    706 	}
    707 
    708 #ifdef PFIL_HOOKS
    709 	if (pfil_run_hooks(&ifp->if_pfil, &m, ifp, PFIL_IN) != 0)
    710 		return;
    711 	if (m == NULL)
    712 		return;
    713 
    714 	eh = mtod(m, struct ether_header *);
    715 	etype = ntohs(eh->ether_type);
    716 #endif
    717 
    718 	/* Check if the mbuf has a VLAN tag */
    719 	n = m_aux_find(m, AF_LINK, ETHERTYPE_VLAN);
    720 	if (n) {
    721 #if NVLAN > 0
    722 		/*
    723 		 * vlan_input() will either recursively call ether_input()
    724 		 * or drop the packet.
    725 		 */
    726 		if (((struct ethercom *)ifp)->ec_nvlans != 0)
    727 			vlan_input(ifp, m);
    728 		else
    729 #endif
    730 			m_freem(m);
    731 		return;
    732 	}
    733 
    734 	/*
    735 	 * Handle protocols that expect to have the Ethernet header
    736 	 * (and possibly FCS) intact.
    737 	 */
    738 	switch (etype) {
    739 #if NVLAN > 0
    740 	case ETHERTYPE_VLAN:
    741 		/*
    742 		 * vlan_input() will either recursively call ether_input()
    743 		 * or drop the packet.
    744 		 */
    745 		if (((struct ethercom *)ifp)->ec_nvlans != 0)
    746 			vlan_input(ifp, m);
    747 		else
    748 			m_freem(m);
    749 		return;
    750 #endif /* NVLAN > 0 */
    751 	default:
    752 		; /* Nothing. */
    753 	}
    754 
    755 	/* Strip off the Ethernet header. */
    756 	m_adj(m, sizeof(struct ether_header));
    757 
    758 	/* If the CRC is still on the packet, trim it off. */
    759 	if (m->m_flags & M_HASFCS) {
    760 		m_adj(m, -ETHER_CRC_LEN);
    761 		m->m_flags &= ~M_HASFCS;
    762 	}
    763 
    764 	switch (etype) {
    765 #ifdef INET
    766 	case ETHERTYPE_IP:
    767 #ifdef GATEWAY
    768 		if (ipflow_fastforward(m))
    769 			return;
    770 #endif
    771 		schednetisr(NETISR_IP);
    772 		inq = &ipintrq;
    773 		break;
    774 
    775 	case ETHERTYPE_ARP:
    776 		schednetisr(NETISR_ARP);
    777 		inq = &arpintrq;
    778 		break;
    779 
    780 	case ETHERTYPE_REVARP:
    781 		revarpinput(m);	/* XXX queue? */
    782 		return;
    783 #endif
    784 #ifdef INET6
    785 	case ETHERTYPE_IPV6:
    786 		schednetisr(NETISR_IPV6);
    787 		inq = &ip6intrq;
    788 		break;
    789 #endif
    790 #ifdef NS
    791 	case ETHERTYPE_NS:
    792 		schednetisr(NETISR_NS);
    793 		inq = &nsintrq;
    794 		break;
    795 
    796 #endif
    797 #ifdef IPX
    798 	case ETHERTYPE_IPX:
    799 		schednetisr(NETISR_IPX);
    800 		inq = &ipxintrq;
    801 		break;
    802 #endif
    803 #ifdef NETATALK
    804         case ETHERTYPE_ATALK:
    805                 schednetisr(NETISR_ATALK);
    806                 inq = &atintrq1;
    807                 break;
    808         case ETHERTYPE_AARP:
    809 		/* probably this should be done with a NETISR as well */
    810                 aarpinput(ifp, m); /* XXX */
    811                 return;
    812 #endif /* NETATALK */
    813 	default:
    814 #if defined (ISO) || defined (LLC) || defined (NETATALK)
    815 		if (etype > ETHERMTU)
    816 			goto dropanyway;
    817 		l = mtod(m, struct llc *);
    818 		switch (l->llc_dsap) {
    819 #ifdef NETATALK
    820 		case LLC_SNAP_LSAP:
    821 			switch (l->llc_control) {
    822 			case LLC_UI:
    823 				if (l->llc_ssap != LLC_SNAP_LSAP) {
    824 					goto dropanyway;
    825 				}
    826 
    827 				if (Bcmp(&(l->llc_snap_org_code)[0],
    828 				    at_org_code, sizeof(at_org_code)) == 0 &&
    829 				    ntohs(l->llc_snap_ether_type) ==
    830 				    ETHERTYPE_ATALK) {
    831 					inq = &atintrq2;
    832 					m_adj(m, sizeof(struct llc));
    833 					schednetisr(NETISR_ATALK);
    834 					break;
    835 				}
    836 
    837 				if (Bcmp(&(l->llc_snap_org_code)[0],
    838 				    aarp_org_code,
    839 				    sizeof(aarp_org_code)) == 0 &&
    840 				    ntohs(l->llc_snap_ether_type) ==
    841 				    ETHERTYPE_AARP) {
    842 					m_adj( m, sizeof(struct llc));
    843 					aarpinput(ifp, m); /* XXX */
    844 				    return;
    845 				}
    846 
    847 			default:
    848 				goto dropanyway;
    849 			}
    850 			break;
    851 #endif /* NETATALK */
    852 #ifdef	ISO
    853 		case LLC_ISO_LSAP:
    854 			switch (l->llc_control) {
    855 			case LLC_UI:
    856 				/* LLC_UI_P forbidden in class 1 service */
    857 				if ((l->llc_dsap == LLC_ISO_LSAP) &&
    858 				    (l->llc_ssap == LLC_ISO_LSAP)) {
    859 					/* LSAP for ISO */
    860 					if (m->m_pkthdr.len > etype)
    861 						m_adj(m, etype - m->m_pkthdr.len);
    862 					m->m_data += 3;		/* XXX */
    863 					m->m_len -= 3;		/* XXX */
    864 					m->m_pkthdr.len -= 3;	/* XXX */
    865 					M_PREPEND(m, sizeof *eh, M_DONTWAIT);
    866 					if (m == 0)
    867 						return;
    868 					*mtod(m, struct ether_header *) = *eh;
    869 #ifdef ARGO_DEBUG
    870 					if (argo_debug[D_ETHER])
    871 						printf("clnp packet");
    872 #endif
    873 					schednetisr(NETISR_ISO);
    874 					inq = &clnlintrq;
    875 					break;
    876 				}
    877 				goto dropanyway;
    878 
    879 			case LLC_XID:
    880 			case LLC_XID_P:
    881 				if(m->m_len < 6)
    882 					goto dropanyway;
    883 				l->llc_window = 0;
    884 				l->llc_fid = 9;
    885 				l->llc_class = 1;
    886 				l->llc_dsap = l->llc_ssap = 0;
    887 				/* Fall through to */
    888 			case LLC_TEST:
    889 			case LLC_TEST_P:
    890 			{
    891 				struct sockaddr sa;
    892 				struct ether_header *eh2;
    893 				int i;
    894 				u_char c = l->llc_dsap;
    895 
    896 				l->llc_dsap = l->llc_ssap;
    897 				l->llc_ssap = c;
    898 				if (m->m_flags & (M_BCAST | M_MCAST))
    899 					bcopy(LLADDR(ifp->if_sadl),
    900 					      (caddr_t)eh->ether_dhost, 6);
    901 				sa.sa_family = AF_UNSPEC;
    902 				sa.sa_len = sizeof(sa);
    903 				eh2 = (struct ether_header *)sa.sa_data;
    904 				for (i = 0; i < 6; i++) {
    905 					eh2->ether_shost[i] = c =
    906 					    eh->ether_dhost[i];
    907 					eh2->ether_dhost[i] =
    908 					    eh->ether_dhost[i] =
    909 					    eh->ether_shost[i];
    910 					eh->ether_shost[i] = c;
    911 				}
    912 				ifp->if_output(ifp, m, &sa, NULL);
    913 				return;
    914 			}
    915 			default:
    916 				m_freem(m);
    917 				return;
    918 			}
    919 			break;
    920 #endif /* ISO */
    921 #ifdef LLC
    922 		case LLC_X25_LSAP:
    923 		{
    924 			if (m->m_pkthdr.len > etype)
    925 				m_adj(m, etype - m->m_pkthdr.len);
    926 			M_PREPEND(m, sizeof(struct sdl_hdr) , M_DONTWAIT);
    927 			if (m == 0)
    928 				return;
    929 			if ( !sdl_sethdrif(ifp, eh->ether_shost, LLC_X25_LSAP,
    930 					    eh->ether_dhost, LLC_X25_LSAP, 6,
    931 					    mtod(m, struct sdl_hdr *)))
    932 				panic("ETHER cons addr failure");
    933 			mtod(m, struct sdl_hdr *)->sdlhdr_len = etype;
    934 #ifdef LLC_DEBUG
    935 				printf("llc packet\n");
    936 #endif /* LLC_DEBUG */
    937 			schednetisr(NETISR_CCITT);
    938 			inq = &llcintrq;
    939 			break;
    940 		}
    941 #endif /* LLC */
    942 		dropanyway:
    943 		default:
    944 			m_freem(m);
    945 			return;
    946 		}
    947 #else /* ISO || LLC  || NETATALK*/
    948 	    m_freem(m);
    949 	    return;
    950 #endif /* ISO || LLC || NETATALK*/
    951 	}
    952 
    953 	s = splnet();
    954 	if (IF_QFULL(inq)) {
    955 		IF_DROP(inq);
    956 		m_freem(m);
    957 	} else
    958 		IF_ENQUEUE(inq, m);
    959 	splx(s);
    960 }
    961 
    962 /*
    963  * Convert Ethernet address to printable (loggable) representation.
    964  */
    965 static char digits[] = "0123456789abcdef";
    966 char *
    967 ether_sprintf(const u_char *ap)
    968 {
    969 	static char etherbuf[18];
    970 	char *cp = etherbuf;
    971 	int i;
    972 
    973 	for (i = 0; i < 6; i++) {
    974 		*cp++ = digits[*ap >> 4];
    975 		*cp++ = digits[*ap++ & 0xf];
    976 		*cp++ = ':';
    977 	}
    978 	*--cp = 0;
    979 	return (etherbuf);
    980 }
    981 
    982 /*
    983  * Perform common duties while attaching to interface list
    984  */
    985 void
    986 ether_ifattach(struct ifnet *ifp, const u_int8_t *lla)
    987 {
    988 
    989 	ifp->if_type = IFT_ETHER;
    990 	ifp->if_addrlen = ETHER_ADDR_LEN;
    991 	ifp->if_hdrlen = 14;
    992 	ifp->if_dlt = DLT_EN10MB;
    993 	ifp->if_mtu = ETHERMTU;
    994 	ifp->if_output = ether_output;
    995 	ifp->if_input = ether_input;
    996 	if (ifp->if_baudrate == 0)
    997 		ifp->if_baudrate = IF_Mbps(10);		/* just a default */
    998 
    999 	if_alloc_sadl(ifp);
   1000 	memcpy(LLADDR(ifp->if_sadl), lla, ifp->if_addrlen);
   1001 
   1002 	LIST_INIT(&((struct ethercom *)ifp)->ec_multiaddrs);
   1003 	ifp->if_broadcastaddr = etherbroadcastaddr;
   1004 #if NBPFILTER > 0
   1005 	bpfattach(ifp, DLT_EN10MB, sizeof(struct ether_header));
   1006 #endif
   1007 }
   1008 
   1009 void
   1010 ether_ifdetach(struct ifnet *ifp)
   1011 {
   1012 	struct ethercom *ec = (void *) ifp;
   1013 	struct ether_multi *enm;
   1014 	int s;
   1015 
   1016 #if NBPFILTER > 0
   1017 	bpfdetach(ifp);
   1018 #endif
   1019 
   1020 #if NVLAN > 0
   1021 	if (ec->ec_nvlans)
   1022 		vlan_ifdetach(ifp);
   1023 #endif
   1024 
   1025 	s = splnet();
   1026 	while ((enm = LIST_FIRST(&ec->ec_multiaddrs)) != NULL) {
   1027 		LIST_REMOVE(enm, enm_list);
   1028 		free(enm, M_IFADDR);
   1029 		ec->ec_multicnt--;
   1030 	}
   1031 	splx(s);
   1032 
   1033 	if_free_sadl(ifp);
   1034 }
   1035 
   1036 #if 0
   1037 /*
   1038  * This is for reference.  We have a table-driven version
   1039  * of the little-endian crc32 generator, which is faster
   1040  * than the double-loop.
   1041  */
   1042 u_int32_t
   1043 ether_crc32_le(const u_int8_t *buf, size_t len)
   1044 {
   1045 	u_int32_t c, crc, carry;
   1046 	size_t i, j;
   1047 
   1048 	crc = 0xffffffffU;	/* initial value */
   1049 
   1050 	for (i = 0; i < len; i++) {
   1051 		c = buf[i];
   1052 		for (j = 0; j < 8; j++) {
   1053 			carry = ((crc & 0x01) ? 1 : 0) ^ (c & 0x01);
   1054 			crc >>= 1;
   1055 			c >>= 1;
   1056 			if (carry)
   1057 				crc = (crc ^ ETHER_CRC_POLY_LE);
   1058 		}
   1059 	}
   1060 
   1061 	return (crc);
   1062 }
   1063 #else
   1064 u_int32_t
   1065 ether_crc32_le(const u_int8_t *buf, size_t len)
   1066 {
   1067 	static const u_int32_t crctab[] = {
   1068 		0x00000000, 0x1db71064, 0x3b6e20c8, 0x26d930ac,
   1069 		0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c,
   1070 		0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c,
   1071 		0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c
   1072 	};
   1073 	u_int32_t crc;
   1074 	int i;
   1075 
   1076 	crc = 0xffffffffU;	/* initial value */
   1077 
   1078 	for (i = 0; i < len; i++) {
   1079 		crc ^= buf[i];
   1080 		crc = (crc >> 4) ^ crctab[crc & 0xf];
   1081 		crc = (crc >> 4) ^ crctab[crc & 0xf];
   1082 	}
   1083 
   1084 	return (crc);
   1085 }
   1086 #endif
   1087 
   1088 u_int32_t
   1089 ether_crc32_be(const u_int8_t *buf, size_t len)
   1090 {
   1091 	u_int32_t c, crc, carry;
   1092 	size_t i, j;
   1093 
   1094 	crc = 0xffffffffU;	/* initial value */
   1095 
   1096 	for (i = 0; i < len; i++) {
   1097 		c = buf[i];
   1098 		for (j = 0; j < 8; j++) {
   1099 			carry = ((crc & 0x80000000U) ? 1 : 0) ^ (c & 0x01);
   1100 			crc <<= 1;
   1101 			c >>= 1;
   1102 			if (carry)
   1103 				crc = (crc ^ ETHER_CRC_POLY_BE) | carry;
   1104 		}
   1105 	}
   1106 
   1107 	return (crc);
   1108 }
   1109 
   1110 #ifdef INET
   1111 u_char	ether_ipmulticast_min[6] = { 0x01, 0x00, 0x5e, 0x00, 0x00, 0x00 };
   1112 u_char	ether_ipmulticast_max[6] = { 0x01, 0x00, 0x5e, 0x7f, 0xff, 0xff };
   1113 #endif
   1114 #ifdef INET6
   1115 u_char	ether_ip6multicast_min[6] = { 0x33, 0x33, 0x00, 0x00, 0x00, 0x00 };
   1116 u_char	ether_ip6multicast_max[6] = { 0x33, 0x33, 0xff, 0xff, 0xff, 0xff };
   1117 #endif
   1118 
   1119 /*
   1120  * Convert a sockaddr into an Ethernet address or range of Ethernet
   1121  * addresses.
   1122  */
   1123 int
   1124 ether_multiaddr(struct sockaddr *sa, u_int8_t addrlo[ETHER_ADDR_LEN],
   1125     u_int8_t addrhi[ETHER_ADDR_LEN])
   1126 {
   1127 #ifdef INET
   1128 	struct sockaddr_in *sin;
   1129 #endif /* INET */
   1130 #ifdef INET6
   1131 	struct sockaddr_in6 *sin6;
   1132 #endif /* INET6 */
   1133 
   1134 	switch (sa->sa_family) {
   1135 
   1136 	case AF_UNSPEC:
   1137 		bcopy(sa->sa_data, addrlo, ETHER_ADDR_LEN);
   1138 		bcopy(addrlo, addrhi, ETHER_ADDR_LEN);
   1139 		break;
   1140 
   1141 #ifdef INET
   1142 	case AF_INET:
   1143 		sin = satosin(sa);
   1144 		if (sin->sin_addr.s_addr == INADDR_ANY) {
   1145 			/*
   1146 			 * An IP address of INADDR_ANY means listen to
   1147 			 * or stop listening to all of the Ethernet
   1148 			 * multicast addresses used for IP.
   1149 			 * (This is for the sake of IP multicast routers.)
   1150 			 */
   1151 			bcopy(ether_ipmulticast_min, addrlo, ETHER_ADDR_LEN);
   1152 			bcopy(ether_ipmulticast_max, addrhi, ETHER_ADDR_LEN);
   1153 		}
   1154 		else {
   1155 			ETHER_MAP_IP_MULTICAST(&sin->sin_addr, addrlo);
   1156 			bcopy(addrlo, addrhi, ETHER_ADDR_LEN);
   1157 		}
   1158 		break;
   1159 #endif
   1160 #ifdef INET6
   1161 	case AF_INET6:
   1162 		sin6 = satosin6(sa);
   1163 		if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
   1164 			/*
   1165 			 * An IP6 address of 0 means listen to or stop
   1166 			 * listening to all of the Ethernet multicast
   1167 			 * address used for IP6.
   1168 			 * (This is used for multicast routers.)
   1169 			 */
   1170 			bcopy(ether_ip6multicast_min, addrlo, ETHER_ADDR_LEN);
   1171 			bcopy(ether_ip6multicast_max, addrhi, ETHER_ADDR_LEN);
   1172 		} else {
   1173 			ETHER_MAP_IPV6_MULTICAST(&sin6->sin6_addr, addrlo);
   1174 			bcopy(addrlo, addrhi, ETHER_ADDR_LEN);
   1175 		}
   1176 		break;
   1177 #endif
   1178 
   1179 	default:
   1180 		return (EAFNOSUPPORT);
   1181 	}
   1182 	return (0);
   1183 }
   1184 
   1185 /*
   1186  * Add an Ethernet multicast address or range of addresses to the list for a
   1187  * given interface.
   1188  */
   1189 int
   1190 ether_addmulti(struct ifreq *ifr, struct ethercom *ec)
   1191 {
   1192 	struct ether_multi *enm;
   1193 	u_char addrlo[ETHER_ADDR_LEN];
   1194 	u_char addrhi[ETHER_ADDR_LEN];
   1195 	int s = splnet(), error;
   1196 
   1197 	error = ether_multiaddr(&ifr->ifr_addr, addrlo, addrhi);
   1198 	if (error != 0) {
   1199 		splx(s);
   1200 		return (error);
   1201 	}
   1202 
   1203 	/*
   1204 	 * Verify that we have valid Ethernet multicast addresses.
   1205 	 */
   1206 	if ((addrlo[0] & 0x01) != 1 || (addrhi[0] & 0x01) != 1) {
   1207 		splx(s);
   1208 		return (EINVAL);
   1209 	}
   1210 	/*
   1211 	 * See if the address range is already in the list.
   1212 	 */
   1213 	ETHER_LOOKUP_MULTI(addrlo, addrhi, ec, enm);
   1214 	if (enm != NULL) {
   1215 		/*
   1216 		 * Found it; just increment the reference count.
   1217 		 */
   1218 		++enm->enm_refcount;
   1219 		splx(s);
   1220 		return (0);
   1221 	}
   1222 	/*
   1223 	 * New address or range; malloc a new multicast record
   1224 	 * and link it into the interface's multicast list.
   1225 	 */
   1226 	enm = (struct ether_multi *)malloc(sizeof(*enm), M_IFMADDR, M_NOWAIT);
   1227 	if (enm == NULL) {
   1228 		splx(s);
   1229 		return (ENOBUFS);
   1230 	}
   1231 	bcopy(addrlo, enm->enm_addrlo, 6);
   1232 	bcopy(addrhi, enm->enm_addrhi, 6);
   1233 	enm->enm_ec = ec;
   1234 	enm->enm_refcount = 1;
   1235 	LIST_INSERT_HEAD(&ec->ec_multiaddrs, enm, enm_list);
   1236 	ec->ec_multicnt++;
   1237 	splx(s);
   1238 	/*
   1239 	 * Return ENETRESET to inform the driver that the list has changed
   1240 	 * and its reception filter should be adjusted accordingly.
   1241 	 */
   1242 	return (ENETRESET);
   1243 }
   1244 
   1245 /*
   1246  * Delete a multicast address record.
   1247  */
   1248 int
   1249 ether_delmulti(struct ifreq *ifr, struct ethercom *ec)
   1250 {
   1251 	struct ether_multi *enm;
   1252 	u_char addrlo[ETHER_ADDR_LEN];
   1253 	u_char addrhi[ETHER_ADDR_LEN];
   1254 	int s = splnet(), error;
   1255 
   1256 	error = ether_multiaddr(&ifr->ifr_addr, addrlo, addrhi);
   1257 	if (error != 0) {
   1258 		splx(s);
   1259 		return (error);
   1260 	}
   1261 
   1262 	/*
   1263 	 * Look ur the address in our list.
   1264 	 */
   1265 	ETHER_LOOKUP_MULTI(addrlo, addrhi, ec, enm);
   1266 	if (enm == NULL) {
   1267 		splx(s);
   1268 		return (ENXIO);
   1269 	}
   1270 	if (--enm->enm_refcount != 0) {
   1271 		/*
   1272 		 * Still some claims to this record.
   1273 		 */
   1274 		splx(s);
   1275 		return (0);
   1276 	}
   1277 	/*
   1278 	 * No remaining claims to this record; unlink and free it.
   1279 	 */
   1280 	LIST_REMOVE(enm, enm_list);
   1281 	free(enm, M_IFMADDR);
   1282 	ec->ec_multicnt--;
   1283 	splx(s);
   1284 	/*
   1285 	 * Return ENETRESET to inform the driver that the list has changed
   1286 	 * and its reception filter should be adjusted accordingly.
   1287 	 */
   1288 	return (ENETRESET);
   1289 }
   1290 
   1291 /*
   1292  * Common ioctls for Ethernet interfaces.  Note, we must be
   1293  * called at splnet().
   1294  */
   1295 int
   1296 ether_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
   1297 {
   1298 	struct ethercom *ec = (void *) ifp;
   1299 	struct ifreq *ifr = (struct ifreq *)data;
   1300 	struct ifaddr *ifa = (struct ifaddr *)data;
   1301 	int error = 0;
   1302 
   1303 	switch (cmd) {
   1304 	case SIOCSIFADDR:
   1305 		ifp->if_flags |= IFF_UP;
   1306 		switch (ifa->ifa_addr->sa_family) {
   1307 		case AF_LINK:
   1308 		    {
   1309 			struct sockaddr_dl *sdl =
   1310 			    (struct sockaddr_dl *) ifa->ifa_addr;
   1311 
   1312 			if (sdl->sdl_type != IFT_ETHER ||
   1313 			    sdl->sdl_alen != ifp->if_addrlen) {
   1314 				error = EINVAL;
   1315 				break;
   1316 			}
   1317 
   1318 			memcpy(LLADDR(ifp->if_sadl), LLADDR(sdl),
   1319 			    ifp->if_addrlen);
   1320 
   1321 			/* Set new address. */
   1322 			error = (*ifp->if_init)(ifp);
   1323 			break;
   1324 		    }
   1325 #ifdef INET
   1326 		case AF_INET:
   1327 			if ((error = (*ifp->if_init)(ifp)) != 0)
   1328 				break;
   1329 			arp_ifinit(ifp, ifa);
   1330 			break;
   1331 #endif /* INET */
   1332 #ifdef NS
   1333 		case AF_NS:
   1334 		    {
   1335 			struct ns_addr *ina = &IA_SNS(ifa)->sns_addr;
   1336 
   1337 			if (ns_nullhost(*ina))
   1338 				ina->x_host = *(union ns_host *)
   1339 				    LLADDR(ifp->if_sadl);
   1340 			else
   1341 				memcpy(LLADDR(ifp->if_sadl),
   1342 				    ina->x_host.c_host, ifp->if_addrlen);
   1343 			/* Set new address. */
   1344 			error = (*ifp->if_init)(ifp);
   1345 			break;
   1346 		    }
   1347 #endif /* NS */
   1348 		default:
   1349 			error = (*ifp->if_init)(ifp);
   1350 			break;
   1351 		}
   1352 		break;
   1353 
   1354 	case SIOCGIFADDR:
   1355 		memcpy(((struct sockaddr *)&ifr->ifr_data)->sa_data,
   1356 		    LLADDR(ifp->if_sadl), ETHER_ADDR_LEN);
   1357 		break;
   1358 
   1359 	case SIOCSIFMTU:
   1360 		if (ifr->ifr_mtu > ETHERMTU)
   1361 			error = EINVAL;
   1362 		else
   1363 			ifp->if_mtu = ifr->ifr_mtu;
   1364 		break;
   1365 
   1366 	case SIOCSIFFLAGS:
   1367 		if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) == IFF_RUNNING) {
   1368 			/*
   1369 			 * If interface is marked down and it is running,
   1370 			 * then stop and disable it.
   1371 			 */
   1372 			(*ifp->if_stop)(ifp, 1);
   1373 		} else if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) == IFF_UP) {
   1374 			/*
   1375 			 * If interface is marked up and it is stopped, then
   1376 			 * start it.
   1377 			 */
   1378 			error = (*ifp->if_init)(ifp);
   1379 		} else if ((ifp->if_flags & IFF_UP) != 0) {
   1380 			/*
   1381 			 * Reset the interface to pick up changes in any other
   1382 			 * flags that affect the hardware state.
   1383 			 */
   1384 			error = (*ifp->if_init)(ifp);
   1385 		}
   1386 		break;
   1387 
   1388 	case SIOCADDMULTI:
   1389 		error = ether_addmulti(ifr, ec);
   1390 		break;
   1391 
   1392 	case SIOCDELMULTI:
   1393 		error = ether_delmulti(ifr, ec);
   1394 		break;
   1395 
   1396 	default:
   1397 		error = ENOTTY;
   1398 	}
   1399 
   1400 	return (error);
   1401 }
   1402