Annotation of src/sys/net/if_ethersubr.c, Revision 1.126
1.126 ! bouyer 1: /* $NetBSD: if_ethersubr.c,v 1.125 2005/05/29 21:22:52 christos Exp $ */
1.44 itojun 2:
3: /*
4: * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
5: * All rights reserved.
1.120 perry 6: *
1.44 itojun 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.
1.120 perry 18: *
1.44 itojun 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: */
1.9 cgd 31:
1.1 cgd 32: /*
1.8 mycroft 33: * Copyright (c) 1982, 1989, 1993
34: * The Regents of the University of California. All rights reserved.
1.1 cgd 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.
1.113 agc 44: * 3. Neither the name of the University nor the names of its contributors
1.1 cgd 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: *
1.27 fvdl 60: * @(#)if_ethersubr.c 8.2 (Berkeley) 4/4/96
1.1 cgd 61: */
1.90 lukem 62:
63: #include <sys/cdefs.h>
1.126 ! bouyer 64: __KERNEL_RCSID(0, "$NetBSD: if_ethersubr.c,v 1.125 2005/05/29 21:22:52 christos Exp $");
1.1 cgd 65:
1.33 jonathan 66: #include "opt_inet.h"
67: #include "opt_atalk.h"
1.34 jonathan 68: #include "opt_ccitt.h"
1.35 jonathan 69: #include "opt_llc.h"
1.36 jonathan 70: #include "opt_iso.h"
1.112 martin 71: #include "opt_ipx.h"
72: #include "opt_mbuftrace.h"
1.37 jonathan 73: #include "opt_ns.h"
1.30 matt 74: #include "opt_gateway.h"
1.77 thorpej 75: #include "opt_pfil_hooks.h"
1.59 thorpej 76: #include "vlan.h"
1.81 martin 77: #include "pppoe.h"
1.78 thorpej 78: #include "bridge.h"
1.69 thorpej 79: #include "bpfilter.h"
1.93 martin 80: #include "arp.h"
1.121 yamt 81: #include "agr.h"
1.30 matt 82:
1.4 mycroft 83: #include <sys/param.h>
84: #include <sys/systm.h>
85: #include <sys/kernel.h>
1.81 martin 86: #include <sys/callout.h>
1.4 mycroft 87: #include <sys/malloc.h>
88: #include <sys/mbuf.h>
89: #include <sys/protosw.h>
90: #include <sys/socket.h>
91: #include <sys/ioctl.h>
92: #include <sys/errno.h>
93: #include <sys/syslog.h>
94:
1.8 mycroft 95: #include <machine/cpu.h>
96:
1.4 mycroft 97: #include <net/if.h>
98: #include <net/netisr.h>
99: #include <net/route.h>
100: #include <net/if_llc.h>
101: #include <net/if_dl.h>
1.8 mycroft 102: #include <net/if_types.h>
1.93 martin 103:
104: #if NARP == 0
105: /*
1.102 jmmv 106: * XXX there should really be a way to issue this warning from within config(8)
1.93 martin 107: */
1.111 martin 108: #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.
1.93 martin 109: #endif
1.1 cgd 110:
1.120 perry 111: #if NBPFILTER > 0
1.69 thorpej 112: #include <net/bpf.h>
113: #endif
114:
1.22 is 115: #include <net/if_ether.h>
1.59 thorpej 116: #if NVLAN > 0
117: #include <net/if_vlanvar.h>
118: #endif
1.22 is 119:
1.81 martin 120: #if NPPPOE > 0
121: #include <net/if_pppoe.h>
122: #endif
123:
1.121 yamt 124: #if NAGR > 0
125: #include <net/agr/ieee8023_slowprotocols.h> /* XXX */
126: #include <net/agr/ieee8023ad.h>
127: #include <net/agr/if_agrvar.h>
128: #endif
129:
1.78 thorpej 130: #if NBRIDGE > 0
131: #include <net/if_bridgevar.h>
132: #endif
133:
1.15 phil 134: #include <netinet/in.h>
1.1 cgd 135: #ifdef INET
1.4 mycroft 136: #include <netinet/in_var.h>
1.1 cgd 137: #endif
1.22 is 138: #include <netinet/if_inarp.h>
1.1 cgd 139:
1.44 itojun 140: #ifdef INET6
141: #ifndef INET
142: #include <netinet/in.h>
143: #endif
144: #include <netinet6/in6_var.h>
145: #include <netinet6/nd6.h>
146: #endif
147:
1.1 cgd 148: #ifdef NS
1.4 mycroft 149: #include <netns/ns.h>
150: #include <netns/ns_if.h>
1.1 cgd 151: #endif
152:
1.32 christos 153: #ifdef IPX
154: #include <netipx/ipx.h>
155: #include <netipx/ipx_if.h>
156: #endif
157:
1.1 cgd 158: #ifdef ISO
1.4 mycroft 159: #include <netiso/argo_debug.h>
160: #include <netiso/iso.h>
161: #include <netiso/iso_var.h>
162: #include <netiso/iso_snpac.h>
1.1 cgd 163: #endif
1.4 mycroft 164:
1.8 mycroft 165: #ifdef LLC
166: #include <netccitt/dll.h>
167: #include <netccitt/llc_var.h>
168: #endif
169:
170: #if defined(LLC) && defined(CCITT)
171: extern struct ifqueue pkintrq;
172: #endif
1.1 cgd 173:
1.23 christos 174: #ifdef NETATALK
175: #include <netatalk/at.h>
176: #include <netatalk/at_var.h>
177: #include <netatalk/at_extern.h>
178:
179: #define llc_snap_org_code llc_un.type_snap.org_code
180: #define llc_snap_ether_type llc_un.type_snap.ether_type
181:
182: extern u_char at_org_code[3];
183: extern u_char aarp_org_code[3];
184: #endif /* NETATALK */
185:
1.123 matt 186: static struct timeval bigpktppslim_last;
187: static int bigpktppslim = 2; /* XXX */
188: static int bigpktpps_count;
189:
190:
1.118 yamt 191: const uint8_t etherbroadcastaddr[ETHER_ADDR_LEN] =
192: { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1.121 yamt 193: const uint8_t ethermulticastaddr_slowprotocols[ETHER_ADDR_LEN] =
194: { 0x01, 0x80, 0xc2, 0x00, 0x00, 0x02 };
1.8 mycroft 195: #define senderr(e) { error = (e); goto bad;}
1.1 cgd 196:
1.22 is 197: #define SIN(x) ((struct sockaddr_in *)x)
198:
1.42 thorpej 199: static int ether_output __P((struct ifnet *, struct mbuf *,
200: struct sockaddr *, struct rtentry *));
201: static void ether_input __P((struct ifnet *, struct mbuf *));
202:
1.1 cgd 203: /*
204: * Ethernet output routine.
205: * Encapsulate a packet of type family for the local net.
1.22 is 206: * Assumes that ifp is actually pointer to ethercom structure.
1.1 cgd 207: */
1.42 thorpej 208: static int
1.58 matt 209: ether_output(struct ifnet *ifp, struct mbuf *m0, struct sockaddr *dst,
210: struct rtentry *rt0)
1.1 cgd 211: {
1.49 matt 212: u_int16_t etype = 0;
1.122 christos 213: int error = 0, hdrcmplt = 0;
1.31 thorpej 214: u_char esrc[6], edst[6];
1.29 mrg 215: struct mbuf *m = m0;
216: struct rtentry *rt;
1.1 cgd 217: struct mbuf *mcopy = (struct mbuf *)0;
1.29 mrg 218: struct ether_header *eh;
1.72 thorpej 219: ALTQ_DECL(struct altq_pktattr pktattr;)
1.24 christos 220: #ifdef INET
1.22 is 221: struct arphdr *ah;
1.24 christos 222: #endif /* INET */
1.23 christos 223: #ifdef NETATALK
224: struct at_ifaddr *aa;
225: #endif /* NETATALK */
1.1 cgd 226:
1.104 matt 227: #ifdef MBUFTRACE
1.116 jonathan 228: m_claimm(m, ifp->if_mowner);
1.104 matt 229: #endif
1.8 mycroft 230: if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING))
231: senderr(ENETDOWN);
1.18 christos 232: if ((rt = rt0) != NULL) {
1.8 mycroft 233: if ((rt->rt_flags & RTF_UP) == 0) {
1.27 fvdl 234: if ((rt0 = rt = rtalloc1(dst, 1)) != NULL) {
1.8 mycroft 235: rt->rt_refcnt--;
1.27 fvdl 236: if (rt->rt_ifp != ifp)
237: return (*rt->rt_ifp->if_output)
238: (ifp, m0, dst, rt);
1.120 perry 239: } else
1.8 mycroft 240: senderr(EHOSTUNREACH);
241: }
1.27 fvdl 242: if ((rt->rt_flags & RTF_GATEWAY) && dst->sa_family != AF_NS) {
1.8 mycroft 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);
248: if ((rt = rt->rt_gwroute) == 0)
249: senderr(EHOSTUNREACH);
1.27 fvdl 250: /* the "G" test below also prevents rt == rt0 */
251: if ((rt->rt_flags & RTF_GATEWAY) ||
252: (rt->rt_ifp != ifp)) {
253: rt->rt_refcnt--;
254: rt0->rt_gwroute = 0;
255: senderr(EHOSTUNREACH);
256: }
1.8 mycroft 257: }
258: }
259: if (rt->rt_flags & RTF_REJECT)
260: if (rt->rt_rmx.rmx_expire == 0 ||
1.98 thorpej 261: (u_long) time.tv_sec < rt->rt_rmx.rmx_expire)
1.8 mycroft 262: senderr(rt == rt0 ? EHOSTDOWN : EHOSTUNREACH);
1.1 cgd 263: }
1.72 thorpej 264:
1.1 cgd 265: switch (dst->sa_family) {
266:
267: #ifdef INET
268: case AF_INET:
1.22 is 269: if (m->m_flags & M_BCAST)
1.125 christos 270: (void)memcpy(edst, etherbroadcastaddr, sizeof(edst));
1.22 is 271:
272: else if (m->m_flags & M_MCAST) {
273: ETHER_MAP_IP_MULTICAST(&SIN(dst)->sin_addr,
274: (caddr_t)edst)
275:
276: } else if (!arpresolve(ifp, rt, m, dst, edst))
1.1 cgd 277: return (0); /* if not yet resolved */
1.3 hpeyerl 278: /* If broadcasting on a simplex interface, loopback a copy */
279: if ((m->m_flags & M_BCAST) && (ifp->if_flags & IFF_SIMPLEX))
1.1 cgd 280: mcopy = m_copy(m, 0, (int)M_COPYALL);
1.17 mycroft 281: etype = htons(ETHERTYPE_IP);
1.8 mycroft 282: break;
1.22 is 283:
284: case AF_ARP:
285: ah = mtod(m, struct arphdr *);
286: if (m->m_flags & M_BCAST)
1.125 christos 287: (void)memcpy(edst, etherbroadcastaddr, sizeof(edst));
1.22 is 288: else
289: bcopy((caddr_t)ar_tha(ah),
290: (caddr_t)edst, sizeof(edst));
1.120 perry 291:
1.22 is 292: ah->ar_hrd = htons(ARPHRD_ETHER);
293:
1.107 itojun 294: switch (ntohs(ah->ar_op)) {
1.22 is 295: case ARPOP_REVREQUEST:
296: case ARPOP_REVREPLY:
297: etype = htons(ETHERTYPE_REVARP);
298: break;
299:
300: case ARPOP_REQUEST:
301: case ARPOP_REPLY:
302: default:
303: etype = htons(ETHERTYPE_ARP);
304: }
305:
306: break;
1.1 cgd 307: #endif
1.44 itojun 308: #ifdef INET6
309: case AF_INET6:
1.51 itojun 310: if (!nd6_storelladdr(ifp, rt, m, dst, (u_char *)edst)){
1.67 itojun 311: /* something bad happened */
1.99 itojun 312: return (0);
1.51 itojun 313: }
1.44 itojun 314: etype = htons(ETHERTYPE_IPV6);
315: break;
316: #endif
1.23 christos 317: #ifdef NETATALK
318: case AF_APPLETALK:
319: if (!aarpresolve(ifp, m, (struct sockaddr_at *)dst, edst)) {
320: #ifdef NETATALKDEBUG
321: printf("aarpresolv failed\n");
322: #endif /* NETATALKDEBUG */
323: return (0);
324: }
325: /*
326: * ifaddr is the first thing in at_ifaddr
327: */
328: aa = (struct at_ifaddr *) at_ifawithnet(
1.25 christos 329: (struct sockaddr_at *)dst, ifp);
1.23 christos 330: if (aa == NULL)
331: goto bad;
1.120 perry 332:
1.23 christos 333: /*
334: * In the phase 2 case, we need to prepend an mbuf for the
335: * llc header. Since we must preserve the value of m,
336: * which is passed to us by value, we m_copy() the first
337: * mbuf, and use it for our llc header.
338: */
339: if (aa->aa_flags & AFA_PHASE2) {
340: struct llc llc;
341:
1.43 bouyer 342: M_PREPEND(m, sizeof(struct llc), M_DONTWAIT);
1.23 christos 343: llc.llc_dsap = llc.llc_ssap = LLC_SNAP_LSAP;
344: llc.llc_control = LLC_UI;
345: bcopy(at_org_code, llc.llc_snap_org_code,
346: sizeof(llc.llc_snap_org_code));
1.38 kim 347: llc.llc_snap_ether_type = htons(ETHERTYPE_ATALK);
1.23 christos 348: bcopy(&llc, mtod(m, caddr_t), sizeof(struct llc));
349: } else {
1.38 kim 350: etype = htons(ETHERTYPE_ATALK);
1.23 christos 351: }
352: break;
353: #endif /* NETATALK */
1.1 cgd 354: #ifdef NS
355: case AF_NS:
1.17 mycroft 356: etype = htons(ETHERTYPE_NS);
1.1 cgd 357: bcopy((caddr_t)&(((struct sockaddr_ns *)dst)->sns_addr.x_host),
358: (caddr_t)edst, sizeof (edst));
359: if (!bcmp((caddr_t)edst, (caddr_t)&ns_thishost, sizeof(edst)))
360: return (looutput(ifp, m, dst, rt));
1.3 hpeyerl 361: /* If broadcasting on a simplex interface, loopback a copy */
362: if ((m->m_flags & M_BCAST) && (ifp->if_flags & IFF_SIMPLEX))
1.1 cgd 363: mcopy = m_copy(m, 0, (int)M_COPYALL);
1.8 mycroft 364: break;
1.1 cgd 365: #endif
1.32 christos 366: #ifdef IPX
367: case AF_IPX:
1.39 christos 368: etype = htons(ETHERTYPE_IPX);
369: bcopy((caddr_t)&(((struct sockaddr_ipx *)dst)->sipx_addr.x_host),
1.32 christos 370: (caddr_t)edst, sizeof (edst));
371: /* If broadcasting on a simplex interface, loopback a copy */
372: if ((m->m_flags & M_BCAST) && (ifp->if_flags & IFF_SIMPLEX))
373: mcopy = m_copy(m, 0, (int)M_COPYALL);
374: break;
375: #endif
1.1 cgd 376: #ifdef ISO
377: case AF_ISO: {
378: int snpalen;
379: struct llc *l;
1.29 mrg 380: struct sockaddr_dl *sdl;
1.1 cgd 381:
1.8 mycroft 382: if (rt && (sdl = (struct sockaddr_dl *)rt->rt_gateway) &&
383: sdl->sdl_family == AF_LINK && sdl->sdl_alen > 0) {
384: bcopy(LLADDR(sdl), (caddr_t)edst, sizeof(edst));
1.18 christos 385: } else {
386: error = iso_snparesolve(ifp, (struct sockaddr_iso *)dst,
387: (char *)edst, &snpalen);
388: if (error)
389: goto bad; /* Not Resolved */
390: }
1.3 hpeyerl 391: /* If broadcasting on a simplex interface, loopback a copy */
1.8 mycroft 392: if (*edst & 1)
393: m->m_flags |= (M_BCAST|M_MCAST);
1.3 hpeyerl 394: if ((m->m_flags & M_BCAST) && (ifp->if_flags & IFF_SIMPLEX) &&
1.1 cgd 395: (mcopy = m_copy(m, 0, (int)M_COPYALL))) {
396: M_PREPEND(mcopy, sizeof (*eh), M_DONTWAIT);
397: if (mcopy) {
398: eh = mtod(mcopy, struct ether_header *);
399: bcopy((caddr_t)edst,
400: (caddr_t)eh->ether_dhost, sizeof (edst));
1.22 is 401: bcopy(LLADDR(ifp->if_sadl),
1.1 cgd 402: (caddr_t)eh->ether_shost, sizeof (edst));
403: }
404: }
405: M_PREPEND(m, 3, M_DONTWAIT);
406: if (m == NULL)
407: return (0);
408: l = mtod(m, struct llc *);
409: l->llc_dsap = l->llc_ssap = LLC_ISO_LSAP;
410: l->llc_control = LLC_UI;
1.18 christos 411: #ifdef ARGO_DEBUG
412: if (argo_debug[D_ETHER]) {
1.1 cgd 413: int i;
1.21 christos 414: printf("unoutput: sending pkt to: ");
1.1 cgd 415: for (i=0; i<6; i++)
1.21 christos 416: printf("%x ", edst[i] & 0xff);
417: printf("\n");
1.18 christos 418: }
419: #endif
1.8 mycroft 420: } break;
421: #endif /* ISO */
422: #ifdef LLC
423: /* case AF_NSAP: */
424: case AF_CCITT: {
1.120 perry 425: struct sockaddr_dl *sdl =
1.8 mycroft 426: (struct sockaddr_dl *) rt -> rt_gateway;
427:
428: if (sdl && sdl->sdl_family == AF_LINK
429: && sdl->sdl_alen > 0) {
430: bcopy(LLADDR(sdl), (char *)edst,
431: sizeof(edst));
432: } else goto bad; /* Not a link interface ? Funny ... */
433: if ((ifp->if_flags & IFF_SIMPLEX) && (*edst & 1) &&
434: (mcopy = m_copy(m, 0, (int)M_COPYALL))) {
435: M_PREPEND(mcopy, sizeof (*eh), M_DONTWAIT);
436: if (mcopy) {
437: eh = mtod(mcopy, struct ether_header *);
438: bcopy((caddr_t)edst,
439: (caddr_t)eh->ether_dhost, sizeof (edst));
1.22 is 440: bcopy(LLADDR(ifp->if_sadl),
1.8 mycroft 441: (caddr_t)eh->ether_shost, sizeof (edst));
442: }
1.3 hpeyerl 443: }
1.8 mycroft 444: #ifdef LLC_DEBUG
445: {
446: int i;
1.29 mrg 447: struct llc *l = mtod(m, struct llc *);
1.8 mycroft 448:
1.21 christos 449: printf("ether_output: sending LLC2 pkt to: ");
1.8 mycroft 450: for (i=0; i<6; i++)
1.21 christos 451: printf("%x ", edst[i] & 0xff);
1.120 perry 452: printf(" len 0x%x dsap 0x%x ssap 0x%x control 0x%x\n",
1.17 mycroft 453: m->m_pkthdr.len, l->llc_dsap & 0xff, l->llc_ssap &0xff,
454: l->llc_control & 0xff);
1.8 mycroft 455:
456: }
457: #endif /* LLC_DEBUG */
458: } break;
1.120 perry 459: #endif /* LLC */
1.1 cgd 460:
1.31 thorpej 461: case pseudo_AF_HDRCMPLT:
462: hdrcmplt = 1;
463: eh = (struct ether_header *)dst->sa_data;
464: bcopy((caddr_t)eh->ether_shost, (caddr_t)esrc, sizeof (esrc));
465: /* FALLTHROUGH */
466:
1.1 cgd 467: case AF_UNSPEC:
468: eh = (struct ether_header *)dst->sa_data;
469: bcopy((caddr_t)eh->ether_dhost, (caddr_t)edst, sizeof (edst));
1.8 mycroft 470: /* AF_UNSPEC doesn't swap the byte order of the ether_type. */
1.17 mycroft 471: etype = eh->ether_type;
1.8 mycroft 472: break;
1.1 cgd 473:
474: default:
1.21 christos 475: printf("%s: can't handle af%d\n", ifp->if_xname,
1.1 cgd 476: dst->sa_family);
1.8 mycroft 477: senderr(EAFNOSUPPORT);
1.1 cgd 478: }
479:
480: if (mcopy)
481: (void) looutput(ifp, mcopy, dst, rt);
1.16 mycroft 482:
1.50 matt 483: /* If no ether type is set, this must be a 802.2 formatted packet.
484: */
485: if (etype == 0)
486: etype = htons(m->m_pkthdr.len);
1.1 cgd 487: /*
488: * Add local net header. If no space in first mbuf,
489: * allocate another.
490: */
491: M_PREPEND(m, sizeof (struct ether_header), M_DONTWAIT);
1.8 mycroft 492: if (m == 0)
493: senderr(ENOBUFS);
1.1 cgd 494: eh = mtod(m, struct ether_header *);
1.96 thorpej 495: /* Note: etype is already in network byte order. */
496: #ifdef __NO_STRICT_ALIGNMENT
1.97 kristerw 497: eh->ether_type = etype;
1.96 thorpej 498: #else
499: {
500: uint8_t *dstp = (uint8_t *) &eh->ether_type;
501: #if BYTE_ORDER == BIG_ENDIAN
502: dstp[0] = etype >> 8;
1.120 perry 503: dstp[1] = etype;
1.96 thorpej 504: #else
505: dstp[0] = etype;
506: dstp[1] = etype >> 8;
507: #endif /* BYTE_ORDER == BIG_ENDIAN */
508: }
509: #endif /* __NO_STRICT_ALIGNMENT */
1.1 cgd 510: bcopy((caddr_t)edst, (caddr_t)eh->ether_dhost, sizeof (edst));
1.31 thorpej 511: if (hdrcmplt)
512: bcopy((caddr_t)esrc, (caddr_t)eh->ether_shost,
513: sizeof(eh->ether_shost));
514: else
515: bcopy(LLADDR(ifp->if_sadl), (caddr_t)eh->ether_shost,
516: sizeof(eh->ether_shost));
1.77 thorpej 517:
518: #ifdef PFIL_HOOKS
519: if ((error = pfil_run_hooks(&ifp->if_pfil, &m, ifp, PFIL_OUT)) != 0)
520: return (error);
521: if (m == NULL)
522: return (0);
523: #endif
524:
1.78 thorpej 525: #if NBRIDGE > 0
526: /*
527: * Bridges require special output handling.
528: */
529: if (ifp->if_bridge)
530: return (bridge_output(ifp, m, NULL, NULL));
531: #endif
532:
1.77 thorpej 533: #ifdef ALTQ
534: /*
535: * If ALTQ is enabled on the parent interface, do
536: * classification; the queueing discipline might not
537: * require classification, but might require the
538: * address family/header pointer in the pktattr.
539: */
540: if (ALTQ_IS_ENABLED(&ifp->if_snd))
541: altq_etherclassify(&ifp->if_snd, m, &pktattr);
542: #endif
543:
1.122 christos 544: return ifq_enqueue(ifp, m ALTQ_COMMA ALTQ_DECL(&pktattr));
1.1 cgd 545:
546: bad:
547: if (m)
548: m_freem(m);
549: return (error);
550: }
1.76 thorpej 551:
552: #ifdef ALTQ
553: /*
554: * This routine is a slight hack to allow a packet to be classified
555: * if the Ethernet headers are present. It will go away when ALTQ's
556: * classification engine understands link headers.
557: */
558: void
559: altq_etherclassify(struct ifaltq *ifq, struct mbuf *m,
560: struct altq_pktattr *pktattr)
561: {
562: struct ether_header *eh;
563: u_int16_t ether_type;
564: int hlen, af, hdrsize;
565: caddr_t hdr;
566:
567: hlen = ETHER_HDR_LEN;
568: eh = mtod(m, struct ether_header *);
569:
570: ether_type = htons(eh->ether_type);
571:
572: if (ether_type < ETHERMTU) {
573: /* LLC/SNAP */
574: struct llc *llc = (struct llc *)(eh + 1);
575: hlen += 8;
576:
577: if (m->m_len < hlen ||
578: llc->llc_dsap != LLC_SNAP_LSAP ||
579: llc->llc_ssap != LLC_SNAP_LSAP ||
580: llc->llc_control != LLC_UI) {
581: /* Not SNAP. */
582: goto bad;
583: }
584:
585: ether_type = htons(llc->llc_un.type_snap.ether_type);
586: }
587:
588: switch (ether_type) {
589: case ETHERTYPE_IP:
590: af = AF_INET;
591: hdrsize = 20; /* sizeof(struct ip) */
592: break;
593:
594: case ETHERTYPE_IPV6:
595: af = AF_INET6;
596: hdrsize = 40; /* sizeof(struct ip6_hdr) */
597: break;
598:
599: default:
600: af = AF_UNSPEC;
601: hdrsize = 0;
602: break;
603: }
604:
1.95 itojun 605: while (m->m_len <= hlen) {
606: hlen -= m->m_len;
607: m = m->m_next;
608: }
1.76 thorpej 609: if (m->m_len < (hlen + hdrsize)) {
610: /*
1.95 itojun 611: * protocol header not in a single mbuf.
612: * We can't cope with this situation right
1.76 thorpej 613: * now (but it shouldn't ever happen, really, anyhow).
614: */
1.92 itojun 615: #ifdef DEBUG
1.78 thorpej 616: printf("altq_etherclassify: headers span multiple mbufs: "
617: "%d < %d\n", m->m_len, (hlen + hdrsize));
1.92 itojun 618: #endif
1.76 thorpej 619: goto bad;
620: }
621:
622: m->m_data += hlen;
623: m->m_len -= hlen;
624:
625: hdr = mtod(m, caddr_t);
626:
627: if (ALTQ_NEEDS_CLASSIFY(ifq))
628: pktattr->pattr_class =
629: (*ifq->altq_classify)(ifq->altq_clfier, m, af);
630: pktattr->pattr_af = af;
631: pktattr->pattr_hdr = hdr;
632:
633: m->m_data -= hlen;
634: m->m_len += hlen;
635:
636: return;
637:
638: bad:
639: pktattr->pattr_class = NULL;
640: pktattr->pattr_hdr = NULL;
641: pktattr->pattr_af = AF_UNSPEC;
642: }
643: #endif /* ALTQ */
1.1 cgd 644:
645: /*
646: * Process a received Ethernet packet;
1.42 thorpej 647: * the packet is in the mbuf chain m with
648: * the ether header.
1.1 cgd 649: */
1.42 thorpej 650: static void
1.58 matt 651: ether_input(struct ifnet *ifp, struct mbuf *m)
1.1 cgd 652: {
1.91 thorpej 653: struct ethercom *ec = (struct ethercom *) ifp;
1.29 mrg 654: struct ifqueue *inq;
1.18 christos 655: u_int16_t etype;
1.42 thorpej 656: struct ether_header *eh;
1.23 christos 657: #if defined (ISO) || defined (LLC) || defined(NETATALK)
1.29 mrg 658: struct llc *l;
1.18 christos 659: #endif
1.1 cgd 660:
1.8 mycroft 661: if ((ifp->if_flags & IFF_UP) == 0) {
662: m_freem(m);
663: return;
664: }
1.42 thorpej 665:
1.104 matt 666: #ifdef MBUFTRACE
1.116 jonathan 667: m_claimm(m, &ec->ec_rx_mowner);
1.104 matt 668: #endif
1.42 thorpej 669: eh = mtod(m, struct ether_header *);
1.63 thorpej 670: etype = ntohs(eh->ether_type);
671:
672: /*
673: * Determine if the packet is within its size limits.
674: */
1.83 thorpej 675: if (m->m_pkthdr.len >
676: ETHER_MAX_FRAME(ifp, etype, m->m_flags & M_HASFCS)) {
1.123 matt 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: }
1.63 thorpej 682: m_freem(m);
683: return;
684: }
1.77 thorpej 685:
1.84 thorpej 686: if (ETHER_IS_MULTICAST(eh->ether_dhost)) {
687: /*
688: * If this is not a simplex interface, drop the packet
689: * if it came from us.
690: */
691: if ((ifp->if_flags & IFF_SIMPLEX) == 0 &&
692: memcmp(LLADDR(ifp->if_sadl), eh->ether_shost,
693: ETHER_ADDR_LEN) == 0) {
694: m_freem(m);
695: return;
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: ifp->if_imcasts++;
704: }
705:
1.79 thorpej 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:
1.42 thorpej 712: ifp->if_ibytes += m->m_pkthdr.len;
1.78 thorpej 713:
714: #if NBRIDGE > 0
715: /*
716: * Tap the packet off here for a bridge. bridge_input()
717: * will return NULL if it has consumed the packet, otherwise
718: * it gets processed as normal. Note that bridge_input()
719: * will always return the original packet if we need to
720: * process it locally.
721: */
722: if (ifp->if_bridge) {
1.119 kim 723: if(m->m_flags & M_PROTO1) {
724: m->m_flags &= ~M_PROTO1;
725: } else {
726: /* clear M_PROMISC, in case the packets comes from a vlan */
727: m->m_flags &= ~M_PROMISC;
728: m = bridge_input(ifp, m);
729: if (m == NULL)
730: return;
1.78 thorpej 731:
1.119 kim 732: /*
733: * Bridge has determined that the packet is for us.
734: * Update our interface pointer -- we may have had
735: * to "bridge" the packet locally.
736: */
737: ifp = m->m_pkthdr.rcvif;
738: }
1.120 perry 739: } else
1.78 thorpej 740: #endif /* NBRIDGE > 0 */
1.106 bouyer 741: {
742: if ((m->m_flags & (M_BCAST|M_MCAST)) == 0 &&
743: (ifp->if_flags & IFF_PROMISC) != 0 &&
744: memcmp(LLADDR(ifp->if_sadl), eh->ether_dhost,
745: ETHER_ADDR_LEN) != 0) {
746: m->m_flags |= M_PROMISC;
747: }
1.70 bouyer 748: }
1.78 thorpej 749:
750: #ifdef PFIL_HOOKS
1.106 bouyer 751: if ((m->m_flags & M_PROMISC) == 0) {
752: if (pfil_run_hooks(&ifp->if_pfil, &m, ifp, PFIL_IN) != 0)
753: return;
754: if (m == NULL)
755: return;
1.78 thorpej 756:
1.106 bouyer 757: eh = mtod(m, struct ether_header *);
758: etype = ntohs(eh->ether_type);
759: }
1.78 thorpej 760: #endif
1.70 bouyer 761:
1.91 thorpej 762: /*
763: * If VLANs are configured on the interface, check to
764: * see if the device performed the decapsulation and
765: * provided us with the tag.
766: */
1.114 simonb 767: if (ec->ec_nvlans && m_tag_find(m, PACKET_TAG_VLAN, NULL) != NULL) {
1.70 bouyer 768: #if NVLAN > 0
769: /*
770: * vlan_input() will either recursively call ether_input()
771: * or drop the packet.
772: */
1.91 thorpej 773: vlan_input(ifp, m);
774: #else
775: m_freem(m);
1.70 bouyer 776: #endif
1.61 thorpej 777: return;
778: }
1.1 cgd 779:
1.121 yamt 780: #if NAGR > 0
781: if (ifp->if_agrprivate &&
782: __predict_true(etype != ETHERTYPE_SLOWPROTOCOLS)) {
783: m->m_flags &= ~M_PROMISC;
784: agr_input(ifp, m);
785: return;
786: }
787: #endif /* NAGR > 0 */
788:
1.59 thorpej 789: /*
790: * Handle protocols that expect to have the Ethernet header
791: * (and possibly FCS) intact.
792: */
793: switch (etype) {
794: #if NVLAN > 0
795: case ETHERTYPE_VLAN:
796: /*
797: * vlan_input() will either recursively call ether_input()
798: * or drop the packet.
799: */
1.63 thorpej 800: if (((struct ethercom *)ifp)->ec_nvlans != 0)
801: vlan_input(ifp, m);
1.65 enami 802: else
803: m_freem(m);
1.59 thorpej 804: return;
805: #endif /* NVLAN > 0 */
1.81 martin 806: #if NPPPOE > 0
807: case ETHERTYPE_PPPOEDISC:
808: case ETHERTYPE_PPPOE:
1.106 bouyer 809: if (m->m_flags & M_PROMISC) {
810: m_freem(m);
811: return;
812: }
1.105 aymeric 813: #ifndef PPPOE_SERVER
814: if (m->m_flags & (M_MCAST | M_BCAST)) {
815: m_freem(m);
816: return;
817: }
818: #endif
819:
1.120 perry 820: if (etype == ETHERTYPE_PPPOEDISC)
1.81 martin 821: inq = &ppoediscinq;
822: else
823: inq = &ppoeinq;
824: if (IF_QFULL(inq)) {
825: IF_DROP(inq);
826: m_freem(m);
827: } else
828: IF_ENQUEUE(inq, m);
829: #ifndef __HAVE_GENERIC_SOFT_INTERRUPTS
1.103 thorpej 830: if (!callout_pending(&pppoe_softintr))
1.81 martin 831: callout_reset(&pppoe_softintr, 1, pppoe_softintr_handler, NULL);
832: #else
833: softintr_schedule(pppoe_softintr);
834: #endif
835: return;
836: #endif /* NPPPOE > 0 */
1.121 yamt 837: case ETHERTYPE_SLOWPROTOCOLS: {
838: uint8_t subtype;
839:
840: #if defined(DIAGNOSTIC)
841: if (m->m_pkthdr.len < sizeof(*eh) + sizeof(subtype)) {
842: panic("ether_input: too short slow protocol packet");
843: }
844: #endif
845: m_copydata(m, sizeof(*eh), sizeof(subtype), &subtype);
846: switch (subtype) {
847: #if NAGR > 0
848: case SLOWPROTOCOLS_SUBTYPE_LACP:
849: if (ifp->if_agrprivate) {
850: ieee8023ad_lacp_input(ifp, m);
851: return;
852: }
853: break;
854:
855: case SLOWPROTOCOLS_SUBTYPE_MARKER:
856: if (ifp->if_agrprivate) {
857: ieee8023ad_marker_input(ifp, m);
858: return;
859: }
860: break;
861: #endif /* NAGR > 0 */
862: default:
863: if (subtype == 0 || subtype > 10) {
864: /* illegal value */
865: m_freem(m);
866: return;
867: }
868: /* unknown subtype */
869: break;
870: }
871: /* FALLTHROUGH */
872: }
1.59 thorpej 873: default:
1.106 bouyer 874: if (m->m_flags & M_PROMISC) {
875: m_freem(m);
876: return;
877: }
1.59 thorpej 878: }
1.42 thorpej 879:
880: /* Strip off the Ethernet header. */
881: m_adj(m, sizeof(struct ether_header));
1.45 thorpej 882:
883: /* If the CRC is still on the packet, trim it off. */
1.79 thorpej 884: if (m->m_flags & M_HASFCS) {
1.45 thorpej 885: m_adj(m, -ETHER_CRC_LEN);
1.79 thorpej 886: m->m_flags &= ~M_HASFCS;
887: }
1.42 thorpej 888:
1.5 deraadt 889: switch (etype) {
1.1 cgd 890: #ifdef INET
891: case ETHERTYPE_IP:
1.30 matt 892: #ifdef GATEWAY
893: if (ipflow_fastforward(m))
894: return;
895: #endif
1.1 cgd 896: schednetisr(NETISR_IP);
897: inq = &ipintrq;
898: break;
899:
900: case ETHERTYPE_ARP:
1.8 mycroft 901: schednetisr(NETISR_ARP);
902: inq = &arpintrq;
903: break;
1.7 glass 904:
905: case ETHERTYPE_REVARP:
1.8 mycroft 906: revarpinput(m); /* XXX queue? */
1.1 cgd 907: return;
908: #endif
1.44 itojun 909: #ifdef INET6
910: case ETHERTYPE_IPV6:
911: schednetisr(NETISR_IPV6);
912: inq = &ip6intrq;
913: break;
914: #endif
1.1 cgd 915: #ifdef NS
916: case ETHERTYPE_NS:
917: schednetisr(NETISR_NS);
918: inq = &nsintrq;
919: break;
920:
1.32 christos 921: #endif
922: #ifdef IPX
923: case ETHERTYPE_IPX:
924: schednetisr(NETISR_IPX);
925: inq = &ipxintrq;
926: break;
1.1 cgd 927: #endif
1.23 christos 928: #ifdef NETATALK
1.38 kim 929: case ETHERTYPE_ATALK:
1.23 christos 930: schednetisr(NETISR_ATALK);
931: inq = &atintrq1;
932: break;
933: case ETHERTYPE_AARP:
934: /* probably this should be done with a NETISR as well */
935: aarpinput(ifp, m); /* XXX */
936: return;
937: #endif /* NETATALK */
1.1 cgd 938: default:
1.23 christos 939: #if defined (ISO) || defined (LLC) || defined (NETATALK)
1.11 mycroft 940: if (etype > ETHERMTU)
1.1 cgd 941: goto dropanyway;
942: l = mtod(m, struct llc *);
1.8 mycroft 943: switch (l->llc_dsap) {
1.23 christos 944: #ifdef NETATALK
945: case LLC_SNAP_LSAP:
946: switch (l->llc_control) {
947: case LLC_UI:
948: if (l->llc_ssap != LLC_SNAP_LSAP) {
949: goto dropanyway;
950: }
1.120 perry 951:
1.23 christos 952: if (Bcmp(&(l->llc_snap_org_code)[0],
953: at_org_code, sizeof(at_org_code)) == 0 &&
954: ntohs(l->llc_snap_ether_type) ==
1.38 kim 955: ETHERTYPE_ATALK) {
1.23 christos 956: inq = &atintrq2;
957: m_adj(m, sizeof(struct llc));
958: schednetisr(NETISR_ATALK);
959: break;
960: }
961:
962: if (Bcmp(&(l->llc_snap_org_code)[0],
963: aarp_org_code,
964: sizeof(aarp_org_code)) == 0 &&
965: ntohs(l->llc_snap_ether_type) ==
966: ETHERTYPE_AARP) {
967: m_adj( m, sizeof(struct llc));
968: aarpinput(ifp, m); /* XXX */
969: return;
970: }
1.120 perry 971:
1.23 christos 972: default:
973: goto dropanyway;
974: }
975: break;
976: #endif /* NETATALK */
1.8 mycroft 977: #ifdef ISO
1.120 perry 978: case LLC_ISO_LSAP:
1.8 mycroft 979: switch (l->llc_control) {
980: case LLC_UI:
981: /* LLC_UI_P forbidden in class 1 service */
982: if ((l->llc_dsap == LLC_ISO_LSAP) &&
983: (l->llc_ssap == LLC_ISO_LSAP)) {
984: /* LSAP for ISO */
1.11 mycroft 985: if (m->m_pkthdr.len > etype)
986: m_adj(m, etype - m->m_pkthdr.len);
1.8 mycroft 987: m->m_data += 3; /* XXX */
988: m->m_len -= 3; /* XXX */
989: m->m_pkthdr.len -= 3; /* XXX */
990: M_PREPEND(m, sizeof *eh, M_DONTWAIT);
991: if (m == 0)
992: return;
993: *mtod(m, struct ether_header *) = *eh;
1.18 christos 994: #ifdef ARGO_DEBUG
995: if (argo_debug[D_ETHER])
1.21 christos 996: printf("clnp packet");
1.18 christos 997: #endif
1.8 mycroft 998: schednetisr(NETISR_ISO);
999: inq = &clnlintrq;
1000: break;
1001: }
1002: goto dropanyway;
1.120 perry 1003:
1.8 mycroft 1004: case LLC_XID:
1005: case LLC_XID_P:
1006: if(m->m_len < 6)
1007: goto dropanyway;
1008: l->llc_window = 0;
1009: l->llc_fid = 9;
1010: l->llc_class = 1;
1011: l->llc_dsap = l->llc_ssap = 0;
1012: /* Fall through to */
1013: case LLC_TEST:
1014: case LLC_TEST_P:
1015: {
1016: struct sockaddr sa;
1.29 mrg 1017: struct ether_header *eh2;
1.8 mycroft 1018: int i;
1019: u_char c = l->llc_dsap;
1020:
1021: l->llc_dsap = l->llc_ssap;
1022: l->llc_ssap = c;
1023: if (m->m_flags & (M_BCAST | M_MCAST))
1.22 is 1024: bcopy(LLADDR(ifp->if_sadl),
1.8 mycroft 1025: (caddr_t)eh->ether_dhost, 6);
1026: sa.sa_family = AF_UNSPEC;
1027: sa.sa_len = sizeof(sa);
1028: eh2 = (struct ether_header *)sa.sa_data;
1029: for (i = 0; i < 6; i++) {
1.120 perry 1030: eh2->ether_shost[i] = c =
1.22 is 1031: eh->ether_dhost[i];
1.120 perry 1032: eh2->ether_dhost[i] =
1.22 is 1033: eh->ether_dhost[i] =
1034: eh->ether_shost[i];
1.8 mycroft 1035: eh->ether_shost[i] = c;
1036: }
1037: ifp->if_output(ifp, m, &sa, NULL);
1038: return;
1039: }
1040: default:
1041: m_freem(m);
1042: return;
1043: }
1044: break;
1045: #endif /* ISO */
1046: #ifdef LLC
1047: case LLC_X25_LSAP:
1048: {
1.11 mycroft 1049: if (m->m_pkthdr.len > etype)
1050: m_adj(m, etype - m->m_pkthdr.len);
1.8 mycroft 1051: M_PREPEND(m, sizeof(struct sdl_hdr) , M_DONTWAIT);
1.1 cgd 1052: if (m == 0)
1053: return;
1.8 mycroft 1054: if ( !sdl_sethdrif(ifp, eh->ether_shost, LLC_X25_LSAP,
1.120 perry 1055: eh->ether_dhost, LLC_X25_LSAP, 6,
1.8 mycroft 1056: mtod(m, struct sdl_hdr *)))
1057: panic("ETHER cons addr failure");
1.11 mycroft 1058: mtod(m, struct sdl_hdr *)->sdlhdr_len = etype;
1.8 mycroft 1059: #ifdef LLC_DEBUG
1.21 christos 1060: printf("llc packet\n");
1.8 mycroft 1061: #endif /* LLC_DEBUG */
1062: schednetisr(NETISR_CCITT);
1063: inq = &llcintrq;
1.1 cgd 1064: break;
1065: }
1.8 mycroft 1066: #endif /* LLC */
1.1 cgd 1067: dropanyway:
1068: default:
1.8 mycroft 1069: m_freem(m);
1070: return;
1071: }
1.23 christos 1072: #else /* ISO || LLC || NETATALK*/
1.1 cgd 1073: m_freem(m);
1074: return;
1.23 christos 1075: #endif /* ISO || LLC || NETATALK*/
1.1 cgd 1076: }
1077:
1078: if (IF_QFULL(inq)) {
1079: IF_DROP(inq);
1080: m_freem(m);
1081: } else
1082: IF_ENQUEUE(inq, m);
1083: }
1084:
1085: /*
1086: * Convert Ethernet address to printable (loggable) representation.
1087: */
1088: char *
1.58 matt 1089: ether_sprintf(const u_char *ap)
1.1 cgd 1090: {
1091: static char etherbuf[18];
1.29 mrg 1092: char *cp = etherbuf;
1093: int i;
1.1 cgd 1094:
1095: for (i = 0; i < 6; i++) {
1.124 christos 1096: *cp++ = hexdigits[*ap >> 4];
1097: *cp++ = hexdigits[*ap++ & 0xf];
1.1 cgd 1098: *cp++ = ':';
1099: }
1100: *--cp = 0;
1101: return (etherbuf);
1102: }
1.8 mycroft 1103:
1104: /*
1105: * Perform common duties while attaching to interface list
1106: */
1107: void
1.58 matt 1108: ether_ifattach(struct ifnet *ifp, const u_int8_t *lla)
1.8 mycroft 1109: {
1.104 matt 1110: struct ethercom *ec = (struct ethercom *)ifp;
1.8 mycroft 1111:
1112: ifp->if_type = IFT_ETHER;
1.75 thorpej 1113: ifp->if_addrlen = ETHER_ADDR_LEN;
1.94 enami 1114: ifp->if_hdrlen = ETHER_HDR_LEN;
1.73 thorpej 1115: ifp->if_dlt = DLT_EN10MB;
1.8 mycroft 1116: ifp->if_mtu = ETHERMTU;
1.12 mycroft 1117: ifp->if_output = ether_output;
1.42 thorpej 1118: ifp->if_input = ether_input;
1.54 thorpej 1119: if (ifp->if_baudrate == 0)
1120: ifp->if_baudrate = IF_Mbps(10); /* just a default */
1.75 thorpej 1121:
1122: if_alloc_sadl(ifp);
1123: memcpy(LLADDR(ifp->if_sadl), lla, ifp->if_addrlen);
1124:
1.104 matt 1125: LIST_INIT(&ec->ec_multiaddrs);
1.26 is 1126: ifp->if_broadcastaddr = etherbroadcastaddr;
1.69 thorpej 1127: #if NBPFILTER > 0
1.71 thorpej 1128: bpfattach(ifp, DLT_EN10MB, sizeof(struct ether_header));
1.69 thorpej 1129: #endif
1.104 matt 1130: #ifdef MBUFTRACE
1.108 itojun 1131: strlcpy(ec->ec_tx_mowner.mo_name, ifp->if_xname,
1132: sizeof(ec->ec_tx_mowner.mo_name));
1133: strlcpy(ec->ec_tx_mowner.mo_descr, "tx",
1134: sizeof(ec->ec_tx_mowner.mo_descr));
1135: strlcpy(ec->ec_rx_mowner.mo_name, ifp->if_xname,
1136: sizeof(ec->ec_rx_mowner.mo_name));
1137: strlcpy(ec->ec_rx_mowner.mo_descr, "rx",
1138: sizeof(ec->ec_rx_mowner.mo_descr));
1.104 matt 1139: MOWNER_ATTACH(&ec->ec_tx_mowner);
1140: MOWNER_ATTACH(&ec->ec_rx_mowner);
1141: ifp->if_mowner = &ec->ec_tx_mowner;
1142: #endif
1.52 thorpej 1143: }
1144:
1145: void
1.58 matt 1146: ether_ifdetach(struct ifnet *ifp)
1.52 thorpej 1147: {
1.63 thorpej 1148: struct ethercom *ec = (void *) ifp;
1149: struct ether_multi *enm;
1150: int s;
1.69 thorpej 1151:
1.115 dyoung 1152: #if NBRIDGE > 0
1153: if (ifp->if_bridge)
1154: bridge_ifdetach(ifp);
1155: #endif
1156:
1.69 thorpej 1157: #if NBPFILTER > 0
1158: bpfdetach(ifp);
1159: #endif
1.64 thorpej 1160:
1161: #if NVLAN > 0
1162: if (ec->ec_nvlans)
1163: vlan_ifdetach(ifp);
1164: #endif
1.63 thorpej 1165:
1.79 thorpej 1166: s = splnet();
1.63 thorpej 1167: while ((enm = LIST_FIRST(&ec->ec_multiaddrs)) != NULL) {
1168: LIST_REMOVE(enm, enm_list);
1.100 jdolecek 1169: free(enm, M_IFMADDR);
1.63 thorpej 1170: ec->ec_multicnt--;
1171: }
1172: splx(s);
1.52 thorpej 1173:
1.109 itojun 1174: #if 0 /* done in if_detach() */
1.75 thorpej 1175: if_free_sadl(ifp);
1.109 itojun 1176: #endif
1.104 matt 1177:
1178: MOWNER_DETACH(&ec->ec_rx_mowner);
1179: MOWNER_DETACH(&ec->ec_tx_mowner);
1.53 thorpej 1180: }
1181:
1.56 thorpej 1182: #if 0
1183: /*
1184: * This is for reference. We have a table-driven version
1185: * of the little-endian crc32 generator, which is faster
1186: * than the double-loop.
1187: */
1.53 thorpej 1188: u_int32_t
1.58 matt 1189: ether_crc32_le(const u_int8_t *buf, size_t len)
1.53 thorpej 1190: {
1191: u_int32_t c, crc, carry;
1192: size_t i, j;
1193:
1194: crc = 0xffffffffU; /* initial value */
1195:
1196: for (i = 0; i < len; i++) {
1197: c = buf[i];
1198: for (j = 0; j < 8; j++) {
1199: carry = ((crc & 0x01) ? 1 : 0) ^ (c & 0x01);
1200: crc >>= 1;
1201: c >>= 1;
1202: if (carry)
1.56 thorpej 1203: crc = (crc ^ ETHER_CRC_POLY_LE);
1.53 thorpej 1204: }
1205: }
1206:
1207: return (crc);
1208: }
1.56 thorpej 1209: #else
1210: u_int32_t
1.58 matt 1211: ether_crc32_le(const u_int8_t *buf, size_t len)
1.56 thorpej 1212: {
1213: static const u_int32_t crctab[] = {
1214: 0x00000000, 0x1db71064, 0x3b6e20c8, 0x26d930ac,
1215: 0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c,
1216: 0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c,
1217: 0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c
1218: };
1219: u_int32_t crc;
1.98 thorpej 1220: size_t i;
1.56 thorpej 1221:
1222: crc = 0xffffffffU; /* initial value */
1223:
1224: for (i = 0; i < len; i++) {
1225: crc ^= buf[i];
1226: crc = (crc >> 4) ^ crctab[crc & 0xf];
1227: crc = (crc >> 4) ^ crctab[crc & 0xf];
1228: }
1229:
1230: return (crc);
1231: }
1232: #endif
1.53 thorpej 1233:
1234: u_int32_t
1.58 matt 1235: ether_crc32_be(const u_int8_t *buf, size_t len)
1.53 thorpej 1236: {
1237: u_int32_t c, crc, carry;
1238: size_t i, j;
1239:
1240: crc = 0xffffffffU; /* initial value */
1241:
1242: for (i = 0; i < len; i++) {
1243: c = buf[i];
1244: for (j = 0; j < 8; j++) {
1245: carry = ((crc & 0x80000000U) ? 1 : 0) ^ (c & 0x01);
1246: crc <<= 1;
1247: c >>= 1;
1248: if (carry)
1249: crc = (crc ^ ETHER_CRC_POLY_BE) | carry;
1250: }
1251: }
1252:
1253: return (crc);
1.8 mycroft 1254: }
1255:
1.48 is 1256: #ifdef INET
1.118 yamt 1257: const uint8_t ether_ipmulticast_min[ETHER_ADDR_LEN] =
1258: { 0x01, 0x00, 0x5e, 0x00, 0x00, 0x00 };
1259: const uint8_t ether_ipmulticast_max[ETHER_ADDR_LEN] =
1260: { 0x01, 0x00, 0x5e, 0x7f, 0xff, 0xff };
1.48 is 1261: #endif
1.44 itojun 1262: #ifdef INET6
1.118 yamt 1263: const uint8_t ether_ip6multicast_min[ETHER_ADDR_LEN] =
1264: { 0x33, 0x33, 0x00, 0x00, 0x00, 0x00 };
1265: const uint8_t ether_ip6multicast_max[ETHER_ADDR_LEN] =
1266: { 0x33, 0x33, 0xff, 0xff, 0xff, 0xff };
1.44 itojun 1267: #endif
1.60 enami 1268:
1.3 hpeyerl 1269: /*
1.60 enami 1270: * Convert a sockaddr into an Ethernet address or range of Ethernet
1271: * addresses.
1.3 hpeyerl 1272: */
1273: int
1.60 enami 1274: ether_multiaddr(struct sockaddr *sa, u_int8_t addrlo[ETHER_ADDR_LEN],
1275: u_int8_t addrhi[ETHER_ADDR_LEN])
1.3 hpeyerl 1276: {
1.24 christos 1277: #ifdef INET
1.3 hpeyerl 1278: struct sockaddr_in *sin;
1.24 christos 1279: #endif /* INET */
1.44 itojun 1280: #ifdef INET6
1281: struct sockaddr_in6 *sin6;
1282: #endif /* INET6 */
1.3 hpeyerl 1283:
1.60 enami 1284: switch (sa->sa_family) {
1.3 hpeyerl 1285:
1286: case AF_UNSPEC:
1.60 enami 1287: bcopy(sa->sa_data, addrlo, ETHER_ADDR_LEN);
1288: bcopy(addrlo, addrhi, ETHER_ADDR_LEN);
1.3 hpeyerl 1289: break;
1290:
1291: #ifdef INET
1292: case AF_INET:
1.60 enami 1293: sin = satosin(sa);
1.3 hpeyerl 1294: if (sin->sin_addr.s_addr == INADDR_ANY) {
1295: /*
1.60 enami 1296: * An IP address of INADDR_ANY means listen to
1297: * or stop listening to all of the Ethernet
1298: * multicast addresses used for IP.
1.3 hpeyerl 1299: * (This is for the sake of IP multicast routers.)
1300: */
1.60 enami 1301: bcopy(ether_ipmulticast_min, addrlo, ETHER_ADDR_LEN);
1302: bcopy(ether_ipmulticast_max, addrhi, ETHER_ADDR_LEN);
1.3 hpeyerl 1303: }
1304: else {
1305: ETHER_MAP_IP_MULTICAST(&sin->sin_addr, addrlo);
1.60 enami 1306: bcopy(addrlo, addrhi, ETHER_ADDR_LEN);
1.3 hpeyerl 1307: }
1308: break;
1309: #endif
1.44 itojun 1310: #ifdef INET6
1311: case AF_INET6:
1.60 enami 1312: sin6 = satosin6(sa);
1.47 itojun 1313: if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
1.44 itojun 1314: /*
1.60 enami 1315: * An IP6 address of 0 means listen to or stop
1316: * listening to all of the Ethernet multicast
1317: * address used for IP6.
1.44 itojun 1318: * (This is used for multicast routers.)
1319: */
1320: bcopy(ether_ip6multicast_min, addrlo, ETHER_ADDR_LEN);
1321: bcopy(ether_ip6multicast_max, addrhi, ETHER_ADDR_LEN);
1322: } else {
1323: ETHER_MAP_IPV6_MULTICAST(&sin6->sin6_addr, addrlo);
1324: bcopy(addrlo, addrhi, ETHER_ADDR_LEN);
1325: }
1326: break;
1327: #endif
1.3 hpeyerl 1328:
1329: default:
1.60 enami 1330: return (EAFNOSUPPORT);
1331: }
1332: return (0);
1333: }
1334:
1335: /*
1336: * Add an Ethernet multicast address or range of addresses to the list for a
1337: * given interface.
1338: */
1339: int
1340: ether_addmulti(struct ifreq *ifr, struct ethercom *ec)
1341: {
1342: struct ether_multi *enm;
1343: u_char addrlo[ETHER_ADDR_LEN];
1344: u_char addrhi[ETHER_ADDR_LEN];
1.79 thorpej 1345: int s = splnet(), error;
1.60 enami 1346:
1347: error = ether_multiaddr(&ifr->ifr_addr, addrlo, addrhi);
1348: if (error != 0) {
1.3 hpeyerl 1349: splx(s);
1.60 enami 1350: return (error);
1.3 hpeyerl 1351: }
1352:
1353: /*
1354: * Verify that we have valid Ethernet multicast addresses.
1355: */
1356: if ((addrlo[0] & 0x01) != 1 || (addrhi[0] & 0x01) != 1) {
1357: splx(s);
1358: return (EINVAL);
1359: }
1360: /*
1361: * See if the address range is already in the list.
1362: */
1.22 is 1363: ETHER_LOOKUP_MULTI(addrlo, addrhi, ec, enm);
1.3 hpeyerl 1364: if (enm != NULL) {
1365: /*
1366: * Found it; just increment the reference count.
1367: */
1368: ++enm->enm_refcount;
1369: splx(s);
1370: return (0);
1371: }
1372: /*
1373: * New address or range; malloc a new multicast record
1374: * and link it into the interface's multicast list.
1375: */
1376: enm = (struct ether_multi *)malloc(sizeof(*enm), M_IFMADDR, M_NOWAIT);
1377: if (enm == NULL) {
1378: splx(s);
1379: return (ENOBUFS);
1380: }
1381: bcopy(addrlo, enm->enm_addrlo, 6);
1382: bcopy(addrhi, enm->enm_addrhi, 6);
1383: enm->enm_refcount = 1;
1.22 is 1384: LIST_INSERT_HEAD(&ec->ec_multiaddrs, enm, enm_list);
1385: ec->ec_multicnt++;
1.3 hpeyerl 1386: splx(s);
1387: /*
1388: * Return ENETRESET to inform the driver that the list has changed
1389: * and its reception filter should be adjusted accordingly.
1390: */
1391: return (ENETRESET);
1392: }
1393:
1394: /*
1395: * Delete a multicast address record.
1396: */
1397: int
1.58 matt 1398: ether_delmulti(struct ifreq *ifr, struct ethercom *ec)
1.3 hpeyerl 1399: {
1.29 mrg 1400: struct ether_multi *enm;
1.60 enami 1401: u_char addrlo[ETHER_ADDR_LEN];
1402: u_char addrhi[ETHER_ADDR_LEN];
1.79 thorpej 1403: int s = splnet(), error;
1.3 hpeyerl 1404:
1.60 enami 1405: error = ether_multiaddr(&ifr->ifr_addr, addrlo, addrhi);
1406: if (error != 0) {
1.3 hpeyerl 1407: splx(s);
1.60 enami 1408: return (error);
1.3 hpeyerl 1409: }
1410:
1411: /*
1.66 thorpej 1412: * Look ur the address in our list.
1.3 hpeyerl 1413: */
1.22 is 1414: ETHER_LOOKUP_MULTI(addrlo, addrhi, ec, enm);
1.3 hpeyerl 1415: if (enm == NULL) {
1416: splx(s);
1417: return (ENXIO);
1418: }
1419: if (--enm->enm_refcount != 0) {
1420: /*
1421: * Still some claims to this record.
1422: */
1423: splx(s);
1424: return (0);
1425: }
1426: /*
1427: * No remaining claims to this record; unlink and free it.
1428: */
1.13 mycroft 1429: LIST_REMOVE(enm, enm_list);
1.3 hpeyerl 1430: free(enm, M_IFMADDR);
1.22 is 1431: ec->ec_multicnt--;
1.3 hpeyerl 1432: splx(s);
1433: /*
1434: * Return ENETRESET to inform the driver that the list has changed
1435: * and its reception filter should be adjusted accordingly.
1436: */
1437: return (ENETRESET);
1.66 thorpej 1438: }
1439:
1440: /*
1441: * Common ioctls for Ethernet interfaces. Note, we must be
1442: * called at splnet().
1443: */
1444: int
1445: ether_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
1446: {
1447: struct ethercom *ec = (void *) ifp;
1448: struct ifreq *ifr = (struct ifreq *)data;
1449: struct ifaddr *ifa = (struct ifaddr *)data;
1450: int error = 0;
1451:
1452: switch (cmd) {
1453: case SIOCSIFADDR:
1454: ifp->if_flags |= IFF_UP;
1455: switch (ifa->ifa_addr->sa_family) {
1.75 thorpej 1456: case AF_LINK:
1457: {
1458: struct sockaddr_dl *sdl =
1459: (struct sockaddr_dl *) ifa->ifa_addr;
1460:
1461: if (sdl->sdl_type != IFT_ETHER ||
1462: sdl->sdl_alen != ifp->if_addrlen) {
1463: error = EINVAL;
1464: break;
1465: }
1466:
1467: memcpy(LLADDR(ifp->if_sadl), LLADDR(sdl),
1468: ifp->if_addrlen);
1469:
1470: /* Set new address. */
1471: error = (*ifp->if_init)(ifp);
1472: break;
1473: }
1.66 thorpej 1474: #ifdef INET
1475: case AF_INET:
1.86 thorpej 1476: if ((ifp->if_flags & IFF_RUNNING) == 0 &&
1477: (error = (*ifp->if_init)(ifp)) != 0)
1.66 thorpej 1478: break;
1479: arp_ifinit(ifp, ifa);
1480: break;
1481: #endif /* INET */
1482: #ifdef NS
1483: case AF_NS:
1484: {
1485: struct ns_addr *ina = &IA_SNS(ifa)->sns_addr;
1486:
1487: if (ns_nullhost(*ina))
1488: ina->x_host = *(union ns_host *)
1489: LLADDR(ifp->if_sadl);
1490: else
1491: memcpy(LLADDR(ifp->if_sadl),
1492: ina->x_host.c_host, ifp->if_addrlen);
1493: /* Set new address. */
1494: error = (*ifp->if_init)(ifp);
1495: break;
1496: }
1497: #endif /* NS */
1498: default:
1.86 thorpej 1499: if ((ifp->if_flags & IFF_RUNNING) == 0)
1500: error = (*ifp->if_init)(ifp);
1.66 thorpej 1501: break;
1502: }
1503: break;
1504:
1505: case SIOCGIFADDR:
1506: memcpy(((struct sockaddr *)&ifr->ifr_data)->sa_data,
1507: LLADDR(ifp->if_sadl), ETHER_ADDR_LEN);
1508: break;
1509:
1510: case SIOCSIFMTU:
1.82 thorpej 1511: {
1512: int maxmtu;
1513:
1514: if (ec->ec_capabilities & ETHERCAP_JUMBO_MTU)
1515: maxmtu = ETHERMTU_JUMBO;
1516: else
1517: maxmtu = ETHERMTU;
1518:
1519: if (ifr->ifr_mtu < ETHERMIN || ifr->ifr_mtu > maxmtu)
1.66 thorpej 1520: error = EINVAL;
1.88 thorpej 1521: else {
1.66 thorpej 1522: ifp->if_mtu = ifr->ifr_mtu;
1.87 thorpej 1523:
1.88 thorpej 1524: /* Make sure the device notices the MTU change. */
1525: if (ifp->if_flags & IFF_UP)
1526: error = (*ifp->if_init)(ifp);
1527: }
1.66 thorpej 1528: break;
1.82 thorpej 1529: }
1.66 thorpej 1530:
1531: case SIOCSIFFLAGS:
1532: if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) == IFF_RUNNING) {
1533: /*
1534: * If interface is marked down and it is running,
1535: * then stop and disable it.
1536: */
1537: (*ifp->if_stop)(ifp, 1);
1538: } else if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) == IFF_UP) {
1539: /*
1540: * If interface is marked up and it is stopped, then
1541: * start it.
1542: */
1543: error = (*ifp->if_init)(ifp);
1544: } else if ((ifp->if_flags & IFF_UP) != 0) {
1545: /*
1546: * Reset the interface to pick up changes in any other
1547: * flags that affect the hardware state.
1548: */
1549: error = (*ifp->if_init)(ifp);
1550: }
1551: break;
1552:
1553: case SIOCADDMULTI:
1.74 augustss 1554: error = ether_addmulti(ifr, ec);
1555: break;
1556:
1.66 thorpej 1557: case SIOCDELMULTI:
1.74 augustss 1558: error = ether_delmulti(ifr, ec);
1.66 thorpej 1559: break;
1560:
1561: default:
1562: error = ENOTTY;
1563: }
1564:
1565: return (error);
1.3 hpeyerl 1566: }
CVSweb <webmaster@jp.NetBSD.org>