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
9 * These functions manipulate an sctp event. The struct ulpevent is used
10 * to carry notifications and data to the ULP (sockets).
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)
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.
24 * You should have received a copy of the GNU General Public License
25 * along with GNU CC; see the file COPYING. If not, see
26 * <http://www.gnu.org/licenses/>.
28 * Please send any bug reports or fixes you make to the
30 * lksctp developers <linux-sctp@vger.kernel.org>
32 * Written or modified by:
33 * Jon Grimm <jgrimm@us.ibm.com>
34 * La Monte H.P. Yarroll <piggy@acm.org>
35 * Ardelle Fan <ardelle.fan@intel.com>
36 * Sridhar Samudrala <sri@us.ibm.com>
39 #include <linux/slab.h>
40 #include <linux/types.h>
41 #include <linux/skbuff.h>
42 #include <net/sctp/structs.h>
43 #include <net/sctp/sctp.h>
44 #include <net/sctp/sm.h>
46 static void sctp_ulpevent_receive_data(struct sctp_ulpevent
*event
,
47 struct sctp_association
*asoc
);
48 static void sctp_ulpevent_release_data(struct sctp_ulpevent
*event
);
49 static void sctp_ulpevent_release_frag_data(struct sctp_ulpevent
*event
);
52 /* Initialize an ULP event from an given skb. */
53 static void sctp_ulpevent_init(struct sctp_ulpevent
*event
,
57 memset(event
, 0, sizeof(struct sctp_ulpevent
));
58 event
->msg_flags
= msg_flags
;
59 event
->rmem_len
= len
;
62 /* Create a new sctp_ulpevent. */
63 static struct sctp_ulpevent
*sctp_ulpevent_new(int size
, __u16 msg_flags
,
66 struct sctp_ulpevent
*event
;
69 skb
= alloc_skb(size
, gfp
);
73 event
= sctp_skb2event(skb
);
74 sctp_ulpevent_init(event
, msg_flags
, skb
->truesize
);
82 /* Is this a MSG_NOTIFICATION? */
83 int sctp_ulpevent_is_notification(const struct sctp_ulpevent
*event
)
85 return MSG_NOTIFICATION
== (event
->msg_flags
& MSG_NOTIFICATION
);
88 /* Hold the association in case the msg_name needs read out of
91 static inline void sctp_ulpevent_set_owner(struct sctp_ulpevent
*event
,
92 const struct sctp_association
*asoc
)
94 struct sctp_chunk
*chunk
= event
->chunk
;
97 /* Cast away the const, as we are just wanting to
98 * bump the reference count.
100 sctp_association_hold((struct sctp_association
*)asoc
);
101 skb
= sctp_event2skb(event
);
102 event
->asoc
= (struct sctp_association
*)asoc
;
103 atomic_add(event
->rmem_len
, &event
->asoc
->rmem_alloc
);
104 sctp_skb_set_owner_r(skb
, asoc
->base
.sk
);
105 if (chunk
&& chunk
->head_skb
&& !chunk
->head_skb
->sk
)
106 chunk
->head_skb
->sk
= asoc
->base
.sk
;
109 /* A simple destructor to give up the reference to the association. */
110 static inline void sctp_ulpevent_release_owner(struct sctp_ulpevent
*event
)
112 struct sctp_association
*asoc
= event
->asoc
;
114 atomic_sub(event
->rmem_len
, &asoc
->rmem_alloc
);
115 sctp_association_put(asoc
);
118 /* Create and initialize an SCTP_ASSOC_CHANGE event.
120 * 5.3.1.1 SCTP_ASSOC_CHANGE
122 * Communication notifications inform the ULP that an SCTP association
123 * has either begun or ended. The identifier for a new association is
124 * provided by this notification.
126 * Note: There is no field checking here. If a field is unused it will be
129 struct sctp_ulpevent
*sctp_ulpevent_make_assoc_change(
130 const struct sctp_association
*asoc
,
131 __u16 flags
, __u16 state
, __u16 error
, __u16 outbound
,
132 __u16 inbound
, struct sctp_chunk
*chunk
, gfp_t gfp
)
134 struct sctp_ulpevent
*event
;
135 struct sctp_assoc_change
*sac
;
138 /* If the lower layer passed in the chunk, it will be
139 * an ABORT, so we need to include it in the sac_info.
142 /* Copy the chunk data to a new skb and reserve enough
143 * head room to use as notification.
145 skb
= skb_copy_expand(chunk
->skb
,
146 sizeof(struct sctp_assoc_change
), 0, gfp
);
151 /* Embed the event fields inside the cloned skb. */
152 event
= sctp_skb2event(skb
);
153 sctp_ulpevent_init(event
, MSG_NOTIFICATION
, skb
->truesize
);
155 /* Include the notification structure */
156 sac
= skb_push(skb
, sizeof(struct sctp_assoc_change
));
158 /* Trim the buffer to the right length. */
159 skb_trim(skb
, sizeof(struct sctp_assoc_change
) +
160 ntohs(chunk
->chunk_hdr
->length
) -
161 sizeof(struct sctp_chunkhdr
));
163 event
= sctp_ulpevent_new(sizeof(struct sctp_assoc_change
),
164 MSG_NOTIFICATION
, gfp
);
168 skb
= sctp_event2skb(event
);
169 sac
= skb_put(skb
, sizeof(struct sctp_assoc_change
));
172 /* Socket Extensions for SCTP
173 * 5.3.1.1 SCTP_ASSOC_CHANGE
176 * It should be SCTP_ASSOC_CHANGE.
178 sac
->sac_type
= SCTP_ASSOC_CHANGE
;
180 /* Socket Extensions for SCTP
181 * 5.3.1.1 SCTP_ASSOC_CHANGE
183 * sac_state: 32 bits (signed integer)
184 * This field holds one of a number of values that communicate the
185 * event that happened to the association.
187 sac
->sac_state
= state
;
189 /* Socket Extensions for SCTP
190 * 5.3.1.1 SCTP_ASSOC_CHANGE
192 * sac_flags: 16 bits (unsigned integer)
197 /* Socket Extensions for SCTP
198 * 5.3.1.1 SCTP_ASSOC_CHANGE
200 * sac_length: sizeof (__u32)
201 * This field is the total length of the notification data, including
202 * the notification header.
204 sac
->sac_length
= skb
->len
;
206 /* Socket Extensions for SCTP
207 * 5.3.1.1 SCTP_ASSOC_CHANGE
209 * sac_error: 32 bits (signed integer)
211 * If the state was reached due to a error condition (e.g.
212 * COMMUNICATION_LOST) any relevant error information is available in
213 * this field. This corresponds to the protocol error codes defined in
216 sac
->sac_error
= error
;
218 /* Socket Extensions for SCTP
219 * 5.3.1.1 SCTP_ASSOC_CHANGE
221 * sac_outbound_streams: 16 bits (unsigned integer)
222 * sac_inbound_streams: 16 bits (unsigned integer)
224 * The maximum number of streams allowed in each direction are
225 * available in sac_outbound_streams and sac_inbound streams.
227 sac
->sac_outbound_streams
= outbound
;
228 sac
->sac_inbound_streams
= inbound
;
230 /* Socket Extensions for SCTP
231 * 5.3.1.1 SCTP_ASSOC_CHANGE
233 * sac_assoc_id: sizeof (sctp_assoc_t)
235 * The association id field, holds the identifier for the association.
236 * All notifications for a given association have the same association
237 * identifier. For TCP style socket, this field is ignored.
239 sctp_ulpevent_set_owner(event
, asoc
);
240 sac
->sac_assoc_id
= sctp_assoc2id(asoc
);
248 /* Create and initialize an SCTP_PEER_ADDR_CHANGE event.
250 * Socket Extensions for SCTP - draft-01
251 * 5.3.1.2 SCTP_PEER_ADDR_CHANGE
253 * When a destination address on a multi-homed peer encounters a change
254 * an interface details event is sent.
256 struct sctp_ulpevent
*sctp_ulpevent_make_peer_addr_change(
257 const struct sctp_association
*asoc
,
258 const struct sockaddr_storage
*aaddr
,
259 int flags
, int state
, int error
, gfp_t gfp
)
261 struct sctp_ulpevent
*event
;
262 struct sctp_paddr_change
*spc
;
265 event
= sctp_ulpevent_new(sizeof(struct sctp_paddr_change
),
266 MSG_NOTIFICATION
, gfp
);
270 skb
= sctp_event2skb(event
);
271 spc
= skb_put(skb
, sizeof(struct sctp_paddr_change
));
273 /* Sockets API Extensions for SCTP
274 * Section 5.3.1.2 SCTP_PEER_ADDR_CHANGE
278 * It should be SCTP_PEER_ADDR_CHANGE.
280 spc
->spc_type
= SCTP_PEER_ADDR_CHANGE
;
282 /* Sockets API Extensions for SCTP
283 * Section 5.3.1.2 SCTP_PEER_ADDR_CHANGE
285 * spc_length: sizeof (__u32)
287 * This field is the total length of the notification data, including
288 * the notification header.
290 spc
->spc_length
= sizeof(struct sctp_paddr_change
);
292 /* Sockets API Extensions for SCTP
293 * Section 5.3.1.2 SCTP_PEER_ADDR_CHANGE
295 * spc_flags: 16 bits (unsigned integer)
300 /* Sockets API Extensions for SCTP
301 * Section 5.3.1.2 SCTP_PEER_ADDR_CHANGE
303 * spc_state: 32 bits (signed integer)
305 * This field holds one of a number of values that communicate the
306 * event that happened to the address.
308 spc
->spc_state
= state
;
310 /* Sockets API Extensions for SCTP
311 * Section 5.3.1.2 SCTP_PEER_ADDR_CHANGE
313 * spc_error: 32 bits (signed integer)
315 * If the state was reached due to any error condition (e.g.
316 * ADDRESS_UNREACHABLE) any relevant error information is available in
319 spc
->spc_error
= error
;
321 /* Socket Extensions for SCTP
322 * 5.3.1.1 SCTP_ASSOC_CHANGE
324 * spc_assoc_id: sizeof (sctp_assoc_t)
326 * The association id field, holds the identifier for the association.
327 * All notifications for a given association have the same association
328 * identifier. For TCP style socket, this field is ignored.
330 sctp_ulpevent_set_owner(event
, asoc
);
331 spc
->spc_assoc_id
= sctp_assoc2id(asoc
);
333 /* Sockets API Extensions for SCTP
334 * Section 5.3.1.2 SCTP_PEER_ADDR_CHANGE
336 * spc_aaddr: sizeof (struct sockaddr_storage)
338 * The affected address field, holds the remote peer's address that is
339 * encountering the change of state.
341 memcpy(&spc
->spc_aaddr
, aaddr
, sizeof(struct sockaddr_storage
));
343 /* Map ipv4 address into v4-mapped-on-v6 address. */
344 sctp_get_pf_specific(asoc
->base
.sk
->sk_family
)->addr_to_user(
345 sctp_sk(asoc
->base
.sk
),
346 (union sctp_addr
*)&spc
->spc_aaddr
);
354 /* Create and initialize an SCTP_REMOTE_ERROR notification.
356 * Note: This assumes that the chunk->skb->data already points to the
357 * operation error payload.
359 * Socket Extensions for SCTP - draft-01
360 * 5.3.1.3 SCTP_REMOTE_ERROR
362 * A remote peer may send an Operational Error message to its peer.
363 * This message indicates a variety of error conditions on an
364 * association. The entire error TLV as it appears on the wire is
365 * included in a SCTP_REMOTE_ERROR event. Please refer to the SCTP
366 * specification [SCTP] and any extensions for a list of possible
369 struct sctp_ulpevent
*
370 sctp_ulpevent_make_remote_error(const struct sctp_association
*asoc
,
371 struct sctp_chunk
*chunk
, __u16 flags
,
374 struct sctp_remote_error
*sre
;
375 struct sctp_ulpevent
*event
;
376 struct sctp_errhdr
*ch
;
381 ch
= (struct sctp_errhdr
*)(chunk
->skb
->data
);
383 elen
= SCTP_PAD4(ntohs(ch
->length
)) - sizeof(*ch
);
385 /* Pull off the ERROR header. */
386 skb_pull(chunk
->skb
, sizeof(*ch
));
388 /* Copy the skb to a new skb with room for us to prepend
391 skb
= skb_copy_expand(chunk
->skb
, sizeof(*sre
), 0, gfp
);
393 /* Pull off the rest of the cause TLV from the chunk. */
394 skb_pull(chunk
->skb
, elen
);
398 /* Embed the event fields inside the cloned skb. */
399 event
= sctp_skb2event(skb
);
400 sctp_ulpevent_init(event
, MSG_NOTIFICATION
, skb
->truesize
);
402 sre
= skb_push(skb
, sizeof(*sre
));
404 /* Trim the buffer to the right length. */
405 skb_trim(skb
, sizeof(*sre
) + elen
);
407 /* RFC6458, Section 6.1.3. SCTP_REMOTE_ERROR */
408 memset(sre
, 0, sizeof(*sre
));
409 sre
->sre_type
= SCTP_REMOTE_ERROR
;
411 sre
->sre_length
= skb
->len
;
412 sre
->sre_error
= cause
;
413 sctp_ulpevent_set_owner(event
, asoc
);
414 sre
->sre_assoc_id
= sctp_assoc2id(asoc
);
421 /* Create and initialize a SCTP_SEND_FAILED notification.
423 * Socket Extensions for SCTP - draft-01
424 * 5.3.1.4 SCTP_SEND_FAILED
426 struct sctp_ulpevent
*sctp_ulpevent_make_send_failed(
427 const struct sctp_association
*asoc
, struct sctp_chunk
*chunk
,
428 __u16 flags
, __u32 error
, gfp_t gfp
)
430 struct sctp_ulpevent
*event
;
431 struct sctp_send_failed
*ssf
;
434 /* Pull off any padding. */
435 int len
= ntohs(chunk
->chunk_hdr
->length
);
437 /* Make skb with more room so we can prepend notification. */
438 skb
= skb_copy_expand(chunk
->skb
,
439 sizeof(struct sctp_send_failed
), /* headroom */
445 /* Pull off the common chunk header and DATA header. */
446 skb_pull(skb
, sctp_datachk_len(&asoc
->stream
));
447 len
-= sctp_datachk_len(&asoc
->stream
);
449 /* Embed the event fields inside the cloned skb. */
450 event
= sctp_skb2event(skb
);
451 sctp_ulpevent_init(event
, MSG_NOTIFICATION
, skb
->truesize
);
453 ssf
= skb_push(skb
, sizeof(struct sctp_send_failed
));
455 /* Socket Extensions for SCTP
456 * 5.3.1.4 SCTP_SEND_FAILED
459 * It should be SCTP_SEND_FAILED.
461 ssf
->ssf_type
= SCTP_SEND_FAILED
;
463 /* Socket Extensions for SCTP
464 * 5.3.1.4 SCTP_SEND_FAILED
466 * ssf_flags: 16 bits (unsigned integer)
467 * The flag value will take one of the following values
469 * SCTP_DATA_UNSENT - Indicates that the data was never put on
472 * SCTP_DATA_SENT - Indicates that the data was put on the wire.
473 * Note that this does not necessarily mean that the
474 * data was (or was not) successfully delivered.
476 ssf
->ssf_flags
= flags
;
478 /* Socket Extensions for SCTP
479 * 5.3.1.4 SCTP_SEND_FAILED
481 * ssf_length: sizeof (__u32)
482 * This field is the total length of the notification data, including
483 * the notification header.
485 ssf
->ssf_length
= sizeof(struct sctp_send_failed
) + len
;
486 skb_trim(skb
, ssf
->ssf_length
);
488 /* Socket Extensions for SCTP
489 * 5.3.1.4 SCTP_SEND_FAILED
491 * ssf_error: 16 bits (unsigned integer)
492 * This value represents the reason why the send failed, and if set,
493 * will be a SCTP protocol error code as defined in [SCTP] section
496 ssf
->ssf_error
= error
;
498 /* Socket Extensions for SCTP
499 * 5.3.1.4 SCTP_SEND_FAILED
501 * ssf_info: sizeof (struct sctp_sndrcvinfo)
502 * The original send information associated with the undelivered
505 memcpy(&ssf
->ssf_info
, &chunk
->sinfo
, sizeof(struct sctp_sndrcvinfo
));
507 /* Per TSVWG discussion with Randy. Allow the application to
508 * reassemble a fragmented message.
510 ssf
->ssf_info
.sinfo_flags
= chunk
->chunk_hdr
->flags
;
512 /* Socket Extensions for SCTP
513 * 5.3.1.4 SCTP_SEND_FAILED
515 * ssf_assoc_id: sizeof (sctp_assoc_t)
516 * The association id field, sf_assoc_id, holds the identifier for the
517 * association. All notifications for a given association have the
518 * same association identifier. For TCP style socket, this field is
521 sctp_ulpevent_set_owner(event
, asoc
);
522 ssf
->ssf_assoc_id
= sctp_assoc2id(asoc
);
529 /* Create and initialize a SCTP_SHUTDOWN_EVENT notification.
531 * Socket Extensions for SCTP - draft-01
532 * 5.3.1.5 SCTP_SHUTDOWN_EVENT
534 struct sctp_ulpevent
*sctp_ulpevent_make_shutdown_event(
535 const struct sctp_association
*asoc
,
536 __u16 flags
, gfp_t gfp
)
538 struct sctp_ulpevent
*event
;
539 struct sctp_shutdown_event
*sse
;
542 event
= sctp_ulpevent_new(sizeof(struct sctp_shutdown_event
),
543 MSG_NOTIFICATION
, gfp
);
547 skb
= sctp_event2skb(event
);
548 sse
= skb_put(skb
, sizeof(struct sctp_shutdown_event
));
550 /* Socket Extensions for SCTP
551 * 5.3.1.5 SCTP_SHUTDOWN_EVENT
554 * It should be SCTP_SHUTDOWN_EVENT
556 sse
->sse_type
= SCTP_SHUTDOWN_EVENT
;
558 /* Socket Extensions for SCTP
559 * 5.3.1.5 SCTP_SHUTDOWN_EVENT
561 * sse_flags: 16 bits (unsigned integer)
566 /* Socket Extensions for SCTP
567 * 5.3.1.5 SCTP_SHUTDOWN_EVENT
569 * sse_length: sizeof (__u32)
570 * This field is the total length of the notification data, including
571 * the notification header.
573 sse
->sse_length
= sizeof(struct sctp_shutdown_event
);
575 /* Socket Extensions for SCTP
576 * 5.3.1.5 SCTP_SHUTDOWN_EVENT
578 * sse_assoc_id: sizeof (sctp_assoc_t)
579 * The association id field, holds the identifier for the association.
580 * All notifications for a given association have the same association
581 * identifier. For TCP style socket, this field is ignored.
583 sctp_ulpevent_set_owner(event
, asoc
);
584 sse
->sse_assoc_id
= sctp_assoc2id(asoc
);
592 /* Create and initialize a SCTP_ADAPTATION_INDICATION notification.
594 * Socket Extensions for SCTP
595 * 5.3.1.6 SCTP_ADAPTATION_INDICATION
597 struct sctp_ulpevent
*sctp_ulpevent_make_adaptation_indication(
598 const struct sctp_association
*asoc
, gfp_t gfp
)
600 struct sctp_ulpevent
*event
;
601 struct sctp_adaptation_event
*sai
;
604 event
= sctp_ulpevent_new(sizeof(struct sctp_adaptation_event
),
605 MSG_NOTIFICATION
, gfp
);
609 skb
= sctp_event2skb(event
);
610 sai
= skb_put(skb
, sizeof(struct sctp_adaptation_event
));
612 sai
->sai_type
= SCTP_ADAPTATION_INDICATION
;
614 sai
->sai_length
= sizeof(struct sctp_adaptation_event
);
615 sai
->sai_adaptation_ind
= asoc
->peer
.adaptation_ind
;
616 sctp_ulpevent_set_owner(event
, asoc
);
617 sai
->sai_assoc_id
= sctp_assoc2id(asoc
);
625 /* A message has been received. Package this message as a notification
626 * to pass it to the upper layers. Go ahead and calculate the sndrcvinfo
627 * even if filtered out later.
629 * Socket Extensions for SCTP
630 * 5.2.2 SCTP Header Information Structure (SCTP_SNDRCV)
632 struct sctp_ulpevent
*sctp_ulpevent_make_rcvmsg(struct sctp_association
*asoc
,
633 struct sctp_chunk
*chunk
,
636 struct sctp_ulpevent
*event
= NULL
;
642 * check to see if we need to make space for this
643 * new skb, expand the rcvbuffer if needed, or drop
646 if (asoc
->ep
->rcvbuf_policy
)
647 rx_count
= atomic_read(&asoc
->rmem_alloc
);
649 rx_count
= atomic_read(&asoc
->base
.sk
->sk_rmem_alloc
);
651 if (rx_count
>= asoc
->base
.sk
->sk_rcvbuf
) {
653 if ((asoc
->base
.sk
->sk_userlocks
& SOCK_RCVBUF_LOCK
) ||
654 (!sk_rmem_schedule(asoc
->base
.sk
, chunk
->skb
,
655 chunk
->skb
->truesize
)))
659 /* Clone the original skb, sharing the data. */
660 skb
= skb_clone(chunk
->skb
, gfp
);
664 /* Now that all memory allocations for this chunk succeeded, we
665 * can mark it as received so the tsn_map is updated correctly.
667 if (sctp_tsnmap_mark(&asoc
->peer
.tsn_map
,
668 ntohl(chunk
->subh
.data_hdr
->tsn
),
672 /* First calculate the padding, so we don't inadvertently
673 * pass up the wrong length to the user.
675 * RFC 2960 - Section 3.2 Chunk Field Descriptions
677 * The total length of a chunk(including Type, Length and Value fields)
678 * MUST be a multiple of 4 bytes. If the length of the chunk is not a
679 * multiple of 4 bytes, the sender MUST pad the chunk with all zero
680 * bytes and this padding is not included in the chunk length field.
681 * The sender should never pad with more than 3 bytes. The receiver
682 * MUST ignore the padding bytes.
684 len
= ntohs(chunk
->chunk_hdr
->length
);
685 padding
= SCTP_PAD4(len
) - len
;
687 /* Fixup cloned skb with just this chunks data. */
688 skb_trim(skb
, chunk
->chunk_end
- padding
- skb
->data
);
690 /* Embed the event fields inside the cloned skb. */
691 event
= sctp_skb2event(skb
);
693 /* Initialize event with flags 0 and correct length
694 * Since this is a clone of the original skb, only account for
695 * the data of this chunk as other chunks will be accounted separately.
697 sctp_ulpevent_init(event
, 0, skb
->len
+ sizeof(struct sk_buff
));
699 /* And hold the chunk as we need it for getting the IP headers
702 sctp_chunk_hold(chunk
);
703 event
->chunk
= chunk
;
705 sctp_ulpevent_receive_data(event
, asoc
);
707 event
->stream
= ntohs(chunk
->subh
.data_hdr
->stream
);
708 if (chunk
->chunk_hdr
->flags
& SCTP_DATA_UNORDERED
) {
709 event
->flags
|= SCTP_UNORDERED
;
710 event
->cumtsn
= sctp_tsnmap_get_ctsn(&asoc
->peer
.tsn_map
);
712 event
->tsn
= ntohl(chunk
->subh
.data_hdr
->tsn
);
713 event
->msg_flags
|= chunk
->chunk_hdr
->flags
;
718 sctp_chunk_put(chunk
);
724 /* Create a partial delivery related event.
726 * 5.3.1.7 SCTP_PARTIAL_DELIVERY_EVENT
728 * When a receiver is engaged in a partial delivery of a
729 * message this notification will be used to indicate
732 struct sctp_ulpevent
*sctp_ulpevent_make_pdapi(
733 const struct sctp_association
*asoc
, __u32 indication
,
736 struct sctp_ulpevent
*event
;
737 struct sctp_pdapi_event
*pd
;
740 event
= sctp_ulpevent_new(sizeof(struct sctp_pdapi_event
),
741 MSG_NOTIFICATION
, gfp
);
745 skb
= sctp_event2skb(event
);
746 pd
= skb_put(skb
, sizeof(struct sctp_pdapi_event
));
749 * It should be SCTP_PARTIAL_DELIVERY_EVENT
751 * pdapi_flags: 16 bits (unsigned integer)
754 pd
->pdapi_type
= SCTP_PARTIAL_DELIVERY_EVENT
;
757 /* pdapi_length: 32 bits (unsigned integer)
759 * This field is the total length of the notification data, including
760 * the notification header. It will generally be sizeof (struct
763 pd
->pdapi_length
= sizeof(struct sctp_pdapi_event
);
765 /* pdapi_indication: 32 bits (unsigned integer)
767 * This field holds the indication being sent to the application.
769 pd
->pdapi_indication
= indication
;
771 /* pdapi_assoc_id: sizeof (sctp_assoc_t)
773 * The association id field, holds the identifier for the association.
775 sctp_ulpevent_set_owner(event
, asoc
);
776 pd
->pdapi_assoc_id
= sctp_assoc2id(asoc
);
783 struct sctp_ulpevent
*sctp_ulpevent_make_authkey(
784 const struct sctp_association
*asoc
, __u16 key_id
,
785 __u32 indication
, gfp_t gfp
)
787 struct sctp_ulpevent
*event
;
788 struct sctp_authkey_event
*ak
;
791 event
= sctp_ulpevent_new(sizeof(struct sctp_authkey_event
),
792 MSG_NOTIFICATION
, gfp
);
796 skb
= sctp_event2skb(event
);
797 ak
= skb_put(skb
, sizeof(struct sctp_authkey_event
));
799 ak
->auth_type
= SCTP_AUTHENTICATION_EVENT
;
801 ak
->auth_length
= sizeof(struct sctp_authkey_event
);
803 ak
->auth_keynumber
= key_id
;
804 ak
->auth_altkeynumber
= 0;
805 ak
->auth_indication
= indication
;
808 * The association id field, holds the identifier for the association.
810 sctp_ulpevent_set_owner(event
, asoc
);
811 ak
->auth_assoc_id
= sctp_assoc2id(asoc
);
819 * Socket Extensions for SCTP
820 * 6.3.10. SCTP_SENDER_DRY_EVENT
822 struct sctp_ulpevent
*sctp_ulpevent_make_sender_dry_event(
823 const struct sctp_association
*asoc
, gfp_t gfp
)
825 struct sctp_ulpevent
*event
;
826 struct sctp_sender_dry_event
*sdry
;
829 event
= sctp_ulpevent_new(sizeof(struct sctp_sender_dry_event
),
830 MSG_NOTIFICATION
, gfp
);
834 skb
= sctp_event2skb(event
);
835 sdry
= skb_put(skb
, sizeof(struct sctp_sender_dry_event
));
837 sdry
->sender_dry_type
= SCTP_SENDER_DRY_EVENT
;
838 sdry
->sender_dry_flags
= 0;
839 sdry
->sender_dry_length
= sizeof(struct sctp_sender_dry_event
);
840 sctp_ulpevent_set_owner(event
, asoc
);
841 sdry
->sender_dry_assoc_id
= sctp_assoc2id(asoc
);
846 struct sctp_ulpevent
*sctp_ulpevent_make_stream_reset_event(
847 const struct sctp_association
*asoc
, __u16 flags
, __u16 stream_num
,
848 __be16
*stream_list
, gfp_t gfp
)
850 struct sctp_stream_reset_event
*sreset
;
851 struct sctp_ulpevent
*event
;
855 length
= sizeof(struct sctp_stream_reset_event
) + 2 * stream_num
;
856 event
= sctp_ulpevent_new(length
, MSG_NOTIFICATION
, gfp
);
860 skb
= sctp_event2skb(event
);
861 sreset
= skb_put(skb
, length
);
863 sreset
->strreset_type
= SCTP_STREAM_RESET_EVENT
;
864 sreset
->strreset_flags
= flags
;
865 sreset
->strreset_length
= length
;
866 sctp_ulpevent_set_owner(event
, asoc
);
867 sreset
->strreset_assoc_id
= sctp_assoc2id(asoc
);
869 for (i
= 0; i
< stream_num
; i
++)
870 sreset
->strreset_stream_list
[i
] = ntohs(stream_list
[i
]);
875 struct sctp_ulpevent
*sctp_ulpevent_make_assoc_reset_event(
876 const struct sctp_association
*asoc
, __u16 flags
, __u32 local_tsn
,
877 __u32 remote_tsn
, gfp_t gfp
)
879 struct sctp_assoc_reset_event
*areset
;
880 struct sctp_ulpevent
*event
;
883 event
= sctp_ulpevent_new(sizeof(struct sctp_assoc_reset_event
),
884 MSG_NOTIFICATION
, gfp
);
888 skb
= sctp_event2skb(event
);
889 areset
= skb_put(skb
, sizeof(struct sctp_assoc_reset_event
));
891 areset
->assocreset_type
= SCTP_ASSOC_RESET_EVENT
;
892 areset
->assocreset_flags
= flags
;
893 areset
->assocreset_length
= sizeof(struct sctp_assoc_reset_event
);
894 sctp_ulpevent_set_owner(event
, asoc
);
895 areset
->assocreset_assoc_id
= sctp_assoc2id(asoc
);
896 areset
->assocreset_local_tsn
= local_tsn
;
897 areset
->assocreset_remote_tsn
= remote_tsn
;
902 struct sctp_ulpevent
*sctp_ulpevent_make_stream_change_event(
903 const struct sctp_association
*asoc
, __u16 flags
,
904 __u32 strchange_instrms
, __u32 strchange_outstrms
, gfp_t gfp
)
906 struct sctp_stream_change_event
*schange
;
907 struct sctp_ulpevent
*event
;
910 event
= sctp_ulpevent_new(sizeof(struct sctp_stream_change_event
),
911 MSG_NOTIFICATION
, gfp
);
915 skb
= sctp_event2skb(event
);
916 schange
= skb_put(skb
, sizeof(struct sctp_stream_change_event
));
918 schange
->strchange_type
= SCTP_STREAM_CHANGE_EVENT
;
919 schange
->strchange_flags
= flags
;
920 schange
->strchange_length
= sizeof(struct sctp_stream_change_event
);
921 sctp_ulpevent_set_owner(event
, asoc
);
922 schange
->strchange_assoc_id
= sctp_assoc2id(asoc
);
923 schange
->strchange_instrms
= strchange_instrms
;
924 schange
->strchange_outstrms
= strchange_outstrms
;
929 /* Return the notification type, assuming this is a notification
932 __u16
sctp_ulpevent_get_notification_type(const struct sctp_ulpevent
*event
)
934 union sctp_notification
*notification
;
937 skb
= sctp_event2skb(event
);
938 notification
= (union sctp_notification
*) skb
->data
;
939 return notification
->sn_header
.sn_type
;
942 /* RFC6458, Section 5.3.2. SCTP Header Information Structure
943 * (SCTP_SNDRCV, DEPRECATED)
945 void sctp_ulpevent_read_sndrcvinfo(const struct sctp_ulpevent
*event
,
946 struct msghdr
*msghdr
)
948 struct sctp_sndrcvinfo sinfo
;
950 if (sctp_ulpevent_is_notification(event
))
953 memset(&sinfo
, 0, sizeof(sinfo
));
954 sinfo
.sinfo_stream
= event
->stream
;
955 sinfo
.sinfo_ssn
= event
->ssn
;
956 sinfo
.sinfo_ppid
= event
->ppid
;
957 sinfo
.sinfo_flags
= event
->flags
;
958 sinfo
.sinfo_tsn
= event
->tsn
;
959 sinfo
.sinfo_cumtsn
= event
->cumtsn
;
960 sinfo
.sinfo_assoc_id
= sctp_assoc2id(event
->asoc
);
961 /* Context value that is set via SCTP_CONTEXT socket option. */
962 sinfo
.sinfo_context
= event
->asoc
->default_rcv_context
;
963 /* These fields are not used while receiving. */
964 sinfo
.sinfo_timetolive
= 0;
966 put_cmsg(msghdr
, IPPROTO_SCTP
, SCTP_SNDRCV
,
967 sizeof(sinfo
), &sinfo
);
970 /* RFC6458, Section 5.3.5 SCTP Receive Information Structure
973 void sctp_ulpevent_read_rcvinfo(const struct sctp_ulpevent
*event
,
974 struct msghdr
*msghdr
)
976 struct sctp_rcvinfo rinfo
;
978 if (sctp_ulpevent_is_notification(event
))
981 memset(&rinfo
, 0, sizeof(struct sctp_rcvinfo
));
982 rinfo
.rcv_sid
= event
->stream
;
983 rinfo
.rcv_ssn
= event
->ssn
;
984 rinfo
.rcv_ppid
= event
->ppid
;
985 rinfo
.rcv_flags
= event
->flags
;
986 rinfo
.rcv_tsn
= event
->tsn
;
987 rinfo
.rcv_cumtsn
= event
->cumtsn
;
988 rinfo
.rcv_assoc_id
= sctp_assoc2id(event
->asoc
);
989 rinfo
.rcv_context
= event
->asoc
->default_rcv_context
;
991 put_cmsg(msghdr
, IPPROTO_SCTP
, SCTP_RCVINFO
,
992 sizeof(rinfo
), &rinfo
);
995 /* RFC6458, Section 5.3.6. SCTP Next Receive Information Structure
998 static void __sctp_ulpevent_read_nxtinfo(const struct sctp_ulpevent
*event
,
999 struct msghdr
*msghdr
,
1000 const struct sk_buff
*skb
)
1002 struct sctp_nxtinfo nxtinfo
;
1004 memset(&nxtinfo
, 0, sizeof(nxtinfo
));
1005 nxtinfo
.nxt_sid
= event
->stream
;
1006 nxtinfo
.nxt_ppid
= event
->ppid
;
1007 nxtinfo
.nxt_flags
= event
->flags
;
1008 if (sctp_ulpevent_is_notification(event
))
1009 nxtinfo
.nxt_flags
|= SCTP_NOTIFICATION
;
1010 nxtinfo
.nxt_length
= skb
->len
;
1011 nxtinfo
.nxt_assoc_id
= sctp_assoc2id(event
->asoc
);
1013 put_cmsg(msghdr
, IPPROTO_SCTP
, SCTP_NXTINFO
,
1014 sizeof(nxtinfo
), &nxtinfo
);
1017 void sctp_ulpevent_read_nxtinfo(const struct sctp_ulpevent
*event
,
1018 struct msghdr
*msghdr
,
1021 struct sk_buff
*skb
;
1024 skb
= sctp_skb_recv_datagram(sk
, MSG_PEEK
, 1, &err
);
1026 __sctp_ulpevent_read_nxtinfo(sctp_skb2event(skb
),
1028 /* Just release refcount here. */
1033 /* Do accounting for bytes received and hold a reference to the association
1036 static void sctp_ulpevent_receive_data(struct sctp_ulpevent
*event
,
1037 struct sctp_association
*asoc
)
1039 struct sk_buff
*skb
, *frag
;
1041 skb
= sctp_event2skb(event
);
1042 /* Set the owner and charge rwnd for bytes received. */
1043 sctp_ulpevent_set_owner(event
, asoc
);
1044 sctp_assoc_rwnd_decrease(asoc
, skb_headlen(skb
));
1049 /* Note: Not clearing the entire event struct as this is just a
1050 * fragment of the real event. However, we still need to do rwnd
1052 * In general, the skb passed from IP can have only 1 level of
1053 * fragments. But we allow multiple levels of fragments.
1055 skb_walk_frags(skb
, frag
)
1056 sctp_ulpevent_receive_data(sctp_skb2event(frag
), asoc
);
1059 /* Do accounting for bytes just read by user and release the references to
1062 static void sctp_ulpevent_release_data(struct sctp_ulpevent
*event
)
1064 struct sk_buff
*skb
, *frag
;
1067 /* Current stack structures assume that the rcv buffer is
1068 * per socket. For UDP style sockets this is not true as
1069 * multiple associations may be on a single UDP-style socket.
1070 * Use the local private area of the skb to track the owning
1074 skb
= sctp_event2skb(event
);
1080 /* Don't forget the fragments. */
1081 skb_walk_frags(skb
, frag
) {
1082 /* NOTE: skb_shinfos are recursive. Although IP returns
1083 * skb's with only 1 level of fragments, SCTP reassembly can
1084 * increase the levels.
1086 sctp_ulpevent_release_frag_data(sctp_skb2event(frag
));
1090 sctp_assoc_rwnd_increase(event
->asoc
, len
);
1091 sctp_chunk_put(event
->chunk
);
1092 sctp_ulpevent_release_owner(event
);
1095 static void sctp_ulpevent_release_frag_data(struct sctp_ulpevent
*event
)
1097 struct sk_buff
*skb
, *frag
;
1099 skb
= sctp_event2skb(event
);
1104 /* Don't forget the fragments. */
1105 skb_walk_frags(skb
, frag
) {
1106 /* NOTE: skb_shinfos are recursive. Although IP returns
1107 * skb's with only 1 level of fragments, SCTP reassembly can
1108 * increase the levels.
1110 sctp_ulpevent_release_frag_data(sctp_skb2event(frag
));
1114 sctp_chunk_put(event
->chunk
);
1115 sctp_ulpevent_release_owner(event
);
1118 /* Free a ulpevent that has an owner. It includes releasing the reference
1119 * to the owner, updating the rwnd in case of a DATA event and freeing the
1122 void sctp_ulpevent_free(struct sctp_ulpevent
*event
)
1124 if (sctp_ulpevent_is_notification(event
))
1125 sctp_ulpevent_release_owner(event
);
1127 sctp_ulpevent_release_data(event
);
1129 kfree_skb(sctp_event2skb(event
));
1132 /* Purge the skb lists holding ulpevents. */
1133 unsigned int sctp_queue_purge_ulpevents(struct sk_buff_head
*list
)
1135 struct sk_buff
*skb
;
1136 unsigned int data_unread
= 0;
1138 while ((skb
= skb_dequeue(list
)) != NULL
) {
1139 struct sctp_ulpevent
*event
= sctp_skb2event(skb
);
1141 if (!sctp_ulpevent_is_notification(event
))
1142 data_unread
+= skb
->len
;
1144 sctp_ulpevent_free(event
);