[NET]: Kill skb->list
[linux-3.10.git] / 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                         unsigned int __nocast 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.  'event' is the sctp_ulpevent for
129          * very first SKB on the 'temp' list.
130          */
131         if (event)
132                 sctp_ulpq_tail_event(ulpq, event);
133
134         return 0;
135 }
136
137 /* Add a new event for propagation to the ULP.  */
138 /* Clear the partial delivery mode for this socket.   Note: This
139  * assumes that no association is currently in partial delivery mode.
140  */
141 int sctp_clear_pd(struct sock *sk)
142 {
143         struct sctp_sock *sp = sctp_sk(sk);
144
145         sp->pd_mode = 0;
146         if (!skb_queue_empty(&sp->pd_lobby)) {
147                 struct list_head *list;
148                 sctp_skb_list_tail(&sp->pd_lobby, &sk->sk_receive_queue);
149                 list = (struct list_head *)&sctp_sk(sk)->pd_lobby;
150                 INIT_LIST_HEAD(list);
151                 return 1;
152         }
153         return 0;
154 }
155
156 /* Clear the pd_mode and restart any pending messages waiting for delivery. */
157 static int sctp_ulpq_clear_pd(struct sctp_ulpq *ulpq)
158 {
159         ulpq->pd_mode = 0;
160         return sctp_clear_pd(ulpq->asoc->base.sk);
161 }
162
163 /* If the SKB of 'event' is on a list, it is the first such member
164  * of that list.
165  */
166 int sctp_ulpq_tail_event(struct sctp_ulpq *ulpq, struct sctp_ulpevent *event)
167 {
168         struct sock *sk = ulpq->asoc->base.sk;
169         struct sk_buff_head *queue, *skb_list;
170         struct sk_buff *skb = sctp_event2skb(event);
171         int clear_pd = 0;
172
173         skb_list = (struct sk_buff_head *) skb->prev;
174
175         /* If the socket is just going to throw this away, do not
176          * even try to deliver it.
177          */
178         if (sock_flag(sk, SOCK_DEAD) || (sk->sk_shutdown & RCV_SHUTDOWN))
179                 goto out_free;
180
181         /* Check if the user wishes to receive this event.  */
182         if (!sctp_ulpevent_is_enabled(event, &sctp_sk(sk)->subscribe))
183                 goto out_free;
184
185         /* If we are in partial delivery mode, post to the lobby until
186          * partial delivery is cleared, unless, of course _this_ is
187          * the association the cause of the partial delivery.
188          */
189
190         if (!sctp_sk(sk)->pd_mode) {
191                 queue = &sk->sk_receive_queue;
192         } else if (ulpq->pd_mode) {
193                 if (event->msg_flags & MSG_NOTIFICATION)
194                         queue = &sctp_sk(sk)->pd_lobby;
195                 else {
196                         clear_pd = event->msg_flags & MSG_EOR;
197                         queue = &sk->sk_receive_queue;
198                 }
199         } else
200                 queue = &sctp_sk(sk)->pd_lobby;
201
202
203         /* If we are harvesting multiple skbs they will be
204          * collected on a list.
205          */
206         if (skb_list)
207                 sctp_skb_list_tail(skb_list, queue);
208         else
209                 __skb_queue_tail(queue, skb);
210
211         /* Did we just complete partial delivery and need to get
212          * rolling again?  Move pending data to the receive
213          * queue.
214          */
215         if (clear_pd)
216                 sctp_ulpq_clear_pd(ulpq);
217
218         if (queue == &sk->sk_receive_queue)
219                 sk->sk_data_ready(sk, 0);
220         return 1;
221
222 out_free:
223         if (skb_list)
224                 sctp_queue_purge_ulpevents(skb_list);
225         else
226                 sctp_ulpevent_free(event);
227
228         return 0;
229 }
230
231 /* 2nd Level Abstractions */
232
233 /* Helper function to store chunks that need to be reassembled.  */
234 static inline void sctp_ulpq_store_reasm(struct sctp_ulpq *ulpq,
235                                          struct sctp_ulpevent *event)
236 {
237         struct sk_buff *pos;
238         struct sctp_ulpevent *cevent;
239         __u32 tsn, ctsn;
240
241         tsn = event->tsn;
242
243         /* See if it belongs at the end. */
244         pos = skb_peek_tail(&ulpq->reasm);
245         if (!pos) {
246                 __skb_queue_tail(&ulpq->reasm, sctp_event2skb(event));
247                 return;
248         }
249
250         /* Short circuit just dropping it at the end. */
251         cevent = sctp_skb2event(pos);
252         ctsn = cevent->tsn;
253         if (TSN_lt(ctsn, tsn)) {
254                 __skb_queue_tail(&ulpq->reasm, sctp_event2skb(event));
255                 return;
256         }
257
258         /* Find the right place in this list. We store them by TSN.  */
259         skb_queue_walk(&ulpq->reasm, pos) {
260                 cevent = sctp_skb2event(pos);
261                 ctsn = cevent->tsn;
262
263                 if (TSN_lt(tsn, ctsn))
264                         break;
265         }
266
267         /* Insert before pos. */
268         __skb_insert(sctp_event2skb(event), pos->prev, pos, &ulpq->reasm);
269
270 }
271
272 /* Helper function to return an event corresponding to the reassembled
273  * datagram.
274  * This routine creates a re-assembled skb given the first and last skb's
275  * as stored in the reassembly queue. The skb's may be non-linear if the sctp
276  * payload was fragmented on the way and ip had to reassemble them.
277  * We add the rest of skb's to the first skb's fraglist.
278  */
279 static struct sctp_ulpevent *sctp_make_reassembled_event(struct sk_buff_head *queue, struct sk_buff *f_frag, struct sk_buff *l_frag)
280 {
281         struct sk_buff *pos;
282         struct sctp_ulpevent *event;
283         struct sk_buff *pnext, *last;
284         struct sk_buff *list = skb_shinfo(f_frag)->frag_list;
285
286         /* Store the pointer to the 2nd skb */
287         if (f_frag == l_frag)
288                 pos = NULL;
289         else
290                 pos = f_frag->next;
291
292         /* Get the last skb in the f_frag's frag_list if present. */
293         for (last = list; list; last = list, list = list->next);
294
295         /* Add the list of remaining fragments to the first fragments
296          * frag_list.
297          */
298         if (last)
299                 last->next = pos;
300         else
301                 skb_shinfo(f_frag)->frag_list = pos;
302
303         /* Remove the first fragment from the reassembly queue.  */
304         __skb_unlink(f_frag, queue);
305         while (pos) {
306
307                 pnext = pos->next;
308
309                 /* Update the len and data_len fields of the first fragment. */
310                 f_frag->len += pos->len;
311                 f_frag->data_len += pos->len;
312
313                 /* Remove the fragment from the reassembly queue.  */
314                 __skb_unlink(pos, queue);
315         
316                 /* Break if we have reached the last fragment.  */
317                 if (pos == l_frag)
318                         break;
319                 pos->next = pnext;
320                 pos = pnext;
321         };
322
323         event = sctp_skb2event(f_frag);
324         SCTP_INC_STATS(SCTP_MIB_REASMUSRMSGS);
325
326         return event;
327 }
328
329
330 /* Helper function to check if an incoming chunk has filled up the last
331  * missing fragment in a SCTP datagram and return the corresponding event.
332  */
333 static inline struct sctp_ulpevent *sctp_ulpq_retrieve_reassembled(struct sctp_ulpq *ulpq)
334 {
335         struct sk_buff *pos;
336         struct sctp_ulpevent *cevent;
337         struct sk_buff *first_frag = NULL;
338         __u32 ctsn, next_tsn;
339         struct sctp_ulpevent *retval = NULL;
340
341         /* Initialized to 0 just to avoid compiler warning message.  Will
342          * never be used with this value. It is referenced only after it
343          * is set when we find the first fragment of a message.
344          */
345         next_tsn = 0;
346
347         /* The chunks are held in the reasm queue sorted by TSN.
348          * Walk through the queue sequentially and look for a sequence of
349          * fragmented chunks that complete a datagram.
350          * 'first_frag' and next_tsn are reset when we find a chunk which
351          * is the first fragment of a datagram. Once these 2 fields are set
352          * we expect to find the remaining middle fragments and the last
353          * fragment in order. If not, first_frag is reset to NULL and we
354          * start the next pass when we find another first fragment.
355          */
356         skb_queue_walk(&ulpq->reasm, pos) {
357                 cevent = sctp_skb2event(pos);
358                 ctsn = cevent->tsn;
359
360                 switch (cevent->msg_flags & SCTP_DATA_FRAG_MASK) {
361                 case SCTP_DATA_FIRST_FRAG:
362                         first_frag = pos;
363                         next_tsn = ctsn + 1;
364                         break;
365
366                 case SCTP_DATA_MIDDLE_FRAG:
367                         if ((first_frag) && (ctsn == next_tsn))
368                                 next_tsn++;
369                         else
370                                 first_frag = NULL;
371                         break;
372
373                 case SCTP_DATA_LAST_FRAG:
374                         if (first_frag && (ctsn == next_tsn))
375                                 goto found;
376                         else
377                                 first_frag = NULL;
378                         break;
379                 };
380
381         }
382 done:
383         return retval;
384 found:
385         retval = sctp_make_reassembled_event(&ulpq->reasm, first_frag, pos);
386         if (retval)
387                 retval->msg_flags |= MSG_EOR;
388         goto done;
389 }
390
391 /* Retrieve the next set of fragments of a partial message. */
392 static inline struct sctp_ulpevent *sctp_ulpq_retrieve_partial(struct sctp_ulpq *ulpq)
393 {
394         struct sk_buff *pos, *last_frag, *first_frag;
395         struct sctp_ulpevent *cevent;
396         __u32 ctsn, next_tsn;
397         int is_last;
398         struct sctp_ulpevent *retval;
399
400         /* The chunks are held in the reasm queue sorted by TSN.
401          * Walk through the queue sequentially and look for the first
402          * sequence of fragmented chunks.
403          */
404
405         if (skb_queue_empty(&ulpq->reasm))
406                 return NULL;
407
408         last_frag = first_frag = NULL;
409         retval = NULL;
410         next_tsn = 0;
411         is_last = 0;
412
413         skb_queue_walk(&ulpq->reasm, pos) {
414                 cevent = sctp_skb2event(pos);
415                 ctsn = cevent->tsn;
416
417                 switch (cevent->msg_flags & SCTP_DATA_FRAG_MASK) {
418                 case SCTP_DATA_MIDDLE_FRAG:
419                         if (!first_frag) {
420                                 first_frag = pos;
421                                 next_tsn = ctsn + 1;
422                                 last_frag = pos;
423                         } else if (next_tsn == ctsn)
424                                 next_tsn++;
425                         else
426                                 goto done;
427                         break;
428                 case SCTP_DATA_LAST_FRAG:
429                         if (!first_frag)
430                                 first_frag = pos;
431                         else if (ctsn != next_tsn)
432                                 goto done;
433                         last_frag = pos;
434                         is_last = 1;
435                         goto done;
436                 default:
437                         return NULL;
438                 };
439         }
440
441         /* We have the reassembled event. There is no need to look
442          * further.
443          */
444 done:
445         retval = sctp_make_reassembled_event(&ulpq->reasm, first_frag, last_frag);
446         if (retval && is_last)
447                 retval->msg_flags |= MSG_EOR;
448
449         return retval;
450 }
451
452
453 /* Helper function to reassemble chunks.  Hold chunks on the reasm queue that
454  * need reassembling.
455  */
456 static struct sctp_ulpevent *sctp_ulpq_reasm(struct sctp_ulpq *ulpq,
457                                                 struct sctp_ulpevent *event)
458 {
459         struct sctp_ulpevent *retval = NULL;
460
461         /* Check if this is part of a fragmented message.  */
462         if (SCTP_DATA_NOT_FRAG == (event->msg_flags & SCTP_DATA_FRAG_MASK)) {
463                 event->msg_flags |= MSG_EOR;
464                 return event;
465         }
466
467         sctp_ulpq_store_reasm(ulpq, event);
468         if (!ulpq->pd_mode)
469                 retval = sctp_ulpq_retrieve_reassembled(ulpq);
470         else {
471                 __u32 ctsn, ctsnap;
472
473                 /* Do not even bother unless this is the next tsn to
474                  * be delivered.
475                  */
476                 ctsn = event->tsn;
477                 ctsnap = sctp_tsnmap_get_ctsn(&ulpq->asoc->peer.tsn_map);
478                 if (TSN_lte(ctsn, ctsnap))
479                         retval = sctp_ulpq_retrieve_partial(ulpq);
480         }
481
482         return retval;
483 }
484
485 /* Retrieve the first part (sequential fragments) for partial delivery.  */
486 static inline struct sctp_ulpevent *sctp_ulpq_retrieve_first(struct sctp_ulpq *ulpq)
487 {
488         struct sk_buff *pos, *last_frag, *first_frag;
489         struct sctp_ulpevent *cevent;
490         __u32 ctsn, next_tsn;
491         struct sctp_ulpevent *retval;
492
493         /* The chunks are held in the reasm queue sorted by TSN.
494          * Walk through the queue sequentially and look for a sequence of
495          * fragmented chunks that start a datagram.
496          */
497
498         if (skb_queue_empty(&ulpq->reasm))
499                 return NULL;
500
501         last_frag = first_frag = NULL;
502         retval = NULL;
503         next_tsn = 0;
504
505         skb_queue_walk(&ulpq->reasm, pos) {
506                 cevent = sctp_skb2event(pos);
507                 ctsn = cevent->tsn;
508
509                 switch (cevent->msg_flags & SCTP_DATA_FRAG_MASK) {
510                 case SCTP_DATA_FIRST_FRAG:
511                         if (!first_frag) {
512                                 first_frag = pos;
513                                 next_tsn = ctsn + 1;
514                                 last_frag = pos;
515                         } else
516                                 goto done;
517                         break;
518
519                 case SCTP_DATA_MIDDLE_FRAG:
520                         if (!first_frag)
521                                 return NULL;
522                         if (ctsn == next_tsn) {
523                                 next_tsn++;
524                                 last_frag = pos;
525                         } else
526                                 goto done;
527                         break;
528                 default:
529                         return NULL;
530                 };
531         }
532
533         /* We have the reassembled event. There is no need to look
534          * further.
535          */
536 done:
537         retval = sctp_make_reassembled_event(&ulpq->reasm, first_frag, last_frag);
538         return retval;
539 }
540
541 /* Helper function to gather skbs that have possibly become
542  * ordered by an an incoming chunk.
543  */
544 static inline void sctp_ulpq_retrieve_ordered(struct sctp_ulpq *ulpq,
545                                               struct sctp_ulpevent *event)
546 {
547         struct sk_buff_head *event_list;
548         struct sk_buff *pos, *tmp;
549         struct sctp_ulpevent *cevent;
550         struct sctp_stream *in;
551         __u16 sid, csid;
552         __u16 ssn, cssn;
553
554         sid = event->stream;
555         ssn = event->ssn;
556         in  = &ulpq->asoc->ssnmap->in;
557
558         event_list = (struct sk_buff_head *) sctp_event2skb(event)->prev;
559
560         /* We are holding the chunks by stream, by SSN.  */
561         sctp_skb_for_each(pos, &ulpq->lobby, tmp) {
562                 cevent = (struct sctp_ulpevent *) pos->cb;
563                 csid = cevent->stream;
564                 cssn = cevent->ssn;
565
566                 /* Have we gone too far?  */
567                 if (csid > sid)
568                         break;
569
570                 /* Have we not gone far enough?  */
571                 if (csid < sid)
572                         continue;
573
574                 if (cssn != sctp_ssn_peek(in, sid))
575                         break;
576
577                 /* Found it, so mark in the ssnmap. */
578                 sctp_ssn_next(in, sid);
579
580                 __skb_unlink(pos, &ulpq->lobby);
581
582                 /* Attach all gathered skbs to the event.  */
583                 __skb_queue_tail(event_list, pos);
584         }
585 }
586
587 /* Helper function to store chunks needing ordering.  */
588 static inline void sctp_ulpq_store_ordered(struct sctp_ulpq *ulpq,
589                                            struct sctp_ulpevent *event)
590 {
591         struct sk_buff *pos;
592         struct sctp_ulpevent *cevent;
593         __u16 sid, csid;
594         __u16 ssn, cssn;
595
596         pos = skb_peek_tail(&ulpq->lobby);
597         if (!pos) {
598                 __skb_queue_tail(&ulpq->lobby, sctp_event2skb(event));
599                 return;
600         }
601
602         sid = event->stream;
603         ssn = event->ssn;
604         
605         cevent = (struct sctp_ulpevent *) pos->cb;
606         csid = cevent->stream;
607         cssn = cevent->ssn;
608         if (sid > csid) {
609                 __skb_queue_tail(&ulpq->lobby, sctp_event2skb(event));
610                 return;
611         }
612
613         if ((sid == csid) && SSN_lt(cssn, ssn)) {
614                 __skb_queue_tail(&ulpq->lobby, sctp_event2skb(event));
615                 return;
616         }
617
618         /* Find the right place in this list.  We store them by
619          * stream ID and then by SSN.
620          */
621         skb_queue_walk(&ulpq->lobby, pos) {
622                 cevent = (struct sctp_ulpevent *) pos->cb;
623                 csid = cevent->stream;
624                 cssn = cevent->ssn;
625
626                 if (csid > sid)
627                         break;
628                 if (csid == sid && SSN_lt(ssn, cssn))
629                         break;
630         }
631
632
633         /* Insert before pos. */
634         __skb_insert(sctp_event2skb(event), pos->prev, pos, &ulpq->lobby);
635
636 }
637
638 static struct sctp_ulpevent *sctp_ulpq_order(struct sctp_ulpq *ulpq,
639                                              struct sctp_ulpevent *event)
640 {
641         __u16 sid, ssn;
642         struct sctp_stream *in;
643
644         /* Check if this message needs ordering.  */
645         if (SCTP_DATA_UNORDERED & event->msg_flags)
646                 return event;
647
648         /* Note: The stream ID must be verified before this routine.  */
649         sid = event->stream;
650         ssn = event->ssn;
651         in  = &ulpq->asoc->ssnmap->in;
652
653         /* Is this the expected SSN for this stream ID?  */
654         if (ssn != sctp_ssn_peek(in, sid)) {
655                 /* We've received something out of order, so find where it
656                  * needs to be placed.  We order by stream and then by SSN.
657                  */
658                 sctp_ulpq_store_ordered(ulpq, event);
659                 return NULL;
660         }
661
662         /* Mark that the next chunk has been found.  */
663         sctp_ssn_next(in, sid);
664
665         /* Go find any other chunks that were waiting for
666          * ordering.
667          */
668         sctp_ulpq_retrieve_ordered(ulpq, event);
669
670         return event;
671 }
672
673 /* Helper function to gather skbs that have possibly become
674  * ordered by forward tsn skipping their dependencies.
675  */
676 static inline void sctp_ulpq_reap_ordered(struct sctp_ulpq *ulpq)
677 {
678         struct sk_buff *pos, *tmp;
679         struct sctp_ulpevent *cevent;
680         struct sctp_ulpevent *event;
681         struct sctp_stream *in;
682         struct sk_buff_head temp;
683         __u16 csid, cssn;
684
685         in  = &ulpq->asoc->ssnmap->in;
686
687         /* We are holding the chunks by stream, by SSN.  */
688         skb_queue_head_init(&temp);
689         event = NULL;
690         sctp_skb_for_each(pos, &ulpq->lobby, tmp) {
691                 cevent = (struct sctp_ulpevent *) pos->cb;
692                 csid = cevent->stream;
693                 cssn = cevent->ssn;
694
695                 if (cssn != sctp_ssn_peek(in, csid))
696                         break;
697
698                 /* Found it, so mark in the ssnmap. */         
699                 sctp_ssn_next(in, csid);
700
701                 __skb_unlink(pos, &ulpq->lobby);
702                 if (!event) {                                           
703                         /* Create a temporary list to collect chunks on.  */
704                         event = sctp_skb2event(pos);
705                         __skb_queue_tail(&temp, sctp_event2skb(event));
706                 } else {
707                         /* Attach all gathered skbs to the event.  */
708                         __skb_queue_tail(&temp, pos);
709                 }
710         }
711
712         /* Send event to the ULP.  'event' is the sctp_ulpevent for
713          * very first SKB on the 'temp' list.
714          */
715         if (event)
716                 sctp_ulpq_tail_event(ulpq, event);
717 }
718
719 /* Skip over an SSN. */
720 void sctp_ulpq_skip(struct sctp_ulpq *ulpq, __u16 sid, __u16 ssn)
721 {
722         struct sctp_stream *in;
723
724         /* Note: The stream ID must be verified before this routine.  */
725         in  = &ulpq->asoc->ssnmap->in;
726
727         /* Is this an old SSN?  If so ignore. */
728         if (SSN_lt(ssn, sctp_ssn_peek(in, sid)))
729                 return;
730
731         /* Mark that we are no longer expecting this SSN or lower. */
732         sctp_ssn_skip(in, sid, ssn);
733
734         /* Go find any other chunks that were waiting for
735          * ordering and deliver them if needed. 
736          */
737         sctp_ulpq_reap_ordered(ulpq);
738         return;
739 }
740
741 /* Renege 'needed' bytes from the ordering queue. */
742 static __u16 sctp_ulpq_renege_order(struct sctp_ulpq *ulpq, __u16 needed)
743 {
744         __u16 freed = 0;
745         __u32 tsn;
746         struct sk_buff *skb;
747         struct sctp_ulpevent *event;
748         struct sctp_tsnmap *tsnmap;
749
750         tsnmap = &ulpq->asoc->peer.tsn_map;
751
752         while ((skb = __skb_dequeue_tail(&ulpq->lobby)) != NULL) {
753                 freed += skb_headlen(skb);
754                 event = sctp_skb2event(skb);
755                 tsn = event->tsn;
756
757                 sctp_ulpevent_free(event);
758                 sctp_tsnmap_renege(tsnmap, tsn);
759                 if (freed >= needed)
760                         return freed;
761         }
762
763         return freed;
764 }
765
766 /* Renege 'needed' bytes from the reassembly queue. */
767 static __u16 sctp_ulpq_renege_frags(struct sctp_ulpq *ulpq, __u16 needed)
768 {
769         __u16 freed = 0;
770         __u32 tsn;
771         struct sk_buff *skb;
772         struct sctp_ulpevent *event;
773         struct sctp_tsnmap *tsnmap;
774
775         tsnmap = &ulpq->asoc->peer.tsn_map;
776
777         /* Walk backwards through the list, reneges the newest tsns. */
778         while ((skb = __skb_dequeue_tail(&ulpq->reasm)) != NULL) {
779                 freed += skb_headlen(skb);
780                 event = sctp_skb2event(skb);
781                 tsn = event->tsn;
782
783                 sctp_ulpevent_free(event);
784                 sctp_tsnmap_renege(tsnmap, tsn);
785                 if (freed >= needed)
786                         return freed;
787         }
788
789         return freed;
790 }
791
792 /* Partial deliver the first message as there is pressure on rwnd. */
793 void sctp_ulpq_partial_delivery(struct sctp_ulpq *ulpq,
794                                 struct sctp_chunk *chunk,
795                                 unsigned int __nocast gfp)
796 {
797         struct sctp_ulpevent *event;
798         struct sctp_association *asoc;
799
800         asoc = ulpq->asoc;
801
802         /* Are we already in partial delivery mode?  */
803         if (!sctp_sk(asoc->base.sk)->pd_mode) {
804
805                 /* Is partial delivery possible?  */
806                 event = sctp_ulpq_retrieve_first(ulpq);
807                 /* Send event to the ULP.   */
808                 if (event) {
809                         sctp_ulpq_tail_event(ulpq, event);
810                         sctp_sk(asoc->base.sk)->pd_mode = 1;
811                         ulpq->pd_mode = 1;
812                         return;
813                 }
814         }
815 }
816
817 /* Renege some packets to make room for an incoming chunk.  */
818 void sctp_ulpq_renege(struct sctp_ulpq *ulpq, struct sctp_chunk *chunk,
819                       unsigned int __nocast gfp)
820 {
821         struct sctp_association *asoc;
822         __u16 needed, freed;
823
824         asoc = ulpq->asoc;
825
826         if (chunk) {
827                 needed = ntohs(chunk->chunk_hdr->length);
828                 needed -= sizeof(sctp_data_chunk_t);
829         } else 
830                 needed = SCTP_DEFAULT_MAXWINDOW;
831
832         freed = 0;
833
834         if (skb_queue_empty(&asoc->base.sk->sk_receive_queue)) {
835                 freed = sctp_ulpq_renege_order(ulpq, needed);
836                 if (freed < needed) {
837                         freed += sctp_ulpq_renege_frags(ulpq, needed - freed);
838                 }
839         }
840         /* If able to free enough room, accept this chunk. */
841         if (chunk && (freed >= needed)) {
842                 __u32 tsn;
843                 tsn = ntohl(chunk->subh.data_hdr->tsn);
844                 sctp_tsnmap_mark(&asoc->peer.tsn_map, tsn);
845                 sctp_ulpq_tail_data(ulpq, chunk, gfp);
846                 
847                 sctp_ulpq_partial_delivery(ulpq, chunk, gfp);
848         }
849
850         return;
851 }
852
853
854
855 /* Notify the application if an association is aborted and in
856  * partial delivery mode.  Send up any pending received messages.
857  */
858 void sctp_ulpq_abort_pd(struct sctp_ulpq *ulpq, unsigned int __nocast gfp)
859 {
860         struct sctp_ulpevent *ev = NULL;
861         struct sock *sk;
862
863         if (!ulpq->pd_mode)
864                 return;
865
866         sk = ulpq->asoc->base.sk;
867         if (sctp_ulpevent_type_enabled(SCTP_PARTIAL_DELIVERY_EVENT,
868                                        &sctp_sk(sk)->subscribe))
869                 ev = sctp_ulpevent_make_pdapi(ulpq->asoc,
870                                               SCTP_PARTIAL_DELIVERY_ABORTED,
871                                               gfp);
872         if (ev)
873                 __skb_queue_tail(&sk->sk_receive_queue, sctp_event2skb(ev));
874
875         /* If there is data waiting, send it up the socket now. */
876         if (sctp_ulpq_clear_pd(ulpq) || ev)
877                 sk->sk_data_ready(sk, 0);
878 }