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                 if (addr->s6_addr8[15] == 0) /* unspecified */
 164                         return (IPV6_ADDR_SCOPE_GLOBAL); /* XXX: correct? */
 165         }
 166
 167         return (IPV6_ADDR_SCOPE_GLOBAL);
 168 }
 169
 170 int
 171 in6_addr2scopeid(struct ifnet *ifp, struct in6_addr *addr)
 172 {
 173         int scope = in6_addrscope(addr);
 174         int retid = 0;
 175         struct scope6_id *sid;
 176
 177         if_inet6data_lock_shared(ifp);
 178         if (IN6_IFEXTRA(ifp) == NULL)
 179                 goto err;
 180         sid = SID(ifp);
 181         switch (scope) {
 182         case IPV6_ADDR_SCOPE_NODELOCAL:
 183                 retid = -1;     /* XXX: is this an appropriate value? */
 184                 break;
 185         case IPV6_ADDR_SCOPE_LINKLOCAL:
 186                 retid = sid->s6id_list[IPV6_ADDR_SCOPE_LINKLOCAL];
 187                 break;
 188         case IPV6_ADDR_SCOPE_SITELOCAL:
 189                 retid = sid->s6id_list[IPV6_ADDR_SCOPE_SITELOCAL];
 190                 break;
 191         case IPV6_ADDR_SCOPE_ORGLOCAL:
 192                 retid = sid->s6id_list[IPV6_ADDR_SCOPE_ORGLOCAL];
 193                 break;
 194         default:
 195                 break;  /* XXX: value 0, treat as global. */
 196         }
 197 err:
 198         if_inet6data_lock_done(ifp);
 199
 200         return (retid);
 201 }
 202
 203 /*
 204  * Validate the specified scope zone ID in the sin6_scope_id field.  If the ID
 205  * is unspecified (=0), needs to be specified, and the default zone ID can be
 206  * used, the default value will be used.
 207  * This routine then generates the kernel-internal form: if the address scope
 208  * of is interface-local or link-local, embed the interface index in the
 209  * address.
 210  */
 211 int
 212 sa6_embedscope(struct sockaddr_in6 *sin6, int defaultok)
 213 {
 214         struct ifnet *ifp;
 215         u_int32_t zoneid;
 216
 217         if ((zoneid = sin6->sin6_scope_id) == 0 && defaultok)
 218                 zoneid = scope6_addr2default(&sin6->sin6_addr);
 219
 220         if (zoneid != 0 &&
 221             (IN6_IS_SCOPE_LINKLOCAL(&sin6->sin6_addr) ||
 222             IN6_IS_ADDR_MC_INTFACELOCAL(&sin6->sin6_addr))) {
 223                 /*
 224                  * At this moment, we only check interface-local and
 225                  * link-local scope IDs, and use interface indices as the
 226                  * zone IDs assuming a one-to-one mapping between interfaces
 227                  * and links.
 228                  */
 229                 if (if_index < zoneid)
 230                         return (ENXIO);
 231                 ifnet_head_lock_shared();
 232                 ifp = ifindex2ifnet[zoneid];
 233                 if (ifp == NULL) {      /* XXX: this can happen for some OS */
 234                         ifnet_head_done();
 235                         return (ENXIO);
 236                 }
 237                 ifnet_head_done();
 238                 /* XXX assignment to 16bit from 32bit variable */
 239                 sin6->sin6_addr.s6_addr16[1] = htons(zoneid & 0xffff);
 240
 241                 sin6->sin6_scope_id = 0;
 242         }
 243
 244         return (0);
 245 }
 246
 247 void
 248 rtkey_to_sa6(struct rtentry *rt, struct sockaddr_in6 *sin6)
 249 {
 250         VERIFY(rt_key(rt)->sa_family == AF_INET6);
 251
 252         *sin6 = *((struct sockaddr_in6 *)(void *)rt_key(rt));
 253         sin6->sin6_scope_id = 0;
 254 }
 255
 256 void
 257 rtgw_to_sa6(struct rtentry *rt, struct sockaddr_in6 *sin6)
 258 {
 259         VERIFY(rt->rt_flags & RTF_GATEWAY);
 260
 261         *sin6 = *((struct sockaddr_in6 *)(void *)rt->rt_gateway);
 262         sin6->sin6_scope_id = 0;
 263 }
 264
 265 /*
 266  * generate standard sockaddr_in6 from embedded form.
 267  */
 268 int
 269 sa6_recoverscope(struct sockaddr_in6 *sin6, boolean_t attachcheck)
 270 {
 271         u_int32_t zoneid;
 272
 273         if (sin6->sin6_scope_id != 0) {
 274                 log(LOG_NOTICE,
 275                     "sa6_recoverscope: assumption failure (non 0 ID): %s%%%d\n",
 276                     ip6_sprintf(&sin6->sin6_addr), sin6->sin6_scope_id);
 277                 /* XXX: proceed anyway... */
 278         }
 279         if (IN6_IS_SCOPE_LINKLOCAL(&sin6->sin6_addr) ||
 280             IN6_IS_ADDR_MC_INTFACELOCAL(&sin6->sin6_addr)) {
 281                 /*
 282                  * KAME assumption: link id == interface id
 283                  */
 284                 zoneid = ntohs(sin6->sin6_addr.s6_addr16[1]);
 285                 if (zoneid) {
 286                         /* sanity check */
 287                         if (if_index < zoneid)
 288                                 return (ENXIO);
 289                         /*
 290                          * We use the attachcheck parameter to skip the
 291                          * interface attachment check.
 292                          * Some callers might hold the ifnet_head lock in
 293                          * exclusive mode. This means that:
 294                          * 1) the interface can't go away -- hence we don't
 295                          *    need to perform this check
 296                          * 2) we can't perform this check because the lock is
 297                          *    in exclusive mode and trying to lock it in shared
 298                          *    mode would cause a deadlock.
 299                          */
 300                         if (attachcheck) {
 301                                 ifnet_head_lock_shared();
 302                                 if (ifindex2ifnet[zoneid] == NULL) {
 303                                         ifnet_head_done();
 304                                         return (ENXIO);
 305                                 }
 306                                 ifnet_head_done();
 307                         }
 308                         sin6->sin6_addr.s6_addr16[1] = 0;
 309                         sin6->sin6_scope_id = zoneid;
 310                 }
 311         }
 312
 313         return (0);
 314 }
 315
 316 void
 317 scope6_setdefault(struct ifnet *ifp)
 318 {
 319         /*
 320          * Currently, this function just set the default "link" according to
 321          * the given interface.
 322          * We might eventually have to separate the notion of "link" from
 323          * "interface" and provide a user interface to set the default.
 324          */
 325         lck_mtx_lock(&scope6_lock);
 326         if (ifp != NULL) {
 327                 sid_default.s6id_list[IPV6_ADDR_SCOPE_INTFACELOCAL] =
 328                     ifp->if_index;
 329                 sid_default.s6id_list[IPV6_ADDR_SCOPE_LINKLOCAL] =
 330                     ifp->if_index;
 331         } else {
 332                 sid_default.s6id_list[IPV6_ADDR_SCOPE_INTFACELOCAL] = 0;
 333                 sid_default.s6id_list[IPV6_ADDR_SCOPE_LINKLOCAL] = 0;
 334         }
 335         lck_mtx_unlock(&scope6_lock);
 336 }
 337
 338
 339 u_int32_t
 340 scope6_addr2default(struct in6_addr *addr)
 341 {
 342         u_int32_t id = 0;
 343         int index = in6_addrscope(addr);
 344
 345         /*
 346          * special case: The loopback address should be considered as
 347          * link-local, but there's no ambiguity in the syntax.
 348          */
 349         if (IN6_IS_ADDR_LOOPBACK(addr))
 350                 return (0);
 351
 352         lck_mtx_lock(&scope6_lock);
 353         id = sid_default.s6id_list[index];
 354         lck_mtx_unlock(&scope6_lock);
 355
 356         return (id);
 357 }
 358
 359 /*
 360  * Determine the appropriate scope zone ID for in6 and ifp.  If ret_id is
 361  * non NULL, it is set to the zone ID.  If the zone ID needs to be embedded
 362  * in the in6_addr structure, in6 will be modified.
 363  *
 364  * ret_id - unnecessary?
 365  */
 366 int
 367 in6_setscope(struct in6_addr *in6, struct ifnet *ifp, u_int32_t *ret_id)
 368 {
 369         int scope;
 370         u_int32_t zoneid = 0;
 371         struct scope6_id *sid;
 372
 373         /*
 374          * special case: the loopback address can only belong to a loopback
 375          * interface.
 376          */
 377         if (IN6_IS_ADDR_LOOPBACK(in6)) {
 378                 if (!(ifp->if_flags & IFF_LOOPBACK)) {
 379                         return (EINVAL);
 380                 } else {
 381                         if (ret_id != NULL)
 382                                 *ret_id = 0; /* there's no ambiguity */
 383                         return (0);
 384                 }
 385         }
 386
 387         scope = in6_addrscope(in6);
 388
 389         if_inet6data_lock_shared(ifp);
 390         if (IN6_IFEXTRA(ifp) == NULL) {
 391                 if_inet6data_lock_done(ifp);
 392                 if (ret_id)
 393                         *ret_id = 0;
 394                 return (EINVAL);
 395         }
 396         sid = SID(ifp);
 397         switch (scope) {
 398         case IPV6_ADDR_SCOPE_INTFACELOCAL: /* should be interface index */
 399                 zoneid = sid->s6id_list[IPV6_ADDR_SCOPE_INTFACELOCAL];
 400                 break;
 401
 402         case IPV6_ADDR_SCOPE_LINKLOCAL:
 403                 zoneid = sid->s6id_list[IPV6_ADDR_SCOPE_LINKLOCAL];
 404                 break;
 405
 406         case IPV6_ADDR_SCOPE_SITELOCAL:
 407                 zoneid = sid->s6id_list[IPV6_ADDR_SCOPE_SITELOCAL];
 408                 break;
 409
 410         case IPV6_ADDR_SCOPE_ORGLOCAL:
 411                 zoneid = sid->s6id_list[IPV6_ADDR_SCOPE_ORGLOCAL];
 412                 break;
 413         default:
 414                 zoneid = 0;     /* XXX: treat as global. */
 415                 break;
 416         }
 417         if_inet6data_lock_done(ifp);
 418
 419         if (ret_id != NULL)
 420                 *ret_id = zoneid;
 421
 422         if (IN6_IS_SCOPE_LINKLOCAL(in6) || IN6_IS_ADDR_MC_INTFACELOCAL(in6))
 423                 in6->s6_addr16[1] = htons(zoneid & 0xffff); /* XXX */
 424
 425         return (0);
 426 }
 427
 428 /*
 429  * Just clear the embedded scope identifier.  Return 0 if the original address
 430  * is intact; return non 0 if the address is modified.
 431  */
 432 int
 433 in6_clearscope(struct in6_addr *in6)
 434 {
 435         int modified = 0;
 436
 437         if (IN6_IS_SCOPE_LINKLOCAL(in6) || IN6_IS_ADDR_MC_INTFACELOCAL(in6)) {
 438                 if (in6->s6_addr16[1] != 0)
 439                         modified = 1;
 440                 in6->s6_addr16[1] = 0;
 441         }
 442
 443         return (modified);
 444 }