bsd/net/if_ethersubr.c

   1 /*
   2  * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * Copyright (c) 1999-2003 Apple Computer, Inc.  All Rights Reserved.
   7  *
   8  * This file contains Original Code and/or Modifications of Original Code
   9  * as defined in and that are subject to the Apple Public Source License
  10  * Version 2.0 (the 'License'). You may not use this file except in
  11  * compliance with the License. Please obtain a copy of the License at
  12  * http://www.opensource.apple.com/apsl/ and read it before using this
  13  * file.
  14  *
  15  * The Original Code and all software distributed under the License are
  16  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  17  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  18  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  20  * Please see the License for the specific language governing rights and
  21  * limitations under the License.
  22  *
  23  * @APPLE_LICENSE_HEADER_END@
  24  */
  25 /*
  26  * Copyright (c) 1982, 1989, 1993
  27  *      The Regents of the University of California.  All rights reserved.
  28  *
  29  * Redistribution and use in source and binary forms, with or without
  30  * modification, are permitted provided that the following conditions
  31  * are met:
  32  * 1. Redistributions of source code must retain the above copyright
  33  *    notice, this list of conditions and the following disclaimer.
  34  * 2. Redistributions in binary form must reproduce the above copyright
  35  *    notice, this list of conditions and the following disclaimer in the
  36  *    documentation and/or other materials provided with the distribution.
  37  * 3. All advertising materials mentioning features or use of this software
  38  *    must display the following acknowledgement:
  39  *      This product includes software developed by the University of
  40  *      California, Berkeley and its contributors.
  41  * 4. Neither the name of the University nor the names of its contributors
  42  *    may be used to endorse or promote products derived from this software
  43  *    without specific prior written permission.
  44  *
  45  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  46  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  47  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  48  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  49  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  50  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  51  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  52  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  53  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  54  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  55  * SUCH DAMAGE.
  56  *
  57  *      @(#)if_ethersubr.c      8.1 (Berkeley) 6/10/93
  58  * $FreeBSD: src/sys/net/if_ethersubr.c,v 1.70.2.17 2001/08/01 00:47:49 fenner Exp $
  59  */
  60
  61 #include <sys/param.h>
  62 #include <sys/systm.h>
  63 #include <sys/kernel.h>
  64 #include <sys/malloc.h>
  65 #include <sys/mbuf.h>
  66 #include <sys/socket.h>
  67 #include <sys/sockio.h>
  68 #include <sys/sysctl.h>
  69
  70 #include <net/if.h>
  71 #include <net/netisr.h>
  72 #include <net/route.h>
  73 #include <net/if_llc.h>
  74 #include <net/if_dl.h>
  75 #include <net/if_types.h>
  76
  77 #if INET || INET6
  78 #include <netinet/in.h>
  79 #include <netinet/in_var.h>
  80 #include <netinet/if_ether.h>
  81 #include <netinet/in_systm.h>
  82 #include <netinet/ip.h>
  83 #endif
  84
  85 #if IPX
  86 #include <netipx/ipx.h>
  87 #include <netipx/ipx_if.h>
  88 #endif
  89
  90 #include <sys/socketvar.h>
  91
  92 #if LLC && CCITT
  93 extern struct ifqueue pkintrq;
  94 #endif
  95
  96 #if BRIDGE
  97 #include <net/bridge.h>
  98 #endif
  99
 100 /* #include "vlan.h" */
 101 #if NVLAN > 0
 102 #include <net/if_vlan_var.h>
 103 #endif /* NVLAN > 0 */
 104
 105 extern u_char   etherbroadcastaddr[];
 106 #define senderr(e) do { error = (e); goto bad;} while (0)
 107 #define IFP2AC(IFP) ((struct arpcom *)IFP)
 108
 109 /*
 110  * Perform common duties while attaching to interface list
 111  */
 112
 113
 114 /*
 115     IONetworkingFamily should call dlil_if_attach
 116     ether_ifattach becomes obsolete, but remains for
 117     temporary compatibility with third parties extensions
 118 */
 119 void
 120 ether_ifattach(ifp)
 121         register struct ifnet *ifp;
 122 {
 123         boolean_t funnel_state;
 124
 125         funnel_state = thread_funnel_set(network_flock, TRUE);
 126
 127         ifp->if_name = "en";
 128         ifp->if_family = APPLE_IF_FAM_ETHERNET;
 129         ifp->if_type = IFT_ETHER;
 130         ifp->if_addrlen = 6;
 131         ifp->if_hdrlen = 14;
 132         ifp->if_mtu = ETHERMTU;
 133         if (ifp->if_baudrate == 0)
 134             ifp->if_baudrate = 10000000;
 135
 136         dlil_if_attach(ifp);
 137         (void) thread_funnel_set(network_flock, funnel_state);
 138 }
 139
 140 SYSCTL_DECL(_net_link);
 141 SYSCTL_NODE(_net_link, IFT_ETHER, ether, CTLFLAG_RW, 0, "Ethernet");
 142
 143 int
 144 ether_resolvemulti(ifp, llsa, sa)
 145         struct ifnet *ifp;
 146         struct sockaddr **llsa;
 147         struct sockaddr *sa;
 148 {
 149         struct sockaddr_dl *sdl;
 150         struct sockaddr_in *sin;
 151         u_char *e_addr;
 152 #if INET6
 153         struct sockaddr_in6 *sin6;
 154 #endif
 155
 156
 157         switch(sa->sa_family) {
 158         case AF_UNSPEC:
 159                 /* AppleTalk uses AF_UNSPEC for multicast registration.
 160                  * No mapping needed. Just check that it's a valid MC address.
 161                  */
 162                 e_addr = &sa->sa_data[0];
 163                 if ((e_addr[0] & 1) != 1)
 164                         return EADDRNOTAVAIL;
 165                 *llsa = 0;
 166                 return 0;
 167
 168         case AF_LINK:
 169                 /*
 170                  * No mapping needed. Just check that it's a valid MC address.
 171                  */
 172                 sdl = (struct sockaddr_dl *)sa;
 173                 e_addr = LLADDR(sdl);
 174                 if ((e_addr[0] & 1) != 1)
 175                         return EADDRNOTAVAIL;
 176                 *llsa = 0;
 177                 return 0;
 178
 179 #if INET
 180         case AF_INET:
 181                 sin = (struct sockaddr_in *)sa;
 182                 if (!IN_MULTICAST(ntohl(sin->sin_addr.s_addr)))
 183                         return EADDRNOTAVAIL;
 184                 MALLOC(sdl, struct sockaddr_dl *, sizeof *sdl, M_IFMADDR,
 185                        M_WAITOK);
 186                 sdl->sdl_len = sizeof *sdl;
 187                 sdl->sdl_family = AF_LINK;
 188                 sdl->sdl_index = ifp->if_index;
 189                 sdl->sdl_type = IFT_ETHER;
 190                 sdl->sdl_nlen = 0;
 191                 sdl->sdl_alen = ETHER_ADDR_LEN;
 192                 sdl->sdl_slen = 0;
 193                 e_addr = LLADDR(sdl);
 194                 ETHER_MAP_IP_MULTICAST(&sin->sin_addr, e_addr);
 195                 *llsa = (struct sockaddr *)sdl;
 196                 return 0;
 197 #endif
 198 #if INET6
 199         case AF_INET6:
 200                 sin6 = (struct sockaddr_in6 *)sa;
 201                 if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
 202                         /*
 203                          * An IP6 address of 0 means listen to all
 204                          * of the Ethernet multicast address used for IP6.
 205                          * (This is used for multicast routers.)
 206                          */
 207                         ifp->if_flags |= IFF_ALLMULTI;
 208                         *llsa = 0;
 209                         return 0;
 210                 }
 211                 MALLOC(sdl, struct sockaddr_dl *, sizeof *sdl, M_IFMADDR,
 212                        M_WAITOK);
 213                 sdl->sdl_len = sizeof *sdl;
 214                 sdl->sdl_family = AF_LINK;
 215                 sdl->sdl_index = ifp->if_index;
 216                 sdl->sdl_type = IFT_ETHER;
 217                 sdl->sdl_nlen = 0;
 218                 sdl->sdl_alen = ETHER_ADDR_LEN;
 219                 sdl->sdl_slen = 0;
 220                 e_addr = LLADDR(sdl);
 221                 ETHER_MAP_IPV6_MULTICAST(&sin6->sin6_addr, e_addr);
 222                 kprintf("ether_resolvemulti Adding %x:%x:%x:%x:%x:%x\n",
 223                                 e_addr[0], e_addr[1], e_addr[2], e_addr[3], e_addr[4], e_addr[5]);
 224                 *llsa = (struct sockaddr *)sdl;
 225                 return 0;
 226 #endif
 227
 228         default:
 229                 /*
 230                  * Well, the text isn't quite right, but it's the name
 231                  * that counts...
 232                  */
 233                 return EAFNOSUPPORT;
 234         }
 235 }
 236
 237
 238
 239
 240
 241 u_char  ether_ipmulticast_min[6] = { 0x01, 0x00, 0x5e, 0x00, 0x00, 0x00 };
 242 u_char  ether_ipmulticast_max[6] = { 0x01, 0x00, 0x5e, 0x7f, 0xff, 0xff };
 243 /*
 244  * Add an Ethernet multicast address or range of addresses to the list for a
 245  * given interface.
 246  */
 247 int
 248 ether_addmulti(ifr, ac)
 249         struct ifreq *ifr;
 250         register struct arpcom *ac;
 251 {
 252         register struct ether_multi *enm;
 253         struct sockaddr_in *sin;
 254         u_char addrlo[6];
 255         u_char addrhi[6];
 256         int s = splimp();
 257
 258         switch (ifr->ifr_addr.sa_family) {
 259
 260         case AF_UNSPEC:
 261                 bcopy(ifr->ifr_addr.sa_data, addrlo, 6);
 262                 bcopy(addrlo, addrhi, 6);
 263                 break;
 264
 265 #if INET
 266         case AF_INET:
 267                 sin = (struct sockaddr_in *)&(ifr->ifr_addr);
 268                 if (sin->sin_addr.s_addr == INADDR_ANY) {
 269                         /*
 270                          * An IP address of INADDR_ANY means listen to all
 271                          * of the Ethernet multicast addresses used for IP.
 272                          * (This is for the sake of IP multicast routers.)
 273                          */
 274                         bcopy(ether_ipmulticast_min, addrlo, 6);
 275                         bcopy(ether_ipmulticast_max, addrhi, 6);
 276                 }
 277                 else {
 278                         ETHER_MAP_IP_MULTICAST(&sin->sin_addr, addrlo);
 279                         bcopy(addrlo, addrhi, 6);
 280                 }
 281                 break;
 282 #endif
 283
 284         default:
 285                 splx(s);
 286                 return (EAFNOSUPPORT);
 287         }
 288
 289         /*
 290          * Verify that we have valid Ethernet multicast addresses.
 291          */
 292         if ((addrlo[0] & 0x01) != 1 || (addrhi[0] & 0x01) != 1) {
 293                 splx(s);
 294                 return (EINVAL);
 295         }
 296         /*
 297          * See if the address range is already in the list.
 298          */
 299         ETHER_LOOKUP_MULTI(addrlo, addrhi, ac, enm);
 300         if (enm != NULL) {
 301                 /*
 302                  * Found it; just increment the reference count.
 303                  */
 304                 ++enm->enm_refcount;
 305                 splx(s);
 306                 return (0);
 307         }
 308         /*
 309          * New address or range; malloc a new multicast record
 310          * and link it into the interface's multicast list.
 311          */
 312         enm = (struct ether_multi *)_MALLOC(sizeof(*enm), M_IFMADDR, M_WAITOK);
 313         if (enm == NULL) {
 314                 splx(s);
 315                 return (ENOBUFS);
 316         }
 317         bcopy(addrlo, enm->enm_addrlo, 6);
 318         bcopy(addrhi, enm->enm_addrhi, 6);
 319         enm->enm_ac = ac;
 320         enm->enm_refcount = 1;
 321         enm->enm_next = ac->ac_multiaddrs;
 322         ac->ac_multiaddrs = enm;
 323         splx(s);
 324         /*
 325          * Return ENETRESET to inform the driver that the list has changed
 326          * and its reception filter should be adjusted accordingly.
 327          */
 328         return (ENETRESET);
 329 }
 330
 331 /*
 332  * Delete a multicast address record.
 333  */
 334 int
 335 ether_delmulti(ifr, ac, ret_mca)
 336         struct ifreq *ifr;
 337         register struct arpcom *ac;
 338         struct ether_addr * ret_mca;
 339 {
 340         register struct ether_multi *enm;
 341         register struct ether_multi **p;
 342         struct sockaddr_in *sin;
 343         u_char addrlo[6];
 344         u_char addrhi[6];
 345         int s = splimp();
 346
 347         switch (ifr->ifr_addr.sa_family) {
 348
 349         case AF_UNSPEC:
 350                 bcopy(ifr->ifr_addr.sa_data, addrlo, 6);
 351                 bcopy(addrlo, addrhi, 6);
 352                 break;
 353
 354 #if INET
 355         case AF_INET:
 356                 sin = (struct sockaddr_in *)&(ifr->ifr_addr);
 357                 if (sin->sin_addr.s_addr == INADDR_ANY) {
 358                         /*
 359                          * An IP address of INADDR_ANY means stop listening
 360                          * to the range of Ethernet multicast addresses used
 361                          * for IP.
 362                          */
 363                         bcopy(ether_ipmulticast_min, addrlo, 6);
 364                         bcopy(ether_ipmulticast_max, addrhi, 6);
 365                 }
 366                 else {
 367                         ETHER_MAP_IP_MULTICAST(&sin->sin_addr, addrlo);
 368                         bcopy(addrlo, addrhi, 6);
 369                 }
 370                 break;
 371 #endif
 372
 373         default:
 374                 splx(s);
 375                 return (EAFNOSUPPORT);
 376         }
 377
 378         /*
 379          * Look up the address in our list.
 380          */
 381         ETHER_LOOKUP_MULTI(addrlo, addrhi, ac, enm);
 382         if (enm == NULL) {
 383                 splx(s);
 384                 return (ENXIO);
 385         }
 386         if (--enm->enm_refcount != 0) {
 387                 /*
 388                  * Still some claims to this record.
 389                  */
 390                 splx(s);
 391                 return (0);
 392         }
 393
 394         /* save the low and high address of the range before deletion */
 395         if (ret_mca) {
 396                 *ret_mca        = *((struct ether_addr *)addrlo);
 397                 *(ret_mca + 1)  = *((struct ether_addr *)addrhi);
 398         }
 399
 400         /*
 401          * No remaining claims to this record; unlink and free it.
 402          */
 403         for (p = &enm->enm_ac->ac_multiaddrs;
 404              *p != enm;
 405              p = &(*p)->enm_next)
 406                 continue;
 407         *p = (*p)->enm_next;
 408         FREE(enm, M_IFMADDR);
 409         splx(s);
 410         /*
 411          * Return ENETRESET to inform the driver that the list has changed
 412          * and its reception filter should be adjusted accordingly.
 413          */
 414         return (ENETRESET);
 415 }
 416
 417 /*
 418  * Convert Ethernet address to printable (loggable) representation.
 419  */
 420 static u_char digits[] = "0123456789abcdef";
 421 char *
 422 ether_sprintf(p, ap)
 423         register u_char *p;
 424         register u_char *ap;
 425 {       register char *cp;
 426         register i;
 427
 428         for (cp = p, i = 0; i < 6; i++) {
 429                 *cp++ = digits[*ap >> 4];
 430                 *cp++ = digits[*ap++ & 0xf];
 431                 *cp++ = ':';
 432         }
 433         *--cp = 0;
 434         return (p);
 435 }