![[BACK]](/icons/back.gif){kind=icon}
Return to if_ethersubr.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / net|
Return to if_ethersubr.c CVS log | Up to [local] / sys / net |
1.1 nbrk 1: /* $OpenBSD: if_ethersubr.c,v 1.110 2007/06/06 10:04:36 henning Exp $ */
2: /* $NetBSD: if_ethersubr.c,v 1.19 1996/05/07 02:40:30 thorpej Exp $ */
3:
4: /*
5: * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
6: * All rights reserved.
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: * 2. Redistributions in binary form must reproduce the above copyright
14: * notice, this list of conditions and the following disclaimer in the
15: * documentation and/or other materials provided with the distribution.
16: * 3. Neither the name of the project nor the names of its contributors
17: * may be used to endorse or promote products derived from this software
18: * without specific prior written permission.
19: *
20: * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
21: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23: * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
24: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30: * SUCH DAMAGE.
31: */
32:
33: /*
34: * Copyright (c) 1982, 1989, 1993
35: * The Regents of the University of California. All rights reserved.
36: *
37: * Redistribution and use in source and binary forms, with or without
38: * modification, are permitted provided that the following conditions
39: * are met:
40: * 1. Redistributions of source code must retain the above copyright
41: * notice, this list of conditions and the following disclaimer.
42: * 2. Redistributions in binary form must reproduce the above copyright
43: * notice, this list of conditions and the following disclaimer in the
44: * documentation and/or other materials provided with the distribution.
45: * 3. Neither the name of the University nor the names of its contributors
46: * may be used to endorse or promote products derived from this software
47: * without specific prior written permission.
48: *
49: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
50: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
51: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
52: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
53: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
54: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
55: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
56: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
57: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
58: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
59: * SUCH DAMAGE.
60: *
61: * @(#)if_ethersubr.c 8.1 (Berkeley) 6/10/93
62: */
63:
64: /*
65: %%% portions-copyright-nrl-95
66: Portions of this software are Copyright 1995-1998 by Randall Atkinson,
67: Ronald Lee, Daniel McDonald, Bao Phan, and Chris Winters. All Rights
68: Reserved. All rights under this copyright have been assigned to the US
69: Naval Research Laboratory (NRL). The NRL Copyright Notice and License
70: Agreement Version 1.1 (January 17, 1995) applies to these portions of the
71: software.
72: You should have received a copy of the license with this software. If you
73: didn't get a copy, you may request one from <license@ipv6.nrl.navy.mil>.
74: */
75:
76: #include "bpfilter.h"
77:
78: #include <sys/param.h>
79: #include <sys/systm.h>
80: #include <sys/kernel.h>
81: #include <sys/malloc.h>
82: #include <sys/mbuf.h>
83: #include <sys/protosw.h>
84: #include <sys/socket.h>
85: #include <sys/ioctl.h>
86: #include <sys/errno.h>
87: #include <sys/syslog.h>
88: #include <sys/timeout.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_media.h>
98: #include <net/if_types.h>
99:
100: #include <netinet/in.h>
101: #ifdef INET
102: #include <netinet/in_var.h>
103: #endif
104: #include <netinet/if_ether.h>
105: #include <netinet/ip_ipsp.h>
106:
107: #if NBPFILTER > 0
108: #include <net/bpf.h>
109: #endif
110:
111: #include "bridge.h"
112: #if NBRIDGE > 0
113: #include <net/if_bridge.h>
114: #endif
115:
116: #include "vlan.h"
117: #if NVLAN > 0
118: #include <net/if_vlan_var.h>
119: #endif /* NVLAN > 0 */
120:
121: #include "carp.h"
122: #if NCARP > 0
123: #include <netinet/ip_carp.h>
124: #endif
125:
126: #include "pppoe.h"
127: #if NPPPOE > 0
128: #include <net/if_pppoe.h>
129: #endif
130:
131: #include "trunk.h"
132: #if NTRUNK > 0
133: #include <net/if_trunk.h>
134: #endif
135:
136: #ifdef INET6
137: #ifndef INET
138: #include <netinet/in.h>
139: #endif
140: #include <netinet6/in6_var.h>
141: #include <netinet6/nd6.h>
142: #endif
143:
144: #ifdef NETATALK
145: #include <netatalk/at.h>
146: #include <netatalk/at_var.h>
147: #include <netatalk/at_extern.h>
148:
149: extern u_char at_org_code[ 3 ];
150: extern u_char aarp_org_code[ 3 ];
151: #endif /* NETATALK */
152:
153: u_char etherbroadcastaddr[ETHER_ADDR_LEN] =
154: { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
155: #define senderr(e) { error = (e); goto bad;}
156:
157:
158: int
159: ether_ioctl(ifp, arp, cmd, data)
160: struct ifnet *ifp;
161: struct arpcom *arp;
162: u_long cmd;
163: caddr_t data;
164: {
165: struct ifaddr *ifa = (struct ifaddr *)data;
166: int error = 0;
167:
168: switch (cmd) {
169:
170: case SIOCSIFADDR:
171: switch (ifa->ifa_addr->sa_family) {
172: #ifdef NETATALK
173: case AF_APPLETALK:
174: /* Nothing to do. */
175: break;
176: #endif /* NETATALK */
177: }
178: break;
179: default:
180: break;
181: }
182:
183: return error;
184: }
185:
186: /*
187: * Ethernet output routine.
188: * Encapsulate a packet of type family for the local net.
189: * Assumes that ifp is actually pointer to arpcom structure.
190: */
191: int
192: ether_output(ifp0, m0, dst, rt0)
193: struct ifnet *ifp0;
194: struct mbuf *m0;
195: struct sockaddr *dst;
196: struct rtentry *rt0;
197: {
198: u_int16_t etype;
199: int s, len, error = 0, hdrcmplt = 0;
200: u_char edst[ETHER_ADDR_LEN], esrc[ETHER_ADDR_LEN];
201: struct mbuf *m = m0;
202: struct rtentry *rt;
203: struct mbuf *mcopy = (struct mbuf *)0;
204: struct ether_header *eh;
205: struct arpcom *ac = (struct arpcom *)ifp0;
206: short mflags;
207: struct ifnet *ifp = ifp0;
208:
209: #if NTRUNK > 0
210: if (ifp->if_type == IFT_IEEE8023ADLAG)
211: senderr(EBUSY);
212: #endif
213:
214: #if NCARP > 0
215: if (ifp->if_type == IFT_CARP) {
216: struct ifaddr *ifa;
217:
218: /* loop back if this is going to the carp interface */
219: if (dst != NULL && LINK_STATE_IS_UP(ifp0->if_link_state) &&
220: (ifa = ifa_ifwithaddr(dst)) != NULL &&
221: ifa->ifa_ifp == ifp0)
222: return (looutput(ifp0, m, dst, rt0));
223:
224: ifp = ifp->if_carpdev;
225: ac = (struct arpcom *)ifp;
226:
227: if ((ifp0->if_flags & (IFF_UP|IFF_RUNNING)) !=
228: (IFF_UP|IFF_RUNNING))
229: senderr(ENETDOWN);
230: }
231: #endif /* NCARP > 0 */
232:
233: if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING))
234: senderr(ENETDOWN);
235: if ((rt = rt0) != NULL) {
236: if ((rt->rt_flags & RTF_UP) == 0) {
237: if ((rt0 = rt = rtalloc1(dst, 1, 0)) != NULL)
238: rt->rt_refcnt--;
239: else
240: senderr(EHOSTUNREACH);
241: }
242: if (rt->rt_flags & RTF_GATEWAY) {
243: if (rt->rt_gwroute == 0)
244: goto lookup;
245: if (((rt = rt->rt_gwroute)->rt_flags & RTF_UP) == 0) {
246: rtfree(rt); rt = rt0;
247: lookup: rt->rt_gwroute = rtalloc1(rt->rt_gateway, 1, 0);
248: if ((rt = rt->rt_gwroute) == 0)
249: senderr(EHOSTUNREACH);
250: }
251: }
252: if (rt->rt_flags & RTF_REJECT)
253: if (rt->rt_rmx.rmx_expire == 0 ||
254: time_second < rt->rt_rmx.rmx_expire)
255: senderr(rt == rt0 ? EHOSTDOWN : EHOSTUNREACH);
256: }
257:
258: switch (dst->sa_family) {
259:
260: #ifdef INET
261: case AF_INET:
262: if (!arpresolve(ac, rt, m, dst, edst))
263: return (0); /* if not yet resolved */
264: /* If broadcasting on a simplex interface, loopback a copy */
265: if ((m->m_flags & M_BCAST) && (ifp->if_flags & IFF_SIMPLEX) &&
266: !m->m_pkthdr.pf.routed)
267: mcopy = m_copy(m, 0, (int)M_COPYALL);
268: etype = htons(ETHERTYPE_IP);
269: break;
270: #endif
271: #ifdef INET6
272: case AF_INET6:
273: if (!nd6_storelladdr(ifp, rt, m, dst, (u_char *)edst))
274: return (0); /* it must be impossible, but... */
275: etype = htons(ETHERTYPE_IPV6);
276: break;
277: #endif
278: #ifdef NETATALK
279: case AF_APPLETALK: {
280: struct at_ifaddr *aa;
281:
282: if (!aarpresolve(ac, m, (struct sockaddr_at *)dst, edst)) {
283: #ifdef NETATALKDEBUG
284: extern char *prsockaddr(struct sockaddr *);
285: printf("aarpresolv: failed for %s\n", prsockaddr(dst));
286: #endif /* NETATALKDEBUG */
287: return (0);
288: }
289:
290: /*
291: * ifaddr is the first thing in at_ifaddr
292: */
293: aa = (struct at_ifaddr *)at_ifawithnet(
294: (struct sockaddr_at *)dst,
295: TAILQ_FIRST(&ifp->if_addrlist));
296: if (aa == 0)
297: goto bad;
298:
299: /*
300: * In the phase 2 case, we need to prepend an mbuf for the llc
301: * header. Since we must preserve the value of m, which is
302: * passed to us by value, we m_copy() the first mbuf,
303: * and use it for our llc header.
304: */
305: if (aa->aa_flags & AFA_PHASE2) {
306: struct llc llc;
307:
308: M_PREPEND(m, AT_LLC_SIZE, M_DONTWAIT);
309: if (m == NULL)
310: return (0);
311: /*
312: * FreeBSD doesn't count the LLC len in
313: * ifp->obytes, so they increment a length
314: * field here. We don't do this.
315: */
316: llc.llc_dsap = llc.llc_ssap = LLC_SNAP_LSAP;
317: llc.llc_control = LLC_UI;
318: bcopy(at_org_code, llc.llc_snap.org_code,
319: sizeof(at_org_code));
320: llc.llc_snap.ether_type = htons( ETHERTYPE_AT );
321: bcopy(&llc, mtod(m, caddr_t), AT_LLC_SIZE);
322: etype = htons(m->m_pkthdr.len);
323: } else {
324: etype = htons(ETHERTYPE_AT);
325: }
326: } break;
327: #endif /* NETATALK */
328: case pseudo_AF_HDRCMPLT:
329: hdrcmplt = 1;
330: eh = (struct ether_header *)dst->sa_data;
331: bcopy((caddr_t)eh->ether_shost, (caddr_t)esrc, sizeof(esrc));
332: /* FALLTHROUGH */
333:
334: case AF_UNSPEC:
335: eh = (struct ether_header *)dst->sa_data;
336: bcopy((caddr_t)eh->ether_dhost, (caddr_t)edst, sizeof(edst));
337: /* AF_UNSPEC doesn't swap the byte order of the ether_type. */
338: etype = eh->ether_type;
339: break;
340:
341: default:
342: printf("%s: can't handle af%d\n", ifp->if_xname,
343: dst->sa_family);
344: senderr(EAFNOSUPPORT);
345: }
346:
347: /* XXX Should we feed-back an unencrypted IPsec packet ? */
348: if (mcopy)
349: (void) looutput(ifp, mcopy, dst, rt);
350:
351: /*
352: * Add local net header. If no space in first mbuf,
353: * allocate another.
354: */
355: M_PREPEND(m, ETHER_HDR_LEN, M_DONTWAIT);
356: if (m == 0)
357: senderr(ENOBUFS);
358: eh = mtod(m, struct ether_header *);
359: bcopy((caddr_t)&etype,(caddr_t)&eh->ether_type,
360: sizeof(eh->ether_type));
361: bcopy((caddr_t)edst, (caddr_t)eh->ether_dhost, sizeof(edst));
362: if (hdrcmplt)
363: bcopy((caddr_t)esrc, (caddr_t)eh->ether_shost,
364: sizeof(eh->ether_shost));
365: else
366: bcopy((caddr_t)ac->ac_enaddr, (caddr_t)eh->ether_shost,
367: sizeof(eh->ether_shost));
368:
369: #if NCARP > 0
370: if (ifp0 != ifp && ifp0->if_type == IFT_CARP &&
371: !(ifp0->if_flags & IFF_LINK1)) {
372: bcopy((caddr_t)((struct arpcom *)ifp0)->ac_enaddr,
373: (caddr_t)eh->ether_shost, sizeof(eh->ether_shost));
374: }
375: #endif
376:
377: #if NBRIDGE > 0
378: /*
379: * Interfaces that are bridge members need special handling
380: * for output.
381: */
382: if (ifp->if_bridge) {
383: struct m_tag *mtag;
384:
385: /*
386: * Check if this packet has already been sent out through
387: * this bridge, in which case we simply send it out
388: * without further bridge processing.
389: */
390: for (mtag = m_tag_find(m, PACKET_TAG_BRIDGE, NULL); mtag;
391: mtag = m_tag_find(m, PACKET_TAG_BRIDGE, mtag)) {
392: #ifdef DEBUG
393: /* Check that the information is there */
394: if (mtag->m_tag_len != sizeof(caddr_t)) {
395: error = EINVAL;
396: goto bad;
397: }
398: #endif
399: if (!bcmp(&ifp->if_bridge, mtag + 1, sizeof(caddr_t)))
400: break;
401: }
402: if (mtag == NULL) {
403: /* Attach a tag so we can detect loops */
404: mtag = m_tag_get(PACKET_TAG_BRIDGE, sizeof(caddr_t),
405: M_NOWAIT);
406: if (mtag == NULL) {
407: error = ENOBUFS;
408: goto bad;
409: }
410: bcopy(&ifp->if_bridge, mtag + 1, sizeof(caddr_t));
411: m_tag_prepend(m, mtag);
412: error = bridge_output(ifp, m, NULL, NULL);
413: return (error);
414: }
415: }
416: #endif
417:
418: mflags = m->m_flags;
419: len = m->m_pkthdr.len;
420: s = splnet();
421: /*
422: * Queue message on interface, and start output if interface
423: * not yet active.
424: */
425: IFQ_ENQUEUE(&ifp->if_snd, m, NULL, error);
426: if (error) {
427: /* mbuf is already freed */
428: splx(s);
429: return (error);
430: }
431: ifp->if_obytes += len + ETHER_HDR_LEN;
432: #if NCARP > 0
433: if (ifp != ifp0)
434: ifp0->if_obytes += len + ETHER_HDR_LEN;
435: #endif /* NCARP > 0 */
436: if (mflags & M_MCAST)
437: ifp->if_omcasts++;
438: if ((ifp->if_flags & IFF_OACTIVE) == 0)
439: (*ifp->if_start)(ifp);
440: splx(s);
441: return (error);
442:
443: bad:
444: if (m)
445: m_freem(m);
446: return (error);
447: }
448:
449: /*
450: * Process a received Ethernet packet;
451: * the packet is in the mbuf chain m without
452: * the ether header, which is provided separately.
453: */
454: void
455: ether_input(ifp, eh, m)
456: struct ifnet *ifp;
457: struct ether_header *eh;
458: struct mbuf *m;
459: {
460: struct ifqueue *inq;
461: u_int16_t etype;
462: int s, llcfound = 0;
463: struct llc *l;
464: struct arpcom *ac;
465: #if NTRUNK > 0
466: int i = 0;
467: #endif
468: #if NPPPOE > 0
469: struct ether_header *eh_tmp;
470: #endif
471:
472: if (eh == NULL) {
473: eh = mtod(m, struct ether_header *);
474: m_adj(m, ETHER_HDR_LEN);
475: }
476:
477: #if NTRUNK > 0
478: /* Handle input from a trunk port */
479: while (ifp->if_type == IFT_IEEE8023ADLAG) {
480: if (++i > TRUNK_MAX_STACKING ||
481: trunk_input(ifp, eh, m) != 0) {
482: if (m)
483: m_freem(m);
484: return;
485: }
486:
487: /* Has been set to the trunk interface */
488: ifp = m->m_pkthdr.rcvif;
489: }
490: #endif
491:
492: if ((ifp->if_flags & IFF_UP) == 0) {
493: m_freem(m);
494: return;
495: }
496: if (ETHER_IS_MULTICAST(eh->ether_dhost)) {
497: if ((ifp->if_flags & IFF_SIMPLEX) == 0) {
498: struct ifaddr *ifa;
499: struct sockaddr_dl *sdl = NULL;
500:
501: TAILQ_FOREACH(ifa, &ifp->if_addrlist, ifa_list) {
502: if ((sdl =
503: (struct sockaddr_dl *)ifa->ifa_addr) &&
504: sdl->sdl_family == AF_LINK)
505: break;
506: }
507: /*
508: * If this is not a simplex interface, drop the packet
509: * if it came from us.
510: */
511: if (sdl && bcmp(LLADDR(sdl), eh->ether_shost,
512: ETHER_ADDR_LEN) == 0) {
513: m_freem(m);
514: return;
515: }
516: }
517:
518: if (bcmp((caddr_t)etherbroadcastaddr, (caddr_t)eh->ether_dhost,
519: sizeof(etherbroadcastaddr)) == 0)
520: m->m_flags |= M_BCAST;
521: else
522: m->m_flags |= M_MCAST;
523: ifp->if_imcasts++;
524: }
525:
526: ifp->if_ibytes += m->m_pkthdr.len + sizeof(*eh);
527:
528: etype = ntohs(eh->ether_type);
529:
530: #if NVLAN > 0
531: if (etype == ETHERTYPE_VLAN && (vlan_input(eh, m) == 0))
532: return;
533: #endif
534:
535: #if NBRIDGE > 0
536: /*
537: * Tap the packet off here for a bridge, if configured and
538: * active for this interface. bridge_input returns
539: * NULL if it has consumed the packet, otherwise, it
540: * gets processed as normal.
541: */
542: if (ifp->if_bridge) {
543: if (m->m_flags & M_PROTO1)
544: m->m_flags &= ~M_PROTO1;
545: else {
546: m = bridge_input(ifp, eh, m);
547: if (m == NULL)
548: return;
549: /* The bridge has determined it's for us. */
550: ifp = m->m_pkthdr.rcvif;
551: }
552: }
553: #endif
554:
555: #if NVLAN > 0
556: if (etype == ETHERTYPE_VLAN) {
557: /* The bridge did not want the vlan frame either, drop it. */
558: ifp->if_noproto++;
559: m_freem(m);
560: return;
561: }
562: #endif /* NVLAN > 0 */
563:
564: #if NCARP > 0
565: if (ifp->if_carp) {
566: if (ifp->if_type != IFT_CARP &&
567: (carp_input(m, (u_int8_t *)&eh->ether_shost,
568: (u_int8_t *)&eh->ether_dhost, eh->ether_type) == 0))
569: return;
570: /* Always clear multicast flags if received on a carp address */
571: else if (ifp->if_type == IFT_CARP &&
572: ifp->if_flags & IFF_LINK2 &&
573: m->m_flags & (M_BCAST|M_MCAST) &&
574: !bcmp(((struct arpcom *)ifp)->ac_enaddr,
575: (caddr_t)eh->ether_dhost, ETHER_ADDR_LEN))
576: m->m_flags &= ~(M_BCAST|M_MCAST);
577: }
578: #endif /* NCARP > 0 */
579:
580: ac = (struct arpcom *)ifp;
581:
582: /*
583: * If packet has been filtered by the bpf listener, drop it now
584: */
585: if (m->m_flags & M_FILDROP) {
586: m_free(m);
587: return;
588: }
589:
590: /*
591: * If packet is unicast and we're in promiscuous mode, make sure it
592: * is for us. Drop otherwise.
593: */
594: if ((m->m_flags & (M_BCAST|M_MCAST)) == 0 &&
595: (ifp->if_flags & IFF_PROMISC)) {
596: if (bcmp(ac->ac_enaddr, (caddr_t)eh->ether_dhost,
597: ETHER_ADDR_LEN)) {
598: m_freem(m);
599: return;
600: }
601: }
602:
603: decapsulate:
604:
605: switch (etype) {
606: #ifdef INET
607: case ETHERTYPE_IP:
608: schednetisr(NETISR_IP);
609: inq = &ipintrq;
610: break;
611:
612: case ETHERTYPE_ARP:
613: if (ifp->if_flags & IFF_NOARP)
614: goto dropanyway;
615: schednetisr(NETISR_ARP);
616: inq = &arpintrq;
617: break;
618:
619: case ETHERTYPE_REVARP:
620: if (ifp->if_flags & IFF_NOARP)
621: goto dropanyway;
622: revarpinput(m); /* XXX queue? */
623: return;
624:
625: #endif
626: #ifdef INET6
627: /*
628: * Schedule IPv6 software interrupt for incoming IPv6 packet.
629: */
630: case ETHERTYPE_IPV6:
631: schednetisr(NETISR_IPV6);
632: inq = &ip6intrq;
633: break;
634: #endif /* INET6 */
635: #ifdef NETATALK
636: case ETHERTYPE_AT:
637: schednetisr(NETISR_ATALK);
638: inq = &atintrq1;
639: break;
640: case ETHERTYPE_AARP:
641: /* probably this should be done with a NETISR as well */
642: /* XXX queue this */
643: aarpinput((struct arpcom *)ifp, m);
644: return;
645: #endif
646: #if NPPPOE > 0
647: case ETHERTYPE_PPPOEDISC:
648: case ETHERTYPE_PPPOE:
649: /* XXX we dont have this flag */
650: /*
651: if (m->m_flags & M_PROMISC) {
652: m_freem(m);
653: return;
654: }
655: */
656: #ifndef PPPOE_SERVER
657: if (m->m_flags & (M_MCAST | M_BCAST)) {
658: m_freem(m);
659: return;
660: }
661: #endif
662: M_PREPEND(m, sizeof(*eh), M_DONTWAIT);
663: if (m == NULL)
664: return;
665:
666: eh_tmp = mtod(m, struct ether_header *);
667: bcopy(eh, eh_tmp, sizeof(struct ether_header));
668:
669: if (etype == ETHERTYPE_PPPOEDISC)
670: inq = &ppoediscinq;
671: else
672: inq = &ppoeinq;
673:
674: schednetisr(NETISR_PPPOE);
675: break;
676: #endif /* NPPPOE > 0 */
677: default:
678: if (llcfound || etype > ETHERMTU)
679: goto dropanyway;
680: llcfound = 1;
681: l = mtod(m, struct llc *);
682: switch (l->llc_dsap) {
683: case LLC_SNAP_LSAP:
684: #ifdef NETATALK
685: /*
686: * Some protocols (like Appletalk) need special
687: * handling depending on if they are type II
688: * or SNAP encapsulated. Everything else
689: * gets handled by stripping off the SNAP header
690: * and going back up to decapsulate.
691: */
692: if (l->llc_control == LLC_UI &&
693: l->llc_ssap == LLC_SNAP_LSAP &&
694: Bcmp(&(l->llc_snap.org_code)[0],
695: at_org_code, sizeof(at_org_code)) == 0 &&
696: ntohs(l->llc_snap.ether_type) == ETHERTYPE_AT) {
697: inq = &atintrq2;
698: m_adj(m, AT_LLC_SIZE);
699: schednetisr(NETISR_ATALK);
700: break;
701: }
702:
703: if (l->llc_control == LLC_UI &&
704: l->llc_ssap == LLC_SNAP_LSAP &&
705: Bcmp(&(l->llc_snap.org_code)[0],
706: aarp_org_code, sizeof(aarp_org_code)) == 0 &&
707: ntohs(l->llc_snap.ether_type) == ETHERTYPE_AARP) {
708: m_adj(m, AT_LLC_SIZE);
709: /* XXX Really this should use netisr too */
710: aarpinput((struct arpcom *)ifp, m);
711: return;
712: }
713: #endif /* NETATALK */
714: if (l->llc_control == LLC_UI &&
715: l->llc_dsap == LLC_SNAP_LSAP &&
716: l->llc_ssap == LLC_SNAP_LSAP) {
717: /* SNAP */
718: if (m->m_pkthdr.len > etype)
719: m_adj(m, etype - m->m_pkthdr.len);
720: m->m_data += 6; /* XXX */
721: m->m_len -= 6; /* XXX */
722: m->m_pkthdr.len -= 6; /* XXX */
723: M_PREPEND(m, sizeof(*eh), M_DONTWAIT);
724: if (m == 0)
725: return;
726: *mtod(m, struct ether_header *) = *eh;
727: goto decapsulate;
728: }
729: goto dropanyway;
730: dropanyway:
731: default:
732: m_freem(m);
733: return;
734: }
735: }
736:
737: s = splnet();
738: IF_INPUT_ENQUEUE(inq, m);
739: splx(s);
740: }
741:
742: /*
743: * Convert Ethernet address to printable (loggable) representation.
744: */
745: static char digits[] = "0123456789abcdef";
746: char *
747: ether_sprintf(ap)
748: u_char *ap;
749: {
750: int i;
751: static char etherbuf[ETHER_ADDR_LEN * 3];
752: char *cp = etherbuf;
753:
754: for (i = 0; i < ETHER_ADDR_LEN; i++) {
755: *cp++ = digits[*ap >> 4];
756: *cp++ = digits[*ap++ & 0xf];
757: *cp++ = ':';
758: }
759: *--cp = 0;
760: return (etherbuf);
761: }
762:
763: /*
764: * Perform common duties while attaching to interface list
765: */
766: void
767: ether_ifattach(ifp)
768: struct ifnet *ifp;
769: {
770:
771: /*
772: * Any interface which provides a MAC address which is obviously
773: * invalid gets whacked, so that users will notice.
774: */
775: if (ETHER_IS_MULTICAST(((struct arpcom *)ifp)->ac_enaddr)) {
776: ((struct arpcom *)ifp)->ac_enaddr[0] = 0x00;
777: ((struct arpcom *)ifp)->ac_enaddr[1] = 0xfe;
778: ((struct arpcom *)ifp)->ac_enaddr[2] = 0xe1;
779: ((struct arpcom *)ifp)->ac_enaddr[3] = 0xba;
780: ((struct arpcom *)ifp)->ac_enaddr[4] = 0xd0;
781: /*
782: * XXX use of random() by anything except the scheduler is
783: * normally invalid, but this is boot time, so pre-scheduler,
784: * and the random subsystem is not alive yet
785: */
786: ((struct arpcom *)ifp)->ac_enaddr[5] = (u_char)random() & 0xff;
787: }
788:
789: ifp->if_type = IFT_ETHER;
790: ifp->if_addrlen = ETHER_ADDR_LEN;
791: ifp->if_hdrlen = ETHER_HDR_LEN;
792: ifp->if_mtu = ETHERMTU;
793: ifp->if_output = ether_output;
794:
795: if (ifp->if_hardmtu == 0)
796: ifp->if_hardmtu = ETHERMTU;
797:
798: if_alloc_sadl(ifp);
799: bcopy((caddr_t)((struct arpcom *)ifp)->ac_enaddr,
800: LLADDR(ifp->if_sadl), ifp->if_addrlen);
801: LIST_INIT(&((struct arpcom *)ifp)->ac_multiaddrs);
802: #if NBPFILTER > 0
803: bpfattach(&ifp->if_bpf, ifp, DLT_EN10MB, ETHER_HDR_LEN);
804: #endif
805: }
806:
807: void
808: ether_ifdetach(ifp)
809: struct ifnet *ifp;
810: {
811: struct arpcom *ac = (struct arpcom *)ifp;
812: struct ether_multi *enm;
813:
814: for (enm = LIST_FIRST(&ac->ac_multiaddrs);
815: enm != LIST_END(&ac->ac_multiaddrs);
816: enm = LIST_FIRST(&ac->ac_multiaddrs)) {
817: LIST_REMOVE(enm, enm_list);
818: free(enm, M_IFMADDR);
819: }
820:
821: #if 0
822: /* moved to if_detach() */
823: if_free_sadl(ifp);
824: #endif
825: }
826:
827: #if 0
828: /*
829: * This is for reference. We have table-driven versions of the
830: * crc32 generators, which are faster than the double-loop.
831: */
832: u_int32_t
833: ether_crc32_le(const u_int8_t *buf, size_t len)
834: {
835: u_int32_t c, crc, carry;
836: size_t i, j;
837:
838: crc = 0xffffffffU; /* initial value */
839:
840: for (i = 0; i < len; i++) {
841: c = buf[i];
842: for (j = 0; j < 8; j++) {
843: carry = ((crc & 0x01) ? 1 : 0) ^ (c & 0x01);
844: crc >>= 1;
845: c >>= 1;
846: if (carry)
847: crc = (crc ^ ETHER_CRC_POLY_LE);
848: }
849: }
850:
851: return (crc);
852: }
853:
854: u_int32_t
855: ether_crc32_be(const u_int8_t *buf, size_t len)
856: {
857: u_int32_t c, crc, carry;
858: size_t i, j;
859:
860: crc = 0xffffffffU; /* initial value */
861:
862: for (i = 0; i < len; i++) {
863: c = buf[i];
864: for (j = 0; j < 8; j++) {
865: carry = ((crc & 0x80000000U) ? 1 : 0) ^ (c & 0x01);
866: crc <<= 1;
867: c >>= 1;
868: if (carry)
869: crc = (crc ^ ETHER_CRC_POLY_BE) | carry;
870: }
871: }
872:
873: return (crc);
874: }
875: #else
876: u_int32_t
877: ether_crc32_le(const u_int8_t *buf, size_t len)
878: {
879: static const u_int32_t crctab[] = {
880: 0x00000000, 0x1db71064, 0x3b6e20c8, 0x26d930ac,
881: 0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c,
882: 0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c,
883: 0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c
884: };
885: size_t i;
886: u_int32_t crc;
887:
888: crc = 0xffffffffU; /* initial value */
889:
890: for (i = 0; i < len; i++) {
891: crc ^= buf[i];
892: crc = (crc >> 4) ^ crctab[crc & 0xf];
893: crc = (crc >> 4) ^ crctab[crc & 0xf];
894: }
895:
896: return (crc);
897: }
898:
899: u_int32_t
900: ether_crc32_be(const u_int8_t *buf, size_t len)
901: {
902: static const u_int8_t rev[] = {
903: 0x0, 0x8, 0x4, 0xc, 0x2, 0xa, 0x6, 0xe,
904: 0x1, 0x9, 0x5, 0xd, 0x3, 0xb, 0x7, 0xf
905: };
906: static const u_int32_t crctab[] = {
907: 0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9,
908: 0x130476dc, 0x17c56b6b, 0x1a864db2, 0x1e475005,
909: 0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61,
910: 0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd
911: };
912: size_t i;
913: u_int32_t crc;
914: u_int8_t data;
915:
916: crc = 0xffffffffU; /* initial value */
917: for (i = 0; i < len; i++) {
918: data = buf[i];
919: crc = (crc << 4) ^ crctab[(crc >> 28) ^ rev[data & 0xf]];
920: crc = (crc << 4) ^ crctab[(crc >> 28) ^ rev[data >> 4]];
921: }
922:
923: return (crc);
924: }
925: #endif
926:
927: #ifdef INET
928: u_char ether_ipmulticast_min[ETHER_ADDR_LEN] =
929: { 0x01, 0x00, 0x5e, 0x00, 0x00, 0x00 };
930: u_char ether_ipmulticast_max[ETHER_ADDR_LEN] =
931: { 0x01, 0x00, 0x5e, 0x7f, 0xff, 0xff };
932: #endif
933:
934: #ifdef INET6
935: u_char ether_ip6multicast_min[ETHER_ADDR_LEN] =
936: { 0x33, 0x33, 0x00, 0x00, 0x00, 0x00 };
937: u_char ether_ip6multicast_max[ETHER_ADDR_LEN] =
938: { 0x33, 0x33, 0xff, 0xff, 0xff, 0xff };
939: #endif
940:
941: /*
942: * Convert a sockaddr into an Ethernet address or range of Ethernet
943: * addresses.
944: */
945: int
946: ether_multiaddr(struct sockaddr *sa, u_int8_t addrlo[ETHER_ADDR_LEN],
947: u_int8_t addrhi[ETHER_ADDR_LEN])
948: {
949: #ifdef INET
950: struct sockaddr_in *sin;
951: #endif /* INET */
952: #ifdef INET6
953: struct sockaddr_in6 *sin6;
954: #endif /* INET6 */
955:
956: switch (sa->sa_family) {
957:
958: case AF_UNSPEC:
959: bcopy(sa->sa_data, addrlo, ETHER_ADDR_LEN);
960: bcopy(addrlo, addrhi, ETHER_ADDR_LEN);
961: break;
962:
963: #ifdef INET
964: case AF_INET:
965: sin = satosin(sa);
966: if (sin->sin_addr.s_addr == INADDR_ANY) {
967: /*
968: * An IP address of INADDR_ANY means listen to
969: * or stop listening to all of the Ethernet
970: * multicast addresses used for IP.
971: * (This is for the sake of IP multicast routers.)
972: */
973: bcopy(ether_ipmulticast_min, addrlo, ETHER_ADDR_LEN);
974: bcopy(ether_ipmulticast_max, addrhi, ETHER_ADDR_LEN);
975: } else {
976: ETHER_MAP_IP_MULTICAST(&sin->sin_addr, addrlo);
977: bcopy(addrlo, addrhi, ETHER_ADDR_LEN);
978: }
979: break;
980: #endif
981: #ifdef INET6
982: case AF_INET6:
983: sin6 = satosin6(sa);
984: if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
985: /*
986: * An IP6 address of 0 means listen to or stop
987: * listening to all of the Ethernet multicast
988: * address used for IP6.
989: *
990: * (This might not be healthy, given IPv6's reliance on
991: * multicast for things like neighbor discovery.
992: * Perhaps initializing all-nodes, solicited nodes, and
993: * possibly all-routers for this interface afterwards
994: * is not a bad idea.)
995: */
996:
997: bcopy(ether_ip6multicast_min, addrlo, ETHER_ADDR_LEN);
998: bcopy(ether_ip6multicast_max, addrhi, ETHER_ADDR_LEN);
999: } else {
1000: ETHER_MAP_IPV6_MULTICAST(&sin6->sin6_addr, addrlo);
1001: bcopy(addrlo, addrhi, ETHER_ADDR_LEN);
1002: }
1003: break;
1004: #endif
1005:
1006: default:
1007: return (EAFNOSUPPORT);
1008: }
1009: return (0);
1010: }
1011:
1012: /*
1013: * Add an Ethernet multicast address or range of addresses to the list for a
1014: * given interface.
1015: */
1016: int
1017: ether_addmulti(ifr, ac)
1018: struct ifreq *ifr;
1019: struct arpcom *ac;
1020: {
1021: struct ether_multi *enm;
1022: u_char addrlo[ETHER_ADDR_LEN];
1023: u_char addrhi[ETHER_ADDR_LEN];
1024: int s = splnet(), error;
1025:
1026: error = ether_multiaddr(&ifr->ifr_addr, addrlo, addrhi);
1027: if (error != 0) {
1028: splx(s);
1029: return (error);
1030: }
1031:
1032: /*
1033: * Verify that we have valid Ethernet multicast addresses.
1034: */
1035: if ((addrlo[0] & 0x01) != 1 || (addrhi[0] & 0x01) != 1) {
1036: splx(s);
1037: return (EINVAL);
1038: }
1039: /*
1040: * See if the address range is already in the list.
1041: */
1042: ETHER_LOOKUP_MULTI(addrlo, addrhi, ac, enm);
1043: if (enm != NULL) {
1044: /*
1045: * Found it; just increment the reference count.
1046: */
1047: ++enm->enm_refcount;
1048: splx(s);
1049: return (0);
1050: }
1051: /*
1052: * New address or range; malloc a new multicast record
1053: * and link it into the interface's multicast list.
1054: */
1055: enm = (struct ether_multi *)malloc(sizeof(*enm), M_IFMADDR, M_NOWAIT);
1056: if (enm == NULL) {
1057: splx(s);
1058: return (ENOBUFS);
1059: }
1060: bcopy(addrlo, enm->enm_addrlo, ETHER_ADDR_LEN);
1061: bcopy(addrhi, enm->enm_addrhi, ETHER_ADDR_LEN);
1062: enm->enm_ac = ac;
1063: enm->enm_refcount = 1;
1064: LIST_INSERT_HEAD(&ac->ac_multiaddrs, enm, enm_list);
1065: ac->ac_multicnt++;
1066: if (bcmp(addrlo, addrhi, ETHER_ADDR_LEN) != 0)
1067: ac->ac_multirangecnt++;
1068: splx(s);
1069: /*
1070: * Return ENETRESET to inform the driver that the list has changed
1071: * and its reception filter should be adjusted accordingly.
1072: */
1073: return (ENETRESET);
1074: }
1075:
1076: /*
1077: * Delete a multicast address record.
1078: */
1079: int
1080: ether_delmulti(ifr, ac)
1081: struct ifreq *ifr;
1082: struct arpcom *ac;
1083: {
1084: struct ether_multi *enm;
1085: u_char addrlo[ETHER_ADDR_LEN];
1086: u_char addrhi[ETHER_ADDR_LEN];
1087: int s = splnet(), error;
1088:
1089: error = ether_multiaddr(&ifr->ifr_addr, addrlo, addrhi);
1090: if (error != 0) {
1091: splx(s);
1092: return (error);
1093: }
1094:
1095: /*
1096: * Look up the address in our list.
1097: */
1098: ETHER_LOOKUP_MULTI(addrlo, addrhi, ac, enm);
1099: if (enm == NULL) {
1100: splx(s);
1101: return (ENXIO);
1102: }
1103: if (--enm->enm_refcount != 0) {
1104: /*
1105: * Still some claims to this record.
1106: */
1107: splx(s);
1108: return (0);
1109: }
1110: /*
1111: * No remaining claims to this record; unlink and free it.
1112: */
1113: LIST_REMOVE(enm, enm_list);
1114: free(enm, M_IFMADDR);
1115: ac->ac_multicnt--;
1116: if (bcmp(addrlo, addrhi, ETHER_ADDR_LEN) != 0)
1117: ac->ac_multirangecnt--;
1118: splx(s);
1119: /*
1120: * Return ENETRESET to inform the driver that the list has changed
1121: * and its reception filter should be adjusted accordingly.
1122: */
1123: return (ENETRESET);
1124: }