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