1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* SCTP kernel implementation
3 * (C) Copyright IBM Corp. 2001, 2004
4 * Copyright (c) 1999-2000 Cisco, Inc.
5 * Copyright (c) 1999-2001 Motorola, Inc.
6 * Copyright (c) 2001 Intel Corp.
7 * Copyright (c) 2001 Nokia, Inc.
8 * Copyright (c) 2001 La Monte H.P. Yarroll
10 * These functions manipulate an sctp event. The struct ulpevent is used
11 * to carry notifications and data to the ULP (sockets).
13 * Please send any bug reports or fixes you make to the
15 * lksctp developers <linux-sctp@vger.kernel.org>
17 * Written or modified by:
18 * Jon Grimm <jgrimm@us.ibm.com>
19 * La Monte H.P. Yarroll <piggy@acm.org>
20 * Ardelle Fan <ardelle.fan@intel.com>
21 * Sridhar Samudrala <sri@us.ibm.com>
24 #include <linux/slab.h>
25 #include <linux/types.h>
26 #include <linux/skbuff.h>
27 #include <net/sctp/structs.h>
28 #include <net/sctp/sctp.h>
29 #include <net/sctp/sm.h>
31 static void sctp_ulpevent_receive_data(struct sctp_ulpevent
*event
,
32 struct sctp_association
*asoc
);
33 static void sctp_ulpevent_release_data(struct sctp_ulpevent
*event
);
34 static void sctp_ulpevent_release_frag_data(struct sctp_ulpevent
*event
);
37 /* Initialize an ULP event from an given skb. */
38 static void sctp_ulpevent_init(struct sctp_ulpevent
*event
,
42 memset(event
, 0, sizeof(struct sctp_ulpevent
));
43 event
->msg_flags
= msg_flags
;
44 event
->rmem_len
= len
;
47 /* Create a new sctp_ulpevent. */
48 static struct sctp_ulpevent
*sctp_ulpevent_new(int size
, __u16 msg_flags
,
51 struct sctp_ulpevent
*event
;
54 skb
= alloc_skb(size
, gfp
);
58 event
= sctp_skb2event(skb
);
59 sctp_ulpevent_init(event
, msg_flags
, skb
->truesize
);
67 /* Is this a MSG_NOTIFICATION? */
68 int sctp_ulpevent_is_notification(const struct sctp_ulpevent
*event
)
70 return MSG_NOTIFICATION
== (event
->msg_flags
& MSG_NOTIFICATION
);
73 /* Hold the association in case the msg_name needs read out of
76 static inline void sctp_ulpevent_set_owner(struct sctp_ulpevent
*event
,
77 const struct sctp_association
*asoc
)
79 struct sctp_chunk
*chunk
= event
->chunk
;
82 /* Cast away the const, as we are just wanting to
83 * bump the reference count.
85 sctp_association_hold((struct sctp_association
*)asoc
);
86 skb
= sctp_event2skb(event
);
87 event
->asoc
= (struct sctp_association
*)asoc
;
88 atomic_add(event
->rmem_len
, &event
->asoc
->rmem_alloc
);
89 sctp_skb_set_owner_r(skb
, asoc
->base
.sk
);
90 if (chunk
&& chunk
->head_skb
&& !chunk
->head_skb
->sk
)
91 chunk
->head_skb
->sk
= asoc
->base
.sk
;
94 /* A simple destructor to give up the reference to the association. */
95 static inline void sctp_ulpevent_release_owner(struct sctp_ulpevent
*event
)
97 struct sctp_association
*asoc
= event
->asoc
;
99 atomic_sub(event
->rmem_len
, &asoc
->rmem_alloc
);
100 sctp_association_put(asoc
);
103 /* Create and initialize an SCTP_ASSOC_CHANGE event.
105 * 5.3.1.1 SCTP_ASSOC_CHANGE
107 * Communication notifications inform the ULP that an SCTP association
108 * has either begun or ended. The identifier for a new association is
109 * provided by this notification.
111 * Note: There is no field checking here. If a field is unused it will be
114 struct sctp_ulpevent
*sctp_ulpevent_make_assoc_change(
115 const struct sctp_association
*asoc
,
116 __u16 flags
, __u16 state
, __u16 error
, __u16 outbound
,
117 __u16 inbound
, struct sctp_chunk
*chunk
, gfp_t gfp
)
119 struct sctp_ulpevent
*event
;
120 struct sctp_assoc_change
*sac
;
123 /* If the lower layer passed in the chunk, it will be
124 * an ABORT, so we need to include it in the sac_info.
127 /* Copy the chunk data to a new skb and reserve enough
128 * head room to use as notification.
130 skb
= skb_copy_expand(chunk
->skb
,
131 sizeof(struct sctp_assoc_change
), 0, gfp
);
136 /* Embed the event fields inside the cloned skb. */
137 event
= sctp_skb2event(skb
);
138 sctp_ulpevent_init(event
, MSG_NOTIFICATION
, skb
->truesize
);
140 /* Include the notification structure */
141 sac
= skb_push(skb
, sizeof(struct sctp_assoc_change
));
143 /* Trim the buffer to the right length. */
144 skb_trim(skb
, sizeof(struct sctp_assoc_change
) +
145 ntohs(chunk
->chunk_hdr
->length
) -
146 sizeof(struct sctp_chunkhdr
));
148 event
= sctp_ulpevent_new(sizeof(struct sctp_assoc_change
),
149 MSG_NOTIFICATION
, gfp
);
153 skb
= sctp_event2skb(event
);
154 sac
= skb_put(skb
, sizeof(struct sctp_assoc_change
));
157 /* Socket Extensions for SCTP
158 * 5.3.1.1 SCTP_ASSOC_CHANGE
161 * It should be SCTP_ASSOC_CHANGE.
163 sac
->sac_type
= SCTP_ASSOC_CHANGE
;
165 /* Socket Extensions for SCTP
166 * 5.3.1.1 SCTP_ASSOC_CHANGE
168 * sac_state: 32 bits (signed integer)
169 * This field holds one of a number of values that communicate the
170 * event that happened to the association.
172 sac
->sac_state
= state
;
174 /* Socket Extensions for SCTP
175 * 5.3.1.1 SCTP_ASSOC_CHANGE
177 * sac_flags: 16 bits (unsigned integer)
182 /* Socket Extensions for SCTP
183 * 5.3.1.1 SCTP_ASSOC_CHANGE
185 * sac_length: sizeof (__u32)
186 * This field is the total length of the notification data, including
187 * the notification header.
189 sac
->sac_length
= skb
->len
;
191 /* Socket Extensions for SCTP
192 * 5.3.1.1 SCTP_ASSOC_CHANGE
194 * sac_error: 32 bits (signed integer)
196 * If the state was reached due to a error condition (e.g.
197 * COMMUNICATION_LOST) any relevant error information is available in
198 * this field. This corresponds to the protocol error codes defined in
201 sac
->sac_error
= error
;
203 /* Socket Extensions for SCTP
204 * 5.3.1.1 SCTP_ASSOC_CHANGE
206 * sac_outbound_streams: 16 bits (unsigned integer)
207 * sac_inbound_streams: 16 bits (unsigned integer)
209 * The maximum number of streams allowed in each direction are
210 * available in sac_outbound_streams and sac_inbound streams.
212 sac
->sac_outbound_streams
= outbound
;
213 sac
->sac_inbound_streams
= inbound
;
215 /* Socket Extensions for SCTP
216 * 5.3.1.1 SCTP_ASSOC_CHANGE
218 * sac_assoc_id: sizeof (sctp_assoc_t)
220 * The association id field, holds the identifier for the association.
221 * All notifications for a given association have the same association
222 * identifier. For TCP style socket, this field is ignored.
224 sctp_ulpevent_set_owner(event
, asoc
);
225 sac
->sac_assoc_id
= sctp_assoc2id(asoc
);
233 /* Create and initialize an SCTP_PEER_ADDR_CHANGE event.
235 * Socket Extensions for SCTP - draft-01
236 * 5.3.1.2 SCTP_PEER_ADDR_CHANGE
238 * When a destination address on a multi-homed peer encounters a change
239 * an interface details event is sent.
241 static struct sctp_ulpevent
*sctp_ulpevent_make_peer_addr_change(
242 const struct sctp_association
*asoc
,
243 const struct sockaddr_storage
*aaddr
,
244 int flags
, int state
, int error
, gfp_t gfp
)
246 struct sctp_ulpevent
*event
;
247 struct sctp_paddr_change
*spc
;
250 event
= sctp_ulpevent_new(sizeof(struct sctp_paddr_change
),
251 MSG_NOTIFICATION
, gfp
);
255 skb
= sctp_event2skb(event
);
256 spc
= skb_put(skb
, sizeof(struct sctp_paddr_change
));
258 /* Sockets API Extensions for SCTP
259 * Section 5.3.1.2 SCTP_PEER_ADDR_CHANGE
263 * It should be SCTP_PEER_ADDR_CHANGE.
265 spc
->spc_type
= SCTP_PEER_ADDR_CHANGE
;
267 /* Sockets API Extensions for SCTP
268 * Section 5.3.1.2 SCTP_PEER_ADDR_CHANGE
270 * spc_length: sizeof (__u32)
272 * This field is the total length of the notification data, including
273 * the notification header.
275 spc
->spc_length
= sizeof(struct sctp_paddr_change
);
277 /* Sockets API Extensions for SCTP
278 * Section 5.3.1.2 SCTP_PEER_ADDR_CHANGE
280 * spc_flags: 16 bits (unsigned integer)
285 /* Sockets API Extensions for SCTP
286 * Section 5.3.1.2 SCTP_PEER_ADDR_CHANGE
288 * spc_state: 32 bits (signed integer)
290 * This field holds one of a number of values that communicate the
291 * event that happened to the address.
293 spc
->spc_state
= state
;
295 /* Sockets API Extensions for SCTP
296 * Section 5.3.1.2 SCTP_PEER_ADDR_CHANGE
298 * spc_error: 32 bits (signed integer)
300 * If the state was reached due to any error condition (e.g.
301 * ADDRESS_UNREACHABLE) any relevant error information is available in
304 spc
->spc_error
= error
;
306 /* Socket Extensions for SCTP
307 * 5.3.1.1 SCTP_ASSOC_CHANGE
309 * spc_assoc_id: sizeof (sctp_assoc_t)
311 * The association id field, holds the identifier for the association.
312 * All notifications for a given association have the same association
313 * identifier. For TCP style socket, this field is ignored.
315 sctp_ulpevent_set_owner(event
, asoc
);
316 spc
->spc_assoc_id
= sctp_assoc2id(asoc
);
318 /* Sockets API Extensions for SCTP
319 * Section 5.3.1.2 SCTP_PEER_ADDR_CHANGE
321 * spc_aaddr: sizeof (struct sockaddr_storage)
323 * The affected address field, holds the remote peer's address that is
324 * encountering the change of state.
326 memcpy(&spc
->spc_aaddr
, aaddr
, sizeof(struct sockaddr_storage
));
328 /* Map ipv4 address into v4-mapped-on-v6 address. */
329 sctp_get_pf_specific(asoc
->base
.sk
->sk_family
)->addr_to_user(
330 sctp_sk(asoc
->base
.sk
),
331 (union sctp_addr
*)&spc
->spc_aaddr
);
339 void sctp_ulpevent_notify_peer_addr_change(struct sctp_transport
*transport
,
340 int state
, int error
)
342 struct sctp_association
*asoc
= transport
->asoc
;
343 struct sockaddr_storage addr
;
344 struct sctp_ulpevent
*event
;
346 if (asoc
->state
< SCTP_STATE_ESTABLISHED
)
349 memset(&addr
, 0, sizeof(struct sockaddr_storage
));
350 memcpy(&addr
, &transport
->ipaddr
, transport
->af_specific
->sockaddr_len
);
352 event
= sctp_ulpevent_make_peer_addr_change(asoc
, &addr
, 0, state
,
355 asoc
->stream
.si
->enqueue_event(&asoc
->ulpq
, event
);
358 /* Create and initialize an SCTP_REMOTE_ERROR notification.
360 * Note: This assumes that the chunk->skb->data already points to the
361 * operation error payload.
363 * Socket Extensions for SCTP - draft-01
364 * 5.3.1.3 SCTP_REMOTE_ERROR
366 * A remote peer may send an Operational Error message to its peer.
367 * This message indicates a variety of error conditions on an
368 * association. The entire error TLV as it appears on the wire is
369 * included in a SCTP_REMOTE_ERROR event. Please refer to the SCTP
370 * specification [SCTP] and any extensions for a list of possible
373 struct sctp_ulpevent
*
374 sctp_ulpevent_make_remote_error(const struct sctp_association
*asoc
,
375 struct sctp_chunk
*chunk
, __u16 flags
,
378 struct sctp_remote_error
*sre
;
379 struct sctp_ulpevent
*event
;
380 struct sctp_errhdr
*ch
;
385 ch
= (struct sctp_errhdr
*)(chunk
->skb
->data
);
387 elen
= SCTP_PAD4(ntohs(ch
->length
)) - sizeof(*ch
);
389 /* Pull off the ERROR header. */
390 skb_pull(chunk
->skb
, sizeof(*ch
));
392 /* Copy the skb to a new skb with room for us to prepend
395 skb
= skb_copy_expand(chunk
->skb
, sizeof(*sre
), 0, gfp
);
397 /* Pull off the rest of the cause TLV from the chunk. */
398 skb_pull(chunk
->skb
, elen
);
402 /* Embed the event fields inside the cloned skb. */
403 event
= sctp_skb2event(skb
);
404 sctp_ulpevent_init(event
, MSG_NOTIFICATION
, skb
->truesize
);
406 sre
= skb_push(skb
, sizeof(*sre
));
408 /* Trim the buffer to the right length. */
409 skb_trim(skb
, sizeof(*sre
) + elen
);
411 /* RFC6458, Section 6.1.3. SCTP_REMOTE_ERROR */
412 memset(sre
, 0, sizeof(*sre
));
413 sre
->sre_type
= SCTP_REMOTE_ERROR
;
415 sre
->sre_length
= skb
->len
;
416 sre
->sre_error
= cause
;
417 sctp_ulpevent_set_owner(event
, asoc
);
418 sre
->sre_assoc_id
= sctp_assoc2id(asoc
);
425 /* Create and initialize a SCTP_SEND_FAILED notification.
427 * Socket Extensions for SCTP - draft-01
428 * 5.3.1.4 SCTP_SEND_FAILED
430 struct sctp_ulpevent
*sctp_ulpevent_make_send_failed(
431 const struct sctp_association
*asoc
, struct sctp_chunk
*chunk
,
432 __u16 flags
, __u32 error
, gfp_t gfp
)
434 struct sctp_ulpevent
*event
;
435 struct sctp_send_failed
*ssf
;
438 /* Pull off any padding. */
439 int len
= ntohs(chunk
->chunk_hdr
->length
);
441 /* Make skb with more room so we can prepend notification. */
442 skb
= skb_copy_expand(chunk
->skb
,
443 sizeof(struct sctp_send_failed
), /* headroom */
449 /* Pull off the common chunk header and DATA header. */
450 skb_pull(skb
, sctp_datachk_len(&asoc
->stream
));
451 len
-= sctp_datachk_len(&asoc
->stream
);
453 /* Embed the event fields inside the cloned skb. */
454 event
= sctp_skb2event(skb
);
455 sctp_ulpevent_init(event
, MSG_NOTIFICATION
, skb
->truesize
);
457 ssf
= skb_push(skb
, sizeof(struct sctp_send_failed
));
459 /* Socket Extensions for SCTP
460 * 5.3.1.4 SCTP_SEND_FAILED
463 * It should be SCTP_SEND_FAILED.
465 ssf
->ssf_type
= SCTP_SEND_FAILED
;
467 /* Socket Extensions for SCTP
468 * 5.3.1.4 SCTP_SEND_FAILED
470 * ssf_flags: 16 bits (unsigned integer)
471 * The flag value will take one of the following values
473 * SCTP_DATA_UNSENT - Indicates that the data was never put on
476 * SCTP_DATA_SENT - Indicates that the data was put on the wire.
477 * Note that this does not necessarily mean that the
478 * data was (or was not) successfully delivered.
480 ssf
->ssf_flags
= flags
;
482 /* Socket Extensions for SCTP
483 * 5.3.1.4 SCTP_SEND_FAILED
485 * ssf_length: sizeof (__u32)
486 * This field is the total length of the notification data, including
487 * the notification header.
489 ssf
->ssf_length
= sizeof(struct sctp_send_failed
) + len
;
490 skb_trim(skb
, ssf
->ssf_length
);
492 /* Socket Extensions for SCTP
493 * 5.3.1.4 SCTP_SEND_FAILED
495 * ssf_error: 16 bits (unsigned integer)
496 * This value represents the reason why the send failed, and if set,
497 * will be a SCTP protocol error code as defined in [SCTP] section
500 ssf
->ssf_error
= error
;
502 /* Socket Extensions for SCTP
503 * 5.3.1.4 SCTP_SEND_FAILED
505 * ssf_info: sizeof (struct sctp_sndrcvinfo)
506 * The original send information associated with the undelivered
509 memcpy(&ssf
->ssf_info
, &chunk
->sinfo
, sizeof(struct sctp_sndrcvinfo
));
511 /* Per TSVWG discussion with Randy. Allow the application to
512 * reassemble a fragmented message.
514 ssf
->ssf_info
.sinfo_flags
= chunk
->chunk_hdr
->flags
;
516 /* Socket Extensions for SCTP
517 * 5.3.1.4 SCTP_SEND_FAILED
519 * ssf_assoc_id: sizeof (sctp_assoc_t)
520 * The association id field, sf_assoc_id, holds the identifier for the
521 * association. All notifications for a given association have the
522 * same association identifier. For TCP style socket, this field is
525 sctp_ulpevent_set_owner(event
, asoc
);
526 ssf
->ssf_assoc_id
= sctp_assoc2id(asoc
);
533 struct sctp_ulpevent
*sctp_ulpevent_make_send_failed_event(
534 const struct sctp_association
*asoc
, struct sctp_chunk
*chunk
,
535 __u16 flags
, __u32 error
, gfp_t gfp
)
537 struct sctp_send_failed_event
*ssf
;
538 struct sctp_ulpevent
*event
;
542 skb
= skb_copy_expand(chunk
->skb
, sizeof(*ssf
), 0, gfp
);
546 len
= ntohs(chunk
->chunk_hdr
->length
);
547 len
-= sctp_datachk_len(&asoc
->stream
);
549 skb_pull(skb
, sctp_datachk_len(&asoc
->stream
));
550 event
= sctp_skb2event(skb
);
551 sctp_ulpevent_init(event
, MSG_NOTIFICATION
, skb
->truesize
);
553 ssf
= skb_push(skb
, sizeof(*ssf
));
554 ssf
->ssf_type
= SCTP_SEND_FAILED_EVENT
;
555 ssf
->ssf_flags
= flags
;
556 ssf
->ssf_length
= sizeof(*ssf
) + len
;
557 skb_trim(skb
, ssf
->ssf_length
);
558 ssf
->ssf_error
= error
;
560 ssf
->ssfe_info
.snd_sid
= chunk
->sinfo
.sinfo_stream
;
561 ssf
->ssfe_info
.snd_ppid
= chunk
->sinfo
.sinfo_ppid
;
562 ssf
->ssfe_info
.snd_context
= chunk
->sinfo
.sinfo_context
;
563 ssf
->ssfe_info
.snd_assoc_id
= chunk
->sinfo
.sinfo_assoc_id
;
564 ssf
->ssfe_info
.snd_flags
= chunk
->chunk_hdr
->flags
;
566 sctp_ulpevent_set_owner(event
, asoc
);
567 ssf
->ssf_assoc_id
= sctp_assoc2id(asoc
);
572 /* Create and initialize a SCTP_SHUTDOWN_EVENT notification.
574 * Socket Extensions for SCTP - draft-01
575 * 5.3.1.5 SCTP_SHUTDOWN_EVENT
577 struct sctp_ulpevent
*sctp_ulpevent_make_shutdown_event(
578 const struct sctp_association
*asoc
,
579 __u16 flags
, gfp_t gfp
)
581 struct sctp_ulpevent
*event
;
582 struct sctp_shutdown_event
*sse
;
585 event
= sctp_ulpevent_new(sizeof(struct sctp_shutdown_event
),
586 MSG_NOTIFICATION
, gfp
);
590 skb
= sctp_event2skb(event
);
591 sse
= skb_put(skb
, sizeof(struct sctp_shutdown_event
));
593 /* Socket Extensions for SCTP
594 * 5.3.1.5 SCTP_SHUTDOWN_EVENT
597 * It should be SCTP_SHUTDOWN_EVENT
599 sse
->sse_type
= SCTP_SHUTDOWN_EVENT
;
601 /* Socket Extensions for SCTP
602 * 5.3.1.5 SCTP_SHUTDOWN_EVENT
604 * sse_flags: 16 bits (unsigned integer)
609 /* Socket Extensions for SCTP
610 * 5.3.1.5 SCTP_SHUTDOWN_EVENT
612 * sse_length: sizeof (__u32)
613 * This field is the total length of the notification data, including
614 * the notification header.
616 sse
->sse_length
= sizeof(struct sctp_shutdown_event
);
618 /* Socket Extensions for SCTP
619 * 5.3.1.5 SCTP_SHUTDOWN_EVENT
621 * sse_assoc_id: sizeof (sctp_assoc_t)
622 * The association id field, holds the identifier for the association.
623 * All notifications for a given association have the same association
624 * identifier. For TCP style socket, this field is ignored.
626 sctp_ulpevent_set_owner(event
, asoc
);
627 sse
->sse_assoc_id
= sctp_assoc2id(asoc
);
635 /* Create and initialize a SCTP_ADAPTATION_INDICATION notification.
637 * Socket Extensions for SCTP
638 * 5.3.1.6 SCTP_ADAPTATION_INDICATION
640 struct sctp_ulpevent
*sctp_ulpevent_make_adaptation_indication(
641 const struct sctp_association
*asoc
, gfp_t gfp
)
643 struct sctp_ulpevent
*event
;
644 struct sctp_adaptation_event
*sai
;
647 event
= sctp_ulpevent_new(sizeof(struct sctp_adaptation_event
),
648 MSG_NOTIFICATION
, gfp
);
652 skb
= sctp_event2skb(event
);
653 sai
= skb_put(skb
, sizeof(struct sctp_adaptation_event
));
655 sai
->sai_type
= SCTP_ADAPTATION_INDICATION
;
657 sai
->sai_length
= sizeof(struct sctp_adaptation_event
);
658 sai
->sai_adaptation_ind
= asoc
->peer
.adaptation_ind
;
659 sctp_ulpevent_set_owner(event
, asoc
);
660 sai
->sai_assoc_id
= sctp_assoc2id(asoc
);
668 /* A message has been received. Package this message as a notification
669 * to pass it to the upper layers. Go ahead and calculate the sndrcvinfo
670 * even if filtered out later.
672 * Socket Extensions for SCTP
673 * 5.2.2 SCTP Header Information Structure (SCTP_SNDRCV)
675 struct sctp_ulpevent
*sctp_ulpevent_make_rcvmsg(struct sctp_association
*asoc
,
676 struct sctp_chunk
*chunk
,
679 struct sctp_ulpevent
*event
= NULL
;
680 struct sk_buff
*skb
= chunk
->skb
;
681 struct sock
*sk
= asoc
->base
.sk
;
682 size_t padding
, datalen
;
686 * check to see if we need to make space for this
687 * new skb, expand the rcvbuffer if needed, or drop
690 if (asoc
->ep
->rcvbuf_policy
)
691 rx_count
= atomic_read(&asoc
->rmem_alloc
);
693 rx_count
= atomic_read(&sk
->sk_rmem_alloc
);
695 datalen
= ntohs(chunk
->chunk_hdr
->length
);
697 if (rx_count
>= sk
->sk_rcvbuf
|| !sk_rmem_schedule(sk
, skb
, datalen
))
700 /* Clone the original skb, sharing the data. */
701 skb
= skb_clone(chunk
->skb
, gfp
);
705 /* Now that all memory allocations for this chunk succeeded, we
706 * can mark it as received so the tsn_map is updated correctly.
708 if (sctp_tsnmap_mark(&asoc
->peer
.tsn_map
,
709 ntohl(chunk
->subh
.data_hdr
->tsn
),
713 /* First calculate the padding, so we don't inadvertently
714 * pass up the wrong length to the user.
716 * RFC 2960 - Section 3.2 Chunk Field Descriptions
718 * The total length of a chunk(including Type, Length and Value fields)
719 * MUST be a multiple of 4 bytes. If the length of the chunk is not a
720 * multiple of 4 bytes, the sender MUST pad the chunk with all zero
721 * bytes and this padding is not included in the chunk length field.
722 * The sender should never pad with more than 3 bytes. The receiver
723 * MUST ignore the padding bytes.
725 padding
= SCTP_PAD4(datalen
) - datalen
;
727 /* Fixup cloned skb with just this chunks data. */
728 skb_trim(skb
, chunk
->chunk_end
- padding
- skb
->data
);
730 /* Embed the event fields inside the cloned skb. */
731 event
= sctp_skb2event(skb
);
733 /* Initialize event with flags 0 and correct length
734 * Since this is a clone of the original skb, only account for
735 * the data of this chunk as other chunks will be accounted separately.
737 sctp_ulpevent_init(event
, 0, skb
->len
+ sizeof(struct sk_buff
));
739 /* And hold the chunk as we need it for getting the IP headers
742 sctp_chunk_hold(chunk
);
743 event
->chunk
= chunk
;
745 sctp_ulpevent_receive_data(event
, asoc
);
747 event
->stream
= ntohs(chunk
->subh
.data_hdr
->stream
);
748 if (chunk
->chunk_hdr
->flags
& SCTP_DATA_UNORDERED
) {
749 event
->flags
|= SCTP_UNORDERED
;
750 event
->cumtsn
= sctp_tsnmap_get_ctsn(&asoc
->peer
.tsn_map
);
752 event
->tsn
= ntohl(chunk
->subh
.data_hdr
->tsn
);
753 event
->msg_flags
|= chunk
->chunk_hdr
->flags
;
763 /* Create a partial delivery related event.
765 * 5.3.1.7 SCTP_PARTIAL_DELIVERY_EVENT
767 * When a receiver is engaged in a partial delivery of a
768 * message this notification will be used to indicate
771 struct sctp_ulpevent
*sctp_ulpevent_make_pdapi(
772 const struct sctp_association
*asoc
,
773 __u32 indication
, __u32 sid
, __u32 seq
,
774 __u32 flags
, gfp_t gfp
)
776 struct sctp_ulpevent
*event
;
777 struct sctp_pdapi_event
*pd
;
780 event
= sctp_ulpevent_new(sizeof(struct sctp_pdapi_event
),
781 MSG_NOTIFICATION
, gfp
);
785 skb
= sctp_event2skb(event
);
786 pd
= skb_put(skb
, sizeof(struct sctp_pdapi_event
));
789 * It should be SCTP_PARTIAL_DELIVERY_EVENT
791 * pdapi_flags: 16 bits (unsigned integer)
794 pd
->pdapi_type
= SCTP_PARTIAL_DELIVERY_EVENT
;
795 pd
->pdapi_flags
= flags
;
796 pd
->pdapi_stream
= sid
;
799 /* pdapi_length: 32 bits (unsigned integer)
801 * This field is the total length of the notification data, including
802 * the notification header. It will generally be sizeof (struct
805 pd
->pdapi_length
= sizeof(struct sctp_pdapi_event
);
807 /* pdapi_indication: 32 bits (unsigned integer)
809 * This field holds the indication being sent to the application.
811 pd
->pdapi_indication
= indication
;
813 /* pdapi_assoc_id: sizeof (sctp_assoc_t)
815 * The association id field, holds the identifier for the association.
817 sctp_ulpevent_set_owner(event
, asoc
);
818 pd
->pdapi_assoc_id
= sctp_assoc2id(asoc
);
825 struct sctp_ulpevent
*sctp_ulpevent_make_authkey(
826 const struct sctp_association
*asoc
, __u16 key_id
,
827 __u32 indication
, gfp_t gfp
)
829 struct sctp_ulpevent
*event
;
830 struct sctp_authkey_event
*ak
;
833 event
= sctp_ulpevent_new(sizeof(struct sctp_authkey_event
),
834 MSG_NOTIFICATION
, gfp
);
838 skb
= sctp_event2skb(event
);
839 ak
= skb_put(skb
, sizeof(struct sctp_authkey_event
));
841 ak
->auth_type
= SCTP_AUTHENTICATION_EVENT
;
843 ak
->auth_length
= sizeof(struct sctp_authkey_event
);
845 ak
->auth_keynumber
= key_id
;
846 ak
->auth_altkeynumber
= 0;
847 ak
->auth_indication
= indication
;
850 * The association id field, holds the identifier for the association.
852 sctp_ulpevent_set_owner(event
, asoc
);
853 ak
->auth_assoc_id
= sctp_assoc2id(asoc
);
861 * Socket Extensions for SCTP
862 * 6.3.10. SCTP_SENDER_DRY_EVENT
864 struct sctp_ulpevent
*sctp_ulpevent_make_sender_dry_event(
865 const struct sctp_association
*asoc
, gfp_t gfp
)
867 struct sctp_ulpevent
*event
;
868 struct sctp_sender_dry_event
*sdry
;
871 event
= sctp_ulpevent_new(sizeof(struct sctp_sender_dry_event
),
872 MSG_NOTIFICATION
, gfp
);
876 skb
= sctp_event2skb(event
);
877 sdry
= skb_put(skb
, sizeof(struct sctp_sender_dry_event
));
879 sdry
->sender_dry_type
= SCTP_SENDER_DRY_EVENT
;
880 sdry
->sender_dry_flags
= 0;
881 sdry
->sender_dry_length
= sizeof(struct sctp_sender_dry_event
);
882 sctp_ulpevent_set_owner(event
, asoc
);
883 sdry
->sender_dry_assoc_id
= sctp_assoc2id(asoc
);
888 struct sctp_ulpevent
*sctp_ulpevent_make_stream_reset_event(
889 const struct sctp_association
*asoc
, __u16 flags
, __u16 stream_num
,
890 __be16
*stream_list
, gfp_t gfp
)
892 struct sctp_stream_reset_event
*sreset
;
893 struct sctp_ulpevent
*event
;
897 length
= sizeof(struct sctp_stream_reset_event
) + 2 * stream_num
;
898 event
= sctp_ulpevent_new(length
, MSG_NOTIFICATION
, gfp
);
902 skb
= sctp_event2skb(event
);
903 sreset
= skb_put(skb
, length
);
905 sreset
->strreset_type
= SCTP_STREAM_RESET_EVENT
;
906 sreset
->strreset_flags
= flags
;
907 sreset
->strreset_length
= length
;
908 sctp_ulpevent_set_owner(event
, asoc
);
909 sreset
->strreset_assoc_id
= sctp_assoc2id(asoc
);
911 for (i
= 0; i
< stream_num
; i
++)
912 sreset
->strreset_stream_list
[i
] = ntohs(stream_list
[i
]);
917 struct sctp_ulpevent
*sctp_ulpevent_make_assoc_reset_event(
918 const struct sctp_association
*asoc
, __u16 flags
, __u32 local_tsn
,
919 __u32 remote_tsn
, gfp_t gfp
)
921 struct sctp_assoc_reset_event
*areset
;
922 struct sctp_ulpevent
*event
;
925 event
= sctp_ulpevent_new(sizeof(struct sctp_assoc_reset_event
),
926 MSG_NOTIFICATION
, gfp
);
930 skb
= sctp_event2skb(event
);
931 areset
= skb_put(skb
, sizeof(struct sctp_assoc_reset_event
));
933 areset
->assocreset_type
= SCTP_ASSOC_RESET_EVENT
;
934 areset
->assocreset_flags
= flags
;
935 areset
->assocreset_length
= sizeof(struct sctp_assoc_reset_event
);
936 sctp_ulpevent_set_owner(event
, asoc
);
937 areset
->assocreset_assoc_id
= sctp_assoc2id(asoc
);
938 areset
->assocreset_local_tsn
= local_tsn
;
939 areset
->assocreset_remote_tsn
= remote_tsn
;
944 struct sctp_ulpevent
*sctp_ulpevent_make_stream_change_event(
945 const struct sctp_association
*asoc
, __u16 flags
,
946 __u32 strchange_instrms
, __u32 strchange_outstrms
, gfp_t gfp
)
948 struct sctp_stream_change_event
*schange
;
949 struct sctp_ulpevent
*event
;
952 event
= sctp_ulpevent_new(sizeof(struct sctp_stream_change_event
),
953 MSG_NOTIFICATION
, gfp
);
957 skb
= sctp_event2skb(event
);
958 schange
= skb_put(skb
, sizeof(struct sctp_stream_change_event
));
960 schange
->strchange_type
= SCTP_STREAM_CHANGE_EVENT
;
961 schange
->strchange_flags
= flags
;
962 schange
->strchange_length
= sizeof(struct sctp_stream_change_event
);
963 sctp_ulpevent_set_owner(event
, asoc
);
964 schange
->strchange_assoc_id
= sctp_assoc2id(asoc
);
965 schange
->strchange_instrms
= strchange_instrms
;
966 schange
->strchange_outstrms
= strchange_outstrms
;
971 /* Return the notification type, assuming this is a notification
974 __u16
sctp_ulpevent_get_notification_type(const struct sctp_ulpevent
*event
)
976 union sctp_notification
*notification
;
979 skb
= sctp_event2skb(event
);
980 notification
= (union sctp_notification
*) skb
->data
;
981 return notification
->sn_header
.sn_type
;
984 /* RFC6458, Section 5.3.2. SCTP Header Information Structure
985 * (SCTP_SNDRCV, DEPRECATED)
987 void sctp_ulpevent_read_sndrcvinfo(const struct sctp_ulpevent
*event
,
988 struct msghdr
*msghdr
)
990 struct sctp_sndrcvinfo sinfo
;
992 if (sctp_ulpevent_is_notification(event
))
995 memset(&sinfo
, 0, sizeof(sinfo
));
996 sinfo
.sinfo_stream
= event
->stream
;
997 sinfo
.sinfo_ssn
= event
->ssn
;
998 sinfo
.sinfo_ppid
= event
->ppid
;
999 sinfo
.sinfo_flags
= event
->flags
;
1000 sinfo
.sinfo_tsn
= event
->tsn
;
1001 sinfo
.sinfo_cumtsn
= event
->cumtsn
;
1002 sinfo
.sinfo_assoc_id
= sctp_assoc2id(event
->asoc
);
1003 /* Context value that is set via SCTP_CONTEXT socket option. */
1004 sinfo
.sinfo_context
= event
->asoc
->default_rcv_context
;
1005 /* These fields are not used while receiving. */
1006 sinfo
.sinfo_timetolive
= 0;
1008 put_cmsg(msghdr
, IPPROTO_SCTP
, SCTP_SNDRCV
,
1009 sizeof(sinfo
), &sinfo
);
1012 /* RFC6458, Section 5.3.5 SCTP Receive Information Structure
1015 void sctp_ulpevent_read_rcvinfo(const struct sctp_ulpevent
*event
,
1016 struct msghdr
*msghdr
)
1018 struct sctp_rcvinfo rinfo
;
1020 if (sctp_ulpevent_is_notification(event
))
1023 memset(&rinfo
, 0, sizeof(struct sctp_rcvinfo
));
1024 rinfo
.rcv_sid
= event
->stream
;
1025 rinfo
.rcv_ssn
= event
->ssn
;
1026 rinfo
.rcv_ppid
= event
->ppid
;
1027 rinfo
.rcv_flags
= event
->flags
;
1028 rinfo
.rcv_tsn
= event
->tsn
;
1029 rinfo
.rcv_cumtsn
= event
->cumtsn
;
1030 rinfo
.rcv_assoc_id
= sctp_assoc2id(event
->asoc
);
1031 rinfo
.rcv_context
= event
->asoc
->default_rcv_context
;
1033 put_cmsg(msghdr
, IPPROTO_SCTP
, SCTP_RCVINFO
,
1034 sizeof(rinfo
), &rinfo
);
1037 /* RFC6458, Section 5.3.6. SCTP Next Receive Information Structure
1040 static void __sctp_ulpevent_read_nxtinfo(const struct sctp_ulpevent
*event
,
1041 struct msghdr
*msghdr
,
1042 const struct sk_buff
*skb
)
1044 struct sctp_nxtinfo nxtinfo
;
1046 memset(&nxtinfo
, 0, sizeof(nxtinfo
));
1047 nxtinfo
.nxt_sid
= event
->stream
;
1048 nxtinfo
.nxt_ppid
= event
->ppid
;
1049 nxtinfo
.nxt_flags
= event
->flags
;
1050 if (sctp_ulpevent_is_notification(event
))
1051 nxtinfo
.nxt_flags
|= SCTP_NOTIFICATION
;
1052 nxtinfo
.nxt_length
= skb
->len
;
1053 nxtinfo
.nxt_assoc_id
= sctp_assoc2id(event
->asoc
);
1055 put_cmsg(msghdr
, IPPROTO_SCTP
, SCTP_NXTINFO
,
1056 sizeof(nxtinfo
), &nxtinfo
);
1059 void sctp_ulpevent_read_nxtinfo(const struct sctp_ulpevent
*event
,
1060 struct msghdr
*msghdr
,
1063 struct sk_buff
*skb
;
1066 skb
= sctp_skb_recv_datagram(sk
, MSG_PEEK
| MSG_DONTWAIT
, &err
);
1068 __sctp_ulpevent_read_nxtinfo(sctp_skb2event(skb
),
1070 /* Just release refcount here. */
1075 /* Do accounting for bytes received and hold a reference to the association
1078 static void sctp_ulpevent_receive_data(struct sctp_ulpevent
*event
,
1079 struct sctp_association
*asoc
)
1081 struct sk_buff
*skb
, *frag
;
1083 skb
= sctp_event2skb(event
);
1084 /* Set the owner and charge rwnd for bytes received. */
1085 sctp_ulpevent_set_owner(event
, asoc
);
1086 sctp_assoc_rwnd_decrease(asoc
, skb_headlen(skb
));
1091 /* Note: Not clearing the entire event struct as this is just a
1092 * fragment of the real event. However, we still need to do rwnd
1094 * In general, the skb passed from IP can have only 1 level of
1095 * fragments. But we allow multiple levels of fragments.
1097 skb_walk_frags(skb
, frag
)
1098 sctp_ulpevent_receive_data(sctp_skb2event(frag
), asoc
);
1101 /* Do accounting for bytes just read by user and release the references to
1104 static void sctp_ulpevent_release_data(struct sctp_ulpevent
*event
)
1106 struct sk_buff
*skb
, *frag
;
1109 /* Current stack structures assume that the rcv buffer is
1110 * per socket. For UDP style sockets this is not true as
1111 * multiple associations may be on a single UDP-style socket.
1112 * Use the local private area of the skb to track the owning
1116 skb
= sctp_event2skb(event
);
1122 /* Don't forget the fragments. */
1123 skb_walk_frags(skb
, frag
) {
1124 /* NOTE: skb_shinfos are recursive. Although IP returns
1125 * skb's with only 1 level of fragments, SCTP reassembly can
1126 * increase the levels.
1128 sctp_ulpevent_release_frag_data(sctp_skb2event(frag
));
1132 sctp_assoc_rwnd_increase(event
->asoc
, len
);
1133 sctp_chunk_put(event
->chunk
);
1134 sctp_ulpevent_release_owner(event
);
1137 static void sctp_ulpevent_release_frag_data(struct sctp_ulpevent
*event
)
1139 struct sk_buff
*skb
, *frag
;
1141 skb
= sctp_event2skb(event
);
1146 /* Don't forget the fragments. */
1147 skb_walk_frags(skb
, frag
) {
1148 /* NOTE: skb_shinfos are recursive. Although IP returns
1149 * skb's with only 1 level of fragments, SCTP reassembly can
1150 * increase the levels.
1152 sctp_ulpevent_release_frag_data(sctp_skb2event(frag
));
1156 sctp_chunk_put(event
->chunk
);
1157 sctp_ulpevent_release_owner(event
);
1160 /* Free a ulpevent that has an owner. It includes releasing the reference
1161 * to the owner, updating the rwnd in case of a DATA event and freeing the
1164 void sctp_ulpevent_free(struct sctp_ulpevent
*event
)
1166 if (sctp_ulpevent_is_notification(event
))
1167 sctp_ulpevent_release_owner(event
);
1169 sctp_ulpevent_release_data(event
);
1171 kfree_skb(sctp_event2skb(event
));
1174 /* Purge the skb lists holding ulpevents. */
1175 unsigned int sctp_queue_purge_ulpevents(struct sk_buff_head
*list
)
1177 struct sk_buff
*skb
;
1178 unsigned int data_unread
= 0;
1180 while ((skb
= skb_dequeue(list
)) != NULL
) {
1181 struct sctp_ulpevent
*event
= sctp_skb2event(skb
);
1183 if (!sctp_ulpevent_is_notification(event
))
1184 data_unread
+= skb
->len
;
1186 sctp_ulpevent_free(event
);