net/sctp/stream_interleave.c

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