Linux Audio

Check our new training course

Linux debugging, profiling, tracing and performance analysis training

Mar 24-27, 2025, special US time zones
Register
Loading...
v6.2
   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
   9 *
  10 * These functions manipulate an sctp event.   The struct ulpevent is used
  11 * to carry notifications and data to the ULP (sockets).
  12 *
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  13 * Please send any bug reports or fixes you make to the
  14 * email address(es):
  15 *    lksctp developers <linux-sctp@vger.kernel.org>
 
 
 
  16 *
  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>
 
 
 
  22 */
  23
  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>
  30
  31static void sctp_ulpevent_receive_data(struct sctp_ulpevent *event,
  32				       struct sctp_association *asoc);
  33static void sctp_ulpevent_release_data(struct sctp_ulpevent *event);
  34static void sctp_ulpevent_release_frag_data(struct sctp_ulpevent *event);
  35
  36
  37/* Initialize an ULP event from an given skb.  */
  38static void sctp_ulpevent_init(struct sctp_ulpevent *event,
  39			       __u16 msg_flags,
  40			       unsigned int len)
  41{
  42	memset(event, 0, sizeof(struct sctp_ulpevent));
  43	event->msg_flags = msg_flags;
  44	event->rmem_len = len;
  45}
  46
  47/* Create a new sctp_ulpevent.  */
  48static struct sctp_ulpevent *sctp_ulpevent_new(int size, __u16 msg_flags,
  49					       gfp_t gfp)
  50{
  51	struct sctp_ulpevent *event;
  52	struct sk_buff *skb;
  53
  54	skb = alloc_skb(size, gfp);
  55	if (!skb)
  56		goto fail;
  57
  58	event = sctp_skb2event(skb);
  59	sctp_ulpevent_init(event, msg_flags, skb->truesize);
  60
  61	return event;
  62
  63fail:
  64	return NULL;
  65}
  66
  67/* Is this a MSG_NOTIFICATION?  */
  68int sctp_ulpevent_is_notification(const struct sctp_ulpevent *event)
  69{
  70	return MSG_NOTIFICATION == (event->msg_flags & MSG_NOTIFICATION);
  71}
  72
  73/* Hold the association in case the msg_name needs read out of
  74 * the association.
  75 */
  76static inline void sctp_ulpevent_set_owner(struct sctp_ulpevent *event,
  77					   const struct sctp_association *asoc)
  78{
  79	struct sctp_chunk *chunk = event->chunk;
  80	struct sk_buff *skb;
  81
  82	/* Cast away the const, as we are just wanting to
  83	 * bump the reference count.
  84	 */
  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;
  92}
  93
  94/* A simple destructor to give up the reference to the association. */
  95static inline void sctp_ulpevent_release_owner(struct sctp_ulpevent *event)
  96{
  97	struct sctp_association *asoc = event->asoc;
  98
  99	atomic_sub(event->rmem_len, &asoc->rmem_alloc);
 100	sctp_association_put(asoc);
 101}
 102
 103/* Create and initialize an SCTP_ASSOC_CHANGE event.
 104 *
 105 * 5.3.1.1 SCTP_ASSOC_CHANGE
 106 *
 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.
 110 *
 111 * Note: There is no field checking here.  If a field is unused it will be
 112 * zero'd out.
 113 */
 114struct 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)
 118{
 119	struct sctp_ulpevent *event;
 120	struct sctp_assoc_change *sac;
 121	struct sk_buff *skb;
 122
 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.
 125	 */
 126	if (chunk) {
 127		/* Copy the chunk data to a new skb and reserve enough
 128		 * head room to use as notification.
 129		 */
 130		skb = skb_copy_expand(chunk->skb,
 131				      sizeof(struct sctp_assoc_change), 0, gfp);
 132
 133		if (!skb)
 134			goto fail;
 135
 136		/* Embed the event fields inside the cloned skb.  */
 137		event = sctp_skb2event(skb);
 138		sctp_ulpevent_init(event, MSG_NOTIFICATION, skb->truesize);
 139
 140		/* Include the notification structure */
 141		sac = skb_push(skb, sizeof(struct sctp_assoc_change));
 
 142
 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));
 147	} else {
 148		event = sctp_ulpevent_new(sizeof(struct sctp_assoc_change),
 149				  MSG_NOTIFICATION, gfp);
 150		if (!event)
 151			goto fail;
 152
 153		skb = sctp_event2skb(event);
 154		sac = skb_put(skb, sizeof(struct sctp_assoc_change));
 
 155	}
 156
 157	/* Socket Extensions for SCTP
 158	 * 5.3.1.1 SCTP_ASSOC_CHANGE
 159	 *
 160	 * sac_type:
 161	 * It should be SCTP_ASSOC_CHANGE.
 162	 */
 163	sac->sac_type = SCTP_ASSOC_CHANGE;
 164
 165	/* Socket Extensions for SCTP
 166	 * 5.3.1.1 SCTP_ASSOC_CHANGE
 167	 *
 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.
 171	 */
 172	sac->sac_state = state;
 173
 174	/* Socket Extensions for SCTP
 175	 * 5.3.1.1 SCTP_ASSOC_CHANGE
 176	 *
 177	 * sac_flags: 16 bits (unsigned integer)
 178	 * Currently unused.
 179	 */
 180	sac->sac_flags = 0;
 181
 182	/* Socket Extensions for SCTP
 183	 * 5.3.1.1 SCTP_ASSOC_CHANGE
 184	 *
 185	 * sac_length: sizeof (__u32)
 186	 * This field is the total length of the notification data, including
 187	 * the notification header.
 188	 */
 189	sac->sac_length = skb->len;
 190
 191	/* Socket Extensions for SCTP
 192	 * 5.3.1.1 SCTP_ASSOC_CHANGE
 193	 *
 194	 * sac_error:  32 bits (signed integer)
 195	 *
 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
 199	 * [SCTP].
 200	 */
 201	sac->sac_error = error;
 202
 203	/* Socket Extensions for SCTP
 204	 * 5.3.1.1 SCTP_ASSOC_CHANGE
 205	 *
 206	 * sac_outbound_streams:  16 bits (unsigned integer)
 207	 * sac_inbound_streams:  16 bits (unsigned integer)
 208	 *
 209	 * The maximum number of streams allowed in each direction are
 210	 * available in sac_outbound_streams and sac_inbound streams.
 211	 */
 212	sac->sac_outbound_streams = outbound;
 213	sac->sac_inbound_streams = inbound;
 214
 215	/* Socket Extensions for SCTP
 216	 * 5.3.1.1 SCTP_ASSOC_CHANGE
 217	 *
 218	 * sac_assoc_id: sizeof (sctp_assoc_t)
 219	 *
 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.
 223	 */
 224	sctp_ulpevent_set_owner(event, asoc);
 225	sac->sac_assoc_id = sctp_assoc2id(asoc);
 226
 227	return event;
 228
 229fail:
 230	return NULL;
 231}
 232
 233/* Create and initialize an SCTP_PEER_ADDR_CHANGE event.
 234 *
 235 * Socket Extensions for SCTP - draft-01
 236 * 5.3.1.2 SCTP_PEER_ADDR_CHANGE
 237 *
 238 * When a destination address on a multi-homed peer encounters a change
 239 * an interface details event is sent.
 240 */
 241static 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)
 245{
 246	struct sctp_ulpevent *event;
 247	struct sctp_paddr_change  *spc;
 248	struct sk_buff *skb;
 249
 250	event = sctp_ulpevent_new(sizeof(struct sctp_paddr_change),
 251				  MSG_NOTIFICATION, gfp);
 252	if (!event)
 253		goto fail;
 254
 255	skb = sctp_event2skb(event);
 256	spc = skb_put(skb, sizeof(struct sctp_paddr_change));
 
 257
 258	/* Sockets API Extensions for SCTP
 259	 * Section 5.3.1.2 SCTP_PEER_ADDR_CHANGE
 260	 *
 261	 * spc_type:
 262	 *
 263	 *    It should be SCTP_PEER_ADDR_CHANGE.
 264	 */
 265	spc->spc_type = SCTP_PEER_ADDR_CHANGE;
 266
 267	/* Sockets API Extensions for SCTP
 268	 * Section 5.3.1.2 SCTP_PEER_ADDR_CHANGE
 269	 *
 270	 * spc_length: sizeof (__u32)
 271	 *
 272	 * This field is the total length of the notification data, including
 273	 * the notification header.
 274	 */
 275	spc->spc_length = sizeof(struct sctp_paddr_change);
 276
 277	/* Sockets API Extensions for SCTP
 278	 * Section 5.3.1.2 SCTP_PEER_ADDR_CHANGE
 279	 *
 280	 * spc_flags: 16 bits (unsigned integer)
 281	 * Currently unused.
 282	 */
 283	spc->spc_flags = 0;
 284
 285	/* Sockets API Extensions for SCTP
 286	 * Section 5.3.1.2 SCTP_PEER_ADDR_CHANGE
 287	 *
 288	 * spc_state:  32 bits (signed integer)
 289	 *
 290	 * This field holds one of a number of values that communicate the
 291	 * event that happened to the address.
 292	 */
 293	spc->spc_state = state;
 294
 295	/* Sockets API Extensions for SCTP
 296	 * Section 5.3.1.2 SCTP_PEER_ADDR_CHANGE
 297	 *
 298	 * spc_error:  32 bits (signed integer)
 299	 *
 300	 * If the state was reached due to any error condition (e.g.
 301	 * ADDRESS_UNREACHABLE) any relevant error information is available in
 302	 * this field.
 303	 */
 304	spc->spc_error = error;
 305
 306	/* Socket Extensions for SCTP
 307	 * 5.3.1.1 SCTP_ASSOC_CHANGE
 308	 *
 309	 * spc_assoc_id: sizeof (sctp_assoc_t)
 310	 *
 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.
 314	 */
 315	sctp_ulpevent_set_owner(event, asoc);
 316	spc->spc_assoc_id = sctp_assoc2id(asoc);
 317
 318	/* Sockets API Extensions for SCTP
 319	 * Section 5.3.1.2 SCTP_PEER_ADDR_CHANGE
 320	 *
 321	 * spc_aaddr: sizeof (struct sockaddr_storage)
 322	 *
 323	 * The affected address field, holds the remote peer's address that is
 324	 * encountering the change of state.
 325	 */
 326	memcpy(&spc->spc_aaddr, aaddr, sizeof(struct sockaddr_storage));
 327
 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);
 332
 333	return event;
 334
 335fail:
 336	return NULL;
 337}
 338
 339void sctp_ulpevent_notify_peer_addr_change(struct sctp_transport *transport,
 340					   int state, int error)
 341{
 342	struct sctp_association *asoc = transport->asoc;
 343	struct sockaddr_storage addr;
 344	struct sctp_ulpevent *event;
 345
 346	if (asoc->state < SCTP_STATE_ESTABLISHED)
 347		return;
 348
 349	memset(&addr, 0, sizeof(struct sockaddr_storage));
 350	memcpy(&addr, &transport->ipaddr, transport->af_specific->sockaddr_len);
 351
 352	event = sctp_ulpevent_make_peer_addr_change(asoc, &addr, 0, state,
 353						    error, GFP_ATOMIC);
 354	if (event)
 355		asoc->stream.si->enqueue_event(&asoc->ulpq, event);
 356}
 357
 358/* Create and initialize an SCTP_REMOTE_ERROR notification.
 359 *
 360 * Note: This assumes that the chunk->skb->data already points to the
 361 * operation error payload.
 362 *
 363 * Socket Extensions for SCTP - draft-01
 364 * 5.3.1.3 SCTP_REMOTE_ERROR
 365 *
 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
 371 * error formats.
 372 */
 373struct sctp_ulpevent *
 374sctp_ulpevent_make_remote_error(const struct sctp_association *asoc,
 375				struct sctp_chunk *chunk, __u16 flags,
 376				gfp_t gfp)
 377{
 378	struct sctp_remote_error *sre;
 379	struct sctp_ulpevent *event;
 380	struct sctp_errhdr *ch;
 381	struct sk_buff *skb;
 
 382	__be16 cause;
 383	int elen;
 384
 385	ch = (struct sctp_errhdr *)(chunk->skb->data);
 386	cause = ch->cause;
 387	elen = SCTP_PAD4(ntohs(ch->length)) - sizeof(*ch);
 388
 389	/* Pull off the ERROR header.  */
 390	skb_pull(chunk->skb, sizeof(*ch));
 391
 392	/* Copy the skb to a new skb with room for us to prepend
 393	 * notification with.
 394	 */
 395	skb = skb_copy_expand(chunk->skb, sizeof(*sre), 0, gfp);
 
 396
 397	/* Pull off the rest of the cause TLV from the chunk.  */
 398	skb_pull(chunk->skb, elen);
 399	if (!skb)
 400		goto fail;
 401
 402	/* Embed the event fields inside the cloned skb.  */
 403	event = sctp_skb2event(skb);
 404	sctp_ulpevent_init(event, MSG_NOTIFICATION, skb->truesize);
 405
 406	sre = skb_push(skb, sizeof(*sre));
 
 407
 408	/* Trim the buffer to the right length.  */
 409	skb_trim(skb, sizeof(*sre) + elen);
 410
 411	/* RFC6458, Section 6.1.3. SCTP_REMOTE_ERROR */
 412	memset(sre, 0, sizeof(*sre));
 
 
 
 
 413	sre->sre_type = SCTP_REMOTE_ERROR;
 
 
 
 
 
 
 
 
 414	sre->sre_flags = 0;
 
 
 
 
 
 
 
 
 
 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);
 419
 420	return event;
 
 421fail:
 422	return NULL;
 423}
 424
 425/* Create and initialize a SCTP_SEND_FAILED notification.
 426 *
 427 * Socket Extensions for SCTP - draft-01
 428 * 5.3.1.4 SCTP_SEND_FAILED
 429 */
 430struct 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)
 433{
 434	struct sctp_ulpevent *event;
 435	struct sctp_send_failed *ssf;
 436	struct sk_buff *skb;
 437
 438	/* Pull off any padding. */
 439	int len = ntohs(chunk->chunk_hdr->length);
 440
 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 */
 444			      0,                               /* tailroom */
 445			      gfp);
 446	if (!skb)
 447		goto fail;
 448
 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);
 452
 453	/* Embed the event fields inside the cloned skb.  */
 454	event = sctp_skb2event(skb);
 455	sctp_ulpevent_init(event, MSG_NOTIFICATION, skb->truesize);
 456
 457	ssf = skb_push(skb, sizeof(struct sctp_send_failed));
 
 458
 459	/* Socket Extensions for SCTP
 460	 * 5.3.1.4 SCTP_SEND_FAILED
 461	 *
 462	 * ssf_type:
 463	 * It should be SCTP_SEND_FAILED.
 464	 */
 465	ssf->ssf_type = SCTP_SEND_FAILED;
 466
 467	/* Socket Extensions for SCTP
 468	 * 5.3.1.4 SCTP_SEND_FAILED
 469	 *
 470	 * ssf_flags: 16 bits (unsigned integer)
 471	 * The flag value will take one of the following values
 472	 *
 473	 * SCTP_DATA_UNSENT - Indicates that the data was never put on
 474	 *                    the wire.
 475	 *
 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.
 479	 */
 480	ssf->ssf_flags = flags;
 481
 482	/* Socket Extensions for SCTP
 483	 * 5.3.1.4 SCTP_SEND_FAILED
 484	 *
 485	 * ssf_length: sizeof (__u32)
 486	 * This field is the total length of the notification data, including
 487	 * the notification header.
 488	 */
 489	ssf->ssf_length = sizeof(struct sctp_send_failed) + len;
 490	skb_trim(skb, ssf->ssf_length);
 491
 492	/* Socket Extensions for SCTP
 493	 * 5.3.1.4 SCTP_SEND_FAILED
 494	 *
 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
 498	 * 3.3.10.
 499	 */
 500	ssf->ssf_error = error;
 501
 502	/* Socket Extensions for SCTP
 503	 * 5.3.1.4 SCTP_SEND_FAILED
 504	 *
 505	 * ssf_info: sizeof (struct sctp_sndrcvinfo)
 506	 * The original send information associated with the undelivered
 507	 * message.
 508	 */
 509	memcpy(&ssf->ssf_info, &chunk->sinfo, sizeof(struct sctp_sndrcvinfo));
 510
 511	/* Per TSVWG discussion with Randy. Allow the application to
 512	 * reassemble a fragmented message.
 513	 */
 514	ssf->ssf_info.sinfo_flags = chunk->chunk_hdr->flags;
 515
 516	/* Socket Extensions for SCTP
 517	 * 5.3.1.4 SCTP_SEND_FAILED
 518	 *
 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
 523	 * ignored.
 524	 */
 525	sctp_ulpevent_set_owner(event, asoc);
 526	ssf->ssf_assoc_id = sctp_assoc2id(asoc);
 527	return event;
 528
 529fail:
 530	return NULL;
 531}
 532
 533struct 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)
 536{
 537	struct sctp_send_failed_event *ssf;
 538	struct sctp_ulpevent *event;
 539	struct sk_buff *skb;
 540	int len;
 541
 542	skb = skb_copy_expand(chunk->skb, sizeof(*ssf), 0, gfp);
 543	if (!skb)
 544		return NULL;
 545
 546	len = ntohs(chunk->chunk_hdr->length);
 547	len -= sctp_datachk_len(&asoc->stream);
 548
 549	skb_pull(skb, sctp_datachk_len(&asoc->stream));
 550	event = sctp_skb2event(skb);
 551	sctp_ulpevent_init(event, MSG_NOTIFICATION, skb->truesize);
 552
 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;
 559
 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;
 565
 566	sctp_ulpevent_set_owner(event, asoc);
 567	ssf->ssf_assoc_id = sctp_assoc2id(asoc);
 568
 569	return event;
 570}
 571
 572/* Create and initialize a SCTP_SHUTDOWN_EVENT notification.
 573 *
 574 * Socket Extensions for SCTP - draft-01
 575 * 5.3.1.5 SCTP_SHUTDOWN_EVENT
 576 */
 577struct sctp_ulpevent *sctp_ulpevent_make_shutdown_event(
 578	const struct sctp_association *asoc,
 579	__u16 flags, gfp_t gfp)
 580{
 581	struct sctp_ulpevent *event;
 582	struct sctp_shutdown_event *sse;
 583	struct sk_buff *skb;
 584
 585	event = sctp_ulpevent_new(sizeof(struct sctp_shutdown_event),
 586				  MSG_NOTIFICATION, gfp);
 587	if (!event)
 588		goto fail;
 589
 590	skb = sctp_event2skb(event);
 591	sse = skb_put(skb, sizeof(struct sctp_shutdown_event));
 
 592
 593	/* Socket Extensions for SCTP
 594	 * 5.3.1.5 SCTP_SHUTDOWN_EVENT
 595	 *
 596	 * sse_type
 597	 * It should be SCTP_SHUTDOWN_EVENT
 598	 */
 599	sse->sse_type = SCTP_SHUTDOWN_EVENT;
 600
 601	/* Socket Extensions for SCTP
 602	 * 5.3.1.5 SCTP_SHUTDOWN_EVENT
 603	 *
 604	 * sse_flags: 16 bits (unsigned integer)
 605	 * Currently unused.
 606	 */
 607	sse->sse_flags = 0;
 608
 609	/* Socket Extensions for SCTP
 610	 * 5.3.1.5 SCTP_SHUTDOWN_EVENT
 611	 *
 612	 * sse_length: sizeof (__u32)
 613	 * This field is the total length of the notification data, including
 614	 * the notification header.
 615	 */
 616	sse->sse_length = sizeof(struct sctp_shutdown_event);
 617
 618	/* Socket Extensions for SCTP
 619	 * 5.3.1.5 SCTP_SHUTDOWN_EVENT
 620	 *
 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.
 625	 */
 626	sctp_ulpevent_set_owner(event, asoc);
 627	sse->sse_assoc_id = sctp_assoc2id(asoc);
 628
 629	return event;
 630
 631fail:
 632	return NULL;
 633}
 634
 635/* Create and initialize a SCTP_ADAPTATION_INDICATION notification.
 636 *
 637 * Socket Extensions for SCTP
 638 * 5.3.1.6 SCTP_ADAPTATION_INDICATION
 639 */
 640struct sctp_ulpevent *sctp_ulpevent_make_adaptation_indication(
 641	const struct sctp_association *asoc, gfp_t gfp)
 642{
 643	struct sctp_ulpevent *event;
 644	struct sctp_adaptation_event *sai;
 645	struct sk_buff *skb;
 646
 647	event = sctp_ulpevent_new(sizeof(struct sctp_adaptation_event),
 648				  MSG_NOTIFICATION, gfp);
 649	if (!event)
 650		goto fail;
 651
 652	skb = sctp_event2skb(event);
 653	sai = skb_put(skb, sizeof(struct sctp_adaptation_event));
 
 654
 655	sai->sai_type = SCTP_ADAPTATION_INDICATION;
 656	sai->sai_flags = 0;
 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);
 661
 662	return event;
 663
 664fail:
 665	return NULL;
 666}
 667
 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.
 671 *
 672 * Socket Extensions for SCTP
 673 * 5.2.2 SCTP Header Information Structure (SCTP_SNDRCV)
 674 */
 675struct sctp_ulpevent *sctp_ulpevent_make_rcvmsg(struct sctp_association *asoc,
 676						struct sctp_chunk *chunk,
 677						gfp_t gfp)
 678{
 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;
 683	int rx_count;
 684
 685	/*
 686	 * check to see if we need to make space for this
 687	 * new skb, expand the rcvbuffer if needed, or drop
 688	 * the frame
 689	 */
 690	if (asoc->ep->rcvbuf_policy)
 691		rx_count = atomic_read(&asoc->rmem_alloc);
 692	else
 693		rx_count = atomic_read(&sk->sk_rmem_alloc);
 694
 695	datalen = ntohs(chunk->chunk_hdr->length);
 696
 697	if (rx_count >= sk->sk_rcvbuf || !sk_rmem_schedule(sk, skb, datalen))
 698		goto fail;
 
 
 699
 700	/* Clone the original skb, sharing the data.  */
 701	skb = skb_clone(chunk->skb, gfp);
 702	if (!skb)
 703		goto fail;
 704
 705	/* Now that all memory allocations for this chunk succeeded, we
 706	 * can mark it as received so the tsn_map is updated correctly.
 707	 */
 708	if (sctp_tsnmap_mark(&asoc->peer.tsn_map,
 709			     ntohl(chunk->subh.data_hdr->tsn),
 710			     chunk->transport))
 711		goto fail_mark;
 712
 713	/* First calculate the padding, so we don't inadvertently
 714	 * pass up the wrong length to the user.
 715	 *
 716	 * RFC 2960 - Section 3.2  Chunk Field Descriptions
 717	 *
 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.
 724	 */
 725	padding = SCTP_PAD4(datalen) - datalen;
 
 726
 727	/* Fixup cloned skb with just this chunks data.  */
 728	skb_trim(skb, chunk->chunk_end - padding - skb->data);
 729
 730	/* Embed the event fields inside the cloned skb.  */
 731	event = sctp_skb2event(skb);
 732
 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.
 736	 */
 737	sctp_ulpevent_init(event, 0, skb->len + sizeof(struct sk_buff));
 738
 739	/* And hold the chunk as we need it for getting the IP headers
 740	 * later in recvmsg
 741	 */
 742	sctp_chunk_hold(chunk);
 743	event->chunk = chunk;
 744
 745	sctp_ulpevent_receive_data(event, asoc);
 746
 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);
 751	}
 752	event->tsn = ntohl(chunk->subh.data_hdr->tsn);
 753	event->msg_flags |= chunk->chunk_hdr->flags;
 
 754
 755	return event;
 756
 757fail_mark:
 758	kfree_skb(skb);
 759fail:
 760	return NULL;
 761}
 762
 763/* Create a partial delivery related event.
 764 *
 765 * 5.3.1.7 SCTP_PARTIAL_DELIVERY_EVENT
 766 *
 767 *   When a receiver is engaged in a partial delivery of a
 768 *   message this notification will be used to indicate
 769 *   various events.
 770 */
 771struct 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)
 775{
 776	struct sctp_ulpevent *event;
 777	struct sctp_pdapi_event *pd;
 778	struct sk_buff *skb;
 779
 780	event = sctp_ulpevent_new(sizeof(struct sctp_pdapi_event),
 781				  MSG_NOTIFICATION, gfp);
 782	if (!event)
 783		goto fail;
 784
 785	skb = sctp_event2skb(event);
 786	pd = skb_put(skb, sizeof(struct sctp_pdapi_event));
 
 787
 788	/* pdapi_type
 789	 *   It should be SCTP_PARTIAL_DELIVERY_EVENT
 790	 *
 791	 * pdapi_flags: 16 bits (unsigned integer)
 792	 *   Currently unused.
 793	 */
 794	pd->pdapi_type = SCTP_PARTIAL_DELIVERY_EVENT;
 795	pd->pdapi_flags = flags;
 796	pd->pdapi_stream = sid;
 797	pd->pdapi_seq = seq;
 798
 799	/* pdapi_length: 32 bits (unsigned integer)
 800	 *
 801	 * This field is the total length of the notification data, including
 802	 * the notification header.  It will generally be sizeof (struct
 803	 * sctp_pdapi_event).
 804	 */
 805	pd->pdapi_length = sizeof(struct sctp_pdapi_event);
 806
 807	/*  pdapi_indication: 32 bits (unsigned integer)
 808	 *
 809	 * This field holds the indication being sent to the application.
 810	 */
 811	pd->pdapi_indication = indication;
 812
 813	/*  pdapi_assoc_id: sizeof (sctp_assoc_t)
 814	 *
 815	 * The association id field, holds the identifier for the association.
 816	 */
 817	sctp_ulpevent_set_owner(event, asoc);
 818	pd->pdapi_assoc_id = sctp_assoc2id(asoc);
 819
 820	return event;
 821fail:
 822	return NULL;
 823}
 824
 825struct sctp_ulpevent *sctp_ulpevent_make_authkey(
 826	const struct sctp_association *asoc, __u16 key_id,
 827	__u32 indication, gfp_t gfp)
 828{
 829	struct sctp_ulpevent *event;
 830	struct sctp_authkey_event *ak;
 831	struct sk_buff *skb;
 832
 833	event = sctp_ulpevent_new(sizeof(struct sctp_authkey_event),
 834				  MSG_NOTIFICATION, gfp);
 835	if (!event)
 836		goto fail;
 837
 838	skb = sctp_event2skb(event);
 839	ak = skb_put(skb, sizeof(struct sctp_authkey_event));
 
 840
 841	ak->auth_type = SCTP_AUTHENTICATION_EVENT;
 842	ak->auth_flags = 0;
 843	ak->auth_length = sizeof(struct sctp_authkey_event);
 844
 845	ak->auth_keynumber = key_id;
 846	ak->auth_altkeynumber = 0;
 847	ak->auth_indication = indication;
 848
 849	/*
 850	 * The association id field, holds the identifier for the association.
 851	 */
 852	sctp_ulpevent_set_owner(event, asoc);
 853	ak->auth_assoc_id = sctp_assoc2id(asoc);
 854
 855	return event;
 856fail:
 857	return NULL;
 858}
 859
 860/*
 861 * Socket Extensions for SCTP
 862 * 6.3.10. SCTP_SENDER_DRY_EVENT
 863 */
 864struct sctp_ulpevent *sctp_ulpevent_make_sender_dry_event(
 865	const struct sctp_association *asoc, gfp_t gfp)
 866{
 867	struct sctp_ulpevent *event;
 868	struct sctp_sender_dry_event *sdry;
 869	struct sk_buff *skb;
 870
 871	event = sctp_ulpevent_new(sizeof(struct sctp_sender_dry_event),
 872				  MSG_NOTIFICATION, gfp);
 873	if (!event)
 874		return NULL;
 875
 876	skb = sctp_event2skb(event);
 877	sdry = skb_put(skb, sizeof(struct sctp_sender_dry_event));
 
 878
 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);
 884
 885	return event;
 886}
 887
 888struct 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)
 891{
 892	struct sctp_stream_reset_event *sreset;
 893	struct sctp_ulpevent *event;
 894	struct sk_buff *skb;
 895	int length, i;
 896
 897	length = sizeof(struct sctp_stream_reset_event) + 2 * stream_num;
 898	event = sctp_ulpevent_new(length, MSG_NOTIFICATION, gfp);
 899	if (!event)
 900		return NULL;
 901
 902	skb = sctp_event2skb(event);
 903	sreset = skb_put(skb, length);
 904
 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);
 910
 911	for (i = 0; i < stream_num; i++)
 912		sreset->strreset_stream_list[i] = ntohs(stream_list[i]);
 913
 914	return event;
 915}
 916
 917struct 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)
 920{
 921	struct sctp_assoc_reset_event *areset;
 922	struct sctp_ulpevent *event;
 923	struct sk_buff *skb;
 924
 925	event = sctp_ulpevent_new(sizeof(struct sctp_assoc_reset_event),
 926				  MSG_NOTIFICATION, gfp);
 927	if (!event)
 928		return NULL;
 929
 930	skb = sctp_event2skb(event);
 931	areset = skb_put(skb, sizeof(struct sctp_assoc_reset_event));
 932
 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;
 940
 941	return event;
 942}
 943
 944struct 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)
 947{
 948	struct sctp_stream_change_event *schange;
 949	struct sctp_ulpevent *event;
 950	struct sk_buff *skb;
 951
 952	event = sctp_ulpevent_new(sizeof(struct sctp_stream_change_event),
 953				  MSG_NOTIFICATION, gfp);
 954	if (!event)
 955		return NULL;
 956
 957	skb = sctp_event2skb(event);
 958	schange = skb_put(skb, sizeof(struct sctp_stream_change_event));
 959
 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;
 967
 968	return event;
 969}
 970
 971/* Return the notification type, assuming this is a notification
 972 * event.
 973 */
 974__u16 sctp_ulpevent_get_notification_type(const struct sctp_ulpevent *event)
 975{
 976	union sctp_notification *notification;
 977	struct sk_buff *skb;
 978
 979	skb = sctp_event2skb(event);
 980	notification = (union sctp_notification *) skb->data;
 981	return notification->sn_header.sn_type;
 982}
 983
 984/* RFC6458, Section 5.3.2. SCTP Header Information Structure
 985 * (SCTP_SNDRCV, DEPRECATED)
 986 */
 987void sctp_ulpevent_read_sndrcvinfo(const struct sctp_ulpevent *event,
 988				   struct msghdr *msghdr)
 989{
 990	struct sctp_sndrcvinfo sinfo;
 991
 992	if (sctp_ulpevent_is_notification(event))
 993		return;
 994
 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;
1007
1008	put_cmsg(msghdr, IPPROTO_SCTP, SCTP_SNDRCV,
1009		 sizeof(sinfo), &sinfo);
1010}
1011
1012/* RFC6458, Section 5.3.5 SCTP Receive Information Structure
1013 * (SCTP_SNDRCV)
1014 */
1015void sctp_ulpevent_read_rcvinfo(const struct sctp_ulpevent *event,
1016				struct msghdr *msghdr)
1017{
1018	struct sctp_rcvinfo rinfo;
1019
1020	if (sctp_ulpevent_is_notification(event))
1021		return;
1022
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;
1032
1033	put_cmsg(msghdr, IPPROTO_SCTP, SCTP_RCVINFO,
1034		 sizeof(rinfo), &rinfo);
1035}
1036
1037/* RFC6458, Section 5.3.6. SCTP Next Receive Information Structure
1038 * (SCTP_NXTINFO)
1039 */
1040static void __sctp_ulpevent_read_nxtinfo(const struct sctp_ulpevent *event,
1041					 struct msghdr *msghdr,
1042					 const struct sk_buff *skb)
1043{
1044	struct sctp_nxtinfo nxtinfo;
1045
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);
1054
1055	put_cmsg(msghdr, IPPROTO_SCTP, SCTP_NXTINFO,
1056		 sizeof(nxtinfo), &nxtinfo);
1057}
1058
1059void sctp_ulpevent_read_nxtinfo(const struct sctp_ulpevent *event,
1060				struct msghdr *msghdr,
1061				struct sock *sk)
1062{
1063	struct sk_buff *skb;
1064	int err;
1065
1066	skb = sctp_skb_recv_datagram(sk, MSG_PEEK | MSG_DONTWAIT, &err);
1067	if (skb != NULL) {
1068		__sctp_ulpevent_read_nxtinfo(sctp_skb2event(skb),
1069					     msghdr, skb);
1070		/* Just release refcount here. */
1071		kfree_skb(skb);
1072	}
1073}
1074
1075/* Do accounting for bytes received and hold a reference to the association
1076 * for each skb.
1077 */
1078static void sctp_ulpevent_receive_data(struct sctp_ulpevent *event,
1079				       struct sctp_association *asoc)
1080{
1081	struct sk_buff *skb, *frag;
1082
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));
1087
1088	if (!skb->data_len)
1089		return;
1090
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
1093	 * accounting.
1094	 * In general, the skb passed from IP can have only 1 level of
1095	 * fragments. But we allow multiple levels of fragments.
1096	 */
1097	skb_walk_frags(skb, frag)
1098		sctp_ulpevent_receive_data(sctp_skb2event(frag), asoc);
1099}
1100
1101/* Do accounting for bytes just read by user and release the references to
1102 * the association.
1103 */
1104static void sctp_ulpevent_release_data(struct sctp_ulpevent *event)
1105{
1106	struct sk_buff *skb, *frag;
1107	unsigned int	len;
1108
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
1113	 * association.
1114	 */
1115
1116	skb = sctp_event2skb(event);
1117	len = skb->len;
1118
1119	if (!skb->data_len)
1120		goto done;
1121
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.
1127		 */
1128		sctp_ulpevent_release_frag_data(sctp_skb2event(frag));
1129	}
1130
1131done:
1132	sctp_assoc_rwnd_increase(event->asoc, len);
1133	sctp_chunk_put(event->chunk);
1134	sctp_ulpevent_release_owner(event);
1135}
1136
1137static void sctp_ulpevent_release_frag_data(struct sctp_ulpevent *event)
1138{
1139	struct sk_buff *skb, *frag;
1140
1141	skb = sctp_event2skb(event);
1142
1143	if (!skb->data_len)
1144		goto done;
1145
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.
1151		 */
1152		sctp_ulpevent_release_frag_data(sctp_skb2event(frag));
1153	}
1154
1155done:
1156	sctp_chunk_put(event->chunk);
1157	sctp_ulpevent_release_owner(event);
1158}
1159
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
1162 * skb.
1163 */
1164void sctp_ulpevent_free(struct sctp_ulpevent *event)
1165{
1166	if (sctp_ulpevent_is_notification(event))
1167		sctp_ulpevent_release_owner(event);
1168	else
1169		sctp_ulpevent_release_data(event);
1170
1171	kfree_skb(sctp_event2skb(event));
1172}
1173
1174/* Purge the skb lists holding ulpevents. */
1175unsigned int sctp_queue_purge_ulpevents(struct sk_buff_head *list)
1176{
1177	struct sk_buff *skb;
1178	unsigned int data_unread = 0;
1179
1180	while ((skb = skb_dequeue(list)) != NULL) {
1181		struct sctp_ulpevent *event = sctp_skb2event(skb);
1182
1183		if (!sctp_ulpevent_is_notification(event))
1184			data_unread += skb->len;
1185
1186		sctp_ulpevent_free(event);
1187	}
1188
1189	return data_unread;
1190}
v3.5.6
 
   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 <lksctp-developers@lists.sourceforge.net>
  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             <jgrimm@us.ibm.com>
  38 *    La Monte H.P. Yarroll <piggy@acm.org>
  39 *    Ardelle Fan	    <ardelle.fan@intel.com>
  40 *    Sridhar Samudrala     <sri@us.ibm.com>
  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
  53static void sctp_ulpevent_receive_data(struct sctp_ulpevent *event,
  54				       struct sctp_association *asoc);
  55static void sctp_ulpevent_release_data(struct sctp_ulpevent *event);
  56static void sctp_ulpevent_release_frag_data(struct sctp_ulpevent *event);
  57
  58
  59/* Initialize an ULP event from an given skb.  */
  60SCTP_STATIC void sctp_ulpevent_init(struct sctp_ulpevent *event,
  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.  */
  70SCTP_STATIC struct sctp_ulpevent *sctp_ulpevent_new(int size, int msg_flags,
  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
  85fail:
  86	return NULL;
  87}
  88
  89/* Is this a MSG_NOTIFICATION?  */
  90int sctp_ulpevent_is_notification(const struct sctp_ulpevent *event)
  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 */
  98static 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. */
 114static 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 */
 133struct sctp_ulpevent  *sctp_ulpevent_make_assoc_change(
 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);
 157		sctp_ulpevent_init(event, MSG_NOTIFICATION, skb->truesize);
 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	 */
 184	sac->sac_type = SCTP_ASSOC_CHANGE;
 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
 250fail:
 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 */
 262struct sctp_ulpevent *sctp_ulpevent_make_peer_addr_change(
 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	 */
 287	spc->spc_type = SCTP_PEER_ADDR_CHANGE;
 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
 357fail:
 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 */
 376struct sctp_ulpevent *sctp_ulpevent_make_remote_error(
 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);
 407	sctp_ulpevent_init(event, MSG_NOTIFICATION, skb->truesize);
 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	 */
 421	sre->sre_type = SCTP_REMOTE_ERROR;
 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
 465fail:
 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 */
 474struct sctp_ulpevent *sctp_ulpevent_make_send_failed(
 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);
 499	sctp_ulpevent_init(event, MSG_NOTIFICATION, skb->truesize);
 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
 574fail:
 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 */
 583struct sctp_ulpevent *sctp_ulpevent_make_shutdown_event(
 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	 */
 606	sse->sse_type = SCTP_SHUTDOWN_EVENT;
 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
 638fail:
 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 */
 647struct sctp_ulpevent *sctp_ulpevent_make_adaptation_indication(
 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
 663	sai->sai_type = SCTP_ADAPTATION_INDICATION;
 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
 672fail:
 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 */
 683struct sctp_ulpevent *sctp_ulpevent_make_rcvmsg(struct sctp_association *asoc,
 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->truesize)))
 706			goto fail;
 707	}
 708
 709	/* Clone the original skb, sharing the data.  */
 710	skb = skb_clone(chunk->skb, gfp);
 711	if (!skb)
 712		goto fail;
 713
 714	/* Now that all memory allocations for this chunk succeeded, we
 715	 * can mark it as received so the tsn_map is updated correctly.
 716	 */
 717	if (sctp_tsnmap_mark(&asoc->peer.tsn_map,
 718			     ntohl(chunk->subh.data_hdr->tsn),
 719			     chunk->transport))
 720		goto fail_mark;
 721
 722	/* First calculate the padding, so we don't inadvertently
 723	 * pass up the wrong length to the user.
 724	 *
 725	 * RFC 2960 - Section 3.2  Chunk Field Descriptions
 726	 *
 727	 * The total length of a chunk(including Type, Length and Value fields)
 728	 * MUST be a multiple of 4 bytes.  If the length of the chunk is not a
 729	 * multiple of 4 bytes, the sender MUST pad the chunk with all zero
 730	 * bytes and this padding is not included in the chunk length field.
 731	 * The sender should never pad with more than 3 bytes.  The receiver
 732	 * MUST ignore the padding bytes.
 733	 */
 734	len = ntohs(chunk->chunk_hdr->length);
 735	padding = WORD_ROUND(len) - len;
 736
 737	/* Fixup cloned skb with just this chunks data.  */
 738	skb_trim(skb, chunk->chunk_end - padding - skb->data);
 739
 740	/* Embed the event fields inside the cloned skb.  */
 741	event = sctp_skb2event(skb);
 742
 743	/* Initialize event with flags 0  and correct length
 744	 * Since this is a clone of the original skb, only account for
 745	 * the data of this chunk as other chunks will be accounted separately.
 746	 */
 747	sctp_ulpevent_init(event, 0, skb->len + sizeof(struct sk_buff));
 748
 
 
 
 
 
 
 749	sctp_ulpevent_receive_data(event, asoc);
 750
 751	event->stream = ntohs(chunk->subh.data_hdr->stream);
 752	event->ssn = ntohs(chunk->subh.data_hdr->ssn);
 753	event->ppid = chunk->subh.data_hdr->ppid;
 754	if (chunk->chunk_hdr->flags & SCTP_DATA_UNORDERED) {
 755		event->flags |= SCTP_UNORDERED;
 756		event->cumtsn = sctp_tsnmap_get_ctsn(&asoc->peer.tsn_map);
 757	}
 758	event->tsn = ntohl(chunk->subh.data_hdr->tsn);
 759	event->msg_flags |= chunk->chunk_hdr->flags;
 760	event->iif = sctp_chunk_iif(chunk);
 761
 762	return event;
 763
 764fail_mark:
 765	kfree_skb(skb);
 766fail:
 767	return NULL;
 768}
 769
 770/* Create a partial delivery related event.
 771 *
 772 * 5.3.1.7 SCTP_PARTIAL_DELIVERY_EVENT
 773 *
 774 *   When a receiver is engaged in a partial delivery of a
 775 *   message this notification will be used to indicate
 776 *   various events.
 777 */
 778struct sctp_ulpevent *sctp_ulpevent_make_pdapi(
 779	const struct sctp_association *asoc, __u32 indication,
 780	gfp_t gfp)
 
 781{
 782	struct sctp_ulpevent *event;
 783	struct sctp_pdapi_event *pd;
 784	struct sk_buff *skb;
 785
 786	event = sctp_ulpevent_new(sizeof(struct sctp_pdapi_event),
 787				  MSG_NOTIFICATION, gfp);
 788	if (!event)
 789		goto fail;
 790
 791	skb = sctp_event2skb(event);
 792	pd = (struct sctp_pdapi_event *)
 793		skb_put(skb, sizeof(struct sctp_pdapi_event));
 794
 795	/* pdapi_type
 796	 *   It should be SCTP_PARTIAL_DELIVERY_EVENT
 797	 *
 798	 * pdapi_flags: 16 bits (unsigned integer)
 799	 *   Currently unused.
 800	 */
 801	pd->pdapi_type = SCTP_PARTIAL_DELIVERY_EVENT;
 802	pd->pdapi_flags = 0;
 
 
 803
 804	/* pdapi_length: 32 bits (unsigned integer)
 805	 *
 806	 * This field is the total length of the notification data, including
 807	 * the notification header.  It will generally be sizeof (struct
 808	 * sctp_pdapi_event).
 809	 */
 810	pd->pdapi_length = sizeof(struct sctp_pdapi_event);
 811
 812	/*  pdapi_indication: 32 bits (unsigned integer)
 813	 *
 814	 * This field holds the indication being sent to the application.
 815	 */
 816	pd->pdapi_indication = indication;
 817
 818	/*  pdapi_assoc_id: sizeof (sctp_assoc_t)
 819	 *
 820	 * The association id field, holds the identifier for the association.
 821	 */
 822	sctp_ulpevent_set_owner(event, asoc);
 823	pd->pdapi_assoc_id = sctp_assoc2id(asoc);
 824
 825	return event;
 826fail:
 827	return NULL;
 828}
 829
 830struct sctp_ulpevent *sctp_ulpevent_make_authkey(
 831	const struct sctp_association *asoc, __u16 key_id,
 832	__u32 indication, gfp_t gfp)
 833{
 834	struct sctp_ulpevent *event;
 835	struct sctp_authkey_event *ak;
 836	struct sk_buff *skb;
 837
 838	event = sctp_ulpevent_new(sizeof(struct sctp_authkey_event),
 839				  MSG_NOTIFICATION, gfp);
 840	if (!event)
 841		goto fail;
 842
 843	skb = sctp_event2skb(event);
 844	ak = (struct sctp_authkey_event *)
 845		skb_put(skb, sizeof(struct sctp_authkey_event));
 846
 847	ak->auth_type = SCTP_AUTHENTICATION_EVENT;
 848	ak->auth_flags = 0;
 849	ak->auth_length = sizeof(struct sctp_authkey_event);
 850
 851	ak->auth_keynumber = key_id;
 852	ak->auth_altkeynumber = 0;
 853	ak->auth_indication = indication;
 854
 855	/*
 856	 * The association id field, holds the identifier for the association.
 857	 */
 858	sctp_ulpevent_set_owner(event, asoc);
 859	ak->auth_assoc_id = sctp_assoc2id(asoc);
 860
 861	return event;
 862fail:
 863	return NULL;
 864}
 865
 866/*
 867 * Socket Extensions for SCTP
 868 * 6.3.10. SCTP_SENDER_DRY_EVENT
 869 */
 870struct sctp_ulpevent *sctp_ulpevent_make_sender_dry_event(
 871	const struct sctp_association *asoc, gfp_t gfp)
 872{
 873	struct sctp_ulpevent *event;
 874	struct sctp_sender_dry_event *sdry;
 875	struct sk_buff *skb;
 876
 877	event = sctp_ulpevent_new(sizeof(struct sctp_sender_dry_event),
 878				  MSG_NOTIFICATION, gfp);
 879	if (!event)
 880		return NULL;
 881
 882	skb = sctp_event2skb(event);
 883	sdry = (struct sctp_sender_dry_event *)
 884		skb_put(skb, sizeof(struct sctp_sender_dry_event));
 885
 886	sdry->sender_dry_type = SCTP_SENDER_DRY_EVENT;
 887	sdry->sender_dry_flags = 0;
 888	sdry->sender_dry_length = sizeof(struct sctp_sender_dry_event);
 889	sctp_ulpevent_set_owner(event, asoc);
 890	sdry->sender_dry_assoc_id = sctp_assoc2id(asoc);
 891
 892	return event;
 893}
 894
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 895/* Return the notification type, assuming this is a notification
 896 * event.
 897 */
 898__u16 sctp_ulpevent_get_notification_type(const struct sctp_ulpevent *event)
 899{
 900	union sctp_notification *notification;
 901	struct sk_buff *skb;
 902
 903	skb = sctp_event2skb(event);
 904	notification = (union sctp_notification *) skb->data;
 905	return notification->sn_header.sn_type;
 906}
 907
 908/* Copy out the sndrcvinfo into a msghdr.  */
 
 
 909void sctp_ulpevent_read_sndrcvinfo(const struct sctp_ulpevent *event,
 910				   struct msghdr *msghdr)
 911{
 912	struct sctp_sndrcvinfo sinfo;
 913
 914	if (sctp_ulpevent_is_notification(event))
 915		return;
 916
 917	/* Sockets API Extensions for SCTP
 918	 * Section 5.2.2 SCTP Header Information Structure (SCTP_SNDRCV)
 919	 *
 920	 * sinfo_stream: 16 bits (unsigned integer)
 921	 *
 922	 * For recvmsg() the SCTP stack places the message's stream number in
 923	 * this value.
 924	*/
 925	sinfo.sinfo_stream = event->stream;
 926	/* sinfo_ssn: 16 bits (unsigned integer)
 927	 *
 928	 * For recvmsg() this value contains the stream sequence number that
 929	 * the remote endpoint placed in the DATA chunk.  For fragmented
 930	 * messages this is the same number for all deliveries of the message
 931	 * (if more than one recvmsg() is needed to read the message).
 932	 */
 933	sinfo.sinfo_ssn = event->ssn;
 934	/* sinfo_ppid: 32 bits (unsigned integer)
 935	 *
 936	 * In recvmsg() this value is
 937	 * the same information that was passed by the upper layer in the peer
 938	 * application.  Please note that byte order issues are NOT accounted
 939	 * for and this information is passed opaquely by the SCTP stack from
 940	 * one end to the other.
 941	 */
 942	sinfo.sinfo_ppid = event->ppid;
 943	/* sinfo_flags: 16 bits (unsigned integer)
 944	 *
 945	 * This field may contain any of the following flags and is composed of
 946	 * a bitwise OR of these values.
 947	 *
 948	 * recvmsg() flags:
 949	 *
 950	 * SCTP_UNORDERED - This flag is present when the message was sent
 951	 *                 non-ordered.
 952	 */
 953	sinfo.sinfo_flags = event->flags;
 954	/* sinfo_tsn: 32 bit (unsigned integer)
 955	 *
 956	 * For the receiving side, this field holds a TSN that was
 957	 * assigned to one of the SCTP Data Chunks.
 958	 */
 959	sinfo.sinfo_tsn = event->tsn;
 960	/* sinfo_cumtsn: 32 bit (unsigned integer)
 961	 *
 962	 * This field will hold the current cumulative TSN as
 963	 * known by the underlying SCTP layer.  Note this field is
 964	 * ignored when sending and only valid for a receive
 965	 * operation when sinfo_flags are set to SCTP_UNORDERED.
 966	 */
 967	sinfo.sinfo_cumtsn = event->cumtsn;
 968	/* sinfo_assoc_id: sizeof (sctp_assoc_t)
 969	 *
 970	 * The association handle field, sinfo_assoc_id, holds the identifier
 971	 * for the association announced in the COMMUNICATION_UP notification.
 972	 * All notifications for a given association have the same identifier.
 973	 * Ignored for one-to-one style sockets.
 974	 */
 975	sinfo.sinfo_assoc_id = sctp_assoc2id(event->asoc);
 976
 977	/* context value that is set via SCTP_CONTEXT socket option. */
 978	sinfo.sinfo_context = event->asoc->default_rcv_context;
 979
 980	/* These fields are not used while receiving. */
 981	sinfo.sinfo_timetolive = 0;
 982
 983	put_cmsg(msghdr, IPPROTO_SCTP, SCTP_SNDRCV,
 984		 sizeof(struct sctp_sndrcvinfo), (void *)&sinfo);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 985}
 986
 987/* Do accounting for bytes received and hold a reference to the association
 988 * for each skb.
 989 */
 990static void sctp_ulpevent_receive_data(struct sctp_ulpevent *event,
 991				       struct sctp_association *asoc)
 992{
 993	struct sk_buff *skb, *frag;
 994
 995	skb = sctp_event2skb(event);
 996	/* Set the owner and charge rwnd for bytes received.  */
 997	sctp_ulpevent_set_owner(event, asoc);
 998	sctp_assoc_rwnd_decrease(asoc, skb_headlen(skb));
 999
1000	if (!skb->data_len)
1001		return;
1002
1003	/* Note:  Not clearing the entire event struct as this is just a
1004	 * fragment of the real event.  However, we still need to do rwnd
1005	 * accounting.
1006	 * In general, the skb passed from IP can have only 1 level of
1007	 * fragments. But we allow multiple levels of fragments.
1008	 */
1009	skb_walk_frags(skb, frag)
1010		sctp_ulpevent_receive_data(sctp_skb2event(frag), asoc);
1011}
1012
1013/* Do accounting for bytes just read by user and release the references to
1014 * the association.
1015 */
1016static void sctp_ulpevent_release_data(struct sctp_ulpevent *event)
1017{
1018	struct sk_buff *skb, *frag;
1019	unsigned int	len;
1020
1021	/* Current stack structures assume that the rcv buffer is
1022	 * per socket.   For UDP style sockets this is not true as
1023	 * multiple associations may be on a single UDP-style socket.
1024	 * Use the local private area of the skb to track the owning
1025	 * association.
1026	 */
1027
1028	skb = sctp_event2skb(event);
1029	len = skb->len;
1030
1031	if (!skb->data_len)
1032		goto done;
1033
1034	/* Don't forget the fragments. */
1035	skb_walk_frags(skb, frag) {
1036		/* NOTE:  skb_shinfos are recursive. Although IP returns
1037		 * skb's with only 1 level of fragments, SCTP reassembly can
1038		 * increase the levels.
1039		 */
1040		sctp_ulpevent_release_frag_data(sctp_skb2event(frag));
1041	}
1042
1043done:
1044	sctp_assoc_rwnd_increase(event->asoc, len);
 
1045	sctp_ulpevent_release_owner(event);
1046}
1047
1048static void sctp_ulpevent_release_frag_data(struct sctp_ulpevent *event)
1049{
1050	struct sk_buff *skb, *frag;
1051
1052	skb = sctp_event2skb(event);
1053
1054	if (!skb->data_len)
1055		goto done;
1056
1057	/* Don't forget the fragments. */
1058	skb_walk_frags(skb, frag) {
1059		/* NOTE:  skb_shinfos are recursive. Although IP returns
1060		 * skb's with only 1 level of fragments, SCTP reassembly can
1061		 * increase the levels.
1062		 */
1063		sctp_ulpevent_release_frag_data(sctp_skb2event(frag));
1064	}
1065
1066done:
 
1067	sctp_ulpevent_release_owner(event);
1068}
1069
1070/* Free a ulpevent that has an owner.  It includes releasing the reference
1071 * to the owner, updating the rwnd in case of a DATA event and freeing the
1072 * skb.
1073 */
1074void sctp_ulpevent_free(struct sctp_ulpevent *event)
1075{
1076	if (sctp_ulpevent_is_notification(event))
1077		sctp_ulpevent_release_owner(event);
1078	else
1079		sctp_ulpevent_release_data(event);
1080
1081	kfree_skb(sctp_event2skb(event));
1082}
1083
1084/* Purge the skb lists holding ulpevents. */
1085unsigned int sctp_queue_purge_ulpevents(struct sk_buff_head *list)
1086{
1087	struct sk_buff *skb;
1088	unsigned int data_unread = 0;
1089
1090	while ((skb = skb_dequeue(list)) != NULL) {
1091		struct sctp_ulpevent *event = sctp_skb2event(skb);
1092
1093		if (!sctp_ulpevent_is_notification(event))
1094			data_unread += skb->len;
1095
1096		sctp_ulpevent_free(event);
1097	}
1098
1099	return data_unread;
1100}