1 /* SCTP kernel implementation 2 * (C) Copyright Red Hat Inc. 2017 3 * 4 * This file is part of the SCTP kernel implementation 5 * 6 * These functions manipulate sctp stream queue/scheduling. 7 * 8 * This SCTP implementation is free software; 9 * you can redistribute it and/or modify it under the terms of 10 * the GNU General Public License as published by 11 * the Free Software Foundation; either version 2, or (at your option) 12 * any later version. 13 * 14 * This SCTP implementation is distributed in the hope that it 15 * will be useful, but WITHOUT ANY WARRANTY; without even the implied 16 * ************************ 17 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 18 * See the GNU General Public License for more details. 19 * 20 * You should have received a copy of the GNU General Public License 21 * along with GNU CC; see the file COPYING. If not, see 22 * <http://www.gnu.org/licenses/>. 23 * 24 * Please send any bug reports or fixes you make to the 25 * email addresched(es): 26 * lksctp developers <linux-sctp@vger.kernel.org> 27 * 28 * Written or modified by: 29 * Xin Long <lucien.xin@gmail.com> 30 */ 31 32 #include <net/busy_poll.h> 33 #include <net/sctp/sctp.h> 34 #include <net/sctp/sm.h> 35 #include <net/sctp/ulpevent.h> 36 #include <linux/sctp.h> 37 38 static struct sctp_chunk *sctp_make_idatafrag_empty( 39 const struct sctp_association *asoc, 40 const struct sctp_sndrcvinfo *sinfo, 41 int len, __u8 flags, gfp_t gfp) 42 { 43 struct sctp_chunk *retval; 44 struct sctp_idatahdr dp; 45 46 memset(&dp, 0, sizeof(dp)); 47 dp.stream = htons(sinfo->sinfo_stream); 48 49 if (sinfo->sinfo_flags & SCTP_UNORDERED) 50 flags |= SCTP_DATA_UNORDERED; 51 52 retval = sctp_make_idata(asoc, flags, sizeof(dp) + len, gfp); 53 if (!retval) 54 return NULL; 55 56 retval->subh.idata_hdr = sctp_addto_chunk(retval, sizeof(dp), &dp); 57 memcpy(&retval->sinfo, sinfo, sizeof(struct sctp_sndrcvinfo)); 58 59 return retval; 60 } 61 62 static void sctp_chunk_assign_mid(struct sctp_chunk *chunk) 63 { 64 struct sctp_stream *stream; 65 struct sctp_chunk *lchunk; 66 __u32 cfsn = 0; 67 __u16 sid; 68 69 if (chunk->has_mid) 70 return; 71 72 sid = sctp_chunk_stream_no(chunk); 73 stream = &chunk->asoc->stream; 74 75 list_for_each_entry(lchunk, &chunk->msg->chunks, frag_list) { 76 struct sctp_idatahdr *hdr; 77 __u32 mid; 78 79 lchunk->has_mid = 1; 80 81 hdr = lchunk->subh.idata_hdr; 82 83 if (lchunk->chunk_hdr->flags & SCTP_DATA_FIRST_FRAG) 84 hdr->ppid = lchunk->sinfo.sinfo_ppid; 85 else 86 hdr->fsn = htonl(cfsn++); 87 88 if (lchunk->chunk_hdr->flags & SCTP_DATA_UNORDERED) { 89 mid = lchunk->chunk_hdr->flags & SCTP_DATA_LAST_FRAG ? 90 sctp_mid_uo_next(stream, out, sid) : 91 sctp_mid_uo_peek(stream, out, sid); 92 } else { 93 mid = lchunk->chunk_hdr->flags & SCTP_DATA_LAST_FRAG ? 94 sctp_mid_next(stream, out, sid) : 95 sctp_mid_peek(stream, out, sid); 96 } 97 hdr->mid = htonl(mid); 98 } 99 } 100 101 static bool sctp_validate_data(struct sctp_chunk *chunk) 102 { 103 const struct sctp_stream *stream; 104 __u16 sid, ssn; 105 106 if (chunk->chunk_hdr->type != SCTP_CID_DATA) 107 return false; 108 109 if (chunk->chunk_hdr->flags & SCTP_DATA_UNORDERED) 110 return true; 111 112 stream = &chunk->asoc->stream; 113 sid = sctp_chunk_stream_no(chunk); 114 ssn = ntohs(chunk->subh.data_hdr->ssn); 115 116 return !SSN_lt(ssn, sctp_ssn_peek(stream, in, sid)); 117 } 118 119 static bool sctp_validate_idata(struct sctp_chunk *chunk) 120 { 121 struct sctp_stream *stream; 122 __u32 mid; 123 __u16 sid; 124 125 if (chunk->chunk_hdr->type != SCTP_CID_I_DATA) 126 return false; 127 128 if (chunk->chunk_hdr->flags & SCTP_DATA_UNORDERED) 129 return true; 130 131 stream = &chunk->asoc->stream; 132 sid = sctp_chunk_stream_no(chunk); 133 mid = ntohl(chunk->subh.idata_hdr->mid); 134 135 return !MID_lt(mid, sctp_mid_peek(stream, in, sid)); 136 } 137 138 static void sctp_intl_store_reasm(struct sctp_ulpq *ulpq, 139 struct sctp_ulpevent *event) 140 { 141 struct sctp_ulpevent *cevent; 142 struct sk_buff *pos; 143 144 pos = skb_peek_tail(&ulpq->reasm); 145 if (!pos) { 146 __skb_queue_tail(&ulpq->reasm, sctp_event2skb(event)); 147 return; 148 } 149 150 cevent = sctp_skb2event(pos); 151 152 if (event->stream == cevent->stream && 153 event->mid == cevent->mid && 154 (cevent->msg_flags & SCTP_DATA_FIRST_FRAG || 155 (!(event->msg_flags & SCTP_DATA_FIRST_FRAG) && 156 event->fsn > cevent->fsn))) { 157 __skb_queue_tail(&ulpq->reasm, sctp_event2skb(event)); 158 return; 159 } 160 161 if ((event->stream == cevent->stream && 162 MID_lt(cevent->mid, event->mid)) || 163 event->stream > cevent->stream) { 164 __skb_queue_tail(&ulpq->reasm, sctp_event2skb(event)); 165 return; 166 } 167 168 skb_queue_walk(&ulpq->reasm, pos) { 169 cevent = sctp_skb2event(pos); 170 171 if (event->stream < cevent->stream || 172 (event->stream == cevent->stream && 173 MID_lt(event->mid, cevent->mid))) 174 break; 175 176 if (event->stream == cevent->stream && 177 event->mid == cevent->mid && 178 !(cevent->msg_flags & SCTP_DATA_FIRST_FRAG) && 179 (event->msg_flags & SCTP_DATA_FIRST_FRAG || 180 event->fsn < cevent->fsn)) 181 break; 182 } 183 184 __skb_queue_before(&ulpq->reasm, pos, sctp_event2skb(event)); 185 } 186 187 static struct sctp_ulpevent *sctp_intl_retrieve_partial( 188 struct sctp_ulpq *ulpq, 189 struct sctp_ulpevent *event) 190 { 191 struct sk_buff *first_frag = NULL; 192 struct sk_buff *last_frag = NULL; 193 struct sctp_ulpevent *retval; 194 struct sctp_stream_in *sin; 195 struct sk_buff *pos; 196 __u32 next_fsn = 0; 197 int is_last = 0; 198 199 sin = sctp_stream_in(ulpq->asoc, event->stream); 200 201 skb_queue_walk(&ulpq->reasm, pos) { 202 struct sctp_ulpevent *cevent = sctp_skb2event(pos); 203 204 if (cevent->stream < event->stream) 205 continue; 206 207 if (cevent->stream > event->stream || 208 cevent->mid != sin->mid) 209 break; 210 211 switch (cevent->msg_flags & SCTP_DATA_FRAG_MASK) { 212 case SCTP_DATA_FIRST_FRAG: 213 goto out; 214 case SCTP_DATA_MIDDLE_FRAG: 215 if (!first_frag) { 216 if (cevent->fsn == sin->fsn) { 217 first_frag = pos; 218 last_frag = pos; 219 next_fsn = cevent->fsn + 1; 220 } 221 } else if (cevent->fsn == next_fsn) { 222 last_frag = pos; 223 next_fsn++; 224 } else { 225 goto out; 226 } 227 break; 228 case SCTP_DATA_LAST_FRAG: 229 if (!first_frag) { 230 if (cevent->fsn == sin->fsn) { 231 first_frag = pos; 232 last_frag = pos; 233 next_fsn = 0; 234 is_last = 1; 235 } 236 } else if (cevent->fsn == next_fsn) { 237 last_frag = pos; 238 next_fsn = 0; 239 is_last = 1; 240 } 241 goto out; 242 default: 243 goto out; 244 } 245 } 246 247 out: 248 if (!first_frag) 249 return NULL; 250 251 retval = sctp_make_reassembled_event(sock_net(ulpq->asoc->base.sk), 252 &ulpq->reasm, first_frag, 253 last_frag); 254 if (retval) { 255 sin->fsn = next_fsn; 256 if (is_last) { 257 retval->msg_flags |= MSG_EOR; 258 sin->pd_mode = 0; 259 } 260 } 261 262 return retval; 263 } 264 265 static struct sctp_ulpevent *sctp_intl_retrieve_reassembled( 266 struct sctp_ulpq *ulpq, 267 struct sctp_ulpevent *event) 268 { 269 struct sctp_association *asoc = ulpq->asoc; 270 struct sk_buff *pos, *first_frag = NULL; 271 struct sctp_ulpevent *retval = NULL; 272 struct sk_buff *pd_first = NULL; 273 struct sk_buff *pd_last = NULL; 274 struct sctp_stream_in *sin; 275 __u32 next_fsn = 0; 276 __u32 pd_point = 0; 277 __u32 pd_len = 0; 278 __u32 mid = 0; 279 280 sin = sctp_stream_in(ulpq->asoc, event->stream); 281 282 skb_queue_walk(&ulpq->reasm, pos) { 283 struct sctp_ulpevent *cevent = sctp_skb2event(pos); 284 285 if (cevent->stream < event->stream) 286 continue; 287 if (cevent->stream > event->stream) 288 break; 289 290 if (MID_lt(cevent->mid, event->mid)) 291 continue; 292 if (MID_lt(event->mid, cevent->mid)) 293 break; 294 295 switch (cevent->msg_flags & SCTP_DATA_FRAG_MASK) { 296 case SCTP_DATA_FIRST_FRAG: 297 if (cevent->mid == sin->mid) { 298 pd_first = pos; 299 pd_last = pos; 300 pd_len = pos->len; 301 } 302 303 first_frag = pos; 304 next_fsn = 0; 305 mid = cevent->mid; 306 break; 307 308 case SCTP_DATA_MIDDLE_FRAG: 309 if (first_frag && cevent->mid == mid && 310 cevent->fsn == next_fsn) { 311 next_fsn++; 312 if (pd_first) { 313 pd_last = pos; 314 pd_len += pos->len; 315 } 316 } else { 317 first_frag = NULL; 318 } 319 break; 320 321 case SCTP_DATA_LAST_FRAG: 322 if (first_frag && cevent->mid == mid && 323 cevent->fsn == next_fsn) 324 goto found; 325 else 326 first_frag = NULL; 327 break; 328 } 329 } 330 331 if (!pd_first) 332 goto out; 333 334 pd_point = sctp_sk(asoc->base.sk)->pd_point; 335 if (pd_point && pd_point <= pd_len) { 336 retval = sctp_make_reassembled_event(sock_net(asoc->base.sk), 337 &ulpq->reasm, 338 pd_first, pd_last); 339 if (retval) { 340 sin->fsn = next_fsn; 341 sin->pd_mode = 1; 342 } 343 } 344 goto out; 345 346 found: 347 retval = sctp_make_reassembled_event(sock_net(asoc->base.sk), 348 &ulpq->reasm, 349 first_frag, pos); 350 if (retval) 351 retval->msg_flags |= MSG_EOR; 352 353 out: 354 return retval; 355 } 356 357 static struct sctp_ulpevent *sctp_intl_reasm(struct sctp_ulpq *ulpq, 358 struct sctp_ulpevent *event) 359 { 360 struct sctp_ulpevent *retval = NULL; 361 struct sctp_stream_in *sin; 362 363 if (SCTP_DATA_NOT_FRAG == (event->msg_flags & SCTP_DATA_FRAG_MASK)) { 364 event->msg_flags |= MSG_EOR; 365 return event; 366 } 367 368 sctp_intl_store_reasm(ulpq, event); 369 370 sin = sctp_stream_in(ulpq->asoc, event->stream); 371 if (sin->pd_mode && event->mid == sin->mid && 372 event->fsn == sin->fsn) 373 retval = sctp_intl_retrieve_partial(ulpq, event); 374 375 if (!retval) 376 retval = sctp_intl_retrieve_reassembled(ulpq, event); 377 378 return retval; 379 } 380 381 static void sctp_intl_store_ordered(struct sctp_ulpq *ulpq, 382 struct sctp_ulpevent *event) 383 { 384 struct sctp_ulpevent *cevent; 385 struct sk_buff *pos; 386 387 pos = skb_peek_tail(&ulpq->lobby); 388 if (!pos) { 389 __skb_queue_tail(&ulpq->lobby, sctp_event2skb(event)); 390 return; 391 } 392 393 cevent = (struct sctp_ulpevent *)pos->cb; 394 if (event->stream == cevent->stream && 395 MID_lt(cevent->mid, event->mid)) { 396 __skb_queue_tail(&ulpq->lobby, sctp_event2skb(event)); 397 return; 398 } 399 400 if (event->stream > cevent->stream) { 401 __skb_queue_tail(&ulpq->lobby, sctp_event2skb(event)); 402 return; 403 } 404 405 skb_queue_walk(&ulpq->lobby, pos) { 406 cevent = (struct sctp_ulpevent *)pos->cb; 407 408 if (cevent->stream > event->stream) 409 break; 410 411 if (cevent->stream == event->stream && 412 MID_lt(event->mid, cevent->mid)) 413 break; 414 } 415 416 __skb_queue_before(&ulpq->lobby, pos, sctp_event2skb(event)); 417 } 418 419 static void sctp_intl_retrieve_ordered(struct sctp_ulpq *ulpq, 420 struct sctp_ulpevent *event) 421 { 422 struct sk_buff_head *event_list; 423 struct sctp_stream *stream; 424 struct sk_buff *pos, *tmp; 425 __u16 sid = event->stream; 426 427 stream = &ulpq->asoc->stream; 428 event_list = (struct sk_buff_head *)sctp_event2skb(event)->prev; 429 430 sctp_skb_for_each(pos, &ulpq->lobby, tmp) { 431 struct sctp_ulpevent *cevent = (struct sctp_ulpevent *)pos->cb; 432 433 if (cevent->stream > sid) 434 break; 435 436 if (cevent->stream < sid) 437 continue; 438 439 if (cevent->mid != sctp_mid_peek(stream, in, sid)) 440 break; 441 442 sctp_mid_next(stream, in, sid); 443 444 __skb_unlink(pos, &ulpq->lobby); 445 446 __skb_queue_tail(event_list, pos); 447 } 448 } 449 450 static struct sctp_ulpevent *sctp_intl_order(struct sctp_ulpq *ulpq, 451 struct sctp_ulpevent *event) 452 { 453 struct sctp_stream *stream; 454 __u16 sid; 455 456 stream = &ulpq->asoc->stream; 457 sid = event->stream; 458 459 if (event->mid != sctp_mid_peek(stream, in, sid)) { 460 sctp_intl_store_ordered(ulpq, event); 461 return NULL; 462 } 463 464 sctp_mid_next(stream, in, sid); 465 466 sctp_intl_retrieve_ordered(ulpq, event); 467 468 return event; 469 } 470 471 static int sctp_enqueue_event(struct sctp_ulpq *ulpq, 472 struct sctp_ulpevent *event) 473 { 474 struct sk_buff *skb = sctp_event2skb(event); 475 struct sock *sk = ulpq->asoc->base.sk; 476 struct sctp_sock *sp = sctp_sk(sk); 477 struct sk_buff_head *skb_list; 478 479 skb_list = (struct sk_buff_head *)skb->prev; 480 481 if (sk->sk_shutdown & RCV_SHUTDOWN && 482 (sk->sk_shutdown & SEND_SHUTDOWN || 483 !sctp_ulpevent_is_notification(event))) 484 goto out_free; 485 486 if (!sctp_ulpevent_is_notification(event)) { 487 sk_mark_napi_id(sk, skb); 488 sk_incoming_cpu_update(sk); 489 } 490 491 if (!sctp_ulpevent_is_enabled(event, &sp->subscribe)) 492 goto out_free; 493 494 if (skb_list) 495 skb_queue_splice_tail_init(skb_list, 496 &sk->sk_receive_queue); 497 else 498 __skb_queue_tail(&sk->sk_receive_queue, skb); 499 500 if (!sp->data_ready_signalled) { 501 sp->data_ready_signalled = 1; 502 sk->sk_data_ready(sk); 503 } 504 505 return 1; 506 507 out_free: 508 if (skb_list) 509 sctp_queue_purge_ulpevents(skb_list); 510 else 511 sctp_ulpevent_free(event); 512 513 return 0; 514 } 515 516 static void sctp_intl_store_reasm_uo(struct sctp_ulpq *ulpq, 517 struct sctp_ulpevent *event) 518 { 519 struct sctp_ulpevent *cevent; 520 struct sk_buff *pos; 521 522 pos = skb_peek_tail(&ulpq->reasm_uo); 523 if (!pos) { 524 __skb_queue_tail(&ulpq->reasm_uo, sctp_event2skb(event)); 525 return; 526 } 527 528 cevent = sctp_skb2event(pos); 529 530 if (event->stream == cevent->stream && 531 event->mid == cevent->mid && 532 (cevent->msg_flags & SCTP_DATA_FIRST_FRAG || 533 (!(event->msg_flags & SCTP_DATA_FIRST_FRAG) && 534 event->fsn > cevent->fsn))) { 535 __skb_queue_tail(&ulpq->reasm_uo, sctp_event2skb(event)); 536 return; 537 } 538 539 if ((event->stream == cevent->stream && 540 MID_lt(cevent->mid, event->mid)) || 541 event->stream > cevent->stream) { 542 __skb_queue_tail(&ulpq->reasm_uo, sctp_event2skb(event)); 543 return; 544 } 545 546 skb_queue_walk(&ulpq->reasm_uo, pos) { 547 cevent = sctp_skb2event(pos); 548 549 if (event->stream < cevent->stream || 550 (event->stream == cevent->stream && 551 MID_lt(event->mid, cevent->mid))) 552 break; 553 554 if (event->stream == cevent->stream && 555 event->mid == cevent->mid && 556 !(cevent->msg_flags & SCTP_DATA_FIRST_FRAG) && 557 (event->msg_flags & SCTP_DATA_FIRST_FRAG || 558 event->fsn < cevent->fsn)) 559 break; 560 } 561 562 __skb_queue_before(&ulpq->reasm_uo, pos, sctp_event2skb(event)); 563 } 564 565 static struct sctp_ulpevent *sctp_intl_retrieve_partial_uo( 566 struct sctp_ulpq *ulpq, 567 struct sctp_ulpevent *event) 568 { 569 struct sk_buff *first_frag = NULL; 570 struct sk_buff *last_frag = NULL; 571 struct sctp_ulpevent *retval; 572 struct sctp_stream_in *sin; 573 struct sk_buff *pos; 574 __u32 next_fsn = 0; 575 int is_last = 0; 576 577 sin = sctp_stream_in(ulpq->asoc, event->stream); 578 579 skb_queue_walk(&ulpq->reasm_uo, pos) { 580 struct sctp_ulpevent *cevent = sctp_skb2event(pos); 581 582 if (cevent->stream < event->stream) 583 continue; 584 if (cevent->stream > event->stream) 585 break; 586 587 if (MID_lt(cevent->mid, sin->mid_uo)) 588 continue; 589 if (MID_lt(sin->mid_uo, cevent->mid)) 590 break; 591 592 switch (cevent->msg_flags & SCTP_DATA_FRAG_MASK) { 593 case SCTP_DATA_FIRST_FRAG: 594 goto out; 595 case SCTP_DATA_MIDDLE_FRAG: 596 if (!first_frag) { 597 if (cevent->fsn == sin->fsn_uo) { 598 first_frag = pos; 599 last_frag = pos; 600 next_fsn = cevent->fsn + 1; 601 } 602 } else if (cevent->fsn == next_fsn) { 603 last_frag = pos; 604 next_fsn++; 605 } else { 606 goto out; 607 } 608 break; 609 case SCTP_DATA_LAST_FRAG: 610 if (!first_frag) { 611 if (cevent->fsn == sin->fsn_uo) { 612 first_frag = pos; 613 last_frag = pos; 614 next_fsn = 0; 615 is_last = 1; 616 } 617 } else if (cevent->fsn == next_fsn) { 618 last_frag = pos; 619 next_fsn = 0; 620 is_last = 1; 621 } 622 goto out; 623 default: 624 goto out; 625 } 626 } 627 628 out: 629 if (!first_frag) 630 return NULL; 631 632 retval = sctp_make_reassembled_event(sock_net(ulpq->asoc->base.sk), 633 &ulpq->reasm_uo, first_frag, 634 last_frag); 635 if (retval) { 636 sin->fsn_uo = next_fsn; 637 if (is_last) { 638 retval->msg_flags |= MSG_EOR; 639 sin->pd_mode_uo = 0; 640 } 641 } 642 643 return retval; 644 } 645 646 static struct sctp_ulpevent *sctp_intl_retrieve_reassembled_uo( 647 struct sctp_ulpq *ulpq, 648 struct sctp_ulpevent *event) 649 { 650 struct sctp_association *asoc = ulpq->asoc; 651 struct sk_buff *pos, *first_frag = NULL; 652 struct sctp_ulpevent *retval = NULL; 653 struct sk_buff *pd_first = NULL; 654 struct sk_buff *pd_last = NULL; 655 struct sctp_stream_in *sin; 656 __u32 next_fsn = 0; 657 __u32 pd_point = 0; 658 __u32 pd_len = 0; 659 __u32 mid = 0; 660 661 sin = sctp_stream_in(ulpq->asoc, event->stream); 662 663 skb_queue_walk(&ulpq->reasm_uo, pos) { 664 struct sctp_ulpevent *cevent = sctp_skb2event(pos); 665 666 if (cevent->stream < event->stream) 667 continue; 668 if (cevent->stream > event->stream) 669 break; 670 671 if (MID_lt(cevent->mid, event->mid)) 672 continue; 673 if (MID_lt(event->mid, cevent->mid)) 674 break; 675 676 switch (cevent->msg_flags & SCTP_DATA_FRAG_MASK) { 677 case SCTP_DATA_FIRST_FRAG: 678 if (!sin->pd_mode_uo) { 679 sin->mid_uo = cevent->mid; 680 pd_first = pos; 681 pd_last = pos; 682 pd_len = pos->len; 683 } 684 685 first_frag = pos; 686 next_fsn = 0; 687 mid = cevent->mid; 688 break; 689 690 case SCTP_DATA_MIDDLE_FRAG: 691 if (first_frag && cevent->mid == mid && 692 cevent->fsn == next_fsn) { 693 next_fsn++; 694 if (pd_first) { 695 pd_last = pos; 696 pd_len += pos->len; 697 } 698 } else { 699 first_frag = NULL; 700 } 701 break; 702 703 case SCTP_DATA_LAST_FRAG: 704 if (first_frag && cevent->mid == mid && 705 cevent->fsn == next_fsn) 706 goto found; 707 else 708 first_frag = NULL; 709 break; 710 } 711 } 712 713 if (!pd_first) 714 goto out; 715 716 pd_point = sctp_sk(asoc->base.sk)->pd_point; 717 if (pd_point && pd_point <= pd_len) { 718 retval = sctp_make_reassembled_event(sock_net(asoc->base.sk), 719 &ulpq->reasm_uo, 720 pd_first, pd_last); 721 if (retval) { 722 sin->fsn_uo = next_fsn; 723 sin->pd_mode_uo = 1; 724 } 725 } 726 goto out; 727 728 found: 729 retval = sctp_make_reassembled_event(sock_net(asoc->base.sk), 730 &ulpq->reasm_uo, 731 first_frag, pos); 732 if (retval) 733 retval->msg_flags |= MSG_EOR; 734 735 out: 736 return retval; 737 } 738 739 static struct sctp_ulpevent *sctp_intl_reasm_uo(struct sctp_ulpq *ulpq, 740 struct sctp_ulpevent *event) 741 { 742 struct sctp_ulpevent *retval = NULL; 743 struct sctp_stream_in *sin; 744 745 if (SCTP_DATA_NOT_FRAG == (event->msg_flags & SCTP_DATA_FRAG_MASK)) { 746 event->msg_flags |= MSG_EOR; 747 return event; 748 } 749 750 sctp_intl_store_reasm_uo(ulpq, event); 751 752 sin = sctp_stream_in(ulpq->asoc, event->stream); 753 if (sin->pd_mode_uo && event->mid == sin->mid_uo && 754 event->fsn == sin->fsn_uo) 755 retval = sctp_intl_retrieve_partial_uo(ulpq, event); 756 757 if (!retval) 758 retval = sctp_intl_retrieve_reassembled_uo(ulpq, event); 759 760 return retval; 761 } 762 763 static struct sctp_ulpevent *sctp_intl_retrieve_first_uo(struct sctp_ulpq *ulpq) 764 { 765 struct sctp_stream_in *csin, *sin = NULL; 766 struct sk_buff *first_frag = NULL; 767 struct sk_buff *last_frag = NULL; 768 struct sctp_ulpevent *retval; 769 struct sk_buff *pos; 770 __u32 next_fsn = 0; 771 __u16 sid = 0; 772 773 skb_queue_walk(&ulpq->reasm_uo, pos) { 774 struct sctp_ulpevent *cevent = sctp_skb2event(pos); 775 776 csin = sctp_stream_in(ulpq->asoc, cevent->stream); 777 if (csin->pd_mode_uo) 778 continue; 779 780 switch (cevent->msg_flags & SCTP_DATA_FRAG_MASK) { 781 case SCTP_DATA_FIRST_FRAG: 782 if (first_frag) 783 goto out; 784 first_frag = pos; 785 last_frag = pos; 786 next_fsn = 0; 787 sin = csin; 788 sid = cevent->stream; 789 sin->mid_uo = cevent->mid; 790 break; 791 case SCTP_DATA_MIDDLE_FRAG: 792 if (!first_frag) 793 break; 794 if (cevent->stream == sid && 795 cevent->mid == sin->mid_uo && 796 cevent->fsn == next_fsn) { 797 next_fsn++; 798 last_frag = pos; 799 } else { 800 goto out; 801 } 802 break; 803 case SCTP_DATA_LAST_FRAG: 804 if (first_frag) 805 goto out; 806 break; 807 default: 808 break; 809 } 810 } 811 812 if (!first_frag) 813 return NULL; 814 815 out: 816 retval = sctp_make_reassembled_event(sock_net(ulpq->asoc->base.sk), 817 &ulpq->reasm_uo, first_frag, 818 last_frag); 819 if (retval) { 820 sin->fsn_uo = next_fsn; 821 sin->pd_mode_uo = 1; 822 } 823 824 return retval; 825 } 826 827 static int sctp_ulpevent_idata(struct sctp_ulpq *ulpq, 828 struct sctp_chunk *chunk, gfp_t gfp) 829 { 830 struct sctp_ulpevent *event; 831 struct sk_buff_head temp; 832 int event_eor = 0; 833 834 event = sctp_ulpevent_make_rcvmsg(chunk->asoc, chunk, gfp); 835 if (!event) 836 return -ENOMEM; 837 838 event->mid = ntohl(chunk->subh.idata_hdr->mid); 839 if (event->msg_flags & SCTP_DATA_FIRST_FRAG) 840 event->ppid = chunk->subh.idata_hdr->ppid; 841 else 842 event->fsn = ntohl(chunk->subh.idata_hdr->fsn); 843 844 if (!(event->msg_flags & SCTP_DATA_UNORDERED)) { 845 event = sctp_intl_reasm(ulpq, event); 846 if (event && event->msg_flags & MSG_EOR) { 847 skb_queue_head_init(&temp); 848 __skb_queue_tail(&temp, sctp_event2skb(event)); 849 850 event = sctp_intl_order(ulpq, event); 851 } 852 } else { 853 event = sctp_intl_reasm_uo(ulpq, event); 854 } 855 856 if (event) { 857 event_eor = (event->msg_flags & MSG_EOR) ? 1 : 0; 858 sctp_enqueue_event(ulpq, event); 859 } 860 861 return event_eor; 862 } 863 864 static struct sctp_ulpevent *sctp_intl_retrieve_first(struct sctp_ulpq *ulpq) 865 { 866 struct sctp_stream_in *csin, *sin = NULL; 867 struct sk_buff *first_frag = NULL; 868 struct sk_buff *last_frag = NULL; 869 struct sctp_ulpevent *retval; 870 struct sk_buff *pos; 871 __u32 next_fsn = 0; 872 __u16 sid = 0; 873 874 skb_queue_walk(&ulpq->reasm, pos) { 875 struct sctp_ulpevent *cevent = sctp_skb2event(pos); 876 877 csin = sctp_stream_in(ulpq->asoc, cevent->stream); 878 if (csin->pd_mode) 879 continue; 880 881 switch (cevent->msg_flags & SCTP_DATA_FRAG_MASK) { 882 case SCTP_DATA_FIRST_FRAG: 883 if (first_frag) 884 goto out; 885 if (cevent->mid == csin->mid) { 886 first_frag = pos; 887 last_frag = pos; 888 next_fsn = 0; 889 sin = csin; 890 sid = cevent->stream; 891 } 892 break; 893 case SCTP_DATA_MIDDLE_FRAG: 894 if (!first_frag) 895 break; 896 if (cevent->stream == sid && 897 cevent->mid == sin->mid && 898 cevent->fsn == next_fsn) { 899 next_fsn++; 900 last_frag = pos; 901 } else { 902 goto out; 903 } 904 break; 905 case SCTP_DATA_LAST_FRAG: 906 if (first_frag) 907 goto out; 908 break; 909 default: 910 break; 911 } 912 } 913 914 if (!first_frag) 915 return NULL; 916 917 out: 918 retval = sctp_make_reassembled_event(sock_net(ulpq->asoc->base.sk), 919 &ulpq->reasm, first_frag, 920 last_frag); 921 if (retval) { 922 sin->fsn = next_fsn; 923 sin->pd_mode = 1; 924 } 925 926 return retval; 927 } 928 929 static void sctp_intl_start_pd(struct sctp_ulpq *ulpq, gfp_t gfp) 930 { 931 struct sctp_ulpevent *event; 932 933 if (!skb_queue_empty(&ulpq->reasm)) { 934 do { 935 event = sctp_intl_retrieve_first(ulpq); 936 if (event) 937 sctp_enqueue_event(ulpq, event); 938 } while (event); 939 } 940 941 if (!skb_queue_empty(&ulpq->reasm_uo)) { 942 do { 943 event = sctp_intl_retrieve_first_uo(ulpq); 944 if (event) 945 sctp_enqueue_event(ulpq, event); 946 } while (event); 947 } 948 } 949 950 static void sctp_renege_events(struct sctp_ulpq *ulpq, struct sctp_chunk *chunk, 951 gfp_t gfp) 952 { 953 struct sctp_association *asoc = ulpq->asoc; 954 __u32 freed = 0; 955 __u16 needed; 956 957 if (chunk) { 958 needed = ntohs(chunk->chunk_hdr->length); 959 needed -= sizeof(struct sctp_idata_chunk); 960 } else { 961 needed = SCTP_DEFAULT_MAXWINDOW; 962 } 963 964 if (skb_queue_empty(&asoc->base.sk->sk_receive_queue)) { 965 freed = sctp_ulpq_renege_list(ulpq, &ulpq->lobby, needed); 966 if (freed < needed) 967 freed += sctp_ulpq_renege_list(ulpq, &ulpq->reasm, 968 needed); 969 if (freed < needed) 970 freed += sctp_ulpq_renege_list(ulpq, &ulpq->reasm_uo, 971 needed); 972 } 973 974 if (chunk && freed >= needed) 975 if (sctp_ulpevent_idata(ulpq, chunk, gfp) <= 0) 976 sctp_intl_start_pd(ulpq, gfp); 977 978 sk_mem_reclaim(asoc->base.sk); 979 } 980 981 static void sctp_intl_stream_abort_pd(struct sctp_ulpq *ulpq, __u16 sid, 982 __u32 mid, __u16 flags, gfp_t gfp) 983 { 984 struct sock *sk = ulpq->asoc->base.sk; 985 struct sctp_ulpevent *ev = NULL; 986 987 if (!sctp_ulpevent_type_enabled(SCTP_PARTIAL_DELIVERY_EVENT, 988 &sctp_sk(sk)->subscribe)) 989 return; 990 991 ev = sctp_ulpevent_make_pdapi(ulpq->asoc, SCTP_PARTIAL_DELIVERY_ABORTED, 992 sid, mid, flags, gfp); 993 if (ev) { 994 __skb_queue_tail(&sk->sk_receive_queue, sctp_event2skb(ev)); 995 996 if (!sctp_sk(sk)->data_ready_signalled) { 997 sctp_sk(sk)->data_ready_signalled = 1; 998 sk->sk_data_ready(sk); 999 } 1000 } 1001 } 1002 1003 static void sctp_intl_reap_ordered(struct sctp_ulpq *ulpq, __u16 sid) 1004 { 1005 struct sctp_stream *stream = &ulpq->asoc->stream; 1006 struct sctp_ulpevent *cevent, *event = NULL; 1007 struct sk_buff_head *lobby = &ulpq->lobby; 1008 struct sk_buff *pos, *tmp; 1009 struct sk_buff_head temp; 1010 __u16 csid; 1011 __u32 cmid; 1012 1013 skb_queue_head_init(&temp); 1014 sctp_skb_for_each(pos, lobby, tmp) { 1015 cevent = (struct sctp_ulpevent *)pos->cb; 1016 csid = cevent->stream; 1017 cmid = cevent->mid; 1018 1019 if (csid > sid) 1020 break; 1021 1022 if (csid < sid) 1023 continue; 1024 1025 if (!MID_lt(cmid, sctp_mid_peek(stream, in, csid))) 1026 break; 1027 1028 __skb_unlink(pos, lobby); 1029 if (!event) 1030 event = sctp_skb2event(pos); 1031 1032 __skb_queue_tail(&temp, pos); 1033 } 1034 1035 if (!event && pos != (struct sk_buff *)lobby) { 1036 cevent = (struct sctp_ulpevent *)pos->cb; 1037 csid = cevent->stream; 1038 cmid = cevent->mid; 1039 1040 if (csid == sid && cmid == sctp_mid_peek(stream, in, csid)) { 1041 sctp_mid_next(stream, in, csid); 1042 __skb_unlink(pos, lobby); 1043 __skb_queue_tail(&temp, pos); 1044 event = sctp_skb2event(pos); 1045 } 1046 } 1047 1048 if (event) { 1049 sctp_intl_retrieve_ordered(ulpq, event); 1050 sctp_enqueue_event(ulpq, event); 1051 } 1052 } 1053 1054 static void sctp_intl_abort_pd(struct sctp_ulpq *ulpq, gfp_t gfp) 1055 { 1056 struct sctp_stream *stream = &ulpq->asoc->stream; 1057 __u16 sid; 1058 1059 for (sid = 0; sid < stream->incnt; sid++) { 1060 struct sctp_stream_in *sin = &stream->in[sid]; 1061 __u32 mid; 1062 1063 if (sin->pd_mode_uo) { 1064 sin->pd_mode_uo = 0; 1065 1066 mid = sin->mid_uo; 1067 sctp_intl_stream_abort_pd(ulpq, sid, mid, 0x1, gfp); 1068 } 1069 1070 if (sin->pd_mode) { 1071 sin->pd_mode = 0; 1072 1073 mid = sin->mid; 1074 sctp_intl_stream_abort_pd(ulpq, sid, mid, 0, gfp); 1075 sctp_mid_skip(stream, in, sid, mid); 1076 1077 sctp_intl_reap_ordered(ulpq, sid); 1078 } 1079 } 1080 1081 /* intl abort pd happens only when all data needs to be cleaned */ 1082 sctp_ulpq_flush(ulpq); 1083 } 1084 1085 static inline int sctp_get_skip_pos(struct sctp_ifwdtsn_skip *skiplist, 1086 int nskips, __be16 stream, __u8 flags) 1087 { 1088 int i; 1089 1090 for (i = 0; i < nskips; i++) 1091 if (skiplist[i].stream == stream && 1092 skiplist[i].flags == flags) 1093 return i; 1094 1095 return i; 1096 } 1097 1098 #define SCTP_FTSN_U_BIT 0x1 1099 static void sctp_generate_iftsn(struct sctp_outq *q, __u32 ctsn) 1100 { 1101 struct sctp_ifwdtsn_skip ftsn_skip_arr[10]; 1102 struct sctp_association *asoc = q->asoc; 1103 struct sctp_chunk *ftsn_chunk = NULL; 1104 struct list_head *lchunk, *temp; 1105 int nskips = 0, skip_pos; 1106 struct sctp_chunk *chunk; 1107 __u32 tsn; 1108 1109 if (!asoc->peer.prsctp_capable) 1110 return; 1111 1112 if (TSN_lt(asoc->adv_peer_ack_point, ctsn)) 1113 asoc->adv_peer_ack_point = ctsn; 1114 1115 list_for_each_safe(lchunk, temp, &q->abandoned) { 1116 chunk = list_entry(lchunk, struct sctp_chunk, transmitted_list); 1117 tsn = ntohl(chunk->subh.data_hdr->tsn); 1118 1119 if (TSN_lte(tsn, ctsn)) { 1120 list_del_init(lchunk); 1121 sctp_chunk_free(chunk); 1122 } else if (TSN_lte(tsn, asoc->adv_peer_ack_point + 1)) { 1123 __be16 sid = chunk->subh.idata_hdr->stream; 1124 __be32 mid = chunk->subh.idata_hdr->mid; 1125 __u8 flags = 0; 1126 1127 if (chunk->chunk_hdr->flags & SCTP_DATA_UNORDERED) 1128 flags |= SCTP_FTSN_U_BIT; 1129 1130 asoc->adv_peer_ack_point = tsn; 1131 skip_pos = sctp_get_skip_pos(&ftsn_skip_arr[0], nskips, 1132 sid, flags); 1133 ftsn_skip_arr[skip_pos].stream = sid; 1134 ftsn_skip_arr[skip_pos].reserved = 0; 1135 ftsn_skip_arr[skip_pos].flags = flags; 1136 ftsn_skip_arr[skip_pos].mid = mid; 1137 if (skip_pos == nskips) 1138 nskips++; 1139 if (nskips == 10) 1140 break; 1141 } else { 1142 break; 1143 } 1144 } 1145 1146 if (asoc->adv_peer_ack_point > ctsn) 1147 ftsn_chunk = sctp_make_ifwdtsn(asoc, asoc->adv_peer_ack_point, 1148 nskips, &ftsn_skip_arr[0]); 1149 1150 if (ftsn_chunk) { 1151 list_add_tail(&ftsn_chunk->list, &q->control_chunk_list); 1152 SCTP_INC_STATS(sock_net(asoc->base.sk), SCTP_MIB_OUTCTRLCHUNKS); 1153 } 1154 } 1155 1156 #define _sctp_walk_ifwdtsn(pos, chunk, end) \ 1157 for (pos = chunk->subh.ifwdtsn_hdr->skip; \ 1158 (void *)pos < (void *)chunk->subh.ifwdtsn_hdr->skip + (end); pos++) 1159 1160 #define sctp_walk_ifwdtsn(pos, ch) \ 1161 _sctp_walk_ifwdtsn((pos), (ch), ntohs((ch)->chunk_hdr->length) - \ 1162 sizeof(struct sctp_ifwdtsn_chunk)) 1163 1164 static bool sctp_validate_fwdtsn(struct sctp_chunk *chunk) 1165 { 1166 struct sctp_fwdtsn_skip *skip; 1167 __u16 incnt; 1168 1169 if (chunk->chunk_hdr->type != SCTP_CID_FWD_TSN) 1170 return false; 1171 1172 incnt = chunk->asoc->stream.incnt; 1173 sctp_walk_fwdtsn(skip, chunk) 1174 if (ntohs(skip->stream) >= incnt) 1175 return false; 1176 1177 return true; 1178 } 1179 1180 static bool sctp_validate_iftsn(struct sctp_chunk *chunk) 1181 { 1182 struct sctp_ifwdtsn_skip *skip; 1183 __u16 incnt; 1184 1185 if (chunk->chunk_hdr->type != SCTP_CID_I_FWD_TSN) 1186 return false; 1187 1188 incnt = chunk->asoc->stream.incnt; 1189 sctp_walk_ifwdtsn(skip, chunk) 1190 if (ntohs(skip->stream) >= incnt) 1191 return false; 1192 1193 return true; 1194 } 1195 1196 static void sctp_report_fwdtsn(struct sctp_ulpq *ulpq, __u32 ftsn) 1197 { 1198 /* Move the Cumulattive TSN Ack ahead. */ 1199 sctp_tsnmap_skip(&ulpq->asoc->peer.tsn_map, ftsn); 1200 /* purge the fragmentation queue */ 1201 sctp_ulpq_reasm_flushtsn(ulpq, ftsn); 1202 /* Abort any in progress partial delivery. */ 1203 sctp_ulpq_abort_pd(ulpq, GFP_ATOMIC); 1204 } 1205 1206 static void sctp_intl_reasm_flushtsn(struct sctp_ulpq *ulpq, __u32 ftsn) 1207 { 1208 struct sk_buff *pos, *tmp; 1209 1210 skb_queue_walk_safe(&ulpq->reasm, pos, tmp) { 1211 struct sctp_ulpevent *event = sctp_skb2event(pos); 1212 __u32 tsn = event->tsn; 1213 1214 if (TSN_lte(tsn, ftsn)) { 1215 __skb_unlink(pos, &ulpq->reasm); 1216 sctp_ulpevent_free(event); 1217 } 1218 } 1219 1220 skb_queue_walk_safe(&ulpq->reasm_uo, pos, tmp) { 1221 struct sctp_ulpevent *event = sctp_skb2event(pos); 1222 __u32 tsn = event->tsn; 1223 1224 if (TSN_lte(tsn, ftsn)) { 1225 __skb_unlink(pos, &ulpq->reasm_uo); 1226 sctp_ulpevent_free(event); 1227 } 1228 } 1229 } 1230 1231 static void sctp_report_iftsn(struct sctp_ulpq *ulpq, __u32 ftsn) 1232 { 1233 /* Move the Cumulattive TSN Ack ahead. */ 1234 sctp_tsnmap_skip(&ulpq->asoc->peer.tsn_map, ftsn); 1235 /* purge the fragmentation queue */ 1236 sctp_intl_reasm_flushtsn(ulpq, ftsn); 1237 /* abort only when it's for all data */ 1238 if (ftsn == sctp_tsnmap_get_max_tsn_seen(&ulpq->asoc->peer.tsn_map)) 1239 sctp_intl_abort_pd(ulpq, GFP_ATOMIC); 1240 } 1241 1242 static void sctp_handle_fwdtsn(struct sctp_ulpq *ulpq, struct sctp_chunk *chunk) 1243 { 1244 struct sctp_fwdtsn_skip *skip; 1245 1246 /* Walk through all the skipped SSNs */ 1247 sctp_walk_fwdtsn(skip, chunk) 1248 sctp_ulpq_skip(ulpq, ntohs(skip->stream), ntohs(skip->ssn)); 1249 } 1250 1251 static void sctp_intl_skip(struct sctp_ulpq *ulpq, __u16 sid, __u32 mid, 1252 __u8 flags) 1253 { 1254 struct sctp_stream_in *sin = sctp_stream_in(ulpq->asoc, sid); 1255 struct sctp_stream *stream = &ulpq->asoc->stream; 1256 1257 if (flags & SCTP_FTSN_U_BIT) { 1258 if (sin->pd_mode_uo && MID_lt(sin->mid_uo, mid)) { 1259 sin->pd_mode_uo = 0; 1260 sctp_intl_stream_abort_pd(ulpq, sid, mid, 0x1, 1261 GFP_ATOMIC); 1262 } 1263 return; 1264 } 1265 1266 if (MID_lt(mid, sctp_mid_peek(stream, in, sid))) 1267 return; 1268 1269 if (sin->pd_mode) { 1270 sin->pd_mode = 0; 1271 sctp_intl_stream_abort_pd(ulpq, sid, mid, 0x0, GFP_ATOMIC); 1272 } 1273 1274 sctp_mid_skip(stream, in, sid, mid); 1275 1276 sctp_intl_reap_ordered(ulpq, sid); 1277 } 1278 1279 static void sctp_handle_iftsn(struct sctp_ulpq *ulpq, struct sctp_chunk *chunk) 1280 { 1281 struct sctp_ifwdtsn_skip *skip; 1282 1283 /* Walk through all the skipped MIDs and abort stream pd if possible */ 1284 sctp_walk_ifwdtsn(skip, chunk) 1285 sctp_intl_skip(ulpq, ntohs(skip->stream), 1286 ntohl(skip->mid), skip->flags); 1287 } 1288 1289 static struct sctp_stream_interleave sctp_stream_interleave_0 = { 1290 .data_chunk_len = sizeof(struct sctp_data_chunk), 1291 .ftsn_chunk_len = sizeof(struct sctp_fwdtsn_chunk), 1292 /* DATA process functions */ 1293 .make_datafrag = sctp_make_datafrag_empty, 1294 .assign_number = sctp_chunk_assign_ssn, 1295 .validate_data = sctp_validate_data, 1296 .ulpevent_data = sctp_ulpq_tail_data, 1297 .enqueue_event = sctp_ulpq_tail_event, 1298 .renege_events = sctp_ulpq_renege, 1299 .start_pd = sctp_ulpq_partial_delivery, 1300 .abort_pd = sctp_ulpq_abort_pd, 1301 /* FORWARD-TSN process functions */ 1302 .generate_ftsn = sctp_generate_fwdtsn, 1303 .validate_ftsn = sctp_validate_fwdtsn, 1304 .report_ftsn = sctp_report_fwdtsn, 1305 .handle_ftsn = sctp_handle_fwdtsn, 1306 }; 1307 1308 static struct sctp_stream_interleave sctp_stream_interleave_1 = { 1309 .data_chunk_len = sizeof(struct sctp_idata_chunk), 1310 .ftsn_chunk_len = sizeof(struct sctp_ifwdtsn_chunk), 1311 /* I-DATA process functions */ 1312 .make_datafrag = sctp_make_idatafrag_empty, 1313 .assign_number = sctp_chunk_assign_mid, 1314 .validate_data = sctp_validate_idata, 1315 .ulpevent_data = sctp_ulpevent_idata, 1316 .enqueue_event = sctp_enqueue_event, 1317 .renege_events = sctp_renege_events, 1318 .start_pd = sctp_intl_start_pd, 1319 .abort_pd = sctp_intl_abort_pd, 1320 /* I-FORWARD-TSN process functions */ 1321 .generate_ftsn = sctp_generate_iftsn, 1322 .validate_ftsn = sctp_validate_iftsn, 1323 .report_ftsn = sctp_report_iftsn, 1324 .handle_ftsn = sctp_handle_iftsn, 1325 }; 1326 1327 void sctp_stream_interleave_init(struct sctp_stream *stream) 1328 { 1329 struct sctp_association *asoc; 1330 1331 asoc = container_of(stream, struct sctp_association, stream); 1332 stream->si = asoc->intl_enable ? &sctp_stream_interleave_1 1333 : &sctp_stream_interleave_0; 1334 } 1335