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 * 6 * This file is part of the SCTP kernel implementation 7 * 8 * These functions handle output processing. 9 * 10 * This SCTP implementation is free software; 11 * you can redistribute it and/or modify it under the terms of 12 * the GNU General Public License as published by 13 * the Free Software Foundation; either version 2, or (at your option) 14 * any later version. 15 * 16 * This SCTP implementation is distributed in the hope that it 17 * will be useful, but WITHOUT ANY WARRANTY; without even the implied 18 * ************************ 19 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 20 * See the GNU General Public License for more details. 21 * 22 * You should have received a copy of the GNU General Public License 23 * along with GNU CC; see the file COPYING. If not, see 24 * <http://www.gnu.org/licenses/>. 25 * 26 * Please send any bug reports or fixes you make to the 27 * email address(es): 28 * lksctp developers <linux-sctp@vger.kernel.org> 29 * 30 * Written or modified by: 31 * La Monte H.P. Yarroll <piggy@acm.org> 32 * Karl Knutson <karl@athena.chicago.il.us> 33 * Jon Grimm <jgrimm@austin.ibm.com> 34 * Sridhar Samudrala <sri@us.ibm.com> 35 */ 36 37 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 38 39 #include <linux/types.h> 40 #include <linux/kernel.h> 41 #include <linux/wait.h> 42 #include <linux/time.h> 43 #include <linux/ip.h> 44 #include <linux/ipv6.h> 45 #include <linux/init.h> 46 #include <linux/slab.h> 47 #include <net/inet_ecn.h> 48 #include <net/ip.h> 49 #include <net/icmp.h> 50 #include <net/net_namespace.h> 51 52 #include <linux/socket.h> /* for sa_family_t */ 53 #include <net/sock.h> 54 55 #include <net/sctp/sctp.h> 56 #include <net/sctp/sm.h> 57 #include <net/sctp/checksum.h> 58 59 /* Forward declarations for private helpers. */ 60 static sctp_xmit_t __sctp_packet_append_chunk(struct sctp_packet *packet, 61 struct sctp_chunk *chunk); 62 static sctp_xmit_t sctp_packet_can_append_data(struct sctp_packet *packet, 63 struct sctp_chunk *chunk); 64 static void sctp_packet_append_data(struct sctp_packet *packet, 65 struct sctp_chunk *chunk); 66 static sctp_xmit_t sctp_packet_will_fit(struct sctp_packet *packet, 67 struct sctp_chunk *chunk, 68 u16 chunk_len); 69 70 static void sctp_packet_reset(struct sctp_packet *packet) 71 { 72 packet->size = packet->overhead; 73 packet->has_cookie_echo = 0; 74 packet->has_sack = 0; 75 packet->has_data = 0; 76 packet->has_auth = 0; 77 packet->ipfragok = 0; 78 packet->auth = NULL; 79 } 80 81 /* Config a packet. 82 * This appears to be a followup set of initializations. 83 */ 84 struct sctp_packet *sctp_packet_config(struct sctp_packet *packet, 85 __u32 vtag, int ecn_capable) 86 { 87 struct sctp_chunk *chunk = NULL; 88 89 pr_debug("%s: packet:%p vtag:0x%x\n", __func__, packet, vtag); 90 91 packet->vtag = vtag; 92 93 if (ecn_capable && sctp_packet_empty(packet)) { 94 chunk = sctp_get_ecne_prepend(packet->transport->asoc); 95 96 /* If there a is a prepend chunk stick it on the list before 97 * any other chunks get appended. 98 */ 99 if (chunk) 100 sctp_packet_append_chunk(packet, chunk); 101 } 102 103 return packet; 104 } 105 106 /* Initialize the packet structure. */ 107 struct sctp_packet *sctp_packet_init(struct sctp_packet *packet, 108 struct sctp_transport *transport, 109 __u16 sport, __u16 dport) 110 { 111 struct sctp_association *asoc = transport->asoc; 112 size_t overhead; 113 114 pr_debug("%s: packet:%p transport:%p\n", __func__, packet, transport); 115 116 packet->transport = transport; 117 packet->source_port = sport; 118 packet->destination_port = dport; 119 INIT_LIST_HEAD(&packet->chunk_list); 120 if (asoc) { 121 struct sctp_sock *sp = sctp_sk(asoc->base.sk); 122 overhead = sp->pf->af->net_header_len; 123 } else { 124 overhead = sizeof(struct ipv6hdr); 125 } 126 overhead += sizeof(struct sctphdr); 127 packet->overhead = overhead; 128 sctp_packet_reset(packet); 129 packet->vtag = 0; 130 131 return packet; 132 } 133 134 /* Free a packet. */ 135 void sctp_packet_free(struct sctp_packet *packet) 136 { 137 struct sctp_chunk *chunk, *tmp; 138 139 pr_debug("%s: packet:%p\n", __func__, packet); 140 141 list_for_each_entry_safe(chunk, tmp, &packet->chunk_list, list) { 142 list_del_init(&chunk->list); 143 sctp_chunk_free(chunk); 144 } 145 } 146 147 /* This routine tries to append the chunk to the offered packet. If adding 148 * the chunk causes the packet to exceed the path MTU and COOKIE_ECHO chunk 149 * is not present in the packet, it transmits the input packet. 150 * Data can be bundled with a packet containing a COOKIE_ECHO chunk as long 151 * as it can fit in the packet, but any more data that does not fit in this 152 * packet can be sent only after receiving the COOKIE_ACK. 153 */ 154 sctp_xmit_t sctp_packet_transmit_chunk(struct sctp_packet *packet, 155 struct sctp_chunk *chunk, 156 int one_packet) 157 { 158 sctp_xmit_t retval; 159 int error = 0; 160 161 pr_debug("%s: packet:%p chunk:%p\n", __func__, packet, chunk); 162 163 switch ((retval = (sctp_packet_append_chunk(packet, chunk)))) { 164 case SCTP_XMIT_PMTU_FULL: 165 if (!packet->has_cookie_echo) { 166 error = sctp_packet_transmit(packet); 167 if (error < 0) 168 chunk->skb->sk->sk_err = -error; 169 170 /* If we have an empty packet, then we can NOT ever 171 * return PMTU_FULL. 172 */ 173 if (!one_packet) 174 retval = sctp_packet_append_chunk(packet, 175 chunk); 176 } 177 break; 178 179 case SCTP_XMIT_RWND_FULL: 180 case SCTP_XMIT_OK: 181 case SCTP_XMIT_DELAY: 182 break; 183 } 184 185 return retval; 186 } 187 188 /* Try to bundle an auth chunk into the packet. */ 189 static sctp_xmit_t sctp_packet_bundle_auth(struct sctp_packet *pkt, 190 struct sctp_chunk *chunk) 191 { 192 struct sctp_association *asoc = pkt->transport->asoc; 193 struct sctp_chunk *auth; 194 sctp_xmit_t retval = SCTP_XMIT_OK; 195 196 /* if we don't have an association, we can't do authentication */ 197 if (!asoc) 198 return retval; 199 200 /* See if this is an auth chunk we are bundling or if 201 * auth is already bundled. 202 */ 203 if (chunk->chunk_hdr->type == SCTP_CID_AUTH || pkt->has_auth) 204 return retval; 205 206 /* if the peer did not request this chunk to be authenticated, 207 * don't do it 208 */ 209 if (!chunk->auth) 210 return retval; 211 212 auth = sctp_make_auth(asoc); 213 if (!auth) 214 return retval; 215 216 retval = __sctp_packet_append_chunk(pkt, auth); 217 218 if (retval != SCTP_XMIT_OK) 219 sctp_chunk_free(auth); 220 221 return retval; 222 } 223 224 /* Try to bundle a SACK with the packet. */ 225 static sctp_xmit_t sctp_packet_bundle_sack(struct sctp_packet *pkt, 226 struct sctp_chunk *chunk) 227 { 228 sctp_xmit_t retval = SCTP_XMIT_OK; 229 230 /* If sending DATA and haven't aleady bundled a SACK, try to 231 * bundle one in to the packet. 232 */ 233 if (sctp_chunk_is_data(chunk) && !pkt->has_sack && 234 !pkt->has_cookie_echo) { 235 struct sctp_association *asoc; 236 struct timer_list *timer; 237 asoc = pkt->transport->asoc; 238 timer = &asoc->timers[SCTP_EVENT_TIMEOUT_SACK]; 239 240 /* If the SACK timer is running, we have a pending SACK */ 241 if (timer_pending(timer)) { 242 struct sctp_chunk *sack; 243 244 if (pkt->transport->sack_generation != 245 pkt->transport->asoc->peer.sack_generation) 246 return retval; 247 248 asoc->a_rwnd = asoc->rwnd; 249 sack = sctp_make_sack(asoc); 250 if (sack) { 251 retval = __sctp_packet_append_chunk(pkt, sack); 252 if (retval != SCTP_XMIT_OK) { 253 sctp_chunk_free(sack); 254 goto out; 255 } 256 asoc->peer.sack_needed = 0; 257 if (del_timer(timer)) 258 sctp_association_put(asoc); 259 } 260 } 261 } 262 out: 263 return retval; 264 } 265 266 267 /* Append a chunk to the offered packet reporting back any inability to do 268 * so. 269 */ 270 static sctp_xmit_t __sctp_packet_append_chunk(struct sctp_packet *packet, 271 struct sctp_chunk *chunk) 272 { 273 sctp_xmit_t retval = SCTP_XMIT_OK; 274 __u16 chunk_len = WORD_ROUND(ntohs(chunk->chunk_hdr->length)); 275 276 /* Check to see if this chunk will fit into the packet */ 277 retval = sctp_packet_will_fit(packet, chunk, chunk_len); 278 if (retval != SCTP_XMIT_OK) 279 goto finish; 280 281 /* We believe that this chunk is OK to add to the packet */ 282 switch (chunk->chunk_hdr->type) { 283 case SCTP_CID_DATA: 284 /* Account for the data being in the packet */ 285 sctp_packet_append_data(packet, chunk); 286 /* Disallow SACK bundling after DATA. */ 287 packet->has_sack = 1; 288 /* Disallow AUTH bundling after DATA */ 289 packet->has_auth = 1; 290 /* Let it be knows that packet has DATA in it */ 291 packet->has_data = 1; 292 /* timestamp the chunk for rtx purposes */ 293 chunk->sent_at = jiffies; 294 break; 295 case SCTP_CID_COOKIE_ECHO: 296 packet->has_cookie_echo = 1; 297 break; 298 299 case SCTP_CID_SACK: 300 packet->has_sack = 1; 301 if (chunk->asoc) 302 chunk->asoc->stats.osacks++; 303 break; 304 305 case SCTP_CID_AUTH: 306 packet->has_auth = 1; 307 packet->auth = chunk; 308 break; 309 } 310 311 /* It is OK to send this chunk. */ 312 list_add_tail(&chunk->list, &packet->chunk_list); 313 packet->size += chunk_len; 314 chunk->transport = packet->transport; 315 finish: 316 return retval; 317 } 318 319 /* Append a chunk to the offered packet reporting back any inability to do 320 * so. 321 */ 322 sctp_xmit_t sctp_packet_append_chunk(struct sctp_packet *packet, 323 struct sctp_chunk *chunk) 324 { 325 sctp_xmit_t retval = SCTP_XMIT_OK; 326 327 pr_debug("%s: packet:%p chunk:%p\n", __func__, packet, chunk); 328 329 /* Data chunks are special. Before seeing what else we can 330 * bundle into this packet, check to see if we are allowed to 331 * send this DATA. 332 */ 333 if (sctp_chunk_is_data(chunk)) { 334 retval = sctp_packet_can_append_data(packet, chunk); 335 if (retval != SCTP_XMIT_OK) 336 goto finish; 337 } 338 339 /* Try to bundle AUTH chunk */ 340 retval = sctp_packet_bundle_auth(packet, chunk); 341 if (retval != SCTP_XMIT_OK) 342 goto finish; 343 344 /* Try to bundle SACK chunk */ 345 retval = sctp_packet_bundle_sack(packet, chunk); 346 if (retval != SCTP_XMIT_OK) 347 goto finish; 348 349 retval = __sctp_packet_append_chunk(packet, chunk); 350 351 finish: 352 return retval; 353 } 354 355 static void sctp_packet_release_owner(struct sk_buff *skb) 356 { 357 sk_free(skb->sk); 358 } 359 360 static void sctp_packet_set_owner_w(struct sk_buff *skb, struct sock *sk) 361 { 362 skb_orphan(skb); 363 skb->sk = sk; 364 skb->destructor = sctp_packet_release_owner; 365 366 /* 367 * The data chunks have already been accounted for in sctp_sendmsg(), 368 * therefore only reserve a single byte to keep socket around until 369 * the packet has been transmitted. 370 */ 371 atomic_inc(&sk->sk_wmem_alloc); 372 } 373 374 /* All packets are sent to the network through this function from 375 * sctp_outq_tail(). 376 * 377 * The return value is a normal kernel error return value. 378 */ 379 int sctp_packet_transmit(struct sctp_packet *packet) 380 { 381 struct sctp_transport *tp = packet->transport; 382 struct sctp_association *asoc = tp->asoc; 383 struct sctphdr *sh; 384 struct sk_buff *nskb; 385 struct sctp_chunk *chunk, *tmp; 386 struct sock *sk; 387 int err = 0; 388 int padding; /* How much padding do we need? */ 389 __u8 has_data = 0; 390 struct dst_entry *dst; 391 unsigned char *auth = NULL; /* pointer to auth in skb data */ 392 393 pr_debug("%s: packet:%p\n", __func__, packet); 394 395 /* Do NOT generate a chunkless packet. */ 396 if (list_empty(&packet->chunk_list)) 397 return err; 398 399 /* Set up convenience variables... */ 400 chunk = list_entry(packet->chunk_list.next, struct sctp_chunk, list); 401 sk = chunk->skb->sk; 402 403 /* Allocate the new skb. */ 404 nskb = alloc_skb(packet->size + MAX_HEADER, GFP_ATOMIC); 405 if (!nskb) 406 goto nomem; 407 408 /* Make sure the outbound skb has enough header room reserved. */ 409 skb_reserve(nskb, packet->overhead + MAX_HEADER); 410 411 /* Set the owning socket so that we know where to get the 412 * destination IP address. 413 */ 414 sctp_packet_set_owner_w(nskb, sk); 415 416 if (!sctp_transport_dst_check(tp)) { 417 sctp_transport_route(tp, NULL, sctp_sk(sk)); 418 if (asoc && (asoc->param_flags & SPP_PMTUD_ENABLE)) { 419 sctp_assoc_sync_pmtu(sk, asoc); 420 } 421 } 422 dst = dst_clone(tp->dst); 423 if (!dst) 424 goto no_route; 425 skb_dst_set(nskb, dst); 426 427 /* Build the SCTP header. */ 428 sh = (struct sctphdr *)skb_push(nskb, sizeof(struct sctphdr)); 429 skb_reset_transport_header(nskb); 430 sh->source = htons(packet->source_port); 431 sh->dest = htons(packet->destination_port); 432 433 /* From 6.8 Adler-32 Checksum Calculation: 434 * After the packet is constructed (containing the SCTP common 435 * header and one or more control or DATA chunks), the 436 * transmitter shall: 437 * 438 * 1) Fill in the proper Verification Tag in the SCTP common 439 * header and initialize the checksum field to 0's. 440 */ 441 sh->vtag = htonl(packet->vtag); 442 sh->checksum = 0; 443 444 /** 445 * 6.10 Bundling 446 * 447 * An endpoint bundles chunks by simply including multiple 448 * chunks in one outbound SCTP packet. ... 449 */ 450 451 /** 452 * 3.2 Chunk Field Descriptions 453 * 454 * The total length of a chunk (including Type, Length and 455 * Value fields) MUST be a multiple of 4 bytes. If the length 456 * of the chunk is not a multiple of 4 bytes, the sender MUST 457 * pad the chunk with all zero bytes and this padding is not 458 * included in the chunk length field. The sender should 459 * never pad with more than 3 bytes. 460 * 461 * [This whole comment explains WORD_ROUND() below.] 462 */ 463 464 pr_debug("***sctp_transmit_packet***\n"); 465 466 list_for_each_entry_safe(chunk, tmp, &packet->chunk_list, list) { 467 list_del_init(&chunk->list); 468 if (sctp_chunk_is_data(chunk)) { 469 /* 6.3.1 C4) When data is in flight and when allowed 470 * by rule C5, a new RTT measurement MUST be made each 471 * round trip. Furthermore, new RTT measurements 472 * SHOULD be made no more than once per round-trip 473 * for a given destination transport address. 474 */ 475 476 if (!chunk->resent && !tp->rto_pending) { 477 chunk->rtt_in_progress = 1; 478 tp->rto_pending = 1; 479 } 480 481 has_data = 1; 482 } 483 484 padding = WORD_ROUND(chunk->skb->len) - chunk->skb->len; 485 if (padding) 486 memset(skb_put(chunk->skb, padding), 0, padding); 487 488 /* if this is the auth chunk that we are adding, 489 * store pointer where it will be added and put 490 * the auth into the packet. 491 */ 492 if (chunk == packet->auth) 493 auth = skb_tail_pointer(nskb); 494 495 memcpy(skb_put(nskb, chunk->skb->len), 496 chunk->skb->data, chunk->skb->len); 497 498 pr_debug("*** Chunk:%p[%s] %s 0x%x, length:%d, chunk->skb->len:%d, " 499 "rtt_in_progress:%d\n", chunk, 500 sctp_cname(SCTP_ST_CHUNK(chunk->chunk_hdr->type)), 501 chunk->has_tsn ? "TSN" : "No TSN", 502 chunk->has_tsn ? ntohl(chunk->subh.data_hdr->tsn) : 0, 503 ntohs(chunk->chunk_hdr->length), chunk->skb->len, 504 chunk->rtt_in_progress); 505 506 /* 507 * If this is a control chunk, this is our last 508 * reference. Free data chunks after they've been 509 * acknowledged or have failed. 510 */ 511 if (!sctp_chunk_is_data(chunk)) 512 sctp_chunk_free(chunk); 513 } 514 515 /* SCTP-AUTH, Section 6.2 516 * The sender MUST calculate the MAC as described in RFC2104 [2] 517 * using the hash function H as described by the MAC Identifier and 518 * the shared association key K based on the endpoint pair shared key 519 * described by the shared key identifier. The 'data' used for the 520 * computation of the AUTH-chunk is given by the AUTH chunk with its 521 * HMAC field set to zero (as shown in Figure 6) followed by all 522 * chunks that are placed after the AUTH chunk in the SCTP packet. 523 */ 524 if (auth) 525 sctp_auth_calculate_hmac(asoc, nskb, 526 (struct sctp_auth_chunk *)auth, 527 GFP_ATOMIC); 528 529 /* 2) Calculate the Adler-32 checksum of the whole packet, 530 * including the SCTP common header and all the 531 * chunks. 532 * 533 * Note: Adler-32 is no longer applicable, as has been replaced 534 * by CRC32-C as described in <draft-ietf-tsvwg-sctpcsum-02.txt>. 535 */ 536 if (!sctp_checksum_disable) { 537 if (!(dst->dev->features & NETIF_F_SCTP_CSUM) || 538 (dst_xfrm(dst) != NULL) || packet->ipfragok) { 539 sh->checksum = sctp_compute_cksum(nskb, 0); 540 } else { 541 /* no need to seed pseudo checksum for SCTP */ 542 nskb->ip_summed = CHECKSUM_PARTIAL; 543 nskb->csum_start = skb_transport_header(nskb) - nskb->head; 544 nskb->csum_offset = offsetof(struct sctphdr, checksum); 545 } 546 } 547 548 /* IP layer ECN support 549 * From RFC 2481 550 * "The ECN-Capable Transport (ECT) bit would be set by the 551 * data sender to indicate that the end-points of the 552 * transport protocol are ECN-capable." 553 * 554 * Now setting the ECT bit all the time, as it should not cause 555 * any problems protocol-wise even if our peer ignores it. 556 * 557 * Note: The works for IPv6 layer checks this bit too later 558 * in transmission. See IP6_ECN_flow_xmit(). 559 */ 560 tp->af_specific->ecn_capable(nskb->sk); 561 562 /* Set up the IP options. */ 563 /* BUG: not implemented 564 * For v4 this all lives somewhere in sk->sk_opt... 565 */ 566 567 /* Dump that on IP! */ 568 if (asoc) { 569 asoc->stats.opackets++; 570 if (asoc->peer.last_sent_to != tp) 571 /* Considering the multiple CPU scenario, this is a 572 * "correcter" place for last_sent_to. --xguo 573 */ 574 asoc->peer.last_sent_to = tp; 575 } 576 577 if (has_data) { 578 struct timer_list *timer; 579 unsigned long timeout; 580 581 /* Restart the AUTOCLOSE timer when sending data. */ 582 if (sctp_state(asoc, ESTABLISHED) && 583 asoc->timeouts[SCTP_EVENT_TIMEOUT_AUTOCLOSE]) { 584 timer = &asoc->timers[SCTP_EVENT_TIMEOUT_AUTOCLOSE]; 585 timeout = asoc->timeouts[SCTP_EVENT_TIMEOUT_AUTOCLOSE]; 586 587 if (!mod_timer(timer, jiffies + timeout)) 588 sctp_association_hold(asoc); 589 } 590 } 591 592 pr_debug("***sctp_transmit_packet*** skb->len:%d\n", nskb->len); 593 594 nskb->ignore_df = packet->ipfragok; 595 tp->af_specific->sctp_xmit(nskb, tp); 596 597 out: 598 sctp_packet_reset(packet); 599 return err; 600 no_route: 601 kfree_skb(nskb); 602 603 if (asoc) 604 IP_INC_STATS(sock_net(asoc->base.sk), IPSTATS_MIB_OUTNOROUTES); 605 606 /* FIXME: Returning the 'err' will effect all the associations 607 * associated with a socket, although only one of the paths of the 608 * association is unreachable. 609 * The real failure of a transport or association can be passed on 610 * to the user via notifications. So setting this error may not be 611 * required. 612 */ 613 /* err = -EHOSTUNREACH; */ 614 err: 615 /* Control chunks are unreliable so just drop them. DATA chunks 616 * will get resent or dropped later. 617 */ 618 619 list_for_each_entry_safe(chunk, tmp, &packet->chunk_list, list) { 620 list_del_init(&chunk->list); 621 if (!sctp_chunk_is_data(chunk)) 622 sctp_chunk_free(chunk); 623 } 624 goto out; 625 nomem: 626 err = -ENOMEM; 627 goto err; 628 } 629 630 /******************************************************************** 631 * 2nd Level Abstractions 632 ********************************************************************/ 633 634 /* This private function check to see if a chunk can be added */ 635 static sctp_xmit_t sctp_packet_can_append_data(struct sctp_packet *packet, 636 struct sctp_chunk *chunk) 637 { 638 size_t datasize, rwnd, inflight, flight_size; 639 struct sctp_transport *transport = packet->transport; 640 struct sctp_association *asoc = transport->asoc; 641 struct sctp_outq *q = &asoc->outqueue; 642 643 /* RFC 2960 6.1 Transmission of DATA Chunks 644 * 645 * A) At any given time, the data sender MUST NOT transmit new data to 646 * any destination transport address if its peer's rwnd indicates 647 * that the peer has no buffer space (i.e. rwnd is 0, see Section 648 * 6.2.1). However, regardless of the value of rwnd (including if it 649 * is 0), the data sender can always have one DATA chunk in flight to 650 * the receiver if allowed by cwnd (see rule B below). This rule 651 * allows the sender to probe for a change in rwnd that the sender 652 * missed due to the SACK having been lost in transit from the data 653 * receiver to the data sender. 654 */ 655 656 rwnd = asoc->peer.rwnd; 657 inflight = q->outstanding_bytes; 658 flight_size = transport->flight_size; 659 660 datasize = sctp_data_size(chunk); 661 662 if (datasize > rwnd && inflight > 0) 663 /* We have (at least) one data chunk in flight, 664 * so we can't fall back to rule 6.1 B). 665 */ 666 return SCTP_XMIT_RWND_FULL; 667 668 /* RFC 2960 6.1 Transmission of DATA Chunks 669 * 670 * B) At any given time, the sender MUST NOT transmit new data 671 * to a given transport address if it has cwnd or more bytes 672 * of data outstanding to that transport address. 673 */ 674 /* RFC 7.2.4 & the Implementers Guide 2.8. 675 * 676 * 3) ... 677 * When a Fast Retransmit is being performed the sender SHOULD 678 * ignore the value of cwnd and SHOULD NOT delay retransmission. 679 */ 680 if (chunk->fast_retransmit != SCTP_NEED_FRTX && 681 flight_size >= transport->cwnd) 682 return SCTP_XMIT_RWND_FULL; 683 684 /* Nagle's algorithm to solve small-packet problem: 685 * Inhibit the sending of new chunks when new outgoing data arrives 686 * if any previously transmitted data on the connection remains 687 * unacknowledged. 688 */ 689 690 if (sctp_sk(asoc->base.sk)->nodelay) 691 /* Nagle disabled */ 692 return SCTP_XMIT_OK; 693 694 if (!sctp_packet_empty(packet)) 695 /* Append to packet */ 696 return SCTP_XMIT_OK; 697 698 if (inflight == 0) 699 /* Nothing unacked */ 700 return SCTP_XMIT_OK; 701 702 if (!sctp_state(asoc, ESTABLISHED)) 703 return SCTP_XMIT_OK; 704 705 /* Check whether this chunk and all the rest of pending data will fit 706 * or delay in hopes of bundling a full sized packet. 707 */ 708 if (chunk->skb->len + q->out_qlen >= transport->pathmtu - packet->overhead) 709 /* Enough data queued to fill a packet */ 710 return SCTP_XMIT_OK; 711 712 /* Don't delay large message writes that may have been fragmented */ 713 if (!chunk->msg->can_delay) 714 return SCTP_XMIT_OK; 715 716 /* Defer until all data acked or packet full */ 717 return SCTP_XMIT_DELAY; 718 } 719 720 /* This private function does management things when adding DATA chunk */ 721 static void sctp_packet_append_data(struct sctp_packet *packet, 722 struct sctp_chunk *chunk) 723 { 724 struct sctp_transport *transport = packet->transport; 725 size_t datasize = sctp_data_size(chunk); 726 struct sctp_association *asoc = transport->asoc; 727 u32 rwnd = asoc->peer.rwnd; 728 729 /* Keep track of how many bytes are in flight over this transport. */ 730 transport->flight_size += datasize; 731 732 /* Keep track of how many bytes are in flight to the receiver. */ 733 asoc->outqueue.outstanding_bytes += datasize; 734 735 /* Update our view of the receiver's rwnd. */ 736 if (datasize < rwnd) 737 rwnd -= datasize; 738 else 739 rwnd = 0; 740 741 asoc->peer.rwnd = rwnd; 742 /* Has been accepted for transmission. */ 743 if (!asoc->peer.prsctp_capable) 744 chunk->msg->can_abandon = 0; 745 sctp_chunk_assign_tsn(chunk); 746 sctp_chunk_assign_ssn(chunk); 747 } 748 749 static sctp_xmit_t sctp_packet_will_fit(struct sctp_packet *packet, 750 struct sctp_chunk *chunk, 751 u16 chunk_len) 752 { 753 size_t psize; 754 size_t pmtu; 755 int too_big; 756 sctp_xmit_t retval = SCTP_XMIT_OK; 757 758 psize = packet->size; 759 pmtu = ((packet->transport->asoc) ? 760 (packet->transport->asoc->pathmtu) : 761 (packet->transport->pathmtu)); 762 763 too_big = (psize + chunk_len > pmtu); 764 765 /* Decide if we need to fragment or resubmit later. */ 766 if (too_big) { 767 /* It's OK to fragmet at IP level if any one of the following 768 * is true: 769 * 1. The packet is empty (meaning this chunk is greater 770 * the MTU) 771 * 2. The chunk we are adding is a control chunk 772 * 3. The packet doesn't have any data in it yet and data 773 * requires authentication. 774 */ 775 if (sctp_packet_empty(packet) || !sctp_chunk_is_data(chunk) || 776 (!packet->has_data && chunk->auth)) { 777 /* We no longer do re-fragmentation. 778 * Just fragment at the IP layer, if we 779 * actually hit this condition 780 */ 781 packet->ipfragok = 1; 782 } else { 783 retval = SCTP_XMIT_PMTU_FULL; 784 } 785 } 786 787 return retval; 788 } 789