1/* 2 * Copyright (c) 2000-2006 Apple Computer, Inc. All rights reserved. 3 * 4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ 5 * 6 * This file contains Original Code and/or Modifications of Original Code 7 * as defined in and that are subject to the Apple Public Source License 8 * Version 2.0 (the 'License'). You may not use this file except in 9 * compliance with the License. The rights granted to you under the License 10 * may not be used to create, or enable the creation or redistribution of, 11 * unlawful or unlicensed copies of an Apple operating system, or to 12 * circumvent, violate, or enable the circumvention or violation of, any 13 * terms of an Apple operating system software license agreement. 14 * 15 * Please obtain a copy of the License at 16 * http://www.opensource.apple.com/apsl/ and read it before using this file. 17 * 18 * The Original Code and all software distributed under the License are 19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, 21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, 22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 23 * Please see the License for the specific language governing rights and 24 * limitations under the License. 25 * 26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ 27 */ 28/* 29 * Copyright (c) 1982, 1989, 1993 30 * The Regents of the University of California. All rights reserved. 31 * 32 * Redistribution and use in source and binary forms, with or without 33 * modification, are permitted provided that the following conditions 34 * are met: 35 * 1. Redistributions of source code must retain the above copyright 36 * notice, this list of conditions and the following disclaimer. 37 * 2. Redistributions in binary form must reproduce the above copyright 38 * notice, this list of conditions and the following disclaimer in the 39 * documentation and/or other materials provided with the distribution. 40 * 3. All advertising materials mentioning features or use of this software 41 * must display the following acknowledgement: 42 * This product includes software developed by the University of 43 * California, Berkeley and its contributors. 44 * 4. 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 */ 61 62 63 64#include <sys/param.h> 65#include <sys/systm.h> 66#include <sys/kernel.h> 67#include <sys/malloc.h> 68#include <sys/mbuf.h> 69#include <sys/socket.h> 70#include <sys/sockio.h> 71#include <sys/sysctl.h> 72 73#include <pexpert/pexpert.h> 74 75#include <net/if.h> 76#include <net/route.h> 77#include <net/if_llc.h> 78#include <net/if_dl.h> 79#include <net/if_types.h> 80#include <net/if_ether.h> 81#include <netinet/if_ether.h> 82#include <netinet/in.h> /* For M_LOOP */ 83#include <net/kpi_interface.h> 84#include <net/kpi_protocol.h> 85 86/* 87#if INET 88#include <netinet/in.h> 89#include <netinet/in_var.h> 90 91#include <netinet/in_systm.h> 92#include <netinet/ip.h> 93#endif 94*/ 95#include <net/ether_if_module.h> 96#include <sys/socketvar.h> 97#include <net/if_vlan_var.h> 98#include <net/if_bond_var.h> 99 100#include <net/dlil.h> 101 102#if LLC && CCITT 103extern struct ifqueue pkintrq; 104#endif 105 106/* General stuff from if_ethersubr.c - may not need some of it */ 107 108#include <netat/at_pat.h> 109#if NETAT 110extern struct ifqueue atalkintrq; 111#endif 112 113 114#if BRIDGE 115#include <net/bridge.h> 116#endif 117 118#define memcpy(x,y,z) bcopy(y, x, z) 119 120 121SYSCTL_DECL(_net_link); 122SYSCTL_NODE(_net_link, IFT_ETHER, ether, CTLFLAG_RW|CTLFLAG_LOCKED, 0, "Ethernet"); 123 124struct en_desc { 125 u_int16_t type; /* Type of protocol stored in data */ 126 u_long protocol_family; /* Protocol family */ 127 u_long data[2]; /* Protocol data */ 128}; 129 130/* descriptors are allocated in blocks of ETHER_DESC_BLK_SIZE */ 131#if CONFIG_EMBEDDED 132#define ETHER_DESC_BLK_SIZE (2) /* IP, ARP */ 133#else 134#define ETHER_DESC_BLK_SIZE (10) 135#endif 136 137/* 138 * Header for the demux list, hangs off of IFP at family_cookie 139 */ 140 141struct ether_desc_blk_str { 142 u_long n_max_used; 143 u_long n_count; 144 u_long n_used; 145 struct en_desc block_ptr[1]; 146}; 147/* Size of the above struct before the array of struct en_desc */ 148#define ETHER_DESC_HEADER_SIZE ((size_t)offsetof(struct ether_desc_blk_str, block_ptr)) 149__private_extern__ u_char etherbroadcastaddr[ETHER_ADDR_LEN] = 150 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; 151 152static __inline__ int 153_ether_cmp(const void * a, const void * b) 154{ 155 const u_int16_t * a_s = (const u_int16_t *)a; 156 const u_int16_t * b_s = (const u_int16_t *)b; 157 158 if (a_s[0] != b_s[0] 159 || a_s[1] != b_s[1] 160 || a_s[2] != b_s[2]) { 161 return (1); 162 } 163 return (0); 164} 165 166/* 167 * Release all descriptor entries owned by this protocol (there may be several). 168 * Setting the type to 0 releases the entry. Eventually we should compact-out 169 * the unused entries. 170 */ 171int 172ether_del_proto( 173 ifnet_t ifp, 174 protocol_family_t protocol_family) 175{ 176 struct ether_desc_blk_str *desc_blk = (struct ether_desc_blk_str *)ifp->family_cookie; 177 u_long current = 0; 178 int found = 0; 179 180 if (desc_blk == NULL) 181 return 0; 182 183 for (current = desc_blk->n_max_used; current > 0; current--) { 184 if (desc_blk->block_ptr[current - 1].protocol_family == protocol_family) { 185 found = 1; 186 desc_blk->block_ptr[current - 1].type = 0; 187 desc_blk->n_used--; 188 } 189 } 190 191 if (desc_blk->n_used == 0) { 192 FREE(ifp->family_cookie, M_IFADDR); 193 ifp->family_cookie = 0; 194 } 195 else { 196 /* Decrement n_max_used */ 197 for (; desc_blk->n_max_used > 0 && desc_blk->block_ptr[desc_blk->n_max_used - 1].type == 0; desc_blk->n_max_used--) 198 ; 199 } 200 201 return 0; 202 } 203 204 205static int 206ether_add_proto_internal( 207 struct ifnet *ifp, 208 protocol_family_t protocol, 209 const struct ifnet_demux_desc *demux) 210{ 211 struct en_desc *ed; 212 struct ether_desc_blk_str *desc_blk = (struct ether_desc_blk_str *)ifp->family_cookie; 213 u_int32_t i; 214 215 switch (demux->type) { 216 /* These types are supported */ 217 /* Top three are preferred */ 218 case DLIL_DESC_ETYPE2: 219 if (demux->datalen != 2) { 220 return EINVAL; 221 } 222 break; 223 224 case DLIL_DESC_SAP: 225 if (demux->datalen != 3) { 226 return EINVAL; 227 } 228 break; 229 230 case DLIL_DESC_SNAP: 231 if (demux->datalen != 5) { 232 return EINVAL; 233 } 234 break; 235 236 default: 237 return ENOTSUP; 238 } 239 240 // Verify a matching descriptor does not exist. 241 if (desc_blk != NULL) { 242 switch (demux->type) { 243 case DLIL_DESC_ETYPE2: 244 for (i = 0; i < desc_blk->n_max_used; i++) { 245 if (desc_blk->block_ptr[i].type == DLIL_DESC_ETYPE2 && 246 desc_blk->block_ptr[i].data[0] == 247 *(u_int16_t*)demux->data) { 248 return EADDRINUSE; 249 } 250 } 251 break; 252 case DLIL_DESC_SAP: 253 case DLIL_DESC_SNAP: 254 for (i = 0; i < desc_blk->n_max_used; i++) { 255 if (desc_blk->block_ptr[i].type == demux->type && 256 bcmp(desc_blk->block_ptr[i].data, demux->data, 257 demux->datalen) == 0) { 258 return EADDRINUSE; 259 } 260 } 261 break; 262 } 263 } 264 265 // Check for case where all of the descriptor blocks are in use 266 if (desc_blk == NULL || desc_blk->n_used == desc_blk->n_count) { 267 struct ether_desc_blk_str *tmp; 268 u_long new_count = ETHER_DESC_BLK_SIZE; 269 u_long new_size; 270 u_long old_size = 0; 271 272 i = 0; 273 274 if (desc_blk) { 275 new_count += desc_blk->n_count; 276 old_size = desc_blk->n_count * sizeof(struct en_desc) + ETHER_DESC_HEADER_SIZE; 277 i = desc_blk->n_used; 278 } 279 280 new_size = new_count * sizeof(struct en_desc) + ETHER_DESC_HEADER_SIZE; 281 282 tmp = _MALLOC(new_size, M_IFADDR, M_WAITOK); 283 if (tmp == 0) { 284 /* 285 * Remove any previous descriptors set in the call. 286 */ 287 return ENOMEM; 288 } 289 290 bzero(((char *)tmp) + old_size, new_size - old_size); 291 if (desc_blk) { 292 bcopy(desc_blk, tmp, old_size); 293 FREE(desc_blk, M_IFADDR); 294 } 295 desc_blk = tmp; 296 ifp->family_cookie = (u_long)desc_blk; 297 desc_blk->n_count = new_count; 298 } 299 else { 300 /* Find a free entry */ 301 for (i = 0; i < desc_blk->n_count; i++) { 302 if (desc_blk->block_ptr[i].type == 0) { 303 break; 304 } 305 } 306 } 307 308 /* Bump n_max_used if appropriate */ 309 if (i + 1 > desc_blk->n_max_used) { 310 desc_blk->n_max_used = i + 1; 311 } 312 313 ed = &desc_blk->block_ptr[i]; 314 ed->protocol_family = protocol; 315 ed->data[0] = 0; 316 ed->data[1] = 0; 317 318 switch (demux->type) { 319 case DLIL_DESC_ETYPE2: 320 /* 2 byte ethernet raw protocol type is at native_type */ 321 /* prtocol must be in network byte order */ 322 ed->type = DLIL_DESC_ETYPE2; 323 ed->data[0] = *(u_int16_t*)demux->data; 324 break; 325 326 case DLIL_DESC_SAP: 327 ed->type = DLIL_DESC_SAP; 328 bcopy(demux->data, &ed->data[0], 3); 329 break; 330 331 case DLIL_DESC_SNAP: { 332 u_int8_t* pDest = ((u_int8_t*)&ed->data[0]) + 3; 333 ed->type = DLIL_DESC_SNAP; 334 bcopy(demux->data, pDest, 5); 335 } 336 break; 337 } 338 339 desc_blk->n_used++; 340 341 return 0; 342} 343 344int 345ether_add_proto( 346 ifnet_t ifp, 347 protocol_family_t protocol, 348 const struct ifnet_demux_desc *demux_list, 349 u_int32_t demux_count) 350{ 351 int error = 0; 352 u_int32_t i; 353 354 for (i = 0; i < demux_count; i++) { 355 error = ether_add_proto_internal(ifp, protocol, &demux_list[i]); 356 if (error) { 357 ether_del_proto(ifp, protocol); 358 break; 359 } 360 } 361 362 return error; 363} 364 365int 366ether_demux( 367 ifnet_t ifp, 368 mbuf_t m, 369 char *frame_header, 370 protocol_family_t *protocol_family) 371{ 372 struct ether_header *eh = (struct ether_header *)frame_header; 373 u_short ether_type = eh->ether_type; 374 u_int16_t type; 375 u_int8_t *data; 376 u_long i = 0; 377 struct ether_desc_blk_str *desc_blk = (struct ether_desc_blk_str *)ifp->family_cookie; 378 u_long maxd = desc_blk ? desc_blk->n_max_used : 0; 379 struct en_desc *ed = desc_blk ? desc_blk->block_ptr : NULL; 380 u_int32_t extProto1 = 0; 381 u_int32_t extProto2 = 0; 382 383 if (eh->ether_dhost[0] & 1) { 384 /* Check for broadcast */ 385 if (_ether_cmp(etherbroadcastaddr, eh->ether_dhost) == 0) 386 m->m_flags |= M_BCAST; 387 else 388 m->m_flags |= M_MCAST; 389 } 390 391 if (ifp->if_eflags & IFEF_BOND) { 392 /* if we're bonded, bond "protocol" gets all the packets */ 393 *protocol_family = PF_BOND; 394 return (0); 395 } 396 397 if ((eh->ether_dhost[0] & 1) == 0) { 398 /* 399 * When the driver is put into promiscuous mode we may receive unicast 400 * frames that are not intended for our interfaces. They are marked here 401 * as being promiscuous so the caller may dispose of them after passing 402 * the packets to any interface filters. 403 */ 404 if (_ether_cmp(eh->ether_dhost, ifnet_lladdr(ifp))) { 405 m->m_flags |= M_PROMISC; 406 } 407 } 408 409 /* check for VLAN */ 410 if ((m->m_pkthdr.csum_flags & CSUM_VLAN_TAG_VALID) != 0) { 411 if (EVL_VLANOFTAG(m->m_pkthdr.vlan_tag) != 0) { 412 *protocol_family = PF_VLAN; 413 return (0); 414 } 415 /* the packet is just priority-tagged, clear the bit */ 416 m->m_pkthdr.csum_flags &= ~CSUM_VLAN_TAG_VALID; 417 } 418 else if (ether_type == htons(ETHERTYPE_VLAN)) { 419 struct ether_vlan_header * evl; 420 421 evl = (struct ether_vlan_header *)frame_header; 422 if (m->m_len < ETHER_VLAN_ENCAP_LEN 423 || ntohs(evl->evl_proto) == ETHERTYPE_VLAN 424 || EVL_VLANOFTAG(ntohs(evl->evl_tag)) != 0) { 425 *protocol_family = PF_VLAN; 426 return 0; 427 } 428 /* the packet is just priority-tagged */ 429 430 /* make the encapsulated ethertype the actual ethertype */ 431 ether_type = evl->evl_encap_proto = evl->evl_proto; 432 433 /* remove the encapsulation header */ 434 m->m_len -= ETHER_VLAN_ENCAP_LEN; 435 m->m_data += ETHER_VLAN_ENCAP_LEN; 436 m->m_pkthdr.len -= ETHER_VLAN_ENCAP_LEN; 437 m->m_pkthdr.csum_flags = 0; /* can't trust hardware checksum */ 438 } 439 440 data = mtod(m, u_int8_t*); 441 442 /* 443 * Determine the packet's protocol type and stuff the protocol into 444 * longs for quick compares. 445 */ 446 447 if (ntohs(ether_type) <= 1500) { 448 extProto1 = *(u_int32_t*)data; 449 450 // SAP or SNAP 451 if ((extProto1 & htonl(0xFFFFFF00)) == htonl(0xAAAA0300)) { 452 // SNAP 453 type = DLIL_DESC_SNAP; 454 extProto2 = *(u_int32_t*)(data + sizeof(u_int32_t)); 455 extProto1 &= htonl(0x000000FF); 456 } else { 457 type = DLIL_DESC_SAP; 458 extProto1 &= htonl(0xFFFFFF00); 459 } 460 } else { 461 type = DLIL_DESC_ETYPE2; 462 } 463 464 /* 465 * Search through the connected protocols for a match. 466 */ 467 468 switch (type) { 469 case DLIL_DESC_ETYPE2: 470 for (i = 0; i < maxd; i++) { 471 if ((ed[i].type == type) && (ed[i].data[0] == ether_type)) { 472 *protocol_family = ed[i].protocol_family; 473 return 0; 474 } 475 } 476 break; 477 478 case DLIL_DESC_SAP: 479 for (i = 0; i < maxd; i++) { 480 if ((ed[i].type == type) && (ed[i].data[0] == extProto1)) { 481 *protocol_family = ed[i].protocol_family; 482 return 0; 483 } 484 } 485 break; 486 487 case DLIL_DESC_SNAP: 488 for (i = 0; i < maxd; i++) { 489 if ((ed[i].type == type) && (ed[i].data[0] == extProto1) && 490 (ed[i].data[1] == extProto2)) { 491 *protocol_family = ed[i].protocol_family; 492 return 0; 493 } 494 } 495 break; 496 } 497 498 return ENOENT; 499} 500 501/* 502 * Ethernet output routine. 503 * Encapsulate a packet of type family for the local net. 504 * Use trailer local net encapsulation if enough data in first 505 * packet leaves a multiple of 512 bytes of data in remainder. 506 */ 507int 508ether_frameout( 509 struct ifnet *ifp, 510 struct mbuf **m, 511 const struct sockaddr *ndest, 512 const char *edst, 513 const char *ether_type) 514{ 515 struct ether_header *eh; 516 int hlen; /* link layer header length */ 517 518 hlen = ETHER_HDR_LEN; 519 520 /* 521 * If a simplex interface, and the packet is being sent to our 522 * Ethernet address or a broadcast address, loopback a copy. 523 * XXX To make a simplex device behave exactly like a duplex 524 * device, we should copy in the case of sending to our own 525 * ethernet address (thus letting the original actually appear 526 * on the wire). However, we don't do that here for security 527 * reasons and compatibility with the original behavior. 528 */ 529 if ((ifp->if_flags & IFF_SIMPLEX) && 530 ((*m)->m_flags & M_LOOP)) { 531 if (lo_ifp) { 532 if ((*m)->m_flags & M_BCAST) { 533 struct mbuf *n = m_copy(*m, 0, (int)M_COPYALL); 534 if (n != NULL) 535 dlil_output(lo_ifp, ndest->sa_family, n, NULL, ndest, 0); 536 } 537 else { 538 if (_ether_cmp(edst, ifnet_lladdr(ifp)) == 0) { 539 dlil_output(lo_ifp, ndest->sa_family, *m, NULL, ndest, 0); 540 return EJUSTRETURN; 541 } 542 } 543 } 544 } 545 546 /* 547 * Add local net header. If no space in first mbuf, 548 * allocate another. 549 */ 550 M_PREPEND(*m, sizeof (struct ether_header), M_DONTWAIT); 551 if (*m == 0) { 552 return (EJUSTRETURN); 553 } 554 555 556 eh = mtod(*m, struct ether_header *); 557 (void)memcpy(&eh->ether_type, ether_type, 558 sizeof(eh->ether_type)); 559 (void)memcpy(eh->ether_dhost, edst, ETHER_ADDR_LEN); 560 ifnet_lladdr_copy_bytes(ifp, eh->ether_shost, ETHER_ADDR_LEN); 561 562 return 0; 563} 564 565errno_t 566ether_check_multi( 567 __unused ifnet_t ifp, 568 const struct sockaddr *proto_addr) 569{ 570 errno_t result = EAFNOSUPPORT; 571 const u_char *e_addr; 572 573 /* 574 * AF_SPEC and AF_LINK don't require translation. We do 575 * want to verify that they specify a valid multicast. 576 */ 577 switch(proto_addr->sa_family) { 578 case AF_UNSPEC: 579 e_addr = (const u_char*)&proto_addr->sa_data[0]; 580 if ((e_addr[0] & 0x01) != 0x01) 581 result = EADDRNOTAVAIL; 582 else 583 result = 0; 584 break; 585 586 case AF_LINK: 587 e_addr = CONST_LLADDR((const struct sockaddr_dl*)proto_addr); 588 if ((e_addr[0] & 0x01) != 0x01) 589 result = EADDRNOTAVAIL; 590 else 591 result = 0; 592 break; 593 } 594 595 return result; 596} 597 598int 599ether_ioctl( 600 __unused ifnet_t ifp, 601 __unused u_int32_t command, 602 __unused void* data) 603{ 604 return EOPNOTSUPP; 605} 606 607__private_extern__ int ether_family_init(void) 608{ 609 errno_t error = 0; 610 611 /* Register protocol registration functions */ 612 if ((error = proto_register_plumber(PF_INET, APPLE_IF_FAM_ETHERNET, 613 ether_attach_inet, ether_detach_inet)) != 0) { 614 printf("proto_register_plumber failed for PF_INET error=%d\n", error); 615 goto done; 616 } 617#if INET6 618 if ((error = proto_register_plumber(PF_INET6, APPLE_IF_FAM_ETHERNET, 619 ether_attach_inet6, ether_detach_inet6)) != 0) { 620 printf("proto_register_plumber failed for PF_INET6 error=%d\n", error); 621 goto done; 622 } 623#endif /* INET6 */ 624#if NETAT 625 if ((error = proto_register_plumber(PF_APPLETALK, APPLE_IF_FAM_ETHERNET, 626 ether_attach_at, ether_detach_at)) != 0) { 627 printf("proto_register_plumber failed PF_APPLETALK error=%d\n", error); 628 goto done; 629 } 630#endif /* NETAT */ 631#if VLAN 632 vlan_family_init(); 633#endif /* VLAN */ 634#if BOND 635 bond_family_init(); 636#endif /* BOND */ 637 638 done: 639 640 return (error); 641} 642