1f8829a4aSRandall Stewart /*- 2b1006367SRandall Stewart * Copyright (c) 2001-2007, by Cisco Systems, Inc. All rights reserved. 3f8829a4aSRandall Stewart * 4f8829a4aSRandall Stewart * Redistribution and use in source and binary forms, with or without 5f8829a4aSRandall Stewart * modification, are permitted provided that the following conditions are met: 6f8829a4aSRandall Stewart * 7f8829a4aSRandall Stewart * a) Redistributions of source code must retain the above copyright notice, 8f8829a4aSRandall Stewart * this list of conditions and the following disclaimer. 9f8829a4aSRandall Stewart * 10f8829a4aSRandall Stewart * b) Redistributions in binary form must reproduce the above copyright 11f8829a4aSRandall Stewart * notice, this list of conditions and the following disclaimer in 12f8829a4aSRandall Stewart * the documentation and/or other materials provided with the distribution. 13f8829a4aSRandall Stewart * 14f8829a4aSRandall Stewart * c) Neither the name of Cisco Systems, Inc. nor the names of its 15f8829a4aSRandall Stewart * contributors may be used to endorse or promote products derived 16f8829a4aSRandall Stewart * from this software without specific prior written permission. 17f8829a4aSRandall Stewart * 18f8829a4aSRandall Stewart * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19f8829a4aSRandall Stewart * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 20f8829a4aSRandall Stewart * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21f8829a4aSRandall Stewart * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 22f8829a4aSRandall Stewart * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 23f8829a4aSRandall Stewart * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 24f8829a4aSRandall Stewart * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 25f8829a4aSRandall Stewart * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 26f8829a4aSRandall Stewart * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 27f8829a4aSRandall Stewart * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 28f8829a4aSRandall Stewart * THE POSSIBILITY OF SUCH DAMAGE. 29f8829a4aSRandall Stewart */ 30f8829a4aSRandall Stewart 31f8829a4aSRandall Stewart /* $KAME: sctputil.c,v 1.37 2005/03/07 23:26:09 itojun Exp $ */ 32f8829a4aSRandall Stewart 33f8829a4aSRandall Stewart #include <sys/cdefs.h> 34f8829a4aSRandall Stewart __FBSDID("$FreeBSD$"); 35f8829a4aSRandall Stewart 36f8829a4aSRandall Stewart #include <netinet/sctp_os.h> 37f8829a4aSRandall Stewart #include <netinet/sctp_pcb.h> 38f8829a4aSRandall Stewart #include <netinet/sctputil.h> 39f8829a4aSRandall Stewart #include <netinet/sctp_var.h> 4042551e99SRandall Stewart #include <netinet/sctp_sysctl.h> 41f8829a4aSRandall Stewart #ifdef INET6 42f8829a4aSRandall Stewart #include <netinet6/sctp6_var.h> 43f8829a4aSRandall Stewart #endif 44f8829a4aSRandall Stewart #include <netinet/sctp_header.h> 45f8829a4aSRandall Stewart #include <netinet/sctp_output.h> 46f8829a4aSRandall Stewart #include <netinet/sctp_uio.h> 47f8829a4aSRandall Stewart #include <netinet/sctp_timer.h> 48f8829a4aSRandall Stewart #include <netinet/sctp_crc32.h> 49f8829a4aSRandall Stewart #include <netinet/sctp_indata.h>/* for sctp_deliver_data() */ 50f8829a4aSRandall Stewart #include <netinet/sctp_auth.h> 51f8829a4aSRandall Stewart #include <netinet/sctp_asconf.h> 52b54d3a6cSRandall Stewart #include <netinet/sctp_cc_functions.h> 53f8829a4aSRandall Stewart 54f8829a4aSRandall Stewart #define NUMBER_OF_MTU_SIZES 18 55f8829a4aSRandall Stewart 56f8829a4aSRandall Stewart 57b9e7085aSRandall Stewart #ifndef KTR_SCTP 58b9e7085aSRandall Stewart #define KTR_SCTP KTR_SUBSYS 5980fefe0aSRandall Stewart #endif 60f8829a4aSRandall Stewart 61f8829a4aSRandall Stewart void 62f8829a4aSRandall Stewart sctp_sblog(struct sockbuf *sb, 63f8829a4aSRandall Stewart struct sctp_tcb *stcb, int from, int incr) 64f8829a4aSRandall Stewart { 6580fefe0aSRandall Stewart struct sctp_cwnd_log sctp_clog; 66f8829a4aSRandall Stewart 6780fefe0aSRandall Stewart sctp_clog.x.sb.stcb = stcb; 6880fefe0aSRandall Stewart sctp_clog.x.sb.so_sbcc = sb->sb_cc; 69f8829a4aSRandall Stewart if (stcb) 7080fefe0aSRandall Stewart sctp_clog.x.sb.stcb_sbcc = stcb->asoc.sb_cc; 71f8829a4aSRandall Stewart else 7280fefe0aSRandall Stewart sctp_clog.x.sb.stcb_sbcc = 0; 7380fefe0aSRandall Stewart sctp_clog.x.sb.incr = incr; 74c4739e2fSRandall Stewart SCTP_CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x", 7580fefe0aSRandall Stewart SCTP_LOG_EVENT_SB, 7680fefe0aSRandall Stewart from, 7780fefe0aSRandall Stewart sctp_clog.x.misc.log1, 7880fefe0aSRandall Stewart sctp_clog.x.misc.log2, 7980fefe0aSRandall Stewart sctp_clog.x.misc.log3, 8080fefe0aSRandall Stewart sctp_clog.x.misc.log4); 81f8829a4aSRandall Stewart } 82f8829a4aSRandall Stewart 83f8829a4aSRandall Stewart void 84f8829a4aSRandall Stewart sctp_log_closing(struct sctp_inpcb *inp, struct sctp_tcb *stcb, int16_t loc) 85f8829a4aSRandall Stewart { 8680fefe0aSRandall Stewart struct sctp_cwnd_log sctp_clog; 87f8829a4aSRandall Stewart 8880fefe0aSRandall Stewart sctp_clog.x.close.inp = (void *)inp; 8980fefe0aSRandall Stewart sctp_clog.x.close.sctp_flags = inp->sctp_flags; 90f8829a4aSRandall Stewart if (stcb) { 9180fefe0aSRandall Stewart sctp_clog.x.close.stcb = (void *)stcb; 9280fefe0aSRandall Stewart sctp_clog.x.close.state = (uint16_t) stcb->asoc.state; 93f8829a4aSRandall Stewart } else { 9480fefe0aSRandall Stewart sctp_clog.x.close.stcb = 0; 9580fefe0aSRandall Stewart sctp_clog.x.close.state = 0; 96f8829a4aSRandall Stewart } 9780fefe0aSRandall Stewart sctp_clog.x.close.loc = loc; 98c4739e2fSRandall Stewart SCTP_CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x", 9980fefe0aSRandall Stewart SCTP_LOG_EVENT_CLOSE, 10080fefe0aSRandall Stewart 0, 10180fefe0aSRandall Stewart sctp_clog.x.misc.log1, 10280fefe0aSRandall Stewart sctp_clog.x.misc.log2, 10380fefe0aSRandall Stewart sctp_clog.x.misc.log3, 10480fefe0aSRandall Stewart sctp_clog.x.misc.log4); 105f8829a4aSRandall Stewart } 106f8829a4aSRandall Stewart 107f8829a4aSRandall Stewart 108f8829a4aSRandall Stewart void 109f8829a4aSRandall Stewart rto_logging(struct sctp_nets *net, int from) 110f8829a4aSRandall Stewart { 11180fefe0aSRandall Stewart struct sctp_cwnd_log sctp_clog; 112f8829a4aSRandall Stewart 11380fefe0aSRandall Stewart sctp_clog.x.rto.net = (void *)net; 11480fefe0aSRandall Stewart sctp_clog.x.rto.rtt = net->prev_rtt; 115c4739e2fSRandall Stewart SCTP_CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x", 11680fefe0aSRandall Stewart SCTP_LOG_EVENT_RTT, 11780fefe0aSRandall Stewart from, 11880fefe0aSRandall Stewart sctp_clog.x.misc.log1, 11980fefe0aSRandall Stewart sctp_clog.x.misc.log2, 12080fefe0aSRandall Stewart sctp_clog.x.misc.log3, 12180fefe0aSRandall Stewart sctp_clog.x.misc.log4); 12280fefe0aSRandall Stewart 123f8829a4aSRandall Stewart } 124f8829a4aSRandall Stewart 125f8829a4aSRandall Stewart void 1266a91f103SRandall Stewart sctp_log_strm_del_alt(struct sctp_tcb *stcb, uint32_t tsn, uint16_t sseq, uint16_t stream, int from) 127f8829a4aSRandall Stewart { 12880fefe0aSRandall Stewart struct sctp_cwnd_log sctp_clog; 129f8829a4aSRandall Stewart 13080fefe0aSRandall Stewart sctp_clog.x.strlog.stcb = stcb; 13180fefe0aSRandall Stewart sctp_clog.x.strlog.n_tsn = tsn; 13280fefe0aSRandall Stewart sctp_clog.x.strlog.n_sseq = sseq; 13380fefe0aSRandall Stewart sctp_clog.x.strlog.e_tsn = 0; 13480fefe0aSRandall Stewart sctp_clog.x.strlog.e_sseq = 0; 13580fefe0aSRandall Stewart sctp_clog.x.strlog.strm = stream; 136c4739e2fSRandall Stewart SCTP_CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x", 13780fefe0aSRandall Stewart SCTP_LOG_EVENT_STRM, 13880fefe0aSRandall Stewart from, 13980fefe0aSRandall Stewart sctp_clog.x.misc.log1, 14080fefe0aSRandall Stewart sctp_clog.x.misc.log2, 14180fefe0aSRandall Stewart sctp_clog.x.misc.log3, 14280fefe0aSRandall Stewart sctp_clog.x.misc.log4); 14380fefe0aSRandall Stewart 144f8829a4aSRandall Stewart } 145f8829a4aSRandall Stewart 146f8829a4aSRandall Stewart void 147f8829a4aSRandall Stewart sctp_log_nagle_event(struct sctp_tcb *stcb, int action) 148f8829a4aSRandall Stewart { 14980fefe0aSRandall Stewart struct sctp_cwnd_log sctp_clog; 150f8829a4aSRandall Stewart 15180fefe0aSRandall Stewart sctp_clog.x.nagle.stcb = (void *)stcb; 15280fefe0aSRandall Stewart sctp_clog.x.nagle.total_flight = stcb->asoc.total_flight; 15380fefe0aSRandall Stewart sctp_clog.x.nagle.total_in_queue = stcb->asoc.total_output_queue_size; 15480fefe0aSRandall Stewart sctp_clog.x.nagle.count_in_queue = stcb->asoc.chunks_on_out_queue; 15580fefe0aSRandall Stewart sctp_clog.x.nagle.count_in_flight = stcb->asoc.total_flight_count; 156c4739e2fSRandall Stewart SCTP_CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x", 15780fefe0aSRandall Stewart SCTP_LOG_EVENT_NAGLE, 15880fefe0aSRandall Stewart action, 15980fefe0aSRandall Stewart sctp_clog.x.misc.log1, 16080fefe0aSRandall Stewart sctp_clog.x.misc.log2, 16180fefe0aSRandall Stewart sctp_clog.x.misc.log3, 16280fefe0aSRandall Stewart sctp_clog.x.misc.log4); 163f8829a4aSRandall Stewart } 164f8829a4aSRandall Stewart 165f8829a4aSRandall Stewart 166f8829a4aSRandall Stewart void 167f8829a4aSRandall Stewart sctp_log_sack(uint32_t old_cumack, uint32_t cumack, uint32_t tsn, uint16_t gaps, uint16_t dups, int from) 168f8829a4aSRandall Stewart { 16980fefe0aSRandall Stewart struct sctp_cwnd_log sctp_clog; 170f8829a4aSRandall Stewart 17180fefe0aSRandall Stewart sctp_clog.x.sack.cumack = cumack; 17280fefe0aSRandall Stewart sctp_clog.x.sack.oldcumack = old_cumack; 17380fefe0aSRandall Stewart sctp_clog.x.sack.tsn = tsn; 17480fefe0aSRandall Stewart sctp_clog.x.sack.numGaps = gaps; 17580fefe0aSRandall Stewart sctp_clog.x.sack.numDups = dups; 176c4739e2fSRandall Stewart SCTP_CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x", 17780fefe0aSRandall Stewart SCTP_LOG_EVENT_SACK, 17880fefe0aSRandall Stewart from, 17980fefe0aSRandall Stewart sctp_clog.x.misc.log1, 18080fefe0aSRandall Stewart sctp_clog.x.misc.log2, 18180fefe0aSRandall Stewart sctp_clog.x.misc.log3, 18280fefe0aSRandall Stewart sctp_clog.x.misc.log4); 183f8829a4aSRandall Stewart } 184f8829a4aSRandall Stewart 185f8829a4aSRandall Stewart void 186f8829a4aSRandall Stewart sctp_log_map(uint32_t map, uint32_t cum, uint32_t high, int from) 187f8829a4aSRandall Stewart { 18880fefe0aSRandall Stewart struct sctp_cwnd_log sctp_clog; 189f8829a4aSRandall Stewart 19080fefe0aSRandall Stewart sctp_clog.x.map.base = map; 19180fefe0aSRandall Stewart sctp_clog.x.map.cum = cum; 19280fefe0aSRandall Stewart sctp_clog.x.map.high = high; 193c4739e2fSRandall Stewart SCTP_CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x", 19480fefe0aSRandall Stewart SCTP_LOG_EVENT_MAP, 19580fefe0aSRandall Stewart from, 19680fefe0aSRandall Stewart sctp_clog.x.misc.log1, 19780fefe0aSRandall Stewart sctp_clog.x.misc.log2, 19880fefe0aSRandall Stewart sctp_clog.x.misc.log3, 19980fefe0aSRandall Stewart sctp_clog.x.misc.log4); 200f8829a4aSRandall Stewart } 201f8829a4aSRandall Stewart 202f8829a4aSRandall Stewart void 203f8829a4aSRandall Stewart sctp_log_fr(uint32_t biggest_tsn, uint32_t biggest_new_tsn, uint32_t tsn, 204f8829a4aSRandall Stewart int from) 205f8829a4aSRandall Stewart { 20680fefe0aSRandall Stewart struct sctp_cwnd_log sctp_clog; 207f8829a4aSRandall Stewart 20880fefe0aSRandall Stewart sctp_clog.x.fr.largest_tsn = biggest_tsn; 20980fefe0aSRandall Stewart sctp_clog.x.fr.largest_new_tsn = biggest_new_tsn; 21080fefe0aSRandall Stewart sctp_clog.x.fr.tsn = tsn; 211c4739e2fSRandall Stewart SCTP_CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x", 21280fefe0aSRandall Stewart SCTP_LOG_EVENT_FR, 21380fefe0aSRandall Stewart from, 21480fefe0aSRandall Stewart sctp_clog.x.misc.log1, 21580fefe0aSRandall Stewart sctp_clog.x.misc.log2, 21680fefe0aSRandall Stewart sctp_clog.x.misc.log3, 21780fefe0aSRandall Stewart sctp_clog.x.misc.log4); 21880fefe0aSRandall Stewart 219f8829a4aSRandall Stewart } 220f8829a4aSRandall Stewart 221f8829a4aSRandall Stewart 222f8829a4aSRandall Stewart void 223f8829a4aSRandall Stewart sctp_log_mb(struct mbuf *m, int from) 224f8829a4aSRandall Stewart { 22580fefe0aSRandall Stewart struct sctp_cwnd_log sctp_clog; 226f8829a4aSRandall Stewart 22780fefe0aSRandall Stewart sctp_clog.x.mb.mp = m; 22880fefe0aSRandall Stewart sctp_clog.x.mb.mbuf_flags = (uint8_t) (SCTP_BUF_GET_FLAGS(m)); 22980fefe0aSRandall Stewart sctp_clog.x.mb.size = (uint16_t) (SCTP_BUF_LEN(m)); 23080fefe0aSRandall Stewart sctp_clog.x.mb.data = SCTP_BUF_AT(m, 0); 231139bc87fSRandall Stewart if (SCTP_BUF_IS_EXTENDED(m)) { 23280fefe0aSRandall Stewart sctp_clog.x.mb.ext = SCTP_BUF_EXTEND_BASE(m); 23380fefe0aSRandall Stewart sctp_clog.x.mb.refcnt = (uint8_t) (SCTP_BUF_EXTEND_REFCNT(m)); 234f8829a4aSRandall Stewart } else { 23580fefe0aSRandall Stewart sctp_clog.x.mb.ext = 0; 23680fefe0aSRandall Stewart sctp_clog.x.mb.refcnt = 0; 237f8829a4aSRandall Stewart } 238c4739e2fSRandall Stewart SCTP_CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x", 23980fefe0aSRandall Stewart SCTP_LOG_EVENT_MBUF, 24080fefe0aSRandall Stewart from, 24180fefe0aSRandall Stewart sctp_clog.x.misc.log1, 24280fefe0aSRandall Stewart sctp_clog.x.misc.log2, 24380fefe0aSRandall Stewart sctp_clog.x.misc.log3, 24480fefe0aSRandall Stewart sctp_clog.x.misc.log4); 245f8829a4aSRandall Stewart } 246f8829a4aSRandall Stewart 247f8829a4aSRandall Stewart 248f8829a4aSRandall Stewart void 249f8829a4aSRandall Stewart sctp_log_strm_del(struct sctp_queued_to_read *control, struct sctp_queued_to_read *poschk, 250f8829a4aSRandall Stewart int from) 251f8829a4aSRandall Stewart { 25280fefe0aSRandall Stewart struct sctp_cwnd_log sctp_clog; 253f8829a4aSRandall Stewart 254f8829a4aSRandall Stewart if (control == NULL) { 255ad81507eSRandall Stewart SCTP_PRINTF("Gak log of NULL?\n"); 256f8829a4aSRandall Stewart return; 257f8829a4aSRandall Stewart } 25880fefe0aSRandall Stewart sctp_clog.x.strlog.stcb = control->stcb; 25980fefe0aSRandall Stewart sctp_clog.x.strlog.n_tsn = control->sinfo_tsn; 26080fefe0aSRandall Stewart sctp_clog.x.strlog.n_sseq = control->sinfo_ssn; 26180fefe0aSRandall Stewart sctp_clog.x.strlog.strm = control->sinfo_stream; 262f8829a4aSRandall Stewart if (poschk != NULL) { 26380fefe0aSRandall Stewart sctp_clog.x.strlog.e_tsn = poschk->sinfo_tsn; 26480fefe0aSRandall Stewart sctp_clog.x.strlog.e_sseq = poschk->sinfo_ssn; 265f8829a4aSRandall Stewart } else { 26680fefe0aSRandall Stewart sctp_clog.x.strlog.e_tsn = 0; 26780fefe0aSRandall Stewart sctp_clog.x.strlog.e_sseq = 0; 268f8829a4aSRandall Stewart } 269c4739e2fSRandall Stewart SCTP_CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x", 27080fefe0aSRandall Stewart SCTP_LOG_EVENT_STRM, 27180fefe0aSRandall Stewart from, 27280fefe0aSRandall Stewart sctp_clog.x.misc.log1, 27380fefe0aSRandall Stewart sctp_clog.x.misc.log2, 27480fefe0aSRandall Stewart sctp_clog.x.misc.log3, 27580fefe0aSRandall Stewart sctp_clog.x.misc.log4); 27680fefe0aSRandall Stewart 277f8829a4aSRandall Stewart } 278f8829a4aSRandall Stewart 279f8829a4aSRandall Stewart void 280f8829a4aSRandall Stewart sctp_log_cwnd(struct sctp_tcb *stcb, struct sctp_nets *net, int augment, uint8_t from) 281f8829a4aSRandall Stewart { 28280fefe0aSRandall Stewart struct sctp_cwnd_log sctp_clog; 283f8829a4aSRandall Stewart 28480fefe0aSRandall Stewart sctp_clog.x.cwnd.net = net; 285f8829a4aSRandall Stewart if (stcb->asoc.send_queue_cnt > 255) 28680fefe0aSRandall Stewart sctp_clog.x.cwnd.cnt_in_send = 255; 287f8829a4aSRandall Stewart else 28880fefe0aSRandall Stewart sctp_clog.x.cwnd.cnt_in_send = stcb->asoc.send_queue_cnt; 289f8829a4aSRandall Stewart if (stcb->asoc.stream_queue_cnt > 255) 29080fefe0aSRandall Stewart sctp_clog.x.cwnd.cnt_in_str = 255; 291f8829a4aSRandall Stewart else 29280fefe0aSRandall Stewart sctp_clog.x.cwnd.cnt_in_str = stcb->asoc.stream_queue_cnt; 293f8829a4aSRandall Stewart 294f8829a4aSRandall Stewart if (net) { 29580fefe0aSRandall Stewart sctp_clog.x.cwnd.cwnd_new_value = net->cwnd; 29680fefe0aSRandall Stewart sctp_clog.x.cwnd.inflight = net->flight_size; 29780fefe0aSRandall Stewart sctp_clog.x.cwnd.pseudo_cumack = net->pseudo_cumack; 29880fefe0aSRandall Stewart sctp_clog.x.cwnd.meets_pseudo_cumack = net->new_pseudo_cumack; 29980fefe0aSRandall Stewart sctp_clog.x.cwnd.need_new_pseudo_cumack = net->find_pseudo_cumack; 300f8829a4aSRandall Stewart } 301f8829a4aSRandall Stewart if (SCTP_CWNDLOG_PRESEND == from) { 30280fefe0aSRandall Stewart sctp_clog.x.cwnd.meets_pseudo_cumack = stcb->asoc.peers_rwnd; 303f8829a4aSRandall Stewart } 30480fefe0aSRandall Stewart sctp_clog.x.cwnd.cwnd_augment = augment; 305c4739e2fSRandall Stewart SCTP_CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x", 30680fefe0aSRandall Stewart SCTP_LOG_EVENT_CWND, 30780fefe0aSRandall Stewart from, 30880fefe0aSRandall Stewart sctp_clog.x.misc.log1, 30980fefe0aSRandall Stewart sctp_clog.x.misc.log2, 31080fefe0aSRandall Stewart sctp_clog.x.misc.log3, 31180fefe0aSRandall Stewart sctp_clog.x.misc.log4); 31280fefe0aSRandall Stewart 313f8829a4aSRandall Stewart } 314f8829a4aSRandall Stewart 315f8829a4aSRandall Stewart void 316f8829a4aSRandall Stewart sctp_log_lock(struct sctp_inpcb *inp, struct sctp_tcb *stcb, uint8_t from) 317f8829a4aSRandall Stewart { 31880fefe0aSRandall Stewart struct sctp_cwnd_log sctp_clog; 319f8829a4aSRandall Stewart 32003b0b021SRandall Stewart if (inp) { 32180fefe0aSRandall Stewart sctp_clog.x.lock.sock = (void *)inp->sctp_socket; 32203b0b021SRandall Stewart 32303b0b021SRandall Stewart } else { 32480fefe0aSRandall Stewart sctp_clog.x.lock.sock = (void *)NULL; 32503b0b021SRandall Stewart } 32680fefe0aSRandall Stewart sctp_clog.x.lock.inp = (void *)inp; 327f8829a4aSRandall Stewart if (stcb) { 32880fefe0aSRandall Stewart sctp_clog.x.lock.tcb_lock = mtx_owned(&stcb->tcb_mtx); 329f8829a4aSRandall Stewart } else { 33080fefe0aSRandall Stewart sctp_clog.x.lock.tcb_lock = SCTP_LOCK_UNKNOWN; 331f8829a4aSRandall Stewart } 332f8829a4aSRandall Stewart if (inp) { 33380fefe0aSRandall Stewart sctp_clog.x.lock.inp_lock = mtx_owned(&inp->inp_mtx); 33480fefe0aSRandall Stewart sctp_clog.x.lock.create_lock = mtx_owned(&inp->inp_create_mtx); 335f8829a4aSRandall Stewart } else { 33680fefe0aSRandall Stewart sctp_clog.x.lock.inp_lock = SCTP_LOCK_UNKNOWN; 33780fefe0aSRandall Stewart sctp_clog.x.lock.create_lock = SCTP_LOCK_UNKNOWN; 338f8829a4aSRandall Stewart } 339c99efcf6SRandall Stewart sctp_clog.x.lock.info_lock = rw_wowned(&sctppcbinfo.ipi_ep_mtx); 340f8829a4aSRandall Stewart if (inp->sctp_socket) { 34180fefe0aSRandall Stewart sctp_clog.x.lock.sock_lock = mtx_owned(&(inp->sctp_socket->so_rcv.sb_mtx)); 34280fefe0aSRandall Stewart sctp_clog.x.lock.sockrcvbuf_lock = mtx_owned(&(inp->sctp_socket->so_rcv.sb_mtx)); 34380fefe0aSRandall Stewart sctp_clog.x.lock.socksndbuf_lock = mtx_owned(&(inp->sctp_socket->so_snd.sb_mtx)); 344f8829a4aSRandall Stewart } else { 34580fefe0aSRandall Stewart sctp_clog.x.lock.sock_lock = SCTP_LOCK_UNKNOWN; 34680fefe0aSRandall Stewart sctp_clog.x.lock.sockrcvbuf_lock = SCTP_LOCK_UNKNOWN; 34780fefe0aSRandall Stewart sctp_clog.x.lock.socksndbuf_lock = SCTP_LOCK_UNKNOWN; 348f8829a4aSRandall Stewart } 349c4739e2fSRandall Stewart SCTP_CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x", 35080fefe0aSRandall Stewart SCTP_LOG_LOCK_EVENT, 35180fefe0aSRandall Stewart from, 35280fefe0aSRandall Stewart sctp_clog.x.misc.log1, 35380fefe0aSRandall Stewart sctp_clog.x.misc.log2, 35480fefe0aSRandall Stewart sctp_clog.x.misc.log3, 35580fefe0aSRandall Stewart sctp_clog.x.misc.log4); 35680fefe0aSRandall Stewart 357f8829a4aSRandall Stewart } 358f8829a4aSRandall Stewart 359f8829a4aSRandall Stewart void 360f8829a4aSRandall Stewart sctp_log_maxburst(struct sctp_tcb *stcb, struct sctp_nets *net, int error, int burst, uint8_t from) 361f8829a4aSRandall Stewart { 36280fefe0aSRandall Stewart struct sctp_cwnd_log sctp_clog; 363f8829a4aSRandall Stewart 36480fefe0aSRandall Stewart sctp_clog.x.cwnd.net = net; 36580fefe0aSRandall Stewart sctp_clog.x.cwnd.cwnd_new_value = error; 36680fefe0aSRandall Stewart sctp_clog.x.cwnd.inflight = net->flight_size; 36780fefe0aSRandall Stewart sctp_clog.x.cwnd.cwnd_augment = burst; 368f8829a4aSRandall Stewart if (stcb->asoc.send_queue_cnt > 255) 36980fefe0aSRandall Stewart sctp_clog.x.cwnd.cnt_in_send = 255; 370f8829a4aSRandall Stewart else 37180fefe0aSRandall Stewart sctp_clog.x.cwnd.cnt_in_send = stcb->asoc.send_queue_cnt; 372f8829a4aSRandall Stewart if (stcb->asoc.stream_queue_cnt > 255) 37380fefe0aSRandall Stewart sctp_clog.x.cwnd.cnt_in_str = 255; 374f8829a4aSRandall Stewart else 37580fefe0aSRandall Stewart sctp_clog.x.cwnd.cnt_in_str = stcb->asoc.stream_queue_cnt; 376c4739e2fSRandall Stewart SCTP_CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x", 37780fefe0aSRandall Stewart SCTP_LOG_EVENT_MAXBURST, 37880fefe0aSRandall Stewart from, 37980fefe0aSRandall Stewart sctp_clog.x.misc.log1, 38080fefe0aSRandall Stewart sctp_clog.x.misc.log2, 38180fefe0aSRandall Stewart sctp_clog.x.misc.log3, 38280fefe0aSRandall Stewart sctp_clog.x.misc.log4); 38380fefe0aSRandall Stewart 384f8829a4aSRandall Stewart } 385f8829a4aSRandall Stewart 386f8829a4aSRandall Stewart void 387f8829a4aSRandall Stewart sctp_log_rwnd(uint8_t from, uint32_t peers_rwnd, uint32_t snd_size, uint32_t overhead) 388f8829a4aSRandall Stewart { 38980fefe0aSRandall Stewart struct sctp_cwnd_log sctp_clog; 390f8829a4aSRandall Stewart 39180fefe0aSRandall Stewart sctp_clog.x.rwnd.rwnd = peers_rwnd; 39280fefe0aSRandall Stewart sctp_clog.x.rwnd.send_size = snd_size; 39380fefe0aSRandall Stewart sctp_clog.x.rwnd.overhead = overhead; 39480fefe0aSRandall Stewart sctp_clog.x.rwnd.new_rwnd = 0; 395c4739e2fSRandall Stewart SCTP_CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x", 39680fefe0aSRandall Stewart SCTP_LOG_EVENT_RWND, 39780fefe0aSRandall Stewart from, 39880fefe0aSRandall Stewart sctp_clog.x.misc.log1, 39980fefe0aSRandall Stewart sctp_clog.x.misc.log2, 40080fefe0aSRandall Stewart sctp_clog.x.misc.log3, 40180fefe0aSRandall Stewart sctp_clog.x.misc.log4); 402f8829a4aSRandall Stewart } 403f8829a4aSRandall Stewart 404f8829a4aSRandall Stewart void 405f8829a4aSRandall Stewart sctp_log_rwnd_set(uint8_t from, uint32_t peers_rwnd, uint32_t flight_size, uint32_t overhead, uint32_t a_rwndval) 406f8829a4aSRandall Stewart { 40780fefe0aSRandall Stewart struct sctp_cwnd_log sctp_clog; 408f8829a4aSRandall Stewart 40980fefe0aSRandall Stewart sctp_clog.x.rwnd.rwnd = peers_rwnd; 41080fefe0aSRandall Stewart sctp_clog.x.rwnd.send_size = flight_size; 41180fefe0aSRandall Stewart sctp_clog.x.rwnd.overhead = overhead; 41280fefe0aSRandall Stewart sctp_clog.x.rwnd.new_rwnd = a_rwndval; 413c4739e2fSRandall Stewart SCTP_CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x", 41480fefe0aSRandall Stewart SCTP_LOG_EVENT_RWND, 41580fefe0aSRandall Stewart from, 41680fefe0aSRandall Stewart sctp_clog.x.misc.log1, 41780fefe0aSRandall Stewart sctp_clog.x.misc.log2, 41880fefe0aSRandall Stewart sctp_clog.x.misc.log3, 41980fefe0aSRandall Stewart sctp_clog.x.misc.log4); 420f8829a4aSRandall Stewart } 421f8829a4aSRandall Stewart 422f8829a4aSRandall Stewart void 423f8829a4aSRandall Stewart sctp_log_mbcnt(uint8_t from, uint32_t total_oq, uint32_t book, uint32_t total_mbcnt_q, uint32_t mbcnt) 424f8829a4aSRandall Stewart { 42580fefe0aSRandall Stewart struct sctp_cwnd_log sctp_clog; 426f8829a4aSRandall Stewart 42780fefe0aSRandall Stewart sctp_clog.x.mbcnt.total_queue_size = total_oq; 42880fefe0aSRandall Stewart sctp_clog.x.mbcnt.size_change = book; 42980fefe0aSRandall Stewart sctp_clog.x.mbcnt.total_queue_mb_size = total_mbcnt_q; 43080fefe0aSRandall Stewart sctp_clog.x.mbcnt.mbcnt_change = mbcnt; 431c4739e2fSRandall Stewart SCTP_CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x", 43280fefe0aSRandall Stewart SCTP_LOG_EVENT_MBCNT, 43380fefe0aSRandall Stewart from, 43480fefe0aSRandall Stewart sctp_clog.x.misc.log1, 43580fefe0aSRandall Stewart sctp_clog.x.misc.log2, 43680fefe0aSRandall Stewart sctp_clog.x.misc.log3, 43780fefe0aSRandall Stewart sctp_clog.x.misc.log4); 43880fefe0aSRandall Stewart 439f8829a4aSRandall Stewart } 440f8829a4aSRandall Stewart 441f8829a4aSRandall Stewart void 442f8829a4aSRandall Stewart sctp_misc_ints(uint8_t from, uint32_t a, uint32_t b, uint32_t c, uint32_t d) 443f8829a4aSRandall Stewart { 444c4739e2fSRandall Stewart SCTP_CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x", 44580fefe0aSRandall Stewart SCTP_LOG_MISC_EVENT, 44680fefe0aSRandall Stewart from, 44780fefe0aSRandall Stewart a, b, c, d); 448f8829a4aSRandall Stewart } 449f8829a4aSRandall Stewart 450f8829a4aSRandall Stewart void 451f8829a4aSRandall Stewart sctp_wakeup_log(struct sctp_tcb *stcb, uint32_t cumtsn, uint32_t wake_cnt, int from) 452f8829a4aSRandall Stewart { 45380fefe0aSRandall Stewart struct sctp_cwnd_log sctp_clog; 454f8829a4aSRandall Stewart 45580fefe0aSRandall Stewart sctp_clog.x.wake.stcb = (void *)stcb; 45680fefe0aSRandall Stewart sctp_clog.x.wake.wake_cnt = wake_cnt; 45780fefe0aSRandall Stewart sctp_clog.x.wake.flight = stcb->asoc.total_flight_count; 45880fefe0aSRandall Stewart sctp_clog.x.wake.send_q = stcb->asoc.send_queue_cnt; 45980fefe0aSRandall Stewart sctp_clog.x.wake.sent_q = stcb->asoc.sent_queue_cnt; 460f8829a4aSRandall Stewart 461f8829a4aSRandall Stewart if (stcb->asoc.stream_queue_cnt < 0xff) 46280fefe0aSRandall Stewart sctp_clog.x.wake.stream_qcnt = (uint8_t) stcb->asoc.stream_queue_cnt; 463f8829a4aSRandall Stewart else 46480fefe0aSRandall Stewart sctp_clog.x.wake.stream_qcnt = 0xff; 465f8829a4aSRandall Stewart 466f8829a4aSRandall Stewart if (stcb->asoc.chunks_on_out_queue < 0xff) 46780fefe0aSRandall Stewart sctp_clog.x.wake.chunks_on_oque = (uint8_t) stcb->asoc.chunks_on_out_queue; 468f8829a4aSRandall Stewart else 46980fefe0aSRandall Stewart sctp_clog.x.wake.chunks_on_oque = 0xff; 470f8829a4aSRandall Stewart 47180fefe0aSRandall Stewart sctp_clog.x.wake.sctpflags = 0; 472f8829a4aSRandall Stewart /* set in the defered mode stuff */ 473f8829a4aSRandall Stewart if (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_DONT_WAKE) 47480fefe0aSRandall Stewart sctp_clog.x.wake.sctpflags |= 1; 475f8829a4aSRandall Stewart if (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_WAKEOUTPUT) 47680fefe0aSRandall Stewart sctp_clog.x.wake.sctpflags |= 2; 477f8829a4aSRandall Stewart if (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_WAKEINPUT) 47880fefe0aSRandall Stewart sctp_clog.x.wake.sctpflags |= 4; 479f8829a4aSRandall Stewart /* what about the sb */ 480f8829a4aSRandall Stewart if (stcb->sctp_socket) { 481f8829a4aSRandall Stewart struct socket *so = stcb->sctp_socket; 482f8829a4aSRandall Stewart 48380fefe0aSRandall Stewart sctp_clog.x.wake.sbflags = (uint8_t) ((so->so_snd.sb_flags & 0x00ff)); 484f8829a4aSRandall Stewart } else { 48580fefe0aSRandall Stewart sctp_clog.x.wake.sbflags = 0xff; 486f8829a4aSRandall Stewart } 487c4739e2fSRandall Stewart SCTP_CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x", 48880fefe0aSRandall Stewart SCTP_LOG_EVENT_WAKE, 48980fefe0aSRandall Stewart from, 49080fefe0aSRandall Stewart sctp_clog.x.misc.log1, 49180fefe0aSRandall Stewart sctp_clog.x.misc.log2, 49280fefe0aSRandall Stewart sctp_clog.x.misc.log3, 49380fefe0aSRandall Stewart sctp_clog.x.misc.log4); 49480fefe0aSRandall Stewart 495f8829a4aSRandall Stewart } 496f8829a4aSRandall Stewart 497f8829a4aSRandall Stewart void 498f8829a4aSRandall Stewart sctp_log_block(uint8_t from, struct socket *so, struct sctp_association *asoc, int sendlen) 499f8829a4aSRandall Stewart { 50080fefe0aSRandall Stewart struct sctp_cwnd_log sctp_clog; 501f8829a4aSRandall Stewart 50280fefe0aSRandall Stewart sctp_clog.x.blk.onsb = asoc->total_output_queue_size; 50380fefe0aSRandall Stewart sctp_clog.x.blk.send_sent_qcnt = (uint16_t) (asoc->send_queue_cnt + asoc->sent_queue_cnt); 50480fefe0aSRandall Stewart sctp_clog.x.blk.peer_rwnd = asoc->peers_rwnd; 50580fefe0aSRandall Stewart sctp_clog.x.blk.stream_qcnt = (uint16_t) asoc->stream_queue_cnt; 50680fefe0aSRandall Stewart sctp_clog.x.blk.chunks_on_oque = (uint16_t) asoc->chunks_on_out_queue; 50780fefe0aSRandall Stewart sctp_clog.x.blk.flight_size = (uint16_t) (asoc->total_flight / 1024); 50880fefe0aSRandall Stewart sctp_clog.x.blk.sndlen = sendlen; 509c4739e2fSRandall Stewart SCTP_CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x", 51080fefe0aSRandall Stewart SCTP_LOG_EVENT_BLOCK, 51180fefe0aSRandall Stewart from, 51280fefe0aSRandall Stewart sctp_clog.x.misc.log1, 51380fefe0aSRandall Stewart sctp_clog.x.misc.log2, 51480fefe0aSRandall Stewart sctp_clog.x.misc.log3, 51580fefe0aSRandall Stewart sctp_clog.x.misc.log4); 51680fefe0aSRandall Stewart 517f8829a4aSRandall Stewart } 518f8829a4aSRandall Stewart 519f8829a4aSRandall Stewart int 52042551e99SRandall Stewart sctp_fill_stat_log(void *optval, size_t *optsize) 521f8829a4aSRandall Stewart { 52280fefe0aSRandall Stewart /* May need to fix this if ktrdump does not work */ 523f8829a4aSRandall Stewart return (0); 524f8829a4aSRandall Stewart } 525f8829a4aSRandall Stewart 526f8829a4aSRandall Stewart #ifdef SCTP_AUDITING_ENABLED 527f8829a4aSRandall Stewart uint8_t sctp_audit_data[SCTP_AUDIT_SIZE][2]; 528f8829a4aSRandall Stewart static int sctp_audit_indx = 0; 529f8829a4aSRandall Stewart 530f8829a4aSRandall Stewart static 531f8829a4aSRandall Stewart void 532f8829a4aSRandall Stewart sctp_print_audit_report(void) 533f8829a4aSRandall Stewart { 534f8829a4aSRandall Stewart int i; 535f8829a4aSRandall Stewart int cnt; 536f8829a4aSRandall Stewart 537f8829a4aSRandall Stewart cnt = 0; 538f8829a4aSRandall Stewart for (i = sctp_audit_indx; i < SCTP_AUDIT_SIZE; i++) { 539f8829a4aSRandall Stewart if ((sctp_audit_data[i][0] == 0xe0) && 540f8829a4aSRandall Stewart (sctp_audit_data[i][1] == 0x01)) { 541f8829a4aSRandall Stewart cnt = 0; 542ad81507eSRandall Stewart SCTP_PRINTF("\n"); 543f8829a4aSRandall Stewart } else if (sctp_audit_data[i][0] == 0xf0) { 544f8829a4aSRandall Stewart cnt = 0; 545ad81507eSRandall Stewart SCTP_PRINTF("\n"); 546f8829a4aSRandall Stewart } else if ((sctp_audit_data[i][0] == 0xc0) && 547f8829a4aSRandall Stewart (sctp_audit_data[i][1] == 0x01)) { 548ad81507eSRandall Stewart SCTP_PRINTF("\n"); 549f8829a4aSRandall Stewart cnt = 0; 550f8829a4aSRandall Stewart } 551ad81507eSRandall Stewart SCTP_PRINTF("%2.2x%2.2x ", (uint32_t) sctp_audit_data[i][0], 552f8829a4aSRandall Stewart (uint32_t) sctp_audit_data[i][1]); 553f8829a4aSRandall Stewart cnt++; 554f8829a4aSRandall Stewart if ((cnt % 14) == 0) 555ad81507eSRandall Stewart SCTP_PRINTF("\n"); 556f8829a4aSRandall Stewart } 557f8829a4aSRandall Stewart for (i = 0; i < sctp_audit_indx; i++) { 558f8829a4aSRandall Stewart if ((sctp_audit_data[i][0] == 0xe0) && 559f8829a4aSRandall Stewart (sctp_audit_data[i][1] == 0x01)) { 560f8829a4aSRandall Stewart cnt = 0; 561ad81507eSRandall Stewart SCTP_PRINTF("\n"); 562f8829a4aSRandall Stewart } else if (sctp_audit_data[i][0] == 0xf0) { 563f8829a4aSRandall Stewart cnt = 0; 564ad81507eSRandall Stewart SCTP_PRINTF("\n"); 565f8829a4aSRandall Stewart } else if ((sctp_audit_data[i][0] == 0xc0) && 566f8829a4aSRandall Stewart (sctp_audit_data[i][1] == 0x01)) { 567ad81507eSRandall Stewart SCTP_PRINTF("\n"); 568f8829a4aSRandall Stewart cnt = 0; 569f8829a4aSRandall Stewart } 570ad81507eSRandall Stewart SCTP_PRINTF("%2.2x%2.2x ", (uint32_t) sctp_audit_data[i][0], 571f8829a4aSRandall Stewart (uint32_t) sctp_audit_data[i][1]); 572f8829a4aSRandall Stewart cnt++; 573f8829a4aSRandall Stewart if ((cnt % 14) == 0) 574ad81507eSRandall Stewart SCTP_PRINTF("\n"); 575f8829a4aSRandall Stewart } 576ad81507eSRandall Stewart SCTP_PRINTF("\n"); 577f8829a4aSRandall Stewart } 578f8829a4aSRandall Stewart 579f8829a4aSRandall Stewart void 580f8829a4aSRandall Stewart sctp_auditing(int from, struct sctp_inpcb *inp, struct sctp_tcb *stcb, 581f8829a4aSRandall Stewart struct sctp_nets *net) 582f8829a4aSRandall Stewart { 583f8829a4aSRandall Stewart int resend_cnt, tot_out, rep, tot_book_cnt; 584f8829a4aSRandall Stewart struct sctp_nets *lnet; 585f8829a4aSRandall Stewart struct sctp_tmit_chunk *chk; 586f8829a4aSRandall Stewart 587f8829a4aSRandall Stewart sctp_audit_data[sctp_audit_indx][0] = 0xAA; 588f8829a4aSRandall Stewart sctp_audit_data[sctp_audit_indx][1] = 0x000000ff & from; 589f8829a4aSRandall Stewart sctp_audit_indx++; 590f8829a4aSRandall Stewart if (sctp_audit_indx >= SCTP_AUDIT_SIZE) { 591f8829a4aSRandall Stewart sctp_audit_indx = 0; 592f8829a4aSRandall Stewart } 593f8829a4aSRandall Stewart if (inp == NULL) { 594f8829a4aSRandall Stewart sctp_audit_data[sctp_audit_indx][0] = 0xAF; 595f8829a4aSRandall Stewart sctp_audit_data[sctp_audit_indx][1] = 0x01; 596f8829a4aSRandall Stewart sctp_audit_indx++; 597f8829a4aSRandall Stewart if (sctp_audit_indx >= SCTP_AUDIT_SIZE) { 598f8829a4aSRandall Stewart sctp_audit_indx = 0; 599f8829a4aSRandall Stewart } 600f8829a4aSRandall Stewart return; 601f8829a4aSRandall Stewart } 602f8829a4aSRandall Stewart if (stcb == NULL) { 603f8829a4aSRandall Stewart sctp_audit_data[sctp_audit_indx][0] = 0xAF; 604f8829a4aSRandall Stewart sctp_audit_data[sctp_audit_indx][1] = 0x02; 605f8829a4aSRandall Stewart sctp_audit_indx++; 606f8829a4aSRandall Stewart if (sctp_audit_indx >= SCTP_AUDIT_SIZE) { 607f8829a4aSRandall Stewart sctp_audit_indx = 0; 608f8829a4aSRandall Stewart } 609f8829a4aSRandall Stewart return; 610f8829a4aSRandall Stewart } 611f8829a4aSRandall Stewart sctp_audit_data[sctp_audit_indx][0] = 0xA1; 612f8829a4aSRandall Stewart sctp_audit_data[sctp_audit_indx][1] = 613f8829a4aSRandall Stewart (0x000000ff & stcb->asoc.sent_queue_retran_cnt); 614f8829a4aSRandall Stewart sctp_audit_indx++; 615f8829a4aSRandall Stewart if (sctp_audit_indx >= SCTP_AUDIT_SIZE) { 616f8829a4aSRandall Stewart sctp_audit_indx = 0; 617f8829a4aSRandall Stewart } 618f8829a4aSRandall Stewart rep = 0; 619f8829a4aSRandall Stewart tot_book_cnt = 0; 620f8829a4aSRandall Stewart resend_cnt = tot_out = 0; 621f8829a4aSRandall Stewart TAILQ_FOREACH(chk, &stcb->asoc.sent_queue, sctp_next) { 622f8829a4aSRandall Stewart if (chk->sent == SCTP_DATAGRAM_RESEND) { 623f8829a4aSRandall Stewart resend_cnt++; 624f8829a4aSRandall Stewart } else if (chk->sent < SCTP_DATAGRAM_RESEND) { 625f8829a4aSRandall Stewart tot_out += chk->book_size; 626f8829a4aSRandall Stewart tot_book_cnt++; 627f8829a4aSRandall Stewart } 628f8829a4aSRandall Stewart } 629f8829a4aSRandall Stewart if (resend_cnt != stcb->asoc.sent_queue_retran_cnt) { 630f8829a4aSRandall Stewart sctp_audit_data[sctp_audit_indx][0] = 0xAF; 631f8829a4aSRandall Stewart sctp_audit_data[sctp_audit_indx][1] = 0xA1; 632f8829a4aSRandall Stewart sctp_audit_indx++; 633f8829a4aSRandall Stewart if (sctp_audit_indx >= SCTP_AUDIT_SIZE) { 634f8829a4aSRandall Stewart sctp_audit_indx = 0; 635f8829a4aSRandall Stewart } 636ad81507eSRandall Stewart SCTP_PRINTF("resend_cnt:%d asoc-tot:%d\n", 637f8829a4aSRandall Stewart resend_cnt, stcb->asoc.sent_queue_retran_cnt); 638f8829a4aSRandall Stewart rep = 1; 639f8829a4aSRandall Stewart stcb->asoc.sent_queue_retran_cnt = resend_cnt; 640f8829a4aSRandall Stewart sctp_audit_data[sctp_audit_indx][0] = 0xA2; 641f8829a4aSRandall Stewart sctp_audit_data[sctp_audit_indx][1] = 642f8829a4aSRandall Stewart (0x000000ff & stcb->asoc.sent_queue_retran_cnt); 643f8829a4aSRandall Stewart sctp_audit_indx++; 644f8829a4aSRandall Stewart if (sctp_audit_indx >= SCTP_AUDIT_SIZE) { 645f8829a4aSRandall Stewart sctp_audit_indx = 0; 646f8829a4aSRandall Stewart } 647f8829a4aSRandall Stewart } 648f8829a4aSRandall Stewart if (tot_out != stcb->asoc.total_flight) { 649f8829a4aSRandall Stewart sctp_audit_data[sctp_audit_indx][0] = 0xAF; 650f8829a4aSRandall Stewart sctp_audit_data[sctp_audit_indx][1] = 0xA2; 651f8829a4aSRandall Stewart sctp_audit_indx++; 652f8829a4aSRandall Stewart if (sctp_audit_indx >= SCTP_AUDIT_SIZE) { 653f8829a4aSRandall Stewart sctp_audit_indx = 0; 654f8829a4aSRandall Stewart } 655f8829a4aSRandall Stewart rep = 1; 656ad81507eSRandall Stewart SCTP_PRINTF("tot_flt:%d asoc_tot:%d\n", tot_out, 657f8829a4aSRandall Stewart (int)stcb->asoc.total_flight); 658f8829a4aSRandall Stewart stcb->asoc.total_flight = tot_out; 659f8829a4aSRandall Stewart } 660f8829a4aSRandall Stewart if (tot_book_cnt != stcb->asoc.total_flight_count) { 661f8829a4aSRandall Stewart sctp_audit_data[sctp_audit_indx][0] = 0xAF; 662f8829a4aSRandall Stewart sctp_audit_data[sctp_audit_indx][1] = 0xA5; 663f8829a4aSRandall Stewart sctp_audit_indx++; 664f8829a4aSRandall Stewart if (sctp_audit_indx >= SCTP_AUDIT_SIZE) { 665f8829a4aSRandall Stewart sctp_audit_indx = 0; 666f8829a4aSRandall Stewart } 667f8829a4aSRandall Stewart rep = 1; 668ad81507eSRandall Stewart SCTP_PRINTF("tot_flt_book:%d\n", tot_book); 669f8829a4aSRandall Stewart 670f8829a4aSRandall Stewart stcb->asoc.total_flight_count = tot_book_cnt; 671f8829a4aSRandall Stewart } 672f8829a4aSRandall Stewart tot_out = 0; 673f8829a4aSRandall Stewart TAILQ_FOREACH(lnet, &stcb->asoc.nets, sctp_next) { 674f8829a4aSRandall Stewart tot_out += lnet->flight_size; 675f8829a4aSRandall Stewart } 676f8829a4aSRandall Stewart if (tot_out != stcb->asoc.total_flight) { 677f8829a4aSRandall Stewart sctp_audit_data[sctp_audit_indx][0] = 0xAF; 678f8829a4aSRandall Stewart sctp_audit_data[sctp_audit_indx][1] = 0xA3; 679f8829a4aSRandall Stewart sctp_audit_indx++; 680f8829a4aSRandall Stewart if (sctp_audit_indx >= SCTP_AUDIT_SIZE) { 681f8829a4aSRandall Stewart sctp_audit_indx = 0; 682f8829a4aSRandall Stewart } 683f8829a4aSRandall Stewart rep = 1; 684ad81507eSRandall Stewart SCTP_PRINTF("real flight:%d net total was %d\n", 685f8829a4aSRandall Stewart stcb->asoc.total_flight, tot_out); 686f8829a4aSRandall Stewart /* now corrective action */ 687f8829a4aSRandall Stewart TAILQ_FOREACH(lnet, &stcb->asoc.nets, sctp_next) { 688f8829a4aSRandall Stewart 689f8829a4aSRandall Stewart tot_out = 0; 690f8829a4aSRandall Stewart TAILQ_FOREACH(chk, &stcb->asoc.sent_queue, sctp_next) { 691f8829a4aSRandall Stewart if ((chk->whoTo == lnet) && 692f8829a4aSRandall Stewart (chk->sent < SCTP_DATAGRAM_RESEND)) { 693f8829a4aSRandall Stewart tot_out += chk->book_size; 694f8829a4aSRandall Stewart } 695f8829a4aSRandall Stewart } 696f8829a4aSRandall Stewart if (lnet->flight_size != tot_out) { 697ad81507eSRandall Stewart SCTP_PRINTF("net:%x flight was %d corrected to %d\n", 698ad81507eSRandall Stewart (uint32_t) lnet, lnet->flight_size, 699ad81507eSRandall Stewart tot_out); 700f8829a4aSRandall Stewart lnet->flight_size = tot_out; 701f8829a4aSRandall Stewart } 702f8829a4aSRandall Stewart } 703f8829a4aSRandall Stewart } 704f8829a4aSRandall Stewart if (rep) { 705f8829a4aSRandall Stewart sctp_print_audit_report(); 706f8829a4aSRandall Stewart } 707f8829a4aSRandall Stewart } 708f8829a4aSRandall Stewart 709f8829a4aSRandall Stewart void 710f8829a4aSRandall Stewart sctp_audit_log(uint8_t ev, uint8_t fd) 711f8829a4aSRandall Stewart { 712f8829a4aSRandall Stewart 713f8829a4aSRandall Stewart sctp_audit_data[sctp_audit_indx][0] = ev; 714f8829a4aSRandall Stewart sctp_audit_data[sctp_audit_indx][1] = fd; 715f8829a4aSRandall Stewart sctp_audit_indx++; 716f8829a4aSRandall Stewart if (sctp_audit_indx >= SCTP_AUDIT_SIZE) { 717f8829a4aSRandall Stewart sctp_audit_indx = 0; 718f8829a4aSRandall Stewart } 719f8829a4aSRandall Stewart } 720f8829a4aSRandall Stewart 721f8829a4aSRandall Stewart #endif 722f8829a4aSRandall Stewart 723f8829a4aSRandall Stewart /* 724f8829a4aSRandall Stewart * a list of sizes based on typical mtu's, used only if next hop size not 725f8829a4aSRandall Stewart * returned. 726f8829a4aSRandall Stewart */ 727f8829a4aSRandall Stewart static int sctp_mtu_sizes[] = { 728f8829a4aSRandall Stewart 68, 729f8829a4aSRandall Stewart 296, 730f8829a4aSRandall Stewart 508, 731f8829a4aSRandall Stewart 512, 732f8829a4aSRandall Stewart 544, 733f8829a4aSRandall Stewart 576, 734f8829a4aSRandall Stewart 1006, 735f8829a4aSRandall Stewart 1492, 736f8829a4aSRandall Stewart 1500, 737f8829a4aSRandall Stewart 1536, 738f8829a4aSRandall Stewart 2002, 739f8829a4aSRandall Stewart 2048, 740f8829a4aSRandall Stewart 4352, 741f8829a4aSRandall Stewart 4464, 742f8829a4aSRandall Stewart 8166, 743f8829a4aSRandall Stewart 17914, 744f8829a4aSRandall Stewart 32000, 745f8829a4aSRandall Stewart 65535 746f8829a4aSRandall Stewart }; 747f8829a4aSRandall Stewart 748f8829a4aSRandall Stewart void 749f8829a4aSRandall Stewart sctp_stop_timers_for_shutdown(struct sctp_tcb *stcb) 750f8829a4aSRandall Stewart { 751f8829a4aSRandall Stewart struct sctp_association *asoc; 752f8829a4aSRandall Stewart struct sctp_nets *net; 753f8829a4aSRandall Stewart 754f8829a4aSRandall Stewart asoc = &stcb->asoc; 755f8829a4aSRandall Stewart 7566e55db54SRandall Stewart (void)SCTP_OS_TIMER_STOP(&asoc->hb_timer.timer); 7576e55db54SRandall Stewart (void)SCTP_OS_TIMER_STOP(&asoc->dack_timer.timer); 7586e55db54SRandall Stewart (void)SCTP_OS_TIMER_STOP(&asoc->strreset_timer.timer); 7596e55db54SRandall Stewart (void)SCTP_OS_TIMER_STOP(&asoc->asconf_timer.timer); 7606e55db54SRandall Stewart (void)SCTP_OS_TIMER_STOP(&asoc->autoclose_timer.timer); 7616e55db54SRandall Stewart (void)SCTP_OS_TIMER_STOP(&asoc->delayed_event_timer.timer); 762f8829a4aSRandall Stewart TAILQ_FOREACH(net, &asoc->nets, sctp_next) { 7636e55db54SRandall Stewart (void)SCTP_OS_TIMER_STOP(&net->fr_timer.timer); 7646e55db54SRandall Stewart (void)SCTP_OS_TIMER_STOP(&net->pmtu_timer.timer); 765f8829a4aSRandall Stewart } 766f8829a4aSRandall Stewart } 767f8829a4aSRandall Stewart 768f8829a4aSRandall Stewart int 769f8829a4aSRandall Stewart find_next_best_mtu(int totsz) 770f8829a4aSRandall Stewart { 771f8829a4aSRandall Stewart int i, perfer; 772f8829a4aSRandall Stewart 773f8829a4aSRandall Stewart /* 774f8829a4aSRandall Stewart * if we are in here we must find the next best fit based on the 775f8829a4aSRandall Stewart * size of the dg that failed to be sent. 776f8829a4aSRandall Stewart */ 777f8829a4aSRandall Stewart perfer = 0; 778f8829a4aSRandall Stewart for (i = 0; i < NUMBER_OF_MTU_SIZES; i++) { 779f8829a4aSRandall Stewart if (totsz < sctp_mtu_sizes[i]) { 780f8829a4aSRandall Stewart perfer = i - 1; 781f8829a4aSRandall Stewart if (perfer < 0) 782f8829a4aSRandall Stewart perfer = 0; 783f8829a4aSRandall Stewart break; 784f8829a4aSRandall Stewart } 785f8829a4aSRandall Stewart } 786f8829a4aSRandall Stewart return (sctp_mtu_sizes[perfer]); 787f8829a4aSRandall Stewart } 788f8829a4aSRandall Stewart 789f8829a4aSRandall Stewart void 790f8829a4aSRandall Stewart sctp_fill_random_store(struct sctp_pcb *m) 791f8829a4aSRandall Stewart { 792f8829a4aSRandall Stewart /* 793f8829a4aSRandall Stewart * Here we use the MD5/SHA-1 to hash with our good randomNumbers and 794f8829a4aSRandall Stewart * our counter. The result becomes our good random numbers and we 795f8829a4aSRandall Stewart * then setup to give these out. Note that we do no locking to 796f8829a4aSRandall Stewart * protect this. This is ok, since if competing folks call this we 79717205eccSRandall Stewart * will get more gobbled gook in the random store which is what we 798f8829a4aSRandall Stewart * want. There is a danger that two guys will use the same random 799f8829a4aSRandall Stewart * numbers, but thats ok too since that is random as well :-> 800f8829a4aSRandall Stewart */ 801f8829a4aSRandall Stewart m->store_at = 0; 802ad81507eSRandall Stewart (void)sctp_hmac(SCTP_HMAC, (uint8_t *) m->random_numbers, 803f8829a4aSRandall Stewart sizeof(m->random_numbers), (uint8_t *) & m->random_counter, 804f8829a4aSRandall Stewart sizeof(m->random_counter), (uint8_t *) m->random_store); 805f8829a4aSRandall Stewart m->random_counter++; 806f8829a4aSRandall Stewart } 807f8829a4aSRandall Stewart 808f8829a4aSRandall Stewart uint32_t 809851b7298SRandall Stewart sctp_select_initial_TSN(struct sctp_pcb *inp) 810f8829a4aSRandall Stewart { 811f8829a4aSRandall Stewart /* 812f8829a4aSRandall Stewart * A true implementation should use random selection process to get 813f8829a4aSRandall Stewart * the initial stream sequence number, using RFC1750 as a good 814f8829a4aSRandall Stewart * guideline 815f8829a4aSRandall Stewart */ 816139bc87fSRandall Stewart uint32_t x, *xp; 817f8829a4aSRandall Stewart uint8_t *p; 818851b7298SRandall Stewart int store_at, new_store; 819f8829a4aSRandall Stewart 820851b7298SRandall Stewart if (inp->initial_sequence_debug != 0) { 821f8829a4aSRandall Stewart uint32_t ret; 822f8829a4aSRandall Stewart 823851b7298SRandall Stewart ret = inp->initial_sequence_debug; 824851b7298SRandall Stewart inp->initial_sequence_debug++; 825f8829a4aSRandall Stewart return (ret); 826f8829a4aSRandall Stewart } 827851b7298SRandall Stewart retry: 828851b7298SRandall Stewart store_at = inp->store_at; 829851b7298SRandall Stewart new_store = store_at + sizeof(uint32_t); 830851b7298SRandall Stewart if (new_store >= (SCTP_SIGNATURE_SIZE - 3)) { 831851b7298SRandall Stewart new_store = 0; 832f8829a4aSRandall Stewart } 833851b7298SRandall Stewart if (!atomic_cmpset_int(&inp->store_at, store_at, new_store)) { 834851b7298SRandall Stewart goto retry; 835851b7298SRandall Stewart } 836851b7298SRandall Stewart if (new_store == 0) { 837851b7298SRandall Stewart /* Refill the random store */ 838851b7298SRandall Stewart sctp_fill_random_store(inp); 839851b7298SRandall Stewart } 840851b7298SRandall Stewart p = &inp->random_store[store_at]; 841139bc87fSRandall Stewart xp = (uint32_t *) p; 842f8829a4aSRandall Stewart x = *xp; 843f8829a4aSRandall Stewart return (x); 844f8829a4aSRandall Stewart } 845f8829a4aSRandall Stewart 846f8829a4aSRandall Stewart uint32_t 847fb8fb8f8SRandall Stewart sctp_select_a_tag(struct sctp_inpcb *inp, int save_in_twait) 848f8829a4aSRandall Stewart { 849f8829a4aSRandall Stewart u_long x, not_done; 850f8829a4aSRandall Stewart struct timeval now; 851f8829a4aSRandall Stewart 8526e55db54SRandall Stewart (void)SCTP_GETTIME_TIMEVAL(&now); 853f8829a4aSRandall Stewart not_done = 1; 854f8829a4aSRandall Stewart while (not_done) { 855851b7298SRandall Stewart x = sctp_select_initial_TSN(&inp->sctp_ep); 856f8829a4aSRandall Stewart if (x == 0) { 857f8829a4aSRandall Stewart /* we never use 0 */ 858f8829a4aSRandall Stewart continue; 859f8829a4aSRandall Stewart } 860fb8fb8f8SRandall Stewart if (sctp_is_vtag_good(inp, x, &now, save_in_twait)) { 861f8829a4aSRandall Stewart not_done = 0; 862f8829a4aSRandall Stewart } 863f8829a4aSRandall Stewart } 864f8829a4aSRandall Stewart return (x); 865f8829a4aSRandall Stewart } 866f8829a4aSRandall Stewart 867f8829a4aSRandall Stewart int 8680696e120SRandall Stewart sctp_init_asoc(struct sctp_inpcb *m, struct sctp_tcb *stcb, 86942551e99SRandall Stewart int for_a_init, uint32_t override_tag, uint32_t vrf_id) 870f8829a4aSRandall Stewart { 8710696e120SRandall Stewart struct sctp_association *asoc; 8720696e120SRandall Stewart 873f8829a4aSRandall Stewart /* 874f8829a4aSRandall Stewart * Anything set to zero is taken care of by the allocation routine's 875f8829a4aSRandall Stewart * bzero 876f8829a4aSRandall Stewart */ 877f8829a4aSRandall Stewart 878f8829a4aSRandall Stewart /* 879f8829a4aSRandall Stewart * Up front select what scoping to apply on addresses I tell my peer 880f8829a4aSRandall Stewart * Not sure what to do with these right now, we will need to come up 881f8829a4aSRandall Stewart * with a way to set them. We may need to pass them through from the 882f8829a4aSRandall Stewart * caller in the sctp_aloc_assoc() function. 883f8829a4aSRandall Stewart */ 884f8829a4aSRandall Stewart int i; 885f8829a4aSRandall Stewart 8860696e120SRandall Stewart asoc = &stcb->asoc; 887f8829a4aSRandall Stewart /* init all variables to a known value. */ 888c4739e2fSRandall Stewart SCTP_SET_STATE(&stcb->asoc, SCTP_STATE_INUSE); 889f8829a4aSRandall Stewart asoc->max_burst = m->sctp_ep.max_burst; 890f8829a4aSRandall Stewart asoc->heart_beat_delay = TICKS_TO_MSEC(m->sctp_ep.sctp_timeoutticks[SCTP_TIMER_HEARTBEAT]); 891f8829a4aSRandall Stewart asoc->cookie_life = m->sctp_ep.def_cookie_life; 892f8829a4aSRandall Stewart asoc->sctp_cmt_on_off = (uint8_t) sctp_cmt_on_off; 893b54d3a6cSRandall Stewart /* JRS 5/21/07 - Init CMT PF variables */ 894b54d3a6cSRandall Stewart asoc->sctp_cmt_pf = (uint8_t) sctp_cmt_pf; 895d61a0ae0SRandall Stewart asoc->sctp_frag_point = m->sctp_frag_point; 89642551e99SRandall Stewart #ifdef INET 897f8829a4aSRandall Stewart asoc->default_tos = m->ip_inp.inp.inp_ip_tos; 898f8829a4aSRandall Stewart #else 899f8829a4aSRandall Stewart asoc->default_tos = 0; 900f8829a4aSRandall Stewart #endif 901f8829a4aSRandall Stewart 90242551e99SRandall Stewart #ifdef INET6 903f8829a4aSRandall Stewart asoc->default_flowlabel = ((struct in6pcb *)m)->in6p_flowinfo; 904f8829a4aSRandall Stewart #else 905f8829a4aSRandall Stewart asoc->default_flowlabel = 0; 906f8829a4aSRandall Stewart #endif 9079f22f500SRandall Stewart asoc->sb_send_resv = 0; 908f8829a4aSRandall Stewart if (override_tag) { 909f8829a4aSRandall Stewart struct timeval now; 910f8829a4aSRandall Stewart 9116e55db54SRandall Stewart (void)SCTP_GETTIME_TIMEVAL(&now); 912fb8fb8f8SRandall Stewart if (sctp_is_in_timewait(override_tag)) { 913fb8fb8f8SRandall Stewart /* 914fb8fb8f8SRandall Stewart * It must be in the time-wait hash, we put it there 915fb8fb8f8SRandall Stewart * when we aloc one. If not the peer is playing 916fb8fb8f8SRandall Stewart * games. 917fb8fb8f8SRandall Stewart */ 918f8829a4aSRandall Stewart asoc->my_vtag = override_tag; 919f8829a4aSRandall Stewart } else { 920c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTPUTIL, ENOMEM); 921fb8fb8f8SRandall Stewart panic("Huh is_in_timewait fails"); 922f8829a4aSRandall Stewart return (ENOMEM); 923f8829a4aSRandall Stewart } 924f8829a4aSRandall Stewart 925f8829a4aSRandall Stewart } else { 926fb8fb8f8SRandall Stewart asoc->my_vtag = sctp_select_a_tag(m, 1); 927f8829a4aSRandall Stewart } 928de0e935bSRandall Stewart /* Get the nonce tags */ 929fb8fb8f8SRandall Stewart asoc->my_vtag_nonce = sctp_select_a_tag(m, 0); 930fb8fb8f8SRandall Stewart asoc->peer_vtag_nonce = sctp_select_a_tag(m, 0); 93142551e99SRandall Stewart asoc->vrf_id = vrf_id; 932de0e935bSRandall Stewart 933f8829a4aSRandall Stewart if (sctp_is_feature_on(m, SCTP_PCB_FLAGS_DONOT_HEARTBEAT)) 934f8829a4aSRandall Stewart asoc->hb_is_disabled = 1; 935f8829a4aSRandall Stewart else 936f8829a4aSRandall Stewart asoc->hb_is_disabled = 0; 937f8829a4aSRandall Stewart 93818e198d3SRandall Stewart #ifdef SCTP_ASOCLOG_OF_TSNS 93918e198d3SRandall Stewart asoc->tsn_in_at = 0; 94018e198d3SRandall Stewart asoc->tsn_out_at = 0; 94118e198d3SRandall Stewart asoc->tsn_in_wrapped = 0; 94218e198d3SRandall Stewart asoc->tsn_out_wrapped = 0; 94318e198d3SRandall Stewart asoc->cumack_log_at = 0; 944b201f536SRandall Stewart asoc->cumack_log_atsnt = 0; 94518e198d3SRandall Stewart #endif 94618e198d3SRandall Stewart #ifdef SCTP_FS_SPEC_LOG 94718e198d3SRandall Stewart asoc->fs_index = 0; 94818e198d3SRandall Stewart #endif 949f8829a4aSRandall Stewart asoc->refcnt = 0; 950f8829a4aSRandall Stewart asoc->assoc_up_sent = 0; 951f8829a4aSRandall Stewart asoc->assoc_id = asoc->my_vtag; 952f8829a4aSRandall Stewart asoc->asconf_seq_out = asoc->str_reset_seq_out = asoc->init_seq_number = asoc->sending_seq = 953f8829a4aSRandall Stewart sctp_select_initial_TSN(&m->sctp_ep); 954f8829a4aSRandall Stewart /* we are optimisitic here */ 955f8829a4aSRandall Stewart asoc->peer_supports_pktdrop = 1; 956f8829a4aSRandall Stewart 957f8829a4aSRandall Stewart asoc->sent_queue_retran_cnt = 0; 958f8829a4aSRandall Stewart 959f8829a4aSRandall Stewart /* for CMT */ 960f8829a4aSRandall Stewart asoc->last_net_data_came_from = NULL; 961f8829a4aSRandall Stewart 962f8829a4aSRandall Stewart /* This will need to be adjusted */ 963f8829a4aSRandall Stewart asoc->last_cwr_tsn = asoc->init_seq_number - 1; 964f8829a4aSRandall Stewart asoc->last_acked_seq = asoc->init_seq_number - 1; 965f8829a4aSRandall Stewart asoc->advanced_peer_ack_point = asoc->last_acked_seq; 966f8829a4aSRandall Stewart asoc->asconf_seq_in = asoc->last_acked_seq; 967f8829a4aSRandall Stewart 968f8829a4aSRandall Stewart /* here we are different, we hold the next one we expect */ 969f8829a4aSRandall Stewart asoc->str_reset_seq_in = asoc->last_acked_seq + 1; 970f8829a4aSRandall Stewart 971f8829a4aSRandall Stewart asoc->initial_init_rto_max = m->sctp_ep.initial_init_rto_max; 972f8829a4aSRandall Stewart asoc->initial_rto = m->sctp_ep.initial_rto; 973f8829a4aSRandall Stewart 974f8829a4aSRandall Stewart asoc->max_init_times = m->sctp_ep.max_init_times; 975f8829a4aSRandall Stewart asoc->max_send_times = m->sctp_ep.max_send_times; 976f8829a4aSRandall Stewart asoc->def_net_failure = m->sctp_ep.def_net_failure; 977f8829a4aSRandall Stewart asoc->free_chunk_cnt = 0; 978f8829a4aSRandall Stewart 979f8829a4aSRandall Stewart asoc->iam_blocking = 0; 980f8829a4aSRandall Stewart /* ECN Nonce initialization */ 981f8829a4aSRandall Stewart asoc->context = m->sctp_context; 982f8829a4aSRandall Stewart asoc->def_send = m->def_send; 983f8829a4aSRandall Stewart asoc->ecn_nonce_allowed = 0; 984f8829a4aSRandall Stewart asoc->receiver_nonce_sum = 1; 985f8829a4aSRandall Stewart asoc->nonce_sum_expect_base = 1; 986f8829a4aSRandall Stewart asoc->nonce_sum_check = 1; 987f8829a4aSRandall Stewart asoc->nonce_resync_tsn = 0; 988f8829a4aSRandall Stewart asoc->nonce_wait_for_ecne = 0; 989f8829a4aSRandall Stewart asoc->nonce_wait_tsn = 0; 990f8829a4aSRandall Stewart asoc->delayed_ack = TICKS_TO_MSEC(m->sctp_ep.sctp_timeoutticks[SCTP_TIMER_RECV]); 99142551e99SRandall Stewart asoc->sack_freq = m->sctp_ep.sctp_sack_freq; 992f8829a4aSRandall Stewart asoc->pr_sctp_cnt = 0; 993f8829a4aSRandall Stewart asoc->total_output_queue_size = 0; 994f8829a4aSRandall Stewart 995f8829a4aSRandall Stewart if (m->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) { 996f8829a4aSRandall Stewart struct in6pcb *inp6; 997f8829a4aSRandall Stewart 998f8829a4aSRandall Stewart /* Its a V6 socket */ 999f8829a4aSRandall Stewart inp6 = (struct in6pcb *)m; 1000f8829a4aSRandall Stewart asoc->ipv6_addr_legal = 1; 1001f8829a4aSRandall Stewart /* Now look at the binding flag to see if V4 will be legal */ 100244b7479bSRandall Stewart if (SCTP_IPV6_V6ONLY(inp6) == 0) { 1003f8829a4aSRandall Stewart asoc->ipv4_addr_legal = 1; 1004f8829a4aSRandall Stewart } else { 1005f8829a4aSRandall Stewart /* V4 addresses are NOT legal on the association */ 1006f8829a4aSRandall Stewart asoc->ipv4_addr_legal = 0; 1007f8829a4aSRandall Stewart } 1008f8829a4aSRandall Stewart } else { 1009f8829a4aSRandall Stewart /* Its a V4 socket, no - V6 */ 1010f8829a4aSRandall Stewart asoc->ipv4_addr_legal = 1; 1011f8829a4aSRandall Stewart asoc->ipv6_addr_legal = 0; 1012f8829a4aSRandall Stewart } 1013f8829a4aSRandall Stewart 101462c1ff9cSRandall Stewart asoc->my_rwnd = max(SCTP_SB_LIMIT_RCV(m->sctp_socket), SCTP_MINIMAL_RWND); 101562c1ff9cSRandall Stewart asoc->peers_rwnd = SCTP_SB_LIMIT_RCV(m->sctp_socket); 1016f8829a4aSRandall Stewart 1017f8829a4aSRandall Stewart asoc->smallest_mtu = m->sctp_frag_point; 101817205eccSRandall Stewart #ifdef SCTP_PRINT_FOR_B_AND_M 1019ad81507eSRandall Stewart SCTP_PRINTF("smallest_mtu init'd with asoc to :%d\n", 102017205eccSRandall Stewart asoc->smallest_mtu); 102117205eccSRandall Stewart #endif 1022f8829a4aSRandall Stewart asoc->minrto = m->sctp_ep.sctp_minrto; 1023f8829a4aSRandall Stewart asoc->maxrto = m->sctp_ep.sctp_maxrto; 1024f8829a4aSRandall Stewart 1025f8829a4aSRandall Stewart asoc->locked_on_sending = NULL; 1026f8829a4aSRandall Stewart asoc->stream_locked_on = 0; 1027f8829a4aSRandall Stewart asoc->ecn_echo_cnt_onq = 0; 1028f8829a4aSRandall Stewart asoc->stream_locked = 0; 1029f8829a4aSRandall Stewart 103042551e99SRandall Stewart asoc->send_sack = 1; 103142551e99SRandall Stewart 103242551e99SRandall Stewart LIST_INIT(&asoc->sctp_restricted_addrs); 103342551e99SRandall Stewart 1034f8829a4aSRandall Stewart TAILQ_INIT(&asoc->nets); 1035f8829a4aSRandall Stewart TAILQ_INIT(&asoc->pending_reply_queue); 10362afb3e84SRandall Stewart TAILQ_INIT(&asoc->asconf_ack_sent); 1037f8829a4aSRandall Stewart /* Setup to fill the hb random cache at first HB */ 1038f8829a4aSRandall Stewart asoc->hb_random_idx = 4; 1039f8829a4aSRandall Stewart 1040f8829a4aSRandall Stewart asoc->sctp_autoclose_ticks = m->sctp_ep.auto_close_time; 1041f8829a4aSRandall Stewart 1042f8829a4aSRandall Stewart /* 1043b54d3a6cSRandall Stewart * JRS - Pick the default congestion control module based on the 1044b54d3a6cSRandall Stewart * sysctl. 1045b54d3a6cSRandall Stewart */ 1046b54d3a6cSRandall Stewart switch (m->sctp_ep.sctp_default_cc_module) { 1047b54d3a6cSRandall Stewart /* JRS - Standard TCP congestion control */ 1048b54d3a6cSRandall Stewart case SCTP_CC_RFC2581: 1049b54d3a6cSRandall Stewart { 1050b54d3a6cSRandall Stewart stcb->asoc.congestion_control_module = SCTP_CC_RFC2581; 1051b54d3a6cSRandall Stewart stcb->asoc.cc_functions.sctp_set_initial_cc_param = &sctp_set_initial_cc_param; 1052b54d3a6cSRandall Stewart stcb->asoc.cc_functions.sctp_cwnd_update_after_sack = &sctp_cwnd_update_after_sack; 1053b54d3a6cSRandall Stewart stcb->asoc.cc_functions.sctp_cwnd_update_after_fr = &sctp_cwnd_update_after_fr; 1054b54d3a6cSRandall Stewart stcb->asoc.cc_functions.sctp_cwnd_update_after_timeout = &sctp_cwnd_update_after_timeout; 1055b54d3a6cSRandall Stewart stcb->asoc.cc_functions.sctp_cwnd_update_after_ecn_echo = &sctp_cwnd_update_after_ecn_echo; 1056b54d3a6cSRandall Stewart stcb->asoc.cc_functions.sctp_cwnd_update_after_packet_dropped = &sctp_cwnd_update_after_packet_dropped; 1057b54d3a6cSRandall Stewart stcb->asoc.cc_functions.sctp_cwnd_update_after_output = &sctp_cwnd_update_after_output; 1058b54d3a6cSRandall Stewart stcb->asoc.cc_functions.sctp_cwnd_update_after_fr_timer = &sctp_cwnd_update_after_fr_timer; 1059b54d3a6cSRandall Stewart break; 1060b54d3a6cSRandall Stewart } 1061b54d3a6cSRandall Stewart /* JRS - High Speed TCP congestion control (Floyd) */ 1062b54d3a6cSRandall Stewart case SCTP_CC_HSTCP: 1063b54d3a6cSRandall Stewart { 1064b54d3a6cSRandall Stewart stcb->asoc.congestion_control_module = SCTP_CC_HSTCP; 1065b54d3a6cSRandall Stewart stcb->asoc.cc_functions.sctp_set_initial_cc_param = &sctp_set_initial_cc_param; 1066b54d3a6cSRandall Stewart stcb->asoc.cc_functions.sctp_cwnd_update_after_sack = &sctp_hs_cwnd_update_after_sack; 1067b54d3a6cSRandall Stewart stcb->asoc.cc_functions.sctp_cwnd_update_after_fr = &sctp_hs_cwnd_update_after_fr; 1068b54d3a6cSRandall Stewart stcb->asoc.cc_functions.sctp_cwnd_update_after_timeout = &sctp_cwnd_update_after_timeout; 1069b54d3a6cSRandall Stewart stcb->asoc.cc_functions.sctp_cwnd_update_after_ecn_echo = &sctp_cwnd_update_after_ecn_echo; 1070b54d3a6cSRandall Stewart stcb->asoc.cc_functions.sctp_cwnd_update_after_packet_dropped = &sctp_cwnd_update_after_packet_dropped; 1071b54d3a6cSRandall Stewart stcb->asoc.cc_functions.sctp_cwnd_update_after_output = &sctp_cwnd_update_after_output; 1072b54d3a6cSRandall Stewart stcb->asoc.cc_functions.sctp_cwnd_update_after_fr_timer = &sctp_cwnd_update_after_fr_timer; 1073b54d3a6cSRandall Stewart break; 1074b54d3a6cSRandall Stewart } 1075b54d3a6cSRandall Stewart /* JRS - HTCP congestion control */ 1076b54d3a6cSRandall Stewart case SCTP_CC_HTCP: 1077b54d3a6cSRandall Stewart { 1078b54d3a6cSRandall Stewart stcb->asoc.congestion_control_module = SCTP_CC_HTCP; 1079b54d3a6cSRandall Stewart stcb->asoc.cc_functions.sctp_set_initial_cc_param = &sctp_htcp_set_initial_cc_param; 1080b54d3a6cSRandall Stewart stcb->asoc.cc_functions.sctp_cwnd_update_after_sack = &sctp_htcp_cwnd_update_after_sack; 1081b54d3a6cSRandall Stewart stcb->asoc.cc_functions.sctp_cwnd_update_after_fr = &sctp_htcp_cwnd_update_after_fr; 1082b54d3a6cSRandall Stewart stcb->asoc.cc_functions.sctp_cwnd_update_after_timeout = &sctp_htcp_cwnd_update_after_timeout; 1083b54d3a6cSRandall Stewart stcb->asoc.cc_functions.sctp_cwnd_update_after_ecn_echo = &sctp_htcp_cwnd_update_after_ecn_echo; 1084b54d3a6cSRandall Stewart stcb->asoc.cc_functions.sctp_cwnd_update_after_packet_dropped = &sctp_cwnd_update_after_packet_dropped; 1085b54d3a6cSRandall Stewart stcb->asoc.cc_functions.sctp_cwnd_update_after_output = &sctp_cwnd_update_after_output; 1086b54d3a6cSRandall Stewart stcb->asoc.cc_functions.sctp_cwnd_update_after_fr_timer = &sctp_htcp_cwnd_update_after_fr_timer; 1087b54d3a6cSRandall Stewart break; 1088b54d3a6cSRandall Stewart } 1089b54d3a6cSRandall Stewart /* JRS - By default, use RFC2581 */ 1090b54d3a6cSRandall Stewart default: 1091b54d3a6cSRandall Stewart { 1092b54d3a6cSRandall Stewart stcb->asoc.congestion_control_module = SCTP_CC_RFC2581; 1093b54d3a6cSRandall Stewart stcb->asoc.cc_functions.sctp_set_initial_cc_param = &sctp_set_initial_cc_param; 1094b54d3a6cSRandall Stewart stcb->asoc.cc_functions.sctp_cwnd_update_after_sack = &sctp_cwnd_update_after_sack; 1095b54d3a6cSRandall Stewart stcb->asoc.cc_functions.sctp_cwnd_update_after_fr = &sctp_cwnd_update_after_fr; 1096b54d3a6cSRandall Stewart stcb->asoc.cc_functions.sctp_cwnd_update_after_timeout = &sctp_cwnd_update_after_timeout; 1097b54d3a6cSRandall Stewart stcb->asoc.cc_functions.sctp_cwnd_update_after_ecn_echo = &sctp_cwnd_update_after_ecn_echo; 1098b54d3a6cSRandall Stewart stcb->asoc.cc_functions.sctp_cwnd_update_after_packet_dropped = &sctp_cwnd_update_after_packet_dropped; 1099b54d3a6cSRandall Stewart stcb->asoc.cc_functions.sctp_cwnd_update_after_output = &sctp_cwnd_update_after_output; 1100b54d3a6cSRandall Stewart stcb->asoc.cc_functions.sctp_cwnd_update_after_fr_timer = &sctp_cwnd_update_after_fr_timer; 1101b54d3a6cSRandall Stewart break; 1102b54d3a6cSRandall Stewart } 1103b54d3a6cSRandall Stewart } 1104b54d3a6cSRandall Stewart 1105b54d3a6cSRandall Stewart /* 1106f8829a4aSRandall Stewart * Now the stream parameters, here we allocate space for all streams 1107f8829a4aSRandall Stewart * that we request by default. 1108f8829a4aSRandall Stewart */ 1109f8829a4aSRandall Stewart asoc->streamoutcnt = asoc->pre_open_streams = 1110f8829a4aSRandall Stewart m->sctp_ep.pre_open_stream_count; 1111f8829a4aSRandall Stewart SCTP_MALLOC(asoc->strmout, struct sctp_stream_out *, 1112f8829a4aSRandall Stewart asoc->streamoutcnt * sizeof(struct sctp_stream_out), 1113207304d4SRandall Stewart SCTP_M_STRMO); 1114f8829a4aSRandall Stewart if (asoc->strmout == NULL) { 1115f8829a4aSRandall Stewart /* big trouble no memory */ 1116c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTPUTIL, ENOMEM); 1117f8829a4aSRandall Stewart return (ENOMEM); 1118f8829a4aSRandall Stewart } 1119f8829a4aSRandall Stewart for (i = 0; i < asoc->streamoutcnt; i++) { 1120f8829a4aSRandall Stewart /* 1121f8829a4aSRandall Stewart * inbound side must be set to 0xffff, also NOTE when we get 1122f8829a4aSRandall Stewart * the INIT-ACK back (for INIT sender) we MUST reduce the 1123f8829a4aSRandall Stewart * count (streamoutcnt) but first check if we sent to any of 1124f8829a4aSRandall Stewart * the upper streams that were dropped (if some were). Those 1125f8829a4aSRandall Stewart * that were dropped must be notified to the upper layer as 1126f8829a4aSRandall Stewart * failed to send. 1127f8829a4aSRandall Stewart */ 1128f8829a4aSRandall Stewart asoc->strmout[i].next_sequence_sent = 0x0; 1129f8829a4aSRandall Stewart TAILQ_INIT(&asoc->strmout[i].outqueue); 1130f8829a4aSRandall Stewart asoc->strmout[i].stream_no = i; 1131f8829a4aSRandall Stewart asoc->strmout[i].last_msg_incomplete = 0; 1132f8829a4aSRandall Stewart asoc->strmout[i].next_spoke.tqe_next = 0; 1133f8829a4aSRandall Stewart asoc->strmout[i].next_spoke.tqe_prev = 0; 1134f8829a4aSRandall Stewart } 1135f8829a4aSRandall Stewart /* Now the mapping array */ 1136f8829a4aSRandall Stewart asoc->mapping_array_size = SCTP_INITIAL_MAPPING_ARRAY; 1137f8829a4aSRandall Stewart SCTP_MALLOC(asoc->mapping_array, uint8_t *, asoc->mapping_array_size, 1138207304d4SRandall Stewart SCTP_M_MAP); 1139f8829a4aSRandall Stewart if (asoc->mapping_array == NULL) { 1140207304d4SRandall Stewart SCTP_FREE(asoc->strmout, SCTP_M_STRMO); 1141c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTPUTIL, ENOMEM); 1142f8829a4aSRandall Stewart return (ENOMEM); 1143f8829a4aSRandall Stewart } 1144f8829a4aSRandall Stewart memset(asoc->mapping_array, 0, asoc->mapping_array_size); 1145f8829a4aSRandall Stewart /* Now the init of the other outqueues */ 1146f8829a4aSRandall Stewart TAILQ_INIT(&asoc->free_chunks); 1147f8829a4aSRandall Stewart TAILQ_INIT(&asoc->out_wheel); 1148f8829a4aSRandall Stewart TAILQ_INIT(&asoc->control_send_queue); 1149f8829a4aSRandall Stewart TAILQ_INIT(&asoc->send_queue); 1150f8829a4aSRandall Stewart TAILQ_INIT(&asoc->sent_queue); 1151f8829a4aSRandall Stewart TAILQ_INIT(&asoc->reasmqueue); 1152f8829a4aSRandall Stewart TAILQ_INIT(&asoc->resetHead); 1153f8829a4aSRandall Stewart asoc->max_inbound_streams = m->sctp_ep.max_open_streams_intome; 1154f8829a4aSRandall Stewart TAILQ_INIT(&asoc->asconf_queue); 1155f8829a4aSRandall Stewart /* authentication fields */ 1156f8829a4aSRandall Stewart asoc->authinfo.random = NULL; 1157f8829a4aSRandall Stewart asoc->authinfo.assoc_key = NULL; 1158f8829a4aSRandall Stewart asoc->authinfo.assoc_keyid = 0; 1159f8829a4aSRandall Stewart asoc->authinfo.recv_key = NULL; 1160f8829a4aSRandall Stewart asoc->authinfo.recv_keyid = 0; 1161f8829a4aSRandall Stewart LIST_INIT(&asoc->shared_keys); 1162f42a358aSRandall Stewart asoc->marked_retrans = 0; 1163f42a358aSRandall Stewart asoc->timoinit = 0; 1164f42a358aSRandall Stewart asoc->timodata = 0; 1165f42a358aSRandall Stewart asoc->timosack = 0; 1166f42a358aSRandall Stewart asoc->timoshutdown = 0; 1167f42a358aSRandall Stewart asoc->timoheartbeat = 0; 1168f42a358aSRandall Stewart asoc->timocookie = 0; 1169f42a358aSRandall Stewart asoc->timoshutdownack = 0; 11706e55db54SRandall Stewart (void)SCTP_GETTIME_TIMEVAL(&asoc->start_time); 11716e55db54SRandall Stewart asoc->discontinuity_time = asoc->start_time; 1172eacc51c5SRandall Stewart /* 1173eacc51c5SRandall Stewart * sa_ignore MEMLEAK {memory is put in the assoc mapping array and 1174eacc51c5SRandall Stewart * freed later whe the association is freed. 1175eacc51c5SRandall Stewart */ 1176f8829a4aSRandall Stewart return (0); 1177f8829a4aSRandall Stewart } 1178f8829a4aSRandall Stewart 1179f8829a4aSRandall Stewart int 11800696e120SRandall Stewart sctp_expand_mapping_array(struct sctp_association *asoc, uint32_t needed) 1181f8829a4aSRandall Stewart { 1182f8829a4aSRandall Stewart /* mapping array needs to grow */ 1183f8829a4aSRandall Stewart uint8_t *new_array; 11840696e120SRandall Stewart uint32_t new_size; 1185f8829a4aSRandall Stewart 11860696e120SRandall Stewart new_size = asoc->mapping_array_size + ((needed + 7) / 8 + SCTP_MAPPING_ARRAY_INCR); 1187207304d4SRandall Stewart SCTP_MALLOC(new_array, uint8_t *, new_size, SCTP_M_MAP); 1188f8829a4aSRandall Stewart if (new_array == NULL) { 1189f8829a4aSRandall Stewart /* can't get more, forget it */ 1190ad81507eSRandall Stewart SCTP_PRINTF("No memory for expansion of SCTP mapping array %d\n", 1191f8829a4aSRandall Stewart new_size); 1192f8829a4aSRandall Stewart return (-1); 1193f8829a4aSRandall Stewart } 1194f8829a4aSRandall Stewart memset(new_array, 0, new_size); 1195f8829a4aSRandall Stewart memcpy(new_array, asoc->mapping_array, asoc->mapping_array_size); 1196207304d4SRandall Stewart SCTP_FREE(asoc->mapping_array, SCTP_M_MAP); 1197f8829a4aSRandall Stewart asoc->mapping_array = new_array; 1198f8829a4aSRandall Stewart asoc->mapping_array_size = new_size; 1199f8829a4aSRandall Stewart return (0); 1200f8829a4aSRandall Stewart } 1201f8829a4aSRandall Stewart 120242551e99SRandall Stewart #if defined(SCTP_USE_THREAD_BASED_ITERATOR) 120342551e99SRandall Stewart static void 120442551e99SRandall Stewart sctp_iterator_work(struct sctp_iterator *it) 120542551e99SRandall Stewart { 120642551e99SRandall Stewart int iteration_count = 0; 120742551e99SRandall Stewart int inp_skip = 0; 120842551e99SRandall Stewart 120942551e99SRandall Stewart SCTP_ITERATOR_LOCK(); 1210ad81507eSRandall Stewart if (it->inp) { 121142551e99SRandall Stewart SCTP_INP_DECR_REF(it->inp); 1212ad81507eSRandall Stewart } 121342551e99SRandall Stewart if (it->inp == NULL) { 121442551e99SRandall Stewart /* iterator is complete */ 121542551e99SRandall Stewart done_with_iterator: 121642551e99SRandall Stewart SCTP_ITERATOR_UNLOCK(); 121742551e99SRandall Stewart if (it->function_atend != NULL) { 121842551e99SRandall Stewart (*it->function_atend) (it->pointer, it->val); 121942551e99SRandall Stewart } 1220207304d4SRandall Stewart SCTP_FREE(it, SCTP_M_ITER); 122142551e99SRandall Stewart return; 122242551e99SRandall Stewart } 122342551e99SRandall Stewart select_a_new_ep: 122442551e99SRandall Stewart SCTP_INP_WLOCK(it->inp); 122542551e99SRandall Stewart while (((it->pcb_flags) && 122642551e99SRandall Stewart ((it->inp->sctp_flags & it->pcb_flags) != it->pcb_flags)) || 122742551e99SRandall Stewart ((it->pcb_features) && 122842551e99SRandall Stewart ((it->inp->sctp_features & it->pcb_features) != it->pcb_features))) { 122942551e99SRandall Stewart /* endpoint flags or features don't match, so keep looking */ 123042551e99SRandall Stewart if (it->iterator_flags & SCTP_ITERATOR_DO_SINGLE_INP) { 123142551e99SRandall Stewart SCTP_INP_WUNLOCK(it->inp); 123242551e99SRandall Stewart goto done_with_iterator; 123342551e99SRandall Stewart } 123442551e99SRandall Stewart SCTP_INP_WUNLOCK(it->inp); 123542551e99SRandall Stewart it->inp = LIST_NEXT(it->inp, sctp_list); 123642551e99SRandall Stewart if (it->inp == NULL) { 123742551e99SRandall Stewart goto done_with_iterator; 123842551e99SRandall Stewart } 123942551e99SRandall Stewart SCTP_INP_WLOCK(it->inp); 124042551e99SRandall Stewart } 124142551e99SRandall Stewart 124242551e99SRandall Stewart SCTP_INP_WUNLOCK(it->inp); 124342551e99SRandall Stewart SCTP_INP_RLOCK(it->inp); 124442551e99SRandall Stewart 124542551e99SRandall Stewart /* now go through each assoc which is in the desired state */ 124642551e99SRandall Stewart if (it->done_current_ep == 0) { 124742551e99SRandall Stewart if (it->function_inp != NULL) 124842551e99SRandall Stewart inp_skip = (*it->function_inp) (it->inp, it->pointer, it->val); 124942551e99SRandall Stewart it->done_current_ep = 1; 125042551e99SRandall Stewart } 125142551e99SRandall Stewart if (it->stcb == NULL) { 125242551e99SRandall Stewart /* run the per instance function */ 125342551e99SRandall Stewart it->stcb = LIST_FIRST(&it->inp->sctp_asoc_list); 125442551e99SRandall Stewart } 125542551e99SRandall Stewart if ((inp_skip) || it->stcb == NULL) { 125642551e99SRandall Stewart if (it->function_inp_end != NULL) { 125742551e99SRandall Stewart inp_skip = (*it->function_inp_end) (it->inp, 125842551e99SRandall Stewart it->pointer, 125942551e99SRandall Stewart it->val); 126042551e99SRandall Stewart } 126142551e99SRandall Stewart SCTP_INP_RUNLOCK(it->inp); 126242551e99SRandall Stewart goto no_stcb; 126342551e99SRandall Stewart } 126442551e99SRandall Stewart while (it->stcb) { 126542551e99SRandall Stewart SCTP_TCB_LOCK(it->stcb); 126642551e99SRandall Stewart if (it->asoc_state && ((it->stcb->asoc.state & it->asoc_state) != it->asoc_state)) { 126742551e99SRandall Stewart /* not in the right state... keep looking */ 126842551e99SRandall Stewart SCTP_TCB_UNLOCK(it->stcb); 126942551e99SRandall Stewart goto next_assoc; 127042551e99SRandall Stewart } 127142551e99SRandall Stewart /* see if we have limited out the iterator loop */ 127242551e99SRandall Stewart iteration_count++; 127342551e99SRandall Stewart if (iteration_count > SCTP_ITERATOR_MAX_AT_ONCE) { 127442551e99SRandall Stewart /* Pause to let others grab the lock */ 127542551e99SRandall Stewart atomic_add_int(&it->stcb->asoc.refcnt, 1); 127642551e99SRandall Stewart SCTP_TCB_UNLOCK(it->stcb); 1277c4739e2fSRandall Stewart 1278c4739e2fSRandall Stewart SCTP_INP_INCR_REF(it->inp); 127942551e99SRandall Stewart SCTP_INP_RUNLOCK(it->inp); 128042551e99SRandall Stewart SCTP_ITERATOR_UNLOCK(); 128142551e99SRandall Stewart SCTP_ITERATOR_LOCK(); 128242551e99SRandall Stewart SCTP_INP_RLOCK(it->inp); 1283c4739e2fSRandall Stewart 1284c4739e2fSRandall Stewart SCTP_INP_DECR_REF(it->inp); 128542551e99SRandall Stewart SCTP_TCB_LOCK(it->stcb); 128642551e99SRandall Stewart atomic_add_int(&it->stcb->asoc.refcnt, -1); 128742551e99SRandall Stewart iteration_count = 0; 128842551e99SRandall Stewart } 128942551e99SRandall Stewart /* run function on this one */ 129042551e99SRandall Stewart (*it->function_assoc) (it->inp, it->stcb, it->pointer, it->val); 129142551e99SRandall Stewart 129242551e99SRandall Stewart /* 129342551e99SRandall Stewart * we lie here, it really needs to have its own type but 129442551e99SRandall Stewart * first I must verify that this won't effect things :-0 129542551e99SRandall Stewart */ 129642551e99SRandall Stewart if (it->no_chunk_output == 0) 1297ceaad40aSRandall Stewart sctp_chunk_output(it->inp, it->stcb, SCTP_OUTPUT_FROM_T3, SCTP_SO_NOT_LOCKED); 129842551e99SRandall Stewart 129942551e99SRandall Stewart SCTP_TCB_UNLOCK(it->stcb); 130042551e99SRandall Stewart next_assoc: 130142551e99SRandall Stewart it->stcb = LIST_NEXT(it->stcb, sctp_tcblist); 130242551e99SRandall Stewart if (it->stcb == NULL) { 130342551e99SRandall Stewart /* Run last function */ 130442551e99SRandall Stewart if (it->function_inp_end != NULL) { 130542551e99SRandall Stewart inp_skip = (*it->function_inp_end) (it->inp, 130642551e99SRandall Stewart it->pointer, 130742551e99SRandall Stewart it->val); 130842551e99SRandall Stewart } 130942551e99SRandall Stewart } 131042551e99SRandall Stewart } 131142551e99SRandall Stewart SCTP_INP_RUNLOCK(it->inp); 131242551e99SRandall Stewart no_stcb: 131342551e99SRandall Stewart /* done with all assocs on this endpoint, move on to next endpoint */ 131442551e99SRandall Stewart it->done_current_ep = 0; 131542551e99SRandall Stewart SCTP_INP_WLOCK(it->inp); 131642551e99SRandall Stewart SCTP_INP_WUNLOCK(it->inp); 131742551e99SRandall Stewart if (it->iterator_flags & SCTP_ITERATOR_DO_SINGLE_INP) { 131842551e99SRandall Stewart it->inp = NULL; 131942551e99SRandall Stewart } else { 132042551e99SRandall Stewart SCTP_INP_INFO_RLOCK(); 132142551e99SRandall Stewart it->inp = LIST_NEXT(it->inp, sctp_list); 132242551e99SRandall Stewart SCTP_INP_INFO_RUNLOCK(); 132342551e99SRandall Stewart } 132442551e99SRandall Stewart if (it->inp == NULL) { 132542551e99SRandall Stewart goto done_with_iterator; 132642551e99SRandall Stewart } 132742551e99SRandall Stewart goto select_a_new_ep; 132842551e99SRandall Stewart } 132942551e99SRandall Stewart 133042551e99SRandall Stewart void 133142551e99SRandall Stewart sctp_iterator_worker(void) 133242551e99SRandall Stewart { 133342551e99SRandall Stewart struct sctp_iterator *it = NULL; 133442551e99SRandall Stewart 133542551e99SRandall Stewart /* This function is called with the WQ lock in place */ 133642551e99SRandall Stewart 133742551e99SRandall Stewart sctppcbinfo.iterator_running = 1; 133842551e99SRandall Stewart again: 133942551e99SRandall Stewart it = TAILQ_FIRST(&sctppcbinfo.iteratorhead); 134042551e99SRandall Stewart while (it) { 134142551e99SRandall Stewart /* now lets work on this one */ 134242551e99SRandall Stewart TAILQ_REMOVE(&sctppcbinfo.iteratorhead, it, sctp_nxt_itr); 134342551e99SRandall Stewart SCTP_IPI_ITERATOR_WQ_UNLOCK(); 134442551e99SRandall Stewart sctp_iterator_work(it); 134542551e99SRandall Stewart SCTP_IPI_ITERATOR_WQ_LOCK(); 13463c503c28SRandall Stewart /* sa_ignore FREED_MEMORY */ 134742551e99SRandall Stewart it = TAILQ_FIRST(&sctppcbinfo.iteratorhead); 134842551e99SRandall Stewart } 134942551e99SRandall Stewart if (TAILQ_FIRST(&sctppcbinfo.iteratorhead)) { 135042551e99SRandall Stewart goto again; 135142551e99SRandall Stewart } 135242551e99SRandall Stewart sctppcbinfo.iterator_running = 0; 135342551e99SRandall Stewart return; 135442551e99SRandall Stewart } 135542551e99SRandall Stewart 135642551e99SRandall Stewart #endif 135742551e99SRandall Stewart 1358f8829a4aSRandall Stewart 1359f8829a4aSRandall Stewart static void 1360f8829a4aSRandall Stewart sctp_handle_addr_wq(void) 1361f8829a4aSRandall Stewart { 1362f8829a4aSRandall Stewart /* deal with the ADDR wq from the rtsock calls */ 1363f8829a4aSRandall Stewart struct sctp_laddr *wi; 136442551e99SRandall Stewart struct sctp_asconf_iterator *asc; 1365f8829a4aSRandall Stewart 136642551e99SRandall Stewart SCTP_MALLOC(asc, struct sctp_asconf_iterator *, 1367207304d4SRandall Stewart sizeof(struct sctp_asconf_iterator), SCTP_M_ASC_IT); 136842551e99SRandall Stewart if (asc == NULL) { 136942551e99SRandall Stewart /* Try later, no memory */ 1370f8829a4aSRandall Stewart sctp_timer_start(SCTP_TIMER_TYPE_ADDR_WQ, 1371f8829a4aSRandall Stewart (struct sctp_inpcb *)NULL, 1372f8829a4aSRandall Stewart (struct sctp_tcb *)NULL, 1373f8829a4aSRandall Stewart (struct sctp_nets *)NULL); 137442551e99SRandall Stewart return; 1375f8829a4aSRandall Stewart } 137642551e99SRandall Stewart LIST_INIT(&asc->list_of_work); 137742551e99SRandall Stewart asc->cnt = 0; 137842551e99SRandall Stewart SCTP_IPI_ITERATOR_WQ_LOCK(); 137942551e99SRandall Stewart wi = LIST_FIRST(&sctppcbinfo.addr_wq); 138042551e99SRandall Stewart while (wi != NULL) { 138142551e99SRandall Stewart LIST_REMOVE(wi, sctp_nxt_addr); 138242551e99SRandall Stewart LIST_INSERT_HEAD(&asc->list_of_work, wi, sctp_nxt_addr); 138342551e99SRandall Stewart asc->cnt++; 138442551e99SRandall Stewart wi = LIST_FIRST(&sctppcbinfo.addr_wq); 1385f8829a4aSRandall Stewart } 138642551e99SRandall Stewart SCTP_IPI_ITERATOR_WQ_UNLOCK(); 138742551e99SRandall Stewart if (asc->cnt == 0) { 1388207304d4SRandall Stewart SCTP_FREE(asc, SCTP_M_ASC_IT); 138942551e99SRandall Stewart } else { 13901b649582SRandall Stewart (void)sctp_initiate_iterator(sctp_asconf_iterator_ep, 13911b649582SRandall Stewart sctp_asconf_iterator_stcb, 139242551e99SRandall Stewart NULL, /* No ep end for boundall */ 139342551e99SRandall Stewart SCTP_PCB_FLAGS_BOUNDALL, 139442551e99SRandall Stewart SCTP_PCB_ANY_FEATURES, 13951b649582SRandall Stewart SCTP_ASOC_ANY_STATE, 13961b649582SRandall Stewart (void *)asc, 0, 13971b649582SRandall Stewart sctp_asconf_iterator_end, NULL, 0); 139842551e99SRandall Stewart } 1399f8829a4aSRandall Stewart } 1400f8829a4aSRandall Stewart 1401b54d3a6cSRandall Stewart int retcode = 0; 1402b54d3a6cSRandall Stewart int cur_oerr = 0; 1403b54d3a6cSRandall Stewart 1404f8829a4aSRandall Stewart void 1405f8829a4aSRandall Stewart sctp_timeout_handler(void *t) 1406f8829a4aSRandall Stewart { 1407f8829a4aSRandall Stewart struct sctp_inpcb *inp; 1408f8829a4aSRandall Stewart struct sctp_tcb *stcb; 1409f8829a4aSRandall Stewart struct sctp_nets *net; 1410f8829a4aSRandall Stewart struct sctp_timer *tmr; 1411ceaad40aSRandall Stewart 1412ceaad40aSRandall Stewart #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 1413ceaad40aSRandall Stewart struct socket *so; 1414ceaad40aSRandall Stewart 1415ceaad40aSRandall Stewart #endif 141693164cf9SRandall Stewart int did_output; 1417f8829a4aSRandall Stewart struct sctp_iterator *it = NULL; 1418f8829a4aSRandall Stewart 1419f8829a4aSRandall Stewart tmr = (struct sctp_timer *)t; 1420f8829a4aSRandall Stewart inp = (struct sctp_inpcb *)tmr->ep; 1421f8829a4aSRandall Stewart stcb = (struct sctp_tcb *)tmr->tcb; 1422f8829a4aSRandall Stewart net = (struct sctp_nets *)tmr->net; 1423f8829a4aSRandall Stewart did_output = 1; 1424f8829a4aSRandall Stewart 1425f8829a4aSRandall Stewart #ifdef SCTP_AUDITING_ENABLED 1426f8829a4aSRandall Stewart sctp_audit_log(0xF0, (uint8_t) tmr->type); 1427f8829a4aSRandall Stewart sctp_auditing(3, inp, stcb, net); 1428f8829a4aSRandall Stewart #endif 1429f8829a4aSRandall Stewart 1430f8829a4aSRandall Stewart /* sanity checks... */ 1431f8829a4aSRandall Stewart if (tmr->self != (void *)tmr) { 1432f8829a4aSRandall Stewart /* 1433ad81507eSRandall Stewart * SCTP_PRINTF("Stale SCTP timer fired (%p), ignoring...\n", 1434f8829a4aSRandall Stewart * tmr); 1435f8829a4aSRandall Stewart */ 1436f8829a4aSRandall Stewart return; 1437f8829a4aSRandall Stewart } 1438a5d547adSRandall Stewart tmr->stopped_from = 0xa001; 1439f8829a4aSRandall Stewart if (!SCTP_IS_TIMER_TYPE_VALID(tmr->type)) { 1440f8829a4aSRandall Stewart /* 1441ad81507eSRandall Stewart * SCTP_PRINTF("SCTP timer fired with invalid type: 0x%x\n", 1442f8829a4aSRandall Stewart * tmr->type); 1443f8829a4aSRandall Stewart */ 1444f8829a4aSRandall Stewart return; 1445f8829a4aSRandall Stewart } 1446a5d547adSRandall Stewart tmr->stopped_from = 0xa002; 1447f8829a4aSRandall Stewart if ((tmr->type != SCTP_TIMER_TYPE_ADDR_WQ) && (inp == NULL)) { 1448f8829a4aSRandall Stewart return; 1449f8829a4aSRandall Stewart } 1450f8829a4aSRandall Stewart /* if this is an iterator timeout, get the struct and clear inp */ 1451a5d547adSRandall Stewart tmr->stopped_from = 0xa003; 1452f8829a4aSRandall Stewart if (tmr->type == SCTP_TIMER_TYPE_ITERATOR) { 1453f8829a4aSRandall Stewart it = (struct sctp_iterator *)inp; 1454f8829a4aSRandall Stewart inp = NULL; 1455f8829a4aSRandall Stewart } 1456f8829a4aSRandall Stewart if (inp) { 1457f8829a4aSRandall Stewart SCTP_INP_INCR_REF(inp); 1458f8829a4aSRandall Stewart if ((inp->sctp_socket == 0) && 1459f8829a4aSRandall Stewart ((tmr->type != SCTP_TIMER_TYPE_INPKILL) && 1460f8829a4aSRandall Stewart (tmr->type != SCTP_TIMER_TYPE_SHUTDOWN) && 1461f8829a4aSRandall Stewart (tmr->type != SCTP_TIMER_TYPE_SHUTDOWNACK) && 1462f8829a4aSRandall Stewart (tmr->type != SCTP_TIMER_TYPE_SHUTDOWNGUARD) && 1463f8829a4aSRandall Stewart (tmr->type != SCTP_TIMER_TYPE_ASOCKILL)) 1464f8829a4aSRandall Stewart ) { 1465f8829a4aSRandall Stewart SCTP_INP_DECR_REF(inp); 1466f8829a4aSRandall Stewart return; 1467f8829a4aSRandall Stewart } 1468f8829a4aSRandall Stewart } 1469a5d547adSRandall Stewart tmr->stopped_from = 0xa004; 1470f8829a4aSRandall Stewart if (stcb) { 1471c105859eSRandall Stewart atomic_add_int(&stcb->asoc.refcnt, 1); 1472f8829a4aSRandall Stewart if (stcb->asoc.state == 0) { 1473c105859eSRandall Stewart atomic_add_int(&stcb->asoc.refcnt, -1); 1474f8829a4aSRandall Stewart if (inp) { 1475f8829a4aSRandall Stewart SCTP_INP_DECR_REF(inp); 1476f8829a4aSRandall Stewart } 1477f8829a4aSRandall Stewart return; 1478f8829a4aSRandall Stewart } 1479f8829a4aSRandall Stewart } 1480a5d547adSRandall Stewart tmr->stopped_from = 0xa005; 1481ad81507eSRandall Stewart SCTPDBG(SCTP_DEBUG_TIMER1, "Timer type %d goes off\n", tmr->type); 1482139bc87fSRandall Stewart if (!SCTP_OS_TIMER_ACTIVE(&tmr->timer)) { 1483f8829a4aSRandall Stewart if (inp) { 1484f8829a4aSRandall Stewart SCTP_INP_DECR_REF(inp); 1485f8829a4aSRandall Stewart } 1486207304d4SRandall Stewart if (stcb) { 1487207304d4SRandall Stewart atomic_add_int(&stcb->asoc.refcnt, -1); 1488207304d4SRandall Stewart } 1489f8829a4aSRandall Stewart return; 1490f8829a4aSRandall Stewart } 1491a5d547adSRandall Stewart tmr->stopped_from = 0xa006; 1492a5d547adSRandall Stewart 1493f8829a4aSRandall Stewart if (stcb) { 1494f8829a4aSRandall Stewart SCTP_TCB_LOCK(stcb); 149550cec919SRandall Stewart atomic_add_int(&stcb->asoc.refcnt, -1); 1496b54d3a6cSRandall Stewart if ((tmr->type != SCTP_TIMER_TYPE_ASOCKILL) && 1497b54d3a6cSRandall Stewart ((stcb->asoc.state == 0) || 1498b54d3a6cSRandall Stewart (stcb->asoc.state & SCTP_STATE_ABOUT_TO_BE_FREED))) { 1499b54d3a6cSRandall Stewart SCTP_TCB_UNLOCK(stcb); 1500b54d3a6cSRandall Stewart if (inp) { 1501b54d3a6cSRandall Stewart SCTP_INP_DECR_REF(inp); 1502b54d3a6cSRandall Stewart } 1503b54d3a6cSRandall Stewart return; 1504b54d3a6cSRandall Stewart } 1505f8829a4aSRandall Stewart } 150644b7479bSRandall Stewart /* record in stopped what t-o occured */ 150744b7479bSRandall Stewart tmr->stopped_from = tmr->type; 150844b7479bSRandall Stewart 1509f8829a4aSRandall Stewart /* mark as being serviced now */ 151044b7479bSRandall Stewart if (SCTP_OS_TIMER_PENDING(&tmr->timer)) { 151144b7479bSRandall Stewart /* 151244b7479bSRandall Stewart * Callout has been rescheduled. 151344b7479bSRandall Stewart */ 151444b7479bSRandall Stewart goto get_out; 151544b7479bSRandall Stewart } 151644b7479bSRandall Stewart if (!SCTP_OS_TIMER_ACTIVE(&tmr->timer)) { 151744b7479bSRandall Stewart /* 151844b7479bSRandall Stewart * Not active, so no action. 151944b7479bSRandall Stewart */ 152044b7479bSRandall Stewart goto get_out; 152144b7479bSRandall Stewart } 1522139bc87fSRandall Stewart SCTP_OS_TIMER_DEACTIVATE(&tmr->timer); 1523f8829a4aSRandall Stewart 1524f8829a4aSRandall Stewart /* call the handler for the appropriate timer type */ 1525f8829a4aSRandall Stewart switch (tmr->type) { 1526d61a0ae0SRandall Stewart case SCTP_TIMER_TYPE_ZERO_COPY: 1527eacc51c5SRandall Stewart if (inp == NULL) { 1528eacc51c5SRandall Stewart break; 1529eacc51c5SRandall Stewart } 1530d61a0ae0SRandall Stewart if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_ZERO_COPY_ACTIVE)) { 1531d61a0ae0SRandall Stewart SCTP_ZERO_COPY_EVENT(inp, inp->sctp_socket); 1532d61a0ae0SRandall Stewart } 1533d61a0ae0SRandall Stewart break; 1534ad21a364SRandall Stewart case SCTP_TIMER_TYPE_ZCOPY_SENDQ: 1535eacc51c5SRandall Stewart if (inp == NULL) { 1536eacc51c5SRandall Stewart break; 1537eacc51c5SRandall Stewart } 1538ad21a364SRandall Stewart if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_ZERO_COPY_ACTIVE)) { 1539ad21a364SRandall Stewart SCTP_ZERO_COPY_SENDQ_EVENT(inp, inp->sctp_socket); 1540ad21a364SRandall Stewart } 1541ad21a364SRandall Stewart break; 1542f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_ADDR_WQ: 1543f8829a4aSRandall Stewart sctp_handle_addr_wq(); 1544f8829a4aSRandall Stewart break; 1545f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_ITERATOR: 1546f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_timoiterator); 1547f8829a4aSRandall Stewart sctp_iterator_timer(it); 1548f8829a4aSRandall Stewart break; 1549f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_SEND: 1550ad81507eSRandall Stewart if ((stcb == NULL) || (inp == NULL)) { 1551ad81507eSRandall Stewart break; 1552ad81507eSRandall Stewart } 1553f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_timodata); 1554f42a358aSRandall Stewart stcb->asoc.timodata++; 1555f8829a4aSRandall Stewart stcb->asoc.num_send_timers_up--; 1556f8829a4aSRandall Stewart if (stcb->asoc.num_send_timers_up < 0) { 1557f8829a4aSRandall Stewart stcb->asoc.num_send_timers_up = 0; 1558f8829a4aSRandall Stewart } 1559b54d3a6cSRandall Stewart SCTP_TCB_LOCK_ASSERT(stcb); 1560b54d3a6cSRandall Stewart cur_oerr = stcb->asoc.overall_error_count; 1561b54d3a6cSRandall Stewart retcode = sctp_t3rxt_timer(inp, stcb, net); 1562b54d3a6cSRandall Stewart if (retcode) { 1563f8829a4aSRandall Stewart /* no need to unlock on tcb its gone */ 1564f8829a4aSRandall Stewart 1565f8829a4aSRandall Stewart goto out_decr; 1566f8829a4aSRandall Stewart } 1567b54d3a6cSRandall Stewart SCTP_TCB_LOCK_ASSERT(stcb); 1568f8829a4aSRandall Stewart #ifdef SCTP_AUDITING_ENABLED 1569f8829a4aSRandall Stewart sctp_auditing(4, inp, stcb, net); 1570f8829a4aSRandall Stewart #endif 1571ceaad40aSRandall Stewart sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_T3, SCTP_SO_NOT_LOCKED); 1572f8829a4aSRandall Stewart if ((stcb->asoc.num_send_timers_up == 0) && 1573f8829a4aSRandall Stewart (stcb->asoc.sent_queue_cnt > 0) 1574f8829a4aSRandall Stewart ) { 1575f8829a4aSRandall Stewart struct sctp_tmit_chunk *chk; 1576f8829a4aSRandall Stewart 1577f8829a4aSRandall Stewart /* 1578f8829a4aSRandall Stewart * safeguard. If there on some on the sent queue 1579f8829a4aSRandall Stewart * somewhere but no timers running something is 1580f8829a4aSRandall Stewart * wrong... so we start a timer on the first chunk 1581f8829a4aSRandall Stewart * on the send queue on whatever net it is sent to. 1582f8829a4aSRandall Stewart */ 1583f8829a4aSRandall Stewart chk = TAILQ_FIRST(&stcb->asoc.sent_queue); 1584f8829a4aSRandall Stewart sctp_timer_start(SCTP_TIMER_TYPE_SEND, inp, stcb, 1585f8829a4aSRandall Stewart chk->whoTo); 1586f8829a4aSRandall Stewart } 1587f8829a4aSRandall Stewart break; 1588f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_INIT: 1589ad81507eSRandall Stewart if ((stcb == NULL) || (inp == NULL)) { 1590ad81507eSRandall Stewart break; 1591ad81507eSRandall Stewart } 1592f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_timoinit); 1593f42a358aSRandall Stewart stcb->asoc.timoinit++; 1594f8829a4aSRandall Stewart if (sctp_t1init_timer(inp, stcb, net)) { 1595f8829a4aSRandall Stewart /* no need to unlock on tcb its gone */ 1596f8829a4aSRandall Stewart goto out_decr; 1597f8829a4aSRandall Stewart } 1598f8829a4aSRandall Stewart /* We do output but not here */ 1599f8829a4aSRandall Stewart did_output = 0; 1600f8829a4aSRandall Stewart break; 1601f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_RECV: 1602ad81507eSRandall Stewart if ((stcb == NULL) || (inp == NULL)) { 1603ad81507eSRandall Stewart break; 1604c4739e2fSRandall Stewart } { 1605c4739e2fSRandall Stewart int abort_flag; 1606c4739e2fSRandall Stewart 1607f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_timosack); 1608f42a358aSRandall Stewart stcb->asoc.timosack++; 1609c4739e2fSRandall Stewart if (stcb->asoc.cumulative_tsn != stcb->asoc.highest_tsn_inside_map) 1610c4739e2fSRandall Stewart sctp_sack_check(stcb, 0, 0, &abort_flag); 1611f8829a4aSRandall Stewart sctp_send_sack(stcb); 1612c4739e2fSRandall Stewart } 1613f8829a4aSRandall Stewart #ifdef SCTP_AUDITING_ENABLED 1614f8829a4aSRandall Stewart sctp_auditing(4, inp, stcb, net); 1615f8829a4aSRandall Stewart #endif 1616ceaad40aSRandall Stewart sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_SACK_TMR, SCTP_SO_NOT_LOCKED); 1617f8829a4aSRandall Stewart break; 1618f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_SHUTDOWN: 1619ad81507eSRandall Stewart if ((stcb == NULL) || (inp == NULL)) { 1620ad81507eSRandall Stewart break; 1621ad81507eSRandall Stewart } 1622f8829a4aSRandall Stewart if (sctp_shutdown_timer(inp, stcb, net)) { 1623f8829a4aSRandall Stewart /* no need to unlock on tcb its gone */ 1624f8829a4aSRandall Stewart goto out_decr; 1625f8829a4aSRandall Stewart } 1626f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_timoshutdown); 1627f42a358aSRandall Stewart stcb->asoc.timoshutdown++; 1628f8829a4aSRandall Stewart #ifdef SCTP_AUDITING_ENABLED 1629f8829a4aSRandall Stewart sctp_auditing(4, inp, stcb, net); 1630f8829a4aSRandall Stewart #endif 1631ceaad40aSRandall Stewart sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_SHUT_TMR, SCTP_SO_NOT_LOCKED); 1632f8829a4aSRandall Stewart break; 1633f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_HEARTBEAT: 1634f8829a4aSRandall Stewart { 16354c9179adSRandall Stewart struct sctp_nets *lnet; 1636f8829a4aSRandall Stewart int cnt_of_unconf = 0; 1637f8829a4aSRandall Stewart 1638ad81507eSRandall Stewart if ((stcb == NULL) || (inp == NULL)) { 1639ad81507eSRandall Stewart break; 1640ad81507eSRandall Stewart } 1641f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_timoheartbeat); 1642f42a358aSRandall Stewart stcb->asoc.timoheartbeat++; 16434c9179adSRandall Stewart TAILQ_FOREACH(lnet, &stcb->asoc.nets, sctp_next) { 16444c9179adSRandall Stewart if ((lnet->dest_state & SCTP_ADDR_UNCONFIRMED) && 16454c9179adSRandall Stewart (lnet->dest_state & SCTP_ADDR_REACHABLE)) { 1646f8829a4aSRandall Stewart cnt_of_unconf++; 1647f8829a4aSRandall Stewart } 1648f8829a4aSRandall Stewart } 1649f8829a4aSRandall Stewart if (cnt_of_unconf == 0) { 16504c9179adSRandall Stewart if (sctp_heartbeat_timer(inp, stcb, lnet, 16514c9179adSRandall Stewart cnt_of_unconf)) { 1652f8829a4aSRandall Stewart /* no need to unlock on tcb its gone */ 1653f8829a4aSRandall Stewart goto out_decr; 1654f8829a4aSRandall Stewart } 1655f8829a4aSRandall Stewart } 1656f8829a4aSRandall Stewart #ifdef SCTP_AUDITING_ENABLED 16574c9179adSRandall Stewart sctp_auditing(4, inp, stcb, lnet); 1658f8829a4aSRandall Stewart #endif 16594c9179adSRandall Stewart sctp_timer_start(SCTP_TIMER_TYPE_HEARTBEAT, 16604c9179adSRandall Stewart stcb->sctp_ep, stcb, lnet); 1661ceaad40aSRandall Stewart sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_HB_TMR, SCTP_SO_NOT_LOCKED); 1662f8829a4aSRandall Stewart } 1663f8829a4aSRandall Stewart break; 1664f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_COOKIE: 1665ad81507eSRandall Stewart if ((stcb == NULL) || (inp == NULL)) { 1666ad81507eSRandall Stewart break; 1667ad81507eSRandall Stewart } 1668f8829a4aSRandall Stewart if (sctp_cookie_timer(inp, stcb, net)) { 1669f8829a4aSRandall Stewart /* no need to unlock on tcb its gone */ 1670f8829a4aSRandall Stewart goto out_decr; 1671f8829a4aSRandall Stewart } 1672f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_timocookie); 1673f42a358aSRandall Stewart stcb->asoc.timocookie++; 1674f8829a4aSRandall Stewart #ifdef SCTP_AUDITING_ENABLED 1675f8829a4aSRandall Stewart sctp_auditing(4, inp, stcb, net); 1676f8829a4aSRandall Stewart #endif 1677f8829a4aSRandall Stewart /* 1678f8829a4aSRandall Stewart * We consider T3 and Cookie timer pretty much the same with 1679f8829a4aSRandall Stewart * respect to where from in chunk_output. 1680f8829a4aSRandall Stewart */ 1681ceaad40aSRandall Stewart sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_T3, SCTP_SO_NOT_LOCKED); 1682f8829a4aSRandall Stewart break; 1683f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_NEWCOOKIE: 1684f8829a4aSRandall Stewart { 1685f8829a4aSRandall Stewart struct timeval tv; 1686f8829a4aSRandall Stewart int i, secret; 1687f8829a4aSRandall Stewart 1688ad81507eSRandall Stewart if (inp == NULL) { 1689ad81507eSRandall Stewart break; 1690ad81507eSRandall Stewart } 1691f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_timosecret); 16926e55db54SRandall Stewart (void)SCTP_GETTIME_TIMEVAL(&tv); 1693f8829a4aSRandall Stewart SCTP_INP_WLOCK(inp); 1694f8829a4aSRandall Stewart inp->sctp_ep.time_of_secret_change = tv.tv_sec; 1695f8829a4aSRandall Stewart inp->sctp_ep.last_secret_number = 1696f8829a4aSRandall Stewart inp->sctp_ep.current_secret_number; 1697f8829a4aSRandall Stewart inp->sctp_ep.current_secret_number++; 1698f8829a4aSRandall Stewart if (inp->sctp_ep.current_secret_number >= 1699f8829a4aSRandall Stewart SCTP_HOW_MANY_SECRETS) { 1700f8829a4aSRandall Stewart inp->sctp_ep.current_secret_number = 0; 1701f8829a4aSRandall Stewart } 1702f8829a4aSRandall Stewart secret = (int)inp->sctp_ep.current_secret_number; 1703f8829a4aSRandall Stewart for (i = 0; i < SCTP_NUMBER_OF_SECRETS; i++) { 1704f8829a4aSRandall Stewart inp->sctp_ep.secret_key[secret][i] = 1705f8829a4aSRandall Stewart sctp_select_initial_TSN(&inp->sctp_ep); 1706f8829a4aSRandall Stewart } 1707f8829a4aSRandall Stewart SCTP_INP_WUNLOCK(inp); 1708f8829a4aSRandall Stewart sctp_timer_start(SCTP_TIMER_TYPE_NEWCOOKIE, inp, stcb, net); 1709f8829a4aSRandall Stewart } 1710f8829a4aSRandall Stewart did_output = 0; 1711f8829a4aSRandall Stewart break; 1712f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_PATHMTURAISE: 1713ad81507eSRandall Stewart if ((stcb == NULL) || (inp == NULL)) { 1714ad81507eSRandall Stewart break; 1715ad81507eSRandall Stewart } 1716f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_timopathmtu); 1717f8829a4aSRandall Stewart sctp_pathmtu_timer(inp, stcb, net); 1718f8829a4aSRandall Stewart did_output = 0; 1719f8829a4aSRandall Stewart break; 1720f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_SHUTDOWNACK: 1721ad81507eSRandall Stewart if ((stcb == NULL) || (inp == NULL)) { 1722ad81507eSRandall Stewart break; 1723ad81507eSRandall Stewart } 1724f8829a4aSRandall Stewart if (sctp_shutdownack_timer(inp, stcb, net)) { 1725f8829a4aSRandall Stewart /* no need to unlock on tcb its gone */ 1726f8829a4aSRandall Stewart goto out_decr; 1727f8829a4aSRandall Stewart } 1728f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_timoshutdownack); 1729f42a358aSRandall Stewart stcb->asoc.timoshutdownack++; 1730f8829a4aSRandall Stewart #ifdef SCTP_AUDITING_ENABLED 1731f8829a4aSRandall Stewart sctp_auditing(4, inp, stcb, net); 1732f8829a4aSRandall Stewart #endif 1733ceaad40aSRandall Stewart sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_SHUT_ACK_TMR, SCTP_SO_NOT_LOCKED); 1734f8829a4aSRandall Stewart break; 1735f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_SHUTDOWNGUARD: 1736ad81507eSRandall Stewart if ((stcb == NULL) || (inp == NULL)) { 1737ad81507eSRandall Stewart break; 1738ad81507eSRandall Stewart } 1739f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_timoshutdownguard); 1740f8829a4aSRandall Stewart sctp_abort_an_association(inp, stcb, 1741ceaad40aSRandall Stewart SCTP_SHUTDOWN_GUARD_EXPIRES, NULL, SCTP_SO_NOT_LOCKED); 1742f8829a4aSRandall Stewart /* no need to unlock on tcb its gone */ 1743f8829a4aSRandall Stewart goto out_decr; 1744f8829a4aSRandall Stewart 1745f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_STRRESET: 1746ad81507eSRandall Stewart if ((stcb == NULL) || (inp == NULL)) { 1747ad81507eSRandall Stewart break; 1748ad81507eSRandall Stewart } 1749f8829a4aSRandall Stewart if (sctp_strreset_timer(inp, stcb, net)) { 1750f8829a4aSRandall Stewart /* no need to unlock on tcb its gone */ 1751f8829a4aSRandall Stewart goto out_decr; 1752f8829a4aSRandall Stewart } 1753f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_timostrmrst); 1754ceaad40aSRandall Stewart sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_STRRST_TMR, SCTP_SO_NOT_LOCKED); 1755f8829a4aSRandall Stewart break; 1756f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_EARLYFR: 1757f8829a4aSRandall Stewart /* Need to do FR of things for net */ 1758ad81507eSRandall Stewart if ((stcb == NULL) || (inp == NULL)) { 1759ad81507eSRandall Stewart break; 1760ad81507eSRandall Stewart } 1761f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_timoearlyfr); 1762f8829a4aSRandall Stewart sctp_early_fr_timer(inp, stcb, net); 1763f8829a4aSRandall Stewart break; 1764f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_ASCONF: 1765ad81507eSRandall Stewart if ((stcb == NULL) || (inp == NULL)) { 1766ad81507eSRandall Stewart break; 1767ad81507eSRandall Stewart } 1768f8829a4aSRandall Stewart if (sctp_asconf_timer(inp, stcb, net)) { 1769f8829a4aSRandall Stewart /* no need to unlock on tcb its gone */ 1770f8829a4aSRandall Stewart goto out_decr; 1771f8829a4aSRandall Stewart } 1772f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_timoasconf); 1773f8829a4aSRandall Stewart #ifdef SCTP_AUDITING_ENABLED 1774f8829a4aSRandall Stewart sctp_auditing(4, inp, stcb, net); 1775f8829a4aSRandall Stewart #endif 1776ceaad40aSRandall Stewart sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_ASCONF_TMR, SCTP_SO_NOT_LOCKED); 1777f8829a4aSRandall Stewart break; 1778851b7298SRandall Stewart case SCTP_TIMER_TYPE_PRIM_DELETED: 1779851b7298SRandall Stewart if ((stcb == NULL) || (inp == NULL)) { 1780851b7298SRandall Stewart break; 1781851b7298SRandall Stewart } 178204ee05e8SRandall Stewart sctp_delete_prim_timer(inp, stcb, net); 1783851b7298SRandall Stewart SCTP_STAT_INCR(sctps_timodelprim); 1784851b7298SRandall Stewart break; 1785f8829a4aSRandall Stewart 1786f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_AUTOCLOSE: 1787ad81507eSRandall Stewart if ((stcb == NULL) || (inp == NULL)) { 1788ad81507eSRandall Stewart break; 1789ad81507eSRandall Stewart } 1790f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_timoautoclose); 1791f8829a4aSRandall Stewart sctp_autoclose_timer(inp, stcb, net); 1792ceaad40aSRandall Stewart sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_AUTOCLOSE_TMR, SCTP_SO_NOT_LOCKED); 1793f8829a4aSRandall Stewart did_output = 0; 1794f8829a4aSRandall Stewart break; 1795f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_ASOCKILL: 1796ad81507eSRandall Stewart if ((stcb == NULL) || (inp == NULL)) { 1797ad81507eSRandall Stewart break; 1798ad81507eSRandall Stewart } 1799f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_timoassockill); 1800f8829a4aSRandall Stewart /* Can we free it yet? */ 1801f8829a4aSRandall Stewart SCTP_INP_DECR_REF(inp); 1802a5d547adSRandall Stewart sctp_timer_stop(SCTP_TIMER_TYPE_ASOCKILL, inp, stcb, NULL, SCTP_FROM_SCTPUTIL + SCTP_LOC_1); 1803ceaad40aSRandall Stewart #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 1804ceaad40aSRandall Stewart so = SCTP_INP_SO(inp); 1805ceaad40aSRandall Stewart atomic_add_int(&stcb->asoc.refcnt, 1); 1806ceaad40aSRandall Stewart SCTP_TCB_UNLOCK(stcb); 1807ceaad40aSRandall Stewart SCTP_SOCKET_LOCK(so, 1); 1808ceaad40aSRandall Stewart SCTP_TCB_LOCK(stcb); 1809ceaad40aSRandall Stewart atomic_subtract_int(&stcb->asoc.refcnt, 1); 1810ceaad40aSRandall Stewart #endif 1811c4739e2fSRandall Stewart (void)sctp_free_assoc(inp, stcb, SCTP_NORMAL_PROC, SCTP_FROM_SCTPUTIL + SCTP_LOC_2); 1812ceaad40aSRandall Stewart #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 1813ceaad40aSRandall Stewart SCTP_SOCKET_UNLOCK(so, 1); 1814ceaad40aSRandall Stewart #endif 1815f8829a4aSRandall Stewart /* 1816f8829a4aSRandall Stewart * free asoc, always unlocks (or destroy's) so prevent 1817f8829a4aSRandall Stewart * duplicate unlock or unlock of a free mtx :-0 1818f8829a4aSRandall Stewart */ 1819f8829a4aSRandall Stewart stcb = NULL; 1820f8829a4aSRandall Stewart goto out_no_decr; 1821f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_INPKILL: 1822f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_timoinpkill); 1823ad81507eSRandall Stewart if (inp == NULL) { 1824ad81507eSRandall Stewart break; 1825ad81507eSRandall Stewart } 1826f8829a4aSRandall Stewart /* 1827f8829a4aSRandall Stewart * special case, take away our increment since WE are the 1828f8829a4aSRandall Stewart * killer 1829f8829a4aSRandall Stewart */ 1830f8829a4aSRandall Stewart SCTP_INP_DECR_REF(inp); 1831a5d547adSRandall Stewart sctp_timer_stop(SCTP_TIMER_TYPE_INPKILL, inp, NULL, NULL, SCTP_FROM_SCTPUTIL + SCTP_LOC_3); 1832b0552ae2SRandall Stewart sctp_inpcb_free(inp, SCTP_FREE_SHOULD_USE_ABORT, 1833b0552ae2SRandall Stewart SCTP_CALLED_DIRECTLY_NOCMPSET); 1834f8829a4aSRandall Stewart goto out_no_decr; 1835f8829a4aSRandall Stewart default: 1836ad81507eSRandall Stewart SCTPDBG(SCTP_DEBUG_TIMER1, "sctp_timeout_handler:unknown timer %d\n", 1837f8829a4aSRandall Stewart tmr->type); 1838f8829a4aSRandall Stewart break; 1839f8829a4aSRandall Stewart }; 1840f8829a4aSRandall Stewart #ifdef SCTP_AUDITING_ENABLED 1841f8829a4aSRandall Stewart sctp_audit_log(0xF1, (uint8_t) tmr->type); 1842f8829a4aSRandall Stewart if (inp) 1843f8829a4aSRandall Stewart sctp_auditing(5, inp, stcb, net); 1844f8829a4aSRandall Stewart #endif 1845f8829a4aSRandall Stewart if ((did_output) && stcb) { 1846f8829a4aSRandall Stewart /* 1847f8829a4aSRandall Stewart * Now we need to clean up the control chunk chain if an 1848f8829a4aSRandall Stewart * ECNE is on it. It must be marked as UNSENT again so next 1849f8829a4aSRandall Stewart * call will continue to send it until such time that we get 1850f8829a4aSRandall Stewart * a CWR, to remove it. It is, however, less likely that we 1851f8829a4aSRandall Stewart * will find a ecn echo on the chain though. 1852f8829a4aSRandall Stewart */ 1853f8829a4aSRandall Stewart sctp_fix_ecn_echo(&stcb->asoc); 1854f8829a4aSRandall Stewart } 185544b7479bSRandall Stewart get_out: 1856f8829a4aSRandall Stewart if (stcb) { 1857f8829a4aSRandall Stewart SCTP_TCB_UNLOCK(stcb); 1858f8829a4aSRandall Stewart } 1859f8829a4aSRandall Stewart out_decr: 1860f8829a4aSRandall Stewart if (inp) { 1861f8829a4aSRandall Stewart SCTP_INP_DECR_REF(inp); 1862f8829a4aSRandall Stewart } 1863f8829a4aSRandall Stewart out_no_decr: 1864ad81507eSRandall Stewart SCTPDBG(SCTP_DEBUG_TIMER1, "Timer now complete (type %d)\n", 1865ad81507eSRandall Stewart tmr->type); 1866f8829a4aSRandall Stewart if (inp) { 1867f8829a4aSRandall Stewart } 1868f8829a4aSRandall Stewart } 1869f8829a4aSRandall Stewart 1870ad81507eSRandall Stewart void 1871f8829a4aSRandall Stewart sctp_timer_start(int t_type, struct sctp_inpcb *inp, struct sctp_tcb *stcb, 1872f8829a4aSRandall Stewart struct sctp_nets *net) 1873f8829a4aSRandall Stewart { 1874f8829a4aSRandall Stewart int to_ticks; 1875f8829a4aSRandall Stewart struct sctp_timer *tmr; 1876f8829a4aSRandall Stewart 1877139bc87fSRandall Stewart if ((t_type != SCTP_TIMER_TYPE_ADDR_WQ) && (inp == NULL)) 1878ad81507eSRandall Stewart return; 1879f8829a4aSRandall Stewart 1880f8829a4aSRandall Stewart to_ticks = 0; 1881f8829a4aSRandall Stewart 1882f8829a4aSRandall Stewart tmr = NULL; 1883f8829a4aSRandall Stewart if (stcb) { 1884f8829a4aSRandall Stewart SCTP_TCB_LOCK_ASSERT(stcb); 1885f8829a4aSRandall Stewart } 1886f8829a4aSRandall Stewart switch (t_type) { 1887d61a0ae0SRandall Stewart case SCTP_TIMER_TYPE_ZERO_COPY: 1888d61a0ae0SRandall Stewart tmr = &inp->sctp_ep.zero_copy_timer; 1889d61a0ae0SRandall Stewart to_ticks = SCTP_ZERO_COPY_TICK_DELAY; 1890d61a0ae0SRandall Stewart break; 1891ad21a364SRandall Stewart case SCTP_TIMER_TYPE_ZCOPY_SENDQ: 1892ad21a364SRandall Stewart tmr = &inp->sctp_ep.zero_copy_sendq_timer; 1893ad21a364SRandall Stewart to_ticks = SCTP_ZERO_COPY_SENDQ_TICK_DELAY; 1894ad21a364SRandall Stewart break; 1895f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_ADDR_WQ: 1896f8829a4aSRandall Stewart /* Only 1 tick away :-) */ 1897f8829a4aSRandall Stewart tmr = &sctppcbinfo.addr_wq_timer; 189842551e99SRandall Stewart to_ticks = SCTP_ADDRESS_TICK_DELAY; 1899f8829a4aSRandall Stewart break; 1900f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_ITERATOR: 1901f8829a4aSRandall Stewart { 1902f8829a4aSRandall Stewart struct sctp_iterator *it; 1903f8829a4aSRandall Stewart 1904f8829a4aSRandall Stewart it = (struct sctp_iterator *)inp; 1905f8829a4aSRandall Stewart tmr = &it->tmr; 1906f8829a4aSRandall Stewart to_ticks = SCTP_ITERATOR_TICKS; 1907f8829a4aSRandall Stewart } 1908f8829a4aSRandall Stewart break; 1909f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_SEND: 1910f8829a4aSRandall Stewart /* Here we use the RTO timer */ 1911f8829a4aSRandall Stewart { 1912f8829a4aSRandall Stewart int rto_val; 1913f8829a4aSRandall Stewart 1914f8829a4aSRandall Stewart if ((stcb == NULL) || (net == NULL)) { 1915ad81507eSRandall Stewart return; 1916f8829a4aSRandall Stewart } 1917f8829a4aSRandall Stewart tmr = &net->rxt_timer; 1918f8829a4aSRandall Stewart if (net->RTO == 0) { 1919f8829a4aSRandall Stewart rto_val = stcb->asoc.initial_rto; 1920f8829a4aSRandall Stewart } else { 1921f8829a4aSRandall Stewart rto_val = net->RTO; 1922f8829a4aSRandall Stewart } 1923f8829a4aSRandall Stewart to_ticks = MSEC_TO_TICKS(rto_val); 1924f8829a4aSRandall Stewart } 1925f8829a4aSRandall Stewart break; 1926f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_INIT: 1927f8829a4aSRandall Stewart /* 1928f8829a4aSRandall Stewart * Here we use the INIT timer default usually about 1 1929f8829a4aSRandall Stewart * minute. 1930f8829a4aSRandall Stewart */ 1931f8829a4aSRandall Stewart if ((stcb == NULL) || (net == NULL)) { 1932ad81507eSRandall Stewart return; 1933f8829a4aSRandall Stewart } 1934f8829a4aSRandall Stewart tmr = &net->rxt_timer; 1935f8829a4aSRandall Stewart if (net->RTO == 0) { 1936f8829a4aSRandall Stewart to_ticks = MSEC_TO_TICKS(stcb->asoc.initial_rto); 1937f8829a4aSRandall Stewart } else { 1938f8829a4aSRandall Stewart to_ticks = MSEC_TO_TICKS(net->RTO); 1939f8829a4aSRandall Stewart } 1940f8829a4aSRandall Stewart break; 1941f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_RECV: 1942f8829a4aSRandall Stewart /* 1943f8829a4aSRandall Stewart * Here we use the Delayed-Ack timer value from the inp 1944f8829a4aSRandall Stewart * ususually about 200ms. 1945f8829a4aSRandall Stewart */ 1946f8829a4aSRandall Stewart if (stcb == NULL) { 1947ad81507eSRandall Stewart return; 1948f8829a4aSRandall Stewart } 1949f8829a4aSRandall Stewart tmr = &stcb->asoc.dack_timer; 1950f8829a4aSRandall Stewart to_ticks = MSEC_TO_TICKS(stcb->asoc.delayed_ack); 1951f8829a4aSRandall Stewart break; 1952f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_SHUTDOWN: 1953f8829a4aSRandall Stewart /* Here we use the RTO of the destination. */ 1954f8829a4aSRandall Stewart if ((stcb == NULL) || (net == NULL)) { 1955ad81507eSRandall Stewart return; 1956f8829a4aSRandall Stewart } 1957f8829a4aSRandall Stewart if (net->RTO == 0) { 1958f8829a4aSRandall Stewart to_ticks = MSEC_TO_TICKS(stcb->asoc.initial_rto); 1959f8829a4aSRandall Stewart } else { 1960f8829a4aSRandall Stewart to_ticks = MSEC_TO_TICKS(net->RTO); 1961f8829a4aSRandall Stewart } 1962f8829a4aSRandall Stewart tmr = &net->rxt_timer; 1963f8829a4aSRandall Stewart break; 1964f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_HEARTBEAT: 1965f8829a4aSRandall Stewart /* 1966f8829a4aSRandall Stewart * the net is used here so that we can add in the RTO. Even 1967f8829a4aSRandall Stewart * though we use a different timer. We also add the HB timer 1968f8829a4aSRandall Stewart * PLUS a random jitter. 1969f8829a4aSRandall Stewart */ 1970ad81507eSRandall Stewart if ((inp == NULL) || (stcb == NULL)) { 1971ad81507eSRandall Stewart return; 1972ad81507eSRandall Stewart } else { 1973f8829a4aSRandall Stewart uint32_t rndval; 1974f8829a4aSRandall Stewart uint8_t this_random; 1975f8829a4aSRandall Stewart int cnt_of_unconf = 0; 1976f8829a4aSRandall Stewart struct sctp_nets *lnet; 1977f8829a4aSRandall Stewart 1978f8829a4aSRandall Stewart TAILQ_FOREACH(lnet, &stcb->asoc.nets, sctp_next) { 1979f8829a4aSRandall Stewart if ((lnet->dest_state & SCTP_ADDR_UNCONFIRMED) && 1980f8829a4aSRandall Stewart (lnet->dest_state & SCTP_ADDR_REACHABLE)) { 1981f8829a4aSRandall Stewart cnt_of_unconf++; 1982f8829a4aSRandall Stewart } 1983f8829a4aSRandall Stewart } 1984f8829a4aSRandall Stewart if (cnt_of_unconf) { 19853c503c28SRandall Stewart net = lnet = NULL; 1986ad81507eSRandall Stewart (void)sctp_heartbeat_timer(inp, stcb, lnet, cnt_of_unconf); 1987f8829a4aSRandall Stewart } 1988f8829a4aSRandall Stewart if (stcb->asoc.hb_random_idx > 3) { 1989f8829a4aSRandall Stewart rndval = sctp_select_initial_TSN(&inp->sctp_ep); 1990f8829a4aSRandall Stewart memcpy(stcb->asoc.hb_random_values, &rndval, 1991f8829a4aSRandall Stewart sizeof(stcb->asoc.hb_random_values)); 1992f8829a4aSRandall Stewart stcb->asoc.hb_random_idx = 0; 199342551e99SRandall Stewart } 1994f8829a4aSRandall Stewart this_random = stcb->asoc.hb_random_values[stcb->asoc.hb_random_idx]; 1995f8829a4aSRandall Stewart stcb->asoc.hb_random_idx++; 1996f8829a4aSRandall Stewart stcb->asoc.hb_ect_randombit = 0; 1997f8829a4aSRandall Stewart /* 1998f8829a4aSRandall Stewart * this_random will be 0 - 256 ms RTO is in ms. 1999f8829a4aSRandall Stewart */ 2000f8829a4aSRandall Stewart if ((stcb->asoc.hb_is_disabled) && 2001f8829a4aSRandall Stewart (cnt_of_unconf == 0)) { 2002ad81507eSRandall Stewart return; 2003f8829a4aSRandall Stewart } 2004f8829a4aSRandall Stewart if (net) { 2005f8829a4aSRandall Stewart int delay; 2006f8829a4aSRandall Stewart 2007f8829a4aSRandall Stewart delay = stcb->asoc.heart_beat_delay; 2008f8829a4aSRandall Stewart TAILQ_FOREACH(lnet, &stcb->asoc.nets, sctp_next) { 2009f8829a4aSRandall Stewart if ((lnet->dest_state & SCTP_ADDR_UNCONFIRMED) && 2010f8829a4aSRandall Stewart ((lnet->dest_state & SCTP_ADDR_OUT_OF_SCOPE) == 0) && 2011f8829a4aSRandall Stewart (lnet->dest_state & SCTP_ADDR_REACHABLE)) { 2012f8829a4aSRandall Stewart delay = 0; 2013f8829a4aSRandall Stewart } 2014f8829a4aSRandall Stewart } 2015f8829a4aSRandall Stewart if (net->RTO == 0) { 2016f8829a4aSRandall Stewart /* Never been checked */ 2017f8829a4aSRandall Stewart to_ticks = this_random + stcb->asoc.initial_rto + delay; 2018f8829a4aSRandall Stewart } else { 2019f8829a4aSRandall Stewart /* set rto_val to the ms */ 2020f8829a4aSRandall Stewart to_ticks = delay + net->RTO + this_random; 2021f8829a4aSRandall Stewart } 2022f8829a4aSRandall Stewart } else { 2023f8829a4aSRandall Stewart if (cnt_of_unconf) { 2024f8829a4aSRandall Stewart to_ticks = this_random + stcb->asoc.initial_rto; 2025f8829a4aSRandall Stewart } else { 2026f8829a4aSRandall Stewart to_ticks = stcb->asoc.heart_beat_delay + this_random + stcb->asoc.initial_rto; 2027f8829a4aSRandall Stewart } 2028f8829a4aSRandall Stewart } 2029f8829a4aSRandall Stewart /* 2030f8829a4aSRandall Stewart * Now we must convert the to_ticks that are now in 2031f8829a4aSRandall Stewart * ms to ticks. 2032f8829a4aSRandall Stewart */ 2033f8829a4aSRandall Stewart to_ticks = MSEC_TO_TICKS(to_ticks); 2034f8829a4aSRandall Stewart tmr = &stcb->asoc.hb_timer; 2035f8829a4aSRandall Stewart } 2036f8829a4aSRandall Stewart break; 2037f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_COOKIE: 2038f8829a4aSRandall Stewart /* 2039f8829a4aSRandall Stewart * Here we can use the RTO timer from the network since one 2040f8829a4aSRandall Stewart * RTT was compelete. If a retran happened then we will be 2041f8829a4aSRandall Stewart * using the RTO initial value. 2042f8829a4aSRandall Stewart */ 2043f8829a4aSRandall Stewart if ((stcb == NULL) || (net == NULL)) { 2044ad81507eSRandall Stewart return; 2045f8829a4aSRandall Stewart } 2046f8829a4aSRandall Stewart if (net->RTO == 0) { 2047f8829a4aSRandall Stewart to_ticks = MSEC_TO_TICKS(stcb->asoc.initial_rto); 2048f8829a4aSRandall Stewart } else { 2049f8829a4aSRandall Stewart to_ticks = MSEC_TO_TICKS(net->RTO); 2050f8829a4aSRandall Stewart } 2051f8829a4aSRandall Stewart tmr = &net->rxt_timer; 2052f8829a4aSRandall Stewart break; 2053f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_NEWCOOKIE: 2054f8829a4aSRandall Stewart /* 2055f8829a4aSRandall Stewart * nothing needed but the endpoint here ususually about 60 2056f8829a4aSRandall Stewart * minutes. 2057f8829a4aSRandall Stewart */ 2058ad81507eSRandall Stewart if (inp == NULL) { 2059ad81507eSRandall Stewart return; 2060ad81507eSRandall Stewart } 2061f8829a4aSRandall Stewart tmr = &inp->sctp_ep.signature_change; 2062f8829a4aSRandall Stewart to_ticks = inp->sctp_ep.sctp_timeoutticks[SCTP_TIMER_SIGNATURE]; 2063f8829a4aSRandall Stewart break; 2064f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_ASOCKILL: 2065f8829a4aSRandall Stewart if (stcb == NULL) { 2066ad81507eSRandall Stewart return; 2067f8829a4aSRandall Stewart } 2068f8829a4aSRandall Stewart tmr = &stcb->asoc.strreset_timer; 2069f8829a4aSRandall Stewart to_ticks = MSEC_TO_TICKS(SCTP_ASOC_KILL_TIMEOUT); 2070f8829a4aSRandall Stewart break; 2071f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_INPKILL: 2072f8829a4aSRandall Stewart /* 2073f8829a4aSRandall Stewart * The inp is setup to die. We re-use the signature_chage 2074f8829a4aSRandall Stewart * timer since that has stopped and we are in the GONE 2075f8829a4aSRandall Stewart * state. 2076f8829a4aSRandall Stewart */ 2077ad81507eSRandall Stewart if (inp == NULL) { 2078ad81507eSRandall Stewart return; 2079ad81507eSRandall Stewart } 2080f8829a4aSRandall Stewart tmr = &inp->sctp_ep.signature_change; 2081f8829a4aSRandall Stewart to_ticks = MSEC_TO_TICKS(SCTP_INP_KILL_TIMEOUT); 2082f8829a4aSRandall Stewart break; 2083f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_PATHMTURAISE: 2084f8829a4aSRandall Stewart /* 2085f8829a4aSRandall Stewart * Here we use the value found in the EP for PMTU ususually 2086f8829a4aSRandall Stewart * about 10 minutes. 2087f8829a4aSRandall Stewart */ 2088ad81507eSRandall Stewart if ((stcb == NULL) || (inp == NULL)) { 2089ad81507eSRandall Stewart return; 2090f8829a4aSRandall Stewart } 2091f8829a4aSRandall Stewart if (net == NULL) { 2092ad81507eSRandall Stewart return; 2093f8829a4aSRandall Stewart } 2094f8829a4aSRandall Stewart to_ticks = inp->sctp_ep.sctp_timeoutticks[SCTP_TIMER_PMTU]; 2095f8829a4aSRandall Stewart tmr = &net->pmtu_timer; 2096f8829a4aSRandall Stewart break; 2097f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_SHUTDOWNACK: 2098f8829a4aSRandall Stewart /* Here we use the RTO of the destination */ 2099f8829a4aSRandall Stewart if ((stcb == NULL) || (net == NULL)) { 2100ad81507eSRandall Stewart return; 2101f8829a4aSRandall Stewart } 2102f8829a4aSRandall Stewart if (net->RTO == 0) { 2103f8829a4aSRandall Stewart to_ticks = MSEC_TO_TICKS(stcb->asoc.initial_rto); 2104f8829a4aSRandall Stewart } else { 2105f8829a4aSRandall Stewart to_ticks = MSEC_TO_TICKS(net->RTO); 2106f8829a4aSRandall Stewart } 2107f8829a4aSRandall Stewart tmr = &net->rxt_timer; 2108f8829a4aSRandall Stewart break; 2109f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_SHUTDOWNGUARD: 2110f8829a4aSRandall Stewart /* 2111f8829a4aSRandall Stewart * Here we use the endpoints shutdown guard timer usually 2112f8829a4aSRandall Stewart * about 3 minutes. 2113f8829a4aSRandall Stewart */ 2114ad81507eSRandall Stewart if ((inp == NULL) || (stcb == NULL)) { 2115ad81507eSRandall Stewart return; 2116f8829a4aSRandall Stewart } 2117f8829a4aSRandall Stewart to_ticks = inp->sctp_ep.sctp_timeoutticks[SCTP_TIMER_MAXSHUTDOWN]; 2118f8829a4aSRandall Stewart tmr = &stcb->asoc.shut_guard_timer; 2119f8829a4aSRandall Stewart break; 2120f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_STRRESET: 2121f8829a4aSRandall Stewart /* 21221b649582SRandall Stewart * Here the timer comes from the stcb but its value is from 21231b649582SRandall Stewart * the net's RTO. 2124f8829a4aSRandall Stewart */ 2125f8829a4aSRandall Stewart if ((stcb == NULL) || (net == NULL)) { 2126ad81507eSRandall Stewart return; 2127f8829a4aSRandall Stewart } 2128f8829a4aSRandall Stewart if (net->RTO == 0) { 2129f8829a4aSRandall Stewart to_ticks = MSEC_TO_TICKS(stcb->asoc.initial_rto); 2130f8829a4aSRandall Stewart } else { 2131f8829a4aSRandall Stewart to_ticks = MSEC_TO_TICKS(net->RTO); 2132f8829a4aSRandall Stewart } 2133f8829a4aSRandall Stewart tmr = &stcb->asoc.strreset_timer; 2134f8829a4aSRandall Stewart break; 2135f8829a4aSRandall Stewart 2136f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_EARLYFR: 2137f8829a4aSRandall Stewart { 2138f8829a4aSRandall Stewart unsigned int msec; 2139f8829a4aSRandall Stewart 2140f8829a4aSRandall Stewart if ((stcb == NULL) || (net == NULL)) { 2141ad81507eSRandall Stewart return; 2142f8829a4aSRandall Stewart } 2143f8829a4aSRandall Stewart if (net->flight_size > net->cwnd) { 2144f8829a4aSRandall Stewart /* no need to start */ 2145ad81507eSRandall Stewart return; 2146f8829a4aSRandall Stewart } 2147f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_earlyfrstart); 2148f8829a4aSRandall Stewart if (net->lastsa == 0) { 2149f8829a4aSRandall Stewart /* Hmm no rtt estimate yet? */ 2150f8829a4aSRandall Stewart msec = stcb->asoc.initial_rto >> 2; 2151f8829a4aSRandall Stewart } else { 2152f8829a4aSRandall Stewart msec = ((net->lastsa >> 2) + net->lastsv) >> 1; 2153f8829a4aSRandall Stewart } 2154f8829a4aSRandall Stewart if (msec < sctp_early_fr_msec) { 2155f8829a4aSRandall Stewart msec = sctp_early_fr_msec; 2156f8829a4aSRandall Stewart if (msec < SCTP_MINFR_MSEC_FLOOR) { 2157f8829a4aSRandall Stewart msec = SCTP_MINFR_MSEC_FLOOR; 2158f8829a4aSRandall Stewart } 2159f8829a4aSRandall Stewart } 2160f8829a4aSRandall Stewart to_ticks = MSEC_TO_TICKS(msec); 2161f8829a4aSRandall Stewart tmr = &net->fr_timer; 2162f8829a4aSRandall Stewart } 2163f8829a4aSRandall Stewart break; 2164f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_ASCONF: 2165f8829a4aSRandall Stewart /* 21661b649582SRandall Stewart * Here the timer comes from the stcb but its value is from 21671b649582SRandall Stewart * the net's RTO. 2168f8829a4aSRandall Stewart */ 2169f8829a4aSRandall Stewart if ((stcb == NULL) || (net == NULL)) { 2170ad81507eSRandall Stewart return; 2171f8829a4aSRandall Stewart } 2172f8829a4aSRandall Stewart if (net->RTO == 0) { 2173f8829a4aSRandall Stewart to_ticks = MSEC_TO_TICKS(stcb->asoc.initial_rto); 2174f8829a4aSRandall Stewart } else { 2175f8829a4aSRandall Stewart to_ticks = MSEC_TO_TICKS(net->RTO); 2176f8829a4aSRandall Stewart } 2177f8829a4aSRandall Stewart tmr = &stcb->asoc.asconf_timer; 2178f8829a4aSRandall Stewart break; 2179851b7298SRandall Stewart case SCTP_TIMER_TYPE_PRIM_DELETED: 2180851b7298SRandall Stewart if ((stcb == NULL) || (net != NULL)) { 2181851b7298SRandall Stewart return; 2182851b7298SRandall Stewart } 2183851b7298SRandall Stewart to_ticks = MSEC_TO_TICKS(stcb->asoc.initial_rto); 2184851b7298SRandall Stewart tmr = &stcb->asoc.delete_prim_timer; 2185851b7298SRandall Stewart break; 2186f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_AUTOCLOSE: 2187f8829a4aSRandall Stewart if (stcb == NULL) { 2188ad81507eSRandall Stewart return; 2189f8829a4aSRandall Stewart } 2190f8829a4aSRandall Stewart if (stcb->asoc.sctp_autoclose_ticks == 0) { 2191f8829a4aSRandall Stewart /* 2192f8829a4aSRandall Stewart * Really an error since stcb is NOT set to 2193f8829a4aSRandall Stewart * autoclose 2194f8829a4aSRandall Stewart */ 2195ad81507eSRandall Stewart return; 2196f8829a4aSRandall Stewart } 2197f8829a4aSRandall Stewart to_ticks = stcb->asoc.sctp_autoclose_ticks; 2198f8829a4aSRandall Stewart tmr = &stcb->asoc.autoclose_timer; 2199f8829a4aSRandall Stewart break; 2200f8829a4aSRandall Stewart default: 2201ad81507eSRandall Stewart SCTPDBG(SCTP_DEBUG_TIMER1, "%s: Unknown timer type %d\n", 2202ad81507eSRandall Stewart __FUNCTION__, t_type); 2203ad81507eSRandall Stewart return; 2204f8829a4aSRandall Stewart break; 2205f8829a4aSRandall Stewart }; 2206f8829a4aSRandall Stewart if ((to_ticks <= 0) || (tmr == NULL)) { 2207ad81507eSRandall Stewart SCTPDBG(SCTP_DEBUG_TIMER1, "%s: %d:software error to_ticks:%d tmr:%p not set ??\n", 2208ad81507eSRandall Stewart __FUNCTION__, t_type, to_ticks, tmr); 2209ad81507eSRandall Stewart return; 2210f8829a4aSRandall Stewart } 2211139bc87fSRandall Stewart if (SCTP_OS_TIMER_PENDING(&tmr->timer)) { 2212f8829a4aSRandall Stewart /* 2213f8829a4aSRandall Stewart * we do NOT allow you to have it already running. if it is 2214f8829a4aSRandall Stewart * we leave the current one up unchanged 2215f8829a4aSRandall Stewart */ 2216ad81507eSRandall Stewart return; 2217f8829a4aSRandall Stewart } 2218f8829a4aSRandall Stewart /* At this point we can proceed */ 2219f8829a4aSRandall Stewart if (t_type == SCTP_TIMER_TYPE_SEND) { 2220f8829a4aSRandall Stewart stcb->asoc.num_send_timers_up++; 2221f8829a4aSRandall Stewart } 2222a5d547adSRandall Stewart tmr->stopped_from = 0; 2223f8829a4aSRandall Stewart tmr->type = t_type; 2224f8829a4aSRandall Stewart tmr->ep = (void *)inp; 2225f8829a4aSRandall Stewart tmr->tcb = (void *)stcb; 2226f8829a4aSRandall Stewart tmr->net = (void *)net; 2227f8829a4aSRandall Stewart tmr->self = (void *)tmr; 2228c4739e2fSRandall Stewart tmr->ticks = sctp_get_tick_count(); 2229ad81507eSRandall Stewart (void)SCTP_OS_TIMER_START(&tmr->timer, to_ticks, sctp_timeout_handler, tmr); 2230ad81507eSRandall Stewart return; 2231f8829a4aSRandall Stewart } 2232f8829a4aSRandall Stewart 22336e55db54SRandall Stewart void 2234f8829a4aSRandall Stewart sctp_timer_stop(int t_type, struct sctp_inpcb *inp, struct sctp_tcb *stcb, 2235a5d547adSRandall Stewart struct sctp_nets *net, uint32_t from) 2236f8829a4aSRandall Stewart { 2237f8829a4aSRandall Stewart struct sctp_timer *tmr; 2238f8829a4aSRandall Stewart 2239f8829a4aSRandall Stewart if ((t_type != SCTP_TIMER_TYPE_ADDR_WQ) && 2240f8829a4aSRandall Stewart (inp == NULL)) 22416e55db54SRandall Stewart return; 2242f8829a4aSRandall Stewart 2243f8829a4aSRandall Stewart tmr = NULL; 2244f8829a4aSRandall Stewart if (stcb) { 2245f8829a4aSRandall Stewart SCTP_TCB_LOCK_ASSERT(stcb); 2246f8829a4aSRandall Stewart } 2247f8829a4aSRandall Stewart switch (t_type) { 2248d61a0ae0SRandall Stewart case SCTP_TIMER_TYPE_ZERO_COPY: 2249d61a0ae0SRandall Stewart tmr = &inp->sctp_ep.zero_copy_timer; 2250d61a0ae0SRandall Stewart break; 2251ad21a364SRandall Stewart case SCTP_TIMER_TYPE_ZCOPY_SENDQ: 2252ad21a364SRandall Stewart tmr = &inp->sctp_ep.zero_copy_sendq_timer; 2253ad21a364SRandall Stewart break; 2254f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_ADDR_WQ: 2255f8829a4aSRandall Stewart tmr = &sctppcbinfo.addr_wq_timer; 2256f8829a4aSRandall Stewart break; 2257f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_EARLYFR: 2258f8829a4aSRandall Stewart if ((stcb == NULL) || (net == NULL)) { 22596e55db54SRandall Stewart return; 2260f8829a4aSRandall Stewart } 2261f8829a4aSRandall Stewart tmr = &net->fr_timer; 2262f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_earlyfrstop); 2263f8829a4aSRandall Stewart break; 2264f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_ITERATOR: 2265f8829a4aSRandall Stewart { 2266f8829a4aSRandall Stewart struct sctp_iterator *it; 2267f8829a4aSRandall Stewart 2268f8829a4aSRandall Stewart it = (struct sctp_iterator *)inp; 2269f8829a4aSRandall Stewart tmr = &it->tmr; 2270f8829a4aSRandall Stewart } 2271f8829a4aSRandall Stewart break; 2272f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_SEND: 2273f8829a4aSRandall Stewart if ((stcb == NULL) || (net == NULL)) { 22746e55db54SRandall Stewart return; 2275f8829a4aSRandall Stewart } 2276f8829a4aSRandall Stewart tmr = &net->rxt_timer; 2277f8829a4aSRandall Stewart break; 2278f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_INIT: 2279f8829a4aSRandall Stewart if ((stcb == NULL) || (net == NULL)) { 22806e55db54SRandall Stewart return; 2281f8829a4aSRandall Stewart } 2282f8829a4aSRandall Stewart tmr = &net->rxt_timer; 2283f8829a4aSRandall Stewart break; 2284f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_RECV: 2285f8829a4aSRandall Stewart if (stcb == NULL) { 22866e55db54SRandall Stewart return; 2287f8829a4aSRandall Stewart } 2288f8829a4aSRandall Stewart tmr = &stcb->asoc.dack_timer; 2289f8829a4aSRandall Stewart break; 2290f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_SHUTDOWN: 2291f8829a4aSRandall Stewart if ((stcb == NULL) || (net == NULL)) { 22926e55db54SRandall Stewart return; 2293f8829a4aSRandall Stewart } 2294f8829a4aSRandall Stewart tmr = &net->rxt_timer; 2295f8829a4aSRandall Stewart break; 2296f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_HEARTBEAT: 2297f8829a4aSRandall Stewart if (stcb == NULL) { 22986e55db54SRandall Stewart return; 2299f8829a4aSRandall Stewart } 2300f8829a4aSRandall Stewart tmr = &stcb->asoc.hb_timer; 2301f8829a4aSRandall Stewart break; 2302f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_COOKIE: 2303f8829a4aSRandall Stewart if ((stcb == NULL) || (net == NULL)) { 23046e55db54SRandall Stewart return; 2305f8829a4aSRandall Stewart } 2306f8829a4aSRandall Stewart tmr = &net->rxt_timer; 2307f8829a4aSRandall Stewart break; 2308f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_NEWCOOKIE: 2309f8829a4aSRandall Stewart /* nothing needed but the endpoint here */ 2310f8829a4aSRandall Stewart tmr = &inp->sctp_ep.signature_change; 2311f8829a4aSRandall Stewart /* 2312f8829a4aSRandall Stewart * We re-use the newcookie timer for the INP kill timer. We 2313f8829a4aSRandall Stewart * must assure that we do not kill it by accident. 2314f8829a4aSRandall Stewart */ 2315f8829a4aSRandall Stewart break; 2316f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_ASOCKILL: 2317f8829a4aSRandall Stewart /* 2318f8829a4aSRandall Stewart * Stop the asoc kill timer. 2319f8829a4aSRandall Stewart */ 2320f8829a4aSRandall Stewart if (stcb == NULL) { 23216e55db54SRandall Stewart return; 2322f8829a4aSRandall Stewart } 2323f8829a4aSRandall Stewart tmr = &stcb->asoc.strreset_timer; 2324f8829a4aSRandall Stewart break; 2325f8829a4aSRandall Stewart 2326f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_INPKILL: 2327f8829a4aSRandall Stewart /* 2328f8829a4aSRandall Stewart * The inp is setup to die. We re-use the signature_chage 2329f8829a4aSRandall Stewart * timer since that has stopped and we are in the GONE 2330f8829a4aSRandall Stewart * state. 2331f8829a4aSRandall Stewart */ 2332f8829a4aSRandall Stewart tmr = &inp->sctp_ep.signature_change; 2333f8829a4aSRandall Stewart break; 2334f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_PATHMTURAISE: 2335f8829a4aSRandall Stewart if ((stcb == NULL) || (net == NULL)) { 23366e55db54SRandall Stewart return; 2337f8829a4aSRandall Stewart } 2338f8829a4aSRandall Stewart tmr = &net->pmtu_timer; 2339f8829a4aSRandall Stewart break; 2340f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_SHUTDOWNACK: 2341f8829a4aSRandall Stewart if ((stcb == NULL) || (net == NULL)) { 23426e55db54SRandall Stewart return; 2343f8829a4aSRandall Stewart } 2344f8829a4aSRandall Stewart tmr = &net->rxt_timer; 2345f8829a4aSRandall Stewart break; 2346f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_SHUTDOWNGUARD: 2347f8829a4aSRandall Stewart if (stcb == NULL) { 23486e55db54SRandall Stewart return; 2349f8829a4aSRandall Stewart } 2350f8829a4aSRandall Stewart tmr = &stcb->asoc.shut_guard_timer; 2351f8829a4aSRandall Stewart break; 2352f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_STRRESET: 2353f8829a4aSRandall Stewart if (stcb == NULL) { 23546e55db54SRandall Stewart return; 2355f8829a4aSRandall Stewart } 2356f8829a4aSRandall Stewart tmr = &stcb->asoc.strreset_timer; 2357f8829a4aSRandall Stewart break; 2358f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_ASCONF: 2359f8829a4aSRandall Stewart if (stcb == NULL) { 23606e55db54SRandall Stewart return; 2361f8829a4aSRandall Stewart } 2362f8829a4aSRandall Stewart tmr = &stcb->asoc.asconf_timer; 2363f8829a4aSRandall Stewart break; 2364851b7298SRandall Stewart case SCTP_TIMER_TYPE_PRIM_DELETED: 2365851b7298SRandall Stewart if (stcb == NULL) { 2366851b7298SRandall Stewart return; 2367851b7298SRandall Stewart } 2368851b7298SRandall Stewart tmr = &stcb->asoc.delete_prim_timer; 2369851b7298SRandall Stewart break; 2370f8829a4aSRandall Stewart case SCTP_TIMER_TYPE_AUTOCLOSE: 2371f8829a4aSRandall Stewart if (stcb == NULL) { 23726e55db54SRandall Stewart return; 2373f8829a4aSRandall Stewart } 2374f8829a4aSRandall Stewart tmr = &stcb->asoc.autoclose_timer; 2375f8829a4aSRandall Stewart break; 2376f8829a4aSRandall Stewart default: 2377ad81507eSRandall Stewart SCTPDBG(SCTP_DEBUG_TIMER1, "%s: Unknown timer type %d\n", 2378ad81507eSRandall Stewart __FUNCTION__, t_type); 2379f8829a4aSRandall Stewart break; 2380f8829a4aSRandall Stewart }; 2381f8829a4aSRandall Stewart if (tmr == NULL) { 23826e55db54SRandall Stewart return; 2383f8829a4aSRandall Stewart } 2384f8829a4aSRandall Stewart if ((tmr->type != t_type) && tmr->type) { 2385f8829a4aSRandall Stewart /* 2386f8829a4aSRandall Stewart * Ok we have a timer that is under joint use. Cookie timer 2387f8829a4aSRandall Stewart * per chance with the SEND timer. We therefore are NOT 2388f8829a4aSRandall Stewart * running the timer that the caller wants stopped. So just 2389f8829a4aSRandall Stewart * return. 2390f8829a4aSRandall Stewart */ 23916e55db54SRandall Stewart return; 2392f8829a4aSRandall Stewart } 2393ad81507eSRandall Stewart if ((t_type == SCTP_TIMER_TYPE_SEND) && (stcb != NULL)) { 2394f8829a4aSRandall Stewart stcb->asoc.num_send_timers_up--; 2395f8829a4aSRandall Stewart if (stcb->asoc.num_send_timers_up < 0) { 2396f8829a4aSRandall Stewart stcb->asoc.num_send_timers_up = 0; 2397f8829a4aSRandall Stewart } 2398f8829a4aSRandall Stewart } 2399f8829a4aSRandall Stewart tmr->self = NULL; 2400a5d547adSRandall Stewart tmr->stopped_from = from; 24016e55db54SRandall Stewart (void)SCTP_OS_TIMER_STOP(&tmr->timer); 24026e55db54SRandall Stewart return; 2403f8829a4aSRandall Stewart } 2404f8829a4aSRandall Stewart 2405f8829a4aSRandall Stewart #ifdef SCTP_USE_ADLER32 2406f8829a4aSRandall Stewart static uint32_t 2407f8829a4aSRandall Stewart update_adler32(uint32_t adler, uint8_t * buf, int32_t len) 2408f8829a4aSRandall Stewart { 2409f8829a4aSRandall Stewart uint32_t s1 = adler & 0xffff; 2410f8829a4aSRandall Stewart uint32_t s2 = (adler >> 16) & 0xffff; 2411f8829a4aSRandall Stewart int n; 2412f8829a4aSRandall Stewart 2413f8829a4aSRandall Stewart for (n = 0; n < len; n++, buf++) { 2414f8829a4aSRandall Stewart /* s1 = (s1 + buf[n]) % BASE */ 2415f8829a4aSRandall Stewart /* first we add */ 2416f8829a4aSRandall Stewart s1 = (s1 + *buf); 2417f8829a4aSRandall Stewart /* 2418f8829a4aSRandall Stewart * now if we need to, we do a mod by subtracting. It seems a 2419f8829a4aSRandall Stewart * bit faster since I really will only ever do one subtract 2420f8829a4aSRandall Stewart * at the MOST, since buf[n] is a max of 255. 2421f8829a4aSRandall Stewart */ 2422f8829a4aSRandall Stewart if (s1 >= SCTP_ADLER32_BASE) { 2423f8829a4aSRandall Stewart s1 -= SCTP_ADLER32_BASE; 2424f8829a4aSRandall Stewart } 2425f8829a4aSRandall Stewart /* s2 = (s2 + s1) % BASE */ 2426f8829a4aSRandall Stewart /* first we add */ 2427f8829a4aSRandall Stewart s2 = (s2 + s1); 2428f8829a4aSRandall Stewart /* 2429f8829a4aSRandall Stewart * again, it is more efficent (it seems) to subtract since 2430f8829a4aSRandall Stewart * the most s2 will ever be is (BASE-1 + BASE-1) in the 2431f8829a4aSRandall Stewart * worse case. This would then be (2 * BASE) - 2, which will 2432f8829a4aSRandall Stewart * still only do one subtract. On Intel this is much better 2433f8829a4aSRandall Stewart * to do this way and avoid the divide. Have not -pg'd on 2434f8829a4aSRandall Stewart * sparc. 2435f8829a4aSRandall Stewart */ 2436f8829a4aSRandall Stewart if (s2 >= SCTP_ADLER32_BASE) { 2437f8829a4aSRandall Stewart s2 -= SCTP_ADLER32_BASE; 2438f8829a4aSRandall Stewart } 2439f8829a4aSRandall Stewart } 2440f8829a4aSRandall Stewart /* Return the adler32 of the bytes buf[0..len-1] */ 2441f8829a4aSRandall Stewart return ((s2 << 16) + s1); 2442f8829a4aSRandall Stewart } 2443f8829a4aSRandall Stewart 2444f8829a4aSRandall Stewart #endif 2445f8829a4aSRandall Stewart 2446f8829a4aSRandall Stewart 2447f8829a4aSRandall Stewart uint32_t 2448f8829a4aSRandall Stewart sctp_calculate_len(struct mbuf *m) 2449f8829a4aSRandall Stewart { 2450f8829a4aSRandall Stewart uint32_t tlen = 0; 2451f8829a4aSRandall Stewart struct mbuf *at; 2452f8829a4aSRandall Stewart 2453f8829a4aSRandall Stewart at = m; 2454f8829a4aSRandall Stewart while (at) { 2455139bc87fSRandall Stewart tlen += SCTP_BUF_LEN(at); 2456139bc87fSRandall Stewart at = SCTP_BUF_NEXT(at); 2457f8829a4aSRandall Stewart } 2458f8829a4aSRandall Stewart return (tlen); 2459f8829a4aSRandall Stewart } 2460f8829a4aSRandall Stewart 2461f8829a4aSRandall Stewart #if defined(SCTP_WITH_NO_CSUM) 2462f8829a4aSRandall Stewart 2463f8829a4aSRandall Stewart uint32_t 2464f8829a4aSRandall Stewart sctp_calculate_sum(struct mbuf *m, int32_t * pktlen, uint32_t offset) 2465f8829a4aSRandall Stewart { 2466f8829a4aSRandall Stewart /* 2467f8829a4aSRandall Stewart * given a mbuf chain with a packetheader offset by 'offset' 2468f8829a4aSRandall Stewart * pointing at a sctphdr (with csum set to 0) go through the chain 24694c9179adSRandall Stewart * of SCTP_BUF_NEXT()'s and calculate the SCTP checksum. This also 24704c9179adSRandall Stewart * has a side bonus as it will calculate the total length of the 24714c9179adSRandall Stewart * mbuf chain. Note: if offset is greater than the total mbuf 24724c9179adSRandall Stewart * length, checksum=1, pktlen=0 is returned (ie. no real error code) 2473f8829a4aSRandall Stewart */ 2474f8829a4aSRandall Stewart if (pktlen == NULL) 2475f8829a4aSRandall Stewart return (0); 2476f8829a4aSRandall Stewart *pktlen = sctp_calculate_len(m); 2477f8829a4aSRandall Stewart return (0); 2478f8829a4aSRandall Stewart } 2479f8829a4aSRandall Stewart 2480f8829a4aSRandall Stewart #elif defined(SCTP_USE_INCHKSUM) 2481f8829a4aSRandall Stewart 2482f8829a4aSRandall Stewart #include <machine/in_cksum.h> 2483f8829a4aSRandall Stewart 2484f8829a4aSRandall Stewart uint32_t 2485f8829a4aSRandall Stewart sctp_calculate_sum(struct mbuf *m, int32_t * pktlen, uint32_t offset) 2486f8829a4aSRandall Stewart { 2487f8829a4aSRandall Stewart /* 2488f8829a4aSRandall Stewart * given a mbuf chain with a packetheader offset by 'offset' 2489f8829a4aSRandall Stewart * pointing at a sctphdr (with csum set to 0) go through the chain 24904c9179adSRandall Stewart * of SCTP_BUF_NEXT()'s and calculate the SCTP checksum. This also 24914c9179adSRandall Stewart * has a side bonus as it will calculate the total length of the 24924c9179adSRandall Stewart * mbuf chain. Note: if offset is greater than the total mbuf 24934c9179adSRandall Stewart * length, checksum=1, pktlen=0 is returned (ie. no real error code) 2494f8829a4aSRandall Stewart */ 2495f8829a4aSRandall Stewart int32_t tlen = 0; 2496f8829a4aSRandall Stewart struct mbuf *at; 2497f8829a4aSRandall Stewart uint32_t the_sum, retsum; 2498f8829a4aSRandall Stewart 2499f8829a4aSRandall Stewart at = m; 2500f8829a4aSRandall Stewart while (at) { 2501139bc87fSRandall Stewart tlen += SCTP_BUF_LEN(at); 2502139bc87fSRandall Stewart at = SCTP_BUF_NEXT(at); 2503f8829a4aSRandall Stewart } 2504f8829a4aSRandall Stewart the_sum = (uint32_t) (in_cksum_skip(m, tlen, offset)); 2505f8829a4aSRandall Stewart if (pktlen != NULL) 2506f8829a4aSRandall Stewart *pktlen = (tlen - offset); 2507f8829a4aSRandall Stewart retsum = htons(the_sum); 2508f8829a4aSRandall Stewart return (the_sum); 2509f8829a4aSRandall Stewart } 2510f8829a4aSRandall Stewart 2511f8829a4aSRandall Stewart #else 2512f8829a4aSRandall Stewart 2513f8829a4aSRandall Stewart uint32_t 2514f8829a4aSRandall Stewart sctp_calculate_sum(struct mbuf *m, int32_t * pktlen, uint32_t offset) 2515f8829a4aSRandall Stewart { 2516f8829a4aSRandall Stewart /* 2517f8829a4aSRandall Stewart * given a mbuf chain with a packetheader offset by 'offset' 2518f8829a4aSRandall Stewart * pointing at a sctphdr (with csum set to 0) go through the chain 25194c9179adSRandall Stewart * of SCTP_BUF_NEXT()'s and calculate the SCTP checksum. This also 25204c9179adSRandall Stewart * has a side bonus as it will calculate the total length of the 25214c9179adSRandall Stewart * mbuf chain. Note: if offset is greater than the total mbuf 25224c9179adSRandall Stewart * length, checksum=1, pktlen=0 is returned (ie. no real error code) 2523f8829a4aSRandall Stewart */ 2524f8829a4aSRandall Stewart int32_t tlen = 0; 2525f8829a4aSRandall Stewart 2526f8829a4aSRandall Stewart #ifdef SCTP_USE_ADLER32 2527f8829a4aSRandall Stewart uint32_t base = 1L; 2528f8829a4aSRandall Stewart 2529f8829a4aSRandall Stewart #else 2530f8829a4aSRandall Stewart uint32_t base = 0xffffffff; 2531f8829a4aSRandall Stewart 25324c9179adSRandall Stewart #endif 2533f8829a4aSRandall Stewart struct mbuf *at; 2534f8829a4aSRandall Stewart 2535f8829a4aSRandall Stewart at = m; 2536f8829a4aSRandall Stewart /* find the correct mbuf and offset into mbuf */ 2537139bc87fSRandall Stewart while ((at != NULL) && (offset > (uint32_t) SCTP_BUF_LEN(at))) { 2538139bc87fSRandall Stewart offset -= SCTP_BUF_LEN(at); /* update remaining offset 2539139bc87fSRandall Stewart * left */ 2540139bc87fSRandall Stewart at = SCTP_BUF_NEXT(at); 2541f8829a4aSRandall Stewart } 2542f8829a4aSRandall Stewart while (at != NULL) { 2543139bc87fSRandall Stewart if ((SCTP_BUF_LEN(at) - offset) > 0) { 2544f8829a4aSRandall Stewart #ifdef SCTP_USE_ADLER32 2545f8829a4aSRandall Stewart base = update_adler32(base, 2546139bc87fSRandall Stewart (unsigned char *)(SCTP_BUF_AT(at, offset)), 2547139bc87fSRandall Stewart (unsigned int)(SCTP_BUF_LEN(at) - offset)); 2548f8829a4aSRandall Stewart #else 2549139bc87fSRandall Stewart if ((SCTP_BUF_LEN(at) - offset) < 4) { 2550f8829a4aSRandall Stewart /* Use old method if less than 4 bytes */ 2551f8829a4aSRandall Stewart base = old_update_crc32(base, 2552139bc87fSRandall Stewart (unsigned char *)(SCTP_BUF_AT(at, offset)), 2553139bc87fSRandall Stewart (unsigned int)(SCTP_BUF_LEN(at) - offset)); 2554f8829a4aSRandall Stewart } else { 2555f8829a4aSRandall Stewart base = update_crc32(base, 2556139bc87fSRandall Stewart (unsigned char *)(SCTP_BUF_AT(at, offset)), 2557139bc87fSRandall Stewart (unsigned int)(SCTP_BUF_LEN(at) - offset)); 2558f8829a4aSRandall Stewart } 25594c9179adSRandall Stewart #endif 2560139bc87fSRandall Stewart tlen += SCTP_BUF_LEN(at) - offset; 2561f8829a4aSRandall Stewart /* we only offset once into the first mbuf */ 2562f8829a4aSRandall Stewart } 2563f8829a4aSRandall Stewart if (offset) { 25644c9179adSRandall Stewart if (offset < (uint32_t) SCTP_BUF_LEN(at)) 2565f8829a4aSRandall Stewart offset = 0; 2566f8829a4aSRandall Stewart else 2567139bc87fSRandall Stewart offset -= SCTP_BUF_LEN(at); 2568f8829a4aSRandall Stewart } 2569139bc87fSRandall Stewart at = SCTP_BUF_NEXT(at); 2570f8829a4aSRandall Stewart } 2571f8829a4aSRandall Stewart if (pktlen != NULL) { 2572f8829a4aSRandall Stewart *pktlen = tlen; 2573f8829a4aSRandall Stewart } 2574f8829a4aSRandall Stewart #ifdef SCTP_USE_ADLER32 2575f8829a4aSRandall Stewart /* Adler32 */ 2576f8829a4aSRandall Stewart base = htonl(base); 2577f8829a4aSRandall Stewart #else 2578f8829a4aSRandall Stewart /* CRC-32c */ 2579f8829a4aSRandall Stewart base = sctp_csum_finalize(base); 2580f8829a4aSRandall Stewart #endif 2581f8829a4aSRandall Stewart return (base); 2582f8829a4aSRandall Stewart } 2583f8829a4aSRandall Stewart 2584f8829a4aSRandall Stewart 2585f8829a4aSRandall Stewart #endif 2586f8829a4aSRandall Stewart 2587f8829a4aSRandall Stewart void 2588f8829a4aSRandall Stewart sctp_mtu_size_reset(struct sctp_inpcb *inp, 258944b7479bSRandall Stewart struct sctp_association *asoc, uint32_t mtu) 2590f8829a4aSRandall Stewart { 2591f8829a4aSRandall Stewart /* 2592f8829a4aSRandall Stewart * Reset the P-MTU size on this association, this involves changing 2593f8829a4aSRandall Stewart * the asoc MTU, going through ANY chunk+overhead larger than mtu to 2594f8829a4aSRandall Stewart * allow the DF flag to be cleared. 2595f8829a4aSRandall Stewart */ 2596f8829a4aSRandall Stewart struct sctp_tmit_chunk *chk; 2597f8829a4aSRandall Stewart unsigned int eff_mtu, ovh; 2598f8829a4aSRandall Stewart 259917205eccSRandall Stewart #ifdef SCTP_PRINT_FOR_B_AND_M 2600ad81507eSRandall Stewart SCTP_PRINTF("sctp_mtu_size_reset(%p, asoc:%p mtu:%d\n", 260117205eccSRandall Stewart inp, asoc, mtu); 260217205eccSRandall Stewart #endif 2603f8829a4aSRandall Stewart asoc->smallest_mtu = mtu; 2604f8829a4aSRandall Stewart if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) { 2605f8829a4aSRandall Stewart ovh = SCTP_MIN_OVERHEAD; 2606f8829a4aSRandall Stewart } else { 2607f8829a4aSRandall Stewart ovh = SCTP_MIN_V4_OVERHEAD; 2608f8829a4aSRandall Stewart } 2609f8829a4aSRandall Stewart eff_mtu = mtu - ovh; 2610f8829a4aSRandall Stewart TAILQ_FOREACH(chk, &asoc->send_queue, sctp_next) { 2611f8829a4aSRandall Stewart 2612f8829a4aSRandall Stewart if (chk->send_size > eff_mtu) { 2613f8829a4aSRandall Stewart chk->flags |= CHUNK_FLAGS_FRAGMENT_OK; 2614f8829a4aSRandall Stewart } 2615f8829a4aSRandall Stewart } 2616f8829a4aSRandall Stewart TAILQ_FOREACH(chk, &asoc->sent_queue, sctp_next) { 2617f8829a4aSRandall Stewart if (chk->send_size > eff_mtu) { 2618f8829a4aSRandall Stewart chk->flags |= CHUNK_FLAGS_FRAGMENT_OK; 2619f8829a4aSRandall Stewart } 2620f8829a4aSRandall Stewart } 2621f8829a4aSRandall Stewart } 2622f8829a4aSRandall Stewart 2623f8829a4aSRandall Stewart 2624f8829a4aSRandall Stewart /* 2625f8829a4aSRandall Stewart * given an association and starting time of the current RTT period return 2626f42a358aSRandall Stewart * RTO in number of msecs net should point to the current network 2627f8829a4aSRandall Stewart */ 2628f8829a4aSRandall Stewart uint32_t 2629f8829a4aSRandall Stewart sctp_calculate_rto(struct sctp_tcb *stcb, 2630f8829a4aSRandall Stewart struct sctp_association *asoc, 2631f8829a4aSRandall Stewart struct sctp_nets *net, 263218e198d3SRandall Stewart struct timeval *told, 263318e198d3SRandall Stewart int safe) 2634f8829a4aSRandall Stewart { 263518e198d3SRandall Stewart /*- 2636f8829a4aSRandall Stewart * given an association and the starting time of the current RTT 2637f42a358aSRandall Stewart * period (in value1/value2) return RTO in number of msecs. 2638f8829a4aSRandall Stewart */ 2639f8829a4aSRandall Stewart int calc_time = 0; 2640f8829a4aSRandall Stewart int o_calctime; 26415e54f665SRandall Stewart uint32_t new_rto = 0; 2642f8829a4aSRandall Stewart int first_measure = 0; 264318e198d3SRandall Stewart struct timeval now, then, *old; 2644f8829a4aSRandall Stewart 264518e198d3SRandall Stewart /* Copy it out for sparc64 */ 264618e198d3SRandall Stewart if (safe == sctp_align_unsafe_makecopy) { 264718e198d3SRandall Stewart old = &then; 264818e198d3SRandall Stewart memcpy(&then, told, sizeof(struct timeval)); 264918e198d3SRandall Stewart } else if (safe == sctp_align_safe_nocopy) { 265018e198d3SRandall Stewart old = told; 265118e198d3SRandall Stewart } else { 265218e198d3SRandall Stewart /* error */ 265318e198d3SRandall Stewart SCTP_PRINTF("Huh, bad rto calc call\n"); 265418e198d3SRandall Stewart return (0); 265518e198d3SRandall Stewart } 2656f8829a4aSRandall Stewart /************************/ 2657f8829a4aSRandall Stewart /* 1. calculate new RTT */ 2658f8829a4aSRandall Stewart /************************/ 2659f8829a4aSRandall Stewart /* get the current time */ 26606e55db54SRandall Stewart (void)SCTP_GETTIME_TIMEVAL(&now); 2661f8829a4aSRandall Stewart /* compute the RTT value */ 2662f8829a4aSRandall Stewart if ((u_long)now.tv_sec > (u_long)old->tv_sec) { 2663f8829a4aSRandall Stewart calc_time = ((u_long)now.tv_sec - (u_long)old->tv_sec) * 1000; 2664f8829a4aSRandall Stewart if ((u_long)now.tv_usec > (u_long)old->tv_usec) { 2665f8829a4aSRandall Stewart calc_time += (((u_long)now.tv_usec - 2666f8829a4aSRandall Stewart (u_long)old->tv_usec) / 1000); 2667f8829a4aSRandall Stewart } else if ((u_long)now.tv_usec < (u_long)old->tv_usec) { 2668f8829a4aSRandall Stewart /* Borrow 1,000ms from current calculation */ 2669f8829a4aSRandall Stewart calc_time -= 1000; 2670f8829a4aSRandall Stewart /* Add in the slop over */ 2671f8829a4aSRandall Stewart calc_time += ((int)now.tv_usec / 1000); 2672f8829a4aSRandall Stewart /* Add in the pre-second ms's */ 2673f8829a4aSRandall Stewart calc_time += (((int)1000000 - (int)old->tv_usec) / 1000); 2674f8829a4aSRandall Stewart } 2675f8829a4aSRandall Stewart } else if ((u_long)now.tv_sec == (u_long)old->tv_sec) { 2676f8829a4aSRandall Stewart if ((u_long)now.tv_usec > (u_long)old->tv_usec) { 2677f8829a4aSRandall Stewart calc_time = ((u_long)now.tv_usec - 2678f8829a4aSRandall Stewart (u_long)old->tv_usec) / 1000; 2679f8829a4aSRandall Stewart } else if ((u_long)now.tv_usec < (u_long)old->tv_usec) { 2680f8829a4aSRandall Stewart /* impossible .. garbage in nothing out */ 26815e54f665SRandall Stewart goto calc_rto; 2682a5d547adSRandall Stewart } else if ((u_long)now.tv_usec == (u_long)old->tv_usec) { 2683a5d547adSRandall Stewart /* 2684a5d547adSRandall Stewart * We have to have 1 usec :-D this must be the 2685a5d547adSRandall Stewart * loopback. 2686a5d547adSRandall Stewart */ 2687a5d547adSRandall Stewart calc_time = 1; 2688f8829a4aSRandall Stewart } else { 2689f8829a4aSRandall Stewart /* impossible .. garbage in nothing out */ 26905e54f665SRandall Stewart goto calc_rto; 2691f8829a4aSRandall Stewart } 2692f8829a4aSRandall Stewart } else { 2693f8829a4aSRandall Stewart /* Clock wrapped? */ 26945e54f665SRandall Stewart goto calc_rto; 2695f8829a4aSRandall Stewart } 2696f8829a4aSRandall Stewart /***************************/ 2697f8829a4aSRandall Stewart /* 2. update RTTVAR & SRTT */ 2698f8829a4aSRandall Stewart /***************************/ 2699f8829a4aSRandall Stewart o_calctime = calc_time; 2700f8829a4aSRandall Stewart /* this is Van Jacobson's integer version */ 27019a972525SRandall Stewart if (net->RTO_measured) { 2702108df27cSRandall Stewart calc_time -= (net->lastsa >> SCTP_RTT_SHIFT); /* take away 1/8th when 2703108df27cSRandall Stewart * shift=3 */ 270480fefe0aSRandall Stewart if (sctp_logging_level & SCTP_RTTVAR_LOGGING_ENABLE) { 2705f8829a4aSRandall Stewart rto_logging(net, SCTP_LOG_RTTVAR); 270680fefe0aSRandall Stewart } 2707f8829a4aSRandall Stewart net->prev_rtt = o_calctime; 2708108df27cSRandall Stewart net->lastsa += calc_time; /* add 7/8th into sa when 2709108df27cSRandall Stewart * shift=3 */ 2710f8829a4aSRandall Stewart if (calc_time < 0) { 2711f8829a4aSRandall Stewart calc_time = -calc_time; 2712f8829a4aSRandall Stewart } 2713108df27cSRandall Stewart calc_time -= (net->lastsv >> SCTP_RTT_VAR_SHIFT); /* take away 1/4 when 2714108df27cSRandall Stewart * VAR shift=2 */ 2715f8829a4aSRandall Stewart net->lastsv += calc_time; 2716f8829a4aSRandall Stewart if (net->lastsv == 0) { 2717f8829a4aSRandall Stewart net->lastsv = SCTP_CLOCK_GRANULARITY; 2718f8829a4aSRandall Stewart } 2719f8829a4aSRandall Stewart } else { 2720f8829a4aSRandall Stewart /* First RTO measurment */ 27219a972525SRandall Stewart net->RTO_measured = 1; 2722108df27cSRandall Stewart net->lastsa = calc_time << SCTP_RTT_SHIFT; /* Multiply by 8 when 2723108df27cSRandall Stewart * shift=3 */ 2724108df27cSRandall Stewart net->lastsv = calc_time; 2725108df27cSRandall Stewart if (net->lastsv == 0) { 2726108df27cSRandall Stewart net->lastsv = SCTP_CLOCK_GRANULARITY; 2727108df27cSRandall Stewart } 2728f8829a4aSRandall Stewart first_measure = 1; 2729f8829a4aSRandall Stewart net->prev_rtt = o_calctime; 273080fefe0aSRandall Stewart if (sctp_logging_level & SCTP_RTTVAR_LOGGING_ENABLE) { 2731f8829a4aSRandall Stewart rto_logging(net, SCTP_LOG_INITIAL_RTT); 273280fefe0aSRandall Stewart } 2733f8829a4aSRandall Stewart } 27345e54f665SRandall Stewart calc_rto: 2735108df27cSRandall Stewart new_rto = (net->lastsa >> SCTP_RTT_SHIFT) + net->lastsv; 2736f8829a4aSRandall Stewart if ((new_rto > SCTP_SAT_NETWORK_MIN) && 2737f8829a4aSRandall Stewart (stcb->asoc.sat_network_lockout == 0)) { 2738f8829a4aSRandall Stewart stcb->asoc.sat_network = 1; 2739f8829a4aSRandall Stewart } else if ((!first_measure) && stcb->asoc.sat_network) { 2740f8829a4aSRandall Stewart stcb->asoc.sat_network = 0; 2741f8829a4aSRandall Stewart stcb->asoc.sat_network_lockout = 1; 2742f8829a4aSRandall Stewart } 2743f8829a4aSRandall Stewart /* bound it, per C6/C7 in Section 5.3.1 */ 2744f8829a4aSRandall Stewart if (new_rto < stcb->asoc.minrto) { 2745f8829a4aSRandall Stewart new_rto = stcb->asoc.minrto; 2746f8829a4aSRandall Stewart } 2747f8829a4aSRandall Stewart if (new_rto > stcb->asoc.maxrto) { 2748f8829a4aSRandall Stewart new_rto = stcb->asoc.maxrto; 2749f8829a4aSRandall Stewart } 27505e54f665SRandall Stewart /* we are now returning the RTO */ 27515e54f665SRandall Stewart return (new_rto); 2752f8829a4aSRandall Stewart } 2753f8829a4aSRandall Stewart 2754f8829a4aSRandall Stewart /* 2755f8829a4aSRandall Stewart * return a pointer to a contiguous piece of data from the given mbuf chain 2756f8829a4aSRandall Stewart * starting at 'off' for 'len' bytes. If the desired piece spans more than 2757f8829a4aSRandall Stewart * one mbuf, a copy is made at 'ptr'. caller must ensure that the buffer size 2758f8829a4aSRandall Stewart * is >= 'len' returns NULL if there there isn't 'len' bytes in the chain. 2759f8829a4aSRandall Stewart */ 276072fb6fdbSRandall Stewart caddr_t 2761f8829a4aSRandall Stewart sctp_m_getptr(struct mbuf *m, int off, int len, uint8_t * in_ptr) 2762f8829a4aSRandall Stewart { 2763f8829a4aSRandall Stewart uint32_t count; 2764f8829a4aSRandall Stewart uint8_t *ptr; 2765f8829a4aSRandall Stewart 2766f8829a4aSRandall Stewart ptr = in_ptr; 2767f8829a4aSRandall Stewart if ((off < 0) || (len <= 0)) 2768f8829a4aSRandall Stewart return (NULL); 2769f8829a4aSRandall Stewart 2770f8829a4aSRandall Stewart /* find the desired start location */ 2771f8829a4aSRandall Stewart while ((m != NULL) && (off > 0)) { 2772139bc87fSRandall Stewart if (off < SCTP_BUF_LEN(m)) 2773f8829a4aSRandall Stewart break; 2774139bc87fSRandall Stewart off -= SCTP_BUF_LEN(m); 2775139bc87fSRandall Stewart m = SCTP_BUF_NEXT(m); 2776f8829a4aSRandall Stewart } 2777f8829a4aSRandall Stewart if (m == NULL) 2778f8829a4aSRandall Stewart return (NULL); 2779f8829a4aSRandall Stewart 2780f8829a4aSRandall Stewart /* is the current mbuf large enough (eg. contiguous)? */ 2781139bc87fSRandall Stewart if ((SCTP_BUF_LEN(m) - off) >= len) { 2782f8829a4aSRandall Stewart return (mtod(m, caddr_t)+off); 2783f8829a4aSRandall Stewart } else { 2784f8829a4aSRandall Stewart /* else, it spans more than one mbuf, so save a temp copy... */ 2785f8829a4aSRandall Stewart while ((m != NULL) && (len > 0)) { 2786139bc87fSRandall Stewart count = min(SCTP_BUF_LEN(m) - off, len); 2787f8829a4aSRandall Stewart bcopy(mtod(m, caddr_t)+off, ptr, count); 2788f8829a4aSRandall Stewart len -= count; 2789f8829a4aSRandall Stewart ptr += count; 2790f8829a4aSRandall Stewart off = 0; 2791139bc87fSRandall Stewart m = SCTP_BUF_NEXT(m); 2792f8829a4aSRandall Stewart } 2793f8829a4aSRandall Stewart if ((m == NULL) && (len > 0)) 2794f8829a4aSRandall Stewart return (NULL); 2795f8829a4aSRandall Stewart else 2796f8829a4aSRandall Stewart return ((caddr_t)in_ptr); 2797f8829a4aSRandall Stewart } 2798f8829a4aSRandall Stewart } 2799f8829a4aSRandall Stewart 2800f8829a4aSRandall Stewart 280144b7479bSRandall Stewart 2802f8829a4aSRandall Stewart struct sctp_paramhdr * 2803f8829a4aSRandall Stewart sctp_get_next_param(struct mbuf *m, 2804f8829a4aSRandall Stewart int offset, 2805f8829a4aSRandall Stewart struct sctp_paramhdr *pull, 2806f8829a4aSRandall Stewart int pull_limit) 2807f8829a4aSRandall Stewart { 2808f8829a4aSRandall Stewart /* This just provides a typed signature to Peter's Pull routine */ 2809f8829a4aSRandall Stewart return ((struct sctp_paramhdr *)sctp_m_getptr(m, offset, pull_limit, 2810f8829a4aSRandall Stewart (uint8_t *) pull)); 2811f8829a4aSRandall Stewart } 2812f8829a4aSRandall Stewart 2813f8829a4aSRandall Stewart 2814f8829a4aSRandall Stewart int 2815f8829a4aSRandall Stewart sctp_add_pad_tombuf(struct mbuf *m, int padlen) 2816f8829a4aSRandall Stewart { 2817f8829a4aSRandall Stewart /* 2818f8829a4aSRandall Stewart * add padlen bytes of 0 filled padding to the end of the mbuf. If 2819f8829a4aSRandall Stewart * padlen is > 3 this routine will fail. 2820f8829a4aSRandall Stewart */ 2821f8829a4aSRandall Stewart uint8_t *dp; 2822f8829a4aSRandall Stewart int i; 2823f8829a4aSRandall Stewart 2824f8829a4aSRandall Stewart if (padlen > 3) { 2825c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET_PKT(m, NULL, NULL, NULL, SCTP_FROM_SCTPUTIL, ENOBUFS); 2826f8829a4aSRandall Stewart return (ENOBUFS); 2827f8829a4aSRandall Stewart } 2828f8829a4aSRandall Stewart if (M_TRAILINGSPACE(m)) { 2829f8829a4aSRandall Stewart /* 2830f8829a4aSRandall Stewart * The easy way. We hope the majority of the time we hit 2831f8829a4aSRandall Stewart * here :) 2832f8829a4aSRandall Stewart */ 2833139bc87fSRandall Stewart dp = (uint8_t *) (mtod(m, caddr_t)+SCTP_BUF_LEN(m)); 2834139bc87fSRandall Stewart SCTP_BUF_LEN(m) += padlen; 2835f8829a4aSRandall Stewart } else { 2836f8829a4aSRandall Stewart /* Hard way we must grow the mbuf */ 2837f8829a4aSRandall Stewart struct mbuf *tmp; 2838f8829a4aSRandall Stewart 2839f8829a4aSRandall Stewart tmp = sctp_get_mbuf_for_msg(padlen, 0, M_DONTWAIT, 1, MT_DATA); 2840f8829a4aSRandall Stewart if (tmp == NULL) { 2841f8829a4aSRandall Stewart /* Out of space GAK! we are in big trouble. */ 2842c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET_PKT(m, NULL, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL); 2843f8829a4aSRandall Stewart return (ENOSPC); 2844f8829a4aSRandall Stewart } 2845f8829a4aSRandall Stewart /* setup and insert in middle */ 2846139bc87fSRandall Stewart SCTP_BUF_NEXT(tmp) = SCTP_BUF_NEXT(m); 2847139bc87fSRandall Stewart SCTP_BUF_LEN(tmp) = padlen; 2848139bc87fSRandall Stewart SCTP_BUF_NEXT(m) = tmp; 2849f8829a4aSRandall Stewart dp = mtod(tmp, uint8_t *); 2850f8829a4aSRandall Stewart } 2851f8829a4aSRandall Stewart /* zero out the pad */ 2852f8829a4aSRandall Stewart for (i = 0; i < padlen; i++) { 2853f8829a4aSRandall Stewart *dp = 0; 2854f8829a4aSRandall Stewart dp++; 2855f8829a4aSRandall Stewart } 2856f8829a4aSRandall Stewart return (0); 2857f8829a4aSRandall Stewart } 2858f8829a4aSRandall Stewart 2859f8829a4aSRandall Stewart int 2860f8829a4aSRandall Stewart sctp_pad_lastmbuf(struct mbuf *m, int padval, struct mbuf *last_mbuf) 2861f8829a4aSRandall Stewart { 2862f8829a4aSRandall Stewart /* find the last mbuf in chain and pad it */ 2863f8829a4aSRandall Stewart struct mbuf *m_at; 2864f8829a4aSRandall Stewart 2865f8829a4aSRandall Stewart m_at = m; 2866f8829a4aSRandall Stewart if (last_mbuf) { 2867f8829a4aSRandall Stewart return (sctp_add_pad_tombuf(last_mbuf, padval)); 2868f8829a4aSRandall Stewart } else { 2869f8829a4aSRandall Stewart while (m_at) { 2870139bc87fSRandall Stewart if (SCTP_BUF_NEXT(m_at) == NULL) { 2871f8829a4aSRandall Stewart return (sctp_add_pad_tombuf(m_at, padval)); 2872f8829a4aSRandall Stewart } 2873139bc87fSRandall Stewart m_at = SCTP_BUF_NEXT(m_at); 2874f8829a4aSRandall Stewart } 2875f8829a4aSRandall Stewart } 2876c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET_PKT(m, NULL, NULL, NULL, SCTP_FROM_SCTPUTIL, EFAULT); 2877f8829a4aSRandall Stewart return (EFAULT); 2878f8829a4aSRandall Stewart } 2879f8829a4aSRandall Stewart 2880f8829a4aSRandall Stewart int sctp_asoc_change_wake = 0; 2881f8829a4aSRandall Stewart 2882f8829a4aSRandall Stewart static void 2883f8829a4aSRandall Stewart sctp_notify_assoc_change(uint32_t event, struct sctp_tcb *stcb, 2884ceaad40aSRandall Stewart uint32_t error, void *data, int so_locked 2885ceaad40aSRandall Stewart #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING) 2886ceaad40aSRandall Stewart SCTP_UNUSED 2887ceaad40aSRandall Stewart #endif 2888ceaad40aSRandall Stewart ) 2889f8829a4aSRandall Stewart { 2890f8829a4aSRandall Stewart struct mbuf *m_notify; 2891f8829a4aSRandall Stewart struct sctp_assoc_change *sac; 2892f8829a4aSRandall Stewart struct sctp_queued_to_read *control; 2893f8829a4aSRandall Stewart 2894ceaad40aSRandall Stewart #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 2895ceaad40aSRandall Stewart struct socket *so; 2896ceaad40aSRandall Stewart 2897ceaad40aSRandall Stewart #endif 2898ceaad40aSRandall Stewart 2899f8829a4aSRandall Stewart /* 2900f8829a4aSRandall Stewart * First if we are are going down dump everything we can to the 2901f8829a4aSRandall Stewart * socket rcv queue. 2902f8829a4aSRandall Stewart */ 2903f8829a4aSRandall Stewart 2904ad81507eSRandall Stewart if ((stcb == NULL) || 2905ad81507eSRandall Stewart (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) || 2906f8829a4aSRandall Stewart (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_ALLGONE) || 2907f8829a4aSRandall Stewart (stcb->asoc.state & SCTP_STATE_CLOSED_SOCKET) 2908f8829a4aSRandall Stewart ) { 2909f8829a4aSRandall Stewart /* If the socket is gone we are out of here */ 2910f8829a4aSRandall Stewart return; 2911f8829a4aSRandall Stewart } 2912f8829a4aSRandall Stewart /* 2913f8829a4aSRandall Stewart * For TCP model AND UDP connected sockets we will send an error up 2914f8829a4aSRandall Stewart * when an ABORT comes in. 2915f8829a4aSRandall Stewart */ 2916f8829a4aSRandall Stewart if (((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) || 2917f8829a4aSRandall Stewart (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL)) && 29183c503c28SRandall Stewart ((event == SCTP_COMM_LOST) || (event == SCTP_CANT_STR_ASSOC))) { 2919c4739e2fSRandall Stewart if (SCTP_GET_STATE(&stcb->asoc) == SCTP_STATE_COOKIE_WAIT) { 2920c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTPUTIL, ECONNREFUSED); 292144b7479bSRandall Stewart stcb->sctp_socket->so_error = ECONNREFUSED; 2922c4739e2fSRandall Stewart } else { 2923c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTPUTIL, ECONNRESET); 2924f8829a4aSRandall Stewart stcb->sctp_socket->so_error = ECONNRESET; 2925c4739e2fSRandall Stewart } 2926f8829a4aSRandall Stewart /* Wake ANY sleepers */ 2927ceaad40aSRandall Stewart #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 2928ceaad40aSRandall Stewart so = SCTP_INP_SO(stcb->sctp_ep); 2929ceaad40aSRandall Stewart if (!so_locked) { 2930ceaad40aSRandall Stewart atomic_add_int(&stcb->asoc.refcnt, 1); 2931ceaad40aSRandall Stewart SCTP_TCB_UNLOCK(stcb); 2932ceaad40aSRandall Stewart SCTP_SOCKET_LOCK(so, 1); 2933ceaad40aSRandall Stewart SCTP_TCB_LOCK(stcb); 2934ceaad40aSRandall Stewart atomic_subtract_int(&stcb->asoc.refcnt, 1); 2935ceaad40aSRandall Stewart if (stcb->asoc.state & SCTP_STATE_CLOSED_SOCKET) { 2936ceaad40aSRandall Stewart SCTP_SOCKET_UNLOCK(so, 1); 2937ceaad40aSRandall Stewart return; 2938ceaad40aSRandall Stewart } 2939ceaad40aSRandall Stewart } 2940ceaad40aSRandall Stewart #endif 2941f8829a4aSRandall Stewart sorwakeup(stcb->sctp_socket); 2942f8829a4aSRandall Stewart sowwakeup(stcb->sctp_socket); 2943ceaad40aSRandall Stewart #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 2944ceaad40aSRandall Stewart if (!so_locked) { 2945ceaad40aSRandall Stewart SCTP_SOCKET_UNLOCK(so, 1); 2946ceaad40aSRandall Stewart } 2947ceaad40aSRandall Stewart #endif 2948f8829a4aSRandall Stewart sctp_asoc_change_wake++; 2949f8829a4aSRandall Stewart } 2950f8829a4aSRandall Stewart if (sctp_is_feature_off(stcb->sctp_ep, SCTP_PCB_FLAGS_RECVASSOCEVNT)) { 2951f8829a4aSRandall Stewart /* event not enabled */ 2952f8829a4aSRandall Stewart return; 2953f8829a4aSRandall Stewart } 2954139bc87fSRandall Stewart m_notify = sctp_get_mbuf_for_msg(sizeof(struct sctp_assoc_change), 0, M_DONTWAIT, 1, MT_DATA); 2955f8829a4aSRandall Stewart if (m_notify == NULL) 2956f8829a4aSRandall Stewart /* no space left */ 2957f8829a4aSRandall Stewart return; 2958139bc87fSRandall Stewart SCTP_BUF_LEN(m_notify) = 0; 2959f8829a4aSRandall Stewart 2960f8829a4aSRandall Stewart sac = mtod(m_notify, struct sctp_assoc_change *); 2961f8829a4aSRandall Stewart sac->sac_type = SCTP_ASSOC_CHANGE; 2962f8829a4aSRandall Stewart sac->sac_flags = 0; 2963f8829a4aSRandall Stewart sac->sac_length = sizeof(struct sctp_assoc_change); 2964f8829a4aSRandall Stewart sac->sac_state = event; 2965f8829a4aSRandall Stewart sac->sac_error = error; 2966f8829a4aSRandall Stewart /* XXX verify these stream counts */ 2967f8829a4aSRandall Stewart sac->sac_outbound_streams = stcb->asoc.streamoutcnt; 2968f8829a4aSRandall Stewart sac->sac_inbound_streams = stcb->asoc.streamincnt; 2969f8829a4aSRandall Stewart sac->sac_assoc_id = sctp_get_associd(stcb); 2970139bc87fSRandall Stewart SCTP_BUF_LEN(m_notify) = sizeof(struct sctp_assoc_change); 2971139bc87fSRandall Stewart SCTP_BUF_NEXT(m_notify) = NULL; 2972f8829a4aSRandall Stewart control = sctp_build_readq_entry(stcb, stcb->asoc.primary_destination, 2973f8829a4aSRandall Stewart 0, 0, 0, 0, 0, 0, 2974f8829a4aSRandall Stewart m_notify); 2975f8829a4aSRandall Stewart if (control == NULL) { 2976f8829a4aSRandall Stewart /* no memory */ 2977f8829a4aSRandall Stewart sctp_m_freem(m_notify); 2978f8829a4aSRandall Stewart return; 2979f8829a4aSRandall Stewart } 2980139bc87fSRandall Stewart control->length = SCTP_BUF_LEN(m_notify); 2981f8829a4aSRandall Stewart /* not that we need this */ 2982f8829a4aSRandall Stewart control->tail_mbuf = m_notify; 2983139bc87fSRandall Stewart control->spec_flags = M_NOTIFICATION; 2984f8829a4aSRandall Stewart sctp_add_to_readq(stcb->sctp_ep, stcb, 2985f8829a4aSRandall Stewart control, 2986ceaad40aSRandall Stewart &stcb->sctp_socket->so_rcv, 1, so_locked); 2987f8829a4aSRandall Stewart if (event == SCTP_COMM_LOST) { 2988f8829a4aSRandall Stewart /* Wake up any sleeper */ 2989ceaad40aSRandall Stewart #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 2990ceaad40aSRandall Stewart so = SCTP_INP_SO(stcb->sctp_ep); 2991ceaad40aSRandall Stewart if (!so_locked) { 2992ceaad40aSRandall Stewart atomic_add_int(&stcb->asoc.refcnt, 1); 2993ceaad40aSRandall Stewart SCTP_TCB_UNLOCK(stcb); 2994ceaad40aSRandall Stewart SCTP_SOCKET_LOCK(so, 1); 2995ceaad40aSRandall Stewart SCTP_TCB_LOCK(stcb); 2996ceaad40aSRandall Stewart atomic_subtract_int(&stcb->asoc.refcnt, 1); 2997ceaad40aSRandall Stewart if (stcb->asoc.state & SCTP_STATE_CLOSED_SOCKET) { 2998ceaad40aSRandall Stewart SCTP_SOCKET_UNLOCK(so, 1); 2999ceaad40aSRandall Stewart return; 3000ceaad40aSRandall Stewart } 3001ceaad40aSRandall Stewart } 3002ceaad40aSRandall Stewart #endif 3003f8829a4aSRandall Stewart sctp_sowwakeup(stcb->sctp_ep, stcb->sctp_socket); 3004ceaad40aSRandall Stewart #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 3005ceaad40aSRandall Stewart if (!so_locked) { 3006ceaad40aSRandall Stewart SCTP_SOCKET_UNLOCK(so, 1); 3007ceaad40aSRandall Stewart } 3008ceaad40aSRandall Stewart #endif 3009f8829a4aSRandall Stewart } 3010f8829a4aSRandall Stewart } 3011f8829a4aSRandall Stewart 3012f8829a4aSRandall Stewart static void 3013f8829a4aSRandall Stewart sctp_notify_peer_addr_change(struct sctp_tcb *stcb, uint32_t state, 3014f8829a4aSRandall Stewart struct sockaddr *sa, uint32_t error) 3015f8829a4aSRandall Stewart { 3016f8829a4aSRandall Stewart struct mbuf *m_notify; 3017f8829a4aSRandall Stewart struct sctp_paddr_change *spc; 3018f8829a4aSRandall Stewart struct sctp_queued_to_read *control; 3019f8829a4aSRandall Stewart 3020ad81507eSRandall Stewart if ((stcb == NULL) || (sctp_is_feature_off(stcb->sctp_ep, SCTP_PCB_FLAGS_RECVPADDREVNT))) 3021f8829a4aSRandall Stewart /* event not enabled */ 3022f8829a4aSRandall Stewart return; 3023f8829a4aSRandall Stewart 3024139bc87fSRandall Stewart m_notify = sctp_get_mbuf_for_msg(sizeof(struct sctp_paddr_change), 0, M_DONTWAIT, 1, MT_DATA); 3025f8829a4aSRandall Stewart if (m_notify == NULL) 3026f8829a4aSRandall Stewart return; 3027139bc87fSRandall Stewart SCTP_BUF_LEN(m_notify) = 0; 3028f8829a4aSRandall Stewart spc = mtod(m_notify, struct sctp_paddr_change *); 3029f8829a4aSRandall Stewart spc->spc_type = SCTP_PEER_ADDR_CHANGE; 3030f8829a4aSRandall Stewart spc->spc_flags = 0; 3031f8829a4aSRandall Stewart spc->spc_length = sizeof(struct sctp_paddr_change); 3032f8829a4aSRandall Stewart if (sa->sa_family == AF_INET) { 3033f8829a4aSRandall Stewart memcpy(&spc->spc_aaddr, sa, sizeof(struct sockaddr_in)); 3034f8829a4aSRandall Stewart } else { 3035f42a358aSRandall Stewart struct sockaddr_in6 *sin6; 3036f42a358aSRandall Stewart 3037f8829a4aSRandall Stewart memcpy(&spc->spc_aaddr, sa, sizeof(struct sockaddr_in6)); 3038f42a358aSRandall Stewart 3039f42a358aSRandall Stewart sin6 = (struct sockaddr_in6 *)&spc->spc_aaddr; 3040f42a358aSRandall Stewart if (IN6_IS_SCOPE_LINKLOCAL(&sin6->sin6_addr)) { 304142551e99SRandall Stewart if (sin6->sin6_scope_id == 0) { 304242551e99SRandall Stewart /* recover scope_id for user */ 3043f42a358aSRandall Stewart (void)sa6_recoverscope(sin6); 304442551e99SRandall Stewart } else { 304542551e99SRandall Stewart /* clear embedded scope_id for user */ 304642551e99SRandall Stewart in6_clearscope(&sin6->sin6_addr); 304742551e99SRandall Stewart } 3048f42a358aSRandall Stewart } 3049f8829a4aSRandall Stewart } 3050f8829a4aSRandall Stewart spc->spc_state = state; 3051f8829a4aSRandall Stewart spc->spc_error = error; 3052f8829a4aSRandall Stewart spc->spc_assoc_id = sctp_get_associd(stcb); 3053f8829a4aSRandall Stewart 3054139bc87fSRandall Stewart SCTP_BUF_LEN(m_notify) = sizeof(struct sctp_paddr_change); 3055139bc87fSRandall Stewart SCTP_BUF_NEXT(m_notify) = NULL; 3056f8829a4aSRandall Stewart 3057f8829a4aSRandall Stewart /* append to socket */ 3058f8829a4aSRandall Stewart control = sctp_build_readq_entry(stcb, stcb->asoc.primary_destination, 3059f8829a4aSRandall Stewart 0, 0, 0, 0, 0, 0, 3060f8829a4aSRandall Stewart m_notify); 3061f8829a4aSRandall Stewart if (control == NULL) { 3062f8829a4aSRandall Stewart /* no memory */ 3063f8829a4aSRandall Stewart sctp_m_freem(m_notify); 3064f8829a4aSRandall Stewart return; 3065f8829a4aSRandall Stewart } 3066139bc87fSRandall Stewart control->length = SCTP_BUF_LEN(m_notify); 3067139bc87fSRandall Stewart control->spec_flags = M_NOTIFICATION; 3068f8829a4aSRandall Stewart /* not that we need this */ 3069f8829a4aSRandall Stewart control->tail_mbuf = m_notify; 3070f8829a4aSRandall Stewart sctp_add_to_readq(stcb->sctp_ep, stcb, 3071f8829a4aSRandall Stewart control, 3072ceaad40aSRandall Stewart &stcb->sctp_socket->so_rcv, 1, SCTP_SO_NOT_LOCKED); 3073f8829a4aSRandall Stewart } 3074f8829a4aSRandall Stewart 3075f8829a4aSRandall Stewart 3076f8829a4aSRandall Stewart static void 3077f8829a4aSRandall Stewart sctp_notify_send_failed(struct sctp_tcb *stcb, uint32_t error, 3078ceaad40aSRandall Stewart struct sctp_tmit_chunk *chk, int so_locked 3079ceaad40aSRandall Stewart #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING) 3080ceaad40aSRandall Stewart SCTP_UNUSED 3081ceaad40aSRandall Stewart #endif 3082ceaad40aSRandall Stewart ) 3083f8829a4aSRandall Stewart { 3084f8829a4aSRandall Stewart struct mbuf *m_notify; 3085f8829a4aSRandall Stewart struct sctp_send_failed *ssf; 3086f8829a4aSRandall Stewart struct sctp_queued_to_read *control; 3087f8829a4aSRandall Stewart int length; 3088f8829a4aSRandall Stewart 3089ad81507eSRandall Stewart if ((stcb == NULL) || (sctp_is_feature_off(stcb->sctp_ep, SCTP_PCB_FLAGS_RECVSENDFAILEVNT))) 3090f8829a4aSRandall Stewart /* event not enabled */ 3091f8829a4aSRandall Stewart return; 3092f8829a4aSRandall Stewart 3093f8829a4aSRandall Stewart length = sizeof(struct sctp_send_failed) + chk->send_size; 3094139bc87fSRandall Stewart m_notify = sctp_get_mbuf_for_msg(sizeof(struct sctp_send_failed), 0, M_DONTWAIT, 1, MT_DATA); 3095f8829a4aSRandall Stewart if (m_notify == NULL) 3096f8829a4aSRandall Stewart /* no space left */ 3097f8829a4aSRandall Stewart return; 3098139bc87fSRandall Stewart SCTP_BUF_LEN(m_notify) = 0; 3099f8829a4aSRandall Stewart ssf = mtod(m_notify, struct sctp_send_failed *); 3100f8829a4aSRandall Stewart ssf->ssf_type = SCTP_SEND_FAILED; 3101f8829a4aSRandall Stewart if (error == SCTP_NOTIFY_DATAGRAM_UNSENT) 3102f8829a4aSRandall Stewart ssf->ssf_flags = SCTP_DATA_UNSENT; 3103f8829a4aSRandall Stewart else 3104f8829a4aSRandall Stewart ssf->ssf_flags = SCTP_DATA_SENT; 3105f8829a4aSRandall Stewart ssf->ssf_length = length; 3106f8829a4aSRandall Stewart ssf->ssf_error = error; 3107f8829a4aSRandall Stewart /* not exactly what the user sent in, but should be close :) */ 3108d00aff5dSRandall Stewart bzero(&ssf->ssf_info, sizeof(ssf->ssf_info)); 3109f8829a4aSRandall Stewart ssf->ssf_info.sinfo_stream = chk->rec.data.stream_number; 3110f8829a4aSRandall Stewart ssf->ssf_info.sinfo_ssn = chk->rec.data.stream_seq; 3111f8829a4aSRandall Stewart ssf->ssf_info.sinfo_flags = chk->rec.data.rcv_flags; 3112f8829a4aSRandall Stewart ssf->ssf_info.sinfo_ppid = chk->rec.data.payloadtype; 3113f8829a4aSRandall Stewart ssf->ssf_info.sinfo_context = chk->rec.data.context; 3114f8829a4aSRandall Stewart ssf->ssf_info.sinfo_assoc_id = sctp_get_associd(stcb); 3115f8829a4aSRandall Stewart ssf->ssf_assoc_id = sctp_get_associd(stcb); 3116139bc87fSRandall Stewart SCTP_BUF_NEXT(m_notify) = chk->data; 3117139bc87fSRandall Stewart SCTP_BUF_LEN(m_notify) = sizeof(struct sctp_send_failed); 3118f8829a4aSRandall Stewart 3119f8829a4aSRandall Stewart /* Steal off the mbuf */ 3120f8829a4aSRandall Stewart chk->data = NULL; 3121f8829a4aSRandall Stewart /* 3122f8829a4aSRandall Stewart * For this case, we check the actual socket buffer, since the assoc 3123f8829a4aSRandall Stewart * is going away we don't want to overfill the socket buffer for a 3124f8829a4aSRandall Stewart * non-reader 3125f8829a4aSRandall Stewart */ 3126139bc87fSRandall Stewart if (sctp_sbspace_failedmsgs(&stcb->sctp_socket->so_rcv) < SCTP_BUF_LEN(m_notify)) { 3127f8829a4aSRandall Stewart sctp_m_freem(m_notify); 3128f8829a4aSRandall Stewart return; 3129f8829a4aSRandall Stewart } 3130f8829a4aSRandall Stewart /* append to socket */ 3131f8829a4aSRandall Stewart control = sctp_build_readq_entry(stcb, stcb->asoc.primary_destination, 3132f8829a4aSRandall Stewart 0, 0, 0, 0, 0, 0, 3133f8829a4aSRandall Stewart m_notify); 3134f8829a4aSRandall Stewart if (control == NULL) { 3135f8829a4aSRandall Stewart /* no memory */ 3136f8829a4aSRandall Stewart sctp_m_freem(m_notify); 3137f8829a4aSRandall Stewart return; 3138f8829a4aSRandall Stewart } 3139139bc87fSRandall Stewart control->spec_flags = M_NOTIFICATION; 3140f8829a4aSRandall Stewart sctp_add_to_readq(stcb->sctp_ep, stcb, 3141f8829a4aSRandall Stewart control, 3142ceaad40aSRandall Stewart &stcb->sctp_socket->so_rcv, 1, so_locked); 3143f8829a4aSRandall Stewart } 3144f8829a4aSRandall Stewart 3145f8829a4aSRandall Stewart 3146f8829a4aSRandall Stewart static void 3147f8829a4aSRandall Stewart sctp_notify_send_failed2(struct sctp_tcb *stcb, uint32_t error, 3148ceaad40aSRandall Stewart struct sctp_stream_queue_pending *sp, int so_locked 3149ceaad40aSRandall Stewart #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING) 3150ceaad40aSRandall Stewart SCTP_UNUSED 3151ceaad40aSRandall Stewart #endif 3152ceaad40aSRandall Stewart ) 3153f8829a4aSRandall Stewart { 3154f8829a4aSRandall Stewart struct mbuf *m_notify; 3155f8829a4aSRandall Stewart struct sctp_send_failed *ssf; 3156f8829a4aSRandall Stewart struct sctp_queued_to_read *control; 3157f8829a4aSRandall Stewart int length; 3158f8829a4aSRandall Stewart 3159ad81507eSRandall Stewart if ((stcb == NULL) || (sctp_is_feature_off(stcb->sctp_ep, SCTP_PCB_FLAGS_RECVSENDFAILEVNT))) 3160f8829a4aSRandall Stewart /* event not enabled */ 3161f8829a4aSRandall Stewart return; 3162f8829a4aSRandall Stewart 3163f8829a4aSRandall Stewart length = sizeof(struct sctp_send_failed) + sp->length; 3164d00aff5dSRandall Stewart m_notify = sctp_get_mbuf_for_msg(sizeof(struct sctp_send_failed), 0, M_DONTWAIT, 1, MT_DATA); 3165f8829a4aSRandall Stewart if (m_notify == NULL) 3166f8829a4aSRandall Stewart /* no space left */ 3167f8829a4aSRandall Stewart return; 3168139bc87fSRandall Stewart SCTP_BUF_LEN(m_notify) = 0; 3169f8829a4aSRandall Stewart ssf = mtod(m_notify, struct sctp_send_failed *); 3170f8829a4aSRandall Stewart ssf->ssf_type = SCTP_SEND_FAILED; 3171f8829a4aSRandall Stewart if (error == SCTP_NOTIFY_DATAGRAM_UNSENT) 3172f8829a4aSRandall Stewart ssf->ssf_flags = SCTP_DATA_UNSENT; 3173f8829a4aSRandall Stewart else 3174f8829a4aSRandall Stewart ssf->ssf_flags = SCTP_DATA_SENT; 3175f8829a4aSRandall Stewart ssf->ssf_length = length; 3176f8829a4aSRandall Stewart ssf->ssf_error = error; 3177f8829a4aSRandall Stewart /* not exactly what the user sent in, but should be close :) */ 3178d00aff5dSRandall Stewart bzero(&ssf->ssf_info, sizeof(ssf->ssf_info)); 3179f8829a4aSRandall Stewart ssf->ssf_info.sinfo_stream = sp->stream; 3180f8829a4aSRandall Stewart ssf->ssf_info.sinfo_ssn = sp->strseq; 3181f8829a4aSRandall Stewart ssf->ssf_info.sinfo_flags = sp->sinfo_flags; 3182f8829a4aSRandall Stewart ssf->ssf_info.sinfo_ppid = sp->ppid; 3183f8829a4aSRandall Stewart ssf->ssf_info.sinfo_context = sp->context; 3184f8829a4aSRandall Stewart ssf->ssf_info.sinfo_assoc_id = sctp_get_associd(stcb); 3185f8829a4aSRandall Stewart ssf->ssf_assoc_id = sctp_get_associd(stcb); 3186139bc87fSRandall Stewart SCTP_BUF_NEXT(m_notify) = sp->data; 3187139bc87fSRandall Stewart SCTP_BUF_LEN(m_notify) = sizeof(struct sctp_send_failed); 3188f8829a4aSRandall Stewart 3189f8829a4aSRandall Stewart /* Steal off the mbuf */ 3190f8829a4aSRandall Stewart sp->data = NULL; 3191f8829a4aSRandall Stewart /* 3192f8829a4aSRandall Stewart * For this case, we check the actual socket buffer, since the assoc 3193f8829a4aSRandall Stewart * is going away we don't want to overfill the socket buffer for a 3194f8829a4aSRandall Stewart * non-reader 3195f8829a4aSRandall Stewart */ 3196139bc87fSRandall Stewart if (sctp_sbspace_failedmsgs(&stcb->sctp_socket->so_rcv) < SCTP_BUF_LEN(m_notify)) { 3197f8829a4aSRandall Stewart sctp_m_freem(m_notify); 3198f8829a4aSRandall Stewart return; 3199f8829a4aSRandall Stewart } 3200f8829a4aSRandall Stewart /* append to socket */ 3201f8829a4aSRandall Stewart control = sctp_build_readq_entry(stcb, stcb->asoc.primary_destination, 3202f8829a4aSRandall Stewart 0, 0, 0, 0, 0, 0, 3203f8829a4aSRandall Stewart m_notify); 3204f8829a4aSRandall Stewart if (control == NULL) { 3205f8829a4aSRandall Stewart /* no memory */ 3206f8829a4aSRandall Stewart sctp_m_freem(m_notify); 3207f8829a4aSRandall Stewart return; 3208f8829a4aSRandall Stewart } 3209139bc87fSRandall Stewart control->spec_flags = M_NOTIFICATION; 3210f8829a4aSRandall Stewart sctp_add_to_readq(stcb->sctp_ep, stcb, 3211f8829a4aSRandall Stewart control, 3212ceaad40aSRandall Stewart &stcb->sctp_socket->so_rcv, 1, so_locked); 3213f8829a4aSRandall Stewart } 3214f8829a4aSRandall Stewart 3215f8829a4aSRandall Stewart 3216f8829a4aSRandall Stewart 3217f8829a4aSRandall Stewart static void 3218f8829a4aSRandall Stewart sctp_notify_adaptation_layer(struct sctp_tcb *stcb, 3219f8829a4aSRandall Stewart uint32_t error) 3220f8829a4aSRandall Stewart { 3221f8829a4aSRandall Stewart struct mbuf *m_notify; 3222f8829a4aSRandall Stewart struct sctp_adaptation_event *sai; 3223f8829a4aSRandall Stewart struct sctp_queued_to_read *control; 3224f8829a4aSRandall Stewart 3225ad81507eSRandall Stewart if ((stcb == NULL) || (sctp_is_feature_off(stcb->sctp_ep, SCTP_PCB_FLAGS_ADAPTATIONEVNT))) 3226f8829a4aSRandall Stewart /* event not enabled */ 3227f8829a4aSRandall Stewart return; 3228f8829a4aSRandall Stewart 3229139bc87fSRandall Stewart m_notify = sctp_get_mbuf_for_msg(sizeof(struct sctp_adaption_event), 0, M_DONTWAIT, 1, MT_DATA); 3230f8829a4aSRandall Stewart if (m_notify == NULL) 3231f8829a4aSRandall Stewart /* no space left */ 3232f8829a4aSRandall Stewart return; 3233139bc87fSRandall Stewart SCTP_BUF_LEN(m_notify) = 0; 3234f8829a4aSRandall Stewart sai = mtod(m_notify, struct sctp_adaptation_event *); 3235f8829a4aSRandall Stewart sai->sai_type = SCTP_ADAPTATION_INDICATION; 3236f8829a4aSRandall Stewart sai->sai_flags = 0; 3237f8829a4aSRandall Stewart sai->sai_length = sizeof(struct sctp_adaptation_event); 32382afb3e84SRandall Stewart sai->sai_adaptation_ind = stcb->asoc.peers_adaptation; 3239f8829a4aSRandall Stewart sai->sai_assoc_id = sctp_get_associd(stcb); 3240f8829a4aSRandall Stewart 3241139bc87fSRandall Stewart SCTP_BUF_LEN(m_notify) = sizeof(struct sctp_adaptation_event); 3242139bc87fSRandall Stewart SCTP_BUF_NEXT(m_notify) = NULL; 3243f8829a4aSRandall Stewart 3244f8829a4aSRandall Stewart /* append to socket */ 3245f8829a4aSRandall Stewart control = sctp_build_readq_entry(stcb, stcb->asoc.primary_destination, 3246f8829a4aSRandall Stewart 0, 0, 0, 0, 0, 0, 3247f8829a4aSRandall Stewart m_notify); 3248f8829a4aSRandall Stewart if (control == NULL) { 3249f8829a4aSRandall Stewart /* no memory */ 3250f8829a4aSRandall Stewart sctp_m_freem(m_notify); 3251f8829a4aSRandall Stewart return; 3252f8829a4aSRandall Stewart } 3253139bc87fSRandall Stewart control->length = SCTP_BUF_LEN(m_notify); 3254139bc87fSRandall Stewart control->spec_flags = M_NOTIFICATION; 3255f8829a4aSRandall Stewart /* not that we need this */ 3256f8829a4aSRandall Stewart control->tail_mbuf = m_notify; 3257f8829a4aSRandall Stewart sctp_add_to_readq(stcb->sctp_ep, stcb, 3258f8829a4aSRandall Stewart control, 3259ceaad40aSRandall Stewart &stcb->sctp_socket->so_rcv, 1, SCTP_SO_NOT_LOCKED); 3260f8829a4aSRandall Stewart } 3261f8829a4aSRandall Stewart 326203b0b021SRandall Stewart /* This always must be called with the read-queue LOCKED in the INP */ 3263f8829a4aSRandall Stewart void 32642dad8a55SRandall Stewart sctp_notify_partial_delivery_indication(struct sctp_tcb *stcb, uint32_t error, 32652dad8a55SRandall Stewart int nolock, uint32_t val) 3266f8829a4aSRandall Stewart { 3267f8829a4aSRandall Stewart struct mbuf *m_notify; 3268f8829a4aSRandall Stewart struct sctp_pdapi_event *pdapi; 3269f8829a4aSRandall Stewart struct sctp_queued_to_read *control; 327003b0b021SRandall Stewart struct sockbuf *sb; 3271f8829a4aSRandall Stewart 32722dad8a55SRandall Stewart if ((stcb == NULL) || (stcb->sctp_socket == NULL) || 32732dad8a55SRandall Stewart sctp_is_feature_off(stcb->sctp_ep, SCTP_PCB_FLAGS_PDAPIEVNT)) 3274f8829a4aSRandall Stewart /* event not enabled */ 3275f8829a4aSRandall Stewart return; 3276f8829a4aSRandall Stewart 3277139bc87fSRandall Stewart m_notify = sctp_get_mbuf_for_msg(sizeof(struct sctp_pdapi_event), 0, M_DONTWAIT, 1, MT_DATA); 3278f8829a4aSRandall Stewart if (m_notify == NULL) 3279f8829a4aSRandall Stewart /* no space left */ 3280f8829a4aSRandall Stewart return; 3281139bc87fSRandall Stewart SCTP_BUF_LEN(m_notify) = 0; 3282f8829a4aSRandall Stewart pdapi = mtod(m_notify, struct sctp_pdapi_event *); 3283f8829a4aSRandall Stewart pdapi->pdapi_type = SCTP_PARTIAL_DELIVERY_EVENT; 3284f8829a4aSRandall Stewart pdapi->pdapi_flags = 0; 3285f8829a4aSRandall Stewart pdapi->pdapi_length = sizeof(struct sctp_pdapi_event); 3286f8829a4aSRandall Stewart pdapi->pdapi_indication = error; 32879a6142d8SRandall Stewart pdapi->pdapi_stream = (val >> 16); 32889a6142d8SRandall Stewart pdapi->pdapi_seq = (val & 0x0000ffff); 3289f8829a4aSRandall Stewart pdapi->pdapi_assoc_id = sctp_get_associd(stcb); 3290f8829a4aSRandall Stewart 3291139bc87fSRandall Stewart SCTP_BUF_LEN(m_notify) = sizeof(struct sctp_pdapi_event); 3292139bc87fSRandall Stewart SCTP_BUF_NEXT(m_notify) = NULL; 3293f8829a4aSRandall Stewart control = sctp_build_readq_entry(stcb, stcb->asoc.primary_destination, 3294f8829a4aSRandall Stewart 0, 0, 0, 0, 0, 0, 3295f8829a4aSRandall Stewart m_notify); 3296f8829a4aSRandall Stewart if (control == NULL) { 3297f8829a4aSRandall Stewart /* no memory */ 3298f8829a4aSRandall Stewart sctp_m_freem(m_notify); 3299f8829a4aSRandall Stewart return; 3300f8829a4aSRandall Stewart } 3301139bc87fSRandall Stewart control->spec_flags = M_NOTIFICATION; 3302139bc87fSRandall Stewart control->length = SCTP_BUF_LEN(m_notify); 3303f8829a4aSRandall Stewart /* not that we need this */ 3304f8829a4aSRandall Stewart control->tail_mbuf = m_notify; 330503b0b021SRandall Stewart control->held_length = 0; 330603b0b021SRandall Stewart control->length = 0; 330703b0b021SRandall Stewart if (nolock == 0) { 330803b0b021SRandall Stewart SCTP_INP_READ_LOCK(stcb->sctp_ep); 330903b0b021SRandall Stewart } 331003b0b021SRandall Stewart sb = &stcb->sctp_socket->so_rcv; 331180fefe0aSRandall Stewart if (sctp_logging_level & SCTP_SB_LOGGING_ENABLE) { 3312139bc87fSRandall Stewart sctp_sblog(sb, control->do_not_ref_stcb ? NULL : stcb, SCTP_LOG_SBALLOC, SCTP_BUF_LEN(m_notify)); 331380fefe0aSRandall Stewart } 331403b0b021SRandall Stewart sctp_sballoc(stcb, sb, m_notify); 331580fefe0aSRandall Stewart if (sctp_logging_level & SCTP_SB_LOGGING_ENABLE) { 331603b0b021SRandall Stewart sctp_sblog(sb, control->do_not_ref_stcb ? NULL : stcb, SCTP_LOG_SBRESULT, 0); 331780fefe0aSRandall Stewart } 3318139bc87fSRandall Stewart atomic_add_int(&control->length, SCTP_BUF_LEN(m_notify)); 331903b0b021SRandall Stewart control->end_added = 1; 332003b0b021SRandall Stewart if (stcb->asoc.control_pdapi) 332103b0b021SRandall Stewart TAILQ_INSERT_AFTER(&stcb->sctp_ep->read_queue, stcb->asoc.control_pdapi, control, next); 332203b0b021SRandall Stewart else { 332303b0b021SRandall Stewart /* we really should not see this case */ 332403b0b021SRandall Stewart TAILQ_INSERT_TAIL(&stcb->sctp_ep->read_queue, control, next); 332503b0b021SRandall Stewart } 332603b0b021SRandall Stewart if (nolock == 0) { 332703b0b021SRandall Stewart SCTP_INP_READ_UNLOCK(stcb->sctp_ep); 332803b0b021SRandall Stewart } 332903b0b021SRandall Stewart if (stcb->sctp_ep && stcb->sctp_socket) { 333003b0b021SRandall Stewart /* This should always be the case */ 333103b0b021SRandall Stewart sctp_sorwakeup(stcb->sctp_ep, stcb->sctp_socket); 3332f8829a4aSRandall Stewart } 3333f8829a4aSRandall Stewart } 3334f8829a4aSRandall Stewart 3335f8829a4aSRandall Stewart static void 3336f8829a4aSRandall Stewart sctp_notify_shutdown_event(struct sctp_tcb *stcb) 3337f8829a4aSRandall Stewart { 3338f8829a4aSRandall Stewart struct mbuf *m_notify; 3339f8829a4aSRandall Stewart struct sctp_shutdown_event *sse; 3340f8829a4aSRandall Stewart struct sctp_queued_to_read *control; 3341f8829a4aSRandall Stewart 3342f8829a4aSRandall Stewart /* 3343f8829a4aSRandall Stewart * For TCP model AND UDP connected sockets we will send an error up 3344f8829a4aSRandall Stewart * when an SHUTDOWN completes 3345f8829a4aSRandall Stewart */ 3346ad81507eSRandall Stewart if (stcb == NULL) { 3347ad81507eSRandall Stewart return; 3348ad81507eSRandall Stewart } 3349f8829a4aSRandall Stewart if ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) || 3350f8829a4aSRandall Stewart (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL)) { 3351f8829a4aSRandall Stewart /* mark socket closed for read/write and wakeup! */ 3352ceaad40aSRandall Stewart #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 3353ceaad40aSRandall Stewart struct socket *so; 3354ceaad40aSRandall Stewart 3355ceaad40aSRandall Stewart so = SCTP_INP_SO(stcb->sctp_ep); 3356ceaad40aSRandall Stewart atomic_add_int(&stcb->asoc.refcnt, 1); 3357ceaad40aSRandall Stewart SCTP_TCB_UNLOCK(stcb); 3358ceaad40aSRandall Stewart SCTP_SOCKET_LOCK(so, 1); 3359ceaad40aSRandall Stewart SCTP_TCB_LOCK(stcb); 3360ceaad40aSRandall Stewart atomic_subtract_int(&stcb->asoc.refcnt, 1); 3361ceaad40aSRandall Stewart if (stcb->asoc.state & SCTP_STATE_CLOSED_SOCKET) { 3362ceaad40aSRandall Stewart SCTP_SOCKET_UNLOCK(so, 1); 3363ceaad40aSRandall Stewart return; 3364ceaad40aSRandall Stewart } 3365ceaad40aSRandall Stewart #endif 3366f8829a4aSRandall Stewart socantsendmore(stcb->sctp_socket); 33679f22f500SRandall Stewart socantrcvmore(stcb->sctp_socket); 3368ceaad40aSRandall Stewart #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 3369ceaad40aSRandall Stewart SCTP_SOCKET_UNLOCK(so, 1); 3370ceaad40aSRandall Stewart #endif 3371f8829a4aSRandall Stewart } 3372f8829a4aSRandall Stewart if (sctp_is_feature_off(stcb->sctp_ep, SCTP_PCB_FLAGS_RECVSHUTDOWNEVNT)) 3373f8829a4aSRandall Stewart /* event not enabled */ 3374f8829a4aSRandall Stewart return; 3375f8829a4aSRandall Stewart 3376139bc87fSRandall Stewart m_notify = sctp_get_mbuf_for_msg(sizeof(struct sctp_shutdown_event), 0, M_DONTWAIT, 1, MT_DATA); 3377f8829a4aSRandall Stewart if (m_notify == NULL) 3378f8829a4aSRandall Stewart /* no space left */ 3379f8829a4aSRandall Stewart return; 3380f8829a4aSRandall Stewart sse = mtod(m_notify, struct sctp_shutdown_event *); 3381f8829a4aSRandall Stewart sse->sse_type = SCTP_SHUTDOWN_EVENT; 3382f8829a4aSRandall Stewart sse->sse_flags = 0; 3383f8829a4aSRandall Stewart sse->sse_length = sizeof(struct sctp_shutdown_event); 3384f8829a4aSRandall Stewart sse->sse_assoc_id = sctp_get_associd(stcb); 3385f8829a4aSRandall Stewart 3386139bc87fSRandall Stewart SCTP_BUF_LEN(m_notify) = sizeof(struct sctp_shutdown_event); 3387139bc87fSRandall Stewart SCTP_BUF_NEXT(m_notify) = NULL; 3388f8829a4aSRandall Stewart 3389f8829a4aSRandall Stewart /* append to socket */ 3390f8829a4aSRandall Stewart control = sctp_build_readq_entry(stcb, stcb->asoc.primary_destination, 3391f8829a4aSRandall Stewart 0, 0, 0, 0, 0, 0, 3392f8829a4aSRandall Stewart m_notify); 3393f8829a4aSRandall Stewart if (control == NULL) { 3394f8829a4aSRandall Stewart /* no memory */ 3395f8829a4aSRandall Stewart sctp_m_freem(m_notify); 3396f8829a4aSRandall Stewart return; 3397f8829a4aSRandall Stewart } 3398139bc87fSRandall Stewart control->spec_flags = M_NOTIFICATION; 3399139bc87fSRandall Stewart control->length = SCTP_BUF_LEN(m_notify); 3400f8829a4aSRandall Stewart /* not that we need this */ 3401f8829a4aSRandall Stewart control->tail_mbuf = m_notify; 3402f8829a4aSRandall Stewart sctp_add_to_readq(stcb->sctp_ep, stcb, 3403f8829a4aSRandall Stewart control, 3404ceaad40aSRandall Stewart &stcb->sctp_socket->so_rcv, 1, SCTP_SO_NOT_LOCKED); 3405f8829a4aSRandall Stewart } 3406f8829a4aSRandall Stewart 3407f8829a4aSRandall Stewart static void 3408f8829a4aSRandall Stewart sctp_notify_stream_reset(struct sctp_tcb *stcb, 3409f8829a4aSRandall Stewart int number_entries, uint16_t * list, int flag) 3410f8829a4aSRandall Stewart { 3411f8829a4aSRandall Stewart struct mbuf *m_notify; 3412f8829a4aSRandall Stewart struct sctp_queued_to_read *control; 3413f8829a4aSRandall Stewart struct sctp_stream_reset_event *strreset; 3414f8829a4aSRandall Stewart int len; 3415f8829a4aSRandall Stewart 3416ad81507eSRandall Stewart if (stcb == NULL) { 3417ad81507eSRandall Stewart return; 3418ad81507eSRandall Stewart } 3419f8829a4aSRandall Stewart if (sctp_is_feature_off(stcb->sctp_ep, SCTP_PCB_FLAGS_STREAM_RESETEVNT)) 3420f8829a4aSRandall Stewart /* event not enabled */ 3421f8829a4aSRandall Stewart return; 3422f8829a4aSRandall Stewart 3423139bc87fSRandall Stewart m_notify = sctp_get_mbuf_for_msg(MCLBYTES, 0, M_DONTWAIT, 1, MT_DATA); 3424f8829a4aSRandall Stewart if (m_notify == NULL) 3425f8829a4aSRandall Stewart /* no space left */ 3426f8829a4aSRandall Stewart return; 3427139bc87fSRandall Stewart SCTP_BUF_LEN(m_notify) = 0; 3428f8829a4aSRandall Stewart len = sizeof(struct sctp_stream_reset_event) + (number_entries * sizeof(uint16_t)); 3429f8829a4aSRandall Stewart if (len > M_TRAILINGSPACE(m_notify)) { 3430f8829a4aSRandall Stewart /* never enough room */ 3431f8829a4aSRandall Stewart sctp_m_freem(m_notify); 3432f8829a4aSRandall Stewart return; 3433f8829a4aSRandall Stewart } 3434f8829a4aSRandall Stewart strreset = mtod(m_notify, struct sctp_stream_reset_event *); 3435f8829a4aSRandall Stewart strreset->strreset_type = SCTP_STREAM_RESET_EVENT; 3436f8829a4aSRandall Stewart if (number_entries == 0) { 3437f8829a4aSRandall Stewart strreset->strreset_flags = flag | SCTP_STRRESET_ALL_STREAMS; 3438f8829a4aSRandall Stewart } else { 3439f8829a4aSRandall Stewart strreset->strreset_flags = flag | SCTP_STRRESET_STREAM_LIST; 3440f8829a4aSRandall Stewart } 3441f8829a4aSRandall Stewart strreset->strreset_length = len; 3442f8829a4aSRandall Stewart strreset->strreset_assoc_id = sctp_get_associd(stcb); 3443f8829a4aSRandall Stewart if (number_entries) { 3444f8829a4aSRandall Stewart int i; 3445f8829a4aSRandall Stewart 3446f8829a4aSRandall Stewart for (i = 0; i < number_entries; i++) { 3447f8829a4aSRandall Stewart strreset->strreset_list[i] = ntohs(list[i]); 3448f8829a4aSRandall Stewart } 3449f8829a4aSRandall Stewart } 3450139bc87fSRandall Stewart SCTP_BUF_LEN(m_notify) = len; 3451139bc87fSRandall Stewart SCTP_BUF_NEXT(m_notify) = NULL; 3452139bc87fSRandall Stewart if (sctp_sbspace(&stcb->asoc, &stcb->sctp_socket->so_rcv) < SCTP_BUF_LEN(m_notify)) { 3453f8829a4aSRandall Stewart /* no space */ 3454f8829a4aSRandall Stewart sctp_m_freem(m_notify); 3455f8829a4aSRandall Stewart return; 3456f8829a4aSRandall Stewart } 3457f8829a4aSRandall Stewart /* append to socket */ 3458f8829a4aSRandall Stewart control = sctp_build_readq_entry(stcb, stcb->asoc.primary_destination, 3459f8829a4aSRandall Stewart 0, 0, 0, 0, 0, 0, 3460f8829a4aSRandall Stewart m_notify); 3461f8829a4aSRandall Stewart if (control == NULL) { 3462f8829a4aSRandall Stewart /* no memory */ 3463f8829a4aSRandall Stewart sctp_m_freem(m_notify); 3464f8829a4aSRandall Stewart return; 3465f8829a4aSRandall Stewart } 3466139bc87fSRandall Stewart control->spec_flags = M_NOTIFICATION; 3467139bc87fSRandall Stewart control->length = SCTP_BUF_LEN(m_notify); 3468f8829a4aSRandall Stewart /* not that we need this */ 3469f8829a4aSRandall Stewart control->tail_mbuf = m_notify; 3470f8829a4aSRandall Stewart sctp_add_to_readq(stcb->sctp_ep, stcb, 3471f8829a4aSRandall Stewart control, 3472ceaad40aSRandall Stewart &stcb->sctp_socket->so_rcv, 1, SCTP_SO_NOT_LOCKED); 3473f8829a4aSRandall Stewart } 3474f8829a4aSRandall Stewart 3475f8829a4aSRandall Stewart 3476f8829a4aSRandall Stewart void 3477f8829a4aSRandall Stewart sctp_ulp_notify(uint32_t notification, struct sctp_tcb *stcb, 3478ceaad40aSRandall Stewart uint32_t error, void *data, int so_locked 3479ceaad40aSRandall Stewart #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING) 3480ceaad40aSRandall Stewart SCTP_UNUSED 3481ceaad40aSRandall Stewart #endif 3482ceaad40aSRandall Stewart ) 3483f8829a4aSRandall Stewart { 348403b0b021SRandall Stewart if (stcb == NULL) { 348503b0b021SRandall Stewart /* unlikely but */ 348603b0b021SRandall Stewart return; 348703b0b021SRandall Stewart } 3488f8829a4aSRandall Stewart if ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) || 3489f8829a4aSRandall Stewart (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_ALLGONE) || 3490f8829a4aSRandall Stewart (stcb->asoc.state & SCTP_STATE_CLOSED_SOCKET) 3491f8829a4aSRandall Stewart ) { 3492f8829a4aSRandall Stewart /* No notifications up when we are in a no socket state */ 3493f8829a4aSRandall Stewart return; 3494f8829a4aSRandall Stewart } 3495f8829a4aSRandall Stewart if (stcb->asoc.state & SCTP_STATE_CLOSED_SOCKET) { 3496f8829a4aSRandall Stewart /* Can't send up to a closed socket any notifications */ 3497f8829a4aSRandall Stewart return; 3498f8829a4aSRandall Stewart } 349917205eccSRandall Stewart if (stcb && ((stcb->asoc.state & SCTP_STATE_COOKIE_WAIT) || 350017205eccSRandall Stewart (stcb->asoc.state & SCTP_STATE_COOKIE_ECHOED))) { 350117205eccSRandall Stewart if ((notification == SCTP_NOTIFY_INTERFACE_DOWN) || 350217205eccSRandall Stewart (notification == SCTP_NOTIFY_INTERFACE_UP) || 350317205eccSRandall Stewart (notification == SCTP_NOTIFY_INTERFACE_CONFIRMED)) { 350417205eccSRandall Stewart /* Don't report these in front states */ 350517205eccSRandall Stewart return; 350617205eccSRandall Stewart } 350717205eccSRandall Stewart } 3508f8829a4aSRandall Stewart switch (notification) { 3509f8829a4aSRandall Stewart case SCTP_NOTIFY_ASSOC_UP: 3510f8829a4aSRandall Stewart if (stcb->asoc.assoc_up_sent == 0) { 3511ceaad40aSRandall Stewart sctp_notify_assoc_change(SCTP_COMM_UP, stcb, error, NULL, so_locked); 3512f8829a4aSRandall Stewart stcb->asoc.assoc_up_sent = 1; 3513f8829a4aSRandall Stewart } 35142afb3e84SRandall Stewart if (stcb->asoc.adaptation_needed && (stcb->asoc.adaptation_sent == 0)) { 35152afb3e84SRandall Stewart sctp_notify_adaptation_layer(stcb, error); 35162afb3e84SRandall Stewart } 3517f8829a4aSRandall Stewart break; 3518f8829a4aSRandall Stewart case SCTP_NOTIFY_ASSOC_DOWN: 3519ceaad40aSRandall Stewart sctp_notify_assoc_change(SCTP_SHUTDOWN_COMP, stcb, error, NULL, so_locked); 3520f8829a4aSRandall Stewart break; 3521f8829a4aSRandall Stewart case SCTP_NOTIFY_INTERFACE_DOWN: 3522f8829a4aSRandall Stewart { 3523f8829a4aSRandall Stewart struct sctp_nets *net; 3524f8829a4aSRandall Stewart 3525f8829a4aSRandall Stewart net = (struct sctp_nets *)data; 3526f8829a4aSRandall Stewart sctp_notify_peer_addr_change(stcb, SCTP_ADDR_UNREACHABLE, 3527f8829a4aSRandall Stewart (struct sockaddr *)&net->ro._l_addr, error); 3528f8829a4aSRandall Stewart break; 3529f8829a4aSRandall Stewart } 3530f8829a4aSRandall Stewart case SCTP_NOTIFY_INTERFACE_UP: 3531f8829a4aSRandall Stewart { 3532f8829a4aSRandall Stewart struct sctp_nets *net; 3533f8829a4aSRandall Stewart 3534f8829a4aSRandall Stewart net = (struct sctp_nets *)data; 3535f8829a4aSRandall Stewart sctp_notify_peer_addr_change(stcb, SCTP_ADDR_AVAILABLE, 3536f8829a4aSRandall Stewart (struct sockaddr *)&net->ro._l_addr, error); 3537f8829a4aSRandall Stewart break; 3538f8829a4aSRandall Stewart } 3539f8829a4aSRandall Stewart case SCTP_NOTIFY_INTERFACE_CONFIRMED: 3540f8829a4aSRandall Stewart { 3541f8829a4aSRandall Stewart struct sctp_nets *net; 3542f8829a4aSRandall Stewart 3543f8829a4aSRandall Stewart net = (struct sctp_nets *)data; 3544f8829a4aSRandall Stewart sctp_notify_peer_addr_change(stcb, SCTP_ADDR_CONFIRMED, 3545f8829a4aSRandall Stewart (struct sockaddr *)&net->ro._l_addr, error); 3546f8829a4aSRandall Stewart break; 3547f8829a4aSRandall Stewart } 3548f8829a4aSRandall Stewart case SCTP_NOTIFY_SPECIAL_SP_FAIL: 3549f8829a4aSRandall Stewart sctp_notify_send_failed2(stcb, error, 3550ceaad40aSRandall Stewart (struct sctp_stream_queue_pending *)data, so_locked); 3551f8829a4aSRandall Stewart break; 3552f8829a4aSRandall Stewart case SCTP_NOTIFY_DG_FAIL: 3553f8829a4aSRandall Stewart sctp_notify_send_failed(stcb, error, 3554ceaad40aSRandall Stewart (struct sctp_tmit_chunk *)data, so_locked); 3555f8829a4aSRandall Stewart break; 3556f8829a4aSRandall Stewart case SCTP_NOTIFY_PARTIAL_DELVIERY_INDICATION: 35579a6142d8SRandall Stewart { 35589a6142d8SRandall Stewart uint32_t val; 35599a6142d8SRandall Stewart 35609a6142d8SRandall Stewart val = *((uint32_t *) data); 35619a6142d8SRandall Stewart 35629a6142d8SRandall Stewart sctp_notify_partial_delivery_indication(stcb, error, 0, val); 35639a6142d8SRandall Stewart } 3564f8829a4aSRandall Stewart break; 3565f8829a4aSRandall Stewart case SCTP_NOTIFY_STRDATA_ERR: 3566f8829a4aSRandall Stewart break; 3567f8829a4aSRandall Stewart case SCTP_NOTIFY_ASSOC_ABORTED: 3568c105859eSRandall Stewart if ((stcb) && (((stcb->asoc.state & SCTP_STATE_MASK) == SCTP_STATE_COOKIE_WAIT) || 3569c105859eSRandall Stewart ((stcb->asoc.state & SCTP_STATE_MASK) == SCTP_STATE_COOKIE_ECHOED))) { 3570ceaad40aSRandall Stewart sctp_notify_assoc_change(SCTP_CANT_STR_ASSOC, stcb, error, NULL, so_locked); 3571c105859eSRandall Stewart } else { 3572ceaad40aSRandall Stewart sctp_notify_assoc_change(SCTP_COMM_LOST, stcb, error, NULL, so_locked); 3573c105859eSRandall Stewart } 3574f8829a4aSRandall Stewart break; 3575f8829a4aSRandall Stewart case SCTP_NOTIFY_PEER_OPENED_STREAM: 3576f8829a4aSRandall Stewart break; 3577f8829a4aSRandall Stewart case SCTP_NOTIFY_STREAM_OPENED_OK: 3578f8829a4aSRandall Stewart break; 3579f8829a4aSRandall Stewart case SCTP_NOTIFY_ASSOC_RESTART: 3580ceaad40aSRandall Stewart sctp_notify_assoc_change(SCTP_RESTART, stcb, error, data, so_locked); 3581f8829a4aSRandall Stewart break; 3582f8829a4aSRandall Stewart case SCTP_NOTIFY_HB_RESP: 3583f8829a4aSRandall Stewart break; 3584f8829a4aSRandall Stewart case SCTP_NOTIFY_STR_RESET_SEND: 3585f8829a4aSRandall Stewart sctp_notify_stream_reset(stcb, error, ((uint16_t *) data), SCTP_STRRESET_OUTBOUND_STR); 3586f8829a4aSRandall Stewart break; 3587f8829a4aSRandall Stewart case SCTP_NOTIFY_STR_RESET_RECV: 3588f8829a4aSRandall Stewart sctp_notify_stream_reset(stcb, error, ((uint16_t *) data), SCTP_STRRESET_INBOUND_STR); 3589f8829a4aSRandall Stewart break; 3590f8829a4aSRandall Stewart case SCTP_NOTIFY_STR_RESET_FAILED_OUT: 3591671d309cSRandall Stewart sctp_notify_stream_reset(stcb, error, ((uint16_t *) data), (SCTP_STRRESET_OUTBOUND_STR | SCTP_STRRESET_FAILED)); 3592f8829a4aSRandall Stewart break; 3593f8829a4aSRandall Stewart 3594f8829a4aSRandall Stewart case SCTP_NOTIFY_STR_RESET_FAILED_IN: 3595671d309cSRandall Stewart sctp_notify_stream_reset(stcb, error, ((uint16_t *) data), (SCTP_STRRESET_INBOUND_STR | SCTP_STRRESET_FAILED)); 3596f8829a4aSRandall Stewart break; 3597f8829a4aSRandall Stewart 3598f8829a4aSRandall Stewart case SCTP_NOTIFY_ASCONF_ADD_IP: 3599f8829a4aSRandall Stewart sctp_notify_peer_addr_change(stcb, SCTP_ADDR_ADDED, data, 3600f8829a4aSRandall Stewart error); 3601f8829a4aSRandall Stewart break; 3602f8829a4aSRandall Stewart case SCTP_NOTIFY_ASCONF_DELETE_IP: 3603f8829a4aSRandall Stewart sctp_notify_peer_addr_change(stcb, SCTP_ADDR_REMOVED, data, 3604f8829a4aSRandall Stewart error); 3605f8829a4aSRandall Stewart break; 3606f8829a4aSRandall Stewart case SCTP_NOTIFY_ASCONF_SET_PRIMARY: 3607f8829a4aSRandall Stewart sctp_notify_peer_addr_change(stcb, SCTP_ADDR_MADE_PRIM, data, 3608f8829a4aSRandall Stewart error); 3609f8829a4aSRandall Stewart break; 3610f8829a4aSRandall Stewart case SCTP_NOTIFY_ASCONF_SUCCESS: 3611f8829a4aSRandall Stewart break; 3612f8829a4aSRandall Stewart case SCTP_NOTIFY_ASCONF_FAILED: 3613f8829a4aSRandall Stewart break; 3614f8829a4aSRandall Stewart case SCTP_NOTIFY_PEER_SHUTDOWN: 3615f8829a4aSRandall Stewart sctp_notify_shutdown_event(stcb); 3616f8829a4aSRandall Stewart break; 3617f8829a4aSRandall Stewart case SCTP_NOTIFY_AUTH_NEW_KEY: 3618f8829a4aSRandall Stewart sctp_notify_authentication(stcb, SCTP_AUTH_NEWKEY, error, 3619562a89b5SRandall Stewart (uint16_t) (uintptr_t) data); 3620f8829a4aSRandall Stewart break; 3621f8829a4aSRandall Stewart #if 0 3622f8829a4aSRandall Stewart case SCTP_NOTIFY_AUTH_KEY_CONFLICT: 3623f8829a4aSRandall Stewart sctp_notify_authentication(stcb, SCTP_AUTH_KEY_CONFLICT, 3624562a89b5SRandall Stewart error, (uint16_t) (uintptr_t) data); 3625f8829a4aSRandall Stewart break; 3626f8829a4aSRandall Stewart #endif /* not yet? remove? */ 3627f8829a4aSRandall Stewart 3628f8829a4aSRandall Stewart 3629f8829a4aSRandall Stewart default: 3630ad81507eSRandall Stewart SCTPDBG(SCTP_DEBUG_UTIL1, "%s: unknown notification %xh (%u)\n", 3631ad81507eSRandall Stewart __FUNCTION__, notification, notification); 3632f8829a4aSRandall Stewart break; 3633f8829a4aSRandall Stewart } /* end switch */ 3634f8829a4aSRandall Stewart } 3635f8829a4aSRandall Stewart 3636f8829a4aSRandall Stewart void 3637ceaad40aSRandall Stewart sctp_report_all_outbound(struct sctp_tcb *stcb, int holds_lock, int so_locked 3638ceaad40aSRandall Stewart #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING) 3639ceaad40aSRandall Stewart SCTP_UNUSED 3640ceaad40aSRandall Stewart #endif 3641ceaad40aSRandall Stewart ) 3642f8829a4aSRandall Stewart { 3643f8829a4aSRandall Stewart struct sctp_association *asoc; 3644f8829a4aSRandall Stewart struct sctp_stream_out *outs; 3645f8829a4aSRandall Stewart struct sctp_tmit_chunk *chk; 3646f8829a4aSRandall Stewart struct sctp_stream_queue_pending *sp; 36477f34832bSRandall Stewart int i; 3648f8829a4aSRandall Stewart 3649f8829a4aSRandall Stewart asoc = &stcb->asoc; 3650f8829a4aSRandall Stewart 3651ad81507eSRandall Stewart if (stcb == NULL) { 3652ad81507eSRandall Stewart return; 3653ad81507eSRandall Stewart } 3654f8829a4aSRandall Stewart if ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) || 3655f8829a4aSRandall Stewart (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_ALLGONE) || 3656f8829a4aSRandall Stewart (stcb->asoc.state & SCTP_STATE_CLOSED_SOCKET)) { 3657f8829a4aSRandall Stewart return; 3658f8829a4aSRandall Stewart } 3659f8829a4aSRandall Stewart /* now through all the gunk freeing chunks */ 3660ad81507eSRandall Stewart if (holds_lock == 0) { 36617f34832bSRandall Stewart SCTP_TCB_SEND_LOCK(stcb); 3662ad81507eSRandall Stewart } 3663d00aff5dSRandall Stewart /* sent queue SHOULD be empty */ 3664d00aff5dSRandall Stewart if (!TAILQ_EMPTY(&asoc->sent_queue)) { 3665d00aff5dSRandall Stewart chk = TAILQ_FIRST(&asoc->sent_queue); 3666d00aff5dSRandall Stewart while (chk) { 3667d00aff5dSRandall Stewart TAILQ_REMOVE(&asoc->sent_queue, chk, sctp_next); 3668d00aff5dSRandall Stewart asoc->sent_queue_cnt--; 3669d00aff5dSRandall Stewart if (chk->data) { 3670d00aff5dSRandall Stewart /* 3671d00aff5dSRandall Stewart * trim off the sctp chunk header(it should 3672d00aff5dSRandall Stewart * be there) 3673d00aff5dSRandall Stewart */ 3674d00aff5dSRandall Stewart if (chk->send_size >= sizeof(struct sctp_data_chunk)) { 3675d00aff5dSRandall Stewart m_adj(chk->data, sizeof(struct sctp_data_chunk)); 3676d00aff5dSRandall Stewart sctp_mbuf_crush(chk->data); 3677d00aff5dSRandall Stewart chk->send_size -= sizeof(struct sctp_data_chunk); 3678d00aff5dSRandall Stewart } 3679d00aff5dSRandall Stewart } 3680d00aff5dSRandall Stewart sctp_free_bufspace(stcb, asoc, chk, 1); 3681d00aff5dSRandall Stewart sctp_ulp_notify(SCTP_NOTIFY_DG_FAIL, stcb, 3682ceaad40aSRandall Stewart SCTP_NOTIFY_DATAGRAM_SENT, chk, so_locked); 3683d00aff5dSRandall Stewart if (chk->data) { 3684d00aff5dSRandall Stewart sctp_m_freem(chk->data); 3685d00aff5dSRandall Stewart chk->data = NULL; 3686d00aff5dSRandall Stewart } 3687d00aff5dSRandall Stewart sctp_free_a_chunk(stcb, chk); 3688d00aff5dSRandall Stewart /* sa_ignore FREED_MEMORY */ 3689d00aff5dSRandall Stewart chk = TAILQ_FIRST(&asoc->sent_queue); 3690d00aff5dSRandall Stewart } 3691d00aff5dSRandall Stewart } 3692d00aff5dSRandall Stewart /* pending send queue SHOULD be empty */ 3693d00aff5dSRandall Stewart if (!TAILQ_EMPTY(&asoc->send_queue)) { 3694d00aff5dSRandall Stewart chk = TAILQ_FIRST(&asoc->send_queue); 3695d00aff5dSRandall Stewart while (chk) { 3696d00aff5dSRandall Stewart TAILQ_REMOVE(&asoc->send_queue, chk, sctp_next); 3697d00aff5dSRandall Stewart asoc->send_queue_cnt--; 3698d00aff5dSRandall Stewart if (chk->data) { 3699d00aff5dSRandall Stewart /* 3700d00aff5dSRandall Stewart * trim off the sctp chunk header(it should 3701d00aff5dSRandall Stewart * be there) 3702d00aff5dSRandall Stewart */ 3703d00aff5dSRandall Stewart if (chk->send_size >= sizeof(struct sctp_data_chunk)) { 3704d00aff5dSRandall Stewart m_adj(chk->data, sizeof(struct sctp_data_chunk)); 3705d00aff5dSRandall Stewart sctp_mbuf_crush(chk->data); 3706d00aff5dSRandall Stewart chk->send_size -= sizeof(struct sctp_data_chunk); 3707d00aff5dSRandall Stewart } 3708d00aff5dSRandall Stewart } 3709d00aff5dSRandall Stewart sctp_free_bufspace(stcb, asoc, chk, 1); 3710ceaad40aSRandall Stewart sctp_ulp_notify(SCTP_NOTIFY_DG_FAIL, stcb, SCTP_NOTIFY_DATAGRAM_UNSENT, chk, so_locked); 3711d00aff5dSRandall Stewart if (chk->data) { 3712d00aff5dSRandall Stewart sctp_m_freem(chk->data); 3713d00aff5dSRandall Stewart chk->data = NULL; 3714d00aff5dSRandall Stewart } 3715d00aff5dSRandall Stewart sctp_free_a_chunk(stcb, chk); 3716d00aff5dSRandall Stewart /* sa_ignore FREED_MEMORY */ 3717d00aff5dSRandall Stewart chk = TAILQ_FIRST(&asoc->send_queue); 3718d00aff5dSRandall Stewart } 3719d00aff5dSRandall Stewart } 37207f34832bSRandall Stewart for (i = 0; i < stcb->asoc.streamoutcnt; i++) { 37217f34832bSRandall Stewart /* For each stream */ 37227f34832bSRandall Stewart outs = &stcb->asoc.strmout[i]; 37237f34832bSRandall Stewart /* clean up any sends there */ 3724f8829a4aSRandall Stewart stcb->asoc.locked_on_sending = NULL; 3725f8829a4aSRandall Stewart sp = TAILQ_FIRST(&outs->outqueue); 3726f8829a4aSRandall Stewart while (sp) { 3727f8829a4aSRandall Stewart stcb->asoc.stream_queue_cnt--; 3728f8829a4aSRandall Stewart TAILQ_REMOVE(&outs->outqueue, sp, next); 3729f8829a4aSRandall Stewart sctp_free_spbufspace(stcb, asoc, sp); 3730f8829a4aSRandall Stewart sctp_ulp_notify(SCTP_NOTIFY_SPECIAL_SP_FAIL, stcb, 3731ceaad40aSRandall Stewart SCTP_NOTIFY_DATAGRAM_UNSENT, (void *)sp, so_locked); 3732f8829a4aSRandall Stewart if (sp->data) { 3733f8829a4aSRandall Stewart sctp_m_freem(sp->data); 3734f8829a4aSRandall Stewart sp->data = NULL; 3735f8829a4aSRandall Stewart } 3736f8829a4aSRandall Stewart if (sp->net) 3737f8829a4aSRandall Stewart sctp_free_remote_addr(sp->net); 3738f8829a4aSRandall Stewart sp->net = NULL; 3739f8829a4aSRandall Stewart /* Free the chunk */ 3740f8829a4aSRandall Stewart sctp_free_a_strmoq(stcb, sp); 37413c503c28SRandall Stewart /* sa_ignore FREED_MEMORY */ 3742f8829a4aSRandall Stewart sp = TAILQ_FIRST(&outs->outqueue); 3743f8829a4aSRandall Stewart } 3744f8829a4aSRandall Stewart } 3745f8829a4aSRandall Stewart 3746ad81507eSRandall Stewart if (holds_lock == 0) { 37477f34832bSRandall Stewart SCTP_TCB_SEND_UNLOCK(stcb); 3748f8829a4aSRandall Stewart } 3749ad81507eSRandall Stewart } 3750f8829a4aSRandall Stewart 3751f8829a4aSRandall Stewart void 3752ceaad40aSRandall Stewart sctp_abort_notification(struct sctp_tcb *stcb, int error, int so_locked 3753ceaad40aSRandall Stewart #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING) 3754ceaad40aSRandall Stewart SCTP_UNUSED 3755ceaad40aSRandall Stewart #endif 3756ceaad40aSRandall Stewart ) 3757f8829a4aSRandall Stewart { 3758f8829a4aSRandall Stewart 3759ad81507eSRandall Stewart if (stcb == NULL) { 3760ad81507eSRandall Stewart return; 3761ad81507eSRandall Stewart } 3762f8829a4aSRandall Stewart if ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) || 3763f8829a4aSRandall Stewart (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_ALLGONE) || 3764f8829a4aSRandall Stewart (stcb->asoc.state & SCTP_STATE_CLOSED_SOCKET)) { 3765f8829a4aSRandall Stewart return; 3766f8829a4aSRandall Stewart } 3767f8829a4aSRandall Stewart /* Tell them we lost the asoc */ 3768ceaad40aSRandall Stewart sctp_report_all_outbound(stcb, 1, so_locked); 3769f8829a4aSRandall Stewart if ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) || 3770f8829a4aSRandall Stewart ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) && 3771f8829a4aSRandall Stewart (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_CONNECTED))) { 3772f8829a4aSRandall Stewart stcb->sctp_ep->sctp_flags |= SCTP_PCB_FLAGS_WAS_ABORTED; 3773f8829a4aSRandall Stewart } 3774ceaad40aSRandall Stewart sctp_ulp_notify(SCTP_NOTIFY_ASSOC_ABORTED, stcb, error, NULL, so_locked); 3775f8829a4aSRandall Stewart } 3776f8829a4aSRandall Stewart 3777f8829a4aSRandall Stewart void 3778f8829a4aSRandall Stewart sctp_abort_association(struct sctp_inpcb *inp, struct sctp_tcb *stcb, 377917205eccSRandall Stewart struct mbuf *m, int iphlen, struct sctphdr *sh, struct mbuf *op_err, 3780ad21a364SRandall Stewart uint32_t vrf_id) 3781f8829a4aSRandall Stewart { 3782f8829a4aSRandall Stewart uint32_t vtag; 3783f8829a4aSRandall Stewart 3784ceaad40aSRandall Stewart #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 3785ceaad40aSRandall Stewart struct socket *so; 3786ceaad40aSRandall Stewart 3787ceaad40aSRandall Stewart #endif 3788ceaad40aSRandall Stewart 3789f8829a4aSRandall Stewart vtag = 0; 3790f8829a4aSRandall Stewart if (stcb != NULL) { 3791f8829a4aSRandall Stewart /* We have a TCB to abort, send notification too */ 3792f8829a4aSRandall Stewart vtag = stcb->asoc.peer_vtag; 3793ceaad40aSRandall Stewart sctp_abort_notification(stcb, 0, SCTP_SO_NOT_LOCKED); 379417205eccSRandall Stewart /* get the assoc vrf id and table id */ 379517205eccSRandall Stewart vrf_id = stcb->asoc.vrf_id; 379663981c2bSRandall Stewart stcb->asoc.state |= SCTP_STATE_WAS_ABORTED; 3797f8829a4aSRandall Stewart } 3798ad21a364SRandall Stewart sctp_send_abort(m, iphlen, sh, vtag, op_err, vrf_id); 3799f8829a4aSRandall Stewart if (stcb != NULL) { 3800f8829a4aSRandall Stewart /* Ok, now lets free it */ 3801ceaad40aSRandall Stewart #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 3802ceaad40aSRandall Stewart so = SCTP_INP_SO(inp); 3803ceaad40aSRandall Stewart atomic_add_int(&stcb->asoc.refcnt, 1); 3804ceaad40aSRandall Stewart SCTP_TCB_UNLOCK(stcb); 3805ceaad40aSRandall Stewart SCTP_SOCKET_LOCK(so, 1); 3806ceaad40aSRandall Stewart SCTP_TCB_LOCK(stcb); 3807ceaad40aSRandall Stewart atomic_subtract_int(&stcb->asoc.refcnt, 1); 3808ceaad40aSRandall Stewart #endif 3809c4739e2fSRandall Stewart (void)sctp_free_assoc(inp, stcb, SCTP_NORMAL_PROC, SCTP_FROM_SCTPUTIL + SCTP_LOC_4); 3810ceaad40aSRandall Stewart #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 3811ceaad40aSRandall Stewart SCTP_SOCKET_UNLOCK(so, 1); 3812ceaad40aSRandall Stewart #endif 3813f8829a4aSRandall Stewart } else { 3814f8829a4aSRandall Stewart if (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) { 3815f8829a4aSRandall Stewart if (LIST_FIRST(&inp->sctp_asoc_list) == NULL) { 3816b0552ae2SRandall Stewart sctp_inpcb_free(inp, SCTP_FREE_SHOULD_USE_ABORT, 3817b0552ae2SRandall Stewart SCTP_CALLED_DIRECTLY_NOCMPSET); 3818f8829a4aSRandall Stewart } 3819f8829a4aSRandall Stewart } 3820f8829a4aSRandall Stewart } 3821f8829a4aSRandall Stewart } 3822f8829a4aSRandall Stewart 3823f1f73e57SRandall Stewart #ifdef SCTP_ASOCLOG_OF_TSNS 3824f1f73e57SRandall Stewart void 3825f1f73e57SRandall Stewart sctp_print_out_track_log(struct sctp_tcb *stcb) 3826f1f73e57SRandall Stewart { 382718e198d3SRandall Stewart #ifdef NOSIY_PRINTS 3828f1f73e57SRandall Stewart int i; 3829f1f73e57SRandall Stewart 3830ad81507eSRandall Stewart SCTP_PRINTF("Last ep reason:%x\n", stcb->sctp_ep->last_abort_code); 3831ad81507eSRandall Stewart SCTP_PRINTF("IN bound TSN log-aaa\n"); 3832f1f73e57SRandall Stewart if ((stcb->asoc.tsn_in_at == 0) && (stcb->asoc.tsn_in_wrapped == 0)) { 3833ad81507eSRandall Stewart SCTP_PRINTF("None rcvd\n"); 3834f1f73e57SRandall Stewart goto none_in; 3835f1f73e57SRandall Stewart } 3836f1f73e57SRandall Stewart if (stcb->asoc.tsn_in_wrapped) { 3837f1f73e57SRandall Stewart for (i = stcb->asoc.tsn_in_at; i < SCTP_TSN_LOG_SIZE; i++) { 3838ad81507eSRandall Stewart SCTP_PRINTF("TSN:%x strm:%d seq:%d flags:%x sz:%d\n", 3839f1f73e57SRandall Stewart stcb->asoc.in_tsnlog[i].tsn, 3840f1f73e57SRandall Stewart stcb->asoc.in_tsnlog[i].strm, 3841f1f73e57SRandall Stewart stcb->asoc.in_tsnlog[i].seq, 3842f1f73e57SRandall Stewart stcb->asoc.in_tsnlog[i].flgs, 3843f1f73e57SRandall Stewart stcb->asoc.in_tsnlog[i].sz); 3844f1f73e57SRandall Stewart } 3845f1f73e57SRandall Stewart } 3846f1f73e57SRandall Stewart if (stcb->asoc.tsn_in_at) { 3847f1f73e57SRandall Stewart for (i = 0; i < stcb->asoc.tsn_in_at; i++) { 3848ad81507eSRandall Stewart SCTP_PRINTF("TSN:%x strm:%d seq:%d flags:%x sz:%d\n", 3849f1f73e57SRandall Stewart stcb->asoc.in_tsnlog[i].tsn, 3850f1f73e57SRandall Stewart stcb->asoc.in_tsnlog[i].strm, 3851f1f73e57SRandall Stewart stcb->asoc.in_tsnlog[i].seq, 3852f1f73e57SRandall Stewart stcb->asoc.in_tsnlog[i].flgs, 3853f1f73e57SRandall Stewart stcb->asoc.in_tsnlog[i].sz); 3854f1f73e57SRandall Stewart } 3855f1f73e57SRandall Stewart } 3856f1f73e57SRandall Stewart none_in: 3857ad81507eSRandall Stewart SCTP_PRINTF("OUT bound TSN log-aaa\n"); 3858ad81507eSRandall Stewart if ((stcb->asoc.tsn_out_at == 0) && 3859ad81507eSRandall Stewart (stcb->asoc.tsn_out_wrapped == 0)) { 3860ad81507eSRandall Stewart SCTP_PRINTF("None sent\n"); 3861f1f73e57SRandall Stewart } 3862f1f73e57SRandall Stewart if (stcb->asoc.tsn_out_wrapped) { 3863f1f73e57SRandall Stewart for (i = stcb->asoc.tsn_out_at; i < SCTP_TSN_LOG_SIZE; i++) { 3864ad81507eSRandall Stewart SCTP_PRINTF("TSN:%x strm:%d seq:%d flags:%x sz:%d\n", 3865f1f73e57SRandall Stewart stcb->asoc.out_tsnlog[i].tsn, 3866f1f73e57SRandall Stewart stcb->asoc.out_tsnlog[i].strm, 3867f1f73e57SRandall Stewart stcb->asoc.out_tsnlog[i].seq, 3868f1f73e57SRandall Stewart stcb->asoc.out_tsnlog[i].flgs, 3869f1f73e57SRandall Stewart stcb->asoc.out_tsnlog[i].sz); 3870f1f73e57SRandall Stewart } 3871f1f73e57SRandall Stewart } 3872f1f73e57SRandall Stewart if (stcb->asoc.tsn_out_at) { 3873f1f73e57SRandall Stewart for (i = 0; i < stcb->asoc.tsn_out_at; i++) { 3874ad81507eSRandall Stewart SCTP_PRINTF("TSN:%x strm:%d seq:%d flags:%x sz:%d\n", 3875f1f73e57SRandall Stewart stcb->asoc.out_tsnlog[i].tsn, 3876f1f73e57SRandall Stewart stcb->asoc.out_tsnlog[i].strm, 3877f1f73e57SRandall Stewart stcb->asoc.out_tsnlog[i].seq, 3878f1f73e57SRandall Stewart stcb->asoc.out_tsnlog[i].flgs, 3879f1f73e57SRandall Stewart stcb->asoc.out_tsnlog[i].sz); 3880f1f73e57SRandall Stewart } 3881f1f73e57SRandall Stewart } 388218e198d3SRandall Stewart #endif 3883f1f73e57SRandall Stewart } 3884f1f73e57SRandall Stewart 3885f1f73e57SRandall Stewart #endif 3886f1f73e57SRandall Stewart 3887f8829a4aSRandall Stewart void 3888f8829a4aSRandall Stewart sctp_abort_an_association(struct sctp_inpcb *inp, struct sctp_tcb *stcb, 3889ceaad40aSRandall Stewart int error, struct mbuf *op_err, 3890ceaad40aSRandall Stewart int so_locked 3891ceaad40aSRandall Stewart #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING) 3892ceaad40aSRandall Stewart SCTP_UNUSED 3893ceaad40aSRandall Stewart #endif 3894ceaad40aSRandall Stewart ) 3895f8829a4aSRandall Stewart { 3896f8829a4aSRandall Stewart uint32_t vtag; 3897f8829a4aSRandall Stewart 3898ceaad40aSRandall Stewart #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 3899ceaad40aSRandall Stewart struct socket *so; 3900ceaad40aSRandall Stewart 3901ceaad40aSRandall Stewart #endif 3902ceaad40aSRandall Stewart 3903ceaad40aSRandall Stewart #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 3904ceaad40aSRandall Stewart so = SCTP_INP_SO(inp); 3905ceaad40aSRandall Stewart #endif 3906f8829a4aSRandall Stewart if (stcb == NULL) { 3907f8829a4aSRandall Stewart /* Got to have a TCB */ 3908f8829a4aSRandall Stewart if (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) { 3909f8829a4aSRandall Stewart if (LIST_FIRST(&inp->sctp_asoc_list) == NULL) { 3910b0552ae2SRandall Stewart sctp_inpcb_free(inp, SCTP_FREE_SHOULD_USE_ABORT, 3911b0552ae2SRandall Stewart SCTP_CALLED_DIRECTLY_NOCMPSET); 3912f8829a4aSRandall Stewart } 3913f8829a4aSRandall Stewart } 3914f8829a4aSRandall Stewart return; 391563981c2bSRandall Stewart } else { 391663981c2bSRandall Stewart stcb->asoc.state |= SCTP_STATE_WAS_ABORTED; 3917f8829a4aSRandall Stewart } 3918f8829a4aSRandall Stewart vtag = stcb->asoc.peer_vtag; 3919f8829a4aSRandall Stewart /* notify the ulp */ 3920f8829a4aSRandall Stewart if ((inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) == 0) 3921ceaad40aSRandall Stewart sctp_abort_notification(stcb, error, so_locked); 3922f8829a4aSRandall Stewart /* notify the peer */ 3923b201f536SRandall Stewart #if defined(SCTP_PANIC_ON_ABORT) 3924b201f536SRandall Stewart panic("aborting an association"); 3925b201f536SRandall Stewart #endif 3926ceaad40aSRandall Stewart sctp_send_abort_tcb(stcb, op_err, so_locked); 3927f8829a4aSRandall Stewart SCTP_STAT_INCR_COUNTER32(sctps_aborted); 3928f8829a4aSRandall Stewart if ((SCTP_GET_STATE(&stcb->asoc) == SCTP_STATE_OPEN) || 3929f8829a4aSRandall Stewart (SCTP_GET_STATE(&stcb->asoc) == SCTP_STATE_SHUTDOWN_RECEIVED)) { 3930f8829a4aSRandall Stewart SCTP_STAT_DECR_GAUGE32(sctps_currestab); 3931f8829a4aSRandall Stewart } 3932f8829a4aSRandall Stewart /* now free the asoc */ 3933f1f73e57SRandall Stewart #ifdef SCTP_ASOCLOG_OF_TSNS 3934f1f73e57SRandall Stewart sctp_print_out_track_log(stcb); 3935f1f73e57SRandall Stewart #endif 3936ceaad40aSRandall Stewart #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 3937ceaad40aSRandall Stewart if (!so_locked) { 3938ceaad40aSRandall Stewart atomic_add_int(&stcb->asoc.refcnt, 1); 3939ceaad40aSRandall Stewart SCTP_TCB_UNLOCK(stcb); 3940ceaad40aSRandall Stewart SCTP_SOCKET_LOCK(so, 1); 3941ceaad40aSRandall Stewart SCTP_TCB_LOCK(stcb); 3942ceaad40aSRandall Stewart atomic_subtract_int(&stcb->asoc.refcnt, 1); 3943ceaad40aSRandall Stewart } 3944ceaad40aSRandall Stewart #endif 3945c4739e2fSRandall Stewart (void)sctp_free_assoc(inp, stcb, SCTP_NORMAL_PROC, SCTP_FROM_SCTPUTIL + SCTP_LOC_5); 3946ceaad40aSRandall Stewart #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 3947ceaad40aSRandall Stewart if (!so_locked) { 3948ceaad40aSRandall Stewart SCTP_SOCKET_UNLOCK(so, 1); 3949ceaad40aSRandall Stewart } 3950ceaad40aSRandall Stewart #endif 3951f8829a4aSRandall Stewart } 3952f8829a4aSRandall Stewart 3953f8829a4aSRandall Stewart void 3954f8829a4aSRandall Stewart sctp_handle_ootb(struct mbuf *m, int iphlen, int offset, struct sctphdr *sh, 3955ad21a364SRandall Stewart struct sctp_inpcb *inp, struct mbuf *op_err, uint32_t vrf_id) 3956f8829a4aSRandall Stewart { 3957f8829a4aSRandall Stewart struct sctp_chunkhdr *ch, chunk_buf; 3958f8829a4aSRandall Stewart unsigned int chk_length; 3959f8829a4aSRandall Stewart 3960f8829a4aSRandall Stewart SCTP_STAT_INCR_COUNTER32(sctps_outoftheblue); 3961f8829a4aSRandall Stewart /* Generate a TO address for future reference */ 3962f8829a4aSRandall Stewart if (inp && (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE)) { 3963f8829a4aSRandall Stewart if (LIST_FIRST(&inp->sctp_asoc_list) == NULL) { 3964b0552ae2SRandall Stewart sctp_inpcb_free(inp, SCTP_FREE_SHOULD_USE_ABORT, 3965b0552ae2SRandall Stewart SCTP_CALLED_DIRECTLY_NOCMPSET); 3966f8829a4aSRandall Stewart } 3967f8829a4aSRandall Stewart } 3968f8829a4aSRandall Stewart ch = (struct sctp_chunkhdr *)sctp_m_getptr(m, offset, 3969f8829a4aSRandall Stewart sizeof(*ch), (uint8_t *) & chunk_buf); 3970f8829a4aSRandall Stewart while (ch != NULL) { 3971f8829a4aSRandall Stewart chk_length = ntohs(ch->chunk_length); 3972f8829a4aSRandall Stewart if (chk_length < sizeof(*ch)) { 3973f8829a4aSRandall Stewart /* break to abort land */ 3974f8829a4aSRandall Stewart break; 3975f8829a4aSRandall Stewart } 3976f8829a4aSRandall Stewart switch (ch->chunk_type) { 3977d55b0b1bSRandall Stewart case SCTP_COOKIE_ECHO: 3978d55b0b1bSRandall Stewart /* We hit here only if the assoc is being freed */ 3979d55b0b1bSRandall Stewart return; 3980f8829a4aSRandall Stewart case SCTP_PACKET_DROPPED: 3981f8829a4aSRandall Stewart /* we don't respond to pkt-dropped */ 3982f8829a4aSRandall Stewart return; 3983f8829a4aSRandall Stewart case SCTP_ABORT_ASSOCIATION: 3984f8829a4aSRandall Stewart /* we don't respond with an ABORT to an ABORT */ 3985f8829a4aSRandall Stewart return; 3986f8829a4aSRandall Stewart case SCTP_SHUTDOWN_COMPLETE: 3987f8829a4aSRandall Stewart /* 3988f8829a4aSRandall Stewart * we ignore it since we are not waiting for it and 3989f8829a4aSRandall Stewart * peer is gone 3990f8829a4aSRandall Stewart */ 3991f8829a4aSRandall Stewart return; 3992f8829a4aSRandall Stewart case SCTP_SHUTDOWN_ACK: 3993ad21a364SRandall Stewart sctp_send_shutdown_complete2(m, iphlen, sh, vrf_id); 3994f8829a4aSRandall Stewart return; 3995f8829a4aSRandall Stewart default: 3996f8829a4aSRandall Stewart break; 3997f8829a4aSRandall Stewart } 3998f8829a4aSRandall Stewart offset += SCTP_SIZE32(chk_length); 3999f8829a4aSRandall Stewart ch = (struct sctp_chunkhdr *)sctp_m_getptr(m, offset, 4000f8829a4aSRandall Stewart sizeof(*ch), (uint8_t *) & chunk_buf); 4001f8829a4aSRandall Stewart } 4002ad21a364SRandall Stewart sctp_send_abort(m, iphlen, sh, 0, op_err, vrf_id); 4003f8829a4aSRandall Stewart } 4004f8829a4aSRandall Stewart 4005f8829a4aSRandall Stewart /* 4006f8829a4aSRandall Stewart * check the inbound datagram to make sure there is not an abort inside it, 4007f8829a4aSRandall Stewart * if there is return 1, else return 0. 4008f8829a4aSRandall Stewart */ 4009f8829a4aSRandall Stewart int 4010f8829a4aSRandall Stewart sctp_is_there_an_abort_here(struct mbuf *m, int iphlen, uint32_t * vtagfill) 4011f8829a4aSRandall Stewart { 4012f8829a4aSRandall Stewart struct sctp_chunkhdr *ch; 4013f8829a4aSRandall Stewart struct sctp_init_chunk *init_chk, chunk_buf; 4014f8829a4aSRandall Stewart int offset; 4015f8829a4aSRandall Stewart unsigned int chk_length; 4016f8829a4aSRandall Stewart 4017f8829a4aSRandall Stewart offset = iphlen + sizeof(struct sctphdr); 4018f8829a4aSRandall Stewart ch = (struct sctp_chunkhdr *)sctp_m_getptr(m, offset, sizeof(*ch), 4019f8829a4aSRandall Stewart (uint8_t *) & chunk_buf); 4020f8829a4aSRandall Stewart while (ch != NULL) { 4021f8829a4aSRandall Stewart chk_length = ntohs(ch->chunk_length); 4022f8829a4aSRandall Stewart if (chk_length < sizeof(*ch)) { 4023f8829a4aSRandall Stewart /* packet is probably corrupt */ 4024f8829a4aSRandall Stewart break; 4025f8829a4aSRandall Stewart } 4026f8829a4aSRandall Stewart /* we seem to be ok, is it an abort? */ 4027f8829a4aSRandall Stewart if (ch->chunk_type == SCTP_ABORT_ASSOCIATION) { 4028f8829a4aSRandall Stewart /* yep, tell them */ 4029f8829a4aSRandall Stewart return (1); 4030f8829a4aSRandall Stewart } 4031f8829a4aSRandall Stewart if (ch->chunk_type == SCTP_INITIATION) { 4032f8829a4aSRandall Stewart /* need to update the Vtag */ 4033f8829a4aSRandall Stewart init_chk = (struct sctp_init_chunk *)sctp_m_getptr(m, 4034f8829a4aSRandall Stewart offset, sizeof(*init_chk), (uint8_t *) & chunk_buf); 4035f8829a4aSRandall Stewart if (init_chk != NULL) { 4036f8829a4aSRandall Stewart *vtagfill = ntohl(init_chk->init.initiate_tag); 4037f8829a4aSRandall Stewart } 4038f8829a4aSRandall Stewart } 4039f8829a4aSRandall Stewart /* Nope, move to the next chunk */ 4040f8829a4aSRandall Stewart offset += SCTP_SIZE32(chk_length); 4041f8829a4aSRandall Stewart ch = (struct sctp_chunkhdr *)sctp_m_getptr(m, offset, 4042f8829a4aSRandall Stewart sizeof(*ch), (uint8_t *) & chunk_buf); 4043f8829a4aSRandall Stewart } 4044f8829a4aSRandall Stewart return (0); 4045f8829a4aSRandall Stewart } 4046f8829a4aSRandall Stewart 4047f8829a4aSRandall Stewart /* 4048f8829a4aSRandall Stewart * currently (2/02), ifa_addr embeds scope_id's and don't have sin6_scope_id 4049f8829a4aSRandall Stewart * set (i.e. it's 0) so, create this function to compare link local scopes 4050f8829a4aSRandall Stewart */ 4051f8829a4aSRandall Stewart uint32_t 4052f8829a4aSRandall Stewart sctp_is_same_scope(struct sockaddr_in6 *addr1, struct sockaddr_in6 *addr2) 4053f8829a4aSRandall Stewart { 4054f8829a4aSRandall Stewart struct sockaddr_in6 a, b; 4055f8829a4aSRandall Stewart 4056f8829a4aSRandall Stewart /* save copies */ 4057f8829a4aSRandall Stewart a = *addr1; 4058f8829a4aSRandall Stewart b = *addr2; 4059f8829a4aSRandall Stewart 4060f8829a4aSRandall Stewart if (a.sin6_scope_id == 0) 4061f8829a4aSRandall Stewart if (sa6_recoverscope(&a)) { 4062f8829a4aSRandall Stewart /* can't get scope, so can't match */ 4063f8829a4aSRandall Stewart return (0); 4064f8829a4aSRandall Stewart } 4065f8829a4aSRandall Stewart if (b.sin6_scope_id == 0) 4066f8829a4aSRandall Stewart if (sa6_recoverscope(&b)) { 4067f8829a4aSRandall Stewart /* can't get scope, so can't match */ 4068f8829a4aSRandall Stewart return (0); 4069f8829a4aSRandall Stewart } 4070f8829a4aSRandall Stewart if (a.sin6_scope_id != b.sin6_scope_id) 4071f8829a4aSRandall Stewart return (0); 4072f8829a4aSRandall Stewart 4073f8829a4aSRandall Stewart return (1); 4074f8829a4aSRandall Stewart } 4075f8829a4aSRandall Stewart 4076f8829a4aSRandall Stewart /* 4077f8829a4aSRandall Stewart * returns a sockaddr_in6 with embedded scope recovered and removed 4078f8829a4aSRandall Stewart */ 4079f8829a4aSRandall Stewart struct sockaddr_in6 * 4080f8829a4aSRandall Stewart sctp_recover_scope(struct sockaddr_in6 *addr, struct sockaddr_in6 *store) 4081f8829a4aSRandall Stewart { 4082f8829a4aSRandall Stewart /* check and strip embedded scope junk */ 4083f8829a4aSRandall Stewart if (addr->sin6_family == AF_INET6) { 4084f8829a4aSRandall Stewart if (IN6_IS_SCOPE_LINKLOCAL(&addr->sin6_addr)) { 4085f8829a4aSRandall Stewart if (addr->sin6_scope_id == 0) { 4086f8829a4aSRandall Stewart *store = *addr; 4087f8829a4aSRandall Stewart if (!sa6_recoverscope(store)) { 4088f8829a4aSRandall Stewart /* use the recovered scope */ 4089f8829a4aSRandall Stewart addr = store; 4090f8829a4aSRandall Stewart } 4091f42a358aSRandall Stewart } else { 4092f8829a4aSRandall Stewart /* else, return the original "to" addr */ 4093f42a358aSRandall Stewart in6_clearscope(&addr->sin6_addr); 4094f8829a4aSRandall Stewart } 4095f8829a4aSRandall Stewart } 4096f8829a4aSRandall Stewart } 4097f8829a4aSRandall Stewart return (addr); 4098f8829a4aSRandall Stewart } 4099f8829a4aSRandall Stewart 4100f8829a4aSRandall Stewart /* 4101f8829a4aSRandall Stewart * are the two addresses the same? currently a "scopeless" check returns: 1 4102f8829a4aSRandall Stewart * if same, 0 if not 4103f8829a4aSRandall Stewart */ 410472fb6fdbSRandall Stewart int 4105f8829a4aSRandall Stewart sctp_cmpaddr(struct sockaddr *sa1, struct sockaddr *sa2) 4106f8829a4aSRandall Stewart { 4107f8829a4aSRandall Stewart 4108f8829a4aSRandall Stewart /* must be valid */ 4109f8829a4aSRandall Stewart if (sa1 == NULL || sa2 == NULL) 4110f8829a4aSRandall Stewart return (0); 4111f8829a4aSRandall Stewart 4112f8829a4aSRandall Stewart /* must be the same family */ 4113f8829a4aSRandall Stewart if (sa1->sa_family != sa2->sa_family) 4114f8829a4aSRandall Stewart return (0); 4115f8829a4aSRandall Stewart 4116f8829a4aSRandall Stewart if (sa1->sa_family == AF_INET6) { 4117f8829a4aSRandall Stewart /* IPv6 addresses */ 4118f8829a4aSRandall Stewart struct sockaddr_in6 *sin6_1, *sin6_2; 4119f8829a4aSRandall Stewart 4120f8829a4aSRandall Stewart sin6_1 = (struct sockaddr_in6 *)sa1; 4121f8829a4aSRandall Stewart sin6_2 = (struct sockaddr_in6 *)sa2; 4122f8829a4aSRandall Stewart return (SCTP6_ARE_ADDR_EQUAL(&sin6_1->sin6_addr, 4123f8829a4aSRandall Stewart &sin6_2->sin6_addr)); 4124f8829a4aSRandall Stewart } else if (sa1->sa_family == AF_INET) { 4125f8829a4aSRandall Stewart /* IPv4 addresses */ 4126f8829a4aSRandall Stewart struct sockaddr_in *sin_1, *sin_2; 4127f8829a4aSRandall Stewart 4128f8829a4aSRandall Stewart sin_1 = (struct sockaddr_in *)sa1; 4129f8829a4aSRandall Stewart sin_2 = (struct sockaddr_in *)sa2; 4130f8829a4aSRandall Stewart return (sin_1->sin_addr.s_addr == sin_2->sin_addr.s_addr); 4131f8829a4aSRandall Stewart } else { 4132f8829a4aSRandall Stewart /* we don't do these... */ 4133f8829a4aSRandall Stewart return (0); 4134f8829a4aSRandall Stewart } 4135f8829a4aSRandall Stewart } 4136f8829a4aSRandall Stewart 4137f8829a4aSRandall Stewart void 4138f8829a4aSRandall Stewart sctp_print_address(struct sockaddr *sa) 4139f8829a4aSRandall Stewart { 41407d32aa0cSBjoern A. Zeeb char ip6buf[INET6_ADDRSTRLEN]; 4141f8829a4aSRandall Stewart 4142ad81507eSRandall Stewart ip6buf[0] = 0; 4143ad81507eSRandall Stewart if (sa->sa_family == AF_INET6) { 4144ad81507eSRandall Stewart struct sockaddr_in6 *sin6; 4145ad81507eSRandall Stewart 4146f8829a4aSRandall Stewart sin6 = (struct sockaddr_in6 *)sa; 4147ad81507eSRandall Stewart SCTP_PRINTF("IPv6 address: %s:port:%d scope:%u\n", 41487d32aa0cSBjoern A. Zeeb ip6_sprintf(ip6buf, &sin6->sin6_addr), 41497d32aa0cSBjoern A. Zeeb ntohs(sin6->sin6_port), 4150f8829a4aSRandall Stewart sin6->sin6_scope_id); 4151f8829a4aSRandall Stewart } else if (sa->sa_family == AF_INET) { 4152f8829a4aSRandall Stewart struct sockaddr_in *sin; 4153f8829a4aSRandall Stewart unsigned char *p; 4154f8829a4aSRandall Stewart 4155f8829a4aSRandall Stewart sin = (struct sockaddr_in *)sa; 4156f8829a4aSRandall Stewart p = (unsigned char *)&sin->sin_addr; 4157ad81507eSRandall Stewart SCTP_PRINTF("IPv4 address: %u.%u.%u.%u:%d\n", 4158f8829a4aSRandall Stewart p[0], p[1], p[2], p[3], ntohs(sin->sin_port)); 4159f8829a4aSRandall Stewart } else { 4160ad81507eSRandall Stewart SCTP_PRINTF("?\n"); 4161f8829a4aSRandall Stewart } 4162f8829a4aSRandall Stewart } 4163f8829a4aSRandall Stewart 4164f8829a4aSRandall Stewart void 4165f8829a4aSRandall Stewart sctp_print_address_pkt(struct ip *iph, struct sctphdr *sh) 4166f8829a4aSRandall Stewart { 4167f8829a4aSRandall Stewart if (iph->ip_v == IPVERSION) { 4168f8829a4aSRandall Stewart struct sockaddr_in lsa, fsa; 4169f8829a4aSRandall Stewart 4170f8829a4aSRandall Stewart bzero(&lsa, sizeof(lsa)); 4171f8829a4aSRandall Stewart lsa.sin_len = sizeof(lsa); 4172f8829a4aSRandall Stewart lsa.sin_family = AF_INET; 4173f8829a4aSRandall Stewart lsa.sin_addr = iph->ip_src; 4174f8829a4aSRandall Stewart lsa.sin_port = sh->src_port; 4175f8829a4aSRandall Stewart bzero(&fsa, sizeof(fsa)); 4176f8829a4aSRandall Stewart fsa.sin_len = sizeof(fsa); 4177f8829a4aSRandall Stewart fsa.sin_family = AF_INET; 4178f8829a4aSRandall Stewart fsa.sin_addr = iph->ip_dst; 4179f8829a4aSRandall Stewart fsa.sin_port = sh->dest_port; 4180ad81507eSRandall Stewart SCTP_PRINTF("src: "); 4181f8829a4aSRandall Stewart sctp_print_address((struct sockaddr *)&lsa); 4182ad81507eSRandall Stewart SCTP_PRINTF("dest: "); 4183f8829a4aSRandall Stewart sctp_print_address((struct sockaddr *)&fsa); 4184f8829a4aSRandall Stewart } else if (iph->ip_v == (IPV6_VERSION >> 4)) { 4185f8829a4aSRandall Stewart struct ip6_hdr *ip6; 4186f8829a4aSRandall Stewart struct sockaddr_in6 lsa6, fsa6; 4187f8829a4aSRandall Stewart 4188f8829a4aSRandall Stewart ip6 = (struct ip6_hdr *)iph; 4189f8829a4aSRandall Stewart bzero(&lsa6, sizeof(lsa6)); 4190f8829a4aSRandall Stewart lsa6.sin6_len = sizeof(lsa6); 4191f8829a4aSRandall Stewart lsa6.sin6_family = AF_INET6; 4192f8829a4aSRandall Stewart lsa6.sin6_addr = ip6->ip6_src; 4193f8829a4aSRandall Stewart lsa6.sin6_port = sh->src_port; 4194f8829a4aSRandall Stewart bzero(&fsa6, sizeof(fsa6)); 4195f8829a4aSRandall Stewart fsa6.sin6_len = sizeof(fsa6); 4196f8829a4aSRandall Stewart fsa6.sin6_family = AF_INET6; 4197f8829a4aSRandall Stewart fsa6.sin6_addr = ip6->ip6_dst; 4198f8829a4aSRandall Stewart fsa6.sin6_port = sh->dest_port; 4199ad81507eSRandall Stewart SCTP_PRINTF("src: "); 4200f8829a4aSRandall Stewart sctp_print_address((struct sockaddr *)&lsa6); 4201ad81507eSRandall Stewart SCTP_PRINTF("dest: "); 4202f8829a4aSRandall Stewart sctp_print_address((struct sockaddr *)&fsa6); 4203f8829a4aSRandall Stewart } 4204f8829a4aSRandall Stewart } 4205f8829a4aSRandall Stewart 4206f8829a4aSRandall Stewart void 4207f8829a4aSRandall Stewart sctp_pull_off_control_to_new_inp(struct sctp_inpcb *old_inp, 4208f8829a4aSRandall Stewart struct sctp_inpcb *new_inp, 4209d06c82f1SRandall Stewart struct sctp_tcb *stcb, 4210d06c82f1SRandall Stewart int waitflags) 4211f8829a4aSRandall Stewart { 4212f8829a4aSRandall Stewart /* 4213f8829a4aSRandall Stewart * go through our old INP and pull off any control structures that 4214f8829a4aSRandall Stewart * belong to stcb and move then to the new inp. 4215f8829a4aSRandall Stewart */ 4216f8829a4aSRandall Stewart struct socket *old_so, *new_so; 4217f8829a4aSRandall Stewart struct sctp_queued_to_read *control, *nctl; 4218f8829a4aSRandall Stewart struct sctp_readhead tmp_queue; 4219f8829a4aSRandall Stewart struct mbuf *m; 4220bff64a4dSRandall Stewart int error = 0; 4221f8829a4aSRandall Stewart 4222f8829a4aSRandall Stewart old_so = old_inp->sctp_socket; 4223f8829a4aSRandall Stewart new_so = new_inp->sctp_socket; 4224f8829a4aSRandall Stewart TAILQ_INIT(&tmp_queue); 4225d06c82f1SRandall Stewart error = sblock(&old_so->so_rcv, waitflags); 4226f8829a4aSRandall Stewart if (error) { 4227f8829a4aSRandall Stewart /* 4228f8829a4aSRandall Stewart * Gak, can't get sblock, we have a problem. data will be 4229f8829a4aSRandall Stewart * left stranded.. and we don't dare look at it since the 4230f8829a4aSRandall Stewart * other thread may be reading something. Oh well, its a 4231f8829a4aSRandall Stewart * screwed up app that does a peeloff OR a accept while 4232f8829a4aSRandall Stewart * reading from the main socket... actually its only the 4233f8829a4aSRandall Stewart * peeloff() case, since I think read will fail on a 4234f8829a4aSRandall Stewart * listening socket.. 4235f8829a4aSRandall Stewart */ 4236f8829a4aSRandall Stewart return; 4237f8829a4aSRandall Stewart } 4238f8829a4aSRandall Stewart /* lock the socket buffers */ 4239f8829a4aSRandall Stewart SCTP_INP_READ_LOCK(old_inp); 4240f8829a4aSRandall Stewart control = TAILQ_FIRST(&old_inp->read_queue); 4241f8829a4aSRandall Stewart /* Pull off all for out target stcb */ 4242f8829a4aSRandall Stewart while (control) { 4243f8829a4aSRandall Stewart nctl = TAILQ_NEXT(control, next); 4244f8829a4aSRandall Stewart if (control->stcb == stcb) { 4245f8829a4aSRandall Stewart /* remove it we want it */ 4246f8829a4aSRandall Stewart TAILQ_REMOVE(&old_inp->read_queue, control, next); 4247f8829a4aSRandall Stewart TAILQ_INSERT_TAIL(&tmp_queue, control, next); 4248f8829a4aSRandall Stewart m = control->data; 4249f8829a4aSRandall Stewart while (m) { 425080fefe0aSRandall Stewart if (sctp_logging_level & SCTP_SB_LOGGING_ENABLE) { 4251139bc87fSRandall Stewart sctp_sblog(&old_so->so_rcv, control->do_not_ref_stcb ? NULL : stcb, SCTP_LOG_SBFREE, SCTP_BUF_LEN(m)); 425280fefe0aSRandall Stewart } 4253f8829a4aSRandall Stewart sctp_sbfree(control, stcb, &old_so->so_rcv, m); 425480fefe0aSRandall Stewart if (sctp_logging_level & SCTP_SB_LOGGING_ENABLE) { 4255f8829a4aSRandall Stewart sctp_sblog(&old_so->so_rcv, control->do_not_ref_stcb ? NULL : stcb, SCTP_LOG_SBRESULT, 0); 425680fefe0aSRandall Stewart } 4257139bc87fSRandall Stewart m = SCTP_BUF_NEXT(m); 4258f8829a4aSRandall Stewart } 4259f8829a4aSRandall Stewart } 4260f8829a4aSRandall Stewart control = nctl; 4261f8829a4aSRandall Stewart } 4262f8829a4aSRandall Stewart SCTP_INP_READ_UNLOCK(old_inp); 4263f8829a4aSRandall Stewart /* Remove the sb-lock on the old socket */ 4264f8829a4aSRandall Stewart 4265f8829a4aSRandall Stewart sbunlock(&old_so->so_rcv); 4266f8829a4aSRandall Stewart /* Now we move them over to the new socket buffer */ 4267f8829a4aSRandall Stewart control = TAILQ_FIRST(&tmp_queue); 4268f8829a4aSRandall Stewart SCTP_INP_READ_LOCK(new_inp); 4269f8829a4aSRandall Stewart while (control) { 4270f8829a4aSRandall Stewart nctl = TAILQ_NEXT(control, next); 4271f8829a4aSRandall Stewart TAILQ_INSERT_TAIL(&new_inp->read_queue, control, next); 4272f8829a4aSRandall Stewart m = control->data; 4273f8829a4aSRandall Stewart while (m) { 427480fefe0aSRandall Stewart if (sctp_logging_level & SCTP_SB_LOGGING_ENABLE) { 4275139bc87fSRandall Stewart sctp_sblog(&new_so->so_rcv, control->do_not_ref_stcb ? NULL : stcb, SCTP_LOG_SBALLOC, SCTP_BUF_LEN(m)); 427680fefe0aSRandall Stewart } 4277f8829a4aSRandall Stewart sctp_sballoc(stcb, &new_so->so_rcv, m); 427880fefe0aSRandall Stewart if (sctp_logging_level & SCTP_SB_LOGGING_ENABLE) { 4279f8829a4aSRandall Stewart sctp_sblog(&new_so->so_rcv, control->do_not_ref_stcb ? NULL : stcb, SCTP_LOG_SBRESULT, 0); 428080fefe0aSRandall Stewart } 4281139bc87fSRandall Stewart m = SCTP_BUF_NEXT(m); 4282f8829a4aSRandall Stewart } 4283f8829a4aSRandall Stewart control = nctl; 4284f8829a4aSRandall Stewart } 4285f8829a4aSRandall Stewart SCTP_INP_READ_UNLOCK(new_inp); 4286f8829a4aSRandall Stewart } 4287f8829a4aSRandall Stewart 4288f8829a4aSRandall Stewart 4289f8829a4aSRandall Stewart void 4290f8829a4aSRandall Stewart sctp_add_to_readq(struct sctp_inpcb *inp, 4291f8829a4aSRandall Stewart struct sctp_tcb *stcb, 4292f8829a4aSRandall Stewart struct sctp_queued_to_read *control, 4293f8829a4aSRandall Stewart struct sockbuf *sb, 4294ceaad40aSRandall Stewart int end, 4295ceaad40aSRandall Stewart int so_locked 4296ceaad40aSRandall Stewart #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING) 4297ceaad40aSRandall Stewart SCTP_UNUSED 4298ceaad40aSRandall Stewart #endif 4299ceaad40aSRandall Stewart ) 4300f8829a4aSRandall Stewart { 4301f8829a4aSRandall Stewart /* 4302f8829a4aSRandall Stewart * Here we must place the control on the end of the socket read 4303f8829a4aSRandall Stewart * queue AND increment sb_cc so that select will work properly on 4304f8829a4aSRandall Stewart * read. 4305f8829a4aSRandall Stewart */ 4306f8829a4aSRandall Stewart struct mbuf *m, *prev = NULL; 4307f8829a4aSRandall Stewart 430803b0b021SRandall Stewart if (inp == NULL) { 430903b0b021SRandall Stewart /* Gak, TSNH!! */ 4310a5d547adSRandall Stewart #ifdef INVARIANTS 431103b0b021SRandall Stewart panic("Gak, inp NULL on add_to_readq"); 431203b0b021SRandall Stewart #endif 431303b0b021SRandall Stewart return; 431403b0b021SRandall Stewart } 4315f8829a4aSRandall Stewart SCTP_INP_READ_LOCK(inp); 431642551e99SRandall Stewart if (!(control->spec_flags & M_NOTIFICATION)) { 4317a5d547adSRandall Stewart atomic_add_int(&inp->total_recvs, 1); 431842551e99SRandall Stewart if (!control->do_not_ref_stcb) { 4319a5d547adSRandall Stewart atomic_add_int(&stcb->total_recvs, 1); 432042551e99SRandall Stewart } 432142551e99SRandall Stewart } 4322f8829a4aSRandall Stewart m = control->data; 4323f8829a4aSRandall Stewart control->held_length = 0; 4324f8829a4aSRandall Stewart control->length = 0; 4325f8829a4aSRandall Stewart while (m) { 4326139bc87fSRandall Stewart if (SCTP_BUF_LEN(m) == 0) { 4327f8829a4aSRandall Stewart /* Skip mbufs with NO length */ 4328f8829a4aSRandall Stewart if (prev == NULL) { 4329f8829a4aSRandall Stewart /* First one */ 4330f8829a4aSRandall Stewart control->data = sctp_m_free(m); 4331f8829a4aSRandall Stewart m = control->data; 4332f8829a4aSRandall Stewart } else { 4333139bc87fSRandall Stewart SCTP_BUF_NEXT(prev) = sctp_m_free(m); 4334139bc87fSRandall Stewart m = SCTP_BUF_NEXT(prev); 4335f8829a4aSRandall Stewart } 4336f8829a4aSRandall Stewart if (m == NULL) { 4337f8829a4aSRandall Stewart control->tail_mbuf = prev;; 4338f8829a4aSRandall Stewart } 4339f8829a4aSRandall Stewart continue; 4340f8829a4aSRandall Stewart } 4341f8829a4aSRandall Stewart prev = m; 434280fefe0aSRandall Stewart if (sctp_logging_level & SCTP_SB_LOGGING_ENABLE) { 4343139bc87fSRandall Stewart sctp_sblog(sb, control->do_not_ref_stcb ? NULL : stcb, SCTP_LOG_SBALLOC, SCTP_BUF_LEN(m)); 434480fefe0aSRandall Stewart } 4345f8829a4aSRandall Stewart sctp_sballoc(stcb, sb, m); 434680fefe0aSRandall Stewart if (sctp_logging_level & SCTP_SB_LOGGING_ENABLE) { 4347f8829a4aSRandall Stewart sctp_sblog(sb, control->do_not_ref_stcb ? NULL : stcb, SCTP_LOG_SBRESULT, 0); 434880fefe0aSRandall Stewart } 4349139bc87fSRandall Stewart atomic_add_int(&control->length, SCTP_BUF_LEN(m)); 4350139bc87fSRandall Stewart m = SCTP_BUF_NEXT(m); 4351f8829a4aSRandall Stewart } 4352f8829a4aSRandall Stewart if (prev != NULL) { 4353f8829a4aSRandall Stewart control->tail_mbuf = prev; 4354f8829a4aSRandall Stewart } else { 4355139bc87fSRandall Stewart /* Everything got collapsed out?? */ 4356f8829a4aSRandall Stewart return; 4357f8829a4aSRandall Stewart } 4358f8829a4aSRandall Stewart if (end) { 4359f8829a4aSRandall Stewart control->end_added = 1; 4360f8829a4aSRandall Stewart } 4361f8829a4aSRandall Stewart TAILQ_INSERT_TAIL(&inp->read_queue, control, next); 4362f8829a4aSRandall Stewart SCTP_INP_READ_UNLOCK(inp); 4363f8829a4aSRandall Stewart if (inp && inp->sctp_socket) { 436417205eccSRandall Stewart if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_ZERO_COPY_ACTIVE)) { 436517205eccSRandall Stewart SCTP_ZERO_COPY_EVENT(inp, inp->sctp_socket); 4366ceaad40aSRandall Stewart } else { 4367ceaad40aSRandall Stewart #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 4368ceaad40aSRandall Stewart struct socket *so; 4369ceaad40aSRandall Stewart 4370ceaad40aSRandall Stewart so = SCTP_INP_SO(inp); 4371ceaad40aSRandall Stewart if (!so_locked) { 4372ceaad40aSRandall Stewart atomic_add_int(&stcb->asoc.refcnt, 1); 4373ceaad40aSRandall Stewart SCTP_TCB_UNLOCK(stcb); 4374ceaad40aSRandall Stewart SCTP_SOCKET_LOCK(so, 1); 4375ceaad40aSRandall Stewart SCTP_TCB_LOCK(stcb); 4376ceaad40aSRandall Stewart atomic_subtract_int(&stcb->asoc.refcnt, 1); 4377ceaad40aSRandall Stewart if (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) { 4378ceaad40aSRandall Stewart SCTP_SOCKET_UNLOCK(so, 1); 4379ceaad40aSRandall Stewart return; 4380ceaad40aSRandall Stewart } 4381ceaad40aSRandall Stewart } 4382ceaad40aSRandall Stewart #endif 4383f8829a4aSRandall Stewart sctp_sorwakeup(inp, inp->sctp_socket); 4384ceaad40aSRandall Stewart #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 4385ceaad40aSRandall Stewart if (!so_locked) { 4386ceaad40aSRandall Stewart SCTP_SOCKET_UNLOCK(so, 1); 4387ceaad40aSRandall Stewart } 4388ceaad40aSRandall Stewart #endif 4389ceaad40aSRandall Stewart } 4390f8829a4aSRandall Stewart } 4391f8829a4aSRandall Stewart } 4392f8829a4aSRandall Stewart 4393f8829a4aSRandall Stewart 4394f8829a4aSRandall Stewart int 4395f8829a4aSRandall Stewart sctp_append_to_readq(struct sctp_inpcb *inp, 4396f8829a4aSRandall Stewart struct sctp_tcb *stcb, 4397f8829a4aSRandall Stewart struct sctp_queued_to_read *control, 4398f8829a4aSRandall Stewart struct mbuf *m, 4399f8829a4aSRandall Stewart int end, 4400f8829a4aSRandall Stewart int ctls_cumack, 4401f8829a4aSRandall Stewart struct sockbuf *sb) 4402f8829a4aSRandall Stewart { 4403f8829a4aSRandall Stewart /* 4404f8829a4aSRandall Stewart * A partial delivery API event is underway. OR we are appending on 4405f8829a4aSRandall Stewart * the reassembly queue. 4406f8829a4aSRandall Stewart * 4407f8829a4aSRandall Stewart * If PDAPI this means we need to add m to the end of the data. 4408f8829a4aSRandall Stewart * Increase the length in the control AND increment the sb_cc. 4409f8829a4aSRandall Stewart * Otherwise sb is NULL and all we need to do is put it at the end 4410f8829a4aSRandall Stewart * of the mbuf chain. 4411f8829a4aSRandall Stewart */ 4412f8829a4aSRandall Stewart int len = 0; 4413f8829a4aSRandall Stewart struct mbuf *mm, *tail = NULL, *prev = NULL; 4414f8829a4aSRandall Stewart 4415f8829a4aSRandall Stewart if (inp) { 4416f8829a4aSRandall Stewart SCTP_INP_READ_LOCK(inp); 4417f8829a4aSRandall Stewart } 4418f8829a4aSRandall Stewart if (control == NULL) { 4419f8829a4aSRandall Stewart get_out: 4420f8829a4aSRandall Stewart if (inp) { 4421f8829a4aSRandall Stewart SCTP_INP_READ_UNLOCK(inp); 4422f8829a4aSRandall Stewart } 4423f8829a4aSRandall Stewart return (-1); 4424f8829a4aSRandall Stewart } 4425139bc87fSRandall Stewart if (control->end_added) { 4426f8829a4aSRandall Stewart /* huh this one is complete? */ 4427f8829a4aSRandall Stewart goto get_out; 4428f8829a4aSRandall Stewart } 4429f8829a4aSRandall Stewart mm = m; 4430f8829a4aSRandall Stewart if (mm == NULL) { 4431f8829a4aSRandall Stewart goto get_out; 4432f8829a4aSRandall Stewart } 4433f8829a4aSRandall Stewart while (mm) { 4434139bc87fSRandall Stewart if (SCTP_BUF_LEN(mm) == 0) { 4435f8829a4aSRandall Stewart /* Skip mbufs with NO lenght */ 4436f8829a4aSRandall Stewart if (prev == NULL) { 4437f8829a4aSRandall Stewart /* First one */ 4438f8829a4aSRandall Stewart m = sctp_m_free(mm); 4439f8829a4aSRandall Stewart mm = m; 4440f8829a4aSRandall Stewart } else { 4441139bc87fSRandall Stewart SCTP_BUF_NEXT(prev) = sctp_m_free(mm); 4442139bc87fSRandall Stewart mm = SCTP_BUF_NEXT(prev); 4443f8829a4aSRandall Stewart } 4444f8829a4aSRandall Stewart continue; 4445f8829a4aSRandall Stewart } 4446f8829a4aSRandall Stewart prev = mm; 4447139bc87fSRandall Stewart len += SCTP_BUF_LEN(mm); 4448f8829a4aSRandall Stewart if (sb) { 444980fefe0aSRandall Stewart if (sctp_logging_level & SCTP_SB_LOGGING_ENABLE) { 4450139bc87fSRandall Stewart sctp_sblog(sb, control->do_not_ref_stcb ? NULL : stcb, SCTP_LOG_SBALLOC, SCTP_BUF_LEN(mm)); 445180fefe0aSRandall Stewart } 4452f8829a4aSRandall Stewart sctp_sballoc(stcb, sb, mm); 445380fefe0aSRandall Stewart if (sctp_logging_level & SCTP_SB_LOGGING_ENABLE) { 4454f8829a4aSRandall Stewart sctp_sblog(sb, control->do_not_ref_stcb ? NULL : stcb, SCTP_LOG_SBRESULT, 0); 445580fefe0aSRandall Stewart } 4456f8829a4aSRandall Stewart } 4457139bc87fSRandall Stewart mm = SCTP_BUF_NEXT(mm); 4458f8829a4aSRandall Stewart } 4459f8829a4aSRandall Stewart if (prev) { 4460f8829a4aSRandall Stewart tail = prev; 4461f8829a4aSRandall Stewart } else { 4462f8829a4aSRandall Stewart /* Really there should always be a prev */ 4463f8829a4aSRandall Stewart if (m == NULL) { 4464f8829a4aSRandall Stewart /* Huh nothing left? */ 4465a5d547adSRandall Stewart #ifdef INVARIANTS 4466f8829a4aSRandall Stewart panic("Nothing left to add?"); 4467f8829a4aSRandall Stewart #else 4468f8829a4aSRandall Stewart goto get_out; 4469f8829a4aSRandall Stewart #endif 4470f8829a4aSRandall Stewart } 4471f8829a4aSRandall Stewart tail = m; 4472f8829a4aSRandall Stewart } 4473f8829a4aSRandall Stewart if (control->tail_mbuf) { 4474f8829a4aSRandall Stewart /* append */ 4475139bc87fSRandall Stewart SCTP_BUF_NEXT(control->tail_mbuf) = m; 4476f8829a4aSRandall Stewart control->tail_mbuf = tail; 4477f8829a4aSRandall Stewart } else { 4478f8829a4aSRandall Stewart /* nothing there */ 4479a5d547adSRandall Stewart #ifdef INVARIANTS 4480f8829a4aSRandall Stewart if (control->data != NULL) { 4481f8829a4aSRandall Stewart panic("This should NOT happen"); 4482f8829a4aSRandall Stewart } 4483f8829a4aSRandall Stewart #endif 4484f8829a4aSRandall Stewart control->data = m; 4485f8829a4aSRandall Stewart control->tail_mbuf = tail; 4486f8829a4aSRandall Stewart } 448718e198d3SRandall Stewart atomic_add_int(&control->length, len); 448818e198d3SRandall Stewart if (end) { 448918e198d3SRandall Stewart /* message is complete */ 449018e198d3SRandall Stewart if (stcb && (control == stcb->asoc.control_pdapi)) { 449118e198d3SRandall Stewart stcb->asoc.control_pdapi = NULL; 449218e198d3SRandall Stewart } 449318e198d3SRandall Stewart control->held_length = 0; 449418e198d3SRandall Stewart control->end_added = 1; 449518e198d3SRandall Stewart } 4496ad81507eSRandall Stewart if (stcb == NULL) { 4497ad81507eSRandall Stewart control->do_not_ref_stcb = 1; 4498ad81507eSRandall Stewart } 4499f8829a4aSRandall Stewart /* 4500f8829a4aSRandall Stewart * When we are appending in partial delivery, the cum-ack is used 4501f8829a4aSRandall Stewart * for the actual pd-api highest tsn on this mbuf. The true cum-ack 4502f8829a4aSRandall Stewart * is populated in the outbound sinfo structure from the true cumack 4503f8829a4aSRandall Stewart * if the association exists... 4504f8829a4aSRandall Stewart */ 4505f8829a4aSRandall Stewart control->sinfo_tsn = control->sinfo_cumtsn = ctls_cumack; 4506f8829a4aSRandall Stewart if (inp) { 4507f8829a4aSRandall Stewart SCTP_INP_READ_UNLOCK(inp); 4508f8829a4aSRandall Stewart } 4509f8829a4aSRandall Stewart if (inp && inp->sctp_socket) { 451017205eccSRandall Stewart if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_ZERO_COPY_ACTIVE)) { 451117205eccSRandall Stewart SCTP_ZERO_COPY_EVENT(inp, inp->sctp_socket); 4512ceaad40aSRandall Stewart } else { 4513ceaad40aSRandall Stewart #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 4514ceaad40aSRandall Stewart struct socket *so; 4515ceaad40aSRandall Stewart 4516ceaad40aSRandall Stewart so = SCTP_INP_SO(inp); 4517ceaad40aSRandall Stewart atomic_add_int(&stcb->asoc.refcnt, 1); 4518ceaad40aSRandall Stewart SCTP_TCB_UNLOCK(stcb); 4519ceaad40aSRandall Stewart SCTP_SOCKET_LOCK(so, 1); 4520ceaad40aSRandall Stewart SCTP_TCB_LOCK(stcb); 4521ceaad40aSRandall Stewart atomic_subtract_int(&stcb->asoc.refcnt, 1); 4522ceaad40aSRandall Stewart if (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) { 4523ceaad40aSRandall Stewart SCTP_SOCKET_UNLOCK(so, 1); 4524ceaad40aSRandall Stewart return (0); 4525ceaad40aSRandall Stewart } 4526ceaad40aSRandall Stewart #endif 4527f8829a4aSRandall Stewart sctp_sorwakeup(inp, inp->sctp_socket); 4528ceaad40aSRandall Stewart #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 4529ceaad40aSRandall Stewart SCTP_SOCKET_UNLOCK(so, 1); 4530ceaad40aSRandall Stewart #endif 4531ceaad40aSRandall Stewart } 4532f8829a4aSRandall Stewart } 4533f8829a4aSRandall Stewart return (0); 4534f8829a4aSRandall Stewart } 4535f8829a4aSRandall Stewart 4536f8829a4aSRandall Stewart 4537f8829a4aSRandall Stewart 4538f8829a4aSRandall Stewart /*************HOLD THIS COMMENT FOR PATCH FILE OF 4539f8829a4aSRandall Stewart *************ALTERNATE ROUTING CODE 4540f8829a4aSRandall Stewart */ 4541f8829a4aSRandall Stewart 4542f8829a4aSRandall Stewart /*************HOLD THIS COMMENT FOR END OF PATCH FILE OF 4543f8829a4aSRandall Stewart *************ALTERNATE ROUTING CODE 4544f8829a4aSRandall Stewart */ 4545f8829a4aSRandall Stewart 4546f8829a4aSRandall Stewart struct mbuf * 4547f8829a4aSRandall Stewart sctp_generate_invmanparam(int err) 4548f8829a4aSRandall Stewart { 4549f8829a4aSRandall Stewart /* Return a MBUF with a invalid mandatory parameter */ 4550f8829a4aSRandall Stewart struct mbuf *m; 4551f8829a4aSRandall Stewart 4552f8829a4aSRandall Stewart m = sctp_get_mbuf_for_msg(sizeof(struct sctp_paramhdr), 0, M_DONTWAIT, 1, MT_DATA); 4553f8829a4aSRandall Stewart if (m) { 4554f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 4555f8829a4aSRandall Stewart 4556139bc87fSRandall Stewart SCTP_BUF_LEN(m) = sizeof(struct sctp_paramhdr); 4557f8829a4aSRandall Stewart ph = mtod(m, struct sctp_paramhdr *); 4558f8829a4aSRandall Stewart ph->param_length = htons(sizeof(struct sctp_paramhdr)); 4559f8829a4aSRandall Stewart ph->param_type = htons(err); 4560f8829a4aSRandall Stewart } 4561f8829a4aSRandall Stewart return (m); 4562f8829a4aSRandall Stewart } 4563f8829a4aSRandall Stewart 4564f8829a4aSRandall Stewart #ifdef SCTP_MBCNT_LOGGING 4565f8829a4aSRandall Stewart void 4566f8829a4aSRandall Stewart sctp_free_bufspace(struct sctp_tcb *stcb, struct sctp_association *asoc, 4567f8829a4aSRandall Stewart struct sctp_tmit_chunk *tp1, int chk_cnt) 4568f8829a4aSRandall Stewart { 4569f8829a4aSRandall Stewart if (tp1->data == NULL) { 4570f8829a4aSRandall Stewart return; 4571f8829a4aSRandall Stewart } 4572f8829a4aSRandall Stewart asoc->chunks_on_out_queue -= chk_cnt; 457380fefe0aSRandall Stewart if (sctp_logging_level & SCTP_MBCNT_LOGGING_ENABLE) { 4574f8829a4aSRandall Stewart sctp_log_mbcnt(SCTP_LOG_MBCNT_DECREASE, 4575f8829a4aSRandall Stewart asoc->total_output_queue_size, 4576f8829a4aSRandall Stewart tp1->book_size, 4577f8829a4aSRandall Stewart 0, 4578f8829a4aSRandall Stewart tp1->mbcnt); 457980fefe0aSRandall Stewart } 4580f8829a4aSRandall Stewart if (asoc->total_output_queue_size >= tp1->book_size) { 458144b7479bSRandall Stewart atomic_add_int(&asoc->total_output_queue_size, -tp1->book_size); 4582f8829a4aSRandall Stewart } else { 4583f8829a4aSRandall Stewart asoc->total_output_queue_size = 0; 4584f8829a4aSRandall Stewart } 4585f8829a4aSRandall Stewart 4586f8829a4aSRandall Stewart if (stcb->sctp_socket && (((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL)) || 4587f8829a4aSRandall Stewart ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE)))) { 4588f8829a4aSRandall Stewart if (stcb->sctp_socket->so_snd.sb_cc >= tp1->book_size) { 4589f8829a4aSRandall Stewart stcb->sctp_socket->so_snd.sb_cc -= tp1->book_size; 4590f8829a4aSRandall Stewart } else { 4591f8829a4aSRandall Stewart stcb->sctp_socket->so_snd.sb_cc = 0; 4592f8829a4aSRandall Stewart 4593f8829a4aSRandall Stewart } 4594f8829a4aSRandall Stewart } 4595f8829a4aSRandall Stewart } 4596f8829a4aSRandall Stewart 4597f8829a4aSRandall Stewart #endif 4598f8829a4aSRandall Stewart 4599f8829a4aSRandall Stewart int 4600f8829a4aSRandall Stewart sctp_release_pr_sctp_chunk(struct sctp_tcb *stcb, struct sctp_tmit_chunk *tp1, 4601ceaad40aSRandall Stewart int reason, struct sctpchunk_listhead *queue, int so_locked 4602ceaad40aSRandall Stewart #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING) 4603ceaad40aSRandall Stewart SCTP_UNUSED 4604ceaad40aSRandall Stewart #endif 4605ceaad40aSRandall Stewart ) 4606f8829a4aSRandall Stewart { 4607f8829a4aSRandall Stewart int ret_sz = 0; 4608f8829a4aSRandall Stewart int notdone; 4609f8829a4aSRandall Stewart uint8_t foundeom = 0; 4610f8829a4aSRandall Stewart 4611f8829a4aSRandall Stewart do { 4612f8829a4aSRandall Stewart ret_sz += tp1->book_size; 4613f8829a4aSRandall Stewart tp1->sent = SCTP_FORWARD_TSN_SKIP; 4614f8829a4aSRandall Stewart if (tp1->data) { 4615ceaad40aSRandall Stewart #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 4616ceaad40aSRandall Stewart struct socket *so; 4617ceaad40aSRandall Stewart 4618ceaad40aSRandall Stewart #endif 4619f8829a4aSRandall Stewart sctp_free_bufspace(stcb, &stcb->asoc, tp1, 1); 4620ceaad40aSRandall Stewart sctp_ulp_notify(SCTP_NOTIFY_DG_FAIL, stcb, reason, tp1, SCTP_SO_NOT_LOCKED); 4621f8829a4aSRandall Stewart sctp_m_freem(tp1->data); 4622f8829a4aSRandall Stewart tp1->data = NULL; 4623ceaad40aSRandall Stewart #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 4624ceaad40aSRandall Stewart so = SCTP_INP_SO(stcb->sctp_ep); 4625ceaad40aSRandall Stewart if (!so_locked) { 4626ceaad40aSRandall Stewart atomic_add_int(&stcb->asoc.refcnt, 1); 4627ceaad40aSRandall Stewart SCTP_TCB_UNLOCK(stcb); 4628ceaad40aSRandall Stewart SCTP_SOCKET_LOCK(so, 1); 4629ceaad40aSRandall Stewart SCTP_TCB_LOCK(stcb); 4630ceaad40aSRandall Stewart atomic_subtract_int(&stcb->asoc.refcnt, 1); 4631ceaad40aSRandall Stewart if (stcb->asoc.state & SCTP_STATE_CLOSED_SOCKET) { 4632ceaad40aSRandall Stewart /* 4633ceaad40aSRandall Stewart * assoc was freed while we were 4634ceaad40aSRandall Stewart * unlocked 4635ceaad40aSRandall Stewart */ 4636ceaad40aSRandall Stewart SCTP_SOCKET_UNLOCK(so, 1); 4637ceaad40aSRandall Stewart return (ret_sz); 4638ceaad40aSRandall Stewart } 4639ceaad40aSRandall Stewart } 4640ceaad40aSRandall Stewart #endif 4641f8829a4aSRandall Stewart sctp_sowwakeup(stcb->sctp_ep, stcb->sctp_socket); 4642ceaad40aSRandall Stewart #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 4643ceaad40aSRandall Stewart if (!so_locked) { 4644ceaad40aSRandall Stewart SCTP_SOCKET_UNLOCK(so, 1); 4645ceaad40aSRandall Stewart } 4646ceaad40aSRandall Stewart #endif 4647f8829a4aSRandall Stewart } 4648f8829a4aSRandall Stewart if (PR_SCTP_BUF_ENABLED(tp1->flags)) { 4649f8829a4aSRandall Stewart stcb->asoc.sent_queue_cnt_removeable--; 4650f8829a4aSRandall Stewart } 4651f8829a4aSRandall Stewart if (queue == &stcb->asoc.send_queue) { 4652f8829a4aSRandall Stewart TAILQ_REMOVE(&stcb->asoc.send_queue, tp1, sctp_next); 4653f8829a4aSRandall Stewart /* on to the sent queue */ 4654f8829a4aSRandall Stewart TAILQ_INSERT_TAIL(&stcb->asoc.sent_queue, tp1, 4655f8829a4aSRandall Stewart sctp_next); 4656f8829a4aSRandall Stewart stcb->asoc.sent_queue_cnt++; 4657f8829a4aSRandall Stewart } 4658f8829a4aSRandall Stewart if ((tp1->rec.data.rcv_flags & SCTP_DATA_NOT_FRAG) == 4659f8829a4aSRandall Stewart SCTP_DATA_NOT_FRAG) { 4660f8829a4aSRandall Stewart /* not frag'ed we ae done */ 4661f8829a4aSRandall Stewart notdone = 0; 4662f8829a4aSRandall Stewart foundeom = 1; 4663f8829a4aSRandall Stewart } else if (tp1->rec.data.rcv_flags & SCTP_DATA_LAST_FRAG) { 4664f8829a4aSRandall Stewart /* end of frag, we are done */ 4665f8829a4aSRandall Stewart notdone = 0; 4666f8829a4aSRandall Stewart foundeom = 1; 4667f8829a4aSRandall Stewart } else { 4668f8829a4aSRandall Stewart /* 4669f8829a4aSRandall Stewart * Its a begin or middle piece, we must mark all of 4670f8829a4aSRandall Stewart * it 4671f8829a4aSRandall Stewart */ 4672f8829a4aSRandall Stewart notdone = 1; 4673f8829a4aSRandall Stewart tp1 = TAILQ_NEXT(tp1, sctp_next); 4674f8829a4aSRandall Stewart } 4675f8829a4aSRandall Stewart } while (tp1 && notdone); 4676f8829a4aSRandall Stewart if ((foundeom == 0) && (queue == &stcb->asoc.sent_queue)) { 4677f8829a4aSRandall Stewart /* 4678f8829a4aSRandall Stewart * The multi-part message was scattered across the send and 4679f8829a4aSRandall Stewart * sent queue. 4680f8829a4aSRandall Stewart */ 4681f8829a4aSRandall Stewart tp1 = TAILQ_FIRST(&stcb->asoc.send_queue); 4682f8829a4aSRandall Stewart /* 4683f8829a4aSRandall Stewart * recurse throught the send_queue too, starting at the 4684f8829a4aSRandall Stewart * beginning. 4685f8829a4aSRandall Stewart */ 4686f8829a4aSRandall Stewart if (tp1) { 4687f8829a4aSRandall Stewart ret_sz += sctp_release_pr_sctp_chunk(stcb, tp1, reason, 4688ceaad40aSRandall Stewart &stcb->asoc.send_queue, so_locked); 4689f8829a4aSRandall Stewart } else { 4690ad81507eSRandall Stewart SCTP_PRINTF("hmm, nothing on the send queue and no EOM?\n"); 4691f8829a4aSRandall Stewart } 4692f8829a4aSRandall Stewart } 4693f8829a4aSRandall Stewart return (ret_sz); 4694f8829a4aSRandall Stewart } 4695f8829a4aSRandall Stewart 4696f8829a4aSRandall Stewart /* 4697f8829a4aSRandall Stewart * checks to see if the given address, sa, is one that is currently known by 4698f8829a4aSRandall Stewart * the kernel note: can't distinguish the same address on multiple interfaces 4699f8829a4aSRandall Stewart * and doesn't handle multiple addresses with different zone/scope id's note: 4700f8829a4aSRandall Stewart * ifa_ifwithaddr() compares the entire sockaddr struct 4701f8829a4aSRandall Stewart */ 470242551e99SRandall Stewart struct sctp_ifa * 470380fefe0aSRandall Stewart sctp_find_ifa_in_ep(struct sctp_inpcb *inp, struct sockaddr *addr, 470480fefe0aSRandall Stewart int holds_lock) 4705f8829a4aSRandall Stewart { 470642551e99SRandall Stewart struct sctp_laddr *laddr; 4707f8829a4aSRandall Stewart 4708ad81507eSRandall Stewart if (holds_lock == 0) { 470942551e99SRandall Stewart SCTP_INP_RLOCK(inp); 4710ad81507eSRandall Stewart } 471142551e99SRandall Stewart LIST_FOREACH(laddr, &inp->sctp_addr_list, sctp_nxt_addr) { 471242551e99SRandall Stewart if (laddr->ifa == NULL) 4713f8829a4aSRandall Stewart continue; 471442551e99SRandall Stewart if (addr->sa_family != laddr->ifa->address.sa.sa_family) 471542551e99SRandall Stewart continue; 471642551e99SRandall Stewart if (addr->sa_family == AF_INET) { 471742551e99SRandall Stewart if (((struct sockaddr_in *)addr)->sin_addr.s_addr == 471842551e99SRandall Stewart laddr->ifa->address.sin.sin_addr.s_addr) { 471942551e99SRandall Stewart /* found him. */ 4720ad81507eSRandall Stewart if (holds_lock == 0) { 472142551e99SRandall Stewart SCTP_INP_RUNLOCK(inp); 4722ad81507eSRandall Stewart } 472342551e99SRandall Stewart return (laddr->ifa); 472442551e99SRandall Stewart break; 472542551e99SRandall Stewart } 472642551e99SRandall Stewart } else if (addr->sa_family == AF_INET6) { 472742551e99SRandall Stewart if (SCTP6_ARE_ADDR_EQUAL(&((struct sockaddr_in6 *)addr)->sin6_addr, 472842551e99SRandall Stewart &laddr->ifa->address.sin6.sin6_addr)) { 472942551e99SRandall Stewart /* found him. */ 4730ad81507eSRandall Stewart if (holds_lock == 0) { 473142551e99SRandall Stewart SCTP_INP_RUNLOCK(inp); 4732ad81507eSRandall Stewart } 473342551e99SRandall Stewart return (laddr->ifa); 473442551e99SRandall Stewart break; 473542551e99SRandall Stewart } 473642551e99SRandall Stewart } 473742551e99SRandall Stewart } 4738ad81507eSRandall Stewart if (holds_lock == 0) { 473942551e99SRandall Stewart SCTP_INP_RUNLOCK(inp); 4740ad81507eSRandall Stewart } 474142551e99SRandall Stewart return (NULL); 474242551e99SRandall Stewart } 4743f8829a4aSRandall Stewart 47446a27c376SRandall Stewart uint32_t 47456a27c376SRandall Stewart sctp_get_ifa_hash_val(struct sockaddr *addr) 47466a27c376SRandall Stewart { 47476a27c376SRandall Stewart if (addr->sa_family == AF_INET) { 47486a27c376SRandall Stewart struct sockaddr_in *sin; 47496a27c376SRandall Stewart 47506a27c376SRandall Stewart sin = (struct sockaddr_in *)addr; 47516a27c376SRandall Stewart return (sin->sin_addr.s_addr ^ (sin->sin_addr.s_addr >> 16)); 47526a27c376SRandall Stewart } else if (addr->sa_family == AF_INET6) { 47536a27c376SRandall Stewart struct sockaddr_in6 *sin6; 47546a27c376SRandall Stewart uint32_t hash_of_addr; 47556a27c376SRandall Stewart 47566a27c376SRandall Stewart sin6 = (struct sockaddr_in6 *)addr; 47576a27c376SRandall Stewart hash_of_addr = (sin6->sin6_addr.s6_addr32[0] + 47586a27c376SRandall Stewart sin6->sin6_addr.s6_addr32[1] + 47596a27c376SRandall Stewart sin6->sin6_addr.s6_addr32[2] + 47606a27c376SRandall Stewart sin6->sin6_addr.s6_addr32[3]); 47616a27c376SRandall Stewart hash_of_addr = (hash_of_addr ^ (hash_of_addr >> 16)); 47626a27c376SRandall Stewart return (hash_of_addr); 47636a27c376SRandall Stewart } 47646a27c376SRandall Stewart return (0); 47656a27c376SRandall Stewart } 47666a27c376SRandall Stewart 476742551e99SRandall Stewart struct sctp_ifa * 476842551e99SRandall Stewart sctp_find_ifa_by_addr(struct sockaddr *addr, uint32_t vrf_id, int holds_lock) 476942551e99SRandall Stewart { 477042551e99SRandall Stewart struct sctp_ifa *sctp_ifap; 477142551e99SRandall Stewart struct sctp_vrf *vrf; 47726a27c376SRandall Stewart struct sctp_ifalist *hash_head; 47736a27c376SRandall Stewart uint32_t hash_of_addr; 477442551e99SRandall Stewart 477542551e99SRandall Stewart if (holds_lock == 0) 4776c99efcf6SRandall Stewart SCTP_IPI_ADDR_RLOCK(); 477742551e99SRandall Stewart 4778bff64a4dSRandall Stewart vrf = sctp_find_vrf(vrf_id); 4779bff64a4dSRandall Stewart if (vrf == NULL) { 4780bff64a4dSRandall Stewart if (holds_lock == 0) 4781c99efcf6SRandall Stewart SCTP_IPI_ADDR_RUNLOCK(); 4782bff64a4dSRandall Stewart return (NULL); 4783bff64a4dSRandall Stewart } 4784bff64a4dSRandall Stewart hash_of_addr = sctp_get_ifa_hash_val(addr); 4785bff64a4dSRandall Stewart 478617205eccSRandall Stewart hash_head = &vrf->vrf_addr_hash[(hash_of_addr & vrf->vrf_addr_hashmark)]; 4787bff64a4dSRandall Stewart if (hash_head == NULL) { 4788ad81507eSRandall Stewart SCTP_PRINTF("hash_of_addr:%x mask:%x table:%x - ", 4789c99efcf6SRandall Stewart hash_of_addr, (uint32_t) vrf->vrf_addr_hashmark, 4790c99efcf6SRandall Stewart (uint32_t) (hash_of_addr & vrf->vrf_addr_hashmark)); 4791bff64a4dSRandall Stewart sctp_print_address(addr); 4792ad81507eSRandall Stewart SCTP_PRINTF("No such bucket for address\n"); 4793bff64a4dSRandall Stewart if (holds_lock == 0) 4794c99efcf6SRandall Stewart SCTP_IPI_ADDR_RUNLOCK(); 4795bff64a4dSRandall Stewart 4796bff64a4dSRandall Stewart return (NULL); 4797bff64a4dSRandall Stewart } 47986a27c376SRandall Stewart LIST_FOREACH(sctp_ifap, hash_head, next_bucket) { 4799bff64a4dSRandall Stewart if (sctp_ifap == NULL) { 4800bff64a4dSRandall Stewart panic("Huh LIST_FOREACH corrupt"); 4801bff64a4dSRandall Stewart } 48026a27c376SRandall Stewart if (addr->sa_family != sctp_ifap->address.sa.sa_family) 48036a27c376SRandall Stewart continue; 48046a27c376SRandall Stewart if (addr->sa_family == AF_INET) { 48056a27c376SRandall Stewart if (((struct sockaddr_in *)addr)->sin_addr.s_addr == 48066a27c376SRandall Stewart sctp_ifap->address.sin.sin_addr.s_addr) { 48076a27c376SRandall Stewart /* found him. */ 480842551e99SRandall Stewart if (holds_lock == 0) 4809c99efcf6SRandall Stewart SCTP_IPI_ADDR_RUNLOCK(); 481042551e99SRandall Stewart return (sctp_ifap); 48116a27c376SRandall Stewart break; 48126a27c376SRandall Stewart } 48136a27c376SRandall Stewart } else if (addr->sa_family == AF_INET6) { 48146a27c376SRandall Stewart if (SCTP6_ARE_ADDR_EQUAL(&((struct sockaddr_in6 *)addr)->sin6_addr, 48156a27c376SRandall Stewart &sctp_ifap->address.sin6.sin6_addr)) { 48166a27c376SRandall Stewart /* found him. */ 48176a27c376SRandall Stewart if (holds_lock == 0) 4818c99efcf6SRandall Stewart SCTP_IPI_ADDR_RUNLOCK(); 48196a27c376SRandall Stewart return (sctp_ifap); 48206a27c376SRandall Stewart break; 48216a27c376SRandall Stewart } 482242551e99SRandall Stewart } 482342551e99SRandall Stewart } 482442551e99SRandall Stewart if (holds_lock == 0) 4825c99efcf6SRandall Stewart SCTP_IPI_ADDR_RUNLOCK(); 4826f8829a4aSRandall Stewart return (NULL); 4827f8829a4aSRandall Stewart } 4828f8829a4aSRandall Stewart 4829f8829a4aSRandall Stewart static void 48304c9179adSRandall Stewart sctp_user_rcvd(struct sctp_tcb *stcb, uint32_t * freed_so_far, int hold_rlock, 4831f8829a4aSRandall Stewart uint32_t rwnd_req) 4832f8829a4aSRandall Stewart { 4833f8829a4aSRandall Stewart /* User pulled some data, do we need a rwnd update? */ 4834f8829a4aSRandall Stewart int r_unlocked = 0; 4835f8829a4aSRandall Stewart uint32_t dif, rwnd; 4836f8829a4aSRandall Stewart struct socket *so = NULL; 4837f8829a4aSRandall Stewart 4838f8829a4aSRandall Stewart if (stcb == NULL) 4839f8829a4aSRandall Stewart return; 4840f8829a4aSRandall Stewart 484150cec919SRandall Stewart atomic_add_int(&stcb->asoc.refcnt, 1); 4842f8829a4aSRandall Stewart 484362c1ff9cSRandall Stewart if (stcb->asoc.state & (SCTP_STATE_ABOUT_TO_BE_FREED | 484462c1ff9cSRandall Stewart SCTP_STATE_SHUTDOWN_RECEIVED | 48454c9179adSRandall Stewart SCTP_STATE_SHUTDOWN_ACK_SENT)) { 4846f8829a4aSRandall Stewart /* Pre-check If we are freeing no update */ 4847f8829a4aSRandall Stewart goto no_lock; 4848f8829a4aSRandall Stewart } 4849f8829a4aSRandall Stewart SCTP_INP_INCR_REF(stcb->sctp_ep); 4850f8829a4aSRandall Stewart if ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) || 4851f8829a4aSRandall Stewart (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_ALLGONE)) { 4852f8829a4aSRandall Stewart goto out; 4853f8829a4aSRandall Stewart } 4854f8829a4aSRandall Stewart so = stcb->sctp_socket; 4855f8829a4aSRandall Stewart if (so == NULL) { 4856f8829a4aSRandall Stewart goto out; 4857f8829a4aSRandall Stewart } 4858f8829a4aSRandall Stewart atomic_add_int(&stcb->freed_by_sorcv_sincelast, *freed_so_far); 4859f8829a4aSRandall Stewart /* Have you have freed enough to look */ 4860f8829a4aSRandall Stewart *freed_so_far = 0; 4861f8829a4aSRandall Stewart /* Yep, its worth a look and the lock overhead */ 4862f8829a4aSRandall Stewart 4863f8829a4aSRandall Stewart /* Figure out what the rwnd would be */ 4864f8829a4aSRandall Stewart rwnd = sctp_calc_rwnd(stcb, &stcb->asoc); 4865f8829a4aSRandall Stewart if (rwnd >= stcb->asoc.my_last_reported_rwnd) { 4866f8829a4aSRandall Stewart dif = rwnd - stcb->asoc.my_last_reported_rwnd; 4867f8829a4aSRandall Stewart } else { 4868f8829a4aSRandall Stewart dif = 0; 4869f8829a4aSRandall Stewart } 4870f8829a4aSRandall Stewart if (dif >= rwnd_req) { 4871f8829a4aSRandall Stewart if (hold_rlock) { 4872f8829a4aSRandall Stewart SCTP_INP_READ_UNLOCK(stcb->sctp_ep); 4873f8829a4aSRandall Stewart r_unlocked = 1; 4874f8829a4aSRandall Stewart } 4875f8829a4aSRandall Stewart if (stcb->asoc.state & SCTP_STATE_ABOUT_TO_BE_FREED) { 4876f8829a4aSRandall Stewart /* 4877f8829a4aSRandall Stewart * One last check before we allow the guy possibly 4878f8829a4aSRandall Stewart * to get in. There is a race, where the guy has not 4879f8829a4aSRandall Stewart * reached the gate. In that case 4880f8829a4aSRandall Stewart */ 4881f8829a4aSRandall Stewart goto out; 4882f8829a4aSRandall Stewart } 4883f8829a4aSRandall Stewart SCTP_TCB_LOCK(stcb); 4884f8829a4aSRandall Stewart if (stcb->asoc.state & SCTP_STATE_ABOUT_TO_BE_FREED) { 4885f8829a4aSRandall Stewart /* No reports here */ 4886f8829a4aSRandall Stewart SCTP_TCB_UNLOCK(stcb); 4887f8829a4aSRandall Stewart goto out; 4888f8829a4aSRandall Stewart } 4889f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_wu_sacks_sent); 4890f8829a4aSRandall Stewart sctp_send_sack(stcb); 4891f8829a4aSRandall Stewart sctp_chunk_output(stcb->sctp_ep, stcb, 4892ceaad40aSRandall Stewart SCTP_OUTPUT_FROM_USR_RCVD, SCTP_SO_LOCKED); 4893f8829a4aSRandall Stewart /* make sure no timer is running */ 4894a5d547adSRandall Stewart sctp_timer_stop(SCTP_TIMER_TYPE_RECV, stcb->sctp_ep, stcb, NULL, SCTP_FROM_SCTPUTIL + SCTP_LOC_6); 4895f8829a4aSRandall Stewart SCTP_TCB_UNLOCK(stcb); 4896f8829a4aSRandall Stewart } else { 4897f8829a4aSRandall Stewart /* Update how much we have pending */ 4898f8829a4aSRandall Stewart stcb->freed_by_sorcv_sincelast = dif; 4899f8829a4aSRandall Stewart } 4900f8829a4aSRandall Stewart out: 4901f8829a4aSRandall Stewart if (so && r_unlocked && hold_rlock) { 4902f8829a4aSRandall Stewart SCTP_INP_READ_LOCK(stcb->sctp_ep); 4903f8829a4aSRandall Stewart } 4904f8829a4aSRandall Stewart SCTP_INP_DECR_REF(stcb->sctp_ep); 4905f8829a4aSRandall Stewart no_lock: 490650cec919SRandall Stewart atomic_add_int(&stcb->asoc.refcnt, -1); 4907f8829a4aSRandall Stewart return; 4908f8829a4aSRandall Stewart } 4909f8829a4aSRandall Stewart 4910f8829a4aSRandall Stewart int 4911f8829a4aSRandall Stewart sctp_sorecvmsg(struct socket *so, 4912f8829a4aSRandall Stewart struct uio *uio, 4913f8829a4aSRandall Stewart struct mbuf **mp, 4914f8829a4aSRandall Stewart struct sockaddr *from, 4915f8829a4aSRandall Stewart int fromlen, 4916f8829a4aSRandall Stewart int *msg_flags, 4917f8829a4aSRandall Stewart struct sctp_sndrcvinfo *sinfo, 4918f8829a4aSRandall Stewart int filling_sinfo) 4919f8829a4aSRandall Stewart { 4920f8829a4aSRandall Stewart /* 4921f8829a4aSRandall Stewart * MSG flags we will look at MSG_DONTWAIT - non-blocking IO. 4922f8829a4aSRandall Stewart * MSG_PEEK - Look don't touch :-D (only valid with OUT mbuf copy 4923f8829a4aSRandall Stewart * mp=NULL thus uio is the copy method to userland) MSG_WAITALL - ?? 4924f8829a4aSRandall Stewart * On the way out we may send out any combination of: 4925f8829a4aSRandall Stewart * MSG_NOTIFICATION MSG_EOR 4926f8829a4aSRandall Stewart * 4927f8829a4aSRandall Stewart */ 4928f8829a4aSRandall Stewart struct sctp_inpcb *inp = NULL; 4929f8829a4aSRandall Stewart int my_len = 0; 4930f8829a4aSRandall Stewart int cp_len = 0, error = 0; 4931f8829a4aSRandall Stewart struct sctp_queued_to_read *control = NULL, *ctl = NULL, *nxt = NULL; 4932f8829a4aSRandall Stewart struct mbuf *m = NULL, *embuf = NULL; 4933f8829a4aSRandall Stewart struct sctp_tcb *stcb = NULL; 4934f8829a4aSRandall Stewart int wakeup_read_socket = 0; 4935f8829a4aSRandall Stewart int freecnt_applied = 0; 4936f8829a4aSRandall Stewart int out_flags = 0, in_flags = 0; 4937f8829a4aSRandall Stewart int block_allowed = 1; 49384c9179adSRandall Stewart uint32_t freed_so_far = 0; 493981aca91aSRandall Stewart uint32_t copied_so_far = 0; 494093164cf9SRandall Stewart int in_eeor_mode = 0; 4941f8829a4aSRandall Stewart int no_rcv_needed = 0; 4942f8829a4aSRandall Stewart uint32_t rwnd_req = 0; 4943f8829a4aSRandall Stewart int hold_sblock = 0; 4944f8829a4aSRandall Stewart int hold_rlock = 0; 494542551e99SRandall Stewart int slen = 0; 49464c9179adSRandall Stewart uint32_t held_length = 0; 49477abab911SRobert Watson int sockbuf_lock = 0; 4948f8829a4aSRandall Stewart 494917205eccSRandall Stewart if (uio == NULL) { 4950c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL); 495117205eccSRandall Stewart return (EINVAL); 495217205eccSRandall Stewart } 4953f8829a4aSRandall Stewart if (msg_flags) { 4954f8829a4aSRandall Stewart in_flags = *msg_flags; 4955c105859eSRandall Stewart if (in_flags & MSG_PEEK) 4956c105859eSRandall Stewart SCTP_STAT_INCR(sctps_read_peeks); 4957f8829a4aSRandall Stewart } else { 4958f8829a4aSRandall Stewart in_flags = 0; 4959f8829a4aSRandall Stewart } 4960f8829a4aSRandall Stewart slen = uio->uio_resid; 496117205eccSRandall Stewart 4962f8829a4aSRandall Stewart /* Pull in and set up our int flags */ 4963f8829a4aSRandall Stewart if (in_flags & MSG_OOB) { 4964f8829a4aSRandall Stewart /* Out of band's NOT supported */ 4965f8829a4aSRandall Stewart return (EOPNOTSUPP); 4966f8829a4aSRandall Stewart } 4967f8829a4aSRandall Stewart if ((in_flags & MSG_PEEK) && (mp != NULL)) { 4968c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL); 4969f8829a4aSRandall Stewart return (EINVAL); 4970f8829a4aSRandall Stewart } 4971f8829a4aSRandall Stewart if ((in_flags & (MSG_DONTWAIT 4972f8829a4aSRandall Stewart | MSG_NBIO 4973f8829a4aSRandall Stewart )) || 497442551e99SRandall Stewart SCTP_SO_IS_NBIO(so)) { 4975f8829a4aSRandall Stewart block_allowed = 0; 4976f8829a4aSRandall Stewart } 4977f8829a4aSRandall Stewart /* setup the endpoint */ 4978f8829a4aSRandall Stewart inp = (struct sctp_inpcb *)so->so_pcb; 4979f8829a4aSRandall Stewart if (inp == NULL) { 4980c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET(NULL, NULL, NULL, SCTP_FROM_SCTPUTIL, EFAULT); 4981f8829a4aSRandall Stewart return (EFAULT); 4982f8829a4aSRandall Stewart } 498362c1ff9cSRandall Stewart rwnd_req = (SCTP_SB_LIMIT_RCV(so) >> SCTP_RWND_HIWAT_SHIFT); 4984f8829a4aSRandall Stewart /* Must be at least a MTU's worth */ 4985f8829a4aSRandall Stewart if (rwnd_req < SCTP_MIN_RWND) 4986f8829a4aSRandall Stewart rwnd_req = SCTP_MIN_RWND; 4987f8829a4aSRandall Stewart in_eeor_mode = sctp_is_feature_on(inp, SCTP_PCB_FLAGS_EXPLICIT_EOR); 498880fefe0aSRandall Stewart if (sctp_logging_level & SCTP_RECV_RWND_LOGGING_ENABLE) { 4989f8829a4aSRandall Stewart sctp_misc_ints(SCTP_SORECV_ENTER, 499017205eccSRandall Stewart rwnd_req, in_eeor_mode, so->so_rcv.sb_cc, uio->uio_resid); 499180fefe0aSRandall Stewart } 499280fefe0aSRandall Stewart if (sctp_logging_level & SCTP_RECV_RWND_LOGGING_ENABLE) { 4993f8829a4aSRandall Stewart sctp_misc_ints(SCTP_SORECV_ENTERPL, 499417205eccSRandall Stewart rwnd_req, block_allowed, so->so_rcv.sb_cc, uio->uio_resid); 499580fefe0aSRandall Stewart } 4996f8829a4aSRandall Stewart error = sblock(&so->so_rcv, (block_allowed ? M_WAITOK : 0)); 49977abab911SRobert Watson sockbuf_lock = 1; 4998f8829a4aSRandall Stewart if (error) { 4999f8829a4aSRandall Stewart goto release_unlocked; 5000f8829a4aSRandall Stewart } 5001f8829a4aSRandall Stewart restart: 50027abab911SRobert Watson 5003f8829a4aSRandall Stewart 5004f8829a4aSRandall Stewart restart_nosblocks: 5005f8829a4aSRandall Stewart if (hold_sblock == 0) { 5006f8829a4aSRandall Stewart SOCKBUF_LOCK(&so->so_rcv); 5007f8829a4aSRandall Stewart hold_sblock = 1; 5008f8829a4aSRandall Stewart } 5009f8829a4aSRandall Stewart if ((inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) || 5010f8829a4aSRandall Stewart (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_ALLGONE)) { 5011f8829a4aSRandall Stewart goto out; 5012f8829a4aSRandall Stewart } 501344b7479bSRandall Stewart if (so->so_rcv.sb_state & SBS_CANTRCVMORE) { 5014f8829a4aSRandall Stewart if (so->so_error) { 5015f8829a4aSRandall Stewart error = so->so_error; 501644b7479bSRandall Stewart if ((in_flags & MSG_PEEK) == 0) 501744b7479bSRandall Stewart so->so_error = 0; 50189f22f500SRandall Stewart goto out; 5019f8829a4aSRandall Stewart } else { 50209f22f500SRandall Stewart if (so->so_rcv.sb_cc == 0) { 5021c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, ENOTCONN); 50227924093fSRandall Stewart /* indicate EOF */ 50237924093fSRandall Stewart error = 0; 5024f8829a4aSRandall Stewart goto out; 5025f8829a4aSRandall Stewart } 50269f22f500SRandall Stewart } 50279f22f500SRandall Stewart } 5028f8829a4aSRandall Stewart if ((so->so_rcv.sb_cc <= held_length) && block_allowed) { 5029f8829a4aSRandall Stewart /* we need to wait for data */ 5030f8829a4aSRandall Stewart if ((so->so_rcv.sb_cc == 0) && 5031f8829a4aSRandall Stewart ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) || 5032f8829a4aSRandall Stewart (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL))) { 5033f8829a4aSRandall Stewart if ((inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) == 0) { 5034f8829a4aSRandall Stewart /* 5035f8829a4aSRandall Stewart * For active open side clear flags for 5036f8829a4aSRandall Stewart * re-use passive open is blocked by 5037f8829a4aSRandall Stewart * connect. 5038f8829a4aSRandall Stewart */ 5039f8829a4aSRandall Stewart if (inp->sctp_flags & SCTP_PCB_FLAGS_WAS_ABORTED) { 5040f8829a4aSRandall Stewart /* 5041f8829a4aSRandall Stewart * You were aborted, passive side 5042f8829a4aSRandall Stewart * always hits here 5043f8829a4aSRandall Stewart */ 5044c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, ECONNRESET); 5045f8829a4aSRandall Stewart error = ECONNRESET; 5046f8829a4aSRandall Stewart /* 5047f8829a4aSRandall Stewart * You get this once if you are 5048f8829a4aSRandall Stewart * active open side 5049f8829a4aSRandall Stewart */ 5050f8829a4aSRandall Stewart if (!(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL)) { 5051f8829a4aSRandall Stewart /* 5052f8829a4aSRandall Stewart * Remove flag if on the 5053f8829a4aSRandall Stewart * active open side 5054f8829a4aSRandall Stewart */ 5055f8829a4aSRandall Stewart inp->sctp_flags &= ~SCTP_PCB_FLAGS_WAS_ABORTED; 5056f8829a4aSRandall Stewart } 5057f8829a4aSRandall Stewart } 5058f8829a4aSRandall Stewart so->so_state &= ~(SS_ISCONNECTING | 5059f8829a4aSRandall Stewart SS_ISDISCONNECTING | 5060f8829a4aSRandall Stewart SS_ISCONFIRMING | 5061f8829a4aSRandall Stewart SS_ISCONNECTED); 5062f8829a4aSRandall Stewart if (error == 0) { 5063f8829a4aSRandall Stewart if ((inp->sctp_flags & SCTP_PCB_FLAGS_WAS_CONNECTED) == 0) { 5064c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, ENOTCONN); 5065f8829a4aSRandall Stewart error = ENOTCONN; 5066f8829a4aSRandall Stewart } else { 5067f8829a4aSRandall Stewart inp->sctp_flags &= ~SCTP_PCB_FLAGS_WAS_CONNECTED; 5068f8829a4aSRandall Stewart } 5069f8829a4aSRandall Stewart } 5070f8829a4aSRandall Stewart goto out; 5071f8829a4aSRandall Stewart } 5072f8829a4aSRandall Stewart } 5073f8829a4aSRandall Stewart error = sbwait(&so->so_rcv); 5074f8829a4aSRandall Stewart if (error) { 5075f8829a4aSRandall Stewart goto out; 5076f8829a4aSRandall Stewart } 5077f8829a4aSRandall Stewart held_length = 0; 5078f8829a4aSRandall Stewart goto restart_nosblocks; 5079f8829a4aSRandall Stewart } else if (so->so_rcv.sb_cc == 0) { 508044b7479bSRandall Stewart if (so->so_error) { 508144b7479bSRandall Stewart error = so->so_error; 508244b7479bSRandall Stewart if ((in_flags & MSG_PEEK) == 0) 508344b7479bSRandall Stewart so->so_error = 0; 508444b7479bSRandall Stewart } else { 508544b7479bSRandall Stewart if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) || 508644b7479bSRandall Stewart (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL)) { 508744b7479bSRandall Stewart if ((inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) == 0) { 508844b7479bSRandall Stewart /* 508944b7479bSRandall Stewart * For active open side clear flags 509044b7479bSRandall Stewart * for re-use passive open is 509144b7479bSRandall Stewart * blocked by connect. 509244b7479bSRandall Stewart */ 509344b7479bSRandall Stewart if (inp->sctp_flags & SCTP_PCB_FLAGS_WAS_ABORTED) { 509444b7479bSRandall Stewart /* 509544b7479bSRandall Stewart * You were aborted, passive 509644b7479bSRandall Stewart * side always hits here 509744b7479bSRandall Stewart */ 5098c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, ECONNRESET); 509944b7479bSRandall Stewart error = ECONNRESET; 510044b7479bSRandall Stewart /* 510144b7479bSRandall Stewart * You get this once if you 510244b7479bSRandall Stewart * are active open side 510344b7479bSRandall Stewart */ 510444b7479bSRandall Stewart if (!(inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL)) { 510544b7479bSRandall Stewart /* 510644b7479bSRandall Stewart * Remove flag if on 510744b7479bSRandall Stewart * the active open 510844b7479bSRandall Stewart * side 510944b7479bSRandall Stewart */ 511044b7479bSRandall Stewart inp->sctp_flags &= ~SCTP_PCB_FLAGS_WAS_ABORTED; 511144b7479bSRandall Stewart } 511244b7479bSRandall Stewart } 511344b7479bSRandall Stewart so->so_state &= ~(SS_ISCONNECTING | 511444b7479bSRandall Stewart SS_ISDISCONNECTING | 511544b7479bSRandall Stewart SS_ISCONFIRMING | 511644b7479bSRandall Stewart SS_ISCONNECTED); 511744b7479bSRandall Stewart if (error == 0) { 511844b7479bSRandall Stewart if ((inp->sctp_flags & SCTP_PCB_FLAGS_WAS_CONNECTED) == 0) { 5119c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, ENOTCONN); 512044b7479bSRandall Stewart error = ENOTCONN; 512144b7479bSRandall Stewart } else { 512244b7479bSRandall Stewart inp->sctp_flags &= ~SCTP_PCB_FLAGS_WAS_CONNECTED; 512344b7479bSRandall Stewart } 512444b7479bSRandall Stewart } 512544b7479bSRandall Stewart goto out; 512644b7479bSRandall Stewart } 512744b7479bSRandall Stewart } 5128c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EWOULDBLOCK); 5129f8829a4aSRandall Stewart error = EWOULDBLOCK; 513044b7479bSRandall Stewart } 5131f8829a4aSRandall Stewart goto out; 5132f8829a4aSRandall Stewart } 5133d06c82f1SRandall Stewart if (hold_sblock == 1) { 5134d06c82f1SRandall Stewart SOCKBUF_UNLOCK(&so->so_rcv); 5135d06c82f1SRandall Stewart hold_sblock = 0; 5136d06c82f1SRandall Stewart } 5137f8829a4aSRandall Stewart /* we possibly have data we can read */ 51383c503c28SRandall Stewart /* sa_ignore FREED_MEMORY */ 5139f8829a4aSRandall Stewart control = TAILQ_FIRST(&inp->read_queue); 5140f8829a4aSRandall Stewart if (control == NULL) { 5141f8829a4aSRandall Stewart /* 5142f8829a4aSRandall Stewart * This could be happening since the appender did the 5143f8829a4aSRandall Stewart * increment but as not yet did the tailq insert onto the 5144f8829a4aSRandall Stewart * read_queue 5145f8829a4aSRandall Stewart */ 5146f8829a4aSRandall Stewart if (hold_rlock == 0) { 5147f8829a4aSRandall Stewart SCTP_INP_READ_LOCK(inp); 5148f8829a4aSRandall Stewart hold_rlock = 1; 5149f8829a4aSRandall Stewart } 5150f8829a4aSRandall Stewart control = TAILQ_FIRST(&inp->read_queue); 5151f8829a4aSRandall Stewart if ((control == NULL) && (so->so_rcv.sb_cc != 0)) { 5152a5d547adSRandall Stewart #ifdef INVARIANTS 5153f8829a4aSRandall Stewart panic("Huh, its non zero and nothing on control?"); 5154f8829a4aSRandall Stewart #endif 5155f8829a4aSRandall Stewart so->so_rcv.sb_cc = 0; 5156f8829a4aSRandall Stewart } 5157f8829a4aSRandall Stewart SCTP_INP_READ_UNLOCK(inp); 5158f8829a4aSRandall Stewart hold_rlock = 0; 5159f8829a4aSRandall Stewart goto restart; 5160f8829a4aSRandall Stewart } 5161f8829a4aSRandall Stewart if ((control->length == 0) && 5162f8829a4aSRandall Stewart (control->do_not_ref_stcb)) { 5163f8829a4aSRandall Stewart /* 5164f8829a4aSRandall Stewart * Clean up code for freeing assoc that left behind a 5165f8829a4aSRandall Stewart * pdapi.. maybe a peer in EEOR that just closed after 5166f8829a4aSRandall Stewart * sending and never indicated a EOR. 5167f8829a4aSRandall Stewart */ 5168f8829a4aSRandall Stewart if (hold_rlock == 0) { 5169f8829a4aSRandall Stewart hold_rlock = 1; 5170f8829a4aSRandall Stewart SCTP_INP_READ_LOCK(inp); 5171f8829a4aSRandall Stewart } 5172f8829a4aSRandall Stewart control->held_length = 0; 5173f8829a4aSRandall Stewart if (control->data) { 5174f8829a4aSRandall Stewart /* Hmm there is data here .. fix */ 51754c9179adSRandall Stewart struct mbuf *m_tmp; 5176f8829a4aSRandall Stewart int cnt = 0; 5177f8829a4aSRandall Stewart 51784c9179adSRandall Stewart m_tmp = control->data; 51794c9179adSRandall Stewart while (m_tmp) { 51804c9179adSRandall Stewart cnt += SCTP_BUF_LEN(m_tmp); 51814c9179adSRandall Stewart if (SCTP_BUF_NEXT(m_tmp) == NULL) { 51824c9179adSRandall Stewart control->tail_mbuf = m_tmp; 5183f8829a4aSRandall Stewart control->end_added = 1; 5184f8829a4aSRandall Stewart } 51854c9179adSRandall Stewart m_tmp = SCTP_BUF_NEXT(m_tmp); 5186f8829a4aSRandall Stewart } 5187f8829a4aSRandall Stewart control->length = cnt; 5188f8829a4aSRandall Stewart } else { 5189f8829a4aSRandall Stewart /* remove it */ 5190f8829a4aSRandall Stewart TAILQ_REMOVE(&inp->read_queue, control, next); 5191f8829a4aSRandall Stewart /* Add back any hiddend data */ 5192f8829a4aSRandall Stewart sctp_free_remote_addr(control->whoFrom); 5193f8829a4aSRandall Stewart sctp_free_a_readq(stcb, control); 5194f8829a4aSRandall Stewart } 5195f8829a4aSRandall Stewart if (hold_rlock) { 5196f8829a4aSRandall Stewart hold_rlock = 0; 5197f8829a4aSRandall Stewart SCTP_INP_READ_UNLOCK(inp); 5198f8829a4aSRandall Stewart } 5199f8829a4aSRandall Stewart goto restart; 5200f8829a4aSRandall Stewart } 5201f8829a4aSRandall Stewart if (control->length == 0) { 5202f8829a4aSRandall Stewart if ((sctp_is_feature_on(inp, SCTP_PCB_FLAGS_FRAG_INTERLEAVE)) && 5203f8829a4aSRandall Stewart (filling_sinfo)) { 5204f8829a4aSRandall Stewart /* find a more suitable one then this */ 5205f8829a4aSRandall Stewart ctl = TAILQ_NEXT(control, next); 5206f8829a4aSRandall Stewart while (ctl) { 52079a6142d8SRandall Stewart if ((ctl->stcb != control->stcb) && (ctl->length) && 52089a6142d8SRandall Stewart (ctl->some_taken || 52096114cd96SRandall Stewart (ctl->spec_flags & M_NOTIFICATION) || 52109a6142d8SRandall Stewart ((ctl->do_not_ref_stcb == 0) && 52119a6142d8SRandall Stewart (ctl->stcb->asoc.strmin[ctl->sinfo_stream].delivery_started == 0))) 52129a6142d8SRandall Stewart ) { 52139a6142d8SRandall Stewart /*- 52149a6142d8SRandall Stewart * If we have a different TCB next, and there is data 52159a6142d8SRandall Stewart * present. If we have already taken some (pdapi), OR we can 52169a6142d8SRandall Stewart * ref the tcb and no delivery as started on this stream, we 521717205eccSRandall Stewart * take it. Note we allow a notification on a different 521817205eccSRandall Stewart * assoc to be delivered.. 52199a6142d8SRandall Stewart */ 52209a6142d8SRandall Stewart control = ctl; 52219a6142d8SRandall Stewart goto found_one; 52229a6142d8SRandall Stewart } else if ((sctp_is_feature_on(inp, SCTP_PCB_FLAGS_INTERLEAVE_STRMS)) && 52239a6142d8SRandall Stewart (ctl->length) && 52249a6142d8SRandall Stewart ((ctl->some_taken) || 52259a6142d8SRandall Stewart ((ctl->do_not_ref_stcb == 0) && 522617205eccSRandall Stewart ((ctl->spec_flags & M_NOTIFICATION) == 0) && 52279a6142d8SRandall Stewart (ctl->stcb->asoc.strmin[ctl->sinfo_stream].delivery_started == 0))) 52289a6142d8SRandall Stewart ) { 52299a6142d8SRandall Stewart /*- 52309a6142d8SRandall Stewart * If we have the same tcb, and there is data present, and we 52319a6142d8SRandall Stewart * have the strm interleave feature present. Then if we have 52329a6142d8SRandall Stewart * taken some (pdapi) or we can refer to tht tcb AND we have 52339a6142d8SRandall Stewart * not started a delivery for this stream, we can take it. 523417205eccSRandall Stewart * Note we do NOT allow a notificaiton on the same assoc to 523517205eccSRandall Stewart * be delivered. 52369a6142d8SRandall Stewart */ 5237f8829a4aSRandall Stewart control = ctl; 5238f8829a4aSRandall Stewart goto found_one; 5239f8829a4aSRandall Stewart } 5240f8829a4aSRandall Stewart ctl = TAILQ_NEXT(ctl, next); 5241f8829a4aSRandall Stewart } 5242f8829a4aSRandall Stewart } 5243f8829a4aSRandall Stewart /* 5244f8829a4aSRandall Stewart * if we reach here, not suitable replacement is available 5245f8829a4aSRandall Stewart * <or> fragment interleave is NOT on. So stuff the sb_cc 5246f8829a4aSRandall Stewart * into the our held count, and its time to sleep again. 5247f8829a4aSRandall Stewart */ 5248f8829a4aSRandall Stewart held_length = so->so_rcv.sb_cc; 5249f8829a4aSRandall Stewart control->held_length = so->so_rcv.sb_cc; 5250f8829a4aSRandall Stewart goto restart; 5251f8829a4aSRandall Stewart } 5252f8829a4aSRandall Stewart /* Clear the held length since there is something to read */ 5253f8829a4aSRandall Stewart control->held_length = 0; 5254f8829a4aSRandall Stewart if (hold_rlock) { 5255f8829a4aSRandall Stewart SCTP_INP_READ_UNLOCK(inp); 5256f8829a4aSRandall Stewart hold_rlock = 0; 5257f8829a4aSRandall Stewart } 5258f8829a4aSRandall Stewart found_one: 5259f8829a4aSRandall Stewart /* 5260f8829a4aSRandall Stewart * If we reach here, control has a some data for us to read off. 5261f8829a4aSRandall Stewart * Note that stcb COULD be NULL. 5262f8829a4aSRandall Stewart */ 52639a6142d8SRandall Stewart control->some_taken = 1; 5264f8829a4aSRandall Stewart if (hold_sblock) { 5265f8829a4aSRandall Stewart SOCKBUF_UNLOCK(&so->so_rcv); 5266f8829a4aSRandall Stewart hold_sblock = 0; 5267f8829a4aSRandall Stewart } 5268f8829a4aSRandall Stewart stcb = control->stcb; 5269f8829a4aSRandall Stewart if (stcb) { 52700696e120SRandall Stewart if ((control->do_not_ref_stcb == 0) && 52710696e120SRandall Stewart (stcb->asoc.state & SCTP_STATE_ABOUT_TO_BE_FREED)) { 527250cec919SRandall Stewart if (freecnt_applied == 0) 5273f8829a4aSRandall Stewart stcb = NULL; 5274f8829a4aSRandall Stewart } else if (control->do_not_ref_stcb == 0) { 5275f8829a4aSRandall Stewart /* you can't free it on me please */ 5276f8829a4aSRandall Stewart /* 5277f8829a4aSRandall Stewart * The lock on the socket buffer protects us so the 5278f8829a4aSRandall Stewart * free code will stop. But since we used the 5279f8829a4aSRandall Stewart * socketbuf lock and the sender uses the tcb_lock 5280f8829a4aSRandall Stewart * to increment, we need to use the atomic add to 5281f8829a4aSRandall Stewart * the refcnt 5282f8829a4aSRandall Stewart */ 5283d55b0b1bSRandall Stewart if (freecnt_applied) { 5284d55b0b1bSRandall Stewart #ifdef INVARIANTS 5285207304d4SRandall Stewart panic("refcnt already incremented"); 5286d55b0b1bSRandall Stewart #else 5287d55b0b1bSRandall Stewart printf("refcnt already incremented?\n"); 5288d55b0b1bSRandall Stewart #endif 5289d55b0b1bSRandall Stewart } else { 529050cec919SRandall Stewart atomic_add_int(&stcb->asoc.refcnt, 1); 5291f8829a4aSRandall Stewart freecnt_applied = 1; 5292d55b0b1bSRandall Stewart } 5293f8829a4aSRandall Stewart /* 5294f8829a4aSRandall Stewart * Setup to remember how much we have not yet told 5295f8829a4aSRandall Stewart * the peer our rwnd has opened up. Note we grab the 5296f8829a4aSRandall Stewart * value from the tcb from last time. Note too that 52970696e120SRandall Stewart * sack sending clears this when a sack is sent, 5298f8829a4aSRandall Stewart * which is fine. Once we hit the rwnd_req, we then 5299f8829a4aSRandall Stewart * will go to the sctp_user_rcvd() that will not 5300f8829a4aSRandall Stewart * lock until it KNOWs it MUST send a WUP-SACK. 5301f8829a4aSRandall Stewart */ 5302f8829a4aSRandall Stewart freed_so_far = stcb->freed_by_sorcv_sincelast; 5303f8829a4aSRandall Stewart stcb->freed_by_sorcv_sincelast = 0; 5304f8829a4aSRandall Stewart } 5305f8829a4aSRandall Stewart } 53066114cd96SRandall Stewart if (stcb && 53076114cd96SRandall Stewart ((control->spec_flags & M_NOTIFICATION) == 0) && 53086114cd96SRandall Stewart control->do_not_ref_stcb == 0) { 5309d06c82f1SRandall Stewart stcb->asoc.strmin[control->sinfo_stream].delivery_started = 1; 5310d06c82f1SRandall Stewart } 5311f8829a4aSRandall Stewart /* First lets get off the sinfo and sockaddr info */ 5312f8829a4aSRandall Stewart if ((sinfo) && filling_sinfo) { 5313f8829a4aSRandall Stewart memcpy(sinfo, control, sizeof(struct sctp_nonpad_sndrcvinfo)); 5314f8829a4aSRandall Stewart nxt = TAILQ_NEXT(control, next); 5315f8829a4aSRandall Stewart if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_EXT_RCVINFO)) { 5316f8829a4aSRandall Stewart struct sctp_extrcvinfo *s_extra; 5317f8829a4aSRandall Stewart 5318f8829a4aSRandall Stewart s_extra = (struct sctp_extrcvinfo *)sinfo; 53199a6142d8SRandall Stewart if ((nxt) && 53209a6142d8SRandall Stewart (nxt->length)) { 53219a6142d8SRandall Stewart s_extra->sreinfo_next_flags = SCTP_NEXT_MSG_AVAIL; 5322f8829a4aSRandall Stewart if (nxt->sinfo_flags & SCTP_UNORDERED) { 53239a6142d8SRandall Stewart s_extra->sreinfo_next_flags |= SCTP_NEXT_MSG_IS_UNORDERED; 5324f8829a4aSRandall Stewart } 5325f42a358aSRandall Stewart if (nxt->spec_flags & M_NOTIFICATION) { 53269a6142d8SRandall Stewart s_extra->sreinfo_next_flags |= SCTP_NEXT_MSG_IS_NOTIFICATION; 5327f42a358aSRandall Stewart } 53289a6142d8SRandall Stewart s_extra->sreinfo_next_aid = nxt->sinfo_assoc_id; 53299a6142d8SRandall Stewart s_extra->sreinfo_next_length = nxt->length; 53309a6142d8SRandall Stewart s_extra->sreinfo_next_ppid = nxt->sinfo_ppid; 53319a6142d8SRandall Stewart s_extra->sreinfo_next_stream = nxt->sinfo_stream; 5332f8829a4aSRandall Stewart if (nxt->tail_mbuf != NULL) { 5333139bc87fSRandall Stewart if (nxt->end_added) { 53349a6142d8SRandall Stewart s_extra->sreinfo_next_flags |= SCTP_NEXT_MSG_ISCOMPLETE; 5335f8829a4aSRandall Stewart } 5336f8829a4aSRandall Stewart } 5337f8829a4aSRandall Stewart } else { 5338f8829a4aSRandall Stewart /* 5339f8829a4aSRandall Stewart * we explicitly 0 this, since the memcpy 5340f8829a4aSRandall Stewart * got some other things beyond the older 5341f8829a4aSRandall Stewart * sinfo_ that is on the control's structure 5342f8829a4aSRandall Stewart * :-D 5343f8829a4aSRandall Stewart */ 53449a6142d8SRandall Stewart nxt = NULL; 53459a6142d8SRandall Stewart s_extra->sreinfo_next_flags = SCTP_NO_NEXT_MSG; 53469a6142d8SRandall Stewart s_extra->sreinfo_next_aid = 0; 53479a6142d8SRandall Stewart s_extra->sreinfo_next_length = 0; 53489a6142d8SRandall Stewart s_extra->sreinfo_next_ppid = 0; 53499a6142d8SRandall Stewart s_extra->sreinfo_next_stream = 0; 5350f8829a4aSRandall Stewart } 5351f8829a4aSRandall Stewart } 5352f8829a4aSRandall Stewart /* 5353f8829a4aSRandall Stewart * update off the real current cum-ack, if we have an stcb. 5354f8829a4aSRandall Stewart */ 53550696e120SRandall Stewart if ((control->do_not_ref_stcb == 0) && stcb) 5356f8829a4aSRandall Stewart sinfo->sinfo_cumtsn = stcb->asoc.cumulative_tsn; 5357f8829a4aSRandall Stewart /* 5358f8829a4aSRandall Stewart * mask off the high bits, we keep the actual chunk bits in 5359f8829a4aSRandall Stewart * there. 5360f8829a4aSRandall Stewart */ 5361f8829a4aSRandall Stewart sinfo->sinfo_flags &= 0x00ff; 53625f26a41dSRandall Stewart if ((control->sinfo_flags >> 8) & SCTP_DATA_UNORDERED) { 53635f26a41dSRandall Stewart sinfo->sinfo_flags |= SCTP_UNORDERED; 53645f26a41dSRandall Stewart } 5365f8829a4aSRandall Stewart } 536618e198d3SRandall Stewart #ifdef SCTP_ASOCLOG_OF_TSNS 536718e198d3SRandall Stewart { 536818e198d3SRandall Stewart int index, newindex; 536918e198d3SRandall Stewart struct sctp_pcbtsn_rlog *entry; 537018e198d3SRandall Stewart 537118e198d3SRandall Stewart do { 537218e198d3SRandall Stewart index = inp->readlog_index; 537318e198d3SRandall Stewart newindex = index + 1; 537418e198d3SRandall Stewart if (newindex >= SCTP_READ_LOG_SIZE) { 537518e198d3SRandall Stewart newindex = 0; 537618e198d3SRandall Stewart } 537718e198d3SRandall Stewart } while (atomic_cmpset_int(&inp->readlog_index, index, newindex) == 0); 537818e198d3SRandall Stewart entry = &inp->readlog[index]; 537918e198d3SRandall Stewart entry->vtag = control->sinfo_assoc_id; 538018e198d3SRandall Stewart entry->strm = control->sinfo_stream; 538118e198d3SRandall Stewart entry->seq = control->sinfo_ssn; 538218e198d3SRandall Stewart entry->sz = control->length; 538318e198d3SRandall Stewart entry->flgs = control->sinfo_flags; 538418e198d3SRandall Stewart } 538518e198d3SRandall Stewart #endif 5386f8829a4aSRandall Stewart if (fromlen && from) { 5387f8829a4aSRandall Stewart struct sockaddr *to; 5388f8829a4aSRandall Stewart 538942551e99SRandall Stewart #ifdef INET 5390baf3da66SRandall Stewart cp_len = min((size_t)fromlen, (size_t)control->whoFrom->ro._l_addr.sin.sin_len); 5391f8829a4aSRandall Stewart memcpy(from, &control->whoFrom->ro._l_addr, cp_len); 5392f8829a4aSRandall Stewart ((struct sockaddr_in *)from)->sin_port = control->port_from; 5393f8829a4aSRandall Stewart #else 5394f8829a4aSRandall Stewart /* No AF_INET use AF_INET6 */ 5395baf3da66SRandall Stewart cp_len = min((size_t)fromlen, (size_t)control->whoFrom->ro._l_addr.sin6.sin6_len); 5396f8829a4aSRandall Stewart memcpy(from, &control->whoFrom->ro._l_addr, cp_len); 5397f8829a4aSRandall Stewart ((struct sockaddr_in6 *)from)->sin6_port = control->port_from; 5398f8829a4aSRandall Stewart #endif 5399f8829a4aSRandall Stewart 5400f8829a4aSRandall Stewart to = from; 540142551e99SRandall Stewart #if defined(INET) && defined(INET6) 5402f8829a4aSRandall Stewart if ((inp->sctp_flags & SCTP_PCB_FLAGS_NEEDS_MAPPED_V4) && 5403f8829a4aSRandall Stewart (to->sa_family == AF_INET) && 5404f8829a4aSRandall Stewart ((size_t)fromlen >= sizeof(struct sockaddr_in6))) { 5405f8829a4aSRandall Stewart struct sockaddr_in *sin; 5406f8829a4aSRandall Stewart struct sockaddr_in6 sin6; 5407f8829a4aSRandall Stewart 5408f8829a4aSRandall Stewart sin = (struct sockaddr_in *)to; 5409f8829a4aSRandall Stewart bzero(&sin6, sizeof(sin6)); 5410f8829a4aSRandall Stewart sin6.sin6_family = AF_INET6; 5411f8829a4aSRandall Stewart sin6.sin6_len = sizeof(struct sockaddr_in6); 5412f8829a4aSRandall Stewart sin6.sin6_addr.s6_addr16[2] = 0xffff; 5413f8829a4aSRandall Stewart bcopy(&sin->sin_addr, 5414f8829a4aSRandall Stewart &sin6.sin6_addr.s6_addr16[3], 5415f8829a4aSRandall Stewart sizeof(sin6.sin6_addr.s6_addr16[3])); 5416f8829a4aSRandall Stewart sin6.sin6_port = sin->sin_port; 5417f8829a4aSRandall Stewart memcpy(from, (caddr_t)&sin6, sizeof(sin6)); 5418f8829a4aSRandall Stewart } 5419f8829a4aSRandall Stewart #endif 542042551e99SRandall Stewart #if defined(INET6) 5421f8829a4aSRandall Stewart { 5422f8829a4aSRandall Stewart struct sockaddr_in6 lsa6, *to6; 5423f8829a4aSRandall Stewart 5424f8829a4aSRandall Stewart to6 = (struct sockaddr_in6 *)to; 5425f8829a4aSRandall Stewart sctp_recover_scope_mac(to6, (&lsa6)); 5426f8829a4aSRandall Stewart } 5427f8829a4aSRandall Stewart #endif 5428f8829a4aSRandall Stewart } 5429f8829a4aSRandall Stewart /* now copy out what data we can */ 5430f8829a4aSRandall Stewart if (mp == NULL) { 5431f8829a4aSRandall Stewart /* copy out each mbuf in the chain up to length */ 5432f8829a4aSRandall Stewart get_more_data: 5433f8829a4aSRandall Stewart m = control->data; 5434f8829a4aSRandall Stewart while (m) { 5435f8829a4aSRandall Stewart /* Move out all we can */ 5436f8829a4aSRandall Stewart cp_len = (int)uio->uio_resid; 5437139bc87fSRandall Stewart my_len = (int)SCTP_BUF_LEN(m); 5438f8829a4aSRandall Stewart if (cp_len > my_len) { 5439f8829a4aSRandall Stewart /* not enough in this buf */ 5440f8829a4aSRandall Stewart cp_len = my_len; 5441f8829a4aSRandall Stewart } 5442f8829a4aSRandall Stewart if (hold_rlock) { 5443f8829a4aSRandall Stewart SCTP_INP_READ_UNLOCK(inp); 5444f8829a4aSRandall Stewart hold_rlock = 0; 5445f8829a4aSRandall Stewart } 5446f8829a4aSRandall Stewart if (cp_len > 0) 5447f8829a4aSRandall Stewart error = uiomove(mtod(m, char *), cp_len, uio); 5448f8829a4aSRandall Stewart /* re-read */ 5449f8829a4aSRandall Stewart if (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) { 5450f8829a4aSRandall Stewart goto release; 5451f8829a4aSRandall Stewart } 54520696e120SRandall Stewart if ((control->do_not_ref_stcb == 0) && stcb && 5453f8829a4aSRandall Stewart stcb->asoc.state & SCTP_STATE_ABOUT_TO_BE_FREED) { 5454f8829a4aSRandall Stewart no_rcv_needed = 1; 5455f8829a4aSRandall Stewart } 5456f8829a4aSRandall Stewart if (error) { 5457f8829a4aSRandall Stewart /* error we are out of here */ 5458f8829a4aSRandall Stewart goto release; 5459f8829a4aSRandall Stewart } 5460139bc87fSRandall Stewart if ((SCTP_BUF_NEXT(m) == NULL) && 5461139bc87fSRandall Stewart (cp_len >= SCTP_BUF_LEN(m)) && 5462f8829a4aSRandall Stewart ((control->end_added == 0) || 54630696e120SRandall Stewart (control->end_added && 54640696e120SRandall Stewart (TAILQ_NEXT(control, next) == NULL))) 5465f8829a4aSRandall Stewart ) { 5466f8829a4aSRandall Stewart SCTP_INP_READ_LOCK(inp); 5467f8829a4aSRandall Stewart hold_rlock = 1; 5468f8829a4aSRandall Stewart } 5469139bc87fSRandall Stewart if (cp_len == SCTP_BUF_LEN(m)) { 5470139bc87fSRandall Stewart if ((SCTP_BUF_NEXT(m) == NULL) && 5471139bc87fSRandall Stewart (control->end_added)) { 5472f8829a4aSRandall Stewart out_flags |= MSG_EOR; 54736114cd96SRandall Stewart if ((control->do_not_ref_stcb == 0) && ((control->spec_flags & M_NOTIFICATION) == 0)) 5474ee7f9857SRandall Stewart control->stcb->asoc.strmin[control->sinfo_stream].delivery_started = 0; 5475f8829a4aSRandall Stewart } 5476139bc87fSRandall Stewart if (control->spec_flags & M_NOTIFICATION) { 5477f8829a4aSRandall Stewart out_flags |= MSG_NOTIFICATION; 5478f8829a4aSRandall Stewart } 5479f8829a4aSRandall Stewart /* we ate up the mbuf */ 5480f8829a4aSRandall Stewart if (in_flags & MSG_PEEK) { 5481f8829a4aSRandall Stewart /* just looking */ 5482139bc87fSRandall Stewart m = SCTP_BUF_NEXT(m); 5483f8829a4aSRandall Stewart copied_so_far += cp_len; 5484f8829a4aSRandall Stewart } else { 5485f8829a4aSRandall Stewart /* dispose of the mbuf */ 548680fefe0aSRandall Stewart if (sctp_logging_level & SCTP_SB_LOGGING_ENABLE) { 5487f8829a4aSRandall Stewart sctp_sblog(&so->so_rcv, 5488139bc87fSRandall Stewart control->do_not_ref_stcb ? NULL : stcb, SCTP_LOG_SBFREE, SCTP_BUF_LEN(m)); 548980fefe0aSRandall Stewart } 5490f8829a4aSRandall Stewart sctp_sbfree(control, stcb, &so->so_rcv, m); 549180fefe0aSRandall Stewart if (sctp_logging_level & SCTP_SB_LOGGING_ENABLE) { 5492f8829a4aSRandall Stewart sctp_sblog(&so->so_rcv, 5493f8829a4aSRandall Stewart control->do_not_ref_stcb ? NULL : stcb, SCTP_LOG_SBRESULT, 0); 549480fefe0aSRandall Stewart } 5495f8829a4aSRandall Stewart embuf = m; 5496f8829a4aSRandall Stewart copied_so_far += cp_len; 5497f8829a4aSRandall Stewart freed_so_far += cp_len; 5498c4739e2fSRandall Stewart freed_so_far += MSIZE; 549918e198d3SRandall Stewart atomic_subtract_int(&control->length, cp_len); 5500f8829a4aSRandall Stewart control->data = sctp_m_free(m); 5501f8829a4aSRandall Stewart m = control->data; 5502f8829a4aSRandall Stewart /* 5503f8829a4aSRandall Stewart * been through it all, must hold sb 5504f8829a4aSRandall Stewart * lock ok to null tail 5505f8829a4aSRandall Stewart */ 5506f8829a4aSRandall Stewart if (control->data == NULL) { 5507a5d547adSRandall Stewart #ifdef INVARIANTS 5508f8829a4aSRandall Stewart if ((control->end_added == 0) || 5509f8829a4aSRandall Stewart (TAILQ_NEXT(control, next) == NULL)) { 5510f8829a4aSRandall Stewart /* 5511f8829a4aSRandall Stewart * If the end is not 5512f8829a4aSRandall Stewart * added, OR the 5513f8829a4aSRandall Stewart * next is NOT null 5514f8829a4aSRandall Stewart * we MUST have the 5515f8829a4aSRandall Stewart * lock. 5516f8829a4aSRandall Stewart */ 5517f8829a4aSRandall Stewart if (mtx_owned(&inp->inp_rdata_mtx) == 0) { 5518f8829a4aSRandall Stewart panic("Hmm we don't own the lock?"); 5519f8829a4aSRandall Stewart } 5520f8829a4aSRandall Stewart } 5521f8829a4aSRandall Stewart #endif 5522f8829a4aSRandall Stewart control->tail_mbuf = NULL; 5523a5d547adSRandall Stewart #ifdef INVARIANTS 5524f8829a4aSRandall Stewart if ((control->end_added) && ((out_flags & MSG_EOR) == 0)) { 5525f8829a4aSRandall Stewart panic("end_added, nothing left and no MSG_EOR"); 5526f8829a4aSRandall Stewart } 5527f8829a4aSRandall Stewart #endif 5528f8829a4aSRandall Stewart } 5529f8829a4aSRandall Stewart } 5530f8829a4aSRandall Stewart } else { 5531f8829a4aSRandall Stewart /* Do we need to trim the mbuf? */ 5532139bc87fSRandall Stewart if (control->spec_flags & M_NOTIFICATION) { 5533f8829a4aSRandall Stewart out_flags |= MSG_NOTIFICATION; 5534f8829a4aSRandall Stewart } 5535f8829a4aSRandall Stewart if ((in_flags & MSG_PEEK) == 0) { 5536139bc87fSRandall Stewart SCTP_BUF_RESV_UF(m, cp_len); 5537139bc87fSRandall Stewart SCTP_BUF_LEN(m) -= cp_len; 553880fefe0aSRandall Stewart if (sctp_logging_level & SCTP_SB_LOGGING_ENABLE) { 5539f8829a4aSRandall Stewart sctp_sblog(&so->so_rcv, control->do_not_ref_stcb ? NULL : stcb, SCTP_LOG_SBFREE, cp_len); 554080fefe0aSRandall Stewart } 5541f8829a4aSRandall Stewart atomic_subtract_int(&so->so_rcv.sb_cc, cp_len); 55420696e120SRandall Stewart if ((control->do_not_ref_stcb == 0) && 55430696e120SRandall Stewart stcb) { 5544f8829a4aSRandall Stewart atomic_subtract_int(&stcb->asoc.sb_cc, cp_len); 5545f8829a4aSRandall Stewart } 5546f8829a4aSRandall Stewart copied_so_far += cp_len; 5547f8829a4aSRandall Stewart embuf = m; 5548f8829a4aSRandall Stewart freed_so_far += cp_len; 5549c4739e2fSRandall Stewart freed_so_far += MSIZE; 555080fefe0aSRandall Stewart if (sctp_logging_level & SCTP_SB_LOGGING_ENABLE) { 5551f8829a4aSRandall Stewart sctp_sblog(&so->so_rcv, control->do_not_ref_stcb ? NULL : stcb, 5552f8829a4aSRandall Stewart SCTP_LOG_SBRESULT, 0); 555380fefe0aSRandall Stewart } 555418e198d3SRandall Stewart atomic_subtract_int(&control->length, cp_len); 5555f8829a4aSRandall Stewart } else { 5556f8829a4aSRandall Stewart copied_so_far += cp_len; 5557f8829a4aSRandall Stewart } 5558f8829a4aSRandall Stewart } 5559d61a0ae0SRandall Stewart if ((out_flags & MSG_EOR) || (uio->uio_resid == 0)) { 5560f8829a4aSRandall Stewart break; 5561f8829a4aSRandall Stewart } 5562f8829a4aSRandall Stewart if (((stcb) && (in_flags & MSG_PEEK) == 0) && 5563f8829a4aSRandall Stewart (control->do_not_ref_stcb == 0) && 5564f8829a4aSRandall Stewart (freed_so_far >= rwnd_req)) { 5565f8829a4aSRandall Stewart sctp_user_rcvd(stcb, &freed_so_far, hold_rlock, rwnd_req); 5566f8829a4aSRandall Stewart } 5567f8829a4aSRandall Stewart } /* end while(m) */ 5568f8829a4aSRandall Stewart /* 5569f8829a4aSRandall Stewart * At this point we have looked at it all and we either have 5570f8829a4aSRandall Stewart * a MSG_EOR/or read all the user wants... <OR> 5571f8829a4aSRandall Stewart * control->length == 0. 5572f8829a4aSRandall Stewart */ 5573d61a0ae0SRandall Stewart if ((out_flags & MSG_EOR) && ((in_flags & MSG_PEEK) == 0)) { 5574f8829a4aSRandall Stewart /* we are done with this control */ 5575f8829a4aSRandall Stewart if (control->length == 0) { 5576f8829a4aSRandall Stewart if (control->data) { 5577a5d547adSRandall Stewart #ifdef INVARIANTS 5578f8829a4aSRandall Stewart panic("control->data not null at read eor?"); 5579f8829a4aSRandall Stewart #else 5580ad81507eSRandall Stewart SCTP_PRINTF("Strange, data left in the control buffer .. invarients would panic?\n"); 5581f8829a4aSRandall Stewart sctp_m_freem(control->data); 5582f8829a4aSRandall Stewart control->data = NULL; 5583f8829a4aSRandall Stewart #endif 5584f8829a4aSRandall Stewart } 5585f8829a4aSRandall Stewart done_with_control: 5586f8829a4aSRandall Stewart if (TAILQ_NEXT(control, next) == NULL) { 5587f8829a4aSRandall Stewart /* 5588f8829a4aSRandall Stewart * If we don't have a next we need a 5589b201f536SRandall Stewart * lock, if there is a next 5590b201f536SRandall Stewart * interrupt is filling ahead of us 5591b201f536SRandall Stewart * and we don't need a lock to 5592b201f536SRandall Stewart * remove this guy (which is the 5593b201f536SRandall Stewart * head of the queue). 5594f8829a4aSRandall Stewart */ 5595f8829a4aSRandall Stewart if (hold_rlock == 0) { 5596f8829a4aSRandall Stewart SCTP_INP_READ_LOCK(inp); 5597f8829a4aSRandall Stewart hold_rlock = 1; 5598f8829a4aSRandall Stewart } 5599f8829a4aSRandall Stewart } 5600f8829a4aSRandall Stewart TAILQ_REMOVE(&inp->read_queue, control, next); 5601f8829a4aSRandall Stewart /* Add back any hiddend data */ 5602f8829a4aSRandall Stewart if (control->held_length) { 5603f8829a4aSRandall Stewart held_length = 0; 5604f8829a4aSRandall Stewart control->held_length = 0; 5605f8829a4aSRandall Stewart wakeup_read_socket = 1; 5606f8829a4aSRandall Stewart } 560717205eccSRandall Stewart if (control->aux_data) { 560817205eccSRandall Stewart sctp_m_free(control->aux_data); 560917205eccSRandall Stewart control->aux_data = NULL; 561017205eccSRandall Stewart } 5611f8829a4aSRandall Stewart no_rcv_needed = control->do_not_ref_stcb; 5612f8829a4aSRandall Stewart sctp_free_remote_addr(control->whoFrom); 5613f8829a4aSRandall Stewart control->data = NULL; 5614f8829a4aSRandall Stewart sctp_free_a_readq(stcb, control); 5615f8829a4aSRandall Stewart control = NULL; 56160696e120SRandall Stewart if ((freed_so_far >= rwnd_req) && 56170696e120SRandall Stewart (no_rcv_needed == 0)) 5618f8829a4aSRandall Stewart sctp_user_rcvd(stcb, &freed_so_far, hold_rlock, rwnd_req); 5619f8829a4aSRandall Stewart 5620f8829a4aSRandall Stewart } else { 5621f8829a4aSRandall Stewart /* 5622f8829a4aSRandall Stewart * The user did not read all of this 5623f8829a4aSRandall Stewart * message, turn off the returned MSG_EOR 5624f8829a4aSRandall Stewart * since we are leaving more behind on the 5625f8829a4aSRandall Stewart * control to read. 5626f8829a4aSRandall Stewart */ 5627a5d547adSRandall Stewart #ifdef INVARIANTS 56280696e120SRandall Stewart if (control->end_added && 56290696e120SRandall Stewart (control->data == NULL) && 5630f8829a4aSRandall Stewart (control->tail_mbuf == NULL)) { 5631f8829a4aSRandall Stewart panic("Gak, control->length is corrupt?"); 5632f8829a4aSRandall Stewart } 5633f8829a4aSRandall Stewart #endif 5634f8829a4aSRandall Stewart no_rcv_needed = control->do_not_ref_stcb; 5635f8829a4aSRandall Stewart out_flags &= ~MSG_EOR; 5636f8829a4aSRandall Stewart } 5637f8829a4aSRandall Stewart } 5638f8829a4aSRandall Stewart if (out_flags & MSG_EOR) { 5639f8829a4aSRandall Stewart goto release; 5640f8829a4aSRandall Stewart } 5641f8829a4aSRandall Stewart if ((uio->uio_resid == 0) || 5642f8829a4aSRandall Stewart ((in_eeor_mode) && (copied_so_far >= max(so->so_rcv.sb_lowat, 1))) 5643f8829a4aSRandall Stewart ) { 5644f8829a4aSRandall Stewart goto release; 5645f8829a4aSRandall Stewart } 5646f8829a4aSRandall Stewart /* 5647f8829a4aSRandall Stewart * If I hit here the receiver wants more and this message is 5648f8829a4aSRandall Stewart * NOT done (pd-api). So two questions. Can we block? if not 5649f8829a4aSRandall Stewart * we are done. Did the user NOT set MSG_WAITALL? 5650f8829a4aSRandall Stewart */ 5651f8829a4aSRandall Stewart if (block_allowed == 0) { 5652f8829a4aSRandall Stewart goto release; 5653f8829a4aSRandall Stewart } 5654f8829a4aSRandall Stewart /* 5655f8829a4aSRandall Stewart * We need to wait for more data a few things: - We don't 5656f8829a4aSRandall Stewart * sbunlock() so we don't get someone else reading. - We 5657f8829a4aSRandall Stewart * must be sure to account for the case where what is added 5658f8829a4aSRandall Stewart * is NOT to our control when we wakeup. 5659f8829a4aSRandall Stewart */ 5660f8829a4aSRandall Stewart 5661f8829a4aSRandall Stewart /* 5662f8829a4aSRandall Stewart * Do we need to tell the transport a rwnd update might be 5663f8829a4aSRandall Stewart * needed before we go to sleep? 5664f8829a4aSRandall Stewart */ 5665f8829a4aSRandall Stewart if (((stcb) && (in_flags & MSG_PEEK) == 0) && 5666f8829a4aSRandall Stewart ((freed_so_far >= rwnd_req) && 5667f8829a4aSRandall Stewart (control->do_not_ref_stcb == 0) && 5668f8829a4aSRandall Stewart (no_rcv_needed == 0))) { 5669f8829a4aSRandall Stewart sctp_user_rcvd(stcb, &freed_so_far, hold_rlock, rwnd_req); 5670f8829a4aSRandall Stewart } 5671f8829a4aSRandall Stewart wait_some_more: 567244b7479bSRandall Stewart if (so->so_rcv.sb_state & SBS_CANTRCVMORE) { 5673f8829a4aSRandall Stewart goto release; 5674f8829a4aSRandall Stewart } 5675f8829a4aSRandall Stewart if (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) 5676f8829a4aSRandall Stewart goto release; 5677f8829a4aSRandall Stewart 5678f8829a4aSRandall Stewart if (hold_rlock == 1) { 5679f8829a4aSRandall Stewart SCTP_INP_READ_UNLOCK(inp); 5680f8829a4aSRandall Stewart hold_rlock = 0; 5681f8829a4aSRandall Stewart } 5682f8829a4aSRandall Stewart if (hold_sblock == 0) { 5683f8829a4aSRandall Stewart SOCKBUF_LOCK(&so->so_rcv); 5684f8829a4aSRandall Stewart hold_sblock = 1; 5685f8829a4aSRandall Stewart } 5686851b7298SRandall Stewart if ((copied_so_far) && (control->length == 0) && 5687851b7298SRandall Stewart (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_FRAG_INTERLEAVE)) 5688851b7298SRandall Stewart ) { 5689851b7298SRandall Stewart goto release; 5690851b7298SRandall Stewart } 5691f8829a4aSRandall Stewart if (so->so_rcv.sb_cc <= control->held_length) { 5692f8829a4aSRandall Stewart error = sbwait(&so->so_rcv); 5693f8829a4aSRandall Stewart if (error) { 5694f8829a4aSRandall Stewart goto release; 5695f8829a4aSRandall Stewart } 5696f8829a4aSRandall Stewart control->held_length = 0; 5697f8829a4aSRandall Stewart } 5698f8829a4aSRandall Stewart if (hold_sblock) { 5699f8829a4aSRandall Stewart SOCKBUF_UNLOCK(&so->so_rcv); 5700f8829a4aSRandall Stewart hold_sblock = 0; 5701f8829a4aSRandall Stewart } 5702f8829a4aSRandall Stewart if (control->length == 0) { 5703f8829a4aSRandall Stewart /* still nothing here */ 5704f8829a4aSRandall Stewart if (control->end_added == 1) { 5705f8829a4aSRandall Stewart /* he aborted, or is done i.e.did a shutdown */ 5706f8829a4aSRandall Stewart out_flags |= MSG_EOR; 57079a6142d8SRandall Stewart if (control->pdapi_aborted) { 57086114cd96SRandall Stewart if ((control->do_not_ref_stcb == 0) && ((control->spec_flags & M_NOTIFICATION) == 0)) 5709ee7f9857SRandall Stewart control->stcb->asoc.strmin[control->sinfo_stream].delivery_started = 0; 57109a6142d8SRandall Stewart 571103b0b021SRandall Stewart out_flags |= MSG_TRUNC; 57129a6142d8SRandall Stewart } else { 57136114cd96SRandall Stewart if ((control->do_not_ref_stcb == 0) && ((control->spec_flags & M_NOTIFICATION) == 0)) 5714ee7f9857SRandall Stewart control->stcb->asoc.strmin[control->sinfo_stream].delivery_started = 0; 57159a6142d8SRandall Stewart } 5716f8829a4aSRandall Stewart goto done_with_control; 5717f8829a4aSRandall Stewart } 5718f8829a4aSRandall Stewart if (so->so_rcv.sb_cc > held_length) { 5719f8829a4aSRandall Stewart control->held_length = so->so_rcv.sb_cc; 5720f8829a4aSRandall Stewart held_length = 0; 5721f8829a4aSRandall Stewart } 5722f8829a4aSRandall Stewart goto wait_some_more; 5723f8829a4aSRandall Stewart } else if (control->data == NULL) { 572450cec919SRandall Stewart /* 572550cec919SRandall Stewart * we must re-sync since data is probably being 572650cec919SRandall Stewart * added 572750cec919SRandall Stewart */ 572850cec919SRandall Stewart SCTP_INP_READ_LOCK(inp); 572950cec919SRandall Stewart if ((control->length > 0) && (control->data == NULL)) { 573050cec919SRandall Stewart /* 573150cec919SRandall Stewart * big trouble.. we have the lock and its 573250cec919SRandall Stewart * corrupt? 573350cec919SRandall Stewart */ 5734f8829a4aSRandall Stewart panic("Impossible data==NULL length !=0"); 5735f8829a4aSRandall Stewart } 573650cec919SRandall Stewart SCTP_INP_READ_UNLOCK(inp); 573750cec919SRandall Stewart /* We will fall around to get more data */ 573850cec919SRandall Stewart } 5739f8829a4aSRandall Stewart goto get_more_data; 5740f8829a4aSRandall Stewart } else { 574117205eccSRandall Stewart /*- 574217205eccSRandall Stewart * Give caller back the mbuf chain, 574317205eccSRandall Stewart * store in uio_resid the length 5744f8829a4aSRandall Stewart */ 574517205eccSRandall Stewart wakeup_read_socket = 0; 5746f8829a4aSRandall Stewart if ((control->end_added == 0) || 5747f8829a4aSRandall Stewart (TAILQ_NEXT(control, next) == NULL)) { 5748f8829a4aSRandall Stewart /* Need to get rlock */ 5749f8829a4aSRandall Stewart if (hold_rlock == 0) { 5750f8829a4aSRandall Stewart SCTP_INP_READ_LOCK(inp); 5751f8829a4aSRandall Stewart hold_rlock = 1; 5752f8829a4aSRandall Stewart } 5753f8829a4aSRandall Stewart } 5754139bc87fSRandall Stewart if (control->end_added) { 5755f8829a4aSRandall Stewart out_flags |= MSG_EOR; 57566114cd96SRandall Stewart if ((control->do_not_ref_stcb == 0) && ((control->spec_flags & M_NOTIFICATION) == 0)) 5757ee7f9857SRandall Stewart control->stcb->asoc.strmin[control->sinfo_stream].delivery_started = 0; 5758f8829a4aSRandall Stewart } 5759139bc87fSRandall Stewart if (control->spec_flags & M_NOTIFICATION) { 5760f8829a4aSRandall Stewart out_flags |= MSG_NOTIFICATION; 5761f8829a4aSRandall Stewart } 576217205eccSRandall Stewart uio->uio_resid = control->length; 5763f8829a4aSRandall Stewart *mp = control->data; 5764f8829a4aSRandall Stewart m = control->data; 5765f8829a4aSRandall Stewart while (m) { 576680fefe0aSRandall Stewart if (sctp_logging_level & SCTP_SB_LOGGING_ENABLE) { 5767f8829a4aSRandall Stewart sctp_sblog(&so->so_rcv, 5768139bc87fSRandall Stewart control->do_not_ref_stcb ? NULL : stcb, SCTP_LOG_SBFREE, SCTP_BUF_LEN(m)); 576980fefe0aSRandall Stewart } 5770f8829a4aSRandall Stewart sctp_sbfree(control, stcb, &so->so_rcv, m); 5771139bc87fSRandall Stewart freed_so_far += SCTP_BUF_LEN(m); 5772c4739e2fSRandall Stewart freed_so_far += MSIZE; 577380fefe0aSRandall Stewart if (sctp_logging_level & SCTP_SB_LOGGING_ENABLE) { 5774f8829a4aSRandall Stewart sctp_sblog(&so->so_rcv, 5775f8829a4aSRandall Stewart control->do_not_ref_stcb ? NULL : stcb, SCTP_LOG_SBRESULT, 0); 577680fefe0aSRandall Stewart } 5777139bc87fSRandall Stewart m = SCTP_BUF_NEXT(m); 5778f8829a4aSRandall Stewart } 5779f8829a4aSRandall Stewart control->data = control->tail_mbuf = NULL; 5780f8829a4aSRandall Stewart control->length = 0; 5781f8829a4aSRandall Stewart if (out_flags & MSG_EOR) { 5782f8829a4aSRandall Stewart /* Done with this control */ 5783f8829a4aSRandall Stewart goto done_with_control; 5784f8829a4aSRandall Stewart } 5785f8829a4aSRandall Stewart } 5786f8829a4aSRandall Stewart release: 5787f8829a4aSRandall Stewart if (hold_rlock == 1) { 5788f8829a4aSRandall Stewart SCTP_INP_READ_UNLOCK(inp); 5789f8829a4aSRandall Stewart hold_rlock = 0; 5790f8829a4aSRandall Stewart } 57917abab911SRobert Watson if (hold_sblock == 1) { 57927abab911SRobert Watson SOCKBUF_UNLOCK(&so->so_rcv); 57937abab911SRobert Watson hold_sblock = 0; 5794f8829a4aSRandall Stewart } 5795f8829a4aSRandall Stewart sbunlock(&so->so_rcv); 57967abab911SRobert Watson sockbuf_lock = 0; 5797f8829a4aSRandall Stewart 5798f8829a4aSRandall Stewart release_unlocked: 5799f8829a4aSRandall Stewart if (hold_sblock) { 5800f8829a4aSRandall Stewart SOCKBUF_UNLOCK(&so->so_rcv); 5801f8829a4aSRandall Stewart hold_sblock = 0; 5802f8829a4aSRandall Stewart } 5803f8829a4aSRandall Stewart if ((stcb) && (in_flags & MSG_PEEK) == 0) { 5804f8829a4aSRandall Stewart if ((freed_so_far >= rwnd_req) && 5805f8829a4aSRandall Stewart (control && (control->do_not_ref_stcb == 0)) && 5806f8829a4aSRandall Stewart (no_rcv_needed == 0)) 5807f8829a4aSRandall Stewart sctp_user_rcvd(stcb, &freed_so_far, hold_rlock, rwnd_req); 5808f8829a4aSRandall Stewart } 5809f8829a4aSRandall Stewart if (msg_flags) 5810f8829a4aSRandall Stewart *msg_flags |= out_flags; 5811f8829a4aSRandall Stewart out: 58129a6142d8SRandall Stewart if (((out_flags & MSG_EOR) == 0) && 58139a6142d8SRandall Stewart ((in_flags & MSG_PEEK) == 0) && 58149a6142d8SRandall Stewart (sinfo) && 58159a6142d8SRandall Stewart (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_EXT_RCVINFO))) { 58169a6142d8SRandall Stewart struct sctp_extrcvinfo *s_extra; 58179a6142d8SRandall Stewart 58189a6142d8SRandall Stewart s_extra = (struct sctp_extrcvinfo *)sinfo; 58199a6142d8SRandall Stewart s_extra->sreinfo_next_flags = SCTP_NO_NEXT_MSG; 58209a6142d8SRandall Stewart } 5821f8829a4aSRandall Stewart if (hold_rlock == 1) { 5822f8829a4aSRandall Stewart SCTP_INP_READ_UNLOCK(inp); 5823f8829a4aSRandall Stewart hold_rlock = 0; 5824f8829a4aSRandall Stewart } 5825f8829a4aSRandall Stewart if (hold_sblock) { 5826f8829a4aSRandall Stewart SOCKBUF_UNLOCK(&so->so_rcv); 5827f8829a4aSRandall Stewart hold_sblock = 0; 5828f8829a4aSRandall Stewart } 58297abab911SRobert Watson if (sockbuf_lock) { 58307abab911SRobert Watson sbunlock(&so->so_rcv); 58317abab911SRobert Watson } 583250cec919SRandall Stewart if (freecnt_applied) { 5833f8829a4aSRandall Stewart /* 5834f8829a4aSRandall Stewart * The lock on the socket buffer protects us so the free 5835f8829a4aSRandall Stewart * code will stop. But since we used the socketbuf lock and 5836f8829a4aSRandall Stewart * the sender uses the tcb_lock to increment, we need to use 5837f8829a4aSRandall Stewart * the atomic add to the refcnt. 5838f8829a4aSRandall Stewart */ 583950cec919SRandall Stewart if (stcb == NULL) { 584050cec919SRandall Stewart panic("stcb for refcnt has gone NULL?"); 584150cec919SRandall Stewart } 584250cec919SRandall Stewart atomic_add_int(&stcb->asoc.refcnt, -1); 5843f8829a4aSRandall Stewart freecnt_applied = 0; 5844f8829a4aSRandall Stewart /* Save the value back for next time */ 5845f8829a4aSRandall Stewart stcb->freed_by_sorcv_sincelast = freed_so_far; 5846f8829a4aSRandall Stewart } 584780fefe0aSRandall Stewart if (sctp_logging_level & SCTP_RECV_RWND_LOGGING_ENABLE) { 5848f8829a4aSRandall Stewart if (stcb) { 5849f8829a4aSRandall Stewart sctp_misc_ints(SCTP_SORECV_DONE, 5850f8829a4aSRandall Stewart freed_so_far, 5851f8829a4aSRandall Stewart ((uio) ? (slen - uio->uio_resid) : slen), 5852f8829a4aSRandall Stewart stcb->asoc.my_rwnd, 5853f8829a4aSRandall Stewart so->so_rcv.sb_cc); 5854f8829a4aSRandall Stewart } else { 5855f8829a4aSRandall Stewart sctp_misc_ints(SCTP_SORECV_DONE, 5856f8829a4aSRandall Stewart freed_so_far, 5857f8829a4aSRandall Stewart ((uio) ? (slen - uio->uio_resid) : slen), 5858f8829a4aSRandall Stewart 0, 5859f8829a4aSRandall Stewart so->so_rcv.sb_cc); 5860f8829a4aSRandall Stewart } 586180fefe0aSRandall Stewart } 5862f8829a4aSRandall Stewart if (wakeup_read_socket) { 5863f8829a4aSRandall Stewart sctp_sorwakeup(inp, so); 5864f8829a4aSRandall Stewart } 5865f8829a4aSRandall Stewart return (error); 5866f8829a4aSRandall Stewart } 5867f8829a4aSRandall Stewart 5868f8829a4aSRandall Stewart 5869f8829a4aSRandall Stewart #ifdef SCTP_MBUF_LOGGING 5870f8829a4aSRandall Stewart struct mbuf * 5871f8829a4aSRandall Stewart sctp_m_free(struct mbuf *m) 5872f8829a4aSRandall Stewart { 587380fefe0aSRandall Stewart if (sctp_logging_level & SCTP_MBUF_LOGGING_ENABLE) { 5874139bc87fSRandall Stewart if (SCTP_BUF_IS_EXTENDED(m)) { 5875f8829a4aSRandall Stewart sctp_log_mb(m, SCTP_MBUF_IFREE); 5876f8829a4aSRandall Stewart } 587780fefe0aSRandall Stewart } 5878f8829a4aSRandall Stewart return (m_free(m)); 5879f8829a4aSRandall Stewart } 5880f8829a4aSRandall Stewart 5881f8829a4aSRandall Stewart void 5882f8829a4aSRandall Stewart sctp_m_freem(struct mbuf *mb) 5883f8829a4aSRandall Stewart { 5884f8829a4aSRandall Stewart while (mb != NULL) 5885f8829a4aSRandall Stewart mb = sctp_m_free(mb); 5886f8829a4aSRandall Stewart } 5887f8829a4aSRandall Stewart 5888f8829a4aSRandall Stewart #endif 5889f8829a4aSRandall Stewart 589042551e99SRandall Stewart int 589142551e99SRandall Stewart sctp_dynamic_set_primary(struct sockaddr *sa, uint32_t vrf_id) 589242551e99SRandall Stewart { 589342551e99SRandall Stewart /* 589442551e99SRandall Stewart * Given a local address. For all associations that holds the 589542551e99SRandall Stewart * address, request a peer-set-primary. 589642551e99SRandall Stewart */ 589742551e99SRandall Stewart struct sctp_ifa *ifa; 589842551e99SRandall Stewart struct sctp_laddr *wi; 589942551e99SRandall Stewart 590042551e99SRandall Stewart ifa = sctp_find_ifa_by_addr(sa, vrf_id, 0); 590142551e99SRandall Stewart if (ifa == NULL) { 5902c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET(NULL, NULL, NULL, SCTP_FROM_SCTPUTIL, EADDRNOTAVAIL); 590342551e99SRandall Stewart return (EADDRNOTAVAIL); 590442551e99SRandall Stewart } 590542551e99SRandall Stewart /* 590642551e99SRandall Stewart * Now that we have the ifa we must awaken the iterator with this 590742551e99SRandall Stewart * message. 590842551e99SRandall Stewart */ 590942551e99SRandall Stewart wi = SCTP_ZONE_GET(sctppcbinfo.ipi_zone_laddr, struct sctp_laddr); 591042551e99SRandall Stewart if (wi == NULL) { 5911c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET(NULL, NULL, NULL, SCTP_FROM_SCTPUTIL, ENOMEM); 591242551e99SRandall Stewart return (ENOMEM); 591342551e99SRandall Stewart } 591442551e99SRandall Stewart /* Now incr the count and int wi structure */ 591542551e99SRandall Stewart SCTP_INCR_LADDR_COUNT(); 591642551e99SRandall Stewart bzero(wi, sizeof(*wi)); 5917d61a0ae0SRandall Stewart (void)SCTP_GETTIME_TIMEVAL(&wi->start_time); 591842551e99SRandall Stewart wi->ifa = ifa; 591942551e99SRandall Stewart wi->action = SCTP_SET_PRIM_ADDR; 592042551e99SRandall Stewart atomic_add_int(&ifa->refcount, 1); 592142551e99SRandall Stewart 592242551e99SRandall Stewart /* Now add it to the work queue */ 592342551e99SRandall Stewart SCTP_IPI_ITERATOR_WQ_LOCK(); 592442551e99SRandall Stewart /* 592542551e99SRandall Stewart * Should this really be a tailq? As it is we will process the 592642551e99SRandall Stewart * newest first :-0 592742551e99SRandall Stewart */ 592842551e99SRandall Stewart LIST_INSERT_HEAD(&sctppcbinfo.addr_wq, wi, sctp_nxt_addr); 592942551e99SRandall Stewart sctp_timer_start(SCTP_TIMER_TYPE_ADDR_WQ, 593042551e99SRandall Stewart (struct sctp_inpcb *)NULL, 593142551e99SRandall Stewart (struct sctp_tcb *)NULL, 593242551e99SRandall Stewart (struct sctp_nets *)NULL); 593342551e99SRandall Stewart SCTP_IPI_ITERATOR_WQ_UNLOCK(); 593442551e99SRandall Stewart return (0); 593542551e99SRandall Stewart } 593642551e99SRandall Stewart 593742551e99SRandall Stewart 593842551e99SRandall Stewart 5939f8829a4aSRandall Stewart 5940f8829a4aSRandall Stewart int 594117205eccSRandall Stewart sctp_soreceive(struct socket *so, 594217205eccSRandall Stewart struct sockaddr **psa, 594317205eccSRandall Stewart struct uio *uio, 594417205eccSRandall Stewart struct mbuf **mp0, 594517205eccSRandall Stewart struct mbuf **controlp, 594617205eccSRandall Stewart int *flagsp) 5947f8829a4aSRandall Stewart { 5948f8829a4aSRandall Stewart int error, fromlen; 5949f8829a4aSRandall Stewart uint8_t sockbuf[256]; 5950f8829a4aSRandall Stewart struct sockaddr *from; 5951f8829a4aSRandall Stewart struct sctp_extrcvinfo sinfo; 5952f8829a4aSRandall Stewart int filling_sinfo = 1; 5953f8829a4aSRandall Stewart struct sctp_inpcb *inp; 5954f8829a4aSRandall Stewart 5955f8829a4aSRandall Stewart inp = (struct sctp_inpcb *)so->so_pcb; 5956f8829a4aSRandall Stewart /* pickup the assoc we are reading from */ 5957f8829a4aSRandall Stewart if (inp == NULL) { 5958c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL); 5959f8829a4aSRandall Stewart return (EINVAL); 5960f8829a4aSRandall Stewart } 5961f8829a4aSRandall Stewart if ((sctp_is_feature_off(inp, 5962f8829a4aSRandall Stewart SCTP_PCB_FLAGS_RECVDATAIOEVNT)) || 5963f8829a4aSRandall Stewart (controlp == NULL)) { 5964f8829a4aSRandall Stewart /* user does not want the sndrcv ctl */ 5965f8829a4aSRandall Stewart filling_sinfo = 0; 5966f8829a4aSRandall Stewart } 5967f8829a4aSRandall Stewart if (psa) { 5968f8829a4aSRandall Stewart from = (struct sockaddr *)sockbuf; 5969f8829a4aSRandall Stewart fromlen = sizeof(sockbuf); 5970f8829a4aSRandall Stewart from->sa_len = 0; 5971f8829a4aSRandall Stewart } else { 5972f8829a4aSRandall Stewart from = NULL; 5973f8829a4aSRandall Stewart fromlen = 0; 5974f8829a4aSRandall Stewart } 5975f8829a4aSRandall Stewart 5976f8829a4aSRandall Stewart error = sctp_sorecvmsg(so, uio, mp0, from, fromlen, flagsp, 5977f8829a4aSRandall Stewart (struct sctp_sndrcvinfo *)&sinfo, filling_sinfo); 5978f8829a4aSRandall Stewart if ((controlp) && (filling_sinfo)) { 5979f8829a4aSRandall Stewart /* copy back the sinfo in a CMSG format */ 5980f8829a4aSRandall Stewart if (filling_sinfo) 5981f8829a4aSRandall Stewart *controlp = sctp_build_ctl_nchunk(inp, 5982f8829a4aSRandall Stewart (struct sctp_sndrcvinfo *)&sinfo); 5983f8829a4aSRandall Stewart else 5984f8829a4aSRandall Stewart *controlp = NULL; 5985f8829a4aSRandall Stewart } 5986f8829a4aSRandall Stewart if (psa) { 5987f8829a4aSRandall Stewart /* copy back the address info */ 5988f8829a4aSRandall Stewart if (from && from->sa_len) { 5989f8829a4aSRandall Stewart *psa = sodupsockaddr(from, M_NOWAIT); 5990f8829a4aSRandall Stewart } else { 5991f8829a4aSRandall Stewart *psa = NULL; 5992f8829a4aSRandall Stewart } 5993f8829a4aSRandall Stewart } 5994f8829a4aSRandall Stewart return (error); 5995f8829a4aSRandall Stewart } 599617205eccSRandall Stewart 599717205eccSRandall Stewart 599817205eccSRandall Stewart int 599917205eccSRandall Stewart sctp_l_soreceive(struct socket *so, 600017205eccSRandall Stewart struct sockaddr **name, 600117205eccSRandall Stewart struct uio *uio, 600217205eccSRandall Stewart char **controlp, 600317205eccSRandall Stewart int *controllen, 600417205eccSRandall Stewart int *flag) 600517205eccSRandall Stewart { 600617205eccSRandall Stewart int error, fromlen; 600717205eccSRandall Stewart uint8_t sockbuf[256]; 600817205eccSRandall Stewart struct sockaddr *from; 600917205eccSRandall Stewart struct sctp_extrcvinfo sinfo; 601017205eccSRandall Stewart int filling_sinfo = 1; 601117205eccSRandall Stewart struct sctp_inpcb *inp; 601217205eccSRandall Stewart 601317205eccSRandall Stewart inp = (struct sctp_inpcb *)so->so_pcb; 601417205eccSRandall Stewart /* pickup the assoc we are reading from */ 601517205eccSRandall Stewart if (inp == NULL) { 6016c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL); 601717205eccSRandall Stewart return (EINVAL); 601817205eccSRandall Stewart } 601917205eccSRandall Stewart if ((sctp_is_feature_off(inp, 602017205eccSRandall Stewart SCTP_PCB_FLAGS_RECVDATAIOEVNT)) || 602117205eccSRandall Stewart (controlp == NULL)) { 602217205eccSRandall Stewart /* user does not want the sndrcv ctl */ 602317205eccSRandall Stewart filling_sinfo = 0; 602417205eccSRandall Stewart } 602517205eccSRandall Stewart if (name) { 602617205eccSRandall Stewart from = (struct sockaddr *)sockbuf; 602717205eccSRandall Stewart fromlen = sizeof(sockbuf); 602817205eccSRandall Stewart from->sa_len = 0; 602917205eccSRandall Stewart } else { 603017205eccSRandall Stewart from = NULL; 603117205eccSRandall Stewart fromlen = 0; 603217205eccSRandall Stewart } 603317205eccSRandall Stewart 603417205eccSRandall Stewart error = sctp_sorecvmsg(so, uio, 603517205eccSRandall Stewart (struct mbuf **)NULL, 603617205eccSRandall Stewart from, fromlen, flag, 603717205eccSRandall Stewart (struct sctp_sndrcvinfo *)&sinfo, 603817205eccSRandall Stewart filling_sinfo); 603917205eccSRandall Stewart if ((controlp) && (filling_sinfo)) { 604017205eccSRandall Stewart /* 604117205eccSRandall Stewart * copy back the sinfo in a CMSG format note that the caller 604217205eccSRandall Stewart * has reponsibility for freeing the memory. 604317205eccSRandall Stewart */ 604417205eccSRandall Stewart if (filling_sinfo) 604517205eccSRandall Stewart *controlp = sctp_build_ctl_cchunk(inp, 604617205eccSRandall Stewart controllen, 604717205eccSRandall Stewart (struct sctp_sndrcvinfo *)&sinfo); 604817205eccSRandall Stewart } 604917205eccSRandall Stewart if (name) { 605017205eccSRandall Stewart /* copy back the address info */ 605117205eccSRandall Stewart if (from && from->sa_len) { 605217205eccSRandall Stewart *name = sodupsockaddr(from, M_WAIT); 605317205eccSRandall Stewart } else { 605417205eccSRandall Stewart *name = NULL; 605517205eccSRandall Stewart } 605617205eccSRandall Stewart } 605717205eccSRandall Stewart return (error); 605817205eccSRandall Stewart } 605917205eccSRandall Stewart 606017205eccSRandall Stewart 606117205eccSRandall Stewart 606217205eccSRandall Stewart 606317205eccSRandall Stewart 606417205eccSRandall Stewart 606517205eccSRandall Stewart 606617205eccSRandall Stewart int 6067d61a0ae0SRandall Stewart sctp_connectx_helper_add(struct sctp_tcb *stcb, struct sockaddr *addr, 6068d61a0ae0SRandall Stewart int totaddr, int *error) 606917205eccSRandall Stewart { 607017205eccSRandall Stewart int added = 0; 607117205eccSRandall Stewart int i; 607217205eccSRandall Stewart struct sctp_inpcb *inp; 607317205eccSRandall Stewart struct sockaddr *sa; 607417205eccSRandall Stewart size_t incr = 0; 607517205eccSRandall Stewart 607617205eccSRandall Stewart sa = addr; 607717205eccSRandall Stewart inp = stcb->sctp_ep; 607817205eccSRandall Stewart *error = 0; 607917205eccSRandall Stewart for (i = 0; i < totaddr; i++) { 608017205eccSRandall Stewart if (sa->sa_family == AF_INET) { 608117205eccSRandall Stewart incr = sizeof(struct sockaddr_in); 608217205eccSRandall Stewart if (sctp_add_remote_addr(stcb, sa, SCTP_DONOT_SETSCOPE, SCTP_ADDR_IS_CONFIRMED)) { 608317205eccSRandall Stewart /* assoc gone no un-lock */ 6084c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTPUTIL, ENOBUFS); 6085c4739e2fSRandall Stewart (void)sctp_free_assoc(inp, stcb, SCTP_NORMAL_PROC, SCTP_FROM_SCTP_USRREQ + SCTP_LOC_7); 608617205eccSRandall Stewart *error = ENOBUFS; 608717205eccSRandall Stewart goto out_now; 608817205eccSRandall Stewart } 608917205eccSRandall Stewart added++; 609017205eccSRandall Stewart } else if (sa->sa_family == AF_INET6) { 609117205eccSRandall Stewart incr = sizeof(struct sockaddr_in6); 609217205eccSRandall Stewart if (sctp_add_remote_addr(stcb, sa, SCTP_DONOT_SETSCOPE, SCTP_ADDR_IS_CONFIRMED)) { 609317205eccSRandall Stewart /* assoc gone no un-lock */ 6094c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTPUTIL, ENOBUFS); 6095c4739e2fSRandall Stewart (void)sctp_free_assoc(inp, stcb, SCTP_NORMAL_PROC, SCTP_FROM_SCTP_USRREQ + SCTP_LOC_8); 609617205eccSRandall Stewart *error = ENOBUFS; 609717205eccSRandall Stewart goto out_now; 609817205eccSRandall Stewart } 609917205eccSRandall Stewart added++; 610017205eccSRandall Stewart } 610117205eccSRandall Stewart sa = (struct sockaddr *)((caddr_t)sa + incr); 610217205eccSRandall Stewart } 610317205eccSRandall Stewart out_now: 610417205eccSRandall Stewart return (added); 610517205eccSRandall Stewart } 610617205eccSRandall Stewart 610717205eccSRandall Stewart struct sctp_tcb * 6108d61a0ae0SRandall Stewart sctp_connectx_helper_find(struct sctp_inpcb *inp, struct sockaddr *addr, 6109d61a0ae0SRandall Stewart int *totaddr, int *num_v4, int *num_v6, int *error, 6110d61a0ae0SRandall Stewart int limit, int *bad_addr) 611117205eccSRandall Stewart { 611217205eccSRandall Stewart struct sockaddr *sa; 611317205eccSRandall Stewart struct sctp_tcb *stcb = NULL; 611417205eccSRandall Stewart size_t incr, at, i; 611517205eccSRandall Stewart 611617205eccSRandall Stewart at = incr = 0; 611717205eccSRandall Stewart sa = addr; 611817205eccSRandall Stewart *error = *num_v6 = *num_v4 = 0; 611917205eccSRandall Stewart /* account and validate addresses */ 61204c9179adSRandall Stewart for (i = 0; i < (size_t)*totaddr; i++) { 612117205eccSRandall Stewart if (sa->sa_family == AF_INET) { 612217205eccSRandall Stewart (*num_v4) += 1; 612317205eccSRandall Stewart incr = sizeof(struct sockaddr_in); 6124d61a0ae0SRandall Stewart if (sa->sa_len != incr) { 6125c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL); 6126d61a0ae0SRandall Stewart *error = EINVAL; 6127d61a0ae0SRandall Stewart *bad_addr = 1; 6128d61a0ae0SRandall Stewart return (NULL); 6129d61a0ae0SRandall Stewart } 613017205eccSRandall Stewart } else if (sa->sa_family == AF_INET6) { 613117205eccSRandall Stewart struct sockaddr_in6 *sin6; 613217205eccSRandall Stewart 613317205eccSRandall Stewart sin6 = (struct sockaddr_in6 *)sa; 613417205eccSRandall Stewart if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) { 613517205eccSRandall Stewart /* Must be non-mapped for connectx */ 6136c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL); 613717205eccSRandall Stewart *error = EINVAL; 6138d61a0ae0SRandall Stewart *bad_addr = 1; 613917205eccSRandall Stewart return (NULL); 614017205eccSRandall Stewart } 614117205eccSRandall Stewart (*num_v6) += 1; 614217205eccSRandall Stewart incr = sizeof(struct sockaddr_in6); 6143d61a0ae0SRandall Stewart if (sa->sa_len != incr) { 6144c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL); 6145d61a0ae0SRandall Stewart *error = EINVAL; 6146d61a0ae0SRandall Stewart *bad_addr = 1; 6147d61a0ae0SRandall Stewart return (NULL); 6148d61a0ae0SRandall Stewart } 614917205eccSRandall Stewart } else { 615017205eccSRandall Stewart *totaddr = i; 615117205eccSRandall Stewart /* we are done */ 615217205eccSRandall Stewart break; 615317205eccSRandall Stewart } 6154d61a0ae0SRandall Stewart SCTP_INP_INCR_REF(inp); 615517205eccSRandall Stewart stcb = sctp_findassociation_ep_addr(&inp, sa, NULL, NULL, NULL); 615617205eccSRandall Stewart if (stcb != NULL) { 615717205eccSRandall Stewart /* Already have or am bring up an association */ 615817205eccSRandall Stewart return (stcb); 6159d61a0ae0SRandall Stewart } else { 6160d61a0ae0SRandall Stewart SCTP_INP_DECR_REF(inp); 616117205eccSRandall Stewart } 61624c9179adSRandall Stewart if ((at + incr) > (size_t)limit) { 616317205eccSRandall Stewart *totaddr = i; 616417205eccSRandall Stewart break; 616517205eccSRandall Stewart } 616617205eccSRandall Stewart sa = (struct sockaddr *)((caddr_t)sa + incr); 616717205eccSRandall Stewart } 616817205eccSRandall Stewart return ((struct sctp_tcb *)NULL); 616917205eccSRandall Stewart } 617035918f85SRandall Stewart 617135918f85SRandall Stewart /* 617235918f85SRandall Stewart * sctp_bindx(ADD) for one address. 617335918f85SRandall Stewart * assumes all arguments are valid/checked by caller. 617435918f85SRandall Stewart */ 617535918f85SRandall Stewart void 617635918f85SRandall Stewart sctp_bindx_add_address(struct socket *so, struct sctp_inpcb *inp, 617735918f85SRandall Stewart struct sockaddr *sa, sctp_assoc_t assoc_id, 617835918f85SRandall Stewart uint32_t vrf_id, int *error, void *p) 617935918f85SRandall Stewart { 618035918f85SRandall Stewart struct sockaddr *addr_touse; 618135918f85SRandall Stewart struct sockaddr_in sin; 618235918f85SRandall Stewart 618335918f85SRandall Stewart /* see if we're bound all already! */ 618435918f85SRandall Stewart if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) { 6185c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL); 618635918f85SRandall Stewart *error = EINVAL; 618735918f85SRandall Stewart return; 618835918f85SRandall Stewart } 618935918f85SRandall Stewart addr_touse = sa; 619035918f85SRandall Stewart #if defined(INET6) 619135918f85SRandall Stewart if (sa->sa_family == AF_INET6) { 619235918f85SRandall Stewart struct sockaddr_in6 *sin6; 619335918f85SRandall Stewart 619435918f85SRandall Stewart if (sa->sa_len != sizeof(struct sockaddr_in6)) { 6195c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL); 619635918f85SRandall Stewart *error = EINVAL; 619735918f85SRandall Stewart return; 619835918f85SRandall Stewart } 6199db4fd95bSRandall Stewart if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) == 0) { 6200db4fd95bSRandall Stewart /* can only bind v6 on PF_INET6 sockets */ 6201c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL); 6202db4fd95bSRandall Stewart *error = EINVAL; 6203db4fd95bSRandall Stewart return; 6204db4fd95bSRandall Stewart } 620535918f85SRandall Stewart sin6 = (struct sockaddr_in6 *)addr_touse; 620635918f85SRandall Stewart if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) { 6207db4fd95bSRandall Stewart if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) && 6208db4fd95bSRandall Stewart SCTP_IPV6_V6ONLY(inp)) { 6209db4fd95bSRandall Stewart /* can't bind v4-mapped on PF_INET sockets */ 6210c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL); 6211db4fd95bSRandall Stewart *error = EINVAL; 6212db4fd95bSRandall Stewart return; 6213db4fd95bSRandall Stewart } 621435918f85SRandall Stewart in6_sin6_2_sin(&sin, sin6); 621535918f85SRandall Stewart addr_touse = (struct sockaddr *)&sin; 621635918f85SRandall Stewart } 621735918f85SRandall Stewart } 621835918f85SRandall Stewart #endif 621935918f85SRandall Stewart if (sa->sa_family == AF_INET) { 622035918f85SRandall Stewart if (sa->sa_len != sizeof(struct sockaddr_in)) { 6221c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL); 622235918f85SRandall Stewart *error = EINVAL; 622335918f85SRandall Stewart return; 622435918f85SRandall Stewart } 6225db4fd95bSRandall Stewart if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) && 6226db4fd95bSRandall Stewart SCTP_IPV6_V6ONLY(inp)) { 6227db4fd95bSRandall Stewart /* can't bind v4 on PF_INET sockets */ 6228c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL); 6229db4fd95bSRandall Stewart *error = EINVAL; 6230db4fd95bSRandall Stewart return; 6231db4fd95bSRandall Stewart } 623235918f85SRandall Stewart } 623335918f85SRandall Stewart if (inp->sctp_flags & SCTP_PCB_FLAGS_UNBOUND) { 623435918f85SRandall Stewart if (p == NULL) { 623535918f85SRandall Stewart /* Can't get proc for Net/Open BSD */ 6236c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL); 623735918f85SRandall Stewart *error = EINVAL; 623835918f85SRandall Stewart return; 623935918f85SRandall Stewart } 62401b649582SRandall Stewart *error = sctp_inpcb_bind(so, addr_touse, NULL, p); 624135918f85SRandall Stewart return; 624235918f85SRandall Stewart } 624335918f85SRandall Stewart /* 624435918f85SRandall Stewart * No locks required here since bind and mgmt_ep_sa all do their own 624535918f85SRandall Stewart * locking. If we do something for the FIX: below we may need to 624635918f85SRandall Stewart * lock in that case. 624735918f85SRandall Stewart */ 624835918f85SRandall Stewart if (assoc_id == 0) { 624935918f85SRandall Stewart /* add the address */ 625035918f85SRandall Stewart struct sctp_inpcb *lep; 625197c76f10SRandall Stewart struct sockaddr_in *lsin = (struct sockaddr_in *)addr_touse; 625235918f85SRandall Stewart 625397c76f10SRandall Stewart /* validate the incoming port */ 625497c76f10SRandall Stewart if ((lsin->sin_port != 0) && 625597c76f10SRandall Stewart (lsin->sin_port != inp->sctp_lport)) { 6256c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL); 625797c76f10SRandall Stewart *error = EINVAL; 625897c76f10SRandall Stewart return; 625997c76f10SRandall Stewart } else { 626097c76f10SRandall Stewart /* user specified 0 port, set it to existing port */ 626197c76f10SRandall Stewart lsin->sin_port = inp->sctp_lport; 626297c76f10SRandall Stewart } 626397c76f10SRandall Stewart 626435918f85SRandall Stewart lep = sctp_pcb_findep(addr_touse, 1, 0, vrf_id); 626535918f85SRandall Stewart if (lep != NULL) { 626635918f85SRandall Stewart /* 626735918f85SRandall Stewart * We must decrement the refcount since we have the 626835918f85SRandall Stewart * ep already and are binding. No remove going on 626935918f85SRandall Stewart * here. 627035918f85SRandall Stewart */ 627135918f85SRandall Stewart SCTP_INP_DECR_REF(inp); 627235918f85SRandall Stewart } 627335918f85SRandall Stewart if (lep == inp) { 627435918f85SRandall Stewart /* already bound to it.. ok */ 627535918f85SRandall Stewart return; 627635918f85SRandall Stewart } else if (lep == NULL) { 627735918f85SRandall Stewart ((struct sockaddr_in *)addr_touse)->sin_port = 0; 627835918f85SRandall Stewart *error = sctp_addr_mgmt_ep_sa(inp, addr_touse, 627935918f85SRandall Stewart SCTP_ADD_IP_ADDRESS, 628080fefe0aSRandall Stewart vrf_id, NULL); 628135918f85SRandall Stewart } else { 628235918f85SRandall Stewart *error = EADDRINUSE; 628335918f85SRandall Stewart } 628435918f85SRandall Stewart if (*error) 628535918f85SRandall Stewart return; 628635918f85SRandall Stewart } else { 628735918f85SRandall Stewart /* 628835918f85SRandall Stewart * FIX: decide whether we allow assoc based bindx 628935918f85SRandall Stewart */ 629035918f85SRandall Stewart } 629135918f85SRandall Stewart } 629235918f85SRandall Stewart 629335918f85SRandall Stewart /* 629435918f85SRandall Stewart * sctp_bindx(DELETE) for one address. 629535918f85SRandall Stewart * assumes all arguments are valid/checked by caller. 629635918f85SRandall Stewart */ 629735918f85SRandall Stewart void 629835918f85SRandall Stewart sctp_bindx_delete_address(struct socket *so, struct sctp_inpcb *inp, 629935918f85SRandall Stewart struct sockaddr *sa, sctp_assoc_t assoc_id, 630035918f85SRandall Stewart uint32_t vrf_id, int *error) 630135918f85SRandall Stewart { 630235918f85SRandall Stewart struct sockaddr *addr_touse; 630335918f85SRandall Stewart struct sockaddr_in sin; 630435918f85SRandall Stewart 630535918f85SRandall Stewart /* see if we're bound all already! */ 630635918f85SRandall Stewart if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) { 6307c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL); 630835918f85SRandall Stewart *error = EINVAL; 630935918f85SRandall Stewart return; 631035918f85SRandall Stewart } 631135918f85SRandall Stewart addr_touse = sa; 631235918f85SRandall Stewart #if defined(INET6) 631335918f85SRandall Stewart if (sa->sa_family == AF_INET6) { 631435918f85SRandall Stewart struct sockaddr_in6 *sin6; 631535918f85SRandall Stewart 631635918f85SRandall Stewart if (sa->sa_len != sizeof(struct sockaddr_in6)) { 6317c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL); 631835918f85SRandall Stewart *error = EINVAL; 631935918f85SRandall Stewart return; 632035918f85SRandall Stewart } 6321db4fd95bSRandall Stewart if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) == 0) { 6322db4fd95bSRandall Stewart /* can only bind v6 on PF_INET6 sockets */ 6323c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL); 6324db4fd95bSRandall Stewart *error = EINVAL; 6325db4fd95bSRandall Stewart return; 6326db4fd95bSRandall Stewart } 632735918f85SRandall Stewart sin6 = (struct sockaddr_in6 *)addr_touse; 632835918f85SRandall Stewart if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) { 6329db4fd95bSRandall Stewart if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) && 6330db4fd95bSRandall Stewart SCTP_IPV6_V6ONLY(inp)) { 6331db4fd95bSRandall Stewart /* can't bind mapped-v4 on PF_INET sockets */ 6332c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL); 6333db4fd95bSRandall Stewart *error = EINVAL; 6334db4fd95bSRandall Stewart return; 6335db4fd95bSRandall Stewart } 633635918f85SRandall Stewart in6_sin6_2_sin(&sin, sin6); 633735918f85SRandall Stewart addr_touse = (struct sockaddr *)&sin; 633835918f85SRandall Stewart } 633935918f85SRandall Stewart } 634035918f85SRandall Stewart #endif 634135918f85SRandall Stewart if (sa->sa_family == AF_INET) { 634235918f85SRandall Stewart if (sa->sa_len != sizeof(struct sockaddr_in)) { 6343c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL); 634435918f85SRandall Stewart *error = EINVAL; 634535918f85SRandall Stewart return; 634635918f85SRandall Stewart } 6347db4fd95bSRandall Stewart if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) && 6348db4fd95bSRandall Stewart SCTP_IPV6_V6ONLY(inp)) { 6349db4fd95bSRandall Stewart /* can't bind v4 on PF_INET sockets */ 6350c4739e2fSRandall Stewart SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL); 6351db4fd95bSRandall Stewart *error = EINVAL; 6352db4fd95bSRandall Stewart return; 6353db4fd95bSRandall Stewart } 635435918f85SRandall Stewart } 635535918f85SRandall Stewart /* 635635918f85SRandall Stewart * No lock required mgmt_ep_sa does its own locking. If the FIX: 635735918f85SRandall Stewart * below is ever changed we may need to lock before calling 635835918f85SRandall Stewart * association level binding. 635935918f85SRandall Stewart */ 636035918f85SRandall Stewart if (assoc_id == 0) { 636135918f85SRandall Stewart /* delete the address */ 636235918f85SRandall Stewart *error = sctp_addr_mgmt_ep_sa(inp, addr_touse, 636335918f85SRandall Stewart SCTP_DEL_IP_ADDRESS, 636480fefe0aSRandall Stewart vrf_id, NULL); 636535918f85SRandall Stewart } else { 636635918f85SRandall Stewart /* 636735918f85SRandall Stewart * FIX: decide whether we allow assoc based bindx 636835918f85SRandall Stewart */ 636935918f85SRandall Stewart } 637035918f85SRandall Stewart } 63711b649582SRandall Stewart 63721b649582SRandall Stewart /* 63731b649582SRandall Stewart * returns the valid local address count for an assoc, taking into account 63741b649582SRandall Stewart * all scoping rules 63751b649582SRandall Stewart */ 63761b649582SRandall Stewart int 63771b649582SRandall Stewart sctp_local_addr_count(struct sctp_tcb *stcb) 63781b649582SRandall Stewart { 63791b649582SRandall Stewart int loopback_scope, ipv4_local_scope, local_scope, site_scope; 63801b649582SRandall Stewart int ipv4_addr_legal, ipv6_addr_legal; 63811b649582SRandall Stewart struct sctp_vrf *vrf; 63821b649582SRandall Stewart struct sctp_ifn *sctp_ifn; 63831b649582SRandall Stewart struct sctp_ifa *sctp_ifa; 63841b649582SRandall Stewart int count = 0; 63851b649582SRandall Stewart 63861b649582SRandall Stewart /* Turn on all the appropriate scopes */ 63871b649582SRandall Stewart loopback_scope = stcb->asoc.loopback_scope; 63881b649582SRandall Stewart ipv4_local_scope = stcb->asoc.ipv4_local_scope; 63891b649582SRandall Stewart local_scope = stcb->asoc.local_scope; 63901b649582SRandall Stewart site_scope = stcb->asoc.site_scope; 63911b649582SRandall Stewart ipv4_addr_legal = ipv6_addr_legal = 0; 63921b649582SRandall Stewart if (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) { 63931b649582SRandall Stewart ipv6_addr_legal = 1; 63941b649582SRandall Stewart if (SCTP_IPV6_V6ONLY(stcb->sctp_ep) == 0) { 63951b649582SRandall Stewart ipv4_addr_legal = 1; 63961b649582SRandall Stewart } 63971b649582SRandall Stewart } else { 63981b649582SRandall Stewart ipv4_addr_legal = 1; 63991b649582SRandall Stewart } 64001b649582SRandall Stewart 6401c99efcf6SRandall Stewart SCTP_IPI_ADDR_RLOCK(); 64021b649582SRandall Stewart vrf = sctp_find_vrf(stcb->asoc.vrf_id); 64031b649582SRandall Stewart if (vrf == NULL) { 64041b649582SRandall Stewart /* no vrf, no addresses */ 6405c99efcf6SRandall Stewart SCTP_IPI_ADDR_RUNLOCK(); 64061b649582SRandall Stewart return (0); 64071b649582SRandall Stewart } 64081b649582SRandall Stewart if (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) { 64091b649582SRandall Stewart /* 64101b649582SRandall Stewart * bound all case: go through all ifns on the vrf 64111b649582SRandall Stewart */ 64121b649582SRandall Stewart LIST_FOREACH(sctp_ifn, &vrf->ifnlist, next_ifn) { 64131b649582SRandall Stewart if ((loopback_scope == 0) && 64141b649582SRandall Stewart SCTP_IFN_IS_IFT_LOOP(sctp_ifn)) { 64151b649582SRandall Stewart continue; 64161b649582SRandall Stewart } 64171b649582SRandall Stewart LIST_FOREACH(sctp_ifa, &sctp_ifn->ifalist, next_ifa) { 64181b649582SRandall Stewart if (sctp_is_addr_restricted(stcb, sctp_ifa)) 64191b649582SRandall Stewart continue; 64201b649582SRandall Stewart 64211b649582SRandall Stewart if ((sctp_ifa->address.sa.sa_family == AF_INET) && 64221b649582SRandall Stewart (ipv4_addr_legal)) { 64231b649582SRandall Stewart struct sockaddr_in *sin; 64241b649582SRandall Stewart 64251b649582SRandall Stewart sin = (struct sockaddr_in *)&sctp_ifa->address.sa; 64261b649582SRandall Stewart if (sin->sin_addr.s_addr == 0) { 64271b649582SRandall Stewart /* skip unspecified addrs */ 64281b649582SRandall Stewart continue; 64291b649582SRandall Stewart } 64301b649582SRandall Stewart if ((ipv4_local_scope == 0) && 64311b649582SRandall Stewart (IN4_ISPRIVATE_ADDRESS(&sin->sin_addr))) { 64321b649582SRandall Stewart continue; 64331b649582SRandall Stewart } 64341b649582SRandall Stewart /* count this one */ 64351b649582SRandall Stewart count++; 64361b649582SRandall Stewart } else if ((sctp_ifa->address.sa.sa_family == AF_INET6) && 64371b649582SRandall Stewart (ipv6_addr_legal)) { 64381b649582SRandall Stewart struct sockaddr_in6 *sin6; 64391b649582SRandall Stewart 64401b649582SRandall Stewart sin6 = (struct sockaddr_in6 *)&sctp_ifa->address.sa; 64411b649582SRandall Stewart if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) { 64421b649582SRandall Stewart continue; 64431b649582SRandall Stewart } 64441b649582SRandall Stewart if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr)) { 64451b649582SRandall Stewart if (local_scope == 0) 64461b649582SRandall Stewart continue; 64471b649582SRandall Stewart if (sin6->sin6_scope_id == 0) { 64481b649582SRandall Stewart if (sa6_recoverscope(sin6) != 0) 64491b649582SRandall Stewart /* 64501b649582SRandall Stewart * bad link 64511b649582SRandall Stewart * local 64521b649582SRandall Stewart * address 64531b649582SRandall Stewart */ 64541b649582SRandall Stewart continue; 64551b649582SRandall Stewart } 64561b649582SRandall Stewart } 64571b649582SRandall Stewart if ((site_scope == 0) && 64581b649582SRandall Stewart (IN6_IS_ADDR_SITELOCAL(&sin6->sin6_addr))) { 64591b649582SRandall Stewart continue; 64601b649582SRandall Stewart } 64611b649582SRandall Stewart /* count this one */ 64621b649582SRandall Stewart count++; 64631b649582SRandall Stewart } 64641b649582SRandall Stewart } 64651b649582SRandall Stewart } 64661b649582SRandall Stewart } else { 64671b649582SRandall Stewart /* 64681b649582SRandall Stewart * subset bound case 64691b649582SRandall Stewart */ 64701b649582SRandall Stewart struct sctp_laddr *laddr; 64711b649582SRandall Stewart 64721b649582SRandall Stewart LIST_FOREACH(laddr, &stcb->sctp_ep->sctp_addr_list, 64731b649582SRandall Stewart sctp_nxt_addr) { 64741b649582SRandall Stewart if (sctp_is_addr_restricted(stcb, laddr->ifa)) { 64751b649582SRandall Stewart continue; 64761b649582SRandall Stewart } 64771b649582SRandall Stewart /* count this one */ 64781b649582SRandall Stewart count++; 64791b649582SRandall Stewart } 64801b649582SRandall Stewart } 6481c99efcf6SRandall Stewart SCTP_IPI_ADDR_RUNLOCK(); 64821b649582SRandall Stewart return (count); 64831b649582SRandall Stewart } 6484c4739e2fSRandall Stewart 6485c4739e2fSRandall Stewart #if defined(SCTP_LOCAL_TRACE_BUF) 6486c4739e2fSRandall Stewart 6487c4739e2fSRandall Stewart void 6488b27a6b7dSRandall Stewart sctp_log_trace(uint32_t subsys, const char *str SCTP_UNUSED, uint32_t a, uint32_t b, uint32_t c, uint32_t d, uint32_t e, uint32_t f) 6489c4739e2fSRandall Stewart { 6490b27a6b7dSRandall Stewart uint32_t saveindex, newindex; 6491c4739e2fSRandall Stewart 6492c4739e2fSRandall Stewart do { 6493b27a6b7dSRandall Stewart saveindex = sctp_log.index; 6494c4739e2fSRandall Stewart if (saveindex >= SCTP_MAX_LOGGING_SIZE) { 6495c4739e2fSRandall Stewart newindex = 1; 6496c4739e2fSRandall Stewart } else { 6497c4739e2fSRandall Stewart newindex = saveindex + 1; 6498c4739e2fSRandall Stewart } 6499b27a6b7dSRandall Stewart } while (atomic_cmpset_int(&sctp_log.index, saveindex, newindex) == 0); 6500c4739e2fSRandall Stewart if (saveindex >= SCTP_MAX_LOGGING_SIZE) { 6501c4739e2fSRandall Stewart saveindex = 0; 6502c4739e2fSRandall Stewart } 6503b27a6b7dSRandall Stewart sctp_log.entry[saveindex].timestamp = SCTP_GET_CYCLECOUNT; 6504b27a6b7dSRandall Stewart sctp_log.entry[saveindex].subsys = subsys; 6505b27a6b7dSRandall Stewart sctp_log.entry[saveindex].params[0] = a; 6506b27a6b7dSRandall Stewart sctp_log.entry[saveindex].params[1] = b; 6507b27a6b7dSRandall Stewart sctp_log.entry[saveindex].params[2] = c; 6508b27a6b7dSRandall Stewart sctp_log.entry[saveindex].params[3] = d; 6509b27a6b7dSRandall Stewart sctp_log.entry[saveindex].params[4] = e; 6510b27a6b7dSRandall Stewart sctp_log.entry[saveindex].params[5] = f; 6511c4739e2fSRandall Stewart } 6512c4739e2fSRandall Stewart 6513c4739e2fSRandall Stewart #endif 6514