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(ulpq->asoc->base.net, &ulpq->reasm,
 245                                              first_frag, last_frag);
 246         if (retval) {
 247                 sin->fsn = next_fsn;
 248                 if (is_last) {
 249                         retval->msg_flags |= MSG_EOR;
 250                         sin->pd_mode = 0;
 251                 }
 252         }
 253
 254         return retval;
 255 }
 256
 257 static struct sctp_ulpevent *sctp_intl_retrieve_reassembled(
 258                                                 struct sctp_ulpq *ulpq,
 259                                                 struct sctp_ulpevent *event)
 260 {
 261         struct sctp_association *asoc = ulpq->asoc;
 262         struct sk_buff *pos, *first_frag = NULL;
 263         struct sctp_ulpevent *retval = NULL;
 264         struct sk_buff *pd_first = NULL;
 265         struct sk_buff *pd_last = NULL;
 266         struct sctp_stream_in *sin;
 267         __u32 next_fsn = 0;
 268         __u32 pd_point = 0;
 269         __u32 pd_len = 0;
 270         __u32 mid = 0;
 271
 272         sin = sctp_stream_in(&ulpq->asoc->stream, event->stream);
 273
 274         skb_queue_walk(&ulpq->reasm, pos) {
 275                 struct sctp_ulpevent *cevent = sctp_skb2event(pos);
 276
 277                 if (cevent->stream < event->stream)
 278                         continue;
 279                 if (cevent->stream > event->stream)
 280                         break;
 281
 282                 if (MID_lt(cevent->mid, event->mid))
 283                         continue;
 284                 if (MID_lt(event->mid, cevent->mid))
 285                         break;
 286
 287                 switch (cevent->msg_flags & SCTP_DATA_FRAG_MASK) {
 288                 case SCTP_DATA_FIRST_FRAG:
 289                         if (cevent->mid == sin->mid) {
 290                                 pd_first = pos;
 291                                 pd_last = pos;
 292                                 pd_len = pos->len;
 293                         }
 294
 295                         first_frag = pos;
 296                         next_fsn = 0;
 297                         mid = cevent->mid;
 298                         break;
 299
 300                 case SCTP_DATA_MIDDLE_FRAG:
 301                         if (first_frag && cevent->mid == mid &&
 302                             cevent->fsn == next_fsn) {
 303                                 next_fsn++;
 304                                 if (pd_first) {
 305                                         pd_last = pos;
 306                                         pd_len += pos->len;
 307                                 }
 308                         } else {
 309                                 first_frag = NULL;
 310                         }
 311                         break;
 312
 313                 case SCTP_DATA_LAST_FRAG:
 314                         if (first_frag && cevent->mid == mid &&
 315                             cevent->fsn == next_fsn)
 316                                 goto found;
 317                         else
 318                                 first_frag = NULL;
 319                         break;
 320                 }
 321         }
 322
 323         if (!pd_first)
 324                 goto out;
 325
 326         pd_point = sctp_sk(asoc->base.sk)->pd_point;
 327         if (pd_point && pd_point <= pd_len) {
 328                 retval = sctp_make_reassembled_event(asoc->base.net,
 329                                                      &ulpq->reasm,
 330                                                      pd_first, pd_last);
 331                 if (retval) {
 332                         sin->fsn = next_fsn;
 333                         sin->pd_mode = 1;
 334                 }
 335         }
 336         goto out;
 337
 338 found:
 339         retval = sctp_make_reassembled_event(asoc->base.net, &ulpq->reasm,
 340                                              first_frag, pos);
 341         if (retval)
 342                 retval->msg_flags |= MSG_EOR;
 343
 344 out:
 345         return retval;
 346 }
 347
 348 static struct sctp_ulpevent *sctp_intl_reasm(struct sctp_ulpq *ulpq,
 349                                              struct sctp_ulpevent *event)
 350 {
 351         struct sctp_ulpevent *retval = NULL;
 352         struct sctp_stream_in *sin;
 353
 354         if (SCTP_DATA_NOT_FRAG == (event->msg_flags & SCTP_DATA_FRAG_MASK)) {
 355                 event->msg_flags |= MSG_EOR;
 356                 return event;
 357         }
 358
 359         sctp_intl_store_reasm(ulpq, event);
 360
 361         sin = sctp_stream_in(&ulpq->asoc->stream, event->stream);
 362         if (sin->pd_mode && event->mid == sin->mid &&
 363             event->fsn == sin->fsn)
 364                 retval = sctp_intl_retrieve_partial(ulpq, event);
 365
 366         if (!retval)
 367                 retval = sctp_intl_retrieve_reassembled(ulpq, event);
 368
 369         return retval;
 370 }
 371
 372 static void sctp_intl_store_ordered(struct sctp_ulpq *ulpq,
 373                                     struct sctp_ulpevent *event)
 374 {
 375         struct sctp_ulpevent *cevent;
 376         struct sk_buff *pos, *loc;
 377
 378         pos = skb_peek_tail(&ulpq->lobby);
 379         if (!pos) {
 380                 __skb_queue_tail(&ulpq->lobby, sctp_event2skb(event));
 381                 return;
 382         }
 383
 384         cevent = (struct sctp_ulpevent *)pos->cb;
 385         if (event->stream == cevent->stream &&
 386             MID_lt(cevent->mid, event->mid)) {
 387                 __skb_queue_tail(&ulpq->lobby, sctp_event2skb(event));
 388                 return;
 389         }
 390
 391         if (event->stream > cevent->stream) {
 392                 __skb_queue_tail(&ulpq->lobby, sctp_event2skb(event));
 393                 return;
 394         }
 395
 396         loc = NULL;
 397         skb_queue_walk(&ulpq->lobby, pos) {
 398                 cevent = (struct sctp_ulpevent *)pos->cb;
 399
 400                 if (cevent->stream > event->stream) {
 401                         loc = pos;
 402                         break;
 403                 }
 404                 if (cevent->stream == event->stream &&
 405                     MID_lt(event->mid, cevent->mid)) {
 406                         loc = pos;
 407                         break;
 408                 }
 409         }
 410
 411         if (!loc)
 412                 __skb_queue_tail(&ulpq->lobby, sctp_event2skb(event));
 413         else
 414                 __skb_queue_before(&ulpq->lobby, loc, sctp_event2skb(event));
 415 }
 416
 417 static void sctp_intl_retrieve_ordered(struct sctp_ulpq *ulpq,
 418                                        struct sctp_ulpevent *event)
 419 {
 420         struct sk_buff_head *event_list;
 421         struct sctp_stream *stream;
 422         struct sk_buff *pos, *tmp;
 423         __u16 sid = event->stream;
 424
 425         stream  = &ulpq->asoc->stream;
 426         event_list = (struct sk_buff_head *)sctp_event2skb(event)->prev;
 427
 428         sctp_skb_for_each(pos, &ulpq->lobby, tmp) {
 429                 struct sctp_ulpevent *cevent = (struct sctp_ulpevent *)pos->cb;
 430
 431                 if (cevent->stream > sid)
 432                         break;
 433
 434                 if (cevent->stream < sid)
 435                         continue;
 436
 437                 if (cevent->mid != sctp_mid_peek(stream, in, sid))
 438                         break;
 439
 440                 sctp_mid_next(stream, in, sid);
 441
 442                 __skb_unlink(pos, &ulpq->lobby);
 443
 444                 __skb_queue_tail(event_list, pos);
 445         }
 446 }
 447
 448 static struct sctp_ulpevent *sctp_intl_order(struct sctp_ulpq *ulpq,
 449                                              struct sctp_ulpevent *event)
 450 {
 451         struct sctp_stream *stream;
 452         __u16 sid;
 453
 454         stream  = &ulpq->asoc->stream;
 455         sid = event->stream;
 456
 457         if (event->mid != sctp_mid_peek(stream, in, sid)) {
 458                 sctp_intl_store_ordered(ulpq, event);
 459                 return NULL;
 460         }
 461
 462         sctp_mid_next(stream, in, sid);
 463
 464         sctp_intl_retrieve_ordered(ulpq, event);
 465
 466         return event;
 467 }
 468
 469 static int sctp_enqueue_event(struct sctp_ulpq *ulpq,
 470                               struct sk_buff_head *skb_list)
 471 {
 472         struct sock *sk = ulpq->asoc->base.sk;
 473         struct sctp_sock *sp = sctp_sk(sk);
 474         struct sctp_ulpevent *event;
 475         struct sk_buff *skb;
 476
 477         skb = __skb_peek(skb_list);
 478         event = sctp_skb2event(skb);
 479
 480         if (sk->sk_shutdown & RCV_SHUTDOWN &&
 481             (sk->sk_shutdown & SEND_SHUTDOWN ||
 482              !sctp_ulpevent_is_notification(event)))
 483                 goto out_free;
 484
 485         if (!sctp_ulpevent_is_notification(event)) {
 486                 sk_mark_napi_id(sk, skb);
 487                 sk_incoming_cpu_update(sk);
 488         }
 489
 490         if (!sctp_ulpevent_is_enabled(event, ulpq->asoc->subscribe))
 491                 goto out_free;
 492
 493         if (skb_list)
 494                 skb_queue_splice_tail_init(skb_list,
 495                                            &sk->sk_receive_queue);
 496         else
 497                 __skb_queue_tail(&sk->sk_receive_queue, skb);
 498
 499         if (!sp->data_ready_signalled) {
 500                 sp->data_ready_signalled = 1;
 501                 sk->sk_data_ready(sk);
 502         }
 503
 504         return 1;
 505
 506 out_free:
 507         if (skb_list)
 508                 sctp_queue_purge_ulpevents(skb_list);
 509         else
 510                 sctp_ulpevent_free(event);
 511
 512         return 0;
 513 }
 514
 515 static void sctp_intl_store_reasm_uo(struct sctp_ulpq *ulpq,
 516                                      struct sctp_ulpevent *event)
 517 {
 518         struct sctp_ulpevent *cevent;
 519         struct sk_buff *pos;
 520
 521         pos = skb_peek_tail(&ulpq->reasm_uo);
 522         if (!pos) {
 523                 __skb_queue_tail(&ulpq->reasm_uo, sctp_event2skb(event));
 524                 return;
 525         }
 526
 527         cevent = sctp_skb2event(pos);
 528
 529         if (event->stream == cevent->stream &&
 530             event->mid == cevent->mid &&
 531             (cevent->msg_flags & SCTP_DATA_FIRST_FRAG ||
 532              (!(event->msg_flags & SCTP_DATA_FIRST_FRAG) &&
 533               event->fsn > cevent->fsn))) {
 534                 __skb_queue_tail(&ulpq->reasm_uo, sctp_event2skb(event));
 535                 return;
 536         }
 537
 538         if ((event->stream == cevent->stream &&
 539              MID_lt(cevent->mid, event->mid)) ||
 540             event->stream > cevent->stream) {
 541                 __skb_queue_tail(&ulpq->reasm_uo, sctp_event2skb(event));
 542                 return;
 543         }
 544
 545         skb_queue_walk(&ulpq->reasm_uo, pos) {
 546                 cevent = sctp_skb2event(pos);
 547
 548                 if (event->stream < cevent->stream ||
 549                     (event->stream == cevent->stream &&
 550                      MID_lt(event->mid, cevent->mid)))
 551                         break;
 552
 553                 if (event->stream == cevent->stream &&
 554                     event->mid == cevent->mid &&
 555                     !(cevent->msg_flags & SCTP_DATA_FIRST_FRAG) &&
 556                     (event->msg_flags & SCTP_DATA_FIRST_FRAG ||
 557                      event->fsn < cevent->fsn))
 558                         break;
 559         }
 560
 561         __skb_queue_before(&ulpq->reasm_uo, pos, sctp_event2skb(event));
 562 }
 563
 564 static struct sctp_ulpevent *sctp_intl_retrieve_partial_uo(
 565                                                 struct sctp_ulpq *ulpq,
 566                                                 struct sctp_ulpevent *event)
 567 {
 568         struct sk_buff *first_frag = NULL;
 569         struct sk_buff *last_frag = NULL;
 570         struct sctp_ulpevent *retval;
 571         struct sctp_stream_in *sin;
 572         struct sk_buff *pos;
 573         __u32 next_fsn = 0;
 574         int is_last = 0;
 575
 576         sin = sctp_stream_in(&ulpq->asoc->stream, event->stream);
 577
 578         skb_queue_walk(&ulpq->reasm_uo, pos) {
 579                 struct sctp_ulpevent *cevent = sctp_skb2event(pos);
 580
 581                 if (cevent->stream < event->stream)
 582                         continue;
 583                 if (cevent->stream > event->stream)
 584                         break;
 585
 586                 if (MID_lt(cevent->mid, sin->mid_uo))
 587                         continue;
 588                 if (MID_lt(sin->mid_uo, cevent->mid))
 589                         break;
 590
 591                 switch (cevent->msg_flags & SCTP_DATA_FRAG_MASK) {
 592                 case SCTP_DATA_FIRST_FRAG:
 593                         goto out;
 594                 case SCTP_DATA_MIDDLE_FRAG:
 595                         if (!first_frag) {
 596                                 if (cevent->fsn == sin->fsn_uo) {
 597                                         first_frag = pos;
 598                                         last_frag = pos;
 599                                         next_fsn = cevent->fsn + 1;
 600                                 }
 601                         } else if (cevent->fsn == next_fsn) {
 602                                 last_frag = pos;
 603                                 next_fsn++;
 604                         } else {
 605                                 goto out;
 606                         }
 607                         break;
 608                 case SCTP_DATA_LAST_FRAG:
 609                         if (!first_frag) {
 610                                 if (cevent->fsn == sin->fsn_uo) {
 611                                         first_frag = pos;
 612                                         last_frag = pos;
 613                                         next_fsn = 0;
 614                                         is_last = 1;
 615                                 }
 616                         } else if (cevent->fsn == next_fsn) {
 617                                 last_frag = pos;
 618                                 next_fsn = 0;
 619                                 is_last = 1;
 620                         }
 621                         goto out;
 622                 default:
 623                         goto out;
 624                 }
 625         }
 626
 627 out:
 628         if (!first_frag)
 629                 return NULL;
 630
 631         retval = sctp_make_reassembled_event(ulpq->asoc->base.net,
 632                                              &ulpq->reasm_uo, first_frag,
 633                                              last_frag);
 634         if (retval) {
 635                 sin->fsn_uo = next_fsn;
 636                 if (is_last) {
 637                         retval->msg_flags |= MSG_EOR;
 638                         sin->pd_mode_uo = 0;
 639                 }
 640         }
 641
 642         return retval;
 643 }
 644
 645 static struct sctp_ulpevent *sctp_intl_retrieve_reassembled_uo(
 646                                                 struct sctp_ulpq *ulpq,
 647                                                 struct sctp_ulpevent *event)
 648 {
 649         struct sctp_association *asoc = ulpq->asoc;
 650         struct sk_buff *pos, *first_frag = NULL;
 651         struct sctp_ulpevent *retval = NULL;
 652         struct sk_buff *pd_first = NULL;
 653         struct sk_buff *pd_last = NULL;
 654         struct sctp_stream_in *sin;
 655         __u32 next_fsn = 0;
 656         __u32 pd_point = 0;
 657         __u32 pd_len = 0;
 658         __u32 mid = 0;
 659
 660         sin = sctp_stream_in(&ulpq->asoc->stream, event->stream);
 661
 662         skb_queue_walk(&ulpq->reasm_uo, pos) {
 663                 struct sctp_ulpevent *cevent = sctp_skb2event(pos);
 664
 665                 if (cevent->stream < event->stream)
 666                         continue;
 667                 if (cevent->stream > event->stream)
 668                         break;
 669
 670                 if (MID_lt(cevent->mid, event->mid))
 671                         continue;
 672                 if (MID_lt(event->mid, cevent->mid))
 673                         break;
 674
 675                 switch (cevent->msg_flags & SCTP_DATA_FRAG_MASK) {
 676                 case SCTP_DATA_FIRST_FRAG:
 677                         if (!sin->pd_mode_uo) {
 678                                 sin->mid_uo = cevent->mid;
 679                                 pd_first = pos;
 680                                 pd_last = pos;
 681                                 pd_len = pos->len;
 682                         }
 683
 684                         first_frag = pos;
 685                         next_fsn = 0;
 686                         mid = cevent->mid;
 687                         break;
 688
 689                 case SCTP_DATA_MIDDLE_FRAG:
 690                         if (first_frag && cevent->mid == mid &&
 691                             cevent->fsn == next_fsn) {
 692                                 next_fsn++;
 693                                 if (pd_first) {
 694                                         pd_last = pos;
 695                                         pd_len += pos->len;
 696                                 }
 697                         } else {
 698                                 first_frag = NULL;
 699                         }
 700                         break;
 701
 702                 case SCTP_DATA_LAST_FRAG:
 703                         if (first_frag && cevent->mid == mid &&
 704                             cevent->fsn == next_fsn)
 705                                 goto found;
 706                         else
 707                                 first_frag = NULL;
 708                         break;
 709                 }
 710         }
 711
 712         if (!pd_first)
 713                 goto out;
 714
 715         pd_point = sctp_sk(asoc->base.sk)->pd_point;
 716         if (pd_point && pd_point <= pd_len) {
 717                 retval = sctp_make_reassembled_event(asoc->base.net,
 718                                                      &ulpq->reasm_uo,
 719                                                      pd_first, pd_last);
 720                 if (retval) {
 721                         sin->fsn_uo = next_fsn;
 722                         sin->pd_mode_uo = 1;
 723                 }
 724         }
 725         goto out;
 726
 727 found:
 728         retval = sctp_make_reassembled_event(asoc->base.net, &ulpq->reasm_uo,
 729                                              first_frag, pos);
 730         if (retval)
 731                 retval->msg_flags |= MSG_EOR;
 732
 733 out:
 734         return retval;
 735 }
 736
 737 static struct sctp_ulpevent *sctp_intl_reasm_uo(struct sctp_ulpq *ulpq,
 738                                                 struct sctp_ulpevent *event)
 739 {
 740         struct sctp_ulpevent *retval = NULL;
 741         struct sctp_stream_in *sin;
 742
 743         if (SCTP_DATA_NOT_FRAG == (event->msg_flags & SCTP_DATA_FRAG_MASK)) {
 744                 event->msg_flags |= MSG_EOR;
 745                 return event;
 746         }
 747
 748         sctp_intl_store_reasm_uo(ulpq, event);
 749
 750         sin = sctp_stream_in(&ulpq->asoc->stream, event->stream);
 751         if (sin->pd_mode_uo && event->mid == sin->mid_uo &&
 752             event->fsn == sin->fsn_uo)
 753                 retval = sctp_intl_retrieve_partial_uo(ulpq, event);
 754
 755         if (!retval)
 756                 retval = sctp_intl_retrieve_reassembled_uo(ulpq, event);
 757
 758         return retval;
 759 }
 760
 761 static struct sctp_ulpevent *sctp_intl_retrieve_first_uo(struct sctp_ulpq *ulpq)
 762 {
 763         struct sctp_stream_in *csin, *sin = NULL;
 764         struct sk_buff *first_frag = NULL;
 765         struct sk_buff *last_frag = NULL;
 766         struct sctp_ulpevent *retval;
 767         struct sk_buff *pos;
 768         __u32 next_fsn = 0;
 769         __u16 sid = 0;
 770
 771         skb_queue_walk(&ulpq->reasm_uo, pos) {
 772                 struct sctp_ulpevent *cevent = sctp_skb2event(pos);
 773
 774                 csin = sctp_stream_in(&ulpq->asoc->stream, cevent->stream);
 775                 if (csin->pd_mode_uo)
 776                         continue;
 777
 778                 switch (cevent->msg_flags & SCTP_DATA_FRAG_MASK) {
 779                 case SCTP_DATA_FIRST_FRAG:
 780                         if (first_frag)
 781                                 goto out;
 782                         first_frag = pos;
 783                         last_frag = pos;
 784                         next_fsn = 0;
 785                         sin = csin;
 786                         sid = cevent->stream;
 787                         sin->mid_uo = cevent->mid;
 788                         break;
 789                 case SCTP_DATA_MIDDLE_FRAG:
 790                         if (!first_frag)
 791                                 break;
 792                         if (cevent->stream == sid &&
 793                             cevent->mid == sin->mid_uo &&
 794                             cevent->fsn == next_fsn) {
 795                                 next_fsn++;
 796                                 last_frag = pos;
 797                         } else {
 798                                 goto out;
 799                         }
 800                         break;
 801                 case SCTP_DATA_LAST_FRAG:
 802                         if (first_frag)
 803                                 goto out;
 804                         break;
 805                 default:
 806                         break;
 807                 }
 808         }
 809
 810         if (!first_frag)
 811                 return NULL;
 812
 813 out:
 814         retval = sctp_make_reassembled_event(ulpq->asoc->base.net,
 815                                              &ulpq->reasm_uo, first_frag,
 816                                              last_frag);
 817         if (retval) {
 818                 sin->fsn_uo = next_fsn;
 819                 sin->pd_mode_uo = 1;
 820         }
 821
 822         return retval;
 823 }
 824
 825 static int sctp_ulpevent_idata(struct sctp_ulpq *ulpq,
 826                                struct sctp_chunk *chunk, gfp_t gfp)
 827 {
 828         struct sctp_ulpevent *event;
 829         struct sk_buff_head temp;
 830         int event_eor = 0;
 831
 832         event = sctp_ulpevent_make_rcvmsg(chunk->asoc, chunk, gfp);
 833         if (!event)
 834                 return -ENOMEM;
 835
 836         event->mid = ntohl(chunk->subh.idata_hdr->mid);
 837         if (event->msg_flags & SCTP_DATA_FIRST_FRAG)
 838                 event->ppid = chunk->subh.idata_hdr->ppid;
 839         else
 840                 event->fsn = ntohl(chunk->subh.idata_hdr->fsn);
 841
 842         if (!(event->msg_flags & SCTP_DATA_UNORDERED)) {
 843                 event = sctp_intl_reasm(ulpq, event);
 844                 if (event) {
 845                         skb_queue_head_init(&temp);
 846                         __skb_queue_tail(&temp, sctp_event2skb(event));
 847
 848                         if (event->msg_flags & MSG_EOR)
 849                                 event = sctp_intl_order(ulpq, event);
 850                 }
 851         } else {
 852                 event = sctp_intl_reasm_uo(ulpq, event);
 853                 if (event) {
 854                         skb_queue_head_init(&temp);
 855                         __skb_queue_tail(&temp, sctp_event2skb(event));
 856                 }
 857         }
 858
 859         if (event) {
 860                 event_eor = (event->msg_flags & MSG_EOR) ? 1 : 0;
 861                 sctp_enqueue_event(ulpq, &temp);
 862         }
 863
 864         return event_eor;
 865 }
 866
 867 static struct sctp_ulpevent *sctp_intl_retrieve_first(struct sctp_ulpq *ulpq)
 868 {
 869         struct sctp_stream_in *csin, *sin = NULL;
 870         struct sk_buff *first_frag = NULL;
 871         struct sk_buff *last_frag = NULL;
 872         struct sctp_ulpevent *retval;
 873         struct sk_buff *pos;
 874         __u32 next_fsn = 0;
 875         __u16 sid = 0;
 876
 877         skb_queue_walk(&ulpq->reasm, pos) {
 878                 struct sctp_ulpevent *cevent = sctp_skb2event(pos);
 879
 880                 csin = sctp_stream_in(&ulpq->asoc->stream, cevent->stream);
 881                 if (csin->pd_mode)
 882                         continue;
 883
 884                 switch (cevent->msg_flags & SCTP_DATA_FRAG_MASK) {
 885                 case SCTP_DATA_FIRST_FRAG:
 886                         if (first_frag)
 887                                 goto out;
 888                         if (cevent->mid == csin->mid) {
 889                                 first_frag = pos;
 890                                 last_frag = pos;
 891                                 next_fsn = 0;
 892                                 sin = csin;
 893                                 sid = cevent->stream;
 894                         }
 895                         break;
 896                 case SCTP_DATA_MIDDLE_FRAG:
 897                         if (!first_frag)
 898                                 break;
 899                         if (cevent->stream == sid &&
 900                             cevent->mid == sin->mid &&
 901                             cevent->fsn == next_fsn) {
 902                                 next_fsn++;
 903                                 last_frag = pos;
 904                         } else {
 905                                 goto out;
 906                         }
 907                         break;
 908                 case SCTP_DATA_LAST_FRAG:
 909                         if (first_frag)
 910                                 goto out;
 911                         break;
 912                 default:
 913                         break;
 914                 }
 915         }
 916
 917         if (!first_frag)
 918                 return NULL;
 919
 920 out:
 921         retval = sctp_make_reassembled_event(ulpq->asoc->base.net,
 922                                              &ulpq->reasm, first_frag,
 923                                              last_frag);
 924         if (retval) {
 925                 sin->fsn = next_fsn;
 926                 sin->pd_mode = 1;
 927         }
 928
 929         return retval;
 930 }
 931
 932 static void sctp_intl_start_pd(struct sctp_ulpq *ulpq, gfp_t gfp)
 933 {
 934         struct sctp_ulpevent *event;
 935         struct sk_buff_head temp;
 936
 937         if (!skb_queue_empty(&ulpq->reasm)) {
 938                 do {
 939                         event = sctp_intl_retrieve_first(ulpq);
 940                         if (event) {
 941                                 skb_queue_head_init(&temp);
 942                                 __skb_queue_tail(&temp, sctp_event2skb(event));
 943                                 sctp_enqueue_event(ulpq, &temp);
 944                         }
 945                 } while (event);
 946         }
 947
 948         if (!skb_queue_empty(&ulpq->reasm_uo)) {
 949                 do {
 950                         event = sctp_intl_retrieve_first_uo(ulpq);
 951                         if (event) {
 952                                 skb_queue_head_init(&temp);
 953                                 __skb_queue_tail(&temp, sctp_event2skb(event));
 954                                 sctp_enqueue_event(ulpq, &temp);
 955                         }
 956                 } while (event);
 957         }
 958 }
 959
 960 static void sctp_renege_events(struct sctp_ulpq *ulpq, struct sctp_chunk *chunk,
 961                                gfp_t gfp)
 962 {
 963         struct sctp_association *asoc = ulpq->asoc;
 964         __u32 freed = 0;
 965         __u16 needed;
 966
 967         needed = ntohs(chunk->chunk_hdr->length) -
 968                  sizeof(struct sctp_idata_chunk);
 969
 970         if (skb_queue_empty(&asoc->base.sk->sk_receive_queue)) {
 971                 freed = sctp_ulpq_renege_list(ulpq, &ulpq->lobby, needed);
 972                 if (freed < needed)
 973                         freed += sctp_ulpq_renege_list(ulpq, &ulpq->reasm,
 974                                                        needed);
 975                 if (freed < needed)
 976                         freed += sctp_ulpq_renege_list(ulpq, &ulpq->reasm_uo,
 977                                                        needed);
 978         }
 979
 980         if (freed >= needed && sctp_ulpevent_idata(ulpq, chunk, gfp) <= 0)
 981                 sctp_intl_start_pd(ulpq, gfp);
 982
 983         sk_mem_reclaim(asoc->base.sk);
 984 }
 985
 986 static void sctp_intl_stream_abort_pd(struct sctp_ulpq *ulpq, __u16 sid,
 987                                       __u32 mid, __u16 flags, gfp_t gfp)
 988 {
 989         struct sock *sk = ulpq->asoc->base.sk;
 990         struct sctp_ulpevent *ev = NULL;
 991
 992         if (!sctp_ulpevent_type_enabled(ulpq->asoc->subscribe,
 993                                         SCTP_PARTIAL_DELIVERY_EVENT))
 994                 return;
 995
 996         ev = sctp_ulpevent_make_pdapi(ulpq->asoc, SCTP_PARTIAL_DELIVERY_ABORTED,
 997                                       sid, mid, flags, gfp);
 998         if (ev) {
 999                 struct sctp_sock *sp = sctp_sk(sk);
1000
1001                 __skb_queue_tail(&sk->sk_receive_queue, sctp_event2skb(ev));
1002
1003                 if (!sp->data_ready_signalled) {
1004                         sp->data_ready_signalled = 1;
1005                         sk->sk_data_ready(sk);
1006                 }
1007         }
1008 }
1009
1010 static void sctp_intl_reap_ordered(struct sctp_ulpq *ulpq, __u16 sid)
1011 {
1012         struct sctp_stream *stream = &ulpq->asoc->stream;
1013         struct sctp_ulpevent *cevent, *event = NULL;
1014         struct sk_buff_head *lobby = &ulpq->lobby;
1015         struct sk_buff *pos, *tmp;
1016         struct sk_buff_head temp;
1017         __u16 csid;
1018         __u32 cmid;
1019
1020         skb_queue_head_init(&temp);
1021         sctp_skb_for_each(pos, lobby, tmp) {
1022                 cevent = (struct sctp_ulpevent *)pos->cb;
1023                 csid = cevent->stream;
1024                 cmid = cevent->mid;
1025
1026                 if (csid > sid)
1027                         break;
1028
1029                 if (csid < sid)
1030                         continue;
1031
1032                 if (!MID_lt(cmid, sctp_mid_peek(stream, in, csid)))
1033                         break;
1034
1035                 __skb_unlink(pos, lobby);
1036                 if (!event)
1037                         event = sctp_skb2event(pos);
1038
1039                 __skb_queue_tail(&temp, pos);
1040         }
1041
1042         if (!event && pos != (struct sk_buff *)lobby) {
1043                 cevent = (struct sctp_ulpevent *)pos->cb;
1044                 csid = cevent->stream;
1045                 cmid = cevent->mid;
1046
1047                 if (csid == sid && cmid == sctp_mid_peek(stream, in, csid)) {
1048                         sctp_mid_next(stream, in, csid);
1049                         __skb_unlink(pos, lobby);
1050                         __skb_queue_tail(&temp, pos);
1051                         event = sctp_skb2event(pos);
1052                 }
1053         }
1054
1055         if (event) {
1056                 sctp_intl_retrieve_ordered(ulpq, event);
1057                 sctp_enqueue_event(ulpq, &temp);
1058         }
1059 }
1060
1061 static void sctp_intl_abort_pd(struct sctp_ulpq *ulpq, gfp_t gfp)
1062 {
1063         struct sctp_stream *stream = &ulpq->asoc->stream;
1064         __u16 sid;
1065
1066         for (sid = 0; sid < stream->incnt; sid++) {
1067                 struct sctp_stream_in *sin = SCTP_SI(stream, sid);
1068                 __u32 mid;
1069
1070                 if (sin->pd_mode_uo) {
1071                         sin->pd_mode_uo = 0;
1072
1073                         mid = sin->mid_uo;
1074                         sctp_intl_stream_abort_pd(ulpq, sid, mid, 0x1, gfp);
1075                 }
1076
1077                 if (sin->pd_mode) {
1078                         sin->pd_mode = 0;
1079
1080                         mid = sin->mid;
1081                         sctp_intl_stream_abort_pd(ulpq, sid, mid, 0, gfp);
1082                         sctp_mid_skip(stream, in, sid, mid);
1083
1084                         sctp_intl_reap_ordered(ulpq, sid);
1085                 }
1086         }
1087
1088         /* intl abort pd happens only when all data needs to be cleaned */
1089         sctp_ulpq_flush(ulpq);
1090 }
1091
1092 static inline int sctp_get_skip_pos(struct sctp_ifwdtsn_skip *skiplist,
1093                                     int nskips, __be16 stream, __u8 flags)
1094 {
1095         int i;
1096
1097         for (i = 0; i < nskips; i++)
1098                 if (skiplist[i].stream == stream &&
1099                     skiplist[i].flags == flags)
1100                         return i;
1101
1102         return i;
1103 }
1104
1105 #define SCTP_FTSN_U_BIT 0x1
1106 static void sctp_generate_iftsn(struct sctp_outq *q, __u32 ctsn)
1107 {
1108         struct sctp_ifwdtsn_skip ftsn_skip_arr[10];
1109         struct sctp_association *asoc = q->asoc;
1110         struct sctp_chunk *ftsn_chunk = NULL;
1111         struct list_head *lchunk, *temp;
1112         int nskips = 0, skip_pos;
1113         struct sctp_chunk *chunk;
1114         __u32 tsn;
1115
1116         if (!asoc->peer.prsctp_capable)
1117                 return;
1118
1119         if (TSN_lt(asoc->adv_peer_ack_point, ctsn))
1120                 asoc->adv_peer_ack_point = ctsn;
1121
1122         list_for_each_safe(lchunk, temp, &q->abandoned) {
1123                 chunk = list_entry(lchunk, struct sctp_chunk, transmitted_list);
1124                 tsn = ntohl(chunk->subh.data_hdr->tsn);
1125
1126                 if (TSN_lte(tsn, ctsn)) {
1127                         list_del_init(lchunk);
1128                         sctp_chunk_free(chunk);
1129                 } else if (TSN_lte(tsn, asoc->adv_peer_ack_point + 1)) {
1130                         __be16 sid = chunk->subh.idata_hdr->stream;
1131                         __be32 mid = chunk->subh.idata_hdr->mid;
1132                         __u8 flags = 0;
1133
1134                         if (chunk->chunk_hdr->flags & SCTP_DATA_UNORDERED)
1135                                 flags |= SCTP_FTSN_U_BIT;
1136
1137                         asoc->adv_peer_ack_point = tsn;
1138                         skip_pos = sctp_get_skip_pos(&ftsn_skip_arr[0], nskips,
1139                                                      sid, flags);
1140                         ftsn_skip_arr[skip_pos].stream = sid;
1141                         ftsn_skip_arr[skip_pos].reserved = 0;
1142                         ftsn_skip_arr[skip_pos].flags = flags;
1143                         ftsn_skip_arr[skip_pos].mid = mid;
1144                         if (skip_pos == nskips)
1145                                 nskips++;
1146                         if (nskips == 10)
1147                                 break;
1148                 } else {
1149                         break;
1150                 }
1151         }
1152
1153         if (asoc->adv_peer_ack_point > ctsn)
1154                 ftsn_chunk = sctp_make_ifwdtsn(asoc, asoc->adv_peer_ack_point,
1155                                                nskips, &ftsn_skip_arr[0]);
1156
1157         if (ftsn_chunk) {
1158                 list_add_tail(&ftsn_chunk->list, &q->control_chunk_list);
1159                 SCTP_INC_STATS(asoc->base.net, SCTP_MIB_OUTCTRLCHUNKS);
1160         }
1161 }
1162
1163 #define _sctp_walk_ifwdtsn(pos, chunk, end) \
1164         for (pos = chunk->subh.ifwdtsn_hdr->skip; \
1165              (void *)pos < (void *)chunk->subh.ifwdtsn_hdr->skip + (end); pos++)
1166
1167 #define sctp_walk_ifwdtsn(pos, ch) \
1168         _sctp_walk_ifwdtsn((pos), (ch), ntohs((ch)->chunk_hdr->length) - \
1169                                         sizeof(struct sctp_ifwdtsn_chunk))
1170
1171 static bool sctp_validate_fwdtsn(struct sctp_chunk *chunk)
1172 {
1173         struct sctp_fwdtsn_skip *skip;
1174         __u16 incnt;
1175
1176         if (chunk->chunk_hdr->type != SCTP_CID_FWD_TSN)
1177                 return false;
1178
1179         incnt = chunk->asoc->stream.incnt;
1180         sctp_walk_fwdtsn(skip, chunk)
1181                 if (ntohs(skip->stream) >= incnt)
1182                         return false;
1183
1184         return true;
1185 }
1186
1187 static bool sctp_validate_iftsn(struct sctp_chunk *chunk)
1188 {
1189         struct sctp_ifwdtsn_skip *skip;
1190         __u16 incnt;
1191
1192         if (chunk->chunk_hdr->type != SCTP_CID_I_FWD_TSN)
1193                 return false;
1194
1195         incnt = chunk->asoc->stream.incnt;
1196         sctp_walk_ifwdtsn(skip, chunk)
1197                 if (ntohs(skip->stream) >= incnt)
1198                         return false;
1199
1200         return true;
1201 }
1202
1203 static void sctp_report_fwdtsn(struct sctp_ulpq *ulpq, __u32 ftsn)
1204 {
1205         /* Move the Cumulattive TSN Ack ahead. */
1206         sctp_tsnmap_skip(&ulpq->asoc->peer.tsn_map, ftsn);
1207         /* purge the fragmentation queue */
1208         sctp_ulpq_reasm_flushtsn(ulpq, ftsn);
1209         /* Abort any in progress partial delivery. */
1210         sctp_ulpq_abort_pd(ulpq, GFP_ATOMIC);
1211 }
1212
1213 static void sctp_intl_reasm_flushtsn(struct sctp_ulpq *ulpq, __u32 ftsn)
1214 {
1215         struct sk_buff *pos, *tmp;
1216
1217         skb_queue_walk_safe(&ulpq->reasm, pos, tmp) {
1218                 struct sctp_ulpevent *event = sctp_skb2event(pos);
1219                 __u32 tsn = event->tsn;
1220
1221                 if (TSN_lte(tsn, ftsn)) {
1222                         __skb_unlink(pos, &ulpq->reasm);
1223                         sctp_ulpevent_free(event);
1224                 }
1225         }
1226
1227         skb_queue_walk_safe(&ulpq->reasm_uo, pos, tmp) {
1228                 struct sctp_ulpevent *event = sctp_skb2event(pos);
1229                 __u32 tsn = event->tsn;
1230
1231                 if (TSN_lte(tsn, ftsn)) {
1232                         __skb_unlink(pos, &ulpq->reasm_uo);
1233                         sctp_ulpevent_free(event);
1234                 }
1235         }
1236 }
1237
1238 static void sctp_report_iftsn(struct sctp_ulpq *ulpq, __u32 ftsn)
1239 {
1240         /* Move the Cumulattive TSN Ack ahead. */
1241         sctp_tsnmap_skip(&ulpq->asoc->peer.tsn_map, ftsn);
1242         /* purge the fragmentation queue */
1243         sctp_intl_reasm_flushtsn(ulpq, ftsn);
1244         /* abort only when it's for all data */
1245         if (ftsn == sctp_tsnmap_get_max_tsn_seen(&ulpq->asoc->peer.tsn_map))
1246                 sctp_intl_abort_pd(ulpq, GFP_ATOMIC);
1247 }
1248
1249 static void sctp_handle_fwdtsn(struct sctp_ulpq *ulpq, struct sctp_chunk *chunk)
1250 {
1251         struct sctp_fwdtsn_skip *skip;
1252
1253         /* Walk through all the skipped SSNs */
1254         sctp_walk_fwdtsn(skip, chunk)
1255                 sctp_ulpq_skip(ulpq, ntohs(skip->stream), ntohs(skip->ssn));
1256 }
1257
1258 static void sctp_intl_skip(struct sctp_ulpq *ulpq, __u16 sid, __u32 mid,
1259                            __u8 flags)
1260 {
1261         struct sctp_stream_in *sin = sctp_stream_in(&ulpq->asoc->stream, sid);
1262         struct sctp_stream *stream  = &ulpq->asoc->stream;
1263
1264         if (flags & SCTP_FTSN_U_BIT) {
1265                 if (sin->pd_mode_uo && MID_lt(sin->mid_uo, mid)) {
1266                         sin->pd_mode_uo = 0;
1267                         sctp_intl_stream_abort_pd(ulpq, sid, mid, 0x1,
1268                                                   GFP_ATOMIC);
1269                 }
1270                 return;
1271         }
1272
1273         if (MID_lt(mid, sctp_mid_peek(stream, in, sid)))
1274                 return;
1275
1276         if (sin->pd_mode) {
1277                 sin->pd_mode = 0;
1278                 sctp_intl_stream_abort_pd(ulpq, sid, mid, 0x0, GFP_ATOMIC);
1279         }
1280
1281         sctp_mid_skip(stream, in, sid, mid);
1282
1283         sctp_intl_reap_ordered(ulpq, sid);
1284 }
1285
1286 static void sctp_handle_iftsn(struct sctp_ulpq *ulpq, struct sctp_chunk *chunk)
1287 {
1288         struct sctp_ifwdtsn_skip *skip;
1289
1290         /* Walk through all the skipped MIDs and abort stream pd if possible */
1291         sctp_walk_ifwdtsn(skip, chunk)
1292                 sctp_intl_skip(ulpq, ntohs(skip->stream),
1293                                ntohl(skip->mid), skip->flags);
1294 }
1295
1296 static int do_ulpq_tail_event(struct sctp_ulpq *ulpq, struct sctp_ulpevent *event)
1297 {
1298         struct sk_buff_head temp;
1299
1300         skb_queue_head_init(&temp);
1301         __skb_queue_tail(&temp, sctp_event2skb(event));
1302         return sctp_ulpq_tail_event(ulpq, &temp);
1303 }
1304
1305 static struct sctp_stream_interleave sctp_stream_interleave_0 = {
1306         .data_chunk_len         = sizeof(struct sctp_data_chunk),
1307         .ftsn_chunk_len         = sizeof(struct sctp_fwdtsn_chunk),
1308         /* DATA process functions */
1309         .make_datafrag          = sctp_make_datafrag_empty,
1310         .assign_number          = sctp_chunk_assign_ssn,
1311         .validate_data          = sctp_validate_data,
1312         .ulpevent_data          = sctp_ulpq_tail_data,
1313         .enqueue_event          = do_ulpq_tail_event,
1314         .renege_events          = sctp_ulpq_renege,
1315         .start_pd               = sctp_ulpq_partial_delivery,
1316         .abort_pd               = sctp_ulpq_abort_pd,
1317         /* FORWARD-TSN process functions */
1318         .generate_ftsn          = sctp_generate_fwdtsn,
1319         .validate_ftsn          = sctp_validate_fwdtsn,
1320         .report_ftsn            = sctp_report_fwdtsn,
1321         .handle_ftsn            = sctp_handle_fwdtsn,
1322 };
1323
1324 static int do_sctp_enqueue_event(struct sctp_ulpq *ulpq,
1325                                  struct sctp_ulpevent *event)
1326 {
1327         struct sk_buff_head temp;
1328
1329         skb_queue_head_init(&temp);
1330         __skb_queue_tail(&temp, sctp_event2skb(event));
1331         return sctp_enqueue_event(ulpq, &temp);
1332 }
1333
1334 static struct sctp_stream_interleave sctp_stream_interleave_1 = {
1335         .data_chunk_len         = sizeof(struct sctp_idata_chunk),
1336         .ftsn_chunk_len         = sizeof(struct sctp_ifwdtsn_chunk),
1337         /* I-DATA process functions */
1338         .make_datafrag          = sctp_make_idatafrag_empty,
1339         .assign_number          = sctp_chunk_assign_mid,
1340         .validate_data          = sctp_validate_idata,
1341         .ulpevent_data          = sctp_ulpevent_idata,
1342         .enqueue_event          = do_sctp_enqueue_event,
1343         .renege_events          = sctp_renege_events,
1344         .start_pd               = sctp_intl_start_pd,
1345         .abort_pd               = sctp_intl_abort_pd,
1346         /* I-FORWARD-TSN process functions */
1347         .generate_ftsn          = sctp_generate_iftsn,
1348         .validate_ftsn          = sctp_validate_iftsn,
1349         .report_ftsn            = sctp_report_iftsn,
1350         .handle_ftsn            = sctp_handle_iftsn,
1351 };
1352
1353 void sctp_stream_interleave_init(struct sctp_stream *stream)
1354 {
1355         struct sctp_association *asoc;
1356
1357         asoc = container_of(stream, struct sctp_association, stream);
1358         stream->si = asoc->peer.intl_capable ? &sctp_stream_interleave_1
1359                                              : &sctp_stream_interleave_0;
1360 }