Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
ulpevent.c
Go to the documentation of this file.
1 /* SCTP kernel 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  * These functions manipulate an sctp event. The struct ulpevent is used
10  * to carry notifications and data to the ULP (sockets).
11  *
12  * This SCTP implementation is free software;
13  * you can redistribute it and/or modify it under the terms of
14  * the GNU General Public License as published by
15  * the Free Software Foundation; either version 2, or (at your option)
16  * any later version.
17  *
18  * This SCTP implementation is distributed in the hope that it
19  * will be useful, but WITHOUT ANY WARRANTY; without even the implied
20  * ************************
21  * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
22  * See the GNU General Public License for more details.
23  *
24  * You should have received a copy of the GNU General Public License
25  * along with GNU CC; see the file COPYING. If not, write to
26  * the Free Software Foundation, 59 Temple Place - Suite 330,
27  * Boston, MA 02111-1307, USA.
28  *
29  * Please send any bug reports or fixes you make to the
30  * email address(es):
31  * lksctp developers <[email protected]>
32  *
33  * Or submit a bug report through the following website:
34  * http://www.sf.net/projects/lksctp
35  *
36  * Written or modified by:
37  * Jon Grimm <[email protected]>
38  * La Monte H.P. Yarroll <[email protected]>
39  * Ardelle Fan <[email protected]>
40  * Sridhar Samudrala <[email protected]>
41  *
42  * Any bugs reported given to us we will try to fix... any fixes shared will
43  * be incorporated into the next SCTP release.
44  */
45 
46 #include <linux/slab.h>
47 #include <linux/types.h>
48 #include <linux/skbuff.h>
49 #include <net/sctp/structs.h>
50 #include <net/sctp/sctp.h>
51 #include <net/sctp/sm.h>
52 
53 static void sctp_ulpevent_receive_data(struct sctp_ulpevent *event,
54  struct sctp_association *asoc);
55 static void sctp_ulpevent_release_data(struct sctp_ulpevent *event);
56 static void sctp_ulpevent_release_frag_data(struct sctp_ulpevent *event);
57 
58 
59 /* Initialize an ULP event from an given skb. */
61  int msg_flags,
62  unsigned int len)
63 {
64  memset(event, 0, sizeof(struct sctp_ulpevent));
65  event->msg_flags = msg_flags;
66  event->rmem_len = len;
67 }
68 
69 /* Create a new sctp_ulpevent. */
71  gfp_t gfp)
72 {
73  struct sctp_ulpevent *event;
74  struct sk_buff *skb;
75 
76  skb = alloc_skb(size, gfp);
77  if (!skb)
78  goto fail;
79 
80  event = sctp_skb2event(skb);
81  sctp_ulpevent_init(event, msg_flags, skb->truesize);
82 
83  return event;
84 
85 fail:
86  return NULL;
87 }
88 
89 /* Is this a MSG_NOTIFICATION? */
91 {
92  return MSG_NOTIFICATION == (event->msg_flags & MSG_NOTIFICATION);
93 }
94 
95 /* Hold the association in case the msg_name needs read out of
96  * the association.
97  */
98 static inline void sctp_ulpevent_set_owner(struct sctp_ulpevent *event,
99  const struct sctp_association *asoc)
100 {
101  struct sk_buff *skb;
102 
103  /* Cast away the const, as we are just wanting to
104  * bump the reference count.
105  */
106  sctp_association_hold((struct sctp_association *)asoc);
107  skb = sctp_event2skb(event);
108  event->asoc = (struct sctp_association *)asoc;
109  atomic_add(event->rmem_len, &event->asoc->rmem_alloc);
110  sctp_skb_set_owner_r(skb, asoc->base.sk);
111 }
112 
113 /* A simple destructor to give up the reference to the association. */
114 static inline void sctp_ulpevent_release_owner(struct sctp_ulpevent *event)
115 {
116  struct sctp_association *asoc = event->asoc;
117 
118  atomic_sub(event->rmem_len, &asoc->rmem_alloc);
119  sctp_association_put(asoc);
120 }
121 
122 /* Create and initialize an SCTP_ASSOC_CHANGE event.
123  *
124  * 5.3.1.1 SCTP_ASSOC_CHANGE
125  *
126  * Communication notifications inform the ULP that an SCTP association
127  * has either begun or ended. The identifier for a new association is
128  * provided by this notification.
129  *
130  * Note: There is no field checking here. If a field is unused it will be
131  * zero'd out.
132  */
134  const struct sctp_association *asoc,
135  __u16 flags, __u16 state, __u16 error, __u16 outbound,
136  __u16 inbound, struct sctp_chunk *chunk, gfp_t gfp)
137 {
138  struct sctp_ulpevent *event;
139  struct sctp_assoc_change *sac;
140  struct sk_buff *skb;
141 
142  /* If the lower layer passed in the chunk, it will be
143  * an ABORT, so we need to include it in the sac_info.
144  */
145  if (chunk) {
146  /* Copy the chunk data to a new skb and reserve enough
147  * head room to use as notification.
148  */
149  skb = skb_copy_expand(chunk->skb,
150  sizeof(struct sctp_assoc_change), 0, gfp);
151 
152  if (!skb)
153  goto fail;
154 
155  /* Embed the event fields inside the cloned skb. */
156  event = sctp_skb2event(skb);
158 
159  /* Include the notification structure */
160  sac = (struct sctp_assoc_change *)
161  skb_push(skb, sizeof(struct sctp_assoc_change));
162 
163  /* Trim the buffer to the right length. */
164  skb_trim(skb, sizeof(struct sctp_assoc_change) +
165  ntohs(chunk->chunk_hdr->length) -
166  sizeof(sctp_chunkhdr_t));
167  } else {
168  event = sctp_ulpevent_new(sizeof(struct sctp_assoc_change),
169  MSG_NOTIFICATION, gfp);
170  if (!event)
171  goto fail;
172 
173  skb = sctp_event2skb(event);
174  sac = (struct sctp_assoc_change *) skb_put(skb,
175  sizeof(struct sctp_assoc_change));
176  }
177 
178  /* Socket Extensions for SCTP
179  * 5.3.1.1 SCTP_ASSOC_CHANGE
180  *
181  * sac_type:
182  * It should be SCTP_ASSOC_CHANGE.
183  */
185 
186  /* Socket Extensions for SCTP
187  * 5.3.1.1 SCTP_ASSOC_CHANGE
188  *
189  * sac_state: 32 bits (signed integer)
190  * This field holds one of a number of values that communicate the
191  * event that happened to the association.
192  */
193  sac->sac_state = state;
194 
195  /* Socket Extensions for SCTP
196  * 5.3.1.1 SCTP_ASSOC_CHANGE
197  *
198  * sac_flags: 16 bits (unsigned integer)
199  * Currently unused.
200  */
201  sac->sac_flags = 0;
202 
203  /* Socket Extensions for SCTP
204  * 5.3.1.1 SCTP_ASSOC_CHANGE
205  *
206  * sac_length: sizeof (__u32)
207  * This field is the total length of the notification data, including
208  * the notification header.
209  */
210  sac->sac_length = skb->len;
211 
212  /* Socket Extensions for SCTP
213  * 5.3.1.1 SCTP_ASSOC_CHANGE
214  *
215  * sac_error: 32 bits (signed integer)
216  *
217  * If the state was reached due to a error condition (e.g.
218  * COMMUNICATION_LOST) any relevant error information is available in
219  * this field. This corresponds to the protocol error codes defined in
220  * [SCTP].
221  */
222  sac->sac_error = error;
223 
224  /* Socket Extensions for SCTP
225  * 5.3.1.1 SCTP_ASSOC_CHANGE
226  *
227  * sac_outbound_streams: 16 bits (unsigned integer)
228  * sac_inbound_streams: 16 bits (unsigned integer)
229  *
230  * The maximum number of streams allowed in each direction are
231  * available in sac_outbound_streams and sac_inbound streams.
232  */
233  sac->sac_outbound_streams = outbound;
234  sac->sac_inbound_streams = inbound;
235 
236  /* Socket Extensions for SCTP
237  * 5.3.1.1 SCTP_ASSOC_CHANGE
238  *
239  * sac_assoc_id: sizeof (sctp_assoc_t)
240  *
241  * The association id field, holds the identifier for the association.
242  * All notifications for a given association have the same association
243  * identifier. For TCP style socket, this field is ignored.
244  */
245  sctp_ulpevent_set_owner(event, asoc);
246  sac->sac_assoc_id = sctp_assoc2id(asoc);
247 
248  return event;
249 
250 fail:
251  return NULL;
252 }
253 
254 /* Create and initialize an SCTP_PEER_ADDR_CHANGE event.
255  *
256  * Socket Extensions for SCTP - draft-01
257  * 5.3.1.2 SCTP_PEER_ADDR_CHANGE
258  *
259  * When a destination address on a multi-homed peer encounters a change
260  * an interface details event is sent.
261  */
263  const struct sctp_association *asoc,
264  const struct sockaddr_storage *aaddr,
265  int flags, int state, int error, gfp_t gfp)
266 {
267  struct sctp_ulpevent *event;
268  struct sctp_paddr_change *spc;
269  struct sk_buff *skb;
270 
271  event = sctp_ulpevent_new(sizeof(struct sctp_paddr_change),
272  MSG_NOTIFICATION, gfp);
273  if (!event)
274  goto fail;
275 
276  skb = sctp_event2skb(event);
277  spc = (struct sctp_paddr_change *)
278  skb_put(skb, sizeof(struct sctp_paddr_change));
279 
280  /* Sockets API Extensions for SCTP
281  * Section 5.3.1.2 SCTP_PEER_ADDR_CHANGE
282  *
283  * spc_type:
284  *
285  * It should be SCTP_PEER_ADDR_CHANGE.
286  */
288 
289  /* Sockets API Extensions for SCTP
290  * Section 5.3.1.2 SCTP_PEER_ADDR_CHANGE
291  *
292  * spc_length: sizeof (__u32)
293  *
294  * This field is the total length of the notification data, including
295  * the notification header.
296  */
297  spc->spc_length = sizeof(struct sctp_paddr_change);
298 
299  /* Sockets API Extensions for SCTP
300  * Section 5.3.1.2 SCTP_PEER_ADDR_CHANGE
301  *
302  * spc_flags: 16 bits (unsigned integer)
303  * Currently unused.
304  */
305  spc->spc_flags = 0;
306 
307  /* Sockets API Extensions for SCTP
308  * Section 5.3.1.2 SCTP_PEER_ADDR_CHANGE
309  *
310  * spc_state: 32 bits (signed integer)
311  *
312  * This field holds one of a number of values that communicate the
313  * event that happened to the address.
314  */
315  spc->spc_state = state;
316 
317  /* Sockets API Extensions for SCTP
318  * Section 5.3.1.2 SCTP_PEER_ADDR_CHANGE
319  *
320  * spc_error: 32 bits (signed integer)
321  *
322  * If the state was reached due to any error condition (e.g.
323  * ADDRESS_UNREACHABLE) any relevant error information is available in
324  * this field.
325  */
326  spc->spc_error = error;
327 
328  /* Socket Extensions for SCTP
329  * 5.3.1.1 SCTP_ASSOC_CHANGE
330  *
331  * spc_assoc_id: sizeof (sctp_assoc_t)
332  *
333  * The association id field, holds the identifier for the association.
334  * All notifications for a given association have the same association
335  * identifier. For TCP style socket, this field is ignored.
336  */
337  sctp_ulpevent_set_owner(event, asoc);
338  spc->spc_assoc_id = sctp_assoc2id(asoc);
339 
340  /* Sockets API Extensions for SCTP
341  * Section 5.3.1.2 SCTP_PEER_ADDR_CHANGE
342  *
343  * spc_aaddr: sizeof (struct sockaddr_storage)
344  *
345  * The affected address field, holds the remote peer's address that is
346  * encountering the change of state.
347  */
348  memcpy(&spc->spc_aaddr, aaddr, sizeof(struct sockaddr_storage));
349 
350  /* Map ipv4 address into v4-mapped-on-v6 address. */
351  sctp_get_pf_specific(asoc->base.sk->sk_family)->addr_v4map(
352  sctp_sk(asoc->base.sk),
353  (union sctp_addr *)&spc->spc_aaddr);
354 
355  return event;
356 
357 fail:
358  return NULL;
359 }
360 
361 /* Create and initialize an SCTP_REMOTE_ERROR notification.
362  *
363  * Note: This assumes that the chunk->skb->data already points to the
364  * operation error payload.
365  *
366  * Socket Extensions for SCTP - draft-01
367  * 5.3.1.3 SCTP_REMOTE_ERROR
368  *
369  * A remote peer may send an Operational Error message to its peer.
370  * This message indicates a variety of error conditions on an
371  * association. The entire error TLV as it appears on the wire is
372  * included in a SCTP_REMOTE_ERROR event. Please refer to the SCTP
373  * specification [SCTP] and any extensions for a list of possible
374  * error formats.
375  */
377  const struct sctp_association *asoc, struct sctp_chunk *chunk,
378  __u16 flags, gfp_t gfp)
379 {
380  struct sctp_ulpevent *event;
381  struct sctp_remote_error *sre;
382  struct sk_buff *skb;
383  sctp_errhdr_t *ch;
384  __be16 cause;
385  int elen;
386 
387  ch = (sctp_errhdr_t *)(chunk->skb->data);
388  cause = ch->cause;
389  elen = WORD_ROUND(ntohs(ch->length)) - sizeof(sctp_errhdr_t);
390 
391  /* Pull off the ERROR header. */
392  skb_pull(chunk->skb, sizeof(sctp_errhdr_t));
393 
394  /* Copy the skb to a new skb with room for us to prepend
395  * notification with.
396  */
397  skb = skb_copy_expand(chunk->skb, sizeof(struct sctp_remote_error),
398  0, gfp);
399 
400  /* Pull off the rest of the cause TLV from the chunk. */
401  skb_pull(chunk->skb, elen);
402  if (!skb)
403  goto fail;
404 
405  /* Embed the event fields inside the cloned skb. */
406  event = sctp_skb2event(skb);
408 
409  sre = (struct sctp_remote_error *)
410  skb_push(skb, sizeof(struct sctp_remote_error));
411 
412  /* Trim the buffer to the right length. */
413  skb_trim(skb, sizeof(struct sctp_remote_error) + elen);
414 
415  /* Socket Extensions for SCTP
416  * 5.3.1.3 SCTP_REMOTE_ERROR
417  *
418  * sre_type:
419  * It should be SCTP_REMOTE_ERROR.
420  */
422 
423  /*
424  * Socket Extensions for SCTP
425  * 5.3.1.3 SCTP_REMOTE_ERROR
426  *
427  * sre_flags: 16 bits (unsigned integer)
428  * Currently unused.
429  */
430  sre->sre_flags = 0;
431 
432  /* Socket Extensions for SCTP
433  * 5.3.1.3 SCTP_REMOTE_ERROR
434  *
435  * sre_length: sizeof (__u32)
436  *
437  * This field is the total length of the notification data,
438  * including the notification header.
439  */
440  sre->sre_length = skb->len;
441 
442  /* Socket Extensions for SCTP
443  * 5.3.1.3 SCTP_REMOTE_ERROR
444  *
445  * sre_error: 16 bits (unsigned integer)
446  * This value represents one of the Operational Error causes defined in
447  * the SCTP specification, in network byte order.
448  */
449  sre->sre_error = cause;
450 
451  /* Socket Extensions for SCTP
452  * 5.3.1.3 SCTP_REMOTE_ERROR
453  *
454  * sre_assoc_id: sizeof (sctp_assoc_t)
455  *
456  * The association id field, holds the identifier for the association.
457  * All notifications for a given association have the same association
458  * identifier. For TCP style socket, this field is ignored.
459  */
460  sctp_ulpevent_set_owner(event, asoc);
461  sre->sre_assoc_id = sctp_assoc2id(asoc);
462 
463  return event;
464 
465 fail:
466  return NULL;
467 }
468 
469 /* Create and initialize a SCTP_SEND_FAILED notification.
470  *
471  * Socket Extensions for SCTP - draft-01
472  * 5.3.1.4 SCTP_SEND_FAILED
473  */
475  const struct sctp_association *asoc, struct sctp_chunk *chunk,
476  __u16 flags, __u32 error, gfp_t gfp)
477 {
478  struct sctp_ulpevent *event;
479  struct sctp_send_failed *ssf;
480  struct sk_buff *skb;
481 
482  /* Pull off any padding. */
483  int len = ntohs(chunk->chunk_hdr->length);
484 
485  /* Make skb with more room so we can prepend notification. */
486  skb = skb_copy_expand(chunk->skb,
487  sizeof(struct sctp_send_failed), /* headroom */
488  0, /* tailroom */
489  gfp);
490  if (!skb)
491  goto fail;
492 
493  /* Pull off the common chunk header and DATA header. */
494  skb_pull(skb, sizeof(struct sctp_data_chunk));
495  len -= sizeof(struct sctp_data_chunk);
496 
497  /* Embed the event fields inside the cloned skb. */
498  event = sctp_skb2event(skb);
500 
501  ssf = (struct sctp_send_failed *)
502  skb_push(skb, sizeof(struct sctp_send_failed));
503 
504  /* Socket Extensions for SCTP
505  * 5.3.1.4 SCTP_SEND_FAILED
506  *
507  * ssf_type:
508  * It should be SCTP_SEND_FAILED.
509  */
510  ssf->ssf_type = SCTP_SEND_FAILED;
511 
512  /* Socket Extensions for SCTP
513  * 5.3.1.4 SCTP_SEND_FAILED
514  *
515  * ssf_flags: 16 bits (unsigned integer)
516  * The flag value will take one of the following values
517  *
518  * SCTP_DATA_UNSENT - Indicates that the data was never put on
519  * the wire.
520  *
521  * SCTP_DATA_SENT - Indicates that the data was put on the wire.
522  * Note that this does not necessarily mean that the
523  * data was (or was not) successfully delivered.
524  */
525  ssf->ssf_flags = flags;
526 
527  /* Socket Extensions for SCTP
528  * 5.3.1.4 SCTP_SEND_FAILED
529  *
530  * ssf_length: sizeof (__u32)
531  * This field is the total length of the notification data, including
532  * the notification header.
533  */
534  ssf->ssf_length = sizeof(struct sctp_send_failed) + len;
535  skb_trim(skb, ssf->ssf_length);
536 
537  /* Socket Extensions for SCTP
538  * 5.3.1.4 SCTP_SEND_FAILED
539  *
540  * ssf_error: 16 bits (unsigned integer)
541  * This value represents the reason why the send failed, and if set,
542  * will be a SCTP protocol error code as defined in [SCTP] section
543  * 3.3.10.
544  */
545  ssf->ssf_error = error;
546 
547  /* Socket Extensions for SCTP
548  * 5.3.1.4 SCTP_SEND_FAILED
549  *
550  * ssf_info: sizeof (struct sctp_sndrcvinfo)
551  * The original send information associated with the undelivered
552  * message.
553  */
554  memcpy(&ssf->ssf_info, &chunk->sinfo, sizeof(struct sctp_sndrcvinfo));
555 
556  /* Per TSVWG discussion with Randy. Allow the application to
557  * reassemble a fragmented message.
558  */
559  ssf->ssf_info.sinfo_flags = chunk->chunk_hdr->flags;
560 
561  /* Socket Extensions for SCTP
562  * 5.3.1.4 SCTP_SEND_FAILED
563  *
564  * ssf_assoc_id: sizeof (sctp_assoc_t)
565  * The association id field, sf_assoc_id, holds the identifier for the
566  * association. All notifications for a given association have the
567  * same association identifier. For TCP style socket, this field is
568  * ignored.
569  */
570  sctp_ulpevent_set_owner(event, asoc);
571  ssf->ssf_assoc_id = sctp_assoc2id(asoc);
572  return event;
573 
574 fail:
575  return NULL;
576 }
577 
578 /* Create and initialize a SCTP_SHUTDOWN_EVENT notification.
579  *
580  * Socket Extensions for SCTP - draft-01
581  * 5.3.1.5 SCTP_SHUTDOWN_EVENT
582  */
584  const struct sctp_association *asoc,
585  __u16 flags, gfp_t gfp)
586 {
587  struct sctp_ulpevent *event;
588  struct sctp_shutdown_event *sse;
589  struct sk_buff *skb;
590 
591  event = sctp_ulpevent_new(sizeof(struct sctp_shutdown_event),
592  MSG_NOTIFICATION, gfp);
593  if (!event)
594  goto fail;
595 
596  skb = sctp_event2skb(event);
597  sse = (struct sctp_shutdown_event *)
598  skb_put(skb, sizeof(struct sctp_shutdown_event));
599 
600  /* Socket Extensions for SCTP
601  * 5.3.1.5 SCTP_SHUTDOWN_EVENT
602  *
603  * sse_type
604  * It should be SCTP_SHUTDOWN_EVENT
605  */
607 
608  /* Socket Extensions for SCTP
609  * 5.3.1.5 SCTP_SHUTDOWN_EVENT
610  *
611  * sse_flags: 16 bits (unsigned integer)
612  * Currently unused.
613  */
614  sse->sse_flags = 0;
615 
616  /* Socket Extensions for SCTP
617  * 5.3.1.5 SCTP_SHUTDOWN_EVENT
618  *
619  * sse_length: sizeof (__u32)
620  * This field is the total length of the notification data, including
621  * the notification header.
622  */
623  sse->sse_length = sizeof(struct sctp_shutdown_event);
624 
625  /* Socket Extensions for SCTP
626  * 5.3.1.5 SCTP_SHUTDOWN_EVENT
627  *
628  * sse_assoc_id: sizeof (sctp_assoc_t)
629  * The association id field, holds the identifier for the association.
630  * All notifications for a given association have the same association
631  * identifier. For TCP style socket, this field is ignored.
632  */
633  sctp_ulpevent_set_owner(event, asoc);
634  sse->sse_assoc_id = sctp_assoc2id(asoc);
635 
636  return event;
637 
638 fail:
639  return NULL;
640 }
641 
642 /* Create and initialize a SCTP_ADAPTATION_INDICATION notification.
643  *
644  * Socket Extensions for SCTP
645  * 5.3.1.6 SCTP_ADAPTATION_INDICATION
646  */
648  const struct sctp_association *asoc, gfp_t gfp)
649 {
650  struct sctp_ulpevent *event;
651  struct sctp_adaptation_event *sai;
652  struct sk_buff *skb;
653 
654  event = sctp_ulpevent_new(sizeof(struct sctp_adaptation_event),
655  MSG_NOTIFICATION, gfp);
656  if (!event)
657  goto fail;
658 
659  skb = sctp_event2skb(event);
660  sai = (struct sctp_adaptation_event *)
661  skb_put(skb, sizeof(struct sctp_adaptation_event));
662 
664  sai->sai_flags = 0;
665  sai->sai_length = sizeof(struct sctp_adaptation_event);
666  sai->sai_adaptation_ind = asoc->peer.adaptation_ind;
667  sctp_ulpevent_set_owner(event, asoc);
668  sai->sai_assoc_id = sctp_assoc2id(asoc);
669 
670  return event;
671 
672 fail:
673  return NULL;
674 }
675 
676 /* A message has been received. Package this message as a notification
677  * to pass it to the upper layers. Go ahead and calculate the sndrcvinfo
678  * even if filtered out later.
679  *
680  * Socket Extensions for SCTP
681  * 5.2.2 SCTP Header Information Structure (SCTP_SNDRCV)
682  */
684  struct sctp_chunk *chunk,
685  gfp_t gfp)
686 {
687  struct sctp_ulpevent *event = NULL;
688  struct sk_buff *skb;
689  size_t padding, len;
690  int rx_count;
691 
692  /*
693  * check to see if we need to make space for this
694  * new skb, expand the rcvbuffer if needed, or drop
695  * the frame
696  */
697  if (asoc->ep->rcvbuf_policy)
698  rx_count = atomic_read(&asoc->rmem_alloc);
699  else
700  rx_count = atomic_read(&asoc->base.sk->sk_rmem_alloc);
701 
702  if (rx_count >= asoc->base.sk->sk_rcvbuf) {
703 
704  if ((asoc->base.sk->sk_userlocks & SOCK_RCVBUF_LOCK) ||
705  (!sk_rmem_schedule(asoc->base.sk, chunk->skb,
706  chunk->skb->truesize)))
707  goto fail;
708  }
709 
710  /* Clone the original skb, sharing the data. */
711  skb = skb_clone(chunk->skb, gfp);
712  if (!skb)
713  goto fail;
714 
715  /* Now that all memory allocations for this chunk succeeded, we
716  * can mark it as received so the tsn_map is updated correctly.
717  */
718  if (sctp_tsnmap_mark(&asoc->peer.tsn_map,
719  ntohl(chunk->subh.data_hdr->tsn),
720  chunk->transport))
721  goto fail_mark;
722 
723  /* First calculate the padding, so we don't inadvertently
724  * pass up the wrong length to the user.
725  *
726  * RFC 2960 - Section 3.2 Chunk Field Descriptions
727  *
728  * The total length of a chunk(including Type, Length and Value fields)
729  * MUST be a multiple of 4 bytes. If the length of the chunk is not a
730  * multiple of 4 bytes, the sender MUST pad the chunk with all zero
731  * bytes and this padding is not included in the chunk length field.
732  * The sender should never pad with more than 3 bytes. The receiver
733  * MUST ignore the padding bytes.
734  */
735  len = ntohs(chunk->chunk_hdr->length);
736  padding = WORD_ROUND(len) - len;
737 
738  /* Fixup cloned skb with just this chunks data. */
739  skb_trim(skb, chunk->chunk_end - padding - skb->data);
740 
741  /* Embed the event fields inside the cloned skb. */
742  event = sctp_skb2event(skb);
743 
744  /* Initialize event with flags 0 and correct length
745  * Since this is a clone of the original skb, only account for
746  * the data of this chunk as other chunks will be accounted separately.
747  */
748  sctp_ulpevent_init(event, 0, skb->len + sizeof(struct sk_buff));
749 
750  sctp_ulpevent_receive_data(event, asoc);
751 
752  event->stream = ntohs(chunk->subh.data_hdr->stream);
753  event->ssn = ntohs(chunk->subh.data_hdr->ssn);
754  event->ppid = chunk->subh.data_hdr->ppid;
755  if (chunk->chunk_hdr->flags & SCTP_DATA_UNORDERED) {
756  event->flags |= SCTP_UNORDERED;
757  event->cumtsn = sctp_tsnmap_get_ctsn(&asoc->peer.tsn_map);
758  }
759  event->tsn = ntohl(chunk->subh.data_hdr->tsn);
760  event->msg_flags |= chunk->chunk_hdr->flags;
761  event->iif = sctp_chunk_iif(chunk);
762 
763  return event;
764 
765 fail_mark:
766  kfree_skb(skb);
767 fail:
768  return NULL;
769 }
770 
771 /* Create a partial delivery related event.
772  *
773  * 5.3.1.7 SCTP_PARTIAL_DELIVERY_EVENT
774  *
775  * When a receiver is engaged in a partial delivery of a
776  * message this notification will be used to indicate
777  * various events.
778  */
780  const struct sctp_association *asoc, __u32 indication,
781  gfp_t gfp)
782 {
783  struct sctp_ulpevent *event;
784  struct sctp_pdapi_event *pd;
785  struct sk_buff *skb;
786 
787  event = sctp_ulpevent_new(sizeof(struct sctp_pdapi_event),
788  MSG_NOTIFICATION, gfp);
789  if (!event)
790  goto fail;
791 
792  skb = sctp_event2skb(event);
793  pd = (struct sctp_pdapi_event *)
794  skb_put(skb, sizeof(struct sctp_pdapi_event));
795 
796  /* pdapi_type
797  * It should be SCTP_PARTIAL_DELIVERY_EVENT
798  *
799  * pdapi_flags: 16 bits (unsigned integer)
800  * Currently unused.
801  */
803  pd->pdapi_flags = 0;
804 
805  /* pdapi_length: 32 bits (unsigned integer)
806  *
807  * This field is the total length of the notification data, including
808  * the notification header. It will generally be sizeof (struct
809  * sctp_pdapi_event).
810  */
811  pd->pdapi_length = sizeof(struct sctp_pdapi_event);
812 
813  /* pdapi_indication: 32 bits (unsigned integer)
814  *
815  * This field holds the indication being sent to the application.
816  */
817  pd->pdapi_indication = indication;
818 
819  /* pdapi_assoc_id: sizeof (sctp_assoc_t)
820  *
821  * The association id field, holds the identifier for the association.
822  */
823  sctp_ulpevent_set_owner(event, asoc);
824  pd->pdapi_assoc_id = sctp_assoc2id(asoc);
825 
826  return event;
827 fail:
828  return NULL;
829 }
830 
832  const struct sctp_association *asoc, __u16 key_id,
833  __u32 indication, gfp_t gfp)
834 {
835  struct sctp_ulpevent *event;
836  struct sctp_authkey_event *ak;
837  struct sk_buff *skb;
838 
839  event = sctp_ulpevent_new(sizeof(struct sctp_authkey_event),
840  MSG_NOTIFICATION, gfp);
841  if (!event)
842  goto fail;
843 
844  skb = sctp_event2skb(event);
845  ak = (struct sctp_authkey_event *)
846  skb_put(skb, sizeof(struct sctp_authkey_event));
847 
849  ak->auth_flags = 0;
850  ak->auth_length = sizeof(struct sctp_authkey_event);
851 
852  ak->auth_keynumber = key_id;
853  ak->auth_altkeynumber = 0;
854  ak->auth_indication = indication;
855 
856  /*
857  * The association id field, holds the identifier for the association.
858  */
859  sctp_ulpevent_set_owner(event, asoc);
860  ak->auth_assoc_id = sctp_assoc2id(asoc);
861 
862  return event;
863 fail:
864  return NULL;
865 }
866 
867 /*
868  * Socket Extensions for SCTP
869  * 6.3.10. SCTP_SENDER_DRY_EVENT
870  */
872  const struct sctp_association *asoc, gfp_t gfp)
873 {
874  struct sctp_ulpevent *event;
875  struct sctp_sender_dry_event *sdry;
876  struct sk_buff *skb;
877 
878  event = sctp_ulpevent_new(sizeof(struct sctp_sender_dry_event),
879  MSG_NOTIFICATION, gfp);
880  if (!event)
881  return NULL;
882 
883  skb = sctp_event2skb(event);
884  sdry = (struct sctp_sender_dry_event *)
885  skb_put(skb, sizeof(struct sctp_sender_dry_event));
886 
888  sdry->sender_dry_flags = 0;
889  sdry->sender_dry_length = sizeof(struct sctp_sender_dry_event);
890  sctp_ulpevent_set_owner(event, asoc);
891  sdry->sender_dry_assoc_id = sctp_assoc2id(asoc);
892 
893  return event;
894 }
895 
896 /* Return the notification type, assuming this is a notification
897  * event.
898  */
900 {
902  struct sk_buff *skb;
903 
904  skb = sctp_event2skb(event);
905  notification = (union sctp_notification *) skb->data;
906  return notification->sn_header.sn_type;
907 }
908 
909 /* Copy out the sndrcvinfo into a msghdr. */
911  struct msghdr *msghdr)
912 {
913  struct sctp_sndrcvinfo sinfo;
914 
916  return;
917 
918  /* Sockets API Extensions for SCTP
919  * Section 5.2.2 SCTP Header Information Structure (SCTP_SNDRCV)
920  *
921  * sinfo_stream: 16 bits (unsigned integer)
922  *
923  * For recvmsg() the SCTP stack places the message's stream number in
924  * this value.
925  */
926  sinfo.sinfo_stream = event->stream;
927  /* sinfo_ssn: 16 bits (unsigned integer)
928  *
929  * For recvmsg() this value contains the stream sequence number that
930  * the remote endpoint placed in the DATA chunk. For fragmented
931  * messages this is the same number for all deliveries of the message
932  * (if more than one recvmsg() is needed to read the message).
933  */
934  sinfo.sinfo_ssn = event->ssn;
935  /* sinfo_ppid: 32 bits (unsigned integer)
936  *
937  * In recvmsg() this value is
938  * the same information that was passed by the upper layer in the peer
939  * application. Please note that byte order issues are NOT accounted
940  * for and this information is passed opaquely by the SCTP stack from
941  * one end to the other.
942  */
943  sinfo.sinfo_ppid = event->ppid;
944  /* sinfo_flags: 16 bits (unsigned integer)
945  *
946  * This field may contain any of the following flags and is composed of
947  * a bitwise OR of these values.
948  *
949  * recvmsg() flags:
950  *
951  * SCTP_UNORDERED - This flag is present when the message was sent
952  * non-ordered.
953  */
954  sinfo.sinfo_flags = event->flags;
955  /* sinfo_tsn: 32 bit (unsigned integer)
956  *
957  * For the receiving side, this field holds a TSN that was
958  * assigned to one of the SCTP Data Chunks.
959  */
960  sinfo.sinfo_tsn = event->tsn;
961  /* sinfo_cumtsn: 32 bit (unsigned integer)
962  *
963  * This field will hold the current cumulative TSN as
964  * known by the underlying SCTP layer. Note this field is
965  * ignored when sending and only valid for a receive
966  * operation when sinfo_flags are set to SCTP_UNORDERED.
967  */
968  sinfo.sinfo_cumtsn = event->cumtsn;
969  /* sinfo_assoc_id: sizeof (sctp_assoc_t)
970  *
971  * The association handle field, sinfo_assoc_id, holds the identifier
972  * for the association announced in the COMMUNICATION_UP notification.
973  * All notifications for a given association have the same identifier.
974  * Ignored for one-to-one style sockets.
975  */
976  sinfo.sinfo_assoc_id = sctp_assoc2id(event->asoc);
977 
978  /* context value that is set via SCTP_CONTEXT socket option. */
979  sinfo.sinfo_context = event->asoc->default_rcv_context;
980 
981  /* These fields are not used while receiving. */
982  sinfo.sinfo_timetolive = 0;
983 
985  sizeof(struct sctp_sndrcvinfo), (void *)&sinfo);
986 }
987 
988 /* Do accounting for bytes received and hold a reference to the association
989  * for each skb.
990  */
991 static void sctp_ulpevent_receive_data(struct sctp_ulpevent *event,
992  struct sctp_association *asoc)
993 {
994  struct sk_buff *skb, *frag;
995 
996  skb = sctp_event2skb(event);
997  /* Set the owner and charge rwnd for bytes received. */
998  sctp_ulpevent_set_owner(event, asoc);
999  sctp_assoc_rwnd_decrease(asoc, skb_headlen(skb));
1000 
1001  if (!skb->data_len)
1002  return;
1003 
1004  /* Note: Not clearing the entire event struct as this is just a
1005  * fragment of the real event. However, we still need to do rwnd
1006  * accounting.
1007  * In general, the skb passed from IP can have only 1 level of
1008  * fragments. But we allow multiple levels of fragments.
1009  */
1010  skb_walk_frags(skb, frag)
1011  sctp_ulpevent_receive_data(sctp_skb2event(frag), asoc);
1012 }
1013 
1014 /* Do accounting for bytes just read by user and release the references to
1015  * the association.
1016  */
1017 static void sctp_ulpevent_release_data(struct sctp_ulpevent *event)
1018 {
1019  struct sk_buff *skb, *frag;
1020  unsigned int len;
1021 
1022  /* Current stack structures assume that the rcv buffer is
1023  * per socket. For UDP style sockets this is not true as
1024  * multiple associations may be on a single UDP-style socket.
1025  * Use the local private area of the skb to track the owning
1026  * association.
1027  */
1028 
1029  skb = sctp_event2skb(event);
1030  len = skb->len;
1031 
1032  if (!skb->data_len)
1033  goto done;
1034 
1035  /* Don't forget the fragments. */
1036  skb_walk_frags(skb, frag) {
1037  /* NOTE: skb_shinfos are recursive. Although IP returns
1038  * skb's with only 1 level of fragments, SCTP reassembly can
1039  * increase the levels.
1040  */
1041  sctp_ulpevent_release_frag_data(sctp_skb2event(frag));
1042  }
1043 
1044 done:
1045  sctp_assoc_rwnd_increase(event->asoc, len);
1046  sctp_ulpevent_release_owner(event);
1047 }
1048 
1049 static void sctp_ulpevent_release_frag_data(struct sctp_ulpevent *event)
1050 {
1051  struct sk_buff *skb, *frag;
1052 
1053  skb = sctp_event2skb(event);
1054 
1055  if (!skb->data_len)
1056  goto done;
1057 
1058  /* Don't forget the fragments. */
1059  skb_walk_frags(skb, frag) {
1060  /* NOTE: skb_shinfos are recursive. Although IP returns
1061  * skb's with only 1 level of fragments, SCTP reassembly can
1062  * increase the levels.
1063  */
1064  sctp_ulpevent_release_frag_data(sctp_skb2event(frag));
1065  }
1066 
1067 done:
1068  sctp_ulpevent_release_owner(event);
1069 }
1070 
1071 /* Free a ulpevent that has an owner. It includes releasing the reference
1072  * to the owner, updating the rwnd in case of a DATA event and freeing the
1073  * skb.
1074  */
1076 {
1077  if (sctp_ulpevent_is_notification(event))
1078  sctp_ulpevent_release_owner(event);
1079  else
1080  sctp_ulpevent_release_data(event);
1081 
1082  kfree_skb(sctp_event2skb(event));
1083 }
1084 
1085 /* Purge the skb lists holding ulpevents. */
1087 {
1088  struct sk_buff *skb;
1089  unsigned int data_unread = 0;
1090 
1091  while ((skb = skb_dequeue(list)) != NULL) {
1092  struct sctp_ulpevent *event = sctp_skb2event(skb);
1093 
1094  if (!sctp_ulpevent_is_notification(event))
1095  data_unread += skb->len;
1096 
1097  sctp_ulpevent_free(event);
1098  }
1099 
1100  return data_unread;
1101 }