1caf43b02SWarner Losh /*- 2686cdd19SJun-ichiro itojun Hagino * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project. 3686cdd19SJun-ichiro itojun Hagino * All rights reserved. 4686cdd19SJun-ichiro itojun Hagino * 5686cdd19SJun-ichiro itojun Hagino * Redistribution and use in source and binary forms, with or without 6686cdd19SJun-ichiro itojun Hagino * modification, are permitted provided that the following conditions 7686cdd19SJun-ichiro itojun Hagino * are met: 8686cdd19SJun-ichiro itojun Hagino * 1. Redistributions of source code must retain the above copyright 9686cdd19SJun-ichiro itojun Hagino * notice, this list of conditions and the following disclaimer. 10686cdd19SJun-ichiro itojun Hagino * 2. Redistributions in binary form must reproduce the above copyright 11686cdd19SJun-ichiro itojun Hagino * notice, this list of conditions and the following disclaimer in the 12686cdd19SJun-ichiro itojun Hagino * documentation and/or other materials provided with the distribution. 13686cdd19SJun-ichiro itojun Hagino * 3. Neither the name of the project nor the names of its contributors 14686cdd19SJun-ichiro itojun Hagino * may be used to endorse or promote products derived from this software 15686cdd19SJun-ichiro itojun Hagino * without specific prior written permission. 16686cdd19SJun-ichiro itojun Hagino * 17686cdd19SJun-ichiro itojun Hagino * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND 18686cdd19SJun-ichiro itojun Hagino * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19686cdd19SJun-ichiro itojun Hagino * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20686cdd19SJun-ichiro itojun Hagino * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE 21686cdd19SJun-ichiro itojun Hagino * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22686cdd19SJun-ichiro itojun Hagino * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23686cdd19SJun-ichiro itojun Hagino * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24686cdd19SJun-ichiro itojun Hagino * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25686cdd19SJun-ichiro itojun Hagino * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26686cdd19SJun-ichiro itojun Hagino * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27686cdd19SJun-ichiro itojun Hagino * SUCH DAMAGE. 28b48287a3SDavid E. O'Brien * 29b48287a3SDavid E. O'Brien * $KAME: in6_src.c,v 1.132 2003/08/26 04:42:27 keiichi Exp $ 30686cdd19SJun-ichiro itojun Hagino */ 31686cdd19SJun-ichiro itojun Hagino 32caf43b02SWarner Losh /*- 33686cdd19SJun-ichiro itojun Hagino * Copyright (c) 1982, 1986, 1991, 1993 34686cdd19SJun-ichiro itojun Hagino * The Regents of the University of California. All rights reserved. 35686cdd19SJun-ichiro itojun Hagino * 36686cdd19SJun-ichiro itojun Hagino * Redistribution and use in source and binary forms, with or without 37686cdd19SJun-ichiro itojun Hagino * modification, are permitted provided that the following conditions 38686cdd19SJun-ichiro itojun Hagino * are met: 39686cdd19SJun-ichiro itojun Hagino * 1. Redistributions of source code must retain the above copyright 40686cdd19SJun-ichiro itojun Hagino * notice, this list of conditions and the following disclaimer. 41686cdd19SJun-ichiro itojun Hagino * 2. Redistributions in binary form must reproduce the above copyright 42686cdd19SJun-ichiro itojun Hagino * notice, this list of conditions and the following disclaimer in the 43686cdd19SJun-ichiro itojun Hagino * documentation and/or other materials provided with the distribution. 44686cdd19SJun-ichiro itojun Hagino * 4. Neither the name of the University nor the names of its contributors 45686cdd19SJun-ichiro itojun Hagino * may be used to endorse or promote products derived from this software 46686cdd19SJun-ichiro itojun Hagino * without specific prior written permission. 47686cdd19SJun-ichiro itojun Hagino * 48686cdd19SJun-ichiro itojun Hagino * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 49686cdd19SJun-ichiro itojun Hagino * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 50686cdd19SJun-ichiro itojun Hagino * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 51686cdd19SJun-ichiro itojun Hagino * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 52686cdd19SJun-ichiro itojun Hagino * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 53686cdd19SJun-ichiro itojun Hagino * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 54686cdd19SJun-ichiro itojun Hagino * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 55686cdd19SJun-ichiro itojun Hagino * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 56686cdd19SJun-ichiro itojun Hagino * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 57686cdd19SJun-ichiro itojun Hagino * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 58686cdd19SJun-ichiro itojun Hagino * SUCH DAMAGE. 59686cdd19SJun-ichiro itojun Hagino * 60686cdd19SJun-ichiro itojun Hagino * @(#)in_pcb.c 8.2 (Berkeley) 1/4/94 61686cdd19SJun-ichiro itojun Hagino */ 62686cdd19SJun-ichiro itojun Hagino 63b48287a3SDavid E. O'Brien #include <sys/cdefs.h> 64b48287a3SDavid E. O'Brien __FBSDID("$FreeBSD$"); 65b48287a3SDavid E. O'Brien 66686cdd19SJun-ichiro itojun Hagino #include "opt_inet.h" 67686cdd19SJun-ichiro itojun Hagino #include "opt_inet6.h" 68686cdd19SJun-ichiro itojun Hagino 69686cdd19SJun-ichiro itojun Hagino #include <sys/param.h> 70686cdd19SJun-ichiro itojun Hagino #include <sys/systm.h> 714e7f640dSJohn Baldwin #include <sys/lock.h> 7233841545SHajimu UMEMOTO #include <sys/malloc.h> 73686cdd19SJun-ichiro itojun Hagino #include <sys/mbuf.h> 74acd3428bSRobert Watson #include <sys/priv.h> 75686cdd19SJun-ichiro itojun Hagino #include <sys/protosw.h> 76686cdd19SJun-ichiro itojun Hagino #include <sys/socket.h> 77686cdd19SJun-ichiro itojun Hagino #include <sys/socketvar.h> 787fc91b3fSHajimu UMEMOTO #include <sys/sockio.h> 797fc91b3fSHajimu UMEMOTO #include <sys/sysctl.h> 80686cdd19SJun-ichiro itojun Hagino #include <sys/errno.h> 81686cdd19SJun-ichiro itojun Hagino #include <sys/time.h> 824a201dfcSHajimu UMEMOTO #include <sys/kernel.h> 835d525653SHajimu UMEMOTO #include <sys/sx.h> 84686cdd19SJun-ichiro itojun Hagino 85686cdd19SJun-ichiro itojun Hagino #include <net/if.h> 86686cdd19SJun-ichiro itojun Hagino #include <net/route.h> 87686cdd19SJun-ichiro itojun Hagino 88686cdd19SJun-ichiro itojun Hagino #include <netinet/in.h> 89686cdd19SJun-ichiro itojun Hagino #include <netinet/in_var.h> 90686cdd19SJun-ichiro itojun Hagino #include <netinet/in_systm.h> 91686cdd19SJun-ichiro itojun Hagino #include <netinet/ip.h> 92686cdd19SJun-ichiro itojun Hagino #include <netinet/in_pcb.h> 93686cdd19SJun-ichiro itojun Hagino #include <netinet6/in6_var.h> 94686cdd19SJun-ichiro itojun Hagino #include <netinet/ip6.h> 95686cdd19SJun-ichiro itojun Hagino #include <netinet6/in6_pcb.h> 96686cdd19SJun-ichiro itojun Hagino #include <netinet6/ip6_var.h> 97a1f7e5f8SHajimu UMEMOTO #include <netinet6/scope6_var.h> 98686cdd19SJun-ichiro itojun Hagino #include <netinet6/nd6.h> 99686cdd19SJun-ichiro itojun Hagino 1007fc91b3fSHajimu UMEMOTO static struct mtx addrsel_lock; 1017fc91b3fSHajimu UMEMOTO #define ADDRSEL_LOCK_INIT() mtx_init(&addrsel_lock, "addrsel_lock", NULL, MTX_DEF) 1027fc91b3fSHajimu UMEMOTO #define ADDRSEL_LOCK() mtx_lock(&addrsel_lock) 1037fc91b3fSHajimu UMEMOTO #define ADDRSEL_UNLOCK() mtx_unlock(&addrsel_lock) 1047fc91b3fSHajimu UMEMOTO #define ADDRSEL_LOCK_ASSERT() mtx_assert(&addrsel_lock, MA_OWNED) 1057fc91b3fSHajimu UMEMOTO 1065d525653SHajimu UMEMOTO static struct sx addrsel_sxlock; 1075d525653SHajimu UMEMOTO #define ADDRSEL_SXLOCK_INIT() sx_init(&addrsel_sxlock, "addrsel_sxlock") 1085d525653SHajimu UMEMOTO #define ADDRSEL_SLOCK() sx_slock(&addrsel_sxlock) 1095d525653SHajimu UMEMOTO #define ADDRSEL_SUNLOCK() sx_sunlock(&addrsel_sxlock) 1105d525653SHajimu UMEMOTO #define ADDRSEL_XLOCK() sx_xlock(&addrsel_sxlock) 1115d525653SHajimu UMEMOTO #define ADDRSEL_XUNLOCK() sx_xunlock(&addrsel_sxlock) 1125d525653SHajimu UMEMOTO 1137fc91b3fSHajimu UMEMOTO #define ADDR_LABEL_NOTAPP (-1) 1147fc91b3fSHajimu UMEMOTO struct in6_addrpolicy defaultaddrpolicy; 1157fc91b3fSHajimu UMEMOTO 116d6385b1cSHajimu UMEMOTO int ip6_prefer_tempaddr = 0; 117d6385b1cSHajimu UMEMOTO 118a1f7e5f8SHajimu UMEMOTO static int selectroute __P((struct sockaddr_in6 *, struct ip6_pktopts *, 119a1f7e5f8SHajimu UMEMOTO struct ip6_moptions *, struct route_in6 *, struct ifnet **, 120a1f7e5f8SHajimu UMEMOTO struct rtentry **, int, int)); 121d6385b1cSHajimu UMEMOTO static int in6_selectif __P((struct sockaddr_in6 *, struct ip6_pktopts *, 12268efda09SHajimu UMEMOTO struct ip6_moptions *, struct route_in6 *ro, struct ifnet **)); 123d6385b1cSHajimu UMEMOTO 124d6385b1cSHajimu UMEMOTO static struct in6_addrpolicy *lookup_addrsel_policy __P((struct sockaddr_in6 *)); 125d6385b1cSHajimu UMEMOTO 1267fc91b3fSHajimu UMEMOTO static void init_policy_queue __P((void)); 1277fc91b3fSHajimu UMEMOTO static int add_addrsel_policyent __P((struct in6_addrpolicy *)); 1287fc91b3fSHajimu UMEMOTO static int delete_addrsel_policyent __P((struct in6_addrpolicy *)); 1297fc91b3fSHajimu UMEMOTO static int walk_addrsel_policy __P((int (*)(struct in6_addrpolicy *, void *), 1307fc91b3fSHajimu UMEMOTO void *)); 1317fc91b3fSHajimu UMEMOTO static int dump_addrsel_policyent __P((struct in6_addrpolicy *, void *)); 132d6385b1cSHajimu UMEMOTO static struct in6_addrpolicy *match_addrsel_policy __P((struct sockaddr_in6 *)); 1337fc91b3fSHajimu UMEMOTO 134686cdd19SJun-ichiro itojun Hagino /* 13533841545SHajimu UMEMOTO * Return an IPv6 address, which is the most appropriate for a given 136686cdd19SJun-ichiro itojun Hagino * destination and user specified options. 13733841545SHajimu UMEMOTO * If necessary, this function lookups the routing table and returns 138686cdd19SJun-ichiro itojun Hagino * an entry to the caller for later use. 139686cdd19SJun-ichiro itojun Hagino */ 140d6385b1cSHajimu UMEMOTO #define REPLACE(r) do {\ 141d6385b1cSHajimu UMEMOTO if ((r) < sizeof(ip6stat.ip6s_sources_rule) / \ 142d6385b1cSHajimu UMEMOTO sizeof(ip6stat.ip6s_sources_rule[0])) /* check for safety */ \ 143d6385b1cSHajimu UMEMOTO ip6stat.ip6s_sources_rule[(r)]++; \ 144d6385b1cSHajimu UMEMOTO /* 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)); */ \ 145d6385b1cSHajimu UMEMOTO goto replace; \ 146d6385b1cSHajimu UMEMOTO } while(0) 147d6385b1cSHajimu UMEMOTO #define NEXT(r) do {\ 148d6385b1cSHajimu UMEMOTO if ((r) < sizeof(ip6stat.ip6s_sources_rule) / \ 149d6385b1cSHajimu UMEMOTO sizeof(ip6stat.ip6s_sources_rule[0])) /* check for safety */ \ 150d6385b1cSHajimu UMEMOTO ip6stat.ip6s_sources_rule[(r)]++; \ 151d6385b1cSHajimu UMEMOTO /* 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)); */ \ 152d6385b1cSHajimu UMEMOTO goto next; /* XXX: we can't use 'continue' here */ \ 153d6385b1cSHajimu UMEMOTO } while(0) 154d6385b1cSHajimu UMEMOTO #define BREAK(r) do { \ 155d6385b1cSHajimu UMEMOTO if ((r) < sizeof(ip6stat.ip6s_sources_rule) / \ 156d6385b1cSHajimu UMEMOTO sizeof(ip6stat.ip6s_sources_rule[0])) /* check for safety */ \ 157d6385b1cSHajimu UMEMOTO ip6stat.ip6s_sources_rule[(r)]++; \ 158d6385b1cSHajimu UMEMOTO goto out; /* XXX: we can't use 'break' here */ \ 159d6385b1cSHajimu UMEMOTO } while(0) 160d6385b1cSHajimu UMEMOTO 161686cdd19SJun-ichiro itojun Hagino struct in6_addr * 1621272577eSXin LI in6_selectsrc(struct sockaddr_in6 *dstsock, struct ip6_pktopts *opts, 1631272577eSXin LI struct ip6_moptions *mopts, struct route_in6 *ro, 1641272577eSXin LI struct in6_addr *laddr, struct ifnet **ifpp, int *errorp) 165686cdd19SJun-ichiro itojun Hagino { 166a1f7e5f8SHajimu UMEMOTO struct in6_addr dst; 167d6385b1cSHajimu UMEMOTO struct ifnet *ifp = NULL; 168d6385b1cSHajimu UMEMOTO struct in6_ifaddr *ia = NULL, *ia_best = NULL; 169686cdd19SJun-ichiro itojun Hagino struct in6_pktinfo *pi = NULL; 170d6385b1cSHajimu UMEMOTO int dst_scope = -1, best_scope = -1, best_matchlen = -1; 171d6385b1cSHajimu UMEMOTO struct in6_addrpolicy *dst_policy = NULL, *best_policy = NULL; 172d6385b1cSHajimu UMEMOTO u_int32_t odstzone; 173d6385b1cSHajimu UMEMOTO int prefer_tempaddr; 174e6a27350SHajimu UMEMOTO 175a1f7e5f8SHajimu UMEMOTO dst = dstsock->sin6_addr; /* make a copy for local operation */ 176686cdd19SJun-ichiro itojun Hagino *errorp = 0; 177a1f7e5f8SHajimu UMEMOTO if (ifpp) 178a1f7e5f8SHajimu UMEMOTO *ifpp = NULL; 179686cdd19SJun-ichiro itojun Hagino 180686cdd19SJun-ichiro itojun Hagino /* 181686cdd19SJun-ichiro itojun Hagino * If the source address is explicitly specified by the caller, 182d6385b1cSHajimu UMEMOTO * check if the requested source address is indeed a unicast address 183d6385b1cSHajimu UMEMOTO * assigned to the node, and can be used as the packet's source 184d6385b1cSHajimu UMEMOTO * address. If everything is okay, use the address as source. 185686cdd19SJun-ichiro itojun Hagino */ 186686cdd19SJun-ichiro itojun Hagino if (opts && (pi = opts->ip6po_pktinfo) && 187d6385b1cSHajimu UMEMOTO !IN6_IS_ADDR_UNSPECIFIED(&pi->ipi6_addr)) { 188d6385b1cSHajimu UMEMOTO struct sockaddr_in6 srcsock; 189d6385b1cSHajimu UMEMOTO struct in6_ifaddr *ia6; 190d6385b1cSHajimu UMEMOTO 191d6385b1cSHajimu UMEMOTO /* get the outgoing interface */ 192d6385b1cSHajimu UMEMOTO if ((*errorp = in6_selectif(dstsock, opts, mopts, ro, &ifp)) 193d6385b1cSHajimu UMEMOTO != 0) { 194d6385b1cSHajimu UMEMOTO return (NULL); 195d6385b1cSHajimu UMEMOTO } 19668efda09SHajimu UMEMOTO 197686cdd19SJun-ichiro itojun Hagino /* 198d6385b1cSHajimu UMEMOTO * determine the appropriate zone id of the source based on 199d6385b1cSHajimu UMEMOTO * the zone of the destination and the outgoing interface. 200a1f7e5f8SHajimu UMEMOTO * If the specified address is ambiguous wrt the scope zone, 201a1f7e5f8SHajimu UMEMOTO * the interface must be specified; otherwise, ifa_ifwithaddr() 202a1f7e5f8SHajimu UMEMOTO * will fail matching the address. 203d6385b1cSHajimu UMEMOTO */ 204d6385b1cSHajimu UMEMOTO bzero(&srcsock, sizeof(srcsock)); 205d6385b1cSHajimu UMEMOTO srcsock.sin6_family = AF_INET6; 206d6385b1cSHajimu UMEMOTO srcsock.sin6_len = sizeof(srcsock); 207d6385b1cSHajimu UMEMOTO srcsock.sin6_addr = pi->ipi6_addr; 208d6385b1cSHajimu UMEMOTO if (ifp) { 209a1f7e5f8SHajimu UMEMOTO *errorp = in6_setscope(&srcsock.sin6_addr, ifp, NULL); 210a1f7e5f8SHajimu UMEMOTO if (*errorp != 0) 211d6385b1cSHajimu UMEMOTO return (NULL); 212d6385b1cSHajimu UMEMOTO } 213a1f7e5f8SHajimu UMEMOTO 214d6385b1cSHajimu UMEMOTO ia6 = (struct in6_ifaddr *)ifa_ifwithaddr((struct sockaddr *)(&srcsock)); 215d6385b1cSHajimu UMEMOTO if (ia6 == NULL || 216d6385b1cSHajimu UMEMOTO (ia6->ia6_flags & (IN6_IFF_ANYCAST | IN6_IFF_NOTREADY))) { 217d6385b1cSHajimu UMEMOTO *errorp = EADDRNOTAVAIL; 218d6385b1cSHajimu UMEMOTO return (NULL); 219d6385b1cSHajimu UMEMOTO } 220d6385b1cSHajimu UMEMOTO pi->ipi6_addr = srcsock.sin6_addr; /* XXX: this overrides pi */ 221a1f7e5f8SHajimu UMEMOTO if (ifpp) 222a1f7e5f8SHajimu UMEMOTO *ifpp = ifp; 223d6385b1cSHajimu UMEMOTO return (&ia6->ia_addr.sin6_addr); 224d6385b1cSHajimu UMEMOTO } 225d6385b1cSHajimu UMEMOTO 226d6385b1cSHajimu UMEMOTO /* 227d6385b1cSHajimu UMEMOTO * Otherwise, if the socket has already bound the source, just use it. 228686cdd19SJun-ichiro itojun Hagino */ 229686cdd19SJun-ichiro itojun Hagino if (laddr && !IN6_IS_ADDR_UNSPECIFIED(laddr)) 230686cdd19SJun-ichiro itojun Hagino return (laddr); 231686cdd19SJun-ichiro itojun Hagino 232686cdd19SJun-ichiro itojun Hagino /* 233d6385b1cSHajimu UMEMOTO * If the address is not specified, choose the best one based on 234d6385b1cSHajimu UMEMOTO * the outgoing interface and the destination address. 235686cdd19SJun-ichiro itojun Hagino */ 236d6385b1cSHajimu UMEMOTO /* get the outgoing interface */ 237d6385b1cSHajimu UMEMOTO if ((*errorp = in6_selectif(dstsock, opts, mopts, ro, &ifp)) != 0) 238d6385b1cSHajimu UMEMOTO return (NULL); 239686cdd19SJun-ichiro itojun Hagino 240d6385b1cSHajimu UMEMOTO #ifdef DIAGNOSTIC 241d6385b1cSHajimu UMEMOTO if (ifp == NULL) /* this should not happen */ 242d6385b1cSHajimu UMEMOTO panic("in6_selectsrc: NULL ifp"); 243d6385b1cSHajimu UMEMOTO #endif 244a1f7e5f8SHajimu UMEMOTO *errorp = in6_setscope(&dst, ifp, &odstzone); 245a1f7e5f8SHajimu UMEMOTO if (*errorp != 0) 246d6385b1cSHajimu UMEMOTO return (NULL); 247a1f7e5f8SHajimu UMEMOTO 248d6385b1cSHajimu UMEMOTO for (ia = in6_ifaddr; ia; ia = ia->ia_next) { 249d6385b1cSHajimu UMEMOTO int new_scope = -1, new_matchlen = -1; 250d6385b1cSHajimu UMEMOTO struct in6_addrpolicy *new_policy = NULL; 251d6385b1cSHajimu UMEMOTO u_int32_t srczone, osrczone, dstzone; 252a1f7e5f8SHajimu UMEMOTO struct in6_addr src; 253d6385b1cSHajimu UMEMOTO struct ifnet *ifp1 = ia->ia_ifp; 254d6385b1cSHajimu UMEMOTO 255d6385b1cSHajimu UMEMOTO /* 256d6385b1cSHajimu UMEMOTO * We'll never take an address that breaks the scope zone 257d6385b1cSHajimu UMEMOTO * of the destination. We also skip an address if its zone 258d6385b1cSHajimu UMEMOTO * does not contain the outgoing interface. 259d6385b1cSHajimu UMEMOTO * XXX: we should probably use sin6_scope_id here. 260d6385b1cSHajimu UMEMOTO */ 261a1f7e5f8SHajimu UMEMOTO if (in6_setscope(&dst, ifp1, &dstzone) || 262d6385b1cSHajimu UMEMOTO odstzone != dstzone) { 263d6385b1cSHajimu UMEMOTO continue; 264d6385b1cSHajimu UMEMOTO } 265a1f7e5f8SHajimu UMEMOTO src = ia->ia_addr.sin6_addr; 266a1f7e5f8SHajimu UMEMOTO if (in6_setscope(&src, ifp, &osrczone) || 267a1f7e5f8SHajimu UMEMOTO in6_setscope(&src, ifp1, &srczone) || 268d6385b1cSHajimu UMEMOTO osrczone != srczone) { 269d6385b1cSHajimu UMEMOTO continue; 270686cdd19SJun-ichiro itojun Hagino } 271686cdd19SJun-ichiro itojun Hagino 272d6385b1cSHajimu UMEMOTO /* avoid unusable addresses */ 273d6385b1cSHajimu UMEMOTO if ((ia->ia6_flags & 274d6385b1cSHajimu UMEMOTO (IN6_IFF_NOTREADY | IN6_IFF_ANYCAST | IN6_IFF_DETACHED))) { 275d6385b1cSHajimu UMEMOTO continue; 276d6385b1cSHajimu UMEMOTO } 277d6385b1cSHajimu UMEMOTO if (!ip6_use_deprecated && IFA6_IS_DEPRECATED(ia)) 278d6385b1cSHajimu UMEMOTO continue; 279d6385b1cSHajimu UMEMOTO 280d6385b1cSHajimu UMEMOTO /* Rule 1: Prefer same address */ 281a1f7e5f8SHajimu UMEMOTO if (IN6_ARE_ADDR_EQUAL(&dst, &ia->ia_addr.sin6_addr)) { 282d6385b1cSHajimu UMEMOTO ia_best = ia; 283d6385b1cSHajimu UMEMOTO BREAK(1); /* there should be no better candidate */ 284d6385b1cSHajimu UMEMOTO } 285d6385b1cSHajimu UMEMOTO 286d6385b1cSHajimu UMEMOTO if (ia_best == NULL) 287d6385b1cSHajimu UMEMOTO REPLACE(0); 288d6385b1cSHajimu UMEMOTO 289d6385b1cSHajimu UMEMOTO /* Rule 2: Prefer appropriate scope */ 290d6385b1cSHajimu UMEMOTO if (dst_scope < 0) 291a1f7e5f8SHajimu UMEMOTO dst_scope = in6_addrscope(&dst); 292d6385b1cSHajimu UMEMOTO new_scope = in6_addrscope(&ia->ia_addr.sin6_addr); 293d6385b1cSHajimu UMEMOTO if (IN6_ARE_SCOPE_CMP(best_scope, new_scope) < 0) { 294d6385b1cSHajimu UMEMOTO if (IN6_ARE_SCOPE_CMP(best_scope, dst_scope) < 0) 295d6385b1cSHajimu UMEMOTO REPLACE(2); 296d6385b1cSHajimu UMEMOTO NEXT(2); 297d6385b1cSHajimu UMEMOTO } else if (IN6_ARE_SCOPE_CMP(new_scope, best_scope) < 0) { 298d6385b1cSHajimu UMEMOTO if (IN6_ARE_SCOPE_CMP(new_scope, dst_scope) < 0) 299d6385b1cSHajimu UMEMOTO NEXT(2); 300d6385b1cSHajimu UMEMOTO REPLACE(2); 301d6385b1cSHajimu UMEMOTO } 302d6385b1cSHajimu UMEMOTO 303d6385b1cSHajimu UMEMOTO /* 304d6385b1cSHajimu UMEMOTO * Rule 3: Avoid deprecated addresses. Note that the case of 305d6385b1cSHajimu UMEMOTO * !ip6_use_deprecated is already rejected above. 306d6385b1cSHajimu UMEMOTO */ 307d6385b1cSHajimu UMEMOTO if (!IFA6_IS_DEPRECATED(ia_best) && IFA6_IS_DEPRECATED(ia)) 308d6385b1cSHajimu UMEMOTO NEXT(3); 309d6385b1cSHajimu UMEMOTO if (IFA6_IS_DEPRECATED(ia_best) && !IFA6_IS_DEPRECATED(ia)) 310d6385b1cSHajimu UMEMOTO REPLACE(3); 311d6385b1cSHajimu UMEMOTO 312d6385b1cSHajimu UMEMOTO /* Rule 4: Prefer home addresses */ 313d6385b1cSHajimu UMEMOTO /* 314d6385b1cSHajimu UMEMOTO * XXX: This is a TODO. We should probably merge the MIP6 315d6385b1cSHajimu UMEMOTO * case above. 316d6385b1cSHajimu UMEMOTO */ 317d6385b1cSHajimu UMEMOTO 318d6385b1cSHajimu UMEMOTO /* Rule 5: Prefer outgoing interface */ 319d6385b1cSHajimu UMEMOTO if (ia_best->ia_ifp == ifp && ia->ia_ifp != ifp) 320d6385b1cSHajimu UMEMOTO NEXT(5); 321d6385b1cSHajimu UMEMOTO if (ia_best->ia_ifp != ifp && ia->ia_ifp == ifp) 322d6385b1cSHajimu UMEMOTO REPLACE(5); 323d6385b1cSHajimu UMEMOTO 324d6385b1cSHajimu UMEMOTO /* 325d6385b1cSHajimu UMEMOTO * Rule 6: Prefer matching label 326d6385b1cSHajimu UMEMOTO * Note that best_policy should be non-NULL here. 327d6385b1cSHajimu UMEMOTO */ 328d6385b1cSHajimu UMEMOTO if (dst_policy == NULL) 329d6385b1cSHajimu UMEMOTO dst_policy = lookup_addrsel_policy(dstsock); 330d6385b1cSHajimu UMEMOTO if (dst_policy->label != ADDR_LABEL_NOTAPP) { 331d6385b1cSHajimu UMEMOTO new_policy = lookup_addrsel_policy(&ia->ia_addr); 332d6385b1cSHajimu UMEMOTO if (dst_policy->label == best_policy->label && 333d6385b1cSHajimu UMEMOTO dst_policy->label != new_policy->label) 334d6385b1cSHajimu UMEMOTO NEXT(6); 335d6385b1cSHajimu UMEMOTO if (dst_policy->label != best_policy->label && 336d6385b1cSHajimu UMEMOTO dst_policy->label == new_policy->label) 337d6385b1cSHajimu UMEMOTO REPLACE(6); 338d6385b1cSHajimu UMEMOTO } 339d6385b1cSHajimu UMEMOTO 340d6385b1cSHajimu UMEMOTO /* 341d6385b1cSHajimu UMEMOTO * Rule 7: Prefer public addresses. 342d6385b1cSHajimu UMEMOTO * We allow users to reverse the logic by configuring 343d6385b1cSHajimu UMEMOTO * a sysctl variable, so that privacy conscious users can 344d6385b1cSHajimu UMEMOTO * always prefer temporary addresses. 345d6385b1cSHajimu UMEMOTO */ 346d6385b1cSHajimu UMEMOTO if (opts == NULL || 347d6385b1cSHajimu UMEMOTO opts->ip6po_prefer_tempaddr == IP6PO_TEMPADDR_SYSTEM) { 348d6385b1cSHajimu UMEMOTO prefer_tempaddr = ip6_prefer_tempaddr; 349d6385b1cSHajimu UMEMOTO } else if (opts->ip6po_prefer_tempaddr == 350d6385b1cSHajimu UMEMOTO IP6PO_TEMPADDR_NOTPREFER) { 351d6385b1cSHajimu UMEMOTO prefer_tempaddr = 0; 352d6385b1cSHajimu UMEMOTO } else 353d6385b1cSHajimu UMEMOTO prefer_tempaddr = 1; 354d6385b1cSHajimu UMEMOTO if (!(ia_best->ia6_flags & IN6_IFF_TEMPORARY) && 355d6385b1cSHajimu UMEMOTO (ia->ia6_flags & IN6_IFF_TEMPORARY)) { 356d6385b1cSHajimu UMEMOTO if (prefer_tempaddr) 357d6385b1cSHajimu UMEMOTO REPLACE(7); 358d6385b1cSHajimu UMEMOTO else 359d6385b1cSHajimu UMEMOTO NEXT(7); 360d6385b1cSHajimu UMEMOTO } 361d6385b1cSHajimu UMEMOTO if ((ia_best->ia6_flags & IN6_IFF_TEMPORARY) && 362d6385b1cSHajimu UMEMOTO !(ia->ia6_flags & IN6_IFF_TEMPORARY)) { 363d6385b1cSHajimu UMEMOTO if (prefer_tempaddr) 364d6385b1cSHajimu UMEMOTO NEXT(7); 365d6385b1cSHajimu UMEMOTO else 366d6385b1cSHajimu UMEMOTO REPLACE(7); 367d6385b1cSHajimu UMEMOTO } 368d6385b1cSHajimu UMEMOTO 369d6385b1cSHajimu UMEMOTO /* 370d6385b1cSHajimu UMEMOTO * Rule 8: prefer addresses on alive interfaces. 371d6385b1cSHajimu UMEMOTO * This is a KAME specific rule. 372d6385b1cSHajimu UMEMOTO */ 373d6385b1cSHajimu UMEMOTO if ((ia_best->ia_ifp->if_flags & IFF_UP) && 374d6385b1cSHajimu UMEMOTO !(ia->ia_ifp->if_flags & IFF_UP)) 375d6385b1cSHajimu UMEMOTO NEXT(8); 376d6385b1cSHajimu UMEMOTO if (!(ia_best->ia_ifp->if_flags & IFF_UP) && 377d6385b1cSHajimu UMEMOTO (ia->ia_ifp->if_flags & IFF_UP)) 378d6385b1cSHajimu UMEMOTO REPLACE(8); 379d6385b1cSHajimu UMEMOTO 380d6385b1cSHajimu UMEMOTO /* 381d6385b1cSHajimu UMEMOTO * Rule 14: Use longest matching prefix. 382d6385b1cSHajimu UMEMOTO * Note: in the address selection draft, this rule is 383d6385b1cSHajimu UMEMOTO * documented as "Rule 8". However, since it is also 384d6385b1cSHajimu UMEMOTO * documented that this rule can be overridden, we assign 385d6385b1cSHajimu UMEMOTO * a large number so that it is easy to assign smaller numbers 386d6385b1cSHajimu UMEMOTO * to more preferred rules. 387d6385b1cSHajimu UMEMOTO */ 388a1f7e5f8SHajimu UMEMOTO new_matchlen = in6_matchlen(&ia->ia_addr.sin6_addr, &dst); 389d6385b1cSHajimu UMEMOTO if (best_matchlen < new_matchlen) 390d6385b1cSHajimu UMEMOTO REPLACE(14); 391d6385b1cSHajimu UMEMOTO if (new_matchlen < best_matchlen) 392d6385b1cSHajimu UMEMOTO NEXT(14); 393d6385b1cSHajimu UMEMOTO 394d6385b1cSHajimu UMEMOTO /* Rule 15 is reserved. */ 395d6385b1cSHajimu UMEMOTO 396d6385b1cSHajimu UMEMOTO /* 397d6385b1cSHajimu UMEMOTO * Last resort: just keep the current candidate. 398d6385b1cSHajimu UMEMOTO * Or, do we need more rules? 399d6385b1cSHajimu UMEMOTO */ 400d6385b1cSHajimu UMEMOTO continue; 401d6385b1cSHajimu UMEMOTO 402d6385b1cSHajimu UMEMOTO replace: 403d6385b1cSHajimu UMEMOTO ia_best = ia; 404d6385b1cSHajimu UMEMOTO best_scope = (new_scope >= 0 ? new_scope : 405d6385b1cSHajimu UMEMOTO in6_addrscope(&ia_best->ia_addr.sin6_addr)); 406d6385b1cSHajimu UMEMOTO best_policy = (new_policy ? new_policy : 407d6385b1cSHajimu UMEMOTO lookup_addrsel_policy(&ia_best->ia_addr)); 408d6385b1cSHajimu UMEMOTO best_matchlen = (new_matchlen >= 0 ? new_matchlen : 409d6385b1cSHajimu UMEMOTO in6_matchlen(&ia_best->ia_addr.sin6_addr, 410a1f7e5f8SHajimu UMEMOTO &dst)); 411d6385b1cSHajimu UMEMOTO 412d6385b1cSHajimu UMEMOTO next: 413d6385b1cSHajimu UMEMOTO continue; 414d6385b1cSHajimu UMEMOTO 415d6385b1cSHajimu UMEMOTO out: 416d6385b1cSHajimu UMEMOTO break; 417d6385b1cSHajimu UMEMOTO } 418d6385b1cSHajimu UMEMOTO 419d6385b1cSHajimu UMEMOTO if ((ia = ia_best) == NULL) { 420686cdd19SJun-ichiro itojun Hagino *errorp = EADDRNOTAVAIL; 421d6385b1cSHajimu UMEMOTO return (NULL); 422686cdd19SJun-ichiro itojun Hagino } 423686cdd19SJun-ichiro itojun Hagino 424a1f7e5f8SHajimu UMEMOTO if (ifpp) 425a1f7e5f8SHajimu UMEMOTO *ifpp = ifp; 426a1f7e5f8SHajimu UMEMOTO 427d6385b1cSHajimu UMEMOTO return (&ia->ia_addr.sin6_addr); 428d6385b1cSHajimu UMEMOTO } 429d6385b1cSHajimu UMEMOTO 4301272577eSXin LI /* 4311272577eSXin LI * clone - meaningful only for bsdi and freebsd 4321272577eSXin LI */ 433d6385b1cSHajimu UMEMOTO static int 4341272577eSXin LI selectroute(struct sockaddr_in6 *dstsock, struct ip6_pktopts *opts, 4351272577eSXin LI struct ip6_moptions *mopts, struct route_in6 *ro, 4361272577eSXin LI struct ifnet **retifp, struct rtentry **retrt, int clone, 4371272577eSXin LI int norouteok) 438d6385b1cSHajimu UMEMOTO { 439d6385b1cSHajimu UMEMOTO int error = 0; 440d6385b1cSHajimu UMEMOTO struct ifnet *ifp = NULL; 441d6385b1cSHajimu UMEMOTO struct rtentry *rt = NULL; 442d6385b1cSHajimu UMEMOTO struct sockaddr_in6 *sin6_next; 443d6385b1cSHajimu UMEMOTO struct in6_pktinfo *pi = NULL; 444d6385b1cSHajimu UMEMOTO struct in6_addr *dst = &dstsock->sin6_addr; 445d6385b1cSHajimu UMEMOTO #if 0 4461d54aa3bSBjoern A. Zeeb char ip6buf[INET6_ADDRSTRLEN]; 4471d54aa3bSBjoern A. Zeeb 448d6385b1cSHajimu UMEMOTO if (dstsock->sin6_addr.s6_addr32[0] == 0 && 449d6385b1cSHajimu UMEMOTO dstsock->sin6_addr.s6_addr32[1] == 0 && 450d6385b1cSHajimu UMEMOTO !IN6_IS_ADDR_LOOPBACK(&dstsock->sin6_addr)) { 451d6385b1cSHajimu UMEMOTO printf("in6_selectroute: strange destination %s\n", 4521d54aa3bSBjoern A. Zeeb ip6_sprintf(ip6buf, &dstsock->sin6_addr)); 453d6385b1cSHajimu UMEMOTO } else { 454d6385b1cSHajimu UMEMOTO printf("in6_selectroute: destination = %s%%%d\n", 4551d54aa3bSBjoern A. Zeeb ip6_sprintf(ip6buf, &dstsock->sin6_addr), 456d6385b1cSHajimu UMEMOTO dstsock->sin6_scope_id); /* for debug */ 457d6385b1cSHajimu UMEMOTO } 458d6385b1cSHajimu UMEMOTO #endif 459d6385b1cSHajimu UMEMOTO 460d6385b1cSHajimu UMEMOTO /* If the caller specify the outgoing interface explicitly, use it. */ 461d6385b1cSHajimu UMEMOTO if (opts && (pi = opts->ip6po_pktinfo) != NULL && pi->ipi6_ifindex) { 462d6385b1cSHajimu UMEMOTO /* XXX boundary check is assumed to be already done. */ 463d6385b1cSHajimu UMEMOTO ifp = ifnet_byindex(pi->ipi6_ifindex); 464d6385b1cSHajimu UMEMOTO if (ifp != NULL && 465a1f7e5f8SHajimu UMEMOTO (norouteok || retrt == NULL || 466a1f7e5f8SHajimu UMEMOTO IN6_IS_ADDR_MULTICAST(dst))) { 467d6385b1cSHajimu UMEMOTO /* 468cd0fdcf7SHajimu UMEMOTO * we do not have to check or get the route for 469d6385b1cSHajimu UMEMOTO * multicast. 470d6385b1cSHajimu UMEMOTO */ 471d6385b1cSHajimu UMEMOTO goto done; 472d6385b1cSHajimu UMEMOTO } else 473d6385b1cSHajimu UMEMOTO goto getroute; 474d6385b1cSHajimu UMEMOTO } 475d6385b1cSHajimu UMEMOTO 476d6385b1cSHajimu UMEMOTO /* 477d6385b1cSHajimu UMEMOTO * If the destination address is a multicast address and the outgoing 478d6385b1cSHajimu UMEMOTO * interface for the address is specified by the caller, use it. 479d6385b1cSHajimu UMEMOTO */ 480d6385b1cSHajimu UMEMOTO if (IN6_IS_ADDR_MULTICAST(dst) && 481d6385b1cSHajimu UMEMOTO mopts != NULL && (ifp = mopts->im6o_multicast_ifp) != NULL) { 482d6385b1cSHajimu UMEMOTO goto done; /* we do not need a route for multicast. */ 483d6385b1cSHajimu UMEMOTO } 484d6385b1cSHajimu UMEMOTO 485d6385b1cSHajimu UMEMOTO getroute: 486d6385b1cSHajimu UMEMOTO /* 487d6385b1cSHajimu UMEMOTO * If the next hop address for the packet is specified by the caller, 488d6385b1cSHajimu UMEMOTO * use it as the gateway. 489d6385b1cSHajimu UMEMOTO */ 490d6385b1cSHajimu UMEMOTO if (opts && opts->ip6po_nexthop) { 491d6385b1cSHajimu UMEMOTO struct route_in6 *ron; 492d6385b1cSHajimu UMEMOTO 493d6385b1cSHajimu UMEMOTO sin6_next = satosin6(opts->ip6po_nexthop); 494d6385b1cSHajimu UMEMOTO 495d6385b1cSHajimu UMEMOTO /* at this moment, we only support AF_INET6 next hops */ 496d6385b1cSHajimu UMEMOTO if (sin6_next->sin6_family != AF_INET6) { 497d6385b1cSHajimu UMEMOTO error = EAFNOSUPPORT; /* or should we proceed? */ 498d6385b1cSHajimu UMEMOTO goto done; 499d6385b1cSHajimu UMEMOTO } 500d6385b1cSHajimu UMEMOTO 501d6385b1cSHajimu UMEMOTO /* 502d6385b1cSHajimu UMEMOTO * If the next hop is an IPv6 address, then the node identified 503d6385b1cSHajimu UMEMOTO * by that address must be a neighbor of the sending host. 504d6385b1cSHajimu UMEMOTO */ 505d6385b1cSHajimu UMEMOTO ron = &opts->ip6po_nextroute; 506d6385b1cSHajimu UMEMOTO if ((ron->ro_rt && 507d6385b1cSHajimu UMEMOTO (ron->ro_rt->rt_flags & (RTF_UP | RTF_LLINFO)) != 508d6385b1cSHajimu UMEMOTO (RTF_UP | RTF_LLINFO)) || 509c1a049acSSUZUKI Shinsuke !IN6_ARE_ADDR_EQUAL(&satosin6(&ron->ro_dst)->sin6_addr, 510c1a049acSSUZUKI Shinsuke &sin6_next->sin6_addr)) { 511d6385b1cSHajimu UMEMOTO if (ron->ro_rt) { 512d6385b1cSHajimu UMEMOTO RTFREE(ron->ro_rt); 513d6385b1cSHajimu UMEMOTO ron->ro_rt = NULL; 514d6385b1cSHajimu UMEMOTO } 515d6385b1cSHajimu UMEMOTO *satosin6(&ron->ro_dst) = *sin6_next; 516d6385b1cSHajimu UMEMOTO } 517d6385b1cSHajimu UMEMOTO if (ron->ro_rt == NULL) { 518d6385b1cSHajimu UMEMOTO rtalloc((struct route *)ron); /* multi path case? */ 519d6385b1cSHajimu UMEMOTO if (ron->ro_rt == NULL || 520d6385b1cSHajimu UMEMOTO !(ron->ro_rt->rt_flags & RTF_LLINFO)) { 521d6385b1cSHajimu UMEMOTO if (ron->ro_rt) { 522d6385b1cSHajimu UMEMOTO RTFREE(ron->ro_rt); 523d6385b1cSHajimu UMEMOTO ron->ro_rt = NULL; 524d6385b1cSHajimu UMEMOTO } 525d6385b1cSHajimu UMEMOTO error = EHOSTUNREACH; 526d6385b1cSHajimu UMEMOTO goto done; 527d6385b1cSHajimu UMEMOTO } 528d6385b1cSHajimu UMEMOTO } 529d6385b1cSHajimu UMEMOTO rt = ron->ro_rt; 530d6385b1cSHajimu UMEMOTO ifp = rt->rt_ifp; 531d6385b1cSHajimu UMEMOTO 532d6385b1cSHajimu UMEMOTO /* 533d6385b1cSHajimu UMEMOTO * When cloning is required, try to allocate a route to the 534d6385b1cSHajimu UMEMOTO * destination so that the caller can store path MTU 535d6385b1cSHajimu UMEMOTO * information. 536d6385b1cSHajimu UMEMOTO */ 537d6385b1cSHajimu UMEMOTO if (!clone) 538d6385b1cSHajimu UMEMOTO goto done; 539d6385b1cSHajimu UMEMOTO } 540d6385b1cSHajimu UMEMOTO 541d6385b1cSHajimu UMEMOTO /* 542d6385b1cSHajimu UMEMOTO * Use a cached route if it exists and is valid, else try to allocate 543d6385b1cSHajimu UMEMOTO * a new one. Note that we should check the address family of the 544d6385b1cSHajimu UMEMOTO * cached destination, in case of sharing the cache with IPv4. 545686cdd19SJun-ichiro itojun Hagino */ 546686cdd19SJun-ichiro itojun Hagino if (ro) { 547686cdd19SJun-ichiro itojun Hagino if (ro->ro_rt && 54854c1b882SHajimu UMEMOTO (!(ro->ro_rt->rt_flags & RTF_UP) || 549d6385b1cSHajimu UMEMOTO ((struct sockaddr *)(&ro->ro_dst))->sa_family != AF_INET6 || 55054c1b882SHajimu UMEMOTO !IN6_ARE_ADDR_EQUAL(&satosin6(&ro->ro_dst)->sin6_addr, 55154c1b882SHajimu UMEMOTO dst))) { 552686cdd19SJun-ichiro itojun Hagino RTFREE(ro->ro_rt); 553d6385b1cSHajimu UMEMOTO ro->ro_rt = (struct rtentry *)NULL; 554686cdd19SJun-ichiro itojun Hagino } 555d6385b1cSHajimu UMEMOTO if (ro->ro_rt == (struct rtentry *)NULL) { 55633841545SHajimu UMEMOTO struct sockaddr_in6 *sa6; 55733841545SHajimu UMEMOTO 558686cdd19SJun-ichiro itojun Hagino /* No route yet, so try to acquire one */ 559686cdd19SJun-ichiro itojun Hagino bzero(&ro->ro_dst, sizeof(struct sockaddr_in6)); 56033841545SHajimu UMEMOTO sa6 = (struct sockaddr_in6 *)&ro->ro_dst; 561d6385b1cSHajimu UMEMOTO *sa6 = *dstsock; 562e6a27350SHajimu UMEMOTO sa6->sin6_scope_id = 0; 56397d8d152SAndre Oppermann 564d6385b1cSHajimu UMEMOTO if (clone) { 565d6385b1cSHajimu UMEMOTO rtalloc((struct route *)ro); 566d6385b1cSHajimu UMEMOTO } else { 567686cdd19SJun-ichiro itojun Hagino ro->ro_rt = rtalloc1(&((struct route *)ro) 568a89ec05eSPeter Wemm ->ro_dst, 0, 0UL); 56937bdc280SSam Leffler if (ro->ro_rt) 570d1dd20beSSam Leffler RT_UNLOCK(ro->ro_rt); 571686cdd19SJun-ichiro itojun Hagino } 572686cdd19SJun-ichiro itojun Hagino } 573686cdd19SJun-ichiro itojun Hagino 574686cdd19SJun-ichiro itojun Hagino /* 575d6385b1cSHajimu UMEMOTO * do not care about the result if we have the nexthop 576d6385b1cSHajimu UMEMOTO * explicitly specified. 577686cdd19SJun-ichiro itojun Hagino */ 578d6385b1cSHajimu UMEMOTO if (opts && opts->ip6po_nexthop) 579d6385b1cSHajimu UMEMOTO goto done; 580686cdd19SJun-ichiro itojun Hagino 581686cdd19SJun-ichiro itojun Hagino if (ro->ro_rt) { 582d6385b1cSHajimu UMEMOTO ifp = ro->ro_rt->rt_ifp; 583d6385b1cSHajimu UMEMOTO 584d6385b1cSHajimu UMEMOTO if (ifp == NULL) { /* can this really happen? */ 585d6385b1cSHajimu UMEMOTO RTFREE(ro->ro_rt); 586d6385b1cSHajimu UMEMOTO ro->ro_rt = NULL; 587686cdd19SJun-ichiro itojun Hagino } 588686cdd19SJun-ichiro itojun Hagino } 589d6385b1cSHajimu UMEMOTO if (ro->ro_rt == NULL) 590d6385b1cSHajimu UMEMOTO error = EHOSTUNREACH; 591d6385b1cSHajimu UMEMOTO rt = ro->ro_rt; 592d6385b1cSHajimu UMEMOTO 593d6385b1cSHajimu UMEMOTO /* 594d6385b1cSHajimu UMEMOTO * Check if the outgoing interface conflicts with 595d6385b1cSHajimu UMEMOTO * the interface specified by ipi6_ifindex (if specified). 596d6385b1cSHajimu UMEMOTO * Note that loopback interface is always okay. 597d6385b1cSHajimu UMEMOTO * (this may happen when we are sending a packet to one of 598d6385b1cSHajimu UMEMOTO * our own addresses.) 599d6385b1cSHajimu UMEMOTO */ 600403cbcf5SGeorge V. Neville-Neil if (ifp && opts && opts->ip6po_pktinfo && 60168efda09SHajimu UMEMOTO opts->ip6po_pktinfo->ipi6_ifindex) { 602d6385b1cSHajimu UMEMOTO if (!(ifp->if_flags & IFF_LOOPBACK) && 603d6385b1cSHajimu UMEMOTO ifp->if_index != 604d6385b1cSHajimu UMEMOTO opts->ip6po_pktinfo->ipi6_ifindex) { 605d6385b1cSHajimu UMEMOTO error = EHOSTUNREACH; 606d6385b1cSHajimu UMEMOTO goto done; 607d6385b1cSHajimu UMEMOTO } 608d6385b1cSHajimu UMEMOTO } 609686cdd19SJun-ichiro itojun Hagino } 610686cdd19SJun-ichiro itojun Hagino 611d6385b1cSHajimu UMEMOTO done: 612d6385b1cSHajimu UMEMOTO if (ifp == NULL && rt == NULL) { 613d6385b1cSHajimu UMEMOTO /* 614d6385b1cSHajimu UMEMOTO * This can happen if the caller did not pass a cached route 615d6385b1cSHajimu UMEMOTO * nor any other hints. We treat this case an error. 616d6385b1cSHajimu UMEMOTO */ 617d6385b1cSHajimu UMEMOTO error = EHOSTUNREACH; 618d6385b1cSHajimu UMEMOTO } 619d6385b1cSHajimu UMEMOTO if (error == EHOSTUNREACH) 620d6385b1cSHajimu UMEMOTO ip6stat.ip6s_noroute++; 621d6385b1cSHajimu UMEMOTO 622d6385b1cSHajimu UMEMOTO if (retifp != NULL) 623d6385b1cSHajimu UMEMOTO *retifp = ifp; 624d6385b1cSHajimu UMEMOTO if (retrt != NULL) 625d6385b1cSHajimu UMEMOTO *retrt = rt; /* rt may be NULL */ 626d6385b1cSHajimu UMEMOTO 627d6385b1cSHajimu UMEMOTO return (error); 628686cdd19SJun-ichiro itojun Hagino } 629686cdd19SJun-ichiro itojun Hagino 630a1f7e5f8SHajimu UMEMOTO static int 6311272577eSXin LI in6_selectif(struct sockaddr_in6 *dstsock, struct ip6_pktopts *opts, 6321272577eSXin LI struct ip6_moptions *mopts, struct route_in6 *ro, struct ifnet **retifp) 633a1f7e5f8SHajimu UMEMOTO { 634a1f7e5f8SHajimu UMEMOTO int error; 635a1f7e5f8SHajimu UMEMOTO struct route_in6 sro; 636a1f7e5f8SHajimu UMEMOTO struct rtentry *rt = NULL; 637a1f7e5f8SHajimu UMEMOTO 638a1f7e5f8SHajimu UMEMOTO if (ro == NULL) { 639a1f7e5f8SHajimu UMEMOTO bzero(&sro, sizeof(sro)); 640a1f7e5f8SHajimu UMEMOTO ro = &sro; 641a1f7e5f8SHajimu UMEMOTO } 642a1f7e5f8SHajimu UMEMOTO 643a1f7e5f8SHajimu UMEMOTO if ((error = selectroute(dstsock, opts, mopts, ro, retifp, 644a1f7e5f8SHajimu UMEMOTO &rt, 0, 1)) != 0) { 645f8366b03SSeigo Tanimura if (ro == &sro && rt && rt == sro.ro_rt) 646a1f7e5f8SHajimu UMEMOTO RTFREE(rt); 647a1f7e5f8SHajimu UMEMOTO return (error); 648a1f7e5f8SHajimu UMEMOTO } 649a1f7e5f8SHajimu UMEMOTO 650a1f7e5f8SHajimu UMEMOTO /* 651a1f7e5f8SHajimu UMEMOTO * do not use a rejected or black hole route. 652a1f7e5f8SHajimu UMEMOTO * XXX: this check should be done in the L2 output routine. 653a1f7e5f8SHajimu UMEMOTO * However, if we skipped this check here, we'd see the following 654a1f7e5f8SHajimu UMEMOTO * scenario: 655a1f7e5f8SHajimu UMEMOTO * - install a rejected route for a scoped address prefix 656a1f7e5f8SHajimu UMEMOTO * (like fe80::/10) 657a1f7e5f8SHajimu UMEMOTO * - send a packet to a destination that matches the scoped prefix, 658a1f7e5f8SHajimu UMEMOTO * with ambiguity about the scope zone. 659a1f7e5f8SHajimu UMEMOTO * - pick the outgoing interface from the route, and disambiguate the 660a1f7e5f8SHajimu UMEMOTO * scope zone with the interface. 661a1f7e5f8SHajimu UMEMOTO * - ip6_output() would try to get another route with the "new" 662a1f7e5f8SHajimu UMEMOTO * destination, which may be valid. 663a1f7e5f8SHajimu UMEMOTO * - we'd see no error on output. 664a1f7e5f8SHajimu UMEMOTO * Although this may not be very harmful, it should still be confusing. 665a1f7e5f8SHajimu UMEMOTO * We thus reject the case here. 666a1f7e5f8SHajimu UMEMOTO */ 667a1f7e5f8SHajimu UMEMOTO if (rt && (rt->rt_flags & (RTF_REJECT | RTF_BLACKHOLE))) { 668a1f7e5f8SHajimu UMEMOTO int flags = (rt->rt_flags & RTF_HOST ? EHOSTUNREACH : ENETUNREACH); 669a1f7e5f8SHajimu UMEMOTO 670f8366b03SSeigo Tanimura if (ro == &sro && rt && rt == sro.ro_rt) 671a1f7e5f8SHajimu UMEMOTO RTFREE(rt); 672a1f7e5f8SHajimu UMEMOTO return (flags); 673a1f7e5f8SHajimu UMEMOTO } 674a1f7e5f8SHajimu UMEMOTO 675a1f7e5f8SHajimu UMEMOTO /* 676a1f7e5f8SHajimu UMEMOTO * Adjust the "outgoing" interface. If we're going to loop the packet 677a1f7e5f8SHajimu UMEMOTO * back to ourselves, the ifp would be the loopback interface. 678a1f7e5f8SHajimu UMEMOTO * However, we'd rather know the interface associated to the 679a1f7e5f8SHajimu UMEMOTO * destination address (which should probably be one of our own 680a1f7e5f8SHajimu UMEMOTO * addresses.) 681a1f7e5f8SHajimu UMEMOTO */ 682a1f7e5f8SHajimu UMEMOTO if (rt && rt->rt_ifa && rt->rt_ifa->ifa_ifp) 683a1f7e5f8SHajimu UMEMOTO *retifp = rt->rt_ifa->ifa_ifp; 684a1f7e5f8SHajimu UMEMOTO 685f8366b03SSeigo Tanimura if (ro == &sro && rt && rt == sro.ro_rt) 686a1f7e5f8SHajimu UMEMOTO RTFREE(rt); 687a1f7e5f8SHajimu UMEMOTO return (0); 688a1f7e5f8SHajimu UMEMOTO } 689a1f7e5f8SHajimu UMEMOTO 6901272577eSXin LI /* 6911272577eSXin LI * clone - meaningful only for bsdi and freebsd 6921272577eSXin LI */ 693a1f7e5f8SHajimu UMEMOTO int 6941272577eSXin LI in6_selectroute(struct sockaddr_in6 *dstsock, struct ip6_pktopts *opts, 6951272577eSXin LI struct ip6_moptions *mopts, struct route_in6 *ro, 6961272577eSXin LI struct ifnet **retifp, struct rtentry **retrt, int clone) 697a1f7e5f8SHajimu UMEMOTO { 6981272577eSXin LI 699a1f7e5f8SHajimu UMEMOTO return (selectroute(dstsock, opts, mopts, ro, retifp, 700a1f7e5f8SHajimu UMEMOTO retrt, clone, 0)); 701a1f7e5f8SHajimu UMEMOTO } 702a1f7e5f8SHajimu UMEMOTO 703686cdd19SJun-ichiro itojun Hagino /* 704686cdd19SJun-ichiro itojun Hagino * Default hop limit selection. The precedence is as follows: 705686cdd19SJun-ichiro itojun Hagino * 1. Hoplimit value specified via ioctl. 706686cdd19SJun-ichiro itojun Hagino * 2. (If the outgoing interface is detected) the current 707686cdd19SJun-ichiro itojun Hagino * hop limit of the interface specified by router advertisement. 708686cdd19SJun-ichiro itojun Hagino * 3. The system default hoplimit. 709686cdd19SJun-ichiro itojun Hagino */ 710686cdd19SJun-ichiro itojun Hagino int 7111272577eSXin LI in6_selecthlim(struct in6pcb *in6p, struct ifnet *ifp) 712686cdd19SJun-ichiro itojun Hagino { 7131272577eSXin LI 714686cdd19SJun-ichiro itojun Hagino if (in6p && in6p->in6p_hops >= 0) 715686cdd19SJun-ichiro itojun Hagino return (in6p->in6p_hops); 716686cdd19SJun-ichiro itojun Hagino else if (ifp) 71731b1bfe1SHajimu UMEMOTO return (ND_IFINFO(ifp)->chlim); 71897d8d152SAndre Oppermann else if (in6p && !IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_faddr)) { 71997d8d152SAndre Oppermann struct route_in6 ro6; 72097d8d152SAndre Oppermann struct ifnet *lifp; 72197d8d152SAndre Oppermann 72297d8d152SAndre Oppermann bzero(&ro6, sizeof(ro6)); 72397d8d152SAndre Oppermann ro6.ro_dst.sin6_family = AF_INET6; 72497d8d152SAndre Oppermann ro6.ro_dst.sin6_len = sizeof(struct sockaddr_in6); 72597d8d152SAndre Oppermann ro6.ro_dst.sin6_addr = in6p->in6p_faddr; 72697d8d152SAndre Oppermann rtalloc((struct route *)&ro6); 72797d8d152SAndre Oppermann if (ro6.ro_rt) { 72897d8d152SAndre Oppermann lifp = ro6.ro_rt->rt_ifp; 72997d8d152SAndre Oppermann RTFREE(ro6.ro_rt); 73097d8d152SAndre Oppermann if (lifp) 73197d8d152SAndre Oppermann return (ND_IFINFO(lifp)->chlim); 73297d8d152SAndre Oppermann } else 73397d8d152SAndre Oppermann return (ip6_defhlim); 73497d8d152SAndre Oppermann } 735686cdd19SJun-ichiro itojun Hagino return (ip6_defhlim); 736686cdd19SJun-ichiro itojun Hagino } 737686cdd19SJun-ichiro itojun Hagino 738686cdd19SJun-ichiro itojun Hagino /* 739686cdd19SJun-ichiro itojun Hagino * XXX: this is borrowed from in6_pcbbind(). If possible, we should 740686cdd19SJun-ichiro itojun Hagino * share this function by all *bsd*... 741686cdd19SJun-ichiro itojun Hagino */ 742686cdd19SJun-ichiro itojun Hagino int 7431272577eSXin LI in6_pcbsetport(struct in6_addr *laddr, struct inpcb *inp, struct ucred *cred) 744686cdd19SJun-ichiro itojun Hagino { 745686cdd19SJun-ichiro itojun Hagino struct socket *so = inp->inp_socket; 746686cdd19SJun-ichiro itojun Hagino u_int16_t lport = 0, first, last, *lastport; 747686cdd19SJun-ichiro itojun Hagino int count, error = 0, wild = 0; 748686cdd19SJun-ichiro itojun Hagino struct inpcbinfo *pcbinfo = inp->inp_pcbinfo; 749686cdd19SJun-ichiro itojun Hagino 7508deea4a8SRobert Watson INP_INFO_WLOCK_ASSERT(pcbinfo); 7518deea4a8SRobert Watson INP_LOCK_ASSERT(inp); 7528deea4a8SRobert Watson 753686cdd19SJun-ichiro itojun Hagino /* XXX: this is redundant when called from in6_pcbbind */ 754686cdd19SJun-ichiro itojun Hagino if ((so->so_options & (SO_REUSEADDR|SO_REUSEPORT)) == 0) 755686cdd19SJun-ichiro itojun Hagino wild = INPLOOKUP_WILDCARD; 756686cdd19SJun-ichiro itojun Hagino 757686cdd19SJun-ichiro itojun Hagino inp->inp_flags |= INP_ANONPORT; 758686cdd19SJun-ichiro itojun Hagino 759686cdd19SJun-ichiro itojun Hagino if (inp->inp_flags & INP_HIGHPORT) { 760686cdd19SJun-ichiro itojun Hagino first = ipport_hifirstauto; /* sysctl */ 761686cdd19SJun-ichiro itojun Hagino last = ipport_hilastauto; 762712fc218SRobert Watson lastport = &pcbinfo->ipi_lasthi; 763686cdd19SJun-ichiro itojun Hagino } else if (inp->inp_flags & INP_LOWPORT) { 76432f9753cSRobert Watson error = priv_check_cred(cred, PRIV_NETINET_RESERVEDPORT, 0); 765acd3428bSRobert Watson if (error) 766686cdd19SJun-ichiro itojun Hagino return error; 767686cdd19SJun-ichiro itojun Hagino first = ipport_lowfirstauto; /* 1023 */ 768686cdd19SJun-ichiro itojun Hagino last = ipport_lowlastauto; /* 600 */ 769712fc218SRobert Watson lastport = &pcbinfo->ipi_lastlow; 770686cdd19SJun-ichiro itojun Hagino } else { 771686cdd19SJun-ichiro itojun Hagino first = ipport_firstauto; /* sysctl */ 772686cdd19SJun-ichiro itojun Hagino last = ipport_lastauto; 773712fc218SRobert Watson lastport = &pcbinfo->ipi_lastport; 774686cdd19SJun-ichiro itojun Hagino } 775686cdd19SJun-ichiro itojun Hagino /* 776686cdd19SJun-ichiro itojun Hagino * Simple check to ensure all ports are not used up causing 777686cdd19SJun-ichiro itojun Hagino * a deadlock here. 778686cdd19SJun-ichiro itojun Hagino * 779686cdd19SJun-ichiro itojun Hagino * We split the two cases (up and down) so that the direction 780686cdd19SJun-ichiro itojun Hagino * is not being tested on each round of the loop. 781686cdd19SJun-ichiro itojun Hagino */ 782686cdd19SJun-ichiro itojun Hagino if (first > last) { 783686cdd19SJun-ichiro itojun Hagino /* 784686cdd19SJun-ichiro itojun Hagino * counting down 785686cdd19SJun-ichiro itojun Hagino */ 786686cdd19SJun-ichiro itojun Hagino count = first - last; 787686cdd19SJun-ichiro itojun Hagino 788686cdd19SJun-ichiro itojun Hagino do { 789686cdd19SJun-ichiro itojun Hagino if (count-- < 0) { /* completely used? */ 790686cdd19SJun-ichiro itojun Hagino /* 791686cdd19SJun-ichiro itojun Hagino * Undo any address bind that may have 792686cdd19SJun-ichiro itojun Hagino * occurred above. 793686cdd19SJun-ichiro itojun Hagino */ 794686cdd19SJun-ichiro itojun Hagino inp->in6p_laddr = in6addr_any; 795686cdd19SJun-ichiro itojun Hagino return (EAGAIN); 796686cdd19SJun-ichiro itojun Hagino } 797686cdd19SJun-ichiro itojun Hagino --*lastport; 798686cdd19SJun-ichiro itojun Hagino if (*lastport > first || *lastport < last) 799686cdd19SJun-ichiro itojun Hagino *lastport = first; 800686cdd19SJun-ichiro itojun Hagino lport = htons(*lastport); 80168efda09SHajimu UMEMOTO } while (in6_pcblookup_local(pcbinfo, &inp->in6p_laddr, 80268efda09SHajimu UMEMOTO lport, wild)); 803686cdd19SJun-ichiro itojun Hagino } else { 804686cdd19SJun-ichiro itojun Hagino /* 805686cdd19SJun-ichiro itojun Hagino * counting up 806686cdd19SJun-ichiro itojun Hagino */ 807686cdd19SJun-ichiro itojun Hagino count = last - first; 808686cdd19SJun-ichiro itojun Hagino 809686cdd19SJun-ichiro itojun Hagino do { 810686cdd19SJun-ichiro itojun Hagino if (count-- < 0) { /* completely used? */ 811686cdd19SJun-ichiro itojun Hagino /* 812686cdd19SJun-ichiro itojun Hagino * Undo any address bind that may have 813686cdd19SJun-ichiro itojun Hagino * occurred above. 814686cdd19SJun-ichiro itojun Hagino */ 815686cdd19SJun-ichiro itojun Hagino inp->in6p_laddr = in6addr_any; 816686cdd19SJun-ichiro itojun Hagino return (EAGAIN); 817686cdd19SJun-ichiro itojun Hagino } 818686cdd19SJun-ichiro itojun Hagino ++*lastport; 819686cdd19SJun-ichiro itojun Hagino if (*lastport < first || *lastport > last) 820686cdd19SJun-ichiro itojun Hagino *lastport = first; 821686cdd19SJun-ichiro itojun Hagino lport = htons(*lastport); 822686cdd19SJun-ichiro itojun Hagino } while (in6_pcblookup_local(pcbinfo, 823686cdd19SJun-ichiro itojun Hagino &inp->in6p_laddr, lport, wild)); 824686cdd19SJun-ichiro itojun Hagino } 825686cdd19SJun-ichiro itojun Hagino 826686cdd19SJun-ichiro itojun Hagino inp->inp_lport = lport; 827686cdd19SJun-ichiro itojun Hagino if (in_pcbinshash(inp) != 0) { 828686cdd19SJun-ichiro itojun Hagino inp->in6p_laddr = in6addr_any; 829686cdd19SJun-ichiro itojun Hagino inp->inp_lport = 0; 830686cdd19SJun-ichiro itojun Hagino return (EAGAIN); 831686cdd19SJun-ichiro itojun Hagino } 832686cdd19SJun-ichiro itojun Hagino 833686cdd19SJun-ichiro itojun Hagino return (0); 834686cdd19SJun-ichiro itojun Hagino } 835686cdd19SJun-ichiro itojun Hagino 8367fc91b3fSHajimu UMEMOTO void 8371272577eSXin LI addrsel_policy_init(void) 8387fc91b3fSHajimu UMEMOTO { 8397fc91b3fSHajimu UMEMOTO ADDRSEL_LOCK_INIT(); 8405d525653SHajimu UMEMOTO ADDRSEL_SXLOCK_INIT(); 8417fc91b3fSHajimu UMEMOTO 8427fc91b3fSHajimu UMEMOTO init_policy_queue(); 8437fc91b3fSHajimu UMEMOTO 8447fc91b3fSHajimu UMEMOTO /* initialize the "last resort" policy */ 8457fc91b3fSHajimu UMEMOTO bzero(&defaultaddrpolicy, sizeof(defaultaddrpolicy)); 8467fc91b3fSHajimu UMEMOTO defaultaddrpolicy.label = ADDR_LABEL_NOTAPP; 8477fc91b3fSHajimu UMEMOTO } 8487fc91b3fSHajimu UMEMOTO 849d6385b1cSHajimu UMEMOTO static struct in6_addrpolicy * 8501272577eSXin LI lookup_addrsel_policy(struct sockaddr_in6 *key) 851d6385b1cSHajimu UMEMOTO { 852d6385b1cSHajimu UMEMOTO struct in6_addrpolicy *match = NULL; 853d6385b1cSHajimu UMEMOTO 854d6385b1cSHajimu UMEMOTO ADDRSEL_LOCK(); 855d6385b1cSHajimu UMEMOTO match = match_addrsel_policy(key); 856d6385b1cSHajimu UMEMOTO 857d6385b1cSHajimu UMEMOTO if (match == NULL) 858d6385b1cSHajimu UMEMOTO match = &defaultaddrpolicy; 859d6385b1cSHajimu UMEMOTO else 860d6385b1cSHajimu UMEMOTO match->use++; 861d6385b1cSHajimu UMEMOTO ADDRSEL_UNLOCK(); 862d6385b1cSHajimu UMEMOTO 863d6385b1cSHajimu UMEMOTO return (match); 864d6385b1cSHajimu UMEMOTO } 865d6385b1cSHajimu UMEMOTO 8667fc91b3fSHajimu UMEMOTO /* 8677fc91b3fSHajimu UMEMOTO * Subroutines to manage the address selection policy table via sysctl. 8687fc91b3fSHajimu UMEMOTO */ 8697fc91b3fSHajimu UMEMOTO struct walkarg { 8707fc91b3fSHajimu UMEMOTO struct sysctl_req *w_req; 8717fc91b3fSHajimu UMEMOTO }; 8727fc91b3fSHajimu UMEMOTO 8737fc91b3fSHajimu UMEMOTO static int in6_src_sysctl(SYSCTL_HANDLER_ARGS); 8747fc91b3fSHajimu UMEMOTO SYSCTL_DECL(_net_inet6_ip6); 8757fc91b3fSHajimu UMEMOTO SYSCTL_NODE(_net_inet6_ip6, IPV6CTL_ADDRCTLPOLICY, addrctlpolicy, 8767fc91b3fSHajimu UMEMOTO CTLFLAG_RD, in6_src_sysctl, ""); 8777fc91b3fSHajimu UMEMOTO 8787fc91b3fSHajimu UMEMOTO static int 8797fc91b3fSHajimu UMEMOTO in6_src_sysctl(SYSCTL_HANDLER_ARGS) 8807fc91b3fSHajimu UMEMOTO { 8817fc91b3fSHajimu UMEMOTO struct walkarg w; 8827fc91b3fSHajimu UMEMOTO 8837fc91b3fSHajimu UMEMOTO if (req->newptr) 8847fc91b3fSHajimu UMEMOTO return EPERM; 8857fc91b3fSHajimu UMEMOTO 8867fc91b3fSHajimu UMEMOTO bzero(&w, sizeof(w)); 8877fc91b3fSHajimu UMEMOTO w.w_req = req; 8887fc91b3fSHajimu UMEMOTO 8897fc91b3fSHajimu UMEMOTO return (walk_addrsel_policy(dump_addrsel_policyent, &w)); 8907fc91b3fSHajimu UMEMOTO } 8917fc91b3fSHajimu UMEMOTO 8927fc91b3fSHajimu UMEMOTO int 8931272577eSXin LI in6_src_ioctl(u_long cmd, caddr_t data) 8947fc91b3fSHajimu UMEMOTO { 8957fc91b3fSHajimu UMEMOTO int i; 8967fc91b3fSHajimu UMEMOTO struct in6_addrpolicy ent0; 8977fc91b3fSHajimu UMEMOTO 8987fc91b3fSHajimu UMEMOTO if (cmd != SIOCAADDRCTL_POLICY && cmd != SIOCDADDRCTL_POLICY) 8997fc91b3fSHajimu UMEMOTO return (EOPNOTSUPP); /* check for safety */ 9007fc91b3fSHajimu UMEMOTO 9017fc91b3fSHajimu UMEMOTO ent0 = *(struct in6_addrpolicy *)data; 9027fc91b3fSHajimu UMEMOTO 9037fc91b3fSHajimu UMEMOTO if (ent0.label == ADDR_LABEL_NOTAPP) 9047fc91b3fSHajimu UMEMOTO return (EINVAL); 9057fc91b3fSHajimu UMEMOTO /* check if the prefix mask is consecutive. */ 9067fc91b3fSHajimu UMEMOTO if (in6_mask2len(&ent0.addrmask.sin6_addr, NULL) < 0) 9077fc91b3fSHajimu UMEMOTO return (EINVAL); 9087fc91b3fSHajimu UMEMOTO /* clear trailing garbages (if any) of the prefix address. */ 9097fc91b3fSHajimu UMEMOTO for (i = 0; i < 4; i++) { 9107fc91b3fSHajimu UMEMOTO ent0.addr.sin6_addr.s6_addr32[i] &= 9117fc91b3fSHajimu UMEMOTO ent0.addrmask.sin6_addr.s6_addr32[i]; 9127fc91b3fSHajimu UMEMOTO } 9137fc91b3fSHajimu UMEMOTO ent0.use = 0; 9147fc91b3fSHajimu UMEMOTO 9157fc91b3fSHajimu UMEMOTO switch (cmd) { 9167fc91b3fSHajimu UMEMOTO case SIOCAADDRCTL_POLICY: 9177fc91b3fSHajimu UMEMOTO return (add_addrsel_policyent(&ent0)); 9187fc91b3fSHajimu UMEMOTO case SIOCDADDRCTL_POLICY: 9197fc91b3fSHajimu UMEMOTO return (delete_addrsel_policyent(&ent0)); 9207fc91b3fSHajimu UMEMOTO } 9217fc91b3fSHajimu UMEMOTO 9227fc91b3fSHajimu UMEMOTO return (0); /* XXX: compromise compilers */ 9237fc91b3fSHajimu UMEMOTO } 9247fc91b3fSHajimu UMEMOTO 9257fc91b3fSHajimu UMEMOTO /* 9267fc91b3fSHajimu UMEMOTO * The followings are implementation of the policy table using a 9277fc91b3fSHajimu UMEMOTO * simple tail queue. 9287fc91b3fSHajimu UMEMOTO * XXX such details should be hidden. 9297fc91b3fSHajimu UMEMOTO * XXX implementation using binary tree should be more efficient. 9307fc91b3fSHajimu UMEMOTO */ 9317fc91b3fSHajimu UMEMOTO struct addrsel_policyent { 9327fc91b3fSHajimu UMEMOTO TAILQ_ENTRY(addrsel_policyent) ape_entry; 9337fc91b3fSHajimu UMEMOTO struct in6_addrpolicy ape_policy; 9347fc91b3fSHajimu UMEMOTO }; 9357fc91b3fSHajimu UMEMOTO 9367fc91b3fSHajimu UMEMOTO TAILQ_HEAD(addrsel_policyhead, addrsel_policyent); 9377fc91b3fSHajimu UMEMOTO 9387fc91b3fSHajimu UMEMOTO struct addrsel_policyhead addrsel_policytab; 9397fc91b3fSHajimu UMEMOTO 9407fc91b3fSHajimu UMEMOTO static void 9411272577eSXin LI init_policy_queue(void) 9427fc91b3fSHajimu UMEMOTO { 9431272577eSXin LI 9447fc91b3fSHajimu UMEMOTO TAILQ_INIT(&addrsel_policytab); 9457fc91b3fSHajimu UMEMOTO } 9467fc91b3fSHajimu UMEMOTO 9477fc91b3fSHajimu UMEMOTO static int 9481272577eSXin LI add_addrsel_policyent(struct in6_addrpolicy *newpolicy) 9497fc91b3fSHajimu UMEMOTO { 9507fc91b3fSHajimu UMEMOTO struct addrsel_policyent *new, *pol; 9517fc91b3fSHajimu UMEMOTO 952349b668aSHajimu UMEMOTO MALLOC(new, struct addrsel_policyent *, sizeof(*new), M_IFADDR, 953349b668aSHajimu UMEMOTO M_WAITOK); 9545d525653SHajimu UMEMOTO ADDRSEL_XLOCK(); 9557fc91b3fSHajimu UMEMOTO ADDRSEL_LOCK(); 9567fc91b3fSHajimu UMEMOTO 9577fc91b3fSHajimu UMEMOTO /* duplication check */ 9585d525653SHajimu UMEMOTO TAILQ_FOREACH(pol, &addrsel_policytab, ape_entry) { 959c1a049acSSUZUKI Shinsuke if (IN6_ARE_ADDR_EQUAL(&newpolicy->addr.sin6_addr, 960c1a049acSSUZUKI Shinsuke &pol->ape_policy.addr.sin6_addr) && 961c1a049acSSUZUKI Shinsuke IN6_ARE_ADDR_EQUAL(&newpolicy->addrmask.sin6_addr, 962c1a049acSSUZUKI Shinsuke &pol->ape_policy.addrmask.sin6_addr)) { 963349b668aSHajimu UMEMOTO ADDRSEL_UNLOCK(); 9645d525653SHajimu UMEMOTO ADDRSEL_XUNLOCK(); 965349b668aSHajimu UMEMOTO FREE(new, M_IFADDR); 9667fc91b3fSHajimu UMEMOTO return (EEXIST); /* or override it? */ 9677fc91b3fSHajimu UMEMOTO } 9687fc91b3fSHajimu UMEMOTO } 9697fc91b3fSHajimu UMEMOTO 9707fc91b3fSHajimu UMEMOTO bzero(new, sizeof(*new)); 9717fc91b3fSHajimu UMEMOTO 9727fc91b3fSHajimu UMEMOTO /* XXX: should validate entry */ 9737fc91b3fSHajimu UMEMOTO new->ape_policy = *newpolicy; 9747fc91b3fSHajimu UMEMOTO 9757fc91b3fSHajimu UMEMOTO TAILQ_INSERT_TAIL(&addrsel_policytab, new, ape_entry); 9767fc91b3fSHajimu UMEMOTO ADDRSEL_UNLOCK(); 9775d525653SHajimu UMEMOTO ADDRSEL_XUNLOCK(); 9787fc91b3fSHajimu UMEMOTO 9797fc91b3fSHajimu UMEMOTO return (0); 9807fc91b3fSHajimu UMEMOTO } 9817fc91b3fSHajimu UMEMOTO 9827fc91b3fSHajimu UMEMOTO static int 9831272577eSXin LI delete_addrsel_policyent(struct in6_addrpolicy *key) 9847fc91b3fSHajimu UMEMOTO { 9857fc91b3fSHajimu UMEMOTO struct addrsel_policyent *pol; 9867fc91b3fSHajimu UMEMOTO 9875d525653SHajimu UMEMOTO ADDRSEL_XLOCK(); 9887fc91b3fSHajimu UMEMOTO ADDRSEL_LOCK(); 9897fc91b3fSHajimu UMEMOTO 9907fc91b3fSHajimu UMEMOTO /* search for the entry in the table */ 9915d525653SHajimu UMEMOTO TAILQ_FOREACH(pol, &addrsel_policytab, ape_entry) { 992c1a049acSSUZUKI Shinsuke if (IN6_ARE_ADDR_EQUAL(&key->addr.sin6_addr, 993c1a049acSSUZUKI Shinsuke &pol->ape_policy.addr.sin6_addr) && 994c1a049acSSUZUKI Shinsuke IN6_ARE_ADDR_EQUAL(&key->addrmask.sin6_addr, 995c1a049acSSUZUKI Shinsuke &pol->ape_policy.addrmask.sin6_addr)) { 9967fc91b3fSHajimu UMEMOTO break; 9977fc91b3fSHajimu UMEMOTO } 9987fc91b3fSHajimu UMEMOTO } 999349b668aSHajimu UMEMOTO if (pol == NULL) { 1000349b668aSHajimu UMEMOTO ADDRSEL_UNLOCK(); 10015d525653SHajimu UMEMOTO ADDRSEL_XUNLOCK(); 10027fc91b3fSHajimu UMEMOTO return (ESRCH); 1003349b668aSHajimu UMEMOTO } 10047fc91b3fSHajimu UMEMOTO 10057fc91b3fSHajimu UMEMOTO TAILQ_REMOVE(&addrsel_policytab, pol, ape_entry); 10067fc91b3fSHajimu UMEMOTO ADDRSEL_UNLOCK(); 10075d525653SHajimu UMEMOTO ADDRSEL_XUNLOCK(); 10087fc91b3fSHajimu UMEMOTO 10097fc91b3fSHajimu UMEMOTO return (0); 10107fc91b3fSHajimu UMEMOTO } 10117fc91b3fSHajimu UMEMOTO 10127fc91b3fSHajimu UMEMOTO static int 10131272577eSXin LI walk_addrsel_policy(int (*callback) __P((struct in6_addrpolicy *, void *)), 10141272577eSXin LI void *w) 10157fc91b3fSHajimu UMEMOTO { 10167fc91b3fSHajimu UMEMOTO struct addrsel_policyent *pol; 10177fc91b3fSHajimu UMEMOTO int error = 0; 10187fc91b3fSHajimu UMEMOTO 10195d525653SHajimu UMEMOTO ADDRSEL_SLOCK(); 10205d525653SHajimu UMEMOTO TAILQ_FOREACH(pol, &addrsel_policytab, ape_entry) { 10215d525653SHajimu UMEMOTO if ((error = (*callback)(&pol->ape_policy, w)) != 0) { 10225d525653SHajimu UMEMOTO ADDRSEL_SUNLOCK(); 10237fc91b3fSHajimu UMEMOTO return (error); 1024349b668aSHajimu UMEMOTO } 10255d525653SHajimu UMEMOTO } 10265d525653SHajimu UMEMOTO ADDRSEL_SUNLOCK(); 10277fc91b3fSHajimu UMEMOTO return (error); 10287fc91b3fSHajimu UMEMOTO } 10297fc91b3fSHajimu UMEMOTO 10307fc91b3fSHajimu UMEMOTO static int 10311272577eSXin LI dump_addrsel_policyent(struct in6_addrpolicy *pol, void *arg) 10327fc91b3fSHajimu UMEMOTO { 10337fc91b3fSHajimu UMEMOTO int error = 0; 10347fc91b3fSHajimu UMEMOTO struct walkarg *w = arg; 10357fc91b3fSHajimu UMEMOTO 10367fc91b3fSHajimu UMEMOTO error = SYSCTL_OUT(w->w_req, pol, sizeof(*pol)); 10377fc91b3fSHajimu UMEMOTO 10387fc91b3fSHajimu UMEMOTO return (error); 10397fc91b3fSHajimu UMEMOTO } 1040d6385b1cSHajimu UMEMOTO 1041d6385b1cSHajimu UMEMOTO static struct in6_addrpolicy * 10421272577eSXin LI match_addrsel_policy(struct sockaddr_in6 *key) 1043d6385b1cSHajimu UMEMOTO { 1044d6385b1cSHajimu UMEMOTO struct addrsel_policyent *pent; 1045d6385b1cSHajimu UMEMOTO struct in6_addrpolicy *bestpol = NULL, *pol; 1046d6385b1cSHajimu UMEMOTO int matchlen, bestmatchlen = -1; 1047d6385b1cSHajimu UMEMOTO u_char *mp, *ep, *k, *p, m; 1048d6385b1cSHajimu UMEMOTO 10495d525653SHajimu UMEMOTO TAILQ_FOREACH(pent, &addrsel_policytab, ape_entry) { 1050d6385b1cSHajimu UMEMOTO matchlen = 0; 1051d6385b1cSHajimu UMEMOTO 1052d6385b1cSHajimu UMEMOTO pol = &pent->ape_policy; 1053d6385b1cSHajimu UMEMOTO mp = (u_char *)&pol->addrmask.sin6_addr; 1054d6385b1cSHajimu UMEMOTO ep = mp + 16; /* XXX: scope field? */ 1055d6385b1cSHajimu UMEMOTO k = (u_char *)&key->sin6_addr; 1056d6385b1cSHajimu UMEMOTO p = (u_char *)&pol->addr.sin6_addr; 1057d6385b1cSHajimu UMEMOTO for (; mp < ep && *mp; mp++, k++, p++) { 1058d6385b1cSHajimu UMEMOTO m = *mp; 1059d6385b1cSHajimu UMEMOTO if ((*k & m) != *p) 1060d6385b1cSHajimu UMEMOTO goto next; /* not match */ 1061d6385b1cSHajimu UMEMOTO if (m == 0xff) /* short cut for a typical case */ 1062d6385b1cSHajimu UMEMOTO matchlen += 8; 1063d6385b1cSHajimu UMEMOTO else { 1064d6385b1cSHajimu UMEMOTO while (m >= 0x80) { 1065d6385b1cSHajimu UMEMOTO matchlen++; 1066d6385b1cSHajimu UMEMOTO m <<= 1; 1067d6385b1cSHajimu UMEMOTO } 1068d6385b1cSHajimu UMEMOTO } 1069d6385b1cSHajimu UMEMOTO } 1070d6385b1cSHajimu UMEMOTO 1071d6385b1cSHajimu UMEMOTO /* matched. check if this is better than the current best. */ 1072d6385b1cSHajimu UMEMOTO if (bestpol == NULL || 1073d6385b1cSHajimu UMEMOTO matchlen > bestmatchlen) { 1074d6385b1cSHajimu UMEMOTO bestpol = pol; 1075d6385b1cSHajimu UMEMOTO bestmatchlen = matchlen; 1076d6385b1cSHajimu UMEMOTO } 1077d6385b1cSHajimu UMEMOTO 1078d6385b1cSHajimu UMEMOTO next: 1079d6385b1cSHajimu UMEMOTO continue; 1080d6385b1cSHajimu UMEMOTO } 1081d6385b1cSHajimu UMEMOTO 1082d6385b1cSHajimu UMEMOTO return (bestpol); 1083d6385b1cSHajimu UMEMOTO } 1084