bsd/net/ether_if_module.c

   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
 103 extern 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
 110 extern 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
 121 SYSCTL_DECL(_net_link);
 122 SYSCTL_NODE(_net_link, IFT_ETHER, ether, CTLFLAG_RW|CTLFLAG_LOCKED, 0, "Ethernet");
 123
 124 struct 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
 141 struct 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
 152 static __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  */
 171 int
 172 ether_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
 205 static int
 206 ether_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
 344 int
 345 ether_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
 365 int
 366 ether_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         /* Quick check for VLAN */
 410         if ((m->m_pkthdr.csum_flags & CSUM_VLAN_TAG_VALID) != 0 ||
 411                 ether_type == htons(ETHERTYPE_VLAN)) {
 412                 *protocol_family = PF_VLAN;
 413                 return 0;
 414         }
 415
 416         data = mtod(m, u_int8_t*);
 417
 418         /*
 419         * Determine the packet's protocol type and stuff the protocol into
 420         * longs for quick compares.
 421         */
 422
 423         if (ntohs(ether_type) <= 1500) {
 424                 extProto1 = *(u_int32_t*)data;
 425
 426                 // SAP or SNAP
 427                 if ((extProto1 & htonl(0xFFFFFF00)) == htonl(0xAAAA0300)) {
 428                         // SNAP
 429                         type = DLIL_DESC_SNAP;
 430                         extProto2 = *(u_int32_t*)(data + sizeof(u_int32_t));
 431                         extProto1 &= htonl(0x000000FF);
 432                 } else {
 433                         type = DLIL_DESC_SAP;
 434                         extProto1 &= htonl(0xFFFFFF00);
 435                 }
 436         } else {
 437                 type = DLIL_DESC_ETYPE2;
 438         }
 439
 440         /*
 441         * Search through the connected protocols for a match.
 442         */
 443
 444         switch (type) {
 445                 case DLIL_DESC_ETYPE2:
 446                         for (i = 0; i < maxd; i++) {
 447                                 if ((ed[i].type == type) && (ed[i].data[0] == ether_type)) {
 448                                         *protocol_family = ed[i].protocol_family;
 449                                         return 0;
 450                                 }
 451                         }
 452                         break;
 453
 454                 case DLIL_DESC_SAP:
 455                         for (i = 0; i < maxd; i++) {
 456                                 if ((ed[i].type == type) && (ed[i].data[0] == extProto1)) {
 457                                         *protocol_family = ed[i].protocol_family;
 458                                         return 0;
 459                                 }
 460                         }
 461                         break;
 462
 463                 case DLIL_DESC_SNAP:
 464                         for (i = 0; i < maxd; i++) {
 465                                 if ((ed[i].type == type) && (ed[i].data[0] == extProto1) &&
 466                                         (ed[i].data[1] == extProto2)) {
 467                                         *protocol_family = ed[i].protocol_family;
 468                                         return 0;
 469                                 }
 470                         }
 471                 break;
 472         }
 473
 474         return ENOENT;
 475 }
 476
 477 /*
 478  * Ethernet output routine.
 479  * Encapsulate a packet of type family for the local net.
 480  * Use trailer local net encapsulation if enough data in first
 481  * packet leaves a multiple of 512 bytes of data in remainder.
 482  */
 483 int
 484 ether_frameout(
 485         struct ifnet                    *ifp,
 486         struct mbuf                             **m,
 487         const struct sockaddr   *ndest,
 488         const char                              *edst,
 489         const char                              *ether_type)
 490 {
 491         struct ether_header *eh;
 492         int hlen;       /* link layer header length */
 493
 494         hlen = ETHER_HDR_LEN;
 495
 496         /*
 497          * If a simplex interface, and the packet is being sent to our
 498          * Ethernet address or a broadcast address, loopback a copy.
 499          * XXX To make a simplex device behave exactly like a duplex
 500          * device, we should copy in the case of sending to our own
 501          * ethernet address (thus letting the original actually appear
 502          * on the wire). However, we don't do that here for security
 503          * reasons and compatibility with the original behavior.
 504          */
 505         if ((ifp->if_flags & IFF_SIMPLEX) &&
 506             ((*m)->m_flags & M_LOOP)) {
 507             if (lo_ifp) {
 508             if ((*m)->m_flags & M_BCAST) {
 509                 struct mbuf *n = m_copy(*m, 0, (int)M_COPYALL);
 510                 if (n != NULL)
 511                     dlil_output(lo_ifp, ndest->sa_family, n, NULL, ndest, 0);
 512             }
 513             else {
 514                                         if (_ether_cmp(edst, ifnet_lladdr(ifp)) == 0) {
 515                     dlil_output(lo_ifp, ndest->sa_family, *m, NULL, ndest, 0);
 516                     return EJUSTRETURN;
 517                 }
 518             }
 519             }
 520         }
 521
 522         /*
 523          * Add local net header.  If no space in first mbuf,
 524          * allocate another.
 525          */
 526         M_PREPEND(*m, sizeof (struct ether_header), M_DONTWAIT);
 527         if (*m == 0) {
 528             return (EJUSTRETURN);
 529         }
 530
 531
 532         eh = mtod(*m, struct ether_header *);
 533         (void)memcpy(&eh->ether_type, ether_type,
 534                 sizeof(eh->ether_type));
 535         (void)memcpy(eh->ether_dhost, edst, ETHER_ADDR_LEN);
 536         ifnet_lladdr_copy_bytes(ifp, eh->ether_shost, ETHER_ADDR_LEN);
 537
 538         return 0;
 539 }
 540
 541 errno_t
 542 ether_check_multi(
 543         __unused ifnet_t                ifp,
 544         const struct sockaddr   *proto_addr)
 545 {
 546         errno_t result = EAFNOSUPPORT;
 547         const u_char *e_addr;
 548
 549         /*
 550          * AF_SPEC and AF_LINK don't require translation. We do
 551          * want to verify that they specify a valid multicast.
 552          */
 553         switch(proto_addr->sa_family) {
 554                 case AF_UNSPEC:
 555                         e_addr = (const u_char*)&proto_addr->sa_data[0];
 556                         if ((e_addr[0] & 0x01) != 0x01)
 557                                 result = EADDRNOTAVAIL;
 558                         else
 559                                 result = 0;
 560                         break;
 561
 562                 case AF_LINK:
 563                         e_addr = CONST_LLADDR((const struct sockaddr_dl*)proto_addr);
 564                         if ((e_addr[0] & 0x01) != 0x01)
 565                                 result = EADDRNOTAVAIL;
 566                         else
 567                                 result = 0;
 568                         break;
 569         }
 570
 571         return result;
 572 }
 573
 574 int
 575 ether_ioctl(
 576     __unused ifnet_t    ifp,
 577     __unused u_int32_t  command,
 578     __unused void*              data)
 579 {
 580         return EOPNOTSUPP;
 581 }
 582
 583 __private_extern__ int ether_family_init(void)
 584 {
 585         errno_t error = 0;
 586
 587         /* Register protocol registration functions */
 588         if ((error = proto_register_plumber(PF_INET, APPLE_IF_FAM_ETHERNET,
 589                                                                           ether_attach_inet, ether_detach_inet)) != 0) {
 590                 printf("proto_register_plumber failed for PF_INET error=%d\n", error);
 591                 goto done;
 592         }
 593 #if INET6
 594         if ((error = proto_register_plumber(PF_INET6, APPLE_IF_FAM_ETHERNET,
 595                                                                           ether_attach_inet6, ether_detach_inet6)) != 0) {
 596                 printf("proto_register_plumber failed for PF_INET6 error=%d\n", error);
 597                 goto done;
 598         }
 599 #endif /* INET6 */
 600 #if NETAT
 601         if ((error = proto_register_plumber(PF_APPLETALK, APPLE_IF_FAM_ETHERNET,
 602                                                                           ether_attach_at, ether_detach_at)) != 0) {
 603                 printf("proto_register_plumber failed PF_APPLETALK error=%d\n", error);
 604                 goto done;
 605         }
 606 #endif /* NETAT */
 607 #if VLAN
 608         vlan_family_init();
 609 #endif /* VLAN */
 610 #if BOND
 611         bond_family_init();
 612 #endif /* BOND */
 613
 614  done:
 615
 616     return (error);
 617 }