1 /* $NetBSD: in6_src.c,v 1.59 2015/12/12 23:34:25 christos Exp $ */ 2 /* $KAME: in6_src.c,v 1.159 2005/10/19 01:40:32 t-momose Exp $ */ 3 4 /* 5 * Copyright (C) 1995, 1996, 1997, and 1998 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 /* 34 * Copyright (c) 1982, 1986, 1991, 1993 35 * The Regents of the University of California. All rights reserved. 36 * 37 * Redistribution and use in source and binary forms, with or without 38 * modification, are permitted provided that the following conditions 39 * are met: 40 * 1. Redistributions of source code must retain the above copyright 41 * notice, this list of conditions and the following disclaimer. 42 * 2. Redistributions in binary form must reproduce the above copyright 43 * notice, this list of conditions and the following disclaimer in the 44 * documentation and/or other materials provided with the distribution. 45 * 3. All advertising materials mentioning features or use of this software 46 * must display the following acknowledgement: 47 * This product includes software developed by the University of 48 * California, Berkeley and its contributors. 49 * 4. Neither the name of the University nor the names of its contributors 50 * may be used to endorse or promote products derived from this software 51 * without specific prior written permission. 52 * 53 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 54 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 55 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 56 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 57 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 58 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 59 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 60 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 61 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 62 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 63 * SUCH DAMAGE. 64 * 65 * @(#)in_pcb.c 8.2 (Berkeley) 1/4/94 66 */ 67 68 #include <sys/cdefs.h> 69 __KERNEL_RCSID(0, "$NetBSD: in6_src.c,v 1.59 2015/12/12 23:34:25 christos Exp $"); 70 71 #ifdef _KERNEL_OPT 72 #include "opt_inet.h" 73 #endif 74 75 #include <sys/param.h> 76 #include <sys/systm.h> 77 #include <sys/malloc.h> 78 #include <sys/mbuf.h> 79 #include <sys/protosw.h> 80 #include <sys/socket.h> 81 #include <sys/socketvar.h> 82 #include <sys/ioctl.h> 83 #include <sys/errno.h> 84 #include <sys/time.h> 85 #include <sys/kernel.h> 86 #include <sys/proc.h> 87 #include <sys/kauth.h> 88 89 #include <net/if.h> 90 #include <net/if_types.h> 91 #include <net/route.h> 92 93 #include <netinet/in.h> 94 #include <netinet/in_var.h> 95 #include <netinet/in_systm.h> 96 #include <netinet/ip.h> 97 #include <netinet/in_pcb.h> 98 #include <netinet/portalgo.h> 99 #include <netinet6/in6_var.h> 100 #include <netinet/ip6.h> 101 #include <netinet6/in6_pcb.h> 102 #include <netinet6/ip6_var.h> 103 #include <netinet6/ip6_private.h> 104 #include <netinet6/nd6.h> 105 #include <netinet6/scope6_var.h> 106 107 #include <net/net_osdep.h> 108 109 #ifdef MIP6 110 #include <netinet6/mip6.h> 111 #include <netinet6/mip6_var.h> 112 #include "mip.h" 113 #if NMIP > 0 114 #include <net/if_mip.h> 115 #endif /* NMIP > 0 */ 116 #endif /* MIP6 */ 117 118 #include <netinet/tcp_vtw.h> 119 120 #define ADDR_LABEL_NOTAPP (-1) 121 struct in6_addrpolicy defaultaddrpolicy; 122 123 int ip6_prefer_tempaddr = 0; 124 125 static int selectroute(struct sockaddr_in6 *, struct ip6_pktopts *, 126 struct ip6_moptions *, struct route *, struct ifnet **, 127 struct rtentry **, int, int); 128 static int in6_selectif(struct sockaddr_in6 *, struct ip6_pktopts *, 129 struct ip6_moptions *, struct route *, struct ifnet **); 130 131 static struct in6_addrpolicy *lookup_addrsel_policy(struct sockaddr_in6 *); 132 133 static void init_policy_queue(void); 134 static int add_addrsel_policyent(struct in6_addrpolicy *); 135 static int delete_addrsel_policyent(struct in6_addrpolicy *); 136 static int walk_addrsel_policy(int (*)(struct in6_addrpolicy *, void *), 137 void *); 138 static int dump_addrsel_policyent(struct in6_addrpolicy *, void *); 139 static struct in6_addrpolicy *match_addrsel_policy(struct sockaddr_in6 *); 140 141 /* 142 * Return an IPv6 address, which is the most appropriate for a given 143 * destination and user specified options. 144 * If necessary, this function lookups the routing table and returns 145 * an entry to the caller for later use. 146 */ 147 #if 0 /* diabled ad-hoc */ 148 #define REPLACE(r) do {\ 149 if ((r) < sizeof(ip6stat.ip6s_sources_rule) / \ 150 sizeof(ip6stat.ip6s_sources_rule[0])) /* check for safety */ \ 151 ip6stat.ip6s_sources_rule[(r)]++; \ 152 /* printf("in6_selectsrc: replace %s with %s by %d\n", ia_best ? ip6_sprintf(&ia_best->ia_addr.sin6_addr) : "none", ip6_sprintf(&ia->ia_addr.sin6_addr), (r)); */ \ 153 goto replace; \ 154 } while(0) 155 #define NEXT(r) do {\ 156 if ((r) < sizeof(ip6stat.ip6s_sources_rule) / \ 157 sizeof(ip6stat.ip6s_sources_rule[0])) /* check for safety */ \ 158 ip6stat.ip6s_sources_rule[(r)]++; \ 159 /* printf("in6_selectsrc: keep %s against %s by %d\n", ia_best ? ip6_sprintf(&ia_best->ia_addr.sin6_addr) : "none", ip6_sprintf(&ia->ia_addr.sin6_addr), (r)); */ \ 160 goto next; /* XXX: we can't use 'continue' here */ \ 161 } while(0) 162 #define BREAK(r) do { \ 163 if ((r) < sizeof(ip6stat.ip6s_sources_rule) / \ 164 sizeof(ip6stat.ip6s_sources_rule[0])) /* check for safety */ \ 165 ip6stat.ip6s_sources_rule[(r)]++; \ 166 goto out; /* XXX: we can't use 'break' here */ \ 167 } while(0) 168 #else 169 #define REPLACE(r) goto replace 170 #define NEXT(r) goto next 171 #define BREAK(r) goto out 172 #endif 173 174 struct in6_addr * 175 in6_selectsrc(struct sockaddr_in6 *dstsock, struct ip6_pktopts *opts, 176 struct ip6_moptions *mopts, struct route *ro, struct in6_addr *laddr, 177 struct ifnet **ifpp, int *errorp) 178 { 179 struct in6_addr dst; 180 struct ifnet *ifp = NULL; 181 struct in6_ifaddr *ia = NULL, *ia_best = NULL; 182 struct in6_pktinfo *pi = NULL; 183 int dst_scope = -1, best_scope = -1, best_matchlen = -1; 184 struct in6_addrpolicy *dst_policy = NULL, *best_policy = NULL; 185 u_int32_t odstzone; 186 int error; 187 int prefer_tempaddr; 188 #if defined(MIP6) && NMIP > 0 189 u_int8_t ip6po_usecoa = 0; 190 #endif /* MIP6 && NMIP > 0 */ 191 192 dst = dstsock->sin6_addr; /* make a copy for local operation */ 193 *errorp = 0; 194 if (ifpp) 195 *ifpp = NULL; 196 197 /* 198 * Try to determine the outgoing interface for the given destination. 199 * We do this regardless of whether the socket is bound, since the 200 * caller may need this information as a side effect of the call 201 * to this function (e.g., for identifying the appropriate scope zone 202 * ID). 203 */ 204 error = in6_selectif(dstsock, opts, mopts, ro, &ifp); 205 if (ifpp) 206 *ifpp = ifp; 207 208 /* 209 * If the source address is explicitly specified by the caller, 210 * check if the requested source address is indeed a unicast address 211 * assigned to the node, and can be used as the packet's source 212 * address. If everything is okay, use the address as source. 213 */ 214 if (opts && (pi = opts->ip6po_pktinfo) && 215 !IN6_IS_ADDR_UNSPECIFIED(&pi->ipi6_addr)) { 216 struct sockaddr_in6 srcsock; 217 struct in6_ifaddr *ia6; 218 219 /* 220 * Determine the appropriate zone id of the source based on 221 * the zone of the destination and the outgoing interface. 222 * If the specified address is ambiguous wrt the scope zone, 223 * the interface must be specified; otherwise, ifa_ifwithaddr() 224 * will fail matching the address. 225 */ 226 memset(&srcsock, 0, sizeof(srcsock)); 227 srcsock.sin6_family = AF_INET6; 228 srcsock.sin6_len = sizeof(srcsock); 229 srcsock.sin6_addr = pi->ipi6_addr; 230 if (ifp) { 231 *errorp = in6_setscope(&srcsock.sin6_addr, ifp, NULL); 232 if (*errorp != 0) 233 return (NULL); 234 } 235 236 ia6 = (struct in6_ifaddr *)ifa_ifwithaddr((struct sockaddr *)(&srcsock)); 237 if (ia6 == NULL || 238 (ia6->ia6_flags & (IN6_IFF_ANYCAST | IN6_IFF_NOTREADY))) { 239 *errorp = EADDRNOTAVAIL; 240 return (NULL); 241 } 242 pi->ipi6_addr = srcsock.sin6_addr; /* XXX: this overrides pi */ 243 if (ifpp) 244 *ifpp = ifp; 245 return (&ia6->ia_addr.sin6_addr); 246 } 247 248 /* 249 * If the socket has already bound the source, just use it. We don't 250 * care at the moment whether in6_selectif() succeeded above, even 251 * though it would eventually cause an error. 252 */ 253 if (laddr && !IN6_IS_ADDR_UNSPECIFIED(laddr)) 254 return (laddr); 255 256 /* 257 * The outgoing interface is crucial in the general selection procedure 258 * below. If it is not known at this point, we fail. 259 */ 260 if (ifp == NULL) { 261 *errorp = error; 262 return (NULL); 263 } 264 265 /* 266 * If the address is not yet determined, choose the best one based on 267 * the outgoing interface and the destination address. 268 */ 269 270 #if defined(MIP6) && NMIP > 0 271 /* 272 * a caller can specify IP6PO_USECOA to not to use a home 273 * address. for example, the case that the neighbour 274 * unreachability detection to the global address. 275 */ 276 if (opts != NULL && 277 (opts->ip6po_flags & IP6PO_USECOA) != 0) { 278 ip6po_usecoa = 1; 279 } 280 #endif /* MIP6 && NMIP > 0 */ 281 282 #ifdef DIAGNOSTIC 283 if (ifp == NULL) /* this should not happen */ 284 panic("in6_selectsrc: NULL ifp"); 285 #endif 286 *errorp = in6_setscope(&dst, ifp, &odstzone); 287 if (*errorp != 0) 288 return (NULL); 289 290 for (ia = in6_ifaddr; ia; ia = ia->ia_next) { 291 int new_scope = -1, new_matchlen = -1; 292 struct in6_addrpolicy *new_policy = NULL; 293 u_int32_t srczone, osrczone, dstzone; 294 struct in6_addr src; 295 struct ifnet *ifp1 = ia->ia_ifp; 296 297 /* 298 * We'll never take an address that breaks the scope zone 299 * of the destination. We also skip an address if its zone 300 * does not contain the outgoing interface. 301 * XXX: we should probably use sin6_scope_id here. 302 */ 303 if (in6_setscope(&dst, ifp1, &dstzone) || 304 odstzone != dstzone) { 305 continue; 306 } 307 src = ia->ia_addr.sin6_addr; 308 if (in6_setscope(&src, ifp, &osrczone) || 309 in6_setscope(&src, ifp1, &srczone) || 310 osrczone != srczone) { 311 continue; 312 } 313 314 /* avoid unusable addresses */ 315 if ((ia->ia6_flags & 316 (IN6_IFF_NOTREADY | IN6_IFF_ANYCAST | IN6_IFF_DETACHED))) { 317 continue; 318 } 319 if (!ip6_use_deprecated && IFA6_IS_DEPRECATED(ia)) 320 continue; 321 322 #if defined(MIP6) && NMIP > 0 323 /* avoid unusable home addresses. */ 324 if ((ia->ia6_flags & IN6_IFF_HOME) && 325 !mip6_ifa6_is_addr_valid_hoa(ia)) 326 continue; 327 #endif /* MIP6 && NMIP > 0 */ 328 329 /* Rule 1: Prefer same address */ 330 if (IN6_ARE_ADDR_EQUAL(&dst, &ia->ia_addr.sin6_addr)) { 331 ia_best = ia; 332 BREAK(1); /* there should be no better candidate */ 333 } 334 335 if (ia_best == NULL) 336 REPLACE(0); 337 338 /* Rule 2: Prefer appropriate scope */ 339 if (dst_scope < 0) 340 dst_scope = in6_addrscope(&dst); 341 new_scope = in6_addrscope(&ia->ia_addr.sin6_addr); 342 if (IN6_ARE_SCOPE_CMP(best_scope, new_scope) < 0) { 343 if (IN6_ARE_SCOPE_CMP(best_scope, dst_scope) < 0) 344 REPLACE(2); 345 NEXT(2); 346 } else if (IN6_ARE_SCOPE_CMP(new_scope, best_scope) < 0) { 347 if (IN6_ARE_SCOPE_CMP(new_scope, dst_scope) < 0) 348 NEXT(2); 349 REPLACE(2); 350 } 351 352 /* 353 * Rule 3: Avoid deprecated addresses. Note that the case of 354 * !ip6_use_deprecated is already rejected above. 355 */ 356 if (!IFA6_IS_DEPRECATED(ia_best) && IFA6_IS_DEPRECATED(ia)) 357 NEXT(3); 358 if (IFA6_IS_DEPRECATED(ia_best) && !IFA6_IS_DEPRECATED(ia)) 359 REPLACE(3); 360 361 /* Rule 4: Prefer home addresses */ 362 #if defined(MIP6) && NMIP > 0 363 if (!MIP6_IS_MN) 364 goto skip_rule4; 365 366 if ((ia_best->ia6_flags & IN6_IFF_HOME) == 0 && 367 (ia->ia6_flags & IN6_IFF_HOME) == 0) { 368 /* both address are not home addresses. */ 369 goto skip_rule4; 370 } 371 372 /* 373 * If SA is simultaneously a home address and care-of 374 * address and SB is not, then prefer SA. Similarly, 375 * if SB is simultaneously a home address and care-of 376 * address and SA is not, then prefer SB. 377 */ 378 if (((ia_best->ia6_flags & IN6_IFF_HOME) != 0 && 379 ia_best->ia_ifp->if_type != IFT_MIP) 380 && 381 ((ia->ia6_flags & IN6_IFF_HOME) != 0 && 382 ia->ia_ifp->if_type == IFT_MIP)) 383 NEXT(4); 384 if (((ia_best->ia6_flags & IN6_IFF_HOME) != 0 && 385 ia_best->ia_ifp->if_type == IFT_MIP) 386 && 387 ((ia->ia6_flags & IN6_IFF_HOME) != 0 && 388 ia->ia_ifp->if_type != IFT_MIP)) 389 REPLACE(4); 390 if (ip6po_usecoa == 0) { 391 /* 392 * If SA is just a home address and SB is just 393 * a care-of address, then prefer 394 * SA. Similarly, if SB is just a home address 395 * and SA is just a care-of address, then 396 * prefer SB. 397 */ 398 if ((ia_best->ia6_flags & IN6_IFF_HOME) != 0 && 399 (ia->ia6_flags & IN6_IFF_HOME) == 0) { 400 NEXT(4); 401 } 402 if ((ia_best->ia6_flags & IN6_IFF_HOME) == 0 && 403 (ia->ia6_flags & IN6_IFF_HOME) != 0) { 404 REPLACE(4); 405 } 406 } else { 407 /* 408 * a sender don't want to use a home address 409 * because: 410 * 411 * 1) we cannot use. (ex. NS or NA to global 412 * addresses.) 413 * 414 * 2) a user specified not to use. 415 * (ex. mip6control -u) 416 */ 417 if ((ia_best->ia6_flags & IN6_IFF_HOME) == 0 && 418 (ia->ia6_flags & IN6_IFF_HOME) != 0) { 419 /* XXX breaks stat */ 420 NEXT(0); 421 } 422 if ((ia_best->ia6_flags & IN6_IFF_HOME) != 0 && 423 (ia->ia6_flags & IN6_IFF_HOME) == 0) { 424 /* XXX breaks stat */ 425 REPLACE(0); 426 } 427 } 428 skip_rule4: 429 #endif /* MIP6 && NMIP > 0 */ 430 431 /* Rule 5: Prefer outgoing interface */ 432 if (ia_best->ia_ifp == ifp && ia->ia_ifp != ifp) 433 NEXT(5); 434 if (ia_best->ia_ifp != ifp && ia->ia_ifp == ifp) 435 REPLACE(5); 436 437 /* 438 * Rule 6: Prefer matching label 439 * Note that best_policy should be non-NULL here. 440 */ 441 if (dst_policy == NULL) 442 dst_policy = lookup_addrsel_policy(dstsock); 443 if (dst_policy->label != ADDR_LABEL_NOTAPP) { 444 new_policy = lookup_addrsel_policy(&ia->ia_addr); 445 if (dst_policy->label == best_policy->label && 446 dst_policy->label != new_policy->label) 447 NEXT(6); 448 if (dst_policy->label != best_policy->label && 449 dst_policy->label == new_policy->label) 450 REPLACE(6); 451 } 452 453 /* 454 * Rule 7: Prefer public addresses. 455 * We allow users to reverse the logic by configuring 456 * a sysctl variable, so that privacy conscious users can 457 * always prefer temporary addresses. 458 */ 459 if (opts == NULL || 460 opts->ip6po_prefer_tempaddr == IP6PO_TEMPADDR_SYSTEM) { 461 prefer_tempaddr = ip6_prefer_tempaddr; 462 } else if (opts->ip6po_prefer_tempaddr == 463 IP6PO_TEMPADDR_NOTPREFER) { 464 prefer_tempaddr = 0; 465 } else 466 prefer_tempaddr = 1; 467 if (!(ia_best->ia6_flags & IN6_IFF_TEMPORARY) && 468 (ia->ia6_flags & IN6_IFF_TEMPORARY)) { 469 if (prefer_tempaddr) 470 REPLACE(7); 471 else 472 NEXT(7); 473 } 474 if ((ia_best->ia6_flags & IN6_IFF_TEMPORARY) && 475 !(ia->ia6_flags & IN6_IFF_TEMPORARY)) { 476 if (prefer_tempaddr) 477 NEXT(7); 478 else 479 REPLACE(7); 480 } 481 482 /* 483 * Rule 8: prefer addresses on alive interfaces. 484 * This is a KAME specific rule. 485 */ 486 if ((ia_best->ia_ifp->if_flags & IFF_UP) && 487 !(ia->ia_ifp->if_flags & IFF_UP)) 488 NEXT(8); 489 if (!(ia_best->ia_ifp->if_flags & IFF_UP) && 490 (ia->ia_ifp->if_flags & IFF_UP)) 491 REPLACE(8); 492 493 /* 494 * Rule 9: prefer addresses on "preferred" interfaces. 495 * This is a KAME specific rule. 496 */ 497 #ifdef notyet /* until introducing address selection */ 498 #define NDI_BEST ND_IFINFO(ia_best->ia_ifp) 499 #define NDI_NEW ND_IFINFO(ia->ia_ifp) 500 if ((NDI_BEST->flags & ND6_IFF_PREFER_SOURCE) && 501 !(NDI_NEW->flags & ND6_IFF_PREFER_SOURCE)) 502 NEXT(9); 503 if (!(NDI_BEST->flags & ND6_IFF_PREFER_SOURCE) && 504 (NDI_NEW->flags & ND6_IFF_PREFER_SOURCE)) 505 REPLACE(9); 506 #undef NDI_BEST 507 #undef NDI_NEW 508 #endif 509 510 /* 511 * Rule 14: Use longest matching prefix. 512 * Note: in the address selection draft, this rule is 513 * documented as "Rule 8". However, since it is also 514 * documented that this rule can be overridden, we assign 515 * a large number so that it is easy to assign smaller numbers 516 * to more preferred rules. 517 */ 518 new_matchlen = in6_matchlen(&ia->ia_addr.sin6_addr, &dst); 519 if (best_matchlen < new_matchlen) 520 REPLACE(14); 521 if (new_matchlen < best_matchlen) 522 NEXT(14); 523 524 /* Rule 15 is reserved. */ 525 526 /* 527 * Last resort: just keep the current candidate. 528 * Or, do we need more rules? 529 */ 530 continue; 531 532 replace: 533 ia_best = ia; 534 best_scope = (new_scope >= 0 ? new_scope : 535 in6_addrscope(&ia_best->ia_addr.sin6_addr)); 536 best_policy = (new_policy ? new_policy : 537 lookup_addrsel_policy(&ia_best->ia_addr)); 538 best_matchlen = (new_matchlen >= 0 ? new_matchlen : 539 in6_matchlen(&ia_best->ia_addr.sin6_addr, 540 &dst)); 541 542 next: 543 continue; 544 545 out: 546 break; 547 } 548 549 if ((ia = ia_best) == NULL) { 550 *errorp = EADDRNOTAVAIL; 551 return (NULL); 552 } 553 554 return (&ia->ia_addr.sin6_addr); 555 } 556 #undef REPLACE 557 #undef BREAK 558 #undef NEXT 559 560 static int 561 selectroute(struct sockaddr_in6 *dstsock, struct ip6_pktopts *opts, 562 struct ip6_moptions *mopts, struct route *ro, struct ifnet **retifp, 563 struct rtentry **retrt, int clone, int norouteok) 564 { 565 int error = 0; 566 struct ifnet *ifp = NULL; 567 struct rtentry *rt = NULL; 568 struct sockaddr_in6 *sin6_next; 569 struct in6_pktinfo *pi = NULL; 570 struct in6_addr *dst; 571 572 dst = &dstsock->sin6_addr; 573 574 #if 0 575 if (dstsock->sin6_addr.s6_addr32[0] == 0 && 576 dstsock->sin6_addr.s6_addr32[1] == 0 && 577 !IN6_IS_ADDR_LOOPBACK(&dstsock->sin6_addr)) { 578 printf("in6_selectroute: strange destination %s\n", 579 ip6_sprintf(&dstsock->sin6_addr)); 580 } else { 581 printf("in6_selectroute: destination = %s%%%d\n", 582 ip6_sprintf(&dstsock->sin6_addr), 583 dstsock->sin6_scope_id); /* for debug */ 584 } 585 #endif 586 587 /* If the caller specify the outgoing interface explicitly, use it. */ 588 if (opts && (pi = opts->ip6po_pktinfo) != NULL && pi->ipi6_ifindex) { 589 /* XXX boundary check is assumed to be already done. */ 590 ifp = if_byindex(pi->ipi6_ifindex); 591 if (ifp != NULL && 592 (norouteok || retrt == NULL || 593 IN6_IS_ADDR_MULTICAST(dst))) { 594 /* 595 * we do not have to check or get the route for 596 * multicast. 597 */ 598 goto done; 599 } else 600 goto getroute; 601 } 602 603 /* 604 * If the destination address is a multicast address and the outgoing 605 * interface for the address is specified by the caller, use it. 606 */ 607 if (IN6_IS_ADDR_MULTICAST(dst) && 608 mopts != NULL && (ifp = mopts->im6o_multicast_ifp) != NULL) { 609 goto done; /* we do not need a route for multicast. */ 610 } 611 612 getroute: 613 /* 614 * If the next hop address for the packet is specified by the caller, 615 * use it as the gateway. 616 */ 617 if (opts && opts->ip6po_nexthop) { 618 struct route *ron; 619 620 sin6_next = satosin6(opts->ip6po_nexthop); 621 622 /* at this moment, we only support AF_INET6 next hops */ 623 if (sin6_next->sin6_family != AF_INET6) { 624 error = EAFNOSUPPORT; /* or should we proceed? */ 625 goto done; 626 } 627 628 /* 629 * If the next hop is an IPv6 address, then the node identified 630 * by that address must be a neighbor of the sending host. 631 */ 632 ron = &opts->ip6po_nextroute; 633 if ((rt = rtcache_lookup(ron, sin6tosa(sin6_next))) == NULL || 634 (rt->rt_flags & RTF_GATEWAY) != 0 || 635 !nd6_is_addr_neighbor(sin6_next, rt->rt_ifp)) { 636 rtcache_free(ron); 637 error = EHOSTUNREACH; 638 goto done; 639 } 640 ifp = rt->rt_ifp; 641 642 /* 643 * When cloning is required, try to allocate a route to the 644 * destination so that the caller can store path MTU 645 * information. 646 */ 647 if (!clone) 648 goto done; 649 } 650 651 /* 652 * Use a cached route if it exists and is valid, else try to allocate 653 * a new one. Note that we should check the address family of the 654 * cached destination, in case of sharing the cache with IPv4. 655 */ 656 if (ro != NULL) { 657 union { 658 struct sockaddr dst; 659 struct sockaddr_in6 dst6; 660 } u; 661 662 /* No route yet, so try to acquire one */ 663 u.dst6 = *dstsock; 664 u.dst6.sin6_scope_id = 0; 665 rt = rtcache_lookup1(ro, &u.dst, clone); 666 667 /* 668 * do not care about the result if we have the nexthop 669 * explicitly specified. 670 */ 671 if (opts && opts->ip6po_nexthop) 672 goto done; 673 674 if (rt == NULL) 675 error = EHOSTUNREACH; 676 else 677 ifp = rt->rt_ifp; 678 679 /* 680 * Check if the outgoing interface conflicts with 681 * the interface specified by ipi6_ifindex (if specified). 682 * Note that loopback interface is always okay. 683 * (this may happen when we are sending a packet to one of 684 * our own addresses.) 685 */ 686 if (opts && opts->ip6po_pktinfo && 687 opts->ip6po_pktinfo->ipi6_ifindex) { 688 if (!(ifp->if_flags & IFF_LOOPBACK) && 689 ifp->if_index != 690 opts->ip6po_pktinfo->ipi6_ifindex) { 691 error = EHOSTUNREACH; 692 goto done; 693 } 694 } 695 } 696 697 done: 698 if (ifp == NULL && rt == NULL) { 699 /* 700 * This can happen if the caller did not pass a cached route 701 * nor any other hints. We treat this case an error. 702 */ 703 error = EHOSTUNREACH; 704 } 705 if (error == EHOSTUNREACH) 706 IP6_STATINC(IP6_STAT_NOROUTE); 707 708 if (retifp != NULL) 709 *retifp = ifp; 710 if (retrt != NULL) 711 *retrt = rt; /* rt may be NULL */ 712 713 return (error); 714 } 715 716 static int 717 in6_selectif(struct sockaddr_in6 *dstsock, struct ip6_pktopts *opts, 718 struct ip6_moptions *mopts, struct route *ro, struct ifnet **retifp) 719 { 720 int error, clone; 721 struct rtentry *rt = NULL; 722 723 clone = IN6_IS_ADDR_MULTICAST(&dstsock->sin6_addr) ? 0 : 1; 724 if ((error = selectroute(dstsock, opts, mopts, ro, retifp, 725 &rt, clone, 1)) != 0) { 726 return (error); 727 } 728 729 /* 730 * do not use a rejected or black hole route. 731 * XXX: this check should be done in the L2 output routine. 732 * However, if we skipped this check here, we'd see the following 733 * scenario: 734 * - install a rejected route for a scoped address prefix 735 * (like fe80::/10) 736 * - send a packet to a destination that matches the scoped prefix, 737 * with ambiguity about the scope zone. 738 * - pick the outgoing interface from the route, and disambiguate the 739 * scope zone with the interface. 740 * - ip6_output() would try to get another route with the "new" 741 * destination, which may be valid. 742 * - we'd see no error on output. 743 * Although this may not be very harmful, it should still be confusing. 744 * We thus reject the case here. 745 */ 746 if (rt && (rt->rt_flags & (RTF_REJECT | RTF_BLACKHOLE))) 747 return (rt->rt_flags & RTF_HOST ? EHOSTUNREACH : ENETUNREACH); 748 749 /* 750 * Adjust the "outgoing" interface. If we're going to loop the packet 751 * back to ourselves, the ifp would be the loopback interface. 752 * However, we'd rather know the interface associated to the 753 * destination address (which should probably be one of our own 754 * addresses.) 755 */ 756 if (rt && rt->rt_ifa && rt->rt_ifa->ifa_ifp) 757 *retifp = rt->rt_ifa->ifa_ifp; 758 759 return (0); 760 } 761 762 /* 763 * close - meaningful only for bsdi and freebsd. 764 */ 765 766 int 767 in6_selectroute(struct sockaddr_in6 *dstsock, struct ip6_pktopts *opts, 768 struct ip6_moptions *mopts, struct route *ro, struct ifnet **retifp, 769 struct rtentry **retrt, int clone) 770 { 771 return selectroute(dstsock, opts, mopts, ro, retifp, 772 retrt, clone, 0); 773 } 774 775 /* 776 * Default hop limit selection. The precedence is as follows: 777 * 1. Hoplimit value specified via ioctl. 778 * 2. (If the outgoing interface is detected) the current 779 * hop limit of the interface specified by router advertisement. 780 * 3. The system default hoplimit. 781 */ 782 int 783 in6_selecthlim(struct in6pcb *in6p, struct ifnet *ifp) 784 { 785 if (in6p && in6p->in6p_hops >= 0) 786 return (in6p->in6p_hops); 787 else if (ifp) 788 return (ND_IFINFO(ifp)->chlim); 789 else 790 return (ip6_defhlim); 791 } 792 793 int 794 in6_selecthlim_rt(struct in6pcb *in6p) 795 { 796 struct rtentry *rt; 797 798 if (in6p == NULL) 799 return in6_selecthlim(in6p, NULL); 800 801 rt = rtcache_validate(&in6p->in6p_route); 802 if (rt != NULL) 803 return in6_selecthlim(in6p, rt->rt_ifp); 804 else 805 return in6_selecthlim(in6p, NULL); 806 } 807 808 /* 809 * Find an empty port and set it to the specified PCB. 810 */ 811 int 812 in6_pcbsetport(struct sockaddr_in6 *sin6, struct in6pcb *in6p, struct lwp *l) 813 { 814 struct socket *so = in6p->in6p_socket; 815 struct inpcbtable *table = in6p->in6p_table; 816 u_int16_t lport, *lastport; 817 enum kauth_network_req req; 818 int error = 0; 819 820 if (in6p->in6p_flags & IN6P_LOWPORT) { 821 #ifndef IPNOPRIVPORTS 822 req = KAUTH_REQ_NETWORK_BIND_PRIVPORT; 823 #else 824 req = KAUTH_REQ_NETWORK_BIND_PORT; 825 #endif 826 lastport = &table->inpt_lastlow; 827 } else { 828 req = KAUTH_REQ_NETWORK_BIND_PORT; 829 830 lastport = &table->inpt_lastport; 831 } 832 833 /* XXX-kauth: KAUTH_REQ_NETWORK_BIND_AUTOASSIGN_{,PRIV}PORT */ 834 error = kauth_authorize_network(l->l_cred, KAUTH_NETWORK_BIND, req, so, 835 sin6, NULL); 836 if (error) 837 return (EACCES); 838 839 /* 840 * Use RFC6056 randomized port selection 841 */ 842 error = portalgo_randport(&lport, &in6p->in6p_head, l->l_cred); 843 if (error) 844 return error; 845 846 in6p->in6p_flags |= IN6P_ANONPORT; 847 *lastport = lport; 848 in6p->in6p_lport = htons(lport); 849 in6_pcbstate(in6p, IN6P_BOUND); 850 return (0); /* success */ 851 } 852 853 void 854 addrsel_policy_init(void) 855 { 856 init_policy_queue(); 857 858 /* initialize the "last resort" policy */ 859 memset(&defaultaddrpolicy, 0, sizeof(defaultaddrpolicy)); 860 defaultaddrpolicy.label = ADDR_LABEL_NOTAPP; 861 } 862 863 static struct in6_addrpolicy * 864 lookup_addrsel_policy(struct sockaddr_in6 *key) 865 { 866 struct in6_addrpolicy *match = NULL; 867 868 match = match_addrsel_policy(key); 869 870 if (match == NULL) 871 match = &defaultaddrpolicy; 872 else 873 match->use++; 874 875 return (match); 876 } 877 878 /* 879 * Subroutines to manage the address selection policy table via sysctl. 880 */ 881 struct sel_walkarg { 882 size_t w_total; 883 size_t w_given; 884 void * w_where; 885 void *w_limit; 886 }; 887 888 int sysctl_net_inet6_addrctlpolicy(SYSCTLFN_ARGS); 889 int 890 sysctl_net_inet6_addrctlpolicy(SYSCTLFN_ARGS) 891 { 892 int error = 0; 893 int s; 894 895 s = splsoftnet(); 896 897 if (newp) { 898 error = EPERM; 899 goto end; 900 } 901 if (oldp && oldlenp == NULL) { 902 error = EINVAL; 903 goto end; 904 } 905 if (oldp || oldlenp) { 906 struct sel_walkarg w; 907 size_t oldlen = *oldlenp; 908 909 memset(&w, 0, sizeof(w)); 910 w.w_given = oldlen; 911 w.w_where = oldp; 912 if (oldp) 913 w.w_limit = (char *)oldp + oldlen; 914 915 error = walk_addrsel_policy(dump_addrsel_policyent, &w); 916 917 *oldlenp = w.w_total; 918 if (oldp && w.w_total > oldlen && error == 0) 919 error = ENOMEM; 920 } 921 922 end: 923 splx(s); 924 925 return (error); 926 } 927 928 int 929 in6_src_ioctl(u_long cmd, void *data) 930 { 931 int i; 932 struct in6_addrpolicy ent0; 933 934 if (cmd != SIOCAADDRCTL_POLICY && cmd != SIOCDADDRCTL_POLICY) 935 return (EOPNOTSUPP); /* check for safety */ 936 937 ent0 = *(struct in6_addrpolicy *)data; 938 939 if (ent0.label == ADDR_LABEL_NOTAPP) 940 return (EINVAL); 941 /* check if the prefix mask is consecutive. */ 942 if (in6_mask2len(&ent0.addrmask.sin6_addr, NULL) < 0) 943 return (EINVAL); 944 /* clear trailing garbages (if any) of the prefix address. */ 945 for (i = 0; i < 4; i++) { 946 ent0.addr.sin6_addr.s6_addr32[i] &= 947 ent0.addrmask.sin6_addr.s6_addr32[i]; 948 } 949 ent0.use = 0; 950 951 switch (cmd) { 952 case SIOCAADDRCTL_POLICY: 953 return (add_addrsel_policyent(&ent0)); 954 case SIOCDADDRCTL_POLICY: 955 return (delete_addrsel_policyent(&ent0)); 956 } 957 958 return (0); /* XXX: compromise compilers */ 959 } 960 961 /* 962 * The followings are implementation of the policy table using a 963 * simple tail queue. 964 * XXX such details should be hidden. 965 * XXX implementation using binary tree should be more efficient. 966 */ 967 struct addrsel_policyent { 968 TAILQ_ENTRY(addrsel_policyent) ape_entry; 969 struct in6_addrpolicy ape_policy; 970 }; 971 972 TAILQ_HEAD(addrsel_policyhead, addrsel_policyent); 973 974 struct addrsel_policyhead addrsel_policytab; 975 976 static void 977 init_policy_queue(void) 978 { 979 TAILQ_INIT(&addrsel_policytab); 980 } 981 982 static int 983 add_addrsel_policyent(struct in6_addrpolicy *newpolicy) 984 { 985 struct addrsel_policyent *newpol, *pol; 986 987 /* duplication check */ 988 TAILQ_FOREACH(pol, &addrsel_policytab, ape_entry) { 989 if (IN6_ARE_ADDR_EQUAL(&newpolicy->addr.sin6_addr, 990 &pol->ape_policy.addr.sin6_addr) && 991 IN6_ARE_ADDR_EQUAL(&newpolicy->addrmask.sin6_addr, 992 &pol->ape_policy.addrmask.sin6_addr)) { 993 return (EEXIST); /* or override it? */ 994 } 995 } 996 997 newpol = malloc(sizeof(*newpol), M_IFADDR, M_WAITOK|M_ZERO); 998 999 /* XXX: should validate entry */ 1000 newpol->ape_policy = *newpolicy; 1001 1002 TAILQ_INSERT_TAIL(&addrsel_policytab, newpol, ape_entry); 1003 1004 return (0); 1005 } 1006 1007 static int 1008 delete_addrsel_policyent(struct in6_addrpolicy *key) 1009 { 1010 struct addrsel_policyent *pol; 1011 1012 /* search for the entry in the table */ 1013 for (pol = TAILQ_FIRST(&addrsel_policytab); pol; 1014 pol = TAILQ_NEXT(pol, ape_entry)) { 1015 if (IN6_ARE_ADDR_EQUAL(&key->addr.sin6_addr, 1016 &pol->ape_policy.addr.sin6_addr) && 1017 IN6_ARE_ADDR_EQUAL(&key->addrmask.sin6_addr, 1018 &pol->ape_policy.addrmask.sin6_addr)) { 1019 break; 1020 } 1021 } 1022 if (pol == NULL) { 1023 return (ESRCH); 1024 } 1025 1026 TAILQ_REMOVE(&addrsel_policytab, pol, ape_entry); 1027 1028 return (0); 1029 } 1030 1031 static int 1032 walk_addrsel_policy(int (*callback)(struct in6_addrpolicy *, void *), void *w) 1033 { 1034 struct addrsel_policyent *pol; 1035 int error = 0; 1036 1037 TAILQ_FOREACH(pol, &addrsel_policytab, ape_entry) { 1038 if ((error = (*callback)(&pol->ape_policy, w)) != 0) 1039 return error; 1040 } 1041 1042 return error; 1043 } 1044 1045 static int 1046 dump_addrsel_policyent(struct in6_addrpolicy *pol, void *arg) 1047 { 1048 int error = 0; 1049 struct sel_walkarg *w = arg; 1050 1051 if (w->w_where && (char *)w->w_where + sizeof(*pol) <= (char *)w->w_limit) { 1052 if ((error = copyout(pol, w->w_where, sizeof(*pol))) != 0) 1053 return error; 1054 w->w_where = (char *)w->w_where + sizeof(*pol); 1055 } 1056 w->w_total += sizeof(*pol); 1057 1058 return error; 1059 } 1060 1061 static struct in6_addrpolicy * 1062 match_addrsel_policy(struct sockaddr_in6 *key) 1063 { 1064 struct addrsel_policyent *pent; 1065 struct in6_addrpolicy *bestpol = NULL, *pol; 1066 int matchlen, bestmatchlen = -1; 1067 u_char *mp, *ep, *k, *p, m; 1068 1069 for (pent = TAILQ_FIRST(&addrsel_policytab); pent; 1070 pent = TAILQ_NEXT(pent, ape_entry)) { 1071 matchlen = 0; 1072 1073 pol = &pent->ape_policy; 1074 mp = (u_char *)&pol->addrmask.sin6_addr; 1075 ep = mp + 16; /* XXX: scope field? */ 1076 k = (u_char *)&key->sin6_addr; 1077 p = (u_char *)&pol->addr.sin6_addr; 1078 for (; mp < ep && *mp; mp++, k++, p++) { 1079 m = *mp; 1080 if ((*k & m) != *p) 1081 goto next; /* not match */ 1082 if (m == 0xff) /* short cut for a typical case */ 1083 matchlen += 8; 1084 else { 1085 while (m >= 0x80) { 1086 matchlen++; 1087 m <<= 1; 1088 } 1089 } 1090 } 1091 1092 /* matched. check if this is better than the current best. */ 1093 if (bestpol == NULL || 1094 matchlen > bestmatchlen) { 1095 bestpol = pol; 1096 bestmatchlen = matchlen; 1097 } 1098 1099 next: 1100 continue; 1101 } 1102 1103 return (bestpol); 1104 } 1105