1/*- 2 * Copyright (c) 2001-2008, by Cisco Systems, Inc. All rights reserved. 3 * Copyright (c) 2008-2012, by Randall Stewart. All rights reserved. 4 * Copyright (c) 2008-2012, by Michael Tuexen. All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions are met: 8 * 9 * a) Redistributions of source code must retain the above copyright notice, 10 * this list of conditions and the following disclaimer. 11 * 12 * b) Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in 14 * the documentation and/or other materials provided with the distribution. 15 * 16 * c) Neither the name of Cisco Systems, Inc. nor the names of its 17 * contributors may be used to endorse or promote products derived 18 * from this software without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 21 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 22 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 24 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 30 * THE POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33#include <sys/cdefs.h> 34__FBSDID("$FreeBSD: releng/10.3/sys/netinet/sctp_input.c 296052 2016-02-25 18:46:06Z tuexen $"); 35 36#include <netinet/sctp_os.h> 37#include <netinet/sctp_var.h> 38#include <netinet/sctp_sysctl.h> 39#include <netinet/sctp_pcb.h> 40#include <netinet/sctp_header.h> 41#include <netinet/sctputil.h> 42#include <netinet/sctp_output.h> 43#include <netinet/sctp_input.h> 44#include <netinet/sctp_auth.h> 45#include <netinet/sctp_indata.h> 46#include <netinet/sctp_asconf.h> 47#include <netinet/sctp_bsd_addr.h> 48#include <netinet/sctp_timer.h> 49#include <netinet/sctp_crc32.h> 50#if defined(INET) || defined(INET6) 51#include <netinet/udp.h> 52#endif 53#include <sys/smp.h> 54 55 56 57static void 58sctp_stop_all_cookie_timers(struct sctp_tcb *stcb) 59{ 60 struct sctp_nets *net; 61 62 /* 63 * This now not only stops all cookie timers it also stops any INIT 64 * timers as well. This will make sure that the timers are stopped 65 * in all collision cases. 66 */ 67 SCTP_TCB_LOCK_ASSERT(stcb); 68 TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) { 69 if (net->rxt_timer.type == SCTP_TIMER_TYPE_COOKIE) { 70 sctp_timer_stop(SCTP_TIMER_TYPE_COOKIE, 71 stcb->sctp_ep, 72 stcb, 73 net, SCTP_FROM_SCTP_INPUT + SCTP_LOC_1); 74 } else if (net->rxt_timer.type == SCTP_TIMER_TYPE_INIT) { 75 sctp_timer_stop(SCTP_TIMER_TYPE_INIT, 76 stcb->sctp_ep, 77 stcb, 78 net, SCTP_FROM_SCTP_INPUT + SCTP_LOC_2); 79 } 80 } 81} 82 83/* INIT handler */ 84static void 85sctp_handle_init(struct mbuf *m, int iphlen, int offset, 86 struct sockaddr *src, struct sockaddr *dst, struct sctphdr *sh, 87 struct sctp_init_chunk *cp, struct sctp_inpcb *inp, 88 struct sctp_tcb *stcb, struct sctp_nets *net, int *abort_no_unlock, 89 uint8_t mflowtype, uint32_t mflowid, 90 uint32_t vrf_id, uint16_t port) 91{ 92 struct sctp_init *init; 93 struct mbuf *op_err; 94 95 SCTPDBG(SCTP_DEBUG_INPUT2, "sctp_handle_init: handling INIT tcb:%p\n", 96 (void *)stcb); 97 if (stcb == NULL) { 98 SCTP_INP_RLOCK(inp); 99 } 100 /* validate length */ 101 if (ntohs(cp->ch.chunk_length) < sizeof(struct sctp_init_chunk)) { 102 op_err = sctp_generate_cause(SCTP_CAUSE_INVALID_PARAM, ""); 103 sctp_abort_association(inp, stcb, m, iphlen, src, dst, sh, op_err, 104 mflowtype, mflowid, 105 vrf_id, port); 106 if (stcb) 107 *abort_no_unlock = 1; 108 goto outnow; 109 } 110 /* validate parameters */ 111 init = &cp->init; 112 if (init->initiate_tag == 0) { 113 /* protocol error... send abort */ 114 op_err = sctp_generate_cause(SCTP_CAUSE_INVALID_PARAM, ""); 115 sctp_abort_association(inp, stcb, m, iphlen, src, dst, sh, op_err, 116 mflowtype, mflowid, 117 vrf_id, port); 118 if (stcb) 119 *abort_no_unlock = 1; 120 goto outnow; 121 } 122 if (ntohl(init->a_rwnd) < SCTP_MIN_RWND) { 123 /* invalid parameter... send abort */ 124 op_err = sctp_generate_cause(SCTP_CAUSE_INVALID_PARAM, ""); 125 sctp_abort_association(inp, stcb, m, iphlen, src, dst, sh, op_err, 126 mflowtype, mflowid, 127 vrf_id, port); 128 if (stcb) 129 *abort_no_unlock = 1; 130 goto outnow; 131 } 132 if (init->num_inbound_streams == 0) { 133 /* protocol error... send abort */ 134 op_err = sctp_generate_cause(SCTP_CAUSE_INVALID_PARAM, ""); 135 sctp_abort_association(inp, stcb, m, iphlen, src, dst, sh, op_err, 136 mflowtype, mflowid, 137 vrf_id, port); 138 if (stcb) 139 *abort_no_unlock = 1; 140 goto outnow; 141 } 142 if (init->num_outbound_streams == 0) { 143 /* protocol error... send abort */ 144 op_err = sctp_generate_cause(SCTP_CAUSE_INVALID_PARAM, ""); 145 sctp_abort_association(inp, stcb, m, iphlen, src, dst, sh, op_err, 146 mflowtype, mflowid, 147 vrf_id, port); 148 if (stcb) 149 *abort_no_unlock = 1; 150 goto outnow; 151 } 152 if (sctp_validate_init_auth_params(m, offset + sizeof(*cp), 153 offset + ntohs(cp->ch.chunk_length))) { 154 /* auth parameter(s) error... send abort */ 155 op_err = sctp_generate_cause(SCTP_BASE_SYSCTL(sctp_diag_info_code), 156 "Problem with AUTH parameters"); 157 sctp_abort_association(inp, stcb, m, iphlen, src, dst, sh, op_err, 158 mflowtype, mflowid, 159 vrf_id, port); 160 if (stcb) 161 *abort_no_unlock = 1; 162 goto outnow; 163 } 164 /* 165 * We are only accepting if we have a socket with positive 166 * so_qlimit. 167 */ 168 if ((stcb == NULL) && 169 ((inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) || 170 (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_ALLGONE) || 171 (inp->sctp_socket == NULL) || 172 (inp->sctp_socket->so_qlimit == 0))) { 173 /* 174 * FIX ME ?? What about TCP model and we have a 175 * match/restart case? Actually no fix is needed. the lookup 176 * will always find the existing assoc so stcb would not be 177 * NULL. It may be questionable to do this since we COULD 178 * just send back the INIT-ACK and hope that the app did 179 * accept()'s by the time the COOKIE was sent. But there is 180 * a price to pay for COOKIE generation and I don't want to 181 * pay it on the chance that the app will actually do some 182 * accepts(). The App just looses and should NOT be in this 183 * state :-) 184 */ 185 if (SCTP_BASE_SYSCTL(sctp_blackhole) == 0) { 186 op_err = sctp_generate_cause(SCTP_BASE_SYSCTL(sctp_diag_info_code), 187 "No listener"); 188 sctp_send_abort(m, iphlen, src, dst, sh, 0, op_err, 189 mflowtype, mflowid, inp->fibnum, 190 vrf_id, port); 191 } 192 goto outnow; 193 } 194 if ((stcb != NULL) && 195 (SCTP_GET_STATE(&stcb->asoc) == SCTP_STATE_SHUTDOWN_ACK_SENT)) { 196 SCTPDBG(SCTP_DEBUG_INPUT3, "sctp_handle_init: sending SHUTDOWN-ACK\n"); 197 sctp_send_shutdown_ack(stcb, NULL); 198 sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_CONTROL_PROC, SCTP_SO_NOT_LOCKED); 199 } else { 200 SCTPDBG(SCTP_DEBUG_INPUT3, "sctp_handle_init: sending INIT-ACK\n"); 201 sctp_send_initiate_ack(inp, stcb, net, m, iphlen, offset, 202 src, dst, sh, cp, 203 mflowtype, mflowid, 204 vrf_id, port, 205 ((stcb == NULL) ? SCTP_HOLDS_LOCK : SCTP_NOT_LOCKED)); 206 } 207outnow: 208 if (stcb == NULL) { 209 SCTP_INP_RUNLOCK(inp); 210 } 211} 212 213/* 214 * process peer "INIT/INIT-ACK" chunk returns value < 0 on error 215 */ 216 217int 218sctp_is_there_unsent_data(struct sctp_tcb *stcb, int so_locked 219#if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING) 220 SCTP_UNUSED 221#endif 222) 223{ 224 int unsent_data = 0; 225 unsigned int i; 226 struct sctp_stream_queue_pending *sp; 227 struct sctp_association *asoc; 228 229 /* 230 * This function returns the number of streams that have true unsent 231 * data on them. Note that as it looks through it will clean up any 232 * places that have old data that has been sent but left at top of 233 * stream queue. 234 */ 235 asoc = &stcb->asoc; 236 SCTP_TCB_SEND_LOCK(stcb); 237 if (!stcb->asoc.ss_functions.sctp_ss_is_empty(stcb, asoc)) { 238 /* Check to see if some data queued */ 239 for (i = 0; i < stcb->asoc.streamoutcnt; i++) { 240 /* sa_ignore FREED_MEMORY */ 241 sp = TAILQ_FIRST(&stcb->asoc.strmout[i].outqueue); 242 if (sp == NULL) { 243 continue; 244 } 245 if ((sp->msg_is_complete) && 246 (sp->length == 0) && 247 (sp->sender_all_done)) { 248 /* 249 * We are doing differed cleanup. Last time 250 * through when we took all the data the 251 * sender_all_done was not set. 252 */ 253 if (sp->put_last_out == 0) { 254 SCTP_PRINTF("Gak, put out entire msg with NO end!-1\n"); 255 SCTP_PRINTF("sender_done:%d len:%d msg_comp:%d put_last_out:%d\n", 256 sp->sender_all_done, 257 sp->length, 258 sp->msg_is_complete, 259 sp->put_last_out); 260 } 261 atomic_subtract_int(&stcb->asoc.stream_queue_cnt, 1); 262 TAILQ_REMOVE(&stcb->asoc.strmout[i].outqueue, sp, next); 263 if (sp->net) { 264 sctp_free_remote_addr(sp->net); 265 sp->net = NULL; 266 } 267 if (sp->data) { 268 sctp_m_freem(sp->data); 269 sp->data = NULL; 270 } 271 sctp_free_a_strmoq(stcb, sp, so_locked); 272 } else { 273 unsent_data++; 274 break; 275 } 276 } 277 } 278 SCTP_TCB_SEND_UNLOCK(stcb); 279 return (unsent_data); 280} 281 282static int 283sctp_process_init(struct sctp_init_chunk *cp, struct sctp_tcb *stcb) 284{ 285 struct sctp_init *init; 286 struct sctp_association *asoc; 287 struct sctp_nets *lnet; 288 unsigned int i; 289 290 init = &cp->init; 291 asoc = &stcb->asoc; 292 /* save off parameters */ 293 asoc->peer_vtag = ntohl(init->initiate_tag); 294 asoc->peers_rwnd = ntohl(init->a_rwnd); 295 /* init tsn's */ 296 asoc->highest_tsn_inside_map = asoc->asconf_seq_in = ntohl(init->initial_tsn) - 1; 297 298 if (!TAILQ_EMPTY(&asoc->nets)) { 299 /* update any ssthresh's that may have a default */ 300 TAILQ_FOREACH(lnet, &asoc->nets, sctp_next) { 301 lnet->ssthresh = asoc->peers_rwnd; 302 if (SCTP_BASE_SYSCTL(sctp_logging_level) & (SCTP_CWND_MONITOR_ENABLE | SCTP_CWND_LOGGING_ENABLE)) { 303 sctp_log_cwnd(stcb, lnet, 0, SCTP_CWND_INITIALIZATION); 304 } 305 } 306 } 307 SCTP_TCB_SEND_LOCK(stcb); 308 if (asoc->pre_open_streams > ntohs(init->num_inbound_streams)) { 309 unsigned int newcnt; 310 struct sctp_stream_out *outs; 311 struct sctp_stream_queue_pending *sp, *nsp; 312 struct sctp_tmit_chunk *chk, *nchk; 313 314 /* abandon the upper streams */ 315 newcnt = ntohs(init->num_inbound_streams); 316 TAILQ_FOREACH_SAFE(chk, &asoc->send_queue, sctp_next, nchk) { 317 if (chk->rec.data.stream_number >= newcnt) { 318 TAILQ_REMOVE(&asoc->send_queue, chk, sctp_next); 319 asoc->send_queue_cnt--; 320 if (asoc->strmout[chk->rec.data.stream_number].chunks_on_queues > 0) { 321 asoc->strmout[chk->rec.data.stream_number].chunks_on_queues--; 322#ifdef INVARIANTS 323 } else { 324 panic("No chunks on the queues for sid %u.", chk->rec.data.stream_number); 325#endif 326 } 327 if (chk->data != NULL) { 328 sctp_free_bufspace(stcb, asoc, chk, 1); 329 sctp_ulp_notify(SCTP_NOTIFY_UNSENT_DG_FAIL, stcb, 330 0, chk, SCTP_SO_NOT_LOCKED); 331 if (chk->data) { 332 sctp_m_freem(chk->data); 333 chk->data = NULL; 334 } 335 } 336 sctp_free_a_chunk(stcb, chk, SCTP_SO_NOT_LOCKED); 337 /* sa_ignore FREED_MEMORY */ 338 } 339 } 340 if (asoc->strmout) { 341 for (i = newcnt; i < asoc->pre_open_streams; i++) { 342 outs = &asoc->strmout[i]; 343 TAILQ_FOREACH_SAFE(sp, &outs->outqueue, next, nsp) { 344 TAILQ_REMOVE(&outs->outqueue, sp, next); 345 asoc->stream_queue_cnt--; 346 sctp_ulp_notify(SCTP_NOTIFY_SPECIAL_SP_FAIL, 347 stcb, 0, sp, SCTP_SO_NOT_LOCKED); 348 if (sp->data) { 349 sctp_m_freem(sp->data); 350 sp->data = NULL; 351 } 352 if (sp->net) { 353 sctp_free_remote_addr(sp->net); 354 sp->net = NULL; 355 } 356 /* Free the chunk */ 357 sctp_free_a_strmoq(stcb, sp, SCTP_SO_NOT_LOCKED); 358 /* sa_ignore FREED_MEMORY */ 359 } 360 outs->state = SCTP_STREAM_CLOSED; 361 } 362 } 363 /* cut back the count */ 364 asoc->pre_open_streams = newcnt; 365 } 366 SCTP_TCB_SEND_UNLOCK(stcb); 367 asoc->streamoutcnt = asoc->pre_open_streams; 368 if (asoc->strmout) { 369 for (i = 0; i < asoc->streamoutcnt; i++) { 370 asoc->strmout[i].state = SCTP_STREAM_OPEN; 371 } 372 } 373 /* EY - nr_sack: initialize highest tsn in nr_mapping_array */ 374 asoc->highest_tsn_inside_nr_map = asoc->highest_tsn_inside_map; 375 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_MAP_LOGGING_ENABLE) { 376 sctp_log_map(0, 5, asoc->highest_tsn_inside_map, SCTP_MAP_SLIDE_RESULT); 377 } 378 /* This is the next one we expect */ 379 asoc->str_reset_seq_in = asoc->asconf_seq_in + 1; 380 381 asoc->mapping_array_base_tsn = ntohl(init->initial_tsn); 382 asoc->tsn_last_delivered = asoc->cumulative_tsn = asoc->asconf_seq_in; 383 384 asoc->advanced_peer_ack_point = asoc->last_acked_seq; 385 /* open the requested streams */ 386 387 if (asoc->strmin != NULL) { 388 /* Free the old ones */ 389 struct sctp_queued_to_read *ctl, *nctl; 390 391 for (i = 0; i < asoc->streamincnt; i++) { 392 TAILQ_FOREACH_SAFE(ctl, &asoc->strmin[i].inqueue, next, nctl) { 393 TAILQ_REMOVE(&asoc->strmin[i].inqueue, ctl, next); 394 sctp_free_remote_addr(ctl->whoFrom); 395 ctl->whoFrom = NULL; 396 sctp_m_freem(ctl->data); 397 ctl->data = NULL; 398 sctp_free_a_readq(stcb, ctl); 399 } 400 } 401 SCTP_FREE(asoc->strmin, SCTP_M_STRMI); 402 } 403 if (asoc->max_inbound_streams > ntohs(init->num_outbound_streams)) { 404 asoc->streamincnt = ntohs(init->num_outbound_streams); 405 } else { 406 asoc->streamincnt = asoc->max_inbound_streams; 407 } 408 SCTP_MALLOC(asoc->strmin, struct sctp_stream_in *, asoc->streamincnt * 409 sizeof(struct sctp_stream_in), SCTP_M_STRMI); 410 if (asoc->strmin == NULL) { 411 /* we didn't get memory for the streams! */ 412 SCTPDBG(SCTP_DEBUG_INPUT2, "process_init: couldn't get memory for the streams!\n"); 413 return (-1); 414 } 415 for (i = 0; i < asoc->streamincnt; i++) { 416 asoc->strmin[i].stream_no = i; 417 asoc->strmin[i].last_sequence_delivered = 0xffff; 418 TAILQ_INIT(&asoc->strmin[i].inqueue); 419 asoc->strmin[i].delivery_started = 0; 420 } 421 /* 422 * load_address_from_init will put the addresses into the 423 * association when the COOKIE is processed or the INIT-ACK is 424 * processed. Both types of COOKIE's existing and new call this 425 * routine. It will remove addresses that are no longer in the 426 * association (for the restarting case where addresses are 427 * removed). Up front when the INIT arrives we will discard it if it 428 * is a restart and new addresses have been added. 429 */ 430 /* sa_ignore MEMLEAK */ 431 return (0); 432} 433 434/* 435 * INIT-ACK message processing/consumption returns value < 0 on error 436 */ 437static int 438sctp_process_init_ack(struct mbuf *m, int iphlen, int offset, 439 struct sockaddr *src, struct sockaddr *dst, struct sctphdr *sh, 440 struct sctp_init_ack_chunk *cp, struct sctp_tcb *stcb, 441 struct sctp_nets *net, int *abort_no_unlock, 442 uint8_t mflowtype, uint32_t mflowid, 443 uint32_t vrf_id) 444{ 445 struct sctp_association *asoc; 446 struct mbuf *op_err; 447 int retval, abort_flag; 448 uint32_t initack_limit; 449 int nat_friendly = 0; 450 451 /* First verify that we have no illegal param's */ 452 abort_flag = 0; 453 454 op_err = sctp_arethere_unrecognized_parameters(m, 455 (offset + sizeof(struct sctp_init_chunk)), 456 &abort_flag, (struct sctp_chunkhdr *)cp, &nat_friendly); 457 if (abort_flag) { 458 /* Send an abort and notify peer */ 459 sctp_abort_an_association(stcb->sctp_ep, stcb, op_err, SCTP_SO_NOT_LOCKED); 460 *abort_no_unlock = 1; 461 return (-1); 462 } 463 asoc = &stcb->asoc; 464 asoc->peer_supports_nat = (uint8_t) nat_friendly; 465 /* process the peer's parameters in the INIT-ACK */ 466 retval = sctp_process_init((struct sctp_init_chunk *)cp, stcb); 467 if (retval < 0) { 468 return (retval); 469 } 470 initack_limit = offset + ntohs(cp->ch.chunk_length); 471 /* load all addresses */ 472 if ((retval = sctp_load_addresses_from_init(stcb, m, 473 (offset + sizeof(struct sctp_init_chunk)), initack_limit, 474 src, dst, NULL))) { 475 op_err = sctp_generate_cause(SCTP_BASE_SYSCTL(sctp_diag_info_code), 476 "Problem with address parameters"); 477 SCTPDBG(SCTP_DEBUG_INPUT1, 478 "Load addresses from INIT causes an abort %d\n", 479 retval); 480 sctp_abort_association(stcb->sctp_ep, stcb, m, iphlen, 481 src, dst, sh, op_err, 482 mflowtype, mflowid, 483 vrf_id, net->port); 484 *abort_no_unlock = 1; 485 return (-1); 486 } 487 /* if the peer doesn't support asconf, flush the asconf queue */ 488 if (asoc->asconf_supported == 0) { 489 struct sctp_asconf_addr *param, *nparam; 490 491 TAILQ_FOREACH_SAFE(param, &asoc->asconf_queue, next, nparam) { 492 TAILQ_REMOVE(&asoc->asconf_queue, param, next); 493 SCTP_FREE(param, SCTP_M_ASC_ADDR); 494 } 495 } 496 stcb->asoc.peer_hmac_id = sctp_negotiate_hmacid(stcb->asoc.peer_hmacs, 497 stcb->asoc.local_hmacs); 498 if (op_err) { 499 sctp_queue_op_err(stcb, op_err); 500 /* queuing will steal away the mbuf chain to the out queue */ 501 op_err = NULL; 502 } 503 /* extract the cookie and queue it to "echo" it back... */ 504 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_THRESHOLD_LOGGING) { 505 sctp_misc_ints(SCTP_THRESHOLD_CLEAR, 506 stcb->asoc.overall_error_count, 507 0, 508 SCTP_FROM_SCTP_INPUT, 509 __LINE__); 510 } 511 stcb->asoc.overall_error_count = 0; 512 net->error_count = 0; 513 514 /* 515 * Cancel the INIT timer, We do this first before queueing the 516 * cookie. We always cancel at the primary to assue that we are 517 * canceling the timer started by the INIT which always goes to the 518 * primary. 519 */ 520 sctp_timer_stop(SCTP_TIMER_TYPE_INIT, stcb->sctp_ep, stcb, 521 asoc->primary_destination, SCTP_FROM_SCTP_INPUT + SCTP_LOC_3); 522 523 /* calculate the RTO */ 524 net->RTO = sctp_calculate_rto(stcb, asoc, net, &asoc->time_entered, sctp_align_safe_nocopy, 525 SCTP_RTT_FROM_NON_DATA); 526 retval = sctp_send_cookie_echo(m, offset, stcb, net); 527 if (retval < 0) { 528 /* 529 * No cookie, we probably should send a op error. But in any 530 * case if there is no cookie in the INIT-ACK, we can 531 * abandon the peer, its broke. 532 */ 533 if (retval == -3) { 534 uint16_t len; 535 536 len = (uint16_t) (sizeof(struct sctp_error_missing_param) + sizeof(uint16_t)); 537 /* We abort with an error of missing mandatory param */ 538 op_err = sctp_get_mbuf_for_msg(len, 0, M_NOWAIT, 1, MT_DATA); 539 if (op_err != NULL) { 540 struct sctp_error_missing_param *cause; 541 542 SCTP_BUF_LEN(op_err) = len; 543 cause = mtod(op_err, struct sctp_error_missing_param *); 544 /* Subtract the reserved param */ 545 cause->cause.code = htons(SCTP_CAUSE_MISSING_PARAM); 546 cause->cause.length = htons(len); 547 cause->num_missing_params = htonl(1); 548 cause->type[0] = htons(SCTP_STATE_COOKIE); 549 } 550 sctp_abort_association(stcb->sctp_ep, stcb, m, iphlen, 551 src, dst, sh, op_err, 552 mflowtype, mflowid, 553 vrf_id, net->port); 554 *abort_no_unlock = 1; 555 } 556 return (retval); 557 } 558 return (0); 559} 560 561static void 562sctp_handle_heartbeat_ack(struct sctp_heartbeat_chunk *cp, 563 struct sctp_tcb *stcb, struct sctp_nets *net) 564{ 565 union sctp_sockstore store; 566 struct sctp_nets *r_net, *f_net; 567 struct timeval tv; 568 int req_prim = 0; 569 uint16_t old_error_counter; 570 571 if (ntohs(cp->ch.chunk_length) != sizeof(struct sctp_heartbeat_chunk)) { 572 /* Invalid length */ 573 return; 574 } 575 memset(&store, 0, sizeof(store)); 576 switch (cp->heartbeat.hb_info.addr_family) { 577#ifdef INET 578 case AF_INET: 579 if (cp->heartbeat.hb_info.addr_len == sizeof(struct sockaddr_in)) { 580 store.sin.sin_family = cp->heartbeat.hb_info.addr_family; 581 store.sin.sin_len = cp->heartbeat.hb_info.addr_len; 582 store.sin.sin_port = stcb->rport; 583 memcpy(&store.sin.sin_addr, cp->heartbeat.hb_info.address, 584 sizeof(store.sin.sin_addr)); 585 } else { 586 return; 587 } 588 break; 589#endif 590#ifdef INET6 591 case AF_INET6: 592 if (cp->heartbeat.hb_info.addr_len == sizeof(struct sockaddr_in6)) { 593 store.sin6.sin6_family = cp->heartbeat.hb_info.addr_family; 594 store.sin6.sin6_len = cp->heartbeat.hb_info.addr_len; 595 store.sin6.sin6_port = stcb->rport; 596 memcpy(&store.sin6.sin6_addr, cp->heartbeat.hb_info.address, sizeof(struct in6_addr)); 597 } else { 598 return; 599 } 600 break; 601#endif 602 default: 603 return; 604 } 605 r_net = sctp_findnet(stcb, &store.sa); 606 if (r_net == NULL) { 607 SCTPDBG(SCTP_DEBUG_INPUT1, "Huh? I can't find the address I sent it to, discard\n"); 608 return; 609 } 610 if ((r_net && (r_net->dest_state & SCTP_ADDR_UNCONFIRMED)) && 611 (r_net->heartbeat_random1 == cp->heartbeat.hb_info.random_value1) && 612 (r_net->heartbeat_random2 == cp->heartbeat.hb_info.random_value2)) { 613 /* 614 * If the its a HB and it's random value is correct when can 615 * confirm the destination. 616 */ 617 r_net->dest_state &= ~SCTP_ADDR_UNCONFIRMED; 618 if (r_net->dest_state & SCTP_ADDR_REQ_PRIMARY) { 619 stcb->asoc.primary_destination = r_net; 620 r_net->dest_state &= ~SCTP_ADDR_REQ_PRIMARY; 621 f_net = TAILQ_FIRST(&stcb->asoc.nets); 622 if (f_net != r_net) { 623 /* 624 * first one on the list is NOT the primary 625 * sctp_cmpaddr() is much more efficent if 626 * the primary is the first on the list, 627 * make it so. 628 */ 629 TAILQ_REMOVE(&stcb->asoc.nets, r_net, sctp_next); 630 TAILQ_INSERT_HEAD(&stcb->asoc.nets, r_net, sctp_next); 631 } 632 req_prim = 1; 633 } 634 sctp_ulp_notify(SCTP_NOTIFY_INTERFACE_CONFIRMED, 635 stcb, 0, (void *)r_net, SCTP_SO_NOT_LOCKED); 636 sctp_timer_stop(SCTP_TIMER_TYPE_HEARTBEAT, stcb->sctp_ep, stcb, 637 r_net, SCTP_FROM_SCTP_INPUT + SCTP_LOC_4); 638 sctp_timer_start(SCTP_TIMER_TYPE_HEARTBEAT, stcb->sctp_ep, stcb, r_net); 639 } 640 old_error_counter = r_net->error_count; 641 r_net->error_count = 0; 642 r_net->hb_responded = 1; 643 tv.tv_sec = cp->heartbeat.hb_info.time_value_1; 644 tv.tv_usec = cp->heartbeat.hb_info.time_value_2; 645 /* Now lets do a RTO with this */ 646 r_net->RTO = sctp_calculate_rto(stcb, &stcb->asoc, r_net, &tv, sctp_align_safe_nocopy, 647 SCTP_RTT_FROM_NON_DATA); 648 if (!(r_net->dest_state & SCTP_ADDR_REACHABLE)) { 649 r_net->dest_state |= SCTP_ADDR_REACHABLE; 650 sctp_ulp_notify(SCTP_NOTIFY_INTERFACE_UP, stcb, 651 0, (void *)r_net, SCTP_SO_NOT_LOCKED); 652 } 653 if (r_net->dest_state & SCTP_ADDR_PF) { 654 r_net->dest_state &= ~SCTP_ADDR_PF; 655 stcb->asoc.cc_functions.sctp_cwnd_update_exit_pf(stcb, net); 656 } 657 if (old_error_counter > 0) { 658 sctp_timer_stop(SCTP_TIMER_TYPE_HEARTBEAT, stcb->sctp_ep, 659 stcb, r_net, SCTP_FROM_SCTP_INPUT + SCTP_LOC_5); 660 sctp_timer_start(SCTP_TIMER_TYPE_HEARTBEAT, stcb->sctp_ep, stcb, r_net); 661 } 662 if (r_net == stcb->asoc.primary_destination) { 663 if (stcb->asoc.alternate) { 664 /* release the alternate, primary is good */ 665 sctp_free_remote_addr(stcb->asoc.alternate); 666 stcb->asoc.alternate = NULL; 667 } 668 } 669 /* Mobility adaptation */ 670 if (req_prim) { 671 if ((sctp_is_mobility_feature_on(stcb->sctp_ep, 672 SCTP_MOBILITY_BASE) || 673 sctp_is_mobility_feature_on(stcb->sctp_ep, 674 SCTP_MOBILITY_FASTHANDOFF)) && 675 sctp_is_mobility_feature_on(stcb->sctp_ep, 676 SCTP_MOBILITY_PRIM_DELETED)) { 677 678 sctp_timer_stop(SCTP_TIMER_TYPE_PRIM_DELETED, 679 stcb->sctp_ep, stcb, NULL, 680 SCTP_FROM_SCTP_INPUT + SCTP_LOC_6); 681 if (sctp_is_mobility_feature_on(stcb->sctp_ep, 682 SCTP_MOBILITY_FASTHANDOFF)) { 683 sctp_assoc_immediate_retrans(stcb, 684 stcb->asoc.primary_destination); 685 } 686 if (sctp_is_mobility_feature_on(stcb->sctp_ep, 687 SCTP_MOBILITY_BASE)) { 688 sctp_move_chunks_from_net(stcb, 689 stcb->asoc.deleted_primary); 690 } 691 sctp_delete_prim_timer(stcb->sctp_ep, stcb, 692 stcb->asoc.deleted_primary); 693 } 694 } 695} 696 697static int 698sctp_handle_nat_colliding_state(struct sctp_tcb *stcb) 699{ 700 /* 701 * return 0 means we want you to proceed with the abort non-zero 702 * means no abort processing 703 */ 704 struct sctpasochead *head; 705 706 if (SCTP_GET_STATE(&stcb->asoc) == SCTP_STATE_COOKIE_WAIT) { 707 /* generate a new vtag and send init */ 708 LIST_REMOVE(stcb, sctp_asocs); 709 stcb->asoc.my_vtag = sctp_select_a_tag(stcb->sctp_ep, stcb->sctp_ep->sctp_lport, stcb->rport, 1); 710 head = &SCTP_BASE_INFO(sctp_asochash)[SCTP_PCBHASH_ASOC(stcb->asoc.my_vtag, SCTP_BASE_INFO(hashasocmark))]; 711 /* 712 * put it in the bucket in the vtag hash of assoc's for the 713 * system 714 */ 715 LIST_INSERT_HEAD(head, stcb, sctp_asocs); 716 sctp_send_initiate(stcb->sctp_ep, stcb, SCTP_SO_NOT_LOCKED); 717 return (1); 718 } 719 if (SCTP_GET_STATE(&stcb->asoc) == SCTP_STATE_COOKIE_ECHOED) { 720 /* 721 * treat like a case where the cookie expired i.e.: - dump 722 * current cookie. - generate a new vtag. - resend init. 723 */ 724 /* generate a new vtag and send init */ 725 LIST_REMOVE(stcb, sctp_asocs); 726 stcb->asoc.state &= ~SCTP_STATE_COOKIE_ECHOED; 727 stcb->asoc.state |= SCTP_STATE_COOKIE_WAIT; 728 sctp_stop_all_cookie_timers(stcb); 729 sctp_toss_old_cookies(stcb, &stcb->asoc); 730 stcb->asoc.my_vtag = sctp_select_a_tag(stcb->sctp_ep, stcb->sctp_ep->sctp_lport, stcb->rport, 1); 731 head = &SCTP_BASE_INFO(sctp_asochash)[SCTP_PCBHASH_ASOC(stcb->asoc.my_vtag, SCTP_BASE_INFO(hashasocmark))]; 732 /* 733 * put it in the bucket in the vtag hash of assoc's for the 734 * system 735 */ 736 LIST_INSERT_HEAD(head, stcb, sctp_asocs); 737 sctp_send_initiate(stcb->sctp_ep, stcb, SCTP_SO_NOT_LOCKED); 738 return (1); 739 } 740 return (0); 741} 742 743static int 744sctp_handle_nat_missing_state(struct sctp_tcb *stcb, 745 struct sctp_nets *net) 746{ 747 /* 748 * return 0 means we want you to proceed with the abort non-zero 749 * means no abort processing 750 */ 751 if (stcb->asoc.auth_supported == 0) { 752 SCTPDBG(SCTP_DEBUG_INPUT2, "sctp_handle_nat_missing_state: Peer does not support AUTH, cannot send an asconf\n"); 753 return (0); 754 } 755 sctp_asconf_send_nat_state_update(stcb, net); 756 return (1); 757} 758 759 760static void 761sctp_handle_abort(struct sctp_abort_chunk *abort, 762 struct sctp_tcb *stcb, struct sctp_nets *net) 763{ 764#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 765 struct socket *so; 766 767#endif 768 uint16_t len; 769 uint16_t error; 770 771 SCTPDBG(SCTP_DEBUG_INPUT2, "sctp_handle_abort: handling ABORT\n"); 772 if (stcb == NULL) 773 return; 774 775 len = ntohs(abort->ch.chunk_length); 776 if (len > sizeof(struct sctp_chunkhdr)) { 777 /* 778 * Need to check the cause codes for our two magic nat 779 * aborts which don't kill the assoc necessarily. 780 */ 781 struct sctp_gen_error_cause *cause; 782 783 cause = (struct sctp_gen_error_cause *)(abort + 1); 784 error = ntohs(cause->code); 785 if (error == SCTP_CAUSE_NAT_COLLIDING_STATE) { 786 SCTPDBG(SCTP_DEBUG_INPUT2, "Received Colliding state abort flags:%x\n", 787 abort->ch.chunk_flags); 788 if (sctp_handle_nat_colliding_state(stcb)) { 789 return; 790 } 791 } else if (error == SCTP_CAUSE_NAT_MISSING_STATE) { 792 SCTPDBG(SCTP_DEBUG_INPUT2, "Received missing state abort flags:%x\n", 793 abort->ch.chunk_flags); 794 if (sctp_handle_nat_missing_state(stcb, net)) { 795 return; 796 } 797 } 798 } else { 799 error = 0; 800 } 801 /* stop any receive timers */ 802 sctp_timer_stop(SCTP_TIMER_TYPE_RECV, stcb->sctp_ep, stcb, net, 803 SCTP_FROM_SCTP_INPUT + SCTP_LOC_7); 804 /* notify user of the abort and clean up... */ 805 sctp_abort_notification(stcb, 1, error, abort, SCTP_SO_NOT_LOCKED); 806 /* free the tcb */ 807 SCTP_STAT_INCR_COUNTER32(sctps_aborted); 808 if ((SCTP_GET_STATE(&stcb->asoc) == SCTP_STATE_OPEN) || 809 (SCTP_GET_STATE(&stcb->asoc) == SCTP_STATE_SHUTDOWN_RECEIVED)) { 810 SCTP_STAT_DECR_GAUGE32(sctps_currestab); 811 } 812#ifdef SCTP_ASOCLOG_OF_TSNS 813 sctp_print_out_track_log(stcb); 814#endif 815#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 816 so = SCTP_INP_SO(stcb->sctp_ep); 817 atomic_add_int(&stcb->asoc.refcnt, 1); 818 SCTP_TCB_UNLOCK(stcb); 819 SCTP_SOCKET_LOCK(so, 1); 820 SCTP_TCB_LOCK(stcb); 821 atomic_subtract_int(&stcb->asoc.refcnt, 1); 822#endif 823 stcb->asoc.state |= SCTP_STATE_WAS_ABORTED; 824 (void)sctp_free_assoc(stcb->sctp_ep, stcb, SCTP_NORMAL_PROC, 825 SCTP_FROM_SCTP_INPUT + SCTP_LOC_8); 826#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 827 SCTP_SOCKET_UNLOCK(so, 1); 828#endif 829 SCTPDBG(SCTP_DEBUG_INPUT2, "sctp_handle_abort: finished\n"); 830} 831 832static void 833sctp_start_net_timers(struct sctp_tcb *stcb) 834{ 835 uint32_t cnt_hb_sent; 836 struct sctp_nets *net; 837 838 cnt_hb_sent = 0; 839 TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) { 840 /* 841 * For each network start: 1) A pmtu timer. 2) A HB timer 3) 842 * If the dest in unconfirmed send a hb as well if under 843 * max_hb_burst have been sent. 844 */ 845 sctp_timer_start(SCTP_TIMER_TYPE_PATHMTURAISE, stcb->sctp_ep, stcb, net); 846 sctp_timer_start(SCTP_TIMER_TYPE_HEARTBEAT, stcb->sctp_ep, stcb, net); 847 if ((net->dest_state & SCTP_ADDR_UNCONFIRMED) && 848 (cnt_hb_sent < SCTP_BASE_SYSCTL(sctp_hb_maxburst))) { 849 sctp_send_hb(stcb, net, SCTP_SO_NOT_LOCKED); 850 cnt_hb_sent++; 851 } 852 } 853 if (cnt_hb_sent) { 854 sctp_chunk_output(stcb->sctp_ep, stcb, 855 SCTP_OUTPUT_FROM_COOKIE_ACK, 856 SCTP_SO_NOT_LOCKED); 857 } 858} 859 860 861static void 862sctp_handle_shutdown(struct sctp_shutdown_chunk *cp, 863 struct sctp_tcb *stcb, struct sctp_nets *net, int *abort_flag) 864{ 865 struct sctp_association *asoc; 866 int some_on_streamwheel; 867 int old_state; 868 869#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 870 struct socket *so; 871 872#endif 873 874 SCTPDBG(SCTP_DEBUG_INPUT2, 875 "sctp_handle_shutdown: handling SHUTDOWN\n"); 876 if (stcb == NULL) 877 return; 878 asoc = &stcb->asoc; 879 if ((SCTP_GET_STATE(asoc) == SCTP_STATE_COOKIE_WAIT) || 880 (SCTP_GET_STATE(asoc) == SCTP_STATE_COOKIE_ECHOED)) { 881 return; 882 } 883 if (ntohs(cp->ch.chunk_length) != sizeof(struct sctp_shutdown_chunk)) { 884 /* Shutdown NOT the expected size */ 885 return; 886 } 887 old_state = SCTP_GET_STATE(asoc); 888 sctp_update_acked(stcb, cp, abort_flag); 889 if (*abort_flag) { 890 return; 891 } 892 if (asoc->control_pdapi) { 893 /* 894 * With a normal shutdown we assume the end of last record. 895 */ 896 SCTP_INP_READ_LOCK(stcb->sctp_ep); 897 asoc->control_pdapi->end_added = 1; 898 asoc->control_pdapi->pdapi_aborted = 1; 899 asoc->control_pdapi = NULL; 900 SCTP_INP_READ_UNLOCK(stcb->sctp_ep); 901#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 902 so = SCTP_INP_SO(stcb->sctp_ep); 903 atomic_add_int(&stcb->asoc.refcnt, 1); 904 SCTP_TCB_UNLOCK(stcb); 905 SCTP_SOCKET_LOCK(so, 1); 906 SCTP_TCB_LOCK(stcb); 907 atomic_subtract_int(&stcb->asoc.refcnt, 1); 908 if (stcb->asoc.state & SCTP_STATE_CLOSED_SOCKET) { 909 /* assoc was freed while we were unlocked */ 910 SCTP_SOCKET_UNLOCK(so, 1); 911 return; 912 } 913#endif 914 if (stcb->sctp_socket) { 915 sctp_sorwakeup(stcb->sctp_ep, stcb->sctp_socket); 916 } 917#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 918 SCTP_SOCKET_UNLOCK(so, 1); 919#endif 920 } 921 /* goto SHUTDOWN_RECEIVED state to block new requests */ 922 if (stcb->sctp_socket) { 923 if ((SCTP_GET_STATE(asoc) != SCTP_STATE_SHUTDOWN_RECEIVED) && 924 (SCTP_GET_STATE(asoc) != SCTP_STATE_SHUTDOWN_ACK_SENT) && 925 (SCTP_GET_STATE(asoc) != SCTP_STATE_SHUTDOWN_SENT)) { 926 SCTP_SET_STATE(asoc, SCTP_STATE_SHUTDOWN_RECEIVED); 927 SCTP_CLEAR_SUBSTATE(asoc, SCTP_STATE_SHUTDOWN_PENDING); 928 /* 929 * notify upper layer that peer has initiated a 930 * shutdown 931 */ 932 sctp_ulp_notify(SCTP_NOTIFY_PEER_SHUTDOWN, stcb, 0, NULL, SCTP_SO_NOT_LOCKED); 933 934 /* reset time */ 935 (void)SCTP_GETTIME_TIMEVAL(&asoc->time_entered); 936 } 937 } 938 if (SCTP_GET_STATE(asoc) == SCTP_STATE_SHUTDOWN_SENT) { 939 /* 940 * stop the shutdown timer, since we WILL move to 941 * SHUTDOWN-ACK-SENT. 942 */ 943 sctp_timer_stop(SCTP_TIMER_TYPE_SHUTDOWN, stcb->sctp_ep, stcb, 944 net, SCTP_FROM_SCTP_INPUT + SCTP_LOC_9); 945 } 946 /* Now is there unsent data on a stream somewhere? */ 947 some_on_streamwheel = sctp_is_there_unsent_data(stcb, SCTP_SO_NOT_LOCKED); 948 949 if (!TAILQ_EMPTY(&asoc->send_queue) || 950 !TAILQ_EMPTY(&asoc->sent_queue) || 951 some_on_streamwheel) { 952 /* By returning we will push more data out */ 953 return; 954 } else { 955 /* no outstanding data to send, so move on... */ 956 /* send SHUTDOWN-ACK */ 957 /* move to SHUTDOWN-ACK-SENT state */ 958 if ((SCTP_GET_STATE(asoc) == SCTP_STATE_OPEN) || 959 (SCTP_GET_STATE(asoc) == SCTP_STATE_SHUTDOWN_RECEIVED)) { 960 SCTP_STAT_DECR_GAUGE32(sctps_currestab); 961 } 962 SCTP_CLEAR_SUBSTATE(asoc, SCTP_STATE_SHUTDOWN_PENDING); 963 if (SCTP_GET_STATE(asoc) != SCTP_STATE_SHUTDOWN_ACK_SENT) { 964 SCTP_SET_STATE(asoc, SCTP_STATE_SHUTDOWN_ACK_SENT); 965 sctp_stop_timers_for_shutdown(stcb); 966 sctp_send_shutdown_ack(stcb, net); 967 sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWNACK, 968 stcb->sctp_ep, stcb, net); 969 } else if (old_state == SCTP_STATE_SHUTDOWN_ACK_SENT) { 970 sctp_send_shutdown_ack(stcb, net); 971 } 972 } 973} 974 975static void 976sctp_handle_shutdown_ack(struct sctp_shutdown_ack_chunk *cp SCTP_UNUSED, 977 struct sctp_tcb *stcb, 978 struct sctp_nets *net) 979{ 980 struct sctp_association *asoc; 981 982#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 983 struct socket *so; 984 985 so = SCTP_INP_SO(stcb->sctp_ep); 986#endif 987 SCTPDBG(SCTP_DEBUG_INPUT2, 988 "sctp_handle_shutdown_ack: handling SHUTDOWN ACK\n"); 989 if (stcb == NULL) 990 return; 991 992 asoc = &stcb->asoc; 993 /* process according to association state */ 994 if ((SCTP_GET_STATE(asoc) == SCTP_STATE_COOKIE_WAIT) || 995 (SCTP_GET_STATE(asoc) == SCTP_STATE_COOKIE_ECHOED)) { 996 /* unexpected SHUTDOWN-ACK... do OOTB handling... */ 997 sctp_send_shutdown_complete(stcb, net, 1); 998 SCTP_TCB_UNLOCK(stcb); 999 return; 1000 } 1001 if ((SCTP_GET_STATE(asoc) != SCTP_STATE_SHUTDOWN_SENT) && 1002 (SCTP_GET_STATE(asoc) != SCTP_STATE_SHUTDOWN_ACK_SENT)) { 1003 /* unexpected SHUTDOWN-ACK... so ignore... */ 1004 SCTP_TCB_UNLOCK(stcb); 1005 return; 1006 } 1007 if (asoc->control_pdapi) { 1008 /* 1009 * With a normal shutdown we assume the end of last record. 1010 */ 1011 SCTP_INP_READ_LOCK(stcb->sctp_ep); 1012 asoc->control_pdapi->end_added = 1; 1013 asoc->control_pdapi->pdapi_aborted = 1; 1014 asoc->control_pdapi = NULL; 1015 SCTP_INP_READ_UNLOCK(stcb->sctp_ep); 1016#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 1017 atomic_add_int(&stcb->asoc.refcnt, 1); 1018 SCTP_TCB_UNLOCK(stcb); 1019 SCTP_SOCKET_LOCK(so, 1); 1020 SCTP_TCB_LOCK(stcb); 1021 atomic_subtract_int(&stcb->asoc.refcnt, 1); 1022 if (stcb->asoc.state & SCTP_STATE_CLOSED_SOCKET) { 1023 /* assoc was freed while we were unlocked */ 1024 SCTP_SOCKET_UNLOCK(so, 1); 1025 return; 1026 } 1027#endif 1028 sctp_sorwakeup(stcb->sctp_ep, stcb->sctp_socket); 1029#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 1030 SCTP_SOCKET_UNLOCK(so, 1); 1031#endif 1032 } 1033#ifdef INVARIANTS 1034 if (!TAILQ_EMPTY(&asoc->send_queue) || 1035 !TAILQ_EMPTY(&asoc->sent_queue) || 1036 !stcb->asoc.ss_functions.sctp_ss_is_empty(stcb, asoc)) { 1037 panic("Queues are not empty when handling SHUTDOWN-ACK"); 1038 } 1039#endif 1040 /* stop the timer */ 1041 sctp_timer_stop(SCTP_TIMER_TYPE_SHUTDOWN, stcb->sctp_ep, stcb, net, 1042 SCTP_FROM_SCTP_INPUT + SCTP_LOC_10); 1043 /* send SHUTDOWN-COMPLETE */ 1044 sctp_send_shutdown_complete(stcb, net, 0); 1045 /* notify upper layer protocol */ 1046 if (stcb->sctp_socket) { 1047 if ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) || 1048 (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL)) { 1049 stcb->sctp_socket->so_snd.sb_cc = 0; 1050 } 1051 sctp_ulp_notify(SCTP_NOTIFY_ASSOC_DOWN, stcb, 0, NULL, SCTP_SO_NOT_LOCKED); 1052 } 1053 SCTP_STAT_INCR_COUNTER32(sctps_shutdown); 1054 /* free the TCB but first save off the ep */ 1055#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 1056 atomic_add_int(&stcb->asoc.refcnt, 1); 1057 SCTP_TCB_UNLOCK(stcb); 1058 SCTP_SOCKET_LOCK(so, 1); 1059 SCTP_TCB_LOCK(stcb); 1060 atomic_subtract_int(&stcb->asoc.refcnt, 1); 1061#endif 1062 (void)sctp_free_assoc(stcb->sctp_ep, stcb, SCTP_NORMAL_PROC, 1063 SCTP_FROM_SCTP_INPUT + SCTP_LOC_11); 1064#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 1065 SCTP_SOCKET_UNLOCK(so, 1); 1066#endif 1067} 1068 1069/* 1070 * Skip past the param header and then we will find the chunk that caused the 1071 * problem. There are two possiblities ASCONF or FWD-TSN other than that and 1072 * our peer must be broken. 1073 */ 1074static void 1075sctp_process_unrecog_chunk(struct sctp_tcb *stcb, struct sctp_paramhdr *phdr, 1076 struct sctp_nets *net) 1077{ 1078 struct sctp_chunkhdr *chk; 1079 1080 chk = (struct sctp_chunkhdr *)((caddr_t)phdr + sizeof(*phdr)); 1081 switch (chk->chunk_type) { 1082 case SCTP_ASCONF_ACK: 1083 case SCTP_ASCONF: 1084 sctp_asconf_cleanup(stcb, net); 1085 break; 1086 case SCTP_FORWARD_CUM_TSN: 1087 stcb->asoc.prsctp_supported = 0; 1088 break; 1089 default: 1090 SCTPDBG(SCTP_DEBUG_INPUT2, 1091 "Peer does not support chunk type %d(%x)??\n", 1092 chk->chunk_type, (uint32_t) chk->chunk_type); 1093 break; 1094 } 1095} 1096 1097/* 1098 * Skip past the param header and then we will find the param that caused the 1099 * problem. There are a number of param's in a ASCONF OR the prsctp param 1100 * these will turn of specific features. 1101 * XXX: Is this the right thing to do? 1102 */ 1103static void 1104sctp_process_unrecog_param(struct sctp_tcb *stcb, struct sctp_paramhdr *phdr) 1105{ 1106 struct sctp_paramhdr *pbad; 1107 1108 pbad = phdr + 1; 1109 switch (ntohs(pbad->param_type)) { 1110 /* pr-sctp draft */ 1111 case SCTP_PRSCTP_SUPPORTED: 1112 stcb->asoc.prsctp_supported = 0; 1113 break; 1114 case SCTP_SUPPORTED_CHUNK_EXT: 1115 break; 1116 /* draft-ietf-tsvwg-addip-sctp */ 1117 case SCTP_HAS_NAT_SUPPORT: 1118 stcb->asoc.peer_supports_nat = 0; 1119 break; 1120 case SCTP_ADD_IP_ADDRESS: 1121 case SCTP_DEL_IP_ADDRESS: 1122 case SCTP_SET_PRIM_ADDR: 1123 stcb->asoc.asconf_supported = 0; 1124 break; 1125 case SCTP_SUCCESS_REPORT: 1126 case SCTP_ERROR_CAUSE_IND: 1127 SCTPDBG(SCTP_DEBUG_INPUT2, "Huh, the peer does not support success? or error cause?\n"); 1128 SCTPDBG(SCTP_DEBUG_INPUT2, 1129 "Turning off ASCONF to this strange peer\n"); 1130 stcb->asoc.asconf_supported = 0; 1131 break; 1132 default: 1133 SCTPDBG(SCTP_DEBUG_INPUT2, 1134 "Peer does not support param type %d(%x)??\n", 1135 pbad->param_type, (uint32_t) pbad->param_type); 1136 break; 1137 } 1138} 1139 1140static int 1141sctp_handle_error(struct sctp_chunkhdr *ch, 1142 struct sctp_tcb *stcb, struct sctp_nets *net) 1143{ 1144 int chklen; 1145 struct sctp_paramhdr *phdr; 1146 uint16_t error, error_type; 1147 uint16_t error_len; 1148 struct sctp_association *asoc; 1149 int adjust; 1150 1151#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 1152 struct socket *so; 1153 1154#endif 1155 1156 /* parse through all of the errors and process */ 1157 asoc = &stcb->asoc; 1158 phdr = (struct sctp_paramhdr *)((caddr_t)ch + 1159 sizeof(struct sctp_chunkhdr)); 1160 chklen = ntohs(ch->chunk_length) - sizeof(struct sctp_chunkhdr); 1161 error = 0; 1162 while ((size_t)chklen >= sizeof(struct sctp_paramhdr)) { 1163 /* Process an Error Cause */ 1164 error_type = ntohs(phdr->param_type); 1165 error_len = ntohs(phdr->param_length); 1166 if ((error_len > chklen) || (error_len == 0)) { 1167 /* invalid param length for this param */ 1168 SCTPDBG(SCTP_DEBUG_INPUT1, "Bogus length in error param- chunk left:%d errorlen:%d\n", 1169 chklen, error_len); 1170 return (0); 1171 } 1172 if (error == 0) { 1173 /* report the first error cause */ 1174 error = error_type; 1175 } 1176 switch (error_type) { 1177 case SCTP_CAUSE_INVALID_STREAM: 1178 case SCTP_CAUSE_MISSING_PARAM: 1179 case SCTP_CAUSE_INVALID_PARAM: 1180 case SCTP_CAUSE_NO_USER_DATA: 1181 SCTPDBG(SCTP_DEBUG_INPUT1, "Software error we got a %d back? We have a bug :/ (or do they?)\n", 1182 error_type); 1183 break; 1184 case SCTP_CAUSE_NAT_COLLIDING_STATE: 1185 SCTPDBG(SCTP_DEBUG_INPUT2, "Received Colliding state abort flags:%x\n", 1186 ch->chunk_flags); 1187 if (sctp_handle_nat_colliding_state(stcb)) { 1188 return (0); 1189 } 1190 break; 1191 case SCTP_CAUSE_NAT_MISSING_STATE: 1192 SCTPDBG(SCTP_DEBUG_INPUT2, "Received missing state abort flags:%x\n", 1193 ch->chunk_flags); 1194 if (sctp_handle_nat_missing_state(stcb, net)) { 1195 return (0); 1196 } 1197 break; 1198 case SCTP_CAUSE_STALE_COOKIE: 1199 /* 1200 * We only act if we have echoed a cookie and are 1201 * waiting. 1202 */ 1203 if (SCTP_GET_STATE(asoc) == SCTP_STATE_COOKIE_ECHOED) { 1204 int *p; 1205 1206 p = (int *)((caddr_t)phdr + sizeof(*phdr)); 1207 /* Save the time doubled */ 1208 asoc->cookie_preserve_req = ntohl(*p) << 1; 1209 asoc->stale_cookie_count++; 1210 if (asoc->stale_cookie_count > 1211 asoc->max_init_times) { 1212 sctp_abort_notification(stcb, 0, 0, NULL, SCTP_SO_NOT_LOCKED); 1213 /* now free the asoc */ 1214#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 1215 so = SCTP_INP_SO(stcb->sctp_ep); 1216 atomic_add_int(&stcb->asoc.refcnt, 1); 1217 SCTP_TCB_UNLOCK(stcb); 1218 SCTP_SOCKET_LOCK(so, 1); 1219 SCTP_TCB_LOCK(stcb); 1220 atomic_subtract_int(&stcb->asoc.refcnt, 1); 1221#endif 1222 (void)sctp_free_assoc(stcb->sctp_ep, stcb, SCTP_NORMAL_PROC, 1223 SCTP_FROM_SCTP_INPUT + SCTP_LOC_12); 1224#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 1225 SCTP_SOCKET_UNLOCK(so, 1); 1226#endif 1227 return (-1); 1228 } 1229 /* blast back to INIT state */ 1230 sctp_toss_old_cookies(stcb, &stcb->asoc); 1231 asoc->state &= ~SCTP_STATE_COOKIE_ECHOED; 1232 asoc->state |= SCTP_STATE_COOKIE_WAIT; 1233 sctp_stop_all_cookie_timers(stcb); 1234 sctp_send_initiate(stcb->sctp_ep, stcb, SCTP_SO_NOT_LOCKED); 1235 } 1236 break; 1237 case SCTP_CAUSE_UNRESOLVABLE_ADDR: 1238 /* 1239 * Nothing we can do here, we don't do hostname 1240 * addresses so if the peer does not like my IPv6 1241 * (or IPv4 for that matter) it does not matter. If 1242 * they don't support that type of address, they can 1243 * NOT possibly get that packet type... i.e. with no 1244 * IPv6 you can't recieve a IPv6 packet. so we can 1245 * safely ignore this one. If we ever added support 1246 * for HOSTNAME Addresses, then we would need to do 1247 * something here. 1248 */ 1249 break; 1250 case SCTP_CAUSE_UNRECOG_CHUNK: 1251 sctp_process_unrecog_chunk(stcb, phdr, net); 1252 break; 1253 case SCTP_CAUSE_UNRECOG_PARAM: 1254 sctp_process_unrecog_param(stcb, phdr); 1255 break; 1256 case SCTP_CAUSE_COOKIE_IN_SHUTDOWN: 1257 /* 1258 * We ignore this since the timer will drive out a 1259 * new cookie anyway and there timer will drive us 1260 * to send a SHUTDOWN_COMPLETE. We can't send one 1261 * here since we don't have their tag. 1262 */ 1263 break; 1264 case SCTP_CAUSE_DELETING_LAST_ADDR: 1265 case SCTP_CAUSE_RESOURCE_SHORTAGE: 1266 case SCTP_CAUSE_DELETING_SRC_ADDR: 1267 /* 1268 * We should NOT get these here, but in a 1269 * ASCONF-ACK. 1270 */ 1271 SCTPDBG(SCTP_DEBUG_INPUT2, "Peer sends ASCONF errors in a Operational Error?<%d>?\n", 1272 error_type); 1273 break; 1274 case SCTP_CAUSE_OUT_OF_RESC: 1275 /* 1276 * And what, pray tell do we do with the fact that 1277 * the peer is out of resources? Not really sure we 1278 * could do anything but abort. I suspect this 1279 * should have came WITH an abort instead of in a 1280 * OP-ERROR. 1281 */ 1282 break; 1283 default: 1284 SCTPDBG(SCTP_DEBUG_INPUT1, "sctp_handle_error: unknown error type = 0x%xh\n", 1285 error_type); 1286 break; 1287 } 1288 adjust = SCTP_SIZE32(error_len); 1289 chklen -= adjust; 1290 phdr = (struct sctp_paramhdr *)((caddr_t)phdr + adjust); 1291 } 1292 sctp_ulp_notify(SCTP_NOTIFY_REMOTE_ERROR, stcb, error, ch, SCTP_SO_NOT_LOCKED); 1293 return (0); 1294} 1295 1296static int 1297sctp_handle_init_ack(struct mbuf *m, int iphlen, int offset, 1298 struct sockaddr *src, struct sockaddr *dst, struct sctphdr *sh, 1299 struct sctp_init_ack_chunk *cp, struct sctp_tcb *stcb, 1300 struct sctp_nets *net, int *abort_no_unlock, 1301 uint8_t mflowtype, uint32_t mflowid, 1302 uint32_t vrf_id) 1303{ 1304 struct sctp_init_ack *init_ack; 1305 struct mbuf *op_err; 1306 1307 SCTPDBG(SCTP_DEBUG_INPUT2, 1308 "sctp_handle_init_ack: handling INIT-ACK\n"); 1309 1310 if (stcb == NULL) { 1311 SCTPDBG(SCTP_DEBUG_INPUT2, 1312 "sctp_handle_init_ack: TCB is null\n"); 1313 return (-1); 1314 } 1315 if (ntohs(cp->ch.chunk_length) < sizeof(struct sctp_init_ack_chunk)) { 1316 /* Invalid length */ 1317 op_err = sctp_generate_cause(SCTP_CAUSE_INVALID_PARAM, ""); 1318 sctp_abort_association(stcb->sctp_ep, stcb, m, iphlen, 1319 src, dst, sh, op_err, 1320 mflowtype, mflowid, 1321 vrf_id, net->port); 1322 *abort_no_unlock = 1; 1323 return (-1); 1324 } 1325 init_ack = &cp->init; 1326 /* validate parameters */ 1327 if (init_ack->initiate_tag == 0) { 1328 /* protocol error... send an abort */ 1329 op_err = sctp_generate_cause(SCTP_CAUSE_INVALID_PARAM, ""); 1330 sctp_abort_association(stcb->sctp_ep, stcb, m, iphlen, 1331 src, dst, sh, op_err, 1332 mflowtype, mflowid, 1333 vrf_id, net->port); 1334 *abort_no_unlock = 1; 1335 return (-1); 1336 } 1337 if (ntohl(init_ack->a_rwnd) < SCTP_MIN_RWND) { 1338 /* protocol error... send an abort */ 1339 op_err = sctp_generate_cause(SCTP_CAUSE_INVALID_PARAM, ""); 1340 sctp_abort_association(stcb->sctp_ep, stcb, m, iphlen, 1341 src, dst, sh, op_err, 1342 mflowtype, mflowid, 1343 vrf_id, net->port); 1344 *abort_no_unlock = 1; 1345 return (-1); 1346 } 1347 if (init_ack->num_inbound_streams == 0) { 1348 /* protocol error... send an abort */ 1349 op_err = sctp_generate_cause(SCTP_CAUSE_INVALID_PARAM, ""); 1350 sctp_abort_association(stcb->sctp_ep, stcb, m, iphlen, 1351 src, dst, sh, op_err, 1352 mflowtype, mflowid, 1353 vrf_id, net->port); 1354 *abort_no_unlock = 1; 1355 return (-1); 1356 } 1357 if (init_ack->num_outbound_streams == 0) { 1358 /* protocol error... send an abort */ 1359 op_err = sctp_generate_cause(SCTP_CAUSE_INVALID_PARAM, ""); 1360 sctp_abort_association(stcb->sctp_ep, stcb, m, iphlen, 1361 src, dst, sh, op_err, 1362 mflowtype, mflowid, 1363 vrf_id, net->port); 1364 *abort_no_unlock = 1; 1365 return (-1); 1366 } 1367 /* process according to association state... */ 1368 switch (stcb->asoc.state & SCTP_STATE_MASK) { 1369 case SCTP_STATE_COOKIE_WAIT: 1370 /* this is the expected state for this chunk */ 1371 /* process the INIT-ACK parameters */ 1372 if (stcb->asoc.primary_destination->dest_state & 1373 SCTP_ADDR_UNCONFIRMED) { 1374 /* 1375 * The primary is where we sent the INIT, we can 1376 * always consider it confirmed when the INIT-ACK is 1377 * returned. Do this before we load addresses 1378 * though. 1379 */ 1380 stcb->asoc.primary_destination->dest_state &= 1381 ~SCTP_ADDR_UNCONFIRMED; 1382 sctp_ulp_notify(SCTP_NOTIFY_INTERFACE_CONFIRMED, 1383 stcb, 0, (void *)stcb->asoc.primary_destination, SCTP_SO_NOT_LOCKED); 1384 } 1385 if (sctp_process_init_ack(m, iphlen, offset, src, dst, sh, cp, stcb, 1386 net, abort_no_unlock, 1387 mflowtype, mflowid, 1388 vrf_id) < 0) { 1389 /* error in parsing parameters */ 1390 return (-1); 1391 } 1392 /* update our state */ 1393 SCTPDBG(SCTP_DEBUG_INPUT2, "moving to COOKIE-ECHOED state\n"); 1394 SCTP_SET_STATE(&stcb->asoc, SCTP_STATE_COOKIE_ECHOED); 1395 1396 /* reset the RTO calc */ 1397 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_THRESHOLD_LOGGING) { 1398 sctp_misc_ints(SCTP_THRESHOLD_CLEAR, 1399 stcb->asoc.overall_error_count, 1400 0, 1401 SCTP_FROM_SCTP_INPUT, 1402 __LINE__); 1403 } 1404 stcb->asoc.overall_error_count = 0; 1405 (void)SCTP_GETTIME_TIMEVAL(&stcb->asoc.time_entered); 1406 /* 1407 * collapse the init timer back in case of a exponential 1408 * backoff 1409 */ 1410 sctp_timer_start(SCTP_TIMER_TYPE_COOKIE, stcb->sctp_ep, 1411 stcb, net); 1412 /* 1413 * the send at the end of the inbound data processing will 1414 * cause the cookie to be sent 1415 */ 1416 break; 1417 case SCTP_STATE_SHUTDOWN_SENT: 1418 /* incorrect state... discard */ 1419 break; 1420 case SCTP_STATE_COOKIE_ECHOED: 1421 /* incorrect state... discard */ 1422 break; 1423 case SCTP_STATE_OPEN: 1424 /* incorrect state... discard */ 1425 break; 1426 case SCTP_STATE_EMPTY: 1427 case SCTP_STATE_INUSE: 1428 default: 1429 /* incorrect state... discard */ 1430 return (-1); 1431 break; 1432 } 1433 SCTPDBG(SCTP_DEBUG_INPUT1, "Leaving handle-init-ack end\n"); 1434 return (0); 1435} 1436 1437static struct sctp_tcb * 1438sctp_process_cookie_new(struct mbuf *m, int iphlen, int offset, 1439 struct sockaddr *src, struct sockaddr *dst, 1440 struct sctphdr *sh, struct sctp_state_cookie *cookie, int cookie_len, 1441 struct sctp_inpcb *inp, struct sctp_nets **netp, 1442 struct sockaddr *init_src, int *notification, 1443 int auth_skipped, uint32_t auth_offset, uint32_t auth_len, 1444 uint8_t mflowtype, uint32_t mflowid, 1445 uint32_t vrf_id, uint16_t port); 1446 1447 1448/* 1449 * handle a state cookie for an existing association m: input packet mbuf 1450 * chain-- assumes a pullup on IP/SCTP/COOKIE-ECHO chunk note: this is a 1451 * "split" mbuf and the cookie signature does not exist offset: offset into 1452 * mbuf to the cookie-echo chunk 1453 */ 1454static struct sctp_tcb * 1455sctp_process_cookie_existing(struct mbuf *m, int iphlen, int offset, 1456 struct sockaddr *src, struct sockaddr *dst, 1457 struct sctphdr *sh, struct sctp_state_cookie *cookie, int cookie_len, 1458 struct sctp_inpcb *inp, struct sctp_tcb *stcb, struct sctp_nets **netp, 1459 struct sockaddr *init_src, int *notification, 1460 int auth_skipped, uint32_t auth_offset, uint32_t auth_len, 1461 uint8_t mflowtype, uint32_t mflowid, 1462 uint32_t vrf_id, uint16_t port) 1463{ 1464 struct sctp_association *asoc; 1465 struct sctp_init_chunk *init_cp, init_buf; 1466 struct sctp_init_ack_chunk *initack_cp, initack_buf; 1467 struct sctp_nets *net; 1468 struct mbuf *op_err; 1469 int init_offset, initack_offset, i; 1470 int retval; 1471 int spec_flag = 0; 1472 uint32_t how_indx; 1473 1474#if defined(SCTP_DETAILED_STR_STATS) 1475 int j; 1476 1477#endif 1478 1479 net = *netp; 1480 /* I know that the TCB is non-NULL from the caller */ 1481 asoc = &stcb->asoc; 1482 for (how_indx = 0; how_indx < sizeof(asoc->cookie_how); how_indx++) { 1483 if (asoc->cookie_how[how_indx] == 0) 1484 break; 1485 } 1486 if (how_indx < sizeof(asoc->cookie_how)) { 1487 asoc->cookie_how[how_indx] = 1; 1488 } 1489 if (SCTP_GET_STATE(asoc) == SCTP_STATE_SHUTDOWN_ACK_SENT) { 1490 /* SHUTDOWN came in after sending INIT-ACK */ 1491 sctp_send_shutdown_ack(stcb, stcb->asoc.primary_destination); 1492 op_err = sctp_generate_cause(SCTP_CAUSE_COOKIE_IN_SHUTDOWN, ""); 1493 sctp_send_operr_to(src, dst, sh, cookie->peers_vtag, op_err, 1494 mflowtype, mflowid, inp->fibnum, 1495 vrf_id, net->port); 1496 if (how_indx < sizeof(asoc->cookie_how)) 1497 asoc->cookie_how[how_indx] = 2; 1498 return (NULL); 1499 } 1500 /* 1501 * find and validate the INIT chunk in the cookie (peer's info) the 1502 * INIT should start after the cookie-echo header struct (chunk 1503 * header, state cookie header struct) 1504 */ 1505 init_offset = offset += sizeof(struct sctp_cookie_echo_chunk); 1506 1507 init_cp = (struct sctp_init_chunk *) 1508 sctp_m_getptr(m, init_offset, sizeof(struct sctp_init_chunk), 1509 (uint8_t *) & init_buf); 1510 if (init_cp == NULL) { 1511 /* could not pull a INIT chunk in cookie */ 1512 return (NULL); 1513 } 1514 if (init_cp->ch.chunk_type != SCTP_INITIATION) { 1515 return (NULL); 1516 } 1517 /* 1518 * find and validate the INIT-ACK chunk in the cookie (my info) the 1519 * INIT-ACK follows the INIT chunk 1520 */ 1521 initack_offset = init_offset + SCTP_SIZE32(ntohs(init_cp->ch.chunk_length)); 1522 initack_cp = (struct sctp_init_ack_chunk *) 1523 sctp_m_getptr(m, initack_offset, sizeof(struct sctp_init_ack_chunk), 1524 (uint8_t *) & initack_buf); 1525 if (initack_cp == NULL) { 1526 /* could not pull INIT-ACK chunk in cookie */ 1527 return (NULL); 1528 } 1529 if (initack_cp->ch.chunk_type != SCTP_INITIATION_ACK) { 1530 return (NULL); 1531 } 1532 if ((ntohl(initack_cp->init.initiate_tag) == asoc->my_vtag) && 1533 (ntohl(init_cp->init.initiate_tag) == asoc->peer_vtag)) { 1534 /* 1535 * case D in Section 5.2.4 Table 2: MMAA process accordingly 1536 * to get into the OPEN state 1537 */ 1538 if (ntohl(initack_cp->init.initial_tsn) != asoc->init_seq_number) { 1539 /*- 1540 * Opps, this means that we somehow generated two vtag's 1541 * the same. I.e. we did: 1542 * Us Peer 1543 * <---INIT(tag=a)------ 1544 * ----INIT-ACK(tag=t)--> 1545 * ----INIT(tag=t)------> *1 1546 * <---INIT-ACK(tag=a)--- 1547 * <----CE(tag=t)------------- *2 1548 * 1549 * At point *1 we should be generating a different 1550 * tag t'. Which means we would throw away the CE and send 1551 * ours instead. Basically this is case C (throw away side). 1552 */ 1553 if (how_indx < sizeof(asoc->cookie_how)) 1554 asoc->cookie_how[how_indx] = 17; 1555 return (NULL); 1556 1557 } 1558 switch (SCTP_GET_STATE(asoc)) { 1559 case SCTP_STATE_COOKIE_WAIT: 1560 case SCTP_STATE_COOKIE_ECHOED: 1561 /* 1562 * INIT was sent but got a COOKIE_ECHO with the 1563 * correct tags... just accept it...but we must 1564 * process the init so that we can make sure we have 1565 * the right seq no's. 1566 */ 1567 /* First we must process the INIT !! */ 1568 retval = sctp_process_init(init_cp, stcb); 1569 if (retval < 0) { 1570 if (how_indx < sizeof(asoc->cookie_how)) 1571 asoc->cookie_how[how_indx] = 3; 1572 return (NULL); 1573 } 1574 /* we have already processed the INIT so no problem */ 1575 sctp_timer_stop(SCTP_TIMER_TYPE_HEARTBEAT, inp, 1576 stcb, net, 1577 SCTP_FROM_SCTP_INPUT + SCTP_LOC_13); 1578 sctp_timer_stop(SCTP_TIMER_TYPE_INIT, inp, 1579 stcb, net, 1580 SCTP_FROM_SCTP_INPUT + SCTP_LOC_14); 1581 /* update current state */ 1582 if (SCTP_GET_STATE(asoc) == SCTP_STATE_COOKIE_ECHOED) 1583 SCTP_STAT_INCR_COUNTER32(sctps_activeestab); 1584 else 1585 SCTP_STAT_INCR_COUNTER32(sctps_collisionestab); 1586 1587 SCTP_SET_STATE(asoc, SCTP_STATE_OPEN); 1588 if (asoc->state & SCTP_STATE_SHUTDOWN_PENDING) { 1589 sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWNGUARD, 1590 stcb->sctp_ep, stcb, asoc->primary_destination); 1591 } 1592 SCTP_STAT_INCR_GAUGE32(sctps_currestab); 1593 sctp_stop_all_cookie_timers(stcb); 1594 if (((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) || 1595 (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL)) && 1596 (inp->sctp_socket->so_qlimit == 0) 1597 ) { 1598#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 1599 struct socket *so; 1600 1601#endif 1602 /* 1603 * Here is where collision would go if we 1604 * did a connect() and instead got a 1605 * init/init-ack/cookie done before the 1606 * init-ack came back.. 1607 */ 1608 stcb->sctp_ep->sctp_flags |= 1609 SCTP_PCB_FLAGS_CONNECTED; 1610#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 1611 so = SCTP_INP_SO(stcb->sctp_ep); 1612 atomic_add_int(&stcb->asoc.refcnt, 1); 1613 SCTP_TCB_UNLOCK(stcb); 1614 SCTP_SOCKET_LOCK(so, 1); 1615 SCTP_TCB_LOCK(stcb); 1616 atomic_add_int(&stcb->asoc.refcnt, -1); 1617 if (stcb->asoc.state & SCTP_STATE_CLOSED_SOCKET) { 1618 SCTP_SOCKET_UNLOCK(so, 1); 1619 return (NULL); 1620 } 1621#endif 1622 soisconnected(stcb->sctp_socket); 1623#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 1624 SCTP_SOCKET_UNLOCK(so, 1); 1625#endif 1626 } 1627 /* notify upper layer */ 1628 *notification = SCTP_NOTIFY_ASSOC_UP; 1629 /* 1630 * since we did not send a HB make sure we don't 1631 * double things 1632 */ 1633 net->hb_responded = 1; 1634 net->RTO = sctp_calculate_rto(stcb, asoc, net, 1635 &cookie->time_entered, 1636 sctp_align_unsafe_makecopy, 1637 SCTP_RTT_FROM_NON_DATA); 1638 1639 if (stcb->asoc.sctp_autoclose_ticks && 1640 (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_AUTOCLOSE))) { 1641 sctp_timer_start(SCTP_TIMER_TYPE_AUTOCLOSE, 1642 inp, stcb, NULL); 1643 } 1644 break; 1645 default: 1646 /* 1647 * we're in the OPEN state (or beyond), so peer must 1648 * have simply lost the COOKIE-ACK 1649 */ 1650 break; 1651 } /* end switch */ 1652 sctp_stop_all_cookie_timers(stcb); 1653 /* 1654 * We ignore the return code here.. not sure if we should 1655 * somehow abort.. but we do have an existing asoc. This 1656 * really should not fail. 1657 */ 1658 if (sctp_load_addresses_from_init(stcb, m, 1659 init_offset + sizeof(struct sctp_init_chunk), 1660 initack_offset, src, dst, init_src)) { 1661 if (how_indx < sizeof(asoc->cookie_how)) 1662 asoc->cookie_how[how_indx] = 4; 1663 return (NULL); 1664 } 1665 /* respond with a COOKIE-ACK */ 1666 sctp_toss_old_cookies(stcb, asoc); 1667 sctp_send_cookie_ack(stcb); 1668 if (how_indx < sizeof(asoc->cookie_how)) 1669 asoc->cookie_how[how_indx] = 5; 1670 return (stcb); 1671 } 1672 if (ntohl(initack_cp->init.initiate_tag) != asoc->my_vtag && 1673 ntohl(init_cp->init.initiate_tag) == asoc->peer_vtag && 1674 cookie->tie_tag_my_vtag == 0 && 1675 cookie->tie_tag_peer_vtag == 0) { 1676 /* 1677 * case C in Section 5.2.4 Table 2: XMOO silently discard 1678 */ 1679 if (how_indx < sizeof(asoc->cookie_how)) 1680 asoc->cookie_how[how_indx] = 6; 1681 return (NULL); 1682 } 1683 /* 1684 * If nat support, and the below and stcb is established, send back 1685 * a ABORT(colliding state) if we are established. 1686 */ 1687 if ((SCTP_GET_STATE(asoc) == SCTP_STATE_OPEN) && 1688 (asoc->peer_supports_nat) && 1689 ((ntohl(initack_cp->init.initiate_tag) == asoc->my_vtag) && 1690 ((ntohl(init_cp->init.initiate_tag) != asoc->peer_vtag) || 1691 (asoc->peer_vtag == 0)))) { 1692 /* 1693 * Special case - Peer's support nat. We may have two init's 1694 * that we gave out the same tag on since one was not 1695 * established.. i.e. we get INIT from host-1 behind the nat 1696 * and we respond tag-a, we get a INIT from host-2 behind 1697 * the nat and we get tag-a again. Then we bring up host-1 1698 * (or 2's) assoc, Then comes the cookie from hsot-2 (or 1). 1699 * Now we have colliding state. We must send an abort here 1700 * with colliding state indication. 1701 */ 1702 op_err = sctp_generate_cause(SCTP_CAUSE_NAT_COLLIDING_STATE, ""); 1703 sctp_send_abort(m, iphlen, src, dst, sh, 0, op_err, 1704 mflowtype, mflowid, inp->fibnum, 1705 vrf_id, port); 1706 return (NULL); 1707 } 1708 if ((ntohl(initack_cp->init.initiate_tag) == asoc->my_vtag) && 1709 ((ntohl(init_cp->init.initiate_tag) != asoc->peer_vtag) || 1710 (asoc->peer_vtag == 0))) { 1711 /* 1712 * case B in Section 5.2.4 Table 2: MXAA or MOAA my info 1713 * should be ok, re-accept peer info 1714 */ 1715 if (ntohl(initack_cp->init.initial_tsn) != asoc->init_seq_number) { 1716 /* 1717 * Extension of case C. If we hit this, then the 1718 * random number generator returned the same vtag 1719 * when we first sent our INIT-ACK and when we later 1720 * sent our INIT. The side with the seq numbers that 1721 * are different will be the one that normnally 1722 * would have hit case C. This in effect "extends" 1723 * our vtags in this collision case to be 64 bits. 1724 * The same collision could occur aka you get both 1725 * vtag and seq number the same twice in a row.. but 1726 * is much less likely. If it did happen then we 1727 * would proceed through and bring up the assoc.. we 1728 * may end up with the wrong stream setup however.. 1729 * which would be bad.. but there is no way to 1730 * tell.. until we send on a stream that does not 1731 * exist :-) 1732 */ 1733 if (how_indx < sizeof(asoc->cookie_how)) 1734 asoc->cookie_how[how_indx] = 7; 1735 1736 return (NULL); 1737 } 1738 if (how_indx < sizeof(asoc->cookie_how)) 1739 asoc->cookie_how[how_indx] = 8; 1740 sctp_timer_stop(SCTP_TIMER_TYPE_HEARTBEAT, inp, stcb, net, 1741 SCTP_FROM_SCTP_INPUT + SCTP_LOC_15); 1742 sctp_stop_all_cookie_timers(stcb); 1743 /* 1744 * since we did not send a HB make sure we don't double 1745 * things 1746 */ 1747 net->hb_responded = 1; 1748 if (stcb->asoc.sctp_autoclose_ticks && 1749 sctp_is_feature_on(inp, SCTP_PCB_FLAGS_AUTOCLOSE)) { 1750 sctp_timer_start(SCTP_TIMER_TYPE_AUTOCLOSE, inp, stcb, 1751 NULL); 1752 } 1753 asoc->my_rwnd = ntohl(initack_cp->init.a_rwnd); 1754 asoc->pre_open_streams = ntohs(initack_cp->init.num_outbound_streams); 1755 1756 if (ntohl(init_cp->init.initiate_tag) != asoc->peer_vtag) { 1757 /* 1758 * Ok the peer probably discarded our data (if we 1759 * echoed a cookie+data). So anything on the 1760 * sent_queue should be marked for retransmit, we 1761 * may not get something to kick us so it COULD 1762 * still take a timeout to move these.. but it can't 1763 * hurt to mark them. 1764 */ 1765 struct sctp_tmit_chunk *chk; 1766 1767 TAILQ_FOREACH(chk, &stcb->asoc.sent_queue, sctp_next) { 1768 if (chk->sent < SCTP_DATAGRAM_RESEND) { 1769 chk->sent = SCTP_DATAGRAM_RESEND; 1770 sctp_flight_size_decrease(chk); 1771 sctp_total_flight_decrease(stcb, chk); 1772 sctp_ucount_incr(stcb->asoc.sent_queue_retran_cnt); 1773 spec_flag++; 1774 } 1775 } 1776 1777 } 1778 /* process the INIT info (peer's info) */ 1779 retval = sctp_process_init(init_cp, stcb); 1780 if (retval < 0) { 1781 if (how_indx < sizeof(asoc->cookie_how)) 1782 asoc->cookie_how[how_indx] = 9; 1783 return (NULL); 1784 } 1785 if (sctp_load_addresses_from_init(stcb, m, 1786 init_offset + sizeof(struct sctp_init_chunk), 1787 initack_offset, src, dst, init_src)) { 1788 if (how_indx < sizeof(asoc->cookie_how)) 1789 asoc->cookie_how[how_indx] = 10; 1790 return (NULL); 1791 } 1792 if ((asoc->state & SCTP_STATE_COOKIE_WAIT) || 1793 (asoc->state & SCTP_STATE_COOKIE_ECHOED)) { 1794 *notification = SCTP_NOTIFY_ASSOC_UP; 1795 1796 if (((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) || 1797 (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL)) && 1798 (inp->sctp_socket->so_qlimit == 0)) { 1799#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 1800 struct socket *so; 1801 1802#endif 1803 stcb->sctp_ep->sctp_flags |= 1804 SCTP_PCB_FLAGS_CONNECTED; 1805#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 1806 so = SCTP_INP_SO(stcb->sctp_ep); 1807 atomic_add_int(&stcb->asoc.refcnt, 1); 1808 SCTP_TCB_UNLOCK(stcb); 1809 SCTP_SOCKET_LOCK(so, 1); 1810 SCTP_TCB_LOCK(stcb); 1811 atomic_add_int(&stcb->asoc.refcnt, -1); 1812 if (stcb->asoc.state & SCTP_STATE_CLOSED_SOCKET) { 1813 SCTP_SOCKET_UNLOCK(so, 1); 1814 return (NULL); 1815 } 1816#endif 1817 soisconnected(stcb->sctp_socket); 1818#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 1819 SCTP_SOCKET_UNLOCK(so, 1); 1820#endif 1821 } 1822 if (SCTP_GET_STATE(asoc) == SCTP_STATE_COOKIE_ECHOED) 1823 SCTP_STAT_INCR_COUNTER32(sctps_activeestab); 1824 else 1825 SCTP_STAT_INCR_COUNTER32(sctps_collisionestab); 1826 SCTP_STAT_INCR_GAUGE32(sctps_currestab); 1827 } else if (SCTP_GET_STATE(asoc) == SCTP_STATE_OPEN) { 1828 SCTP_STAT_INCR_COUNTER32(sctps_restartestab); 1829 } else { 1830 SCTP_STAT_INCR_COUNTER32(sctps_collisionestab); 1831 } 1832 SCTP_SET_STATE(asoc, SCTP_STATE_OPEN); 1833 if (asoc->state & SCTP_STATE_SHUTDOWN_PENDING) { 1834 sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWNGUARD, 1835 stcb->sctp_ep, stcb, asoc->primary_destination); 1836 } 1837 sctp_stop_all_cookie_timers(stcb); 1838 sctp_toss_old_cookies(stcb, asoc); 1839 sctp_send_cookie_ack(stcb); 1840 if (spec_flag) { 1841 /* 1842 * only if we have retrans set do we do this. What 1843 * this call does is get only the COOKIE-ACK out and 1844 * then when we return the normal call to 1845 * sctp_chunk_output will get the retrans out behind 1846 * this. 1847 */ 1848 sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_COOKIE_ACK, SCTP_SO_NOT_LOCKED); 1849 } 1850 if (how_indx < sizeof(asoc->cookie_how)) 1851 asoc->cookie_how[how_indx] = 11; 1852 1853 return (stcb); 1854 } 1855 if ((ntohl(initack_cp->init.initiate_tag) != asoc->my_vtag && 1856 ntohl(init_cp->init.initiate_tag) != asoc->peer_vtag) && 1857 cookie->tie_tag_my_vtag == asoc->my_vtag_nonce && 1858 cookie->tie_tag_peer_vtag == asoc->peer_vtag_nonce && 1859 cookie->tie_tag_peer_vtag != 0) { 1860 struct sctpasochead *head; 1861 1862#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 1863 struct socket *so; 1864 1865#endif 1866 1867 if (asoc->peer_supports_nat) { 1868 /* 1869 * This is a gross gross hack. Just call the 1870 * cookie_new code since we are allowing a duplicate 1871 * association. I hope this works... 1872 */ 1873 return (sctp_process_cookie_new(m, iphlen, offset, src, dst, 1874 sh, cookie, cookie_len, 1875 inp, netp, init_src, notification, 1876 auth_skipped, auth_offset, auth_len, 1877 mflowtype, mflowid, 1878 vrf_id, port)); 1879 } 1880 /* 1881 * case A in Section 5.2.4 Table 2: XXMM (peer restarted) 1882 */ 1883 /* temp code */ 1884 if (how_indx < sizeof(asoc->cookie_how)) 1885 asoc->cookie_how[how_indx] = 12; 1886 sctp_timer_stop(SCTP_TIMER_TYPE_INIT, inp, stcb, net, 1887 SCTP_FROM_SCTP_INPUT + SCTP_LOC_16); 1888 sctp_timer_stop(SCTP_TIMER_TYPE_HEARTBEAT, inp, stcb, net, 1889 SCTP_FROM_SCTP_INPUT + SCTP_LOC_17); 1890 1891 /* notify upper layer */ 1892 *notification = SCTP_NOTIFY_ASSOC_RESTART; 1893 atomic_add_int(&stcb->asoc.refcnt, 1); 1894 if ((SCTP_GET_STATE(asoc) != SCTP_STATE_OPEN) && 1895 (SCTP_GET_STATE(asoc) != SCTP_STATE_SHUTDOWN_RECEIVED) && 1896 (SCTP_GET_STATE(asoc) != SCTP_STATE_SHUTDOWN_SENT)) { 1897 SCTP_STAT_INCR_GAUGE32(sctps_currestab); 1898 } 1899 if (SCTP_GET_STATE(asoc) == SCTP_STATE_OPEN) { 1900 SCTP_STAT_INCR_GAUGE32(sctps_restartestab); 1901 } else if (SCTP_GET_STATE(asoc) != SCTP_STATE_SHUTDOWN_SENT) { 1902 SCTP_STAT_INCR_GAUGE32(sctps_collisionestab); 1903 } 1904 if (asoc->state & SCTP_STATE_SHUTDOWN_PENDING) { 1905 SCTP_SET_STATE(asoc, SCTP_STATE_OPEN); 1906 sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWNGUARD, 1907 stcb->sctp_ep, stcb, asoc->primary_destination); 1908 1909 } else if (!(asoc->state & SCTP_STATE_SHUTDOWN_SENT)) { 1910 /* move to OPEN state, if not in SHUTDOWN_SENT */ 1911 SCTP_SET_STATE(asoc, SCTP_STATE_OPEN); 1912 } 1913 asoc->pre_open_streams = 1914 ntohs(initack_cp->init.num_outbound_streams); 1915 asoc->init_seq_number = ntohl(initack_cp->init.initial_tsn); 1916 asoc->sending_seq = asoc->asconf_seq_out = asoc->str_reset_seq_out = asoc->init_seq_number; 1917 asoc->asconf_seq_out_acked = asoc->asconf_seq_out - 1; 1918 1919 asoc->asconf_seq_in = asoc->last_acked_seq = asoc->init_seq_number - 1; 1920 1921 asoc->str_reset_seq_in = asoc->init_seq_number; 1922 1923 asoc->advanced_peer_ack_point = asoc->last_acked_seq; 1924 if (asoc->mapping_array) { 1925 memset(asoc->mapping_array, 0, 1926 asoc->mapping_array_size); 1927 } 1928 if (asoc->nr_mapping_array) { 1929 memset(asoc->nr_mapping_array, 0, 1930 asoc->mapping_array_size); 1931 } 1932 SCTP_TCB_UNLOCK(stcb); 1933#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 1934 so = SCTP_INP_SO(stcb->sctp_ep); 1935 SCTP_SOCKET_LOCK(so, 1); 1936#endif 1937 SCTP_INP_INFO_WLOCK(); 1938 SCTP_INP_WLOCK(stcb->sctp_ep); 1939 SCTP_TCB_LOCK(stcb); 1940 atomic_add_int(&stcb->asoc.refcnt, -1); 1941 /* send up all the data */ 1942 SCTP_TCB_SEND_LOCK(stcb); 1943 1944 sctp_report_all_outbound(stcb, 0, 1, SCTP_SO_LOCKED); 1945 for (i = 0; i < stcb->asoc.streamoutcnt; i++) { 1946 stcb->asoc.strmout[i].chunks_on_queues = 0; 1947#if defined(SCTP_DETAILED_STR_STATS) 1948 for (j = 0; j < SCTP_PR_SCTP_MAX + 1; j++) { 1949 asoc->strmout[i].abandoned_sent[j] = 0; 1950 asoc->strmout[i].abandoned_unsent[j] = 0; 1951 } 1952#else 1953 asoc->strmout[i].abandoned_sent[0] = 0; 1954 asoc->strmout[i].abandoned_unsent[0] = 0; 1955#endif 1956 stcb->asoc.strmout[i].stream_no = i; 1957 stcb->asoc.strmout[i].next_sequence_send = 0; 1958 stcb->asoc.strmout[i].last_msg_incomplete = 0; 1959 } 1960 /* process the INIT-ACK info (my info) */ 1961 asoc->my_vtag = ntohl(initack_cp->init.initiate_tag); 1962 asoc->my_rwnd = ntohl(initack_cp->init.a_rwnd); 1963 1964 /* pull from vtag hash */ 1965 LIST_REMOVE(stcb, sctp_asocs); 1966 /* re-insert to new vtag position */ 1967 head = &SCTP_BASE_INFO(sctp_asochash)[SCTP_PCBHASH_ASOC(stcb->asoc.my_vtag, 1968 SCTP_BASE_INFO(hashasocmark))]; 1969 /* 1970 * put it in the bucket in the vtag hash of assoc's for the 1971 * system 1972 */ 1973 LIST_INSERT_HEAD(head, stcb, sctp_asocs); 1974 1975 SCTP_TCB_SEND_UNLOCK(stcb); 1976 SCTP_INP_WUNLOCK(stcb->sctp_ep); 1977 SCTP_INP_INFO_WUNLOCK(); 1978#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 1979 SCTP_SOCKET_UNLOCK(so, 1); 1980#endif 1981 asoc->total_flight = 0; 1982 asoc->total_flight_count = 0; 1983 /* process the INIT info (peer's info) */ 1984 retval = sctp_process_init(init_cp, stcb); 1985 if (retval < 0) { 1986 if (how_indx < sizeof(asoc->cookie_how)) 1987 asoc->cookie_how[how_indx] = 13; 1988 1989 return (NULL); 1990 } 1991 /* 1992 * since we did not send a HB make sure we don't double 1993 * things 1994 */ 1995 net->hb_responded = 1; 1996 1997 if (sctp_load_addresses_from_init(stcb, m, 1998 init_offset + sizeof(struct sctp_init_chunk), 1999 initack_offset, src, dst, init_src)) { 2000 if (how_indx < sizeof(asoc->cookie_how)) 2001 asoc->cookie_how[how_indx] = 14; 2002 2003 return (NULL); 2004 } 2005 /* respond with a COOKIE-ACK */ 2006 sctp_stop_all_cookie_timers(stcb); 2007 sctp_toss_old_cookies(stcb, asoc); 2008 sctp_send_cookie_ack(stcb); 2009 if (how_indx < sizeof(asoc->cookie_how)) 2010 asoc->cookie_how[how_indx] = 15; 2011 2012 return (stcb); 2013 } 2014 if (how_indx < sizeof(asoc->cookie_how)) 2015 asoc->cookie_how[how_indx] = 16; 2016 /* all other cases... */ 2017 return (NULL); 2018} 2019 2020 2021/* 2022 * handle a state cookie for a new association m: input packet mbuf chain-- 2023 * assumes a pullup on IP/SCTP/COOKIE-ECHO chunk note: this is a "split" mbuf 2024 * and the cookie signature does not exist offset: offset into mbuf to the 2025 * cookie-echo chunk length: length of the cookie chunk to: where the init 2026 * was from returns a new TCB 2027 */ 2028static struct sctp_tcb * 2029sctp_process_cookie_new(struct mbuf *m, int iphlen, int offset, 2030 struct sockaddr *src, struct sockaddr *dst, 2031 struct sctphdr *sh, struct sctp_state_cookie *cookie, int cookie_len, 2032 struct sctp_inpcb *inp, struct sctp_nets **netp, 2033 struct sockaddr *init_src, int *notification, 2034 int auth_skipped, uint32_t auth_offset, uint32_t auth_len, 2035 uint8_t mflowtype, uint32_t mflowid, 2036 uint32_t vrf_id, uint16_t port) 2037{ 2038 struct sctp_tcb *stcb; 2039 struct sctp_init_chunk *init_cp, init_buf; 2040 struct sctp_init_ack_chunk *initack_cp, initack_buf; 2041 union sctp_sockstore store; 2042 struct sctp_association *asoc; 2043 int init_offset, initack_offset, initack_limit; 2044 int retval; 2045 int error = 0; 2046 uint8_t auth_chunk_buf[SCTP_PARAM_BUFFER_SIZE]; 2047 2048#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 2049 struct socket *so; 2050 2051 so = SCTP_INP_SO(inp); 2052#endif 2053 2054 /* 2055 * find and validate the INIT chunk in the cookie (peer's info) the 2056 * INIT should start after the cookie-echo header struct (chunk 2057 * header, state cookie header struct) 2058 */ 2059 init_offset = offset + sizeof(struct sctp_cookie_echo_chunk); 2060 init_cp = (struct sctp_init_chunk *) 2061 sctp_m_getptr(m, init_offset, sizeof(struct sctp_init_chunk), 2062 (uint8_t *) & init_buf); 2063 if (init_cp == NULL) { 2064 /* could not pull a INIT chunk in cookie */ 2065 SCTPDBG(SCTP_DEBUG_INPUT1, 2066 "process_cookie_new: could not pull INIT chunk hdr\n"); 2067 return (NULL); 2068 } 2069 if (init_cp->ch.chunk_type != SCTP_INITIATION) { 2070 SCTPDBG(SCTP_DEBUG_INPUT1, "HUH? process_cookie_new: could not find INIT chunk!\n"); 2071 return (NULL); 2072 } 2073 initack_offset = init_offset + SCTP_SIZE32(ntohs(init_cp->ch.chunk_length)); 2074 /* 2075 * find and validate the INIT-ACK chunk in the cookie (my info) the 2076 * INIT-ACK follows the INIT chunk 2077 */ 2078 initack_cp = (struct sctp_init_ack_chunk *) 2079 sctp_m_getptr(m, initack_offset, sizeof(struct sctp_init_ack_chunk), 2080 (uint8_t *) & initack_buf); 2081 if (initack_cp == NULL) { 2082 /* could not pull INIT-ACK chunk in cookie */ 2083 SCTPDBG(SCTP_DEBUG_INPUT1, "process_cookie_new: could not pull INIT-ACK chunk hdr\n"); 2084 return (NULL); 2085 } 2086 if (initack_cp->ch.chunk_type != SCTP_INITIATION_ACK) { 2087 return (NULL); 2088 } 2089 /* 2090 * NOTE: We can't use the INIT_ACK's chk_length to determine the 2091 * "initack_limit" value. This is because the chk_length field 2092 * includes the length of the cookie, but the cookie is omitted when 2093 * the INIT and INIT_ACK are tacked onto the cookie... 2094 */ 2095 initack_limit = offset + cookie_len; 2096 2097 /* 2098 * now that we know the INIT/INIT-ACK are in place, create a new TCB 2099 * and popluate 2100 */ 2101 2102 /* 2103 * Here we do a trick, we set in NULL for the proc/thread argument. 2104 * We do this since in effect we only use the p argument when the 2105 * socket is unbound and we must do an implicit bind. Since we are 2106 * getting a cookie, we cannot be unbound. 2107 */ 2108 stcb = sctp_aloc_assoc(inp, init_src, &error, 2109 ntohl(initack_cp->init.initiate_tag), vrf_id, 2110 ntohs(initack_cp->init.num_outbound_streams), 2111 (struct thread *)NULL 2112 ); 2113 if (stcb == NULL) { 2114 struct mbuf *op_err; 2115 2116 /* memory problem? */ 2117 SCTPDBG(SCTP_DEBUG_INPUT1, 2118 "process_cookie_new: no room for another TCB!\n"); 2119 op_err = sctp_generate_cause(SCTP_CAUSE_OUT_OF_RESC, ""); 2120 sctp_abort_association(inp, (struct sctp_tcb *)NULL, m, iphlen, 2121 src, dst, sh, op_err, 2122 mflowtype, mflowid, 2123 vrf_id, port); 2124 return (NULL); 2125 } 2126 /* get the correct sctp_nets */ 2127 if (netp) 2128 *netp = sctp_findnet(stcb, init_src); 2129 2130 asoc = &stcb->asoc; 2131 /* get scope variables out of cookie */ 2132 asoc->scope.ipv4_local_scope = cookie->ipv4_scope; 2133 asoc->scope.site_scope = cookie->site_scope; 2134 asoc->scope.local_scope = cookie->local_scope; 2135 asoc->scope.loopback_scope = cookie->loopback_scope; 2136 2137 if ((asoc->scope.ipv4_addr_legal != cookie->ipv4_addr_legal) || 2138 (asoc->scope.ipv6_addr_legal != cookie->ipv6_addr_legal)) { 2139 struct mbuf *op_err; 2140 2141 /* 2142 * Houston we have a problem. The EP changed while the 2143 * cookie was in flight. Only recourse is to abort the 2144 * association. 2145 */ 2146 atomic_add_int(&stcb->asoc.refcnt, 1); 2147 op_err = sctp_generate_cause(SCTP_CAUSE_OUT_OF_RESC, ""); 2148 sctp_abort_association(inp, (struct sctp_tcb *)NULL, m, iphlen, 2149 src, dst, sh, op_err, 2150 mflowtype, mflowid, 2151 vrf_id, port); 2152#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 2153 SCTP_TCB_UNLOCK(stcb); 2154 SCTP_SOCKET_LOCK(so, 1); 2155 SCTP_TCB_LOCK(stcb); 2156#endif 2157 (void)sctp_free_assoc(inp, stcb, SCTP_NORMAL_PROC, 2158 SCTP_FROM_SCTP_INPUT + SCTP_LOC_18); 2159#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 2160 SCTP_SOCKET_UNLOCK(so, 1); 2161#endif 2162 atomic_subtract_int(&stcb->asoc.refcnt, 1); 2163 return (NULL); 2164 } 2165 /* process the INIT-ACK info (my info) */ 2166 asoc->my_vtag = ntohl(initack_cp->init.initiate_tag); 2167 asoc->my_rwnd = ntohl(initack_cp->init.a_rwnd); 2168 asoc->pre_open_streams = ntohs(initack_cp->init.num_outbound_streams); 2169 asoc->init_seq_number = ntohl(initack_cp->init.initial_tsn); 2170 asoc->sending_seq = asoc->asconf_seq_out = asoc->str_reset_seq_out = asoc->init_seq_number; 2171 asoc->asconf_seq_out_acked = asoc->asconf_seq_out - 1; 2172 asoc->asconf_seq_in = asoc->last_acked_seq = asoc->init_seq_number - 1; 2173 asoc->str_reset_seq_in = asoc->init_seq_number; 2174 2175 asoc->advanced_peer_ack_point = asoc->last_acked_seq; 2176 2177 /* process the INIT info (peer's info) */ 2178 if (netp) 2179 retval = sctp_process_init(init_cp, stcb); 2180 else 2181 retval = 0; 2182 if (retval < 0) { 2183 atomic_add_int(&stcb->asoc.refcnt, 1); 2184#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 2185 SCTP_TCB_UNLOCK(stcb); 2186 SCTP_SOCKET_LOCK(so, 1); 2187 SCTP_TCB_LOCK(stcb); 2188#endif 2189 (void)sctp_free_assoc(inp, stcb, SCTP_NORMAL_PROC, 2190 SCTP_FROM_SCTP_INPUT + SCTP_LOC_19); 2191#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 2192 SCTP_SOCKET_UNLOCK(so, 1); 2193#endif 2194 atomic_subtract_int(&stcb->asoc.refcnt, 1); 2195 return (NULL); 2196 } 2197 /* load all addresses */ 2198 if (sctp_load_addresses_from_init(stcb, m, 2199 init_offset + sizeof(struct sctp_init_chunk), initack_offset, 2200 src, dst, init_src)) { 2201 atomic_add_int(&stcb->asoc.refcnt, 1); 2202#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 2203 SCTP_TCB_UNLOCK(stcb); 2204 SCTP_SOCKET_LOCK(so, 1); 2205 SCTP_TCB_LOCK(stcb); 2206#endif 2207 (void)sctp_free_assoc(inp, stcb, SCTP_NORMAL_PROC, 2208 SCTP_FROM_SCTP_INPUT + SCTP_LOC_20); 2209#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 2210 SCTP_SOCKET_UNLOCK(so, 1); 2211#endif 2212 atomic_subtract_int(&stcb->asoc.refcnt, 1); 2213 return (NULL); 2214 } 2215 /* 2216 * verify any preceding AUTH chunk that was skipped 2217 */ 2218 /* pull the local authentication parameters from the cookie/init-ack */ 2219 sctp_auth_get_cookie_params(stcb, m, 2220 initack_offset + sizeof(struct sctp_init_ack_chunk), 2221 initack_limit - (initack_offset + sizeof(struct sctp_init_ack_chunk))); 2222 if (auth_skipped) { 2223 struct sctp_auth_chunk *auth; 2224 2225 auth = (struct sctp_auth_chunk *) 2226 sctp_m_getptr(m, auth_offset, auth_len, auth_chunk_buf); 2227 if ((auth == NULL) || sctp_handle_auth(stcb, auth, m, auth_offset)) { 2228 /* auth HMAC failed, dump the assoc and packet */ 2229 SCTPDBG(SCTP_DEBUG_AUTH1, 2230 "COOKIE-ECHO: AUTH failed\n"); 2231 atomic_add_int(&stcb->asoc.refcnt, 1); 2232#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 2233 SCTP_TCB_UNLOCK(stcb); 2234 SCTP_SOCKET_LOCK(so, 1); 2235 SCTP_TCB_LOCK(stcb); 2236#endif 2237 (void)sctp_free_assoc(inp, stcb, SCTP_NORMAL_PROC, 2238 SCTP_FROM_SCTP_INPUT + SCTP_LOC_21); 2239#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 2240 SCTP_SOCKET_UNLOCK(so, 1); 2241#endif 2242 atomic_subtract_int(&stcb->asoc.refcnt, 1); 2243 return (NULL); 2244 } else { 2245 /* remaining chunks checked... good to go */ 2246 stcb->asoc.authenticated = 1; 2247 } 2248 } 2249 /* update current state */ 2250 SCTPDBG(SCTP_DEBUG_INPUT2, "moving to OPEN state\n"); 2251 SCTP_SET_STATE(asoc, SCTP_STATE_OPEN); 2252 if (asoc->state & SCTP_STATE_SHUTDOWN_PENDING) { 2253 sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWNGUARD, 2254 stcb->sctp_ep, stcb, asoc->primary_destination); 2255 } 2256 sctp_stop_all_cookie_timers(stcb); 2257 SCTP_STAT_INCR_COUNTER32(sctps_passiveestab); 2258 SCTP_STAT_INCR_GAUGE32(sctps_currestab); 2259 2260 /* 2261 * if we're doing ASCONFs, check to see if we have any new local 2262 * addresses that need to get added to the peer (eg. addresses 2263 * changed while cookie echo in flight). This needs to be done 2264 * after we go to the OPEN state to do the correct asconf 2265 * processing. else, make sure we have the correct addresses in our 2266 * lists 2267 */ 2268 2269 /* warning, we re-use sin, sin6, sa_store here! */ 2270 /* pull in local_address (our "from" address) */ 2271 switch (cookie->laddr_type) { 2272#ifdef INET 2273 case SCTP_IPV4_ADDRESS: 2274 /* source addr is IPv4 */ 2275 memset(&store.sin, 0, sizeof(struct sockaddr_in)); 2276 store.sin.sin_family = AF_INET; 2277 store.sin.sin_len = sizeof(struct sockaddr_in); 2278 store.sin.sin_addr.s_addr = cookie->laddress[0]; 2279 break; 2280#endif 2281#ifdef INET6 2282 case SCTP_IPV6_ADDRESS: 2283 /* source addr is IPv6 */ 2284 memset(&store.sin6, 0, sizeof(struct sockaddr_in6)); 2285 store.sin6.sin6_family = AF_INET6; 2286 store.sin6.sin6_len = sizeof(struct sockaddr_in6); 2287 store.sin6.sin6_scope_id = cookie->scope_id; 2288 memcpy(&store.sin6.sin6_addr, cookie->laddress, sizeof(struct in6_addr)); 2289 break; 2290#endif 2291 default: 2292 atomic_add_int(&stcb->asoc.refcnt, 1); 2293#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 2294 SCTP_TCB_UNLOCK(stcb); 2295 SCTP_SOCKET_LOCK(so, 1); 2296 SCTP_TCB_LOCK(stcb); 2297#endif 2298 (void)sctp_free_assoc(inp, stcb, SCTP_NORMAL_PROC, 2299 SCTP_FROM_SCTP_INPUT + SCTP_LOC_22); 2300#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 2301 SCTP_SOCKET_UNLOCK(so, 1); 2302#endif 2303 atomic_subtract_int(&stcb->asoc.refcnt, 1); 2304 return (NULL); 2305 } 2306 2307 /* set up to notify upper layer */ 2308 *notification = SCTP_NOTIFY_ASSOC_UP; 2309 if (((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) || 2310 (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL)) && 2311 (inp->sctp_socket->so_qlimit == 0)) { 2312 /* 2313 * This is an endpoint that called connect() how it got a 2314 * cookie that is NEW is a bit of a mystery. It must be that 2315 * the INIT was sent, but before it got there.. a complete 2316 * INIT/INIT-ACK/COOKIE arrived. But of course then it 2317 * should have went to the other code.. not here.. oh well.. 2318 * a bit of protection is worth having.. 2319 */ 2320 stcb->sctp_ep->sctp_flags |= SCTP_PCB_FLAGS_CONNECTED; 2321#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 2322 atomic_add_int(&stcb->asoc.refcnt, 1); 2323 SCTP_TCB_UNLOCK(stcb); 2324 SCTP_SOCKET_LOCK(so, 1); 2325 SCTP_TCB_LOCK(stcb); 2326 atomic_subtract_int(&stcb->asoc.refcnt, 1); 2327 if (stcb->asoc.state & SCTP_STATE_CLOSED_SOCKET) { 2328 SCTP_SOCKET_UNLOCK(so, 1); 2329 return (NULL); 2330 } 2331#endif 2332 soisconnected(stcb->sctp_socket); 2333#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 2334 SCTP_SOCKET_UNLOCK(so, 1); 2335#endif 2336 } else if ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) && 2337 (inp->sctp_socket->so_qlimit)) { 2338 /* 2339 * We don't want to do anything with this one. Since it is 2340 * the listening guy. The timer will get started for 2341 * accepted connections in the caller. 2342 */ 2343 ; 2344 } 2345 /* since we did not send a HB make sure we don't double things */ 2346 if ((netp) && (*netp)) 2347 (*netp)->hb_responded = 1; 2348 2349 if (stcb->asoc.sctp_autoclose_ticks && 2350 sctp_is_feature_on(inp, SCTP_PCB_FLAGS_AUTOCLOSE)) { 2351 sctp_timer_start(SCTP_TIMER_TYPE_AUTOCLOSE, inp, stcb, NULL); 2352 } 2353 (void)SCTP_GETTIME_TIMEVAL(&stcb->asoc.time_entered); 2354 if ((netp != NULL) && (*netp != NULL)) { 2355 /* calculate the RTT and set the encaps port */ 2356 (*netp)->RTO = sctp_calculate_rto(stcb, asoc, *netp, 2357 &cookie->time_entered, sctp_align_unsafe_makecopy, 2358 SCTP_RTT_FROM_NON_DATA); 2359#if defined(INET) || defined(INET6) 2360 if (((*netp)->port == 0) && (port != 0)) { 2361 sctp_pathmtu_adjustment(stcb, (*netp)->mtu - sizeof(struct udphdr)); 2362 } 2363 (*netp)->port = port; 2364#endif 2365 } 2366 /* respond with a COOKIE-ACK */ 2367 sctp_send_cookie_ack(stcb); 2368 2369 /* 2370 * check the address lists for any ASCONFs that need to be sent 2371 * AFTER the cookie-ack is sent 2372 */ 2373 sctp_check_address_list(stcb, m, 2374 initack_offset + sizeof(struct sctp_init_ack_chunk), 2375 initack_limit - (initack_offset + sizeof(struct sctp_init_ack_chunk)), 2376 &store.sa, cookie->local_scope, cookie->site_scope, 2377 cookie->ipv4_scope, cookie->loopback_scope); 2378 2379 2380 return (stcb); 2381} 2382 2383/* 2384 * CODE LIKE THIS NEEDS TO RUN IF the peer supports the NAT extension, i.e 2385 * we NEED to make sure we are not already using the vtag. If so we 2386 * need to send back an ABORT-TRY-AGAIN-WITH-NEW-TAG No middle box bit! 2387 head = &SCTP_BASE_INFO(sctp_asochash)[SCTP_PCBHASH_ASOC(tag, 2388 SCTP_BASE_INFO(hashasocmark))]; 2389 LIST_FOREACH(stcb, head, sctp_asocs) { 2390 if ((stcb->asoc.my_vtag == tag) && (stcb->rport == rport) && (inp == stcb->sctp_ep)) { 2391 -- SEND ABORT - TRY AGAIN -- 2392 } 2393 } 2394*/ 2395 2396/* 2397 * handles a COOKIE-ECHO message stcb: modified to either a new or left as 2398 * existing (non-NULL) TCB 2399 */ 2400static struct mbuf * 2401sctp_handle_cookie_echo(struct mbuf *m, int iphlen, int offset, 2402 struct sockaddr *src, struct sockaddr *dst, 2403 struct sctphdr *sh, struct sctp_cookie_echo_chunk *cp, 2404 struct sctp_inpcb **inp_p, struct sctp_tcb **stcb, struct sctp_nets **netp, 2405 int auth_skipped, uint32_t auth_offset, uint32_t auth_len, 2406 struct sctp_tcb **locked_tcb, 2407 uint8_t mflowtype, uint32_t mflowid, 2408 uint32_t vrf_id, uint16_t port) 2409{ 2410 struct sctp_state_cookie *cookie; 2411 struct sctp_tcb *l_stcb = *stcb; 2412 struct sctp_inpcb *l_inp; 2413 struct sockaddr *to; 2414 struct sctp_pcb *ep; 2415 struct mbuf *m_sig; 2416 uint8_t calc_sig[SCTP_SIGNATURE_SIZE], tmp_sig[SCTP_SIGNATURE_SIZE]; 2417 uint8_t *sig; 2418 uint8_t cookie_ok = 0; 2419 unsigned int sig_offset, cookie_offset; 2420 unsigned int cookie_len; 2421 struct timeval now; 2422 struct timeval time_expires; 2423 int notification = 0; 2424 struct sctp_nets *netl; 2425 int had_a_existing_tcb = 0; 2426 int send_int_conf = 0; 2427 2428#ifdef INET 2429 struct sockaddr_in sin; 2430 2431#endif 2432#ifdef INET6 2433 struct sockaddr_in6 sin6; 2434 2435#endif 2436 2437 SCTPDBG(SCTP_DEBUG_INPUT2, 2438 "sctp_handle_cookie: handling COOKIE-ECHO\n"); 2439 2440 if (inp_p == NULL) { 2441 return (NULL); 2442 } 2443 cookie = &cp->cookie; 2444 cookie_offset = offset + sizeof(struct sctp_chunkhdr); 2445 cookie_len = ntohs(cp->ch.chunk_length); 2446 2447 if ((cookie->peerport != sh->src_port) || 2448 (cookie->myport != sh->dest_port) || 2449 (cookie->my_vtag != sh->v_tag)) { 2450 /* 2451 * invalid ports or bad tag. Note that we always leave the 2452 * v_tag in the header in network order and when we stored 2453 * it in the my_vtag slot we also left it in network order. 2454 * This maintains the match even though it may be in the 2455 * opposite byte order of the machine :-> 2456 */ 2457 return (NULL); 2458 } 2459 if (cookie_len < sizeof(struct sctp_cookie_echo_chunk) + 2460 sizeof(struct sctp_init_chunk) + 2461 sizeof(struct sctp_init_ack_chunk) + SCTP_SIGNATURE_SIZE) { 2462 /* cookie too small */ 2463 return (NULL); 2464 } 2465 /* 2466 * split off the signature into its own mbuf (since it should not be 2467 * calculated in the sctp_hmac_m() call). 2468 */ 2469 sig_offset = offset + cookie_len - SCTP_SIGNATURE_SIZE; 2470 m_sig = m_split(m, sig_offset, M_NOWAIT); 2471 if (m_sig == NULL) { 2472 /* out of memory or ?? */ 2473 return (NULL); 2474 } 2475#ifdef SCTP_MBUF_LOGGING 2476 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_MBUF_LOGGING_ENABLE) { 2477 sctp_log_mbc(m_sig, SCTP_MBUF_SPLIT); 2478 } 2479#endif 2480 2481 /* 2482 * compute the signature/digest for the cookie 2483 */ 2484 ep = &(*inp_p)->sctp_ep; 2485 l_inp = *inp_p; 2486 if (l_stcb) { 2487 SCTP_TCB_UNLOCK(l_stcb); 2488 } 2489 SCTP_INP_RLOCK(l_inp); 2490 if (l_stcb) { 2491 SCTP_TCB_LOCK(l_stcb); 2492 } 2493 /* which cookie is it? */ 2494 if ((cookie->time_entered.tv_sec < (long)ep->time_of_secret_change) && 2495 (ep->current_secret_number != ep->last_secret_number)) { 2496 /* it's the old cookie */ 2497 (void)sctp_hmac_m(SCTP_HMAC, 2498 (uint8_t *) ep->secret_key[(int)ep->last_secret_number], 2499 SCTP_SECRET_SIZE, m, cookie_offset, calc_sig, 0); 2500 } else { 2501 /* it's the current cookie */ 2502 (void)sctp_hmac_m(SCTP_HMAC, 2503 (uint8_t *) ep->secret_key[(int)ep->current_secret_number], 2504 SCTP_SECRET_SIZE, m, cookie_offset, calc_sig, 0); 2505 } 2506 /* get the signature */ 2507 SCTP_INP_RUNLOCK(l_inp); 2508 sig = (uint8_t *) sctp_m_getptr(m_sig, 0, SCTP_SIGNATURE_SIZE, (uint8_t *) & tmp_sig); 2509 if (sig == NULL) { 2510 /* couldn't find signature */ 2511 sctp_m_freem(m_sig); 2512 return (NULL); 2513 } 2514 /* compare the received digest with the computed digest */ 2515 if (memcmp(calc_sig, sig, SCTP_SIGNATURE_SIZE) != 0) { 2516 /* try the old cookie? */ 2517 if ((cookie->time_entered.tv_sec == (long)ep->time_of_secret_change) && 2518 (ep->current_secret_number != ep->last_secret_number)) { 2519 /* compute digest with old */ 2520 (void)sctp_hmac_m(SCTP_HMAC, 2521 (uint8_t *) ep->secret_key[(int)ep->last_secret_number], 2522 SCTP_SECRET_SIZE, m, cookie_offset, calc_sig, 0); 2523 /* compare */ 2524 if (memcmp(calc_sig, sig, SCTP_SIGNATURE_SIZE) == 0) 2525 cookie_ok = 1; 2526 } 2527 } else { 2528 cookie_ok = 1; 2529 } 2530 2531 /* 2532 * Now before we continue we must reconstruct our mbuf so that 2533 * normal processing of any other chunks will work. 2534 */ 2535 { 2536 struct mbuf *m_at; 2537 2538 m_at = m; 2539 while (SCTP_BUF_NEXT(m_at) != NULL) { 2540 m_at = SCTP_BUF_NEXT(m_at); 2541 } 2542 SCTP_BUF_NEXT(m_at) = m_sig; 2543 } 2544 2545 if (cookie_ok == 0) { 2546 SCTPDBG(SCTP_DEBUG_INPUT2, "handle_cookie_echo: cookie signature validation failed!\n"); 2547 SCTPDBG(SCTP_DEBUG_INPUT2, 2548 "offset = %u, cookie_offset = %u, sig_offset = %u\n", 2549 (uint32_t) offset, cookie_offset, sig_offset); 2550 return (NULL); 2551 } 2552 /* 2553 * check the cookie timestamps to be sure it's not stale 2554 */ 2555 (void)SCTP_GETTIME_TIMEVAL(&now); 2556 /* Expire time is in Ticks, so we convert to seconds */ 2557 time_expires.tv_sec = cookie->time_entered.tv_sec + TICKS_TO_SEC(cookie->cookie_life); 2558 time_expires.tv_usec = cookie->time_entered.tv_usec; 2559 /* 2560 * TODO sctp_constants.h needs alternative time macros when _KERNEL 2561 * is undefined. 2562 */ 2563 if (timevalcmp(&now, &time_expires, >)) { 2564 /* cookie is stale! */ 2565 struct mbuf *op_err; 2566 struct sctp_error_stale_cookie *cause; 2567 uint32_t tim; 2568 2569 op_err = sctp_get_mbuf_for_msg(sizeof(struct sctp_error_stale_cookie), 2570 0, M_NOWAIT, 1, MT_DATA); 2571 if (op_err == NULL) { 2572 /* FOOBAR */ 2573 return (NULL); 2574 } 2575 /* Set the len */ 2576 SCTP_BUF_LEN(op_err) = sizeof(struct sctp_error_stale_cookie); 2577 cause = mtod(op_err, struct sctp_error_stale_cookie *); 2578 cause->cause.code = htons(SCTP_CAUSE_STALE_COOKIE); 2579 cause->cause.length = htons((sizeof(struct sctp_paramhdr) + 2580 (sizeof(uint32_t)))); 2581 /* seconds to usec */ 2582 tim = (now.tv_sec - time_expires.tv_sec) * 1000000; 2583 /* add in usec */ 2584 if (tim == 0) 2585 tim = now.tv_usec - cookie->time_entered.tv_usec; 2586 cause->stale_time = htonl(tim); 2587 sctp_send_operr_to(src, dst, sh, cookie->peers_vtag, op_err, 2588 mflowtype, mflowid, l_inp->fibnum, 2589 vrf_id, port); 2590 return (NULL); 2591 } 2592 /* 2593 * Now we must see with the lookup address if we have an existing 2594 * asoc. This will only happen if we were in the COOKIE-WAIT state 2595 * and a INIT collided with us and somewhere the peer sent the 2596 * cookie on another address besides the single address our assoc 2597 * had for him. In this case we will have one of the tie-tags set at 2598 * least AND the address field in the cookie can be used to look it 2599 * up. 2600 */ 2601 to = NULL; 2602 switch (cookie->addr_type) { 2603#ifdef INET6 2604 case SCTP_IPV6_ADDRESS: 2605 memset(&sin6, 0, sizeof(sin6)); 2606 sin6.sin6_family = AF_INET6; 2607 sin6.sin6_len = sizeof(sin6); 2608 sin6.sin6_port = sh->src_port; 2609 sin6.sin6_scope_id = cookie->scope_id; 2610 memcpy(&sin6.sin6_addr.s6_addr, cookie->address, 2611 sizeof(sin6.sin6_addr.s6_addr)); 2612 to = (struct sockaddr *)&sin6; 2613 break; 2614#endif 2615#ifdef INET 2616 case SCTP_IPV4_ADDRESS: 2617 memset(&sin, 0, sizeof(sin)); 2618 sin.sin_family = AF_INET; 2619 sin.sin_len = sizeof(sin); 2620 sin.sin_port = sh->src_port; 2621 sin.sin_addr.s_addr = cookie->address[0]; 2622 to = (struct sockaddr *)&sin; 2623 break; 2624#endif 2625 default: 2626 /* This should not happen */ 2627 return (NULL); 2628 } 2629 if (*stcb == NULL) { 2630 /* Yep, lets check */ 2631 *stcb = sctp_findassociation_ep_addr(inp_p, to, netp, dst, NULL); 2632 if (*stcb == NULL) { 2633 /* 2634 * We should have only got back the same inp. If we 2635 * got back a different ep we have a problem. The 2636 * original findep got back l_inp and now 2637 */ 2638 if (l_inp != *inp_p) { 2639 SCTP_PRINTF("Bad problem find_ep got a diff inp then special_locate?\n"); 2640 } 2641 } else { 2642 if (*locked_tcb == NULL) { 2643 /* 2644 * In this case we found the assoc only 2645 * after we locked the create lock. This 2646 * means we are in a colliding case and we 2647 * must make sure that we unlock the tcb if 2648 * its one of the cases where we throw away 2649 * the incoming packets. 2650 */ 2651 *locked_tcb = *stcb; 2652 2653 /* 2654 * We must also increment the inp ref count 2655 * since the ref_count flags was set when we 2656 * did not find the TCB, now we found it 2657 * which reduces the refcount.. we must 2658 * raise it back out to balance it all :-) 2659 */ 2660 SCTP_INP_INCR_REF((*stcb)->sctp_ep); 2661 if ((*stcb)->sctp_ep != l_inp) { 2662 SCTP_PRINTF("Huh? ep:%p diff then l_inp:%p?\n", 2663 (void *)(*stcb)->sctp_ep, (void *)l_inp); 2664 } 2665 } 2666 } 2667 } 2668 cookie_len -= SCTP_SIGNATURE_SIZE; 2669 if (*stcb == NULL) { 2670 /* this is the "normal" case... get a new TCB */ 2671 *stcb = sctp_process_cookie_new(m, iphlen, offset, src, dst, sh, 2672 cookie, cookie_len, *inp_p, 2673 netp, to, ¬ification, 2674 auth_skipped, auth_offset, auth_len, 2675 mflowtype, mflowid, 2676 vrf_id, port); 2677 } else { 2678 /* this is abnormal... cookie-echo on existing TCB */ 2679 had_a_existing_tcb = 1; 2680 *stcb = sctp_process_cookie_existing(m, iphlen, offset, 2681 src, dst, sh, 2682 cookie, cookie_len, *inp_p, *stcb, netp, to, 2683 ¬ification, auth_skipped, auth_offset, auth_len, 2684 mflowtype, mflowid, 2685 vrf_id, port); 2686 } 2687 2688 if (*stcb == NULL) { 2689 /* still no TCB... must be bad cookie-echo */ 2690 return (NULL); 2691 } 2692 if (*netp != NULL) { 2693 (*netp)->flowtype = mflowtype; 2694 (*netp)->flowid = mflowid; 2695 } 2696 /* 2697 * Ok, we built an association so confirm the address we sent the 2698 * INIT-ACK to. 2699 */ 2700 netl = sctp_findnet(*stcb, to); 2701 /* 2702 * This code should in theory NOT run but 2703 */ 2704 if (netl == NULL) { 2705 /* TSNH! Huh, why do I need to add this address here? */ 2706 if (sctp_add_remote_addr(*stcb, to, NULL, SCTP_DONOT_SETSCOPE, SCTP_IN_COOKIE_PROC)) { 2707 return (NULL); 2708 } 2709 netl = sctp_findnet(*stcb, to); 2710 } 2711 if (netl) { 2712 if (netl->dest_state & SCTP_ADDR_UNCONFIRMED) { 2713 netl->dest_state &= ~SCTP_ADDR_UNCONFIRMED; 2714 (void)sctp_set_primary_addr((*stcb), (struct sockaddr *)NULL, 2715 netl); 2716 send_int_conf = 1; 2717 } 2718 } 2719 sctp_start_net_timers(*stcb); 2720 if ((*inp_p)->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) { 2721 if (!had_a_existing_tcb || 2722 (((*inp_p)->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) == 0)) { 2723 /* 2724 * If we have a NEW cookie or the connect never 2725 * reached the connected state during collision we 2726 * must do the TCP accept thing. 2727 */ 2728 struct socket *so, *oso; 2729 struct sctp_inpcb *inp; 2730 2731 if (notification == SCTP_NOTIFY_ASSOC_RESTART) { 2732 /* 2733 * For a restart we will keep the same 2734 * socket, no need to do anything. I THINK!! 2735 */ 2736 sctp_ulp_notify(notification, *stcb, 0, NULL, SCTP_SO_NOT_LOCKED); 2737 if (send_int_conf) { 2738 sctp_ulp_notify(SCTP_NOTIFY_INTERFACE_CONFIRMED, 2739 (*stcb), 0, (void *)netl, SCTP_SO_NOT_LOCKED); 2740 } 2741 return (m); 2742 } 2743 oso = (*inp_p)->sctp_socket; 2744 atomic_add_int(&(*stcb)->asoc.refcnt, 1); 2745 SCTP_TCB_UNLOCK((*stcb)); 2746 CURVNET_SET(oso->so_vnet); 2747 so = sonewconn(oso, 0 2748 ); 2749 CURVNET_RESTORE(); 2750 SCTP_TCB_LOCK((*stcb)); 2751 atomic_subtract_int(&(*stcb)->asoc.refcnt, 1); 2752 2753 if (so == NULL) { 2754 struct mbuf *op_err; 2755 2756#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 2757 struct socket *pcb_so; 2758 2759#endif 2760 /* Too many sockets */ 2761 SCTPDBG(SCTP_DEBUG_INPUT1, "process_cookie_new: no room for another socket!\n"); 2762 op_err = sctp_generate_cause(SCTP_CAUSE_OUT_OF_RESC, ""); 2763 sctp_abort_association(*inp_p, NULL, m, iphlen, 2764 src, dst, sh, op_err, 2765 mflowtype, mflowid, 2766 vrf_id, port); 2767#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 2768 pcb_so = SCTP_INP_SO(*inp_p); 2769 atomic_add_int(&(*stcb)->asoc.refcnt, 1); 2770 SCTP_TCB_UNLOCK((*stcb)); 2771 SCTP_SOCKET_LOCK(pcb_so, 1); 2772 SCTP_TCB_LOCK((*stcb)); 2773 atomic_subtract_int(&(*stcb)->asoc.refcnt, 1); 2774#endif 2775 (void)sctp_free_assoc(*inp_p, *stcb, SCTP_NORMAL_PROC, 2776 SCTP_FROM_SCTP_INPUT + SCTP_LOC_23); 2777#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 2778 SCTP_SOCKET_UNLOCK(pcb_so, 1); 2779#endif 2780 return (NULL); 2781 } 2782 inp = (struct sctp_inpcb *)so->so_pcb; 2783 SCTP_INP_INCR_REF(inp); 2784 /* 2785 * We add the unbound flag here so that if we get an 2786 * soabort() before we get the move_pcb done, we 2787 * will properly cleanup. 2788 */ 2789 inp->sctp_flags = (SCTP_PCB_FLAGS_TCPTYPE | 2790 SCTP_PCB_FLAGS_CONNECTED | 2791 SCTP_PCB_FLAGS_IN_TCPPOOL | 2792 SCTP_PCB_FLAGS_UNBOUND | 2793 (SCTP_PCB_COPY_FLAGS & (*inp_p)->sctp_flags) | 2794 SCTP_PCB_FLAGS_DONT_WAKE); 2795 inp->sctp_features = (*inp_p)->sctp_features; 2796 inp->sctp_mobility_features = (*inp_p)->sctp_mobility_features; 2797 inp->sctp_socket = so; 2798 inp->sctp_frag_point = (*inp_p)->sctp_frag_point; 2799 inp->max_cwnd = (*inp_p)->max_cwnd; 2800 inp->sctp_cmt_on_off = (*inp_p)->sctp_cmt_on_off; 2801 inp->ecn_supported = (*inp_p)->ecn_supported; 2802 inp->prsctp_supported = (*inp_p)->prsctp_supported; 2803 inp->auth_supported = (*inp_p)->auth_supported; 2804 inp->asconf_supported = (*inp_p)->asconf_supported; 2805 inp->reconfig_supported = (*inp_p)->reconfig_supported; 2806 inp->nrsack_supported = (*inp_p)->nrsack_supported; 2807 inp->pktdrop_supported = (*inp_p)->pktdrop_supported; 2808 inp->partial_delivery_point = (*inp_p)->partial_delivery_point; 2809 inp->sctp_context = (*inp_p)->sctp_context; 2810 inp->local_strreset_support = (*inp_p)->local_strreset_support; 2811 inp->fibnum = (*inp_p)->fibnum; 2812 inp->inp_starting_point_for_iterator = NULL; 2813 /* 2814 * copy in the authentication parameters from the 2815 * original endpoint 2816 */ 2817 if (inp->sctp_ep.local_hmacs) 2818 sctp_free_hmaclist(inp->sctp_ep.local_hmacs); 2819 inp->sctp_ep.local_hmacs = 2820 sctp_copy_hmaclist((*inp_p)->sctp_ep.local_hmacs); 2821 if (inp->sctp_ep.local_auth_chunks) 2822 sctp_free_chunklist(inp->sctp_ep.local_auth_chunks); 2823 inp->sctp_ep.local_auth_chunks = 2824 sctp_copy_chunklist((*inp_p)->sctp_ep.local_auth_chunks); 2825 2826 /* 2827 * Now we must move it from one hash table to 2828 * another and get the tcb in the right place. 2829 */ 2830 2831 /* 2832 * This is where the one-2-one socket is put into 2833 * the accept state waiting for the accept! 2834 */ 2835 if (*stcb) { 2836 (*stcb)->asoc.state |= SCTP_STATE_IN_ACCEPT_QUEUE; 2837 } 2838 sctp_move_pcb_and_assoc(*inp_p, inp, *stcb); 2839 2840 atomic_add_int(&(*stcb)->asoc.refcnt, 1); 2841 SCTP_TCB_UNLOCK((*stcb)); 2842 2843 sctp_pull_off_control_to_new_inp((*inp_p), inp, *stcb, 2844 0); 2845 SCTP_TCB_LOCK((*stcb)); 2846 atomic_subtract_int(&(*stcb)->asoc.refcnt, 1); 2847 2848 2849 /* 2850 * now we must check to see if we were aborted while 2851 * the move was going on and the lock/unlock 2852 * happened. 2853 */ 2854 if (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) { 2855 /* 2856 * yep it was, we leave the assoc attached 2857 * to the socket since the sctp_inpcb_free() 2858 * call will send an abort for us. 2859 */ 2860 SCTP_INP_DECR_REF(inp); 2861 return (NULL); 2862 } 2863 SCTP_INP_DECR_REF(inp); 2864 /* Switch over to the new guy */ 2865 *inp_p = inp; 2866 sctp_ulp_notify(notification, *stcb, 0, NULL, SCTP_SO_NOT_LOCKED); 2867 if (send_int_conf) { 2868 sctp_ulp_notify(SCTP_NOTIFY_INTERFACE_CONFIRMED, 2869 (*stcb), 0, (void *)netl, SCTP_SO_NOT_LOCKED); 2870 } 2871 /* 2872 * Pull it from the incomplete queue and wake the 2873 * guy 2874 */ 2875#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 2876 atomic_add_int(&(*stcb)->asoc.refcnt, 1); 2877 SCTP_TCB_UNLOCK((*stcb)); 2878 SCTP_SOCKET_LOCK(so, 1); 2879#endif 2880 soisconnected(so); 2881#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 2882 SCTP_TCB_LOCK((*stcb)); 2883 atomic_subtract_int(&(*stcb)->asoc.refcnt, 1); 2884 SCTP_SOCKET_UNLOCK(so, 1); 2885#endif 2886 return (m); 2887 } 2888 } 2889 if (notification) { 2890 sctp_ulp_notify(notification, *stcb, 0, NULL, SCTP_SO_NOT_LOCKED); 2891 } 2892 if (send_int_conf) { 2893 sctp_ulp_notify(SCTP_NOTIFY_INTERFACE_CONFIRMED, 2894 (*stcb), 0, (void *)netl, SCTP_SO_NOT_LOCKED); 2895 } 2896 return (m); 2897} 2898 2899static void 2900sctp_handle_cookie_ack(struct sctp_cookie_ack_chunk *cp SCTP_UNUSED, 2901 struct sctp_tcb *stcb, struct sctp_nets *net) 2902{ 2903 /* cp must not be used, others call this without a c-ack :-) */ 2904 struct sctp_association *asoc; 2905 2906 SCTPDBG(SCTP_DEBUG_INPUT2, 2907 "sctp_handle_cookie_ack: handling COOKIE-ACK\n"); 2908 if ((stcb == NULL) || (net == NULL)) { 2909 return; 2910 } 2911 asoc = &stcb->asoc; 2912 2913 sctp_stop_all_cookie_timers(stcb); 2914 /* process according to association state */ 2915 if (SCTP_GET_STATE(asoc) == SCTP_STATE_COOKIE_ECHOED) { 2916 /* state change only needed when I am in right state */ 2917 SCTPDBG(SCTP_DEBUG_INPUT2, "moving to OPEN state\n"); 2918 SCTP_SET_STATE(asoc, SCTP_STATE_OPEN); 2919 sctp_start_net_timers(stcb); 2920 if (asoc->state & SCTP_STATE_SHUTDOWN_PENDING) { 2921 sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWNGUARD, 2922 stcb->sctp_ep, stcb, asoc->primary_destination); 2923 2924 } 2925 /* update RTO */ 2926 SCTP_STAT_INCR_COUNTER32(sctps_activeestab); 2927 SCTP_STAT_INCR_GAUGE32(sctps_currestab); 2928 if (asoc->overall_error_count == 0) { 2929 net->RTO = sctp_calculate_rto(stcb, asoc, net, 2930 &asoc->time_entered, sctp_align_safe_nocopy, 2931 SCTP_RTT_FROM_NON_DATA); 2932 } 2933 (void)SCTP_GETTIME_TIMEVAL(&asoc->time_entered); 2934 sctp_ulp_notify(SCTP_NOTIFY_ASSOC_UP, stcb, 0, NULL, SCTP_SO_NOT_LOCKED); 2935 if ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) || 2936 (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL)) { 2937#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 2938 struct socket *so; 2939 2940#endif 2941 stcb->sctp_ep->sctp_flags |= SCTP_PCB_FLAGS_CONNECTED; 2942#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 2943 so = SCTP_INP_SO(stcb->sctp_ep); 2944 atomic_add_int(&stcb->asoc.refcnt, 1); 2945 SCTP_TCB_UNLOCK(stcb); 2946 SCTP_SOCKET_LOCK(so, 1); 2947 SCTP_TCB_LOCK(stcb); 2948 atomic_subtract_int(&stcb->asoc.refcnt, 1); 2949#endif 2950 if ((stcb->asoc.state & SCTP_STATE_CLOSED_SOCKET) == 0) { 2951 soisconnected(stcb->sctp_socket); 2952 } 2953#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 2954 SCTP_SOCKET_UNLOCK(so, 1); 2955#endif 2956 } 2957 /* 2958 * since we did not send a HB make sure we don't double 2959 * things 2960 */ 2961 net->hb_responded = 1; 2962 2963 if (stcb->asoc.state & SCTP_STATE_CLOSED_SOCKET) { 2964 /* 2965 * We don't need to do the asconf thing, nor hb or 2966 * autoclose if the socket is closed. 2967 */ 2968 goto closed_socket; 2969 } 2970 sctp_timer_start(SCTP_TIMER_TYPE_HEARTBEAT, stcb->sctp_ep, 2971 stcb, net); 2972 2973 2974 if (stcb->asoc.sctp_autoclose_ticks && 2975 sctp_is_feature_on(stcb->sctp_ep, SCTP_PCB_FLAGS_AUTOCLOSE)) { 2976 sctp_timer_start(SCTP_TIMER_TYPE_AUTOCLOSE, 2977 stcb->sctp_ep, stcb, NULL); 2978 } 2979 /* 2980 * send ASCONF if parameters are pending and ASCONFs are 2981 * allowed (eg. addresses changed when init/cookie echo were 2982 * in flight) 2983 */ 2984 if ((sctp_is_feature_on(stcb->sctp_ep, SCTP_PCB_FLAGS_DO_ASCONF)) && 2985 (stcb->asoc.asconf_supported == 1) && 2986 (!TAILQ_EMPTY(&stcb->asoc.asconf_queue))) { 2987#ifdef SCTP_TIMER_BASED_ASCONF 2988 sctp_timer_start(SCTP_TIMER_TYPE_ASCONF, 2989 stcb->sctp_ep, stcb, 2990 stcb->asoc.primary_destination); 2991#else 2992 sctp_send_asconf(stcb, stcb->asoc.primary_destination, 2993 SCTP_ADDR_NOT_LOCKED); 2994#endif 2995 } 2996 } 2997closed_socket: 2998 /* Toss the cookie if I can */ 2999 sctp_toss_old_cookies(stcb, asoc); 3000 if (!TAILQ_EMPTY(&asoc->sent_queue)) { 3001 /* Restart the timer if we have pending data */ 3002 struct sctp_tmit_chunk *chk; 3003 3004 chk = TAILQ_FIRST(&asoc->sent_queue); 3005 sctp_timer_start(SCTP_TIMER_TYPE_SEND, stcb->sctp_ep, stcb, chk->whoTo); 3006 } 3007} 3008 3009static void 3010sctp_handle_ecn_echo(struct sctp_ecne_chunk *cp, 3011 struct sctp_tcb *stcb) 3012{ 3013 struct sctp_nets *net; 3014 struct sctp_tmit_chunk *lchk; 3015 struct sctp_ecne_chunk bkup; 3016 uint8_t override_bit; 3017 uint32_t tsn, window_data_tsn; 3018 int len; 3019 unsigned int pkt_cnt; 3020 3021 len = ntohs(cp->ch.chunk_length); 3022 if ((len != sizeof(struct sctp_ecne_chunk)) && 3023 (len != sizeof(struct old_sctp_ecne_chunk))) { 3024 return; 3025 } 3026 if (len == sizeof(struct old_sctp_ecne_chunk)) { 3027 /* Its the old format */ 3028 memcpy(&bkup, cp, sizeof(struct old_sctp_ecne_chunk)); 3029 bkup.num_pkts_since_cwr = htonl(1); 3030 cp = &bkup; 3031 } 3032 SCTP_STAT_INCR(sctps_recvecne); 3033 tsn = ntohl(cp->tsn); 3034 pkt_cnt = ntohl(cp->num_pkts_since_cwr); 3035 lchk = TAILQ_LAST(&stcb->asoc.send_queue, sctpchunk_listhead); 3036 if (lchk == NULL) { 3037 window_data_tsn = stcb->asoc.sending_seq - 1; 3038 } else { 3039 window_data_tsn = lchk->rec.data.TSN_seq; 3040 } 3041 3042 /* Find where it was sent to if possible. */ 3043 net = NULL; 3044 TAILQ_FOREACH(lchk, &stcb->asoc.sent_queue, sctp_next) { 3045 if (lchk->rec.data.TSN_seq == tsn) { 3046 net = lchk->whoTo; 3047 net->ecn_prev_cwnd = lchk->rec.data.cwnd_at_send; 3048 break; 3049 } 3050 if (SCTP_TSN_GT(lchk->rec.data.TSN_seq, tsn)) { 3051 break; 3052 } 3053 } 3054 if (net == NULL) { 3055 /* 3056 * What to do. A previous send of a CWR was possibly lost. 3057 * See how old it is, we may have it marked on the actual 3058 * net. 3059 */ 3060 TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) { 3061 if (tsn == net->last_cwr_tsn) { 3062 /* Found him, send it off */ 3063 break; 3064 } 3065 } 3066 if (net == NULL) { 3067 /* 3068 * If we reach here, we need to send a special CWR 3069 * that says hey, we did this a long time ago and 3070 * you lost the response. 3071 */ 3072 net = TAILQ_FIRST(&stcb->asoc.nets); 3073 if (net == NULL) { 3074 /* TSNH */ 3075 return; 3076 } 3077 override_bit = SCTP_CWR_REDUCE_OVERRIDE; 3078 } else { 3079 override_bit = 0; 3080 } 3081 } else { 3082 override_bit = 0; 3083 } 3084 if (SCTP_TSN_GT(tsn, net->cwr_window_tsn) && 3085 ((override_bit & SCTP_CWR_REDUCE_OVERRIDE) == 0)) { 3086 /* 3087 * JRS - Use the congestion control given in the pluggable 3088 * CC module 3089 */ 3090 stcb->asoc.cc_functions.sctp_cwnd_update_after_ecn_echo(stcb, net, 0, pkt_cnt); 3091 /* 3092 * We reduce once every RTT. So we will only lower cwnd at 3093 * the next sending seq i.e. the window_data_tsn 3094 */ 3095 net->cwr_window_tsn = window_data_tsn; 3096 net->ecn_ce_pkt_cnt += pkt_cnt; 3097 net->lost_cnt = pkt_cnt; 3098 net->last_cwr_tsn = tsn; 3099 } else { 3100 override_bit |= SCTP_CWR_IN_SAME_WINDOW; 3101 if (SCTP_TSN_GT(tsn, net->last_cwr_tsn) && 3102 ((override_bit & SCTP_CWR_REDUCE_OVERRIDE) == 0)) { 3103 /* 3104 * Another loss in the same window update how many 3105 * marks/packets lost we have had. 3106 */ 3107 int cnt = 1; 3108 3109 if (pkt_cnt > net->lost_cnt) { 3110 /* Should be the case */ 3111 cnt = (pkt_cnt - net->lost_cnt); 3112 net->ecn_ce_pkt_cnt += cnt; 3113 } 3114 net->lost_cnt = pkt_cnt; 3115 net->last_cwr_tsn = tsn; 3116 /* 3117 * Most CC functions will ignore this call, since we 3118 * are in-window yet of the initial CE the peer saw. 3119 */ 3120 stcb->asoc.cc_functions.sctp_cwnd_update_after_ecn_echo(stcb, net, 1, cnt); 3121 } 3122 } 3123 /* 3124 * We always send a CWR this way if our previous one was lost our 3125 * peer will get an update, or if it is not time again to reduce we 3126 * still get the cwr to the peer. Note we set the override when we 3127 * could not find the TSN on the chunk or the destination network. 3128 */ 3129 sctp_send_cwr(stcb, net, net->last_cwr_tsn, override_bit); 3130} 3131 3132static void 3133sctp_handle_ecn_cwr(struct sctp_cwr_chunk *cp, struct sctp_tcb *stcb, struct sctp_nets *net) 3134{ 3135 /* 3136 * Here we get a CWR from the peer. We must look in the outqueue and 3137 * make sure that we have a covered ECNE in the control chunk part. 3138 * If so remove it. 3139 */ 3140 struct sctp_tmit_chunk *chk; 3141 struct sctp_ecne_chunk *ecne; 3142 int override; 3143 uint32_t cwr_tsn; 3144 3145 cwr_tsn = ntohl(cp->tsn); 3146 override = cp->ch.chunk_flags & SCTP_CWR_REDUCE_OVERRIDE; 3147 TAILQ_FOREACH(chk, &stcb->asoc.control_send_queue, sctp_next) { 3148 if (chk->rec.chunk_id.id != SCTP_ECN_ECHO) { 3149 continue; 3150 } 3151 if ((override == 0) && (chk->whoTo != net)) { 3152 /* Must be from the right src unless override is set */ 3153 continue; 3154 } 3155 ecne = mtod(chk->data, struct sctp_ecne_chunk *); 3156 if (SCTP_TSN_GE(cwr_tsn, ntohl(ecne->tsn))) { 3157 /* this covers this ECNE, we can remove it */ 3158 stcb->asoc.ecn_echo_cnt_onq--; 3159 TAILQ_REMOVE(&stcb->asoc.control_send_queue, chk, 3160 sctp_next); 3161 sctp_m_freem(chk->data); 3162 chk->data = NULL; 3163 stcb->asoc.ctrl_queue_cnt--; 3164 sctp_free_a_chunk(stcb, chk, SCTP_SO_NOT_LOCKED); 3165 if (override == 0) { 3166 break; 3167 } 3168 } 3169 } 3170} 3171 3172static void 3173sctp_handle_shutdown_complete(struct sctp_shutdown_complete_chunk *cp SCTP_UNUSED, 3174 struct sctp_tcb *stcb, struct sctp_nets *net) 3175{ 3176 struct sctp_association *asoc; 3177 3178#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 3179 struct socket *so; 3180 3181#endif 3182 3183 SCTPDBG(SCTP_DEBUG_INPUT2, 3184 "sctp_handle_shutdown_complete: handling SHUTDOWN-COMPLETE\n"); 3185 if (stcb == NULL) 3186 return; 3187 3188 asoc = &stcb->asoc; 3189 /* process according to association state */ 3190 if (SCTP_GET_STATE(asoc) != SCTP_STATE_SHUTDOWN_ACK_SENT) { 3191 /* unexpected SHUTDOWN-COMPLETE... so ignore... */ 3192 SCTPDBG(SCTP_DEBUG_INPUT2, 3193 "sctp_handle_shutdown_complete: not in SCTP_STATE_SHUTDOWN_ACK_SENT --- ignore\n"); 3194 SCTP_TCB_UNLOCK(stcb); 3195 return; 3196 } 3197 /* notify upper layer protocol */ 3198 if (stcb->sctp_socket) { 3199 sctp_ulp_notify(SCTP_NOTIFY_ASSOC_DOWN, stcb, 0, NULL, SCTP_SO_NOT_LOCKED); 3200 } 3201#ifdef INVARIANTS 3202 if (!TAILQ_EMPTY(&asoc->send_queue) || 3203 !TAILQ_EMPTY(&asoc->sent_queue) || 3204 !stcb->asoc.ss_functions.sctp_ss_is_empty(stcb, asoc)) { 3205 panic("Queues are not empty when handling SHUTDOWN-COMPLETE"); 3206 } 3207#endif 3208 /* stop the timer */ 3209 sctp_timer_stop(SCTP_TIMER_TYPE_SHUTDOWNACK, stcb->sctp_ep, stcb, net, 3210 SCTP_FROM_SCTP_INPUT + SCTP_LOC_24); 3211 SCTP_STAT_INCR_COUNTER32(sctps_shutdown); 3212 /* free the TCB */ 3213 SCTPDBG(SCTP_DEBUG_INPUT2, 3214 "sctp_handle_shutdown_complete: calls free-asoc\n"); 3215#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 3216 so = SCTP_INP_SO(stcb->sctp_ep); 3217 atomic_add_int(&stcb->asoc.refcnt, 1); 3218 SCTP_TCB_UNLOCK(stcb); 3219 SCTP_SOCKET_LOCK(so, 1); 3220 SCTP_TCB_LOCK(stcb); 3221 atomic_subtract_int(&stcb->asoc.refcnt, 1); 3222#endif 3223 (void)sctp_free_assoc(stcb->sctp_ep, stcb, SCTP_NORMAL_PROC, 3224 SCTP_FROM_SCTP_INPUT + SCTP_LOC_25); 3225#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 3226 SCTP_SOCKET_UNLOCK(so, 1); 3227#endif 3228 return; 3229} 3230 3231static int 3232process_chunk_drop(struct sctp_tcb *stcb, struct sctp_chunk_desc *desc, 3233 struct sctp_nets *net, uint8_t flg) 3234{ 3235 switch (desc->chunk_type) { 3236 case SCTP_DATA: 3237 /* find the tsn to resend (possibly */ 3238 { 3239 uint32_t tsn; 3240 struct sctp_tmit_chunk *tp1; 3241 3242 tsn = ntohl(desc->tsn_ifany); 3243 TAILQ_FOREACH(tp1, &stcb->asoc.sent_queue, sctp_next) { 3244 if (tp1->rec.data.TSN_seq == tsn) { 3245 /* found it */ 3246 break; 3247 } 3248 if (SCTP_TSN_GT(tp1->rec.data.TSN_seq, tsn)) { 3249 /* not found */ 3250 tp1 = NULL; 3251 break; 3252 } 3253 } 3254 if (tp1 == NULL) { 3255 /* 3256 * Do it the other way , aka without paying 3257 * attention to queue seq order. 3258 */ 3259 SCTP_STAT_INCR(sctps_pdrpdnfnd); 3260 TAILQ_FOREACH(tp1, &stcb->asoc.sent_queue, sctp_next) { 3261 if (tp1->rec.data.TSN_seq == tsn) { 3262 /* found it */ 3263 break; 3264 } 3265 } 3266 } 3267 if (tp1 == NULL) { 3268 SCTP_STAT_INCR(sctps_pdrptsnnf); 3269 } 3270 if ((tp1) && (tp1->sent < SCTP_DATAGRAM_ACKED)) { 3271 uint8_t *ddp; 3272 3273 if (((flg & SCTP_BADCRC) == 0) && 3274 ((flg & SCTP_FROM_MIDDLE_BOX) == 0)) { 3275 return (0); 3276 } 3277 if ((stcb->asoc.peers_rwnd == 0) && 3278 ((flg & SCTP_FROM_MIDDLE_BOX) == 0)) { 3279 SCTP_STAT_INCR(sctps_pdrpdiwnp); 3280 return (0); 3281 } 3282 if (stcb->asoc.peers_rwnd == 0 && 3283 (flg & SCTP_FROM_MIDDLE_BOX)) { 3284 SCTP_STAT_INCR(sctps_pdrpdizrw); 3285 return (0); 3286 } 3287 ddp = (uint8_t *) (mtod(tp1->data, caddr_t)+ 3288 sizeof(struct sctp_data_chunk)); 3289 { 3290 unsigned int iii; 3291 3292 for (iii = 0; iii < sizeof(desc->data_bytes); 3293 iii++) { 3294 if (ddp[iii] != desc->data_bytes[iii]) { 3295 SCTP_STAT_INCR(sctps_pdrpbadd); 3296 return (-1); 3297 } 3298 } 3299 } 3300 3301 if (tp1->do_rtt) { 3302 /* 3303 * this guy had a RTO calculation 3304 * pending on it, cancel it 3305 */ 3306 if (tp1->whoTo->rto_needed == 0) { 3307 tp1->whoTo->rto_needed = 1; 3308 } 3309 tp1->do_rtt = 0; 3310 } 3311 SCTP_STAT_INCR(sctps_pdrpmark); 3312 if (tp1->sent != SCTP_DATAGRAM_RESEND) 3313 sctp_ucount_incr(stcb->asoc.sent_queue_retran_cnt); 3314 /* 3315 * mark it as if we were doing a FR, since 3316 * we will be getting gap ack reports behind 3317 * the info from the router. 3318 */ 3319 tp1->rec.data.doing_fast_retransmit = 1; 3320 /* 3321 * mark the tsn with what sequences can 3322 * cause a new FR. 3323 */ 3324 if (TAILQ_EMPTY(&stcb->asoc.send_queue)) { 3325 tp1->rec.data.fast_retran_tsn = stcb->asoc.sending_seq; 3326 } else { 3327 tp1->rec.data.fast_retran_tsn = (TAILQ_FIRST(&stcb->asoc.send_queue))->rec.data.TSN_seq; 3328 } 3329 3330 /* restart the timer */ 3331 sctp_timer_stop(SCTP_TIMER_TYPE_SEND, stcb->sctp_ep, 3332 stcb, tp1->whoTo, 3333 SCTP_FROM_SCTP_INPUT + SCTP_LOC_26); 3334 sctp_timer_start(SCTP_TIMER_TYPE_SEND, stcb->sctp_ep, 3335 stcb, tp1->whoTo); 3336 3337 /* fix counts and things */ 3338 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_FLIGHT_LOGGING_ENABLE) { 3339 sctp_misc_ints(SCTP_FLIGHT_LOG_DOWN_PDRP, 3340 tp1->whoTo->flight_size, 3341 tp1->book_size, 3342 (uintptr_t) stcb, 3343 tp1->rec.data.TSN_seq); 3344 } 3345 if (tp1->sent < SCTP_DATAGRAM_RESEND) { 3346 sctp_flight_size_decrease(tp1); 3347 sctp_total_flight_decrease(stcb, tp1); 3348 } 3349 tp1->sent = SCTP_DATAGRAM_RESEND; 3350 } { 3351 /* audit code */ 3352 unsigned int audit; 3353 3354 audit = 0; 3355 TAILQ_FOREACH(tp1, &stcb->asoc.sent_queue, sctp_next) { 3356 if (tp1->sent == SCTP_DATAGRAM_RESEND) 3357 audit++; 3358 } 3359 TAILQ_FOREACH(tp1, &stcb->asoc.control_send_queue, 3360 sctp_next) { 3361 if (tp1->sent == SCTP_DATAGRAM_RESEND) 3362 audit++; 3363 } 3364 if (audit != stcb->asoc.sent_queue_retran_cnt) { 3365 SCTP_PRINTF("**Local Audit finds cnt:%d asoc cnt:%d\n", 3366 audit, stcb->asoc.sent_queue_retran_cnt); 3367#ifndef SCTP_AUDITING_ENABLED 3368 stcb->asoc.sent_queue_retran_cnt = audit; 3369#endif 3370 } 3371 } 3372 } 3373 break; 3374 case SCTP_ASCONF: 3375 { 3376 struct sctp_tmit_chunk *asconf; 3377 3378 TAILQ_FOREACH(asconf, &stcb->asoc.control_send_queue, 3379 sctp_next) { 3380 if (asconf->rec.chunk_id.id == SCTP_ASCONF) { 3381 break; 3382 } 3383 } 3384 if (asconf) { 3385 if (asconf->sent != SCTP_DATAGRAM_RESEND) 3386 sctp_ucount_incr(stcb->asoc.sent_queue_retran_cnt); 3387 asconf->sent = SCTP_DATAGRAM_RESEND; 3388 asconf->snd_count--; 3389 } 3390 } 3391 break; 3392 case SCTP_INITIATION: 3393 /* resend the INIT */ 3394 stcb->asoc.dropped_special_cnt++; 3395 if (stcb->asoc.dropped_special_cnt < SCTP_RETRY_DROPPED_THRESH) { 3396 /* 3397 * If we can get it in, in a few attempts we do 3398 * this, otherwise we let the timer fire. 3399 */ 3400 sctp_timer_stop(SCTP_TIMER_TYPE_INIT, stcb->sctp_ep, 3401 stcb, net, 3402 SCTP_FROM_SCTP_INPUT + SCTP_LOC_27); 3403 sctp_send_initiate(stcb->sctp_ep, stcb, SCTP_SO_NOT_LOCKED); 3404 } 3405 break; 3406 case SCTP_SELECTIVE_ACK: 3407 case SCTP_NR_SELECTIVE_ACK: 3408 /* resend the sack */ 3409 sctp_send_sack(stcb, SCTP_SO_NOT_LOCKED); 3410 break; 3411 case SCTP_HEARTBEAT_REQUEST: 3412 /* resend a demand HB */ 3413 if ((stcb->asoc.overall_error_count + 3) < stcb->asoc.max_send_times) { 3414 /* 3415 * Only retransmit if we KNOW we wont destroy the 3416 * tcb 3417 */ 3418 sctp_send_hb(stcb, net, SCTP_SO_NOT_LOCKED); 3419 } 3420 break; 3421 case SCTP_SHUTDOWN: 3422 sctp_send_shutdown(stcb, net); 3423 break; 3424 case SCTP_SHUTDOWN_ACK: 3425 sctp_send_shutdown_ack(stcb, net); 3426 break; 3427 case SCTP_COOKIE_ECHO: 3428 { 3429 struct sctp_tmit_chunk *cookie; 3430 3431 cookie = NULL; 3432 TAILQ_FOREACH(cookie, &stcb->asoc.control_send_queue, 3433 sctp_next) { 3434 if (cookie->rec.chunk_id.id == SCTP_COOKIE_ECHO) { 3435 break; 3436 } 3437 } 3438 if (cookie) { 3439 if (cookie->sent != SCTP_DATAGRAM_RESEND) 3440 sctp_ucount_incr(stcb->asoc.sent_queue_retran_cnt); 3441 cookie->sent = SCTP_DATAGRAM_RESEND; 3442 sctp_stop_all_cookie_timers(stcb); 3443 } 3444 } 3445 break; 3446 case SCTP_COOKIE_ACK: 3447 sctp_send_cookie_ack(stcb); 3448 break; 3449 case SCTP_ASCONF_ACK: 3450 /* resend last asconf ack */ 3451 sctp_send_asconf_ack(stcb); 3452 break; 3453 case SCTP_FORWARD_CUM_TSN: 3454 send_forward_tsn(stcb, &stcb->asoc); 3455 break; 3456 /* can't do anything with these */ 3457 case SCTP_PACKET_DROPPED: 3458 case SCTP_INITIATION_ACK: /* this should not happen */ 3459 case SCTP_HEARTBEAT_ACK: 3460 case SCTP_ABORT_ASSOCIATION: 3461 case SCTP_OPERATION_ERROR: 3462 case SCTP_SHUTDOWN_COMPLETE: 3463 case SCTP_ECN_ECHO: 3464 case SCTP_ECN_CWR: 3465 default: 3466 break; 3467 } 3468 return (0); 3469} 3470 3471void 3472sctp_reset_in_stream(struct sctp_tcb *stcb, uint32_t number_entries, uint16_t * list) 3473{ 3474 uint32_t i; 3475 uint16_t temp; 3476 3477 /* 3478 * We set things to 0xffff since this is the last delivered sequence 3479 * and we will be sending in 0 after the reset. 3480 */ 3481 3482 if (number_entries) { 3483 for (i = 0; i < number_entries; i++) { 3484 temp = ntohs(list[i]); 3485 if (temp >= stcb->asoc.streamincnt) { 3486 continue; 3487 } 3488 stcb->asoc.strmin[temp].last_sequence_delivered = 0xffff; 3489 } 3490 } else { 3491 list = NULL; 3492 for (i = 0; i < stcb->asoc.streamincnt; i++) { 3493 stcb->asoc.strmin[i].last_sequence_delivered = 0xffff; 3494 } 3495 } 3496 sctp_ulp_notify(SCTP_NOTIFY_STR_RESET_RECV, stcb, number_entries, (void *)list, SCTP_SO_NOT_LOCKED); 3497} 3498 3499static void 3500sctp_reset_out_streams(struct sctp_tcb *stcb, uint32_t number_entries, uint16_t * list) 3501{ 3502 uint32_t i; 3503 uint16_t temp; 3504 3505 if (number_entries > 0) { 3506 for (i = 0; i < number_entries; i++) { 3507 temp = ntohs(list[i]); 3508 if (temp >= stcb->asoc.streamoutcnt) { 3509 /* no such stream */ 3510 continue; 3511 } 3512 stcb->asoc.strmout[temp].next_sequence_send = 0; 3513 } 3514 } else { 3515 for (i = 0; i < stcb->asoc.streamoutcnt; i++) { 3516 stcb->asoc.strmout[i].next_sequence_send = 0; 3517 } 3518 } 3519 sctp_ulp_notify(SCTP_NOTIFY_STR_RESET_SEND, stcb, number_entries, (void *)list, SCTP_SO_NOT_LOCKED); 3520} 3521 3522static void 3523sctp_reset_clear_pending(struct sctp_tcb *stcb, uint32_t number_entries, uint16_t * list) 3524{ 3525 uint32_t i; 3526 uint16_t temp; 3527 3528 if (number_entries > 0) { 3529 for (i = 0; i < number_entries; i++) { 3530 temp = ntohs(list[i]); 3531 if (temp >= stcb->asoc.streamoutcnt) { 3532 /* no such stream */ 3533 continue; 3534 } 3535 stcb->asoc.strmout[temp].state = SCTP_STREAM_OPEN; 3536 } 3537 } else { 3538 for (i = 0; i < stcb->asoc.streamoutcnt; i++) { 3539 stcb->asoc.strmout[i].state = SCTP_STREAM_OPEN; 3540 } 3541 } 3542} 3543 3544 3545struct sctp_stream_reset_request * 3546sctp_find_stream_reset(struct sctp_tcb *stcb, uint32_t seq, struct sctp_tmit_chunk **bchk) 3547{ 3548 struct sctp_association *asoc; 3549 struct sctp_chunkhdr *ch; 3550 struct sctp_stream_reset_request *r; 3551 struct sctp_tmit_chunk *chk; 3552 int len, clen; 3553 3554 asoc = &stcb->asoc; 3555 if (TAILQ_EMPTY(&stcb->asoc.control_send_queue)) { 3556 asoc->stream_reset_outstanding = 0; 3557 return (NULL); 3558 } 3559 if (stcb->asoc.str_reset == NULL) { 3560 asoc->stream_reset_outstanding = 0; 3561 return (NULL); 3562 } 3563 chk = stcb->asoc.str_reset; 3564 if (chk->data == NULL) { 3565 return (NULL); 3566 } 3567 if (bchk) { 3568 /* he wants a copy of the chk pointer */ 3569 *bchk = chk; 3570 } 3571 clen = chk->send_size; 3572 ch = mtod(chk->data, struct sctp_chunkhdr *); 3573 r = (struct sctp_stream_reset_request *)(ch + 1); 3574 if (ntohl(r->request_seq) == seq) { 3575 /* found it */ 3576 return (r); 3577 } 3578 len = SCTP_SIZE32(ntohs(r->ph.param_length)); 3579 if (clen > (len + (int)sizeof(struct sctp_chunkhdr))) { 3580 /* move to the next one, there can only be a max of two */ 3581 r = (struct sctp_stream_reset_request *)((caddr_t)r + len); 3582 if (ntohl(r->request_seq) == seq) { 3583 return (r); 3584 } 3585 } 3586 /* that seq is not here */ 3587 return (NULL); 3588} 3589 3590static void 3591sctp_clean_up_stream_reset(struct sctp_tcb *stcb) 3592{ 3593 struct sctp_association *asoc; 3594 struct sctp_tmit_chunk *chk = stcb->asoc.str_reset; 3595 3596 if (stcb->asoc.str_reset == NULL) { 3597 return; 3598 } 3599 asoc = &stcb->asoc; 3600 3601 sctp_timer_stop(SCTP_TIMER_TYPE_STRRESET, stcb->sctp_ep, stcb, 3602 chk->whoTo, SCTP_FROM_SCTP_INPUT + SCTP_LOC_28); 3603 TAILQ_REMOVE(&asoc->control_send_queue, 3604 chk, 3605 sctp_next); 3606 if (chk->data) { 3607 sctp_m_freem(chk->data); 3608 chk->data = NULL; 3609 } 3610 asoc->ctrl_queue_cnt--; 3611 sctp_free_a_chunk(stcb, chk, SCTP_SO_NOT_LOCKED); 3612 /* sa_ignore NO_NULL_CHK */ 3613 stcb->asoc.str_reset = NULL; 3614} 3615 3616 3617static int 3618sctp_handle_stream_reset_response(struct sctp_tcb *stcb, 3619 uint32_t seq, uint32_t action, 3620 struct sctp_stream_reset_response *respin) 3621{ 3622 uint16_t type; 3623 int lparm_len; 3624 struct sctp_association *asoc = &stcb->asoc; 3625 struct sctp_tmit_chunk *chk; 3626 struct sctp_stream_reset_request *req_param; 3627 struct sctp_stream_reset_out_request *req_out_param; 3628 struct sctp_stream_reset_in_request *req_in_param; 3629 uint32_t number_entries; 3630 3631 if (asoc->stream_reset_outstanding == 0) { 3632 /* duplicate */ 3633 return (0); 3634 } 3635 if (seq == stcb->asoc.str_reset_seq_out) { 3636 req_param = sctp_find_stream_reset(stcb, seq, &chk); 3637 if (req_param != NULL) { 3638 stcb->asoc.str_reset_seq_out++; 3639 type = ntohs(req_param->ph.param_type); 3640 lparm_len = ntohs(req_param->ph.param_length); 3641 if (type == SCTP_STR_RESET_OUT_REQUEST) { 3642 int no_clear = 0; 3643 3644 req_out_param = (struct sctp_stream_reset_out_request *)req_param; 3645 number_entries = (lparm_len - sizeof(struct sctp_stream_reset_out_request)) / sizeof(uint16_t); 3646 asoc->stream_reset_out_is_outstanding = 0; 3647 if (asoc->stream_reset_outstanding) 3648 asoc->stream_reset_outstanding--; 3649 if (action == SCTP_STREAM_RESET_RESULT_PERFORMED) { 3650 /* do it */ 3651 sctp_reset_out_streams(stcb, number_entries, req_out_param->list_of_streams); 3652 } else if (action == SCTP_STREAM_RESET_RESULT_DENIED) { 3653 sctp_ulp_notify(SCTP_NOTIFY_STR_RESET_DENIED_OUT, stcb, number_entries, req_out_param->list_of_streams, SCTP_SO_NOT_LOCKED); 3654 } else if (action == SCTP_STREAM_RESET_RESULT_IN_PROGRESS) { 3655 /* 3656 * Set it up so we don't stop 3657 * retransmitting 3658 */ 3659 asoc->stream_reset_outstanding++; 3660 stcb->asoc.str_reset_seq_out--; 3661 asoc->stream_reset_out_is_outstanding = 1; 3662 no_clear = 1; 3663 } else { 3664 sctp_ulp_notify(SCTP_NOTIFY_STR_RESET_FAILED_OUT, stcb, number_entries, req_out_param->list_of_streams, SCTP_SO_NOT_LOCKED); 3665 } 3666 if (no_clear == 0) { 3667 sctp_reset_clear_pending(stcb, number_entries, req_out_param->list_of_streams); 3668 } 3669 } else if (type == SCTP_STR_RESET_IN_REQUEST) { 3670 req_in_param = (struct sctp_stream_reset_in_request *)req_param; 3671 number_entries = (lparm_len - sizeof(struct sctp_stream_reset_in_request)) / sizeof(uint16_t); 3672 if (asoc->stream_reset_outstanding) 3673 asoc->stream_reset_outstanding--; 3674 if (action == SCTP_STREAM_RESET_RESULT_DENIED) { 3675 sctp_ulp_notify(SCTP_NOTIFY_STR_RESET_DENIED_IN, stcb, 3676 number_entries, req_in_param->list_of_streams, SCTP_SO_NOT_LOCKED); 3677 } else if (action != SCTP_STREAM_RESET_RESULT_PERFORMED) { 3678 sctp_ulp_notify(SCTP_NOTIFY_STR_RESET_FAILED_IN, stcb, 3679 number_entries, req_in_param->list_of_streams, SCTP_SO_NOT_LOCKED); 3680 } 3681 } else if (type == SCTP_STR_RESET_ADD_OUT_STREAMS) { 3682 /* Ok we now may have more streams */ 3683 int num_stream; 3684 3685 num_stream = stcb->asoc.strm_pending_add_size; 3686 if (num_stream > (stcb->asoc.strm_realoutsize - stcb->asoc.streamoutcnt)) { 3687 /* TSNH */ 3688 num_stream = stcb->asoc.strm_realoutsize - stcb->asoc.streamoutcnt; 3689 } 3690 stcb->asoc.strm_pending_add_size = 0; 3691 if (asoc->stream_reset_outstanding) 3692 asoc->stream_reset_outstanding--; 3693 if (action == SCTP_STREAM_RESET_RESULT_PERFORMED) { 3694 /* Put the new streams into effect */ 3695 int i; 3696 3697 for (i = asoc->streamoutcnt; i < (asoc->streamoutcnt + num_stream); i++) { 3698 asoc->strmout[i].state = SCTP_STREAM_OPEN; 3699 } 3700 asoc->streamoutcnt += num_stream; 3701 sctp_notify_stream_reset_add(stcb, stcb->asoc.streamincnt, stcb->asoc.streamoutcnt, 0); 3702 } else if (action == SCTP_STREAM_RESET_RESULT_DENIED) { 3703 sctp_notify_stream_reset_add(stcb, stcb->asoc.streamincnt, stcb->asoc.streamoutcnt, 3704 SCTP_STREAM_CHANGE_DENIED); 3705 } else { 3706 sctp_notify_stream_reset_add(stcb, stcb->asoc.streamincnt, stcb->asoc.streamoutcnt, 3707 SCTP_STREAM_CHANGE_FAILED); 3708 } 3709 } else if (type == SCTP_STR_RESET_ADD_IN_STREAMS) { 3710 if (asoc->stream_reset_outstanding) 3711 asoc->stream_reset_outstanding--; 3712 if (action == SCTP_STREAM_RESET_RESULT_DENIED) { 3713 sctp_notify_stream_reset_add(stcb, stcb->asoc.streamincnt, stcb->asoc.streamoutcnt, 3714 SCTP_STREAM_CHANGE_DENIED); 3715 } else if (action != SCTP_STREAM_RESET_RESULT_PERFORMED) { 3716 sctp_notify_stream_reset_add(stcb, stcb->asoc.streamincnt, stcb->asoc.streamoutcnt, 3717 SCTP_STREAM_CHANGE_FAILED); 3718 } 3719 } else if (type == SCTP_STR_RESET_TSN_REQUEST) { 3720 /** 3721 * a) Adopt the new in tsn. 3722 * b) reset the map 3723 * c) Adopt the new out-tsn 3724 */ 3725 struct sctp_stream_reset_response_tsn *resp; 3726 struct sctp_forward_tsn_chunk fwdtsn; 3727 int abort_flag = 0; 3728 3729 if (respin == NULL) { 3730 /* huh ? */ 3731 return (0); 3732 } 3733 if (ntohs(respin->ph.param_length) < sizeof(struct sctp_stream_reset_response_tsn)) { 3734 return (0); 3735 } 3736 if (action == SCTP_STREAM_RESET_RESULT_PERFORMED) { 3737 resp = (struct sctp_stream_reset_response_tsn *)respin; 3738 asoc->stream_reset_outstanding--; 3739 fwdtsn.ch.chunk_length = htons(sizeof(struct sctp_forward_tsn_chunk)); 3740 fwdtsn.ch.chunk_type = SCTP_FORWARD_CUM_TSN; 3741 fwdtsn.new_cumulative_tsn = htonl(ntohl(resp->senders_next_tsn) - 1); 3742 sctp_handle_forward_tsn(stcb, &fwdtsn, &abort_flag, NULL, 0); 3743 if (abort_flag) { 3744 return (1); 3745 } 3746 stcb->asoc.highest_tsn_inside_map = (ntohl(resp->senders_next_tsn) - 1); 3747 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_MAP_LOGGING_ENABLE) { 3748 sctp_log_map(0, 7, asoc->highest_tsn_inside_map, SCTP_MAP_SLIDE_RESULT); 3749 } 3750 stcb->asoc.tsn_last_delivered = stcb->asoc.cumulative_tsn = stcb->asoc.highest_tsn_inside_map; 3751 stcb->asoc.mapping_array_base_tsn = ntohl(resp->senders_next_tsn); 3752 memset(stcb->asoc.mapping_array, 0, stcb->asoc.mapping_array_size); 3753 3754 stcb->asoc.highest_tsn_inside_nr_map = stcb->asoc.highest_tsn_inside_map; 3755 memset(stcb->asoc.nr_mapping_array, 0, stcb->asoc.mapping_array_size); 3756 3757 stcb->asoc.sending_seq = ntohl(resp->receivers_next_tsn); 3758 stcb->asoc.last_acked_seq = stcb->asoc.cumulative_tsn; 3759 3760 sctp_reset_out_streams(stcb, 0, (uint16_t *) NULL); 3761 sctp_reset_in_stream(stcb, 0, (uint16_t *) NULL); 3762 sctp_notify_stream_reset_tsn(stcb, stcb->asoc.sending_seq, (stcb->asoc.mapping_array_base_tsn + 1), 0); 3763 } else if (action == SCTP_STREAM_RESET_RESULT_DENIED) { 3764 sctp_notify_stream_reset_tsn(stcb, stcb->asoc.sending_seq, (stcb->asoc.mapping_array_base_tsn + 1), 3765 SCTP_ASSOC_RESET_DENIED); 3766 } else { 3767 sctp_notify_stream_reset_tsn(stcb, stcb->asoc.sending_seq, (stcb->asoc.mapping_array_base_tsn + 1), 3768 SCTP_ASSOC_RESET_FAILED); 3769 } 3770 } 3771 /* get rid of the request and get the request flags */ 3772 if (asoc->stream_reset_outstanding == 0) { 3773 sctp_clean_up_stream_reset(stcb); 3774 } 3775 } 3776 } 3777 if (asoc->stream_reset_outstanding == 0) { 3778 sctp_send_stream_reset_out_if_possible(stcb, SCTP_SO_NOT_LOCKED); 3779 } 3780 return (0); 3781} 3782 3783static void 3784sctp_handle_str_reset_request_in(struct sctp_tcb *stcb, 3785 struct sctp_tmit_chunk *chk, 3786 struct sctp_stream_reset_in_request *req, int trunc) 3787{ 3788 uint32_t seq; 3789 int len, i; 3790 int number_entries; 3791 uint16_t temp; 3792 3793 /* 3794 * peer wants me to send a str-reset to him for my outgoing seq's if 3795 * seq_in is right. 3796 */ 3797 struct sctp_association *asoc = &stcb->asoc; 3798 3799 seq = ntohl(req->request_seq); 3800 if (asoc->str_reset_seq_in == seq) { 3801 asoc->last_reset_action[1] = asoc->last_reset_action[0]; 3802 if (!(asoc->local_strreset_support & SCTP_ENABLE_RESET_STREAM_REQ)) { 3803 asoc->last_reset_action[0] = SCTP_STREAM_RESET_RESULT_DENIED; 3804 } else if (trunc) { 3805 /* Can't do it, since they exceeded our buffer size */ 3806 asoc->last_reset_action[0] = SCTP_STREAM_RESET_RESULT_DENIED; 3807 } else if (stcb->asoc.stream_reset_out_is_outstanding == 0) { 3808 len = ntohs(req->ph.param_length); 3809 number_entries = ((len - sizeof(struct sctp_stream_reset_in_request)) / sizeof(uint16_t)); 3810 if (number_entries) { 3811 for (i = 0; i < number_entries; i++) { 3812 temp = ntohs(req->list_of_streams[i]); 3813 if (temp >= stcb->asoc.streamoutcnt) { 3814 asoc->last_reset_action[0] = SCTP_STREAM_RESET_RESULT_DENIED; 3815 goto bad_boy; 3816 } 3817 req->list_of_streams[i] = temp; 3818 } 3819 for (i = 0; i < number_entries; i++) { 3820 if (stcb->asoc.strmout[req->list_of_streams[i]].state == SCTP_STREAM_OPEN) { 3821 stcb->asoc.strmout[req->list_of_streams[i]].state = SCTP_STREAM_RESET_PENDING; 3822 } 3823 } 3824 } else { 3825 /* Its all */ 3826 for (i = 0; i < stcb->asoc.streamoutcnt; i++) { 3827 if (stcb->asoc.strmout[i].state == SCTP_STREAM_OPEN) 3828 stcb->asoc.strmout[i].state = SCTP_STREAM_RESET_PENDING; 3829 } 3830 } 3831 asoc->last_reset_action[0] = SCTP_STREAM_RESET_RESULT_PERFORMED; 3832 } else { 3833 /* Can't do it, since we have sent one out */ 3834 asoc->last_reset_action[0] = SCTP_STREAM_RESET_RESULT_ERR_IN_PROGRESS; 3835 } 3836bad_boy: 3837 sctp_add_stream_reset_result(chk, seq, asoc->last_reset_action[0]); 3838 asoc->str_reset_seq_in++; 3839 } else if (asoc->str_reset_seq_in - 1 == seq) { 3840 sctp_add_stream_reset_result(chk, seq, asoc->last_reset_action[0]); 3841 } else if (asoc->str_reset_seq_in - 2 == seq) { 3842 sctp_add_stream_reset_result(chk, seq, asoc->last_reset_action[1]); 3843 } else { 3844 sctp_add_stream_reset_result(chk, seq, SCTP_STREAM_RESET_RESULT_ERR_BAD_SEQNO); 3845 } 3846 sctp_send_stream_reset_out_if_possible(stcb, SCTP_SO_NOT_LOCKED); 3847} 3848 3849static int 3850sctp_handle_str_reset_request_tsn(struct sctp_tcb *stcb, 3851 struct sctp_tmit_chunk *chk, 3852 struct sctp_stream_reset_tsn_request *req) 3853{ 3854 /* reset all in and out and update the tsn */ 3855 /* 3856 * A) reset my str-seq's on in and out. B) Select a receive next, 3857 * and set cum-ack to it. Also process this selected number as a 3858 * fwd-tsn as well. C) set in the response my next sending seq. 3859 */ 3860 struct sctp_forward_tsn_chunk fwdtsn; 3861 struct sctp_association *asoc = &stcb->asoc; 3862 int abort_flag = 0; 3863 uint32_t seq; 3864 3865 seq = ntohl(req->request_seq); 3866 if (asoc->str_reset_seq_in == seq) { 3867 asoc->last_reset_action[1] = stcb->asoc.last_reset_action[0]; 3868 if (!(asoc->local_strreset_support & SCTP_ENABLE_CHANGE_ASSOC_REQ)) { 3869 asoc->last_reset_action[0] = SCTP_STREAM_RESET_RESULT_DENIED; 3870 } else { 3871 fwdtsn.ch.chunk_length = htons(sizeof(struct sctp_forward_tsn_chunk)); 3872 fwdtsn.ch.chunk_type = SCTP_FORWARD_CUM_TSN; 3873 fwdtsn.ch.chunk_flags = 0; 3874 fwdtsn.new_cumulative_tsn = htonl(stcb->asoc.highest_tsn_inside_map + 1); 3875 sctp_handle_forward_tsn(stcb, &fwdtsn, &abort_flag, NULL, 0); 3876 if (abort_flag) { 3877 return (1); 3878 } 3879 asoc->highest_tsn_inside_map += SCTP_STREAM_RESET_TSN_DELTA; 3880 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_MAP_LOGGING_ENABLE) { 3881 sctp_log_map(0, 10, asoc->highest_tsn_inside_map, SCTP_MAP_SLIDE_RESULT); 3882 } 3883 asoc->tsn_last_delivered = asoc->cumulative_tsn = asoc->highest_tsn_inside_map; 3884 asoc->mapping_array_base_tsn = asoc->highest_tsn_inside_map + 1; 3885 memset(asoc->mapping_array, 0, asoc->mapping_array_size); 3886 asoc->highest_tsn_inside_nr_map = asoc->highest_tsn_inside_map; 3887 memset(asoc->nr_mapping_array, 0, asoc->mapping_array_size); 3888 atomic_add_int(&asoc->sending_seq, 1); 3889 /* save off historical data for retrans */ 3890 asoc->last_sending_seq[1] = asoc->last_sending_seq[0]; 3891 asoc->last_sending_seq[0] = asoc->sending_seq; 3892 asoc->last_base_tsnsent[1] = asoc->last_base_tsnsent[0]; 3893 asoc->last_base_tsnsent[0] = asoc->mapping_array_base_tsn; 3894 sctp_reset_out_streams(stcb, 0, (uint16_t *) NULL); 3895 sctp_reset_in_stream(stcb, 0, (uint16_t *) NULL); 3896 asoc->last_reset_action[0] = SCTP_STREAM_RESET_RESULT_PERFORMED; 3897 sctp_notify_stream_reset_tsn(stcb, asoc->sending_seq, (asoc->mapping_array_base_tsn + 1), 0); 3898 } 3899 sctp_add_stream_reset_result_tsn(chk, seq, asoc->last_reset_action[0], 3900 asoc->last_sending_seq[0], asoc->last_base_tsnsent[0]); 3901 asoc->str_reset_seq_in++; 3902 } else if (asoc->str_reset_seq_in - 1 == seq) { 3903 sctp_add_stream_reset_result_tsn(chk, seq, asoc->last_reset_action[0], 3904 asoc->last_sending_seq[0], asoc->last_base_tsnsent[0]); 3905 } else if (asoc->str_reset_seq_in - 2 == seq) { 3906 sctp_add_stream_reset_result_tsn(chk, seq, asoc->last_reset_action[1], 3907 asoc->last_sending_seq[1], asoc->last_base_tsnsent[1]); 3908 } else { 3909 sctp_add_stream_reset_result(chk, seq, SCTP_STREAM_RESET_RESULT_ERR_BAD_SEQNO); 3910 } 3911 return (0); 3912} 3913 3914static void 3915sctp_handle_str_reset_request_out(struct sctp_tcb *stcb, 3916 struct sctp_tmit_chunk *chk, 3917 struct sctp_stream_reset_out_request *req, int trunc) 3918{ 3919 uint32_t seq, tsn; 3920 int number_entries, len; 3921 struct sctp_association *asoc = &stcb->asoc; 3922 3923 seq = ntohl(req->request_seq); 3924 3925 /* now if its not a duplicate we process it */ 3926 if (asoc->str_reset_seq_in == seq) { 3927 len = ntohs(req->ph.param_length); 3928 number_entries = ((len - sizeof(struct sctp_stream_reset_out_request)) / sizeof(uint16_t)); 3929 /* 3930 * the sender is resetting, handle the list issue.. we must 3931 * a) verify if we can do the reset, if so no problem b) If 3932 * we can't do the reset we must copy the request. c) queue 3933 * it, and setup the data in processor to trigger it off 3934 * when needed and dequeue all the queued data. 3935 */ 3936 tsn = ntohl(req->send_reset_at_tsn); 3937 3938 /* move the reset action back one */ 3939 asoc->last_reset_action[1] = asoc->last_reset_action[0]; 3940 if (!(asoc->local_strreset_support & SCTP_ENABLE_RESET_STREAM_REQ)) { 3941 asoc->last_reset_action[0] = SCTP_STREAM_RESET_RESULT_DENIED; 3942 } else if (trunc) { 3943 asoc->last_reset_action[0] = SCTP_STREAM_RESET_RESULT_DENIED; 3944 } else if (SCTP_TSN_GE(asoc->cumulative_tsn, tsn)) { 3945 /* we can do it now */ 3946 sctp_reset_in_stream(stcb, number_entries, req->list_of_streams); 3947 asoc->last_reset_action[0] = SCTP_STREAM_RESET_RESULT_PERFORMED; 3948 } else { 3949 /* 3950 * we must queue it up and thus wait for the TSN's 3951 * to arrive that are at or before tsn 3952 */ 3953 struct sctp_stream_reset_list *liste; 3954 int siz; 3955 3956 siz = sizeof(struct sctp_stream_reset_list) + (number_entries * sizeof(uint16_t)); 3957 SCTP_MALLOC(liste, struct sctp_stream_reset_list *, 3958 siz, SCTP_M_STRESET); 3959 if (liste == NULL) { 3960 /* gak out of memory */ 3961 asoc->last_reset_action[0] = SCTP_STREAM_RESET_RESULT_DENIED; 3962 sctp_add_stream_reset_result(chk, seq, asoc->last_reset_action[0]); 3963 return; 3964 } 3965 liste->seq = seq; 3966 liste->tsn = tsn; 3967 liste->number_entries = number_entries; 3968 memcpy(&liste->list_of_streams, req->list_of_streams, number_entries * sizeof(uint16_t)); 3969 TAILQ_INSERT_TAIL(&asoc->resetHead, liste, next_resp); 3970 asoc->last_reset_action[0] = SCTP_STREAM_RESET_RESULT_IN_PROGRESS; 3971 } 3972 sctp_add_stream_reset_result(chk, seq, asoc->last_reset_action[0]); 3973 asoc->str_reset_seq_in++; 3974 } else if ((asoc->str_reset_seq_in - 1) == seq) { 3975 /* 3976 * one seq back, just echo back last action since my 3977 * response was lost. 3978 */ 3979 sctp_add_stream_reset_result(chk, seq, asoc->last_reset_action[0]); 3980 } else if ((asoc->str_reset_seq_in - 2) == seq) { 3981 /* 3982 * two seq back, just echo back last action since my 3983 * response was lost. 3984 */ 3985 sctp_add_stream_reset_result(chk, seq, asoc->last_reset_action[1]); 3986 } else { 3987 sctp_add_stream_reset_result(chk, seq, SCTP_STREAM_RESET_RESULT_ERR_BAD_SEQNO); 3988 } 3989} 3990 3991static void 3992sctp_handle_str_reset_add_strm(struct sctp_tcb *stcb, struct sctp_tmit_chunk *chk, 3993 struct sctp_stream_reset_add_strm *str_add) 3994{ 3995 /* 3996 * Peer is requesting to add more streams. If its within our 3997 * max-streams we will allow it. 3998 */ 3999 uint32_t num_stream, i; 4000 uint32_t seq; 4001 struct sctp_association *asoc = &stcb->asoc; 4002 struct sctp_queued_to_read *ctl, *nctl; 4003 4004 /* Get the number. */ 4005 seq = ntohl(str_add->request_seq); 4006 num_stream = ntohs(str_add->number_of_streams); 4007 /* Now what would be the new total? */ 4008 if (asoc->str_reset_seq_in == seq) { 4009 num_stream += stcb->asoc.streamincnt; 4010 stcb->asoc.last_reset_action[1] = stcb->asoc.last_reset_action[0]; 4011 if (!(asoc->local_strreset_support & SCTP_ENABLE_CHANGE_ASSOC_REQ)) { 4012 asoc->last_reset_action[0] = SCTP_STREAM_RESET_RESULT_DENIED; 4013 } else if ((num_stream > stcb->asoc.max_inbound_streams) || 4014 (num_stream > 0xffff)) { 4015 /* We must reject it they ask for to many */ 4016 denied: 4017 stcb->asoc.last_reset_action[0] = SCTP_STREAM_RESET_RESULT_DENIED; 4018 } else { 4019 /* Ok, we can do that :-) */ 4020 struct sctp_stream_in *oldstrm; 4021 4022 /* save off the old */ 4023 oldstrm = stcb->asoc.strmin; 4024 SCTP_MALLOC(stcb->asoc.strmin, struct sctp_stream_in *, 4025 (num_stream * sizeof(struct sctp_stream_in)), 4026 SCTP_M_STRMI); 4027 if (stcb->asoc.strmin == NULL) { 4028 stcb->asoc.strmin = oldstrm; 4029 goto denied; 4030 } 4031 /* copy off the old data */ 4032 for (i = 0; i < stcb->asoc.streamincnt; i++) { 4033 TAILQ_INIT(&stcb->asoc.strmin[i].inqueue); 4034 stcb->asoc.strmin[i].stream_no = i; 4035 stcb->asoc.strmin[i].last_sequence_delivered = oldstrm[i].last_sequence_delivered; 4036 stcb->asoc.strmin[i].delivery_started = oldstrm[i].delivery_started; 4037 /* now anything on those queues? */ 4038 TAILQ_FOREACH_SAFE(ctl, &oldstrm[i].inqueue, next, nctl) { 4039 TAILQ_REMOVE(&oldstrm[i].inqueue, ctl, next); 4040 TAILQ_INSERT_TAIL(&stcb->asoc.strmin[i].inqueue, ctl, next); 4041 } 4042 } 4043 /* Init the new streams */ 4044 for (i = stcb->asoc.streamincnt; i < num_stream; i++) { 4045 TAILQ_INIT(&stcb->asoc.strmin[i].inqueue); 4046 stcb->asoc.strmin[i].stream_no = i; 4047 stcb->asoc.strmin[i].last_sequence_delivered = 0xffff; 4048 stcb->asoc.strmin[i].delivery_started = 0; 4049 } 4050 SCTP_FREE(oldstrm, SCTP_M_STRMI); 4051 /* update the size */ 4052 stcb->asoc.streamincnt = num_stream; 4053 stcb->asoc.last_reset_action[0] = SCTP_STREAM_RESET_RESULT_PERFORMED; 4054 sctp_notify_stream_reset_add(stcb, stcb->asoc.streamincnt, stcb->asoc.streamoutcnt, 0); 4055 } 4056 sctp_add_stream_reset_result(chk, seq, asoc->last_reset_action[0]); 4057 asoc->str_reset_seq_in++; 4058 } else if ((asoc->str_reset_seq_in - 1) == seq) { 4059 /* 4060 * one seq back, just echo back last action since my 4061 * response was lost. 4062 */ 4063 sctp_add_stream_reset_result(chk, seq, asoc->last_reset_action[0]); 4064 } else if ((asoc->str_reset_seq_in - 2) == seq) { 4065 /* 4066 * two seq back, just echo back last action since my 4067 * response was lost. 4068 */ 4069 sctp_add_stream_reset_result(chk, seq, asoc->last_reset_action[1]); 4070 } else { 4071 sctp_add_stream_reset_result(chk, seq, SCTP_STREAM_RESET_RESULT_ERR_BAD_SEQNO); 4072 4073 } 4074} 4075 4076static void 4077sctp_handle_str_reset_add_out_strm(struct sctp_tcb *stcb, struct sctp_tmit_chunk *chk, 4078 struct sctp_stream_reset_add_strm *str_add) 4079{ 4080 /* 4081 * Peer is requesting to add more streams. If its within our 4082 * max-streams we will allow it. 4083 */ 4084 uint16_t num_stream; 4085 uint32_t seq; 4086 struct sctp_association *asoc = &stcb->asoc; 4087 4088 /* Get the number. */ 4089 seq = ntohl(str_add->request_seq); 4090 num_stream = ntohs(str_add->number_of_streams); 4091 /* Now what would be the new total? */ 4092 if (asoc->str_reset_seq_in == seq) { 4093 stcb->asoc.last_reset_action[1] = stcb->asoc.last_reset_action[0]; 4094 if (!(asoc->local_strreset_support & SCTP_ENABLE_CHANGE_ASSOC_REQ)) { 4095 asoc->last_reset_action[0] = SCTP_STREAM_RESET_RESULT_DENIED; 4096 } else if (stcb->asoc.stream_reset_outstanding) { 4097 /* We must reject it we have something pending */ 4098 stcb->asoc.last_reset_action[0] = SCTP_STREAM_RESET_RESULT_ERR_IN_PROGRESS; 4099 } else { 4100 /* Ok, we can do that :-) */ 4101 int mychk; 4102 4103 mychk = stcb->asoc.streamoutcnt; 4104 mychk += num_stream; 4105 if (mychk < 0x10000) { 4106 stcb->asoc.last_reset_action[0] = SCTP_STREAM_RESET_RESULT_PERFORMED; 4107 if (sctp_send_str_reset_req(stcb, 0, NULL, 0, 0, 1, num_stream, 0, 1)) { 4108 stcb->asoc.last_reset_action[0] = SCTP_STREAM_RESET_RESULT_DENIED; 4109 } 4110 } else { 4111 stcb->asoc.last_reset_action[0] = SCTP_STREAM_RESET_RESULT_DENIED; 4112 } 4113 } 4114 sctp_add_stream_reset_result(chk, seq, stcb->asoc.last_reset_action[0]); 4115 asoc->str_reset_seq_in++; 4116 } else if ((asoc->str_reset_seq_in - 1) == seq) { 4117 /* 4118 * one seq back, just echo back last action since my 4119 * response was lost. 4120 */ 4121 sctp_add_stream_reset_result(chk, seq, asoc->last_reset_action[0]); 4122 } else if ((asoc->str_reset_seq_in - 2) == seq) { 4123 /* 4124 * two seq back, just echo back last action since my 4125 * response was lost. 4126 */ 4127 sctp_add_stream_reset_result(chk, seq, asoc->last_reset_action[1]); 4128 } else { 4129 sctp_add_stream_reset_result(chk, seq, SCTP_STREAM_RESET_RESULT_ERR_BAD_SEQNO); 4130 } 4131} 4132 4133#ifdef __GNUC__ 4134__attribute__((noinline)) 4135#endif 4136 static int 4137 sctp_handle_stream_reset(struct sctp_tcb *stcb, struct mbuf *m, int offset, 4138 struct sctp_chunkhdr *ch_req) 4139{ 4140 uint16_t remaining_length, param_len, ptype; 4141 struct sctp_paramhdr pstore; 4142 uint8_t cstore[SCTP_CHUNK_BUFFER_SIZE]; 4143 uint32_t seq = 0; 4144 int num_req = 0; 4145 int trunc = 0; 4146 struct sctp_tmit_chunk *chk; 4147 struct sctp_chunkhdr *ch; 4148 struct sctp_paramhdr *ph; 4149 int ret_code = 0; 4150 int num_param = 0; 4151 4152 /* now it may be a reset or a reset-response */ 4153 remaining_length = ntohs(ch_req->chunk_length) - sizeof(struct sctp_chunkhdr); 4154 4155 /* setup for adding the response */ 4156 sctp_alloc_a_chunk(stcb, chk); 4157 if (chk == NULL) { 4158 return (ret_code); 4159 } 4160 chk->copy_by_ref = 0; 4161 chk->rec.chunk_id.id = SCTP_STREAM_RESET; 4162 chk->rec.chunk_id.can_take_data = 0; 4163 chk->flags = 0; 4164 chk->asoc = &stcb->asoc; 4165 chk->no_fr_allowed = 0; 4166 chk->book_size = chk->send_size = sizeof(struct sctp_chunkhdr); 4167 chk->book_size_scale = 0; 4168 chk->data = sctp_get_mbuf_for_msg(MCLBYTES, 0, M_NOWAIT, 1, MT_DATA); 4169 if (chk->data == NULL) { 4170strres_nochunk: 4171 if (chk->data) { 4172 sctp_m_freem(chk->data); 4173 chk->data = NULL; 4174 } 4175 sctp_free_a_chunk(stcb, chk, SCTP_SO_NOT_LOCKED); 4176 return (ret_code); 4177 } 4178 SCTP_BUF_RESV_UF(chk->data, SCTP_MIN_OVERHEAD); 4179 4180 /* setup chunk parameters */ 4181 chk->sent = SCTP_DATAGRAM_UNSENT; 4182 chk->snd_count = 0; 4183 chk->whoTo = NULL; 4184 4185 ch = mtod(chk->data, struct sctp_chunkhdr *); 4186 ch->chunk_type = SCTP_STREAM_RESET; 4187 ch->chunk_flags = 0; 4188 ch->chunk_length = htons(chk->send_size); 4189 SCTP_BUF_LEN(chk->data) = SCTP_SIZE32(chk->send_size); 4190 offset += sizeof(struct sctp_chunkhdr); 4191 while (remaining_length >= sizeof(struct sctp_paramhdr)) { 4192 ph = (struct sctp_paramhdr *)sctp_m_getptr(m, offset, sizeof(pstore), (uint8_t *) & pstore); 4193 if (ph == NULL) { 4194 /* TSNH */ 4195 break; 4196 } 4197 param_len = ntohs(ph->param_length); 4198 if ((param_len > remaining_length) || 4199 (param_len < (sizeof(struct sctp_paramhdr) + sizeof(uint32_t)))) { 4200 /* bad parameter length */ 4201 break; 4202 } 4203 ph = (struct sctp_paramhdr *)sctp_m_getptr(m, offset, min(param_len, sizeof(cstore)), 4204 (uint8_t *) & cstore); 4205 if (ph == NULL) { 4206 /* TSNH */ 4207 break; 4208 } 4209 ptype = ntohs(ph->param_type); 4210 num_param++; 4211 if (param_len > sizeof(cstore)) { 4212 trunc = 1; 4213 } else { 4214 trunc = 0; 4215 } 4216 if (num_param > SCTP_MAX_RESET_PARAMS) { 4217 /* hit the max of parameters already sorry.. */ 4218 break; 4219 } 4220 if (ptype == SCTP_STR_RESET_OUT_REQUEST) { 4221 struct sctp_stream_reset_out_request *req_out; 4222 4223 if (param_len < sizeof(struct sctp_stream_reset_out_request)) { 4224 break; 4225 } 4226 req_out = (struct sctp_stream_reset_out_request *)ph; 4227 num_req++; 4228 if (stcb->asoc.stream_reset_outstanding) { 4229 seq = ntohl(req_out->response_seq); 4230 if (seq == stcb->asoc.str_reset_seq_out) { 4231 /* implicit ack */ 4232 (void)sctp_handle_stream_reset_response(stcb, seq, SCTP_STREAM_RESET_RESULT_PERFORMED, NULL); 4233 } 4234 } 4235 sctp_handle_str_reset_request_out(stcb, chk, req_out, trunc); 4236 } else if (ptype == SCTP_STR_RESET_ADD_OUT_STREAMS) { 4237 struct sctp_stream_reset_add_strm *str_add; 4238 4239 if (param_len < sizeof(struct sctp_stream_reset_add_strm)) { 4240 break; 4241 } 4242 str_add = (struct sctp_stream_reset_add_strm *)ph; 4243 num_req++; 4244 sctp_handle_str_reset_add_strm(stcb, chk, str_add); 4245 } else if (ptype == SCTP_STR_RESET_ADD_IN_STREAMS) { 4246 struct sctp_stream_reset_add_strm *str_add; 4247 4248 if (param_len < sizeof(struct sctp_stream_reset_add_strm)) { 4249 break; 4250 } 4251 str_add = (struct sctp_stream_reset_add_strm *)ph; 4252 num_req++; 4253 sctp_handle_str_reset_add_out_strm(stcb, chk, str_add); 4254 } else if (ptype == SCTP_STR_RESET_IN_REQUEST) { 4255 struct sctp_stream_reset_in_request *req_in; 4256 4257 num_req++; 4258 req_in = (struct sctp_stream_reset_in_request *)ph; 4259 sctp_handle_str_reset_request_in(stcb, chk, req_in, trunc); 4260 } else if (ptype == SCTP_STR_RESET_TSN_REQUEST) { 4261 struct sctp_stream_reset_tsn_request *req_tsn; 4262 4263 num_req++; 4264 req_tsn = (struct sctp_stream_reset_tsn_request *)ph; 4265 if (sctp_handle_str_reset_request_tsn(stcb, chk, req_tsn)) { 4266 ret_code = 1; 4267 goto strres_nochunk; 4268 } 4269 /* no more */ 4270 break; 4271 } else if (ptype == SCTP_STR_RESET_RESPONSE) { 4272 struct sctp_stream_reset_response *resp; 4273 uint32_t result; 4274 4275 if (param_len < sizeof(struct sctp_stream_reset_response)) { 4276 break; 4277 } 4278 resp = (struct sctp_stream_reset_response *)ph; 4279 seq = ntohl(resp->response_seq); 4280 result = ntohl(resp->result); 4281 if (sctp_handle_stream_reset_response(stcb, seq, result, resp)) { 4282 ret_code = 1; 4283 goto strres_nochunk; 4284 } 4285 } else { 4286 break; 4287 } 4288 offset += SCTP_SIZE32(param_len); 4289 if (remaining_length >= SCTP_SIZE32(param_len)) { 4290 remaining_length -= SCTP_SIZE32(param_len); 4291 } else { 4292 remaining_length = 0; 4293 } 4294 } 4295 if (num_req == 0) { 4296 /* we have no response free the stuff */ 4297 goto strres_nochunk; 4298 } 4299 /* ok we have a chunk to link in */ 4300 TAILQ_INSERT_TAIL(&stcb->asoc.control_send_queue, 4301 chk, 4302 sctp_next); 4303 stcb->asoc.ctrl_queue_cnt++; 4304 return (ret_code); 4305} 4306 4307/* 4308 * Handle a router or endpoints report of a packet loss, there are two ways 4309 * to handle this, either we get the whole packet and must disect it 4310 * ourselves (possibly with truncation and or corruption) or it is a summary 4311 * from a middle box that did the disectting for us. 4312 */ 4313static void 4314sctp_handle_packet_dropped(struct sctp_pktdrop_chunk *cp, 4315 struct sctp_tcb *stcb, struct sctp_nets *net, uint32_t limit) 4316{ 4317 uint32_t bottle_bw, on_queue; 4318 uint16_t trunc_len; 4319 unsigned int chlen; 4320 unsigned int at; 4321 struct sctp_chunk_desc desc; 4322 struct sctp_chunkhdr *ch; 4323 4324 chlen = ntohs(cp->ch.chunk_length); 4325 chlen -= sizeof(struct sctp_pktdrop_chunk); 4326 /* XXX possible chlen underflow */ 4327 if (chlen == 0) { 4328 ch = NULL; 4329 if (cp->ch.chunk_flags & SCTP_FROM_MIDDLE_BOX) 4330 SCTP_STAT_INCR(sctps_pdrpbwrpt); 4331 } else { 4332 ch = (struct sctp_chunkhdr *)(cp->data + sizeof(struct sctphdr)); 4333 chlen -= sizeof(struct sctphdr); 4334 /* XXX possible chlen underflow */ 4335 memset(&desc, 0, sizeof(desc)); 4336 } 4337 trunc_len = (uint16_t) ntohs(cp->trunc_len); 4338 if (trunc_len > limit) { 4339 trunc_len = limit; 4340 } 4341 /* now the chunks themselves */ 4342 while ((ch != NULL) && (chlen >= sizeof(struct sctp_chunkhdr))) { 4343 desc.chunk_type = ch->chunk_type; 4344 /* get amount we need to move */ 4345 at = ntohs(ch->chunk_length); 4346 if (at < sizeof(struct sctp_chunkhdr)) { 4347 /* corrupt chunk, maybe at the end? */ 4348 SCTP_STAT_INCR(sctps_pdrpcrupt); 4349 break; 4350 } 4351 if (trunc_len == 0) { 4352 /* we are supposed to have all of it */ 4353 if (at > chlen) { 4354 /* corrupt skip it */ 4355 SCTP_STAT_INCR(sctps_pdrpcrupt); 4356 break; 4357 } 4358 } else { 4359 /* is there enough of it left ? */ 4360 if (desc.chunk_type == SCTP_DATA) { 4361 if (chlen < (sizeof(struct sctp_data_chunk) + 4362 sizeof(desc.data_bytes))) { 4363 break; 4364 } 4365 } else { 4366 if (chlen < sizeof(struct sctp_chunkhdr)) { 4367 break; 4368 } 4369 } 4370 } 4371 if (desc.chunk_type == SCTP_DATA) { 4372 /* can we get out the tsn? */ 4373 if ((cp->ch.chunk_flags & SCTP_FROM_MIDDLE_BOX)) 4374 SCTP_STAT_INCR(sctps_pdrpmbda); 4375 4376 if (chlen >= (sizeof(struct sctp_data_chunk) + sizeof(uint32_t))) { 4377 /* yep */ 4378 struct sctp_data_chunk *dcp; 4379 uint8_t *ddp; 4380 unsigned int iii; 4381 4382 dcp = (struct sctp_data_chunk *)ch; 4383 ddp = (uint8_t *) (dcp + 1); 4384 for (iii = 0; iii < sizeof(desc.data_bytes); iii++) { 4385 desc.data_bytes[iii] = ddp[iii]; 4386 } 4387 desc.tsn_ifany = dcp->dp.tsn; 4388 } else { 4389 /* nope we are done. */ 4390 SCTP_STAT_INCR(sctps_pdrpnedat); 4391 break; 4392 } 4393 } else { 4394 if ((cp->ch.chunk_flags & SCTP_FROM_MIDDLE_BOX)) 4395 SCTP_STAT_INCR(sctps_pdrpmbct); 4396 } 4397 4398 if (process_chunk_drop(stcb, &desc, net, cp->ch.chunk_flags)) { 4399 SCTP_STAT_INCR(sctps_pdrppdbrk); 4400 break; 4401 } 4402 if (SCTP_SIZE32(at) > chlen) { 4403 break; 4404 } 4405 chlen -= SCTP_SIZE32(at); 4406 if (chlen < sizeof(struct sctp_chunkhdr)) { 4407 /* done, none left */ 4408 break; 4409 } 4410 ch = (struct sctp_chunkhdr *)((caddr_t)ch + SCTP_SIZE32(at)); 4411 } 4412 /* Now update any rwnd --- possibly */ 4413 if ((cp->ch.chunk_flags & SCTP_FROM_MIDDLE_BOX) == 0) { 4414 /* From a peer, we get a rwnd report */ 4415 uint32_t a_rwnd; 4416 4417 SCTP_STAT_INCR(sctps_pdrpfehos); 4418 4419 bottle_bw = ntohl(cp->bottle_bw); 4420 on_queue = ntohl(cp->current_onq); 4421 if (bottle_bw && on_queue) { 4422 /* a rwnd report is in here */ 4423 if (bottle_bw > on_queue) 4424 a_rwnd = bottle_bw - on_queue; 4425 else 4426 a_rwnd = 0; 4427 4428 if (a_rwnd == 0) 4429 stcb->asoc.peers_rwnd = 0; 4430 else { 4431 if (a_rwnd > stcb->asoc.total_flight) { 4432 stcb->asoc.peers_rwnd = 4433 a_rwnd - stcb->asoc.total_flight; 4434 } else { 4435 stcb->asoc.peers_rwnd = 0; 4436 } 4437 if (stcb->asoc.peers_rwnd < 4438 stcb->sctp_ep->sctp_ep.sctp_sws_sender) { 4439 /* SWS sender side engages */ 4440 stcb->asoc.peers_rwnd = 0; 4441 } 4442 } 4443 } 4444 } else { 4445 SCTP_STAT_INCR(sctps_pdrpfmbox); 4446 } 4447 4448 /* now middle boxes in sat networks get a cwnd bump */ 4449 if ((cp->ch.chunk_flags & SCTP_FROM_MIDDLE_BOX) && 4450 (stcb->asoc.sat_t3_loss_recovery == 0) && 4451 (stcb->asoc.sat_network)) { 4452 /* 4453 * This is debateable but for sat networks it makes sense 4454 * Note if a T3 timer has went off, we will prohibit any 4455 * changes to cwnd until we exit the t3 loss recovery. 4456 */ 4457 stcb->asoc.cc_functions.sctp_cwnd_update_after_packet_dropped(stcb, 4458 net, cp, &bottle_bw, &on_queue); 4459 } 4460} 4461 4462/* 4463 * handles all control chunks in a packet inputs: - m: mbuf chain, assumed to 4464 * still contain IP/SCTP header - stcb: is the tcb found for this packet - 4465 * offset: offset into the mbuf chain to first chunkhdr - length: is the 4466 * length of the complete packet outputs: - length: modified to remaining 4467 * length after control processing - netp: modified to new sctp_nets after 4468 * cookie-echo processing - return NULL to discard the packet (ie. no asoc, 4469 * bad packet,...) otherwise return the tcb for this packet 4470 */ 4471#ifdef __GNUC__ 4472__attribute__((noinline)) 4473#endif 4474 static struct sctp_tcb * 4475 sctp_process_control(struct mbuf *m, int iphlen, int *offset, int length, 4476 struct sockaddr *src, struct sockaddr *dst, 4477 struct sctphdr *sh, struct sctp_chunkhdr *ch, struct sctp_inpcb *inp, 4478 struct sctp_tcb *stcb, struct sctp_nets **netp, int *fwd_tsn_seen, 4479 uint8_t mflowtype, uint32_t mflowid, uint16_t fibnum, 4480 uint32_t vrf_id, uint16_t port) 4481{ 4482 struct sctp_association *asoc; 4483 struct mbuf *op_err; 4484 char msg[SCTP_DIAG_INFO_LEN]; 4485 uint32_t vtag_in; 4486 int num_chunks = 0; /* number of control chunks processed */ 4487 uint32_t chk_length; 4488 int ret; 4489 int abort_no_unlock = 0; 4490 int ecne_seen = 0; 4491 4492 /* 4493 * How big should this be, and should it be alloc'd? Lets try the 4494 * d-mtu-ceiling for now (2k) and that should hopefully work ... 4495 * until we get into jumbo grams and such.. 4496 */ 4497 uint8_t chunk_buf[SCTP_CHUNK_BUFFER_SIZE]; 4498 struct sctp_tcb *locked_tcb = stcb; 4499 int got_auth = 0; 4500 uint32_t auth_offset = 0, auth_len = 0; 4501 int auth_skipped = 0; 4502 int asconf_cnt = 0; 4503 4504#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 4505 struct socket *so; 4506 4507#endif 4508 4509 SCTPDBG(SCTP_DEBUG_INPUT1, "sctp_process_control: iphlen=%u, offset=%u, length=%u stcb:%p\n", 4510 iphlen, *offset, length, (void *)stcb); 4511 4512 /* validate chunk header length... */ 4513 if (ntohs(ch->chunk_length) < sizeof(*ch)) { 4514 SCTPDBG(SCTP_DEBUG_INPUT1, "Invalid header length %d\n", 4515 ntohs(ch->chunk_length)); 4516 if (locked_tcb) { 4517 SCTP_TCB_UNLOCK(locked_tcb); 4518 } 4519 return (NULL); 4520 } 4521 /* 4522 * validate the verification tag 4523 */ 4524 vtag_in = ntohl(sh->v_tag); 4525 4526 if (locked_tcb) { 4527 SCTP_TCB_LOCK_ASSERT(locked_tcb); 4528 } 4529 if (ch->chunk_type == SCTP_INITIATION) { 4530 SCTPDBG(SCTP_DEBUG_INPUT1, "Its an INIT of len:%d vtag:%x\n", 4531 ntohs(ch->chunk_length), vtag_in); 4532 if (vtag_in != 0) { 4533 /* protocol error- silently discard... */ 4534 SCTP_STAT_INCR(sctps_badvtag); 4535 if (locked_tcb) { 4536 SCTP_TCB_UNLOCK(locked_tcb); 4537 } 4538 return (NULL); 4539 } 4540 } else if (ch->chunk_type != SCTP_COOKIE_ECHO) { 4541 /* 4542 * If there is no stcb, skip the AUTH chunk and process 4543 * later after a stcb is found (to validate the lookup was 4544 * valid. 4545 */ 4546 if ((ch->chunk_type == SCTP_AUTHENTICATION) && 4547 (stcb == NULL) && 4548 (inp->auth_supported == 1)) { 4549 /* save this chunk for later processing */ 4550 auth_skipped = 1; 4551 auth_offset = *offset; 4552 auth_len = ntohs(ch->chunk_length); 4553 4554 /* (temporarily) move past this chunk */ 4555 *offset += SCTP_SIZE32(auth_len); 4556 if (*offset >= length) { 4557 /* no more data left in the mbuf chain */ 4558 *offset = length; 4559 if (locked_tcb) { 4560 SCTP_TCB_UNLOCK(locked_tcb); 4561 } 4562 return (NULL); 4563 } 4564 ch = (struct sctp_chunkhdr *)sctp_m_getptr(m, *offset, 4565 sizeof(struct sctp_chunkhdr), chunk_buf); 4566 } 4567 if (ch == NULL) { 4568 /* Help */ 4569 *offset = length; 4570 if (locked_tcb) { 4571 SCTP_TCB_UNLOCK(locked_tcb); 4572 } 4573 return (NULL); 4574 } 4575 if (ch->chunk_type == SCTP_COOKIE_ECHO) { 4576 goto process_control_chunks; 4577 } 4578 /* 4579 * first check if it's an ASCONF with an unknown src addr we 4580 * need to look inside to find the association 4581 */ 4582 if (ch->chunk_type == SCTP_ASCONF && stcb == NULL) { 4583 struct sctp_chunkhdr *asconf_ch = ch; 4584 uint32_t asconf_offset = 0, asconf_len = 0; 4585 4586 /* inp's refcount may be reduced */ 4587 SCTP_INP_INCR_REF(inp); 4588 4589 asconf_offset = *offset; 4590 do { 4591 asconf_len = ntohs(asconf_ch->chunk_length); 4592 if (asconf_len < sizeof(struct sctp_asconf_paramhdr)) 4593 break; 4594 stcb = sctp_findassociation_ep_asconf(m, 4595 *offset, 4596 dst, 4597 sh, &inp, netp, vrf_id); 4598 if (stcb != NULL) 4599 break; 4600 asconf_offset += SCTP_SIZE32(asconf_len); 4601 asconf_ch = (struct sctp_chunkhdr *)sctp_m_getptr(m, asconf_offset, 4602 sizeof(struct sctp_chunkhdr), chunk_buf); 4603 } while (asconf_ch != NULL && asconf_ch->chunk_type == SCTP_ASCONF); 4604 if (stcb == NULL) { 4605 /* 4606 * reduce inp's refcount if not reduced in 4607 * sctp_findassociation_ep_asconf(). 4608 */ 4609 SCTP_INP_DECR_REF(inp); 4610 } else { 4611 locked_tcb = stcb; 4612 } 4613 4614 /* now go back and verify any auth chunk to be sure */ 4615 if (auth_skipped && (stcb != NULL)) { 4616 struct sctp_auth_chunk *auth; 4617 4618 auth = (struct sctp_auth_chunk *) 4619 sctp_m_getptr(m, auth_offset, 4620 auth_len, chunk_buf); 4621 got_auth = 1; 4622 auth_skipped = 0; 4623 if ((auth == NULL) || sctp_handle_auth(stcb, auth, m, 4624 auth_offset)) { 4625 /* auth HMAC failed so dump it */ 4626 *offset = length; 4627 if (locked_tcb) { 4628 SCTP_TCB_UNLOCK(locked_tcb); 4629 } 4630 return (NULL); 4631 } else { 4632 /* remaining chunks are HMAC checked */ 4633 stcb->asoc.authenticated = 1; 4634 } 4635 } 4636 } 4637 if (stcb == NULL) { 4638 snprintf(msg, sizeof(msg), "OOTB, %s:%d at %s", __FILE__, __LINE__, __func__); 4639 op_err = sctp_generate_cause(SCTP_BASE_SYSCTL(sctp_diag_info_code), 4640 msg); 4641 /* no association, so it's out of the blue... */ 4642 sctp_handle_ootb(m, iphlen, *offset, src, dst, sh, inp, op_err, 4643 mflowtype, mflowid, inp->fibnum, 4644 vrf_id, port); 4645 *offset = length; 4646 if (locked_tcb) { 4647 SCTP_TCB_UNLOCK(locked_tcb); 4648 } 4649 return (NULL); 4650 } 4651 asoc = &stcb->asoc; 4652 /* ABORT and SHUTDOWN can use either v_tag... */ 4653 if ((ch->chunk_type == SCTP_ABORT_ASSOCIATION) || 4654 (ch->chunk_type == SCTP_SHUTDOWN_COMPLETE) || 4655 (ch->chunk_type == SCTP_PACKET_DROPPED)) { 4656 /* Take the T-bit always into account. */ 4657 if ((((ch->chunk_flags & SCTP_HAD_NO_TCB) == 0) && 4658 (vtag_in == asoc->my_vtag)) || 4659 (((ch->chunk_flags & SCTP_HAD_NO_TCB) == SCTP_HAD_NO_TCB) && 4660 (vtag_in == asoc->peer_vtag))) { 4661 /* this is valid */ 4662 } else { 4663 /* drop this packet... */ 4664 SCTP_STAT_INCR(sctps_badvtag); 4665 if (locked_tcb) { 4666 SCTP_TCB_UNLOCK(locked_tcb); 4667 } 4668 return (NULL); 4669 } 4670 } else if (ch->chunk_type == SCTP_SHUTDOWN_ACK) { 4671 if (vtag_in != asoc->my_vtag) { 4672 /* 4673 * this could be a stale SHUTDOWN-ACK or the 4674 * peer never got the SHUTDOWN-COMPLETE and 4675 * is still hung; we have started a new asoc 4676 * but it won't complete until the shutdown 4677 * is completed 4678 */ 4679 if (locked_tcb) { 4680 SCTP_TCB_UNLOCK(locked_tcb); 4681 } 4682 snprintf(msg, sizeof(msg), "OOTB, %s:%d at %s", __FILE__, __LINE__, __func__); 4683 op_err = sctp_generate_cause(SCTP_BASE_SYSCTL(sctp_diag_info_code), 4684 msg); 4685 sctp_handle_ootb(m, iphlen, *offset, src, dst, 4686 sh, inp, op_err, 4687 mflowtype, mflowid, fibnum, 4688 vrf_id, port); 4689 return (NULL); 4690 } 4691 } else { 4692 /* for all other chunks, vtag must match */ 4693 if (vtag_in != asoc->my_vtag) { 4694 /* invalid vtag... */ 4695 SCTPDBG(SCTP_DEBUG_INPUT3, 4696 "invalid vtag: %xh, expect %xh\n", 4697 vtag_in, asoc->my_vtag); 4698 SCTP_STAT_INCR(sctps_badvtag); 4699 if (locked_tcb) { 4700 SCTP_TCB_UNLOCK(locked_tcb); 4701 } 4702 *offset = length; 4703 return (NULL); 4704 } 4705 } 4706 } /* end if !SCTP_COOKIE_ECHO */ 4707 /* 4708 * process all control chunks... 4709 */ 4710 if (((ch->chunk_type == SCTP_SELECTIVE_ACK) || 4711 (ch->chunk_type == SCTP_NR_SELECTIVE_ACK) || 4712 (ch->chunk_type == SCTP_HEARTBEAT_REQUEST)) && 4713 (SCTP_GET_STATE(&stcb->asoc) == SCTP_STATE_COOKIE_ECHOED)) { 4714 /* implied cookie-ack.. we must have lost the ack */ 4715 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_THRESHOLD_LOGGING) { 4716 sctp_misc_ints(SCTP_THRESHOLD_CLEAR, 4717 stcb->asoc.overall_error_count, 4718 0, 4719 SCTP_FROM_SCTP_INPUT, 4720 __LINE__); 4721 } 4722 stcb->asoc.overall_error_count = 0; 4723 sctp_handle_cookie_ack((struct sctp_cookie_ack_chunk *)ch, stcb, 4724 *netp); 4725 } 4726process_control_chunks: 4727 while (IS_SCTP_CONTROL(ch)) { 4728 /* validate chunk length */ 4729 chk_length = ntohs(ch->chunk_length); 4730 SCTPDBG(SCTP_DEBUG_INPUT2, "sctp_process_control: processing a chunk type=%u, len=%u\n", 4731 ch->chunk_type, chk_length); 4732 SCTP_LTRACE_CHK(inp, stcb, ch->chunk_type, chk_length); 4733 if (chk_length < sizeof(*ch) || 4734 (*offset + (int)chk_length) > length) { 4735 *offset = length; 4736 if (locked_tcb) { 4737 SCTP_TCB_UNLOCK(locked_tcb); 4738 } 4739 return (NULL); 4740 } 4741 SCTP_STAT_INCR_COUNTER64(sctps_incontrolchunks); 4742 /* 4743 * INIT-ACK only gets the init ack "header" portion only 4744 * because we don't have to process the peer's COOKIE. All 4745 * others get a complete chunk. 4746 */ 4747 if ((ch->chunk_type == SCTP_INITIATION_ACK) || 4748 (ch->chunk_type == SCTP_INITIATION)) { 4749 /* get an init-ack chunk */ 4750 ch = (struct sctp_chunkhdr *)sctp_m_getptr(m, *offset, 4751 sizeof(struct sctp_init_ack_chunk), chunk_buf); 4752 if (ch == NULL) { 4753 *offset = length; 4754 if (locked_tcb) { 4755 SCTP_TCB_UNLOCK(locked_tcb); 4756 } 4757 return (NULL); 4758 } 4759 } else { 4760 /* For cookies and all other chunks. */ 4761 if (chk_length > sizeof(chunk_buf)) { 4762 /* 4763 * use just the size of the chunk buffer so 4764 * the front part of our chunks fit in 4765 * contiguous space up to the chunk buffer 4766 * size (508 bytes). For chunks that need to 4767 * get more than that they must use the 4768 * sctp_m_getptr() function or other means 4769 * (e.g. know how to parse mbuf chains). 4770 * Cookies do this already. 4771 */ 4772 ch = (struct sctp_chunkhdr *)sctp_m_getptr(m, *offset, 4773 (sizeof(chunk_buf) - 4), 4774 chunk_buf); 4775 if (ch == NULL) { 4776 *offset = length; 4777 if (locked_tcb) { 4778 SCTP_TCB_UNLOCK(locked_tcb); 4779 } 4780 return (NULL); 4781 } 4782 } else { 4783 /* We can fit it all */ 4784 ch = (struct sctp_chunkhdr *)sctp_m_getptr(m, *offset, 4785 chk_length, chunk_buf); 4786 if (ch == NULL) { 4787 SCTP_PRINTF("sctp_process_control: Can't get the all data....\n"); 4788 *offset = length; 4789 if (locked_tcb) { 4790 SCTP_TCB_UNLOCK(locked_tcb); 4791 } 4792 return (NULL); 4793 } 4794 } 4795 } 4796 num_chunks++; 4797 /* Save off the last place we got a control from */ 4798 if (stcb != NULL) { 4799 if (((netp != NULL) && (*netp != NULL)) || (ch->chunk_type == SCTP_ASCONF)) { 4800 /* 4801 * allow last_control to be NULL if 4802 * ASCONF... ASCONF processing will find the 4803 * right net later 4804 */ 4805 if ((netp != NULL) && (*netp != NULL)) 4806 stcb->asoc.last_control_chunk_from = *netp; 4807 } 4808 } 4809#ifdef SCTP_AUDITING_ENABLED 4810 sctp_audit_log(0xB0, ch->chunk_type); 4811#endif 4812 4813 /* check to see if this chunk required auth, but isn't */ 4814 if ((stcb != NULL) && 4815 (stcb->asoc.auth_supported == 1) && 4816 sctp_auth_is_required_chunk(ch->chunk_type, stcb->asoc.local_auth_chunks) && 4817 !stcb->asoc.authenticated) { 4818 /* "silently" ignore */ 4819 SCTP_STAT_INCR(sctps_recvauthmissing); 4820 goto next_chunk; 4821 } 4822 switch (ch->chunk_type) { 4823 case SCTP_INITIATION: 4824 SCTPDBG(SCTP_DEBUG_INPUT3, "SCTP_INIT\n"); 4825 /* The INIT chunk must be the only chunk. */ 4826 if ((num_chunks > 1) || 4827 (length - *offset > (int)SCTP_SIZE32(chk_length))) { 4828 /* RFC 4960 requires that no ABORT is sent */ 4829 *offset = length; 4830 if (locked_tcb) { 4831 SCTP_TCB_UNLOCK(locked_tcb); 4832 } 4833 return (NULL); 4834 } 4835 /* Honor our resource limit. */ 4836 if (chk_length > SCTP_LARGEST_INIT_ACCEPTED) { 4837 op_err = sctp_generate_cause(SCTP_CAUSE_OUT_OF_RESC, ""); 4838 sctp_abort_association(inp, stcb, m, iphlen, 4839 src, dst, sh, op_err, 4840 mflowtype, mflowid, 4841 vrf_id, port); 4842 *offset = length; 4843 return (NULL); 4844 } 4845 sctp_handle_init(m, iphlen, *offset, src, dst, sh, 4846 (struct sctp_init_chunk *)ch, inp, 4847 stcb, *netp, &abort_no_unlock, 4848 mflowtype, mflowid, 4849 vrf_id, port); 4850 *offset = length; 4851 if ((!abort_no_unlock) && (locked_tcb)) { 4852 SCTP_TCB_UNLOCK(locked_tcb); 4853 } 4854 return (NULL); 4855 break; 4856 case SCTP_PAD_CHUNK: 4857 break; 4858 case SCTP_INITIATION_ACK: 4859 SCTPDBG(SCTP_DEBUG_INPUT3, "SCTP_INIT-ACK\n"); 4860 if (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) { 4861 /* We are not interested anymore */ 4862 if ((stcb) && (stcb->asoc.total_output_queue_size)) { 4863 ; 4864 } else { 4865 if ((locked_tcb != NULL) && (locked_tcb != stcb)) { 4866 /* Very unlikely */ 4867 SCTP_TCB_UNLOCK(locked_tcb); 4868 } 4869 *offset = length; 4870 if (stcb) { 4871#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 4872 so = SCTP_INP_SO(inp); 4873 atomic_add_int(&stcb->asoc.refcnt, 1); 4874 SCTP_TCB_UNLOCK(stcb); 4875 SCTP_SOCKET_LOCK(so, 1); 4876 SCTP_TCB_LOCK(stcb); 4877 atomic_subtract_int(&stcb->asoc.refcnt, 1); 4878#endif 4879 (void)sctp_free_assoc(inp, stcb, SCTP_NORMAL_PROC, 4880 SCTP_FROM_SCTP_INPUT + SCTP_LOC_29); 4881#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 4882 SCTP_SOCKET_UNLOCK(so, 1); 4883#endif 4884 } 4885 return (NULL); 4886 } 4887 } 4888 /* The INIT-ACK chunk must be the only chunk. */ 4889 if ((num_chunks > 1) || 4890 (length - *offset > (int)SCTP_SIZE32(chk_length))) { 4891 *offset = length; 4892 if (locked_tcb) { 4893 SCTP_TCB_UNLOCK(locked_tcb); 4894 } 4895 return (NULL); 4896 } 4897 if ((netp) && (*netp)) { 4898 ret = sctp_handle_init_ack(m, iphlen, *offset, 4899 src, dst, sh, 4900 (struct sctp_init_ack_chunk *)ch, 4901 stcb, *netp, 4902 &abort_no_unlock, 4903 mflowtype, mflowid, 4904 vrf_id); 4905 } else { 4906 ret = -1; 4907 } 4908 *offset = length; 4909 if (abort_no_unlock) { 4910 return (NULL); 4911 } 4912 /* 4913 * Special case, I must call the output routine to 4914 * get the cookie echoed 4915 */ 4916 if ((stcb != NULL) && (ret == 0)) { 4917 sctp_chunk_output(stcb->sctp_ep, stcb, SCTP_OUTPUT_FROM_CONTROL_PROC, SCTP_SO_NOT_LOCKED); 4918 } 4919 if (locked_tcb) { 4920 SCTP_TCB_UNLOCK(locked_tcb); 4921 } 4922 return (NULL); 4923 break; 4924 case SCTP_SELECTIVE_ACK: 4925 { 4926 struct sctp_sack_chunk *sack; 4927 int abort_now = 0; 4928 uint32_t a_rwnd, cum_ack; 4929 uint16_t num_seg, num_dup; 4930 uint8_t flags; 4931 int offset_seg, offset_dup; 4932 4933 SCTPDBG(SCTP_DEBUG_INPUT3, "SCTP_SACK\n"); 4934 SCTP_STAT_INCR(sctps_recvsacks); 4935 if (stcb == NULL) { 4936 SCTPDBG(SCTP_DEBUG_INDATA1, "No stcb when processing SACK chunk\n"); 4937 break; 4938 } 4939 if (chk_length < sizeof(struct sctp_sack_chunk)) { 4940 SCTPDBG(SCTP_DEBUG_INDATA1, "Bad size on SACK chunk, too small\n"); 4941 break; 4942 } 4943 if (SCTP_GET_STATE(&stcb->asoc) == SCTP_STATE_SHUTDOWN_ACK_SENT) { 4944 /*- 4945 * If we have sent a shutdown-ack, we will pay no 4946 * attention to a sack sent in to us since 4947 * we don't care anymore. 4948 */ 4949 break; 4950 } 4951 sack = (struct sctp_sack_chunk *)ch; 4952 flags = ch->chunk_flags; 4953 cum_ack = ntohl(sack->sack.cum_tsn_ack); 4954 num_seg = ntohs(sack->sack.num_gap_ack_blks); 4955 num_dup = ntohs(sack->sack.num_dup_tsns); 4956 a_rwnd = (uint32_t) ntohl(sack->sack.a_rwnd); 4957 if (sizeof(struct sctp_sack_chunk) + 4958 num_seg * sizeof(struct sctp_gap_ack_block) + 4959 num_dup * sizeof(uint32_t) != chk_length) { 4960 SCTPDBG(SCTP_DEBUG_INDATA1, "Bad size of SACK chunk\n"); 4961 break; 4962 } 4963 offset_seg = *offset + sizeof(struct sctp_sack_chunk); 4964 offset_dup = offset_seg + num_seg * sizeof(struct sctp_gap_ack_block); 4965 SCTPDBG(SCTP_DEBUG_INPUT3, "SCTP_SACK process cum_ack:%x num_seg:%d a_rwnd:%d\n", 4966 cum_ack, num_seg, a_rwnd); 4967 stcb->asoc.seen_a_sack_this_pkt = 1; 4968 if ((stcb->asoc.pr_sctp_cnt == 0) && 4969 (num_seg == 0) && 4970 SCTP_TSN_GE(cum_ack, stcb->asoc.last_acked_seq) && 4971 (stcb->asoc.saw_sack_with_frags == 0) && 4972 (stcb->asoc.saw_sack_with_nr_frags == 0) && 4973 (!TAILQ_EMPTY(&stcb->asoc.sent_queue)) 4974 ) { 4975 /* 4976 * We have a SIMPLE sack having no 4977 * prior segments and data on sent 4978 * queue to be acked.. Use the 4979 * faster path sack processing. We 4980 * also allow window update sacks 4981 * with no missing segments to go 4982 * this way too. 4983 */ 4984 sctp_express_handle_sack(stcb, cum_ack, a_rwnd, &abort_now, ecne_seen); 4985 } else { 4986 if (netp && *netp) 4987 sctp_handle_sack(m, offset_seg, offset_dup, stcb, 4988 num_seg, 0, num_dup, &abort_now, flags, 4989 cum_ack, a_rwnd, ecne_seen); 4990 } 4991 if (abort_now) { 4992 /* ABORT signal from sack processing */ 4993 *offset = length; 4994 return (NULL); 4995 } 4996 if (TAILQ_EMPTY(&stcb->asoc.send_queue) && 4997 TAILQ_EMPTY(&stcb->asoc.sent_queue) && 4998 (stcb->asoc.stream_queue_cnt == 0)) { 4999 sctp_ulp_notify(SCTP_NOTIFY_SENDER_DRY, stcb, 0, NULL, SCTP_SO_NOT_LOCKED); 5000 } 5001 } 5002 break; 5003 /* 5004 * EY - nr_sack: If the received chunk is an 5005 * nr_sack chunk 5006 */ 5007 case SCTP_NR_SELECTIVE_ACK: 5008 { 5009 struct sctp_nr_sack_chunk *nr_sack; 5010 int abort_now = 0; 5011 uint32_t a_rwnd, cum_ack; 5012 uint16_t num_seg, num_nr_seg, num_dup; 5013 uint8_t flags; 5014 int offset_seg, offset_dup; 5015 5016 SCTPDBG(SCTP_DEBUG_INPUT3, "SCTP_NR_SACK\n"); 5017 SCTP_STAT_INCR(sctps_recvsacks); 5018 if (stcb == NULL) { 5019 SCTPDBG(SCTP_DEBUG_INDATA1, "No stcb when processing NR-SACK chunk\n"); 5020 break; 5021 } 5022 if (stcb->asoc.nrsack_supported == 0) { 5023 goto unknown_chunk; 5024 } 5025 if (chk_length < sizeof(struct sctp_nr_sack_chunk)) { 5026 SCTPDBG(SCTP_DEBUG_INDATA1, "Bad size on NR-SACK chunk, too small\n"); 5027 break; 5028 } 5029 if (SCTP_GET_STATE(&stcb->asoc) == SCTP_STATE_SHUTDOWN_ACK_SENT) { 5030 /*- 5031 * If we have sent a shutdown-ack, we will pay no 5032 * attention to a sack sent in to us since 5033 * we don't care anymore. 5034 */ 5035 break; 5036 } 5037 nr_sack = (struct sctp_nr_sack_chunk *)ch; 5038 flags = ch->chunk_flags; 5039 cum_ack = ntohl(nr_sack->nr_sack.cum_tsn_ack); 5040 num_seg = ntohs(nr_sack->nr_sack.num_gap_ack_blks); 5041 num_nr_seg = ntohs(nr_sack->nr_sack.num_nr_gap_ack_blks); 5042 num_dup = ntohs(nr_sack->nr_sack.num_dup_tsns); 5043 a_rwnd = (uint32_t) ntohl(nr_sack->nr_sack.a_rwnd); 5044 if (sizeof(struct sctp_nr_sack_chunk) + 5045 (num_seg + num_nr_seg) * sizeof(struct sctp_gap_ack_block) + 5046 num_dup * sizeof(uint32_t) != chk_length) { 5047 SCTPDBG(SCTP_DEBUG_INDATA1, "Bad size of NR_SACK chunk\n"); 5048 break; 5049 } 5050 offset_seg = *offset + sizeof(struct sctp_nr_sack_chunk); 5051 offset_dup = offset_seg + num_seg * sizeof(struct sctp_gap_ack_block); 5052 SCTPDBG(SCTP_DEBUG_INPUT3, "SCTP_NR_SACK process cum_ack:%x num_seg:%d a_rwnd:%d\n", 5053 cum_ack, num_seg, a_rwnd); 5054 stcb->asoc.seen_a_sack_this_pkt = 1; 5055 if ((stcb->asoc.pr_sctp_cnt == 0) && 5056 (num_seg == 0) && (num_nr_seg == 0) && 5057 SCTP_TSN_GE(cum_ack, stcb->asoc.last_acked_seq) && 5058 (stcb->asoc.saw_sack_with_frags == 0) && 5059 (stcb->asoc.saw_sack_with_nr_frags == 0) && 5060 (!TAILQ_EMPTY(&stcb->asoc.sent_queue))) { 5061 /* 5062 * We have a SIMPLE sack having no 5063 * prior segments and data on sent 5064 * queue to be acked. Use the faster 5065 * path sack processing. We also 5066 * allow window update sacks with no 5067 * missing segments to go this way 5068 * too. 5069 */ 5070 sctp_express_handle_sack(stcb, cum_ack, a_rwnd, 5071 &abort_now, ecne_seen); 5072 } else { 5073 if (netp && *netp) 5074 sctp_handle_sack(m, offset_seg, offset_dup, stcb, 5075 num_seg, num_nr_seg, num_dup, &abort_now, flags, 5076 cum_ack, a_rwnd, ecne_seen); 5077 } 5078 if (abort_now) { 5079 /* ABORT signal from sack processing */ 5080 *offset = length; 5081 return (NULL); 5082 } 5083 if (TAILQ_EMPTY(&stcb->asoc.send_queue) && 5084 TAILQ_EMPTY(&stcb->asoc.sent_queue) && 5085 (stcb->asoc.stream_queue_cnt == 0)) { 5086 sctp_ulp_notify(SCTP_NOTIFY_SENDER_DRY, stcb, 0, NULL, SCTP_SO_NOT_LOCKED); 5087 } 5088 } 5089 break; 5090 5091 case SCTP_HEARTBEAT_REQUEST: 5092 SCTPDBG(SCTP_DEBUG_INPUT3, "SCTP_HEARTBEAT\n"); 5093 if ((stcb) && netp && *netp) { 5094 SCTP_STAT_INCR(sctps_recvheartbeat); 5095 sctp_send_heartbeat_ack(stcb, m, *offset, 5096 chk_length, *netp); 5097 5098 /* He's alive so give him credit */ 5099 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_THRESHOLD_LOGGING) { 5100 sctp_misc_ints(SCTP_THRESHOLD_CLEAR, 5101 stcb->asoc.overall_error_count, 5102 0, 5103 SCTP_FROM_SCTP_INPUT, 5104 __LINE__); 5105 } 5106 stcb->asoc.overall_error_count = 0; 5107 } 5108 break; 5109 case SCTP_HEARTBEAT_ACK: 5110 SCTPDBG(SCTP_DEBUG_INPUT3, "SCTP_HEARTBEAT-ACK\n"); 5111 if ((stcb == NULL) || (chk_length != sizeof(struct sctp_heartbeat_chunk))) { 5112 /* Its not ours */ 5113 *offset = length; 5114 if (locked_tcb) { 5115 SCTP_TCB_UNLOCK(locked_tcb); 5116 } 5117 return (NULL); 5118 } 5119 /* He's alive so give him credit */ 5120 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_THRESHOLD_LOGGING) { 5121 sctp_misc_ints(SCTP_THRESHOLD_CLEAR, 5122 stcb->asoc.overall_error_count, 5123 0, 5124 SCTP_FROM_SCTP_INPUT, 5125 __LINE__); 5126 } 5127 stcb->asoc.overall_error_count = 0; 5128 SCTP_STAT_INCR(sctps_recvheartbeatack); 5129 if (netp && *netp) 5130 sctp_handle_heartbeat_ack((struct sctp_heartbeat_chunk *)ch, 5131 stcb, *netp); 5132 break; 5133 case SCTP_ABORT_ASSOCIATION: 5134 SCTPDBG(SCTP_DEBUG_INPUT3, "SCTP_ABORT, stcb %p\n", 5135 (void *)stcb); 5136 if ((stcb) && netp && *netp) 5137 sctp_handle_abort((struct sctp_abort_chunk *)ch, 5138 stcb, *netp); 5139 *offset = length; 5140 return (NULL); 5141 break; 5142 case SCTP_SHUTDOWN: 5143 SCTPDBG(SCTP_DEBUG_INPUT3, "SCTP_SHUTDOWN, stcb %p\n", 5144 (void *)stcb); 5145 if ((stcb == NULL) || (chk_length != sizeof(struct sctp_shutdown_chunk))) { 5146 *offset = length; 5147 if (locked_tcb) { 5148 SCTP_TCB_UNLOCK(locked_tcb); 5149 } 5150 return (NULL); 5151 } 5152 if (netp && *netp) { 5153 int abort_flag = 0; 5154 5155 sctp_handle_shutdown((struct sctp_shutdown_chunk *)ch, 5156 stcb, *netp, &abort_flag); 5157 if (abort_flag) { 5158 *offset = length; 5159 return (NULL); 5160 } 5161 } 5162 break; 5163 case SCTP_SHUTDOWN_ACK: 5164 SCTPDBG(SCTP_DEBUG_INPUT3, "SCTP_SHUTDOWN-ACK, stcb %p\n", (void *)stcb); 5165 if ((stcb) && (netp) && (*netp)) 5166 sctp_handle_shutdown_ack((struct sctp_shutdown_ack_chunk *)ch, stcb, *netp); 5167 *offset = length; 5168 return (NULL); 5169 break; 5170 5171 case SCTP_OPERATION_ERROR: 5172 SCTPDBG(SCTP_DEBUG_INPUT3, "SCTP_OP-ERR\n"); 5173 if ((stcb) && netp && *netp && sctp_handle_error(ch, stcb, *netp) < 0) { 5174 *offset = length; 5175 return (NULL); 5176 } 5177 break; 5178 case SCTP_COOKIE_ECHO: 5179 SCTPDBG(SCTP_DEBUG_INPUT3, 5180 "SCTP_COOKIE-ECHO, stcb %p\n", (void *)stcb); 5181 if ((stcb) && (stcb->asoc.total_output_queue_size)) { 5182 ; 5183 } else { 5184 if (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) { 5185 /* We are not interested anymore */ 5186 abend: 5187 if (stcb) { 5188 SCTP_TCB_UNLOCK(stcb); 5189 } 5190 *offset = length; 5191 return (NULL); 5192 } 5193 } 5194 /* 5195 * First are we accepting? We do this again here 5196 * since it is possible that a previous endpoint WAS 5197 * listening responded to a INIT-ACK and then 5198 * closed. We opened and bound.. and are now no 5199 * longer listening. 5200 */ 5201 5202 if ((stcb == NULL) && (inp->sctp_socket->so_qlen >= inp->sctp_socket->so_qlimit)) { 5203 if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) && 5204 (SCTP_BASE_SYSCTL(sctp_abort_if_one_2_one_hits_limit))) { 5205 op_err = sctp_generate_cause(SCTP_CAUSE_OUT_OF_RESC, ""); 5206 sctp_abort_association(inp, stcb, m, iphlen, 5207 src, dst, sh, op_err, 5208 mflowtype, mflowid, 5209 vrf_id, port); 5210 } 5211 *offset = length; 5212 return (NULL); 5213 } else { 5214 struct mbuf *ret_buf; 5215 struct sctp_inpcb *linp; 5216 5217 if (stcb) { 5218 linp = NULL; 5219 } else { 5220 linp = inp; 5221 } 5222 5223 if (linp) { 5224 SCTP_ASOC_CREATE_LOCK(linp); 5225 if ((inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) || 5226 (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_ALLGONE)) { 5227 SCTP_ASOC_CREATE_UNLOCK(linp); 5228 goto abend; 5229 } 5230 } 5231 if (netp) { 5232 ret_buf = 5233 sctp_handle_cookie_echo(m, iphlen, 5234 *offset, 5235 src, dst, 5236 sh, 5237 (struct sctp_cookie_echo_chunk *)ch, 5238 &inp, &stcb, netp, 5239 auth_skipped, 5240 auth_offset, 5241 auth_len, 5242 &locked_tcb, 5243 mflowtype, 5244 mflowid, 5245 vrf_id, 5246 port); 5247 } else { 5248 ret_buf = NULL; 5249 } 5250 if (linp) { 5251 SCTP_ASOC_CREATE_UNLOCK(linp); 5252 } 5253 if (ret_buf == NULL) { 5254 if (locked_tcb) { 5255 SCTP_TCB_UNLOCK(locked_tcb); 5256 } 5257 SCTPDBG(SCTP_DEBUG_INPUT3, 5258 "GAK, null buffer\n"); 5259 *offset = length; 5260 return (NULL); 5261 } 5262 /* if AUTH skipped, see if it verified... */ 5263 if (auth_skipped) { 5264 got_auth = 1; 5265 auth_skipped = 0; 5266 } 5267 if (!TAILQ_EMPTY(&stcb->asoc.sent_queue)) { 5268 /* 5269 * Restart the timer if we have 5270 * pending data 5271 */ 5272 struct sctp_tmit_chunk *chk; 5273 5274 chk = TAILQ_FIRST(&stcb->asoc.sent_queue); 5275 sctp_timer_start(SCTP_TIMER_TYPE_SEND, stcb->sctp_ep, stcb, chk->whoTo); 5276 } 5277 } 5278 break; 5279 case SCTP_COOKIE_ACK: 5280 SCTPDBG(SCTP_DEBUG_INPUT3, "SCTP_COOKIE-ACK, stcb %p\n", (void *)stcb); 5281 if ((stcb == NULL) || chk_length != sizeof(struct sctp_cookie_ack_chunk)) { 5282 if (locked_tcb) { 5283 SCTP_TCB_UNLOCK(locked_tcb); 5284 } 5285 return (NULL); 5286 } 5287 if (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) { 5288 /* We are not interested anymore */ 5289 if ((stcb) && (stcb->asoc.total_output_queue_size)) { 5290 ; 5291 } else if (stcb) { 5292#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 5293 so = SCTP_INP_SO(inp); 5294 atomic_add_int(&stcb->asoc.refcnt, 1); 5295 SCTP_TCB_UNLOCK(stcb); 5296 SCTP_SOCKET_LOCK(so, 1); 5297 SCTP_TCB_LOCK(stcb); 5298 atomic_subtract_int(&stcb->asoc.refcnt, 1); 5299#endif 5300 (void)sctp_free_assoc(inp, stcb, SCTP_NORMAL_PROC, 5301 SCTP_FROM_SCTP_INPUT + SCTP_LOC_30); 5302#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 5303 SCTP_SOCKET_UNLOCK(so, 1); 5304#endif 5305 *offset = length; 5306 return (NULL); 5307 } 5308 } 5309 /* He's alive so give him credit */ 5310 if ((stcb) && netp && *netp) { 5311 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_THRESHOLD_LOGGING) { 5312 sctp_misc_ints(SCTP_THRESHOLD_CLEAR, 5313 stcb->asoc.overall_error_count, 5314 0, 5315 SCTP_FROM_SCTP_INPUT, 5316 __LINE__); 5317 } 5318 stcb->asoc.overall_error_count = 0; 5319 sctp_handle_cookie_ack((struct sctp_cookie_ack_chunk *)ch, stcb, *netp); 5320 } 5321 break; 5322 case SCTP_ECN_ECHO: 5323 SCTPDBG(SCTP_DEBUG_INPUT3, "SCTP_ECN-ECHO\n"); 5324 /* He's alive so give him credit */ 5325 if ((stcb == NULL) || (chk_length != sizeof(struct sctp_ecne_chunk))) { 5326 /* Its not ours */ 5327 if (locked_tcb) { 5328 SCTP_TCB_UNLOCK(locked_tcb); 5329 } 5330 *offset = length; 5331 return (NULL); 5332 } 5333 if (stcb) { 5334 if (stcb->asoc.ecn_supported == 0) { 5335 goto unknown_chunk; 5336 } 5337 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_THRESHOLD_LOGGING) { 5338 sctp_misc_ints(SCTP_THRESHOLD_CLEAR, 5339 stcb->asoc.overall_error_count, 5340 0, 5341 SCTP_FROM_SCTP_INPUT, 5342 __LINE__); 5343 } 5344 stcb->asoc.overall_error_count = 0; 5345 sctp_handle_ecn_echo((struct sctp_ecne_chunk *)ch, 5346 stcb); 5347 ecne_seen = 1; 5348 } 5349 break; 5350 case SCTP_ECN_CWR: 5351 SCTPDBG(SCTP_DEBUG_INPUT3, "SCTP_ECN-CWR\n"); 5352 /* He's alive so give him credit */ 5353 if ((stcb == NULL) || (chk_length != sizeof(struct sctp_cwr_chunk))) { 5354 /* Its not ours */ 5355 if (locked_tcb) { 5356 SCTP_TCB_UNLOCK(locked_tcb); 5357 } 5358 *offset = length; 5359 return (NULL); 5360 } 5361 if (stcb) { 5362 if (stcb->asoc.ecn_supported == 0) { 5363 goto unknown_chunk; 5364 } 5365 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_THRESHOLD_LOGGING) { 5366 sctp_misc_ints(SCTP_THRESHOLD_CLEAR, 5367 stcb->asoc.overall_error_count, 5368 0, 5369 SCTP_FROM_SCTP_INPUT, 5370 __LINE__); 5371 } 5372 stcb->asoc.overall_error_count = 0; 5373 sctp_handle_ecn_cwr((struct sctp_cwr_chunk *)ch, stcb, *netp); 5374 } 5375 break; 5376 case SCTP_SHUTDOWN_COMPLETE: 5377 SCTPDBG(SCTP_DEBUG_INPUT3, "SCTP_SHUTDOWN-COMPLETE, stcb %p\n", (void *)stcb); 5378 /* must be first and only chunk */ 5379 if ((num_chunks > 1) || 5380 (length - *offset > (int)SCTP_SIZE32(chk_length))) { 5381 *offset = length; 5382 if (locked_tcb) { 5383 SCTP_TCB_UNLOCK(locked_tcb); 5384 } 5385 return (NULL); 5386 } 5387 if ((stcb) && netp && *netp) { 5388 sctp_handle_shutdown_complete((struct sctp_shutdown_complete_chunk *)ch, 5389 stcb, *netp); 5390 } 5391 *offset = length; 5392 return (NULL); 5393 break; 5394 case SCTP_ASCONF: 5395 SCTPDBG(SCTP_DEBUG_INPUT3, "SCTP_ASCONF\n"); 5396 /* He's alive so give him credit */ 5397 if (stcb) { 5398 if (stcb->asoc.asconf_supported == 0) { 5399 goto unknown_chunk; 5400 } 5401 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_THRESHOLD_LOGGING) { 5402 sctp_misc_ints(SCTP_THRESHOLD_CLEAR, 5403 stcb->asoc.overall_error_count, 5404 0, 5405 SCTP_FROM_SCTP_INPUT, 5406 __LINE__); 5407 } 5408 stcb->asoc.overall_error_count = 0; 5409 sctp_handle_asconf(m, *offset, src, 5410 (struct sctp_asconf_chunk *)ch, stcb, asconf_cnt == 0); 5411 asconf_cnt++; 5412 } 5413 break; 5414 case SCTP_ASCONF_ACK: 5415 SCTPDBG(SCTP_DEBUG_INPUT3, "SCTP_ASCONF-ACK\n"); 5416 if (chk_length < sizeof(struct sctp_asconf_ack_chunk)) { 5417 /* Its not ours */ 5418 if (locked_tcb) { 5419 SCTP_TCB_UNLOCK(locked_tcb); 5420 } 5421 *offset = length; 5422 return (NULL); 5423 } 5424 if ((stcb) && netp && *netp) { 5425 if (stcb->asoc.asconf_supported == 0) { 5426 goto unknown_chunk; 5427 } 5428 /* He's alive so give him credit */ 5429 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_THRESHOLD_LOGGING) { 5430 sctp_misc_ints(SCTP_THRESHOLD_CLEAR, 5431 stcb->asoc.overall_error_count, 5432 0, 5433 SCTP_FROM_SCTP_INPUT, 5434 __LINE__); 5435 } 5436 stcb->asoc.overall_error_count = 0; 5437 sctp_handle_asconf_ack(m, *offset, 5438 (struct sctp_asconf_ack_chunk *)ch, stcb, *netp, &abort_no_unlock); 5439 if (abort_no_unlock) 5440 return (NULL); 5441 } 5442 break; 5443 case SCTP_FORWARD_CUM_TSN: 5444 SCTPDBG(SCTP_DEBUG_INPUT3, "SCTP_FWD-TSN\n"); 5445 if (chk_length < sizeof(struct sctp_forward_tsn_chunk)) { 5446 /* Its not ours */ 5447 if (locked_tcb) { 5448 SCTP_TCB_UNLOCK(locked_tcb); 5449 } 5450 *offset = length; 5451 return (NULL); 5452 } 5453 /* He's alive so give him credit */ 5454 if (stcb) { 5455 int abort_flag = 0; 5456 5457 if (stcb->asoc.prsctp_supported == 0) { 5458 goto unknown_chunk; 5459 } 5460 stcb->asoc.overall_error_count = 0; 5461 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_THRESHOLD_LOGGING) { 5462 sctp_misc_ints(SCTP_THRESHOLD_CLEAR, 5463 stcb->asoc.overall_error_count, 5464 0, 5465 SCTP_FROM_SCTP_INPUT, 5466 __LINE__); 5467 } 5468 *fwd_tsn_seen = 1; 5469 if (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) { 5470 /* We are not interested anymore */ 5471#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 5472 so = SCTP_INP_SO(inp); 5473 atomic_add_int(&stcb->asoc.refcnt, 1); 5474 SCTP_TCB_UNLOCK(stcb); 5475 SCTP_SOCKET_LOCK(so, 1); 5476 SCTP_TCB_LOCK(stcb); 5477 atomic_subtract_int(&stcb->asoc.refcnt, 1); 5478#endif 5479 (void)sctp_free_assoc(inp, stcb, SCTP_NORMAL_PROC, 5480 SCTP_FROM_SCTP_INPUT + SCTP_LOC_31); 5481#if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 5482 SCTP_SOCKET_UNLOCK(so, 1); 5483#endif 5484 *offset = length; 5485 return (NULL); 5486 } 5487 sctp_handle_forward_tsn(stcb, 5488 (struct sctp_forward_tsn_chunk *)ch, &abort_flag, m, *offset); 5489 if (abort_flag) { 5490 *offset = length; 5491 return (NULL); 5492 } else { 5493 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_THRESHOLD_LOGGING) { 5494 sctp_misc_ints(SCTP_THRESHOLD_CLEAR, 5495 stcb->asoc.overall_error_count, 5496 0, 5497 SCTP_FROM_SCTP_INPUT, 5498 __LINE__); 5499 } 5500 stcb->asoc.overall_error_count = 0; 5501 } 5502 5503 } 5504 break; 5505 case SCTP_STREAM_RESET: 5506 SCTPDBG(SCTP_DEBUG_INPUT3, "SCTP_STREAM_RESET\n"); 5507 if (((stcb == NULL) || (ch == NULL) || (chk_length < sizeof(struct sctp_stream_reset_tsn_req)))) { 5508 /* Its not ours */ 5509 if (locked_tcb) { 5510 SCTP_TCB_UNLOCK(locked_tcb); 5511 } 5512 *offset = length; 5513 return (NULL); 5514 } 5515 if (stcb->asoc.reconfig_supported == 0) { 5516 goto unknown_chunk; 5517 } 5518 if (sctp_handle_stream_reset(stcb, m, *offset, ch)) { 5519 /* stop processing */ 5520 *offset = length; 5521 return (NULL); 5522 } 5523 break; 5524 case SCTP_PACKET_DROPPED: 5525 SCTPDBG(SCTP_DEBUG_INPUT3, "SCTP_PACKET_DROPPED\n"); 5526 /* re-get it all please */ 5527 if (chk_length < sizeof(struct sctp_pktdrop_chunk)) { 5528 /* Its not ours */ 5529 if (locked_tcb) { 5530 SCTP_TCB_UNLOCK(locked_tcb); 5531 } 5532 *offset = length; 5533 return (NULL); 5534 } 5535 if (ch && (stcb) && netp && (*netp)) { 5536 if (stcb->asoc.pktdrop_supported == 0) { 5537 goto unknown_chunk; 5538 } 5539 sctp_handle_packet_dropped((struct sctp_pktdrop_chunk *)ch, 5540 stcb, *netp, 5541 min(chk_length, (sizeof(chunk_buf) - 4))); 5542 5543 } 5544 break; 5545 case SCTP_AUTHENTICATION: 5546 SCTPDBG(SCTP_DEBUG_INPUT3, "SCTP_AUTHENTICATION\n"); 5547 if (stcb == NULL) { 5548 /* save the first AUTH for later processing */ 5549 if (auth_skipped == 0) { 5550 auth_offset = *offset; 5551 auth_len = chk_length; 5552 auth_skipped = 1; 5553 } 5554 /* skip this chunk (temporarily) */ 5555 goto next_chunk; 5556 } 5557 if (stcb->asoc.auth_supported == 0) { 5558 goto unknown_chunk; 5559 } 5560 if ((chk_length < (sizeof(struct sctp_auth_chunk))) || 5561 (chk_length > (sizeof(struct sctp_auth_chunk) + 5562 SCTP_AUTH_DIGEST_LEN_MAX))) { 5563 /* Its not ours */ 5564 if (locked_tcb) { 5565 SCTP_TCB_UNLOCK(locked_tcb); 5566 } 5567 *offset = length; 5568 return (NULL); 5569 } 5570 if (got_auth == 1) { 5571 /* skip this chunk... it's already auth'd */ 5572 goto next_chunk; 5573 } 5574 got_auth = 1; 5575 if ((ch == NULL) || sctp_handle_auth(stcb, (struct sctp_auth_chunk *)ch, 5576 m, *offset)) { 5577 /* auth HMAC failed so dump the packet */ 5578 *offset = length; 5579 return (stcb); 5580 } else { 5581 /* remaining chunks are HMAC checked */ 5582 stcb->asoc.authenticated = 1; 5583 } 5584 break; 5585 5586 default: 5587 unknown_chunk: 5588 /* it's an unknown chunk! */ 5589 if ((ch->chunk_type & 0x40) && (stcb != NULL)) { 5590 struct sctp_gen_error_cause *cause; 5591 int len; 5592 5593 op_err = sctp_get_mbuf_for_msg(sizeof(struct sctp_gen_error_cause), 5594 0, M_NOWAIT, 1, MT_DATA); 5595 if (op_err != NULL) { 5596 len = min(SCTP_SIZE32(chk_length), (uint32_t) (length - *offset)); 5597 cause = mtod(op_err, struct sctp_gen_error_cause *); 5598 cause->code = htons(SCTP_CAUSE_UNRECOG_CHUNK); 5599 cause->length = htons(len + sizeof(struct sctp_gen_error_cause)); 5600 SCTP_BUF_LEN(op_err) = sizeof(struct sctp_gen_error_cause); 5601 SCTP_BUF_NEXT(op_err) = SCTP_M_COPYM(m, *offset, len, M_NOWAIT); 5602 if (SCTP_BUF_NEXT(op_err) != NULL) { 5603#ifdef SCTP_MBUF_LOGGING 5604 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_MBUF_LOGGING_ENABLE) { 5605 sctp_log_mbc(SCTP_BUF_NEXT(op_err), SCTP_MBUF_ICOPY); 5606 } 5607#endif 5608 sctp_queue_op_err(stcb, op_err); 5609 } else { 5610 sctp_m_freem(op_err); 5611 } 5612 } 5613 } 5614 if ((ch->chunk_type & 0x80) == 0) { 5615 /* discard this packet */ 5616 *offset = length; 5617 return (stcb); 5618 } /* else skip this bad chunk and continue... */ 5619 break; 5620 } /* switch (ch->chunk_type) */ 5621 5622 5623next_chunk: 5624 /* get the next chunk */ 5625 *offset += SCTP_SIZE32(chk_length); 5626 if (*offset >= length) { 5627 /* no more data left in the mbuf chain */ 5628 break; 5629 } 5630 ch = (struct sctp_chunkhdr *)sctp_m_getptr(m, *offset, 5631 sizeof(struct sctp_chunkhdr), chunk_buf); 5632 if (ch == NULL) { 5633 if (locked_tcb) { 5634 SCTP_TCB_UNLOCK(locked_tcb); 5635 } 5636 *offset = length; 5637 return (NULL); 5638 } 5639 } /* while */ 5640 5641 if (asconf_cnt > 0 && stcb != NULL) { 5642 sctp_send_asconf_ack(stcb); 5643 } 5644 return (stcb); 5645} 5646 5647 5648/* 5649 * common input chunk processing (v4 and v6) 5650 */ 5651void 5652sctp_common_input_processing(struct mbuf **mm, int iphlen, int offset, int length, 5653 struct sockaddr *src, struct sockaddr *dst, 5654 struct sctphdr *sh, struct sctp_chunkhdr *ch, 5655#if !defined(SCTP_WITH_NO_CSUM) 5656 uint8_t compute_crc, 5657#endif 5658 uint8_t ecn_bits, 5659 uint8_t mflowtype, uint32_t mflowid, uint16_t fibnum, 5660 uint32_t vrf_id, uint16_t port) 5661{ 5662 uint32_t high_tsn; 5663 int fwd_tsn_seen = 0, data_processed = 0; 5664 struct mbuf *m = *mm, *op_err; 5665 char msg[SCTP_DIAG_INFO_LEN]; 5666 int un_sent; 5667 int cnt_ctrl_ready = 0; 5668 struct sctp_inpcb *inp = NULL, *inp_decr = NULL; 5669 struct sctp_tcb *stcb = NULL; 5670 struct sctp_nets *net = NULL; 5671 5672 SCTP_STAT_INCR(sctps_recvdatagrams); 5673#ifdef SCTP_AUDITING_ENABLED 5674 sctp_audit_log(0xE0, 1); 5675 sctp_auditing(0, inp, stcb, net); 5676#endif 5677#if !defined(SCTP_WITH_NO_CSUM) 5678 if (compute_crc != 0) { 5679 uint32_t check, calc_check; 5680 5681 check = sh->checksum; 5682 sh->checksum = 0; 5683 calc_check = sctp_calculate_cksum(m, iphlen); 5684 sh->checksum = check; 5685 if (calc_check != check) { 5686 SCTPDBG(SCTP_DEBUG_INPUT1, "Bad CSUM on SCTP packet calc_check:%x check:%x m:%p mlen:%d iphlen:%d\n", 5687 calc_check, check, (void *)m, length, iphlen); 5688 stcb = sctp_findassociation_addr(m, offset, src, dst, 5689 sh, ch, &inp, &net, vrf_id); 5690#if defined(INET) || defined(INET6) 5691 if ((ch->chunk_type != SCTP_INITIATION) && 5692 (net != NULL) && (net->port != port)) { 5693 if (net->port == 0) { 5694 /* UDP encapsulation turned on. */ 5695 net->mtu -= sizeof(struct udphdr); 5696 if (stcb->asoc.smallest_mtu > net->mtu) { 5697 sctp_pathmtu_adjustment(stcb, net->mtu); 5698 } 5699 } else if (port == 0) { 5700 /* UDP encapsulation turned off. */ 5701 net->mtu += sizeof(struct udphdr); 5702 /* XXX Update smallest_mtu */ 5703 } 5704 net->port = port; 5705 } 5706#endif 5707 if (net != NULL) { 5708 net->flowtype = mflowtype; 5709 net->flowid = mflowid; 5710 } 5711 if ((inp != NULL) && (stcb != NULL)) { 5712 sctp_send_packet_dropped(stcb, net, m, length, iphlen, 1); 5713 sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_INPUT_ERROR, SCTP_SO_NOT_LOCKED); 5714 } else if ((inp != NULL) && (stcb == NULL)) { 5715 inp_decr = inp; 5716 } 5717 SCTP_STAT_INCR(sctps_badsum); 5718 SCTP_STAT_INCR_COUNTER32(sctps_checksumerrors); 5719 goto out; 5720 } 5721 } 5722#endif 5723 /* Destination port of 0 is illegal, based on RFC4960. */ 5724 if (sh->dest_port == 0) { 5725 SCTP_STAT_INCR(sctps_hdrops); 5726 goto out; 5727 } 5728 stcb = sctp_findassociation_addr(m, offset, src, dst, 5729 sh, ch, &inp, &net, vrf_id); 5730#if defined(INET) || defined(INET6) 5731 if ((ch->chunk_type != SCTP_INITIATION) && 5732 (net != NULL) && (net->port != port)) { 5733 if (net->port == 0) { 5734 /* UDP encapsulation turned on. */ 5735 net->mtu -= sizeof(struct udphdr); 5736 if (stcb->asoc.smallest_mtu > net->mtu) { 5737 sctp_pathmtu_adjustment(stcb, net->mtu); 5738 } 5739 } else if (port == 0) { 5740 /* UDP encapsulation turned off. */ 5741 net->mtu += sizeof(struct udphdr); 5742 /* XXX Update smallest_mtu */ 5743 } 5744 net->port = port; 5745 } 5746#endif 5747 if (net != NULL) { 5748 net->flowtype = mflowtype; 5749 net->flowid = mflowid; 5750 } 5751 if (inp == NULL) { 5752 SCTP_STAT_INCR(sctps_noport); 5753 if (badport_bandlim(BANDLIM_SCTP_OOTB) < 0) { 5754 goto out; 5755 } 5756 if (ch->chunk_type == SCTP_SHUTDOWN_ACK) { 5757 sctp_send_shutdown_complete2(src, dst, sh, 5758 mflowtype, mflowid, fibnum, 5759 vrf_id, port); 5760 goto out; 5761 } 5762 if (ch->chunk_type == SCTP_SHUTDOWN_COMPLETE) { 5763 goto out; 5764 } 5765 if (ch->chunk_type != SCTP_ABORT_ASSOCIATION) { 5766 if ((SCTP_BASE_SYSCTL(sctp_blackhole) == 0) || 5767 ((SCTP_BASE_SYSCTL(sctp_blackhole) == 1) && 5768 (ch->chunk_type != SCTP_INIT))) { 5769 op_err = sctp_generate_cause(SCTP_BASE_SYSCTL(sctp_diag_info_code), 5770 "Out of the blue"); 5771 sctp_send_abort(m, iphlen, src, dst, 5772 sh, 0, op_err, 5773 mflowtype, mflowid, fibnum, 5774 vrf_id, port); 5775 } 5776 } 5777 goto out; 5778 } else if (stcb == NULL) { 5779 inp_decr = inp; 5780 } 5781#ifdef IPSEC 5782 /*- 5783 * I very much doubt any of the IPSEC stuff will work but I have no 5784 * idea, so I will leave it in place. 5785 */ 5786 if (inp != NULL) { 5787 switch (dst->sa_family) { 5788#ifdef INET 5789 case AF_INET: 5790 if (ipsec4_in_reject(m, &inp->ip_inp.inp)) { 5791 IPSECSTAT_INC(ips_in_polvio); 5792 SCTP_STAT_INCR(sctps_hdrops); 5793 goto out; 5794 } 5795 break; 5796#endif 5797#ifdef INET6 5798 case AF_INET6: 5799 if (ipsec6_in_reject(m, &inp->ip_inp.inp)) { 5800 IPSEC6STAT_INC(ips_in_polvio); 5801 SCTP_STAT_INCR(sctps_hdrops); 5802 goto out; 5803 } 5804 break; 5805#endif 5806 default: 5807 break; 5808 } 5809 } 5810#endif 5811 SCTPDBG(SCTP_DEBUG_INPUT1, "Ok, Common input processing called, m:%p iphlen:%d offset:%d length:%d stcb:%p\n", 5812 (void *)m, iphlen, offset, length, (void *)stcb); 5813 if (stcb) { 5814 /* always clear this before beginning a packet */ 5815 stcb->asoc.authenticated = 0; 5816 stcb->asoc.seen_a_sack_this_pkt = 0; 5817 SCTPDBG(SCTP_DEBUG_INPUT1, "stcb:%p state:%x\n", 5818 (void *)stcb, stcb->asoc.state); 5819 5820 if ((stcb->asoc.state & SCTP_STATE_WAS_ABORTED) || 5821 (stcb->asoc.state & SCTP_STATE_ABOUT_TO_BE_FREED)) { 5822 /*- 5823 * If we hit here, we had a ref count 5824 * up when the assoc was aborted and the 5825 * timer is clearing out the assoc, we should 5826 * NOT respond to any packet.. its OOTB. 5827 */ 5828 SCTP_TCB_UNLOCK(stcb); 5829 stcb = NULL; 5830 snprintf(msg, sizeof(msg), "OOTB, %s:%d at %s", __FILE__, __LINE__, __func__); 5831 op_err = sctp_generate_cause(SCTP_BASE_SYSCTL(sctp_diag_info_code), 5832 msg); 5833 sctp_handle_ootb(m, iphlen, offset, src, dst, sh, inp, op_err, 5834 mflowtype, mflowid, inp->fibnum, 5835 vrf_id, port); 5836 goto out; 5837 } 5838 } 5839 if (IS_SCTP_CONTROL(ch)) { 5840 /* process the control portion of the SCTP packet */ 5841 /* sa_ignore NO_NULL_CHK */ 5842 stcb = sctp_process_control(m, iphlen, &offset, length, 5843 src, dst, sh, ch, 5844 inp, stcb, &net, &fwd_tsn_seen, 5845 mflowtype, mflowid, fibnum, 5846 vrf_id, port); 5847 if (stcb) { 5848 /* 5849 * This covers us if the cookie-echo was there and 5850 * it changes our INP. 5851 */ 5852 inp = stcb->sctp_ep; 5853#if defined(INET) || defined(INET6) 5854 if ((ch->chunk_type != SCTP_INITIATION) && 5855 (net != NULL) && (net->port != port)) { 5856 if (net->port == 0) { 5857 /* UDP encapsulation turned on. */ 5858 net->mtu -= sizeof(struct udphdr); 5859 if (stcb->asoc.smallest_mtu > net->mtu) { 5860 sctp_pathmtu_adjustment(stcb, net->mtu); 5861 } 5862 } else if (port == 0) { 5863 /* UDP encapsulation turned off. */ 5864 net->mtu += sizeof(struct udphdr); 5865 /* XXX Update smallest_mtu */ 5866 } 5867 net->port = port; 5868 } 5869#endif 5870 } 5871 } else { 5872 /* 5873 * no control chunks, so pre-process DATA chunks (these 5874 * checks are taken care of by control processing) 5875 */ 5876 5877 /* 5878 * if DATA only packet, and auth is required, then punt... 5879 * can't have authenticated without any AUTH (control) 5880 * chunks 5881 */ 5882 if ((stcb != NULL) && 5883 (stcb->asoc.auth_supported == 1) && 5884 sctp_auth_is_required_chunk(SCTP_DATA, stcb->asoc.local_auth_chunks)) { 5885 /* "silently" ignore */ 5886 SCTP_STAT_INCR(sctps_recvauthmissing); 5887 goto out; 5888 } 5889 if (stcb == NULL) { 5890 /* out of the blue DATA chunk */ 5891 snprintf(msg, sizeof(msg), "OOTB, %s:%d at %s", __FILE__, __LINE__, __func__); 5892 op_err = sctp_generate_cause(SCTP_BASE_SYSCTL(sctp_diag_info_code), 5893 msg); 5894 sctp_handle_ootb(m, iphlen, offset, src, dst, sh, inp, op_err, 5895 mflowtype, mflowid, fibnum, 5896 vrf_id, port); 5897 goto out; 5898 } 5899 if (stcb->asoc.my_vtag != ntohl(sh->v_tag)) { 5900 /* v_tag mismatch! */ 5901 SCTP_STAT_INCR(sctps_badvtag); 5902 goto out; 5903 } 5904 } 5905 5906 if (stcb == NULL) { 5907 /* 5908 * no valid TCB for this packet, or we found it's a bad 5909 * packet while processing control, or we're done with this 5910 * packet (done or skip rest of data), so we drop it... 5911 */ 5912 goto out; 5913 } 5914 /* 5915 * DATA chunk processing 5916 */ 5917 /* plow through the data chunks while length > offset */ 5918 5919 /* 5920 * Rest should be DATA only. Check authentication state if AUTH for 5921 * DATA is required. 5922 */ 5923 if ((length > offset) && 5924 (stcb != NULL) && 5925 (stcb->asoc.auth_supported == 1) && 5926 sctp_auth_is_required_chunk(SCTP_DATA, stcb->asoc.local_auth_chunks) && 5927 !stcb->asoc.authenticated) { 5928 /* "silently" ignore */ 5929 SCTP_STAT_INCR(sctps_recvauthmissing); 5930 SCTPDBG(SCTP_DEBUG_AUTH1, 5931 "Data chunk requires AUTH, skipped\n"); 5932 goto trigger_send; 5933 } 5934 if (length > offset) { 5935 int retval; 5936 5937 /* 5938 * First check to make sure our state is correct. We would 5939 * not get here unless we really did have a tag, so we don't 5940 * abort if this happens, just dump the chunk silently. 5941 */ 5942 switch (SCTP_GET_STATE(&stcb->asoc)) { 5943 case SCTP_STATE_COOKIE_ECHOED: 5944 /* 5945 * we consider data with valid tags in this state 5946 * shows us the cookie-ack was lost. Imply it was 5947 * there. 5948 */ 5949 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_THRESHOLD_LOGGING) { 5950 sctp_misc_ints(SCTP_THRESHOLD_CLEAR, 5951 stcb->asoc.overall_error_count, 5952 0, 5953 SCTP_FROM_SCTP_INPUT, 5954 __LINE__); 5955 } 5956 stcb->asoc.overall_error_count = 0; 5957 sctp_handle_cookie_ack((struct sctp_cookie_ack_chunk *)ch, stcb, net); 5958 break; 5959 case SCTP_STATE_COOKIE_WAIT: 5960 /* 5961 * We consider OOTB any data sent during asoc setup. 5962 */ 5963 snprintf(msg, sizeof(msg), "OOTB, %s:%d at %s", __FILE__, __LINE__, __func__); 5964 op_err = sctp_generate_cause(SCTP_BASE_SYSCTL(sctp_diag_info_code), 5965 msg); 5966 sctp_handle_ootb(m, iphlen, offset, src, dst, sh, inp, op_err, 5967 mflowtype, mflowid, inp->fibnum, 5968 vrf_id, port); 5969 goto out; 5970 /* sa_ignore NOTREACHED */ 5971 break; 5972 case SCTP_STATE_EMPTY: /* should not happen */ 5973 case SCTP_STATE_INUSE: /* should not happen */ 5974 case SCTP_STATE_SHUTDOWN_RECEIVED: /* This is a peer error */ 5975 case SCTP_STATE_SHUTDOWN_ACK_SENT: 5976 default: 5977 goto out; 5978 /* sa_ignore NOTREACHED */ 5979 break; 5980 case SCTP_STATE_OPEN: 5981 case SCTP_STATE_SHUTDOWN_SENT: 5982 break; 5983 } 5984 /* plow through the data chunks while length > offset */ 5985 retval = sctp_process_data(mm, iphlen, &offset, length, 5986 inp, stcb, net, &high_tsn); 5987 if (retval == 2) { 5988 /* 5989 * The association aborted, NO UNLOCK needed since 5990 * the association is destroyed. 5991 */ 5992 stcb = NULL; 5993 goto out; 5994 } 5995 data_processed = 1; 5996 /* 5997 * Anything important needs to have been m_copy'ed in 5998 * process_data 5999 */ 6000 } 6001 /* take care of ecn */ 6002 if ((data_processed == 1) && 6003 (stcb->asoc.ecn_supported == 1) && 6004 ((ecn_bits & SCTP_CE_BITS) == SCTP_CE_BITS)) { 6005 /* Yep, we need to add a ECNE */ 6006 sctp_send_ecn_echo(stcb, net, high_tsn); 6007 } 6008 if ((data_processed == 0) && (fwd_tsn_seen)) { 6009 int was_a_gap; 6010 uint32_t highest_tsn; 6011 6012 if (SCTP_TSN_GT(stcb->asoc.highest_tsn_inside_nr_map, stcb->asoc.highest_tsn_inside_map)) { 6013 highest_tsn = stcb->asoc.highest_tsn_inside_nr_map; 6014 } else { 6015 highest_tsn = stcb->asoc.highest_tsn_inside_map; 6016 } 6017 was_a_gap = SCTP_TSN_GT(highest_tsn, stcb->asoc.cumulative_tsn); 6018 stcb->asoc.send_sack = 1; 6019 sctp_sack_check(stcb, was_a_gap); 6020 } else if (fwd_tsn_seen) { 6021 stcb->asoc.send_sack = 1; 6022 } 6023 /* trigger send of any chunks in queue... */ 6024trigger_send: 6025#ifdef SCTP_AUDITING_ENABLED 6026 sctp_audit_log(0xE0, 2); 6027 sctp_auditing(1, inp, stcb, net); 6028#endif 6029 SCTPDBG(SCTP_DEBUG_INPUT1, 6030 "Check for chunk output prw:%d tqe:%d tf=%d\n", 6031 stcb->asoc.peers_rwnd, 6032 TAILQ_EMPTY(&stcb->asoc.control_send_queue), 6033 stcb->asoc.total_flight); 6034 un_sent = (stcb->asoc.total_output_queue_size - stcb->asoc.total_flight); 6035 if (!TAILQ_EMPTY(&stcb->asoc.control_send_queue)) { 6036 cnt_ctrl_ready = stcb->asoc.ctrl_queue_cnt - stcb->asoc.ecn_echo_cnt_onq; 6037 } 6038 if (cnt_ctrl_ready || stcb->asoc.trigger_reset || 6039 ((un_sent) && 6040 (stcb->asoc.peers_rwnd > 0 || 6041 (stcb->asoc.peers_rwnd <= 0 && stcb->asoc.total_flight == 0)))) { 6042 SCTPDBG(SCTP_DEBUG_INPUT3, "Calling chunk OUTPUT\n"); 6043 sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_CONTROL_PROC, SCTP_SO_NOT_LOCKED); 6044 SCTPDBG(SCTP_DEBUG_INPUT3, "chunk OUTPUT returns\n"); 6045 } 6046#ifdef SCTP_AUDITING_ENABLED 6047 sctp_audit_log(0xE0, 3); 6048 sctp_auditing(2, inp, stcb, net); 6049#endif 6050out: 6051 if (stcb != NULL) { 6052 SCTP_TCB_UNLOCK(stcb); 6053 } 6054 if (inp_decr != NULL) { 6055 /* reduce ref-count */ 6056 SCTP_INP_WLOCK(inp_decr); 6057 SCTP_INP_DECR_REF(inp_decr); 6058 SCTP_INP_WUNLOCK(inp_decr); 6059 } 6060 return; 6061} 6062 6063#if 0 6064static void 6065sctp_print_mbuf_chain(struct mbuf *m) 6066{ 6067 for (; m; m = SCTP_BUF_NEXT(m)) { 6068 SCTP_PRINTF("%p: m_len = %ld\n", (void *)m, SCTP_BUF_LEN(m)); 6069 if (SCTP_BUF_IS_EXTENDED(m)) 6070 SCTP_PRINTF("%p: extend_size = %d\n", (void *)m, SCTP_BUF_EXTEND_SIZE(m)); 6071 } 6072} 6073 6074#endif 6075 6076#ifdef INET 6077void 6078sctp_input_with_port(struct mbuf *i_pak, int off, uint16_t port) 6079{ 6080 struct mbuf *m; 6081 int iphlen; 6082 uint32_t vrf_id = 0; 6083 uint8_t ecn_bits; 6084 struct sockaddr_in src, dst; 6085 struct ip *ip; 6086 struct sctphdr *sh; 6087 struct sctp_chunkhdr *ch; 6088 int length, offset; 6089 6090#if !defined(SCTP_WITH_NO_CSUM) 6091 uint8_t compute_crc; 6092 6093#endif 6094 uint32_t mflowid; 6095 uint8_t mflowtype; 6096 uint16_t fibnum; 6097 6098 iphlen = off; 6099 if (SCTP_GET_PKT_VRFID(i_pak, vrf_id)) { 6100 SCTP_RELEASE_PKT(i_pak); 6101 return; 6102 } 6103 m = SCTP_HEADER_TO_CHAIN(i_pak); 6104#ifdef SCTP_MBUF_LOGGING 6105 /* Log in any input mbufs */ 6106 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_MBUF_LOGGING_ENABLE) { 6107 sctp_log_mbc(m, SCTP_MBUF_INPUT); 6108 } 6109#endif 6110#ifdef SCTP_PACKET_LOGGING 6111 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_LAST_PACKET_TRACING) { 6112 sctp_packet_log(m); 6113 } 6114#endif 6115 SCTPDBG(SCTP_DEBUG_CRCOFFLOAD, 6116 "sctp_input(): Packet of length %d received on %s with csum_flags 0x%b.\n", 6117 m->m_pkthdr.len, 6118 if_name(m->m_pkthdr.rcvif), 6119 (int)m->m_pkthdr.csum_flags, CSUM_BITS); 6120 mflowid = m->m_pkthdr.flowid; 6121 mflowtype = M_HASHTYPE_GET(m); 6122 fibnum = M_GETFIB(m); 6123 SCTP_STAT_INCR(sctps_recvpackets); 6124 SCTP_STAT_INCR_COUNTER64(sctps_inpackets); 6125 /* Get IP, SCTP, and first chunk header together in the first mbuf. */ 6126 offset = iphlen + sizeof(struct sctphdr) + sizeof(struct sctp_chunkhdr); 6127 if (SCTP_BUF_LEN(m) < offset) { 6128 if ((m = m_pullup(m, offset)) == NULL) { 6129 SCTP_STAT_INCR(sctps_hdrops); 6130 return; 6131 } 6132 } 6133 ip = mtod(m, struct ip *); 6134 sh = (struct sctphdr *)((caddr_t)ip + iphlen); 6135 ch = (struct sctp_chunkhdr *)((caddr_t)sh + sizeof(struct sctphdr)); 6136 offset -= sizeof(struct sctp_chunkhdr); 6137 memset(&src, 0, sizeof(struct sockaddr_in)); 6138 src.sin_family = AF_INET; 6139 src.sin_len = sizeof(struct sockaddr_in); 6140 src.sin_port = sh->src_port; 6141 src.sin_addr = ip->ip_src; 6142 memset(&dst, 0, sizeof(struct sockaddr_in)); 6143 dst.sin_family = AF_INET; 6144 dst.sin_len = sizeof(struct sockaddr_in); 6145 dst.sin_port = sh->dest_port; 6146 dst.sin_addr = ip->ip_dst; 6147 length = ntohs(ip->ip_len); 6148 /* Validate mbuf chain length with IP payload length. */ 6149 if (SCTP_HEADER_LEN(m) != length) { 6150 SCTPDBG(SCTP_DEBUG_INPUT1, 6151 "sctp_input() length:%d reported length:%d\n", length, SCTP_HEADER_LEN(m)); 6152 SCTP_STAT_INCR(sctps_hdrops); 6153 goto out; 6154 } 6155 /* SCTP does not allow broadcasts or multicasts */ 6156 if (IN_MULTICAST(ntohl(dst.sin_addr.s_addr))) { 6157 goto out; 6158 } 6159 if (SCTP_IS_IT_BROADCAST(dst.sin_addr, m)) { 6160 goto out; 6161 } 6162 ecn_bits = ip->ip_tos; 6163#if defined(SCTP_WITH_NO_CSUM) 6164 SCTP_STAT_INCR(sctps_recvnocrc); 6165#else 6166 if (m->m_pkthdr.csum_flags & CSUM_SCTP_VALID) { 6167 SCTP_STAT_INCR(sctps_recvhwcrc); 6168 compute_crc = 0; 6169 } else { 6170 SCTP_STAT_INCR(sctps_recvswcrc); 6171 compute_crc = 1; 6172 } 6173#endif 6174 sctp_common_input_processing(&m, iphlen, offset, length, 6175 (struct sockaddr *)&src, 6176 (struct sockaddr *)&dst, 6177 sh, ch, 6178#if !defined(SCTP_WITH_NO_CSUM) 6179 compute_crc, 6180#endif 6181 ecn_bits, 6182 mflowtype, mflowid, fibnum, 6183 vrf_id, port); 6184out: 6185 if (m) { 6186 sctp_m_freem(m); 6187 } 6188 return; 6189} 6190 6191#if defined(__FreeBSD__) && defined(SCTP_MCORE_INPUT) && defined(SMP) 6192extern int *sctp_cpuarry; 6193 6194#endif 6195 6196void 6197sctp_input(struct mbuf *m, int off) 6198{ 6199#if defined(__FreeBSD__) && defined(SCTP_MCORE_INPUT) && defined(SMP) 6200 struct ip *ip; 6201 struct sctphdr *sh; 6202 int offset; 6203 int cpu_to_use; 6204 uint32_t flowid, tag; 6205 6206 if (mp_ncpus > 1) { 6207 if (M_HASHTYPE_GET(m) != M_HASHTYPE_NONE) { 6208 flowid = m->m_pkthdr.flowid; 6209 } else { 6210 /* 6211 * No flow id built by lower layers fix it so we 6212 * create one. 6213 */ 6214 offset = off + sizeof(struct sctphdr); 6215 if (SCTP_BUF_LEN(m) < offset) { 6216 if ((m = m_pullup(m, offset)) == NULL) { 6217 SCTP_STAT_INCR(sctps_hdrops); 6218 return; 6219 } 6220 } 6221 ip = mtod(m, struct ip *); 6222 sh = (struct sctphdr *)((caddr_t)ip + off); 6223 tag = htonl(sh->v_tag); 6224 flowid = tag ^ ntohs(sh->dest_port) ^ ntohs(sh->src_port); 6225 m->m_pkthdr.flowid = flowid; 6226 M_HASHTYPE_SET(m, M_HASHTYPE_OPAQUE); 6227 } 6228 cpu_to_use = sctp_cpuarry[flowid % mp_ncpus]; 6229 sctp_queue_to_mcore(m, off, cpu_to_use); 6230 return; 6231 } 6232#endif 6233 sctp_input_with_port(m, off, 0); 6234} 6235 6236#endif 6237