1 /*- 2 * SPDX-License-Identifier: BSD-3-Clause 3 * 4 * Copyright (c) 1982, 1989, 1993 5 * The Regents of the University of California. 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 University 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 REGENTS 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 REGENTS 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 * @(#)if_ethersubr.c 8.1 (Berkeley) 6/10/93 32 * $FreeBSD$ 33 */ 34 35 #include "opt_inet.h" 36 #include "opt_inet6.h" 37 #include "opt_netgraph.h" 38 #include "opt_mbuf_profiling.h" 39 #include "opt_rss.h" 40 41 #include <sys/param.h> 42 #include <sys/systm.h> 43 #include <sys/devctl.h> 44 #include <sys/eventhandler.h> 45 #include <sys/jail.h> 46 #include <sys/kernel.h> 47 #include <sys/lock.h> 48 #include <sys/malloc.h> 49 #include <sys/mbuf.h> 50 #include <sys/module.h> 51 #include <sys/msan.h> 52 #include <sys/proc.h> 53 #include <sys/priv.h> 54 #include <sys/random.h> 55 #include <sys/socket.h> 56 #include <sys/sockio.h> 57 #include <sys/sysctl.h> 58 #include <sys/uuid.h> 59 60 #include <net/ieee_oui.h> 61 #include <net/if.h> 62 #include <net/if_var.h> 63 #include <net/if_arp.h> 64 #include <net/netisr.h> 65 #include <net/route.h> 66 #include <net/if_llc.h> 67 #include <net/if_dl.h> 68 #include <net/if_types.h> 69 #include <net/bpf.h> 70 #include <net/ethernet.h> 71 #include <net/if_bridgevar.h> 72 #include <net/if_vlan_var.h> 73 #include <net/if_llatbl.h> 74 #include <net/pfil.h> 75 #include <net/rss_config.h> 76 #include <net/vnet.h> 77 78 #include <netpfil/pf/pf_mtag.h> 79 80 #if defined(INET) || defined(INET6) 81 #include <netinet/in.h> 82 #include <netinet/in_var.h> 83 #include <netinet/if_ether.h> 84 #include <netinet/ip_carp.h> 85 #include <netinet/ip_var.h> 86 #endif 87 #ifdef INET6 88 #include <netinet6/nd6.h> 89 #endif 90 #include <security/mac/mac_framework.h> 91 92 #include <crypto/sha1.h> 93 94 #ifdef CTASSERT 95 CTASSERT(sizeof (struct ether_header) == ETHER_ADDR_LEN * 2 + 2); 96 CTASSERT(sizeof (struct ether_addr) == ETHER_ADDR_LEN); 97 #endif 98 99 VNET_DEFINE(pfil_head_t, link_pfil_head); /* Packet filter hooks */ 100 101 /* netgraph node hooks for ng_ether(4) */ 102 void (*ng_ether_input_p)(struct ifnet *ifp, struct mbuf **mp); 103 void (*ng_ether_input_orphan_p)(struct ifnet *ifp, struct mbuf *m); 104 int (*ng_ether_output_p)(struct ifnet *ifp, struct mbuf **mp); 105 void (*ng_ether_attach_p)(struct ifnet *ifp); 106 void (*ng_ether_detach_p)(struct ifnet *ifp); 107 108 void (*vlan_input_p)(struct ifnet *, struct mbuf *); 109 110 /* if_bridge(4) support */ 111 void (*bridge_dn_p)(struct mbuf *, struct ifnet *); 112 113 /* if_lagg(4) support */ 114 struct mbuf *(*lagg_input_ethernet_p)(struct ifnet *, struct mbuf *); 115 116 static const u_char etherbroadcastaddr[ETHER_ADDR_LEN] = 117 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; 118 119 static int ether_resolvemulti(struct ifnet *, struct sockaddr **, 120 struct sockaddr *); 121 static int ether_requestencap(struct ifnet *, struct if_encap_req *); 122 123 #define senderr(e) do { error = (e); goto bad;} while (0) 124 125 static void 126 update_mbuf_csumflags(struct mbuf *src, struct mbuf *dst) 127 { 128 int csum_flags = 0; 129 130 if (src->m_pkthdr.csum_flags & CSUM_IP) 131 csum_flags |= (CSUM_IP_CHECKED|CSUM_IP_VALID); 132 if (src->m_pkthdr.csum_flags & CSUM_DELAY_DATA) 133 csum_flags |= (CSUM_DATA_VALID|CSUM_PSEUDO_HDR); 134 if (src->m_pkthdr.csum_flags & CSUM_SCTP) 135 csum_flags |= CSUM_SCTP_VALID; 136 dst->m_pkthdr.csum_flags |= csum_flags; 137 if (csum_flags & CSUM_DATA_VALID) 138 dst->m_pkthdr.csum_data = 0xffff; 139 } 140 141 /* 142 * Handle link-layer encapsulation requests. 143 */ 144 static int 145 ether_requestencap(struct ifnet *ifp, struct if_encap_req *req) 146 { 147 struct ether_header *eh; 148 struct arphdr *ah; 149 uint16_t etype; 150 const u_char *lladdr; 151 152 if (req->rtype != IFENCAP_LL) 153 return (EOPNOTSUPP); 154 155 if (req->bufsize < ETHER_HDR_LEN) 156 return (ENOMEM); 157 158 eh = (struct ether_header *)req->buf; 159 lladdr = req->lladdr; 160 req->lladdr_off = 0; 161 162 switch (req->family) { 163 case AF_INET: 164 etype = htons(ETHERTYPE_IP); 165 break; 166 case AF_INET6: 167 etype = htons(ETHERTYPE_IPV6); 168 break; 169 case AF_ARP: 170 ah = (struct arphdr *)req->hdata; 171 ah->ar_hrd = htons(ARPHRD_ETHER); 172 173 switch(ntohs(ah->ar_op)) { 174 case ARPOP_REVREQUEST: 175 case ARPOP_REVREPLY: 176 etype = htons(ETHERTYPE_REVARP); 177 break; 178 case ARPOP_REQUEST: 179 case ARPOP_REPLY: 180 default: 181 etype = htons(ETHERTYPE_ARP); 182 break; 183 } 184 185 if (req->flags & IFENCAP_FLAG_BROADCAST) 186 lladdr = ifp->if_broadcastaddr; 187 break; 188 default: 189 return (EAFNOSUPPORT); 190 } 191 192 memcpy(&eh->ether_type, &etype, sizeof(eh->ether_type)); 193 memcpy(eh->ether_dhost, lladdr, ETHER_ADDR_LEN); 194 memcpy(eh->ether_shost, IF_LLADDR(ifp), ETHER_ADDR_LEN); 195 req->bufsize = sizeof(struct ether_header); 196 197 return (0); 198 } 199 200 static int 201 ether_resolve_addr(struct ifnet *ifp, struct mbuf *m, 202 const struct sockaddr *dst, struct route *ro, u_char *phdr, 203 uint32_t *pflags, struct llentry **plle) 204 { 205 uint32_t lleflags = 0; 206 int error = 0; 207 #if defined(INET) || defined(INET6) 208 struct ether_header *eh = (struct ether_header *)phdr; 209 uint16_t etype; 210 #endif 211 212 if (plle) 213 *plle = NULL; 214 215 switch (dst->sa_family) { 216 #ifdef INET 217 case AF_INET: 218 if ((m->m_flags & (M_BCAST | M_MCAST)) == 0) 219 error = arpresolve(ifp, 0, m, dst, phdr, &lleflags, 220 plle); 221 else { 222 if (m->m_flags & M_BCAST) 223 memcpy(eh->ether_dhost, ifp->if_broadcastaddr, 224 ETHER_ADDR_LEN); 225 else { 226 const struct in_addr *a; 227 a = &(((const struct sockaddr_in *)dst)->sin_addr); 228 ETHER_MAP_IP_MULTICAST(a, eh->ether_dhost); 229 } 230 etype = htons(ETHERTYPE_IP); 231 memcpy(&eh->ether_type, &etype, sizeof(etype)); 232 memcpy(eh->ether_shost, IF_LLADDR(ifp), ETHER_ADDR_LEN); 233 } 234 break; 235 #endif 236 #ifdef INET6 237 case AF_INET6: 238 if ((m->m_flags & M_MCAST) == 0) { 239 int af = RO_GET_FAMILY(ro, dst); 240 error = nd6_resolve(ifp, LLE_SF(af, 0), m, dst, phdr, 241 &lleflags, plle); 242 } else { 243 const struct in6_addr *a6; 244 a6 = &(((const struct sockaddr_in6 *)dst)->sin6_addr); 245 ETHER_MAP_IPV6_MULTICAST(a6, eh->ether_dhost); 246 etype = htons(ETHERTYPE_IPV6); 247 memcpy(&eh->ether_type, &etype, sizeof(etype)); 248 memcpy(eh->ether_shost, IF_LLADDR(ifp), ETHER_ADDR_LEN); 249 } 250 break; 251 #endif 252 default: 253 if_printf(ifp, "can't handle af%d\n", dst->sa_family); 254 if (m != NULL) 255 m_freem(m); 256 return (EAFNOSUPPORT); 257 } 258 259 if (error == EHOSTDOWN) { 260 if (ro != NULL && (ro->ro_flags & RT_HAS_GW) != 0) 261 error = EHOSTUNREACH; 262 } 263 264 if (error != 0) 265 return (error); 266 267 *pflags = RT_MAY_LOOP; 268 if (lleflags & LLE_IFADDR) 269 *pflags |= RT_L2_ME; 270 271 return (0); 272 } 273 274 /* 275 * Ethernet output routine. 276 * Encapsulate a packet of type family for the local net. 277 * Use trailer local net encapsulation if enough data in first 278 * packet leaves a multiple of 512 bytes of data in remainder. 279 */ 280 int 281 ether_output(struct ifnet *ifp, struct mbuf *m, 282 const struct sockaddr *dst, struct route *ro) 283 { 284 int error = 0; 285 char linkhdr[ETHER_HDR_LEN], *phdr; 286 struct ether_header *eh; 287 struct pf_mtag *t; 288 bool loop_copy; 289 int hlen; /* link layer header length */ 290 uint32_t pflags; 291 struct llentry *lle = NULL; 292 int addref = 0; 293 294 phdr = NULL; 295 pflags = 0; 296 if (ro != NULL) { 297 /* XXX BPF uses ro_prepend */ 298 if (ro->ro_prepend != NULL) { 299 phdr = ro->ro_prepend; 300 hlen = ro->ro_plen; 301 } else if (!(m->m_flags & (M_BCAST | M_MCAST))) { 302 if ((ro->ro_flags & RT_LLE_CACHE) != 0) { 303 lle = ro->ro_lle; 304 if (lle != NULL && 305 (lle->la_flags & LLE_VALID) == 0) { 306 LLE_FREE(lle); 307 lle = NULL; /* redundant */ 308 ro->ro_lle = NULL; 309 } 310 if (lle == NULL) { 311 /* if we lookup, keep cache */ 312 addref = 1; 313 } else 314 /* 315 * Notify LLE code that 316 * the entry was used 317 * by datapath. 318 */ 319 llentry_provide_feedback(lle); 320 } 321 if (lle != NULL) { 322 phdr = lle->r_linkdata; 323 hlen = lle->r_hdrlen; 324 pflags = lle->r_flags; 325 } 326 } 327 } 328 329 #ifdef MAC 330 error = mac_ifnet_check_transmit(ifp, m); 331 if (error) 332 senderr(error); 333 #endif 334 335 M_PROFILE(m); 336 if (ifp->if_flags & IFF_MONITOR) 337 senderr(ENETDOWN); 338 if (!((ifp->if_flags & IFF_UP) && 339 (ifp->if_drv_flags & IFF_DRV_RUNNING))) 340 senderr(ENETDOWN); 341 342 if (phdr == NULL) { 343 /* No prepend data supplied. Try to calculate ourselves. */ 344 phdr = linkhdr; 345 hlen = ETHER_HDR_LEN; 346 error = ether_resolve_addr(ifp, m, dst, ro, phdr, &pflags, 347 addref ? &lle : NULL); 348 if (addref && lle != NULL) 349 ro->ro_lle = lle; 350 if (error != 0) 351 return (error == EWOULDBLOCK ? 0 : error); 352 } 353 354 if ((pflags & RT_L2_ME) != 0) { 355 update_mbuf_csumflags(m, m); 356 return (if_simloop(ifp, m, RO_GET_FAMILY(ro, dst), 0)); 357 } 358 loop_copy = (pflags & RT_MAY_LOOP) != 0; 359 360 /* 361 * Add local net header. If no space in first mbuf, 362 * allocate another. 363 * 364 * Note that we do prepend regardless of RT_HAS_HEADER flag. 365 * This is done because BPF code shifts m_data pointer 366 * to the end of ethernet header prior to calling if_output(). 367 */ 368 M_PREPEND(m, hlen, M_NOWAIT); 369 if (m == NULL) 370 senderr(ENOBUFS); 371 if ((pflags & RT_HAS_HEADER) == 0) { 372 eh = mtod(m, struct ether_header *); 373 memcpy(eh, phdr, hlen); 374 } 375 376 /* 377 * If a simplex interface, and the packet is being sent to our 378 * Ethernet address or a broadcast address, loopback a copy. 379 * XXX To make a simplex device behave exactly like a duplex 380 * device, we should copy in the case of sending to our own 381 * ethernet address (thus letting the original actually appear 382 * on the wire). However, we don't do that here for security 383 * reasons and compatibility with the original behavior. 384 */ 385 if ((m->m_flags & M_BCAST) && loop_copy && (ifp->if_flags & IFF_SIMPLEX) && 386 ((t = pf_find_mtag(m)) == NULL || !t->routed)) { 387 struct mbuf *n; 388 389 /* 390 * Because if_simloop() modifies the packet, we need a 391 * writable copy through m_dup() instead of a readonly 392 * one as m_copy[m] would give us. The alternative would 393 * be to modify if_simloop() to handle the readonly mbuf, 394 * but performancewise it is mostly equivalent (trading 395 * extra data copying vs. extra locking). 396 * 397 * XXX This is a local workaround. A number of less 398 * often used kernel parts suffer from the same bug. 399 * See PR kern/105943 for a proposed general solution. 400 */ 401 if ((n = m_dup(m, M_NOWAIT)) != NULL) { 402 update_mbuf_csumflags(m, n); 403 (void)if_simloop(ifp, n, RO_GET_FAMILY(ro, dst), hlen); 404 } else 405 if_inc_counter(ifp, IFCOUNTER_IQDROPS, 1); 406 } 407 408 /* 409 * Bridges require special output handling. 410 */ 411 if (ifp->if_bridge) { 412 BRIDGE_OUTPUT(ifp, m, error); 413 return (error); 414 } 415 416 #if defined(INET) || defined(INET6) 417 if (ifp->if_carp && 418 (error = (*carp_output_p)(ifp, m, dst))) 419 goto bad; 420 #endif 421 422 /* Handle ng_ether(4) processing, if any */ 423 if (ifp->if_l2com != NULL) { 424 KASSERT(ng_ether_output_p != NULL, 425 ("ng_ether_output_p is NULL")); 426 if ((error = (*ng_ether_output_p)(ifp, &m)) != 0) { 427 bad: if (m != NULL) 428 m_freem(m); 429 return (error); 430 } 431 if (m == NULL) 432 return (0); 433 } 434 435 /* Continue with link-layer output */ 436 return ether_output_frame(ifp, m); 437 } 438 439 static bool 440 ether_set_pcp(struct mbuf **mp, struct ifnet *ifp, uint8_t pcp) 441 { 442 struct ether_8021q_tag qtag; 443 struct ether_header *eh; 444 445 eh = mtod(*mp, struct ether_header *); 446 if (ntohs(eh->ether_type) == ETHERTYPE_VLAN || 447 ntohs(eh->ether_type) == ETHERTYPE_QINQ) 448 return (true); 449 450 qtag.vid = 0; 451 qtag.pcp = pcp; 452 qtag.proto = ETHERTYPE_VLAN; 453 if (ether_8021q_frame(mp, ifp, ifp, &qtag)) 454 return (true); 455 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); 456 return (false); 457 } 458 459 /* 460 * Ethernet link layer output routine to send a raw frame to the device. 461 * 462 * This assumes that the 14 byte Ethernet header is present and contiguous 463 * in the first mbuf (if BRIDGE'ing). 464 */ 465 int 466 ether_output_frame(struct ifnet *ifp, struct mbuf *m) 467 { 468 uint8_t pcp; 469 470 pcp = ifp->if_pcp; 471 if (pcp != IFNET_PCP_NONE && ifp->if_type != IFT_L2VLAN && 472 !ether_set_pcp(&m, ifp, pcp)) 473 return (0); 474 475 if (PFIL_HOOKED_OUT(V_link_pfil_head)) 476 switch (pfil_run_hooks(V_link_pfil_head, &m, ifp, PFIL_OUT, 477 NULL)) { 478 case PFIL_DROPPED: 479 return (EACCES); 480 case PFIL_CONSUMED: 481 return (0); 482 } 483 484 #ifdef EXPERIMENTAL 485 #if defined(INET6) && defined(INET) 486 /* draft-ietf-6man-ipv6only-flag */ 487 /* Catch ETHERTYPE_IP, and ETHERTYPE_[REV]ARP if we are v6-only. */ 488 if ((ND_IFINFO(ifp)->flags & ND6_IFF_IPV6_ONLY_MASK) != 0) { 489 struct ether_header *eh; 490 491 eh = mtod(m, struct ether_header *); 492 switch (ntohs(eh->ether_type)) { 493 case ETHERTYPE_IP: 494 case ETHERTYPE_ARP: 495 case ETHERTYPE_REVARP: 496 m_freem(m); 497 return (EAFNOSUPPORT); 498 /* NOTREACHED */ 499 break; 500 }; 501 } 502 #endif 503 #endif 504 505 /* 506 * Queue message on interface, update output statistics if successful, 507 * and start output if interface not yet active. 508 * 509 * If KMSAN is enabled, use it to verify that the data does not contain 510 * any uninitialized bytes. 511 */ 512 kmsan_check_mbuf(m, "ether_output"); 513 return ((ifp->if_transmit)(ifp, m)); 514 } 515 516 /* 517 * Process a received Ethernet packet; the packet is in the 518 * mbuf chain m with the ethernet header at the front. 519 */ 520 static void 521 ether_input_internal(struct ifnet *ifp, struct mbuf *m) 522 { 523 struct ether_header *eh; 524 u_short etype; 525 526 if ((ifp->if_flags & IFF_UP) == 0) { 527 m_freem(m); 528 return; 529 } 530 #ifdef DIAGNOSTIC 531 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) { 532 if_printf(ifp, "discard frame at !IFF_DRV_RUNNING\n"); 533 m_freem(m); 534 return; 535 } 536 #endif 537 if (m->m_len < ETHER_HDR_LEN) { 538 /* XXX maybe should pullup? */ 539 if_printf(ifp, "discard frame w/o leading ethernet " 540 "header (len %u pkt len %u)\n", 541 m->m_len, m->m_pkthdr.len); 542 if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); 543 m_freem(m); 544 return; 545 } 546 eh = mtod(m, struct ether_header *); 547 etype = ntohs(eh->ether_type); 548 random_harvest_queue_ether(m, sizeof(*m)); 549 550 #ifdef EXPERIMENTAL 551 #if defined(INET6) && defined(INET) 552 /* draft-ietf-6man-ipv6only-flag */ 553 /* Catch ETHERTYPE_IP, and ETHERTYPE_[REV]ARP if we are v6-only. */ 554 if ((ND_IFINFO(ifp)->flags & ND6_IFF_IPV6_ONLY_MASK) != 0) { 555 switch (etype) { 556 case ETHERTYPE_IP: 557 case ETHERTYPE_ARP: 558 case ETHERTYPE_REVARP: 559 m_freem(m); 560 return; 561 /* NOTREACHED */ 562 break; 563 }; 564 } 565 #endif 566 #endif 567 568 CURVNET_SET_QUIET(ifp->if_vnet); 569 570 if (ETHER_IS_MULTICAST(eh->ether_dhost)) { 571 if (ETHER_IS_BROADCAST(eh->ether_dhost)) 572 m->m_flags |= M_BCAST; 573 else 574 m->m_flags |= M_MCAST; 575 if_inc_counter(ifp, IFCOUNTER_IMCASTS, 1); 576 } 577 578 #ifdef MAC 579 /* 580 * Tag the mbuf with an appropriate MAC label before any other 581 * consumers can get to it. 582 */ 583 mac_ifnet_create_mbuf(ifp, m); 584 #endif 585 586 /* 587 * Give bpf a chance at the packet. 588 */ 589 ETHER_BPF_MTAP(ifp, m); 590 591 /* 592 * If the CRC is still on the packet, trim it off. We do this once 593 * and once only in case we are re-entered. Nothing else on the 594 * Ethernet receive path expects to see the FCS. 595 */ 596 if (m->m_flags & M_HASFCS) { 597 m_adj(m, -ETHER_CRC_LEN); 598 m->m_flags &= ~M_HASFCS; 599 } 600 601 if (!(ifp->if_capenable & IFCAP_HWSTATS)) 602 if_inc_counter(ifp, IFCOUNTER_IBYTES, m->m_pkthdr.len); 603 604 /* Allow monitor mode to claim this frame, after stats are updated. */ 605 if (ifp->if_flags & IFF_MONITOR) { 606 m_freem(m); 607 CURVNET_RESTORE(); 608 return; 609 } 610 611 /* Handle input from a lagg(4) port */ 612 if (ifp->if_type == IFT_IEEE8023ADLAG) { 613 KASSERT(lagg_input_ethernet_p != NULL, 614 ("%s: if_lagg not loaded!", __func__)); 615 m = (*lagg_input_ethernet_p)(ifp, m); 616 if (m != NULL) 617 ifp = m->m_pkthdr.rcvif; 618 else { 619 CURVNET_RESTORE(); 620 return; 621 } 622 } 623 624 /* 625 * If the hardware did not process an 802.1Q tag, do this now, 626 * to allow 802.1P priority frames to be passed to the main input 627 * path correctly. 628 */ 629 if ((m->m_flags & M_VLANTAG) == 0 && 630 ((etype == ETHERTYPE_VLAN) || (etype == ETHERTYPE_QINQ))) { 631 struct ether_vlan_header *evl; 632 633 if (m->m_len < sizeof(*evl) && 634 (m = m_pullup(m, sizeof(*evl))) == NULL) { 635 #ifdef DIAGNOSTIC 636 if_printf(ifp, "cannot pullup VLAN header\n"); 637 #endif 638 if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); 639 CURVNET_RESTORE(); 640 return; 641 } 642 643 evl = mtod(m, struct ether_vlan_header *); 644 m->m_pkthdr.ether_vtag = ntohs(evl->evl_tag); 645 m->m_flags |= M_VLANTAG; 646 647 bcopy((char *)evl, (char *)evl + ETHER_VLAN_ENCAP_LEN, 648 ETHER_HDR_LEN - ETHER_TYPE_LEN); 649 m_adj(m, ETHER_VLAN_ENCAP_LEN); 650 eh = mtod(m, struct ether_header *); 651 } 652 653 M_SETFIB(m, ifp->if_fib); 654 655 /* Allow ng_ether(4) to claim this frame. */ 656 if (ifp->if_l2com != NULL) { 657 KASSERT(ng_ether_input_p != NULL, 658 ("%s: ng_ether_input_p is NULL", __func__)); 659 m->m_flags &= ~M_PROMISC; 660 (*ng_ether_input_p)(ifp, &m); 661 if (m == NULL) { 662 CURVNET_RESTORE(); 663 return; 664 } 665 eh = mtod(m, struct ether_header *); 666 } 667 668 /* 669 * Allow if_bridge(4) to claim this frame. 670 * The BRIDGE_INPUT() macro will update ifp if the bridge changed it 671 * and the frame should be delivered locally. 672 */ 673 if (ifp->if_bridge != NULL) { 674 m->m_flags &= ~M_PROMISC; 675 BRIDGE_INPUT(ifp, m); 676 if (m == NULL) { 677 CURVNET_RESTORE(); 678 return; 679 } 680 eh = mtod(m, struct ether_header *); 681 } 682 683 #if defined(INET) || defined(INET6) 684 /* 685 * Clear M_PROMISC on frame so that carp(4) will see it when the 686 * mbuf flows up to Layer 3. 687 * FreeBSD's implementation of carp(4) uses the inprotosw 688 * to dispatch IPPROTO_CARP. carp(4) also allocates its own 689 * Ethernet addresses of the form 00:00:5e:00:01:xx, which 690 * is outside the scope of the M_PROMISC test below. 691 * TODO: Maintain a hash table of ethernet addresses other than 692 * ether_dhost which may be active on this ifp. 693 */ 694 if (ifp->if_carp && (*carp_forus_p)(ifp, eh->ether_dhost)) { 695 m->m_flags &= ~M_PROMISC; 696 } else 697 #endif 698 { 699 /* 700 * If the frame received was not for our MAC address, set the 701 * M_PROMISC flag on the mbuf chain. The frame may need to 702 * be seen by the rest of the Ethernet input path in case of 703 * re-entry (e.g. bridge, vlan, netgraph) but should not be 704 * seen by upper protocol layers. 705 */ 706 if (!ETHER_IS_MULTICAST(eh->ether_dhost) && 707 bcmp(IF_LLADDR(ifp), eh->ether_dhost, ETHER_ADDR_LEN) != 0) 708 m->m_flags |= M_PROMISC; 709 } 710 711 ether_demux(ifp, m); 712 CURVNET_RESTORE(); 713 } 714 715 /* 716 * Ethernet input dispatch; by default, direct dispatch here regardless of 717 * global configuration. However, if RSS is enabled, hook up RSS affinity 718 * so that when deferred or hybrid dispatch is enabled, we can redistribute 719 * load based on RSS. 720 * 721 * XXXRW: Would be nice if the ifnet passed up a flag indicating whether or 722 * not it had already done work distribution via multi-queue. Then we could 723 * direct dispatch in the event load balancing was already complete and 724 * handle the case of interfaces with different capabilities better. 725 * 726 * XXXRW: Sort of want an M_DISTRIBUTED flag to avoid multiple distributions 727 * at multiple layers? 728 * 729 * XXXRW: For now, enable all this only if RSS is compiled in, although it 730 * works fine without RSS. Need to characterise the performance overhead 731 * of the detour through the netisr code in the event the result is always 732 * direct dispatch. 733 */ 734 static void 735 ether_nh_input(struct mbuf *m) 736 { 737 738 M_ASSERTPKTHDR(m); 739 KASSERT(m->m_pkthdr.rcvif != NULL, 740 ("%s: NULL interface pointer", __func__)); 741 ether_input_internal(m->m_pkthdr.rcvif, m); 742 } 743 744 static struct netisr_handler ether_nh = { 745 .nh_name = "ether", 746 .nh_handler = ether_nh_input, 747 .nh_proto = NETISR_ETHER, 748 #ifdef RSS 749 .nh_policy = NETISR_POLICY_CPU, 750 .nh_dispatch = NETISR_DISPATCH_DIRECT, 751 .nh_m2cpuid = rss_m2cpuid, 752 #else 753 .nh_policy = NETISR_POLICY_SOURCE, 754 .nh_dispatch = NETISR_DISPATCH_DIRECT, 755 #endif 756 }; 757 758 static void 759 ether_init(__unused void *arg) 760 { 761 762 netisr_register(ðer_nh); 763 } 764 SYSINIT(ether, SI_SUB_INIT_IF, SI_ORDER_ANY, ether_init, NULL); 765 766 static void 767 vnet_ether_init(__unused void *arg) 768 { 769 struct pfil_head_args args; 770 771 args.pa_version = PFIL_VERSION; 772 args.pa_flags = PFIL_IN | PFIL_OUT; 773 args.pa_type = PFIL_TYPE_ETHERNET; 774 args.pa_headname = PFIL_ETHER_NAME; 775 V_link_pfil_head = pfil_head_register(&args); 776 777 #ifdef VIMAGE 778 netisr_register_vnet(ðer_nh); 779 #endif 780 } 781 VNET_SYSINIT(vnet_ether_init, SI_SUB_PROTO_IF, SI_ORDER_ANY, 782 vnet_ether_init, NULL); 783 784 #ifdef VIMAGE 785 static void 786 vnet_ether_pfil_destroy(__unused void *arg) 787 { 788 789 pfil_head_unregister(V_link_pfil_head); 790 } 791 VNET_SYSUNINIT(vnet_ether_pfil_uninit, SI_SUB_PROTO_PFIL, SI_ORDER_ANY, 792 vnet_ether_pfil_destroy, NULL); 793 794 static void 795 vnet_ether_destroy(__unused void *arg) 796 { 797 798 netisr_unregister_vnet(ðer_nh); 799 } 800 VNET_SYSUNINIT(vnet_ether_uninit, SI_SUB_PROTO_IF, SI_ORDER_ANY, 801 vnet_ether_destroy, NULL); 802 #endif 803 804 static void 805 ether_input(struct ifnet *ifp, struct mbuf *m) 806 { 807 struct epoch_tracker et; 808 struct mbuf *mn; 809 bool needs_epoch; 810 811 needs_epoch = !(ifp->if_flags & IFF_KNOWSEPOCH); 812 813 /* 814 * The drivers are allowed to pass in a chain of packets linked with 815 * m_nextpkt. We split them up into separate packets here and pass 816 * them up. This allows the drivers to amortize the receive lock. 817 */ 818 CURVNET_SET_QUIET(ifp->if_vnet); 819 if (__predict_false(needs_epoch)) 820 NET_EPOCH_ENTER(et); 821 while (m) { 822 mn = m->m_nextpkt; 823 m->m_nextpkt = NULL; 824 825 /* 826 * We will rely on rcvif being set properly in the deferred 827 * context, so assert it is correct here. 828 */ 829 MPASS((m->m_pkthdr.csum_flags & CSUM_SND_TAG) == 0); 830 KASSERT(m->m_pkthdr.rcvif == ifp, ("%s: ifnet mismatch m %p " 831 "rcvif %p ifp %p", __func__, m, m->m_pkthdr.rcvif, ifp)); 832 netisr_dispatch(NETISR_ETHER, m); 833 m = mn; 834 } 835 if (__predict_false(needs_epoch)) 836 NET_EPOCH_EXIT(et); 837 CURVNET_RESTORE(); 838 } 839 840 /* 841 * Upper layer processing for a received Ethernet packet. 842 */ 843 void 844 ether_demux(struct ifnet *ifp, struct mbuf *m) 845 { 846 struct ether_header *eh; 847 int i, isr; 848 u_short ether_type; 849 850 NET_EPOCH_ASSERT(); 851 KASSERT(ifp != NULL, ("%s: NULL interface pointer", __func__)); 852 853 /* Do not grab PROMISC frames in case we are re-entered. */ 854 if (PFIL_HOOKED_IN(V_link_pfil_head) && !(m->m_flags & M_PROMISC)) { 855 i = pfil_run_hooks(V_link_pfil_head, &m, ifp, PFIL_IN, NULL); 856 if (i != 0 || m == NULL) 857 return; 858 } 859 860 eh = mtod(m, struct ether_header *); 861 ether_type = ntohs(eh->ether_type); 862 863 /* 864 * If this frame has a VLAN tag other than 0, call vlan_input() 865 * if its module is loaded. Otherwise, drop. 866 */ 867 if ((m->m_flags & M_VLANTAG) && 868 EVL_VLANOFTAG(m->m_pkthdr.ether_vtag) != 0) { 869 if (ifp->if_vlantrunk == NULL) { 870 if_inc_counter(ifp, IFCOUNTER_NOPROTO, 1); 871 m_freem(m); 872 return; 873 } 874 KASSERT(vlan_input_p != NULL,("%s: VLAN not loaded!", 875 __func__)); 876 /* Clear before possibly re-entering ether_input(). */ 877 m->m_flags &= ~M_PROMISC; 878 (*vlan_input_p)(ifp, m); 879 return; 880 } 881 882 /* 883 * Pass promiscuously received frames to the upper layer if the user 884 * requested this by setting IFF_PPROMISC. Otherwise, drop them. 885 */ 886 if ((ifp->if_flags & IFF_PPROMISC) == 0 && (m->m_flags & M_PROMISC)) { 887 m_freem(m); 888 return; 889 } 890 891 /* 892 * Reset layer specific mbuf flags to avoid confusing upper layers. 893 * Strip off Ethernet header. 894 */ 895 m->m_flags &= ~M_VLANTAG; 896 m_clrprotoflags(m); 897 m_adj(m, ETHER_HDR_LEN); 898 899 /* 900 * Dispatch frame to upper layer. 901 */ 902 switch (ether_type) { 903 #ifdef INET 904 case ETHERTYPE_IP: 905 isr = NETISR_IP; 906 break; 907 908 case ETHERTYPE_ARP: 909 if (ifp->if_flags & IFF_NOARP) { 910 /* Discard packet if ARP is disabled on interface */ 911 m_freem(m); 912 return; 913 } 914 isr = NETISR_ARP; 915 break; 916 #endif 917 #ifdef INET6 918 case ETHERTYPE_IPV6: 919 isr = NETISR_IPV6; 920 break; 921 #endif 922 default: 923 goto discard; 924 } 925 netisr_dispatch(isr, m); 926 return; 927 928 discard: 929 /* 930 * Packet is to be discarded. If netgraph is present, 931 * hand the packet to it for last chance processing; 932 * otherwise dispose of it. 933 */ 934 if (ifp->if_l2com != NULL) { 935 KASSERT(ng_ether_input_orphan_p != NULL, 936 ("ng_ether_input_orphan_p is NULL")); 937 /* 938 * Put back the ethernet header so netgraph has a 939 * consistent view of inbound packets. 940 */ 941 M_PREPEND(m, ETHER_HDR_LEN, M_NOWAIT); 942 (*ng_ether_input_orphan_p)(ifp, m); 943 return; 944 } 945 m_freem(m); 946 } 947 948 /* 949 * Convert Ethernet address to printable (loggable) representation. 950 * This routine is for compatibility; it's better to just use 951 * 952 * printf("%6D", <pointer to address>, ":"); 953 * 954 * since there's no static buffer involved. 955 */ 956 char * 957 ether_sprintf(const u_char *ap) 958 { 959 static char etherbuf[18]; 960 snprintf(etherbuf, sizeof (etherbuf), "%6D", ap, ":"); 961 return (etherbuf); 962 } 963 964 /* 965 * Perform common duties while attaching to interface list 966 */ 967 void 968 ether_ifattach(struct ifnet *ifp, const u_int8_t *lla) 969 { 970 int i; 971 struct ifaddr *ifa; 972 struct sockaddr_dl *sdl; 973 974 ifp->if_addrlen = ETHER_ADDR_LEN; 975 ifp->if_hdrlen = ETHER_HDR_LEN; 976 ifp->if_mtu = ETHERMTU; 977 if_attach(ifp); 978 ifp->if_output = ether_output; 979 ifp->if_input = ether_input; 980 ifp->if_resolvemulti = ether_resolvemulti; 981 ifp->if_requestencap = ether_requestencap; 982 #ifdef VIMAGE 983 ifp->if_reassign = ether_reassign; 984 #endif 985 if (ifp->if_baudrate == 0) 986 ifp->if_baudrate = IF_Mbps(10); /* just a default */ 987 ifp->if_broadcastaddr = etherbroadcastaddr; 988 989 ifa = ifp->if_addr; 990 KASSERT(ifa != NULL, ("%s: no lladdr!\n", __func__)); 991 sdl = (struct sockaddr_dl *)ifa->ifa_addr; 992 sdl->sdl_type = IFT_ETHER; 993 sdl->sdl_alen = ifp->if_addrlen; 994 bcopy(lla, LLADDR(sdl), ifp->if_addrlen); 995 996 if (ifp->if_hw_addr != NULL) 997 bcopy(lla, ifp->if_hw_addr, ifp->if_addrlen); 998 999 bpfattach(ifp, DLT_EN10MB, ETHER_HDR_LEN); 1000 if (ng_ether_attach_p != NULL) 1001 (*ng_ether_attach_p)(ifp); 1002 1003 /* Announce Ethernet MAC address if non-zero. */ 1004 for (i = 0; i < ifp->if_addrlen; i++) 1005 if (lla[i] != 0) 1006 break; 1007 if (i != ifp->if_addrlen) 1008 if_printf(ifp, "Ethernet address: %6D\n", lla, ":"); 1009 1010 uuid_ether_add(LLADDR(sdl)); 1011 1012 /* Add necessary bits are setup; announce it now. */ 1013 EVENTHANDLER_INVOKE(ether_ifattach_event, ifp); 1014 if (IS_DEFAULT_VNET(curvnet)) 1015 devctl_notify("ETHERNET", ifp->if_xname, "IFATTACH", NULL); 1016 } 1017 1018 /* 1019 * Perform common duties while detaching an Ethernet interface 1020 */ 1021 void 1022 ether_ifdetach(struct ifnet *ifp) 1023 { 1024 struct sockaddr_dl *sdl; 1025 1026 sdl = (struct sockaddr_dl *)(ifp->if_addr->ifa_addr); 1027 uuid_ether_del(LLADDR(sdl)); 1028 1029 if (ifp->if_l2com != NULL) { 1030 KASSERT(ng_ether_detach_p != NULL, 1031 ("ng_ether_detach_p is NULL")); 1032 (*ng_ether_detach_p)(ifp); 1033 } 1034 1035 bpfdetach(ifp); 1036 if_detach(ifp); 1037 } 1038 1039 #ifdef VIMAGE 1040 void 1041 ether_reassign(struct ifnet *ifp, struct vnet *new_vnet, char *unused __unused) 1042 { 1043 1044 if (ifp->if_l2com != NULL) { 1045 KASSERT(ng_ether_detach_p != NULL, 1046 ("ng_ether_detach_p is NULL")); 1047 (*ng_ether_detach_p)(ifp); 1048 } 1049 1050 if (ng_ether_attach_p != NULL) { 1051 CURVNET_SET_QUIET(new_vnet); 1052 (*ng_ether_attach_p)(ifp); 1053 CURVNET_RESTORE(); 1054 } 1055 } 1056 #endif 1057 1058 SYSCTL_DECL(_net_link); 1059 SYSCTL_NODE(_net_link, IFT_ETHER, ether, CTLFLAG_RW | CTLFLAG_MPSAFE, 0, 1060 "Ethernet"); 1061 1062 #if 0 1063 /* 1064 * This is for reference. We have a table-driven version 1065 * of the little-endian crc32 generator, which is faster 1066 * than the double-loop. 1067 */ 1068 uint32_t 1069 ether_crc32_le(const uint8_t *buf, size_t len) 1070 { 1071 size_t i; 1072 uint32_t crc; 1073 int bit; 1074 uint8_t data; 1075 1076 crc = 0xffffffff; /* initial value */ 1077 1078 for (i = 0; i < len; i++) { 1079 for (data = *buf++, bit = 0; bit < 8; bit++, data >>= 1) { 1080 carry = (crc ^ data) & 1; 1081 crc >>= 1; 1082 if (carry) 1083 crc = (crc ^ ETHER_CRC_POLY_LE); 1084 } 1085 } 1086 1087 return (crc); 1088 } 1089 #else 1090 uint32_t 1091 ether_crc32_le(const uint8_t *buf, size_t len) 1092 { 1093 static const uint32_t crctab[] = { 1094 0x00000000, 0x1db71064, 0x3b6e20c8, 0x26d930ac, 1095 0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c, 1096 0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c, 1097 0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c 1098 }; 1099 size_t i; 1100 uint32_t crc; 1101 1102 crc = 0xffffffff; /* initial value */ 1103 1104 for (i = 0; i < len; i++) { 1105 crc ^= buf[i]; 1106 crc = (crc >> 4) ^ crctab[crc & 0xf]; 1107 crc = (crc >> 4) ^ crctab[crc & 0xf]; 1108 } 1109 1110 return (crc); 1111 } 1112 #endif 1113 1114 uint32_t 1115 ether_crc32_be(const uint8_t *buf, size_t len) 1116 { 1117 size_t i; 1118 uint32_t crc, carry; 1119 int bit; 1120 uint8_t data; 1121 1122 crc = 0xffffffff; /* initial value */ 1123 1124 for (i = 0; i < len; i++) { 1125 for (data = *buf++, bit = 0; bit < 8; bit++, data >>= 1) { 1126 carry = ((crc & 0x80000000) ? 1 : 0) ^ (data & 0x01); 1127 crc <<= 1; 1128 if (carry) 1129 crc = (crc ^ ETHER_CRC_POLY_BE) | carry; 1130 } 1131 } 1132 1133 return (crc); 1134 } 1135 1136 int 1137 ether_ioctl(struct ifnet *ifp, u_long command, caddr_t data) 1138 { 1139 struct ifaddr *ifa = (struct ifaddr *) data; 1140 struct ifreq *ifr = (struct ifreq *) data; 1141 int error = 0; 1142 1143 switch (command) { 1144 case SIOCSIFADDR: 1145 ifp->if_flags |= IFF_UP; 1146 1147 switch (ifa->ifa_addr->sa_family) { 1148 #ifdef INET 1149 case AF_INET: 1150 ifp->if_init(ifp->if_softc); /* before arpwhohas */ 1151 arp_ifinit(ifp, ifa); 1152 break; 1153 #endif 1154 default: 1155 ifp->if_init(ifp->if_softc); 1156 break; 1157 } 1158 break; 1159 1160 case SIOCGIFADDR: 1161 bcopy(IF_LLADDR(ifp), &ifr->ifr_addr.sa_data[0], 1162 ETHER_ADDR_LEN); 1163 break; 1164 1165 case SIOCSIFMTU: 1166 /* 1167 * Set the interface MTU. 1168 */ 1169 if (ifr->ifr_mtu > ETHERMTU) { 1170 error = EINVAL; 1171 } else { 1172 ifp->if_mtu = ifr->ifr_mtu; 1173 } 1174 break; 1175 1176 case SIOCSLANPCP: 1177 error = priv_check(curthread, PRIV_NET_SETLANPCP); 1178 if (error != 0) 1179 break; 1180 if (ifr->ifr_lan_pcp > 7 && 1181 ifr->ifr_lan_pcp != IFNET_PCP_NONE) { 1182 error = EINVAL; 1183 } else { 1184 ifp->if_pcp = ifr->ifr_lan_pcp; 1185 /* broadcast event about PCP change */ 1186 EVENTHANDLER_INVOKE(ifnet_event, ifp, IFNET_EVENT_PCP); 1187 } 1188 break; 1189 1190 case SIOCGLANPCP: 1191 ifr->ifr_lan_pcp = ifp->if_pcp; 1192 break; 1193 1194 default: 1195 error = EINVAL; /* XXX netbsd has ENOTTY??? */ 1196 break; 1197 } 1198 return (error); 1199 } 1200 1201 static int 1202 ether_resolvemulti(struct ifnet *ifp, struct sockaddr **llsa, 1203 struct sockaddr *sa) 1204 { 1205 struct sockaddr_dl *sdl; 1206 #ifdef INET 1207 struct sockaddr_in *sin; 1208 #endif 1209 #ifdef INET6 1210 struct sockaddr_in6 *sin6; 1211 #endif 1212 u_char *e_addr; 1213 1214 switch(sa->sa_family) { 1215 case AF_LINK: 1216 /* 1217 * No mapping needed. Just check that it's a valid MC address. 1218 */ 1219 sdl = (struct sockaddr_dl *)sa; 1220 e_addr = LLADDR(sdl); 1221 if (!ETHER_IS_MULTICAST(e_addr)) 1222 return EADDRNOTAVAIL; 1223 *llsa = NULL; 1224 return 0; 1225 1226 #ifdef INET 1227 case AF_INET: 1228 sin = (struct sockaddr_in *)sa; 1229 if (!IN_MULTICAST(ntohl(sin->sin_addr.s_addr))) 1230 return EADDRNOTAVAIL; 1231 sdl = link_init_sdl(ifp, *llsa, IFT_ETHER); 1232 sdl->sdl_alen = ETHER_ADDR_LEN; 1233 e_addr = LLADDR(sdl); 1234 ETHER_MAP_IP_MULTICAST(&sin->sin_addr, e_addr); 1235 *llsa = (struct sockaddr *)sdl; 1236 return 0; 1237 #endif 1238 #ifdef INET6 1239 case AF_INET6: 1240 sin6 = (struct sockaddr_in6 *)sa; 1241 if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) { 1242 /* 1243 * An IP6 address of 0 means listen to all 1244 * of the Ethernet multicast address used for IP6. 1245 * (This is used for multicast routers.) 1246 */ 1247 ifp->if_flags |= IFF_ALLMULTI; 1248 *llsa = NULL; 1249 return 0; 1250 } 1251 if (!IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr)) 1252 return EADDRNOTAVAIL; 1253 sdl = link_init_sdl(ifp, *llsa, IFT_ETHER); 1254 sdl->sdl_alen = ETHER_ADDR_LEN; 1255 e_addr = LLADDR(sdl); 1256 ETHER_MAP_IPV6_MULTICAST(&sin6->sin6_addr, e_addr); 1257 *llsa = (struct sockaddr *)sdl; 1258 return 0; 1259 #endif 1260 1261 default: 1262 /* 1263 * Well, the text isn't quite right, but it's the name 1264 * that counts... 1265 */ 1266 return EAFNOSUPPORT; 1267 } 1268 } 1269 1270 static moduledata_t ether_mod = { 1271 .name = "ether", 1272 }; 1273 1274 void 1275 ether_vlan_mtap(struct bpf_if *bp, struct mbuf *m, void *data, u_int dlen) 1276 { 1277 struct ether_vlan_header vlan; 1278 struct mbuf mv, mb; 1279 1280 KASSERT((m->m_flags & M_VLANTAG) != 0, 1281 ("%s: vlan information not present", __func__)); 1282 KASSERT(m->m_len >= sizeof(struct ether_header), 1283 ("%s: mbuf not large enough for header", __func__)); 1284 bcopy(mtod(m, char *), &vlan, sizeof(struct ether_header)); 1285 vlan.evl_proto = vlan.evl_encap_proto; 1286 vlan.evl_encap_proto = htons(ETHERTYPE_VLAN); 1287 vlan.evl_tag = htons(m->m_pkthdr.ether_vtag); 1288 m->m_len -= sizeof(struct ether_header); 1289 m->m_data += sizeof(struct ether_header); 1290 /* 1291 * If a data link has been supplied by the caller, then we will need to 1292 * re-create a stack allocated mbuf chain with the following structure: 1293 * 1294 * (1) mbuf #1 will contain the supplied data link 1295 * (2) mbuf #2 will contain the vlan header 1296 * (3) mbuf #3 will contain the original mbuf's packet data 1297 * 1298 * Otherwise, submit the packet and vlan header via bpf_mtap2(). 1299 */ 1300 if (data != NULL) { 1301 mv.m_next = m; 1302 mv.m_data = (caddr_t)&vlan; 1303 mv.m_len = sizeof(vlan); 1304 mb.m_next = &mv; 1305 mb.m_data = data; 1306 mb.m_len = dlen; 1307 bpf_mtap(bp, &mb); 1308 } else 1309 bpf_mtap2(bp, &vlan, sizeof(vlan), m); 1310 m->m_len += sizeof(struct ether_header); 1311 m->m_data -= sizeof(struct ether_header); 1312 } 1313 1314 struct mbuf * 1315 ether_vlanencap_proto(struct mbuf *m, uint16_t tag, uint16_t proto) 1316 { 1317 struct ether_vlan_header *evl; 1318 1319 M_PREPEND(m, ETHER_VLAN_ENCAP_LEN, M_NOWAIT); 1320 if (m == NULL) 1321 return (NULL); 1322 /* M_PREPEND takes care of m_len, m_pkthdr.len for us */ 1323 1324 if (m->m_len < sizeof(*evl)) { 1325 m = m_pullup(m, sizeof(*evl)); 1326 if (m == NULL) 1327 return (NULL); 1328 } 1329 1330 /* 1331 * Transform the Ethernet header into an Ethernet header 1332 * with 802.1Q encapsulation. 1333 */ 1334 evl = mtod(m, struct ether_vlan_header *); 1335 bcopy((char *)evl + ETHER_VLAN_ENCAP_LEN, 1336 (char *)evl, ETHER_HDR_LEN - ETHER_TYPE_LEN); 1337 evl->evl_encap_proto = htons(proto); 1338 evl->evl_tag = htons(tag); 1339 return (m); 1340 } 1341 1342 static SYSCTL_NODE(_net_link, IFT_L2VLAN, vlan, CTLFLAG_RW | CTLFLAG_MPSAFE, 0, 1343 "IEEE 802.1Q VLAN"); 1344 static SYSCTL_NODE(_net_link_vlan, PF_LINK, link, 1345 CTLFLAG_RW | CTLFLAG_MPSAFE, 0, 1346 "for consistency"); 1347 1348 VNET_DEFINE_STATIC(int, soft_pad); 1349 #define V_soft_pad VNET(soft_pad) 1350 SYSCTL_INT(_net_link_vlan, OID_AUTO, soft_pad, CTLFLAG_RW | CTLFLAG_VNET, 1351 &VNET_NAME(soft_pad), 0, 1352 "pad short frames before tagging"); 1353 1354 /* 1355 * For now, make preserving PCP via an mbuf tag optional, as it increases 1356 * per-packet memory allocations and frees. In the future, it would be 1357 * preferable to reuse ether_vtag for this, or similar. 1358 */ 1359 VNET_DEFINE(int, vlan_mtag_pcp) = 0; 1360 #define V_vlan_mtag_pcp VNET(vlan_mtag_pcp) 1361 SYSCTL_INT(_net_link_vlan, OID_AUTO, mtag_pcp, CTLFLAG_RW | CTLFLAG_VNET, 1362 &VNET_NAME(vlan_mtag_pcp), 0, 1363 "Retain VLAN PCP information as packets are passed up the stack"); 1364 1365 bool 1366 ether_8021q_frame(struct mbuf **mp, struct ifnet *ife, struct ifnet *p, 1367 struct ether_8021q_tag *qtag) 1368 { 1369 struct m_tag *mtag; 1370 int n; 1371 uint16_t tag; 1372 static const char pad[8]; /* just zeros */ 1373 1374 /* 1375 * Pad the frame to the minimum size allowed if told to. 1376 * This option is in accord with IEEE Std 802.1Q, 2003 Ed., 1377 * paragraph C.4.4.3.b. It can help to work around buggy 1378 * bridges that violate paragraph C.4.4.3.a from the same 1379 * document, i.e., fail to pad short frames after untagging. 1380 * E.g., a tagged frame 66 bytes long (incl. FCS) is OK, but 1381 * untagging it will produce a 62-byte frame, which is a runt 1382 * and requires padding. There are VLAN-enabled network 1383 * devices that just discard such runts instead or mishandle 1384 * them somehow. 1385 */ 1386 if (V_soft_pad && p->if_type == IFT_ETHER) { 1387 for (n = ETHERMIN + ETHER_HDR_LEN - (*mp)->m_pkthdr.len; 1388 n > 0; n -= sizeof(pad)) { 1389 if (!m_append(*mp, min(n, sizeof(pad)), pad)) 1390 break; 1391 } 1392 if (n > 0) { 1393 m_freem(*mp); 1394 *mp = NULL; 1395 if_printf(ife, "cannot pad short frame"); 1396 return (false); 1397 } 1398 } 1399 1400 /* 1401 * If PCP is set in mbuf, use it 1402 */ 1403 if ((*mp)->m_flags & M_VLANTAG) { 1404 qtag->pcp = EVL_PRIOFTAG((*mp)->m_pkthdr.ether_vtag); 1405 } 1406 1407 /* 1408 * If underlying interface can do VLAN tag insertion itself, 1409 * just pass the packet along. However, we need some way to 1410 * tell the interface where the packet came from so that it 1411 * knows how to find the VLAN tag to use, so we attach a 1412 * packet tag that holds it. 1413 */ 1414 if (V_vlan_mtag_pcp && (mtag = m_tag_locate(*mp, MTAG_8021Q, 1415 MTAG_8021Q_PCP_OUT, NULL)) != NULL) 1416 tag = EVL_MAKETAG(qtag->vid, *(uint8_t *)(mtag + 1), 0); 1417 else 1418 tag = EVL_MAKETAG(qtag->vid, qtag->pcp, 0); 1419 if ((p->if_capenable & IFCAP_VLAN_HWTAGGING) && 1420 (qtag->proto == ETHERTYPE_VLAN)) { 1421 (*mp)->m_pkthdr.ether_vtag = tag; 1422 (*mp)->m_flags |= M_VLANTAG; 1423 } else { 1424 *mp = ether_vlanencap_proto(*mp, tag, qtag->proto); 1425 if (*mp == NULL) { 1426 if_printf(ife, "unable to prepend 802.1Q header"); 1427 return (false); 1428 } 1429 } 1430 return (true); 1431 } 1432 1433 /* 1434 * Allocate an address from the FreeBSD Foundation OUI. This uses a 1435 * cryptographic hash function on the containing jail's name, UUID and the 1436 * interface name to attempt to provide a unique but stable address. 1437 * Pseudo-interfaces which require a MAC address should use this function to 1438 * allocate non-locally-administered addresses. 1439 */ 1440 void 1441 ether_gen_addr(struct ifnet *ifp, struct ether_addr *hwaddr) 1442 { 1443 SHA1_CTX ctx; 1444 char *buf; 1445 char uuid[HOSTUUIDLEN + 1]; 1446 uint64_t addr; 1447 int i, sz; 1448 char digest[SHA1_RESULTLEN]; 1449 char jailname[MAXHOSTNAMELEN]; 1450 1451 getcredhostuuid(curthread->td_ucred, uuid, sizeof(uuid)); 1452 if (strncmp(uuid, DEFAULT_HOSTUUID, sizeof(uuid)) == 0) { 1453 /* Fall back to a random mac address. */ 1454 goto rando; 1455 } 1456 1457 /* If each (vnet) jail would also have a unique hostuuid this would not 1458 * be necessary. */ 1459 getjailname(curthread->td_ucred, jailname, sizeof(jailname)); 1460 sz = asprintf(&buf, M_TEMP, "%s-%s-%s", uuid, if_name(ifp), 1461 jailname); 1462 if (sz < 0) { 1463 /* Fall back to a random mac address. */ 1464 goto rando; 1465 } 1466 1467 SHA1Init(&ctx); 1468 SHA1Update(&ctx, buf, sz); 1469 SHA1Final(digest, &ctx); 1470 free(buf, M_TEMP); 1471 1472 addr = ((digest[0] << 16) | (digest[1] << 8) | digest[2]) & 1473 OUI_FREEBSD_GENERATED_MASK; 1474 addr = OUI_FREEBSD(addr); 1475 for (i = 0; i < ETHER_ADDR_LEN; ++i) { 1476 hwaddr->octet[i] = addr >> ((ETHER_ADDR_LEN - i - 1) * 8) & 1477 0xFF; 1478 } 1479 1480 return; 1481 rando: 1482 arc4rand(hwaddr, sizeof(*hwaddr), 0); 1483 /* Unicast */ 1484 hwaddr->octet[0] &= 0xFE; 1485 /* Locally administered. */ 1486 hwaddr->octet[0] |= 0x02; 1487 } 1488 1489 DECLARE_MODULE(ether, ether_mod, SI_SUB_INIT_IF, SI_ORDER_ANY); 1490 MODULE_VERSION(ether, 1); 1491