1f8829a4aSRandall Stewart /*- 242551e99SRandall Stewart * Copyright (c) 2001-2007, 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 31a5d547adSRandall Stewart /* $KAME: sctp_indata.c,v 1.36 2005/03/06 16:04:17 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_var.h> 3842551e99SRandall Stewart #include <netinet/sctp_sysctl.h> 39f8829a4aSRandall Stewart #include <netinet/sctp_pcb.h> 40f8829a4aSRandall Stewart #include <netinet/sctp_header.h> 41f8829a4aSRandall Stewart #include <netinet/sctputil.h> 42f8829a4aSRandall Stewart #include <netinet/sctp_output.h> 43f8829a4aSRandall Stewart #include <netinet/sctp_input.h> 44f8829a4aSRandall Stewart #include <netinet/sctp_indata.h> 45f8829a4aSRandall Stewart #include <netinet/sctp_uio.h> 46f8829a4aSRandall Stewart #include <netinet/sctp_timer.h> 47f8829a4aSRandall Stewart 48f8829a4aSRandall Stewart 49f8829a4aSRandall Stewart /* 50f8829a4aSRandall Stewart * NOTES: On the outbound side of things I need to check the sack timer to 51f8829a4aSRandall Stewart * see if I should generate a sack into the chunk queue (if I have data to 52f8829a4aSRandall Stewart * send that is and will be sending it .. for bundling. 53f8829a4aSRandall Stewart * 54f8829a4aSRandall Stewart * The callback in sctp_usrreq.c will get called when the socket is read from. 55f8829a4aSRandall Stewart * This will cause sctp_service_queues() to get called on the top entry in 56f8829a4aSRandall Stewart * the list. 57f8829a4aSRandall Stewart */ 58f8829a4aSRandall Stewart 59f8829a4aSRandall Stewart __inline void 60f8829a4aSRandall Stewart sctp_set_rwnd(struct sctp_tcb *stcb, struct sctp_association *asoc) 61f8829a4aSRandall Stewart { 62f8829a4aSRandall Stewart uint32_t calc, calc_w_oh; 63f8829a4aSRandall Stewart 64f8829a4aSRandall Stewart /* 65f8829a4aSRandall Stewart * This is really set wrong with respect to a 1-2-m socket. Since 66f8829a4aSRandall Stewart * the sb_cc is the count that everyone as put up. When we re-write 67f8829a4aSRandall Stewart * sctp_soreceive then we will fix this so that ONLY this 68f8829a4aSRandall Stewart * associations data is taken into account. 69f8829a4aSRandall Stewart */ 70f8829a4aSRandall Stewart if (stcb->sctp_socket == NULL) 71f8829a4aSRandall Stewart return; 72f8829a4aSRandall Stewart 73f8829a4aSRandall Stewart if (stcb->asoc.sb_cc == 0 && 74f8829a4aSRandall Stewart asoc->size_on_reasm_queue == 0 && 75f8829a4aSRandall Stewart asoc->size_on_all_streams == 0) { 76f8829a4aSRandall Stewart /* Full rwnd granted */ 7762c1ff9cSRandall Stewart asoc->my_rwnd = max(SCTP_SB_LIMIT_RCV(stcb->sctp_socket), 78f8829a4aSRandall Stewart SCTP_MINIMAL_RWND); 79f8829a4aSRandall Stewart return; 80f8829a4aSRandall Stewart } 81f8829a4aSRandall Stewart /* get actual space */ 82f8829a4aSRandall Stewart calc = (uint32_t) sctp_sbspace(&stcb->asoc, &stcb->sctp_socket->so_rcv); 83f8829a4aSRandall Stewart 84f8829a4aSRandall Stewart /* 85f8829a4aSRandall Stewart * take out what has NOT been put on socket queue and we yet hold 86f8829a4aSRandall Stewart * for putting up. 87f8829a4aSRandall Stewart */ 88f8829a4aSRandall Stewart calc = sctp_sbspace_sub(calc, (uint32_t) asoc->size_on_reasm_queue); 89f8829a4aSRandall Stewart calc = sctp_sbspace_sub(calc, (uint32_t) asoc->size_on_all_streams); 90f8829a4aSRandall Stewart 91f8829a4aSRandall Stewart if (calc == 0) { 92f8829a4aSRandall Stewart /* out of space */ 93f8829a4aSRandall Stewart asoc->my_rwnd = 0; 94f8829a4aSRandall Stewart return; 95f8829a4aSRandall Stewart } 96f8829a4aSRandall Stewart /* what is the overhead of all these rwnd's */ 97f8829a4aSRandall Stewart calc_w_oh = sctp_sbspace_sub(calc, stcb->asoc.my_rwnd_control_len); 98f8829a4aSRandall Stewart asoc->my_rwnd = calc; 99f8829a4aSRandall Stewart if (calc_w_oh == 0) { 100f8829a4aSRandall Stewart /* 101f8829a4aSRandall Stewart * If our overhead is greater than the advertised rwnd, we 102f8829a4aSRandall Stewart * clamp the rwnd to 1. This lets us still accept inbound 103f8829a4aSRandall Stewart * segments, but hopefully will shut the sender down when he 104f8829a4aSRandall Stewart * finally gets the message. 105f8829a4aSRandall Stewart */ 106f8829a4aSRandall Stewart asoc->my_rwnd = 1; 107f8829a4aSRandall Stewart } else { 108f8829a4aSRandall Stewart /* SWS threshold */ 109f8829a4aSRandall Stewart if (asoc->my_rwnd && 110f8829a4aSRandall Stewart (asoc->my_rwnd < stcb->sctp_ep->sctp_ep.sctp_sws_receiver)) { 111f8829a4aSRandall Stewart /* SWS engaged, tell peer none left */ 112f8829a4aSRandall Stewart asoc->my_rwnd = 1; 113f8829a4aSRandall Stewart } 114f8829a4aSRandall Stewart } 115f8829a4aSRandall Stewart } 116f8829a4aSRandall Stewart 117f8829a4aSRandall Stewart /* Calculate what the rwnd would be */ 118f8829a4aSRandall Stewart 119f8829a4aSRandall Stewart __inline uint32_t 120f8829a4aSRandall Stewart sctp_calc_rwnd(struct sctp_tcb *stcb, struct sctp_association *asoc) 121f8829a4aSRandall Stewart { 122f8829a4aSRandall Stewart uint32_t calc = 0, calc_w_oh; 123f8829a4aSRandall Stewart 124f8829a4aSRandall Stewart /* 125f8829a4aSRandall Stewart * This is really set wrong with respect to a 1-2-m socket. Since 126f8829a4aSRandall Stewart * the sb_cc is the count that everyone as put up. When we re-write 127f8829a4aSRandall Stewart * sctp_soreceive then we will fix this so that ONLY this 128f8829a4aSRandall Stewart * associations data is taken into account. 129f8829a4aSRandall Stewart */ 130f8829a4aSRandall Stewart if (stcb->sctp_socket == NULL) 131f8829a4aSRandall Stewart return (calc); 132f8829a4aSRandall Stewart 133f8829a4aSRandall Stewart if (stcb->asoc.sb_cc == 0 && 134f8829a4aSRandall Stewart asoc->size_on_reasm_queue == 0 && 135f8829a4aSRandall Stewart asoc->size_on_all_streams == 0) { 136f8829a4aSRandall Stewart /* Full rwnd granted */ 13762c1ff9cSRandall Stewart calc = max(SCTP_SB_LIMIT_RCV(stcb->sctp_socket), 138f8829a4aSRandall Stewart SCTP_MINIMAL_RWND); 139f8829a4aSRandall Stewart return (calc); 140f8829a4aSRandall Stewart } 141f8829a4aSRandall Stewart /* get actual space */ 142f8829a4aSRandall Stewart calc = (uint32_t) sctp_sbspace(&stcb->asoc, &stcb->sctp_socket->so_rcv); 143f8829a4aSRandall Stewart 144f8829a4aSRandall Stewart /* 145f8829a4aSRandall Stewart * take out what has NOT been put on socket queue and we yet hold 146f8829a4aSRandall Stewart * for putting up. 147f8829a4aSRandall Stewart */ 148f8829a4aSRandall Stewart calc = sctp_sbspace_sub(calc, (uint32_t) asoc->size_on_reasm_queue); 149f8829a4aSRandall Stewart calc = sctp_sbspace_sub(calc, (uint32_t) asoc->size_on_all_streams); 150f8829a4aSRandall Stewart 151f8829a4aSRandall Stewart if (calc == 0) { 152f8829a4aSRandall Stewart /* out of space */ 153f8829a4aSRandall Stewart return (calc); 154f8829a4aSRandall Stewart } 155f8829a4aSRandall Stewart /* what is the overhead of all these rwnd's */ 156f8829a4aSRandall Stewart calc_w_oh = sctp_sbspace_sub(calc, stcb->asoc.my_rwnd_control_len); 157f8829a4aSRandall Stewart if (calc_w_oh == 0) { 158f8829a4aSRandall Stewart /* 159f8829a4aSRandall Stewart * If our overhead is greater than the advertised rwnd, we 160f8829a4aSRandall Stewart * clamp the rwnd to 1. This lets us still accept inbound 161f8829a4aSRandall Stewart * segments, but hopefully will shut the sender down when he 162f8829a4aSRandall Stewart * finally gets the message. 163f8829a4aSRandall Stewart */ 164f8829a4aSRandall Stewart calc = 1; 165f8829a4aSRandall Stewart } else { 166f8829a4aSRandall Stewart /* SWS threshold */ 167f8829a4aSRandall Stewart if (calc && 168f8829a4aSRandall Stewart (calc < stcb->sctp_ep->sctp_ep.sctp_sws_receiver)) { 169f8829a4aSRandall Stewart /* SWS engaged, tell peer none left */ 170f8829a4aSRandall Stewart calc = 1; 171f8829a4aSRandall Stewart } 172f8829a4aSRandall Stewart } 173f8829a4aSRandall Stewart return (calc); 174f8829a4aSRandall Stewart } 175f8829a4aSRandall Stewart 176f8829a4aSRandall Stewart 177f8829a4aSRandall Stewart 178f8829a4aSRandall Stewart /* 179f8829a4aSRandall Stewart * Build out our readq entry based on the incoming packet. 180f8829a4aSRandall Stewart */ 181f8829a4aSRandall Stewart struct sctp_queued_to_read * 182f8829a4aSRandall Stewart sctp_build_readq_entry(struct sctp_tcb *stcb, 183f8829a4aSRandall Stewart struct sctp_nets *net, 184f8829a4aSRandall Stewart uint32_t tsn, uint32_t ppid, 185f8829a4aSRandall Stewart uint32_t context, uint16_t stream_no, 186f8829a4aSRandall Stewart uint16_t stream_seq, uint8_t flags, 187f8829a4aSRandall Stewart struct mbuf *dm) 188f8829a4aSRandall Stewart { 189f8829a4aSRandall Stewart struct sctp_queued_to_read *read_queue_e = NULL; 190f8829a4aSRandall Stewart 191f8829a4aSRandall Stewart sctp_alloc_a_readq(stcb, read_queue_e); 192f8829a4aSRandall Stewart if (read_queue_e == NULL) { 193f8829a4aSRandall Stewart goto failed_build; 194f8829a4aSRandall Stewart } 195f8829a4aSRandall Stewart read_queue_e->sinfo_stream = stream_no; 196f8829a4aSRandall Stewart read_queue_e->sinfo_ssn = stream_seq; 197f8829a4aSRandall Stewart read_queue_e->sinfo_flags = (flags << 8); 198f8829a4aSRandall Stewart read_queue_e->sinfo_ppid = ppid; 199f8829a4aSRandall Stewart read_queue_e->sinfo_context = stcb->asoc.context; 200f8829a4aSRandall Stewart read_queue_e->sinfo_timetolive = 0; 201f8829a4aSRandall Stewart read_queue_e->sinfo_tsn = tsn; 202f8829a4aSRandall Stewart read_queue_e->sinfo_cumtsn = tsn; 203f8829a4aSRandall Stewart read_queue_e->sinfo_assoc_id = sctp_get_associd(stcb); 204f8829a4aSRandall Stewart read_queue_e->whoFrom = net; 205f8829a4aSRandall Stewart read_queue_e->length = 0; 206f8829a4aSRandall Stewart atomic_add_int(&net->ref_count, 1); 207f8829a4aSRandall Stewart read_queue_e->data = dm; 208139bc87fSRandall Stewart read_queue_e->spec_flags = 0; 209f8829a4aSRandall Stewart read_queue_e->tail_mbuf = NULL; 21017205eccSRandall Stewart read_queue_e->aux_data = NULL; 211f8829a4aSRandall Stewart read_queue_e->stcb = stcb; 212f8829a4aSRandall Stewart read_queue_e->port_from = stcb->rport; 213f8829a4aSRandall Stewart read_queue_e->do_not_ref_stcb = 0; 214f8829a4aSRandall Stewart read_queue_e->end_added = 0; 2159a6142d8SRandall Stewart read_queue_e->some_taken = 0; 21603b0b021SRandall Stewart read_queue_e->pdapi_aborted = 0; 217f8829a4aSRandall Stewart failed_build: 218f8829a4aSRandall Stewart return (read_queue_e); 219f8829a4aSRandall Stewart } 220f8829a4aSRandall Stewart 221f8829a4aSRandall Stewart 222f8829a4aSRandall Stewart /* 223f8829a4aSRandall Stewart * Build out our readq entry based on the incoming packet. 224f8829a4aSRandall Stewart */ 225f8829a4aSRandall Stewart static struct sctp_queued_to_read * 226f8829a4aSRandall Stewart sctp_build_readq_entry_chk(struct sctp_tcb *stcb, 227f8829a4aSRandall Stewart struct sctp_tmit_chunk *chk) 228f8829a4aSRandall Stewart { 229f8829a4aSRandall Stewart struct sctp_queued_to_read *read_queue_e = NULL; 230f8829a4aSRandall Stewart 231f8829a4aSRandall Stewart sctp_alloc_a_readq(stcb, read_queue_e); 232f8829a4aSRandall Stewart if (read_queue_e == NULL) { 233f8829a4aSRandall Stewart goto failed_build; 234f8829a4aSRandall Stewart } 235f8829a4aSRandall Stewart read_queue_e->sinfo_stream = chk->rec.data.stream_number; 236f8829a4aSRandall Stewart read_queue_e->sinfo_ssn = chk->rec.data.stream_seq; 237f8829a4aSRandall Stewart read_queue_e->sinfo_flags = (chk->rec.data.rcv_flags << 8); 238f8829a4aSRandall Stewart read_queue_e->sinfo_ppid = chk->rec.data.payloadtype; 239f8829a4aSRandall Stewart read_queue_e->sinfo_context = stcb->asoc.context; 240f8829a4aSRandall Stewart read_queue_e->sinfo_timetolive = 0; 241f8829a4aSRandall Stewart read_queue_e->sinfo_tsn = chk->rec.data.TSN_seq; 242f8829a4aSRandall Stewart read_queue_e->sinfo_cumtsn = chk->rec.data.TSN_seq; 243f8829a4aSRandall Stewart read_queue_e->sinfo_assoc_id = sctp_get_associd(stcb); 244f8829a4aSRandall Stewart read_queue_e->whoFrom = chk->whoTo; 24517205eccSRandall Stewart read_queue_e->aux_data = NULL; 246f8829a4aSRandall Stewart read_queue_e->length = 0; 247f8829a4aSRandall Stewart atomic_add_int(&chk->whoTo->ref_count, 1); 248f8829a4aSRandall Stewart read_queue_e->data = chk->data; 249f8829a4aSRandall Stewart read_queue_e->tail_mbuf = NULL; 250f8829a4aSRandall Stewart read_queue_e->stcb = stcb; 251f8829a4aSRandall Stewart read_queue_e->port_from = stcb->rport; 252139bc87fSRandall Stewart read_queue_e->spec_flags = 0; 253f8829a4aSRandall Stewart read_queue_e->do_not_ref_stcb = 0; 254f8829a4aSRandall Stewart read_queue_e->end_added = 0; 2559a6142d8SRandall Stewart read_queue_e->some_taken = 0; 25603b0b021SRandall Stewart read_queue_e->pdapi_aborted = 0; 257f8829a4aSRandall Stewart failed_build: 258f8829a4aSRandall Stewart return (read_queue_e); 259f8829a4aSRandall Stewart } 260f8829a4aSRandall Stewart 261f8829a4aSRandall Stewart 262f8829a4aSRandall Stewart struct mbuf * 263f8829a4aSRandall Stewart sctp_build_ctl_nchunk(struct sctp_inpcb *inp, 264f8829a4aSRandall Stewart struct sctp_sndrcvinfo *sinfo) 265f8829a4aSRandall Stewart { 266f8829a4aSRandall Stewart struct sctp_sndrcvinfo *outinfo; 267f8829a4aSRandall Stewart struct cmsghdr *cmh; 268f8829a4aSRandall Stewart struct mbuf *ret; 269f8829a4aSRandall Stewart int len; 270f8829a4aSRandall Stewart int use_extended = 0; 271f8829a4aSRandall Stewart 272f8829a4aSRandall Stewart if (sctp_is_feature_off(inp, SCTP_PCB_FLAGS_RECVDATAIOEVNT)) { 273f8829a4aSRandall Stewart /* user does not want the sndrcv ctl */ 274f8829a4aSRandall Stewart return (NULL); 275f8829a4aSRandall Stewart } 276f8829a4aSRandall Stewart if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_EXT_RCVINFO)) { 277f8829a4aSRandall Stewart use_extended = 1; 278f8829a4aSRandall Stewart len = CMSG_LEN(sizeof(struct sctp_extrcvinfo)); 279f8829a4aSRandall Stewart } else { 280f8829a4aSRandall Stewart len = CMSG_LEN(sizeof(struct sctp_sndrcvinfo)); 281f8829a4aSRandall Stewart } 282f8829a4aSRandall Stewart 283f8829a4aSRandall Stewart 284f8829a4aSRandall Stewart ret = sctp_get_mbuf_for_msg(len, 285139bc87fSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 286f8829a4aSRandall Stewart 287f8829a4aSRandall Stewart if (ret == NULL) { 288f8829a4aSRandall Stewart /* No space */ 289f8829a4aSRandall Stewart return (ret); 290f8829a4aSRandall Stewart } 291f8829a4aSRandall Stewart /* We need a CMSG header followed by the struct */ 292f8829a4aSRandall Stewart cmh = mtod(ret, struct cmsghdr *); 293f8829a4aSRandall Stewart outinfo = (struct sctp_sndrcvinfo *)CMSG_DATA(cmh); 294f8829a4aSRandall Stewart cmh->cmsg_level = IPPROTO_SCTP; 295f8829a4aSRandall Stewart if (use_extended) { 296f8829a4aSRandall Stewart cmh->cmsg_type = SCTP_EXTRCV; 297f8829a4aSRandall Stewart cmh->cmsg_len = len; 298f8829a4aSRandall Stewart memcpy(outinfo, sinfo, len); 299f8829a4aSRandall Stewart } else { 300f8829a4aSRandall Stewart cmh->cmsg_type = SCTP_SNDRCV; 301f8829a4aSRandall Stewart cmh->cmsg_len = len; 302f8829a4aSRandall Stewart *outinfo = *sinfo; 303f8829a4aSRandall Stewart } 304139bc87fSRandall Stewart SCTP_BUF_LEN(ret) = cmh->cmsg_len; 305f8829a4aSRandall Stewart return (ret); 306f8829a4aSRandall Stewart } 307f8829a4aSRandall Stewart 308139bc87fSRandall Stewart 30917205eccSRandall Stewart char * 31017205eccSRandall Stewart sctp_build_ctl_cchunk(struct sctp_inpcb *inp, 31117205eccSRandall Stewart int *control_len, 31217205eccSRandall Stewart struct sctp_sndrcvinfo *sinfo) 31317205eccSRandall Stewart { 31417205eccSRandall Stewart struct sctp_sndrcvinfo *outinfo; 31517205eccSRandall Stewart struct cmsghdr *cmh; 31617205eccSRandall Stewart char *buf; 31717205eccSRandall Stewart int len; 31817205eccSRandall Stewart int use_extended = 0; 31917205eccSRandall Stewart 32017205eccSRandall Stewart if (sctp_is_feature_off(inp, SCTP_PCB_FLAGS_RECVDATAIOEVNT)) { 32117205eccSRandall Stewart /* user does not want the sndrcv ctl */ 32217205eccSRandall Stewart return (NULL); 32317205eccSRandall Stewart } 32417205eccSRandall Stewart if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_EXT_RCVINFO)) { 32517205eccSRandall Stewart use_extended = 1; 32617205eccSRandall Stewart len = CMSG_LEN(sizeof(struct sctp_extrcvinfo)); 32717205eccSRandall Stewart } else { 32817205eccSRandall Stewart len = CMSG_LEN(sizeof(struct sctp_sndrcvinfo)); 32917205eccSRandall Stewart } 33017205eccSRandall Stewart SCTP_MALLOC(buf, char *, len, "SCTP_CMSG"); 33117205eccSRandall Stewart if (buf == NULL) { 33217205eccSRandall Stewart /* No space */ 33317205eccSRandall Stewart return (buf); 33417205eccSRandall Stewart } 33517205eccSRandall Stewart /* We need a CMSG header followed by the struct */ 33617205eccSRandall Stewart cmh = (struct cmsghdr *)buf; 33717205eccSRandall Stewart outinfo = (struct sctp_sndrcvinfo *)CMSG_DATA(cmh); 33817205eccSRandall Stewart cmh->cmsg_level = IPPROTO_SCTP; 33917205eccSRandall Stewart if (use_extended) { 34017205eccSRandall Stewart cmh->cmsg_type = SCTP_EXTRCV; 34117205eccSRandall Stewart cmh->cmsg_len = len; 34217205eccSRandall Stewart memcpy(outinfo, sinfo, len); 34317205eccSRandall Stewart } else { 34417205eccSRandall Stewart cmh->cmsg_type = SCTP_SNDRCV; 34517205eccSRandall Stewart cmh->cmsg_len = len; 34617205eccSRandall Stewart *outinfo = *sinfo; 34717205eccSRandall Stewart } 34817205eccSRandall Stewart *control_len = len; 34917205eccSRandall Stewart return (buf); 35017205eccSRandall Stewart } 35117205eccSRandall Stewart 35217205eccSRandall Stewart 353f8829a4aSRandall Stewart /* 354f8829a4aSRandall Stewart * We are delivering currently from the reassembly queue. We must continue to 355f8829a4aSRandall Stewart * deliver until we either: 1) run out of space. 2) run out of sequential 356f8829a4aSRandall Stewart * TSN's 3) hit the SCTP_DATA_LAST_FRAG flag. 357f8829a4aSRandall Stewart */ 358f8829a4aSRandall Stewart static void 359f8829a4aSRandall Stewart sctp_service_reassembly(struct sctp_tcb *stcb, struct sctp_association *asoc) 360f8829a4aSRandall Stewart { 361f8829a4aSRandall Stewart struct sctp_tmit_chunk *chk; 362f8829a4aSRandall Stewart uint16_t nxt_todel; 363f8829a4aSRandall Stewart uint16_t stream_no; 364f8829a4aSRandall Stewart int end = 0; 365f8829a4aSRandall Stewart int cntDel; 366f8829a4aSRandall Stewart struct sctp_queued_to_read *control, *ctl, *ctlat; 367f8829a4aSRandall Stewart 368f42a358aSRandall Stewart cntDel = stream_no = 0; 369f42a358aSRandall Stewart if (stcb && 370f42a358aSRandall Stewart ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) || 371f42a358aSRandall Stewart (stcb->asoc.state & SCTP_STATE_CLOSED_SOCKET))) { 372f8829a4aSRandall Stewart /* socket above is long gone */ 373f8829a4aSRandall Stewart asoc->fragmented_delivery_inprogress = 0; 374f8829a4aSRandall Stewart chk = TAILQ_FIRST(&asoc->reasmqueue); 375f8829a4aSRandall Stewart while (chk) { 376f8829a4aSRandall Stewart TAILQ_REMOVE(&asoc->reasmqueue, chk, sctp_next); 377f8829a4aSRandall Stewart asoc->size_on_reasm_queue -= chk->send_size; 378f8829a4aSRandall Stewart sctp_ucount_decr(asoc->cnt_on_reasm_queue); 379f8829a4aSRandall Stewart /* 380f8829a4aSRandall Stewart * Lose the data pointer, since its in the socket 381f8829a4aSRandall Stewart * buffer 382f8829a4aSRandall Stewart */ 383f8829a4aSRandall Stewart if (chk->data) { 384f8829a4aSRandall Stewart sctp_m_freem(chk->data); 385f8829a4aSRandall Stewart chk->data = NULL; 386f8829a4aSRandall Stewart } 387f8829a4aSRandall Stewart /* Now free the address and data */ 388f8829a4aSRandall Stewart sctp_free_remote_addr(chk->whoTo); 389f8829a4aSRandall Stewart sctp_free_a_chunk(stcb, chk); 390f8829a4aSRandall Stewart chk = TAILQ_FIRST(&asoc->reasmqueue); 391f8829a4aSRandall Stewart } 392f8829a4aSRandall Stewart return; 393f8829a4aSRandall Stewart } 394f8829a4aSRandall Stewart SCTP_TCB_LOCK_ASSERT(stcb); 395f8829a4aSRandall Stewart do { 396f8829a4aSRandall Stewart chk = TAILQ_FIRST(&asoc->reasmqueue); 397f8829a4aSRandall Stewart if (chk == NULL) { 398f8829a4aSRandall Stewart return; 399f8829a4aSRandall Stewart } 400f8829a4aSRandall Stewart if (chk->rec.data.TSN_seq != (asoc->tsn_last_delivered + 1)) { 401f8829a4aSRandall Stewart /* Can't deliver more :< */ 402f8829a4aSRandall Stewart return; 403f8829a4aSRandall Stewart } 404f8829a4aSRandall Stewart stream_no = chk->rec.data.stream_number; 405f8829a4aSRandall Stewart nxt_todel = asoc->strmin[stream_no].last_sequence_delivered + 1; 406f8829a4aSRandall Stewart if (nxt_todel != chk->rec.data.stream_seq && 407f8829a4aSRandall Stewart (chk->rec.data.rcv_flags & SCTP_DATA_UNORDERED) == 0) { 408f8829a4aSRandall Stewart /* 409f8829a4aSRandall Stewart * Not the next sequence to deliver in its stream OR 410f8829a4aSRandall Stewart * unordered 411f8829a4aSRandall Stewart */ 412f8829a4aSRandall Stewart return; 413f8829a4aSRandall Stewart } 414f8829a4aSRandall Stewart if (chk->rec.data.rcv_flags & SCTP_DATA_FIRST_FRAG) { 415f8829a4aSRandall Stewart 416f8829a4aSRandall Stewart control = sctp_build_readq_entry_chk(stcb, chk); 417f8829a4aSRandall Stewart if (control == NULL) { 418f8829a4aSRandall Stewart /* out of memory? */ 419f8829a4aSRandall Stewart return; 420f8829a4aSRandall Stewart } 421f8829a4aSRandall Stewart /* save it off for our future deliveries */ 422f8829a4aSRandall Stewart stcb->asoc.control_pdapi = control; 423f8829a4aSRandall Stewart if (chk->rec.data.rcv_flags & SCTP_DATA_LAST_FRAG) 424f8829a4aSRandall Stewart end = 1; 425f8829a4aSRandall Stewart else 426f8829a4aSRandall Stewart end = 0; 427f8829a4aSRandall Stewart sctp_add_to_readq(stcb->sctp_ep, 428f8829a4aSRandall Stewart stcb, control, &stcb->sctp_socket->so_rcv, end); 429f8829a4aSRandall Stewart cntDel++; 430f8829a4aSRandall Stewart } else { 431f8829a4aSRandall Stewart if (chk->rec.data.rcv_flags & SCTP_DATA_LAST_FRAG) 432f8829a4aSRandall Stewart end = 1; 433f8829a4aSRandall Stewart else 434f8829a4aSRandall Stewart end = 0; 435f8829a4aSRandall Stewart if (sctp_append_to_readq(stcb->sctp_ep, stcb, 436f8829a4aSRandall Stewart stcb->asoc.control_pdapi, 437f8829a4aSRandall Stewart chk->data, end, chk->rec.data.TSN_seq, 438f8829a4aSRandall Stewart &stcb->sctp_socket->so_rcv)) { 439f8829a4aSRandall Stewart /* 440f8829a4aSRandall Stewart * something is very wrong, either 441f8829a4aSRandall Stewart * control_pdapi is NULL, or the tail_mbuf 442f8829a4aSRandall Stewart * is corrupt, or there is a EOM already on 443f8829a4aSRandall Stewart * the mbuf chain. 444f8829a4aSRandall Stewart */ 445f8829a4aSRandall Stewart if (stcb->asoc.control_pdapi == NULL) { 446f8829a4aSRandall Stewart panic("This should not happen control_pdapi NULL?"); 447f8829a4aSRandall Stewart } 448f8829a4aSRandall Stewart if (stcb->asoc.control_pdapi->tail_mbuf == NULL) { 449f8829a4aSRandall Stewart panic("This should not happen, tail_mbuf not being maintained?"); 450f8829a4aSRandall Stewart } 451f8829a4aSRandall Stewart /* if we did not panic, it was a EOM */ 452f8829a4aSRandall Stewart panic("Bad chunking ??"); 453f8829a4aSRandall Stewart } 454f8829a4aSRandall Stewart cntDel++; 455f8829a4aSRandall Stewart } 456f8829a4aSRandall Stewart /* pull it we did it */ 457f8829a4aSRandall Stewart TAILQ_REMOVE(&asoc->reasmqueue, chk, sctp_next); 458f8829a4aSRandall Stewart if (chk->rec.data.rcv_flags & SCTP_DATA_LAST_FRAG) { 459f8829a4aSRandall Stewart asoc->fragmented_delivery_inprogress = 0; 460f8829a4aSRandall Stewart if ((chk->rec.data.rcv_flags & SCTP_DATA_UNORDERED) == 0) { 461f8829a4aSRandall Stewart asoc->strmin[stream_no].last_sequence_delivered++; 462f8829a4aSRandall Stewart } 463f8829a4aSRandall Stewart if ((chk->rec.data.rcv_flags & SCTP_DATA_FIRST_FRAG) == 0) { 464f8829a4aSRandall Stewart SCTP_STAT_INCR_COUNTER64(sctps_reasmusrmsgs); 465f8829a4aSRandall Stewart } 466f8829a4aSRandall Stewart } else if (chk->rec.data.rcv_flags & SCTP_DATA_FIRST_FRAG) { 467f8829a4aSRandall Stewart /* 468f8829a4aSRandall Stewart * turn the flag back on since we just delivered 469f8829a4aSRandall Stewart * yet another one. 470f8829a4aSRandall Stewart */ 471f8829a4aSRandall Stewart asoc->fragmented_delivery_inprogress = 1; 472f8829a4aSRandall Stewart } 473f8829a4aSRandall Stewart asoc->tsn_of_pdapi_last_delivered = chk->rec.data.TSN_seq; 474f8829a4aSRandall Stewart asoc->last_flags_delivered = chk->rec.data.rcv_flags; 475f8829a4aSRandall Stewart asoc->last_strm_seq_delivered = chk->rec.data.stream_seq; 476f8829a4aSRandall Stewart asoc->last_strm_no_delivered = chk->rec.data.stream_number; 477f8829a4aSRandall Stewart 478f8829a4aSRandall Stewart asoc->tsn_last_delivered = chk->rec.data.TSN_seq; 479f8829a4aSRandall Stewart asoc->size_on_reasm_queue -= chk->send_size; 480f8829a4aSRandall Stewart sctp_ucount_decr(asoc->cnt_on_reasm_queue); 481f8829a4aSRandall Stewart /* free up the chk */ 482f8829a4aSRandall Stewart chk->data = NULL; 483f8829a4aSRandall Stewart sctp_free_remote_addr(chk->whoTo); 484f8829a4aSRandall Stewart sctp_free_a_chunk(stcb, chk); 485f8829a4aSRandall Stewart 486f8829a4aSRandall Stewart if (asoc->fragmented_delivery_inprogress == 0) { 487f8829a4aSRandall Stewart /* 488f8829a4aSRandall Stewart * Now lets see if we can deliver the next one on 489f8829a4aSRandall Stewart * the stream 490f8829a4aSRandall Stewart */ 491f8829a4aSRandall Stewart uint16_t nxt_todel; 492f8829a4aSRandall Stewart struct sctp_stream_in *strm; 493f8829a4aSRandall Stewart 494f8829a4aSRandall Stewart strm = &asoc->strmin[stream_no]; 495f8829a4aSRandall Stewart nxt_todel = strm->last_sequence_delivered + 1; 496f8829a4aSRandall Stewart ctl = TAILQ_FIRST(&strm->inqueue); 497f8829a4aSRandall Stewart if (ctl && (nxt_todel == ctl->sinfo_ssn)) { 498f8829a4aSRandall Stewart while (ctl != NULL) { 499f8829a4aSRandall Stewart /* Deliver more if we can. */ 500f8829a4aSRandall Stewart if (nxt_todel == ctl->sinfo_ssn) { 501f8829a4aSRandall Stewart ctlat = TAILQ_NEXT(ctl, next); 502f8829a4aSRandall Stewart TAILQ_REMOVE(&strm->inqueue, ctl, next); 503f8829a4aSRandall Stewart asoc->size_on_all_streams -= ctl->length; 504f8829a4aSRandall Stewart sctp_ucount_decr(asoc->cnt_on_all_streams); 505f8829a4aSRandall Stewart strm->last_sequence_delivered++; 506f8829a4aSRandall Stewart sctp_add_to_readq(stcb->sctp_ep, stcb, 507f8829a4aSRandall Stewart ctl, 508f8829a4aSRandall Stewart &stcb->sctp_socket->so_rcv, 1); 509f8829a4aSRandall Stewart ctl = ctlat; 510f8829a4aSRandall Stewart } else { 511f8829a4aSRandall Stewart break; 512f8829a4aSRandall Stewart } 513f8829a4aSRandall Stewart nxt_todel = strm->last_sequence_delivered + 1; 514f8829a4aSRandall Stewart } 515f8829a4aSRandall Stewart } 516139bc87fSRandall Stewart break; 517f8829a4aSRandall Stewart } 518f8829a4aSRandall Stewart chk = TAILQ_FIRST(&asoc->reasmqueue); 519f8829a4aSRandall Stewart } while (chk); 520f8829a4aSRandall Stewart } 521f8829a4aSRandall Stewart 522f8829a4aSRandall Stewart /* 523f8829a4aSRandall Stewart * Queue the chunk either right into the socket buffer if it is the next one 524f8829a4aSRandall Stewart * to go OR put it in the correct place in the delivery queue. If we do 525f8829a4aSRandall Stewart * append to the so_buf, keep doing so until we are out of order. One big 526f8829a4aSRandall Stewart * question still remains, what to do when the socket buffer is FULL?? 527f8829a4aSRandall Stewart */ 528f8829a4aSRandall Stewart static void 529f8829a4aSRandall Stewart sctp_queue_data_to_stream(struct sctp_tcb *stcb, struct sctp_association *asoc, 530f8829a4aSRandall Stewart struct sctp_queued_to_read *control, int *abort_flag) 531f8829a4aSRandall Stewart { 532f8829a4aSRandall Stewart /* 533f8829a4aSRandall Stewart * FIX-ME maybe? What happens when the ssn wraps? If we are getting 534f8829a4aSRandall Stewart * all the data in one stream this could happen quite rapidly. One 535f8829a4aSRandall Stewart * could use the TSN to keep track of things, but this scheme breaks 536f8829a4aSRandall Stewart * down in the other type of stream useage that could occur. Send a 537f8829a4aSRandall Stewart * single msg to stream 0, send 4Billion messages to stream 1, now 538f8829a4aSRandall Stewart * send a message to stream 0. You have a situation where the TSN 539f8829a4aSRandall Stewart * has wrapped but not in the stream. Is this worth worrying about 540f8829a4aSRandall Stewart * or should we just change our queue sort at the bottom to be by 541f8829a4aSRandall Stewart * TSN. 542f8829a4aSRandall Stewart * 543f8829a4aSRandall Stewart * Could it also be legal for a peer to send ssn 1 with TSN 2 and ssn 2 544f8829a4aSRandall Stewart * with TSN 1? If the peer is doing some sort of funky TSN/SSN 545f8829a4aSRandall Stewart * assignment this could happen... and I don't see how this would be 546f8829a4aSRandall Stewart * a violation. So for now I am undecided an will leave the sort by 547f8829a4aSRandall Stewart * SSN alone. Maybe a hybred approach is the answer 548f8829a4aSRandall Stewart * 549f8829a4aSRandall Stewart */ 550f8829a4aSRandall Stewart struct sctp_stream_in *strm; 551f8829a4aSRandall Stewart struct sctp_queued_to_read *at; 552f8829a4aSRandall Stewart int queue_needed; 553f8829a4aSRandall Stewart uint16_t nxt_todel; 554f8829a4aSRandall Stewart struct mbuf *oper; 555f8829a4aSRandall Stewart 556f8829a4aSRandall Stewart queue_needed = 1; 557f8829a4aSRandall Stewart asoc->size_on_all_streams += control->length; 558f8829a4aSRandall Stewart sctp_ucount_incr(asoc->cnt_on_all_streams); 559f8829a4aSRandall Stewart strm = &asoc->strmin[control->sinfo_stream]; 560f8829a4aSRandall Stewart nxt_todel = strm->last_sequence_delivered + 1; 561f8829a4aSRandall Stewart #ifdef SCTP_STR_LOGGING 562f8829a4aSRandall Stewart sctp_log_strm_del(control, NULL, SCTP_STR_LOG_FROM_INTO_STRD); 563f8829a4aSRandall Stewart #endif 564f8829a4aSRandall Stewart #ifdef SCTP_DEBUG 565f8829a4aSRandall Stewart if (sctp_debug_on & SCTP_DEBUG_INDATA1) { 566f8829a4aSRandall Stewart printf("queue to stream called for ssn:%u lastdel:%u nxt:%u\n", 567f8829a4aSRandall Stewart (uint32_t) control->sinfo_stream, 568f8829a4aSRandall Stewart (uint32_t) strm->last_sequence_delivered, (uint32_t) nxt_todel); 569f8829a4aSRandall Stewart } 570f8829a4aSRandall Stewart #endif 571f8829a4aSRandall Stewart if (compare_with_wrap(strm->last_sequence_delivered, 572f8829a4aSRandall Stewart control->sinfo_ssn, MAX_SEQ) || 573f8829a4aSRandall Stewart (strm->last_sequence_delivered == control->sinfo_ssn)) { 574f8829a4aSRandall Stewart /* The incoming sseq is behind where we last delivered? */ 575f8829a4aSRandall Stewart #ifdef SCTP_DEBUG 576f8829a4aSRandall Stewart if (sctp_debug_on & SCTP_DEBUG_INDATA1) { 577f8829a4aSRandall Stewart printf("Duplicate S-SEQ:%d delivered:%d from peer, Abort association\n", 578f8829a4aSRandall Stewart control->sinfo_ssn, 579f8829a4aSRandall Stewart strm->last_sequence_delivered); 580f8829a4aSRandall Stewart } 581f8829a4aSRandall Stewart #endif 582f8829a4aSRandall Stewart /* 583f8829a4aSRandall Stewart * throw it in the stream so it gets cleaned up in 584f8829a4aSRandall Stewart * association destruction 585f8829a4aSRandall Stewart */ 586f8829a4aSRandall Stewart TAILQ_INSERT_HEAD(&strm->inqueue, control, next); 587139bc87fSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + 3 * sizeof(uint32_t)), 588f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 589f8829a4aSRandall Stewart if (oper) { 590f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 591f8829a4aSRandall Stewart uint32_t *ippp; 592f8829a4aSRandall Stewart 593139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = sizeof(struct sctp_paramhdr) + 594f8829a4aSRandall Stewart (sizeof(uint32_t) * 3); 595f8829a4aSRandall Stewart ph = mtod(oper, struct sctp_paramhdr *); 596f8829a4aSRandall Stewart ph->param_type = htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 597139bc87fSRandall Stewart ph->param_length = htons(SCTP_BUF_LEN(oper)); 598f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 599a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_1); 600f8829a4aSRandall Stewart ippp++; 601f8829a4aSRandall Stewart *ippp = control->sinfo_tsn; 602f8829a4aSRandall Stewart ippp++; 603f8829a4aSRandall Stewart *ippp = ((control->sinfo_stream << 16) | control->sinfo_ssn); 604f8829a4aSRandall Stewart } 605a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_1; 606f8829a4aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, stcb, 607f8829a4aSRandall Stewart SCTP_PEER_FAULTY, oper); 608f8829a4aSRandall Stewart 609f8829a4aSRandall Stewart *abort_flag = 1; 610f8829a4aSRandall Stewart return; 611f8829a4aSRandall Stewart 612f8829a4aSRandall Stewart } 613f8829a4aSRandall Stewart if (nxt_todel == control->sinfo_ssn) { 614f8829a4aSRandall Stewart /* can be delivered right away? */ 615f8829a4aSRandall Stewart #ifdef SCTP_STR_LOGGING 616f8829a4aSRandall Stewart sctp_log_strm_del(control, NULL, SCTP_STR_LOG_FROM_IMMED_DEL); 617f8829a4aSRandall Stewart #endif 618f8829a4aSRandall Stewart queue_needed = 0; 619f8829a4aSRandall Stewart asoc->size_on_all_streams -= control->length; 620f8829a4aSRandall Stewart sctp_ucount_decr(asoc->cnt_on_all_streams); 621f8829a4aSRandall Stewart strm->last_sequence_delivered++; 622f8829a4aSRandall Stewart sctp_add_to_readq(stcb->sctp_ep, stcb, 623f8829a4aSRandall Stewart control, 624f8829a4aSRandall Stewart &stcb->sctp_socket->so_rcv, 1); 625f8829a4aSRandall Stewart control = TAILQ_FIRST(&strm->inqueue); 626f8829a4aSRandall Stewart while (control != NULL) { 627f8829a4aSRandall Stewart /* all delivered */ 628f8829a4aSRandall Stewart nxt_todel = strm->last_sequence_delivered + 1; 629f8829a4aSRandall Stewart if (nxt_todel == control->sinfo_ssn) { 630f8829a4aSRandall Stewart at = TAILQ_NEXT(control, next); 631f8829a4aSRandall Stewart TAILQ_REMOVE(&strm->inqueue, control, next); 632f8829a4aSRandall Stewart asoc->size_on_all_streams -= control->length; 633f8829a4aSRandall Stewart sctp_ucount_decr(asoc->cnt_on_all_streams); 634f8829a4aSRandall Stewart strm->last_sequence_delivered++; 635f8829a4aSRandall Stewart /* 636f8829a4aSRandall Stewart * We ignore the return of deliver_data here 637f8829a4aSRandall Stewart * since we always can hold the chunk on the 638f8829a4aSRandall Stewart * d-queue. And we have a finite number that 639f8829a4aSRandall Stewart * can be delivered from the strq. 640f8829a4aSRandall Stewart */ 641f8829a4aSRandall Stewart #ifdef SCTP_STR_LOGGING 642f8829a4aSRandall Stewart sctp_log_strm_del(control, NULL, 643f8829a4aSRandall Stewart SCTP_STR_LOG_FROM_IMMED_DEL); 644f8829a4aSRandall Stewart #endif 645f8829a4aSRandall Stewart sctp_add_to_readq(stcb->sctp_ep, stcb, 646f8829a4aSRandall Stewart control, 647f8829a4aSRandall Stewart &stcb->sctp_socket->so_rcv, 1); 648f8829a4aSRandall Stewart control = at; 649f8829a4aSRandall Stewart continue; 650f8829a4aSRandall Stewart } 651f8829a4aSRandall Stewart break; 652f8829a4aSRandall Stewart } 653f8829a4aSRandall Stewart } 654f8829a4aSRandall Stewart if (queue_needed) { 655f8829a4aSRandall Stewart /* 656f8829a4aSRandall Stewart * Ok, we did not deliver this guy, find the correct place 657f8829a4aSRandall Stewart * to put it on the queue. 658f8829a4aSRandall Stewart */ 659f8829a4aSRandall Stewart if (TAILQ_EMPTY(&strm->inqueue)) { 660f8829a4aSRandall Stewart /* Empty queue */ 661f8829a4aSRandall Stewart #ifdef SCTP_STR_LOGGING 662f8829a4aSRandall Stewart sctp_log_strm_del(control, NULL, SCTP_STR_LOG_FROM_INSERT_HD); 663f8829a4aSRandall Stewart #endif 664f8829a4aSRandall Stewart TAILQ_INSERT_HEAD(&strm->inqueue, control, next); 665f8829a4aSRandall Stewart } else { 666f8829a4aSRandall Stewart TAILQ_FOREACH(at, &strm->inqueue, next) { 667f8829a4aSRandall Stewart if (compare_with_wrap(at->sinfo_ssn, 668f8829a4aSRandall Stewart control->sinfo_ssn, MAX_SEQ)) { 669f8829a4aSRandall Stewart /* 670f8829a4aSRandall Stewart * one in queue is bigger than the 671f8829a4aSRandall Stewart * new one, insert before this one 672f8829a4aSRandall Stewart */ 673f8829a4aSRandall Stewart #ifdef SCTP_STR_LOGGING 674f8829a4aSRandall Stewart sctp_log_strm_del(control, at, 675f8829a4aSRandall Stewart SCTP_STR_LOG_FROM_INSERT_MD); 676f8829a4aSRandall Stewart #endif 677f8829a4aSRandall Stewart TAILQ_INSERT_BEFORE(at, control, next); 678f8829a4aSRandall Stewart break; 679f8829a4aSRandall Stewart } else if (at->sinfo_ssn == control->sinfo_ssn) { 680f8829a4aSRandall Stewart /* 681f8829a4aSRandall Stewart * Gak, He sent me a duplicate str 682f8829a4aSRandall Stewart * seq number 683f8829a4aSRandall Stewart */ 684f8829a4aSRandall Stewart /* 685f8829a4aSRandall Stewart * foo bar, I guess I will just free 686f8829a4aSRandall Stewart * this new guy, should we abort 687f8829a4aSRandall Stewart * too? FIX ME MAYBE? Or it COULD be 688f8829a4aSRandall Stewart * that the SSN's have wrapped. 689f8829a4aSRandall Stewart * Maybe I should compare to TSN 690f8829a4aSRandall Stewart * somehow... sigh for now just blow 691f8829a4aSRandall Stewart * away the chunk! 692f8829a4aSRandall Stewart */ 693f8829a4aSRandall Stewart 694f8829a4aSRandall Stewart if (control->data) 695f8829a4aSRandall Stewart sctp_m_freem(control->data); 696f8829a4aSRandall Stewart control->data = NULL; 697f8829a4aSRandall Stewart asoc->size_on_all_streams -= control->length; 698f8829a4aSRandall Stewart sctp_ucount_decr(asoc->cnt_on_all_streams); 699f8829a4aSRandall Stewart sctp_free_remote_addr(control->whoFrom); 700f8829a4aSRandall Stewart sctp_free_a_readq(stcb, control); 701f8829a4aSRandall Stewart return; 702f8829a4aSRandall Stewart } else { 703f8829a4aSRandall Stewart if (TAILQ_NEXT(at, next) == NULL) { 704f8829a4aSRandall Stewart /* 705f8829a4aSRandall Stewart * We are at the end, insert 706f8829a4aSRandall Stewart * it after this one 707f8829a4aSRandall Stewart */ 708f8829a4aSRandall Stewart #ifdef SCTP_STR_LOGGING 709f8829a4aSRandall Stewart sctp_log_strm_del(control, at, 710f8829a4aSRandall Stewart SCTP_STR_LOG_FROM_INSERT_TL); 711f8829a4aSRandall Stewart #endif 712f8829a4aSRandall Stewart TAILQ_INSERT_AFTER(&strm->inqueue, 713f8829a4aSRandall Stewart at, control, next); 714f8829a4aSRandall Stewart break; 715f8829a4aSRandall Stewart } 716f8829a4aSRandall Stewart } 717f8829a4aSRandall Stewart } 718f8829a4aSRandall Stewart } 719f8829a4aSRandall Stewart } 720f8829a4aSRandall Stewart } 721f8829a4aSRandall Stewart 722f8829a4aSRandall Stewart /* 723f8829a4aSRandall Stewart * Returns two things: You get the total size of the deliverable parts of the 724f8829a4aSRandall Stewart * first fragmented message on the reassembly queue. And you get a 1 back if 725f8829a4aSRandall Stewart * all of the message is ready or a 0 back if the message is still incomplete 726f8829a4aSRandall Stewart */ 727f8829a4aSRandall Stewart static int 728f8829a4aSRandall Stewart sctp_is_all_msg_on_reasm(struct sctp_association *asoc, uint32_t * t_size) 729f8829a4aSRandall Stewart { 730f8829a4aSRandall Stewart struct sctp_tmit_chunk *chk; 731f8829a4aSRandall Stewart uint32_t tsn; 732f8829a4aSRandall Stewart 733f8829a4aSRandall Stewart *t_size = 0; 734f8829a4aSRandall Stewart chk = TAILQ_FIRST(&asoc->reasmqueue); 735f8829a4aSRandall Stewart if (chk == NULL) { 736f8829a4aSRandall Stewart /* nothing on the queue */ 737f8829a4aSRandall Stewart return (0); 738f8829a4aSRandall Stewart } 739f8829a4aSRandall Stewart if ((chk->rec.data.rcv_flags & SCTP_DATA_FIRST_FRAG) == 0) { 740f8829a4aSRandall Stewart /* Not a first on the queue */ 741f8829a4aSRandall Stewart return (0); 742f8829a4aSRandall Stewart } 743f8829a4aSRandall Stewart tsn = chk->rec.data.TSN_seq; 744f8829a4aSRandall Stewart while (chk) { 745f8829a4aSRandall Stewart if (tsn != chk->rec.data.TSN_seq) { 746f8829a4aSRandall Stewart return (0); 747f8829a4aSRandall Stewart } 748f8829a4aSRandall Stewart *t_size += chk->send_size; 749f8829a4aSRandall Stewart if (chk->rec.data.rcv_flags & SCTP_DATA_LAST_FRAG) { 750f8829a4aSRandall Stewart return (1); 751f8829a4aSRandall Stewart } 752f8829a4aSRandall Stewart tsn++; 753f8829a4aSRandall Stewart chk = TAILQ_NEXT(chk, sctp_next); 754f8829a4aSRandall Stewart } 755f8829a4aSRandall Stewart return (0); 756f8829a4aSRandall Stewart } 757f8829a4aSRandall Stewart 758f8829a4aSRandall Stewart static void 759f8829a4aSRandall Stewart sctp_deliver_reasm_check(struct sctp_tcb *stcb, struct sctp_association *asoc) 760f8829a4aSRandall Stewart { 761f8829a4aSRandall Stewart struct sctp_tmit_chunk *chk; 762f8829a4aSRandall Stewart uint16_t nxt_todel; 763f8829a4aSRandall Stewart uint32_t tsize; 764f8829a4aSRandall Stewart 765139bc87fSRandall Stewart doit_again: 766f8829a4aSRandall Stewart chk = TAILQ_FIRST(&asoc->reasmqueue); 767f8829a4aSRandall Stewart if (chk == NULL) { 768f8829a4aSRandall Stewart /* Huh? */ 769f8829a4aSRandall Stewart asoc->size_on_reasm_queue = 0; 770f8829a4aSRandall Stewart asoc->cnt_on_reasm_queue = 0; 771f8829a4aSRandall Stewart return; 772f8829a4aSRandall Stewart } 773f8829a4aSRandall Stewart if (asoc->fragmented_delivery_inprogress == 0) { 774f8829a4aSRandall Stewart nxt_todel = 775f8829a4aSRandall Stewart asoc->strmin[chk->rec.data.stream_number].last_sequence_delivered + 1; 776f8829a4aSRandall Stewart if ((chk->rec.data.rcv_flags & SCTP_DATA_FIRST_FRAG) && 777f8829a4aSRandall Stewart (nxt_todel == chk->rec.data.stream_seq || 778f8829a4aSRandall Stewart (chk->rec.data.rcv_flags & SCTP_DATA_UNORDERED))) { 779f8829a4aSRandall Stewart /* 780f8829a4aSRandall Stewart * Yep the first one is here and its ok to deliver 781f8829a4aSRandall Stewart * but should we? 782f8829a4aSRandall Stewart */ 783f8829a4aSRandall Stewart if ((sctp_is_all_msg_on_reasm(asoc, &tsize) || 784f8829a4aSRandall Stewart (tsize > stcb->sctp_ep->partial_delivery_point))) { 785f8829a4aSRandall Stewart 786f8829a4aSRandall Stewart /* 787f8829a4aSRandall Stewart * Yes, we setup to start reception, by 788f8829a4aSRandall Stewart * backing down the TSN just in case we 789f8829a4aSRandall Stewart * can't deliver. If we 790f8829a4aSRandall Stewart */ 791f8829a4aSRandall Stewart asoc->fragmented_delivery_inprogress = 1; 792f8829a4aSRandall Stewart asoc->tsn_last_delivered = 793f8829a4aSRandall Stewart chk->rec.data.TSN_seq - 1; 794f8829a4aSRandall Stewart asoc->str_of_pdapi = 795f8829a4aSRandall Stewart chk->rec.data.stream_number; 796f8829a4aSRandall Stewart asoc->ssn_of_pdapi = chk->rec.data.stream_seq; 797f8829a4aSRandall Stewart asoc->pdapi_ppid = chk->rec.data.payloadtype; 798f8829a4aSRandall Stewart asoc->fragment_flags = chk->rec.data.rcv_flags; 799f8829a4aSRandall Stewart sctp_service_reassembly(stcb, asoc); 800f8829a4aSRandall Stewart } 801f8829a4aSRandall Stewart } 802f8829a4aSRandall Stewart } else { 803139bc87fSRandall Stewart /* 804139bc87fSRandall Stewart * Service re-assembly will deliver stream data queued at 805139bc87fSRandall Stewart * the end of fragmented delivery.. but it wont know to go 806139bc87fSRandall Stewart * back and call itself again... we do that here with the 807139bc87fSRandall Stewart * got doit_again 808139bc87fSRandall Stewart */ 809f8829a4aSRandall Stewart sctp_service_reassembly(stcb, asoc); 810139bc87fSRandall Stewart if (asoc->fragmented_delivery_inprogress == 0) { 811139bc87fSRandall Stewart /* 812139bc87fSRandall Stewart * finished our Fragmented delivery, could be more 813139bc87fSRandall Stewart * waiting? 814139bc87fSRandall Stewart */ 815139bc87fSRandall Stewart goto doit_again; 816139bc87fSRandall Stewart } 817f8829a4aSRandall Stewart } 818f8829a4aSRandall Stewart } 819f8829a4aSRandall Stewart 820f8829a4aSRandall Stewart /* 821f8829a4aSRandall Stewart * Dump onto the re-assembly queue, in its proper place. After dumping on the 822f8829a4aSRandall Stewart * queue, see if anthing can be delivered. If so pull it off (or as much as 823f8829a4aSRandall Stewart * we can. If we run out of space then we must dump what we can and set the 824f8829a4aSRandall Stewart * appropriate flag to say we queued what we could. 825f8829a4aSRandall Stewart */ 826f8829a4aSRandall Stewart static void 827f8829a4aSRandall Stewart sctp_queue_data_for_reasm(struct sctp_tcb *stcb, struct sctp_association *asoc, 828f8829a4aSRandall Stewart struct sctp_tmit_chunk *chk, int *abort_flag) 829f8829a4aSRandall Stewart { 830f8829a4aSRandall Stewart struct mbuf *oper; 831f8829a4aSRandall Stewart uint32_t cum_ackp1, last_tsn, prev_tsn, post_tsn; 832f8829a4aSRandall Stewart u_char last_flags; 833f8829a4aSRandall Stewart struct sctp_tmit_chunk *at, *prev, *next; 834f8829a4aSRandall Stewart 835f8829a4aSRandall Stewart prev = next = NULL; 836f8829a4aSRandall Stewart cum_ackp1 = asoc->tsn_last_delivered + 1; 837f8829a4aSRandall Stewart if (TAILQ_EMPTY(&asoc->reasmqueue)) { 838f8829a4aSRandall Stewart /* This is the first one on the queue */ 839f8829a4aSRandall Stewart TAILQ_INSERT_HEAD(&asoc->reasmqueue, chk, sctp_next); 840f8829a4aSRandall Stewart /* 841f8829a4aSRandall Stewart * we do not check for delivery of anything when only one 842f8829a4aSRandall Stewart * fragment is here 843f8829a4aSRandall Stewart */ 844f8829a4aSRandall Stewart asoc->size_on_reasm_queue = chk->send_size; 845f8829a4aSRandall Stewart sctp_ucount_incr(asoc->cnt_on_reasm_queue); 846f8829a4aSRandall Stewart if (chk->rec.data.TSN_seq == cum_ackp1) { 847f8829a4aSRandall Stewart if (asoc->fragmented_delivery_inprogress == 0 && 848f8829a4aSRandall Stewart (chk->rec.data.rcv_flags & SCTP_DATA_FIRST_FRAG) != 849f8829a4aSRandall Stewart SCTP_DATA_FIRST_FRAG) { 850f8829a4aSRandall Stewart /* 851f8829a4aSRandall Stewart * An empty queue, no delivery inprogress, 852f8829a4aSRandall Stewart * we hit the next one and it does NOT have 853f8829a4aSRandall Stewart * a FIRST fragment mark. 854f8829a4aSRandall Stewart */ 855f8829a4aSRandall Stewart #ifdef SCTP_DEBUG 856f8829a4aSRandall Stewart if (sctp_debug_on & SCTP_DEBUG_INDATA1) { 857f8829a4aSRandall Stewart printf("Gak, Evil plot, its not first, no fragmented delivery in progress\n"); 858f8829a4aSRandall Stewart } 859f8829a4aSRandall Stewart #endif 860139bc87fSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + 3 * sizeof(uint32_t)), 861f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 862f8829a4aSRandall Stewart 863f8829a4aSRandall Stewart if (oper) { 864f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 865f8829a4aSRandall Stewart uint32_t *ippp; 866f8829a4aSRandall Stewart 867139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = 868f8829a4aSRandall Stewart sizeof(struct sctp_paramhdr) + 869f8829a4aSRandall Stewart (sizeof(uint32_t) * 3); 870f8829a4aSRandall Stewart ph = mtod(oper, struct sctp_paramhdr *); 871f8829a4aSRandall Stewart ph->param_type = 872f8829a4aSRandall Stewart htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 873139bc87fSRandall Stewart ph->param_length = htons(SCTP_BUF_LEN(oper)); 874f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 875a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_2); 876f8829a4aSRandall Stewart ippp++; 877f8829a4aSRandall Stewart *ippp = chk->rec.data.TSN_seq; 878f8829a4aSRandall Stewart ippp++; 879f8829a4aSRandall Stewart *ippp = ((chk->rec.data.stream_number << 16) | chk->rec.data.stream_seq); 880f8829a4aSRandall Stewart 881f8829a4aSRandall Stewart } 882a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_2; 883f8829a4aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, stcb, 884f8829a4aSRandall Stewart SCTP_PEER_FAULTY, oper); 885f8829a4aSRandall Stewart *abort_flag = 1; 886f8829a4aSRandall Stewart } else if (asoc->fragmented_delivery_inprogress && 887f8829a4aSRandall Stewart (chk->rec.data.rcv_flags & SCTP_DATA_FIRST_FRAG) == SCTP_DATA_FIRST_FRAG) { 888f8829a4aSRandall Stewart /* 889f8829a4aSRandall Stewart * We are doing a partial delivery and the 890f8829a4aSRandall Stewart * NEXT chunk MUST be either the LAST or 891f8829a4aSRandall Stewart * MIDDLE fragment NOT a FIRST 892f8829a4aSRandall Stewart */ 893f8829a4aSRandall Stewart #ifdef SCTP_DEBUG 894f8829a4aSRandall Stewart if (sctp_debug_on & SCTP_DEBUG_INDATA1) { 895f8829a4aSRandall Stewart printf("Gak, Evil plot, it IS a first and fragmented delivery in progress\n"); 896f8829a4aSRandall Stewart } 897f8829a4aSRandall Stewart #endif 898139bc87fSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + 3 * sizeof(uint32_t)), 899f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 900f8829a4aSRandall Stewart if (oper) { 901f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 902f8829a4aSRandall Stewart uint32_t *ippp; 903f8829a4aSRandall Stewart 904139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = 905f8829a4aSRandall Stewart sizeof(struct sctp_paramhdr) + 906f8829a4aSRandall Stewart (3 * sizeof(uint32_t)); 907f8829a4aSRandall Stewart ph = mtod(oper, struct sctp_paramhdr *); 908f8829a4aSRandall Stewart ph->param_type = 909f8829a4aSRandall Stewart htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 910139bc87fSRandall Stewart ph->param_length = htons(SCTP_BUF_LEN(oper)); 911f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 912a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_3); 913f8829a4aSRandall Stewart ippp++; 914f8829a4aSRandall Stewart *ippp = chk->rec.data.TSN_seq; 915f8829a4aSRandall Stewart ippp++; 916f8829a4aSRandall Stewart *ippp = ((chk->rec.data.stream_number << 16) | chk->rec.data.stream_seq); 917f8829a4aSRandall Stewart } 918a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_3; 919f8829a4aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, stcb, 920f8829a4aSRandall Stewart SCTP_PEER_FAULTY, oper); 921f8829a4aSRandall Stewart *abort_flag = 1; 922f8829a4aSRandall Stewart } else if (asoc->fragmented_delivery_inprogress) { 923f8829a4aSRandall Stewart /* 924f8829a4aSRandall Stewart * Here we are ok with a MIDDLE or LAST 925f8829a4aSRandall Stewart * piece 926f8829a4aSRandall Stewart */ 927f8829a4aSRandall Stewart if (chk->rec.data.stream_number != 928f8829a4aSRandall Stewart asoc->str_of_pdapi) { 929f8829a4aSRandall Stewart /* Got to be the right STR No */ 930f8829a4aSRandall Stewart #ifdef SCTP_DEBUG 931f8829a4aSRandall Stewart if (sctp_debug_on & SCTP_DEBUG_INDATA1) { 932f8829a4aSRandall Stewart printf("Gak, Evil plot, it IS not same stream number %d vs %d\n", 933f8829a4aSRandall Stewart chk->rec.data.stream_number, 934f8829a4aSRandall Stewart asoc->str_of_pdapi); 935f8829a4aSRandall Stewart } 936f8829a4aSRandall Stewart #endif 937139bc87fSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + 3 * sizeof(uint32_t)), 938f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 939f8829a4aSRandall Stewart if (oper) { 940f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 941f8829a4aSRandall Stewart uint32_t *ippp; 942f8829a4aSRandall Stewart 943139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = 944f8829a4aSRandall Stewart sizeof(struct sctp_paramhdr) + 945f8829a4aSRandall Stewart (sizeof(uint32_t) * 3); 946f8829a4aSRandall Stewart ph = mtod(oper, 947f8829a4aSRandall Stewart struct sctp_paramhdr *); 948f8829a4aSRandall Stewart ph->param_type = 949f8829a4aSRandall Stewart htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 950f8829a4aSRandall Stewart ph->param_length = 951139bc87fSRandall Stewart htons(SCTP_BUF_LEN(oper)); 952f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 953a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_4); 954f8829a4aSRandall Stewart ippp++; 955f8829a4aSRandall Stewart *ippp = chk->rec.data.TSN_seq; 956f8829a4aSRandall Stewart ippp++; 957f8829a4aSRandall Stewart *ippp = ((chk->rec.data.stream_number << 16) | chk->rec.data.stream_seq); 958f8829a4aSRandall Stewart } 959a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_4; 960f8829a4aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, 961f8829a4aSRandall Stewart stcb, SCTP_PEER_FAULTY, oper); 962f8829a4aSRandall Stewart *abort_flag = 1; 963f8829a4aSRandall Stewart } else if ((asoc->fragment_flags & SCTP_DATA_UNORDERED) != 964f8829a4aSRandall Stewart SCTP_DATA_UNORDERED && 965f8829a4aSRandall Stewart chk->rec.data.stream_seq != 966f8829a4aSRandall Stewart asoc->ssn_of_pdapi) { 967f8829a4aSRandall Stewart /* Got to be the right STR Seq */ 968f8829a4aSRandall Stewart #ifdef SCTP_DEBUG 969f8829a4aSRandall Stewart if (sctp_debug_on & SCTP_DEBUG_INDATA1) { 970f8829a4aSRandall Stewart printf("Gak, Evil plot, it IS not same stream seq %d vs %d\n", 971f8829a4aSRandall Stewart chk->rec.data.stream_seq, 972f8829a4aSRandall Stewart asoc->ssn_of_pdapi); 973f8829a4aSRandall Stewart } 974f8829a4aSRandall Stewart #endif 975139bc87fSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + 3 * sizeof(uint32_t)), 976f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 977f8829a4aSRandall Stewart if (oper) { 978f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 979f8829a4aSRandall Stewart uint32_t *ippp; 980f8829a4aSRandall Stewart 981139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = 982f8829a4aSRandall Stewart sizeof(struct sctp_paramhdr) + 983f8829a4aSRandall Stewart (3 * sizeof(uint32_t)); 984f8829a4aSRandall Stewart ph = mtod(oper, 985f8829a4aSRandall Stewart struct sctp_paramhdr *); 986f8829a4aSRandall Stewart ph->param_type = 987f8829a4aSRandall Stewart htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 988f8829a4aSRandall Stewart ph->param_length = 989139bc87fSRandall Stewart htons(SCTP_BUF_LEN(oper)); 990f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 991a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_5); 992f8829a4aSRandall Stewart ippp++; 993f8829a4aSRandall Stewart *ippp = chk->rec.data.TSN_seq; 994f8829a4aSRandall Stewart ippp++; 995f8829a4aSRandall Stewart *ippp = ((chk->rec.data.stream_number << 16) | chk->rec.data.stream_seq); 996f8829a4aSRandall Stewart 997f8829a4aSRandall Stewart } 998a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_5; 999f8829a4aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, 1000f8829a4aSRandall Stewart stcb, SCTP_PEER_FAULTY, oper); 1001f8829a4aSRandall Stewart *abort_flag = 1; 1002f8829a4aSRandall Stewart } 1003f8829a4aSRandall Stewart } 1004f8829a4aSRandall Stewart } 1005f8829a4aSRandall Stewart return; 1006f8829a4aSRandall Stewart } 1007f8829a4aSRandall Stewart /* Find its place */ 1008f8829a4aSRandall Stewart TAILQ_FOREACH(at, &asoc->reasmqueue, sctp_next) { 1009f8829a4aSRandall Stewart if (compare_with_wrap(at->rec.data.TSN_seq, 1010f8829a4aSRandall Stewart chk->rec.data.TSN_seq, MAX_TSN)) { 1011f8829a4aSRandall Stewart /* 1012f8829a4aSRandall Stewart * one in queue is bigger than the new one, insert 1013f8829a4aSRandall Stewart * before this one 1014f8829a4aSRandall Stewart */ 1015f8829a4aSRandall Stewart /* A check */ 1016f8829a4aSRandall Stewart asoc->size_on_reasm_queue += chk->send_size; 1017f8829a4aSRandall Stewart sctp_ucount_incr(asoc->cnt_on_reasm_queue); 1018f8829a4aSRandall Stewart next = at; 1019f8829a4aSRandall Stewart TAILQ_INSERT_BEFORE(at, chk, sctp_next); 1020f8829a4aSRandall Stewart break; 1021f8829a4aSRandall Stewart } else if (at->rec.data.TSN_seq == chk->rec.data.TSN_seq) { 1022f8829a4aSRandall Stewart /* Gak, He sent me a duplicate str seq number */ 1023f8829a4aSRandall Stewart /* 1024f8829a4aSRandall Stewart * foo bar, I guess I will just free this new guy, 1025f8829a4aSRandall Stewart * should we abort too? FIX ME MAYBE? Or it COULD be 1026f8829a4aSRandall Stewart * that the SSN's have wrapped. Maybe I should 1027f8829a4aSRandall Stewart * compare to TSN somehow... sigh for now just blow 1028f8829a4aSRandall Stewart * away the chunk! 1029f8829a4aSRandall Stewart */ 1030f8829a4aSRandall Stewart if (chk->data) { 1031f8829a4aSRandall Stewart sctp_m_freem(chk->data); 1032f8829a4aSRandall Stewart chk->data = NULL; 1033f8829a4aSRandall Stewart } 1034f8829a4aSRandall Stewart sctp_free_remote_addr(chk->whoTo); 1035f8829a4aSRandall Stewart sctp_free_a_chunk(stcb, chk); 1036f8829a4aSRandall Stewart return; 1037f8829a4aSRandall Stewart } else { 1038f8829a4aSRandall Stewart last_flags = at->rec.data.rcv_flags; 1039f8829a4aSRandall Stewart last_tsn = at->rec.data.TSN_seq; 1040f8829a4aSRandall Stewart prev = at; 1041f8829a4aSRandall Stewart if (TAILQ_NEXT(at, sctp_next) == NULL) { 1042f8829a4aSRandall Stewart /* 1043f8829a4aSRandall Stewart * We are at the end, insert it after this 1044f8829a4aSRandall Stewart * one 1045f8829a4aSRandall Stewart */ 1046f8829a4aSRandall Stewart /* check it first */ 1047f8829a4aSRandall Stewart asoc->size_on_reasm_queue += chk->send_size; 1048f8829a4aSRandall Stewart sctp_ucount_incr(asoc->cnt_on_reasm_queue); 1049f8829a4aSRandall Stewart TAILQ_INSERT_AFTER(&asoc->reasmqueue, at, chk, sctp_next); 1050f8829a4aSRandall Stewart break; 1051f8829a4aSRandall Stewart } 1052f8829a4aSRandall Stewart } 1053f8829a4aSRandall Stewart } 1054f8829a4aSRandall Stewart /* Now the audits */ 1055f8829a4aSRandall Stewart if (prev) { 1056f8829a4aSRandall Stewart prev_tsn = chk->rec.data.TSN_seq - 1; 1057f8829a4aSRandall Stewart if (prev_tsn == prev->rec.data.TSN_seq) { 1058f8829a4aSRandall Stewart /* 1059f8829a4aSRandall Stewart * Ok the one I am dropping onto the end is the 1060f8829a4aSRandall Stewart * NEXT. A bit of valdiation here. 1061f8829a4aSRandall Stewart */ 1062f8829a4aSRandall Stewart if ((prev->rec.data.rcv_flags & SCTP_DATA_FRAG_MASK) == 1063f8829a4aSRandall Stewart SCTP_DATA_FIRST_FRAG || 1064f8829a4aSRandall Stewart (prev->rec.data.rcv_flags & SCTP_DATA_FRAG_MASK) == 1065f8829a4aSRandall Stewart SCTP_DATA_MIDDLE_FRAG) { 1066f8829a4aSRandall Stewart /* 1067f8829a4aSRandall Stewart * Insert chk MUST be a MIDDLE or LAST 1068f8829a4aSRandall Stewart * fragment 1069f8829a4aSRandall Stewart */ 1070f8829a4aSRandall Stewart if ((chk->rec.data.rcv_flags & SCTP_DATA_FRAG_MASK) == 1071f8829a4aSRandall Stewart SCTP_DATA_FIRST_FRAG) { 1072f8829a4aSRandall Stewart #ifdef SCTP_DEBUG 1073f8829a4aSRandall Stewart if (sctp_debug_on & SCTP_DEBUG_INDATA1) { 1074f8829a4aSRandall Stewart printf("Prev check - It can be a midlle or last but not a first\n"); 1075f8829a4aSRandall Stewart printf("Gak, Evil plot, it's a FIRST!\n"); 1076f8829a4aSRandall Stewart } 1077f8829a4aSRandall Stewart #endif 1078139bc87fSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + 3 * sizeof(uint32_t)), 1079f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 1080f8829a4aSRandall Stewart if (oper) { 1081f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 1082f8829a4aSRandall Stewart uint32_t *ippp; 1083f8829a4aSRandall Stewart 1084139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = 1085f8829a4aSRandall Stewart sizeof(struct sctp_paramhdr) + 1086f8829a4aSRandall Stewart (3 * sizeof(uint32_t)); 1087f8829a4aSRandall Stewart ph = mtod(oper, 1088f8829a4aSRandall Stewart struct sctp_paramhdr *); 1089f8829a4aSRandall Stewart ph->param_type = 1090f8829a4aSRandall Stewart htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 1091f8829a4aSRandall Stewart ph->param_length = 1092139bc87fSRandall Stewart htons(SCTP_BUF_LEN(oper)); 1093f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 1094a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_6); 1095f8829a4aSRandall Stewart ippp++; 1096f8829a4aSRandall Stewart *ippp = chk->rec.data.TSN_seq; 1097f8829a4aSRandall Stewart ippp++; 1098f8829a4aSRandall Stewart *ippp = ((chk->rec.data.stream_number << 16) | chk->rec.data.stream_seq); 1099f8829a4aSRandall Stewart 1100f8829a4aSRandall Stewart } 1101a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_6; 1102f8829a4aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, 1103f8829a4aSRandall Stewart stcb, SCTP_PEER_FAULTY, oper); 1104f8829a4aSRandall Stewart *abort_flag = 1; 1105f8829a4aSRandall Stewart return; 1106f8829a4aSRandall Stewart } 1107f8829a4aSRandall Stewart if (chk->rec.data.stream_number != 1108f8829a4aSRandall Stewart prev->rec.data.stream_number) { 1109f8829a4aSRandall Stewart /* 1110f8829a4aSRandall Stewart * Huh, need the correct STR here, 1111f8829a4aSRandall Stewart * they must be the same. 1112f8829a4aSRandall Stewart */ 1113f8829a4aSRandall Stewart #ifdef SCTP_DEBUG 1114f8829a4aSRandall Stewart if (sctp_debug_on & SCTP_DEBUG_INDATA1) { 1115f8829a4aSRandall Stewart printf("Prev check - Gak, Evil plot, ssn:%d not the same as at:%d\n", 1116f8829a4aSRandall Stewart chk->rec.data.stream_number, 1117f8829a4aSRandall Stewart prev->rec.data.stream_number); 1118f8829a4aSRandall Stewart } 1119f8829a4aSRandall Stewart #endif 1120139bc87fSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + 3 * sizeof(uint32_t)), 1121f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 1122f8829a4aSRandall Stewart if (oper) { 1123f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 1124f8829a4aSRandall Stewart uint32_t *ippp; 1125f8829a4aSRandall Stewart 1126139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = 1127f8829a4aSRandall Stewart sizeof(struct sctp_paramhdr) + 1128f8829a4aSRandall Stewart (3 * sizeof(uint32_t)); 1129f8829a4aSRandall Stewart ph = mtod(oper, 1130f8829a4aSRandall Stewart struct sctp_paramhdr *); 1131f8829a4aSRandall Stewart ph->param_type = 1132f8829a4aSRandall Stewart htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 1133f8829a4aSRandall Stewart ph->param_length = 1134139bc87fSRandall Stewart htons(SCTP_BUF_LEN(oper)); 1135f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 1136a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_7); 1137f8829a4aSRandall Stewart ippp++; 1138f8829a4aSRandall Stewart *ippp = chk->rec.data.TSN_seq; 1139f8829a4aSRandall Stewart ippp++; 1140f8829a4aSRandall Stewart *ippp = ((chk->rec.data.stream_number << 16) | chk->rec.data.stream_seq); 1141f8829a4aSRandall Stewart } 1142a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_7; 1143f8829a4aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, 1144f8829a4aSRandall Stewart stcb, SCTP_PEER_FAULTY, oper); 1145f8829a4aSRandall Stewart 1146f8829a4aSRandall Stewart *abort_flag = 1; 1147f8829a4aSRandall Stewart return; 1148f8829a4aSRandall Stewart } 1149f8829a4aSRandall Stewart if ((prev->rec.data.rcv_flags & SCTP_DATA_UNORDERED) == 0 && 1150f8829a4aSRandall Stewart chk->rec.data.stream_seq != 1151f8829a4aSRandall Stewart prev->rec.data.stream_seq) { 1152f8829a4aSRandall Stewart /* 1153f8829a4aSRandall Stewart * Huh, need the correct STR here, 1154f8829a4aSRandall Stewart * they must be the same. 1155f8829a4aSRandall Stewart */ 1156f8829a4aSRandall Stewart #ifdef SCTP_DEBUG 1157f8829a4aSRandall Stewart if (sctp_debug_on & SCTP_DEBUG_INDATA1) { 1158f8829a4aSRandall Stewart printf("Prev check - Gak, Evil plot, sseq:%d not the same as at:%d\n", 1159f8829a4aSRandall Stewart chk->rec.data.stream_seq, 1160f8829a4aSRandall Stewart prev->rec.data.stream_seq); 1161f8829a4aSRandall Stewart } 1162f8829a4aSRandall Stewart #endif 1163139bc87fSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + 3 * sizeof(uint32_t)), 1164f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 1165f8829a4aSRandall Stewart if (oper) { 1166f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 1167f8829a4aSRandall Stewart uint32_t *ippp; 1168f8829a4aSRandall Stewart 1169139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = 1170f8829a4aSRandall Stewart sizeof(struct sctp_paramhdr) + 1171f8829a4aSRandall Stewart (3 * sizeof(uint32_t)); 1172f8829a4aSRandall Stewart ph = mtod(oper, 1173f8829a4aSRandall Stewart struct sctp_paramhdr *); 1174f8829a4aSRandall Stewart ph->param_type = 1175f8829a4aSRandall Stewart htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 1176f8829a4aSRandall Stewart ph->param_length = 1177139bc87fSRandall Stewart htons(SCTP_BUF_LEN(oper)); 1178f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 1179a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_8); 1180f8829a4aSRandall Stewart ippp++; 1181f8829a4aSRandall Stewart *ippp = chk->rec.data.TSN_seq; 1182f8829a4aSRandall Stewart ippp++; 1183f8829a4aSRandall Stewart *ippp = ((chk->rec.data.stream_number << 16) | chk->rec.data.stream_seq); 1184f8829a4aSRandall Stewart } 1185a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_8; 1186f8829a4aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, 1187f8829a4aSRandall Stewart stcb, SCTP_PEER_FAULTY, oper); 1188f8829a4aSRandall Stewart 1189f8829a4aSRandall Stewart *abort_flag = 1; 1190f8829a4aSRandall Stewart return; 1191f8829a4aSRandall Stewart } 1192f8829a4aSRandall Stewart } else if ((prev->rec.data.rcv_flags & SCTP_DATA_FRAG_MASK) == 1193f8829a4aSRandall Stewart SCTP_DATA_LAST_FRAG) { 1194f8829a4aSRandall Stewart /* Insert chk MUST be a FIRST */ 1195f8829a4aSRandall Stewart if ((chk->rec.data.rcv_flags & SCTP_DATA_FRAG_MASK) != 1196f8829a4aSRandall Stewart SCTP_DATA_FIRST_FRAG) { 1197f8829a4aSRandall Stewart #ifdef SCTP_DEBUG 1198f8829a4aSRandall Stewart if (sctp_debug_on & SCTP_DEBUG_INDATA1) { 1199f8829a4aSRandall Stewart printf("Prev check - Gak, evil plot, its not FIRST and it must be!\n"); 1200f8829a4aSRandall Stewart } 1201f8829a4aSRandall Stewart #endif 1202139bc87fSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + 3 * sizeof(uint32_t)), 1203f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 1204f8829a4aSRandall Stewart if (oper) { 1205f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 1206f8829a4aSRandall Stewart uint32_t *ippp; 1207f8829a4aSRandall Stewart 1208139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = 1209f8829a4aSRandall Stewart sizeof(struct sctp_paramhdr) + 1210f8829a4aSRandall Stewart (3 * sizeof(uint32_t)); 1211f8829a4aSRandall Stewart ph = mtod(oper, 1212f8829a4aSRandall Stewart struct sctp_paramhdr *); 1213f8829a4aSRandall Stewart ph->param_type = 1214f8829a4aSRandall Stewart htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 1215f8829a4aSRandall Stewart ph->param_length = 1216139bc87fSRandall Stewart htons(SCTP_BUF_LEN(oper)); 1217f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 1218a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_9); 1219f8829a4aSRandall Stewart ippp++; 1220f8829a4aSRandall Stewart *ippp = chk->rec.data.TSN_seq; 1221f8829a4aSRandall Stewart ippp++; 1222f8829a4aSRandall Stewart *ippp = ((chk->rec.data.stream_number << 16) | chk->rec.data.stream_seq); 1223f8829a4aSRandall Stewart 1224f8829a4aSRandall Stewart } 1225a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_9; 1226f8829a4aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, 1227f8829a4aSRandall Stewart stcb, SCTP_PEER_FAULTY, oper); 1228f8829a4aSRandall Stewart 1229f8829a4aSRandall Stewart *abort_flag = 1; 1230f8829a4aSRandall Stewart return; 1231f8829a4aSRandall Stewart } 1232f8829a4aSRandall Stewart } 1233f8829a4aSRandall Stewart } 1234f8829a4aSRandall Stewart } 1235f8829a4aSRandall Stewart if (next) { 1236f8829a4aSRandall Stewart post_tsn = chk->rec.data.TSN_seq + 1; 1237f8829a4aSRandall Stewart if (post_tsn == next->rec.data.TSN_seq) { 1238f8829a4aSRandall Stewart /* 1239f8829a4aSRandall Stewart * Ok the one I am inserting ahead of is my NEXT 1240f8829a4aSRandall Stewart * one. A bit of valdiation here. 1241f8829a4aSRandall Stewart */ 1242f8829a4aSRandall Stewart if (next->rec.data.rcv_flags & SCTP_DATA_FIRST_FRAG) { 1243f8829a4aSRandall Stewart /* Insert chk MUST be a last fragment */ 1244f8829a4aSRandall Stewart if ((chk->rec.data.rcv_flags & SCTP_DATA_FRAG_MASK) 1245f8829a4aSRandall Stewart != SCTP_DATA_LAST_FRAG) { 1246f8829a4aSRandall Stewart #ifdef SCTP_DEBUG 1247f8829a4aSRandall Stewart if (sctp_debug_on & SCTP_DEBUG_INDATA1) { 1248f8829a4aSRandall Stewart printf("Next chk - Next is FIRST, we must be LAST\n"); 1249f8829a4aSRandall Stewart printf("Gak, Evil plot, its not a last!\n"); 1250f8829a4aSRandall Stewart } 1251f8829a4aSRandall Stewart #endif 1252139bc87fSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + 3 * sizeof(uint32_t)), 1253f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 1254f8829a4aSRandall Stewart if (oper) { 1255f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 1256f8829a4aSRandall Stewart uint32_t *ippp; 1257f8829a4aSRandall Stewart 1258139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = 1259f8829a4aSRandall Stewart sizeof(struct sctp_paramhdr) + 1260f8829a4aSRandall Stewart (3 * sizeof(uint32_t)); 1261f8829a4aSRandall Stewart ph = mtod(oper, 1262f8829a4aSRandall Stewart struct sctp_paramhdr *); 1263f8829a4aSRandall Stewart ph->param_type = 1264f8829a4aSRandall Stewart htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 1265f8829a4aSRandall Stewart ph->param_length = 1266139bc87fSRandall Stewart htons(SCTP_BUF_LEN(oper)); 1267f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 1268a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_10); 1269f8829a4aSRandall Stewart ippp++; 1270f8829a4aSRandall Stewart *ippp = chk->rec.data.TSN_seq; 1271f8829a4aSRandall Stewart ippp++; 1272f8829a4aSRandall Stewart *ippp = ((chk->rec.data.stream_number << 16) | chk->rec.data.stream_seq); 1273f8829a4aSRandall Stewart } 1274a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_10; 1275f8829a4aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, 1276f8829a4aSRandall Stewart stcb, SCTP_PEER_FAULTY, oper); 1277f8829a4aSRandall Stewart 1278f8829a4aSRandall Stewart *abort_flag = 1; 1279f8829a4aSRandall Stewart return; 1280f8829a4aSRandall Stewart } 1281f8829a4aSRandall Stewart } else if ((next->rec.data.rcv_flags & SCTP_DATA_FRAG_MASK) == 1282f8829a4aSRandall Stewart SCTP_DATA_MIDDLE_FRAG || 1283f8829a4aSRandall Stewart (next->rec.data.rcv_flags & SCTP_DATA_FRAG_MASK) == 1284f8829a4aSRandall Stewart SCTP_DATA_LAST_FRAG) { 1285f8829a4aSRandall Stewart /* 1286f8829a4aSRandall Stewart * Insert chk CAN be MIDDLE or FIRST NOT 1287f8829a4aSRandall Stewart * LAST 1288f8829a4aSRandall Stewart */ 1289f8829a4aSRandall Stewart if ((chk->rec.data.rcv_flags & SCTP_DATA_FRAG_MASK) == 1290f8829a4aSRandall Stewart SCTP_DATA_LAST_FRAG) { 1291f8829a4aSRandall Stewart #ifdef SCTP_DEBUG 1292f8829a4aSRandall Stewart if (sctp_debug_on & SCTP_DEBUG_INDATA1) { 1293f8829a4aSRandall Stewart printf("Next chk - Next is a MIDDLE/LAST\n"); 1294f8829a4aSRandall Stewart printf("Gak, Evil plot, new prev chunk is a LAST\n"); 1295f8829a4aSRandall Stewart } 1296f8829a4aSRandall Stewart #endif 1297139bc87fSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + 3 * sizeof(uint32_t)), 1298f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 1299f8829a4aSRandall Stewart if (oper) { 1300f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 1301f8829a4aSRandall Stewart uint32_t *ippp; 1302f8829a4aSRandall Stewart 1303139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = 1304f8829a4aSRandall Stewart sizeof(struct sctp_paramhdr) + 1305f8829a4aSRandall Stewart (3 * sizeof(uint32_t)); 1306f8829a4aSRandall Stewart ph = mtod(oper, 1307f8829a4aSRandall Stewart struct sctp_paramhdr *); 1308f8829a4aSRandall Stewart ph->param_type = 1309f8829a4aSRandall Stewart htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 1310f8829a4aSRandall Stewart ph->param_length = 1311139bc87fSRandall Stewart htons(SCTP_BUF_LEN(oper)); 1312f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 1313a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_11); 1314f8829a4aSRandall Stewart ippp++; 1315f8829a4aSRandall Stewart *ippp = chk->rec.data.TSN_seq; 1316f8829a4aSRandall Stewart ippp++; 1317f8829a4aSRandall Stewart *ippp = ((chk->rec.data.stream_number << 16) | chk->rec.data.stream_seq); 1318f8829a4aSRandall Stewart 1319f8829a4aSRandall Stewart } 1320a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_11; 1321f8829a4aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, 1322f8829a4aSRandall Stewart stcb, SCTP_PEER_FAULTY, oper); 1323f8829a4aSRandall Stewart 1324f8829a4aSRandall Stewart *abort_flag = 1; 1325f8829a4aSRandall Stewart return; 1326f8829a4aSRandall Stewart } 1327f8829a4aSRandall Stewart if (chk->rec.data.stream_number != 1328f8829a4aSRandall Stewart next->rec.data.stream_number) { 1329f8829a4aSRandall Stewart /* 1330f8829a4aSRandall Stewart * Huh, need the correct STR here, 1331f8829a4aSRandall Stewart * they must be the same. 1332f8829a4aSRandall Stewart */ 1333f8829a4aSRandall Stewart #ifdef SCTP_DEBUG 1334f8829a4aSRandall Stewart if (sctp_debug_on & SCTP_DEBUG_INDATA1) { 1335f8829a4aSRandall Stewart printf("Next chk - Gak, Evil plot, ssn:%d not the same as at:%d\n", 1336f8829a4aSRandall Stewart chk->rec.data.stream_number, 1337f8829a4aSRandall Stewart next->rec.data.stream_number); 1338f8829a4aSRandall Stewart } 1339f8829a4aSRandall Stewart #endif 1340139bc87fSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + 3 * sizeof(uint32_t)), 1341f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 1342f8829a4aSRandall Stewart if (oper) { 1343f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 1344f8829a4aSRandall Stewart uint32_t *ippp; 1345f8829a4aSRandall Stewart 1346139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = 1347f8829a4aSRandall Stewart sizeof(struct sctp_paramhdr) + 1348f8829a4aSRandall Stewart (3 * sizeof(uint32_t)); 1349f8829a4aSRandall Stewart ph = mtod(oper, 1350f8829a4aSRandall Stewart struct sctp_paramhdr *); 1351f8829a4aSRandall Stewart ph->param_type = 1352f8829a4aSRandall Stewart htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 1353f8829a4aSRandall Stewart ph->param_length = 1354139bc87fSRandall Stewart htons(SCTP_BUF_LEN(oper)); 1355f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 1356a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_12); 1357f8829a4aSRandall Stewart ippp++; 1358f8829a4aSRandall Stewart *ippp = chk->rec.data.TSN_seq; 1359f8829a4aSRandall Stewart ippp++; 1360f8829a4aSRandall Stewart *ippp = ((chk->rec.data.stream_number << 16) | chk->rec.data.stream_seq); 1361f8829a4aSRandall Stewart 1362f8829a4aSRandall Stewart } 1363a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_12; 1364f8829a4aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, 1365f8829a4aSRandall Stewart stcb, SCTP_PEER_FAULTY, oper); 1366f8829a4aSRandall Stewart 1367f8829a4aSRandall Stewart *abort_flag = 1; 1368f8829a4aSRandall Stewart return; 1369f8829a4aSRandall Stewart } 1370f8829a4aSRandall Stewart if ((next->rec.data.rcv_flags & SCTP_DATA_UNORDERED) == 0 && 1371f8829a4aSRandall Stewart chk->rec.data.stream_seq != 1372f8829a4aSRandall Stewart next->rec.data.stream_seq) { 1373f8829a4aSRandall Stewart /* 1374f8829a4aSRandall Stewart * Huh, need the correct STR here, 1375f8829a4aSRandall Stewart * they must be the same. 1376f8829a4aSRandall Stewart */ 1377f8829a4aSRandall Stewart #ifdef SCTP_DEBUG 1378f8829a4aSRandall Stewart if (sctp_debug_on & SCTP_DEBUG_INDATA1) { 1379f8829a4aSRandall Stewart printf("Next chk - Gak, Evil plot, sseq:%d not the same as at:%d\n", 1380f8829a4aSRandall Stewart chk->rec.data.stream_seq, 1381f8829a4aSRandall Stewart next->rec.data.stream_seq); 1382f8829a4aSRandall Stewart } 1383f8829a4aSRandall Stewart #endif 1384139bc87fSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + 3 * sizeof(uint32_t)), 1385f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 1386f8829a4aSRandall Stewart if (oper) { 1387f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 1388f8829a4aSRandall Stewart uint32_t *ippp; 1389f8829a4aSRandall Stewart 1390139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = 1391f8829a4aSRandall Stewart sizeof(struct sctp_paramhdr) + 1392f8829a4aSRandall Stewart (3 * sizeof(uint32_t)); 1393f8829a4aSRandall Stewart ph = mtod(oper, 1394f8829a4aSRandall Stewart struct sctp_paramhdr *); 1395f8829a4aSRandall Stewart ph->param_type = 1396f8829a4aSRandall Stewart htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 1397f8829a4aSRandall Stewart ph->param_length = 1398139bc87fSRandall Stewart htons(SCTP_BUF_LEN(oper)); 1399f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 1400a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_13); 1401f8829a4aSRandall Stewart ippp++; 1402f8829a4aSRandall Stewart *ippp = chk->rec.data.TSN_seq; 1403f8829a4aSRandall Stewart ippp++; 1404f8829a4aSRandall Stewart *ippp = ((chk->rec.data.stream_number << 16) | chk->rec.data.stream_seq); 1405f8829a4aSRandall Stewart } 1406a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_13; 1407f8829a4aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, 1408f8829a4aSRandall Stewart stcb, SCTP_PEER_FAULTY, oper); 1409f8829a4aSRandall Stewart 1410f8829a4aSRandall Stewart *abort_flag = 1; 1411f8829a4aSRandall Stewart return; 1412f8829a4aSRandall Stewart 1413f8829a4aSRandall Stewart } 1414f8829a4aSRandall Stewart } 1415f8829a4aSRandall Stewart } 1416f8829a4aSRandall Stewart } 1417f8829a4aSRandall Stewart /* Do we need to do some delivery? check */ 1418f8829a4aSRandall Stewart sctp_deliver_reasm_check(stcb, asoc); 1419f8829a4aSRandall Stewart } 1420f8829a4aSRandall Stewart 1421f8829a4aSRandall Stewart /* 1422f8829a4aSRandall Stewart * This is an unfortunate routine. It checks to make sure a evil guy is not 1423f8829a4aSRandall Stewart * stuffing us full of bad packet fragments. A broken peer could also do this 1424f8829a4aSRandall Stewart * but this is doubtful. It is to bad I must worry about evil crackers sigh 1425f8829a4aSRandall Stewart * :< more cycles. 1426f8829a4aSRandall Stewart */ 1427f8829a4aSRandall Stewart static int 1428f8829a4aSRandall Stewart sctp_does_tsn_belong_to_reasm(struct sctp_association *asoc, 1429f8829a4aSRandall Stewart uint32_t TSN_seq) 1430f8829a4aSRandall Stewart { 1431f8829a4aSRandall Stewart struct sctp_tmit_chunk *at; 1432f8829a4aSRandall Stewart uint32_t tsn_est; 1433f8829a4aSRandall Stewart 1434f8829a4aSRandall Stewart TAILQ_FOREACH(at, &asoc->reasmqueue, sctp_next) { 1435f8829a4aSRandall Stewart if (compare_with_wrap(TSN_seq, 1436f8829a4aSRandall Stewart at->rec.data.TSN_seq, MAX_TSN)) { 1437f8829a4aSRandall Stewart /* is it one bigger? */ 1438f8829a4aSRandall Stewart tsn_est = at->rec.data.TSN_seq + 1; 1439f8829a4aSRandall Stewart if (tsn_est == TSN_seq) { 1440f8829a4aSRandall Stewart /* yep. It better be a last then */ 1441f8829a4aSRandall Stewart if ((at->rec.data.rcv_flags & SCTP_DATA_FRAG_MASK) != 1442f8829a4aSRandall Stewart SCTP_DATA_LAST_FRAG) { 1443f8829a4aSRandall Stewart /* 1444f8829a4aSRandall Stewart * Ok this guy belongs next to a guy 1445f8829a4aSRandall Stewart * that is NOT last, it should be a 1446f8829a4aSRandall Stewart * middle/last, not a complete 1447f8829a4aSRandall Stewart * chunk. 1448f8829a4aSRandall Stewart */ 1449f8829a4aSRandall Stewart return (1); 1450f8829a4aSRandall Stewart } else { 1451f8829a4aSRandall Stewart /* 1452f8829a4aSRandall Stewart * This guy is ok since its a LAST 1453f8829a4aSRandall Stewart * and the new chunk is a fully 1454f8829a4aSRandall Stewart * self- contained one. 1455f8829a4aSRandall Stewart */ 1456f8829a4aSRandall Stewart return (0); 1457f8829a4aSRandall Stewart } 1458f8829a4aSRandall Stewart } 1459f8829a4aSRandall Stewart } else if (TSN_seq == at->rec.data.TSN_seq) { 1460f8829a4aSRandall Stewart /* Software error since I have a dup? */ 1461f8829a4aSRandall Stewart return (1); 1462f8829a4aSRandall Stewart } else { 1463f8829a4aSRandall Stewart /* 1464f8829a4aSRandall Stewart * Ok, 'at' is larger than new chunk but does it 1465f8829a4aSRandall Stewart * need to be right before it. 1466f8829a4aSRandall Stewart */ 1467f8829a4aSRandall Stewart tsn_est = TSN_seq + 1; 1468f8829a4aSRandall Stewart if (tsn_est == at->rec.data.TSN_seq) { 1469f8829a4aSRandall Stewart /* Yep, It better be a first */ 1470f8829a4aSRandall Stewart if ((at->rec.data.rcv_flags & SCTP_DATA_FRAG_MASK) != 1471f8829a4aSRandall Stewart SCTP_DATA_FIRST_FRAG) { 1472f8829a4aSRandall Stewart return (1); 1473f8829a4aSRandall Stewart } else { 1474f8829a4aSRandall Stewart return (0); 1475f8829a4aSRandall Stewart } 1476f8829a4aSRandall Stewart } 1477f8829a4aSRandall Stewart } 1478f8829a4aSRandall Stewart } 1479f8829a4aSRandall Stewart return (0); 1480f8829a4aSRandall Stewart } 1481f8829a4aSRandall Stewart 1482f8829a4aSRandall Stewart 1483f8829a4aSRandall Stewart static int 1484f8829a4aSRandall Stewart sctp_process_a_data_chunk(struct sctp_tcb *stcb, struct sctp_association *asoc, 1485f8829a4aSRandall Stewart struct mbuf **m, int offset, struct sctp_data_chunk *ch, int chk_length, 1486f8829a4aSRandall Stewart struct sctp_nets *net, uint32_t * high_tsn, int *abort_flag, 1487f8829a4aSRandall Stewart int *break_flag, int last_chunk) 1488f8829a4aSRandall Stewart { 1489f8829a4aSRandall Stewart /* Process a data chunk */ 1490f8829a4aSRandall Stewart /* struct sctp_tmit_chunk *chk; */ 1491f8829a4aSRandall Stewart struct sctp_tmit_chunk *chk; 1492f8829a4aSRandall Stewart uint32_t tsn, gap; 1493f8829a4aSRandall Stewart struct mbuf *dmbuf; 1494f8829a4aSRandall Stewart int indx, the_len; 1495139bc87fSRandall Stewart int need_reasm_check = 0; 1496f8829a4aSRandall Stewart uint16_t strmno, strmseq; 1497f8829a4aSRandall Stewart struct mbuf *oper; 1498f8829a4aSRandall Stewart struct sctp_queued_to_read *control; 1499f42a358aSRandall Stewart int ordered; 1500f42a358aSRandall Stewart uint32_t protocol_id; 1501f42a358aSRandall Stewart uint8_t chunk_flags; 150217205eccSRandall Stewart struct sctp_stream_reset_list *liste; 1503f8829a4aSRandall Stewart 1504f8829a4aSRandall Stewart chk = NULL; 1505f8829a4aSRandall Stewart tsn = ntohl(ch->dp.tsn); 1506f42a358aSRandall Stewart chunk_flags = ch->ch.chunk_flags; 1507f42a358aSRandall Stewart protocol_id = ch->dp.protocol_id; 1508f42a358aSRandall Stewart ordered = ((ch->ch.chunk_flags & SCTP_DATA_UNORDERED) == 0); 1509f8829a4aSRandall Stewart #ifdef SCTP_MAP_LOGGING 1510f8829a4aSRandall Stewart sctp_log_map(0, tsn, asoc->cumulative_tsn, SCTP_MAP_PREPARE_SLIDE); 1511f8829a4aSRandall Stewart #endif 1512f8829a4aSRandall Stewart if (compare_with_wrap(asoc->cumulative_tsn, tsn, MAX_TSN) || 1513f8829a4aSRandall Stewart asoc->cumulative_tsn == tsn) { 1514f8829a4aSRandall Stewart /* It is a duplicate */ 1515f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_recvdupdata); 1516f8829a4aSRandall Stewart if (asoc->numduptsns < SCTP_MAX_DUP_TSNS) { 1517f8829a4aSRandall Stewart /* Record a dup for the next outbound sack */ 1518f8829a4aSRandall Stewart asoc->dup_tsns[asoc->numduptsns] = tsn; 1519f8829a4aSRandall Stewart asoc->numduptsns++; 1520f8829a4aSRandall Stewart } 1521f8829a4aSRandall Stewart return (0); 1522f8829a4aSRandall Stewart } 1523f8829a4aSRandall Stewart /* Calculate the number of TSN's between the base and this TSN */ 1524f8829a4aSRandall Stewart if (tsn >= asoc->mapping_array_base_tsn) { 1525f8829a4aSRandall Stewart gap = tsn - asoc->mapping_array_base_tsn; 1526f8829a4aSRandall Stewart } else { 1527f8829a4aSRandall Stewart gap = (MAX_TSN - asoc->mapping_array_base_tsn) + tsn + 1; 1528f8829a4aSRandall Stewart } 1529f8829a4aSRandall Stewart if (gap >= (SCTP_MAPPING_ARRAY << 3)) { 1530f8829a4aSRandall Stewart /* Can't hold the bit in the mapping at max array, toss it */ 1531f8829a4aSRandall Stewart return (0); 1532f8829a4aSRandall Stewart } 1533f8829a4aSRandall Stewart if (gap >= (uint32_t) (asoc->mapping_array_size << 3)) { 1534f8829a4aSRandall Stewart if (sctp_expand_mapping_array(asoc)) { 1535f8829a4aSRandall Stewart /* Can't expand, drop it */ 1536f8829a4aSRandall Stewart return (0); 1537f8829a4aSRandall Stewart } 1538f8829a4aSRandall Stewart } 1539f8829a4aSRandall Stewart if (compare_with_wrap(tsn, *high_tsn, MAX_TSN)) { 1540f8829a4aSRandall Stewart *high_tsn = tsn; 1541f8829a4aSRandall Stewart } 1542f8829a4aSRandall Stewart /* See if we have received this one already */ 1543f8829a4aSRandall Stewart if (SCTP_IS_TSN_PRESENT(asoc->mapping_array, gap)) { 1544f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_recvdupdata); 1545f8829a4aSRandall Stewart if (asoc->numduptsns < SCTP_MAX_DUP_TSNS) { 1546f8829a4aSRandall Stewart /* Record a dup for the next outbound sack */ 1547f8829a4aSRandall Stewart asoc->dup_tsns[asoc->numduptsns] = tsn; 1548f8829a4aSRandall Stewart asoc->numduptsns++; 1549f8829a4aSRandall Stewart } 155042551e99SRandall Stewart asoc->send_sack = 1; 1551f8829a4aSRandall Stewart return (0); 1552f8829a4aSRandall Stewart } 1553f8829a4aSRandall Stewart /* 1554f8829a4aSRandall Stewart * Check to see about the GONE flag, duplicates would cause a sack 1555f8829a4aSRandall Stewart * to be sent up above 1556f8829a4aSRandall Stewart */ 1557f8829a4aSRandall Stewart if (stcb && ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) || 1558f8829a4aSRandall Stewart (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_ALLGONE) || 1559f8829a4aSRandall Stewart (stcb->asoc.state & SCTP_STATE_CLOSED_SOCKET)) 1560f8829a4aSRandall Stewart ) { 1561f8829a4aSRandall Stewart /* 1562f8829a4aSRandall Stewart * wait a minute, this guy is gone, there is no longer a 1563f8829a4aSRandall Stewart * receiver. Send peer an ABORT! 1564f8829a4aSRandall Stewart */ 1565f8829a4aSRandall Stewart struct mbuf *op_err; 1566f8829a4aSRandall Stewart 1567f8829a4aSRandall Stewart op_err = sctp_generate_invmanparam(SCTP_CAUSE_OUT_OF_RESC); 1568f8829a4aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, stcb, 0, op_err); 1569f8829a4aSRandall Stewart *abort_flag = 1; 1570f8829a4aSRandall Stewart return (0); 1571f8829a4aSRandall Stewart } 1572f8829a4aSRandall Stewart /* 1573f8829a4aSRandall Stewart * Now before going further we see if there is room. If NOT then we 1574f8829a4aSRandall Stewart * MAY let one through only IF this TSN is the one we are waiting 1575f8829a4aSRandall Stewart * for on a partial delivery API. 1576f8829a4aSRandall Stewart */ 1577f8829a4aSRandall Stewart 1578f8829a4aSRandall Stewart /* now do the tests */ 1579f8829a4aSRandall Stewart if (((asoc->cnt_on_all_streams + 1580f8829a4aSRandall Stewart asoc->cnt_on_reasm_queue + 1581f8829a4aSRandall Stewart asoc->cnt_msg_on_sb) > sctp_max_chunks_on_queue) || 1582f8829a4aSRandall Stewart (((int)asoc->my_rwnd) <= 0)) { 1583f8829a4aSRandall Stewart /* 1584f8829a4aSRandall Stewart * When we have NO room in the rwnd we check to make sure 1585f8829a4aSRandall Stewart * the reader is doing its job... 1586f8829a4aSRandall Stewart */ 1587f8829a4aSRandall Stewart if (stcb->sctp_socket->so_rcv.sb_cc) { 1588f8829a4aSRandall Stewart /* some to read, wake-up */ 1589f8829a4aSRandall Stewart sctp_sorwakeup(stcb->sctp_ep, stcb->sctp_socket); 1590f8829a4aSRandall Stewart } 1591f8829a4aSRandall Stewart /* now is it in the mapping array of what we have accepted? */ 1592f8829a4aSRandall Stewart if (compare_with_wrap(tsn, 1593f8829a4aSRandall Stewart asoc->highest_tsn_inside_map, MAX_TSN)) { 1594f8829a4aSRandall Stewart 1595f8829a4aSRandall Stewart /* Nope not in the valid range dump it */ 1596f8829a4aSRandall Stewart #ifdef SCTP_DEBUG 1597f8829a4aSRandall Stewart if (sctp_debug_on & SCTP_DEBUG_INDATA1) { 1598f8829a4aSRandall Stewart printf("My rwnd overrun1:tsn:%lx rwnd %lu sbspace:%ld\n", 1599f8829a4aSRandall Stewart (u_long)tsn, (u_long)asoc->my_rwnd, 1600f8829a4aSRandall Stewart sctp_sbspace(&stcb->asoc, &stcb->sctp_socket->so_rcv)); 1601f8829a4aSRandall Stewart 1602f8829a4aSRandall Stewart } 1603f8829a4aSRandall Stewart #endif 1604f8829a4aSRandall Stewart sctp_set_rwnd(stcb, asoc); 1605f8829a4aSRandall Stewart if ((asoc->cnt_on_all_streams + 1606f8829a4aSRandall Stewart asoc->cnt_on_reasm_queue + 1607f8829a4aSRandall Stewart asoc->cnt_msg_on_sb) > sctp_max_chunks_on_queue) { 1608f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_datadropchklmt); 1609f8829a4aSRandall Stewart } else { 1610f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_datadroprwnd); 1611f8829a4aSRandall Stewart } 1612f8829a4aSRandall Stewart indx = *break_flag; 1613f8829a4aSRandall Stewart *break_flag = 1; 1614f8829a4aSRandall Stewart return (0); 1615f8829a4aSRandall Stewart } 1616f8829a4aSRandall Stewart } 1617f8829a4aSRandall Stewart strmno = ntohs(ch->dp.stream_id); 1618f8829a4aSRandall Stewart if (strmno >= asoc->streamincnt) { 1619f8829a4aSRandall Stewart struct sctp_paramhdr *phdr; 1620f8829a4aSRandall Stewart struct mbuf *mb; 1621f8829a4aSRandall Stewart 1622f8829a4aSRandall Stewart mb = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) * 2), 1623139bc87fSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 1624f8829a4aSRandall Stewart if (mb != NULL) { 1625f8829a4aSRandall Stewart /* add some space up front so prepend will work well */ 1626139bc87fSRandall Stewart SCTP_BUF_RESV_UF(mb, sizeof(struct sctp_chunkhdr)); 1627f8829a4aSRandall Stewart phdr = mtod(mb, struct sctp_paramhdr *); 1628f8829a4aSRandall Stewart /* 1629f8829a4aSRandall Stewart * Error causes are just param's and this one has 1630f8829a4aSRandall Stewart * two back to back phdr, one with the error type 1631f8829a4aSRandall Stewart * and size, the other with the streamid and a rsvd 1632f8829a4aSRandall Stewart */ 1633139bc87fSRandall Stewart SCTP_BUF_LEN(mb) = (sizeof(struct sctp_paramhdr) * 2); 1634f8829a4aSRandall Stewart phdr->param_type = htons(SCTP_CAUSE_INVALID_STREAM); 1635f8829a4aSRandall Stewart phdr->param_length = 1636f8829a4aSRandall Stewart htons(sizeof(struct sctp_paramhdr) * 2); 1637f8829a4aSRandall Stewart phdr++; 1638f8829a4aSRandall Stewart /* We insert the stream in the type field */ 1639f8829a4aSRandall Stewart phdr->param_type = ch->dp.stream_id; 1640f8829a4aSRandall Stewart /* And set the length to 0 for the rsvd field */ 1641f8829a4aSRandall Stewart phdr->param_length = 0; 1642f8829a4aSRandall Stewart sctp_queue_op_err(stcb, mb); 1643f8829a4aSRandall Stewart } 1644f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_badsid); 1645d06c82f1SRandall Stewart SCTP_SET_TSN_PRESENT(asoc->mapping_array, gap); 1646d06c82f1SRandall Stewart if (compare_with_wrap(tsn, asoc->highest_tsn_inside_map, MAX_TSN)) { 1647d06c82f1SRandall Stewart /* we have a new high score */ 1648d06c82f1SRandall Stewart asoc->highest_tsn_inside_map = tsn; 1649d06c82f1SRandall Stewart #ifdef SCTP_MAP_LOGGING 1650d06c82f1SRandall Stewart sctp_log_map(0, 2, asoc->highest_tsn_inside_map, SCTP_MAP_SLIDE_RESULT); 1651d06c82f1SRandall Stewart #endif 1652d06c82f1SRandall Stewart } 1653d06c82f1SRandall Stewart if (tsn == (asoc->cumulative_tsn + 1)) { 1654d06c82f1SRandall Stewart /* Update cum-ack */ 1655d06c82f1SRandall Stewart asoc->cumulative_tsn = tsn; 1656d06c82f1SRandall Stewart } 1657f8829a4aSRandall Stewart return (0); 1658f8829a4aSRandall Stewart } 1659f8829a4aSRandall Stewart /* 1660f8829a4aSRandall Stewart * Before we continue lets validate that we are not being fooled by 1661f8829a4aSRandall Stewart * an evil attacker. We can only have 4k chunks based on our TSN 1662f8829a4aSRandall Stewart * spread allowed by the mapping array 512 * 8 bits, so there is no 1663f8829a4aSRandall Stewart * way our stream sequence numbers could have wrapped. We of course 1664f8829a4aSRandall Stewart * only validate the FIRST fragment so the bit must be set. 1665f8829a4aSRandall Stewart */ 1666f8829a4aSRandall Stewart strmseq = ntohs(ch->dp.stream_sequence); 1667f42a358aSRandall Stewart 1668f42a358aSRandall Stewart #ifdef SCTP_ASOCLOG_OF_TSNS 1669f42a358aSRandall Stewart asoc->in_tsnlog[asoc->tsn_in_at].tsn = tsn; 1670f42a358aSRandall Stewart asoc->in_tsnlog[asoc->tsn_in_at].strm = strmno; 1671f42a358aSRandall Stewart asoc->in_tsnlog[asoc->tsn_in_at].seq = strmseq; 1672f1f73e57SRandall Stewart asoc->in_tsnlog[asoc->tsn_in_at].sz = chk_length; 1673f1f73e57SRandall Stewart asoc->in_tsnlog[asoc->tsn_in_at].flgs = chunk_flags; 1674f42a358aSRandall Stewart asoc->tsn_in_at++; 1675f42a358aSRandall Stewart if (asoc->tsn_in_at >= SCTP_TSN_LOG_SIZE) { 1676f42a358aSRandall Stewart asoc->tsn_in_at = 0; 1677f1f73e57SRandall Stewart asoc->tsn_in_wrapped = 1; 1678f42a358aSRandall Stewart } 1679f42a358aSRandall Stewart #endif 1680f42a358aSRandall Stewart if ((chunk_flags & SCTP_DATA_FIRST_FRAG) && 1681f42a358aSRandall Stewart (chunk_flags & SCTP_DATA_UNORDERED) == 0 && 1682f8829a4aSRandall Stewart (compare_with_wrap(asoc->strmin[strmno].last_sequence_delivered, 1683f8829a4aSRandall Stewart strmseq, MAX_SEQ) || 1684f8829a4aSRandall Stewart asoc->strmin[strmno].last_sequence_delivered == strmseq)) { 1685f8829a4aSRandall Stewart /* The incoming sseq is behind where we last delivered? */ 1686f8829a4aSRandall Stewart #ifdef SCTP_DEBUG 1687f8829a4aSRandall Stewart if (sctp_debug_on & SCTP_DEBUG_INDATA1) { 1688f8829a4aSRandall Stewart printf("EVIL/Broken-Dup S-SEQ:%d delivered:%d from peer, Abort!\n", 1689f8829a4aSRandall Stewart strmseq, 1690f8829a4aSRandall Stewart asoc->strmin[strmno].last_sequence_delivered); 1691f8829a4aSRandall Stewart } 1692f8829a4aSRandall Stewart #endif 1693139bc87fSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + 3 * sizeof(uint32_t)), 1694f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 1695f8829a4aSRandall Stewart if (oper) { 1696f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 1697f8829a4aSRandall Stewart uint32_t *ippp; 1698f8829a4aSRandall Stewart 1699139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = sizeof(struct sctp_paramhdr) + 1700f8829a4aSRandall Stewart (3 * sizeof(uint32_t)); 1701f8829a4aSRandall Stewart ph = mtod(oper, struct sctp_paramhdr *); 1702f8829a4aSRandall Stewart ph->param_type = htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 1703139bc87fSRandall Stewart ph->param_length = htons(SCTP_BUF_LEN(oper)); 1704f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 1705a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_14); 1706f8829a4aSRandall Stewart ippp++; 1707f8829a4aSRandall Stewart *ippp = tsn; 1708f8829a4aSRandall Stewart ippp++; 1709f8829a4aSRandall Stewart *ippp = ((strmno << 16) | strmseq); 1710f8829a4aSRandall Stewart 1711f8829a4aSRandall Stewart } 1712a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_14; 1713f8829a4aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, stcb, 1714f8829a4aSRandall Stewart SCTP_PEER_FAULTY, oper); 1715f8829a4aSRandall Stewart *abort_flag = 1; 1716f8829a4aSRandall Stewart return (0); 1717f8829a4aSRandall Stewart } 1718f42a358aSRandall Stewart /************************************ 1719f42a358aSRandall Stewart * From here down we may find ch-> invalid 1720f42a358aSRandall Stewart * so its a good idea NOT to use it. 1721f42a358aSRandall Stewart *************************************/ 1722f42a358aSRandall Stewart 1723f8829a4aSRandall Stewart the_len = (chk_length - sizeof(struct sctp_data_chunk)); 1724f8829a4aSRandall Stewart if (last_chunk == 0) { 172544b7479bSRandall Stewart dmbuf = SCTP_M_COPYM(*m, 1726f8829a4aSRandall Stewart (offset + sizeof(struct sctp_data_chunk)), 1727f8829a4aSRandall Stewart the_len, M_DONTWAIT); 1728f8829a4aSRandall Stewart #ifdef SCTP_MBUF_LOGGING 1729f8829a4aSRandall Stewart { 1730f8829a4aSRandall Stewart struct mbuf *mat; 1731f8829a4aSRandall Stewart 1732f8829a4aSRandall Stewart mat = dmbuf; 1733f8829a4aSRandall Stewart while (mat) { 1734139bc87fSRandall Stewart if (SCTP_BUF_IS_EXTENDED(mat)) { 1735f8829a4aSRandall Stewart sctp_log_mb(mat, SCTP_MBUF_ICOPY); 1736f8829a4aSRandall Stewart } 1737139bc87fSRandall Stewart mat = SCTP_BUF_NEXT(mat); 1738f8829a4aSRandall Stewart } 1739f8829a4aSRandall Stewart } 1740f8829a4aSRandall Stewart #endif 1741f8829a4aSRandall Stewart } else { 1742f8829a4aSRandall Stewart /* We can steal the last chunk */ 1743139bc87fSRandall Stewart int l_len; 1744139bc87fSRandall Stewart 1745f8829a4aSRandall Stewart dmbuf = *m; 1746f8829a4aSRandall Stewart /* lop off the top part */ 1747f8829a4aSRandall Stewart m_adj(dmbuf, (offset + sizeof(struct sctp_data_chunk))); 1748139bc87fSRandall Stewart if (SCTP_BUF_NEXT(dmbuf) == NULL) { 1749139bc87fSRandall Stewart l_len = SCTP_BUF_LEN(dmbuf); 1750139bc87fSRandall Stewart } else { 1751139bc87fSRandall Stewart /* 1752139bc87fSRandall Stewart * need to count up the size hopefully does not hit 1753139bc87fSRandall Stewart * this to often :-0 1754139bc87fSRandall Stewart */ 1755139bc87fSRandall Stewart struct mbuf *lat; 1756139bc87fSRandall Stewart 1757139bc87fSRandall Stewart l_len = 0; 1758139bc87fSRandall Stewart lat = dmbuf; 1759139bc87fSRandall Stewart while (lat) { 1760139bc87fSRandall Stewart l_len += SCTP_BUF_LEN(lat); 1761139bc87fSRandall Stewart lat = SCTP_BUF_NEXT(lat); 1762139bc87fSRandall Stewart } 1763139bc87fSRandall Stewart } 1764139bc87fSRandall Stewart if (l_len > the_len) { 1765f8829a4aSRandall Stewart /* Trim the end round bytes off too */ 1766139bc87fSRandall Stewart m_adj(dmbuf, -(l_len - the_len)); 1767f8829a4aSRandall Stewart } 1768f8829a4aSRandall Stewart } 1769f8829a4aSRandall Stewart if (dmbuf == NULL) { 1770f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_nomem); 1771f8829a4aSRandall Stewart return (0); 1772f8829a4aSRandall Stewart } 1773f42a358aSRandall Stewart if ((chunk_flags & SCTP_DATA_NOT_FRAG) == SCTP_DATA_NOT_FRAG && 1774f8829a4aSRandall Stewart asoc->fragmented_delivery_inprogress == 0 && 1775f8829a4aSRandall Stewart TAILQ_EMPTY(&asoc->resetHead) && 1776f42a358aSRandall Stewart ((ordered == 0) || 1777f8829a4aSRandall Stewart ((asoc->strmin[strmno].last_sequence_delivered + 1) == strmseq && 1778f8829a4aSRandall Stewart TAILQ_EMPTY(&asoc->strmin[strmno].inqueue)))) { 1779f8829a4aSRandall Stewart /* Candidate for express delivery */ 1780f8829a4aSRandall Stewart /* 1781f8829a4aSRandall Stewart * Its not fragmented, No PD-API is up, Nothing in the 1782f8829a4aSRandall Stewart * delivery queue, Its un-ordered OR ordered and the next to 1783f8829a4aSRandall Stewart * deliver AND nothing else is stuck on the stream queue, 1784f8829a4aSRandall Stewart * And there is room for it in the socket buffer. Lets just 1785f8829a4aSRandall Stewart * stuff it up the buffer.... 1786f8829a4aSRandall Stewart */ 1787f8829a4aSRandall Stewart 1788f8829a4aSRandall Stewart /* It would be nice to avoid this copy if we could :< */ 1789f8829a4aSRandall Stewart sctp_alloc_a_readq(stcb, control); 1790f8829a4aSRandall Stewart sctp_build_readq_entry_mac(control, stcb, asoc->context, net, tsn, 1791f42a358aSRandall Stewart protocol_id, 1792f8829a4aSRandall Stewart stcb->asoc.context, 1793f8829a4aSRandall Stewart strmno, strmseq, 1794f42a358aSRandall Stewart chunk_flags, 1795f8829a4aSRandall Stewart dmbuf); 1796f8829a4aSRandall Stewart if (control == NULL) { 1797f8829a4aSRandall Stewart goto failed_express_del; 1798f8829a4aSRandall Stewart } 1799f8829a4aSRandall Stewart sctp_add_to_readq(stcb->sctp_ep, stcb, control, &stcb->sctp_socket->so_rcv, 1); 1800f42a358aSRandall Stewart if ((chunk_flags & SCTP_DATA_UNORDERED) == 0) { 1801f8829a4aSRandall Stewart /* for ordered, bump what we delivered */ 1802f8829a4aSRandall Stewart asoc->strmin[strmno].last_sequence_delivered++; 1803f8829a4aSRandall Stewart } 1804f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_recvexpress); 1805f8829a4aSRandall Stewart #ifdef SCTP_STR_LOGGING 18066a91f103SRandall Stewart sctp_log_strm_del_alt(stcb, tsn, strmseq, strmno, 1807f8829a4aSRandall Stewart SCTP_STR_LOG_FROM_EXPRS_DEL); 1808f8829a4aSRandall Stewart #endif 1809f8829a4aSRandall Stewart control = NULL; 1810f8829a4aSRandall Stewart goto finish_express_del; 1811f8829a4aSRandall Stewart } 1812f8829a4aSRandall Stewart failed_express_del: 1813f8829a4aSRandall Stewart /* If we reach here this is a new chunk */ 1814f8829a4aSRandall Stewart chk = NULL; 1815f8829a4aSRandall Stewart control = NULL; 1816f8829a4aSRandall Stewart /* Express for fragmented delivery? */ 1817f8829a4aSRandall Stewart if ((asoc->fragmented_delivery_inprogress) && 1818f8829a4aSRandall Stewart (stcb->asoc.control_pdapi) && 1819f8829a4aSRandall Stewart (asoc->str_of_pdapi == strmno) && 1820f8829a4aSRandall Stewart (asoc->ssn_of_pdapi == strmseq) 1821f8829a4aSRandall Stewart ) { 1822f8829a4aSRandall Stewart control = stcb->asoc.control_pdapi; 1823f42a358aSRandall Stewart if ((chunk_flags & SCTP_DATA_FIRST_FRAG) == SCTP_DATA_FIRST_FRAG) { 1824f8829a4aSRandall Stewart /* Can't be another first? */ 1825f8829a4aSRandall Stewart goto failed_pdapi_express_del; 1826f8829a4aSRandall Stewart } 1827f8829a4aSRandall Stewart if (tsn == (control->sinfo_tsn + 1)) { 1828f8829a4aSRandall Stewart /* Yep, we can add it on */ 1829f8829a4aSRandall Stewart int end = 0; 1830f8829a4aSRandall Stewart uint32_t cumack; 1831f8829a4aSRandall Stewart 1832f42a358aSRandall Stewart if (chunk_flags & SCTP_DATA_LAST_FRAG) { 1833f8829a4aSRandall Stewart end = 1; 1834f8829a4aSRandall Stewart } 1835f8829a4aSRandall Stewart cumack = asoc->cumulative_tsn; 1836f8829a4aSRandall Stewart if ((cumack + 1) == tsn) 1837f8829a4aSRandall Stewart cumack = tsn; 1838f8829a4aSRandall Stewart 1839f8829a4aSRandall Stewart if (sctp_append_to_readq(stcb->sctp_ep, stcb, control, dmbuf, end, 1840f8829a4aSRandall Stewart tsn, 1841f8829a4aSRandall Stewart &stcb->sctp_socket->so_rcv)) { 1842f8829a4aSRandall Stewart printf("Append fails end:%d\n", end); 1843f8829a4aSRandall Stewart goto failed_pdapi_express_del; 1844f8829a4aSRandall Stewart } 1845f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_recvexpressm); 1846f8829a4aSRandall Stewart control->sinfo_tsn = tsn; 1847f8829a4aSRandall Stewart asoc->tsn_last_delivered = tsn; 1848f42a358aSRandall Stewart asoc->fragment_flags = chunk_flags; 1849f8829a4aSRandall Stewart asoc->tsn_of_pdapi_last_delivered = tsn; 1850f42a358aSRandall Stewart asoc->last_flags_delivered = chunk_flags; 1851f8829a4aSRandall Stewart asoc->last_strm_seq_delivered = strmseq; 1852f8829a4aSRandall Stewart asoc->last_strm_no_delivered = strmno; 1853f8829a4aSRandall Stewart if (end) { 1854f8829a4aSRandall Stewart /* clean up the flags and such */ 1855f8829a4aSRandall Stewart asoc->fragmented_delivery_inprogress = 0; 1856f42a358aSRandall Stewart if ((chunk_flags & SCTP_DATA_UNORDERED) == 0) { 1857f8829a4aSRandall Stewart asoc->strmin[strmno].last_sequence_delivered++; 1858a5d547adSRandall Stewart } 1859f8829a4aSRandall Stewart stcb->asoc.control_pdapi = NULL; 1860139bc87fSRandall Stewart if (TAILQ_EMPTY(&asoc->reasmqueue) == 0) { 1861139bc87fSRandall Stewart /* 1862139bc87fSRandall Stewart * There could be another message 1863139bc87fSRandall Stewart * ready 1864139bc87fSRandall Stewart */ 1865139bc87fSRandall Stewart need_reasm_check = 1; 1866139bc87fSRandall Stewart } 1867f8829a4aSRandall Stewart } 1868f8829a4aSRandall Stewart control = NULL; 1869f8829a4aSRandall Stewart goto finish_express_del; 1870f8829a4aSRandall Stewart } 1871f8829a4aSRandall Stewart } 1872f8829a4aSRandall Stewart failed_pdapi_express_del: 1873f8829a4aSRandall Stewart control = NULL; 1874f42a358aSRandall Stewart if ((chunk_flags & SCTP_DATA_NOT_FRAG) != SCTP_DATA_NOT_FRAG) { 1875f8829a4aSRandall Stewart sctp_alloc_a_chunk(stcb, chk); 1876f8829a4aSRandall Stewart if (chk == NULL) { 1877f8829a4aSRandall Stewart /* No memory so we drop the chunk */ 1878f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_nomem); 1879f8829a4aSRandall Stewart if (last_chunk == 0) { 1880f8829a4aSRandall Stewart /* we copied it, free the copy */ 1881f8829a4aSRandall Stewart sctp_m_freem(dmbuf); 1882f8829a4aSRandall Stewart } 1883f8829a4aSRandall Stewart return (0); 1884f8829a4aSRandall Stewart } 1885f8829a4aSRandall Stewart chk->rec.data.TSN_seq = tsn; 1886f8829a4aSRandall Stewart chk->no_fr_allowed = 0; 1887f8829a4aSRandall Stewart chk->rec.data.stream_seq = strmseq; 1888f8829a4aSRandall Stewart chk->rec.data.stream_number = strmno; 1889f42a358aSRandall Stewart chk->rec.data.payloadtype = protocol_id; 1890f8829a4aSRandall Stewart chk->rec.data.context = stcb->asoc.context; 1891f8829a4aSRandall Stewart chk->rec.data.doing_fast_retransmit = 0; 1892f42a358aSRandall Stewart chk->rec.data.rcv_flags = chunk_flags; 1893f8829a4aSRandall Stewart chk->asoc = asoc; 1894f8829a4aSRandall Stewart chk->send_size = the_len; 1895f8829a4aSRandall Stewart chk->whoTo = net; 1896f8829a4aSRandall Stewart atomic_add_int(&net->ref_count, 1); 1897f8829a4aSRandall Stewart chk->data = dmbuf; 1898f8829a4aSRandall Stewart } else { 1899f8829a4aSRandall Stewart sctp_alloc_a_readq(stcb, control); 1900f8829a4aSRandall Stewart sctp_build_readq_entry_mac(control, stcb, asoc->context, net, tsn, 1901f42a358aSRandall Stewart protocol_id, 1902f8829a4aSRandall Stewart stcb->asoc.context, 1903f8829a4aSRandall Stewart strmno, strmseq, 1904f42a358aSRandall Stewart chunk_flags, 1905f8829a4aSRandall Stewart dmbuf); 1906f8829a4aSRandall Stewart if (control == NULL) { 1907f8829a4aSRandall Stewart /* No memory so we drop the chunk */ 1908f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_nomem); 1909f8829a4aSRandall Stewart if (last_chunk == 0) { 1910f8829a4aSRandall Stewart /* we copied it, free the copy */ 1911f8829a4aSRandall Stewart sctp_m_freem(dmbuf); 1912f8829a4aSRandall Stewart } 1913f8829a4aSRandall Stewart return (0); 1914f8829a4aSRandall Stewart } 1915f8829a4aSRandall Stewart control->length = the_len; 1916f8829a4aSRandall Stewart } 1917f8829a4aSRandall Stewart 1918f8829a4aSRandall Stewart /* Mark it as received */ 1919f8829a4aSRandall Stewart /* Now queue it where it belongs */ 1920f8829a4aSRandall Stewart if (control != NULL) { 1921f8829a4aSRandall Stewart /* First a sanity check */ 1922f8829a4aSRandall Stewart if (asoc->fragmented_delivery_inprogress) { 1923f8829a4aSRandall Stewart /* 1924f8829a4aSRandall Stewart * Ok, we have a fragmented delivery in progress if 1925f8829a4aSRandall Stewart * this chunk is next to deliver OR belongs in our 1926f8829a4aSRandall Stewart * view to the reassembly, the peer is evil or 1927f8829a4aSRandall Stewart * broken. 1928f8829a4aSRandall Stewart */ 1929f8829a4aSRandall Stewart uint32_t estimate_tsn; 1930f8829a4aSRandall Stewart 1931f8829a4aSRandall Stewart estimate_tsn = asoc->tsn_last_delivered + 1; 1932f8829a4aSRandall Stewart if (TAILQ_EMPTY(&asoc->reasmqueue) && 1933f8829a4aSRandall Stewart (estimate_tsn == control->sinfo_tsn)) { 1934f8829a4aSRandall Stewart /* Evil/Broke peer */ 1935f8829a4aSRandall Stewart sctp_m_freem(control->data); 1936f8829a4aSRandall Stewart control->data = NULL; 1937f8829a4aSRandall Stewart sctp_free_remote_addr(control->whoFrom); 1938f8829a4aSRandall Stewart sctp_free_a_readq(stcb, control); 1939139bc87fSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + 3 * sizeof(uint32_t)), 1940f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 1941f8829a4aSRandall Stewart if (oper) { 1942f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 1943f8829a4aSRandall Stewart uint32_t *ippp; 1944f8829a4aSRandall Stewart 1945139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = 1946f8829a4aSRandall Stewart sizeof(struct sctp_paramhdr) + 1947f8829a4aSRandall Stewart (3 * sizeof(uint32_t)); 1948f8829a4aSRandall Stewart ph = mtod(oper, struct sctp_paramhdr *); 1949f8829a4aSRandall Stewart ph->param_type = 1950f8829a4aSRandall Stewart htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 1951139bc87fSRandall Stewart ph->param_length = htons(SCTP_BUF_LEN(oper)); 1952f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 1953a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_15); 1954f8829a4aSRandall Stewart ippp++; 1955f8829a4aSRandall Stewart *ippp = tsn; 1956f8829a4aSRandall Stewart ippp++; 1957f8829a4aSRandall Stewart *ippp = ((strmno << 16) | strmseq); 1958f8829a4aSRandall Stewart } 1959a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_15; 1960f8829a4aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, stcb, 1961f8829a4aSRandall Stewart SCTP_PEER_FAULTY, oper); 1962f8829a4aSRandall Stewart 1963f8829a4aSRandall Stewart *abort_flag = 1; 1964f8829a4aSRandall Stewart return (0); 1965f8829a4aSRandall Stewart } else { 1966f8829a4aSRandall Stewart if (sctp_does_tsn_belong_to_reasm(asoc, control->sinfo_tsn)) { 1967f8829a4aSRandall Stewart sctp_m_freem(control->data); 1968f8829a4aSRandall Stewart control->data = NULL; 1969f8829a4aSRandall Stewart sctp_free_remote_addr(control->whoFrom); 1970f8829a4aSRandall Stewart sctp_free_a_readq(stcb, control); 1971f8829a4aSRandall Stewart 1972139bc87fSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + 3 * sizeof(uint32_t)), 1973f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 1974f8829a4aSRandall Stewart if (oper) { 1975f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 1976f8829a4aSRandall Stewart uint32_t *ippp; 1977f8829a4aSRandall Stewart 1978139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = 1979f8829a4aSRandall Stewart sizeof(struct sctp_paramhdr) + 1980f8829a4aSRandall Stewart (3 * sizeof(uint32_t)); 1981f8829a4aSRandall Stewart ph = mtod(oper, 1982f8829a4aSRandall Stewart struct sctp_paramhdr *); 1983f8829a4aSRandall Stewart ph->param_type = 1984f8829a4aSRandall Stewart htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 1985f8829a4aSRandall Stewart ph->param_length = 1986139bc87fSRandall Stewart htons(SCTP_BUF_LEN(oper)); 1987f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 1988a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_16); 1989f8829a4aSRandall Stewart ippp++; 1990f8829a4aSRandall Stewart *ippp = tsn; 1991f8829a4aSRandall Stewart ippp++; 1992f8829a4aSRandall Stewart *ippp = ((strmno << 16) | strmseq); 1993f8829a4aSRandall Stewart } 1994a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_16; 1995f8829a4aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, 1996f8829a4aSRandall Stewart stcb, SCTP_PEER_FAULTY, oper); 1997f8829a4aSRandall Stewart 1998f8829a4aSRandall Stewart *abort_flag = 1; 1999f8829a4aSRandall Stewart return (0); 2000f8829a4aSRandall Stewart } 2001f8829a4aSRandall Stewart } 2002f8829a4aSRandall Stewart } else { 2003f8829a4aSRandall Stewart /* No PDAPI running */ 2004f8829a4aSRandall Stewart if (!TAILQ_EMPTY(&asoc->reasmqueue)) { 2005f8829a4aSRandall Stewart /* 2006f8829a4aSRandall Stewart * Reassembly queue is NOT empty validate 2007f8829a4aSRandall Stewart * that this tsn does not need to be in 2008f8829a4aSRandall Stewart * reasembly queue. If it does then our peer 2009f8829a4aSRandall Stewart * is broken or evil. 2010f8829a4aSRandall Stewart */ 2011f8829a4aSRandall Stewart if (sctp_does_tsn_belong_to_reasm(asoc, control->sinfo_tsn)) { 2012f8829a4aSRandall Stewart sctp_m_freem(control->data); 2013f8829a4aSRandall Stewart control->data = NULL; 2014f8829a4aSRandall Stewart sctp_free_remote_addr(control->whoFrom); 2015f8829a4aSRandall Stewart sctp_free_a_readq(stcb, control); 2016139bc87fSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + 3 * sizeof(uint32_t)), 2017f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 2018f8829a4aSRandall Stewart if (oper) { 2019f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 2020f8829a4aSRandall Stewart uint32_t *ippp; 2021f8829a4aSRandall Stewart 2022139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = 2023f8829a4aSRandall Stewart sizeof(struct sctp_paramhdr) + 2024f8829a4aSRandall Stewart (3 * sizeof(uint32_t)); 2025f8829a4aSRandall Stewart ph = mtod(oper, 2026f8829a4aSRandall Stewart struct sctp_paramhdr *); 2027f8829a4aSRandall Stewart ph->param_type = 2028f8829a4aSRandall Stewart htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 2029f8829a4aSRandall Stewart ph->param_length = 2030139bc87fSRandall Stewart htons(SCTP_BUF_LEN(oper)); 2031f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 2032a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_17); 2033f8829a4aSRandall Stewart ippp++; 2034f8829a4aSRandall Stewart *ippp = tsn; 2035f8829a4aSRandall Stewart ippp++; 2036f8829a4aSRandall Stewart *ippp = ((strmno << 16) | strmseq); 2037f8829a4aSRandall Stewart } 2038a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_17; 2039f8829a4aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, 2040f8829a4aSRandall Stewart stcb, SCTP_PEER_FAULTY, oper); 2041f8829a4aSRandall Stewart 2042f8829a4aSRandall Stewart *abort_flag = 1; 2043f8829a4aSRandall Stewart return (0); 2044f8829a4aSRandall Stewart } 2045f8829a4aSRandall Stewart } 2046f8829a4aSRandall Stewart } 2047f8829a4aSRandall Stewart /* ok, if we reach here we have passed the sanity checks */ 2048f42a358aSRandall Stewart if (chunk_flags & SCTP_DATA_UNORDERED) { 2049f8829a4aSRandall Stewart /* queue directly into socket buffer */ 2050f8829a4aSRandall Stewart sctp_add_to_readq(stcb->sctp_ep, stcb, 2051f8829a4aSRandall Stewart control, 2052f8829a4aSRandall Stewart &stcb->sctp_socket->so_rcv, 1); 2053f8829a4aSRandall Stewart } else { 2054f8829a4aSRandall Stewart /* 2055f8829a4aSRandall Stewart * Special check for when streams are resetting. We 2056f8829a4aSRandall Stewart * could be more smart about this and check the 2057f8829a4aSRandall Stewart * actual stream to see if it is not being reset.. 2058f8829a4aSRandall Stewart * that way we would not create a HOLB when amongst 2059f8829a4aSRandall Stewart * streams being reset and those not being reset. 2060f8829a4aSRandall Stewart * 2061f8829a4aSRandall Stewart * We take complete messages that have a stream reset 2062f8829a4aSRandall Stewart * intervening (aka the TSN is after where our 2063f8829a4aSRandall Stewart * cum-ack needs to be) off and put them on a 2064f8829a4aSRandall Stewart * pending_reply_queue. The reassembly ones we do 2065f8829a4aSRandall Stewart * not have to worry about since they are all sorted 2066f8829a4aSRandall Stewart * and proceessed by TSN order. It is only the 2067f8829a4aSRandall Stewart * singletons I must worry about. 2068f8829a4aSRandall Stewart */ 2069f8829a4aSRandall Stewart struct sctp_stream_reset_list *liste; 2070f8829a4aSRandall Stewart 2071f8829a4aSRandall Stewart if (((liste = TAILQ_FIRST(&asoc->resetHead)) != NULL) && 2072d06c82f1SRandall Stewart ((compare_with_wrap(tsn, ntohl(liste->tsn), MAX_TSN)) || 2073f8829a4aSRandall Stewart (tsn == ntohl(liste->tsn))) 2074f8829a4aSRandall Stewart ) { 2075f8829a4aSRandall Stewart /* 2076f8829a4aSRandall Stewart * yep its past where we need to reset... go 2077f8829a4aSRandall Stewart * ahead and queue it. 2078f8829a4aSRandall Stewart */ 2079f8829a4aSRandall Stewart if (TAILQ_EMPTY(&asoc->pending_reply_queue)) { 2080f8829a4aSRandall Stewart /* first one on */ 2081f8829a4aSRandall Stewart TAILQ_INSERT_TAIL(&asoc->pending_reply_queue, control, next); 2082f8829a4aSRandall Stewart } else { 2083f8829a4aSRandall Stewart struct sctp_queued_to_read *ctlOn; 2084f8829a4aSRandall Stewart unsigned char inserted = 0; 2085f8829a4aSRandall Stewart 2086f8829a4aSRandall Stewart ctlOn = TAILQ_FIRST(&asoc->pending_reply_queue); 2087f8829a4aSRandall Stewart while (ctlOn) { 2088f8829a4aSRandall Stewart if (compare_with_wrap(control->sinfo_tsn, 2089f8829a4aSRandall Stewart ctlOn->sinfo_tsn, MAX_TSN)) { 2090f8829a4aSRandall Stewart ctlOn = TAILQ_NEXT(ctlOn, next); 2091f8829a4aSRandall Stewart } else { 2092f8829a4aSRandall Stewart /* found it */ 2093f8829a4aSRandall Stewart TAILQ_INSERT_BEFORE(ctlOn, control, next); 2094f8829a4aSRandall Stewart inserted = 1; 2095f8829a4aSRandall Stewart break; 2096f8829a4aSRandall Stewart } 2097f8829a4aSRandall Stewart } 2098f8829a4aSRandall Stewart if (inserted == 0) { 2099f8829a4aSRandall Stewart /* 2100f8829a4aSRandall Stewart * must be put at end, use 2101f8829a4aSRandall Stewart * prevP (all setup from 2102f8829a4aSRandall Stewart * loop) to setup nextP. 2103f8829a4aSRandall Stewart */ 2104f8829a4aSRandall Stewart TAILQ_INSERT_TAIL(&asoc->pending_reply_queue, control, next); 2105f8829a4aSRandall Stewart } 2106f8829a4aSRandall Stewart } 2107f8829a4aSRandall Stewart } else { 2108f8829a4aSRandall Stewart sctp_queue_data_to_stream(stcb, asoc, control, abort_flag); 2109f8829a4aSRandall Stewart if (*abort_flag) { 2110f8829a4aSRandall Stewart return (0); 2111f8829a4aSRandall Stewart } 2112f8829a4aSRandall Stewart } 2113f8829a4aSRandall Stewart } 2114f8829a4aSRandall Stewart } else { 2115f8829a4aSRandall Stewart /* Into the re-assembly queue */ 2116f8829a4aSRandall Stewart sctp_queue_data_for_reasm(stcb, asoc, chk, abort_flag); 2117f8829a4aSRandall Stewart if (*abort_flag) { 2118a5d547adSRandall Stewart /* 2119a5d547adSRandall Stewart * the assoc is now gone and chk was put onto the 2120a5d547adSRandall Stewart * reasm queue, which has all been freed. 2121a5d547adSRandall Stewart */ 2122a5d547adSRandall Stewart *m = NULL; 2123f8829a4aSRandall Stewart return (0); 2124f8829a4aSRandall Stewart } 2125f8829a4aSRandall Stewart } 2126f8829a4aSRandall Stewart finish_express_del: 2127f8829a4aSRandall Stewart if (compare_with_wrap(tsn, asoc->highest_tsn_inside_map, MAX_TSN)) { 2128f8829a4aSRandall Stewart /* we have a new high score */ 2129f8829a4aSRandall Stewart asoc->highest_tsn_inside_map = tsn; 2130f8829a4aSRandall Stewart #ifdef SCTP_MAP_LOGGING 2131f8829a4aSRandall Stewart sctp_log_map(0, 2, asoc->highest_tsn_inside_map, SCTP_MAP_SLIDE_RESULT); 2132f8829a4aSRandall Stewart #endif 2133f8829a4aSRandall Stewart } 2134f8829a4aSRandall Stewart if (tsn == (asoc->cumulative_tsn + 1)) { 2135f8829a4aSRandall Stewart /* Update cum-ack */ 2136f8829a4aSRandall Stewart asoc->cumulative_tsn = tsn; 2137f8829a4aSRandall Stewart } 2138f8829a4aSRandall Stewart if (last_chunk) { 2139f8829a4aSRandall Stewart *m = NULL; 2140f8829a4aSRandall Stewart } 2141f42a358aSRandall Stewart if (ordered) { 2142f8829a4aSRandall Stewart SCTP_STAT_INCR_COUNTER64(sctps_inorderchunks); 2143f8829a4aSRandall Stewart } else { 2144f8829a4aSRandall Stewart SCTP_STAT_INCR_COUNTER64(sctps_inunorderchunks); 2145f8829a4aSRandall Stewart } 2146f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_recvdata); 2147f8829a4aSRandall Stewart /* Set it present please */ 2148f8829a4aSRandall Stewart #ifdef SCTP_STR_LOGGING 21496a91f103SRandall Stewart sctp_log_strm_del_alt(stcb, tsn, strmseq, strmno, SCTP_STR_LOG_FROM_MARK_TSN); 2150f8829a4aSRandall Stewart #endif 2151f8829a4aSRandall Stewart #ifdef SCTP_MAP_LOGGING 2152f8829a4aSRandall Stewart sctp_log_map(asoc->mapping_array_base_tsn, asoc->cumulative_tsn, 2153f8829a4aSRandall Stewart asoc->highest_tsn_inside_map, SCTP_MAP_PREPARE_SLIDE); 2154f8829a4aSRandall Stewart #endif 2155f8829a4aSRandall Stewart SCTP_SET_TSN_PRESENT(asoc->mapping_array, gap); 215617205eccSRandall Stewart /* check the special flag for stream resets */ 215717205eccSRandall Stewart if (((liste = TAILQ_FIRST(&asoc->resetHead)) != NULL) && 215817205eccSRandall Stewart ((compare_with_wrap(asoc->cumulative_tsn, ntohl(liste->tsn), MAX_TSN)) || 215917205eccSRandall Stewart (asoc->cumulative_tsn == ntohl(liste->tsn))) 216017205eccSRandall Stewart ) { 216117205eccSRandall Stewart /* 216217205eccSRandall Stewart * we have finished working through the backlogged TSN's now 216317205eccSRandall Stewart * time to reset streams. 1: call reset function. 2: free 216417205eccSRandall Stewart * pending_reply space 3: distribute any chunks in 216517205eccSRandall Stewart * pending_reply_queue. 216617205eccSRandall Stewart */ 216717205eccSRandall Stewart struct sctp_queued_to_read *ctl; 216817205eccSRandall Stewart 216917205eccSRandall Stewart sctp_reset_in_stream(stcb, liste->number_entries, liste->req.list_of_streams); 217017205eccSRandall Stewart TAILQ_REMOVE(&asoc->resetHead, liste, next_resp); 217117205eccSRandall Stewart SCTP_FREE(liste); 217217205eccSRandall Stewart liste = TAILQ_FIRST(&asoc->resetHead); 217317205eccSRandall Stewart ctl = TAILQ_FIRST(&asoc->pending_reply_queue); 217417205eccSRandall Stewart if (ctl && (liste == NULL)) { 217517205eccSRandall Stewart /* All can be removed */ 217617205eccSRandall Stewart while (ctl) { 217717205eccSRandall Stewart TAILQ_REMOVE(&asoc->pending_reply_queue, ctl, next); 217817205eccSRandall Stewart sctp_queue_data_to_stream(stcb, asoc, ctl, abort_flag); 217917205eccSRandall Stewart if (*abort_flag) { 218017205eccSRandall Stewart return (0); 218117205eccSRandall Stewart } 218217205eccSRandall Stewart ctl = TAILQ_FIRST(&asoc->pending_reply_queue); 218317205eccSRandall Stewart } 218417205eccSRandall Stewart } else if (ctl) { 218517205eccSRandall Stewart /* more than one in queue */ 218617205eccSRandall Stewart while (!compare_with_wrap(ctl->sinfo_tsn, ntohl(liste->tsn), MAX_TSN)) { 218717205eccSRandall Stewart /* 218817205eccSRandall Stewart * if ctl->sinfo_tsn is <= liste->tsn we can 218917205eccSRandall Stewart * process it which is the NOT of 219017205eccSRandall Stewart * ctl->sinfo_tsn > liste->tsn 219117205eccSRandall Stewart */ 219217205eccSRandall Stewart TAILQ_REMOVE(&asoc->pending_reply_queue, ctl, next); 219317205eccSRandall Stewart sctp_queue_data_to_stream(stcb, asoc, ctl, abort_flag); 219417205eccSRandall Stewart if (*abort_flag) { 219517205eccSRandall Stewart return (0); 219617205eccSRandall Stewart } 219717205eccSRandall Stewart ctl = TAILQ_FIRST(&asoc->pending_reply_queue); 219817205eccSRandall Stewart } 219917205eccSRandall Stewart } 220017205eccSRandall Stewart /* 220117205eccSRandall Stewart * Now service re-assembly to pick up anything that has been 220217205eccSRandall Stewart * held on reassembly queue? 220317205eccSRandall Stewart */ 220417205eccSRandall Stewart sctp_deliver_reasm_check(stcb, asoc); 220517205eccSRandall Stewart need_reasm_check = 0; 220617205eccSRandall Stewart } 2207139bc87fSRandall Stewart if (need_reasm_check) { 2208139bc87fSRandall Stewart /* Another one waits ? */ 2209139bc87fSRandall Stewart sctp_deliver_reasm_check(stcb, asoc); 2210139bc87fSRandall Stewart } 2211f8829a4aSRandall Stewart return (1); 2212f8829a4aSRandall Stewart } 2213f8829a4aSRandall Stewart 2214f8829a4aSRandall Stewart int8_t sctp_map_lookup_tab[256] = { 2215f8829a4aSRandall Stewart -1, 0, -1, 1, -1, 0, -1, 2, 2216f8829a4aSRandall Stewart -1, 0, -1, 1, -1, 0, -1, 3, 2217f8829a4aSRandall Stewart -1, 0, -1, 1, -1, 0, -1, 2, 2218f8829a4aSRandall Stewart -1, 0, -1, 1, -1, 0, -1, 4, 2219f8829a4aSRandall Stewart -1, 0, -1, 1, -1, 0, -1, 2, 2220f8829a4aSRandall Stewart -1, 0, -1, 1, -1, 0, -1, 3, 2221f8829a4aSRandall Stewart -1, 0, -1, 1, -1, 0, -1, 2, 2222f8829a4aSRandall Stewart -1, 0, -1, 1, -1, 0, -1, 5, 2223f8829a4aSRandall Stewart -1, 0, -1, 1, -1, 0, -1, 2, 2224f8829a4aSRandall Stewart -1, 0, -1, 1, -1, 0, -1, 3, 2225f8829a4aSRandall Stewart -1, 0, -1, 1, -1, 0, -1, 2, 2226f8829a4aSRandall Stewart -1, 0, -1, 1, -1, 0, -1, 4, 2227f8829a4aSRandall Stewart -1, 0, -1, 1, -1, 0, -1, 2, 2228f8829a4aSRandall Stewart -1, 0, -1, 1, -1, 0, -1, 3, 2229f8829a4aSRandall Stewart -1, 0, -1, 1, -1, 0, -1, 2, 2230f8829a4aSRandall Stewart -1, 0, -1, 1, -1, 0, -1, 6, 2231f8829a4aSRandall Stewart -1, 0, -1, 1, -1, 0, -1, 2, 2232f8829a4aSRandall Stewart -1, 0, -1, 1, -1, 0, -1, 3, 2233f8829a4aSRandall Stewart -1, 0, -1, 1, -1, 0, -1, 2, 2234f8829a4aSRandall Stewart -1, 0, -1, 1, -1, 0, -1, 4, 2235f8829a4aSRandall Stewart -1, 0, -1, 1, -1, 0, -1, 2, 2236f8829a4aSRandall Stewart -1, 0, -1, 1, -1, 0, -1, 3, 2237f8829a4aSRandall Stewart -1, 0, -1, 1, -1, 0, -1, 2, 2238f8829a4aSRandall Stewart -1, 0, -1, 1, -1, 0, -1, 5, 2239f8829a4aSRandall Stewart -1, 0, -1, 1, -1, 0, -1, 2, 2240f8829a4aSRandall Stewart -1, 0, -1, 1, -1, 0, -1, 3, 2241f8829a4aSRandall Stewart -1, 0, -1, 1, -1, 0, -1, 2, 2242f8829a4aSRandall Stewart -1, 0, -1, 1, -1, 0, -1, 4, 2243f8829a4aSRandall Stewart -1, 0, -1, 1, -1, 0, -1, 2, 2244f8829a4aSRandall Stewart -1, 0, -1, 1, -1, 0, -1, 3, 2245f8829a4aSRandall Stewart -1, 0, -1, 1, -1, 0, -1, 2, 2246f8829a4aSRandall Stewart -1, 0, -1, 1, -1, 0, -1, 7, 2247f8829a4aSRandall Stewart }; 2248f8829a4aSRandall Stewart 2249f8829a4aSRandall Stewart 2250f8829a4aSRandall Stewart void 2251f8829a4aSRandall Stewart sctp_sack_check(struct sctp_tcb *stcb, int ok_to_sack, int was_a_gap, int *abort_flag) 2252f8829a4aSRandall Stewart { 2253f8829a4aSRandall Stewart /* 2254f8829a4aSRandall Stewart * Now we also need to check the mapping array in a couple of ways. 2255f8829a4aSRandall Stewart * 1) Did we move the cum-ack point? 2256f8829a4aSRandall Stewart */ 2257f8829a4aSRandall Stewart struct sctp_association *asoc; 2258f8829a4aSRandall Stewart int i, at; 225993164cf9SRandall Stewart int all_ones, last_all_ones = 0; 2260f8829a4aSRandall Stewart int slide_from, slide_end, lgap, distance; 2261f8829a4aSRandall Stewart 2262f8829a4aSRandall Stewart #ifdef SCTP_MAP_LOGGING 2263f8829a4aSRandall Stewart uint32_t old_cumack, old_base, old_highest; 2264f8829a4aSRandall Stewart unsigned char aux_array[64]; 2265f8829a4aSRandall Stewart 2266f8829a4aSRandall Stewart #endif 2267f8829a4aSRandall Stewart 2268f8829a4aSRandall Stewart asoc = &stcb->asoc; 2269f8829a4aSRandall Stewart at = 0; 2270f8829a4aSRandall Stewart 2271f8829a4aSRandall Stewart #ifdef SCTP_MAP_LOGGING 2272f8829a4aSRandall Stewart old_cumack = asoc->cumulative_tsn; 2273f8829a4aSRandall Stewart old_base = asoc->mapping_array_base_tsn; 2274f8829a4aSRandall Stewart old_highest = asoc->highest_tsn_inside_map; 2275f8829a4aSRandall Stewart if (asoc->mapping_array_size < 64) 2276f8829a4aSRandall Stewart memcpy(aux_array, asoc->mapping_array, 2277f8829a4aSRandall Stewart asoc->mapping_array_size); 2278f8829a4aSRandall Stewart else 2279f8829a4aSRandall Stewart memcpy(aux_array, asoc->mapping_array, 64); 2280f8829a4aSRandall Stewart #endif 2281f8829a4aSRandall Stewart 2282f8829a4aSRandall Stewart /* 2283f8829a4aSRandall Stewart * We could probably improve this a small bit by calculating the 2284f8829a4aSRandall Stewart * offset of the current cum-ack as the starting point. 2285f8829a4aSRandall Stewart */ 2286f8829a4aSRandall Stewart all_ones = 1; 2287f8829a4aSRandall Stewart at = 0; 2288f8829a4aSRandall Stewart for (i = 0; i < stcb->asoc.mapping_array_size; i++) { 2289d06c82f1SRandall Stewart 2290f8829a4aSRandall Stewart if (asoc->mapping_array[i] == 0xff) { 2291f8829a4aSRandall Stewart at += 8; 229293164cf9SRandall Stewart last_all_ones = 1; 2293f8829a4aSRandall Stewart } else { 2294f8829a4aSRandall Stewart /* there is a 0 bit */ 2295f8829a4aSRandall Stewart all_ones = 0; 2296f8829a4aSRandall Stewart at += sctp_map_lookup_tab[asoc->mapping_array[i]]; 229793164cf9SRandall Stewart last_all_ones = 0; 2298f8829a4aSRandall Stewart break; 2299f8829a4aSRandall Stewart } 2300f8829a4aSRandall Stewart } 230193164cf9SRandall Stewart asoc->cumulative_tsn = asoc->mapping_array_base_tsn + (at - last_all_ones); 2302f8829a4aSRandall Stewart /* at is one off, since in the table a embedded -1 is present */ 2303f8829a4aSRandall Stewart at++; 2304f8829a4aSRandall Stewart 2305f8829a4aSRandall Stewart if (compare_with_wrap(asoc->cumulative_tsn, 2306f8829a4aSRandall Stewart asoc->highest_tsn_inside_map, 2307f8829a4aSRandall Stewart MAX_TSN)) { 2308a5d547adSRandall Stewart #ifdef INVARIANTS 2309f8829a4aSRandall Stewart panic("huh, cumack greater than high-tsn in map"); 2310f8829a4aSRandall Stewart #else 2311f8829a4aSRandall Stewart printf("huh, cumack greater than high-tsn in map - should panic?\n"); 2312f8829a4aSRandall Stewart asoc->highest_tsn_inside_map = asoc->cumulative_tsn; 2313f8829a4aSRandall Stewart #endif 2314f8829a4aSRandall Stewart } 2315f8829a4aSRandall Stewart if (all_ones || 2316f8829a4aSRandall Stewart (asoc->cumulative_tsn == asoc->highest_tsn_inside_map && at >= 8)) { 2317f8829a4aSRandall Stewart /* The complete array was completed by a single FR */ 2318f8829a4aSRandall Stewart /* higest becomes the cum-ack */ 2319f8829a4aSRandall Stewart int clr; 2320f8829a4aSRandall Stewart 2321f8829a4aSRandall Stewart asoc->cumulative_tsn = asoc->highest_tsn_inside_map; 2322f8829a4aSRandall Stewart /* clear the array */ 2323f8829a4aSRandall Stewart if (all_ones) 2324f8829a4aSRandall Stewart clr = asoc->mapping_array_size; 2325f8829a4aSRandall Stewart else { 2326f8829a4aSRandall Stewart clr = (at >> 3) + 1; 2327f8829a4aSRandall Stewart /* 2328f8829a4aSRandall Stewart * this should be the allones case but just in case 2329f8829a4aSRandall Stewart * :> 2330f8829a4aSRandall Stewart */ 2331f8829a4aSRandall Stewart if (clr > asoc->mapping_array_size) 2332f8829a4aSRandall Stewart clr = asoc->mapping_array_size; 2333f8829a4aSRandall Stewart } 2334f8829a4aSRandall Stewart memset(asoc->mapping_array, 0, clr); 2335f8829a4aSRandall Stewart /* base becomes one ahead of the cum-ack */ 2336f8829a4aSRandall Stewart asoc->mapping_array_base_tsn = asoc->cumulative_tsn + 1; 2337f8829a4aSRandall Stewart #ifdef SCTP_MAP_LOGGING 2338f8829a4aSRandall Stewart sctp_log_map(old_base, old_cumack, old_highest, 2339f8829a4aSRandall Stewart SCTP_MAP_PREPARE_SLIDE); 2340f8829a4aSRandall Stewart sctp_log_map(asoc->mapping_array_base_tsn, asoc->cumulative_tsn, 2341f8829a4aSRandall Stewart asoc->highest_tsn_inside_map, SCTP_MAP_SLIDE_CLEARED); 2342f8829a4aSRandall Stewart #endif 2343f8829a4aSRandall Stewart } else if (at >= 8) { 2344f8829a4aSRandall Stewart /* we can slide the mapping array down */ 2345f8829a4aSRandall Stewart /* Calculate the new byte postion we can move down */ 2346f8829a4aSRandall Stewart slide_from = at >> 3; 2347f8829a4aSRandall Stewart /* 2348f8829a4aSRandall Stewart * now calculate the ceiling of the move using our highest 2349f8829a4aSRandall Stewart * TSN value 2350f8829a4aSRandall Stewart */ 2351f8829a4aSRandall Stewart if (asoc->highest_tsn_inside_map >= asoc->mapping_array_base_tsn) { 2352f8829a4aSRandall Stewart lgap = asoc->highest_tsn_inside_map - 2353f8829a4aSRandall Stewart asoc->mapping_array_base_tsn; 2354f8829a4aSRandall Stewart } else { 2355f8829a4aSRandall Stewart lgap = (MAX_TSN - asoc->mapping_array_base_tsn) + 2356f8829a4aSRandall Stewart asoc->highest_tsn_inside_map + 1; 2357f8829a4aSRandall Stewart } 2358f8829a4aSRandall Stewart slide_end = lgap >> 3; 2359f8829a4aSRandall Stewart if (slide_end < slide_from) { 2360f8829a4aSRandall Stewart panic("impossible slide"); 2361f8829a4aSRandall Stewart } 2362f8829a4aSRandall Stewart distance = (slide_end - slide_from) + 1; 2363f8829a4aSRandall Stewart #ifdef SCTP_MAP_LOGGING 2364f8829a4aSRandall Stewart sctp_log_map(old_base, old_cumack, old_highest, 2365f8829a4aSRandall Stewart SCTP_MAP_PREPARE_SLIDE); 2366f8829a4aSRandall Stewart sctp_log_map((uint32_t) slide_from, (uint32_t) slide_end, 2367f8829a4aSRandall Stewart (uint32_t) lgap, SCTP_MAP_SLIDE_FROM); 2368f8829a4aSRandall Stewart #endif 2369f8829a4aSRandall Stewart if (distance + slide_from > asoc->mapping_array_size || 2370f8829a4aSRandall Stewart distance < 0) { 2371f8829a4aSRandall Stewart /* 2372f8829a4aSRandall Stewart * Here we do NOT slide forward the array so that 2373f8829a4aSRandall Stewart * hopefully when more data comes in to fill it up 2374f8829a4aSRandall Stewart * we will be able to slide it forward. Really I 2375f8829a4aSRandall Stewart * don't think this should happen :-0 2376f8829a4aSRandall Stewart */ 2377f8829a4aSRandall Stewart 2378f8829a4aSRandall Stewart #ifdef SCTP_MAP_LOGGING 2379f8829a4aSRandall Stewart sctp_log_map((uint32_t) distance, (uint32_t) slide_from, 2380f8829a4aSRandall Stewart (uint32_t) asoc->mapping_array_size, 2381f8829a4aSRandall Stewart SCTP_MAP_SLIDE_NONE); 2382f8829a4aSRandall Stewart #endif 2383f8829a4aSRandall Stewart } else { 2384f8829a4aSRandall Stewart int ii; 2385f8829a4aSRandall Stewart 2386f8829a4aSRandall Stewart for (ii = 0; ii < distance; ii++) { 2387f8829a4aSRandall Stewart asoc->mapping_array[ii] = 2388f8829a4aSRandall Stewart asoc->mapping_array[slide_from + ii]; 2389f8829a4aSRandall Stewart } 2390f8829a4aSRandall Stewart for (ii = distance; ii <= slide_end; ii++) { 2391f8829a4aSRandall Stewart asoc->mapping_array[ii] = 0; 2392f8829a4aSRandall Stewart } 2393f8829a4aSRandall Stewart asoc->mapping_array_base_tsn += (slide_from << 3); 2394f8829a4aSRandall Stewart #ifdef SCTP_MAP_LOGGING 2395f8829a4aSRandall Stewart sctp_log_map(asoc->mapping_array_base_tsn, 2396f8829a4aSRandall Stewart asoc->cumulative_tsn, asoc->highest_tsn_inside_map, 2397f8829a4aSRandall Stewart SCTP_MAP_SLIDE_RESULT); 2398f8829a4aSRandall Stewart #endif 2399f8829a4aSRandall Stewart } 2400f8829a4aSRandall Stewart } 2401f8829a4aSRandall Stewart /* 2402f8829a4aSRandall Stewart * Now we need to see if we need to queue a sack or just start the 2403f8829a4aSRandall Stewart * timer (if allowed). 2404f8829a4aSRandall Stewart */ 2405f8829a4aSRandall Stewart if (ok_to_sack) { 2406f8829a4aSRandall Stewart if (SCTP_GET_STATE(asoc) == SCTP_STATE_SHUTDOWN_SENT) { 2407f8829a4aSRandall Stewart /* 2408f8829a4aSRandall Stewart * Ok special case, in SHUTDOWN-SENT case. here we 2409f8829a4aSRandall Stewart * maker sure SACK timer is off and instead send a 2410f8829a4aSRandall Stewart * SHUTDOWN and a SACK 2411f8829a4aSRandall Stewart */ 2412139bc87fSRandall Stewart if (SCTP_OS_TIMER_PENDING(&stcb->asoc.dack_timer.timer)) { 2413f8829a4aSRandall Stewart sctp_timer_stop(SCTP_TIMER_TYPE_RECV, 2414a5d547adSRandall Stewart stcb->sctp_ep, stcb, NULL, SCTP_FROM_SCTP_INDATA + SCTP_LOC_18); 2415f8829a4aSRandall Stewart } 2416f8829a4aSRandall Stewart sctp_send_shutdown(stcb, stcb->asoc.primary_destination); 2417f8829a4aSRandall Stewart sctp_send_sack(stcb); 2418f8829a4aSRandall Stewart } else { 2419f8829a4aSRandall Stewart int is_a_gap; 2420f8829a4aSRandall Stewart 2421f8829a4aSRandall Stewart /* is there a gap now ? */ 2422f8829a4aSRandall Stewart is_a_gap = compare_with_wrap(stcb->asoc.highest_tsn_inside_map, 2423f8829a4aSRandall Stewart stcb->asoc.cumulative_tsn, MAX_TSN); 2424f8829a4aSRandall Stewart 2425f8829a4aSRandall Stewart /* 2426f8829a4aSRandall Stewart * CMT DAC algorithm: increase number of packets 2427f8829a4aSRandall Stewart * received since last ack 2428f8829a4aSRandall Stewart */ 2429f8829a4aSRandall Stewart stcb->asoc.cmt_dac_pkts_rcvd++; 2430f8829a4aSRandall Stewart 243142551e99SRandall Stewart if ((stcb->asoc.send_sack == 1) || /* We need to send a 243242551e99SRandall Stewart * SACK */ 2433f8829a4aSRandall Stewart ((was_a_gap) && (is_a_gap == 0)) || /* was a gap, but no 2434f8829a4aSRandall Stewart * longer is one */ 2435f8829a4aSRandall Stewart (stcb->asoc.numduptsns) || /* we have dup's */ 2436f8829a4aSRandall Stewart (is_a_gap) || /* is still a gap */ 243742551e99SRandall Stewart (stcb->asoc.delayed_ack == 0) || /* Delayed sack disabled */ 243842551e99SRandall Stewart (stcb->asoc.data_pkts_seen >= stcb->asoc.sack_freq) /* hit limit of pkts */ 2439f8829a4aSRandall Stewart ) { 2440f8829a4aSRandall Stewart 2441f8829a4aSRandall Stewart if ((sctp_cmt_on_off) && (sctp_cmt_use_dac) && 244242551e99SRandall Stewart (stcb->asoc.send_sack == 0) && 2443f8829a4aSRandall Stewart (stcb->asoc.numduptsns == 0) && 2444f8829a4aSRandall Stewart (stcb->asoc.delayed_ack) && 2445139bc87fSRandall Stewart (!SCTP_OS_TIMER_PENDING(&stcb->asoc.dack_timer.timer))) { 2446f8829a4aSRandall Stewart 2447f8829a4aSRandall Stewart /* 2448f8829a4aSRandall Stewart * CMT DAC algorithm: With CMT, 2449f8829a4aSRandall Stewart * delay acks even in the face of 2450f8829a4aSRandall Stewart * 2451f8829a4aSRandall Stewart * reordering. Therefore, if acks that 2452f8829a4aSRandall Stewart * do not have to be sent because of 2453f8829a4aSRandall Stewart * the above reasons, will be 2454f8829a4aSRandall Stewart * delayed. That is, acks that would 2455f8829a4aSRandall Stewart * have been sent due to gap reports 2456f8829a4aSRandall Stewart * will be delayed with DAC. Start 2457f8829a4aSRandall Stewart * the delayed ack timer. 2458f8829a4aSRandall Stewart */ 2459f8829a4aSRandall Stewart sctp_timer_start(SCTP_TIMER_TYPE_RECV, 2460f8829a4aSRandall Stewart stcb->sctp_ep, stcb, NULL); 2461f8829a4aSRandall Stewart } else { 2462f8829a4aSRandall Stewart /* 2463f8829a4aSRandall Stewart * Ok we must build a SACK since the 2464f8829a4aSRandall Stewart * timer is pending, we got our 2465f8829a4aSRandall Stewart * first packet OR there are gaps or 2466f8829a4aSRandall Stewart * duplicates. 2467f8829a4aSRandall Stewart */ 2468f42a358aSRandall Stewart SCTP_OS_TIMER_STOP(&stcb->asoc.dack_timer.timer); 2469f8829a4aSRandall Stewart sctp_send_sack(stcb); 2470f8829a4aSRandall Stewart } 2471f8829a4aSRandall Stewart } else { 247242551e99SRandall Stewart if (!SCTP_OS_TIMER_PENDING(&stcb->asoc.dack_timer.timer)) { 2473f8829a4aSRandall Stewart sctp_timer_start(SCTP_TIMER_TYPE_RECV, 2474f8829a4aSRandall Stewart stcb->sctp_ep, stcb, NULL); 2475f8829a4aSRandall Stewart } 2476f8829a4aSRandall Stewart } 2477f8829a4aSRandall Stewart } 2478f8829a4aSRandall Stewart } 247942551e99SRandall Stewart } 2480f8829a4aSRandall Stewart 2481f8829a4aSRandall Stewart void 2482f8829a4aSRandall Stewart sctp_service_queues(struct sctp_tcb *stcb, struct sctp_association *asoc) 2483f8829a4aSRandall Stewart { 2484f8829a4aSRandall Stewart struct sctp_tmit_chunk *chk; 2485f8829a4aSRandall Stewart uint32_t tsize; 2486f8829a4aSRandall Stewart uint16_t nxt_todel; 2487f8829a4aSRandall Stewart 2488f8829a4aSRandall Stewart if (asoc->fragmented_delivery_inprogress) { 2489f8829a4aSRandall Stewart sctp_service_reassembly(stcb, asoc); 2490f8829a4aSRandall Stewart } 2491f8829a4aSRandall Stewart /* Can we proceed further, i.e. the PD-API is complete */ 2492f8829a4aSRandall Stewart if (asoc->fragmented_delivery_inprogress) { 2493f8829a4aSRandall Stewart /* no */ 2494f8829a4aSRandall Stewart return; 2495f8829a4aSRandall Stewart } 2496f8829a4aSRandall Stewart /* 2497f8829a4aSRandall Stewart * Now is there some other chunk I can deliver from the reassembly 2498f8829a4aSRandall Stewart * queue. 2499f8829a4aSRandall Stewart */ 2500139bc87fSRandall Stewart doit_again: 2501f8829a4aSRandall Stewart chk = TAILQ_FIRST(&asoc->reasmqueue); 2502f8829a4aSRandall Stewart if (chk == NULL) { 2503f8829a4aSRandall Stewart asoc->size_on_reasm_queue = 0; 2504f8829a4aSRandall Stewart asoc->cnt_on_reasm_queue = 0; 2505f8829a4aSRandall Stewart return; 2506f8829a4aSRandall Stewart } 2507f8829a4aSRandall Stewart nxt_todel = asoc->strmin[chk->rec.data.stream_number].last_sequence_delivered + 1; 2508f8829a4aSRandall Stewart if ((chk->rec.data.rcv_flags & SCTP_DATA_FIRST_FRAG) && 2509f8829a4aSRandall Stewart ((nxt_todel == chk->rec.data.stream_seq) || 2510f8829a4aSRandall Stewart (chk->rec.data.rcv_flags & SCTP_DATA_UNORDERED))) { 2511f8829a4aSRandall Stewart /* 2512f8829a4aSRandall Stewart * Yep the first one is here. We setup to start reception, 2513f8829a4aSRandall Stewart * by backing down the TSN just in case we can't deliver. 2514f8829a4aSRandall Stewart */ 2515f8829a4aSRandall Stewart 2516f8829a4aSRandall Stewart /* 2517f8829a4aSRandall Stewart * Before we start though either all of the message should 2518f8829a4aSRandall Stewart * be here or 1/4 the socket buffer max or nothing on the 2519f8829a4aSRandall Stewart * delivery queue and something can be delivered. 2520f8829a4aSRandall Stewart */ 2521f8829a4aSRandall Stewart if ((sctp_is_all_msg_on_reasm(asoc, &tsize) || 2522f8829a4aSRandall Stewart (tsize > stcb->sctp_ep->partial_delivery_point))) { 2523f8829a4aSRandall Stewart asoc->fragmented_delivery_inprogress = 1; 2524f8829a4aSRandall Stewart asoc->tsn_last_delivered = chk->rec.data.TSN_seq - 1; 2525f8829a4aSRandall Stewart asoc->str_of_pdapi = chk->rec.data.stream_number; 2526f8829a4aSRandall Stewart asoc->ssn_of_pdapi = chk->rec.data.stream_seq; 2527f8829a4aSRandall Stewart asoc->pdapi_ppid = chk->rec.data.payloadtype; 2528f8829a4aSRandall Stewart asoc->fragment_flags = chk->rec.data.rcv_flags; 2529f8829a4aSRandall Stewart sctp_service_reassembly(stcb, asoc); 2530139bc87fSRandall Stewart if (asoc->fragmented_delivery_inprogress == 0) { 2531139bc87fSRandall Stewart goto doit_again; 2532139bc87fSRandall Stewart } 2533f8829a4aSRandall Stewart } 2534f8829a4aSRandall Stewart } 2535f8829a4aSRandall Stewart } 2536f8829a4aSRandall Stewart 2537f8829a4aSRandall Stewart int 2538f8829a4aSRandall Stewart sctp_process_data(struct mbuf **mm, int iphlen, int *offset, int length, 2539f8829a4aSRandall Stewart struct sctphdr *sh, struct sctp_inpcb *inp, struct sctp_tcb *stcb, 2540f8829a4aSRandall Stewart struct sctp_nets *net, uint32_t * high_tsn) 2541f8829a4aSRandall Stewart { 2542f8829a4aSRandall Stewart struct sctp_data_chunk *ch, chunk_buf; 2543f8829a4aSRandall Stewart struct sctp_association *asoc; 2544f8829a4aSRandall Stewart int num_chunks = 0; /* number of control chunks processed */ 2545f8829a4aSRandall Stewart int stop_proc = 0; 2546f8829a4aSRandall Stewart int chk_length, break_flag, last_chunk; 2547f8829a4aSRandall Stewart int abort_flag = 0, was_a_gap = 0; 2548f8829a4aSRandall Stewart struct mbuf *m; 2549f8829a4aSRandall Stewart 2550f8829a4aSRandall Stewart /* set the rwnd */ 2551f8829a4aSRandall Stewart sctp_set_rwnd(stcb, &stcb->asoc); 2552f8829a4aSRandall Stewart 2553f8829a4aSRandall Stewart m = *mm; 2554f8829a4aSRandall Stewart SCTP_TCB_LOCK_ASSERT(stcb); 2555f8829a4aSRandall Stewart asoc = &stcb->asoc; 2556f8829a4aSRandall Stewart if ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) || 2557f8829a4aSRandall Stewart (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_ALLGONE) || 2558f8829a4aSRandall Stewart (stcb->asoc.state & SCTP_STATE_CLOSED_SOCKET)) { 2559f8829a4aSRandall Stewart /* 2560f8829a4aSRandall Stewart * wait a minute, this guy is gone, there is no longer a 2561f8829a4aSRandall Stewart * receiver. Send peer an ABORT! 2562f8829a4aSRandall Stewart */ 2563f8829a4aSRandall Stewart struct mbuf *op_err; 2564f8829a4aSRandall Stewart 2565f8829a4aSRandall Stewart op_err = sctp_generate_invmanparam(SCTP_CAUSE_OUT_OF_RESC); 2566f8829a4aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, stcb, 0, op_err); 2567f8829a4aSRandall Stewart return (2); 2568f8829a4aSRandall Stewart } 2569f8829a4aSRandall Stewart if (compare_with_wrap(stcb->asoc.highest_tsn_inside_map, 2570f8829a4aSRandall Stewart stcb->asoc.cumulative_tsn, MAX_TSN)) { 2571f8829a4aSRandall Stewart /* there was a gap before this data was processed */ 2572f8829a4aSRandall Stewart was_a_gap = 1; 2573f8829a4aSRandall Stewart } 2574f8829a4aSRandall Stewart /* 2575f8829a4aSRandall Stewart * setup where we got the last DATA packet from for any SACK that 2576f8829a4aSRandall Stewart * may need to go out. Don't bump the net. This is done ONLY when a 2577f8829a4aSRandall Stewart * chunk is assigned. 2578f8829a4aSRandall Stewart */ 2579f8829a4aSRandall Stewart asoc->last_data_chunk_from = net; 2580f8829a4aSRandall Stewart 2581d06c82f1SRandall Stewart /*- 2582f8829a4aSRandall Stewart * Now before we proceed we must figure out if this is a wasted 2583f8829a4aSRandall Stewart * cluster... i.e. it is a small packet sent in and yet the driver 2584f8829a4aSRandall Stewart * underneath allocated a full cluster for it. If so we must copy it 2585f8829a4aSRandall Stewart * to a smaller mbuf and free up the cluster mbuf. This will help 2586d06c82f1SRandall Stewart * with cluster starvation. Note for __Panda__ we don't do this 2587d06c82f1SRandall Stewart * since it has clusters all the way down to 64 bytes. 2588f8829a4aSRandall Stewart */ 258944b7479bSRandall Stewart if (SCTP_BUF_LEN(m) < (long)MLEN && SCTP_BUF_NEXT(m) == NULL) { 2590f8829a4aSRandall Stewart /* we only handle mbufs that are singletons.. not chains */ 2591139bc87fSRandall Stewart m = sctp_get_mbuf_for_msg(SCTP_BUF_LEN(m), 0, M_DONTWAIT, 1, MT_DATA); 2592f8829a4aSRandall Stewart if (m) { 2593f8829a4aSRandall Stewart /* ok lets see if we can copy the data up */ 2594f8829a4aSRandall Stewart caddr_t *from, *to; 2595f8829a4aSRandall Stewart 2596f8829a4aSRandall Stewart /* get the pointers and copy */ 2597f8829a4aSRandall Stewart to = mtod(m, caddr_t *); 2598f8829a4aSRandall Stewart from = mtod((*mm), caddr_t *); 2599139bc87fSRandall Stewart memcpy(to, from, SCTP_BUF_LEN((*mm))); 2600f8829a4aSRandall Stewart /* copy the length and free up the old */ 2601139bc87fSRandall Stewart SCTP_BUF_LEN(m) = SCTP_BUF_LEN((*mm)); 2602f8829a4aSRandall Stewart sctp_m_freem(*mm); 2603f8829a4aSRandall Stewart /* sucess, back copy */ 2604f8829a4aSRandall Stewart *mm = m; 2605f8829a4aSRandall Stewart } else { 2606f8829a4aSRandall Stewart /* We are in trouble in the mbuf world .. yikes */ 2607f8829a4aSRandall Stewart m = *mm; 2608f8829a4aSRandall Stewart } 2609f8829a4aSRandall Stewart } 2610f8829a4aSRandall Stewart /* get pointer to the first chunk header */ 2611f8829a4aSRandall Stewart ch = (struct sctp_data_chunk *)sctp_m_getptr(m, *offset, 2612f8829a4aSRandall Stewart sizeof(struct sctp_data_chunk), (uint8_t *) & chunk_buf); 2613f8829a4aSRandall Stewart if (ch == NULL) { 2614f8829a4aSRandall Stewart return (1); 2615f8829a4aSRandall Stewart } 2616f8829a4aSRandall Stewart /* 2617f8829a4aSRandall Stewart * process all DATA chunks... 2618f8829a4aSRandall Stewart */ 2619f8829a4aSRandall Stewart *high_tsn = asoc->cumulative_tsn; 2620f8829a4aSRandall Stewart break_flag = 0; 262142551e99SRandall Stewart asoc->data_pkts_seen++; 2622f8829a4aSRandall Stewart while (stop_proc == 0) { 2623f8829a4aSRandall Stewart /* validate chunk length */ 2624f8829a4aSRandall Stewart chk_length = ntohs(ch->ch.chunk_length); 2625f8829a4aSRandall Stewart if (length - *offset < chk_length) { 2626f8829a4aSRandall Stewart /* all done, mutulated chunk */ 2627f8829a4aSRandall Stewart stop_proc = 1; 2628f8829a4aSRandall Stewart break; 2629f8829a4aSRandall Stewart } 2630f8829a4aSRandall Stewart if (ch->ch.chunk_type == SCTP_DATA) { 2631f8829a4aSRandall Stewart if ((size_t)chk_length < sizeof(struct sctp_data_chunk) + 1) { 2632f8829a4aSRandall Stewart /* 2633f8829a4aSRandall Stewart * Need to send an abort since we had a 2634f8829a4aSRandall Stewart * invalid data chunk. 2635f8829a4aSRandall Stewart */ 2636f8829a4aSRandall Stewart struct mbuf *op_err; 2637f8829a4aSRandall Stewart 2638139bc87fSRandall Stewart op_err = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + 2 * sizeof(uint32_t)), 2639f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 2640f8829a4aSRandall Stewart 2641f8829a4aSRandall Stewart if (op_err) { 2642f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 2643f8829a4aSRandall Stewart uint32_t *ippp; 2644f8829a4aSRandall Stewart 2645139bc87fSRandall Stewart SCTP_BUF_LEN(op_err) = sizeof(struct sctp_paramhdr) + 2646f8829a4aSRandall Stewart (2 * sizeof(uint32_t)); 2647f8829a4aSRandall Stewart ph = mtod(op_err, struct sctp_paramhdr *); 2648f8829a4aSRandall Stewart ph->param_type = 2649f8829a4aSRandall Stewart htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 2650139bc87fSRandall Stewart ph->param_length = htons(SCTP_BUF_LEN(op_err)); 2651f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 2652a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_19); 2653f8829a4aSRandall Stewart ippp++; 2654f8829a4aSRandall Stewart *ippp = asoc->cumulative_tsn; 2655f8829a4aSRandall Stewart 2656f8829a4aSRandall Stewart } 2657a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_19; 2658f8829a4aSRandall Stewart sctp_abort_association(inp, stcb, m, iphlen, sh, 265917205eccSRandall Stewart op_err, 0, 0); 2660f8829a4aSRandall Stewart return (2); 2661f8829a4aSRandall Stewart } 2662f8829a4aSRandall Stewart #ifdef SCTP_AUDITING_ENABLED 2663f8829a4aSRandall Stewart sctp_audit_log(0xB1, 0); 2664f8829a4aSRandall Stewart #endif 2665f8829a4aSRandall Stewart if (SCTP_SIZE32(chk_length) == (length - *offset)) { 2666f8829a4aSRandall Stewart last_chunk = 1; 2667f8829a4aSRandall Stewart } else { 2668f8829a4aSRandall Stewart last_chunk = 0; 2669f8829a4aSRandall Stewart } 2670f8829a4aSRandall Stewart if (sctp_process_a_data_chunk(stcb, asoc, mm, *offset, ch, 2671f8829a4aSRandall Stewart chk_length, net, high_tsn, &abort_flag, &break_flag, 2672f8829a4aSRandall Stewart last_chunk)) { 2673f8829a4aSRandall Stewart num_chunks++; 2674f8829a4aSRandall Stewart } 2675f8829a4aSRandall Stewart if (abort_flag) 2676f8829a4aSRandall Stewart return (2); 2677f8829a4aSRandall Stewart 2678f8829a4aSRandall Stewart if (break_flag) { 2679f8829a4aSRandall Stewart /* 2680f8829a4aSRandall Stewart * Set because of out of rwnd space and no 2681f8829a4aSRandall Stewart * drop rep space left. 2682f8829a4aSRandall Stewart */ 2683f8829a4aSRandall Stewart stop_proc = 1; 2684f8829a4aSRandall Stewart break; 2685f8829a4aSRandall Stewart } 2686f8829a4aSRandall Stewart } else { 2687f8829a4aSRandall Stewart /* not a data chunk in the data region */ 2688f8829a4aSRandall Stewart switch (ch->ch.chunk_type) { 2689f8829a4aSRandall Stewart case SCTP_INITIATION: 2690f8829a4aSRandall Stewart case SCTP_INITIATION_ACK: 2691f8829a4aSRandall Stewart case SCTP_SELECTIVE_ACK: 2692f8829a4aSRandall Stewart case SCTP_HEARTBEAT_REQUEST: 2693f8829a4aSRandall Stewart case SCTP_HEARTBEAT_ACK: 2694f8829a4aSRandall Stewart case SCTP_ABORT_ASSOCIATION: 2695f8829a4aSRandall Stewart case SCTP_SHUTDOWN: 2696f8829a4aSRandall Stewart case SCTP_SHUTDOWN_ACK: 2697f8829a4aSRandall Stewart case SCTP_OPERATION_ERROR: 2698f8829a4aSRandall Stewart case SCTP_COOKIE_ECHO: 2699f8829a4aSRandall Stewart case SCTP_COOKIE_ACK: 2700f8829a4aSRandall Stewart case SCTP_ECN_ECHO: 2701f8829a4aSRandall Stewart case SCTP_ECN_CWR: 2702f8829a4aSRandall Stewart case SCTP_SHUTDOWN_COMPLETE: 2703f8829a4aSRandall Stewart case SCTP_AUTHENTICATION: 2704f8829a4aSRandall Stewart case SCTP_ASCONF_ACK: 2705f8829a4aSRandall Stewart case SCTP_PACKET_DROPPED: 2706f8829a4aSRandall Stewart case SCTP_STREAM_RESET: 2707f8829a4aSRandall Stewart case SCTP_FORWARD_CUM_TSN: 2708f8829a4aSRandall Stewart case SCTP_ASCONF: 2709f8829a4aSRandall Stewart /* 2710f8829a4aSRandall Stewart * Now, what do we do with KNOWN chunks that 2711f8829a4aSRandall Stewart * are NOT in the right place? 2712f8829a4aSRandall Stewart * 2713f8829a4aSRandall Stewart * For now, I do nothing but ignore them. We 2714f8829a4aSRandall Stewart * may later want to add sysctl stuff to 2715f8829a4aSRandall Stewart * switch out and do either an ABORT() or 2716f8829a4aSRandall Stewart * possibly process them. 2717f8829a4aSRandall Stewart */ 2718f8829a4aSRandall Stewart if (sctp_strict_data_order) { 2719f8829a4aSRandall Stewart struct mbuf *op_err; 2720f8829a4aSRandall Stewart 2721f8829a4aSRandall Stewart op_err = sctp_generate_invmanparam(SCTP_CAUSE_PROTOCOL_VIOLATION); 272217205eccSRandall Stewart sctp_abort_association(inp, stcb, m, iphlen, sh, op_err, 0, 0); 2723f8829a4aSRandall Stewart return (2); 2724f8829a4aSRandall Stewart } 2725f8829a4aSRandall Stewart break; 2726f8829a4aSRandall Stewart default: 2727f8829a4aSRandall Stewart /* unknown chunk type, use bit rules */ 2728f8829a4aSRandall Stewart if (ch->ch.chunk_type & 0x40) { 2729f8829a4aSRandall Stewart /* Add a error report to the queue */ 2730f8829a4aSRandall Stewart struct mbuf *mm; 2731f8829a4aSRandall Stewart struct sctp_paramhdr *phd; 2732f8829a4aSRandall Stewart 2733139bc87fSRandall Stewart mm = sctp_get_mbuf_for_msg(sizeof(*phd), 0, M_DONTWAIT, 1, MT_DATA); 2734f8829a4aSRandall Stewart if (mm) { 2735f8829a4aSRandall Stewart phd = mtod(mm, struct sctp_paramhdr *); 2736f8829a4aSRandall Stewart /* 2737f8829a4aSRandall Stewart * We cheat and use param 2738f8829a4aSRandall Stewart * type since we did not 2739f8829a4aSRandall Stewart * bother to define a error 2740f8829a4aSRandall Stewart * cause struct. They are 2741f8829a4aSRandall Stewart * the same basic format 2742f8829a4aSRandall Stewart * with different names. 2743f8829a4aSRandall Stewart */ 2744f8829a4aSRandall Stewart phd->param_type = 2745f8829a4aSRandall Stewart htons(SCTP_CAUSE_UNRECOG_CHUNK); 2746f8829a4aSRandall Stewart phd->param_length = 2747f8829a4aSRandall Stewart htons(chk_length + sizeof(*phd)); 2748139bc87fSRandall Stewart SCTP_BUF_LEN(mm) = sizeof(*phd); 274944b7479bSRandall Stewart SCTP_BUF_NEXT(mm) = SCTP_M_COPYM(m, *offset, 2750f8829a4aSRandall Stewart SCTP_SIZE32(chk_length), 2751f8829a4aSRandall Stewart M_DONTWAIT); 2752139bc87fSRandall Stewart if (SCTP_BUF_NEXT(mm)) { 2753f8829a4aSRandall Stewart sctp_queue_op_err(stcb, mm); 2754f8829a4aSRandall Stewart } else { 2755f8829a4aSRandall Stewart sctp_m_freem(mm); 2756f8829a4aSRandall Stewart } 2757f8829a4aSRandall Stewart } 2758f8829a4aSRandall Stewart } 2759f8829a4aSRandall Stewart if ((ch->ch.chunk_type & 0x80) == 0) { 2760f8829a4aSRandall Stewart /* discard the rest of this packet */ 2761f8829a4aSRandall Stewart stop_proc = 1; 2762f8829a4aSRandall Stewart } /* else skip this bad chunk and 2763f8829a4aSRandall Stewart * continue... */ 2764f8829a4aSRandall Stewart break; 2765f8829a4aSRandall Stewart }; /* switch of chunk type */ 2766f8829a4aSRandall Stewart } 2767f8829a4aSRandall Stewart *offset += SCTP_SIZE32(chk_length); 2768f8829a4aSRandall Stewart if ((*offset >= length) || stop_proc) { 2769f8829a4aSRandall Stewart /* no more data left in the mbuf chain */ 2770f8829a4aSRandall Stewart stop_proc = 1; 2771f8829a4aSRandall Stewart continue; 2772f8829a4aSRandall Stewart } 2773f8829a4aSRandall Stewart ch = (struct sctp_data_chunk *)sctp_m_getptr(m, *offset, 2774f8829a4aSRandall Stewart sizeof(struct sctp_data_chunk), (uint8_t *) & chunk_buf); 2775f8829a4aSRandall Stewart if (ch == NULL) { 2776f8829a4aSRandall Stewart *offset = length; 2777f8829a4aSRandall Stewart stop_proc = 1; 2778f8829a4aSRandall Stewart break; 2779f8829a4aSRandall Stewart 2780f8829a4aSRandall Stewart } 2781f8829a4aSRandall Stewart } /* while */ 2782f8829a4aSRandall Stewart if (break_flag) { 2783f8829a4aSRandall Stewart /* 2784f8829a4aSRandall Stewart * we need to report rwnd overrun drops. 2785f8829a4aSRandall Stewart */ 2786f8829a4aSRandall Stewart sctp_send_packet_dropped(stcb, net, *mm, iphlen, 0); 2787f8829a4aSRandall Stewart } 2788f8829a4aSRandall Stewart if (num_chunks) { 2789f8829a4aSRandall Stewart /* 2790f8829a4aSRandall Stewart * Did we get data, if so update the time for auto-close and 2791f8829a4aSRandall Stewart * give peer credit for being alive. 2792f8829a4aSRandall Stewart */ 2793f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_recvpktwithdata); 2794f8829a4aSRandall Stewart stcb->asoc.overall_error_count = 0; 27956e55db54SRandall Stewart (void)SCTP_GETTIME_TIMEVAL(&stcb->asoc.time_last_rcvd); 2796f8829a4aSRandall Stewart } 2797f8829a4aSRandall Stewart /* now service all of the reassm queue if needed */ 2798f8829a4aSRandall Stewart if (!(TAILQ_EMPTY(&asoc->reasmqueue))) 2799f8829a4aSRandall Stewart sctp_service_queues(stcb, asoc); 2800f8829a4aSRandall Stewart 2801f8829a4aSRandall Stewart if (SCTP_GET_STATE(asoc) == SCTP_STATE_SHUTDOWN_SENT) { 280242551e99SRandall Stewart /* Assure that we ack right away */ 280342551e99SRandall Stewart stcb->asoc.send_sack = 1; 2804f8829a4aSRandall Stewart } 2805f8829a4aSRandall Stewart /* Start a sack timer or QUEUE a SACK for sending */ 2806f8829a4aSRandall Stewart if ((stcb->asoc.cumulative_tsn == stcb->asoc.highest_tsn_inside_map) && 280742551e99SRandall Stewart (stcb->asoc.mapping_array[0] != 0xff)) { 280842551e99SRandall Stewart if ((stcb->asoc.data_pkts_seen >= stcb->asoc.sack_freq) || 280942551e99SRandall Stewart (stcb->asoc.delayed_ack == 0) || 281042551e99SRandall Stewart (stcb->asoc.send_sack == 1)) { 2811139bc87fSRandall Stewart if (SCTP_OS_TIMER_PENDING(&stcb->asoc.dack_timer.timer)) { 2812139bc87fSRandall Stewart SCTP_OS_TIMER_STOP(&stcb->asoc.dack_timer.timer); 281342551e99SRandall Stewart } 2814f8829a4aSRandall Stewart sctp_send_sack(stcb); 2815f8829a4aSRandall Stewart } else { 281642551e99SRandall Stewart if (!SCTP_OS_TIMER_PENDING(&stcb->asoc.dack_timer.timer)) { 2817f8829a4aSRandall Stewart sctp_timer_start(SCTP_TIMER_TYPE_RECV, 2818f8829a4aSRandall Stewart stcb->sctp_ep, stcb, NULL); 2819f8829a4aSRandall Stewart } 2820f8829a4aSRandall Stewart } 2821f8829a4aSRandall Stewart } else { 2822f8829a4aSRandall Stewart sctp_sack_check(stcb, 1, was_a_gap, &abort_flag); 2823f8829a4aSRandall Stewart } 2824f8829a4aSRandall Stewart if (abort_flag) 2825f8829a4aSRandall Stewart return (2); 2826f8829a4aSRandall Stewart 2827f8829a4aSRandall Stewart return (0); 2828f8829a4aSRandall Stewart } 2829f8829a4aSRandall Stewart 2830f8829a4aSRandall Stewart static void 2831f8829a4aSRandall Stewart sctp_handle_segments(struct sctp_tcb *stcb, struct sctp_association *asoc, 2832f8829a4aSRandall Stewart struct sctp_sack_chunk *ch, uint32_t last_tsn, uint32_t * biggest_tsn_acked, 2833139bc87fSRandall Stewart uint32_t * biggest_newly_acked_tsn, uint32_t * this_sack_lowest_newack, 2834139bc87fSRandall Stewart int num_seg, int *ecn_seg_sums) 2835f8829a4aSRandall Stewart { 2836f8829a4aSRandall Stewart /************************************************/ 2837f8829a4aSRandall Stewart /* process fragments and update sendqueue */ 2838f8829a4aSRandall Stewart /************************************************/ 2839f8829a4aSRandall Stewart struct sctp_sack *sack; 2840f8829a4aSRandall Stewart struct sctp_gap_ack_block *frag; 2841f8829a4aSRandall Stewart struct sctp_tmit_chunk *tp1; 2842f8829a4aSRandall Stewart int i; 2843f8829a4aSRandall Stewart unsigned int j; 2844f8829a4aSRandall Stewart 2845f8829a4aSRandall Stewart #ifdef SCTP_FR_LOGGING 2846f8829a4aSRandall Stewart int num_frs = 0; 2847f8829a4aSRandall Stewart 2848f8829a4aSRandall Stewart #endif 2849f8829a4aSRandall Stewart uint16_t frag_strt, frag_end, primary_flag_set; 2850f8829a4aSRandall Stewart u_long last_frag_high; 2851f8829a4aSRandall Stewart 2852f8829a4aSRandall Stewart /* 2853f8829a4aSRandall Stewart * @@@ JRI : TODO: This flag is not used anywhere .. remove? 2854f8829a4aSRandall Stewart */ 2855f8829a4aSRandall Stewart if (asoc->primary_destination->dest_state & SCTP_ADDR_SWITCH_PRIMARY) { 2856f8829a4aSRandall Stewart primary_flag_set = 1; 2857f8829a4aSRandall Stewart } else { 2858f8829a4aSRandall Stewart primary_flag_set = 0; 2859f8829a4aSRandall Stewart } 2860f8829a4aSRandall Stewart 2861f8829a4aSRandall Stewart sack = &ch->sack; 2862f8829a4aSRandall Stewart frag = (struct sctp_gap_ack_block *)((caddr_t)sack + 2863f8829a4aSRandall Stewart sizeof(struct sctp_sack)); 2864f8829a4aSRandall Stewart tp1 = NULL; 2865f8829a4aSRandall Stewart last_frag_high = 0; 2866f8829a4aSRandall Stewart for (i = 0; i < num_seg; i++) { 2867f8829a4aSRandall Stewart frag_strt = ntohs(frag->start); 2868f8829a4aSRandall Stewart frag_end = ntohs(frag->end); 2869f8829a4aSRandall Stewart /* some sanity checks on the fargment offsets */ 2870f8829a4aSRandall Stewart if (frag_strt > frag_end) { 2871f8829a4aSRandall Stewart /* this one is malformed, skip */ 2872f8829a4aSRandall Stewart frag++; 2873f8829a4aSRandall Stewart continue; 2874f8829a4aSRandall Stewart } 2875f8829a4aSRandall Stewart if (compare_with_wrap((frag_end + last_tsn), *biggest_tsn_acked, 2876f8829a4aSRandall Stewart MAX_TSN)) 2877f8829a4aSRandall Stewart *biggest_tsn_acked = frag_end + last_tsn; 2878f8829a4aSRandall Stewart 2879f8829a4aSRandall Stewart /* mark acked dgs and find out the highestTSN being acked */ 2880f8829a4aSRandall Stewart if (tp1 == NULL) { 2881f8829a4aSRandall Stewart tp1 = TAILQ_FIRST(&asoc->sent_queue); 2882f8829a4aSRandall Stewart 2883f8829a4aSRandall Stewart /* save the locations of the last frags */ 2884f8829a4aSRandall Stewart last_frag_high = frag_end + last_tsn; 2885f8829a4aSRandall Stewart } else { 2886f8829a4aSRandall Stewart /* 2887f8829a4aSRandall Stewart * now lets see if we need to reset the queue due to 2888f8829a4aSRandall Stewart * a out-of-order SACK fragment 2889f8829a4aSRandall Stewart */ 2890f8829a4aSRandall Stewart if (compare_with_wrap(frag_strt + last_tsn, 2891f8829a4aSRandall Stewart last_frag_high, MAX_TSN)) { 2892f8829a4aSRandall Stewart /* 2893f8829a4aSRandall Stewart * if the new frag starts after the last TSN 2894f8829a4aSRandall Stewart * frag covered, we are ok and this one is 2895f8829a4aSRandall Stewart * beyond the last one 2896f8829a4aSRandall Stewart */ 2897f8829a4aSRandall Stewart ; 2898f8829a4aSRandall Stewart } else { 2899f8829a4aSRandall Stewart /* 2900f8829a4aSRandall Stewart * ok, they have reset us, so we need to 2901f8829a4aSRandall Stewart * reset the queue this will cause extra 2902f8829a4aSRandall Stewart * hunting but hey, they chose the 2903f8829a4aSRandall Stewart * performance hit when they failed to order 2904f8829a4aSRandall Stewart * there gaps.. 2905f8829a4aSRandall Stewart */ 2906f8829a4aSRandall Stewart tp1 = TAILQ_FIRST(&asoc->sent_queue); 2907f8829a4aSRandall Stewart } 2908f8829a4aSRandall Stewart last_frag_high = frag_end + last_tsn; 2909f8829a4aSRandall Stewart } 2910f8829a4aSRandall Stewart for (j = frag_strt + last_tsn; j <= frag_end + last_tsn; j++) { 2911f8829a4aSRandall Stewart while (tp1) { 2912f8829a4aSRandall Stewart #ifdef SCTP_FR_LOGGING 2913f8829a4aSRandall Stewart if (tp1->rec.data.doing_fast_retransmit) 2914f8829a4aSRandall Stewart num_frs++; 2915f8829a4aSRandall Stewart #endif 2916f8829a4aSRandall Stewart 2917f8829a4aSRandall Stewart /* 2918f8829a4aSRandall Stewart * CMT: CUCv2 algorithm. For each TSN being 2919f8829a4aSRandall Stewart * processed from the sent queue, track the 2920f8829a4aSRandall Stewart * next expected pseudo-cumack, or 2921f8829a4aSRandall Stewart * rtx_pseudo_cumack, if required. Separate 2922f8829a4aSRandall Stewart * cumack trackers for first transmissions, 2923f8829a4aSRandall Stewart * and retransmissions. 2924f8829a4aSRandall Stewart */ 2925f8829a4aSRandall Stewart if ((tp1->whoTo->find_pseudo_cumack == 1) && (tp1->sent < SCTP_DATAGRAM_RESEND) && 2926f8829a4aSRandall Stewart (tp1->snd_count == 1)) { 2927f8829a4aSRandall Stewart tp1->whoTo->pseudo_cumack = tp1->rec.data.TSN_seq; 2928f8829a4aSRandall Stewart tp1->whoTo->find_pseudo_cumack = 0; 2929f8829a4aSRandall Stewart } 2930f8829a4aSRandall Stewart if ((tp1->whoTo->find_rtx_pseudo_cumack == 1) && (tp1->sent < SCTP_DATAGRAM_RESEND) && 2931f8829a4aSRandall Stewart (tp1->snd_count > 1)) { 2932f8829a4aSRandall Stewart tp1->whoTo->rtx_pseudo_cumack = tp1->rec.data.TSN_seq; 2933f8829a4aSRandall Stewart tp1->whoTo->find_rtx_pseudo_cumack = 0; 2934f8829a4aSRandall Stewart } 2935f8829a4aSRandall Stewart if (tp1->rec.data.TSN_seq == j) { 2936f8829a4aSRandall Stewart if (tp1->sent != SCTP_DATAGRAM_UNSENT) { 2937f8829a4aSRandall Stewart /* 2938f8829a4aSRandall Stewart * must be held until 2939f8829a4aSRandall Stewart * cum-ack passes 2940f8829a4aSRandall Stewart */ 2941f8829a4aSRandall Stewart /* 2942f8829a4aSRandall Stewart * ECN Nonce: Add the nonce 2943f8829a4aSRandall Stewart * value to the sender's 2944f8829a4aSRandall Stewart * nonce sum 2945f8829a4aSRandall Stewart */ 2946c105859eSRandall Stewart if (tp1->sent < SCTP_DATAGRAM_RESEND) { 2947c105859eSRandall Stewart /*- 2948c105859eSRandall Stewart * If it is less than RESEND, it is 2949c105859eSRandall Stewart * now no-longer in flight. 2950c105859eSRandall Stewart * Higher values may already be set 2951c105859eSRandall Stewart * via previous Gap Ack Blocks... 2952c105859eSRandall Stewart * i.e. ACKED or RESEND. 2953f8829a4aSRandall Stewart */ 2954f8829a4aSRandall Stewart if (compare_with_wrap(tp1->rec.data.TSN_seq, 2955f8829a4aSRandall Stewart *biggest_newly_acked_tsn, MAX_TSN)) { 2956f8829a4aSRandall Stewart *biggest_newly_acked_tsn = tp1->rec.data.TSN_seq; 2957f8829a4aSRandall Stewart } 2958f8829a4aSRandall Stewart /* 2959f8829a4aSRandall Stewart * CMT: SFR algo 2960f8829a4aSRandall Stewart * (and HTNA) - set 2961f8829a4aSRandall Stewart * saw_newack to 1 2962f8829a4aSRandall Stewart * for dest being 2963f8829a4aSRandall Stewart * newly acked. 2964f8829a4aSRandall Stewart * update 2965f8829a4aSRandall Stewart * this_sack_highest_ 2966f8829a4aSRandall Stewart * newack if 2967f8829a4aSRandall Stewart * appropriate. 2968f8829a4aSRandall Stewart */ 2969f8829a4aSRandall Stewart if (tp1->rec.data.chunk_was_revoked == 0) 2970f8829a4aSRandall Stewart tp1->whoTo->saw_newack = 1; 2971f8829a4aSRandall Stewart 2972f8829a4aSRandall Stewart if (compare_with_wrap(tp1->rec.data.TSN_seq, 2973f8829a4aSRandall Stewart tp1->whoTo->this_sack_highest_newack, 2974f8829a4aSRandall Stewart MAX_TSN)) { 2975f8829a4aSRandall Stewart tp1->whoTo->this_sack_highest_newack = 2976f8829a4aSRandall Stewart tp1->rec.data.TSN_seq; 2977f8829a4aSRandall Stewart } 2978f8829a4aSRandall Stewart /* 2979f8829a4aSRandall Stewart * CMT DAC algo: 2980f8829a4aSRandall Stewart * also update 2981f8829a4aSRandall Stewart * this_sack_lowest_n 2982f8829a4aSRandall Stewart * ewack 2983f8829a4aSRandall Stewart */ 2984f8829a4aSRandall Stewart if (*this_sack_lowest_newack == 0) { 2985f8829a4aSRandall Stewart #ifdef SCTP_SACK_LOGGING 2986f8829a4aSRandall Stewart sctp_log_sack(*this_sack_lowest_newack, 2987d0cf96b4SMax Laier last_tsn, 2988f8829a4aSRandall Stewart tp1->rec.data.TSN_seq, 2989f8829a4aSRandall Stewart 0, 2990f8829a4aSRandall Stewart 0, 2991f8829a4aSRandall Stewart SCTP_LOG_TSN_ACKED); 2992f8829a4aSRandall Stewart #endif 2993f8829a4aSRandall Stewart *this_sack_lowest_newack = tp1->rec.data.TSN_seq; 2994f8829a4aSRandall Stewart } 2995f8829a4aSRandall Stewart /* 2996f8829a4aSRandall Stewart * CMT: CUCv2 2997f8829a4aSRandall Stewart * algorithm. If 2998f8829a4aSRandall Stewart * (rtx-)pseudo-cumac 2999f8829a4aSRandall Stewart * k for corresp 3000f8829a4aSRandall Stewart * dest is being 3001f8829a4aSRandall Stewart * acked, then we 3002f8829a4aSRandall Stewart * have a new 3003f8829a4aSRandall Stewart * (rtx-)pseudo-cumac 3004f8829a4aSRandall Stewart * k. Set 3005f8829a4aSRandall Stewart * new_(rtx_)pseudo_c 3006f8829a4aSRandall Stewart * umack to TRUE so 3007f8829a4aSRandall Stewart * that the cwnd for 3008f8829a4aSRandall Stewart * this dest can be 3009f8829a4aSRandall Stewart * updated. Also 3010f8829a4aSRandall Stewart * trigger search 3011f8829a4aSRandall Stewart * for the next 3012f8829a4aSRandall Stewart * expected 3013f8829a4aSRandall Stewart * (rtx-)pseudo-cumac 3014f8829a4aSRandall Stewart * k. Separate 3015f8829a4aSRandall Stewart * pseudo_cumack 3016f8829a4aSRandall Stewart * trackers for 3017f8829a4aSRandall Stewart * first 3018f8829a4aSRandall Stewart * transmissions and 3019f8829a4aSRandall Stewart * retransmissions. 3020f8829a4aSRandall Stewart */ 3021f8829a4aSRandall Stewart if (tp1->rec.data.TSN_seq == tp1->whoTo->pseudo_cumack) { 3022f8829a4aSRandall Stewart if (tp1->rec.data.chunk_was_revoked == 0) { 3023f8829a4aSRandall Stewart tp1->whoTo->new_pseudo_cumack = 1; 3024f8829a4aSRandall Stewart } 3025f8829a4aSRandall Stewart tp1->whoTo->find_pseudo_cumack = 1; 3026f8829a4aSRandall Stewart } 3027f8829a4aSRandall Stewart #ifdef SCTP_CWND_LOGGING 3028f8829a4aSRandall Stewart sctp_log_cwnd(stcb, tp1->whoTo, tp1->rec.data.TSN_seq, SCTP_CWND_LOG_FROM_SACK); 3029f8829a4aSRandall Stewart #endif 3030f8829a4aSRandall Stewart if (tp1->rec.data.TSN_seq == tp1->whoTo->rtx_pseudo_cumack) { 3031f8829a4aSRandall Stewart if (tp1->rec.data.chunk_was_revoked == 0) { 3032f8829a4aSRandall Stewart tp1->whoTo->new_pseudo_cumack = 1; 3033f8829a4aSRandall Stewart } 3034f8829a4aSRandall Stewart tp1->whoTo->find_rtx_pseudo_cumack = 1; 3035f8829a4aSRandall Stewart } 3036f8829a4aSRandall Stewart #ifdef SCTP_SACK_LOGGING 3037f8829a4aSRandall Stewart sctp_log_sack(*biggest_newly_acked_tsn, 3038f8829a4aSRandall Stewart last_tsn, 3039f8829a4aSRandall Stewart tp1->rec.data.TSN_seq, 3040f8829a4aSRandall Stewart frag_strt, 3041f8829a4aSRandall Stewart frag_end, 3042f8829a4aSRandall Stewart SCTP_LOG_TSN_ACKED); 3043f8829a4aSRandall Stewart #endif 3044a5d547adSRandall Stewart #ifdef SCTP_FLIGHT_LOGGING 3045c105859eSRandall Stewart sctp_misc_ints(SCTP_FLIGHT_LOG_DOWN_GAP, 3046a5d547adSRandall Stewart tp1->whoTo->flight_size, 3047a5d547adSRandall Stewart tp1->book_size, 3048c105859eSRandall Stewart (uintptr_t) tp1->whoTo, 3049a5d547adSRandall Stewart tp1->rec.data.TSN_seq); 3050a5d547adSRandall Stewart #endif 3051c105859eSRandall Stewart sctp_flight_size_decrease(tp1); 3052c105859eSRandall Stewart sctp_total_flight_decrease(stcb, tp1); 3053f8829a4aSRandall Stewart 3054f8829a4aSRandall Stewart tp1->whoTo->net_ack += tp1->send_size; 3055f8829a4aSRandall Stewart if (tp1->snd_count < 2) { 3056f8829a4aSRandall Stewart /* 3057a5d547adSRandall Stewart * True 3058a5d547adSRandall Stewart * non-retran 3059a5d547adSRandall Stewart * smited 3060a5d547adSRandall Stewart * chunk */ 3061f8829a4aSRandall Stewart tp1->whoTo->net_ack2 += tp1->send_size; 3062f8829a4aSRandall Stewart 3063f8829a4aSRandall Stewart /* 3064a5d547adSRandall Stewart * update RTO 3065a5d547adSRandall Stewart * too ? */ 3066f8829a4aSRandall Stewart if (tp1->do_rtt) { 3067f8829a4aSRandall Stewart tp1->whoTo->RTO = 3068f8829a4aSRandall Stewart sctp_calculate_rto(stcb, 3069f8829a4aSRandall Stewart asoc, 3070f8829a4aSRandall Stewart tp1->whoTo, 3071f8829a4aSRandall Stewart &tp1->sent_rcv_time); 3072f8829a4aSRandall Stewart tp1->do_rtt = 0; 3073f8829a4aSRandall Stewart } 3074f8829a4aSRandall Stewart } 3075f8829a4aSRandall Stewart } 3076c105859eSRandall Stewart if (tp1->sent <= SCTP_DATAGRAM_RESEND) { 3077c105859eSRandall Stewart (*ecn_seg_sums) += tp1->rec.data.ect_nonce; 3078c105859eSRandall Stewart (*ecn_seg_sums) &= SCTP_SACK_NONCE_SUM; 3079c105859eSRandall Stewart if (compare_with_wrap(tp1->rec.data.TSN_seq, 3080f8829a4aSRandall Stewart asoc->this_sack_highest_gap, 3081f8829a4aSRandall Stewart MAX_TSN)) { 3082f8829a4aSRandall Stewart asoc->this_sack_highest_gap = 3083f8829a4aSRandall Stewart tp1->rec.data.TSN_seq; 3084f8829a4aSRandall Stewart } 3085f8829a4aSRandall Stewart if (tp1->sent == SCTP_DATAGRAM_RESEND) { 3086f8829a4aSRandall Stewart sctp_ucount_decr(asoc->sent_queue_retran_cnt); 3087f8829a4aSRandall Stewart #ifdef SCTP_AUDITING_ENABLED 3088f8829a4aSRandall Stewart sctp_audit_log(0xB2, 3089f8829a4aSRandall Stewart (asoc->sent_queue_retran_cnt & 0x000000ff)); 3090f8829a4aSRandall Stewart #endif 3091f8829a4aSRandall Stewart } 3092c105859eSRandall Stewart } 3093c105859eSRandall Stewart /* 3094c105859eSRandall Stewart * All chunks NOT UNSENT 3095c105859eSRandall Stewart * fall through here and are 3096c105859eSRandall Stewart * marked 3097c105859eSRandall Stewart */ 3098f8829a4aSRandall Stewart tp1->sent = SCTP_DATAGRAM_MARKED; 309942551e99SRandall Stewart if (tp1->rec.data.chunk_was_revoked) { 310042551e99SRandall Stewart /* deflate the cwnd */ 310142551e99SRandall Stewart tp1->whoTo->cwnd -= tp1->book_size; 310242551e99SRandall Stewart tp1->rec.data.chunk_was_revoked = 0; 310342551e99SRandall Stewart } 3104f8829a4aSRandall Stewart } 3105f8829a4aSRandall Stewart break; 3106f8829a4aSRandall Stewart } /* if (tp1->TSN_seq == j) */ 3107f8829a4aSRandall Stewart if (compare_with_wrap(tp1->rec.data.TSN_seq, j, 3108f8829a4aSRandall Stewart MAX_TSN)) 3109f8829a4aSRandall Stewart break; 3110f8829a4aSRandall Stewart 3111f8829a4aSRandall Stewart tp1 = TAILQ_NEXT(tp1, sctp_next); 3112f8829a4aSRandall Stewart } /* end while (tp1) */ 3113f8829a4aSRandall Stewart } /* end for (j = fragStart */ 3114f8829a4aSRandall Stewart frag++; /* next one */ 3115f8829a4aSRandall Stewart } 3116f8829a4aSRandall Stewart #ifdef SCTP_FR_LOGGING 3117f8829a4aSRandall Stewart /* 3118f8829a4aSRandall Stewart * if (num_frs) sctp_log_fr(*biggest_tsn_acked, 3119f8829a4aSRandall Stewart * *biggest_newly_acked_tsn, last_tsn, SCTP_FR_LOG_BIGGEST_TSNS); 3120f8829a4aSRandall Stewart */ 3121f8829a4aSRandall Stewart #endif 3122f8829a4aSRandall Stewart } 3123f8829a4aSRandall Stewart 3124f8829a4aSRandall Stewart static void 3125c105859eSRandall Stewart sctp_check_for_revoked(struct sctp_tcb *stcb, 3126c105859eSRandall Stewart struct sctp_association *asoc, uint32_t cumack, 3127f8829a4aSRandall Stewart u_long biggest_tsn_acked) 3128f8829a4aSRandall Stewart { 3129f8829a4aSRandall Stewart struct sctp_tmit_chunk *tp1; 3130f8829a4aSRandall Stewart int tot_revoked = 0; 3131f8829a4aSRandall Stewart 3132f8829a4aSRandall Stewart tp1 = TAILQ_FIRST(&asoc->sent_queue); 3133f8829a4aSRandall Stewart while (tp1) { 3134f8829a4aSRandall Stewart if (compare_with_wrap(tp1->rec.data.TSN_seq, cumack, 3135f8829a4aSRandall Stewart MAX_TSN)) { 3136f8829a4aSRandall Stewart /* 3137f8829a4aSRandall Stewart * ok this guy is either ACK or MARKED. If it is 3138f8829a4aSRandall Stewart * ACKED it has been previously acked but not this 3139f8829a4aSRandall Stewart * time i.e. revoked. If it is MARKED it was ACK'ed 3140f8829a4aSRandall Stewart * again. 3141f8829a4aSRandall Stewart */ 3142d06c82f1SRandall Stewart if (compare_with_wrap(tp1->rec.data.TSN_seq, biggest_tsn_acked, 3143d06c82f1SRandall Stewart MAX_TSN)) 3144d06c82f1SRandall Stewart break; 3145d06c82f1SRandall Stewart 3146d06c82f1SRandall Stewart 3147f8829a4aSRandall Stewart if (tp1->sent == SCTP_DATAGRAM_ACKED) { 3148f8829a4aSRandall Stewart /* it has been revoked */ 3149f8829a4aSRandall Stewart tp1->sent = SCTP_DATAGRAM_SENT; 3150f8829a4aSRandall Stewart tp1->rec.data.chunk_was_revoked = 1; 3151a5d547adSRandall Stewart /* 315242551e99SRandall Stewart * We must add this stuff back in to assure 315342551e99SRandall Stewart * timers and such get started. 3154a5d547adSRandall Stewart */ 3155c105859eSRandall Stewart #ifdef SCTP_FLIGHT_LOGGING 3156c105859eSRandall Stewart sctp_misc_ints(SCTP_FLIGHT_LOG_UP_REVOKE, 3157c105859eSRandall Stewart tp1->whoTo->flight_size, 3158c105859eSRandall Stewart tp1->book_size, 3159c105859eSRandall Stewart (uintptr_t) tp1->whoTo, 3160c105859eSRandall Stewart tp1->rec.data.TSN_seq); 3161c105859eSRandall Stewart #endif 3162c105859eSRandall Stewart sctp_flight_size_increase(tp1); 3163c105859eSRandall Stewart sctp_total_flight_increase(stcb, tp1); 316442551e99SRandall Stewart /* 316542551e99SRandall Stewart * We inflate the cwnd to compensate for our 316642551e99SRandall Stewart * artificial inflation of the flight_size. 316742551e99SRandall Stewart */ 316842551e99SRandall Stewart tp1->whoTo->cwnd += tp1->book_size; 3169f8829a4aSRandall Stewart tot_revoked++; 3170f8829a4aSRandall Stewart #ifdef SCTP_SACK_LOGGING 3171f8829a4aSRandall Stewart sctp_log_sack(asoc->last_acked_seq, 3172f8829a4aSRandall Stewart cumack, 3173f8829a4aSRandall Stewart tp1->rec.data.TSN_seq, 3174f8829a4aSRandall Stewart 0, 3175f8829a4aSRandall Stewart 0, 3176f8829a4aSRandall Stewart SCTP_LOG_TSN_REVOKED); 3177f8829a4aSRandall Stewart #endif 3178f8829a4aSRandall Stewart } else if (tp1->sent == SCTP_DATAGRAM_MARKED) { 3179f8829a4aSRandall Stewart /* it has been re-acked in this SACK */ 3180f8829a4aSRandall Stewart tp1->sent = SCTP_DATAGRAM_ACKED; 3181f8829a4aSRandall Stewart } 3182f8829a4aSRandall Stewart } 3183f8829a4aSRandall Stewart if (tp1->sent == SCTP_DATAGRAM_UNSENT) 3184f8829a4aSRandall Stewart break; 3185f8829a4aSRandall Stewart tp1 = TAILQ_NEXT(tp1, sctp_next); 3186f8829a4aSRandall Stewart } 3187f8829a4aSRandall Stewart if (tot_revoked > 0) { 3188f8829a4aSRandall Stewart /* 3189f8829a4aSRandall Stewart * Setup the ecn nonce re-sync point. We do this since once 3190f8829a4aSRandall Stewart * data is revoked we begin to retransmit things, which do 3191f8829a4aSRandall Stewart * NOT have the ECN bits set. This means we are now out of 3192f8829a4aSRandall Stewart * sync and must wait until we get back in sync with the 3193f8829a4aSRandall Stewart * peer to check ECN bits. 3194f8829a4aSRandall Stewart */ 3195f8829a4aSRandall Stewart tp1 = TAILQ_FIRST(&asoc->send_queue); 3196f8829a4aSRandall Stewart if (tp1 == NULL) { 3197f8829a4aSRandall Stewart asoc->nonce_resync_tsn = asoc->sending_seq; 3198f8829a4aSRandall Stewart } else { 3199f8829a4aSRandall Stewart asoc->nonce_resync_tsn = tp1->rec.data.TSN_seq; 3200f8829a4aSRandall Stewart } 3201f8829a4aSRandall Stewart asoc->nonce_wait_for_ecne = 0; 3202f8829a4aSRandall Stewart asoc->nonce_sum_check = 0; 3203f8829a4aSRandall Stewart } 3204f8829a4aSRandall Stewart } 3205f8829a4aSRandall Stewart 3206f8829a4aSRandall Stewart static void 3207f8829a4aSRandall Stewart sctp_strike_gap_ack_chunks(struct sctp_tcb *stcb, struct sctp_association *asoc, 3208f8829a4aSRandall Stewart u_long biggest_tsn_acked, u_long biggest_tsn_newly_acked, u_long this_sack_lowest_newack, int accum_moved) 3209f8829a4aSRandall Stewart { 3210f8829a4aSRandall Stewart struct sctp_tmit_chunk *tp1; 3211f8829a4aSRandall Stewart int strike_flag = 0; 3212f8829a4aSRandall Stewart struct timeval now; 3213f8829a4aSRandall Stewart int tot_retrans = 0; 3214f8829a4aSRandall Stewart uint32_t sending_seq; 3215f8829a4aSRandall Stewart struct sctp_nets *net; 3216f8829a4aSRandall Stewart int num_dests_sacked = 0; 3217f8829a4aSRandall Stewart 3218f8829a4aSRandall Stewart /* 3219f8829a4aSRandall Stewart * select the sending_seq, this is either the next thing ready to be 3220f8829a4aSRandall Stewart * sent but not transmitted, OR, the next seq we assign. 3221f8829a4aSRandall Stewart */ 3222f8829a4aSRandall Stewart tp1 = TAILQ_FIRST(&stcb->asoc.send_queue); 3223f8829a4aSRandall Stewart if (tp1 == NULL) { 3224f8829a4aSRandall Stewart sending_seq = asoc->sending_seq; 3225f8829a4aSRandall Stewart } else { 3226f8829a4aSRandall Stewart sending_seq = tp1->rec.data.TSN_seq; 3227f8829a4aSRandall Stewart } 3228f8829a4aSRandall Stewart 3229f8829a4aSRandall Stewart /* CMT DAC algo: finding out if SACK is a mixed SACK */ 3230f8829a4aSRandall Stewart if (sctp_cmt_on_off && sctp_cmt_use_dac) { 3231f8829a4aSRandall Stewart TAILQ_FOREACH(net, &asoc->nets, sctp_next) { 3232f8829a4aSRandall Stewart if (net->saw_newack) 3233f8829a4aSRandall Stewart num_dests_sacked++; 3234f8829a4aSRandall Stewart } 3235f8829a4aSRandall Stewart } 3236f8829a4aSRandall Stewart if (stcb->asoc.peer_supports_prsctp) { 32376e55db54SRandall Stewart (void)SCTP_GETTIME_TIMEVAL(&now); 3238f8829a4aSRandall Stewart } 3239f8829a4aSRandall Stewart tp1 = TAILQ_FIRST(&asoc->sent_queue); 3240f8829a4aSRandall Stewart while (tp1) { 3241f8829a4aSRandall Stewart strike_flag = 0; 3242f8829a4aSRandall Stewart if (tp1->no_fr_allowed) { 3243f8829a4aSRandall Stewart /* this one had a timeout or something */ 3244f8829a4aSRandall Stewart tp1 = TAILQ_NEXT(tp1, sctp_next); 3245f8829a4aSRandall Stewart continue; 3246f8829a4aSRandall Stewart } 3247f8829a4aSRandall Stewart #ifdef SCTP_FR_LOGGING 3248f8829a4aSRandall Stewart if (tp1->sent < SCTP_DATAGRAM_RESEND) 3249f8829a4aSRandall Stewart sctp_log_fr(biggest_tsn_newly_acked, 3250f8829a4aSRandall Stewart tp1->rec.data.TSN_seq, 3251f8829a4aSRandall Stewart tp1->sent, 3252f8829a4aSRandall Stewart SCTP_FR_LOG_CHECK_STRIKE); 3253f8829a4aSRandall Stewart #endif 3254f8829a4aSRandall Stewart if (compare_with_wrap(tp1->rec.data.TSN_seq, biggest_tsn_acked, 3255f8829a4aSRandall Stewart MAX_TSN) || 3256f8829a4aSRandall Stewart tp1->sent == SCTP_DATAGRAM_UNSENT) { 3257f8829a4aSRandall Stewart /* done */ 3258f8829a4aSRandall Stewart break; 3259f8829a4aSRandall Stewart } 3260f8829a4aSRandall Stewart if (stcb->asoc.peer_supports_prsctp) { 3261f8829a4aSRandall Stewart if ((PR_SCTP_TTL_ENABLED(tp1->flags)) && tp1->sent < SCTP_DATAGRAM_ACKED) { 3262f8829a4aSRandall Stewart /* Is it expired? */ 32635e54f665SRandall Stewart if ( 32645e54f665SRandall Stewart (timevalcmp(&now, &tp1->rec.data.timetodrop, >)) 32655e54f665SRandall Stewart ) { 3266f8829a4aSRandall Stewart /* Yes so drop it */ 3267f8829a4aSRandall Stewart if (tp1->data != NULL) { 3268f8829a4aSRandall Stewart sctp_release_pr_sctp_chunk(stcb, tp1, 3269f8829a4aSRandall Stewart (SCTP_RESPONSE_TO_USER_REQ | SCTP_NOTIFY_DATAGRAM_SENT), 3270f8829a4aSRandall Stewart &asoc->sent_queue); 3271f8829a4aSRandall Stewart } 3272f8829a4aSRandall Stewart tp1 = TAILQ_NEXT(tp1, sctp_next); 3273f8829a4aSRandall Stewart continue; 3274f8829a4aSRandall Stewart } 3275f8829a4aSRandall Stewart } 3276f8829a4aSRandall Stewart if ((PR_SCTP_RTX_ENABLED(tp1->flags)) && tp1->sent < SCTP_DATAGRAM_ACKED) { 3277f8829a4aSRandall Stewart /* Has it been retransmitted tv_sec times? */ 3278f8829a4aSRandall Stewart if (tp1->snd_count > tp1->rec.data.timetodrop.tv_sec) { 3279f8829a4aSRandall Stewart /* Yes, so drop it */ 3280f8829a4aSRandall Stewart if (tp1->data != NULL) { 3281f8829a4aSRandall Stewart sctp_release_pr_sctp_chunk(stcb, tp1, 3282f8829a4aSRandall Stewart (SCTP_RESPONSE_TO_USER_REQ | SCTP_NOTIFY_DATAGRAM_SENT), 3283f8829a4aSRandall Stewart &asoc->sent_queue); 3284f8829a4aSRandall Stewart } 3285f8829a4aSRandall Stewart tp1 = TAILQ_NEXT(tp1, sctp_next); 3286f8829a4aSRandall Stewart continue; 3287f8829a4aSRandall Stewart } 3288f8829a4aSRandall Stewart } 3289f8829a4aSRandall Stewart } 3290f8829a4aSRandall Stewart if (compare_with_wrap(tp1->rec.data.TSN_seq, 3291f8829a4aSRandall Stewart asoc->this_sack_highest_gap, MAX_TSN)) { 3292f8829a4aSRandall Stewart /* we are beyond the tsn in the sack */ 3293f8829a4aSRandall Stewart break; 3294f8829a4aSRandall Stewart } 3295f8829a4aSRandall Stewart if (tp1->sent >= SCTP_DATAGRAM_RESEND) { 3296f8829a4aSRandall Stewart /* either a RESEND, ACKED, or MARKED */ 3297f8829a4aSRandall Stewart /* skip */ 3298f8829a4aSRandall Stewart tp1 = TAILQ_NEXT(tp1, sctp_next); 3299f8829a4aSRandall Stewart continue; 3300f8829a4aSRandall Stewart } 3301f8829a4aSRandall Stewart /* 3302f8829a4aSRandall Stewart * CMT : SFR algo (covers part of DAC and HTNA as well) 3303f8829a4aSRandall Stewart */ 3304f8829a4aSRandall Stewart if (tp1->whoTo->saw_newack == 0) { 3305f8829a4aSRandall Stewart /* 3306f8829a4aSRandall Stewart * No new acks were receieved for data sent to this 3307f8829a4aSRandall Stewart * dest. Therefore, according to the SFR algo for 3308f8829a4aSRandall Stewart * CMT, no data sent to this dest can be marked for 3309c105859eSRandall Stewart * FR using this SACK. 3310f8829a4aSRandall Stewart */ 3311f8829a4aSRandall Stewart tp1 = TAILQ_NEXT(tp1, sctp_next); 3312f8829a4aSRandall Stewart continue; 3313f8829a4aSRandall Stewart } else if (compare_with_wrap(tp1->rec.data.TSN_seq, 3314f8829a4aSRandall Stewart tp1->whoTo->this_sack_highest_newack, MAX_TSN)) { 3315f8829a4aSRandall Stewart /* 3316f8829a4aSRandall Stewart * CMT: New acks were receieved for data sent to 3317f8829a4aSRandall Stewart * this dest. But no new acks were seen for data 3318f8829a4aSRandall Stewart * sent after tp1. Therefore, according to the SFR 3319f8829a4aSRandall Stewart * algo for CMT, tp1 cannot be marked for FR using 3320f8829a4aSRandall Stewart * this SACK. This step covers part of the DAC algo 3321f8829a4aSRandall Stewart * and the HTNA algo as well. 3322f8829a4aSRandall Stewart */ 3323f8829a4aSRandall Stewart tp1 = TAILQ_NEXT(tp1, sctp_next); 3324f8829a4aSRandall Stewart continue; 3325f8829a4aSRandall Stewart } 3326f8829a4aSRandall Stewart /* 3327f8829a4aSRandall Stewart * Here we check to see if we were have already done a FR 3328f8829a4aSRandall Stewart * and if so we see if the biggest TSN we saw in the sack is 3329f8829a4aSRandall Stewart * smaller than the recovery point. If so we don't strike 3330f8829a4aSRandall Stewart * the tsn... otherwise we CAN strike the TSN. 3331f8829a4aSRandall Stewart */ 3332f8829a4aSRandall Stewart /* 333342551e99SRandall Stewart * @@@ JRI: Check for CMT if (accum_moved && 333442551e99SRandall Stewart * asoc->fast_retran_loss_recovery && (sctp_cmt_on_off == 333542551e99SRandall Stewart * 0)) { 3336f8829a4aSRandall Stewart */ 333742551e99SRandall Stewart if (accum_moved && asoc->fast_retran_loss_recovery) { 3338f8829a4aSRandall Stewart /* 3339f8829a4aSRandall Stewart * Strike the TSN if in fast-recovery and cum-ack 3340f8829a4aSRandall Stewart * moved. 3341f8829a4aSRandall Stewart */ 3342f8829a4aSRandall Stewart #ifdef SCTP_FR_LOGGING 3343f8829a4aSRandall Stewart sctp_log_fr(biggest_tsn_newly_acked, 3344f8829a4aSRandall Stewart tp1->rec.data.TSN_seq, 3345f8829a4aSRandall Stewart tp1->sent, 3346f8829a4aSRandall Stewart SCTP_FR_LOG_STRIKE_CHUNK); 3347f8829a4aSRandall Stewart #endif 33485e54f665SRandall Stewart if (tp1->sent < SCTP_DATAGRAM_RESEND) { 3349f8829a4aSRandall Stewart tp1->sent++; 33505e54f665SRandall Stewart } 3351f8829a4aSRandall Stewart if (sctp_cmt_on_off && sctp_cmt_use_dac) { 3352f8829a4aSRandall Stewart /* 3353f8829a4aSRandall Stewart * CMT DAC algorithm: If SACK flag is set to 3354f8829a4aSRandall Stewart * 0, then lowest_newack test will not pass 3355f8829a4aSRandall Stewart * because it would have been set to the 3356f8829a4aSRandall Stewart * cumack earlier. If not already to be 3357f8829a4aSRandall Stewart * rtx'd, If not a mixed sack and if tp1 is 3358f8829a4aSRandall Stewart * not between two sacked TSNs, then mark by 3359c105859eSRandall Stewart * one more. NOTE that we are marking by one 3360c105859eSRandall Stewart * additional time since the SACK DAC flag 3361c105859eSRandall Stewart * indicates that two packets have been 3362c105859eSRandall Stewart * received after this missing TSN. 33635e54f665SRandall Stewart */ 33645e54f665SRandall Stewart if ((tp1->sent < SCTP_DATAGRAM_RESEND) && (num_dests_sacked == 1) && 3365f8829a4aSRandall Stewart compare_with_wrap(this_sack_lowest_newack, tp1->rec.data.TSN_seq, MAX_TSN)) { 3366f8829a4aSRandall Stewart #ifdef SCTP_FR_LOGGING 3367f8829a4aSRandall Stewart sctp_log_fr(16 + num_dests_sacked, 3368f8829a4aSRandall Stewart tp1->rec.data.TSN_seq, 3369f8829a4aSRandall Stewart tp1->sent, 3370f8829a4aSRandall Stewart SCTP_FR_LOG_STRIKE_CHUNK); 3371f8829a4aSRandall Stewart #endif 3372f8829a4aSRandall Stewart tp1->sent++; 3373f8829a4aSRandall Stewart } 3374f8829a4aSRandall Stewart } 3375f8829a4aSRandall Stewart } else if (tp1->rec.data.doing_fast_retransmit) { 3376f8829a4aSRandall Stewart /* 3377f8829a4aSRandall Stewart * For those that have done a FR we must take 3378f8829a4aSRandall Stewart * special consideration if we strike. I.e the 3379f8829a4aSRandall Stewart * biggest_newly_acked must be higher than the 3380f8829a4aSRandall Stewart * sending_seq at the time we did the FR. 3381f8829a4aSRandall Stewart */ 33825e54f665SRandall Stewart if ( 3383f8829a4aSRandall Stewart #ifdef SCTP_FR_TO_ALTERNATE 3384f8829a4aSRandall Stewart /* 3385f8829a4aSRandall Stewart * If FR's go to new networks, then we must only do 3386f8829a4aSRandall Stewart * this for singly homed asoc's. However if the FR's 3387f8829a4aSRandall Stewart * go to the same network (Armando's work) then its 3388f8829a4aSRandall Stewart * ok to FR multiple times. 3389f8829a4aSRandall Stewart */ 33905e54f665SRandall Stewart (asoc->numnets < 2) 3391f8829a4aSRandall Stewart #else 33925e54f665SRandall Stewart (1) 3393f8829a4aSRandall Stewart #endif 33945e54f665SRandall Stewart ) { 33955e54f665SRandall Stewart 3396f8829a4aSRandall Stewart if ((compare_with_wrap(biggest_tsn_newly_acked, 3397f8829a4aSRandall Stewart tp1->rec.data.fast_retran_tsn, MAX_TSN)) || 3398f8829a4aSRandall Stewart (biggest_tsn_newly_acked == 3399f8829a4aSRandall Stewart tp1->rec.data.fast_retran_tsn)) { 3400f8829a4aSRandall Stewart /* 3401f8829a4aSRandall Stewart * Strike the TSN, since this ack is 3402f8829a4aSRandall Stewart * beyond where things were when we 3403f8829a4aSRandall Stewart * did a FR. 3404f8829a4aSRandall Stewart */ 3405f8829a4aSRandall Stewart #ifdef SCTP_FR_LOGGING 3406f8829a4aSRandall Stewart sctp_log_fr(biggest_tsn_newly_acked, 3407f8829a4aSRandall Stewart tp1->rec.data.TSN_seq, 3408f8829a4aSRandall Stewart tp1->sent, 3409f8829a4aSRandall Stewart SCTP_FR_LOG_STRIKE_CHUNK); 3410f8829a4aSRandall Stewart #endif 34115e54f665SRandall Stewart if (tp1->sent < SCTP_DATAGRAM_RESEND) { 3412f8829a4aSRandall Stewart tp1->sent++; 34135e54f665SRandall Stewart } 3414f8829a4aSRandall Stewart strike_flag = 1; 3415f8829a4aSRandall Stewart if (sctp_cmt_on_off && sctp_cmt_use_dac) { 3416f8829a4aSRandall Stewart /* 3417f8829a4aSRandall Stewart * CMT DAC algorithm: If 3418f8829a4aSRandall Stewart * SACK flag is set to 0, 3419f8829a4aSRandall Stewart * then lowest_newack test 3420f8829a4aSRandall Stewart * will not pass because it 3421f8829a4aSRandall Stewart * would have been set to 3422f8829a4aSRandall Stewart * the cumack earlier. If 3423f8829a4aSRandall Stewart * not already to be rtx'd, 3424f8829a4aSRandall Stewart * If not a mixed sack and 3425f8829a4aSRandall Stewart * if tp1 is not between two 3426f8829a4aSRandall Stewart * sacked TSNs, then mark by 3427c105859eSRandall Stewart * one more. NOTE that we 3428c105859eSRandall Stewart * are marking by one 3429c105859eSRandall Stewart * additional time since the 3430c105859eSRandall Stewart * SACK DAC flag indicates 3431c105859eSRandall Stewart * that two packets have 3432c105859eSRandall Stewart * been received after this 3433c105859eSRandall Stewart * missing TSN. 3434f8829a4aSRandall Stewart */ 34355e54f665SRandall Stewart if ((tp1->sent < SCTP_DATAGRAM_RESEND) && 34365e54f665SRandall Stewart (num_dests_sacked == 1) && 34375e54f665SRandall Stewart compare_with_wrap(this_sack_lowest_newack, 34385e54f665SRandall Stewart tp1->rec.data.TSN_seq, MAX_TSN)) { 3439f8829a4aSRandall Stewart #ifdef SCTP_FR_LOGGING 3440f8829a4aSRandall Stewart sctp_log_fr(32 + num_dests_sacked, 3441f8829a4aSRandall Stewart tp1->rec.data.TSN_seq, 3442f8829a4aSRandall Stewart tp1->sent, 3443f8829a4aSRandall Stewart SCTP_FR_LOG_STRIKE_CHUNK); 3444f8829a4aSRandall Stewart #endif 34455e54f665SRandall Stewart if (tp1->sent < SCTP_DATAGRAM_RESEND) { 3446f8829a4aSRandall Stewart tp1->sent++; 34475e54f665SRandall Stewart 34485e54f665SRandall Stewart } 3449f8829a4aSRandall Stewart } 3450f8829a4aSRandall Stewart } 3451f8829a4aSRandall Stewart } 3452f8829a4aSRandall Stewart } 3453f8829a4aSRandall Stewart /* 345442551e99SRandall Stewart * JRI: TODO: remove code for HTNA algo. CMT's SFR 345542551e99SRandall Stewart * algo covers HTNA. 3456f8829a4aSRandall Stewart */ 3457f8829a4aSRandall Stewart } else if (compare_with_wrap(tp1->rec.data.TSN_seq, 3458f8829a4aSRandall Stewart biggest_tsn_newly_acked, MAX_TSN)) { 3459f8829a4aSRandall Stewart /* 3460f8829a4aSRandall Stewart * We don't strike these: This is the HTNA 3461f8829a4aSRandall Stewart * algorithm i.e. we don't strike If our TSN is 3462f8829a4aSRandall Stewart * larger than the Highest TSN Newly Acked. 3463f8829a4aSRandall Stewart */ 3464f8829a4aSRandall Stewart ; 3465f8829a4aSRandall Stewart } else { 3466f8829a4aSRandall Stewart /* Strike the TSN */ 3467f8829a4aSRandall Stewart #ifdef SCTP_FR_LOGGING 3468f8829a4aSRandall Stewart sctp_log_fr(biggest_tsn_newly_acked, 3469f8829a4aSRandall Stewart tp1->rec.data.TSN_seq, 3470f8829a4aSRandall Stewart tp1->sent, 3471f8829a4aSRandall Stewart SCTP_FR_LOG_STRIKE_CHUNK); 3472f8829a4aSRandall Stewart #endif 34735e54f665SRandall Stewart if (tp1->sent < SCTP_DATAGRAM_RESEND) { 3474f8829a4aSRandall Stewart tp1->sent++; 34755e54f665SRandall Stewart } 3476f8829a4aSRandall Stewart if (sctp_cmt_on_off && sctp_cmt_use_dac) { 3477f8829a4aSRandall Stewart /* 3478f8829a4aSRandall Stewart * CMT DAC algorithm: If SACK flag is set to 3479f8829a4aSRandall Stewart * 0, then lowest_newack test will not pass 3480f8829a4aSRandall Stewart * because it would have been set to the 3481f8829a4aSRandall Stewart * cumack earlier. If not already to be 3482f8829a4aSRandall Stewart * rtx'd, If not a mixed sack and if tp1 is 3483f8829a4aSRandall Stewart * not between two sacked TSNs, then mark by 3484c105859eSRandall Stewart * one more. NOTE that we are marking by one 3485c105859eSRandall Stewart * additional time since the SACK DAC flag 3486c105859eSRandall Stewart * indicates that two packets have been 3487c105859eSRandall Stewart * received after this missing TSN. 3488f8829a4aSRandall Stewart */ 34895e54f665SRandall Stewart if ((tp1->sent < SCTP_DATAGRAM_RESEND) && (num_dests_sacked == 1) && 3490f8829a4aSRandall Stewart compare_with_wrap(this_sack_lowest_newack, tp1->rec.data.TSN_seq, MAX_TSN)) { 3491f8829a4aSRandall Stewart #ifdef SCTP_FR_LOGGING 3492f8829a4aSRandall Stewart sctp_log_fr(48 + num_dests_sacked, 3493f8829a4aSRandall Stewart tp1->rec.data.TSN_seq, 3494f8829a4aSRandall Stewart tp1->sent, 3495f8829a4aSRandall Stewart SCTP_FR_LOG_STRIKE_CHUNK); 3496f8829a4aSRandall Stewart #endif 3497f8829a4aSRandall Stewart tp1->sent++; 3498f8829a4aSRandall Stewart } 3499f8829a4aSRandall Stewart } 3500f8829a4aSRandall Stewart } 3501f8829a4aSRandall Stewart if (tp1->sent == SCTP_DATAGRAM_RESEND) { 3502f8829a4aSRandall Stewart /* Increment the count to resend */ 3503f8829a4aSRandall Stewart struct sctp_nets *alt; 3504f8829a4aSRandall Stewart 3505f8829a4aSRandall Stewart /* printf("OK, we are now ready to FR this guy\n"); */ 3506f8829a4aSRandall Stewart #ifdef SCTP_FR_LOGGING 3507f8829a4aSRandall Stewart sctp_log_fr(tp1->rec.data.TSN_seq, tp1->snd_count, 3508f8829a4aSRandall Stewart 0, SCTP_FR_MARKED); 3509f8829a4aSRandall Stewart #endif 3510f8829a4aSRandall Stewart if (strike_flag) { 3511f8829a4aSRandall Stewart /* This is a subsequent FR */ 3512f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_sendmultfastretrans); 3513f8829a4aSRandall Stewart } 35145e54f665SRandall Stewart sctp_ucount_incr(stcb->asoc.sent_queue_retran_cnt); 3515f8829a4aSRandall Stewart if (sctp_cmt_on_off) { 3516f8829a4aSRandall Stewart /* 3517f8829a4aSRandall Stewart * CMT: Using RTX_SSTHRESH policy for CMT. 3518f8829a4aSRandall Stewart * If CMT is being used, then pick dest with 3519f8829a4aSRandall Stewart * largest ssthresh for any retransmission. 3520f8829a4aSRandall Stewart */ 3521f8829a4aSRandall Stewart tp1->no_fr_allowed = 1; 3522f8829a4aSRandall Stewart alt = tp1->whoTo; 3523f8829a4aSRandall Stewart alt = sctp_find_alternate_net(stcb, alt, 1); 3524f8829a4aSRandall Stewart /* 3525f8829a4aSRandall Stewart * CUCv2: If a different dest is picked for 3526f8829a4aSRandall Stewart * the retransmission, then new 3527f8829a4aSRandall Stewart * (rtx-)pseudo_cumack needs to be tracked 3528f8829a4aSRandall Stewart * for orig dest. Let CUCv2 track new (rtx-) 3529f8829a4aSRandall Stewart * pseudo-cumack always. 3530f8829a4aSRandall Stewart */ 3531f8829a4aSRandall Stewart tp1->whoTo->find_pseudo_cumack = 1; 3532f8829a4aSRandall Stewart tp1->whoTo->find_rtx_pseudo_cumack = 1; 3533f8829a4aSRandall Stewart 3534f8829a4aSRandall Stewart 3535f8829a4aSRandall Stewart } else {/* CMT is OFF */ 3536f8829a4aSRandall Stewart 3537f8829a4aSRandall Stewart #ifdef SCTP_FR_TO_ALTERNATE 3538f8829a4aSRandall Stewart /* Can we find an alternate? */ 3539f8829a4aSRandall Stewart alt = sctp_find_alternate_net(stcb, tp1->whoTo, 0); 3540f8829a4aSRandall Stewart #else 3541f8829a4aSRandall Stewart /* 3542f8829a4aSRandall Stewart * default behavior is to NOT retransmit 3543f8829a4aSRandall Stewart * FR's to an alternate. Armando Caro's 3544f8829a4aSRandall Stewart * paper details why. 3545f8829a4aSRandall Stewart */ 3546f8829a4aSRandall Stewart alt = tp1->whoTo; 3547f8829a4aSRandall Stewart #endif 3548f8829a4aSRandall Stewart } 3549f8829a4aSRandall Stewart 3550f8829a4aSRandall Stewart tp1->rec.data.doing_fast_retransmit = 1; 3551f8829a4aSRandall Stewart tot_retrans++; 3552f8829a4aSRandall Stewart /* mark the sending seq for possible subsequent FR's */ 3553f8829a4aSRandall Stewart /* 3554f8829a4aSRandall Stewart * printf("Marking TSN for FR new value %x\n", 3555f8829a4aSRandall Stewart * (uint32_t)tpi->rec.data.TSN_seq); 3556f8829a4aSRandall Stewart */ 3557f8829a4aSRandall Stewart if (TAILQ_EMPTY(&asoc->send_queue)) { 3558f8829a4aSRandall Stewart /* 3559f8829a4aSRandall Stewart * If the queue of send is empty then its 3560f8829a4aSRandall Stewart * the next sequence number that will be 3561f8829a4aSRandall Stewart * assigned so we subtract one from this to 3562f8829a4aSRandall Stewart * get the one we last sent. 3563f8829a4aSRandall Stewart */ 3564f8829a4aSRandall Stewart tp1->rec.data.fast_retran_tsn = sending_seq; 3565f8829a4aSRandall Stewart } else { 3566f8829a4aSRandall Stewart /* 3567f8829a4aSRandall Stewart * If there are chunks on the send queue 3568f8829a4aSRandall Stewart * (unsent data that has made it from the 3569f8829a4aSRandall Stewart * stream queues but not out the door, we 3570f8829a4aSRandall Stewart * take the first one (which will have the 3571f8829a4aSRandall Stewart * lowest TSN) and subtract one to get the 3572f8829a4aSRandall Stewart * one we last sent. 3573f8829a4aSRandall Stewart */ 3574f8829a4aSRandall Stewart struct sctp_tmit_chunk *ttt; 3575f8829a4aSRandall Stewart 3576f8829a4aSRandall Stewart ttt = TAILQ_FIRST(&asoc->send_queue); 3577f8829a4aSRandall Stewart tp1->rec.data.fast_retran_tsn = 3578f8829a4aSRandall Stewart ttt->rec.data.TSN_seq; 3579f8829a4aSRandall Stewart } 3580f8829a4aSRandall Stewart 3581f8829a4aSRandall Stewart if (tp1->do_rtt) { 3582f8829a4aSRandall Stewart /* 3583f8829a4aSRandall Stewart * this guy had a RTO calculation pending on 3584f8829a4aSRandall Stewart * it, cancel it 3585f8829a4aSRandall Stewart */ 3586f8829a4aSRandall Stewart tp1->do_rtt = 0; 3587f8829a4aSRandall Stewart } 3588f8829a4aSRandall Stewart /* fix counts and things */ 3589a5d547adSRandall Stewart #ifdef SCTP_FLIGHT_LOGGING 3590c105859eSRandall Stewart sctp_misc_ints(SCTP_FLIGHT_LOG_DOWN_RSND, 3591a5d547adSRandall Stewart tp1->whoTo->flight_size, 3592a5d547adSRandall Stewart tp1->book_size, 3593c105859eSRandall Stewart (uintptr_t) tp1->whoTo, 3594a5d547adSRandall Stewart tp1->rec.data.TSN_seq); 3595a5d547adSRandall Stewart #endif 3596f8829a4aSRandall Stewart tp1->whoTo->net_ack++; 3597c105859eSRandall Stewart sctp_flight_size_decrease(tp1); 3598f8829a4aSRandall Stewart 3599f8829a4aSRandall Stewart #ifdef SCTP_LOG_RWND 3600f8829a4aSRandall Stewart sctp_log_rwnd(SCTP_INCREASE_PEER_RWND, 3601f8829a4aSRandall Stewart asoc->peers_rwnd, tp1->send_size, sctp_peer_chunk_oh); 3602f8829a4aSRandall Stewart #endif 3603f8829a4aSRandall Stewart /* add back to the rwnd */ 3604f8829a4aSRandall Stewart asoc->peers_rwnd += (tp1->send_size + sctp_peer_chunk_oh); 3605f8829a4aSRandall Stewart 3606f8829a4aSRandall Stewart /* remove from the total flight */ 3607c105859eSRandall Stewart sctp_total_flight_decrease(stcb, tp1); 3608f8829a4aSRandall Stewart if (alt != tp1->whoTo) { 3609f8829a4aSRandall Stewart /* yes, there is an alternate. */ 3610f8829a4aSRandall Stewart sctp_free_remote_addr(tp1->whoTo); 3611f8829a4aSRandall Stewart tp1->whoTo = alt; 3612f8829a4aSRandall Stewart atomic_add_int(&alt->ref_count, 1); 3613f8829a4aSRandall Stewart } 3614f8829a4aSRandall Stewart } 3615f8829a4aSRandall Stewart tp1 = TAILQ_NEXT(tp1, sctp_next); 3616f8829a4aSRandall Stewart } /* while (tp1) */ 3617f8829a4aSRandall Stewart 3618f8829a4aSRandall Stewart if (tot_retrans > 0) { 3619f8829a4aSRandall Stewart /* 3620f8829a4aSRandall Stewart * Setup the ecn nonce re-sync point. We do this since once 3621f8829a4aSRandall Stewart * we go to FR something we introduce a Karn's rule scenario 3622f8829a4aSRandall Stewart * and won't know the totals for the ECN bits. 3623f8829a4aSRandall Stewart */ 3624f8829a4aSRandall Stewart asoc->nonce_resync_tsn = sending_seq; 3625f8829a4aSRandall Stewart asoc->nonce_wait_for_ecne = 0; 3626f8829a4aSRandall Stewart asoc->nonce_sum_check = 0; 3627f8829a4aSRandall Stewart } 3628f8829a4aSRandall Stewart } 3629f8829a4aSRandall Stewart 3630f8829a4aSRandall Stewart struct sctp_tmit_chunk * 3631f8829a4aSRandall Stewart sctp_try_advance_peer_ack_point(struct sctp_tcb *stcb, 3632f8829a4aSRandall Stewart struct sctp_association *asoc) 3633f8829a4aSRandall Stewart { 3634f8829a4aSRandall Stewart struct sctp_tmit_chunk *tp1, *tp2, *a_adv = NULL; 3635f8829a4aSRandall Stewart struct timeval now; 3636f8829a4aSRandall Stewart int now_filled = 0; 3637f8829a4aSRandall Stewart 3638f8829a4aSRandall Stewart if (asoc->peer_supports_prsctp == 0) { 3639f8829a4aSRandall Stewart return (NULL); 3640f8829a4aSRandall Stewart } 3641f8829a4aSRandall Stewart tp1 = TAILQ_FIRST(&asoc->sent_queue); 3642f8829a4aSRandall Stewart while (tp1) { 3643f8829a4aSRandall Stewart if (tp1->sent != SCTP_FORWARD_TSN_SKIP && 3644f8829a4aSRandall Stewart tp1->sent != SCTP_DATAGRAM_RESEND) { 3645f8829a4aSRandall Stewart /* no chance to advance, out of here */ 3646f8829a4aSRandall Stewart break; 3647f8829a4aSRandall Stewart } 3648f8829a4aSRandall Stewart if (!PR_SCTP_ENABLED(tp1->flags)) { 3649f8829a4aSRandall Stewart /* 3650f8829a4aSRandall Stewart * We can't fwd-tsn past any that are reliable aka 3651f8829a4aSRandall Stewart * retransmitted until the asoc fails. 3652f8829a4aSRandall Stewart */ 3653f8829a4aSRandall Stewart break; 3654f8829a4aSRandall Stewart } 3655f8829a4aSRandall Stewart if (!now_filled) { 36566e55db54SRandall Stewart (void)SCTP_GETTIME_TIMEVAL(&now); 3657f8829a4aSRandall Stewart now_filled = 1; 3658f8829a4aSRandall Stewart } 3659f8829a4aSRandall Stewart tp2 = TAILQ_NEXT(tp1, sctp_next); 3660f8829a4aSRandall Stewart /* 3661f8829a4aSRandall Stewart * now we got a chunk which is marked for another 3662f8829a4aSRandall Stewart * retransmission to a PR-stream but has run out its chances 3663f8829a4aSRandall Stewart * already maybe OR has been marked to skip now. Can we skip 3664f8829a4aSRandall Stewart * it if its a resend? 3665f8829a4aSRandall Stewart */ 3666f8829a4aSRandall Stewart if (tp1->sent == SCTP_DATAGRAM_RESEND && 3667f8829a4aSRandall Stewart (PR_SCTP_TTL_ENABLED(tp1->flags))) { 3668f8829a4aSRandall Stewart /* 3669f8829a4aSRandall Stewart * Now is this one marked for resend and its time is 3670f8829a4aSRandall Stewart * now up? 3671f8829a4aSRandall Stewart */ 3672f8829a4aSRandall Stewart if (timevalcmp(&now, &tp1->rec.data.timetodrop, >)) { 3673f8829a4aSRandall Stewart /* Yes so drop it */ 3674f8829a4aSRandall Stewart if (tp1->data) { 3675f8829a4aSRandall Stewart sctp_release_pr_sctp_chunk(stcb, tp1, 3676f8829a4aSRandall Stewart (SCTP_RESPONSE_TO_USER_REQ | SCTP_NOTIFY_DATAGRAM_SENT), 3677f8829a4aSRandall Stewart &asoc->sent_queue); 3678f8829a4aSRandall Stewart } 3679f8829a4aSRandall Stewart } else { 3680f8829a4aSRandall Stewart /* 3681f8829a4aSRandall Stewart * No, we are done when hit one for resend 3682f8829a4aSRandall Stewart * whos time as not expired. 3683f8829a4aSRandall Stewart */ 3684f8829a4aSRandall Stewart break; 3685f8829a4aSRandall Stewart } 3686f8829a4aSRandall Stewart } 3687f8829a4aSRandall Stewart /* 3688f8829a4aSRandall Stewart * Ok now if this chunk is marked to drop it we can clean up 3689f8829a4aSRandall Stewart * the chunk, advance our peer ack point and we can check 3690f8829a4aSRandall Stewart * the next chunk. 3691f8829a4aSRandall Stewart */ 3692f8829a4aSRandall Stewart if (tp1->sent == SCTP_FORWARD_TSN_SKIP) { 3693f8829a4aSRandall Stewart /* advance PeerAckPoint goes forward */ 3694f8829a4aSRandall Stewart asoc->advanced_peer_ack_point = tp1->rec.data.TSN_seq; 3695f8829a4aSRandall Stewart a_adv = tp1; 3696f8829a4aSRandall Stewart /* 3697f8829a4aSRandall Stewart * we don't want to de-queue it here. Just wait for 3698f8829a4aSRandall Stewart * the next peer SACK to come with a new cumTSN and 3699f8829a4aSRandall Stewart * then the chunk will be droped in the normal 3700f8829a4aSRandall Stewart * fashion. 3701f8829a4aSRandall Stewart */ 3702f8829a4aSRandall Stewart if (tp1->data) { 3703f8829a4aSRandall Stewart sctp_free_bufspace(stcb, asoc, tp1, 1); 3704f8829a4aSRandall Stewart /* 3705f8829a4aSRandall Stewart * Maybe there should be another 3706f8829a4aSRandall Stewart * notification type 3707f8829a4aSRandall Stewart */ 3708f8829a4aSRandall Stewart sctp_ulp_notify(SCTP_NOTIFY_DG_FAIL, stcb, 3709f8829a4aSRandall Stewart (SCTP_RESPONSE_TO_USER_REQ | SCTP_NOTIFY_DATAGRAM_SENT), 3710f8829a4aSRandall Stewart tp1); 3711f8829a4aSRandall Stewart sctp_m_freem(tp1->data); 3712f8829a4aSRandall Stewart tp1->data = NULL; 3713f8829a4aSRandall Stewart if (stcb->sctp_socket) { 3714f8829a4aSRandall Stewart sctp_sowwakeup(stcb->sctp_ep, 3715f8829a4aSRandall Stewart stcb->sctp_socket); 3716f8829a4aSRandall Stewart #ifdef SCTP_WAKE_LOGGING 3717f8829a4aSRandall Stewart sctp_wakeup_log(stcb, tp1->rec.data.TSN_seq, 1, SCTP_WAKESND_FROM_FWDTSN); 3718f8829a4aSRandall Stewart #endif 3719f8829a4aSRandall Stewart } 3720f8829a4aSRandall Stewart } 3721f8829a4aSRandall Stewart } else { 3722f8829a4aSRandall Stewart /* 3723f8829a4aSRandall Stewart * If it is still in RESEND we can advance no 3724f8829a4aSRandall Stewart * further 3725f8829a4aSRandall Stewart */ 3726f8829a4aSRandall Stewart break; 3727f8829a4aSRandall Stewart } 3728f8829a4aSRandall Stewart /* 3729f8829a4aSRandall Stewart * If we hit here we just dumped tp1, move to next tsn on 3730f8829a4aSRandall Stewart * sent queue. 3731f8829a4aSRandall Stewart */ 3732f8829a4aSRandall Stewart tp1 = tp2; 3733f8829a4aSRandall Stewart } 3734f8829a4aSRandall Stewart return (a_adv); 3735f8829a4aSRandall Stewart } 3736f8829a4aSRandall Stewart 3737f8829a4aSRandall Stewart #ifdef SCTP_HIGH_SPEED 3738f8829a4aSRandall Stewart struct sctp_hs_raise_drop { 3739f8829a4aSRandall Stewart int32_t cwnd; 3740f8829a4aSRandall Stewart int32_t increase; 3741f8829a4aSRandall Stewart int32_t drop_percent; 3742f8829a4aSRandall Stewart }; 3743f8829a4aSRandall Stewart 3744f8829a4aSRandall Stewart #define SCTP_HS_TABLE_SIZE 73 3745f8829a4aSRandall Stewart 3746f8829a4aSRandall Stewart struct sctp_hs_raise_drop sctp_cwnd_adjust[SCTP_HS_TABLE_SIZE] = { 3747f8829a4aSRandall Stewart {38, 1, 50}, /* 0 */ 3748f8829a4aSRandall Stewart {118, 2, 44}, /* 1 */ 3749f8829a4aSRandall Stewart {221, 3, 41}, /* 2 */ 3750f8829a4aSRandall Stewart {347, 4, 38}, /* 3 */ 3751f8829a4aSRandall Stewart {495, 5, 37}, /* 4 */ 3752f8829a4aSRandall Stewart {663, 6, 35}, /* 5 */ 3753f8829a4aSRandall Stewart {851, 7, 34}, /* 6 */ 3754f8829a4aSRandall Stewart {1058, 8, 33}, /* 7 */ 3755f8829a4aSRandall Stewart {1284, 9, 32}, /* 8 */ 3756f8829a4aSRandall Stewart {1529, 10, 31}, /* 9 */ 3757f8829a4aSRandall Stewart {1793, 11, 30}, /* 10 */ 3758f8829a4aSRandall Stewart {2076, 12, 29}, /* 11 */ 3759f8829a4aSRandall Stewart {2378, 13, 28}, /* 12 */ 3760f8829a4aSRandall Stewart {2699, 14, 28}, /* 13 */ 3761f8829a4aSRandall Stewart {3039, 15, 27}, /* 14 */ 3762f8829a4aSRandall Stewart {3399, 16, 27}, /* 15 */ 3763f8829a4aSRandall Stewart {3778, 17, 26}, /* 16 */ 3764f8829a4aSRandall Stewart {4177, 18, 26}, /* 17 */ 3765f8829a4aSRandall Stewart {4596, 19, 25}, /* 18 */ 3766f8829a4aSRandall Stewart {5036, 20, 25}, /* 19 */ 3767f8829a4aSRandall Stewart {5497, 21, 24}, /* 20 */ 3768f8829a4aSRandall Stewart {5979, 22, 24}, /* 21 */ 3769f8829a4aSRandall Stewart {6483, 23, 23}, /* 22 */ 3770f8829a4aSRandall Stewart {7009, 24, 23}, /* 23 */ 3771f8829a4aSRandall Stewart {7558, 25, 22}, /* 24 */ 3772f8829a4aSRandall Stewart {8130, 26, 22}, /* 25 */ 3773f8829a4aSRandall Stewart {8726, 27, 22}, /* 26 */ 3774f8829a4aSRandall Stewart {9346, 28, 21}, /* 27 */ 3775f8829a4aSRandall Stewart {9991, 29, 21}, /* 28 */ 3776f8829a4aSRandall Stewart {10661, 30, 21}, /* 29 */ 3777f8829a4aSRandall Stewart {11358, 31, 20}, /* 30 */ 3778f8829a4aSRandall Stewart {12082, 32, 20}, /* 31 */ 3779f8829a4aSRandall Stewart {12834, 33, 20}, /* 32 */ 3780f8829a4aSRandall Stewart {13614, 34, 19}, /* 33 */ 3781f8829a4aSRandall Stewart {14424, 35, 19}, /* 34 */ 3782f8829a4aSRandall Stewart {15265, 36, 19}, /* 35 */ 3783f8829a4aSRandall Stewart {16137, 37, 19}, /* 36 */ 3784f8829a4aSRandall Stewart {17042, 38, 18}, /* 37 */ 3785f8829a4aSRandall Stewart {17981, 39, 18}, /* 38 */ 3786f8829a4aSRandall Stewart {18955, 40, 18}, /* 39 */ 3787f8829a4aSRandall Stewart {19965, 41, 17}, /* 40 */ 3788f8829a4aSRandall Stewart {21013, 42, 17}, /* 41 */ 3789f8829a4aSRandall Stewart {22101, 43, 17}, /* 42 */ 3790f8829a4aSRandall Stewart {23230, 44, 17}, /* 43 */ 3791f8829a4aSRandall Stewart {24402, 45, 16}, /* 44 */ 3792f8829a4aSRandall Stewart {25618, 46, 16}, /* 45 */ 3793f8829a4aSRandall Stewart {26881, 47, 16}, /* 46 */ 3794f8829a4aSRandall Stewart {28193, 48, 16}, /* 47 */ 3795f8829a4aSRandall Stewart {29557, 49, 15}, /* 48 */ 3796f8829a4aSRandall Stewart {30975, 50, 15}, /* 49 */ 3797f8829a4aSRandall Stewart {32450, 51, 15}, /* 50 */ 3798f8829a4aSRandall Stewart {33986, 52, 15}, /* 51 */ 3799f8829a4aSRandall Stewart {35586, 53, 14}, /* 52 */ 3800f8829a4aSRandall Stewart {37253, 54, 14}, /* 53 */ 3801f8829a4aSRandall Stewart {38992, 55, 14}, /* 54 */ 3802f8829a4aSRandall Stewart {40808, 56, 14}, /* 55 */ 3803f8829a4aSRandall Stewart {42707, 57, 13}, /* 56 */ 3804f8829a4aSRandall Stewart {44694, 58, 13}, /* 57 */ 3805f8829a4aSRandall Stewart {46776, 59, 13}, /* 58 */ 3806f8829a4aSRandall Stewart {48961, 60, 13}, /* 59 */ 3807f8829a4aSRandall Stewart {51258, 61, 13}, /* 60 */ 3808f8829a4aSRandall Stewart {53677, 62, 12}, /* 61 */ 3809f8829a4aSRandall Stewart {56230, 63, 12}, /* 62 */ 3810f8829a4aSRandall Stewart {58932, 64, 12}, /* 63 */ 3811f8829a4aSRandall Stewart {61799, 65, 12}, /* 64 */ 3812f8829a4aSRandall Stewart {64851, 66, 11}, /* 65 */ 3813f8829a4aSRandall Stewart {68113, 67, 11}, /* 66 */ 3814f8829a4aSRandall Stewart {71617, 68, 11}, /* 67 */ 3815f8829a4aSRandall Stewart {75401, 69, 10}, /* 68 */ 3816f8829a4aSRandall Stewart {79517, 70, 10}, /* 69 */ 3817f8829a4aSRandall Stewart {84035, 71, 10}, /* 70 */ 3818f8829a4aSRandall Stewart {89053, 72, 10}, /* 71 */ 3819f8829a4aSRandall Stewart {94717, 73, 9} /* 72 */ 3820f8829a4aSRandall Stewart }; 3821f8829a4aSRandall Stewart 3822f8829a4aSRandall Stewart static void 382350cec919SRandall Stewart sctp_hs_cwnd_increase(struct sctp_tcb *stcb, struct sctp_nets *net) 3824f8829a4aSRandall Stewart { 3825f8829a4aSRandall Stewart int cur_val, i, indx, incr; 3826f8829a4aSRandall Stewart 3827f8829a4aSRandall Stewart cur_val = net->cwnd >> 10; 3828f8829a4aSRandall Stewart indx = SCTP_HS_TABLE_SIZE - 1; 3829f8829a4aSRandall Stewart 3830f8829a4aSRandall Stewart if (cur_val < sctp_cwnd_adjust[0].cwnd) { 3831f8829a4aSRandall Stewart /* normal mode */ 3832f8829a4aSRandall Stewart if (net->net_ack > net->mtu) { 3833f8829a4aSRandall Stewart net->cwnd += net->mtu; 3834f8829a4aSRandall Stewart #ifdef SCTP_CWND_MONITOR 3835f8829a4aSRandall Stewart sctp_log_cwnd(stcb, net, net->mtu, SCTP_CWND_LOG_FROM_SS); 3836f8829a4aSRandall Stewart #endif 3837f8829a4aSRandall Stewart } else { 3838f8829a4aSRandall Stewart net->cwnd += net->net_ack; 3839f8829a4aSRandall Stewart #ifdef SCTP_CWND_MONITOR 3840f8829a4aSRandall Stewart sctp_log_cwnd(stcb, net, net->net_ack, SCTP_CWND_LOG_FROM_SS); 3841f8829a4aSRandall Stewart #endif 3842f8829a4aSRandall Stewart } 3843f8829a4aSRandall Stewart } else { 3844f8829a4aSRandall Stewart for (i = net->last_hs_used; i < SCTP_HS_TABLE_SIZE; i++) { 3845f8829a4aSRandall Stewart if (cur_val < sctp_cwnd_adjust[i].cwnd) { 3846f8829a4aSRandall Stewart indx = i; 3847f8829a4aSRandall Stewart break; 3848f8829a4aSRandall Stewart } 3849f8829a4aSRandall Stewart } 3850f8829a4aSRandall Stewart net->last_hs_used = indx; 3851f8829a4aSRandall Stewart incr = ((sctp_cwnd_adjust[indx].increase) << 10); 3852f8829a4aSRandall Stewart net->cwnd += incr; 3853f8829a4aSRandall Stewart #ifdef SCTP_CWND_MONITOR 3854f8829a4aSRandall Stewart sctp_log_cwnd(stcb, net, incr, SCTP_CWND_LOG_FROM_SS); 3855f8829a4aSRandall Stewart #endif 3856f8829a4aSRandall Stewart } 3857f8829a4aSRandall Stewart } 3858f8829a4aSRandall Stewart 3859f8829a4aSRandall Stewart static void 386050cec919SRandall Stewart sctp_hs_cwnd_decrease(struct sctp_tcb *stcb, struct sctp_nets *net) 3861f8829a4aSRandall Stewart { 3862f8829a4aSRandall Stewart int cur_val, i, indx; 3863f8829a4aSRandall Stewart 3864f8829a4aSRandall Stewart #ifdef SCTP_CWND_MONITOR 3865f8829a4aSRandall Stewart int old_cwnd = net->cwnd; 3866f8829a4aSRandall Stewart 3867f8829a4aSRandall Stewart #endif 3868f8829a4aSRandall Stewart 3869f8829a4aSRandall Stewart cur_val = net->cwnd >> 10; 3870f8829a4aSRandall Stewart indx = net->last_hs_used; 3871f8829a4aSRandall Stewart if (cur_val < sctp_cwnd_adjust[0].cwnd) { 3872f8829a4aSRandall Stewart /* normal mode */ 3873f8829a4aSRandall Stewart net->ssthresh = net->cwnd / 2; 3874f8829a4aSRandall Stewart if (net->ssthresh < (net->mtu * 2)) { 3875f8829a4aSRandall Stewart net->ssthresh = 2 * net->mtu; 3876f8829a4aSRandall Stewart } 3877f8829a4aSRandall Stewart net->cwnd = net->ssthresh; 3878f8829a4aSRandall Stewart } else { 3879f8829a4aSRandall Stewart /* drop by the proper amount */ 3880f8829a4aSRandall Stewart net->ssthresh = net->cwnd - (int)((net->cwnd / 100) * 3881f8829a4aSRandall Stewart sctp_cwnd_adjust[net->last_hs_used].drop_percent); 3882f8829a4aSRandall Stewart net->cwnd = net->ssthresh; 3883f8829a4aSRandall Stewart /* now where are we */ 3884f8829a4aSRandall Stewart indx = net->last_hs_used; 3885f8829a4aSRandall Stewart cur_val = net->cwnd >> 10; 3886f8829a4aSRandall Stewart /* reset where we are in the table */ 3887f8829a4aSRandall Stewart if (cur_val < sctp_cwnd_adjust[0].cwnd) { 3888f8829a4aSRandall Stewart /* feel out of hs */ 3889f8829a4aSRandall Stewart net->last_hs_used = 0; 3890f8829a4aSRandall Stewart } else { 3891f8829a4aSRandall Stewart for (i = indx; i >= 1; i--) { 3892f8829a4aSRandall Stewart if (cur_val > sctp_cwnd_adjust[i - 1].cwnd) { 3893f8829a4aSRandall Stewart break; 3894f8829a4aSRandall Stewart } 3895f8829a4aSRandall Stewart } 3896f8829a4aSRandall Stewart net->last_hs_used = indx; 3897f8829a4aSRandall Stewart } 3898f8829a4aSRandall Stewart } 3899f8829a4aSRandall Stewart #ifdef SCTP_CWND_MONITOR 3900f8829a4aSRandall Stewart sctp_log_cwnd(stcb, net, (net->cwnd - old_cwnd), SCTP_CWND_LOG_FROM_FR); 3901f8829a4aSRandall Stewart #endif 3902f8829a4aSRandall Stewart 3903f8829a4aSRandall Stewart } 3904f8829a4aSRandall Stewart 3905f8829a4aSRandall Stewart #endif 3906f8829a4aSRandall Stewart 3907f8829a4aSRandall Stewart 3908f8829a4aSRandall Stewart static __inline void 3909f8829a4aSRandall Stewart sctp_cwnd_update(struct sctp_tcb *stcb, 3910f8829a4aSRandall Stewart struct sctp_association *asoc, 3911f8829a4aSRandall Stewart int accum_moved, int reneged_all, int will_exit) 3912f8829a4aSRandall Stewart { 3913f8829a4aSRandall Stewart struct sctp_nets *net; 3914f8829a4aSRandall Stewart 3915f8829a4aSRandall Stewart /******************************/ 3916f8829a4aSRandall Stewart /* update cwnd and Early FR */ 3917f8829a4aSRandall Stewart /******************************/ 3918f8829a4aSRandall Stewart TAILQ_FOREACH(net, &asoc->nets, sctp_next) { 391942551e99SRandall Stewart 392042551e99SRandall Stewart #ifdef JANA_CMT_FAST_RECOVERY 3921f8829a4aSRandall Stewart /* 3922f8829a4aSRandall Stewart * CMT fast recovery code. Need to debug. 3923f8829a4aSRandall Stewart */ 3924f8829a4aSRandall Stewart if (net->fast_retran_loss_recovery && net->new_pseudo_cumack) { 3925f8829a4aSRandall Stewart if (compare_with_wrap(asoc->last_acked_seq, 3926f8829a4aSRandall Stewart net->fast_recovery_tsn, MAX_TSN) || 3927f8829a4aSRandall Stewart (asoc->last_acked_seq == net->fast_recovery_tsn) || 3928f8829a4aSRandall Stewart compare_with_wrap(net->pseudo_cumack, net->fast_recovery_tsn, MAX_TSN) || 3929f8829a4aSRandall Stewart (net->pseudo_cumack == net->fast_recovery_tsn)) { 3930f8829a4aSRandall Stewart net->will_exit_fast_recovery = 1; 3931f8829a4aSRandall Stewart } 3932f8829a4aSRandall Stewart } 3933f8829a4aSRandall Stewart #endif 3934f8829a4aSRandall Stewart if (sctp_early_fr) { 3935f8829a4aSRandall Stewart /* 3936f8829a4aSRandall Stewart * So, first of all do we need to have a Early FR 3937f8829a4aSRandall Stewart * timer running? 3938f8829a4aSRandall Stewart */ 3939f8829a4aSRandall Stewart if (((TAILQ_FIRST(&asoc->sent_queue)) && 3940f8829a4aSRandall Stewart (net->ref_count > 1) && 3941f8829a4aSRandall Stewart (net->flight_size < net->cwnd)) || 3942f8829a4aSRandall Stewart (reneged_all)) { 3943f8829a4aSRandall Stewart /* 3944f8829a4aSRandall Stewart * yes, so in this case stop it if its 3945f8829a4aSRandall Stewart * running, and then restart it. Reneging 3946f8829a4aSRandall Stewart * all is a special case where we want to 3947f8829a4aSRandall Stewart * run the Early FR timer and then force the 3948f8829a4aSRandall Stewart * last few unacked to be sent, causing us 3949f8829a4aSRandall Stewart * to illicit a sack with gaps to force out 3950f8829a4aSRandall Stewart * the others. 3951f8829a4aSRandall Stewart */ 3952139bc87fSRandall Stewart if (SCTP_OS_TIMER_PENDING(&net->fr_timer.timer)) { 3953f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_earlyfrstpidsck2); 3954a5d547adSRandall Stewart sctp_timer_stop(SCTP_TIMER_TYPE_EARLYFR, stcb->sctp_ep, stcb, net, 3955a5d547adSRandall Stewart SCTP_FROM_SCTP_INDATA + SCTP_LOC_20); 3956f8829a4aSRandall Stewart } 3957f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_earlyfrstrid); 3958f8829a4aSRandall Stewart sctp_timer_start(SCTP_TIMER_TYPE_EARLYFR, stcb->sctp_ep, stcb, net); 3959f8829a4aSRandall Stewart } else { 3960f8829a4aSRandall Stewart /* No, stop it if its running */ 3961139bc87fSRandall Stewart if (SCTP_OS_TIMER_PENDING(&net->fr_timer.timer)) { 3962f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_earlyfrstpidsck3); 3963a5d547adSRandall Stewart sctp_timer_stop(SCTP_TIMER_TYPE_EARLYFR, stcb->sctp_ep, stcb, net, 3964a5d547adSRandall Stewart SCTP_FROM_SCTP_INDATA + SCTP_LOC_21); 3965f8829a4aSRandall Stewart } 3966f8829a4aSRandall Stewart } 3967f8829a4aSRandall Stewart } 3968f8829a4aSRandall Stewart /* if nothing was acked on this destination skip it */ 3969f8829a4aSRandall Stewart if (net->net_ack == 0) { 3970f8829a4aSRandall Stewart #ifdef SCTP_CWND_LOGGING 3971f8829a4aSRandall Stewart sctp_log_cwnd(stcb, net, 0, SCTP_CWND_LOG_FROM_SACK); 3972f8829a4aSRandall Stewart #endif 3973f8829a4aSRandall Stewart continue; 3974f8829a4aSRandall Stewart } 3975f8829a4aSRandall Stewart if (net->net_ack2 > 0) { 3976f8829a4aSRandall Stewart /* 3977f8829a4aSRandall Stewart * Karn's rule applies to clearing error count, this 3978f8829a4aSRandall Stewart * is optional. 3979f8829a4aSRandall Stewart */ 3980f8829a4aSRandall Stewart net->error_count = 0; 3981f8829a4aSRandall Stewart if ((net->dest_state & SCTP_ADDR_NOT_REACHABLE) == 3982f8829a4aSRandall Stewart SCTP_ADDR_NOT_REACHABLE) { 3983f8829a4aSRandall Stewart /* addr came good */ 3984f8829a4aSRandall Stewart net->dest_state &= ~SCTP_ADDR_NOT_REACHABLE; 3985f8829a4aSRandall Stewart net->dest_state |= SCTP_ADDR_REACHABLE; 3986f8829a4aSRandall Stewart sctp_ulp_notify(SCTP_NOTIFY_INTERFACE_UP, stcb, 3987f8829a4aSRandall Stewart SCTP_RECEIVED_SACK, (void *)net); 3988f8829a4aSRandall Stewart /* now was it the primary? if so restore */ 3989f8829a4aSRandall Stewart if (net->dest_state & SCTP_ADDR_WAS_PRIMARY) { 3990f8829a4aSRandall Stewart sctp_set_primary_addr(stcb, (struct sockaddr *)NULL, net); 3991f8829a4aSRandall Stewart } 3992f8829a4aSRandall Stewart } 3993f8829a4aSRandall Stewart } 399442551e99SRandall Stewart #ifdef JANA_CMT_FAST_RECOVERY 3995f8829a4aSRandall Stewart /* 399642551e99SRandall Stewart * CMT fast recovery code 3997f8829a4aSRandall Stewart */ 3998f8829a4aSRandall Stewart /* 399942551e99SRandall Stewart * if (sctp_cmt_on_off == 1 && 400042551e99SRandall Stewart * net->fast_retran_loss_recovery && 400142551e99SRandall Stewart * net->will_exit_fast_recovery == 0) { // @@@ Do something 400242551e99SRandall Stewart * } else if (sctp_cmt_on_off == 0 && 400342551e99SRandall Stewart * asoc->fast_retran_loss_recovery && will_exit == 0) { 400442551e99SRandall Stewart */ 400542551e99SRandall Stewart #endif 400642551e99SRandall Stewart 4007c105859eSRandall Stewart if (asoc->fast_retran_loss_recovery && will_exit == 0 && sctp_cmt_on_off == 0) { 400842551e99SRandall Stewart /* 400942551e99SRandall Stewart * If we are in loss recovery we skip any cwnd 401042551e99SRandall Stewart * update 4011f8829a4aSRandall Stewart */ 4012f8829a4aSRandall Stewart goto skip_cwnd_update; 4013f8829a4aSRandall Stewart } 4014f8829a4aSRandall Stewart /* 4015f8829a4aSRandall Stewart * CMT: CUC algorithm. Update cwnd if pseudo-cumack has 4016f8829a4aSRandall Stewart * moved. 4017f8829a4aSRandall Stewart */ 4018f8829a4aSRandall Stewart if (accum_moved || (sctp_cmt_on_off && net->new_pseudo_cumack)) { 4019f8829a4aSRandall Stewart /* If the cumulative ack moved we can proceed */ 4020f8829a4aSRandall Stewart if (net->cwnd <= net->ssthresh) { 4021f8829a4aSRandall Stewart /* We are in slow start */ 4022f8829a4aSRandall Stewart if (net->flight_size + net->net_ack >= 4023f8829a4aSRandall Stewart net->cwnd) { 4024f8829a4aSRandall Stewart #ifdef SCTP_HIGH_SPEED 402550cec919SRandall Stewart sctp_hs_cwnd_increase(stcb, net); 4026f8829a4aSRandall Stewart #else 4027f8829a4aSRandall Stewart if (net->net_ack > (net->mtu * sctp_L2_abc_variable)) { 4028f8829a4aSRandall Stewart net->cwnd += (net->mtu * sctp_L2_abc_variable); 4029f8829a4aSRandall Stewart #ifdef SCTP_CWND_MONITOR 4030f8829a4aSRandall Stewart sctp_log_cwnd(stcb, net, net->mtu, 4031f8829a4aSRandall Stewart SCTP_CWND_LOG_FROM_SS); 4032f8829a4aSRandall Stewart #endif 4033f8829a4aSRandall Stewart 4034f8829a4aSRandall Stewart } else { 4035f8829a4aSRandall Stewart net->cwnd += net->net_ack; 4036f8829a4aSRandall Stewart #ifdef SCTP_CWND_MONITOR 4037f8829a4aSRandall Stewart sctp_log_cwnd(stcb, net, net->net_ack, 4038f8829a4aSRandall Stewart SCTP_CWND_LOG_FROM_SS); 4039f8829a4aSRandall Stewart #endif 4040f8829a4aSRandall Stewart 4041f8829a4aSRandall Stewart } 4042f8829a4aSRandall Stewart #endif 4043f8829a4aSRandall Stewart } else { 4044f8829a4aSRandall Stewart unsigned int dif; 4045f8829a4aSRandall Stewart 4046f8829a4aSRandall Stewart dif = net->cwnd - (net->flight_size + 4047f8829a4aSRandall Stewart net->net_ack); 4048f8829a4aSRandall Stewart #ifdef SCTP_CWND_LOGGING 4049f8829a4aSRandall Stewart sctp_log_cwnd(stcb, net, net->net_ack, 4050f8829a4aSRandall Stewart SCTP_CWND_LOG_NOADV_SS); 4051f8829a4aSRandall Stewart #endif 4052f8829a4aSRandall Stewart } 4053f8829a4aSRandall Stewart } else { 4054f8829a4aSRandall Stewart /* We are in congestion avoidance */ 4055f8829a4aSRandall Stewart if (net->flight_size + net->net_ack >= 4056f8829a4aSRandall Stewart net->cwnd) { 4057f8829a4aSRandall Stewart /* 4058f8829a4aSRandall Stewart * add to pba only if we had a 4059f8829a4aSRandall Stewart * cwnd's worth (or so) in flight OR 4060f8829a4aSRandall Stewart * the burst limit was applied. 4061f8829a4aSRandall Stewart */ 4062f8829a4aSRandall Stewart net->partial_bytes_acked += 4063f8829a4aSRandall Stewart net->net_ack; 4064f8829a4aSRandall Stewart 4065f8829a4aSRandall Stewart /* 4066f8829a4aSRandall Stewart * Do we need to increase (if pba is 4067f8829a4aSRandall Stewart * > cwnd)? 4068f8829a4aSRandall Stewart */ 4069f8829a4aSRandall Stewart if (net->partial_bytes_acked >= 4070f8829a4aSRandall Stewart net->cwnd) { 4071f8829a4aSRandall Stewart if (net->cwnd < 4072f8829a4aSRandall Stewart net->partial_bytes_acked) { 4073f8829a4aSRandall Stewart net->partial_bytes_acked -= 4074f8829a4aSRandall Stewart net->cwnd; 4075f8829a4aSRandall Stewart } else { 4076f8829a4aSRandall Stewart net->partial_bytes_acked = 4077f8829a4aSRandall Stewart 0; 4078f8829a4aSRandall Stewart } 4079f8829a4aSRandall Stewart net->cwnd += net->mtu; 4080f8829a4aSRandall Stewart #ifdef SCTP_CWND_MONITOR 4081f8829a4aSRandall Stewart sctp_log_cwnd(stcb, net, net->mtu, 4082f8829a4aSRandall Stewart SCTP_CWND_LOG_FROM_CA); 4083f8829a4aSRandall Stewart #endif 4084f8829a4aSRandall Stewart } 4085f8829a4aSRandall Stewart #ifdef SCTP_CWND_LOGGING 4086f8829a4aSRandall Stewart else { 4087f8829a4aSRandall Stewart sctp_log_cwnd(stcb, net, net->net_ack, 4088f8829a4aSRandall Stewart SCTP_CWND_LOG_NOADV_CA); 4089f8829a4aSRandall Stewart } 4090f8829a4aSRandall Stewart #endif 4091f8829a4aSRandall Stewart } else { 4092f8829a4aSRandall Stewart unsigned int dif; 4093f8829a4aSRandall Stewart 4094f8829a4aSRandall Stewart #ifdef SCTP_CWND_LOGGING 4095f8829a4aSRandall Stewart sctp_log_cwnd(stcb, net, net->net_ack, 4096f8829a4aSRandall Stewart SCTP_CWND_LOG_NOADV_CA); 4097f8829a4aSRandall Stewart #endif 4098f8829a4aSRandall Stewart dif = net->cwnd - (net->flight_size + 4099f8829a4aSRandall Stewart net->net_ack); 4100f8829a4aSRandall Stewart } 4101f8829a4aSRandall Stewart } 4102f8829a4aSRandall Stewart } else { 4103f8829a4aSRandall Stewart #ifdef SCTP_CWND_LOGGING 4104f8829a4aSRandall Stewart sctp_log_cwnd(stcb, net, net->mtu, 4105f8829a4aSRandall Stewart SCTP_CWND_LOG_NO_CUMACK); 4106f8829a4aSRandall Stewart #endif 4107f8829a4aSRandall Stewart } 4108f8829a4aSRandall Stewart skip_cwnd_update: 4109f8829a4aSRandall Stewart /* 4110f8829a4aSRandall Stewart * NOW, according to Karn's rule do we need to restore the 4111f8829a4aSRandall Stewart * RTO timer back? Check our net_ack2. If not set then we 4112f8829a4aSRandall Stewart * have a ambiguity.. i.e. all data ack'd was sent to more 4113f8829a4aSRandall Stewart * than one place. 4114f8829a4aSRandall Stewart */ 4115f8829a4aSRandall Stewart if (net->net_ack2) { 4116f8829a4aSRandall Stewart /* restore any doubled timers */ 4117f8829a4aSRandall Stewart net->RTO = ((net->lastsa >> 2) + net->lastsv) >> 1; 4118f8829a4aSRandall Stewart if (net->RTO < stcb->asoc.minrto) { 4119f8829a4aSRandall Stewart net->RTO = stcb->asoc.minrto; 4120f8829a4aSRandall Stewart } 4121f8829a4aSRandall Stewart if (net->RTO > stcb->asoc.maxrto) { 4122f8829a4aSRandall Stewart net->RTO = stcb->asoc.maxrto; 4123f8829a4aSRandall Stewart } 4124f8829a4aSRandall Stewart } 4125f8829a4aSRandall Stewart } 4126f8829a4aSRandall Stewart } 4127f8829a4aSRandall Stewart 4128bff64a4dSRandall Stewart static void 4129c105859eSRandall Stewart sctp_fs_audit(struct sctp_association *asoc) 4130bff64a4dSRandall Stewart { 4131bff64a4dSRandall Stewart struct sctp_tmit_chunk *chk; 4132bff64a4dSRandall Stewart int inflight = 0, resend = 0, inbetween = 0, acked = 0, above = 0; 4133bff64a4dSRandall Stewart 4134bff64a4dSRandall Stewart TAILQ_FOREACH(chk, &asoc->sent_queue, sctp_next) { 4135bff64a4dSRandall Stewart if (chk->sent < SCTP_DATAGRAM_RESEND) { 4136bff64a4dSRandall Stewart inflight++; 4137bff64a4dSRandall Stewart } else if (chk->sent == SCTP_DATAGRAM_RESEND) { 4138bff64a4dSRandall Stewart resend++; 4139bff64a4dSRandall Stewart } else if (chk->sent < SCTP_DATAGRAM_ACKED) { 4140bff64a4dSRandall Stewart inbetween++; 4141bff64a4dSRandall Stewart } else if (chk->sent > SCTP_DATAGRAM_ACKED) { 4142bff64a4dSRandall Stewart above++; 4143bff64a4dSRandall Stewart } else { 4144bff64a4dSRandall Stewart acked++; 4145bff64a4dSRandall Stewart } 4146bff64a4dSRandall Stewart } 4147f1f73e57SRandall Stewart 4148c105859eSRandall Stewart if ((inflight > 0) || (inbetween > 0)) { 4149f1f73e57SRandall Stewart #ifdef INVARIANTS 4150c105859eSRandall Stewart panic("Flight size-express incorrect? \n"); 4151f1f73e57SRandall Stewart #else 4152f1f73e57SRandall Stewart printf("Flight size-express incorrect inflight:%d inbetween:%d\n", 4153f1f73e57SRandall Stewart inflight, inbetween); 4154f1f73e57SRandall Stewart #endif 4155bff64a4dSRandall Stewart } 4156c105859eSRandall Stewart } 4157c105859eSRandall Stewart 4158c105859eSRandall Stewart 4159c105859eSRandall Stewart static void 4160c105859eSRandall Stewart sctp_window_probe_recovery(struct sctp_tcb *stcb, 4161c105859eSRandall Stewart struct sctp_association *asoc, 4162c105859eSRandall Stewart struct sctp_nets *net, 4163c105859eSRandall Stewart struct sctp_tmit_chunk *tp1) 4164c105859eSRandall Stewart { 4165c105859eSRandall Stewart struct sctp_tmit_chunk *chk; 4166c105859eSRandall Stewart 4167c105859eSRandall Stewart /* First setup this one and get it moved back */ 4168c105859eSRandall Stewart tp1->sent = SCTP_DATAGRAM_UNSENT; 4169c105859eSRandall Stewart tp1->window_probe = 0; 4170c105859eSRandall Stewart #ifdef SCTP_FLIGHT_LOGGING 4171c105859eSRandall Stewart sctp_misc_ints(SCTP_FLIGHT_LOG_DOWN_WP, 4172c105859eSRandall Stewart tp1->whoTo->flight_size, 4173c105859eSRandall Stewart tp1->book_size, 4174c105859eSRandall Stewart (uintptr_t) tp1->whoTo, 4175c105859eSRandall Stewart tp1->rec.data.TSN_seq); 4176c105859eSRandall Stewart #endif 4177c105859eSRandall Stewart sctp_flight_size_decrease(tp1); 4178c105859eSRandall Stewart sctp_total_flight_decrease(stcb, tp1); 4179c105859eSRandall Stewart TAILQ_REMOVE(&asoc->sent_queue, tp1, sctp_next); 4180c105859eSRandall Stewart TAILQ_INSERT_HEAD(&asoc->send_queue, tp1, sctp_next); 4181c105859eSRandall Stewart asoc->sent_queue_cnt--; 4182c105859eSRandall Stewart asoc->send_queue_cnt++; 4183c105859eSRandall Stewart /* 4184c105859eSRandall Stewart * Now all guys marked for RESEND on the sent_queue must be moved 4185c105859eSRandall Stewart * back too. 4186c105859eSRandall Stewart */ 4187c105859eSRandall Stewart TAILQ_FOREACH(chk, &asoc->sent_queue, sctp_next) { 4188c105859eSRandall Stewart if (chk->sent == SCTP_DATAGRAM_RESEND) { 4189c105859eSRandall Stewart /* Another chunk to move */ 4190c105859eSRandall Stewart chk->sent = SCTP_DATAGRAM_UNSENT; 4191c105859eSRandall Stewart chk->window_probe = 0; 4192c105859eSRandall Stewart /* It should not be in flight */ 4193c105859eSRandall Stewart TAILQ_REMOVE(&asoc->sent_queue, chk, sctp_next); 4194c105859eSRandall Stewart TAILQ_INSERT_AFTER(&asoc->send_queue, tp1, chk, sctp_next); 4195c105859eSRandall Stewart asoc->sent_queue_cnt--; 4196c105859eSRandall Stewart asoc->send_queue_cnt++; 4197c105859eSRandall Stewart sctp_ucount_decr(asoc->sent_queue_retran_cnt); 4198c105859eSRandall Stewart } 4199c105859eSRandall Stewart } 4200c105859eSRandall Stewart } 4201c105859eSRandall Stewart 4202f8829a4aSRandall Stewart 4203f8829a4aSRandall Stewart void 4204f8829a4aSRandall Stewart sctp_express_handle_sack(struct sctp_tcb *stcb, uint32_t cumack, 4205f8829a4aSRandall Stewart uint32_t rwnd, int nonce_sum_flag, int *abort_now) 4206f8829a4aSRandall Stewart { 4207f8829a4aSRandall Stewart struct sctp_nets *net; 4208f8829a4aSRandall Stewart struct sctp_association *asoc; 4209f8829a4aSRandall Stewart struct sctp_tmit_chunk *tp1, *tp2; 42105e54f665SRandall Stewart uint32_t old_rwnd; 42115e54f665SRandall Stewart int win_probe_recovery = 0; 4212c105859eSRandall Stewart int win_probe_recovered = 0; 4213d06c82f1SRandall Stewart int j, done_once = 0; 4214f8829a4aSRandall Stewart 4215d06c82f1SRandall Stewart 4216d06c82f1SRandall Stewart #ifdef SCTP_LOG_SACK_ARRIVALS 4217d06c82f1SRandall Stewart sctp_misc_ints(SCTP_SACK_LOG_EXPRESS, cumack, 4218d06c82f1SRandall Stewart rwnd, stcb->asoc.last_acked_seq, stcb->asoc.peers_rwnd); 4219d06c82f1SRandall Stewart #endif 4220f8829a4aSRandall Stewart SCTP_TCB_LOCK_ASSERT(stcb); 4221f8829a4aSRandall Stewart asoc = &stcb->asoc; 4222d06c82f1SRandall Stewart old_rwnd = asoc->peers_rwnd; 42235e54f665SRandall Stewart if (compare_with_wrap(asoc->last_acked_seq, cumack, MAX_TSN)) { 42245e54f665SRandall Stewart /* old ack */ 42255e54f665SRandall Stewart return; 4226d06c82f1SRandall Stewart } else if (asoc->last_acked_seq == cumack) { 4227d06c82f1SRandall Stewart /* Window update sack */ 4228d06c82f1SRandall Stewart asoc->peers_rwnd = sctp_sbspace_sub(rwnd, 4229d06c82f1SRandall Stewart (uint32_t) (asoc->total_flight + (asoc->sent_queue_cnt * sctp_peer_chunk_oh))); 4230d06c82f1SRandall Stewart if (asoc->peers_rwnd < stcb->sctp_ep->sctp_ep.sctp_sws_sender) { 4231d06c82f1SRandall Stewart /* SWS sender side engages */ 4232d06c82f1SRandall Stewart asoc->peers_rwnd = 0; 4233d06c82f1SRandall Stewart } 4234d06c82f1SRandall Stewart if (asoc->peers_rwnd > old_rwnd) { 4235d06c82f1SRandall Stewart goto again; 4236d06c82f1SRandall Stewart } 4237d06c82f1SRandall Stewart return; 4238d06c82f1SRandall Stewart 42395e54f665SRandall Stewart } 4240f8829a4aSRandall Stewart /* First setup for CC stuff */ 4241f8829a4aSRandall Stewart TAILQ_FOREACH(net, &asoc->nets, sctp_next) { 4242f8829a4aSRandall Stewart net->prev_cwnd = net->cwnd; 4243f8829a4aSRandall Stewart net->net_ack = 0; 4244f8829a4aSRandall Stewart net->net_ack2 = 0; 4245132dea7dSRandall Stewart 4246132dea7dSRandall Stewart /* 4247132dea7dSRandall Stewart * CMT: Reset CUC and Fast recovery algo variables before 4248132dea7dSRandall Stewart * SACK processing 4249132dea7dSRandall Stewart */ 4250132dea7dSRandall Stewart net->new_pseudo_cumack = 0; 4251132dea7dSRandall Stewart net->will_exit_fast_recovery = 0; 4252f8829a4aSRandall Stewart } 4253139bc87fSRandall Stewart if (sctp_strict_sacks) { 4254139bc87fSRandall Stewart uint32_t send_s; 4255139bc87fSRandall Stewart 4256c105859eSRandall Stewart if (!TAILQ_EMPTY(&asoc->sent_queue)) { 4257c105859eSRandall Stewart tp1 = TAILQ_LAST(&asoc->sent_queue, 4258c105859eSRandall Stewart sctpchunk_listhead); 4259c105859eSRandall Stewart send_s = tp1->rec.data.TSN_seq + 1; 4260139bc87fSRandall Stewart } else { 4261c105859eSRandall Stewart send_s = asoc->sending_seq; 4262139bc87fSRandall Stewart } 4263139bc87fSRandall Stewart if ((cumack == send_s) || 4264139bc87fSRandall Stewart compare_with_wrap(cumack, send_s, MAX_TSN)) { 4265c105859eSRandall Stewart #ifndef INVARIANTS 4266139bc87fSRandall Stewart struct mbuf *oper; 4267139bc87fSRandall Stewart 4268c105859eSRandall Stewart #endif 4269c105859eSRandall Stewart #ifdef INVARIANTS 4270c105859eSRandall Stewart panic("Impossible sack 1"); 4271c105859eSRandall Stewart #else 4272139bc87fSRandall Stewart *abort_now = 1; 4273139bc87fSRandall Stewart /* XXX */ 4274139bc87fSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + sizeof(uint32_t)), 4275139bc87fSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 4276139bc87fSRandall Stewart if (oper) { 4277139bc87fSRandall Stewart struct sctp_paramhdr *ph; 4278139bc87fSRandall Stewart uint32_t *ippp; 4279139bc87fSRandall Stewart 4280139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = sizeof(struct sctp_paramhdr) + 4281139bc87fSRandall Stewart sizeof(uint32_t); 4282139bc87fSRandall Stewart ph = mtod(oper, struct sctp_paramhdr *); 4283139bc87fSRandall Stewart ph->param_type = htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 4284139bc87fSRandall Stewart ph->param_length = htons(SCTP_BUF_LEN(oper)); 4285139bc87fSRandall Stewart ippp = (uint32_t *) (ph + 1); 4286139bc87fSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_25); 4287139bc87fSRandall Stewart } 4288139bc87fSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_25; 4289139bc87fSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, stcb, SCTP_PEER_FAULTY, oper); 4290139bc87fSRandall Stewart return; 4291139bc87fSRandall Stewart #endif 4292139bc87fSRandall Stewart } 4293139bc87fSRandall Stewart } 4294f8829a4aSRandall Stewart asoc->this_sack_highest_gap = cumack; 4295f8829a4aSRandall Stewart stcb->asoc.overall_error_count = 0; 42965e54f665SRandall Stewart if (compare_with_wrap(cumack, asoc->last_acked_seq, MAX_TSN)) { 4297f8829a4aSRandall Stewart /* process the new consecutive TSN first */ 4298f8829a4aSRandall Stewart tp1 = TAILQ_FIRST(&asoc->sent_queue); 4299f8829a4aSRandall Stewart while (tp1) { 4300f8829a4aSRandall Stewart tp2 = TAILQ_NEXT(tp1, sctp_next); 4301f8829a4aSRandall Stewart if (compare_with_wrap(cumack, tp1->rec.data.TSN_seq, 4302f8829a4aSRandall Stewart MAX_TSN) || 4303f8829a4aSRandall Stewart cumack == tp1->rec.data.TSN_seq) { 4304f8829a4aSRandall Stewart if (tp1->sent != SCTP_DATAGRAM_UNSENT) { 4305f8829a4aSRandall Stewart /* 43065e54f665SRandall Stewart * ECN Nonce: Add the nonce to the 43075e54f665SRandall Stewart * sender's nonce sum 4308f8829a4aSRandall Stewart */ 4309f8829a4aSRandall Stewart asoc->nonce_sum_expect_base += tp1->rec.data.ect_nonce; 4310f8829a4aSRandall Stewart if (tp1->sent < SCTP_DATAGRAM_ACKED) { 4311f8829a4aSRandall Stewart /* 43125e54f665SRandall Stewart * If it is less than ACKED, 43135e54f665SRandall Stewart * it is now no-longer in 43145e54f665SRandall Stewart * flight. Higher values may 43155e54f665SRandall Stewart * occur during marking 4316f8829a4aSRandall Stewart */ 4317c105859eSRandall Stewart if (tp1->sent < SCTP_DATAGRAM_RESEND) { 4318a5d547adSRandall Stewart #ifdef SCTP_FLIGHT_LOGGING 4319c105859eSRandall Stewart sctp_misc_ints(SCTP_FLIGHT_LOG_DOWN_CA, 4320a5d547adSRandall Stewart tp1->whoTo->flight_size, 4321a5d547adSRandall Stewart tp1->book_size, 4322c105859eSRandall Stewart (uintptr_t) tp1->whoTo, 4323a5d547adSRandall Stewart tp1->rec.data.TSN_seq); 4324a5d547adSRandall Stewart #endif 4325a5d547adSRandall Stewart 4326c105859eSRandall Stewart sctp_flight_size_decrease(tp1); 4327c105859eSRandall Stewart sctp_total_flight_decrease(stcb, tp1); 4328f8829a4aSRandall Stewart } 4329f8829a4aSRandall Stewart tp1->whoTo->net_ack += tp1->send_size; 4330f8829a4aSRandall Stewart if (tp1->snd_count < 2) { 4331f8829a4aSRandall Stewart /* 43325e54f665SRandall Stewart * True 43335e54f665SRandall Stewart * non-retransmited 4334f8829a4aSRandall Stewart * chunk 4335f8829a4aSRandall Stewart */ 4336f8829a4aSRandall Stewart tp1->whoTo->net_ack2 += 4337f8829a4aSRandall Stewart tp1->send_size; 4338f8829a4aSRandall Stewart 4339f8829a4aSRandall Stewart /* update RTO too? */ 434062c1ff9cSRandall Stewart if (tp1->do_rtt) { 4341f8829a4aSRandall Stewart tp1->whoTo->RTO = 4342f8829a4aSRandall Stewart sctp_calculate_rto(stcb, 4343f8829a4aSRandall Stewart asoc, tp1->whoTo, 4344f8829a4aSRandall Stewart &tp1->sent_rcv_time); 4345f8829a4aSRandall Stewart tp1->do_rtt = 0; 4346f8829a4aSRandall Stewart } 4347f8829a4aSRandall Stewart } 4348132dea7dSRandall Stewart /* 43495e54f665SRandall Stewart * CMT: CUCv2 algorithm. 43505e54f665SRandall Stewart * From the cumack'd TSNs, 43515e54f665SRandall Stewart * for each TSN being acked 43525e54f665SRandall Stewart * for the first time, set 43535e54f665SRandall Stewart * the following variables 43545e54f665SRandall Stewart * for the corresp 43555e54f665SRandall Stewart * destination. 43565e54f665SRandall Stewart * new_pseudo_cumack will 43575e54f665SRandall Stewart * trigger a cwnd update. 43585e54f665SRandall Stewart * find_(rtx_)pseudo_cumack 43595e54f665SRandall Stewart * will trigger search for 43605e54f665SRandall Stewart * the next expected 43615e54f665SRandall Stewart * (rtx-)pseudo-cumack. 4362132dea7dSRandall Stewart */ 4363132dea7dSRandall Stewart tp1->whoTo->new_pseudo_cumack = 1; 4364132dea7dSRandall Stewart tp1->whoTo->find_pseudo_cumack = 1; 4365132dea7dSRandall Stewart tp1->whoTo->find_rtx_pseudo_cumack = 1; 4366132dea7dSRandall Stewart 4367f8829a4aSRandall Stewart #ifdef SCTP_CWND_LOGGING 4368f8829a4aSRandall Stewart sctp_log_cwnd(stcb, tp1->whoTo, tp1->rec.data.TSN_seq, SCTP_CWND_LOG_FROM_SACK); 4369f8829a4aSRandall Stewart #endif 4370f8829a4aSRandall Stewart } 4371f8829a4aSRandall Stewart if (tp1->sent == SCTP_DATAGRAM_RESEND) { 4372f8829a4aSRandall Stewart sctp_ucount_decr(asoc->sent_queue_retran_cnt); 4373f8829a4aSRandall Stewart } 437442551e99SRandall Stewart if (tp1->rec.data.chunk_was_revoked) { 437542551e99SRandall Stewart /* deflate the cwnd */ 437642551e99SRandall Stewart tp1->whoTo->cwnd -= tp1->book_size; 437742551e99SRandall Stewart tp1->rec.data.chunk_was_revoked = 0; 437842551e99SRandall Stewart } 4379f8829a4aSRandall Stewart tp1->sent = SCTP_DATAGRAM_ACKED; 4380f8829a4aSRandall Stewart } 4381f8829a4aSRandall Stewart } else { 4382f8829a4aSRandall Stewart break; 4383f8829a4aSRandall Stewart } 4384f8829a4aSRandall Stewart TAILQ_REMOVE(&asoc->sent_queue, tp1, sctp_next); 4385f8829a4aSRandall Stewart if (tp1->data) { 4386f8829a4aSRandall Stewart sctp_free_bufspace(stcb, asoc, tp1, 1); 4387f8829a4aSRandall Stewart sctp_m_freem(tp1->data); 4388f8829a4aSRandall Stewart } 4389f8829a4aSRandall Stewart #ifdef SCTP_SACK_LOGGING 4390f8829a4aSRandall Stewart sctp_log_sack(asoc->last_acked_seq, 4391f8829a4aSRandall Stewart cumack, 4392f8829a4aSRandall Stewart tp1->rec.data.TSN_seq, 4393f8829a4aSRandall Stewart 0, 4394f8829a4aSRandall Stewart 0, 4395f8829a4aSRandall Stewart SCTP_LOG_FREE_SENT); 4396f8829a4aSRandall Stewart #endif 4397f8829a4aSRandall Stewart tp1->data = NULL; 4398f8829a4aSRandall Stewart asoc->sent_queue_cnt--; 4399f8829a4aSRandall Stewart sctp_free_remote_addr(tp1->whoTo); 4400f8829a4aSRandall Stewart sctp_free_a_chunk(stcb, tp1); 4401f8829a4aSRandall Stewart tp1 = tp2; 4402f8829a4aSRandall Stewart } 44035e54f665SRandall Stewart } 4404f8829a4aSRandall Stewart if (stcb->sctp_socket) { 4405f8829a4aSRandall Stewart SOCKBUF_LOCK(&stcb->sctp_socket->so_snd); 4406f8829a4aSRandall Stewart #ifdef SCTP_WAKE_LOGGING 4407f8829a4aSRandall Stewart sctp_wakeup_log(stcb, cumack, 1, SCTP_WAKESND_FROM_SACK); 4408f8829a4aSRandall Stewart #endif 4409f8829a4aSRandall Stewart sctp_sowwakeup_locked(stcb->sctp_ep, stcb->sctp_socket); 4410f8829a4aSRandall Stewart #ifdef SCTP_WAKE_LOGGING 4411f8829a4aSRandall Stewart } else { 4412f8829a4aSRandall Stewart sctp_wakeup_log(stcb, cumack, 1, SCTP_NOWAKE_FROM_SACK); 4413f8829a4aSRandall Stewart #endif 4414f8829a4aSRandall Stewart } 4415f8829a4aSRandall Stewart 44165e54f665SRandall Stewart 4417f8829a4aSRandall Stewart if (asoc->last_acked_seq != cumack) 4418f8829a4aSRandall Stewart sctp_cwnd_update(stcb, asoc, 1, 0, 0); 44195e54f665SRandall Stewart 4420f8829a4aSRandall Stewart asoc->last_acked_seq = cumack; 44215e54f665SRandall Stewart 4422f8829a4aSRandall Stewart if (TAILQ_EMPTY(&asoc->sent_queue)) { 4423f8829a4aSRandall Stewart /* nothing left in-flight */ 4424f8829a4aSRandall Stewart TAILQ_FOREACH(net, &asoc->nets, sctp_next) { 4425f8829a4aSRandall Stewart net->flight_size = 0; 4426f8829a4aSRandall Stewart net->partial_bytes_acked = 0; 4427f8829a4aSRandall Stewart } 4428f8829a4aSRandall Stewart asoc->total_flight = 0; 4429f8829a4aSRandall Stewart asoc->total_flight_count = 0; 4430f8829a4aSRandall Stewart } 4431f8829a4aSRandall Stewart /* Fix up the a-p-a-p for future PR-SCTP sends */ 4432f8829a4aSRandall Stewart if (compare_with_wrap(cumack, asoc->advanced_peer_ack_point, MAX_TSN)) { 4433f8829a4aSRandall Stewart asoc->advanced_peer_ack_point = cumack; 4434f8829a4aSRandall Stewart } 4435f8829a4aSRandall Stewart /* ECN Nonce updates */ 4436f8829a4aSRandall Stewart if (asoc->ecn_nonce_allowed) { 4437f8829a4aSRandall Stewart if (asoc->nonce_sum_check) { 4438f8829a4aSRandall Stewart if (nonce_sum_flag != ((asoc->nonce_sum_expect_base) & SCTP_SACK_NONCE_SUM)) { 4439f8829a4aSRandall Stewart if (asoc->nonce_wait_for_ecne == 0) { 4440f8829a4aSRandall Stewart struct sctp_tmit_chunk *lchk; 4441f8829a4aSRandall Stewart 4442f8829a4aSRandall Stewart lchk = TAILQ_FIRST(&asoc->send_queue); 4443f8829a4aSRandall Stewart asoc->nonce_wait_for_ecne = 1; 4444f8829a4aSRandall Stewart if (lchk) { 4445f8829a4aSRandall Stewart asoc->nonce_wait_tsn = lchk->rec.data.TSN_seq; 4446f8829a4aSRandall Stewart } else { 4447f8829a4aSRandall Stewart asoc->nonce_wait_tsn = asoc->sending_seq; 4448f8829a4aSRandall Stewart } 4449f8829a4aSRandall Stewart } else { 4450f8829a4aSRandall Stewart if (compare_with_wrap(asoc->last_acked_seq, asoc->nonce_wait_tsn, MAX_TSN) || 4451f8829a4aSRandall Stewart (asoc->last_acked_seq == asoc->nonce_wait_tsn)) { 4452f8829a4aSRandall Stewart /* 4453f8829a4aSRandall Stewart * Misbehaving peer. We need 4454f8829a4aSRandall Stewart * to react to this guy 4455f8829a4aSRandall Stewart */ 4456f8829a4aSRandall Stewart asoc->ecn_allowed = 0; 4457f8829a4aSRandall Stewart asoc->ecn_nonce_allowed = 0; 4458f8829a4aSRandall Stewart } 4459f8829a4aSRandall Stewart } 4460f8829a4aSRandall Stewart } 4461f8829a4aSRandall Stewart } else { 4462f8829a4aSRandall Stewart /* See if Resynchronization Possible */ 4463f8829a4aSRandall Stewart if (compare_with_wrap(asoc->last_acked_seq, asoc->nonce_resync_tsn, MAX_TSN)) { 4464f8829a4aSRandall Stewart asoc->nonce_sum_check = 1; 4465f8829a4aSRandall Stewart /* 4466f8829a4aSRandall Stewart * now we must calculate what the base is. 4467f8829a4aSRandall Stewart * We do this based on two things, we know 4468f8829a4aSRandall Stewart * the total's for all the segments 4469f8829a4aSRandall Stewart * gap-acked in the SACK (none), We also 4470f8829a4aSRandall Stewart * know the SACK's nonce sum, its in 4471f8829a4aSRandall Stewart * nonce_sum_flag. So we can build a truth 4472f8829a4aSRandall Stewart * table to back-calculate the new value of 4473f8829a4aSRandall Stewart * asoc->nonce_sum_expect_base: 4474f8829a4aSRandall Stewart * 4475f8829a4aSRandall Stewart * SACK-flag-Value Seg-Sums Base 0 0 0 4476f8829a4aSRandall Stewart * 1 0 1 0 1 1 1 4477f8829a4aSRandall Stewart * 1 0 4478f8829a4aSRandall Stewart */ 4479f8829a4aSRandall Stewart asoc->nonce_sum_expect_base = (0 ^ nonce_sum_flag) & SCTP_SACK_NONCE_SUM; 4480f8829a4aSRandall Stewart } 4481f8829a4aSRandall Stewart } 4482f8829a4aSRandall Stewart } 4483f8829a4aSRandall Stewart /* RWND update */ 4484f8829a4aSRandall Stewart asoc->peers_rwnd = sctp_sbspace_sub(rwnd, 4485f8829a4aSRandall Stewart (uint32_t) (asoc->total_flight + (asoc->sent_queue_cnt * sctp_peer_chunk_oh))); 4486f8829a4aSRandall Stewart if (asoc->peers_rwnd < stcb->sctp_ep->sctp_ep.sctp_sws_sender) { 4487f8829a4aSRandall Stewart /* SWS sender side engages */ 4488f8829a4aSRandall Stewart asoc->peers_rwnd = 0; 4489f8829a4aSRandall Stewart } 44905e54f665SRandall Stewart if (asoc->peers_rwnd > old_rwnd) { 44915e54f665SRandall Stewart win_probe_recovery = 1; 44925e54f665SRandall Stewart } 4493f8829a4aSRandall Stewart /* Now assure a timer where data is queued at */ 4494a5d547adSRandall Stewart again: 4495a5d547adSRandall Stewart j = 0; 4496f8829a4aSRandall Stewart TAILQ_FOREACH(net, &asoc->nets, sctp_next) { 44975e54f665SRandall Stewart if (win_probe_recovery && (net->window_probe)) { 44985e54f665SRandall Stewart net->window_probe = 0; 4499c105859eSRandall Stewart win_probe_recovered = 1; 45005e54f665SRandall Stewart /* 45015e54f665SRandall Stewart * Find first chunk that was used with window probe 45025e54f665SRandall Stewart * and clear the sent 45035e54f665SRandall Stewart */ 45045e54f665SRandall Stewart TAILQ_FOREACH(tp1, &asoc->sent_queue, sctp_next) { 45055e54f665SRandall Stewart if (tp1->window_probe) { 45065e54f665SRandall Stewart /* move back to data send queue */ 4507c105859eSRandall Stewart sctp_window_probe_recovery(stcb, asoc, net, tp1); 45085e54f665SRandall Stewart break; 45095e54f665SRandall Stewart } 45105e54f665SRandall Stewart } 45115e54f665SRandall Stewart } 4512f8829a4aSRandall Stewart if (net->flight_size) { 4513f8829a4aSRandall Stewart int to_ticks; 4514f8829a4aSRandall Stewart 4515f8829a4aSRandall Stewart if (net->RTO == 0) { 4516f8829a4aSRandall Stewart to_ticks = MSEC_TO_TICKS(stcb->asoc.initial_rto); 4517f8829a4aSRandall Stewart } else { 4518f8829a4aSRandall Stewart to_ticks = MSEC_TO_TICKS(net->RTO); 4519f8829a4aSRandall Stewart } 4520a5d547adSRandall Stewart j++; 4521139bc87fSRandall Stewart SCTP_OS_TIMER_START(&net->rxt_timer.timer, to_ticks, 4522f8829a4aSRandall Stewart sctp_timeout_handler, &net->rxt_timer); 4523f8829a4aSRandall Stewart } else { 4524139bc87fSRandall Stewart if (SCTP_OS_TIMER_PENDING(&net->rxt_timer.timer)) { 4525f8829a4aSRandall Stewart sctp_timer_stop(SCTP_TIMER_TYPE_SEND, stcb->sctp_ep, 4526a5d547adSRandall Stewart stcb, net, 4527a5d547adSRandall Stewart SCTP_FROM_SCTP_INDATA + SCTP_LOC_22); 4528f8829a4aSRandall Stewart } 4529f8829a4aSRandall Stewart if (sctp_early_fr) { 4530139bc87fSRandall Stewart if (SCTP_OS_TIMER_PENDING(&net->fr_timer.timer)) { 4531f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_earlyfrstpidsck4); 4532a5d547adSRandall Stewart sctp_timer_stop(SCTP_TIMER_TYPE_EARLYFR, stcb->sctp_ep, stcb, net, 4533a5d547adSRandall Stewart SCTP_FROM_SCTP_INDATA + SCTP_LOC_23); 4534f8829a4aSRandall Stewart } 4535f8829a4aSRandall Stewart } 4536f8829a4aSRandall Stewart } 4537f8829a4aSRandall Stewart } 4538bff64a4dSRandall Stewart if ((j == 0) && 4539bff64a4dSRandall Stewart (!TAILQ_EMPTY(&asoc->sent_queue)) && 4540bff64a4dSRandall Stewart (asoc->sent_queue_retran_cnt == 0) && 4541c105859eSRandall Stewart (win_probe_recovered == 0) && 4542bff64a4dSRandall Stewart (done_once == 0)) { 4543a5d547adSRandall Stewart /* huh, this should not happen */ 4544c105859eSRandall Stewart sctp_fs_audit(asoc); 4545a5d547adSRandall Stewart TAILQ_FOREACH(net, &asoc->nets, sctp_next) { 4546a5d547adSRandall Stewart net->flight_size = 0; 4547a5d547adSRandall Stewart } 4548a5d547adSRandall Stewart asoc->total_flight = 0; 4549a5d547adSRandall Stewart asoc->total_flight_count = 0; 4550a5d547adSRandall Stewart asoc->sent_queue_retran_cnt = 0; 4551a5d547adSRandall Stewart TAILQ_FOREACH(tp1, &asoc->sent_queue, sctp_next) { 4552a5d547adSRandall Stewart if (tp1->sent < SCTP_DATAGRAM_RESEND) { 4553c105859eSRandall Stewart sctp_flight_size_increase(tp1); 4554c105859eSRandall Stewart sctp_total_flight_increase(stcb, tp1); 4555a5d547adSRandall Stewart } else if (tp1->sent == SCTP_DATAGRAM_RESEND) { 4556a5d547adSRandall Stewart asoc->sent_queue_retran_cnt++; 4557a5d547adSRandall Stewart } 4558a5d547adSRandall Stewart } 4559bff64a4dSRandall Stewart done_once = 1; 4560a5d547adSRandall Stewart goto again; 4561a5d547adSRandall Stewart } 4562f8829a4aSRandall Stewart /**********************************/ 4563f8829a4aSRandall Stewart /* Now what about shutdown issues */ 4564f8829a4aSRandall Stewart /**********************************/ 4565f8829a4aSRandall Stewart if (TAILQ_EMPTY(&asoc->send_queue) && TAILQ_EMPTY(&asoc->sent_queue)) { 4566f8829a4aSRandall Stewart /* nothing left on sendqueue.. consider done */ 4567f8829a4aSRandall Stewart /* clean up */ 4568f8829a4aSRandall Stewart if ((asoc->stream_queue_cnt == 1) && 4569f8829a4aSRandall Stewart ((asoc->state & SCTP_STATE_SHUTDOWN_PENDING) || 4570f8829a4aSRandall Stewart (asoc->state & SCTP_STATE_SHUTDOWN_RECEIVED)) && 4571f8829a4aSRandall Stewart (asoc->locked_on_sending) 4572f8829a4aSRandall Stewart ) { 4573f8829a4aSRandall Stewart struct sctp_stream_queue_pending *sp; 4574f8829a4aSRandall Stewart 4575f8829a4aSRandall Stewart /* 4576f8829a4aSRandall Stewart * I may be in a state where we got all across.. but 4577f8829a4aSRandall Stewart * cannot write more due to a shutdown... we abort 4578f8829a4aSRandall Stewart * since the user did not indicate EOR in this case. 4579f8829a4aSRandall Stewart * The sp will be cleaned during free of the asoc. 4580f8829a4aSRandall Stewart */ 4581f8829a4aSRandall Stewart sp = TAILQ_LAST(&((asoc->locked_on_sending)->outqueue), 4582f8829a4aSRandall Stewart sctp_streamhead); 4583f8829a4aSRandall Stewart if ((sp) && (sp->length == 0) && (sp->msg_is_complete == 0)) { 4584f8829a4aSRandall Stewart asoc->state |= SCTP_STATE_PARTIAL_MSG_LEFT; 4585f8829a4aSRandall Stewart asoc->locked_on_sending = NULL; 4586f8829a4aSRandall Stewart asoc->stream_queue_cnt--; 4587f8829a4aSRandall Stewart } 4588f8829a4aSRandall Stewart } 4589f8829a4aSRandall Stewart if ((asoc->state & SCTP_STATE_SHUTDOWN_PENDING) && 4590f8829a4aSRandall Stewart (asoc->stream_queue_cnt == 0)) { 4591f8829a4aSRandall Stewart if (asoc->state & SCTP_STATE_PARTIAL_MSG_LEFT) { 4592f8829a4aSRandall Stewart /* Need to abort here */ 4593f8829a4aSRandall Stewart struct mbuf *oper; 4594f8829a4aSRandall Stewart 4595f8829a4aSRandall Stewart abort_out_now: 4596f8829a4aSRandall Stewart *abort_now = 1; 4597f8829a4aSRandall Stewart /* XXX */ 4598f8829a4aSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + sizeof(uint32_t)), 4599f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 4600f8829a4aSRandall Stewart if (oper) { 4601f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 4602f8829a4aSRandall Stewart uint32_t *ippp; 4603f8829a4aSRandall Stewart 4604139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = sizeof(struct sctp_paramhdr) + 4605f8829a4aSRandall Stewart sizeof(uint32_t); 4606f8829a4aSRandall Stewart ph = mtod(oper, struct sctp_paramhdr *); 4607f8829a4aSRandall Stewart ph->param_type = htons(SCTP_CAUSE_USER_INITIATED_ABT); 4608139bc87fSRandall Stewart ph->param_length = htons(SCTP_BUF_LEN(oper)); 4609f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 4610a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_24); 4611f8829a4aSRandall Stewart } 4612a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_24; 4613f8829a4aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, stcb, SCTP_RESPONSE_TO_USER_REQ, oper); 4614f8829a4aSRandall Stewart } else { 4615f42a358aSRandall Stewart if ((SCTP_GET_STATE(asoc) == SCTP_STATE_OPEN) || 4616f42a358aSRandall Stewart (SCTP_GET_STATE(asoc) == SCTP_STATE_SHUTDOWN_RECEIVED)) { 4617f8829a4aSRandall Stewart SCTP_STAT_DECR_GAUGE32(sctps_currestab); 4618f42a358aSRandall Stewart } 4619f42a358aSRandall Stewart asoc->state = SCTP_STATE_SHUTDOWN_SENT; 4620f8829a4aSRandall Stewart sctp_stop_timers_for_shutdown(stcb); 4621f8829a4aSRandall Stewart sctp_send_shutdown(stcb, 4622f8829a4aSRandall Stewart stcb->asoc.primary_destination); 4623f8829a4aSRandall Stewart sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWN, 4624f8829a4aSRandall Stewart stcb->sctp_ep, stcb, asoc->primary_destination); 4625f8829a4aSRandall Stewart sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWNGUARD, 4626f8829a4aSRandall Stewart stcb->sctp_ep, stcb, asoc->primary_destination); 4627f8829a4aSRandall Stewart } 4628f8829a4aSRandall Stewart } else if ((SCTP_GET_STATE(asoc) == SCTP_STATE_SHUTDOWN_RECEIVED) && 4629f8829a4aSRandall Stewart (asoc->stream_queue_cnt == 0)) { 4630f8829a4aSRandall Stewart if (asoc->state & SCTP_STATE_PARTIAL_MSG_LEFT) { 4631f8829a4aSRandall Stewart goto abort_out_now; 4632f8829a4aSRandall Stewart } 4633f8829a4aSRandall Stewart SCTP_STAT_DECR_GAUGE32(sctps_currestab); 4634f42a358aSRandall Stewart asoc->state = SCTP_STATE_SHUTDOWN_ACK_SENT; 4635f8829a4aSRandall Stewart sctp_send_shutdown_ack(stcb, 4636f8829a4aSRandall Stewart stcb->asoc.primary_destination); 4637f8829a4aSRandall Stewart 4638f8829a4aSRandall Stewart sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWNACK, 4639f8829a4aSRandall Stewart stcb->sctp_ep, stcb, asoc->primary_destination); 4640f8829a4aSRandall Stewart } 4641f8829a4aSRandall Stewart } 4642f8829a4aSRandall Stewart #ifdef SCTP_SACK_RWND_LOGGING 4643f8829a4aSRandall Stewart sctp_misc_ints(SCTP_SACK_RWND_UPDATE, 4644f8829a4aSRandall Stewart rwnd, 4645f8829a4aSRandall Stewart stcb->asoc.peers_rwnd, 4646f8829a4aSRandall Stewart stcb->asoc.total_flight, 4647f8829a4aSRandall Stewart stcb->asoc.total_output_queue_size); 4648f8829a4aSRandall Stewart 4649f8829a4aSRandall Stewart #endif 4650f8829a4aSRandall Stewart } 4651f8829a4aSRandall Stewart 4652f8829a4aSRandall Stewart 4653f8829a4aSRandall Stewart 4654f8829a4aSRandall Stewart void 4655f8829a4aSRandall Stewart sctp_handle_sack(struct sctp_sack_chunk *ch, struct sctp_tcb *stcb, 4656d06c82f1SRandall Stewart struct sctp_nets *net_from, int *abort_now, int sack_len, uint32_t rwnd) 4657f8829a4aSRandall Stewart { 4658f8829a4aSRandall Stewart struct sctp_association *asoc; 4659f8829a4aSRandall Stewart struct sctp_sack *sack; 4660f8829a4aSRandall Stewart struct sctp_tmit_chunk *tp1, *tp2; 4661f8829a4aSRandall Stewart uint32_t cum_ack, last_tsn, biggest_tsn_acked, biggest_tsn_newly_acked, 4662f8829a4aSRandall Stewart this_sack_lowest_newack; 4663bff64a4dSRandall Stewart uint32_t sav_cum_ack; 4664f8829a4aSRandall Stewart uint16_t num_seg, num_dup; 4665f8829a4aSRandall Stewart uint16_t wake_him = 0; 4666f8829a4aSRandall Stewart unsigned int sack_length; 4667c105859eSRandall Stewart uint32_t send_s = 0; 4668f8829a4aSRandall Stewart long j; 4669f8829a4aSRandall Stewart int accum_moved = 0; 4670f8829a4aSRandall Stewart int will_exit_fast_recovery = 0; 46715e54f665SRandall Stewart uint32_t a_rwnd, old_rwnd; 46725e54f665SRandall Stewart int win_probe_recovery = 0; 4673c105859eSRandall Stewart int win_probe_recovered = 0; 4674f8829a4aSRandall Stewart struct sctp_nets *net = NULL; 4675f8829a4aSRandall Stewart int nonce_sum_flag, ecn_seg_sums = 0; 4676bff64a4dSRandall Stewart int done_once; 4677f8829a4aSRandall Stewart uint8_t reneged_all = 0; 4678f8829a4aSRandall Stewart uint8_t cmt_dac_flag; 4679f8829a4aSRandall Stewart 4680f8829a4aSRandall Stewart /* 4681f8829a4aSRandall Stewart * we take any chance we can to service our queues since we cannot 4682f8829a4aSRandall Stewart * get awoken when the socket is read from :< 4683f8829a4aSRandall Stewart */ 4684f8829a4aSRandall Stewart /* 4685f8829a4aSRandall Stewart * Now perform the actual SACK handling: 1) Verify that it is not an 4686f8829a4aSRandall Stewart * old sack, if so discard. 2) If there is nothing left in the send 4687f8829a4aSRandall Stewart * queue (cum-ack is equal to last acked) then you have a duplicate 4688f8829a4aSRandall Stewart * too, update any rwnd change and verify no timers are running. 4689f8829a4aSRandall Stewart * then return. 3) Process any new consequtive data i.e. cum-ack 4690f8829a4aSRandall Stewart * moved process these first and note that it moved. 4) Process any 4691f8829a4aSRandall Stewart * sack blocks. 5) Drop any acked from the queue. 6) Check for any 4692f8829a4aSRandall Stewart * revoked blocks and mark. 7) Update the cwnd. 8) Nothing left, 4693f8829a4aSRandall Stewart * sync up flightsizes and things, stop all timers and also check 4694f8829a4aSRandall Stewart * for shutdown_pending state. If so then go ahead and send off the 4695f8829a4aSRandall Stewart * shutdown. If in shutdown recv, send off the shutdown-ack and 4696f8829a4aSRandall Stewart * start that timer, Ret. 9) Strike any non-acked things and do FR 4697f8829a4aSRandall Stewart * procedure if needed being sure to set the FR flag. 10) Do pr-sctp 4698f8829a4aSRandall Stewart * procedures. 11) Apply any FR penalties. 12) Assure we will SACK 4699f8829a4aSRandall Stewart * if in shutdown_recv state. 4700f8829a4aSRandall Stewart */ 4701f8829a4aSRandall Stewart SCTP_TCB_LOCK_ASSERT(stcb); 4702f8829a4aSRandall Stewart sack = &ch->sack; 4703f8829a4aSRandall Stewart /* CMT DAC algo */ 4704f8829a4aSRandall Stewart this_sack_lowest_newack = 0; 4705f8829a4aSRandall Stewart j = 0; 4706d06c82f1SRandall Stewart sack_length = (unsigned int)sack_len; 4707f8829a4aSRandall Stewart /* ECN Nonce */ 4708f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_slowpath_sack); 4709f8829a4aSRandall Stewart nonce_sum_flag = ch->ch.chunk_flags & SCTP_SACK_NONCE_SUM; 4710f8829a4aSRandall Stewart cum_ack = last_tsn = ntohl(sack->cum_tsn_ack); 4711f8829a4aSRandall Stewart num_seg = ntohs(sack->num_gap_ack_blks); 4712d06c82f1SRandall Stewart a_rwnd = rwnd; 4713f8829a4aSRandall Stewart 4714d06c82f1SRandall Stewart #ifdef SCTP_LOG_SACK_ARRIVALS 4715d06c82f1SRandall Stewart sctp_misc_ints(SCTP_SACK_LOG_NORMAL, cum_ack, 4716d06c82f1SRandall Stewart rwnd, stcb->asoc.last_acked_seq, stcb->asoc.peers_rwnd); 4717d06c82f1SRandall Stewart #endif 4718f8829a4aSRandall Stewart /* CMT DAC algo */ 4719f8829a4aSRandall Stewart cmt_dac_flag = ch->ch.chunk_flags & SCTP_SACK_CMT_DAC; 4720f8829a4aSRandall Stewart num_dup = ntohs(sack->num_dup_tsns); 4721f8829a4aSRandall Stewart 47225e54f665SRandall Stewart old_rwnd = stcb->asoc.peers_rwnd; 4723f8829a4aSRandall Stewart stcb->asoc.overall_error_count = 0; 4724f8829a4aSRandall Stewart asoc = &stcb->asoc; 4725f8829a4aSRandall Stewart #ifdef SCTP_SACK_LOGGING 4726f8829a4aSRandall Stewart sctp_log_sack(asoc->last_acked_seq, 4727f8829a4aSRandall Stewart cum_ack, 4728f8829a4aSRandall Stewart 0, 4729f8829a4aSRandall Stewart num_seg, 4730f8829a4aSRandall Stewart num_dup, 4731f8829a4aSRandall Stewart SCTP_LOG_NEW_SACK); 4732f8829a4aSRandall Stewart #endif 4733f8829a4aSRandall Stewart #if defined(SCTP_FR_LOGGING) || defined(SCTP_EARLYFR_LOGGING) 4734f8829a4aSRandall Stewart if (num_dup) { 4735f8829a4aSRandall Stewart int off_to_dup, iii; 4736f8829a4aSRandall Stewart uint32_t *dupdata; 4737f8829a4aSRandall Stewart 4738f8829a4aSRandall Stewart off_to_dup = (num_seg * sizeof(struct sctp_gap_ack_block)) + sizeof(struct sctp_sack_chunk); 4739f8829a4aSRandall Stewart if ((off_to_dup + (num_dup * sizeof(uint32_t))) <= sack_length) { 4740f8829a4aSRandall Stewart dupdata = (uint32_t *) ((caddr_t)ch + off_to_dup); 4741f8829a4aSRandall Stewart for (iii = 0; iii < num_dup; iii++) { 4742f8829a4aSRandall Stewart sctp_log_fr(*dupdata, 0, 0, SCTP_FR_DUPED); 4743f8829a4aSRandall Stewart dupdata++; 4744f8829a4aSRandall Stewart 4745f8829a4aSRandall Stewart } 4746f8829a4aSRandall Stewart } else { 4747f8829a4aSRandall Stewart printf("Size invalid offset to dups:%d number dups:%d sack_len:%d num gaps:%d\n", 4748f8829a4aSRandall Stewart off_to_dup, num_dup, sack_length, num_seg); 4749f8829a4aSRandall Stewart } 4750f8829a4aSRandall Stewart } 4751f8829a4aSRandall Stewart #endif 4752f8829a4aSRandall Stewart if (sctp_strict_sacks) { 4753c105859eSRandall Stewart /* reality check */ 4754c105859eSRandall Stewart if (!TAILQ_EMPTY(&asoc->sent_queue)) { 4755c105859eSRandall Stewart tp1 = TAILQ_LAST(&asoc->sent_queue, 4756c105859eSRandall Stewart sctpchunk_listhead); 4757c105859eSRandall Stewart send_s = tp1->rec.data.TSN_seq + 1; 4758c105859eSRandall Stewart } else { 4759c105859eSRandall Stewart send_s = asoc->sending_seq; 4760c105859eSRandall Stewart } 4761f8829a4aSRandall Stewart if (cum_ack == send_s || 4762f8829a4aSRandall Stewart compare_with_wrap(cum_ack, send_s, MAX_TSN)) { 4763c105859eSRandall Stewart #ifndef INVARIANTS 4764c105859eSRandall Stewart struct mbuf *oper; 4765c105859eSRandall Stewart 4766c105859eSRandall Stewart #endif 4767c105859eSRandall Stewart #ifdef INVARIANTS 4768139bc87fSRandall Stewart hopeless_peer: 4769139bc87fSRandall Stewart panic("Impossible sack 1"); 4770139bc87fSRandall Stewart #else 4771c105859eSRandall Stewart 4772f8829a4aSRandall Stewart 4773f8829a4aSRandall Stewart /* 4774f8829a4aSRandall Stewart * no way, we have not even sent this TSN out yet. 4775f8829a4aSRandall Stewart * Peer is hopelessly messed up with us. 4776f8829a4aSRandall Stewart */ 4777f8829a4aSRandall Stewart hopeless_peer: 4778f8829a4aSRandall Stewart *abort_now = 1; 4779f8829a4aSRandall Stewart /* XXX */ 4780f8829a4aSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + sizeof(uint32_t)), 4781f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 4782f8829a4aSRandall Stewart if (oper) { 4783f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 4784f8829a4aSRandall Stewart uint32_t *ippp; 4785f8829a4aSRandall Stewart 4786139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = sizeof(struct sctp_paramhdr) + 4787f8829a4aSRandall Stewart sizeof(uint32_t); 4788f8829a4aSRandall Stewart ph = mtod(oper, struct sctp_paramhdr *); 4789f8829a4aSRandall Stewart ph->param_type = htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 4790139bc87fSRandall Stewart ph->param_length = htons(SCTP_BUF_LEN(oper)); 4791f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 4792a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_25); 4793f8829a4aSRandall Stewart } 4794a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_25; 4795f8829a4aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, stcb, SCTP_PEER_FAULTY, oper); 4796f8829a4aSRandall Stewart return; 4797139bc87fSRandall Stewart #endif 4798f8829a4aSRandall Stewart } 4799f8829a4aSRandall Stewart } 4800f8829a4aSRandall Stewart /**********************/ 4801f8829a4aSRandall Stewart /* 1) check the range */ 4802f8829a4aSRandall Stewart /**********************/ 4803f8829a4aSRandall Stewart if (compare_with_wrap(asoc->last_acked_seq, last_tsn, MAX_TSN)) { 4804f8829a4aSRandall Stewart /* acking something behind */ 4805f8829a4aSRandall Stewart return; 4806f8829a4aSRandall Stewart } 4807bff64a4dSRandall Stewart sav_cum_ack = asoc->last_acked_seq; 4808bff64a4dSRandall Stewart 4809f8829a4aSRandall Stewart /* update the Rwnd of the peer */ 4810f8829a4aSRandall Stewart if (TAILQ_EMPTY(&asoc->sent_queue) && 4811f8829a4aSRandall Stewart TAILQ_EMPTY(&asoc->send_queue) && 4812f8829a4aSRandall Stewart (asoc->stream_queue_cnt == 0) 4813f8829a4aSRandall Stewart ) { 4814f8829a4aSRandall Stewart /* nothing left on send/sent and strmq */ 4815f8829a4aSRandall Stewart #ifdef SCTP_LOG_RWND 4816f8829a4aSRandall Stewart sctp_log_rwnd_set(SCTP_SET_PEER_RWND_VIA_SACK, 4817f8829a4aSRandall Stewart asoc->peers_rwnd, 0, 0, a_rwnd); 4818f8829a4aSRandall Stewart #endif 4819f8829a4aSRandall Stewart asoc->peers_rwnd = a_rwnd; 4820f8829a4aSRandall Stewart if (asoc->sent_queue_retran_cnt) { 4821f8829a4aSRandall Stewart asoc->sent_queue_retran_cnt = 0; 4822f8829a4aSRandall Stewart } 4823f8829a4aSRandall Stewart if (asoc->peers_rwnd < stcb->sctp_ep->sctp_ep.sctp_sws_sender) { 4824f8829a4aSRandall Stewart /* SWS sender side engages */ 4825f8829a4aSRandall Stewart asoc->peers_rwnd = 0; 4826f8829a4aSRandall Stewart } 4827f8829a4aSRandall Stewart /* stop any timers */ 4828f8829a4aSRandall Stewart TAILQ_FOREACH(net, &asoc->nets, sctp_next) { 4829f8829a4aSRandall Stewart sctp_timer_stop(SCTP_TIMER_TYPE_SEND, stcb->sctp_ep, 4830a5d547adSRandall Stewart stcb, net, SCTP_FROM_SCTP_INDATA + SCTP_LOC_26); 4831f8829a4aSRandall Stewart if (sctp_early_fr) { 4832139bc87fSRandall Stewart if (SCTP_OS_TIMER_PENDING(&net->fr_timer.timer)) { 4833f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_earlyfrstpidsck1); 4834a5d547adSRandall Stewart sctp_timer_stop(SCTP_TIMER_TYPE_EARLYFR, stcb->sctp_ep, stcb, net, 4835a5d547adSRandall Stewart SCTP_FROM_SCTP_INDATA + SCTP_LOC_26); 4836f8829a4aSRandall Stewart } 4837f8829a4aSRandall Stewart } 4838f8829a4aSRandall Stewart net->partial_bytes_acked = 0; 4839f8829a4aSRandall Stewart net->flight_size = 0; 4840f8829a4aSRandall Stewart } 4841f8829a4aSRandall Stewart asoc->total_flight = 0; 4842f8829a4aSRandall Stewart asoc->total_flight_count = 0; 4843f8829a4aSRandall Stewart return; 4844f8829a4aSRandall Stewart } 4845f8829a4aSRandall Stewart /* 4846f8829a4aSRandall Stewart * We init netAckSz and netAckSz2 to 0. These are used to track 2 4847f8829a4aSRandall Stewart * things. The total byte count acked is tracked in netAckSz AND 4848f8829a4aSRandall Stewart * netAck2 is used to track the total bytes acked that are un- 4849f8829a4aSRandall Stewart * amibguious and were never retransmitted. We track these on a per 4850f8829a4aSRandall Stewart * destination address basis. 4851f8829a4aSRandall Stewart */ 4852f8829a4aSRandall Stewart TAILQ_FOREACH(net, &asoc->nets, sctp_next) { 4853f8829a4aSRandall Stewart net->prev_cwnd = net->cwnd; 4854f8829a4aSRandall Stewart net->net_ack = 0; 4855f8829a4aSRandall Stewart net->net_ack2 = 0; 4856f8829a4aSRandall Stewart 4857f8829a4aSRandall Stewart /* 485842551e99SRandall Stewart * CMT: Reset CUC and Fast recovery algo variables before 485942551e99SRandall Stewart * SACK processing 4860f8829a4aSRandall Stewart */ 4861f8829a4aSRandall Stewart net->new_pseudo_cumack = 0; 4862f8829a4aSRandall Stewart net->will_exit_fast_recovery = 0; 4863f8829a4aSRandall Stewart } 4864f8829a4aSRandall Stewart /* process the new consecutive TSN first */ 4865f8829a4aSRandall Stewart tp1 = TAILQ_FIRST(&asoc->sent_queue); 4866f8829a4aSRandall Stewart while (tp1) { 4867f8829a4aSRandall Stewart if (compare_with_wrap(last_tsn, tp1->rec.data.TSN_seq, 4868f8829a4aSRandall Stewart MAX_TSN) || 4869f8829a4aSRandall Stewart last_tsn == tp1->rec.data.TSN_seq) { 4870f8829a4aSRandall Stewart if (tp1->sent != SCTP_DATAGRAM_UNSENT) { 4871f8829a4aSRandall Stewart /* 4872f8829a4aSRandall Stewart * ECN Nonce: Add the nonce to the sender's 4873f8829a4aSRandall Stewart * nonce sum 4874f8829a4aSRandall Stewart */ 4875f8829a4aSRandall Stewart asoc->nonce_sum_expect_base += tp1->rec.data.ect_nonce; 4876f8829a4aSRandall Stewart accum_moved = 1; 4877f8829a4aSRandall Stewart if (tp1->sent < SCTP_DATAGRAM_ACKED) { 4878f8829a4aSRandall Stewart /* 4879f8829a4aSRandall Stewart * If it is less than ACKED, it is 4880f8829a4aSRandall Stewart * now no-longer in flight. Higher 4881f8829a4aSRandall Stewart * values may occur during marking 4882f8829a4aSRandall Stewart */ 4883f8829a4aSRandall Stewart if ((tp1->whoTo->dest_state & 4884f8829a4aSRandall Stewart SCTP_ADDR_UNCONFIRMED) && 4885f8829a4aSRandall Stewart (tp1->snd_count < 2)) { 4886f8829a4aSRandall Stewart /* 4887f8829a4aSRandall Stewart * If there was no retran 4888f8829a4aSRandall Stewart * and the address is 4889f8829a4aSRandall Stewart * un-confirmed and we sent 4890f8829a4aSRandall Stewart * there and are now 4891f8829a4aSRandall Stewart * sacked.. its confirmed, 4892f8829a4aSRandall Stewart * mark it so. 4893f8829a4aSRandall Stewart */ 4894f8829a4aSRandall Stewart tp1->whoTo->dest_state &= 4895f8829a4aSRandall Stewart ~SCTP_ADDR_UNCONFIRMED; 4896f8829a4aSRandall Stewart } 4897c105859eSRandall Stewart if (tp1->sent < SCTP_DATAGRAM_RESEND) { 4898a5d547adSRandall Stewart #ifdef SCTP_FLIGHT_LOGGING 4899c105859eSRandall Stewart sctp_misc_ints(SCTP_FLIGHT_LOG_DOWN_CA, 4900a5d547adSRandall Stewart tp1->whoTo->flight_size, 4901a5d547adSRandall Stewart tp1->book_size, 4902c105859eSRandall Stewart (uintptr_t) tp1->whoTo, 4903a5d547adSRandall Stewart tp1->rec.data.TSN_seq); 4904a5d547adSRandall Stewart #endif 4905c105859eSRandall Stewart sctp_flight_size_decrease(tp1); 4906c105859eSRandall Stewart sctp_total_flight_decrease(stcb, tp1); 4907f8829a4aSRandall Stewart } 4908f8829a4aSRandall Stewart tp1->whoTo->net_ack += tp1->send_size; 4909f8829a4aSRandall Stewart 4910f8829a4aSRandall Stewart /* CMT SFR and DAC algos */ 4911f8829a4aSRandall Stewart this_sack_lowest_newack = tp1->rec.data.TSN_seq; 4912f8829a4aSRandall Stewart tp1->whoTo->saw_newack = 1; 4913f8829a4aSRandall Stewart 4914f8829a4aSRandall Stewart if (tp1->snd_count < 2) { 4915f8829a4aSRandall Stewart /* 4916f8829a4aSRandall Stewart * True non-retransmited 4917f8829a4aSRandall Stewart * chunk 4918f8829a4aSRandall Stewart */ 4919f8829a4aSRandall Stewart tp1->whoTo->net_ack2 += 4920f8829a4aSRandall Stewart tp1->send_size; 4921f8829a4aSRandall Stewart 4922f8829a4aSRandall Stewart /* update RTO too? */ 4923f8829a4aSRandall Stewart if (tp1->do_rtt) { 4924f8829a4aSRandall Stewart tp1->whoTo->RTO = 4925f8829a4aSRandall Stewart sctp_calculate_rto(stcb, 4926f8829a4aSRandall Stewart asoc, tp1->whoTo, 4927f8829a4aSRandall Stewart &tp1->sent_rcv_time); 4928f8829a4aSRandall Stewart tp1->do_rtt = 0; 4929f8829a4aSRandall Stewart } 4930f8829a4aSRandall Stewart } 4931f8829a4aSRandall Stewart /* 4932f8829a4aSRandall Stewart * CMT: CUCv2 algorithm. From the 4933f8829a4aSRandall Stewart * cumack'd TSNs, for each TSN being 4934f8829a4aSRandall Stewart * acked for the first time, set the 4935f8829a4aSRandall Stewart * following variables for the 4936f8829a4aSRandall Stewart * corresp destination. 4937f8829a4aSRandall Stewart * new_pseudo_cumack will trigger a 4938f8829a4aSRandall Stewart * cwnd update. 4939f8829a4aSRandall Stewart * find_(rtx_)pseudo_cumack will 4940f8829a4aSRandall Stewart * trigger search for the next 4941f8829a4aSRandall Stewart * expected (rtx-)pseudo-cumack. 4942f8829a4aSRandall Stewart */ 4943f8829a4aSRandall Stewart tp1->whoTo->new_pseudo_cumack = 1; 4944f8829a4aSRandall Stewart tp1->whoTo->find_pseudo_cumack = 1; 4945f8829a4aSRandall Stewart tp1->whoTo->find_rtx_pseudo_cumack = 1; 4946f8829a4aSRandall Stewart 4947f8829a4aSRandall Stewart 4948f8829a4aSRandall Stewart #ifdef SCTP_SACK_LOGGING 4949f8829a4aSRandall Stewart sctp_log_sack(asoc->last_acked_seq, 4950f8829a4aSRandall Stewart cum_ack, 4951f8829a4aSRandall Stewart tp1->rec.data.TSN_seq, 4952f8829a4aSRandall Stewart 0, 4953f8829a4aSRandall Stewart 0, 4954f8829a4aSRandall Stewart SCTP_LOG_TSN_ACKED); 4955f8829a4aSRandall Stewart #endif 4956f8829a4aSRandall Stewart #ifdef SCTP_CWND_LOGGING 4957f8829a4aSRandall Stewart sctp_log_cwnd(stcb, tp1->whoTo, tp1->rec.data.TSN_seq, SCTP_CWND_LOG_FROM_SACK); 4958f8829a4aSRandall Stewart #endif 4959f8829a4aSRandall Stewart } 4960f8829a4aSRandall Stewart if (tp1->sent == SCTP_DATAGRAM_RESEND) { 4961f8829a4aSRandall Stewart sctp_ucount_decr(asoc->sent_queue_retran_cnt); 4962f8829a4aSRandall Stewart #ifdef SCTP_AUDITING_ENABLED 4963f8829a4aSRandall Stewart sctp_audit_log(0xB3, 4964f8829a4aSRandall Stewart (asoc->sent_queue_retran_cnt & 0x000000ff)); 4965f8829a4aSRandall Stewart #endif 4966f8829a4aSRandall Stewart } 496742551e99SRandall Stewart if (tp1->rec.data.chunk_was_revoked) { 496842551e99SRandall Stewart /* deflate the cwnd */ 496942551e99SRandall Stewart tp1->whoTo->cwnd -= tp1->book_size; 497042551e99SRandall Stewart tp1->rec.data.chunk_was_revoked = 0; 497142551e99SRandall Stewart } 4972f8829a4aSRandall Stewart tp1->sent = SCTP_DATAGRAM_ACKED; 4973f8829a4aSRandall Stewart } 4974f8829a4aSRandall Stewart } else { 4975f8829a4aSRandall Stewart break; 4976f8829a4aSRandall Stewart } 4977f8829a4aSRandall Stewart tp1 = TAILQ_NEXT(tp1, sctp_next); 4978f8829a4aSRandall Stewart } 4979f8829a4aSRandall Stewart biggest_tsn_newly_acked = biggest_tsn_acked = last_tsn; 4980f8829a4aSRandall Stewart /* always set this up to cum-ack */ 4981f8829a4aSRandall Stewart asoc->this_sack_highest_gap = last_tsn; 4982f8829a4aSRandall Stewart 4983f8829a4aSRandall Stewart if (((num_seg * (sizeof(struct sctp_gap_ack_block))) + sizeof(struct sctp_sack_chunk)) > sack_length) { 4984f8829a4aSRandall Stewart 4985f8829a4aSRandall Stewart /* skip corrupt segments */ 4986f8829a4aSRandall Stewart goto skip_segments; 4987f8829a4aSRandall Stewart } 4988f8829a4aSRandall Stewart if (num_seg > 0) { 4989f8829a4aSRandall Stewart 4990f8829a4aSRandall Stewart /* 4991f8829a4aSRandall Stewart * CMT: SFR algo (and HTNA) - this_sack_highest_newack has 4992f8829a4aSRandall Stewart * to be greater than the cumack. Also reset saw_newack to 0 4993f8829a4aSRandall Stewart * for all dests. 4994f8829a4aSRandall Stewart */ 4995f8829a4aSRandall Stewart TAILQ_FOREACH(net, &asoc->nets, sctp_next) { 4996f8829a4aSRandall Stewart net->saw_newack = 0; 4997f8829a4aSRandall Stewart net->this_sack_highest_newack = last_tsn; 4998f8829a4aSRandall Stewart } 4999f8829a4aSRandall Stewart 5000f8829a4aSRandall Stewart /* 5001f8829a4aSRandall Stewart * thisSackHighestGap will increase while handling NEW 5002f8829a4aSRandall Stewart * segments this_sack_highest_newack will increase while 5003f8829a4aSRandall Stewart * handling NEWLY ACKED chunks. this_sack_lowest_newack is 5004f8829a4aSRandall Stewart * used for CMT DAC algo. saw_newack will also change. 5005f8829a4aSRandall Stewart */ 5006f8829a4aSRandall Stewart sctp_handle_segments(stcb, asoc, ch, last_tsn, 5007f8829a4aSRandall Stewart &biggest_tsn_acked, &biggest_tsn_newly_acked, &this_sack_lowest_newack, 5008f8829a4aSRandall Stewart num_seg, &ecn_seg_sums); 5009f8829a4aSRandall Stewart 5010f8829a4aSRandall Stewart if (sctp_strict_sacks) { 5011f8829a4aSRandall Stewart /* 5012f8829a4aSRandall Stewart * validate the biggest_tsn_acked in the gap acks if 5013f8829a4aSRandall Stewart * strict adherence is wanted. 5014f8829a4aSRandall Stewart */ 5015f8829a4aSRandall Stewart if ((biggest_tsn_acked == send_s) || 5016f8829a4aSRandall Stewart (compare_with_wrap(biggest_tsn_acked, send_s, MAX_TSN))) { 5017f8829a4aSRandall Stewart /* 5018f8829a4aSRandall Stewart * peer is either confused or we are under 5019f8829a4aSRandall Stewart * attack. We must abort. 5020f8829a4aSRandall Stewart */ 5021f8829a4aSRandall Stewart goto hopeless_peer; 5022f8829a4aSRandall Stewart } 5023f8829a4aSRandall Stewart } 5024f8829a4aSRandall Stewart } 5025f8829a4aSRandall Stewart skip_segments: 5026f8829a4aSRandall Stewart /*******************************************/ 5027f8829a4aSRandall Stewart /* cancel ALL T3-send timer if accum moved */ 5028f8829a4aSRandall Stewart /*******************************************/ 5029f8829a4aSRandall Stewart if (sctp_cmt_on_off) { 5030f8829a4aSRandall Stewart TAILQ_FOREACH(net, &asoc->nets, sctp_next) { 5031f8829a4aSRandall Stewart if (net->new_pseudo_cumack) 5032f8829a4aSRandall Stewart sctp_timer_stop(SCTP_TIMER_TYPE_SEND, stcb->sctp_ep, 5033a5d547adSRandall Stewart stcb, net, 5034a5d547adSRandall Stewart SCTP_FROM_SCTP_INDATA + SCTP_LOC_27); 5035f8829a4aSRandall Stewart 5036f8829a4aSRandall Stewart } 5037f8829a4aSRandall Stewart } else { 5038f8829a4aSRandall Stewart if (accum_moved) { 5039f8829a4aSRandall Stewart TAILQ_FOREACH(net, &asoc->nets, sctp_next) { 5040f8829a4aSRandall Stewart sctp_timer_stop(SCTP_TIMER_TYPE_SEND, stcb->sctp_ep, 5041a5d547adSRandall Stewart stcb, net, SCTP_FROM_SCTP_INDATA + SCTP_LOC_28); 5042f8829a4aSRandall Stewart } 5043f8829a4aSRandall Stewart } 5044f8829a4aSRandall Stewart } 5045f8829a4aSRandall Stewart /********************************************/ 5046f8829a4aSRandall Stewart /* drop the acked chunks from the sendqueue */ 5047f8829a4aSRandall Stewart /********************************************/ 5048f8829a4aSRandall Stewart asoc->last_acked_seq = cum_ack; 5049f8829a4aSRandall Stewart 5050f8829a4aSRandall Stewart tp1 = TAILQ_FIRST(&asoc->sent_queue); 5051f8829a4aSRandall Stewart if (tp1 == NULL) 5052f8829a4aSRandall Stewart goto done_with_it; 5053f8829a4aSRandall Stewart do { 5054f8829a4aSRandall Stewart if (compare_with_wrap(tp1->rec.data.TSN_seq, cum_ack, 5055f8829a4aSRandall Stewart MAX_TSN)) { 5056f8829a4aSRandall Stewart break; 5057f8829a4aSRandall Stewart } 5058f8829a4aSRandall Stewart if (tp1->sent == SCTP_DATAGRAM_UNSENT) { 5059f8829a4aSRandall Stewart /* no more sent on list */ 5060f8829a4aSRandall Stewart break; 5061f8829a4aSRandall Stewart } 5062f8829a4aSRandall Stewart tp2 = TAILQ_NEXT(tp1, sctp_next); 5063f8829a4aSRandall Stewart TAILQ_REMOVE(&asoc->sent_queue, tp1, sctp_next); 5064f8829a4aSRandall Stewart /* 5065f8829a4aSRandall Stewart * Friendlier printf in lieu of panic now that I think its 5066f8829a4aSRandall Stewart * fixed 5067f8829a4aSRandall Stewart */ 5068f8829a4aSRandall Stewart 5069f8829a4aSRandall Stewart if (tp1->pr_sctp_on) { 5070f8829a4aSRandall Stewart if (asoc->pr_sctp_cnt != 0) 5071f8829a4aSRandall Stewart asoc->pr_sctp_cnt--; 5072f8829a4aSRandall Stewart } 5073f8829a4aSRandall Stewart if ((TAILQ_FIRST(&asoc->sent_queue) == NULL) && 5074f8829a4aSRandall Stewart (asoc->total_flight > 0)) { 5075f1f73e57SRandall Stewart #ifdef INVARIANTS 5076c105859eSRandall Stewart panic("Warning flight size is postive and should be 0"); 5077f1f73e57SRandall Stewart #else 5078f1f73e57SRandall Stewart 5079f8829a4aSRandall Stewart printf("Warning flight size incorrect should be 0 is %d\n", 5080f8829a4aSRandall Stewart asoc->total_flight); 5081f1f73e57SRandall Stewart #endif 5082f8829a4aSRandall Stewart asoc->total_flight = 0; 5083f8829a4aSRandall Stewart } 5084f8829a4aSRandall Stewart if (tp1->data) { 5085f8829a4aSRandall Stewart sctp_free_bufspace(stcb, asoc, tp1, 1); 5086f8829a4aSRandall Stewart sctp_m_freem(tp1->data); 5087f8829a4aSRandall Stewart if (PR_SCTP_BUF_ENABLED(tp1->flags)) { 5088f8829a4aSRandall Stewart asoc->sent_queue_cnt_removeable--; 5089f8829a4aSRandall Stewart } 5090f8829a4aSRandall Stewart } 5091f8829a4aSRandall Stewart #ifdef SCTP_SACK_LOGGING 5092f8829a4aSRandall Stewart sctp_log_sack(asoc->last_acked_seq, 5093f8829a4aSRandall Stewart cum_ack, 5094f8829a4aSRandall Stewart tp1->rec.data.TSN_seq, 5095f8829a4aSRandall Stewart 0, 5096f8829a4aSRandall Stewart 0, 5097f8829a4aSRandall Stewart SCTP_LOG_FREE_SENT); 5098f8829a4aSRandall Stewart #endif 5099f8829a4aSRandall Stewart tp1->data = NULL; 5100f8829a4aSRandall Stewart asoc->sent_queue_cnt--; 5101f8829a4aSRandall Stewart sctp_free_remote_addr(tp1->whoTo); 5102f8829a4aSRandall Stewart 5103f8829a4aSRandall Stewart sctp_free_a_chunk(stcb, tp1); 5104f8829a4aSRandall Stewart wake_him++; 5105f8829a4aSRandall Stewart tp1 = tp2; 5106f8829a4aSRandall Stewart } while (tp1 != NULL); 5107f8829a4aSRandall Stewart 5108f8829a4aSRandall Stewart done_with_it: 5109f8829a4aSRandall Stewart if ((wake_him) && (stcb->sctp_socket)) { 5110f8829a4aSRandall Stewart SOCKBUF_LOCK(&stcb->sctp_socket->so_snd); 5111f8829a4aSRandall Stewart #ifdef SCTP_WAKE_LOGGING 5112f8829a4aSRandall Stewart sctp_wakeup_log(stcb, cum_ack, wake_him, SCTP_WAKESND_FROM_SACK); 5113f8829a4aSRandall Stewart #endif 5114f8829a4aSRandall Stewart sctp_sowwakeup_locked(stcb->sctp_ep, stcb->sctp_socket); 5115f8829a4aSRandall Stewart #ifdef SCTP_WAKE_LOGGING 5116f8829a4aSRandall Stewart } else { 5117f8829a4aSRandall Stewart sctp_wakeup_log(stcb, cum_ack, wake_him, SCTP_NOWAKE_FROM_SACK); 5118f8829a4aSRandall Stewart #endif 5119f8829a4aSRandall Stewart } 5120f8829a4aSRandall Stewart 512142551e99SRandall Stewart if (asoc->fast_retran_loss_recovery && accum_moved) { 5122f8829a4aSRandall Stewart if (compare_with_wrap(asoc->last_acked_seq, 5123f8829a4aSRandall Stewart asoc->fast_recovery_tsn, MAX_TSN) || 5124f8829a4aSRandall Stewart asoc->last_acked_seq == asoc->fast_recovery_tsn) { 5125f8829a4aSRandall Stewart /* Setup so we will exit RFC2582 fast recovery */ 5126f8829a4aSRandall Stewart will_exit_fast_recovery = 1; 5127f8829a4aSRandall Stewart } 5128f8829a4aSRandall Stewart } 5129f8829a4aSRandall Stewart /* 5130f8829a4aSRandall Stewart * Check for revoked fragments: 5131f8829a4aSRandall Stewart * 5132f8829a4aSRandall Stewart * if Previous sack - Had no frags then we can't have any revoked if 5133f8829a4aSRandall Stewart * Previous sack - Had frag's then - If we now have frags aka 5134f8829a4aSRandall Stewart * num_seg > 0 call sctp_check_for_revoked() to tell if peer revoked 5135f8829a4aSRandall Stewart * some of them. else - The peer revoked all ACKED fragments, since 5136f8829a4aSRandall Stewart * we had some before and now we have NONE. 5137f8829a4aSRandall Stewart */ 5138f8829a4aSRandall Stewart 5139f42a358aSRandall Stewart if (num_seg) 5140c105859eSRandall Stewart sctp_check_for_revoked(stcb, asoc, cum_ack, biggest_tsn_acked); 5141f8829a4aSRandall Stewart else if (asoc->saw_sack_with_frags) { 5142f8829a4aSRandall Stewart int cnt_revoked = 0; 5143f8829a4aSRandall Stewart 5144f8829a4aSRandall Stewart tp1 = TAILQ_FIRST(&asoc->sent_queue); 5145f8829a4aSRandall Stewart if (tp1 != NULL) { 5146f8829a4aSRandall Stewart /* Peer revoked all dg's marked or acked */ 5147f8829a4aSRandall Stewart TAILQ_FOREACH(tp1, &asoc->sent_queue, sctp_next) { 5148f8829a4aSRandall Stewart if ((tp1->sent > SCTP_DATAGRAM_RESEND) && 5149f8829a4aSRandall Stewart (tp1->sent < SCTP_FORWARD_TSN_SKIP)) { 5150f8829a4aSRandall Stewart tp1->sent = SCTP_DATAGRAM_SENT; 5151c105859eSRandall Stewart #ifdef SCTP_FLIGHT_LOGGING 5152c105859eSRandall Stewart sctp_misc_ints(SCTP_FLIGHT_LOG_UP_REVOKE, 5153c105859eSRandall Stewart tp1->whoTo->flight_size, 5154c105859eSRandall Stewart tp1->book_size, 5155c105859eSRandall Stewart (uintptr_t) tp1->whoTo, 5156c105859eSRandall Stewart tp1->rec.data.TSN_seq); 5157c105859eSRandall Stewart #endif 5158c105859eSRandall Stewart sctp_flight_size_increase(tp1); 5159c105859eSRandall Stewart sctp_total_flight_increase(stcb, tp1); 5160a5d547adSRandall Stewart tp1->rec.data.chunk_was_revoked = 1; 516142551e99SRandall Stewart /* 516242551e99SRandall Stewart * To ensure that this increase in 516342551e99SRandall Stewart * flightsize, which is artificial, 516442551e99SRandall Stewart * does not throttle the sender, we 516542551e99SRandall Stewart * also increase the cwnd 516642551e99SRandall Stewart * artificially. 516742551e99SRandall Stewart */ 516842551e99SRandall Stewart tp1->whoTo->cwnd += tp1->book_size; 5169f8829a4aSRandall Stewart cnt_revoked++; 5170f8829a4aSRandall Stewart } 5171f8829a4aSRandall Stewart } 5172f8829a4aSRandall Stewart if (cnt_revoked) { 5173f8829a4aSRandall Stewart reneged_all = 1; 5174f8829a4aSRandall Stewart } 5175f8829a4aSRandall Stewart } 5176f8829a4aSRandall Stewart asoc->saw_sack_with_frags = 0; 5177f8829a4aSRandall Stewart } 5178f8829a4aSRandall Stewart if (num_seg) 5179f8829a4aSRandall Stewart asoc->saw_sack_with_frags = 1; 5180f8829a4aSRandall Stewart else 5181f8829a4aSRandall Stewart asoc->saw_sack_with_frags = 0; 5182f8829a4aSRandall Stewart 5183f8829a4aSRandall Stewart 5184f8829a4aSRandall Stewart sctp_cwnd_update(stcb, asoc, accum_moved, reneged_all, will_exit_fast_recovery); 5185f8829a4aSRandall Stewart 5186f8829a4aSRandall Stewart if (TAILQ_EMPTY(&asoc->sent_queue)) { 5187f8829a4aSRandall Stewart /* nothing left in-flight */ 5188f8829a4aSRandall Stewart TAILQ_FOREACH(net, &asoc->nets, sctp_next) { 5189f8829a4aSRandall Stewart /* stop all timers */ 5190f8829a4aSRandall Stewart if (sctp_early_fr) { 5191139bc87fSRandall Stewart if (SCTP_OS_TIMER_PENDING(&net->fr_timer.timer)) { 5192f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_earlyfrstpidsck4); 5193a5d547adSRandall Stewart sctp_timer_stop(SCTP_TIMER_TYPE_EARLYFR, stcb->sctp_ep, stcb, net, 5194a5d547adSRandall Stewart SCTP_FROM_SCTP_INDATA + SCTP_LOC_29); 5195f8829a4aSRandall Stewart } 5196f8829a4aSRandall Stewart } 5197f8829a4aSRandall Stewart sctp_timer_stop(SCTP_TIMER_TYPE_SEND, stcb->sctp_ep, 5198a5d547adSRandall Stewart stcb, net, SCTP_FROM_SCTP_INDATA + SCTP_LOC_30); 5199f8829a4aSRandall Stewart net->flight_size = 0; 5200f8829a4aSRandall Stewart net->partial_bytes_acked = 0; 5201f8829a4aSRandall Stewart } 5202f8829a4aSRandall Stewart asoc->total_flight = 0; 5203f8829a4aSRandall Stewart asoc->total_flight_count = 0; 5204f8829a4aSRandall Stewart } 5205f8829a4aSRandall Stewart /**********************************/ 5206f8829a4aSRandall Stewart /* Now what about shutdown issues */ 5207f8829a4aSRandall Stewart /**********************************/ 5208f8829a4aSRandall Stewart if (TAILQ_EMPTY(&asoc->send_queue) && TAILQ_EMPTY(&asoc->sent_queue)) { 5209f8829a4aSRandall Stewart /* nothing left on sendqueue.. consider done */ 5210f8829a4aSRandall Stewart #ifdef SCTP_LOG_RWND 5211f8829a4aSRandall Stewart sctp_log_rwnd_set(SCTP_SET_PEER_RWND_VIA_SACK, 5212f8829a4aSRandall Stewart asoc->peers_rwnd, 0, 0, a_rwnd); 5213f8829a4aSRandall Stewart #endif 5214f8829a4aSRandall Stewart asoc->peers_rwnd = a_rwnd; 5215f8829a4aSRandall Stewart if (asoc->peers_rwnd < stcb->sctp_ep->sctp_ep.sctp_sws_sender) { 5216f8829a4aSRandall Stewart /* SWS sender side engages */ 5217f8829a4aSRandall Stewart asoc->peers_rwnd = 0; 5218f8829a4aSRandall Stewart } 5219f8829a4aSRandall Stewart /* clean up */ 5220f8829a4aSRandall Stewart if ((asoc->stream_queue_cnt == 1) && 5221f8829a4aSRandall Stewart ((asoc->state & SCTP_STATE_SHUTDOWN_PENDING) || 5222f8829a4aSRandall Stewart (asoc->state & SCTP_STATE_SHUTDOWN_RECEIVED)) && 5223f8829a4aSRandall Stewart (asoc->locked_on_sending) 5224f8829a4aSRandall Stewart ) { 5225f8829a4aSRandall Stewart struct sctp_stream_queue_pending *sp; 5226f8829a4aSRandall Stewart 5227f8829a4aSRandall Stewart /* 5228f8829a4aSRandall Stewart * I may be in a state where we got all across.. but 5229f8829a4aSRandall Stewart * cannot write more due to a shutdown... we abort 5230f8829a4aSRandall Stewart * since the user did not indicate EOR in this case. 5231f8829a4aSRandall Stewart */ 5232f8829a4aSRandall Stewart sp = TAILQ_LAST(&((asoc->locked_on_sending)->outqueue), 5233f8829a4aSRandall Stewart sctp_streamhead); 5234f8829a4aSRandall Stewart if ((sp) && (sp->length == 0) && (sp->msg_is_complete == 0)) { 5235f8829a4aSRandall Stewart asoc->state |= SCTP_STATE_PARTIAL_MSG_LEFT; 5236f8829a4aSRandall Stewart asoc->locked_on_sending = NULL; 5237f8829a4aSRandall Stewart asoc->stream_queue_cnt--; 5238f8829a4aSRandall Stewart } 5239f8829a4aSRandall Stewart } 5240f8829a4aSRandall Stewart if ((asoc->state & SCTP_STATE_SHUTDOWN_PENDING) && 5241f8829a4aSRandall Stewart (asoc->stream_queue_cnt == 0)) { 5242f8829a4aSRandall Stewart if (asoc->state & SCTP_STATE_PARTIAL_MSG_LEFT) { 5243f8829a4aSRandall Stewart /* Need to abort here */ 5244f8829a4aSRandall Stewart struct mbuf *oper; 5245f8829a4aSRandall Stewart 5246f8829a4aSRandall Stewart abort_out_now: 5247f8829a4aSRandall Stewart *abort_now = 1; 5248f8829a4aSRandall Stewart /* XXX */ 5249f8829a4aSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + sizeof(uint32_t)), 5250f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 5251f8829a4aSRandall Stewart if (oper) { 5252f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 5253f8829a4aSRandall Stewart uint32_t *ippp; 5254f8829a4aSRandall Stewart 5255139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = sizeof(struct sctp_paramhdr) + 5256f8829a4aSRandall Stewart sizeof(uint32_t); 5257f8829a4aSRandall Stewart ph = mtod(oper, struct sctp_paramhdr *); 5258f8829a4aSRandall Stewart ph->param_type = htons(SCTP_CAUSE_USER_INITIATED_ABT); 5259139bc87fSRandall Stewart ph->param_length = htons(SCTP_BUF_LEN(oper)); 5260f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 5261a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_31); 5262f8829a4aSRandall Stewart } 5263a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_31; 5264f8829a4aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, stcb, SCTP_RESPONSE_TO_USER_REQ, oper); 5265f8829a4aSRandall Stewart return; 5266f8829a4aSRandall Stewart } else { 5267f42a358aSRandall Stewart if ((SCTP_GET_STATE(asoc) == SCTP_STATE_OPEN) || 5268f42a358aSRandall Stewart (SCTP_GET_STATE(asoc) == SCTP_STATE_SHUTDOWN_RECEIVED)) { 5269f8829a4aSRandall Stewart SCTP_STAT_DECR_GAUGE32(sctps_currestab); 5270f42a358aSRandall Stewart } 5271f42a358aSRandall Stewart asoc->state = SCTP_STATE_SHUTDOWN_SENT; 5272f8829a4aSRandall Stewart sctp_stop_timers_for_shutdown(stcb); 5273f8829a4aSRandall Stewart sctp_send_shutdown(stcb, 5274f8829a4aSRandall Stewart stcb->asoc.primary_destination); 5275f8829a4aSRandall Stewart sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWN, 5276f8829a4aSRandall Stewart stcb->sctp_ep, stcb, asoc->primary_destination); 5277f8829a4aSRandall Stewart sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWNGUARD, 5278f8829a4aSRandall Stewart stcb->sctp_ep, stcb, asoc->primary_destination); 5279f8829a4aSRandall Stewart } 5280f8829a4aSRandall Stewart return; 5281f8829a4aSRandall Stewart } else if ((SCTP_GET_STATE(asoc) == SCTP_STATE_SHUTDOWN_RECEIVED) && 5282f8829a4aSRandall Stewart (asoc->stream_queue_cnt == 0)) { 5283f8829a4aSRandall Stewart if (asoc->state & SCTP_STATE_PARTIAL_MSG_LEFT) { 5284f8829a4aSRandall Stewart goto abort_out_now; 5285f8829a4aSRandall Stewart } 5286f8829a4aSRandall Stewart SCTP_STAT_DECR_GAUGE32(sctps_currestab); 5287f42a358aSRandall Stewart asoc->state = SCTP_STATE_SHUTDOWN_ACK_SENT; 5288f8829a4aSRandall Stewart sctp_send_shutdown_ack(stcb, 5289f8829a4aSRandall Stewart stcb->asoc.primary_destination); 5290f8829a4aSRandall Stewart 5291f8829a4aSRandall Stewart sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWNACK, 5292f8829a4aSRandall Stewart stcb->sctp_ep, stcb, asoc->primary_destination); 5293f8829a4aSRandall Stewart return; 5294f8829a4aSRandall Stewart } 5295f8829a4aSRandall Stewart } 5296f8829a4aSRandall Stewart /* 5297f8829a4aSRandall Stewart * Now here we are going to recycle net_ack for a different use... 5298f8829a4aSRandall Stewart * HEADS UP. 5299f8829a4aSRandall Stewart */ 5300f8829a4aSRandall Stewart TAILQ_FOREACH(net, &asoc->nets, sctp_next) { 5301f8829a4aSRandall Stewart net->net_ack = 0; 5302f8829a4aSRandall Stewart } 5303f8829a4aSRandall Stewart 5304f8829a4aSRandall Stewart /* 5305f8829a4aSRandall Stewart * CMT DAC algorithm: If SACK DAC flag was 0, then no extra marking 5306f8829a4aSRandall Stewart * to be done. Setting this_sack_lowest_newack to the cum_ack will 5307f8829a4aSRandall Stewart * automatically ensure that. 5308f8829a4aSRandall Stewart */ 5309f8829a4aSRandall Stewart if (sctp_cmt_on_off && sctp_cmt_use_dac && (cmt_dac_flag == 0)) { 5310f8829a4aSRandall Stewart this_sack_lowest_newack = cum_ack; 5311f8829a4aSRandall Stewart } 5312f8829a4aSRandall Stewart if (num_seg > 0) { 5313f8829a4aSRandall Stewart sctp_strike_gap_ack_chunks(stcb, asoc, biggest_tsn_acked, 5314f8829a4aSRandall Stewart biggest_tsn_newly_acked, this_sack_lowest_newack, accum_moved); 5315f8829a4aSRandall Stewart } 5316f8829a4aSRandall Stewart /*********************************************/ 5317f8829a4aSRandall Stewart /* Here we perform PR-SCTP procedures */ 5318f8829a4aSRandall Stewart /* (section 4.2) */ 5319f8829a4aSRandall Stewart /*********************************************/ 5320f8829a4aSRandall Stewart /* C1. update advancedPeerAckPoint */ 5321f8829a4aSRandall Stewart if (compare_with_wrap(cum_ack, asoc->advanced_peer_ack_point, MAX_TSN)) { 5322f8829a4aSRandall Stewart asoc->advanced_peer_ack_point = cum_ack; 5323f8829a4aSRandall Stewart } 5324f8829a4aSRandall Stewart /* C2. try to further move advancedPeerAckPoint ahead */ 5325f8829a4aSRandall Stewart 5326f8829a4aSRandall Stewart if ((asoc->peer_supports_prsctp) && (asoc->pr_sctp_cnt > 0)) { 5327f8829a4aSRandall Stewart struct sctp_tmit_chunk *lchk; 5328f8829a4aSRandall Stewart 5329f8829a4aSRandall Stewart lchk = sctp_try_advance_peer_ack_point(stcb, asoc); 5330f8829a4aSRandall Stewart /* C3. See if we need to send a Fwd-TSN */ 5331f8829a4aSRandall Stewart if (compare_with_wrap(asoc->advanced_peer_ack_point, cum_ack, 5332f8829a4aSRandall Stewart MAX_TSN)) { 5333f8829a4aSRandall Stewart /* 5334f8829a4aSRandall Stewart * ISSUE with ECN, see FWD-TSN processing for notes 5335f8829a4aSRandall Stewart * on issues that will occur when the ECN NONCE 5336f8829a4aSRandall Stewart * stuff is put into SCTP for cross checking. 5337f8829a4aSRandall Stewart */ 5338f8829a4aSRandall Stewart send_forward_tsn(stcb, asoc); 5339f8829a4aSRandall Stewart 5340f8829a4aSRandall Stewart /* 5341f8829a4aSRandall Stewart * ECN Nonce: Disable Nonce Sum check when FWD TSN 5342f8829a4aSRandall Stewart * is sent and store resync tsn 5343f8829a4aSRandall Stewart */ 5344f8829a4aSRandall Stewart asoc->nonce_sum_check = 0; 5345f8829a4aSRandall Stewart asoc->nonce_resync_tsn = asoc->advanced_peer_ack_point; 5346f8829a4aSRandall Stewart if (lchk) { 5347f8829a4aSRandall Stewart /* Assure a timer is up */ 5348f8829a4aSRandall Stewart sctp_timer_start(SCTP_TIMER_TYPE_SEND, 5349f8829a4aSRandall Stewart stcb->sctp_ep, stcb, lchk->whoTo); 5350f8829a4aSRandall Stewart } 5351f8829a4aSRandall Stewart } 5352f8829a4aSRandall Stewart } 5353f8829a4aSRandall Stewart /* 5354f8829a4aSRandall Stewart * CMT fast recovery code. Need to debug. ((sctp_cmt_on_off == 1) && 5355c105859eSRandall Stewart * (net->fast_retran_loss_recovery == 0))) 5356f8829a4aSRandall Stewart */ 5357f8829a4aSRandall Stewart TAILQ_FOREACH(net, &asoc->nets, sctp_next) { 5358c105859eSRandall Stewart if ((asoc->fast_retran_loss_recovery == 0) || (sctp_cmt_on_off == 1)) { 5359f8829a4aSRandall Stewart /* out of a RFC2582 Fast recovery window? */ 5360f8829a4aSRandall Stewart if (net->net_ack > 0) { 5361f8829a4aSRandall Stewart /* 5362f8829a4aSRandall Stewart * per section 7.2.3, are there any 5363f8829a4aSRandall Stewart * destinations that had a fast retransmit 5364f8829a4aSRandall Stewart * to them. If so what we need to do is 5365f8829a4aSRandall Stewart * adjust ssthresh and cwnd. 5366f8829a4aSRandall Stewart */ 5367f8829a4aSRandall Stewart struct sctp_tmit_chunk *lchk; 5368f8829a4aSRandall Stewart 5369f8829a4aSRandall Stewart #ifdef SCTP_HIGH_SPEED 537050cec919SRandall Stewart sctp_hs_cwnd_decrease(stcb, net); 5371f8829a4aSRandall Stewart #else 5372f8829a4aSRandall Stewart #ifdef SCTP_CWND_MONITOR 5373f8829a4aSRandall Stewart int old_cwnd = net->cwnd; 5374f8829a4aSRandall Stewart 5375f8829a4aSRandall Stewart #endif 5376f8829a4aSRandall Stewart net->ssthresh = net->cwnd / 2; 5377f8829a4aSRandall Stewart if (net->ssthresh < (net->mtu * 2)) { 5378f8829a4aSRandall Stewart net->ssthresh = 2 * net->mtu; 5379f8829a4aSRandall Stewart } 5380f8829a4aSRandall Stewart net->cwnd = net->ssthresh; 5381f8829a4aSRandall Stewart #ifdef SCTP_CWND_MONITOR 5382f8829a4aSRandall Stewart sctp_log_cwnd(stcb, net, (net->cwnd - old_cwnd), 5383f8829a4aSRandall Stewart SCTP_CWND_LOG_FROM_FR); 5384f8829a4aSRandall Stewart #endif 5385f8829a4aSRandall Stewart #endif 5386f8829a4aSRandall Stewart 5387f8829a4aSRandall Stewart lchk = TAILQ_FIRST(&asoc->send_queue); 5388f8829a4aSRandall Stewart 5389f8829a4aSRandall Stewart net->partial_bytes_acked = 0; 5390f8829a4aSRandall Stewart /* Turn on fast recovery window */ 5391f8829a4aSRandall Stewart asoc->fast_retran_loss_recovery = 1; 5392f8829a4aSRandall Stewart if (lchk == NULL) { 5393f8829a4aSRandall Stewart /* Mark end of the window */ 5394f8829a4aSRandall Stewart asoc->fast_recovery_tsn = asoc->sending_seq - 1; 5395f8829a4aSRandall Stewart } else { 5396f8829a4aSRandall Stewart asoc->fast_recovery_tsn = lchk->rec.data.TSN_seq - 1; 5397f8829a4aSRandall Stewart } 5398f8829a4aSRandall Stewart 5399f8829a4aSRandall Stewart /* 5400f8829a4aSRandall Stewart * CMT fast recovery -- per destination 5401f8829a4aSRandall Stewart * recovery variable. 5402f8829a4aSRandall Stewart */ 5403f8829a4aSRandall Stewart net->fast_retran_loss_recovery = 1; 5404f8829a4aSRandall Stewart 5405f8829a4aSRandall Stewart if (lchk == NULL) { 5406f8829a4aSRandall Stewart /* Mark end of the window */ 5407f8829a4aSRandall Stewart net->fast_recovery_tsn = asoc->sending_seq - 1; 5408f8829a4aSRandall Stewart } else { 5409f8829a4aSRandall Stewart net->fast_recovery_tsn = lchk->rec.data.TSN_seq - 1; 5410f8829a4aSRandall Stewart } 5411f8829a4aSRandall Stewart 5412f8829a4aSRandall Stewart 5413f8829a4aSRandall Stewart 5414f8829a4aSRandall Stewart /* 5415f8829a4aSRandall Stewart * Disable Nonce Sum Checking and store the 5416f8829a4aSRandall Stewart * resync tsn 5417f8829a4aSRandall Stewart */ 5418f8829a4aSRandall Stewart asoc->nonce_sum_check = 0; 5419f8829a4aSRandall Stewart asoc->nonce_resync_tsn = asoc->fast_recovery_tsn + 1; 5420f8829a4aSRandall Stewart 5421f8829a4aSRandall Stewart sctp_timer_stop(SCTP_TIMER_TYPE_SEND, 5422a5d547adSRandall Stewart stcb->sctp_ep, stcb, net, SCTP_FROM_SCTP_INDATA + SCTP_LOC_32); 5423f8829a4aSRandall Stewart sctp_timer_start(SCTP_TIMER_TYPE_SEND, 5424f8829a4aSRandall Stewart stcb->sctp_ep, stcb, net); 5425f8829a4aSRandall Stewart } 5426f8829a4aSRandall Stewart } else if (net->net_ack > 0) { 5427f8829a4aSRandall Stewart /* 5428f8829a4aSRandall Stewart * Mark a peg that we WOULD have done a cwnd 5429f8829a4aSRandall Stewart * reduction but RFC2582 prevented this action. 5430f8829a4aSRandall Stewart */ 5431f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_fastretransinrtt); 5432f8829a4aSRandall Stewart } 5433f8829a4aSRandall Stewart } 5434f8829a4aSRandall Stewart 5435f8829a4aSRandall Stewart 5436f8829a4aSRandall Stewart /****************************************************************** 5437f8829a4aSRandall Stewart * Here we do the stuff with ECN Nonce checking. 5438f8829a4aSRandall Stewart * We basically check to see if the nonce sum flag was incorrect 5439f8829a4aSRandall Stewart * or if resynchronization needs to be done. Also if we catch a 5440f8829a4aSRandall Stewart * misbehaving receiver we give him the kick. 5441f8829a4aSRandall Stewart ******************************************************************/ 5442f8829a4aSRandall Stewart 5443f8829a4aSRandall Stewart if (asoc->ecn_nonce_allowed) { 5444f8829a4aSRandall Stewart if (asoc->nonce_sum_check) { 5445f8829a4aSRandall Stewart if (nonce_sum_flag != ((asoc->nonce_sum_expect_base + ecn_seg_sums) & SCTP_SACK_NONCE_SUM)) { 5446f8829a4aSRandall Stewart if (asoc->nonce_wait_for_ecne == 0) { 5447f8829a4aSRandall Stewart struct sctp_tmit_chunk *lchk; 5448f8829a4aSRandall Stewart 5449f8829a4aSRandall Stewart lchk = TAILQ_FIRST(&asoc->send_queue); 5450f8829a4aSRandall Stewart asoc->nonce_wait_for_ecne = 1; 5451f8829a4aSRandall Stewart if (lchk) { 5452f8829a4aSRandall Stewart asoc->nonce_wait_tsn = lchk->rec.data.TSN_seq; 5453f8829a4aSRandall Stewart } else { 5454f8829a4aSRandall Stewart asoc->nonce_wait_tsn = asoc->sending_seq; 5455f8829a4aSRandall Stewart } 5456f8829a4aSRandall Stewart } else { 5457f8829a4aSRandall Stewart if (compare_with_wrap(asoc->last_acked_seq, asoc->nonce_wait_tsn, MAX_TSN) || 5458f8829a4aSRandall Stewart (asoc->last_acked_seq == asoc->nonce_wait_tsn)) { 5459f8829a4aSRandall Stewart /* 5460f8829a4aSRandall Stewart * Misbehaving peer. We need 5461f8829a4aSRandall Stewart * to react to this guy 5462f8829a4aSRandall Stewart */ 5463f8829a4aSRandall Stewart asoc->ecn_allowed = 0; 5464f8829a4aSRandall Stewart asoc->ecn_nonce_allowed = 0; 5465f8829a4aSRandall Stewart } 5466f8829a4aSRandall Stewart } 5467f8829a4aSRandall Stewart } 5468f8829a4aSRandall Stewart } else { 5469f8829a4aSRandall Stewart /* See if Resynchronization Possible */ 5470f8829a4aSRandall Stewart if (compare_with_wrap(asoc->last_acked_seq, asoc->nonce_resync_tsn, MAX_TSN)) { 5471f8829a4aSRandall Stewart asoc->nonce_sum_check = 1; 5472f8829a4aSRandall Stewart /* 5473f8829a4aSRandall Stewart * now we must calculate what the base is. 5474f8829a4aSRandall Stewart * We do this based on two things, we know 5475f8829a4aSRandall Stewart * the total's for all the segments 5476f8829a4aSRandall Stewart * gap-acked in the SACK, its stored in 5477f8829a4aSRandall Stewart * ecn_seg_sums. We also know the SACK's 5478f8829a4aSRandall Stewart * nonce sum, its in nonce_sum_flag. So we 5479f8829a4aSRandall Stewart * can build a truth table to back-calculate 5480f8829a4aSRandall Stewart * the new value of 5481f8829a4aSRandall Stewart * asoc->nonce_sum_expect_base: 5482f8829a4aSRandall Stewart * 5483f8829a4aSRandall Stewart * SACK-flag-Value Seg-Sums Base 0 0 0 5484f8829a4aSRandall Stewart * 1 0 1 0 1 1 1 5485f8829a4aSRandall Stewart * 1 0 5486f8829a4aSRandall Stewart */ 5487f8829a4aSRandall Stewart asoc->nonce_sum_expect_base = (ecn_seg_sums ^ nonce_sum_flag) & SCTP_SACK_NONCE_SUM; 5488f8829a4aSRandall Stewart } 5489f8829a4aSRandall Stewart } 5490f8829a4aSRandall Stewart } 5491f8829a4aSRandall Stewart /* Now are we exiting loss recovery ? */ 5492f8829a4aSRandall Stewart if (will_exit_fast_recovery) { 5493f8829a4aSRandall Stewart /* Ok, we must exit fast recovery */ 5494f8829a4aSRandall Stewart asoc->fast_retran_loss_recovery = 0; 5495f8829a4aSRandall Stewart } 5496f8829a4aSRandall Stewart if ((asoc->sat_t3_loss_recovery) && 5497f8829a4aSRandall Stewart ((compare_with_wrap(asoc->last_acked_seq, asoc->sat_t3_recovery_tsn, 5498f8829a4aSRandall Stewart MAX_TSN) || 5499f8829a4aSRandall Stewart (asoc->last_acked_seq == asoc->sat_t3_recovery_tsn)))) { 5500f8829a4aSRandall Stewart /* end satellite t3 loss recovery */ 5501f8829a4aSRandall Stewart asoc->sat_t3_loss_recovery = 0; 5502f8829a4aSRandall Stewart } 550342551e99SRandall Stewart /* 550442551e99SRandall Stewart * CMT Fast recovery 550542551e99SRandall Stewart */ 5506f8829a4aSRandall Stewart TAILQ_FOREACH(net, &asoc->nets, sctp_next) { 5507f8829a4aSRandall Stewart if (net->will_exit_fast_recovery) { 5508f8829a4aSRandall Stewart /* Ok, we must exit fast recovery */ 5509f8829a4aSRandall Stewart net->fast_retran_loss_recovery = 0; 5510f8829a4aSRandall Stewart } 5511f8829a4aSRandall Stewart } 5512f8829a4aSRandall Stewart 5513f8829a4aSRandall Stewart /* Adjust and set the new rwnd value */ 5514f8829a4aSRandall Stewart #ifdef SCTP_LOG_RWND 5515f8829a4aSRandall Stewart sctp_log_rwnd_set(SCTP_SET_PEER_RWND_VIA_SACK, 5516f8829a4aSRandall Stewart asoc->peers_rwnd, asoc->total_flight, (asoc->sent_queue_cnt * sctp_peer_chunk_oh), a_rwnd); 5517f8829a4aSRandall Stewart #endif 5518f8829a4aSRandall Stewart 5519f8829a4aSRandall Stewart asoc->peers_rwnd = sctp_sbspace_sub(a_rwnd, 5520f8829a4aSRandall Stewart (uint32_t) (asoc->total_flight + (asoc->sent_queue_cnt * sctp_peer_chunk_oh))); 5521f8829a4aSRandall Stewart if (asoc->peers_rwnd < stcb->sctp_ep->sctp_ep.sctp_sws_sender) { 5522f8829a4aSRandall Stewart /* SWS sender side engages */ 5523f8829a4aSRandall Stewart asoc->peers_rwnd = 0; 5524f8829a4aSRandall Stewart } 55255e54f665SRandall Stewart if (asoc->peers_rwnd > old_rwnd) { 55265e54f665SRandall Stewart win_probe_recovery = 1; 55275e54f665SRandall Stewart } 5528f8829a4aSRandall Stewart /* 5529f8829a4aSRandall Stewart * Now we must setup so we have a timer up for anyone with 5530f8829a4aSRandall Stewart * outstanding data. 5531f8829a4aSRandall Stewart */ 5532bff64a4dSRandall Stewart done_once = 0; 5533a5d547adSRandall Stewart again: 5534a5d547adSRandall Stewart j = 0; 5535f8829a4aSRandall Stewart TAILQ_FOREACH(net, &asoc->nets, sctp_next) { 55365e54f665SRandall Stewart if (win_probe_recovery && (net->window_probe)) { 55375e54f665SRandall Stewart net->window_probe = 0; 5538c105859eSRandall Stewart win_probe_recovered = 1; 55395e54f665SRandall Stewart /*- 55405e54f665SRandall Stewart * Find first chunk that was used with 55415e54f665SRandall Stewart * window probe and clear the event. Put 55425e54f665SRandall Stewart * it back into the send queue as if has 55435e54f665SRandall Stewart * not been sent. 55445e54f665SRandall Stewart */ 55455e54f665SRandall Stewart TAILQ_FOREACH(tp1, &asoc->sent_queue, sctp_next) { 55465e54f665SRandall Stewart if (tp1->window_probe) { 5547c105859eSRandall Stewart sctp_window_probe_recovery(stcb, asoc, net, tp1); 55485e54f665SRandall Stewart break; 55495e54f665SRandall Stewart } 55505e54f665SRandall Stewart } 55515e54f665SRandall Stewart } 5552f8829a4aSRandall Stewart if (net->flight_size) { 5553a5d547adSRandall Stewart j++; 5554f8829a4aSRandall Stewart sctp_timer_start(SCTP_TIMER_TYPE_SEND, 5555f8829a4aSRandall Stewart stcb->sctp_ep, stcb, net); 5556c105859eSRandall Stewart } else { 5557c105859eSRandall Stewart if (SCTP_OS_TIMER_PENDING(&net->rxt_timer.timer)) { 5558c105859eSRandall Stewart sctp_timer_stop(SCTP_TIMER_TYPE_SEND, stcb->sctp_ep, 5559c105859eSRandall Stewart stcb, net, 5560c105859eSRandall Stewart SCTP_FROM_SCTP_INDATA + SCTP_LOC_22); 5561c105859eSRandall Stewart } 5562c105859eSRandall Stewart if (sctp_early_fr) { 5563c105859eSRandall Stewart if (SCTP_OS_TIMER_PENDING(&net->fr_timer.timer)) { 5564c105859eSRandall Stewart SCTP_STAT_INCR(sctps_earlyfrstpidsck4); 5565c105859eSRandall Stewart sctp_timer_stop(SCTP_TIMER_TYPE_EARLYFR, stcb->sctp_ep, stcb, net, 5566c105859eSRandall Stewart SCTP_FROM_SCTP_INDATA + SCTP_LOC_23); 5567c105859eSRandall Stewart } 5568c105859eSRandall Stewart } 5569f8829a4aSRandall Stewart } 5570f8829a4aSRandall Stewart } 5571bff64a4dSRandall Stewart if ((j == 0) && 5572bff64a4dSRandall Stewart (!TAILQ_EMPTY(&asoc->sent_queue)) && 5573bff64a4dSRandall Stewart (asoc->sent_queue_retran_cnt == 0) && 5574c105859eSRandall Stewart (win_probe_recovered == 0) && 5575bff64a4dSRandall Stewart (done_once == 0)) { 5576a5d547adSRandall Stewart /* huh, this should not happen */ 5577c105859eSRandall Stewart sctp_fs_audit(asoc); 5578a5d547adSRandall Stewart TAILQ_FOREACH(net, &asoc->nets, sctp_next) { 5579a5d547adSRandall Stewart net->flight_size = 0; 5580a5d547adSRandall Stewart } 5581a5d547adSRandall Stewart asoc->total_flight = 0; 5582a5d547adSRandall Stewart asoc->total_flight_count = 0; 5583a5d547adSRandall Stewart asoc->sent_queue_retran_cnt = 0; 5584a5d547adSRandall Stewart TAILQ_FOREACH(tp1, &asoc->sent_queue, sctp_next) { 5585a5d547adSRandall Stewart if (tp1->sent < SCTP_DATAGRAM_RESEND) { 5586c105859eSRandall Stewart sctp_flight_size_increase(tp1); 5587c105859eSRandall Stewart sctp_total_flight_increase(stcb, tp1); 5588a5d547adSRandall Stewart } else if (tp1->sent == SCTP_DATAGRAM_RESEND) { 5589a5d547adSRandall Stewart asoc->sent_queue_retran_cnt++; 5590a5d547adSRandall Stewart } 5591a5d547adSRandall Stewart } 5592bff64a4dSRandall Stewart done_once = 1; 5593a5d547adSRandall Stewart goto again; 5594a5d547adSRandall Stewart } 5595f8829a4aSRandall Stewart #ifdef SCTP_SACK_RWND_LOGGING 5596f8829a4aSRandall Stewart sctp_misc_ints(SCTP_SACK_RWND_UPDATE, 5597f8829a4aSRandall Stewart a_rwnd, 5598f8829a4aSRandall Stewart stcb->asoc.peers_rwnd, 5599f8829a4aSRandall Stewart stcb->asoc.total_flight, 5600f8829a4aSRandall Stewart stcb->asoc.total_output_queue_size); 5601f8829a4aSRandall Stewart 5602f8829a4aSRandall Stewart #endif 5603f8829a4aSRandall Stewart 5604f8829a4aSRandall Stewart } 5605f8829a4aSRandall Stewart 5606f8829a4aSRandall Stewart void 5607f8829a4aSRandall Stewart sctp_update_acked(struct sctp_tcb *stcb, struct sctp_shutdown_chunk *cp, 5608f8829a4aSRandall Stewart struct sctp_nets *netp, int *abort_flag) 5609f8829a4aSRandall Stewart { 5610f8829a4aSRandall Stewart /* Copy cum-ack */ 5611f8829a4aSRandall Stewart uint32_t cum_ack, a_rwnd; 5612f8829a4aSRandall Stewart 5613f8829a4aSRandall Stewart cum_ack = ntohl(cp->cumulative_tsn_ack); 5614f8829a4aSRandall Stewart /* Arrange so a_rwnd does NOT change */ 5615f8829a4aSRandall Stewart a_rwnd = stcb->asoc.peers_rwnd + stcb->asoc.total_flight; 5616f8829a4aSRandall Stewart 5617f8829a4aSRandall Stewart /* Now call the express sack handling */ 5618f8829a4aSRandall Stewart sctp_express_handle_sack(stcb, cum_ack, a_rwnd, 0, abort_flag); 5619f8829a4aSRandall Stewart } 5620f8829a4aSRandall Stewart 5621f8829a4aSRandall Stewart static void 5622f8829a4aSRandall Stewart sctp_kick_prsctp_reorder_queue(struct sctp_tcb *stcb, 5623f8829a4aSRandall Stewart struct sctp_stream_in *strmin) 5624f8829a4aSRandall Stewart { 5625f8829a4aSRandall Stewart struct sctp_queued_to_read *ctl, *nctl; 5626f8829a4aSRandall Stewart struct sctp_association *asoc; 5627f8829a4aSRandall Stewart int tt; 5628f8829a4aSRandall Stewart 5629f8829a4aSRandall Stewart asoc = &stcb->asoc; 5630f8829a4aSRandall Stewart tt = strmin->last_sequence_delivered; 5631f8829a4aSRandall Stewart /* 5632f8829a4aSRandall Stewart * First deliver anything prior to and including the stream no that 5633f8829a4aSRandall Stewart * came in 5634f8829a4aSRandall Stewart */ 5635f8829a4aSRandall Stewart ctl = TAILQ_FIRST(&strmin->inqueue); 5636f8829a4aSRandall Stewart while (ctl) { 5637f8829a4aSRandall Stewart nctl = TAILQ_NEXT(ctl, next); 5638f8829a4aSRandall Stewart if (compare_with_wrap(tt, ctl->sinfo_ssn, MAX_SEQ) || 5639f8829a4aSRandall Stewart (tt == ctl->sinfo_ssn)) { 5640f8829a4aSRandall Stewart /* this is deliverable now */ 5641f8829a4aSRandall Stewart TAILQ_REMOVE(&strmin->inqueue, ctl, next); 5642f8829a4aSRandall Stewart /* subtract pending on streams */ 5643f8829a4aSRandall Stewart asoc->size_on_all_streams -= ctl->length; 5644f8829a4aSRandall Stewart sctp_ucount_decr(asoc->cnt_on_all_streams); 5645f8829a4aSRandall Stewart /* deliver it to at least the delivery-q */ 5646f8829a4aSRandall Stewart if (stcb->sctp_socket) { 5647f8829a4aSRandall Stewart sctp_add_to_readq(stcb->sctp_ep, stcb, 5648f8829a4aSRandall Stewart ctl, 5649f8829a4aSRandall Stewart &stcb->sctp_socket->so_rcv, 1); 5650f8829a4aSRandall Stewart } 5651f8829a4aSRandall Stewart } else { 5652f8829a4aSRandall Stewart /* no more delivery now. */ 5653f8829a4aSRandall Stewart break; 5654f8829a4aSRandall Stewart } 5655f8829a4aSRandall Stewart ctl = nctl; 5656f8829a4aSRandall Stewart } 5657f8829a4aSRandall Stewart /* 5658f8829a4aSRandall Stewart * now we must deliver things in queue the normal way if any are 5659f8829a4aSRandall Stewart * now ready. 5660f8829a4aSRandall Stewart */ 5661f8829a4aSRandall Stewart tt = strmin->last_sequence_delivered + 1; 5662f8829a4aSRandall Stewart ctl = TAILQ_FIRST(&strmin->inqueue); 5663f8829a4aSRandall Stewart while (ctl) { 5664f8829a4aSRandall Stewart nctl = TAILQ_NEXT(ctl, next); 5665f8829a4aSRandall Stewart if (tt == ctl->sinfo_ssn) { 5666f8829a4aSRandall Stewart /* this is deliverable now */ 5667f8829a4aSRandall Stewart TAILQ_REMOVE(&strmin->inqueue, ctl, next); 5668f8829a4aSRandall Stewart /* subtract pending on streams */ 5669f8829a4aSRandall Stewart asoc->size_on_all_streams -= ctl->length; 5670f8829a4aSRandall Stewart sctp_ucount_decr(asoc->cnt_on_all_streams); 5671f8829a4aSRandall Stewart /* deliver it to at least the delivery-q */ 5672f8829a4aSRandall Stewart strmin->last_sequence_delivered = ctl->sinfo_ssn; 5673f8829a4aSRandall Stewart if (stcb->sctp_socket) { 5674f8829a4aSRandall Stewart sctp_add_to_readq(stcb->sctp_ep, stcb, 5675f8829a4aSRandall Stewart ctl, 5676f8829a4aSRandall Stewart &stcb->sctp_socket->so_rcv, 1); 5677f8829a4aSRandall Stewart } 5678f8829a4aSRandall Stewart tt = strmin->last_sequence_delivered + 1; 5679f8829a4aSRandall Stewart } else { 5680f8829a4aSRandall Stewart break; 5681f8829a4aSRandall Stewart } 5682f8829a4aSRandall Stewart ctl = nctl; 5683f8829a4aSRandall Stewart } 5684f8829a4aSRandall Stewart } 5685f8829a4aSRandall Stewart 5686f8829a4aSRandall Stewart void 5687f8829a4aSRandall Stewart sctp_handle_forward_tsn(struct sctp_tcb *stcb, 5688f8829a4aSRandall Stewart struct sctp_forward_tsn_chunk *fwd, int *abort_flag) 5689f8829a4aSRandall Stewart { 5690f8829a4aSRandall Stewart /* 5691f8829a4aSRandall Stewart * ISSUES that MUST be fixed for ECN! When we are the sender of the 5692f8829a4aSRandall Stewart * forward TSN, when the SACK comes back that acknowledges the 5693f8829a4aSRandall Stewart * FWD-TSN we must reset the NONCE sum to match correctly. This will 5694f8829a4aSRandall Stewart * get quite tricky since we may have sent more data interveneing 5695f8829a4aSRandall Stewart * and must carefully account for what the SACK says on the nonce 5696f8829a4aSRandall Stewart * and any gaps that are reported. This work will NOT be done here, 5697f8829a4aSRandall Stewart * but I note it here since it is really related to PR-SCTP and 5698f8829a4aSRandall Stewart * FWD-TSN's 5699f8829a4aSRandall Stewart */ 5700f8829a4aSRandall Stewart 5701f8829a4aSRandall Stewart /* The pr-sctp fwd tsn */ 5702f8829a4aSRandall Stewart /* 5703f8829a4aSRandall Stewart * here we will perform all the data receiver side steps for 5704f8829a4aSRandall Stewart * processing FwdTSN, as required in by pr-sctp draft: 5705f8829a4aSRandall Stewart * 5706f8829a4aSRandall Stewart * Assume we get FwdTSN(x): 5707f8829a4aSRandall Stewart * 5708f8829a4aSRandall Stewart * 1) update local cumTSN to x 2) try to further advance cumTSN to x + 5709f8829a4aSRandall Stewart * others we have 3) examine and update re-ordering queue on 5710f8829a4aSRandall Stewart * pr-in-streams 4) clean up re-assembly queue 5) Send a sack to 5711f8829a4aSRandall Stewart * report where we are. 5712f8829a4aSRandall Stewart */ 5713f8829a4aSRandall Stewart struct sctp_strseq *stseq; 5714f8829a4aSRandall Stewart struct sctp_association *asoc; 5715f8829a4aSRandall Stewart uint32_t new_cum_tsn, gap, back_out_htsn; 5716f8829a4aSRandall Stewart unsigned int i, cnt_gone, fwd_sz, cumack_set_flag, m_size; 5717f8829a4aSRandall Stewart struct sctp_stream_in *strm; 5718f8829a4aSRandall Stewart struct sctp_tmit_chunk *chk, *at; 5719f8829a4aSRandall Stewart 5720f8829a4aSRandall Stewart cumack_set_flag = 0; 5721f8829a4aSRandall Stewart asoc = &stcb->asoc; 5722f8829a4aSRandall Stewart cnt_gone = 0; 5723f8829a4aSRandall Stewart if ((fwd_sz = ntohs(fwd->ch.chunk_length)) < sizeof(struct sctp_forward_tsn_chunk)) { 5724f8829a4aSRandall Stewart #ifdef SCTP_DEBUG 5725f8829a4aSRandall Stewart if (sctp_debug_on & SCTP_DEBUG_INDATA1) { 5726f8829a4aSRandall Stewart printf("Bad size too small/big fwd-tsn\n"); 5727f8829a4aSRandall Stewart } 5728f8829a4aSRandall Stewart #endif 5729f8829a4aSRandall Stewart return; 5730f8829a4aSRandall Stewart } 5731f8829a4aSRandall Stewart m_size = (stcb->asoc.mapping_array_size << 3); 5732f8829a4aSRandall Stewart /*************************************************************/ 5733f8829a4aSRandall Stewart /* 1. Here we update local cumTSN and shift the bitmap array */ 5734f8829a4aSRandall Stewart /*************************************************************/ 5735f8829a4aSRandall Stewart new_cum_tsn = ntohl(fwd->new_cumulative_tsn); 5736f8829a4aSRandall Stewart 5737f8829a4aSRandall Stewart if (compare_with_wrap(asoc->cumulative_tsn, new_cum_tsn, MAX_TSN) || 5738f8829a4aSRandall Stewart asoc->cumulative_tsn == new_cum_tsn) { 5739f8829a4aSRandall Stewart /* Already got there ... */ 5740f8829a4aSRandall Stewart return; 5741f8829a4aSRandall Stewart } 5742f8829a4aSRandall Stewart back_out_htsn = asoc->highest_tsn_inside_map; 5743f8829a4aSRandall Stewart if (compare_with_wrap(new_cum_tsn, asoc->highest_tsn_inside_map, 5744f8829a4aSRandall Stewart MAX_TSN)) { 5745f8829a4aSRandall Stewart asoc->highest_tsn_inside_map = new_cum_tsn; 5746f8829a4aSRandall Stewart #ifdef SCTP_MAP_LOGGING 5747f8829a4aSRandall Stewart sctp_log_map(0, 0, asoc->highest_tsn_inside_map, SCTP_MAP_SLIDE_RESULT); 5748f8829a4aSRandall Stewart #endif 5749f8829a4aSRandall Stewart } 5750f8829a4aSRandall Stewart /* 5751f8829a4aSRandall Stewart * now we know the new TSN is more advanced, let's find the actual 5752f8829a4aSRandall Stewart * gap 5753f8829a4aSRandall Stewart */ 5754f8829a4aSRandall Stewart if ((compare_with_wrap(new_cum_tsn, asoc->mapping_array_base_tsn, 5755f8829a4aSRandall Stewart MAX_TSN)) || 5756f8829a4aSRandall Stewart (new_cum_tsn == asoc->mapping_array_base_tsn)) { 5757f8829a4aSRandall Stewart gap = new_cum_tsn - asoc->mapping_array_base_tsn; 5758f8829a4aSRandall Stewart } else { 5759f8829a4aSRandall Stewart /* try to prevent underflow here */ 5760f8829a4aSRandall Stewart gap = new_cum_tsn + (MAX_TSN - asoc->mapping_array_base_tsn) + 1; 5761f8829a4aSRandall Stewart } 5762f8829a4aSRandall Stewart 576317205eccSRandall Stewart if (gap > m_size) { 5764f8829a4aSRandall Stewart asoc->highest_tsn_inside_map = back_out_htsn; 5765f8829a4aSRandall Stewart if ((long)gap > sctp_sbspace(&stcb->asoc, &stcb->sctp_socket->so_rcv)) { 576617205eccSRandall Stewart struct mbuf *oper; 576717205eccSRandall Stewart 5768f8829a4aSRandall Stewart /* 5769f8829a4aSRandall Stewart * out of range (of single byte chunks in the rwnd I 577017205eccSRandall Stewart * give out). This must be an attacker. 5771f8829a4aSRandall Stewart */ 577217205eccSRandall Stewart *abort_flag = 1; 577317205eccSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + 3 * sizeof(uint32_t)), 577417205eccSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 577517205eccSRandall Stewart if (oper) { 577617205eccSRandall Stewart struct sctp_paramhdr *ph; 577717205eccSRandall Stewart uint32_t *ippp; 577817205eccSRandall Stewart 577917205eccSRandall Stewart SCTP_BUF_LEN(oper) = sizeof(struct sctp_paramhdr) + 578017205eccSRandall Stewart (sizeof(uint32_t) * 3); 578117205eccSRandall Stewart ph = mtod(oper, struct sctp_paramhdr *); 578217205eccSRandall Stewart ph->param_type = htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 578317205eccSRandall Stewart ph->param_length = htons(SCTP_BUF_LEN(oper)); 578417205eccSRandall Stewart ippp = (uint32_t *) (ph + 1); 578517205eccSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_33); 578617205eccSRandall Stewart ippp++; 578717205eccSRandall Stewart *ippp = asoc->highest_tsn_inside_map; 578817205eccSRandall Stewart ippp++; 578917205eccSRandall Stewart *ippp = new_cum_tsn; 579017205eccSRandall Stewart } 579117205eccSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_33; 579217205eccSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, stcb, 579317205eccSRandall Stewart SCTP_PEER_FAULTY, oper); 5794f8829a4aSRandall Stewart return; 5795f8829a4aSRandall Stewart } 5796f8829a4aSRandall Stewart if (asoc->highest_tsn_inside_map > 5797f8829a4aSRandall Stewart asoc->mapping_array_base_tsn) { 5798f8829a4aSRandall Stewart gap = asoc->highest_tsn_inside_map - 5799f8829a4aSRandall Stewart asoc->mapping_array_base_tsn; 5800f8829a4aSRandall Stewart } else { 5801f8829a4aSRandall Stewart gap = asoc->highest_tsn_inside_map + 5802f8829a4aSRandall Stewart (MAX_TSN - asoc->mapping_array_base_tsn) + 1; 5803f8829a4aSRandall Stewart } 5804f8829a4aSRandall Stewart cumack_set_flag = 1; 5805f8829a4aSRandall Stewart } 5806f8829a4aSRandall Stewart for (i = 0; i <= gap; i++) { 5807f8829a4aSRandall Stewart SCTP_SET_TSN_PRESENT(asoc->mapping_array, i); 5808f8829a4aSRandall Stewart } 5809f8829a4aSRandall Stewart /* 5810f8829a4aSRandall Stewart * Now after marking all, slide thing forward but no sack please. 5811f8829a4aSRandall Stewart */ 5812f8829a4aSRandall Stewart sctp_sack_check(stcb, 0, 0, abort_flag); 5813f8829a4aSRandall Stewart if (*abort_flag) 5814f8829a4aSRandall Stewart return; 5815f8829a4aSRandall Stewart 5816f8829a4aSRandall Stewart if (cumack_set_flag) { 5817f8829a4aSRandall Stewart /* 5818f8829a4aSRandall Stewart * fwd-tsn went outside my gap array - not a common 5819f8829a4aSRandall Stewart * occurance. Do the same thing we do when a cookie-echo 5820f8829a4aSRandall Stewart * arrives. 5821f8829a4aSRandall Stewart */ 5822f8829a4aSRandall Stewart asoc->highest_tsn_inside_map = new_cum_tsn - 1; 5823f8829a4aSRandall Stewart asoc->mapping_array_base_tsn = new_cum_tsn; 5824f8829a4aSRandall Stewart asoc->cumulative_tsn = asoc->highest_tsn_inside_map; 5825f8829a4aSRandall Stewart #ifdef SCTP_MAP_LOGGING 5826f8829a4aSRandall Stewart sctp_log_map(0, 3, asoc->highest_tsn_inside_map, SCTP_MAP_SLIDE_RESULT); 5827f8829a4aSRandall Stewart #endif 5828f8829a4aSRandall Stewart asoc->last_echo_tsn = asoc->highest_tsn_inside_map; 5829f8829a4aSRandall Stewart } 5830f8829a4aSRandall Stewart /*************************************************************/ 5831f8829a4aSRandall Stewart /* 2. Clear up re-assembly queue */ 5832f8829a4aSRandall Stewart /*************************************************************/ 5833f8829a4aSRandall Stewart 5834f8829a4aSRandall Stewart /* 5835f8829a4aSRandall Stewart * First service it if pd-api is up, just in case we can progress it 5836f8829a4aSRandall Stewart * forward 5837f8829a4aSRandall Stewart */ 5838f8829a4aSRandall Stewart if (asoc->fragmented_delivery_inprogress) { 5839f8829a4aSRandall Stewart sctp_service_reassembly(stcb, asoc); 5840f8829a4aSRandall Stewart } 5841f8829a4aSRandall Stewart if (!TAILQ_EMPTY(&asoc->reasmqueue)) { 5842f8829a4aSRandall Stewart /* For each one on here see if we need to toss it */ 5843f8829a4aSRandall Stewart /* 5844f8829a4aSRandall Stewart * For now large messages held on the reasmqueue that are 5845f8829a4aSRandall Stewart * complete will be tossed too. We could in theory do more 5846f8829a4aSRandall Stewart * work to spin through and stop after dumping one msg aka 5847f8829a4aSRandall Stewart * seeing the start of a new msg at the head, and call the 5848f8829a4aSRandall Stewart * delivery function... to see if it can be delivered... But 5849f8829a4aSRandall Stewart * for now we just dump everything on the queue. 5850f8829a4aSRandall Stewart */ 5851f8829a4aSRandall Stewart chk = TAILQ_FIRST(&asoc->reasmqueue); 5852f8829a4aSRandall Stewart while (chk) { 5853f8829a4aSRandall Stewart at = TAILQ_NEXT(chk, sctp_next); 5854f8829a4aSRandall Stewart if (compare_with_wrap(asoc->cumulative_tsn, 5855f8829a4aSRandall Stewart chk->rec.data.TSN_seq, MAX_TSN) || 5856f8829a4aSRandall Stewart asoc->cumulative_tsn == chk->rec.data.TSN_seq) { 5857f8829a4aSRandall Stewart /* It needs to be tossed */ 5858f8829a4aSRandall Stewart TAILQ_REMOVE(&asoc->reasmqueue, chk, sctp_next); 5859f8829a4aSRandall Stewart if (compare_with_wrap(chk->rec.data.TSN_seq, 5860f8829a4aSRandall Stewart asoc->tsn_last_delivered, MAX_TSN)) { 5861f8829a4aSRandall Stewart asoc->tsn_last_delivered = 5862f8829a4aSRandall Stewart chk->rec.data.TSN_seq; 5863f8829a4aSRandall Stewart asoc->str_of_pdapi = 5864f8829a4aSRandall Stewart chk->rec.data.stream_number; 5865f8829a4aSRandall Stewart asoc->ssn_of_pdapi = 5866f8829a4aSRandall Stewart chk->rec.data.stream_seq; 5867f8829a4aSRandall Stewart asoc->fragment_flags = 5868f8829a4aSRandall Stewart chk->rec.data.rcv_flags; 5869f8829a4aSRandall Stewart } 5870f8829a4aSRandall Stewart asoc->size_on_reasm_queue -= chk->send_size; 5871f8829a4aSRandall Stewart sctp_ucount_decr(asoc->cnt_on_reasm_queue); 5872f8829a4aSRandall Stewart cnt_gone++; 5873f8829a4aSRandall Stewart 5874f8829a4aSRandall Stewart /* Clear up any stream problem */ 5875f8829a4aSRandall Stewart if ((chk->rec.data.rcv_flags & SCTP_DATA_UNORDERED) != 5876f8829a4aSRandall Stewart SCTP_DATA_UNORDERED && 5877f8829a4aSRandall Stewart (compare_with_wrap(chk->rec.data.stream_seq, 5878f8829a4aSRandall Stewart asoc->strmin[chk->rec.data.stream_number].last_sequence_delivered, 5879f8829a4aSRandall Stewart MAX_SEQ))) { 5880f8829a4aSRandall Stewart /* 5881f8829a4aSRandall Stewart * We must dump forward this streams 5882f8829a4aSRandall Stewart * sequence number if the chunk is 5883f8829a4aSRandall Stewart * not unordered that is being 5884f8829a4aSRandall Stewart * skipped. There is a chance that 5885f8829a4aSRandall Stewart * if the peer does not include the 5886f8829a4aSRandall Stewart * last fragment in its FWD-TSN we 5887f8829a4aSRandall Stewart * WILL have a problem here since 5888f8829a4aSRandall Stewart * you would have a partial chunk in 5889f8829a4aSRandall Stewart * queue that may not be 5890f8829a4aSRandall Stewart * deliverable. Also if a Partial 5891f8829a4aSRandall Stewart * delivery API as started the user 5892f8829a4aSRandall Stewart * may get a partial chunk. The next 5893f8829a4aSRandall Stewart * read returning a new chunk... 5894f8829a4aSRandall Stewart * really ugly but I see no way 5895f8829a4aSRandall Stewart * around it! Maybe a notify?? 5896f8829a4aSRandall Stewart */ 5897f8829a4aSRandall Stewart asoc->strmin[chk->rec.data.stream_number].last_sequence_delivered = 5898f8829a4aSRandall Stewart chk->rec.data.stream_seq; 5899f8829a4aSRandall Stewart } 5900f8829a4aSRandall Stewart if (chk->data) { 5901f8829a4aSRandall Stewart sctp_m_freem(chk->data); 5902f8829a4aSRandall Stewart chk->data = NULL; 5903f8829a4aSRandall Stewart } 5904f8829a4aSRandall Stewart sctp_free_remote_addr(chk->whoTo); 5905f8829a4aSRandall Stewart sctp_free_a_chunk(stcb, chk); 5906f8829a4aSRandall Stewart } else { 5907f8829a4aSRandall Stewart /* 5908f8829a4aSRandall Stewart * Ok we have gone beyond the end of the 5909f8829a4aSRandall Stewart * fwd-tsn's mark. Some checks... 5910f8829a4aSRandall Stewart */ 5911f8829a4aSRandall Stewart if ((asoc->fragmented_delivery_inprogress) && 5912f8829a4aSRandall Stewart (chk->rec.data.rcv_flags & SCTP_DATA_FIRST_FRAG)) { 59139a6142d8SRandall Stewart uint32_t str_seq; 59149a6142d8SRandall Stewart 5915f8829a4aSRandall Stewart /* 5916f8829a4aSRandall Stewart * Special case PD-API is up and 5917f8829a4aSRandall Stewart * what we fwd-tsn' over includes 5918f8829a4aSRandall Stewart * one that had the LAST_FRAG. We no 5919f8829a4aSRandall Stewart * longer need to do the PD-API. 5920f8829a4aSRandall Stewart */ 5921f8829a4aSRandall Stewart asoc->fragmented_delivery_inprogress = 0; 59229a6142d8SRandall Stewart 59239a6142d8SRandall Stewart str_seq = (asoc->str_of_pdapi << 16) | asoc->ssn_of_pdapi; 5924f8829a4aSRandall Stewart sctp_ulp_notify(SCTP_NOTIFY_PARTIAL_DELVIERY_INDICATION, 59259a6142d8SRandall Stewart stcb, SCTP_PARTIAL_DELIVERY_ABORTED, (void *)&str_seq); 5926f8829a4aSRandall Stewart 5927f8829a4aSRandall Stewart } 5928f8829a4aSRandall Stewart break; 5929f8829a4aSRandall Stewart } 5930f8829a4aSRandall Stewart chk = at; 5931f8829a4aSRandall Stewart } 5932f8829a4aSRandall Stewart } 5933f8829a4aSRandall Stewart if (asoc->fragmented_delivery_inprogress) { 5934f8829a4aSRandall Stewart /* 5935f8829a4aSRandall Stewart * Ok we removed cnt_gone chunks in the PD-API queue that 5936f8829a4aSRandall Stewart * were being delivered. So now we must turn off the flag. 5937f8829a4aSRandall Stewart */ 59389a6142d8SRandall Stewart uint32_t str_seq; 59399a6142d8SRandall Stewart 59409a6142d8SRandall Stewart str_seq = (asoc->str_of_pdapi << 16) | asoc->ssn_of_pdapi; 5941f8829a4aSRandall Stewart sctp_ulp_notify(SCTP_NOTIFY_PARTIAL_DELVIERY_INDICATION, 59429a6142d8SRandall Stewart stcb, SCTP_PARTIAL_DELIVERY_ABORTED, (void *)&str_seq); 5943f8829a4aSRandall Stewart asoc->fragmented_delivery_inprogress = 0; 5944f8829a4aSRandall Stewart } 5945f8829a4aSRandall Stewart /*************************************************************/ 5946f8829a4aSRandall Stewart /* 3. Update the PR-stream re-ordering queues */ 5947f8829a4aSRandall Stewart /*************************************************************/ 5948f8829a4aSRandall Stewart stseq = (struct sctp_strseq *)((caddr_t)fwd + sizeof(*fwd)); 5949f8829a4aSRandall Stewart fwd_sz -= sizeof(*fwd); 5950f8829a4aSRandall Stewart { 5951f8829a4aSRandall Stewart /* New method. */ 5952f8829a4aSRandall Stewart int num_str, i; 5953f8829a4aSRandall Stewart 5954f8829a4aSRandall Stewart num_str = fwd_sz / sizeof(struct sctp_strseq); 5955f8829a4aSRandall Stewart for (i = 0; i < num_str; i++) { 5956f8829a4aSRandall Stewart uint16_t st; 5957f8829a4aSRandall Stewart unsigned char *xx; 5958f8829a4aSRandall Stewart 5959f8829a4aSRandall Stewart /* Convert */ 5960f8829a4aSRandall Stewart xx = (unsigned char *)&stseq[i]; 5961f8829a4aSRandall Stewart st = ntohs(stseq[i].stream); 5962f8829a4aSRandall Stewart stseq[i].stream = st; 5963f8829a4aSRandall Stewart st = ntohs(stseq[i].sequence); 5964f8829a4aSRandall Stewart stseq[i].sequence = st; 5965f8829a4aSRandall Stewart /* now process */ 5966f8829a4aSRandall Stewart if (stseq[i].stream > asoc->streamincnt) { 5967f8829a4aSRandall Stewart /* 5968f8829a4aSRandall Stewart * It is arguable if we should continue. 5969f8829a4aSRandall Stewart * Since the peer sent bogus stream info we 5970f8829a4aSRandall Stewart * may be in deep trouble.. a return may be 5971f8829a4aSRandall Stewart * a better choice? 5972f8829a4aSRandall Stewart */ 5973f8829a4aSRandall Stewart continue; 5974f8829a4aSRandall Stewart } 5975f8829a4aSRandall Stewart strm = &asoc->strmin[stseq[i].stream]; 5976f8829a4aSRandall Stewart if (compare_with_wrap(stseq[i].sequence, 5977f8829a4aSRandall Stewart strm->last_sequence_delivered, MAX_SEQ)) { 5978f8829a4aSRandall Stewart /* Update the sequence number */ 5979f8829a4aSRandall Stewart strm->last_sequence_delivered = 5980f8829a4aSRandall Stewart stseq[i].sequence; 5981f8829a4aSRandall Stewart } 5982f8829a4aSRandall Stewart /* now kick the stream the new way */ 5983f8829a4aSRandall Stewart sctp_kick_prsctp_reorder_queue(stcb, strm); 5984f8829a4aSRandall Stewart } 5985f8829a4aSRandall Stewart } 5986139bc87fSRandall Stewart if (TAILQ_FIRST(&asoc->reasmqueue)) { 5987139bc87fSRandall Stewart /* now lets kick out and check for more fragmented delivery */ 5988139bc87fSRandall Stewart sctp_deliver_reasm_check(stcb, &stcb->asoc); 5989139bc87fSRandall Stewart } 5990f8829a4aSRandall Stewart } 5991