1 /* $FreeBSD: src/sys/netinet6/udp6_usrreq.c,v 1.6.2.13 2003/01/24 05:11:35 sam Exp $ */ 2 /* $DragonFly: src/sys/netinet6/udp6_usrreq.c,v 1.14 2004/05/20 18:30:36 cpressey Exp $ */ 3 /* $KAME: udp6_usrreq.c,v 1.27 2001/05/21 05:45:10 jinmei Exp $ */ 4 5 /* 6 * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project. 7 * All rights reserved. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 3. Neither the name of the project nor the names of its contributors 18 * may be used to endorse or promote products derived from this software 19 * without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND 22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE 25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 */ 33 34 /* 35 * Copyright (c) 1982, 1986, 1989, 1993 36 * The Regents of the University of California. All rights reserved. 37 * 38 * Redistribution and use in source and binary forms, with or without 39 * modification, are permitted provided that the following conditions 40 * are met: 41 * 1. Redistributions of source code must retain the above copyright 42 * notice, this list of conditions and the following disclaimer. 43 * 2. Redistributions in binary form must reproduce the above copyright 44 * notice, this list of conditions and the following disclaimer in the 45 * documentation and/or other materials provided with the distribution. 46 * 3. All advertising materials mentioning features or use of this software 47 * must display the following acknowledgement: 48 * This product includes software developed by the University of 49 * California, Berkeley and its contributors. 50 * 4. Neither the name of the University nor the names of its contributors 51 * may be used to endorse or promote products derived from this software 52 * without specific prior written permission. 53 * 54 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 55 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 56 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 57 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 58 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 59 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 60 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 61 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 62 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 63 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 64 * SUCH DAMAGE. 65 * 66 * @(#)udp_var.h 8.1 (Berkeley) 6/10/93 67 */ 68 69 #include "opt_inet.h" 70 #include "opt_inet6.h" 71 #include "opt_ipsec.h" 72 73 #include <sys/param.h> 74 #include <sys/kernel.h> 75 #include <sys/mbuf.h> 76 #include <sys/protosw.h> 77 #include <sys/socket.h> 78 #include <sys/socketvar.h> 79 #include <sys/sysctl.h> 80 #include <sys/errno.h> 81 #include <sys/stat.h> 82 #include <sys/systm.h> 83 #include <sys/syslog.h> 84 #include <sys/proc.h> 85 86 #include <net/if.h> 87 #include <net/route.h> 88 #include <net/if_types.h> 89 90 #include <netinet/in.h> 91 #include <netinet/in_systm.h> 92 #include <netinet/ip.h> 93 #include <netinet/in_pcb.h> 94 #include <netinet/in_var.h> 95 #include <netinet/ip_var.h> 96 #include <netinet/udp.h> 97 #include <netinet/udp_var.h> 98 #include <netinet/ip6.h> 99 #include <netinet6/ip6_var.h> 100 #include <netinet6/in6_pcb.h> 101 #include <netinet/icmp6.h> 102 #include <netinet6/udp6_var.h> 103 #include <netinet6/ip6protosw.h> 104 105 #ifdef IPSEC 106 #include <netinet6/ipsec.h> 107 #include <netinet6/ipsec6.h> 108 #endif /* IPSEC */ 109 110 #ifdef FAST_IPSEC 111 #include "ipsec.h" 112 #include "ipsec6.h" 113 #endif /* FAST_IPSEC */ 114 115 /* 116 * UDP protocol inplementation. 117 * Per RFC 768, August, 1980. 118 */ 119 120 extern struct protosw inetsw[]; 121 static int in6_mcmatch (struct inpcb *, struct in6_addr *, struct ifnet *); 122 static int udp6_detach (struct socket *so); 123 124 static int 125 in6_mcmatch(struct inpcb *in6p, struct in6_addr *ia6, struct ifnet *ifp) 126 { 127 struct ip6_moptions *im6o = in6p->in6p_moptions; 128 struct in6_multi_mship *imm; 129 130 if (im6o == NULL) 131 return 0; 132 133 for (imm = im6o->im6o_memberships.lh_first; imm != NULL; 134 imm = imm->i6mm_chain.le_next) { 135 if ((ifp == NULL || 136 imm->i6mm_maddr->in6m_ifp == ifp) && 137 IN6_ARE_ADDR_EQUAL(&imm->i6mm_maddr->in6m_addr, 138 ia6)) 139 return 1; 140 } 141 return 0; 142 } 143 144 int 145 udp6_input(struct mbuf **mp, int *offp, int proto) 146 { 147 struct mbuf *m = *mp; 148 struct ip6_hdr *ip6; 149 struct udphdr *uh; 150 struct inpcb *in6p; 151 struct mbuf *opts = NULL; 152 int off = *offp; 153 int plen, ulen; 154 struct sockaddr_in6 udp_in6; 155 156 IP6_EXTHDR_CHECK(m, off, sizeof(struct udphdr), IPPROTO_DONE); 157 158 ip6 = mtod(m, struct ip6_hdr *); 159 160 if (faithprefix_p != NULL && (*faithprefix_p)(&ip6->ip6_dst)) { 161 /* XXX send icmp6 host/port unreach? */ 162 m_freem(m); 163 return IPPROTO_DONE; 164 } 165 166 udpstat.udps_ipackets++; 167 168 plen = ntohs(ip6->ip6_plen) - off + sizeof(*ip6); 169 uh = (struct udphdr *)((caddr_t)ip6 + off); 170 ulen = ntohs((u_short)uh->uh_ulen); 171 172 if (plen != ulen) { 173 udpstat.udps_badlen++; 174 goto bad; 175 } 176 177 /* 178 * Checksum extended UDP header and data. 179 */ 180 if (uh->uh_sum == 0) 181 udpstat.udps_nosum++; 182 else if (in6_cksum(m, IPPROTO_UDP, off, ulen) != 0) { 183 udpstat.udps_badsum++; 184 goto bad; 185 } 186 187 if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst)) { 188 struct inpcb *last; 189 190 /* 191 * Deliver a multicast datagram to all sockets 192 * for which the local and remote addresses and ports match 193 * those of the incoming datagram. This allows more than 194 * one process to receive multicasts on the same port. 195 * (This really ought to be done for unicast datagrams as 196 * well, but that would cause problems with existing 197 * applications that open both address-specific sockets and 198 * a wildcard socket listening to the same port -- they would 199 * end up receiving duplicates of every unicast datagram. 200 * Those applications open the multiple sockets to overcome an 201 * inadequacy of the UDP socket interface, but for backwards 202 * compatibility we avoid the problem here rather than 203 * fixing the interface. Maybe 4.5BSD will remedy this?) 204 */ 205 206 /* 207 * In a case that laddr should be set to the link-local 208 * address (this happens in RIPng), the multicast address 209 * specified in the received packet does not match with 210 * laddr. To cure this situation, the matching is relaxed 211 * if the receiving interface is the same as one specified 212 * in the socket and if the destination multicast address 213 * matches one of the multicast groups specified in the socket. 214 */ 215 216 /* 217 * Construct sockaddr format source address. 218 */ 219 init_sin6(&udp_in6, m); /* general init */ 220 udp_in6.sin6_port = uh->uh_sport; 221 /* 222 * KAME note: traditionally we dropped udpiphdr from mbuf here. 223 * We need udphdr for IPsec processing so we do that later. 224 */ 225 226 /* 227 * Locate pcb(s) for datagram. 228 * (Algorithm copied from raw_intr().) 229 */ 230 last = NULL; 231 LIST_FOREACH(in6p, &udbinfo.listhead, inp_list) { 232 if ((in6p->inp_vflag & INP_IPV6) == 0) 233 continue; 234 if (in6p->in6p_lport != uh->uh_dport) 235 continue; 236 if (!IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_laddr)) { 237 if (!IN6_ARE_ADDR_EQUAL(&in6p->in6p_laddr, 238 &ip6->ip6_dst) && 239 !in6_mcmatch(in6p, &ip6->ip6_dst, 240 m->m_pkthdr.rcvif)) 241 continue; 242 } 243 if (!IN6_IS_ADDR_UNSPECIFIED(&in6p->in6p_faddr)) { 244 if (!IN6_ARE_ADDR_EQUAL(&in6p->in6p_faddr, 245 &ip6->ip6_src) || 246 in6p->in6p_fport != uh->uh_sport) 247 continue; 248 } 249 250 if (last != NULL) { 251 struct mbuf *n; 252 253 #ifdef IPSEC 254 /* 255 * Check AH/ESP integrity. 256 */ 257 if (ipsec6_in_reject_so(m, last->inp_socket)) 258 ipsec6stat.in_polvio++; 259 /* do not inject data into pcb */ 260 else 261 #endif /* IPSEC */ 262 #ifdef FAST_IPSEC 263 /* 264 * Check AH/ESP integrity. 265 */ 266 if (ipsec6_in_reject(m, last)) 267 ; 268 else 269 #endif /* FAST_IPSEC */ 270 if ((n = m_copy(m, 0, M_COPYALL)) != NULL) { 271 /* 272 * KAME NOTE: do not 273 * m_copy(m, offset, ...) above. 274 * sbappendaddr() expects M_PKTHDR, 275 * and m_copy() will copy M_PKTHDR 276 * only if offset is 0. 277 */ 278 if (last->in6p_flags & IN6P_CONTROLOPTS 279 || last->in6p_socket->so_options & SO_TIMESTAMP) 280 ip6_savecontrol(last, &opts, 281 ip6, n); 282 283 m_adj(n, off + sizeof(struct udphdr)); 284 if (sbappendaddr(&last->in6p_socket->so_rcv, 285 (struct sockaddr *)&udp_in6, 286 n, opts) == 0) { 287 m_freem(n); 288 if (opts) 289 m_freem(opts); 290 udpstat.udps_fullsock++; 291 } else 292 sorwakeup(last->in6p_socket); 293 opts = NULL; 294 } 295 } 296 last = in6p; 297 /* 298 * Don't look for additional matches if this one does 299 * not have either the SO_REUSEPORT or SO_REUSEADDR 300 * socket options set. This heuristic avoids searching 301 * through all pcbs in the common case of a non-shared 302 * port. It assumes that an application will never 303 * clear these options after setting them. 304 */ 305 if ((last->in6p_socket->so_options & 306 (SO_REUSEPORT|SO_REUSEADDR)) == 0) 307 break; 308 } 309 310 if (last == NULL) { 311 /* 312 * No matching pcb found; discard datagram. 313 * (No need to send an ICMP Port Unreachable 314 * for a broadcast or multicast datgram.) 315 */ 316 udpstat.udps_noport++; 317 udpstat.udps_noportmcast++; 318 goto bad; 319 } 320 #ifdef IPSEC 321 /* 322 * Check AH/ESP integrity. 323 */ 324 if (ipsec6_in_reject_so(m, last->inp_socket)) { 325 ipsec6stat.in_polvio++; 326 goto bad; 327 } 328 #endif /* IPSEC */ 329 #ifdef FAST_IPSEC 330 /* 331 * Check AH/ESP integrity. 332 */ 333 if (ipsec6_in_reject(m, last)) { 334 goto bad; 335 } 336 #endif /* FAST_IPSEC */ 337 if (last->in6p_flags & IN6P_CONTROLOPTS 338 || last->in6p_socket->so_options & SO_TIMESTAMP) 339 ip6_savecontrol(last, &opts, ip6, m); 340 341 m_adj(m, off + sizeof(struct udphdr)); 342 if (sbappendaddr(&last->in6p_socket->so_rcv, 343 (struct sockaddr *)&udp_in6, 344 m, opts) == 0) { 345 udpstat.udps_fullsock++; 346 goto bad; 347 } 348 sorwakeup(last->in6p_socket); 349 return IPPROTO_DONE; 350 } 351 /* 352 * Locate pcb for datagram. 353 */ 354 in6p = in6_pcblookup_hash(&udbinfo, &ip6->ip6_src, uh->uh_sport, 355 &ip6->ip6_dst, uh->uh_dport, 1, 356 m->m_pkthdr.rcvif); 357 if (in6p == 0) { 358 if (log_in_vain) { 359 char buf[INET6_ADDRSTRLEN]; 360 361 strcpy(buf, ip6_sprintf(&ip6->ip6_dst)); 362 log(LOG_INFO, 363 "Connection attempt to UDP [%s]:%d from [%s]:%d\n", 364 buf, ntohs(uh->uh_dport), 365 ip6_sprintf(&ip6->ip6_src), ntohs(uh->uh_sport)); 366 } 367 udpstat.udps_noport++; 368 if (m->m_flags & M_MCAST) { 369 printf("UDP6: M_MCAST is set in a unicast packet.\n"); 370 udpstat.udps_noportmcast++; 371 goto bad; 372 } 373 icmp6_error(m, ICMP6_DST_UNREACH, ICMP6_DST_UNREACH_NOPORT, 0); 374 return IPPROTO_DONE; 375 } 376 #ifdef IPSEC 377 /* 378 * Check AH/ESP integrity. 379 */ 380 if (ipsec6_in_reject_so(m, in6p->in6p_socket)) { 381 ipsec6stat.in_polvio++; 382 goto bad; 383 } 384 #endif /* IPSEC */ 385 #ifdef FAST_IPSEC 386 /* 387 * Check AH/ESP integrity. 388 */ 389 if (ipsec6_in_reject(m, in6p)) { 390 goto bad; 391 } 392 #endif /* FAST_IPSEC */ 393 394 /* 395 * Construct sockaddr format source address. 396 * Stuff source address and datagram in user buffer. 397 */ 398 init_sin6(&udp_in6, m); /* general init */ 399 udp_in6.sin6_port = uh->uh_sport; 400 if (in6p->in6p_flags & IN6P_CONTROLOPTS 401 || in6p->in6p_socket->so_options & SO_TIMESTAMP) 402 ip6_savecontrol(in6p, &opts, ip6, m); 403 m_adj(m, off + sizeof(struct udphdr)); 404 if (sbappendaddr(&in6p->in6p_socket->so_rcv, 405 (struct sockaddr *)&udp_in6, 406 m, opts) == 0) { 407 udpstat.udps_fullsock++; 408 goto bad; 409 } 410 sorwakeup(in6p->in6p_socket); 411 return IPPROTO_DONE; 412 bad: 413 if (m) 414 m_freem(m); 415 if (opts) 416 m_freem(opts); 417 return IPPROTO_DONE; 418 } 419 420 void 421 udp6_ctlinput(int cmd, struct sockaddr *sa, void *d) 422 { 423 struct udphdr uh; 424 struct ip6_hdr *ip6; 425 struct mbuf *m; 426 int off = 0; 427 struct ip6ctlparam *ip6cp = NULL; 428 const struct sockaddr_in6 *sa6_src = NULL; 429 void (*notify) (struct inpcb *, int) = udp_notify; 430 struct udp_portonly { 431 u_int16_t uh_sport; 432 u_int16_t uh_dport; 433 } *uhp; 434 435 if (sa->sa_family != AF_INET6 || 436 sa->sa_len != sizeof(struct sockaddr_in6)) 437 return; 438 439 if ((unsigned)cmd >= PRC_NCMDS) 440 return; 441 if (PRC_IS_REDIRECT(cmd)) 442 notify = in6_rtchange, d = NULL; 443 else if (cmd == PRC_HOSTDEAD) 444 d = NULL; 445 else if (inet6ctlerrmap[cmd] == 0) 446 return; 447 448 /* if the parameter is from icmp6, decode it. */ 449 if (d != NULL) { 450 ip6cp = (struct ip6ctlparam *)d; 451 m = ip6cp->ip6c_m; 452 ip6 = ip6cp->ip6c_ip6; 453 off = ip6cp->ip6c_off; 454 sa6_src = ip6cp->ip6c_src; 455 } else { 456 m = NULL; 457 ip6 = NULL; 458 sa6_src = &sa6_any; 459 } 460 461 if (ip6) { 462 /* 463 * XXX: We assume that when IPV6 is non NULL, 464 * M and OFF are valid. 465 */ 466 467 /* check if we can safely examine src and dst ports */ 468 if (m->m_pkthdr.len < off + sizeof(*uhp)) 469 return; 470 471 bzero(&uh, sizeof(uh)); 472 m_copydata(m, off, sizeof(*uhp), (caddr_t)&uh); 473 474 (void) in6_pcbnotify(&udbinfo.listhead, sa, uh.uh_dport, 475 (struct sockaddr *)ip6cp->ip6c_src, 476 uh.uh_sport, cmd, notify); 477 } else 478 (void) in6_pcbnotify(&udbinfo.listhead, sa, 0, 479 (const struct sockaddr *)sa6_src, 480 0, cmd, notify); 481 } 482 483 static int 484 udp6_getcred(SYSCTL_HANDLER_ARGS) 485 { 486 struct sockaddr_in6 addrs[2]; 487 struct inpcb *inp; 488 int error, s; 489 490 error = suser(req->td); 491 if (error) 492 return (error); 493 494 if (req->newlen != sizeof(addrs)) 495 return (EINVAL); 496 if (req->oldlen != sizeof(struct ucred)) 497 return (EINVAL); 498 error = SYSCTL_IN(req, addrs, sizeof(addrs)); 499 if (error) 500 return (error); 501 s = splnet(); 502 inp = in6_pcblookup_hash(&udbinfo, &addrs[1].sin6_addr, 503 addrs[1].sin6_port, 504 &addrs[0].sin6_addr, addrs[0].sin6_port, 505 1, NULL); 506 if (!inp || !inp->inp_socket) { 507 error = ENOENT; 508 goto out; 509 } 510 error = SYSCTL_OUT(req, inp->inp_socket->so_cred, 511 sizeof(struct ucred)); 512 513 out: 514 splx(s); 515 return (error); 516 } 517 518 SYSCTL_PROC(_net_inet6_udp6, OID_AUTO, getcred, CTLTYPE_OPAQUE|CTLFLAG_RW, 519 0, 0, 520 udp6_getcred, "S,ucred", "Get the ucred of a UDP6 connection"); 521 522 static int 523 udp6_abort(struct socket *so) 524 { 525 struct inpcb *inp; 526 int s; 527 528 inp = sotoinpcb(so); 529 if (inp == 0) 530 return EINVAL; /* ??? possible? panic instead? */ 531 soisdisconnected(so); 532 s = splnet(); 533 in6_pcbdetach(inp); 534 splx(s); 535 return 0; 536 } 537 538 static int 539 udp6_attach(struct socket *so, int proto, struct pru_attach_info *ai) 540 { 541 struct inpcb *inp; 542 int s, error; 543 544 inp = sotoinpcb(so); 545 if (inp != 0) 546 return EINVAL; 547 548 if (so->so_snd.sb_hiwat == 0 || so->so_rcv.sb_hiwat == 0) { 549 error = soreserve(so, udp_sendspace, udp_recvspace, 550 ai->sb_rlimit); 551 if (error) 552 return error; 553 } 554 s = splnet(); 555 error = in_pcballoc(so, &udbinfo); 556 splx(s); 557 if (error) 558 return error; 559 inp = (struct inpcb *)so->so_pcb; 560 inp->inp_vflag |= INP_IPV6; 561 if (!ip6_v6only) 562 inp->inp_vflag |= INP_IPV4; 563 inp->in6p_hops = -1; /* use kernel default */ 564 inp->in6p_cksum = -1; /* just to be sure */ 565 /* 566 * XXX: ugly!! 567 * IPv4 TTL initialization is necessary for an IPv6 socket as well, 568 * because the socket may be bound to an IPv6 wildcard address, 569 * which may match an IPv4-mapped IPv6 address. 570 */ 571 inp->inp_ip_ttl = ip_defttl; 572 return 0; 573 } 574 575 static int 576 udp6_bind(struct socket *so, struct sockaddr *nam, struct thread *td) 577 { 578 struct sockaddr_in6 *sin6_p = (struct sockaddr_in6 *)nam; 579 struct inpcb *inp; 580 int s, error; 581 582 inp = sotoinpcb(so); 583 if (inp == 0) 584 return EINVAL; 585 586 inp->inp_vflag &= ~INP_IPV4; 587 inp->inp_vflag |= INP_IPV6; 588 if ((inp->inp_flags & IN6P_IPV6_V6ONLY) == 0) { 589 if (IN6_IS_ADDR_UNSPECIFIED(&sin6_p->sin6_addr)) 590 inp->inp_vflag |= INP_IPV4; 591 else if (IN6_IS_ADDR_V4MAPPED(&sin6_p->sin6_addr)) { 592 struct sockaddr_in sin; 593 594 in6_sin6_2_sin(&sin, sin6_p); 595 inp->inp_vflag |= INP_IPV4; 596 inp->inp_vflag &= ~INP_IPV6; 597 s = splnet(); 598 error = in_pcbbind(inp, (struct sockaddr *)&sin, td); 599 splx(s); 600 return error; 601 } 602 } 603 604 s = splnet(); 605 error = in6_pcbbind(inp, nam, td); 606 splx(s); 607 if (error == 0) { 608 if (IN6_IS_ADDR_UNSPECIFIED(&sin6_p->sin6_addr)) 609 inp->inp_flags |= INP_WASBOUND_NOTANY; 610 in_pcbinswildcardhash(inp); 611 } 612 return error; 613 } 614 615 static int 616 udp6_connect(struct socket *so, struct sockaddr *nam, struct thread *td) 617 { 618 struct inpcb *inp; 619 int s, error; 620 621 inp = sotoinpcb(so); 622 if (inp == 0) 623 return EINVAL; 624 625 if ((inp->inp_flags & IN6P_IPV6_V6ONLY) == 0) { 626 struct sockaddr_in6 *sin6_p; 627 628 sin6_p = (struct sockaddr_in6 *)nam; 629 if (IN6_IS_ADDR_V4MAPPED(&sin6_p->sin6_addr)) { 630 struct sockaddr_in sin; 631 632 if (inp->inp_faddr.s_addr != INADDR_ANY) 633 return EISCONN; 634 in6_sin6_2_sin(&sin, sin6_p); 635 s = splnet(); 636 error = in_pcbconnect(inp, (struct sockaddr *)&sin, td); 637 splx(s); 638 if (error == 0) { 639 inp->inp_vflag |= INP_IPV4; 640 inp->inp_vflag &= ~INP_IPV6; 641 soisconnected(so); 642 } 643 return error; 644 } 645 } 646 if (!IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_faddr)) 647 return EISCONN; 648 if (inp->inp_flags & INP_WILDCARD) 649 in_pcbremwildcardhash(inp); 650 s = splnet(); 651 error = in6_pcbconnect(inp, nam, td); 652 splx(s); 653 if (error == 0) { 654 if (!ip6_v6only) { /* should be non mapped addr */ 655 inp->inp_vflag &= ~INP_IPV4; 656 inp->inp_vflag |= INP_IPV6; 657 } 658 soisconnected(so); 659 } else if (error == EAFNOSUPPORT) { /* connection dissolved */ 660 /* 661 * Follow traditional BSD behavior and retain 662 * the local port binding. But, fix the old misbehavior 663 * of overwriting any previously bound local address. 664 */ 665 if (!(inp->inp_flags & INP_WASBOUND_NOTANY)) 666 inp->in6p_laddr = in6addr_any; 667 in_pcbinswildcardhash(inp); 668 } 669 return error; 670 } 671 672 static int 673 udp6_detach(struct socket *so) 674 { 675 struct inpcb *inp; 676 int s; 677 678 inp = sotoinpcb(so); 679 if (inp == 0) 680 return EINVAL; 681 s = splnet(); 682 in6_pcbdetach(inp); 683 splx(s); 684 return 0; 685 } 686 687 static int 688 udp6_disconnect(struct socket *so) 689 { 690 struct inpcb *inp; 691 int s; 692 693 inp = sotoinpcb(so); 694 if (inp == 0) 695 return EINVAL; 696 697 if (inp->inp_vflag & INP_IPV4) { 698 struct pr_usrreqs *pru; 699 700 pru = inetsw[ip_protox[IPPROTO_UDP]].pr_usrreqs; 701 return ((*pru->pru_disconnect)(so)); 702 } 703 704 if (IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_faddr)) 705 return ENOTCONN; 706 707 s = splnet(); 708 in6_pcbdisconnect(inp); 709 splx(s); 710 so->so_state &= ~SS_ISCONNECTED; /* XXX */ 711 return 0; 712 } 713 714 static int 715 udp6_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr, 716 struct mbuf *control, struct thread *td) 717 { 718 struct inpcb *inp; 719 int error = 0; 720 721 inp = sotoinpcb(so); 722 if (inp == 0) { 723 error = EINVAL; 724 goto bad; 725 } 726 727 if (addr) { 728 if (addr->sa_len != sizeof(struct sockaddr_in6)) { 729 error = EINVAL; 730 goto bad; 731 } 732 if (addr->sa_family != AF_INET6) { 733 error = EAFNOSUPPORT; 734 goto bad; 735 } 736 } 737 738 if (!ip6_v6only) { 739 int hasv4addr; 740 struct sockaddr_in6 *sin6 = 0; 741 742 if (addr == 0) 743 hasv4addr = (inp->inp_vflag & INP_IPV4); 744 else { 745 sin6 = (struct sockaddr_in6 *)addr; 746 hasv4addr = IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr) 747 ? 1 : 0; 748 } 749 if (hasv4addr) { 750 struct pr_usrreqs *pru; 751 752 if (sin6) 753 in6_sin6_2_sin_in_sock(addr); 754 pru = inetsw[ip_protox[IPPROTO_UDP]].pr_usrreqs; 755 error = ((*pru->pru_send)(so, flags, m, addr, 756 control, td)); 757 /* addr will just be freed in sendit(). */ 758 return error; 759 } 760 } 761 762 return udp6_output(inp, m, addr, control, td); 763 764 bad: 765 m_freem(m); 766 return(error); 767 } 768 769 struct pr_usrreqs udp6_usrreqs = { 770 udp6_abort, pru_accept_notsupp, udp6_attach, udp6_bind, udp6_connect, 771 pru_connect2_notsupp, in6_control, udp6_detach, udp6_disconnect, 772 pru_listen_notsupp, in6_mapped_peeraddr, pru_rcvd_notsupp, 773 pru_rcvoob_notsupp, udp6_send, pru_sense_null, udp_shutdown, 774 in6_mapped_sockaddr, sosend, soreceive, sopoll 775 }; 776