net/sctp/ulpqueue.c

   1 /* SCTP kernel reference Implementation
   2  * (C) Copyright IBM Corp. 2001, 2004
   3  * Copyright (c) 1999-2000 Cisco, Inc.
   4  * Copyright (c) 1999-2001 Motorola, Inc.
   5  * Copyright (c) 2001 Intel Corp.
   6  * Copyright (c) 2001 Nokia, Inc.
   7  * Copyright (c) 2001 La Monte H.P. Yarroll
   8  *
   9  * This abstraction carries sctp events to the ULP (sockets).
  10  *
  11  * The SCTP reference implementation is free software;
  12  * you can redistribute it and/or modify it under the terms of
  13  * the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2, or (at your option)
  15  * any later version.
  16  *
  17  * The SCTP reference implementation is distributed in the hope that it
  18  * will be useful, but WITHOUT ANY WARRANTY; without even the implied
  19  *                 ************************
  20  * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  21  * See the GNU General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU General Public License
  24  * along with GNU CC; see the file COPYING.  If not, write to
  25  * the Free Software Foundation, 59 Temple Place - Suite 330,
  26  * Boston, MA 02111-1307, USA.
  27  *
  28  * Please send any bug reports or fixes you make to the
  29  * email address(es):
  30  *    lksctp developers <lksctp-developers@lists.sourceforge.net>
  31  *
  32  * Or submit a bug report through the following website:
  33  *    http://www.sf.net/projects/lksctp
  34  *
  35  * Written or modified by:
  36  *    Jon Grimm             <jgrimm@us.ibm.com>
  37  *    La Monte H.P. Yarroll <piggy@acm.org>
  38  *    Sridhar Samudrala     <sri@us.ibm.com>
  39  *
  40  * Any bugs reported given to us we will try to fix... any fixes shared will
  41  * be incorporated into the next SCTP release.
  42  */
  43
  44 #include <linux/types.h>
  45 #include <linux/skbuff.h>
  46 #include <net/sock.h>
  47 #include <net/sctp/structs.h>
  48 #include <net/sctp/sctp.h>
  49 #include <net/sctp/sm.h>
  50
  51 /* Forward declarations for internal helpers.  */
  52 static struct sctp_ulpevent * sctp_ulpq_reasm(struct sctp_ulpq *ulpq,
  53                                                 struct sctp_ulpevent *);
  54 static struct sctp_ulpevent * sctp_ulpq_order(struct sctp_ulpq *,
  55                                                 struct sctp_ulpevent *);
  56
  57 /* 1st Level Abstractions */
  58
  59 /* Initialize a ULP queue from a block of memory.  */
  60 struct sctp_ulpq *sctp_ulpq_init(struct sctp_ulpq *ulpq,
  61                                  struct sctp_association *asoc)
  62 {
  63         memset(ulpq, 0, sizeof(struct sctp_ulpq));
  64
  65         ulpq->asoc = asoc;
  66         skb_queue_head_init(&ulpq->reasm);
  67         skb_queue_head_init(&ulpq->lobby);
  68         ulpq->pd_mode  = 0;
  69         ulpq->malloced = 0;
  70
  71         return ulpq;
  72 }
  73
  74
  75 /* Flush the reassembly and ordering queues.  */
  76 static void sctp_ulpq_flush(struct sctp_ulpq *ulpq)
  77 {
  78         struct sk_buff *skb;
  79         struct sctp_ulpevent *event;
  80
  81         while ((skb = __skb_dequeue(&ulpq->lobby)) != NULL) {
  82                 event = sctp_skb2event(skb);
  83                 sctp_ulpevent_free(event);
  84         }
  85
  86         while ((skb = __skb_dequeue(&ulpq->reasm)) != NULL) {
  87                 event = sctp_skb2event(skb);
  88                 sctp_ulpevent_free(event);
  89         }
  90
  91 }
  92
  93 /* Dispose of a ulpqueue.  */
  94 void sctp_ulpq_free(struct sctp_ulpq *ulpq)
  95 {
  96         sctp_ulpq_flush(ulpq);
  97         if (ulpq->malloced)
  98                 kfree(ulpq);
  99 }
 100
 101 /* Process an incoming DATA chunk.  */
 102 int sctp_ulpq_tail_data(struct sctp_ulpq *ulpq, struct sctp_chunk *chunk,
 103                         int gfp)
 104 {
 105         struct sk_buff_head temp;
 106         sctp_data_chunk_t *hdr;
 107         struct sctp_ulpevent *event;
 108
 109         hdr = (sctp_data_chunk_t *) chunk->chunk_hdr;
 110
 111         /* Create an event from the incoming chunk. */
 112         event = sctp_ulpevent_make_rcvmsg(chunk->asoc, chunk, gfp);
 113         if (!event)
 114                 return -ENOMEM;
 115
 116         /* Do reassembly if needed.  */
 117         event = sctp_ulpq_reasm(ulpq, event);
 118
 119         /* Do ordering if needed.  */
 120         if ((event) && (event->msg_flags & MSG_EOR)){
 121                 /* Create a temporary list to collect chunks on.  */
 122                 skb_queue_head_init(&temp);
 123                 __skb_queue_tail(&temp, sctp_event2skb(event));
 124
 125                 event = sctp_ulpq_order(ulpq, event);
 126         }
 127
 128         /* Send event to the ULP.  */
 129         if (event)
 130                 sctp_ulpq_tail_event(ulpq, event);
 131
 132         return 0;
 133 }
 134
 135 /* Add a new event for propagation to the ULP.  */
 136 /* Clear the partial delivery mode for this socket.   Note: This
 137  * assumes that no association is currently in partial delivery mode.
 138  */
 139 int sctp_clear_pd(struct sock *sk)
 140 {
 141         struct sctp_sock *sp = sctp_sk(sk);
 142
 143         sp->pd_mode = 0;
 144         if (!skb_queue_empty(&sp->pd_lobby)) {
 145                 struct list_head *list;
 146                 sctp_skb_list_tail(&sp->pd_lobby, &sk->sk_receive_queue);
 147                 list = (struct list_head *)&sctp_sk(sk)->pd_lobby;
 148                 INIT_LIST_HEAD(list);
 149                 return 1;
 150         }
 151         return 0;
 152 }
 153
 154 /* Clear the pd_mode and restart any pending messages waiting for delivery. */
 155 static int sctp_ulpq_clear_pd(struct sctp_ulpq *ulpq)
 156 {
 157         ulpq->pd_mode = 0;
 158         return sctp_clear_pd(ulpq->asoc->base.sk);
 159 }
 160
 161
 162
 163 int sctp_ulpq_tail_event(struct sctp_ulpq *ulpq, struct sctp_ulpevent *event)
 164 {
 165         struct sock *sk = ulpq->asoc->base.sk;
 166         struct sk_buff_head *queue;
 167         int clear_pd = 0;
 168
 169         /* If the socket is just going to throw this away, do not
 170          * even try to deliver it.
 171          */
 172         if (sock_flag(sk, SOCK_DEAD) || (sk->sk_shutdown & RCV_SHUTDOWN))
 173                 goto out_free;
 174
 175         /* Check if the user wishes to receive this event.  */
 176         if (!sctp_ulpevent_is_enabled(event, &sctp_sk(sk)->subscribe))
 177                 goto out_free;
 178
 179         /* If we are in partial delivery mode, post to the lobby until
 180          * partial delivery is cleared, unless, of course _this_ is
 181          * the association the cause of the partial delivery.
 182          */
 183
 184         if (!sctp_sk(sk)->pd_mode) {
 185                 queue = &sk->sk_receive_queue;
 186         } else if (ulpq->pd_mode) {
 187                 if (event->msg_flags & MSG_NOTIFICATION)
 188                         queue = &sctp_sk(sk)->pd_lobby;
 189                 else {
 190                         clear_pd = event->msg_flags & MSG_EOR;
 191                         queue = &sk->sk_receive_queue;
 192                 }
 193         } else
 194                 queue = &sctp_sk(sk)->pd_lobby;
 195
 196
 197         /* If we are harvesting multiple skbs they will be
 198          * collected on a list.
 199          */
 200         if (sctp_event2skb(event)->list)
 201                 sctp_skb_list_tail(sctp_event2skb(event)->list, queue);
 202         else
 203                 __skb_queue_tail(queue, sctp_event2skb(event));
 204
 205         /* Did we just complete partial delivery and need to get
 206          * rolling again?  Move pending data to the receive
 207          * queue.
 208          */
 209         if (clear_pd)
 210                 sctp_ulpq_clear_pd(ulpq);
 211
 212         if (queue == &sk->sk_receive_queue)
 213                 sk->sk_data_ready(sk, 0);
 214         return 1;
 215
 216 out_free:
 217         if (sctp_event2skb(event)->list)
 218                 sctp_queue_purge_ulpevents(sctp_event2skb(event)->list);
 219         else
 220                 sctp_ulpevent_free(event);
 221         return 0;
 222 }
 223
 224 /* 2nd Level Abstractions */
 225
 226 /* Helper function to store chunks that need to be reassembled.  */
 227 static inline void sctp_ulpq_store_reasm(struct sctp_ulpq *ulpq,
 228                                          struct sctp_ulpevent *event)
 229 {
 230         struct sk_buff *pos;
 231         struct sctp_ulpevent *cevent;
 232         __u32 tsn, ctsn;
 233
 234         tsn = event->tsn;
 235
 236         /* See if it belongs at the end. */
 237         pos = skb_peek_tail(&ulpq->reasm);
 238         if (!pos) {
 239                 __skb_queue_tail(&ulpq->reasm, sctp_event2skb(event));
 240                 return;
 241         }
 242
 243         /* Short circuit just dropping it at the end. */
 244         cevent = sctp_skb2event(pos);
 245         ctsn = cevent->tsn;
 246         if (TSN_lt(ctsn, tsn)) {
 247                 __skb_queue_tail(&ulpq->reasm, sctp_event2skb(event));
 248                 return;
 249         }
 250
 251         /* Find the right place in this list. We store them by TSN.  */
 252         skb_queue_walk(&ulpq->reasm, pos) {
 253                 cevent = sctp_skb2event(pos);
 254                 ctsn = cevent->tsn;
 255
 256                 if (TSN_lt(tsn, ctsn))
 257                         break;
 258         }
 259
 260         /* Insert before pos. */
 261         __skb_insert(sctp_event2skb(event), pos->prev, pos, &ulpq->reasm);
 262
 263 }
 264
 265 /* Helper function to return an event corresponding to the reassembled
 266  * datagram.
 267  * This routine creates a re-assembled skb given the first and last skb's
 268  * as stored in the reassembly queue. The skb's may be non-linear if the sctp
 269  * payload was fragmented on the way and ip had to reassemble them.
 270  * We add the rest of skb's to the first skb's fraglist.
 271  */
 272 static struct sctp_ulpevent *sctp_make_reassembled_event(struct sk_buff *f_frag, struct sk_buff *l_frag)
 273 {
 274         struct sk_buff *pos;
 275         struct sctp_ulpevent *event;
 276         struct sk_buff *pnext, *last;
 277         struct sk_buff *list = skb_shinfo(f_frag)->frag_list;
 278
 279         /* Store the pointer to the 2nd skb */
 280         if (f_frag == l_frag)
 281                 pos = NULL;
 282         else
 283                 pos = f_frag->next;
 284
 285         /* Get the last skb in the f_frag's frag_list if present. */
 286         for (last = list; list; last = list, list = list->next);
 287
 288         /* Add the list of remaining fragments to the first fragments
 289          * frag_list.
 290          */
 291         if (last)
 292                 last->next = pos;
 293         else
 294                 skb_shinfo(f_frag)->frag_list = pos;
 295
 296         /* Remove the first fragment from the reassembly queue.  */
 297         __skb_unlink(f_frag, f_frag->list);
 298         while (pos) {
 299
 300                 pnext = pos->next;
 301
 302                 /* Update the len and data_len fields of the first fragment. */
 303                 f_frag->len += pos->len;
 304                 f_frag->data_len += pos->len;
 305
 306                 /* Remove the fragment from the reassembly queue.  */
 307                 __skb_unlink(pos, pos->list);
 308
 309                 /* Break if we have reached the last fragment.  */
 310                 if (pos == l_frag)
 311                         break;
 312                 pos->next = pnext;
 313                 pos = pnext;
 314         };
 315
 316         event = sctp_skb2event(f_frag);
 317         SCTP_INC_STATS(SCTP_MIB_REASMUSRMSGS);
 318
 319         return event;
 320 }
 321
 322
 323 /* Helper function to check if an incoming chunk has filled up the last
 324  * missing fragment in a SCTP datagram and return the corresponding event.
 325  */
 326 static inline struct sctp_ulpevent *sctp_ulpq_retrieve_reassembled(struct sctp_ulpq *ulpq)
 327 {
 328         struct sk_buff *pos;
 329         struct sctp_ulpevent *cevent;
 330         struct sk_buff *first_frag = NULL;
 331         __u32 ctsn, next_tsn;
 332         struct sctp_ulpevent *retval = NULL;
 333
 334         /* Initialized to 0 just to avoid compiler warning message.  Will
 335          * never be used with this value. It is referenced only after it
 336          * is set when we find the first fragment of a message.
 337          */
 338         next_tsn = 0;
 339
 340         /* The chunks are held in the reasm queue sorted by TSN.
 341          * Walk through the queue sequentially and look for a sequence of
 342          * fragmented chunks that complete a datagram.
 343          * 'first_frag' and next_tsn are reset when we find a chunk which
 344          * is the first fragment of a datagram. Once these 2 fields are set
 345          * we expect to find the remaining middle fragments and the last
 346          * fragment in order. If not, first_frag is reset to NULL and we
 347          * start the next pass when we find another first fragment.
 348          */
 349         skb_queue_walk(&ulpq->reasm, pos) {
 350                 cevent = sctp_skb2event(pos);
 351                 ctsn = cevent->tsn;
 352
 353                 switch (cevent->msg_flags & SCTP_DATA_FRAG_MASK) {
 354                 case SCTP_DATA_FIRST_FRAG:
 355                         first_frag = pos;
 356                         next_tsn = ctsn + 1;
 357                         break;
 358
 359                 case SCTP_DATA_MIDDLE_FRAG:
 360                         if ((first_frag) && (ctsn == next_tsn))
 361                                 next_tsn++;
 362                         else
 363                                 first_frag = NULL;
 364                         break;
 365
 366                 case SCTP_DATA_LAST_FRAG:
 367                         if (first_frag && (ctsn == next_tsn))
 368                                 goto found;
 369                         else
 370                                 first_frag = NULL;
 371                         break;
 372                 };
 373
 374         }
 375 done:
 376         return retval;
 377 found:
 378         retval = sctp_make_reassembled_event(first_frag, pos);
 379         if (retval)
 380                 retval->msg_flags |= MSG_EOR;
 381         goto done;
 382 }
 383
 384 /* Retrieve the next set of fragments of a partial message. */
 385 static inline struct sctp_ulpevent *sctp_ulpq_retrieve_partial(struct sctp_ulpq *ulpq)
 386 {
 387         struct sk_buff *pos, *last_frag, *first_frag;
 388         struct sctp_ulpevent *cevent;
 389         __u32 ctsn, next_tsn;
 390         int is_last;
 391         struct sctp_ulpevent *retval;
 392
 393         /* The chunks are held in the reasm queue sorted by TSN.
 394          * Walk through the queue sequentially and look for the first
 395          * sequence of fragmented chunks.
 396          */
 397
 398         if (skb_queue_empty(&ulpq->reasm))
 399                 return NULL;
 400
 401         last_frag = first_frag = NULL;
 402         retval = NULL;
 403         next_tsn = 0;
 404         is_last = 0;
 405
 406         skb_queue_walk(&ulpq->reasm, pos) {
 407                 cevent = sctp_skb2event(pos);
 408                 ctsn = cevent->tsn;
 409
 410                 switch (cevent->msg_flags & SCTP_DATA_FRAG_MASK) {
 411                 case SCTP_DATA_MIDDLE_FRAG:
 412                         if (!first_frag) {
 413                                 first_frag = pos;
 414                                 next_tsn = ctsn + 1;
 415                                 last_frag = pos;
 416                         } else if (next_tsn == ctsn)
 417                                 next_tsn++;
 418                         else
 419                                 goto done;
 420                         break;
 421                 case SCTP_DATA_LAST_FRAG:
 422                         if (!first_frag)
 423                                 first_frag = pos;
 424                         else if (ctsn != next_tsn)
 425                                 goto done;
 426                         last_frag = pos;
 427                         is_last = 1;
 428                         goto done;
 429                 default:
 430                         return NULL;
 431                 };
 432         }
 433
 434         /* We have the reassembled event. There is no need to look
 435          * further.
 436          */
 437 done:
 438         retval = sctp_make_reassembled_event(first_frag, last_frag);
 439         if (retval && is_last)
 440                 retval->msg_flags |= MSG_EOR;
 441
 442         return retval;
 443 }
 444
 445
 446 /* Helper function to reassemble chunks.  Hold chunks on the reasm queue that
 447  * need reassembling.
 448  */
 449 static struct sctp_ulpevent *sctp_ulpq_reasm(struct sctp_ulpq *ulpq,
 450                                                 struct sctp_ulpevent *event)
 451 {
 452         struct sctp_ulpevent *retval = NULL;
 453
 454         /* Check if this is part of a fragmented message.  */
 455         if (SCTP_DATA_NOT_FRAG == (event->msg_flags & SCTP_DATA_FRAG_MASK)) {
 456                 event->msg_flags |= MSG_EOR;
 457                 return event;
 458         }
 459
 460         sctp_ulpq_store_reasm(ulpq, event);
 461         if (!ulpq->pd_mode)
 462                 retval = sctp_ulpq_retrieve_reassembled(ulpq);
 463         else {
 464                 __u32 ctsn, ctsnap;
 465
 466                 /* Do not even bother unless this is the next tsn to
 467                  * be delivered.
 468                  */
 469                 ctsn = event->tsn;
 470                 ctsnap = sctp_tsnmap_get_ctsn(&ulpq->asoc->peer.tsn_map);
 471                 if (TSN_lte(ctsn, ctsnap))
 472                         retval = sctp_ulpq_retrieve_partial(ulpq);
 473         }
 474
 475         return retval;
 476 }
 477
 478 /* Retrieve the first part (sequential fragments) for partial delivery.  */
 479 static inline struct sctp_ulpevent *sctp_ulpq_retrieve_first(struct sctp_ulpq *ulpq)
 480 {
 481         struct sk_buff *pos, *last_frag, *first_frag;
 482         struct sctp_ulpevent *cevent;
 483         __u32 ctsn, next_tsn;
 484         struct sctp_ulpevent *retval;
 485
 486         /* The chunks are held in the reasm queue sorted by TSN.
 487          * Walk through the queue sequentially and look for a sequence of
 488          * fragmented chunks that start a datagram.
 489          */
 490
 491         if (skb_queue_empty(&ulpq->reasm))
 492                 return NULL;
 493
 494         last_frag = first_frag = NULL;
 495         retval = NULL;
 496         next_tsn = 0;
 497
 498         skb_queue_walk(&ulpq->reasm, pos) {
 499                 cevent = sctp_skb2event(pos);
 500                 ctsn = cevent->tsn;
 501
 502                 switch (cevent->msg_flags & SCTP_DATA_FRAG_MASK) {
 503                 case SCTP_DATA_FIRST_FRAG:
 504                         if (!first_frag) {
 505                                 first_frag = pos;
 506                                 next_tsn = ctsn + 1;
 507                                 last_frag = pos;
 508                         } else
 509                                 goto done;
 510                         break;
 511
 512                 case SCTP_DATA_MIDDLE_FRAG:
 513                         if (!first_frag)
 514                                 return NULL;
 515                         if (ctsn == next_tsn) {
 516                                 next_tsn++;
 517                                 last_frag = pos;
 518                         } else
 519                                 goto done;
 520                         break;
 521                 default:
 522                         return NULL;
 523                 };
 524         }
 525
 526         /* We have the reassembled event. There is no need to look
 527          * further.
 528          */
 529 done:
 530         retval = sctp_make_reassembled_event(first_frag, last_frag);
 531         return retval;
 532 }
 533
 534 /* Helper function to gather skbs that have possibly become
 535  * ordered by an an incoming chunk.
 536  */
 537 static inline void sctp_ulpq_retrieve_ordered(struct sctp_ulpq *ulpq,
 538                                               struct sctp_ulpevent *event)
 539 {
 540         struct sk_buff *pos, *tmp;
 541         struct sctp_ulpevent *cevent;
 542         struct sctp_stream *in;
 543         __u16 sid, csid;
 544         __u16 ssn, cssn;
 545
 546         sid = event->stream;
 547         ssn = event->ssn;
 548         in  = &ulpq->asoc->ssnmap->in;
 549
 550         /* We are holding the chunks by stream, by SSN.  */
 551         sctp_skb_for_each(pos, &ulpq->lobby, tmp) {
 552                 cevent = (struct sctp_ulpevent *) pos->cb;
 553                 csid = cevent->stream;
 554                 cssn = cevent->ssn;
 555
 556                 /* Have we gone too far?  */
 557                 if (csid > sid)
 558                         break;
 559
 560                 /* Have we not gone far enough?  */
 561                 if (csid < sid)
 562                         continue;
 563
 564                 if (cssn != sctp_ssn_peek(in, sid))
 565                         break;
 566
 567                 /* Found it, so mark in the ssnmap. */
 568                 sctp_ssn_next(in, sid);
 569
 570                 __skb_unlink(pos, pos->list);
 571
 572                 /* Attach all gathered skbs to the event.  */
 573                 __skb_queue_tail(sctp_event2skb(event)->list, pos);
 574         }
 575 }
 576
 577 /* Helper function to store chunks needing ordering.  */
 578 static inline void sctp_ulpq_store_ordered(struct sctp_ulpq *ulpq,
 579                                            struct sctp_ulpevent *event)
 580 {
 581         struct sk_buff *pos;
 582         struct sctp_ulpevent *cevent;
 583         __u16 sid, csid;
 584         __u16 ssn, cssn;
 585
 586         pos = skb_peek_tail(&ulpq->lobby);
 587         if (!pos) {
 588                 __skb_queue_tail(&ulpq->lobby, sctp_event2skb(event));
 589                 return;
 590         }
 591
 592         sid = event->stream;
 593         ssn = event->ssn;
 594
 595         cevent = (struct sctp_ulpevent *) pos->cb;
 596         csid = cevent->stream;
 597         cssn = cevent->ssn;
 598         if (sid > csid) {
 599                 __skb_queue_tail(&ulpq->lobby, sctp_event2skb(event));
 600                 return;
 601         }
 602
 603         if ((sid == csid) && SSN_lt(cssn, ssn)) {
 604                 __skb_queue_tail(&ulpq->lobby, sctp_event2skb(event));
 605                 return;
 606         }
 607
 608         /* Find the right place in this list.  We store them by
 609          * stream ID and then by SSN.
 610          */
 611         skb_queue_walk(&ulpq->lobby, pos) {
 612                 cevent = (struct sctp_ulpevent *) pos->cb;
 613                 csid = cevent->stream;
 614                 cssn = cevent->ssn;
 615
 616                 if (csid > sid)
 617                         break;
 618                 if (csid == sid && SSN_lt(ssn, cssn))
 619                         break;
 620         }
 621
 622
 623         /* Insert before pos. */
 624         __skb_insert(sctp_event2skb(event), pos->prev, pos, &ulpq->lobby);
 625
 626 }
 627
 628 static struct sctp_ulpevent *sctp_ulpq_order(struct sctp_ulpq *ulpq,
 629                                                 struct sctp_ulpevent *event)
 630 {
 631         __u16 sid, ssn;
 632         struct sctp_stream *in;
 633
 634         /* Check if this message needs ordering.  */
 635         if (SCTP_DATA_UNORDERED & event->msg_flags)
 636                 return event;
 637
 638         /* Note: The stream ID must be verified before this routine.  */
 639         sid = event->stream;
 640         ssn = event->ssn;
 641         in  = &ulpq->asoc->ssnmap->in;
 642
 643         /* Is this the expected SSN for this stream ID?  */
 644         if (ssn != sctp_ssn_peek(in, sid)) {
 645                 /* We've received something out of order, so find where it
 646                  * needs to be placed.  We order by stream and then by SSN.
 647                  */
 648                 sctp_ulpq_store_ordered(ulpq, event);
 649                 return NULL;
 650         }
 651
 652         /* Mark that the next chunk has been found.  */
 653         sctp_ssn_next(in, sid);
 654
 655         /* Go find any other chunks that were waiting for
 656          * ordering.
 657          */
 658         sctp_ulpq_retrieve_ordered(ulpq, event);
 659
 660         return event;
 661 }
 662
 663 /* Helper function to gather skbs that have possibly become
 664  * ordered by forward tsn skipping their dependencies.
 665  */
 666 static inline void sctp_ulpq_reap_ordered(struct sctp_ulpq *ulpq)
 667 {
 668         struct sk_buff *pos, *tmp;
 669         struct sctp_ulpevent *cevent;
 670         struct sctp_ulpevent *event = NULL;
 671         struct sctp_stream *in;
 672         struct sk_buff_head temp;
 673         __u16 csid, cssn;
 674
 675         in  = &ulpq->asoc->ssnmap->in;
 676
 677         /* We are holding the chunks by stream, by SSN.  */
 678         sctp_skb_for_each(pos, &ulpq->lobby, tmp) {
 679                 cevent = (struct sctp_ulpevent *) pos->cb;
 680                 csid = cevent->stream;
 681                 cssn = cevent->ssn;
 682
 683                 if (cssn != sctp_ssn_peek(in, csid))
 684                         break;
 685
 686                 /* Found it, so mark in the ssnmap. */
 687                 sctp_ssn_next(in, csid);
 688
 689                 __skb_unlink(pos, pos->list);
 690                 if (!event) {
 691                         /* Create a temporary list to collect chunks on.  */
 692                         event = sctp_skb2event(pos);
 693                         skb_queue_head_init(&temp);
 694                         __skb_queue_tail(&temp, sctp_event2skb(event));
 695                 } else {
 696                         /* Attach all gathered skbs to the event.  */
 697                         __skb_queue_tail(sctp_event2skb(event)->list, pos);
 698                 }
 699         }
 700
 701         /* Send event to the ULP.  */
 702         if (event)
 703                 sctp_ulpq_tail_event(ulpq, event);
 704 }
 705
 706 /* Skip over an SSN. */
 707 void sctp_ulpq_skip(struct sctp_ulpq *ulpq, __u16 sid, __u16 ssn)
 708 {
 709         struct sctp_stream *in;
 710
 711         /* Note: The stream ID must be verified before this routine.  */
 712         in  = &ulpq->asoc->ssnmap->in;
 713
 714         /* Is this an old SSN?  If so ignore. */
 715         if (SSN_lt(ssn, sctp_ssn_peek(in, sid)))
 716                 return;
 717
 718         /* Mark that we are no longer expecting this SSN or lower. */
 719         sctp_ssn_skip(in, sid, ssn);
 720
 721         /* Go find any other chunks that were waiting for
 722          * ordering and deliver them if needed.
 723          */
 724         sctp_ulpq_reap_ordered(ulpq);
 725         return;
 726 }
 727
 728 /* Renege 'needed' bytes from the ordering queue. */
 729 static __u16 sctp_ulpq_renege_order(struct sctp_ulpq *ulpq, __u16 needed)
 730 {
 731         __u16 freed = 0;
 732         __u32 tsn;
 733         struct sk_buff *skb;
 734         struct sctp_ulpevent *event;
 735         struct sctp_tsnmap *tsnmap;
 736
 737         tsnmap = &ulpq->asoc->peer.tsn_map;
 738
 739         while ((skb = __skb_dequeue_tail(&ulpq->lobby)) != NULL) {
 740                 freed += skb_headlen(skb);
 741                 event = sctp_skb2event(skb);
 742                 tsn = event->tsn;
 743
 744                 sctp_ulpevent_free(event);
 745                 sctp_tsnmap_renege(tsnmap, tsn);
 746                 if (freed >= needed)
 747                         return freed;
 748         }
 749
 750         return freed;
 751 }
 752
 753 /* Renege 'needed' bytes from the reassembly queue. */
 754 static __u16 sctp_ulpq_renege_frags(struct sctp_ulpq *ulpq, __u16 needed)
 755 {
 756         __u16 freed = 0;
 757         __u32 tsn;
 758         struct sk_buff *skb;
 759         struct sctp_ulpevent *event;
 760         struct sctp_tsnmap *tsnmap;
 761
 762         tsnmap = &ulpq->asoc->peer.tsn_map;
 763
 764         /* Walk backwards through the list, reneges the newest tsns. */
 765         while ((skb = __skb_dequeue_tail(&ulpq->reasm)) != NULL) {
 766                 freed += skb_headlen(skb);
 767                 event = sctp_skb2event(skb);
 768                 tsn = event->tsn;
 769
 770                 sctp_ulpevent_free(event);
 771                 sctp_tsnmap_renege(tsnmap, tsn);
 772                 if (freed >= needed)
 773                         return freed;
 774         }
 775
 776         return freed;
 777 }
 778
 779 /* Partial deliver the first message as there is pressure on rwnd. */
 780 void sctp_ulpq_partial_delivery(struct sctp_ulpq *ulpq,
 781                                 struct sctp_chunk *chunk, int gfp)
 782 {
 783         struct sctp_ulpevent *event;
 784         struct sctp_association *asoc;
 785
 786         asoc = ulpq->asoc;
 787
 788         /* Are we already in partial delivery mode?  */
 789         if (!sctp_sk(asoc->base.sk)->pd_mode) {
 790
 791                 /* Is partial delivery possible?  */
 792                 event = sctp_ulpq_retrieve_first(ulpq);
 793                 /* Send event to the ULP.   */
 794                 if (event) {
 795                         sctp_ulpq_tail_event(ulpq, event);
 796                         sctp_sk(asoc->base.sk)->pd_mode = 1;
 797                         ulpq->pd_mode = 1;
 798                         return;
 799                 }
 800         }
 801 }
 802
 803 /* Renege some packets to make room for an incoming chunk.  */
 804 void sctp_ulpq_renege(struct sctp_ulpq *ulpq, struct sctp_chunk *chunk,
 805                       int gfp)
 806 {
 807         struct sctp_association *asoc;
 808         __u16 needed, freed;
 809
 810         asoc = ulpq->asoc;
 811
 812         if (chunk) {
 813                 needed = ntohs(chunk->chunk_hdr->length);
 814                 needed -= sizeof(sctp_data_chunk_t);
 815         } else
 816                 needed = SCTP_DEFAULT_MAXWINDOW;
 817
 818         freed = 0;
 819
 820         if (skb_queue_empty(&asoc->base.sk->sk_receive_queue)) {
 821                 freed = sctp_ulpq_renege_order(ulpq, needed);
 822                 if (freed < needed) {
 823                         freed += sctp_ulpq_renege_frags(ulpq, needed - freed);
 824                 }
 825         }
 826         /* If able to free enough room, accept this chunk. */
 827         if (chunk && (freed >= needed)) {
 828                 __u32 tsn;
 829                 tsn = ntohl(chunk->subh.data_hdr->tsn);
 830                 sctp_tsnmap_mark(&asoc->peer.tsn_map, tsn);
 831                 sctp_ulpq_tail_data(ulpq, chunk, gfp);
 832
 833                 sctp_ulpq_partial_delivery(ulpq, chunk, gfp);
 834         }
 835
 836         return;
 837 }
 838
 839
 840
 841 /* Notify the application if an association is aborted and in
 842  * partial delivery mode.  Send up any pending received messages.
 843  */
 844 void sctp_ulpq_abort_pd(struct sctp_ulpq *ulpq, int gfp)
 845 {
 846         struct sctp_ulpevent *ev = NULL;
 847         struct sock *sk;
 848
 849         if (!ulpq->pd_mode)
 850                 return;
 851
 852         sk = ulpq->asoc->base.sk;
 853         if (sctp_ulpevent_type_enabled(SCTP_PARTIAL_DELIVERY_EVENT,
 854                                        &sctp_sk(sk)->subscribe))
 855                 ev = sctp_ulpevent_make_pdapi(ulpq->asoc,
 856                                               SCTP_PARTIAL_DELIVERY_ABORTED,
 857                                               gfp);
 858         if (ev)
 859                 __skb_queue_tail(&sk->sk_receive_queue, sctp_event2skb(ev));
 860
 861         /* If there is data waiting, send it up the socket now. */
 862         if (sctp_ulpq_clear_pd(ulpq) || ev)
 863                 sk->sk_data_ready(sk, 0);
 864 }