The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/netinet6/scope6.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (C) 2000 WIDE Project.
    3  * All rights reserved.
    4  *
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions
    7  * are met:
    8  * 1. Redistributions of source code must retain the above copyright
    9  *    notice, this list of conditions and the following disclaimer.
   10  * 2. Redistributions in binary form must reproduce the above copyright
   11  *    notice, this list of conditions and the following disclaimer in the
   12  *    documentation and/or other materials provided with the distribution.
   13  * 3. Neither the name of the project nor the names of its contributors
   14  *    may be used to endorse or promote products derived from this software
   15  *    without specific prior written permission.
   16  *
   17  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
   18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
   21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   27  * SUCH DAMAGE.
   28  *
   29  *      $KAME: scope6.c,v 1.10 2000/07/24 13:29:31 itojun Exp $
   30  */
   31 
   32 #include <sys/cdefs.h>
   33 __FBSDID("$FreeBSD: releng/9.0/sys/netinet6/scope6.c 215701 2010-11-22 19:32:54Z dim $");
   34 
   35 #include <sys/param.h>
   36 #include <sys/malloc.h>
   37 #include <sys/mbuf.h>
   38 #include <sys/socket.h>
   39 #include <sys/systm.h>
   40 #include <sys/queue.h>
   41 #include <sys/syslog.h>
   42 
   43 #include <net/if.h>
   44 #include <net/vnet.h>
   45 
   46 #include <netinet/in.h>
   47 
   48 #include <netinet/ip6.h>
   49 #include <netinet6/in6_var.h>
   50 #include <netinet6/ip6_var.h>
   51 #include <netinet6/scope6_var.h>
   52 
   53 #ifdef ENABLE_DEFAULT_SCOPE
   54 VNET_DEFINE(int, ip6_use_defzone) = 1;
   55 #else
   56 VNET_DEFINE(int, ip6_use_defzone) = 0;
   57 #endif
   58 
   59 /*
   60  * The scope6_lock protects the global sid default stored in
   61  * sid_default below.
   62  */
   63 static struct mtx scope6_lock;
   64 #define SCOPE6_LOCK_INIT()      mtx_init(&scope6_lock, "scope6_lock", NULL, MTX_DEF)
   65 #define SCOPE6_LOCK()           mtx_lock(&scope6_lock)
   66 #define SCOPE6_UNLOCK()         mtx_unlock(&scope6_lock)
   67 #define SCOPE6_LOCK_ASSERT()    mtx_assert(&scope6_lock, MA_OWNED)
   68 
   69 static VNET_DEFINE(struct scope6_id, sid_default);
   70 #define V_sid_default                   VNET(sid_default)
   71 
   72 #define SID(ifp) \
   73         (((struct in6_ifextra *)(ifp)->if_afdata[AF_INET6])->scope6_id)
   74 
   75 void
   76 scope6_init(void)
   77 {
   78 
   79         bzero(&V_sid_default, sizeof(V_sid_default));
   80 
   81         if (!IS_DEFAULT_VNET(curvnet))
   82                 return;
   83 
   84         SCOPE6_LOCK_INIT();
   85 }
   86 
   87 struct scope6_id *
   88 scope6_ifattach(struct ifnet *ifp)
   89 {
   90         struct scope6_id *sid;
   91 
   92         sid = (struct scope6_id *)malloc(sizeof(*sid), M_IFADDR, M_WAITOK);
   93         bzero(sid, sizeof(*sid));
   94 
   95         /*
   96          * XXX: IPV6_ADDR_SCOPE_xxx macros are not standard.
   97          * Should we rather hardcode here?
   98          */
   99         sid->s6id_list[IPV6_ADDR_SCOPE_INTFACELOCAL] = ifp->if_index;
  100         sid->s6id_list[IPV6_ADDR_SCOPE_LINKLOCAL] = ifp->if_index;
  101 #ifdef MULTI_SCOPE
  102         /* by default, we don't care about scope boundary for these scopes. */
  103         sid->s6id_list[IPV6_ADDR_SCOPE_SITELOCAL] = 1;
  104         sid->s6id_list[IPV6_ADDR_SCOPE_ORGLOCAL] = 1;
  105 #endif
  106 
  107         return sid;
  108 }
  109 
  110 void
  111 scope6_ifdetach(struct scope6_id *sid)
  112 {
  113 
  114         free(sid, M_IFADDR);
  115 }
  116 
  117 int
  118 scope6_set(struct ifnet *ifp, struct scope6_id *idlist)
  119 {
  120         int i;
  121         int error = 0;
  122         struct scope6_id *sid = NULL;
  123 
  124         IF_AFDATA_LOCK(ifp);
  125         sid = SID(ifp);
  126 
  127         if (!sid) {     /* paranoid? */
  128                 IF_AFDATA_UNLOCK(ifp);
  129                 return (EINVAL);
  130         }
  131 
  132         /*
  133          * XXX: We need more consistency checks of the relationship among
  134          * scopes (e.g. an organization should be larger than a site).
  135          */
  136 
  137         /*
  138          * TODO(XXX): after setting, we should reflect the changes to
  139          * interface addresses, routing table entries, PCB entries...
  140          */
  141 
  142         SCOPE6_LOCK();
  143         for (i = 0; i < 16; i++) {
  144                 if (idlist->s6id_list[i] &&
  145                     idlist->s6id_list[i] != sid->s6id_list[i]) {
  146                         /*
  147                          * An interface zone ID must be the corresponding
  148                          * interface index by definition.
  149                          */
  150                         if (i == IPV6_ADDR_SCOPE_INTFACELOCAL &&
  151                             idlist->s6id_list[i] != ifp->if_index) {
  152                                 IF_AFDATA_UNLOCK(ifp);
  153                                 SCOPE6_UNLOCK();
  154                                 return (EINVAL);
  155                         }
  156 
  157                         if (i == IPV6_ADDR_SCOPE_LINKLOCAL &&
  158                             idlist->s6id_list[i] > V_if_index) {
  159                                 /*
  160                                  * XXX: theoretically, there should be no
  161                                  * relationship between link IDs and interface
  162                                  * IDs, but we check the consistency for
  163                                  * safety in later use.
  164                                  */
  165                                 IF_AFDATA_UNLOCK(ifp);
  166                                 SCOPE6_UNLOCK();
  167                                 return (EINVAL);
  168                         }
  169 
  170                         /*
  171                          * XXX: we must need lots of work in this case,
  172                          * but we simply set the new value in this initial
  173                          * implementation.
  174                          */
  175                         sid->s6id_list[i] = idlist->s6id_list[i];
  176                 }
  177         }
  178         SCOPE6_UNLOCK();
  179         IF_AFDATA_UNLOCK(ifp);
  180 
  181         return (error);
  182 }
  183 
  184 int
  185 scope6_get(struct ifnet *ifp, struct scope6_id *idlist)
  186 {
  187         /* We only need to lock the interface's afdata for SID() to work. */
  188         IF_AFDATA_LOCK(ifp);
  189         struct scope6_id *sid = SID(ifp);
  190 
  191         if (sid == NULL) {      /* paranoid? */
  192                 IF_AFDATA_UNLOCK(ifp);
  193                 return (EINVAL);
  194         }
  195 
  196         SCOPE6_LOCK();
  197         *idlist = *sid;
  198         SCOPE6_UNLOCK();
  199 
  200         IF_AFDATA_UNLOCK(ifp);
  201         return (0);
  202 }
  203 
  204 
  205 /*
  206  * Get a scope of the address. Node-local, link-local, site-local or global.
  207  */
  208 int
  209 in6_addrscope(struct in6_addr *addr)
  210 {
  211         int scope;
  212 
  213         if (addr->s6_addr[0] == 0xfe) {
  214                 scope = addr->s6_addr[1] & 0xc0;
  215 
  216                 switch (scope) {
  217                 case 0x80:
  218                         return IPV6_ADDR_SCOPE_LINKLOCAL;
  219                         break;
  220                 case 0xc0:
  221                         return IPV6_ADDR_SCOPE_SITELOCAL;
  222                         break;
  223                 default:
  224                         return IPV6_ADDR_SCOPE_GLOBAL; /* just in case */
  225                         break;
  226                 }
  227         }
  228 
  229 
  230         if (addr->s6_addr[0] == 0xff) {
  231                 scope = addr->s6_addr[1] & 0x0f;
  232 
  233                 /*
  234                  * due to other scope such as reserved,
  235                  * return scope doesn't work.
  236                  */
  237                 switch (scope) {
  238                 case IPV6_ADDR_SCOPE_INTFACELOCAL:
  239                         return IPV6_ADDR_SCOPE_INTFACELOCAL;
  240                         break;
  241                 case IPV6_ADDR_SCOPE_LINKLOCAL:
  242                         return IPV6_ADDR_SCOPE_LINKLOCAL;
  243                         break;
  244                 case IPV6_ADDR_SCOPE_SITELOCAL:
  245                         return IPV6_ADDR_SCOPE_SITELOCAL;
  246                         break;
  247                 default:
  248                         return IPV6_ADDR_SCOPE_GLOBAL;
  249                         break;
  250                 }
  251         }
  252 
  253         /*
  254          * Regard loopback and unspecified addresses as global, since
  255          * they have no ambiguity.
  256          */
  257         if (bcmp(&in6addr_loopback, addr, sizeof(*addr) - 1) == 0) {
  258                 if (addr->s6_addr[15] == 1) /* loopback */
  259                         return IPV6_ADDR_SCOPE_LINKLOCAL;
  260                 if (addr->s6_addr[15] == 0) /* unspecified */
  261                         return IPV6_ADDR_SCOPE_GLOBAL; /* XXX: correct? */
  262         }
  263 
  264         return IPV6_ADDR_SCOPE_GLOBAL;
  265 }
  266 
  267 /*
  268  * ifp - note that this might be NULL
  269  */
  270 
  271 void
  272 scope6_setdefault(struct ifnet *ifp)
  273 {
  274 
  275         /*
  276          * Currently, this function just sets the default "interfaces"
  277          * and "links" according to the given interface.
  278          * We might eventually have to separate the notion of "link" from
  279          * "interface" and provide a user interface to set the default.
  280          */
  281         SCOPE6_LOCK();
  282         if (ifp) {
  283                 V_sid_default.s6id_list[IPV6_ADDR_SCOPE_INTFACELOCAL] =
  284                         ifp->if_index;
  285                 V_sid_default.s6id_list[IPV6_ADDR_SCOPE_LINKLOCAL] =
  286                         ifp->if_index;
  287         } else {
  288                 V_sid_default.s6id_list[IPV6_ADDR_SCOPE_INTFACELOCAL] = 0;
  289                 V_sid_default.s6id_list[IPV6_ADDR_SCOPE_LINKLOCAL] = 0;
  290         }
  291         SCOPE6_UNLOCK();
  292 }
  293 
  294 int
  295 scope6_get_default(struct scope6_id *idlist)
  296 {
  297 
  298         SCOPE6_LOCK();
  299         *idlist = V_sid_default;
  300         SCOPE6_UNLOCK();
  301 
  302         return (0);
  303 }
  304 
  305 u_int32_t
  306 scope6_addr2default(struct in6_addr *addr)
  307 {
  308         u_int32_t id;
  309 
  310         /*
  311          * special case: The loopback address should be considered as
  312          * link-local, but there's no ambiguity in the syntax.
  313          */
  314         if (IN6_IS_ADDR_LOOPBACK(addr))
  315                 return (0);
  316 
  317         /*
  318          * XXX: 32-bit read is atomic on all our platforms, is it OK
  319          * not to lock here?
  320          */
  321         SCOPE6_LOCK();
  322         id = V_sid_default.s6id_list[in6_addrscope(addr)];
  323         SCOPE6_UNLOCK();
  324         return (id);
  325 }
  326 
  327 /*
  328  * Validate the specified scope zone ID in the sin6_scope_id field.  If the ID
  329  * is unspecified (=0), needs to be specified, and the default zone ID can be
  330  * used, the default value will be used.
  331  * This routine then generates the kernel-internal form: if the address scope
  332  * of is interface-local or link-local, embed the interface index in the
  333  * address.
  334  */
  335 int
  336 sa6_embedscope(struct sockaddr_in6 *sin6, int defaultok)
  337 {
  338         struct ifnet *ifp;
  339         u_int32_t zoneid;
  340 
  341         if ((zoneid = sin6->sin6_scope_id) == 0 && defaultok)
  342                 zoneid = scope6_addr2default(&sin6->sin6_addr);
  343 
  344         if (zoneid != 0 &&
  345             (IN6_IS_SCOPE_LINKLOCAL(&sin6->sin6_addr) ||
  346             IN6_IS_ADDR_MC_INTFACELOCAL(&sin6->sin6_addr))) {
  347                 /*
  348                  * At this moment, we only check interface-local and
  349                  * link-local scope IDs, and use interface indices as the
  350                  * zone IDs assuming a one-to-one mapping between interfaces
  351                  * and links.
  352                  */
  353                 if (V_if_index < zoneid)
  354                         return (ENXIO);
  355                 ifp = ifnet_byindex(zoneid);
  356                 if (ifp == NULL) /* XXX: this can happen for some OS */
  357                         return (ENXIO);
  358 
  359                 /* XXX assignment to 16bit from 32bit variable */
  360                 sin6->sin6_addr.s6_addr16[1] = htons(zoneid & 0xffff);
  361 
  362                 sin6->sin6_scope_id = 0;
  363         }
  364 
  365         return 0;
  366 }
  367 
  368 /*
  369  * generate standard sockaddr_in6 from embedded form.
  370  */
  371 int
  372 sa6_recoverscope(struct sockaddr_in6 *sin6)
  373 {
  374         char ip6buf[INET6_ADDRSTRLEN];
  375         u_int32_t zoneid;
  376 
  377         if (sin6->sin6_scope_id != 0) {
  378                 log(LOG_NOTICE,
  379                     "sa6_recoverscope: assumption failure (non 0 ID): %s%%%d\n",
  380                     ip6_sprintf(ip6buf, &sin6->sin6_addr), sin6->sin6_scope_id);
  381                 /* XXX: proceed anyway... */
  382         }
  383         if (IN6_IS_SCOPE_LINKLOCAL(&sin6->sin6_addr) ||
  384             IN6_IS_ADDR_MC_INTFACELOCAL(&sin6->sin6_addr)) {
  385                 /*
  386                  * KAME assumption: link id == interface id
  387                  */
  388                 zoneid = ntohs(sin6->sin6_addr.s6_addr16[1]);
  389                 if (zoneid) {
  390                         /* sanity check */
  391                         if (zoneid < 0 || V_if_index < zoneid)
  392                                 return (ENXIO);
  393                         if (!ifnet_byindex(zoneid))
  394                                 return (ENXIO);
  395                         sin6->sin6_addr.s6_addr16[1] = 0;
  396                         sin6->sin6_scope_id = zoneid;
  397                 }
  398         }
  399 
  400         return 0;
  401 }
  402 
  403 /*
  404  * Determine the appropriate scope zone ID for in6 and ifp.  If ret_id is
  405  * non NULL, it is set to the zone ID.  If the zone ID needs to be embedded
  406  * in the in6_addr structure, in6 will be modified.
  407  *
  408  * ret_id - unnecessary?
  409  */
  410 int
  411 in6_setscope(struct in6_addr *in6, struct ifnet *ifp, u_int32_t *ret_id)
  412 {
  413         int scope;
  414         u_int32_t zoneid = 0;
  415         struct scope6_id *sid;
  416 
  417         IF_AFDATA_LOCK(ifp);
  418 
  419         sid = SID(ifp);
  420 
  421 #ifdef DIAGNOSTIC
  422         if (sid == NULL) { /* should not happen */
  423                 panic("in6_setscope: scope array is NULL");
  424                 /* NOTREACHED */
  425         }
  426 #endif
  427 
  428         /*
  429          * special case: the loopback address can only belong to a loopback
  430          * interface.
  431          */
  432         if (IN6_IS_ADDR_LOOPBACK(in6)) {
  433                 if (!(ifp->if_flags & IFF_LOOPBACK)) {
  434                         IF_AFDATA_UNLOCK(ifp);
  435                         return (EINVAL);
  436                 } else {
  437                         if (ret_id != NULL)
  438                                 *ret_id = 0; /* there's no ambiguity */
  439                         IF_AFDATA_UNLOCK(ifp);
  440                         return (0);
  441                 }
  442         }
  443 
  444         scope = in6_addrscope(in6);
  445 
  446         SCOPE6_LOCK();
  447         switch (scope) {
  448         case IPV6_ADDR_SCOPE_INTFACELOCAL: /* should be interface index */
  449                 zoneid = sid->s6id_list[IPV6_ADDR_SCOPE_INTFACELOCAL];
  450                 break;
  451 
  452         case IPV6_ADDR_SCOPE_LINKLOCAL:
  453                 zoneid = sid->s6id_list[IPV6_ADDR_SCOPE_LINKLOCAL];
  454                 break;
  455 
  456         case IPV6_ADDR_SCOPE_SITELOCAL:
  457                 zoneid = sid->s6id_list[IPV6_ADDR_SCOPE_SITELOCAL];
  458                 break;
  459 
  460         case IPV6_ADDR_SCOPE_ORGLOCAL:
  461                 zoneid = sid->s6id_list[IPV6_ADDR_SCOPE_ORGLOCAL];
  462                 break;
  463 
  464         default:
  465                 zoneid = 0;     /* XXX: treat as global. */
  466                 break;
  467         }
  468         SCOPE6_UNLOCK();
  469         IF_AFDATA_UNLOCK(ifp);
  470 
  471         if (ret_id != NULL)
  472                 *ret_id = zoneid;
  473 
  474         if (IN6_IS_SCOPE_LINKLOCAL(in6) || IN6_IS_ADDR_MC_INTFACELOCAL(in6))
  475                 in6->s6_addr16[1] = htons(zoneid & 0xffff); /* XXX */
  476 
  477         return (0);
  478 }
  479 
  480 /*
  481  * Just clear the embedded scope identifier.  Return 0 if the original address
  482  * is intact; return non 0 if the address is modified.
  483  */
  484 int
  485 in6_clearscope(struct in6_addr *in6)
  486 {
  487         int modified = 0;
  488 
  489         if (IN6_IS_SCOPE_LINKLOCAL(in6) || IN6_IS_ADDR_MC_INTFACELOCAL(in6)) {
  490                 if (in6->s6_addr16[1] != 0)
  491                         modified = 1;
  492                 in6->s6_addr16[1] = 0;
  493         }
  494 
  495         return (modified);
  496 }

Cache object: c3565a3df6d1045c7a9b291faa0a7c35


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.