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 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); 35 36 37 /* Initialize an ULP event from an given skb. */ 38 static 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. */ 48 static 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 63 fail: 64 return NULL; 65 } 66 67 /* Is this a MSG_NOTIFICATION? */ 68 int 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 */ 76 static 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. */ 95 static 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 */ 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) 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 229 fail: 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 */ 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) 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 335 fail: 336 return NULL; 337 } 338 339 void 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 */ 373 struct sctp_ulpevent * 374 sctp_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; 421 fail: 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 */ 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) 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 529 fail: 530 return NULL; 531 } 532 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) 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 */ 577 struct 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 631 fail: 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 */ 640 struct 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 664 fail: 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 */ 675 struct 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 757 fail_mark: 758 kfree_skb(skb); 759 fail: 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 */ 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) 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; 821 fail: 822 return NULL; 823 } 824 825 struct 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; 856 fail: 857 return NULL; 858 } 859 860 /* 861 * Socket Extensions for SCTP 862 * 6.3.10. SCTP_SENDER_DRY_EVENT 863 */ 864 struct 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 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) 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 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) 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 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) 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 */ 987 void 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 */ 1015 void 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 */ 1040 static 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 1059 void 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 */ 1078 static 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 */ 1104 static 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 1131 done: 1132 sctp_assoc_rwnd_increase(event->asoc, len); 1133 sctp_chunk_put(event->chunk); 1134 sctp_ulpevent_release_owner(event); 1135 } 1136 1137 static 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 1155 done: 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 */ 1164 void 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. */ 1175 unsigned 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 } 1191