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