1 /* $NetBSD: in6_pcb.c,v 1.121 2012/08/24 06:03:18 dholland 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, "$NetBSD: in6_pcb.c,v 1.121 2012/08/24 06:03:18 dholland 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 #include <sys/domain.h> 83 #include <sys/once.h> 84 85 #include <net/if.h> 86 #include <net/route.h> 87 88 #include <netinet/in.h> 89 #include <netinet/in_var.h> 90 #include <netinet/in_systm.h> 91 #include <netinet/ip.h> 92 #include <netinet/in_pcb.h> 93 #include <netinet/ip6.h> 94 #include <netinet/portalgo.h> 95 #include <netinet6/ip6_var.h> 96 #include <netinet6/in6_pcb.h> 97 #include <netinet6/scope6_var.h> 98 #include <netinet6/nd6.h> 99 100 #include "faith.h" 101 102 #ifdef FAST_IPSEC 103 #include <netipsec/ipsec.h> 104 #include <netipsec/ipsec6.h> 105 #include <netipsec/key.h> 106 #endif /* FAST_IPSEC */ 107 108 #include <netinet/tcp_vtw.h> 109 110 const 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 static struct pool in6pcb_pool; 133 134 static int 135 in6pcb_poolinit(void) 136 { 137 138 pool_init(&in6pcb_pool, sizeof(struct in6pcb), 0, 0, 0, "in6pcbpl", 139 NULL, IPL_SOFTNET); 140 return 0; 141 } 142 143 void 144 in6_pcbinit(struct inpcbtable *table, int bindhashsize, int connecthashsize) 145 { 146 static ONCE_DECL(control); 147 148 in_pcbinit(table, bindhashsize, connecthashsize); 149 table->inpt_lastport = (u_int16_t)ip6_anonportmax; 150 151 RUN_ONCE(&control, in6pcb_poolinit); 152 } 153 154 int 155 in6_pcballoc(struct socket *so, void *v) 156 { 157 struct inpcbtable *table = v; 158 struct in6pcb *in6p; 159 int s; 160 #if defined(FAST_IPSEC) 161 int error; 162 #endif 163 164 s = splnet(); 165 in6p = pool_get(&in6pcb_pool, PR_NOWAIT); 166 splx(s); 167 if (in6p == NULL) 168 return (ENOBUFS); 169 memset((void *)in6p, 0, sizeof(*in6p)); 170 in6p->in6p_af = AF_INET6; 171 in6p->in6p_table = table; 172 in6p->in6p_socket = so; 173 in6p->in6p_hops = -1; /* use kernel default */ 174 in6p->in6p_icmp6filt = NULL; 175 in6p->in6p_portalgo = PORTALGO_DEFAULT; 176 in6p->in6p_bindportonsend = false; 177 #if defined(FAST_IPSEC) 178 error = ipsec_init_pcbpolicy(so, &in6p->in6p_sp); 179 if (error != 0) { 180 s = splnet(); 181 pool_put(&in6pcb_pool, in6p); 182 splx(s); 183 return error; 184 } 185 #endif /* IPSEC */ 186 s = splnet(); 187 CIRCLEQ_INSERT_HEAD(&table->inpt_queue, (struct inpcb_hdr*)in6p, 188 inph_queue); 189 LIST_INSERT_HEAD(IN6PCBHASH_PORT(table, in6p->in6p_lport), 190 &in6p->in6p_head, inph_lhash); 191 in6_pcbstate(in6p, IN6P_ATTACHED); 192 splx(s); 193 if (ip6_v6only) 194 in6p->in6p_flags |= IN6P_IPV6_V6ONLY; 195 so->so_pcb = (void *)in6p; 196 return (0); 197 } 198 199 /* 200 * Bind address from sin6 to in6p. 201 */ 202 static int 203 in6_pcbbind_addr(struct in6pcb *in6p, struct sockaddr_in6 *sin6, struct lwp *l) 204 { 205 int error; 206 207 /* 208 * We should check the family, but old programs 209 * incorrectly fail to intialize it. 210 */ 211 if (sin6->sin6_family != AF_INET6) 212 return (EAFNOSUPPORT); 213 214 #ifndef INET 215 if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) 216 return (EADDRNOTAVAIL); 217 #endif 218 219 if ((error = sa6_embedscope(sin6, ip6_use_defzone)) != 0) 220 return (error); 221 222 if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) { 223 if ((in6p->in6p_flags & IN6P_IPV6_V6ONLY) != 0) 224 return (EINVAL); 225 if (sin6->sin6_addr.s6_addr32[3]) { 226 struct sockaddr_in sin; 227 228 memset(&sin, 0, sizeof(sin)); 229 sin.sin_len = sizeof(sin); 230 sin.sin_family = AF_INET; 231 bcopy(&sin6->sin6_addr.s6_addr32[3], 232 &sin.sin_addr, sizeof(sin.sin_addr)); 233 if (ifa_ifwithaddr((struct sockaddr *)&sin) == 0) 234 return EADDRNOTAVAIL; 235 } 236 } else if (!IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) { 237 struct ifaddr *ia = NULL; 238 239 if ((in6p->in6p_flags & IN6P_FAITH) == 0 && 240 (ia = ifa_ifwithaddr((struct sockaddr *)sin6)) == 0) 241 return (EADDRNOTAVAIL); 242 243 /* 244 * bind to an anycast address might accidentally 245 * cause sending a packet with an anycast source 246 * address, so we forbid it. 247 * 248 * We should allow to bind to a deprecated address, 249 * since the application dare to use it. 250 * But, can we assume that they are careful enough 251 * to check if the address is deprecated or not? 252 * Maybe, as a safeguard, we should have a setsockopt 253 * flag to control the bind(2) behavior against 254 * deprecated addresses (default: forbid bind(2)). 255 */ 256 if (ia && 257 ((struct in6_ifaddr *)ia)->ia6_flags & 258 (IN6_IFF_ANYCAST|IN6_IFF_NOTREADY|IN6_IFF_DETACHED)) 259 return (EADDRNOTAVAIL); 260 } 261 262 263 in6p->in6p_laddr = sin6->sin6_addr; 264 265 266 return (0); 267 } 268 269 /* 270 * Bind port from sin6 to in6p. 271 */ 272 static int 273 in6_pcbbind_port(struct in6pcb *in6p, struct sockaddr_in6 *sin6, struct lwp *l) 274 { 275 struct inpcbtable *table = in6p->in6p_table; 276 struct socket *so = in6p->in6p_socket; 277 int wild = 0, reuseport = (so->so_options & SO_REUSEPORT); 278 int error; 279 280 if ((so->so_options & (SO_REUSEADDR|SO_REUSEPORT)) == 0 && 281 ((so->so_proto->pr_flags & PR_CONNREQUIRED) == 0 || 282 (so->so_options & SO_ACCEPTCONN) == 0)) 283 wild = 1; 284 285 if (sin6->sin6_port != 0) { 286 enum kauth_network_req req; 287 288 #ifndef IPNOPRIVPORTS 289 if (ntohs(sin6->sin6_port) < IPV6PORT_RESERVED) 290 req = KAUTH_REQ_NETWORK_BIND_PRIVPORT; 291 else 292 #endif /* IPNOPRIVPORTS */ 293 req = KAUTH_REQ_NETWORK_BIND_PORT; 294 295 error = kauth_authorize_network(l->l_cred, KAUTH_NETWORK_BIND, 296 req, so, sin6, NULL); 297 if (error) 298 return (EACCES); 299 } 300 301 if (IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr)) { 302 /* 303 * Treat SO_REUSEADDR as SO_REUSEPORT for multicast; 304 * allow compepte duplication of binding if 305 * SO_REUSEPORT is set, or if SO_REUSEADDR is set 306 * and a multicast address is bound on both 307 * new and duplicated sockets. 308 */ 309 if (so->so_options & SO_REUSEADDR) 310 reuseport = SO_REUSEADDR|SO_REUSEPORT; 311 } 312 313 if (sin6->sin6_port != 0) { 314 if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) { 315 #ifdef INET 316 struct inpcb *t; 317 struct vestigial_inpcb vestige; 318 319 t = in_pcblookup_port(table, 320 *(struct in_addr *)&sin6->sin6_addr.s6_addr32[3], 321 sin6->sin6_port, wild, &vestige); 322 if (t && (reuseport & t->inp_socket->so_options) == 0) 323 return (EADDRINUSE); 324 if (!t 325 && vestige.valid 326 && !(reuseport && vestige.reuse_port)) 327 return EADDRINUSE; 328 #else 329 return (EADDRNOTAVAIL); 330 #endif 331 } 332 333 { 334 struct in6pcb *t; 335 struct vestigial_inpcb vestige; 336 337 t = in6_pcblookup_port(table, &sin6->sin6_addr, 338 sin6->sin6_port, wild, &vestige); 339 if (t && (reuseport & t->in6p_socket->so_options) == 0) 340 return (EADDRINUSE); 341 if (!t 342 && vestige.valid 343 && !(reuseport && vestige.reuse_port)) 344 return EADDRINUSE; 345 } 346 } 347 348 if (sin6->sin6_port == 0) { 349 int e; 350 e = in6_pcbsetport(sin6, in6p, l); 351 if (e != 0) 352 return (e); 353 } else { 354 in6p->in6p_lport = sin6->sin6_port; 355 in6_pcbstate(in6p, IN6P_BOUND); 356 } 357 358 LIST_REMOVE(&in6p->in6p_head, inph_lhash); 359 LIST_INSERT_HEAD(IN6PCBHASH_PORT(table, in6p->in6p_lport), 360 &in6p->in6p_head, inph_lhash); 361 362 return (0); 363 } 364 365 int 366 in6_pcbbind(void *v, struct mbuf *nam, struct lwp *l) 367 { 368 struct in6pcb *in6p = v; 369 struct sockaddr_in6 lsin6; 370 struct sockaddr_in6 *sin6 = NULL; 371 int error; 372 373 if (in6p->in6p_af != AF_INET6) 374 return (EINVAL); 375 376 /* 377 * If we already have a local port or a local address it means we're 378 * bounded. 379 */ 380 if (in6p->in6p_lport || !(IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_laddr) || 381 (IN6_IS_ADDR_V4MAPPED(&in6p->in6p_laddr) && 382 in6p->in6p_laddr.s6_addr32[3] == 0))) 383 return (EINVAL); 384 385 if (nam != NULL) { 386 /* We were provided a sockaddr_in6 to use. */ 387 sin6 = mtod(nam, struct sockaddr_in6 *); 388 if (nam->m_len != sizeof(*sin6)) 389 return (EINVAL); 390 } else { 391 /* We always bind to *something*, even if it's "anything". */ 392 lsin6 = *((const struct sockaddr_in6 *) 393 in6p->in6p_socket->so_proto->pr_domain->dom_sa_any); 394 sin6 = &lsin6; 395 } 396 397 /* Bind address. */ 398 error = in6_pcbbind_addr(in6p, sin6, l); 399 if (error) 400 return (error); 401 402 /* Bind port. */ 403 error = in6_pcbbind_port(in6p, sin6, l); 404 if (error) { 405 /* 406 * Reset the address here to "any" so we don't "leak" the 407 * in6pcb. 408 */ 409 in6p->in6p_laddr = in6addr_any; 410 411 return (error); 412 } 413 414 415 #if 0 416 in6p->in6p_flowinfo = 0; /* XXX */ 417 #endif 418 return (0); 419 } 420 421 /* 422 * Connect from a socket to a specified address. 423 * Both address and port must be specified in argument sin6. 424 * If don't have a local address for this socket yet, 425 * then pick one. 426 */ 427 int 428 in6_pcbconnect(void *v, struct mbuf *nam, struct lwp *l) 429 { 430 struct rtentry *rt; 431 struct in6pcb *in6p = v; 432 struct in6_addr *in6a = NULL; 433 struct sockaddr_in6 *sin6 = mtod(nam, struct sockaddr_in6 *); 434 struct ifnet *ifp = NULL; /* outgoing interface */ 435 int error = 0; 436 int scope_ambiguous = 0; 437 #ifdef INET 438 struct in6_addr mapped; 439 #endif 440 struct sockaddr_in6 tmp; 441 struct vestigial_inpcb vestige; 442 443 (void)&in6a; /* XXX fool gcc */ 444 445 if (in6p->in6p_af != AF_INET6) 446 return (EINVAL); 447 448 if (nam->m_len != sizeof(*sin6)) 449 return (EINVAL); 450 if (sin6->sin6_family != AF_INET6) 451 return (EAFNOSUPPORT); 452 if (sin6->sin6_port == 0) 453 return (EADDRNOTAVAIL); 454 455 if (sin6->sin6_scope_id == 0 && !ip6_use_defzone) 456 scope_ambiguous = 1; 457 if ((error = sa6_embedscope(sin6, ip6_use_defzone)) != 0) 458 return(error); 459 460 /* sanity check for mapped address case */ 461 if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) { 462 if ((in6p->in6p_flags & IN6P_IPV6_V6ONLY) != 0) 463 return EINVAL; 464 if (IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_laddr)) 465 in6p->in6p_laddr.s6_addr16[5] = htons(0xffff); 466 if (!IN6_IS_ADDR_V4MAPPED(&in6p->in6p_laddr)) 467 return EINVAL; 468 } else 469 { 470 if (IN6_IS_ADDR_V4MAPPED(&in6p->in6p_laddr)) 471 return EINVAL; 472 } 473 474 /* protect *sin6 from overwrites */ 475 tmp = *sin6; 476 sin6 = &tmp; 477 478 /* Source address selection. */ 479 if (IN6_IS_ADDR_V4MAPPED(&in6p->in6p_laddr) && 480 in6p->in6p_laddr.s6_addr32[3] == 0) { 481 #ifdef INET 482 struct sockaddr_in sin, *sinp; 483 484 memset(&sin, 0, sizeof(sin)); 485 sin.sin_len = sizeof(sin); 486 sin.sin_family = AF_INET; 487 memcpy(&sin.sin_addr, &sin6->sin6_addr.s6_addr32[3], 488 sizeof(sin.sin_addr)); 489 sinp = in_selectsrc(&sin, &in6p->in6p_route, 490 in6p->in6p_socket->so_options, NULL, &error); 491 if (sinp == 0) { 492 if (error == 0) 493 error = EADDRNOTAVAIL; 494 return (error); 495 } 496 memset(&mapped, 0, sizeof(mapped)); 497 mapped.s6_addr16[5] = htons(0xffff); 498 memcpy(&mapped.s6_addr32[3], &sinp->sin_addr, sizeof(sinp->sin_addr)); 499 in6a = &mapped; 500 #else 501 return EADDRNOTAVAIL; 502 #endif 503 } else { 504 /* 505 * XXX: in6_selectsrc might replace the bound local address 506 * with the address specified by setsockopt(IPV6_PKTINFO). 507 * Is it the intended behavior? 508 */ 509 in6a = in6_selectsrc(sin6, in6p->in6p_outputopts, 510 in6p->in6p_moptions, 511 &in6p->in6p_route, 512 &in6p->in6p_laddr, &ifp, &error); 513 if (ifp && scope_ambiguous && 514 (error = in6_setscope(&sin6->sin6_addr, ifp, NULL)) != 0) { 515 return(error); 516 } 517 518 if (in6a == 0) { 519 if (error == 0) 520 error = EADDRNOTAVAIL; 521 return (error); 522 } 523 } 524 if (ifp == NULL && (rt = rtcache_validate(&in6p->in6p_route)) != NULL) 525 ifp = rt->rt_ifp; 526 527 in6p->in6p_ip6.ip6_hlim = (u_int8_t)in6_selecthlim(in6p, ifp); 528 529 if (in6_pcblookup_connect(in6p->in6p_table, &sin6->sin6_addr, 530 sin6->sin6_port, 531 IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_laddr) ? in6a : &in6p->in6p_laddr, 532 in6p->in6p_lport, 0, &vestige) 533 || vestige.valid) 534 return (EADDRINUSE); 535 if (IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_laddr) || 536 (IN6_IS_ADDR_V4MAPPED(&in6p->in6p_laddr) && 537 in6p->in6p_laddr.s6_addr32[3] == 0)) 538 { 539 if (in6p->in6p_lport == 0) { 540 error = in6_pcbbind(in6p, NULL, l); 541 if (error != 0) 542 return error; 543 } 544 in6p->in6p_laddr = *in6a; 545 } 546 in6p->in6p_faddr = sin6->sin6_addr; 547 in6p->in6p_fport = sin6->sin6_port; 548 549 /* Late bind, if needed */ 550 if (in6p->in6p_bindportonsend) { 551 struct sockaddr_in6 lsin = *((const struct sockaddr_in6 *) 552 in6p->in6p_socket->so_proto->pr_domain->dom_sa_any); 553 lsin.sin6_addr = in6p->in6p_laddr; 554 lsin.sin6_port = 0; 555 556 if ((error = in6_pcbbind_port(in6p, &lsin, l)) != 0) 557 return error; 558 } 559 560 in6_pcbstate(in6p, IN6P_CONNECTED); 561 in6p->in6p_flowinfo &= ~IPV6_FLOWLABEL_MASK; 562 if (ip6_auto_flowlabel) 563 in6p->in6p_flowinfo |= 564 (htonl(ip6_randomflowlabel()) & IPV6_FLOWLABEL_MASK); 565 #if defined(FAST_IPSEC) 566 if (in6p->in6p_socket->so_type == SOCK_STREAM) 567 ipsec_pcbconn(in6p->in6p_sp); 568 #endif 569 return (0); 570 } 571 572 void 573 in6_pcbdisconnect(struct in6pcb *in6p) 574 { 575 memset((void *)&in6p->in6p_faddr, 0, sizeof(in6p->in6p_faddr)); 576 in6p->in6p_fport = 0; 577 in6_pcbstate(in6p, IN6P_BOUND); 578 in6p->in6p_flowinfo &= ~IPV6_FLOWLABEL_MASK; 579 #if defined(FAST_IPSEC) 580 ipsec_pcbdisconn(in6p->in6p_sp); 581 #endif 582 if (in6p->in6p_socket->so_state & SS_NOFDREF) 583 in6_pcbdetach(in6p); 584 } 585 586 void 587 in6_pcbdetach(struct in6pcb *in6p) 588 { 589 struct socket *so = in6p->in6p_socket; 590 int s; 591 592 if (in6p->in6p_af != AF_INET6) 593 return; 594 595 #if defined(FAST_IPSEC) 596 ipsec6_delete_pcbpolicy(in6p); 597 #endif /* IPSEC */ 598 so->so_pcb = 0; 599 if (in6p->in6p_options) 600 m_freem(in6p->in6p_options); 601 if (in6p->in6p_outputopts != NULL) { 602 ip6_clearpktopts(in6p->in6p_outputopts, -1); 603 free(in6p->in6p_outputopts, M_IP6OPT); 604 } 605 rtcache_free(&in6p->in6p_route); 606 ip6_freemoptions(in6p->in6p_moptions); 607 s = splnet(); 608 in6_pcbstate(in6p, IN6P_ATTACHED); 609 LIST_REMOVE(&in6p->in6p_head, inph_lhash); 610 CIRCLEQ_REMOVE(&in6p->in6p_table->inpt_queue, &in6p->in6p_head, 611 inph_queue); 612 pool_put(&in6pcb_pool, in6p); 613 splx(s); 614 sofree(so); /* drops the socket's lock */ 615 mutex_enter(softnet_lock); /* reacquire it */ 616 } 617 618 void 619 in6_setsockaddr(struct in6pcb *in6p, struct mbuf *nam) 620 { 621 struct sockaddr_in6 *sin6; 622 623 if (in6p->in6p_af != AF_INET6) 624 return; 625 626 nam->m_len = sizeof(*sin6); 627 sin6 = mtod(nam, struct sockaddr_in6 *); 628 sockaddr_in6_init(sin6, &in6p->in6p_laddr, in6p->in6p_lport, 0, 0); 629 (void)sa6_recoverscope(sin6); /* XXX: should catch errors */ 630 } 631 632 void 633 in6_setpeeraddr(struct in6pcb *in6p, struct mbuf *nam) 634 { 635 struct sockaddr_in6 *sin6; 636 637 if (in6p->in6p_af != AF_INET6) 638 return; 639 640 nam->m_len = sizeof(*sin6); 641 sin6 = mtod(nam, struct sockaddr_in6 *); 642 sockaddr_in6_init(sin6, &in6p->in6p_faddr, in6p->in6p_fport, 0, 0); 643 (void)sa6_recoverscope(sin6); /* XXX: should catch errors */ 644 } 645 646 /* 647 * Pass some notification to all connections of a protocol 648 * associated with address dst. The local address and/or port numbers 649 * may be specified to limit the search. The "usual action" will be 650 * taken, depending on the ctlinput cmd. The caller must filter any 651 * cmds that are uninteresting (e.g., no error in the map). 652 * Call the protocol specific routine (if any) to report 653 * any errors for each matching socket. 654 * 655 * Must be called at splsoftnet. 656 * 657 * Note: src (4th arg) carries the flowlabel value on the original IPv6 658 * header, in sin6_flowinfo member. 659 */ 660 int 661 in6_pcbnotify(struct inpcbtable *table, const struct sockaddr *dst, 662 u_int fport_arg, const struct sockaddr *src, u_int lport_arg, int cmd, 663 void *cmdarg, void (*notify)(struct in6pcb *, int)) 664 { 665 struct rtentry *rt; 666 struct in6pcb *in6p, *nin6p; 667 struct sockaddr_in6 sa6_src; 668 const struct sockaddr_in6 *sa6_dst; 669 u_int16_t fport = fport_arg, lport = lport_arg; 670 int errno; 671 int nmatch = 0; 672 u_int32_t flowinfo; 673 674 if ((unsigned)cmd >= PRC_NCMDS || dst->sa_family != AF_INET6) 675 return 0; 676 677 sa6_dst = (const struct sockaddr_in6 *)dst; 678 if (IN6_IS_ADDR_UNSPECIFIED(&sa6_dst->sin6_addr)) 679 return 0; 680 681 /* 682 * note that src can be NULL when we get notify by local fragmentation. 683 */ 684 sa6_src = (src == NULL) ? sa6_any : *(const struct sockaddr_in6 *)src; 685 flowinfo = sa6_src.sin6_flowinfo; 686 687 /* 688 * Redirects go to all references to the destination, 689 * and use in6_rtchange to invalidate the route cache. 690 * Dead host indications: also use in6_rtchange to invalidate 691 * the cache, and deliver the error to all the sockets. 692 * Otherwise, if we have knowledge of the local port and address, 693 * deliver only to that socket. 694 */ 695 if (PRC_IS_REDIRECT(cmd) || cmd == PRC_HOSTDEAD) { 696 fport = 0; 697 lport = 0; 698 memset((void *)&sa6_src.sin6_addr, 0, sizeof(sa6_src.sin6_addr)); 699 700 if (cmd != PRC_HOSTDEAD) 701 notify = in6_rtchange; 702 } 703 704 errno = inet6ctlerrmap[cmd]; 705 for (in6p = (struct in6pcb *)CIRCLEQ_FIRST(&table->inpt_queue); 706 in6p != (void *)&table->inpt_queue; 707 in6p = nin6p) { 708 nin6p = (struct in6pcb *)CIRCLEQ_NEXT(in6p, in6p_queue); 709 710 if (in6p->in6p_af != AF_INET6) 711 continue; 712 713 /* 714 * Under the following condition, notify of redirects 715 * to the pcb, without making address matches against inpcb. 716 * - redirect notification is arrived. 717 * - the inpcb is unconnected. 718 * - the inpcb is caching !RTF_HOST routing entry. 719 * - the ICMPv6 notification is from the gateway cached in the 720 * inpcb. i.e. ICMPv6 notification is from nexthop gateway 721 * the inpcb used very recently. 722 * 723 * This is to improve interaction between netbsd/openbsd 724 * redirect handling code, and inpcb route cache code. 725 * without the clause, !RTF_HOST routing entry (which carries 726 * gateway used by inpcb right before the ICMPv6 redirect) 727 * will be cached forever in unconnected inpcb. 728 * 729 * There still is a question regarding to what is TRT: 730 * - On bsdi/freebsd, RTF_HOST (cloned) routing entry will be 731 * generated on packet output. inpcb will always cache 732 * RTF_HOST routing entry so there's no need for the clause 733 * (ICMPv6 redirect will update RTF_HOST routing entry, 734 * and inpcb is caching it already). 735 * However, bsdi/freebsd are vulnerable to local DoS attacks 736 * due to the cloned routing entries. 737 * - Specwise, "destination cache" is mentioned in RFC2461. 738 * Jinmei says that it implies bsdi/freebsd behavior, itojun 739 * is not really convinced. 740 * - Having hiwat/lowat on # of cloned host route (redirect/ 741 * pmtud) may be a good idea. netbsd/openbsd has it. see 742 * icmp6_mtudisc_update(). 743 */ 744 if ((PRC_IS_REDIRECT(cmd) || cmd == PRC_HOSTDEAD) && 745 IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_laddr) && 746 (rt = rtcache_validate(&in6p->in6p_route)) != NULL && 747 !(rt->rt_flags & RTF_HOST)) { 748 const struct sockaddr_in6 *dst6; 749 750 dst6 = (const struct sockaddr_in6 *) 751 rtcache_getdst(&in6p->in6p_route); 752 if (dst6 == NULL) 753 ; 754 else if (IN6_ARE_ADDR_EQUAL(&dst6->sin6_addr, 755 &sa6_dst->sin6_addr)) 756 goto do_notify; 757 } 758 759 /* 760 * If the error designates a new path MTU for a destination 761 * and the application (associated with this socket) wanted to 762 * know the value, notify. Note that we notify for all 763 * disconnected sockets if the corresponding application 764 * wanted. This is because some UDP applications keep sending 765 * sockets disconnected. 766 * XXX: should we avoid to notify the value to TCP sockets? 767 */ 768 if (cmd == PRC_MSGSIZE && (in6p->in6p_flags & IN6P_MTU) != 0 && 769 (IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_faddr) || 770 IN6_ARE_ADDR_EQUAL(&in6p->in6p_faddr, &sa6_dst->sin6_addr))) { 771 ip6_notify_pmtu(in6p, (const struct sockaddr_in6 *)dst, 772 (u_int32_t *)cmdarg); 773 } 774 775 /* 776 * Detect if we should notify the error. If no source and 777 * destination ports are specified, but non-zero flowinfo and 778 * local address match, notify the error. This is the case 779 * when the error is delivered with an encrypted buffer 780 * by ESP. Otherwise, just compare addresses and ports 781 * as usual. 782 */ 783 if (lport == 0 && fport == 0 && flowinfo && 784 in6p->in6p_socket != NULL && 785 flowinfo == (in6p->in6p_flowinfo & IPV6_FLOWLABEL_MASK) && 786 IN6_ARE_ADDR_EQUAL(&in6p->in6p_laddr, &sa6_src.sin6_addr)) 787 goto do_notify; 788 else if (!IN6_ARE_ADDR_EQUAL(&in6p->in6p_faddr, 789 &sa6_dst->sin6_addr) || 790 in6p->in6p_socket == 0 || 791 (lport && in6p->in6p_lport != lport) || 792 (!IN6_IS_ADDR_UNSPECIFIED(&sa6_src.sin6_addr) && 793 !IN6_ARE_ADDR_EQUAL(&in6p->in6p_laddr, 794 &sa6_src.sin6_addr)) || 795 (fport && in6p->in6p_fport != fport)) 796 continue; 797 798 do_notify: 799 if (notify) 800 (*notify)(in6p, errno); 801 nmatch++; 802 } 803 return nmatch; 804 } 805 806 void 807 in6_pcbpurgeif0(struct inpcbtable *table, struct ifnet *ifp) 808 { 809 struct in6pcb *in6p, *nin6p; 810 struct ip6_moptions *im6o; 811 struct in6_multi_mship *imm, *nimm; 812 813 for (in6p = (struct in6pcb *)CIRCLEQ_FIRST(&table->inpt_queue); 814 in6p != (void *)&table->inpt_queue; 815 in6p = nin6p) { 816 nin6p = (struct in6pcb *)CIRCLEQ_NEXT(in6p, in6p_queue); 817 if (in6p->in6p_af != AF_INET6) 818 continue; 819 820 im6o = in6p->in6p_moptions; 821 if (im6o) { 822 /* 823 * Unselect the outgoing interface if it is being 824 * detached. 825 */ 826 if (im6o->im6o_multicast_ifp == ifp) 827 im6o->im6o_multicast_ifp = NULL; 828 829 /* 830 * Drop multicast group membership if we joined 831 * through the interface being detached. 832 * XXX controversial - is it really legal for kernel 833 * to force this? 834 */ 835 for (imm = im6o->im6o_memberships.lh_first; 836 imm != NULL; imm = nimm) { 837 nimm = imm->i6mm_chain.le_next; 838 if (imm->i6mm_maddr->in6m_ifp == ifp) { 839 LIST_REMOVE(imm, i6mm_chain); 840 in6_leavegroup(imm); 841 } 842 } 843 } 844 } 845 } 846 847 void 848 in6_pcbpurgeif(struct inpcbtable *table, struct ifnet *ifp) 849 { 850 struct rtentry *rt; 851 struct in6pcb *in6p, *nin6p; 852 853 for (in6p = (struct in6pcb *)CIRCLEQ_FIRST(&table->inpt_queue); 854 in6p != (void *)&table->inpt_queue; 855 in6p = nin6p) { 856 nin6p = (struct in6pcb *)CIRCLEQ_NEXT(in6p, in6p_queue); 857 if (in6p->in6p_af != AF_INET6) 858 continue; 859 if ((rt = rtcache_validate(&in6p->in6p_route)) != NULL && 860 rt->rt_ifp == ifp) 861 in6_rtchange(in6p, 0); 862 } 863 } 864 865 /* 866 * Check for alternatives when higher level complains 867 * about service problems. For now, invalidate cached 868 * routing information. If the route was created dynamically 869 * (by a redirect), time to try a default gateway again. 870 */ 871 void 872 in6_losing(struct in6pcb *in6p) 873 { 874 struct rtentry *rt; 875 struct rt_addrinfo info; 876 877 if (in6p->in6p_af != AF_INET6) 878 return; 879 880 if ((rt = rtcache_validate(&in6p->in6p_route)) == NULL) 881 return; 882 883 memset(&info, 0, sizeof(info)); 884 info.rti_info[RTAX_DST] = rtcache_getdst(&in6p->in6p_route); 885 info.rti_info[RTAX_GATEWAY] = rt->rt_gateway; 886 info.rti_info[RTAX_NETMASK] = rt_mask(rt); 887 rt_missmsg(RTM_LOSING, &info, rt->rt_flags, 0); 888 if (rt->rt_flags & RTF_DYNAMIC) { 889 (void)rtrequest(RTM_DELETE, rt_getkey(rt), 890 rt->rt_gateway, rt_mask(rt), rt->rt_flags, NULL); 891 } 892 /* 893 * A new route can be allocated 894 * the next time output is attempted. 895 */ 896 rtcache_free(&in6p->in6p_route); 897 } 898 899 /* 900 * After a routing change, flush old routing. A new route can be 901 * allocated the next time output is attempted. 902 */ 903 void 904 in6_rtchange(struct in6pcb *in6p, int errno) 905 { 906 if (in6p->in6p_af != AF_INET6) 907 return; 908 909 rtcache_free(&in6p->in6p_route); 910 /* 911 * A new route can be allocated the next time 912 * output is attempted. 913 */ 914 } 915 916 struct in6pcb * 917 in6_pcblookup_port(struct inpcbtable *table, struct in6_addr *laddr6, 918 u_int lport_arg, int lookup_wildcard, struct vestigial_inpcb *vp) 919 { 920 struct inpcbhead *head; 921 struct inpcb_hdr *inph; 922 struct in6pcb *in6p, *match = 0; 923 int matchwild = 3, wildcard; 924 u_int16_t lport = lport_arg; 925 926 if (vp) 927 vp->valid = 0; 928 929 head = IN6PCBHASH_PORT(table, lport); 930 LIST_FOREACH(inph, head, inph_lhash) { 931 in6p = (struct in6pcb *)inph; 932 if (in6p->in6p_af != AF_INET6) 933 continue; 934 935 if (in6p->in6p_lport != lport) 936 continue; 937 wildcard = 0; 938 if (IN6_IS_ADDR_V4MAPPED(&in6p->in6p_faddr)) { 939 if ((in6p->in6p_flags & IN6P_IPV6_V6ONLY) != 0) 940 continue; 941 } 942 if (!IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_faddr)) 943 wildcard++; 944 if (IN6_IS_ADDR_V4MAPPED(&in6p->in6p_laddr)) { 945 if ((in6p->in6p_flags & IN6P_IPV6_V6ONLY) != 0) 946 continue; 947 if (!IN6_IS_ADDR_V4MAPPED(laddr6)) 948 continue; 949 950 /* duplicate of IPv4 logic */ 951 wildcard = 0; 952 if (IN6_IS_ADDR_V4MAPPED(&in6p->in6p_faddr) && 953 in6p->in6p_faddr.s6_addr32[3]) 954 wildcard++; 955 if (!in6p->in6p_laddr.s6_addr32[3]) { 956 if (laddr6->s6_addr32[3]) 957 wildcard++; 958 } else { 959 if (!laddr6->s6_addr32[3]) 960 wildcard++; 961 else { 962 if (in6p->in6p_laddr.s6_addr32[3] != 963 laddr6->s6_addr32[3]) 964 continue; 965 } 966 } 967 } else if (IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_laddr)) { 968 if (IN6_IS_ADDR_V4MAPPED(laddr6)) { 969 if ((in6p->in6p_flags & IN6P_IPV6_V6ONLY) != 0) 970 continue; 971 } 972 if (!IN6_IS_ADDR_UNSPECIFIED(laddr6)) 973 wildcard++; 974 } else { 975 if (IN6_IS_ADDR_V4MAPPED(laddr6)) { 976 if ((in6p->in6p_flags & IN6P_IPV6_V6ONLY) != 0) 977 continue; 978 } 979 if (IN6_IS_ADDR_UNSPECIFIED(laddr6)) 980 wildcard++; 981 else { 982 if (!IN6_ARE_ADDR_EQUAL(&in6p->in6p_laddr, 983 laddr6)) 984 continue; 985 } 986 } 987 if (wildcard && !lookup_wildcard) 988 continue; 989 if (wildcard < matchwild) { 990 match = in6p; 991 matchwild = wildcard; 992 if (matchwild == 0) 993 break; 994 } 995 } 996 if (match && matchwild == 0) 997 return match; 998 999 if (vp && table->vestige && table->vestige->init_ports6) { 1000 struct vestigial_inpcb better; 1001 void *state; 1002 1003 state = (*table->vestige->init_ports6)(laddr6, 1004 lport_arg, 1005 lookup_wildcard); 1006 while (table->vestige 1007 && (*table->vestige->next_port6)(state, vp)) { 1008 1009 if (vp->lport != lport) 1010 continue; 1011 wildcard = 0; 1012 if (!IN6_IS_ADDR_UNSPECIFIED(&vp->faddr.v6)) 1013 wildcard++; 1014 if (IN6_IS_ADDR_UNSPECIFIED(&vp->laddr.v6)) { 1015 if (!IN6_IS_ADDR_UNSPECIFIED(laddr6)) 1016 wildcard++; 1017 } else { 1018 if (IN6_IS_ADDR_V4MAPPED(laddr6)) { 1019 if (vp->v6only) 1020 continue; 1021 } 1022 if (IN6_IS_ADDR_UNSPECIFIED(laddr6)) 1023 wildcard++; 1024 else { 1025 if (!IN6_ARE_ADDR_EQUAL(&vp->laddr.v6, laddr6)) 1026 continue; 1027 } 1028 } 1029 if (wildcard && !lookup_wildcard) 1030 continue; 1031 if (wildcard < matchwild) { 1032 better = *vp; 1033 match = (void*)&better; 1034 1035 matchwild = wildcard; 1036 if (matchwild == 0) 1037 break; 1038 } 1039 } 1040 1041 if (match) { 1042 if (match != (void*)&better) 1043 return match; 1044 else { 1045 *vp = better; 1046 return 0; 1047 } 1048 } 1049 } 1050 return (match); 1051 } 1052 1053 /* 1054 * WARNING: return value (rtentry) could be IPv4 one if in6pcb is connected to 1055 * IPv4 mapped address. 1056 */ 1057 struct rtentry * 1058 in6_pcbrtentry(struct in6pcb *in6p) 1059 { 1060 struct rtentry *rt; 1061 struct route *ro; 1062 union { 1063 const struct sockaddr *sa; 1064 const struct sockaddr_in6 *sa6; 1065 #ifdef INET 1066 const struct sockaddr_in *sa4; 1067 #endif 1068 } cdst; 1069 1070 ro = &in6p->in6p_route; 1071 1072 if (in6p->in6p_af != AF_INET6) 1073 return (NULL); 1074 1075 cdst.sa = rtcache_getdst(ro); 1076 if (cdst.sa == NULL) 1077 ; 1078 #ifdef INET 1079 else if (cdst.sa->sa_family == AF_INET) { 1080 KASSERT(IN6_IS_ADDR_V4MAPPED(&in6p->in6p_faddr)); 1081 if (cdst.sa4->sin_addr.s_addr != in6p->in6p_faddr.s6_addr32[3]) 1082 rtcache_free(ro); 1083 } 1084 #endif 1085 else { 1086 if (!IN6_ARE_ADDR_EQUAL(&cdst.sa6->sin6_addr, 1087 &in6p->in6p_faddr)) 1088 rtcache_free(ro); 1089 } 1090 if ((rt = rtcache_validate(ro)) == NULL) 1091 rt = rtcache_update(ro, 1); 1092 #ifdef INET 1093 if (rt == NULL && IN6_IS_ADDR_V4MAPPED(&in6p->in6p_faddr)) { 1094 union { 1095 struct sockaddr dst; 1096 struct sockaddr_in dst4; 1097 } u; 1098 struct in_addr addr; 1099 1100 addr.s_addr = in6p->in6p_faddr.s6_addr32[3]; 1101 1102 sockaddr_in_init(&u.dst4, &addr, 0); 1103 rtcache_setdst(ro, &u.dst); 1104 1105 rt = rtcache_init(ro); 1106 } else 1107 #endif 1108 if (rt == NULL && !IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_faddr)) { 1109 union { 1110 struct sockaddr dst; 1111 struct sockaddr_in6 dst6; 1112 } u; 1113 1114 sockaddr_in6_init(&u.dst6, &in6p->in6p_faddr, 0, 0, 0); 1115 rtcache_setdst(ro, &u.dst); 1116 1117 rt = rtcache_init(ro); 1118 } 1119 return rt; 1120 } 1121 1122 struct in6pcb * 1123 in6_pcblookup_connect(struct inpcbtable *table, const struct in6_addr *faddr6, 1124 u_int fport_arg, const struct in6_addr *laddr6, u_int lport_arg, 1125 int faith, 1126 struct vestigial_inpcb *vp) 1127 { 1128 struct inpcbhead *head; 1129 struct inpcb_hdr *inph; 1130 struct in6pcb *in6p; 1131 u_int16_t fport = fport_arg, lport = lport_arg; 1132 1133 if (vp) 1134 vp->valid = 0; 1135 1136 head = IN6PCBHASH_CONNECT(table, faddr6, fport, laddr6, lport); 1137 LIST_FOREACH(inph, head, inph_hash) { 1138 in6p = (struct in6pcb *)inph; 1139 if (in6p->in6p_af != AF_INET6) 1140 continue; 1141 1142 /* find exact match on both source and dest */ 1143 if (in6p->in6p_fport != fport) 1144 continue; 1145 if (in6p->in6p_lport != lport) 1146 continue; 1147 if (IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_faddr)) 1148 continue; 1149 if (!IN6_ARE_ADDR_EQUAL(&in6p->in6p_faddr, faddr6)) 1150 continue; 1151 if (IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_laddr)) 1152 continue; 1153 if (!IN6_ARE_ADDR_EQUAL(&in6p->in6p_laddr, laddr6)) 1154 continue; 1155 if ((IN6_IS_ADDR_V4MAPPED(laddr6) || 1156 IN6_IS_ADDR_V4MAPPED(faddr6)) && 1157 (in6p->in6p_flags & IN6P_IPV6_V6ONLY)) 1158 continue; 1159 return in6p; 1160 } 1161 if (vp && table->vestige) { 1162 if ((*table->vestige->lookup6)(faddr6, fport_arg, 1163 laddr6, lport_arg, vp)) 1164 return 0; 1165 } 1166 1167 return NULL; 1168 } 1169 1170 struct in6pcb * 1171 in6_pcblookup_bind(struct inpcbtable *table, const struct in6_addr *laddr6, 1172 u_int lport_arg, int faith) 1173 { 1174 struct inpcbhead *head; 1175 struct inpcb_hdr *inph; 1176 struct in6pcb *in6p; 1177 u_int16_t lport = lport_arg; 1178 #ifdef INET 1179 struct in6_addr zero_mapped; 1180 #endif 1181 1182 head = IN6PCBHASH_BIND(table, laddr6, lport); 1183 LIST_FOREACH(inph, head, inph_hash) { 1184 in6p = (struct in6pcb *)inph; 1185 if (in6p->in6p_af != AF_INET6) 1186 continue; 1187 1188 if (faith && (in6p->in6p_flags & IN6P_FAITH) == 0) 1189 continue; 1190 if (in6p->in6p_fport != 0) 1191 continue; 1192 if (in6p->in6p_lport != lport) 1193 continue; 1194 if (IN6_IS_ADDR_V4MAPPED(laddr6) && 1195 (in6p->in6p_flags & IN6P_IPV6_V6ONLY) != 0) 1196 continue; 1197 if (IN6_ARE_ADDR_EQUAL(&in6p->in6p_laddr, laddr6)) 1198 goto out; 1199 } 1200 #ifdef INET 1201 if (IN6_IS_ADDR_V4MAPPED(laddr6)) { 1202 memset(&zero_mapped, 0, sizeof(zero_mapped)); 1203 zero_mapped.s6_addr16[5] = 0xffff; 1204 head = IN6PCBHASH_BIND(table, &zero_mapped, lport); 1205 LIST_FOREACH(inph, head, inph_hash) { 1206 in6p = (struct in6pcb *)inph; 1207 if (in6p->in6p_af != AF_INET6) 1208 continue; 1209 1210 if (faith && (in6p->in6p_flags & IN6P_FAITH) == 0) 1211 continue; 1212 if (in6p->in6p_fport != 0) 1213 continue; 1214 if (in6p->in6p_lport != lport) 1215 continue; 1216 if ((in6p->in6p_flags & IN6P_IPV6_V6ONLY) != 0) 1217 continue; 1218 if (IN6_ARE_ADDR_EQUAL(&in6p->in6p_laddr, &zero_mapped)) 1219 goto out; 1220 } 1221 } 1222 #endif 1223 head = IN6PCBHASH_BIND(table, &zeroin6_addr, lport); 1224 LIST_FOREACH(inph, head, inph_hash) { 1225 in6p = (struct in6pcb *)inph; 1226 if (in6p->in6p_af != AF_INET6) 1227 continue; 1228 1229 if (faith && (in6p->in6p_flags & IN6P_FAITH) == 0) 1230 continue; 1231 if (in6p->in6p_fport != 0) 1232 continue; 1233 if (in6p->in6p_lport != lport) 1234 continue; 1235 if (IN6_IS_ADDR_V4MAPPED(laddr6) && 1236 (in6p->in6p_flags & IN6P_IPV6_V6ONLY) != 0) 1237 continue; 1238 if (IN6_ARE_ADDR_EQUAL(&in6p->in6p_laddr, &zeroin6_addr)) 1239 goto out; 1240 } 1241 return (NULL); 1242 1243 out: 1244 inph = &in6p->in6p_head; 1245 if (inph != LIST_FIRST(head)) { 1246 LIST_REMOVE(inph, inph_hash); 1247 LIST_INSERT_HEAD(head, inph, inph_hash); 1248 } 1249 return in6p; 1250 } 1251 1252 void 1253 in6_pcbstate(struct in6pcb *in6p, int state) 1254 { 1255 1256 if (in6p->in6p_af != AF_INET6) 1257 return; 1258 1259 if (in6p->in6p_state > IN6P_ATTACHED) 1260 LIST_REMOVE(&in6p->in6p_head, inph_hash); 1261 1262 switch (state) { 1263 case IN6P_BOUND: 1264 LIST_INSERT_HEAD(IN6PCBHASH_BIND(in6p->in6p_table, 1265 &in6p->in6p_laddr, in6p->in6p_lport), &in6p->in6p_head, 1266 inph_hash); 1267 break; 1268 case IN6P_CONNECTED: 1269 LIST_INSERT_HEAD(IN6PCBHASH_CONNECT(in6p->in6p_table, 1270 &in6p->in6p_faddr, in6p->in6p_fport, 1271 &in6p->in6p_laddr, in6p->in6p_lport), &in6p->in6p_head, 1272 inph_hash); 1273 break; 1274 } 1275 1276 in6p->in6p_state = state; 1277 } 1278