1 /*- 2 * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project. 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. Neither the name of the project nor the names of its contributors 14 * may be used to endorse or promote products derived from this software 15 * without specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 */ 29 30 /*- 31 * Copyright (c) 1982, 1986, 1988, 1993 32 * The Regents of the University of California. 33 * All rights reserved. 34 * 35 * Redistribution and use in source and binary forms, with or without 36 * modification, are permitted provided that the following conditions 37 * are met: 38 * 1. Redistributions of source code must retain the above copyright 39 * notice, this list of conditions and the following disclaimer. 40 * 2. Redistributions in binary form must reproduce the above copyright 41 * notice, this list of conditions and the following disclaimer in the 42 * documentation and/or other materials provided with the distribution. 43 * 4. Neither the name of the University nor the names of its contributors 44 * may be used to endorse or promote products derived from this software 45 * without specific prior written permission. 46 * 47 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 48 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 49 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 50 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 51 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 52 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 53 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 54 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 55 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 56 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 57 * SUCH DAMAGE. 58 * 59 * @(#)raw_ip.c 8.2 (Berkeley) 1/4/94 60 */ 61 62 #include <sys/cdefs.h> 63 __FBSDID("$FreeBSD$"); 64 65 #include "opt_ipsec.h" 66 #include "opt_inet6.h" 67 #include "opt_route.h" 68 69 #include <sys/param.h> 70 #include <sys/errno.h> 71 #include <sys/jail.h> 72 #include <sys/lock.h> 73 #include <sys/malloc.h> 74 #include <sys/mbuf.h> 75 #include <sys/priv.h> 76 #include <sys/proc.h> 77 #include <sys/protosw.h> 78 #include <sys/signalvar.h> 79 #include <sys/socket.h> 80 #include <sys/socketvar.h> 81 #include <sys/sx.h> 82 #include <sys/syslog.h> 83 #include <sys/vimage.h> 84 85 #include <net/if.h> 86 #include <net/if_types.h> 87 #include <net/route.h> 88 #include <net/vnet.h> 89 90 #include <netinet/in.h> 91 #include <netinet/in_var.h> 92 #include <netinet/in_systm.h> 93 #include <netinet/in_pcb.h> 94 #include <netinet/vinet.h> 95 96 #include <netinet/icmp6.h> 97 #include <netinet/ip6.h> 98 #include <netinet6/ip6protosw.h> 99 #include <netinet6/ip6_mroute.h> 100 #include <netinet6/in6_pcb.h> 101 #include <netinet6/ip6_var.h> 102 #include <netinet6/nd6.h> 103 #include <netinet6/raw_ip6.h> 104 #include <netinet6/scope6_var.h> 105 #include <netinet6/vinet6.h> 106 107 #ifdef IPSEC 108 #include <netipsec/ipsec.h> 109 #include <netipsec/ipsec6.h> 110 #endif /* IPSEC */ 111 112 #include <machine/stdarg.h> 113 114 #define satosin6(sa) ((struct sockaddr_in6 *)(sa)) 115 #define ifatoia6(ifa) ((struct in6_ifaddr *)(ifa)) 116 117 /* 118 * Raw interface to IP6 protocol. 119 */ 120 121 #ifdef VIMAGE_GLOBALS 122 extern struct inpcbhead ripcb; 123 extern struct inpcbinfo ripcbinfo; 124 struct rip6stat rip6stat; 125 #endif 126 127 extern u_long rip_sendspace; 128 extern u_long rip_recvspace; 129 130 /* 131 * Hooks for multicast forwarding. 132 */ 133 struct socket *ip6_mrouter = NULL; 134 int (*ip6_mrouter_set)(struct socket *, struct sockopt *); 135 int (*ip6_mrouter_get)(struct socket *, struct sockopt *); 136 int (*ip6_mrouter_done)(void); 137 int (*ip6_mforward)(struct ip6_hdr *, struct ifnet *, struct mbuf *); 138 int (*mrt6_ioctl)(int, caddr_t); 139 140 /* 141 * Setup generic address and protocol structures for raw_input routine, then 142 * pass them along with mbuf chain. 143 */ 144 int 145 rip6_input(struct mbuf **mp, int *offp, int proto) 146 { 147 INIT_VNET_INET(curvnet); 148 INIT_VNET_INET6(curvnet); 149 #ifdef IPSEC 150 INIT_VNET_IPSEC(curvnet); 151 #endif 152 struct mbuf *m = *mp; 153 register struct ip6_hdr *ip6 = mtod(m, struct ip6_hdr *); 154 register struct inpcb *in6p; 155 struct inpcb *last = 0; 156 struct mbuf *opts = NULL; 157 struct sockaddr_in6 fromsa; 158 159 V_rip6stat.rip6s_ipackets++; 160 161 if (faithprefix_p != NULL && (*faithprefix_p)(&ip6->ip6_dst)) { 162 /* XXX Send icmp6 host/port unreach? */ 163 m_freem(m); 164 return (IPPROTO_DONE); 165 } 166 167 init_sin6(&fromsa, m); /* general init */ 168 169 INP_INFO_RLOCK(&V_ripcbinfo); 170 LIST_FOREACH(in6p, &V_ripcb, inp_list) { 171 /* XXX inp locking */ 172 if ((in6p->inp_vflag & INP_IPV6) == 0) 173 continue; 174 if (in6p->inp_ip_p && 175 in6p->inp_ip_p != proto) 176 continue; 177 if (!IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_laddr) && 178 !IN6_ARE_ADDR_EQUAL(&in6p->in6p_laddr, &ip6->ip6_dst)) 179 continue; 180 if (!IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_faddr) && 181 !IN6_ARE_ADDR_EQUAL(&in6p->in6p_faddr, &ip6->ip6_src)) 182 continue; 183 if (prison_check_ip6(in6p->inp_cred, &ip6->ip6_dst) != 0) 184 continue; 185 INP_RLOCK(in6p); 186 if (in6p->in6p_cksum != -1) { 187 V_rip6stat.rip6s_isum++; 188 if (in6_cksum(m, proto, *offp, 189 m->m_pkthdr.len - *offp)) { 190 INP_RUNLOCK(in6p); 191 V_rip6stat.rip6s_badsum++; 192 continue; 193 } 194 } 195 if (last != NULL) { 196 struct mbuf *n = m_copy(m, 0, (int)M_COPYALL); 197 198 #ifdef IPSEC 199 /* 200 * Check AH/ESP integrity. 201 */ 202 if (n && ipsec6_in_reject(n, last)) { 203 m_freem(n); 204 V_ipsec6stat.in_polvio++; 205 /* Do not inject data into pcb. */ 206 } else 207 #endif /* IPSEC */ 208 if (n) { 209 if (last->inp_flags & INP_CONTROLOPTS || 210 last->inp_socket->so_options & SO_TIMESTAMP) 211 ip6_savecontrol(last, n, &opts); 212 /* strip intermediate headers */ 213 m_adj(n, *offp); 214 if (sbappendaddr(&last->inp_socket->so_rcv, 215 (struct sockaddr *)&fromsa, 216 n, opts) == 0) { 217 m_freem(n); 218 if (opts) 219 m_freem(opts); 220 V_rip6stat.rip6s_fullsock++; 221 } else 222 sorwakeup(last->inp_socket); 223 opts = NULL; 224 } 225 INP_RUNLOCK(last); 226 } 227 last = in6p; 228 } 229 INP_INFO_RUNLOCK(&V_ripcbinfo); 230 #ifdef IPSEC 231 /* 232 * Check AH/ESP integrity. 233 */ 234 if ((last != NULL) && ipsec6_in_reject(m, last)) { 235 m_freem(m); 236 V_ipsec6stat.in_polvio++; 237 V_ip6stat.ip6s_delivered--; 238 /* Do not inject data into pcb. */ 239 INP_RUNLOCK(last); 240 } else 241 #endif /* IPSEC */ 242 if (last != NULL) { 243 if (last->inp_flags & INP_CONTROLOPTS || 244 last->inp_socket->so_options & SO_TIMESTAMP) 245 ip6_savecontrol(last, m, &opts); 246 /* Strip intermediate headers. */ 247 m_adj(m, *offp); 248 if (sbappendaddr(&last->inp_socket->so_rcv, 249 (struct sockaddr *)&fromsa, m, opts) == 0) { 250 m_freem(m); 251 if (opts) 252 m_freem(opts); 253 V_rip6stat.rip6s_fullsock++; 254 } else 255 sorwakeup(last->inp_socket); 256 INP_RUNLOCK(last); 257 } else { 258 V_rip6stat.rip6s_nosock++; 259 if (m->m_flags & M_MCAST) 260 V_rip6stat.rip6s_nosockmcast++; 261 if (proto == IPPROTO_NONE) 262 m_freem(m); 263 else { 264 char *prvnxtp = ip6_get_prevhdr(m, *offp); /* XXX */ 265 icmp6_error(m, ICMP6_PARAM_PROB, 266 ICMP6_PARAMPROB_NEXTHEADER, 267 prvnxtp - mtod(m, char *)); 268 } 269 V_ip6stat.ip6s_delivered--; 270 } 271 return (IPPROTO_DONE); 272 } 273 274 void 275 rip6_ctlinput(int cmd, struct sockaddr *sa, void *d) 276 { 277 INIT_VNET_INET(curvnet); 278 struct ip6_hdr *ip6; 279 struct mbuf *m; 280 int off = 0; 281 struct ip6ctlparam *ip6cp = NULL; 282 const struct sockaddr_in6 *sa6_src = NULL; 283 void *cmdarg; 284 struct inpcb *(*notify)(struct inpcb *, int) = in6_rtchange; 285 286 if (sa->sa_family != AF_INET6 || 287 sa->sa_len != sizeof(struct sockaddr_in6)) 288 return; 289 290 if ((unsigned)cmd >= PRC_NCMDS) 291 return; 292 if (PRC_IS_REDIRECT(cmd)) 293 notify = in6_rtchange, d = NULL; 294 else if (cmd == PRC_HOSTDEAD) 295 d = NULL; 296 else if (inet6ctlerrmap[cmd] == 0) 297 return; 298 299 /* 300 * If the parameter is from icmp6, decode it. 301 */ 302 if (d != NULL) { 303 ip6cp = (struct ip6ctlparam *)d; 304 m = ip6cp->ip6c_m; 305 ip6 = ip6cp->ip6c_ip6; 306 off = ip6cp->ip6c_off; 307 cmdarg = ip6cp->ip6c_cmdarg; 308 sa6_src = ip6cp->ip6c_src; 309 } else { 310 m = NULL; 311 ip6 = NULL; 312 cmdarg = NULL; 313 sa6_src = &sa6_any; 314 } 315 316 (void) in6_pcbnotify(&V_ripcbinfo, sa, 0, 317 (const struct sockaddr *)sa6_src, 0, cmd, cmdarg, notify); 318 } 319 320 /* 321 * Generate IPv6 header and pass packet to ip6_output. Tack on options user 322 * may have setup with control call. 323 */ 324 int 325 #if __STDC__ 326 rip6_output(struct mbuf *m, ...) 327 #else 328 rip6_output(m, va_alist) 329 struct mbuf *m; 330 va_dcl 331 #endif 332 { 333 INIT_VNET_INET6(curvnet); 334 struct mbuf *control; 335 struct socket *so; 336 struct sockaddr_in6 *dstsock; 337 struct in6_addr *dst; 338 struct ip6_hdr *ip6; 339 struct inpcb *in6p; 340 u_int plen = m->m_pkthdr.len; 341 int error = 0; 342 struct ip6_pktopts opt, *optp; 343 struct ifnet *oifp = NULL; 344 int type = 0, code = 0; /* for ICMPv6 output statistics only */ 345 int scope_ambiguous = 0; 346 struct in6_addr *in6a; 347 va_list ap; 348 349 va_start(ap, m); 350 so = va_arg(ap, struct socket *); 351 dstsock = va_arg(ap, struct sockaddr_in6 *); 352 control = va_arg(ap, struct mbuf *); 353 va_end(ap); 354 355 in6p = sotoinpcb(so); 356 INP_WLOCK(in6p); 357 358 dst = &dstsock->sin6_addr; 359 if (control != NULL) { 360 if ((error = ip6_setpktopts(control, &opt, 361 in6p->in6p_outputopts, so->so_cred, 362 so->so_proto->pr_protocol)) != 0) { 363 goto bad; 364 } 365 optp = &opt; 366 } else 367 optp = in6p->in6p_outputopts; 368 369 /* 370 * Check and convert scope zone ID into internal form. 371 * 372 * XXX: we may still need to determine the zone later. 373 */ 374 if (!(so->so_state & SS_ISCONNECTED)) { 375 if (dstsock->sin6_scope_id == 0 && !V_ip6_use_defzone) 376 scope_ambiguous = 1; 377 if ((error = sa6_embedscope(dstsock, V_ip6_use_defzone)) != 0) 378 goto bad; 379 } 380 381 /* 382 * For an ICMPv6 packet, we should know its type and code to update 383 * statistics. 384 */ 385 if (so->so_proto->pr_protocol == IPPROTO_ICMPV6) { 386 struct icmp6_hdr *icmp6; 387 if (m->m_len < sizeof(struct icmp6_hdr) && 388 (m = m_pullup(m, sizeof(struct icmp6_hdr))) == NULL) { 389 error = ENOBUFS; 390 goto bad; 391 } 392 icmp6 = mtod(m, struct icmp6_hdr *); 393 type = icmp6->icmp6_type; 394 code = icmp6->icmp6_code; 395 } 396 397 M_PREPEND(m, sizeof(*ip6), M_DONTWAIT); 398 if (m == NULL) { 399 error = ENOBUFS; 400 goto bad; 401 } 402 ip6 = mtod(m, struct ip6_hdr *); 403 404 /* 405 * Source address selection. 406 */ 407 if ((in6a = in6_selectsrc(dstsock, optp, in6p, NULL, so->so_cred, 408 &oifp, &error)) == NULL) { 409 if (error == 0) 410 error = EADDRNOTAVAIL; 411 goto bad; 412 } 413 error = prison_get_ip6(in6p->inp_cred, in6a); 414 if (error != 0) 415 goto bad; 416 ip6->ip6_src = *in6a; 417 418 if (oifp && scope_ambiguous) { 419 /* 420 * Application should provide a proper zone ID or the use of 421 * default zone IDs should be enabled. Unfortunately, some 422 * applications do not behave as it should, so we need a 423 * workaround. Even if an appropriate ID is not determined 424 * (when it's required), if we can determine the outgoing 425 * interface. determine the zone ID based on the interface. 426 */ 427 error = in6_setscope(&dstsock->sin6_addr, oifp, NULL); 428 if (error != 0) 429 goto bad; 430 } 431 ip6->ip6_dst = dstsock->sin6_addr; 432 433 /* 434 * Fill in the rest of the IPv6 header fields. 435 */ 436 ip6->ip6_flow = (ip6->ip6_flow & ~IPV6_FLOWINFO_MASK) | 437 (in6p->inp_flow & IPV6_FLOWINFO_MASK); 438 ip6->ip6_vfc = (ip6->ip6_vfc & ~IPV6_VERSION_MASK) | 439 (IPV6_VERSION & IPV6_VERSION_MASK); 440 441 /* 442 * ip6_plen will be filled in ip6_output, so not fill it here. 443 */ 444 ip6->ip6_nxt = in6p->inp_ip_p; 445 ip6->ip6_hlim = in6_selecthlim(in6p, oifp); 446 447 if (so->so_proto->pr_protocol == IPPROTO_ICMPV6 || 448 in6p->in6p_cksum != -1) { 449 struct mbuf *n; 450 int off; 451 u_int16_t *p; 452 453 /* Compute checksum. */ 454 if (so->so_proto->pr_protocol == IPPROTO_ICMPV6) 455 off = offsetof(struct icmp6_hdr, icmp6_cksum); 456 else 457 off = in6p->in6p_cksum; 458 if (plen < off + 1) { 459 error = EINVAL; 460 goto bad; 461 } 462 off += sizeof(struct ip6_hdr); 463 464 n = m; 465 while (n && n->m_len <= off) { 466 off -= n->m_len; 467 n = n->m_next; 468 } 469 if (!n) 470 goto bad; 471 p = (u_int16_t *)(mtod(n, caddr_t) + off); 472 *p = 0; 473 *p = in6_cksum(m, ip6->ip6_nxt, sizeof(*ip6), plen); 474 } 475 476 error = ip6_output(m, optp, NULL, 0, in6p->in6p_moptions, &oifp, in6p); 477 if (so->so_proto->pr_protocol == IPPROTO_ICMPV6) { 478 if (oifp) 479 icmp6_ifoutstat_inc(oifp, type, code); 480 ICMP6STAT_INC(icp6s_outhist[type]); 481 } else 482 V_rip6stat.rip6s_opackets++; 483 484 goto freectl; 485 486 bad: 487 if (m) 488 m_freem(m); 489 490 freectl: 491 if (control != NULL) { 492 ip6_clearpktopts(&opt, -1); 493 m_freem(control); 494 } 495 INP_WUNLOCK(in6p); 496 return (error); 497 } 498 499 /* 500 * Raw IPv6 socket option processing. 501 */ 502 int 503 rip6_ctloutput(struct socket *so, struct sockopt *sopt) 504 { 505 int error; 506 507 if (sopt->sopt_level == IPPROTO_ICMPV6) 508 /* 509 * XXX: is it better to call icmp6_ctloutput() directly 510 * from protosw? 511 */ 512 return (icmp6_ctloutput(so, sopt)); 513 else if (sopt->sopt_level != IPPROTO_IPV6) 514 return (EINVAL); 515 516 error = 0; 517 518 switch (sopt->sopt_dir) { 519 case SOPT_GET: 520 switch (sopt->sopt_name) { 521 case MRT6_INIT: 522 case MRT6_DONE: 523 case MRT6_ADD_MIF: 524 case MRT6_DEL_MIF: 525 case MRT6_ADD_MFC: 526 case MRT6_DEL_MFC: 527 case MRT6_PIM: 528 error = ip6_mrouter_get ? ip6_mrouter_get(so, sopt) : 529 EOPNOTSUPP; 530 break; 531 case IPV6_CHECKSUM: 532 error = ip6_raw_ctloutput(so, sopt); 533 break; 534 default: 535 error = ip6_ctloutput(so, sopt); 536 break; 537 } 538 break; 539 540 case SOPT_SET: 541 switch (sopt->sopt_name) { 542 case MRT6_INIT: 543 case MRT6_DONE: 544 case MRT6_ADD_MIF: 545 case MRT6_DEL_MIF: 546 case MRT6_ADD_MFC: 547 case MRT6_DEL_MFC: 548 case MRT6_PIM: 549 error = ip6_mrouter_set ? ip6_mrouter_set(so, sopt) : 550 EOPNOTSUPP; 551 break; 552 case IPV6_CHECKSUM: 553 error = ip6_raw_ctloutput(so, sopt); 554 break; 555 default: 556 error = ip6_ctloutput(so, sopt); 557 break; 558 } 559 break; 560 } 561 562 return (error); 563 } 564 565 static int 566 rip6_attach(struct socket *so, int proto, struct thread *td) 567 { 568 INIT_VNET_INET(so->so_vnet); 569 struct inpcb *inp; 570 struct icmp6_filter *filter; 571 int error; 572 573 inp = sotoinpcb(so); 574 KASSERT(inp == NULL, ("rip6_attach: inp != NULL")); 575 576 error = priv_check(td, PRIV_NETINET_RAW); 577 if (error) 578 return (error); 579 error = soreserve(so, rip_sendspace, rip_recvspace); 580 if (error) 581 return (error); 582 filter = malloc(sizeof(struct icmp6_filter), M_PCB, M_NOWAIT); 583 if (filter == NULL) 584 return (ENOMEM); 585 INP_INFO_WLOCK(&V_ripcbinfo); 586 error = in_pcballoc(so, &V_ripcbinfo); 587 if (error) { 588 INP_INFO_WUNLOCK(&V_ripcbinfo); 589 free(filter, M_PCB); 590 return (error); 591 } 592 inp = (struct inpcb *)so->so_pcb; 593 INP_INFO_WUNLOCK(&V_ripcbinfo); 594 inp->inp_vflag |= INP_IPV6; 595 inp->inp_ip_p = (long)proto; 596 inp->in6p_hops = -1; /* use kernel default */ 597 inp->in6p_cksum = -1; 598 inp->in6p_icmp6filt = filter; 599 ICMP6_FILTER_SETPASSALL(inp->in6p_icmp6filt); 600 INP_WUNLOCK(inp); 601 return (0); 602 } 603 604 static void 605 rip6_detach(struct socket *so) 606 { 607 INIT_VNET_INET(so->so_vnet); 608 struct inpcb *inp; 609 610 inp = sotoinpcb(so); 611 KASSERT(inp != NULL, ("rip6_detach: inp == NULL")); 612 613 if (so == ip6_mrouter && ip6_mrouter_done) 614 ip6_mrouter_done(); 615 /* xxx: RSVP */ 616 INP_INFO_WLOCK(&V_ripcbinfo); 617 INP_WLOCK(inp); 618 free(inp->in6p_icmp6filt, M_PCB); 619 in_pcbdetach(inp); 620 in_pcbfree(inp); 621 INP_INFO_WUNLOCK(&V_ripcbinfo); 622 } 623 624 /* XXXRW: This can't ever be called. */ 625 static void 626 rip6_abort(struct socket *so) 627 { 628 struct inpcb *inp; 629 630 inp = sotoinpcb(so); 631 KASSERT(inp != NULL, ("rip6_abort: inp == NULL")); 632 633 soisdisconnected(so); 634 } 635 636 static void 637 rip6_close(struct socket *so) 638 { 639 struct inpcb *inp; 640 641 inp = sotoinpcb(so); 642 KASSERT(inp != NULL, ("rip6_close: inp == NULL")); 643 644 soisdisconnected(so); 645 } 646 647 static int 648 rip6_disconnect(struct socket *so) 649 { 650 struct inpcb *inp; 651 652 inp = sotoinpcb(so); 653 KASSERT(inp != NULL, ("rip6_disconnect: inp == NULL")); 654 655 if ((so->so_state & SS_ISCONNECTED) == 0) 656 return (ENOTCONN); 657 inp->in6p_faddr = in6addr_any; 658 rip6_abort(so); 659 return (0); 660 } 661 662 static int 663 rip6_bind(struct socket *so, struct sockaddr *nam, struct thread *td) 664 { 665 INIT_VNET_NET(so->so_vnet); 666 INIT_VNET_INET(so->so_vnet); 667 INIT_VNET_INET6(so->so_vnet); 668 struct inpcb *inp; 669 struct sockaddr_in6 *addr = (struct sockaddr_in6 *)nam; 670 struct ifaddr *ia = NULL; 671 int error = 0; 672 673 inp = sotoinpcb(so); 674 KASSERT(inp != NULL, ("rip6_bind: inp == NULL")); 675 676 if (nam->sa_len != sizeof(*addr)) 677 return (EINVAL); 678 if ((error = prison_check_ip6(td->td_ucred, &addr->sin6_addr)) != 0) 679 return (error); 680 if (TAILQ_EMPTY(&V_ifnet) || addr->sin6_family != AF_INET6) 681 return (EADDRNOTAVAIL); 682 if ((error = sa6_embedscope(addr, V_ip6_use_defzone)) != 0) 683 return (error); 684 685 if (!IN6_IS_ADDR_UNSPECIFIED(&addr->sin6_addr) && 686 (ia = ifa_ifwithaddr((struct sockaddr *)addr)) == 0) 687 return (EADDRNOTAVAIL); 688 if (ia && 689 ((struct in6_ifaddr *)ia)->ia6_flags & 690 (IN6_IFF_ANYCAST|IN6_IFF_NOTREADY| 691 IN6_IFF_DETACHED|IN6_IFF_DEPRECATED)) { 692 return (EADDRNOTAVAIL); 693 } 694 INP_INFO_WLOCK(&V_ripcbinfo); 695 INP_WLOCK(inp); 696 inp->in6p_laddr = addr->sin6_addr; 697 INP_WUNLOCK(inp); 698 INP_INFO_WUNLOCK(&V_ripcbinfo); 699 return (0); 700 } 701 702 static int 703 rip6_connect(struct socket *so, struct sockaddr *nam, struct thread *td) 704 { 705 INIT_VNET_NET(so->so_vnet); 706 INIT_VNET_INET(so->so_vnet); 707 INIT_VNET_INET6(so->so_vnet); 708 struct inpcb *inp; 709 struct sockaddr_in6 *addr = (struct sockaddr_in6 *)nam; 710 struct in6_addr *in6a = NULL; 711 struct ifnet *ifp = NULL; 712 int error = 0, scope_ambiguous = 0; 713 714 inp = sotoinpcb(so); 715 KASSERT(inp != NULL, ("rip6_connect: inp == NULL")); 716 717 if (nam->sa_len != sizeof(*addr)) 718 return (EINVAL); 719 if (TAILQ_EMPTY(&V_ifnet)) 720 return (EADDRNOTAVAIL); 721 if (addr->sin6_family != AF_INET6) 722 return (EAFNOSUPPORT); 723 724 /* 725 * Application should provide a proper zone ID or the use of default 726 * zone IDs should be enabled. Unfortunately, some applications do 727 * not behave as it should, so we need a workaround. Even if an 728 * appropriate ID is not determined, we'll see if we can determine 729 * the outgoing interface. If we can, determine the zone ID based on 730 * the interface below. 731 */ 732 if (addr->sin6_scope_id == 0 && !V_ip6_use_defzone) 733 scope_ambiguous = 1; 734 if ((error = sa6_embedscope(addr, V_ip6_use_defzone)) != 0) 735 return (error); 736 737 INP_INFO_WLOCK(&V_ripcbinfo); 738 INP_WLOCK(inp); 739 /* Source address selection. XXX: need pcblookup? */ 740 in6a = in6_selectsrc(addr, inp->in6p_outputopts, 741 inp, NULL, so->so_cred, 742 &ifp, &error); 743 if (in6a == NULL) { 744 INP_WUNLOCK(inp); 745 INP_INFO_WUNLOCK(&V_ripcbinfo); 746 return (error ? error : EADDRNOTAVAIL); 747 } 748 749 /* XXX: see above */ 750 if (ifp && scope_ambiguous && 751 (error = in6_setscope(&addr->sin6_addr, ifp, NULL)) != 0) { 752 INP_WUNLOCK(inp); 753 INP_INFO_WUNLOCK(&V_ripcbinfo); 754 return (error); 755 } 756 inp->in6p_faddr = addr->sin6_addr; 757 inp->in6p_laddr = *in6a; 758 soisconnected(so); 759 INP_WUNLOCK(inp); 760 INP_INFO_WUNLOCK(&V_ripcbinfo); 761 return (0); 762 } 763 764 static int 765 rip6_shutdown(struct socket *so) 766 { 767 struct inpcb *inp; 768 769 inp = sotoinpcb(so); 770 KASSERT(inp != NULL, ("rip6_shutdown: inp == NULL")); 771 772 INP_WLOCK(inp); 773 socantsendmore(so); 774 INP_WUNLOCK(inp); 775 return (0); 776 } 777 778 static int 779 rip6_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *nam, 780 struct mbuf *control, struct thread *td) 781 { 782 struct inpcb *inp; 783 struct sockaddr_in6 tmp; 784 struct sockaddr_in6 *dst; 785 int ret; 786 787 inp = sotoinpcb(so); 788 KASSERT(inp != NULL, ("rip6_send: inp == NULL")); 789 790 /* Always copy sockaddr to avoid overwrites. */ 791 /* Unlocked read. */ 792 if (so->so_state & SS_ISCONNECTED) { 793 if (nam) { 794 m_freem(m); 795 return (EISCONN); 796 } 797 /* XXX */ 798 bzero(&tmp, sizeof(tmp)); 799 tmp.sin6_family = AF_INET6; 800 tmp.sin6_len = sizeof(struct sockaddr_in6); 801 INP_RLOCK(inp); 802 bcopy(&inp->in6p_faddr, &tmp.sin6_addr, 803 sizeof(struct in6_addr)); 804 INP_RUNLOCK(inp); 805 dst = &tmp; 806 } else { 807 if (nam == NULL) { 808 m_freem(m); 809 return (ENOTCONN); 810 } 811 if (nam->sa_len != sizeof(struct sockaddr_in6)) { 812 m_freem(m); 813 return (EINVAL); 814 } 815 tmp = *(struct sockaddr_in6 *)nam; 816 dst = &tmp; 817 818 if (dst->sin6_family == AF_UNSPEC) { 819 /* 820 * XXX: we allow this case for backward 821 * compatibility to buggy applications that 822 * rely on old (and wrong) kernel behavior. 823 */ 824 log(LOG_INFO, "rip6 SEND: address family is " 825 "unspec. Assume AF_INET6\n"); 826 dst->sin6_family = AF_INET6; 827 } else if (dst->sin6_family != AF_INET6) { 828 m_freem(m); 829 return(EAFNOSUPPORT); 830 } 831 } 832 ret = rip6_output(m, so, dst, control); 833 return (ret); 834 } 835 836 struct pr_usrreqs rip6_usrreqs = { 837 .pru_abort = rip6_abort, 838 .pru_attach = rip6_attach, 839 .pru_bind = rip6_bind, 840 .pru_connect = rip6_connect, 841 .pru_control = in6_control, 842 .pru_detach = rip6_detach, 843 .pru_disconnect = rip6_disconnect, 844 .pru_peeraddr = in6_getpeeraddr, 845 .pru_send = rip6_send, 846 .pru_shutdown = rip6_shutdown, 847 .pru_sockaddr = in6_getsockaddr, 848 .pru_close = rip6_close, 849 }; 850