2006-11-03 15:23:16 +00:00
|
|
|
/*-
|
2017-11-20 19:43:44 +00:00
|
|
|
* SPDX-License-Identifier: BSD-3-Clause
|
|
|
|
*
|
2008-12-06 13:19:54 +00:00
|
|
|
* Copyright (c) 2001-2008, by Cisco Systems, Inc. All rights reserved.
|
2012-05-23 11:26:28 +00:00
|
|
|
* Copyright (c) 2008-2012, by Randall Stewart. All rights reserved.
|
|
|
|
* Copyright (c) 2008-2012, by Michael Tuexen. All rights reserved.
|
2006-11-03 15:23:16 +00:00
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions are met:
|
|
|
|
*
|
|
|
|
* a) Redistributions of source code must retain the above copyright notice,
|
2011-12-17 19:21:40 +00:00
|
|
|
* this list of conditions and the following disclaimer.
|
2006-11-03 15:23:16 +00:00
|
|
|
*
|
|
|
|
* b) Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in
|
2011-12-17 19:21:40 +00:00
|
|
|
* the documentation and/or other materials provided with the distribution.
|
2006-11-03 15:23:16 +00:00
|
|
|
*
|
|
|
|
* c) Neither the name of Cisco Systems, Inc. nor the names of its
|
|
|
|
* contributors may be used to endorse or promote products derived
|
|
|
|
* from this software without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
|
|
|
|
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
|
|
|
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
|
|
|
|
* THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
2012-05-23 11:26:28 +00:00
|
|
|
|
2006-11-03 15:23:16 +00:00
|
|
|
#include <netinet/sctp_os.h>
|
2007-01-18 09:58:43 +00:00
|
|
|
#include <sys/proc.h>
|
2006-11-03 15:23:16 +00:00
|
|
|
#include <netinet/sctp_pcb.h>
|
|
|
|
#include <netinet/sctp_header.h>
|
|
|
|
#include <netinet/sctp_var.h>
|
2012-07-15 11:04:49 +00:00
|
|
|
#ifdef INET6
|
2014-12-06 20:00:08 +00:00
|
|
|
#include <netinet6/sctp6_var.h>
|
2007-03-19 06:53:02 +00:00
|
|
|
#endif
|
2007-03-15 11:27:14 +00:00
|
|
|
#include <netinet/sctp_sysctl.h>
|
2006-11-03 15:23:16 +00:00
|
|
|
#include <netinet/sctp_output.h>
|
|
|
|
#include <netinet/sctp_uio.h>
|
|
|
|
#include <netinet/sctp_asconf.h>
|
|
|
|
#include <netinet/sctputil.h>
|
|
|
|
#include <netinet/sctp_indata.h>
|
|
|
|
#include <netinet/sctp_timer.h>
|
|
|
|
#include <netinet/sctp_auth.h>
|
2007-05-29 09:29:03 +00:00
|
|
|
#include <netinet/sctp_bsd_addr.h>
|
2008-12-06 13:19:54 +00:00
|
|
|
#include <netinet/udp.h>
|
2019-10-13 18:17:08 +00:00
|
|
|
#include <sys/eventhandler.h>
|
2007-05-29 09:29:03 +00:00
|
|
|
|
2016-03-23 13:28:04 +00:00
|
|
|
extern const struct sctp_cc_functions sctp_cc_functions[];
|
|
|
|
extern const struct sctp_ss_functions sctp_ss_functions[];
|
2006-11-03 15:23:16 +00:00
|
|
|
|
|
|
|
void
|
|
|
|
sctp_init(void)
|
|
|
|
{
|
|
|
|
u_long sb_max_adj;
|
|
|
|
|
2008-06-14 07:58:05 +00:00
|
|
|
/* Initialize and modify the sysctled variables */
|
|
|
|
sctp_init_sysctls();
|
2006-11-03 15:23:16 +00:00
|
|
|
if ((nmbclusters / 8) > SCTP_ASOC_MAX_CHUNKS_ON_QUEUE)
|
2008-06-14 07:58:05 +00:00
|
|
|
SCTP_BASE_SYSCTL(sctp_max_chunks_on_queue) = (nmbclusters / 8);
|
2006-11-03 15:23:16 +00:00
|
|
|
/*
|
|
|
|
* Allow a user to take no more than 1/2 the number of clusters or
|
2020-06-06 18:20:09 +00:00
|
|
|
* the SB_MAX, whichever is smaller, for the send window.
|
2006-11-03 15:23:16 +00:00
|
|
|
*/
|
2018-07-19 20:11:14 +00:00
|
|
|
sb_max_adj = (u_long)((u_quad_t)(SB_MAX) * MCLBYTES / (MSIZE + MCLBYTES));
|
2008-06-14 07:58:05 +00:00
|
|
|
SCTP_BASE_SYSCTL(sctp_sendspace) = min(sb_max_adj,
|
2018-07-19 20:11:14 +00:00
|
|
|
(((uint32_t)nmbclusters / 2) * SCTP_DEFAULT_MAXSEGMENT));
|
2006-11-03 15:23:16 +00:00
|
|
|
/*
|
|
|
|
* Now for the recv window, should we take the same amount? or
|
|
|
|
* should I do 1/2 the SB_MAX instead in the SB_MAX min above. For
|
|
|
|
* now I will just copy.
|
|
|
|
*/
|
2008-06-14 07:58:05 +00:00
|
|
|
SCTP_BASE_SYSCTL(sctp_recvspace) = SCTP_BASE_SYSCTL(sctp_sendspace);
|
|
|
|
SCTP_BASE_VAR(first_time) = 0;
|
|
|
|
SCTP_BASE_VAR(sctp_pcb_initialized) = 0;
|
|
|
|
sctp_pcb_init();
|
|
|
|
#if defined(SCTP_PACKET_LOGGING)
|
|
|
|
SCTP_BASE_VAR(packet_log_writers) = 0;
|
|
|
|
SCTP_BASE_VAR(packet_log_end) = 0;
|
2017-07-19 14:28:58 +00:00
|
|
|
memset(&SCTP_BASE_VAR(packet_log_buffer), 0, SCTP_PACKET_LOG_SIZE);
|
2008-06-14 07:58:05 +00:00
|
|
|
#endif
|
2019-10-24 09:22:23 +00:00
|
|
|
SCTP_BASE_VAR(eh_tag) = EVENTHANDLER_REGISTER(rt_addrmsg,
|
|
|
|
sctp_addr_change_event_handler, NULL, EVENTHANDLER_PRI_FIRST);
|
2008-06-14 07:58:05 +00:00
|
|
|
}
|
|
|
|
|
2016-06-01 10:14:04 +00:00
|
|
|
#ifdef VIMAGE
|
|
|
|
static void
|
|
|
|
sctp_finish(void *unused __unused)
|
2008-06-14 07:58:05 +00:00
|
|
|
{
|
2020-07-10 14:56:05 +00:00
|
|
|
EVENTHANDLER_DEREGISTER(rt_addrmsg, SCTP_BASE_VAR(eh_tag));
|
2008-06-14 07:58:05 +00:00
|
|
|
sctp_pcb_finish();
|
|
|
|
}
|
2020-07-10 16:59:06 +00:00
|
|
|
|
2016-06-01 10:14:04 +00:00
|
|
|
VNET_SYSUNINIT(sctp, SI_SUB_PROTO_DOMAIN, SI_ORDER_FOURTH, sctp_finish, NULL);
|
|
|
|
#endif
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2008-05-20 13:47:46 +00:00
|
|
|
void
|
2011-12-17 19:21:40 +00:00
|
|
|
sctp_pathmtu_adjustment(struct sctp_tcb *stcb, uint16_t nxtsz)
|
2006-11-03 15:23:16 +00:00
|
|
|
{
|
|
|
|
struct sctp_tmit_chunk *chk;
|
2009-09-16 14:23:31 +00:00
|
|
|
uint16_t overhead;
|
2006-11-03 15:23:16 +00:00
|
|
|
|
|
|
|
/* Adjust that too */
|
|
|
|
stcb->asoc.smallest_mtu = nxtsz;
|
|
|
|
/* now off to subtract IP_DF flag if needed */
|
2017-01-31 23:36:31 +00:00
|
|
|
overhead = IP_HDR_SIZE + sizeof(struct sctphdr);
|
2009-09-16 14:23:31 +00:00
|
|
|
if (sctp_auth_is_required_chunk(SCTP_DATA, stcb->asoc.peer_auth_chunks)) {
|
|
|
|
overhead += sctp_get_auth_chunk_len(stcb->asoc.peer_hmac_id);
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
TAILQ_FOREACH(chk, &stcb->asoc.send_queue, sctp_next) {
|
2009-09-16 14:23:31 +00:00
|
|
|
if ((chk->send_size + overhead) > nxtsz) {
|
2006-11-03 15:23:16 +00:00
|
|
|
chk->flags |= CHUNK_FLAGS_FRAGMENT_OK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
TAILQ_FOREACH(chk, &stcb->asoc.sent_queue, sctp_next) {
|
2009-09-16 14:23:31 +00:00
|
|
|
if ((chk->send_size + overhead) > nxtsz) {
|
2006-11-03 15:23:16 +00:00
|
|
|
/*
|
|
|
|
* For this guy we also mark for immediate resend
|
|
|
|
* since we sent to big of chunk
|
|
|
|
*/
|
|
|
|
chk->flags |= CHUNK_FLAGS_FRAGMENT_OK;
|
2009-04-04 11:43:32 +00:00
|
|
|
if (chk->sent < SCTP_DATAGRAM_RESEND) {
|
|
|
|
sctp_flight_size_decrease(chk);
|
|
|
|
sctp_total_flight_decrease(stcb, chk);
|
2015-03-23 23:34:21 +00:00
|
|
|
chk->sent = SCTP_DATAGRAM_RESEND;
|
2006-11-03 15:23:16 +00:00
|
|
|
sctp_ucount_incr(stcb->asoc.sent_queue_retran_cnt);
|
2015-03-23 23:34:21 +00:00
|
|
|
chk->rec.data.doing_fast_retransmit = 0;
|
|
|
|
if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_FLIGHT_LOGGING_ENABLE) {
|
|
|
|
sctp_misc_ints(SCTP_FLIGHT_LOG_DOWN_PMTU,
|
|
|
|
chk->whoTo->flight_size,
|
|
|
|
chk->book_size,
|
2018-07-19 20:11:14 +00:00
|
|
|
(uint32_t)(uintptr_t)chk->whoTo,
|
2016-12-07 19:30:59 +00:00
|
|
|
chk->rec.data.tsn);
|
2015-03-23 23:34:21 +00:00
|
|
|
}
|
|
|
|
/* Clear any time so NO RTT is being done */
|
2019-12-01 17:35:36 +00:00
|
|
|
if (chk->do_rtt == 1) {
|
|
|
|
chk->do_rtt = 0;
|
|
|
|
chk->whoTo->rto_needed = 1;
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-04-30 11:18:16 +00:00
|
|
|
#ifdef INET
|
2016-04-16 21:34:49 +00:00
|
|
|
void
|
2006-11-03 15:23:16 +00:00
|
|
|
sctp_notify(struct sctp_inpcb *inp,
|
|
|
|
struct sctp_tcb *stcb,
|
2016-04-12 21:40:54 +00:00
|
|
|
struct sctp_nets *net,
|
|
|
|
uint8_t icmp_type,
|
|
|
|
uint8_t icmp_code,
|
|
|
|
uint16_t ip_len,
|
2017-04-26 19:26:40 +00:00
|
|
|
uint32_t next_mtu)
|
2006-11-03 15:23:16 +00:00
|
|
|
{
|
2016-04-12 21:40:54 +00:00
|
|
|
int timer_stopped;
|
2007-09-08 17:48:46 +00:00
|
|
|
|
2016-04-12 21:40:54 +00:00
|
|
|
if (icmp_type != ICMP_UNREACH) {
|
2007-09-08 17:48:46 +00:00
|
|
|
/* We only care about unreachable */
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
return;
|
|
|
|
}
|
2016-04-12 21:40:54 +00:00
|
|
|
if ((icmp_code == ICMP_UNREACH_NET) ||
|
|
|
|
(icmp_code == ICMP_UNREACH_HOST) ||
|
|
|
|
(icmp_code == ICMP_UNREACH_NET_UNKNOWN) ||
|
|
|
|
(icmp_code == ICMP_UNREACH_HOST_UNKNOWN) ||
|
|
|
|
(icmp_code == ICMP_UNREACH_ISOLATED) ||
|
|
|
|
(icmp_code == ICMP_UNREACH_NET_PROHIB) ||
|
|
|
|
(icmp_code == ICMP_UNREACH_HOST_PROHIB) ||
|
|
|
|
(icmp_code == ICMP_UNREACH_FILTER_PROHIB)) {
|
2016-04-16 21:34:49 +00:00
|
|
|
/* Mark the net unreachable. */
|
2007-09-08 17:48:46 +00:00
|
|
|
if (net->dest_state & SCTP_ADDR_REACHABLE) {
|
2016-04-12 21:40:54 +00:00
|
|
|
/* OK, that destination is NOT reachable. */
|
2007-09-08 17:48:46 +00:00
|
|
|
net->dest_state &= ~SCTP_ADDR_REACHABLE;
|
2011-08-03 20:21:00 +00:00
|
|
|
net->dest_state &= ~SCTP_ADDR_PF;
|
2007-09-08 17:48:46 +00:00
|
|
|
sctp_ulp_notify(SCTP_NOTIFY_INTERFACE_DOWN,
|
2012-05-13 17:36:04 +00:00
|
|
|
stcb, 0,
|
2007-09-08 17:48:46 +00:00
|
|
|
(void *)net, SCTP_SO_NOT_LOCKED);
|
|
|
|
}
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
2016-04-12 21:40:54 +00:00
|
|
|
} else if ((icmp_code == ICMP_UNREACH_PROTOCOL) ||
|
|
|
|
(icmp_code == ICMP_UNREACH_PORT)) {
|
2016-04-16 21:34:49 +00:00
|
|
|
/* Treat it like an ABORT. */
|
2021-07-09 21:17:35 +00:00
|
|
|
sctp_abort_notification(stcb, true, false, 0, NULL, SCTP_SO_NOT_LOCKED);
|
2015-05-28 16:00:23 +00:00
|
|
|
(void)sctp_free_assoc(inp, stcb, SCTP_NORMAL_PROC,
|
|
|
|
SCTP_FROM_SCTP_USRREQ + SCTP_LOC_2);
|
2007-09-08 17:48:46 +00:00
|
|
|
/* no need to unlock here, since the TCB is gone */
|
2016-04-12 21:40:54 +00:00
|
|
|
} else if (icmp_code == ICMP_UNREACH_NEEDFRAG) {
|
2018-04-08 12:08:20 +00:00
|
|
|
if (net->dest_state & SCTP_ADDR_NO_PMTUD) {
|
2017-11-03 20:46:12 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
return;
|
|
|
|
}
|
2016-04-12 21:40:54 +00:00
|
|
|
/* Find the next (smaller) MTU */
|
|
|
|
if (next_mtu == 0) {
|
|
|
|
/*
|
|
|
|
* Old type router that does not tell us what the
|
|
|
|
* next MTU is. Rats we will have to guess (in a
|
|
|
|
* educated fashion of course).
|
|
|
|
*/
|
|
|
|
next_mtu = sctp_get_prev_mtu(ip_len);
|
|
|
|
}
|
|
|
|
/* Stop the PMTU timer. */
|
|
|
|
if (SCTP_OS_TIMER_PENDING(&net->pmtu_timer.timer)) {
|
|
|
|
timer_stopped = 1;
|
|
|
|
sctp_timer_stop(SCTP_TIMER_TYPE_PATHMTURAISE, inp, stcb, net,
|
|
|
|
SCTP_FROM_SCTP_USRREQ + SCTP_LOC_1);
|
|
|
|
} else {
|
|
|
|
timer_stopped = 0;
|
|
|
|
}
|
|
|
|
/* Update the path MTU. */
|
2017-04-26 20:21:05 +00:00
|
|
|
if (net->port) {
|
|
|
|
next_mtu -= sizeof(struct udphdr);
|
|
|
|
}
|
2016-04-12 21:40:54 +00:00
|
|
|
if (net->mtu > next_mtu) {
|
|
|
|
net->mtu = next_mtu;
|
2017-04-29 19:20:50 +00:00
|
|
|
if (net->port) {
|
|
|
|
sctp_hc_set_mtu(&net->ro._l_addr, inp->fibnum, next_mtu + sizeof(struct udphdr));
|
|
|
|
} else {
|
|
|
|
sctp_hc_set_mtu(&net->ro._l_addr, inp->fibnum, next_mtu);
|
|
|
|
}
|
2016-04-12 21:40:54 +00:00
|
|
|
}
|
|
|
|
/* Update the association MTU */
|
|
|
|
if (stcb->asoc.smallest_mtu > next_mtu) {
|
|
|
|
sctp_pathmtu_adjustment(stcb, next_mtu);
|
|
|
|
}
|
|
|
|
/* Finally, start the PMTU timer if it was running before. */
|
|
|
|
if (timer_stopped) {
|
|
|
|
sctp_timer_start(SCTP_TIMER_TYPE_PATHMTURAISE, inp, stcb, net);
|
|
|
|
}
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
2006-11-03 15:23:16 +00:00
|
|
|
} else {
|
2007-09-08 17:48:46 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2016-04-12 11:48:54 +00:00
|
|
|
sctp_ctlinput(int cmd, struct sockaddr *sa, void *vip)
|
2006-11-03 15:23:16 +00:00
|
|
|
{
|
2016-04-18 20:16:41 +00:00
|
|
|
struct ip *outer_ip;
|
|
|
|
struct ip *inner_ip;
|
2006-11-03 15:23:16 +00:00
|
|
|
struct sctphdr *sh;
|
2016-04-14 19:59:21 +00:00
|
|
|
struct icmp *icmp;
|
|
|
|
struct sctp_inpcb *inp;
|
|
|
|
struct sctp_tcb *stcb;
|
|
|
|
struct sctp_nets *net;
|
|
|
|
struct sctp_init_chunk *ch;
|
2016-04-16 21:34:49 +00:00
|
|
|
struct sockaddr_in src, dst;
|
2006-11-03 15:23:16 +00:00
|
|
|
|
|
|
|
if (sa->sa_family != AF_INET ||
|
|
|
|
((struct sockaddr_in *)sa)->sin_addr.s_addr == INADDR_ANY) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (PRC_IS_REDIRECT(cmd)) {
|
2016-04-14 19:59:21 +00:00
|
|
|
vip = NULL;
|
2006-11-03 15:23:16 +00:00
|
|
|
} else if ((unsigned)cmd >= PRC_NCMDS || inetctlerrmap[cmd] == 0) {
|
|
|
|
return;
|
|
|
|
}
|
2016-04-14 19:59:21 +00:00
|
|
|
if (vip != NULL) {
|
|
|
|
inner_ip = (struct ip *)vip;
|
|
|
|
icmp = (struct icmp *)((caddr_t)inner_ip -
|
|
|
|
(sizeof(struct icmp) - sizeof(struct ip)));
|
|
|
|
outer_ip = (struct ip *)((caddr_t)icmp - sizeof(struct ip));
|
|
|
|
sh = (struct sctphdr *)((caddr_t)inner_ip + (inner_ip->ip_hl << 2));
|
2016-04-16 21:34:49 +00:00
|
|
|
memset(&src, 0, sizeof(struct sockaddr_in));
|
|
|
|
src.sin_family = AF_INET;
|
|
|
|
src.sin_len = sizeof(struct sockaddr_in);
|
|
|
|
src.sin_port = sh->src_port;
|
|
|
|
src.sin_addr = inner_ip->ip_src;
|
|
|
|
memset(&dst, 0, sizeof(struct sockaddr_in));
|
|
|
|
dst.sin_family = AF_INET;
|
|
|
|
dst.sin_len = sizeof(struct sockaddr_in);
|
|
|
|
dst.sin_port = sh->dest_port;
|
|
|
|
dst.sin_addr = inner_ip->ip_dst;
|
2006-11-03 15:23:16 +00:00
|
|
|
/*
|
2016-04-16 21:34:49 +00:00
|
|
|
* 'dst' holds the dest of the packet that failed to be
|
|
|
|
* sent. 'src' holds our local endpoint address. Thus we
|
|
|
|
* reverse the dst and the src in the lookup.
|
2006-11-03 15:23:16 +00:00
|
|
|
*/
|
2016-04-14 19:59:21 +00:00
|
|
|
inp = NULL;
|
|
|
|
net = NULL;
|
2016-04-16 21:34:49 +00:00
|
|
|
stcb = sctp_findassociation_addr_sa((struct sockaddr *)&dst,
|
|
|
|
(struct sockaddr *)&src,
|
2016-04-14 19:59:21 +00:00
|
|
|
&inp, &net, 1,
|
|
|
|
SCTP_DEFAULT_VRFID);
|
2016-04-12 11:48:54 +00:00
|
|
|
if ((stcb != NULL) &&
|
2016-04-12 21:40:54 +00:00
|
|
|
(net != NULL) &&
|
2016-06-23 09:13:15 +00:00
|
|
|
(inp != NULL)) {
|
2016-04-12 11:48:54 +00:00
|
|
|
/* Check the verification tag */
|
|
|
|
if (ntohl(sh->v_tag) != 0) {
|
|
|
|
/*
|
|
|
|
* This must be the verification tag used
|
|
|
|
* for sending out packets. We don't
|
|
|
|
* consider packets reflecting the
|
|
|
|
* verification tag.
|
|
|
|
*/
|
2016-04-12 21:40:54 +00:00
|
|
|
if (ntohl(sh->v_tag) != stcb->asoc.peer_vtag) {
|
2016-04-12 11:48:54 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
} else {
|
2016-04-14 19:59:21 +00:00
|
|
|
if (ntohs(outer_ip->ip_len) >=
|
|
|
|
sizeof(struct ip) +
|
|
|
|
8 + (inner_ip->ip_hl << 2) + 20) {
|
|
|
|
/*
|
|
|
|
* In this case we can check if we
|
|
|
|
* got an INIT chunk and if the
|
|
|
|
* initiate tag matches.
|
|
|
|
*/
|
|
|
|
ch = (struct sctp_init_chunk *)(sh + 1);
|
|
|
|
if ((ch->ch.chunk_type != SCTP_INITIATION) ||
|
|
|
|
(ntohl(ch->init.initiate_tag) != stcb->asoc.my_vtag)) {
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
return;
|
|
|
|
}
|
2016-04-12 11:48:54 +00:00
|
|
|
}
|
2016-04-12 21:40:54 +00:00
|
|
|
sctp_notify(inp, stcb, net,
|
2016-04-14 19:59:21 +00:00
|
|
|
icmp->icmp_type,
|
|
|
|
icmp->icmp_code,
|
|
|
|
ntohs(inner_ip->ip_len),
|
2018-07-19 20:11:14 +00:00
|
|
|
(uint32_t)ntohs(icmp->icmp_nextmtu));
|
2006-11-03 15:23:16 +00:00
|
|
|
} else {
|
|
|
|
if ((stcb == NULL) && (inp != NULL)) {
|
|
|
|
/* reduce ref-count */
|
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
SCTP_INP_DECR_REF(inp);
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
|
|
|
}
|
2010-06-11 03:54:00 +00:00
|
|
|
if (stcb) {
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
2011-04-30 11:18:16 +00:00
|
|
|
#endif
|
|
|
|
|
2006-11-03 15:23:16 +00:00
|
|
|
static int
|
|
|
|
sctp_getcred(SYSCTL_HANDLER_ARGS)
|
|
|
|
{
|
2006-11-08 00:21:13 +00:00
|
|
|
struct xucred xuc;
|
2006-11-03 15:23:16 +00:00
|
|
|
struct sockaddr_in addrs[2];
|
|
|
|
struct sctp_inpcb *inp;
|
|
|
|
struct sctp_nets *net;
|
|
|
|
struct sctp_tcb *stcb;
|
2006-11-08 00:21:13 +00:00
|
|
|
int error;
|
2007-03-15 11:27:14 +00:00
|
|
|
uint32_t vrf_id;
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2007-04-03 11:15:32 +00:00
|
|
|
/* FIX, for non-bsd is this right? */
|
2007-03-15 11:27:14 +00:00
|
|
|
vrf_id = SCTP_DEFAULT_VRFID;
|
2007-04-03 11:15:32 +00:00
|
|
|
|
2007-06-12 00:12:01 +00:00
|
|
|
error = priv_check(req->td, PRIV_NETINET_GETCRED);
|
|
|
|
|
2006-11-03 15:23:16 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
2006-11-06 14:54:06 +00:00
|
|
|
|
2006-11-03 15:23:16 +00:00
|
|
|
error = SYSCTL_IN(req, addrs, sizeof(addrs));
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
|
2012-06-28 16:01:08 +00:00
|
|
|
stcb = sctp_findassociation_addr_sa(sintosa(&addrs[1]),
|
|
|
|
sintosa(&addrs[0]),
|
2007-03-15 11:27:14 +00:00
|
|
|
&inp, &net, 1, vrf_id);
|
2006-11-03 15:23:16 +00:00
|
|
|
if (stcb == NULL || inp == NULL || inp->sctp_socket == NULL) {
|
|
|
|
if ((inp != NULL) && (stcb == NULL)) {
|
|
|
|
/* reduce ref-count */
|
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
SCTP_INP_DECR_REF(inp);
|
2006-11-08 00:21:13 +00:00
|
|
|
goto cred_can_cont;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2018-07-19 20:16:33 +00:00
|
|
|
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOENT);
|
2006-11-03 15:23:16 +00:00
|
|
|
error = ENOENT;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
2006-11-08 00:21:13 +00:00
|
|
|
/*
|
|
|
|
* We use the write lock here, only since in the error leg we need
|
|
|
|
* it. If we used RLOCK, then we would have to
|
|
|
|
* wlock/decr/unlock/rlock. Which in theory could create a hole.
|
|
|
|
* Better to use higher wlock.
|
|
|
|
*/
|
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
cred_can_cont:
|
|
|
|
error = cr_canseesocket(req->td->td_ucred, inp->sctp_socket);
|
|
|
|
if (error) {
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
cru2x(inp->sctp_socket->so_cred, &xuc);
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
|
|
|
error = SYSCTL_OUT(req, &xuc, sizeof(struct xucred));
|
2006-11-03 15:23:16 +00:00
|
|
|
out:
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2020-02-24 10:47:18 +00:00
|
|
|
SYSCTL_PROC(_net_inet_sctp, OID_AUTO, getcred,
|
|
|
|
CTLTYPE_OPAQUE | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
|
|
|
|
0, 0, sctp_getcred, "S,ucred",
|
|
|
|
"Get the ucred of a SCTP connection");
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2011-04-30 11:18:16 +00:00
|
|
|
#ifdef INET
|
2006-11-03 15:23:16 +00:00
|
|
|
static void
|
|
|
|
sctp_abort(struct socket *so)
|
|
|
|
{
|
2020-02-18 21:25:17 +00:00
|
|
|
struct epoch_tracker et;
|
2006-11-03 15:23:16 +00:00
|
|
|
struct sctp_inpcb *inp;
|
|
|
|
|
|
|
|
inp = (struct sctp_inpcb *)so->so_pcb;
|
2012-03-15 14:22:05 +00:00
|
|
|
if (inp == NULL) {
|
2006-11-03 15:23:16 +00:00
|
|
|
return;
|
2007-08-24 00:53:53 +00:00
|
|
|
}
|
2018-07-19 20:16:33 +00:00
|
|
|
|
sctp: Fix races around sctp_inpcb_free()
sctp_close() and sctp_abort() disassociate the PCB from its socket.
As a part of this, they attempt to free the PCB, which may end up
lingering. Fix some bugs in this area:
- For some reason, sctp_close() and sctp_abort() set
SCTP_PCB_FLAGS_SOCKET_GONE using an atomic compare-and-set without the
PCB lock held. This is racy since sctp_flags is normally updated
without atomics, using the PCB lock to synchronize. So, the update
can be lost, which can cause all sort of races with other SCTP
components which look for the _GONE flag. Fix the problem simply by
acquiring the PCB lock in order to set the flag. Note that we have to
drop and re-acquire the lock again in sctp_inpcb_free(), but I don't
see a good way around that for now. If it's a real problem, the _GONE
flag could be split out of sctp_flags and into a dedicated sctp_inpcb
field.
- In sctp_inpcb_free(), load sctp_socket after acquiring the PCB lock,
to avoid possible races with parallel sctp_inpcb_free() calls.
- Add an assertion sctp_inpcb_free() to verify that _ALLGONE is not set.
Reviewed by: tuexen
MFC after: 1 week
Sponsored by: The FreeBSD Foundation
Differential Revision: https://reviews.freebsd.org/D31811
2021-09-07 13:44:12 +00:00
|
|
|
SCTP_INP_WLOCK(inp);
|
2020-02-18 21:25:17 +00:00
|
|
|
NET_EPOCH_ENTER(et);
|
2006-11-03 15:23:16 +00:00
|
|
|
#ifdef SCTP_LOG_CLOSING
|
|
|
|
sctp_log_closing(inp, NULL, 17);
|
|
|
|
#endif
|
sctp: Fix races around sctp_inpcb_free()
sctp_close() and sctp_abort() disassociate the PCB from its socket.
As a part of this, they attempt to free the PCB, which may end up
lingering. Fix some bugs in this area:
- For some reason, sctp_close() and sctp_abort() set
SCTP_PCB_FLAGS_SOCKET_GONE using an atomic compare-and-set without the
PCB lock held. This is racy since sctp_flags is normally updated
without atomics, using the PCB lock to synchronize. So, the update
can be lost, which can cause all sort of races with other SCTP
components which look for the _GONE flag. Fix the problem simply by
acquiring the PCB lock in order to set the flag. Note that we have to
drop and re-acquire the lock again in sctp_inpcb_free(), but I don't
see a good way around that for now. If it's a real problem, the _GONE
flag could be split out of sctp_flags and into a dedicated sctp_inpcb
field.
- In sctp_inpcb_free(), load sctp_socket after acquiring the PCB lock,
to avoid possible races with parallel sctp_inpcb_free() calls.
- Add an assertion sctp_inpcb_free() to verify that _ALLGONE is not set.
Reviewed by: tuexen
MFC after: 1 week
Sponsored by: The FreeBSD Foundation
Differential Revision: https://reviews.freebsd.org/D31811
2021-09-07 13:44:12 +00:00
|
|
|
if (((inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) == 0)) {
|
|
|
|
inp->sctp_flags |= SCTP_PCB_FLAGS_SOCKET_GONE | SCTP_PCB_FLAGS_CLOSE_IP;
|
2006-11-03 15:23:16 +00:00
|
|
|
#ifdef SCTP_LOG_CLOSING
|
|
|
|
sctp_log_closing(inp, NULL, 16);
|
|
|
|
#endif
|
sctp: Fix races around sctp_inpcb_free()
sctp_close() and sctp_abort() disassociate the PCB from its socket.
As a part of this, they attempt to free the PCB, which may end up
lingering. Fix some bugs in this area:
- For some reason, sctp_close() and sctp_abort() set
SCTP_PCB_FLAGS_SOCKET_GONE using an atomic compare-and-set without the
PCB lock held. This is racy since sctp_flags is normally updated
without atomics, using the PCB lock to synchronize. So, the update
can be lost, which can cause all sort of races with other SCTP
components which look for the _GONE flag. Fix the problem simply by
acquiring the PCB lock in order to set the flag. Note that we have to
drop and re-acquire the lock again in sctp_inpcb_free(), but I don't
see a good way around that for now. If it's a real problem, the _GONE
flag could be split out of sctp_flags and into a dedicated sctp_inpcb
field.
- In sctp_inpcb_free(), load sctp_socket after acquiring the PCB lock,
to avoid possible races with parallel sctp_inpcb_free() calls.
- Add an assertion sctp_inpcb_free() to verify that _ALLGONE is not set.
Reviewed by: tuexen
MFC after: 1 week
Sponsored by: The FreeBSD Foundation
Differential Revision: https://reviews.freebsd.org/D31811
2021-09-07 13:44:12 +00:00
|
|
|
SCTP_INP_WUNLOCK(inp);
|
2007-05-08 15:53:03 +00:00
|
|
|
sctp_inpcb_free(inp, SCTP_FREE_SHOULD_USE_ABORT,
|
|
|
|
SCTP_CALLED_AFTER_CMPSET_OFCLOSE);
|
2006-11-03 15:23:16 +00:00
|
|
|
SOCK_LOCK(so);
|
2007-03-19 06:53:02 +00:00
|
|
|
SCTP_SB_CLEAR(so->so_snd);
|
2006-11-03 15:23:16 +00:00
|
|
|
/*
|
|
|
|
* same for the rcv ones, they are only here for the
|
|
|
|
* accounting/select.
|
|
|
|
*/
|
2007-03-19 06:53:02 +00:00
|
|
|
SCTP_SB_CLEAR(so->so_rcv);
|
|
|
|
|
|
|
|
/* Now null out the reference, we are completely detached. */
|
2006-11-03 15:23:16 +00:00
|
|
|
so->so_pcb = NULL;
|
|
|
|
SOCK_UNLOCK(so);
|
|
|
|
} else {
|
sctp: Fix races around sctp_inpcb_free()
sctp_close() and sctp_abort() disassociate the PCB from its socket.
As a part of this, they attempt to free the PCB, which may end up
lingering. Fix some bugs in this area:
- For some reason, sctp_close() and sctp_abort() set
SCTP_PCB_FLAGS_SOCKET_GONE using an atomic compare-and-set without the
PCB lock held. This is racy since sctp_flags is normally updated
without atomics, using the PCB lock to synchronize. So, the update
can be lost, which can cause all sort of races with other SCTP
components which look for the _GONE flag. Fix the problem simply by
acquiring the PCB lock in order to set the flag. Note that we have to
drop and re-acquire the lock again in sctp_inpcb_free(), but I don't
see a good way around that for now. If it's a real problem, the _GONE
flag could be split out of sctp_flags and into a dedicated sctp_inpcb
field.
- In sctp_inpcb_free(), load sctp_socket after acquiring the PCB lock,
to avoid possible races with parallel sctp_inpcb_free() calls.
- Add an assertion sctp_inpcb_free() to verify that _ALLGONE is not set.
Reviewed by: tuexen
MFC after: 1 week
Sponsored by: The FreeBSD Foundation
Differential Revision: https://reviews.freebsd.org/D31811
2021-09-07 13:44:12 +00:00
|
|
|
SCTP_INP_WUNLOCK(inp);
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2020-02-18 21:25:17 +00:00
|
|
|
NET_EPOCH_EXIT(et);
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2011-12-17 19:21:40 +00:00
|
|
|
sctp_attach(struct socket *so, int proto SCTP_UNUSED, struct thread *p SCTP_UNUSED)
|
2006-11-03 15:23:16 +00:00
|
|
|
{
|
|
|
|
struct sctp_inpcb *inp;
|
|
|
|
struct inpcb *ip_inp;
|
2007-01-18 09:58:43 +00:00
|
|
|
int error;
|
2007-06-02 11:05:08 +00:00
|
|
|
uint32_t vrf_id = SCTP_DEFAULT_VRFID;
|
2008-12-06 13:19:54 +00:00
|
|
|
|
2006-11-03 15:23:16 +00:00
|
|
|
inp = (struct sctp_inpcb *)so->so_pcb;
|
2016-04-15 15:46:41 +00:00
|
|
|
if (inp != NULL) {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2011-12-27 10:16:24 +00:00
|
|
|
return (EINVAL);
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2008-10-18 15:56:12 +00:00
|
|
|
if (so->so_snd.sb_hiwat == 0 || so->so_rcv.sb_hiwat == 0) {
|
|
|
|
error = SCTP_SORESERVE(so, SCTP_BASE_SYSCTL(sctp_sendspace), SCTP_BASE_SYSCTL(sctp_recvspace));
|
|
|
|
if (error) {
|
2011-12-27 10:16:24 +00:00
|
|
|
return (error);
|
2008-10-18 15:56:12 +00:00
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2007-06-02 11:05:08 +00:00
|
|
|
error = sctp_inpcb_alloc(so, vrf_id);
|
2006-11-03 15:23:16 +00:00
|
|
|
if (error) {
|
2011-12-27 10:16:24 +00:00
|
|
|
return (error);
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
inp = (struct sctp_inpcb *)so->so_pcb;
|
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
inp->sctp_flags &= ~SCTP_PCB_FLAGS_BOUND_V6; /* I'm not v6! */
|
|
|
|
ip_inp = &inp->ip_inp.inp;
|
|
|
|
ip_inp->inp_vflag |= INP_IPV4;
|
2009-09-17 15:11:12 +00:00
|
|
|
ip_inp->inp_ip_ttl = MODULE_GLOBAL(ip_defttl);
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_INP_WUNLOCK(inp);
|
2011-12-27 10:16:24 +00:00
|
|
|
return (0);
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
sctp_bind(struct socket *so, struct sockaddr *addr, struct thread *p)
|
|
|
|
{
|
2012-12-27 08:10:58 +00:00
|
|
|
struct sctp_inpcb *inp;
|
2006-11-03 15:23:16 +00:00
|
|
|
|
|
|
|
inp = (struct sctp_inpcb *)so->so_pcb;
|
2012-03-15 14:22:05 +00:00
|
|
|
if (inp == NULL) {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2011-12-27 10:16:24 +00:00
|
|
|
return (EINVAL);
|
2007-08-24 00:53:53 +00:00
|
|
|
}
|
2012-12-27 08:10:58 +00:00
|
|
|
if (addr != NULL) {
|
|
|
|
if ((addr->sa_family != AF_INET) ||
|
|
|
|
(addr->sa_len != sizeof(struct sockaddr_in))) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
return (EINVAL);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return (sctp_inpcb_bind(so, addr, NULL, p));
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
|
2011-04-30 11:18:16 +00:00
|
|
|
#endif
|
2007-08-27 05:19:48 +00:00
|
|
|
void
|
2006-11-03 15:23:16 +00:00
|
|
|
sctp_close(struct socket *so)
|
|
|
|
{
|
2020-02-18 21:25:17 +00:00
|
|
|
struct epoch_tracker et;
|
2006-11-03 15:23:16 +00:00
|
|
|
struct sctp_inpcb *inp;
|
|
|
|
|
|
|
|
inp = (struct sctp_inpcb *)so->so_pcb;
|
2012-03-15 14:22:05 +00:00
|
|
|
if (inp == NULL)
|
2006-11-03 15:23:16 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Inform all the lower layer assoc that we are done.
|
|
|
|
*/
|
sctp: Fix races around sctp_inpcb_free()
sctp_close() and sctp_abort() disassociate the PCB from its socket.
As a part of this, they attempt to free the PCB, which may end up
lingering. Fix some bugs in this area:
- For some reason, sctp_close() and sctp_abort() set
SCTP_PCB_FLAGS_SOCKET_GONE using an atomic compare-and-set without the
PCB lock held. This is racy since sctp_flags is normally updated
without atomics, using the PCB lock to synchronize. So, the update
can be lost, which can cause all sort of races with other SCTP
components which look for the _GONE flag. Fix the problem simply by
acquiring the PCB lock in order to set the flag. Note that we have to
drop and re-acquire the lock again in sctp_inpcb_free(), but I don't
see a good way around that for now. If it's a real problem, the _GONE
flag could be split out of sctp_flags and into a dedicated sctp_inpcb
field.
- In sctp_inpcb_free(), load sctp_socket after acquiring the PCB lock,
to avoid possible races with parallel sctp_inpcb_free() calls.
- Add an assertion sctp_inpcb_free() to verify that _ALLGONE is not set.
Reviewed by: tuexen
MFC after: 1 week
Sponsored by: The FreeBSD Foundation
Differential Revision: https://reviews.freebsd.org/D31811
2021-09-07 13:44:12 +00:00
|
|
|
SCTP_INP_WLOCK(inp);
|
2020-02-18 21:25:17 +00:00
|
|
|
NET_EPOCH_ENTER(et);
|
2006-11-03 15:23:16 +00:00
|
|
|
#ifdef SCTP_LOG_CLOSING
|
|
|
|
sctp_log_closing(inp, NULL, 17);
|
|
|
|
#endif
|
sctp: Fix races around sctp_inpcb_free()
sctp_close() and sctp_abort() disassociate the PCB from its socket.
As a part of this, they attempt to free the PCB, which may end up
lingering. Fix some bugs in this area:
- For some reason, sctp_close() and sctp_abort() set
SCTP_PCB_FLAGS_SOCKET_GONE using an atomic compare-and-set without the
PCB lock held. This is racy since sctp_flags is normally updated
without atomics, using the PCB lock to synchronize. So, the update
can be lost, which can cause all sort of races with other SCTP
components which look for the _GONE flag. Fix the problem simply by
acquiring the PCB lock in order to set the flag. Note that we have to
drop and re-acquire the lock again in sctp_inpcb_free(), but I don't
see a good way around that for now. If it's a real problem, the _GONE
flag could be split out of sctp_flags and into a dedicated sctp_inpcb
field.
- In sctp_inpcb_free(), load sctp_socket after acquiring the PCB lock,
to avoid possible races with parallel sctp_inpcb_free() calls.
- Add an assertion sctp_inpcb_free() to verify that _ALLGONE is not set.
Reviewed by: tuexen
MFC after: 1 week
Sponsored by: The FreeBSD Foundation
Differential Revision: https://reviews.freebsd.org/D31811
2021-09-07 13:44:12 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) == 0) {
|
|
|
|
inp->sctp_flags |= SCTP_PCB_FLAGS_SOCKET_GONE | SCTP_PCB_FLAGS_CLOSE_IP;
|
2006-11-03 15:23:16 +00:00
|
|
|
if (((so->so_options & SO_LINGER) && (so->so_linger == 0)) ||
|
2014-12-02 20:29:29 +00:00
|
|
|
(so->so_rcv.sb_cc > 0)) {
|
2006-11-03 15:23:16 +00:00
|
|
|
#ifdef SCTP_LOG_CLOSING
|
|
|
|
sctp_log_closing(inp, NULL, 13);
|
|
|
|
#endif
|
sctp: Fix races around sctp_inpcb_free()
sctp_close() and sctp_abort() disassociate the PCB from its socket.
As a part of this, they attempt to free the PCB, which may end up
lingering. Fix some bugs in this area:
- For some reason, sctp_close() and sctp_abort() set
SCTP_PCB_FLAGS_SOCKET_GONE using an atomic compare-and-set without the
PCB lock held. This is racy since sctp_flags is normally updated
without atomics, using the PCB lock to synchronize. So, the update
can be lost, which can cause all sort of races with other SCTP
components which look for the _GONE flag. Fix the problem simply by
acquiring the PCB lock in order to set the flag. Note that we have to
drop and re-acquire the lock again in sctp_inpcb_free(), but I don't
see a good way around that for now. If it's a real problem, the _GONE
flag could be split out of sctp_flags and into a dedicated sctp_inpcb
field.
- In sctp_inpcb_free(), load sctp_socket after acquiring the PCB lock,
to avoid possible races with parallel sctp_inpcb_free() calls.
- Add an assertion sctp_inpcb_free() to verify that _ALLGONE is not set.
Reviewed by: tuexen
MFC after: 1 week
Sponsored by: The FreeBSD Foundation
Differential Revision: https://reviews.freebsd.org/D31811
2021-09-07 13:44:12 +00:00
|
|
|
SCTP_INP_WUNLOCK(inp);
|
2007-05-08 15:53:03 +00:00
|
|
|
sctp_inpcb_free(inp, SCTP_FREE_SHOULD_USE_ABORT,
|
|
|
|
SCTP_CALLED_AFTER_CMPSET_OFCLOSE);
|
2006-11-03 15:23:16 +00:00
|
|
|
} else {
|
|
|
|
#ifdef SCTP_LOG_CLOSING
|
|
|
|
sctp_log_closing(inp, NULL, 14);
|
|
|
|
#endif
|
sctp: Fix races around sctp_inpcb_free()
sctp_close() and sctp_abort() disassociate the PCB from its socket.
As a part of this, they attempt to free the PCB, which may end up
lingering. Fix some bugs in this area:
- For some reason, sctp_close() and sctp_abort() set
SCTP_PCB_FLAGS_SOCKET_GONE using an atomic compare-and-set without the
PCB lock held. This is racy since sctp_flags is normally updated
without atomics, using the PCB lock to synchronize. So, the update
can be lost, which can cause all sort of races with other SCTP
components which look for the _GONE flag. Fix the problem simply by
acquiring the PCB lock in order to set the flag. Note that we have to
drop and re-acquire the lock again in sctp_inpcb_free(), but I don't
see a good way around that for now. If it's a real problem, the _GONE
flag could be split out of sctp_flags and into a dedicated sctp_inpcb
field.
- In sctp_inpcb_free(), load sctp_socket after acquiring the PCB lock,
to avoid possible races with parallel sctp_inpcb_free() calls.
- Add an assertion sctp_inpcb_free() to verify that _ALLGONE is not set.
Reviewed by: tuexen
MFC after: 1 week
Sponsored by: The FreeBSD Foundation
Differential Revision: https://reviews.freebsd.org/D31811
2021-09-07 13:44:12 +00:00
|
|
|
SCTP_INP_WUNLOCK(inp);
|
2007-05-08 15:53:03 +00:00
|
|
|
sctp_inpcb_free(inp, SCTP_FREE_SHOULD_USE_GRACEFUL_CLOSE,
|
|
|
|
SCTP_CALLED_AFTER_CMPSET_OFCLOSE);
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
/*
|
|
|
|
* The socket is now detached, no matter what the state of
|
|
|
|
* the SCTP association.
|
|
|
|
*/
|
|
|
|
SOCK_LOCK(so);
|
2007-03-19 06:53:02 +00:00
|
|
|
SCTP_SB_CLEAR(so->so_snd);
|
2006-11-03 15:23:16 +00:00
|
|
|
/*
|
|
|
|
* same for the rcv ones, they are only here for the
|
|
|
|
* accounting/select.
|
|
|
|
*/
|
2007-03-19 06:53:02 +00:00
|
|
|
SCTP_SB_CLEAR(so->so_rcv);
|
|
|
|
|
|
|
|
/* Now null out the reference, we are completely detached. */
|
2006-11-03 15:23:16 +00:00
|
|
|
so->so_pcb = NULL;
|
|
|
|
SOCK_UNLOCK(so);
|
|
|
|
} else {
|
sctp: Fix races around sctp_inpcb_free()
sctp_close() and sctp_abort() disassociate the PCB from its socket.
As a part of this, they attempt to free the PCB, which may end up
lingering. Fix some bugs in this area:
- For some reason, sctp_close() and sctp_abort() set
SCTP_PCB_FLAGS_SOCKET_GONE using an atomic compare-and-set without the
PCB lock held. This is racy since sctp_flags is normally updated
without atomics, using the PCB lock to synchronize. So, the update
can be lost, which can cause all sort of races with other SCTP
components which look for the _GONE flag. Fix the problem simply by
acquiring the PCB lock in order to set the flag. Note that we have to
drop and re-acquire the lock again in sctp_inpcb_free(), but I don't
see a good way around that for now. If it's a real problem, the _GONE
flag could be split out of sctp_flags and into a dedicated sctp_inpcb
field.
- In sctp_inpcb_free(), load sctp_socket after acquiring the PCB lock,
to avoid possible races with parallel sctp_inpcb_free() calls.
- Add an assertion sctp_inpcb_free() to verify that _ALLGONE is not set.
Reviewed by: tuexen
MFC after: 1 week
Sponsored by: The FreeBSD Foundation
Differential Revision: https://reviews.freebsd.org/D31811
2021-09-07 13:44:12 +00:00
|
|
|
SCTP_INP_WUNLOCK(inp);
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2020-02-18 21:25:17 +00:00
|
|
|
NET_EPOCH_EXIT(et);
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
sctp_sendm(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr,
|
|
|
|
struct mbuf *control, struct thread *p);
|
|
|
|
|
|
|
|
int
|
|
|
|
sctp_sendm(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr,
|
|
|
|
struct mbuf *control, struct thread *p)
|
|
|
|
{
|
|
|
|
struct sctp_inpcb *inp;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
inp = (struct sctp_inpcb *)so->so_pcb;
|
2012-03-15 14:22:05 +00:00
|
|
|
if (inp == NULL) {
|
2006-11-03 15:23:16 +00:00
|
|
|
if (control) {
|
|
|
|
sctp_m_freem(control);
|
|
|
|
control = NULL;
|
|
|
|
}
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET_PKT(m, inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2006-11-03 15:23:16 +00:00
|
|
|
sctp_m_freem(m);
|
2011-12-27 10:16:24 +00:00
|
|
|
return (EINVAL);
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
/* Got to have an to address if we are NOT a connected socket */
|
|
|
|
if ((addr == NULL) &&
|
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) ||
|
2011-12-27 10:16:24 +00:00
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE))) {
|
2006-11-03 15:23:16 +00:00
|
|
|
goto connected_type;
|
2021-05-03 16:51:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
error = 0;
|
|
|
|
if (addr == NULL) {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET_PKT(m, inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EDESTADDRREQ);
|
2006-11-03 15:23:16 +00:00
|
|
|
error = EDESTADDRREQ;
|
2021-05-03 16:51:04 +00:00
|
|
|
} else if (addr->sa_family != AF_INET) {
|
|
|
|
SCTP_LTRACE_ERR_RET_PKT(m, inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EAFNOSUPPORT);
|
|
|
|
error = EAFNOSUPPORT;
|
|
|
|
} else if (addr->sa_len != sizeof(struct sockaddr_in)) {
|
|
|
|
SCTP_LTRACE_ERR_RET_PKT(m, inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2021-05-03 16:51:04 +00:00
|
|
|
if (error != 0) {
|
2006-11-03 15:23:16 +00:00
|
|
|
sctp_m_freem(m);
|
|
|
|
if (control) {
|
|
|
|
sctp_m_freem(control);
|
|
|
|
control = NULL;
|
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
return (error);
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
connected_type:
|
|
|
|
/* now what about control */
|
|
|
|
if (control) {
|
|
|
|
if (inp->control) {
|
|
|
|
sctp_m_freem(inp->control);
|
|
|
|
inp->control = NULL;
|
|
|
|
}
|
|
|
|
inp->control = control;
|
|
|
|
}
|
|
|
|
/* Place the data */
|
|
|
|
if (inp->pkt) {
|
2006-12-29 20:21:42 +00:00
|
|
|
SCTP_BUF_NEXT(inp->pkt_last) = m;
|
2006-11-03 15:23:16 +00:00
|
|
|
inp->pkt_last = m;
|
|
|
|
} else {
|
|
|
|
inp->pkt_last = inp->pkt = m;
|
|
|
|
}
|
|
|
|
if (
|
|
|
|
/* FreeBSD uses a flag passed */
|
|
|
|
((flags & PRUS_MORETOCOME) == 0)
|
|
|
|
) {
|
|
|
|
/*
|
|
|
|
* note with the current version this code will only be used
|
|
|
|
* by OpenBSD-- NetBSD, FreeBSD, and MacOS have methods for
|
|
|
|
* re-defining sosend to use the sctp_sosend. One can
|
|
|
|
* optionally switch back to this code (by changing back the
|
|
|
|
* definitions) but this is not advisable. This code is used
|
|
|
|
* by FreeBSD when sending a file with sendfile() though.
|
|
|
|
*/
|
2020-02-18 21:25:17 +00:00
|
|
|
struct epoch_tracker et;
|
2006-11-03 15:23:16 +00:00
|
|
|
int ret;
|
|
|
|
|
2020-02-18 21:25:17 +00:00
|
|
|
NET_EPOCH_ENTER(et);
|
2006-11-03 15:23:16 +00:00
|
|
|
ret = sctp_output(inp, inp->pkt, addr, inp->control, p, flags);
|
2020-02-18 21:25:17 +00:00
|
|
|
NET_EPOCH_EXIT(et);
|
2006-11-03 15:23:16 +00:00
|
|
|
inp->pkt = NULL;
|
|
|
|
inp->control = NULL;
|
|
|
|
return (ret);
|
|
|
|
} else {
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-08-27 05:19:48 +00:00
|
|
|
int
|
2006-11-03 15:23:16 +00:00
|
|
|
sctp_disconnect(struct socket *so)
|
|
|
|
{
|
|
|
|
struct sctp_inpcb *inp;
|
|
|
|
|
|
|
|
inp = (struct sctp_inpcb *)so->so_pcb;
|
|
|
|
if (inp == NULL) {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOTCONN);
|
2006-11-03 15:23:16 +00:00
|
|
|
return (ENOTCONN);
|
|
|
|
}
|
|
|
|
SCTP_INP_RLOCK(inp);
|
2007-08-06 15:46:46 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL)) {
|
2009-11-17 20:56:14 +00:00
|
|
|
if (LIST_EMPTY(&inp->sctp_asoc_list)) {
|
2006-11-03 15:23:16 +00:00
|
|
|
/* No connection */
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
return (0);
|
|
|
|
} else {
|
2020-02-18 21:25:17 +00:00
|
|
|
struct epoch_tracker et;
|
2006-11-03 15:23:16 +00:00
|
|
|
struct sctp_association *asoc;
|
|
|
|
struct sctp_tcb *stcb;
|
|
|
|
|
|
|
|
stcb = LIST_FIRST(&inp->sctp_asoc_list);
|
|
|
|
if (stcb == NULL) {
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2006-11-03 15:23:16 +00:00
|
|
|
return (EINVAL);
|
|
|
|
}
|
|
|
|
SCTP_TCB_LOCK(stcb);
|
|
|
|
asoc = &stcb->asoc;
|
|
|
|
if (stcb->asoc.state & SCTP_STATE_ABOUT_TO_BE_FREED) {
|
|
|
|
/* We are about to be freed, out of here */
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
return (0);
|
|
|
|
}
|
2020-02-18 21:25:17 +00:00
|
|
|
NET_EPOCH_ENTER(et);
|
2006-11-03 15:23:16 +00:00
|
|
|
if (((so->so_options & SO_LINGER) &&
|
|
|
|
(so->so_linger == 0)) ||
|
2014-12-02 20:29:29 +00:00
|
|
|
(so->so_rcv.sb_cc > 0)) {
|
2018-08-13 13:58:45 +00:00
|
|
|
if (SCTP_GET_STATE(stcb) != SCTP_STATE_COOKIE_WAIT) {
|
2006-11-03 15:23:16 +00:00
|
|
|
/* Left with Data unread */
|
2018-04-08 11:50:06 +00:00
|
|
|
struct mbuf *op_err;
|
|
|
|
|
|
|
|
op_err = sctp_generate_cause(SCTP_CAUSE_USER_INITIATED_ABT, "");
|
|
|
|
sctp_send_abort_tcb(stcb, op_err, SCTP_SO_LOCKED);
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_STAT_INCR_COUNTER32(sctps_aborted);
|
|
|
|
}
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
2018-08-13 13:58:45 +00:00
|
|
|
if ((SCTP_GET_STATE(stcb) == SCTP_STATE_OPEN) ||
|
|
|
|
(SCTP_GET_STATE(stcb) == SCTP_STATE_SHUTDOWN_RECEIVED)) {
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_STAT_DECR_GAUGE32(sctps_currestab);
|
|
|
|
}
|
2015-05-28 16:00:23 +00:00
|
|
|
(void)sctp_free_assoc(inp, stcb, SCTP_NORMAL_PROC,
|
|
|
|
SCTP_FROM_SCTP_USRREQ + SCTP_LOC_3);
|
2006-11-03 15:23:16 +00:00
|
|
|
/* No unlock tcb assoc is gone */
|
2020-02-18 21:25:17 +00:00
|
|
|
NET_EPOCH_EXIT(et);
|
2006-11-03 15:23:16 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
if (TAILQ_EMPTY(&asoc->send_queue) &&
|
|
|
|
TAILQ_EMPTY(&asoc->sent_queue) &&
|
|
|
|
(asoc->stream_queue_cnt == 0)) {
|
|
|
|
/* there is nothing queued to send, so done */
|
2016-08-06 12:33:15 +00:00
|
|
|
if ((*asoc->ss_functions.sctp_ss_is_user_msgs_incomplete) (stcb, asoc)) {
|
2006-11-03 15:23:16 +00:00
|
|
|
goto abort_anyway;
|
|
|
|
}
|
2018-08-13 13:58:45 +00:00
|
|
|
if ((SCTP_GET_STATE(stcb) != SCTP_STATE_SHUTDOWN_SENT) &&
|
|
|
|
(SCTP_GET_STATE(stcb) != SCTP_STATE_SHUTDOWN_ACK_SENT)) {
|
2006-11-03 15:23:16 +00:00
|
|
|
/* only send SHUTDOWN 1st time thru */
|
2011-08-03 20:21:00 +00:00
|
|
|
struct sctp_nets *netp;
|
|
|
|
|
2018-08-13 13:58:45 +00:00
|
|
|
if ((SCTP_GET_STATE(stcb) == SCTP_STATE_OPEN) ||
|
|
|
|
(SCTP_GET_STATE(stcb) == SCTP_STATE_SHUTDOWN_RECEIVED)) {
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_STAT_DECR_GAUGE32(sctps_currestab);
|
|
|
|
}
|
2018-08-13 13:58:45 +00:00
|
|
|
SCTP_SET_STATE(stcb, SCTP_STATE_SHUTDOWN_SENT);
|
2013-02-09 08:27:08 +00:00
|
|
|
sctp_stop_timers_for_shutdown(stcb);
|
|
|
|
if (stcb->asoc.alternate) {
|
|
|
|
netp = stcb->asoc.alternate;
|
|
|
|
} else {
|
|
|
|
netp = stcb->asoc.primary_destination;
|
|
|
|
}
|
|
|
|
sctp_send_shutdown(stcb, netp);
|
2006-11-03 15:23:16 +00:00
|
|
|
sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWN,
|
2011-08-03 20:21:00 +00:00
|
|
|
stcb->sctp_ep, stcb, netp);
|
2006-11-03 15:23:16 +00:00
|
|
|
sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWNGUARD,
|
2020-03-19 21:01:16 +00:00
|
|
|
stcb->sctp_ep, stcb, NULL);
|
2013-02-09 08:27:08 +00:00
|
|
|
sctp_chunk_output(stcb->sctp_ep, stcb, SCTP_OUTPUT_FROM_T3, SCTP_SO_LOCKED);
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* we still got (or just got) data to send,
|
|
|
|
* so set SHUTDOWN_PENDING
|
|
|
|
*/
|
|
|
|
/*
|
|
|
|
* XXX sockets draft says that SCTP_EOF
|
|
|
|
* should be sent with no data. currently,
|
|
|
|
* we will allow user data to be sent first
|
|
|
|
* and move to SHUTDOWN-PENDING
|
|
|
|
*/
|
2018-08-13 13:58:45 +00:00
|
|
|
SCTP_ADD_SUBSTATE(stcb, SCTP_STATE_SHUTDOWN_PENDING);
|
2020-03-19 21:01:16 +00:00
|
|
|
sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWNGUARD, stcb->sctp_ep, stcb, NULL);
|
2016-08-06 12:33:15 +00:00
|
|
|
if ((*asoc->ss_functions.sctp_ss_is_user_msgs_incomplete) (stcb, asoc)) {
|
2018-08-13 13:58:45 +00:00
|
|
|
SCTP_ADD_SUBSTATE(stcb, SCTP_STATE_PARTIAL_MSG_LEFT);
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
if (TAILQ_EMPTY(&asoc->send_queue) &&
|
|
|
|
TAILQ_EMPTY(&asoc->sent_queue) &&
|
|
|
|
(asoc->state & SCTP_STATE_PARTIAL_MSG_LEFT)) {
|
|
|
|
struct mbuf *op_err;
|
|
|
|
|
|
|
|
abort_anyway:
|
2014-03-16 12:32:16 +00:00
|
|
|
op_err = sctp_generate_cause(SCTP_CAUSE_USER_INITIATED_ABT, "");
|
2006-12-14 17:02:55 +00:00
|
|
|
stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_USRREQ + SCTP_LOC_4;
|
2007-09-08 11:35:11 +00:00
|
|
|
sctp_send_abort_tcb(stcb, op_err, SCTP_SO_LOCKED);
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_STAT_INCR_COUNTER32(sctps_aborted);
|
2018-08-13 13:58:45 +00:00
|
|
|
if ((SCTP_GET_STATE(stcb) == SCTP_STATE_OPEN) ||
|
|
|
|
(SCTP_GET_STATE(stcb) == SCTP_STATE_SHUTDOWN_RECEIVED)) {
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_STAT_DECR_GAUGE32(sctps_currestab);
|
|
|
|
}
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
2015-05-28 16:00:23 +00:00
|
|
|
(void)sctp_free_assoc(inp, stcb, SCTP_NORMAL_PROC,
|
|
|
|
SCTP_FROM_SCTP_USRREQ + SCTP_LOC_5);
|
2020-02-18 21:25:17 +00:00
|
|
|
NET_EPOCH_EXIT(et);
|
2006-11-03 15:23:16 +00:00
|
|
|
return (0);
|
2007-08-27 05:19:48 +00:00
|
|
|
} else {
|
2007-09-08 11:35:11 +00:00
|
|
|
sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_CLOSING, SCTP_SO_LOCKED);
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
}
|
2009-02-03 11:04:03 +00:00
|
|
|
soisdisconnecting(so);
|
2020-02-18 21:25:17 +00:00
|
|
|
NET_EPOCH_EXIT(et);
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
/* not reached */
|
|
|
|
} else {
|
|
|
|
/* UDP model does not support this */
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EOPNOTSUPP);
|
2011-12-27 10:16:24 +00:00
|
|
|
return (EOPNOTSUPP);
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-04-14 18:13:33 +00:00
|
|
|
int
|
|
|
|
sctp_flush(struct socket *so, int how)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* We will just clear out the values and let subsequent close clear
|
|
|
|
* out the data, if any. Note if the user did a shutdown(SHUT_RD)
|
|
|
|
* they will not be able to read the data, the socket will block
|
|
|
|
* that from happening.
|
|
|
|
*/
|
2010-06-18 09:01:44 +00:00
|
|
|
struct sctp_inpcb *inp;
|
|
|
|
|
|
|
|
inp = (struct sctp_inpcb *)so->so_pcb;
|
|
|
|
if (inp == NULL) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2011-12-27 10:16:24 +00:00
|
|
|
return (EINVAL);
|
2010-06-18 09:01:44 +00:00
|
|
|
}
|
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
/* For the 1 to many model this does nothing */
|
|
|
|
if (inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) {
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
2008-04-14 18:13:33 +00:00
|
|
|
if ((how == PRU_FLUSH_RD) || (how == PRU_FLUSH_RDWR)) {
|
|
|
|
/*
|
|
|
|
* First make sure the sb will be happy, we don't use these
|
|
|
|
* except maybe the count
|
|
|
|
*/
|
2010-06-18 09:01:44 +00:00
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
SCTP_INP_READ_LOCK(inp);
|
|
|
|
inp->sctp_flags |= SCTP_PCB_FLAGS_SOCKET_CANT_READ;
|
|
|
|
SCTP_INP_READ_UNLOCK(inp);
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
2014-12-02 20:29:29 +00:00
|
|
|
so->so_rcv.sb_cc = 0;
|
2008-04-14 18:13:33 +00:00
|
|
|
so->so_rcv.sb_mbcnt = 0;
|
|
|
|
so->so_rcv.sb_mb = NULL;
|
|
|
|
}
|
|
|
|
if ((how == PRU_FLUSH_WR) || (how == PRU_FLUSH_RDWR)) {
|
|
|
|
/*
|
|
|
|
* First make sure the sb will be happy, we don't use these
|
|
|
|
* except maybe the count
|
|
|
|
*/
|
2014-12-02 20:29:29 +00:00
|
|
|
so->so_snd.sb_cc = 0;
|
2008-04-14 18:13:33 +00:00
|
|
|
so->so_snd.sb_mbcnt = 0;
|
|
|
|
so->so_snd.sb_mb = NULL;
|
|
|
|
}
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2006-11-03 15:23:16 +00:00
|
|
|
int
|
|
|
|
sctp_shutdown(struct socket *so)
|
|
|
|
{
|
|
|
|
struct sctp_inpcb *inp;
|
|
|
|
|
|
|
|
inp = (struct sctp_inpcb *)so->so_pcb;
|
2012-03-15 14:22:05 +00:00
|
|
|
if (inp == NULL) {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2011-12-27 10:16:24 +00:00
|
|
|
return (EINVAL);
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
/* For UDP model this is a invalid call */
|
2012-11-26 08:50:00 +00:00
|
|
|
if (!((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL))) {
|
2006-11-03 15:23:16 +00:00
|
|
|
/* Restore the flags that the soshutdown took away. */
|
2010-02-19 18:00:38 +00:00
|
|
|
SOCKBUF_LOCK(&so->so_rcv);
|
2006-11-03 15:23:16 +00:00
|
|
|
so->so_rcv.sb_state &= ~SBS_CANTRCVMORE;
|
2010-02-19 18:00:38 +00:00
|
|
|
SOCKBUF_UNLOCK(&so->so_rcv);
|
2006-11-03 15:23:16 +00:00
|
|
|
/* This proc will wakeup for read and do nothing (I hope) */
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EOPNOTSUPP);
|
2006-11-03 15:23:16 +00:00
|
|
|
return (EOPNOTSUPP);
|
2015-11-19 16:46:00 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Ok, if we reach here its the TCP model and it is either a
|
|
|
|
* SHUT_WR or SHUT_RDWR. This means we put the shutdown flag
|
|
|
|
* against it.
|
|
|
|
*/
|
2020-02-18 21:25:17 +00:00
|
|
|
struct epoch_tracker et;
|
2006-11-03 15:23:16 +00:00
|
|
|
struct sctp_tcb *stcb;
|
|
|
|
struct sctp_association *asoc;
|
2015-11-19 16:46:00 +00:00
|
|
|
struct sctp_nets *netp;
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2009-02-03 11:04:03 +00:00
|
|
|
if ((so->so_state &
|
|
|
|
(SS_ISCONNECTED | SS_ISCONNECTING | SS_ISDISCONNECTING)) == 0) {
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
return (ENOTCONN);
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
socantsendmore(so);
|
|
|
|
|
|
|
|
stcb = LIST_FIRST(&inp->sctp_asoc_list);
|
|
|
|
if (stcb == NULL) {
|
|
|
|
/*
|
2015-11-19 16:46:00 +00:00
|
|
|
* Ok, we hit the case that the shutdown call was
|
2006-11-03 15:23:16 +00:00
|
|
|
* made after an abort or something. Nothing to do
|
|
|
|
* now.
|
|
|
|
*/
|
2007-04-03 11:15:32 +00:00
|
|
|
SCTP_INP_RUNLOCK(inp);
|
2006-11-03 15:23:16 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
SCTP_TCB_LOCK(stcb);
|
|
|
|
asoc = &stcb->asoc;
|
2015-11-19 16:46:00 +00:00
|
|
|
if (asoc->state & SCTP_STATE_ABOUT_TO_BE_FREED) {
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
return (0);
|
|
|
|
}
|
2018-08-13 13:58:45 +00:00
|
|
|
if ((SCTP_GET_STATE(stcb) != SCTP_STATE_COOKIE_WAIT) &&
|
|
|
|
(SCTP_GET_STATE(stcb) != SCTP_STATE_COOKIE_ECHOED) &&
|
|
|
|
(SCTP_GET_STATE(stcb) != SCTP_STATE_OPEN)) {
|
2015-11-19 16:46:00 +00:00
|
|
|
/*
|
|
|
|
* If we are not in or before ESTABLISHED, there is
|
|
|
|
* no protocol action required.
|
|
|
|
*/
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
return (0);
|
|
|
|
}
|
2020-02-18 21:25:17 +00:00
|
|
|
NET_EPOCH_ENTER(et);
|
2015-11-19 16:46:00 +00:00
|
|
|
if (stcb->asoc.alternate) {
|
|
|
|
netp = stcb->asoc.alternate;
|
|
|
|
} else {
|
|
|
|
netp = stcb->asoc.primary_destination;
|
|
|
|
}
|
2018-08-13 13:58:45 +00:00
|
|
|
if ((SCTP_GET_STATE(stcb) == SCTP_STATE_OPEN) &&
|
2015-11-21 16:25:09 +00:00
|
|
|
TAILQ_EMPTY(&asoc->send_queue) &&
|
2006-11-03 15:23:16 +00:00
|
|
|
TAILQ_EMPTY(&asoc->sent_queue) &&
|
|
|
|
(asoc->stream_queue_cnt == 0)) {
|
2016-08-06 12:33:15 +00:00
|
|
|
if ((*asoc->ss_functions.sctp_ss_is_user_msgs_incomplete) (stcb, asoc)) {
|
2006-11-03 15:23:16 +00:00
|
|
|
goto abort_anyway;
|
|
|
|
}
|
|
|
|
/* there is nothing queued to send, so I'm done... */
|
2015-11-21 16:25:09 +00:00
|
|
|
SCTP_STAT_DECR_GAUGE32(sctps_currestab);
|
2018-08-13 13:58:45 +00:00
|
|
|
SCTP_SET_STATE(stcb, SCTP_STATE_SHUTDOWN_SENT);
|
2015-11-19 16:46:00 +00:00
|
|
|
sctp_stop_timers_for_shutdown(stcb);
|
|
|
|
sctp_send_shutdown(stcb, netp);
|
|
|
|
sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWN,
|
|
|
|
stcb->sctp_ep, stcb, netp);
|
2006-11-03 15:23:16 +00:00
|
|
|
} else {
|
|
|
|
/*
|
2015-11-19 16:46:00 +00:00
|
|
|
* We still got (or just got) data to send, so set
|
|
|
|
* SHUTDOWN_PENDING.
|
2006-11-03 15:23:16 +00:00
|
|
|
*/
|
2018-08-13 13:58:45 +00:00
|
|
|
SCTP_ADD_SUBSTATE(stcb, SCTP_STATE_SHUTDOWN_PENDING);
|
2016-08-06 12:33:15 +00:00
|
|
|
if ((*asoc->ss_functions.sctp_ss_is_user_msgs_incomplete) (stcb, asoc)) {
|
2018-08-13 13:58:45 +00:00
|
|
|
SCTP_ADD_SUBSTATE(stcb, SCTP_STATE_PARTIAL_MSG_LEFT);
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
if (TAILQ_EMPTY(&asoc->send_queue) &&
|
|
|
|
TAILQ_EMPTY(&asoc->sent_queue) &&
|
|
|
|
(asoc->state & SCTP_STATE_PARTIAL_MSG_LEFT)) {
|
|
|
|
struct mbuf *op_err;
|
|
|
|
|
|
|
|
abort_anyway:
|
2014-03-16 12:32:16 +00:00
|
|
|
op_err = sctp_generate_cause(SCTP_CAUSE_USER_INITIATED_ABT, "");
|
2006-12-14 17:02:55 +00:00
|
|
|
stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_USRREQ + SCTP_LOC_6;
|
2019-07-23 18:07:36 +00:00
|
|
|
SCTP_INP_RUNLOCK(inp);
|
2006-11-03 15:23:16 +00:00
|
|
|
sctp_abort_an_association(stcb->sctp_ep, stcb,
|
2021-07-09 21:17:35 +00:00
|
|
|
op_err, false, SCTP_SO_LOCKED);
|
2020-02-18 21:25:17 +00:00
|
|
|
NET_EPOCH_EXIT(et);
|
2015-11-19 16:46:00 +00:00
|
|
|
return (0);
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
}
|
2020-03-19 21:01:16 +00:00
|
|
|
sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWNGUARD, stcb->sctp_ep, stcb, NULL);
|
2016-12-26 11:06:41 +00:00
|
|
|
/*
|
|
|
|
* XXX: Why do this in the case where we have still data
|
|
|
|
* queued?
|
|
|
|
*/
|
2015-11-19 16:46:00 +00:00
|
|
|
sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_CLOSING, SCTP_SO_LOCKED);
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
2015-11-19 16:46:00 +00:00
|
|
|
SCTP_INP_RUNLOCK(inp);
|
2020-02-18 21:25:17 +00:00
|
|
|
NET_EPOCH_EXIT(et);
|
2015-11-19 16:46:00 +00:00
|
|
|
return (0);
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* copies a "user" presentable address and removes embedded scope, etc.
|
|
|
|
* returns 0 on success, 1 on error
|
|
|
|
*/
|
|
|
|
static uint32_t
|
2020-06-23 23:05:05 +00:00
|
|
|
sctp_fill_user_address(struct sockaddr *dst, struct sockaddr *src)
|
2018-07-19 20:11:14 +00:00
|
|
|
{
|
2008-04-16 17:24:18 +00:00
|
|
|
#ifdef INET6
|
2006-11-03 15:23:16 +00:00
|
|
|
struct sockaddr_in6 lsa6;
|
|
|
|
|
2020-06-23 23:05:05 +00:00
|
|
|
src = (struct sockaddr *)sctp_recover_scope((struct sockaddr_in6 *)src,
|
2006-11-03 15:23:16 +00:00
|
|
|
&lsa6);
|
2008-04-16 17:24:18 +00:00
|
|
|
#endif
|
2020-06-23 23:05:05 +00:00
|
|
|
memcpy(dst, src, src->sa_len);
|
2006-11-03 15:23:16 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
static size_t
|
2007-03-31 11:47:30 +00:00
|
|
|
sctp_fill_up_addresses_vrf(struct sctp_inpcb *inp,
|
2006-11-03 15:23:16 +00:00
|
|
|
struct sctp_tcb *stcb,
|
2007-02-12 23:24:31 +00:00
|
|
|
size_t limit,
|
2020-06-23 23:05:05 +00:00
|
|
|
struct sockaddr *addr,
|
2007-03-15 11:27:14 +00:00
|
|
|
uint32_t vrf_id)
|
2006-11-03 15:23:16 +00:00
|
|
|
{
|
2007-03-15 11:27:14 +00:00
|
|
|
struct sctp_ifn *sctp_ifn;
|
|
|
|
struct sctp_ifa *sctp_ifa;
|
2007-02-12 23:24:31 +00:00
|
|
|
size_t actual;
|
2013-11-02 20:12:19 +00:00
|
|
|
int loopback_scope;
|
|
|
|
#if defined(INET)
|
|
|
|
int ipv4_local_scope, ipv4_addr_legal;
|
|
|
|
#endif
|
|
|
|
#if defined(INET6)
|
|
|
|
int local_scope, site_scope, ipv6_addr_legal;
|
|
|
|
#endif
|
2007-03-15 11:27:14 +00:00
|
|
|
struct sctp_vrf *vrf;
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2020-07-17 15:09:49 +00:00
|
|
|
SCTP_IPI_ADDR_LOCK_ASSERT();
|
2006-11-03 15:23:16 +00:00
|
|
|
actual = 0;
|
2020-05-18 19:35:46 +00:00
|
|
|
if (limit == 0)
|
2006-11-03 15:23:16 +00:00
|
|
|
return (actual);
|
|
|
|
|
|
|
|
if (stcb) {
|
|
|
|
/* Turn on all the appropriate scope */
|
2013-02-09 17:26:14 +00:00
|
|
|
loopback_scope = stcb->asoc.scope.loopback_scope;
|
2013-11-02 20:12:19 +00:00
|
|
|
#if defined(INET)
|
2013-02-09 17:26:14 +00:00
|
|
|
ipv4_local_scope = stcb->asoc.scope.ipv4_local_scope;
|
2013-11-02 20:12:19 +00:00
|
|
|
ipv4_addr_legal = stcb->asoc.scope.ipv4_addr_legal;
|
|
|
|
#endif
|
|
|
|
#if defined(INET6)
|
2013-02-09 17:26:14 +00:00
|
|
|
local_scope = stcb->asoc.scope.local_scope;
|
|
|
|
site_scope = stcb->asoc.scope.site_scope;
|
|
|
|
ipv6_addr_legal = stcb->asoc.scope.ipv6_addr_legal;
|
2013-11-02 20:12:19 +00:00
|
|
|
#endif
|
2006-11-03 15:23:16 +00:00
|
|
|
} else {
|
2013-02-09 17:26:14 +00:00
|
|
|
/* Use generic values for endpoints. */
|
|
|
|
loopback_scope = 1;
|
2013-11-02 20:12:19 +00:00
|
|
|
#if defined(INET)
|
2013-02-09 17:26:14 +00:00
|
|
|
ipv4_local_scope = 1;
|
2013-11-02 20:12:19 +00:00
|
|
|
#endif
|
|
|
|
#if defined(INET6)
|
2013-02-09 17:26:14 +00:00
|
|
|
local_scope = 1;
|
|
|
|
site_scope = 1;
|
2013-11-02 20:12:19 +00:00
|
|
|
#endif
|
2013-02-09 17:26:14 +00:00
|
|
|
if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) {
|
2013-11-02 20:12:19 +00:00
|
|
|
#if defined(INET6)
|
2013-02-09 17:26:14 +00:00
|
|
|
ipv6_addr_legal = 1;
|
2013-11-02 20:12:19 +00:00
|
|
|
#endif
|
|
|
|
#if defined(INET)
|
2013-02-09 17:26:14 +00:00
|
|
|
if (SCTP_IPV6_V6ONLY(inp)) {
|
|
|
|
ipv4_addr_legal = 0;
|
|
|
|
} else {
|
|
|
|
ipv4_addr_legal = 1;
|
|
|
|
}
|
2013-11-02 20:12:19 +00:00
|
|
|
#endif
|
2013-02-09 17:26:14 +00:00
|
|
|
} else {
|
2013-11-02 20:12:19 +00:00
|
|
|
#if defined(INET6)
|
2013-02-09 17:26:14 +00:00
|
|
|
ipv6_addr_legal = 0;
|
2013-11-02 20:12:19 +00:00
|
|
|
#endif
|
|
|
|
#if defined(INET)
|
2006-11-03 15:23:16 +00:00
|
|
|
ipv4_addr_legal = 1;
|
2013-11-02 20:12:19 +00:00
|
|
|
#endif
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
}
|
2007-03-15 11:27:14 +00:00
|
|
|
vrf = sctp_find_vrf(vrf_id);
|
|
|
|
if (vrf == NULL) {
|
|
|
|
return (0);
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) {
|
2007-03-15 11:27:14 +00:00
|
|
|
LIST_FOREACH(sctp_ifn, &vrf->ifnlist, next_ifn) {
|
2006-11-03 15:23:16 +00:00
|
|
|
if ((loopback_scope == 0) &&
|
2007-03-15 11:27:14 +00:00
|
|
|
SCTP_IFN_IS_IFT_LOOP(sctp_ifn)) {
|
2006-11-03 15:23:16 +00:00
|
|
|
/* Skip loopback if loopback_scope not set */
|
|
|
|
continue;
|
|
|
|
}
|
2007-03-15 11:27:14 +00:00
|
|
|
LIST_FOREACH(sctp_ifa, &sctp_ifn->ifalist, next_ifa) {
|
2006-11-03 15:23:16 +00:00
|
|
|
if (stcb) {
|
|
|
|
/*
|
|
|
|
* For the BOUND-ALL case, the list
|
|
|
|
* associated with a TCB is Always
|
|
|
|
* considered a reverse list.. i.e.
|
|
|
|
* it lists addresses that are NOT
|
|
|
|
* part of the association. If this
|
|
|
|
* is one of those we must skip it.
|
|
|
|
*/
|
|
|
|
if (sctp_is_addr_restricted(stcb,
|
2007-03-15 11:27:14 +00:00
|
|
|
sctp_ifa)) {
|
2006-11-03 15:23:16 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
2008-04-16 17:24:18 +00:00
|
|
|
switch (sctp_ifa->address.sa.sa_family) {
|
2011-04-30 11:18:16 +00:00
|
|
|
#ifdef INET
|
2008-04-16 17:24:18 +00:00
|
|
|
case AF_INET:
|
|
|
|
if (ipv4_addr_legal) {
|
|
|
|
struct sockaddr_in *sin;
|
|
|
|
|
2014-09-07 09:06:26 +00:00
|
|
|
sin = &sctp_ifa->address.sin;
|
2008-04-16 17:24:18 +00:00
|
|
|
if (sin->sin_addr.s_addr == 0) {
|
|
|
|
/*
|
|
|
|
* we skip
|
|
|
|
* unspecifed
|
|
|
|
* addresses
|
|
|
|
*/
|
|
|
|
continue;
|
|
|
|
}
|
2014-06-20 13:26:49 +00:00
|
|
|
if (prison_check_ip4(inp->ip_inp.inp.inp_cred,
|
|
|
|
&sin->sin_addr) != 0) {
|
|
|
|
continue;
|
|
|
|
}
|
2008-04-16 17:24:18 +00:00
|
|
|
if ((ipv4_local_scope == 0) &&
|
|
|
|
(IN4_ISPRIVATE_ADDRESS(&sin->sin_addr))) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
#ifdef INET6
|
|
|
|
if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_NEEDS_MAPPED_V4)) {
|
2019-03-01 18:47:41 +00:00
|
|
|
if (actual + sizeof(struct sockaddr_in6) > limit) {
|
|
|
|
return (actual);
|
|
|
|
}
|
2020-08-18 19:25:03 +00:00
|
|
|
in6_sin_2_v4mapsin6(sin, (struct sockaddr_in6 *)addr);
|
2020-06-23 23:05:05 +00:00
|
|
|
((struct sockaddr_in6 *)addr)->sin6_port = inp->sctp_lport;
|
|
|
|
addr = (struct sockaddr *)((caddr_t)addr + sizeof(struct sockaddr_in6));
|
2008-04-16 17:24:18 +00:00
|
|
|
actual += sizeof(struct sockaddr_in6);
|
|
|
|
} else {
|
|
|
|
#endif
|
2019-03-01 18:47:41 +00:00
|
|
|
if (actual + sizeof(struct sockaddr_in) > limit) {
|
|
|
|
return (actual);
|
|
|
|
}
|
2020-06-21 23:12:56 +00:00
|
|
|
memcpy(addr, sin, sizeof(struct sockaddr_in));
|
2020-06-23 23:05:05 +00:00
|
|
|
((struct sockaddr_in *)addr)->sin_port = inp->sctp_lport;
|
|
|
|
addr = (struct sockaddr *)((caddr_t)addr + sizeof(struct sockaddr_in));
|
2019-03-01 15:57:55 +00:00
|
|
|
actual += sizeof(struct sockaddr_in);
|
2008-04-16 17:24:18 +00:00
|
|
|
#ifdef INET6
|
|
|
|
}
|
|
|
|
#endif
|
2006-11-03 15:23:16 +00:00
|
|
|
} else {
|
|
|
|
continue;
|
|
|
|
}
|
2008-04-16 17:24:18 +00:00
|
|
|
break;
|
2011-04-30 11:18:16 +00:00
|
|
|
#endif
|
2008-04-16 17:24:18 +00:00
|
|
|
#ifdef INET6
|
|
|
|
case AF_INET6:
|
|
|
|
if (ipv6_addr_legal) {
|
|
|
|
struct sockaddr_in6 *sin6;
|
|
|
|
|
2014-09-07 09:06:26 +00:00
|
|
|
sin6 = &sctp_ifa->address.sin6;
|
2008-04-16 17:24:18 +00:00
|
|
|
if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
|
|
|
|
/*
|
|
|
|
* we skip
|
|
|
|
* unspecifed
|
|
|
|
* addresses
|
|
|
|
*/
|
2006-11-03 15:23:16 +00:00
|
|
|
continue;
|
2008-04-16 17:24:18 +00:00
|
|
|
}
|
2014-06-20 13:26:49 +00:00
|
|
|
if (prison_check_ip6(inp->ip_inp.inp.inp_cred,
|
|
|
|
&sin6->sin6_addr) != 0) {
|
|
|
|
continue;
|
|
|
|
}
|
2008-04-16 17:24:18 +00:00
|
|
|
if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr)) {
|
|
|
|
if (local_scope == 0)
|
2006-11-03 15:23:16 +00:00
|
|
|
continue;
|
2008-04-16 17:24:18 +00:00
|
|
|
if (sin6->sin6_scope_id == 0) {
|
|
|
|
if (sa6_recoverscope(sin6) != 0)
|
|
|
|
/*
|
2016-12-06 10:21:25 +00:00
|
|
|
*
|
2008-04-16 17:24:18 +00:00
|
|
|
* bad
|
2016-12-06 10:21:25 +00:00
|
|
|
* link
|
|
|
|
*
|
|
|
|
* local
|
|
|
|
*
|
|
|
|
* address
|
|
|
|
*/
|
2008-04-16 17:24:18 +00:00
|
|
|
continue;
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2008-04-16 17:24:18 +00:00
|
|
|
if ((site_scope == 0) &&
|
|
|
|
(IN6_IS_ADDR_SITELOCAL(&sin6->sin6_addr))) {
|
|
|
|
continue;
|
|
|
|
}
|
2019-03-01 18:47:41 +00:00
|
|
|
if (actual + sizeof(struct sockaddr_in6) > limit) {
|
|
|
|
return (actual);
|
|
|
|
}
|
2020-06-21 23:12:56 +00:00
|
|
|
memcpy(addr, sin6, sizeof(struct sockaddr_in6));
|
2020-06-23 23:05:05 +00:00
|
|
|
((struct sockaddr_in6 *)addr)->sin6_port = inp->sctp_lport;
|
|
|
|
addr = (struct sockaddr *)((caddr_t)addr + sizeof(struct sockaddr_in6));
|
2019-03-01 15:57:55 +00:00
|
|
|
actual += sizeof(struct sockaddr_in6);
|
2008-04-16 17:24:18 +00:00
|
|
|
} else {
|
2006-11-03 15:23:16 +00:00
|
|
|
continue;
|
|
|
|
}
|
2008-04-16 17:24:18 +00:00
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
default:
|
|
|
|
/* TSNH */
|
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
struct sctp_laddr *laddr;
|
2019-03-01 18:47:41 +00:00
|
|
|
size_t sa_len;
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2007-03-15 11:27:14 +00:00
|
|
|
LIST_FOREACH(laddr, &inp->sctp_addr_list, sctp_nxt_addr) {
|
|
|
|
if (stcb) {
|
|
|
|
if (sctp_is_addr_restricted(stcb, laddr->ifa)) {
|
2006-11-03 15:23:16 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
2019-03-01 18:47:41 +00:00
|
|
|
sa_len = laddr->ifa->address.sa.sa_len;
|
|
|
|
if (actual + sa_len > limit) {
|
|
|
|
return (actual);
|
|
|
|
}
|
2020-06-21 23:12:56 +00:00
|
|
|
if (sctp_fill_user_address(addr, &laddr->ifa->address.sa))
|
2007-03-15 11:27:14 +00:00
|
|
|
continue;
|
2013-02-09 17:26:14 +00:00
|
|
|
switch (laddr->ifa->address.sa.sa_family) {
|
|
|
|
#ifdef INET
|
|
|
|
case AF_INET:
|
2020-06-23 23:05:05 +00:00
|
|
|
((struct sockaddr_in *)addr)->sin_port = inp->sctp_lport;
|
2013-02-09 17:26:14 +00:00
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
#ifdef INET6
|
|
|
|
case AF_INET6:
|
2020-06-23 23:05:05 +00:00
|
|
|
((struct sockaddr_in6 *)addr)->sin6_port = inp->sctp_lport;
|
2013-02-09 17:26:14 +00:00
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
default:
|
|
|
|
/* TSNH */
|
|
|
|
break;
|
|
|
|
}
|
2020-06-23 23:05:05 +00:00
|
|
|
addr = (struct sockaddr *)((caddr_t)addr + sa_len);
|
2019-03-01 18:47:41 +00:00
|
|
|
actual += sa_len;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return (actual);
|
|
|
|
}
|
|
|
|
|
2007-03-31 11:47:30 +00:00
|
|
|
static size_t
|
|
|
|
sctp_fill_up_addresses(struct sctp_inpcb *inp,
|
|
|
|
struct sctp_tcb *stcb,
|
|
|
|
size_t limit,
|
2020-06-23 23:05:05 +00:00
|
|
|
struct sockaddr *addr)
|
2007-03-31 11:47:30 +00:00
|
|
|
{
|
|
|
|
size_t size = 0;
|
|
|
|
|
2007-09-18 15:16:39 +00:00
|
|
|
SCTP_IPI_ADDR_RLOCK();
|
2007-03-31 11:47:30 +00:00
|
|
|
/* fill up addresses for the endpoint's default vrf */
|
2020-06-21 23:12:56 +00:00
|
|
|
size = sctp_fill_up_addresses_vrf(inp, stcb, limit, addr,
|
2007-03-31 11:47:30 +00:00
|
|
|
inp->def_vrf_id);
|
2007-09-18 15:16:39 +00:00
|
|
|
SCTP_IPI_ADDR_RUNLOCK();
|
2007-03-31 11:47:30 +00:00
|
|
|
return (size);
|
|
|
|
}
|
|
|
|
|
2006-11-03 15:23:16 +00:00
|
|
|
static int
|
2007-03-31 11:47:30 +00:00
|
|
|
sctp_count_max_addresses_vrf(struct sctp_inpcb *inp, uint32_t vrf_id)
|
2006-11-03 15:23:16 +00:00
|
|
|
{
|
|
|
|
int cnt = 0;
|
2007-03-15 11:27:14 +00:00
|
|
|
struct sctp_vrf *vrf = NULL;
|
2006-11-03 15:23:16 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* In both sub-set bound an bound_all cases we return the MAXIMUM
|
|
|
|
* number of addresses that you COULD get. In reality the sub-set
|
|
|
|
* bound may have an exclusion list for a given TCB OR in the
|
|
|
|
* bound-all case a TCB may NOT include the loopback or other
|
|
|
|
* addresses as well.
|
|
|
|
*/
|
2020-07-17 15:09:49 +00:00
|
|
|
SCTP_IPI_ADDR_LOCK_ASSERT();
|
2007-03-15 11:27:14 +00:00
|
|
|
vrf = sctp_find_vrf(vrf_id);
|
|
|
|
if (vrf == NULL) {
|
|
|
|
return (0);
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) {
|
2007-03-15 11:27:14 +00:00
|
|
|
struct sctp_ifn *sctp_ifn;
|
|
|
|
struct sctp_ifa *sctp_ifa;
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2007-03-15 11:27:14 +00:00
|
|
|
LIST_FOREACH(sctp_ifn, &vrf->ifnlist, next_ifn) {
|
|
|
|
LIST_FOREACH(sctp_ifa, &sctp_ifn->ifalist, next_ifa) {
|
2006-11-03 15:23:16 +00:00
|
|
|
/* Count them if they are the right type */
|
2011-04-30 11:18:16 +00:00
|
|
|
switch (sctp_ifa->address.sa.sa_family) {
|
|
|
|
#ifdef INET
|
|
|
|
case AF_INET:
|
2014-12-06 20:00:08 +00:00
|
|
|
#ifdef INET6
|
2008-04-16 17:24:18 +00:00
|
|
|
if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_NEEDS_MAPPED_V4))
|
2006-11-03 15:23:16 +00:00
|
|
|
cnt += sizeof(struct sockaddr_in6);
|
|
|
|
else
|
|
|
|
cnt += sizeof(struct sockaddr_in);
|
2014-12-06 20:00:08 +00:00
|
|
|
#else
|
|
|
|
cnt += sizeof(struct sockaddr_in);
|
|
|
|
#endif
|
2011-04-30 11:18:16 +00:00
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
#ifdef INET6
|
|
|
|
case AF_INET6:
|
2006-11-03 15:23:16 +00:00
|
|
|
cnt += sizeof(struct sockaddr_in6);
|
2011-04-30 11:18:16 +00:00
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
struct sctp_laddr *laddr;
|
|
|
|
|
|
|
|
LIST_FOREACH(laddr, &inp->sctp_addr_list, sctp_nxt_addr) {
|
2011-04-30 11:18:16 +00:00
|
|
|
switch (laddr->ifa->address.sa.sa_family) {
|
|
|
|
#ifdef INET
|
|
|
|
case AF_INET:
|
2014-12-06 20:00:08 +00:00
|
|
|
#ifdef INET6
|
2008-04-16 17:24:18 +00:00
|
|
|
if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_NEEDS_MAPPED_V4))
|
2006-11-03 15:23:16 +00:00
|
|
|
cnt += sizeof(struct sockaddr_in6);
|
|
|
|
else
|
|
|
|
cnt += sizeof(struct sockaddr_in);
|
2014-12-06 20:00:08 +00:00
|
|
|
#else
|
|
|
|
cnt += sizeof(struct sockaddr_in);
|
|
|
|
#endif
|
2011-04-30 11:18:16 +00:00
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
#ifdef INET6
|
|
|
|
case AF_INET6:
|
2006-11-03 15:23:16 +00:00
|
|
|
cnt += sizeof(struct sockaddr_in6);
|
2011-04-30 11:18:16 +00:00
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return (cnt);
|
|
|
|
}
|
|
|
|
|
2007-03-31 11:47:30 +00:00
|
|
|
static int
|
|
|
|
sctp_count_max_addresses(struct sctp_inpcb *inp)
|
|
|
|
{
|
|
|
|
int cnt = 0;
|
|
|
|
|
2007-09-18 15:16:39 +00:00
|
|
|
SCTP_IPI_ADDR_RLOCK();
|
2007-03-31 11:47:30 +00:00
|
|
|
/* count addresses for the endpoint's default VRF */
|
|
|
|
cnt = sctp_count_max_addresses_vrf(inp, inp->def_vrf_id);
|
2007-09-18 15:16:39 +00:00
|
|
|
SCTP_IPI_ADDR_RUNLOCK();
|
2007-03-31 11:47:30 +00:00
|
|
|
return (cnt);
|
|
|
|
}
|
|
|
|
|
2006-11-03 15:23:16 +00:00
|
|
|
static int
|
2007-02-12 23:24:31 +00:00
|
|
|
sctp_do_connect_x(struct socket *so, struct sctp_inpcb *inp, void *optval,
|
|
|
|
size_t optsize, void *p, int delay)
|
2006-11-03 15:23:16 +00:00
|
|
|
{
|
2019-05-19 17:28:00 +00:00
|
|
|
int error;
|
2006-11-03 15:23:16 +00:00
|
|
|
int creat_lock_on = 0;
|
|
|
|
struct sctp_tcb *stcb = NULL;
|
|
|
|
struct sockaddr *sa;
|
2016-03-27 10:04:25 +00:00
|
|
|
unsigned int num_v6 = 0, num_v4 = 0, *totaddrp, totaddr;
|
2007-03-15 11:27:14 +00:00
|
|
|
uint32_t vrf_id;
|
|
|
|
sctp_assoc_t *a_id;
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2007-05-09 13:30:06 +00:00
|
|
|
SCTPDBG(SCTP_DEBUG_PCB1, "Connectx called\n");
|
2006-11-03 15:23:16 +00:00
|
|
|
|
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) &&
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED)) {
|
|
|
|
/* We are already connected AND the TCP model */
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, stcb, NULL, SCTP_FROM_SCTP_USRREQ, EADDRINUSE);
|
2006-11-03 15:23:16 +00:00
|
|
|
return (EADDRINUSE);
|
|
|
|
}
|
2018-07-19 20:16:33 +00:00
|
|
|
|
2008-07-31 11:08:30 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) &&
|
|
|
|
(sctp_is_feature_off(inp, SCTP_PCB_FLAGS_PORTREUSE))) {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, stcb, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2006-11-03 15:23:16 +00:00
|
|
|
return (EINVAL);
|
|
|
|
}
|
2018-07-19 20:16:33 +00:00
|
|
|
|
2006-11-03 15:23:16 +00:00
|
|
|
if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
|
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
stcb = LIST_FIRST(&inp->sctp_asoc_list);
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
}
|
|
|
|
if (stcb) {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, stcb, NULL, SCTP_FROM_SCTP_USRREQ, EALREADY);
|
2006-11-03 15:23:16 +00:00
|
|
|
return (EALREADY);
|
|
|
|
}
|
|
|
|
SCTP_INP_INCR_REF(inp);
|
|
|
|
SCTP_ASOC_CREATE_LOCK(inp);
|
|
|
|
creat_lock_on = 1;
|
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_ALLGONE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE)) {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, stcb, NULL, SCTP_FROM_SCTP_USRREQ, EFAULT);
|
2006-11-03 15:23:16 +00:00
|
|
|
error = EFAULT;
|
|
|
|
goto out_now;
|
|
|
|
}
|
2016-03-27 10:04:25 +00:00
|
|
|
totaddrp = (unsigned int *)optval;
|
2006-11-03 15:23:16 +00:00
|
|
|
totaddr = *totaddrp;
|
|
|
|
sa = (struct sockaddr *)(totaddrp + 1);
|
2019-05-19 17:28:00 +00:00
|
|
|
error = sctp_connectx_helper_find(inp, sa, totaddr, &num_v4, &num_v6, (unsigned int)(optsize - sizeof(int)));
|
|
|
|
if (error != 0) {
|
2007-05-08 00:21:05 +00:00
|
|
|
/* Already have or am bring up an association */
|
|
|
|
SCTP_ASOC_CREATE_UNLOCK(inp);
|
|
|
|
creat_lock_on = 0;
|
2019-05-19 17:28:00 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
|
2007-05-08 00:21:05 +00:00
|
|
|
goto out_now;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
#ifdef INET6
|
|
|
|
if (((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) == 0) &&
|
|
|
|
(num_v6 > 0)) {
|
|
|
|
error = EINVAL;
|
|
|
|
goto out_now;
|
|
|
|
}
|
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) &&
|
|
|
|
(num_v4 > 0)) {
|
2019-08-02 07:41:36 +00:00
|
|
|
if (SCTP_IPV6_V6ONLY(inp)) {
|
2006-11-03 15:23:16 +00:00
|
|
|
/*
|
|
|
|
* if IPV6_V6ONLY flag, ignore connections destined
|
|
|
|
* to a v4 addr or v4-mapped addr
|
|
|
|
*/
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, stcb, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2006-11-03 15:23:16 +00:00
|
|
|
error = EINVAL;
|
|
|
|
goto out_now;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif /* INET6 */
|
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_UNBOUND) ==
|
|
|
|
SCTP_PCB_FLAGS_UNBOUND) {
|
|
|
|
/* Bind a ephemeral port */
|
2007-07-24 20:06:02 +00:00
|
|
|
error = sctp_inpcb_bind(so, NULL, NULL, p);
|
2006-11-03 15:23:16 +00:00
|
|
|
if (error) {
|
|
|
|
goto out_now;
|
|
|
|
}
|
|
|
|
}
|
2018-07-19 20:16:33 +00:00
|
|
|
|
2007-03-19 06:53:02 +00:00
|
|
|
/* FIX ME: do we want to pass in a vrf on the connect call? */
|
|
|
|
vrf_id = inp->def_vrf_id;
|
|
|
|
|
2006-11-03 15:23:16 +00:00
|
|
|
/* We are GOOD to go */
|
2021-06-27 18:14:48 +00:00
|
|
|
stcb = sctp_aloc_assoc(inp, sa, &error, 0, 0, vrf_id,
|
2015-12-06 16:17:57 +00:00
|
|
|
inp->sctp_ep.pre_open_stream_count,
|
2016-05-01 21:48:55 +00:00
|
|
|
inp->sctp_ep.port,
|
2019-07-14 12:04:39 +00:00
|
|
|
(struct thread *)p,
|
|
|
|
SCTP_INITIALIZE_AUTH_PARAMS);
|
2006-11-03 15:23:16 +00:00
|
|
|
if (stcb == NULL) {
|
|
|
|
/* Gak! no memory */
|
|
|
|
goto out_now;
|
|
|
|
}
|
2011-09-14 19:10:13 +00:00
|
|
|
if (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) {
|
|
|
|
stcb->sctp_ep->sctp_flags |= SCTP_PCB_FLAGS_CONNECTED;
|
|
|
|
/* Set the connected flag so we can queue data */
|
|
|
|
soisconnecting(so);
|
|
|
|
}
|
2018-08-13 13:58:45 +00:00
|
|
|
SCTP_SET_STATE(stcb, SCTP_STATE_COOKIE_WAIT);
|
2006-11-03 15:23:16 +00:00
|
|
|
/* move to second address */
|
2011-04-30 11:18:16 +00:00
|
|
|
switch (sa->sa_family) {
|
|
|
|
#ifdef INET
|
|
|
|
case AF_INET:
|
2006-11-03 15:23:16 +00:00
|
|
|
sa = (struct sockaddr *)((caddr_t)sa + sizeof(struct sockaddr_in));
|
2011-04-30 11:18:16 +00:00
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
#ifdef INET6
|
|
|
|
case AF_INET6:
|
2006-11-03 15:23:16 +00:00
|
|
|
sa = (struct sockaddr *)((caddr_t)sa + sizeof(struct sockaddr_in6));
|
2011-04-30 11:18:16 +00:00
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2007-05-28 11:17:24 +00:00
|
|
|
error = 0;
|
2011-06-15 23:50:27 +00:00
|
|
|
sctp_connectx_helper_add(stcb, sa, (totaddr - 1), &error);
|
2007-03-15 11:27:14 +00:00
|
|
|
/* Fill in the return id */
|
2007-05-28 11:17:24 +00:00
|
|
|
if (error) {
|
|
|
|
goto out_now;
|
|
|
|
}
|
2018-07-19 20:11:14 +00:00
|
|
|
a_id = (sctp_assoc_t *)optval;
|
2007-03-15 11:27:14 +00:00
|
|
|
*a_id = sctp_get_associd(stcb);
|
2006-11-03 15:23:16 +00:00
|
|
|
|
|
|
|
if (delay) {
|
|
|
|
/* doing delayed connection */
|
|
|
|
stcb->asoc.delayed_connection = 1;
|
|
|
|
sctp_timer_start(SCTP_TIMER_TYPE_INIT, inp, stcb, stcb->asoc.primary_destination);
|
|
|
|
} else {
|
2007-05-08 14:32:53 +00:00
|
|
|
(void)SCTP_GETTIME_TIMEVAL(&stcb->asoc.time_entered);
|
2007-09-08 11:35:11 +00:00
|
|
|
sctp_send_initiate(inp, stcb, SCTP_SO_LOCKED);
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
out_now:
|
2007-05-17 12:16:24 +00:00
|
|
|
if (creat_lock_on) {
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_ASOC_CREATE_UNLOCK(inp);
|
2007-05-17 12:16:24 +00:00
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_INP_DECR_REF(inp);
|
2011-12-27 10:16:24 +00:00
|
|
|
return (error);
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
|
2007-05-09 13:30:06 +00:00
|
|
|
#define SCTP_FIND_STCB(inp, stcb, assoc_id) { \
|
2007-05-17 12:16:24 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||\
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL)) { \
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_INP_RLOCK(inp); \
|
|
|
|
stcb = LIST_FIRST(&inp->sctp_asoc_list); \
|
2007-05-17 12:16:24 +00:00
|
|
|
if (stcb) { \
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_TCB_LOCK(stcb); \
|
2016-12-06 10:21:25 +00:00
|
|
|
} \
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_INP_RUNLOCK(inp); \
|
2011-06-15 23:50:27 +00:00
|
|
|
} else if (assoc_id > SCTP_ALL_ASSOC) { \
|
2007-02-12 23:24:31 +00:00
|
|
|
stcb = sctp_findassociation_ep_asocid(inp, assoc_id, 1); \
|
|
|
|
if (stcb == NULL) { \
|
2016-12-06 10:21:25 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOENT); \
|
2007-02-12 23:24:31 +00:00
|
|
|
error = ENOENT; \
|
|
|
|
break; \
|
|
|
|
} \
|
|
|
|
} else { \
|
|
|
|
stcb = NULL; \
|
2016-12-06 10:21:25 +00:00
|
|
|
} \
|
|
|
|
}
|
2007-02-12 23:24:31 +00:00
|
|
|
|
2012-04-19 15:30:15 +00:00
|
|
|
#define SCTP_CHECK_AND_CAST(destp, srcp, type, size) {\
|
2007-02-12 23:24:31 +00:00
|
|
|
if (size < sizeof(type)) { \
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL); \
|
2007-02-12 23:24:31 +00:00
|
|
|
error = EINVAL; \
|
|
|
|
break; \
|
|
|
|
} else { \
|
|
|
|
destp = (type *)srcp; \
|
2007-05-09 13:30:06 +00:00
|
|
|
} \
|
2016-12-06 10:21:25 +00:00
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
|
|
|
|
static int
|
2007-02-12 23:24:31 +00:00
|
|
|
sctp_getopt(struct socket *so, int optname, void *optval, size_t *optsize,
|
|
|
|
void *p)
|
2006-11-03 15:23:16 +00:00
|
|
|
{
|
2007-08-24 00:53:53 +00:00
|
|
|
struct sctp_inpcb *inp = NULL;
|
2007-02-12 23:24:31 +00:00
|
|
|
int error, val = 0;
|
2006-11-03 15:23:16 +00:00
|
|
|
struct sctp_tcb *stcb = NULL;
|
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
if (optval == NULL) {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2007-02-12 23:24:31 +00:00
|
|
|
return (EINVAL);
|
|
|
|
}
|
2018-07-19 20:16:33 +00:00
|
|
|
|
2006-11-03 15:23:16 +00:00
|
|
|
inp = (struct sctp_inpcb *)so->so_pcb;
|
2012-03-15 14:22:05 +00:00
|
|
|
if (inp == NULL) {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2006-11-03 15:23:16 +00:00
|
|
|
return EINVAL;
|
2007-08-24 00:53:53 +00:00
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
error = 0;
|
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
switch (optname) {
|
2006-11-03 15:23:16 +00:00
|
|
|
case SCTP_NODELAY:
|
|
|
|
case SCTP_AUTOCLOSE:
|
|
|
|
case SCTP_EXPLICIT_EOR:
|
|
|
|
case SCTP_AUTO_ASCONF:
|
|
|
|
case SCTP_DISABLE_FRAGMENTS:
|
|
|
|
case SCTP_I_WANT_MAPPED_V4_ADDR:
|
|
|
|
case SCTP_USE_EXT_RCVINFO:
|
|
|
|
SCTP_INP_RLOCK(inp);
|
2007-02-12 23:24:31 +00:00
|
|
|
switch (optname) {
|
2006-11-03 15:23:16 +00:00
|
|
|
case SCTP_DISABLE_FRAGMENTS:
|
2007-02-12 23:24:31 +00:00
|
|
|
val = sctp_is_feature_on(inp, SCTP_PCB_FLAGS_NO_FRAGMENT);
|
2006-11-03 15:23:16 +00:00
|
|
|
break;
|
|
|
|
case SCTP_I_WANT_MAPPED_V4_ADDR:
|
2007-02-12 23:24:31 +00:00
|
|
|
val = sctp_is_feature_on(inp, SCTP_PCB_FLAGS_NEEDS_MAPPED_V4);
|
2006-11-03 15:23:16 +00:00
|
|
|
break;
|
|
|
|
case SCTP_AUTO_ASCONF:
|
2007-08-24 00:53:53 +00:00
|
|
|
if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) {
|
|
|
|
/* only valid for bound all sockets */
|
|
|
|
val = sctp_is_feature_on(inp, SCTP_PCB_FLAGS_AUTO_ASCONF);
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
goto flags_out;
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
break;
|
|
|
|
case SCTP_EXPLICIT_EOR:
|
2007-02-12 23:24:31 +00:00
|
|
|
val = sctp_is_feature_on(inp, SCTP_PCB_FLAGS_EXPLICIT_EOR);
|
2006-11-03 15:23:16 +00:00
|
|
|
break;
|
|
|
|
case SCTP_NODELAY:
|
2007-02-12 23:24:31 +00:00
|
|
|
val = sctp_is_feature_on(inp, SCTP_PCB_FLAGS_NODELAY);
|
2006-11-03 15:23:16 +00:00
|
|
|
break;
|
|
|
|
case SCTP_USE_EXT_RCVINFO:
|
2007-02-12 23:24:31 +00:00
|
|
|
val = sctp_is_feature_on(inp, SCTP_PCB_FLAGS_EXT_RCVINFO);
|
2006-11-03 15:23:16 +00:00
|
|
|
break;
|
|
|
|
case SCTP_AUTOCLOSE:
|
|
|
|
if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_AUTOCLOSE))
|
2020-03-28 20:25:45 +00:00
|
|
|
val = sctp_ticks_to_secs(inp->sctp_ep.auto_close_time);
|
2006-11-03 15:23:16 +00:00
|
|
|
else
|
2007-02-12 23:24:31 +00:00
|
|
|
val = 0;
|
2006-11-03 15:23:16 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOPROTOOPT);
|
2006-11-03 15:23:16 +00:00
|
|
|
error = ENOPROTOOPT;
|
|
|
|
} /* end switch (sopt->sopt_name) */
|
2007-02-12 23:24:31 +00:00
|
|
|
if (*optsize < sizeof(val)) {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2006-11-03 15:23:16 +00:00
|
|
|
error = EINVAL;
|
|
|
|
}
|
2007-08-24 00:53:53 +00:00
|
|
|
flags_out:
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
if (error == 0) {
|
|
|
|
/* return the option value */
|
2007-02-12 23:24:31 +00:00
|
|
|
*(int *)optval = val;
|
|
|
|
*optsize = sizeof(val);
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
break;
|
2007-05-29 09:29:03 +00:00
|
|
|
case SCTP_GET_PACKET_LOG:
|
|
|
|
{
|
|
|
|
#ifdef SCTP_PACKET_LOGGING
|
|
|
|
uint8_t *target;
|
|
|
|
int ret;
|
2007-03-15 11:27:14 +00:00
|
|
|
|
2007-05-29 09:29:03 +00:00
|
|
|
SCTP_CHECK_AND_CAST(target, optval, uint8_t, *optsize);
|
|
|
|
ret = sctp_copy_out_packet_log(target, (int)*optsize);
|
|
|
|
*optsize = ret;
|
|
|
|
#else
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EOPNOTSUPP);
|
2007-05-29 09:29:03 +00:00
|
|
|
error = EOPNOTSUPP;
|
|
|
|
#endif
|
|
|
|
break;
|
|
|
|
}
|
2008-07-31 11:08:30 +00:00
|
|
|
case SCTP_REUSE_PORT:
|
|
|
|
{
|
|
|
|
uint32_t *value;
|
|
|
|
|
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE)) {
|
|
|
|
/* Can't do this for a 1-m socket */
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
SCTP_CHECK_AND_CAST(value, optval, uint32_t, *optsize);
|
|
|
|
*value = sctp_is_feature_on(inp, SCTP_PCB_FLAGS_PORTREUSE);
|
|
|
|
*optsize = sizeof(uint32_t);
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2008-07-31 11:08:30 +00:00
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
case SCTP_PARTIAL_DELIVERY_POINT:
|
|
|
|
{
|
2007-02-12 23:24:31 +00:00
|
|
|
uint32_t *value;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(value, optval, uint32_t, *optsize);
|
|
|
|
*value = inp->partial_delivery_point;
|
|
|
|
*optsize = sizeof(uint32_t);
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
case SCTP_FRAGMENT_INTERLEAVE:
|
|
|
|
{
|
2007-02-12 23:24:31 +00:00
|
|
|
uint32_t *value;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(value, optval, uint32_t, *optsize);
|
2007-04-22 11:06:27 +00:00
|
|
|
if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_FRAG_INTERLEAVE)) {
|
|
|
|
if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_INTERLEAVE_STRMS)) {
|
|
|
|
*value = SCTP_FRAG_LEVEL_2;
|
|
|
|
} else {
|
|
|
|
*value = SCTP_FRAG_LEVEL_1;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
*value = SCTP_FRAG_LEVEL_0;
|
|
|
|
}
|
2007-02-12 23:24:31 +00:00
|
|
|
*optsize = sizeof(uint32_t);
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2016-04-07 09:10:34 +00:00
|
|
|
case SCTP_INTERLEAVING_SUPPORTED:
|
|
|
|
{
|
|
|
|
struct sctp_assoc_value *av;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, av->assoc_id);
|
|
|
|
|
|
|
|
if (stcb) {
|
|
|
|
av->assoc_value = stcb->asoc.idata_supported;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(av->assoc_id == SCTP_FUTURE_ASSOC))) {
|
2016-04-07 09:10:34 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
if (inp->idata_supported) {
|
|
|
|
av->assoc_value = 1;
|
|
|
|
} else {
|
|
|
|
av->assoc_value = 0;
|
|
|
|
}
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (error == 0) {
|
|
|
|
*optsize = sizeof(struct sctp_assoc_value);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
case SCTP_CMT_ON_OFF:
|
|
|
|
{
|
2007-02-12 23:24:31 +00:00
|
|
|
struct sctp_assoc_value *av;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, *optsize);
|
2010-08-28 17:59:51 +00:00
|
|
|
SCTP_FIND_STCB(inp, stcb, av->assoc_id);
|
|
|
|
if (stcb) {
|
|
|
|
av->assoc_value = stcb->asoc.sctp_cmt_on_off;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
2008-12-06 13:19:54 +00:00
|
|
|
} else {
|
2011-08-16 21:04:18 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(av->assoc_id == SCTP_FUTURE_ASSOC))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
av->assoc_value = inp->sctp_cmt_on_off;
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (error == 0) {
|
|
|
|
*optsize = sizeof(struct sctp_assoc_value);
|
2008-12-06 13:19:54 +00:00
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2008-12-06 13:19:54 +00:00
|
|
|
}
|
2007-07-14 09:36:28 +00:00
|
|
|
case SCTP_PLUGGABLE_CC:
|
|
|
|
{
|
|
|
|
struct sctp_assoc_value *av;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, av->assoc_id);
|
|
|
|
if (stcb) {
|
|
|
|
av->assoc_value = stcb->asoc.congestion_control_module;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
2011-08-16 21:04:18 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(av->assoc_id == SCTP_FUTURE_ASSOC))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
av->assoc_value = inp->sctp_ep.sctp_default_cc_module;
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (error == 0) {
|
|
|
|
*optsize = sizeof(struct sctp_assoc_value);
|
2007-07-14 09:36:28 +00:00
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2007-07-14 09:36:28 +00:00
|
|
|
}
|
2011-02-26 15:23:46 +00:00
|
|
|
case SCTP_CC_OPTION:
|
|
|
|
{
|
|
|
|
struct sctp_cc_option *cc_opt;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(cc_opt, optval, struct sctp_cc_option, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, cc_opt->aid_value.assoc_id);
|
|
|
|
if (stcb == NULL) {
|
|
|
|
error = EINVAL;
|
|
|
|
} else {
|
|
|
|
if (stcb->asoc.cc_functions.sctp_cwnd_socket_option == NULL) {
|
|
|
|
error = ENOTSUP;
|
|
|
|
} else {
|
2011-06-15 23:50:27 +00:00
|
|
|
error = (*stcb->asoc.cc_functions.sctp_cwnd_socket_option) (stcb, 0, cc_opt);
|
|
|
|
*optsize = sizeof(struct sctp_cc_option);
|
2011-02-26 15:23:46 +00:00
|
|
|
}
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2011-02-26 15:23:46 +00:00
|
|
|
}
|
2011-01-23 19:36:28 +00:00
|
|
|
case SCTP_PLUGGABLE_SS:
|
|
|
|
{
|
|
|
|
struct sctp_assoc_value *av;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, av->assoc_id);
|
|
|
|
if (stcb) {
|
|
|
|
av->assoc_value = stcb->asoc.stream_scheduling_module;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
2011-08-16 21:04:18 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(av->assoc_id == SCTP_FUTURE_ASSOC))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
av->assoc_value = inp->sctp_ep.sctp_default_ss_module;
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
2011-01-23 19:36:28 +00:00
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
if (error == 0) {
|
|
|
|
*optsize = sizeof(struct sctp_assoc_value);
|
|
|
|
}
|
|
|
|
break;
|
2011-01-23 19:36:28 +00:00
|
|
|
}
|
|
|
|
case SCTP_SS_VALUE:
|
|
|
|
{
|
|
|
|
struct sctp_stream_value *av;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(av, optval, struct sctp_stream_value, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, av->assoc_id);
|
|
|
|
if (stcb) {
|
2015-01-27 19:35:36 +00:00
|
|
|
if ((av->stream_id >= stcb->asoc.streamoutcnt) ||
|
|
|
|
(stcb->asoc.ss_functions.sctp_ss_get_value(stcb, &stcb->asoc, &stcb->asoc.strmout[av->stream_id],
|
|
|
|
&av->stream_value) < 0)) {
|
2011-01-23 19:36:28 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
} else {
|
2011-06-15 23:50:27 +00:00
|
|
|
*optsize = sizeof(struct sctp_stream_value);
|
2011-01-23 19:36:28 +00:00
|
|
|
}
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
2016-12-26 11:06:41 +00:00
|
|
|
/*
|
|
|
|
* Can't get stream value without
|
|
|
|
* association
|
|
|
|
*/
|
2011-01-23 19:36:28 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2011-01-23 19:36:28 +00:00
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
case SCTP_GET_ADDR_LEN:
|
|
|
|
{
|
|
|
|
struct sctp_assoc_value *av;
|
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, *optsize);
|
2006-11-03 15:23:16 +00:00
|
|
|
error = EINVAL;
|
2007-03-15 11:27:14 +00:00
|
|
|
#ifdef INET
|
2006-11-03 15:23:16 +00:00
|
|
|
if (av->assoc_value == AF_INET) {
|
|
|
|
av->assoc_value = sizeof(struct sockaddr_in);
|
|
|
|
error = 0;
|
|
|
|
}
|
|
|
|
#endif
|
2007-03-15 11:27:14 +00:00
|
|
|
#ifdef INET6
|
2006-11-03 15:23:16 +00:00
|
|
|
if (av->assoc_value == AF_INET6) {
|
|
|
|
av->assoc_value = sizeof(struct sockaddr_in6);
|
|
|
|
error = 0;
|
|
|
|
}
|
|
|
|
#endif
|
2007-09-08 17:48:46 +00:00
|
|
|
if (error) {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
|
2011-06-15 23:50:27 +00:00
|
|
|
} else {
|
|
|
|
*optsize = sizeof(struct sctp_assoc_value);
|
2007-09-08 17:48:46 +00:00
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2007-05-17 12:16:24 +00:00
|
|
|
case SCTP_GET_ASSOC_NUMBER:
|
2006-11-03 15:23:16 +00:00
|
|
|
{
|
2007-05-17 12:16:24 +00:00
|
|
|
uint32_t *value, cnt;
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2007-05-17 12:16:24 +00:00
|
|
|
SCTP_CHECK_AND_CAST(value, optval, uint32_t, *optsize);
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
2016-01-14 11:25:28 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL)) {
|
|
|
|
/* Can't do this for a 1-1 socket */
|
|
|
|
error = EINVAL;
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
cnt = 0;
|
2007-05-17 12:16:24 +00:00
|
|
|
LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
|
|
|
|
cnt++;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2007-05-17 12:16:24 +00:00
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
*value = cnt;
|
|
|
|
*optsize = sizeof(uint32_t);
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2007-05-17 12:16:24 +00:00
|
|
|
}
|
|
|
|
case SCTP_GET_ASSOC_ID_LIST:
|
|
|
|
{
|
|
|
|
struct sctp_assoc_ids *ids;
|
2016-03-27 10:04:25 +00:00
|
|
|
uint32_t at;
|
|
|
|
size_t limit;
|
2007-05-17 12:16:24 +00:00
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(ids, optval, struct sctp_assoc_ids, *optsize);
|
2016-01-14 11:25:28 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL)) {
|
|
|
|
/* Can't do this for a 1-1 socket */
|
|
|
|
error = EINVAL;
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
break;
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
at = 0;
|
2008-12-06 13:19:54 +00:00
|
|
|
limit = (*optsize - sizeof(uint32_t)) / sizeof(sctp_assoc_t);
|
2007-05-17 12:16:24 +00:00
|
|
|
LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
|
|
|
|
if (at < limit) {
|
|
|
|
ids->gaids_assoc_id[at++] = sctp_get_associd(stcb);
|
2016-03-27 10:04:25 +00:00
|
|
|
if (at == 0) {
|
|
|
|
error = EINVAL;
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
|
|
|
|
break;
|
|
|
|
}
|
2007-05-17 12:16:24 +00:00
|
|
|
} else {
|
|
|
|
error = EINVAL;
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
|
2006-11-03 15:23:16 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
2011-06-15 23:50:27 +00:00
|
|
|
if (error == 0) {
|
|
|
|
ids->gaids_number_of_ids = at;
|
|
|
|
*optsize = ((at * sizeof(sctp_assoc_t)) + sizeof(uint32_t));
|
|
|
|
}
|
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
case SCTP_CONTEXT:
|
|
|
|
{
|
|
|
|
struct sctp_assoc_value *av;
|
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, av->assoc_id);
|
|
|
|
|
|
|
|
if (stcb) {
|
|
|
|
av->assoc_value = stcb->asoc.context;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
2006-11-03 15:23:16 +00:00
|
|
|
} else {
|
2011-08-16 21:04:18 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(av->assoc_id == SCTP_FUTURE_ASSOC))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
av->assoc_value = inp->sctp_context;
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (error == 0) {
|
|
|
|
*optsize = sizeof(struct sctp_assoc_value);
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2007-03-15 11:27:14 +00:00
|
|
|
case SCTP_VRF_ID:
|
|
|
|
{
|
2007-05-28 11:17:24 +00:00
|
|
|
uint32_t *default_vrfid;
|
2007-03-15 11:27:14 +00:00
|
|
|
|
2007-05-28 11:17:24 +00:00
|
|
|
SCTP_CHECK_AND_CAST(default_vrfid, optval, uint32_t, *optsize);
|
|
|
|
*default_vrfid = inp->def_vrf_id;
|
2011-06-15 23:50:27 +00:00
|
|
|
*optsize = sizeof(uint32_t);
|
2007-03-15 11:27:14 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case SCTP_GET_ASOC_VRF:
|
|
|
|
{
|
|
|
|
struct sctp_assoc_value *id;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(id, optval, struct sctp_assoc_value, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, id->assoc_id);
|
|
|
|
if (stcb == NULL) {
|
|
|
|
error = EINVAL;
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
|
2011-06-15 23:50:27 +00:00
|
|
|
} else {
|
|
|
|
id->assoc_value = stcb->asoc.vrf_id;
|
2017-09-09 20:44:56 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
2011-06-15 23:50:27 +00:00
|
|
|
*optsize = sizeof(struct sctp_assoc_value);
|
2007-03-15 11:27:14 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case SCTP_GET_VRF_IDS:
|
|
|
|
{
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EOPNOTSUPP);
|
2007-03-15 11:27:14 +00:00
|
|
|
error = EOPNOTSUPP;
|
|
|
|
break;
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
case SCTP_GET_NONCE_VALUES:
|
|
|
|
{
|
|
|
|
struct sctp_get_nonce_values *gnv;
|
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_CHECK_AND_CAST(gnv, optval, struct sctp_get_nonce_values, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, gnv->gn_assoc_id);
|
|
|
|
|
|
|
|
if (stcb) {
|
2006-11-03 15:23:16 +00:00
|
|
|
gnv->gn_peers_tag = stcb->asoc.peer_vtag;
|
|
|
|
gnv->gn_local_tag = stcb->asoc.my_vtag;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
2011-06-15 23:50:27 +00:00
|
|
|
*optsize = sizeof(struct sctp_get_nonce_values);
|
2007-02-12 23:24:31 +00:00
|
|
|
} else {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOTCONN);
|
2007-02-12 23:24:31 +00:00
|
|
|
error = ENOTCONN;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2007-05-28 11:17:24 +00:00
|
|
|
case SCTP_DELAYED_SACK:
|
2006-11-03 15:23:16 +00:00
|
|
|
{
|
2007-05-28 11:17:24 +00:00
|
|
|
struct sctp_sack_info *sack;
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2007-05-28 11:17:24 +00:00
|
|
|
SCTP_CHECK_AND_CAST(sack, optval, struct sctp_sack_info, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, sack->sack_assoc_id);
|
2007-02-12 23:24:31 +00:00
|
|
|
if (stcb) {
|
2007-05-28 11:17:24 +00:00
|
|
|
sack->sack_delay = stcb->asoc.delayed_ack;
|
|
|
|
sack->sack_freq = stcb->asoc.sack_freq;
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
2011-08-16 21:04:18 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(sack->sack_assoc_id == SCTP_FUTURE_ASSOC))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
2020-03-28 20:25:45 +00:00
|
|
|
sack->sack_delay = sctp_ticks_to_msecs(inp->sctp_ep.sctp_timeoutticks[SCTP_TIMER_RECV]);
|
2011-06-15 23:50:27 +00:00
|
|
|
sack->sack_freq = inp->sctp_ep.sctp_sack_freq;
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
if (error == 0) {
|
|
|
|
*optsize = sizeof(struct sctp_sack_info);
|
|
|
|
}
|
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
case SCTP_GET_SNDBUF_USE:
|
2007-02-12 23:24:31 +00:00
|
|
|
{
|
2006-11-03 15:23:16 +00:00
|
|
|
struct sctp_sockstat *ss;
|
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_CHECK_AND_CAST(ss, optval, struct sctp_sockstat, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, ss->ss_assoc_id);
|
|
|
|
|
|
|
|
if (stcb) {
|
|
|
|
ss->ss_total_sndbuf = stcb->asoc.total_output_queue_size;
|
|
|
|
ss->ss_total_recv_buf = (stcb->asoc.size_on_reasm_queue +
|
|
|
|
stcb->asoc.size_on_all_streams);
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
2011-06-15 23:50:27 +00:00
|
|
|
*optsize = sizeof(struct sctp_sockstat);
|
2007-02-12 23:24:31 +00:00
|
|
|
} else {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOTCONN);
|
2007-02-12 23:24:31 +00:00
|
|
|
error = ENOTCONN;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2007-05-28 11:17:24 +00:00
|
|
|
case SCTP_MAX_BURST:
|
2006-11-03 15:23:16 +00:00
|
|
|
{
|
2011-01-26 19:55:54 +00:00
|
|
|
struct sctp_assoc_value *av;
|
2007-02-12 23:24:31 +00:00
|
|
|
|
2011-01-26 19:55:54 +00:00
|
|
|
SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, av->assoc_id);
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2011-01-26 19:55:54 +00:00
|
|
|
if (stcb) {
|
|
|
|
av->assoc_value = stcb->asoc.max_burst;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
2011-01-26 19:49:03 +00:00
|
|
|
} else {
|
2011-08-16 21:04:18 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(av->assoc_id == SCTP_FUTURE_ASSOC))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
av->assoc_value = inp->sctp_ep.max_burst;
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
2011-01-26 19:49:03 +00:00
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
if (error == 0) {
|
|
|
|
*optsize = sizeof(struct sctp_assoc_value);
|
|
|
|
}
|
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
case SCTP_MAXSEG:
|
|
|
|
{
|
2007-03-15 11:27:14 +00:00
|
|
|
struct sctp_assoc_value *av;
|
2006-11-03 15:23:16 +00:00
|
|
|
int ovh;
|
|
|
|
|
2007-03-15 11:27:14 +00:00
|
|
|
SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, *optsize);
|
2007-05-28 11:17:24 +00:00
|
|
|
SCTP_FIND_STCB(inp, stcb, av->assoc_id);
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2007-03-15 11:27:14 +00:00
|
|
|
if (stcb) {
|
|
|
|
av->assoc_value = sctp_get_frag_point(stcb, &stcb->asoc);
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
2006-11-03 15:23:16 +00:00
|
|
|
} else {
|
2011-08-16 21:04:18 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(av->assoc_id == SCTP_FUTURE_ASSOC))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) {
|
|
|
|
ovh = SCTP_MED_OVERHEAD;
|
|
|
|
} else {
|
|
|
|
ovh = SCTP_MED_V4_OVERHEAD;
|
|
|
|
}
|
|
|
|
if (inp->sctp_frag_point >= SCTP_DEFAULT_MAXSEGMENT)
|
|
|
|
av->assoc_value = 0;
|
|
|
|
else
|
|
|
|
av->assoc_value = inp->sctp_frag_point - ovh;
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
2007-03-15 11:27:14 +00:00
|
|
|
} else {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
2007-03-15 11:27:14 +00:00
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
if (error == 0) {
|
|
|
|
*optsize = sizeof(struct sctp_assoc_value);
|
|
|
|
}
|
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
case SCTP_GET_STAT_LOG:
|
2007-03-15 11:27:14 +00:00
|
|
|
error = sctp_fill_stat_log(optval, optsize);
|
2006-11-03 15:23:16 +00:00
|
|
|
break;
|
|
|
|
case SCTP_EVENTS:
|
|
|
|
{
|
|
|
|
struct sctp_event_subscribe *events;
|
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_CHECK_AND_CAST(events, optval, struct sctp_event_subscribe, *optsize);
|
2011-06-15 23:50:27 +00:00
|
|
|
memset(events, 0, sizeof(struct sctp_event_subscribe));
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_RECVDATAIOEVNT))
|
|
|
|
events->sctp_data_io_event = 1;
|
|
|
|
|
|
|
|
if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_RECVASSOCEVNT))
|
|
|
|
events->sctp_association_event = 1;
|
|
|
|
|
|
|
|
if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_RECVPADDREVNT))
|
|
|
|
events->sctp_address_event = 1;
|
|
|
|
|
|
|
|
if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_RECVSENDFAILEVNT))
|
|
|
|
events->sctp_send_failure_event = 1;
|
|
|
|
|
|
|
|
if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_RECVPEERERR))
|
|
|
|
events->sctp_peer_error_event = 1;
|
|
|
|
|
|
|
|
if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_RECVSHUTDOWNEVNT))
|
|
|
|
events->sctp_shutdown_event = 1;
|
|
|
|
|
|
|
|
if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_PDAPIEVNT))
|
|
|
|
events->sctp_partial_delivery_event = 1;
|
|
|
|
|
|
|
|
if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_ADAPTATIONEVNT))
|
|
|
|
events->sctp_adaptation_layer_event = 1;
|
|
|
|
|
|
|
|
if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_AUTHEVNT))
|
|
|
|
events->sctp_authentication_event = 1;
|
|
|
|
|
2008-12-06 13:19:54 +00:00
|
|
|
if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_DRYEVNT))
|
|
|
|
events->sctp_sender_dry_event = 1;
|
|
|
|
|
2006-11-03 15:23:16 +00:00
|
|
|
if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_STREAM_RESETEVNT))
|
2010-01-17 19:35:38 +00:00
|
|
|
events->sctp_stream_reset_event = 1;
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_INP_RUNLOCK(inp);
|
2007-02-12 23:24:31 +00:00
|
|
|
*optsize = sizeof(struct sctp_event_subscribe);
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
case SCTP_ADAPTATION_LAYER:
|
2007-02-12 23:24:31 +00:00
|
|
|
{
|
|
|
|
uint32_t *value;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(value, optval, uint32_t, *optsize);
|
|
|
|
|
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
*value = inp->sctp_ep.adaptation_layer_indicator;
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
*optsize = sizeof(uint32_t);
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
case SCTP_SET_INITIAL_DBG_SEQ:
|
2007-02-12 23:24:31 +00:00
|
|
|
{
|
|
|
|
uint32_t *value;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(value, optval, uint32_t, *optsize);
|
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
*value = inp->sctp_ep.initial_sequence_debug;
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
*optsize = sizeof(uint32_t);
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
case SCTP_GET_LOCAL_ADDR_SIZE:
|
2007-02-12 23:24:31 +00:00
|
|
|
{
|
|
|
|
uint32_t *value;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(value, optval, uint32_t, *optsize);
|
|
|
|
SCTP_INP_RLOCK(inp);
|
2007-03-31 11:47:30 +00:00
|
|
|
*value = sctp_count_max_addresses(inp);
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
*optsize = sizeof(uint32_t);
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
case SCTP_GET_REMOTE_ADDR_SIZE:
|
|
|
|
{
|
2007-02-12 23:24:31 +00:00
|
|
|
uint32_t *value;
|
|
|
|
size_t size;
|
2006-11-03 15:23:16 +00:00
|
|
|
struct sctp_nets *net;
|
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_CHECK_AND_CAST(value, optval, uint32_t, *optsize);
|
|
|
|
/* FIXME MT: change to sctp_assoc_value? */
|
2018-07-19 20:11:14 +00:00
|
|
|
SCTP_FIND_STCB(inp, stcb, (sctp_assoc_t)*value);
|
2007-02-12 23:24:31 +00:00
|
|
|
|
|
|
|
if (stcb) {
|
|
|
|
size = 0;
|
|
|
|
/* Count the sizes */
|
|
|
|
TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
|
2014-12-06 20:00:08 +00:00
|
|
|
switch (net->ro._l_addr.sa.sa_family) {
|
2011-04-30 11:18:16 +00:00
|
|
|
#ifdef INET
|
2014-12-06 20:00:08 +00:00
|
|
|
case AF_INET:
|
|
|
|
#ifdef INET6
|
|
|
|
if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_NEEDS_MAPPED_V4)) {
|
|
|
|
size += sizeof(struct sockaddr_in6);
|
|
|
|
} else {
|
2011-04-30 11:18:16 +00:00
|
|
|
size += sizeof(struct sockaddr_in);
|
2014-12-06 20:00:08 +00:00
|
|
|
}
|
|
|
|
#else
|
|
|
|
size += sizeof(struct sockaddr_in);
|
|
|
|
#endif
|
|
|
|
break;
|
2011-04-30 11:18:16 +00:00
|
|
|
#endif
|
|
|
|
#ifdef INET6
|
2014-12-06 20:00:08 +00:00
|
|
|
case AF_INET6:
|
|
|
|
size += sizeof(struct sockaddr_in6);
|
|
|
|
break;
|
2011-04-30 11:18:16 +00:00
|
|
|
#endif
|
2014-12-06 20:00:08 +00:00
|
|
|
default:
|
|
|
|
break;
|
2007-02-12 23:24:31 +00:00
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
2018-07-19 20:11:14 +00:00
|
|
|
*value = (uint32_t)size;
|
2011-06-15 23:50:27 +00:00
|
|
|
*optsize = sizeof(uint32_t);
|
2007-02-12 23:24:31 +00:00
|
|
|
} else {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOTCONN);
|
2007-02-12 23:24:31 +00:00
|
|
|
error = ENOTCONN;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
case SCTP_GET_PEER_ADDRESSES:
|
|
|
|
/*
|
|
|
|
* Get the address information, an array is passed in to
|
|
|
|
* fill up we pack it.
|
|
|
|
*/
|
|
|
|
{
|
2007-02-12 23:24:31 +00:00
|
|
|
size_t cpsz, left;
|
2020-06-23 23:05:05 +00:00
|
|
|
struct sockaddr *addr;
|
2006-11-03 15:23:16 +00:00
|
|
|
struct sctp_nets *net;
|
|
|
|
struct sctp_getaddresses *saddr;
|
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_CHECK_AND_CAST(saddr, optval, struct sctp_getaddresses, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, saddr->sget_assoc_id);
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
if (stcb) {
|
2020-06-21 23:12:56 +00:00
|
|
|
left = *optsize - offsetof(struct sctp_getaddresses, addr);
|
|
|
|
*optsize = offsetof(struct sctp_getaddresses, addr);
|
2020-06-23 23:05:05 +00:00
|
|
|
addr = &saddr->addr[0].sa;
|
2007-02-12 23:24:31 +00:00
|
|
|
|
|
|
|
TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
|
2014-12-06 20:00:08 +00:00
|
|
|
switch (net->ro._l_addr.sa.sa_family) {
|
2011-04-30 11:18:16 +00:00
|
|
|
#ifdef INET
|
2014-12-06 20:00:08 +00:00
|
|
|
case AF_INET:
|
|
|
|
#ifdef INET6
|
|
|
|
if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_NEEDS_MAPPED_V4)) {
|
|
|
|
cpsz = sizeof(struct sockaddr_in6);
|
|
|
|
} else {
|
2011-04-30 11:18:16 +00:00
|
|
|
cpsz = sizeof(struct sockaddr_in);
|
2014-12-06 20:00:08 +00:00
|
|
|
}
|
|
|
|
#else
|
|
|
|
cpsz = sizeof(struct sockaddr_in);
|
|
|
|
#endif
|
|
|
|
break;
|
2011-04-30 11:18:16 +00:00
|
|
|
#endif
|
|
|
|
#ifdef INET6
|
2014-12-06 20:00:08 +00:00
|
|
|
case AF_INET6:
|
|
|
|
cpsz = sizeof(struct sockaddr_in6);
|
|
|
|
break;
|
2011-04-30 11:18:16 +00:00
|
|
|
#endif
|
2014-12-06 20:00:08 +00:00
|
|
|
default:
|
|
|
|
cpsz = 0;
|
|
|
|
break;
|
2011-04-30 11:18:16 +00:00
|
|
|
}
|
|
|
|
if (cpsz == 0) {
|
2007-02-12 23:24:31 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (left < cpsz) {
|
|
|
|
/* not enough room. */
|
|
|
|
break;
|
|
|
|
}
|
2011-04-30 11:18:16 +00:00
|
|
|
#if defined(INET) && defined(INET6)
|
2008-04-16 17:24:18 +00:00
|
|
|
if ((sctp_is_feature_on(inp, SCTP_PCB_FLAGS_NEEDS_MAPPED_V4)) &&
|
2014-12-06 20:00:08 +00:00
|
|
|
(net->ro._l_addr.sa.sa_family == AF_INET)) {
|
2007-02-12 23:24:31 +00:00
|
|
|
/* Must map the address */
|
2014-12-06 20:00:08 +00:00
|
|
|
in6_sin_2_v4mapsin6(&net->ro._l_addr.sin,
|
2020-08-18 19:25:03 +00:00
|
|
|
(struct sockaddr_in6 *)addr);
|
2007-02-12 23:24:31 +00:00
|
|
|
} else {
|
2020-06-21 23:12:56 +00:00
|
|
|
memcpy(addr, &net->ro._l_addr, cpsz);
|
2007-02-12 23:24:31 +00:00
|
|
|
}
|
2014-12-06 20:00:08 +00:00
|
|
|
#else
|
2020-06-21 23:12:56 +00:00
|
|
|
memcpy(addr, &net->ro._l_addr, cpsz);
|
2008-04-16 17:24:18 +00:00
|
|
|
#endif
|
2020-06-23 23:05:05 +00:00
|
|
|
((struct sockaddr_in *)addr)->sin_port = stcb->rport;
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2020-06-23 23:05:05 +00:00
|
|
|
addr = (struct sockaddr *)((caddr_t)addr + cpsz);
|
2007-02-12 23:24:31 +00:00
|
|
|
left -= cpsz;
|
|
|
|
*optsize += cpsz;
|
|
|
|
}
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOENT);
|
2007-02-12 23:24:31 +00:00
|
|
|
error = ENOENT;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
case SCTP_GET_LOCAL_ADDRESSES:
|
|
|
|
{
|
2007-02-12 23:24:31 +00:00
|
|
|
size_t limit, actual;
|
2006-11-03 15:23:16 +00:00
|
|
|
struct sctp_getaddresses *saddr;
|
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_CHECK_AND_CAST(saddr, optval, struct sctp_getaddresses, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, saddr->sget_assoc_id);
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2020-06-21 23:12:56 +00:00
|
|
|
limit = *optsize - offsetof(struct sctp_getaddresses, addr);
|
2020-06-23 23:05:05 +00:00
|
|
|
actual = sctp_fill_up_addresses(inp, stcb, limit, &saddr->addr[0].sa);
|
2007-05-17 12:16:24 +00:00
|
|
|
if (stcb) {
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
2007-05-17 12:16:24 +00:00
|
|
|
}
|
2020-06-21 23:12:56 +00:00
|
|
|
*optsize = offsetof(struct sctp_getaddresses, addr) + actual;
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
case SCTP_PEER_ADDR_PARAMS:
|
|
|
|
{
|
|
|
|
struct sctp_paddrparams *paddrp;
|
|
|
|
struct sctp_nets *net;
|
2014-12-06 20:00:08 +00:00
|
|
|
struct sockaddr *addr;
|
|
|
|
#if defined(INET) && defined(INET6)
|
|
|
|
struct sockaddr_in sin_store;
|
|
|
|
#endif
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_CHECK_AND_CAST(paddrp, optval, struct sctp_paddrparams, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, paddrp->spp_assoc_id);
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2014-12-06 20:00:08 +00:00
|
|
|
#if defined(INET) && defined(INET6)
|
|
|
|
if (paddrp->spp_address.ss_family == AF_INET6) {
|
|
|
|
struct sockaddr_in6 *sin6;
|
|
|
|
|
|
|
|
sin6 = (struct sockaddr_in6 *)&paddrp->spp_address;
|
|
|
|
if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
|
|
|
|
in6_sin6_2_sin(&sin_store, sin6);
|
|
|
|
addr = (struct sockaddr *)&sin_store;
|
|
|
|
} else {
|
|
|
|
addr = (struct sockaddr *)&paddrp->spp_address;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
addr = (struct sockaddr *)&paddrp->spp_address;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
addr = (struct sockaddr *)&paddrp->spp_address;
|
|
|
|
#endif
|
|
|
|
if (stcb != NULL) {
|
|
|
|
net = sctp_findnet(stcb, addr);
|
2007-02-12 23:24:31 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* We increment here since
|
|
|
|
* sctp_findassociation_ep_addr() wil do a
|
|
|
|
* decrement if it finds the stcb as long as
|
|
|
|
* the locked tcb (last argument) is NOT a
|
|
|
|
* TCB.. aka NULL.
|
|
|
|
*/
|
2014-12-06 20:00:08 +00:00
|
|
|
net = NULL;
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_INP_INCR_REF(inp);
|
2014-12-06 20:00:08 +00:00
|
|
|
stcb = sctp_findassociation_ep_addr(&inp, addr, &net, NULL, NULL);
|
2006-11-03 15:23:16 +00:00
|
|
|
if (stcb == NULL) {
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_INP_DECR_REF(inp);
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
}
|
2014-12-06 20:00:08 +00:00
|
|
|
if ((stcb != NULL) && (net == NULL)) {
|
2011-04-30 11:18:16 +00:00
|
|
|
#ifdef INET
|
2014-12-06 20:00:08 +00:00
|
|
|
if (addr->sa_family == AF_INET) {
|
2007-08-24 00:53:53 +00:00
|
|
|
struct sockaddr_in *sin;
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2014-12-06 20:00:08 +00:00
|
|
|
sin = (struct sockaddr_in *)addr;
|
|
|
|
if (sin->sin_addr.s_addr != INADDR_ANY) {
|
2007-08-24 00:53:53 +00:00
|
|
|
error = EINVAL;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
|
|
|
|
break;
|
|
|
|
}
|
2011-04-30 11:18:16 +00:00
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
#ifdef INET6
|
2014-12-06 20:00:08 +00:00
|
|
|
if (addr->sa_family == AF_INET6) {
|
2007-08-24 00:53:53 +00:00
|
|
|
struct sockaddr_in6 *sin6;
|
|
|
|
|
2014-12-06 20:00:08 +00:00
|
|
|
sin6 = (struct sockaddr_in6 *)addr;
|
2007-08-24 00:53:53 +00:00
|
|
|
if (!IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
|
|
|
|
error = EINVAL;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
|
|
|
|
break;
|
|
|
|
}
|
2011-04-30 11:18:16 +00:00
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
{
|
2007-08-24 00:53:53 +00:00
|
|
|
error = EAFNOSUPPORT;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2018-07-19 20:16:33 +00:00
|
|
|
|
2014-12-06 20:00:08 +00:00
|
|
|
if (stcb != NULL) {
|
2011-08-03 20:21:00 +00:00
|
|
|
/* Applies to the specific association */
|
2006-11-03 15:23:16 +00:00
|
|
|
paddrp->spp_flags = 0;
|
2014-12-06 20:00:08 +00:00
|
|
|
if (net != NULL) {
|
2011-08-03 20:21:00 +00:00
|
|
|
paddrp->spp_hbinterval = net->heart_beat_delay;
|
2006-11-03 15:23:16 +00:00
|
|
|
paddrp->spp_pathmaxrxt = net->failure_threshold;
|
2015-05-28 20:33:28 +00:00
|
|
|
paddrp->spp_pathmtu = net->mtu;
|
|
|
|
switch (net->ro._l_addr.sa.sa_family) {
|
|
|
|
#ifdef INET
|
|
|
|
case AF_INET:
|
|
|
|
paddrp->spp_pathmtu -= SCTP_MIN_V4_OVERHEAD;
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
#ifdef INET6
|
|
|
|
case AF_INET6:
|
2017-11-01 16:32:11 +00:00
|
|
|
paddrp->spp_pathmtu -= SCTP_MIN_OVERHEAD;
|
2015-05-28 20:33:28 +00:00
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
/* get flags for HB */
|
2011-09-17 08:50:29 +00:00
|
|
|
if (net->dest_state & SCTP_ADDR_NOHB) {
|
2006-11-03 15:23:16 +00:00
|
|
|
paddrp->spp_flags |= SPP_HB_DISABLE;
|
2011-09-17 08:50:29 +00:00
|
|
|
} else {
|
2006-11-03 15:23:16 +00:00
|
|
|
paddrp->spp_flags |= SPP_HB_ENABLE;
|
2011-09-17 08:50:29 +00:00
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
/* get flags for PMTU */
|
2011-09-17 08:50:29 +00:00
|
|
|
if (net->dest_state & SCTP_ADDR_NO_PMTUD) {
|
2006-11-03 15:23:16 +00:00
|
|
|
paddrp->spp_flags |= SPP_PMTUD_DISABLE;
|
2015-06-12 18:59:29 +00:00
|
|
|
} else {
|
|
|
|
paddrp->spp_flags |= SPP_PMTUD_ENABLE;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2011-09-14 08:15:21 +00:00
|
|
|
if (net->dscp & 0x01) {
|
2011-10-11 13:24:37 +00:00
|
|
|
paddrp->spp_dscp = net->dscp & 0xfc;
|
2011-08-14 20:55:32 +00:00
|
|
|
paddrp->spp_flags |= SPP_DSCP;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2007-03-15 11:27:14 +00:00
|
|
|
#ifdef INET6
|
2011-09-14 08:15:21 +00:00
|
|
|
if ((net->ro._l_addr.sa.sa_family == AF_INET6) &&
|
|
|
|
(net->flowlabel & 0x80000000)) {
|
|
|
|
paddrp->spp_ipv6_flowlabel = net->flowlabel & 0x000fffff;
|
2006-11-03 15:23:16 +00:00
|
|
|
paddrp->spp_flags |= SPP_IPV6_FLOWLABEL;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* No destination so return default
|
|
|
|
* value
|
|
|
|
*/
|
|
|
|
paddrp->spp_pathmaxrxt = stcb->asoc.def_net_failure;
|
2017-11-03 20:46:12 +00:00
|
|
|
paddrp->spp_pathmtu = stcb->asoc.default_mtu;
|
2011-09-14 08:15:21 +00:00
|
|
|
if (stcb->asoc.default_dscp & 0x01) {
|
2011-10-11 13:24:37 +00:00
|
|
|
paddrp->spp_dscp = stcb->asoc.default_dscp & 0xfc;
|
2011-09-14 08:15:21 +00:00
|
|
|
paddrp->spp_flags |= SPP_DSCP;
|
|
|
|
}
|
2007-03-15 11:27:14 +00:00
|
|
|
#ifdef INET6
|
2011-09-14 08:15:21 +00:00
|
|
|
if (stcb->asoc.default_flowlabel & 0x80000000) {
|
|
|
|
paddrp->spp_ipv6_flowlabel = stcb->asoc.default_flowlabel & 0x000fffff;
|
|
|
|
paddrp->spp_flags |= SPP_IPV6_FLOWLABEL;
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
#endif
|
|
|
|
/* default settings should be these */
|
2011-09-17 08:50:29 +00:00
|
|
|
if (sctp_stcb_is_feature_on(inp, stcb, SCTP_PCB_FLAGS_DONOT_HEARTBEAT)) {
|
2007-05-28 11:17:24 +00:00
|
|
|
paddrp->spp_flags |= SPP_HB_DISABLE;
|
2011-08-03 20:21:00 +00:00
|
|
|
} else {
|
|
|
|
paddrp->spp_flags |= SPP_HB_ENABLE;
|
2007-05-28 11:17:24 +00:00
|
|
|
}
|
2011-09-17 08:50:29 +00:00
|
|
|
if (sctp_stcb_is_feature_on(inp, stcb, SCTP_PCB_FLAGS_DO_NOT_PMTUD)) {
|
|
|
|
paddrp->spp_flags |= SPP_PMTUD_DISABLE;
|
|
|
|
} else {
|
2007-05-28 11:17:24 +00:00
|
|
|
paddrp->spp_flags |= SPP_PMTUD_ENABLE;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2011-09-17 08:50:29 +00:00
|
|
|
paddrp->spp_hbinterval = stcb->asoc.heart_beat_delay;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
paddrp->spp_assoc_id = sctp_get_associd(stcb);
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
2011-08-16 21:04:18 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(paddrp->spp_assoc_id == SCTP_FUTURE_ASSOC))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
/* Use endpoint defaults */
|
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
paddrp->spp_pathmaxrxt = inp->sctp_ep.def_net_failure;
|
2020-03-28 20:25:45 +00:00
|
|
|
paddrp->spp_hbinterval = sctp_ticks_to_msecs(inp->sctp_ep.sctp_timeoutticks[SCTP_TIMER_HEARTBEAT]);
|
2011-06-15 23:50:27 +00:00
|
|
|
paddrp->spp_assoc_id = SCTP_FUTURE_ASSOC;
|
|
|
|
/* get inp's default */
|
2011-09-14 08:15:21 +00:00
|
|
|
if (inp->sctp_ep.default_dscp & 0x01) {
|
2011-10-11 13:24:37 +00:00
|
|
|
paddrp->spp_dscp = inp->sctp_ep.default_dscp & 0xfc;
|
2011-09-14 08:15:21 +00:00
|
|
|
paddrp->spp_flags |= SPP_DSCP;
|
|
|
|
}
|
2007-03-15 11:27:14 +00:00
|
|
|
#ifdef INET6
|
2011-09-14 08:15:21 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) &&
|
|
|
|
(inp->sctp_ep.default_flowlabel & 0x80000000)) {
|
|
|
|
paddrp->spp_ipv6_flowlabel = inp->sctp_ep.default_flowlabel & 0x000fffff;
|
2011-06-15 23:50:27 +00:00
|
|
|
paddrp->spp_flags |= SPP_IPV6_FLOWLABEL;
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
#endif
|
2017-11-03 20:46:12 +00:00
|
|
|
paddrp->spp_pathmtu = inp->sctp_ep.default_mtu;
|
2007-05-28 11:17:24 +00:00
|
|
|
|
2011-06-15 23:50:27 +00:00
|
|
|
if (sctp_is_feature_off(inp, SCTP_PCB_FLAGS_DONOT_HEARTBEAT)) {
|
|
|
|
paddrp->spp_flags |= SPP_HB_ENABLE;
|
|
|
|
} else {
|
|
|
|
paddrp->spp_flags |= SPP_HB_DISABLE;
|
|
|
|
}
|
2011-09-17 08:50:29 +00:00
|
|
|
if (sctp_is_feature_off(inp, SCTP_PCB_FLAGS_DO_NOT_PMTUD)) {
|
|
|
|
paddrp->spp_flags |= SPP_PMTUD_ENABLE;
|
|
|
|
} else {
|
|
|
|
paddrp->spp_flags |= SPP_PMTUD_DISABLE;
|
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_RUNLOCK(inp);
|
2007-05-28 11:17:24 +00:00
|
|
|
} else {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
2007-05-28 11:17:24 +00:00
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
if (error == 0) {
|
|
|
|
*optsize = sizeof(struct sctp_paddrparams);
|
|
|
|
}
|
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
case SCTP_GET_PEER_ADDR_INFO:
|
|
|
|
{
|
|
|
|
struct sctp_paddrinfo *paddri;
|
|
|
|
struct sctp_nets *net;
|
2014-12-06 20:00:08 +00:00
|
|
|
struct sockaddr *addr;
|
|
|
|
#if defined(INET) && defined(INET6)
|
|
|
|
struct sockaddr_in sin_store;
|
|
|
|
#endif
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_CHECK_AND_CAST(paddri, optval, struct sctp_paddrinfo, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, paddri->spinfo_assoc_id);
|
|
|
|
|
2014-12-06 20:00:08 +00:00
|
|
|
#if defined(INET) && defined(INET6)
|
|
|
|
if (paddri->spinfo_address.ss_family == AF_INET6) {
|
|
|
|
struct sockaddr_in6 *sin6;
|
|
|
|
|
|
|
|
sin6 = (struct sockaddr_in6 *)&paddri->spinfo_address;
|
|
|
|
if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
|
|
|
|
in6_sin6_2_sin(&sin_store, sin6);
|
|
|
|
addr = (struct sockaddr *)&sin_store;
|
|
|
|
} else {
|
|
|
|
addr = (struct sockaddr *)&paddri->spinfo_address;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
addr = (struct sockaddr *)&paddri->spinfo_address;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
addr = (struct sockaddr *)&paddri->spinfo_address;
|
|
|
|
#endif
|
|
|
|
if (stcb != NULL) {
|
|
|
|
net = sctp_findnet(stcb, addr);
|
2007-02-12 23:24:31 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* We increment here since
|
|
|
|
* sctp_findassociation_ep_addr() wil do a
|
|
|
|
* decrement if it finds the stcb as long as
|
|
|
|
* the locked tcb (last argument) is NOT a
|
|
|
|
* TCB.. aka NULL.
|
|
|
|
*/
|
2014-12-06 20:00:08 +00:00
|
|
|
net = NULL;
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_INP_INCR_REF(inp);
|
2014-12-06 20:00:08 +00:00
|
|
|
stcb = sctp_findassociation_ep_addr(&inp, addr, &net, NULL, NULL);
|
2007-02-12 23:24:31 +00:00
|
|
|
if (stcb == NULL) {
|
|
|
|
SCTP_INP_DECR_REF(inp);
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2007-02-12 23:24:31 +00:00
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2014-12-06 20:00:08 +00:00
|
|
|
if ((stcb != NULL) && (net != NULL)) {
|
2011-01-20 12:40:09 +00:00
|
|
|
if (net->dest_state & SCTP_ADDR_UNCONFIRMED) {
|
2011-01-20 13:53:34 +00:00
|
|
|
/* It's unconfirmed */
|
2011-01-20 12:40:09 +00:00
|
|
|
paddri->spinfo_state = SCTP_UNCONFIRMED;
|
|
|
|
} else if (net->dest_state & SCTP_ADDR_REACHABLE) {
|
2011-01-20 13:53:34 +00:00
|
|
|
/* It's active */
|
2011-01-20 12:40:09 +00:00
|
|
|
paddri->spinfo_state = SCTP_ACTIVE;
|
|
|
|
} else {
|
2011-01-20 13:53:34 +00:00
|
|
|
/* It's inactive */
|
2011-01-20 12:40:09 +00:00
|
|
|
paddri->spinfo_state = SCTP_INACTIVE;
|
|
|
|
}
|
2007-02-12 23:24:31 +00:00
|
|
|
paddri->spinfo_cwnd = net->cwnd;
|
2011-02-24 22:58:15 +00:00
|
|
|
paddri->spinfo_srtt = net->lastsa >> SCTP_RTT_SHIFT;
|
2007-02-12 23:24:31 +00:00
|
|
|
paddri->spinfo_rto = net->RTO;
|
|
|
|
paddri->spinfo_assoc_id = sctp_get_associd(stcb);
|
2011-05-17 15:57:31 +00:00
|
|
|
paddri->spinfo_mtu = net->mtu;
|
2015-05-28 20:33:28 +00:00
|
|
|
switch (addr->sa_family) {
|
|
|
|
#if defined(INET)
|
|
|
|
case AF_INET:
|
|
|
|
paddri->spinfo_mtu -= SCTP_MIN_V4_OVERHEAD;
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
#if defined(INET6)
|
|
|
|
case AF_INET6:
|
|
|
|
paddri->spinfo_mtu -= SCTP_MIN_OVERHEAD;
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
2011-06-15 23:50:27 +00:00
|
|
|
*optsize = sizeof(struct sctp_paddrinfo);
|
2006-11-03 15:23:16 +00:00
|
|
|
} else {
|
2014-12-06 20:00:08 +00:00
|
|
|
if (stcb != NULL) {
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
}
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOENT);
|
2006-11-03 15:23:16 +00:00
|
|
|
error = ENOENT;
|
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
case SCTP_PCB_STATUS:
|
|
|
|
{
|
|
|
|
struct sctp_pcbinfo *spcb;
|
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_CHECK_AND_CAST(spcb, optval, struct sctp_pcbinfo, *optsize);
|
2006-11-03 15:23:16 +00:00
|
|
|
sctp_fill_pcbinfo(spcb);
|
2007-02-12 23:24:31 +00:00
|
|
|
*optsize = sizeof(struct sctp_pcbinfo);
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
case SCTP_STATUS:
|
|
|
|
{
|
|
|
|
struct sctp_nets *net;
|
|
|
|
struct sctp_status *sstat;
|
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_CHECK_AND_CAST(sstat, optval, struct sctp_status, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, sstat->sstat_assoc_id);
|
2006-11-03 15:23:16 +00:00
|
|
|
|
|
|
|
if (stcb == NULL) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2006-11-03 15:23:16 +00:00
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
2015-08-29 09:14:32 +00:00
|
|
|
sstat->sstat_state = sctp_map_assoc_state(stcb->asoc.state);
|
2007-10-30 14:09:24 +00:00
|
|
|
sstat->sstat_assoc_id = sctp_get_associd(stcb);
|
2006-11-03 15:23:16 +00:00
|
|
|
sstat->sstat_rwnd = stcb->asoc.peers_rwnd;
|
|
|
|
sstat->sstat_unackdata = stcb->asoc.sent_queue_cnt;
|
|
|
|
/*
|
|
|
|
* We can't include chunks that have been passed to
|
|
|
|
* the socket layer. Only things in queue.
|
|
|
|
*/
|
|
|
|
sstat->sstat_penddata = (stcb->asoc.cnt_on_reasm_queue +
|
|
|
|
stcb->asoc.cnt_on_all_streams);
|
|
|
|
sstat->sstat_instrms = stcb->asoc.streamincnt;
|
|
|
|
sstat->sstat_outstrms = stcb->asoc.streamoutcnt;
|
|
|
|
sstat->sstat_fragmentation_point = sctp_get_frag_point(stcb, &stcb->asoc);
|
|
|
|
net = stcb->asoc.primary_destination;
|
2019-03-02 14:15:33 +00:00
|
|
|
if (net != NULL) {
|
|
|
|
memcpy(&sstat->sstat_primary.spinfo_address,
|
2020-03-28 22:35:04 +00:00
|
|
|
&net->ro._l_addr,
|
|
|
|
((struct sockaddr *)(&net->ro._l_addr))->sa_len);
|
2019-03-02 14:15:33 +00:00
|
|
|
((struct sockaddr_in *)&sstat->sstat_primary.spinfo_address)->sin_port = stcb->rport;
|
|
|
|
/*
|
|
|
|
* Again the user can get info from
|
|
|
|
* sctp_constants.h for what the state of
|
|
|
|
* the network is.
|
|
|
|
*/
|
|
|
|
if (net->dest_state & SCTP_ADDR_UNCONFIRMED) {
|
|
|
|
/* It's unconfirmed */
|
|
|
|
sstat->sstat_primary.spinfo_state = SCTP_UNCONFIRMED;
|
|
|
|
} else if (net->dest_state & SCTP_ADDR_REACHABLE) {
|
|
|
|
/* It's active */
|
|
|
|
sstat->sstat_primary.spinfo_state = SCTP_ACTIVE;
|
|
|
|
} else {
|
|
|
|
/* It's inactive */
|
|
|
|
sstat->sstat_primary.spinfo_state = SCTP_INACTIVE;
|
|
|
|
}
|
|
|
|
sstat->sstat_primary.spinfo_cwnd = net->cwnd;
|
|
|
|
sstat->sstat_primary.spinfo_srtt = net->lastsa >> SCTP_RTT_SHIFT;
|
|
|
|
sstat->sstat_primary.spinfo_rto = net->RTO;
|
|
|
|
sstat->sstat_primary.spinfo_mtu = net->mtu;
|
|
|
|
switch (stcb->asoc.primary_destination->ro._l_addr.sa.sa_family) {
|
2015-05-28 20:33:28 +00:00
|
|
|
#if defined(INET)
|
2019-03-02 14:15:33 +00:00
|
|
|
case AF_INET:
|
|
|
|
sstat->sstat_primary.spinfo_mtu -= SCTP_MIN_V4_OVERHEAD;
|
|
|
|
break;
|
2015-05-28 20:33:28 +00:00
|
|
|
#endif
|
|
|
|
#if defined(INET6)
|
2019-03-02 14:15:33 +00:00
|
|
|
case AF_INET6:
|
|
|
|
sstat->sstat_primary.spinfo_mtu -= SCTP_MIN_OVERHEAD;
|
|
|
|
break;
|
2015-05-28 20:33:28 +00:00
|
|
|
#endif
|
2019-03-02 14:15:33 +00:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
memset(&sstat->sstat_primary, 0, sizeof(struct sctp_paddrinfo));
|
2015-05-28 20:33:28 +00:00
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
sstat->sstat_primary.spinfo_assoc_id = sctp_get_associd(stcb);
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
2011-06-15 23:50:27 +00:00
|
|
|
*optsize = sizeof(struct sctp_status);
|
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
case SCTP_RTOINFO:
|
|
|
|
{
|
|
|
|
struct sctp_rtoinfo *srto;
|
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_CHECK_AND_CAST(srto, optval, struct sctp_rtoinfo, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, srto->srto_assoc_id);
|
|
|
|
|
|
|
|
if (stcb) {
|
|
|
|
srto->srto_initial = stcb->asoc.initial_rto;
|
|
|
|
srto->srto_max = stcb->asoc.maxrto;
|
|
|
|
srto->srto_min = stcb->asoc.minrto;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
2011-08-16 21:04:18 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(srto->srto_assoc_id == SCTP_FUTURE_ASSOC))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
srto->srto_initial = inp->sctp_ep.initial_rto;
|
|
|
|
srto->srto_max = inp->sctp_ep.sctp_maxrto;
|
|
|
|
srto->srto_min = inp->sctp_ep.sctp_minrto;
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
if (error == 0) {
|
|
|
|
*optsize = sizeof(struct sctp_rtoinfo);
|
|
|
|
}
|
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2010-11-16 22:16:38 +00:00
|
|
|
case SCTP_TIMEOUTS:
|
|
|
|
{
|
|
|
|
struct sctp_timeouts *stimo;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(stimo, optval, struct sctp_timeouts, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, stimo->stimo_assoc_id);
|
|
|
|
|
|
|
|
if (stcb) {
|
|
|
|
stimo->stimo_init = stcb->asoc.timoinit;
|
|
|
|
stimo->stimo_data = stcb->asoc.timodata;
|
|
|
|
stimo->stimo_sack = stcb->asoc.timosack;
|
|
|
|
stimo->stimo_shutdown = stcb->asoc.timoshutdown;
|
|
|
|
stimo->stimo_heartbeat = stcb->asoc.timoheartbeat;
|
|
|
|
stimo->stimo_cookie = stcb->asoc.timocookie;
|
|
|
|
stimo->stimo_shutdownack = stcb->asoc.timoshutdownack;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
2011-06-15 23:50:27 +00:00
|
|
|
*optsize = sizeof(struct sctp_timeouts);
|
2010-11-16 22:16:38 +00:00
|
|
|
} else {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2010-11-16 22:16:38 +00:00
|
|
|
error = EINVAL;
|
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2010-11-16 22:16:38 +00:00
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
case SCTP_ASSOCINFO:
|
|
|
|
{
|
|
|
|
struct sctp_assocparams *sasoc;
|
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_CHECK_AND_CAST(sasoc, optval, struct sctp_assocparams, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, sasoc->sasoc_assoc_id);
|
2006-11-03 15:23:16 +00:00
|
|
|
|
|
|
|
if (stcb) {
|
2020-03-28 20:25:45 +00:00
|
|
|
sasoc->sasoc_cookie_life = sctp_ticks_to_msecs(stcb->asoc.cookie_life);
|
2006-11-03 15:23:16 +00:00
|
|
|
sasoc->sasoc_asocmaxrxt = stcb->asoc.max_send_times;
|
|
|
|
sasoc->sasoc_number_peer_destinations = stcb->asoc.numnets;
|
|
|
|
sasoc->sasoc_peer_rwnd = stcb->asoc.peers_rwnd;
|
|
|
|
sasoc->sasoc_local_rwnd = stcb->asoc.my_rwnd;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
2011-08-16 21:04:18 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(sasoc->sasoc_assoc_id == SCTP_FUTURE_ASSOC))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
2020-03-28 20:25:45 +00:00
|
|
|
sasoc->sasoc_cookie_life = sctp_ticks_to_msecs(inp->sctp_ep.def_cookie_life);
|
2011-06-15 23:50:27 +00:00
|
|
|
sasoc->sasoc_asocmaxrxt = inp->sctp_ep.max_send_times;
|
|
|
|
sasoc->sasoc_number_peer_destinations = 0;
|
|
|
|
sasoc->sasoc_peer_rwnd = 0;
|
|
|
|
sasoc->sasoc_local_rwnd = sbspace(&inp->sctp_socket->so_rcv);
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
if (error == 0) {
|
|
|
|
*optsize = sizeof(struct sctp_assocparams);
|
|
|
|
}
|
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
case SCTP_DEFAULT_SEND_PARAM:
|
|
|
|
{
|
|
|
|
struct sctp_sndrcvinfo *s_info;
|
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_CHECK_AND_CAST(s_info, optval, struct sctp_sndrcvinfo, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, s_info->sinfo_assoc_id);
|
|
|
|
|
|
|
|
if (stcb) {
|
2007-05-28 11:17:24 +00:00
|
|
|
memcpy(s_info, &stcb->asoc.def_send, sizeof(stcb->asoc.def_send));
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
2011-08-16 21:04:18 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(s_info->sinfo_assoc_id == SCTP_FUTURE_ASSOC))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
memcpy(s_info, &inp->def_send, sizeof(inp->def_send));
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
if (error == 0) {
|
|
|
|
*optsize = sizeof(struct sctp_sndrcvinfo);
|
|
|
|
}
|
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
case SCTP_INITMSG:
|
|
|
|
{
|
|
|
|
struct sctp_initmsg *sinit;
|
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_CHECK_AND_CAST(sinit, optval, struct sctp_initmsg, *optsize);
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
sinit->sinit_num_ostreams = inp->sctp_ep.pre_open_stream_count;
|
|
|
|
sinit->sinit_max_instreams = inp->sctp_ep.max_open_streams_intome;
|
|
|
|
sinit->sinit_max_attempts = inp->sctp_ep.max_init_times;
|
|
|
|
sinit->sinit_max_init_timeo = inp->sctp_ep.initial_init_rto_max;
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
2011-06-15 23:50:27 +00:00
|
|
|
*optsize = sizeof(struct sctp_initmsg);
|
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
case SCTP_PRIMARY_ADDR:
|
|
|
|
/* we allow a "get" operation on this */
|
|
|
|
{
|
|
|
|
struct sctp_setprim *ssp;
|
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_CHECK_AND_CAST(ssp, optval, struct sctp_setprim, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, ssp->ssp_assoc_id);
|
|
|
|
|
|
|
|
if (stcb) {
|
2014-12-06 20:00:08 +00:00
|
|
|
union sctp_sockstore *addr;
|
2007-05-28 11:17:24 +00:00
|
|
|
|
2014-12-06 20:00:08 +00:00
|
|
|
addr = &stcb->asoc.primary_destination->ro._l_addr;
|
|
|
|
switch (addr->sa.sa_family) {
|
|
|
|
#ifdef INET
|
|
|
|
case AF_INET:
|
|
|
|
#ifdef INET6
|
|
|
|
if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_NEEDS_MAPPED_V4)) {
|
|
|
|
in6_sin_2_v4mapsin6(&addr->sin,
|
|
|
|
(struct sockaddr_in6 *)&ssp->ssp_addr);
|
|
|
|
} else {
|
|
|
|
memcpy(&ssp->ssp_addr, &addr->sin, sizeof(struct sockaddr_in));
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
memcpy(&ssp->ssp_addr, &addr->sin, sizeof(struct sockaddr_in));
|
|
|
|
#endif
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
#ifdef INET6
|
|
|
|
case AF_INET6:
|
|
|
|
memcpy(&ssp->ssp_addr, &addr->sin6, sizeof(struct sockaddr_in6));
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
2011-06-15 23:50:27 +00:00
|
|
|
*optsize = sizeof(struct sctp_setprim);
|
2006-11-03 15:23:16 +00:00
|
|
|
} else {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2007-02-12 23:24:31 +00:00
|
|
|
error = EINVAL;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
case SCTP_HMAC_IDENT:
|
|
|
|
{
|
|
|
|
struct sctp_hmacalgo *shmac;
|
|
|
|
sctp_hmaclist_t *hmaclist;
|
|
|
|
uint32_t size;
|
|
|
|
int i;
|
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_CHECK_AND_CAST(shmac, optval, struct sctp_hmacalgo, *optsize);
|
|
|
|
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
hmaclist = inp->sctp_ep.local_hmacs;
|
|
|
|
if (hmaclist == NULL) {
|
|
|
|
/* no HMACs to return */
|
2007-02-12 23:24:31 +00:00
|
|
|
*optsize = sizeof(*shmac);
|
2007-04-03 11:15:32 +00:00
|
|
|
SCTP_INP_RUNLOCK(inp);
|
2006-11-03 15:23:16 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* is there room for all of the hmac ids? */
|
|
|
|
size = sizeof(*shmac) + (hmaclist->num_algo *
|
|
|
|
sizeof(shmac->shmac_idents[0]));
|
2007-02-12 23:24:31 +00:00
|
|
|
if ((size_t)(*optsize) < size) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2006-11-03 15:23:16 +00:00
|
|
|
error = EINVAL;
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* copy in the list */
|
2008-07-31 11:08:30 +00:00
|
|
|
shmac->shmac_number_of_idents = hmaclist->num_algo;
|
|
|
|
for (i = 0; i < hmaclist->num_algo; i++) {
|
2006-11-03 15:23:16 +00:00
|
|
|
shmac->shmac_idents[i] = hmaclist->hmac[i];
|
2008-07-31 11:08:30 +00:00
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_INP_RUNLOCK(inp);
|
2007-02-12 23:24:31 +00:00
|
|
|
*optsize = size;
|
2006-11-03 15:23:16 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case SCTP_AUTH_ACTIVE_KEY:
|
|
|
|
{
|
|
|
|
struct sctp_authkeyid *scact;
|
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_CHECK_AND_CAST(scact, optval, struct sctp_authkeyid, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, scact->scact_assoc_id);
|
|
|
|
|
|
|
|
if (stcb) {
|
2006-11-03 15:23:16 +00:00
|
|
|
/* get the active key on the assoc */
|
2008-12-06 13:19:54 +00:00
|
|
|
scact->scact_keynumber = stcb->asoc.authinfo.active_keyid;
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
2011-08-16 21:04:18 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(scact->scact_assoc_id == SCTP_FUTURE_ASSOC))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
/* get the endpoint active key */
|
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
scact->scact_keynumber = inp->sctp_ep.default_keyid;
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (error == 0) {
|
|
|
|
*optsize = sizeof(struct sctp_authkeyid);
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case SCTP_LOCAL_AUTH_CHUNKS:
|
|
|
|
{
|
|
|
|
struct sctp_authchunks *sac;
|
|
|
|
sctp_auth_chklist_t *chklist = NULL;
|
2007-02-12 23:24:31 +00:00
|
|
|
size_t size = 0;
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_CHECK_AND_CAST(sac, optval, struct sctp_authchunks, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, sac->gauth_assoc_id);
|
|
|
|
|
|
|
|
if (stcb) {
|
2006-11-03 15:23:16 +00:00
|
|
|
/* get off the assoc */
|
|
|
|
chklist = stcb->asoc.local_auth_chunks;
|
|
|
|
/* is there enough space? */
|
|
|
|
size = sctp_auth_get_chklist_size(chklist);
|
2007-02-12 23:24:31 +00:00
|
|
|
if (*optsize < (sizeof(struct sctp_authchunks) + size)) {
|
2006-11-03 15:23:16 +00:00
|
|
|
error = EINVAL;
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
|
2007-02-12 23:24:31 +00:00
|
|
|
} else {
|
|
|
|
/* copy in the chunks */
|
2007-05-09 13:30:06 +00:00
|
|
|
(void)sctp_serialize_auth_chunks(chklist, sac->gauth_chunks);
|
2018-07-19 20:11:14 +00:00
|
|
|
sac->gauth_number_of_chunks = (uint32_t)size;
|
2011-06-15 23:50:27 +00:00
|
|
|
*optsize = sizeof(struct sctp_authchunks) + size;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
2011-08-16 21:04:18 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(sac->gauth_assoc_id == SCTP_FUTURE_ASSOC))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
/* get off the endpoint */
|
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
chklist = inp->sctp_ep.local_auth_chunks;
|
|
|
|
/* is there enough space? */
|
|
|
|
size = sctp_auth_get_chklist_size(chklist);
|
|
|
|
if (*optsize < (sizeof(struct sctp_authchunks) + size)) {
|
|
|
|
error = EINVAL;
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
|
|
|
|
} else {
|
|
|
|
/* copy in the chunks */
|
|
|
|
(void)sctp_serialize_auth_chunks(chklist, sac->gauth_chunks);
|
2018-07-19 20:11:14 +00:00
|
|
|
sac->gauth_number_of_chunks = (uint32_t)size;
|
2011-06-15 23:50:27 +00:00
|
|
|
*optsize = sizeof(struct sctp_authchunks) + size;
|
|
|
|
}
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
2007-02-12 23:24:31 +00:00
|
|
|
} else {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case SCTP_PEER_AUTH_CHUNKS:
|
|
|
|
{
|
|
|
|
struct sctp_authchunks *sac;
|
|
|
|
sctp_auth_chklist_t *chklist = NULL;
|
2007-02-12 23:24:31 +00:00
|
|
|
size_t size = 0;
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_CHECK_AND_CAST(sac, optval, struct sctp_authchunks, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, sac->gauth_assoc_id);
|
|
|
|
|
|
|
|
if (stcb) {
|
|
|
|
/* get off the assoc */
|
|
|
|
chklist = stcb->asoc.peer_auth_chunks;
|
|
|
|
/* is there enough space? */
|
|
|
|
size = sctp_auth_get_chklist_size(chklist);
|
|
|
|
if (*optsize < (sizeof(struct sctp_authchunks) + size)) {
|
|
|
|
error = EINVAL;
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
|
2007-02-12 23:24:31 +00:00
|
|
|
} else {
|
|
|
|
/* copy in the chunks */
|
2007-05-09 13:30:06 +00:00
|
|
|
(void)sctp_serialize_auth_chunks(chklist, sac->gauth_chunks);
|
2018-07-19 20:11:14 +00:00
|
|
|
sac->gauth_number_of_chunks = (uint32_t)size;
|
2011-06-15 23:50:27 +00:00
|
|
|
*optsize = sizeof(struct sctp_authchunks) + size;
|
2007-02-12 23:24:31 +00:00
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
2007-02-12 23:24:31 +00:00
|
|
|
} else {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOENT);
|
2007-02-12 23:24:31 +00:00
|
|
|
error = ENOENT;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
case SCTP_EVENT:
|
|
|
|
{
|
|
|
|
struct sctp_event *event;
|
|
|
|
uint32_t event_type;
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_CHECK_AND_CAST(event, optval, struct sctp_event, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, event->se_assoc_id);
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2011-06-15 23:50:27 +00:00
|
|
|
switch (event->se_type) {
|
|
|
|
case SCTP_ASSOC_CHANGE:
|
|
|
|
event_type = SCTP_PCB_FLAGS_RECVASSOCEVNT;
|
|
|
|
break;
|
|
|
|
case SCTP_PEER_ADDR_CHANGE:
|
|
|
|
event_type = SCTP_PCB_FLAGS_RECVPADDREVNT;
|
|
|
|
break;
|
|
|
|
case SCTP_REMOTE_ERROR:
|
|
|
|
event_type = SCTP_PCB_FLAGS_RECVPEERERR;
|
|
|
|
break;
|
|
|
|
case SCTP_SEND_FAILED:
|
|
|
|
event_type = SCTP_PCB_FLAGS_RECVSENDFAILEVNT;
|
|
|
|
break;
|
|
|
|
case SCTP_SHUTDOWN_EVENT:
|
|
|
|
event_type = SCTP_PCB_FLAGS_RECVSHUTDOWNEVNT;
|
|
|
|
break;
|
|
|
|
case SCTP_ADAPTATION_INDICATION:
|
|
|
|
event_type = SCTP_PCB_FLAGS_ADAPTATIONEVNT;
|
|
|
|
break;
|
|
|
|
case SCTP_PARTIAL_DELIVERY_EVENT:
|
|
|
|
event_type = SCTP_PCB_FLAGS_PDAPIEVNT;
|
|
|
|
break;
|
|
|
|
case SCTP_AUTHENTICATION_EVENT:
|
|
|
|
event_type = SCTP_PCB_FLAGS_AUTHEVNT;
|
|
|
|
break;
|
|
|
|
case SCTP_STREAM_RESET_EVENT:
|
|
|
|
event_type = SCTP_PCB_FLAGS_STREAM_RESETEVNT;
|
|
|
|
break;
|
|
|
|
case SCTP_SENDER_DRY_EVENT:
|
|
|
|
event_type = SCTP_PCB_FLAGS_DRYEVNT;
|
|
|
|
break;
|
|
|
|
case SCTP_NOTIFICATIONS_STOPPED_EVENT:
|
|
|
|
event_type = 0;
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOTSUP);
|
|
|
|
error = ENOTSUP;
|
|
|
|
break;
|
2012-05-04 15:49:08 +00:00
|
|
|
case SCTP_ASSOC_RESET_EVENT:
|
|
|
|
event_type = SCTP_PCB_FLAGS_ASSOC_RESETEVNT;
|
|
|
|
break;
|
|
|
|
case SCTP_STREAM_CHANGE_EVENT:
|
|
|
|
event_type = SCTP_PCB_FLAGS_STREAM_CHANGEEVNT;
|
|
|
|
break;
|
2012-05-06 11:02:53 +00:00
|
|
|
case SCTP_SEND_FAILED_EVENT:
|
|
|
|
event_type = SCTP_PCB_FLAGS_RECVNSENDFAILEVNT;
|
|
|
|
break;
|
2011-06-15 23:50:27 +00:00
|
|
|
default:
|
|
|
|
event_type = 0;
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (event_type > 0) {
|
|
|
|
if (stcb) {
|
|
|
|
event->se_on = sctp_stcb_is_feature_on(inp, stcb, event_type);
|
|
|
|
} else {
|
2011-08-16 21:04:18 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(event->se_assoc_id == SCTP_FUTURE_ASSOC))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
event->se_on = sctp_is_feature_on(inp, event_type);
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2017-09-09 20:44:56 +00:00
|
|
|
if (stcb != NULL) {
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
if (error == 0) {
|
|
|
|
*optsize = sizeof(struct sctp_event);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case SCTP_RECVRCVINFO:
|
2020-10-06 10:41:04 +00:00
|
|
|
if (*optsize < sizeof(int)) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
} else {
|
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
*(int *)optval = sctp_is_feature_on(inp, SCTP_PCB_FLAGS_RECVRCVINFO);
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
*optsize = sizeof(int);
|
2011-06-15 23:50:27 +00:00
|
|
|
}
|
2020-10-06 10:41:04 +00:00
|
|
|
break;
|
2011-06-15 23:50:27 +00:00
|
|
|
case SCTP_RECVNXTINFO:
|
2020-10-06 10:41:04 +00:00
|
|
|
if (*optsize < sizeof(int)) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
} else {
|
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
*(int *)optval = sctp_is_feature_on(inp, SCTP_PCB_FLAGS_RECVNXTINFO);
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
*optsize = sizeof(int);
|
2011-06-15 23:50:27 +00:00
|
|
|
}
|
2020-10-06 10:41:04 +00:00
|
|
|
break;
|
2011-06-15 23:50:27 +00:00
|
|
|
case SCTP_DEFAULT_SNDINFO:
|
|
|
|
{
|
|
|
|
struct sctp_sndinfo *info;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(info, optval, struct sctp_sndinfo, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, info->snd_assoc_id);
|
|
|
|
|
|
|
|
if (stcb) {
|
|
|
|
info->snd_sid = stcb->asoc.def_send.sinfo_stream;
|
|
|
|
info->snd_flags = stcb->asoc.def_send.sinfo_flags;
|
2011-06-16 21:12:36 +00:00
|
|
|
info->snd_flags &= 0xfff0;
|
2011-06-15 23:50:27 +00:00
|
|
|
info->snd_ppid = stcb->asoc.def_send.sinfo_ppid;
|
|
|
|
info->snd_context = stcb->asoc.def_send.sinfo_context;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
2011-08-16 21:04:18 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(info->snd_assoc_id == SCTP_FUTURE_ASSOC))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
info->snd_sid = inp->def_send.sinfo_stream;
|
|
|
|
info->snd_flags = inp->def_send.sinfo_flags;
|
2011-06-16 21:12:36 +00:00
|
|
|
info->snd_flags &= 0xfff0;
|
2011-06-15 23:50:27 +00:00
|
|
|
info->snd_ppid = inp->def_send.sinfo_ppid;
|
|
|
|
info->snd_context = inp->def_send.sinfo_context;
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (error == 0) {
|
|
|
|
*optsize = sizeof(struct sctp_sndinfo);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2011-06-16 21:12:36 +00:00
|
|
|
case SCTP_DEFAULT_PRINFO:
|
|
|
|
{
|
|
|
|
struct sctp_default_prinfo *info;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(info, optval, struct sctp_default_prinfo, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, info->pr_assoc_id);
|
|
|
|
|
|
|
|
if (stcb) {
|
|
|
|
info->pr_policy = PR_SCTP_POLICY(stcb->asoc.def_send.sinfo_flags);
|
|
|
|
info->pr_value = stcb->asoc.def_send.sinfo_timetolive;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
2011-08-16 21:04:18 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(info->pr_assoc_id == SCTP_FUTURE_ASSOC))) {
|
2011-06-16 21:12:36 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
info->pr_policy = PR_SCTP_POLICY(inp->def_send.sinfo_flags);
|
|
|
|
info->pr_value = inp->def_send.sinfo_timetolive;
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (error == 0) {
|
|
|
|
*optsize = sizeof(struct sctp_default_prinfo);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2011-08-03 20:21:00 +00:00
|
|
|
case SCTP_PEER_ADDR_THLDS:
|
|
|
|
{
|
|
|
|
struct sctp_paddrthlds *thlds;
|
|
|
|
struct sctp_nets *net;
|
2014-12-06 20:00:08 +00:00
|
|
|
struct sockaddr *addr;
|
|
|
|
#if defined(INET) && defined(INET6)
|
|
|
|
struct sockaddr_in sin_store;
|
|
|
|
#endif
|
2011-08-03 20:21:00 +00:00
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(thlds, optval, struct sctp_paddrthlds, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, thlds->spt_assoc_id);
|
|
|
|
|
2014-12-06 20:00:08 +00:00
|
|
|
#if defined(INET) && defined(INET6)
|
|
|
|
if (thlds->spt_address.ss_family == AF_INET6) {
|
|
|
|
struct sockaddr_in6 *sin6;
|
|
|
|
|
|
|
|
sin6 = (struct sockaddr_in6 *)&thlds->spt_address;
|
|
|
|
if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
|
|
|
|
in6_sin6_2_sin(&sin_store, sin6);
|
|
|
|
addr = (struct sockaddr *)&sin_store;
|
|
|
|
} else {
|
|
|
|
addr = (struct sockaddr *)&thlds->spt_address;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
addr = (struct sockaddr *)&thlds->spt_address;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
addr = (struct sockaddr *)&thlds->spt_address;
|
|
|
|
#endif
|
|
|
|
if (stcb != NULL) {
|
|
|
|
net = sctp_findnet(stcb, addr);
|
2011-08-03 20:21:00 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* We increment here since
|
|
|
|
* sctp_findassociation_ep_addr() wil do a
|
|
|
|
* decrement if it finds the stcb as long as
|
|
|
|
* the locked tcb (last argument) is NOT a
|
|
|
|
* TCB.. aka NULL.
|
|
|
|
*/
|
2014-12-06 20:00:08 +00:00
|
|
|
net = NULL;
|
2011-08-03 20:21:00 +00:00
|
|
|
SCTP_INP_INCR_REF(inp);
|
2014-12-06 20:00:08 +00:00
|
|
|
stcb = sctp_findassociation_ep_addr(&inp, addr, &net, NULL, NULL);
|
2011-08-03 20:21:00 +00:00
|
|
|
if (stcb == NULL) {
|
|
|
|
SCTP_INP_DECR_REF(inp);
|
|
|
|
}
|
|
|
|
}
|
2014-12-06 20:00:08 +00:00
|
|
|
if ((stcb != NULL) && (net == NULL)) {
|
2011-08-03 20:21:00 +00:00
|
|
|
#ifdef INET
|
2014-12-06 20:00:08 +00:00
|
|
|
if (addr->sa_family == AF_INET) {
|
2011-08-03 20:21:00 +00:00
|
|
|
struct sockaddr_in *sin;
|
|
|
|
|
2014-12-06 20:00:08 +00:00
|
|
|
sin = (struct sockaddr_in *)addr;
|
|
|
|
if (sin->sin_addr.s_addr != INADDR_ANY) {
|
2011-08-03 20:21:00 +00:00
|
|
|
error = EINVAL;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
#ifdef INET6
|
2014-12-06 20:00:08 +00:00
|
|
|
if (addr->sa_family == AF_INET6) {
|
2011-08-03 20:21:00 +00:00
|
|
|
struct sockaddr_in6 *sin6;
|
|
|
|
|
2014-12-06 20:00:08 +00:00
|
|
|
sin6 = (struct sockaddr_in6 *)addr;
|
2011-08-03 20:21:00 +00:00
|
|
|
if (!IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
|
|
|
|
error = EINVAL;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
{
|
|
|
|
error = EAFNOSUPPORT;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2018-07-19 20:16:33 +00:00
|
|
|
|
2014-12-06 20:00:08 +00:00
|
|
|
if (stcb != NULL) {
|
|
|
|
if (net != NULL) {
|
2011-08-03 20:21:00 +00:00
|
|
|
thlds->spt_pathmaxrxt = net->failure_threshold;
|
|
|
|
thlds->spt_pathpfthld = net->pf_threshold;
|
2016-05-26 11:38:26 +00:00
|
|
|
thlds->spt_pathcpthld = 0xffff;
|
2011-08-03 20:21:00 +00:00
|
|
|
} else {
|
|
|
|
thlds->spt_pathmaxrxt = stcb->asoc.def_net_failure;
|
|
|
|
thlds->spt_pathpfthld = stcb->asoc.def_net_pf_threshold;
|
2016-05-26 11:38:26 +00:00
|
|
|
thlds->spt_pathcpthld = 0xffff;
|
2011-08-03 20:21:00 +00:00
|
|
|
}
|
|
|
|
thlds->spt_assoc_id = sctp_get_associd(stcb);
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
2011-08-16 21:04:18 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(thlds->spt_assoc_id == SCTP_FUTURE_ASSOC))) {
|
2011-08-03 20:21:00 +00:00
|
|
|
/* Use endpoint defaults */
|
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
thlds->spt_pathmaxrxt = inp->sctp_ep.def_net_failure;
|
|
|
|
thlds->spt_pathpfthld = inp->sctp_ep.def_net_pf_threshold;
|
2016-05-26 11:38:26 +00:00
|
|
|
thlds->spt_pathcpthld = 0xffff;
|
2011-08-03 20:21:00 +00:00
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (error == 0) {
|
|
|
|
*optsize = sizeof(struct sctp_paddrthlds);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2011-11-20 15:00:45 +00:00
|
|
|
case SCTP_REMOTE_UDP_ENCAPS_PORT:
|
|
|
|
{
|
|
|
|
struct sctp_udpencaps *encaps;
|
|
|
|
struct sctp_nets *net;
|
2014-12-06 20:00:08 +00:00
|
|
|
struct sockaddr *addr;
|
|
|
|
#if defined(INET) && defined(INET6)
|
|
|
|
struct sockaddr_in sin_store;
|
|
|
|
#endif
|
2011-11-20 15:00:45 +00:00
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(encaps, optval, struct sctp_udpencaps, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, encaps->sue_assoc_id);
|
|
|
|
|
2014-12-06 20:00:08 +00:00
|
|
|
#if defined(INET) && defined(INET6)
|
|
|
|
if (encaps->sue_address.ss_family == AF_INET6) {
|
|
|
|
struct sockaddr_in6 *sin6;
|
|
|
|
|
|
|
|
sin6 = (struct sockaddr_in6 *)&encaps->sue_address;
|
|
|
|
if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
|
|
|
|
in6_sin6_2_sin(&sin_store, sin6);
|
|
|
|
addr = (struct sockaddr *)&sin_store;
|
|
|
|
} else {
|
|
|
|
addr = (struct sockaddr *)&encaps->sue_address;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
addr = (struct sockaddr *)&encaps->sue_address;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
addr = (struct sockaddr *)&encaps->sue_address;
|
|
|
|
#endif
|
2011-11-20 15:00:45 +00:00
|
|
|
if (stcb) {
|
2014-12-06 20:00:08 +00:00
|
|
|
net = sctp_findnet(stcb, addr);
|
2011-11-20 15:00:45 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* We increment here since
|
|
|
|
* sctp_findassociation_ep_addr() wil do a
|
|
|
|
* decrement if it finds the stcb as long as
|
|
|
|
* the locked tcb (last argument) is NOT a
|
|
|
|
* TCB.. aka NULL.
|
|
|
|
*/
|
|
|
|
net = NULL;
|
|
|
|
SCTP_INP_INCR_REF(inp);
|
2014-12-06 20:00:08 +00:00
|
|
|
stcb = sctp_findassociation_ep_addr(&inp, addr, &net, NULL, NULL);
|
2011-11-20 15:00:45 +00:00
|
|
|
if (stcb == NULL) {
|
|
|
|
SCTP_INP_DECR_REF(inp);
|
|
|
|
}
|
|
|
|
}
|
2014-12-06 20:00:08 +00:00
|
|
|
if ((stcb != NULL) && (net == NULL)) {
|
2011-11-20 15:00:45 +00:00
|
|
|
#ifdef INET
|
2014-12-06 20:00:08 +00:00
|
|
|
if (addr->sa_family == AF_INET) {
|
2011-11-20 15:00:45 +00:00
|
|
|
struct sockaddr_in *sin;
|
|
|
|
|
2014-12-06 20:00:08 +00:00
|
|
|
sin = (struct sockaddr_in *)addr;
|
|
|
|
if (sin->sin_addr.s_addr != INADDR_ANY) {
|
2011-11-20 15:00:45 +00:00
|
|
|
error = EINVAL;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
#ifdef INET6
|
2014-12-06 20:00:08 +00:00
|
|
|
if (addr->sa_family == AF_INET6) {
|
2011-11-20 15:00:45 +00:00
|
|
|
struct sockaddr_in6 *sin6;
|
|
|
|
|
2014-12-06 20:00:08 +00:00
|
|
|
sin6 = (struct sockaddr_in6 *)addr;
|
2011-11-20 15:00:45 +00:00
|
|
|
if (!IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
|
|
|
|
error = EINVAL;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
{
|
|
|
|
error = EAFNOSUPPORT;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2018-07-19 20:16:33 +00:00
|
|
|
|
2014-12-06 20:00:08 +00:00
|
|
|
if (stcb != NULL) {
|
2011-11-20 15:00:45 +00:00
|
|
|
if (net) {
|
|
|
|
encaps->sue_port = net->port;
|
|
|
|
} else {
|
|
|
|
encaps->sue_port = stcb->asoc.port;
|
|
|
|
}
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(encaps->sue_assoc_id == SCTP_FUTURE_ASSOC))) {
|
2011-11-20 15:00:45 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
encaps->sue_port = inp->sctp_ep.port;
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (error == 0) {
|
2013-10-28 20:45:19 +00:00
|
|
|
*optsize = sizeof(struct sctp_udpencaps);
|
2011-11-20 15:00:45 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2014-08-02 17:35:13 +00:00
|
|
|
case SCTP_ECN_SUPPORTED:
|
|
|
|
{
|
|
|
|
struct sctp_assoc_value *av;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, av->assoc_id);
|
|
|
|
|
|
|
|
if (stcb) {
|
|
|
|
av->assoc_value = stcb->asoc.ecn_supported;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(av->assoc_id == SCTP_FUTURE_ASSOC))) {
|
2014-08-02 17:35:13 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
av->assoc_value = inp->ecn_supported;
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (error == 0) {
|
|
|
|
*optsize = sizeof(struct sctp_assoc_value);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2014-08-02 21:36:40 +00:00
|
|
|
case SCTP_PR_SUPPORTED:
|
|
|
|
{
|
|
|
|
struct sctp_assoc_value *av;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, av->assoc_id);
|
|
|
|
|
|
|
|
if (stcb) {
|
|
|
|
av->assoc_value = stcb->asoc.prsctp_supported;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(av->assoc_id == SCTP_FUTURE_ASSOC))) {
|
2014-08-02 21:36:40 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
av->assoc_value = inp->prsctp_supported;
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (error == 0) {
|
|
|
|
*optsize = sizeof(struct sctp_assoc_value);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2014-08-12 11:30:16 +00:00
|
|
|
case SCTP_AUTH_SUPPORTED:
|
|
|
|
{
|
|
|
|
struct sctp_assoc_value *av;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, av->assoc_id);
|
|
|
|
|
|
|
|
if (stcb) {
|
|
|
|
av->assoc_value = stcb->asoc.auth_supported;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(av->assoc_id == SCTP_FUTURE_ASSOC))) {
|
2014-08-12 11:30:16 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
av->assoc_value = inp->auth_supported;
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (error == 0) {
|
|
|
|
*optsize = sizeof(struct sctp_assoc_value);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case SCTP_ASCONF_SUPPORTED:
|
|
|
|
{
|
|
|
|
struct sctp_assoc_value *av;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, av->assoc_id);
|
|
|
|
|
|
|
|
if (stcb) {
|
|
|
|
av->assoc_value = stcb->asoc.asconf_supported;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(av->assoc_id == SCTP_FUTURE_ASSOC))) {
|
2014-08-12 11:30:16 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
av->assoc_value = inp->asconf_supported;
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (error == 0) {
|
|
|
|
*optsize = sizeof(struct sctp_assoc_value);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2014-08-04 20:07:35 +00:00
|
|
|
case SCTP_RECONFIG_SUPPORTED:
|
|
|
|
{
|
|
|
|
struct sctp_assoc_value *av;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, av->assoc_id);
|
|
|
|
|
|
|
|
if (stcb) {
|
|
|
|
av->assoc_value = stcb->asoc.reconfig_supported;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(av->assoc_id == SCTP_FUTURE_ASSOC))) {
|
2014-08-04 20:07:35 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
av->assoc_value = inp->reconfig_supported;
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (error == 0) {
|
|
|
|
*optsize = sizeof(struct sctp_assoc_value);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2014-08-03 14:10:10 +00:00
|
|
|
case SCTP_NRSACK_SUPPORTED:
|
|
|
|
{
|
|
|
|
struct sctp_assoc_value *av;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, av->assoc_id);
|
|
|
|
|
|
|
|
if (stcb) {
|
|
|
|
av->assoc_value = stcb->asoc.nrsack_supported;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(av->assoc_id == SCTP_FUTURE_ASSOC))) {
|
2014-08-03 14:10:10 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
av->assoc_value = inp->nrsack_supported;
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (error == 0) {
|
|
|
|
*optsize = sizeof(struct sctp_assoc_value);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2014-08-03 18:12:55 +00:00
|
|
|
case SCTP_PKTDROP_SUPPORTED:
|
|
|
|
{
|
|
|
|
struct sctp_assoc_value *av;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, av->assoc_id);
|
|
|
|
|
|
|
|
if (stcb) {
|
|
|
|
av->assoc_value = stcb->asoc.pktdrop_supported;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(av->assoc_id == SCTP_FUTURE_ASSOC))) {
|
2014-08-03 18:12:55 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
av->assoc_value = inp->pktdrop_supported;
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (error == 0) {
|
|
|
|
*optsize = sizeof(struct sctp_assoc_value);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2012-05-04 17:18:02 +00:00
|
|
|
case SCTP_ENABLE_STREAM_RESET:
|
|
|
|
{
|
|
|
|
struct sctp_assoc_value *av;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, av->assoc_id);
|
|
|
|
|
|
|
|
if (stcb) {
|
2018-07-19 20:11:14 +00:00
|
|
|
av->assoc_value = (uint32_t)stcb->asoc.local_strreset_support;
|
2012-05-04 17:18:02 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(av->assoc_id == SCTP_FUTURE_ASSOC))) {
|
2012-05-04 17:18:02 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
2018-07-19 20:11:14 +00:00
|
|
|
av->assoc_value = (uint32_t)inp->local_strreset_support;
|
2012-05-04 17:18:02 +00:00
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (error == 0) {
|
|
|
|
*optsize = sizeof(struct sctp_assoc_value);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2014-08-13 15:50:16 +00:00
|
|
|
case SCTP_PR_STREAM_STATUS:
|
|
|
|
{
|
|
|
|
struct sctp_prstatus *sprstat;
|
|
|
|
uint16_t sid;
|
|
|
|
uint16_t policy;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(sprstat, optval, struct sctp_prstatus, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, sprstat->sprstat_assoc_id);
|
|
|
|
|
|
|
|
sid = sprstat->sprstat_sid;
|
|
|
|
policy = sprstat->sprstat_policy;
|
|
|
|
#if defined(SCTP_DETAILED_STR_STATS)
|
|
|
|
if ((stcb != NULL) &&
|
|
|
|
(sid < stcb->asoc.streamoutcnt) &&
|
2014-12-20 21:17:28 +00:00
|
|
|
(policy != SCTP_PR_SCTP_NONE) &&
|
|
|
|
((policy <= SCTP_PR_SCTP_MAX) ||
|
|
|
|
(policy == SCTP_PR_SCTP_ALL))) {
|
2014-08-13 15:50:16 +00:00
|
|
|
if (policy == SCTP_PR_SCTP_ALL) {
|
|
|
|
sprstat->sprstat_abandoned_unsent = stcb->asoc.strmout[sid].abandoned_unsent[0];
|
|
|
|
sprstat->sprstat_abandoned_sent = stcb->asoc.strmout[sid].abandoned_sent[0];
|
|
|
|
} else {
|
|
|
|
sprstat->sprstat_abandoned_unsent = stcb->asoc.strmout[sid].abandoned_unsent[policy];
|
|
|
|
sprstat->sprstat_abandoned_sent = stcb->asoc.strmout[sid].abandoned_sent[policy];
|
|
|
|
}
|
2014-12-20 13:47:38 +00:00
|
|
|
#else
|
|
|
|
if ((stcb != NULL) &&
|
2014-12-20 21:17:28 +00:00
|
|
|
(sid < stcb->asoc.streamoutcnt) &&
|
|
|
|
(policy == SCTP_PR_SCTP_ALL)) {
|
2014-12-20 13:47:38 +00:00
|
|
|
sprstat->sprstat_abandoned_unsent = stcb->asoc.strmout[sid].abandoned_unsent[0];
|
|
|
|
sprstat->sprstat_abandoned_sent = stcb->asoc.strmout[sid].abandoned_sent[0];
|
|
|
|
#endif
|
2014-08-13 15:50:16 +00:00
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
2017-09-09 20:44:56 +00:00
|
|
|
if (stcb != NULL) {
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
}
|
|
|
|
if (error == 0) {
|
|
|
|
*optsize = sizeof(struct sctp_prstatus);
|
|
|
|
}
|
2014-08-13 15:50:16 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case SCTP_PR_ASSOC_STATUS:
|
|
|
|
{
|
|
|
|
struct sctp_prstatus *sprstat;
|
|
|
|
uint16_t policy;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(sprstat, optval, struct sctp_prstatus, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, sprstat->sprstat_assoc_id);
|
|
|
|
|
|
|
|
policy = sprstat->sprstat_policy;
|
|
|
|
if ((stcb != NULL) &&
|
|
|
|
(policy != SCTP_PR_SCTP_NONE) &&
|
2014-12-20 21:17:28 +00:00
|
|
|
((policy <= SCTP_PR_SCTP_MAX) ||
|
|
|
|
(policy == SCTP_PR_SCTP_ALL))) {
|
2014-08-13 15:50:16 +00:00
|
|
|
if (policy == SCTP_PR_SCTP_ALL) {
|
|
|
|
sprstat->sprstat_abandoned_unsent = stcb->asoc.abandoned_unsent[0];
|
|
|
|
sprstat->sprstat_abandoned_sent = stcb->asoc.abandoned_sent[0];
|
|
|
|
} else {
|
|
|
|
sprstat->sprstat_abandoned_unsent = stcb->asoc.abandoned_unsent[policy];
|
|
|
|
sprstat->sprstat_abandoned_sent = stcb->asoc.abandoned_sent[policy];
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
2017-09-09 20:44:56 +00:00
|
|
|
if (stcb != NULL) {
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
}
|
|
|
|
if (error == 0) {
|
|
|
|
*optsize = sizeof(struct sctp_prstatus);
|
|
|
|
}
|
2014-08-13 15:50:16 +00:00
|
|
|
break;
|
|
|
|
}
|
2015-03-10 19:49:25 +00:00
|
|
|
case SCTP_MAX_CWND:
|
|
|
|
{
|
|
|
|
struct sctp_assoc_value *av;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, *optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, av->assoc_id);
|
|
|
|
|
|
|
|
if (stcb) {
|
|
|
|
av->assoc_value = stcb->asoc.max_cwnd;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(av->assoc_id == SCTP_FUTURE_ASSOC))) {
|
2015-03-10 19:49:25 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
av->assoc_value = inp->max_cwnd;
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (error == 0) {
|
|
|
|
*optsize = sizeof(struct sctp_assoc_value);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
default:
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOPROTOOPT);
|
|
|
|
error = ENOPROTOOPT;
|
|
|
|
break;
|
|
|
|
} /* end switch (sopt->sopt_name) */
|
|
|
|
if (error) {
|
|
|
|
*optsize = 0;
|
|
|
|
}
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
sctp_setopt(struct socket *so, int optname, void *optval, size_t optsize,
|
|
|
|
void *p)
|
|
|
|
{
|
2007-02-12 23:24:31 +00:00
|
|
|
int error, set_opt;
|
|
|
|
uint32_t *mopt;
|
2006-11-03 15:23:16 +00:00
|
|
|
struct sctp_tcb *stcb = NULL;
|
2007-08-24 00:53:53 +00:00
|
|
|
struct sctp_inpcb *inp = NULL;
|
2007-03-15 11:27:14 +00:00
|
|
|
uint32_t vrf_id;
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
if (optval == NULL) {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2006-11-03 15:23:16 +00:00
|
|
|
return (EINVAL);
|
|
|
|
}
|
|
|
|
inp = (struct sctp_inpcb *)so->so_pcb;
|
2012-03-15 14:22:05 +00:00
|
|
|
if (inp == NULL) {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2011-12-27 10:16:24 +00:00
|
|
|
return (EINVAL);
|
2007-03-15 11:27:14 +00:00
|
|
|
}
|
2007-04-03 11:15:32 +00:00
|
|
|
vrf_id = inp->def_vrf_id;
|
2006-11-03 15:23:16 +00:00
|
|
|
|
|
|
|
error = 0;
|
2007-02-12 23:24:31 +00:00
|
|
|
switch (optname) {
|
2006-11-03 15:23:16 +00:00
|
|
|
case SCTP_NODELAY:
|
|
|
|
case SCTP_AUTOCLOSE:
|
|
|
|
case SCTP_AUTO_ASCONF:
|
|
|
|
case SCTP_EXPLICIT_EOR:
|
|
|
|
case SCTP_DISABLE_FRAGMENTS:
|
|
|
|
case SCTP_USE_EXT_RCVINFO:
|
|
|
|
case SCTP_I_WANT_MAPPED_V4_ADDR:
|
|
|
|
/* copy in the option value */
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_CHECK_AND_CAST(mopt, optval, uint32_t, optsize);
|
2006-11-03 15:23:16 +00:00
|
|
|
set_opt = 0;
|
|
|
|
if (error)
|
|
|
|
break;
|
2007-02-12 23:24:31 +00:00
|
|
|
switch (optname) {
|
2006-11-03 15:23:16 +00:00
|
|
|
case SCTP_DISABLE_FRAGMENTS:
|
|
|
|
set_opt = SCTP_PCB_FLAGS_NO_FRAGMENT;
|
|
|
|
break;
|
|
|
|
case SCTP_AUTO_ASCONF:
|
2007-08-24 00:53:53 +00:00
|
|
|
/*
|
|
|
|
* NOTE: we don't really support this flag
|
|
|
|
*/
|
|
|
|
if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) {
|
|
|
|
/* only valid for bound all sockets */
|
2011-08-03 20:21:00 +00:00
|
|
|
if ((SCTP_BASE_SYSCTL(sctp_auto_asconf) == 0) &&
|
|
|
|
(*mopt != 0)) {
|
|
|
|
/* forbidden by admin */
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EPERM);
|
|
|
|
return (EPERM);
|
|
|
|
}
|
2007-08-24 00:53:53 +00:00
|
|
|
set_opt = SCTP_PCB_FLAGS_AUTO_ASCONF;
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
return (EINVAL);
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
break;
|
|
|
|
case SCTP_EXPLICIT_EOR:
|
|
|
|
set_opt = SCTP_PCB_FLAGS_EXPLICIT_EOR;
|
|
|
|
break;
|
|
|
|
case SCTP_USE_EXT_RCVINFO:
|
|
|
|
set_opt = SCTP_PCB_FLAGS_EXT_RCVINFO;
|
|
|
|
break;
|
|
|
|
case SCTP_I_WANT_MAPPED_V4_ADDR:
|
|
|
|
if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) {
|
|
|
|
set_opt = SCTP_PCB_FLAGS_NEEDS_MAPPED_V4;
|
|
|
|
} else {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2006-11-03 15:23:16 +00:00
|
|
|
return (EINVAL);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case SCTP_NODELAY:
|
|
|
|
set_opt = SCTP_PCB_FLAGS_NODELAY;
|
|
|
|
break;
|
|
|
|
case SCTP_AUTOCLOSE:
|
2007-05-28 11:17:24 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL)) {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2007-05-28 11:17:24 +00:00
|
|
|
return (EINVAL);
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
set_opt = SCTP_PCB_FLAGS_AUTOCLOSE;
|
|
|
|
/*
|
|
|
|
* The value is in ticks. Note this does not effect
|
|
|
|
* old associations, only new ones.
|
|
|
|
*/
|
2020-03-28 20:25:45 +00:00
|
|
|
inp->sctp_ep.auto_close_time = sctp_secs_to_ticks(*mopt);
|
2006-11-03 15:23:16 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
if (*mopt != 0) {
|
|
|
|
sctp_feature_on(inp, set_opt);
|
|
|
|
} else {
|
|
|
|
sctp_feature_off(inp, set_opt);
|
|
|
|
}
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
|
|
|
break;
|
2008-07-31 11:08:30 +00:00
|
|
|
case SCTP_REUSE_PORT:
|
|
|
|
{
|
|
|
|
SCTP_CHECK_AND_CAST(mopt, optval, uint32_t, optsize);
|
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_UNBOUND) == 0) {
|
|
|
|
/* Can't set it after we are bound */
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE)) {
|
|
|
|
/* Can't do this for a 1-m socket */
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (optval)
|
|
|
|
sctp_feature_on(inp, SCTP_PCB_FLAGS_PORTREUSE);
|
|
|
|
else
|
|
|
|
sctp_feature_off(inp, SCTP_PCB_FLAGS_PORTREUSE);
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2008-07-31 11:08:30 +00:00
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
case SCTP_PARTIAL_DELIVERY_POINT:
|
|
|
|
{
|
2007-02-12 23:24:31 +00:00
|
|
|
uint32_t *value;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(value, optval, uint32_t, optsize);
|
2007-03-20 10:23:11 +00:00
|
|
|
if (*value > SCTP_SB_LIMIT_RCV(so)) {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2007-03-20 10:23:11 +00:00
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
2007-02-12 23:24:31 +00:00
|
|
|
inp->partial_delivery_point = *value;
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
case SCTP_FRAGMENT_INTERLEAVE:
|
|
|
|
/* not yet until we re-write sctp_recvmsg() */
|
|
|
|
{
|
2007-04-22 11:06:27 +00:00
|
|
|
uint32_t *level;
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2007-04-22 11:06:27 +00:00
|
|
|
SCTP_CHECK_AND_CAST(level, optval, uint32_t, optsize);
|
|
|
|
if (*level == SCTP_FRAG_LEVEL_2) {
|
2006-11-03 15:23:16 +00:00
|
|
|
sctp_feature_on(inp, SCTP_PCB_FLAGS_FRAG_INTERLEAVE);
|
2007-04-22 11:06:27 +00:00
|
|
|
sctp_feature_on(inp, SCTP_PCB_FLAGS_INTERLEAVE_STRMS);
|
|
|
|
} else if (*level == SCTP_FRAG_LEVEL_1) {
|
|
|
|
sctp_feature_on(inp, SCTP_PCB_FLAGS_FRAG_INTERLEAVE);
|
|
|
|
sctp_feature_off(inp, SCTP_PCB_FLAGS_INTERLEAVE_STRMS);
|
|
|
|
} else if (*level == SCTP_FRAG_LEVEL_0) {
|
2007-05-28 11:17:24 +00:00
|
|
|
sctp_feature_off(inp, SCTP_PCB_FLAGS_FRAG_INTERLEAVE);
|
2007-04-22 11:06:27 +00:00
|
|
|
sctp_feature_off(inp, SCTP_PCB_FLAGS_INTERLEAVE_STRMS);
|
|
|
|
|
2006-11-03 15:23:16 +00:00
|
|
|
} else {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2007-04-22 11:06:27 +00:00
|
|
|
error = EINVAL;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2016-04-07 09:10:34 +00:00
|
|
|
case SCTP_INTERLEAVING_SUPPORTED:
|
|
|
|
{
|
|
|
|
struct sctp_assoc_value *av;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, av->assoc_id);
|
|
|
|
|
|
|
|
if (stcb) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(av->assoc_id == SCTP_FUTURE_ASSOC))) {
|
2016-04-07 09:10:34 +00:00
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
if (av->assoc_value == 0) {
|
|
|
|
inp->idata_supported = 0;
|
|
|
|
} else {
|
|
|
|
if ((sctp_is_feature_on(inp, SCTP_PCB_FLAGS_FRAG_INTERLEAVE)) &&
|
|
|
|
(sctp_is_feature_on(inp, SCTP_PCB_FLAGS_INTERLEAVE_STRMS))) {
|
|
|
|
inp->idata_supported = 1;
|
|
|
|
} else {
|
2016-12-26 11:06:41 +00:00
|
|
|
/*
|
|
|
|
* Must have Frag
|
2016-04-07 09:10:34 +00:00
|
|
|
* interleave and
|
|
|
|
* stream interleave
|
2016-12-26 11:06:41 +00:00
|
|
|
* on
|
|
|
|
*/
|
2016-04-07 09:10:34 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
case SCTP_CMT_ON_OFF:
|
2010-08-28 17:59:51 +00:00
|
|
|
if (SCTP_BASE_SYSCTL(sctp_cmt_on_off)) {
|
2006-11-03 15:23:16 +00:00
|
|
|
struct sctp_assoc_value *av;
|
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, optsize);
|
2011-06-15 23:50:27 +00:00
|
|
|
if (av->assoc_value > SCTP_CMT_MAX) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
2010-08-28 17:59:51 +00:00
|
|
|
SCTP_FIND_STCB(inp, stcb, av->assoc_id);
|
|
|
|
if (stcb) {
|
2011-06-15 23:50:27 +00:00
|
|
|
stcb->asoc.sctp_cmt_on_off = av->assoc_value;
|
2010-08-28 17:59:51 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
2008-12-06 13:19:54 +00:00
|
|
|
} else {
|
2011-08-16 21:04:18 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
((av->assoc_id == SCTP_FUTURE_ASSOC) ||
|
|
|
|
(av->assoc_id == SCTP_ALL_ASSOC)))) {
|
2011-05-04 21:27:05 +00:00
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
inp->sctp_cmt_on_off = av->assoc_value;
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
2010-12-22 17:59:38 +00:00
|
|
|
}
|
2019-11-28 12:50:25 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
((av->assoc_id == SCTP_CURRENT_ASSOC) ||
|
|
|
|
(av->assoc_id == SCTP_ALL_ASSOC))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
|
|
|
|
SCTP_TCB_LOCK(stcb);
|
|
|
|
stcb->asoc.sctp_cmt_on_off = av->assoc_value;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
}
|
2011-08-16 21:04:18 +00:00
|
|
|
SCTP_INP_RUNLOCK(inp);
|
2011-06-15 23:50:27 +00:00
|
|
|
}
|
2008-12-06 13:19:54 +00:00
|
|
|
}
|
2010-08-28 17:59:51 +00:00
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOPROTOOPT);
|
|
|
|
error = ENOPROTOOPT;
|
2008-12-06 13:19:54 +00:00
|
|
|
}
|
|
|
|
break;
|
2007-07-14 09:36:28 +00:00
|
|
|
case SCTP_PLUGGABLE_CC:
|
|
|
|
{
|
|
|
|
struct sctp_assoc_value *av;
|
2011-02-26 15:23:46 +00:00
|
|
|
struct sctp_nets *net;
|
2007-07-14 09:36:28 +00:00
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, optsize);
|
2011-06-15 23:50:27 +00:00
|
|
|
if ((av->assoc_value != SCTP_CC_RFC2581) &&
|
|
|
|
(av->assoc_value != SCTP_CC_HSTCP) &&
|
|
|
|
(av->assoc_value != SCTP_CC_HTCP) &&
|
|
|
|
(av->assoc_value != SCTP_CC_RTCC)) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
2007-07-14 09:36:28 +00:00
|
|
|
SCTP_FIND_STCB(inp, stcb, av->assoc_id);
|
|
|
|
if (stcb) {
|
2011-06-15 23:50:27 +00:00
|
|
|
stcb->asoc.cc_functions = sctp_cc_functions[av->assoc_value];
|
|
|
|
stcb->asoc.congestion_control_module = av->assoc_value;
|
|
|
|
if (stcb->asoc.cc_functions.sctp_set_initial_cc_param != NULL) {
|
|
|
|
TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
|
|
|
|
stcb->asoc.cc_functions.sctp_set_initial_cc_param(stcb, net);
|
2011-02-26 15:23:46 +00:00
|
|
|
}
|
2007-07-14 09:36:28 +00:00
|
|
|
}
|
2011-01-19 22:10:35 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
2007-07-14 09:36:28 +00:00
|
|
|
} else {
|
2011-08-16 21:04:18 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
((av->assoc_id == SCTP_FUTURE_ASSOC) ||
|
|
|
|
(av->assoc_id == SCTP_ALL_ASSOC)))) {
|
2011-01-19 22:10:35 +00:00
|
|
|
SCTP_INP_WLOCK(inp);
|
2007-07-14 09:36:28 +00:00
|
|
|
inp->sctp_ep.sctp_default_cc_module = av->assoc_value;
|
2011-01-19 22:10:35 +00:00
|
|
|
SCTP_INP_WUNLOCK(inp);
|
2011-06-15 23:50:27 +00:00
|
|
|
}
|
2019-11-28 12:50:25 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
((av->assoc_id == SCTP_CURRENT_ASSOC) ||
|
|
|
|
(av->assoc_id == SCTP_ALL_ASSOC))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
|
|
|
|
SCTP_TCB_LOCK(stcb);
|
|
|
|
stcb->asoc.cc_functions = sctp_cc_functions[av->assoc_value];
|
|
|
|
stcb->asoc.congestion_control_module = av->assoc_value;
|
|
|
|
if (stcb->asoc.cc_functions.sctp_set_initial_cc_param != NULL) {
|
|
|
|
TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
|
|
|
|
stcb->asoc.cc_functions.sctp_set_initial_cc_param(stcb, net);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
}
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
2011-01-23 19:36:28 +00:00
|
|
|
}
|
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2011-01-23 19:36:28 +00:00
|
|
|
}
|
2011-02-26 15:23:46 +00:00
|
|
|
case SCTP_CC_OPTION:
|
|
|
|
{
|
|
|
|
struct sctp_cc_option *cc_opt;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(cc_opt, optval, struct sctp_cc_option, optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, cc_opt->aid_value.assoc_id);
|
|
|
|
if (stcb == NULL) {
|
2019-11-28 12:50:25 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(cc_opt->aid_value.assoc_id == SCTP_CURRENT_ASSOC)) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
|
|
|
|
SCTP_TCB_LOCK(stcb);
|
|
|
|
if (stcb->asoc.cc_functions.sctp_cwnd_socket_option) {
|
|
|
|
(*stcb->asoc.cc_functions.sctp_cwnd_socket_option) (stcb, 1, cc_opt);
|
|
|
|
}
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
}
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
} else {
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
2011-02-26 15:23:46 +00:00
|
|
|
} else {
|
|
|
|
if (stcb->asoc.cc_functions.sctp_cwnd_socket_option == NULL) {
|
|
|
|
error = ENOTSUP;
|
|
|
|
} else {
|
|
|
|
error = (*stcb->asoc.cc_functions.sctp_cwnd_socket_option) (stcb, 1,
|
|
|
|
cc_opt);
|
|
|
|
}
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2011-02-26 15:23:46 +00:00
|
|
|
}
|
2011-01-23 19:36:28 +00:00
|
|
|
case SCTP_PLUGGABLE_SS:
|
|
|
|
{
|
|
|
|
struct sctp_assoc_value *av;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, optsize);
|
2011-06-15 23:50:27 +00:00
|
|
|
if ((av->assoc_value != SCTP_SS_DEFAULT) &&
|
|
|
|
(av->assoc_value != SCTP_SS_ROUND_ROBIN) &&
|
|
|
|
(av->assoc_value != SCTP_SS_ROUND_ROBIN_PACKET) &&
|
|
|
|
(av->assoc_value != SCTP_SS_PRIORITY) &&
|
|
|
|
(av->assoc_value != SCTP_SS_FAIR_BANDWITH) &&
|
|
|
|
(av->assoc_value != SCTP_SS_FIRST_COME)) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
2011-01-23 19:36:28 +00:00
|
|
|
SCTP_FIND_STCB(inp, stcb, av->assoc_id);
|
|
|
|
if (stcb) {
|
2019-03-08 18:17:57 +00:00
|
|
|
SCTP_TCB_SEND_LOCK(stcb);
|
2011-06-15 23:50:27 +00:00
|
|
|
stcb->asoc.ss_functions.sctp_ss_clear(stcb, &stcb->asoc, 1, 1);
|
|
|
|
stcb->asoc.ss_functions = sctp_ss_functions[av->assoc_value];
|
|
|
|
stcb->asoc.stream_scheduling_module = av->assoc_value;
|
|
|
|
stcb->asoc.ss_functions.sctp_ss_init(stcb, &stcb->asoc, 1);
|
2019-03-08 18:17:57 +00:00
|
|
|
SCTP_TCB_SEND_UNLOCK(stcb);
|
2011-01-23 19:36:28 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
2011-08-16 21:04:18 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
((av->assoc_id == SCTP_FUTURE_ASSOC) ||
|
|
|
|
(av->assoc_id == SCTP_ALL_ASSOC)))) {
|
2011-01-23 19:36:28 +00:00
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
inp->sctp_ep.sctp_default_ss_module = av->assoc_value;
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
2011-06-15 23:50:27 +00:00
|
|
|
}
|
2019-11-28 12:50:25 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
((av->assoc_id == SCTP_CURRENT_ASSOC) ||
|
|
|
|
(av->assoc_id == SCTP_ALL_ASSOC))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
|
|
|
|
SCTP_TCB_LOCK(stcb);
|
2019-03-08 18:17:57 +00:00
|
|
|
SCTP_TCB_SEND_LOCK(stcb);
|
2011-06-15 23:50:27 +00:00
|
|
|
stcb->asoc.ss_functions.sctp_ss_clear(stcb, &stcb->asoc, 1, 1);
|
|
|
|
stcb->asoc.ss_functions = sctp_ss_functions[av->assoc_value];
|
|
|
|
stcb->asoc.stream_scheduling_module = av->assoc_value;
|
|
|
|
stcb->asoc.ss_functions.sctp_ss_init(stcb, &stcb->asoc, 1);
|
2019-03-08 18:17:57 +00:00
|
|
|
SCTP_TCB_SEND_UNLOCK(stcb);
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
}
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
2011-01-23 19:36:28 +00:00
|
|
|
}
|
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2011-01-23 19:36:28 +00:00
|
|
|
}
|
|
|
|
case SCTP_SS_VALUE:
|
|
|
|
{
|
|
|
|
struct sctp_stream_value *av;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(av, optval, struct sctp_stream_value, optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, av->assoc_id);
|
|
|
|
if (stcb) {
|
2015-01-27 19:35:36 +00:00
|
|
|
if ((av->stream_id >= stcb->asoc.streamoutcnt) ||
|
|
|
|
(stcb->asoc.ss_functions.sctp_ss_set_value(stcb, &stcb->asoc, &stcb->asoc.strmout[av->stream_id],
|
|
|
|
av->stream_value) < 0)) {
|
2011-01-23 19:36:28 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
2019-11-28 12:50:25 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(av->assoc_id == SCTP_CURRENT_ASSOC)) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
|
|
|
|
SCTP_TCB_LOCK(stcb);
|
2015-01-27 19:35:36 +00:00
|
|
|
if (av->stream_id < stcb->asoc.streamoutcnt) {
|
|
|
|
stcb->asoc.ss_functions.sctp_ss_set_value(stcb,
|
|
|
|
&stcb->asoc,
|
|
|
|
&stcb->asoc.strmout[av->stream_id],
|
|
|
|
av->stream_value);
|
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
}
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
} else {
|
2016-12-26 11:06:41 +00:00
|
|
|
/*
|
|
|
|
* Can't set stream value without
|
|
|
|
* association
|
|
|
|
*/
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
2007-07-14 09:36:28 +00:00
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2007-07-14 09:36:28 +00:00
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
case SCTP_CLR_STAT_LOG:
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EOPNOTSUPP);
|
2006-11-03 15:23:16 +00:00
|
|
|
error = EOPNOTSUPP;
|
|
|
|
break;
|
|
|
|
case SCTP_CONTEXT:
|
|
|
|
{
|
|
|
|
struct sctp_assoc_value *av;
|
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, av->assoc_id);
|
|
|
|
|
|
|
|
if (stcb) {
|
|
|
|
stcb->asoc.context = av->assoc_value;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
2006-11-03 15:23:16 +00:00
|
|
|
} else {
|
2011-08-16 21:04:18 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
((av->assoc_id == SCTP_FUTURE_ASSOC) ||
|
|
|
|
(av->assoc_id == SCTP_ALL_ASSOC)))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
inp->sctp_context = av->assoc_value;
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
|
|
|
}
|
2019-11-28 12:50:25 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
((av->assoc_id == SCTP_CURRENT_ASSOC) ||
|
|
|
|
(av->assoc_id == SCTP_ALL_ASSOC))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
|
|
|
|
SCTP_TCB_LOCK(stcb);
|
|
|
|
stcb->asoc.context = av->assoc_value;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
}
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2007-03-15 11:27:14 +00:00
|
|
|
case SCTP_VRF_ID:
|
|
|
|
{
|
2007-05-28 11:17:24 +00:00
|
|
|
uint32_t *default_vrfid;
|
2007-03-15 11:27:14 +00:00
|
|
|
|
2007-05-28 11:17:24 +00:00
|
|
|
SCTP_CHECK_AND_CAST(default_vrfid, optval, uint32_t, optsize);
|
|
|
|
if (*default_vrfid > SCTP_MAX_VRF_ID) {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2007-03-15 11:27:14 +00:00
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
2007-05-28 11:17:24 +00:00
|
|
|
inp->def_vrf_id = *default_vrfid;
|
2007-03-15 11:27:14 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case SCTP_DEL_VRF_ID:
|
|
|
|
{
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EOPNOTSUPP);
|
2007-03-15 11:27:14 +00:00
|
|
|
error = EOPNOTSUPP;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case SCTP_ADD_VRF_ID:
|
|
|
|
{
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EOPNOTSUPP);
|
2007-03-15 11:27:14 +00:00
|
|
|
error = EOPNOTSUPP;
|
|
|
|
break;
|
|
|
|
}
|
2007-05-28 11:17:24 +00:00
|
|
|
case SCTP_DELAYED_SACK:
|
2006-11-03 15:23:16 +00:00
|
|
|
{
|
2007-05-28 11:17:24 +00:00
|
|
|
struct sctp_sack_info *sack;
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2007-05-28 11:17:24 +00:00
|
|
|
SCTP_CHECK_AND_CAST(sack, optval, struct sctp_sack_info, optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, sack->sack_assoc_id);
|
2007-07-17 20:58:26 +00:00
|
|
|
if (sack->sack_delay) {
|
2020-03-28 20:25:45 +00:00
|
|
|
if (sack->sack_delay > SCTP_MAX_SACK_DELAY) {
|
|
|
|
error = EINVAL;
|
|
|
|
if (stcb != NULL) {
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
}
|
|
|
|
break;
|
2011-06-15 23:50:27 +00:00
|
|
|
}
|
2007-07-17 20:58:26 +00:00
|
|
|
}
|
2007-02-12 23:24:31 +00:00
|
|
|
if (stcb) {
|
2007-05-28 11:17:24 +00:00
|
|
|
if (sack->sack_delay) {
|
|
|
|
stcb->asoc.delayed_ack = sack->sack_delay;
|
|
|
|
}
|
|
|
|
if (sack->sack_freq) {
|
|
|
|
stcb->asoc.sack_freq = sack->sack_freq;
|
|
|
|
}
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
2011-08-16 21:04:18 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
((sack->sack_assoc_id == SCTP_FUTURE_ASSOC) ||
|
|
|
|
(sack->sack_assoc_id == SCTP_ALL_ASSOC)))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
if (sack->sack_delay) {
|
2020-03-28 20:25:45 +00:00
|
|
|
inp->sctp_ep.sctp_timeoutticks[SCTP_TIMER_RECV] = sctp_msecs_to_ticks(sack->sack_delay);
|
2007-05-28 11:17:24 +00:00
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
if (sack->sack_freq) {
|
|
|
|
inp->sctp_ep.sctp_sack_freq = sack->sack_freq;
|
|
|
|
}
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
2007-05-28 11:17:24 +00:00
|
|
|
}
|
2019-11-28 12:50:25 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
((sack->sack_assoc_id == SCTP_CURRENT_ASSOC) ||
|
|
|
|
(sack->sack_assoc_id == SCTP_ALL_ASSOC))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
|
|
|
|
SCTP_TCB_LOCK(stcb);
|
|
|
|
if (sack->sack_delay) {
|
|
|
|
stcb->asoc.delayed_ack = sack->sack_delay;
|
|
|
|
}
|
|
|
|
if (sack->sack_freq) {
|
|
|
|
stcb->asoc.sack_freq = sack->sack_freq;
|
|
|
|
}
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
}
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
2007-05-28 11:17:24 +00:00
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2007-02-12 23:24:31 +00:00
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
case SCTP_AUTH_CHUNK:
|
|
|
|
{
|
|
|
|
struct sctp_authchunk *sauth;
|
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_CHECK_AND_CAST(sauth, optval, struct sctp_authchunk, optsize);
|
|
|
|
|
|
|
|
SCTP_INP_WLOCK(inp);
|
2007-08-24 00:53:53 +00:00
|
|
|
if (sctp_auth_add_chunk(sauth->sauth_chunk, inp->sctp_ep.local_auth_chunks)) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2006-11-03 15:23:16 +00:00
|
|
|
error = EINVAL;
|
2018-06-06 19:27:06 +00:00
|
|
|
} else {
|
|
|
|
inp->auth_supported = 1;
|
2007-08-24 00:53:53 +00:00
|
|
|
}
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_INP_WUNLOCK(inp);
|
2006-11-03 15:23:16 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case SCTP_AUTH_KEY:
|
|
|
|
{
|
|
|
|
struct sctp_authkey *sca;
|
|
|
|
struct sctp_keyhead *shared_keys;
|
|
|
|
sctp_sharedkey_t *shared_key;
|
|
|
|
sctp_key_t *key = NULL;
|
2007-02-12 23:24:31 +00:00
|
|
|
size_t size;
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_CHECK_AND_CAST(sca, optval, struct sctp_authkey, optsize);
|
2011-06-30 16:56:55 +00:00
|
|
|
if (sca->sca_keylength == 0) {
|
|
|
|
size = optsize - sizeof(struct sctp_authkey);
|
|
|
|
} else {
|
|
|
|
if (sca->sca_keylength + sizeof(struct sctp_authkey) <= optsize) {
|
|
|
|
size = sca->sca_keylength;
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2007-05-09 13:30:06 +00:00
|
|
|
SCTP_FIND_STCB(inp, stcb, sca->sca_assoc_id);
|
2007-02-12 23:24:31 +00:00
|
|
|
|
|
|
|
if (stcb) {
|
2006-11-03 15:23:16 +00:00
|
|
|
shared_keys = &stcb->asoc.shared_keys;
|
|
|
|
/* clear the cached keys for this key id */
|
|
|
|
sctp_clear_cachedkeys(stcb, sca->sca_keynumber);
|
|
|
|
/*
|
|
|
|
* create the new shared key and
|
|
|
|
* insert/replace it
|
|
|
|
*/
|
|
|
|
if (size > 0) {
|
2018-07-19 20:11:14 +00:00
|
|
|
key = sctp_set_key(sca->sca_key, (uint32_t)size);
|
2006-11-03 15:23:16 +00:00
|
|
|
if (key == NULL) {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOMEM);
|
2006-11-03 15:23:16 +00:00
|
|
|
error = ENOMEM;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
shared_key = sctp_alloc_sharedkey();
|
|
|
|
if (shared_key == NULL) {
|
|
|
|
sctp_free_key(key);
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOMEM);
|
2006-11-03 15:23:16 +00:00
|
|
|
error = ENOMEM;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
shared_key->key = key;
|
|
|
|
shared_key->keyid = sca->sca_keynumber;
|
2008-12-06 13:19:54 +00:00
|
|
|
error = sctp_insert_sharedkey(shared_keys, shared_key);
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
2011-08-16 21:04:18 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
((sca->sca_assoc_id == SCTP_FUTURE_ASSOC) ||
|
|
|
|
(sca->sca_assoc_id == SCTP_ALL_ASSOC)))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
shared_keys = &inp->sctp_ep.shared_keys;
|
|
|
|
/*
|
|
|
|
* clear the cached keys on all
|
|
|
|
* assocs for this key id
|
|
|
|
*/
|
|
|
|
sctp_clear_cachedkeys_ep(inp, sca->sca_keynumber);
|
|
|
|
/*
|
|
|
|
* create the new shared key and
|
|
|
|
* insert/replace it
|
|
|
|
*/
|
|
|
|
if (size > 0) {
|
2018-07-19 20:11:14 +00:00
|
|
|
key = sctp_set_key(sca->sca_key, (uint32_t)size);
|
2011-06-15 23:50:27 +00:00
|
|
|
if (key == NULL) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOMEM);
|
|
|
|
error = ENOMEM;
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
shared_key = sctp_alloc_sharedkey();
|
|
|
|
if (shared_key == NULL) {
|
|
|
|
sctp_free_key(key);
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOMEM);
|
2006-11-03 15:23:16 +00:00
|
|
|
error = ENOMEM;
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
|
|
|
break;
|
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
shared_key->key = key;
|
|
|
|
shared_key->keyid = sca->sca_keynumber;
|
|
|
|
error = sctp_insert_sharedkey(shared_keys, shared_key);
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_INP_WUNLOCK(inp);
|
|
|
|
}
|
2019-11-28 12:50:25 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
((sca->sca_assoc_id == SCTP_CURRENT_ASSOC) ||
|
|
|
|
(sca->sca_assoc_id == SCTP_ALL_ASSOC))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
|
|
|
|
SCTP_TCB_LOCK(stcb);
|
|
|
|
shared_keys = &stcb->asoc.shared_keys;
|
2016-12-26 11:06:41 +00:00
|
|
|
/*
|
|
|
|
* clear the cached keys for
|
|
|
|
* this key id
|
|
|
|
*/
|
2011-06-15 23:50:27 +00:00
|
|
|
sctp_clear_cachedkeys(stcb, sca->sca_keynumber);
|
|
|
|
/*
|
|
|
|
* create the new shared key
|
|
|
|
* and insert/replace it
|
|
|
|
*/
|
|
|
|
if (size > 0) {
|
2018-07-19 20:11:14 +00:00
|
|
|
key = sctp_set_key(sca->sca_key, (uint32_t)size);
|
2011-06-15 23:50:27 +00:00
|
|
|
if (key == NULL) {
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
shared_key = sctp_alloc_sharedkey();
|
|
|
|
if (shared_key == NULL) {
|
|
|
|
sctp_free_key(key);
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
shared_key->key = key;
|
|
|
|
shared_key->keyid = sca->sca_keynumber;
|
|
|
|
error = sctp_insert_sharedkey(shared_keys, shared_key);
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
}
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case SCTP_HMAC_IDENT:
|
|
|
|
{
|
|
|
|
struct sctp_hmacalgo *shmac;
|
|
|
|
sctp_hmaclist_t *hmaclist;
|
2008-07-31 11:08:30 +00:00
|
|
|
uint16_t hmacid;
|
|
|
|
uint32_t i;
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_CHECK_AND_CAST(shmac, optval, struct sctp_hmacalgo, optsize);
|
2014-09-16 14:20:33 +00:00
|
|
|
if ((optsize < sizeof(struct sctp_hmacalgo) + shmac->shmac_number_of_idents * sizeof(uint16_t)) ||
|
|
|
|
(shmac->shmac_number_of_idents > 0xffff)) {
|
2008-07-31 11:08:30 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
2018-07-19 20:16:33 +00:00
|
|
|
|
2018-07-19 20:11:14 +00:00
|
|
|
hmaclist = sctp_alloc_hmaclist((uint16_t)shmac->shmac_number_of_idents);
|
2006-11-03 15:23:16 +00:00
|
|
|
if (hmaclist == NULL) {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOMEM);
|
2006-11-03 15:23:16 +00:00
|
|
|
error = ENOMEM;
|
|
|
|
break;
|
|
|
|
}
|
2008-07-31 11:08:30 +00:00
|
|
|
for (i = 0; i < shmac->shmac_number_of_idents; i++) {
|
2006-11-03 15:23:16 +00:00
|
|
|
hmacid = shmac->shmac_idents[i];
|
2008-07-31 11:08:30 +00:00
|
|
|
if (sctp_auth_add_hmacid(hmaclist, hmacid)) {
|
2006-11-03 15:23:16 +00:00
|
|
|
/* invalid HMACs were found */ ;
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2006-11-03 15:23:16 +00:00
|
|
|
error = EINVAL;
|
2006-11-08 00:21:13 +00:00
|
|
|
sctp_free_hmaclist(hmaclist);
|
2006-11-03 15:23:16 +00:00
|
|
|
goto sctp_set_hmac_done;
|
|
|
|
}
|
|
|
|
}
|
2007-05-28 11:17:24 +00:00
|
|
|
for (i = 0; i < hmaclist->num_algo; i++) {
|
|
|
|
if (hmaclist->hmac[i] == SCTP_AUTH_HMAC_ID_SHA1) {
|
|
|
|
/* already in list */
|
2013-08-01 12:05:23 +00:00
|
|
|
break;
|
2007-05-28 11:17:24 +00:00
|
|
|
}
|
|
|
|
}
|
2013-08-01 12:05:23 +00:00
|
|
|
if (i == hmaclist->num_algo) {
|
|
|
|
/* not found in list */
|
2007-05-28 11:17:24 +00:00
|
|
|
sctp_free_hmaclist(hmaclist);
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2007-05-28 11:17:24 +00:00
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
/* set it on the endpoint */
|
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
if (inp->sctp_ep.local_hmacs)
|
|
|
|
sctp_free_hmaclist(inp->sctp_ep.local_hmacs);
|
|
|
|
inp->sctp_ep.local_hmacs = hmaclist;
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
|
|
|
sctp_set_hmac_done:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case SCTP_AUTH_ACTIVE_KEY:
|
|
|
|
{
|
|
|
|
struct sctp_authkeyid *scact;
|
|
|
|
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_CHECK_AND_CAST(scact, optval, struct sctp_authkeyid, optsize);
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_FIND_STCB(inp, stcb, scact->scact_assoc_id);
|
|
|
|
|
2006-11-03 15:23:16 +00:00
|
|
|
/* set the active key on the right place */
|
2007-02-12 23:24:31 +00:00
|
|
|
if (stcb) {
|
2006-11-03 15:23:16 +00:00
|
|
|
/* set the active key on the assoc */
|
2008-12-06 13:19:54 +00:00
|
|
|
if (sctp_auth_setactivekey(stcb,
|
|
|
|
scact->scact_keynumber)) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL,
|
|
|
|
SCTP_FROM_SCTP_USRREQ,
|
|
|
|
EINVAL);
|
2006-11-03 15:23:16 +00:00
|
|
|
error = EINVAL;
|
2007-08-24 00:53:53 +00:00
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
2011-08-16 21:04:18 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
((scact->scact_assoc_id == SCTP_FUTURE_ASSOC) ||
|
|
|
|
(scact->scact_assoc_id == SCTP_ALL_ASSOC)))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
if (sctp_auth_setactivekey_ep(inp, scact->scact_keynumber)) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
|
|
|
}
|
2019-11-28 12:50:25 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
((scact->scact_assoc_id == SCTP_CURRENT_ASSOC) ||
|
|
|
|
(scact->scact_assoc_id == SCTP_ALL_ASSOC))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
|
|
|
|
SCTP_TCB_LOCK(stcb);
|
|
|
|
sctp_auth_setactivekey(stcb, scact->scact_keynumber);
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
}
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
2007-08-24 00:53:53 +00:00
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case SCTP_AUTH_DELETE_KEY:
|
|
|
|
{
|
|
|
|
struct sctp_authkeyid *scdel;
|
|
|
|
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_CHECK_AND_CAST(scdel, optval, struct sctp_authkeyid, optsize);
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_FIND_STCB(inp, stcb, scdel->scact_assoc_id);
|
|
|
|
|
2006-11-03 15:23:16 +00:00
|
|
|
/* delete the key from the right place */
|
2007-02-12 23:24:31 +00:00
|
|
|
if (stcb) {
|
2011-06-15 23:50:27 +00:00
|
|
|
if (sctp_delete_sharedkey(stcb, scdel->scact_keynumber)) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2006-11-03 15:23:16 +00:00
|
|
|
error = EINVAL;
|
2007-08-24 00:53:53 +00:00
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
2011-08-16 21:04:18 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
((scdel->scact_assoc_id == SCTP_FUTURE_ASSOC) ||
|
|
|
|
(scdel->scact_assoc_id == SCTP_ALL_ASSOC)))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
if (sctp_delete_sharedkey_ep(inp, scdel->scact_keynumber)) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
|
|
|
}
|
2019-11-28 12:50:25 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
((scdel->scact_assoc_id == SCTP_CURRENT_ASSOC) ||
|
|
|
|
(scdel->scact_assoc_id == SCTP_ALL_ASSOC))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
|
|
|
|
SCTP_TCB_LOCK(stcb);
|
|
|
|
sctp_delete_sharedkey(stcb, scdel->scact_keynumber);
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
}
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
2008-12-06 13:19:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case SCTP_AUTH_DEACTIVATE_KEY:
|
|
|
|
{
|
|
|
|
struct sctp_authkeyid *keyid;
|
|
|
|
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_CHECK_AND_CAST(keyid, optval, struct sctp_authkeyid, optsize);
|
2008-12-06 13:19:54 +00:00
|
|
|
SCTP_FIND_STCB(inp, stcb, keyid->scact_assoc_id);
|
|
|
|
|
|
|
|
/* deactivate the key from the right place */
|
|
|
|
if (stcb) {
|
2011-06-15 23:50:27 +00:00
|
|
|
if (sctp_deact_sharedkey(stcb, keyid->scact_keynumber)) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2008-12-06 13:19:54 +00:00
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
2011-08-16 21:04:18 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
((keyid->scact_assoc_id == SCTP_FUTURE_ASSOC) ||
|
|
|
|
(keyid->scact_assoc_id == SCTP_ALL_ASSOC)))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
if (sctp_deact_sharedkey_ep(inp, keyid->scact_keynumber)) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
|
|
|
}
|
2019-11-28 12:50:25 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
((keyid->scact_assoc_id == SCTP_CURRENT_ASSOC) ||
|
|
|
|
(keyid->scact_assoc_id == SCTP_ALL_ASSOC))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
|
|
|
|
SCTP_TCB_LOCK(stcb);
|
|
|
|
sctp_deact_sharedkey(stcb, keyid->scact_keynumber);
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
}
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
2007-08-24 00:53:53 +00:00
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2012-03-29 13:36:53 +00:00
|
|
|
case SCTP_ENABLE_STREAM_RESET:
|
|
|
|
{
|
|
|
|
struct sctp_assoc_value *av;
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2012-03-29 13:36:53 +00:00
|
|
|
SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, optsize);
|
|
|
|
if (av->assoc_value & (~SCTP_ENABLE_VALUE_MASK)) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
SCTP_FIND_STCB(inp, stcb, av->assoc_id);
|
|
|
|
if (stcb) {
|
2018-07-19 20:11:14 +00:00
|
|
|
stcb->asoc.local_strreset_support = (uint8_t)av->assoc_value;
|
2012-03-29 13:36:53 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
((av->assoc_id == SCTP_FUTURE_ASSOC) ||
|
|
|
|
(av->assoc_id == SCTP_ALL_ASSOC)))) {
|
2012-03-29 13:36:53 +00:00
|
|
|
SCTP_INP_WLOCK(inp);
|
2018-07-19 20:11:14 +00:00
|
|
|
inp->local_strreset_support = (uint8_t)av->assoc_value;
|
2012-03-29 13:36:53 +00:00
|
|
|
SCTP_INP_WUNLOCK(inp);
|
|
|
|
}
|
2019-11-28 12:50:25 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
((av->assoc_id == SCTP_CURRENT_ASSOC) ||
|
|
|
|
(av->assoc_id == SCTP_ALL_ASSOC))) {
|
2012-03-29 13:36:53 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
|
|
|
|
SCTP_TCB_LOCK(stcb);
|
2018-07-19 20:11:14 +00:00
|
|
|
stcb->asoc.local_strreset_support = (uint8_t)av->assoc_value;
|
2012-03-29 13:36:53 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
}
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
case SCTP_RESET_STREAMS:
|
|
|
|
{
|
2012-03-29 13:36:53 +00:00
|
|
|
struct sctp_reset_streams *strrst;
|
|
|
|
int i, send_out = 0;
|
|
|
|
int send_in = 0;
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2012-03-29 13:36:53 +00:00
|
|
|
SCTP_CHECK_AND_CAST(strrst, optval, struct sctp_reset_streams, optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, strrst->srs_assoc_id);
|
2006-11-03 15:23:16 +00:00
|
|
|
if (stcb == NULL) {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOENT);
|
2006-11-03 15:23:16 +00:00
|
|
|
error = ENOENT;
|
|
|
|
break;
|
|
|
|
}
|
2014-08-04 20:07:35 +00:00
|
|
|
if (stcb->asoc.reconfig_supported == 0) {
|
2006-11-03 15:23:16 +00:00
|
|
|
/*
|
2012-03-29 13:36:53 +00:00
|
|
|
* Peer does not support the chunk type.
|
2006-11-03 15:23:16 +00:00
|
|
|
*/
|
2012-03-29 13:36:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EOPNOTSUPP);
|
|
|
|
error = EOPNOTSUPP;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
break;
|
|
|
|
}
|
2019-03-02 14:30:27 +00:00
|
|
|
if (SCTP_GET_STATE(stcb) != SCTP_STATE_OPEN) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
break;
|
|
|
|
}
|
2014-10-08 15:29:49 +00:00
|
|
|
if (sizeof(struct sctp_reset_streams) +
|
|
|
|
strrst->srs_number_streams * sizeof(uint16_t) > optsize) {
|
|
|
|
error = EINVAL;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
break;
|
|
|
|
}
|
2012-03-29 13:36:53 +00:00
|
|
|
if (strrst->srs_flags & SCTP_STREAM_RESET_INCOMING) {
|
2006-11-03 15:23:16 +00:00
|
|
|
send_in = 1;
|
2015-07-22 11:30:37 +00:00
|
|
|
if (stcb->asoc.stream_reset_outstanding) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EALREADY);
|
|
|
|
error = EALREADY;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
break;
|
|
|
|
}
|
2012-03-29 13:36:53 +00:00
|
|
|
}
|
|
|
|
if (strrst->srs_flags & SCTP_STREAM_RESET_OUTGOING) {
|
2006-11-03 15:23:16 +00:00
|
|
|
send_out = 1;
|
2012-03-29 13:36:53 +00:00
|
|
|
}
|
2015-07-22 11:30:37 +00:00
|
|
|
if ((strrst->srs_number_streams > SCTP_MAX_STREAMS_AT_ONCE_RESET) && send_in) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOMEM);
|
|
|
|
error = ENOMEM;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
break;
|
|
|
|
}
|
2012-03-29 13:36:53 +00:00
|
|
|
if ((send_in == 0) && (send_out == 0)) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
for (i = 0; i < strrst->srs_number_streams; i++) {
|
|
|
|
if ((send_in) &&
|
2019-02-05 10:13:51 +00:00
|
|
|
(strrst->srs_stream_list[i] >= stcb->asoc.streamincnt)) {
|
2012-03-29 13:36:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2009-02-20 15:03:54 +00:00
|
|
|
error = EINVAL;
|
2012-03-29 13:36:53 +00:00
|
|
|
break;
|
2009-02-20 15:03:54 +00:00
|
|
|
}
|
2012-03-29 13:36:53 +00:00
|
|
|
if ((send_out) &&
|
2019-02-05 10:13:51 +00:00
|
|
|
(strrst->srs_stream_list[i] >= stcb->asoc.streamoutcnt)) {
|
2012-03-29 13:36:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
2009-02-20 15:03:54 +00:00
|
|
|
}
|
2012-03-29 13:36:53 +00:00
|
|
|
}
|
|
|
|
if (error) {
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
break;
|
|
|
|
}
|
2015-07-22 11:30:37 +00:00
|
|
|
if (send_out) {
|
|
|
|
int cnt;
|
|
|
|
uint16_t strm;
|
|
|
|
|
|
|
|
if (strrst->srs_number_streams) {
|
|
|
|
for (i = 0, cnt = 0; i < strrst->srs_number_streams; i++) {
|
|
|
|
strm = strrst->srs_stream_list[i];
|
|
|
|
if (stcb->asoc.strmout[strm].state == SCTP_STREAM_OPEN) {
|
|
|
|
stcb->asoc.strmout[strm].state = SCTP_STREAM_RESET_PENDING;
|
|
|
|
cnt++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* Its all */
|
|
|
|
for (i = 0, cnt = 0; i < stcb->asoc.streamoutcnt; i++) {
|
|
|
|
if (stcb->asoc.strmout[i].state == SCTP_STREAM_OPEN) {
|
|
|
|
stcb->asoc.strmout[i].state = SCTP_STREAM_RESET_PENDING;
|
|
|
|
cnt++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (send_in) {
|
|
|
|
error = sctp_send_str_reset_req(stcb, strrst->srs_number_streams,
|
|
|
|
strrst->srs_stream_list,
|
|
|
|
send_in, 0, 0, 0, 0, 0);
|
2015-11-26 23:12:41 +00:00
|
|
|
} else {
|
2015-07-24 14:09:03 +00:00
|
|
|
error = sctp_send_stream_reset_out_if_possible(stcb, SCTP_SO_LOCKED);
|
2015-11-26 23:12:41 +00:00
|
|
|
}
|
|
|
|
if (error == 0) {
|
2015-07-22 11:30:37 +00:00
|
|
|
sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_STRRST_REQ, SCTP_SO_LOCKED);
|
2015-11-26 23:12:41 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* For outgoing streams don't report any
|
|
|
|
* problems in sending the request to the
|
|
|
|
* application. XXX: Double check resetting
|
|
|
|
* incoming streams.
|
|
|
|
*/
|
|
|
|
error = 0;
|
|
|
|
}
|
2012-03-29 13:36:53 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case SCTP_ADD_STREAMS:
|
|
|
|
{
|
|
|
|
struct sctp_add_streams *stradd;
|
|
|
|
uint8_t addstream = 0;
|
|
|
|
uint16_t add_o_strmcnt = 0;
|
|
|
|
uint16_t add_i_strmcnt = 0;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(stradd, optval, struct sctp_add_streams, optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, stradd->sas_assoc_id);
|
|
|
|
if (stcb == NULL) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOENT);
|
|
|
|
error = ENOENT;
|
|
|
|
break;
|
|
|
|
}
|
2014-08-04 20:07:35 +00:00
|
|
|
if (stcb->asoc.reconfig_supported == 0) {
|
2012-05-05 14:06:15 +00:00
|
|
|
/*
|
|
|
|
* Peer does not support the chunk type.
|
|
|
|
*/
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EOPNOTSUPP);
|
|
|
|
error = EOPNOTSUPP;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
break;
|
|
|
|
}
|
2019-03-02 14:30:27 +00:00
|
|
|
if (SCTP_GET_STATE(stcb) != SCTP_STATE_OPEN) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
break;
|
|
|
|
}
|
2012-05-05 14:06:15 +00:00
|
|
|
if (stcb->asoc.stream_reset_outstanding) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EALREADY);
|
|
|
|
error = EALREADY;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
break;
|
|
|
|
}
|
2012-03-29 13:36:53 +00:00
|
|
|
if ((stradd->sas_outstrms == 0) &&
|
|
|
|
(stradd->sas_instrms == 0)) {
|
|
|
|
error = EINVAL;
|
|
|
|
goto skip_stuff;
|
|
|
|
}
|
|
|
|
if (stradd->sas_outstrms) {
|
2009-02-20 15:03:54 +00:00
|
|
|
addstream = 1;
|
|
|
|
/* We allocate here */
|
2012-03-29 13:36:53 +00:00
|
|
|
add_o_strmcnt = stradd->sas_outstrms;
|
|
|
|
if ((((int)add_o_strmcnt) + ((int)stcb->asoc.streamoutcnt)) > 0x0000ffff) {
|
2009-02-20 15:03:54 +00:00
|
|
|
/* You can't have more than 64k */
|
|
|
|
error = EINVAL;
|
|
|
|
goto skip_stuff;
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2012-03-29 13:36:53 +00:00
|
|
|
if (stradd->sas_instrms) {
|
|
|
|
int cnt;
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2012-03-29 13:36:53 +00:00
|
|
|
addstream |= 2;
|
2016-12-26 11:06:41 +00:00
|
|
|
/*
|
|
|
|
* We allocate inside
|
|
|
|
* sctp_send_str_reset_req()
|
|
|
|
*/
|
2012-03-29 13:36:53 +00:00
|
|
|
add_i_strmcnt = stradd->sas_instrms;
|
|
|
|
cnt = add_i_strmcnt;
|
|
|
|
cnt += stcb->asoc.streamincnt;
|
|
|
|
if (cnt > 0x0000ffff) {
|
|
|
|
/* You can't have more than 64k */
|
2006-11-03 15:23:16 +00:00
|
|
|
error = EINVAL;
|
2012-03-29 13:36:53 +00:00
|
|
|
goto skip_stuff;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2012-03-29 13:36:53 +00:00
|
|
|
if (cnt > (int)stcb->asoc.max_inbound_streams) {
|
|
|
|
/* More than you are allowed */
|
2006-11-03 15:23:16 +00:00
|
|
|
error = EINVAL;
|
2012-03-29 13:36:53 +00:00
|
|
|
goto skip_stuff;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
}
|
2015-07-22 11:30:37 +00:00
|
|
|
error = sctp_send_str_reset_req(stcb, 0, NULL, 0, 0, addstream, add_o_strmcnt, add_i_strmcnt, 0);
|
2012-03-29 13:36:53 +00:00
|
|
|
sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_STRRST_REQ, SCTP_SO_LOCKED);
|
2009-02-20 15:03:54 +00:00
|
|
|
skip_stuff:
|
2012-03-29 13:36:53 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case SCTP_RESET_ASSOC:
|
|
|
|
{
|
2015-07-22 11:30:37 +00:00
|
|
|
int i;
|
2012-03-29 13:36:53 +00:00
|
|
|
uint32_t *value;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(value, optval, uint32_t, optsize);
|
2018-07-19 20:11:14 +00:00
|
|
|
SCTP_FIND_STCB(inp, stcb, (sctp_assoc_t)*value);
|
2012-03-29 13:36:53 +00:00
|
|
|
if (stcb == NULL) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOENT);
|
|
|
|
error = ENOENT;
|
|
|
|
break;
|
|
|
|
}
|
2014-08-04 20:07:35 +00:00
|
|
|
if (stcb->asoc.reconfig_supported == 0) {
|
2012-03-29 13:36:53 +00:00
|
|
|
/*
|
|
|
|
* Peer does not support the chunk type.
|
|
|
|
*/
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EOPNOTSUPP);
|
|
|
|
error = EOPNOTSUPP;
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
2019-03-02 14:30:27 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (SCTP_GET_STATE(stcb) != SCTP_STATE_OPEN) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
2006-11-03 15:23:16 +00:00
|
|
|
break;
|
|
|
|
}
|
2012-03-29 13:36:53 +00:00
|
|
|
if (stcb->asoc.stream_reset_outstanding) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EALREADY);
|
|
|
|
error = EALREADY;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
break;
|
|
|
|
}
|
2016-12-26 11:06:41 +00:00
|
|
|
/*
|
|
|
|
* Is there any data pending in the send or sent
|
|
|
|
* queues?
|
|
|
|
*/
|
2015-07-22 11:30:37 +00:00
|
|
|
if (!TAILQ_EMPTY(&stcb->asoc.send_queue) ||
|
|
|
|
!TAILQ_EMPTY(&stcb->asoc.sent_queue)) {
|
|
|
|
busy_out:
|
|
|
|
error = EBUSY;
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* Do any streams have data queued? */
|
|
|
|
for (i = 0; i < stcb->asoc.streamoutcnt; i++) {
|
|
|
|
if (!TAILQ_EMPTY(&stcb->asoc.strmout[i].outqueue)) {
|
|
|
|
goto busy_out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
error = sctp_send_str_reset_req(stcb, 0, NULL, 0, 1, 0, 0, 0, 0);
|
2007-09-08 11:35:11 +00:00
|
|
|
sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_STRRST_REQ, SCTP_SO_LOCKED);
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
case SCTP_CONNECT_X:
|
2007-02-12 23:24:31 +00:00
|
|
|
if (optsize < (sizeof(int) + sizeof(struct sockaddr_in))) {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2006-11-03 15:23:16 +00:00
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
2007-02-12 23:24:31 +00:00
|
|
|
error = sctp_do_connect_x(so, inp, optval, optsize, p, 0);
|
2006-11-03 15:23:16 +00:00
|
|
|
break;
|
|
|
|
case SCTP_CONNECT_X_DELAYED:
|
2007-02-12 23:24:31 +00:00
|
|
|
if (optsize < (sizeof(int) + sizeof(struct sockaddr_in))) {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2006-11-03 15:23:16 +00:00
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
2007-02-12 23:24:31 +00:00
|
|
|
error = sctp_do_connect_x(so, inp, optval, optsize, p, 1);
|
2006-11-03 15:23:16 +00:00
|
|
|
break;
|
|
|
|
case SCTP_CONNECT_X_COMPLETE:
|
|
|
|
{
|
|
|
|
struct sockaddr *sa;
|
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
/* FIXME MT: check correct? */
|
|
|
|
SCTP_CHECK_AND_CAST(sa, optval, struct sockaddr, optsize);
|
|
|
|
|
2006-11-03 15:23:16 +00:00
|
|
|
/* find tcb */
|
|
|
|
if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
|
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
stcb = LIST_FIRST(&inp->sctp_asoc_list);
|
|
|
|
if (stcb) {
|
|
|
|
SCTP_TCB_LOCK(stcb);
|
|
|
|
}
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
} else {
|
2007-02-12 23:24:31 +00:00
|
|
|
/*
|
|
|
|
* We increment here since
|
|
|
|
* sctp_findassociation_ep_addr() wil do a
|
|
|
|
* decrement if it finds the stcb as long as
|
|
|
|
* the locked tcb (last argument) is NOT a
|
|
|
|
* TCB.. aka NULL.
|
|
|
|
*/
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_INP_INCR_REF(inp);
|
2015-01-18 20:20:27 +00:00
|
|
|
stcb = sctp_findassociation_ep_addr(&inp, sa, NULL, NULL, NULL);
|
2006-11-03 15:23:16 +00:00
|
|
|
if (stcb == NULL) {
|
|
|
|
SCTP_INP_DECR_REF(inp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (stcb == NULL) {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOENT);
|
2006-11-03 15:23:16 +00:00
|
|
|
error = ENOENT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (stcb->asoc.delayed_connection == 1) {
|
|
|
|
stcb->asoc.delayed_connection = 0;
|
2007-05-08 14:32:53 +00:00
|
|
|
(void)SCTP_GETTIME_TIMEVAL(&stcb->asoc.time_entered);
|
2006-12-14 17:02:55 +00:00
|
|
|
sctp_timer_stop(SCTP_TIMER_TYPE_INIT, inp, stcb,
|
|
|
|
stcb->asoc.primary_destination,
|
2015-05-28 16:00:23 +00:00
|
|
|
SCTP_FROM_SCTP_USRREQ + SCTP_LOC_8);
|
2007-09-08 11:35:11 +00:00
|
|
|
sctp_send_initiate(inp, stcb, SCTP_SO_LOCKED);
|
2006-11-03 15:23:16 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* already expired or did not use delayed
|
|
|
|
* connectx
|
|
|
|
*/
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EALREADY);
|
2006-11-03 15:23:16 +00:00
|
|
|
error = EALREADY;
|
|
|
|
}
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2007-05-28 11:17:24 +00:00
|
|
|
case SCTP_MAX_BURST:
|
2006-11-03 15:23:16 +00:00
|
|
|
{
|
2011-01-26 19:55:54 +00:00
|
|
|
struct sctp_assoc_value *av;
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2011-01-26 19:55:54 +00:00
|
|
|
SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, av->assoc_id);
|
2007-02-12 23:24:31 +00:00
|
|
|
|
2011-01-26 19:55:54 +00:00
|
|
|
if (stcb) {
|
|
|
|
stcb->asoc.max_burst = av->assoc_value;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
2011-08-16 21:04:18 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
((av->assoc_id == SCTP_FUTURE_ASSOC) ||
|
|
|
|
(av->assoc_id == SCTP_ALL_ASSOC)))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
inp->sctp_ep.max_burst = av->assoc_value;
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
|
|
|
}
|
2019-11-28 12:50:25 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
((av->assoc_id == SCTP_CURRENT_ASSOC) ||
|
|
|
|
(av->assoc_id == SCTP_ALL_ASSOC))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
|
|
|
|
SCTP_TCB_LOCK(stcb);
|
|
|
|
stcb->asoc.max_burst = av->assoc_value;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
}
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
}
|
2011-01-26 19:55:54 +00:00
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
case SCTP_MAXSEG:
|
|
|
|
{
|
2007-03-15 11:27:14 +00:00
|
|
|
struct sctp_assoc_value *av;
|
2006-11-03 15:23:16 +00:00
|
|
|
int ovh;
|
|
|
|
|
2007-03-15 11:27:14 +00:00
|
|
|
SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, av->assoc_id);
|
2007-02-12 23:24:31 +00:00
|
|
|
|
2007-05-28 11:17:24 +00:00
|
|
|
if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) {
|
|
|
|
ovh = SCTP_MED_OVERHEAD;
|
|
|
|
} else {
|
|
|
|
ovh = SCTP_MED_V4_OVERHEAD;
|
|
|
|
}
|
2007-03-15 11:27:14 +00:00
|
|
|
if (stcb) {
|
2007-05-28 11:17:24 +00:00
|
|
|
if (av->assoc_value) {
|
|
|
|
stcb->asoc.sctp_frag_point = (av->assoc_value + ovh);
|
|
|
|
} else {
|
|
|
|
stcb->asoc.sctp_frag_point = SCTP_DEFAULT_MAXSEGMENT;
|
|
|
|
}
|
2007-03-15 11:27:14 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
2011-08-16 21:04:18 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(av->assoc_id == SCTP_FUTURE_ASSOC))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_WLOCK(inp);
|
2016-12-26 11:06:41 +00:00
|
|
|
/*
|
|
|
|
* FIXME MT: I think this is not in
|
|
|
|
* tune with the API ID
|
|
|
|
*/
|
2011-06-15 23:50:27 +00:00
|
|
|
if (av->assoc_value) {
|
|
|
|
inp->sctp_frag_point = (av->assoc_value + ovh);
|
|
|
|
} else {
|
|
|
|
inp->sctp_frag_point = SCTP_DEFAULT_MAXSEGMENT;
|
|
|
|
}
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
2007-03-15 11:27:14 +00:00
|
|
|
} else {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
2007-03-15 11:27:14 +00:00
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
case SCTP_EVENTS:
|
|
|
|
{
|
|
|
|
struct sctp_event_subscribe *events;
|
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_CHECK_AND_CAST(events, optval, struct sctp_event_subscribe, optsize);
|
|
|
|
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
if (events->sctp_data_io_event) {
|
|
|
|
sctp_feature_on(inp, SCTP_PCB_FLAGS_RECVDATAIOEVNT);
|
|
|
|
} else {
|
|
|
|
sctp_feature_off(inp, SCTP_PCB_FLAGS_RECVDATAIOEVNT);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (events->sctp_association_event) {
|
|
|
|
sctp_feature_on(inp, SCTP_PCB_FLAGS_RECVASSOCEVNT);
|
|
|
|
} else {
|
|
|
|
sctp_feature_off(inp, SCTP_PCB_FLAGS_RECVASSOCEVNT);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (events->sctp_address_event) {
|
|
|
|
sctp_feature_on(inp, SCTP_PCB_FLAGS_RECVPADDREVNT);
|
|
|
|
} else {
|
|
|
|
sctp_feature_off(inp, SCTP_PCB_FLAGS_RECVPADDREVNT);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (events->sctp_send_failure_event) {
|
|
|
|
sctp_feature_on(inp, SCTP_PCB_FLAGS_RECVSENDFAILEVNT);
|
|
|
|
} else {
|
|
|
|
sctp_feature_off(inp, SCTP_PCB_FLAGS_RECVSENDFAILEVNT);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (events->sctp_peer_error_event) {
|
|
|
|
sctp_feature_on(inp, SCTP_PCB_FLAGS_RECVPEERERR);
|
|
|
|
} else {
|
|
|
|
sctp_feature_off(inp, SCTP_PCB_FLAGS_RECVPEERERR);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (events->sctp_shutdown_event) {
|
|
|
|
sctp_feature_on(inp, SCTP_PCB_FLAGS_RECVSHUTDOWNEVNT);
|
|
|
|
} else {
|
|
|
|
sctp_feature_off(inp, SCTP_PCB_FLAGS_RECVSHUTDOWNEVNT);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (events->sctp_partial_delivery_event) {
|
|
|
|
sctp_feature_on(inp, SCTP_PCB_FLAGS_PDAPIEVNT);
|
|
|
|
} else {
|
|
|
|
sctp_feature_off(inp, SCTP_PCB_FLAGS_PDAPIEVNT);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (events->sctp_adaptation_layer_event) {
|
|
|
|
sctp_feature_on(inp, SCTP_PCB_FLAGS_ADAPTATIONEVNT);
|
|
|
|
} else {
|
|
|
|
sctp_feature_off(inp, SCTP_PCB_FLAGS_ADAPTATIONEVNT);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (events->sctp_authentication_event) {
|
|
|
|
sctp_feature_on(inp, SCTP_PCB_FLAGS_AUTHEVNT);
|
|
|
|
} else {
|
|
|
|
sctp_feature_off(inp, SCTP_PCB_FLAGS_AUTHEVNT);
|
|
|
|
}
|
|
|
|
|
2008-12-06 13:19:54 +00:00
|
|
|
if (events->sctp_sender_dry_event) {
|
|
|
|
sctp_feature_on(inp, SCTP_PCB_FLAGS_DRYEVNT);
|
|
|
|
} else {
|
|
|
|
sctp_feature_off(inp, SCTP_PCB_FLAGS_DRYEVNT);
|
|
|
|
}
|
|
|
|
|
2010-01-17 19:35:38 +00:00
|
|
|
if (events->sctp_stream_reset_event) {
|
2006-11-03 15:23:16 +00:00
|
|
|
sctp_feature_on(inp, SCTP_PCB_FLAGS_STREAM_RESETEVNT);
|
|
|
|
} else {
|
|
|
|
sctp_feature_off(inp, SCTP_PCB_FLAGS_STREAM_RESETEVNT);
|
|
|
|
}
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
|
|
|
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
|
|
|
|
SCTP_TCB_LOCK(stcb);
|
|
|
|
if (events->sctp_association_event) {
|
|
|
|
sctp_stcb_feature_on(inp, stcb, SCTP_PCB_FLAGS_RECVASSOCEVNT);
|
|
|
|
} else {
|
|
|
|
sctp_stcb_feature_off(inp, stcb, SCTP_PCB_FLAGS_RECVASSOCEVNT);
|
|
|
|
}
|
|
|
|
if (events->sctp_address_event) {
|
|
|
|
sctp_stcb_feature_on(inp, stcb, SCTP_PCB_FLAGS_RECVPADDREVNT);
|
|
|
|
} else {
|
|
|
|
sctp_stcb_feature_off(inp, stcb, SCTP_PCB_FLAGS_RECVPADDREVNT);
|
|
|
|
}
|
|
|
|
if (events->sctp_send_failure_event) {
|
|
|
|
sctp_stcb_feature_on(inp, stcb, SCTP_PCB_FLAGS_RECVSENDFAILEVNT);
|
|
|
|
} else {
|
|
|
|
sctp_stcb_feature_off(inp, stcb, SCTP_PCB_FLAGS_RECVSENDFAILEVNT);
|
|
|
|
}
|
|
|
|
if (events->sctp_peer_error_event) {
|
|
|
|
sctp_stcb_feature_on(inp, stcb, SCTP_PCB_FLAGS_RECVPEERERR);
|
|
|
|
} else {
|
|
|
|
sctp_stcb_feature_off(inp, stcb, SCTP_PCB_FLAGS_RECVPEERERR);
|
|
|
|
}
|
|
|
|
if (events->sctp_shutdown_event) {
|
|
|
|
sctp_stcb_feature_on(inp, stcb, SCTP_PCB_FLAGS_RECVSHUTDOWNEVNT);
|
|
|
|
} else {
|
|
|
|
sctp_stcb_feature_off(inp, stcb, SCTP_PCB_FLAGS_RECVSHUTDOWNEVNT);
|
|
|
|
}
|
|
|
|
if (events->sctp_partial_delivery_event) {
|
|
|
|
sctp_stcb_feature_on(inp, stcb, SCTP_PCB_FLAGS_PDAPIEVNT);
|
|
|
|
} else {
|
|
|
|
sctp_stcb_feature_off(inp, stcb, SCTP_PCB_FLAGS_PDAPIEVNT);
|
|
|
|
}
|
|
|
|
if (events->sctp_adaptation_layer_event) {
|
|
|
|
sctp_stcb_feature_on(inp, stcb, SCTP_PCB_FLAGS_ADAPTATIONEVNT);
|
|
|
|
} else {
|
|
|
|
sctp_stcb_feature_off(inp, stcb, SCTP_PCB_FLAGS_ADAPTATIONEVNT);
|
|
|
|
}
|
|
|
|
if (events->sctp_authentication_event) {
|
|
|
|
sctp_stcb_feature_on(inp, stcb, SCTP_PCB_FLAGS_AUTHEVNT);
|
|
|
|
} else {
|
|
|
|
sctp_stcb_feature_off(inp, stcb, SCTP_PCB_FLAGS_AUTHEVNT);
|
|
|
|
}
|
|
|
|
if (events->sctp_sender_dry_event) {
|
|
|
|
sctp_stcb_feature_on(inp, stcb, SCTP_PCB_FLAGS_DRYEVNT);
|
|
|
|
} else {
|
|
|
|
sctp_stcb_feature_off(inp, stcb, SCTP_PCB_FLAGS_DRYEVNT);
|
|
|
|
}
|
|
|
|
if (events->sctp_stream_reset_event) {
|
|
|
|
sctp_stcb_feature_on(inp, stcb, SCTP_PCB_FLAGS_STREAM_RESETEVNT);
|
|
|
|
} else {
|
|
|
|
sctp_stcb_feature_off(inp, stcb, SCTP_PCB_FLAGS_STREAM_RESETEVNT);
|
|
|
|
}
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
}
|
2016-12-26 11:06:41 +00:00
|
|
|
/*
|
|
|
|
* Send up the sender dry event only for 1-to-1
|
|
|
|
* style sockets.
|
|
|
|
*/
|
2011-06-15 23:50:27 +00:00
|
|
|
if (events->sctp_sender_dry_event) {
|
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL)) {
|
|
|
|
stcb = LIST_FIRST(&inp->sctp_asoc_list);
|
|
|
|
if (stcb) {
|
|
|
|
SCTP_TCB_LOCK(stcb);
|
|
|
|
if (TAILQ_EMPTY(&stcb->asoc.send_queue) &&
|
|
|
|
TAILQ_EMPTY(&stcb->asoc.sent_queue) &&
|
|
|
|
(stcb->asoc.stream_queue_cnt == 0)) {
|
|
|
|
sctp_ulp_notify(SCTP_NOTIFY_SENDER_DRY, stcb, 0, NULL, SCTP_SO_LOCKED);
|
|
|
|
}
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
break;
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
case SCTP_ADAPTATION_LAYER:
|
|
|
|
{
|
|
|
|
struct sctp_setadaptation *adap_bits;
|
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_CHECK_AND_CAST(adap_bits, optval, struct sctp_setadaptation, optsize);
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
inp->sctp_ep.adaptation_layer_indicator = adap_bits->ssb_adaptation_ind;
|
2013-02-11 21:02:49 +00:00
|
|
|
inp->sctp_ep.adaptation_layer_indicator_provided = 1;
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_INP_WUNLOCK(inp);
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2007-02-12 23:24:31 +00:00
|
|
|
#ifdef SCTP_DEBUG
|
2006-11-03 15:23:16 +00:00
|
|
|
case SCTP_SET_INITIAL_DBG_SEQ:
|
|
|
|
{
|
|
|
|
uint32_t *vvv;
|
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_CHECK_AND_CAST(vvv, optval, uint32_t, optsize);
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
inp->sctp_ep.initial_sequence_debug = *vvv;
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2007-02-12 23:24:31 +00:00
|
|
|
#endif
|
2006-11-03 15:23:16 +00:00
|
|
|
case SCTP_DEFAULT_SEND_PARAM:
|
|
|
|
{
|
|
|
|
struct sctp_sndrcvinfo *s_info;
|
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_CHECK_AND_CAST(s_info, optval, struct sctp_sndrcvinfo, optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, s_info->sinfo_assoc_id);
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
if (stcb) {
|
2011-06-15 23:50:27 +00:00
|
|
|
if (s_info->sinfo_stream < stcb->asoc.streamoutcnt) {
|
2007-05-28 11:17:24 +00:00
|
|
|
memcpy(&stcb->asoc.def_send, s_info, min(optsize, sizeof(stcb->asoc.def_send)));
|
2006-11-03 15:23:16 +00:00
|
|
|
} else {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2007-02-12 23:24:31 +00:00
|
|
|
error = EINVAL;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
2007-02-12 23:24:31 +00:00
|
|
|
} else {
|
2011-08-16 21:04:18 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
((s_info->sinfo_assoc_id == SCTP_FUTURE_ASSOC) ||
|
|
|
|
(s_info->sinfo_assoc_id == SCTP_ALL_ASSOC)))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
memcpy(&inp->def_send, s_info, min(optsize, sizeof(inp->def_send)));
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
|
|
|
}
|
2019-11-28 12:50:25 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
((s_info->sinfo_assoc_id == SCTP_CURRENT_ASSOC) ||
|
|
|
|
(s_info->sinfo_assoc_id == SCTP_ALL_ASSOC))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
|
|
|
|
SCTP_TCB_LOCK(stcb);
|
|
|
|
if (s_info->sinfo_stream < stcb->asoc.streamoutcnt) {
|
|
|
|
memcpy(&stcb->asoc.def_send, s_info, min(optsize, sizeof(stcb->asoc.def_send)));
|
|
|
|
}
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
}
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
case SCTP_PEER_ADDR_PARAMS:
|
|
|
|
{
|
|
|
|
struct sctp_paddrparams *paddrp;
|
|
|
|
struct sctp_nets *net;
|
2014-12-06 20:00:08 +00:00
|
|
|
struct sockaddr *addr;
|
|
|
|
#if defined(INET) && defined(INET6)
|
|
|
|
struct sockaddr_in sin_store;
|
|
|
|
#endif
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_CHECK_AND_CAST(paddrp, optval, struct sctp_paddrparams, optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, paddrp->spp_assoc_id);
|
2014-12-06 20:00:08 +00:00
|
|
|
|
|
|
|
#if defined(INET) && defined(INET6)
|
|
|
|
if (paddrp->spp_address.ss_family == AF_INET6) {
|
|
|
|
struct sockaddr_in6 *sin6;
|
|
|
|
|
|
|
|
sin6 = (struct sockaddr_in6 *)&paddrp->spp_address;
|
|
|
|
if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
|
|
|
|
in6_sin6_2_sin(&sin_store, sin6);
|
|
|
|
addr = (struct sockaddr *)&sin_store;
|
|
|
|
} else {
|
|
|
|
addr = (struct sockaddr *)&paddrp->spp_address;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
addr = (struct sockaddr *)&paddrp->spp_address;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
addr = (struct sockaddr *)&paddrp->spp_address;
|
|
|
|
#endif
|
|
|
|
if (stcb != NULL) {
|
|
|
|
net = sctp_findnet(stcb, addr);
|
2007-02-12 23:24:31 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* We increment here since
|
|
|
|
* sctp_findassociation_ep_addr() wil do a
|
|
|
|
* decrement if it finds the stcb as long as
|
|
|
|
* the locked tcb (last argument) is NOT a
|
|
|
|
* TCB.. aka NULL.
|
|
|
|
*/
|
2014-12-06 20:00:08 +00:00
|
|
|
net = NULL;
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_INP_INCR_REF(inp);
|
2014-12-06 20:00:08 +00:00
|
|
|
stcb = sctp_findassociation_ep_addr(&inp, addr,
|
2007-02-12 23:24:31 +00:00
|
|
|
&net, NULL, NULL);
|
2006-11-03 15:23:16 +00:00
|
|
|
if (stcb == NULL) {
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_INP_DECR_REF(inp);
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
}
|
2014-12-06 20:00:08 +00:00
|
|
|
if ((stcb != NULL) && (net == NULL)) {
|
2011-04-30 11:18:16 +00:00
|
|
|
#ifdef INET
|
2014-12-06 20:00:08 +00:00
|
|
|
if (addr->sa_family == AF_INET) {
|
2007-08-24 00:53:53 +00:00
|
|
|
struct sockaddr_in *sin;
|
|
|
|
|
2014-12-06 20:00:08 +00:00
|
|
|
sin = (struct sockaddr_in *)addr;
|
|
|
|
if (sin->sin_addr.s_addr != INADDR_ANY) {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
2011-04-30 11:18:16 +00:00
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
#ifdef INET6
|
2014-12-06 20:00:08 +00:00
|
|
|
if (addr->sa_family == AF_INET6) {
|
2007-08-24 00:53:53 +00:00
|
|
|
struct sockaddr_in6 *sin6;
|
|
|
|
|
2014-12-06 20:00:08 +00:00
|
|
|
sin6 = (struct sockaddr_in6 *)addr;
|
2007-08-24 00:53:53 +00:00
|
|
|
if (!IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
2011-04-30 11:18:16 +00:00
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
{
|
2007-08-24 00:53:53 +00:00
|
|
|
error = EAFNOSUPPORT;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2007-05-28 11:17:24 +00:00
|
|
|
/* sanity checks */
|
|
|
|
if ((paddrp->spp_flags & SPP_HB_ENABLE) && (paddrp->spp_flags & SPP_HB_DISABLE)) {
|
|
|
|
if (stcb)
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2007-05-28 11:17:24 +00:00
|
|
|
return (EINVAL);
|
|
|
|
}
|
2018-07-19 20:16:33 +00:00
|
|
|
|
2007-05-28 11:17:24 +00:00
|
|
|
if ((paddrp->spp_flags & SPP_PMTUD_ENABLE) && (paddrp->spp_flags & SPP_PMTUD_DISABLE)) {
|
|
|
|
if (stcb)
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2007-05-28 11:17:24 +00:00
|
|
|
return (EINVAL);
|
|
|
|
}
|
2020-01-02 13:55:10 +00:00
|
|
|
if ((paddrp->spp_flags & SPP_PMTUD_DISABLE) &&
|
2021-04-30 10:27:47 +00:00
|
|
|
(paddrp->spp_pathmtu > 0) &&
|
2020-01-02 13:55:10 +00:00
|
|
|
((paddrp->spp_pathmtu < SCTP_SMALLEST_PMTU) ||
|
|
|
|
(paddrp->spp_pathmtu > SCTP_LARGEST_PMTU))) {
|
|
|
|
if (stcb)
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
return (EINVAL);
|
|
|
|
}
|
2018-07-19 20:16:33 +00:00
|
|
|
|
2014-12-06 20:00:08 +00:00
|
|
|
if (stcb != NULL) {
|
2006-11-03 15:23:16 +00:00
|
|
|
/************************TCB SPECIFIC SET ******************/
|
2014-12-06 20:00:08 +00:00
|
|
|
if (net != NULL) {
|
2006-11-03 15:23:16 +00:00
|
|
|
/************************NET SPECIFIC SET ******************/
|
|
|
|
if (paddrp->spp_flags & SPP_HB_DISABLE) {
|
2011-08-03 20:21:00 +00:00
|
|
|
if (!(net->dest_state & SCTP_ADDR_UNCONFIRMED) &&
|
|
|
|
!(net->dest_state & SCTP_ADDR_NOHB)) {
|
|
|
|
sctp_timer_stop(SCTP_TIMER_TYPE_HEARTBEAT, inp, stcb, net,
|
2015-05-28 16:00:23 +00:00
|
|
|
SCTP_FROM_SCTP_USRREQ + SCTP_LOC_9);
|
2011-08-03 20:21:00 +00:00
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
net->dest_state |= SCTP_ADDR_NOHB;
|
|
|
|
}
|
|
|
|
if (paddrp->spp_flags & SPP_HB_ENABLE) {
|
2011-08-03 20:21:00 +00:00
|
|
|
if (paddrp->spp_hbinterval) {
|
|
|
|
net->heart_beat_delay = paddrp->spp_hbinterval;
|
|
|
|
} else if (paddrp->spp_flags & SPP_HB_TIME_IS_ZERO) {
|
|
|
|
net->heart_beat_delay = 0;
|
|
|
|
}
|
|
|
|
sctp_timer_stop(SCTP_TIMER_TYPE_HEARTBEAT, inp, stcb, net,
|
|
|
|
SCTP_FROM_SCTP_USRREQ + SCTP_LOC_10);
|
|
|
|
sctp_timer_start(SCTP_TIMER_TYPE_HEARTBEAT, inp, stcb, net);
|
2006-11-03 15:23:16 +00:00
|
|
|
net->dest_state &= ~SCTP_ADDR_NOHB;
|
|
|
|
}
|
2011-08-03 20:21:00 +00:00
|
|
|
if (paddrp->spp_flags & SPP_HB_DEMAND) {
|
2019-05-19 17:53:36 +00:00
|
|
|
if (SCTP_GET_STATE(stcb) == SCTP_STATE_OPEN) {
|
|
|
|
sctp_send_hb(stcb, net, SCTP_SO_LOCKED);
|
|
|
|
sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_SOCKOPT, SCTP_SO_LOCKED);
|
|
|
|
sctp_timer_start(SCTP_TIMER_TYPE_HEARTBEAT, inp, stcb, net);
|
|
|
|
}
|
2011-08-03 20:21:00 +00:00
|
|
|
}
|
2020-01-02 13:55:10 +00:00
|
|
|
if (paddrp->spp_flags & SPP_PMTUD_DISABLE) {
|
2006-12-29 20:21:42 +00:00
|
|
|
if (SCTP_OS_TIMER_PENDING(&net->pmtu_timer.timer)) {
|
2006-12-14 17:02:55 +00:00
|
|
|
sctp_timer_stop(SCTP_TIMER_TYPE_PATHMTURAISE, inp, stcb, net,
|
2015-05-28 16:00:23 +00:00
|
|
|
SCTP_FROM_SCTP_USRREQ + SCTP_LOC_11);
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2011-09-17 08:50:29 +00:00
|
|
|
net->dest_state |= SCTP_ADDR_NO_PMTUD;
|
2021-04-30 10:27:47 +00:00
|
|
|
if (paddrp->spp_pathmtu > 0) {
|
|
|
|
net->mtu = paddrp->spp_pathmtu;
|
|
|
|
switch (net->ro._l_addr.sa.sa_family) {
|
2015-05-28 20:33:28 +00:00
|
|
|
#ifdef INET
|
2021-04-30 10:27:47 +00:00
|
|
|
case AF_INET:
|
|
|
|
net->mtu += SCTP_MIN_V4_OVERHEAD;
|
|
|
|
break;
|
2015-05-28 20:33:28 +00:00
|
|
|
#endif
|
|
|
|
#ifdef INET6
|
2021-04-30 10:27:47 +00:00
|
|
|
case AF_INET6:
|
|
|
|
net->mtu += SCTP_MIN_OVERHEAD;
|
|
|
|
break;
|
2015-05-28 20:33:28 +00:00
|
|
|
#endif
|
2021-04-30 10:27:47 +00:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (net->mtu < stcb->asoc.smallest_mtu) {
|
|
|
|
sctp_pathmtu_adjustment(stcb, net->mtu);
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (paddrp->spp_flags & SPP_PMTUD_ENABLE) {
|
2011-09-17 08:50:29 +00:00
|
|
|
if (!SCTP_OS_TIMER_PENDING(&net->pmtu_timer.timer)) {
|
2006-11-03 15:23:16 +00:00
|
|
|
sctp_timer_start(SCTP_TIMER_TYPE_PATHMTURAISE, inp, stcb, net);
|
|
|
|
}
|
2011-09-17 08:50:29 +00:00
|
|
|
net->dest_state &= ~SCTP_ADDR_NO_PMTUD;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2021-04-30 10:27:47 +00:00
|
|
|
if (paddrp->spp_pathmaxrxt > 0) {
|
2011-08-03 20:21:00 +00:00
|
|
|
if (net->dest_state & SCTP_ADDR_PF) {
|
|
|
|
if (net->error_count > paddrp->spp_pathmaxrxt) {
|
|
|
|
net->dest_state &= ~SCTP_ADDR_PF;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if ((net->error_count <= paddrp->spp_pathmaxrxt) &&
|
|
|
|
(net->error_count > net->pf_threshold)) {
|
|
|
|
net->dest_state |= SCTP_ADDR_PF;
|
|
|
|
sctp_send_hb(stcb, net, SCTP_SO_LOCKED);
|
2015-05-28 16:00:23 +00:00
|
|
|
sctp_timer_stop(SCTP_TIMER_TYPE_HEARTBEAT,
|
|
|
|
stcb->sctp_ep, stcb, net,
|
|
|
|
SCTP_FROM_SCTP_USRREQ + SCTP_LOC_12);
|
2011-08-03 20:21:00 +00:00
|
|
|
sctp_timer_start(SCTP_TIMER_TYPE_HEARTBEAT, stcb->sctp_ep, stcb, net);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (net->dest_state & SCTP_ADDR_REACHABLE) {
|
|
|
|
if (net->error_count > paddrp->spp_pathmaxrxt) {
|
|
|
|
net->dest_state &= ~SCTP_ADDR_REACHABLE;
|
2012-05-13 17:36:04 +00:00
|
|
|
sctp_ulp_notify(SCTP_NOTIFY_INTERFACE_DOWN, stcb, 0, net, SCTP_SO_LOCKED);
|
2011-08-03 20:21:00 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (net->error_count <= paddrp->spp_pathmaxrxt) {
|
|
|
|
net->dest_state |= SCTP_ADDR_REACHABLE;
|
2012-05-13 17:36:04 +00:00
|
|
|
sctp_ulp_notify(SCTP_NOTIFY_INTERFACE_UP, stcb, 0, net, SCTP_SO_LOCKED);
|
2011-08-03 20:21:00 +00:00
|
|
|
}
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
net->failure_threshold = paddrp->spp_pathmaxrxt;
|
2011-08-03 20:21:00 +00:00
|
|
|
}
|
2011-08-14 20:55:32 +00:00
|
|
|
if (paddrp->spp_flags & SPP_DSCP) {
|
2011-10-11 13:24:37 +00:00
|
|
|
net->dscp = paddrp->spp_dscp & 0xfc;
|
2011-09-14 08:15:21 +00:00
|
|
|
net->dscp |= 0x01;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2007-03-15 11:27:14 +00:00
|
|
|
#ifdef INET6
|
2006-11-03 15:23:16 +00:00
|
|
|
if (paddrp->spp_flags & SPP_IPV6_FLOWLABEL) {
|
2011-09-14 08:15:21 +00:00
|
|
|
if (net->ro._l_addr.sa.sa_family == AF_INET6) {
|
2011-08-14 20:55:32 +00:00
|
|
|
net->flowlabel = paddrp->spp_ipv6_flowlabel & 0x000fffff;
|
2011-09-14 08:15:21 +00:00
|
|
|
net->flowlabel |= 0x80000000;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
} else {
|
|
|
|
/************************ASSOC ONLY -- NO NET SPECIFIC SET ******************/
|
2021-04-30 10:27:47 +00:00
|
|
|
if (paddrp->spp_pathmaxrxt > 0) {
|
2006-11-03 15:23:16 +00:00
|
|
|
stcb->asoc.def_net_failure = paddrp->spp_pathmaxrxt;
|
2011-08-03 20:21:00 +00:00
|
|
|
TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
|
|
|
|
if (net->dest_state & SCTP_ADDR_PF) {
|
|
|
|
if (net->error_count > paddrp->spp_pathmaxrxt) {
|
|
|
|
net->dest_state &= ~SCTP_ADDR_PF;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if ((net->error_count <= paddrp->spp_pathmaxrxt) &&
|
|
|
|
(net->error_count > net->pf_threshold)) {
|
|
|
|
net->dest_state |= SCTP_ADDR_PF;
|
|
|
|
sctp_send_hb(stcb, net, SCTP_SO_LOCKED);
|
2015-05-28 16:00:23 +00:00
|
|
|
sctp_timer_stop(SCTP_TIMER_TYPE_HEARTBEAT,
|
|
|
|
stcb->sctp_ep, stcb, net,
|
|
|
|
SCTP_FROM_SCTP_USRREQ + SCTP_LOC_13);
|
2011-08-03 20:21:00 +00:00
|
|
|
sctp_timer_start(SCTP_TIMER_TYPE_HEARTBEAT, stcb->sctp_ep, stcb, net);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (net->dest_state & SCTP_ADDR_REACHABLE) {
|
|
|
|
if (net->error_count > paddrp->spp_pathmaxrxt) {
|
|
|
|
net->dest_state &= ~SCTP_ADDR_REACHABLE;
|
2012-05-13 17:36:04 +00:00
|
|
|
sctp_ulp_notify(SCTP_NOTIFY_INTERFACE_DOWN, stcb, 0, net, SCTP_SO_LOCKED);
|
2011-08-03 20:21:00 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (net->error_count <= paddrp->spp_pathmaxrxt) {
|
|
|
|
net->dest_state |= SCTP_ADDR_REACHABLE;
|
2012-05-13 17:36:04 +00:00
|
|
|
sctp_ulp_notify(SCTP_NOTIFY_INTERFACE_UP, stcb, 0, net, SCTP_SO_LOCKED);
|
2011-08-03 20:21:00 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
net->failure_threshold = paddrp->spp_pathmaxrxt;
|
|
|
|
}
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
if (paddrp->spp_flags & SPP_HB_ENABLE) {
|
2014-12-06 20:00:08 +00:00
|
|
|
if (paddrp->spp_hbinterval != 0) {
|
2011-08-03 20:21:00 +00:00
|
|
|
stcb->asoc.heart_beat_delay = paddrp->spp_hbinterval;
|
|
|
|
} else if (paddrp->spp_flags & SPP_HB_TIME_IS_ZERO) {
|
|
|
|
stcb->asoc.heart_beat_delay = 0;
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
/* Turn back on the timer */
|
2011-08-03 20:21:00 +00:00
|
|
|
TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
|
2014-12-06 20:00:08 +00:00
|
|
|
if (paddrp->spp_hbinterval != 0) {
|
2011-08-03 20:21:00 +00:00
|
|
|
net->heart_beat_delay = paddrp->spp_hbinterval;
|
|
|
|
} else if (paddrp->spp_flags & SPP_HB_TIME_IS_ZERO) {
|
|
|
|
net->heart_beat_delay = 0;
|
|
|
|
}
|
|
|
|
if (net->dest_state & SCTP_ADDR_NOHB) {
|
|
|
|
net->dest_state &= ~SCTP_ADDR_NOHB;
|
|
|
|
}
|
|
|
|
sctp_timer_stop(SCTP_TIMER_TYPE_HEARTBEAT, inp, stcb, net,
|
2015-05-28 16:00:23 +00:00
|
|
|
SCTP_FROM_SCTP_USRREQ + SCTP_LOC_14);
|
2011-08-03 20:21:00 +00:00
|
|
|
sctp_timer_start(SCTP_TIMER_TYPE_HEARTBEAT, inp, stcb, net);
|
|
|
|
}
|
2011-09-17 08:50:29 +00:00
|
|
|
sctp_stcb_feature_off(inp, stcb, SCTP_PCB_FLAGS_DONOT_HEARTBEAT);
|
2011-08-03 20:21:00 +00:00
|
|
|
}
|
|
|
|
if (paddrp->spp_flags & SPP_HB_DISABLE) {
|
|
|
|
TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
|
|
|
|
if (!(net->dest_state & SCTP_ADDR_NOHB)) {
|
|
|
|
net->dest_state |= SCTP_ADDR_NOHB;
|
|
|
|
if (!(net->dest_state & SCTP_ADDR_UNCONFIRMED)) {
|
2015-05-28 16:00:23 +00:00
|
|
|
sctp_timer_stop(SCTP_TIMER_TYPE_HEARTBEAT,
|
|
|
|
inp, stcb, net,
|
|
|
|
SCTP_FROM_SCTP_USRREQ + SCTP_LOC_15);
|
2011-08-03 20:21:00 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-09-17 08:50:29 +00:00
|
|
|
sctp_stcb_feature_on(inp, stcb, SCTP_PCB_FLAGS_DONOT_HEARTBEAT);
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2020-01-02 13:55:10 +00:00
|
|
|
if (paddrp->spp_flags & SPP_PMTUD_DISABLE) {
|
2007-05-28 11:17:24 +00:00
|
|
|
TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
|
|
|
|
if (SCTP_OS_TIMER_PENDING(&net->pmtu_timer.timer)) {
|
|
|
|
sctp_timer_stop(SCTP_TIMER_TYPE_PATHMTURAISE, inp, stcb, net,
|
2015-05-28 16:00:23 +00:00
|
|
|
SCTP_FROM_SCTP_USRREQ + SCTP_LOC_16);
|
2007-05-28 11:17:24 +00:00
|
|
|
}
|
2011-09-17 08:50:29 +00:00
|
|
|
net->dest_state |= SCTP_ADDR_NO_PMTUD;
|
2021-04-30 10:27:47 +00:00
|
|
|
if (paddrp->spp_pathmtu > 0) {
|
|
|
|
net->mtu = paddrp->spp_pathmtu;
|
|
|
|
switch (net->ro._l_addr.sa.sa_family) {
|
2015-05-28 20:33:28 +00:00
|
|
|
#ifdef INET
|
2021-04-30 10:27:47 +00:00
|
|
|
case AF_INET:
|
|
|
|
net->mtu += SCTP_MIN_V4_OVERHEAD;
|
|
|
|
break;
|
2015-05-28 20:33:28 +00:00
|
|
|
#endif
|
|
|
|
#ifdef INET6
|
2021-04-30 10:27:47 +00:00
|
|
|
case AF_INET6:
|
|
|
|
net->mtu += SCTP_MIN_OVERHEAD;
|
|
|
|
break;
|
2015-05-28 20:33:28 +00:00
|
|
|
#endif
|
2021-04-30 10:27:47 +00:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (net->mtu < stcb->asoc.smallest_mtu) {
|
|
|
|
sctp_pathmtu_adjustment(stcb, net->mtu);
|
|
|
|
}
|
2007-05-28 11:17:24 +00:00
|
|
|
}
|
|
|
|
}
|
2021-04-30 10:27:47 +00:00
|
|
|
if (paddrp->spp_pathmtu > 0) {
|
|
|
|
stcb->asoc.default_mtu = paddrp->spp_pathmtu;
|
|
|
|
}
|
2011-09-17 08:50:29 +00:00
|
|
|
sctp_stcb_feature_on(inp, stcb, SCTP_PCB_FLAGS_DO_NOT_PMTUD);
|
2007-05-28 11:17:24 +00:00
|
|
|
}
|
|
|
|
if (paddrp->spp_flags & SPP_PMTUD_ENABLE) {
|
|
|
|
TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
|
2011-09-17 08:50:29 +00:00
|
|
|
if (!SCTP_OS_TIMER_PENDING(&net->pmtu_timer.timer)) {
|
2007-05-28 11:17:24 +00:00
|
|
|
sctp_timer_start(SCTP_TIMER_TYPE_PATHMTURAISE, inp, stcb, net);
|
|
|
|
}
|
2011-09-17 08:50:29 +00:00
|
|
|
net->dest_state &= ~SCTP_ADDR_NO_PMTUD;
|
2007-05-28 11:17:24 +00:00
|
|
|
}
|
2017-11-03 20:46:12 +00:00
|
|
|
stcb->asoc.default_mtu = 0;
|
2011-09-17 08:50:29 +00:00
|
|
|
sctp_stcb_feature_off(inp, stcb, SCTP_PCB_FLAGS_DO_NOT_PMTUD);
|
2007-05-28 11:17:24 +00:00
|
|
|
}
|
2011-08-14 20:55:32 +00:00
|
|
|
if (paddrp->spp_flags & SPP_DSCP) {
|
2007-05-28 11:17:24 +00:00
|
|
|
TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
|
2011-10-11 13:24:37 +00:00
|
|
|
net->dscp = paddrp->spp_dscp & 0xfc;
|
2011-09-14 08:15:21 +00:00
|
|
|
net->dscp |= 0x01;
|
2007-05-28 11:17:24 +00:00
|
|
|
}
|
2011-10-11 13:24:37 +00:00
|
|
|
stcb->asoc.default_dscp = paddrp->spp_dscp & 0xfc;
|
2011-09-14 08:15:21 +00:00
|
|
|
stcb->asoc.default_dscp |= 0x01;
|
2011-08-03 20:21:00 +00:00
|
|
|
}
|
2011-09-14 08:15:21 +00:00
|
|
|
#ifdef INET6
|
2011-08-03 20:21:00 +00:00
|
|
|
if (paddrp->spp_flags & SPP_IPV6_FLOWLABEL) {
|
|
|
|
TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
|
2011-09-14 08:15:21 +00:00
|
|
|
if (net->ro._l_addr.sa.sa_family == AF_INET6) {
|
|
|
|
net->flowlabel = paddrp->spp_ipv6_flowlabel & 0x000fffff;
|
|
|
|
net->flowlabel |= 0x80000000;
|
|
|
|
}
|
2011-08-03 20:21:00 +00:00
|
|
|
}
|
2011-09-14 08:15:21 +00:00
|
|
|
stcb->asoc.default_flowlabel = paddrp->spp_ipv6_flowlabel & 0x000fffff;
|
|
|
|
stcb->asoc.default_flowlabel |= 0x80000000;
|
2011-08-03 20:21:00 +00:00
|
|
|
}
|
2011-09-14 08:15:21 +00:00
|
|
|
#endif
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
|
|
|
/************************NO TCB, SET TO default stuff ******************/
|
2011-08-16 21:04:18 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(paddrp->spp_assoc_id == SCTP_FUTURE_ASSOC))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
/*
|
|
|
|
* For the TOS/FLOWLABEL stuff you
|
|
|
|
* set it with the options on the
|
|
|
|
* socket
|
|
|
|
*/
|
2021-04-30 10:27:47 +00:00
|
|
|
if (paddrp->spp_pathmaxrxt > 0) {
|
2011-06-15 23:50:27 +00:00
|
|
|
inp->sctp_ep.def_net_failure = paddrp->spp_pathmaxrxt;
|
|
|
|
}
|
2018-07-19 20:16:33 +00:00
|
|
|
|
2011-06-15 23:50:27 +00:00
|
|
|
if (paddrp->spp_flags & SPP_HB_TIME_IS_ZERO)
|
|
|
|
inp->sctp_ep.sctp_timeoutticks[SCTP_TIMER_HEARTBEAT] = 0;
|
2014-12-06 20:00:08 +00:00
|
|
|
else if (paddrp->spp_hbinterval != 0) {
|
2011-06-15 23:50:27 +00:00
|
|
|
if (paddrp->spp_hbinterval > SCTP_MAX_HB_INTERVAL)
|
|
|
|
paddrp->spp_hbinterval = SCTP_MAX_HB_INTERVAL;
|
2020-03-28 20:25:45 +00:00
|
|
|
inp->sctp_ep.sctp_timeoutticks[SCTP_TIMER_HEARTBEAT] = sctp_msecs_to_ticks(paddrp->spp_hbinterval);
|
2011-06-15 23:50:27 +00:00
|
|
|
}
|
2018-07-19 20:16:33 +00:00
|
|
|
|
2011-06-15 23:50:27 +00:00
|
|
|
if (paddrp->spp_flags & SPP_HB_ENABLE) {
|
2011-08-03 20:21:00 +00:00
|
|
|
if (paddrp->spp_flags & SPP_HB_TIME_IS_ZERO) {
|
|
|
|
inp->sctp_ep.sctp_timeoutticks[SCTP_TIMER_HEARTBEAT] = 0;
|
|
|
|
} else if (paddrp->spp_hbinterval) {
|
2020-03-28 20:25:45 +00:00
|
|
|
inp->sctp_ep.sctp_timeoutticks[SCTP_TIMER_HEARTBEAT] = sctp_msecs_to_ticks(paddrp->spp_hbinterval);
|
2011-08-03 20:21:00 +00:00
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
sctp_feature_off(inp, SCTP_PCB_FLAGS_DONOT_HEARTBEAT);
|
|
|
|
} else if (paddrp->spp_flags & SPP_HB_DISABLE) {
|
|
|
|
sctp_feature_on(inp, SCTP_PCB_FLAGS_DONOT_HEARTBEAT);
|
|
|
|
}
|
2011-09-17 08:50:29 +00:00
|
|
|
if (paddrp->spp_flags & SPP_PMTUD_ENABLE) {
|
2017-11-03 20:46:12 +00:00
|
|
|
inp->sctp_ep.default_mtu = 0;
|
2011-09-17 08:50:29 +00:00
|
|
|
sctp_feature_off(inp, SCTP_PCB_FLAGS_DO_NOT_PMTUD);
|
|
|
|
} else if (paddrp->spp_flags & SPP_PMTUD_DISABLE) {
|
2021-04-30 10:27:47 +00:00
|
|
|
if (paddrp->spp_pathmtu > 0) {
|
|
|
|
inp->sctp_ep.default_mtu = paddrp->spp_pathmtu;
|
|
|
|
}
|
2011-09-17 08:50:29 +00:00
|
|
|
sctp_feature_on(inp, SCTP_PCB_FLAGS_DO_NOT_PMTUD);
|
|
|
|
}
|
2011-09-14 08:15:21 +00:00
|
|
|
if (paddrp->spp_flags & SPP_DSCP) {
|
2011-10-11 13:24:37 +00:00
|
|
|
inp->sctp_ep.default_dscp = paddrp->spp_dscp & 0xfc;
|
2011-09-14 08:15:21 +00:00
|
|
|
inp->sctp_ep.default_dscp |= 0x01;
|
|
|
|
}
|
|
|
|
#ifdef INET6
|
|
|
|
if (paddrp->spp_flags & SPP_IPV6_FLOWLABEL) {
|
|
|
|
if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) {
|
|
|
|
inp->sctp_ep.default_flowlabel = paddrp->spp_ipv6_flowlabel & 0x000fffff;
|
|
|
|
inp->sctp_ep.default_flowlabel |= 0x80000000;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_WUNLOCK(inp);
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
case SCTP_RTOINFO:
|
|
|
|
{
|
|
|
|
struct sctp_rtoinfo *srto;
|
2007-05-17 12:16:24 +00:00
|
|
|
uint32_t new_init, new_min, new_max;
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_CHECK_AND_CAST(srto, optval, struct sctp_rtoinfo, optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, srto->srto_assoc_id);
|
|
|
|
|
|
|
|
if (stcb) {
|
2007-03-15 11:27:14 +00:00
|
|
|
if (srto->srto_initial)
|
2007-05-17 12:16:24 +00:00
|
|
|
new_init = srto->srto_initial;
|
|
|
|
else
|
|
|
|
new_init = stcb->asoc.initial_rto;
|
2007-03-15 11:27:14 +00:00
|
|
|
if (srto->srto_max)
|
2007-05-17 12:16:24 +00:00
|
|
|
new_max = srto->srto_max;
|
|
|
|
else
|
|
|
|
new_max = stcb->asoc.maxrto;
|
2007-03-15 11:27:14 +00:00
|
|
|
if (srto->srto_min)
|
2007-05-17 12:16:24 +00:00
|
|
|
new_min = srto->srto_min;
|
|
|
|
else
|
|
|
|
new_min = stcb->asoc.minrto;
|
|
|
|
if ((new_min <= new_init) && (new_init <= new_max)) {
|
|
|
|
stcb->asoc.initial_rto = new_init;
|
|
|
|
stcb->asoc.maxrto = new_max;
|
|
|
|
stcb->asoc.minrto = new_min;
|
|
|
|
} else {
|
2008-06-14 07:58:05 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
2007-05-17 12:16:24 +00:00
|
|
|
}
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
2011-08-16 21:04:18 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(srto->srto_assoc_id == SCTP_FUTURE_ASSOC))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
if (srto->srto_initial)
|
|
|
|
new_init = srto->srto_initial;
|
|
|
|
else
|
|
|
|
new_init = inp->sctp_ep.initial_rto;
|
|
|
|
if (srto->srto_max)
|
|
|
|
new_max = srto->srto_max;
|
|
|
|
else
|
|
|
|
new_max = inp->sctp_ep.sctp_maxrto;
|
|
|
|
if (srto->srto_min)
|
|
|
|
new_min = srto->srto_min;
|
|
|
|
else
|
|
|
|
new_min = inp->sctp_ep.sctp_minrto;
|
|
|
|
if ((new_min <= new_init) && (new_init <= new_max)) {
|
|
|
|
inp->sctp_ep.initial_rto = new_init;
|
|
|
|
inp->sctp_ep.sctp_maxrto = new_max;
|
|
|
|
inp->sctp_ep.sctp_minrto = new_min;
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
2007-05-17 12:16:24 +00:00
|
|
|
} else {
|
2008-06-14 07:58:05 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
2007-05-17 12:16:24 +00:00
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
case SCTP_ASSOCINFO:
|
|
|
|
{
|
|
|
|
struct sctp_assocparams *sasoc;
|
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_CHECK_AND_CAST(sasoc, optval, struct sctp_assocparams, optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, sasoc->sasoc_assoc_id);
|
2020-10-16 10:44:48 +00:00
|
|
|
if (sasoc->sasoc_cookie_life > 0) {
|
2007-07-17 20:58:26 +00:00
|
|
|
/* boundary check the cookie life */
|
2020-10-16 10:44:48 +00:00
|
|
|
if (sasoc->sasoc_cookie_life < SCTP_MIN_COOKIE_LIFE) {
|
|
|
|
sasoc->sasoc_cookie_life = SCTP_MIN_COOKIE_LIFE;
|
|
|
|
}
|
2007-07-17 20:58:26 +00:00
|
|
|
if (sasoc->sasoc_cookie_life > SCTP_MAX_COOKIE_LIFE) {
|
|
|
|
sasoc->sasoc_cookie_life = SCTP_MAX_COOKIE_LIFE;
|
|
|
|
}
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
if (stcb) {
|
2020-10-16 10:44:48 +00:00
|
|
|
if (sasoc->sasoc_asocmaxrxt > 0) {
|
2006-11-03 15:23:16 +00:00
|
|
|
stcb->asoc.max_send_times = sasoc->sasoc_asocmaxrxt;
|
2020-10-16 10:44:48 +00:00
|
|
|
}
|
|
|
|
if (sasoc->sasoc_cookie_life > 0) {
|
2020-03-28 20:25:45 +00:00
|
|
|
stcb->asoc.cookie_life = sctp_msecs_to_ticks(sasoc->sasoc_cookie_life);
|
2007-03-15 11:27:14 +00:00
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
2011-08-16 21:04:18 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(sasoc->sasoc_assoc_id == SCTP_FUTURE_ASSOC))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_WLOCK(inp);
|
2020-10-16 10:44:48 +00:00
|
|
|
if (sasoc->sasoc_asocmaxrxt > 0) {
|
2011-06-15 23:50:27 +00:00
|
|
|
inp->sctp_ep.max_send_times = sasoc->sasoc_asocmaxrxt;
|
2020-10-16 10:44:48 +00:00
|
|
|
}
|
|
|
|
if (sasoc->sasoc_cookie_life > 0) {
|
2020-03-28 20:25:45 +00:00
|
|
|
inp->sctp_ep.def_cookie_life = sctp_msecs_to_ticks(sasoc->sasoc_cookie_life);
|
2011-06-15 23:50:27 +00:00
|
|
|
}
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
2007-03-15 11:27:14 +00:00
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
case SCTP_INITMSG:
|
|
|
|
{
|
|
|
|
struct sctp_initmsg *sinit;
|
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_CHECK_AND_CAST(sinit, optval, struct sctp_initmsg, optsize);
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
if (sinit->sinit_num_ostreams)
|
|
|
|
inp->sctp_ep.pre_open_stream_count = sinit->sinit_num_ostreams;
|
|
|
|
|
|
|
|
if (sinit->sinit_max_instreams)
|
|
|
|
inp->sctp_ep.max_open_streams_intome = sinit->sinit_max_instreams;
|
|
|
|
|
|
|
|
if (sinit->sinit_max_attempts)
|
|
|
|
inp->sctp_ep.max_init_times = sinit->sinit_max_attempts;
|
|
|
|
|
2007-03-15 11:27:14 +00:00
|
|
|
if (sinit->sinit_max_init_timeo)
|
2006-11-03 15:23:16 +00:00
|
|
|
inp->sctp_ep.initial_init_rto_max = sinit->sinit_max_init_timeo;
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
case SCTP_PRIMARY_ADDR:
|
|
|
|
{
|
|
|
|
struct sctp_setprim *spa;
|
2011-06-15 23:50:27 +00:00
|
|
|
struct sctp_nets *net;
|
2014-12-06 20:00:08 +00:00
|
|
|
struct sockaddr *addr;
|
|
|
|
#if defined(INET) && defined(INET6)
|
|
|
|
struct sockaddr_in sin_store;
|
|
|
|
#endif
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_CHECK_AND_CAST(spa, optval, struct sctp_setprim, optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, spa->ssp_assoc_id);
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2014-12-06 20:00:08 +00:00
|
|
|
#if defined(INET) && defined(INET6)
|
|
|
|
if (spa->ssp_addr.ss_family == AF_INET6) {
|
|
|
|
struct sockaddr_in6 *sin6;
|
|
|
|
|
|
|
|
sin6 = (struct sockaddr_in6 *)&spa->ssp_addr;
|
|
|
|
if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
|
|
|
|
in6_sin6_2_sin(&sin_store, sin6);
|
|
|
|
addr = (struct sockaddr *)&sin_store;
|
|
|
|
} else {
|
|
|
|
addr = (struct sockaddr *)&spa->ssp_addr;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
addr = (struct sockaddr *)&spa->ssp_addr;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
addr = (struct sockaddr *)&spa->ssp_addr;
|
|
|
|
#endif
|
|
|
|
if (stcb != NULL) {
|
|
|
|
net = sctp_findnet(stcb, addr);
|
2007-02-12 23:24:31 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* We increment here since
|
|
|
|
* sctp_findassociation_ep_addr() wil do a
|
|
|
|
* decrement if it finds the stcb as long as
|
|
|
|
* the locked tcb (last argument) is NOT a
|
|
|
|
* TCB.. aka NULL.
|
|
|
|
*/
|
2014-12-06 20:00:08 +00:00
|
|
|
net = NULL;
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_INP_INCR_REF(inp);
|
2014-12-06 20:00:08 +00:00
|
|
|
stcb = sctp_findassociation_ep_addr(&inp, addr,
|
2006-11-03 15:23:16 +00:00
|
|
|
&net, NULL, NULL);
|
|
|
|
if (stcb == NULL) {
|
|
|
|
SCTP_INP_DECR_REF(inp);
|
|
|
|
}
|
|
|
|
}
|
2007-02-12 23:24:31 +00:00
|
|
|
|
2014-12-06 20:00:08 +00:00
|
|
|
if ((stcb != NULL) && (net != NULL)) {
|
2015-06-19 12:48:22 +00:00
|
|
|
if (net != stcb->asoc.primary_destination) {
|
|
|
|
if (!(net->dest_state & SCTP_ADDR_UNCONFIRMED)) {
|
|
|
|
/* Ok we need to set it */
|
|
|
|
if (sctp_set_primary_addr(stcb, (struct sockaddr *)NULL, net) == 0) {
|
|
|
|
if ((stcb->asoc.alternate) &&
|
|
|
|
(!(net->dest_state & SCTP_ADDR_PF)) &&
|
|
|
|
(net->dest_state & SCTP_ADDR_REACHABLE)) {
|
|
|
|
sctp_free_remote_addr(stcb->asoc.alternate);
|
|
|
|
stcb->asoc.alternate = NULL;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
2007-02-12 23:24:31 +00:00
|
|
|
}
|
2015-06-19 12:48:22 +00:00
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
}
|
2007-02-12 23:24:31 +00:00
|
|
|
} else {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2007-02-12 23:24:31 +00:00
|
|
|
error = EINVAL;
|
|
|
|
}
|
2014-12-06 20:00:08 +00:00
|
|
|
if (stcb != NULL) {
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2007-03-15 11:27:14 +00:00
|
|
|
case SCTP_SET_DYNAMIC_PRIMARY:
|
|
|
|
{
|
|
|
|
union sctp_sockstore *ss;
|
|
|
|
|
2007-06-12 00:12:01 +00:00
|
|
|
error = priv_check(curthread,
|
|
|
|
PRIV_NETINET_RESERVEDPORT);
|
2007-03-15 11:27:14 +00:00
|
|
|
if (error)
|
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2007-03-15 11:27:14 +00:00
|
|
|
SCTP_CHECK_AND_CAST(ss, optval, union sctp_sockstore, optsize);
|
|
|
|
/* SUPER USER CHECK? */
|
|
|
|
error = sctp_dynamic_set_primary(&ss->sa, vrf_id);
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2007-03-15 11:27:14 +00:00
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
case SCTP_SET_PEER_PRIMARY_ADDR:
|
|
|
|
{
|
|
|
|
struct sctp_setpeerprim *sspp;
|
2014-12-06 20:00:08 +00:00
|
|
|
struct sockaddr *addr;
|
|
|
|
#if defined(INET) && defined(INET6)
|
|
|
|
struct sockaddr_in sin_store;
|
|
|
|
#endif
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2007-02-12 23:24:31 +00:00
|
|
|
SCTP_CHECK_AND_CAST(sspp, optval, struct sctp_setpeerprim, optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, sspp->sspp_assoc_id);
|
2007-05-02 12:50:13 +00:00
|
|
|
if (stcb != NULL) {
|
2007-05-28 11:17:24 +00:00
|
|
|
struct sctp_ifa *ifa;
|
|
|
|
|
2014-12-06 20:00:08 +00:00
|
|
|
#if defined(INET) && defined(INET6)
|
|
|
|
if (sspp->sspp_addr.ss_family == AF_INET6) {
|
|
|
|
struct sockaddr_in6 *sin6;
|
|
|
|
|
|
|
|
sin6 = (struct sockaddr_in6 *)&sspp->sspp_addr;
|
|
|
|
if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
|
|
|
|
in6_sin6_2_sin(&sin_store, sin6);
|
|
|
|
addr = (struct sockaddr *)&sin_store;
|
|
|
|
} else {
|
|
|
|
addr = (struct sockaddr *)&sspp->sspp_addr;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
addr = (struct sockaddr *)&sspp->sspp_addr;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
addr = (struct sockaddr *)&sspp->sspp_addr;
|
|
|
|
#endif
|
|
|
|
ifa = sctp_find_ifa_by_addr(addr, stcb->asoc.vrf_id, SCTP_ADDR_NOT_LOCKED);
|
2007-05-28 11:17:24 +00:00
|
|
|
if (ifa == NULL) {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2007-05-28 11:17:24 +00:00
|
|
|
error = EINVAL;
|
|
|
|
goto out_of_it;
|
|
|
|
}
|
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) == 0) {
|
2016-12-26 11:06:41 +00:00
|
|
|
/*
|
|
|
|
* Must validate the ifa found is in
|
|
|
|
* our ep
|
|
|
|
*/
|
2007-05-28 11:17:24 +00:00
|
|
|
struct sctp_laddr *laddr;
|
|
|
|
int found = 0;
|
|
|
|
|
|
|
|
LIST_FOREACH(laddr, &inp->sctp_addr_list, sctp_nxt_addr) {
|
|
|
|
if (laddr->ifa == NULL) {
|
|
|
|
SCTPDBG(SCTP_DEBUG_OUTPUT1, "%s: NULL ifa\n",
|
2015-10-19 11:17:54 +00:00
|
|
|
__func__);
|
2007-05-28 11:17:24 +00:00
|
|
|
continue;
|
|
|
|
}
|
2016-03-28 19:32:13 +00:00
|
|
|
if ((sctp_is_addr_restricted(stcb, laddr->ifa)) &&
|
|
|
|
(!sctp_is_addr_pending(stcb, laddr->ifa))) {
|
|
|
|
continue;
|
|
|
|
}
|
2007-05-28 11:17:24 +00:00
|
|
|
if (laddr->ifa == ifa) {
|
|
|
|
found = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!found) {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2007-05-28 11:17:24 +00:00
|
|
|
error = EINVAL;
|
|
|
|
goto out_of_it;
|
|
|
|
}
|
2014-06-20 13:26:49 +00:00
|
|
|
} else {
|
2014-12-06 20:00:08 +00:00
|
|
|
switch (addr->sa_family) {
|
2014-06-20 13:26:49 +00:00
|
|
|
#ifdef INET
|
|
|
|
case AF_INET:
|
|
|
|
{
|
|
|
|
struct sockaddr_in *sin;
|
|
|
|
|
2014-12-06 20:00:08 +00:00
|
|
|
sin = (struct sockaddr_in *)addr;
|
2014-06-20 13:26:49 +00:00
|
|
|
if (prison_check_ip4(inp->ip_inp.inp.inp_cred,
|
|
|
|
&sin->sin_addr) != 0) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
goto out_of_it;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
#ifdef INET6
|
|
|
|
case AF_INET6:
|
|
|
|
{
|
|
|
|
struct sockaddr_in6 *sin6;
|
|
|
|
|
2014-12-06 20:00:08 +00:00
|
|
|
sin6 = (struct sockaddr_in6 *)addr;
|
2014-06-20 13:26:49 +00:00
|
|
|
if (prison_check_ip6(inp->ip_inp.inp.inp_cred,
|
|
|
|
&sin6->sin6_addr) != 0) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
goto out_of_it;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
default:
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
goto out_of_it;
|
|
|
|
}
|
2007-05-28 11:17:24 +00:00
|
|
|
}
|
2014-12-06 20:00:08 +00:00
|
|
|
if (sctp_set_primary_ip_address_sa(stcb, addr) != 0) {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2007-02-12 23:24:31 +00:00
|
|
|
error = EINVAL;
|
|
|
|
}
|
2016-03-23 13:28:04 +00:00
|
|
|
sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_SOCKOPT, SCTP_SO_LOCKED);
|
2007-05-28 11:17:24 +00:00
|
|
|
out_of_it:
|
2007-05-02 12:50:13 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
2007-02-12 23:24:31 +00:00
|
|
|
} else {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2006-11-03 15:23:16 +00:00
|
|
|
error = EINVAL;
|
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
case SCTP_BINDX_ADD_ADDR:
|
|
|
|
{
|
2020-06-20 21:06:02 +00:00
|
|
|
struct sockaddr *sa;
|
2007-07-17 20:58:26 +00:00
|
|
|
struct thread *td;
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2007-07-17 20:58:26 +00:00
|
|
|
td = (struct thread *)p;
|
2020-06-20 21:06:02 +00:00
|
|
|
SCTP_CHECK_AND_CAST(sa, optval, struct sockaddr, optsize);
|
2011-04-30 11:18:16 +00:00
|
|
|
#ifdef INET
|
2020-06-20 21:06:02 +00:00
|
|
|
if (sa->sa_family == AF_INET) {
|
|
|
|
if (optsize < sizeof(struct sockaddr_in)) {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2007-07-17 20:58:26 +00:00
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
2020-06-20 21:06:02 +00:00
|
|
|
if (td != NULL &&
|
|
|
|
(error = prison_local_ip4(td->td_ucred, &(((struct sockaddr_in *)sa)->sin_addr)))) {
|
2009-02-13 18:44:30 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, stcb, NULL, SCTP_FROM_SCTP_USRREQ, error);
|
MFp4:
Bring in updated jail support from bz_jail branch.
This enhances the current jail implementation to permit multiple
addresses per jail. In addtion to IPv4, IPv6 is supported as well.
Due to updated checks it is even possible to have jails without
an IP address at all, which basically gives one a chroot with
restricted process view, no networking,..
SCTP support was updated and supports IPv6 in jails as well.
Cpuset support permits jails to be bound to specific processor
sets after creation.
Jails can have an unrestricted (no duplicate protection, etc.) name
in addition to the hostname. The jail name cannot be changed from
within a jail and is considered to be used for management purposes
or as audit-token in the future.
DDB 'show jails' command was added to aid debugging.
Proper compat support permits 32bit jail binaries to be used on 64bit
systems to manage jails. Also backward compatibility was preserved where
possible: for jail v1 syscalls, as well as with user space management
utilities.
Both jail as well as prison version were updated for the new features.
A gap was intentionally left as the intermediate versions had been
used by various patches floating around the last years.
Bump __FreeBSD_version for the afore mentioned and in kernel changes.
Special thanks to:
- Pawel Jakub Dawidek (pjd) for his multi-IPv4 patches
and Olivier Houchard (cognet) for initial single-IPv6 patches.
- Jeff Roberson (jeff) and Randall Stewart (rrs) for their
help, ideas and review on cpuset and SCTP support.
- Robert Watson (rwatson) for lots and lots of help, discussions,
suggestions and review of most of the patch at various stages.
- John Baldwin (jhb) for his help.
- Simon L. Nielsen (simon) as early adopter testing changes
on cluster machines as well as all the testers and people
who provided feedback the last months on freebsd-jail and
other channels.
- My employer, CK Software GmbH, for the support so I could work on this.
Reviewed by: (see above)
MFC after: 3 months (this is just so that I get the mail)
X-MFC Before: 7.2-RELEASE if possible
2008-11-29 14:32:14 +00:00
|
|
|
break;
|
2007-07-17 20:58:26 +00:00
|
|
|
}
|
2011-04-30 11:18:16 +00:00
|
|
|
} else
|
|
|
|
#endif
|
MFp4:
Bring in updated jail support from bz_jail branch.
This enhances the current jail implementation to permit multiple
addresses per jail. In addtion to IPv4, IPv6 is supported as well.
Due to updated checks it is even possible to have jails without
an IP address at all, which basically gives one a chroot with
restricted process view, no networking,..
SCTP support was updated and supports IPv6 in jails as well.
Cpuset support permits jails to be bound to specific processor
sets after creation.
Jails can have an unrestricted (no duplicate protection, etc.) name
in addition to the hostname. The jail name cannot be changed from
within a jail and is considered to be used for management purposes
or as audit-token in the future.
DDB 'show jails' command was added to aid debugging.
Proper compat support permits 32bit jail binaries to be used on 64bit
systems to manage jails. Also backward compatibility was preserved where
possible: for jail v1 syscalls, as well as with user space management
utilities.
Both jail as well as prison version were updated for the new features.
A gap was intentionally left as the intermediate versions had been
used by various patches floating around the last years.
Bump __FreeBSD_version for the afore mentioned and in kernel changes.
Special thanks to:
- Pawel Jakub Dawidek (pjd) for his multi-IPv4 patches
and Olivier Houchard (cognet) for initial single-IPv6 patches.
- Jeff Roberson (jeff) and Randall Stewart (rrs) for their
help, ideas and review on cpuset and SCTP support.
- Robert Watson (rwatson) for lots and lots of help, discussions,
suggestions and review of most of the patch at various stages.
- John Baldwin (jhb) for his help.
- Simon L. Nielsen (simon) as early adopter testing changes
on cluster machines as well as all the testers and people
who provided feedback the last months on freebsd-jail and
other channels.
- My employer, CK Software GmbH, for the support so I could work on this.
Reviewed by: (see above)
MFC after: 3 months (this is just so that I get the mail)
X-MFC Before: 7.2-RELEASE if possible
2008-11-29 14:32:14 +00:00
|
|
|
#ifdef INET6
|
2020-06-20 21:06:02 +00:00
|
|
|
if (sa->sa_family == AF_INET6) {
|
|
|
|
if (optsize < sizeof(struct sockaddr_in6)) {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2007-07-17 20:58:26 +00:00
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
2020-06-20 21:06:02 +00:00
|
|
|
if (td != NULL &&
|
|
|
|
(error = prison_local_ip6(td->td_ucred,
|
|
|
|
&(((struct sockaddr_in6 *)sa)->sin6_addr),
|
2009-02-13 18:44:30 +00:00
|
|
|
(SCTP_IPV6_V6ONLY(inp) != 0))) != 0) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, stcb, NULL, SCTP_FROM_SCTP_USRREQ, error);
|
MFp4:
Bring in updated jail support from bz_jail branch.
This enhances the current jail implementation to permit multiple
addresses per jail. In addtion to IPv4, IPv6 is supported as well.
Due to updated checks it is even possible to have jails without
an IP address at all, which basically gives one a chroot with
restricted process view, no networking,..
SCTP support was updated and supports IPv6 in jails as well.
Cpuset support permits jails to be bound to specific processor
sets after creation.
Jails can have an unrestricted (no duplicate protection, etc.) name
in addition to the hostname. The jail name cannot be changed from
within a jail and is considered to be used for management purposes
or as audit-token in the future.
DDB 'show jails' command was added to aid debugging.
Proper compat support permits 32bit jail binaries to be used on 64bit
systems to manage jails. Also backward compatibility was preserved where
possible: for jail v1 syscalls, as well as with user space management
utilities.
Both jail as well as prison version were updated for the new features.
A gap was intentionally left as the intermediate versions had been
used by various patches floating around the last years.
Bump __FreeBSD_version for the afore mentioned and in kernel changes.
Special thanks to:
- Pawel Jakub Dawidek (pjd) for his multi-IPv4 patches
and Olivier Houchard (cognet) for initial single-IPv6 patches.
- Jeff Roberson (jeff) and Randall Stewart (rrs) for their
help, ideas and review on cpuset and SCTP support.
- Robert Watson (rwatson) for lots and lots of help, discussions,
suggestions and review of most of the patch at various stages.
- John Baldwin (jhb) for his help.
- Simon L. Nielsen (simon) as early adopter testing changes
on cluster machines as well as all the testers and people
who provided feedback the last months on freebsd-jail and
other channels.
- My employer, CK Software GmbH, for the support so I could work on this.
Reviewed by: (see above)
MFC after: 3 months (this is just so that I get the mail)
X-MFC Before: 7.2-RELEASE if possible
2008-11-29 14:32:14 +00:00
|
|
|
break;
|
|
|
|
}
|
2011-04-30 11:18:16 +00:00
|
|
|
} else
|
MFp4:
Bring in updated jail support from bz_jail branch.
This enhances the current jail implementation to permit multiple
addresses per jail. In addtion to IPv4, IPv6 is supported as well.
Due to updated checks it is even possible to have jails without
an IP address at all, which basically gives one a chroot with
restricted process view, no networking,..
SCTP support was updated and supports IPv6 in jails as well.
Cpuset support permits jails to be bound to specific processor
sets after creation.
Jails can have an unrestricted (no duplicate protection, etc.) name
in addition to the hostname. The jail name cannot be changed from
within a jail and is considered to be used for management purposes
or as audit-token in the future.
DDB 'show jails' command was added to aid debugging.
Proper compat support permits 32bit jail binaries to be used on 64bit
systems to manage jails. Also backward compatibility was preserved where
possible: for jail v1 syscalls, as well as with user space management
utilities.
Both jail as well as prison version were updated for the new features.
A gap was intentionally left as the intermediate versions had been
used by various patches floating around the last years.
Bump __FreeBSD_version for the afore mentioned and in kernel changes.
Special thanks to:
- Pawel Jakub Dawidek (pjd) for his multi-IPv4 patches
and Olivier Houchard (cognet) for initial single-IPv6 patches.
- Jeff Roberson (jeff) and Randall Stewart (rrs) for their
help, ideas and review on cpuset and SCTP support.
- Robert Watson (rwatson) for lots and lots of help, discussions,
suggestions and review of most of the patch at various stages.
- John Baldwin (jhb) for his help.
- Simon L. Nielsen (simon) as early adopter testing changes
on cluster machines as well as all the testers and people
who provided feedback the last months on freebsd-jail and
other channels.
- My employer, CK Software GmbH, for the support so I could work on this.
Reviewed by: (see above)
MFC after: 3 months (this is just so that I get the mail)
X-MFC Before: 7.2-RELEASE if possible
2008-11-29 14:32:14 +00:00
|
|
|
#endif
|
2011-04-30 11:18:16 +00:00
|
|
|
{
|
MFp4:
Bring in updated jail support from bz_jail branch.
This enhances the current jail implementation to permit multiple
addresses per jail. In addtion to IPv4, IPv6 is supported as well.
Due to updated checks it is even possible to have jails without
an IP address at all, which basically gives one a chroot with
restricted process view, no networking,..
SCTP support was updated and supports IPv6 in jails as well.
Cpuset support permits jails to be bound to specific processor
sets after creation.
Jails can have an unrestricted (no duplicate protection, etc.) name
in addition to the hostname. The jail name cannot be changed from
within a jail and is considered to be used for management purposes
or as audit-token in the future.
DDB 'show jails' command was added to aid debugging.
Proper compat support permits 32bit jail binaries to be used on 64bit
systems to manage jails. Also backward compatibility was preserved where
possible: for jail v1 syscalls, as well as with user space management
utilities.
Both jail as well as prison version were updated for the new features.
A gap was intentionally left as the intermediate versions had been
used by various patches floating around the last years.
Bump __FreeBSD_version for the afore mentioned and in kernel changes.
Special thanks to:
- Pawel Jakub Dawidek (pjd) for his multi-IPv4 patches
and Olivier Houchard (cognet) for initial single-IPv6 patches.
- Jeff Roberson (jeff) and Randall Stewart (rrs) for their
help, ideas and review on cpuset and SCTP support.
- Robert Watson (rwatson) for lots and lots of help, discussions,
suggestions and review of most of the patch at various stages.
- John Baldwin (jhb) for his help.
- Simon L. Nielsen (simon) as early adopter testing changes
on cluster machines as well as all the testers and people
who provided feedback the last months on freebsd-jail and
other channels.
- My employer, CK Software GmbH, for the support so I could work on this.
Reviewed by: (see above)
MFC after: 3 months (this is just so that I get the mail)
X-MFC Before: 7.2-RELEASE if possible
2008-11-29 14:32:14 +00:00
|
|
|
error = EAFNOSUPPORT;
|
|
|
|
break;
|
2007-07-17 20:58:26 +00:00
|
|
|
}
|
2020-06-20 21:06:02 +00:00
|
|
|
sctp_bindx_add_address(so, inp, sa, vrf_id, &error, p);
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
case SCTP_BINDX_REM_ADDR:
|
|
|
|
{
|
2020-06-20 21:06:02 +00:00
|
|
|
struct sockaddr *sa;
|
2007-07-17 20:58:26 +00:00
|
|
|
struct thread *td;
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2007-07-17 20:58:26 +00:00
|
|
|
td = (struct thread *)p;
|
MFp4:
Bring in updated jail support from bz_jail branch.
This enhances the current jail implementation to permit multiple
addresses per jail. In addtion to IPv4, IPv6 is supported as well.
Due to updated checks it is even possible to have jails without
an IP address at all, which basically gives one a chroot with
restricted process view, no networking,..
SCTP support was updated and supports IPv6 in jails as well.
Cpuset support permits jails to be bound to specific processor
sets after creation.
Jails can have an unrestricted (no duplicate protection, etc.) name
in addition to the hostname. The jail name cannot be changed from
within a jail and is considered to be used for management purposes
or as audit-token in the future.
DDB 'show jails' command was added to aid debugging.
Proper compat support permits 32bit jail binaries to be used on 64bit
systems to manage jails. Also backward compatibility was preserved where
possible: for jail v1 syscalls, as well as with user space management
utilities.
Both jail as well as prison version were updated for the new features.
A gap was intentionally left as the intermediate versions had been
used by various patches floating around the last years.
Bump __FreeBSD_version for the afore mentioned and in kernel changes.
Special thanks to:
- Pawel Jakub Dawidek (pjd) for his multi-IPv4 patches
and Olivier Houchard (cognet) for initial single-IPv6 patches.
- Jeff Roberson (jeff) and Randall Stewart (rrs) for their
help, ideas and review on cpuset and SCTP support.
- Robert Watson (rwatson) for lots and lots of help, discussions,
suggestions and review of most of the patch at various stages.
- John Baldwin (jhb) for his help.
- Simon L. Nielsen (simon) as early adopter testing changes
on cluster machines as well as all the testers and people
who provided feedback the last months on freebsd-jail and
other channels.
- My employer, CK Software GmbH, for the support so I could work on this.
Reviewed by: (see above)
MFC after: 3 months (this is just so that I get the mail)
X-MFC Before: 7.2-RELEASE if possible
2008-11-29 14:32:14 +00:00
|
|
|
|
2020-06-20 21:06:02 +00:00
|
|
|
SCTP_CHECK_AND_CAST(sa, optval, struct sockaddr, optsize);
|
2011-04-30 11:18:16 +00:00
|
|
|
#ifdef INET
|
2020-06-20 21:06:02 +00:00
|
|
|
if (sa->sa_family == AF_INET) {
|
|
|
|
if (optsize < sizeof(struct sockaddr_in)) {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2007-07-17 20:58:26 +00:00
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
2020-06-20 21:06:02 +00:00
|
|
|
if (td != NULL &&
|
|
|
|
(error = prison_local_ip4(td->td_ucred, &(((struct sockaddr_in *)sa)->sin_addr)))) {
|
2009-02-13 18:44:30 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, stcb, NULL, SCTP_FROM_SCTP_USRREQ, error);
|
MFp4:
Bring in updated jail support from bz_jail branch.
This enhances the current jail implementation to permit multiple
addresses per jail. In addtion to IPv4, IPv6 is supported as well.
Due to updated checks it is even possible to have jails without
an IP address at all, which basically gives one a chroot with
restricted process view, no networking,..
SCTP support was updated and supports IPv6 in jails as well.
Cpuset support permits jails to be bound to specific processor
sets after creation.
Jails can have an unrestricted (no duplicate protection, etc.) name
in addition to the hostname. The jail name cannot be changed from
within a jail and is considered to be used for management purposes
or as audit-token in the future.
DDB 'show jails' command was added to aid debugging.
Proper compat support permits 32bit jail binaries to be used on 64bit
systems to manage jails. Also backward compatibility was preserved where
possible: for jail v1 syscalls, as well as with user space management
utilities.
Both jail as well as prison version were updated for the new features.
A gap was intentionally left as the intermediate versions had been
used by various patches floating around the last years.
Bump __FreeBSD_version for the afore mentioned and in kernel changes.
Special thanks to:
- Pawel Jakub Dawidek (pjd) for his multi-IPv4 patches
and Olivier Houchard (cognet) for initial single-IPv6 patches.
- Jeff Roberson (jeff) and Randall Stewart (rrs) for their
help, ideas and review on cpuset and SCTP support.
- Robert Watson (rwatson) for lots and lots of help, discussions,
suggestions and review of most of the patch at various stages.
- John Baldwin (jhb) for his help.
- Simon L. Nielsen (simon) as early adopter testing changes
on cluster machines as well as all the testers and people
who provided feedback the last months on freebsd-jail and
other channels.
- My employer, CK Software GmbH, for the support so I could work on this.
Reviewed by: (see above)
MFC after: 3 months (this is just so that I get the mail)
X-MFC Before: 7.2-RELEASE if possible
2008-11-29 14:32:14 +00:00
|
|
|
break;
|
2007-07-17 20:58:26 +00:00
|
|
|
}
|
2011-04-30 11:18:16 +00:00
|
|
|
} else
|
|
|
|
#endif
|
MFp4:
Bring in updated jail support from bz_jail branch.
This enhances the current jail implementation to permit multiple
addresses per jail. In addtion to IPv4, IPv6 is supported as well.
Due to updated checks it is even possible to have jails without
an IP address at all, which basically gives one a chroot with
restricted process view, no networking,..
SCTP support was updated and supports IPv6 in jails as well.
Cpuset support permits jails to be bound to specific processor
sets after creation.
Jails can have an unrestricted (no duplicate protection, etc.) name
in addition to the hostname. The jail name cannot be changed from
within a jail and is considered to be used for management purposes
or as audit-token in the future.
DDB 'show jails' command was added to aid debugging.
Proper compat support permits 32bit jail binaries to be used on 64bit
systems to manage jails. Also backward compatibility was preserved where
possible: for jail v1 syscalls, as well as with user space management
utilities.
Both jail as well as prison version were updated for the new features.
A gap was intentionally left as the intermediate versions had been
used by various patches floating around the last years.
Bump __FreeBSD_version for the afore mentioned and in kernel changes.
Special thanks to:
- Pawel Jakub Dawidek (pjd) for his multi-IPv4 patches
and Olivier Houchard (cognet) for initial single-IPv6 patches.
- Jeff Roberson (jeff) and Randall Stewart (rrs) for their
help, ideas and review on cpuset and SCTP support.
- Robert Watson (rwatson) for lots and lots of help, discussions,
suggestions and review of most of the patch at various stages.
- John Baldwin (jhb) for his help.
- Simon L. Nielsen (simon) as early adopter testing changes
on cluster machines as well as all the testers and people
who provided feedback the last months on freebsd-jail and
other channels.
- My employer, CK Software GmbH, for the support so I could work on this.
Reviewed by: (see above)
MFC after: 3 months (this is just so that I get the mail)
X-MFC Before: 7.2-RELEASE if possible
2008-11-29 14:32:14 +00:00
|
|
|
#ifdef INET6
|
2020-06-20 21:06:02 +00:00
|
|
|
if (sa->sa_family == AF_INET6) {
|
|
|
|
if (optsize < sizeof(struct sockaddr_in6)) {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2007-07-17 20:58:26 +00:00
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
2011-08-03 20:21:00 +00:00
|
|
|
if (td != NULL &&
|
|
|
|
(error = prison_local_ip6(td->td_ucred,
|
2020-06-20 21:06:02 +00:00
|
|
|
&(((struct sockaddr_in6 *)sa)->sin6_addr),
|
2009-02-13 18:44:30 +00:00
|
|
|
(SCTP_IPV6_V6ONLY(inp) != 0))) != 0) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, stcb, NULL, SCTP_FROM_SCTP_USRREQ, error);
|
MFp4:
Bring in updated jail support from bz_jail branch.
This enhances the current jail implementation to permit multiple
addresses per jail. In addtion to IPv4, IPv6 is supported as well.
Due to updated checks it is even possible to have jails without
an IP address at all, which basically gives one a chroot with
restricted process view, no networking,..
SCTP support was updated and supports IPv6 in jails as well.
Cpuset support permits jails to be bound to specific processor
sets after creation.
Jails can have an unrestricted (no duplicate protection, etc.) name
in addition to the hostname. The jail name cannot be changed from
within a jail and is considered to be used for management purposes
or as audit-token in the future.
DDB 'show jails' command was added to aid debugging.
Proper compat support permits 32bit jail binaries to be used on 64bit
systems to manage jails. Also backward compatibility was preserved where
possible: for jail v1 syscalls, as well as with user space management
utilities.
Both jail as well as prison version were updated for the new features.
A gap was intentionally left as the intermediate versions had been
used by various patches floating around the last years.
Bump __FreeBSD_version for the afore mentioned and in kernel changes.
Special thanks to:
- Pawel Jakub Dawidek (pjd) for his multi-IPv4 patches
and Olivier Houchard (cognet) for initial single-IPv6 patches.
- Jeff Roberson (jeff) and Randall Stewart (rrs) for their
help, ideas and review on cpuset and SCTP support.
- Robert Watson (rwatson) for lots and lots of help, discussions,
suggestions and review of most of the patch at various stages.
- John Baldwin (jhb) for his help.
- Simon L. Nielsen (simon) as early adopter testing changes
on cluster machines as well as all the testers and people
who provided feedback the last months on freebsd-jail and
other channels.
- My employer, CK Software GmbH, for the support so I could work on this.
Reviewed by: (see above)
MFC after: 3 months (this is just so that I get the mail)
X-MFC Before: 7.2-RELEASE if possible
2008-11-29 14:32:14 +00:00
|
|
|
break;
|
|
|
|
}
|
2011-04-30 11:18:16 +00:00
|
|
|
} else
|
MFp4:
Bring in updated jail support from bz_jail branch.
This enhances the current jail implementation to permit multiple
addresses per jail. In addtion to IPv4, IPv6 is supported as well.
Due to updated checks it is even possible to have jails without
an IP address at all, which basically gives one a chroot with
restricted process view, no networking,..
SCTP support was updated and supports IPv6 in jails as well.
Cpuset support permits jails to be bound to specific processor
sets after creation.
Jails can have an unrestricted (no duplicate protection, etc.) name
in addition to the hostname. The jail name cannot be changed from
within a jail and is considered to be used for management purposes
or as audit-token in the future.
DDB 'show jails' command was added to aid debugging.
Proper compat support permits 32bit jail binaries to be used on 64bit
systems to manage jails. Also backward compatibility was preserved where
possible: for jail v1 syscalls, as well as with user space management
utilities.
Both jail as well as prison version were updated for the new features.
A gap was intentionally left as the intermediate versions had been
used by various patches floating around the last years.
Bump __FreeBSD_version for the afore mentioned and in kernel changes.
Special thanks to:
- Pawel Jakub Dawidek (pjd) for his multi-IPv4 patches
and Olivier Houchard (cognet) for initial single-IPv6 patches.
- Jeff Roberson (jeff) and Randall Stewart (rrs) for their
help, ideas and review on cpuset and SCTP support.
- Robert Watson (rwatson) for lots and lots of help, discussions,
suggestions and review of most of the patch at various stages.
- John Baldwin (jhb) for his help.
- Simon L. Nielsen (simon) as early adopter testing changes
on cluster machines as well as all the testers and people
who provided feedback the last months on freebsd-jail and
other channels.
- My employer, CK Software GmbH, for the support so I could work on this.
Reviewed by: (see above)
MFC after: 3 months (this is just so that I get the mail)
X-MFC Before: 7.2-RELEASE if possible
2008-11-29 14:32:14 +00:00
|
|
|
#endif
|
2011-04-30 11:18:16 +00:00
|
|
|
{
|
MFp4:
Bring in updated jail support from bz_jail branch.
This enhances the current jail implementation to permit multiple
addresses per jail. In addtion to IPv4, IPv6 is supported as well.
Due to updated checks it is even possible to have jails without
an IP address at all, which basically gives one a chroot with
restricted process view, no networking,..
SCTP support was updated and supports IPv6 in jails as well.
Cpuset support permits jails to be bound to specific processor
sets after creation.
Jails can have an unrestricted (no duplicate protection, etc.) name
in addition to the hostname. The jail name cannot be changed from
within a jail and is considered to be used for management purposes
or as audit-token in the future.
DDB 'show jails' command was added to aid debugging.
Proper compat support permits 32bit jail binaries to be used on 64bit
systems to manage jails. Also backward compatibility was preserved where
possible: for jail v1 syscalls, as well as with user space management
utilities.
Both jail as well as prison version were updated for the new features.
A gap was intentionally left as the intermediate versions had been
used by various patches floating around the last years.
Bump __FreeBSD_version for the afore mentioned and in kernel changes.
Special thanks to:
- Pawel Jakub Dawidek (pjd) for his multi-IPv4 patches
and Olivier Houchard (cognet) for initial single-IPv6 patches.
- Jeff Roberson (jeff) and Randall Stewart (rrs) for their
help, ideas and review on cpuset and SCTP support.
- Robert Watson (rwatson) for lots and lots of help, discussions,
suggestions and review of most of the patch at various stages.
- John Baldwin (jhb) for his help.
- Simon L. Nielsen (simon) as early adopter testing changes
on cluster machines as well as all the testers and people
who provided feedback the last months on freebsd-jail and
other channels.
- My employer, CK Software GmbH, for the support so I could work on this.
Reviewed by: (see above)
MFC after: 3 months (this is just so that I get the mail)
X-MFC Before: 7.2-RELEASE if possible
2008-11-29 14:32:14 +00:00
|
|
|
error = EAFNOSUPPORT;
|
|
|
|
break;
|
2007-07-17 20:58:26 +00:00
|
|
|
}
|
2020-06-20 21:06:02 +00:00
|
|
|
sctp_bindx_delete_address(inp, sa, vrf_id, &error);
|
2011-06-15 23:50:27 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case SCTP_EVENT:
|
|
|
|
{
|
|
|
|
struct sctp_event *event;
|
|
|
|
uint32_t event_type;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(event, optval, struct sctp_event, optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, event->se_assoc_id);
|
|
|
|
switch (event->se_type) {
|
|
|
|
case SCTP_ASSOC_CHANGE:
|
|
|
|
event_type = SCTP_PCB_FLAGS_RECVASSOCEVNT;
|
|
|
|
break;
|
|
|
|
case SCTP_PEER_ADDR_CHANGE:
|
|
|
|
event_type = SCTP_PCB_FLAGS_RECVPADDREVNT;
|
|
|
|
break;
|
|
|
|
case SCTP_REMOTE_ERROR:
|
|
|
|
event_type = SCTP_PCB_FLAGS_RECVPEERERR;
|
|
|
|
break;
|
|
|
|
case SCTP_SEND_FAILED:
|
|
|
|
event_type = SCTP_PCB_FLAGS_RECVSENDFAILEVNT;
|
|
|
|
break;
|
|
|
|
case SCTP_SHUTDOWN_EVENT:
|
|
|
|
event_type = SCTP_PCB_FLAGS_RECVSHUTDOWNEVNT;
|
|
|
|
break;
|
|
|
|
case SCTP_ADAPTATION_INDICATION:
|
|
|
|
event_type = SCTP_PCB_FLAGS_ADAPTATIONEVNT;
|
|
|
|
break;
|
|
|
|
case SCTP_PARTIAL_DELIVERY_EVENT:
|
|
|
|
event_type = SCTP_PCB_FLAGS_PDAPIEVNT;
|
|
|
|
break;
|
|
|
|
case SCTP_AUTHENTICATION_EVENT:
|
|
|
|
event_type = SCTP_PCB_FLAGS_AUTHEVNT;
|
|
|
|
break;
|
|
|
|
case SCTP_STREAM_RESET_EVENT:
|
|
|
|
event_type = SCTP_PCB_FLAGS_STREAM_RESETEVNT;
|
|
|
|
break;
|
|
|
|
case SCTP_SENDER_DRY_EVENT:
|
|
|
|
event_type = SCTP_PCB_FLAGS_DRYEVNT;
|
|
|
|
break;
|
|
|
|
case SCTP_NOTIFICATIONS_STOPPED_EVENT:
|
|
|
|
event_type = 0;
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOTSUP);
|
|
|
|
error = ENOTSUP;
|
|
|
|
break;
|
2012-05-04 15:49:08 +00:00
|
|
|
case SCTP_ASSOC_RESET_EVENT:
|
|
|
|
event_type = SCTP_PCB_FLAGS_ASSOC_RESETEVNT;
|
|
|
|
break;
|
|
|
|
case SCTP_STREAM_CHANGE_EVENT:
|
|
|
|
event_type = SCTP_PCB_FLAGS_STREAM_CHANGEEVNT;
|
|
|
|
break;
|
2012-05-06 11:02:53 +00:00
|
|
|
case SCTP_SEND_FAILED_EVENT:
|
|
|
|
event_type = SCTP_PCB_FLAGS_RECVNSENDFAILEVNT;
|
|
|
|
break;
|
2011-06-15 23:50:27 +00:00
|
|
|
default:
|
|
|
|
event_type = 0;
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (event_type > 0) {
|
|
|
|
if (stcb) {
|
|
|
|
if (event->se_on) {
|
|
|
|
sctp_stcb_feature_on(inp, stcb, event_type);
|
|
|
|
if (event_type == SCTP_PCB_FLAGS_DRYEVNT) {
|
|
|
|
if (TAILQ_EMPTY(&stcb->asoc.send_queue) &&
|
|
|
|
TAILQ_EMPTY(&stcb->asoc.sent_queue) &&
|
|
|
|
(stcb->asoc.stream_queue_cnt == 0)) {
|
|
|
|
sctp_ulp_notify(SCTP_NOTIFY_SENDER_DRY, stcb, 0, NULL, SCTP_SO_LOCKED);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
sctp_stcb_feature_off(inp, stcb, event_type);
|
|
|
|
}
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* We don't want to send up a storm
|
|
|
|
* of events, so return an error for
|
|
|
|
* sender dry events
|
|
|
|
*/
|
|
|
|
if ((event_type == SCTP_PCB_FLAGS_DRYEVNT) &&
|
2019-11-28 12:50:25 +00:00
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
2011-06-15 23:50:27 +00:00
|
|
|
((event->se_assoc_id == SCTP_ALL_ASSOC) ||
|
|
|
|
(event->se_assoc_id == SCTP_CURRENT_ASSOC))) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOTSUP);
|
|
|
|
error = ENOTSUP;
|
|
|
|
break;
|
|
|
|
}
|
2011-08-16 21:04:18 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
((event->se_assoc_id == SCTP_FUTURE_ASSOC) ||
|
|
|
|
(event->se_assoc_id == SCTP_ALL_ASSOC)))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
if (event->se_on) {
|
|
|
|
sctp_feature_on(inp, event_type);
|
|
|
|
} else {
|
|
|
|
sctp_feature_off(inp, event_type);
|
|
|
|
}
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
|
|
|
}
|
2019-11-28 12:50:25 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
((event->se_assoc_id == SCTP_CURRENT_ASSOC) ||
|
|
|
|
(event->se_assoc_id == SCTP_ALL_ASSOC))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
|
|
|
|
SCTP_TCB_LOCK(stcb);
|
|
|
|
if (event->se_on) {
|
|
|
|
sctp_stcb_feature_on(inp, stcb, event_type);
|
|
|
|
} else {
|
|
|
|
sctp_stcb_feature_off(inp, stcb, event_type);
|
|
|
|
}
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
}
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
}
|
|
|
|
}
|
2019-02-10 10:42:16 +00:00
|
|
|
} else {
|
|
|
|
if (stcb) {
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
}
|
2011-06-15 23:50:27 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case SCTP_RECVRCVINFO:
|
|
|
|
{
|
|
|
|
int *onoff;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(onoff, optval, int, optsize);
|
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
if (*onoff != 0) {
|
|
|
|
sctp_feature_on(inp, SCTP_PCB_FLAGS_RECVRCVINFO);
|
|
|
|
} else {
|
|
|
|
sctp_feature_off(inp, SCTP_PCB_FLAGS_RECVRCVINFO);
|
|
|
|
}
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case SCTP_RECVNXTINFO:
|
|
|
|
{
|
|
|
|
int *onoff;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(onoff, optval, int, optsize);
|
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
if (*onoff != 0) {
|
|
|
|
sctp_feature_on(inp, SCTP_PCB_FLAGS_RECVNXTINFO);
|
|
|
|
} else {
|
|
|
|
sctp_feature_off(inp, SCTP_PCB_FLAGS_RECVNXTINFO);
|
|
|
|
}
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case SCTP_DEFAULT_SNDINFO:
|
|
|
|
{
|
|
|
|
struct sctp_sndinfo *info;
|
2011-06-16 21:12:36 +00:00
|
|
|
uint16_t policy;
|
2011-06-15 23:50:27 +00:00
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(info, optval, struct sctp_sndinfo, optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, info->snd_assoc_id);
|
|
|
|
|
|
|
|
if (stcb) {
|
|
|
|
if (info->snd_sid < stcb->asoc.streamoutcnt) {
|
|
|
|
stcb->asoc.def_send.sinfo_stream = info->snd_sid;
|
2011-06-16 21:12:36 +00:00
|
|
|
policy = PR_SCTP_POLICY(stcb->asoc.def_send.sinfo_flags);
|
2011-06-15 23:50:27 +00:00
|
|
|
stcb->asoc.def_send.sinfo_flags = info->snd_flags;
|
2011-06-16 21:12:36 +00:00
|
|
|
stcb->asoc.def_send.sinfo_flags |= policy;
|
2011-06-15 23:50:27 +00:00
|
|
|
stcb->asoc.def_send.sinfo_ppid = info->snd_ppid;
|
|
|
|
stcb->asoc.def_send.sinfo_context = info->snd_context;
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
2011-08-16 21:04:18 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
((info->snd_assoc_id == SCTP_FUTURE_ASSOC) ||
|
|
|
|
(info->snd_assoc_id == SCTP_ALL_ASSOC)))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
inp->def_send.sinfo_stream = info->snd_sid;
|
2011-06-16 21:12:36 +00:00
|
|
|
policy = PR_SCTP_POLICY(inp->def_send.sinfo_flags);
|
2011-06-15 23:50:27 +00:00
|
|
|
inp->def_send.sinfo_flags = info->snd_flags;
|
2011-06-16 21:12:36 +00:00
|
|
|
inp->def_send.sinfo_flags |= policy;
|
2011-06-15 23:50:27 +00:00
|
|
|
inp->def_send.sinfo_ppid = info->snd_ppid;
|
|
|
|
inp->def_send.sinfo_context = info->snd_context;
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
|
|
|
}
|
2019-11-28 12:50:25 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
((info->snd_assoc_id == SCTP_CURRENT_ASSOC) ||
|
|
|
|
(info->snd_assoc_id == SCTP_ALL_ASSOC))) {
|
2011-06-15 23:50:27 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
|
|
|
|
SCTP_TCB_LOCK(stcb);
|
|
|
|
if (info->snd_sid < stcb->asoc.streamoutcnt) {
|
|
|
|
stcb->asoc.def_send.sinfo_stream = info->snd_sid;
|
2011-06-16 21:12:36 +00:00
|
|
|
policy = PR_SCTP_POLICY(stcb->asoc.def_send.sinfo_flags);
|
2011-06-15 23:50:27 +00:00
|
|
|
stcb->asoc.def_send.sinfo_flags = info->snd_flags;
|
2011-06-16 21:12:36 +00:00
|
|
|
stcb->asoc.def_send.sinfo_flags |= policy;
|
2011-06-15 23:50:27 +00:00
|
|
|
stcb->asoc.def_send.sinfo_ppid = info->snd_ppid;
|
|
|
|
stcb->asoc.def_send.sinfo_context = info->snd_context;
|
|
|
|
}
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
}
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2011-06-16 21:12:36 +00:00
|
|
|
case SCTP_DEFAULT_PRINFO:
|
|
|
|
{
|
|
|
|
struct sctp_default_prinfo *info;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(info, optval, struct sctp_default_prinfo, optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, info->pr_assoc_id);
|
|
|
|
|
2014-12-20 21:17:28 +00:00
|
|
|
if (info->pr_policy > SCTP_PR_SCTP_MAX) {
|
2019-02-10 08:28:56 +00:00
|
|
|
if (stcb) {
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
}
|
2011-06-16 21:12:36 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (stcb) {
|
|
|
|
stcb->asoc.def_send.sinfo_flags &= 0xfff0;
|
|
|
|
stcb->asoc.def_send.sinfo_flags |= info->pr_policy;
|
2011-08-16 21:04:18 +00:00
|
|
|
stcb->asoc.def_send.sinfo_timetolive = info->pr_value;
|
2011-06-16 21:12:36 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
2011-08-16 21:04:18 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
((info->pr_assoc_id == SCTP_FUTURE_ASSOC) ||
|
|
|
|
(info->pr_assoc_id == SCTP_ALL_ASSOC)))) {
|
2011-06-16 21:12:36 +00:00
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
inp->def_send.sinfo_flags &= 0xfff0;
|
|
|
|
inp->def_send.sinfo_flags |= info->pr_policy;
|
2011-08-16 21:04:18 +00:00
|
|
|
inp->def_send.sinfo_timetolive = info->pr_value;
|
2011-06-16 21:12:36 +00:00
|
|
|
SCTP_INP_WUNLOCK(inp);
|
|
|
|
}
|
2019-11-28 12:50:25 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
((info->pr_assoc_id == SCTP_CURRENT_ASSOC) ||
|
|
|
|
(info->pr_assoc_id == SCTP_ALL_ASSOC))) {
|
2011-06-16 21:12:36 +00:00
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) {
|
|
|
|
SCTP_TCB_LOCK(stcb);
|
|
|
|
stcb->asoc.def_send.sinfo_flags &= 0xfff0;
|
|
|
|
stcb->asoc.def_send.sinfo_flags |= info->pr_policy;
|
2011-08-16 21:04:18 +00:00
|
|
|
stcb->asoc.def_send.sinfo_timetolive = info->pr_value;
|
2011-06-16 21:12:36 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
}
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2011-08-03 20:21:00 +00:00
|
|
|
case SCTP_PEER_ADDR_THLDS:
|
|
|
|
/* Applies to the specific association */
|
|
|
|
{
|
|
|
|
struct sctp_paddrthlds *thlds;
|
|
|
|
struct sctp_nets *net;
|
2014-12-06 20:00:08 +00:00
|
|
|
struct sockaddr *addr;
|
|
|
|
#if defined(INET) && defined(INET6)
|
|
|
|
struct sockaddr_in sin_store;
|
|
|
|
#endif
|
2011-08-03 20:21:00 +00:00
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(thlds, optval, struct sctp_paddrthlds, optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, thlds->spt_assoc_id);
|
2014-12-06 20:00:08 +00:00
|
|
|
|
|
|
|
#if defined(INET) && defined(INET6)
|
|
|
|
if (thlds->spt_address.ss_family == AF_INET6) {
|
|
|
|
struct sockaddr_in6 *sin6;
|
|
|
|
|
|
|
|
sin6 = (struct sockaddr_in6 *)&thlds->spt_address;
|
|
|
|
if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
|
|
|
|
in6_sin6_2_sin(&sin_store, sin6);
|
|
|
|
addr = (struct sockaddr *)&sin_store;
|
|
|
|
} else {
|
|
|
|
addr = (struct sockaddr *)&thlds->spt_address;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
addr = (struct sockaddr *)&thlds->spt_address;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
addr = (struct sockaddr *)&thlds->spt_address;
|
|
|
|
#endif
|
|
|
|
if (stcb != NULL) {
|
|
|
|
net = sctp_findnet(stcb, addr);
|
2011-08-03 20:21:00 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* We increment here since
|
|
|
|
* sctp_findassociation_ep_addr() wil do a
|
|
|
|
* decrement if it finds the stcb as long as
|
|
|
|
* the locked tcb (last argument) is NOT a
|
|
|
|
* TCB.. aka NULL.
|
|
|
|
*/
|
2014-12-06 20:00:08 +00:00
|
|
|
net = NULL;
|
2011-08-03 20:21:00 +00:00
|
|
|
SCTP_INP_INCR_REF(inp);
|
2014-12-06 20:00:08 +00:00
|
|
|
stcb = sctp_findassociation_ep_addr(&inp, addr,
|
2011-08-03 20:21:00 +00:00
|
|
|
&net, NULL, NULL);
|
|
|
|
if (stcb == NULL) {
|
|
|
|
SCTP_INP_DECR_REF(inp);
|
|
|
|
}
|
|
|
|
}
|
2014-12-06 20:00:08 +00:00
|
|
|
if ((stcb != NULL) && (net == NULL)) {
|
2011-08-03 20:21:00 +00:00
|
|
|
#ifdef INET
|
2014-12-06 20:00:08 +00:00
|
|
|
if (addr->sa_family == AF_INET) {
|
2011-08-03 20:21:00 +00:00
|
|
|
struct sockaddr_in *sin;
|
|
|
|
|
2014-12-06 20:00:08 +00:00
|
|
|
sin = (struct sockaddr_in *)addr;
|
|
|
|
if (sin->sin_addr.s_addr != INADDR_ANY) {
|
2011-08-03 20:21:00 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
#ifdef INET6
|
2014-12-06 20:00:08 +00:00
|
|
|
if (addr->sa_family == AF_INET6) {
|
2011-08-03 20:21:00 +00:00
|
|
|
struct sockaddr_in6 *sin6;
|
|
|
|
|
2014-12-06 20:00:08 +00:00
|
|
|
sin6 = (struct sockaddr_in6 *)addr;
|
2011-08-03 20:21:00 +00:00
|
|
|
if (!IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
{
|
|
|
|
error = EAFNOSUPPORT;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2016-05-26 11:38:26 +00:00
|
|
|
if (thlds->spt_pathcpthld != 0xffff) {
|
2019-02-10 13:55:32 +00:00
|
|
|
if (stcb != NULL) {
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
}
|
2016-05-26 11:38:26 +00:00
|
|
|
error = EINVAL;
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
|
|
|
|
break;
|
|
|
|
}
|
2014-12-06 20:00:08 +00:00
|
|
|
if (stcb != NULL) {
|
|
|
|
if (net != NULL) {
|
2015-03-11 14:25:23 +00:00
|
|
|
net->failure_threshold = thlds->spt_pathmaxrxt;
|
|
|
|
net->pf_threshold = thlds->spt_pathpfthld;
|
2011-08-03 20:21:00 +00:00
|
|
|
if (net->dest_state & SCTP_ADDR_PF) {
|
2015-03-11 14:25:23 +00:00
|
|
|
if ((net->error_count > net->failure_threshold) ||
|
|
|
|
(net->error_count <= net->pf_threshold)) {
|
2011-08-03 20:21:00 +00:00
|
|
|
net->dest_state &= ~SCTP_ADDR_PF;
|
|
|
|
}
|
|
|
|
} else {
|
2015-03-11 14:25:23 +00:00
|
|
|
if ((net->error_count > net->pf_threshold) &&
|
|
|
|
(net->error_count <= net->failure_threshold)) {
|
2011-08-03 20:21:00 +00:00
|
|
|
net->dest_state |= SCTP_ADDR_PF;
|
|
|
|
sctp_send_hb(stcb, net, SCTP_SO_LOCKED);
|
2015-05-28 16:00:23 +00:00
|
|
|
sctp_timer_stop(SCTP_TIMER_TYPE_HEARTBEAT,
|
|
|
|
stcb->sctp_ep, stcb, net,
|
|
|
|
SCTP_FROM_SCTP_USRREQ + SCTP_LOC_17);
|
2011-08-03 20:21:00 +00:00
|
|
|
sctp_timer_start(SCTP_TIMER_TYPE_HEARTBEAT, stcb->sctp_ep, stcb, net);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (net->dest_state & SCTP_ADDR_REACHABLE) {
|
2015-03-11 14:25:23 +00:00
|
|
|
if (net->error_count > net->failure_threshold) {
|
2011-08-03 20:21:00 +00:00
|
|
|
net->dest_state &= ~SCTP_ADDR_REACHABLE;
|
2012-05-13 17:36:04 +00:00
|
|
|
sctp_ulp_notify(SCTP_NOTIFY_INTERFACE_DOWN, stcb, 0, net, SCTP_SO_LOCKED);
|
2011-08-03 20:21:00 +00:00
|
|
|
}
|
|
|
|
} else {
|
2015-03-11 14:25:23 +00:00
|
|
|
if (net->error_count <= net->failure_threshold) {
|
2011-08-03 20:21:00 +00:00
|
|
|
net->dest_state |= SCTP_ADDR_REACHABLE;
|
2012-05-13 17:36:04 +00:00
|
|
|
sctp_ulp_notify(SCTP_NOTIFY_INTERFACE_UP, stcb, 0, net, SCTP_SO_LOCKED);
|
2011-08-03 20:21:00 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
|
2015-03-11 14:25:23 +00:00
|
|
|
net->failure_threshold = thlds->spt_pathmaxrxt;
|
|
|
|
net->pf_threshold = thlds->spt_pathpfthld;
|
2011-08-03 20:21:00 +00:00
|
|
|
if (net->dest_state & SCTP_ADDR_PF) {
|
2015-03-11 14:25:23 +00:00
|
|
|
if ((net->error_count > net->failure_threshold) ||
|
|
|
|
(net->error_count <= net->pf_threshold)) {
|
2011-08-03 20:21:00 +00:00
|
|
|
net->dest_state &= ~SCTP_ADDR_PF;
|
|
|
|
}
|
|
|
|
} else {
|
2015-03-11 14:25:23 +00:00
|
|
|
if ((net->error_count > net->pf_threshold) &&
|
|
|
|
(net->error_count <= net->failure_threshold)) {
|
2011-08-03 20:21:00 +00:00
|
|
|
net->dest_state |= SCTP_ADDR_PF;
|
|
|
|
sctp_send_hb(stcb, net, SCTP_SO_LOCKED);
|
2015-05-28 16:00:23 +00:00
|
|
|
sctp_timer_stop(SCTP_TIMER_TYPE_HEARTBEAT,
|
|
|
|
stcb->sctp_ep, stcb, net,
|
|
|
|
SCTP_FROM_SCTP_USRREQ + SCTP_LOC_18);
|
2011-08-03 20:21:00 +00:00
|
|
|
sctp_timer_start(SCTP_TIMER_TYPE_HEARTBEAT, stcb->sctp_ep, stcb, net);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (net->dest_state & SCTP_ADDR_REACHABLE) {
|
2015-03-11 14:25:23 +00:00
|
|
|
if (net->error_count > net->failure_threshold) {
|
2011-08-03 20:21:00 +00:00
|
|
|
net->dest_state &= ~SCTP_ADDR_REACHABLE;
|
2012-05-13 17:36:04 +00:00
|
|
|
sctp_ulp_notify(SCTP_NOTIFY_INTERFACE_DOWN, stcb, 0, net, SCTP_SO_LOCKED);
|
2011-08-03 20:21:00 +00:00
|
|
|
}
|
|
|
|
} else {
|
2015-03-11 14:25:23 +00:00
|
|
|
if (net->error_count <= net->failure_threshold) {
|
2011-08-03 20:21:00 +00:00
|
|
|
net->dest_state |= SCTP_ADDR_REACHABLE;
|
2012-05-13 17:36:04 +00:00
|
|
|
sctp_ulp_notify(SCTP_NOTIFY_INTERFACE_UP, stcb, 0, net, SCTP_SO_LOCKED);
|
2011-08-03 20:21:00 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
stcb->asoc.def_net_failure = thlds->spt_pathmaxrxt;
|
|
|
|
stcb->asoc.def_net_pf_threshold = thlds->spt_pathpfthld;
|
|
|
|
}
|
2015-03-10 21:05:17 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
2011-08-03 20:21:00 +00:00
|
|
|
} else {
|
2011-08-16 21:04:18 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(thlds->spt_assoc_id == SCTP_FUTURE_ASSOC))) {
|
2011-08-03 20:21:00 +00:00
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
inp->sctp_ep.def_net_failure = thlds->spt_pathmaxrxt;
|
|
|
|
inp->sctp_ep.def_net_pf_threshold = thlds->spt_pathpfthld;
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2011-11-20 15:00:45 +00:00
|
|
|
case SCTP_REMOTE_UDP_ENCAPS_PORT:
|
|
|
|
{
|
|
|
|
struct sctp_udpencaps *encaps;
|
|
|
|
struct sctp_nets *net;
|
2014-12-06 20:00:08 +00:00
|
|
|
struct sockaddr *addr;
|
|
|
|
#if defined(INET) && defined(INET6)
|
|
|
|
struct sockaddr_in sin_store;
|
|
|
|
#endif
|
2011-11-20 15:00:45 +00:00
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(encaps, optval, struct sctp_udpencaps, optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, encaps->sue_assoc_id);
|
2014-12-06 20:00:08 +00:00
|
|
|
|
|
|
|
#if defined(INET) && defined(INET6)
|
|
|
|
if (encaps->sue_address.ss_family == AF_INET6) {
|
|
|
|
struct sockaddr_in6 *sin6;
|
|
|
|
|
|
|
|
sin6 = (struct sockaddr_in6 *)&encaps->sue_address;
|
|
|
|
if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
|
|
|
|
in6_sin6_2_sin(&sin_store, sin6);
|
|
|
|
addr = (struct sockaddr *)&sin_store;
|
|
|
|
} else {
|
|
|
|
addr = (struct sockaddr *)&encaps->sue_address;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
addr = (struct sockaddr *)&encaps->sue_address;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
addr = (struct sockaddr *)&encaps->sue_address;
|
|
|
|
#endif
|
|
|
|
if (stcb != NULL) {
|
|
|
|
net = sctp_findnet(stcb, addr);
|
2011-11-20 15:00:45 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* We increment here since
|
|
|
|
* sctp_findassociation_ep_addr() wil do a
|
|
|
|
* decrement if it finds the stcb as long as
|
|
|
|
* the locked tcb (last argument) is NOT a
|
|
|
|
* TCB.. aka NULL.
|
|
|
|
*/
|
|
|
|
net = NULL;
|
|
|
|
SCTP_INP_INCR_REF(inp);
|
2014-12-06 20:00:08 +00:00
|
|
|
stcb = sctp_findassociation_ep_addr(&inp, addr, &net, NULL, NULL);
|
2011-11-20 15:00:45 +00:00
|
|
|
if (stcb == NULL) {
|
|
|
|
SCTP_INP_DECR_REF(inp);
|
|
|
|
}
|
|
|
|
}
|
2014-12-06 20:00:08 +00:00
|
|
|
if ((stcb != NULL) && (net == NULL)) {
|
2011-11-20 15:00:45 +00:00
|
|
|
#ifdef INET
|
2014-12-06 20:00:08 +00:00
|
|
|
if (addr->sa_family == AF_INET) {
|
2011-11-20 15:00:45 +00:00
|
|
|
struct sockaddr_in *sin;
|
|
|
|
|
2014-12-06 20:00:08 +00:00
|
|
|
sin = (struct sockaddr_in *)addr;
|
|
|
|
if (sin->sin_addr.s_addr != INADDR_ANY) {
|
2011-11-20 15:00:45 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
#ifdef INET6
|
2014-12-06 20:00:08 +00:00
|
|
|
if (addr->sa_family == AF_INET6) {
|
2011-11-20 15:00:45 +00:00
|
|
|
struct sockaddr_in6 *sin6;
|
|
|
|
|
2014-12-06 20:00:08 +00:00
|
|
|
sin6 = (struct sockaddr_in6 *)addr;
|
2011-11-20 15:00:45 +00:00
|
|
|
if (!IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
{
|
|
|
|
error = EAFNOSUPPORT;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2018-07-19 20:16:33 +00:00
|
|
|
|
2014-12-06 20:00:08 +00:00
|
|
|
if (stcb != NULL) {
|
|
|
|
if (net != NULL) {
|
2011-11-20 15:00:45 +00:00
|
|
|
net->port = encaps->sue_port;
|
|
|
|
} else {
|
|
|
|
stcb->asoc.port = encaps->sue_port;
|
|
|
|
}
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(encaps->sue_assoc_id == SCTP_FUTURE_ASSOC))) {
|
2011-11-20 15:00:45 +00:00
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
inp->sctp_ep.port = encaps->sue_port;
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2014-08-02 17:35:13 +00:00
|
|
|
case SCTP_ECN_SUPPORTED:
|
|
|
|
{
|
|
|
|
struct sctp_assoc_value *av;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, av->assoc_id);
|
|
|
|
|
|
|
|
if (stcb) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(av->assoc_id == SCTP_FUTURE_ASSOC))) {
|
2014-08-02 17:35:13 +00:00
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
if (av->assoc_value == 0) {
|
|
|
|
inp->ecn_supported = 0;
|
|
|
|
} else {
|
2014-08-02 20:37:02 +00:00
|
|
|
inp->ecn_supported = 1;
|
2014-08-02 17:35:13 +00:00
|
|
|
}
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2014-08-02 21:36:40 +00:00
|
|
|
case SCTP_PR_SUPPORTED:
|
|
|
|
{
|
|
|
|
struct sctp_assoc_value *av;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, av->assoc_id);
|
|
|
|
|
|
|
|
if (stcb) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(av->assoc_id == SCTP_FUTURE_ASSOC))) {
|
2014-08-02 21:36:40 +00:00
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
if (av->assoc_value == 0) {
|
|
|
|
inp->prsctp_supported = 0;
|
|
|
|
} else {
|
|
|
|
inp->prsctp_supported = 1;
|
|
|
|
}
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2014-08-12 11:30:16 +00:00
|
|
|
case SCTP_AUTH_SUPPORTED:
|
|
|
|
{
|
|
|
|
struct sctp_assoc_value *av;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, av->assoc_id);
|
|
|
|
|
|
|
|
if (stcb) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(av->assoc_id == SCTP_FUTURE_ASSOC))) {
|
2014-08-12 11:30:16 +00:00
|
|
|
if ((av->assoc_value == 0) &&
|
|
|
|
(inp->asconf_supported == 1)) {
|
2016-12-26 11:06:41 +00:00
|
|
|
/*
|
|
|
|
* AUTH is required for
|
|
|
|
* ASCONF
|
|
|
|
*/
|
2014-08-12 11:30:16 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
} else {
|
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
if (av->assoc_value == 0) {
|
|
|
|
inp->auth_supported = 0;
|
|
|
|
} else {
|
|
|
|
inp->auth_supported = 1;
|
|
|
|
}
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case SCTP_ASCONF_SUPPORTED:
|
|
|
|
{
|
|
|
|
struct sctp_assoc_value *av;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, av->assoc_id);
|
|
|
|
|
|
|
|
if (stcb) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(av->assoc_id == SCTP_FUTURE_ASSOC))) {
|
2014-08-12 11:30:16 +00:00
|
|
|
if ((av->assoc_value != 0) &&
|
|
|
|
(inp->auth_supported == 0)) {
|
2016-12-26 11:06:41 +00:00
|
|
|
/*
|
|
|
|
* AUTH is required for
|
|
|
|
* ASCONF
|
|
|
|
*/
|
2014-08-12 11:30:16 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
} else {
|
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
if (av->assoc_value == 0) {
|
|
|
|
inp->asconf_supported = 0;
|
|
|
|
sctp_auth_delete_chunk(SCTP_ASCONF,
|
|
|
|
inp->sctp_ep.local_auth_chunks);
|
|
|
|
sctp_auth_delete_chunk(SCTP_ASCONF_ACK,
|
|
|
|
inp->sctp_ep.local_auth_chunks);
|
|
|
|
} else {
|
|
|
|
inp->asconf_supported = 1;
|
|
|
|
sctp_auth_add_chunk(SCTP_ASCONF,
|
|
|
|
inp->sctp_ep.local_auth_chunks);
|
|
|
|
sctp_auth_add_chunk(SCTP_ASCONF_ACK,
|
|
|
|
inp->sctp_ep.local_auth_chunks);
|
|
|
|
}
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2014-08-04 20:07:35 +00:00
|
|
|
case SCTP_RECONFIG_SUPPORTED:
|
|
|
|
{
|
|
|
|
struct sctp_assoc_value *av;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, av->assoc_id);
|
|
|
|
|
|
|
|
if (stcb) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(av->assoc_id == SCTP_FUTURE_ASSOC))) {
|
2014-08-04 20:07:35 +00:00
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
if (av->assoc_value == 0) {
|
|
|
|
inp->reconfig_supported = 0;
|
|
|
|
} else {
|
|
|
|
inp->reconfig_supported = 1;
|
|
|
|
}
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2014-08-03 14:10:10 +00:00
|
|
|
case SCTP_NRSACK_SUPPORTED:
|
|
|
|
{
|
|
|
|
struct sctp_assoc_value *av;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, av->assoc_id);
|
|
|
|
|
|
|
|
if (stcb) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(av->assoc_id == SCTP_FUTURE_ASSOC))) {
|
2014-08-03 14:10:10 +00:00
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
if (av->assoc_value == 0) {
|
|
|
|
inp->nrsack_supported = 0;
|
|
|
|
} else {
|
|
|
|
inp->nrsack_supported = 1;
|
|
|
|
}
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2014-08-03 18:12:55 +00:00
|
|
|
case SCTP_PKTDROP_SUPPORTED:
|
|
|
|
{
|
|
|
|
struct sctp_assoc_value *av;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, av->assoc_id);
|
|
|
|
|
|
|
|
if (stcb) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(av->assoc_id == SCTP_FUTURE_ASSOC))) {
|
2014-08-03 18:12:55 +00:00
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
if (av->assoc_value == 0) {
|
|
|
|
inp->pktdrop_supported = 0;
|
|
|
|
} else {
|
|
|
|
inp->pktdrop_supported = 1;
|
|
|
|
}
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2015-03-10 19:49:25 +00:00
|
|
|
case SCTP_MAX_CWND:
|
|
|
|
{
|
|
|
|
struct sctp_assoc_value *av;
|
|
|
|
struct sctp_nets *net;
|
|
|
|
|
|
|
|
SCTP_CHECK_AND_CAST(av, optval, struct sctp_assoc_value, optsize);
|
|
|
|
SCTP_FIND_STCB(inp, stcb, av->assoc_id);
|
|
|
|
|
|
|
|
if (stcb) {
|
|
|
|
stcb->asoc.max_cwnd = av->assoc_value;
|
|
|
|
if (stcb->asoc.max_cwnd > 0) {
|
|
|
|
TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
|
|
|
|
if ((net->cwnd > stcb->asoc.max_cwnd) &&
|
|
|
|
(net->cwnd > (net->mtu - sizeof(struct sctphdr)))) {
|
|
|
|
net->cwnd = stcb->asoc.max_cwnd;
|
|
|
|
if (net->cwnd < (net->mtu - sizeof(struct sctphdr))) {
|
|
|
|
net->cwnd = net->mtu - sizeof(struct sctphdr);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||
|
2019-11-28 12:50:25 +00:00
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) &&
|
|
|
|
(av->assoc_id == SCTP_FUTURE_ASSOC))) {
|
2015-03-10 19:49:25 +00:00
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
inp->max_cwnd = av->assoc_value;
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
|
|
|
} else {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
default:
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOPROTOOPT);
|
2006-11-03 15:23:16 +00:00
|
|
|
error = ENOPROTOOPT;
|
|
|
|
break;
|
|
|
|
} /* end switch (opt) */
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
sctp_ctloutput(struct socket *so, struct sockopt *sopt)
|
|
|
|
{
|
2020-02-18 21:25:17 +00:00
|
|
|
struct epoch_tracker et;
|
|
|
|
struct sctp_inpcb *inp;
|
2007-02-12 23:24:31 +00:00
|
|
|
void *optval = NULL;
|
|
|
|
void *p;
|
2020-02-18 21:25:17 +00:00
|
|
|
size_t optsize = 0;
|
2007-02-12 23:24:31 +00:00
|
|
|
int error = 0;
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2015-06-17 15:20:14 +00:00
|
|
|
if ((sopt->sopt_level == SOL_SOCKET) &&
|
|
|
|
(sopt->sopt_name == SO_SETFIB)) {
|
|
|
|
inp = (struct sctp_inpcb *)so->so_pcb;
|
|
|
|
if (inp == NULL) {
|
|
|
|
SCTP_LTRACE_ERR_RET(so->so_pcb, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOBUFS);
|
|
|
|
return (EINVAL);
|
|
|
|
}
|
|
|
|
SCTP_INP_WLOCK(inp);
|
|
|
|
inp->fibnum = so->so_fibnum;
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
|
|
|
return (0);
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
if (sopt->sopt_level != IPPROTO_SCTP) {
|
|
|
|
/* wrong proto level... send back up to IP */
|
|
|
|
#ifdef INET6
|
|
|
|
if (INP_CHECK_SOCKAF(so, AF_INET6))
|
|
|
|
error = ip6_ctloutput(so, sopt);
|
|
|
|
#endif /* INET6 */
|
2012-06-25 17:15:09 +00:00
|
|
|
#if defined(INET) && defined(INET6)
|
2011-04-30 11:18:16 +00:00
|
|
|
else
|
|
|
|
#endif
|
|
|
|
#ifdef INET
|
2006-11-03 15:23:16 +00:00
|
|
|
error = ip_ctloutput(so, sopt);
|
2011-04-30 11:18:16 +00:00
|
|
|
#endif
|
2006-11-03 15:23:16 +00:00
|
|
|
return (error);
|
|
|
|
}
|
2007-02-12 23:24:31 +00:00
|
|
|
optsize = sopt->sopt_valsize;
|
2019-01-16 11:33:47 +00:00
|
|
|
if (optsize > SCTP_SOCKET_OPTION_LIMIT) {
|
|
|
|
SCTP_LTRACE_ERR_RET(so->so_pcb, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOBUFS);
|
|
|
|
return (ENOBUFS);
|
|
|
|
}
|
2007-02-12 23:24:31 +00:00
|
|
|
if (optsize) {
|
2007-05-29 09:29:03 +00:00
|
|
|
SCTP_MALLOC(optval, void *, optsize, SCTP_M_SOCKOPT);
|
2007-02-12 23:24:31 +00:00
|
|
|
if (optval == NULL) {
|
2012-05-06 14:50:54 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(so->so_pcb, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOBUFS);
|
2006-11-03 15:23:16 +00:00
|
|
|
return (ENOBUFS);
|
|
|
|
}
|
2007-02-12 23:24:31 +00:00
|
|
|
error = sooptcopyin(sopt, optval, optsize, optsize);
|
2006-11-03 15:23:16 +00:00
|
|
|
if (error) {
|
2007-05-29 09:29:03 +00:00
|
|
|
SCTP_FREE(optval, SCTP_M_SOCKOPT);
|
2006-11-03 15:23:16 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
2007-02-12 23:24:31 +00:00
|
|
|
p = (void *)sopt->sopt_td;
|
2006-11-03 15:23:16 +00:00
|
|
|
if (sopt->sopt_dir == SOPT_SET) {
|
2020-02-18 21:25:17 +00:00
|
|
|
NET_EPOCH_ENTER(et);
|
2007-02-12 23:24:31 +00:00
|
|
|
error = sctp_setopt(so, sopt->sopt_name, optval, optsize, p);
|
2020-02-18 21:25:17 +00:00
|
|
|
NET_EPOCH_EXIT(et);
|
2006-11-03 15:23:16 +00:00
|
|
|
} else if (sopt->sopt_dir == SOPT_GET) {
|
2007-02-12 23:24:31 +00:00
|
|
|
error = sctp_getopt(so, sopt->sopt_name, optval, &optsize, p);
|
2006-11-03 15:23:16 +00:00
|
|
|
} else {
|
2012-05-06 14:50:54 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(so->so_pcb, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2006-11-03 15:23:16 +00:00
|
|
|
error = EINVAL;
|
|
|
|
}
|
2007-02-12 23:24:31 +00:00
|
|
|
if ((error == 0) && (optval != NULL)) {
|
|
|
|
error = sooptcopyout(sopt, optval, optsize);
|
2007-05-29 09:29:03 +00:00
|
|
|
SCTP_FREE(optval, SCTP_M_SOCKOPT);
|
2007-02-12 23:24:31 +00:00
|
|
|
} else if (optval != NULL) {
|
2007-05-29 09:29:03 +00:00
|
|
|
SCTP_FREE(optval, SCTP_M_SOCKOPT);
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
out:
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2011-04-30 11:18:16 +00:00
|
|
|
#ifdef INET
|
2006-11-03 15:23:16 +00:00
|
|
|
static int
|
|
|
|
sctp_connect(struct socket *so, struct sockaddr *addr, struct thread *p)
|
|
|
|
{
|
2020-02-18 21:25:17 +00:00
|
|
|
struct epoch_tracker et;
|
2006-11-03 15:23:16 +00:00
|
|
|
int error = 0;
|
|
|
|
int create_lock_on = 0;
|
2007-03-15 11:27:14 +00:00
|
|
|
uint32_t vrf_id;
|
2006-11-03 15:23:16 +00:00
|
|
|
struct sctp_inpcb *inp;
|
|
|
|
struct sctp_tcb *stcb = NULL;
|
|
|
|
|
|
|
|
inp = (struct sctp_inpcb *)so->so_pcb;
|
2012-03-15 14:22:05 +00:00
|
|
|
if (inp == NULL) {
|
2006-11-03 15:23:16 +00:00
|
|
|
/* I made the same as TCP since we are not setup? */
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2006-11-03 15:23:16 +00:00
|
|
|
return (ECONNRESET);
|
|
|
|
}
|
2007-08-24 00:53:53 +00:00
|
|
|
if (addr == NULL) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2007-05-28 11:17:24 +00:00
|
|
|
return EINVAL;
|
2007-08-24 00:53:53 +00:00
|
|
|
}
|
2018-07-19 20:16:33 +00:00
|
|
|
|
2011-04-30 11:18:16 +00:00
|
|
|
switch (addr->sa_family) {
|
MFp4:
Bring in updated jail support from bz_jail branch.
This enhances the current jail implementation to permit multiple
addresses per jail. In addtion to IPv4, IPv6 is supported as well.
Due to updated checks it is even possible to have jails without
an IP address at all, which basically gives one a chroot with
restricted process view, no networking,..
SCTP support was updated and supports IPv6 in jails as well.
Cpuset support permits jails to be bound to specific processor
sets after creation.
Jails can have an unrestricted (no duplicate protection, etc.) name
in addition to the hostname. The jail name cannot be changed from
within a jail and is considered to be used for management purposes
or as audit-token in the future.
DDB 'show jails' command was added to aid debugging.
Proper compat support permits 32bit jail binaries to be used on 64bit
systems to manage jails. Also backward compatibility was preserved where
possible: for jail v1 syscalls, as well as with user space management
utilities.
Both jail as well as prison version were updated for the new features.
A gap was intentionally left as the intermediate versions had been
used by various patches floating around the last years.
Bump __FreeBSD_version for the afore mentioned and in kernel changes.
Special thanks to:
- Pawel Jakub Dawidek (pjd) for his multi-IPv4 patches
and Olivier Houchard (cognet) for initial single-IPv6 patches.
- Jeff Roberson (jeff) and Randall Stewart (rrs) for their
help, ideas and review on cpuset and SCTP support.
- Robert Watson (rwatson) for lots and lots of help, discussions,
suggestions and review of most of the patch at various stages.
- John Baldwin (jhb) for his help.
- Simon L. Nielsen (simon) as early adopter testing changes
on cluster machines as well as all the testers and people
who provided feedback the last months on freebsd-jail and
other channels.
- My employer, CK Software GmbH, for the support so I could work on this.
Reviewed by: (see above)
MFC after: 3 months (this is just so that I get the mail)
X-MFC Before: 7.2-RELEASE if possible
2008-11-29 14:32:14 +00:00
|
|
|
#ifdef INET6
|
2011-04-30 11:18:16 +00:00
|
|
|
case AF_INET6:
|
|
|
|
{
|
2019-08-02 07:41:36 +00:00
|
|
|
struct sockaddr_in6 *sin6;
|
2008-12-06 13:19:54 +00:00
|
|
|
|
2011-04-30 11:18:16 +00:00
|
|
|
if (addr->sa_len != sizeof(struct sockaddr_in6)) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
return (EINVAL);
|
|
|
|
}
|
2019-08-02 07:41:36 +00:00
|
|
|
sin6 = (struct sockaddr_in6 *)addr;
|
|
|
|
if (p != NULL && (error = prison_remote_ip6(p->td_ucred, &sin6->sin6_addr)) != 0) {
|
2011-04-30 11:18:16 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
break;
|
MFp4:
Bring in updated jail support from bz_jail branch.
This enhances the current jail implementation to permit multiple
addresses per jail. In addtion to IPv4, IPv6 is supported as well.
Due to updated checks it is even possible to have jails without
an IP address at all, which basically gives one a chroot with
restricted process view, no networking,..
SCTP support was updated and supports IPv6 in jails as well.
Cpuset support permits jails to be bound to specific processor
sets after creation.
Jails can have an unrestricted (no duplicate protection, etc.) name
in addition to the hostname. The jail name cannot be changed from
within a jail and is considered to be used for management purposes
or as audit-token in the future.
DDB 'show jails' command was added to aid debugging.
Proper compat support permits 32bit jail binaries to be used on 64bit
systems to manage jails. Also backward compatibility was preserved where
possible: for jail v1 syscalls, as well as with user space management
utilities.
Both jail as well as prison version were updated for the new features.
A gap was intentionally left as the intermediate versions had been
used by various patches floating around the last years.
Bump __FreeBSD_version for the afore mentioned and in kernel changes.
Special thanks to:
- Pawel Jakub Dawidek (pjd) for his multi-IPv4 patches
and Olivier Houchard (cognet) for initial single-IPv6 patches.
- Jeff Roberson (jeff) and Randall Stewart (rrs) for their
help, ideas and review on cpuset and SCTP support.
- Robert Watson (rwatson) for lots and lots of help, discussions,
suggestions and review of most of the patch at various stages.
- John Baldwin (jhb) for his help.
- Simon L. Nielsen (simon) as early adopter testing changes
on cluster machines as well as all the testers and people
who provided feedback the last months on freebsd-jail and
other channels.
- My employer, CK Software GmbH, for the support so I could work on this.
Reviewed by: (see above)
MFC after: 3 months (this is just so that I get the mail)
X-MFC Before: 7.2-RELEASE if possible
2008-11-29 14:32:14 +00:00
|
|
|
}
|
|
|
|
#endif
|
2011-04-30 11:18:16 +00:00
|
|
|
#ifdef INET
|
|
|
|
case AF_INET:
|
|
|
|
{
|
2019-08-05 13:22:15 +00:00
|
|
|
struct sockaddr_in *sin;
|
2008-12-06 13:19:54 +00:00
|
|
|
|
2011-04-30 11:18:16 +00:00
|
|
|
if (addr->sa_len != sizeof(struct sockaddr_in)) {
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
|
|
|
return (EINVAL);
|
|
|
|
}
|
2019-08-05 13:22:15 +00:00
|
|
|
sin = (struct sockaddr_in *)addr;
|
|
|
|
if (p != NULL && (error = prison_remote_ip4(p->td_ucred, &sin->sin_addr)) != 0) {
|
2011-04-30 11:18:16 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
break;
|
MFp4:
Bring in updated jail support from bz_jail branch.
This enhances the current jail implementation to permit multiple
addresses per jail. In addtion to IPv4, IPv6 is supported as well.
Due to updated checks it is even possible to have jails without
an IP address at all, which basically gives one a chroot with
restricted process view, no networking,..
SCTP support was updated and supports IPv6 in jails as well.
Cpuset support permits jails to be bound to specific processor
sets after creation.
Jails can have an unrestricted (no duplicate protection, etc.) name
in addition to the hostname. The jail name cannot be changed from
within a jail and is considered to be used for management purposes
or as audit-token in the future.
DDB 'show jails' command was added to aid debugging.
Proper compat support permits 32bit jail binaries to be used on 64bit
systems to manage jails. Also backward compatibility was preserved where
possible: for jail v1 syscalls, as well as with user space management
utilities.
Both jail as well as prison version were updated for the new features.
A gap was intentionally left as the intermediate versions had been
used by various patches floating around the last years.
Bump __FreeBSD_version for the afore mentioned and in kernel changes.
Special thanks to:
- Pawel Jakub Dawidek (pjd) for his multi-IPv4 patches
and Olivier Houchard (cognet) for initial single-IPv6 patches.
- Jeff Roberson (jeff) and Randall Stewart (rrs) for their
help, ideas and review on cpuset and SCTP support.
- Robert Watson (rwatson) for lots and lots of help, discussions,
suggestions and review of most of the patch at various stages.
- John Baldwin (jhb) for his help.
- Simon L. Nielsen (simon) as early adopter testing changes
on cluster machines as well as all the testers and people
who provided feedback the last months on freebsd-jail and
other channels.
- My employer, CK Software GmbH, for the support so I could work on this.
Reviewed by: (see above)
MFC after: 3 months (this is just so that I get the mail)
X-MFC Before: 7.2-RELEASE if possible
2008-11-29 14:32:14 +00:00
|
|
|
}
|
2011-04-30 11:18:16 +00:00
|
|
|
#endif
|
|
|
|
default:
|
MFp4:
Bring in updated jail support from bz_jail branch.
This enhances the current jail implementation to permit multiple
addresses per jail. In addtion to IPv4, IPv6 is supported as well.
Due to updated checks it is even possible to have jails without
an IP address at all, which basically gives one a chroot with
restricted process view, no networking,..
SCTP support was updated and supports IPv6 in jails as well.
Cpuset support permits jails to be bound to specific processor
sets after creation.
Jails can have an unrestricted (no duplicate protection, etc.) name
in addition to the hostname. The jail name cannot be changed from
within a jail and is considered to be used for management purposes
or as audit-token in the future.
DDB 'show jails' command was added to aid debugging.
Proper compat support permits 32bit jail binaries to be used on 64bit
systems to manage jails. Also backward compatibility was preserved where
possible: for jail v1 syscalls, as well as with user space management
utilities.
Both jail as well as prison version were updated for the new features.
A gap was intentionally left as the intermediate versions had been
used by various patches floating around the last years.
Bump __FreeBSD_version for the afore mentioned and in kernel changes.
Special thanks to:
- Pawel Jakub Dawidek (pjd) for his multi-IPv4 patches
and Olivier Houchard (cognet) for initial single-IPv6 patches.
- Jeff Roberson (jeff) and Randall Stewart (rrs) for their
help, ideas and review on cpuset and SCTP support.
- Robert Watson (rwatson) for lots and lots of help, discussions,
suggestions and review of most of the patch at various stages.
- John Baldwin (jhb) for his help.
- Simon L. Nielsen (simon) as early adopter testing changes
on cluster machines as well as all the testers and people
who provided feedback the last months on freebsd-jail and
other channels.
- My employer, CK Software GmbH, for the support so I could work on this.
Reviewed by: (see above)
MFC after: 3 months (this is just so that I get the mail)
X-MFC Before: 7.2-RELEASE if possible
2008-11-29 14:32:14 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EAFNOSUPPORT);
|
|
|
|
return (EAFNOSUPPORT);
|
2007-05-28 11:17:24 +00:00
|
|
|
}
|
2008-04-14 18:13:33 +00:00
|
|
|
SCTP_INP_INCR_REF(inp);
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_ASOC_CREATE_LOCK(inp);
|
|
|
|
create_lock_on = 1;
|
2020-02-18 21:25:17 +00:00
|
|
|
NET_EPOCH_ENTER(et);
|
2008-04-14 18:13:33 +00:00
|
|
|
|
2006-11-03 15:23:16 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_ALLGONE) ||
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE)) {
|
|
|
|
/* Should I really unlock ? */
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EFAULT);
|
2006-11-03 15:23:16 +00:00
|
|
|
error = EFAULT;
|
|
|
|
goto out_now;
|
|
|
|
}
|
|
|
|
#ifdef INET6
|
|
|
|
if (((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) == 0) &&
|
|
|
|
(addr->sa_family == AF_INET6)) {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2006-11-03 15:23:16 +00:00
|
|
|
error = EINVAL;
|
|
|
|
goto out_now;
|
|
|
|
}
|
2013-02-09 17:26:14 +00:00
|
|
|
#endif
|
2006-11-03 15:23:16 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_UNBOUND) ==
|
|
|
|
SCTP_PCB_FLAGS_UNBOUND) {
|
|
|
|
/* Bind a ephemeral port */
|
2007-07-24 20:06:02 +00:00
|
|
|
error = sctp_inpcb_bind(so, NULL, NULL, p);
|
2006-11-03 15:23:16 +00:00
|
|
|
if (error) {
|
|
|
|
goto out_now;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* Now do we connect? */
|
2008-07-31 11:08:30 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) &&
|
|
|
|
(sctp_is_feature_off(inp, SCTP_PCB_FLAGS_PORTREUSE))) {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2006-11-03 15:23:16 +00:00
|
|
|
error = EINVAL;
|
|
|
|
goto out_now;
|
|
|
|
}
|
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) &&
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED)) {
|
|
|
|
/* We are already connected AND the TCP model */
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, stcb, NULL, SCTP_FROM_SCTP_USRREQ, EADDRINUSE);
|
2006-11-03 15:23:16 +00:00
|
|
|
error = EADDRINUSE;
|
|
|
|
goto out_now;
|
|
|
|
}
|
|
|
|
if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
|
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
stcb = LIST_FIRST(&inp->sctp_asoc_list);
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
} else {
|
|
|
|
/*
|
2007-02-12 23:24:31 +00:00
|
|
|
* We increment here since sctp_findassociation_ep_addr()
|
2008-07-31 11:08:30 +00:00
|
|
|
* will do a decrement if it finds the stcb as long as the
|
2007-02-12 23:24:31 +00:00
|
|
|
* locked tcb (last argument) is NOT a TCB.. aka NULL.
|
2006-11-03 15:23:16 +00:00
|
|
|
*/
|
|
|
|
SCTP_INP_INCR_REF(inp);
|
|
|
|
stcb = sctp_findassociation_ep_addr(&inp, addr, NULL, NULL, NULL);
|
|
|
|
if (stcb == NULL) {
|
|
|
|
SCTP_INP_DECR_REF(inp);
|
2007-04-03 11:15:32 +00:00
|
|
|
} else {
|
2008-04-14 18:13:33 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (stcb != NULL) {
|
|
|
|
/* Already have or am bring up an association */
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EALREADY);
|
2006-11-03 15:23:16 +00:00
|
|
|
error = EALREADY;
|
|
|
|
goto out_now;
|
|
|
|
}
|
2018-07-19 20:16:33 +00:00
|
|
|
|
2007-04-03 11:15:32 +00:00
|
|
|
vrf_id = inp->def_vrf_id;
|
2006-11-03 15:23:16 +00:00
|
|
|
/* We are GOOD to go */
|
2021-06-27 18:14:48 +00:00
|
|
|
stcb = sctp_aloc_assoc(inp, addr, &error, 0, 0, vrf_id,
|
2016-05-01 21:48:55 +00:00
|
|
|
inp->sctp_ep.pre_open_stream_count,
|
2019-07-14 12:04:39 +00:00
|
|
|
inp->sctp_ep.port, p,
|
|
|
|
SCTP_INITIALIZE_AUTH_PARAMS);
|
2006-11-03 15:23:16 +00:00
|
|
|
if (stcb == NULL) {
|
|
|
|
/* Gak! no memory */
|
2007-03-15 11:27:14 +00:00
|
|
|
goto out_now;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
if (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) {
|
|
|
|
stcb->sctp_ep->sctp_flags |= SCTP_PCB_FLAGS_CONNECTED;
|
|
|
|
/* Set the connected flag so we can queue data */
|
|
|
|
soisconnecting(so);
|
|
|
|
}
|
2018-08-13 13:58:45 +00:00
|
|
|
SCTP_SET_STATE(stcb, SCTP_STATE_COOKIE_WAIT);
|
2007-05-08 14:32:53 +00:00
|
|
|
(void)SCTP_GETTIME_TIMEVAL(&stcb->asoc.time_entered);
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2007-09-08 11:35:11 +00:00
|
|
|
sctp_send_initiate(inp, stcb, SCTP_SO_LOCKED);
|
2007-04-03 11:15:32 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
2006-11-03 15:23:16 +00:00
|
|
|
out_now:
|
2020-02-18 21:25:17 +00:00
|
|
|
NET_EPOCH_EXIT(et);
|
2007-05-09 13:30:06 +00:00
|
|
|
if (create_lock_on) {
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_ASOC_CREATE_UNLOCK(inp);
|
2007-05-09 13:30:06 +00:00
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_INP_DECR_REF(inp);
|
2011-12-27 10:16:24 +00:00
|
|
|
return (error);
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2011-04-30 11:18:16 +00:00
|
|
|
#endif
|
|
|
|
|
2006-11-03 15:23:16 +00:00
|
|
|
int
|
|
|
|
sctp_listen(struct socket *so, int backlog, struct thread *p)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Note this module depends on the protocol processing being called
|
|
|
|
* AFTER any socket level flags and backlog are applied to the
|
|
|
|
* socket. The traditional way that the socket flags are applied is
|
|
|
|
* AFTER protocol processing. We have made a change to the
|
|
|
|
* sys/kern/uipc_socket.c module to reverse this but this MUST be in
|
|
|
|
* place if the socket API for SCTP is to work properly.
|
|
|
|
*/
|
|
|
|
|
|
|
|
int error = 0;
|
|
|
|
struct sctp_inpcb *inp;
|
|
|
|
|
|
|
|
inp = (struct sctp_inpcb *)so->so_pcb;
|
2012-03-15 14:22:05 +00:00
|
|
|
if (inp == NULL) {
|
2006-11-03 15:23:16 +00:00
|
|
|
/* I made the same as TCP since we are not setup? */
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2006-11-03 15:23:16 +00:00
|
|
|
return (ECONNRESET);
|
|
|
|
}
|
2008-07-31 11:08:30 +00:00
|
|
|
if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_PORTREUSE)) {
|
|
|
|
/* See if we have a listener */
|
|
|
|
struct sctp_inpcb *tinp;
|
2014-06-20 20:17:39 +00:00
|
|
|
union sctp_sockstore store;
|
2008-07-31 11:08:30 +00:00
|
|
|
|
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) == 0) {
|
|
|
|
/* not bound all */
|
|
|
|
struct sctp_laddr *laddr;
|
|
|
|
|
|
|
|
LIST_FOREACH(laddr, &inp->sctp_addr_list, sctp_nxt_addr) {
|
|
|
|
memcpy(&store, &laddr->ifa->address, sizeof(store));
|
2014-06-20 20:17:39 +00:00
|
|
|
switch (store.sa.sa_family) {
|
2011-04-30 11:18:16 +00:00
|
|
|
#ifdef INET
|
|
|
|
case AF_INET:
|
2014-06-20 20:17:39 +00:00
|
|
|
store.sin.sin_port = inp->sctp_lport;
|
2011-04-30 11:18:16 +00:00
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
#ifdef INET6
|
|
|
|
case AF_INET6:
|
2014-06-20 20:17:39 +00:00
|
|
|
store.sin6.sin6_port = inp->sctp_lport;
|
2011-04-30 11:18:16 +00:00
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2014-06-20 20:17:39 +00:00
|
|
|
tinp = sctp_pcb_findep(&store.sa, 0, 0, inp->def_vrf_id);
|
2008-07-31 11:08:30 +00:00
|
|
|
if (tinp && (tinp != inp) &&
|
|
|
|
((tinp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_ALLGONE) == 0) &&
|
|
|
|
((tinp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) == 0) &&
|
2017-05-26 16:29:00 +00:00
|
|
|
(SCTP_IS_LISTENING(tinp))) {
|
2016-12-26 11:06:41 +00:00
|
|
|
/*
|
|
|
|
* we have a listener already and
|
|
|
|
* its not this inp.
|
|
|
|
*/
|
2008-07-31 11:08:30 +00:00
|
|
|
SCTP_INP_DECR_REF(tinp);
|
|
|
|
return (EADDRINUSE);
|
|
|
|
} else if (tinp) {
|
|
|
|
SCTP_INP_DECR_REF(tinp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* Setup a local addr bound all */
|
|
|
|
memset(&store, 0, sizeof(store));
|
|
|
|
#ifdef INET6
|
|
|
|
if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) {
|
|
|
|
store.sa.sa_family = AF_INET6;
|
|
|
|
store.sa.sa_len = sizeof(struct sockaddr_in6);
|
|
|
|
}
|
|
|
|
#endif
|
2011-04-30 11:18:16 +00:00
|
|
|
#ifdef INET
|
2008-07-31 11:08:30 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) == 0) {
|
|
|
|
store.sa.sa_family = AF_INET;
|
|
|
|
store.sa.sa_len = sizeof(struct sockaddr_in);
|
|
|
|
}
|
2011-04-30 11:18:16 +00:00
|
|
|
#endif
|
2014-06-20 20:17:39 +00:00
|
|
|
switch (store.sa.sa_family) {
|
|
|
|
#ifdef INET
|
|
|
|
case AF_INET:
|
|
|
|
store.sin.sin_port = inp->sctp_lport;
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
#ifdef INET6
|
|
|
|
case AF_INET6:
|
|
|
|
store.sin6.sin6_port = inp->sctp_lport;
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
tinp = sctp_pcb_findep(&store.sa, 0, 0, inp->def_vrf_id);
|
2008-07-31 11:08:30 +00:00
|
|
|
if (tinp && (tinp != inp) &&
|
|
|
|
((tinp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_ALLGONE) == 0) &&
|
|
|
|
((tinp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) == 0) &&
|
2017-05-26 16:29:00 +00:00
|
|
|
(SCTP_IS_LISTENING(tinp))) {
|
2016-12-26 11:06:41 +00:00
|
|
|
/*
|
|
|
|
* we have a listener already and its not
|
|
|
|
* this inp.
|
|
|
|
*/
|
2008-07-31 11:08:30 +00:00
|
|
|
SCTP_INP_DECR_REF(tinp);
|
|
|
|
return (EADDRINUSE);
|
|
|
|
} else if (tinp) {
|
2015-03-25 21:41:20 +00:00
|
|
|
SCTP_INP_DECR_REF(tinp);
|
2008-07-31 11:08:30 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2021-09-07 18:49:53 +00:00
|
|
|
SCTP_INP_INFO_WLOCK();
|
|
|
|
SCTP_INP_WLOCK(inp);
|
2006-11-03 15:23:16 +00:00
|
|
|
#ifdef SCTP_LOCK_LOGGING
|
2008-06-14 07:58:05 +00:00
|
|
|
if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_LOCK_LOGGING_ENABLE) {
|
2007-06-14 22:59:04 +00:00
|
|
|
sctp_log_lock(inp, (struct sctp_tcb *)NULL, SCTP_LOG_LOCK_SOCK);
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
#endif
|
|
|
|
SOCK_LOCK(so);
|
|
|
|
error = solisten_proto_check(so);
|
|
|
|
if (error) {
|
2021-09-07 18:49:53 +00:00
|
|
|
SOCK_UNLOCK(so);
|
|
|
|
goto out;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
2008-07-31 11:08:30 +00:00
|
|
|
if ((sctp_is_feature_on(inp, SCTP_PCB_FLAGS_PORTREUSE)) &&
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL)) {
|
|
|
|
/*
|
|
|
|
* The unlucky case - We are in the tcp pool with this guy.
|
|
|
|
* - Someone else is in the main inp slot. - We must move
|
|
|
|
* this guy (the listener) to the main slot - We must then
|
|
|
|
* move the guy that was listener to the TCP Pool.
|
|
|
|
*/
|
|
|
|
if (sctp_swap_inpcb_for_listen(inp)) {
|
2021-09-07 18:49:53 +00:00
|
|
|
SOCK_UNLOCK(so);
|
|
|
|
solisten_proto_abort(so);
|
|
|
|
error = EADDRINUSE;
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
|
|
|
|
goto out;
|
2008-07-31 11:08:30 +00:00
|
|
|
}
|
|
|
|
}
|
2018-07-19 20:16:33 +00:00
|
|
|
|
2006-11-03 15:23:16 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) &&
|
|
|
|
(inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED)) {
|
2021-09-07 18:49:53 +00:00
|
|
|
SOCK_UNLOCK(so);
|
|
|
|
solisten_proto_abort(so);
|
|
|
|
error = EADDRINUSE;
|
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, error);
|
|
|
|
goto out;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
if (inp->sctp_flags & SCTP_PCB_FLAGS_UNBOUND) {
|
2021-09-07 18:49:53 +00:00
|
|
|
if ((error = sctp_inpcb_bind_locked(inp, NULL, NULL, p))) {
|
|
|
|
SOCK_UNLOCK(so);
|
|
|
|
solisten_proto_abort(so);
|
2006-11-03 15:23:16 +00:00
|
|
|
/* bind error, probably perm */
|
2021-09-07 18:49:53 +00:00
|
|
|
goto out;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
}
|
Listening sockets improvements.
o Separate fields of struct socket that belong to listening from
fields that belong to normal dataflow, and unionize them. This
shrinks the structure a bit.
- Take out selinfo's from the socket buffers into the socket. The
first reason is to support braindamaged scenario when a socket is
added to kevent(2) and then listen(2) is cast on it. The second
reason is that there is future plan to make socket buffers pluggable,
so that for a dataflow socket a socket buffer can be changed, and
in this case we also want to keep same selinfos through the lifetime
of a socket.
- Remove struct struct so_accf. Since now listening stuff no longer
affects struct socket size, just move its fields into listening part
of the union.
- Provide sol_upcall field and enforce that so_upcall_set() may be called
only on a dataflow socket, which has buffers, and for listening sockets
provide solisten_upcall_set().
o Remove ACCEPT_LOCK() global.
- Add a mutex to socket, to be used instead of socket buffer lock to lock
fields of struct socket that don't belong to a socket buffer.
- Allow to acquire two socket locks, but the first one must belong to a
listening socket.
- Make soref()/sorele() to use atomic(9). This allows in some situations
to do soref() without owning socket lock. There is place for improvement
here, it is possible to make sorele() also to lock optionally.
- Most protocols aren't touched by this change, except UNIX local sockets.
See below for more information.
o Reduce copy-and-paste in kernel modules that accept connections from
listening sockets: provide function solisten_dequeue(), and use it in
the following modules: ctl(4), iscsi(4), ng_btsocket(4), ng_ksocket(4),
infiniband, rpc.
o UNIX local sockets.
- Removal of ACCEPT_LOCK() global uncovered several races in the UNIX
local sockets. Most races exist around spawning a new socket, when we
are connecting to a local listening socket. To cover them, we need to
hold locks on both PCBs when spawning a third one. This means holding
them across sonewconn(). This creates a LOR between pcb locks and
unp_list_lock.
- To fix the new LOR, abandon the global unp_list_lock in favor of global
unp_link_lock. Indeed, separating these two locks didn't provide us any
extra parralelism in the UNIX sockets.
- Now call into uipc_attach() may happen with unp_link_lock hold if, we
are accepting, or without unp_link_lock in case if we are just creating
a socket.
- Another problem in UNIX sockets is that uipc_close() basicly did nothing
for a listening socket. The vnode remained opened for connections. This
is fixed by removing vnode in uipc_close(). Maybe the right way would be
to do it for all sockets (not only listening), simply move the vnode
teardown from uipc_detach() to uipc_close()?
Sponsored by: Netflix
Differential Revision: https://reviews.freebsd.org/D9770
2017-06-08 21:30:34 +00:00
|
|
|
if ((inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) == 0) {
|
|
|
|
solisten_proto(so, backlog);
|
2021-09-07 18:51:19 +00:00
|
|
|
SOCK_UNLOCK(so);
|
2017-06-23 08:35:54 +00:00
|
|
|
inp->sctp_flags |= SCTP_PCB_FLAGS_ACCEPTING;
|
|
|
|
} else {
|
2021-09-07 18:51:19 +00:00
|
|
|
solisten_proto_abort(so);
|
|
|
|
SOCK_UNLOCK(so);
|
|
|
|
if (backlog > 0) {
|
|
|
|
inp->sctp_flags |= SCTP_PCB_FLAGS_ACCEPTING;
|
|
|
|
} else {
|
|
|
|
inp->sctp_flags &= ~SCTP_PCB_FLAGS_ACCEPTING;
|
|
|
|
}
|
2017-06-23 08:35:54 +00:00
|
|
|
}
|
2021-09-07 18:49:53 +00:00
|
|
|
out:
|
2017-05-26 16:29:00 +00:00
|
|
|
SCTP_INP_WUNLOCK(inp);
|
2021-09-07 18:49:53 +00:00
|
|
|
SCTP_INP_INFO_WUNLOCK();
|
2006-11-03 15:23:16 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sctp_defered_wakeup_cnt = 0;
|
|
|
|
|
|
|
|
int
|
|
|
|
sctp_accept(struct socket *so, struct sockaddr **addr)
|
|
|
|
{
|
|
|
|
struct sctp_tcb *stcb;
|
|
|
|
struct sctp_inpcb *inp;
|
|
|
|
union sctp_sockstore store;
|
2008-04-16 17:24:18 +00:00
|
|
|
#ifdef INET6
|
2006-11-03 15:23:16 +00:00
|
|
|
int error;
|
2008-04-16 17:24:18 +00:00
|
|
|
#endif
|
2006-11-03 15:23:16 +00:00
|
|
|
inp = (struct sctp_inpcb *)so->so_pcb;
|
|
|
|
|
2012-03-15 14:22:05 +00:00
|
|
|
if (inp == NULL) {
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2006-11-03 15:23:16 +00:00
|
|
|
return (ECONNRESET);
|
|
|
|
}
|
2019-08-06 10:29:19 +00:00
|
|
|
SCTP_INP_WLOCK(inp);
|
2006-11-03 15:23:16 +00:00
|
|
|
if (inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) {
|
2019-08-06 10:29:19 +00:00
|
|
|
SCTP_INP_WUNLOCK(inp);
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EOPNOTSUPP);
|
|
|
|
return (EOPNOTSUPP);
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
if (so->so_state & SS_ISDISCONNECTED) {
|
2019-08-06 10:29:19 +00:00
|
|
|
SCTP_INP_WUNLOCK(inp);
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ECONNABORTED);
|
2006-11-03 15:23:16 +00:00
|
|
|
return (ECONNABORTED);
|
|
|
|
}
|
|
|
|
stcb = LIST_FIRST(&inp->sctp_asoc_list);
|
|
|
|
if (stcb == NULL) {
|
2019-08-06 10:29:19 +00:00
|
|
|
SCTP_INP_WUNLOCK(inp);
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2006-11-03 15:23:16 +00:00
|
|
|
return (ECONNRESET);
|
|
|
|
}
|
|
|
|
SCTP_TCB_LOCK(stcb);
|
|
|
|
store = stcb->asoc.primary_destination->ro._l_addr;
|
2018-08-13 13:58:45 +00:00
|
|
|
SCTP_CLEAR_SUBSTATE(stcb, SCTP_STATE_IN_ACCEPT_QUEUE);
|
2019-08-06 10:29:19 +00:00
|
|
|
/* Wake any delayed sleep action */
|
|
|
|
if (inp->sctp_flags & SCTP_PCB_FLAGS_DONT_WAKE) {
|
|
|
|
inp->sctp_flags &= ~SCTP_PCB_FLAGS_DONT_WAKE;
|
|
|
|
if (inp->sctp_flags & SCTP_PCB_FLAGS_WAKEOUTPUT) {
|
|
|
|
inp->sctp_flags &= ~SCTP_PCB_FLAGS_WAKEOUTPUT;
|
|
|
|
SOCKBUF_LOCK(&inp->sctp_socket->so_snd);
|
|
|
|
if (sowriteable(inp->sctp_socket)) {
|
|
|
|
sowwakeup_locked(inp->sctp_socket);
|
|
|
|
} else {
|
|
|
|
SOCKBUF_UNLOCK(&inp->sctp_socket->so_snd);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (inp->sctp_flags & SCTP_PCB_FLAGS_WAKEINPUT) {
|
|
|
|
inp->sctp_flags &= ~SCTP_PCB_FLAGS_WAKEINPUT;
|
|
|
|
SOCKBUF_LOCK(&inp->sctp_socket->so_rcv);
|
|
|
|
if (soreadable(inp->sctp_socket)) {
|
|
|
|
sctp_defered_wakeup_cnt++;
|
|
|
|
sorwakeup_locked(inp->sctp_socket);
|
|
|
|
} else {
|
|
|
|
SOCKBUF_UNLOCK(&inp->sctp_socket->so_rcv);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
SCTP_INP_WUNLOCK(inp);
|
|
|
|
if (stcb->asoc.state & SCTP_STATE_ABOUT_TO_BE_FREED) {
|
|
|
|
sctp_free_assoc(inp, stcb, SCTP_NORMAL_PROC,
|
|
|
|
SCTP_FROM_SCTP_USRREQ + SCTP_LOC_19);
|
|
|
|
} else {
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
}
|
2008-04-16 17:24:18 +00:00
|
|
|
switch (store.sa.sa_family) {
|
2011-04-30 11:18:16 +00:00
|
|
|
#ifdef INET
|
2008-04-16 17:24:18 +00:00
|
|
|
case AF_INET:
|
|
|
|
{
|
|
|
|
struct sockaddr_in *sin;
|
|
|
|
|
|
|
|
SCTP_MALLOC_SONAME(sin, struct sockaddr_in *, sizeof *sin);
|
2010-06-06 02:32:20 +00:00
|
|
|
if (sin == NULL)
|
|
|
|
return (ENOMEM);
|
2008-04-16 17:24:18 +00:00
|
|
|
sin->sin_family = AF_INET;
|
|
|
|
sin->sin_len = sizeof(*sin);
|
2013-02-09 17:26:14 +00:00
|
|
|
sin->sin_port = store.sin.sin_port;
|
|
|
|
sin->sin_addr = store.sin.sin_addr;
|
2008-04-16 17:24:18 +00:00
|
|
|
*addr = (struct sockaddr *)sin;
|
|
|
|
break;
|
|
|
|
}
|
2011-04-30 11:18:16 +00:00
|
|
|
#endif
|
2008-04-16 17:24:18 +00:00
|
|
|
#ifdef INET6
|
|
|
|
case AF_INET6:
|
|
|
|
{
|
|
|
|
struct sockaddr_in6 *sin6;
|
2006-11-03 15:23:16 +00:00
|
|
|
|
2008-04-16 17:24:18 +00:00
|
|
|
SCTP_MALLOC_SONAME(sin6, struct sockaddr_in6 *, sizeof *sin6);
|
2010-06-06 02:32:20 +00:00
|
|
|
if (sin6 == NULL)
|
|
|
|
return (ENOMEM);
|
2008-04-16 17:24:18 +00:00
|
|
|
sin6->sin6_family = AF_INET6;
|
|
|
|
sin6->sin6_len = sizeof(*sin6);
|
2013-02-09 17:26:14 +00:00
|
|
|
sin6->sin6_port = store.sin6.sin6_port;
|
|
|
|
sin6->sin6_addr = store.sin6.sin6_addr;
|
2008-04-16 17:24:18 +00:00
|
|
|
if ((error = sa6_recoverscope(sin6)) != 0) {
|
|
|
|
SCTP_FREE_SONAME(sin6);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
*addr = (struct sockaddr *)sin6;
|
|
|
|
break;
|
2006-11-08 00:21:13 +00:00
|
|
|
}
|
2008-04-16 17:24:18 +00:00
|
|
|
#endif
|
|
|
|
default:
|
|
|
|
/* TSNH */
|
|
|
|
break;
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2011-04-30 11:18:16 +00:00
|
|
|
#ifdef INET
|
2006-11-03 15:23:16 +00:00
|
|
|
int
|
|
|
|
sctp_ingetaddr(struct socket *so, struct sockaddr **addr)
|
|
|
|
{
|
|
|
|
struct sockaddr_in *sin;
|
2007-03-15 11:27:14 +00:00
|
|
|
uint32_t vrf_id;
|
2006-11-03 15:23:16 +00:00
|
|
|
struct sctp_inpcb *inp;
|
2007-03-19 06:53:02 +00:00
|
|
|
struct sctp_ifa *sctp_ifa;
|
2006-11-03 15:23:16 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Do the malloc first in case it blocks.
|
|
|
|
*/
|
|
|
|
SCTP_MALLOC_SONAME(sin, struct sockaddr_in *, sizeof *sin);
|
2010-06-06 02:32:20 +00:00
|
|
|
if (sin == NULL)
|
|
|
|
return (ENOMEM);
|
2006-11-03 15:23:16 +00:00
|
|
|
sin->sin_family = AF_INET;
|
|
|
|
sin->sin_len = sizeof(*sin);
|
|
|
|
inp = (struct sctp_inpcb *)so->so_pcb;
|
|
|
|
if (!inp) {
|
|
|
|
SCTP_FREE_SONAME(sin);
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2011-12-27 10:16:24 +00:00
|
|
|
return (ECONNRESET);
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
sin->sin_port = inp->sctp_lport;
|
|
|
|
if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) {
|
|
|
|
if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
|
|
|
|
struct sctp_tcb *stcb;
|
|
|
|
struct sockaddr_in *sin_a;
|
|
|
|
struct sctp_nets *net;
|
|
|
|
int fnd;
|
|
|
|
|
|
|
|
stcb = LIST_FIRST(&inp->sctp_asoc_list);
|
|
|
|
if (stcb == NULL) {
|
|
|
|
goto notConn;
|
|
|
|
}
|
|
|
|
fnd = 0;
|
|
|
|
sin_a = NULL;
|
|
|
|
SCTP_TCB_LOCK(stcb);
|
|
|
|
TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
|
|
|
|
sin_a = (struct sockaddr_in *)&net->ro._l_addr;
|
2006-11-08 00:21:13 +00:00
|
|
|
if (sin_a == NULL)
|
|
|
|
/* this will make coverity happy */
|
|
|
|
continue;
|
|
|
|
|
2006-11-03 15:23:16 +00:00
|
|
|
if (sin_a->sin_family == AF_INET) {
|
|
|
|
fnd = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if ((!fnd) || (sin_a == NULL)) {
|
|
|
|
/* punt */
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
goto notConn;
|
|
|
|
}
|
2018-07-19 20:16:33 +00:00
|
|
|
|
2007-04-03 11:15:32 +00:00
|
|
|
vrf_id = inp->def_vrf_id;
|
2007-03-15 11:27:14 +00:00
|
|
|
sctp_ifa = sctp_source_address_selection(inp,
|
|
|
|
stcb,
|
2018-07-19 20:11:14 +00:00
|
|
|
(sctp_route_t *)&net->ro,
|
2007-03-15 11:27:14 +00:00
|
|
|
net, 0, vrf_id);
|
|
|
|
if (sctp_ifa) {
|
|
|
|
sin->sin_addr = sctp_ifa->address.sin.sin_addr;
|
|
|
|
sctp_free_ifa(sctp_ifa);
|
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
} else {
|
|
|
|
/* For the bound all case you get back 0 */
|
|
|
|
notConn:
|
|
|
|
sin->sin_addr.s_addr = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
|
|
|
/* Take the first IPv4 address in the list */
|
|
|
|
struct sctp_laddr *laddr;
|
|
|
|
int fnd = 0;
|
|
|
|
|
|
|
|
LIST_FOREACH(laddr, &inp->sctp_addr_list, sctp_nxt_addr) {
|
2007-03-15 11:27:14 +00:00
|
|
|
if (laddr->ifa->address.sa.sa_family == AF_INET) {
|
2006-11-03 15:23:16 +00:00
|
|
|
struct sockaddr_in *sin_a;
|
|
|
|
|
2014-09-07 09:06:26 +00:00
|
|
|
sin_a = &laddr->ifa->address.sin;
|
2006-11-03 15:23:16 +00:00
|
|
|
sin->sin_addr = sin_a->sin_addr;
|
|
|
|
fnd = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!fnd) {
|
|
|
|
SCTP_FREE_SONAME(sin);
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOENT);
|
2011-12-27 10:16:24 +00:00
|
|
|
return (ENOENT);
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
(*addr) = (struct sockaddr *)sin;
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
sctp_peeraddr(struct socket *so, struct sockaddr **addr)
|
|
|
|
{
|
2012-02-18 16:06:15 +00:00
|
|
|
struct sockaddr_in *sin;
|
2007-01-18 09:58:43 +00:00
|
|
|
int fnd;
|
2006-11-03 15:23:16 +00:00
|
|
|
struct sockaddr_in *sin_a;
|
|
|
|
struct sctp_inpcb *inp;
|
|
|
|
struct sctp_tcb *stcb;
|
|
|
|
struct sctp_nets *net;
|
|
|
|
|
|
|
|
/* Do the malloc first in case it blocks. */
|
|
|
|
SCTP_MALLOC_SONAME(sin, struct sockaddr_in *, sizeof *sin);
|
2010-06-06 02:32:20 +00:00
|
|
|
if (sin == NULL)
|
|
|
|
return (ENOMEM);
|
2006-11-03 15:23:16 +00:00
|
|
|
sin->sin_family = AF_INET;
|
|
|
|
sin->sin_len = sizeof(*sin);
|
|
|
|
|
|
|
|
inp = (struct sctp_inpcb *)so->so_pcb;
|
2011-12-27 10:16:24 +00:00
|
|
|
if ((inp == NULL) ||
|
|
|
|
((inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) == 0)) {
|
|
|
|
/* UDP type and listeners will drop out here */
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_FREE_SONAME(sin);
|
2011-12-27 10:16:24 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOTCONN);
|
|
|
|
return (ENOTCONN);
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
SCTP_INP_RLOCK(inp);
|
|
|
|
stcb = LIST_FIRST(&inp->sctp_asoc_list);
|
2007-05-09 13:30:06 +00:00
|
|
|
if (stcb) {
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_TCB_LOCK(stcb);
|
2007-05-09 13:30:06 +00:00
|
|
|
}
|
2006-11-03 15:23:16 +00:00
|
|
|
SCTP_INP_RUNLOCK(inp);
|
|
|
|
if (stcb == NULL) {
|
|
|
|
SCTP_FREE_SONAME(sin);
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, EINVAL);
|
2011-12-27 10:16:24 +00:00
|
|
|
return (ECONNRESET);
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
fnd = 0;
|
|
|
|
TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
|
|
|
|
sin_a = (struct sockaddr_in *)&net->ro._l_addr;
|
|
|
|
if (sin_a->sin_family == AF_INET) {
|
|
|
|
fnd = 1;
|
|
|
|
sin->sin_port = stcb->rport;
|
|
|
|
sin->sin_addr = sin_a->sin_addr;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
SCTP_TCB_UNLOCK(stcb);
|
|
|
|
if (!fnd) {
|
|
|
|
/* No IPv4 address */
|
|
|
|
SCTP_FREE_SONAME(sin);
|
2007-08-24 00:53:53 +00:00
|
|
|
SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_USRREQ, ENOENT);
|
2011-12-27 10:16:24 +00:00
|
|
|
return (ENOENT);
|
2006-11-03 15:23:16 +00:00
|
|
|
}
|
|
|
|
(*addr) = (struct sockaddr *)sin;
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct pr_usrreqs sctp_usrreqs = {
|
|
|
|
.pru_abort = sctp_abort,
|
|
|
|
.pru_accept = sctp_accept,
|
|
|
|
.pru_attach = sctp_attach,
|
|
|
|
.pru_bind = sctp_bind,
|
|
|
|
.pru_connect = sctp_connect,
|
|
|
|
.pru_control = in_control,
|
|
|
|
.pru_close = sctp_close,
|
|
|
|
.pru_detach = sctp_close,
|
|
|
|
.pru_sopoll = sopoll_generic,
|
2008-04-14 18:13:33 +00:00
|
|
|
.pru_flush = sctp_flush,
|
2006-11-03 15:23:16 +00:00
|
|
|
.pru_disconnect = sctp_disconnect,
|
|
|
|
.pru_listen = sctp_listen,
|
|
|
|
.pru_peeraddr = sctp_peeraddr,
|
|
|
|
.pru_send = sctp_sendm,
|
|
|
|
.pru_shutdown = sctp_shutdown,
|
|
|
|
.pru_sockaddr = sctp_ingetaddr,
|
|
|
|
.pru_sosend = sctp_sosend,
|
|
|
|
.pru_soreceive = sctp_soreceive
|
|
|
|
};
|
2011-04-30 11:18:16 +00:00
|
|
|
#endif
|