net/sctp/stream_interleave.c

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