1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* SCTP kernel implementation 3 * (C) Copyright IBM Corp. 2001, 2004 4 * Copyright (c) 1999-2000 Cisco, Inc. 5 * Copyright (c) 1999-2001 Motorola, Inc. 6 * Copyright (c) 2001 Intel Corp. 7 * Copyright (c) 2001 Nokia, Inc. 8 * Copyright (c) 2001 La Monte H.P. Yarroll 9 * 10 * This abstraction carries sctp events to the ULP (sockets). 11 * 12 * Please send any bug reports or fixes you make to the 13 * email address(es): 14 * lksctp developers <linux-sctp@vger.kernel.org> 15 * 16 * Written or modified by: 17 * Jon Grimm <jgrimm@us.ibm.com> 18 * La Monte H.P. Yarroll <piggy@acm.org> 19 * Sridhar Samudrala <sri@us.ibm.com> 20 */ 21 22 #include <linux/slab.h> 23 #include <linux/types.h> 24 #include <linux/skbuff.h> 25 #include <net/sock.h> 26 #include <net/busy_poll.h> 27 #include <net/sctp/structs.h> 28 #include <net/sctp/sctp.h> 29 #include <net/sctp/sm.h> 30 31 /* Forward declarations for internal helpers. */ 32 static struct sctp_ulpevent *sctp_ulpq_reasm(struct sctp_ulpq *ulpq, 33 struct sctp_ulpevent *); 34 static struct sctp_ulpevent *sctp_ulpq_order(struct sctp_ulpq *, 35 struct sctp_ulpevent *); 36 static void sctp_ulpq_reasm_drain(struct sctp_ulpq *ulpq); 37 38 /* 1st Level Abstractions */ 39 40 /* Initialize a ULP queue from a block of memory. */ 41 void sctp_ulpq_init(struct sctp_ulpq *ulpq, struct sctp_association *asoc) 42 { 43 memset(ulpq, 0, sizeof(struct sctp_ulpq)); 44 45 ulpq->asoc = asoc; 46 skb_queue_head_init(&ulpq->reasm); 47 skb_queue_head_init(&ulpq->reasm_uo); 48 skb_queue_head_init(&ulpq->lobby); 49 ulpq->pd_mode = 0; 50 } 51 52 53 /* Flush the reassembly and ordering queues. */ 54 void sctp_ulpq_flush(struct sctp_ulpq *ulpq) 55 { 56 struct sk_buff *skb; 57 struct sctp_ulpevent *event; 58 59 while ((skb = __skb_dequeue(&ulpq->lobby)) != NULL) { 60 event = sctp_skb2event(skb); 61 sctp_ulpevent_free(event); 62 } 63 64 while ((skb = __skb_dequeue(&ulpq->reasm)) != NULL) { 65 event = sctp_skb2event(skb); 66 sctp_ulpevent_free(event); 67 } 68 69 while ((skb = __skb_dequeue(&ulpq->reasm_uo)) != NULL) { 70 event = sctp_skb2event(skb); 71 sctp_ulpevent_free(event); 72 } 73 } 74 75 /* Dispose of a ulpqueue. */ 76 void sctp_ulpq_free(struct sctp_ulpq *ulpq) 77 { 78 sctp_ulpq_flush(ulpq); 79 } 80 81 /* Process an incoming DATA chunk. */ 82 int sctp_ulpq_tail_data(struct sctp_ulpq *ulpq, struct sctp_chunk *chunk, 83 gfp_t gfp) 84 { 85 struct sk_buff_head temp; 86 struct sctp_ulpevent *event; 87 int event_eor = 0; 88 89 /* Create an event from the incoming chunk. */ 90 event = sctp_ulpevent_make_rcvmsg(chunk->asoc, chunk, gfp); 91 if (!event) 92 return -ENOMEM; 93 94 event->ssn = ntohs(chunk->subh.data_hdr->ssn); 95 event->ppid = chunk->subh.data_hdr->ppid; 96 97 /* Do reassembly if needed. */ 98 event = sctp_ulpq_reasm(ulpq, event); 99 100 /* Do ordering if needed. */ 101 if (event) { 102 /* Create a temporary list to collect chunks on. */ 103 skb_queue_head_init(&temp); 104 __skb_queue_tail(&temp, sctp_event2skb(event)); 105 106 if (event->msg_flags & MSG_EOR) 107 event = sctp_ulpq_order(ulpq, event); 108 } 109 110 /* Send event to the ULP. 'event' is the sctp_ulpevent for 111 * very first SKB on the 'temp' list. 112 */ 113 if (event) { 114 event_eor = (event->msg_flags & MSG_EOR) ? 1 : 0; 115 sctp_ulpq_tail_event(ulpq, &temp); 116 } 117 118 return event_eor; 119 } 120 121 /* Add a new event for propagation to the ULP. */ 122 /* Clear the partial delivery mode for this socket. Note: This 123 * assumes that no association is currently in partial delivery mode. 124 */ 125 int sctp_clear_pd(struct sock *sk, struct sctp_association *asoc) 126 { 127 struct sctp_sock *sp = sctp_sk(sk); 128 129 if (atomic_dec_and_test(&sp->pd_mode)) { 130 /* This means there are no other associations in PD, so 131 * we can go ahead and clear out the lobby in one shot 132 */ 133 if (!skb_queue_empty(&sp->pd_lobby)) { 134 skb_queue_splice_tail_init(&sp->pd_lobby, 135 &sk->sk_receive_queue); 136 return 1; 137 } 138 } else { 139 /* There are other associations in PD, so we only need to 140 * pull stuff out of the lobby that belongs to the 141 * associations that is exiting PD (all of its notifications 142 * are posted here). 143 */ 144 if (!skb_queue_empty(&sp->pd_lobby) && asoc) { 145 struct sk_buff *skb, *tmp; 146 struct sctp_ulpevent *event; 147 148 sctp_skb_for_each(skb, &sp->pd_lobby, tmp) { 149 event = sctp_skb2event(skb); 150 if (event->asoc == asoc) { 151 __skb_unlink(skb, &sp->pd_lobby); 152 __skb_queue_tail(&sk->sk_receive_queue, 153 skb); 154 } 155 } 156 } 157 } 158 159 return 0; 160 } 161 162 /* Set the pd_mode on the socket and ulpq */ 163 static void sctp_ulpq_set_pd(struct sctp_ulpq *ulpq) 164 { 165 struct sctp_sock *sp = sctp_sk(ulpq->asoc->base.sk); 166 167 atomic_inc(&sp->pd_mode); 168 ulpq->pd_mode = 1; 169 } 170 171 /* Clear the pd_mode and restart any pending messages waiting for delivery. */ 172 static int sctp_ulpq_clear_pd(struct sctp_ulpq *ulpq) 173 { 174 ulpq->pd_mode = 0; 175 sctp_ulpq_reasm_drain(ulpq); 176 return sctp_clear_pd(ulpq->asoc->base.sk, ulpq->asoc); 177 } 178 179 int sctp_ulpq_tail_event(struct sctp_ulpq *ulpq, struct sk_buff_head *skb_list) 180 { 181 struct sock *sk = ulpq->asoc->base.sk; 182 struct sctp_sock *sp = sctp_sk(sk); 183 struct sctp_ulpevent *event; 184 struct sk_buff_head *queue; 185 struct sk_buff *skb; 186 int clear_pd = 0; 187 188 skb = __skb_peek(skb_list); 189 event = sctp_skb2event(skb); 190 191 /* If the socket is just going to throw this away, do not 192 * even try to deliver it. 193 */ 194 if (sk->sk_shutdown & RCV_SHUTDOWN && 195 (sk->sk_shutdown & SEND_SHUTDOWN || 196 !sctp_ulpevent_is_notification(event))) 197 goto out_free; 198 199 if (!sctp_ulpevent_is_notification(event)) { 200 sk_mark_napi_id(sk, skb); 201 sk_incoming_cpu_update(sk); 202 } 203 /* Check if the user wishes to receive this event. */ 204 if (!sctp_ulpevent_is_enabled(event, ulpq->asoc->subscribe)) 205 goto out_free; 206 207 /* If we are in partial delivery mode, post to the lobby until 208 * partial delivery is cleared, unless, of course _this_ is 209 * the association the cause of the partial delivery. 210 */ 211 212 if (atomic_read(&sp->pd_mode) == 0) { 213 queue = &sk->sk_receive_queue; 214 } else { 215 if (ulpq->pd_mode) { 216 /* If the association is in partial delivery, we 217 * need to finish delivering the partially processed 218 * packet before passing any other data. This is 219 * because we don't truly support stream interleaving. 220 */ 221 if ((event->msg_flags & MSG_NOTIFICATION) || 222 (SCTP_DATA_NOT_FRAG == 223 (event->msg_flags & SCTP_DATA_FRAG_MASK))) 224 queue = &sp->pd_lobby; 225 else { 226 clear_pd = event->msg_flags & MSG_EOR; 227 queue = &sk->sk_receive_queue; 228 } 229 } else { 230 /* 231 * If fragment interleave is enabled, we 232 * can queue this to the receive queue instead 233 * of the lobby. 234 */ 235 if (sp->frag_interleave) 236 queue = &sk->sk_receive_queue; 237 else 238 queue = &sp->pd_lobby; 239 } 240 } 241 242 skb_queue_splice_tail_init(skb_list, queue); 243 244 /* Did we just complete partial delivery and need to get 245 * rolling again? Move pending data to the receive 246 * queue. 247 */ 248 if (clear_pd) 249 sctp_ulpq_clear_pd(ulpq); 250 251 if (queue == &sk->sk_receive_queue && !sp->data_ready_signalled) { 252 if (!sock_owned_by_user(sk)) 253 sp->data_ready_signalled = 1; 254 sk->sk_data_ready(sk); 255 } 256 return 1; 257 258 out_free: 259 if (skb_list) 260 sctp_queue_purge_ulpevents(skb_list); 261 else 262 sctp_ulpevent_free(event); 263 264 return 0; 265 } 266 267 /* 2nd Level Abstractions */ 268 269 /* Helper function to store chunks that need to be reassembled. */ 270 static void sctp_ulpq_store_reasm(struct sctp_ulpq *ulpq, 271 struct sctp_ulpevent *event) 272 { 273 struct sk_buff *pos; 274 struct sctp_ulpevent *cevent; 275 __u32 tsn, ctsn; 276 277 tsn = event->tsn; 278 279 /* See if it belongs at the end. */ 280 pos = skb_peek_tail(&ulpq->reasm); 281 if (!pos) { 282 __skb_queue_tail(&ulpq->reasm, sctp_event2skb(event)); 283 return; 284 } 285 286 /* Short circuit just dropping it at the end. */ 287 cevent = sctp_skb2event(pos); 288 ctsn = cevent->tsn; 289 if (TSN_lt(ctsn, tsn)) { 290 __skb_queue_tail(&ulpq->reasm, sctp_event2skb(event)); 291 return; 292 } 293 294 /* Find the right place in this list. We store them by TSN. */ 295 skb_queue_walk(&ulpq->reasm, pos) { 296 cevent = sctp_skb2event(pos); 297 ctsn = cevent->tsn; 298 299 if (TSN_lt(tsn, ctsn)) 300 break; 301 } 302 303 /* Insert before pos. */ 304 __skb_queue_before(&ulpq->reasm, pos, sctp_event2skb(event)); 305 306 } 307 308 /* Helper function to return an event corresponding to the reassembled 309 * datagram. 310 * This routine creates a re-assembled skb given the first and last skb's 311 * as stored in the reassembly queue. The skb's may be non-linear if the sctp 312 * payload was fragmented on the way and ip had to reassemble them. 313 * We add the rest of skb's to the first skb's fraglist. 314 */ 315 struct sctp_ulpevent *sctp_make_reassembled_event(struct net *net, 316 struct sk_buff_head *queue, 317 struct sk_buff *f_frag, 318 struct sk_buff *l_frag) 319 { 320 struct sk_buff *pos; 321 struct sk_buff *new = NULL; 322 struct sctp_ulpevent *event; 323 struct sk_buff *pnext, *last; 324 struct sk_buff *list = skb_shinfo(f_frag)->frag_list; 325 326 /* Store the pointer to the 2nd skb */ 327 if (f_frag == l_frag) 328 pos = NULL; 329 else 330 pos = f_frag->next; 331 332 /* Get the last skb in the f_frag's frag_list if present. */ 333 for (last = list; list; last = list, list = list->next) 334 ; 335 336 /* Add the list of remaining fragments to the first fragments 337 * frag_list. 338 */ 339 if (last) 340 last->next = pos; 341 else { 342 if (skb_cloned(f_frag)) { 343 /* This is a cloned skb, we can't just modify 344 * the frag_list. We need a new skb to do that. 345 * Instead of calling skb_unshare(), we'll do it 346 * ourselves since we need to delay the free. 347 */ 348 new = skb_copy(f_frag, GFP_ATOMIC); 349 if (!new) 350 return NULL; /* try again later */ 351 352 sctp_skb_set_owner_r(new, f_frag->sk); 353 354 skb_shinfo(new)->frag_list = pos; 355 } else 356 skb_shinfo(f_frag)->frag_list = pos; 357 } 358 359 /* Remove the first fragment from the reassembly queue. */ 360 __skb_unlink(f_frag, queue); 361 362 /* if we did unshare, then free the old skb and re-assign */ 363 if (new) { 364 kfree_skb(f_frag); 365 f_frag = new; 366 } 367 368 while (pos) { 369 370 pnext = pos->next; 371 372 /* Update the len and data_len fields of the first fragment. */ 373 f_frag->len += pos->len; 374 f_frag->data_len += pos->len; 375 376 /* Remove the fragment from the reassembly queue. */ 377 __skb_unlink(pos, queue); 378 379 /* Break if we have reached the last fragment. */ 380 if (pos == l_frag) 381 break; 382 pos->next = pnext; 383 pos = pnext; 384 } 385 386 event = sctp_skb2event(f_frag); 387 SCTP_INC_STATS(net, SCTP_MIB_REASMUSRMSGS); 388 389 return event; 390 } 391 392 393 /* Helper function to check if an incoming chunk has filled up the last 394 * missing fragment in a SCTP datagram and return the corresponding event. 395 */ 396 static struct sctp_ulpevent *sctp_ulpq_retrieve_reassembled(struct sctp_ulpq *ulpq) 397 { 398 struct sk_buff *pos; 399 struct sctp_ulpevent *cevent; 400 struct sk_buff *first_frag = NULL; 401 __u32 ctsn, next_tsn; 402 struct sctp_ulpevent *retval = NULL; 403 struct sk_buff *pd_first = NULL; 404 struct sk_buff *pd_last = NULL; 405 size_t pd_len = 0; 406 struct sctp_association *asoc; 407 u32 pd_point; 408 409 /* Initialized to 0 just to avoid compiler warning message. Will 410 * never be used with this value. It is referenced only after it 411 * is set when we find the first fragment of a message. 412 */ 413 next_tsn = 0; 414 415 /* The chunks are held in the reasm queue sorted by TSN. 416 * Walk through the queue sequentially and look for a sequence of 417 * fragmented chunks that complete a datagram. 418 * 'first_frag' and next_tsn are reset when we find a chunk which 419 * is the first fragment of a datagram. Once these 2 fields are set 420 * we expect to find the remaining middle fragments and the last 421 * fragment in order. If not, first_frag is reset to NULL and we 422 * start the next pass when we find another first fragment. 423 * 424 * There is a potential to do partial delivery if user sets 425 * SCTP_PARTIAL_DELIVERY_POINT option. Lets count some things here 426 * to see if can do PD. 427 */ 428 skb_queue_walk(&ulpq->reasm, pos) { 429 cevent = sctp_skb2event(pos); 430 ctsn = cevent->tsn; 431 432 switch (cevent->msg_flags & SCTP_DATA_FRAG_MASK) { 433 case SCTP_DATA_FIRST_FRAG: 434 /* If this "FIRST_FRAG" is the first 435 * element in the queue, then count it towards 436 * possible PD. 437 */ 438 if (skb_queue_is_first(&ulpq->reasm, pos)) { 439 pd_first = pos; 440 pd_last = pos; 441 pd_len = pos->len; 442 } else { 443 pd_first = NULL; 444 pd_last = NULL; 445 pd_len = 0; 446 } 447 448 first_frag = pos; 449 next_tsn = ctsn + 1; 450 break; 451 452 case SCTP_DATA_MIDDLE_FRAG: 453 if ((first_frag) && (ctsn == next_tsn)) { 454 next_tsn++; 455 if (pd_first) { 456 pd_last = pos; 457 pd_len += pos->len; 458 } 459 } else 460 first_frag = NULL; 461 break; 462 463 case SCTP_DATA_LAST_FRAG: 464 if (first_frag && (ctsn == next_tsn)) 465 goto found; 466 else 467 first_frag = NULL; 468 break; 469 } 470 } 471 472 asoc = ulpq->asoc; 473 if (pd_first) { 474 /* Make sure we can enter partial deliver. 475 * We can trigger partial delivery only if framgent 476 * interleave is set, or the socket is not already 477 * in partial delivery. 478 */ 479 if (!sctp_sk(asoc->base.sk)->frag_interleave && 480 atomic_read(&sctp_sk(asoc->base.sk)->pd_mode)) 481 goto done; 482 483 cevent = sctp_skb2event(pd_first); 484 pd_point = sctp_sk(asoc->base.sk)->pd_point; 485 if (pd_point && pd_point <= pd_len) { 486 retval = sctp_make_reassembled_event(asoc->base.net, 487 &ulpq->reasm, 488 pd_first, pd_last); 489 if (retval) 490 sctp_ulpq_set_pd(ulpq); 491 } 492 } 493 done: 494 return retval; 495 found: 496 retval = sctp_make_reassembled_event(ulpq->asoc->base.net, 497 &ulpq->reasm, first_frag, pos); 498 if (retval) 499 retval->msg_flags |= MSG_EOR; 500 goto done; 501 } 502 503 /* Retrieve the next set of fragments of a partial message. */ 504 static struct sctp_ulpevent *sctp_ulpq_retrieve_partial(struct sctp_ulpq *ulpq) 505 { 506 struct sk_buff *pos, *last_frag, *first_frag; 507 struct sctp_ulpevent *cevent; 508 __u32 ctsn, next_tsn; 509 int is_last; 510 struct sctp_ulpevent *retval; 511 512 /* The chunks are held in the reasm queue sorted by TSN. 513 * Walk through the queue sequentially and look for the first 514 * sequence of fragmented chunks. 515 */ 516 517 if (skb_queue_empty(&ulpq->reasm)) 518 return NULL; 519 520 last_frag = first_frag = NULL; 521 retval = NULL; 522 next_tsn = 0; 523 is_last = 0; 524 525 skb_queue_walk(&ulpq->reasm, pos) { 526 cevent = sctp_skb2event(pos); 527 ctsn = cevent->tsn; 528 529 switch (cevent->msg_flags & SCTP_DATA_FRAG_MASK) { 530 case SCTP_DATA_FIRST_FRAG: 531 if (!first_frag) 532 return NULL; 533 goto done; 534 case SCTP_DATA_MIDDLE_FRAG: 535 if (!first_frag) { 536 first_frag = pos; 537 next_tsn = ctsn + 1; 538 last_frag = pos; 539 } else if (next_tsn == ctsn) { 540 next_tsn++; 541 last_frag = pos; 542 } else 543 goto done; 544 break; 545 case SCTP_DATA_LAST_FRAG: 546 if (!first_frag) 547 first_frag = pos; 548 else if (ctsn != next_tsn) 549 goto done; 550 last_frag = pos; 551 is_last = 1; 552 goto done; 553 default: 554 return NULL; 555 } 556 } 557 558 /* We have the reassembled event. There is no need to look 559 * further. 560 */ 561 done: 562 retval = sctp_make_reassembled_event(ulpq->asoc->base.net, &ulpq->reasm, 563 first_frag, last_frag); 564 if (retval && is_last) 565 retval->msg_flags |= MSG_EOR; 566 567 return retval; 568 } 569 570 571 /* Helper function to reassemble chunks. Hold chunks on the reasm queue that 572 * need reassembling. 573 */ 574 static struct sctp_ulpevent *sctp_ulpq_reasm(struct sctp_ulpq *ulpq, 575 struct sctp_ulpevent *event) 576 { 577 struct sctp_ulpevent *retval = NULL; 578 579 /* Check if this is part of a fragmented message. */ 580 if (SCTP_DATA_NOT_FRAG == (event->msg_flags & SCTP_DATA_FRAG_MASK)) { 581 event->msg_flags |= MSG_EOR; 582 return event; 583 } 584 585 sctp_ulpq_store_reasm(ulpq, event); 586 if (!ulpq->pd_mode) 587 retval = sctp_ulpq_retrieve_reassembled(ulpq); 588 else { 589 __u32 ctsn, ctsnap; 590 591 /* Do not even bother unless this is the next tsn to 592 * be delivered. 593 */ 594 ctsn = event->tsn; 595 ctsnap = sctp_tsnmap_get_ctsn(&ulpq->asoc->peer.tsn_map); 596 if (TSN_lte(ctsn, ctsnap)) 597 retval = sctp_ulpq_retrieve_partial(ulpq); 598 } 599 600 return retval; 601 } 602 603 /* Retrieve the first part (sequential fragments) for partial delivery. */ 604 static struct sctp_ulpevent *sctp_ulpq_retrieve_first(struct sctp_ulpq *ulpq) 605 { 606 struct sk_buff *pos, *last_frag, *first_frag; 607 struct sctp_ulpevent *cevent; 608 __u32 ctsn, next_tsn; 609 struct sctp_ulpevent *retval; 610 611 /* The chunks are held in the reasm queue sorted by TSN. 612 * Walk through the queue sequentially and look for a sequence of 613 * fragmented chunks that start a datagram. 614 */ 615 616 if (skb_queue_empty(&ulpq->reasm)) 617 return NULL; 618 619 last_frag = first_frag = NULL; 620 retval = NULL; 621 next_tsn = 0; 622 623 skb_queue_walk(&ulpq->reasm, pos) { 624 cevent = sctp_skb2event(pos); 625 ctsn = cevent->tsn; 626 627 switch (cevent->msg_flags & SCTP_DATA_FRAG_MASK) { 628 case SCTP_DATA_FIRST_FRAG: 629 if (!first_frag) { 630 first_frag = pos; 631 next_tsn = ctsn + 1; 632 last_frag = pos; 633 } else 634 goto done; 635 break; 636 637 case SCTP_DATA_MIDDLE_FRAG: 638 if (!first_frag) 639 return NULL; 640 if (ctsn == next_tsn) { 641 next_tsn++; 642 last_frag = pos; 643 } else 644 goto done; 645 break; 646 647 case SCTP_DATA_LAST_FRAG: 648 if (!first_frag) 649 return NULL; 650 else 651 goto done; 652 break; 653 654 default: 655 return NULL; 656 } 657 } 658 659 /* We have the reassembled event. There is no need to look 660 * further. 661 */ 662 done: 663 retval = sctp_make_reassembled_event(ulpq->asoc->base.net, &ulpq->reasm, 664 first_frag, last_frag); 665 return retval; 666 } 667 668 /* 669 * Flush out stale fragments from the reassembly queue when processing 670 * a Forward TSN. 671 * 672 * RFC 3758, Section 3.6 673 * 674 * After receiving and processing a FORWARD TSN, the data receiver MUST 675 * take cautions in updating its re-assembly queue. The receiver MUST 676 * remove any partially reassembled message, which is still missing one 677 * or more TSNs earlier than or equal to the new cumulative TSN point. 678 * In the event that the receiver has invoked the partial delivery API, 679 * a notification SHOULD also be generated to inform the upper layer API 680 * that the message being partially delivered will NOT be completed. 681 */ 682 void sctp_ulpq_reasm_flushtsn(struct sctp_ulpq *ulpq, __u32 fwd_tsn) 683 { 684 struct sk_buff *pos, *tmp; 685 struct sctp_ulpevent *event; 686 __u32 tsn; 687 688 if (skb_queue_empty(&ulpq->reasm)) 689 return; 690 691 skb_queue_walk_safe(&ulpq->reasm, pos, tmp) { 692 event = sctp_skb2event(pos); 693 tsn = event->tsn; 694 695 /* Since the entire message must be abandoned by the 696 * sender (item A3 in Section 3.5, RFC 3758), we can 697 * free all fragments on the list that are less then 698 * or equal to ctsn_point 699 */ 700 if (TSN_lte(tsn, fwd_tsn)) { 701 __skb_unlink(pos, &ulpq->reasm); 702 sctp_ulpevent_free(event); 703 } else 704 break; 705 } 706 } 707 708 /* 709 * Drain the reassembly queue. If we just cleared parted delivery, it 710 * is possible that the reassembly queue will contain already reassembled 711 * messages. Retrieve any such messages and give them to the user. 712 */ 713 static void sctp_ulpq_reasm_drain(struct sctp_ulpq *ulpq) 714 { 715 struct sctp_ulpevent *event = NULL; 716 717 if (skb_queue_empty(&ulpq->reasm)) 718 return; 719 720 while ((event = sctp_ulpq_retrieve_reassembled(ulpq)) != NULL) { 721 struct sk_buff_head temp; 722 723 skb_queue_head_init(&temp); 724 __skb_queue_tail(&temp, sctp_event2skb(event)); 725 726 /* Do ordering if needed. */ 727 if (event->msg_flags & MSG_EOR) 728 event = sctp_ulpq_order(ulpq, event); 729 730 /* Send event to the ULP. 'event' is the 731 * sctp_ulpevent for very first SKB on the temp' list. 732 */ 733 if (event) 734 sctp_ulpq_tail_event(ulpq, &temp); 735 } 736 } 737 738 739 /* Helper function to gather skbs that have possibly become 740 * ordered by an incoming chunk. 741 */ 742 static void sctp_ulpq_retrieve_ordered(struct sctp_ulpq *ulpq, 743 struct sctp_ulpevent *event) 744 { 745 struct sk_buff_head *event_list; 746 struct sk_buff *pos, *tmp; 747 struct sctp_ulpevent *cevent; 748 struct sctp_stream *stream; 749 __u16 sid, csid, cssn; 750 751 sid = event->stream; 752 stream = &ulpq->asoc->stream; 753 754 event_list = (struct sk_buff_head *) sctp_event2skb(event)->prev; 755 756 /* We are holding the chunks by stream, by SSN. */ 757 sctp_skb_for_each(pos, &ulpq->lobby, tmp) { 758 cevent = (struct sctp_ulpevent *) pos->cb; 759 csid = cevent->stream; 760 cssn = cevent->ssn; 761 762 /* Have we gone too far? */ 763 if (csid > sid) 764 break; 765 766 /* Have we not gone far enough? */ 767 if (csid < sid) 768 continue; 769 770 if (cssn != sctp_ssn_peek(stream, in, sid)) 771 break; 772 773 /* Found it, so mark in the stream. */ 774 sctp_ssn_next(stream, in, sid); 775 776 __skb_unlink(pos, &ulpq->lobby); 777 778 /* Attach all gathered skbs to the event. */ 779 __skb_queue_tail(event_list, pos); 780 } 781 } 782 783 /* Helper function to store chunks needing ordering. */ 784 static void sctp_ulpq_store_ordered(struct sctp_ulpq *ulpq, 785 struct sctp_ulpevent *event) 786 { 787 struct sk_buff *pos; 788 struct sctp_ulpevent *cevent; 789 __u16 sid, csid; 790 __u16 ssn, cssn; 791 792 pos = skb_peek_tail(&ulpq->lobby); 793 if (!pos) { 794 __skb_queue_tail(&ulpq->lobby, sctp_event2skb(event)); 795 return; 796 } 797 798 sid = event->stream; 799 ssn = event->ssn; 800 801 cevent = (struct sctp_ulpevent *) pos->cb; 802 csid = cevent->stream; 803 cssn = cevent->ssn; 804 if (sid > csid) { 805 __skb_queue_tail(&ulpq->lobby, sctp_event2skb(event)); 806 return; 807 } 808 809 if ((sid == csid) && SSN_lt(cssn, ssn)) { 810 __skb_queue_tail(&ulpq->lobby, sctp_event2skb(event)); 811 return; 812 } 813 814 /* Find the right place in this list. We store them by 815 * stream ID and then by SSN. 816 */ 817 skb_queue_walk(&ulpq->lobby, pos) { 818 cevent = (struct sctp_ulpevent *) pos->cb; 819 csid = cevent->stream; 820 cssn = cevent->ssn; 821 822 if (csid > sid) 823 break; 824 if (csid == sid && SSN_lt(ssn, cssn)) 825 break; 826 } 827 828 829 /* Insert before pos. */ 830 __skb_queue_before(&ulpq->lobby, pos, sctp_event2skb(event)); 831 } 832 833 static struct sctp_ulpevent *sctp_ulpq_order(struct sctp_ulpq *ulpq, 834 struct sctp_ulpevent *event) 835 { 836 __u16 sid, ssn; 837 struct sctp_stream *stream; 838 839 /* Check if this message needs ordering. */ 840 if (event->msg_flags & SCTP_DATA_UNORDERED) 841 return event; 842 843 /* Note: The stream ID must be verified before this routine. */ 844 sid = event->stream; 845 ssn = event->ssn; 846 stream = &ulpq->asoc->stream; 847 848 /* Is this the expected SSN for this stream ID? */ 849 if (ssn != sctp_ssn_peek(stream, in, sid)) { 850 /* We've received something out of order, so find where it 851 * needs to be placed. We order by stream and then by SSN. 852 */ 853 sctp_ulpq_store_ordered(ulpq, event); 854 return NULL; 855 } 856 857 /* Mark that the next chunk has been found. */ 858 sctp_ssn_next(stream, in, sid); 859 860 /* Go find any other chunks that were waiting for 861 * ordering. 862 */ 863 sctp_ulpq_retrieve_ordered(ulpq, event); 864 865 return event; 866 } 867 868 /* Helper function to gather skbs that have possibly become 869 * ordered by forward tsn skipping their dependencies. 870 */ 871 static void sctp_ulpq_reap_ordered(struct sctp_ulpq *ulpq, __u16 sid) 872 { 873 struct sk_buff *pos, *tmp; 874 struct sctp_ulpevent *cevent; 875 struct sctp_ulpevent *event; 876 struct sctp_stream *stream; 877 struct sk_buff_head temp; 878 struct sk_buff_head *lobby = &ulpq->lobby; 879 __u16 csid, cssn; 880 881 stream = &ulpq->asoc->stream; 882 883 /* We are holding the chunks by stream, by SSN. */ 884 skb_queue_head_init(&temp); 885 event = NULL; 886 sctp_skb_for_each(pos, lobby, tmp) { 887 cevent = (struct sctp_ulpevent *) pos->cb; 888 csid = cevent->stream; 889 cssn = cevent->ssn; 890 891 /* Have we gone too far? */ 892 if (csid > sid) 893 break; 894 895 /* Have we not gone far enough? */ 896 if (csid < sid) 897 continue; 898 899 /* see if this ssn has been marked by skipping */ 900 if (!SSN_lt(cssn, sctp_ssn_peek(stream, in, csid))) 901 break; 902 903 __skb_unlink(pos, lobby); 904 if (!event) 905 /* Create a temporary list to collect chunks on. */ 906 event = sctp_skb2event(pos); 907 908 /* Attach all gathered skbs to the event. */ 909 __skb_queue_tail(&temp, pos); 910 } 911 912 /* If we didn't reap any data, see if the next expected SSN 913 * is next on the queue and if so, use that. 914 */ 915 if (event == NULL && pos != (struct sk_buff *)lobby) { 916 cevent = (struct sctp_ulpevent *) pos->cb; 917 csid = cevent->stream; 918 cssn = cevent->ssn; 919 920 if (csid == sid && cssn == sctp_ssn_peek(stream, in, csid)) { 921 sctp_ssn_next(stream, in, csid); 922 __skb_unlink(pos, lobby); 923 __skb_queue_tail(&temp, pos); 924 event = sctp_skb2event(pos); 925 } 926 } 927 928 /* Send event to the ULP. 'event' is the sctp_ulpevent for 929 * very first SKB on the 'temp' list. 930 */ 931 if (event) { 932 /* see if we have more ordered that we can deliver */ 933 sctp_ulpq_retrieve_ordered(ulpq, event); 934 sctp_ulpq_tail_event(ulpq, &temp); 935 } 936 } 937 938 /* Skip over an SSN. This is used during the processing of 939 * Forwared TSN chunk to skip over the abandoned ordered data 940 */ 941 void sctp_ulpq_skip(struct sctp_ulpq *ulpq, __u16 sid, __u16 ssn) 942 { 943 struct sctp_stream *stream; 944 945 /* Note: The stream ID must be verified before this routine. */ 946 stream = &ulpq->asoc->stream; 947 948 /* Is this an old SSN? If so ignore. */ 949 if (SSN_lt(ssn, sctp_ssn_peek(stream, in, sid))) 950 return; 951 952 /* Mark that we are no longer expecting this SSN or lower. */ 953 sctp_ssn_skip(stream, in, sid, ssn); 954 955 /* Go find any other chunks that were waiting for 956 * ordering and deliver them if needed. 957 */ 958 sctp_ulpq_reap_ordered(ulpq, sid); 959 } 960 961 __u16 sctp_ulpq_renege_list(struct sctp_ulpq *ulpq, struct sk_buff_head *list, 962 __u16 needed) 963 { 964 __u16 freed = 0; 965 __u32 tsn, last_tsn; 966 struct sk_buff *skb, *flist, *last; 967 struct sctp_ulpevent *event; 968 struct sctp_tsnmap *tsnmap; 969 970 tsnmap = &ulpq->asoc->peer.tsn_map; 971 972 while ((skb = skb_peek_tail(list)) != NULL) { 973 event = sctp_skb2event(skb); 974 tsn = event->tsn; 975 976 /* Don't renege below the Cumulative TSN ACK Point. */ 977 if (TSN_lte(tsn, sctp_tsnmap_get_ctsn(tsnmap))) 978 break; 979 980 /* Events in ordering queue may have multiple fragments 981 * corresponding to additional TSNs. Sum the total 982 * freed space; find the last TSN. 983 */ 984 freed += skb_headlen(skb); 985 flist = skb_shinfo(skb)->frag_list; 986 for (last = flist; flist; flist = flist->next) { 987 last = flist; 988 freed += skb_headlen(last); 989 } 990 if (last) 991 last_tsn = sctp_skb2event(last)->tsn; 992 else 993 last_tsn = tsn; 994 995 /* Unlink the event, then renege all applicable TSNs. */ 996 __skb_unlink(skb, list); 997 sctp_ulpevent_free(event); 998 while (TSN_lte(tsn, last_tsn)) { 999 sctp_tsnmap_renege(tsnmap, tsn); 1000 tsn++; 1001 } 1002 if (freed >= needed) 1003 return freed; 1004 } 1005 1006 return freed; 1007 } 1008 1009 /* Renege 'needed' bytes from the ordering queue. */ 1010 static __u16 sctp_ulpq_renege_order(struct sctp_ulpq *ulpq, __u16 needed) 1011 { 1012 return sctp_ulpq_renege_list(ulpq, &ulpq->lobby, needed); 1013 } 1014 1015 /* Renege 'needed' bytes from the reassembly queue. */ 1016 static __u16 sctp_ulpq_renege_frags(struct sctp_ulpq *ulpq, __u16 needed) 1017 { 1018 return sctp_ulpq_renege_list(ulpq, &ulpq->reasm, needed); 1019 } 1020 1021 /* Partial deliver the first message as there is pressure on rwnd. */ 1022 void sctp_ulpq_partial_delivery(struct sctp_ulpq *ulpq, 1023 gfp_t gfp) 1024 { 1025 struct sctp_ulpevent *event; 1026 struct sctp_association *asoc; 1027 struct sctp_sock *sp; 1028 __u32 ctsn; 1029 struct sk_buff *skb; 1030 1031 asoc = ulpq->asoc; 1032 sp = sctp_sk(asoc->base.sk); 1033 1034 /* If the association is already in Partial Delivery mode 1035 * we have nothing to do. 1036 */ 1037 if (ulpq->pd_mode) 1038 return; 1039 1040 /* Data must be at or below the Cumulative TSN ACK Point to 1041 * start partial delivery. 1042 */ 1043 skb = skb_peek(&asoc->ulpq.reasm); 1044 if (skb != NULL) { 1045 ctsn = sctp_skb2event(skb)->tsn; 1046 if (!TSN_lte(ctsn, sctp_tsnmap_get_ctsn(&asoc->peer.tsn_map))) 1047 return; 1048 } 1049 1050 /* If the user enabled fragment interleave socket option, 1051 * multiple associations can enter partial delivery. 1052 * Otherwise, we can only enter partial delivery if the 1053 * socket is not in partial deliver mode. 1054 */ 1055 if (sp->frag_interleave || atomic_read(&sp->pd_mode) == 0) { 1056 /* Is partial delivery possible? */ 1057 event = sctp_ulpq_retrieve_first(ulpq); 1058 /* Send event to the ULP. */ 1059 if (event) { 1060 struct sk_buff_head temp; 1061 1062 skb_queue_head_init(&temp); 1063 __skb_queue_tail(&temp, sctp_event2skb(event)); 1064 sctp_ulpq_tail_event(ulpq, &temp); 1065 sctp_ulpq_set_pd(ulpq); 1066 return; 1067 } 1068 } 1069 } 1070 1071 /* Renege some packets to make room for an incoming chunk. */ 1072 void sctp_ulpq_renege(struct sctp_ulpq *ulpq, struct sctp_chunk *chunk, 1073 gfp_t gfp) 1074 { 1075 struct sctp_association *asoc = ulpq->asoc; 1076 __u32 freed = 0; 1077 __u16 needed; 1078 1079 needed = ntohs(chunk->chunk_hdr->length) - 1080 sizeof(struct sctp_data_chunk); 1081 1082 if (skb_queue_empty(&asoc->base.sk->sk_receive_queue)) { 1083 freed = sctp_ulpq_renege_order(ulpq, needed); 1084 if (freed < needed) 1085 freed += sctp_ulpq_renege_frags(ulpq, needed - freed); 1086 } 1087 /* If able to free enough room, accept this chunk. */ 1088 if (sk_rmem_schedule(asoc->base.sk, chunk->skb, needed) && 1089 freed >= needed) { 1090 int retval = sctp_ulpq_tail_data(ulpq, chunk, gfp); 1091 /* 1092 * Enter partial delivery if chunk has not been 1093 * delivered; otherwise, drain the reassembly queue. 1094 */ 1095 if (retval <= 0) 1096 sctp_ulpq_partial_delivery(ulpq, gfp); 1097 else if (retval == 1) 1098 sctp_ulpq_reasm_drain(ulpq); 1099 } 1100 } 1101 1102 /* Notify the application if an association is aborted and in 1103 * partial delivery mode. Send up any pending received messages. 1104 */ 1105 void sctp_ulpq_abort_pd(struct sctp_ulpq *ulpq, gfp_t gfp) 1106 { 1107 struct sctp_ulpevent *ev = NULL; 1108 struct sctp_sock *sp; 1109 struct sock *sk; 1110 1111 if (!ulpq->pd_mode) 1112 return; 1113 1114 sk = ulpq->asoc->base.sk; 1115 sp = sctp_sk(sk); 1116 if (sctp_ulpevent_type_enabled(ulpq->asoc->subscribe, 1117 SCTP_PARTIAL_DELIVERY_EVENT)) 1118 ev = sctp_ulpevent_make_pdapi(ulpq->asoc, 1119 SCTP_PARTIAL_DELIVERY_ABORTED, 1120 0, 0, 0, gfp); 1121 if (ev) 1122 __skb_queue_tail(&sk->sk_receive_queue, sctp_event2skb(ev)); 1123 1124 /* If there is data waiting, send it up the socket now. */ 1125 if ((sctp_ulpq_clear_pd(ulpq) || ev) && !sp->data_ready_signalled) { 1126 sp->data_ready_signalled = 1; 1127 sk->sk_data_ready(sk); 1128 } 1129 } 1130