sctp6_usrreq.c revision 293896
1/*- 2 * Copyright (c) 2001-2007, by Cisco Systems, Inc. All rights reserved. 3 * Copyright (c) 2008-2012, by Randall Stewart. All rights reserved. 4 * Copyright (c) 2008-2012, by Michael Tuexen. All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions are met: 8 * 9 * a) Redistributions of source code must retain the above copyright notice, 10 * this list of conditions and the following disclaimer. 11 * 12 * b) Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in 14 * the documentation and/or other materials provided with the distribution. 15 * 16 * c) Neither the name of Cisco Systems, Inc. nor the names of its 17 * contributors may be used to endorse or promote products derived 18 * from this software without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 21 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 22 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 24 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 30 * THE POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33#include <sys/cdefs.h> 34__FBSDID("$FreeBSD: releng/9.3/sys/netinet6/sctp6_usrreq.c 293896 2016-01-14 09:11:26Z glebius $"); 35 36#include <netinet/sctp_os.h> 37#ifdef INET6 38#include <sys/proc.h> 39#include <netinet/sctp_pcb.h> 40#include <netinet/sctp_header.h> 41#include <netinet/sctp_var.h> 42#ifdef INET6 43#include <netinet6/sctp6_var.h> 44#endif 45#include <netinet/sctp_sysctl.h> 46#include <netinet/sctp_output.h> 47#include <netinet/sctp_uio.h> 48#include <netinet/sctp_asconf.h> 49#include <netinet/sctputil.h> 50#include <netinet/sctp_indata.h> 51#include <netinet/sctp_timer.h> 52#include <netinet/sctp_auth.h> 53#include <netinet/sctp_input.h> 54#include <netinet/sctp_output.h> 55#include <netinet/sctp_bsd_addr.h> 56#include <netinet/sctp_crc32.h> 57#include <netinet/udp.h> 58 59#ifdef IPSEC 60#include <netipsec/ipsec.h> 61#ifdef INET6 62#include <netipsec/ipsec6.h> 63#endif /* INET6 */ 64#endif /* IPSEC */ 65 66extern struct protosw inetsw[]; 67 68int 69sctp6_input_with_port(struct mbuf **i_pak, int *offp, uint16_t port) 70{ 71 struct mbuf *m; 72 int iphlen; 73 uint32_t vrf_id; 74 uint8_t ecn_bits; 75 struct sockaddr_in6 src, dst; 76 struct ip6_hdr *ip6; 77 struct sctphdr *sh; 78 struct sctp_chunkhdr *ch; 79 int length, offset; 80 81#if !defined(SCTP_WITH_NO_CSUM) 82 uint8_t compute_crc; 83 84#endif 85 uint32_t mflowid; 86 uint8_t use_mflowid; 87 88 iphlen = *offp; 89 if (SCTP_GET_PKT_VRFID(*i_pak, vrf_id)) { 90 SCTP_RELEASE_PKT(*i_pak); 91 return (IPPROTO_DONE); 92 } 93 m = SCTP_HEADER_TO_CHAIN(*i_pak); 94#ifdef SCTP_MBUF_LOGGING 95 /* Log in any input mbufs */ 96 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_MBUF_LOGGING_ENABLE) { 97 struct mbuf *mat; 98 99 for (mat = m; mat; mat = SCTP_BUF_NEXT(mat)) { 100 if (SCTP_BUF_IS_EXTENDED(mat)) { 101 sctp_log_mb(mat, SCTP_MBUF_INPUT); 102 } 103 } 104 } 105#endif 106#ifdef SCTP_PACKET_LOGGING 107 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_LAST_PACKET_TRACING) { 108 sctp_packet_log(m); 109 } 110#endif 111 SCTPDBG(SCTP_DEBUG_CRCOFFLOAD, 112 "sctp6_input(): Packet of length %d received on %s with csum_flags 0x%x.\n", 113 m->m_pkthdr.len, 114 if_name(m->m_pkthdr.rcvif), 115 m->m_pkthdr.csum_flags); 116 if (m->m_flags & M_FLOWID) { 117 mflowid = m->m_pkthdr.flowid; 118 use_mflowid = 1; 119 } else { 120 mflowid = 0; 121 use_mflowid = 0; 122 } 123 SCTP_STAT_INCR(sctps_recvpackets); 124 SCTP_STAT_INCR_COUNTER64(sctps_inpackets); 125 /* Get IP, SCTP, and first chunk header together in the first mbuf. */ 126 offset = iphlen + sizeof(struct sctphdr) + sizeof(struct sctp_chunkhdr); 127 ip6 = mtod(m, struct ip6_hdr *); 128 IP6_EXTHDR_GET(sh, struct sctphdr *, m, iphlen, 129 (int)(sizeof(struct sctphdr) + sizeof(struct sctp_chunkhdr))); 130 if (sh == NULL) { 131 SCTP_STAT_INCR(sctps_hdrops); 132 return (IPPROTO_DONE); 133 } 134 ch = (struct sctp_chunkhdr *)((caddr_t)sh + sizeof(struct sctphdr)); 135 offset -= sizeof(struct sctp_chunkhdr); 136 memset(&src, 0, sizeof(struct sockaddr_in6)); 137 src.sin6_family = AF_INET6; 138 src.sin6_len = sizeof(struct sockaddr_in6); 139 src.sin6_port = sh->src_port; 140 src.sin6_addr = ip6->ip6_src; 141 if (in6_setscope(&src.sin6_addr, m->m_pkthdr.rcvif, NULL) != 0) { 142 goto out; 143 } 144 memset(&dst, 0, sizeof(struct sockaddr_in6)); 145 dst.sin6_family = AF_INET6; 146 dst.sin6_len = sizeof(struct sockaddr_in6); 147 dst.sin6_port = sh->dest_port; 148 dst.sin6_addr = ip6->ip6_dst; 149 if (in6_setscope(&dst.sin6_addr, m->m_pkthdr.rcvif, NULL) != 0) { 150 goto out; 151 } 152 if (faithprefix_p != NULL && (*faithprefix_p) (&dst.sin6_addr)) { 153 /* XXX send icmp6 host/port unreach? */ 154 goto out; 155 } 156 length = ntohs(ip6->ip6_plen) + iphlen; 157 /* Validate mbuf chain length with IP payload length. */ 158 if (SCTP_HEADER_LEN(m) != length) { 159 SCTPDBG(SCTP_DEBUG_INPUT1, 160 "sctp6_input() length:%d reported length:%d\n", length, SCTP_HEADER_LEN(m)); 161 SCTP_STAT_INCR(sctps_hdrops); 162 goto out; 163 } 164 if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst)) { 165 goto out; 166 } 167 ecn_bits = ((ntohl(ip6->ip6_flow) >> 20) & 0x000000ff); 168#if defined(SCTP_WITH_NO_CSUM) 169 SCTP_STAT_INCR(sctps_recvnocrc); 170#else 171 if (m->m_pkthdr.csum_flags & CSUM_SCTP_VALID) { 172 SCTP_STAT_INCR(sctps_recvhwcrc); 173 compute_crc = 0; 174 } else { 175 SCTP_STAT_INCR(sctps_recvswcrc); 176 compute_crc = 1; 177 } 178#endif 179 sctp_common_input_processing(&m, iphlen, offset, length, 180 (struct sockaddr *)&src, 181 (struct sockaddr *)&dst, 182 sh, ch, 183#if !defined(SCTP_WITH_NO_CSUM) 184 compute_crc, 185#endif 186 ecn_bits, 187 use_mflowid, mflowid, 188 vrf_id, port); 189out: 190 if (m) { 191 sctp_m_freem(m); 192 } 193 return (IPPROTO_DONE); 194} 195 196 197int 198sctp6_input(struct mbuf **i_pak, int *offp, int proto SCTP_UNUSED) 199{ 200 return (sctp6_input_with_port(i_pak, offp, 0)); 201} 202 203static void 204sctp6_notify_mbuf(struct sctp_inpcb *inp, struct icmp6_hdr *icmp6, 205 struct sctphdr *sh, struct sctp_tcb *stcb, struct sctp_nets *net) 206{ 207 uint32_t nxtsz; 208 209 if ((inp == NULL) || (stcb == NULL) || (net == NULL) || 210 (icmp6 == NULL) || (sh == NULL)) { 211 goto out; 212 } 213 /* First do we even look at it? */ 214 if (ntohl(sh->v_tag) != (stcb->asoc.peer_vtag)) 215 goto out; 216 217 if (icmp6->icmp6_type != ICMP6_PACKET_TOO_BIG) { 218 /* not PACKET TO BIG */ 219 goto out; 220 } 221 /* 222 * ok we need to look closely. We could even get smarter and look at 223 * anyone that we sent to in case we get a different ICMP that tells 224 * us there is no way to reach a host, but for this impl, all we 225 * care about is MTU discovery. 226 */ 227 nxtsz = ntohl(icmp6->icmp6_mtu); 228 /* Stop any PMTU timer */ 229 sctp_timer_stop(SCTP_TIMER_TYPE_PATHMTURAISE, inp, stcb, NULL, SCTP_FROM_SCTP6_USRREQ + SCTP_LOC_1); 230 231 /* Adjust destination size limit */ 232 if (net->mtu > nxtsz) { 233 net->mtu = nxtsz; 234 if (net->port) { 235 net->mtu -= sizeof(struct udphdr); 236 } 237 } 238 /* now what about the ep? */ 239 if (stcb->asoc.smallest_mtu > nxtsz) { 240 struct sctp_tmit_chunk *chk; 241 242 /* Adjust that too */ 243 stcb->asoc.smallest_mtu = nxtsz; 244 /* now off to subtract IP_DF flag if needed */ 245 246 TAILQ_FOREACH(chk, &stcb->asoc.send_queue, sctp_next) { 247 if ((uint32_t) (chk->send_size + IP_HDR_SIZE) > nxtsz) { 248 chk->flags |= CHUNK_FLAGS_FRAGMENT_OK; 249 } 250 } 251 TAILQ_FOREACH(chk, &stcb->asoc.sent_queue, sctp_next) { 252 if ((uint32_t) (chk->send_size + IP_HDR_SIZE) > nxtsz) { 253 /* 254 * For this guy we also mark for immediate 255 * resend since we sent to big of chunk 256 */ 257 chk->flags |= CHUNK_FLAGS_FRAGMENT_OK; 258 if (chk->sent != SCTP_DATAGRAM_RESEND) 259 stcb->asoc.sent_queue_retran_cnt++; 260 chk->sent = SCTP_DATAGRAM_RESEND; 261 chk->rec.data.doing_fast_retransmit = 0; 262 263 chk->sent = SCTP_DATAGRAM_RESEND; 264 /* Clear any time so NO RTT is being done */ 265 chk->sent_rcv_time.tv_sec = 0; 266 chk->sent_rcv_time.tv_usec = 0; 267 stcb->asoc.total_flight -= chk->send_size; 268 net->flight_size -= chk->send_size; 269 } 270 } 271 } 272 sctp_timer_start(SCTP_TIMER_TYPE_PATHMTURAISE, inp, stcb, NULL); 273out: 274 if (stcb) { 275 SCTP_TCB_UNLOCK(stcb); 276 } 277} 278 279 280void 281sctp6_notify(struct sctp_inpcb *inp, 282 struct icmp6_hdr *icmph, 283 struct sctphdr *sh, 284 struct sockaddr *to, 285 struct sctp_tcb *stcb, 286 struct sctp_nets *net) 287{ 288#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 289 struct socket *so; 290 291#endif 292 293 /* protection */ 294 if ((inp == NULL) || (stcb == NULL) || (net == NULL) || 295 (sh == NULL) || (to == NULL)) { 296 if (stcb) 297 SCTP_TCB_UNLOCK(stcb); 298 return; 299 } 300 /* First job is to verify the vtag matches what I would send */ 301 if (ntohl(sh->v_tag) != (stcb->asoc.peer_vtag)) { 302 SCTP_TCB_UNLOCK(stcb); 303 return; 304 } 305 if (icmph->icmp6_type != ICMP_UNREACH) { 306 /* We only care about unreachable */ 307 SCTP_TCB_UNLOCK(stcb); 308 return; 309 } 310 if ((icmph->icmp6_code == ICMP_UNREACH_NET) || 311 (icmph->icmp6_code == ICMP_UNREACH_HOST) || 312 (icmph->icmp6_code == ICMP_UNREACH_NET_UNKNOWN) || 313 (icmph->icmp6_code == ICMP_UNREACH_HOST_UNKNOWN) || 314 (icmph->icmp6_code == ICMP_UNREACH_ISOLATED) || 315 (icmph->icmp6_code == ICMP_UNREACH_NET_PROHIB) || 316 (icmph->icmp6_code == ICMP_UNREACH_HOST_PROHIB) || 317 (icmph->icmp6_code == ICMP_UNREACH_FILTER_PROHIB)) { 318 319 /* 320 * Hmm reachablity problems we must examine closely. If its 321 * not reachable, we may have lost a network. Or if there is 322 * NO protocol at the other end named SCTP. well we consider 323 * it a OOTB abort. 324 */ 325 if (net->dest_state & SCTP_ADDR_REACHABLE) { 326 /* Ok that destination is NOT reachable */ 327 net->dest_state &= ~SCTP_ADDR_REACHABLE; 328 net->dest_state &= ~SCTP_ADDR_PF; 329 sctp_ulp_notify(SCTP_NOTIFY_INTERFACE_DOWN, 330 stcb, 0, (void *)net, SCTP_SO_NOT_LOCKED); 331 } 332 SCTP_TCB_UNLOCK(stcb); 333 } else if ((icmph->icmp6_code == ICMP_UNREACH_PROTOCOL) || 334 (icmph->icmp6_code == ICMP_UNREACH_PORT)) { 335 /* 336 * Here the peer is either playing tricks on us, including 337 * an address that belongs to someone who does not support 338 * SCTP OR was a userland implementation that shutdown and 339 * now is dead. In either case treat it like a OOTB abort 340 * with no TCB 341 */ 342 sctp_abort_notification(stcb, 1, 0, NULL, SCTP_SO_NOT_LOCKED); 343#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 344 so = SCTP_INP_SO(inp); 345 atomic_add_int(&stcb->asoc.refcnt, 1); 346 SCTP_TCB_UNLOCK(stcb); 347 SCTP_SOCKET_LOCK(so, 1); 348 SCTP_TCB_LOCK(stcb); 349 atomic_subtract_int(&stcb->asoc.refcnt, 1); 350#endif 351 (void)sctp_free_assoc(inp, stcb, SCTP_NORMAL_PROC, SCTP_FROM_SCTP_USRREQ + SCTP_LOC_2); 352#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 353 SCTP_SOCKET_UNLOCK(so, 1); 354 /* SCTP_TCB_UNLOCK(stcb); MT: I think this is not needed. */ 355#endif 356 /* no need to unlock here, since the TCB is gone */ 357 } else { 358 SCTP_TCB_UNLOCK(stcb); 359 } 360} 361 362 363 364void 365sctp6_ctlinput(int cmd, struct sockaddr *pktdst, void *d) 366{ 367 struct sctphdr sh; 368 struct ip6ctlparam *ip6cp = NULL; 369 uint32_t vrf_id; 370 371 vrf_id = SCTP_DEFAULT_VRFID; 372 373 if (pktdst->sa_family != AF_INET6 || 374 pktdst->sa_len != sizeof(struct sockaddr_in6)) 375 return; 376 377 if ((unsigned)cmd >= PRC_NCMDS) 378 return; 379 if (PRC_IS_REDIRECT(cmd)) { 380 d = NULL; 381 } else if (inet6ctlerrmap[cmd] == 0) { 382 return; 383 } 384 /* if the parameter is from icmp6, decode it. */ 385 if (d != NULL) { 386 ip6cp = (struct ip6ctlparam *)d; 387 } else { 388 ip6cp = (struct ip6ctlparam *)NULL; 389 } 390 391 if (ip6cp) { 392 /* 393 * XXX: We assume that when IPV6 is non NULL, M and OFF are 394 * valid. 395 */ 396 struct sctp_inpcb *inp = NULL; 397 struct sctp_tcb *stcb = NULL; 398 struct sctp_nets *net = NULL; 399 struct sockaddr_in6 final; 400 401 if (ip6cp->ip6c_m == NULL) 402 return; 403 404 /* Check if we can safely examine the SCTP header. */ 405 if (ip6cp->ip6c_m->m_pkthdr.len < ip6cp->ip6c_off + sizeof(sh)) 406 return; 407 408 bzero(&sh, sizeof(sh)); 409 bzero(&final, sizeof(final)); 410 inp = NULL; 411 net = NULL; 412 m_copydata(ip6cp->ip6c_m, ip6cp->ip6c_off, sizeof(sh), 413 (caddr_t)&sh); 414 ip6cp->ip6c_src->sin6_port = sh.src_port; 415 final.sin6_len = sizeof(final); 416 final.sin6_family = AF_INET6; 417 final.sin6_addr = ((struct sockaddr_in6 *)pktdst)->sin6_addr; 418 final.sin6_port = sh.dest_port; 419 stcb = sctp_findassociation_addr_sa((struct sockaddr *)&final, 420 (struct sockaddr *)ip6cp->ip6c_src, 421 &inp, &net, 1, vrf_id); 422 /* inp's ref-count increased && stcb locked */ 423 if (stcb != NULL && inp && (inp->sctp_socket != NULL)) { 424 if (cmd == PRC_MSGSIZE) { 425 sctp6_notify_mbuf(inp, 426 ip6cp->ip6c_icmp6, 427 &sh, 428 stcb, 429 net); 430 /* inp's ref-count reduced && stcb unlocked */ 431 } else { 432 sctp6_notify(inp, ip6cp->ip6c_icmp6, &sh, 433 (struct sockaddr *)&final, 434 stcb, net); 435 /* inp's ref-count reduced && stcb unlocked */ 436 } 437 } else { 438 if (PRC_IS_REDIRECT(cmd) && inp) { 439 in6_rtchange((struct in6pcb *)inp, 440 inet6ctlerrmap[cmd]); 441 } 442 if (inp) { 443 /* reduce inp's ref-count */ 444 SCTP_INP_WLOCK(inp); 445 SCTP_INP_DECR_REF(inp); 446 SCTP_INP_WUNLOCK(inp); 447 } 448 if (stcb) 449 SCTP_TCB_UNLOCK(stcb); 450 } 451 } 452} 453 454/* 455 * this routine can probably be collasped into the one in sctp_userreq.c 456 * since they do the same thing and now we lookup with a sockaddr 457 */ 458static int 459sctp6_getcred(SYSCTL_HANDLER_ARGS) 460{ 461 struct xucred xuc; 462 struct sockaddr_in6 addrs[2]; 463 struct sctp_inpcb *inp; 464 struct sctp_nets *net; 465 struct sctp_tcb *stcb; 466 int error; 467 uint32_t vrf_id; 468 469 vrf_id = SCTP_DEFAULT_VRFID; 470 471 error = priv_check(req->td, PRIV_NETINET_GETCRED); 472 if (error) 473 return (error); 474 475 if (req->newlen != sizeof(addrs)) { 476 SCTP_LTRACE_ERR_RET(NULL, NULL, NULL, SCTP_FROM_SCTP6_USRREQ, EINVAL); 477 return (EINVAL); 478 } 479 if (req->oldlen != sizeof(struct ucred)) { 480 SCTP_LTRACE_ERR_RET(NULL, NULL, NULL, SCTP_FROM_SCTP6_USRREQ, EINVAL); 481 return (EINVAL); 482 } 483 error = SYSCTL_IN(req, addrs, sizeof(addrs)); 484 if (error) 485 return (error); 486 487 stcb = sctp_findassociation_addr_sa(sin6tosa(&addrs[1]), 488 sin6tosa(&addrs[0]), 489 &inp, &net, 1, vrf_id); 490 if (stcb == NULL || inp == NULL || inp->sctp_socket == NULL) { 491 if ((inp != NULL) && (stcb == NULL)) { 492 /* reduce ref-count */ 493 SCTP_INP_WLOCK(inp); 494 SCTP_INP_DECR_REF(inp); 495 goto cred_can_cont; 496 } 497 SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP6_USRREQ, ENOENT); 498 error = ENOENT; 499 goto out; 500 } 501 SCTP_TCB_UNLOCK(stcb); 502 /* 503 * We use the write lock here, only since in the error leg we need 504 * it. If we used RLOCK, then we would have to 505 * wlock/decr/unlock/rlock. Which in theory could create a hole. 506 * Better to use higher wlock. 507 */ 508 SCTP_INP_WLOCK(inp); 509cred_can_cont: 510 error = cr_canseesocket(req->td->td_ucred, inp->sctp_socket); 511 if (error) { 512 SCTP_INP_WUNLOCK(inp); 513 goto out; 514 } 515 cru2x(inp->sctp_socket->so_cred, &xuc); 516 SCTP_INP_WUNLOCK(inp); 517 error = SYSCTL_OUT(req, &xuc, sizeof(struct xucred)); 518out: 519 return (error); 520} 521 522SYSCTL_PROC(_net_inet6_sctp6, OID_AUTO, getcred, CTLTYPE_OPAQUE | CTLFLAG_RW, 523 0, 0, 524 sctp6_getcred, "S,ucred", "Get the ucred of a SCTP6 connection"); 525 526 527/* This is the same as the sctp_abort() could be made common */ 528static void 529sctp6_abort(struct socket *so) 530{ 531 struct sctp_inpcb *inp; 532 uint32_t flags; 533 534 inp = (struct sctp_inpcb *)so->so_pcb; 535 if (inp == NULL) { 536 SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP6_USRREQ, EINVAL); 537 return; 538 } 539sctp_must_try_again: 540 flags = inp->sctp_flags; 541#ifdef SCTP_LOG_CLOSING 542 sctp_log_closing(inp, NULL, 17); 543#endif 544 if (((flags & SCTP_PCB_FLAGS_SOCKET_GONE) == 0) && 545 (atomic_cmpset_int(&inp->sctp_flags, flags, (flags | SCTP_PCB_FLAGS_SOCKET_GONE | SCTP_PCB_FLAGS_CLOSE_IP)))) { 546#ifdef SCTP_LOG_CLOSING 547 sctp_log_closing(inp, NULL, 16); 548#endif 549 sctp_inpcb_free(inp, SCTP_FREE_SHOULD_USE_ABORT, 550 SCTP_CALLED_AFTER_CMPSET_OFCLOSE); 551 SOCK_LOCK(so); 552 SCTP_SB_CLEAR(so->so_snd); 553 /* 554 * same for the rcv ones, they are only here for the 555 * accounting/select. 556 */ 557 SCTP_SB_CLEAR(so->so_rcv); 558 /* Now null out the reference, we are completely detached. */ 559 so->so_pcb = NULL; 560 SOCK_UNLOCK(so); 561 } else { 562 flags = inp->sctp_flags; 563 if ((flags & SCTP_PCB_FLAGS_SOCKET_GONE) == 0) { 564 goto sctp_must_try_again; 565 } 566 } 567 return; 568} 569 570static int 571sctp6_attach(struct socket *so, int proto SCTP_UNUSED, struct thread *p SCTP_UNUSED) 572{ 573 struct in6pcb *inp6; 574 int error; 575 struct sctp_inpcb *inp; 576 uint32_t vrf_id = SCTP_DEFAULT_VRFID; 577 578 inp = (struct sctp_inpcb *)so->so_pcb; 579 if (inp != NULL) { 580 SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP6_USRREQ, EINVAL); 581 return (EINVAL); 582 } 583 if (so->so_snd.sb_hiwat == 0 || so->so_rcv.sb_hiwat == 0) { 584 error = SCTP_SORESERVE(so, SCTP_BASE_SYSCTL(sctp_sendspace), SCTP_BASE_SYSCTL(sctp_recvspace)); 585 if (error) 586 return (error); 587 } 588 error = sctp_inpcb_alloc(so, vrf_id); 589 if (error) 590 return (error); 591 inp = (struct sctp_inpcb *)so->so_pcb; 592 SCTP_INP_WLOCK(inp); 593 inp->sctp_flags |= SCTP_PCB_FLAGS_BOUND_V6; /* I'm v6! */ 594 inp6 = (struct in6pcb *)inp; 595 596 inp6->inp_vflag |= INP_IPV6; 597 inp6->in6p_hops = -1; /* use kernel default */ 598 inp6->in6p_cksum = -1; /* just to be sure */ 599#ifdef INET 600 /* 601 * XXX: ugly!! IPv4 TTL initialization is necessary for an IPv6 602 * socket as well, because the socket may be bound to an IPv6 603 * wildcard address, which may match an IPv4-mapped IPv6 address. 604 */ 605 inp6->inp_ip_ttl = MODULE_GLOBAL(ip_defttl); 606#endif 607 /* 608 * Hmm what about the IPSEC stuff that is missing here but in 609 * sctp_attach()? 610 */ 611 SCTP_INP_WUNLOCK(inp); 612 return (0); 613} 614 615static int 616sctp6_bind(struct socket *so, struct sockaddr *addr, struct thread *p) 617{ 618 struct sctp_inpcb *inp; 619 struct in6pcb *inp6; 620 int error; 621 622 inp = (struct sctp_inpcb *)so->so_pcb; 623 if (inp == NULL) { 624 SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP6_USRREQ, EINVAL); 625 return (EINVAL); 626 } 627 if (addr) { 628 switch (addr->sa_family) { 629#ifdef INET 630 case AF_INET: 631 if (addr->sa_len != sizeof(struct sockaddr_in)) { 632 SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP6_USRREQ, EINVAL); 633 return (EINVAL); 634 } 635 break; 636#endif 637#ifdef INET6 638 case AF_INET6: 639 if (addr->sa_len != sizeof(struct sockaddr_in6)) { 640 SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP6_USRREQ, EINVAL); 641 return (EINVAL); 642 } 643 break; 644#endif 645 default: 646 SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP6_USRREQ, EINVAL); 647 return (EINVAL); 648 } 649 } 650 inp6 = (struct in6pcb *)inp; 651 inp6->inp_vflag &= ~INP_IPV4; 652 inp6->inp_vflag |= INP_IPV6; 653 if ((addr != NULL) && (SCTP_IPV6_V6ONLY(inp6) == 0)) { 654 switch (addr->sa_family) { 655#ifdef INET 656 case AF_INET: 657 /* binding v4 addr to v6 socket, so reset flags */ 658 inp6->inp_vflag |= INP_IPV4; 659 inp6->inp_vflag &= ~INP_IPV6; 660 break; 661#endif 662#ifdef INET6 663 case AF_INET6: 664 { 665 struct sockaddr_in6 *sin6_p; 666 667 sin6_p = (struct sockaddr_in6 *)addr; 668 669 if (IN6_IS_ADDR_UNSPECIFIED(&sin6_p->sin6_addr)) { 670 inp6->inp_vflag |= INP_IPV4; 671 } 672#ifdef INET 673 if (IN6_IS_ADDR_V4MAPPED(&sin6_p->sin6_addr)) { 674 struct sockaddr_in sin; 675 676 in6_sin6_2_sin(&sin, sin6_p); 677 inp6->inp_vflag |= INP_IPV4; 678 inp6->inp_vflag &= ~INP_IPV6; 679 error = sctp_inpcb_bind(so, (struct sockaddr *)&sin, NULL, p); 680 return (error); 681 } 682#endif 683 break; 684 } 685#endif 686 default: 687 break; 688 } 689 } else if (addr != NULL) { 690 struct sockaddr_in6 *sin6_p; 691 692 /* IPV6_V6ONLY socket */ 693#ifdef INET 694 if (addr->sa_family == AF_INET) { 695 /* can't bind v4 addr to v6 only socket! */ 696 SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP6_USRREQ, EINVAL); 697 return (EINVAL); 698 } 699#endif 700 sin6_p = (struct sockaddr_in6 *)addr; 701 702 if (IN6_IS_ADDR_V4MAPPED(&sin6_p->sin6_addr)) { 703 /* can't bind v4-mapped addrs either! */ 704 /* NOTE: we don't support SIIT */ 705 SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP6_USRREQ, EINVAL); 706 return (EINVAL); 707 } 708 } 709 error = sctp_inpcb_bind(so, addr, NULL, p); 710 return (error); 711} 712 713 714static void 715sctp6_close(struct socket *so) 716{ 717 sctp_close(so); 718} 719 720/* This could be made common with sctp_detach() since they are identical */ 721 722static 723int 724sctp6_disconnect(struct socket *so) 725{ 726 return (sctp_disconnect(so)); 727} 728 729 730int 731sctp_sendm(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr, 732 struct mbuf *control, struct thread *p); 733 734 735static int 736sctp6_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr, 737 struct mbuf *control, struct thread *p) 738{ 739 struct sctp_inpcb *inp; 740 struct in6pcb *inp6; 741 742#ifdef INET 743 struct sockaddr_in6 *sin6; 744 745#endif /* INET */ 746 /* No SPL needed since sctp_output does this */ 747 748 inp = (struct sctp_inpcb *)so->so_pcb; 749 if (inp == NULL) { 750 if (control) { 751 SCTP_RELEASE_PKT(control); 752 control = NULL; 753 } 754 SCTP_RELEASE_PKT(m); 755 SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP6_USRREQ, EINVAL); 756 return (EINVAL); 757 } 758 inp6 = (struct in6pcb *)inp; 759 /* 760 * For the TCP model we may get a NULL addr, if we are a connected 761 * socket thats ok. 762 */ 763 if ((inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) && 764 (addr == NULL)) { 765 goto connected_type; 766 } 767 if (addr == NULL) { 768 SCTP_RELEASE_PKT(m); 769 if (control) { 770 SCTP_RELEASE_PKT(control); 771 control = NULL; 772 } 773 SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP6_USRREQ, EDESTADDRREQ); 774 return (EDESTADDRREQ); 775 } 776#ifdef INET 777 sin6 = (struct sockaddr_in6 *)addr; 778 if (SCTP_IPV6_V6ONLY(inp6)) { 779 /* 780 * if IPV6_V6ONLY flag, we discard datagrams destined to a 781 * v4 addr or v4-mapped addr 782 */ 783 if (addr->sa_family == AF_INET) { 784 SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP6_USRREQ, EINVAL); 785 return (EINVAL); 786 } 787 if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) { 788 SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP6_USRREQ, EINVAL); 789 return (EINVAL); 790 } 791 } 792 if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) { 793 struct sockaddr_in sin; 794 795 /* convert v4-mapped into v4 addr and send */ 796 in6_sin6_2_sin(&sin, sin6); 797 return (sctp_sendm(so, flags, m, (struct sockaddr *)&sin, control, p)); 798 } 799#endif /* INET */ 800connected_type: 801 /* now what about control */ 802 if (control) { 803 if (inp->control) { 804 SCTP_PRINTF("huh? control set?\n"); 805 SCTP_RELEASE_PKT(inp->control); 806 inp->control = NULL; 807 } 808 inp->control = control; 809 } 810 /* Place the data */ 811 if (inp->pkt) { 812 SCTP_BUF_NEXT(inp->pkt_last) = m; 813 inp->pkt_last = m; 814 } else { 815 inp->pkt_last = inp->pkt = m; 816 } 817 if ( 818 /* FreeBSD and MacOSX uses a flag passed */ 819 ((flags & PRUS_MORETOCOME) == 0) 820 ) { 821 /* 822 * note with the current version this code will only be used 823 * by OpenBSD, NetBSD and FreeBSD have methods for 824 * re-defining sosend() to use sctp_sosend(). One can 825 * optionaly switch back to this code (by changing back the 826 * defininitions but this is not advisable. 827 */ 828 int ret; 829 830 ret = sctp_output(inp, inp->pkt, addr, inp->control, p, flags); 831 inp->pkt = NULL; 832 inp->control = NULL; 833 return (ret); 834 } else { 835 return (0); 836 } 837} 838 839static int 840sctp6_connect(struct socket *so, struct sockaddr *addr, struct thread *p) 841{ 842 uint32_t vrf_id; 843 int error = 0; 844 struct sctp_inpcb *inp; 845 struct sctp_tcb *stcb; 846 847#ifdef INET 848 struct in6pcb *inp6; 849 struct sockaddr_in6 *sin6; 850 struct sockaddr_storage ss; 851 852#endif 853 854#ifdef INET 855 inp6 = (struct in6pcb *)so->so_pcb; 856#endif 857 inp = (struct sctp_inpcb *)so->so_pcb; 858 if (inp == NULL) { 859 SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP6_USRREQ, ECONNRESET); 860 return (ECONNRESET); /* I made the same as TCP since we are 861 * not setup? */ 862 } 863 if (addr == NULL) { 864 SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP6_USRREQ, EINVAL); 865 return (EINVAL); 866 } 867 switch (addr->sa_family) { 868#ifdef INET 869 case AF_INET: 870 if (addr->sa_len != sizeof(struct sockaddr_in)) { 871 SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP6_USRREQ, EINVAL); 872 return (EINVAL); 873 } 874 break; 875#endif 876#ifdef INET6 877 case AF_INET6: 878 if (addr->sa_len != sizeof(struct sockaddr_in6)) { 879 SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP6_USRREQ, EINVAL); 880 return (EINVAL); 881 } 882 break; 883#endif 884 default: 885 SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP6_USRREQ, EINVAL); 886 return (EINVAL); 887 } 888 889 vrf_id = inp->def_vrf_id; 890 SCTP_ASOC_CREATE_LOCK(inp); 891 SCTP_INP_RLOCK(inp); 892 if ((inp->sctp_flags & SCTP_PCB_FLAGS_UNBOUND) == 893 SCTP_PCB_FLAGS_UNBOUND) { 894 /* Bind a ephemeral port */ 895 SCTP_INP_RUNLOCK(inp); 896 error = sctp6_bind(so, NULL, p); 897 if (error) { 898 SCTP_ASOC_CREATE_UNLOCK(inp); 899 900 return (error); 901 } 902 SCTP_INP_RLOCK(inp); 903 } 904 if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) && 905 (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED)) { 906 /* We are already connected AND the TCP model */ 907 SCTP_INP_RUNLOCK(inp); 908 SCTP_ASOC_CREATE_UNLOCK(inp); 909 SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP6_USRREQ, EADDRINUSE); 910 return (EADDRINUSE); 911 } 912#ifdef INET 913 sin6 = (struct sockaddr_in6 *)addr; 914 if (SCTP_IPV6_V6ONLY(inp6)) { 915 /* 916 * if IPV6_V6ONLY flag, ignore connections destined to a v4 917 * addr or v4-mapped addr 918 */ 919 if (addr->sa_family == AF_INET) { 920 SCTP_INP_RUNLOCK(inp); 921 SCTP_ASOC_CREATE_UNLOCK(inp); 922 SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP6_USRREQ, EINVAL); 923 return (EINVAL); 924 } 925 if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) { 926 SCTP_INP_RUNLOCK(inp); 927 SCTP_ASOC_CREATE_UNLOCK(inp); 928 SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP6_USRREQ, EINVAL); 929 return (EINVAL); 930 } 931 } 932 if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) { 933 /* convert v4-mapped into v4 addr */ 934 in6_sin6_2_sin((struct sockaddr_in *)&ss, sin6); 935 addr = (struct sockaddr *)&ss; 936 } 937#endif /* INET */ 938 /* Now do we connect? */ 939 if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) { 940 stcb = LIST_FIRST(&inp->sctp_asoc_list); 941 if (stcb) { 942 SCTP_TCB_UNLOCK(stcb); 943 } 944 SCTP_INP_RUNLOCK(inp); 945 } else { 946 SCTP_INP_RUNLOCK(inp); 947 SCTP_INP_WLOCK(inp); 948 SCTP_INP_INCR_REF(inp); 949 SCTP_INP_WUNLOCK(inp); 950 stcb = sctp_findassociation_ep_addr(&inp, addr, NULL, NULL, NULL); 951 if (stcb == NULL) { 952 SCTP_INP_WLOCK(inp); 953 SCTP_INP_DECR_REF(inp); 954 SCTP_INP_WUNLOCK(inp); 955 } 956 } 957 958 if (stcb != NULL) { 959 /* Already have or am bring up an association */ 960 SCTP_ASOC_CREATE_UNLOCK(inp); 961 SCTP_TCB_UNLOCK(stcb); 962 SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP6_USRREQ, EALREADY); 963 return (EALREADY); 964 } 965 /* We are GOOD to go */ 966 stcb = sctp_aloc_assoc(inp, addr, &error, 0, vrf_id, p); 967 SCTP_ASOC_CREATE_UNLOCK(inp); 968 if (stcb == NULL) { 969 /* Gak! no memory */ 970 return (error); 971 } 972 if (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) { 973 stcb->sctp_ep->sctp_flags |= SCTP_PCB_FLAGS_CONNECTED; 974 /* Set the connected flag so we can queue data */ 975 soisconnecting(so); 976 } 977 stcb->asoc.state = SCTP_STATE_COOKIE_WAIT; 978 (void)SCTP_GETTIME_TIMEVAL(&stcb->asoc.time_entered); 979 980 /* initialize authentication parameters for the assoc */ 981 sctp_initialize_auth_params(inp, stcb); 982 983 sctp_send_initiate(inp, stcb, SCTP_SO_LOCKED); 984 SCTP_TCB_UNLOCK(stcb); 985 return (error); 986} 987 988static int 989sctp6_getaddr(struct socket *so, struct sockaddr **addr) 990{ 991 struct sockaddr_in6 *sin6; 992 struct sctp_inpcb *inp; 993 uint32_t vrf_id; 994 struct sctp_ifa *sctp_ifa; 995 996 int error; 997 998 /* 999 * Do the malloc first in case it blocks. 1000 */ 1001 SCTP_MALLOC_SONAME(sin6, struct sockaddr_in6 *, sizeof(*sin6)); 1002 if (sin6 == NULL) 1003 return (ENOMEM); 1004 sin6->sin6_family = AF_INET6; 1005 sin6->sin6_len = sizeof(*sin6); 1006 1007 inp = (struct sctp_inpcb *)so->so_pcb; 1008 if (inp == NULL) { 1009 SCTP_FREE_SONAME(sin6); 1010 SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP6_USRREQ, ECONNRESET); 1011 return (ECONNRESET); 1012 } 1013 SCTP_INP_RLOCK(inp); 1014 sin6->sin6_port = inp->sctp_lport; 1015 if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) { 1016 /* For the bound all case you get back 0 */ 1017 if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) { 1018 struct sctp_tcb *stcb; 1019 struct sockaddr_in6 *sin_a6; 1020 struct sctp_nets *net; 1021 int fnd; 1022 1023 stcb = LIST_FIRST(&inp->sctp_asoc_list); 1024 if (stcb == NULL) { 1025 goto notConn6; 1026 } 1027 fnd = 0; 1028 sin_a6 = NULL; 1029 TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) { 1030 sin_a6 = (struct sockaddr_in6 *)&net->ro._l_addr; 1031 if (sin_a6 == NULL) 1032 /* this will make coverity happy */ 1033 continue; 1034 1035 if (sin_a6->sin6_family == AF_INET6) { 1036 fnd = 1; 1037 break; 1038 } 1039 } 1040 if ((!fnd) || (sin_a6 == NULL)) { 1041 /* punt */ 1042 goto notConn6; 1043 } 1044 vrf_id = inp->def_vrf_id; 1045 sctp_ifa = sctp_source_address_selection(inp, stcb, (sctp_route_t *) & net->ro, net, 0, vrf_id); 1046 if (sctp_ifa) { 1047 sin6->sin6_addr = sctp_ifa->address.sin6.sin6_addr; 1048 } 1049 } else { 1050 /* For the bound all case you get back 0 */ 1051 notConn6: 1052 memset(&sin6->sin6_addr, 0, sizeof(sin6->sin6_addr)); 1053 } 1054 } else { 1055 /* Take the first IPv6 address in the list */ 1056 struct sctp_laddr *laddr; 1057 int fnd = 0; 1058 1059 LIST_FOREACH(laddr, &inp->sctp_addr_list, sctp_nxt_addr) { 1060 if (laddr->ifa->address.sa.sa_family == AF_INET6) { 1061 struct sockaddr_in6 *sin_a; 1062 1063 sin_a = (struct sockaddr_in6 *)&laddr->ifa->address.sin6; 1064 sin6->sin6_addr = sin_a->sin6_addr; 1065 fnd = 1; 1066 break; 1067 } 1068 } 1069 if (!fnd) { 1070 SCTP_FREE_SONAME(sin6); 1071 SCTP_INP_RUNLOCK(inp); 1072 SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP6_USRREQ, ENOENT); 1073 return (ENOENT); 1074 } 1075 } 1076 SCTP_INP_RUNLOCK(inp); 1077 /* Scoping things for v6 */ 1078 if ((error = sa6_recoverscope(sin6)) != 0) { 1079 SCTP_FREE_SONAME(sin6); 1080 return (error); 1081 } 1082 (*addr) = (struct sockaddr *)sin6; 1083 return (0); 1084} 1085 1086static int 1087sctp6_peeraddr(struct socket *so, struct sockaddr **addr) 1088{ 1089 struct sockaddr_in6 *sin6; 1090 int fnd; 1091 struct sockaddr_in6 *sin_a6; 1092 struct sctp_inpcb *inp; 1093 struct sctp_tcb *stcb; 1094 struct sctp_nets *net; 1095 int error; 1096 1097 /* Do the malloc first in case it blocks. */ 1098 SCTP_MALLOC_SONAME(sin6, struct sockaddr_in6 *, sizeof *sin6); 1099 if (sin6 == NULL) 1100 return (ENOMEM); 1101 sin6->sin6_family = AF_INET6; 1102 sin6->sin6_len = sizeof(*sin6); 1103 1104 inp = (struct sctp_inpcb *)so->so_pcb; 1105 if ((inp == NULL) || 1106 ((inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) == 0)) { 1107 /* UDP type and listeners will drop out here */ 1108 SCTP_FREE_SONAME(sin6); 1109 SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP6_USRREQ, ENOTCONN); 1110 return (ENOTCONN); 1111 } 1112 SCTP_INP_RLOCK(inp); 1113 stcb = LIST_FIRST(&inp->sctp_asoc_list); 1114 if (stcb) { 1115 SCTP_TCB_LOCK(stcb); 1116 } 1117 SCTP_INP_RUNLOCK(inp); 1118 if (stcb == NULL) { 1119 SCTP_FREE_SONAME(sin6); 1120 SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP6_USRREQ, ECONNRESET); 1121 return (ECONNRESET); 1122 } 1123 fnd = 0; 1124 TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) { 1125 sin_a6 = (struct sockaddr_in6 *)&net->ro._l_addr; 1126 if (sin_a6->sin6_family == AF_INET6) { 1127 fnd = 1; 1128 sin6->sin6_port = stcb->rport; 1129 sin6->sin6_addr = sin_a6->sin6_addr; 1130 break; 1131 } 1132 } 1133 SCTP_TCB_UNLOCK(stcb); 1134 if (!fnd) { 1135 /* No IPv4 address */ 1136 SCTP_FREE_SONAME(sin6); 1137 SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP6_USRREQ, ENOENT); 1138 return (ENOENT); 1139 } 1140 if ((error = sa6_recoverscope(sin6)) != 0) 1141 return (error); 1142 *addr = (struct sockaddr *)sin6; 1143 return (0); 1144} 1145 1146static int 1147sctp6_in6getaddr(struct socket *so, struct sockaddr **nam) 1148{ 1149#ifdef INET 1150 struct sockaddr *addr; 1151 1152#endif 1153 struct in6pcb *inp6 = sotoin6pcb(so); 1154 int error; 1155 1156 if (inp6 == NULL) { 1157 SCTP_LTRACE_ERR_RET(NULL, NULL, NULL, SCTP_FROM_SCTP6_USRREQ, EINVAL); 1158 return (EINVAL); 1159 } 1160 /* allow v6 addresses precedence */ 1161 error = sctp6_getaddr(so, nam); 1162#ifdef INET 1163 if (error) { 1164 /* try v4 next if v6 failed */ 1165 error = sctp_ingetaddr(so, nam); 1166 if (error) { 1167 return (error); 1168 } 1169 addr = *nam; 1170 /* if I'm V6ONLY, convert it to v4-mapped */ 1171 if (SCTP_IPV6_V6ONLY(inp6)) { 1172 struct sockaddr_in6 sin6; 1173 1174 in6_sin_2_v4mapsin6((struct sockaddr_in *)addr, &sin6); 1175 memcpy(addr, &sin6, sizeof(struct sockaddr_in6)); 1176 } 1177 } 1178#endif 1179 return (error); 1180} 1181 1182 1183static int 1184sctp6_getpeeraddr(struct socket *so, struct sockaddr **nam) 1185{ 1186#ifdef INET 1187 struct sockaddr *addr; 1188 1189#endif 1190 struct in6pcb *inp6 = sotoin6pcb(so); 1191 int error; 1192 1193 if (inp6 == NULL) { 1194 SCTP_LTRACE_ERR_RET(NULL, NULL, NULL, SCTP_FROM_SCTP6_USRREQ, EINVAL); 1195 return (EINVAL); 1196 } 1197 /* allow v6 addresses precedence */ 1198 error = sctp6_peeraddr(so, nam); 1199#ifdef INET 1200 if (error) { 1201 /* try v4 next if v6 failed */ 1202 error = sctp_peeraddr(so, nam); 1203 if (error) { 1204 return (error); 1205 } 1206 addr = *nam; 1207 /* if I'm V6ONLY, convert it to v4-mapped */ 1208 if (SCTP_IPV6_V6ONLY(inp6)) { 1209 struct sockaddr_in6 sin6; 1210 1211 in6_sin_2_v4mapsin6((struct sockaddr_in *)addr, &sin6); 1212 memcpy(addr, &sin6, sizeof(struct sockaddr_in6)); 1213 } 1214 } 1215#endif 1216 return (error); 1217} 1218 1219struct pr_usrreqs sctp6_usrreqs = { 1220 .pru_abort = sctp6_abort, 1221 .pru_accept = sctp_accept, 1222 .pru_attach = sctp6_attach, 1223 .pru_bind = sctp6_bind, 1224 .pru_connect = sctp6_connect, 1225 .pru_control = in6_control, 1226 .pru_close = sctp6_close, 1227 .pru_detach = sctp6_close, 1228 .pru_sopoll = sopoll_generic, 1229 .pru_flush = sctp_flush, 1230 .pru_disconnect = sctp6_disconnect, 1231 .pru_listen = sctp_listen, 1232 .pru_peeraddr = sctp6_getpeeraddr, 1233 .pru_send = sctp6_send, 1234 .pru_shutdown = sctp_shutdown, 1235 .pru_sockaddr = sctp6_in6getaddr, 1236 .pru_sosend = sctp_sosend, 1237 .pru_soreceive = sctp_soreceive 1238}; 1239 1240#endif 1241