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