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         /* 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  */
 507 int
 508 ether_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
 565 errno_t
 566 ether_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
 598 int
 599 ether_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 }