bsd/netinet6/scope6.c

   1 /*
   2  * Copyright (c) 2009-2013 Apple 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 /*
  30  * Copyright (C) 2000 WIDE Project.
  31  * All rights reserved.
  32  *
  33  * Redistribution and use in source and binary forms, with or without
  34  * modification, are permitted provided that the following conditions
  35  * are met:
  36  * 1. Redistributions of source code must retain the above copyright
  37  *    notice, this list of conditions and the following disclaimer.
  38  * 2. Redistributions in binary form must reproduce the above copyright
  39  *    notice, this list of conditions and the following disclaimer in the
  40  *    documentation and/or other materials provided with the distribution.
  41  * 3. Neither the name of the project 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 PROJECT 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 PROJECT 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
  58 #include <sys/param.h>
  59 #include <sys/malloc.h>
  60 #include <sys/mbuf.h>
  61 #include <sys/socket.h>
  62 #include <sys/systm.h>
  63 #include <sys/queue.h>
  64 #include <sys/syslog.h>
  65 #include <sys/mcache.h>
  66
  67 #include <net/route.h>
  68 #include <net/if.h>
  69
  70 #include <netinet/in.h>
  71
  72 #include <netinet6/in6_var.h>
  73 #include <netinet6/scope6_var.h>
  74
  75 #ifdef ENABLE_DEFAULT_SCOPE
  76 int ip6_use_defzone = 1;
  77 #else
  78 int ip6_use_defzone = 0;
  79 #endif
  80
  81 decl_lck_mtx_data(static, scope6_lock);
  82 static struct scope6_id sid_default;
  83
  84 #define SID(ifp) &IN6_IFEXTRA(ifp)->scope6_id
  85
  86 void
  87 scope6_init(lck_grp_t *grp, lck_attr_t *attr)
  88 {
  89         bzero(&sid_default, sizeof(sid_default));
  90         lck_mtx_init(&scope6_lock, grp, attr);
  91 }
  92
  93 void
  94 scope6_ifattach(struct ifnet *ifp)
  95 {
  96         struct scope6_id *sid;
  97
  98         VERIFY(IN6_IFEXTRA(ifp) != NULL);
  99         if_inet6data_lock_exclusive(ifp);
 100         sid = SID(ifp);
 101         /* N.B.: the structure is already zero'ed */
 102         /*
 103          * XXX: IPV6_ADDR_SCOPE_xxx macros are not standard.
 104          * Should we rather hardcode here?
 105          */
 106         sid->s6id_list[IPV6_ADDR_SCOPE_INTFACELOCAL] = ifp->if_index;
 107         sid->s6id_list[IPV6_ADDR_SCOPE_LINKLOCAL] = ifp->if_index;
 108 #if MULTI_SCOPE
 109         /* by default, we don't care about scope boundary for these scopes. */
 110         sid->s6id_list[IPV6_ADDR_SCOPE_SITELOCAL] = 1;
 111         sid->s6id_list[IPV6_ADDR_SCOPE_ORGLOCAL] = 1;
 112 #endif
 113         if_inet6data_lock_done(ifp);
 114 }
 115
 116 /*
 117  * Get a scope of the address. Node-local, link-local, site-local or global.
 118  */
 119 int
 120 in6_addrscope(struct in6_addr *addr)
 121 {
 122         int scope;
 123
 124         if (addr->s6_addr8[0] == 0xfe) {
 125                 scope = addr->s6_addr8[1] & 0xc0;
 126
 127                 switch (scope) {
 128                 case 0x80:
 129                         return IPV6_ADDR_SCOPE_LINKLOCAL;
 130                 case 0xc0:
 131                         return IPV6_ADDR_SCOPE_SITELOCAL;
 132                 default:
 133                         return IPV6_ADDR_SCOPE_GLOBAL; /* just in case */
 134                 }
 135         }
 136
 137         if (addr->s6_addr8[0] == 0xff) {
 138                 scope = addr->s6_addr8[1] & 0x0f;
 139
 140                 /*
 141                  * due to other scope such as reserved,
 142                  * return scope doesn't work.
 143                  */
 144                 switch (scope) {
 145                 case IPV6_ADDR_SCOPE_INTFACELOCAL:
 146                         return IPV6_ADDR_SCOPE_INTFACELOCAL;
 147                 case IPV6_ADDR_SCOPE_LINKLOCAL:
 148                         return IPV6_ADDR_SCOPE_LINKLOCAL;
 149                 case IPV6_ADDR_SCOPE_SITELOCAL:
 150                         return IPV6_ADDR_SCOPE_SITELOCAL;
 151                 default:
 152                         return IPV6_ADDR_SCOPE_GLOBAL;
 153                 }
 154         }
 155
 156         /*
 157          * Regard loopback and unspecified addresses as global, since
 158          * they have no ambiguity.
 159          */
 160         if (bcmp(&in6addr_loopback, addr, sizeof(*addr) - 1) == 0) {
 161                 if (addr->s6_addr8[15] == 1) { /* loopback */
 162                         return IPV6_ADDR_SCOPE_LINKLOCAL;
 163                 }
 164                 if (addr->s6_addr8[15] == 0) { /* unspecified */
 165                         return IPV6_ADDR_SCOPE_GLOBAL; /* XXX: correct? */
 166                 }
 167         }
 168
 169         return IPV6_ADDR_SCOPE_GLOBAL;
 170 }
 171
 172 int
 173 in6_addr2scopeid(struct ifnet *ifp, struct in6_addr *addr)
 174 {
 175         int scope = in6_addrscope(addr);
 176         int retid = 0;
 177         struct scope6_id *sid;
 178
 179         if_inet6data_lock_shared(ifp);
 180         if (IN6_IFEXTRA(ifp) == NULL) {
 181                 goto err;
 182         }
 183         sid = SID(ifp);
 184         switch (scope) {
 185         case IPV6_ADDR_SCOPE_NODELOCAL:
 186                 retid = -1;     /* XXX: is this an appropriate value? */
 187                 break;
 188         case IPV6_ADDR_SCOPE_LINKLOCAL:
 189                 retid = sid->s6id_list[IPV6_ADDR_SCOPE_LINKLOCAL];
 190                 break;
 191         case IPV6_ADDR_SCOPE_SITELOCAL:
 192                 retid = sid->s6id_list[IPV6_ADDR_SCOPE_SITELOCAL];
 193                 break;
 194         case IPV6_ADDR_SCOPE_ORGLOCAL:
 195                 retid = sid->s6id_list[IPV6_ADDR_SCOPE_ORGLOCAL];
 196                 break;
 197         default:
 198                 break;  /* XXX: value 0, treat as global. */
 199         }
 200 err:
 201         if_inet6data_lock_done(ifp);
 202
 203         return retid;
 204 }
 205
 206 /*
 207  * Validate the specified scope zone ID in the sin6_scope_id field.  If the ID
 208  * is unspecified (=0), needs to be specified, and the default zone ID can be
 209  * used, the default value will be used.
 210  * This routine then generates the kernel-internal form: if the address scope
 211  * of is interface-local or link-local, embed the interface index in the
 212  * address.
 213  */
 214 int
 215 sa6_embedscope(struct sockaddr_in6 *sin6, int defaultok)
 216 {
 217         struct ifnet *ifp;
 218         u_int32_t zoneid;
 219
 220         if ((zoneid = sin6->sin6_scope_id) == 0 && defaultok) {
 221                 zoneid = scope6_addr2default(&sin6->sin6_addr);
 222         }
 223
 224         if (zoneid != 0 &&
 225             (IN6_IS_SCOPE_LINKLOCAL(&sin6->sin6_addr) ||
 226             IN6_IS_ADDR_MC_INTFACELOCAL(&sin6->sin6_addr))) {
 227                 /*
 228                  * At this moment, we only check interface-local and
 229                  * link-local scope IDs, and use interface indices as the
 230                  * zone IDs assuming a one-to-one mapping between interfaces
 231                  * and links.
 232                  */
 233                 if (if_index < zoneid) {
 234                         return ENXIO;
 235                 }
 236                 ifnet_head_lock_shared();
 237                 ifp = ifindex2ifnet[zoneid];
 238                 if (ifp == NULL) {      /* XXX: this can happen for some OS */
 239                         ifnet_head_done();
 240                         return ENXIO;
 241                 }
 242                 ifnet_head_done();
 243                 /* XXX assignment to 16bit from 32bit variable */
 244                 sin6->sin6_addr.s6_addr16[1] = htons(zoneid & 0xffff);
 245
 246                 sin6->sin6_scope_id = 0;
 247         }
 248
 249         return 0;
 250 }
 251
 252 void
 253 rtkey_to_sa6(struct rtentry *rt, struct sockaddr_in6 *sin6)
 254 {
 255         VERIFY(rt_key(rt)->sa_family == AF_INET6);
 256
 257         *sin6 = *((struct sockaddr_in6 *)(void *)rt_key(rt));
 258         sin6->sin6_scope_id = 0;
 259 }
 260
 261 void
 262 rtgw_to_sa6(struct rtentry *rt, struct sockaddr_in6 *sin6)
 263 {
 264         VERIFY(rt->rt_flags & RTF_GATEWAY);
 265
 266         *sin6 = *((struct sockaddr_in6 *)(void *)rt->rt_gateway);
 267         sin6->sin6_scope_id = 0;
 268 }
 269
 270 /*
 271  * generate standard sockaddr_in6 from embedded form.
 272  */
 273 int
 274 sa6_recoverscope(struct sockaddr_in6 *sin6, boolean_t attachcheck)
 275 {
 276         u_int32_t zoneid;
 277
 278         if (sin6->sin6_scope_id != 0) {
 279                 log(LOG_NOTICE,
 280                     "sa6_recoverscope: assumption failure (non 0 ID): %s%%%d\n",
 281                     ip6_sprintf(&sin6->sin6_addr), sin6->sin6_scope_id);
 282                 /* XXX: proceed anyway... */
 283         }
 284         if (IN6_IS_SCOPE_LINKLOCAL(&sin6->sin6_addr) ||
 285             IN6_IS_ADDR_MC_INTFACELOCAL(&sin6->sin6_addr)) {
 286                 /*
 287                  * KAME assumption: link id == interface id
 288                  */
 289                 zoneid = ntohs(sin6->sin6_addr.s6_addr16[1]);
 290                 if (zoneid) {
 291                         /* sanity check */
 292                         if (if_index < zoneid) {
 293                                 return ENXIO;
 294                         }
 295                         /*
 296                          * We use the attachcheck parameter to skip the
 297                          * interface attachment check.
 298                          * Some callers might hold the ifnet_head lock in
 299                          * exclusive mode. This means that:
 300                          * 1) the interface can't go away -- hence we don't
 301                          *    need to perform this check
 302                          * 2) we can't perform this check because the lock is
 303                          *    in exclusive mode and trying to lock it in shared
 304                          *    mode would cause a deadlock.
 305                          */
 306                         if (attachcheck) {
 307                                 ifnet_head_lock_shared();
 308                                 if (ifindex2ifnet[zoneid] == NULL) {
 309                                         ifnet_head_done();
 310                                         return ENXIO;
 311                                 }
 312                                 ifnet_head_done();
 313                         }
 314                         sin6->sin6_addr.s6_addr16[1] = 0;
 315                         sin6->sin6_scope_id = zoneid;
 316                 }
 317         }
 318
 319         return 0;
 320 }
 321
 322 void
 323 scope6_setdefault(struct ifnet *ifp)
 324 {
 325         /*
 326          * Currently, this function just set the default "link" according to
 327          * the given interface.
 328          * We might eventually have to separate the notion of "link" from
 329          * "interface" and provide a user interface to set the default.
 330          */
 331         lck_mtx_lock(&scope6_lock);
 332         if (ifp != NULL) {
 333                 sid_default.s6id_list[IPV6_ADDR_SCOPE_INTFACELOCAL] =
 334                     ifp->if_index;
 335                 sid_default.s6id_list[IPV6_ADDR_SCOPE_LINKLOCAL] =
 336                     ifp->if_index;
 337         } else {
 338                 sid_default.s6id_list[IPV6_ADDR_SCOPE_INTFACELOCAL] = 0;
 339                 sid_default.s6id_list[IPV6_ADDR_SCOPE_LINKLOCAL] = 0;
 340         }
 341         lck_mtx_unlock(&scope6_lock);
 342 }
 343
 344
 345 u_int32_t
 346 scope6_addr2default(struct in6_addr *addr)
 347 {
 348         u_int32_t id = 0;
 349         int index = in6_addrscope(addr);
 350
 351         /*
 352          * special case: The loopback address should be considered as
 353          * link-local, but there's no ambiguity in the syntax.
 354          */
 355         if (IN6_IS_ADDR_LOOPBACK(addr)) {
 356                 return 0;
 357         }
 358
 359         lck_mtx_lock(&scope6_lock);
 360         id = sid_default.s6id_list[index];
 361         lck_mtx_unlock(&scope6_lock);
 362
 363         return id;
 364 }
 365
 366 /*
 367  * Determine the appropriate scope zone ID for in6 and ifp.  If ret_id is
 368  * non NULL, it is set to the zone ID.  If the zone ID needs to be embedded
 369  * in the in6_addr structure, in6 will be modified.
 370  *
 371  * ret_id - unnecessary?
 372  */
 373 int
 374 in6_setscope(struct in6_addr *in6, struct ifnet *ifp, u_int32_t *ret_id)
 375 {
 376         int scope;
 377         u_int32_t zoneid = 0;
 378         struct scope6_id *sid;
 379
 380         /*
 381          * special case: the loopback address can only belong to a loopback
 382          * interface.
 383          */
 384         if (IN6_IS_ADDR_LOOPBACK(in6)) {
 385                 if (!(ifp->if_flags & IFF_LOOPBACK)) {
 386                         return EINVAL;
 387                 } else {
 388                         if (ret_id != NULL) {
 389                                 *ret_id = 0; /* there's no ambiguity */
 390                         }
 391                         return 0;
 392                 }
 393         }
 394
 395         scope = in6_addrscope(in6);
 396
 397         if_inet6data_lock_shared(ifp);
 398         if (IN6_IFEXTRA(ifp) == NULL) {
 399                 if_inet6data_lock_done(ifp);
 400                 if (ret_id) {
 401                         *ret_id = 0;
 402                 }
 403                 return EINVAL;
 404         }
 405         sid = SID(ifp);
 406         switch (scope) {
 407         case IPV6_ADDR_SCOPE_INTFACELOCAL: /* should be interface index */
 408                 zoneid = sid->s6id_list[IPV6_ADDR_SCOPE_INTFACELOCAL];
 409                 break;
 410
 411         case IPV6_ADDR_SCOPE_LINKLOCAL:
 412                 zoneid = sid->s6id_list[IPV6_ADDR_SCOPE_LINKLOCAL];
 413                 break;
 414
 415         case IPV6_ADDR_SCOPE_SITELOCAL:
 416                 zoneid = sid->s6id_list[IPV6_ADDR_SCOPE_SITELOCAL];
 417                 break;
 418
 419         case IPV6_ADDR_SCOPE_ORGLOCAL:
 420                 zoneid = sid->s6id_list[IPV6_ADDR_SCOPE_ORGLOCAL];
 421                 break;
 422         default:
 423                 zoneid = 0;     /* XXX: treat as global. */
 424                 break;
 425         }
 426         if_inet6data_lock_done(ifp);
 427
 428         if (ret_id != NULL) {
 429                 *ret_id = zoneid;
 430         }
 431
 432         if (IN6_IS_SCOPE_LINKLOCAL(in6) || IN6_IS_ADDR_MC_INTFACELOCAL(in6)) {
 433                 in6->s6_addr16[1] = htons(zoneid & 0xffff); /* XXX */
 434         }
 435         return 0;
 436 }
 437
 438 /*
 439  * Just clear the embedded scope identifier.  Return 0 if the original address
 440  * is intact; return non 0 if the address is modified.
 441  */
 442 int
 443 in6_clearscope(struct in6_addr *in6)
 444 {
 445         int modified = 0;
 446
 447         if (IN6_IS_SCOPE_LINKLOCAL(in6) || IN6_IS_ADDR_MC_INTFACELOCAL(in6)) {
 448                 if (in6->s6_addr16[1] != 0) {
 449                         modified = 1;
 450                 }
 451                 in6->s6_addr16[1] = 0;
 452         }
 453
 454         return modified;
 455 }