1f8829a4aSRandall Stewart /*- 2b1006367SRandall Stewart * Copyright (c) 2001-2007, by Cisco Systems, Inc. All rights reserved. 3f8829a4aSRandall Stewart * 4f8829a4aSRandall Stewart * Redistribution and use in source and binary forms, with or without 5f8829a4aSRandall Stewart * modification, are permitted provided that the following conditions are met: 6f8829a4aSRandall Stewart * 7f8829a4aSRandall Stewart * a) Redistributions of source code must retain the above copyright notice, 8f8829a4aSRandall Stewart * this list of conditions and the following disclaimer. 9f8829a4aSRandall Stewart * 10f8829a4aSRandall Stewart * b) Redistributions in binary form must reproduce the above copyright 11f8829a4aSRandall Stewart * notice, this list of conditions and the following disclaimer in 12f8829a4aSRandall Stewart * the documentation and/or other materials provided with the distribution. 13f8829a4aSRandall Stewart * 14f8829a4aSRandall Stewart * c) Neither the name of Cisco Systems, Inc. nor the names of its 15f8829a4aSRandall Stewart * contributors may be used to endorse or promote products derived 16f8829a4aSRandall Stewart * from this software without specific prior written permission. 17f8829a4aSRandall Stewart * 18f8829a4aSRandall Stewart * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19f8829a4aSRandall Stewart * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 20f8829a4aSRandall Stewart * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21f8829a4aSRandall Stewart * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 22f8829a4aSRandall Stewart * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 23f8829a4aSRandall Stewart * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 24f8829a4aSRandall Stewart * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 25f8829a4aSRandall Stewart * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 26f8829a4aSRandall Stewart * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 27f8829a4aSRandall Stewart * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 28f8829a4aSRandall Stewart * THE POSSIBILITY OF SUCH DAMAGE. 29f8829a4aSRandall Stewart */ 30f8829a4aSRandall Stewart 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 48d50c1d79SRandall 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 5972fb6fdbSRandall Stewart void 60f8829a4aSRandall Stewart sctp_set_rwnd(struct sctp_tcb *stcb, struct sctp_association *asoc) 61f8829a4aSRandall Stewart { 62b3f1ea41SRandall Stewart asoc->my_rwnd = sctp_calc_rwnd(stcb, asoc); 63f8829a4aSRandall Stewart } 64f8829a4aSRandall Stewart 65f8829a4aSRandall Stewart /* Calculate what the rwnd would be */ 6672fb6fdbSRandall Stewart uint32_t 67f8829a4aSRandall Stewart sctp_calc_rwnd(struct sctp_tcb *stcb, struct sctp_association *asoc) 68f8829a4aSRandall Stewart { 69b3f1ea41SRandall Stewart uint32_t calc = 0; 70f8829a4aSRandall Stewart 71f8829a4aSRandall Stewart /* 72f8829a4aSRandall Stewart * This is really set wrong with respect to a 1-2-m socket. Since 73f8829a4aSRandall Stewart * the sb_cc is the count that everyone as put up. When we re-write 74f8829a4aSRandall Stewart * sctp_soreceive then we will fix this so that ONLY this 75f8829a4aSRandall Stewart * associations data is taken into account. 76f8829a4aSRandall Stewart */ 77f8829a4aSRandall Stewart if (stcb->sctp_socket == NULL) 78f8829a4aSRandall Stewart return (calc); 79f8829a4aSRandall Stewart 80f8829a4aSRandall Stewart if (stcb->asoc.sb_cc == 0 && 81f8829a4aSRandall Stewart asoc->size_on_reasm_queue == 0 && 82f8829a4aSRandall Stewart asoc->size_on_all_streams == 0) { 83f8829a4aSRandall Stewart /* Full rwnd granted */ 84b3f1ea41SRandall Stewart calc = max(SCTP_SB_LIMIT_RCV(stcb->sctp_socket), SCTP_MINIMAL_RWND); 85f8829a4aSRandall Stewart return (calc); 86f8829a4aSRandall Stewart } 87f8829a4aSRandall Stewart /* get actual space */ 88f8829a4aSRandall Stewart calc = (uint32_t) sctp_sbspace(&stcb->asoc, &stcb->sctp_socket->so_rcv); 89f8829a4aSRandall Stewart 90f8829a4aSRandall Stewart /* 91f8829a4aSRandall Stewart * take out what has NOT been put on socket queue and we yet hold 92f8829a4aSRandall Stewart * for putting up. 93f8829a4aSRandall Stewart */ 9444fbe462SRandall Stewart calc = sctp_sbspace_sub(calc, (uint32_t) (asoc->size_on_reasm_queue + 9544fbe462SRandall Stewart asoc->cnt_on_reasm_queue * MSIZE)); 9644fbe462SRandall Stewart calc = sctp_sbspace_sub(calc, (uint32_t) (asoc->size_on_all_streams + 9744fbe462SRandall Stewart asoc->cnt_on_all_streams * MSIZE)); 98f8829a4aSRandall Stewart 99f8829a4aSRandall Stewart if (calc == 0) { 100f8829a4aSRandall Stewart /* out of space */ 101f8829a4aSRandall Stewart return (calc); 102f8829a4aSRandall Stewart } 103f8829a4aSRandall Stewart /* what is the overhead of all these rwnd's */ 1042afb3e84SRandall Stewart calc = sctp_sbspace_sub(calc, stcb->asoc.my_rwnd_control_len); 105b3f1ea41SRandall Stewart /* 106b3f1ea41SRandall Stewart * If the window gets too small due to ctrl-stuff, reduce it to 1, 107b3f1ea41SRandall Stewart * even it is 0. SWS engaged 108f8829a4aSRandall Stewart */ 109b3f1ea41SRandall Stewart if (calc < stcb->asoc.my_rwnd_control_len) { 110b3f1ea41SRandall Stewart calc = 1; 1112afb3e84SRandall Stewart } 112b3f1ea41SRandall Stewart return (calc); 113f8829a4aSRandall Stewart } 114f8829a4aSRandall Stewart 115f8829a4aSRandall Stewart 116f8829a4aSRandall Stewart 117f8829a4aSRandall Stewart /* 118f8829a4aSRandall Stewart * Build out our readq entry based on the incoming packet. 119f8829a4aSRandall Stewart */ 120f8829a4aSRandall Stewart struct sctp_queued_to_read * 121f8829a4aSRandall Stewart sctp_build_readq_entry(struct sctp_tcb *stcb, 122f8829a4aSRandall Stewart struct sctp_nets *net, 123f8829a4aSRandall Stewart uint32_t tsn, uint32_t ppid, 124f8829a4aSRandall Stewart uint32_t context, uint16_t stream_no, 125f8829a4aSRandall Stewart uint16_t stream_seq, uint8_t flags, 126f8829a4aSRandall Stewart struct mbuf *dm) 127f8829a4aSRandall Stewart { 128f8829a4aSRandall Stewart struct sctp_queued_to_read *read_queue_e = NULL; 129f8829a4aSRandall Stewart 130f8829a4aSRandall Stewart sctp_alloc_a_readq(stcb, read_queue_e); 131f8829a4aSRandall Stewart if (read_queue_e == NULL) { 132f8829a4aSRandall Stewart goto failed_build; 133f8829a4aSRandall Stewart } 134f8829a4aSRandall Stewart read_queue_e->sinfo_stream = stream_no; 135f8829a4aSRandall Stewart read_queue_e->sinfo_ssn = stream_seq; 136f8829a4aSRandall Stewart read_queue_e->sinfo_flags = (flags << 8); 137f8829a4aSRandall Stewart read_queue_e->sinfo_ppid = ppid; 138f8829a4aSRandall Stewart read_queue_e->sinfo_context = stcb->asoc.context; 139f8829a4aSRandall Stewart read_queue_e->sinfo_timetolive = 0; 140f8829a4aSRandall Stewart read_queue_e->sinfo_tsn = tsn; 141f8829a4aSRandall Stewart read_queue_e->sinfo_cumtsn = tsn; 142f8829a4aSRandall Stewart read_queue_e->sinfo_assoc_id = sctp_get_associd(stcb); 143f8829a4aSRandall Stewart read_queue_e->whoFrom = net; 144f8829a4aSRandall Stewart read_queue_e->length = 0; 145f8829a4aSRandall Stewart atomic_add_int(&net->ref_count, 1); 146f8829a4aSRandall Stewart read_queue_e->data = dm; 147139bc87fSRandall Stewart read_queue_e->spec_flags = 0; 148f8829a4aSRandall Stewart read_queue_e->tail_mbuf = NULL; 14917205eccSRandall Stewart read_queue_e->aux_data = NULL; 150f8829a4aSRandall Stewart read_queue_e->stcb = stcb; 151f8829a4aSRandall Stewart read_queue_e->port_from = stcb->rport; 152f8829a4aSRandall Stewart read_queue_e->do_not_ref_stcb = 0; 153f8829a4aSRandall Stewart read_queue_e->end_added = 0; 1549a6142d8SRandall Stewart read_queue_e->some_taken = 0; 15503b0b021SRandall Stewart read_queue_e->pdapi_aborted = 0; 156f8829a4aSRandall Stewart failed_build: 157f8829a4aSRandall Stewart return (read_queue_e); 158f8829a4aSRandall Stewart } 159f8829a4aSRandall Stewart 160f8829a4aSRandall Stewart 161f8829a4aSRandall Stewart /* 162f8829a4aSRandall Stewart * Build out our readq entry based on the incoming packet. 163f8829a4aSRandall Stewart */ 164f8829a4aSRandall Stewart static struct sctp_queued_to_read * 165f8829a4aSRandall Stewart sctp_build_readq_entry_chk(struct sctp_tcb *stcb, 166f8829a4aSRandall Stewart struct sctp_tmit_chunk *chk) 167f8829a4aSRandall Stewart { 168f8829a4aSRandall Stewart struct sctp_queued_to_read *read_queue_e = NULL; 169f8829a4aSRandall Stewart 170f8829a4aSRandall Stewart sctp_alloc_a_readq(stcb, read_queue_e); 171f8829a4aSRandall Stewart if (read_queue_e == NULL) { 172f8829a4aSRandall Stewart goto failed_build; 173f8829a4aSRandall Stewart } 174f8829a4aSRandall Stewart read_queue_e->sinfo_stream = chk->rec.data.stream_number; 175f8829a4aSRandall Stewart read_queue_e->sinfo_ssn = chk->rec.data.stream_seq; 176f8829a4aSRandall Stewart read_queue_e->sinfo_flags = (chk->rec.data.rcv_flags << 8); 177f8829a4aSRandall Stewart read_queue_e->sinfo_ppid = chk->rec.data.payloadtype; 178f8829a4aSRandall Stewart read_queue_e->sinfo_context = stcb->asoc.context; 179f8829a4aSRandall Stewart read_queue_e->sinfo_timetolive = 0; 180f8829a4aSRandall Stewart read_queue_e->sinfo_tsn = chk->rec.data.TSN_seq; 181f8829a4aSRandall Stewart read_queue_e->sinfo_cumtsn = chk->rec.data.TSN_seq; 182f8829a4aSRandall Stewart read_queue_e->sinfo_assoc_id = sctp_get_associd(stcb); 183f8829a4aSRandall Stewart read_queue_e->whoFrom = chk->whoTo; 18417205eccSRandall Stewart read_queue_e->aux_data = NULL; 185f8829a4aSRandall Stewart read_queue_e->length = 0; 186f8829a4aSRandall Stewart atomic_add_int(&chk->whoTo->ref_count, 1); 187f8829a4aSRandall Stewart read_queue_e->data = chk->data; 188f8829a4aSRandall Stewart read_queue_e->tail_mbuf = NULL; 189f8829a4aSRandall Stewart read_queue_e->stcb = stcb; 190f8829a4aSRandall Stewart read_queue_e->port_from = stcb->rport; 191139bc87fSRandall Stewart read_queue_e->spec_flags = 0; 192f8829a4aSRandall Stewart read_queue_e->do_not_ref_stcb = 0; 193f8829a4aSRandall Stewart read_queue_e->end_added = 0; 1949a6142d8SRandall Stewart read_queue_e->some_taken = 0; 19503b0b021SRandall Stewart read_queue_e->pdapi_aborted = 0; 196f8829a4aSRandall Stewart failed_build: 197f8829a4aSRandall Stewart return (read_queue_e); 198f8829a4aSRandall Stewart } 199f8829a4aSRandall Stewart 200f8829a4aSRandall Stewart 201f8829a4aSRandall Stewart struct mbuf * 202f8829a4aSRandall Stewart sctp_build_ctl_nchunk(struct sctp_inpcb *inp, 203f8829a4aSRandall Stewart struct sctp_sndrcvinfo *sinfo) 204f8829a4aSRandall Stewart { 205f8829a4aSRandall Stewart struct sctp_sndrcvinfo *outinfo; 206f8829a4aSRandall Stewart struct cmsghdr *cmh; 207f8829a4aSRandall Stewart struct mbuf *ret; 208f8829a4aSRandall Stewart int len; 209f8829a4aSRandall Stewart int use_extended = 0; 210f8829a4aSRandall Stewart 211f8829a4aSRandall Stewart if (sctp_is_feature_off(inp, SCTP_PCB_FLAGS_RECVDATAIOEVNT)) { 212f8829a4aSRandall Stewart /* user does not want the sndrcv ctl */ 213f8829a4aSRandall Stewart return (NULL); 214f8829a4aSRandall Stewart } 215f8829a4aSRandall Stewart if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_EXT_RCVINFO)) { 216f8829a4aSRandall Stewart use_extended = 1; 217f8829a4aSRandall Stewart len = CMSG_LEN(sizeof(struct sctp_extrcvinfo)); 218f8829a4aSRandall Stewart } else { 219f8829a4aSRandall Stewart len = CMSG_LEN(sizeof(struct sctp_sndrcvinfo)); 220f8829a4aSRandall Stewart } 221f8829a4aSRandall Stewart 222f8829a4aSRandall Stewart 223f8829a4aSRandall Stewart ret = sctp_get_mbuf_for_msg(len, 224139bc87fSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 225f8829a4aSRandall Stewart 226f8829a4aSRandall Stewart if (ret == NULL) { 227f8829a4aSRandall Stewart /* No space */ 228f8829a4aSRandall Stewart return (ret); 229f8829a4aSRandall Stewart } 230f8829a4aSRandall Stewart /* We need a CMSG header followed by the struct */ 231f8829a4aSRandall Stewart cmh = mtod(ret, struct cmsghdr *); 232f8829a4aSRandall Stewart outinfo = (struct sctp_sndrcvinfo *)CMSG_DATA(cmh); 233f8829a4aSRandall Stewart cmh->cmsg_level = IPPROTO_SCTP; 234f8829a4aSRandall Stewart if (use_extended) { 235f8829a4aSRandall Stewart cmh->cmsg_type = SCTP_EXTRCV; 236f8829a4aSRandall Stewart cmh->cmsg_len = len; 237f8829a4aSRandall Stewart memcpy(outinfo, sinfo, len); 238f8829a4aSRandall Stewart } else { 239f8829a4aSRandall Stewart cmh->cmsg_type = SCTP_SNDRCV; 240f8829a4aSRandall Stewart cmh->cmsg_len = len; 241f8829a4aSRandall Stewart *outinfo = *sinfo; 242f8829a4aSRandall Stewart } 243139bc87fSRandall Stewart SCTP_BUF_LEN(ret) = cmh->cmsg_len; 244f8829a4aSRandall Stewart return (ret); 245f8829a4aSRandall Stewart } 246f8829a4aSRandall Stewart 247139bc87fSRandall Stewart 24817205eccSRandall Stewart char * 24917205eccSRandall Stewart sctp_build_ctl_cchunk(struct sctp_inpcb *inp, 25017205eccSRandall Stewart int *control_len, 25117205eccSRandall Stewart struct sctp_sndrcvinfo *sinfo) 25217205eccSRandall Stewart { 25317205eccSRandall Stewart struct sctp_sndrcvinfo *outinfo; 25417205eccSRandall Stewart struct cmsghdr *cmh; 25517205eccSRandall Stewart char *buf; 25617205eccSRandall Stewart int len; 25717205eccSRandall Stewart int use_extended = 0; 25817205eccSRandall Stewart 25917205eccSRandall Stewart if (sctp_is_feature_off(inp, SCTP_PCB_FLAGS_RECVDATAIOEVNT)) { 26017205eccSRandall Stewart /* user does not want the sndrcv ctl */ 26117205eccSRandall Stewart return (NULL); 26217205eccSRandall Stewart } 26317205eccSRandall Stewart if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_EXT_RCVINFO)) { 26417205eccSRandall Stewart use_extended = 1; 26517205eccSRandall Stewart len = CMSG_LEN(sizeof(struct sctp_extrcvinfo)); 26617205eccSRandall Stewart } else { 26717205eccSRandall Stewart len = CMSG_LEN(sizeof(struct sctp_sndrcvinfo)); 26817205eccSRandall Stewart } 269207304d4SRandall Stewart SCTP_MALLOC(buf, char *, len, SCTP_M_CMSG); 27017205eccSRandall Stewart if (buf == NULL) { 27117205eccSRandall Stewart /* No space */ 27217205eccSRandall Stewart return (buf); 27317205eccSRandall Stewart } 27417205eccSRandall Stewart /* We need a CMSG header followed by the struct */ 27517205eccSRandall Stewart cmh = (struct cmsghdr *)buf; 27617205eccSRandall Stewart outinfo = (struct sctp_sndrcvinfo *)CMSG_DATA(cmh); 27717205eccSRandall Stewart cmh->cmsg_level = IPPROTO_SCTP; 27817205eccSRandall Stewart if (use_extended) { 27917205eccSRandall Stewart cmh->cmsg_type = SCTP_EXTRCV; 28017205eccSRandall Stewart cmh->cmsg_len = len; 28117205eccSRandall Stewart memcpy(outinfo, sinfo, len); 28217205eccSRandall Stewart } else { 28317205eccSRandall Stewart cmh->cmsg_type = SCTP_SNDRCV; 28417205eccSRandall Stewart cmh->cmsg_len = len; 28517205eccSRandall Stewart *outinfo = *sinfo; 28617205eccSRandall Stewart } 28717205eccSRandall Stewart *control_len = len; 28817205eccSRandall Stewart return (buf); 28917205eccSRandall Stewart } 29017205eccSRandall Stewart 29177acdc25SRandall Stewart static void 29277acdc25SRandall Stewart sctp_mark_non_revokable(struct sctp_association *asoc, uint32_t tsn) 29377acdc25SRandall Stewart { 2949b2e0767SRandall Stewart uint32_t gap, i, cumackp1; 29577acdc25SRandall Stewart int fnd = 0; 29677acdc25SRandall Stewart 29777acdc25SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_do_drain) == 0) { 29877acdc25SRandall Stewart return; 29977acdc25SRandall Stewart } 3009b2e0767SRandall Stewart cumackp1 = asoc->cumulative_tsn + 1; 3019b2e0767SRandall Stewart if (compare_with_wrap(cumackp1, tsn, MAX_TSN)) { 3029b2e0767SRandall Stewart /* 3039b2e0767SRandall Stewart * this tsn is behind the cum ack and thus we don't need to 3049b2e0767SRandall Stewart * worry about it being moved from one to the other. 3059b2e0767SRandall Stewart */ 3069b2e0767SRandall Stewart return; 3079b2e0767SRandall Stewart } 30877acdc25SRandall Stewart SCTP_CALC_TSN_TO_GAP(gap, tsn, asoc->mapping_array_base_tsn); 30977acdc25SRandall Stewart if (!SCTP_IS_TSN_PRESENT(asoc->mapping_array, gap)) { 31077acdc25SRandall Stewart printf("gap:%x tsn:%x\n", gap, tsn); 31177acdc25SRandall Stewart sctp_print_mapping_array(asoc); 312b5c16493SMichael Tuexen #ifdef INVARIANTS 31377acdc25SRandall Stewart panic("Things are really messed up now!!"); 31477acdc25SRandall Stewart #endif 315b5c16493SMichael Tuexen } 31677acdc25SRandall Stewart SCTP_SET_TSN_PRESENT(asoc->nr_mapping_array, gap); 31777acdc25SRandall Stewart SCTP_UNSET_TSN_PRESENT(asoc->mapping_array, gap); 31877acdc25SRandall Stewart if (compare_with_wrap(tsn, asoc->highest_tsn_inside_nr_map, MAX_TSN)) { 31977acdc25SRandall Stewart asoc->highest_tsn_inside_nr_map = tsn; 32077acdc25SRandall Stewart } 32177acdc25SRandall Stewart if (tsn == asoc->highest_tsn_inside_map) { 32277acdc25SRandall Stewart /* We must back down to see what the new highest is */ 323b5c16493SMichael Tuexen for (i = tsn - 1; (compare_with_wrap(i, asoc->mapping_array_base_tsn, MAX_TSN) || 324b5c16493SMichael Tuexen (i == asoc->mapping_array_base_tsn)); i--) { 32577acdc25SRandall Stewart SCTP_CALC_TSN_TO_GAP(gap, i, asoc->mapping_array_base_tsn); 32677acdc25SRandall Stewart if (SCTP_IS_TSN_PRESENT(asoc->mapping_array, gap)) { 32777acdc25SRandall Stewart asoc->highest_tsn_inside_map = i; 32877acdc25SRandall Stewart fnd = 1; 32977acdc25SRandall Stewart break; 33077acdc25SRandall Stewart } 33177acdc25SRandall Stewart } 33277acdc25SRandall Stewart if (!fnd) { 33377acdc25SRandall Stewart asoc->highest_tsn_inside_map = asoc->mapping_array_base_tsn - 1; 33477acdc25SRandall Stewart } 33577acdc25SRandall Stewart } 33677acdc25SRandall Stewart } 33777acdc25SRandall Stewart 33817205eccSRandall Stewart 339f8829a4aSRandall Stewart /* 340f8829a4aSRandall Stewart * We are delivering currently from the reassembly queue. We must continue to 341f8829a4aSRandall Stewart * deliver until we either: 1) run out of space. 2) run out of sequential 342f8829a4aSRandall Stewart * TSN's 3) hit the SCTP_DATA_LAST_FRAG flag. 343f8829a4aSRandall Stewart */ 344f8829a4aSRandall Stewart static void 345f8829a4aSRandall Stewart sctp_service_reassembly(struct sctp_tcb *stcb, struct sctp_association *asoc) 346f8829a4aSRandall Stewart { 347f8829a4aSRandall Stewart struct sctp_tmit_chunk *chk; 348f8829a4aSRandall Stewart uint16_t nxt_todel; 349f8829a4aSRandall Stewart uint16_t stream_no; 350f8829a4aSRandall Stewart int end = 0; 351f8829a4aSRandall Stewart int cntDel; 352830d754dSRandall Stewart 353f8829a4aSRandall Stewart struct sctp_queued_to_read *control, *ctl, *ctlat; 354f8829a4aSRandall Stewart 355ad81507eSRandall Stewart if (stcb == NULL) 356ad81507eSRandall Stewart return; 357ad81507eSRandall Stewart 358f42a358aSRandall Stewart cntDel = stream_no = 0; 359ad81507eSRandall Stewart if ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) || 360851b7298SRandall Stewart (stcb->asoc.state & SCTP_STATE_ABOUT_TO_BE_FREED) || 361ad81507eSRandall Stewart (stcb->asoc.state & SCTP_STATE_CLOSED_SOCKET)) { 362851b7298SRandall Stewart /* socket above is long gone or going.. */ 363851b7298SRandall Stewart abandon: 364f8829a4aSRandall Stewart asoc->fragmented_delivery_inprogress = 0; 365f8829a4aSRandall Stewart chk = TAILQ_FIRST(&asoc->reasmqueue); 366f8829a4aSRandall Stewart while (chk) { 367f8829a4aSRandall Stewart TAILQ_REMOVE(&asoc->reasmqueue, chk, sctp_next); 368f8829a4aSRandall Stewart asoc->size_on_reasm_queue -= chk->send_size; 369f8829a4aSRandall Stewart sctp_ucount_decr(asoc->cnt_on_reasm_queue); 370f8829a4aSRandall Stewart /* 371f8829a4aSRandall Stewart * Lose the data pointer, since its in the socket 372f8829a4aSRandall Stewart * buffer 373f8829a4aSRandall Stewart */ 374f8829a4aSRandall Stewart if (chk->data) { 375f8829a4aSRandall Stewart sctp_m_freem(chk->data); 376f8829a4aSRandall Stewart chk->data = NULL; 377f8829a4aSRandall Stewart } 378f8829a4aSRandall Stewart /* Now free the address and data */ 379f8829a4aSRandall Stewart sctp_free_a_chunk(stcb, chk); 3803c503c28SRandall Stewart /* sa_ignore FREED_MEMORY */ 381f8829a4aSRandall Stewart chk = TAILQ_FIRST(&asoc->reasmqueue); 382f8829a4aSRandall Stewart } 383f8829a4aSRandall Stewart return; 384f8829a4aSRandall Stewart } 385f8829a4aSRandall Stewart SCTP_TCB_LOCK_ASSERT(stcb); 386f8829a4aSRandall Stewart do { 387f8829a4aSRandall Stewart chk = TAILQ_FIRST(&asoc->reasmqueue); 388f8829a4aSRandall Stewart if (chk == NULL) { 389f8829a4aSRandall Stewart return; 390f8829a4aSRandall Stewart } 391f8829a4aSRandall Stewart if (chk->rec.data.TSN_seq != (asoc->tsn_last_delivered + 1)) { 392f8829a4aSRandall Stewart /* Can't deliver more :< */ 393f8829a4aSRandall Stewart return; 394f8829a4aSRandall Stewart } 395f8829a4aSRandall Stewart stream_no = chk->rec.data.stream_number; 396f8829a4aSRandall Stewart nxt_todel = asoc->strmin[stream_no].last_sequence_delivered + 1; 397f8829a4aSRandall Stewart if (nxt_todel != chk->rec.data.stream_seq && 398f8829a4aSRandall Stewart (chk->rec.data.rcv_flags & SCTP_DATA_UNORDERED) == 0) { 399f8829a4aSRandall Stewart /* 400f8829a4aSRandall Stewart * Not the next sequence to deliver in its stream OR 401f8829a4aSRandall Stewart * unordered 402f8829a4aSRandall Stewart */ 403f8829a4aSRandall Stewart return; 404f8829a4aSRandall Stewart } 405f8829a4aSRandall Stewart if (chk->rec.data.rcv_flags & SCTP_DATA_FIRST_FRAG) { 406f8829a4aSRandall Stewart 407f8829a4aSRandall Stewart control = sctp_build_readq_entry_chk(stcb, chk); 408f8829a4aSRandall Stewart if (control == NULL) { 409f8829a4aSRandall Stewart /* out of memory? */ 410f8829a4aSRandall Stewart return; 411f8829a4aSRandall Stewart } 412f8829a4aSRandall Stewart /* save it off for our future deliveries */ 413f8829a4aSRandall Stewart stcb->asoc.control_pdapi = control; 414f8829a4aSRandall Stewart if (chk->rec.data.rcv_flags & SCTP_DATA_LAST_FRAG) 415f8829a4aSRandall Stewart end = 1; 416f8829a4aSRandall Stewart else 417f8829a4aSRandall Stewart end = 0; 418b5c16493SMichael Tuexen sctp_mark_non_revokable(asoc, chk->rec.data.TSN_seq); 419f8829a4aSRandall Stewart sctp_add_to_readq(stcb->sctp_ep, 420cfde3ff7SRandall Stewart stcb, control, &stcb->sctp_socket->so_rcv, end, 421cfde3ff7SRandall Stewart SCTP_READ_LOCK_NOT_HELD, SCTP_SO_NOT_LOCKED); 422f8829a4aSRandall Stewart cntDel++; 423f8829a4aSRandall Stewart } else { 424f8829a4aSRandall Stewart if (chk->rec.data.rcv_flags & SCTP_DATA_LAST_FRAG) 425f8829a4aSRandall Stewart end = 1; 426f8829a4aSRandall Stewart else 427f8829a4aSRandall Stewart end = 0; 428b5c16493SMichael Tuexen sctp_mark_non_revokable(asoc, chk->rec.data.TSN_seq); 429f8829a4aSRandall Stewart if (sctp_append_to_readq(stcb->sctp_ep, stcb, 430f8829a4aSRandall Stewart stcb->asoc.control_pdapi, 431f8829a4aSRandall Stewart chk->data, end, chk->rec.data.TSN_seq, 432f8829a4aSRandall Stewart &stcb->sctp_socket->so_rcv)) { 433f8829a4aSRandall Stewart /* 434f8829a4aSRandall Stewart * something is very wrong, either 435f8829a4aSRandall Stewart * control_pdapi is NULL, or the tail_mbuf 436f8829a4aSRandall Stewart * is corrupt, or there is a EOM already on 437f8829a4aSRandall Stewart * the mbuf chain. 438f8829a4aSRandall Stewart */ 439851b7298SRandall Stewart if (stcb->asoc.state & SCTP_STATE_ABOUT_TO_BE_FREED) { 440851b7298SRandall Stewart goto abandon; 441851b7298SRandall Stewart } else { 442df6e0cc3SRandall Stewart #ifdef INVARIANTS 443ad81507eSRandall Stewart if ((stcb->asoc.control_pdapi == NULL) || (stcb->asoc.control_pdapi->tail_mbuf == NULL)) { 444f8829a4aSRandall Stewart panic("This should not happen control_pdapi NULL?"); 445f8829a4aSRandall Stewart } 446f8829a4aSRandall Stewart /* if we did not panic, it was a EOM */ 447f8829a4aSRandall Stewart panic("Bad chunking ??"); 448df6e0cc3SRandall Stewart #else 449df6e0cc3SRandall Stewart if ((stcb->asoc.control_pdapi == NULL) || (stcb->asoc.control_pdapi->tail_mbuf == NULL)) { 450df6e0cc3SRandall Stewart SCTP_PRINTF("This should not happen control_pdapi NULL?\n"); 451df6e0cc3SRandall Stewart } 452df6e0cc3SRandall Stewart SCTP_PRINTF("Bad chunking ??\n"); 453df6e0cc3SRandall Stewart SCTP_PRINTF("Dumping re-assembly queue this will probably hose the association\n"); 454df6e0cc3SRandall Stewart 455df6e0cc3SRandall Stewart #endif 456df6e0cc3SRandall Stewart goto abandon; 457f8829a4aSRandall Stewart } 458851b7298SRandall Stewart } 459f8829a4aSRandall Stewart cntDel++; 460f8829a4aSRandall Stewart } 461f8829a4aSRandall Stewart /* pull it we did it */ 462f8829a4aSRandall Stewart TAILQ_REMOVE(&asoc->reasmqueue, chk, sctp_next); 463f8829a4aSRandall Stewart if (chk->rec.data.rcv_flags & SCTP_DATA_LAST_FRAG) { 464f8829a4aSRandall Stewart asoc->fragmented_delivery_inprogress = 0; 465f8829a4aSRandall Stewart if ((chk->rec.data.rcv_flags & SCTP_DATA_UNORDERED) == 0) { 466f8829a4aSRandall Stewart asoc->strmin[stream_no].last_sequence_delivered++; 467f8829a4aSRandall Stewart } 468f8829a4aSRandall Stewart if ((chk->rec.data.rcv_flags & SCTP_DATA_FIRST_FRAG) == 0) { 469f8829a4aSRandall Stewart SCTP_STAT_INCR_COUNTER64(sctps_reasmusrmsgs); 470f8829a4aSRandall Stewart } 471f8829a4aSRandall Stewart } else if (chk->rec.data.rcv_flags & SCTP_DATA_FIRST_FRAG) { 472f8829a4aSRandall Stewart /* 473f8829a4aSRandall Stewart * turn the flag back on since we just delivered 474f8829a4aSRandall Stewart * yet another one. 475f8829a4aSRandall Stewart */ 476f8829a4aSRandall Stewart asoc->fragmented_delivery_inprogress = 1; 477f8829a4aSRandall Stewart } 478f8829a4aSRandall Stewart asoc->tsn_of_pdapi_last_delivered = chk->rec.data.TSN_seq; 479f8829a4aSRandall Stewart asoc->last_flags_delivered = chk->rec.data.rcv_flags; 480f8829a4aSRandall Stewart asoc->last_strm_seq_delivered = chk->rec.data.stream_seq; 481f8829a4aSRandall Stewart asoc->last_strm_no_delivered = chk->rec.data.stream_number; 482f8829a4aSRandall Stewart 483f8829a4aSRandall Stewart asoc->tsn_last_delivered = chk->rec.data.TSN_seq; 484f8829a4aSRandall Stewart asoc->size_on_reasm_queue -= chk->send_size; 485f8829a4aSRandall Stewart sctp_ucount_decr(asoc->cnt_on_reasm_queue); 486f8829a4aSRandall Stewart /* free up the chk */ 487f8829a4aSRandall Stewart chk->data = NULL; 488f8829a4aSRandall Stewart sctp_free_a_chunk(stcb, chk); 489f8829a4aSRandall Stewart 490f8829a4aSRandall Stewart if (asoc->fragmented_delivery_inprogress == 0) { 491f8829a4aSRandall Stewart /* 492f8829a4aSRandall Stewart * Now lets see if we can deliver the next one on 493f8829a4aSRandall Stewart * the stream 494f8829a4aSRandall Stewart */ 495f8829a4aSRandall Stewart struct sctp_stream_in *strm; 496f8829a4aSRandall Stewart 497f8829a4aSRandall Stewart strm = &asoc->strmin[stream_no]; 498f8829a4aSRandall Stewart nxt_todel = strm->last_sequence_delivered + 1; 499f8829a4aSRandall Stewart ctl = TAILQ_FIRST(&strm->inqueue); 500f8829a4aSRandall Stewart if (ctl && (nxt_todel == ctl->sinfo_ssn)) { 501f8829a4aSRandall Stewart while (ctl != NULL) { 502f8829a4aSRandall Stewart /* Deliver more if we can. */ 503f8829a4aSRandall Stewart if (nxt_todel == ctl->sinfo_ssn) { 504f8829a4aSRandall Stewart ctlat = TAILQ_NEXT(ctl, next); 505f8829a4aSRandall Stewart TAILQ_REMOVE(&strm->inqueue, ctl, next); 506f8829a4aSRandall Stewart asoc->size_on_all_streams -= ctl->length; 507f8829a4aSRandall Stewart sctp_ucount_decr(asoc->cnt_on_all_streams); 508f8829a4aSRandall Stewart strm->last_sequence_delivered++; 509b5c16493SMichael Tuexen sctp_mark_non_revokable(asoc, ctl->sinfo_tsn); 510f8829a4aSRandall Stewart sctp_add_to_readq(stcb->sctp_ep, stcb, 511f8829a4aSRandall Stewart ctl, 512cfde3ff7SRandall Stewart &stcb->sctp_socket->so_rcv, 1, 513cfde3ff7SRandall Stewart SCTP_READ_LOCK_NOT_HELD, SCTP_SO_NOT_LOCKED); 514f8829a4aSRandall Stewart ctl = ctlat; 515f8829a4aSRandall Stewart } else { 516f8829a4aSRandall Stewart break; 517f8829a4aSRandall Stewart } 518f8829a4aSRandall Stewart nxt_todel = strm->last_sequence_delivered + 1; 519f8829a4aSRandall Stewart } 520f8829a4aSRandall Stewart } 521139bc87fSRandall Stewart break; 522f8829a4aSRandall Stewart } 5233c503c28SRandall Stewart /* sa_ignore FREED_MEMORY */ 524f8829a4aSRandall Stewart chk = TAILQ_FIRST(&asoc->reasmqueue); 525f8829a4aSRandall Stewart } while (chk); 526f8829a4aSRandall Stewart } 527f8829a4aSRandall Stewart 528f8829a4aSRandall Stewart /* 529f8829a4aSRandall Stewart * Queue the chunk either right into the socket buffer if it is the next one 530f8829a4aSRandall Stewart * to go OR put it in the correct place in the delivery queue. If we do 531f8829a4aSRandall Stewart * append to the so_buf, keep doing so until we are out of order. One big 532f8829a4aSRandall Stewart * question still remains, what to do when the socket buffer is FULL?? 533f8829a4aSRandall Stewart */ 534f8829a4aSRandall Stewart static void 535f8829a4aSRandall Stewart sctp_queue_data_to_stream(struct sctp_tcb *stcb, struct sctp_association *asoc, 536f8829a4aSRandall Stewart struct sctp_queued_to_read *control, int *abort_flag) 537f8829a4aSRandall Stewart { 538f8829a4aSRandall Stewart /* 539f8829a4aSRandall Stewart * FIX-ME maybe? What happens when the ssn wraps? If we are getting 540f8829a4aSRandall Stewart * all the data in one stream this could happen quite rapidly. One 541f8829a4aSRandall Stewart * could use the TSN to keep track of things, but this scheme breaks 542f8829a4aSRandall Stewart * down in the other type of stream useage that could occur. Send a 543f8829a4aSRandall Stewart * single msg to stream 0, send 4Billion messages to stream 1, now 544f8829a4aSRandall Stewart * send a message to stream 0. You have a situation where the TSN 545f8829a4aSRandall Stewart * has wrapped but not in the stream. Is this worth worrying about 546f8829a4aSRandall Stewart * or should we just change our queue sort at the bottom to be by 547f8829a4aSRandall Stewart * TSN. 548f8829a4aSRandall Stewart * 549f8829a4aSRandall Stewart * Could it also be legal for a peer to send ssn 1 with TSN 2 and ssn 2 550f8829a4aSRandall Stewart * with TSN 1? If the peer is doing some sort of funky TSN/SSN 551f8829a4aSRandall Stewart * assignment this could happen... and I don't see how this would be 552f8829a4aSRandall Stewart * a violation. So for now I am undecided an will leave the sort by 553f8829a4aSRandall Stewart * SSN alone. Maybe a hybred approach is the answer 554f8829a4aSRandall Stewart * 555f8829a4aSRandall Stewart */ 556f8829a4aSRandall Stewart struct sctp_stream_in *strm; 557f8829a4aSRandall Stewart struct sctp_queued_to_read *at; 558f8829a4aSRandall Stewart int queue_needed; 559f8829a4aSRandall Stewart uint16_t nxt_todel; 560f8829a4aSRandall Stewart struct mbuf *oper; 561f8829a4aSRandall Stewart 562f8829a4aSRandall Stewart queue_needed = 1; 563f8829a4aSRandall Stewart asoc->size_on_all_streams += control->length; 564f8829a4aSRandall Stewart sctp_ucount_incr(asoc->cnt_on_all_streams); 565f8829a4aSRandall Stewart strm = &asoc->strmin[control->sinfo_stream]; 566f8829a4aSRandall Stewart nxt_todel = strm->last_sequence_delivered + 1; 567b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_STR_LOGGING_ENABLE) { 568f8829a4aSRandall Stewart sctp_log_strm_del(control, NULL, SCTP_STR_LOG_FROM_INTO_STRD); 56980fefe0aSRandall Stewart } 570ad81507eSRandall Stewart SCTPDBG(SCTP_DEBUG_INDATA1, 571ad81507eSRandall Stewart "queue to stream called for ssn:%u lastdel:%u nxt:%u\n", 572f8829a4aSRandall Stewart (uint32_t) control->sinfo_stream, 573ad81507eSRandall Stewart (uint32_t) strm->last_sequence_delivered, 574ad81507eSRandall Stewart (uint32_t) nxt_todel); 575f8829a4aSRandall Stewart if (compare_with_wrap(strm->last_sequence_delivered, 576f8829a4aSRandall Stewart control->sinfo_ssn, MAX_SEQ) || 577f8829a4aSRandall Stewart (strm->last_sequence_delivered == control->sinfo_ssn)) { 578f8829a4aSRandall Stewart /* The incoming sseq is behind where we last delivered? */ 579ad81507eSRandall Stewart SCTPDBG(SCTP_DEBUG_INDATA1, "Duplicate S-SEQ:%d delivered:%d from peer, Abort association\n", 580ad81507eSRandall Stewart control->sinfo_ssn, strm->last_sequence_delivered); 581c40e9cf2SRandall Stewart protocol_error: 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, 607ceaad40aSRandall Stewart SCTP_PEER_FAULTY, oper, SCTP_SO_NOT_LOCKED); 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? */ 615b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_STR_LOGGING_ENABLE) { 616f8829a4aSRandall Stewart sctp_log_strm_del(control, NULL, SCTP_STR_LOG_FROM_IMMED_DEL); 61780fefe0aSRandall Stewart } 618830d754dSRandall Stewart /* EY it wont be queued if it could be delivered directly */ 619f8829a4aSRandall Stewart queue_needed = 0; 620f8829a4aSRandall Stewart asoc->size_on_all_streams -= control->length; 621f8829a4aSRandall Stewart sctp_ucount_decr(asoc->cnt_on_all_streams); 622f8829a4aSRandall Stewart strm->last_sequence_delivered++; 62377acdc25SRandall Stewart 624b5c16493SMichael Tuexen sctp_mark_non_revokable(asoc, control->sinfo_tsn); 625f8829a4aSRandall Stewart sctp_add_to_readq(stcb->sctp_ep, stcb, 626f8829a4aSRandall Stewart control, 627cfde3ff7SRandall Stewart &stcb->sctp_socket->so_rcv, 1, 628cfde3ff7SRandall Stewart SCTP_READ_LOCK_NOT_HELD, SCTP_SO_NOT_LOCKED); 629f8829a4aSRandall Stewart control = TAILQ_FIRST(&strm->inqueue); 630f8829a4aSRandall Stewart while (control != NULL) { 631f8829a4aSRandall Stewart /* all delivered */ 632f8829a4aSRandall Stewart nxt_todel = strm->last_sequence_delivered + 1; 633f8829a4aSRandall Stewart if (nxt_todel == control->sinfo_ssn) { 634f8829a4aSRandall Stewart at = TAILQ_NEXT(control, next); 635f8829a4aSRandall Stewart TAILQ_REMOVE(&strm->inqueue, control, next); 636f8829a4aSRandall Stewart asoc->size_on_all_streams -= control->length; 637f8829a4aSRandall Stewart sctp_ucount_decr(asoc->cnt_on_all_streams); 638f8829a4aSRandall Stewart strm->last_sequence_delivered++; 639f8829a4aSRandall Stewart /* 640f8829a4aSRandall Stewart * We ignore the return of deliver_data here 641f8829a4aSRandall Stewart * since we always can hold the chunk on the 642f8829a4aSRandall Stewart * d-queue. And we have a finite number that 643f8829a4aSRandall Stewart * can be delivered from the strq. 644f8829a4aSRandall Stewart */ 645b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_STR_LOGGING_ENABLE) { 646f8829a4aSRandall Stewart sctp_log_strm_del(control, NULL, 647f8829a4aSRandall Stewart SCTP_STR_LOG_FROM_IMMED_DEL); 64880fefe0aSRandall Stewart } 649b5c16493SMichael Tuexen sctp_mark_non_revokable(asoc, control->sinfo_tsn); 650f8829a4aSRandall Stewart sctp_add_to_readq(stcb->sctp_ep, stcb, 651f8829a4aSRandall Stewart control, 652cfde3ff7SRandall Stewart &stcb->sctp_socket->so_rcv, 1, 653cfde3ff7SRandall Stewart SCTP_READ_LOCK_NOT_HELD, 654cfde3ff7SRandall Stewart SCTP_SO_NOT_LOCKED); 655f8829a4aSRandall Stewart control = at; 656f8829a4aSRandall Stewart continue; 657f8829a4aSRandall Stewart } 658f8829a4aSRandall Stewart break; 659f8829a4aSRandall Stewart } 660f8829a4aSRandall Stewart } 661f8829a4aSRandall Stewart if (queue_needed) { 662f8829a4aSRandall Stewart /* 663f8829a4aSRandall Stewart * Ok, we did not deliver this guy, find the correct place 664f8829a4aSRandall Stewart * to put it on the queue. 665f8829a4aSRandall Stewart */ 666c40e9cf2SRandall Stewart if ((compare_with_wrap(asoc->cumulative_tsn, 667c40e9cf2SRandall Stewart control->sinfo_tsn, MAX_TSN)) || 668c40e9cf2SRandall Stewart (control->sinfo_tsn == asoc->cumulative_tsn)) { 669c40e9cf2SRandall Stewart goto protocol_error; 670c40e9cf2SRandall Stewart } 671f8829a4aSRandall Stewart if (TAILQ_EMPTY(&strm->inqueue)) { 672f8829a4aSRandall Stewart /* Empty queue */ 673b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_STR_LOGGING_ENABLE) { 674f8829a4aSRandall Stewart sctp_log_strm_del(control, NULL, SCTP_STR_LOG_FROM_INSERT_HD); 67580fefe0aSRandall Stewart } 676f8829a4aSRandall Stewart TAILQ_INSERT_HEAD(&strm->inqueue, control, next); 677f8829a4aSRandall Stewart } else { 678f8829a4aSRandall Stewart TAILQ_FOREACH(at, &strm->inqueue, next) { 679f8829a4aSRandall Stewart if (compare_with_wrap(at->sinfo_ssn, 680f8829a4aSRandall Stewart control->sinfo_ssn, MAX_SEQ)) { 681f8829a4aSRandall Stewart /* 682f8829a4aSRandall Stewart * one in queue is bigger than the 683f8829a4aSRandall Stewart * new one, insert before this one 684f8829a4aSRandall Stewart */ 685b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_STR_LOGGING_ENABLE) { 686f8829a4aSRandall Stewart sctp_log_strm_del(control, at, 687f8829a4aSRandall Stewart SCTP_STR_LOG_FROM_INSERT_MD); 68880fefe0aSRandall Stewart } 689f8829a4aSRandall Stewart TAILQ_INSERT_BEFORE(at, control, next); 690f8829a4aSRandall Stewart break; 691f8829a4aSRandall Stewart } else if (at->sinfo_ssn == control->sinfo_ssn) { 692f8829a4aSRandall Stewart /* 693f8829a4aSRandall Stewart * Gak, He sent me a duplicate str 694f8829a4aSRandall Stewart * seq number 695f8829a4aSRandall Stewart */ 696f8829a4aSRandall Stewart /* 697f8829a4aSRandall Stewart * foo bar, I guess I will just free 698f8829a4aSRandall Stewart * this new guy, should we abort 699f8829a4aSRandall Stewart * too? FIX ME MAYBE? Or it COULD be 700f8829a4aSRandall Stewart * that the SSN's have wrapped. 701f8829a4aSRandall Stewart * Maybe I should compare to TSN 702f8829a4aSRandall Stewart * somehow... sigh for now just blow 703f8829a4aSRandall Stewart * away the chunk! 704f8829a4aSRandall Stewart */ 705f8829a4aSRandall Stewart 706f8829a4aSRandall Stewart if (control->data) 707f8829a4aSRandall Stewart sctp_m_freem(control->data); 708f8829a4aSRandall Stewart control->data = NULL; 709f8829a4aSRandall Stewart asoc->size_on_all_streams -= control->length; 710f8829a4aSRandall Stewart sctp_ucount_decr(asoc->cnt_on_all_streams); 71124f52bbdSMichael Tuexen if (control->whoFrom) { 712f8829a4aSRandall Stewart sctp_free_remote_addr(control->whoFrom); 7135bead436SRandall Stewart control->whoFrom = NULL; 71424f52bbdSMichael Tuexen } 715f8829a4aSRandall Stewart sctp_free_a_readq(stcb, control); 716f8829a4aSRandall Stewart return; 717f8829a4aSRandall Stewart } else { 718f8829a4aSRandall Stewart if (TAILQ_NEXT(at, next) == NULL) { 719f8829a4aSRandall Stewart /* 720f8829a4aSRandall Stewart * We are at the end, insert 721f8829a4aSRandall Stewart * it after this one 722f8829a4aSRandall Stewart */ 723b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_STR_LOGGING_ENABLE) { 724f8829a4aSRandall Stewart sctp_log_strm_del(control, at, 725f8829a4aSRandall Stewart SCTP_STR_LOG_FROM_INSERT_TL); 72680fefe0aSRandall Stewart } 727f8829a4aSRandall Stewart TAILQ_INSERT_AFTER(&strm->inqueue, 728f8829a4aSRandall Stewart at, control, next); 729f8829a4aSRandall Stewart break; 730f8829a4aSRandall Stewart } 731f8829a4aSRandall Stewart } 732f8829a4aSRandall Stewart } 733f8829a4aSRandall Stewart } 734f8829a4aSRandall Stewart } 735f8829a4aSRandall Stewart } 736f8829a4aSRandall Stewart 737f8829a4aSRandall Stewart /* 738f8829a4aSRandall Stewart * Returns two things: You get the total size of the deliverable parts of the 739f8829a4aSRandall Stewart * first fragmented message on the reassembly queue. And you get a 1 back if 740f8829a4aSRandall Stewart * all of the message is ready or a 0 back if the message is still incomplete 741f8829a4aSRandall Stewart */ 742f8829a4aSRandall Stewart static int 743f8829a4aSRandall Stewart sctp_is_all_msg_on_reasm(struct sctp_association *asoc, uint32_t * t_size) 744f8829a4aSRandall Stewart { 745f8829a4aSRandall Stewart struct sctp_tmit_chunk *chk; 746f8829a4aSRandall Stewart uint32_t tsn; 747f8829a4aSRandall Stewart 748f8829a4aSRandall Stewart *t_size = 0; 749f8829a4aSRandall Stewart chk = TAILQ_FIRST(&asoc->reasmqueue); 750f8829a4aSRandall Stewart if (chk == NULL) { 751f8829a4aSRandall Stewart /* nothing on the queue */ 752f8829a4aSRandall Stewart return (0); 753f8829a4aSRandall Stewart } 754f8829a4aSRandall Stewart if ((chk->rec.data.rcv_flags & SCTP_DATA_FIRST_FRAG) == 0) { 755f8829a4aSRandall Stewart /* Not a first on the queue */ 756f8829a4aSRandall Stewart return (0); 757f8829a4aSRandall Stewart } 758f8829a4aSRandall Stewart tsn = chk->rec.data.TSN_seq; 759f8829a4aSRandall Stewart while (chk) { 760f8829a4aSRandall Stewart if (tsn != chk->rec.data.TSN_seq) { 761f8829a4aSRandall Stewart return (0); 762f8829a4aSRandall Stewart } 763f8829a4aSRandall Stewart *t_size += chk->send_size; 764f8829a4aSRandall Stewart if (chk->rec.data.rcv_flags & SCTP_DATA_LAST_FRAG) { 765f8829a4aSRandall Stewart return (1); 766f8829a4aSRandall Stewart } 767f8829a4aSRandall Stewart tsn++; 768f8829a4aSRandall Stewart chk = TAILQ_NEXT(chk, sctp_next); 769f8829a4aSRandall Stewart } 770f8829a4aSRandall Stewart return (0); 771f8829a4aSRandall Stewart } 772f8829a4aSRandall Stewart 773f8829a4aSRandall Stewart static void 774f8829a4aSRandall Stewart sctp_deliver_reasm_check(struct sctp_tcb *stcb, struct sctp_association *asoc) 775f8829a4aSRandall Stewart { 776f8829a4aSRandall Stewart struct sctp_tmit_chunk *chk; 777f8829a4aSRandall Stewart uint16_t nxt_todel; 778810ec536SMichael Tuexen uint32_t tsize, pd_point; 779f8829a4aSRandall Stewart 780139bc87fSRandall Stewart doit_again: 781f8829a4aSRandall Stewart chk = TAILQ_FIRST(&asoc->reasmqueue); 782f8829a4aSRandall Stewart if (chk == NULL) { 783f8829a4aSRandall Stewart /* Huh? */ 784f8829a4aSRandall Stewart asoc->size_on_reasm_queue = 0; 785f8829a4aSRandall Stewart asoc->cnt_on_reasm_queue = 0; 786f8829a4aSRandall Stewart return; 787f8829a4aSRandall Stewart } 788f8829a4aSRandall Stewart if (asoc->fragmented_delivery_inprogress == 0) { 789f8829a4aSRandall Stewart nxt_todel = 790f8829a4aSRandall Stewart asoc->strmin[chk->rec.data.stream_number].last_sequence_delivered + 1; 791f8829a4aSRandall Stewart if ((chk->rec.data.rcv_flags & SCTP_DATA_FIRST_FRAG) && 792f8829a4aSRandall Stewart (nxt_todel == chk->rec.data.stream_seq || 793f8829a4aSRandall Stewart (chk->rec.data.rcv_flags & SCTP_DATA_UNORDERED))) { 794f8829a4aSRandall Stewart /* 795f8829a4aSRandall Stewart * Yep the first one is here and its ok to deliver 796f8829a4aSRandall Stewart * but should we? 797f8829a4aSRandall Stewart */ 798810ec536SMichael Tuexen if (stcb->sctp_socket) { 79924ae5c4aSMichael Tuexen pd_point = min(SCTP_SB_LIMIT_RCV(stcb->sctp_socket), 800810ec536SMichael Tuexen stcb->sctp_ep->partial_delivery_point); 801810ec536SMichael Tuexen } else { 802810ec536SMichael Tuexen pd_point = stcb->sctp_ep->partial_delivery_point; 803810ec536SMichael Tuexen } 804810ec536SMichael Tuexen if (sctp_is_all_msg_on_reasm(asoc, &tsize) || (tsize >= pd_point)) { 805f8829a4aSRandall Stewart 806f8829a4aSRandall Stewart /* 807f8829a4aSRandall Stewart * Yes, we setup to start reception, by 808f8829a4aSRandall Stewart * backing down the TSN just in case we 809f8829a4aSRandall Stewart * can't deliver. If we 810f8829a4aSRandall Stewart */ 811f8829a4aSRandall Stewart asoc->fragmented_delivery_inprogress = 1; 812f8829a4aSRandall Stewart asoc->tsn_last_delivered = 813f8829a4aSRandall Stewart chk->rec.data.TSN_seq - 1; 814f8829a4aSRandall Stewart asoc->str_of_pdapi = 815f8829a4aSRandall Stewart chk->rec.data.stream_number; 816f8829a4aSRandall Stewart asoc->ssn_of_pdapi = chk->rec.data.stream_seq; 817f8829a4aSRandall Stewart asoc->pdapi_ppid = chk->rec.data.payloadtype; 818f8829a4aSRandall Stewart asoc->fragment_flags = chk->rec.data.rcv_flags; 819f8829a4aSRandall Stewart sctp_service_reassembly(stcb, asoc); 820f8829a4aSRandall Stewart } 821f8829a4aSRandall Stewart } 822f8829a4aSRandall Stewart } else { 823139bc87fSRandall Stewart /* 824139bc87fSRandall Stewart * Service re-assembly will deliver stream data queued at 825139bc87fSRandall Stewart * the end of fragmented delivery.. but it wont know to go 826139bc87fSRandall Stewart * back and call itself again... we do that here with the 827139bc87fSRandall Stewart * got doit_again 828139bc87fSRandall Stewart */ 829f8829a4aSRandall Stewart sctp_service_reassembly(stcb, asoc); 830139bc87fSRandall Stewart if (asoc->fragmented_delivery_inprogress == 0) { 831139bc87fSRandall Stewart /* 832139bc87fSRandall Stewart * finished our Fragmented delivery, could be more 833139bc87fSRandall Stewart * waiting? 834139bc87fSRandall Stewart */ 835139bc87fSRandall Stewart goto doit_again; 836139bc87fSRandall Stewart } 837f8829a4aSRandall Stewart } 838f8829a4aSRandall Stewart } 839f8829a4aSRandall Stewart 840f8829a4aSRandall Stewart /* 841f8829a4aSRandall Stewart * Dump onto the re-assembly queue, in its proper place. After dumping on the 842f8829a4aSRandall Stewart * queue, see if anthing can be delivered. If so pull it off (or as much as 843f8829a4aSRandall Stewart * we can. If we run out of space then we must dump what we can and set the 844f8829a4aSRandall Stewart * appropriate flag to say we queued what we could. 845f8829a4aSRandall Stewart */ 846f8829a4aSRandall Stewart static void 847f8829a4aSRandall Stewart sctp_queue_data_for_reasm(struct sctp_tcb *stcb, struct sctp_association *asoc, 848f8829a4aSRandall Stewart struct sctp_tmit_chunk *chk, int *abort_flag) 849f8829a4aSRandall Stewart { 850f8829a4aSRandall Stewart struct mbuf *oper; 851f8829a4aSRandall Stewart uint32_t cum_ackp1, last_tsn, prev_tsn, post_tsn; 852f8829a4aSRandall Stewart u_char last_flags; 853f8829a4aSRandall Stewart struct sctp_tmit_chunk *at, *prev, *next; 854f8829a4aSRandall Stewart 855f8829a4aSRandall Stewart prev = next = NULL; 856f8829a4aSRandall Stewart cum_ackp1 = asoc->tsn_last_delivered + 1; 857f8829a4aSRandall Stewart if (TAILQ_EMPTY(&asoc->reasmqueue)) { 858f8829a4aSRandall Stewart /* This is the first one on the queue */ 859f8829a4aSRandall Stewart TAILQ_INSERT_HEAD(&asoc->reasmqueue, chk, sctp_next); 860f8829a4aSRandall Stewart /* 861f8829a4aSRandall Stewart * we do not check for delivery of anything when only one 862f8829a4aSRandall Stewart * fragment is here 863f8829a4aSRandall Stewart */ 864f8829a4aSRandall Stewart asoc->size_on_reasm_queue = chk->send_size; 865f8829a4aSRandall Stewart sctp_ucount_incr(asoc->cnt_on_reasm_queue); 866f8829a4aSRandall Stewart if (chk->rec.data.TSN_seq == cum_ackp1) { 867f8829a4aSRandall Stewart if (asoc->fragmented_delivery_inprogress == 0 && 868f8829a4aSRandall Stewart (chk->rec.data.rcv_flags & SCTP_DATA_FIRST_FRAG) != 869f8829a4aSRandall Stewart SCTP_DATA_FIRST_FRAG) { 870f8829a4aSRandall Stewart /* 871f8829a4aSRandall Stewart * An empty queue, no delivery inprogress, 872f8829a4aSRandall Stewart * we hit the next one and it does NOT have 873f8829a4aSRandall Stewart * a FIRST fragment mark. 874f8829a4aSRandall Stewart */ 875ad81507eSRandall Stewart SCTPDBG(SCTP_DEBUG_INDATA1, "Gak, Evil plot, its not first, no fragmented delivery in progress\n"); 876139bc87fSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + 3 * sizeof(uint32_t)), 877f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 878f8829a4aSRandall Stewart 879f8829a4aSRandall Stewart if (oper) { 880f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 881f8829a4aSRandall Stewart uint32_t *ippp; 882f8829a4aSRandall Stewart 883139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = 884f8829a4aSRandall Stewart sizeof(struct sctp_paramhdr) + 885f8829a4aSRandall Stewart (sizeof(uint32_t) * 3); 886f8829a4aSRandall Stewart ph = mtod(oper, struct sctp_paramhdr *); 887f8829a4aSRandall Stewart ph->param_type = 888f8829a4aSRandall Stewart htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 889139bc87fSRandall Stewart ph->param_length = htons(SCTP_BUF_LEN(oper)); 890f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 891a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_2); 892f8829a4aSRandall Stewart ippp++; 893f8829a4aSRandall Stewart *ippp = chk->rec.data.TSN_seq; 894f8829a4aSRandall Stewart ippp++; 895f8829a4aSRandall Stewart *ippp = ((chk->rec.data.stream_number << 16) | chk->rec.data.stream_seq); 896f8829a4aSRandall Stewart 897f8829a4aSRandall Stewart } 898a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_2; 899f8829a4aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, stcb, 900ceaad40aSRandall Stewart SCTP_PEER_FAULTY, oper, SCTP_SO_NOT_LOCKED); 901f8829a4aSRandall Stewart *abort_flag = 1; 902f8829a4aSRandall Stewart } else if (asoc->fragmented_delivery_inprogress && 903f8829a4aSRandall Stewart (chk->rec.data.rcv_flags & SCTP_DATA_FIRST_FRAG) == SCTP_DATA_FIRST_FRAG) { 904f8829a4aSRandall Stewart /* 905f8829a4aSRandall Stewart * We are doing a partial delivery and the 906f8829a4aSRandall Stewart * NEXT chunk MUST be either the LAST or 907f8829a4aSRandall Stewart * MIDDLE fragment NOT a FIRST 908f8829a4aSRandall Stewart */ 909ad81507eSRandall Stewart SCTPDBG(SCTP_DEBUG_INDATA1, "Gak, Evil plot, it IS a first and fragmented delivery in progress\n"); 910139bc87fSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + 3 * sizeof(uint32_t)), 911f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 912f8829a4aSRandall Stewart if (oper) { 913f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 914f8829a4aSRandall Stewart uint32_t *ippp; 915f8829a4aSRandall Stewart 916139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = 917f8829a4aSRandall Stewart sizeof(struct sctp_paramhdr) + 918f8829a4aSRandall Stewart (3 * sizeof(uint32_t)); 919f8829a4aSRandall Stewart ph = mtod(oper, struct sctp_paramhdr *); 920f8829a4aSRandall Stewart ph->param_type = 921f8829a4aSRandall Stewart htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 922139bc87fSRandall Stewart ph->param_length = htons(SCTP_BUF_LEN(oper)); 923f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 924a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_3); 925f8829a4aSRandall Stewart ippp++; 926f8829a4aSRandall Stewart *ippp = chk->rec.data.TSN_seq; 927f8829a4aSRandall Stewart ippp++; 928f8829a4aSRandall Stewart *ippp = ((chk->rec.data.stream_number << 16) | chk->rec.data.stream_seq); 929f8829a4aSRandall Stewart } 930a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_3; 931f8829a4aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, stcb, 932ceaad40aSRandall Stewart SCTP_PEER_FAULTY, oper, SCTP_SO_NOT_LOCKED); 933f8829a4aSRandall Stewart *abort_flag = 1; 934f8829a4aSRandall Stewart } else if (asoc->fragmented_delivery_inprogress) { 935f8829a4aSRandall Stewart /* 936f8829a4aSRandall Stewart * Here we are ok with a MIDDLE or LAST 937f8829a4aSRandall Stewart * piece 938f8829a4aSRandall Stewart */ 939f8829a4aSRandall Stewart if (chk->rec.data.stream_number != 940f8829a4aSRandall Stewart asoc->str_of_pdapi) { 941f8829a4aSRandall Stewart /* Got to be the right STR No */ 942ad81507eSRandall Stewart SCTPDBG(SCTP_DEBUG_INDATA1, "Gak, Evil plot, it IS not same stream number %d vs %d\n", 943f8829a4aSRandall Stewart chk->rec.data.stream_number, 944f8829a4aSRandall Stewart asoc->str_of_pdapi); 945139bc87fSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + 3 * sizeof(uint32_t)), 946f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 947f8829a4aSRandall Stewart if (oper) { 948f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 949f8829a4aSRandall Stewart uint32_t *ippp; 950f8829a4aSRandall Stewart 951139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = 952f8829a4aSRandall Stewart sizeof(struct sctp_paramhdr) + 953f8829a4aSRandall Stewart (sizeof(uint32_t) * 3); 954f8829a4aSRandall Stewart ph = mtod(oper, 955f8829a4aSRandall Stewart struct sctp_paramhdr *); 956f8829a4aSRandall Stewart ph->param_type = 957f8829a4aSRandall Stewart htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 958f8829a4aSRandall Stewart ph->param_length = 959139bc87fSRandall Stewart htons(SCTP_BUF_LEN(oper)); 960f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 961a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_4); 962f8829a4aSRandall Stewart ippp++; 963f8829a4aSRandall Stewart *ippp = chk->rec.data.TSN_seq; 964f8829a4aSRandall Stewart ippp++; 965f8829a4aSRandall Stewart *ippp = ((chk->rec.data.stream_number << 16) | chk->rec.data.stream_seq); 966f8829a4aSRandall Stewart } 967a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_4; 968f8829a4aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, 969ceaad40aSRandall Stewart stcb, SCTP_PEER_FAULTY, oper, SCTP_SO_NOT_LOCKED); 970f8829a4aSRandall Stewart *abort_flag = 1; 971f8829a4aSRandall Stewart } else if ((asoc->fragment_flags & SCTP_DATA_UNORDERED) != 972f8829a4aSRandall Stewart SCTP_DATA_UNORDERED && 973b5c16493SMichael Tuexen chk->rec.data.stream_seq != asoc->ssn_of_pdapi) { 974f8829a4aSRandall Stewart /* Got to be the right STR Seq */ 975ad81507eSRandall Stewart SCTPDBG(SCTP_DEBUG_INDATA1, "Gak, Evil plot, it IS not same stream seq %d vs %d\n", 976f8829a4aSRandall Stewart chk->rec.data.stream_seq, 977f8829a4aSRandall Stewart asoc->ssn_of_pdapi); 978139bc87fSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + 3 * sizeof(uint32_t)), 979f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 980f8829a4aSRandall Stewart if (oper) { 981f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 982f8829a4aSRandall Stewart uint32_t *ippp; 983f8829a4aSRandall Stewart 984139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = 985f8829a4aSRandall Stewart sizeof(struct sctp_paramhdr) + 986f8829a4aSRandall Stewart (3 * sizeof(uint32_t)); 987f8829a4aSRandall Stewart ph = mtod(oper, 988f8829a4aSRandall Stewart struct sctp_paramhdr *); 989f8829a4aSRandall Stewart ph->param_type = 990f8829a4aSRandall Stewart htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 991f8829a4aSRandall Stewart ph->param_length = 992139bc87fSRandall Stewart htons(SCTP_BUF_LEN(oper)); 993f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 994a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_5); 995f8829a4aSRandall Stewart ippp++; 996f8829a4aSRandall Stewart *ippp = chk->rec.data.TSN_seq; 997f8829a4aSRandall Stewart ippp++; 998f8829a4aSRandall Stewart *ippp = ((chk->rec.data.stream_number << 16) | chk->rec.data.stream_seq); 999f8829a4aSRandall Stewart 1000f8829a4aSRandall Stewart } 1001a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_5; 1002f8829a4aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, 1003ceaad40aSRandall Stewart stcb, SCTP_PEER_FAULTY, oper, SCTP_SO_NOT_LOCKED); 1004f8829a4aSRandall Stewart *abort_flag = 1; 1005f8829a4aSRandall Stewart } 1006f8829a4aSRandall Stewart } 1007f8829a4aSRandall Stewart } 1008f8829a4aSRandall Stewart return; 1009f8829a4aSRandall Stewart } 1010f8829a4aSRandall Stewart /* Find its place */ 1011f8829a4aSRandall Stewart TAILQ_FOREACH(at, &asoc->reasmqueue, sctp_next) { 1012f8829a4aSRandall Stewart if (compare_with_wrap(at->rec.data.TSN_seq, 1013f8829a4aSRandall Stewart chk->rec.data.TSN_seq, MAX_TSN)) { 1014f8829a4aSRandall Stewart /* 1015f8829a4aSRandall Stewart * one in queue is bigger than the new one, insert 1016f8829a4aSRandall Stewart * before this one 1017f8829a4aSRandall Stewart */ 1018f8829a4aSRandall Stewart /* A check */ 1019f8829a4aSRandall Stewart asoc->size_on_reasm_queue += chk->send_size; 1020f8829a4aSRandall Stewart sctp_ucount_incr(asoc->cnt_on_reasm_queue); 1021f8829a4aSRandall Stewart next = at; 1022f8829a4aSRandall Stewart TAILQ_INSERT_BEFORE(at, chk, sctp_next); 1023f8829a4aSRandall Stewart break; 1024f8829a4aSRandall Stewart } else if (at->rec.data.TSN_seq == chk->rec.data.TSN_seq) { 1025f8829a4aSRandall Stewart /* Gak, He sent me a duplicate str seq number */ 1026f8829a4aSRandall Stewart /* 1027f8829a4aSRandall Stewart * foo bar, I guess I will just free this new guy, 1028f8829a4aSRandall Stewart * should we abort too? FIX ME MAYBE? Or it COULD be 1029f8829a4aSRandall Stewart * that the SSN's have wrapped. Maybe I should 1030f8829a4aSRandall Stewart * compare to TSN somehow... sigh for now just blow 1031f8829a4aSRandall Stewart * away the chunk! 1032f8829a4aSRandall Stewart */ 1033f8829a4aSRandall Stewart if (chk->data) { 1034f8829a4aSRandall Stewart sctp_m_freem(chk->data); 1035f8829a4aSRandall Stewart chk->data = NULL; 1036f8829a4aSRandall Stewart } 1037f8829a4aSRandall Stewart sctp_free_a_chunk(stcb, chk); 1038f8829a4aSRandall Stewart return; 1039f8829a4aSRandall Stewart } else { 1040f8829a4aSRandall Stewart last_flags = at->rec.data.rcv_flags; 1041f8829a4aSRandall Stewart last_tsn = at->rec.data.TSN_seq; 1042f8829a4aSRandall Stewart prev = at; 1043f8829a4aSRandall Stewart if (TAILQ_NEXT(at, sctp_next) == NULL) { 1044f8829a4aSRandall Stewart /* 1045f8829a4aSRandall Stewart * We are at the end, insert it after this 1046f8829a4aSRandall Stewart * one 1047f8829a4aSRandall Stewart */ 1048f8829a4aSRandall Stewart /* check it first */ 1049f8829a4aSRandall Stewart asoc->size_on_reasm_queue += chk->send_size; 1050f8829a4aSRandall Stewart sctp_ucount_incr(asoc->cnt_on_reasm_queue); 1051f8829a4aSRandall Stewart TAILQ_INSERT_AFTER(&asoc->reasmqueue, at, chk, sctp_next); 1052f8829a4aSRandall Stewart break; 1053f8829a4aSRandall Stewart } 1054f8829a4aSRandall Stewart } 1055f8829a4aSRandall Stewart } 1056f8829a4aSRandall Stewart /* Now the audits */ 1057f8829a4aSRandall Stewart if (prev) { 1058f8829a4aSRandall Stewart prev_tsn = chk->rec.data.TSN_seq - 1; 1059f8829a4aSRandall Stewart if (prev_tsn == prev->rec.data.TSN_seq) { 1060f8829a4aSRandall Stewart /* 1061f8829a4aSRandall Stewart * Ok the one I am dropping onto the end is the 1062f8829a4aSRandall Stewart * NEXT. A bit of valdiation here. 1063f8829a4aSRandall Stewart */ 1064f8829a4aSRandall Stewart if ((prev->rec.data.rcv_flags & SCTP_DATA_FRAG_MASK) == 1065f8829a4aSRandall Stewart SCTP_DATA_FIRST_FRAG || 1066f8829a4aSRandall Stewart (prev->rec.data.rcv_flags & SCTP_DATA_FRAG_MASK) == 1067f8829a4aSRandall Stewart SCTP_DATA_MIDDLE_FRAG) { 1068f8829a4aSRandall Stewart /* 1069f8829a4aSRandall Stewart * Insert chk MUST be a MIDDLE or LAST 1070f8829a4aSRandall Stewart * fragment 1071f8829a4aSRandall Stewart */ 1072f8829a4aSRandall Stewart if ((chk->rec.data.rcv_flags & SCTP_DATA_FRAG_MASK) == 1073f8829a4aSRandall Stewart SCTP_DATA_FIRST_FRAG) { 1074ad81507eSRandall Stewart SCTPDBG(SCTP_DEBUG_INDATA1, "Prev check - It can be a midlle or last but not a first\n"); 1075ad81507eSRandall Stewart SCTPDBG(SCTP_DEBUG_INDATA1, "Gak, Evil plot, it's a FIRST!\n"); 1076139bc87fSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + 3 * sizeof(uint32_t)), 1077f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 1078f8829a4aSRandall Stewart if (oper) { 1079f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 1080f8829a4aSRandall Stewart uint32_t *ippp; 1081f8829a4aSRandall Stewart 1082139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = 1083f8829a4aSRandall Stewart sizeof(struct sctp_paramhdr) + 1084f8829a4aSRandall Stewart (3 * sizeof(uint32_t)); 1085f8829a4aSRandall Stewart ph = mtod(oper, 1086f8829a4aSRandall Stewart struct sctp_paramhdr *); 1087f8829a4aSRandall Stewart ph->param_type = 1088f8829a4aSRandall Stewart htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 1089f8829a4aSRandall Stewart ph->param_length = 1090139bc87fSRandall Stewart htons(SCTP_BUF_LEN(oper)); 1091f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 1092a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_6); 1093f8829a4aSRandall Stewart ippp++; 1094f8829a4aSRandall Stewart *ippp = chk->rec.data.TSN_seq; 1095f8829a4aSRandall Stewart ippp++; 1096f8829a4aSRandall Stewart *ippp = ((chk->rec.data.stream_number << 16) | chk->rec.data.stream_seq); 1097f8829a4aSRandall Stewart 1098f8829a4aSRandall Stewart } 1099a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_6; 1100f8829a4aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, 1101ceaad40aSRandall Stewart stcb, SCTP_PEER_FAULTY, oper, SCTP_SO_NOT_LOCKED); 1102f8829a4aSRandall Stewart *abort_flag = 1; 1103f8829a4aSRandall Stewart return; 1104f8829a4aSRandall Stewart } 1105f8829a4aSRandall Stewart if (chk->rec.data.stream_number != 1106f8829a4aSRandall Stewart prev->rec.data.stream_number) { 1107f8829a4aSRandall Stewart /* 1108f8829a4aSRandall Stewart * Huh, need the correct STR here, 1109f8829a4aSRandall Stewart * they must be the same. 1110f8829a4aSRandall Stewart */ 1111ad81507eSRandall Stewart SCTP_PRINTF("Prev check - Gak, Evil plot, ssn:%d not the same as at:%d\n", 1112f8829a4aSRandall Stewart chk->rec.data.stream_number, 1113f8829a4aSRandall Stewart prev->rec.data.stream_number); 1114139bc87fSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + 3 * sizeof(uint32_t)), 1115f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 1116f8829a4aSRandall Stewart if (oper) { 1117f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 1118f8829a4aSRandall Stewart uint32_t *ippp; 1119f8829a4aSRandall Stewart 1120139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = 1121f8829a4aSRandall Stewart sizeof(struct sctp_paramhdr) + 1122f8829a4aSRandall Stewart (3 * sizeof(uint32_t)); 1123f8829a4aSRandall Stewart ph = mtod(oper, 1124f8829a4aSRandall Stewart struct sctp_paramhdr *); 1125f8829a4aSRandall Stewart ph->param_type = 1126f8829a4aSRandall Stewart htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 1127f8829a4aSRandall Stewart ph->param_length = 1128139bc87fSRandall Stewart htons(SCTP_BUF_LEN(oper)); 1129f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 1130a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_7); 1131f8829a4aSRandall Stewart ippp++; 1132f8829a4aSRandall Stewart *ippp = chk->rec.data.TSN_seq; 1133f8829a4aSRandall Stewart ippp++; 1134f8829a4aSRandall Stewart *ippp = ((chk->rec.data.stream_number << 16) | chk->rec.data.stream_seq); 1135f8829a4aSRandall Stewart } 1136a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_7; 1137f8829a4aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, 1138ceaad40aSRandall Stewart stcb, SCTP_PEER_FAULTY, oper, SCTP_SO_NOT_LOCKED); 1139f8829a4aSRandall Stewart 1140f8829a4aSRandall Stewart *abort_flag = 1; 1141f8829a4aSRandall Stewart return; 1142f8829a4aSRandall Stewart } 1143f8829a4aSRandall Stewart if ((prev->rec.data.rcv_flags & SCTP_DATA_UNORDERED) == 0 && 1144f8829a4aSRandall Stewart chk->rec.data.stream_seq != 1145f8829a4aSRandall Stewart prev->rec.data.stream_seq) { 1146f8829a4aSRandall Stewart /* 1147f8829a4aSRandall Stewart * Huh, need the correct STR here, 1148f8829a4aSRandall Stewart * they must be the same. 1149f8829a4aSRandall Stewart */ 1150ad81507eSRandall Stewart SCTPDBG(SCTP_DEBUG_INDATA1, "Prev check - Gak, Evil plot, sseq:%d not the same as at:%d\n", 1151f8829a4aSRandall Stewart chk->rec.data.stream_seq, 1152f8829a4aSRandall Stewart prev->rec.data.stream_seq); 1153139bc87fSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + 3 * sizeof(uint32_t)), 1154f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 1155f8829a4aSRandall Stewart if (oper) { 1156f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 1157f8829a4aSRandall Stewart uint32_t *ippp; 1158f8829a4aSRandall Stewart 1159139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = 1160f8829a4aSRandall Stewart sizeof(struct sctp_paramhdr) + 1161f8829a4aSRandall Stewart (3 * sizeof(uint32_t)); 1162f8829a4aSRandall Stewart ph = mtod(oper, 1163f8829a4aSRandall Stewart struct sctp_paramhdr *); 1164f8829a4aSRandall Stewart ph->param_type = 1165f8829a4aSRandall Stewart htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 1166f8829a4aSRandall Stewart ph->param_length = 1167139bc87fSRandall Stewart htons(SCTP_BUF_LEN(oper)); 1168f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 1169a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_8); 1170f8829a4aSRandall Stewart ippp++; 1171f8829a4aSRandall Stewart *ippp = chk->rec.data.TSN_seq; 1172f8829a4aSRandall Stewart ippp++; 1173f8829a4aSRandall Stewart *ippp = ((chk->rec.data.stream_number << 16) | chk->rec.data.stream_seq); 1174f8829a4aSRandall Stewart } 1175a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_8; 1176f8829a4aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, 1177ceaad40aSRandall Stewart stcb, SCTP_PEER_FAULTY, oper, SCTP_SO_NOT_LOCKED); 1178f8829a4aSRandall Stewart 1179f8829a4aSRandall Stewart *abort_flag = 1; 1180f8829a4aSRandall Stewart return; 1181f8829a4aSRandall Stewart } 1182f8829a4aSRandall Stewart } else if ((prev->rec.data.rcv_flags & SCTP_DATA_FRAG_MASK) == 1183f8829a4aSRandall Stewart SCTP_DATA_LAST_FRAG) { 1184f8829a4aSRandall Stewart /* Insert chk MUST be a FIRST */ 1185f8829a4aSRandall Stewart if ((chk->rec.data.rcv_flags & SCTP_DATA_FRAG_MASK) != 1186f8829a4aSRandall Stewart SCTP_DATA_FIRST_FRAG) { 1187ad81507eSRandall Stewart SCTPDBG(SCTP_DEBUG_INDATA1, "Prev check - Gak, evil plot, its not FIRST and it must be!\n"); 1188139bc87fSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + 3 * sizeof(uint32_t)), 1189f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 1190f8829a4aSRandall Stewart if (oper) { 1191f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 1192f8829a4aSRandall Stewart uint32_t *ippp; 1193f8829a4aSRandall Stewart 1194139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = 1195f8829a4aSRandall Stewart sizeof(struct sctp_paramhdr) + 1196f8829a4aSRandall Stewart (3 * sizeof(uint32_t)); 1197f8829a4aSRandall Stewart ph = mtod(oper, 1198f8829a4aSRandall Stewart struct sctp_paramhdr *); 1199f8829a4aSRandall Stewart ph->param_type = 1200f8829a4aSRandall Stewart htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 1201f8829a4aSRandall Stewart ph->param_length = 1202139bc87fSRandall Stewart htons(SCTP_BUF_LEN(oper)); 1203f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 1204a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_9); 1205f8829a4aSRandall Stewart ippp++; 1206f8829a4aSRandall Stewart *ippp = chk->rec.data.TSN_seq; 1207f8829a4aSRandall Stewart ippp++; 1208f8829a4aSRandall Stewart *ippp = ((chk->rec.data.stream_number << 16) | chk->rec.data.stream_seq); 1209f8829a4aSRandall Stewart 1210f8829a4aSRandall Stewart } 1211a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_9; 1212f8829a4aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, 1213ceaad40aSRandall Stewart stcb, SCTP_PEER_FAULTY, oper, SCTP_SO_NOT_LOCKED); 1214f8829a4aSRandall Stewart 1215f8829a4aSRandall Stewart *abort_flag = 1; 1216f8829a4aSRandall Stewart return; 1217f8829a4aSRandall Stewart } 1218f8829a4aSRandall Stewart } 1219f8829a4aSRandall Stewart } 1220f8829a4aSRandall Stewart } 1221f8829a4aSRandall Stewart if (next) { 1222f8829a4aSRandall Stewart post_tsn = chk->rec.data.TSN_seq + 1; 1223f8829a4aSRandall Stewart if (post_tsn == next->rec.data.TSN_seq) { 1224f8829a4aSRandall Stewart /* 1225f8829a4aSRandall Stewart * Ok the one I am inserting ahead of is my NEXT 1226f8829a4aSRandall Stewart * one. A bit of valdiation here. 1227f8829a4aSRandall Stewart */ 1228f8829a4aSRandall Stewart if (next->rec.data.rcv_flags & SCTP_DATA_FIRST_FRAG) { 1229f8829a4aSRandall Stewart /* Insert chk MUST be a last fragment */ 1230f8829a4aSRandall Stewart if ((chk->rec.data.rcv_flags & SCTP_DATA_FRAG_MASK) 1231f8829a4aSRandall Stewart != SCTP_DATA_LAST_FRAG) { 1232ad81507eSRandall Stewart SCTPDBG(SCTP_DEBUG_INDATA1, "Next chk - Next is FIRST, we must be LAST\n"); 1233ad81507eSRandall Stewart SCTPDBG(SCTP_DEBUG_INDATA1, "Gak, Evil plot, its not a last!\n"); 1234139bc87fSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + 3 * sizeof(uint32_t)), 1235f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 1236f8829a4aSRandall Stewart if (oper) { 1237f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 1238f8829a4aSRandall Stewart uint32_t *ippp; 1239f8829a4aSRandall Stewart 1240139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = 1241f8829a4aSRandall Stewart sizeof(struct sctp_paramhdr) + 1242f8829a4aSRandall Stewart (3 * sizeof(uint32_t)); 1243f8829a4aSRandall Stewart ph = mtod(oper, 1244f8829a4aSRandall Stewart struct sctp_paramhdr *); 1245f8829a4aSRandall Stewart ph->param_type = 1246f8829a4aSRandall Stewart htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 1247f8829a4aSRandall Stewart ph->param_length = 1248139bc87fSRandall Stewart htons(SCTP_BUF_LEN(oper)); 1249f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 1250a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_10); 1251f8829a4aSRandall Stewart ippp++; 1252f8829a4aSRandall Stewart *ippp = chk->rec.data.TSN_seq; 1253f8829a4aSRandall Stewart ippp++; 1254f8829a4aSRandall Stewart *ippp = ((chk->rec.data.stream_number << 16) | chk->rec.data.stream_seq); 1255f8829a4aSRandall Stewart } 1256a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_10; 1257f8829a4aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, 1258ceaad40aSRandall Stewart stcb, SCTP_PEER_FAULTY, oper, SCTP_SO_NOT_LOCKED); 1259f8829a4aSRandall Stewart 1260f8829a4aSRandall Stewart *abort_flag = 1; 1261f8829a4aSRandall Stewart return; 1262f8829a4aSRandall Stewart } 1263f8829a4aSRandall Stewart } else if ((next->rec.data.rcv_flags & SCTP_DATA_FRAG_MASK) == 1264f8829a4aSRandall Stewart SCTP_DATA_MIDDLE_FRAG || 1265f8829a4aSRandall Stewart (next->rec.data.rcv_flags & SCTP_DATA_FRAG_MASK) == 1266f8829a4aSRandall Stewart SCTP_DATA_LAST_FRAG) { 1267f8829a4aSRandall Stewart /* 1268f8829a4aSRandall Stewart * Insert chk CAN be MIDDLE or FIRST NOT 1269f8829a4aSRandall Stewart * LAST 1270f8829a4aSRandall Stewart */ 1271f8829a4aSRandall Stewart if ((chk->rec.data.rcv_flags & SCTP_DATA_FRAG_MASK) == 1272f8829a4aSRandall Stewart SCTP_DATA_LAST_FRAG) { 1273ad81507eSRandall Stewart SCTPDBG(SCTP_DEBUG_INDATA1, "Next chk - Next is a MIDDLE/LAST\n"); 1274ad81507eSRandall Stewart SCTPDBG(SCTP_DEBUG_INDATA1, "Gak, Evil plot, new prev chunk is a LAST\n"); 1275139bc87fSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + 3 * sizeof(uint32_t)), 1276f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 1277f8829a4aSRandall Stewart if (oper) { 1278f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 1279f8829a4aSRandall Stewart uint32_t *ippp; 1280f8829a4aSRandall Stewart 1281139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = 1282f8829a4aSRandall Stewart sizeof(struct sctp_paramhdr) + 1283f8829a4aSRandall Stewart (3 * sizeof(uint32_t)); 1284f8829a4aSRandall Stewart ph = mtod(oper, 1285f8829a4aSRandall Stewart struct sctp_paramhdr *); 1286f8829a4aSRandall Stewart ph->param_type = 1287f8829a4aSRandall Stewart htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 1288f8829a4aSRandall Stewart ph->param_length = 1289139bc87fSRandall Stewart htons(SCTP_BUF_LEN(oper)); 1290f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 1291a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_11); 1292f8829a4aSRandall Stewart ippp++; 1293f8829a4aSRandall Stewart *ippp = chk->rec.data.TSN_seq; 1294f8829a4aSRandall Stewart ippp++; 1295f8829a4aSRandall Stewart *ippp = ((chk->rec.data.stream_number << 16) | chk->rec.data.stream_seq); 1296f8829a4aSRandall Stewart 1297f8829a4aSRandall Stewart } 1298a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_11; 1299f8829a4aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, 1300ceaad40aSRandall Stewart stcb, SCTP_PEER_FAULTY, oper, SCTP_SO_NOT_LOCKED); 1301f8829a4aSRandall Stewart 1302f8829a4aSRandall Stewart *abort_flag = 1; 1303f8829a4aSRandall Stewart return; 1304f8829a4aSRandall Stewart } 1305f8829a4aSRandall Stewart if (chk->rec.data.stream_number != 1306f8829a4aSRandall Stewart next->rec.data.stream_number) { 1307f8829a4aSRandall Stewart /* 1308f8829a4aSRandall Stewart * Huh, need the correct STR here, 1309f8829a4aSRandall Stewart * they must be the same. 1310f8829a4aSRandall Stewart */ 1311ad81507eSRandall Stewart SCTPDBG(SCTP_DEBUG_INDATA1, "Next chk - Gak, Evil plot, ssn:%d not the same as at:%d\n", 1312f8829a4aSRandall Stewart chk->rec.data.stream_number, 1313f8829a4aSRandall Stewart next->rec.data.stream_number); 1314139bc87fSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + 3 * sizeof(uint32_t)), 1315f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 1316f8829a4aSRandall Stewart if (oper) { 1317f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 1318f8829a4aSRandall Stewart uint32_t *ippp; 1319f8829a4aSRandall Stewart 1320139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = 1321f8829a4aSRandall Stewart sizeof(struct sctp_paramhdr) + 1322f8829a4aSRandall Stewart (3 * sizeof(uint32_t)); 1323f8829a4aSRandall Stewart ph = mtod(oper, 1324f8829a4aSRandall Stewart struct sctp_paramhdr *); 1325f8829a4aSRandall Stewart ph->param_type = 1326f8829a4aSRandall Stewart htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 1327f8829a4aSRandall Stewart ph->param_length = 1328139bc87fSRandall Stewart htons(SCTP_BUF_LEN(oper)); 1329f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 1330a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_12); 1331f8829a4aSRandall Stewart ippp++; 1332f8829a4aSRandall Stewart *ippp = chk->rec.data.TSN_seq; 1333f8829a4aSRandall Stewart ippp++; 1334f8829a4aSRandall Stewart *ippp = ((chk->rec.data.stream_number << 16) | chk->rec.data.stream_seq); 1335f8829a4aSRandall Stewart 1336f8829a4aSRandall Stewart } 1337a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_12; 1338f8829a4aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, 1339ceaad40aSRandall Stewart stcb, SCTP_PEER_FAULTY, oper, SCTP_SO_NOT_LOCKED); 1340f8829a4aSRandall Stewart 1341f8829a4aSRandall Stewart *abort_flag = 1; 1342f8829a4aSRandall Stewart return; 1343f8829a4aSRandall Stewart } 1344f8829a4aSRandall Stewart if ((next->rec.data.rcv_flags & SCTP_DATA_UNORDERED) == 0 && 1345f8829a4aSRandall Stewart chk->rec.data.stream_seq != 1346f8829a4aSRandall Stewart next->rec.data.stream_seq) { 1347f8829a4aSRandall Stewart /* 1348f8829a4aSRandall Stewart * Huh, need the correct STR here, 1349f8829a4aSRandall Stewart * they must be the same. 1350f8829a4aSRandall Stewart */ 1351ad81507eSRandall Stewart SCTPDBG(SCTP_DEBUG_INDATA1, "Next chk - Gak, Evil plot, sseq:%d not the same as at:%d\n", 1352f8829a4aSRandall Stewart chk->rec.data.stream_seq, 1353f8829a4aSRandall Stewart next->rec.data.stream_seq); 1354139bc87fSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + 3 * sizeof(uint32_t)), 1355f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 1356f8829a4aSRandall Stewart if (oper) { 1357f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 1358f8829a4aSRandall Stewart uint32_t *ippp; 1359f8829a4aSRandall Stewart 1360139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = 1361f8829a4aSRandall Stewart sizeof(struct sctp_paramhdr) + 1362f8829a4aSRandall Stewart (3 * sizeof(uint32_t)); 1363f8829a4aSRandall Stewart ph = mtod(oper, 1364f8829a4aSRandall Stewart struct sctp_paramhdr *); 1365f8829a4aSRandall Stewart ph->param_type = 1366f8829a4aSRandall Stewart htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 1367f8829a4aSRandall Stewart ph->param_length = 1368139bc87fSRandall Stewart htons(SCTP_BUF_LEN(oper)); 1369f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 1370a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_13); 1371f8829a4aSRandall Stewart ippp++; 1372f8829a4aSRandall Stewart *ippp = chk->rec.data.TSN_seq; 1373f8829a4aSRandall Stewart ippp++; 1374f8829a4aSRandall Stewart *ippp = ((chk->rec.data.stream_number << 16) | chk->rec.data.stream_seq); 1375f8829a4aSRandall Stewart } 1376a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_13; 1377f8829a4aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, 1378ceaad40aSRandall Stewart stcb, SCTP_PEER_FAULTY, oper, SCTP_SO_NOT_LOCKED); 1379f8829a4aSRandall Stewart 1380f8829a4aSRandall Stewart *abort_flag = 1; 1381f8829a4aSRandall Stewart return; 1382f8829a4aSRandall Stewart } 1383f8829a4aSRandall Stewart } 1384f8829a4aSRandall Stewart } 1385f8829a4aSRandall Stewart } 1386f8829a4aSRandall Stewart /* Do we need to do some delivery? check */ 1387f8829a4aSRandall Stewart sctp_deliver_reasm_check(stcb, asoc); 1388f8829a4aSRandall Stewart } 1389f8829a4aSRandall Stewart 1390f8829a4aSRandall Stewart /* 1391f8829a4aSRandall Stewart * This is an unfortunate routine. It checks to make sure a evil guy is not 1392f8829a4aSRandall Stewart * stuffing us full of bad packet fragments. A broken peer could also do this 1393f8829a4aSRandall Stewart * but this is doubtful. It is to bad I must worry about evil crackers sigh 1394f8829a4aSRandall Stewart * :< more cycles. 1395f8829a4aSRandall Stewart */ 1396f8829a4aSRandall Stewart static int 1397f8829a4aSRandall Stewart sctp_does_tsn_belong_to_reasm(struct sctp_association *asoc, 1398f8829a4aSRandall Stewart uint32_t TSN_seq) 1399f8829a4aSRandall Stewart { 1400f8829a4aSRandall Stewart struct sctp_tmit_chunk *at; 1401f8829a4aSRandall Stewart uint32_t tsn_est; 1402f8829a4aSRandall Stewart 1403f8829a4aSRandall Stewart TAILQ_FOREACH(at, &asoc->reasmqueue, sctp_next) { 1404f8829a4aSRandall Stewart if (compare_with_wrap(TSN_seq, 1405f8829a4aSRandall Stewart at->rec.data.TSN_seq, MAX_TSN)) { 1406f8829a4aSRandall Stewart /* is it one bigger? */ 1407f8829a4aSRandall Stewart tsn_est = at->rec.data.TSN_seq + 1; 1408f8829a4aSRandall Stewart if (tsn_est == TSN_seq) { 1409f8829a4aSRandall Stewart /* yep. It better be a last then */ 1410f8829a4aSRandall Stewart if ((at->rec.data.rcv_flags & SCTP_DATA_FRAG_MASK) != 1411f8829a4aSRandall Stewart SCTP_DATA_LAST_FRAG) { 1412f8829a4aSRandall Stewart /* 1413f8829a4aSRandall Stewart * Ok this guy belongs next to a guy 1414f8829a4aSRandall Stewart * that is NOT last, it should be a 1415f8829a4aSRandall Stewart * middle/last, not a complete 1416f8829a4aSRandall Stewart * chunk. 1417f8829a4aSRandall Stewart */ 1418f8829a4aSRandall Stewart return (1); 1419f8829a4aSRandall Stewart } else { 1420f8829a4aSRandall Stewart /* 1421f8829a4aSRandall Stewart * This guy is ok since its a LAST 1422f8829a4aSRandall Stewart * and the new chunk is a fully 1423f8829a4aSRandall Stewart * self- contained one. 1424f8829a4aSRandall Stewart */ 1425f8829a4aSRandall Stewart return (0); 1426f8829a4aSRandall Stewart } 1427f8829a4aSRandall Stewart } 1428f8829a4aSRandall Stewart } else if (TSN_seq == at->rec.data.TSN_seq) { 1429f8829a4aSRandall Stewart /* Software error since I have a dup? */ 1430f8829a4aSRandall Stewart return (1); 1431f8829a4aSRandall Stewart } else { 1432f8829a4aSRandall Stewart /* 1433f8829a4aSRandall Stewart * Ok, 'at' is larger than new chunk but does it 1434f8829a4aSRandall Stewart * need to be right before it. 1435f8829a4aSRandall Stewart */ 1436f8829a4aSRandall Stewart tsn_est = TSN_seq + 1; 1437f8829a4aSRandall Stewart if (tsn_est == at->rec.data.TSN_seq) { 1438f8829a4aSRandall Stewart /* Yep, It better be a first */ 1439f8829a4aSRandall Stewart if ((at->rec.data.rcv_flags & SCTP_DATA_FRAG_MASK) != 1440f8829a4aSRandall Stewart SCTP_DATA_FIRST_FRAG) { 1441f8829a4aSRandall Stewart return (1); 1442f8829a4aSRandall Stewart } else { 1443f8829a4aSRandall Stewart return (0); 1444f8829a4aSRandall Stewart } 1445f8829a4aSRandall Stewart } 1446f8829a4aSRandall Stewart } 1447f8829a4aSRandall Stewart } 1448f8829a4aSRandall Stewart return (0); 1449f8829a4aSRandall Stewart } 1450f8829a4aSRandall Stewart 1451f8829a4aSRandall Stewart 1452f8829a4aSRandall Stewart static int 1453f8829a4aSRandall Stewart sctp_process_a_data_chunk(struct sctp_tcb *stcb, struct sctp_association *asoc, 1454f8829a4aSRandall Stewart struct mbuf **m, int offset, struct sctp_data_chunk *ch, int chk_length, 1455f8829a4aSRandall Stewart struct sctp_nets *net, uint32_t * high_tsn, int *abort_flag, 1456f8829a4aSRandall Stewart int *break_flag, int last_chunk) 1457f8829a4aSRandall Stewart { 1458f8829a4aSRandall Stewart /* Process a data chunk */ 1459f8829a4aSRandall Stewart /* struct sctp_tmit_chunk *chk; */ 1460f8829a4aSRandall Stewart struct sctp_tmit_chunk *chk; 1461f8829a4aSRandall Stewart uint32_t tsn, gap; 1462f8829a4aSRandall Stewart struct mbuf *dmbuf; 1463f8829a4aSRandall Stewart int indx, the_len; 1464139bc87fSRandall Stewart int need_reasm_check = 0; 1465f8829a4aSRandall Stewart uint16_t strmno, strmseq; 1466f8829a4aSRandall Stewart struct mbuf *oper; 1467f8829a4aSRandall Stewart struct sctp_queued_to_read *control; 1468f42a358aSRandall Stewart int ordered; 1469f42a358aSRandall Stewart uint32_t protocol_id; 1470f42a358aSRandall Stewart uint8_t chunk_flags; 147117205eccSRandall Stewart struct sctp_stream_reset_list *liste; 1472f8829a4aSRandall Stewart 1473f8829a4aSRandall Stewart chk = NULL; 1474f8829a4aSRandall Stewart tsn = ntohl(ch->dp.tsn); 1475f42a358aSRandall Stewart chunk_flags = ch->ch.chunk_flags; 1476b3f1ea41SRandall Stewart if ((chunk_flags & SCTP_DATA_SACK_IMMEDIATELY) == SCTP_DATA_SACK_IMMEDIATELY) { 1477b3f1ea41SRandall Stewart asoc->send_sack = 1; 1478b3f1ea41SRandall Stewart } 1479f42a358aSRandall Stewart protocol_id = ch->dp.protocol_id; 148037f144ebSMichael Tuexen ordered = ((chunk_flags & SCTP_DATA_UNORDERED) == 0); 1481b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_MAP_LOGGING_ENABLE) { 1482c4739e2fSRandall Stewart sctp_log_map(tsn, asoc->cumulative_tsn, asoc->highest_tsn_inside_map, SCTP_MAP_TSN_ENTERS); 148380fefe0aSRandall Stewart } 1484ad81507eSRandall Stewart if (stcb == NULL) { 1485ad81507eSRandall Stewart return (0); 1486ad81507eSRandall Stewart } 148780fefe0aSRandall Stewart SCTP_LTRACE_CHK(stcb->sctp_ep, stcb, ch->ch.chunk_type, tsn); 1488f8829a4aSRandall Stewart if (compare_with_wrap(asoc->cumulative_tsn, tsn, MAX_TSN) || 1489f8829a4aSRandall Stewart asoc->cumulative_tsn == tsn) { 1490f8829a4aSRandall Stewart /* It is a duplicate */ 1491f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_recvdupdata); 1492f8829a4aSRandall Stewart if (asoc->numduptsns < SCTP_MAX_DUP_TSNS) { 1493f8829a4aSRandall Stewart /* Record a dup for the next outbound sack */ 1494f8829a4aSRandall Stewart asoc->dup_tsns[asoc->numduptsns] = tsn; 1495f8829a4aSRandall Stewart asoc->numduptsns++; 1496f8829a4aSRandall Stewart } 1497b201f536SRandall Stewart asoc->send_sack = 1; 1498f8829a4aSRandall Stewart return (0); 1499f8829a4aSRandall Stewart } 1500f8829a4aSRandall Stewart /* Calculate the number of TSN's between the base and this TSN */ 1501d50c1d79SRandall Stewart SCTP_CALC_TSN_TO_GAP(gap, tsn, asoc->mapping_array_base_tsn); 1502f8829a4aSRandall Stewart if (gap >= (SCTP_MAPPING_ARRAY << 3)) { 1503f8829a4aSRandall Stewart /* Can't hold the bit in the mapping at max array, toss it */ 1504f8829a4aSRandall Stewart return (0); 1505f8829a4aSRandall Stewart } 1506f8829a4aSRandall Stewart if (gap >= (uint32_t) (asoc->mapping_array_size << 3)) { 1507207304d4SRandall Stewart SCTP_TCB_LOCK_ASSERT(stcb); 15080696e120SRandall Stewart if (sctp_expand_mapping_array(asoc, gap)) { 1509f8829a4aSRandall Stewart /* Can't expand, drop it */ 1510f8829a4aSRandall Stewart return (0); 1511f8829a4aSRandall Stewart } 1512f8829a4aSRandall Stewart } 1513f8829a4aSRandall Stewart if (compare_with_wrap(tsn, *high_tsn, MAX_TSN)) { 1514f8829a4aSRandall Stewart *high_tsn = tsn; 1515f8829a4aSRandall Stewart } 1516f8829a4aSRandall Stewart /* See if we have received this one already */ 151777acdc25SRandall Stewart if (SCTP_IS_TSN_PRESENT(asoc->mapping_array, gap) || 151877acdc25SRandall Stewart SCTP_IS_TSN_PRESENT(asoc->nr_mapping_array, gap)) { 1519f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_recvdupdata); 1520f8829a4aSRandall Stewart if (asoc->numduptsns < SCTP_MAX_DUP_TSNS) { 1521f8829a4aSRandall Stewart /* Record a dup for the next outbound sack */ 1522f8829a4aSRandall Stewart asoc->dup_tsns[asoc->numduptsns] = tsn; 1523f8829a4aSRandall Stewart asoc->numduptsns++; 1524f8829a4aSRandall Stewart } 152542551e99SRandall Stewart asoc->send_sack = 1; 1526f8829a4aSRandall Stewart return (0); 1527f8829a4aSRandall Stewart } 1528f8829a4aSRandall Stewart /* 1529f8829a4aSRandall Stewart * Check to see about the GONE flag, duplicates would cause a sack 1530f8829a4aSRandall Stewart * to be sent up above 1531f8829a4aSRandall Stewart */ 1532ad81507eSRandall Stewart if (((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) || 1533f8829a4aSRandall Stewart (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_ALLGONE) || 1534f8829a4aSRandall Stewart (stcb->asoc.state & SCTP_STATE_CLOSED_SOCKET)) 1535f8829a4aSRandall Stewart ) { 1536f8829a4aSRandall Stewart /* 1537f8829a4aSRandall Stewart * wait a minute, this guy is gone, there is no longer a 1538f8829a4aSRandall Stewart * receiver. Send peer an ABORT! 1539f8829a4aSRandall Stewart */ 1540f8829a4aSRandall Stewart struct mbuf *op_err; 1541f8829a4aSRandall Stewart 1542f8829a4aSRandall Stewart op_err = sctp_generate_invmanparam(SCTP_CAUSE_OUT_OF_RESC); 1543ceaad40aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, stcb, 0, op_err, SCTP_SO_NOT_LOCKED); 1544f8829a4aSRandall Stewart *abort_flag = 1; 1545f8829a4aSRandall Stewart return (0); 1546f8829a4aSRandall Stewart } 1547f8829a4aSRandall Stewart /* 1548f8829a4aSRandall Stewart * Now before going further we see if there is room. If NOT then we 1549f8829a4aSRandall Stewart * MAY let one through only IF this TSN is the one we are waiting 1550f8829a4aSRandall Stewart * for on a partial delivery API. 1551f8829a4aSRandall Stewart */ 1552f8829a4aSRandall Stewart 1553f8829a4aSRandall Stewart /* now do the tests */ 1554f8829a4aSRandall Stewart if (((asoc->cnt_on_all_streams + 1555f8829a4aSRandall Stewart asoc->cnt_on_reasm_queue + 1556b3f1ea41SRandall Stewart asoc->cnt_msg_on_sb) >= SCTP_BASE_SYSCTL(sctp_max_chunks_on_queue)) || 1557f8829a4aSRandall Stewart (((int)asoc->my_rwnd) <= 0)) { 1558f8829a4aSRandall Stewart /* 1559f8829a4aSRandall Stewart * When we have NO room in the rwnd we check to make sure 1560f8829a4aSRandall Stewart * the reader is doing its job... 1561f8829a4aSRandall Stewart */ 1562f8829a4aSRandall Stewart if (stcb->sctp_socket->so_rcv.sb_cc) { 1563f8829a4aSRandall Stewart /* some to read, wake-up */ 1564ceaad40aSRandall Stewart #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 1565ceaad40aSRandall Stewart struct socket *so; 1566ceaad40aSRandall Stewart 1567ceaad40aSRandall Stewart so = SCTP_INP_SO(stcb->sctp_ep); 1568ceaad40aSRandall Stewart atomic_add_int(&stcb->asoc.refcnt, 1); 1569ceaad40aSRandall Stewart SCTP_TCB_UNLOCK(stcb); 1570ceaad40aSRandall Stewart SCTP_SOCKET_LOCK(so, 1); 1571ceaad40aSRandall Stewart SCTP_TCB_LOCK(stcb); 1572ceaad40aSRandall Stewart atomic_subtract_int(&stcb->asoc.refcnt, 1); 1573ceaad40aSRandall Stewart if (stcb->asoc.state & SCTP_STATE_CLOSED_SOCKET) { 1574ceaad40aSRandall Stewart /* assoc was freed while we were unlocked */ 1575ceaad40aSRandall Stewart SCTP_SOCKET_UNLOCK(so, 1); 1576ceaad40aSRandall Stewart return (0); 1577ceaad40aSRandall Stewart } 1578ceaad40aSRandall Stewart #endif 1579f8829a4aSRandall Stewart sctp_sorwakeup(stcb->sctp_ep, stcb->sctp_socket); 1580ceaad40aSRandall Stewart #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 1581ceaad40aSRandall Stewart SCTP_SOCKET_UNLOCK(so, 1); 1582ceaad40aSRandall Stewart #endif 1583f8829a4aSRandall Stewart } 1584f8829a4aSRandall Stewart /* now is it in the mapping array of what we have accepted? */ 158577acdc25SRandall Stewart if (compare_with_wrap(tsn, asoc->highest_tsn_inside_map, MAX_TSN) && 158677acdc25SRandall Stewart compare_with_wrap(tsn, asoc->highest_tsn_inside_nr_map, MAX_TSN)) { 1587f8829a4aSRandall Stewart /* Nope not in the valid range dump it */ 1588f8829a4aSRandall Stewart sctp_set_rwnd(stcb, asoc); 1589f8829a4aSRandall Stewart if ((asoc->cnt_on_all_streams + 1590f8829a4aSRandall Stewart asoc->cnt_on_reasm_queue + 1591b3f1ea41SRandall Stewart asoc->cnt_msg_on_sb) >= SCTP_BASE_SYSCTL(sctp_max_chunks_on_queue)) { 1592f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_datadropchklmt); 1593f8829a4aSRandall Stewart } else { 1594f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_datadroprwnd); 1595f8829a4aSRandall Stewart } 1596f8829a4aSRandall Stewart indx = *break_flag; 1597f8829a4aSRandall Stewart *break_flag = 1; 1598f8829a4aSRandall Stewart return (0); 1599f8829a4aSRandall Stewart } 1600f8829a4aSRandall Stewart } 1601f8829a4aSRandall Stewart strmno = ntohs(ch->dp.stream_id); 1602f8829a4aSRandall Stewart if (strmno >= asoc->streamincnt) { 1603f8829a4aSRandall Stewart struct sctp_paramhdr *phdr; 1604f8829a4aSRandall Stewart struct mbuf *mb; 1605f8829a4aSRandall Stewart 1606f8829a4aSRandall Stewart mb = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) * 2), 1607139bc87fSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 1608f8829a4aSRandall Stewart if (mb != NULL) { 1609f8829a4aSRandall Stewart /* add some space up front so prepend will work well */ 1610139bc87fSRandall Stewart SCTP_BUF_RESV_UF(mb, sizeof(struct sctp_chunkhdr)); 1611f8829a4aSRandall Stewart phdr = mtod(mb, struct sctp_paramhdr *); 1612f8829a4aSRandall Stewart /* 1613f8829a4aSRandall Stewart * Error causes are just param's and this one has 1614f8829a4aSRandall Stewart * two back to back phdr, one with the error type 1615f8829a4aSRandall Stewart * and size, the other with the streamid and a rsvd 1616f8829a4aSRandall Stewart */ 1617139bc87fSRandall Stewart SCTP_BUF_LEN(mb) = (sizeof(struct sctp_paramhdr) * 2); 1618f8829a4aSRandall Stewart phdr->param_type = htons(SCTP_CAUSE_INVALID_STREAM); 1619f8829a4aSRandall Stewart phdr->param_length = 1620f8829a4aSRandall Stewart htons(sizeof(struct sctp_paramhdr) * 2); 1621f8829a4aSRandall Stewart phdr++; 1622f8829a4aSRandall Stewart /* We insert the stream in the type field */ 1623f8829a4aSRandall Stewart phdr->param_type = ch->dp.stream_id; 1624f8829a4aSRandall Stewart /* And set the length to 0 for the rsvd field */ 1625f8829a4aSRandall Stewart phdr->param_length = 0; 1626f8829a4aSRandall Stewart sctp_queue_op_err(stcb, mb); 1627f8829a4aSRandall Stewart } 1628f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_badsid); 1629207304d4SRandall Stewart SCTP_TCB_LOCK_ASSERT(stcb); 1630830d754dSRandall Stewart SCTP_SET_TSN_PRESENT(asoc->nr_mapping_array, gap); 163177acdc25SRandall Stewart if (compare_with_wrap(tsn, asoc->highest_tsn_inside_nr_map, MAX_TSN)) { 1632830d754dSRandall Stewart asoc->highest_tsn_inside_nr_map = tsn; 1633d06c82f1SRandall Stewart } 1634d06c82f1SRandall Stewart if (tsn == (asoc->cumulative_tsn + 1)) { 1635d06c82f1SRandall Stewart /* Update cum-ack */ 1636d06c82f1SRandall Stewart asoc->cumulative_tsn = tsn; 1637d06c82f1SRandall Stewart } 1638f8829a4aSRandall Stewart return (0); 1639f8829a4aSRandall Stewart } 1640f8829a4aSRandall Stewart /* 1641f8829a4aSRandall Stewart * Before we continue lets validate that we are not being fooled by 1642f8829a4aSRandall Stewart * an evil attacker. We can only have 4k chunks based on our TSN 1643f8829a4aSRandall Stewart * spread allowed by the mapping array 512 * 8 bits, so there is no 1644f8829a4aSRandall Stewart * way our stream sequence numbers could have wrapped. We of course 1645f8829a4aSRandall Stewart * only validate the FIRST fragment so the bit must be set. 1646f8829a4aSRandall Stewart */ 1647f8829a4aSRandall Stewart strmseq = ntohs(ch->dp.stream_sequence); 1648f42a358aSRandall Stewart #ifdef SCTP_ASOCLOG_OF_TSNS 164918e198d3SRandall Stewart SCTP_TCB_LOCK_ASSERT(stcb); 165018e198d3SRandall Stewart if (asoc->tsn_in_at >= SCTP_TSN_LOG_SIZE) { 165118e198d3SRandall Stewart asoc->tsn_in_at = 0; 165218e198d3SRandall Stewart asoc->tsn_in_wrapped = 1; 165318e198d3SRandall Stewart } 1654f42a358aSRandall Stewart asoc->in_tsnlog[asoc->tsn_in_at].tsn = tsn; 1655f42a358aSRandall Stewart asoc->in_tsnlog[asoc->tsn_in_at].strm = strmno; 1656f42a358aSRandall Stewart asoc->in_tsnlog[asoc->tsn_in_at].seq = strmseq; 1657f1f73e57SRandall Stewart asoc->in_tsnlog[asoc->tsn_in_at].sz = chk_length; 1658f1f73e57SRandall Stewart asoc->in_tsnlog[asoc->tsn_in_at].flgs = chunk_flags; 165918e198d3SRandall Stewart asoc->in_tsnlog[asoc->tsn_in_at].stcb = (void *)stcb; 166018e198d3SRandall Stewart asoc->in_tsnlog[asoc->tsn_in_at].in_pos = asoc->tsn_in_at; 166118e198d3SRandall Stewart asoc->in_tsnlog[asoc->tsn_in_at].in_out = 1; 1662f42a358aSRandall Stewart asoc->tsn_in_at++; 1663f42a358aSRandall Stewart #endif 1664f42a358aSRandall Stewart if ((chunk_flags & SCTP_DATA_FIRST_FRAG) && 1665d61a0ae0SRandall Stewart (TAILQ_EMPTY(&asoc->resetHead)) && 1666f42a358aSRandall Stewart (chunk_flags & SCTP_DATA_UNORDERED) == 0 && 1667f8829a4aSRandall Stewart (compare_with_wrap(asoc->strmin[strmno].last_sequence_delivered, 1668f8829a4aSRandall Stewart strmseq, MAX_SEQ) || 1669f8829a4aSRandall Stewart asoc->strmin[strmno].last_sequence_delivered == strmseq)) { 1670f8829a4aSRandall Stewart /* The incoming sseq is behind where we last delivered? */ 1671ad81507eSRandall Stewart SCTPDBG(SCTP_DEBUG_INDATA1, "EVIL/Broken-Dup S-SEQ:%d delivered:%d from peer, Abort!\n", 1672ad81507eSRandall Stewart strmseq, asoc->strmin[strmno].last_sequence_delivered); 1673139bc87fSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + 3 * sizeof(uint32_t)), 1674f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 1675f8829a4aSRandall Stewart if (oper) { 1676f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 1677f8829a4aSRandall Stewart uint32_t *ippp; 1678f8829a4aSRandall Stewart 1679139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = sizeof(struct sctp_paramhdr) + 1680f8829a4aSRandall Stewart (3 * sizeof(uint32_t)); 1681f8829a4aSRandall Stewart ph = mtod(oper, struct sctp_paramhdr *); 1682f8829a4aSRandall Stewart ph->param_type = htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 1683139bc87fSRandall Stewart ph->param_length = htons(SCTP_BUF_LEN(oper)); 1684f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 1685a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_14); 1686f8829a4aSRandall Stewart ippp++; 1687f8829a4aSRandall Stewart *ippp = tsn; 1688f8829a4aSRandall Stewart ippp++; 1689f8829a4aSRandall Stewart *ippp = ((strmno << 16) | strmseq); 1690f8829a4aSRandall Stewart 1691f8829a4aSRandall Stewart } 1692a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_14; 1693f8829a4aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, stcb, 1694ceaad40aSRandall Stewart SCTP_PEER_FAULTY, oper, SCTP_SO_NOT_LOCKED); 1695f8829a4aSRandall Stewart *abort_flag = 1; 1696f8829a4aSRandall Stewart return (0); 1697f8829a4aSRandall Stewart } 1698f42a358aSRandall Stewart /************************************ 1699f42a358aSRandall Stewart * From here down we may find ch-> invalid 1700f42a358aSRandall Stewart * so its a good idea NOT to use it. 1701f42a358aSRandall Stewart *************************************/ 1702f42a358aSRandall Stewart 1703f8829a4aSRandall Stewart the_len = (chk_length - sizeof(struct sctp_data_chunk)); 1704f8829a4aSRandall Stewart if (last_chunk == 0) { 170544b7479bSRandall Stewart dmbuf = SCTP_M_COPYM(*m, 1706f8829a4aSRandall Stewart (offset + sizeof(struct sctp_data_chunk)), 1707f8829a4aSRandall Stewart the_len, M_DONTWAIT); 1708f8829a4aSRandall Stewart #ifdef SCTP_MBUF_LOGGING 1709b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_MBUF_LOGGING_ENABLE) { 1710f8829a4aSRandall Stewart struct mbuf *mat; 1711f8829a4aSRandall Stewart 1712f8829a4aSRandall Stewart mat = dmbuf; 1713f8829a4aSRandall Stewart while (mat) { 1714139bc87fSRandall Stewart if (SCTP_BUF_IS_EXTENDED(mat)) { 1715f8829a4aSRandall Stewart sctp_log_mb(mat, SCTP_MBUF_ICOPY); 1716f8829a4aSRandall Stewart } 1717139bc87fSRandall Stewart mat = SCTP_BUF_NEXT(mat); 1718f8829a4aSRandall Stewart } 1719f8829a4aSRandall Stewart } 1720f8829a4aSRandall Stewart #endif 1721f8829a4aSRandall Stewart } else { 1722f8829a4aSRandall Stewart /* We can steal the last chunk */ 1723139bc87fSRandall Stewart int l_len; 1724139bc87fSRandall Stewart 1725f8829a4aSRandall Stewart dmbuf = *m; 1726f8829a4aSRandall Stewart /* lop off the top part */ 1727f8829a4aSRandall Stewart m_adj(dmbuf, (offset + sizeof(struct sctp_data_chunk))); 1728139bc87fSRandall Stewart if (SCTP_BUF_NEXT(dmbuf) == NULL) { 1729139bc87fSRandall Stewart l_len = SCTP_BUF_LEN(dmbuf); 1730139bc87fSRandall Stewart } else { 1731139bc87fSRandall Stewart /* 1732139bc87fSRandall Stewart * need to count up the size hopefully does not hit 1733139bc87fSRandall Stewart * this to often :-0 1734139bc87fSRandall Stewart */ 1735139bc87fSRandall Stewart struct mbuf *lat; 1736139bc87fSRandall Stewart 1737139bc87fSRandall Stewart l_len = 0; 1738139bc87fSRandall Stewart lat = dmbuf; 1739139bc87fSRandall Stewart while (lat) { 1740139bc87fSRandall Stewart l_len += SCTP_BUF_LEN(lat); 1741139bc87fSRandall Stewart lat = SCTP_BUF_NEXT(lat); 1742139bc87fSRandall Stewart } 1743139bc87fSRandall Stewart } 1744139bc87fSRandall Stewart if (l_len > the_len) { 1745f8829a4aSRandall Stewart /* Trim the end round bytes off too */ 1746139bc87fSRandall Stewart m_adj(dmbuf, -(l_len - the_len)); 1747f8829a4aSRandall Stewart } 1748f8829a4aSRandall Stewart } 1749f8829a4aSRandall Stewart if (dmbuf == NULL) { 1750f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_nomem); 1751f8829a4aSRandall Stewart return (0); 1752f8829a4aSRandall Stewart } 1753f42a358aSRandall Stewart if ((chunk_flags & SCTP_DATA_NOT_FRAG) == SCTP_DATA_NOT_FRAG && 1754f8829a4aSRandall Stewart asoc->fragmented_delivery_inprogress == 0 && 1755f8829a4aSRandall Stewart TAILQ_EMPTY(&asoc->resetHead) && 1756f42a358aSRandall Stewart ((ordered == 0) || 175736ec9f81SMichael Tuexen ((uint16_t) (asoc->strmin[strmno].last_sequence_delivered + 1) == strmseq && 1758f8829a4aSRandall Stewart TAILQ_EMPTY(&asoc->strmin[strmno].inqueue)))) { 1759f8829a4aSRandall Stewart /* Candidate for express delivery */ 1760f8829a4aSRandall Stewart /* 1761f8829a4aSRandall Stewart * Its not fragmented, No PD-API is up, Nothing in the 1762f8829a4aSRandall Stewart * delivery queue, Its un-ordered OR ordered and the next to 1763f8829a4aSRandall Stewart * deliver AND nothing else is stuck on the stream queue, 1764f8829a4aSRandall Stewart * And there is room for it in the socket buffer. Lets just 1765f8829a4aSRandall Stewart * stuff it up the buffer.... 1766f8829a4aSRandall Stewart */ 1767f8829a4aSRandall Stewart 1768f8829a4aSRandall Stewart /* It would be nice to avoid this copy if we could :< */ 1769f8829a4aSRandall Stewart sctp_alloc_a_readq(stcb, control); 1770f8829a4aSRandall Stewart sctp_build_readq_entry_mac(control, stcb, asoc->context, net, tsn, 1771f42a358aSRandall Stewart protocol_id, 1772f8829a4aSRandall Stewart stcb->asoc.context, 1773f8829a4aSRandall Stewart strmno, strmseq, 1774f42a358aSRandall Stewart chunk_flags, 1775f8829a4aSRandall Stewart dmbuf); 1776f8829a4aSRandall Stewart if (control == NULL) { 1777f8829a4aSRandall Stewart goto failed_express_del; 1778f8829a4aSRandall Stewart } 17791ea735c8SMichael Tuexen SCTP_SET_TSN_PRESENT(asoc->nr_mapping_array, gap); 17801ea735c8SMichael Tuexen if (compare_with_wrap(tsn, asoc->highest_tsn_inside_nr_map, MAX_TSN)) { 17811ea735c8SMichael Tuexen asoc->highest_tsn_inside_nr_map = tsn; 17821ea735c8SMichael Tuexen } 1783cfde3ff7SRandall Stewart sctp_add_to_readq(stcb->sctp_ep, stcb, 1784cfde3ff7SRandall Stewart control, &stcb->sctp_socket->so_rcv, 1785cfde3ff7SRandall Stewart 1, SCTP_READ_LOCK_NOT_HELD, SCTP_SO_NOT_LOCKED); 1786830d754dSRandall Stewart 1787f42a358aSRandall Stewart if ((chunk_flags & SCTP_DATA_UNORDERED) == 0) { 1788f8829a4aSRandall Stewart /* for ordered, bump what we delivered */ 1789f8829a4aSRandall Stewart asoc->strmin[strmno].last_sequence_delivered++; 1790f8829a4aSRandall Stewart } 1791f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_recvexpress); 1792b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_STR_LOGGING_ENABLE) { 17936a91f103SRandall Stewart sctp_log_strm_del_alt(stcb, tsn, strmseq, strmno, 1794f8829a4aSRandall Stewart SCTP_STR_LOG_FROM_EXPRS_DEL); 179580fefe0aSRandall Stewart } 1796f8829a4aSRandall Stewart control = NULL; 1797b5c16493SMichael Tuexen 1798f8829a4aSRandall Stewart goto finish_express_del; 1799f8829a4aSRandall Stewart } 1800f8829a4aSRandall Stewart failed_express_del: 1801f8829a4aSRandall Stewart /* If we reach here this is a new chunk */ 1802f8829a4aSRandall Stewart chk = NULL; 1803f8829a4aSRandall Stewart control = NULL; 1804f8829a4aSRandall Stewart /* Express for fragmented delivery? */ 1805f8829a4aSRandall Stewart if ((asoc->fragmented_delivery_inprogress) && 1806f8829a4aSRandall Stewart (stcb->asoc.control_pdapi) && 1807f8829a4aSRandall Stewart (asoc->str_of_pdapi == strmno) && 1808f8829a4aSRandall Stewart (asoc->ssn_of_pdapi == strmseq) 1809f8829a4aSRandall Stewart ) { 1810f8829a4aSRandall Stewart control = stcb->asoc.control_pdapi; 1811f42a358aSRandall Stewart if ((chunk_flags & SCTP_DATA_FIRST_FRAG) == SCTP_DATA_FIRST_FRAG) { 1812f8829a4aSRandall Stewart /* Can't be another first? */ 1813f8829a4aSRandall Stewart goto failed_pdapi_express_del; 1814f8829a4aSRandall Stewart } 1815f8829a4aSRandall Stewart if (tsn == (control->sinfo_tsn + 1)) { 1816f8829a4aSRandall Stewart /* Yep, we can add it on */ 1817f8829a4aSRandall Stewart int end = 0; 1818f8829a4aSRandall Stewart uint32_t cumack; 1819f8829a4aSRandall Stewart 1820f42a358aSRandall Stewart if (chunk_flags & SCTP_DATA_LAST_FRAG) { 1821f8829a4aSRandall Stewart end = 1; 1822f8829a4aSRandall Stewart } 1823f8829a4aSRandall Stewart cumack = asoc->cumulative_tsn; 1824f8829a4aSRandall Stewart if ((cumack + 1) == tsn) 1825f8829a4aSRandall Stewart cumack = tsn; 1826f8829a4aSRandall Stewart 1827f8829a4aSRandall Stewart if (sctp_append_to_readq(stcb->sctp_ep, stcb, control, dmbuf, end, 1828f8829a4aSRandall Stewart tsn, 1829f8829a4aSRandall Stewart &stcb->sctp_socket->so_rcv)) { 1830ad81507eSRandall Stewart SCTP_PRINTF("Append fails end:%d\n", end); 1831f8829a4aSRandall Stewart goto failed_pdapi_express_del; 1832f8829a4aSRandall Stewart } 183377acdc25SRandall Stewart SCTP_SET_TSN_PRESENT(asoc->nr_mapping_array, gap); 183477acdc25SRandall Stewart if (compare_with_wrap(tsn, asoc->highest_tsn_inside_nr_map, MAX_TSN)) { 1835830d754dSRandall Stewart asoc->highest_tsn_inside_nr_map = tsn; 1836830d754dSRandall Stewart } 1837f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_recvexpressm); 1838f8829a4aSRandall Stewart control->sinfo_tsn = tsn; 1839f8829a4aSRandall Stewart asoc->tsn_last_delivered = tsn; 1840f42a358aSRandall Stewart asoc->fragment_flags = chunk_flags; 1841f8829a4aSRandall Stewart asoc->tsn_of_pdapi_last_delivered = tsn; 1842f42a358aSRandall Stewart asoc->last_flags_delivered = chunk_flags; 1843f8829a4aSRandall Stewart asoc->last_strm_seq_delivered = strmseq; 1844f8829a4aSRandall Stewart asoc->last_strm_no_delivered = strmno; 1845f8829a4aSRandall Stewart if (end) { 1846f8829a4aSRandall Stewart /* clean up the flags and such */ 1847f8829a4aSRandall Stewart asoc->fragmented_delivery_inprogress = 0; 1848f42a358aSRandall Stewart if ((chunk_flags & SCTP_DATA_UNORDERED) == 0) { 1849f8829a4aSRandall Stewart asoc->strmin[strmno].last_sequence_delivered++; 1850a5d547adSRandall Stewart } 1851f8829a4aSRandall Stewart stcb->asoc.control_pdapi = NULL; 1852139bc87fSRandall Stewart if (TAILQ_EMPTY(&asoc->reasmqueue) == 0) { 1853139bc87fSRandall Stewart /* 1854139bc87fSRandall Stewart * There could be another message 1855139bc87fSRandall Stewart * ready 1856139bc87fSRandall Stewart */ 1857139bc87fSRandall Stewart need_reasm_check = 1; 1858139bc87fSRandall Stewart } 1859f8829a4aSRandall Stewart } 1860f8829a4aSRandall Stewart control = NULL; 1861f8829a4aSRandall Stewart goto finish_express_del; 1862f8829a4aSRandall Stewart } 1863f8829a4aSRandall Stewart } 1864f8829a4aSRandall Stewart failed_pdapi_express_del: 1865f8829a4aSRandall Stewart control = NULL; 186677acdc25SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_do_drain) == 0) { 186777acdc25SRandall Stewart SCTP_SET_TSN_PRESENT(asoc->nr_mapping_array, gap); 186877acdc25SRandall Stewart if (compare_with_wrap(tsn, asoc->highest_tsn_inside_nr_map, MAX_TSN)) { 186977acdc25SRandall Stewart asoc->highest_tsn_inside_nr_map = tsn; 187077acdc25SRandall Stewart } 187177acdc25SRandall Stewart } else { 187277acdc25SRandall Stewart SCTP_SET_TSN_PRESENT(asoc->mapping_array, gap); 187377acdc25SRandall Stewart if (compare_with_wrap(tsn, asoc->highest_tsn_inside_map, MAX_TSN)) { 187477acdc25SRandall Stewart asoc->highest_tsn_inside_map = tsn; 187577acdc25SRandall Stewart } 187677acdc25SRandall Stewart } 1877f42a358aSRandall Stewart if ((chunk_flags & SCTP_DATA_NOT_FRAG) != SCTP_DATA_NOT_FRAG) { 1878f8829a4aSRandall Stewart sctp_alloc_a_chunk(stcb, chk); 1879f8829a4aSRandall Stewart if (chk == NULL) { 1880f8829a4aSRandall Stewart /* No memory so we drop the chunk */ 1881f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_nomem); 1882f8829a4aSRandall Stewart if (last_chunk == 0) { 1883f8829a4aSRandall Stewart /* we copied it, free the copy */ 1884f8829a4aSRandall Stewart sctp_m_freem(dmbuf); 1885f8829a4aSRandall Stewart } 1886f8829a4aSRandall Stewart return (0); 1887f8829a4aSRandall Stewart } 1888f8829a4aSRandall Stewart chk->rec.data.TSN_seq = tsn; 1889f8829a4aSRandall Stewart chk->no_fr_allowed = 0; 1890f8829a4aSRandall Stewart chk->rec.data.stream_seq = strmseq; 1891f8829a4aSRandall Stewart chk->rec.data.stream_number = strmno; 1892f42a358aSRandall Stewart chk->rec.data.payloadtype = protocol_id; 1893f8829a4aSRandall Stewart chk->rec.data.context = stcb->asoc.context; 1894f8829a4aSRandall Stewart chk->rec.data.doing_fast_retransmit = 0; 1895f42a358aSRandall Stewart chk->rec.data.rcv_flags = chunk_flags; 1896f8829a4aSRandall Stewart chk->asoc = asoc; 1897f8829a4aSRandall Stewart chk->send_size = the_len; 1898f8829a4aSRandall Stewart chk->whoTo = net; 1899f8829a4aSRandall Stewart atomic_add_int(&net->ref_count, 1); 1900f8829a4aSRandall Stewart chk->data = dmbuf; 1901f8829a4aSRandall Stewart } else { 1902f8829a4aSRandall Stewart sctp_alloc_a_readq(stcb, control); 1903f8829a4aSRandall Stewart sctp_build_readq_entry_mac(control, stcb, asoc->context, net, tsn, 1904f42a358aSRandall Stewart protocol_id, 1905f8829a4aSRandall Stewart stcb->asoc.context, 1906f8829a4aSRandall Stewart strmno, strmseq, 1907f42a358aSRandall Stewart chunk_flags, 1908f8829a4aSRandall Stewart dmbuf); 1909f8829a4aSRandall Stewart if (control == NULL) { 1910f8829a4aSRandall Stewart /* No memory so we drop the chunk */ 1911f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_nomem); 1912f8829a4aSRandall Stewart if (last_chunk == 0) { 1913f8829a4aSRandall Stewart /* we copied it, free the copy */ 1914f8829a4aSRandall Stewart sctp_m_freem(dmbuf); 1915f8829a4aSRandall Stewart } 1916f8829a4aSRandall Stewart return (0); 1917f8829a4aSRandall Stewart } 1918f8829a4aSRandall Stewart control->length = the_len; 1919f8829a4aSRandall Stewart } 1920f8829a4aSRandall Stewart 1921f8829a4aSRandall Stewart /* Mark it as received */ 1922f8829a4aSRandall Stewart /* Now queue it where it belongs */ 1923f8829a4aSRandall Stewart if (control != NULL) { 1924f8829a4aSRandall Stewart /* First a sanity check */ 1925f8829a4aSRandall Stewart if (asoc->fragmented_delivery_inprogress) { 1926f8829a4aSRandall Stewart /* 1927f8829a4aSRandall Stewart * Ok, we have a fragmented delivery in progress if 1928f8829a4aSRandall Stewart * this chunk is next to deliver OR belongs in our 1929f8829a4aSRandall Stewart * view to the reassembly, the peer is evil or 1930f8829a4aSRandall Stewart * broken. 1931f8829a4aSRandall Stewart */ 1932f8829a4aSRandall Stewart uint32_t estimate_tsn; 1933f8829a4aSRandall Stewart 1934f8829a4aSRandall Stewart estimate_tsn = asoc->tsn_last_delivered + 1; 1935f8829a4aSRandall Stewart if (TAILQ_EMPTY(&asoc->reasmqueue) && 1936f8829a4aSRandall Stewart (estimate_tsn == control->sinfo_tsn)) { 1937f8829a4aSRandall Stewart /* Evil/Broke peer */ 1938f8829a4aSRandall Stewart sctp_m_freem(control->data); 1939f8829a4aSRandall Stewart control->data = NULL; 19405bead436SRandall Stewart if (control->whoFrom) { 1941f8829a4aSRandall Stewart sctp_free_remote_addr(control->whoFrom); 19425bead436SRandall Stewart control->whoFrom = NULL; 19435bead436SRandall Stewart } 1944f8829a4aSRandall Stewart sctp_free_a_readq(stcb, control); 1945139bc87fSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + 3 * sizeof(uint32_t)), 1946f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 1947f8829a4aSRandall Stewart if (oper) { 1948f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 1949f8829a4aSRandall Stewart uint32_t *ippp; 1950f8829a4aSRandall Stewart 1951139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = 1952f8829a4aSRandall Stewart sizeof(struct sctp_paramhdr) + 1953f8829a4aSRandall Stewart (3 * sizeof(uint32_t)); 1954f8829a4aSRandall Stewart ph = mtod(oper, struct sctp_paramhdr *); 1955f8829a4aSRandall Stewart ph->param_type = 1956f8829a4aSRandall Stewart htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 1957139bc87fSRandall Stewart ph->param_length = htons(SCTP_BUF_LEN(oper)); 1958f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 1959a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_15); 1960f8829a4aSRandall Stewart ippp++; 1961f8829a4aSRandall Stewart *ippp = tsn; 1962f8829a4aSRandall Stewart ippp++; 1963f8829a4aSRandall Stewart *ippp = ((strmno << 16) | strmseq); 1964f8829a4aSRandall Stewart } 1965a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_15; 1966f8829a4aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, stcb, 1967ceaad40aSRandall Stewart SCTP_PEER_FAULTY, oper, SCTP_SO_NOT_LOCKED); 1968f8829a4aSRandall Stewart 1969f8829a4aSRandall Stewart *abort_flag = 1; 1970f8829a4aSRandall Stewart return (0); 1971f8829a4aSRandall Stewart } else { 1972f8829a4aSRandall Stewart if (sctp_does_tsn_belong_to_reasm(asoc, control->sinfo_tsn)) { 1973f8829a4aSRandall Stewart sctp_m_freem(control->data); 1974f8829a4aSRandall Stewart control->data = NULL; 19755bead436SRandall Stewart if (control->whoFrom) { 1976f8829a4aSRandall Stewart sctp_free_remote_addr(control->whoFrom); 19775bead436SRandall Stewart control->whoFrom = NULL; 19785bead436SRandall Stewart } 1979f8829a4aSRandall Stewart sctp_free_a_readq(stcb, control); 1980f8829a4aSRandall Stewart 1981139bc87fSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + 3 * sizeof(uint32_t)), 1982f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 1983f8829a4aSRandall Stewart if (oper) { 1984f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 1985f8829a4aSRandall Stewart uint32_t *ippp; 1986f8829a4aSRandall Stewart 1987139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = 1988f8829a4aSRandall Stewart sizeof(struct sctp_paramhdr) + 1989f8829a4aSRandall Stewart (3 * sizeof(uint32_t)); 1990f8829a4aSRandall Stewart ph = mtod(oper, 1991f8829a4aSRandall Stewart struct sctp_paramhdr *); 1992f8829a4aSRandall Stewart ph->param_type = 1993f8829a4aSRandall Stewart htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 1994f8829a4aSRandall Stewart ph->param_length = 1995139bc87fSRandall Stewart htons(SCTP_BUF_LEN(oper)); 1996f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 1997a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_16); 1998f8829a4aSRandall Stewart ippp++; 1999f8829a4aSRandall Stewart *ippp = tsn; 2000f8829a4aSRandall Stewart ippp++; 2001f8829a4aSRandall Stewart *ippp = ((strmno << 16) | strmseq); 2002f8829a4aSRandall Stewart } 2003a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_16; 2004f8829a4aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, 2005ceaad40aSRandall Stewart stcb, SCTP_PEER_FAULTY, oper, SCTP_SO_NOT_LOCKED); 2006f8829a4aSRandall Stewart 2007f8829a4aSRandall Stewart *abort_flag = 1; 2008f8829a4aSRandall Stewart return (0); 2009f8829a4aSRandall Stewart } 2010f8829a4aSRandall Stewart } 2011f8829a4aSRandall Stewart } else { 2012f8829a4aSRandall Stewart /* No PDAPI running */ 2013f8829a4aSRandall Stewart if (!TAILQ_EMPTY(&asoc->reasmqueue)) { 2014f8829a4aSRandall Stewart /* 2015f8829a4aSRandall Stewart * Reassembly queue is NOT empty validate 2016f8829a4aSRandall Stewart * that this tsn does not need to be in 2017f8829a4aSRandall Stewart * reasembly queue. If it does then our peer 2018f8829a4aSRandall Stewart * is broken or evil. 2019f8829a4aSRandall Stewart */ 2020f8829a4aSRandall Stewart if (sctp_does_tsn_belong_to_reasm(asoc, control->sinfo_tsn)) { 2021f8829a4aSRandall Stewart sctp_m_freem(control->data); 2022f8829a4aSRandall Stewart control->data = NULL; 20235bead436SRandall Stewart if (control->whoFrom) { 2024f8829a4aSRandall Stewart sctp_free_remote_addr(control->whoFrom); 20255bead436SRandall Stewart control->whoFrom = NULL; 20265bead436SRandall Stewart } 2027f8829a4aSRandall Stewart sctp_free_a_readq(stcb, control); 2028139bc87fSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + 3 * sizeof(uint32_t)), 2029f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 2030f8829a4aSRandall Stewart if (oper) { 2031f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 2032f8829a4aSRandall Stewart uint32_t *ippp; 2033f8829a4aSRandall Stewart 2034139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = 2035f8829a4aSRandall Stewart sizeof(struct sctp_paramhdr) + 2036f8829a4aSRandall Stewart (3 * sizeof(uint32_t)); 2037f8829a4aSRandall Stewart ph = mtod(oper, 2038f8829a4aSRandall Stewart struct sctp_paramhdr *); 2039f8829a4aSRandall Stewart ph->param_type = 2040f8829a4aSRandall Stewart htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 2041f8829a4aSRandall Stewart ph->param_length = 2042139bc87fSRandall Stewart htons(SCTP_BUF_LEN(oper)); 2043f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 2044a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_17); 2045f8829a4aSRandall Stewart ippp++; 2046f8829a4aSRandall Stewart *ippp = tsn; 2047f8829a4aSRandall Stewart ippp++; 2048f8829a4aSRandall Stewart *ippp = ((strmno << 16) | strmseq); 2049f8829a4aSRandall Stewart } 2050a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_17; 2051f8829a4aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, 2052ceaad40aSRandall Stewart stcb, SCTP_PEER_FAULTY, oper, SCTP_SO_NOT_LOCKED); 2053f8829a4aSRandall Stewart 2054f8829a4aSRandall Stewart *abort_flag = 1; 2055f8829a4aSRandall Stewart return (0); 2056f8829a4aSRandall Stewart } 2057f8829a4aSRandall Stewart } 2058f8829a4aSRandall Stewart } 2059f8829a4aSRandall Stewart /* ok, if we reach here we have passed the sanity checks */ 2060f42a358aSRandall Stewart if (chunk_flags & SCTP_DATA_UNORDERED) { 2061f8829a4aSRandall Stewart /* queue directly into socket buffer */ 2062b5c16493SMichael Tuexen sctp_mark_non_revokable(asoc, control->sinfo_tsn); 2063f8829a4aSRandall Stewart sctp_add_to_readq(stcb->sctp_ep, stcb, 2064f8829a4aSRandall Stewart control, 2065cfde3ff7SRandall Stewart &stcb->sctp_socket->so_rcv, 1, SCTP_READ_LOCK_NOT_HELD, SCTP_SO_NOT_LOCKED); 2066f8829a4aSRandall Stewart } else { 2067f8829a4aSRandall Stewart /* 2068f8829a4aSRandall Stewart * Special check for when streams are resetting. We 2069f8829a4aSRandall Stewart * could be more smart about this and check the 2070f8829a4aSRandall Stewart * actual stream to see if it is not being reset.. 2071f8829a4aSRandall Stewart * that way we would not create a HOLB when amongst 2072f8829a4aSRandall Stewart * streams being reset and those not being reset. 2073f8829a4aSRandall Stewart * 2074f8829a4aSRandall Stewart * We take complete messages that have a stream reset 2075f8829a4aSRandall Stewart * intervening (aka the TSN is after where our 2076f8829a4aSRandall Stewart * cum-ack needs to be) off and put them on a 2077f8829a4aSRandall Stewart * pending_reply_queue. The reassembly ones we do 2078f8829a4aSRandall Stewart * not have to worry about since they are all sorted 2079f8829a4aSRandall Stewart * and proceessed by TSN order. It is only the 2080f8829a4aSRandall Stewart * singletons I must worry about. 2081f8829a4aSRandall Stewart */ 2082f8829a4aSRandall Stewart if (((liste = TAILQ_FIRST(&asoc->resetHead)) != NULL) && 2083d61a0ae0SRandall Stewart ((compare_with_wrap(tsn, liste->tsn, MAX_TSN))) 2084f8829a4aSRandall Stewart ) { 2085f8829a4aSRandall Stewart /* 2086f8829a4aSRandall Stewart * yep its past where we need to reset... go 2087f8829a4aSRandall Stewart * ahead and queue it. 2088f8829a4aSRandall Stewart */ 2089f8829a4aSRandall Stewart if (TAILQ_EMPTY(&asoc->pending_reply_queue)) { 2090f8829a4aSRandall Stewart /* first one on */ 2091f8829a4aSRandall Stewart TAILQ_INSERT_TAIL(&asoc->pending_reply_queue, control, next); 2092f8829a4aSRandall Stewart } else { 2093f8829a4aSRandall Stewart struct sctp_queued_to_read *ctlOn; 2094f8829a4aSRandall Stewart unsigned char inserted = 0; 2095f8829a4aSRandall Stewart 2096f8829a4aSRandall Stewart ctlOn = TAILQ_FIRST(&asoc->pending_reply_queue); 2097f8829a4aSRandall Stewart while (ctlOn) { 2098f8829a4aSRandall Stewart if (compare_with_wrap(control->sinfo_tsn, 2099f8829a4aSRandall Stewart ctlOn->sinfo_tsn, MAX_TSN)) { 2100f8829a4aSRandall Stewart ctlOn = TAILQ_NEXT(ctlOn, next); 2101f8829a4aSRandall Stewart } else { 2102f8829a4aSRandall Stewart /* found it */ 2103f8829a4aSRandall Stewart TAILQ_INSERT_BEFORE(ctlOn, control, next); 2104f8829a4aSRandall Stewart inserted = 1; 2105f8829a4aSRandall Stewart break; 2106f8829a4aSRandall Stewart } 2107f8829a4aSRandall Stewart } 2108f8829a4aSRandall Stewart if (inserted == 0) { 2109f8829a4aSRandall Stewart /* 2110f8829a4aSRandall Stewart * must be put at end, use 2111f8829a4aSRandall Stewart * prevP (all setup from 2112f8829a4aSRandall Stewart * loop) to setup nextP. 2113f8829a4aSRandall Stewart */ 2114f8829a4aSRandall Stewart TAILQ_INSERT_TAIL(&asoc->pending_reply_queue, control, next); 2115f8829a4aSRandall Stewart } 2116f8829a4aSRandall Stewart } 2117f8829a4aSRandall Stewart } else { 2118f8829a4aSRandall Stewart sctp_queue_data_to_stream(stcb, asoc, control, abort_flag); 2119f8829a4aSRandall Stewart if (*abort_flag) { 2120f8829a4aSRandall Stewart return (0); 2121f8829a4aSRandall Stewart } 2122f8829a4aSRandall Stewart } 2123f8829a4aSRandall Stewart } 2124f8829a4aSRandall Stewart } else { 2125f8829a4aSRandall Stewart /* Into the re-assembly queue */ 2126f8829a4aSRandall Stewart sctp_queue_data_for_reasm(stcb, asoc, chk, abort_flag); 2127f8829a4aSRandall Stewart if (*abort_flag) { 2128a5d547adSRandall Stewart /* 2129a5d547adSRandall Stewart * the assoc is now gone and chk was put onto the 2130a5d547adSRandall Stewart * reasm queue, which has all been freed. 2131a5d547adSRandall Stewart */ 2132a5d547adSRandall Stewart *m = NULL; 2133f8829a4aSRandall Stewart return (0); 2134f8829a4aSRandall Stewart } 2135f8829a4aSRandall Stewart } 2136f8829a4aSRandall Stewart finish_express_del: 2137307b49efSMichael Tuexen if (tsn == (asoc->cumulative_tsn + 1)) { 2138307b49efSMichael Tuexen /* Update cum-ack */ 2139307b49efSMichael Tuexen asoc->cumulative_tsn = tsn; 2140307b49efSMichael Tuexen } 2141f8829a4aSRandall Stewart if (last_chunk) { 2142f8829a4aSRandall Stewart *m = NULL; 2143f8829a4aSRandall Stewart } 2144f42a358aSRandall Stewart if (ordered) { 2145f8829a4aSRandall Stewart SCTP_STAT_INCR_COUNTER64(sctps_inorderchunks); 2146f8829a4aSRandall Stewart } else { 2147f8829a4aSRandall Stewart SCTP_STAT_INCR_COUNTER64(sctps_inunorderchunks); 2148f8829a4aSRandall Stewart } 2149f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_recvdata); 2150f8829a4aSRandall Stewart /* Set it present please */ 2151b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_STR_LOGGING_ENABLE) { 21526a91f103SRandall Stewart sctp_log_strm_del_alt(stcb, tsn, strmseq, strmno, SCTP_STR_LOG_FROM_MARK_TSN); 215380fefe0aSRandall Stewart } 2154b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_MAP_LOGGING_ENABLE) { 2155f8829a4aSRandall Stewart sctp_log_map(asoc->mapping_array_base_tsn, asoc->cumulative_tsn, 2156f8829a4aSRandall Stewart asoc->highest_tsn_inside_map, SCTP_MAP_PREPARE_SLIDE); 215780fefe0aSRandall Stewart } 215817205eccSRandall Stewart /* check the special flag for stream resets */ 215917205eccSRandall Stewart if (((liste = TAILQ_FIRST(&asoc->resetHead)) != NULL) && 2160d61a0ae0SRandall Stewart ((compare_with_wrap(asoc->cumulative_tsn, liste->tsn, MAX_TSN)) || 2161d61a0ae0SRandall Stewart (asoc->cumulative_tsn == liste->tsn)) 216217205eccSRandall Stewart ) { 216317205eccSRandall Stewart /* 216417205eccSRandall Stewart * we have finished working through the backlogged TSN's now 216517205eccSRandall Stewart * time to reset streams. 1: call reset function. 2: free 216617205eccSRandall Stewart * pending_reply space 3: distribute any chunks in 216717205eccSRandall Stewart * pending_reply_queue. 216817205eccSRandall Stewart */ 216917205eccSRandall Stewart struct sctp_queued_to_read *ctl; 217017205eccSRandall Stewart 217117205eccSRandall Stewart sctp_reset_in_stream(stcb, liste->number_entries, liste->req.list_of_streams); 217217205eccSRandall Stewart TAILQ_REMOVE(&asoc->resetHead, liste, next_resp); 2173207304d4SRandall Stewart SCTP_FREE(liste, SCTP_M_STRESET); 21743c503c28SRandall Stewart /* sa_ignore FREED_MEMORY */ 217517205eccSRandall Stewart liste = TAILQ_FIRST(&asoc->resetHead); 217617205eccSRandall Stewart ctl = TAILQ_FIRST(&asoc->pending_reply_queue); 217717205eccSRandall Stewart if (ctl && (liste == NULL)) { 217817205eccSRandall Stewart /* All can be removed */ 217917205eccSRandall Stewart while (ctl) { 218017205eccSRandall Stewart TAILQ_REMOVE(&asoc->pending_reply_queue, ctl, next); 218117205eccSRandall Stewart sctp_queue_data_to_stream(stcb, asoc, ctl, abort_flag); 218217205eccSRandall Stewart if (*abort_flag) { 218317205eccSRandall Stewart return (0); 218417205eccSRandall Stewart } 218517205eccSRandall Stewart ctl = TAILQ_FIRST(&asoc->pending_reply_queue); 218617205eccSRandall Stewart } 218717205eccSRandall Stewart } else if (ctl) { 218817205eccSRandall Stewart /* more than one in queue */ 2189d61a0ae0SRandall Stewart while (!compare_with_wrap(ctl->sinfo_tsn, liste->tsn, MAX_TSN)) { 219017205eccSRandall Stewart /* 219117205eccSRandall Stewart * if ctl->sinfo_tsn is <= liste->tsn we can 219217205eccSRandall Stewart * process it which is the NOT of 219317205eccSRandall Stewart * ctl->sinfo_tsn > liste->tsn 219417205eccSRandall Stewart */ 219517205eccSRandall Stewart TAILQ_REMOVE(&asoc->pending_reply_queue, ctl, next); 219617205eccSRandall Stewart sctp_queue_data_to_stream(stcb, asoc, ctl, abort_flag); 219717205eccSRandall Stewart if (*abort_flag) { 219817205eccSRandall Stewart return (0); 219917205eccSRandall Stewart } 220017205eccSRandall Stewart ctl = TAILQ_FIRST(&asoc->pending_reply_queue); 220117205eccSRandall Stewart } 220217205eccSRandall Stewart } 220317205eccSRandall Stewart /* 220417205eccSRandall Stewart * Now service re-assembly to pick up anything that has been 220517205eccSRandall Stewart * held on reassembly queue? 220617205eccSRandall Stewart */ 220717205eccSRandall Stewart sctp_deliver_reasm_check(stcb, asoc); 220817205eccSRandall Stewart need_reasm_check = 0; 220917205eccSRandall Stewart } 2210139bc87fSRandall Stewart if (need_reasm_check) { 2211139bc87fSRandall Stewart /* Another one waits ? */ 2212139bc87fSRandall Stewart sctp_deliver_reasm_check(stcb, asoc); 2213139bc87fSRandall Stewart } 2214f8829a4aSRandall Stewart return (1); 2215f8829a4aSRandall Stewart } 2216f8829a4aSRandall Stewart 2217f8829a4aSRandall Stewart int8_t sctp_map_lookup_tab[256] = { 2218b5c16493SMichael Tuexen 0, 1, 0, 2, 0, 1, 0, 3, 2219b5c16493SMichael Tuexen 0, 1, 0, 2, 0, 1, 0, 4, 2220b5c16493SMichael Tuexen 0, 1, 0, 2, 0, 1, 0, 3, 2221b5c16493SMichael Tuexen 0, 1, 0, 2, 0, 1, 0, 5, 2222b5c16493SMichael Tuexen 0, 1, 0, 2, 0, 1, 0, 3, 2223b5c16493SMichael Tuexen 0, 1, 0, 2, 0, 1, 0, 4, 2224b5c16493SMichael Tuexen 0, 1, 0, 2, 0, 1, 0, 3, 2225b5c16493SMichael Tuexen 0, 1, 0, 2, 0, 1, 0, 6, 2226b5c16493SMichael Tuexen 0, 1, 0, 2, 0, 1, 0, 3, 2227b5c16493SMichael Tuexen 0, 1, 0, 2, 0, 1, 0, 4, 2228b5c16493SMichael Tuexen 0, 1, 0, 2, 0, 1, 0, 3, 2229b5c16493SMichael Tuexen 0, 1, 0, 2, 0, 1, 0, 5, 2230b5c16493SMichael Tuexen 0, 1, 0, 2, 0, 1, 0, 3, 2231b5c16493SMichael Tuexen 0, 1, 0, 2, 0, 1, 0, 4, 2232b5c16493SMichael Tuexen 0, 1, 0, 2, 0, 1, 0, 3, 2233b5c16493SMichael Tuexen 0, 1, 0, 2, 0, 1, 0, 7, 2234b5c16493SMichael Tuexen 0, 1, 0, 2, 0, 1, 0, 3, 2235b5c16493SMichael Tuexen 0, 1, 0, 2, 0, 1, 0, 4, 2236b5c16493SMichael Tuexen 0, 1, 0, 2, 0, 1, 0, 3, 2237b5c16493SMichael Tuexen 0, 1, 0, 2, 0, 1, 0, 5, 2238b5c16493SMichael Tuexen 0, 1, 0, 2, 0, 1, 0, 3, 2239b5c16493SMichael Tuexen 0, 1, 0, 2, 0, 1, 0, 4, 2240b5c16493SMichael Tuexen 0, 1, 0, 2, 0, 1, 0, 3, 2241b5c16493SMichael Tuexen 0, 1, 0, 2, 0, 1, 0, 6, 2242b5c16493SMichael Tuexen 0, 1, 0, 2, 0, 1, 0, 3, 2243b5c16493SMichael Tuexen 0, 1, 0, 2, 0, 1, 0, 4, 2244b5c16493SMichael Tuexen 0, 1, 0, 2, 0, 1, 0, 3, 2245b5c16493SMichael Tuexen 0, 1, 0, 2, 0, 1, 0, 5, 2246b5c16493SMichael Tuexen 0, 1, 0, 2, 0, 1, 0, 3, 2247b5c16493SMichael Tuexen 0, 1, 0, 2, 0, 1, 0, 4, 2248b5c16493SMichael Tuexen 0, 1, 0, 2, 0, 1, 0, 3, 2249b5c16493SMichael Tuexen 0, 1, 0, 2, 0, 1, 0, 8 2250f8829a4aSRandall Stewart }; 2251f8829a4aSRandall Stewart 2252f8829a4aSRandall Stewart 2253f8829a4aSRandall Stewart void 2254b5c16493SMichael Tuexen sctp_slide_mapping_arrays(struct sctp_tcb *stcb) 2255f8829a4aSRandall Stewart { 2256f8829a4aSRandall Stewart /* 2257f8829a4aSRandall Stewart * Now we also need to check the mapping array in a couple of ways. 2258f8829a4aSRandall Stewart * 1) Did we move the cum-ack point? 225966bd30bdSRandall Stewart * 226066bd30bdSRandall Stewart * When you first glance at this you might think that all entries that 226166bd30bdSRandall Stewart * make up the postion of the cum-ack would be in the nr-mapping 226266bd30bdSRandall Stewart * array only.. i.e. things up to the cum-ack are always 226366bd30bdSRandall Stewart * deliverable. Thats true with one exception, when its a fragmented 226466bd30bdSRandall Stewart * message we may not deliver the data until some threshold (or all 226566bd30bdSRandall Stewart * of it) is in place. So we must OR the nr_mapping_array and 226666bd30bdSRandall Stewart * mapping_array to get a true picture of the cum-ack. 2267f8829a4aSRandall Stewart */ 2268f8829a4aSRandall Stewart struct sctp_association *asoc; 2269b3f1ea41SRandall Stewart int at; 227066bd30bdSRandall Stewart uint8_t val; 2271f8829a4aSRandall Stewart int slide_from, slide_end, lgap, distance; 227277acdc25SRandall Stewart uint32_t old_cumack, old_base, old_highest, highest_tsn; 2273f8829a4aSRandall Stewart 2274f8829a4aSRandall Stewart asoc = &stcb->asoc; 2275f8829a4aSRandall Stewart at = 0; 2276f8829a4aSRandall Stewart 2277f8829a4aSRandall Stewart old_cumack = asoc->cumulative_tsn; 2278f8829a4aSRandall Stewart old_base = asoc->mapping_array_base_tsn; 2279f8829a4aSRandall Stewart old_highest = asoc->highest_tsn_inside_map; 2280f8829a4aSRandall Stewart /* 2281f8829a4aSRandall Stewart * We could probably improve this a small bit by calculating the 2282f8829a4aSRandall Stewart * offset of the current cum-ack as the starting point. 2283f8829a4aSRandall Stewart */ 2284f8829a4aSRandall Stewart at = 0; 2285b5c16493SMichael Tuexen for (slide_from = 0; slide_from < stcb->asoc.mapping_array_size; slide_from++) { 228666bd30bdSRandall Stewart val = asoc->nr_mapping_array[slide_from] | asoc->mapping_array[slide_from]; 228766bd30bdSRandall Stewart if (val == 0xff) { 2288f8829a4aSRandall Stewart at += 8; 2289f8829a4aSRandall Stewart } else { 2290f8829a4aSRandall Stewart /* there is a 0 bit */ 229166bd30bdSRandall Stewart at += sctp_map_lookup_tab[val]; 2292f8829a4aSRandall Stewart break; 2293f8829a4aSRandall Stewart } 2294f8829a4aSRandall Stewart } 2295b5c16493SMichael Tuexen asoc->cumulative_tsn = asoc->mapping_array_base_tsn + (at - 1); 2296f8829a4aSRandall Stewart 229777acdc25SRandall Stewart if (compare_with_wrap(asoc->cumulative_tsn, asoc->highest_tsn_inside_map, MAX_TSN) && 2298aed5947cSMichael Tuexen compare_with_wrap(asoc->cumulative_tsn, asoc->highest_tsn_inside_nr_map, MAX_TSN)) { 2299a5d547adSRandall Stewart #ifdef INVARIANTS 2300ceaad40aSRandall Stewart panic("huh, cumack 0x%x greater than high-tsn 0x%x in map", 2301ceaad40aSRandall Stewart asoc->cumulative_tsn, asoc->highest_tsn_inside_map); 2302f8829a4aSRandall Stewart #else 2303ceaad40aSRandall Stewart SCTP_PRINTF("huh, cumack 0x%x greater than high-tsn 0x%x in map - should panic?\n", 2304ceaad40aSRandall Stewart asoc->cumulative_tsn, asoc->highest_tsn_inside_map); 23050e13104dSRandall Stewart sctp_print_mapping_array(asoc); 2306b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_MAP_LOGGING_ENABLE) { 2307b3f1ea41SRandall Stewart sctp_log_map(0, 6, asoc->highest_tsn_inside_map, SCTP_MAP_SLIDE_RESULT); 2308b3f1ea41SRandall Stewart } 2309f8829a4aSRandall Stewart asoc->highest_tsn_inside_map = asoc->cumulative_tsn; 2310830d754dSRandall Stewart asoc->highest_tsn_inside_nr_map = asoc->cumulative_tsn; 2311f8829a4aSRandall Stewart #endif 2312f8829a4aSRandall Stewart } 231377acdc25SRandall Stewart if (compare_with_wrap(asoc->highest_tsn_inside_nr_map, 231477acdc25SRandall Stewart asoc->highest_tsn_inside_map, 231577acdc25SRandall Stewart MAX_TSN)) { 231677acdc25SRandall Stewart highest_tsn = asoc->highest_tsn_inside_nr_map; 231777acdc25SRandall Stewart } else { 231877acdc25SRandall Stewart highest_tsn = asoc->highest_tsn_inside_map; 231977acdc25SRandall Stewart } 232077acdc25SRandall Stewart if ((asoc->cumulative_tsn == highest_tsn) && (at >= 8)) { 2321f8829a4aSRandall Stewart /* The complete array was completed by a single FR */ 232277acdc25SRandall Stewart /* highest becomes the cum-ack */ 232337f144ebSMichael Tuexen int clr; 232437f144ebSMichael Tuexen 232537f144ebSMichael Tuexen #ifdef INVARIANTS 232637f144ebSMichael Tuexen unsigned int i; 232737f144ebSMichael Tuexen 232837f144ebSMichael Tuexen #endif 2329f8829a4aSRandall Stewart 2330f8829a4aSRandall Stewart /* clear the array */ 2331b5c16493SMichael Tuexen clr = ((at + 7) >> 3); 2332c4739e2fSRandall Stewart if (clr > asoc->mapping_array_size) { 2333f8829a4aSRandall Stewart clr = asoc->mapping_array_size; 2334f8829a4aSRandall Stewart } 2335f8829a4aSRandall Stewart memset(asoc->mapping_array, 0, clr); 2336830d754dSRandall Stewart memset(asoc->nr_mapping_array, 0, clr); 233737f144ebSMichael Tuexen #ifdef INVARIANTS 2338b5c16493SMichael Tuexen for (i = 0; i < asoc->mapping_array_size; i++) { 2339b5c16493SMichael Tuexen if ((asoc->mapping_array[i]) || (asoc->nr_mapping_array[i])) { 2340b5c16493SMichael Tuexen printf("Error Mapping array's not clean at clear\n"); 2341b5c16493SMichael Tuexen sctp_print_mapping_array(asoc); 2342b5c16493SMichael Tuexen } 2343b5c16493SMichael Tuexen } 234437f144ebSMichael Tuexen #endif 234577acdc25SRandall Stewart asoc->mapping_array_base_tsn = asoc->cumulative_tsn + 1; 234677acdc25SRandall Stewart asoc->highest_tsn_inside_nr_map = asoc->highest_tsn_inside_map = asoc->cumulative_tsn; 2347f8829a4aSRandall Stewart } else if (at >= 8) { 2348f8829a4aSRandall Stewart /* we can slide the mapping array down */ 2349b3f1ea41SRandall Stewart /* slide_from holds where we hit the first NON 0xff byte */ 2350b3f1ea41SRandall Stewart 2351f8829a4aSRandall Stewart /* 2352f8829a4aSRandall Stewart * now calculate the ceiling of the move using our highest 2353f8829a4aSRandall Stewart * TSN value 2354f8829a4aSRandall Stewart */ 235577acdc25SRandall Stewart SCTP_CALC_TSN_TO_GAP(lgap, highest_tsn, asoc->mapping_array_base_tsn); 235677acdc25SRandall Stewart slide_end = (lgap >> 3); 2357f8829a4aSRandall Stewart if (slide_end < slide_from) { 235877acdc25SRandall Stewart sctp_print_mapping_array(asoc); 2359d55b0b1bSRandall Stewart #ifdef INVARIANTS 2360f8829a4aSRandall Stewart panic("impossible slide"); 2361d55b0b1bSRandall Stewart #else 236277acdc25SRandall Stewart printf("impossible slide lgap:%x slide_end:%x slide_from:%x? at:%d\n", 236377acdc25SRandall Stewart lgap, slide_end, slide_from, at); 2364d55b0b1bSRandall Stewart return; 2365d55b0b1bSRandall Stewart #endif 2366f8829a4aSRandall Stewart } 2367b3f1ea41SRandall Stewart if (slide_end > asoc->mapping_array_size) { 2368b3f1ea41SRandall Stewart #ifdef INVARIANTS 2369b3f1ea41SRandall Stewart panic("would overrun buffer"); 2370b3f1ea41SRandall Stewart #else 2371b3f1ea41SRandall Stewart printf("Gak, would have overrun map end:%d slide_end:%d\n", 2372b3f1ea41SRandall Stewart asoc->mapping_array_size, slide_end); 2373b3f1ea41SRandall Stewart slide_end = asoc->mapping_array_size; 2374b3f1ea41SRandall Stewart #endif 2375b3f1ea41SRandall Stewart } 2376f8829a4aSRandall Stewart distance = (slide_end - slide_from) + 1; 2377b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_MAP_LOGGING_ENABLE) { 2378f8829a4aSRandall Stewart sctp_log_map(old_base, old_cumack, old_highest, 2379f8829a4aSRandall Stewart SCTP_MAP_PREPARE_SLIDE); 2380f8829a4aSRandall Stewart sctp_log_map((uint32_t) slide_from, (uint32_t) slide_end, 2381f8829a4aSRandall Stewart (uint32_t) lgap, SCTP_MAP_SLIDE_FROM); 238280fefe0aSRandall Stewart } 2383f8829a4aSRandall Stewart if (distance + slide_from > asoc->mapping_array_size || 2384f8829a4aSRandall Stewart distance < 0) { 2385f8829a4aSRandall Stewart /* 2386f8829a4aSRandall Stewart * Here we do NOT slide forward the array so that 2387f8829a4aSRandall Stewart * hopefully when more data comes in to fill it up 2388f8829a4aSRandall Stewart * we will be able to slide it forward. Really I 2389f8829a4aSRandall Stewart * don't think this should happen :-0 2390f8829a4aSRandall Stewart */ 2391f8829a4aSRandall Stewart 2392b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_MAP_LOGGING_ENABLE) { 2393f8829a4aSRandall Stewart sctp_log_map((uint32_t) distance, (uint32_t) slide_from, 2394f8829a4aSRandall Stewart (uint32_t) asoc->mapping_array_size, 2395f8829a4aSRandall Stewart SCTP_MAP_SLIDE_NONE); 239680fefe0aSRandall Stewart } 2397f8829a4aSRandall Stewart } else { 2398f8829a4aSRandall Stewart int ii; 2399f8829a4aSRandall Stewart 2400f8829a4aSRandall Stewart for (ii = 0; ii < distance; ii++) { 240137f144ebSMichael Tuexen asoc->mapping_array[ii] = asoc->mapping_array[slide_from + ii]; 240237f144ebSMichael Tuexen asoc->nr_mapping_array[ii] = asoc->nr_mapping_array[slide_from + ii]; 240377acdc25SRandall Stewart 2404f8829a4aSRandall Stewart } 2405aed5947cSMichael Tuexen for (ii = distance; ii < asoc->mapping_array_size; ii++) { 2406f8829a4aSRandall Stewart asoc->mapping_array[ii] = 0; 240777acdc25SRandall Stewart asoc->nr_mapping_array[ii] = 0; 2408f8829a4aSRandall Stewart } 2409ee94f0a2SMichael Tuexen if (asoc->highest_tsn_inside_map + 1 == asoc->mapping_array_base_tsn) { 2410ee94f0a2SMichael Tuexen asoc->highest_tsn_inside_map += (slide_from << 3); 2411ee94f0a2SMichael Tuexen } 2412ee94f0a2SMichael Tuexen if (asoc->highest_tsn_inside_nr_map + 1 == asoc->mapping_array_base_tsn) { 2413ee94f0a2SMichael Tuexen asoc->highest_tsn_inside_nr_map += (slide_from << 3); 2414ee94f0a2SMichael Tuexen } 2415f8829a4aSRandall Stewart asoc->mapping_array_base_tsn += (slide_from << 3); 2416b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_MAP_LOGGING_ENABLE) { 2417f8829a4aSRandall Stewart sctp_log_map(asoc->mapping_array_base_tsn, 2418f8829a4aSRandall Stewart asoc->cumulative_tsn, asoc->highest_tsn_inside_map, 2419f8829a4aSRandall Stewart SCTP_MAP_SLIDE_RESULT); 242080fefe0aSRandall Stewart } 2421830d754dSRandall Stewart } 2422830d754dSRandall Stewart } 2423b5c16493SMichael Tuexen } 2424b5c16493SMichael Tuexen 2425b5c16493SMichael Tuexen 2426b5c16493SMichael Tuexen void 2427b5c16493SMichael Tuexen sctp_sack_check(struct sctp_tcb *stcb, int was_a_gap, int *abort_flag) 2428b5c16493SMichael Tuexen { 2429b5c16493SMichael Tuexen struct sctp_association *asoc; 2430b5c16493SMichael Tuexen uint32_t highest_tsn; 2431b5c16493SMichael Tuexen 2432b5c16493SMichael Tuexen asoc = &stcb->asoc; 2433b5c16493SMichael Tuexen if (compare_with_wrap(asoc->highest_tsn_inside_nr_map, 2434b5c16493SMichael Tuexen asoc->highest_tsn_inside_map, 2435b5c16493SMichael Tuexen MAX_TSN)) { 2436b5c16493SMichael Tuexen highest_tsn = asoc->highest_tsn_inside_nr_map; 2437b5c16493SMichael Tuexen } else { 2438b5c16493SMichael Tuexen highest_tsn = asoc->highest_tsn_inside_map; 2439b5c16493SMichael Tuexen } 2440b5c16493SMichael Tuexen 2441830d754dSRandall Stewart /* 2442f8829a4aSRandall Stewart * Now we need to see if we need to queue a sack or just start the 2443f8829a4aSRandall Stewart * timer (if allowed). 2444f8829a4aSRandall Stewart */ 2445f8829a4aSRandall Stewart if (SCTP_GET_STATE(asoc) == SCTP_STATE_SHUTDOWN_SENT) { 2446f8829a4aSRandall Stewart /* 2447b5c16493SMichael Tuexen * Ok special case, in SHUTDOWN-SENT case. here we maker 2448b5c16493SMichael Tuexen * sure SACK timer is off and instead send a SHUTDOWN and a 2449b5c16493SMichael Tuexen * SACK 2450f8829a4aSRandall Stewart */ 2451139bc87fSRandall Stewart if (SCTP_OS_TIMER_PENDING(&stcb->asoc.dack_timer.timer)) { 2452f8829a4aSRandall Stewart sctp_timer_stop(SCTP_TIMER_TYPE_RECV, 2453a5d547adSRandall Stewart stcb->sctp_ep, stcb, NULL, SCTP_FROM_SCTP_INDATA + SCTP_LOC_18); 2454f8829a4aSRandall Stewart } 2455f8829a4aSRandall Stewart sctp_send_shutdown(stcb, stcb->asoc.primary_destination); 2456f8829a4aSRandall Stewart sctp_send_sack(stcb); 2457f8829a4aSRandall Stewart } else { 2458f8829a4aSRandall Stewart int is_a_gap; 2459f8829a4aSRandall Stewart 2460f8829a4aSRandall Stewart /* is there a gap now ? */ 246177acdc25SRandall Stewart is_a_gap = compare_with_wrap(highest_tsn, stcb->asoc.cumulative_tsn, MAX_TSN); 2462f8829a4aSRandall Stewart 2463f8829a4aSRandall Stewart /* 2464b5c16493SMichael Tuexen * CMT DAC algorithm: increase number of packets received 2465b5c16493SMichael Tuexen * since last ack 2466f8829a4aSRandall Stewart */ 2467f8829a4aSRandall Stewart stcb->asoc.cmt_dac_pkts_rcvd++; 2468f8829a4aSRandall Stewart 246942551e99SRandall Stewart if ((stcb->asoc.send_sack == 1) || /* We need to send a 247042551e99SRandall Stewart * SACK */ 2471f8829a4aSRandall Stewart ((was_a_gap) && (is_a_gap == 0)) || /* was a gap, but no 2472f8829a4aSRandall Stewart * longer is one */ 2473f8829a4aSRandall Stewart (stcb->asoc.numduptsns) || /* we have dup's */ 2474f8829a4aSRandall Stewart (is_a_gap) || /* is still a gap */ 247542551e99SRandall Stewart (stcb->asoc.delayed_ack == 0) || /* Delayed sack disabled */ 247642551e99SRandall Stewart (stcb->asoc.data_pkts_seen >= stcb->asoc.sack_freq) /* hit limit of pkts */ 2477f8829a4aSRandall Stewart ) { 2478f8829a4aSRandall Stewart 2479*7c99d56fSMichael Tuexen if ((stcb->asoc.sctp_cmt_on_off > 0) && 2480b3f1ea41SRandall Stewart (SCTP_BASE_SYSCTL(sctp_cmt_use_dac)) && 248142551e99SRandall Stewart (stcb->asoc.send_sack == 0) && 2482f8829a4aSRandall Stewart (stcb->asoc.numduptsns == 0) && 2483f8829a4aSRandall Stewart (stcb->asoc.delayed_ack) && 2484139bc87fSRandall Stewart (!SCTP_OS_TIMER_PENDING(&stcb->asoc.dack_timer.timer))) { 2485f8829a4aSRandall Stewart 2486f8829a4aSRandall Stewart /* 2487b5c16493SMichael Tuexen * CMT DAC algorithm: With CMT, delay acks 2488b5c16493SMichael Tuexen * even in the face of 2489f8829a4aSRandall Stewart * 2490b5c16493SMichael Tuexen * reordering. Therefore, if acks that do not 2491b5c16493SMichael Tuexen * have to be sent because of the above 2492b5c16493SMichael Tuexen * reasons, will be delayed. That is, acks 2493b5c16493SMichael Tuexen * that would have been sent due to gap 2494b5c16493SMichael Tuexen * reports will be delayed with DAC. Start 2495f8829a4aSRandall Stewart * the delayed ack timer. 2496f8829a4aSRandall Stewart */ 2497f8829a4aSRandall Stewart sctp_timer_start(SCTP_TIMER_TYPE_RECV, 2498f8829a4aSRandall Stewart stcb->sctp_ep, stcb, NULL); 2499f8829a4aSRandall Stewart } else { 2500f8829a4aSRandall Stewart /* 2501b5c16493SMichael Tuexen * Ok we must build a SACK since the timer 2502b5c16493SMichael Tuexen * is pending, we got our first packet OR 2503b5c16493SMichael Tuexen * there are gaps or duplicates. 2504f8829a4aSRandall Stewart */ 2505ad81507eSRandall Stewart (void)SCTP_OS_TIMER_STOP(&stcb->asoc.dack_timer.timer); 2506f8829a4aSRandall Stewart sctp_send_sack(stcb); 2507f8829a4aSRandall Stewart } 2508f8829a4aSRandall Stewart } else { 250942551e99SRandall Stewart if (!SCTP_OS_TIMER_PENDING(&stcb->asoc.dack_timer.timer)) { 2510f8829a4aSRandall Stewart sctp_timer_start(SCTP_TIMER_TYPE_RECV, 2511f8829a4aSRandall Stewart stcb->sctp_ep, stcb, NULL); 2512f8829a4aSRandall Stewart } 2513f8829a4aSRandall Stewart } 2514f8829a4aSRandall Stewart } 2515f8829a4aSRandall Stewart } 2516f8829a4aSRandall Stewart 2517f8829a4aSRandall Stewart void 2518f8829a4aSRandall Stewart sctp_service_queues(struct sctp_tcb *stcb, struct sctp_association *asoc) 2519f8829a4aSRandall Stewart { 2520f8829a4aSRandall Stewart struct sctp_tmit_chunk *chk; 2521810ec536SMichael Tuexen uint32_t tsize, pd_point; 2522f8829a4aSRandall Stewart uint16_t nxt_todel; 2523f8829a4aSRandall Stewart 2524f8829a4aSRandall Stewart if (asoc->fragmented_delivery_inprogress) { 2525f8829a4aSRandall Stewart sctp_service_reassembly(stcb, asoc); 2526f8829a4aSRandall Stewart } 2527f8829a4aSRandall Stewart /* Can we proceed further, i.e. the PD-API is complete */ 2528f8829a4aSRandall Stewart if (asoc->fragmented_delivery_inprogress) { 2529f8829a4aSRandall Stewart /* no */ 2530f8829a4aSRandall Stewart return; 2531f8829a4aSRandall Stewart } 2532f8829a4aSRandall Stewart /* 2533f8829a4aSRandall Stewart * Now is there some other chunk I can deliver from the reassembly 2534f8829a4aSRandall Stewart * queue. 2535f8829a4aSRandall Stewart */ 2536139bc87fSRandall Stewart doit_again: 2537f8829a4aSRandall Stewart chk = TAILQ_FIRST(&asoc->reasmqueue); 2538f8829a4aSRandall Stewart if (chk == NULL) { 2539f8829a4aSRandall Stewart asoc->size_on_reasm_queue = 0; 2540f8829a4aSRandall Stewart asoc->cnt_on_reasm_queue = 0; 2541f8829a4aSRandall Stewart return; 2542f8829a4aSRandall Stewart } 2543f8829a4aSRandall Stewart nxt_todel = asoc->strmin[chk->rec.data.stream_number].last_sequence_delivered + 1; 2544f8829a4aSRandall Stewart if ((chk->rec.data.rcv_flags & SCTP_DATA_FIRST_FRAG) && 2545f8829a4aSRandall Stewart ((nxt_todel == chk->rec.data.stream_seq) || 2546f8829a4aSRandall Stewart (chk->rec.data.rcv_flags & SCTP_DATA_UNORDERED))) { 2547f8829a4aSRandall Stewart /* 2548f8829a4aSRandall Stewart * Yep the first one is here. We setup to start reception, 2549f8829a4aSRandall Stewart * by backing down the TSN just in case we can't deliver. 2550f8829a4aSRandall Stewart */ 2551f8829a4aSRandall Stewart 2552f8829a4aSRandall Stewart /* 2553f8829a4aSRandall Stewart * Before we start though either all of the message should 255424ae5c4aSMichael Tuexen * be here or the socket buffer max or nothing on the 2555f8829a4aSRandall Stewart * delivery queue and something can be delivered. 2556f8829a4aSRandall Stewart */ 2557810ec536SMichael Tuexen if (stcb->sctp_socket) { 255824ae5c4aSMichael Tuexen pd_point = min(SCTP_SB_LIMIT_RCV(stcb->sctp_socket), 2559810ec536SMichael Tuexen stcb->sctp_ep->partial_delivery_point); 2560810ec536SMichael Tuexen } else { 2561810ec536SMichael Tuexen pd_point = stcb->sctp_ep->partial_delivery_point; 2562810ec536SMichael Tuexen } 2563810ec536SMichael Tuexen if (sctp_is_all_msg_on_reasm(asoc, &tsize) || (tsize >= pd_point)) { 2564f8829a4aSRandall Stewart asoc->fragmented_delivery_inprogress = 1; 2565f8829a4aSRandall Stewart asoc->tsn_last_delivered = chk->rec.data.TSN_seq - 1; 2566f8829a4aSRandall Stewart asoc->str_of_pdapi = chk->rec.data.stream_number; 2567f8829a4aSRandall Stewart asoc->ssn_of_pdapi = chk->rec.data.stream_seq; 2568f8829a4aSRandall Stewart asoc->pdapi_ppid = chk->rec.data.payloadtype; 2569f8829a4aSRandall Stewart asoc->fragment_flags = chk->rec.data.rcv_flags; 2570f8829a4aSRandall Stewart sctp_service_reassembly(stcb, asoc); 2571139bc87fSRandall Stewart if (asoc->fragmented_delivery_inprogress == 0) { 2572139bc87fSRandall Stewart goto doit_again; 2573139bc87fSRandall Stewart } 2574f8829a4aSRandall Stewart } 2575f8829a4aSRandall Stewart } 2576f8829a4aSRandall Stewart } 2577f8829a4aSRandall Stewart 2578f8829a4aSRandall Stewart int 2579f8829a4aSRandall Stewart sctp_process_data(struct mbuf **mm, int iphlen, int *offset, int length, 2580f8829a4aSRandall Stewart struct sctphdr *sh, struct sctp_inpcb *inp, struct sctp_tcb *stcb, 2581f8829a4aSRandall Stewart struct sctp_nets *net, uint32_t * high_tsn) 2582f8829a4aSRandall Stewart { 2583f8829a4aSRandall Stewart struct sctp_data_chunk *ch, chunk_buf; 2584f8829a4aSRandall Stewart struct sctp_association *asoc; 2585f8829a4aSRandall Stewart int num_chunks = 0; /* number of control chunks processed */ 2586f8829a4aSRandall Stewart int stop_proc = 0; 2587f8829a4aSRandall Stewart int chk_length, break_flag, last_chunk; 25888f777478SMichael Tuexen int abort_flag = 0, was_a_gap; 2589f8829a4aSRandall Stewart struct mbuf *m; 25908f777478SMichael Tuexen uint32_t highest_tsn; 2591f8829a4aSRandall Stewart 2592f8829a4aSRandall Stewart /* set the rwnd */ 2593f8829a4aSRandall Stewart sctp_set_rwnd(stcb, &stcb->asoc); 2594f8829a4aSRandall Stewart 2595f8829a4aSRandall Stewart m = *mm; 2596f8829a4aSRandall Stewart SCTP_TCB_LOCK_ASSERT(stcb); 2597f8829a4aSRandall Stewart asoc = &stcb->asoc; 25988f777478SMichael Tuexen if (compare_with_wrap(asoc->highest_tsn_inside_nr_map, asoc->highest_tsn_inside_map, MAX_TSN)) { 25998f777478SMichael Tuexen highest_tsn = asoc->highest_tsn_inside_nr_map; 26008f777478SMichael Tuexen } else { 26018f777478SMichael Tuexen highest_tsn = asoc->highest_tsn_inside_map; 2602f8829a4aSRandall Stewart } 26038f777478SMichael Tuexen was_a_gap = compare_with_wrap(highest_tsn, stcb->asoc.cumulative_tsn, MAX_TSN); 2604f8829a4aSRandall Stewart /* 2605f8829a4aSRandall Stewart * setup where we got the last DATA packet from for any SACK that 2606f8829a4aSRandall Stewart * may need to go out. Don't bump the net. This is done ONLY when a 2607f8829a4aSRandall Stewart * chunk is assigned. 2608f8829a4aSRandall Stewart */ 2609f8829a4aSRandall Stewart asoc->last_data_chunk_from = net; 2610f8829a4aSRandall Stewart 2611d06c82f1SRandall Stewart /*- 2612f8829a4aSRandall Stewart * Now before we proceed we must figure out if this is a wasted 2613f8829a4aSRandall Stewart * cluster... i.e. it is a small packet sent in and yet the driver 2614f8829a4aSRandall Stewart * underneath allocated a full cluster for it. If so we must copy it 2615f8829a4aSRandall Stewart * to a smaller mbuf and free up the cluster mbuf. This will help 2616d06c82f1SRandall Stewart * with cluster starvation. Note for __Panda__ we don't do this 2617d06c82f1SRandall Stewart * since it has clusters all the way down to 64 bytes. 2618f8829a4aSRandall Stewart */ 261944b7479bSRandall Stewart if (SCTP_BUF_LEN(m) < (long)MLEN && SCTP_BUF_NEXT(m) == NULL) { 2620f8829a4aSRandall Stewart /* we only handle mbufs that are singletons.. not chains */ 2621139bc87fSRandall Stewart m = sctp_get_mbuf_for_msg(SCTP_BUF_LEN(m), 0, M_DONTWAIT, 1, MT_DATA); 2622f8829a4aSRandall Stewart if (m) { 2623f8829a4aSRandall Stewart /* ok lets see if we can copy the data up */ 2624f8829a4aSRandall Stewart caddr_t *from, *to; 2625f8829a4aSRandall Stewart 2626f8829a4aSRandall Stewart /* get the pointers and copy */ 2627f8829a4aSRandall Stewart to = mtod(m, caddr_t *); 2628f8829a4aSRandall Stewart from = mtod((*mm), caddr_t *); 2629139bc87fSRandall Stewart memcpy(to, from, SCTP_BUF_LEN((*mm))); 2630f8829a4aSRandall Stewart /* copy the length and free up the old */ 2631139bc87fSRandall Stewart SCTP_BUF_LEN(m) = SCTP_BUF_LEN((*mm)); 2632f8829a4aSRandall Stewart sctp_m_freem(*mm); 2633f8829a4aSRandall Stewart /* sucess, back copy */ 2634f8829a4aSRandall Stewart *mm = m; 2635f8829a4aSRandall Stewart } else { 2636f8829a4aSRandall Stewart /* We are in trouble in the mbuf world .. yikes */ 2637f8829a4aSRandall Stewart m = *mm; 2638f8829a4aSRandall Stewart } 2639f8829a4aSRandall Stewart } 2640f8829a4aSRandall Stewart /* get pointer to the first chunk header */ 2641f8829a4aSRandall Stewart ch = (struct sctp_data_chunk *)sctp_m_getptr(m, *offset, 2642f8829a4aSRandall Stewart sizeof(struct sctp_data_chunk), (uint8_t *) & chunk_buf); 2643f8829a4aSRandall Stewart if (ch == NULL) { 2644f8829a4aSRandall Stewart return (1); 2645f8829a4aSRandall Stewart } 2646f8829a4aSRandall Stewart /* 2647f8829a4aSRandall Stewart * process all DATA chunks... 2648f8829a4aSRandall Stewart */ 2649f8829a4aSRandall Stewart *high_tsn = asoc->cumulative_tsn; 2650f8829a4aSRandall Stewart break_flag = 0; 265142551e99SRandall Stewart asoc->data_pkts_seen++; 2652f8829a4aSRandall Stewart while (stop_proc == 0) { 2653f8829a4aSRandall Stewart /* validate chunk length */ 2654f8829a4aSRandall Stewart chk_length = ntohs(ch->ch.chunk_length); 2655f8829a4aSRandall Stewart if (length - *offset < chk_length) { 2656f8829a4aSRandall Stewart /* all done, mutulated chunk */ 2657f8829a4aSRandall Stewart stop_proc = 1; 2658f8829a4aSRandall Stewart break; 2659f8829a4aSRandall Stewart } 2660f8829a4aSRandall Stewart if (ch->ch.chunk_type == SCTP_DATA) { 2661f8829a4aSRandall Stewart if ((size_t)chk_length < sizeof(struct sctp_data_chunk) + 1) { 2662f8829a4aSRandall Stewart /* 2663f8829a4aSRandall Stewart * Need to send an abort since we had a 2664f8829a4aSRandall Stewart * invalid data chunk. 2665f8829a4aSRandall Stewart */ 2666f8829a4aSRandall Stewart struct mbuf *op_err; 2667f8829a4aSRandall Stewart 2668139bc87fSRandall Stewart op_err = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + 2 * sizeof(uint32_t)), 2669f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 2670f8829a4aSRandall Stewart 2671f8829a4aSRandall Stewart if (op_err) { 2672f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 2673f8829a4aSRandall Stewart uint32_t *ippp; 2674f8829a4aSRandall Stewart 2675139bc87fSRandall Stewart SCTP_BUF_LEN(op_err) = sizeof(struct sctp_paramhdr) + 2676f8829a4aSRandall Stewart (2 * sizeof(uint32_t)); 2677f8829a4aSRandall Stewart ph = mtod(op_err, struct sctp_paramhdr *); 2678f8829a4aSRandall Stewart ph->param_type = 2679f8829a4aSRandall Stewart htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 2680139bc87fSRandall Stewart ph->param_length = htons(SCTP_BUF_LEN(op_err)); 2681f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 2682a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_19); 2683f8829a4aSRandall Stewart ippp++; 2684f8829a4aSRandall Stewart *ippp = asoc->cumulative_tsn; 2685f8829a4aSRandall Stewart 2686f8829a4aSRandall Stewart } 2687a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_19; 2688f8829a4aSRandall Stewart sctp_abort_association(inp, stcb, m, iphlen, sh, 2689c54a18d2SRandall Stewart op_err, 0, net->port); 2690f8829a4aSRandall Stewart return (2); 2691f8829a4aSRandall Stewart } 2692f8829a4aSRandall Stewart #ifdef SCTP_AUDITING_ENABLED 2693f8829a4aSRandall Stewart sctp_audit_log(0xB1, 0); 2694f8829a4aSRandall Stewart #endif 2695f8829a4aSRandall Stewart if (SCTP_SIZE32(chk_length) == (length - *offset)) { 2696f8829a4aSRandall Stewart last_chunk = 1; 2697f8829a4aSRandall Stewart } else { 2698f8829a4aSRandall Stewart last_chunk = 0; 2699f8829a4aSRandall Stewart } 2700f8829a4aSRandall Stewart if (sctp_process_a_data_chunk(stcb, asoc, mm, *offset, ch, 2701f8829a4aSRandall Stewart chk_length, net, high_tsn, &abort_flag, &break_flag, 2702f8829a4aSRandall Stewart last_chunk)) { 2703f8829a4aSRandall Stewart num_chunks++; 2704f8829a4aSRandall Stewart } 2705f8829a4aSRandall Stewart if (abort_flag) 2706f8829a4aSRandall Stewart return (2); 2707f8829a4aSRandall Stewart 2708f8829a4aSRandall Stewart if (break_flag) { 2709f8829a4aSRandall Stewart /* 2710f8829a4aSRandall Stewart * Set because of out of rwnd space and no 2711f8829a4aSRandall Stewart * drop rep space left. 2712f8829a4aSRandall Stewart */ 2713f8829a4aSRandall Stewart stop_proc = 1; 2714f8829a4aSRandall Stewart break; 2715f8829a4aSRandall Stewart } 2716f8829a4aSRandall Stewart } else { 2717f8829a4aSRandall Stewart /* not a data chunk in the data region */ 2718f8829a4aSRandall Stewart switch (ch->ch.chunk_type) { 2719f8829a4aSRandall Stewart case SCTP_INITIATION: 2720f8829a4aSRandall Stewart case SCTP_INITIATION_ACK: 2721f8829a4aSRandall Stewart case SCTP_SELECTIVE_ACK: 2722830d754dSRandall Stewart case SCTP_NR_SELECTIVE_ACK: /* EY */ 2723f8829a4aSRandall Stewart case SCTP_HEARTBEAT_REQUEST: 2724f8829a4aSRandall Stewart case SCTP_HEARTBEAT_ACK: 2725f8829a4aSRandall Stewart case SCTP_ABORT_ASSOCIATION: 2726f8829a4aSRandall Stewart case SCTP_SHUTDOWN: 2727f8829a4aSRandall Stewart case SCTP_SHUTDOWN_ACK: 2728f8829a4aSRandall Stewart case SCTP_OPERATION_ERROR: 2729f8829a4aSRandall Stewart case SCTP_COOKIE_ECHO: 2730f8829a4aSRandall Stewart case SCTP_COOKIE_ACK: 2731f8829a4aSRandall Stewart case SCTP_ECN_ECHO: 2732f8829a4aSRandall Stewart case SCTP_ECN_CWR: 2733f8829a4aSRandall Stewart case SCTP_SHUTDOWN_COMPLETE: 2734f8829a4aSRandall Stewart case SCTP_AUTHENTICATION: 2735f8829a4aSRandall Stewart case SCTP_ASCONF_ACK: 2736f8829a4aSRandall Stewart case SCTP_PACKET_DROPPED: 2737f8829a4aSRandall Stewart case SCTP_STREAM_RESET: 2738f8829a4aSRandall Stewart case SCTP_FORWARD_CUM_TSN: 2739f8829a4aSRandall Stewart case SCTP_ASCONF: 2740f8829a4aSRandall Stewart /* 2741f8829a4aSRandall Stewart * Now, what do we do with KNOWN chunks that 2742f8829a4aSRandall Stewart * are NOT in the right place? 2743f8829a4aSRandall Stewart * 2744f8829a4aSRandall Stewart * For now, I do nothing but ignore them. We 2745f8829a4aSRandall Stewart * may later want to add sysctl stuff to 2746f8829a4aSRandall Stewart * switch out and do either an ABORT() or 2747f8829a4aSRandall Stewart * possibly process them. 2748f8829a4aSRandall Stewart */ 2749b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_strict_data_order)) { 2750f8829a4aSRandall Stewart struct mbuf *op_err; 2751f8829a4aSRandall Stewart 2752f8829a4aSRandall Stewart op_err = sctp_generate_invmanparam(SCTP_CAUSE_PROTOCOL_VIOLATION); 2753c54a18d2SRandall Stewart sctp_abort_association(inp, stcb, m, iphlen, sh, op_err, 0, net->port); 2754f8829a4aSRandall Stewart return (2); 2755f8829a4aSRandall Stewart } 2756f8829a4aSRandall Stewart break; 2757f8829a4aSRandall Stewart default: 2758f8829a4aSRandall Stewart /* unknown chunk type, use bit rules */ 2759f8829a4aSRandall Stewart if (ch->ch.chunk_type & 0x40) { 2760f8829a4aSRandall Stewart /* Add a error report to the queue */ 2761d61a0ae0SRandall Stewart struct mbuf *merr; 2762f8829a4aSRandall Stewart struct sctp_paramhdr *phd; 2763f8829a4aSRandall Stewart 2764d61a0ae0SRandall Stewart merr = sctp_get_mbuf_for_msg(sizeof(*phd), 0, M_DONTWAIT, 1, MT_DATA); 2765d61a0ae0SRandall Stewart if (merr) { 2766d61a0ae0SRandall Stewart phd = mtod(merr, struct sctp_paramhdr *); 2767f8829a4aSRandall Stewart /* 2768f8829a4aSRandall Stewart * We cheat and use param 2769f8829a4aSRandall Stewart * type since we did not 2770f8829a4aSRandall Stewart * bother to define a error 2771f8829a4aSRandall Stewart * cause struct. They are 2772f8829a4aSRandall Stewart * the same basic format 2773f8829a4aSRandall Stewart * with different names. 2774f8829a4aSRandall Stewart */ 2775f8829a4aSRandall Stewart phd->param_type = 2776f8829a4aSRandall Stewart htons(SCTP_CAUSE_UNRECOG_CHUNK); 2777f8829a4aSRandall Stewart phd->param_length = 2778f8829a4aSRandall Stewart htons(chk_length + sizeof(*phd)); 2779d61a0ae0SRandall Stewart SCTP_BUF_LEN(merr) = sizeof(*phd); 2780d61a0ae0SRandall Stewart SCTP_BUF_NEXT(merr) = SCTP_M_COPYM(m, *offset, 2781f8829a4aSRandall Stewart SCTP_SIZE32(chk_length), 2782f8829a4aSRandall Stewart M_DONTWAIT); 2783d61a0ae0SRandall Stewart if (SCTP_BUF_NEXT(merr)) { 2784d61a0ae0SRandall Stewart sctp_queue_op_err(stcb, merr); 2785f8829a4aSRandall Stewart } else { 2786d61a0ae0SRandall Stewart sctp_m_freem(merr); 2787f8829a4aSRandall Stewart } 2788f8829a4aSRandall Stewart } 2789f8829a4aSRandall Stewart } 2790f8829a4aSRandall Stewart if ((ch->ch.chunk_type & 0x80) == 0) { 2791f8829a4aSRandall Stewart /* discard the rest of this packet */ 2792f8829a4aSRandall Stewart stop_proc = 1; 2793f8829a4aSRandall Stewart } /* else skip this bad chunk and 2794f8829a4aSRandall Stewart * continue... */ 2795f8829a4aSRandall Stewart break; 2796f8829a4aSRandall Stewart }; /* switch of chunk type */ 2797f8829a4aSRandall Stewart } 2798f8829a4aSRandall Stewart *offset += SCTP_SIZE32(chk_length); 2799f8829a4aSRandall Stewart if ((*offset >= length) || stop_proc) { 2800f8829a4aSRandall Stewart /* no more data left in the mbuf chain */ 2801f8829a4aSRandall Stewart stop_proc = 1; 2802f8829a4aSRandall Stewart continue; 2803f8829a4aSRandall Stewart } 2804f8829a4aSRandall Stewart ch = (struct sctp_data_chunk *)sctp_m_getptr(m, *offset, 2805f8829a4aSRandall Stewart sizeof(struct sctp_data_chunk), (uint8_t *) & chunk_buf); 2806f8829a4aSRandall Stewart if (ch == NULL) { 2807f8829a4aSRandall Stewart *offset = length; 2808f8829a4aSRandall Stewart stop_proc = 1; 2809f8829a4aSRandall Stewart break; 2810f8829a4aSRandall Stewart 2811f8829a4aSRandall Stewart } 2812f8829a4aSRandall Stewart } /* while */ 2813f8829a4aSRandall Stewart if (break_flag) { 2814f8829a4aSRandall Stewart /* 2815f8829a4aSRandall Stewart * we need to report rwnd overrun drops. 2816f8829a4aSRandall Stewart */ 2817f8829a4aSRandall Stewart sctp_send_packet_dropped(stcb, net, *mm, iphlen, 0); 2818f8829a4aSRandall Stewart } 2819f8829a4aSRandall Stewart if (num_chunks) { 2820f8829a4aSRandall Stewart /* 2821ceaad40aSRandall Stewart * Did we get data, if so update the time for auto-close and 2822f8829a4aSRandall Stewart * give peer credit for being alive. 2823f8829a4aSRandall Stewart */ 2824f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_recvpktwithdata); 2825b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_THRESHOLD_LOGGING) { 2826c4739e2fSRandall Stewart sctp_misc_ints(SCTP_THRESHOLD_CLEAR, 2827c4739e2fSRandall Stewart stcb->asoc.overall_error_count, 2828c4739e2fSRandall Stewart 0, 2829c4739e2fSRandall Stewart SCTP_FROM_SCTP_INDATA, 2830c4739e2fSRandall Stewart __LINE__); 2831c4739e2fSRandall Stewart } 2832f8829a4aSRandall Stewart stcb->asoc.overall_error_count = 0; 28336e55db54SRandall Stewart (void)SCTP_GETTIME_TIMEVAL(&stcb->asoc.time_last_rcvd); 2834f8829a4aSRandall Stewart } 2835f8829a4aSRandall Stewart /* now service all of the reassm queue if needed */ 2836f8829a4aSRandall Stewart if (!(TAILQ_EMPTY(&asoc->reasmqueue))) 2837f8829a4aSRandall Stewart sctp_service_queues(stcb, asoc); 2838f8829a4aSRandall Stewart 2839f8829a4aSRandall Stewart if (SCTP_GET_STATE(asoc) == SCTP_STATE_SHUTDOWN_SENT) { 284042551e99SRandall Stewart /* Assure that we ack right away */ 284142551e99SRandall Stewart stcb->asoc.send_sack = 1; 2842f8829a4aSRandall Stewart } 2843f8829a4aSRandall Stewart /* Start a sack timer or QUEUE a SACK for sending */ 2844b5c16493SMichael Tuexen sctp_sack_check(stcb, was_a_gap, &abort_flag); 2845f8829a4aSRandall Stewart if (abort_flag) 2846f8829a4aSRandall Stewart return (2); 2847f8829a4aSRandall Stewart 2848f8829a4aSRandall Stewart return (0); 2849f8829a4aSRandall Stewart } 2850f8829a4aSRandall Stewart 28510fa753b3SRandall Stewart static int 28520fa753b3SRandall Stewart sctp_process_segment_range(struct sctp_tcb *stcb, struct sctp_tmit_chunk **p_tp1, uint32_t last_tsn, 28530fa753b3SRandall Stewart uint16_t frag_strt, uint16_t frag_end, int nr_sacking, 28540fa753b3SRandall Stewart int *num_frs, 28550fa753b3SRandall Stewart uint32_t * biggest_newly_acked_tsn, 28560fa753b3SRandall Stewart uint32_t * this_sack_lowest_newack, 28570fa753b3SRandall Stewart int *ecn_seg_sums) 28580fa753b3SRandall Stewart { 28590fa753b3SRandall Stewart struct sctp_tmit_chunk *tp1; 28600fa753b3SRandall Stewart unsigned int theTSN; 2861b5c16493SMichael Tuexen int j, wake_him = 0, circled = 0; 28620fa753b3SRandall Stewart 28630fa753b3SRandall Stewart /* Recover the tp1 we last saw */ 28640fa753b3SRandall Stewart tp1 = *p_tp1; 28650fa753b3SRandall Stewart if (tp1 == NULL) { 28660fa753b3SRandall Stewart tp1 = TAILQ_FIRST(&stcb->asoc.sent_queue); 28670fa753b3SRandall Stewart } 28680fa753b3SRandall Stewart for (j = frag_strt; j <= frag_end; j++) { 28690fa753b3SRandall Stewart theTSN = j + last_tsn; 28700fa753b3SRandall Stewart while (tp1) { 28710fa753b3SRandall Stewart if (tp1->rec.data.doing_fast_retransmit) 28720fa753b3SRandall Stewart (*num_frs) += 1; 28730fa753b3SRandall Stewart 28740fa753b3SRandall Stewart /*- 28750fa753b3SRandall Stewart * CMT: CUCv2 algorithm. For each TSN being 28760fa753b3SRandall Stewart * processed from the sent queue, track the 28770fa753b3SRandall Stewart * next expected pseudo-cumack, or 28780fa753b3SRandall Stewart * rtx_pseudo_cumack, if required. Separate 28790fa753b3SRandall Stewart * cumack trackers for first transmissions, 28800fa753b3SRandall Stewart * and retransmissions. 28810fa753b3SRandall Stewart */ 28820fa753b3SRandall Stewart if ((tp1->whoTo->find_pseudo_cumack == 1) && (tp1->sent < SCTP_DATAGRAM_RESEND) && 28830fa753b3SRandall Stewart (tp1->snd_count == 1)) { 28840fa753b3SRandall Stewart tp1->whoTo->pseudo_cumack = tp1->rec.data.TSN_seq; 28850fa753b3SRandall Stewart tp1->whoTo->find_pseudo_cumack = 0; 28860fa753b3SRandall Stewart } 28870fa753b3SRandall Stewart if ((tp1->whoTo->find_rtx_pseudo_cumack == 1) && (tp1->sent < SCTP_DATAGRAM_RESEND) && 28880fa753b3SRandall Stewart (tp1->snd_count > 1)) { 28890fa753b3SRandall Stewart tp1->whoTo->rtx_pseudo_cumack = tp1->rec.data.TSN_seq; 28900fa753b3SRandall Stewart tp1->whoTo->find_rtx_pseudo_cumack = 0; 28910fa753b3SRandall Stewart } 28920fa753b3SRandall Stewart if (tp1->rec.data.TSN_seq == theTSN) { 28930fa753b3SRandall Stewart if (tp1->sent != SCTP_DATAGRAM_UNSENT) { 28940fa753b3SRandall Stewart /*- 28950fa753b3SRandall Stewart * must be held until 28960fa753b3SRandall Stewart * cum-ack passes 28970fa753b3SRandall Stewart */ 28980fa753b3SRandall Stewart /*- 28990fa753b3SRandall Stewart * ECN Nonce: Add the nonce 29000fa753b3SRandall Stewart * value to the sender's 29010fa753b3SRandall Stewart * nonce sum 29020fa753b3SRandall Stewart */ 29030fa753b3SRandall Stewart if (tp1->sent < SCTP_DATAGRAM_RESEND) { 29040fa753b3SRandall Stewart /*- 29050fa753b3SRandall Stewart * If it is less than RESEND, it is 29060fa753b3SRandall Stewart * now no-longer in flight. 29070fa753b3SRandall Stewart * Higher values may already be set 29080fa753b3SRandall Stewart * via previous Gap Ack Blocks... 29090fa753b3SRandall Stewart * i.e. ACKED or RESEND. 29100fa753b3SRandall Stewart */ 29110fa753b3SRandall Stewart if (compare_with_wrap(tp1->rec.data.TSN_seq, 29120fa753b3SRandall Stewart *biggest_newly_acked_tsn, MAX_TSN)) { 29130fa753b3SRandall Stewart *biggest_newly_acked_tsn = tp1->rec.data.TSN_seq; 29140fa753b3SRandall Stewart } 29150fa753b3SRandall Stewart /*- 29160fa753b3SRandall Stewart * CMT: SFR algo (and HTNA) - set 29170fa753b3SRandall Stewart * saw_newack to 1 for dest being 29180fa753b3SRandall Stewart * newly acked. update 29190fa753b3SRandall Stewart * this_sack_highest_newack if 29200fa753b3SRandall Stewart * appropriate. 29210fa753b3SRandall Stewart */ 29220fa753b3SRandall Stewart if (tp1->rec.data.chunk_was_revoked == 0) 29230fa753b3SRandall Stewart tp1->whoTo->saw_newack = 1; 29240fa753b3SRandall Stewart 29250fa753b3SRandall Stewart if (compare_with_wrap(tp1->rec.data.TSN_seq, 29260fa753b3SRandall Stewart tp1->whoTo->this_sack_highest_newack, 29270fa753b3SRandall Stewart MAX_TSN)) { 29280fa753b3SRandall Stewart tp1->whoTo->this_sack_highest_newack = 29290fa753b3SRandall Stewart tp1->rec.data.TSN_seq; 29300fa753b3SRandall Stewart } 29310fa753b3SRandall Stewart /*- 29320fa753b3SRandall Stewart * CMT DAC algo: also update 29330fa753b3SRandall Stewart * this_sack_lowest_newack 29340fa753b3SRandall Stewart */ 29350fa753b3SRandall Stewart if (*this_sack_lowest_newack == 0) { 29360fa753b3SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_SACK_LOGGING_ENABLE) { 29370fa753b3SRandall Stewart sctp_log_sack(*this_sack_lowest_newack, 29380fa753b3SRandall Stewart last_tsn, 29390fa753b3SRandall Stewart tp1->rec.data.TSN_seq, 29400fa753b3SRandall Stewart 0, 29410fa753b3SRandall Stewart 0, 29420fa753b3SRandall Stewart SCTP_LOG_TSN_ACKED); 29430fa753b3SRandall Stewart } 29440fa753b3SRandall Stewart *this_sack_lowest_newack = tp1->rec.data.TSN_seq; 29450fa753b3SRandall Stewart } 29460fa753b3SRandall Stewart /*- 29470fa753b3SRandall Stewart * CMT: CUCv2 algorithm. If (rtx-)pseudo-cumack for corresp 29480fa753b3SRandall Stewart * dest is being acked, then we have a new (rtx-)pseudo-cumack. Set 29490fa753b3SRandall Stewart * new_(rtx_)pseudo_cumack to TRUE so that the cwnd for this dest can be 29500fa753b3SRandall Stewart * updated. Also trigger search for the next expected (rtx-)pseudo-cumack. 29510fa753b3SRandall Stewart * Separate pseudo_cumack trackers for first transmissions and 29520fa753b3SRandall Stewart * retransmissions. 29530fa753b3SRandall Stewart */ 29540fa753b3SRandall Stewart if (tp1->rec.data.TSN_seq == tp1->whoTo->pseudo_cumack) { 29550fa753b3SRandall Stewart if (tp1->rec.data.chunk_was_revoked == 0) { 29560fa753b3SRandall Stewart tp1->whoTo->new_pseudo_cumack = 1; 29570fa753b3SRandall Stewart } 29580fa753b3SRandall Stewart tp1->whoTo->find_pseudo_cumack = 1; 29590fa753b3SRandall Stewart } 29600fa753b3SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_LOGGING_ENABLE) { 29610fa753b3SRandall Stewart sctp_log_cwnd(stcb, tp1->whoTo, tp1->rec.data.TSN_seq, SCTP_CWND_LOG_FROM_SACK); 29620fa753b3SRandall Stewart } 29630fa753b3SRandall Stewart if (tp1->rec.data.TSN_seq == tp1->whoTo->rtx_pseudo_cumack) { 29640fa753b3SRandall Stewart if (tp1->rec.data.chunk_was_revoked == 0) { 29650fa753b3SRandall Stewart tp1->whoTo->new_pseudo_cumack = 1; 29660fa753b3SRandall Stewart } 29670fa753b3SRandall Stewart tp1->whoTo->find_rtx_pseudo_cumack = 1; 29680fa753b3SRandall Stewart } 29690fa753b3SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_SACK_LOGGING_ENABLE) { 29700fa753b3SRandall Stewart sctp_log_sack(*biggest_newly_acked_tsn, 29710fa753b3SRandall Stewart last_tsn, 29720fa753b3SRandall Stewart tp1->rec.data.TSN_seq, 29730fa753b3SRandall Stewart frag_strt, 29740fa753b3SRandall Stewart frag_end, 29750fa753b3SRandall Stewart SCTP_LOG_TSN_ACKED); 29760fa753b3SRandall Stewart } 29770fa753b3SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_FLIGHT_LOGGING_ENABLE) { 29780fa753b3SRandall Stewart sctp_misc_ints(SCTP_FLIGHT_LOG_DOWN_GAP, 29790fa753b3SRandall Stewart tp1->whoTo->flight_size, 29800fa753b3SRandall Stewart tp1->book_size, 29810fa753b3SRandall Stewart (uintptr_t) tp1->whoTo, 29820fa753b3SRandall Stewart tp1->rec.data.TSN_seq); 29830fa753b3SRandall Stewart } 29840fa753b3SRandall Stewart sctp_flight_size_decrease(tp1); 29850fa753b3SRandall Stewart sctp_total_flight_decrease(stcb, tp1); 29860fa753b3SRandall Stewart 29870fa753b3SRandall Stewart tp1->whoTo->net_ack += tp1->send_size; 29880fa753b3SRandall Stewart if (tp1->snd_count < 2) { 29890fa753b3SRandall Stewart /*- 29900fa753b3SRandall Stewart * True non-retransmited chunk 29910fa753b3SRandall Stewart */ 29920fa753b3SRandall Stewart tp1->whoTo->net_ack2 += tp1->send_size; 29930fa753b3SRandall Stewart 29940fa753b3SRandall Stewart /*- 29950fa753b3SRandall Stewart * update RTO too ? 29960fa753b3SRandall Stewart */ 29970fa753b3SRandall Stewart if (tp1->do_rtt) { 29980fa753b3SRandall Stewart tp1->whoTo->RTO = 29990fa753b3SRandall Stewart sctp_calculate_rto(stcb, 30000fa753b3SRandall Stewart &stcb->asoc, 30010fa753b3SRandall Stewart tp1->whoTo, 30020fa753b3SRandall Stewart &tp1->sent_rcv_time, 30030fa753b3SRandall Stewart sctp_align_safe_nocopy); 30040fa753b3SRandall Stewart tp1->do_rtt = 0; 30050fa753b3SRandall Stewart } 30060fa753b3SRandall Stewart } 30070fa753b3SRandall Stewart } 30080fa753b3SRandall Stewart if (tp1->sent <= SCTP_DATAGRAM_RESEND) { 30090fa753b3SRandall Stewart (*ecn_seg_sums) += tp1->rec.data.ect_nonce; 30100fa753b3SRandall Stewart (*ecn_seg_sums) &= SCTP_SACK_NONCE_SUM; 30110fa753b3SRandall Stewart if (compare_with_wrap(tp1->rec.data.TSN_seq, 30120fa753b3SRandall Stewart stcb->asoc.this_sack_highest_gap, 30130fa753b3SRandall Stewart MAX_TSN)) { 30140fa753b3SRandall Stewart stcb->asoc.this_sack_highest_gap = 30150fa753b3SRandall Stewart tp1->rec.data.TSN_seq; 30160fa753b3SRandall Stewart } 30170fa753b3SRandall Stewart if (tp1->sent == SCTP_DATAGRAM_RESEND) { 30180fa753b3SRandall Stewart sctp_ucount_decr(stcb->asoc.sent_queue_retran_cnt); 30190fa753b3SRandall Stewart #ifdef SCTP_AUDITING_ENABLED 30200fa753b3SRandall Stewart sctp_audit_log(0xB2, 30210fa753b3SRandall Stewart (stcb->asoc.sent_queue_retran_cnt & 0x000000ff)); 30220fa753b3SRandall Stewart #endif 30230fa753b3SRandall Stewart } 30240fa753b3SRandall Stewart } 30250fa753b3SRandall Stewart /*- 30260fa753b3SRandall Stewart * All chunks NOT UNSENT fall through here and are marked 30270fa753b3SRandall Stewart * (leave PR-SCTP ones that are to skip alone though) 30280fa753b3SRandall Stewart */ 30290fa753b3SRandall Stewart if (tp1->sent != SCTP_FORWARD_TSN_SKIP) 30300fa753b3SRandall Stewart tp1->sent = SCTP_DATAGRAM_MARKED; 30310fa753b3SRandall Stewart 30320fa753b3SRandall Stewart if (tp1->rec.data.chunk_was_revoked) { 30330fa753b3SRandall Stewart /* deflate the cwnd */ 30340fa753b3SRandall Stewart tp1->whoTo->cwnd -= tp1->book_size; 30350fa753b3SRandall Stewart tp1->rec.data.chunk_was_revoked = 0; 30360fa753b3SRandall Stewart } 30370fa753b3SRandall Stewart /* NR Sack code here */ 30380fa753b3SRandall Stewart if (nr_sacking) { 30390fa753b3SRandall Stewart if (tp1->data) { 30400fa753b3SRandall Stewart /* 30410fa753b3SRandall Stewart * sa_ignore 30420fa753b3SRandall Stewart * NO_NULL_CHK 30430fa753b3SRandall Stewart */ 30440fa753b3SRandall Stewart sctp_free_bufspace(stcb, &stcb->asoc, tp1, 1); 30450fa753b3SRandall Stewart sctp_m_freem(tp1->data); 30460fa753b3SRandall Stewart tp1->data = NULL; 3047b5c16493SMichael Tuexen } 30480fa753b3SRandall Stewart wake_him++; 30490fa753b3SRandall Stewart } 30500fa753b3SRandall Stewart } 30510fa753b3SRandall Stewart break; 30520fa753b3SRandall Stewart } /* if (tp1->TSN_seq == theTSN) */ 30530fa753b3SRandall Stewart if (compare_with_wrap(tp1->rec.data.TSN_seq, theTSN, 30540fa753b3SRandall Stewart MAX_TSN)) 30550fa753b3SRandall Stewart break; 30560fa753b3SRandall Stewart 30570fa753b3SRandall Stewart tp1 = TAILQ_NEXT(tp1, sctp_next); 3058b5c16493SMichael Tuexen if ((tp1 == NULL) && (circled == 0)) { 3059b5c16493SMichael Tuexen circled++; 30600fa753b3SRandall Stewart tp1 = TAILQ_FIRST(&stcb->asoc.sent_queue); 30610fa753b3SRandall Stewart } 3062b5c16493SMichael Tuexen } /* end while (tp1) */ 3063b5c16493SMichael Tuexen if (tp1 == NULL) { 3064b5c16493SMichael Tuexen circled = 0; 3065b5c16493SMichael Tuexen tp1 = TAILQ_FIRST(&stcb->asoc.sent_queue); 3066b5c16493SMichael Tuexen } 3067b5c16493SMichael Tuexen /* In case the fragments were not in order we must reset */ 30680fa753b3SRandall Stewart } /* end for (j = fragStart */ 30690fa753b3SRandall Stewart *p_tp1 = tp1; 30700fa753b3SRandall Stewart return (wake_him); /* Return value only used for nr-sack */ 30710fa753b3SRandall Stewart } 30720fa753b3SRandall Stewart 30730fa753b3SRandall Stewart 3074cd554309SMichael Tuexen static int 3075458303daSRandall Stewart sctp_handle_segments(struct mbuf *m, int *offset, struct sctp_tcb *stcb, struct sctp_association *asoc, 3076cd554309SMichael Tuexen uint32_t last_tsn, uint32_t * biggest_tsn_acked, 3077139bc87fSRandall Stewart uint32_t * biggest_newly_acked_tsn, uint32_t * this_sack_lowest_newack, 3078cd554309SMichael Tuexen int num_seg, int num_nr_seg, int *ecn_seg_sums) 3079f8829a4aSRandall Stewart { 3080458303daSRandall Stewart struct sctp_gap_ack_block *frag, block; 3081f8829a4aSRandall Stewart struct sctp_tmit_chunk *tp1; 30820fa753b3SRandall Stewart int i; 3083f8829a4aSRandall Stewart int num_frs = 0; 3084cd554309SMichael Tuexen int chunk_freed; 3085cd554309SMichael Tuexen int non_revocable; 3086d9c5cfeaSMichael Tuexen uint16_t frag_strt, frag_end, prev_frag_end; 3087f8829a4aSRandall Stewart 3088d9c5cfeaSMichael Tuexen tp1 = TAILQ_FIRST(&asoc->sent_queue); 3089d9c5cfeaSMichael Tuexen prev_frag_end = 0; 3090cd554309SMichael Tuexen chunk_freed = 0; 3091f8829a4aSRandall Stewart 3092cd554309SMichael Tuexen for (i = 0; i < (num_seg + num_nr_seg); i++) { 3093d9c5cfeaSMichael Tuexen if (i == num_seg) { 3094d9c5cfeaSMichael Tuexen prev_frag_end = 0; 3095d9c5cfeaSMichael Tuexen tp1 = TAILQ_FIRST(&asoc->sent_queue); 3096d9c5cfeaSMichael Tuexen } 3097458303daSRandall Stewart frag = (struct sctp_gap_ack_block *)sctp_m_getptr(m, *offset, 3098458303daSRandall Stewart sizeof(struct sctp_gap_ack_block), (uint8_t *) & block); 3099458303daSRandall Stewart *offset += sizeof(block); 3100458303daSRandall Stewart if (frag == NULL) { 3101cd554309SMichael Tuexen return (chunk_freed); 3102458303daSRandall Stewart } 3103f8829a4aSRandall Stewart frag_strt = ntohs(frag->start); 3104f8829a4aSRandall Stewart frag_end = ntohs(frag->end); 3105d9c5cfeaSMichael Tuexen 3106f8829a4aSRandall Stewart if (frag_strt > frag_end) { 3107d9c5cfeaSMichael Tuexen /* This gap report is malformed, skip it. */ 3108f8829a4aSRandall Stewart continue; 3109f8829a4aSRandall Stewart } 3110d9c5cfeaSMichael Tuexen if (frag_strt <= prev_frag_end) { 3111d9c5cfeaSMichael Tuexen /* This gap report is not in order, so restart. */ 3112f8829a4aSRandall Stewart tp1 = TAILQ_FIRST(&asoc->sent_queue); 3113f8829a4aSRandall Stewart } 3114d9c5cfeaSMichael Tuexen if (compare_with_wrap((last_tsn + frag_end), *biggest_tsn_acked, MAX_TSN)) { 3115d9c5cfeaSMichael Tuexen *biggest_tsn_acked = last_tsn + frag_end; 3116f8829a4aSRandall Stewart } 3117cd554309SMichael Tuexen if (i < num_seg) { 3118cd554309SMichael Tuexen non_revocable = 0; 3119cd554309SMichael Tuexen } else { 3120cd554309SMichael Tuexen non_revocable = 1; 3121cd554309SMichael Tuexen } 3122cd554309SMichael Tuexen if (sctp_process_segment_range(stcb, &tp1, last_tsn, frag_strt, frag_end, 3123cd554309SMichael Tuexen non_revocable, &num_frs, biggest_newly_acked_tsn, 3124cd554309SMichael Tuexen this_sack_lowest_newack, ecn_seg_sums)) { 3125cd554309SMichael Tuexen chunk_freed = 1; 3126458303daSRandall Stewart } 3127d9c5cfeaSMichael Tuexen prev_frag_end = frag_end; 3128f8829a4aSRandall Stewart } 3129b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_FR_LOGGING_ENABLE) { 313080fefe0aSRandall Stewart if (num_frs) 313180fefe0aSRandall Stewart sctp_log_fr(*biggest_tsn_acked, 313280fefe0aSRandall Stewart *biggest_newly_acked_tsn, 313380fefe0aSRandall Stewart last_tsn, SCTP_FR_LOG_BIGGEST_TSNS); 313480fefe0aSRandall Stewart } 3135cd554309SMichael Tuexen return (chunk_freed); 3136f8829a4aSRandall Stewart } 3137f8829a4aSRandall Stewart 3138f8829a4aSRandall Stewart static void 3139c105859eSRandall Stewart sctp_check_for_revoked(struct sctp_tcb *stcb, 3140c105859eSRandall Stewart struct sctp_association *asoc, uint32_t cumack, 314163eda93dSMichael Tuexen uint32_t biggest_tsn_acked) 3142f8829a4aSRandall Stewart { 3143f8829a4aSRandall Stewart struct sctp_tmit_chunk *tp1; 3144f8829a4aSRandall Stewart int tot_revoked = 0; 3145f8829a4aSRandall Stewart 3146f8829a4aSRandall Stewart tp1 = TAILQ_FIRST(&asoc->sent_queue); 3147f8829a4aSRandall Stewart while (tp1) { 3148f8829a4aSRandall Stewart if (compare_with_wrap(tp1->rec.data.TSN_seq, cumack, 3149f8829a4aSRandall Stewart MAX_TSN)) { 3150f8829a4aSRandall Stewart /* 3151f8829a4aSRandall Stewart * ok this guy is either ACK or MARKED. If it is 3152f8829a4aSRandall Stewart * ACKED it has been previously acked but not this 3153f8829a4aSRandall Stewart * time i.e. revoked. If it is MARKED it was ACK'ed 3154f8829a4aSRandall Stewart * again. 3155f8829a4aSRandall Stewart */ 3156d06c82f1SRandall Stewart if (compare_with_wrap(tp1->rec.data.TSN_seq, biggest_tsn_acked, 3157d06c82f1SRandall Stewart MAX_TSN)) 3158d06c82f1SRandall Stewart break; 3159d06c82f1SRandall Stewart 3160d06c82f1SRandall Stewart 3161f8829a4aSRandall Stewart if (tp1->sent == SCTP_DATAGRAM_ACKED) { 3162f8829a4aSRandall Stewart /* it has been revoked */ 3163f8829a4aSRandall Stewart tp1->sent = SCTP_DATAGRAM_SENT; 3164f8829a4aSRandall Stewart tp1->rec.data.chunk_was_revoked = 1; 3165a5d547adSRandall Stewart /* 316642551e99SRandall Stewart * We must add this stuff back in to assure 316742551e99SRandall Stewart * timers and such get started. 3168a5d547adSRandall Stewart */ 3169b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_FLIGHT_LOGGING_ENABLE) { 3170c105859eSRandall Stewart sctp_misc_ints(SCTP_FLIGHT_LOG_UP_REVOKE, 3171c105859eSRandall Stewart tp1->whoTo->flight_size, 3172c105859eSRandall Stewart tp1->book_size, 3173c105859eSRandall Stewart (uintptr_t) tp1->whoTo, 3174c105859eSRandall Stewart tp1->rec.data.TSN_seq); 317580fefe0aSRandall Stewart } 3176c105859eSRandall Stewart sctp_flight_size_increase(tp1); 3177c105859eSRandall Stewart sctp_total_flight_increase(stcb, tp1); 317842551e99SRandall Stewart /* 317942551e99SRandall Stewart * We inflate the cwnd to compensate for our 318042551e99SRandall Stewart * artificial inflation of the flight_size. 318142551e99SRandall Stewart */ 318242551e99SRandall Stewart tp1->whoTo->cwnd += tp1->book_size; 3183f8829a4aSRandall Stewart tot_revoked++; 3184b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_SACK_LOGGING_ENABLE) { 3185f8829a4aSRandall Stewart sctp_log_sack(asoc->last_acked_seq, 3186f8829a4aSRandall Stewart cumack, 3187f8829a4aSRandall Stewart tp1->rec.data.TSN_seq, 3188f8829a4aSRandall Stewart 0, 3189f8829a4aSRandall Stewart 0, 3190f8829a4aSRandall Stewart SCTP_LOG_TSN_REVOKED); 319180fefe0aSRandall Stewart } 3192f8829a4aSRandall Stewart } else if (tp1->sent == SCTP_DATAGRAM_MARKED) { 3193f8829a4aSRandall Stewart /* it has been re-acked in this SACK */ 3194f8829a4aSRandall Stewart tp1->sent = SCTP_DATAGRAM_ACKED; 3195f8829a4aSRandall Stewart } 3196f8829a4aSRandall Stewart } 3197f8829a4aSRandall Stewart if (tp1->sent == SCTP_DATAGRAM_UNSENT) 3198f8829a4aSRandall Stewart break; 3199f8829a4aSRandall Stewart tp1 = TAILQ_NEXT(tp1, sctp_next); 3200f8829a4aSRandall Stewart } 3201f8829a4aSRandall Stewart if (tot_revoked > 0) { 3202f8829a4aSRandall Stewart /* 3203f8829a4aSRandall Stewart * Setup the ecn nonce re-sync point. We do this since once 3204f8829a4aSRandall Stewart * data is revoked we begin to retransmit things, which do 3205f8829a4aSRandall Stewart * NOT have the ECN bits set. This means we are now out of 3206f8829a4aSRandall Stewart * sync and must wait until we get back in sync with the 3207f8829a4aSRandall Stewart * peer to check ECN bits. 3208f8829a4aSRandall Stewart */ 3209f8829a4aSRandall Stewart tp1 = TAILQ_FIRST(&asoc->send_queue); 3210f8829a4aSRandall Stewart if (tp1 == NULL) { 3211f8829a4aSRandall Stewart asoc->nonce_resync_tsn = asoc->sending_seq; 3212f8829a4aSRandall Stewart } else { 3213f8829a4aSRandall Stewart asoc->nonce_resync_tsn = tp1->rec.data.TSN_seq; 3214f8829a4aSRandall Stewart } 3215f8829a4aSRandall Stewart asoc->nonce_wait_for_ecne = 0; 3216f8829a4aSRandall Stewart asoc->nonce_sum_check = 0; 3217f8829a4aSRandall Stewart } 3218f8829a4aSRandall Stewart } 3219f8829a4aSRandall Stewart 3220830d754dSRandall Stewart 3221f8829a4aSRandall Stewart static void 3222f8829a4aSRandall Stewart sctp_strike_gap_ack_chunks(struct sctp_tcb *stcb, struct sctp_association *asoc, 322363eda93dSMichael Tuexen uint32_t biggest_tsn_acked, uint32_t biggest_tsn_newly_acked, uint32_t this_sack_lowest_newack, int accum_moved) 3224f8829a4aSRandall Stewart { 3225f8829a4aSRandall Stewart struct sctp_tmit_chunk *tp1; 3226f8829a4aSRandall Stewart int strike_flag = 0; 3227f8829a4aSRandall Stewart struct timeval now; 3228f8829a4aSRandall Stewart int tot_retrans = 0; 3229f8829a4aSRandall Stewart uint32_t sending_seq; 3230f8829a4aSRandall Stewart struct sctp_nets *net; 3231f8829a4aSRandall Stewart int num_dests_sacked = 0; 3232f8829a4aSRandall Stewart 3233f8829a4aSRandall Stewart /* 3234f8829a4aSRandall Stewart * select the sending_seq, this is either the next thing ready to be 3235f8829a4aSRandall Stewart * sent but not transmitted, OR, the next seq we assign. 3236f8829a4aSRandall Stewart */ 3237f8829a4aSRandall Stewart tp1 = TAILQ_FIRST(&stcb->asoc.send_queue); 3238f8829a4aSRandall Stewart if (tp1 == NULL) { 3239f8829a4aSRandall Stewart sending_seq = asoc->sending_seq; 3240f8829a4aSRandall Stewart } else { 3241f8829a4aSRandall Stewart sending_seq = tp1->rec.data.TSN_seq; 3242f8829a4aSRandall Stewart } 3243f8829a4aSRandall Stewart 3244f8829a4aSRandall Stewart /* CMT DAC algo: finding out if SACK is a mixed SACK */ 3245*7c99d56fSMichael Tuexen if ((asoc->sctp_cmt_on_off > 0) && 324620083c2eSMichael Tuexen SCTP_BASE_SYSCTL(sctp_cmt_use_dac)) { 3247f8829a4aSRandall Stewart TAILQ_FOREACH(net, &asoc->nets, sctp_next) { 3248f8829a4aSRandall Stewart if (net->saw_newack) 3249f8829a4aSRandall Stewart num_dests_sacked++; 3250f8829a4aSRandall Stewart } 3251f8829a4aSRandall Stewart } 3252f8829a4aSRandall Stewart if (stcb->asoc.peer_supports_prsctp) { 32536e55db54SRandall Stewart (void)SCTP_GETTIME_TIMEVAL(&now); 3254f8829a4aSRandall Stewart } 3255f8829a4aSRandall Stewart tp1 = TAILQ_FIRST(&asoc->sent_queue); 3256f8829a4aSRandall Stewart while (tp1) { 3257f8829a4aSRandall Stewart strike_flag = 0; 3258f8829a4aSRandall Stewart if (tp1->no_fr_allowed) { 3259f8829a4aSRandall Stewart /* this one had a timeout or something */ 3260f8829a4aSRandall Stewart tp1 = TAILQ_NEXT(tp1, sctp_next); 3261f8829a4aSRandall Stewart continue; 3262f8829a4aSRandall Stewart } 3263b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_FR_LOGGING_ENABLE) { 3264f8829a4aSRandall Stewart if (tp1->sent < SCTP_DATAGRAM_RESEND) 3265f8829a4aSRandall Stewart sctp_log_fr(biggest_tsn_newly_acked, 3266f8829a4aSRandall Stewart tp1->rec.data.TSN_seq, 3267f8829a4aSRandall Stewart tp1->sent, 3268f8829a4aSRandall Stewart SCTP_FR_LOG_CHECK_STRIKE); 326980fefe0aSRandall Stewart } 3270f8829a4aSRandall Stewart if (compare_with_wrap(tp1->rec.data.TSN_seq, biggest_tsn_acked, 3271f8829a4aSRandall Stewart MAX_TSN) || 3272f8829a4aSRandall Stewart tp1->sent == SCTP_DATAGRAM_UNSENT) { 3273f8829a4aSRandall Stewart /* done */ 3274f8829a4aSRandall Stewart break; 3275f8829a4aSRandall Stewart } 3276f8829a4aSRandall Stewart if (stcb->asoc.peer_supports_prsctp) { 3277f8829a4aSRandall Stewart if ((PR_SCTP_TTL_ENABLED(tp1->flags)) && tp1->sent < SCTP_DATAGRAM_ACKED) { 3278f8829a4aSRandall Stewart /* Is it expired? */ 327999ddc825SMichael Tuexen if (timevalcmp(&now, &tp1->rec.data.timetodrop, >)) { 3280f8829a4aSRandall Stewart /* Yes so drop it */ 3281f8829a4aSRandall Stewart if (tp1->data != NULL) { 3282ad81507eSRandall Stewart (void)sctp_release_pr_sctp_chunk(stcb, tp1, 3283f8829a4aSRandall Stewart (SCTP_RESPONSE_TO_USER_REQ | SCTP_NOTIFY_DATAGRAM_SENT), 32840c0982b8SRandall Stewart SCTP_SO_NOT_LOCKED); 3285f8829a4aSRandall Stewart } 3286f8829a4aSRandall Stewart tp1 = TAILQ_NEXT(tp1, sctp_next); 3287f8829a4aSRandall Stewart continue; 3288f8829a4aSRandall Stewart } 3289f8829a4aSRandall Stewart } 3290f8829a4aSRandall Stewart } 3291f8829a4aSRandall Stewart if (compare_with_wrap(tp1->rec.data.TSN_seq, 3292f8829a4aSRandall Stewart asoc->this_sack_highest_gap, MAX_TSN)) { 3293f8829a4aSRandall Stewart /* we are beyond the tsn in the sack */ 3294f8829a4aSRandall Stewart break; 3295f8829a4aSRandall Stewart } 3296f8829a4aSRandall Stewart if (tp1->sent >= SCTP_DATAGRAM_RESEND) { 3297f8829a4aSRandall Stewart /* either a RESEND, ACKED, or MARKED */ 3298f8829a4aSRandall Stewart /* skip */ 329944fbe462SRandall Stewart if (tp1->sent == SCTP_FORWARD_TSN_SKIP) { 330044fbe462SRandall Stewart /* Continue strikin FWD-TSN chunks */ 330144fbe462SRandall Stewart tp1->rec.data.fwd_tsn_cnt++; 330244fbe462SRandall Stewart } 3303f8829a4aSRandall Stewart tp1 = TAILQ_NEXT(tp1, sctp_next); 3304f8829a4aSRandall Stewart continue; 3305f8829a4aSRandall Stewart } 3306f8829a4aSRandall Stewart /* 3307f8829a4aSRandall Stewart * CMT : SFR algo (covers part of DAC and HTNA as well) 3308f8829a4aSRandall Stewart */ 3309ad81507eSRandall Stewart if (tp1->whoTo && tp1->whoTo->saw_newack == 0) { 3310f8829a4aSRandall Stewart /* 3311f8829a4aSRandall Stewart * No new acks were receieved for data sent to this 3312f8829a4aSRandall Stewart * dest. Therefore, according to the SFR algo for 3313f8829a4aSRandall Stewart * CMT, no data sent to this dest can be marked for 3314c105859eSRandall Stewart * FR using this SACK. 3315f8829a4aSRandall Stewart */ 3316f8829a4aSRandall Stewart tp1 = TAILQ_NEXT(tp1, sctp_next); 3317f8829a4aSRandall Stewart continue; 3318ad81507eSRandall Stewart } else if (tp1->whoTo && compare_with_wrap(tp1->rec.data.TSN_seq, 3319f8829a4aSRandall Stewart tp1->whoTo->this_sack_highest_newack, MAX_TSN)) { 3320f8829a4aSRandall Stewart /* 3321f8829a4aSRandall Stewart * CMT: New acks were receieved for data sent to 3322f8829a4aSRandall Stewart * this dest. But no new acks were seen for data 3323f8829a4aSRandall Stewart * sent after tp1. Therefore, according to the SFR 3324f8829a4aSRandall Stewart * algo for CMT, tp1 cannot be marked for FR using 3325f8829a4aSRandall Stewart * this SACK. This step covers part of the DAC algo 3326f8829a4aSRandall Stewart * and the HTNA algo as well. 3327f8829a4aSRandall Stewart */ 3328f8829a4aSRandall Stewart tp1 = TAILQ_NEXT(tp1, sctp_next); 3329f8829a4aSRandall Stewart continue; 3330f8829a4aSRandall Stewart } 3331f8829a4aSRandall Stewart /* 3332f8829a4aSRandall Stewart * Here we check to see if we were have already done a FR 3333f8829a4aSRandall Stewart * and if so we see if the biggest TSN we saw in the sack is 3334f8829a4aSRandall Stewart * smaller than the recovery point. If so we don't strike 3335f8829a4aSRandall Stewart * the tsn... otherwise we CAN strike the TSN. 3336f8829a4aSRandall Stewart */ 3337f8829a4aSRandall Stewart /* 333842551e99SRandall Stewart * @@@ JRI: Check for CMT if (accum_moved && 333942551e99SRandall Stewart * asoc->fast_retran_loss_recovery && (sctp_cmt_on_off == 334042551e99SRandall Stewart * 0)) { 3341f8829a4aSRandall Stewart */ 334242551e99SRandall Stewart if (accum_moved && asoc->fast_retran_loss_recovery) { 3343f8829a4aSRandall Stewart /* 3344f8829a4aSRandall Stewart * Strike the TSN if in fast-recovery and cum-ack 3345f8829a4aSRandall Stewart * moved. 3346f8829a4aSRandall Stewart */ 3347b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_FR_LOGGING_ENABLE) { 3348f8829a4aSRandall Stewart sctp_log_fr(biggest_tsn_newly_acked, 3349f8829a4aSRandall Stewart tp1->rec.data.TSN_seq, 3350f8829a4aSRandall Stewart tp1->sent, 3351f8829a4aSRandall Stewart SCTP_FR_LOG_STRIKE_CHUNK); 335280fefe0aSRandall Stewart } 33535e54f665SRandall Stewart if (tp1->sent < SCTP_DATAGRAM_RESEND) { 3354f8829a4aSRandall Stewart tp1->sent++; 33555e54f665SRandall Stewart } 3356*7c99d56fSMichael Tuexen if ((asoc->sctp_cmt_on_off > 0) && 335720083c2eSMichael Tuexen SCTP_BASE_SYSCTL(sctp_cmt_use_dac)) { 3358f8829a4aSRandall Stewart /* 3359f8829a4aSRandall Stewart * CMT DAC algorithm: If SACK flag is set to 3360f8829a4aSRandall Stewart * 0, then lowest_newack test will not pass 3361f8829a4aSRandall Stewart * because it would have been set to the 3362f8829a4aSRandall Stewart * cumack earlier. If not already to be 3363f8829a4aSRandall Stewart * rtx'd, If not a mixed sack and if tp1 is 3364f8829a4aSRandall Stewart * not between two sacked TSNs, then mark by 3365c105859eSRandall Stewart * one more. NOTE that we are marking by one 3366c105859eSRandall Stewart * additional time since the SACK DAC flag 3367c105859eSRandall Stewart * indicates that two packets have been 3368c105859eSRandall Stewart * received after this missing TSN. 33695e54f665SRandall Stewart */ 33705e54f665SRandall Stewart if ((tp1->sent < SCTP_DATAGRAM_RESEND) && (num_dests_sacked == 1) && 3371f8829a4aSRandall Stewart compare_with_wrap(this_sack_lowest_newack, tp1->rec.data.TSN_seq, MAX_TSN)) { 3372b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_FR_LOGGING_ENABLE) { 3373f8829a4aSRandall Stewart sctp_log_fr(16 + num_dests_sacked, 3374f8829a4aSRandall Stewart tp1->rec.data.TSN_seq, 3375f8829a4aSRandall Stewart tp1->sent, 3376f8829a4aSRandall Stewart SCTP_FR_LOG_STRIKE_CHUNK); 337780fefe0aSRandall Stewart } 3378f8829a4aSRandall Stewart tp1->sent++; 3379f8829a4aSRandall Stewart } 3380f8829a4aSRandall Stewart } 338120083c2eSMichael Tuexen } else if ((tp1->rec.data.doing_fast_retransmit) && 338220083c2eSMichael Tuexen (asoc->sctp_cmt_on_off == 0)) { 3383f8829a4aSRandall Stewart /* 3384f8829a4aSRandall Stewart * For those that have done a FR we must take 3385f8829a4aSRandall Stewart * special consideration if we strike. I.e the 3386f8829a4aSRandall Stewart * biggest_newly_acked must be higher than the 3387f8829a4aSRandall Stewart * sending_seq at the time we did the FR. 3388f8829a4aSRandall Stewart */ 33895e54f665SRandall Stewart if ( 3390f8829a4aSRandall Stewart #ifdef SCTP_FR_TO_ALTERNATE 3391f8829a4aSRandall Stewart /* 3392f8829a4aSRandall Stewart * If FR's go to new networks, then we must only do 3393f8829a4aSRandall Stewart * this for singly homed asoc's. However if the FR's 3394f8829a4aSRandall Stewart * go to the same network (Armando's work) then its 3395f8829a4aSRandall Stewart * ok to FR multiple times. 3396f8829a4aSRandall Stewart */ 33975e54f665SRandall Stewart (asoc->numnets < 2) 3398f8829a4aSRandall Stewart #else 33995e54f665SRandall Stewart (1) 3400f8829a4aSRandall Stewart #endif 34015e54f665SRandall Stewart ) { 34025e54f665SRandall Stewart 3403f8829a4aSRandall Stewart if ((compare_with_wrap(biggest_tsn_newly_acked, 3404f8829a4aSRandall Stewart tp1->rec.data.fast_retran_tsn, MAX_TSN)) || 3405f8829a4aSRandall Stewart (biggest_tsn_newly_acked == 3406f8829a4aSRandall Stewart tp1->rec.data.fast_retran_tsn)) { 3407f8829a4aSRandall Stewart /* 3408f8829a4aSRandall Stewart * Strike the TSN, since this ack is 3409f8829a4aSRandall Stewart * beyond where things were when we 3410f8829a4aSRandall Stewart * did a FR. 3411f8829a4aSRandall Stewart */ 3412b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_FR_LOGGING_ENABLE) { 3413f8829a4aSRandall Stewart sctp_log_fr(biggest_tsn_newly_acked, 3414f8829a4aSRandall Stewart tp1->rec.data.TSN_seq, 3415f8829a4aSRandall Stewart tp1->sent, 3416f8829a4aSRandall Stewart SCTP_FR_LOG_STRIKE_CHUNK); 341780fefe0aSRandall Stewart } 34185e54f665SRandall Stewart if (tp1->sent < SCTP_DATAGRAM_RESEND) { 3419f8829a4aSRandall Stewart tp1->sent++; 34205e54f665SRandall Stewart } 3421f8829a4aSRandall Stewart strike_flag = 1; 3422*7c99d56fSMichael Tuexen if ((asoc->sctp_cmt_on_off > 0) && 342320083c2eSMichael Tuexen SCTP_BASE_SYSCTL(sctp_cmt_use_dac)) { 3424f8829a4aSRandall Stewart /* 3425f8829a4aSRandall Stewart * CMT DAC algorithm: If 3426f8829a4aSRandall Stewart * SACK flag is set to 0, 3427f8829a4aSRandall Stewart * then lowest_newack test 3428f8829a4aSRandall Stewart * will not pass because it 3429f8829a4aSRandall Stewart * would have been set to 3430f8829a4aSRandall Stewart * the cumack earlier. If 3431f8829a4aSRandall Stewart * not already to be rtx'd, 3432f8829a4aSRandall Stewart * If not a mixed sack and 3433f8829a4aSRandall Stewart * if tp1 is not between two 3434f8829a4aSRandall Stewart * sacked TSNs, then mark by 3435c105859eSRandall Stewart * one more. NOTE that we 3436c105859eSRandall Stewart * are marking by one 3437c105859eSRandall Stewart * additional time since the 3438c105859eSRandall Stewart * SACK DAC flag indicates 3439c105859eSRandall Stewart * that two packets have 3440c105859eSRandall Stewart * been received after this 3441c105859eSRandall Stewart * missing TSN. 3442f8829a4aSRandall Stewart */ 34435e54f665SRandall Stewart if ((tp1->sent < SCTP_DATAGRAM_RESEND) && 34445e54f665SRandall Stewart (num_dests_sacked == 1) && 34455e54f665SRandall Stewart compare_with_wrap(this_sack_lowest_newack, 34465e54f665SRandall Stewart tp1->rec.data.TSN_seq, MAX_TSN)) { 3447b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_FR_LOGGING_ENABLE) { 3448f8829a4aSRandall Stewart sctp_log_fr(32 + num_dests_sacked, 3449f8829a4aSRandall Stewart tp1->rec.data.TSN_seq, 3450f8829a4aSRandall Stewart tp1->sent, 3451f8829a4aSRandall Stewart SCTP_FR_LOG_STRIKE_CHUNK); 345280fefe0aSRandall Stewart } 34535e54f665SRandall Stewart if (tp1->sent < SCTP_DATAGRAM_RESEND) { 3454f8829a4aSRandall Stewart tp1->sent++; 34555e54f665SRandall Stewart } 3456f8829a4aSRandall Stewart } 3457f8829a4aSRandall Stewart } 3458f8829a4aSRandall Stewart } 3459f8829a4aSRandall Stewart } 3460f8829a4aSRandall Stewart /* 346142551e99SRandall Stewart * JRI: TODO: remove code for HTNA algo. CMT's SFR 346242551e99SRandall Stewart * algo covers HTNA. 3463f8829a4aSRandall Stewart */ 3464f8829a4aSRandall Stewart } else if (compare_with_wrap(tp1->rec.data.TSN_seq, 3465f8829a4aSRandall Stewart biggest_tsn_newly_acked, MAX_TSN)) { 3466f8829a4aSRandall Stewart /* 3467f8829a4aSRandall Stewart * We don't strike these: This is the HTNA 3468f8829a4aSRandall Stewart * algorithm i.e. we don't strike If our TSN is 3469f8829a4aSRandall Stewart * larger than the Highest TSN Newly Acked. 3470f8829a4aSRandall Stewart */ 3471f8829a4aSRandall Stewart ; 3472f8829a4aSRandall Stewart } else { 3473f8829a4aSRandall Stewart /* Strike the TSN */ 3474b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_FR_LOGGING_ENABLE) { 3475f8829a4aSRandall Stewart sctp_log_fr(biggest_tsn_newly_acked, 3476f8829a4aSRandall Stewart tp1->rec.data.TSN_seq, 3477f8829a4aSRandall Stewart tp1->sent, 3478f8829a4aSRandall Stewart SCTP_FR_LOG_STRIKE_CHUNK); 347980fefe0aSRandall Stewart } 34805e54f665SRandall Stewart if (tp1->sent < SCTP_DATAGRAM_RESEND) { 3481f8829a4aSRandall Stewart tp1->sent++; 34825e54f665SRandall Stewart } 3483*7c99d56fSMichael Tuexen if ((asoc->sctp_cmt_on_off > 0) && 348420083c2eSMichael Tuexen SCTP_BASE_SYSCTL(sctp_cmt_use_dac)) { 3485f8829a4aSRandall Stewart /* 3486f8829a4aSRandall Stewart * CMT DAC algorithm: If SACK flag is set to 3487f8829a4aSRandall Stewart * 0, then lowest_newack test will not pass 3488f8829a4aSRandall Stewart * because it would have been set to the 3489f8829a4aSRandall Stewart * cumack earlier. If not already to be 3490f8829a4aSRandall Stewart * rtx'd, If not a mixed sack and if tp1 is 3491f8829a4aSRandall Stewart * not between two sacked TSNs, then mark by 3492c105859eSRandall Stewart * one more. NOTE that we are marking by one 3493c105859eSRandall Stewart * additional time since the SACK DAC flag 3494c105859eSRandall Stewart * indicates that two packets have been 3495c105859eSRandall Stewart * received after this missing TSN. 3496f8829a4aSRandall Stewart */ 34975e54f665SRandall Stewart if ((tp1->sent < SCTP_DATAGRAM_RESEND) && (num_dests_sacked == 1) && 3498f8829a4aSRandall Stewart compare_with_wrap(this_sack_lowest_newack, tp1->rec.data.TSN_seq, MAX_TSN)) { 3499b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_FR_LOGGING_ENABLE) { 3500f8829a4aSRandall Stewart sctp_log_fr(48 + num_dests_sacked, 3501f8829a4aSRandall Stewart tp1->rec.data.TSN_seq, 3502f8829a4aSRandall Stewart tp1->sent, 3503f8829a4aSRandall Stewart SCTP_FR_LOG_STRIKE_CHUNK); 350480fefe0aSRandall Stewart } 3505f8829a4aSRandall Stewart tp1->sent++; 3506f8829a4aSRandall Stewart } 3507f8829a4aSRandall Stewart } 3508f8829a4aSRandall Stewart } 3509f8829a4aSRandall Stewart if (tp1->sent == SCTP_DATAGRAM_RESEND) { 3510f8829a4aSRandall Stewart struct sctp_nets *alt; 3511f8829a4aSRandall Stewart 3512544e35bdSRandall Stewart /* fix counts and things */ 3513544e35bdSRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_FLIGHT_LOGGING_ENABLE) { 3514544e35bdSRandall Stewart sctp_misc_ints(SCTP_FLIGHT_LOG_DOWN_RSND, 3515544e35bdSRandall Stewart (tp1->whoTo ? (tp1->whoTo->flight_size) : 0), 3516544e35bdSRandall Stewart tp1->book_size, 3517544e35bdSRandall Stewart (uintptr_t) tp1->whoTo, 3518544e35bdSRandall Stewart tp1->rec.data.TSN_seq); 3519544e35bdSRandall Stewart } 3520544e35bdSRandall Stewart if (tp1->whoTo) { 3521544e35bdSRandall Stewart tp1->whoTo->net_ack++; 3522544e35bdSRandall Stewart sctp_flight_size_decrease(tp1); 3523544e35bdSRandall Stewart } 3524544e35bdSRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_LOG_RWND_ENABLE) { 3525544e35bdSRandall Stewart sctp_log_rwnd(SCTP_INCREASE_PEER_RWND, 3526544e35bdSRandall Stewart asoc->peers_rwnd, tp1->send_size, SCTP_BASE_SYSCTL(sctp_peer_chunk_oh)); 3527544e35bdSRandall Stewart } 3528544e35bdSRandall Stewart /* add back to the rwnd */ 3529544e35bdSRandall Stewart asoc->peers_rwnd += (tp1->send_size + SCTP_BASE_SYSCTL(sctp_peer_chunk_oh)); 3530544e35bdSRandall Stewart 3531544e35bdSRandall Stewart /* remove from the total flight */ 3532544e35bdSRandall Stewart sctp_total_flight_decrease(stcb, tp1); 3533544e35bdSRandall Stewart 3534475d0674SMichael Tuexen if ((stcb->asoc.peer_supports_prsctp) && 3535475d0674SMichael Tuexen (PR_SCTP_RTX_ENABLED(tp1->flags))) { 3536475d0674SMichael Tuexen /* 3537475d0674SMichael Tuexen * Has it been retransmitted tv_sec times? - 3538475d0674SMichael Tuexen * we store the retran count there. 3539475d0674SMichael Tuexen */ 3540475d0674SMichael Tuexen if (tp1->snd_count > tp1->rec.data.timetodrop.tv_sec) { 3541475d0674SMichael Tuexen /* Yes, so drop it */ 3542475d0674SMichael Tuexen if (tp1->data != NULL) { 3543475d0674SMichael Tuexen (void)sctp_release_pr_sctp_chunk(stcb, tp1, 3544475d0674SMichael Tuexen (SCTP_RESPONSE_TO_USER_REQ | SCTP_NOTIFY_DATAGRAM_SENT), 3545475d0674SMichael Tuexen SCTP_SO_NOT_LOCKED); 3546475d0674SMichael Tuexen } 3547475d0674SMichael Tuexen /* Make sure to flag we had a FR */ 3548475d0674SMichael Tuexen tp1->whoTo->net_ack++; 3549475d0674SMichael Tuexen tp1 = TAILQ_NEXT(tp1, sctp_next); 3550475d0674SMichael Tuexen continue; 3551475d0674SMichael Tuexen } 3552475d0674SMichael Tuexen } 3553f8829a4aSRandall Stewart /* printf("OK, we are now ready to FR this guy\n"); */ 3554b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_FR_LOGGING_ENABLE) { 3555f8829a4aSRandall Stewart sctp_log_fr(tp1->rec.data.TSN_seq, tp1->snd_count, 3556f8829a4aSRandall Stewart 0, SCTP_FR_MARKED); 355780fefe0aSRandall Stewart } 3558f8829a4aSRandall Stewart if (strike_flag) { 3559f8829a4aSRandall Stewart /* This is a subsequent FR */ 3560f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_sendmultfastretrans); 3561f8829a4aSRandall Stewart } 35625e54f665SRandall Stewart sctp_ucount_incr(stcb->asoc.sent_queue_retran_cnt); 3563*7c99d56fSMichael Tuexen if (asoc->sctp_cmt_on_off > 0) { 3564f8829a4aSRandall Stewart /* 3565f8829a4aSRandall Stewart * CMT: Using RTX_SSTHRESH policy for CMT. 3566f8829a4aSRandall Stewart * If CMT is being used, then pick dest with 3567f8829a4aSRandall Stewart * largest ssthresh for any retransmission. 3568f8829a4aSRandall Stewart */ 3569f8829a4aSRandall Stewart tp1->no_fr_allowed = 1; 3570f8829a4aSRandall Stewart alt = tp1->whoTo; 35713c503c28SRandall Stewart /* sa_ignore NO_NULL_CHK */ 357220083c2eSMichael Tuexen if (asoc->sctp_cmt_pf > 0) { 3573b54d3a6cSRandall Stewart /* 3574b54d3a6cSRandall Stewart * JRS 5/18/07 - If CMT PF is on, 3575b54d3a6cSRandall Stewart * use the PF version of 3576b54d3a6cSRandall Stewart * find_alt_net() 3577b54d3a6cSRandall Stewart */ 3578b54d3a6cSRandall Stewart alt = sctp_find_alternate_net(stcb, alt, 2); 3579b54d3a6cSRandall Stewart } else { 3580b54d3a6cSRandall Stewart /* 3581b54d3a6cSRandall Stewart * JRS 5/18/07 - If only CMT is on, 3582b54d3a6cSRandall Stewart * use the CMT version of 3583b54d3a6cSRandall Stewart * find_alt_net() 3584b54d3a6cSRandall Stewart */ 358552be287eSRandall Stewart /* sa_ignore NO_NULL_CHK */ 3586f8829a4aSRandall Stewart alt = sctp_find_alternate_net(stcb, alt, 1); 3587b54d3a6cSRandall Stewart } 3588ad81507eSRandall Stewart if (alt == NULL) { 3589ad81507eSRandall Stewart alt = tp1->whoTo; 3590ad81507eSRandall Stewart } 3591f8829a4aSRandall Stewart /* 3592f8829a4aSRandall Stewart * CUCv2: If a different dest is picked for 3593f8829a4aSRandall Stewart * the retransmission, then new 3594f8829a4aSRandall Stewart * (rtx-)pseudo_cumack needs to be tracked 3595f8829a4aSRandall Stewart * for orig dest. Let CUCv2 track new (rtx-) 3596f8829a4aSRandall Stewart * pseudo-cumack always. 3597f8829a4aSRandall Stewart */ 3598ad81507eSRandall Stewart if (tp1->whoTo) { 3599f8829a4aSRandall Stewart tp1->whoTo->find_pseudo_cumack = 1; 3600f8829a4aSRandall Stewart tp1->whoTo->find_rtx_pseudo_cumack = 1; 3601ad81507eSRandall Stewart } 3602f8829a4aSRandall Stewart } else {/* CMT is OFF */ 3603f8829a4aSRandall Stewart 3604f8829a4aSRandall Stewart #ifdef SCTP_FR_TO_ALTERNATE 3605f8829a4aSRandall Stewart /* Can we find an alternate? */ 3606f8829a4aSRandall Stewart alt = sctp_find_alternate_net(stcb, tp1->whoTo, 0); 3607f8829a4aSRandall Stewart #else 3608f8829a4aSRandall Stewart /* 3609f8829a4aSRandall Stewart * default behavior is to NOT retransmit 3610f8829a4aSRandall Stewart * FR's to an alternate. Armando Caro's 3611f8829a4aSRandall Stewart * paper details why. 3612f8829a4aSRandall Stewart */ 3613f8829a4aSRandall Stewart alt = tp1->whoTo; 3614f8829a4aSRandall Stewart #endif 3615f8829a4aSRandall Stewart } 3616f8829a4aSRandall Stewart 3617f8829a4aSRandall Stewart tp1->rec.data.doing_fast_retransmit = 1; 3618f8829a4aSRandall Stewart tot_retrans++; 3619f8829a4aSRandall Stewart /* mark the sending seq for possible subsequent FR's */ 3620f8829a4aSRandall Stewart /* 3621f8829a4aSRandall Stewart * printf("Marking TSN for FR new value %x\n", 3622f8829a4aSRandall Stewart * (uint32_t)tpi->rec.data.TSN_seq); 3623f8829a4aSRandall Stewart */ 3624f8829a4aSRandall Stewart if (TAILQ_EMPTY(&asoc->send_queue)) { 3625f8829a4aSRandall Stewart /* 3626f8829a4aSRandall Stewart * If the queue of send is empty then its 3627f8829a4aSRandall Stewart * the next sequence number that will be 3628f8829a4aSRandall Stewart * assigned so we subtract one from this to 3629f8829a4aSRandall Stewart * get the one we last sent. 3630f8829a4aSRandall Stewart */ 3631f8829a4aSRandall Stewart tp1->rec.data.fast_retran_tsn = sending_seq; 3632f8829a4aSRandall Stewart } else { 3633f8829a4aSRandall Stewart /* 3634f8829a4aSRandall Stewart * If there are chunks on the send queue 3635f8829a4aSRandall Stewart * (unsent data that has made it from the 3636f8829a4aSRandall Stewart * stream queues but not out the door, we 3637f8829a4aSRandall Stewart * take the first one (which will have the 3638f8829a4aSRandall Stewart * lowest TSN) and subtract one to get the 3639f8829a4aSRandall Stewart * one we last sent. 3640f8829a4aSRandall Stewart */ 3641f8829a4aSRandall Stewart struct sctp_tmit_chunk *ttt; 3642f8829a4aSRandall Stewart 3643f8829a4aSRandall Stewart ttt = TAILQ_FIRST(&asoc->send_queue); 3644f8829a4aSRandall Stewart tp1->rec.data.fast_retran_tsn = 3645f8829a4aSRandall Stewart ttt->rec.data.TSN_seq; 3646f8829a4aSRandall Stewart } 3647f8829a4aSRandall Stewart 3648f8829a4aSRandall Stewart if (tp1->do_rtt) { 3649f8829a4aSRandall Stewart /* 3650f8829a4aSRandall Stewart * this guy had a RTO calculation pending on 3651f8829a4aSRandall Stewart * it, cancel it 3652f8829a4aSRandall Stewart */ 3653f8829a4aSRandall Stewart tp1->do_rtt = 0; 3654f8829a4aSRandall Stewart } 3655f8829a4aSRandall Stewart if (alt != tp1->whoTo) { 3656f8829a4aSRandall Stewart /* yes, there is an alternate. */ 3657f8829a4aSRandall Stewart sctp_free_remote_addr(tp1->whoTo); 36583c503c28SRandall Stewart /* sa_ignore FREED_MEMORY */ 3659f8829a4aSRandall Stewart tp1->whoTo = alt; 3660f8829a4aSRandall Stewart atomic_add_int(&alt->ref_count, 1); 3661f8829a4aSRandall Stewart } 3662f8829a4aSRandall Stewart } 3663f8829a4aSRandall Stewart tp1 = TAILQ_NEXT(tp1, sctp_next); 3664f8829a4aSRandall Stewart } /* while (tp1) */ 3665f8829a4aSRandall Stewart 3666f8829a4aSRandall Stewart if (tot_retrans > 0) { 3667f8829a4aSRandall Stewart /* 3668f8829a4aSRandall Stewart * Setup the ecn nonce re-sync point. We do this since once 3669f8829a4aSRandall Stewart * we go to FR something we introduce a Karn's rule scenario 3670f8829a4aSRandall Stewart * and won't know the totals for the ECN bits. 3671f8829a4aSRandall Stewart */ 3672f8829a4aSRandall Stewart asoc->nonce_resync_tsn = sending_seq; 3673f8829a4aSRandall Stewart asoc->nonce_wait_for_ecne = 0; 3674f8829a4aSRandall Stewart asoc->nonce_sum_check = 0; 3675f8829a4aSRandall Stewart } 3676f8829a4aSRandall Stewart } 3677f8829a4aSRandall Stewart 3678f8829a4aSRandall Stewart struct sctp_tmit_chunk * 3679f8829a4aSRandall Stewart sctp_try_advance_peer_ack_point(struct sctp_tcb *stcb, 3680f8829a4aSRandall Stewart struct sctp_association *asoc) 3681f8829a4aSRandall Stewart { 3682f8829a4aSRandall Stewart struct sctp_tmit_chunk *tp1, *tp2, *a_adv = NULL; 3683f8829a4aSRandall Stewart struct timeval now; 3684f8829a4aSRandall Stewart int now_filled = 0; 3685f8829a4aSRandall Stewart 3686f8829a4aSRandall Stewart if (asoc->peer_supports_prsctp == 0) { 3687f8829a4aSRandall Stewart return (NULL); 3688f8829a4aSRandall Stewart } 3689f8829a4aSRandall Stewart tp1 = TAILQ_FIRST(&asoc->sent_queue); 3690f8829a4aSRandall Stewart while (tp1) { 3691f8829a4aSRandall Stewart if (tp1->sent != SCTP_FORWARD_TSN_SKIP && 3692f8829a4aSRandall Stewart tp1->sent != SCTP_DATAGRAM_RESEND) { 3693f8829a4aSRandall Stewart /* no chance to advance, out of here */ 3694f8829a4aSRandall Stewart break; 3695f8829a4aSRandall Stewart } 36960c0982b8SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_LOG_TRY_ADVANCE) { 36970c0982b8SRandall Stewart if (tp1->sent == SCTP_FORWARD_TSN_SKIP) { 36980c0982b8SRandall Stewart sctp_misc_ints(SCTP_FWD_TSN_CHECK, 36990c0982b8SRandall Stewart asoc->advanced_peer_ack_point, 37000c0982b8SRandall Stewart tp1->rec.data.TSN_seq, 0, 0); 37010c0982b8SRandall Stewart } 37020c0982b8SRandall Stewart } 3703f8829a4aSRandall Stewart if (!PR_SCTP_ENABLED(tp1->flags)) { 3704f8829a4aSRandall Stewart /* 3705f8829a4aSRandall Stewart * We can't fwd-tsn past any that are reliable aka 3706f8829a4aSRandall Stewart * retransmitted until the asoc fails. 3707f8829a4aSRandall Stewart */ 3708f8829a4aSRandall Stewart break; 3709f8829a4aSRandall Stewart } 3710f8829a4aSRandall Stewart if (!now_filled) { 37116e55db54SRandall Stewart (void)SCTP_GETTIME_TIMEVAL(&now); 3712f8829a4aSRandall Stewart now_filled = 1; 3713f8829a4aSRandall Stewart } 3714f8829a4aSRandall Stewart tp2 = TAILQ_NEXT(tp1, sctp_next); 3715f8829a4aSRandall Stewart /* 3716f8829a4aSRandall Stewart * now we got a chunk which is marked for another 3717f8829a4aSRandall Stewart * retransmission to a PR-stream but has run out its chances 3718f8829a4aSRandall Stewart * already maybe OR has been marked to skip now. Can we skip 3719f8829a4aSRandall Stewart * it if its a resend? 3720f8829a4aSRandall Stewart */ 3721f8829a4aSRandall Stewart if (tp1->sent == SCTP_DATAGRAM_RESEND && 3722f8829a4aSRandall Stewart (PR_SCTP_TTL_ENABLED(tp1->flags))) { 3723f8829a4aSRandall Stewart /* 3724f8829a4aSRandall Stewart * Now is this one marked for resend and its time is 3725f8829a4aSRandall Stewart * now up? 3726f8829a4aSRandall Stewart */ 3727f8829a4aSRandall Stewart if (timevalcmp(&now, &tp1->rec.data.timetodrop, >)) { 3728f8829a4aSRandall Stewart /* Yes so drop it */ 3729f8829a4aSRandall Stewart if (tp1->data) { 3730ad81507eSRandall Stewart (void)sctp_release_pr_sctp_chunk(stcb, tp1, 3731f8829a4aSRandall Stewart (SCTP_RESPONSE_TO_USER_REQ | SCTP_NOTIFY_DATAGRAM_SENT), 37320c0982b8SRandall Stewart SCTP_SO_NOT_LOCKED); 3733f8829a4aSRandall Stewart } 3734f8829a4aSRandall Stewart } else { 3735f8829a4aSRandall Stewart /* 3736f8829a4aSRandall Stewart * No, we are done when hit one for resend 3737f8829a4aSRandall Stewart * whos time as not expired. 3738f8829a4aSRandall Stewart */ 3739f8829a4aSRandall Stewart break; 3740f8829a4aSRandall Stewart } 3741f8829a4aSRandall Stewart } 3742f8829a4aSRandall Stewart /* 3743f8829a4aSRandall Stewart * Ok now if this chunk is marked to drop it we can clean up 3744f8829a4aSRandall Stewart * the chunk, advance our peer ack point and we can check 3745f8829a4aSRandall Stewart * the next chunk. 3746f8829a4aSRandall Stewart */ 374744fbe462SRandall Stewart if (tp1->sent == SCTP_FORWARD_TSN_SKIP) { 3748f8829a4aSRandall Stewart /* advance PeerAckPoint goes forward */ 37490c0982b8SRandall Stewart if (compare_with_wrap(tp1->rec.data.TSN_seq, 37500c0982b8SRandall Stewart asoc->advanced_peer_ack_point, 37510c0982b8SRandall Stewart MAX_TSN)) { 37520c0982b8SRandall Stewart 3753f8829a4aSRandall Stewart asoc->advanced_peer_ack_point = tp1->rec.data.TSN_seq; 3754f8829a4aSRandall Stewart a_adv = tp1; 37550c0982b8SRandall Stewart } else if (tp1->rec.data.TSN_seq == asoc->advanced_peer_ack_point) { 37560c0982b8SRandall Stewart /* No update but we do save the chk */ 37570c0982b8SRandall Stewart a_adv = tp1; 37580c0982b8SRandall Stewart } 3759f8829a4aSRandall Stewart } else { 3760f8829a4aSRandall Stewart /* 3761f8829a4aSRandall Stewart * If it is still in RESEND we can advance no 3762f8829a4aSRandall Stewart * further 3763f8829a4aSRandall Stewart */ 3764f8829a4aSRandall Stewart break; 3765f8829a4aSRandall Stewart } 3766f8829a4aSRandall Stewart /* 3767f8829a4aSRandall Stewart * If we hit here we just dumped tp1, move to next tsn on 3768f8829a4aSRandall Stewart * sent queue. 3769f8829a4aSRandall Stewart */ 3770f8829a4aSRandall Stewart tp1 = tp2; 3771f8829a4aSRandall Stewart } 3772f8829a4aSRandall Stewart return (a_adv); 3773f8829a4aSRandall Stewart } 3774f8829a4aSRandall Stewart 37750c0982b8SRandall Stewart static int 3776c105859eSRandall Stewart sctp_fs_audit(struct sctp_association *asoc) 3777bff64a4dSRandall Stewart { 3778bff64a4dSRandall Stewart struct sctp_tmit_chunk *chk; 3779bff64a4dSRandall Stewart int inflight = 0, resend = 0, inbetween = 0, acked = 0, above = 0; 37800c0982b8SRandall Stewart int entry_flight, entry_cnt, ret; 37810c0982b8SRandall Stewart 37820c0982b8SRandall Stewart entry_flight = asoc->total_flight; 37830c0982b8SRandall Stewart entry_cnt = asoc->total_flight_count; 37840c0982b8SRandall Stewart ret = 0; 37850c0982b8SRandall Stewart 37860c0982b8SRandall Stewart if (asoc->pr_sctp_cnt >= asoc->sent_queue_cnt) 37870c0982b8SRandall Stewart return (0); 3788bff64a4dSRandall Stewart 3789bff64a4dSRandall Stewart TAILQ_FOREACH(chk, &asoc->sent_queue, sctp_next) { 3790bff64a4dSRandall Stewart if (chk->sent < SCTP_DATAGRAM_RESEND) { 37910c0982b8SRandall Stewart printf("Chk TSN:%u size:%d inflight cnt:%d\n", 37920c0982b8SRandall Stewart chk->rec.data.TSN_seq, 37930c0982b8SRandall Stewart chk->send_size, 37940c0982b8SRandall Stewart chk->snd_count 37950c0982b8SRandall Stewart ); 3796bff64a4dSRandall Stewart inflight++; 3797bff64a4dSRandall Stewart } else if (chk->sent == SCTP_DATAGRAM_RESEND) { 3798bff64a4dSRandall Stewart resend++; 3799bff64a4dSRandall Stewart } else if (chk->sent < SCTP_DATAGRAM_ACKED) { 3800bff64a4dSRandall Stewart inbetween++; 3801bff64a4dSRandall Stewart } else if (chk->sent > SCTP_DATAGRAM_ACKED) { 3802bff64a4dSRandall Stewart above++; 3803bff64a4dSRandall Stewart } else { 3804bff64a4dSRandall Stewart acked++; 3805bff64a4dSRandall Stewart } 3806bff64a4dSRandall Stewart } 3807f1f73e57SRandall Stewart 3808c105859eSRandall Stewart if ((inflight > 0) || (inbetween > 0)) { 3809f1f73e57SRandall Stewart #ifdef INVARIANTS 3810c105859eSRandall Stewart panic("Flight size-express incorrect? \n"); 3811f1f73e57SRandall Stewart #else 38120c0982b8SRandall Stewart printf("asoc->total_flight:%d cnt:%d\n", 38130c0982b8SRandall Stewart entry_flight, entry_cnt); 38140c0982b8SRandall Stewart 38150c0982b8SRandall Stewart SCTP_PRINTF("Flight size-express incorrect F:%d I:%d R:%d Ab:%d ACK:%d\n", 38160c0982b8SRandall Stewart inflight, inbetween, resend, above, acked); 38170c0982b8SRandall Stewart ret = 1; 3818f1f73e57SRandall Stewart #endif 3819bff64a4dSRandall Stewart } 38200c0982b8SRandall Stewart return (ret); 3821c105859eSRandall Stewart } 3822c105859eSRandall Stewart 3823c105859eSRandall Stewart 3824c105859eSRandall Stewart static void 3825c105859eSRandall Stewart sctp_window_probe_recovery(struct sctp_tcb *stcb, 3826c105859eSRandall Stewart struct sctp_association *asoc, 3827c105859eSRandall Stewart struct sctp_nets *net, 3828c105859eSRandall Stewart struct sctp_tmit_chunk *tp1) 3829c105859eSRandall Stewart { 3830dfb11ef8SRandall Stewart tp1->window_probe = 0; 38315171328bSRandall Stewart if ((tp1->sent >= SCTP_DATAGRAM_ACKED) || (tp1->data == NULL)) { 3832dfb11ef8SRandall Stewart /* TSN's skipped we do NOT move back. */ 3833dfb11ef8SRandall Stewart sctp_misc_ints(SCTP_FLIGHT_LOG_DWN_WP_FWD, 3834dfb11ef8SRandall Stewart tp1->whoTo->flight_size, 3835dfb11ef8SRandall Stewart tp1->book_size, 3836dfb11ef8SRandall Stewart (uintptr_t) tp1->whoTo, 3837dfb11ef8SRandall Stewart tp1->rec.data.TSN_seq); 3838dfb11ef8SRandall Stewart return; 3839dfb11ef8SRandall Stewart } 38405171328bSRandall Stewart /* First setup this by shrinking flight */ 38415171328bSRandall Stewart sctp_flight_size_decrease(tp1); 38425171328bSRandall Stewart sctp_total_flight_decrease(stcb, tp1); 38435171328bSRandall Stewart /* Now mark for resend */ 38445171328bSRandall Stewart tp1->sent = SCTP_DATAGRAM_RESEND; 3845791437b5SRandall Stewart sctp_ucount_incr(asoc->sent_queue_retran_cnt); 3846791437b5SRandall Stewart 3847b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_FLIGHT_LOGGING_ENABLE) { 3848c105859eSRandall Stewart sctp_misc_ints(SCTP_FLIGHT_LOG_DOWN_WP, 3849c105859eSRandall Stewart tp1->whoTo->flight_size, 3850c105859eSRandall Stewart tp1->book_size, 3851c105859eSRandall Stewart (uintptr_t) tp1->whoTo, 3852c105859eSRandall Stewart tp1->rec.data.TSN_seq); 385380fefe0aSRandall Stewart } 3854c105859eSRandall Stewart } 3855c105859eSRandall Stewart 3856f8829a4aSRandall Stewart void 3857f8829a4aSRandall Stewart sctp_express_handle_sack(struct sctp_tcb *stcb, uint32_t cumack, 3858f8829a4aSRandall Stewart uint32_t rwnd, int nonce_sum_flag, int *abort_now) 3859f8829a4aSRandall Stewart { 3860f8829a4aSRandall Stewart struct sctp_nets *net; 3861f8829a4aSRandall Stewart struct sctp_association *asoc; 3862f8829a4aSRandall Stewart struct sctp_tmit_chunk *tp1, *tp2; 38635e54f665SRandall Stewart uint32_t old_rwnd; 38645e54f665SRandall Stewart int win_probe_recovery = 0; 3865c105859eSRandall Stewart int win_probe_recovered = 0; 3866d06c82f1SRandall Stewart int j, done_once = 0; 3867f8829a4aSRandall Stewart 3868b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_LOG_SACK_ARRIVALS_ENABLE) { 3869d06c82f1SRandall Stewart sctp_misc_ints(SCTP_SACK_LOG_EXPRESS, cumack, 3870d06c82f1SRandall Stewart rwnd, stcb->asoc.last_acked_seq, stcb->asoc.peers_rwnd); 387180fefe0aSRandall Stewart } 3872f8829a4aSRandall Stewart SCTP_TCB_LOCK_ASSERT(stcb); 387318e198d3SRandall Stewart #ifdef SCTP_ASOCLOG_OF_TSNS 387418e198d3SRandall Stewart stcb->asoc.cumack_log[stcb->asoc.cumack_log_at] = cumack; 387518e198d3SRandall Stewart stcb->asoc.cumack_log_at++; 387618e198d3SRandall Stewart if (stcb->asoc.cumack_log_at > SCTP_TSN_LOG_SIZE) { 387718e198d3SRandall Stewart stcb->asoc.cumack_log_at = 0; 387818e198d3SRandall Stewart } 387918e198d3SRandall Stewart #endif 3880f8829a4aSRandall Stewart asoc = &stcb->asoc; 3881d06c82f1SRandall Stewart old_rwnd = asoc->peers_rwnd; 38825e54f665SRandall Stewart if (compare_with_wrap(asoc->last_acked_seq, cumack, MAX_TSN)) { 38835e54f665SRandall Stewart /* old ack */ 38845e54f665SRandall Stewart return; 3885d06c82f1SRandall Stewart } else if (asoc->last_acked_seq == cumack) { 3886d06c82f1SRandall Stewart /* Window update sack */ 3887d06c82f1SRandall Stewart asoc->peers_rwnd = sctp_sbspace_sub(rwnd, 388844fbe462SRandall Stewart (uint32_t) (asoc->total_flight + (asoc->total_flight_count * SCTP_BASE_SYSCTL(sctp_peer_chunk_oh)))); 3889d06c82f1SRandall Stewart if (asoc->peers_rwnd < stcb->sctp_ep->sctp_ep.sctp_sws_sender) { 3890d06c82f1SRandall Stewart /* SWS sender side engages */ 3891d06c82f1SRandall Stewart asoc->peers_rwnd = 0; 3892d06c82f1SRandall Stewart } 3893d06c82f1SRandall Stewart if (asoc->peers_rwnd > old_rwnd) { 3894d06c82f1SRandall Stewart goto again; 3895d06c82f1SRandall Stewart } 3896d06c82f1SRandall Stewart return; 38975e54f665SRandall Stewart } 3898f8829a4aSRandall Stewart /* First setup for CC stuff */ 3899f8829a4aSRandall Stewart TAILQ_FOREACH(net, &asoc->nets, sctp_next) { 3900f8829a4aSRandall Stewart net->prev_cwnd = net->cwnd; 3901f8829a4aSRandall Stewart net->net_ack = 0; 3902f8829a4aSRandall Stewart net->net_ack2 = 0; 3903132dea7dSRandall Stewart 3904132dea7dSRandall Stewart /* 3905132dea7dSRandall Stewart * CMT: Reset CUC and Fast recovery algo variables before 3906132dea7dSRandall Stewart * SACK processing 3907132dea7dSRandall Stewart */ 3908132dea7dSRandall Stewart net->new_pseudo_cumack = 0; 3909132dea7dSRandall Stewart net->will_exit_fast_recovery = 0; 3910f8829a4aSRandall Stewart } 3911b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_strict_sacks)) { 3912139bc87fSRandall Stewart uint32_t send_s; 3913139bc87fSRandall Stewart 3914c105859eSRandall Stewart if (!TAILQ_EMPTY(&asoc->sent_queue)) { 3915c105859eSRandall Stewart tp1 = TAILQ_LAST(&asoc->sent_queue, 3916c105859eSRandall Stewart sctpchunk_listhead); 3917c105859eSRandall Stewart send_s = tp1->rec.data.TSN_seq + 1; 3918139bc87fSRandall Stewart } else { 3919c105859eSRandall Stewart send_s = asoc->sending_seq; 3920139bc87fSRandall Stewart } 3921139bc87fSRandall Stewart if ((cumack == send_s) || 3922139bc87fSRandall Stewart compare_with_wrap(cumack, send_s, MAX_TSN)) { 3923c105859eSRandall Stewart #ifndef INVARIANTS 3924139bc87fSRandall Stewart struct mbuf *oper; 3925139bc87fSRandall Stewart 3926c105859eSRandall Stewart #endif 3927c105859eSRandall Stewart #ifdef INVARIANTS 3928c105859eSRandall Stewart panic("Impossible sack 1"); 3929c105859eSRandall Stewart #else 3930b5c16493SMichael Tuexen 3931139bc87fSRandall Stewart *abort_now = 1; 3932139bc87fSRandall Stewart /* XXX */ 3933139bc87fSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + sizeof(uint32_t)), 3934139bc87fSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 3935139bc87fSRandall Stewart if (oper) { 3936139bc87fSRandall Stewart struct sctp_paramhdr *ph; 3937139bc87fSRandall Stewart uint32_t *ippp; 3938139bc87fSRandall Stewart 3939139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = sizeof(struct sctp_paramhdr) + 3940139bc87fSRandall Stewart sizeof(uint32_t); 3941139bc87fSRandall Stewart ph = mtod(oper, struct sctp_paramhdr *); 3942139bc87fSRandall Stewart ph->param_type = htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 3943139bc87fSRandall Stewart ph->param_length = htons(SCTP_BUF_LEN(oper)); 3944139bc87fSRandall Stewart ippp = (uint32_t *) (ph + 1); 3945139bc87fSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_25); 3946139bc87fSRandall Stewart } 3947139bc87fSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_25; 3948ceaad40aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, stcb, SCTP_PEER_FAULTY, oper, SCTP_SO_NOT_LOCKED); 3949139bc87fSRandall Stewart return; 3950139bc87fSRandall Stewart #endif 3951139bc87fSRandall Stewart } 3952139bc87fSRandall Stewart } 3953f8829a4aSRandall Stewart asoc->this_sack_highest_gap = cumack; 3954b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_THRESHOLD_LOGGING) { 3955c4739e2fSRandall Stewart sctp_misc_ints(SCTP_THRESHOLD_CLEAR, 3956c4739e2fSRandall Stewart stcb->asoc.overall_error_count, 3957c4739e2fSRandall Stewart 0, 3958c4739e2fSRandall Stewart SCTP_FROM_SCTP_INDATA, 3959c4739e2fSRandall Stewart __LINE__); 3960c4739e2fSRandall Stewart } 3961f8829a4aSRandall Stewart stcb->asoc.overall_error_count = 0; 39625e54f665SRandall Stewart if (compare_with_wrap(cumack, asoc->last_acked_seq, MAX_TSN)) { 3963f8829a4aSRandall Stewart /* process the new consecutive TSN first */ 3964f8829a4aSRandall Stewart tp1 = TAILQ_FIRST(&asoc->sent_queue); 3965f8829a4aSRandall Stewart while (tp1) { 3966f8829a4aSRandall Stewart tp2 = TAILQ_NEXT(tp1, sctp_next); 3967f8829a4aSRandall Stewart if (compare_with_wrap(cumack, tp1->rec.data.TSN_seq, 3968f8829a4aSRandall Stewart MAX_TSN) || 3969f8829a4aSRandall Stewart cumack == tp1->rec.data.TSN_seq) { 397018e198d3SRandall Stewart if (tp1->sent == SCTP_DATAGRAM_UNSENT) { 397118e198d3SRandall Stewart printf("Warning, an unsent is now acked?\n"); 397218e198d3SRandall Stewart } 3973f8829a4aSRandall Stewart /* 397418e198d3SRandall Stewart * ECN Nonce: Add the nonce to the sender's 397518e198d3SRandall Stewart * nonce sum 3976f8829a4aSRandall Stewart */ 3977f8829a4aSRandall Stewart asoc->nonce_sum_expect_base += tp1->rec.data.ect_nonce; 3978f8829a4aSRandall Stewart if (tp1->sent < SCTP_DATAGRAM_ACKED) { 3979f8829a4aSRandall Stewart /* 398018e198d3SRandall Stewart * If it is less than ACKED, it is 398118e198d3SRandall Stewart * now no-longer in flight. Higher 398218e198d3SRandall Stewart * values may occur during marking 3983f8829a4aSRandall Stewart */ 3984c105859eSRandall Stewart if (tp1->sent < SCTP_DATAGRAM_RESEND) { 3985b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_FLIGHT_LOGGING_ENABLE) { 3986c105859eSRandall Stewart sctp_misc_ints(SCTP_FLIGHT_LOG_DOWN_CA, 3987a5d547adSRandall Stewart tp1->whoTo->flight_size, 3988a5d547adSRandall Stewart tp1->book_size, 3989c105859eSRandall Stewart (uintptr_t) tp1->whoTo, 3990a5d547adSRandall Stewart tp1->rec.data.TSN_seq); 399180fefe0aSRandall Stewart } 3992c105859eSRandall Stewart sctp_flight_size_decrease(tp1); 399304ee05e8SRandall Stewart /* sa_ignore NO_NULL_CHK */ 3994c105859eSRandall Stewart sctp_total_flight_decrease(stcb, tp1); 3995f8829a4aSRandall Stewart } 3996f8829a4aSRandall Stewart tp1->whoTo->net_ack += tp1->send_size; 3997f8829a4aSRandall Stewart if (tp1->snd_count < 2) { 3998f8829a4aSRandall Stewart /* 399918e198d3SRandall Stewart * True non-retransmited 4000f8829a4aSRandall Stewart * chunk 4001f8829a4aSRandall Stewart */ 4002f8829a4aSRandall Stewart tp1->whoTo->net_ack2 += 4003f8829a4aSRandall Stewart tp1->send_size; 4004f8829a4aSRandall Stewart 4005f8829a4aSRandall Stewart /* update RTO too? */ 400662c1ff9cSRandall Stewart if (tp1->do_rtt) { 4007f8829a4aSRandall Stewart tp1->whoTo->RTO = 400804ee05e8SRandall Stewart /* 400904ee05e8SRandall Stewart * sa_ignore 401004ee05e8SRandall Stewart * NO_NULL_CHK 401104ee05e8SRandall Stewart */ 4012f8829a4aSRandall Stewart sctp_calculate_rto(stcb, 4013f8829a4aSRandall Stewart asoc, tp1->whoTo, 401418e198d3SRandall Stewart &tp1->sent_rcv_time, 401518e198d3SRandall Stewart sctp_align_safe_nocopy); 4016f8829a4aSRandall Stewart tp1->do_rtt = 0; 4017f8829a4aSRandall Stewart } 4018f8829a4aSRandall Stewart } 4019132dea7dSRandall Stewart /* 402018e198d3SRandall Stewart * CMT: CUCv2 algorithm. From the 402118e198d3SRandall Stewart * cumack'd TSNs, for each TSN being 402218e198d3SRandall Stewart * acked for the first time, set the 402318e198d3SRandall Stewart * following variables for the 402418e198d3SRandall Stewart * corresp destination. 402518e198d3SRandall Stewart * new_pseudo_cumack will trigger a 402618e198d3SRandall Stewart * cwnd update. 402718e198d3SRandall Stewart * find_(rtx_)pseudo_cumack will 402818e198d3SRandall Stewart * trigger search for the next 402918e198d3SRandall Stewart * expected (rtx-)pseudo-cumack. 4030132dea7dSRandall Stewart */ 4031132dea7dSRandall Stewart tp1->whoTo->new_pseudo_cumack = 1; 4032132dea7dSRandall Stewart tp1->whoTo->find_pseudo_cumack = 1; 4033132dea7dSRandall Stewart tp1->whoTo->find_rtx_pseudo_cumack = 1; 4034132dea7dSRandall Stewart 4035b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_LOGGING_ENABLE) { 403604ee05e8SRandall Stewart /* sa_ignore NO_NULL_CHK */ 4037f8829a4aSRandall Stewart sctp_log_cwnd(stcb, tp1->whoTo, tp1->rec.data.TSN_seq, SCTP_CWND_LOG_FROM_SACK); 403880fefe0aSRandall Stewart } 4039f8829a4aSRandall Stewart } 4040f8829a4aSRandall Stewart if (tp1->sent == SCTP_DATAGRAM_RESEND) { 4041f8829a4aSRandall Stewart sctp_ucount_decr(asoc->sent_queue_retran_cnt); 4042f8829a4aSRandall Stewart } 404342551e99SRandall Stewart if (tp1->rec.data.chunk_was_revoked) { 404442551e99SRandall Stewart /* deflate the cwnd */ 404542551e99SRandall Stewart tp1->whoTo->cwnd -= tp1->book_size; 404642551e99SRandall Stewart tp1->rec.data.chunk_was_revoked = 0; 404742551e99SRandall Stewart } 4048f8829a4aSRandall Stewart tp1->sent = SCTP_DATAGRAM_ACKED; 4049f8829a4aSRandall Stewart TAILQ_REMOVE(&asoc->sent_queue, tp1, sctp_next); 4050f8829a4aSRandall Stewart if (tp1->data) { 405104ee05e8SRandall Stewart /* sa_ignore NO_NULL_CHK */ 4052f8829a4aSRandall Stewart sctp_free_bufspace(stcb, asoc, tp1, 1); 4053f8829a4aSRandall Stewart sctp_m_freem(tp1->data); 4054f8829a4aSRandall Stewart } 4055b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_SACK_LOGGING_ENABLE) { 4056f8829a4aSRandall Stewart sctp_log_sack(asoc->last_acked_seq, 4057f8829a4aSRandall Stewart cumack, 4058f8829a4aSRandall Stewart tp1->rec.data.TSN_seq, 4059f8829a4aSRandall Stewart 0, 4060f8829a4aSRandall Stewart 0, 4061f8829a4aSRandall Stewart SCTP_LOG_FREE_SENT); 406280fefe0aSRandall Stewart } 4063f8829a4aSRandall Stewart tp1->data = NULL; 4064f8829a4aSRandall Stewart asoc->sent_queue_cnt--; 4065f8829a4aSRandall Stewart sctp_free_a_chunk(stcb, tp1); 4066f8829a4aSRandall Stewart tp1 = tp2; 406718e198d3SRandall Stewart } else { 406818e198d3SRandall Stewart break; 4069f8829a4aSRandall Stewart } 40705e54f665SRandall Stewart } 407118e198d3SRandall Stewart 407218e198d3SRandall Stewart } 407304ee05e8SRandall Stewart /* sa_ignore NO_NULL_CHK */ 4074f8829a4aSRandall Stewart if (stcb->sctp_socket) { 4075ceaad40aSRandall Stewart #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 4076ceaad40aSRandall Stewart struct socket *so; 4077ceaad40aSRandall Stewart 4078ceaad40aSRandall Stewart #endif 4079f8829a4aSRandall Stewart SOCKBUF_LOCK(&stcb->sctp_socket->so_snd); 4080b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_WAKE_LOGGING_ENABLE) { 408104ee05e8SRandall Stewart /* sa_ignore NO_NULL_CHK */ 4082f8829a4aSRandall Stewart sctp_wakeup_log(stcb, cumack, 1, SCTP_WAKESND_FROM_SACK); 408380fefe0aSRandall Stewart } 4084ceaad40aSRandall Stewart #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 4085ceaad40aSRandall Stewart so = SCTP_INP_SO(stcb->sctp_ep); 4086ceaad40aSRandall Stewart atomic_add_int(&stcb->asoc.refcnt, 1); 4087ceaad40aSRandall Stewart SCTP_TCB_UNLOCK(stcb); 4088ceaad40aSRandall Stewart SCTP_SOCKET_LOCK(so, 1); 4089ceaad40aSRandall Stewart SCTP_TCB_LOCK(stcb); 4090ceaad40aSRandall Stewart atomic_subtract_int(&stcb->asoc.refcnt, 1); 4091ceaad40aSRandall Stewart if (stcb->asoc.state & SCTP_STATE_CLOSED_SOCKET) { 4092ceaad40aSRandall Stewart /* assoc was freed while we were unlocked */ 4093ceaad40aSRandall Stewart SCTP_SOCKET_UNLOCK(so, 1); 4094ceaad40aSRandall Stewart return; 4095ceaad40aSRandall Stewart } 4096ceaad40aSRandall Stewart #endif 4097f8829a4aSRandall Stewart sctp_sowwakeup_locked(stcb->sctp_ep, stcb->sctp_socket); 4098ceaad40aSRandall Stewart #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 4099ceaad40aSRandall Stewart SCTP_SOCKET_UNLOCK(so, 1); 4100ceaad40aSRandall Stewart #endif 4101f8829a4aSRandall Stewart } else { 4102b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_WAKE_LOGGING_ENABLE) { 4103f8829a4aSRandall Stewart sctp_wakeup_log(stcb, cumack, 1, SCTP_NOWAKE_FROM_SACK); 410480fefe0aSRandall Stewart } 4105f8829a4aSRandall Stewart } 4106f8829a4aSRandall Stewart 4107b54d3a6cSRandall Stewart /* JRS - Use the congestion control given in the CC module */ 4108f8829a4aSRandall Stewart if (asoc->last_acked_seq != cumack) 4109b54d3a6cSRandall Stewart asoc->cc_functions.sctp_cwnd_update_after_sack(stcb, asoc, 1, 0, 0); 41105e54f665SRandall Stewart 4111f8829a4aSRandall Stewart asoc->last_acked_seq = cumack; 41125e54f665SRandall Stewart 4113f8829a4aSRandall Stewart if (TAILQ_EMPTY(&asoc->sent_queue)) { 4114f8829a4aSRandall Stewart /* nothing left in-flight */ 4115f8829a4aSRandall Stewart TAILQ_FOREACH(net, &asoc->nets, sctp_next) { 4116f8829a4aSRandall Stewart net->flight_size = 0; 4117f8829a4aSRandall Stewart net->partial_bytes_acked = 0; 4118f8829a4aSRandall Stewart } 4119f8829a4aSRandall Stewart asoc->total_flight = 0; 4120f8829a4aSRandall Stewart asoc->total_flight_count = 0; 4121f8829a4aSRandall Stewart } 4122f8829a4aSRandall Stewart /* ECN Nonce updates */ 4123f8829a4aSRandall Stewart if (asoc->ecn_nonce_allowed) { 4124f8829a4aSRandall Stewart if (asoc->nonce_sum_check) { 4125f8829a4aSRandall Stewart if (nonce_sum_flag != ((asoc->nonce_sum_expect_base) & SCTP_SACK_NONCE_SUM)) { 4126f8829a4aSRandall Stewart if (asoc->nonce_wait_for_ecne == 0) { 4127f8829a4aSRandall Stewart struct sctp_tmit_chunk *lchk; 4128f8829a4aSRandall Stewart 4129f8829a4aSRandall Stewart lchk = TAILQ_FIRST(&asoc->send_queue); 4130f8829a4aSRandall Stewart asoc->nonce_wait_for_ecne = 1; 4131f8829a4aSRandall Stewart if (lchk) { 4132f8829a4aSRandall Stewart asoc->nonce_wait_tsn = lchk->rec.data.TSN_seq; 4133f8829a4aSRandall Stewart } else { 4134f8829a4aSRandall Stewart asoc->nonce_wait_tsn = asoc->sending_seq; 4135f8829a4aSRandall Stewart } 4136f8829a4aSRandall Stewart } else { 4137f8829a4aSRandall Stewart if (compare_with_wrap(asoc->last_acked_seq, asoc->nonce_wait_tsn, MAX_TSN) || 4138f8829a4aSRandall Stewart (asoc->last_acked_seq == asoc->nonce_wait_tsn)) { 4139f8829a4aSRandall Stewart /* 4140f8829a4aSRandall Stewart * Misbehaving peer. We need 4141f8829a4aSRandall Stewart * to react to this guy 4142f8829a4aSRandall Stewart */ 4143f8829a4aSRandall Stewart asoc->ecn_allowed = 0; 4144f8829a4aSRandall Stewart asoc->ecn_nonce_allowed = 0; 4145f8829a4aSRandall Stewart } 4146f8829a4aSRandall Stewart } 4147f8829a4aSRandall Stewart } 4148f8829a4aSRandall Stewart } else { 4149f8829a4aSRandall Stewart /* See if Resynchronization Possible */ 4150f8829a4aSRandall Stewart if (compare_with_wrap(asoc->last_acked_seq, asoc->nonce_resync_tsn, MAX_TSN)) { 4151f8829a4aSRandall Stewart asoc->nonce_sum_check = 1; 4152f8829a4aSRandall Stewart /* 4153cd554309SMichael Tuexen * Now we must calculate what the base is. 4154f8829a4aSRandall Stewart * We do this based on two things, we know 4155f8829a4aSRandall Stewart * the total's for all the segments 4156cd554309SMichael Tuexen * gap-acked in the SACK (none). We also 4157f8829a4aSRandall Stewart * know the SACK's nonce sum, its in 4158f8829a4aSRandall Stewart * nonce_sum_flag. So we can build a truth 4159f8829a4aSRandall Stewart * table to back-calculate the new value of 4160f8829a4aSRandall Stewart * asoc->nonce_sum_expect_base: 4161f8829a4aSRandall Stewart * 4162f8829a4aSRandall Stewart * SACK-flag-Value Seg-Sums Base 0 0 0 4163f8829a4aSRandall Stewart * 1 0 1 0 1 1 1 4164f8829a4aSRandall Stewart * 1 0 4165f8829a4aSRandall Stewart */ 4166f8829a4aSRandall Stewart asoc->nonce_sum_expect_base = (0 ^ nonce_sum_flag) & SCTP_SACK_NONCE_SUM; 4167f8829a4aSRandall Stewart } 4168f8829a4aSRandall Stewart } 4169f8829a4aSRandall Stewart } 4170f8829a4aSRandall Stewart /* RWND update */ 4171f8829a4aSRandall Stewart asoc->peers_rwnd = sctp_sbspace_sub(rwnd, 417244fbe462SRandall Stewart (uint32_t) (asoc->total_flight + (asoc->total_flight_count * SCTP_BASE_SYSCTL(sctp_peer_chunk_oh)))); 4173f8829a4aSRandall Stewart if (asoc->peers_rwnd < stcb->sctp_ep->sctp_ep.sctp_sws_sender) { 4174f8829a4aSRandall Stewart /* SWS sender side engages */ 4175f8829a4aSRandall Stewart asoc->peers_rwnd = 0; 4176f8829a4aSRandall Stewart } 41775e54f665SRandall Stewart if (asoc->peers_rwnd > old_rwnd) { 41785e54f665SRandall Stewart win_probe_recovery = 1; 41795e54f665SRandall Stewart } 4180f8829a4aSRandall Stewart /* Now assure a timer where data is queued at */ 4181a5d547adSRandall Stewart again: 4182a5d547adSRandall Stewart j = 0; 4183f8829a4aSRandall Stewart TAILQ_FOREACH(net, &asoc->nets, sctp_next) { 41845171328bSRandall Stewart int to_ticks; 41855171328bSRandall Stewart 41865e54f665SRandall Stewart if (win_probe_recovery && (net->window_probe)) { 4187c105859eSRandall Stewart win_probe_recovered = 1; 41885e54f665SRandall Stewart /* 41895e54f665SRandall Stewart * Find first chunk that was used with window probe 41905e54f665SRandall Stewart * and clear the sent 41915e54f665SRandall Stewart */ 41923c503c28SRandall Stewart /* sa_ignore FREED_MEMORY */ 41935e54f665SRandall Stewart TAILQ_FOREACH(tp1, &asoc->sent_queue, sctp_next) { 41945e54f665SRandall Stewart if (tp1->window_probe) { 4195cd554309SMichael Tuexen /* move back to data send queue */ 4196c105859eSRandall Stewart sctp_window_probe_recovery(stcb, asoc, net, tp1); 41975e54f665SRandall Stewart break; 41985e54f665SRandall Stewart } 41995e54f665SRandall Stewart } 42005e54f665SRandall Stewart } 4201f8829a4aSRandall Stewart if (net->RTO == 0) { 4202f8829a4aSRandall Stewart to_ticks = MSEC_TO_TICKS(stcb->asoc.initial_rto); 4203f8829a4aSRandall Stewart } else { 4204f8829a4aSRandall Stewart to_ticks = MSEC_TO_TICKS(net->RTO); 4205f8829a4aSRandall Stewart } 42065171328bSRandall Stewart if (net->flight_size) { 4207a5d547adSRandall Stewart j++; 4208ad81507eSRandall Stewart (void)SCTP_OS_TIMER_START(&net->rxt_timer.timer, to_ticks, 4209f8829a4aSRandall Stewart sctp_timeout_handler, &net->rxt_timer); 42105171328bSRandall Stewart if (net->window_probe) { 42115171328bSRandall Stewart net->window_probe = 0; 42125171328bSRandall Stewart } 4213f8829a4aSRandall Stewart } else { 42145171328bSRandall Stewart if (net->window_probe) { 42155171328bSRandall Stewart /* 42165171328bSRandall Stewart * In window probes we must assure a timer 42175171328bSRandall Stewart * is still running there 42185171328bSRandall Stewart */ 42195171328bSRandall Stewart net->window_probe = 0; 42205171328bSRandall Stewart if (!SCTP_OS_TIMER_PENDING(&net->rxt_timer.timer)) { 42215171328bSRandall Stewart SCTP_OS_TIMER_START(&net->rxt_timer.timer, to_ticks, 42225171328bSRandall Stewart sctp_timeout_handler, &net->rxt_timer); 42235171328bSRandall Stewart } 42245171328bSRandall Stewart } else if (SCTP_OS_TIMER_PENDING(&net->rxt_timer.timer)) { 4225f8829a4aSRandall Stewart sctp_timer_stop(SCTP_TIMER_TYPE_SEND, stcb->sctp_ep, 4226a5d547adSRandall Stewart stcb, net, 4227a5d547adSRandall Stewart SCTP_FROM_SCTP_INDATA + SCTP_LOC_22); 4228f8829a4aSRandall Stewart } 4229b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_early_fr)) { 4230139bc87fSRandall Stewart if (SCTP_OS_TIMER_PENDING(&net->fr_timer.timer)) { 4231f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_earlyfrstpidsck4); 4232a5d547adSRandall Stewart sctp_timer_stop(SCTP_TIMER_TYPE_EARLYFR, stcb->sctp_ep, stcb, net, 4233a5d547adSRandall Stewart SCTP_FROM_SCTP_INDATA + SCTP_LOC_23); 4234f8829a4aSRandall Stewart } 4235f8829a4aSRandall Stewart } 4236f8829a4aSRandall Stewart } 4237f8829a4aSRandall Stewart } 4238bff64a4dSRandall Stewart if ((j == 0) && 4239bff64a4dSRandall Stewart (!TAILQ_EMPTY(&asoc->sent_queue)) && 4240bff64a4dSRandall Stewart (asoc->sent_queue_retran_cnt == 0) && 4241c105859eSRandall Stewart (win_probe_recovered == 0) && 4242bff64a4dSRandall Stewart (done_once == 0)) { 42430c0982b8SRandall Stewart /* 42440c0982b8SRandall Stewart * huh, this should not happen unless all packets are 42450c0982b8SRandall Stewart * PR-SCTP and marked to skip of course. 42460c0982b8SRandall Stewart */ 42470c0982b8SRandall Stewart if (sctp_fs_audit(asoc)) { 4248a5d547adSRandall Stewart TAILQ_FOREACH(net, &asoc->nets, sctp_next) { 4249a5d547adSRandall Stewart net->flight_size = 0; 4250a5d547adSRandall Stewart } 4251a5d547adSRandall Stewart asoc->total_flight = 0; 4252a5d547adSRandall Stewart asoc->total_flight_count = 0; 4253a5d547adSRandall Stewart asoc->sent_queue_retran_cnt = 0; 4254a5d547adSRandall Stewart TAILQ_FOREACH(tp1, &asoc->sent_queue, sctp_next) { 4255a5d547adSRandall Stewart if (tp1->sent < SCTP_DATAGRAM_RESEND) { 4256c105859eSRandall Stewart sctp_flight_size_increase(tp1); 4257c105859eSRandall Stewart sctp_total_flight_increase(stcb, tp1); 4258a5d547adSRandall Stewart } else if (tp1->sent == SCTP_DATAGRAM_RESEND) { 4259791437b5SRandall Stewart sctp_ucount_incr(asoc->sent_queue_retran_cnt); 4260a5d547adSRandall Stewart } 4261a5d547adSRandall Stewart } 42620c0982b8SRandall Stewart } 4263bff64a4dSRandall Stewart done_once = 1; 4264a5d547adSRandall Stewart goto again; 4265a5d547adSRandall Stewart } 4266f8829a4aSRandall Stewart /**********************************/ 4267f8829a4aSRandall Stewart /* Now what about shutdown issues */ 4268f8829a4aSRandall Stewart /**********************************/ 4269f8829a4aSRandall Stewart if (TAILQ_EMPTY(&asoc->send_queue) && TAILQ_EMPTY(&asoc->sent_queue)) { 4270f8829a4aSRandall Stewart /* nothing left on sendqueue.. consider done */ 4271f8829a4aSRandall Stewart /* clean up */ 4272f8829a4aSRandall Stewart if ((asoc->stream_queue_cnt == 1) && 4273f8829a4aSRandall Stewart ((asoc->state & SCTP_STATE_SHUTDOWN_PENDING) || 4274f8829a4aSRandall Stewart (asoc->state & SCTP_STATE_SHUTDOWN_RECEIVED)) && 4275f8829a4aSRandall Stewart (asoc->locked_on_sending) 4276f8829a4aSRandall Stewart ) { 4277f8829a4aSRandall Stewart struct sctp_stream_queue_pending *sp; 4278f8829a4aSRandall Stewart 4279f8829a4aSRandall Stewart /* 4280f8829a4aSRandall Stewart * I may be in a state where we got all across.. but 4281f8829a4aSRandall Stewart * cannot write more due to a shutdown... we abort 4282f8829a4aSRandall Stewart * since the user did not indicate EOR in this case. 4283f8829a4aSRandall Stewart * The sp will be cleaned during free of the asoc. 4284f8829a4aSRandall Stewart */ 4285f8829a4aSRandall Stewart sp = TAILQ_LAST(&((asoc->locked_on_sending)->outqueue), 4286f8829a4aSRandall Stewart sctp_streamhead); 42872afb3e84SRandall Stewart if ((sp) && (sp->length == 0)) { 42882afb3e84SRandall Stewart /* Let cleanup code purge it */ 42892afb3e84SRandall Stewart if (sp->msg_is_complete) { 42902afb3e84SRandall Stewart asoc->stream_queue_cnt--; 42912afb3e84SRandall Stewart } else { 4292f8829a4aSRandall Stewart asoc->state |= SCTP_STATE_PARTIAL_MSG_LEFT; 4293f8829a4aSRandall Stewart asoc->locked_on_sending = NULL; 4294f8829a4aSRandall Stewart asoc->stream_queue_cnt--; 4295f8829a4aSRandall Stewart } 4296f8829a4aSRandall Stewart } 42972afb3e84SRandall Stewart } 4298f8829a4aSRandall Stewart if ((asoc->state & SCTP_STATE_SHUTDOWN_PENDING) && 4299f8829a4aSRandall Stewart (asoc->stream_queue_cnt == 0)) { 4300f8829a4aSRandall Stewart if (asoc->state & SCTP_STATE_PARTIAL_MSG_LEFT) { 4301f8829a4aSRandall Stewart /* Need to abort here */ 4302f8829a4aSRandall Stewart struct mbuf *oper; 4303f8829a4aSRandall Stewart 4304f8829a4aSRandall Stewart abort_out_now: 4305f8829a4aSRandall Stewart *abort_now = 1; 4306f8829a4aSRandall Stewart /* XXX */ 4307f8829a4aSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + sizeof(uint32_t)), 4308f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 4309f8829a4aSRandall Stewart if (oper) { 4310f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 4311f8829a4aSRandall Stewart uint32_t *ippp; 4312f8829a4aSRandall Stewart 4313139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = sizeof(struct sctp_paramhdr) + 4314f8829a4aSRandall Stewart sizeof(uint32_t); 4315f8829a4aSRandall Stewart ph = mtod(oper, struct sctp_paramhdr *); 4316f8829a4aSRandall Stewart ph->param_type = htons(SCTP_CAUSE_USER_INITIATED_ABT); 4317139bc87fSRandall Stewart ph->param_length = htons(SCTP_BUF_LEN(oper)); 4318f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 4319a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_24); 4320f8829a4aSRandall Stewart } 4321a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_24; 4322ceaad40aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, stcb, SCTP_RESPONSE_TO_USER_REQ, oper, SCTP_SO_NOT_LOCKED); 4323f8829a4aSRandall Stewart } else { 4324f42a358aSRandall Stewart if ((SCTP_GET_STATE(asoc) == SCTP_STATE_OPEN) || 4325f42a358aSRandall Stewart (SCTP_GET_STATE(asoc) == SCTP_STATE_SHUTDOWN_RECEIVED)) { 4326f8829a4aSRandall Stewart SCTP_STAT_DECR_GAUGE32(sctps_currestab); 4327f42a358aSRandall Stewart } 4328c4739e2fSRandall Stewart SCTP_SET_STATE(asoc, SCTP_STATE_SHUTDOWN_SENT); 4329b201f536SRandall Stewart SCTP_CLEAR_SUBSTATE(asoc, SCTP_STATE_SHUTDOWN_PENDING); 4330f8829a4aSRandall Stewart sctp_stop_timers_for_shutdown(stcb); 4331f8829a4aSRandall Stewart sctp_send_shutdown(stcb, 4332f8829a4aSRandall Stewart stcb->asoc.primary_destination); 4333f8829a4aSRandall Stewart sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWN, 4334f8829a4aSRandall Stewart stcb->sctp_ep, stcb, asoc->primary_destination); 4335f8829a4aSRandall Stewart sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWNGUARD, 4336f8829a4aSRandall Stewart stcb->sctp_ep, stcb, asoc->primary_destination); 4337f8829a4aSRandall Stewart } 4338f8829a4aSRandall Stewart } else if ((SCTP_GET_STATE(asoc) == SCTP_STATE_SHUTDOWN_RECEIVED) && 4339f8829a4aSRandall Stewart (asoc->stream_queue_cnt == 0)) { 4340f8829a4aSRandall Stewart if (asoc->state & SCTP_STATE_PARTIAL_MSG_LEFT) { 4341f8829a4aSRandall Stewart goto abort_out_now; 4342f8829a4aSRandall Stewart } 4343f8829a4aSRandall Stewart SCTP_STAT_DECR_GAUGE32(sctps_currestab); 4344c4739e2fSRandall Stewart SCTP_SET_STATE(asoc, SCTP_STATE_SHUTDOWN_ACK_SENT); 4345b201f536SRandall Stewart SCTP_CLEAR_SUBSTATE(asoc, SCTP_STATE_SHUTDOWN_PENDING); 4346f8829a4aSRandall Stewart sctp_send_shutdown_ack(stcb, 4347f8829a4aSRandall Stewart stcb->asoc.primary_destination); 434812af6654SMichael Tuexen sctp_stop_timers_for_shutdown(stcb); 4349f8829a4aSRandall Stewart sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWNACK, 4350f8829a4aSRandall Stewart stcb->sctp_ep, stcb, asoc->primary_destination); 4351f8829a4aSRandall Stewart } 4352f8829a4aSRandall Stewart } 4353dfb11ef8SRandall Stewart /*********************************************/ 4354dfb11ef8SRandall Stewart /* Here we perform PR-SCTP procedures */ 4355dfb11ef8SRandall Stewart /* (section 4.2) */ 4356dfb11ef8SRandall Stewart /*********************************************/ 4357dfb11ef8SRandall Stewart /* C1. update advancedPeerAckPoint */ 4358dfb11ef8SRandall Stewart if (compare_with_wrap(cumack, asoc->advanced_peer_ack_point, MAX_TSN)) { 4359dfb11ef8SRandall Stewart asoc->advanced_peer_ack_point = cumack; 4360dfb11ef8SRandall Stewart } 4361830d754dSRandall Stewart /* PR-Sctp issues need to be addressed too */ 4362830d754dSRandall Stewart if ((asoc->peer_supports_prsctp) && (asoc->pr_sctp_cnt > 0)) { 4363830d754dSRandall Stewart struct sctp_tmit_chunk *lchk; 4364830d754dSRandall Stewart uint32_t old_adv_peer_ack_point; 4365830d754dSRandall Stewart 4366830d754dSRandall Stewart old_adv_peer_ack_point = asoc->advanced_peer_ack_point; 4367830d754dSRandall Stewart lchk = sctp_try_advance_peer_ack_point(stcb, asoc); 4368830d754dSRandall Stewart /* C3. See if we need to send a Fwd-TSN */ 4369830d754dSRandall Stewart if (compare_with_wrap(asoc->advanced_peer_ack_point, cumack, 4370830d754dSRandall Stewart MAX_TSN)) { 4371830d754dSRandall Stewart /* 4372830d754dSRandall Stewart * ISSUE with ECN, see FWD-TSN processing for notes 4373830d754dSRandall Stewart * on issues that will occur when the ECN NONCE 4374830d754dSRandall Stewart * stuff is put into SCTP for cross checking. 4375830d754dSRandall Stewart */ 4376830d754dSRandall Stewart if (compare_with_wrap(asoc->advanced_peer_ack_point, old_adv_peer_ack_point, 4377830d754dSRandall Stewart MAX_TSN)) { 4378830d754dSRandall Stewart send_forward_tsn(stcb, asoc); 4379830d754dSRandall Stewart /* 4380830d754dSRandall Stewart * ECN Nonce: Disable Nonce Sum check when 4381830d754dSRandall Stewart * FWD TSN is sent and store resync tsn 4382830d754dSRandall Stewart */ 4383830d754dSRandall Stewart asoc->nonce_sum_check = 0; 4384830d754dSRandall Stewart asoc->nonce_resync_tsn = asoc->advanced_peer_ack_point; 43850c0982b8SRandall Stewart } else if (lchk) { 43860c0982b8SRandall Stewart /* try to FR fwd-tsn's that get lost too */ 438744fbe462SRandall Stewart if (lchk->rec.data.fwd_tsn_cnt >= 3) { 43880c0982b8SRandall Stewart send_forward_tsn(stcb, asoc); 43890c0982b8SRandall Stewart } 4390830d754dSRandall Stewart } 4391830d754dSRandall Stewart } 4392830d754dSRandall Stewart if (lchk) { 4393830d754dSRandall Stewart /* Assure a timer is up */ 4394830d754dSRandall Stewart sctp_timer_start(SCTP_TIMER_TYPE_SEND, 4395830d754dSRandall Stewart stcb->sctp_ep, stcb, lchk->whoTo); 4396830d754dSRandall Stewart } 4397830d754dSRandall Stewart } 4398b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_SACK_RWND_LOGGING_ENABLE) { 4399f8829a4aSRandall Stewart sctp_misc_ints(SCTP_SACK_RWND_UPDATE, 4400f8829a4aSRandall Stewart rwnd, 4401f8829a4aSRandall Stewart stcb->asoc.peers_rwnd, 4402f8829a4aSRandall Stewart stcb->asoc.total_flight, 4403f8829a4aSRandall Stewart stcb->asoc.total_output_queue_size); 440480fefe0aSRandall Stewart } 4405f8829a4aSRandall Stewart } 4406f8829a4aSRandall Stewart 4407f8829a4aSRandall Stewart void 4408cd554309SMichael Tuexen sctp_handle_sack(struct mbuf *m, int offset_seg, int offset_dup, 4409cd554309SMichael Tuexen struct sctp_tcb *stcb, struct sctp_nets *net_from, 4410cd554309SMichael Tuexen uint16_t num_seg, uint16_t num_nr_seg, uint16_t num_dup, 4411cd554309SMichael Tuexen int *abort_now, uint8_t flags, 4412cd554309SMichael Tuexen uint32_t cum_ack, uint32_t rwnd) 4413f8829a4aSRandall Stewart { 4414f8829a4aSRandall Stewart struct sctp_association *asoc; 4415f8829a4aSRandall Stewart struct sctp_tmit_chunk *tp1, *tp2; 4416cd554309SMichael Tuexen uint32_t last_tsn, biggest_tsn_acked, biggest_tsn_newly_acked, this_sack_lowest_newack; 4417bff64a4dSRandall Stewart uint32_t sav_cum_ack; 4418f8829a4aSRandall Stewart uint16_t wake_him = 0; 4419c105859eSRandall Stewart uint32_t send_s = 0; 4420f8829a4aSRandall Stewart long j; 4421f8829a4aSRandall Stewart int accum_moved = 0; 4422f8829a4aSRandall Stewart int will_exit_fast_recovery = 0; 44235e54f665SRandall Stewart uint32_t a_rwnd, old_rwnd; 44245e54f665SRandall Stewart int win_probe_recovery = 0; 4425c105859eSRandall Stewart int win_probe_recovered = 0; 4426f8829a4aSRandall Stewart struct sctp_nets *net = NULL; 4427f8829a4aSRandall Stewart int nonce_sum_flag, ecn_seg_sums = 0; 4428bff64a4dSRandall Stewart int done_once; 4429f8829a4aSRandall Stewart uint8_t reneged_all = 0; 4430f8829a4aSRandall Stewart uint8_t cmt_dac_flag; 4431f8829a4aSRandall Stewart 4432f8829a4aSRandall Stewart /* 4433f8829a4aSRandall Stewart * we take any chance we can to service our queues since we cannot 4434f8829a4aSRandall Stewart * get awoken when the socket is read from :< 4435f8829a4aSRandall Stewart */ 4436f8829a4aSRandall Stewart /* 4437f8829a4aSRandall Stewart * Now perform the actual SACK handling: 1) Verify that it is not an 4438f8829a4aSRandall Stewart * old sack, if so discard. 2) If there is nothing left in the send 4439f8829a4aSRandall Stewart * queue (cum-ack is equal to last acked) then you have a duplicate 4440f8829a4aSRandall Stewart * too, update any rwnd change and verify no timers are running. 4441f8829a4aSRandall Stewart * then return. 3) Process any new consequtive data i.e. cum-ack 4442f8829a4aSRandall Stewart * moved process these first and note that it moved. 4) Process any 4443f8829a4aSRandall Stewart * sack blocks. 5) Drop any acked from the queue. 6) Check for any 4444f8829a4aSRandall Stewart * revoked blocks and mark. 7) Update the cwnd. 8) Nothing left, 4445f8829a4aSRandall Stewart * sync up flightsizes and things, stop all timers and also check 4446f8829a4aSRandall Stewart * for shutdown_pending state. If so then go ahead and send off the 4447f8829a4aSRandall Stewart * shutdown. If in shutdown recv, send off the shutdown-ack and 4448f8829a4aSRandall Stewart * start that timer, Ret. 9) Strike any non-acked things and do FR 4449f8829a4aSRandall Stewart * procedure if needed being sure to set the FR flag. 10) Do pr-sctp 4450f8829a4aSRandall Stewart * procedures. 11) Apply any FR penalties. 12) Assure we will SACK 4451f8829a4aSRandall Stewart * if in shutdown_recv state. 4452f8829a4aSRandall Stewart */ 4453f8829a4aSRandall Stewart SCTP_TCB_LOCK_ASSERT(stcb); 4454f8829a4aSRandall Stewart /* CMT DAC algo */ 4455f8829a4aSRandall Stewart this_sack_lowest_newack = 0; 4456f8829a4aSRandall Stewart j = 0; 4457f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_slowpath_sack); 4458cd554309SMichael Tuexen last_tsn = cum_ack; 4459cd554309SMichael Tuexen nonce_sum_flag = flags & SCTP_SACK_NONCE_SUM; 4460cd554309SMichael Tuexen cmt_dac_flag = flags & SCTP_SACK_CMT_DAC; 446118e198d3SRandall Stewart #ifdef SCTP_ASOCLOG_OF_TSNS 446218e198d3SRandall Stewart stcb->asoc.cumack_log[stcb->asoc.cumack_log_at] = cum_ack; 446318e198d3SRandall Stewart stcb->asoc.cumack_log_at++; 446418e198d3SRandall Stewart if (stcb->asoc.cumack_log_at > SCTP_TSN_LOG_SIZE) { 446518e198d3SRandall Stewart stcb->asoc.cumack_log_at = 0; 446618e198d3SRandall Stewart } 446718e198d3SRandall Stewart #endif 4468d06c82f1SRandall Stewart a_rwnd = rwnd; 4469f8829a4aSRandall Stewart 4470cd554309SMichael Tuexen if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_LOG_SACK_ARRIVALS_ENABLE) { 4471cd554309SMichael Tuexen sctp_misc_ints(SCTP_SACK_LOG_NORMAL, cum_ack, 4472cd554309SMichael Tuexen rwnd, stcb->asoc.last_acked_seq, stcb->asoc.peers_rwnd); 4473cd554309SMichael Tuexen } 44745e54f665SRandall Stewart old_rwnd = stcb->asoc.peers_rwnd; 4475b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_THRESHOLD_LOGGING) { 4476c4739e2fSRandall Stewart sctp_misc_ints(SCTP_THRESHOLD_CLEAR, 4477c4739e2fSRandall Stewart stcb->asoc.overall_error_count, 4478c4739e2fSRandall Stewart 0, 4479c4739e2fSRandall Stewart SCTP_FROM_SCTP_INDATA, 4480c4739e2fSRandall Stewart __LINE__); 4481c4739e2fSRandall Stewart } 4482f8829a4aSRandall Stewart stcb->asoc.overall_error_count = 0; 4483f8829a4aSRandall Stewart asoc = &stcb->asoc; 4484b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_SACK_LOGGING_ENABLE) { 4485f8829a4aSRandall Stewart sctp_log_sack(asoc->last_acked_seq, 4486f8829a4aSRandall Stewart cum_ack, 4487f8829a4aSRandall Stewart 0, 4488f8829a4aSRandall Stewart num_seg, 4489f8829a4aSRandall Stewart num_dup, 4490f8829a4aSRandall Stewart SCTP_LOG_NEW_SACK); 449180fefe0aSRandall Stewart } 4492b3f1ea41SRandall Stewart if ((num_dup) && (SCTP_BASE_SYSCTL(sctp_logging_level) & (SCTP_FR_LOGGING_ENABLE | SCTP_EARLYFR_LOGGING_ENABLE))) { 4493cd554309SMichael Tuexen uint16_t i; 4494458303daSRandall Stewart uint32_t *dupdata, dblock; 4495f8829a4aSRandall Stewart 4496cd554309SMichael Tuexen for (i = 0; i < num_dup; i++) { 4497cd554309SMichael Tuexen dupdata = (uint32_t *) sctp_m_getptr(m, offset_dup + i * sizeof(uint32_t), 4498458303daSRandall Stewart sizeof(uint32_t), (uint8_t *) & dblock); 4499cd554309SMichael Tuexen if (dupdata == NULL) { 4500458303daSRandall Stewart break; 4501458303daSRandall Stewart } 4502cd554309SMichael Tuexen sctp_log_fr(*dupdata, 0, 0, SCTP_FR_DUPED); 4503f8829a4aSRandall Stewart } 4504f8829a4aSRandall Stewart } 4505b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_strict_sacks)) { 4506c105859eSRandall Stewart /* reality check */ 4507c105859eSRandall Stewart if (!TAILQ_EMPTY(&asoc->sent_queue)) { 4508c105859eSRandall Stewart tp1 = TAILQ_LAST(&asoc->sent_queue, 4509c105859eSRandall Stewart sctpchunk_listhead); 4510c105859eSRandall Stewart send_s = tp1->rec.data.TSN_seq + 1; 4511c105859eSRandall Stewart } else { 4512b5c16493SMichael Tuexen tp1 = NULL; 4513c105859eSRandall Stewart send_s = asoc->sending_seq; 4514c105859eSRandall Stewart } 4515f8829a4aSRandall Stewart if (cum_ack == send_s || 4516f8829a4aSRandall Stewart compare_with_wrap(cum_ack, send_s, MAX_TSN)) { 4517c105859eSRandall Stewart struct mbuf *oper; 4518c105859eSRandall Stewart 4519f8829a4aSRandall Stewart /* 4520f8829a4aSRandall Stewart * no way, we have not even sent this TSN out yet. 4521f8829a4aSRandall Stewart * Peer is hopelessly messed up with us. 4522f8829a4aSRandall Stewart */ 4523b5c16493SMichael Tuexen printf("NEW cum_ack:%x send_s:%x is smaller or equal\n", 4524b5c16493SMichael Tuexen cum_ack, send_s); 4525b5c16493SMichael Tuexen if (tp1) { 4526b5c16493SMichael Tuexen printf("Got send_s from tsn:%x + 1 of tp1:%p\n", 4527b5c16493SMichael Tuexen tp1->rec.data.TSN_seq, tp1); 4528b5c16493SMichael Tuexen } 4529f8829a4aSRandall Stewart hopeless_peer: 4530f8829a4aSRandall Stewart *abort_now = 1; 4531f8829a4aSRandall Stewart /* XXX */ 4532f8829a4aSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + sizeof(uint32_t)), 4533f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 4534f8829a4aSRandall Stewart if (oper) { 4535f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 4536f8829a4aSRandall Stewart uint32_t *ippp; 4537f8829a4aSRandall Stewart 4538139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = sizeof(struct sctp_paramhdr) + 4539f8829a4aSRandall Stewart sizeof(uint32_t); 4540f8829a4aSRandall Stewart ph = mtod(oper, struct sctp_paramhdr *); 4541f8829a4aSRandall Stewart ph->param_type = htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 4542139bc87fSRandall Stewart ph->param_length = htons(SCTP_BUF_LEN(oper)); 4543f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 4544a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_25); 4545f8829a4aSRandall Stewart } 4546a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_25; 4547ceaad40aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, stcb, SCTP_PEER_FAULTY, oper, SCTP_SO_NOT_LOCKED); 4548f8829a4aSRandall Stewart return; 4549f8829a4aSRandall Stewart } 4550f8829a4aSRandall Stewart } 4551f8829a4aSRandall Stewart /**********************/ 4552f8829a4aSRandall Stewart /* 1) check the range */ 4553f8829a4aSRandall Stewart /**********************/ 4554f8829a4aSRandall Stewart if (compare_with_wrap(asoc->last_acked_seq, last_tsn, MAX_TSN)) { 4555f8829a4aSRandall Stewart /* acking something behind */ 4556f8829a4aSRandall Stewart return; 4557f8829a4aSRandall Stewart } 4558bff64a4dSRandall Stewart sav_cum_ack = asoc->last_acked_seq; 4559bff64a4dSRandall Stewart 4560f8829a4aSRandall Stewart /* update the Rwnd of the peer */ 4561f8829a4aSRandall Stewart if (TAILQ_EMPTY(&asoc->sent_queue) && 4562f8829a4aSRandall Stewart TAILQ_EMPTY(&asoc->send_queue) && 4563cd554309SMichael Tuexen (asoc->stream_queue_cnt == 0)) { 4564f8829a4aSRandall Stewart /* nothing left on send/sent and strmq */ 4565b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_LOG_RWND_ENABLE) { 4566f8829a4aSRandall Stewart sctp_log_rwnd_set(SCTP_SET_PEER_RWND_VIA_SACK, 4567f8829a4aSRandall Stewart asoc->peers_rwnd, 0, 0, a_rwnd); 456880fefe0aSRandall Stewart } 4569f8829a4aSRandall Stewart asoc->peers_rwnd = a_rwnd; 4570f8829a4aSRandall Stewart if (asoc->sent_queue_retran_cnt) { 4571f8829a4aSRandall Stewart asoc->sent_queue_retran_cnt = 0; 4572f8829a4aSRandall Stewart } 4573f8829a4aSRandall Stewart if (asoc->peers_rwnd < stcb->sctp_ep->sctp_ep.sctp_sws_sender) { 4574f8829a4aSRandall Stewart /* SWS sender side engages */ 4575f8829a4aSRandall Stewart asoc->peers_rwnd = 0; 4576f8829a4aSRandall Stewart } 4577f8829a4aSRandall Stewart /* stop any timers */ 4578f8829a4aSRandall Stewart TAILQ_FOREACH(net, &asoc->nets, sctp_next) { 4579f8829a4aSRandall Stewart sctp_timer_stop(SCTP_TIMER_TYPE_SEND, stcb->sctp_ep, 4580a5d547adSRandall Stewart stcb, net, SCTP_FROM_SCTP_INDATA + SCTP_LOC_26); 4581b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_early_fr)) { 4582139bc87fSRandall Stewart if (SCTP_OS_TIMER_PENDING(&net->fr_timer.timer)) { 4583f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_earlyfrstpidsck1); 4584a5d547adSRandall Stewart sctp_timer_stop(SCTP_TIMER_TYPE_EARLYFR, stcb->sctp_ep, stcb, net, 4585a5d547adSRandall Stewart SCTP_FROM_SCTP_INDATA + SCTP_LOC_26); 4586f8829a4aSRandall Stewart } 4587f8829a4aSRandall Stewart } 4588f8829a4aSRandall Stewart net->partial_bytes_acked = 0; 4589f8829a4aSRandall Stewart net->flight_size = 0; 4590f8829a4aSRandall Stewart } 4591f8829a4aSRandall Stewart asoc->total_flight = 0; 4592f8829a4aSRandall Stewart asoc->total_flight_count = 0; 4593f8829a4aSRandall Stewart return; 4594f8829a4aSRandall Stewart } 4595f8829a4aSRandall Stewart /* 4596f8829a4aSRandall Stewart * We init netAckSz and netAckSz2 to 0. These are used to track 2 4597f8829a4aSRandall Stewart * things. The total byte count acked is tracked in netAckSz AND 4598f8829a4aSRandall Stewart * netAck2 is used to track the total bytes acked that are un- 4599f8829a4aSRandall Stewart * amibguious and were never retransmitted. We track these on a per 4600f8829a4aSRandall Stewart * destination address basis. 4601f8829a4aSRandall Stewart */ 4602f8829a4aSRandall Stewart TAILQ_FOREACH(net, &asoc->nets, sctp_next) { 4603f8829a4aSRandall Stewart net->prev_cwnd = net->cwnd; 4604f8829a4aSRandall Stewart net->net_ack = 0; 4605f8829a4aSRandall Stewart net->net_ack2 = 0; 4606f8829a4aSRandall Stewart 4607f8829a4aSRandall Stewart /* 460842551e99SRandall Stewart * CMT: Reset CUC and Fast recovery algo variables before 460942551e99SRandall Stewart * SACK processing 4610f8829a4aSRandall Stewart */ 4611f8829a4aSRandall Stewart net->new_pseudo_cumack = 0; 4612f8829a4aSRandall Stewart net->will_exit_fast_recovery = 0; 4613f8829a4aSRandall Stewart } 4614f8829a4aSRandall Stewart /* process the new consecutive TSN first */ 4615f8829a4aSRandall Stewart tp1 = TAILQ_FIRST(&asoc->sent_queue); 4616f8829a4aSRandall Stewart while (tp1) { 4617f8829a4aSRandall Stewart if (compare_with_wrap(last_tsn, tp1->rec.data.TSN_seq, 4618f8829a4aSRandall Stewart MAX_TSN) || 4619f8829a4aSRandall Stewart last_tsn == tp1->rec.data.TSN_seq) { 4620f8829a4aSRandall Stewart if (tp1->sent != SCTP_DATAGRAM_UNSENT) { 4621f8829a4aSRandall Stewart /* 4622f8829a4aSRandall Stewart * ECN Nonce: Add the nonce to the sender's 4623f8829a4aSRandall Stewart * nonce sum 4624f8829a4aSRandall Stewart */ 4625f8829a4aSRandall Stewart asoc->nonce_sum_expect_base += tp1->rec.data.ect_nonce; 4626f8829a4aSRandall Stewart accum_moved = 1; 4627f8829a4aSRandall Stewart if (tp1->sent < SCTP_DATAGRAM_ACKED) { 4628f8829a4aSRandall Stewart /* 4629f8829a4aSRandall Stewart * If it is less than ACKED, it is 4630f8829a4aSRandall Stewart * now no-longer in flight. Higher 4631f8829a4aSRandall Stewart * values may occur during marking 4632f8829a4aSRandall Stewart */ 4633f8829a4aSRandall Stewart if ((tp1->whoTo->dest_state & 4634f8829a4aSRandall Stewart SCTP_ADDR_UNCONFIRMED) && 4635f8829a4aSRandall Stewart (tp1->snd_count < 2)) { 4636f8829a4aSRandall Stewart /* 4637f8829a4aSRandall Stewart * If there was no retran 4638f8829a4aSRandall Stewart * and the address is 4639f8829a4aSRandall Stewart * un-confirmed and we sent 4640f8829a4aSRandall Stewart * there and are now 4641f8829a4aSRandall Stewart * sacked.. its confirmed, 4642f8829a4aSRandall Stewart * mark it so. 4643f8829a4aSRandall Stewart */ 4644f8829a4aSRandall Stewart tp1->whoTo->dest_state &= 4645f8829a4aSRandall Stewart ~SCTP_ADDR_UNCONFIRMED; 4646f8829a4aSRandall Stewart } 4647c105859eSRandall Stewart if (tp1->sent < SCTP_DATAGRAM_RESEND) { 4648b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_FLIGHT_LOGGING_ENABLE) { 4649c105859eSRandall Stewart sctp_misc_ints(SCTP_FLIGHT_LOG_DOWN_CA, 4650a5d547adSRandall Stewart tp1->whoTo->flight_size, 4651a5d547adSRandall Stewart tp1->book_size, 4652c105859eSRandall Stewart (uintptr_t) tp1->whoTo, 4653a5d547adSRandall Stewart tp1->rec.data.TSN_seq); 465480fefe0aSRandall Stewart } 4655c105859eSRandall Stewart sctp_flight_size_decrease(tp1); 4656c105859eSRandall Stewart sctp_total_flight_decrease(stcb, tp1); 4657f8829a4aSRandall Stewart } 4658f8829a4aSRandall Stewart tp1->whoTo->net_ack += tp1->send_size; 4659f8829a4aSRandall Stewart 4660f8829a4aSRandall Stewart /* CMT SFR and DAC algos */ 4661f8829a4aSRandall Stewart this_sack_lowest_newack = tp1->rec.data.TSN_seq; 4662f8829a4aSRandall Stewart tp1->whoTo->saw_newack = 1; 4663f8829a4aSRandall Stewart 4664f8829a4aSRandall Stewart if (tp1->snd_count < 2) { 4665f8829a4aSRandall Stewart /* 4666f8829a4aSRandall Stewart * True non-retransmited 4667f8829a4aSRandall Stewart * chunk 4668f8829a4aSRandall Stewart */ 4669f8829a4aSRandall Stewart tp1->whoTo->net_ack2 += 4670f8829a4aSRandall Stewart tp1->send_size; 4671f8829a4aSRandall Stewart 4672f8829a4aSRandall Stewart /* update RTO too? */ 4673f8829a4aSRandall Stewart if (tp1->do_rtt) { 4674f8829a4aSRandall Stewart tp1->whoTo->RTO = 4675f8829a4aSRandall Stewart sctp_calculate_rto(stcb, 4676f8829a4aSRandall Stewart asoc, tp1->whoTo, 467718e198d3SRandall Stewart &tp1->sent_rcv_time, 467818e198d3SRandall Stewart sctp_align_safe_nocopy); 4679f8829a4aSRandall Stewart tp1->do_rtt = 0; 4680f8829a4aSRandall Stewart } 4681f8829a4aSRandall Stewart } 4682f8829a4aSRandall Stewart /* 4683f8829a4aSRandall Stewart * CMT: CUCv2 algorithm. From the 4684f8829a4aSRandall Stewart * cumack'd TSNs, for each TSN being 4685f8829a4aSRandall Stewart * acked for the first time, set the 4686f8829a4aSRandall Stewart * following variables for the 4687f8829a4aSRandall Stewart * corresp destination. 4688f8829a4aSRandall Stewart * new_pseudo_cumack will trigger a 4689f8829a4aSRandall Stewart * cwnd update. 4690f8829a4aSRandall Stewart * find_(rtx_)pseudo_cumack will 4691f8829a4aSRandall Stewart * trigger search for the next 4692f8829a4aSRandall Stewart * expected (rtx-)pseudo-cumack. 4693f8829a4aSRandall Stewart */ 4694f8829a4aSRandall Stewart tp1->whoTo->new_pseudo_cumack = 1; 4695f8829a4aSRandall Stewart tp1->whoTo->find_pseudo_cumack = 1; 4696f8829a4aSRandall Stewart tp1->whoTo->find_rtx_pseudo_cumack = 1; 4697f8829a4aSRandall Stewart 4698f8829a4aSRandall Stewart 4699b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_SACK_LOGGING_ENABLE) { 4700f8829a4aSRandall Stewart sctp_log_sack(asoc->last_acked_seq, 4701f8829a4aSRandall Stewart cum_ack, 4702f8829a4aSRandall Stewart tp1->rec.data.TSN_seq, 4703f8829a4aSRandall Stewart 0, 4704f8829a4aSRandall Stewart 0, 4705f8829a4aSRandall Stewart SCTP_LOG_TSN_ACKED); 470680fefe0aSRandall Stewart } 4707b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_LOGGING_ENABLE) { 4708f8829a4aSRandall Stewart sctp_log_cwnd(stcb, tp1->whoTo, tp1->rec.data.TSN_seq, SCTP_CWND_LOG_FROM_SACK); 470980fefe0aSRandall Stewart } 4710f8829a4aSRandall Stewart } 4711f8829a4aSRandall Stewart if (tp1->sent == SCTP_DATAGRAM_RESEND) { 4712f8829a4aSRandall Stewart sctp_ucount_decr(asoc->sent_queue_retran_cnt); 4713f8829a4aSRandall Stewart #ifdef SCTP_AUDITING_ENABLED 4714f8829a4aSRandall Stewart sctp_audit_log(0xB3, 4715f8829a4aSRandall Stewart (asoc->sent_queue_retran_cnt & 0x000000ff)); 4716f8829a4aSRandall Stewart #endif 4717f8829a4aSRandall Stewart } 471842551e99SRandall Stewart if (tp1->rec.data.chunk_was_revoked) { 471942551e99SRandall Stewart /* deflate the cwnd */ 472042551e99SRandall Stewart tp1->whoTo->cwnd -= tp1->book_size; 472142551e99SRandall Stewart tp1->rec.data.chunk_was_revoked = 0; 472242551e99SRandall Stewart } 4723f8829a4aSRandall Stewart tp1->sent = SCTP_DATAGRAM_ACKED; 4724f8829a4aSRandall Stewart } 4725f8829a4aSRandall Stewart } else { 4726f8829a4aSRandall Stewart break; 4727f8829a4aSRandall Stewart } 4728f8829a4aSRandall Stewart tp1 = TAILQ_NEXT(tp1, sctp_next); 4729f8829a4aSRandall Stewart } 4730f8829a4aSRandall Stewart biggest_tsn_newly_acked = biggest_tsn_acked = last_tsn; 4731f8829a4aSRandall Stewart /* always set this up to cum-ack */ 4732f8829a4aSRandall Stewart asoc->this_sack_highest_gap = last_tsn; 4733f8829a4aSRandall Stewart 4734cd554309SMichael Tuexen if ((num_seg > 0) || (num_nr_seg > 0)) { 4735f8829a4aSRandall Stewart 4736f8829a4aSRandall Stewart /* 4737f8829a4aSRandall Stewart * CMT: SFR algo (and HTNA) - this_sack_highest_newack has 4738f8829a4aSRandall Stewart * to be greater than the cumack. Also reset saw_newack to 0 4739f8829a4aSRandall Stewart * for all dests. 4740f8829a4aSRandall Stewart */ 4741f8829a4aSRandall Stewart TAILQ_FOREACH(net, &asoc->nets, sctp_next) { 4742f8829a4aSRandall Stewart net->saw_newack = 0; 4743f8829a4aSRandall Stewart net->this_sack_highest_newack = last_tsn; 4744f8829a4aSRandall Stewart } 4745f8829a4aSRandall Stewart 4746f8829a4aSRandall Stewart /* 4747f8829a4aSRandall Stewart * thisSackHighestGap will increase while handling NEW 4748f8829a4aSRandall Stewart * segments this_sack_highest_newack will increase while 4749f8829a4aSRandall Stewart * handling NEWLY ACKED chunks. this_sack_lowest_newack is 4750f8829a4aSRandall Stewart * used for CMT DAC algo. saw_newack will also change. 4751f8829a4aSRandall Stewart */ 4752cd554309SMichael Tuexen if (sctp_handle_segments(m, &offset_seg, stcb, asoc, last_tsn, &biggest_tsn_acked, 4753cd554309SMichael Tuexen &biggest_tsn_newly_acked, &this_sack_lowest_newack, 4754cd554309SMichael Tuexen num_seg, num_nr_seg, &ecn_seg_sums)) { 4755cd554309SMichael Tuexen wake_him++; 4756cd554309SMichael Tuexen } 4757b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_strict_sacks)) { 4758f8829a4aSRandall Stewart /* 4759f8829a4aSRandall Stewart * validate the biggest_tsn_acked in the gap acks if 4760f8829a4aSRandall Stewart * strict adherence is wanted. 4761f8829a4aSRandall Stewart */ 4762f8829a4aSRandall Stewart if ((biggest_tsn_acked == send_s) || 4763f8829a4aSRandall Stewart (compare_with_wrap(biggest_tsn_acked, send_s, MAX_TSN))) { 4764f8829a4aSRandall Stewart /* 4765f8829a4aSRandall Stewart * peer is either confused or we are under 4766f8829a4aSRandall Stewart * attack. We must abort. 4767f8829a4aSRandall Stewart */ 4768b5c16493SMichael Tuexen printf("Hopeless peer! biggest_tsn_acked:%x largest seq:%x\n", 4769b5c16493SMichael Tuexen biggest_tsn_acked, 4770b5c16493SMichael Tuexen send_s); 4771b5c16493SMichael Tuexen 4772f8829a4aSRandall Stewart goto hopeless_peer; 4773f8829a4aSRandall Stewart } 4774f8829a4aSRandall Stewart } 4775f8829a4aSRandall Stewart } 4776f8829a4aSRandall Stewart /*******************************************/ 4777f8829a4aSRandall Stewart /* cancel ALL T3-send timer if accum moved */ 4778f8829a4aSRandall Stewart /*******************************************/ 4779*7c99d56fSMichael Tuexen if (asoc->sctp_cmt_on_off > 0) { 4780f8829a4aSRandall Stewart TAILQ_FOREACH(net, &asoc->nets, sctp_next) { 4781f8829a4aSRandall Stewart if (net->new_pseudo_cumack) 4782f8829a4aSRandall Stewart sctp_timer_stop(SCTP_TIMER_TYPE_SEND, stcb->sctp_ep, 4783a5d547adSRandall Stewart stcb, net, 4784a5d547adSRandall Stewart SCTP_FROM_SCTP_INDATA + SCTP_LOC_27); 4785f8829a4aSRandall Stewart 4786f8829a4aSRandall Stewart } 4787f8829a4aSRandall Stewart } else { 4788f8829a4aSRandall Stewart if (accum_moved) { 4789f8829a4aSRandall Stewart TAILQ_FOREACH(net, &asoc->nets, sctp_next) { 4790f8829a4aSRandall Stewart sctp_timer_stop(SCTP_TIMER_TYPE_SEND, stcb->sctp_ep, 4791a5d547adSRandall Stewart stcb, net, SCTP_FROM_SCTP_INDATA + SCTP_LOC_28); 4792f8829a4aSRandall Stewart } 4793f8829a4aSRandall Stewart } 4794f8829a4aSRandall Stewart } 4795f8829a4aSRandall Stewart /********************************************/ 4796d9c5cfeaSMichael Tuexen /* drop the acked chunks from the sentqueue */ 4797f8829a4aSRandall Stewart /********************************************/ 4798f8829a4aSRandall Stewart asoc->last_acked_seq = cum_ack; 4799f8829a4aSRandall Stewart 4800*7c99d56fSMichael Tuexen TAILQ_FOREACH_SAFE(tp1, &asoc->sent_queue, sctp_next, tp2) { 4801f8829a4aSRandall Stewart if (compare_with_wrap(tp1->rec.data.TSN_seq, cum_ack, 4802f8829a4aSRandall Stewart MAX_TSN)) { 4803f8829a4aSRandall Stewart break; 4804f8829a4aSRandall Stewart } 4805f8829a4aSRandall Stewart if (tp1->sent == SCTP_DATAGRAM_UNSENT) { 4806f8829a4aSRandall Stewart /* no more sent on list */ 480718e198d3SRandall Stewart printf("Warning, tp1->sent == %d and its now acked?\n", 480818e198d3SRandall Stewart tp1->sent); 4809f8829a4aSRandall Stewart } 4810f8829a4aSRandall Stewart TAILQ_REMOVE(&asoc->sent_queue, tp1, sctp_next); 4811f8829a4aSRandall Stewart if (tp1->pr_sctp_on) { 4812f8829a4aSRandall Stewart if (asoc->pr_sctp_cnt != 0) 4813f8829a4aSRandall Stewart asoc->pr_sctp_cnt--; 4814f8829a4aSRandall Stewart } 4815*7c99d56fSMichael Tuexen asoc->sent_queue_cnt--; 4816f8829a4aSRandall Stewart if (tp1->data) { 481704ee05e8SRandall Stewart /* sa_ignore NO_NULL_CHK */ 4818f8829a4aSRandall Stewart sctp_free_bufspace(stcb, asoc, tp1, 1); 4819f8829a4aSRandall Stewart sctp_m_freem(tp1->data); 4820*7c99d56fSMichael Tuexen tp1->data = NULL; 4821810ec536SMichael Tuexen if (asoc->peer_supports_prsctp && PR_SCTP_BUF_ENABLED(tp1->flags)) { 4822f8829a4aSRandall Stewart asoc->sent_queue_cnt_removeable--; 4823f8829a4aSRandall Stewart } 4824f8829a4aSRandall Stewart } 4825b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_SACK_LOGGING_ENABLE) { 4826f8829a4aSRandall Stewart sctp_log_sack(asoc->last_acked_seq, 4827f8829a4aSRandall Stewart cum_ack, 4828f8829a4aSRandall Stewart tp1->rec.data.TSN_seq, 4829f8829a4aSRandall Stewart 0, 4830f8829a4aSRandall Stewart 0, 4831f8829a4aSRandall Stewart SCTP_LOG_FREE_SENT); 483280fefe0aSRandall Stewart } 4833f8829a4aSRandall Stewart sctp_free_a_chunk(stcb, tp1); 4834f8829a4aSRandall Stewart wake_him++; 4835*7c99d56fSMichael Tuexen } 4836*7c99d56fSMichael Tuexen if (TAILQ_EMPTY(&asoc->sent_queue) && (asoc->total_flight > 0)) { 4837*7c99d56fSMichael Tuexen #ifdef INVARIANTS 4838*7c99d56fSMichael Tuexen panic("Warning flight size is postive and should be 0"); 4839*7c99d56fSMichael Tuexen #else 4840*7c99d56fSMichael Tuexen SCTP_PRINTF("Warning flight size incorrect should be 0 is %d\n", 4841*7c99d56fSMichael Tuexen asoc->total_flight); 4842*7c99d56fSMichael Tuexen #endif 4843*7c99d56fSMichael Tuexen asoc->total_flight = 0; 4844*7c99d56fSMichael Tuexen } 484504ee05e8SRandall Stewart /* sa_ignore NO_NULL_CHK */ 4846f8829a4aSRandall Stewart if ((wake_him) && (stcb->sctp_socket)) { 4847ceaad40aSRandall Stewart #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 4848ceaad40aSRandall Stewart struct socket *so; 4849ceaad40aSRandall Stewart 4850ceaad40aSRandall Stewart #endif 4851f8829a4aSRandall Stewart SOCKBUF_LOCK(&stcb->sctp_socket->so_snd); 4852b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_WAKE_LOGGING_ENABLE) { 4853f8829a4aSRandall Stewart sctp_wakeup_log(stcb, cum_ack, wake_him, SCTP_WAKESND_FROM_SACK); 485480fefe0aSRandall Stewart } 4855ceaad40aSRandall Stewart #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 4856ceaad40aSRandall Stewart so = SCTP_INP_SO(stcb->sctp_ep); 4857ceaad40aSRandall Stewart atomic_add_int(&stcb->asoc.refcnt, 1); 4858ceaad40aSRandall Stewart SCTP_TCB_UNLOCK(stcb); 4859ceaad40aSRandall Stewart SCTP_SOCKET_LOCK(so, 1); 4860ceaad40aSRandall Stewart SCTP_TCB_LOCK(stcb); 4861ceaad40aSRandall Stewart atomic_subtract_int(&stcb->asoc.refcnt, 1); 4862ceaad40aSRandall Stewart if (stcb->asoc.state & SCTP_STATE_CLOSED_SOCKET) { 4863ceaad40aSRandall Stewart /* assoc was freed while we were unlocked */ 4864ceaad40aSRandall Stewart SCTP_SOCKET_UNLOCK(so, 1); 4865ceaad40aSRandall Stewart return; 4866ceaad40aSRandall Stewart } 4867ceaad40aSRandall Stewart #endif 4868f8829a4aSRandall Stewart sctp_sowwakeup_locked(stcb->sctp_ep, stcb->sctp_socket); 4869ceaad40aSRandall Stewart #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 4870ceaad40aSRandall Stewart SCTP_SOCKET_UNLOCK(so, 1); 4871ceaad40aSRandall Stewart #endif 4872f8829a4aSRandall Stewart } else { 4873b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_WAKE_LOGGING_ENABLE) { 4874f8829a4aSRandall Stewart sctp_wakeup_log(stcb, cum_ack, wake_him, SCTP_NOWAKE_FROM_SACK); 487580fefe0aSRandall Stewart } 4876f8829a4aSRandall Stewart } 4877f8829a4aSRandall Stewart 487842551e99SRandall Stewart if (asoc->fast_retran_loss_recovery && accum_moved) { 4879f8829a4aSRandall Stewart if (compare_with_wrap(asoc->last_acked_seq, 4880f8829a4aSRandall Stewart asoc->fast_recovery_tsn, MAX_TSN) || 4881f8829a4aSRandall Stewart asoc->last_acked_seq == asoc->fast_recovery_tsn) { 4882f8829a4aSRandall Stewart /* Setup so we will exit RFC2582 fast recovery */ 4883f8829a4aSRandall Stewart will_exit_fast_recovery = 1; 4884f8829a4aSRandall Stewart } 4885f8829a4aSRandall Stewart } 4886f8829a4aSRandall Stewart /* 4887f8829a4aSRandall Stewart * Check for revoked fragments: 4888f8829a4aSRandall Stewart * 4889f8829a4aSRandall Stewart * if Previous sack - Had no frags then we can't have any revoked if 4890f8829a4aSRandall Stewart * Previous sack - Had frag's then - If we now have frags aka 4891f8829a4aSRandall Stewart * num_seg > 0 call sctp_check_for_revoked() to tell if peer revoked 4892f8829a4aSRandall Stewart * some of them. else - The peer revoked all ACKED fragments, since 4893f8829a4aSRandall Stewart * we had some before and now we have NONE. 4894f8829a4aSRandall Stewart */ 4895f8829a4aSRandall Stewart 4896d9c5cfeaSMichael Tuexen if (num_seg) { 4897c105859eSRandall Stewart sctp_check_for_revoked(stcb, asoc, cum_ack, biggest_tsn_acked); 4898d9c5cfeaSMichael Tuexen asoc->saw_sack_with_frags = 1; 4899d9c5cfeaSMichael Tuexen } else if (asoc->saw_sack_with_frags) { 4900f8829a4aSRandall Stewart int cnt_revoked = 0; 4901f8829a4aSRandall Stewart 4902f8829a4aSRandall Stewart tp1 = TAILQ_FIRST(&asoc->sent_queue); 4903f8829a4aSRandall Stewart if (tp1 != NULL) { 4904f8829a4aSRandall Stewart /* Peer revoked all dg's marked or acked */ 4905f8829a4aSRandall Stewart TAILQ_FOREACH(tp1, &asoc->sent_queue, sctp_next) { 4906b5c16493SMichael Tuexen if (tp1->sent == SCTP_DATAGRAM_ACKED) { 4907f8829a4aSRandall Stewart tp1->sent = SCTP_DATAGRAM_SENT; 4908b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_FLIGHT_LOGGING_ENABLE) { 4909c105859eSRandall Stewart sctp_misc_ints(SCTP_FLIGHT_LOG_UP_REVOKE, 4910c105859eSRandall Stewart tp1->whoTo->flight_size, 4911c105859eSRandall Stewart tp1->book_size, 4912c105859eSRandall Stewart (uintptr_t) tp1->whoTo, 4913c105859eSRandall Stewart tp1->rec.data.TSN_seq); 491480fefe0aSRandall Stewart } 4915c105859eSRandall Stewart sctp_flight_size_increase(tp1); 4916c105859eSRandall Stewart sctp_total_flight_increase(stcb, tp1); 4917a5d547adSRandall Stewart tp1->rec.data.chunk_was_revoked = 1; 491842551e99SRandall Stewart /* 491942551e99SRandall Stewart * To ensure that this increase in 492042551e99SRandall Stewart * flightsize, which is artificial, 492142551e99SRandall Stewart * does not throttle the sender, we 492242551e99SRandall Stewart * also increase the cwnd 492342551e99SRandall Stewart * artificially. 492442551e99SRandall Stewart */ 492542551e99SRandall Stewart tp1->whoTo->cwnd += tp1->book_size; 4926f8829a4aSRandall Stewart cnt_revoked++; 4927f8829a4aSRandall Stewart } 4928f8829a4aSRandall Stewart } 4929f8829a4aSRandall Stewart if (cnt_revoked) { 4930f8829a4aSRandall Stewart reneged_all = 1; 4931f8829a4aSRandall Stewart } 4932f8829a4aSRandall Stewart } 4933f8829a4aSRandall Stewart asoc->saw_sack_with_frags = 0; 4934f8829a4aSRandall Stewart } 4935d9c5cfeaSMichael Tuexen if (num_nr_seg > 0) 4936d9c5cfeaSMichael Tuexen asoc->saw_sack_with_nr_frags = 1; 4937f8829a4aSRandall Stewart else 4938d9c5cfeaSMichael Tuexen asoc->saw_sack_with_nr_frags = 0; 4939f8829a4aSRandall Stewart 4940b54d3a6cSRandall Stewart /* JRS - Use the congestion control given in the CC module */ 4941b54d3a6cSRandall Stewart asoc->cc_functions.sctp_cwnd_update_after_sack(stcb, asoc, accum_moved, reneged_all, will_exit_fast_recovery); 4942f8829a4aSRandall Stewart 4943f8829a4aSRandall Stewart if (TAILQ_EMPTY(&asoc->sent_queue)) { 4944f8829a4aSRandall Stewart /* nothing left in-flight */ 4945f8829a4aSRandall Stewart TAILQ_FOREACH(net, &asoc->nets, sctp_next) { 4946f8829a4aSRandall Stewart /* stop all timers */ 4947b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_early_fr)) { 4948139bc87fSRandall Stewart if (SCTP_OS_TIMER_PENDING(&net->fr_timer.timer)) { 4949f8829a4aSRandall Stewart SCTP_STAT_INCR(sctps_earlyfrstpidsck4); 4950a5d547adSRandall Stewart sctp_timer_stop(SCTP_TIMER_TYPE_EARLYFR, stcb->sctp_ep, stcb, net, 4951a5d547adSRandall Stewart SCTP_FROM_SCTP_INDATA + SCTP_LOC_29); 4952f8829a4aSRandall Stewart } 4953f8829a4aSRandall Stewart } 4954f8829a4aSRandall Stewart sctp_timer_stop(SCTP_TIMER_TYPE_SEND, stcb->sctp_ep, 4955a5d547adSRandall Stewart stcb, net, SCTP_FROM_SCTP_INDATA + SCTP_LOC_30); 4956f8829a4aSRandall Stewart net->flight_size = 0; 4957f8829a4aSRandall Stewart net->partial_bytes_acked = 0; 4958f8829a4aSRandall Stewart } 4959f8829a4aSRandall Stewart asoc->total_flight = 0; 4960f8829a4aSRandall Stewart asoc->total_flight_count = 0; 4961f8829a4aSRandall Stewart } 4962f8829a4aSRandall Stewart /**********************************/ 4963f8829a4aSRandall Stewart /* Now what about shutdown issues */ 4964f8829a4aSRandall Stewart /**********************************/ 4965f8829a4aSRandall Stewart if (TAILQ_EMPTY(&asoc->send_queue) && TAILQ_EMPTY(&asoc->sent_queue)) { 4966f8829a4aSRandall Stewart /* nothing left on sendqueue.. consider done */ 4967b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_LOG_RWND_ENABLE) { 4968f8829a4aSRandall Stewart sctp_log_rwnd_set(SCTP_SET_PEER_RWND_VIA_SACK, 4969f8829a4aSRandall Stewart asoc->peers_rwnd, 0, 0, a_rwnd); 497080fefe0aSRandall Stewart } 4971f8829a4aSRandall Stewart asoc->peers_rwnd = a_rwnd; 4972f8829a4aSRandall Stewart if (asoc->peers_rwnd < stcb->sctp_ep->sctp_ep.sctp_sws_sender) { 4973f8829a4aSRandall Stewart /* SWS sender side engages */ 4974f8829a4aSRandall Stewart asoc->peers_rwnd = 0; 4975f8829a4aSRandall Stewart } 4976f8829a4aSRandall Stewart /* clean up */ 4977f8829a4aSRandall Stewart if ((asoc->stream_queue_cnt == 1) && 4978f8829a4aSRandall Stewart ((asoc->state & SCTP_STATE_SHUTDOWN_PENDING) || 4979f8829a4aSRandall Stewart (asoc->state & SCTP_STATE_SHUTDOWN_RECEIVED)) && 4980f8829a4aSRandall Stewart (asoc->locked_on_sending) 4981f8829a4aSRandall Stewart ) { 4982f8829a4aSRandall Stewart struct sctp_stream_queue_pending *sp; 4983f8829a4aSRandall Stewart 4984f8829a4aSRandall Stewart /* 4985f8829a4aSRandall Stewart * I may be in a state where we got all across.. but 4986f8829a4aSRandall Stewart * cannot write more due to a shutdown... we abort 4987f8829a4aSRandall Stewart * since the user did not indicate EOR in this case. 4988f8829a4aSRandall Stewart */ 4989f8829a4aSRandall Stewart sp = TAILQ_LAST(&((asoc->locked_on_sending)->outqueue), 4990f8829a4aSRandall Stewart sctp_streamhead); 49912afb3e84SRandall Stewart if ((sp) && (sp->length == 0)) { 4992f8829a4aSRandall Stewart asoc->locked_on_sending = NULL; 49932afb3e84SRandall Stewart if (sp->msg_is_complete) { 4994f8829a4aSRandall Stewart asoc->stream_queue_cnt--; 49952afb3e84SRandall Stewart } else { 49962afb3e84SRandall Stewart asoc->state |= SCTP_STATE_PARTIAL_MSG_LEFT; 49972afb3e84SRandall Stewart asoc->stream_queue_cnt--; 49982afb3e84SRandall Stewart } 4999f8829a4aSRandall Stewart } 5000f8829a4aSRandall Stewart } 5001f8829a4aSRandall Stewart if ((asoc->state & SCTP_STATE_SHUTDOWN_PENDING) && 5002f8829a4aSRandall Stewart (asoc->stream_queue_cnt == 0)) { 5003f8829a4aSRandall Stewart if (asoc->state & SCTP_STATE_PARTIAL_MSG_LEFT) { 5004f8829a4aSRandall Stewart /* Need to abort here */ 5005f8829a4aSRandall Stewart struct mbuf *oper; 5006f8829a4aSRandall Stewart 5007f8829a4aSRandall Stewart abort_out_now: 5008f8829a4aSRandall Stewart *abort_now = 1; 5009f8829a4aSRandall Stewart /* XXX */ 5010f8829a4aSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + sizeof(uint32_t)), 5011f8829a4aSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 5012f8829a4aSRandall Stewart if (oper) { 5013f8829a4aSRandall Stewart struct sctp_paramhdr *ph; 5014f8829a4aSRandall Stewart uint32_t *ippp; 5015f8829a4aSRandall Stewart 5016139bc87fSRandall Stewart SCTP_BUF_LEN(oper) = sizeof(struct sctp_paramhdr) + 5017f8829a4aSRandall Stewart sizeof(uint32_t); 5018f8829a4aSRandall Stewart ph = mtod(oper, struct sctp_paramhdr *); 5019f8829a4aSRandall Stewart ph->param_type = htons(SCTP_CAUSE_USER_INITIATED_ABT); 5020139bc87fSRandall Stewart ph->param_length = htons(SCTP_BUF_LEN(oper)); 5021f8829a4aSRandall Stewart ippp = (uint32_t *) (ph + 1); 5022a5d547adSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_31); 5023f8829a4aSRandall Stewart } 5024a5d547adSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_31; 5025ceaad40aSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, stcb, SCTP_RESPONSE_TO_USER_REQ, oper, SCTP_SO_NOT_LOCKED); 5026f8829a4aSRandall Stewart return; 5027f8829a4aSRandall Stewart } else { 5028f42a358aSRandall Stewart if ((SCTP_GET_STATE(asoc) == SCTP_STATE_OPEN) || 5029f42a358aSRandall Stewart (SCTP_GET_STATE(asoc) == SCTP_STATE_SHUTDOWN_RECEIVED)) { 5030f8829a4aSRandall Stewart SCTP_STAT_DECR_GAUGE32(sctps_currestab); 5031f42a358aSRandall Stewart } 5032c4739e2fSRandall Stewart SCTP_SET_STATE(asoc, SCTP_STATE_SHUTDOWN_SENT); 5033b201f536SRandall Stewart SCTP_CLEAR_SUBSTATE(asoc, SCTP_STATE_SHUTDOWN_PENDING); 5034f8829a4aSRandall Stewart sctp_stop_timers_for_shutdown(stcb); 5035f8829a4aSRandall Stewart sctp_send_shutdown(stcb, 5036f8829a4aSRandall Stewart stcb->asoc.primary_destination); 5037f8829a4aSRandall Stewart sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWN, 5038f8829a4aSRandall Stewart stcb->sctp_ep, stcb, asoc->primary_destination); 5039f8829a4aSRandall Stewart sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWNGUARD, 5040f8829a4aSRandall Stewart stcb->sctp_ep, stcb, asoc->primary_destination); 5041f8829a4aSRandall Stewart } 5042f8829a4aSRandall Stewart return; 5043f8829a4aSRandall Stewart } else if ((SCTP_GET_STATE(asoc) == SCTP_STATE_SHUTDOWN_RECEIVED) && 5044f8829a4aSRandall Stewart (asoc->stream_queue_cnt == 0)) { 5045f8829a4aSRandall Stewart if (asoc->state & SCTP_STATE_PARTIAL_MSG_LEFT) { 5046f8829a4aSRandall Stewart goto abort_out_now; 5047f8829a4aSRandall Stewart } 5048f8829a4aSRandall Stewart SCTP_STAT_DECR_GAUGE32(sctps_currestab); 5049c4739e2fSRandall Stewart SCTP_SET_STATE(asoc, SCTP_STATE_SHUTDOWN_ACK_SENT); 5050b201f536SRandall Stewart SCTP_CLEAR_SUBSTATE(asoc, SCTP_STATE_SHUTDOWN_PENDING); 5051f8829a4aSRandall Stewart sctp_send_shutdown_ack(stcb, 5052f8829a4aSRandall Stewart stcb->asoc.primary_destination); 505312af6654SMichael Tuexen sctp_stop_timers_for_shutdown(stcb); 5054f8829a4aSRandall Stewart sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWNACK, 5055f8829a4aSRandall Stewart stcb->sctp_ep, stcb, asoc->primary_destination); 5056f8829a4aSRandall Stewart return; 5057f8829a4aSRandall Stewart } 5058f8829a4aSRandall Stewart } 5059f8829a4aSRandall Stewart /* 5060f8829a4aSRandall Stewart * Now here we are going to recycle net_ack for a different use... 5061f8829a4aSRandall Stewart * HEADS UP. 5062f8829a4aSRandall Stewart */ 5063f8829a4aSRandall Stewart TAILQ_FOREACH(net, &asoc->nets, sctp_next) { 5064f8829a4aSRandall Stewart net->net_ack = 0; 5065f8829a4aSRandall Stewart } 5066f8829a4aSRandall Stewart 5067f8829a4aSRandall Stewart /* 5068f8829a4aSRandall Stewart * CMT DAC algorithm: If SACK DAC flag was 0, then no extra marking 5069f8829a4aSRandall Stewart * to be done. Setting this_sack_lowest_newack to the cum_ack will 5070f8829a4aSRandall Stewart * automatically ensure that. 5071f8829a4aSRandall Stewart */ 5072*7c99d56fSMichael Tuexen if ((asoc->sctp_cmt_on_off > 0) && 507320083c2eSMichael Tuexen SCTP_BASE_SYSCTL(sctp_cmt_use_dac) && 507420083c2eSMichael Tuexen (cmt_dac_flag == 0)) { 5075f8829a4aSRandall Stewart this_sack_lowest_newack = cum_ack; 5076f8829a4aSRandall Stewart } 5077cd554309SMichael Tuexen if ((num_seg > 0) || (num_nr_seg > 0)) { 5078f8829a4aSRandall Stewart sctp_strike_gap_ack_chunks(stcb, asoc, biggest_tsn_acked, 5079f8829a4aSRandall Stewart biggest_tsn_newly_acked, this_sack_lowest_newack, accum_moved); 5080f8829a4aSRandall Stewart } 5081b54d3a6cSRandall Stewart /* JRS - Use the congestion control given in the CC module */ 5082b54d3a6cSRandall Stewart asoc->cc_functions.sctp_cwnd_update_after_fr(stcb, asoc); 5083f8829a4aSRandall Stewart 5084f8829a4aSRandall Stewart /****************************************************************** 5085f8829a4aSRandall Stewart * Here we do the stuff with ECN Nonce checking. 5086f8829a4aSRandall Stewart * We basically check to see if the nonce sum flag was incorrect 5087f8829a4aSRandall Stewart * or if resynchronization needs to be done. Also if we catch a 5088f8829a4aSRandall Stewart * misbehaving receiver we give him the kick. 5089f8829a4aSRandall Stewart ******************************************************************/ 5090f8829a4aSRandall Stewart 5091f8829a4aSRandall Stewart if (asoc->ecn_nonce_allowed) { 5092f8829a4aSRandall Stewart if (asoc->nonce_sum_check) { 5093f8829a4aSRandall Stewart if (nonce_sum_flag != ((asoc->nonce_sum_expect_base + ecn_seg_sums) & SCTP_SACK_NONCE_SUM)) { 5094f8829a4aSRandall Stewart if (asoc->nonce_wait_for_ecne == 0) { 5095f8829a4aSRandall Stewart struct sctp_tmit_chunk *lchk; 5096f8829a4aSRandall Stewart 5097f8829a4aSRandall Stewart lchk = TAILQ_FIRST(&asoc->send_queue); 5098f8829a4aSRandall Stewart asoc->nonce_wait_for_ecne = 1; 5099f8829a4aSRandall Stewart if (lchk) { 5100f8829a4aSRandall Stewart asoc->nonce_wait_tsn = lchk->rec.data.TSN_seq; 5101f8829a4aSRandall Stewart } else { 5102f8829a4aSRandall Stewart asoc->nonce_wait_tsn = asoc->sending_seq; 5103f8829a4aSRandall Stewart } 5104f8829a4aSRandall Stewart } else { 5105f8829a4aSRandall Stewart if (compare_with_wrap(asoc->last_acked_seq, asoc->nonce_wait_tsn, MAX_TSN) || 5106f8829a4aSRandall Stewart (asoc->last_acked_seq == asoc->nonce_wait_tsn)) { 5107f8829a4aSRandall Stewart /* 5108f8829a4aSRandall Stewart * Misbehaving peer. We need 5109f8829a4aSRandall Stewart * to react to this guy 5110f8829a4aSRandall Stewart */ 5111f8829a4aSRandall Stewart asoc->ecn_allowed = 0; 5112f8829a4aSRandall Stewart asoc->ecn_nonce_allowed = 0; 5113f8829a4aSRandall Stewart } 5114f8829a4aSRandall Stewart } 5115f8829a4aSRandall Stewart } 5116f8829a4aSRandall Stewart } else { 5117f8829a4aSRandall Stewart /* See if Resynchronization Possible */ 5118f8829a4aSRandall Stewart if (compare_with_wrap(asoc->last_acked_seq, asoc->nonce_resync_tsn, MAX_TSN)) { 5119f8829a4aSRandall Stewart asoc->nonce_sum_check = 1; 5120f8829a4aSRandall Stewart /* 5121f8829a4aSRandall Stewart * now we must calculate what the base is. 5122f8829a4aSRandall Stewart * We do this based on two things, we know 5123f8829a4aSRandall Stewart * the total's for all the segments 5124f8829a4aSRandall Stewart * gap-acked in the SACK, its stored in 5125f8829a4aSRandall Stewart * ecn_seg_sums. We also know the SACK's 5126f8829a4aSRandall Stewart * nonce sum, its in nonce_sum_flag. So we 5127f8829a4aSRandall Stewart * can build a truth table to back-calculate 5128f8829a4aSRandall Stewart * the new value of 5129f8829a4aSRandall Stewart * asoc->nonce_sum_expect_base: 5130f8829a4aSRandall Stewart * 5131f8829a4aSRandall Stewart * SACK-flag-Value Seg-Sums Base 0 0 0 5132f8829a4aSRandall Stewart * 1 0 1 0 1 1 1 5133f8829a4aSRandall Stewart * 1 0 5134f8829a4aSRandall Stewart */ 5135f8829a4aSRandall Stewart asoc->nonce_sum_expect_base = (ecn_seg_sums ^ nonce_sum_flag) & SCTP_SACK_NONCE_SUM; 5136f8829a4aSRandall Stewart } 5137f8829a4aSRandall Stewart } 5138f8829a4aSRandall Stewart } 5139f8829a4aSRandall Stewart /* Now are we exiting loss recovery ? */ 5140f8829a4aSRandall Stewart if (will_exit_fast_recovery) { 5141f8829a4aSRandall Stewart /* Ok, we must exit fast recovery */ 5142f8829a4aSRandall Stewart asoc->fast_retran_loss_recovery = 0; 5143f8829a4aSRandall Stewart } 5144f8829a4aSRandall Stewart if ((asoc->sat_t3_loss_recovery) && 5145f8829a4aSRandall Stewart ((compare_with_wrap(asoc->last_acked_seq, asoc->sat_t3_recovery_tsn, 5146f8829a4aSRandall Stewart MAX_TSN) || 5147f8829a4aSRandall Stewart (asoc->last_acked_seq == asoc->sat_t3_recovery_tsn)))) { 5148f8829a4aSRandall Stewart /* end satellite t3 loss recovery */ 5149f8829a4aSRandall Stewart asoc->sat_t3_loss_recovery = 0; 5150f8829a4aSRandall Stewart } 515142551e99SRandall Stewart /* 515242551e99SRandall Stewart * CMT Fast recovery 515342551e99SRandall Stewart */ 5154f8829a4aSRandall Stewart TAILQ_FOREACH(net, &asoc->nets, sctp_next) { 5155f8829a4aSRandall Stewart if (net->will_exit_fast_recovery) { 5156f8829a4aSRandall Stewart /* Ok, we must exit fast recovery */ 5157f8829a4aSRandall Stewart net->fast_retran_loss_recovery = 0; 5158f8829a4aSRandall Stewart } 5159f8829a4aSRandall Stewart } 5160f8829a4aSRandall Stewart 5161f8829a4aSRandall Stewart /* Adjust and set the new rwnd value */ 5162b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_LOG_RWND_ENABLE) { 5163f8829a4aSRandall Stewart sctp_log_rwnd_set(SCTP_SET_PEER_RWND_VIA_SACK, 516444fbe462SRandall Stewart asoc->peers_rwnd, asoc->total_flight, (asoc->total_flight_count * SCTP_BASE_SYSCTL(sctp_peer_chunk_oh)), a_rwnd); 516580fefe0aSRandall Stewart } 5166f8829a4aSRandall Stewart asoc->peers_rwnd = sctp_sbspace_sub(a_rwnd, 516744fbe462SRandall Stewart (uint32_t) (asoc->total_flight + (asoc->total_flight_count * SCTP_BASE_SYSCTL(sctp_peer_chunk_oh)))); 5168f8829a4aSRandall Stewart if (asoc->peers_rwnd < stcb->sctp_ep->sctp_ep.sctp_sws_sender) { 5169f8829a4aSRandall Stewart /* SWS sender side engages */ 5170f8829a4aSRandall Stewart asoc->peers_rwnd = 0; 5171f8829a4aSRandall Stewart } 51725e54f665SRandall Stewart if (asoc->peers_rwnd > old_rwnd) { 51735e54f665SRandall Stewart win_probe_recovery = 1; 51745e54f665SRandall Stewart } 5175f8829a4aSRandall Stewart /* 5176f8829a4aSRandall Stewart * Now we must setup so we have a timer up for anyone with 5177f8829a4aSRandall Stewart * outstanding data. 5178f8829a4aSRandall Stewart */ 5179bff64a4dSRandall Stewart done_once = 0; 5180a5d547adSRandall Stewart again: 5181a5d547adSRandall Stewart j = 0; 5182f8829a4aSRandall Stewart TAILQ_FOREACH(net, &asoc->nets, sctp_next) { 51835e54f665SRandall Stewart if (win_probe_recovery && (net->window_probe)) { 5184c105859eSRandall Stewart win_probe_recovered = 1; 51855e54f665SRandall Stewart /*- 51865e54f665SRandall Stewart * Find first chunk that was used with 51875e54f665SRandall Stewart * window probe and clear the event. Put 51885e54f665SRandall Stewart * it back into the send queue as if has 51895e54f665SRandall Stewart * not been sent. 51905e54f665SRandall Stewart */ 51915e54f665SRandall Stewart TAILQ_FOREACH(tp1, &asoc->sent_queue, sctp_next) { 51925e54f665SRandall Stewart if (tp1->window_probe) { 5193c105859eSRandall Stewart sctp_window_probe_recovery(stcb, asoc, net, tp1); 51945e54f665SRandall Stewart break; 51955e54f665SRandall Stewart } 51965e54f665SRandall Stewart } 51975e54f665SRandall Stewart } 5198f8829a4aSRandall Stewart if (net->flight_size) { 5199a5d547adSRandall Stewart j++; 5200cd554309SMichael Tuexen if (!SCTP_OS_TIMER_PENDING(&net->rxt_timer.timer)) { 5201f8829a4aSRandall Stewart sctp_timer_start(SCTP_TIMER_TYPE_SEND, 5202f8829a4aSRandall Stewart stcb->sctp_ep, stcb, net); 5203cd554309SMichael Tuexen } 52045171328bSRandall Stewart if (net->window_probe) { 5205cd554309SMichael Tuexen net->window_probe = 0; 52065171328bSRandall Stewart } 5207c105859eSRandall Stewart } else { 52085171328bSRandall Stewart if (net->window_probe) { 52095171328bSRandall Stewart /* 52105171328bSRandall Stewart * In window probes we must assure a timer 52115171328bSRandall Stewart * is still running there 52125171328bSRandall Stewart */ 52135171328bSRandall Stewart if (!SCTP_OS_TIMER_PENDING(&net->rxt_timer.timer)) { 52145171328bSRandall Stewart sctp_timer_start(SCTP_TIMER_TYPE_SEND, 52155171328bSRandall Stewart stcb->sctp_ep, stcb, net); 52165171328bSRandall Stewart 52175171328bSRandall Stewart } 52185171328bSRandall Stewart } else if (SCTP_OS_TIMER_PENDING(&net->rxt_timer.timer)) { 5219c105859eSRandall Stewart sctp_timer_stop(SCTP_TIMER_TYPE_SEND, stcb->sctp_ep, 5220c105859eSRandall Stewart stcb, net, 5221c105859eSRandall Stewart SCTP_FROM_SCTP_INDATA + SCTP_LOC_22); 5222c105859eSRandall Stewart } 5223b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_early_fr)) { 5224c105859eSRandall Stewart if (SCTP_OS_TIMER_PENDING(&net->fr_timer.timer)) { 5225c105859eSRandall Stewart SCTP_STAT_INCR(sctps_earlyfrstpidsck4); 5226c105859eSRandall Stewart sctp_timer_stop(SCTP_TIMER_TYPE_EARLYFR, stcb->sctp_ep, stcb, net, 5227c105859eSRandall Stewart SCTP_FROM_SCTP_INDATA + SCTP_LOC_23); 5228c105859eSRandall Stewart } 5229c105859eSRandall Stewart } 5230f8829a4aSRandall Stewart } 5231f8829a4aSRandall Stewart } 5232bff64a4dSRandall Stewart if ((j == 0) && 5233bff64a4dSRandall Stewart (!TAILQ_EMPTY(&asoc->sent_queue)) && 5234bff64a4dSRandall Stewart (asoc->sent_queue_retran_cnt == 0) && 5235c105859eSRandall Stewart (win_probe_recovered == 0) && 5236bff64a4dSRandall Stewart (done_once == 0)) { 52370c0982b8SRandall Stewart /* 52380c0982b8SRandall Stewart * huh, this should not happen unless all packets are 52390c0982b8SRandall Stewart * PR-SCTP and marked to skip of course. 52400c0982b8SRandall Stewart */ 52410c0982b8SRandall Stewart if (sctp_fs_audit(asoc)) { 5242a5d547adSRandall Stewart TAILQ_FOREACH(net, &asoc->nets, sctp_next) { 5243a5d547adSRandall Stewart net->flight_size = 0; 5244a5d547adSRandall Stewart } 5245a5d547adSRandall Stewart asoc->total_flight = 0; 5246a5d547adSRandall Stewart asoc->total_flight_count = 0; 5247a5d547adSRandall Stewart asoc->sent_queue_retran_cnt = 0; 5248a5d547adSRandall Stewart TAILQ_FOREACH(tp1, &asoc->sent_queue, sctp_next) { 5249a5d547adSRandall Stewart if (tp1->sent < SCTP_DATAGRAM_RESEND) { 5250c105859eSRandall Stewart sctp_flight_size_increase(tp1); 5251c105859eSRandall Stewart sctp_total_flight_increase(stcb, tp1); 5252a5d547adSRandall Stewart } else if (tp1->sent == SCTP_DATAGRAM_RESEND) { 5253791437b5SRandall Stewart sctp_ucount_incr(asoc->sent_queue_retran_cnt); 5254a5d547adSRandall Stewart } 5255a5d547adSRandall Stewart } 52560c0982b8SRandall Stewart } 5257bff64a4dSRandall Stewart done_once = 1; 5258a5d547adSRandall Stewart goto again; 5259a5d547adSRandall Stewart } 5260cd554309SMichael Tuexen /*********************************************/ 5261cd554309SMichael Tuexen /* Here we perform PR-SCTP procedures */ 5262cd554309SMichael Tuexen /* (section 4.2) */ 5263cd554309SMichael Tuexen /*********************************************/ 5264cd554309SMichael Tuexen /* C1. update advancedPeerAckPoint */ 5265dfb11ef8SRandall Stewart if (compare_with_wrap(cum_ack, asoc->advanced_peer_ack_point, MAX_TSN)) { 5266dfb11ef8SRandall Stewart asoc->advanced_peer_ack_point = cum_ack; 5267dfb11ef8SRandall Stewart } 5268830d754dSRandall Stewart /* C2. try to further move advancedPeerAckPoint ahead */ 5269830d754dSRandall Stewart if ((asoc->peer_supports_prsctp) && (asoc->pr_sctp_cnt > 0)) { 5270830d754dSRandall Stewart struct sctp_tmit_chunk *lchk; 5271830d754dSRandall Stewart uint32_t old_adv_peer_ack_point; 5272830d754dSRandall Stewart 5273830d754dSRandall Stewart old_adv_peer_ack_point = asoc->advanced_peer_ack_point; 5274830d754dSRandall Stewart lchk = sctp_try_advance_peer_ack_point(stcb, asoc); 5275830d754dSRandall Stewart /* C3. See if we need to send a Fwd-TSN */ 5276830d754dSRandall Stewart if (compare_with_wrap(asoc->advanced_peer_ack_point, cum_ack, 5277830d754dSRandall Stewart MAX_TSN)) { 5278830d754dSRandall Stewart /* 5279830d754dSRandall Stewart * ISSUE with ECN, see FWD-TSN processing for notes 5280830d754dSRandall Stewart * on issues that will occur when the ECN NONCE 5281830d754dSRandall Stewart * stuff is put into SCTP for cross checking. 5282830d754dSRandall Stewart */ 52830c0982b8SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_LOG_TRY_ADVANCE) { 52840c0982b8SRandall Stewart sctp_misc_ints(SCTP_FWD_TSN_CHECK, 52850c0982b8SRandall Stewart 0xee, cum_ack, asoc->advanced_peer_ack_point, 52860c0982b8SRandall Stewart old_adv_peer_ack_point); 52870c0982b8SRandall Stewart } 5288830d754dSRandall Stewart if (compare_with_wrap(asoc->advanced_peer_ack_point, old_adv_peer_ack_point, 5289830d754dSRandall Stewart MAX_TSN)) { 529044fbe462SRandall Stewart 5291830d754dSRandall Stewart send_forward_tsn(stcb, asoc); 5292830d754dSRandall Stewart /* 5293830d754dSRandall Stewart * ECN Nonce: Disable Nonce Sum check when 5294830d754dSRandall Stewart * FWD TSN is sent and store resync tsn 5295830d754dSRandall Stewart */ 5296830d754dSRandall Stewart asoc->nonce_sum_check = 0; 5297830d754dSRandall Stewart asoc->nonce_resync_tsn = asoc->advanced_peer_ack_point; 52980c0982b8SRandall Stewart } else if (lchk) { 52990c0982b8SRandall Stewart /* try to FR fwd-tsn's that get lost too */ 530044fbe462SRandall Stewart if (lchk->rec.data.fwd_tsn_cnt >= 3) { 53010c0982b8SRandall Stewart send_forward_tsn(stcb, asoc); 53020c0982b8SRandall Stewart } 5303830d754dSRandall Stewart } 5304830d754dSRandall Stewart } 5305830d754dSRandall Stewart if (lchk) { 5306830d754dSRandall Stewart /* Assure a timer is up */ 5307830d754dSRandall Stewart sctp_timer_start(SCTP_TIMER_TYPE_SEND, 5308830d754dSRandall Stewart stcb->sctp_ep, stcb, lchk->whoTo); 5309830d754dSRandall Stewart } 5310830d754dSRandall Stewart } 5311b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_SACK_RWND_LOGGING_ENABLE) { 5312f8829a4aSRandall Stewart sctp_misc_ints(SCTP_SACK_RWND_UPDATE, 5313f8829a4aSRandall Stewart a_rwnd, 5314f8829a4aSRandall Stewart stcb->asoc.peers_rwnd, 5315f8829a4aSRandall Stewart stcb->asoc.total_flight, 5316f8829a4aSRandall Stewart stcb->asoc.total_output_queue_size); 531780fefe0aSRandall Stewart } 5318f8829a4aSRandall Stewart } 5319f8829a4aSRandall Stewart 5320f8829a4aSRandall Stewart void 5321f8829a4aSRandall Stewart sctp_update_acked(struct sctp_tcb *stcb, struct sctp_shutdown_chunk *cp, 5322f8829a4aSRandall Stewart struct sctp_nets *netp, int *abort_flag) 5323f8829a4aSRandall Stewart { 5324f8829a4aSRandall Stewart /* Copy cum-ack */ 5325f8829a4aSRandall Stewart uint32_t cum_ack, a_rwnd; 5326f8829a4aSRandall Stewart 5327f8829a4aSRandall Stewart cum_ack = ntohl(cp->cumulative_tsn_ack); 5328f8829a4aSRandall Stewart /* Arrange so a_rwnd does NOT change */ 5329f8829a4aSRandall Stewart a_rwnd = stcb->asoc.peers_rwnd + stcb->asoc.total_flight; 5330f8829a4aSRandall Stewart 5331f8829a4aSRandall Stewart /* Now call the express sack handling */ 5332f8829a4aSRandall Stewart sctp_express_handle_sack(stcb, cum_ack, a_rwnd, 0, abort_flag); 5333f8829a4aSRandall Stewart } 5334f8829a4aSRandall Stewart 5335f8829a4aSRandall Stewart static void 5336f8829a4aSRandall Stewart sctp_kick_prsctp_reorder_queue(struct sctp_tcb *stcb, 5337f8829a4aSRandall Stewart struct sctp_stream_in *strmin) 5338f8829a4aSRandall Stewart { 5339f8829a4aSRandall Stewart struct sctp_queued_to_read *ctl, *nctl; 5340f8829a4aSRandall Stewart struct sctp_association *asoc; 534183128708SRandall Stewart uint16_t tt; 5342f8829a4aSRandall Stewart 5343f8829a4aSRandall Stewart asoc = &stcb->asoc; 5344f8829a4aSRandall Stewart tt = strmin->last_sequence_delivered; 5345f8829a4aSRandall Stewart /* 5346f8829a4aSRandall Stewart * First deliver anything prior to and including the stream no that 5347f8829a4aSRandall Stewart * came in 5348f8829a4aSRandall Stewart */ 5349f8829a4aSRandall Stewart ctl = TAILQ_FIRST(&strmin->inqueue); 5350f8829a4aSRandall Stewart while (ctl) { 5351f8829a4aSRandall Stewart nctl = TAILQ_NEXT(ctl, next); 5352f8829a4aSRandall Stewart if (compare_with_wrap(tt, ctl->sinfo_ssn, MAX_SEQ) || 5353f8829a4aSRandall Stewart (tt == ctl->sinfo_ssn)) { 5354f8829a4aSRandall Stewart /* this is deliverable now */ 5355f8829a4aSRandall Stewart TAILQ_REMOVE(&strmin->inqueue, ctl, next); 5356f8829a4aSRandall Stewart /* subtract pending on streams */ 5357f8829a4aSRandall Stewart asoc->size_on_all_streams -= ctl->length; 5358f8829a4aSRandall Stewart sctp_ucount_decr(asoc->cnt_on_all_streams); 5359f8829a4aSRandall Stewart /* deliver it to at least the delivery-q */ 5360f8829a4aSRandall Stewart if (stcb->sctp_socket) { 5361b5c16493SMichael Tuexen sctp_mark_non_revokable(asoc, ctl->sinfo_tsn); 5362f8829a4aSRandall Stewart sctp_add_to_readq(stcb->sctp_ep, stcb, 5363f8829a4aSRandall Stewart ctl, 5364cfde3ff7SRandall Stewart &stcb->sctp_socket->so_rcv, 1, SCTP_READ_LOCK_HELD, SCTP_SO_NOT_LOCKED); 5365f8829a4aSRandall Stewart } 5366f8829a4aSRandall Stewart } else { 5367f8829a4aSRandall Stewart /* no more delivery now. */ 5368f8829a4aSRandall Stewart break; 5369f8829a4aSRandall Stewart } 5370f8829a4aSRandall Stewart ctl = nctl; 5371f8829a4aSRandall Stewart } 5372f8829a4aSRandall Stewart /* 5373f8829a4aSRandall Stewart * now we must deliver things in queue the normal way if any are 5374f8829a4aSRandall Stewart * now ready. 5375f8829a4aSRandall Stewart */ 5376f8829a4aSRandall Stewart tt = strmin->last_sequence_delivered + 1; 5377f8829a4aSRandall Stewart ctl = TAILQ_FIRST(&strmin->inqueue); 5378f8829a4aSRandall Stewart while (ctl) { 5379f8829a4aSRandall Stewart nctl = TAILQ_NEXT(ctl, next); 5380f8829a4aSRandall Stewart if (tt == ctl->sinfo_ssn) { 5381f8829a4aSRandall Stewart /* this is deliverable now */ 5382f8829a4aSRandall Stewart TAILQ_REMOVE(&strmin->inqueue, ctl, next); 5383f8829a4aSRandall Stewart /* subtract pending on streams */ 5384f8829a4aSRandall Stewart asoc->size_on_all_streams -= ctl->length; 5385f8829a4aSRandall Stewart sctp_ucount_decr(asoc->cnt_on_all_streams); 5386f8829a4aSRandall Stewart /* deliver it to at least the delivery-q */ 5387f8829a4aSRandall Stewart strmin->last_sequence_delivered = ctl->sinfo_ssn; 5388f8829a4aSRandall Stewart if (stcb->sctp_socket) { 5389b5c16493SMichael Tuexen sctp_mark_non_revokable(asoc, ctl->sinfo_tsn); 5390f8829a4aSRandall Stewart sctp_add_to_readq(stcb->sctp_ep, stcb, 5391f8829a4aSRandall Stewart ctl, 5392cfde3ff7SRandall Stewart &stcb->sctp_socket->so_rcv, 1, SCTP_READ_LOCK_HELD, SCTP_SO_NOT_LOCKED); 539377acdc25SRandall Stewart 5394f8829a4aSRandall Stewart } 5395f8829a4aSRandall Stewart tt = strmin->last_sequence_delivered + 1; 5396f8829a4aSRandall Stewart } else { 5397f8829a4aSRandall Stewart break; 5398f8829a4aSRandall Stewart } 5399f8829a4aSRandall Stewart ctl = nctl; 5400f8829a4aSRandall Stewart } 5401f8829a4aSRandall Stewart } 5402f8829a4aSRandall Stewart 54038933fa13SRandall Stewart static void 54048933fa13SRandall Stewart sctp_flush_reassm_for_str_seq(struct sctp_tcb *stcb, 54058933fa13SRandall Stewart struct sctp_association *asoc, 54068933fa13SRandall Stewart uint16_t stream, uint16_t seq) 54078933fa13SRandall Stewart { 54088933fa13SRandall Stewart struct sctp_tmit_chunk *chk, *at; 54098933fa13SRandall Stewart 54108933fa13SRandall Stewart if (!TAILQ_EMPTY(&asoc->reasmqueue)) { 54118933fa13SRandall Stewart /* For each one on here see if we need to toss it */ 54128933fa13SRandall Stewart /* 54138933fa13SRandall Stewart * For now large messages held on the reasmqueue that are 54148933fa13SRandall Stewart * complete will be tossed too. We could in theory do more 54158933fa13SRandall Stewart * work to spin through and stop after dumping one msg aka 54168933fa13SRandall Stewart * seeing the start of a new msg at the head, and call the 54178933fa13SRandall Stewart * delivery function... to see if it can be delivered... But 54188933fa13SRandall Stewart * for now we just dump everything on the queue. 54198933fa13SRandall Stewart */ 54208933fa13SRandall Stewart chk = TAILQ_FIRST(&asoc->reasmqueue); 54218933fa13SRandall Stewart while (chk) { 54228933fa13SRandall Stewart at = TAILQ_NEXT(chk, sctp_next); 54238e71b694SMichael Tuexen /* 54248e71b694SMichael Tuexen * Do not toss it if on a different stream or marked 54258e71b694SMichael Tuexen * for unordered delivery in which case the stream 54268e71b694SMichael Tuexen * sequence number has no meaning. 54278e71b694SMichael Tuexen */ 54288e71b694SMichael Tuexen if ((chk->rec.data.stream_number != stream) || 54298e71b694SMichael Tuexen ((chk->rec.data.rcv_flags & SCTP_DATA_UNORDERED) == SCTP_DATA_UNORDERED)) { 54308933fa13SRandall Stewart chk = at; 54318933fa13SRandall Stewart continue; 54328933fa13SRandall Stewart } 54338933fa13SRandall Stewart if (chk->rec.data.stream_seq == seq) { 54348933fa13SRandall Stewart /* It needs to be tossed */ 54358933fa13SRandall Stewart TAILQ_REMOVE(&asoc->reasmqueue, chk, sctp_next); 54368933fa13SRandall Stewart if (compare_with_wrap(chk->rec.data.TSN_seq, 54378933fa13SRandall Stewart asoc->tsn_last_delivered, MAX_TSN)) { 54388933fa13SRandall Stewart asoc->tsn_last_delivered = 54398933fa13SRandall Stewart chk->rec.data.TSN_seq; 54408933fa13SRandall Stewart asoc->str_of_pdapi = 54418933fa13SRandall Stewart chk->rec.data.stream_number; 54428933fa13SRandall Stewart asoc->ssn_of_pdapi = 54438933fa13SRandall Stewart chk->rec.data.stream_seq; 54448933fa13SRandall Stewart asoc->fragment_flags = 54458933fa13SRandall Stewart chk->rec.data.rcv_flags; 54468933fa13SRandall Stewart } 54478933fa13SRandall Stewart asoc->size_on_reasm_queue -= chk->send_size; 54488933fa13SRandall Stewart sctp_ucount_decr(asoc->cnt_on_reasm_queue); 54498933fa13SRandall Stewart 54508933fa13SRandall Stewart /* Clear up any stream problem */ 54518933fa13SRandall Stewart if ((chk->rec.data.rcv_flags & SCTP_DATA_UNORDERED) != 54528933fa13SRandall Stewart SCTP_DATA_UNORDERED && 54538933fa13SRandall Stewart (compare_with_wrap(chk->rec.data.stream_seq, 54548933fa13SRandall Stewart asoc->strmin[chk->rec.data.stream_number].last_sequence_delivered, 54558933fa13SRandall Stewart MAX_SEQ))) { 54568933fa13SRandall Stewart /* 54578933fa13SRandall Stewart * We must dump forward this streams 54588933fa13SRandall Stewart * sequence number if the chunk is 54598933fa13SRandall Stewart * not unordered that is being 54608933fa13SRandall Stewart * skipped. There is a chance that 54618933fa13SRandall Stewart * if the peer does not include the 54628933fa13SRandall Stewart * last fragment in its FWD-TSN we 54638933fa13SRandall Stewart * WILL have a problem here since 54648933fa13SRandall Stewart * you would have a partial chunk in 54658933fa13SRandall Stewart * queue that may not be 54668933fa13SRandall Stewart * deliverable. Also if a Partial 54678933fa13SRandall Stewart * delivery API as started the user 54688933fa13SRandall Stewart * may get a partial chunk. The next 54698933fa13SRandall Stewart * read returning a new chunk... 54708933fa13SRandall Stewart * really ugly but I see no way 54718933fa13SRandall Stewart * around it! Maybe a notify?? 54728933fa13SRandall Stewart */ 54738933fa13SRandall Stewart asoc->strmin[chk->rec.data.stream_number].last_sequence_delivered = 54748933fa13SRandall Stewart chk->rec.data.stream_seq; 54758933fa13SRandall Stewart } 54768933fa13SRandall Stewart if (chk->data) { 54778933fa13SRandall Stewart sctp_m_freem(chk->data); 54788933fa13SRandall Stewart chk->data = NULL; 54798933fa13SRandall Stewart } 54808933fa13SRandall Stewart sctp_free_a_chunk(stcb, chk); 54818933fa13SRandall Stewart } else if (compare_with_wrap(chk->rec.data.stream_seq, seq, MAX_SEQ)) { 54828933fa13SRandall Stewart /* 54838933fa13SRandall Stewart * If the stream_seq is > than the purging 54848933fa13SRandall Stewart * one, we are done 54858933fa13SRandall Stewart */ 54868933fa13SRandall Stewart break; 54878933fa13SRandall Stewart } 54888933fa13SRandall Stewart chk = at; 54898933fa13SRandall Stewart } 54908933fa13SRandall Stewart } 54918933fa13SRandall Stewart } 54928933fa13SRandall Stewart 54938933fa13SRandall Stewart 5494f8829a4aSRandall Stewart void 5495f8829a4aSRandall Stewart sctp_handle_forward_tsn(struct sctp_tcb *stcb, 5496b5c16493SMichael Tuexen struct sctp_forward_tsn_chunk *fwd, 5497b5c16493SMichael Tuexen int *abort_flag, struct mbuf *m, int offset) 5498f8829a4aSRandall Stewart { 5499f8829a4aSRandall Stewart /* 5500f8829a4aSRandall Stewart * ISSUES that MUST be fixed for ECN! When we are the sender of the 5501f8829a4aSRandall Stewart * forward TSN, when the SACK comes back that acknowledges the 5502f8829a4aSRandall Stewart * FWD-TSN we must reset the NONCE sum to match correctly. This will 5503f8829a4aSRandall Stewart * get quite tricky since we may have sent more data interveneing 5504f8829a4aSRandall Stewart * and must carefully account for what the SACK says on the nonce 5505f8829a4aSRandall Stewart * and any gaps that are reported. This work will NOT be done here, 5506f8829a4aSRandall Stewart * but I note it here since it is really related to PR-SCTP and 5507f8829a4aSRandall Stewart * FWD-TSN's 5508f8829a4aSRandall Stewart */ 5509f8829a4aSRandall Stewart 5510f8829a4aSRandall Stewart /* The pr-sctp fwd tsn */ 5511f8829a4aSRandall Stewart /* 5512f8829a4aSRandall Stewart * here we will perform all the data receiver side steps for 5513f8829a4aSRandall Stewart * processing FwdTSN, as required in by pr-sctp draft: 5514f8829a4aSRandall Stewart * 5515f8829a4aSRandall Stewart * Assume we get FwdTSN(x): 5516f8829a4aSRandall Stewart * 5517f8829a4aSRandall Stewart * 1) update local cumTSN to x 2) try to further advance cumTSN to x + 5518f8829a4aSRandall Stewart * others we have 3) examine and update re-ordering queue on 5519f8829a4aSRandall Stewart * pr-in-streams 4) clean up re-assembly queue 5) Send a sack to 5520f8829a4aSRandall Stewart * report where we are. 5521f8829a4aSRandall Stewart */ 5522f8829a4aSRandall Stewart struct sctp_association *asoc; 55237898f408SRandall Stewart uint32_t new_cum_tsn, gap; 55247898f408SRandall Stewart unsigned int i, fwd_sz, cumack_set_flag, m_size; 55258933fa13SRandall Stewart uint32_t str_seq; 5526f8829a4aSRandall Stewart struct sctp_stream_in *strm; 5527f8829a4aSRandall Stewart struct sctp_tmit_chunk *chk, *at; 55288933fa13SRandall Stewart struct sctp_queued_to_read *ctl, *sv; 5529f8829a4aSRandall Stewart 5530f8829a4aSRandall Stewart cumack_set_flag = 0; 5531f8829a4aSRandall Stewart asoc = &stcb->asoc; 5532f8829a4aSRandall Stewart if ((fwd_sz = ntohs(fwd->ch.chunk_length)) < sizeof(struct sctp_forward_tsn_chunk)) { 5533ad81507eSRandall Stewart SCTPDBG(SCTP_DEBUG_INDATA1, 5534ad81507eSRandall Stewart "Bad size too small/big fwd-tsn\n"); 5535f8829a4aSRandall Stewart return; 5536f8829a4aSRandall Stewart } 5537f8829a4aSRandall Stewart m_size = (stcb->asoc.mapping_array_size << 3); 5538f8829a4aSRandall Stewart /*************************************************************/ 5539f8829a4aSRandall Stewart /* 1. Here we update local cumTSN and shift the bitmap array */ 5540f8829a4aSRandall Stewart /*************************************************************/ 5541f8829a4aSRandall Stewart new_cum_tsn = ntohl(fwd->new_cumulative_tsn); 5542f8829a4aSRandall Stewart 5543f8829a4aSRandall Stewart if (compare_with_wrap(asoc->cumulative_tsn, new_cum_tsn, MAX_TSN) || 5544f8829a4aSRandall Stewart asoc->cumulative_tsn == new_cum_tsn) { 5545f8829a4aSRandall Stewart /* Already got there ... */ 5546f8829a4aSRandall Stewart return; 5547f8829a4aSRandall Stewart } 5548f8829a4aSRandall Stewart /* 5549f8829a4aSRandall Stewart * now we know the new TSN is more advanced, let's find the actual 5550f8829a4aSRandall Stewart * gap 5551f8829a4aSRandall Stewart */ 5552b5c16493SMichael Tuexen SCTP_CALC_TSN_TO_GAP(gap, new_cum_tsn, asoc->mapping_array_base_tsn); 555377acdc25SRandall Stewart asoc->cumulative_tsn = new_cum_tsn; 55542afb3e84SRandall Stewart if (gap >= m_size) { 5555f8829a4aSRandall Stewart if ((long)gap > sctp_sbspace(&stcb->asoc, &stcb->sctp_socket->so_rcv)) { 555617205eccSRandall Stewart struct mbuf *oper; 555717205eccSRandall Stewart 5558f8829a4aSRandall Stewart /* 5559f8829a4aSRandall Stewart * out of range (of single byte chunks in the rwnd I 556017205eccSRandall Stewart * give out). This must be an attacker. 5561f8829a4aSRandall Stewart */ 556217205eccSRandall Stewart *abort_flag = 1; 556317205eccSRandall Stewart oper = sctp_get_mbuf_for_msg((sizeof(struct sctp_paramhdr) + 3 * sizeof(uint32_t)), 556417205eccSRandall Stewart 0, M_DONTWAIT, 1, MT_DATA); 556517205eccSRandall Stewart if (oper) { 556617205eccSRandall Stewart struct sctp_paramhdr *ph; 556717205eccSRandall Stewart uint32_t *ippp; 556817205eccSRandall Stewart 556917205eccSRandall Stewart SCTP_BUF_LEN(oper) = sizeof(struct sctp_paramhdr) + 557017205eccSRandall Stewart (sizeof(uint32_t) * 3); 557117205eccSRandall Stewart ph = mtod(oper, struct sctp_paramhdr *); 557217205eccSRandall Stewart ph->param_type = htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 557317205eccSRandall Stewart ph->param_length = htons(SCTP_BUF_LEN(oper)); 557417205eccSRandall Stewart ippp = (uint32_t *) (ph + 1); 557517205eccSRandall Stewart *ippp = htonl(SCTP_FROM_SCTP_INDATA + SCTP_LOC_33); 557617205eccSRandall Stewart ippp++; 557717205eccSRandall Stewart *ippp = asoc->highest_tsn_inside_map; 557817205eccSRandall Stewart ippp++; 557917205eccSRandall Stewart *ippp = new_cum_tsn; 558017205eccSRandall Stewart } 558117205eccSRandall Stewart stcb->sctp_ep->last_abort_code = SCTP_FROM_SCTP_INDATA + SCTP_LOC_33; 558217205eccSRandall Stewart sctp_abort_an_association(stcb->sctp_ep, stcb, 5583ceaad40aSRandall Stewart SCTP_PEER_FAULTY, oper, SCTP_SO_NOT_LOCKED); 5584f8829a4aSRandall Stewart return; 5585f8829a4aSRandall Stewart } 5586207304d4SRandall Stewart SCTP_STAT_INCR(sctps_fwdtsn_map_over); 558777acdc25SRandall Stewart 55882afb3e84SRandall Stewart memset(stcb->asoc.mapping_array, 0, stcb->asoc.mapping_array_size); 55892afb3e84SRandall Stewart asoc->mapping_array_base_tsn = new_cum_tsn + 1; 559077acdc25SRandall Stewart asoc->highest_tsn_inside_map = new_cum_tsn; 559177acdc25SRandall Stewart 5592b5c16493SMichael Tuexen memset(stcb->asoc.nr_mapping_array, 0, stcb->asoc.mapping_array_size); 5593830d754dSRandall Stewart asoc->highest_tsn_inside_nr_map = new_cum_tsn; 559477acdc25SRandall Stewart 5595b3f1ea41SRandall Stewart if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_MAP_LOGGING_ENABLE) { 5596f8829a4aSRandall Stewart sctp_log_map(0, 3, asoc->highest_tsn_inside_map, SCTP_MAP_SLIDE_RESULT); 559780fefe0aSRandall Stewart } 5598f8829a4aSRandall Stewart asoc->last_echo_tsn = asoc->highest_tsn_inside_map; 55992afb3e84SRandall Stewart } else { 56002afb3e84SRandall Stewart SCTP_TCB_LOCK_ASSERT(stcb); 56012afb3e84SRandall Stewart for (i = 0; i <= gap; i++) { 56027898f408SRandall Stewart if (!SCTP_IS_TSN_PRESENT(asoc->mapping_array, i) && 56037898f408SRandall Stewart !SCTP_IS_TSN_PRESENT(asoc->nr_mapping_array, i)) { 56048933fa13SRandall Stewart SCTP_SET_TSN_PRESENT(asoc->nr_mapping_array, i); 56057898f408SRandall Stewart if (compare_with_wrap(asoc->mapping_array_base_tsn + i, asoc->highest_tsn_inside_nr_map, MAX_TSN)) { 56067898f408SRandall Stewart asoc->highest_tsn_inside_nr_map = asoc->mapping_array_base_tsn + i; 5607b5c16493SMichael Tuexen } 5608b5c16493SMichael Tuexen } 5609b5c16493SMichael Tuexen } 5610f8829a4aSRandall Stewart } 5611f8829a4aSRandall Stewart /*************************************************************/ 5612f8829a4aSRandall Stewart /* 2. Clear up re-assembly queue */ 5613f8829a4aSRandall Stewart /*************************************************************/ 5614f8829a4aSRandall Stewart /* 5615f8829a4aSRandall Stewart * First service it if pd-api is up, just in case we can progress it 5616f8829a4aSRandall Stewart * forward 5617f8829a4aSRandall Stewart */ 5618f8829a4aSRandall Stewart if (asoc->fragmented_delivery_inprogress) { 5619f8829a4aSRandall Stewart sctp_service_reassembly(stcb, asoc); 5620f8829a4aSRandall Stewart } 5621f8829a4aSRandall Stewart if (!TAILQ_EMPTY(&asoc->reasmqueue)) { 5622f8829a4aSRandall Stewart /* For each one on here see if we need to toss it */ 5623f8829a4aSRandall Stewart /* 5624f8829a4aSRandall Stewart * For now large messages held on the reasmqueue that are 5625f8829a4aSRandall Stewart * complete will be tossed too. We could in theory do more 5626f8829a4aSRandall Stewart * work to spin through and stop after dumping one msg aka 5627f8829a4aSRandall Stewart * seeing the start of a new msg at the head, and call the 5628f8829a4aSRandall Stewart * delivery function... to see if it can be delivered... But 5629f8829a4aSRandall Stewart * for now we just dump everything on the queue. 5630f8829a4aSRandall Stewart */ 5631f8829a4aSRandall Stewart chk = TAILQ_FIRST(&asoc->reasmqueue); 5632f8829a4aSRandall Stewart while (chk) { 5633f8829a4aSRandall Stewart at = TAILQ_NEXT(chk, sctp_next); 56340c0982b8SRandall Stewart if ((compare_with_wrap(new_cum_tsn, 56350c0982b8SRandall Stewart chk->rec.data.TSN_seq, MAX_TSN)) || 56360c0982b8SRandall Stewart (new_cum_tsn == chk->rec.data.TSN_seq)) { 5637f8829a4aSRandall Stewart /* It needs to be tossed */ 5638f8829a4aSRandall Stewart TAILQ_REMOVE(&asoc->reasmqueue, chk, sctp_next); 5639f8829a4aSRandall Stewart if (compare_with_wrap(chk->rec.data.TSN_seq, 5640f8829a4aSRandall Stewart asoc->tsn_last_delivered, MAX_TSN)) { 5641f8829a4aSRandall Stewart asoc->tsn_last_delivered = 5642f8829a4aSRandall Stewart chk->rec.data.TSN_seq; 5643f8829a4aSRandall Stewart asoc->str_of_pdapi = 5644f8829a4aSRandall Stewart chk->rec.data.stream_number; 5645f8829a4aSRandall Stewart asoc->ssn_of_pdapi = 5646f8829a4aSRandall Stewart chk->rec.data.stream_seq; 5647f8829a4aSRandall Stewart asoc->fragment_flags = 5648f8829a4aSRandall Stewart chk->rec.data.rcv_flags; 5649f8829a4aSRandall Stewart } 5650f8829a4aSRandall Stewart asoc->size_on_reasm_queue -= chk->send_size; 5651f8829a4aSRandall Stewart sctp_ucount_decr(asoc->cnt_on_reasm_queue); 5652f8829a4aSRandall Stewart 5653f8829a4aSRandall Stewart /* Clear up any stream problem */ 5654f8829a4aSRandall Stewart if ((chk->rec.data.rcv_flags & SCTP_DATA_UNORDERED) != 5655f8829a4aSRandall Stewart SCTP_DATA_UNORDERED && 5656f8829a4aSRandall Stewart (compare_with_wrap(chk->rec.data.stream_seq, 5657f8829a4aSRandall Stewart asoc->strmin[chk->rec.data.stream_number].last_sequence_delivered, 5658f8829a4aSRandall Stewart MAX_SEQ))) { 5659f8829a4aSRandall Stewart /* 5660f8829a4aSRandall Stewart * We must dump forward this streams 5661f8829a4aSRandall Stewart * sequence number if the chunk is 5662f8829a4aSRandall Stewart * not unordered that is being 5663f8829a4aSRandall Stewart * skipped. There is a chance that 5664f8829a4aSRandall Stewart * if the peer does not include the 5665f8829a4aSRandall Stewart * last fragment in its FWD-TSN we 5666f8829a4aSRandall Stewart * WILL have a problem here since 5667f8829a4aSRandall Stewart * you would have a partial chunk in 5668f8829a4aSRandall Stewart * queue that may not be 5669f8829a4aSRandall Stewart * deliverable. Also if a Partial 5670f8829a4aSRandall Stewart * delivery API as started the user 5671f8829a4aSRandall Stewart * may get a partial chunk. The next 5672f8829a4aSRandall Stewart * read returning a new chunk... 5673f8829a4aSRandall Stewart * really ugly but I see no way 5674f8829a4aSRandall Stewart * around it! Maybe a notify?? 5675f8829a4aSRandall Stewart */ 5676f8829a4aSRandall Stewart asoc->strmin[chk->rec.data.stream_number].last_sequence_delivered = 5677f8829a4aSRandall Stewart chk->rec.data.stream_seq; 5678f8829a4aSRandall Stewart } 5679f8829a4aSRandall Stewart if (chk->data) { 5680f8829a4aSRandall Stewart sctp_m_freem(chk->data); 5681f8829a4aSRandall Stewart chk->data = NULL; 5682f8829a4aSRandall Stewart } 5683f8829a4aSRandall Stewart sctp_free_a_chunk(stcb, chk); 5684f8829a4aSRandall Stewart } else { 5685f8829a4aSRandall Stewart /* 5686f8829a4aSRandall Stewart * Ok we have gone beyond the end of the 56878933fa13SRandall Stewart * fwd-tsn's mark. 5688f8829a4aSRandall Stewart */ 5689f8829a4aSRandall Stewart break; 5690f8829a4aSRandall Stewart } 5691f8829a4aSRandall Stewart chk = at; 5692f8829a4aSRandall Stewart } 5693f8829a4aSRandall Stewart } 56948933fa13SRandall Stewart /*******************************************************/ 56958933fa13SRandall Stewart /* 3. Update the PR-stream re-ordering queues and fix */ 56968933fa13SRandall Stewart /* delivery issues as needed. */ 56978933fa13SRandall Stewart /*******************************************************/ 5698f8829a4aSRandall Stewart fwd_sz -= sizeof(*fwd); 5699671d309cSRandall Stewart if (m && fwd_sz) { 5700f8829a4aSRandall Stewart /* New method. */ 5701d61a0ae0SRandall Stewart unsigned int num_str; 5702671d309cSRandall Stewart struct sctp_strseq *stseq, strseqbuf; 5703671d309cSRandall Stewart 5704671d309cSRandall Stewart offset += sizeof(*fwd); 5705f8829a4aSRandall Stewart 57068933fa13SRandall Stewart SCTP_INP_READ_LOCK(stcb->sctp_ep); 5707f8829a4aSRandall Stewart num_str = fwd_sz / sizeof(struct sctp_strseq); 5708f8829a4aSRandall Stewart for (i = 0; i < num_str; i++) { 5709f8829a4aSRandall Stewart uint16_t st; 5710f8829a4aSRandall Stewart 5711671d309cSRandall Stewart stseq = (struct sctp_strseq *)sctp_m_getptr(m, offset, 5712671d309cSRandall Stewart sizeof(struct sctp_strseq), 5713671d309cSRandall Stewart (uint8_t *) & strseqbuf); 5714671d309cSRandall Stewart offset += sizeof(struct sctp_strseq); 57152afb3e84SRandall Stewart if (stseq == NULL) { 5716671d309cSRandall Stewart break; 57172afb3e84SRandall Stewart } 5718f8829a4aSRandall Stewart /* Convert */ 5719851b7298SRandall Stewart st = ntohs(stseq->stream); 5720851b7298SRandall Stewart stseq->stream = st; 5721851b7298SRandall Stewart st = ntohs(stseq->sequence); 5722851b7298SRandall Stewart stseq->sequence = st; 57238933fa13SRandall Stewart 5724f8829a4aSRandall Stewart /* now process */ 57258933fa13SRandall Stewart 57268933fa13SRandall Stewart /* 57278933fa13SRandall Stewart * Ok we now look for the stream/seq on the read 57288933fa13SRandall Stewart * queue where its not all delivered. If we find it 57298933fa13SRandall Stewart * we transmute the read entry into a PDI_ABORTED. 57308933fa13SRandall Stewart */ 5731851b7298SRandall Stewart if (stseq->stream >= asoc->streamincnt) { 57322afb3e84SRandall Stewart /* screwed up streams, stop! */ 57332afb3e84SRandall Stewart break; 5734f8829a4aSRandall Stewart } 57358933fa13SRandall Stewart if ((asoc->str_of_pdapi == stseq->stream) && 57368933fa13SRandall Stewart (asoc->ssn_of_pdapi == stseq->sequence)) { 57378933fa13SRandall Stewart /* 57388933fa13SRandall Stewart * If this is the one we were partially 57398933fa13SRandall Stewart * delivering now then we no longer are. 57408933fa13SRandall Stewart * Note this will change with the reassembly 57418933fa13SRandall Stewart * re-write. 57428933fa13SRandall Stewart */ 57438933fa13SRandall Stewart asoc->fragmented_delivery_inprogress = 0; 57448933fa13SRandall Stewart } 57458933fa13SRandall Stewart sctp_flush_reassm_for_str_seq(stcb, asoc, stseq->stream, stseq->sequence); 57468933fa13SRandall Stewart TAILQ_FOREACH(ctl, &stcb->sctp_ep->read_queue, next) { 57478933fa13SRandall Stewart if ((ctl->sinfo_stream == stseq->stream) && 57488933fa13SRandall Stewart (ctl->sinfo_ssn == stseq->sequence)) { 57498933fa13SRandall Stewart str_seq = (stseq->stream << 16) | stseq->sequence; 57508933fa13SRandall Stewart ctl->end_added = 1; 57518933fa13SRandall Stewart ctl->pdapi_aborted = 1; 57528933fa13SRandall Stewart sv = stcb->asoc.control_pdapi; 57538933fa13SRandall Stewart stcb->asoc.control_pdapi = ctl; 5754810ec536SMichael Tuexen sctp_ulp_notify(SCTP_NOTIFY_PARTIAL_DELVIERY_INDICATION, 5755810ec536SMichael Tuexen stcb, 57568933fa13SRandall Stewart SCTP_PARTIAL_DELIVERY_ABORTED, 5757810ec536SMichael Tuexen (void *)&str_seq, 5758810ec536SMichael Tuexen SCTP_SO_NOT_LOCKED); 57598933fa13SRandall Stewart stcb->asoc.control_pdapi = sv; 57608933fa13SRandall Stewart break; 57618933fa13SRandall Stewart } else if ((ctl->sinfo_stream == stseq->stream) && 57628933fa13SRandall Stewart (compare_with_wrap(ctl->sinfo_ssn, stseq->sequence, MAX_SEQ))) { 57638933fa13SRandall Stewart /* We are past our victim SSN */ 57648933fa13SRandall Stewart break; 57658933fa13SRandall Stewart } 57668933fa13SRandall Stewart } 5767851b7298SRandall Stewart strm = &asoc->strmin[stseq->stream]; 5768851b7298SRandall Stewart if (compare_with_wrap(stseq->sequence, 5769f8829a4aSRandall Stewart strm->last_sequence_delivered, MAX_SEQ)) { 5770f8829a4aSRandall Stewart /* Update the sequence number */ 5771f8829a4aSRandall Stewart strm->last_sequence_delivered = 5772851b7298SRandall Stewart stseq->sequence; 5773f8829a4aSRandall Stewart } 5774f8829a4aSRandall Stewart /* now kick the stream the new way */ 577504ee05e8SRandall Stewart /* sa_ignore NO_NULL_CHK */ 5776f8829a4aSRandall Stewart sctp_kick_prsctp_reorder_queue(stcb, strm); 5777f8829a4aSRandall Stewart } 57788933fa13SRandall Stewart SCTP_INP_READ_UNLOCK(stcb->sctp_ep); 5779f8829a4aSRandall Stewart } 57807898f408SRandall Stewart /* 57817898f408SRandall Stewart * Now slide thing forward. 57827898f408SRandall Stewart */ 57837898f408SRandall Stewart sctp_slide_mapping_arrays(stcb); 57847898f408SRandall Stewart 578524f52bbdSMichael Tuexen if (!TAILQ_EMPTY(&asoc->reasmqueue)) { 5786139bc87fSRandall Stewart /* now lets kick out and check for more fragmented delivery */ 578704ee05e8SRandall Stewart /* sa_ignore NO_NULL_CHK */ 5788139bc87fSRandall Stewart sctp_deliver_reasm_check(stcb, &stcb->asoc); 5789139bc87fSRandall Stewart } 5790f8829a4aSRandall Stewart } 5791