in6_pcb.c revision 1.88.6.2
1 /* in6_pcb.c,v 1.88.6.1 2008/01/09 01:57:35 matt Exp */ 2 /* $KAME: in6_pcb.c,v 1.84 2001/02/08 18:02:08 itojun 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. Neither the name of the University nor the names of its contributors 46 * may be used to endorse or promote products derived from this software 47 * without specific prior written permission. 48 * 49 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 50 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 51 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 52 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 53 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 54 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 55 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 56 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 57 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 58 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 59 * SUCH DAMAGE. 60 * 61 * @(#)in_pcb.c 8.2 (Berkeley) 1/4/94 62 */ 63 64 #include <sys/cdefs.h> 65 __KERNEL_RCSID(0, "in6_pcb.c,v 1.88.6.1 2008/01/09 01:57:35 matt Exp"); 66 67 #include "opt_inet.h" 68 #include "opt_ipsec.h" 69 70 #include <sys/param.h> 71 #include <sys/systm.h> 72 #include <sys/malloc.h> 73 #include <sys/mbuf.h> 74 #include <sys/protosw.h> 75 #include <sys/socket.h> 76 #include <sys/socketvar.h> 77 #include <sys/ioctl.h> 78 #include <sys/errno.h> 79 #include <sys/time.h> 80 #include <sys/proc.h> 81 #include <sys/kauth.h> 82 83 #include <net/if.h> 84 #include <net/route.h> 85 86 #include <netinet/in.h> 87 #include <netinet/in_var.h> 88 #include <netinet/in_systm.h> 89 #include <netinet/ip.h> 90 #include <netinet/in_pcb.h> 91 #include <netinet/ip6.h> 92 #include <netinet6/ip6_var.h> 93 #include <netinet6/in6_pcb.h> 94 #include <netinet6/scope6_var.h> 95 #include <netinet6/nd6.h> 96 97 #include "faith.h" 98 99 #ifdef IPSEC 100 #include <netinet6/ipsec.h> 101 #include <netkey/key.h> 102 #endif /* IPSEC */ 103 104 #ifdef FAST_IPSEC 105 #include <netipsec/ipsec.h> 106 #include <netipsec/ipsec6.h> 107 #include <netipsec/key.h> 108 #endif /* FAST_IPSEC */ 109 110 struct in6_addr zeroin6_addr; 111 112 #define IN6PCBHASH_PORT(table, lport) \ 113 &(table)->inpt_porthashtbl[ntohs(lport) & (table)->inpt_porthash] 114 #define IN6PCBHASH_BIND(table, laddr, lport) \ 115 &(table)->inpt_bindhashtbl[ \ 116 (((laddr)->s6_addr32[0] ^ (laddr)->s6_addr32[1] ^ \ 117 (laddr)->s6_addr32[2] ^ (laddr)->s6_addr32[3]) + ntohs(lport)) & \ 118 (table)->inpt_bindhash] 119 #define IN6PCBHASH_CONNECT(table, faddr, fport, laddr, lport) \ 120 &(table)->inpt_bindhashtbl[ \ 121 ((((faddr)->s6_addr32[0] ^ (faddr)->s6_addr32[1] ^ \ 122 (faddr)->s6_addr32[2] ^ (faddr)->s6_addr32[3]) + ntohs(fport)) + \ 123 (((laddr)->s6_addr32[0] ^ (laddr)->s6_addr32[1] ^ \ 124 (laddr)->s6_addr32[2] ^ (laddr)->s6_addr32[3]) + \ 125 ntohs(lport))) & (table)->inpt_bindhash] 126 127 int ip6_anonportmin = IPV6PORT_ANONMIN; 128 int ip6_anonportmax = IPV6PORT_ANONMAX; 129 int ip6_lowportmin = IPV6PORT_RESERVEDMIN; 130 int ip6_lowportmax = IPV6PORT_RESERVEDMAX; 131 132 POOL_INIT(in6pcb_pool, sizeof(struct in6pcb), 0, 0, 0, "in6pcbpl", NULL, 133 IPL_SOFTNET); 134 135 void 136 in6_pcbinit(struct inpcbtable *table, int bindhashsize, int connecthashsize) 137 { 138 139 in_pcbinit(table, bindhashsize, connecthashsize); 140 table->inpt_lastport = (u_int16_t)ip6_anonportmax; 141 } 142 143 int 144 in6_pcballoc(struct socket *so, void *v) 145 { 146 struct inpcbtable *table = v; 147 struct in6pcb *in6p; 148 int s; 149 #if defined(IPSEC) || defined(FAST_IPSEC) 150 int error; 151 #endif 152 153 s = splnet(); 154 in6p = pool_get(&in6pcb_pool, PR_NOWAIT); 155 splx(s); 156 if (in6p == NULL) 157 return (ENOBUFS); 158 bzero((void *)in6p, sizeof(*in6p)); 159 in6p->in6p_af = AF_INET6; 160 in6p->in6p_table = table; 161 in6p->in6p_socket = so; 162 in6p->in6p_hops = -1; /* use kernel default */ 163 in6p->in6p_icmp6filt = NULL; 164 #if defined(IPSEC) || defined(FAST_IPSEC) 165 error = ipsec_init_pcbpolicy(so, &in6p->in6p_sp); 166 if (error != 0) { 167 s = splnet(); 168 pool_put(&in6pcb_pool, in6p); 169 splx(s); 170 return error; 171 } 172 #endif /* IPSEC */ 173 s = splnet(); 174 CIRCLEQ_INSERT_HEAD(&table->inpt_queue, (struct inpcb_hdr*)in6p, 175 inph_queue); 176 LIST_INSERT_HEAD(IN6PCBHASH_PORT(table, in6p->in6p_lport), 177 &in6p->in6p_head, inph_lhash); 178 in6_pcbstate(in6p, IN6P_ATTACHED); 179 splx(s); 180 if (ip6_v6only) 181 in6p->in6p_flags |= IN6P_IPV6_V6ONLY; 182 so->so_pcb = (void *)in6p; 183 return (0); 184 } 185 186 int 187 in6_pcbbind(void *v, struct mbuf *nam, struct lwp *l) 188 { 189 struct in6pcb *in6p = v; 190 struct socket *so = in6p->in6p_socket; 191 struct inpcbtable *table = in6p->in6p_table; 192 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)NULL; 193 u_int16_t lport = 0; 194 int wild = 0, reuseport = (so->so_options & SO_REUSEPORT); 195 196 if (in6p->in6p_af != AF_INET6) 197 return (EINVAL); 198 199 if (in6p->in6p_lport || !IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_laddr)) 200 return (EINVAL); 201 if ((so->so_options & (SO_REUSEADDR|SO_REUSEPORT)) == 0 && 202 ((so->so_proto->pr_flags & PR_CONNREQUIRED) == 0 || 203 (so->so_options & SO_ACCEPTCONN) == 0)) 204 wild = 1; 205 if (nam) { 206 int error; 207 208 sin6 = mtod(nam, struct sockaddr_in6 *); 209 if (nam->m_len != sizeof(*sin6)) 210 return (EINVAL); 211 /* 212 * We should check the family, but old programs 213 * incorrectly fail to intialize it. 214 */ 215 if (sin6->sin6_family != AF_INET6) 216 return (EAFNOSUPPORT); 217 218 #ifndef INET 219 if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) 220 return (EADDRNOTAVAIL); 221 #endif 222 223 if ((error = sa6_embedscope(sin6, ip6_use_defzone)) != 0) 224 return (error); 225 226 lport = sin6->sin6_port; 227 if (IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr)) { 228 /* 229 * Treat SO_REUSEADDR as SO_REUSEPORT for multicast; 230 * allow compepte duplication of binding if 231 * SO_REUSEPORT is set, or if SO_REUSEADDR is set 232 * and a multicast address is bound on both 233 * new and duplicated sockets. 234 */ 235 if (so->so_options & SO_REUSEADDR) 236 reuseport = SO_REUSEADDR|SO_REUSEPORT; 237 } else if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) { 238 if ((in6p->in6p_flags & IN6P_IPV6_V6ONLY) != 0) 239 return (EINVAL); 240 if (sin6->sin6_addr.s6_addr32[3]) { 241 struct sockaddr_in sin; 242 243 bzero(&sin, sizeof(sin)); 244 sin.sin_len = sizeof(sin); 245 sin.sin_family = AF_INET; 246 bcopy(&sin6->sin6_addr.s6_addr32[3], 247 &sin.sin_addr, sizeof(sin.sin_addr)); 248 if (ifa_ifwithaddr((struct sockaddr *)&sin) == 0) 249 return EADDRNOTAVAIL; 250 } 251 } else if (!IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) { 252 struct ifaddr *ia = NULL; 253 254 sin6->sin6_port = 0; /* yech... */ 255 if ((in6p->in6p_flags & IN6P_FAITH) == 0 && 256 (ia = ifa_ifwithaddr((struct sockaddr *)sin6)) == 0) 257 return (EADDRNOTAVAIL); 258 259 /* 260 * bind to an anycast address might accidentally 261 * cause sending a packet with an anycast source 262 * address, so we forbid it. 263 * 264 * We should allow to bind to a deprecated address, 265 * since the application dare to use it. 266 * But, can we assume that they are careful enough 267 * to check if the address is deprecated or not? 268 * Maybe, as a safeguard, we should have a setsockopt 269 * flag to control the bind(2) behavior against 270 * deprecated addresses (default: forbid bind(2)). 271 */ 272 if (ia && 273 ((struct in6_ifaddr *)ia)->ia6_flags & 274 (IN6_IFF_ANYCAST|IN6_IFF_NOTREADY|IN6_IFF_DETACHED)) 275 return (EADDRNOTAVAIL); 276 } 277 if (lport) { 278 #ifndef IPNOPRIVPORTS 279 int priv; 280 281 /* 282 * NOTE: all operating systems use suser() for 283 * privilege check! do not rewrite it into SS_PRIV. 284 */ 285 priv = (l && !kauth_authorize_generic(l->l_cred, 286 KAUTH_GENERIC_ISSUSER, NULL)) ? 1 : 0; 287 /* GROSS */ 288 if (ntohs(lport) < IPV6PORT_RESERVED && !priv) 289 return (EACCES); 290 #endif 291 292 if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) { 293 #ifdef INET 294 struct inpcb *t; 295 296 t = in_pcblookup_port(table, 297 *(struct in_addr *)&sin6->sin6_addr.s6_addr32[3], 298 lport, wild); 299 if (t && (reuseport & t->inp_socket->so_options) == 0) 300 return (EADDRINUSE); 301 #else 302 return (EADDRNOTAVAIL); 303 #endif 304 } 305 306 { 307 struct in6pcb *t; 308 309 t = in6_pcblookup_port(table, &sin6->sin6_addr, 310 lport, wild); 311 if (t && (reuseport & t->in6p_socket->so_options) == 0) 312 return (EADDRINUSE); 313 } 314 } 315 in6p->in6p_laddr = sin6->sin6_addr; 316 } 317 318 if (lport == 0) { 319 int e; 320 e = in6_pcbsetport(&in6p->in6p_laddr, in6p, l); 321 if (e != 0) 322 return (e); 323 } else { 324 in6p->in6p_lport = lport; 325 in6_pcbstate(in6p, IN6P_BOUND); 326 } 327 328 LIST_REMOVE(&in6p->in6p_head, inph_lhash); 329 LIST_INSERT_HEAD(IN6PCBHASH_PORT(table, in6p->in6p_lport), 330 &in6p->in6p_head, inph_lhash); 331 332 #if 0 333 in6p->in6p_flowinfo = 0; /* XXX */ 334 #endif 335 return (0); 336 } 337 338 /* 339 * Connect from a socket to a specified address. 340 * Both address and port must be specified in argument sin6. 341 * If don't have a local address for this socket yet, 342 * then pick one. 343 */ 344 int 345 in6_pcbconnect(void *v, struct mbuf *nam, struct lwp *l) 346 { 347 struct rtentry *rt; 348 struct in6pcb *in6p = v; 349 struct in6_addr *in6a = NULL; 350 struct sockaddr_in6 *sin6 = mtod(nam, struct sockaddr_in6 *); 351 struct ifnet *ifp = NULL; /* outgoing interface */ 352 int error = 0; 353 int scope_ambiguous = 0; 354 #ifdef INET 355 struct in6_addr mapped; 356 #endif 357 struct sockaddr_in6 tmp; 358 359 (void)&in6a; /* XXX fool gcc */ 360 361 if (in6p->in6p_af != AF_INET6) 362 return (EINVAL); 363 364 if (nam->m_len != sizeof(*sin6)) 365 return (EINVAL); 366 if (sin6->sin6_family != AF_INET6) 367 return (EAFNOSUPPORT); 368 if (sin6->sin6_port == 0) 369 return (EADDRNOTAVAIL); 370 371 if (sin6->sin6_scope_id == 0 && !ip6_use_defzone) 372 scope_ambiguous = 1; 373 if ((error = sa6_embedscope(sin6, ip6_use_defzone)) != 0) 374 return(error); 375 376 /* sanity check for mapped address case */ 377 if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) { 378 if ((in6p->in6p_flags & IN6P_IPV6_V6ONLY) != 0) 379 return EINVAL; 380 if (IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_laddr)) 381 in6p->in6p_laddr.s6_addr16[5] = htons(0xffff); 382 if (!IN6_IS_ADDR_V4MAPPED(&in6p->in6p_laddr)) 383 return EINVAL; 384 } else 385 { 386 if (IN6_IS_ADDR_V4MAPPED(&in6p->in6p_laddr)) 387 return EINVAL; 388 } 389 390 /* protect *sin6 from overwrites */ 391 tmp = *sin6; 392 sin6 = &tmp; 393 394 /* Source address selection. */ 395 if (IN6_IS_ADDR_V4MAPPED(&in6p->in6p_laddr) && 396 in6p->in6p_laddr.s6_addr32[3] == 0) { 397 #ifdef INET 398 struct sockaddr_in sin, *sinp; 399 400 bzero(&sin, sizeof(sin)); 401 sin.sin_len = sizeof(sin); 402 sin.sin_family = AF_INET; 403 bcopy(&sin6->sin6_addr.s6_addr32[3], &sin.sin_addr, 404 sizeof(sin.sin_addr)); 405 sinp = in_selectsrc(&sin, &in6p->in6p_route, 406 in6p->in6p_socket->so_options, NULL, &error); 407 if (sinp == 0) { 408 if (error == 0) 409 error = EADDRNOTAVAIL; 410 return (error); 411 } 412 bzero(&mapped, sizeof(mapped)); 413 mapped.s6_addr16[5] = htons(0xffff); 414 bcopy(&sinp->sin_addr, &mapped.s6_addr32[3], sizeof(sinp->sin_addr)); 415 in6a = &mapped; 416 #else 417 return EADDRNOTAVAIL; 418 #endif 419 } else { 420 /* 421 * XXX: in6_selectsrc might replace the bound local address 422 * with the address specified by setsockopt(IPV6_PKTINFO). 423 * Is it the intended behavior? 424 */ 425 in6a = in6_selectsrc(sin6, in6p->in6p_outputopts, 426 in6p->in6p_moptions, 427 &in6p->in6p_route, 428 &in6p->in6p_laddr, &ifp, &error); 429 if (ifp && scope_ambiguous && 430 (error = in6_setscope(&sin6->sin6_addr, ifp, NULL)) != 0) { 431 return(error); 432 } 433 434 if (in6a == 0) { 435 if (error == 0) 436 error = EADDRNOTAVAIL; 437 return (error); 438 } 439 } 440 if (ifp == NULL && (rt = rtcache_validate(&in6p->in6p_route)) != NULL) 441 ifp = rt->rt_ifp; 442 443 in6p->in6p_ip6.ip6_hlim = (u_int8_t)in6_selecthlim(in6p, ifp); 444 445 if (in6_pcblookup_connect(in6p->in6p_table, &sin6->sin6_addr, 446 sin6->sin6_port, 447 IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_laddr) ? in6a : &in6p->in6p_laddr, 448 in6p->in6p_lport, 0)) 449 return (EADDRINUSE); 450 if (IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_laddr) || 451 (IN6_IS_ADDR_V4MAPPED(&in6p->in6p_laddr) && 452 in6p->in6p_laddr.s6_addr32[3] == 0)) 453 { 454 if (in6p->in6p_lport == 0) { 455 error = in6_pcbbind(in6p, (struct mbuf *)0, l); 456 if (error != 0) 457 return error; 458 } 459 in6p->in6p_laddr = *in6a; 460 } 461 in6p->in6p_faddr = sin6->sin6_addr; 462 in6p->in6p_fport = sin6->sin6_port; 463 in6_pcbstate(in6p, IN6P_CONNECTED); 464 in6p->in6p_flowinfo &= ~IPV6_FLOWLABEL_MASK; 465 if (ip6_auto_flowlabel) 466 in6p->in6p_flowinfo |= 467 (htonl(ip6_randomflowlabel()) & IPV6_FLOWLABEL_MASK); 468 #if defined(IPSEC) || defined(FAST_IPSEC) 469 if (in6p->in6p_socket->so_type == SOCK_STREAM) 470 ipsec_pcbconn(in6p->in6p_sp); 471 #endif 472 return (0); 473 } 474 475 void 476 in6_pcbdisconnect(struct in6pcb *in6p) 477 { 478 bzero((void *)&in6p->in6p_faddr, sizeof(in6p->in6p_faddr)); 479 in6p->in6p_fport = 0; 480 in6_pcbstate(in6p, IN6P_BOUND); 481 in6p->in6p_flowinfo &= ~IPV6_FLOWLABEL_MASK; 482 #if defined(IPSEC) || defined(FAST_IPSEC) 483 ipsec_pcbdisconn(in6p->in6p_sp); 484 #endif 485 if (in6p->in6p_socket->so_state & SS_NOFDREF) 486 in6_pcbdetach(in6p); 487 } 488 489 void 490 in6_pcbdetach(struct in6pcb *in6p) 491 { 492 struct socket *so = in6p->in6p_socket; 493 int s; 494 495 if (in6p->in6p_af != AF_INET6) 496 return; 497 498 #if defined(IPSEC) || defined(FAST_IPSEC) 499 ipsec6_delete_pcbpolicy(in6p); 500 #endif /* IPSEC */ 501 so->so_pcb = 0; 502 sofree(so); 503 if (in6p->in6p_options) 504 m_freem(in6p->in6p_options); 505 if (in6p->in6p_outputopts != NULL) { 506 ip6_clearpktopts(in6p->in6p_outputopts, -1); 507 free(in6p->in6p_outputopts, M_IP6OPT); 508 } 509 rtcache_free(&in6p->in6p_route); 510 ip6_freemoptions(in6p->in6p_moptions); 511 s = splnet(); 512 in6_pcbstate(in6p, IN6P_ATTACHED); 513 LIST_REMOVE(&in6p->in6p_head, inph_lhash); 514 CIRCLEQ_REMOVE(&in6p->in6p_table->inpt_queue, &in6p->in6p_head, 515 inph_queue); 516 pool_put(&in6pcb_pool, in6p); 517 splx(s); 518 } 519 520 void 521 in6_setsockaddr(struct in6pcb *in6p, struct mbuf *nam) 522 { 523 struct sockaddr_in6 *sin6; 524 525 if (in6p->in6p_af != AF_INET6) 526 return; 527 528 nam->m_len = sizeof(*sin6); 529 sin6 = mtod(nam, struct sockaddr_in6 *); 530 sockaddr_in6_init(sin6, &in6p->in6p_laddr, in6p->in6p_lport, 0, 0); 531 (void)sa6_recoverscope(sin6); /* XXX: should catch errors */ 532 } 533 534 void 535 in6_setpeeraddr(struct in6pcb *in6p, struct mbuf *nam) 536 { 537 struct sockaddr_in6 *sin6; 538 539 if (in6p->in6p_af != AF_INET6) 540 return; 541 542 nam->m_len = sizeof(*sin6); 543 sin6 = mtod(nam, struct sockaddr_in6 *); 544 sockaddr_in6_init(sin6, &in6p->in6p_faddr, in6p->in6p_fport, 0, 0); 545 (void)sa6_recoverscope(sin6); /* XXX: should catch errors */ 546 } 547 548 /* 549 * Pass some notification to all connections of a protocol 550 * associated with address dst. The local address and/or port numbers 551 * may be specified to limit the search. The "usual action" will be 552 * taken, depending on the ctlinput cmd. The caller must filter any 553 * cmds that are uninteresting (e.g., no error in the map). 554 * Call the protocol specific routine (if any) to report 555 * any errors for each matching socket. 556 * 557 * Must be called at splsoftnet. 558 * 559 * Note: src (4th arg) carries the flowlabel value on the original IPv6 560 * header, in sin6_flowinfo member. 561 */ 562 int 563 in6_pcbnotify(struct inpcbtable *table, const struct sockaddr *dst, 564 u_int fport_arg, const struct sockaddr *src, u_int lport_arg, int cmd, 565 void *cmdarg, void (*notify)(struct in6pcb *, int)) 566 { 567 struct rtentry *rt; 568 struct in6pcb *in6p, *nin6p; 569 struct sockaddr_in6 sa6_src; 570 const struct sockaddr_in6 *sa6_dst; 571 u_int16_t fport = fport_arg, lport = lport_arg; 572 int errno; 573 int nmatch = 0; 574 u_int32_t flowinfo; 575 576 if ((unsigned)cmd >= PRC_NCMDS || dst->sa_family != AF_INET6) 577 return 0; 578 579 sa6_dst = (const struct sockaddr_in6 *)dst; 580 if (IN6_IS_ADDR_UNSPECIFIED(&sa6_dst->sin6_addr)) 581 return 0; 582 583 /* 584 * note that src can be NULL when we get notify by local fragmentation. 585 */ 586 sa6_src = (src == NULL) ? sa6_any : *(const struct sockaddr_in6 *)src; 587 flowinfo = sa6_src.sin6_flowinfo; 588 589 /* 590 * Redirects go to all references to the destination, 591 * and use in6_rtchange to invalidate the route cache. 592 * Dead host indications: also use in6_rtchange to invalidate 593 * the cache, and deliver the error to all the sockets. 594 * Otherwise, if we have knowledge of the local port and address, 595 * deliver only to that socket. 596 */ 597 if (PRC_IS_REDIRECT(cmd) || cmd == PRC_HOSTDEAD) { 598 fport = 0; 599 lport = 0; 600 bzero((void *)&sa6_src.sin6_addr, sizeof(sa6_src.sin6_addr)); 601 602 if (cmd != PRC_HOSTDEAD) 603 notify = in6_rtchange; 604 } 605 606 errno = inet6ctlerrmap[cmd]; 607 for (in6p = (struct in6pcb *)CIRCLEQ_FIRST(&table->inpt_queue); 608 in6p != (void *)&table->inpt_queue; 609 in6p = nin6p) { 610 nin6p = (struct in6pcb *)CIRCLEQ_NEXT(in6p, in6p_queue); 611 612 if (in6p->in6p_af != AF_INET6) 613 continue; 614 615 /* 616 * Under the following condition, notify of redirects 617 * to the pcb, without making address matches against inpcb. 618 * - redirect notification is arrived. 619 * - the inpcb is unconnected. 620 * - the inpcb is caching !RTF_HOST routing entry. 621 * - the ICMPv6 notification is from the gateway cached in the 622 * inpcb. i.e. ICMPv6 notification is from nexthop gateway 623 * the inpcb used very recently. 624 * 625 * This is to improve interaction between netbsd/openbsd 626 * redirect handling code, and inpcb route cache code. 627 * without the clause, !RTF_HOST routing entry (which carries 628 * gateway used by inpcb right before the ICMPv6 redirect) 629 * will be cached forever in unconnected inpcb. 630 * 631 * There still is a question regarding to what is TRT: 632 * - On bsdi/freebsd, RTF_HOST (cloned) routing entry will be 633 * generated on packet output. inpcb will always cache 634 * RTF_HOST routing entry so there's no need for the clause 635 * (ICMPv6 redirect will update RTF_HOST routing entry, 636 * and inpcb is caching it already). 637 * However, bsdi/freebsd are vulnerable to local DoS attacks 638 * due to the cloned routing entries. 639 * - Specwise, "destination cache" is mentioned in RFC2461. 640 * Jinmei says that it implies bsdi/freebsd behavior, itojun 641 * is not really convinced. 642 * - Having hiwat/lowat on # of cloned host route (redirect/ 643 * pmtud) may be a good idea. netbsd/openbsd has it. see 644 * icmp6_mtudisc_update(). 645 */ 646 if ((PRC_IS_REDIRECT(cmd) || cmd == PRC_HOSTDEAD) && 647 IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_laddr) && 648 (rt = rtcache_validate(&in6p->in6p_route)) != NULL && 649 !(rt->rt_flags & RTF_HOST)) { 650 const struct sockaddr_in6 *dst6; 651 652 dst6 = (const struct sockaddr_in6 *) 653 rtcache_getdst(&in6p->in6p_route); 654 if (dst6 == NULL) 655 ; 656 else if (IN6_ARE_ADDR_EQUAL(&dst6->sin6_addr, 657 &sa6_dst->sin6_addr)) 658 goto do_notify; 659 } 660 661 /* 662 * If the error designates a new path MTU for a destination 663 * and the application (associated with this socket) wanted to 664 * know the value, notify. Note that we notify for all 665 * disconnected sockets if the corresponding application 666 * wanted. This is because some UDP applications keep sending 667 * sockets disconnected. 668 * XXX: should we avoid to notify the value to TCP sockets? 669 */ 670 if (cmd == PRC_MSGSIZE && (in6p->in6p_flags & IN6P_MTU) != 0 && 671 (IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_faddr) || 672 IN6_ARE_ADDR_EQUAL(&in6p->in6p_faddr, &sa6_dst->sin6_addr))) { 673 ip6_notify_pmtu(in6p, (const struct sockaddr_in6 *)dst, 674 (u_int32_t *)cmdarg); 675 } 676 677 /* 678 * Detect if we should notify the error. If no source and 679 * destination ports are specified, but non-zero flowinfo and 680 * local address match, notify the error. This is the case 681 * when the error is delivered with an encrypted buffer 682 * by ESP. Otherwise, just compare addresses and ports 683 * as usual. 684 */ 685 if (lport == 0 && fport == 0 && flowinfo && 686 in6p->in6p_socket != NULL && 687 flowinfo == (in6p->in6p_flowinfo & IPV6_FLOWLABEL_MASK) && 688 IN6_ARE_ADDR_EQUAL(&in6p->in6p_laddr, &sa6_src.sin6_addr)) 689 goto do_notify; 690 else if (!IN6_ARE_ADDR_EQUAL(&in6p->in6p_faddr, 691 &sa6_dst->sin6_addr) || 692 in6p->in6p_socket == 0 || 693 (lport && in6p->in6p_lport != lport) || 694 (!IN6_IS_ADDR_UNSPECIFIED(&sa6_src.sin6_addr) && 695 !IN6_ARE_ADDR_EQUAL(&in6p->in6p_laddr, 696 &sa6_src.sin6_addr)) || 697 (fport && in6p->in6p_fport != fport)) 698 continue; 699 700 do_notify: 701 if (notify) 702 (*notify)(in6p, errno); 703 nmatch++; 704 } 705 return nmatch; 706 } 707 708 void 709 in6_pcbpurgeif0(struct inpcbtable *table, struct ifnet *ifp) 710 { 711 struct in6pcb *in6p, *nin6p; 712 struct ip6_moptions *im6o; 713 struct in6_multi_mship *imm, *nimm; 714 715 for (in6p = (struct in6pcb *)CIRCLEQ_FIRST(&table->inpt_queue); 716 in6p != (void *)&table->inpt_queue; 717 in6p = nin6p) { 718 nin6p = (struct in6pcb *)CIRCLEQ_NEXT(in6p, in6p_queue); 719 if (in6p->in6p_af != AF_INET6) 720 continue; 721 722 im6o = in6p->in6p_moptions; 723 if (im6o) { 724 /* 725 * Unselect the outgoing interface if it is being 726 * detached. 727 */ 728 if (im6o->im6o_multicast_ifp == ifp) 729 im6o->im6o_multicast_ifp = NULL; 730 731 /* 732 * Drop multicast group membership if we joined 733 * through the interface being detached. 734 * XXX controversial - is it really legal for kernel 735 * to force this? 736 */ 737 for (imm = im6o->im6o_memberships.lh_first; 738 imm != NULL; imm = nimm) { 739 nimm = imm->i6mm_chain.le_next; 740 if (imm->i6mm_maddr->in6m_ifp == ifp) { 741 LIST_REMOVE(imm, i6mm_chain); 742 in6_leavegroup(imm); 743 } 744 } 745 } 746 } 747 } 748 749 void 750 in6_pcbpurgeif(struct inpcbtable *table, struct ifnet *ifp) 751 { 752 struct rtentry *rt; 753 struct in6pcb *in6p, *nin6p; 754 755 for (in6p = (struct in6pcb *)CIRCLEQ_FIRST(&table->inpt_queue); 756 in6p != (void *)&table->inpt_queue; 757 in6p = nin6p) { 758 nin6p = (struct in6pcb *)CIRCLEQ_NEXT(in6p, in6p_queue); 759 if (in6p->in6p_af != AF_INET6) 760 continue; 761 if ((rt = rtcache_validate(&in6p->in6p_route)) != NULL && 762 rt->rt_ifp == ifp) 763 in6_rtchange(in6p, 0); 764 } 765 } 766 767 /* 768 * Check for alternatives when higher level complains 769 * about service problems. For now, invalidate cached 770 * routing information. If the route was created dynamically 771 * (by a redirect), time to try a default gateway again. 772 */ 773 void 774 in6_losing(struct in6pcb *in6p) 775 { 776 struct rtentry *rt; 777 struct rt_addrinfo info; 778 779 if (in6p->in6p_af != AF_INET6) 780 return; 781 782 if ((rt = rtcache_validate(&in6p->in6p_route)) == NULL) 783 return; 784 785 memset(&info, 0, sizeof(info)); 786 info.rti_info[RTAX_DST] = rtcache_getdst(&in6p->in6p_route); 787 info.rti_info[RTAX_GATEWAY] = rt->rt_gateway; 788 info.rti_info[RTAX_NETMASK] = rt_mask(rt); 789 rt_missmsg(RTM_LOSING, &info, rt->rt_flags, 0); 790 if (rt->rt_flags & RTF_DYNAMIC) { 791 (void)rtrequest(RTM_DELETE, rt_getkey(rt), 792 rt->rt_gateway, rt_mask(rt), rt->rt_flags, NULL); 793 } 794 /* 795 * A new route can be allocated 796 * the next time output is attempted. 797 */ 798 rtcache_free(&in6p->in6p_route); 799 } 800 801 /* 802 * After a routing change, flush old routing. A new route can be 803 * allocated the next time output is attempted. 804 */ 805 void 806 in6_rtchange(struct in6pcb *in6p, int errno) 807 { 808 if (in6p->in6p_af != AF_INET6) 809 return; 810 811 rtcache_free(&in6p->in6p_route); 812 /* 813 * A new route can be allocated the next time 814 * output is attempted. 815 */ 816 } 817 818 struct in6pcb * 819 in6_pcblookup_port(struct inpcbtable *table, struct in6_addr *laddr6, 820 u_int lport_arg, int lookup_wildcard) 821 { 822 struct inpcbhead *head; 823 struct inpcb_hdr *inph; 824 struct in6pcb *in6p, *match = 0; 825 int matchwild = 3, wildcard; 826 u_int16_t lport = lport_arg; 827 828 head = IN6PCBHASH_PORT(table, lport); 829 LIST_FOREACH(inph, head, inph_lhash) { 830 in6p = (struct in6pcb *)inph; 831 if (in6p->in6p_af != AF_INET6) 832 continue; 833 834 if (in6p->in6p_lport != lport) 835 continue; 836 wildcard = 0; 837 if (IN6_IS_ADDR_V4MAPPED(&in6p->in6p_faddr)) { 838 if ((in6p->in6p_flags & IN6P_IPV6_V6ONLY) != 0) 839 continue; 840 } 841 if (!IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_faddr)) 842 wildcard++; 843 if (IN6_IS_ADDR_V4MAPPED(&in6p->in6p_laddr)) { 844 if ((in6p->in6p_flags & IN6P_IPV6_V6ONLY) != 0) 845 continue; 846 if (!IN6_IS_ADDR_V4MAPPED(laddr6)) 847 continue; 848 849 /* duplicate of IPv4 logic */ 850 wildcard = 0; 851 if (IN6_IS_ADDR_V4MAPPED(&in6p->in6p_faddr) && 852 in6p->in6p_faddr.s6_addr32[3]) 853 wildcard++; 854 if (!in6p->in6p_laddr.s6_addr32[3]) { 855 if (laddr6->s6_addr32[3]) 856 wildcard++; 857 } else { 858 if (!laddr6->s6_addr32[3]) 859 wildcard++; 860 else { 861 if (in6p->in6p_laddr.s6_addr32[3] != 862 laddr6->s6_addr32[3]) 863 continue; 864 } 865 } 866 } else if (IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_laddr)) { 867 if (IN6_IS_ADDR_V4MAPPED(laddr6)) { 868 if ((in6p->in6p_flags & IN6P_IPV6_V6ONLY) != 0) 869 continue; 870 } 871 if (!IN6_IS_ADDR_UNSPECIFIED(laddr6)) 872 wildcard++; 873 } else { 874 if (IN6_IS_ADDR_V4MAPPED(laddr6)) { 875 if ((in6p->in6p_flags & IN6P_IPV6_V6ONLY) != 0) 876 continue; 877 } 878 if (IN6_IS_ADDR_UNSPECIFIED(laddr6)) 879 wildcard++; 880 else { 881 if (!IN6_ARE_ADDR_EQUAL(&in6p->in6p_laddr, 882 laddr6)) 883 continue; 884 } 885 } 886 if (wildcard && !lookup_wildcard) 887 continue; 888 if (wildcard < matchwild) { 889 match = in6p; 890 matchwild = wildcard; 891 if (matchwild == 0) 892 break; 893 } 894 } 895 return (match); 896 } 897 #undef continue 898 899 /* 900 * WARNING: return value (rtentry) could be IPv4 one if in6pcb is connected to 901 * IPv4 mapped address. 902 */ 903 struct rtentry * 904 in6_pcbrtentry(struct in6pcb *in6p) 905 { 906 struct rtentry *rt; 907 struct route *ro; 908 union { 909 const struct sockaddr *sa; 910 const struct sockaddr_in6 *sa6; 911 #ifdef INET 912 const struct sockaddr_in *sa4; 913 #endif 914 } cdst; 915 916 ro = &in6p->in6p_route; 917 918 if (in6p->in6p_af != AF_INET6) 919 return (NULL); 920 921 cdst.sa = rtcache_getdst(ro); 922 if (cdst.sa == NULL) 923 ; 924 #ifdef INET 925 else if (cdst.sa->sa_family == AF_INET) { 926 KASSERT(IN6_IS_ADDR_V4MAPPED(&in6p->in6p_faddr)); 927 if (cdst.sa4->sin_addr.s_addr != in6p->in6p_faddr.s6_addr32[3]) 928 rtcache_free(ro); 929 } 930 #endif 931 else { 932 if (!IN6_ARE_ADDR_EQUAL(&cdst.sa6->sin6_addr, 933 &in6p->in6p_faddr)) 934 rtcache_free(ro); 935 } 936 if ((rt = rtcache_validate(ro)) == NULL) 937 rt = rtcache_update(ro, 1); 938 #ifdef INET 939 if (rt == NULL && IN6_IS_ADDR_V4MAPPED(&in6p->in6p_faddr)) { 940 union { 941 struct sockaddr dst; 942 struct sockaddr_in dst4; 943 } u; 944 struct in_addr addr; 945 946 addr.s_addr = in6p->in6p_faddr.s6_addr32[3]; 947 948 sockaddr_in_init(&u.dst4, &addr, 0); 949 rtcache_setdst(ro, &u.dst); 950 951 rt = rtcache_init(ro); 952 } else 953 #endif 954 if (rt == NULL && !IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_faddr)) { 955 union { 956 struct sockaddr dst; 957 struct sockaddr_in6 dst6; 958 } u; 959 960 sockaddr_in6_init(&u.dst6, &in6p->in6p_faddr, 0, 0, 0); 961 rtcache_setdst(ro, &u.dst); 962 963 rt = rtcache_init(ro); 964 } 965 return rt; 966 } 967 968 struct in6pcb * 969 in6_pcblookup_connect(struct inpcbtable *table, const struct in6_addr *faddr6, 970 u_int fport_arg, const struct in6_addr *laddr6, u_int lport_arg, 971 int faith) 972 { 973 struct inpcbhead *head; 974 struct inpcb_hdr *inph; 975 struct in6pcb *in6p; 976 u_int16_t fport = fport_arg, lport = lport_arg; 977 978 head = IN6PCBHASH_CONNECT(table, faddr6, fport, laddr6, lport); 979 LIST_FOREACH(inph, head, inph_hash) { 980 in6p = (struct in6pcb *)inph; 981 if (in6p->in6p_af != AF_INET6) 982 continue; 983 984 /* find exact match on both source and dest */ 985 if (in6p->in6p_fport != fport) 986 continue; 987 if (in6p->in6p_lport != lport) 988 continue; 989 if (IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_faddr)) 990 continue; 991 if (!IN6_ARE_ADDR_EQUAL(&in6p->in6p_faddr, faddr6)) 992 continue; 993 if (IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_laddr)) 994 continue; 995 if (!IN6_ARE_ADDR_EQUAL(&in6p->in6p_laddr, laddr6)) 996 continue; 997 if ((IN6_IS_ADDR_V4MAPPED(laddr6) || 998 IN6_IS_ADDR_V4MAPPED(faddr6)) && 999 (in6p->in6p_flags & IN6P_IPV6_V6ONLY)) 1000 continue; 1001 return in6p; 1002 } 1003 return NULL; 1004 } 1005 1006 struct in6pcb * 1007 in6_pcblookup_bind(struct inpcbtable *table, const struct in6_addr *laddr6, 1008 u_int lport_arg, int faith) 1009 { 1010 struct inpcbhead *head; 1011 struct inpcb_hdr *inph; 1012 struct in6pcb *in6p; 1013 u_int16_t lport = lport_arg; 1014 #ifdef INET 1015 struct in6_addr zero_mapped; 1016 #endif 1017 1018 head = IN6PCBHASH_BIND(table, laddr6, lport); 1019 LIST_FOREACH(inph, head, inph_hash) { 1020 in6p = (struct in6pcb *)inph; 1021 if (in6p->in6p_af != AF_INET6) 1022 continue; 1023 1024 if (faith && (in6p->in6p_flags & IN6P_FAITH) == 0) 1025 continue; 1026 if (in6p->in6p_fport != 0) 1027 continue; 1028 if (in6p->in6p_lport != lport) 1029 continue; 1030 if (IN6_IS_ADDR_V4MAPPED(laddr6) && 1031 (in6p->in6p_flags & IN6P_IPV6_V6ONLY) != 0) 1032 continue; 1033 if (IN6_ARE_ADDR_EQUAL(&in6p->in6p_laddr, laddr6)) 1034 goto out; 1035 } 1036 #ifdef INET 1037 if (IN6_IS_ADDR_V4MAPPED(laddr6)) { 1038 memset(&zero_mapped, 0, sizeof(zero_mapped)); 1039 zero_mapped.s6_addr16[5] = 0xffff; 1040 head = IN6PCBHASH_BIND(table, &zero_mapped, lport); 1041 LIST_FOREACH(inph, head, inph_hash) { 1042 in6p = (struct in6pcb *)inph; 1043 if (in6p->in6p_af != AF_INET6) 1044 continue; 1045 1046 if (faith && (in6p->in6p_flags & IN6P_FAITH) == 0) 1047 continue; 1048 if (in6p->in6p_fport != 0) 1049 continue; 1050 if (in6p->in6p_lport != lport) 1051 continue; 1052 if ((in6p->in6p_flags & IN6P_IPV6_V6ONLY) != 0) 1053 continue; 1054 if (IN6_ARE_ADDR_EQUAL(&in6p->in6p_laddr, &zero_mapped)) 1055 goto out; 1056 } 1057 } 1058 #endif 1059 head = IN6PCBHASH_BIND(table, &zeroin6_addr, lport); 1060 LIST_FOREACH(inph, head, inph_hash) { 1061 in6p = (struct in6pcb *)inph; 1062 if (in6p->in6p_af != AF_INET6) 1063 continue; 1064 1065 if (faith && (in6p->in6p_flags & IN6P_FAITH) == 0) 1066 continue; 1067 if (in6p->in6p_fport != 0) 1068 continue; 1069 if (in6p->in6p_lport != lport) 1070 continue; 1071 if (IN6_IS_ADDR_V4MAPPED(laddr6) && 1072 (in6p->in6p_flags & IN6P_IPV6_V6ONLY) != 0) 1073 continue; 1074 if (IN6_ARE_ADDR_EQUAL(&in6p->in6p_laddr, &zeroin6_addr)) 1075 goto out; 1076 } 1077 return (NULL); 1078 1079 out: 1080 inph = &in6p->in6p_head; 1081 if (inph != LIST_FIRST(head)) { 1082 LIST_REMOVE(inph, inph_hash); 1083 LIST_INSERT_HEAD(head, inph, inph_hash); 1084 } 1085 return in6p; 1086 } 1087 1088 void 1089 in6_pcbstate(struct in6pcb *in6p, int state) 1090 { 1091 1092 if (in6p->in6p_af != AF_INET6) 1093 return; 1094 1095 if (in6p->in6p_state > IN6P_ATTACHED) 1096 LIST_REMOVE(&in6p->in6p_head, inph_hash); 1097 1098 switch (state) { 1099 case IN6P_BOUND: 1100 LIST_INSERT_HEAD(IN6PCBHASH_BIND(in6p->in6p_table, 1101 &in6p->in6p_laddr, in6p->in6p_lport), &in6p->in6p_head, 1102 inph_hash); 1103 break; 1104 case IN6P_CONNECTED: 1105 LIST_INSERT_HEAD(IN6PCBHASH_CONNECT(in6p->in6p_table, 1106 &in6p->in6p_faddr, in6p->in6p_fport, 1107 &in6p->in6p_laddr, in6p->in6p_lport), &in6p->in6p_head, 1108 inph_hash); 1109 break; 1110 } 1111 1112 in6p->in6p_state = state; 1113 } 1114
Indexes created Wed Oct 15 16:09:53 GMT 2025