Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/netinet/sctp_output.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 /*- 2 * Copyright (c) 2001-2008, by Cisco Systems, Inc. All rights reserved. 3 * Copyright (c) 2008-2012, by Randall Stewart. All rights reserved. 4 * Copyright (c) 2008-2012, by Michael Tuexen. All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions are met: 8 * 9 * a) Redistributions of source code must retain the above copyright notice, 10 * this list of conditions and the following disclaimer. 11 * 12 * b) Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in 14 * the documentation and/or other materials provided with the distribution. 15 * 16 * c) Neither the name of Cisco Systems, Inc. nor the names of its 17 * contributors may be used to endorse or promote products derived 18 * from this software without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 21 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 22 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 24 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 30 * THE POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 #include <sys/cdefs.h> 34 __FBSDID("$FreeBSD: releng/9.2/sys/netinet/sctp_output.c 254355 2013-08-15 05:14:20Z tuexen $"); 35 36 #include <netinet/sctp_os.h> 37 #include <sys/proc.h> 38 #include <netinet/sctp_var.h> 39 #include <netinet/sctp_sysctl.h> 40 #include <netinet/sctp_header.h> 41 #include <netinet/sctp_pcb.h> 42 #include <netinet/sctputil.h> 43 #include <netinet/sctp_output.h> 44 #include <netinet/sctp_uio.h> 45 #include <netinet/sctputil.h> 46 #include <netinet/sctp_auth.h> 47 #include <netinet/sctp_timer.h> 48 #include <netinet/sctp_asconf.h> 49 #include <netinet/sctp_indata.h> 50 #include <netinet/sctp_bsd_addr.h> 51 #include <netinet/sctp_input.h> 52 #include <netinet/sctp_crc32.h> 53 #include <netinet/udp.h> 54 #include <netinet/udp_var.h> 55 #include <machine/in_cksum.h> 56 57 58 59 #define SCTP_MAX_GAPS_INARRAY 4 60 struct sack_track { 61 uint8_t right_edge; /* mergable on the right edge */ 62 uint8_t left_edge; /* mergable on the left edge */ 63 uint8_t num_entries; 64 uint8_t spare; 65 struct sctp_gap_ack_block gaps[SCTP_MAX_GAPS_INARRAY]; 66 }; 67 68 struct sack_track sack_array[256] = { 69 {0, 0, 0, 0, /* 0x00 */ 70 {{0, 0}, 71 {0, 0}, 72 {0, 0}, 73 {0, 0} 74 } 75 }, 76 {1, 0, 1, 0, /* 0x01 */ 77 {{0, 0}, 78 {0, 0}, 79 {0, 0}, 80 {0, 0} 81 } 82 }, 83 {0, 0, 1, 0, /* 0x02 */ 84 {{1, 1}, 85 {0, 0}, 86 {0, 0}, 87 {0, 0} 88 } 89 }, 90 {1, 0, 1, 0, /* 0x03 */ 91 {{0, 1}, 92 {0, 0}, 93 {0, 0}, 94 {0, 0} 95 } 96 }, 97 {0, 0, 1, 0, /* 0x04 */ 98 {{2, 2}, 99 {0, 0}, 100 {0, 0}, 101 {0, 0} 102 } 103 }, 104 {1, 0, 2, 0, /* 0x05 */ 105 {{0, 0}, 106 {2, 2}, 107 {0, 0}, 108 {0, 0} 109 } 110 }, 111 {0, 0, 1, 0, /* 0x06 */ 112 {{1, 2}, 113 {0, 0}, 114 {0, 0}, 115 {0, 0} 116 } 117 }, 118 {1, 0, 1, 0, /* 0x07 */ 119 {{0, 2}, 120 {0, 0}, 121 {0, 0}, 122 {0, 0} 123 } 124 }, 125 {0, 0, 1, 0, /* 0x08 */ 126 {{3, 3}, 127 {0, 0}, 128 {0, 0}, 129 {0, 0} 130 } 131 }, 132 {1, 0, 2, 0, /* 0x09 */ 133 {{0, 0}, 134 {3, 3}, 135 {0, 0}, 136 {0, 0} 137 } 138 }, 139 {0, 0, 2, 0, /* 0x0a */ 140 {{1, 1}, 141 {3, 3}, 142 {0, 0}, 143 {0, 0} 144 } 145 }, 146 {1, 0, 2, 0, /* 0x0b */ 147 {{0, 1}, 148 {3, 3}, 149 {0, 0}, 150 {0, 0} 151 } 152 }, 153 {0, 0, 1, 0, /* 0x0c */ 154 {{2, 3}, 155 {0, 0}, 156 {0, 0}, 157 {0, 0} 158 } 159 }, 160 {1, 0, 2, 0, /* 0x0d */ 161 {{0, 0}, 162 {2, 3}, 163 {0, 0}, 164 {0, 0} 165 } 166 }, 167 {0, 0, 1, 0, /* 0x0e */ 168 {{1, 3}, 169 {0, 0}, 170 {0, 0}, 171 {0, 0} 172 } 173 }, 174 {1, 0, 1, 0, /* 0x0f */ 175 {{0, 3}, 176 {0, 0}, 177 {0, 0}, 178 {0, 0} 179 } 180 }, 181 {0, 0, 1, 0, /* 0x10 */ 182 {{4, 4}, 183 {0, 0}, 184 {0, 0}, 185 {0, 0} 186 } 187 }, 188 {1, 0, 2, 0, /* 0x11 */ 189 {{0, 0}, 190 {4, 4}, 191 {0, 0}, 192 {0, 0} 193 } 194 }, 195 {0, 0, 2, 0, /* 0x12 */ 196 {{1, 1}, 197 {4, 4}, 198 {0, 0}, 199 {0, 0} 200 } 201 }, 202 {1, 0, 2, 0, /* 0x13 */ 203 {{0, 1}, 204 {4, 4}, 205 {0, 0}, 206 {0, 0} 207 } 208 }, 209 {0, 0, 2, 0, /* 0x14 */ 210 {{2, 2}, 211 {4, 4}, 212 {0, 0}, 213 {0, 0} 214 } 215 }, 216 {1, 0, 3, 0, /* 0x15 */ 217 {{0, 0}, 218 {2, 2}, 219 {4, 4}, 220 {0, 0} 221 } 222 }, 223 {0, 0, 2, 0, /* 0x16 */ 224 {{1, 2}, 225 {4, 4}, 226 {0, 0}, 227 {0, 0} 228 } 229 }, 230 {1, 0, 2, 0, /* 0x17 */ 231 {{0, 2}, 232 {4, 4}, 233 {0, 0}, 234 {0, 0} 235 } 236 }, 237 {0, 0, 1, 0, /* 0x18 */ 238 {{3, 4}, 239 {0, 0}, 240 {0, 0}, 241 {0, 0} 242 } 243 }, 244 {1, 0, 2, 0, /* 0x19 */ 245 {{0, 0}, 246 {3, 4}, 247 {0, 0}, 248 {0, 0} 249 } 250 }, 251 {0, 0, 2, 0, /* 0x1a */ 252 {{1, 1}, 253 {3, 4}, 254 {0, 0}, 255 {0, 0} 256 } 257 }, 258 {1, 0, 2, 0, /* 0x1b */ 259 {{0, 1}, 260 {3, 4}, 261 {0, 0}, 262 {0, 0} 263 } 264 }, 265 {0, 0, 1, 0, /* 0x1c */ 266 {{2, 4}, 267 {0, 0}, 268 {0, 0}, 269 {0, 0} 270 } 271 }, 272 {1, 0, 2, 0, /* 0x1d */ 273 {{0, 0}, 274 {2, 4}, 275 {0, 0}, 276 {0, 0} 277 } 278 }, 279 {0, 0, 1, 0, /* 0x1e */ 280 {{1, 4}, 281 {0, 0}, 282 {0, 0}, 283 {0, 0} 284 } 285 }, 286 {1, 0, 1, 0, /* 0x1f */ 287 {{0, 4}, 288 {0, 0}, 289 {0, 0}, 290 {0, 0} 291 } 292 }, 293 {0, 0, 1, 0, /* 0x20 */ 294 {{5, 5}, 295 {0, 0}, 296 {0, 0}, 297 {0, 0} 298 } 299 }, 300 {1, 0, 2, 0, /* 0x21 */ 301 {{0, 0}, 302 {5, 5}, 303 {0, 0}, 304 {0, 0} 305 } 306 }, 307 {0, 0, 2, 0, /* 0x22 */ 308 {{1, 1}, 309 {5, 5}, 310 {0, 0}, 311 {0, 0} 312 } 313 }, 314 {1, 0, 2, 0, /* 0x23 */ 315 {{0, 1}, 316 {5, 5}, 317 {0, 0}, 318 {0, 0} 319 } 320 }, 321 {0, 0, 2, 0, /* 0x24 */ 322 {{2, 2}, 323 {5, 5}, 324 {0, 0}, 325 {0, 0} 326 } 327 }, 328 {1, 0, 3, 0, /* 0x25 */ 329 {{0, 0}, 330 {2, 2}, 331 {5, 5}, 332 {0, 0} 333 } 334 }, 335 {0, 0, 2, 0, /* 0x26 */ 336 {{1, 2}, 337 {5, 5}, 338 {0, 0}, 339 {0, 0} 340 } 341 }, 342 {1, 0, 2, 0, /* 0x27 */ 343 {{0, 2}, 344 {5, 5}, 345 {0, 0}, 346 {0, 0} 347 } 348 }, 349 {0, 0, 2, 0, /* 0x28 */ 350 {{3, 3}, 351 {5, 5}, 352 {0, 0}, 353 {0, 0} 354 } 355 }, 356 {1, 0, 3, 0, /* 0x29 */ 357 {{0, 0}, 358 {3, 3}, 359 {5, 5}, 360 {0, 0} 361 } 362 }, 363 {0, 0, 3, 0, /* 0x2a */ 364 {{1, 1}, 365 {3, 3}, 366 {5, 5}, 367 {0, 0} 368 } 369 }, 370 {1, 0, 3, 0, /* 0x2b */ 371 {{0, 1}, 372 {3, 3}, 373 {5, 5}, 374 {0, 0} 375 } 376 }, 377 {0, 0, 2, 0, /* 0x2c */ 378 {{2, 3}, 379 {5, 5}, 380 {0, 0}, 381 {0, 0} 382 } 383 }, 384 {1, 0, 3, 0, /* 0x2d */ 385 {{0, 0}, 386 {2, 3}, 387 {5, 5}, 388 {0, 0} 389 } 390 }, 391 {0, 0, 2, 0, /* 0x2e */ 392 {{1, 3}, 393 {5, 5}, 394 {0, 0}, 395 {0, 0} 396 } 397 }, 398 {1, 0, 2, 0, /* 0x2f */ 399 {{0, 3}, 400 {5, 5}, 401 {0, 0}, 402 {0, 0} 403 } 404 }, 405 {0, 0, 1, 0, /* 0x30 */ 406 {{4, 5}, 407 {0, 0}, 408 {0, 0}, 409 {0, 0} 410 } 411 }, 412 {1, 0, 2, 0, /* 0x31 */ 413 {{0, 0}, 414 {4, 5}, 415 {0, 0}, 416 {0, 0} 417 } 418 }, 419 {0, 0, 2, 0, /* 0x32 */ 420 {{1, 1}, 421 {4, 5}, 422 {0, 0}, 423 {0, 0} 424 } 425 }, 426 {1, 0, 2, 0, /* 0x33 */ 427 {{0, 1}, 428 {4, 5}, 429 {0, 0}, 430 {0, 0} 431 } 432 }, 433 {0, 0, 2, 0, /* 0x34 */ 434 {{2, 2}, 435 {4, 5}, 436 {0, 0}, 437 {0, 0} 438 } 439 }, 440 {1, 0, 3, 0, /* 0x35 */ 441 {{0, 0}, 442 {2, 2}, 443 {4, 5}, 444 {0, 0} 445 } 446 }, 447 {0, 0, 2, 0, /* 0x36 */ 448 {{1, 2}, 449 {4, 5}, 450 {0, 0}, 451 {0, 0} 452 } 453 }, 454 {1, 0, 2, 0, /* 0x37 */ 455 {{0, 2}, 456 {4, 5}, 457 {0, 0}, 458 {0, 0} 459 } 460 }, 461 {0, 0, 1, 0, /* 0x38 */ 462 {{3, 5}, 463 {0, 0}, 464 {0, 0}, 465 {0, 0} 466 } 467 }, 468 {1, 0, 2, 0, /* 0x39 */ 469 {{0, 0}, 470 {3, 5}, 471 {0, 0}, 472 {0, 0} 473 } 474 }, 475 {0, 0, 2, 0, /* 0x3a */ 476 {{1, 1}, 477 {3, 5}, 478 {0, 0}, 479 {0, 0} 480 } 481 }, 482 {1, 0, 2, 0, /* 0x3b */ 483 {{0, 1}, 484 {3, 5}, 485 {0, 0}, 486 {0, 0} 487 } 488 }, 489 {0, 0, 1, 0, /* 0x3c */ 490 {{2, 5}, 491 {0, 0}, 492 {0, 0}, 493 {0, 0} 494 } 495 }, 496 {1, 0, 2, 0, /* 0x3d */ 497 {{0, 0}, 498 {2, 5}, 499 {0, 0}, 500 {0, 0} 501 } 502 }, 503 {0, 0, 1, 0, /* 0x3e */ 504 {{1, 5}, 505 {0, 0}, 506 {0, 0}, 507 {0, 0} 508 } 509 }, 510 {1, 0, 1, 0, /* 0x3f */ 511 {{0, 5}, 512 {0, 0}, 513 {0, 0}, 514 {0, 0} 515 } 516 }, 517 {0, 0, 1, 0, /* 0x40 */ 518 {{6, 6}, 519 {0, 0}, 520 {0, 0}, 521 {0, 0} 522 } 523 }, 524 {1, 0, 2, 0, /* 0x41 */ 525 {{0, 0}, 526 {6, 6}, 527 {0, 0}, 528 {0, 0} 529 } 530 }, 531 {0, 0, 2, 0, /* 0x42 */ 532 {{1, 1}, 533 {6, 6}, 534 {0, 0}, 535 {0, 0} 536 } 537 }, 538 {1, 0, 2, 0, /* 0x43 */ 539 {{0, 1}, 540 {6, 6}, 541 {0, 0}, 542 {0, 0} 543 } 544 }, 545 {0, 0, 2, 0, /* 0x44 */ 546 {{2, 2}, 547 {6, 6}, 548 {0, 0}, 549 {0, 0} 550 } 551 }, 552 {1, 0, 3, 0, /* 0x45 */ 553 {{0, 0}, 554 {2, 2}, 555 {6, 6}, 556 {0, 0} 557 } 558 }, 559 {0, 0, 2, 0, /* 0x46 */ 560 {{1, 2}, 561 {6, 6}, 562 {0, 0}, 563 {0, 0} 564 } 565 }, 566 {1, 0, 2, 0, /* 0x47 */ 567 {{0, 2}, 568 {6, 6}, 569 {0, 0}, 570 {0, 0} 571 } 572 }, 573 {0, 0, 2, 0, /* 0x48 */ 574 {{3, 3}, 575 {6, 6}, 576 {0, 0}, 577 {0, 0} 578 } 579 }, 580 {1, 0, 3, 0, /* 0x49 */ 581 {{0, 0}, 582 {3, 3}, 583 {6, 6}, 584 {0, 0} 585 } 586 }, 587 {0, 0, 3, 0, /* 0x4a */ 588 {{1, 1}, 589 {3, 3}, 590 {6, 6}, 591 {0, 0} 592 } 593 }, 594 {1, 0, 3, 0, /* 0x4b */ 595 {{0, 1}, 596 {3, 3}, 597 {6, 6}, 598 {0, 0} 599 } 600 }, 601 {0, 0, 2, 0, /* 0x4c */ 602 {{2, 3}, 603 {6, 6}, 604 {0, 0}, 605 {0, 0} 606 } 607 }, 608 {1, 0, 3, 0, /* 0x4d */ 609 {{0, 0}, 610 {2, 3}, 611 {6, 6}, 612 {0, 0} 613 } 614 }, 615 {0, 0, 2, 0, /* 0x4e */ 616 {{1, 3}, 617 {6, 6}, 618 {0, 0}, 619 {0, 0} 620 } 621 }, 622 {1, 0, 2, 0, /* 0x4f */ 623 {{0, 3}, 624 {6, 6}, 625 {0, 0}, 626 {0, 0} 627 } 628 }, 629 {0, 0, 2, 0, /* 0x50 */ 630 {{4, 4}, 631 {6, 6}, 632 {0, 0}, 633 {0, 0} 634 } 635 }, 636 {1, 0, 3, 0, /* 0x51 */ 637 {{0, 0}, 638 {4, 4}, 639 {6, 6}, 640 {0, 0} 641 } 642 }, 643 {0, 0, 3, 0, /* 0x52 */ 644 {{1, 1}, 645 {4, 4}, 646 {6, 6}, 647 {0, 0} 648 } 649 }, 650 {1, 0, 3, 0, /* 0x53 */ 651 {{0, 1}, 652 {4, 4}, 653 {6, 6}, 654 {0, 0} 655 } 656 }, 657 {0, 0, 3, 0, /* 0x54 */ 658 {{2, 2}, 659 {4, 4}, 660 {6, 6}, 661 {0, 0} 662 } 663 }, 664 {1, 0, 4, 0, /* 0x55 */ 665 {{0, 0}, 666 {2, 2}, 667 {4, 4}, 668 {6, 6} 669 } 670 }, 671 {0, 0, 3, 0, /* 0x56 */ 672 {{1, 2}, 673 {4, 4}, 674 {6, 6}, 675 {0, 0} 676 } 677 }, 678 {1, 0, 3, 0, /* 0x57 */ 679 {{0, 2}, 680 {4, 4}, 681 {6, 6}, 682 {0, 0} 683 } 684 }, 685 {0, 0, 2, 0, /* 0x58 */ 686 {{3, 4}, 687 {6, 6}, 688 {0, 0}, 689 {0, 0} 690 } 691 }, 692 {1, 0, 3, 0, /* 0x59 */ 693 {{0, 0}, 694 {3, 4}, 695 {6, 6}, 696 {0, 0} 697 } 698 }, 699 {0, 0, 3, 0, /* 0x5a */ 700 {{1, 1}, 701 {3, 4}, 702 {6, 6}, 703 {0, 0} 704 } 705 }, 706 {1, 0, 3, 0, /* 0x5b */ 707 {{0, 1}, 708 {3, 4}, 709 {6, 6}, 710 {0, 0} 711 } 712 }, 713 {0, 0, 2, 0, /* 0x5c */ 714 {{2, 4}, 715 {6, 6}, 716 {0, 0}, 717 {0, 0} 718 } 719 }, 720 {1, 0, 3, 0, /* 0x5d */ 721 {{0, 0}, 722 {2, 4}, 723 {6, 6}, 724 {0, 0} 725 } 726 }, 727 {0, 0, 2, 0, /* 0x5e */ 728 {{1, 4}, 729 {6, 6}, 730 {0, 0}, 731 {0, 0} 732 } 733 }, 734 {1, 0, 2, 0, /* 0x5f */ 735 {{0, 4}, 736 {6, 6}, 737 {0, 0}, 738 {0, 0} 739 } 740 }, 741 {0, 0, 1, 0, /* 0x60 */ 742 {{5, 6}, 743 {0, 0}, 744 {0, 0}, 745 {0, 0} 746 } 747 }, 748 {1, 0, 2, 0, /* 0x61 */ 749 {{0, 0}, 750 {5, 6}, 751 {0, 0}, 752 {0, 0} 753 } 754 }, 755 {0, 0, 2, 0, /* 0x62 */ 756 {{1, 1}, 757 {5, 6}, 758 {0, 0}, 759 {0, 0} 760 } 761 }, 762 {1, 0, 2, 0, /* 0x63 */ 763 {{0, 1}, 764 {5, 6}, 765 {0, 0}, 766 {0, 0} 767 } 768 }, 769 {0, 0, 2, 0, /* 0x64 */ 770 {{2, 2}, 771 {5, 6}, 772 {0, 0}, 773 {0, 0} 774 } 775 }, 776 {1, 0, 3, 0, /* 0x65 */ 777 {{0, 0}, 778 {2, 2}, 779 {5, 6}, 780 {0, 0} 781 } 782 }, 783 {0, 0, 2, 0, /* 0x66 */ 784 {{1, 2}, 785 {5, 6}, 786 {0, 0}, 787 {0, 0} 788 } 789 }, 790 {1, 0, 2, 0, /* 0x67 */ 791 {{0, 2}, 792 {5, 6}, 793 {0, 0}, 794 {0, 0} 795 } 796 }, 797 {0, 0, 2, 0, /* 0x68 */ 798 {{3, 3}, 799 {5, 6}, 800 {0, 0}, 801 {0, 0} 802 } 803 }, 804 {1, 0, 3, 0, /* 0x69 */ 805 {{0, 0}, 806 {3, 3}, 807 {5, 6}, 808 {0, 0} 809 } 810 }, 811 {0, 0, 3, 0, /* 0x6a */ 812 {{1, 1}, 813 {3, 3}, 814 {5, 6}, 815 {0, 0} 816 } 817 }, 818 {1, 0, 3, 0, /* 0x6b */ 819 {{0, 1}, 820 {3, 3}, 821 {5, 6}, 822 {0, 0} 823 } 824 }, 825 {0, 0, 2, 0, /* 0x6c */ 826 {{2, 3}, 827 {5, 6}, 828 {0, 0}, 829 {0, 0} 830 } 831 }, 832 {1, 0, 3, 0, /* 0x6d */ 833 {{0, 0}, 834 {2, 3}, 835 {5, 6}, 836 {0, 0} 837 } 838 }, 839 {0, 0, 2, 0, /* 0x6e */ 840 {{1, 3}, 841 {5, 6}, 842 {0, 0}, 843 {0, 0} 844 } 845 }, 846 {1, 0, 2, 0, /* 0x6f */ 847 {{0, 3}, 848 {5, 6}, 849 {0, 0}, 850 {0, 0} 851 } 852 }, 853 {0, 0, 1, 0, /* 0x70 */ 854 {{4, 6}, 855 {0, 0}, 856 {0, 0}, 857 {0, 0} 858 } 859 }, 860 {1, 0, 2, 0, /* 0x71 */ 861 {{0, 0}, 862 {4, 6}, 863 {0, 0}, 864 {0, 0} 865 } 866 }, 867 {0, 0, 2, 0, /* 0x72 */ 868 {{1, 1}, 869 {4, 6}, 870 {0, 0}, 871 {0, 0} 872 } 873 }, 874 {1, 0, 2, 0, /* 0x73 */ 875 {{0, 1}, 876 {4, 6}, 877 {0, 0}, 878 {0, 0} 879 } 880 }, 881 {0, 0, 2, 0, /* 0x74 */ 882 {{2, 2}, 883 {4, 6}, 884 {0, 0}, 885 {0, 0} 886 } 887 }, 888 {1, 0, 3, 0, /* 0x75 */ 889 {{0, 0}, 890 {2, 2}, 891 {4, 6}, 892 {0, 0} 893 } 894 }, 895 {0, 0, 2, 0, /* 0x76 */ 896 {{1, 2}, 897 {4, 6}, 898 {0, 0}, 899 {0, 0} 900 } 901 }, 902 {1, 0, 2, 0, /* 0x77 */ 903 {{0, 2}, 904 {4, 6}, 905 {0, 0}, 906 {0, 0} 907 } 908 }, 909 {0, 0, 1, 0, /* 0x78 */ 910 {{3, 6}, 911 {0, 0}, 912 {0, 0}, 913 {0, 0} 914 } 915 }, 916 {1, 0, 2, 0, /* 0x79 */ 917 {{0, 0}, 918 {3, 6}, 919 {0, 0}, 920 {0, 0} 921 } 922 }, 923 {0, 0, 2, 0, /* 0x7a */ 924 {{1, 1}, 925 {3, 6}, 926 {0, 0}, 927 {0, 0} 928 } 929 }, 930 {1, 0, 2, 0, /* 0x7b */ 931 {{0, 1}, 932 {3, 6}, 933 {0, 0}, 934 {0, 0} 935 } 936 }, 937 {0, 0, 1, 0, /* 0x7c */ 938 {{2, 6}, 939 {0, 0}, 940 {0, 0}, 941 {0, 0} 942 } 943 }, 944 {1, 0, 2, 0, /* 0x7d */ 945 {{0, 0}, 946 {2, 6}, 947 {0, 0}, 948 {0, 0} 949 } 950 }, 951 {0, 0, 1, 0, /* 0x7e */ 952 {{1, 6}, 953 {0, 0}, 954 {0, 0}, 955 {0, 0} 956 } 957 }, 958 {1, 0, 1, 0, /* 0x7f */ 959 {{0, 6}, 960 {0, 0}, 961 {0, 0}, 962 {0, 0} 963 } 964 }, 965 {0, 1, 1, 0, /* 0x80 */ 966 {{7, 7}, 967 {0, 0}, 968 {0, 0}, 969 {0, 0} 970 } 971 }, 972 {1, 1, 2, 0, /* 0x81 */ 973 {{0, 0}, 974 {7, 7}, 975 {0, 0}, 976 {0, 0} 977 } 978 }, 979 {0, 1, 2, 0, /* 0x82 */ 980 {{1, 1}, 981 {7, 7}, 982 {0, 0}, 983 {0, 0} 984 } 985 }, 986 {1, 1, 2, 0, /* 0x83 */ 987 {{0, 1}, 988 {7, 7}, 989 {0, 0}, 990 {0, 0} 991 } 992 }, 993 {0, 1, 2, 0, /* 0x84 */ 994 {{2, 2}, 995 {7, 7}, 996 {0, 0}, 997 {0, 0} 998 } 999 }, 1000 {1, 1, 3, 0, /* 0x85 */ 1001 {{0, 0}, 1002 {2, 2}, 1003 {7, 7}, 1004 {0, 0} 1005 } 1006 }, 1007 {0, 1, 2, 0, /* 0x86 */ 1008 {{1, 2}, 1009 {7, 7}, 1010 {0, 0}, 1011 {0, 0} 1012 } 1013 }, 1014 {1, 1, 2, 0, /* 0x87 */ 1015 {{0, 2}, 1016 {7, 7}, 1017 {0, 0}, 1018 {0, 0} 1019 } 1020 }, 1021 {0, 1, 2, 0, /* 0x88 */ 1022 {{3, 3}, 1023 {7, 7}, 1024 {0, 0}, 1025 {0, 0} 1026 } 1027 }, 1028 {1, 1, 3, 0, /* 0x89 */ 1029 {{0, 0}, 1030 {3, 3}, 1031 {7, 7}, 1032 {0, 0} 1033 } 1034 }, 1035 {0, 1, 3, 0, /* 0x8a */ 1036 {{1, 1}, 1037 {3, 3}, 1038 {7, 7}, 1039 {0, 0} 1040 } 1041 }, 1042 {1, 1, 3, 0, /* 0x8b */ 1043 {{0, 1}, 1044 {3, 3}, 1045 {7, 7}, 1046 {0, 0} 1047 } 1048 }, 1049 {0, 1, 2, 0, /* 0x8c */ 1050 {{2, 3}, 1051 {7, 7}, 1052 {0, 0}, 1053 {0, 0} 1054 } 1055 }, 1056 {1, 1, 3, 0, /* 0x8d */ 1057 {{0, 0}, 1058 {2, 3}, 1059 {7, 7}, 1060 {0, 0} 1061 } 1062 }, 1063 {0, 1, 2, 0, /* 0x8e */ 1064 {{1, 3}, 1065 {7, 7}, 1066 {0, 0}, 1067 {0, 0} 1068 } 1069 }, 1070 {1, 1, 2, 0, /* 0x8f */ 1071 {{0, 3}, 1072 {7, 7}, 1073 {0, 0}, 1074 {0, 0} 1075 } 1076 }, 1077 {0, 1, 2, 0, /* 0x90 */ 1078 {{4, 4}, 1079 {7, 7}, 1080 {0, 0}, 1081 {0, 0} 1082 } 1083 }, 1084 {1, 1, 3, 0, /* 0x91 */ 1085 {{0, 0}, 1086 {4, 4}, 1087 {7, 7}, 1088 {0, 0} 1089 } 1090 }, 1091 {0, 1, 3, 0, /* 0x92 */ 1092 {{1, 1}, 1093 {4, 4}, 1094 {7, 7}, 1095 {0, 0} 1096 } 1097 }, 1098 {1, 1, 3, 0, /* 0x93 */ 1099 {{0, 1}, 1100 {4, 4}, 1101 {7, 7}, 1102 {0, 0} 1103 } 1104 }, 1105 {0, 1, 3, 0, /* 0x94 */ 1106 {{2, 2}, 1107 {4, 4}, 1108 {7, 7}, 1109 {0, 0} 1110 } 1111 }, 1112 {1, 1, 4, 0, /* 0x95 */ 1113 {{0, 0}, 1114 {2, 2}, 1115 {4, 4}, 1116 {7, 7} 1117 } 1118 }, 1119 {0, 1, 3, 0, /* 0x96 */ 1120 {{1, 2}, 1121 {4, 4}, 1122 {7, 7}, 1123 {0, 0} 1124 } 1125 }, 1126 {1, 1, 3, 0, /* 0x97 */ 1127 {{0, 2}, 1128 {4, 4}, 1129 {7, 7}, 1130 {0, 0} 1131 } 1132 }, 1133 {0, 1, 2, 0, /* 0x98 */ 1134 {{3, 4}, 1135 {7, 7}, 1136 {0, 0}, 1137 {0, 0} 1138 } 1139 }, 1140 {1, 1, 3, 0, /* 0x99 */ 1141 {{0, 0}, 1142 {3, 4}, 1143 {7, 7}, 1144 {0, 0} 1145 } 1146 }, 1147 {0, 1, 3, 0, /* 0x9a */ 1148 {{1, 1}, 1149 {3, 4}, 1150 {7, 7}, 1151 {0, 0} 1152 } 1153 }, 1154 {1, 1, 3, 0, /* 0x9b */ 1155 {{0, 1}, 1156 {3, 4}, 1157 {7, 7}, 1158 {0, 0} 1159 } 1160 }, 1161 {0, 1, 2, 0, /* 0x9c */ 1162 {{2, 4}, 1163 {7, 7}, 1164 {0, 0}, 1165 {0, 0} 1166 } 1167 }, 1168 {1, 1, 3, 0, /* 0x9d */ 1169 {{0, 0}, 1170 {2, 4}, 1171 {7, 7}, 1172 {0, 0} 1173 } 1174 }, 1175 {0, 1, 2, 0, /* 0x9e */ 1176 {{1, 4}, 1177 {7, 7}, 1178 {0, 0}, 1179 {0, 0} 1180 } 1181 }, 1182 {1, 1, 2, 0, /* 0x9f */ 1183 {{0, 4}, 1184 {7, 7}, 1185 {0, 0}, 1186 {0, 0} 1187 } 1188 }, 1189 {0, 1, 2, 0, /* 0xa0 */ 1190 {{5, 5}, 1191 {7, 7}, 1192 {0, 0}, 1193 {0, 0} 1194 } 1195 }, 1196 {1, 1, 3, 0, /* 0xa1 */ 1197 {{0, 0}, 1198 {5, 5}, 1199 {7, 7}, 1200 {0, 0} 1201 } 1202 }, 1203 {0, 1, 3, 0, /* 0xa2 */ 1204 {{1, 1}, 1205 {5, 5}, 1206 {7, 7}, 1207 {0, 0} 1208 } 1209 }, 1210 {1, 1, 3, 0, /* 0xa3 */ 1211 {{0, 1}, 1212 {5, 5}, 1213 {7, 7}, 1214 {0, 0} 1215 } 1216 }, 1217 {0, 1, 3, 0, /* 0xa4 */ 1218 {{2, 2}, 1219 {5, 5}, 1220 {7, 7}, 1221 {0, 0} 1222 } 1223 }, 1224 {1, 1, 4, 0, /* 0xa5 */ 1225 {{0, 0}, 1226 {2, 2}, 1227 {5, 5}, 1228 {7, 7} 1229 } 1230 }, 1231 {0, 1, 3, 0, /* 0xa6 */ 1232 {{1, 2}, 1233 {5, 5}, 1234 {7, 7}, 1235 {0, 0} 1236 } 1237 }, 1238 {1, 1, 3, 0, /* 0xa7 */ 1239 {{0, 2}, 1240 {5, 5}, 1241 {7, 7}, 1242 {0, 0} 1243 } 1244 }, 1245 {0, 1, 3, 0, /* 0xa8 */ 1246 {{3, 3}, 1247 {5, 5}, 1248 {7, 7}, 1249 {0, 0} 1250 } 1251 }, 1252 {1, 1, 4, 0, /* 0xa9 */ 1253 {{0, 0}, 1254 {3, 3}, 1255 {5, 5}, 1256 {7, 7} 1257 } 1258 }, 1259 {0, 1, 4, 0, /* 0xaa */ 1260 {{1, 1}, 1261 {3, 3}, 1262 {5, 5}, 1263 {7, 7} 1264 } 1265 }, 1266 {1, 1, 4, 0, /* 0xab */ 1267 {{0, 1}, 1268 {3, 3}, 1269 {5, 5}, 1270 {7, 7} 1271 } 1272 }, 1273 {0, 1, 3, 0, /* 0xac */ 1274 {{2, 3}, 1275 {5, 5}, 1276 {7, 7}, 1277 {0, 0} 1278 } 1279 }, 1280 {1, 1, 4, 0, /* 0xad */ 1281 {{0, 0}, 1282 {2, 3}, 1283 {5, 5}, 1284 {7, 7} 1285 } 1286 }, 1287 {0, 1, 3, 0, /* 0xae */ 1288 {{1, 3}, 1289 {5, 5}, 1290 {7, 7}, 1291 {0, 0} 1292 } 1293 }, 1294 {1, 1, 3, 0, /* 0xaf */ 1295 {{0, 3}, 1296 {5, 5}, 1297 {7, 7}, 1298 {0, 0} 1299 } 1300 }, 1301 {0, 1, 2, 0, /* 0xb0 */ 1302 {{4, 5}, 1303 {7, 7}, 1304 {0, 0}, 1305 {0, 0} 1306 } 1307 }, 1308 {1, 1, 3, 0, /* 0xb1 */ 1309 {{0, 0}, 1310 {4, 5}, 1311 {7, 7}, 1312 {0, 0} 1313 } 1314 }, 1315 {0, 1, 3, 0, /* 0xb2 */ 1316 {{1, 1}, 1317 {4, 5}, 1318 {7, 7}, 1319 {0, 0} 1320 } 1321 }, 1322 {1, 1, 3, 0, /* 0xb3 */ 1323 {{0, 1}, 1324 {4, 5}, 1325 {7, 7}, 1326 {0, 0} 1327 } 1328 }, 1329 {0, 1, 3, 0, /* 0xb4 */ 1330 {{2, 2}, 1331 {4, 5}, 1332 {7, 7}, 1333 {0, 0} 1334 } 1335 }, 1336 {1, 1, 4, 0, /* 0xb5 */ 1337 {{0, 0}, 1338 {2, 2}, 1339 {4, 5}, 1340 {7, 7} 1341 } 1342 }, 1343 {0, 1, 3, 0, /* 0xb6 */ 1344 {{1, 2}, 1345 {4, 5}, 1346 {7, 7}, 1347 {0, 0} 1348 } 1349 }, 1350 {1, 1, 3, 0, /* 0xb7 */ 1351 {{0, 2}, 1352 {4, 5}, 1353 {7, 7}, 1354 {0, 0} 1355 } 1356 }, 1357 {0, 1, 2, 0, /* 0xb8 */ 1358 {{3, 5}, 1359 {7, 7}, 1360 {0, 0}, 1361 {0, 0} 1362 } 1363 }, 1364 {1, 1, 3, 0, /* 0xb9 */ 1365 {{0, 0}, 1366 {3, 5}, 1367 {7, 7}, 1368 {0, 0} 1369 } 1370 }, 1371 {0, 1, 3, 0, /* 0xba */ 1372 {{1, 1}, 1373 {3, 5}, 1374 {7, 7}, 1375 {0, 0} 1376 } 1377 }, 1378 {1, 1, 3, 0, /* 0xbb */ 1379 {{0, 1}, 1380 {3, 5}, 1381 {7, 7}, 1382 {0, 0} 1383 } 1384 }, 1385 {0, 1, 2, 0, /* 0xbc */ 1386 {{2, 5}, 1387 {7, 7}, 1388 {0, 0}, 1389 {0, 0} 1390 } 1391 }, 1392 {1, 1, 3, 0, /* 0xbd */ 1393 {{0, 0}, 1394 {2, 5}, 1395 {7, 7}, 1396 {0, 0} 1397 } 1398 }, 1399 {0, 1, 2, 0, /* 0xbe */ 1400 {{1, 5}, 1401 {7, 7}, 1402 {0, 0}, 1403 {0, 0} 1404 } 1405 }, 1406 {1, 1, 2, 0, /* 0xbf */ 1407 {{0, 5}, 1408 {7, 7}, 1409 {0, 0}, 1410 {0, 0} 1411 } 1412 }, 1413 {0, 1, 1, 0, /* 0xc0 */ 1414 {{6, 7}, 1415 {0, 0}, 1416 {0, 0}, 1417 {0, 0} 1418 } 1419 }, 1420 {1, 1, 2, 0, /* 0xc1 */ 1421 {{0, 0}, 1422 {6, 7}, 1423 {0, 0}, 1424 {0, 0} 1425 } 1426 }, 1427 {0, 1, 2, 0, /* 0xc2 */ 1428 {{1, 1}, 1429 {6, 7}, 1430 {0, 0}, 1431 {0, 0} 1432 } 1433 }, 1434 {1, 1, 2, 0, /* 0xc3 */ 1435 {{0, 1}, 1436 {6, 7}, 1437 {0, 0}, 1438 {0, 0} 1439 } 1440 }, 1441 {0, 1, 2, 0, /* 0xc4 */ 1442 {{2, 2}, 1443 {6, 7}, 1444 {0, 0}, 1445 {0, 0} 1446 } 1447 }, 1448 {1, 1, 3, 0, /* 0xc5 */ 1449 {{0, 0}, 1450 {2, 2}, 1451 {6, 7}, 1452 {0, 0} 1453 } 1454 }, 1455 {0, 1, 2, 0, /* 0xc6 */ 1456 {{1, 2}, 1457 {6, 7}, 1458 {0, 0}, 1459 {0, 0} 1460 } 1461 }, 1462 {1, 1, 2, 0, /* 0xc7 */ 1463 {{0, 2}, 1464 {6, 7}, 1465 {0, 0}, 1466 {0, 0} 1467 } 1468 }, 1469 {0, 1, 2, 0, /* 0xc8 */ 1470 {{3, 3}, 1471 {6, 7}, 1472 {0, 0}, 1473 {0, 0} 1474 } 1475 }, 1476 {1, 1, 3, 0, /* 0xc9 */ 1477 {{0, 0}, 1478 {3, 3}, 1479 {6, 7}, 1480 {0, 0} 1481 } 1482 }, 1483 {0, 1, 3, 0, /* 0xca */ 1484 {{1, 1}, 1485 {3, 3}, 1486 {6, 7}, 1487 {0, 0} 1488 } 1489 }, 1490 {1, 1, 3, 0, /* 0xcb */ 1491 {{0, 1}, 1492 {3, 3}, 1493 {6, 7}, 1494 {0, 0} 1495 } 1496 }, 1497 {0, 1, 2, 0, /* 0xcc */ 1498 {{2, 3}, 1499 {6, 7}, 1500 {0, 0}, 1501 {0, 0} 1502 } 1503 }, 1504 {1, 1, 3, 0, /* 0xcd */ 1505 {{0, 0}, 1506 {2, 3}, 1507 {6, 7}, 1508 {0, 0} 1509 } 1510 }, 1511 {0, 1, 2, 0, /* 0xce */ 1512 {{1, 3}, 1513 {6, 7}, 1514 {0, 0}, 1515 {0, 0} 1516 } 1517 }, 1518 {1, 1, 2, 0, /* 0xcf */ 1519 {{0, 3}, 1520 {6, 7}, 1521 {0, 0}, 1522 {0, 0} 1523 } 1524 }, 1525 {0, 1, 2, 0, /* 0xd0 */ 1526 {{4, 4}, 1527 {6, 7}, 1528 {0, 0}, 1529 {0, 0} 1530 } 1531 }, 1532 {1, 1, 3, 0, /* 0xd1 */ 1533 {{0, 0}, 1534 {4, 4}, 1535 {6, 7}, 1536 {0, 0} 1537 } 1538 }, 1539 {0, 1, 3, 0, /* 0xd2 */ 1540 {{1, 1}, 1541 {4, 4}, 1542 {6, 7}, 1543 {0, 0} 1544 } 1545 }, 1546 {1, 1, 3, 0, /* 0xd3 */ 1547 {{0, 1}, 1548 {4, 4}, 1549 {6, 7}, 1550 {0, 0} 1551 } 1552 }, 1553 {0, 1, 3, 0, /* 0xd4 */ 1554 {{2, 2}, 1555 {4, 4}, 1556 {6, 7}, 1557 {0, 0} 1558 } 1559 }, 1560 {1, 1, 4, 0, /* 0xd5 */ 1561 {{0, 0}, 1562 {2, 2}, 1563 {4, 4}, 1564 {6, 7} 1565 } 1566 }, 1567 {0, 1, 3, 0, /* 0xd6 */ 1568 {{1, 2}, 1569 {4, 4}, 1570 {6, 7}, 1571 {0, 0} 1572 } 1573 }, 1574 {1, 1, 3, 0, /* 0xd7 */ 1575 {{0, 2}, 1576 {4, 4}, 1577 {6, 7}, 1578 {0, 0} 1579 } 1580 }, 1581 {0, 1, 2, 0, /* 0xd8 */ 1582 {{3, 4}, 1583 {6, 7}, 1584 {0, 0}, 1585 {0, 0} 1586 } 1587 }, 1588 {1, 1, 3, 0, /* 0xd9 */ 1589 {{0, 0}, 1590 {3, 4}, 1591 {6, 7}, 1592 {0, 0} 1593 } 1594 }, 1595 {0, 1, 3, 0, /* 0xda */ 1596 {{1, 1}, 1597 {3, 4}, 1598 {6, 7}, 1599 {0, 0} 1600 } 1601 }, 1602 {1, 1, 3, 0, /* 0xdb */ 1603 {{0, 1}, 1604 {3, 4}, 1605 {6, 7}, 1606 {0, 0} 1607 } 1608 }, 1609 {0, 1, 2, 0, /* 0xdc */ 1610 {{2, 4}, 1611 {6, 7}, 1612 {0, 0}, 1613 {0, 0} 1614 } 1615 }, 1616 {1, 1, 3, 0, /* 0xdd */ 1617 {{0, 0}, 1618 {2, 4}, 1619 {6, 7}, 1620 {0, 0} 1621 } 1622 }, 1623 {0, 1, 2, 0, /* 0xde */ 1624 {{1, 4}, 1625 {6, 7}, 1626 {0, 0}, 1627 {0, 0} 1628 } 1629 }, 1630 {1, 1, 2, 0, /* 0xdf */ 1631 {{0, 4}, 1632 {6, 7}, 1633 {0, 0}, 1634 {0, 0} 1635 } 1636 }, 1637 {0, 1, 1, 0, /* 0xe0 */ 1638 {{5, 7}, 1639 {0, 0}, 1640 {0, 0}, 1641 {0, 0} 1642 } 1643 }, 1644 {1, 1, 2, 0, /* 0xe1 */ 1645 {{0, 0}, 1646 {5, 7}, 1647 {0, 0}, 1648 {0, 0} 1649 } 1650 }, 1651 {0, 1, 2, 0, /* 0xe2 */ 1652 {{1, 1}, 1653 {5, 7}, 1654 {0, 0}, 1655 {0, 0} 1656 } 1657 }, 1658 {1, 1, 2, 0, /* 0xe3 */ 1659 {{0, 1}, 1660 {5, 7}, 1661 {0, 0}, 1662 {0, 0} 1663 } 1664 }, 1665 {0, 1, 2, 0, /* 0xe4 */ 1666 {{2, 2}, 1667 {5, 7}, 1668 {0, 0}, 1669 {0, 0} 1670 } 1671 }, 1672 {1, 1, 3, 0, /* 0xe5 */ 1673 {{0, 0}, 1674 {2, 2}, 1675 {5, 7}, 1676 {0, 0} 1677 } 1678 }, 1679 {0, 1, 2, 0, /* 0xe6 */ 1680 {{1, 2}, 1681 {5, 7}, 1682 {0, 0}, 1683 {0, 0} 1684 } 1685 }, 1686 {1, 1, 2, 0, /* 0xe7 */ 1687 {{0, 2}, 1688 {5, 7}, 1689 {0, 0}, 1690 {0, 0} 1691 } 1692 }, 1693 {0, 1, 2, 0, /* 0xe8 */ 1694 {{3, 3}, 1695 {5, 7}, 1696 {0, 0}, 1697 {0, 0} 1698 } 1699 }, 1700 {1, 1, 3, 0, /* 0xe9 */ 1701 {{0, 0}, 1702 {3, 3}, 1703 {5, 7}, 1704 {0, 0} 1705 } 1706 }, 1707 {0, 1, 3, 0, /* 0xea */ 1708 {{1, 1}, 1709 {3, 3}, 1710 {5, 7}, 1711 {0, 0} 1712 } 1713 }, 1714 {1, 1, 3, 0, /* 0xeb */ 1715 {{0, 1}, 1716 {3, 3}, 1717 {5, 7}, 1718 {0, 0} 1719 } 1720 }, 1721 {0, 1, 2, 0, /* 0xec */ 1722 {{2, 3}, 1723 {5, 7}, 1724 {0, 0}, 1725 {0, 0} 1726 } 1727 }, 1728 {1, 1, 3, 0, /* 0xed */ 1729 {{0, 0}, 1730 {2, 3}, 1731 {5, 7}, 1732 {0, 0} 1733 } 1734 }, 1735 {0, 1, 2, 0, /* 0xee */ 1736 {{1, 3}, 1737 {5, 7}, 1738 {0, 0}, 1739 {0, 0} 1740 } 1741 }, 1742 {1, 1, 2, 0, /* 0xef */ 1743 {{0, 3}, 1744 {5, 7}, 1745 {0, 0}, 1746 {0, 0} 1747 } 1748 }, 1749 {0, 1, 1, 0, /* 0xf0 */ 1750 {{4, 7}, 1751 {0, 0}, 1752 {0, 0}, 1753 {0, 0} 1754 } 1755 }, 1756 {1, 1, 2, 0, /* 0xf1 */ 1757 {{0, 0}, 1758 {4, 7}, 1759 {0, 0}, 1760 {0, 0} 1761 } 1762 }, 1763 {0, 1, 2, 0, /* 0xf2 */ 1764 {{1, 1}, 1765 {4, 7}, 1766 {0, 0}, 1767 {0, 0} 1768 } 1769 }, 1770 {1, 1, 2, 0, /* 0xf3 */ 1771 {{0, 1}, 1772 {4, 7}, 1773 {0, 0}, 1774 {0, 0} 1775 } 1776 }, 1777 {0, 1, 2, 0, /* 0xf4 */ 1778 {{2, 2}, 1779 {4, 7}, 1780 {0, 0}, 1781 {0, 0} 1782 } 1783 }, 1784 {1, 1, 3, 0, /* 0xf5 */ 1785 {{0, 0}, 1786 {2, 2}, 1787 {4, 7}, 1788 {0, 0} 1789 } 1790 }, 1791 {0, 1, 2, 0, /* 0xf6 */ 1792 {{1, 2}, 1793 {4, 7}, 1794 {0, 0}, 1795 {0, 0} 1796 } 1797 }, 1798 {1, 1, 2, 0, /* 0xf7 */ 1799 {{0, 2}, 1800 {4, 7}, 1801 {0, 0}, 1802 {0, 0} 1803 } 1804 }, 1805 {0, 1, 1, 0, /* 0xf8 */ 1806 {{3, 7}, 1807 {0, 0}, 1808 {0, 0}, 1809 {0, 0} 1810 } 1811 }, 1812 {1, 1, 2, 0, /* 0xf9 */ 1813 {{0, 0}, 1814 {3, 7}, 1815 {0, 0}, 1816 {0, 0} 1817 } 1818 }, 1819 {0, 1, 2, 0, /* 0xfa */ 1820 {{1, 1}, 1821 {3, 7}, 1822 {0, 0}, 1823 {0, 0} 1824 } 1825 }, 1826 {1, 1, 2, 0, /* 0xfb */ 1827 {{0, 1}, 1828 {3, 7}, 1829 {0, 0}, 1830 {0, 0} 1831 } 1832 }, 1833 {0, 1, 1, 0, /* 0xfc */ 1834 {{2, 7}, 1835 {0, 0}, 1836 {0, 0}, 1837 {0, 0} 1838 } 1839 }, 1840 {1, 1, 2, 0, /* 0xfd */ 1841 {{0, 0}, 1842 {2, 7}, 1843 {0, 0}, 1844 {0, 0} 1845 } 1846 }, 1847 {0, 1, 1, 0, /* 0xfe */ 1848 {{1, 7}, 1849 {0, 0}, 1850 {0, 0}, 1851 {0, 0} 1852 } 1853 }, 1854 {1, 1, 1, 0, /* 0xff */ 1855 {{0, 7}, 1856 {0, 0}, 1857 {0, 0}, 1858 {0, 0} 1859 } 1860 } 1861 }; 1862 1863 1864 int 1865 sctp_is_address_in_scope(struct sctp_ifa *ifa, 1866 struct sctp_scoping *scope, 1867 int do_update) 1868 { 1869 if ((scope->loopback_scope == 0) && 1870 (ifa->ifn_p) && SCTP_IFN_IS_IFT_LOOP(ifa->ifn_p)) { 1871 /* 1872 * skip loopback if not in scope * 1873 */ 1874 return (0); 1875 } 1876 switch (ifa->address.sa.sa_family) { 1877 #ifdef INET 1878 case AF_INET: 1879 if (scope->ipv4_addr_legal) { 1880 struct sockaddr_in *sin; 1881 1882 sin = (struct sockaddr_in *)&ifa->address.sin; 1883 if (sin->sin_addr.s_addr == 0) { 1884 /* not in scope , unspecified */ 1885 return (0); 1886 } 1887 if ((scope->ipv4_local_scope == 0) && 1888 (IN4_ISPRIVATE_ADDRESS(&sin->sin_addr))) { 1889 /* private address not in scope */ 1890 return (0); 1891 } 1892 } else { 1893 return (0); 1894 } 1895 break; 1896 #endif 1897 #ifdef INET6 1898 case AF_INET6: 1899 if (scope->ipv6_addr_legal) { 1900 struct sockaddr_in6 *sin6; 1901 1902 /* 1903 * Must update the flags, bummer, which means any 1904 * IFA locks must now be applied HERE <-> 1905 */ 1906 if (do_update) { 1907 sctp_gather_internal_ifa_flags(ifa); 1908 } 1909 if (ifa->localifa_flags & SCTP_ADDR_IFA_UNUSEABLE) { 1910 return (0); 1911 } 1912 /* ok to use deprecated addresses? */ 1913 sin6 = (struct sockaddr_in6 *)&ifa->address.sin6; 1914 if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) { 1915 /* skip unspecifed addresses */ 1916 return (0); 1917 } 1918 if ( /* (local_scope == 0) && */ 1919 (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr))) { 1920 return (0); 1921 } 1922 if ((scope->site_scope == 0) && 1923 (IN6_IS_ADDR_SITELOCAL(&sin6->sin6_addr))) { 1924 return (0); 1925 } 1926 } else { 1927 return (0); 1928 } 1929 break; 1930 #endif 1931 default: 1932 return (0); 1933 } 1934 return (1); 1935 } 1936 1937 static struct mbuf * 1938 sctp_add_addr_to_mbuf(struct mbuf *m, struct sctp_ifa *ifa, uint16_t * len) 1939 { 1940 struct sctp_paramhdr *parmh; 1941 struct mbuf *mret; 1942 uint16_t plen; 1943 1944 switch (ifa->address.sa.sa_family) { 1945 #ifdef INET 1946 case AF_INET: 1947 plen = (uint16_t) sizeof(struct sctp_ipv4addr_param); 1948 break; 1949 #endif 1950 #ifdef INET6 1951 case AF_INET6: 1952 plen = (uint16_t) sizeof(struct sctp_ipv6addr_param); 1953 break; 1954 #endif 1955 default: 1956 return (m); 1957 } 1958 if (M_TRAILINGSPACE(m) >= plen) { 1959 /* easy side we just drop it on the end */ 1960 parmh = (struct sctp_paramhdr *)(SCTP_BUF_AT(m, SCTP_BUF_LEN(m))); 1961 mret = m; 1962 } else { 1963 /* Need more space */ 1964 mret = m; 1965 while (SCTP_BUF_NEXT(mret) != NULL) { 1966 mret = SCTP_BUF_NEXT(mret); 1967 } 1968 SCTP_BUF_NEXT(mret) = sctp_get_mbuf_for_msg(plen, 0, M_DONTWAIT, 1, MT_DATA); 1969 if (SCTP_BUF_NEXT(mret) == NULL) { 1970 /* We are hosed, can't add more addresses */ 1971 return (m); 1972 } 1973 mret = SCTP_BUF_NEXT(mret); 1974 parmh = mtod(mret, struct sctp_paramhdr *); 1975 } 1976 /* now add the parameter */ 1977 switch (ifa->address.sa.sa_family) { 1978 #ifdef INET 1979 case AF_INET: 1980 { 1981 struct sctp_ipv4addr_param *ipv4p; 1982 struct sockaddr_in *sin; 1983 1984 sin = (struct sockaddr_in *)&ifa->address.sin; 1985 ipv4p = (struct sctp_ipv4addr_param *)parmh; 1986 parmh->param_type = htons(SCTP_IPV4_ADDRESS); 1987 parmh->param_length = htons(plen); 1988 ipv4p->addr = sin->sin_addr.s_addr; 1989 SCTP_BUF_LEN(mret) += plen; 1990 break; 1991 } 1992 #endif 1993 #ifdef INET6 1994 case AF_INET6: 1995 { 1996 struct sctp_ipv6addr_param *ipv6p; 1997 struct sockaddr_in6 *sin6; 1998 1999 sin6 = (struct sockaddr_in6 *)&ifa->address.sin6; 2000 ipv6p = (struct sctp_ipv6addr_param *)parmh; 2001 parmh->param_type = htons(SCTP_IPV6_ADDRESS); 2002 parmh->param_length = htons(plen); 2003 memcpy(ipv6p->addr, &sin6->sin6_addr, 2004 sizeof(ipv6p->addr)); 2005 /* clear embedded scope in the address */ 2006 in6_clearscope((struct in6_addr *)ipv6p->addr); 2007 SCTP_BUF_LEN(mret) += plen; 2008 break; 2009 } 2010 #endif 2011 default: 2012 return (m); 2013 } 2014 if (len != NULL) { 2015 *len += plen; 2016 } 2017 return (mret); 2018 } 2019 2020 2021 struct mbuf * 2022 sctp_add_addresses_to_i_ia(struct sctp_inpcb *inp, struct sctp_tcb *stcb, 2023 struct sctp_scoping *scope, 2024 struct mbuf *m_at, int cnt_inits_to, 2025 uint16_t * padding_len, uint16_t * chunk_len) 2026 { 2027 struct sctp_vrf *vrf = NULL; 2028 int cnt, limit_out = 0, total_count; 2029 uint32_t vrf_id; 2030 2031 vrf_id = inp->def_vrf_id; 2032 SCTP_IPI_ADDR_RLOCK(); 2033 vrf = sctp_find_vrf(vrf_id); 2034 if (vrf == NULL) { 2035 SCTP_IPI_ADDR_RUNLOCK(); 2036 return (m_at); 2037 } 2038 if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) { 2039 struct sctp_ifa *sctp_ifap; 2040 struct sctp_ifn *sctp_ifnp; 2041 2042 cnt = cnt_inits_to; 2043 if (vrf->total_ifa_count > SCTP_COUNT_LIMIT) { 2044 limit_out = 1; 2045 cnt = SCTP_ADDRESS_LIMIT; 2046 goto skip_count; 2047 } 2048 LIST_FOREACH(sctp_ifnp, &vrf->ifnlist, next_ifn) { 2049 if ((scope->loopback_scope == 0) && 2050 SCTP_IFN_IS_IFT_LOOP(sctp_ifnp)) { 2051 /* 2052 * Skip loopback devices if loopback_scope 2053 * not set 2054 */ 2055 continue; 2056 } 2057 LIST_FOREACH(sctp_ifap, &sctp_ifnp->ifalist, next_ifa) { 2058 if (sctp_is_addr_restricted(stcb, sctp_ifap)) { 2059 continue; 2060 } 2061 if (sctp_is_address_in_scope(sctp_ifap, scope, 1) == 0) { 2062 continue; 2063 } 2064 cnt++; 2065 if (cnt > SCTP_ADDRESS_LIMIT) { 2066 break; 2067 } 2068 } 2069 if (cnt > SCTP_ADDRESS_LIMIT) { 2070 break; 2071 } 2072 } 2073 skip_count: 2074 if (cnt > 1) { 2075 total_count = 0; 2076 LIST_FOREACH(sctp_ifnp, &vrf->ifnlist, next_ifn) { 2077 cnt = 0; 2078 if ((scope->loopback_scope == 0) && 2079 SCTP_IFN_IS_IFT_LOOP(sctp_ifnp)) { 2080 /* 2081 * Skip loopback devices if 2082 * loopback_scope not set 2083 */ 2084 continue; 2085 } 2086 LIST_FOREACH(sctp_ifap, &sctp_ifnp->ifalist, next_ifa) { 2087 if (sctp_is_addr_restricted(stcb, sctp_ifap)) { 2088 continue; 2089 } 2090 if (sctp_is_address_in_scope(sctp_ifap, 2091 scope, 0) == 0) { 2092 continue; 2093 } 2094 if ((chunk_len != NULL) && 2095 (padding_len != NULL) && 2096 (*padding_len > 0)) { 2097 memset(mtod(m_at, caddr_t)+*chunk_len, 0, *padding_len); 2098 SCTP_BUF_LEN(m_at) += *padding_len; 2099 *chunk_len += *padding_len; 2100 *padding_len = 0; 2101 } 2102 m_at = sctp_add_addr_to_mbuf(m_at, sctp_ifap, chunk_len); 2103 if (limit_out) { 2104 cnt++; 2105 total_count++; 2106 if (cnt >= 2) { 2107 /* 2108 * two from each 2109 * address 2110 */ 2111 break; 2112 } 2113 if (total_count > SCTP_ADDRESS_LIMIT) { 2114 /* No more addresses */ 2115 break; 2116 } 2117 } 2118 } 2119 } 2120 } 2121 } else { 2122 struct sctp_laddr *laddr; 2123 2124 cnt = cnt_inits_to; 2125 /* First, how many ? */ 2126 LIST_FOREACH(laddr, &inp->sctp_addr_list, sctp_nxt_addr) { 2127 if (laddr->ifa == NULL) { 2128 continue; 2129 } 2130 if (laddr->ifa->localifa_flags & SCTP_BEING_DELETED) 2131 /* 2132 * Address being deleted by the system, dont 2133 * list. 2134 */ 2135 continue; 2136 if (laddr->action == SCTP_DEL_IP_ADDRESS) { 2137 /* 2138 * Address being deleted on this ep don't 2139 * list. 2140 */ 2141 continue; 2142 } 2143 if (sctp_is_address_in_scope(laddr->ifa, 2144 scope, 1) == 0) { 2145 continue; 2146 } 2147 cnt++; 2148 } 2149 /* 2150 * To get through a NAT we only list addresses if we have 2151 * more than one. That way if you just bind a single address 2152 * we let the source of the init dictate our address. 2153 */ 2154 if (cnt > 1) { 2155 cnt = cnt_inits_to; 2156 LIST_FOREACH(laddr, &inp->sctp_addr_list, sctp_nxt_addr) { 2157 if (laddr->ifa == NULL) { 2158 continue; 2159 } 2160 if (laddr->ifa->localifa_flags & SCTP_BEING_DELETED) { 2161 continue; 2162 } 2163 if (sctp_is_address_in_scope(laddr->ifa, 2164 scope, 0) == 0) { 2165 continue; 2166 } 2167 if ((chunk_len != NULL) && 2168 (padding_len != NULL) && 2169 (*padding_len > 0)) { 2170 memset(mtod(m_at, caddr_t)+*chunk_len, 0, *padding_len); 2171 SCTP_BUF_LEN(m_at) += *padding_len; 2172 *chunk_len += *padding_len; 2173 *padding_len = 0; 2174 } 2175 m_at = sctp_add_addr_to_mbuf(m_at, laddr->ifa, chunk_len); 2176 cnt++; 2177 if (cnt >= SCTP_ADDRESS_LIMIT) { 2178 break; 2179 } 2180 } 2181 } 2182 } 2183 SCTP_IPI_ADDR_RUNLOCK(); 2184 return (m_at); 2185 } 2186 2187 static struct sctp_ifa * 2188 sctp_is_ifa_addr_preferred(struct sctp_ifa *ifa, 2189 uint8_t dest_is_loop, 2190 uint8_t dest_is_priv, 2191 sa_family_t fam) 2192 { 2193 uint8_t dest_is_global = 0; 2194 2195 /* dest_is_priv is true if destination is a private address */ 2196 /* dest_is_loop is true if destination is a loopback addresses */ 2197 2198 /** 2199 * Here we determine if its a preferred address. A preferred address 2200 * means it is the same scope or higher scope then the destination. 2201 * L = loopback, P = private, G = global 2202 * ----------------------------------------- 2203 * src | dest | result 2204 * ---------------------------------------- 2205 * L | L | yes 2206 * ----------------------------------------- 2207 * P | L | yes-v4 no-v6 2208 * ----------------------------------------- 2209 * G | L | yes-v4 no-v6 2210 * ----------------------------------------- 2211 * L | P | no 2212 * ----------------------------------------- 2213 * P | P | yes 2214 * ----------------------------------------- 2215 * G | P | no 2216 * ----------------------------------------- 2217 * L | G | no 2218 * ----------------------------------------- 2219 * P | G | no 2220 * ----------------------------------------- 2221 * G | G | yes 2222 * ----------------------------------------- 2223 */ 2224 2225 if (ifa->address.sa.sa_family != fam) { 2226 /* forget mis-matched family */ 2227 return (NULL); 2228 } 2229 if ((dest_is_priv == 0) && (dest_is_loop == 0)) { 2230 dest_is_global = 1; 2231 } 2232 SCTPDBG(SCTP_DEBUG_OUTPUT2, "Is destination preferred:"); 2233 SCTPDBG_ADDR(SCTP_DEBUG_OUTPUT2, &ifa->address.sa); 2234 /* Ok the address may be ok */ 2235 #ifdef INET6 2236 if (fam == AF_INET6) { 2237 /* ok to use deprecated addresses? no lets not! */ 2238 if (ifa->localifa_flags & SCTP_ADDR_IFA_UNUSEABLE) { 2239 SCTPDBG(SCTP_DEBUG_OUTPUT3, "NO:1\n"); 2240 return (NULL); 2241 } 2242 if (ifa->src_is_priv && !ifa->src_is_loop) { 2243 if (dest_is_loop) { 2244 SCTPDBG(SCTP_DEBUG_OUTPUT3, "NO:2\n"); 2245 return (NULL); 2246 } 2247 } 2248 if (ifa->src_is_glob) { 2249 if (dest_is_loop) { 2250 SCTPDBG(SCTP_DEBUG_OUTPUT3, "NO:3\n"); 2251 return (NULL); 2252 } 2253 } 2254 } 2255 #endif 2256 /* 2257 * Now that we know what is what, implement or table this could in 2258 * theory be done slicker (it used to be), but this is 2259 * straightforward and easier to validate :-) 2260 */ 2261 SCTPDBG(SCTP_DEBUG_OUTPUT3, "src_loop:%d src_priv:%d src_glob:%d\n", 2262 ifa->src_is_loop, ifa->src_is_priv, ifa->src_is_glob); 2263 SCTPDBG(SCTP_DEBUG_OUTPUT3, "dest_loop:%d dest_priv:%d dest_glob:%d\n", 2264 dest_is_loop, dest_is_priv, dest_is_global); 2265 2266 if ((ifa->src_is_loop) && (dest_is_priv)) { 2267 SCTPDBG(SCTP_DEBUG_OUTPUT3, "NO:4\n"); 2268 return (NULL); 2269 } 2270 if ((ifa->src_is_glob) && (dest_is_priv)) { 2271 SCTPDBG(SCTP_DEBUG_OUTPUT3, "NO:5\n"); 2272 return (NULL); 2273 } 2274 if ((ifa->src_is_loop) && (dest_is_global)) { 2275 SCTPDBG(SCTP_DEBUG_OUTPUT3, "NO:6\n"); 2276 return (NULL); 2277 } 2278 if ((ifa->src_is_priv) && (dest_is_global)) { 2279 SCTPDBG(SCTP_DEBUG_OUTPUT3, "NO:7\n"); 2280 return (NULL); 2281 } 2282 SCTPDBG(SCTP_DEBUG_OUTPUT3, "YES\n"); 2283 /* its a preferred address */ 2284 return (ifa); 2285 } 2286 2287 static struct sctp_ifa * 2288 sctp_is_ifa_addr_acceptable(struct sctp_ifa *ifa, 2289 uint8_t dest_is_loop, 2290 uint8_t dest_is_priv, 2291 sa_family_t fam) 2292 { 2293 uint8_t dest_is_global = 0; 2294 2295 /** 2296 * Here we determine if its a acceptable address. A acceptable 2297 * address means it is the same scope or higher scope but we can 2298 * allow for NAT which means its ok to have a global dest and a 2299 * private src. 2300 * 2301 * L = loopback, P = private, G = global 2302 * ----------------------------------------- 2303 * src | dest | result 2304 * ----------------------------------------- 2305 * L | L | yes 2306 * ----------------------------------------- 2307 * P | L | yes-v4 no-v6 2308 * ----------------------------------------- 2309 * G | L | yes 2310 * ----------------------------------------- 2311 * L | P | no 2312 * ----------------------------------------- 2313 * P | P | yes 2314 * ----------------------------------------- 2315 * G | P | yes - May not work 2316 * ----------------------------------------- 2317 * L | G | no 2318 * ----------------------------------------- 2319 * P | G | yes - May not work 2320 * ----------------------------------------- 2321 * G | G | yes 2322 * ----------------------------------------- 2323 */ 2324 2325 if (ifa->address.sa.sa_family != fam) { 2326 /* forget non matching family */ 2327 SCTPDBG(SCTP_DEBUG_OUTPUT3, "ifa_fam:%d fam:%d\n", 2328 ifa->address.sa.sa_family, fam); 2329 return (NULL); 2330 } 2331 /* Ok the address may be ok */ 2332 SCTPDBG_ADDR(SCTP_DEBUG_OUTPUT3, &ifa->address.sa); 2333 SCTPDBG(SCTP_DEBUG_OUTPUT3, "dst_is_loop:%d dest_is_priv:%d\n", 2334 dest_is_loop, dest_is_priv); 2335 if ((dest_is_loop == 0) && (dest_is_priv == 0)) { 2336 dest_is_global = 1; 2337 } 2338 #ifdef INET6 2339 if (fam == AF_INET6) { 2340 /* ok to use deprecated addresses? */ 2341 if (ifa->localifa_flags & SCTP_ADDR_IFA_UNUSEABLE) { 2342 return (NULL); 2343 } 2344 if (ifa->src_is_priv) { 2345 /* Special case, linklocal to loop */ 2346 if (dest_is_loop) 2347 return (NULL); 2348 } 2349 } 2350 #endif 2351 /* 2352 * Now that we know what is what, implement our table. This could in 2353 * theory be done slicker (it used to be), but this is 2354 * straightforward and easier to validate :-) 2355 */ 2356 SCTPDBG(SCTP_DEBUG_OUTPUT3, "ifa->src_is_loop:%d dest_is_priv:%d\n", 2357 ifa->src_is_loop, 2358 dest_is_priv); 2359 if ((ifa->src_is_loop == 1) && (dest_is_priv)) { 2360 return (NULL); 2361 } 2362 SCTPDBG(SCTP_DEBUG_OUTPUT3, "ifa->src_is_loop:%d dest_is_glob:%d\n", 2363 ifa->src_is_loop, 2364 dest_is_global); 2365 if ((ifa->src_is_loop == 1) && (dest_is_global)) { 2366 return (NULL); 2367 } 2368 SCTPDBG(SCTP_DEBUG_OUTPUT3, "address is acceptable\n"); 2369 /* its an acceptable address */ 2370 return (ifa); 2371 } 2372 2373 int 2374 sctp_is_addr_restricted(struct sctp_tcb *stcb, struct sctp_ifa *ifa) 2375 { 2376 struct sctp_laddr *laddr; 2377 2378 if (stcb == NULL) { 2379 /* There are no restrictions, no TCB :-) */ 2380 return (0); 2381 } 2382 LIST_FOREACH(laddr, &stcb->asoc.sctp_restricted_addrs, sctp_nxt_addr) { 2383 if (laddr->ifa == NULL) { 2384 SCTPDBG(SCTP_DEBUG_OUTPUT1, "%s: NULL ifa\n", 2385 __FUNCTION__); 2386 continue; 2387 } 2388 if (laddr->ifa == ifa) { 2389 /* Yes it is on the list */ 2390 return (1); 2391 } 2392 } 2393 return (0); 2394 } 2395 2396 2397 int 2398 sctp_is_addr_in_ep(struct sctp_inpcb *inp, struct sctp_ifa *ifa) 2399 { 2400 struct sctp_laddr *laddr; 2401 2402 if (ifa == NULL) 2403 return (0); 2404 LIST_FOREACH(laddr, &inp->sctp_addr_list, sctp_nxt_addr) { 2405 if (laddr->ifa == NULL) { 2406 SCTPDBG(SCTP_DEBUG_OUTPUT1, "%s: NULL ifa\n", 2407 __FUNCTION__); 2408 continue; 2409 } 2410 if ((laddr->ifa == ifa) && laddr->action == 0) 2411 /* same pointer */ 2412 return (1); 2413 } 2414 return (0); 2415 } 2416 2417 2418 2419 static struct sctp_ifa * 2420 sctp_choose_boundspecific_inp(struct sctp_inpcb *inp, 2421 sctp_route_t * ro, 2422 uint32_t vrf_id, 2423 int non_asoc_addr_ok, 2424 uint8_t dest_is_priv, 2425 uint8_t dest_is_loop, 2426 sa_family_t fam) 2427 { 2428 struct sctp_laddr *laddr, *starting_point; 2429 void *ifn; 2430 int resettotop = 0; 2431 struct sctp_ifn *sctp_ifn; 2432 struct sctp_ifa *sctp_ifa, *sifa; 2433 struct sctp_vrf *vrf; 2434 uint32_t ifn_index; 2435 2436 vrf = sctp_find_vrf(vrf_id); 2437 if (vrf == NULL) 2438 return (NULL); 2439 2440 ifn = SCTP_GET_IFN_VOID_FROM_ROUTE(ro); 2441 ifn_index = SCTP_GET_IF_INDEX_FROM_ROUTE(ro); 2442 sctp_ifn = sctp_find_ifn(ifn, ifn_index); 2443 /* 2444 * first question, is the ifn we will emit on in our list, if so, we 2445 * want such an address. Note that we first looked for a preferred 2446 * address. 2447 */ 2448 if (sctp_ifn) { 2449 /* is a preferred one on the interface we route out? */ 2450 LIST_FOREACH(sctp_ifa, &sctp_ifn->ifalist, next_ifa) { 2451 if ((sctp_ifa->localifa_flags & SCTP_ADDR_DEFER_USE) && 2452 (non_asoc_addr_ok == 0)) 2453 continue; 2454 sifa = sctp_is_ifa_addr_preferred(sctp_ifa, 2455 dest_is_loop, 2456 dest_is_priv, fam); 2457 if (sifa == NULL) 2458 continue; 2459 if (sctp_is_addr_in_ep(inp, sifa)) { 2460 atomic_add_int(&sifa->refcount, 1); 2461 return (sifa); 2462 } 2463 } 2464 } 2465 /* 2466 * ok, now we now need to find one on the list of the addresses. We 2467 * can't get one on the emitting interface so let's find first a 2468 * preferred one. If not that an acceptable one otherwise... we 2469 * return NULL. 2470 */ 2471 starting_point = inp->next_addr_touse; 2472 once_again: 2473 if (inp->next_addr_touse == NULL) { 2474 inp->next_addr_touse = LIST_FIRST(&inp->sctp_addr_list); 2475 resettotop = 1; 2476 } 2477 for (laddr = inp->next_addr_touse; laddr; 2478 laddr = LIST_NEXT(laddr, sctp_nxt_addr)) { 2479 if (laddr->ifa == NULL) { 2480 /* address has been removed */ 2481 continue; 2482 } 2483 if (laddr->action == SCTP_DEL_IP_ADDRESS) { 2484 /* address is being deleted */ 2485 continue; 2486 } 2487 sifa = sctp_is_ifa_addr_preferred(laddr->ifa, dest_is_loop, 2488 dest_is_priv, fam); 2489 if (sifa == NULL) 2490 continue; 2491 atomic_add_int(&sifa->refcount, 1); 2492 return (sifa); 2493 } 2494 if (resettotop == 0) { 2495 inp->next_addr_touse = NULL; 2496 goto once_again; 2497 } 2498 inp->next_addr_touse = starting_point; 2499 resettotop = 0; 2500 once_again_too: 2501 if (inp->next_addr_touse == NULL) { 2502 inp->next_addr_touse = LIST_FIRST(&inp->sctp_addr_list); 2503 resettotop = 1; 2504 } 2505 /* ok, what about an acceptable address in the inp */ 2506 for (laddr = inp->next_addr_touse; laddr; 2507 laddr = LIST_NEXT(laddr, sctp_nxt_addr)) { 2508 if (laddr->ifa == NULL) { 2509 /* address has been removed */ 2510 continue; 2511 } 2512 if (laddr->action == SCTP_DEL_IP_ADDRESS) { 2513 /* address is being deleted */ 2514 continue; 2515 } 2516 sifa = sctp_is_ifa_addr_acceptable(laddr->ifa, dest_is_loop, 2517 dest_is_priv, fam); 2518 if (sifa == NULL) 2519 continue; 2520 atomic_add_int(&sifa->refcount, 1); 2521 return (sifa); 2522 } 2523 if (resettotop == 0) { 2524 inp->next_addr_touse = NULL; 2525 goto once_again_too; 2526 } 2527 /* 2528 * no address bound can be a source for the destination we are in 2529 * trouble 2530 */ 2531 return (NULL); 2532 } 2533 2534 2535 2536 static struct sctp_ifa * 2537 sctp_choose_boundspecific_stcb(struct sctp_inpcb *inp, 2538 struct sctp_tcb *stcb, 2539 sctp_route_t * ro, 2540 uint32_t vrf_id, 2541 uint8_t dest_is_priv, 2542 uint8_t dest_is_loop, 2543 int non_asoc_addr_ok, 2544 sa_family_t fam) 2545 { 2546 struct sctp_laddr *laddr, *starting_point; 2547 void *ifn; 2548 struct sctp_ifn *sctp_ifn; 2549 struct sctp_ifa *sctp_ifa, *sifa; 2550 uint8_t start_at_beginning = 0; 2551 struct sctp_vrf *vrf; 2552 uint32_t ifn_index; 2553 2554 /* 2555 * first question, is the ifn we will emit on in our list, if so, we 2556 * want that one. 2557 */ 2558 vrf = sctp_find_vrf(vrf_id); 2559 if (vrf == NULL) 2560 return (NULL); 2561 2562 ifn = SCTP_GET_IFN_VOID_FROM_ROUTE(ro); 2563 ifn_index = SCTP_GET_IF_INDEX_FROM_ROUTE(ro); 2564 sctp_ifn = sctp_find_ifn(ifn, ifn_index); 2565 2566 /* 2567 * first question, is the ifn we will emit on in our list? If so, 2568 * we want that one. First we look for a preferred. Second, we go 2569 * for an acceptable. 2570 */ 2571 if (sctp_ifn) { 2572 /* first try for a preferred address on the ep */ 2573 LIST_FOREACH(sctp_ifa, &sctp_ifn->ifalist, next_ifa) { 2574 if ((sctp_ifa->localifa_flags & SCTP_ADDR_DEFER_USE) && (non_asoc_addr_ok == 0)) 2575 continue; 2576 if (sctp_is_addr_in_ep(inp, sctp_ifa)) { 2577 sifa = sctp_is_ifa_addr_preferred(sctp_ifa, dest_is_loop, dest_is_priv, fam); 2578 if (sifa == NULL) 2579 continue; 2580 if (((non_asoc_addr_ok == 0) && 2581 (sctp_is_addr_restricted(stcb, sifa))) || 2582 (non_asoc_addr_ok && 2583 (sctp_is_addr_restricted(stcb, sifa)) && 2584 (!sctp_is_addr_pending(stcb, sifa)))) { 2585 /* on the no-no list */ 2586 continue; 2587 } 2588 atomic_add_int(&sifa->refcount, 1); 2589 return (sifa); 2590 } 2591 } 2592 /* next try for an acceptable address on the ep */ 2593 LIST_FOREACH(sctp_ifa, &sctp_ifn->ifalist, next_ifa) { 2594 if ((sctp_ifa->localifa_flags & SCTP_ADDR_DEFER_USE) && (non_asoc_addr_ok == 0)) 2595 continue; 2596 if (sctp_is_addr_in_ep(inp, sctp_ifa)) { 2597 sifa = sctp_is_ifa_addr_acceptable(sctp_ifa, dest_is_loop, dest_is_priv, fam); 2598 if (sifa == NULL) 2599 continue; 2600 if (((non_asoc_addr_ok == 0) && 2601 (sctp_is_addr_restricted(stcb, sifa))) || 2602 (non_asoc_addr_ok && 2603 (sctp_is_addr_restricted(stcb, sifa)) && 2604 (!sctp_is_addr_pending(stcb, sifa)))) { 2605 /* on the no-no list */ 2606 continue; 2607 } 2608 atomic_add_int(&sifa->refcount, 1); 2609 return (sifa); 2610 } 2611 } 2612 2613 } 2614 /* 2615 * if we can't find one like that then we must look at all addresses 2616 * bound to pick one at first preferable then secondly acceptable. 2617 */ 2618 starting_point = stcb->asoc.last_used_address; 2619 sctp_from_the_top: 2620 if (stcb->asoc.last_used_address == NULL) { 2621 start_at_beginning = 1; 2622 stcb->asoc.last_used_address = LIST_FIRST(&inp->sctp_addr_list); 2623 } 2624 /* search beginning with the last used address */ 2625 for (laddr = stcb->asoc.last_used_address; laddr; 2626 laddr = LIST_NEXT(laddr, sctp_nxt_addr)) { 2627 if (laddr->ifa == NULL) { 2628 /* address has been removed */ 2629 continue; 2630 } 2631 if (laddr->action == SCTP_DEL_IP_ADDRESS) { 2632 /* address is being deleted */ 2633 continue; 2634 } 2635 sifa = sctp_is_ifa_addr_preferred(laddr->ifa, dest_is_loop, dest_is_priv, fam); 2636 if (sifa == NULL) 2637 continue; 2638 if (((non_asoc_addr_ok == 0) && 2639 (sctp_is_addr_restricted(stcb, sifa))) || 2640 (non_asoc_addr_ok && 2641 (sctp_is_addr_restricted(stcb, sifa)) && 2642 (!sctp_is_addr_pending(stcb, sifa)))) { 2643 /* on the no-no list */ 2644 continue; 2645 } 2646 stcb->asoc.last_used_address = laddr; 2647 atomic_add_int(&sifa->refcount, 1); 2648 return (sifa); 2649 } 2650 if (start_at_beginning == 0) { 2651 stcb->asoc.last_used_address = NULL; 2652 goto sctp_from_the_top; 2653 } 2654 /* now try for any higher scope than the destination */ 2655 stcb->asoc.last_used_address = starting_point; 2656 start_at_beginning = 0; 2657 sctp_from_the_top2: 2658 if (stcb->asoc.last_used_address == NULL) { 2659 start_at_beginning = 1; 2660 stcb->asoc.last_used_address = LIST_FIRST(&inp->sctp_addr_list); 2661 } 2662 /* search beginning with the last used address */ 2663 for (laddr = stcb->asoc.last_used_address; laddr; 2664 laddr = LIST_NEXT(laddr, sctp_nxt_addr)) { 2665 if (laddr->ifa == NULL) { 2666 /* address has been removed */ 2667 continue; 2668 } 2669 if (laddr->action == SCTP_DEL_IP_ADDRESS) { 2670 /* address is being deleted */ 2671 continue; 2672 } 2673 sifa = sctp_is_ifa_addr_acceptable(laddr->ifa, dest_is_loop, 2674 dest_is_priv, fam); 2675 if (sifa == NULL) 2676 continue; 2677 if (((non_asoc_addr_ok == 0) && 2678 (sctp_is_addr_restricted(stcb, sifa))) || 2679 (non_asoc_addr_ok && 2680 (sctp_is_addr_restricted(stcb, sifa)) && 2681 (!sctp_is_addr_pending(stcb, sifa)))) { 2682 /* on the no-no list */ 2683 continue; 2684 } 2685 stcb->asoc.last_used_address = laddr; 2686 atomic_add_int(&sifa->refcount, 1); 2687 return (sifa); 2688 } 2689 if (start_at_beginning == 0) { 2690 stcb->asoc.last_used_address = NULL; 2691 goto sctp_from_the_top2; 2692 } 2693 return (NULL); 2694 } 2695 2696 static struct sctp_ifa * 2697 sctp_select_nth_preferred_addr_from_ifn_boundall(struct sctp_ifn *ifn, 2698 struct sctp_tcb *stcb, 2699 int non_asoc_addr_ok, 2700 uint8_t dest_is_loop, 2701 uint8_t dest_is_priv, 2702 int addr_wanted, 2703 sa_family_t fam, 2704 sctp_route_t * ro 2705 ) 2706 { 2707 struct sctp_ifa *ifa, *sifa; 2708 int num_eligible_addr = 0; 2709 2710 #ifdef INET6 2711 struct sockaddr_in6 sin6, lsa6; 2712 2713 if (fam == AF_INET6) { 2714 memcpy(&sin6, &ro->ro_dst, sizeof(struct sockaddr_in6)); 2715 (void)sa6_recoverscope(&sin6); 2716 } 2717 #endif /* INET6 */ 2718 LIST_FOREACH(ifa, &ifn->ifalist, next_ifa) { 2719 if ((ifa->localifa_flags & SCTP_ADDR_DEFER_USE) && 2720 (non_asoc_addr_ok == 0)) 2721 continue; 2722 sifa = sctp_is_ifa_addr_preferred(ifa, dest_is_loop, 2723 dest_is_priv, fam); 2724 if (sifa == NULL) 2725 continue; 2726 #ifdef INET6 2727 if (fam == AF_INET6 && 2728 dest_is_loop && 2729 sifa->src_is_loop && sifa->src_is_priv) { 2730 /* 2731 * don't allow fe80::1 to be a src on loop ::1, we 2732 * don't list it to the peer so we will get an 2733 * abort. 2734 */ 2735 continue; 2736 } 2737 if (fam == AF_INET6 && 2738 IN6_IS_ADDR_LINKLOCAL(&sifa->address.sin6.sin6_addr) && 2739 IN6_IS_ADDR_LINKLOCAL(&sin6.sin6_addr)) { 2740 /* 2741 * link-local <-> link-local must belong to the same 2742 * scope. 2743 */ 2744 memcpy(&lsa6, &sifa->address.sin6, sizeof(struct sockaddr_in6)); 2745 (void)sa6_recoverscope(&lsa6); 2746 if (sin6.sin6_scope_id != lsa6.sin6_scope_id) { 2747 continue; 2748 } 2749 } 2750 #endif /* INET6 */ 2751 2752 /* 2753 * Check if the IPv6 address matches to next-hop. In the 2754 * mobile case, old IPv6 address may be not deleted from the 2755 * interface. Then, the interface has previous and new 2756 * addresses. We should use one corresponding to the 2757 * next-hop. (by micchie) 2758 */ 2759 #ifdef INET6 2760 if (stcb && fam == AF_INET6 && 2761 sctp_is_mobility_feature_on(stcb->sctp_ep, SCTP_MOBILITY_BASE)) { 2762 if (sctp_v6src_match_nexthop(&sifa->address.sin6, ro) 2763 == 0) { 2764 continue; 2765 } 2766 } 2767 #endif 2768 #ifdef INET 2769 /* Avoid topologically incorrect IPv4 address */ 2770 if (stcb && fam == AF_INET && 2771 sctp_is_mobility_feature_on(stcb->sctp_ep, SCTP_MOBILITY_BASE)) { 2772 if (sctp_v4src_match_nexthop(sifa, ro) == 0) { 2773 continue; 2774 } 2775 } 2776 #endif 2777 if (stcb) { 2778 if (sctp_is_address_in_scope(ifa, &stcb->asoc.scope, 0) == 0) { 2779 continue; 2780 } 2781 if (((non_asoc_addr_ok == 0) && 2782 (sctp_is_addr_restricted(stcb, sifa))) || 2783 (non_asoc_addr_ok && 2784 (sctp_is_addr_restricted(stcb, sifa)) && 2785 (!sctp_is_addr_pending(stcb, sifa)))) { 2786 /* 2787 * It is restricted for some reason.. 2788 * probably not yet added. 2789 */ 2790 continue; 2791 } 2792 } 2793 if (num_eligible_addr >= addr_wanted) { 2794 return (sifa); 2795 } 2796 num_eligible_addr++; 2797 } 2798 return (NULL); 2799 } 2800 2801 2802 static int 2803 sctp_count_num_preferred_boundall(struct sctp_ifn *ifn, 2804 struct sctp_tcb *stcb, 2805 int non_asoc_addr_ok, 2806 uint8_t dest_is_loop, 2807 uint8_t dest_is_priv, 2808 sa_family_t fam) 2809 { 2810 struct sctp_ifa *ifa, *sifa; 2811 int num_eligible_addr = 0; 2812 2813 LIST_FOREACH(ifa, &ifn->ifalist, next_ifa) { 2814 if ((ifa->localifa_flags & SCTP_ADDR_DEFER_USE) && 2815 (non_asoc_addr_ok == 0)) { 2816 continue; 2817 } 2818 sifa = sctp_is_ifa_addr_preferred(ifa, dest_is_loop, 2819 dest_is_priv, fam); 2820 if (sifa == NULL) { 2821 continue; 2822 } 2823 if (stcb) { 2824 if (sctp_is_address_in_scope(ifa, &stcb->asoc.scope, 0) == 0) { 2825 continue; 2826 } 2827 if (((non_asoc_addr_ok == 0) && 2828 (sctp_is_addr_restricted(stcb, sifa))) || 2829 (non_asoc_addr_ok && 2830 (sctp_is_addr_restricted(stcb, sifa)) && 2831 (!sctp_is_addr_pending(stcb, sifa)))) { 2832 /* 2833 * It is restricted for some reason.. 2834 * probably not yet added. 2835 */ 2836 continue; 2837 } 2838 } 2839 num_eligible_addr++; 2840 } 2841 return (num_eligible_addr); 2842 } 2843 2844 static struct sctp_ifa * 2845 sctp_choose_boundall(struct sctp_tcb *stcb, 2846 struct sctp_nets *net, 2847 sctp_route_t * ro, 2848 uint32_t vrf_id, 2849 uint8_t dest_is_priv, 2850 uint8_t dest_is_loop, 2851 int non_asoc_addr_ok, 2852 sa_family_t fam) 2853 { 2854 int cur_addr_num = 0, num_preferred = 0; 2855 void *ifn; 2856 struct sctp_ifn *sctp_ifn, *looked_at = NULL, *emit_ifn; 2857 struct sctp_ifa *sctp_ifa, *sifa; 2858 uint32_t ifn_index; 2859 struct sctp_vrf *vrf; 2860 2861 #ifdef INET 2862 int retried = 0; 2863 2864 #endif 2865 2866 /*- 2867 * For boundall we can use any address in the association. 2868 * If non_asoc_addr_ok is set we can use any address (at least in 2869 * theory). So we look for preferred addresses first. If we find one, 2870 * we use it. Otherwise we next try to get an address on the 2871 * interface, which we should be able to do (unless non_asoc_addr_ok 2872 * is false and we are routed out that way). In these cases where we 2873 * can't use the address of the interface we go through all the 2874 * ifn's looking for an address we can use and fill that in. Punting 2875 * means we send back address 0, which will probably cause problems 2876 * actually since then IP will fill in the address of the route ifn, 2877 * which means we probably already rejected it.. i.e. here comes an 2878 * abort :-<. 2879 */ 2880 vrf = sctp_find_vrf(vrf_id); 2881 if (vrf == NULL) 2882 return (NULL); 2883 2884 ifn = SCTP_GET_IFN_VOID_FROM_ROUTE(ro); 2885 ifn_index = SCTP_GET_IF_INDEX_FROM_ROUTE(ro); 2886 SCTPDBG(SCTP_DEBUG_OUTPUT2, "ifn from route:%p ifn_index:%d\n", ifn, ifn_index); 2887 emit_ifn = looked_at = sctp_ifn = sctp_find_ifn(ifn, ifn_index); 2888 if (sctp_ifn == NULL) { 2889 /* ?? We don't have this guy ?? */ 2890 SCTPDBG(SCTP_DEBUG_OUTPUT2, "No ifn emit interface?\n"); 2891 goto bound_all_plan_b; 2892 } 2893 SCTPDBG(SCTP_DEBUG_OUTPUT2, "ifn_index:%d name:%s is emit interface\n", 2894 ifn_index, sctp_ifn->ifn_name); 2895 2896 if (net) { 2897 cur_addr_num = net->indx_of_eligible_next_to_use; 2898 } 2899 num_preferred = sctp_count_num_preferred_boundall(sctp_ifn, 2900 stcb, 2901 non_asoc_addr_ok, 2902 dest_is_loop, 2903 dest_is_priv, fam); 2904 SCTPDBG(SCTP_DEBUG_OUTPUT2, "Found %d preferred source addresses for intf:%s\n", 2905 num_preferred, sctp_ifn->ifn_name); 2906 if (num_preferred == 0) { 2907 /* 2908 * no eligible addresses, we must use some other interface 2909 * address if we can find one. 2910 */ 2911 goto bound_all_plan_b; 2912 } 2913 /* 2914 * Ok we have num_eligible_addr set with how many we can use, this 2915 * may vary from call to call due to addresses being deprecated 2916 * etc.. 2917 */ 2918 if (cur_addr_num >= num_preferred) { 2919 cur_addr_num = 0; 2920 } 2921 /* 2922 * select the nth address from the list (where cur_addr_num is the 2923 * nth) and 0 is the first one, 1 is the second one etc... 2924 */ 2925 SCTPDBG(SCTP_DEBUG_OUTPUT2, "cur_addr_num:%d\n", cur_addr_num); 2926 2927 sctp_ifa = sctp_select_nth_preferred_addr_from_ifn_boundall(sctp_ifn, stcb, non_asoc_addr_ok, dest_is_loop, 2928 dest_is_priv, cur_addr_num, fam, ro); 2929 2930 /* if sctp_ifa is NULL something changed??, fall to plan b. */ 2931 if (sctp_ifa) { 2932 atomic_add_int(&sctp_ifa->refcount, 1); 2933 if (net) { 2934 /* save off where the next one we will want */ 2935 net->indx_of_eligible_next_to_use = cur_addr_num + 1; 2936 } 2937 return (sctp_ifa); 2938 } 2939 /* 2940 * plan_b: Look at all interfaces and find a preferred address. If 2941 * no preferred fall through to plan_c. 2942 */ 2943 bound_all_plan_b: 2944 SCTPDBG(SCTP_DEBUG_OUTPUT2, "Trying Plan B\n"); 2945 LIST_FOREACH(sctp_ifn, &vrf->ifnlist, next_ifn) { 2946 SCTPDBG(SCTP_DEBUG_OUTPUT2, "Examine interface %s\n", 2947 sctp_ifn->ifn_name); 2948 if (dest_is_loop == 0 && SCTP_IFN_IS_IFT_LOOP(sctp_ifn)) { 2949 /* wrong base scope */ 2950 SCTPDBG(SCTP_DEBUG_OUTPUT2, "skip\n"); 2951 continue; 2952 } 2953 if ((sctp_ifn == looked_at) && looked_at) { 2954 /* already looked at this guy */ 2955 SCTPDBG(SCTP_DEBUG_OUTPUT2, "already seen\n"); 2956 continue; 2957 } 2958 num_preferred = sctp_count_num_preferred_boundall(sctp_ifn, stcb, non_asoc_addr_ok, 2959 dest_is_loop, dest_is_priv, fam); 2960 SCTPDBG(SCTP_DEBUG_OUTPUT2, 2961 "Found ifn:%p %d preferred source addresses\n", 2962 ifn, num_preferred); 2963 if (num_preferred == 0) { 2964 /* None on this interface. */ 2965 SCTPDBG(SCTP_DEBUG_OUTPUT2, "No prefered -- skipping to next\n"); 2966 continue; 2967 } 2968 SCTPDBG(SCTP_DEBUG_OUTPUT2, 2969 "num preferred:%d on interface:%p cur_addr_num:%d\n", 2970 num_preferred, (void *)sctp_ifn, cur_addr_num); 2971 2972 /* 2973 * Ok we have num_eligible_addr set with how many we can 2974 * use, this may vary from call to call due to addresses 2975 * being deprecated etc.. 2976 */ 2977 if (cur_addr_num >= num_preferred) { 2978 cur_addr_num = 0; 2979 } 2980 sifa = sctp_select_nth_preferred_addr_from_ifn_boundall(sctp_ifn, stcb, non_asoc_addr_ok, dest_is_loop, 2981 dest_is_priv, cur_addr_num, fam, ro); 2982 if (sifa == NULL) 2983 continue; 2984 if (net) { 2985 net->indx_of_eligible_next_to_use = cur_addr_num + 1; 2986 SCTPDBG(SCTP_DEBUG_OUTPUT2, "we selected %d\n", 2987 cur_addr_num); 2988 SCTPDBG(SCTP_DEBUG_OUTPUT2, "Source:"); 2989 SCTPDBG_ADDR(SCTP_DEBUG_OUTPUT2, &sifa->address.sa); 2990 SCTPDBG(SCTP_DEBUG_OUTPUT2, "Dest:"); 2991 SCTPDBG_ADDR(SCTP_DEBUG_OUTPUT2, &net->ro._l_addr.sa); 2992 } 2993 atomic_add_int(&sifa->refcount, 1); 2994 return (sifa); 2995 } 2996 #ifdef INET 2997 again_with_private_addresses_allowed: 2998 #endif 2999 /* plan_c: do we have an acceptable address on the emit interface */ 3000 sifa = NULL; 3001 SCTPDBG(SCTP_DEBUG_OUTPUT2, "Trying Plan C: find acceptable on interface\n"); 3002 if (emit_ifn == NULL) { 3003 SCTPDBG(SCTP_DEBUG_OUTPUT2, "Jump to Plan D - no emit_ifn\n"); 3004 goto plan_d; 3005 } 3006 LIST_FOREACH(sctp_ifa, &emit_ifn->ifalist, next_ifa) { 3007 SCTPDBG(SCTP_DEBUG_OUTPUT2, "ifa:%p\n", (void *)sctp_ifa); 3008 if ((sctp_ifa->localifa_flags & SCTP_ADDR_DEFER_USE) && 3009 (non_asoc_addr_ok == 0)) { 3010 SCTPDBG(SCTP_DEBUG_OUTPUT2, "Defer\n"); 3011 continue; 3012 } 3013 sifa = sctp_is_ifa_addr_acceptable(sctp_ifa, dest_is_loop, 3014 dest_is_priv, fam); 3015 if (sifa == NULL) { 3016 SCTPDBG(SCTP_DEBUG_OUTPUT2, "IFA not acceptable\n"); 3017 continue; 3018 } 3019 if (stcb) { 3020 if (sctp_is_address_in_scope(sifa, &stcb->asoc.scope, 0) == 0) { 3021 SCTPDBG(SCTP_DEBUG_OUTPUT2, "NOT in scope\n"); 3022 sifa = NULL; 3023 continue; 3024 } 3025 if (((non_asoc_addr_ok == 0) && 3026 (sctp_is_addr_restricted(stcb, sifa))) || 3027 (non_asoc_addr_ok && 3028 (sctp_is_addr_restricted(stcb, sifa)) && 3029 (!sctp_is_addr_pending(stcb, sifa)))) { 3030 /* 3031 * It is restricted for some reason.. 3032 * probably not yet added. 3033 */ 3034 SCTPDBG(SCTP_DEBUG_OUTPUT2, "Its resticted\n"); 3035 sifa = NULL; 3036 continue; 3037 } 3038 } else { 3039 SCTP_PRINTF("Stcb is null - no print\n"); 3040 } 3041 atomic_add_int(&sifa->refcount, 1); 3042 goto out; 3043 } 3044 plan_d: 3045 /* 3046 * plan_d: We are in trouble. No preferred address on the emit 3047 * interface. And not even a preferred address on all interfaces. Go 3048 * out and see if we can find an acceptable address somewhere 3049 * amongst all interfaces. 3050 */ 3051 SCTPDBG(SCTP_DEBUG_OUTPUT2, "Trying Plan D looked_at is %p\n", (void *)looked_at); 3052 LIST_FOREACH(sctp_ifn, &vrf->ifnlist, next_ifn) { 3053 if (dest_is_loop == 0 && SCTP_IFN_IS_IFT_LOOP(sctp_ifn)) { 3054 /* wrong base scope */ 3055 continue; 3056 } 3057 LIST_FOREACH(sctp_ifa, &sctp_ifn->ifalist, next_ifa) { 3058 if ((sctp_ifa->localifa_flags & SCTP_ADDR_DEFER_USE) && 3059 (non_asoc_addr_ok == 0)) 3060 continue; 3061 sifa = sctp_is_ifa_addr_acceptable(sctp_ifa, 3062 dest_is_loop, 3063 dest_is_priv, fam); 3064 if (sifa == NULL) 3065 continue; 3066 if (stcb) { 3067 if (sctp_is_address_in_scope(sifa, &stcb->asoc.scope, 0) == 0) { 3068 sifa = NULL; 3069 continue; 3070 } 3071 if (((non_asoc_addr_ok == 0) && 3072 (sctp_is_addr_restricted(stcb, sifa))) || 3073 (non_asoc_addr_ok && 3074 (sctp_is_addr_restricted(stcb, sifa)) && 3075 (!sctp_is_addr_pending(stcb, sifa)))) { 3076 /* 3077 * It is restricted for some 3078 * reason.. probably not yet added. 3079 */ 3080 sifa = NULL; 3081 continue; 3082 } 3083 } 3084 goto out; 3085 } 3086 } 3087 #ifdef INET 3088 if ((retried == 0) && (stcb->asoc.scope.ipv4_local_scope == 0)) { 3089 stcb->asoc.scope.ipv4_local_scope = 1; 3090 retried = 1; 3091 goto again_with_private_addresses_allowed; 3092 } else if (retried == 1) { 3093 stcb->asoc.scope.ipv4_local_scope = 0; 3094 } 3095 #endif 3096 out: 3097 #ifdef INET 3098 if (sifa) { 3099 if (retried == 1) { 3100 LIST_FOREACH(sctp_ifn, &vrf->ifnlist, next_ifn) { 3101 if (dest_is_loop == 0 && SCTP_IFN_IS_IFT_LOOP(sctp_ifn)) { 3102 /* wrong base scope */ 3103 continue; 3104 } 3105 LIST_FOREACH(sctp_ifa, &sctp_ifn->ifalist, next_ifa) { 3106 struct sctp_ifa *tmp_sifa; 3107 3108 if ((sctp_ifa->localifa_flags & SCTP_ADDR_DEFER_USE) && 3109 (non_asoc_addr_ok == 0)) 3110 continue; 3111 tmp_sifa = sctp_is_ifa_addr_acceptable(sctp_ifa, 3112 dest_is_loop, 3113 dest_is_priv, fam); 3114 if (tmp_sifa == NULL) { 3115 continue; 3116 } 3117 if (tmp_sifa == sifa) { 3118 continue; 3119 } 3120 if (stcb) { 3121 if (sctp_is_address_in_scope(tmp_sifa, 3122 &stcb->asoc.scope, 0) == 0) { 3123 continue; 3124 } 3125 if (((non_asoc_addr_ok == 0) && 3126 (sctp_is_addr_restricted(stcb, tmp_sifa))) || 3127 (non_asoc_addr_ok && 3128 (sctp_is_addr_restricted(stcb, tmp_sifa)) && 3129 (!sctp_is_addr_pending(stcb, tmp_sifa)))) { 3130 /* 3131 * It is restricted 3132 * for some reason.. 3133 * probably not yet 3134 * added. 3135 */ 3136 continue; 3137 } 3138 } 3139 if ((tmp_sifa->address.sin.sin_family == AF_INET) && 3140 (IN4_ISPRIVATE_ADDRESS(&(tmp_sifa->address.sin.sin_addr)))) { 3141 sctp_add_local_addr_restricted(stcb, tmp_sifa); 3142 } 3143 } 3144 } 3145 } 3146 atomic_add_int(&sifa->refcount, 1); 3147 } 3148 #endif 3149 return (sifa); 3150 } 3151 3152 3153 3154 /* tcb may be NULL */ 3155 struct sctp_ifa * 3156 sctp_source_address_selection(struct sctp_inpcb *inp, 3157 struct sctp_tcb *stcb, 3158 sctp_route_t * ro, 3159 struct sctp_nets *net, 3160 int non_asoc_addr_ok, uint32_t vrf_id) 3161 { 3162 struct sctp_ifa *answer; 3163 uint8_t dest_is_priv, dest_is_loop; 3164 sa_family_t fam; 3165 3166 #ifdef INET 3167 struct sockaddr_in *to = (struct sockaddr_in *)&ro->ro_dst; 3168 3169 #endif 3170 #ifdef INET6 3171 struct sockaddr_in6 *to6 = (struct sockaddr_in6 *)&ro->ro_dst; 3172 3173 #endif 3174 3175 /** 3176 * Rules: - Find the route if needed, cache if I can. - Look at 3177 * interface address in route, Is it in the bound list. If so we 3178 * have the best source. - If not we must rotate amongst the 3179 * addresses. 3180 * 3181 * Cavets and issues 3182 * 3183 * Do we need to pay attention to scope. We can have a private address 3184 * or a global address we are sourcing or sending to. So if we draw 3185 * it out 3186 * zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz 3187 * For V4 3188 * ------------------------------------------ 3189 * source * dest * result 3190 * ----------------------------------------- 3191 * <a> Private * Global * NAT 3192 * ----------------------------------------- 3193 * <b> Private * Private * No problem 3194 * ----------------------------------------- 3195 * <c> Global * Private * Huh, How will this work? 3196 * ----------------------------------------- 3197 * <d> Global * Global * No Problem 3198 *------------------------------------------ 3199 * zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz 3200 * For V6 3201 *------------------------------------------ 3202 * source * dest * result 3203 * ----------------------------------------- 3204 * <a> Linklocal * Global * 3205 * ----------------------------------------- 3206 * <b> Linklocal * Linklocal * No problem 3207 * ----------------------------------------- 3208 * <c> Global * Linklocal * Huh, How will this work? 3209 * ----------------------------------------- 3210 * <d> Global * Global * No Problem 3211 *------------------------------------------ 3212 * zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz 3213 * 3214 * And then we add to that what happens if there are multiple addresses 3215 * assigned to an interface. Remember the ifa on a ifn is a linked 3216 * list of addresses. So one interface can have more than one IP 3217 * address. What happens if we have both a private and a global 3218 * address? Do we then use context of destination to sort out which 3219 * one is best? And what about NAT's sending P->G may get you a NAT 3220 * translation, or should you select the G thats on the interface in 3221 * preference. 3222 * 3223 * Decisions: 3224 * 3225 * - count the number of addresses on the interface. 3226 * - if it is one, no problem except case <c>. 3227 * For <a> we will assume a NAT out there. 3228 * - if there are more than one, then we need to worry about scope P 3229 * or G. We should prefer G -> G and P -> P if possible. 3230 * Then as a secondary fall back to mixed types G->P being a last 3231 * ditch one. 3232 * - The above all works for bound all, but bound specific we need to 3233 * use the same concept but instead only consider the bound 3234 * addresses. If the bound set is NOT assigned to the interface then 3235 * we must use rotation amongst the bound addresses.. 3236 */ 3237 if (ro->ro_rt == NULL) { 3238 /* 3239 * Need a route to cache. 3240 */ 3241 SCTP_RTALLOC(ro, vrf_id); 3242 } 3243 if (ro->ro_rt == NULL) { 3244 return (NULL); 3245 } 3246 fam = ro->ro_dst.sa_family; 3247 dest_is_priv = dest_is_loop = 0; 3248 /* Setup our scopes for the destination */ 3249 switch (fam) { 3250 #ifdef INET 3251 case AF_INET: 3252 /* Scope based on outbound address */ 3253 if (IN4_ISLOOPBACK_ADDRESS(&to->sin_addr)) { 3254 dest_is_loop = 1; 3255 if (net != NULL) { 3256 /* mark it as local */ 3257 net->addr_is_local = 1; 3258 } 3259 } else if ((IN4_ISPRIVATE_ADDRESS(&to->sin_addr))) { 3260 dest_is_priv = 1; 3261 } 3262 break; 3263 #endif 3264 #ifdef INET6 3265 case AF_INET6: 3266 /* Scope based on outbound address */ 3267 if (IN6_IS_ADDR_LOOPBACK(&to6->sin6_addr) || 3268 SCTP_ROUTE_IS_REAL_LOOP(ro)) { 3269 /* 3270 * If the address is a loopback address, which 3271 * consists of "::1" OR "fe80::1%lo0", we are 3272 * loopback scope. But we don't use dest_is_priv 3273 * (link local addresses). 3274 */ 3275 dest_is_loop = 1; 3276 if (net != NULL) { 3277 /* mark it as local */ 3278 net->addr_is_local = 1; 3279 } 3280 } else if (IN6_IS_ADDR_LINKLOCAL(&to6->sin6_addr)) { 3281 dest_is_priv = 1; 3282 } 3283 break; 3284 #endif 3285 } 3286 SCTPDBG(SCTP_DEBUG_OUTPUT2, "Select source addr for:"); 3287 SCTPDBG_ADDR(SCTP_DEBUG_OUTPUT2, (struct sockaddr *)&ro->ro_dst); 3288 SCTP_IPI_ADDR_RLOCK(); 3289 if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) { 3290 /* 3291 * Bound all case 3292 */ 3293 answer = sctp_choose_boundall(stcb, net, ro, vrf_id, 3294 dest_is_priv, dest_is_loop, 3295 non_asoc_addr_ok, fam); 3296 SCTP_IPI_ADDR_RUNLOCK(); 3297 return (answer); 3298 } 3299 /* 3300 * Subset bound case 3301 */ 3302 if (stcb) { 3303 answer = sctp_choose_boundspecific_stcb(inp, stcb, ro, 3304 vrf_id, dest_is_priv, 3305 dest_is_loop, 3306 non_asoc_addr_ok, fam); 3307 } else { 3308 answer = sctp_choose_boundspecific_inp(inp, ro, vrf_id, 3309 non_asoc_addr_ok, 3310 dest_is_priv, 3311 dest_is_loop, fam); 3312 } 3313 SCTP_IPI_ADDR_RUNLOCK(); 3314 return (answer); 3315 } 3316 3317 static int 3318 sctp_find_cmsg(int c_type, void *data, struct mbuf *control, size_t cpsize) 3319 { 3320 struct cmsghdr cmh; 3321 int tlen, at, found; 3322 struct sctp_sndinfo sndinfo; 3323 struct sctp_prinfo prinfo; 3324 struct sctp_authinfo authinfo; 3325 3326 tlen = SCTP_BUF_LEN(control); 3327 at = 0; 3328 found = 0; 3329 /* 3330 * Independent of how many mbufs, find the c_type inside the control 3331 * structure and copy out the data. 3332 */ 3333 while (at < tlen) { 3334 if ((tlen - at) < (int)CMSG_ALIGN(sizeof(cmh))) { 3335 /* There is not enough room for one more. */ 3336 return (found); 3337 } 3338 m_copydata(control, at, sizeof(cmh), (caddr_t)&cmh); 3339 if (cmh.cmsg_len < CMSG_ALIGN(sizeof(cmh))) { 3340 /* We dont't have a complete CMSG header. */ 3341 return (found); 3342 } 3343 if (((int)cmh.cmsg_len + at) > tlen) { 3344 /* We don't have the complete CMSG. */ 3345 return (found); 3346 } 3347 if ((cmh.cmsg_level == IPPROTO_SCTP) && 3348 ((c_type == cmh.cmsg_type) || 3349 ((c_type == SCTP_SNDRCV) && 3350 ((cmh.cmsg_type == SCTP_SNDINFO) || 3351 (cmh.cmsg_type == SCTP_PRINFO) || 3352 (cmh.cmsg_type == SCTP_AUTHINFO))))) { 3353 if (c_type == cmh.cmsg_type) { 3354 if ((size_t)(cmh.cmsg_len - CMSG_ALIGN(sizeof(cmh))) < cpsize) { 3355 return (found); 3356 } 3357 /* It is exactly what we want. Copy it out. */ 3358 m_copydata(control, at + CMSG_ALIGN(sizeof(cmh)), cpsize, (caddr_t)data); 3359 return (1); 3360 } else { 3361 struct sctp_sndrcvinfo *sndrcvinfo; 3362 3363 sndrcvinfo = (struct sctp_sndrcvinfo *)data; 3364 if (found == 0) { 3365 if (cpsize < sizeof(struct sctp_sndrcvinfo)) { 3366 return (found); 3367 } 3368 memset(sndrcvinfo, 0, sizeof(struct sctp_sndrcvinfo)); 3369 } 3370 switch (cmh.cmsg_type) { 3371 case SCTP_SNDINFO: 3372 if ((size_t)(cmh.cmsg_len - CMSG_ALIGN(sizeof(cmh))) < sizeof(struct sctp_sndinfo)) { 3373 return (found); 3374 } 3375 m_copydata(control, at + CMSG_ALIGN(sizeof(cmh)), sizeof(struct sctp_sndinfo), (caddr_t)&sndinfo); 3376 sndrcvinfo->sinfo_stream = sndinfo.snd_sid; 3377 sndrcvinfo->sinfo_flags = sndinfo.snd_flags; 3378 sndrcvinfo->sinfo_ppid = sndinfo.snd_ppid; 3379 sndrcvinfo->sinfo_context = sndinfo.snd_context; 3380 sndrcvinfo->sinfo_assoc_id = sndinfo.snd_assoc_id; 3381 break; 3382 case SCTP_PRINFO: 3383 if ((size_t)(cmh.cmsg_len - CMSG_ALIGN(sizeof(cmh))) < sizeof(struct sctp_prinfo)) { 3384 return (found); 3385 } 3386 m_copydata(control, at + CMSG_ALIGN(sizeof(cmh)), sizeof(struct sctp_prinfo), (caddr_t)&prinfo); 3387 sndrcvinfo->sinfo_timetolive = prinfo.pr_value; 3388 sndrcvinfo->sinfo_flags |= prinfo.pr_policy; 3389 break; 3390 case SCTP_AUTHINFO: 3391 if ((size_t)(cmh.cmsg_len - CMSG_ALIGN(sizeof(cmh))) < sizeof(struct sctp_authinfo)) { 3392 return (found); 3393 } 3394 m_copydata(control, at + CMSG_ALIGN(sizeof(cmh)), sizeof(struct sctp_authinfo), (caddr_t)&authinfo); 3395 sndrcvinfo->sinfo_keynumber_valid = 1; 3396 sndrcvinfo->sinfo_keynumber = authinfo.auth_keynumber; 3397 break; 3398 default: 3399 return (found); 3400 } 3401 found = 1; 3402 } 3403 } 3404 at += CMSG_ALIGN(cmh.cmsg_len); 3405 } 3406 return (found); 3407 } 3408 3409 static int 3410 sctp_process_cmsgs_for_init(struct sctp_tcb *stcb, struct mbuf *control, int *error) 3411 { 3412 struct cmsghdr cmh; 3413 int tlen, at; 3414 struct sctp_initmsg initmsg; 3415 3416 #ifdef INET 3417 struct sockaddr_in sin; 3418 3419 #endif 3420 #ifdef INET6 3421 struct sockaddr_in6 sin6; 3422 3423 #endif 3424 3425 tlen = SCTP_BUF_LEN(control); 3426 at = 0; 3427 while (at < tlen) { 3428 if ((tlen - at) < (int)CMSG_ALIGN(sizeof(cmh))) { 3429 /* There is not enough room for one more. */ 3430 *error = EINVAL; 3431 return (1); 3432 } 3433 m_copydata(control, at, sizeof(cmh), (caddr_t)&cmh); 3434 if (cmh.cmsg_len < CMSG_ALIGN(sizeof(cmh))) { 3435 /* We dont't have a complete CMSG header. */ 3436 *error = EINVAL; 3437 return (1); 3438 } 3439 if (((int)cmh.cmsg_len + at) > tlen) { 3440 /* We don't have the complete CMSG. */ 3441 *error = EINVAL; 3442 return (1); 3443 } 3444 if (cmh.cmsg_level == IPPROTO_SCTP) { 3445 switch (cmh.cmsg_type) { 3446 case SCTP_INIT: 3447 if ((size_t)(cmh.cmsg_len - CMSG_ALIGN(sizeof(cmh))) < sizeof(struct sctp_initmsg)) { 3448 *error = EINVAL; 3449 return (1); 3450 } 3451 m_copydata(control, at + CMSG_ALIGN(sizeof(cmh)), sizeof(struct sctp_initmsg), (caddr_t)&initmsg); 3452 if (initmsg.sinit_max_attempts) 3453 stcb->asoc.max_init_times = initmsg.sinit_max_attempts; 3454 if (initmsg.sinit_num_ostreams) 3455 stcb->asoc.pre_open_streams = initmsg.sinit_num_ostreams; 3456 if (initmsg.sinit_max_instreams) 3457 stcb->asoc.max_inbound_streams = initmsg.sinit_max_instreams; 3458 if (initmsg.sinit_max_init_timeo) 3459 stcb->asoc.initial_init_rto_max = initmsg.sinit_max_init_timeo; 3460 if (stcb->asoc.streamoutcnt < stcb->asoc.pre_open_streams) { 3461 struct sctp_stream_out *tmp_str; 3462 unsigned int i; 3463 3464 /* Default is NOT correct */ 3465 SCTPDBG(SCTP_DEBUG_OUTPUT1, "Ok, default:%d pre_open:%d\n", 3466 stcb->asoc.streamoutcnt, stcb->asoc.pre_open_streams); 3467 SCTP_TCB_UNLOCK(stcb); 3468 SCTP_MALLOC(tmp_str, 3469 struct sctp_stream_out *, 3470 (stcb->asoc.pre_open_streams * sizeof(struct sctp_stream_out)), 3471 SCTP_M_STRMO); 3472 SCTP_TCB_LOCK(stcb); 3473 if (tmp_str != NULL) { 3474 SCTP_FREE(stcb->asoc.strmout, SCTP_M_STRMO); 3475 stcb->asoc.strmout = tmp_str; 3476 stcb->asoc.strm_realoutsize = stcb->asoc.streamoutcnt = stcb->asoc.pre_open_streams; 3477 } else { 3478 stcb->asoc.pre_open_streams = stcb->asoc.streamoutcnt; 3479 } 3480 for (i = 0; i < stcb->asoc.streamoutcnt; i++) { 3481 TAILQ_INIT(&stcb->asoc.strmout[i].outqueue); 3482 stcb->asoc.strmout[i].chunks_on_queues = 0; 3483 stcb->asoc.strmout[i].next_sequence_send = 0; 3484 stcb->asoc.strmout[i].stream_no = i; 3485 stcb->asoc.strmout[i].last_msg_incomplete = 0; 3486 stcb->asoc.ss_functions.sctp_ss_init_stream(&stcb->asoc.strmout[i], NULL); 3487 } 3488 } 3489 break; 3490 #ifdef INET 3491 case SCTP_DSTADDRV4: 3492 if ((size_t)(cmh.cmsg_len - CMSG_ALIGN(sizeof(cmh))) < sizeof(struct in_addr)) { 3493 *error = EINVAL; 3494 return (1); 3495 } 3496 memset(&sin, 0, sizeof(struct sockaddr_in)); 3497 sin.sin_family = AF_INET; 3498 sin.sin_len = sizeof(struct sockaddr_in); 3499 sin.sin_port = stcb->rport; 3500 m_copydata(control, at + CMSG_ALIGN(sizeof(cmh)), sizeof(struct in_addr), (caddr_t)&sin.sin_addr); 3501 if ((sin.sin_addr.s_addr == INADDR_ANY) || 3502 (sin.sin_addr.s_addr == INADDR_BROADCAST) || 3503 IN_MULTICAST(ntohl(sin.sin_addr.s_addr))) { 3504 *error = EINVAL; 3505 return (1); 3506 } 3507 if (sctp_add_remote_addr(stcb, (struct sockaddr *)&sin, NULL, 3508 SCTP_DONOT_SETSCOPE, SCTP_ADDR_IS_CONFIRMED)) { 3509 *error = ENOBUFS; 3510 return (1); 3511 } 3512 break; 3513 #endif 3514 #ifdef INET6 3515 case SCTP_DSTADDRV6: 3516 if ((size_t)(cmh.cmsg_len - CMSG_ALIGN(sizeof(cmh))) < sizeof(struct in6_addr)) { 3517 *error = EINVAL; 3518 return (1); 3519 } 3520 memset(&sin6, 0, sizeof(struct sockaddr_in6)); 3521 sin6.sin6_family = AF_INET6; 3522 sin6.sin6_len = sizeof(struct sockaddr_in6); 3523 sin6.sin6_port = stcb->rport; 3524 m_copydata(control, at + CMSG_ALIGN(sizeof(cmh)), sizeof(struct in6_addr), (caddr_t)&sin6.sin6_addr); 3525 if (IN6_IS_ADDR_UNSPECIFIED(&sin6.sin6_addr) || 3526 IN6_IS_ADDR_MULTICAST(&sin6.sin6_addr)) { 3527 *error = EINVAL; 3528 return (1); 3529 } 3530 #ifdef INET 3531 if (IN6_IS_ADDR_V4MAPPED(&sin6.sin6_addr)) { 3532 in6_sin6_2_sin(&sin, &sin6); 3533 if ((sin.sin_addr.s_addr == INADDR_ANY) || 3534 (sin.sin_addr.s_addr == INADDR_BROADCAST) || 3535 IN_MULTICAST(ntohl(sin.sin_addr.s_addr))) { 3536 *error = EINVAL; 3537 return (1); 3538 } 3539 if (sctp_add_remote_addr(stcb, (struct sockaddr *)&sin, NULL, 3540 SCTP_DONOT_SETSCOPE, SCTP_ADDR_IS_CONFIRMED)) { 3541 *error = ENOBUFS; 3542 return (1); 3543 } 3544 } else 3545 #endif 3546 if (sctp_add_remote_addr(stcb, (struct sockaddr *)&sin6, NULL, 3547 SCTP_DONOT_SETSCOPE, SCTP_ADDR_IS_CONFIRMED)) { 3548 *error = ENOBUFS; 3549 return (1); 3550 } 3551 break; 3552 #endif 3553 default: 3554 break; 3555 } 3556 } 3557 at += CMSG_ALIGN(cmh.cmsg_len); 3558 } 3559 return (0); 3560 } 3561 3562 static struct sctp_tcb * 3563 sctp_findassociation_cmsgs(struct sctp_inpcb **inp_p, 3564 in_port_t port, 3565 struct mbuf *control, 3566 struct sctp_nets **net_p, 3567 int *error) 3568 { 3569 struct cmsghdr cmh; 3570 int tlen, at; 3571 struct sctp_tcb *stcb; 3572 struct sockaddr *addr; 3573 3574 #ifdef INET 3575 struct sockaddr_in sin; 3576 3577 #endif 3578 #ifdef INET6 3579 struct sockaddr_in6 sin6; 3580 3581 #endif 3582 3583 tlen = SCTP_BUF_LEN(control); 3584 at = 0; 3585 while (at < tlen) { 3586 if ((tlen - at) < (int)CMSG_ALIGN(sizeof(cmh))) { 3587 /* There is not enough room for one more. */ 3588 *error = EINVAL; 3589 return (NULL); 3590 } 3591 m_copydata(control, at, sizeof(cmh), (caddr_t)&cmh); 3592 if (cmh.cmsg_len < CMSG_ALIGN(sizeof(cmh))) { 3593 /* We dont't have a complete CMSG header. */ 3594 *error = EINVAL; 3595 return (NULL); 3596 } 3597 if (((int)cmh.cmsg_len + at) > tlen) { 3598 /* We don't have the complete CMSG. */ 3599 *error = EINVAL; 3600 return (NULL); 3601 } 3602 if (cmh.cmsg_level == IPPROTO_SCTP) { 3603 switch (cmh.cmsg_type) { 3604 #ifdef INET 3605 case SCTP_DSTADDRV4: 3606 if ((size_t)(cmh.cmsg_len - CMSG_ALIGN(sizeof(cmh))) < sizeof(struct in_addr)) { 3607 *error = EINVAL; 3608 return (NULL); 3609 } 3610 memset(&sin, 0, sizeof(struct sockaddr_in)); 3611 sin.sin_family = AF_INET; 3612 sin.sin_len = sizeof(struct sockaddr_in); 3613 sin.sin_port = port; 3614 m_copydata(control, at + CMSG_ALIGN(sizeof(cmh)), sizeof(struct in_addr), (caddr_t)&sin.sin_addr); 3615 addr = (struct sockaddr *)&sin; 3616 break; 3617 #endif 3618 #ifdef INET6 3619 case SCTP_DSTADDRV6: 3620 if ((size_t)(cmh.cmsg_len - CMSG_ALIGN(sizeof(cmh))) < sizeof(struct in6_addr)) { 3621 *error = EINVAL; 3622 return (NULL); 3623 } 3624 memset(&sin6, 0, sizeof(struct sockaddr_in6)); 3625 sin6.sin6_family = AF_INET6; 3626 sin6.sin6_len = sizeof(struct sockaddr_in6); 3627 sin6.sin6_port = port; 3628 m_copydata(control, at + CMSG_ALIGN(sizeof(cmh)), sizeof(struct in6_addr), (caddr_t)&sin6.sin6_addr); 3629 #ifdef INET 3630 if (IN6_IS_ADDR_V4MAPPED(&sin6.sin6_addr)) { 3631 in6_sin6_2_sin(&sin, &sin6); 3632 addr = (struct sockaddr *)&sin; 3633 } else 3634 #endif 3635 addr = (struct sockaddr *)&sin6; 3636 break; 3637 #endif 3638 default: 3639 addr = NULL; 3640 break; 3641 } 3642 if (addr) { 3643 stcb = sctp_findassociation_ep_addr(inp_p, addr, net_p, NULL, NULL); 3644 if (stcb != NULL) { 3645 return (stcb); 3646 } 3647 } 3648 } 3649 at += CMSG_ALIGN(cmh.cmsg_len); 3650 } 3651 return (NULL); 3652 } 3653 3654 static struct mbuf * 3655 sctp_add_cookie(struct mbuf *init, int init_offset, 3656 struct mbuf *initack, int initack_offset, struct sctp_state_cookie *stc_in, uint8_t ** signature) 3657 { 3658 struct mbuf *copy_init, *copy_initack, *m_at, *sig, *mret; 3659 struct sctp_state_cookie *stc; 3660 struct sctp_paramhdr *ph; 3661 uint8_t *foo; 3662 int sig_offset; 3663 uint16_t cookie_sz; 3664 3665 mret = NULL; 3666 mret = sctp_get_mbuf_for_msg((sizeof(struct sctp_state_cookie) + 3667 sizeof(struct sctp_paramhdr)), 0, 3668 M_DONTWAIT, 1, MT_DATA); 3669 if (mret == NULL) { 3670 return (NULL); 3671 } 3672 copy_init = SCTP_M_COPYM(init, init_offset, M_COPYALL, M_DONTWAIT); 3673 if (copy_init == NULL) { 3674 sctp_m_freem(mret); 3675 return (NULL); 3676 } 3677 #ifdef SCTP_MBUF_LOGGING 3678 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_MBUF_LOGGING_ENABLE) { 3679 struct mbuf *mat; 3680 3681 for (mat = copy_init; mat; mat = SCTP_BUF_NEXT(mat)) { 3682 if (SCTP_BUF_IS_EXTENDED(mat)) { 3683 sctp_log_mb(mat, SCTP_MBUF_ICOPY); 3684 } 3685 } 3686 } 3687 #endif 3688 copy_initack = SCTP_M_COPYM(initack, initack_offset, M_COPYALL, 3689 M_DONTWAIT); 3690 if (copy_initack == NULL) { 3691 sctp_m_freem(mret); 3692 sctp_m_freem(copy_init); 3693 return (NULL); 3694 } 3695 #ifdef SCTP_MBUF_LOGGING 3696 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_MBUF_LOGGING_ENABLE) { 3697 struct mbuf *mat; 3698 3699 for (mat = copy_initack; mat; mat = SCTP_BUF_NEXT(mat)) { 3700 if (SCTP_BUF_IS_EXTENDED(mat)) { 3701 sctp_log_mb(mat, SCTP_MBUF_ICOPY); 3702 } 3703 } 3704 } 3705 #endif 3706 /* easy side we just drop it on the end */ 3707 ph = mtod(mret, struct sctp_paramhdr *); 3708 SCTP_BUF_LEN(mret) = sizeof(struct sctp_state_cookie) + 3709 sizeof(struct sctp_paramhdr); 3710 stc = (struct sctp_state_cookie *)((caddr_t)ph + 3711 sizeof(struct sctp_paramhdr)); 3712 ph->param_type = htons(SCTP_STATE_COOKIE); 3713 ph->param_length = 0; /* fill in at the end */ 3714 /* Fill in the stc cookie data */ 3715 memcpy(stc, stc_in, sizeof(struct sctp_state_cookie)); 3716 3717 /* tack the INIT and then the INIT-ACK onto the chain */ 3718 cookie_sz = 0; 3719 for (m_at = mret; m_at; m_at = SCTP_BUF_NEXT(m_at)) { 3720 cookie_sz += SCTP_BUF_LEN(m_at); 3721 if (SCTP_BUF_NEXT(m_at) == NULL) { 3722 SCTP_BUF_NEXT(m_at) = copy_init; 3723 break; 3724 } 3725 } 3726 for (m_at = copy_init; m_at; m_at = SCTP_BUF_NEXT(m_at)) { 3727 cookie_sz += SCTP_BUF_LEN(m_at); 3728 if (SCTP_BUF_NEXT(m_at) == NULL) { 3729 SCTP_BUF_NEXT(m_at) = copy_initack; 3730 break; 3731 } 3732 } 3733 for (m_at = copy_initack; m_at; m_at = SCTP_BUF_NEXT(m_at)) { 3734 cookie_sz += SCTP_BUF_LEN(m_at); 3735 if (SCTP_BUF_NEXT(m_at) == NULL) { 3736 break; 3737 } 3738 } 3739 sig = sctp_get_mbuf_for_msg(SCTP_SECRET_SIZE, 0, M_DONTWAIT, 1, MT_DATA); 3740 if (sig == NULL) { 3741 /* no space, so free the entire chain */ 3742 sctp_m_freem(mret); 3743 return (NULL); 3744 } 3745 SCTP_BUF_LEN(sig) = 0; 3746 SCTP_BUF_NEXT(m_at) = sig; 3747 sig_offset = 0; 3748 foo = (uint8_t *) (mtod(sig, caddr_t)+sig_offset); 3749 memset(foo, 0, SCTP_SIGNATURE_SIZE); 3750 *signature = foo; 3751 SCTP_BUF_LEN(sig) += SCTP_SIGNATURE_SIZE; 3752 cookie_sz += SCTP_SIGNATURE_SIZE; 3753 ph->param_length = htons(cookie_sz); 3754 return (mret); 3755 } 3756 3757 3758 static uint8_t 3759 sctp_get_ect(struct sctp_tcb *stcb) 3760 { 3761 if ((stcb != NULL) && (stcb->asoc.ecn_allowed == 1)) { 3762 return (SCTP_ECT0_BIT); 3763 } else { 3764 return (0); 3765 } 3766 } 3767 3768 #if defined(INET) || defined(INET6) 3769 static void 3770 sctp_handle_no_route(struct sctp_tcb *stcb, 3771 struct sctp_nets *net, 3772 int so_locked) 3773 { 3774 SCTPDBG(SCTP_DEBUG_OUTPUT1, "dropped packet - no valid source addr\n"); 3775 3776 if (net) { 3777 SCTPDBG(SCTP_DEBUG_OUTPUT1, "Destination was "); 3778 SCTPDBG_ADDR(SCTP_DEBUG_OUTPUT1, &net->ro._l_addr.sa); 3779 if (net->dest_state & SCTP_ADDR_CONFIRMED) { 3780 if ((net->dest_state & SCTP_ADDR_REACHABLE) && stcb) { 3781 SCTPDBG(SCTP_DEBUG_OUTPUT1, "no route takes interface %p down\n", (void *)net); 3782 sctp_ulp_notify(SCTP_NOTIFY_INTERFACE_DOWN, 3783 stcb, 0, 3784 (void *)net, 3785 so_locked); 3786 net->dest_state &= ~SCTP_ADDR_REACHABLE; 3787 net->dest_state &= ~SCTP_ADDR_PF; 3788 } 3789 } 3790 if (stcb) { 3791 if (net == stcb->asoc.primary_destination) { 3792 /* need a new primary */ 3793 struct sctp_nets *alt; 3794 3795 alt = sctp_find_alternate_net(stcb, net, 0); 3796 if (alt != net) { 3797 if (stcb->asoc.alternate) { 3798 sctp_free_remote_addr(stcb->asoc.alternate); 3799 } 3800 stcb->asoc.alternate = alt; 3801 atomic_add_int(&stcb->asoc.alternate->ref_count, 1); 3802 if (net->ro._s_addr) { 3803 sctp_free_ifa(net->ro._s_addr); 3804 net->ro._s_addr = NULL; 3805 } 3806 net->src_addr_selected = 0; 3807 } 3808 } 3809 } 3810 } 3811 } 3812 3813 #endif 3814 3815 static int 3816 sctp_lowlevel_chunk_output(struct sctp_inpcb *inp, 3817 struct sctp_tcb *stcb, /* may be NULL */ 3818 struct sctp_nets *net, 3819 struct sockaddr *to, 3820 struct mbuf *m, 3821 uint32_t auth_offset, 3822 struct sctp_auth_chunk *auth, 3823 uint16_t auth_keyid, 3824 int nofragment_flag, 3825 int ecn_ok, 3826 int out_of_asoc_ok, 3827 uint16_t src_port, 3828 uint16_t dest_port, 3829 uint32_t v_tag, 3830 uint16_t port, 3831 union sctp_sockstore *over_addr, 3832 uint8_t use_mflowid, uint32_t mflowid, 3833 #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING) 3834 int so_locked SCTP_UNUSED 3835 #else 3836 int so_locked 3837 #endif 3838 ) 3839 /* nofragment_flag to tell if IP_DF should be set (IPv4 only) */ 3840 { 3841 /** 3842 * Given a mbuf chain (via SCTP_BUF_NEXT()) that holds a packet header 3843 * WITH an SCTPHDR but no IP header, endpoint inp and sa structure: 3844 * - fill in the HMAC digest of any AUTH chunk in the packet. 3845 * - calculate and fill in the SCTP checksum. 3846 * - prepend an IP address header. 3847 * - if boundall use INADDR_ANY. 3848 * - if boundspecific do source address selection. 3849 * - set fragmentation option for ipV4. 3850 * - On return from IP output, check/adjust mtu size of output 3851 * interface and smallest_mtu size as well. 3852 */ 3853 /* Will need ifdefs around this */ 3854 struct mbuf *newm; 3855 struct sctphdr *sctphdr; 3856 int packet_length; 3857 int ret; 3858 uint32_t vrf_id; 3859 3860 #if defined(INET) || defined(INET6) 3861 struct mbuf *o_pak; 3862 sctp_route_t *ro = NULL; 3863 struct udphdr *udp = NULL; 3864 3865 #endif 3866 uint8_t tos_value; 3867 3868 #if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 3869 struct socket *so = NULL; 3870 3871 #endif 3872 3873 if ((net) && (net->dest_state & SCTP_ADDR_OUT_OF_SCOPE)) { 3874 SCTP_LTRACE_ERR_RET_PKT(m, inp, stcb, net, SCTP_FROM_SCTP_OUTPUT, EFAULT); 3875 sctp_m_freem(m); 3876 return (EFAULT); 3877 } 3878 if (stcb) { 3879 vrf_id = stcb->asoc.vrf_id; 3880 } else { 3881 vrf_id = inp->def_vrf_id; 3882 } 3883 3884 /* fill in the HMAC digest for any AUTH chunk in the packet */ 3885 if ((auth != NULL) && (stcb != NULL)) { 3886 sctp_fill_hmac_digest_m(m, auth_offset, auth, stcb, auth_keyid); 3887 } 3888 if (net) { 3889 tos_value = net->dscp; 3890 } else if (stcb) { 3891 tos_value = stcb->asoc.default_dscp; 3892 } else { 3893 tos_value = inp->sctp_ep.default_dscp; 3894 } 3895 3896 switch (to->sa_family) { 3897 #ifdef INET 3898 case AF_INET: 3899 { 3900 struct ip *ip = NULL; 3901 sctp_route_t iproute; 3902 int len; 3903 3904 len = sizeof(struct ip) + sizeof(struct sctphdr); 3905 if (port) { 3906 len += sizeof(struct udphdr); 3907 } 3908 newm = sctp_get_mbuf_for_msg(len, 1, M_DONTWAIT, 1, MT_DATA); 3909 if (newm == NULL) { 3910 sctp_m_freem(m); 3911 SCTP_LTRACE_ERR_RET(inp, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, ENOMEM); 3912 return (ENOMEM); 3913 } 3914 SCTP_ALIGN_TO_END(newm, len); 3915 SCTP_BUF_LEN(newm) = len; 3916 SCTP_BUF_NEXT(newm) = m; 3917 m = newm; 3918 if (net != NULL) { 3919 #ifdef INVARIANTS 3920 if (net->flowidset == 0) { 3921 panic("Flow ID not set"); 3922 } 3923 #endif 3924 m->m_pkthdr.flowid = net->flowid; 3925 m->m_flags |= M_FLOWID; 3926 } else { 3927 if (use_mflowid != 0) { 3928 m->m_pkthdr.flowid = mflowid; 3929 m->m_flags |= M_FLOWID; 3930 } 3931 } 3932 packet_length = sctp_calculate_len(m); 3933 ip = mtod(m, struct ip *); 3934 ip->ip_v = IPVERSION; 3935 ip->ip_hl = (sizeof(struct ip) >> 2); 3936 if (tos_value == 0) { 3937 /* 3938 * This means especially, that it is not set 3939 * at the SCTP layer. So use the value from 3940 * the IP layer. 3941 */ 3942 tos_value = inp->ip_inp.inp.inp_ip_tos; 3943 } 3944 tos_value &= 0xfc; 3945 if (ecn_ok) { 3946 tos_value |= sctp_get_ect(stcb); 3947 } 3948 if ((nofragment_flag) && (port == 0)) { 3949 ip->ip_off = IP_DF; 3950 } else { 3951 ip->ip_off = 0; 3952 } 3953 /* FreeBSD has a function for ip_id's */ 3954 ip->ip_id = ip_newid(); 3955 3956 ip->ip_ttl = inp->ip_inp.inp.inp_ip_ttl; 3957 ip->ip_len = packet_length; 3958 ip->ip_tos = tos_value; 3959 if (port) { 3960 ip->ip_p = IPPROTO_UDP; 3961 } else { 3962 ip->ip_p = IPPROTO_SCTP; 3963 } 3964 ip->ip_sum = 0; 3965 if (net == NULL) { 3966 ro = &iproute; 3967 memset(&iproute, 0, sizeof(iproute)); 3968 memcpy(&ro->ro_dst, to, to->sa_len); 3969 } else { 3970 ro = (sctp_route_t *) & net->ro; 3971 } 3972 /* Now the address selection part */ 3973 ip->ip_dst.s_addr = ((struct sockaddr_in *)to)->sin_addr.s_addr; 3974 3975 /* call the routine to select the src address */ 3976 if (net && out_of_asoc_ok == 0) { 3977 if (net->ro._s_addr && (net->ro._s_addr->localifa_flags & (SCTP_BEING_DELETED | SCTP_ADDR_IFA_UNUSEABLE))) { 3978 sctp_free_ifa(net->ro._s_addr); 3979 net->ro._s_addr = NULL; 3980 net->src_addr_selected = 0; 3981 if (ro->ro_rt) { 3982 RTFREE(ro->ro_rt); 3983 ro->ro_rt = NULL; 3984 } 3985 } 3986 if (net->src_addr_selected == 0) { 3987 /* Cache the source address */ 3988 net->ro._s_addr = sctp_source_address_selection(inp, stcb, 3989 ro, net, 0, 3990 vrf_id); 3991 net->src_addr_selected = 1; 3992 } 3993 if (net->ro._s_addr == NULL) { 3994 /* No route to host */ 3995 net->src_addr_selected = 0; 3996 sctp_handle_no_route(stcb, net, so_locked); 3997 SCTP_LTRACE_ERR_RET_PKT(m, inp, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, EHOSTUNREACH); 3998 sctp_m_freem(m); 3999 return (EHOSTUNREACH); 4000 } 4001 ip->ip_src = net->ro._s_addr->address.sin.sin_addr; 4002 } else { 4003 if (over_addr == NULL) { 4004 struct sctp_ifa *_lsrc; 4005 4006 _lsrc = sctp_source_address_selection(inp, stcb, ro, 4007 net, 4008 out_of_asoc_ok, 4009 vrf_id); 4010 if (_lsrc == NULL) { 4011 sctp_handle_no_route(stcb, net, so_locked); 4012 SCTP_LTRACE_ERR_RET_PKT(m, inp, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, EHOSTUNREACH); 4013 sctp_m_freem(m); 4014 return (EHOSTUNREACH); 4015 } 4016 ip->ip_src = _lsrc->address.sin.sin_addr; 4017 sctp_free_ifa(_lsrc); 4018 } else { 4019 ip->ip_src = over_addr->sin.sin_addr; 4020 SCTP_RTALLOC(ro, vrf_id); 4021 } 4022 } 4023 if (port) { 4024 if (htons(SCTP_BASE_SYSCTL(sctp_udp_tunneling_port)) == 0) { 4025 sctp_handle_no_route(stcb, net, so_locked); 4026 SCTP_LTRACE_ERR_RET_PKT(m, inp, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, EHOSTUNREACH); 4027 sctp_m_freem(m); 4028 return (EHOSTUNREACH); 4029 } 4030 udp = (struct udphdr *)((caddr_t)ip + sizeof(struct ip)); 4031 udp->uh_sport = htons(SCTP_BASE_SYSCTL(sctp_udp_tunneling_port)); 4032 udp->uh_dport = port; 4033 udp->uh_ulen = htons(packet_length - sizeof(struct ip)); 4034 if (V_udp_cksum) { 4035 udp->uh_sum = in_pseudo(ip->ip_src.s_addr, ip->ip_dst.s_addr, udp->uh_ulen + htons(IPPROTO_UDP)); 4036 } else { 4037 udp->uh_sum = 0; 4038 } 4039 sctphdr = (struct sctphdr *)((caddr_t)udp + sizeof(struct udphdr)); 4040 } else { 4041 sctphdr = (struct sctphdr *)((caddr_t)ip + sizeof(struct ip)); 4042 } 4043 4044 sctphdr->src_port = src_port; 4045 sctphdr->dest_port = dest_port; 4046 sctphdr->v_tag = v_tag; 4047 sctphdr->checksum = 0; 4048 4049 /* 4050 * If source address selection fails and we find no 4051 * route then the ip_output should fail as well with 4052 * a NO_ROUTE_TO_HOST type error. We probably should 4053 * catch that somewhere and abort the association 4054 * right away (assuming this is an INIT being sent). 4055 */ 4056 if (ro->ro_rt == NULL) { 4057 /* 4058 * src addr selection failed to find a route 4059 * (or valid source addr), so we can't get 4060 * there from here (yet)! 4061 */ 4062 sctp_handle_no_route(stcb, net, so_locked); 4063 SCTP_LTRACE_ERR_RET_PKT(m, inp, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, EHOSTUNREACH); 4064 sctp_m_freem(m); 4065 return (EHOSTUNREACH); 4066 } 4067 if (ro != &iproute) { 4068 memcpy(&iproute, ro, sizeof(*ro)); 4069 } 4070 SCTPDBG(SCTP_DEBUG_OUTPUT3, "Calling ipv4 output routine from low level src addr:%x\n", 4071 (uint32_t) (ntohl(ip->ip_src.s_addr))); 4072 SCTPDBG(SCTP_DEBUG_OUTPUT3, "Destination is %x\n", 4073 (uint32_t) (ntohl(ip->ip_dst.s_addr))); 4074 SCTPDBG(SCTP_DEBUG_OUTPUT3, "RTP route is %p through\n", 4075 (void *)ro->ro_rt); 4076 4077 if (SCTP_GET_HEADER_FOR_OUTPUT(o_pak)) { 4078 /* failed to prepend data, give up */ 4079 SCTP_LTRACE_ERR_RET_PKT(m, inp, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, ENOMEM); 4080 sctp_m_freem(m); 4081 return (ENOMEM); 4082 } 4083 SCTP_ATTACH_CHAIN(o_pak, m, packet_length); 4084 if (port) { 4085 #if defined(SCTP_WITH_NO_CSUM) 4086 SCTP_STAT_INCR(sctps_sendnocrc); 4087 #else 4088 sctphdr->checksum = sctp_calculate_cksum(m, sizeof(struct ip) + sizeof(struct udphdr)); 4089 SCTP_STAT_INCR(sctps_sendswcrc); 4090 #endif 4091 if (V_udp_cksum) { 4092 SCTP_ENABLE_UDP_CSUM(o_pak); 4093 } 4094 } else { 4095 #if defined(SCTP_WITH_NO_CSUM) 4096 SCTP_STAT_INCR(sctps_sendnocrc); 4097 #else 4098 m->m_pkthdr.csum_flags = CSUM_SCTP; 4099 m->m_pkthdr.csum_data = 0; 4100 SCTP_STAT_INCR(sctps_sendhwcrc); 4101 #endif 4102 } 4103 #ifdef SCTP_PACKET_LOGGING 4104 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_LAST_PACKET_TRACING) 4105 sctp_packet_log(o_pak); 4106 #endif 4107 /* send it out. table id is taken from stcb */ 4108 #if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 4109 if ((SCTP_BASE_SYSCTL(sctp_output_unlocked)) && (so_locked)) { 4110 so = SCTP_INP_SO(inp); 4111 SCTP_SOCKET_UNLOCK(so, 0); 4112 } 4113 #endif 4114 SCTP_IP_OUTPUT(ret, o_pak, ro, stcb, vrf_id); 4115 #if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 4116 if ((SCTP_BASE_SYSCTL(sctp_output_unlocked)) && (so_locked)) { 4117 atomic_add_int(&stcb->asoc.refcnt, 1); 4118 SCTP_TCB_UNLOCK(stcb); 4119 SCTP_SOCKET_LOCK(so, 0); 4120 SCTP_TCB_LOCK(stcb); 4121 atomic_subtract_int(&stcb->asoc.refcnt, 1); 4122 } 4123 #endif 4124 SCTP_STAT_INCR(sctps_sendpackets); 4125 SCTP_STAT_INCR_COUNTER64(sctps_outpackets); 4126 if (ret) 4127 SCTP_STAT_INCR(sctps_senderrors); 4128 4129 SCTPDBG(SCTP_DEBUG_OUTPUT3, "IP output returns %d\n", ret); 4130 if (net == NULL) { 4131 /* free tempy routes */ 4132 RO_RTFREE(ro); 4133 } else { 4134 /* 4135 * PMTU check versus smallest asoc MTU goes 4136 * here 4137 */ 4138 if ((ro->ro_rt != NULL) && 4139 (net->ro._s_addr)) { 4140 uint32_t mtu; 4141 4142 mtu = SCTP_GATHER_MTU_FROM_ROUTE(net->ro._s_addr, &net->ro._l_addr.sa, ro->ro_rt); 4143 if (net->port) { 4144 mtu -= sizeof(struct udphdr); 4145 } 4146 if (mtu && (stcb->asoc.smallest_mtu > mtu)) { 4147 sctp_mtu_size_reset(inp, &stcb->asoc, mtu); 4148 net->mtu = mtu; 4149 } 4150 } else if (ro->ro_rt == NULL) { 4151 /* route was freed */ 4152 if (net->ro._s_addr && 4153 net->src_addr_selected) { 4154 sctp_free_ifa(net->ro._s_addr); 4155 net->ro._s_addr = NULL; 4156 } 4157 net->src_addr_selected = 0; 4158 } 4159 } 4160 return (ret); 4161 } 4162 #endif 4163 #ifdef INET6 4164 case AF_INET6: 4165 { 4166 uint32_t flowlabel, flowinfo; 4167 struct ip6_hdr *ip6h; 4168 struct route_in6 ip6route; 4169 struct ifnet *ifp; 4170 struct sockaddr_in6 *sin6, tmp, *lsa6, lsa6_tmp; 4171 int prev_scope = 0; 4172 struct sockaddr_in6 lsa6_storage; 4173 int error; 4174 u_short prev_port = 0; 4175 int len; 4176 4177 if (net) { 4178 flowlabel = net->flowlabel; 4179 } else if (stcb) { 4180 flowlabel = stcb->asoc.default_flowlabel; 4181 } else { 4182 flowlabel = inp->sctp_ep.default_flowlabel; 4183 } 4184 if (flowlabel == 0) { 4185 /* 4186 * This means especially, that it is not set 4187 * at the SCTP layer. So use the value from 4188 * the IP layer. 4189 */ 4190 flowlabel = ntohl(((struct in6pcb *)inp)->in6p_flowinfo); 4191 } 4192 flowlabel &= 0x000fffff; 4193 len = sizeof(struct ip6_hdr) + sizeof(struct sctphdr); 4194 if (port) { 4195 len += sizeof(struct udphdr); 4196 } 4197 newm = sctp_get_mbuf_for_msg(len, 1, M_DONTWAIT, 1, MT_DATA); 4198 if (newm == NULL) { 4199 sctp_m_freem(m); 4200 SCTP_LTRACE_ERR_RET(inp, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, ENOMEM); 4201 return (ENOMEM); 4202 } 4203 SCTP_ALIGN_TO_END(newm, len); 4204 SCTP_BUF_LEN(newm) = len; 4205 SCTP_BUF_NEXT(newm) = m; 4206 m = newm; 4207 if (net != NULL) { 4208 #ifdef INVARIANTS 4209 if (net->flowidset == 0) { 4210 panic("Flow ID not set"); 4211 } 4212 #endif 4213 m->m_pkthdr.flowid = net->flowid; 4214 m->m_flags |= M_FLOWID; 4215 } else { 4216 if (use_mflowid != 0) { 4217 m->m_pkthdr.flowid = mflowid; 4218 m->m_flags |= M_FLOWID; 4219 } 4220 } 4221 packet_length = sctp_calculate_len(m); 4222 4223 ip6h = mtod(m, struct ip6_hdr *); 4224 /* protect *sin6 from overwrite */ 4225 sin6 = (struct sockaddr_in6 *)to; 4226 tmp = *sin6; 4227 sin6 = &tmp; 4228 4229 /* KAME hack: embed scopeid */ 4230 if (sa6_embedscope(sin6, MODULE_GLOBAL(ip6_use_defzone)) != 0) { 4231 SCTP_LTRACE_ERR_RET_PKT(m, inp, stcb, net, SCTP_FROM_SCTP_OUTPUT, EINVAL); 4232 return (EINVAL); 4233 } 4234 if (net == NULL) { 4235 memset(&ip6route, 0, sizeof(ip6route)); 4236 ro = (sctp_route_t *) & ip6route; 4237 memcpy(&ro->ro_dst, sin6, sin6->sin6_len); 4238 } else { 4239 ro = (sctp_route_t *) & net->ro; 4240 } 4241 /* 4242 * We assume here that inp_flow is in host byte 4243 * order within the TCB! 4244 */ 4245 if (tos_value == 0) { 4246 /* 4247 * This means especially, that it is not set 4248 * at the SCTP layer. So use the value from 4249 * the IP layer. 4250 */ 4251 tos_value = (ntohl(((struct in6pcb *)inp)->in6p_flowinfo) >> 20) & 0xff; 4252 } 4253 tos_value &= 0xfc; 4254 if (ecn_ok) { 4255 tos_value |= sctp_get_ect(stcb); 4256 } 4257 flowinfo = 0x06; 4258 flowinfo <<= 8; 4259 flowinfo |= tos_value; 4260 flowinfo <<= 20; 4261 flowinfo |= flowlabel; 4262 ip6h->ip6_flow = htonl(flowinfo); 4263 if (port) { 4264 ip6h->ip6_nxt = IPPROTO_UDP; 4265 } else { 4266 ip6h->ip6_nxt = IPPROTO_SCTP; 4267 } 4268 ip6h->ip6_plen = (packet_length - sizeof(struct ip6_hdr)); 4269 ip6h->ip6_dst = sin6->sin6_addr; 4270 4271 /* 4272 * Add SRC address selection here: we can only reuse 4273 * to a limited degree the kame src-addr-sel, since 4274 * we can try their selection but it may not be 4275 * bound. 4276 */ 4277 bzero(&lsa6_tmp, sizeof(lsa6_tmp)); 4278 lsa6_tmp.sin6_family = AF_INET6; 4279 lsa6_tmp.sin6_len = sizeof(lsa6_tmp); 4280 lsa6 = &lsa6_tmp; 4281 if (net && out_of_asoc_ok == 0) { 4282 if (net->ro._s_addr && (net->ro._s_addr->localifa_flags & (SCTP_BEING_DELETED | SCTP_ADDR_IFA_UNUSEABLE))) { 4283 sctp_free_ifa(net->ro._s_addr); 4284 net->ro._s_addr = NULL; 4285 net->src_addr_selected = 0; 4286 if (ro->ro_rt) { 4287 RTFREE(ro->ro_rt); 4288 ro->ro_rt = NULL; 4289 } 4290 } 4291 if (net->src_addr_selected == 0) { 4292 sin6 = (struct sockaddr_in6 *)&net->ro._l_addr; 4293 /* KAME hack: embed scopeid */ 4294 if (sa6_embedscope(sin6, MODULE_GLOBAL(ip6_use_defzone)) != 0) { 4295 SCTP_LTRACE_ERR_RET_PKT(m, inp, stcb, net, SCTP_FROM_SCTP_OUTPUT, EINVAL); 4296 return (EINVAL); 4297 } 4298 /* Cache the source address */ 4299 net->ro._s_addr = sctp_source_address_selection(inp, 4300 stcb, 4301 ro, 4302 net, 4303 0, 4304 vrf_id); 4305 (void)sa6_recoverscope(sin6); 4306 net->src_addr_selected = 1; 4307 } 4308 if (net->ro._s_addr == NULL) { 4309 SCTPDBG(SCTP_DEBUG_OUTPUT3, "V6:No route to host\n"); 4310 net->src_addr_selected = 0; 4311 sctp_handle_no_route(stcb, net, so_locked); 4312 SCTP_LTRACE_ERR_RET_PKT(m, inp, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, EHOSTUNREACH); 4313 sctp_m_freem(m); 4314 return (EHOSTUNREACH); 4315 } 4316 lsa6->sin6_addr = net->ro._s_addr->address.sin6.sin6_addr; 4317 } else { 4318 sin6 = (struct sockaddr_in6 *)&ro->ro_dst; 4319 /* KAME hack: embed scopeid */ 4320 if (sa6_embedscope(sin6, MODULE_GLOBAL(ip6_use_defzone)) != 0) { 4321 SCTP_LTRACE_ERR_RET_PKT(m, inp, stcb, net, SCTP_FROM_SCTP_OUTPUT, EINVAL); 4322 return (EINVAL); 4323 } 4324 if (over_addr == NULL) { 4325 struct sctp_ifa *_lsrc; 4326 4327 _lsrc = sctp_source_address_selection(inp, stcb, ro, 4328 net, 4329 out_of_asoc_ok, 4330 vrf_id); 4331 if (_lsrc == NULL) { 4332 sctp_handle_no_route(stcb, net, so_locked); 4333 SCTP_LTRACE_ERR_RET_PKT(m, inp, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, EHOSTUNREACH); 4334 sctp_m_freem(m); 4335 return (EHOSTUNREACH); 4336 } 4337 lsa6->sin6_addr = _lsrc->address.sin6.sin6_addr; 4338 sctp_free_ifa(_lsrc); 4339 } else { 4340 lsa6->sin6_addr = over_addr->sin6.sin6_addr; 4341 SCTP_RTALLOC(ro, vrf_id); 4342 } 4343 (void)sa6_recoverscope(sin6); 4344 } 4345 lsa6->sin6_port = inp->sctp_lport; 4346 4347 if (ro->ro_rt == NULL) { 4348 /* 4349 * src addr selection failed to find a route 4350 * (or valid source addr), so we can't get 4351 * there from here! 4352 */ 4353 sctp_handle_no_route(stcb, net, so_locked); 4354 SCTP_LTRACE_ERR_RET_PKT(m, inp, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, EHOSTUNREACH); 4355 sctp_m_freem(m); 4356 return (EHOSTUNREACH); 4357 } 4358 /* 4359 * XXX: sa6 may not have a valid sin6_scope_id in 4360 * the non-SCOPEDROUTING case. 4361 */ 4362 bzero(&lsa6_storage, sizeof(lsa6_storage)); 4363 lsa6_storage.sin6_family = AF_INET6; 4364 lsa6_storage.sin6_len = sizeof(lsa6_storage); 4365 lsa6_storage.sin6_addr = lsa6->sin6_addr; 4366 if ((error = sa6_recoverscope(&lsa6_storage)) != 0) { 4367 SCTPDBG(SCTP_DEBUG_OUTPUT3, "recover scope fails error %d\n", error); 4368 sctp_m_freem(m); 4369 return (error); 4370 } 4371 /* XXX */ 4372 lsa6_storage.sin6_addr = lsa6->sin6_addr; 4373 lsa6_storage.sin6_port = inp->sctp_lport; 4374 lsa6 = &lsa6_storage; 4375 ip6h->ip6_src = lsa6->sin6_addr; 4376 4377 if (port) { 4378 if (htons(SCTP_BASE_SYSCTL(sctp_udp_tunneling_port)) == 0) { 4379 sctp_handle_no_route(stcb, net, so_locked); 4380 SCTP_LTRACE_ERR_RET_PKT(m, inp, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, EHOSTUNREACH); 4381 sctp_m_freem(m); 4382 return (EHOSTUNREACH); 4383 } 4384 udp = (struct udphdr *)((caddr_t)ip6h + sizeof(struct ip6_hdr)); 4385 udp->uh_sport = htons(SCTP_BASE_SYSCTL(sctp_udp_tunneling_port)); 4386 udp->uh_dport = port; 4387 udp->uh_ulen = htons(packet_length - sizeof(struct ip6_hdr)); 4388 udp->uh_sum = 0; 4389 sctphdr = (struct sctphdr *)((caddr_t)udp + sizeof(struct udphdr)); 4390 } else { 4391 sctphdr = (struct sctphdr *)((caddr_t)ip6h + sizeof(struct ip6_hdr)); 4392 } 4393 4394 sctphdr->src_port = src_port; 4395 sctphdr->dest_port = dest_port; 4396 sctphdr->v_tag = v_tag; 4397 sctphdr->checksum = 0; 4398 4399 /* 4400 * We set the hop limit now since there is a good 4401 * chance that our ro pointer is now filled 4402 */ 4403 ip6h->ip6_hlim = SCTP_GET_HLIM(inp, ro); 4404 ifp = SCTP_GET_IFN_VOID_FROM_ROUTE(ro); 4405 4406 #ifdef SCTP_DEBUG 4407 /* Copy to be sure something bad is not happening */ 4408 sin6->sin6_addr = ip6h->ip6_dst; 4409 lsa6->sin6_addr = ip6h->ip6_src; 4410 #endif 4411 4412 SCTPDBG(SCTP_DEBUG_OUTPUT3, "Calling ipv6 output routine from low level\n"); 4413 SCTPDBG(SCTP_DEBUG_OUTPUT3, "src: "); 4414 SCTPDBG_ADDR(SCTP_DEBUG_OUTPUT3, (struct sockaddr *)lsa6); 4415 SCTPDBG(SCTP_DEBUG_OUTPUT3, "dst: "); 4416 SCTPDBG_ADDR(SCTP_DEBUG_OUTPUT3, (struct sockaddr *)sin6); 4417 if (net) { 4418 sin6 = (struct sockaddr_in6 *)&net->ro._l_addr; 4419 /* 4420 * preserve the port and scope for link 4421 * local send 4422 */ 4423 prev_scope = sin6->sin6_scope_id; 4424 prev_port = sin6->sin6_port; 4425 } 4426 if (SCTP_GET_HEADER_FOR_OUTPUT(o_pak)) { 4427 /* failed to prepend data, give up */ 4428 sctp_m_freem(m); 4429 SCTP_LTRACE_ERR_RET(inp, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, ENOMEM); 4430 return (ENOMEM); 4431 } 4432 SCTP_ATTACH_CHAIN(o_pak, m, packet_length); 4433 if (port) { 4434 #if defined(SCTP_WITH_NO_CSUM) 4435 SCTP_STAT_INCR(sctps_sendnocrc); 4436 #else 4437 sctphdr->checksum = sctp_calculate_cksum(m, sizeof(struct ip6_hdr) + sizeof(struct udphdr)); 4438 SCTP_STAT_INCR(sctps_sendswcrc); 4439 #endif 4440 if ((udp->uh_sum = in6_cksum(o_pak, IPPROTO_UDP, sizeof(struct ip6_hdr), packet_length - sizeof(struct ip6_hdr))) == 0) { 4441 udp->uh_sum = 0xffff; 4442 } 4443 } else { 4444 #if defined(SCTP_WITH_NO_CSUM) 4445 SCTP_STAT_INCR(sctps_sendnocrc); 4446 #else 4447 m->m_pkthdr.csum_flags = CSUM_SCTP_IPV6; 4448 m->m_pkthdr.csum_data = 0; 4449 SCTP_STAT_INCR(sctps_sendhwcrc); 4450 #endif 4451 } 4452 /* send it out. table id is taken from stcb */ 4453 #if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 4454 if ((SCTP_BASE_SYSCTL(sctp_output_unlocked)) && (so_locked)) { 4455 so = SCTP_INP_SO(inp); 4456 SCTP_SOCKET_UNLOCK(so, 0); 4457 } 4458 #endif 4459 #ifdef SCTP_PACKET_LOGGING 4460 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_LAST_PACKET_TRACING) 4461 sctp_packet_log(o_pak); 4462 #endif 4463 SCTP_IP6_OUTPUT(ret, o_pak, (struct route_in6 *)ro, &ifp, stcb, vrf_id); 4464 #if defined(__APPLE__) || defined(SCTP_SO_LOCK_TESTING) 4465 if ((SCTP_BASE_SYSCTL(sctp_output_unlocked)) && (so_locked)) { 4466 atomic_add_int(&stcb->asoc.refcnt, 1); 4467 SCTP_TCB_UNLOCK(stcb); 4468 SCTP_SOCKET_LOCK(so, 0); 4469 SCTP_TCB_LOCK(stcb); 4470 atomic_subtract_int(&stcb->asoc.refcnt, 1); 4471 } 4472 #endif 4473 if (net) { 4474 /* for link local this must be done */ 4475 sin6->sin6_scope_id = prev_scope; 4476 sin6->sin6_port = prev_port; 4477 } 4478 SCTPDBG(SCTP_DEBUG_OUTPUT3, "return from send is %d\n", ret); 4479 SCTP_STAT_INCR(sctps_sendpackets); 4480 SCTP_STAT_INCR_COUNTER64(sctps_outpackets); 4481 if (ret) { 4482 SCTP_STAT_INCR(sctps_senderrors); 4483 } 4484 if (net == NULL) { 4485 /* Now if we had a temp route free it */ 4486 RO_RTFREE(ro); 4487 } else { 4488 /* 4489 * PMTU check versus smallest asoc MTU goes 4490 * here 4491 */ 4492 if (ro->ro_rt == NULL) { 4493 /* Route was freed */ 4494 if (net->ro._s_addr && 4495 net->src_addr_selected) { 4496 sctp_free_ifa(net->ro._s_addr); 4497 net->ro._s_addr = NULL; 4498 } 4499 net->src_addr_selected = 0; 4500 } 4501 if ((ro->ro_rt != NULL) && 4502 (net->ro._s_addr)) { 4503 uint32_t mtu; 4504 4505 mtu = SCTP_GATHER_MTU_FROM_ROUTE(net->ro._s_addr, &net->ro._l_addr.sa, ro->ro_rt); 4506 if (mtu && 4507 (stcb->asoc.smallest_mtu > mtu)) { 4508 sctp_mtu_size_reset(inp, &stcb->asoc, mtu); 4509 net->mtu = mtu; 4510 if (net->port) { 4511 net->mtu -= sizeof(struct udphdr); 4512 } 4513 } 4514 } else if (ifp) { 4515 if (ND_IFINFO(ifp)->linkmtu && 4516 (stcb->asoc.smallest_mtu > ND_IFINFO(ifp)->linkmtu)) { 4517 sctp_mtu_size_reset(inp, 4518 &stcb->asoc, 4519 ND_IFINFO(ifp)->linkmtu); 4520 } 4521 } 4522 } 4523 return (ret); 4524 } 4525 #endif 4526 default: 4527 SCTPDBG(SCTP_DEBUG_OUTPUT1, "Unknown protocol (TSNH) type %d\n", 4528 ((struct sockaddr *)to)->sa_family); 4529 sctp_m_freem(m); 4530 SCTP_LTRACE_ERR_RET_PKT(m, inp, stcb, net, SCTP_FROM_SCTP_OUTPUT, EFAULT); 4531 return (EFAULT); 4532 } 4533 } 4534 4535 4536 void 4537 sctp_send_initiate(struct sctp_inpcb *inp, struct sctp_tcb *stcb, int so_locked 4538 #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING) 4539 SCTP_UNUSED 4540 #endif 4541 ) 4542 { 4543 struct mbuf *m; 4544 struct sctp_nets *net; 4545 struct sctp_init_chunk *init; 4546 4547 #if defined(INET) || defined(INET6) 4548 struct sctp_supported_addr_param *sup_addr; 4549 4550 #endif 4551 struct sctp_adaptation_layer_indication *ali; 4552 struct sctp_supported_chunk_types_param *pr_supported; 4553 struct sctp_paramhdr *ph; 4554 int cnt_inits_to = 0; 4555 int ret; 4556 uint16_t num_ext, chunk_len, padding_len, parameter_len; 4557 4558 /* INIT's always go to the primary (and usually ONLY address) */ 4559 net = stcb->asoc.primary_destination; 4560 if (net == NULL) { 4561 net = TAILQ_FIRST(&stcb->asoc.nets); 4562 if (net == NULL) { 4563 /* TSNH */ 4564 return; 4565 } 4566 /* we confirm any address we send an INIT to */ 4567 net->dest_state &= ~SCTP_ADDR_UNCONFIRMED; 4568 (void)sctp_set_primary_addr(stcb, NULL, net); 4569 } else { 4570 /* we confirm any address we send an INIT to */ 4571 net->dest_state &= ~SCTP_ADDR_UNCONFIRMED; 4572 } 4573 SCTPDBG(SCTP_DEBUG_OUTPUT4, "Sending INIT\n"); 4574 #ifdef INET6 4575 if (net->ro._l_addr.sa.sa_family == AF_INET6) { 4576 /* 4577 * special hook, if we are sending to link local it will not 4578 * show up in our private address count. 4579 */ 4580 if (IN6_IS_ADDR_LINKLOCAL(&net->ro._l_addr.sin6.sin6_addr)) 4581 cnt_inits_to = 1; 4582 } 4583 #endif 4584 if (SCTP_OS_TIMER_PENDING(&net->rxt_timer.timer)) { 4585 /* This case should not happen */ 4586 SCTPDBG(SCTP_DEBUG_OUTPUT4, "Sending INIT - failed timer?\n"); 4587 return; 4588 } 4589 /* start the INIT timer */ 4590 sctp_timer_start(SCTP_TIMER_TYPE_INIT, inp, stcb, net); 4591 4592 m = sctp_get_mbuf_for_msg(MCLBYTES, 1, M_DONTWAIT, 1, MT_DATA); 4593 if (m == NULL) { 4594 /* No memory, INIT timer will re-attempt. */ 4595 SCTPDBG(SCTP_DEBUG_OUTPUT4, "Sending INIT - mbuf?\n"); 4596 return; 4597 } 4598 chunk_len = (uint16_t) sizeof(struct sctp_init_chunk); 4599 padding_len = 0; 4600 /* 4601 * assume peer supports asconf in order to be able to queue local 4602 * address changes while an INIT is in flight and before the assoc 4603 * is established. 4604 */ 4605 stcb->asoc.peer_supports_asconf = 1; 4606 /* Now lets put the chunk header in place */ 4607 init = mtod(m, struct sctp_init_chunk *); 4608 /* now the chunk header */ 4609 init->ch.chunk_type = SCTP_INITIATION; 4610 init->ch.chunk_flags = 0; 4611 /* fill in later from mbuf we build */ 4612 init->ch.chunk_length = 0; 4613 /* place in my tag */ 4614 init->init.initiate_tag = htonl(stcb->asoc.my_vtag); 4615 /* set up some of the credits. */ 4616 init->init.a_rwnd = htonl(max(inp->sctp_socket ? SCTP_SB_LIMIT_RCV(inp->sctp_socket) : 0, 4617 SCTP_MINIMAL_RWND)); 4618 init->init.num_outbound_streams = htons(stcb->asoc.pre_open_streams); 4619 init->init.num_inbound_streams = htons(stcb->asoc.max_inbound_streams); 4620 init->init.initial_tsn = htonl(stcb->asoc.init_seq_number); 4621 4622 if (stcb->asoc.scope.ipv4_addr_legal || stcb->asoc.scope.ipv6_addr_legal) { 4623 uint8_t i; 4624 4625 parameter_len = (uint16_t) sizeof(struct sctp_paramhdr); 4626 if (stcb->asoc.scope.ipv4_addr_legal) { 4627 parameter_len += (uint16_t) sizeof(uint16_t); 4628 } 4629 if (stcb->asoc.scope.ipv6_addr_legal) { 4630 parameter_len += (uint16_t) sizeof(uint16_t); 4631 } 4632 sup_addr = (struct sctp_supported_addr_param *)(mtod(m, caddr_t)+chunk_len); 4633 sup_addr->ph.param_type = htons(SCTP_SUPPORTED_ADDRTYPE); 4634 sup_addr->ph.param_length = htons(parameter_len); 4635 i = 0; 4636 if (stcb->asoc.scope.ipv4_addr_legal) { 4637 sup_addr->addr_type[i++] = htons(SCTP_IPV4_ADDRESS); 4638 } 4639 if (stcb->asoc.scope.ipv6_addr_legal) { 4640 sup_addr->addr_type[i++] = htons(SCTP_IPV6_ADDRESS); 4641 } 4642 padding_len = 4 - 2 * i; 4643 chunk_len += parameter_len; 4644 } 4645 /* Adaptation layer indication parameter */ 4646 if (inp->sctp_ep.adaptation_layer_indicator_provided) { 4647 if (padding_len > 0) { 4648 memset(mtod(m, caddr_t)+chunk_len, 0, padding_len); 4649 chunk_len += padding_len; 4650 padding_len = 0; 4651 } 4652 parameter_len = (uint16_t) sizeof(struct sctp_adaptation_layer_indication); 4653 ali = (struct sctp_adaptation_layer_indication *)(mtod(m, caddr_t)+chunk_len); 4654 ali->ph.param_type = htons(SCTP_ULP_ADAPTATION); 4655 ali->ph.param_length = htons(parameter_len); 4656 ali->indication = ntohl(inp->sctp_ep.adaptation_layer_indicator); 4657 chunk_len += parameter_len; 4658 } 4659 if (SCTP_BASE_SYSCTL(sctp_inits_include_nat_friendly)) { 4660 /* Add NAT friendly parameter. */ 4661 if (padding_len > 0) { 4662 memset(mtod(m, caddr_t)+chunk_len, 0, padding_len); 4663 chunk_len += padding_len; 4664 padding_len = 0; 4665 } 4666 parameter_len = (uint16_t) sizeof(struct sctp_paramhdr); 4667 ph = (struct sctp_paramhdr *)(mtod(m, caddr_t)+chunk_len); 4668 ph->param_type = htons(SCTP_HAS_NAT_SUPPORT); 4669 ph->param_length = htons(parameter_len); 4670 chunk_len += parameter_len; 4671 } 4672 /* now any cookie time extensions */ 4673 if (stcb->asoc.cookie_preserve_req) { 4674 struct sctp_cookie_perserve_param *cookie_preserve; 4675 4676 if (padding_len > 0) { 4677 memset(mtod(m, caddr_t)+chunk_len, 0, padding_len); 4678 chunk_len += padding_len; 4679 padding_len = 0; 4680 } 4681 parameter_len = (uint16_t) sizeof(struct sctp_cookie_perserve_param); 4682 cookie_preserve = (struct sctp_cookie_perserve_param *)(mtod(m, caddr_t)+chunk_len); 4683 cookie_preserve->ph.param_type = htons(SCTP_COOKIE_PRESERVE); 4684 cookie_preserve->ph.param_length = htons(parameter_len); 4685 cookie_preserve->time = htonl(stcb->asoc.cookie_preserve_req); 4686 stcb->asoc.cookie_preserve_req = 0; 4687 chunk_len += parameter_len; 4688 } 4689 /* ECN parameter */ 4690 if (stcb->asoc.ecn_allowed == 1) { 4691 if (padding_len > 0) { 4692 memset(mtod(m, caddr_t)+chunk_len, 0, padding_len); 4693 chunk_len += padding_len; 4694 padding_len = 0; 4695 } 4696 parameter_len = (uint16_t) sizeof(struct sctp_paramhdr); 4697 ph = (struct sctp_paramhdr *)(mtod(m, caddr_t)+chunk_len); 4698 ph->param_type = htons(SCTP_ECN_CAPABLE); 4699 ph->param_length = htons(parameter_len); 4700 chunk_len += parameter_len; 4701 } 4702 /* And now tell the peer we do support PR-SCTP. */ 4703 if (padding_len > 0) { 4704 memset(mtod(m, caddr_t)+chunk_len, 0, padding_len); 4705 chunk_len += padding_len; 4706 padding_len = 0; 4707 } 4708 parameter_len = (uint16_t) sizeof(struct sctp_paramhdr); 4709 ph = (struct sctp_paramhdr *)(mtod(m, caddr_t)+chunk_len); 4710 ph->param_type = htons(SCTP_PRSCTP_SUPPORTED); 4711 ph->param_length = htons(parameter_len); 4712 chunk_len += parameter_len; 4713 4714 /* And now tell the peer we do all the extensions */ 4715 pr_supported = (struct sctp_supported_chunk_types_param *)(mtod(m, caddr_t)+chunk_len); 4716 pr_supported->ph.param_type = htons(SCTP_SUPPORTED_CHUNK_EXT); 4717 num_ext = 0; 4718 pr_supported->chunk_types[num_ext++] = SCTP_ASCONF; 4719 pr_supported->chunk_types[num_ext++] = SCTP_ASCONF_ACK; 4720 pr_supported->chunk_types[num_ext++] = SCTP_FORWARD_CUM_TSN; 4721 pr_supported->chunk_types[num_ext++] = SCTP_PACKET_DROPPED; 4722 pr_supported->chunk_types[num_ext++] = SCTP_STREAM_RESET; 4723 if (!SCTP_BASE_SYSCTL(sctp_auth_disable)) { 4724 pr_supported->chunk_types[num_ext++] = SCTP_AUTHENTICATION; 4725 } 4726 if (stcb->asoc.sctp_nr_sack_on_off == 1) { 4727 pr_supported->chunk_types[num_ext++] = SCTP_NR_SELECTIVE_ACK; 4728 } 4729 parameter_len = (uint16_t) sizeof(struct sctp_supported_chunk_types_param) + num_ext; 4730 pr_supported->ph.param_length = htons(parameter_len); 4731 padding_len = SCTP_SIZE32(parameter_len) - parameter_len; 4732 chunk_len += parameter_len; 4733 4734 /* add authentication parameters */ 4735 if (!SCTP_BASE_SYSCTL(sctp_auth_disable)) { 4736 /* attach RANDOM parameter, if available */ 4737 if (stcb->asoc.authinfo.random != NULL) { 4738 struct sctp_auth_random *randp; 4739 4740 if (padding_len > 0) { 4741 memset(mtod(m, caddr_t)+chunk_len, 0, padding_len); 4742 chunk_len += padding_len; 4743 padding_len = 0; 4744 } 4745 randp = (struct sctp_auth_random *)(mtod(m, caddr_t)+chunk_len); 4746 parameter_len = (uint16_t) sizeof(struct sctp_auth_random) + stcb->asoc.authinfo.random_len; 4747 /* random key already contains the header */ 4748 memcpy(randp, stcb->asoc.authinfo.random->key, parameter_len); 4749 padding_len = SCTP_SIZE32(parameter_len) - parameter_len; 4750 chunk_len += parameter_len; 4751 } 4752 /* add HMAC_ALGO parameter */ 4753 if ((stcb->asoc.local_hmacs != NULL) && 4754 (stcb->asoc.local_hmacs->num_algo > 0)) { 4755 struct sctp_auth_hmac_algo *hmacs; 4756 4757 if (padding_len > 0) { 4758 memset(mtod(m, caddr_t)+chunk_len, 0, padding_len); 4759 chunk_len += padding_len; 4760 padding_len = 0; 4761 } 4762 hmacs = (struct sctp_auth_hmac_algo *)(mtod(m, caddr_t)+chunk_len); 4763 parameter_len = (uint16_t) (sizeof(struct sctp_auth_hmac_algo) + 4764 stcb->asoc.local_hmacs->num_algo * sizeof(uint16_t)); 4765 hmacs->ph.param_type = htons(SCTP_HMAC_LIST); 4766 hmacs->ph.param_length = htons(parameter_len); 4767 sctp_serialize_hmaclist(stcb->asoc.local_hmacs, (uint8_t *) hmacs->hmac_ids); 4768 padding_len = SCTP_SIZE32(parameter_len) - parameter_len; 4769 chunk_len += parameter_len; 4770 } 4771 /* add CHUNKS parameter */ 4772 if (sctp_auth_get_chklist_size(stcb->asoc.local_auth_chunks) > 0) { 4773 struct sctp_auth_chunk_list *chunks; 4774 4775 if (padding_len > 0) { 4776 memset(mtod(m, caddr_t)+chunk_len, 0, padding_len); 4777 chunk_len += padding_len; 4778 padding_len = 0; 4779 } 4780 chunks = (struct sctp_auth_chunk_list *)(mtod(m, caddr_t)+chunk_len); 4781 parameter_len = (uint16_t) (sizeof(struct sctp_auth_chunk_list) + 4782 sctp_auth_get_chklist_size(stcb->asoc.local_auth_chunks)); 4783 chunks->ph.param_type = htons(SCTP_CHUNK_LIST); 4784 chunks->ph.param_length = htons(parameter_len); 4785 sctp_serialize_auth_chunks(stcb->asoc.local_auth_chunks, chunks->chunk_types); 4786 padding_len = SCTP_SIZE32(parameter_len) - parameter_len; 4787 chunk_len += parameter_len; 4788 } 4789 } 4790 SCTP_BUF_LEN(m) = chunk_len; 4791 4792 /* now the addresses */ 4793 /* 4794 * To optimize this we could put the scoping stuff into a structure 4795 * and remove the individual uint8's from the assoc structure. Then 4796 * we could just sifa in the address within the stcb. But for now 4797 * this is a quick hack to get the address stuff teased apart. 4798 */ 4799 sctp_add_addresses_to_i_ia(inp, stcb, &stcb->asoc.scope, m, cnt_inits_to, &padding_len, &chunk_len); 4800 4801 init->ch.chunk_length = htons(chunk_len); 4802 if (padding_len > 0) { 4803 struct mbuf *m_at, *mp_last; 4804 4805 mp_last = NULL; 4806 for (m_at = m; m_at; m_at = SCTP_BUF_NEXT(m_at)) { 4807 if (SCTP_BUF_NEXT(m_at) == NULL) 4808 mp_last = m_at; 4809 } 4810 if ((mp_last == NULL) || sctp_add_pad_tombuf(mp_last, padding_len)) { 4811 sctp_m_freem(m); 4812 return; 4813 } 4814 } 4815 SCTPDBG(SCTP_DEBUG_OUTPUT4, "Sending INIT - calls lowlevel_output\n"); 4816 ret = sctp_lowlevel_chunk_output(inp, stcb, net, 4817 (struct sockaddr *)&net->ro._l_addr, 4818 m, 0, NULL, 0, 0, 0, 0, 4819 inp->sctp_lport, stcb->rport, htonl(0), 4820 net->port, NULL, 4821 0, 0, 4822 so_locked); 4823 SCTPDBG(SCTP_DEBUG_OUTPUT4, "lowlevel_output - %d\n", ret); 4824 SCTP_STAT_INCR_COUNTER64(sctps_outcontrolchunks); 4825 (void)SCTP_GETTIME_TIMEVAL(&net->last_sent_time); 4826 } 4827 4828 struct mbuf * 4829 sctp_arethere_unrecognized_parameters(struct mbuf *in_initpkt, 4830 int param_offset, int *abort_processing, struct sctp_chunkhdr *cp, int *nat_friendly) 4831 { 4832 /* 4833 * Given a mbuf containing an INIT or INIT-ACK with the param_offset 4834 * being equal to the beginning of the params i.e. (iphlen + 4835 * sizeof(struct sctp_init_msg) parse through the parameters to the 4836 * end of the mbuf verifying that all parameters are known. 4837 * 4838 * For unknown parameters build and return a mbuf with 4839 * UNRECOGNIZED_PARAMETER errors. If the flags indicate to stop 4840 * processing this chunk stop, and set *abort_processing to 1. 4841 * 4842 * By having param_offset be pre-set to where parameters begin it is 4843 * hoped that this routine may be reused in the future by new 4844 * features. 4845 */ 4846 struct sctp_paramhdr *phdr, params; 4847 4848 struct mbuf *mat, *op_err; 4849 char tempbuf[SCTP_PARAM_BUFFER_SIZE]; 4850 int at, limit, pad_needed; 4851 uint16_t ptype, plen, padded_size; 4852 int err_at; 4853 4854 *abort_processing = 0; 4855 mat = in_initpkt; 4856 err_at = 0; 4857 limit = ntohs(cp->chunk_length) - sizeof(struct sctp_init_chunk); 4858 at = param_offset; 4859 op_err = NULL; 4860 SCTPDBG(SCTP_DEBUG_OUTPUT1, "Check for unrecognized param's\n"); 4861 phdr = sctp_get_next_param(mat, at, ¶ms, sizeof(params)); 4862 while ((phdr != NULL) && ((size_t)limit >= sizeof(struct sctp_paramhdr))) { 4863 ptype = ntohs(phdr->param_type); 4864 plen = ntohs(phdr->param_length); 4865 if ((plen > limit) || (plen < sizeof(struct sctp_paramhdr))) { 4866 /* wacked parameter */ 4867 SCTPDBG(SCTP_DEBUG_OUTPUT1, "Invalid size - error %d\n", plen); 4868 goto invalid_size; 4869 } 4870 limit -= SCTP_SIZE32(plen); 4871 /*- 4872 * All parameters for all chunks that we know/understand are 4873 * listed here. We process them other places and make 4874 * appropriate stop actions per the upper bits. However this 4875 * is the generic routine processor's can call to get back 4876 * an operr.. to either incorporate (init-ack) or send. 4877 */ 4878 padded_size = SCTP_SIZE32(plen); 4879 switch (ptype) { 4880 /* Param's with variable size */ 4881 case SCTP_HEARTBEAT_INFO: 4882 case SCTP_STATE_COOKIE: 4883 case SCTP_UNRECOG_PARAM: 4884 case SCTP_ERROR_CAUSE_IND: 4885 /* ok skip fwd */ 4886 at += padded_size; 4887 break; 4888 /* Param's with variable size within a range */ 4889 case SCTP_CHUNK_LIST: 4890 case SCTP_SUPPORTED_CHUNK_EXT: 4891 if (padded_size > (sizeof(struct sctp_supported_chunk_types_param) + (sizeof(uint8_t) * SCTP_MAX_SUPPORTED_EXT))) { 4892 SCTPDBG(SCTP_DEBUG_OUTPUT1, "Invalid size - error chklist %d\n", plen); 4893 goto invalid_size; 4894 } 4895 at += padded_size; 4896 break; 4897 case SCTP_SUPPORTED_ADDRTYPE: 4898 if (padded_size > SCTP_MAX_ADDR_PARAMS_SIZE) { 4899 SCTPDBG(SCTP_DEBUG_OUTPUT1, "Invalid size - error supaddrtype %d\n", plen); 4900 goto invalid_size; 4901 } 4902 at += padded_size; 4903 break; 4904 case SCTP_RANDOM: 4905 if (padded_size > (sizeof(struct sctp_auth_random) + SCTP_RANDOM_MAX_SIZE)) { 4906 SCTPDBG(SCTP_DEBUG_OUTPUT1, "Invalid size - error random %d\n", plen); 4907 goto invalid_size; 4908 } 4909 at += padded_size; 4910 break; 4911 case SCTP_SET_PRIM_ADDR: 4912 case SCTP_DEL_IP_ADDRESS: 4913 case SCTP_ADD_IP_ADDRESS: 4914 if ((padded_size != sizeof(struct sctp_asconf_addrv4_param)) && 4915 (padded_size != sizeof(struct sctp_asconf_addr_param))) { 4916 SCTPDBG(SCTP_DEBUG_OUTPUT1, "Invalid size - error setprim %d\n", plen); 4917 goto invalid_size; 4918 } 4919 at += padded_size; 4920 break; 4921 /* Param's with a fixed size */ 4922 case SCTP_IPV4_ADDRESS: 4923 if (padded_size != sizeof(struct sctp_ipv4addr_param)) { 4924 SCTPDBG(SCTP_DEBUG_OUTPUT1, "Invalid size - error ipv4 addr %d\n", plen); 4925 goto invalid_size; 4926 } 4927 at += padded_size; 4928 break; 4929 case SCTP_IPV6_ADDRESS: 4930 if (padded_size != sizeof(struct sctp_ipv6addr_param)) { 4931 SCTPDBG(SCTP_DEBUG_OUTPUT1, "Invalid size - error ipv6 addr %d\n", plen); 4932 goto invalid_size; 4933 } 4934 at += padded_size; 4935 break; 4936 case SCTP_COOKIE_PRESERVE: 4937 if (padded_size != sizeof(struct sctp_cookie_perserve_param)) { 4938 SCTPDBG(SCTP_DEBUG_OUTPUT1, "Invalid size - error cookie-preserve %d\n", plen); 4939 goto invalid_size; 4940 } 4941 at += padded_size; 4942 break; 4943 case SCTP_HAS_NAT_SUPPORT: 4944 *nat_friendly = 1; 4945 /* fall through */ 4946 case SCTP_PRSCTP_SUPPORTED: 4947 4948 if (padded_size != sizeof(struct sctp_paramhdr)) { 4949 SCTPDBG(SCTP_DEBUG_OUTPUT1, "Invalid size - error prsctp/nat support %d\n", plen); 4950 goto invalid_size; 4951 } 4952 at += padded_size; 4953 break; 4954 case SCTP_ECN_CAPABLE: 4955 if (padded_size != sizeof(struct sctp_ecn_supported_param)) { 4956 SCTPDBG(SCTP_DEBUG_OUTPUT1, "Invalid size - error ecn %d\n", plen); 4957 goto invalid_size; 4958 } 4959 at += padded_size; 4960 break; 4961 case SCTP_ULP_ADAPTATION: 4962 if (padded_size != sizeof(struct sctp_adaptation_layer_indication)) { 4963 SCTPDBG(SCTP_DEBUG_OUTPUT1, "Invalid size - error adapatation %d\n", plen); 4964 goto invalid_size; 4965 } 4966 at += padded_size; 4967 break; 4968 case SCTP_SUCCESS_REPORT: 4969 if (padded_size != sizeof(struct sctp_asconf_paramhdr)) { 4970 SCTPDBG(SCTP_DEBUG_OUTPUT1, "Invalid size - error success %d\n", plen); 4971 goto invalid_size; 4972 } 4973 at += padded_size; 4974 break; 4975 case SCTP_HOSTNAME_ADDRESS: 4976 { 4977 /* We can NOT handle HOST NAME addresses!! */ 4978 int l_len; 4979 4980 SCTPDBG(SCTP_DEBUG_OUTPUT1, "Can't handle hostname addresses.. abort processing\n"); 4981 *abort_processing = 1; 4982 if (op_err == NULL) { 4983 /* Ok need to try to get a mbuf */ 4984 #ifdef INET6 4985 l_len = sizeof(struct ip6_hdr) + sizeof(struct sctphdr) + sizeof(struct sctp_chunkhdr); 4986 #else 4987 l_len = sizeof(struct ip) + sizeof(struct sctphdr) + sizeof(struct sctp_chunkhdr); 4988 #endif 4989 l_len += plen; 4990 l_len += sizeof(struct sctp_paramhdr); 4991 op_err = sctp_get_mbuf_for_msg(l_len, 0, M_DONTWAIT, 1, MT_DATA); 4992 if (op_err) { 4993 SCTP_BUF_LEN(op_err) = 0; 4994 /* 4995 * pre-reserve space for ip 4996 * and sctp header and 4997 * chunk hdr 4998 */ 4999 #ifdef INET6 5000 SCTP_BUF_RESV_UF(op_err, sizeof(struct ip6_hdr)); 5001 #else 5002 SCTP_BUF_RESV_UF(op_err, sizeof(struct ip)); 5003 #endif 5004 SCTP_BUF_RESV_UF(op_err, sizeof(struct sctphdr)); 5005 SCTP_BUF_RESV_UF(op_err, sizeof(struct sctp_chunkhdr)); 5006 } 5007 } 5008 if (op_err) { 5009 /* If we have space */ 5010 struct sctp_paramhdr s; 5011 5012 if (err_at % 4) { 5013 uint32_t cpthis = 0; 5014 5015 pad_needed = 4 - (err_at % 4); 5016 m_copyback(op_err, err_at, pad_needed, (caddr_t)&cpthis); 5017 err_at += pad_needed; 5018 } 5019 s.param_type = htons(SCTP_CAUSE_UNRESOLVABLE_ADDR); 5020 s.param_length = htons(sizeof(s) + plen); 5021 m_copyback(op_err, err_at, sizeof(s), (caddr_t)&s); 5022 err_at += sizeof(s); 5023 phdr = sctp_get_next_param(mat, at, (struct sctp_paramhdr *)tempbuf, min(sizeof(tempbuf), plen)); 5024 if (phdr == NULL) { 5025 sctp_m_freem(op_err); 5026 /* 5027 * we are out of memory but 5028 * we still need to have a 5029 * look at what to do (the 5030 * system is in trouble 5031 * though). 5032 */ 5033 return (NULL); 5034 } 5035 m_copyback(op_err, err_at, plen, (caddr_t)phdr); 5036 } 5037 return (op_err); 5038 break; 5039 } 5040 default: 5041 /* 5042 * we do not recognize the parameter figure out what 5043 * we do. 5044 */ 5045 SCTPDBG(SCTP_DEBUG_OUTPUT1, "Hit default param %x\n", ptype); 5046 if ((ptype & 0x4000) == 0x4000) { 5047 /* Report bit is set?? */ 5048 SCTPDBG(SCTP_DEBUG_OUTPUT1, "report op err\n"); 5049 if (op_err == NULL) { 5050 int l_len; 5051 5052 /* Ok need to try to get an mbuf */ 5053 #ifdef INET6 5054 l_len = sizeof(struct ip6_hdr) + sizeof(struct sctphdr) + sizeof(struct sctp_chunkhdr); 5055 #else 5056 l_len = sizeof(struct ip) + sizeof(struct sctphdr) + sizeof(struct sctp_chunkhdr); 5057 #endif 5058 l_len += plen; 5059 l_len += sizeof(struct sctp_paramhdr); 5060 op_err = sctp_get_mbuf_for_msg(l_len, 0, M_DONTWAIT, 1, MT_DATA); 5061 if (op_err) { 5062 SCTP_BUF_LEN(op_err) = 0; 5063 #ifdef INET6 5064 SCTP_BUF_RESV_UF(op_err, sizeof(struct ip6_hdr)); 5065 #else 5066 SCTP_BUF_RESV_UF(op_err, sizeof(struct ip)); 5067 #endif 5068 SCTP_BUF_RESV_UF(op_err, sizeof(struct sctphdr)); 5069 SCTP_BUF_RESV_UF(op_err, sizeof(struct sctp_chunkhdr)); 5070 } 5071 } 5072 if (op_err) { 5073 /* If we have space */ 5074 struct sctp_paramhdr s; 5075 5076 if (err_at % 4) { 5077 uint32_t cpthis = 0; 5078 5079 pad_needed = 4 - (err_at % 4); 5080 m_copyback(op_err, err_at, pad_needed, (caddr_t)&cpthis); 5081 err_at += pad_needed; 5082 } 5083 s.param_type = htons(SCTP_UNRECOG_PARAM); 5084 s.param_length = htons(sizeof(s) + plen); 5085 m_copyback(op_err, err_at, sizeof(s), (caddr_t)&s); 5086 err_at += sizeof(s); 5087 if (plen > sizeof(tempbuf)) { 5088 plen = sizeof(tempbuf); 5089 } 5090 phdr = sctp_get_next_param(mat, at, (struct sctp_paramhdr *)tempbuf, min(sizeof(tempbuf), plen)); 5091 if (phdr == NULL) { 5092 sctp_m_freem(op_err); 5093 /* 5094 * we are out of memory but 5095 * we still need to have a 5096 * look at what to do (the 5097 * system is in trouble 5098 * though). 5099 */ 5100 op_err = NULL; 5101 goto more_processing; 5102 } 5103 m_copyback(op_err, err_at, plen, (caddr_t)phdr); 5104 err_at += plen; 5105 } 5106 } 5107 more_processing: 5108 if ((ptype & 0x8000) == 0x0000) { 5109 SCTPDBG(SCTP_DEBUG_OUTPUT1, "stop proc\n"); 5110 return (op_err); 5111 } else { 5112 /* skip this chunk and continue processing */ 5113 SCTPDBG(SCTP_DEBUG_OUTPUT1, "move on\n"); 5114 at += SCTP_SIZE32(plen); 5115 } 5116 break; 5117 5118 } 5119 phdr = sctp_get_next_param(mat, at, ¶ms, sizeof(params)); 5120 } 5121 return (op_err); 5122 invalid_size: 5123 SCTPDBG(SCTP_DEBUG_OUTPUT1, "abort flag set\n"); 5124 *abort_processing = 1; 5125 if ((op_err == NULL) && phdr) { 5126 int l_len; 5127 5128 #ifdef INET6 5129 l_len = sizeof(struct ip6_hdr) + sizeof(struct sctphdr) + sizeof(struct sctp_chunkhdr); 5130 #else 5131 l_len = sizeof(struct ip) + sizeof(struct sctphdr) + sizeof(struct sctp_chunkhdr); 5132 #endif 5133 l_len += (2 * sizeof(struct sctp_paramhdr)); 5134 op_err = sctp_get_mbuf_for_msg(l_len, 0, M_DONTWAIT, 1, MT_DATA); 5135 if (op_err) { 5136 SCTP_BUF_LEN(op_err) = 0; 5137 #ifdef INET6 5138 SCTP_BUF_RESV_UF(op_err, sizeof(struct ip6_hdr)); 5139 #else 5140 SCTP_BUF_RESV_UF(op_err, sizeof(struct ip)); 5141 #endif 5142 SCTP_BUF_RESV_UF(op_err, sizeof(struct sctphdr)); 5143 SCTP_BUF_RESV_UF(op_err, sizeof(struct sctp_chunkhdr)); 5144 } 5145 } 5146 if ((op_err) && phdr) { 5147 struct sctp_paramhdr s; 5148 5149 if (err_at % 4) { 5150 uint32_t cpthis = 0; 5151 5152 pad_needed = 4 - (err_at % 4); 5153 m_copyback(op_err, err_at, pad_needed, (caddr_t)&cpthis); 5154 err_at += pad_needed; 5155 } 5156 s.param_type = htons(SCTP_CAUSE_PROTOCOL_VIOLATION); 5157 s.param_length = htons(sizeof(s) + sizeof(struct sctp_paramhdr)); 5158 m_copyback(op_err, err_at, sizeof(s), (caddr_t)&s); 5159 err_at += sizeof(s); 5160 /* Only copy back the p-hdr that caused the issue */ 5161 m_copyback(op_err, err_at, sizeof(struct sctp_paramhdr), (caddr_t)phdr); 5162 } 5163 return (op_err); 5164 } 5165 5166 static int 5167 sctp_are_there_new_addresses(struct sctp_association *asoc, 5168 struct mbuf *in_initpkt, int offset, struct sockaddr *src) 5169 { 5170 /* 5171 * Given a INIT packet, look through the packet to verify that there 5172 * are NO new addresses. As we go through the parameters add reports 5173 * of any un-understood parameters that require an error. Also we 5174 * must return (1) to drop the packet if we see a un-understood 5175 * parameter that tells us to drop the chunk. 5176 */ 5177 struct sockaddr *sa_touse; 5178 struct sockaddr *sa; 5179 struct sctp_paramhdr *phdr, params; 5180 uint16_t ptype, plen; 5181 uint8_t fnd; 5182 struct sctp_nets *net; 5183 5184 #ifdef INET 5185 struct sockaddr_in sin4, *sa4; 5186 5187 #endif 5188 #ifdef INET6 5189 struct sockaddr_in6 sin6, *sa6; 5190 5191 #endif 5192 5193 #ifdef INET 5194 memset(&sin4, 0, sizeof(sin4)); 5195 sin4.sin_family = AF_INET; 5196 sin4.sin_len = sizeof(sin4); 5197 #endif 5198 #ifdef INET6 5199 memset(&sin6, 0, sizeof(sin6)); 5200 sin6.sin6_family = AF_INET6; 5201 sin6.sin6_len = sizeof(sin6); 5202 #endif 5203 /* First what about the src address of the pkt ? */ 5204 fnd = 0; 5205 TAILQ_FOREACH(net, &asoc->nets, sctp_next) { 5206 sa = (struct sockaddr *)&net->ro._l_addr; 5207 if (sa->sa_family == src->sa_family) { 5208 #ifdef INET 5209 if (sa->sa_family == AF_INET) { 5210 struct sockaddr_in *src4; 5211 5212 sa4 = (struct sockaddr_in *)sa; 5213 src4 = (struct sockaddr_in *)src; 5214 if (sa4->sin_addr.s_addr == src4->sin_addr.s_addr) { 5215 fnd = 1; 5216 break; 5217 } 5218 } 5219 #endif 5220 #ifdef INET6 5221 if (sa->sa_family == AF_INET6) { 5222 struct sockaddr_in6 *src6; 5223 5224 sa6 = (struct sockaddr_in6 *)sa; 5225 src6 = (struct sockaddr_in6 *)src; 5226 if (SCTP6_ARE_ADDR_EQUAL(sa6, src6)) { 5227 fnd = 1; 5228 break; 5229 } 5230 } 5231 #endif 5232 } 5233 } 5234 if (fnd == 0) { 5235 /* New address added! no need to look futher. */ 5236 return (1); 5237 } 5238 /* Ok so far lets munge through the rest of the packet */ 5239 offset += sizeof(struct sctp_init_chunk); 5240 phdr = sctp_get_next_param(in_initpkt, offset, ¶ms, sizeof(params)); 5241 while (phdr) { 5242 sa_touse = NULL; 5243 ptype = ntohs(phdr->param_type); 5244 plen = ntohs(phdr->param_length); 5245 switch (ptype) { 5246 #ifdef INET 5247 case SCTP_IPV4_ADDRESS: 5248 { 5249 struct sctp_ipv4addr_param *p4, p4_buf; 5250 5251 phdr = sctp_get_next_param(in_initpkt, offset, 5252 (struct sctp_paramhdr *)&p4_buf, sizeof(p4_buf)); 5253 if (plen != sizeof(struct sctp_ipv4addr_param) || 5254 phdr == NULL) { 5255 return (1); 5256 } 5257 p4 = (struct sctp_ipv4addr_param *)phdr; 5258 sin4.sin_addr.s_addr = p4->addr; 5259 sa_touse = (struct sockaddr *)&sin4; 5260 break; 5261 } 5262 #endif 5263 #ifdef INET6 5264 case SCTP_IPV6_ADDRESS: 5265 { 5266 struct sctp_ipv6addr_param *p6, p6_buf; 5267 5268 phdr = sctp_get_next_param(in_initpkt, offset, 5269 (struct sctp_paramhdr *)&p6_buf, sizeof(p6_buf)); 5270 if (plen != sizeof(struct sctp_ipv6addr_param) || 5271 phdr == NULL) { 5272 return (1); 5273 } 5274 p6 = (struct sctp_ipv6addr_param *)phdr; 5275 memcpy((caddr_t)&sin6.sin6_addr, p6->addr, 5276 sizeof(p6->addr)); 5277 sa_touse = (struct sockaddr *)&sin6; 5278 break; 5279 } 5280 #endif 5281 default: 5282 sa_touse = NULL; 5283 break; 5284 } 5285 if (sa_touse) { 5286 /* ok, sa_touse points to one to check */ 5287 fnd = 0; 5288 TAILQ_FOREACH(net, &asoc->nets, sctp_next) { 5289 sa = (struct sockaddr *)&net->ro._l_addr; 5290 if (sa->sa_family != sa_touse->sa_family) { 5291 continue; 5292 } 5293 #ifdef INET 5294 if (sa->sa_family == AF_INET) { 5295 sa4 = (struct sockaddr_in *)sa; 5296 if (sa4->sin_addr.s_addr == 5297 sin4.sin_addr.s_addr) { 5298 fnd = 1; 5299 break; 5300 } 5301 } 5302 #endif 5303 #ifdef INET6 5304 if (sa->sa_family == AF_INET6) { 5305 sa6 = (struct sockaddr_in6 *)sa; 5306 if (SCTP6_ARE_ADDR_EQUAL( 5307 sa6, &sin6)) { 5308 fnd = 1; 5309 break; 5310 } 5311 } 5312 #endif 5313 } 5314 if (!fnd) { 5315 /* New addr added! no need to look further */ 5316 return (1); 5317 } 5318 } 5319 offset += SCTP_SIZE32(plen); 5320 phdr = sctp_get_next_param(in_initpkt, offset, ¶ms, sizeof(params)); 5321 } 5322 return (0); 5323 } 5324 5325 /* 5326 * Given a MBUF chain that was sent into us containing an INIT. Build a 5327 * INIT-ACK with COOKIE and send back. We assume that the in_initpkt has done 5328 * a pullup to include IPv6/4header, SCTP header and initial part of INIT 5329 * message (i.e. the struct sctp_init_msg). 5330 */ 5331 void 5332 sctp_send_initiate_ack(struct sctp_inpcb *inp, struct sctp_tcb *stcb, 5333 struct mbuf *init_pkt, int iphlen, int offset, 5334 struct sockaddr *src, struct sockaddr *dst, 5335 struct sctphdr *sh, struct sctp_init_chunk *init_chk, 5336 uint8_t use_mflowid, uint32_t mflowid, 5337 uint32_t vrf_id, uint16_t port, int hold_inp_lock) 5338 { 5339 struct sctp_association *asoc; 5340 struct mbuf *m, *m_at, *m_tmp, *m_cookie, *op_err, *mp_last; 5341 struct sctp_init_ack_chunk *initack; 5342 struct sctp_adaptation_layer_indication *ali; 5343 struct sctp_ecn_supported_param *ecn; 5344 struct sctp_prsctp_supported_param *prsctp; 5345 struct sctp_supported_chunk_types_param *pr_supported; 5346 union sctp_sockstore *over_addr; 5347 5348 #ifdef INET 5349 struct sockaddr_in *dst4 = (struct sockaddr_in *)dst; 5350 struct sockaddr_in *src4 = (struct sockaddr_in *)src; 5351 struct sockaddr_in *sin; 5352 5353 #endif 5354 #ifdef INET6 5355 struct sockaddr_in6 *dst6 = (struct sockaddr_in6 *)dst; 5356 struct sockaddr_in6 *src6 = (struct sockaddr_in6 *)src; 5357 struct sockaddr_in6 *sin6; 5358 5359 #endif 5360 struct sockaddr *to; 5361 struct sctp_state_cookie stc; 5362 struct sctp_nets *net = NULL; 5363 uint8_t *signature = NULL; 5364 int cnt_inits_to = 0; 5365 uint16_t his_limit, i_want; 5366 int abort_flag, padval; 5367 int num_ext; 5368 int p_len; 5369 int nat_friendly = 0; 5370 struct socket *so; 5371 5372 if (stcb) { 5373 asoc = &stcb->asoc; 5374 } else { 5375 asoc = NULL; 5376 } 5377 mp_last = NULL; 5378 if ((asoc != NULL) && 5379 (SCTP_GET_STATE(asoc) != SCTP_STATE_COOKIE_WAIT) && 5380 (sctp_are_there_new_addresses(asoc, init_pkt, offset, src))) { 5381 /* new addresses, out of here in non-cookie-wait states */ 5382 /* 5383 * Send a ABORT, we don't add the new address error clause 5384 * though we even set the T bit and copy in the 0 tag.. this 5385 * looks no different than if no listener was present. 5386 */ 5387 sctp_send_abort(init_pkt, iphlen, src, dst, sh, 0, NULL, 5388 use_mflowid, mflowid, 5389 vrf_id, port); 5390 return; 5391 } 5392 abort_flag = 0; 5393 op_err = sctp_arethere_unrecognized_parameters(init_pkt, 5394 (offset + sizeof(struct sctp_init_chunk)), 5395 &abort_flag, (struct sctp_chunkhdr *)init_chk, &nat_friendly); 5396 if (abort_flag) { 5397 do_a_abort: 5398 sctp_send_abort(init_pkt, iphlen, src, dst, sh, 5399 init_chk->init.initiate_tag, op_err, 5400 use_mflowid, mflowid, 5401 vrf_id, port); 5402 return; 5403 } 5404 m = sctp_get_mbuf_for_msg(MCLBYTES, 0, M_DONTWAIT, 1, MT_DATA); 5405 if (m == NULL) { 5406 /* No memory, INIT timer will re-attempt. */ 5407 if (op_err) 5408 sctp_m_freem(op_err); 5409 return; 5410 } 5411 SCTP_BUF_LEN(m) = sizeof(struct sctp_init_chunk); 5412 5413 /* 5414 * We might not overwrite the identification[] completely and on 5415 * some platforms time_entered will contain some padding. Therefore 5416 * zero out the cookie to avoid putting uninitialized memory on the 5417 * wire. 5418 */ 5419 memset(&stc, 0, sizeof(struct sctp_state_cookie)); 5420 5421 /* the time I built cookie */ 5422 (void)SCTP_GETTIME_TIMEVAL(&stc.time_entered); 5423 5424 /* populate any tie tags */ 5425 if (asoc != NULL) { 5426 /* unlock before tag selections */ 5427 stc.tie_tag_my_vtag = asoc->my_vtag_nonce; 5428 stc.tie_tag_peer_vtag = asoc->peer_vtag_nonce; 5429 stc.cookie_life = asoc->cookie_life; 5430 net = asoc->primary_destination; 5431 } else { 5432 stc.tie_tag_my_vtag = 0; 5433 stc.tie_tag_peer_vtag = 0; 5434 /* life I will award this cookie */ 5435 stc.cookie_life = inp->sctp_ep.def_cookie_life; 5436 } 5437 5438 /* copy in the ports for later check */ 5439 stc.myport = sh->dest_port; 5440 stc.peerport = sh->src_port; 5441 5442 /* 5443 * If we wanted to honor cookie life extentions, we would add to 5444 * stc.cookie_life. For now we should NOT honor any extension 5445 */ 5446 stc.site_scope = stc.local_scope = stc.loopback_scope = 0; 5447 if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) { 5448 stc.ipv6_addr_legal = 1; 5449 if (SCTP_IPV6_V6ONLY(inp)) { 5450 stc.ipv4_addr_legal = 0; 5451 } else { 5452 stc.ipv4_addr_legal = 1; 5453 } 5454 } else { 5455 stc.ipv6_addr_legal = 0; 5456 stc.ipv4_addr_legal = 1; 5457 } 5458 #ifdef SCTP_DONT_DO_PRIVADDR_SCOPE 5459 stc.ipv4_scope = 1; 5460 #else 5461 stc.ipv4_scope = 0; 5462 #endif 5463 if (net == NULL) { 5464 to = src; 5465 switch (dst->sa_family) { 5466 #ifdef INET 5467 case AF_INET: 5468 { 5469 /* lookup address */ 5470 stc.address[0] = src4->sin_addr.s_addr; 5471 stc.address[1] = 0; 5472 stc.address[2] = 0; 5473 stc.address[3] = 0; 5474 stc.addr_type = SCTP_IPV4_ADDRESS; 5475 /* local from address */ 5476 stc.laddress[0] = dst4->sin_addr.s_addr; 5477 stc.laddress[1] = 0; 5478 stc.laddress[2] = 0; 5479 stc.laddress[3] = 0; 5480 stc.laddr_type = SCTP_IPV4_ADDRESS; 5481 /* scope_id is only for v6 */ 5482 stc.scope_id = 0; 5483 #ifndef SCTP_DONT_DO_PRIVADDR_SCOPE 5484 if (IN4_ISPRIVATE_ADDRESS(&src4->sin_addr)) { 5485 stc.ipv4_scope = 1; 5486 } 5487 #else 5488 stc.ipv4_scope = 1; 5489 #endif /* SCTP_DONT_DO_PRIVADDR_SCOPE */ 5490 /* Must use the address in this case */ 5491 if (sctp_is_address_on_local_host(src, vrf_id)) { 5492 stc.loopback_scope = 1; 5493 stc.ipv4_scope = 1; 5494 stc.site_scope = 1; 5495 stc.local_scope = 0; 5496 } 5497 break; 5498 } 5499 #endif 5500 #ifdef INET6 5501 case AF_INET6: 5502 { 5503 stc.addr_type = SCTP_IPV6_ADDRESS; 5504 memcpy(&stc.address, &src6->sin6_addr, sizeof(struct in6_addr)); 5505 stc.scope_id = in6_getscope(&src6->sin6_addr); 5506 if (sctp_is_address_on_local_host(src, vrf_id)) { 5507 stc.loopback_scope = 1; 5508 stc.local_scope = 0; 5509 stc.site_scope = 1; 5510 stc.ipv4_scope = 1; 5511 } else if (IN6_IS_ADDR_LINKLOCAL(&src6->sin6_addr)) { 5512 /* 5513 * If the new destination is a 5514 * LINK_LOCAL we must have common 5515 * both site and local scope. Don't 5516 * set local scope though since we 5517 * must depend on the source to be 5518 * added implicitly. We cannot 5519 * assure just because we share one 5520 * link that all links are common. 5521 */ 5522 stc.local_scope = 0; 5523 stc.site_scope = 1; 5524 stc.ipv4_scope = 1; 5525 /* 5526 * we start counting for the private 5527 * address stuff at 1. since the 5528 * link local we source from won't 5529 * show up in our scoped count. 5530 */ 5531 cnt_inits_to = 1; 5532 /* 5533 * pull out the scope_id from 5534 * incoming pkt 5535 */ 5536 } else if (IN6_IS_ADDR_SITELOCAL(&src6->sin6_addr)) { 5537 /* 5538 * If the new destination is 5539 * SITE_LOCAL then we must have site 5540 * scope in common. 5541 */ 5542 stc.site_scope = 1; 5543 } 5544 memcpy(&stc.laddress, &dst6->sin6_addr, sizeof(struct in6_addr)); 5545 stc.laddr_type = SCTP_IPV6_ADDRESS; 5546 break; 5547 } 5548 #endif 5549 default: 5550 /* TSNH */ 5551 goto do_a_abort; 5552 break; 5553 } 5554 } else { 5555 /* set the scope per the existing tcb */ 5556 5557 #ifdef INET6 5558 struct sctp_nets *lnet; 5559 5560 #endif 5561 5562 stc.loopback_scope = asoc->scope.loopback_scope; 5563 stc.ipv4_scope = asoc->scope.ipv4_local_scope; 5564 stc.site_scope = asoc->scope.site_scope; 5565 stc.local_scope = asoc->scope.local_scope; 5566 #ifdef INET6 5567 /* Why do we not consider IPv4 LL addresses? */ 5568 TAILQ_FOREACH(lnet, &asoc->nets, sctp_next) { 5569 if (lnet->ro._l_addr.sin6.sin6_family == AF_INET6) { 5570 if (IN6_IS_ADDR_LINKLOCAL(&lnet->ro._l_addr.sin6.sin6_addr)) { 5571 /* 5572 * if we have a LL address, start 5573 * counting at 1. 5574 */ 5575 cnt_inits_to = 1; 5576 } 5577 } 5578 } 5579 #endif 5580 /* use the net pointer */ 5581 to = (struct sockaddr *)&net->ro._l_addr; 5582 switch (to->sa_family) { 5583 #ifdef INET 5584 case AF_INET: 5585 sin = (struct sockaddr_in *)to; 5586 stc.address[0] = sin->sin_addr.s_addr; 5587 stc.address[1] = 0; 5588 stc.address[2] = 0; 5589 stc.address[3] = 0; 5590 stc.addr_type = SCTP_IPV4_ADDRESS; 5591 if (net->src_addr_selected == 0) { 5592 /* 5593 * strange case here, the INIT should have 5594 * did the selection. 5595 */ 5596 net->ro._s_addr = sctp_source_address_selection(inp, 5597 stcb, (sctp_route_t *) & net->ro, 5598 net, 0, vrf_id); 5599 if (net->ro._s_addr == NULL) 5600 return; 5601 5602 net->src_addr_selected = 1; 5603 5604 } 5605 stc.laddress[0] = net->ro._s_addr->address.sin.sin_addr.s_addr; 5606 stc.laddress[1] = 0; 5607 stc.laddress[2] = 0; 5608 stc.laddress[3] = 0; 5609 stc.laddr_type = SCTP_IPV4_ADDRESS; 5610 /* scope_id is only for v6 */ 5611 stc.scope_id = 0; 5612 break; 5613 #endif 5614 #ifdef INET6 5615 case AF_INET6: 5616 sin6 = (struct sockaddr_in6 *)to; 5617 memcpy(&stc.address, &sin6->sin6_addr, 5618 sizeof(struct in6_addr)); 5619 stc.addr_type = SCTP_IPV6_ADDRESS; 5620 stc.scope_id = sin6->sin6_scope_id; 5621 if (net->src_addr_selected == 0) { 5622 /* 5623 * strange case here, the INIT should have 5624 * done the selection. 5625 */ 5626 net->ro._s_addr = sctp_source_address_selection(inp, 5627 stcb, (sctp_route_t *) & net->ro, 5628 net, 0, vrf_id); 5629 if (net->ro._s_addr == NULL) 5630 return; 5631 5632 net->src_addr_selected = 1; 5633 } 5634 memcpy(&stc.laddress, &net->ro._s_addr->address.sin6.sin6_addr, 5635 sizeof(struct in6_addr)); 5636 stc.laddr_type = SCTP_IPV6_ADDRESS; 5637 break; 5638 #endif 5639 } 5640 } 5641 /* Now lets put the SCTP header in place */ 5642 initack = mtod(m, struct sctp_init_ack_chunk *); 5643 /* Save it off for quick ref */ 5644 stc.peers_vtag = init_chk->init.initiate_tag; 5645 /* who are we */ 5646 memcpy(stc.identification, SCTP_VERSION_STRING, 5647 min(strlen(SCTP_VERSION_STRING), sizeof(stc.identification))); 5648 memset(stc.reserved, 0, SCTP_RESERVE_SPACE); 5649 /* now the chunk header */ 5650 initack->ch.chunk_type = SCTP_INITIATION_ACK; 5651 initack->ch.chunk_flags = 0; 5652 /* fill in later from mbuf we build */ 5653 initack->ch.chunk_length = 0; 5654 /* place in my tag */ 5655 if ((asoc != NULL) && 5656 ((SCTP_GET_STATE(asoc) == SCTP_STATE_COOKIE_WAIT) || 5657 (SCTP_GET_STATE(asoc) == SCTP_STATE_INUSE) || 5658 (SCTP_GET_STATE(asoc) == SCTP_STATE_COOKIE_ECHOED))) { 5659 /* re-use the v-tags and init-seq here */ 5660 initack->init.initiate_tag = htonl(asoc->my_vtag); 5661 initack->init.initial_tsn = htonl(asoc->init_seq_number); 5662 } else { 5663 uint32_t vtag, itsn; 5664 5665 if (hold_inp_lock) { 5666 SCTP_INP_INCR_REF(inp); 5667 SCTP_INP_RUNLOCK(inp); 5668 } 5669 if (asoc) { 5670 atomic_add_int(&asoc->refcnt, 1); 5671 SCTP_TCB_UNLOCK(stcb); 5672 new_tag: 5673 vtag = sctp_select_a_tag(inp, inp->sctp_lport, sh->src_port, 1); 5674 if ((asoc->peer_supports_nat) && (vtag == asoc->my_vtag)) { 5675 /* 5676 * Got a duplicate vtag on some guy behind a 5677 * nat make sure we don't use it. 5678 */ 5679 goto new_tag; 5680 } 5681 initack->init.initiate_tag = htonl(vtag); 5682 /* get a TSN to use too */ 5683 itsn = sctp_select_initial_TSN(&inp->sctp_ep); 5684 initack->init.initial_tsn = htonl(itsn); 5685 SCTP_TCB_LOCK(stcb); 5686 atomic_add_int(&asoc->refcnt, -1); 5687 } else { 5688 vtag = sctp_select_a_tag(inp, inp->sctp_lport, sh->src_port, 1); 5689 initack->init.initiate_tag = htonl(vtag); 5690 /* get a TSN to use too */ 5691 initack->init.initial_tsn = htonl(sctp_select_initial_TSN(&inp->sctp_ep)); 5692 } 5693 if (hold_inp_lock) { 5694 SCTP_INP_RLOCK(inp); 5695 SCTP_INP_DECR_REF(inp); 5696 } 5697 } 5698 /* save away my tag to */ 5699 stc.my_vtag = initack->init.initiate_tag; 5700 5701 /* set up some of the credits. */ 5702 so = inp->sctp_socket; 5703 if (so == NULL) { 5704 /* memory problem */ 5705 sctp_m_freem(m); 5706 return; 5707 } else { 5708 initack->init.a_rwnd = htonl(max(SCTP_SB_LIMIT_RCV(so), SCTP_MINIMAL_RWND)); 5709 } 5710 /* set what I want */ 5711 his_limit = ntohs(init_chk->init.num_inbound_streams); 5712 /* choose what I want */ 5713 if (asoc != NULL) { 5714 if (asoc->streamoutcnt > inp->sctp_ep.pre_open_stream_count) { 5715 i_want = asoc->streamoutcnt; 5716 } else { 5717 i_want = inp->sctp_ep.pre_open_stream_count; 5718 } 5719 } else { 5720 i_want = inp->sctp_ep.pre_open_stream_count; 5721 } 5722 if (his_limit < i_want) { 5723 /* I Want more :< */ 5724 initack->init.num_outbound_streams = init_chk->init.num_inbound_streams; 5725 } else { 5726 /* I can have what I want :> */ 5727 initack->init.num_outbound_streams = htons(i_want); 5728 } 5729 /* tell him his limit. */ 5730 initack->init.num_inbound_streams = 5731 htons(inp->sctp_ep.max_open_streams_intome); 5732 5733 /* adaptation layer indication parameter */ 5734 if (inp->sctp_ep.adaptation_layer_indicator_provided) { 5735 ali = (struct sctp_adaptation_layer_indication *)((caddr_t)initack + sizeof(*initack)); 5736 ali->ph.param_type = htons(SCTP_ULP_ADAPTATION); 5737 ali->ph.param_length = htons(sizeof(*ali)); 5738 ali->indication = ntohl(inp->sctp_ep.adaptation_layer_indicator); 5739 SCTP_BUF_LEN(m) += sizeof(*ali); 5740 ecn = (struct sctp_ecn_supported_param *)((caddr_t)ali + sizeof(*ali)); 5741 } else { 5742 ecn = (struct sctp_ecn_supported_param *)((caddr_t)initack + sizeof(*initack)); 5743 } 5744 5745 /* ECN parameter */ 5746 if (((asoc != NULL) && (asoc->ecn_allowed == 1)) || 5747 (inp->sctp_ecn_enable == 1)) { 5748 ecn->ph.param_type = htons(SCTP_ECN_CAPABLE); 5749 ecn->ph.param_length = htons(sizeof(*ecn)); 5750 SCTP_BUF_LEN(m) += sizeof(*ecn); 5751 5752 prsctp = (struct sctp_prsctp_supported_param *)((caddr_t)ecn + 5753 sizeof(*ecn)); 5754 } else { 5755 prsctp = (struct sctp_prsctp_supported_param *)((caddr_t)ecn); 5756 } 5757 /* And now tell the peer we do pr-sctp */ 5758 prsctp->ph.param_type = htons(SCTP_PRSCTP_SUPPORTED); 5759 prsctp->ph.param_length = htons(sizeof(*prsctp)); 5760 SCTP_BUF_LEN(m) += sizeof(*prsctp); 5761 if (nat_friendly) { 5762 /* Add NAT friendly parameter */ 5763 struct sctp_paramhdr *ph; 5764 5765 ph = (struct sctp_paramhdr *)(mtod(m, caddr_t)+SCTP_BUF_LEN(m)); 5766 ph->param_type = htons(SCTP_HAS_NAT_SUPPORT); 5767 ph->param_length = htons(sizeof(struct sctp_paramhdr)); 5768 SCTP_BUF_LEN(m) += sizeof(struct sctp_paramhdr); 5769 } 5770 /* And now tell the peer we do all the extensions */ 5771 pr_supported = (struct sctp_supported_chunk_types_param *)(mtod(m, caddr_t)+SCTP_BUF_LEN(m)); 5772 pr_supported->ph.param_type = htons(SCTP_SUPPORTED_CHUNK_EXT); 5773 num_ext = 0; 5774 pr_supported->chunk_types[num_ext++] = SCTP_ASCONF; 5775 pr_supported->chunk_types[num_ext++] = SCTP_ASCONF_ACK; 5776 pr_supported->chunk_types[num_ext++] = SCTP_FORWARD_CUM_TSN; 5777 pr_supported->chunk_types[num_ext++] = SCTP_PACKET_DROPPED; 5778 pr_supported->chunk_types[num_ext++] = SCTP_STREAM_RESET; 5779 if (!SCTP_BASE_SYSCTL(sctp_auth_disable)) 5780 pr_supported->chunk_types[num_ext++] = SCTP_AUTHENTICATION; 5781 if (SCTP_BASE_SYSCTL(sctp_nr_sack_on_off)) 5782 pr_supported->chunk_types[num_ext++] = SCTP_NR_SELECTIVE_ACK; 5783 p_len = sizeof(*pr_supported) + num_ext; 5784 pr_supported->ph.param_length = htons(p_len); 5785 bzero((caddr_t)pr_supported + p_len, SCTP_SIZE32(p_len) - p_len); 5786 SCTP_BUF_LEN(m) += SCTP_SIZE32(p_len); 5787 5788 /* add authentication parameters */ 5789 if (!SCTP_BASE_SYSCTL(sctp_auth_disable)) { 5790 struct sctp_auth_random *randp; 5791 struct sctp_auth_hmac_algo *hmacs; 5792 struct sctp_auth_chunk_list *chunks; 5793 uint16_t random_len; 5794 5795 /* generate and add RANDOM parameter */ 5796 random_len = SCTP_AUTH_RANDOM_SIZE_DEFAULT; 5797 randp = (struct sctp_auth_random *)(mtod(m, caddr_t)+SCTP_BUF_LEN(m)); 5798 randp->ph.param_type = htons(SCTP_RANDOM); 5799 p_len = sizeof(*randp) + random_len; 5800 randp->ph.param_length = htons(p_len); 5801 SCTP_READ_RANDOM(randp->random_data, random_len); 5802 /* zero out any padding required */ 5803 bzero((caddr_t)randp + p_len, SCTP_SIZE32(p_len) - p_len); 5804 SCTP_BUF_LEN(m) += SCTP_SIZE32(p_len); 5805 5806 /* add HMAC_ALGO parameter */ 5807 hmacs = (struct sctp_auth_hmac_algo *)(mtod(m, caddr_t)+SCTP_BUF_LEN(m)); 5808 p_len = sctp_serialize_hmaclist(inp->sctp_ep.local_hmacs, 5809 (uint8_t *) hmacs->hmac_ids); 5810 if (p_len > 0) { 5811 p_len += sizeof(*hmacs); 5812 hmacs->ph.param_type = htons(SCTP_HMAC_LIST); 5813 hmacs->ph.param_length = htons(p_len); 5814 /* zero out any padding required */ 5815 bzero((caddr_t)hmacs + p_len, SCTP_SIZE32(p_len) - p_len); 5816 SCTP_BUF_LEN(m) += SCTP_SIZE32(p_len); 5817 } 5818 /* add CHUNKS parameter */ 5819 chunks = (struct sctp_auth_chunk_list *)(mtod(m, caddr_t)+SCTP_BUF_LEN(m)); 5820 p_len = sctp_serialize_auth_chunks(inp->sctp_ep.local_auth_chunks, 5821 chunks->chunk_types); 5822 if (p_len > 0) { 5823 p_len += sizeof(*chunks); 5824 chunks->ph.param_type = htons(SCTP_CHUNK_LIST); 5825 chunks->ph.param_length = htons(p_len); 5826 /* zero out any padding required */ 5827 bzero((caddr_t)chunks + p_len, SCTP_SIZE32(p_len) - p_len); 5828 SCTP_BUF_LEN(m) += SCTP_SIZE32(p_len); 5829 } 5830 } 5831 m_at = m; 5832 /* now the addresses */ 5833 { 5834 struct sctp_scoping scp; 5835 5836 /* 5837 * To optimize this we could put the scoping stuff into a 5838 * structure and remove the individual uint8's from the stc 5839 * structure. Then we could just sifa in the address within 5840 * the stc.. but for now this is a quick hack to get the 5841 * address stuff teased apart. 5842 */ 5843 scp.ipv4_addr_legal = stc.ipv4_addr_legal; 5844 scp.ipv6_addr_legal = stc.ipv6_addr_legal; 5845 scp.loopback_scope = stc.loopback_scope; 5846 scp.ipv4_local_scope = stc.ipv4_scope; 5847 scp.local_scope = stc.local_scope; 5848 scp.site_scope = stc.site_scope; 5849 m_at = sctp_add_addresses_to_i_ia(inp, stcb, &scp, m_at, cnt_inits_to, NULL, NULL); 5850 } 5851 5852 /* tack on the operational error if present */ 5853 if (op_err) { 5854 struct mbuf *ol; 5855 int llen; 5856 5857 llen = 0; 5858 ol = op_err; 5859 5860 while (ol) { 5861 llen += SCTP_BUF_LEN(ol); 5862 ol = SCTP_BUF_NEXT(ol); 5863 } 5864 if (llen % 4) { 5865 /* must add a pad to the param */ 5866 uint32_t cpthis = 0; 5867 int padlen; 5868 5869 padlen = 4 - (llen % 4); 5870 m_copyback(op_err, llen, padlen, (caddr_t)&cpthis); 5871 } 5872 while (SCTP_BUF_NEXT(m_at) != NULL) { 5873 m_at = SCTP_BUF_NEXT(m_at); 5874 } 5875 SCTP_BUF_NEXT(m_at) = op_err; 5876 while (SCTP_BUF_NEXT(m_at) != NULL) { 5877 m_at = SCTP_BUF_NEXT(m_at); 5878 } 5879 } 5880 /* pre-calulate the size and update pkt header and chunk header */ 5881 p_len = 0; 5882 for (m_tmp = m; m_tmp; m_tmp = SCTP_BUF_NEXT(m_tmp)) { 5883 p_len += SCTP_BUF_LEN(m_tmp); 5884 if (SCTP_BUF_NEXT(m_tmp) == NULL) { 5885 /* m_tmp should now point to last one */ 5886 break; 5887 } 5888 } 5889 5890 /* Now we must build a cookie */ 5891 m_cookie = sctp_add_cookie(init_pkt, offset, m, 0, &stc, &signature); 5892 if (m_cookie == NULL) { 5893 /* memory problem */ 5894 sctp_m_freem(m); 5895 return; 5896 } 5897 /* Now append the cookie to the end and update the space/size */ 5898 SCTP_BUF_NEXT(m_tmp) = m_cookie; 5899 5900 for (m_tmp = m_cookie; m_tmp; m_tmp = SCTP_BUF_NEXT(m_tmp)) { 5901 p_len += SCTP_BUF_LEN(m_tmp); 5902 if (SCTP_BUF_NEXT(m_tmp) == NULL) { 5903 /* m_tmp should now point to last one */ 5904 mp_last = m_tmp; 5905 break; 5906 } 5907 } 5908 /* 5909 * Place in the size, but we don't include the last pad (if any) in 5910 * the INIT-ACK. 5911 */ 5912 initack->ch.chunk_length = htons(p_len); 5913 5914 /* 5915 * Time to sign the cookie, we don't sign over the cookie signature 5916 * though thus we set trailer. 5917 */ 5918 (void)sctp_hmac_m(SCTP_HMAC, 5919 (uint8_t *) inp->sctp_ep.secret_key[(int)(inp->sctp_ep.current_secret_number)], 5920 SCTP_SECRET_SIZE, m_cookie, sizeof(struct sctp_paramhdr), 5921 (uint8_t *) signature, SCTP_SIGNATURE_SIZE); 5922 /* 5923 * We sifa 0 here to NOT set IP_DF if its IPv4, we ignore the return 5924 * here since the timer will drive a retranmission. 5925 */ 5926 padval = p_len % 4; 5927 if ((padval) && (mp_last)) { 5928 /* see my previous comments on mp_last */ 5929 if (sctp_add_pad_tombuf(mp_last, (4 - padval))) { 5930 /* Houston we have a problem, no space */ 5931 sctp_m_freem(m); 5932 return; 5933 } 5934 } 5935 if (stc.loopback_scope) { 5936 over_addr = (union sctp_sockstore *)dst; 5937 } else { 5938 over_addr = NULL; 5939 } 5940 5941 (void)sctp_lowlevel_chunk_output(inp, NULL, NULL, to, m, 0, NULL, 0, 0, 5942 0, 0, 5943 inp->sctp_lport, sh->src_port, init_chk->init.initiate_tag, 5944 port, over_addr, 5945 use_mflowid, mflowid, 5946 SCTP_SO_NOT_LOCKED); 5947 SCTP_STAT_INCR_COUNTER64(sctps_outcontrolchunks); 5948 } 5949 5950 5951 static void 5952 sctp_prune_prsctp(struct sctp_tcb *stcb, 5953 struct sctp_association *asoc, 5954 struct sctp_sndrcvinfo *srcv, 5955 int dataout) 5956 { 5957 int freed_spc = 0; 5958 struct sctp_tmit_chunk *chk, *nchk; 5959 5960 SCTP_TCB_LOCK_ASSERT(stcb); 5961 if ((asoc->peer_supports_prsctp) && 5962 (asoc->sent_queue_cnt_removeable > 0)) { 5963 TAILQ_FOREACH(chk, &asoc->sent_queue, sctp_next) { 5964 /* 5965 * Look for chunks marked with the PR_SCTP flag AND 5966 * the buffer space flag. If the one being sent is 5967 * equal or greater priority then purge the old one 5968 * and free some space. 5969 */ 5970 if (PR_SCTP_BUF_ENABLED(chk->flags)) { 5971 /* 5972 * This one is PR-SCTP AND buffer space 5973 * limited type 5974 */ 5975 if (chk->rec.data.timetodrop.tv_sec >= (long)srcv->sinfo_timetolive) { 5976 /* 5977 * Lower numbers equates to higher 5978 * priority so if the one we are 5979 * looking at has a larger or equal 5980 * priority we want to drop the data 5981 * and NOT retransmit it. 5982 */ 5983 if (chk->data) { 5984 /* 5985 * We release the book_size 5986 * if the mbuf is here 5987 */ 5988 int ret_spc; 5989 uint8_t sent; 5990 5991 if (chk->sent > SCTP_DATAGRAM_UNSENT) 5992 sent = 1; 5993 else 5994 sent = 0; 5995 ret_spc = sctp_release_pr_sctp_chunk(stcb, chk, 5996 sent, 5997 SCTP_SO_LOCKED); 5998 freed_spc += ret_spc; 5999 if (freed_spc >= dataout) { 6000 return; 6001 } 6002 } /* if chunk was present */ 6003 } /* if of sufficent priority */ 6004 } /* if chunk has enabled */ 6005 } /* tailqforeach */ 6006 6007 TAILQ_FOREACH_SAFE(chk, &asoc->send_queue, sctp_next, nchk) { 6008 /* Here we must move to the sent queue and mark */ 6009 if (PR_SCTP_BUF_ENABLED(chk->flags)) { 6010 if (chk->rec.data.timetodrop.tv_sec >= (long)srcv->sinfo_timetolive) { 6011 if (chk->data) { 6012 /* 6013 * We release the book_size 6014 * if the mbuf is here 6015 */ 6016 int ret_spc; 6017 6018 ret_spc = sctp_release_pr_sctp_chunk(stcb, chk, 6019 0, SCTP_SO_LOCKED); 6020 6021 freed_spc += ret_spc; 6022 if (freed_spc >= dataout) { 6023 return; 6024 } 6025 } /* end if chk->data */ 6026 } /* end if right class */ 6027 } /* end if chk pr-sctp */ 6028 } /* tailqforeachsafe (chk) */ 6029 } /* if enabled in asoc */ 6030 } 6031 6032 int 6033 sctp_get_frag_point(struct sctp_tcb *stcb, 6034 struct sctp_association *asoc) 6035 { 6036 int siz, ovh; 6037 6038 /* 6039 * For endpoints that have both v6 and v4 addresses we must reserve 6040 * room for the ipv6 header, for those that are only dealing with V4 6041 * we use a larger frag point. 6042 */ 6043 if (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) { 6044 ovh = SCTP_MED_OVERHEAD; 6045 } else { 6046 ovh = SCTP_MED_V4_OVERHEAD; 6047 } 6048 6049 if (stcb->asoc.sctp_frag_point > asoc->smallest_mtu) 6050 siz = asoc->smallest_mtu - ovh; 6051 else 6052 siz = (stcb->asoc.sctp_frag_point - ovh); 6053 /* 6054 * if (siz > (MCLBYTES-sizeof(struct sctp_data_chunk))) { 6055 */ 6056 /* A data chunk MUST fit in a cluster */ 6057 /* siz = (MCLBYTES - sizeof(struct sctp_data_chunk)); */ 6058 /* } */ 6059 6060 /* adjust for an AUTH chunk if DATA requires auth */ 6061 if (sctp_auth_is_required_chunk(SCTP_DATA, stcb->asoc.peer_auth_chunks)) 6062 siz -= sctp_get_auth_chunk_len(stcb->asoc.peer_hmac_id); 6063 6064 if (siz % 4) { 6065 /* make it an even word boundary please */ 6066 siz -= (siz % 4); 6067 } 6068 return (siz); 6069 } 6070 6071 static void 6072 sctp_set_prsctp_policy(struct sctp_stream_queue_pending *sp) 6073 { 6074 sp->pr_sctp_on = 0; 6075 /* 6076 * We assume that the user wants PR_SCTP_TTL if the user provides a 6077 * positive lifetime but does not specify any PR_SCTP policy. This 6078 * is a BAD assumption and causes problems at least with the 6079 * U-Vancovers MPI folks. I will change this to be no policy means 6080 * NO PR-SCTP. 6081 */ 6082 if (PR_SCTP_ENABLED(sp->sinfo_flags)) { 6083 sp->act_flags |= PR_SCTP_POLICY(sp->sinfo_flags); 6084 sp->pr_sctp_on = 1; 6085 } else { 6086 return; 6087 } 6088 switch (PR_SCTP_POLICY(sp->sinfo_flags)) { 6089 case CHUNK_FLAGS_PR_SCTP_BUF: 6090 /* 6091 * Time to live is a priority stored in tv_sec when doing 6092 * the buffer drop thing. 6093 */ 6094 sp->ts.tv_sec = sp->timetolive; 6095 sp->ts.tv_usec = 0; 6096 break; 6097 case CHUNK_FLAGS_PR_SCTP_TTL: 6098 { 6099 struct timeval tv; 6100 6101 (void)SCTP_GETTIME_TIMEVAL(&sp->ts); 6102 tv.tv_sec = sp->timetolive / 1000; 6103 tv.tv_usec = (sp->timetolive * 1000) % 1000000; 6104 /* 6105 * TODO sctp_constants.h needs alternative time 6106 * macros when _KERNEL is undefined. 6107 */ 6108 timevaladd(&sp->ts, &tv); 6109 } 6110 break; 6111 case CHUNK_FLAGS_PR_SCTP_RTX: 6112 /* 6113 * Time to live is a the number or retransmissions stored in 6114 * tv_sec. 6115 */ 6116 sp->ts.tv_sec = sp->timetolive; 6117 sp->ts.tv_usec = 0; 6118 break; 6119 default: 6120 SCTPDBG(SCTP_DEBUG_USRREQ1, 6121 "Unknown PR_SCTP policy %u.\n", 6122 PR_SCTP_POLICY(sp->sinfo_flags)); 6123 break; 6124 } 6125 } 6126 6127 static int 6128 sctp_msg_append(struct sctp_tcb *stcb, 6129 struct sctp_nets *net, 6130 struct mbuf *m, 6131 struct sctp_sndrcvinfo *srcv, int hold_stcb_lock) 6132 { 6133 int error = 0; 6134 struct mbuf *at; 6135 struct sctp_stream_queue_pending *sp = NULL; 6136 struct sctp_stream_out *strm; 6137 6138 /* 6139 * Given an mbuf chain, put it into the association send queue and 6140 * place it on the wheel 6141 */ 6142 if (srcv->sinfo_stream >= stcb->asoc.streamoutcnt) { 6143 /* Invalid stream number */ 6144 SCTP_LTRACE_ERR_RET_PKT(m, NULL, stcb, net, SCTP_FROM_SCTP_OUTPUT, EINVAL); 6145 error = EINVAL; 6146 goto out_now; 6147 } 6148 if ((stcb->asoc.stream_locked) && 6149 (stcb->asoc.stream_locked_on != srcv->sinfo_stream)) { 6150 SCTP_LTRACE_ERR_RET_PKT(m, NULL, stcb, net, SCTP_FROM_SCTP_OUTPUT, EINVAL); 6151 error = EINVAL; 6152 goto out_now; 6153 } 6154 strm = &stcb->asoc.strmout[srcv->sinfo_stream]; 6155 /* Now can we send this? */ 6156 if ((SCTP_GET_STATE(&stcb->asoc) == SCTP_STATE_SHUTDOWN_SENT) || 6157 (SCTP_GET_STATE(&stcb->asoc) == SCTP_STATE_SHUTDOWN_ACK_SENT) || 6158 (SCTP_GET_STATE(&stcb->asoc) == SCTP_STATE_SHUTDOWN_RECEIVED) || 6159 (stcb->asoc.state & SCTP_STATE_SHUTDOWN_PENDING)) { 6160 /* got data while shutting down */ 6161 SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, ECONNRESET); 6162 error = ECONNRESET; 6163 goto out_now; 6164 } 6165 sctp_alloc_a_strmoq(stcb, sp); 6166 if (sp == NULL) { 6167 SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, ENOMEM); 6168 error = ENOMEM; 6169 goto out_now; 6170 } 6171 sp->sinfo_flags = srcv->sinfo_flags; 6172 sp->timetolive = srcv->sinfo_timetolive; 6173 sp->ppid = srcv->sinfo_ppid; 6174 sp->context = srcv->sinfo_context; 6175 if (sp->sinfo_flags & SCTP_ADDR_OVER) { 6176 sp->net = net; 6177 atomic_add_int(&sp->net->ref_count, 1); 6178 } else { 6179 sp->net = NULL; 6180 } 6181 (void)SCTP_GETTIME_TIMEVAL(&sp->ts); 6182 sp->stream = srcv->sinfo_stream; 6183 sp->msg_is_complete = 1; 6184 sp->sender_all_done = 1; 6185 sp->some_taken = 0; 6186 sp->data = m; 6187 sp->tail_mbuf = NULL; 6188 sctp_set_prsctp_policy(sp); 6189 /* 6190 * We could in theory (for sendall) sifa the length in, but we would 6191 * still have to hunt through the chain since we need to setup the 6192 * tail_mbuf 6193 */ 6194 sp->length = 0; 6195 for (at = m; at; at = SCTP_BUF_NEXT(at)) { 6196 if (SCTP_BUF_NEXT(at) == NULL) 6197 sp->tail_mbuf = at; 6198 sp->length += SCTP_BUF_LEN(at); 6199 } 6200 if (srcv->sinfo_keynumber_valid) { 6201 sp->auth_keyid = srcv->sinfo_keynumber; 6202 } else { 6203 sp->auth_keyid = stcb->asoc.authinfo.active_keyid; 6204 } 6205 if (sctp_auth_is_required_chunk(SCTP_DATA, stcb->asoc.peer_auth_chunks)) { 6206 sctp_auth_key_acquire(stcb, sp->auth_keyid); 6207 sp->holds_key_ref = 1; 6208 } 6209 if (hold_stcb_lock == 0) { 6210 SCTP_TCB_SEND_LOCK(stcb); 6211 } 6212 sctp_snd_sb_alloc(stcb, sp->length); 6213 atomic_add_int(&stcb->asoc.stream_queue_cnt, 1); 6214 TAILQ_INSERT_TAIL(&strm->outqueue, sp, next); 6215 stcb->asoc.ss_functions.sctp_ss_add_to_stream(stcb, &stcb->asoc, strm, sp, 1); 6216 m = NULL; 6217 if (hold_stcb_lock == 0) { 6218 SCTP_TCB_SEND_UNLOCK(stcb); 6219 } 6220 out_now: 6221 if (m) { 6222 sctp_m_freem(m); 6223 } 6224 return (error); 6225 } 6226 6227 6228 static struct mbuf * 6229 sctp_copy_mbufchain(struct mbuf *clonechain, 6230 struct mbuf *outchain, 6231 struct mbuf **endofchain, 6232 int can_take_mbuf, 6233 int sizeofcpy, 6234 uint8_t copy_by_ref) 6235 { 6236 struct mbuf *m; 6237 struct mbuf *appendchain; 6238 caddr_t cp; 6239 int len; 6240 6241 if (endofchain == NULL) { 6242 /* error */ 6243 error_out: 6244 if (outchain) 6245 sctp_m_freem(outchain); 6246 return (NULL); 6247 } 6248 if (can_take_mbuf) { 6249 appendchain = clonechain; 6250 } else { 6251 if (!copy_by_ref && 6252 (sizeofcpy <= (int)((((SCTP_BASE_SYSCTL(sctp_mbuf_threshold_count) - 1) * MLEN) + MHLEN))) 6253 ) { 6254 /* Its not in a cluster */ 6255 if (*endofchain == NULL) { 6256 /* lets get a mbuf cluster */ 6257 if (outchain == NULL) { 6258 /* This is the general case */ 6259 new_mbuf: 6260 outchain = sctp_get_mbuf_for_msg(MCLBYTES, 0, M_DONTWAIT, 1, MT_HEADER); 6261 if (outchain == NULL) { 6262 goto error_out; 6263 } 6264 SCTP_BUF_LEN(outchain) = 0; 6265 *endofchain = outchain; 6266 /* get the prepend space */ 6267 SCTP_BUF_RESV_UF(outchain, (SCTP_FIRST_MBUF_RESV + 4)); 6268 } else { 6269 /* 6270 * We really should not get a NULL 6271 * in endofchain 6272 */ 6273 /* find end */ 6274 m = outchain; 6275 while (m) { 6276 if (SCTP_BUF_NEXT(m) == NULL) { 6277 *endofchain = m; 6278 break; 6279 } 6280 m = SCTP_BUF_NEXT(m); 6281 } 6282 /* sanity */ 6283 if (*endofchain == NULL) { 6284 /* 6285 * huh, TSNH XXX maybe we 6286 * should panic 6287 */ 6288 sctp_m_freem(outchain); 6289 goto new_mbuf; 6290 } 6291 } 6292 /* get the new end of length */ 6293 len = M_TRAILINGSPACE(*endofchain); 6294 } else { 6295 /* how much is left at the end? */ 6296 len = M_TRAILINGSPACE(*endofchain); 6297 } 6298 /* Find the end of the data, for appending */ 6299 cp = (mtod((*endofchain), caddr_t)+SCTP_BUF_LEN((*endofchain))); 6300 6301 /* Now lets copy it out */ 6302 if (len >= sizeofcpy) { 6303 /* It all fits, copy it in */ 6304 m_copydata(clonechain, 0, sizeofcpy, cp); 6305 SCTP_BUF_LEN((*endofchain)) += sizeofcpy; 6306 } else { 6307 /* fill up the end of the chain */ 6308 if (len > 0) { 6309 m_copydata(clonechain, 0, len, cp); 6310 SCTP_BUF_LEN((*endofchain)) += len; 6311 /* now we need another one */ 6312 sizeofcpy -= len; 6313 } 6314 m = sctp_get_mbuf_for_msg(MCLBYTES, 0, M_DONTWAIT, 1, MT_HEADER); 6315 if (m == NULL) { 6316 /* We failed */ 6317 goto error_out; 6318 } 6319 SCTP_BUF_NEXT((*endofchain)) = m; 6320 *endofchain = m; 6321 cp = mtod((*endofchain), caddr_t); 6322 m_copydata(clonechain, len, sizeofcpy, cp); 6323 SCTP_BUF_LEN((*endofchain)) += sizeofcpy; 6324 } 6325 return (outchain); 6326 } else { 6327 /* copy the old fashion way */ 6328 appendchain = SCTP_M_COPYM(clonechain, 0, M_COPYALL, M_DONTWAIT); 6329 #ifdef SCTP_MBUF_LOGGING 6330 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_MBUF_LOGGING_ENABLE) { 6331 struct mbuf *mat; 6332 6333 for (mat = appendchain; mat; mat = SCTP_BUF_NEXT(mat)) { 6334 if (SCTP_BUF_IS_EXTENDED(mat)) { 6335 sctp_log_mb(mat, SCTP_MBUF_ICOPY); 6336 } 6337 } 6338 } 6339 #endif 6340 } 6341 } 6342 if (appendchain == NULL) { 6343 /* error */ 6344 if (outchain) 6345 sctp_m_freem(outchain); 6346 return (NULL); 6347 } 6348 if (outchain) { 6349 /* tack on to the end */ 6350 if (*endofchain != NULL) { 6351 SCTP_BUF_NEXT(((*endofchain))) = appendchain; 6352 } else { 6353 m = outchain; 6354 while (m) { 6355 if (SCTP_BUF_NEXT(m) == NULL) { 6356 SCTP_BUF_NEXT(m) = appendchain; 6357 break; 6358 } 6359 m = SCTP_BUF_NEXT(m); 6360 } 6361 } 6362 /* 6363 * save off the end and update the end-chain postion 6364 */ 6365 m = appendchain; 6366 while (m) { 6367 if (SCTP_BUF_NEXT(m) == NULL) { 6368 *endofchain = m; 6369 break; 6370 } 6371 m = SCTP_BUF_NEXT(m); 6372 } 6373 return (outchain); 6374 } else { 6375 /* save off the end and update the end-chain postion */ 6376 m = appendchain; 6377 while (m) { 6378 if (SCTP_BUF_NEXT(m) == NULL) { 6379 *endofchain = m; 6380 break; 6381 } 6382 m = SCTP_BUF_NEXT(m); 6383 } 6384 return (appendchain); 6385 } 6386 } 6387 6388 static int 6389 sctp_med_chunk_output(struct sctp_inpcb *inp, 6390 struct sctp_tcb *stcb, 6391 struct sctp_association *asoc, 6392 int *num_out, 6393 int *reason_code, 6394 int control_only, int from_where, 6395 struct timeval *now, int *now_filled, int frag_point, int so_locked 6396 #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING) 6397 SCTP_UNUSED 6398 #endif 6399 ); 6400 6401 static void 6402 sctp_sendall_iterator(struct sctp_inpcb *inp, struct sctp_tcb *stcb, void *ptr, 6403 uint32_t val SCTP_UNUSED) 6404 { 6405 struct sctp_copy_all *ca; 6406 struct mbuf *m; 6407 int ret = 0; 6408 int added_control = 0; 6409 int un_sent, do_chunk_output = 1; 6410 struct sctp_association *asoc; 6411 struct sctp_nets *net; 6412 6413 ca = (struct sctp_copy_all *)ptr; 6414 if (ca->m == NULL) { 6415 return; 6416 } 6417 if (ca->inp != inp) { 6418 /* TSNH */ 6419 return; 6420 } 6421 if ((ca->m) && ca->sndlen) { 6422 m = SCTP_M_COPYM(ca->m, 0, M_COPYALL, M_DONTWAIT); 6423 if (m == NULL) { 6424 /* can't copy so we are done */ 6425 ca->cnt_failed++; 6426 return; 6427 } 6428 #ifdef SCTP_MBUF_LOGGING 6429 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_MBUF_LOGGING_ENABLE) { 6430 struct mbuf *mat; 6431 6432 for (mat = m; mat; mat = SCTP_BUF_NEXT(mat)) { 6433 if (SCTP_BUF_IS_EXTENDED(mat)) { 6434 sctp_log_mb(mat, SCTP_MBUF_ICOPY); 6435 } 6436 } 6437 } 6438 #endif 6439 } else { 6440 m = NULL; 6441 } 6442 SCTP_TCB_LOCK_ASSERT(stcb); 6443 if (stcb->asoc.alternate) { 6444 net = stcb->asoc.alternate; 6445 } else { 6446 net = stcb->asoc.primary_destination; 6447 } 6448 if (ca->sndrcv.sinfo_flags & SCTP_ABORT) { 6449 /* Abort this assoc with m as the user defined reason */ 6450 if (m) { 6451 struct sctp_paramhdr *ph; 6452 6453 SCTP_BUF_PREPEND(m, sizeof(struct sctp_paramhdr), M_DONTWAIT); 6454 if (m) { 6455 ph = mtod(m, struct sctp_paramhdr *); 6456 ph->param_type = htons(SCTP_CAUSE_USER_INITIATED_ABT); 6457 ph->param_length = htons(sizeof(struct sctp_paramhdr) + ca->sndlen); 6458 } 6459 /* 6460 * We add one here to keep the assoc from 6461 * dis-appearing on us. 6462 */ 6463 atomic_add_int(&stcb->asoc.refcnt, 1); 6464 sctp_abort_an_association(inp, stcb, m, SCTP_SO_NOT_LOCKED); 6465 /* 6466 * sctp_abort_an_association calls sctp_free_asoc() 6467 * free association will NOT free it since we 6468 * incremented the refcnt .. we do this to prevent 6469 * it being freed and things getting tricky since we 6470 * could end up (from free_asoc) calling inpcb_free 6471 * which would get a recursive lock call to the 6472 * iterator lock.. But as a consequence of that the 6473 * stcb will return to us un-locked.. since 6474 * free_asoc returns with either no TCB or the TCB 6475 * unlocked, we must relock.. to unlock in the 6476 * iterator timer :-0 6477 */ 6478 SCTP_TCB_LOCK(stcb); 6479 atomic_add_int(&stcb->asoc.refcnt, -1); 6480 goto no_chunk_output; 6481 } 6482 } else { 6483 if (m) { 6484 ret = sctp_msg_append(stcb, net, m, 6485 &ca->sndrcv, 1); 6486 } 6487 asoc = &stcb->asoc; 6488 if (ca->sndrcv.sinfo_flags & SCTP_EOF) { 6489 /* shutdown this assoc */ 6490 int cnt; 6491 6492 cnt = sctp_is_there_unsent_data(stcb, SCTP_SO_NOT_LOCKED); 6493 6494 if (TAILQ_EMPTY(&asoc->send_queue) && 6495 TAILQ_EMPTY(&asoc->sent_queue) && 6496 (cnt == 0)) { 6497 if (asoc->locked_on_sending) { 6498 goto abort_anyway; 6499 } 6500 /* 6501 * there is nothing queued to send, so I'm 6502 * done... 6503 */ 6504 if ((SCTP_GET_STATE(asoc) != SCTP_STATE_SHUTDOWN_SENT) && 6505 (SCTP_GET_STATE(asoc) != SCTP_STATE_SHUTDOWN_RECEIVED) && 6506 (SCTP_GET_STATE(asoc) != SCTP_STATE_SHUTDOWN_ACK_SENT)) { 6507 /* 6508 * only send SHUTDOWN the first time 6509 * through 6510 */ 6511 if (SCTP_GET_STATE(asoc) == SCTP_STATE_OPEN) { 6512 SCTP_STAT_DECR_GAUGE32(sctps_currestab); 6513 } 6514 SCTP_SET_STATE(asoc, SCTP_STATE_SHUTDOWN_SENT); 6515 SCTP_CLEAR_SUBSTATE(asoc, SCTP_STATE_SHUTDOWN_PENDING); 6516 sctp_stop_timers_for_shutdown(stcb); 6517 sctp_send_shutdown(stcb, net); 6518 sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWN, stcb->sctp_ep, stcb, 6519 net); 6520 sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWNGUARD, stcb->sctp_ep, stcb, 6521 asoc->primary_destination); 6522 added_control = 1; 6523 do_chunk_output = 0; 6524 } 6525 } else { 6526 /* 6527 * we still got (or just got) data to send, 6528 * so set SHUTDOWN_PENDING 6529 */ 6530 /* 6531 * XXX sockets draft says that SCTP_EOF 6532 * should be sent with no data. currently, 6533 * we will allow user data to be sent first 6534 * and move to SHUTDOWN-PENDING 6535 */ 6536 if ((SCTP_GET_STATE(asoc) != SCTP_STATE_SHUTDOWN_SENT) && 6537 (SCTP_GET_STATE(asoc) != SCTP_STATE_SHUTDOWN_RECEIVED) && 6538 (SCTP_GET_STATE(asoc) != SCTP_STATE_SHUTDOWN_ACK_SENT)) { 6539 if (asoc->locked_on_sending) { 6540 /* 6541 * Locked to send out the 6542 * data 6543 */ 6544 struct sctp_stream_queue_pending *sp; 6545 6546 sp = TAILQ_LAST(&asoc->locked_on_sending->outqueue, sctp_streamhead); 6547 if (sp) { 6548 if ((sp->length == 0) && (sp->msg_is_complete == 0)) 6549 asoc->state |= SCTP_STATE_PARTIAL_MSG_LEFT; 6550 } 6551 } 6552 asoc->state |= SCTP_STATE_SHUTDOWN_PENDING; 6553 if (TAILQ_EMPTY(&asoc->send_queue) && 6554 TAILQ_EMPTY(&asoc->sent_queue) && 6555 (asoc->state & SCTP_STATE_PARTIAL_MSG_LEFT)) { 6556 abort_anyway: 6557 atomic_add_int(&stcb->asoc.refcnt, 1); 6558 sctp_abort_an_association(stcb->sctp_ep, stcb, 6559 NULL, SCTP_SO_NOT_LOCKED); 6560 atomic_add_int(&stcb->asoc.refcnt, -1); 6561 goto no_chunk_output; 6562 } 6563 sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWNGUARD, stcb->sctp_ep, stcb, 6564 asoc->primary_destination); 6565 } 6566 } 6567 6568 } 6569 } 6570 un_sent = ((stcb->asoc.total_output_queue_size - stcb->asoc.total_flight) + 6571 (stcb->asoc.stream_queue_cnt * sizeof(struct sctp_data_chunk))); 6572 6573 if ((sctp_is_feature_off(inp, SCTP_PCB_FLAGS_NODELAY)) && 6574 (stcb->asoc.total_flight > 0) && 6575 (un_sent < (int)(stcb->asoc.smallest_mtu - SCTP_MIN_OVERHEAD)) 6576 ) { 6577 do_chunk_output = 0; 6578 } 6579 if (do_chunk_output) 6580 sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_USR_SEND, SCTP_SO_NOT_LOCKED); 6581 else if (added_control) { 6582 int num_out = 0, reason = 0, now_filled = 0; 6583 struct timeval now; 6584 int frag_point; 6585 6586 frag_point = sctp_get_frag_point(stcb, &stcb->asoc); 6587 (void)sctp_med_chunk_output(inp, stcb, &stcb->asoc, &num_out, 6588 &reason, 1, 1, &now, &now_filled, frag_point, SCTP_SO_NOT_LOCKED); 6589 } 6590 no_chunk_output: 6591 if (ret) { 6592 ca->cnt_failed++; 6593 } else { 6594 ca->cnt_sent++; 6595 } 6596 } 6597 6598 static void 6599 sctp_sendall_completes(void *ptr, uint32_t val SCTP_UNUSED) 6600 { 6601 struct sctp_copy_all *ca; 6602 6603 ca = (struct sctp_copy_all *)ptr; 6604 /* 6605 * Do a notify here? Kacheong suggests that the notify be done at 6606 * the send time.. so you would push up a notification if any send 6607 * failed. Don't know if this is feasable since the only failures we 6608 * have is "memory" related and if you cannot get an mbuf to send 6609 * the data you surely can't get an mbuf to send up to notify the 6610 * user you can't send the data :-> 6611 */ 6612 6613 /* now free everything */ 6614 sctp_m_freem(ca->m); 6615 SCTP_FREE(ca, SCTP_M_COPYAL); 6616 } 6617 6618 6619 #define MC_ALIGN(m, len) do { \ 6620 SCTP_BUF_RESV_UF(m, ((MCLBYTES - (len)) & ~(sizeof(long) - 1)); \ 6621 } while (0) 6622 6623 6624 6625 static struct mbuf * 6626 sctp_copy_out_all(struct uio *uio, int len) 6627 { 6628 struct mbuf *ret, *at; 6629 int left, willcpy, cancpy, error; 6630 6631 ret = sctp_get_mbuf_for_msg(MCLBYTES, 0, M_WAIT, 1, MT_DATA); 6632 if (ret == NULL) { 6633 /* TSNH */ 6634 return (NULL); 6635 } 6636 left = len; 6637 SCTP_BUF_LEN(ret) = 0; 6638 /* save space for the data chunk header */ 6639 cancpy = M_TRAILINGSPACE(ret); 6640 willcpy = min(cancpy, left); 6641 at = ret; 6642 while (left > 0) { 6643 /* Align data to the end */ 6644 error = uiomove(mtod(at, caddr_t), willcpy, uio); 6645 if (error) { 6646 err_out_now: 6647 sctp_m_freem(at); 6648 return (NULL); 6649 } 6650 SCTP_BUF_LEN(at) = willcpy; 6651 SCTP_BUF_NEXT_PKT(at) = SCTP_BUF_NEXT(at) = 0; 6652 left -= willcpy; 6653 if (left > 0) { 6654 SCTP_BUF_NEXT(at) = sctp_get_mbuf_for_msg(left, 0, M_WAIT, 1, MT_DATA); 6655 if (SCTP_BUF_NEXT(at) == NULL) { 6656 goto err_out_now; 6657 } 6658 at = SCTP_BUF_NEXT(at); 6659 SCTP_BUF_LEN(at) = 0; 6660 cancpy = M_TRAILINGSPACE(at); 6661 willcpy = min(cancpy, left); 6662 } 6663 } 6664 return (ret); 6665 } 6666 6667 static int 6668 sctp_sendall(struct sctp_inpcb *inp, struct uio *uio, struct mbuf *m, 6669 struct sctp_sndrcvinfo *srcv) 6670 { 6671 int ret; 6672 struct sctp_copy_all *ca; 6673 6674 SCTP_MALLOC(ca, struct sctp_copy_all *, sizeof(struct sctp_copy_all), 6675 SCTP_M_COPYAL); 6676 if (ca == NULL) { 6677 sctp_m_freem(m); 6678 SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_OUTPUT, ENOMEM); 6679 return (ENOMEM); 6680 } 6681 memset(ca, 0, sizeof(struct sctp_copy_all)); 6682 6683 ca->inp = inp; 6684 if (srcv) { 6685 memcpy(&ca->sndrcv, srcv, sizeof(struct sctp_nonpad_sndrcvinfo)); 6686 } 6687 /* 6688 * take off the sendall flag, it would be bad if we failed to do 6689 * this :-0 6690 */ 6691 ca->sndrcv.sinfo_flags &= ~SCTP_SENDALL; 6692 /* get length and mbuf chain */ 6693 if (uio) { 6694 ca->sndlen = uio->uio_resid; 6695 ca->m = sctp_copy_out_all(uio, ca->sndlen); 6696 if (ca->m == NULL) { 6697 SCTP_FREE(ca, SCTP_M_COPYAL); 6698 SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTP_OUTPUT, ENOMEM); 6699 return (ENOMEM); 6700 } 6701 } else { 6702 /* Gather the length of the send */ 6703 struct mbuf *mat; 6704 6705 mat = m; 6706 ca->sndlen = 0; 6707 while (m) { 6708 ca->sndlen += SCTP_BUF_LEN(m); 6709 m = SCTP_BUF_NEXT(m); 6710 } 6711 ca->m = mat; 6712 } 6713 ret = sctp_initiate_iterator(NULL, sctp_sendall_iterator, NULL, 6714 SCTP_PCB_ANY_FLAGS, SCTP_PCB_ANY_FEATURES, 6715 SCTP_ASOC_ANY_STATE, 6716 (void *)ca, 0, 6717 sctp_sendall_completes, inp, 1); 6718 if (ret) { 6719 SCTP_PRINTF("Failed to initiate iterator for sendall\n"); 6720 SCTP_FREE(ca, SCTP_M_COPYAL); 6721 SCTP_LTRACE_ERR_RET_PKT(m, inp, NULL, NULL, SCTP_FROM_SCTP_OUTPUT, EFAULT); 6722 return (EFAULT); 6723 } 6724 return (0); 6725 } 6726 6727 6728 void 6729 sctp_toss_old_cookies(struct sctp_tcb *stcb, struct sctp_association *asoc) 6730 { 6731 struct sctp_tmit_chunk *chk, *nchk; 6732 6733 TAILQ_FOREACH_SAFE(chk, &asoc->control_send_queue, sctp_next, nchk) { 6734 if (chk->rec.chunk_id.id == SCTP_COOKIE_ECHO) { 6735 TAILQ_REMOVE(&asoc->control_send_queue, chk, sctp_next); 6736 if (chk->data) { 6737 sctp_m_freem(chk->data); 6738 chk->data = NULL; 6739 } 6740 asoc->ctrl_queue_cnt--; 6741 sctp_free_a_chunk(stcb, chk, SCTP_SO_NOT_LOCKED); 6742 } 6743 } 6744 } 6745 6746 void 6747 sctp_toss_old_asconf(struct sctp_tcb *stcb) 6748 { 6749 struct sctp_association *asoc; 6750 struct sctp_tmit_chunk *chk, *nchk; 6751 struct sctp_asconf_chunk *acp; 6752 6753 asoc = &stcb->asoc; 6754 TAILQ_FOREACH_SAFE(chk, &asoc->asconf_send_queue, sctp_next, nchk) { 6755 /* find SCTP_ASCONF chunk in queue */ 6756 if (chk->rec.chunk_id.id == SCTP_ASCONF) { 6757 if (chk->data) { 6758 acp = mtod(chk->data, struct sctp_asconf_chunk *); 6759 if (SCTP_TSN_GT(ntohl(acp->serial_number), asoc->asconf_seq_out_acked)) { 6760 /* Not Acked yet */ 6761 break; 6762 } 6763 } 6764 TAILQ_REMOVE(&asoc->asconf_send_queue, chk, sctp_next); 6765 if (chk->data) { 6766 sctp_m_freem(chk->data); 6767 chk->data = NULL; 6768 } 6769 asoc->ctrl_queue_cnt--; 6770 sctp_free_a_chunk(stcb, chk, SCTP_SO_NOT_LOCKED); 6771 } 6772 } 6773 } 6774 6775 6776 static void 6777 sctp_clean_up_datalist(struct sctp_tcb *stcb, 6778 struct sctp_association *asoc, 6779 struct sctp_tmit_chunk **data_list, 6780 int bundle_at, 6781 struct sctp_nets *net) 6782 { 6783 int i; 6784 struct sctp_tmit_chunk *tp1; 6785 6786 for (i = 0; i < bundle_at; i++) { 6787 /* off of the send queue */ 6788 TAILQ_REMOVE(&asoc->send_queue, data_list[i], sctp_next); 6789 asoc->send_queue_cnt--; 6790 if (i > 0) { 6791 /* 6792 * Any chunk NOT 0 you zap the time chunk 0 gets 6793 * zapped or set based on if a RTO measurment is 6794 * needed. 6795 */ 6796 data_list[i]->do_rtt = 0; 6797 } 6798 /* record time */ 6799 data_list[i]->sent_rcv_time = net->last_sent_time; 6800 data_list[i]->rec.data.cwnd_at_send = net->cwnd; 6801 data_list[i]->rec.data.fast_retran_tsn = data_list[i]->rec.data.TSN_seq; 6802 if (data_list[i]->whoTo == NULL) { 6803 data_list[i]->whoTo = net; 6804 atomic_add_int(&net->ref_count, 1); 6805 } 6806 /* on to the sent queue */ 6807 tp1 = TAILQ_LAST(&asoc->sent_queue, sctpchunk_listhead); 6808 if ((tp1) && SCTP_TSN_GT(tp1->rec.data.TSN_seq, data_list[i]->rec.data.TSN_seq)) { 6809 struct sctp_tmit_chunk *tpp; 6810 6811 /* need to move back */ 6812 back_up_more: 6813 tpp = TAILQ_PREV(tp1, sctpchunk_listhead, sctp_next); 6814 if (tpp == NULL) { 6815 TAILQ_INSERT_BEFORE(tp1, data_list[i], sctp_next); 6816 goto all_done; 6817 } 6818 tp1 = tpp; 6819 if (SCTP_TSN_GT(tp1->rec.data.TSN_seq, data_list[i]->rec.data.TSN_seq)) { 6820 goto back_up_more; 6821 } 6822 TAILQ_INSERT_AFTER(&asoc->sent_queue, tp1, data_list[i], sctp_next); 6823 } else { 6824 TAILQ_INSERT_TAIL(&asoc->sent_queue, 6825 data_list[i], 6826 sctp_next); 6827 } 6828 all_done: 6829 /* This does not lower until the cum-ack passes it */ 6830 asoc->sent_queue_cnt++; 6831 if ((asoc->peers_rwnd <= 0) && 6832 (asoc->total_flight == 0) && 6833 (bundle_at == 1)) { 6834 /* Mark the chunk as being a window probe */ 6835 SCTP_STAT_INCR(sctps_windowprobed); 6836 } 6837 #ifdef SCTP_AUDITING_ENABLED 6838 sctp_audit_log(0xC2, 3); 6839 #endif 6840 data_list[i]->sent = SCTP_DATAGRAM_SENT; 6841 data_list[i]->snd_count = 1; 6842 data_list[i]->rec.data.chunk_was_revoked = 0; 6843 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_FLIGHT_LOGGING_ENABLE) { 6844 sctp_misc_ints(SCTP_FLIGHT_LOG_UP, 6845 data_list[i]->whoTo->flight_size, 6846 data_list[i]->book_size, 6847 (uintptr_t) data_list[i]->whoTo, 6848 data_list[i]->rec.data.TSN_seq); 6849 } 6850 sctp_flight_size_increase(data_list[i]); 6851 sctp_total_flight_increase(stcb, data_list[i]); 6852 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_LOG_RWND_ENABLE) { 6853 sctp_log_rwnd(SCTP_DECREASE_PEER_RWND, 6854 asoc->peers_rwnd, data_list[i]->send_size, SCTP_BASE_SYSCTL(sctp_peer_chunk_oh)); 6855 } 6856 asoc->peers_rwnd = sctp_sbspace_sub(asoc->peers_rwnd, 6857 (uint32_t) (data_list[i]->send_size + SCTP_BASE_SYSCTL(sctp_peer_chunk_oh))); 6858 if (asoc->peers_rwnd < stcb->sctp_ep->sctp_ep.sctp_sws_sender) { 6859 /* SWS sender side engages */ 6860 asoc->peers_rwnd = 0; 6861 } 6862 } 6863 if (asoc->cc_functions.sctp_cwnd_update_packet_transmitted) { 6864 (*asoc->cc_functions.sctp_cwnd_update_packet_transmitted) (stcb, net); 6865 } 6866 } 6867 6868 static void 6869 sctp_clean_up_ctl(struct sctp_tcb *stcb, struct sctp_association *asoc, int so_locked 6870 #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING) 6871 SCTP_UNUSED 6872 #endif 6873 ) 6874 { 6875 struct sctp_tmit_chunk *chk, *nchk; 6876 6877 TAILQ_FOREACH_SAFE(chk, &asoc->control_send_queue, sctp_next, nchk) { 6878 if ((chk->rec.chunk_id.id == SCTP_SELECTIVE_ACK) || 6879 (chk->rec.chunk_id.id == SCTP_NR_SELECTIVE_ACK) || /* EY */ 6880 (chk->rec.chunk_id.id == SCTP_HEARTBEAT_REQUEST) || 6881 (chk->rec.chunk_id.id == SCTP_HEARTBEAT_ACK) || 6882 (chk->rec.chunk_id.id == SCTP_FORWARD_CUM_TSN) || 6883 (chk->rec.chunk_id.id == SCTP_SHUTDOWN) || 6884 (chk->rec.chunk_id.id == SCTP_SHUTDOWN_ACK) || 6885 (chk->rec.chunk_id.id == SCTP_OPERATION_ERROR) || 6886 (chk->rec.chunk_id.id == SCTP_PACKET_DROPPED) || 6887 (chk->rec.chunk_id.id == SCTP_COOKIE_ACK) || 6888 (chk->rec.chunk_id.id == SCTP_ECN_CWR) || 6889 (chk->rec.chunk_id.id == SCTP_ASCONF_ACK)) { 6890 /* Stray chunks must be cleaned up */ 6891 clean_up_anyway: 6892 TAILQ_REMOVE(&asoc->control_send_queue, chk, sctp_next); 6893 if (chk->data) { 6894 sctp_m_freem(chk->data); 6895 chk->data = NULL; 6896 } 6897 asoc->ctrl_queue_cnt--; 6898 if (chk->rec.chunk_id.id == SCTP_FORWARD_CUM_TSN) 6899 asoc->fwd_tsn_cnt--; 6900 sctp_free_a_chunk(stcb, chk, so_locked); 6901 } else if (chk->rec.chunk_id.id == SCTP_STREAM_RESET) { 6902 /* special handling, we must look into the param */ 6903 if (chk != asoc->str_reset) { 6904 goto clean_up_anyway; 6905 } 6906 } 6907 } 6908 } 6909 6910 6911 static int 6912 sctp_can_we_split_this(struct sctp_tcb *stcb, 6913 uint32_t length, 6914 uint32_t goal_mtu, uint32_t frag_point, int eeor_on) 6915 { 6916 /* 6917 * Make a decision on if I should split a msg into multiple parts. 6918 * This is only asked of incomplete messages. 6919 */ 6920 if (eeor_on) { 6921 /* 6922 * If we are doing EEOR we need to always send it if its the 6923 * entire thing, since it might be all the guy is putting in 6924 * the hopper. 6925 */ 6926 if (goal_mtu >= length) { 6927 /*- 6928 * If we have data outstanding, 6929 * we get another chance when the sack 6930 * arrives to transmit - wait for more data 6931 */ 6932 if (stcb->asoc.total_flight == 0) { 6933 /* 6934 * If nothing is in flight, we zero the 6935 * packet counter. 6936 */ 6937 return (length); 6938 } 6939 return (0); 6940 6941 } else { 6942 /* You can fill the rest */ 6943 return (goal_mtu); 6944 } 6945 } 6946 /*- 6947 * For those strange folk that make the send buffer 6948 * smaller than our fragmentation point, we can't 6949 * get a full msg in so we have to allow splitting. 6950 */ 6951 if (SCTP_SB_LIMIT_SND(stcb->sctp_socket) < frag_point) { 6952 return (length); 6953 } 6954 if ((length <= goal_mtu) || 6955 ((length - goal_mtu) < SCTP_BASE_SYSCTL(sctp_min_residual))) { 6956 /* Sub-optimial residual don't split in non-eeor mode. */ 6957 return (0); 6958 } 6959 /* 6960 * If we reach here length is larger than the goal_mtu. Do we wish 6961 * to split it for the sake of packet putting together? 6962 */ 6963 if (goal_mtu >= min(SCTP_BASE_SYSCTL(sctp_min_split_point), frag_point)) { 6964 /* Its ok to split it */ 6965 return (min(goal_mtu, frag_point)); 6966 } 6967 /* Nope, can't split */ 6968 return (0); 6969 6970 } 6971 6972 static uint32_t 6973 sctp_move_to_outqueue(struct sctp_tcb *stcb, 6974 struct sctp_stream_out *strq, 6975 uint32_t goal_mtu, 6976 uint32_t frag_point, 6977 int *locked, 6978 int *giveup, 6979 int eeor_mode, 6980 int *bail, 6981 int so_locked 6982 #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING) 6983 SCTP_UNUSED 6984 #endif 6985 ) 6986 { 6987 /* Move from the stream to the send_queue keeping track of the total */ 6988 struct sctp_association *asoc; 6989 struct sctp_stream_queue_pending *sp; 6990 struct sctp_tmit_chunk *chk; 6991 struct sctp_data_chunk *dchkh; 6992 uint32_t to_move, length; 6993 uint8_t rcv_flags = 0; 6994 uint8_t some_taken; 6995 uint8_t send_lock_up = 0; 6996 6997 SCTP_TCB_LOCK_ASSERT(stcb); 6998 asoc = &stcb->asoc; 6999 one_more_time: 7000 /* sa_ignore FREED_MEMORY */ 7001 sp = TAILQ_FIRST(&strq->outqueue); 7002 if (sp == NULL) { 7003 *locked = 0; 7004 if (send_lock_up == 0) { 7005 SCTP_TCB_SEND_LOCK(stcb); 7006 send_lock_up = 1; 7007 } 7008 sp = TAILQ_FIRST(&strq->outqueue); 7009 if (sp) { 7010 goto one_more_time; 7011 } 7012 if (strq->last_msg_incomplete) { 7013 SCTP_PRINTF("Huh? Stream:%d lm_in_c=%d but queue is NULL\n", 7014 strq->stream_no, 7015 strq->last_msg_incomplete); 7016 strq->last_msg_incomplete = 0; 7017 } 7018 to_move = 0; 7019 if (send_lock_up) { 7020 SCTP_TCB_SEND_UNLOCK(stcb); 7021 send_lock_up = 0; 7022 } 7023 goto out_of; 7024 } 7025 if ((sp->msg_is_complete) && (sp->length == 0)) { 7026 if (sp->sender_all_done) { 7027 /* 7028 * We are doing differed cleanup. Last time through 7029 * when we took all the data the sender_all_done was 7030 * not set. 7031 */ 7032 if ((sp->put_last_out == 0) && (sp->discard_rest == 0)) { 7033 SCTP_PRINTF("Gak, put out entire msg with NO end!-1\n"); 7034 SCTP_PRINTF("sender_done:%d len:%d msg_comp:%d put_last_out:%d send_lock:%d\n", 7035 sp->sender_all_done, 7036 sp->length, 7037 sp->msg_is_complete, 7038 sp->put_last_out, 7039 send_lock_up); 7040 } 7041 if ((TAILQ_NEXT(sp, next) == NULL) && (send_lock_up == 0)) { 7042 SCTP_TCB_SEND_LOCK(stcb); 7043 send_lock_up = 1; 7044 } 7045 atomic_subtract_int(&asoc->stream_queue_cnt, 1); 7046 TAILQ_REMOVE(&strq->outqueue, sp, next); 7047 stcb->asoc.ss_functions.sctp_ss_remove_from_stream(stcb, asoc, strq, sp, send_lock_up); 7048 if (sp->net) { 7049 sctp_free_remote_addr(sp->net); 7050 sp->net = NULL; 7051 } 7052 if (sp->data) { 7053 sctp_m_freem(sp->data); 7054 sp->data = NULL; 7055 } 7056 sctp_free_a_strmoq(stcb, sp, so_locked); 7057 /* we can't be locked to it */ 7058 *locked = 0; 7059 stcb->asoc.locked_on_sending = NULL; 7060 if (send_lock_up) { 7061 SCTP_TCB_SEND_UNLOCK(stcb); 7062 send_lock_up = 0; 7063 } 7064 /* back to get the next msg */ 7065 goto one_more_time; 7066 } else { 7067 /* 7068 * sender just finished this but still holds a 7069 * reference 7070 */ 7071 *locked = 1; 7072 *giveup = 1; 7073 to_move = 0; 7074 goto out_of; 7075 } 7076 } else { 7077 /* is there some to get */ 7078 if (sp->length == 0) { 7079 /* no */ 7080 *locked = 1; 7081 *giveup = 1; 7082 to_move = 0; 7083 goto out_of; 7084 } else if (sp->discard_rest) { 7085 if (send_lock_up == 0) { 7086 SCTP_TCB_SEND_LOCK(stcb); 7087 send_lock_up = 1; 7088 } 7089 /* Whack down the size */ 7090 atomic_subtract_int(&stcb->asoc.total_output_queue_size, sp->length); 7091 if ((stcb->sctp_socket != NULL) && \ 7092 ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) || 7093 (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL))) { 7094 atomic_subtract_int(&stcb->sctp_socket->so_snd.sb_cc, sp->length); 7095 } 7096 if (sp->data) { 7097 sctp_m_freem(sp->data); 7098 sp->data = NULL; 7099 sp->tail_mbuf = NULL; 7100 } 7101 sp->length = 0; 7102 sp->some_taken = 1; 7103 *locked = 1; 7104 *giveup = 1; 7105 to_move = 0; 7106 goto out_of; 7107 } 7108 } 7109 some_taken = sp->some_taken; 7110 if (stcb->asoc.state & SCTP_STATE_CLOSED_SOCKET) { 7111 sp->msg_is_complete = 1; 7112 } 7113 re_look: 7114 length = sp->length; 7115 if (sp->msg_is_complete) { 7116 /* The message is complete */ 7117 to_move = min(length, frag_point); 7118 if (to_move == length) { 7119 /* All of it fits in the MTU */ 7120 if (sp->some_taken) { 7121 rcv_flags |= SCTP_DATA_LAST_FRAG; 7122 sp->put_last_out = 1; 7123 } else { 7124 rcv_flags |= SCTP_DATA_NOT_FRAG; 7125 sp->put_last_out = 1; 7126 } 7127 } else { 7128 /* Not all of it fits, we fragment */ 7129 if (sp->some_taken == 0) { 7130 rcv_flags |= SCTP_DATA_FIRST_FRAG; 7131 } 7132 sp->some_taken = 1; 7133 } 7134 } else { 7135 to_move = sctp_can_we_split_this(stcb, length, goal_mtu, frag_point, eeor_mode); 7136 if (to_move) { 7137 /*- 7138 * We use a snapshot of length in case it 7139 * is expanding during the compare. 7140 */ 7141 uint32_t llen; 7142 7143 llen = length; 7144 if (to_move >= llen) { 7145 to_move = llen; 7146 if (send_lock_up == 0) { 7147 /*- 7148 * We are taking all of an incomplete msg 7149 * thus we need a send lock. 7150 */ 7151 SCTP_TCB_SEND_LOCK(stcb); 7152 send_lock_up = 1; 7153 if (sp->msg_is_complete) { 7154 /* 7155 * the sender finished the 7156 * msg 7157 */ 7158 goto re_look; 7159 } 7160 } 7161 } 7162 if (sp->some_taken == 0) { 7163 rcv_flags |= SCTP_DATA_FIRST_FRAG; 7164 sp->some_taken = 1; 7165 } 7166 } else { 7167 /* Nothing to take. */ 7168 if (sp->some_taken) { 7169 *locked = 1; 7170 } 7171 *giveup = 1; 7172 to_move = 0; 7173 goto out_of; 7174 } 7175 } 7176 7177 /* If we reach here, we can copy out a chunk */ 7178 sctp_alloc_a_chunk(stcb, chk); 7179 if (chk == NULL) { 7180 /* No chunk memory */ 7181 *giveup = 1; 7182 to_move = 0; 7183 goto out_of; 7184 } 7185 /* 7186 * Setup for unordered if needed by looking at the user sent info 7187 * flags. 7188 */ 7189 if (sp->sinfo_flags & SCTP_UNORDERED) { 7190 rcv_flags |= SCTP_DATA_UNORDERED; 7191 } 7192 if ((SCTP_BASE_SYSCTL(sctp_enable_sack_immediately) && ((sp->sinfo_flags & SCTP_EOF) == SCTP_EOF)) || 7193 ((sp->sinfo_flags & SCTP_SACK_IMMEDIATELY) == SCTP_SACK_IMMEDIATELY)) { 7194 rcv_flags |= SCTP_DATA_SACK_IMMEDIATELY; 7195 } 7196 /* clear out the chunk before setting up */ 7197 memset(chk, 0, sizeof(*chk)); 7198 chk->rec.data.rcv_flags = rcv_flags; 7199 7200 if (to_move >= length) { 7201 /* we think we can steal the whole thing */ 7202 if ((sp->sender_all_done == 0) && (send_lock_up == 0)) { 7203 SCTP_TCB_SEND_LOCK(stcb); 7204 send_lock_up = 1; 7205 } 7206 if (to_move < sp->length) { 7207 /* bail, it changed */ 7208 goto dont_do_it; 7209 } 7210 chk->data = sp->data; 7211 chk->last_mbuf = sp->tail_mbuf; 7212 /* register the stealing */ 7213 sp->data = sp->tail_mbuf = NULL; 7214 } else { 7215 struct mbuf *m; 7216 7217 dont_do_it: 7218 chk->data = SCTP_M_COPYM(sp->data, 0, to_move, M_DONTWAIT); 7219 chk->last_mbuf = NULL; 7220 if (chk->data == NULL) { 7221 sp->some_taken = some_taken; 7222 sctp_free_a_chunk(stcb, chk, so_locked); 7223 *bail = 1; 7224 to_move = 0; 7225 goto out_of; 7226 } 7227 #ifdef SCTP_MBUF_LOGGING 7228 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_MBUF_LOGGING_ENABLE) { 7229 struct mbuf *mat; 7230 7231 for (mat = chk->data; mat; mat = SCTP_BUF_NEXT(mat)) { 7232 if (SCTP_BUF_IS_EXTENDED(mat)) { 7233 sctp_log_mb(mat, SCTP_MBUF_ICOPY); 7234 } 7235 } 7236 } 7237 #endif 7238 /* Pull off the data */ 7239 m_adj(sp->data, to_move); 7240 /* Now lets work our way down and compact it */ 7241 m = sp->data; 7242 while (m && (SCTP_BUF_LEN(m) == 0)) { 7243 sp->data = SCTP_BUF_NEXT(m); 7244 SCTP_BUF_NEXT(m) = NULL; 7245 if (sp->tail_mbuf == m) { 7246 /*- 7247 * Freeing tail? TSNH since 7248 * we supposedly were taking less 7249 * than the sp->length. 7250 */ 7251 #ifdef INVARIANTS 7252 panic("Huh, freing tail? - TSNH"); 7253 #else 7254 SCTP_PRINTF("Huh, freeing tail? - TSNH\n"); 7255 sp->tail_mbuf = sp->data = NULL; 7256 sp->length = 0; 7257 #endif 7258 7259 } 7260 sctp_m_free(m); 7261 m = sp->data; 7262 } 7263 } 7264 if (SCTP_BUF_IS_EXTENDED(chk->data)) { 7265 chk->copy_by_ref = 1; 7266 } else { 7267 chk->copy_by_ref = 0; 7268 } 7269 /* 7270 * get last_mbuf and counts of mb useage This is ugly but hopefully 7271 * its only one mbuf. 7272 */ 7273 if (chk->last_mbuf == NULL) { 7274 chk->last_mbuf = chk->data; 7275 while (SCTP_BUF_NEXT(chk->last_mbuf) != NULL) { 7276 chk->last_mbuf = SCTP_BUF_NEXT(chk->last_mbuf); 7277 } 7278 } 7279 if (to_move > length) { 7280 /*- This should not happen either 7281 * since we always lower to_move to the size 7282 * of sp->length if its larger. 7283 */ 7284 #ifdef INVARIANTS 7285 panic("Huh, how can to_move be larger?"); 7286 #else 7287 SCTP_PRINTF("Huh, how can to_move be larger?\n"); 7288 sp->length = 0; 7289 #endif 7290 } else { 7291 atomic_subtract_int(&sp->length, to_move); 7292 } 7293 if (M_LEADINGSPACE(chk->data) < (int)sizeof(struct sctp_data_chunk)) { 7294 /* Not enough room for a chunk header, get some */ 7295 struct mbuf *m; 7296 7297 m = sctp_get_mbuf_for_msg(1, 0, M_DONTWAIT, 0, MT_DATA); 7298 if (m == NULL) { 7299 /* 7300 * we're in trouble here. _PREPEND below will free 7301 * all the data if there is no leading space, so we 7302 * must put the data back and restore. 7303 */ 7304 if (send_lock_up == 0) { 7305 SCTP_TCB_SEND_LOCK(stcb); 7306 send_lock_up = 1; 7307 } 7308 if (chk->data == NULL) { 7309 /* unsteal the data */ 7310 sp->data = chk->data; 7311 sp->tail_mbuf = chk->last_mbuf; 7312 } else { 7313 struct mbuf *m_tmp; 7314 7315 /* reassemble the data */ 7316 m_tmp = sp->data; 7317 sp->data = chk->data; 7318 SCTP_BUF_NEXT(chk->last_mbuf) = m_tmp; 7319 } 7320 sp->some_taken = some_taken; 7321 atomic_add_int(&sp->length, to_move); 7322 chk->data = NULL; 7323 *bail = 1; 7324 sctp_free_a_chunk(stcb, chk, so_locked); 7325 to_move = 0; 7326 goto out_of; 7327 } else { 7328 SCTP_BUF_LEN(m) = 0; 7329 SCTP_BUF_NEXT(m) = chk->data; 7330 chk->data = m; 7331 M_ALIGN(chk->data, 4); 7332 } 7333 } 7334 SCTP_BUF_PREPEND(chk->data, sizeof(struct sctp_data_chunk), M_DONTWAIT); 7335 if (chk->data == NULL) { 7336 /* HELP, TSNH since we assured it would not above? */ 7337 #ifdef INVARIANTS 7338 panic("prepend failes HELP?"); 7339 #else 7340 SCTP_PRINTF("prepend fails HELP?\n"); 7341 sctp_free_a_chunk(stcb, chk, so_locked); 7342 #endif 7343 *bail = 1; 7344 to_move = 0; 7345 goto out_of; 7346 } 7347 sctp_snd_sb_alloc(stcb, sizeof(struct sctp_data_chunk)); 7348 chk->book_size = chk->send_size = (to_move + sizeof(struct sctp_data_chunk)); 7349 chk->book_size_scale = 0; 7350 chk->sent = SCTP_DATAGRAM_UNSENT; 7351 7352 chk->flags = 0; 7353 chk->asoc = &stcb->asoc; 7354 chk->pad_inplace = 0; 7355 chk->no_fr_allowed = 0; 7356 chk->rec.data.stream_seq = strq->next_sequence_send; 7357 if (rcv_flags & SCTP_DATA_LAST_FRAG) { 7358 strq->next_sequence_send++; 7359 } 7360 chk->rec.data.stream_number = sp->stream; 7361 chk->rec.data.payloadtype = sp->ppid; 7362 chk->rec.data.context = sp->context; 7363 chk->rec.data.doing_fast_retransmit = 0; 7364 7365 chk->rec.data.timetodrop = sp->ts; 7366 chk->flags = sp->act_flags; 7367 7368 if (sp->net) { 7369 chk->whoTo = sp->net; 7370 atomic_add_int(&chk->whoTo->ref_count, 1); 7371 } else 7372 chk->whoTo = NULL; 7373 7374 if (sp->holds_key_ref) { 7375 chk->auth_keyid = sp->auth_keyid; 7376 sctp_auth_key_acquire(stcb, chk->auth_keyid); 7377 chk->holds_key_ref = 1; 7378 } 7379 chk->rec.data.TSN_seq = atomic_fetchadd_int(&asoc->sending_seq, 1); 7380 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_LOG_AT_SEND_2_OUTQ) { 7381 sctp_misc_ints(SCTP_STRMOUT_LOG_SEND, 7382 (uintptr_t) stcb, sp->length, 7383 (uint32_t) ((chk->rec.data.stream_number << 16) | chk->rec.data.stream_seq), 7384 chk->rec.data.TSN_seq); 7385 } 7386 dchkh = mtod(chk->data, struct sctp_data_chunk *); 7387 /* 7388 * Put the rest of the things in place now. Size was done earlier in 7389 * previous loop prior to padding. 7390 */ 7391 7392 #ifdef SCTP_ASOCLOG_OF_TSNS 7393 SCTP_TCB_LOCK_ASSERT(stcb); 7394 if (asoc->tsn_out_at >= SCTP_TSN_LOG_SIZE) { 7395 asoc->tsn_out_at = 0; 7396 asoc->tsn_out_wrapped = 1; 7397 } 7398 asoc->out_tsnlog[asoc->tsn_out_at].tsn = chk->rec.data.TSN_seq; 7399 asoc->out_tsnlog[asoc->tsn_out_at].strm = chk->rec.data.stream_number; 7400 asoc->out_tsnlog[asoc->tsn_out_at].seq = chk->rec.data.stream_seq; 7401 asoc->out_tsnlog[asoc->tsn_out_at].sz = chk->send_size; 7402 asoc->out_tsnlog[asoc->tsn_out_at].flgs = chk->rec.data.rcv_flags; 7403 asoc->out_tsnlog[asoc->tsn_out_at].stcb = (void *)stcb; 7404 asoc->out_tsnlog[asoc->tsn_out_at].in_pos = asoc->tsn_out_at; 7405 asoc->out_tsnlog[asoc->tsn_out_at].in_out = 2; 7406 asoc->tsn_out_at++; 7407 #endif 7408 7409 dchkh->ch.chunk_type = SCTP_DATA; 7410 dchkh->ch.chunk_flags = chk->rec.data.rcv_flags; 7411 dchkh->dp.tsn = htonl(chk->rec.data.TSN_seq); 7412 dchkh->dp.stream_id = htons(strq->stream_no); 7413 dchkh->dp.stream_sequence = htons(chk->rec.data.stream_seq); 7414 dchkh->dp.protocol_id = chk->rec.data.payloadtype; 7415 dchkh->ch.chunk_length = htons(chk->send_size); 7416 /* Now advance the chk->send_size by the actual pad needed. */ 7417 if (chk->send_size < SCTP_SIZE32(chk->book_size)) { 7418 /* need a pad */ 7419 struct mbuf *lm; 7420 int pads; 7421 7422 pads = SCTP_SIZE32(chk->book_size) - chk->send_size; 7423 if (sctp_pad_lastmbuf(chk->data, pads, chk->last_mbuf) == 0) { 7424 chk->pad_inplace = 1; 7425 } 7426 if ((lm = SCTP_BUF_NEXT(chk->last_mbuf)) != NULL) { 7427 /* pad added an mbuf */ 7428 chk->last_mbuf = lm; 7429 } 7430 chk->send_size += pads; 7431 } 7432 /* We only re-set the policy if it is on */ 7433 if (sp->pr_sctp_on) { 7434 sctp_set_prsctp_policy(sp); 7435 asoc->pr_sctp_cnt++; 7436 chk->pr_sctp_on = 1; 7437 } else { 7438 chk->pr_sctp_on = 0; 7439 } 7440 if (sp->msg_is_complete && (sp->length == 0) && (sp->sender_all_done)) { 7441 /* All done pull and kill the message */ 7442 atomic_subtract_int(&asoc->stream_queue_cnt, 1); 7443 if (sp->put_last_out == 0) { 7444 SCTP_PRINTF("Gak, put out entire msg with NO end!-2\n"); 7445 SCTP_PRINTF("sender_done:%d len:%d msg_comp:%d put_last_out:%d send_lock:%d\n", 7446 sp->sender_all_done, 7447 sp->length, 7448 sp->msg_is_complete, 7449 sp->put_last_out, 7450 send_lock_up); 7451 } 7452 if ((send_lock_up == 0) && (TAILQ_NEXT(sp, next) == NULL)) { 7453 SCTP_TCB_SEND_LOCK(stcb); 7454 send_lock_up = 1; 7455 } 7456 TAILQ_REMOVE(&strq->outqueue, sp, next); 7457 stcb->asoc.ss_functions.sctp_ss_remove_from_stream(stcb, asoc, strq, sp, send_lock_up); 7458 if (sp->net) { 7459 sctp_free_remote_addr(sp->net); 7460 sp->net = NULL; 7461 } 7462 if (sp->data) { 7463 sctp_m_freem(sp->data); 7464 sp->data = NULL; 7465 } 7466 sctp_free_a_strmoq(stcb, sp, so_locked); 7467 7468 /* we can't be locked to it */ 7469 *locked = 0; 7470 stcb->asoc.locked_on_sending = NULL; 7471 } else { 7472 /* more to go, we are locked */ 7473 *locked = 1; 7474 } 7475 asoc->chunks_on_out_queue++; 7476 strq->chunks_on_queues++; 7477 TAILQ_INSERT_TAIL(&asoc->send_queue, chk, sctp_next); 7478 asoc->send_queue_cnt++; 7479 out_of: 7480 if (send_lock_up) { 7481 SCTP_TCB_SEND_UNLOCK(stcb); 7482 } 7483 return (to_move); 7484 } 7485 7486 7487 static void 7488 sctp_fill_outqueue(struct sctp_tcb *stcb, 7489 struct sctp_nets *net, int frag_point, int eeor_mode, int *quit_now, int so_locked 7490 #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING) 7491 SCTP_UNUSED 7492 #endif 7493 ) 7494 { 7495 struct sctp_association *asoc; 7496 struct sctp_stream_out *strq; 7497 int goal_mtu, moved_how_much, total_moved = 0, bail = 0; 7498 int locked, giveup; 7499 7500 SCTP_TCB_LOCK_ASSERT(stcb); 7501 asoc = &stcb->asoc; 7502 switch (net->ro._l_addr.sa.sa_family) { 7503 #ifdef INET 7504 case AF_INET: 7505 goal_mtu = net->mtu - SCTP_MIN_V4_OVERHEAD; 7506 break; 7507 #endif 7508 #ifdef INET6 7509 case AF_INET6: 7510 goal_mtu = net->mtu - SCTP_MIN_OVERHEAD; 7511 break; 7512 #endif 7513 default: 7514 /* TSNH */ 7515 goal_mtu = net->mtu; 7516 break; 7517 } 7518 /* Need an allowance for the data chunk header too */ 7519 goal_mtu -= sizeof(struct sctp_data_chunk); 7520 7521 /* must make even word boundary */ 7522 goal_mtu &= 0xfffffffc; 7523 if (asoc->locked_on_sending) { 7524 /* We are stuck on one stream until the message completes. */ 7525 strq = asoc->locked_on_sending; 7526 locked = 1; 7527 } else { 7528 strq = stcb->asoc.ss_functions.sctp_ss_select_stream(stcb, net, asoc); 7529 locked = 0; 7530 } 7531 while ((goal_mtu > 0) && strq) { 7532 giveup = 0; 7533 bail = 0; 7534 moved_how_much = sctp_move_to_outqueue(stcb, strq, goal_mtu, frag_point, &locked, 7535 &giveup, eeor_mode, &bail, so_locked); 7536 if (moved_how_much) 7537 stcb->asoc.ss_functions.sctp_ss_scheduled(stcb, net, asoc, strq, moved_how_much); 7538 7539 if (locked) { 7540 asoc->locked_on_sending = strq; 7541 if ((moved_how_much == 0) || (giveup) || bail) 7542 /* no more to move for now */ 7543 break; 7544 } else { 7545 asoc->locked_on_sending = NULL; 7546 if ((giveup) || bail) { 7547 break; 7548 } 7549 strq = stcb->asoc.ss_functions.sctp_ss_select_stream(stcb, net, asoc); 7550 if (strq == NULL) { 7551 break; 7552 } 7553 } 7554 total_moved += moved_how_much; 7555 goal_mtu -= (moved_how_much + sizeof(struct sctp_data_chunk)); 7556 goal_mtu &= 0xfffffffc; 7557 } 7558 if (bail) 7559 *quit_now = 1; 7560 7561 stcb->asoc.ss_functions.sctp_ss_packet_done(stcb, net, asoc); 7562 7563 if (total_moved == 0) { 7564 if ((stcb->asoc.sctp_cmt_on_off == 0) && 7565 (net == stcb->asoc.primary_destination)) { 7566 /* ran dry for primary network net */ 7567 SCTP_STAT_INCR(sctps_primary_randry); 7568 } else if (stcb->asoc.sctp_cmt_on_off > 0) { 7569 /* ran dry with CMT on */ 7570 SCTP_STAT_INCR(sctps_cmt_randry); 7571 } 7572 } 7573 } 7574 7575 void 7576 sctp_fix_ecn_echo(struct sctp_association *asoc) 7577 { 7578 struct sctp_tmit_chunk *chk; 7579 7580 TAILQ_FOREACH(chk, &asoc->control_send_queue, sctp_next) { 7581 if (chk->rec.chunk_id.id == SCTP_ECN_ECHO) { 7582 chk->sent = SCTP_DATAGRAM_UNSENT; 7583 } 7584 } 7585 } 7586 7587 void 7588 sctp_move_chunks_from_net(struct sctp_tcb *stcb, struct sctp_nets *net) 7589 { 7590 struct sctp_association *asoc; 7591 struct sctp_tmit_chunk *chk; 7592 struct sctp_stream_queue_pending *sp; 7593 unsigned int i; 7594 7595 if (net == NULL) { 7596 return; 7597 } 7598 asoc = &stcb->asoc; 7599 for (i = 0; i < stcb->asoc.streamoutcnt; i++) { 7600 TAILQ_FOREACH(sp, &stcb->asoc.strmout[i].outqueue, next) { 7601 if (sp->net == net) { 7602 sctp_free_remote_addr(sp->net); 7603 sp->net = NULL; 7604 } 7605 } 7606 } 7607 TAILQ_FOREACH(chk, &asoc->send_queue, sctp_next) { 7608 if (chk->whoTo == net) { 7609 sctp_free_remote_addr(chk->whoTo); 7610 chk->whoTo = NULL; 7611 } 7612 } 7613 } 7614 7615 int 7616 sctp_med_chunk_output(struct sctp_inpcb *inp, 7617 struct sctp_tcb *stcb, 7618 struct sctp_association *asoc, 7619 int *num_out, 7620 int *reason_code, 7621 int control_only, int from_where, 7622 struct timeval *now, int *now_filled, int frag_point, int so_locked 7623 #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING) 7624 SCTP_UNUSED 7625 #endif 7626 ) 7627 { 7628 /* 7629 * Ok this is the generic chunk service queue. we must do the 7630 * following: - Service the stream queue that is next, moving any 7631 * message (note I must get a complete message i.e. FIRST/MIDDLE and 7632 * LAST to the out queue in one pass) and assigning TSN's - Check to 7633 * see if the cwnd/rwnd allows any output, if so we go ahead and 7634 * fomulate and send the low level chunks. Making sure to combine 7635 * any control in the control chunk queue also. 7636 */ 7637 struct sctp_nets *net, *start_at, *sack_goes_to = NULL, *old_start_at = NULL; 7638 struct mbuf *outchain, *endoutchain; 7639 struct sctp_tmit_chunk *chk, *nchk; 7640 7641 /* temp arrays for unlinking */ 7642 struct sctp_tmit_chunk *data_list[SCTP_MAX_DATA_BUNDLING]; 7643 int no_fragmentflg, error; 7644 unsigned int max_rwnd_per_dest, max_send_per_dest; 7645 int one_chunk, hbflag, skip_data_for_this_net; 7646 int asconf, cookie, no_out_cnt; 7647 int bundle_at, ctl_cnt, no_data_chunks, eeor_mode; 7648 unsigned int mtu, r_mtu, omtu, mx_mtu, to_out; 7649 int tsns_sent = 0; 7650 uint32_t auth_offset = 0; 7651 struct sctp_auth_chunk *auth = NULL; 7652 uint16_t auth_keyid; 7653 int override_ok = 1; 7654 int skip_fill_up = 0; 7655 int data_auth_reqd = 0; 7656 7657 /* 7658 * JRS 5/14/07 - Add flag for whether a heartbeat is sent to the 7659 * destination. 7660 */ 7661 int quit_now = 0; 7662 7663 *num_out = 0; 7664 auth_keyid = stcb->asoc.authinfo.active_keyid; 7665 7666 if ((asoc->state & SCTP_STATE_SHUTDOWN_PENDING) || 7667 (asoc->state & SCTP_STATE_SHUTDOWN_RECEIVED) || 7668 (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_EXPLICIT_EOR))) { 7669 eeor_mode = 1; 7670 } else { 7671 eeor_mode = 0; 7672 } 7673 ctl_cnt = no_out_cnt = asconf = cookie = 0; 7674 /* 7675 * First lets prime the pump. For each destination, if there is room 7676 * in the flight size, attempt to pull an MTU's worth out of the 7677 * stream queues into the general send_queue 7678 */ 7679 #ifdef SCTP_AUDITING_ENABLED 7680 sctp_audit_log(0xC2, 2); 7681 #endif 7682 SCTP_TCB_LOCK_ASSERT(stcb); 7683 hbflag = 0; 7684 if ((control_only) || (asoc->stream_reset_outstanding)) 7685 no_data_chunks = 1; 7686 else 7687 no_data_chunks = 0; 7688 7689 /* Nothing to possible to send? */ 7690 if ((TAILQ_EMPTY(&asoc->control_send_queue) || 7691 (asoc->ctrl_queue_cnt == stcb->asoc.ecn_echo_cnt_onq)) && 7692 TAILQ_EMPTY(&asoc->asconf_send_queue) && 7693 TAILQ_EMPTY(&asoc->send_queue) && 7694 stcb->asoc.ss_functions.sctp_ss_is_empty(stcb, asoc)) { 7695 nothing_to_send: 7696 *reason_code = 9; 7697 return (0); 7698 } 7699 if (asoc->peers_rwnd == 0) { 7700 /* No room in peers rwnd */ 7701 *reason_code = 1; 7702 if (asoc->total_flight > 0) { 7703 /* we are allowed one chunk in flight */ 7704 no_data_chunks = 1; 7705 } 7706 } 7707 if (stcb->asoc.ecn_echo_cnt_onq) { 7708 /* Record where a sack goes, if any */ 7709 if (no_data_chunks && 7710 (asoc->ctrl_queue_cnt == stcb->asoc.ecn_echo_cnt_onq)) { 7711 /* Nothing but ECNe to send - we don't do that */ 7712 goto nothing_to_send; 7713 } 7714 TAILQ_FOREACH(chk, &asoc->control_send_queue, sctp_next) { 7715 if ((chk->rec.chunk_id.id == SCTP_SELECTIVE_ACK) || 7716 (chk->rec.chunk_id.id == SCTP_NR_SELECTIVE_ACK)) { 7717 sack_goes_to = chk->whoTo; 7718 break; 7719 } 7720 } 7721 } 7722 max_rwnd_per_dest = ((asoc->peers_rwnd + asoc->total_flight) / asoc->numnets); 7723 if (stcb->sctp_socket) 7724 max_send_per_dest = SCTP_SB_LIMIT_SND(stcb->sctp_socket) / asoc->numnets; 7725 else 7726 max_send_per_dest = 0; 7727 if (no_data_chunks == 0) { 7728 /* How many non-directed chunks are there? */ 7729 TAILQ_FOREACH(chk, &asoc->send_queue, sctp_next) { 7730 if (chk->whoTo == NULL) { 7731 /* 7732 * We already have non-directed chunks on 7733 * the queue, no need to do a fill-up. 7734 */ 7735 skip_fill_up = 1; 7736 break; 7737 } 7738 } 7739 7740 } 7741 if ((no_data_chunks == 0) && 7742 (skip_fill_up == 0) && 7743 (!stcb->asoc.ss_functions.sctp_ss_is_empty(stcb, asoc))) { 7744 TAILQ_FOREACH(net, &asoc->nets, sctp_next) { 7745 /* 7746 * This for loop we are in takes in each net, if 7747 * its's got space in cwnd and has data sent to it 7748 * (when CMT is off) then it calls 7749 * sctp_fill_outqueue for the net. This gets data on 7750 * the send queue for that network. 7751 * 7752 * In sctp_fill_outqueue TSN's are assigned and data is 7753 * copied out of the stream buffers. Note mostly 7754 * copy by reference (we hope). 7755 */ 7756 net->window_probe = 0; 7757 if ((net != stcb->asoc.alternate) && 7758 ((net->dest_state & SCTP_ADDR_PF) || 7759 (!(net->dest_state & SCTP_ADDR_REACHABLE)) || 7760 (net->dest_state & SCTP_ADDR_UNCONFIRMED))) { 7761 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_LOGGING_ENABLE) { 7762 sctp_log_cwnd(stcb, net, 1, 7763 SCTP_CWND_LOG_FILL_OUTQ_CALLED); 7764 } 7765 continue; 7766 } 7767 if ((stcb->asoc.cc_functions.sctp_cwnd_new_transmission_begins) && 7768 (net->flight_size == 0)) { 7769 (*stcb->asoc.cc_functions.sctp_cwnd_new_transmission_begins) (stcb, net); 7770 } 7771 if (net->flight_size >= net->cwnd) { 7772 /* skip this network, no room - can't fill */ 7773 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_LOGGING_ENABLE) { 7774 sctp_log_cwnd(stcb, net, 3, 7775 SCTP_CWND_LOG_FILL_OUTQ_CALLED); 7776 } 7777 continue; 7778 } 7779 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_LOGGING_ENABLE) { 7780 sctp_log_cwnd(stcb, net, 4, SCTP_CWND_LOG_FILL_OUTQ_CALLED); 7781 } 7782 sctp_fill_outqueue(stcb, net, frag_point, eeor_mode, &quit_now, so_locked); 7783 if (quit_now) { 7784 /* memory alloc failure */ 7785 no_data_chunks = 1; 7786 break; 7787 } 7788 } 7789 } 7790 /* now service each destination and send out what we can for it */ 7791 /* Nothing to send? */ 7792 if (TAILQ_EMPTY(&asoc->control_send_queue) && 7793 TAILQ_EMPTY(&asoc->asconf_send_queue) && 7794 TAILQ_EMPTY(&asoc->send_queue)) { 7795 *reason_code = 8; 7796 return (0); 7797 } 7798 if (asoc->sctp_cmt_on_off > 0) { 7799 /* get the last start point */ 7800 start_at = asoc->last_net_cmt_send_started; 7801 if (start_at == NULL) { 7802 /* null so to beginning */ 7803 start_at = TAILQ_FIRST(&asoc->nets); 7804 } else { 7805 start_at = TAILQ_NEXT(asoc->last_net_cmt_send_started, sctp_next); 7806 if (start_at == NULL) { 7807 start_at = TAILQ_FIRST(&asoc->nets); 7808 } 7809 } 7810 asoc->last_net_cmt_send_started = start_at; 7811 } else { 7812 start_at = TAILQ_FIRST(&asoc->nets); 7813 } 7814 TAILQ_FOREACH(chk, &asoc->control_send_queue, sctp_next) { 7815 if (chk->whoTo == NULL) { 7816 if (asoc->alternate) { 7817 chk->whoTo = asoc->alternate; 7818 } else { 7819 chk->whoTo = asoc->primary_destination; 7820 } 7821 atomic_add_int(&chk->whoTo->ref_count, 1); 7822 } 7823 } 7824 old_start_at = NULL; 7825 again_one_more_time: 7826 for (net = start_at; net != NULL; net = TAILQ_NEXT(net, sctp_next)) { 7827 /* how much can we send? */ 7828 /* SCTPDBG("Examine for sending net:%x\n", (uint32_t)net); */ 7829 if (old_start_at && (old_start_at == net)) { 7830 /* through list ocmpletely. */ 7831 break; 7832 } 7833 tsns_sent = 0xa; 7834 if (TAILQ_EMPTY(&asoc->control_send_queue) && 7835 TAILQ_EMPTY(&asoc->asconf_send_queue) && 7836 (net->flight_size >= net->cwnd)) { 7837 /* 7838 * Nothing on control or asconf and flight is full, 7839 * we can skip even in the CMT case. 7840 */ 7841 continue; 7842 } 7843 bundle_at = 0; 7844 endoutchain = outchain = NULL; 7845 no_fragmentflg = 1; 7846 one_chunk = 0; 7847 if (net->dest_state & SCTP_ADDR_UNCONFIRMED) { 7848 skip_data_for_this_net = 1; 7849 } else { 7850 skip_data_for_this_net = 0; 7851 } 7852 if ((net->ro.ro_rt) && (net->ro.ro_rt->rt_ifp)) { 7853 /* 7854 * if we have a route and an ifp check to see if we 7855 * have room to send to this guy 7856 */ 7857 struct ifnet *ifp; 7858 7859 ifp = net->ro.ro_rt->rt_ifp; 7860 if ((ifp->if_snd.ifq_len + 2) >= ifp->if_snd.ifq_maxlen) { 7861 SCTP_STAT_INCR(sctps_ifnomemqueued); 7862 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_LOG_MAXBURST_ENABLE) { 7863 sctp_log_maxburst(stcb, net, ifp->if_snd.ifq_len, ifp->if_snd.ifq_maxlen, SCTP_MAX_IFP_APPLIED); 7864 } 7865 continue; 7866 } 7867 } 7868 switch (((struct sockaddr *)&net->ro._l_addr)->sa_family) { 7869 #ifdef INET 7870 case AF_INET: 7871 mtu = net->mtu - (sizeof(struct ip) + sizeof(struct sctphdr)); 7872 break; 7873 #endif 7874 #ifdef INET6 7875 case AF_INET6: 7876 mtu = net->mtu - (sizeof(struct ip6_hdr) + sizeof(struct sctphdr)); 7877 break; 7878 #endif 7879 default: 7880 /* TSNH */ 7881 mtu = net->mtu; 7882 break; 7883 } 7884 mx_mtu = mtu; 7885 to_out = 0; 7886 if (mtu > asoc->peers_rwnd) { 7887 if (asoc->total_flight > 0) { 7888 /* We have a packet in flight somewhere */ 7889 r_mtu = asoc->peers_rwnd; 7890 } else { 7891 /* We are always allowed to send one MTU out */ 7892 one_chunk = 1; 7893 r_mtu = mtu; 7894 } 7895 } else { 7896 r_mtu = mtu; 7897 } 7898 /************************/ 7899 /* ASCONF transmission */ 7900 /************************/ 7901 /* Now first lets go through the asconf queue */ 7902 TAILQ_FOREACH_SAFE(chk, &asoc->asconf_send_queue, sctp_next, nchk) { 7903 if (chk->rec.chunk_id.id != SCTP_ASCONF) { 7904 continue; 7905 } 7906 if (chk->whoTo == NULL) { 7907 if (asoc->alternate == NULL) { 7908 if (asoc->primary_destination != net) { 7909 break; 7910 } 7911 } else { 7912 if (asoc->alternate != net) { 7913 break; 7914 } 7915 } 7916 } else { 7917 if (chk->whoTo != net) { 7918 break; 7919 } 7920 } 7921 if (chk->data == NULL) { 7922 break; 7923 } 7924 if (chk->sent != SCTP_DATAGRAM_UNSENT && 7925 chk->sent != SCTP_DATAGRAM_RESEND) { 7926 break; 7927 } 7928 /* 7929 * if no AUTH is yet included and this chunk 7930 * requires it, make sure to account for it. We 7931 * don't apply the size until the AUTH chunk is 7932 * actually added below in case there is no room for 7933 * this chunk. NOTE: we overload the use of "omtu" 7934 * here 7935 */ 7936 if ((auth == NULL) && 7937 sctp_auth_is_required_chunk(chk->rec.chunk_id.id, 7938 stcb->asoc.peer_auth_chunks)) { 7939 omtu = sctp_get_auth_chunk_len(stcb->asoc.peer_hmac_id); 7940 } else 7941 omtu = 0; 7942 /* Here we do NOT factor the r_mtu */ 7943 if ((chk->send_size < (int)(mtu - omtu)) || 7944 (chk->flags & CHUNK_FLAGS_FRAGMENT_OK)) { 7945 /* 7946 * We probably should glom the mbuf chain 7947 * from the chk->data for control but the 7948 * problem is it becomes yet one more level 7949 * of tracking to do if for some reason 7950 * output fails. Then I have got to 7951 * reconstruct the merged control chain.. el 7952 * yucko.. for now we take the easy way and 7953 * do the copy 7954 */ 7955 /* 7956 * Add an AUTH chunk, if chunk requires it 7957 * save the offset into the chain for AUTH 7958 */ 7959 if ((auth == NULL) && 7960 (sctp_auth_is_required_chunk(chk->rec.chunk_id.id, 7961 stcb->asoc.peer_auth_chunks))) { 7962 outchain = sctp_add_auth_chunk(outchain, 7963 &endoutchain, 7964 &auth, 7965 &auth_offset, 7966 stcb, 7967 chk->rec.chunk_id.id); 7968 SCTP_STAT_INCR_COUNTER64(sctps_outcontrolchunks); 7969 } 7970 outchain = sctp_copy_mbufchain(chk->data, outchain, &endoutchain, 7971 (int)chk->rec.chunk_id.can_take_data, 7972 chk->send_size, chk->copy_by_ref); 7973 if (outchain == NULL) { 7974 *reason_code = 8; 7975 SCTP_LTRACE_ERR_RET(inp, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, ENOMEM); 7976 return (ENOMEM); 7977 } 7978 SCTP_STAT_INCR_COUNTER64(sctps_outcontrolchunks); 7979 /* update our MTU size */ 7980 if (mtu > (chk->send_size + omtu)) 7981 mtu -= (chk->send_size + omtu); 7982 else 7983 mtu = 0; 7984 to_out += (chk->send_size + omtu); 7985 /* Do clear IP_DF ? */ 7986 if (chk->flags & CHUNK_FLAGS_FRAGMENT_OK) { 7987 no_fragmentflg = 0; 7988 } 7989 if (chk->rec.chunk_id.can_take_data) 7990 chk->data = NULL; 7991 /* 7992 * set hb flag since we can use these for 7993 * RTO 7994 */ 7995 hbflag = 1; 7996 asconf = 1; 7997 /* 7998 * should sysctl this: don't bundle data 7999 * with ASCONF since it requires AUTH 8000 */ 8001 no_data_chunks = 1; 8002 chk->sent = SCTP_DATAGRAM_SENT; 8003 if (chk->whoTo == NULL) { 8004 chk->whoTo = net; 8005 atomic_add_int(&net->ref_count, 1); 8006 } 8007 chk->snd_count++; 8008 if (mtu == 0) { 8009 /* 8010 * Ok we are out of room but we can 8011 * output without effecting the 8012 * flight size since this little guy 8013 * is a control only packet. 8014 */ 8015 sctp_timer_start(SCTP_TIMER_TYPE_ASCONF, inp, stcb, net); 8016 /* 8017 * do NOT clear the asconf flag as 8018 * it is used to do appropriate 8019 * source address selection. 8020 */ 8021 if ((error = sctp_lowlevel_chunk_output(inp, stcb, net, 8022 (struct sockaddr *)&net->ro._l_addr, 8023 outchain, auth_offset, auth, 8024 stcb->asoc.authinfo.active_keyid, 8025 no_fragmentflg, 0, asconf, 8026 inp->sctp_lport, stcb->rport, 8027 htonl(stcb->asoc.peer_vtag), 8028 net->port, NULL, 8029 0, 0, 8030 so_locked))) { 8031 if (error == ENOBUFS) { 8032 asoc->ifp_had_enobuf = 1; 8033 SCTP_STAT_INCR(sctps_lowlevelerr); 8034 } 8035 if (from_where == 0) { 8036 SCTP_STAT_INCR(sctps_lowlevelerrusr); 8037 } 8038 if (*now_filled == 0) { 8039 (void)SCTP_GETTIME_TIMEVAL(&net->last_sent_time); 8040 *now_filled = 1; 8041 *now = net->last_sent_time; 8042 } else { 8043 net->last_sent_time = *now; 8044 } 8045 hbflag = 0; 8046 /* error, could not output */ 8047 if (error == EHOSTUNREACH) { 8048 /* 8049 * Destination went 8050 * unreachable 8051 * during this send 8052 */ 8053 sctp_move_chunks_from_net(stcb, net); 8054 } 8055 *reason_code = 7; 8056 continue; 8057 } else 8058 asoc->ifp_had_enobuf = 0; 8059 if (*now_filled == 0) { 8060 (void)SCTP_GETTIME_TIMEVAL(&net->last_sent_time); 8061 *now_filled = 1; 8062 *now = net->last_sent_time; 8063 } else { 8064 net->last_sent_time = *now; 8065 } 8066 hbflag = 0; 8067 /* 8068 * increase the number we sent, if a 8069 * cookie is sent we don't tell them 8070 * any was sent out. 8071 */ 8072 outchain = endoutchain = NULL; 8073 auth = NULL; 8074 auth_offset = 0; 8075 if (!no_out_cnt) 8076 *num_out += ctl_cnt; 8077 /* recalc a clean slate and setup */ 8078 switch (net->ro._l_addr.sa.sa_family) { 8079 #ifdef INET 8080 case AF_INET: 8081 mtu = net->mtu - SCTP_MIN_V4_OVERHEAD; 8082 break; 8083 #endif 8084 #ifdef INET6 8085 case AF_INET6: 8086 mtu = net->mtu - SCTP_MIN_OVERHEAD; 8087 break; 8088 #endif 8089 default: 8090 /* TSNH */ 8091 mtu = net->mtu; 8092 break; 8093 } 8094 to_out = 0; 8095 no_fragmentflg = 1; 8096 } 8097 } 8098 } 8099 /************************/ 8100 /* Control transmission */ 8101 /************************/ 8102 /* Now first lets go through the control queue */ 8103 TAILQ_FOREACH_SAFE(chk, &asoc->control_send_queue, sctp_next, nchk) { 8104 if ((sack_goes_to) && 8105 (chk->rec.chunk_id.id == SCTP_ECN_ECHO) && 8106 (chk->whoTo != sack_goes_to)) { 8107 /* 8108 * if we have a sack in queue, and we are 8109 * looking at an ecn echo that is NOT queued 8110 * to where the sack is going.. 8111 */ 8112 if (chk->whoTo == net) { 8113 /* 8114 * Don't transmit it to where its 8115 * going (current net) 8116 */ 8117 continue; 8118 } else if (sack_goes_to == net) { 8119 /* 8120 * But do transmit it to this 8121 * address 8122 */ 8123 goto skip_net_check; 8124 } 8125 } 8126 if (chk->whoTo == NULL) { 8127 if (asoc->alternate == NULL) { 8128 if (asoc->primary_destination != net) { 8129 continue; 8130 } 8131 } else { 8132 if (asoc->alternate != net) { 8133 continue; 8134 } 8135 } 8136 } else { 8137 if (chk->whoTo != net) { 8138 continue; 8139 } 8140 } 8141 skip_net_check: 8142 if (chk->data == NULL) { 8143 continue; 8144 } 8145 if (chk->sent != SCTP_DATAGRAM_UNSENT) { 8146 /* 8147 * It must be unsent. Cookies and ASCONF's 8148 * hang around but there timers will force 8149 * when marked for resend. 8150 */ 8151 continue; 8152 } 8153 /* 8154 * if no AUTH is yet included and this chunk 8155 * requires it, make sure to account for it. We 8156 * don't apply the size until the AUTH chunk is 8157 * actually added below in case there is no room for 8158 * this chunk. NOTE: we overload the use of "omtu" 8159 * here 8160 */ 8161 if ((auth == NULL) && 8162 sctp_auth_is_required_chunk(chk->rec.chunk_id.id, 8163 stcb->asoc.peer_auth_chunks)) { 8164 omtu = sctp_get_auth_chunk_len(stcb->asoc.peer_hmac_id); 8165 } else 8166 omtu = 0; 8167 /* Here we do NOT factor the r_mtu */ 8168 if ((chk->send_size <= (int)(mtu - omtu)) || 8169 (chk->flags & CHUNK_FLAGS_FRAGMENT_OK)) { 8170 /* 8171 * We probably should glom the mbuf chain 8172 * from the chk->data for control but the 8173 * problem is it becomes yet one more level 8174 * of tracking to do if for some reason 8175 * output fails. Then I have got to 8176 * reconstruct the merged control chain.. el 8177 * yucko.. for now we take the easy way and 8178 * do the copy 8179 */ 8180 /* 8181 * Add an AUTH chunk, if chunk requires it 8182 * save the offset into the chain for AUTH 8183 */ 8184 if ((auth == NULL) && 8185 (sctp_auth_is_required_chunk(chk->rec.chunk_id.id, 8186 stcb->asoc.peer_auth_chunks))) { 8187 outchain = sctp_add_auth_chunk(outchain, 8188 &endoutchain, 8189 &auth, 8190 &auth_offset, 8191 stcb, 8192 chk->rec.chunk_id.id); 8193 SCTP_STAT_INCR_COUNTER64(sctps_outcontrolchunks); 8194 } 8195 outchain = sctp_copy_mbufchain(chk->data, outchain, &endoutchain, 8196 (int)chk->rec.chunk_id.can_take_data, 8197 chk->send_size, chk->copy_by_ref); 8198 if (outchain == NULL) { 8199 *reason_code = 8; 8200 SCTP_LTRACE_ERR_RET(inp, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, ENOMEM); 8201 return (ENOMEM); 8202 } 8203 SCTP_STAT_INCR_COUNTER64(sctps_outcontrolchunks); 8204 /* update our MTU size */ 8205 if (mtu > (chk->send_size + omtu)) 8206 mtu -= (chk->send_size + omtu); 8207 else 8208 mtu = 0; 8209 to_out += (chk->send_size + omtu); 8210 /* Do clear IP_DF ? */ 8211 if (chk->flags & CHUNK_FLAGS_FRAGMENT_OK) { 8212 no_fragmentflg = 0; 8213 } 8214 if (chk->rec.chunk_id.can_take_data) 8215 chk->data = NULL; 8216 /* Mark things to be removed, if needed */ 8217 if ((chk->rec.chunk_id.id == SCTP_SELECTIVE_ACK) || 8218 (chk->rec.chunk_id.id == SCTP_NR_SELECTIVE_ACK) || /* EY */ 8219 (chk->rec.chunk_id.id == SCTP_HEARTBEAT_REQUEST) || 8220 (chk->rec.chunk_id.id == SCTP_HEARTBEAT_ACK) || 8221 (chk->rec.chunk_id.id == SCTP_SHUTDOWN) || 8222 (chk->rec.chunk_id.id == SCTP_SHUTDOWN_ACK) || 8223 (chk->rec.chunk_id.id == SCTP_OPERATION_ERROR) || 8224 (chk->rec.chunk_id.id == SCTP_COOKIE_ACK) || 8225 (chk->rec.chunk_id.id == SCTP_ECN_CWR) || 8226 (chk->rec.chunk_id.id == SCTP_PACKET_DROPPED) || 8227 (chk->rec.chunk_id.id == SCTP_ASCONF_ACK)) { 8228 if (chk->rec.chunk_id.id == SCTP_HEARTBEAT_REQUEST) { 8229 hbflag = 1; 8230 } 8231 /* remove these chunks at the end */ 8232 if ((chk->rec.chunk_id.id == SCTP_SELECTIVE_ACK) || 8233 (chk->rec.chunk_id.id == SCTP_NR_SELECTIVE_ACK)) { 8234 /* turn off the timer */ 8235 if (SCTP_OS_TIMER_PENDING(&stcb->asoc.dack_timer.timer)) { 8236 sctp_timer_stop(SCTP_TIMER_TYPE_RECV, 8237 inp, stcb, net, SCTP_FROM_SCTP_OUTPUT + SCTP_LOC_1); 8238 } 8239 } 8240 ctl_cnt++; 8241 } else { 8242 /* 8243 * Other chunks, since they have 8244 * timers running (i.e. COOKIE) we 8245 * just "trust" that it gets sent or 8246 * retransmitted. 8247 */ 8248 ctl_cnt++; 8249 if (chk->rec.chunk_id.id == SCTP_COOKIE_ECHO) { 8250 cookie = 1; 8251 no_out_cnt = 1; 8252 } else if (chk->rec.chunk_id.id == SCTP_ECN_ECHO) { 8253 /* 8254 * Increment ecne send count 8255 * here this means we may be 8256 * over-zealous in our 8257 * counting if the send 8258 * fails, but its the best 8259 * place to do it (we used 8260 * to do it in the queue of 8261 * the chunk, but that did 8262 * not tell how many times 8263 * it was sent. 8264 */ 8265 SCTP_STAT_INCR(sctps_sendecne); 8266 } 8267 chk->sent = SCTP_DATAGRAM_SENT; 8268 if (chk->whoTo == NULL) { 8269 chk->whoTo = net; 8270 atomic_add_int(&net->ref_count, 1); 8271 } 8272 chk->snd_count++; 8273 } 8274 if (mtu == 0) { 8275 /* 8276 * Ok we are out of room but we can 8277 * output without effecting the 8278 * flight size since this little guy 8279 * is a control only packet. 8280 */ 8281 if (asconf) { 8282 sctp_timer_start(SCTP_TIMER_TYPE_ASCONF, inp, stcb, net); 8283 /* 8284 * do NOT clear the asconf 8285 * flag as it is used to do 8286 * appropriate source 8287 * address selection. 8288 */ 8289 } 8290 if (cookie) { 8291 sctp_timer_start(SCTP_TIMER_TYPE_COOKIE, inp, stcb, net); 8292 cookie = 0; 8293 } 8294 if ((error = sctp_lowlevel_chunk_output(inp, stcb, net, 8295 (struct sockaddr *)&net->ro._l_addr, 8296 outchain, 8297 auth_offset, auth, 8298 stcb->asoc.authinfo.active_keyid, 8299 no_fragmentflg, 0, asconf, 8300 inp->sctp_lport, stcb->rport, 8301 htonl(stcb->asoc.peer_vtag), 8302 net->port, NULL, 8303 0, 0, 8304 so_locked))) { 8305 if (error == ENOBUFS) { 8306 asoc->ifp_had_enobuf = 1; 8307 SCTP_STAT_INCR(sctps_lowlevelerr); 8308 } 8309 if (from_where == 0) { 8310 SCTP_STAT_INCR(sctps_lowlevelerrusr); 8311 } 8312 /* error, could not output */ 8313 if (hbflag) { 8314 if (*now_filled == 0) { 8315 (void)SCTP_GETTIME_TIMEVAL(&net->last_sent_time); 8316 *now_filled = 1; 8317 *now = net->last_sent_time; 8318 } else { 8319 net->last_sent_time = *now; 8320 } 8321 hbflag = 0; 8322 } 8323 if (error == EHOSTUNREACH) { 8324 /* 8325 * Destination went 8326 * unreachable 8327 * during this send 8328 */ 8329 sctp_move_chunks_from_net(stcb, net); 8330 } 8331 *reason_code = 7; 8332 continue; 8333 } else 8334 asoc->ifp_had_enobuf = 0; 8335 /* Only HB or ASCONF advances time */ 8336 if (hbflag) { 8337 if (*now_filled == 0) { 8338 (void)SCTP_GETTIME_TIMEVAL(&net->last_sent_time); 8339 *now_filled = 1; 8340 *now = net->last_sent_time; 8341 } else { 8342 net->last_sent_time = *now; 8343 } 8344 hbflag = 0; 8345 } 8346 /* 8347 * increase the number we sent, if a 8348 * cookie is sent we don't tell them 8349 * any was sent out. 8350 */ 8351 outchain = endoutchain = NULL; 8352 auth = NULL; 8353 auth_offset = 0; 8354 if (!no_out_cnt) 8355 *num_out += ctl_cnt; 8356 /* recalc a clean slate and setup */ 8357 switch (net->ro._l_addr.sa.sa_family) { 8358 #ifdef INET 8359 case AF_INET: 8360 mtu = net->mtu - SCTP_MIN_V4_OVERHEAD; 8361 break; 8362 #endif 8363 #ifdef INET6 8364 case AF_INET6: 8365 mtu = net->mtu - SCTP_MIN_OVERHEAD; 8366 break; 8367 #endif 8368 default: 8369 /* TSNH */ 8370 mtu = net->mtu; 8371 break; 8372 } 8373 to_out = 0; 8374 no_fragmentflg = 1; 8375 } 8376 } 8377 } 8378 /* JRI: if dest is in PF state, do not send data to it */ 8379 if ((asoc->sctp_cmt_on_off > 0) && 8380 (net != stcb->asoc.alternate) && 8381 (net->dest_state & SCTP_ADDR_PF)) { 8382 goto no_data_fill; 8383 } 8384 if (net->flight_size >= net->cwnd) { 8385 goto no_data_fill; 8386 } 8387 if ((asoc->sctp_cmt_on_off > 0) && 8388 (SCTP_BASE_SYSCTL(sctp_buffer_splitting) & SCTP_RECV_BUFFER_SPLITTING) && 8389 (net->flight_size > max_rwnd_per_dest)) { 8390 goto no_data_fill; 8391 } 8392 /* 8393 * We need a specific accounting for the usage of the send 8394 * buffer. We also need to check the number of messages per 8395 * net. For now, this is better than nothing and it disabled 8396 * by default... 8397 */ 8398 if ((asoc->sctp_cmt_on_off > 0) && 8399 (SCTP_BASE_SYSCTL(sctp_buffer_splitting) & SCTP_SEND_BUFFER_SPLITTING) && 8400 (max_send_per_dest > 0) && 8401 (net->flight_size > max_send_per_dest)) { 8402 goto no_data_fill; 8403 } 8404 /*********************/ 8405 /* Data transmission */ 8406 /*********************/ 8407 /* 8408 * if AUTH for DATA is required and no AUTH has been added 8409 * yet, account for this in the mtu now... if no data can be 8410 * bundled, this adjustment won't matter anyways since the 8411 * packet will be going out... 8412 */ 8413 data_auth_reqd = sctp_auth_is_required_chunk(SCTP_DATA, 8414 stcb->asoc.peer_auth_chunks); 8415 if (data_auth_reqd && (auth == NULL)) { 8416 mtu -= sctp_get_auth_chunk_len(stcb->asoc.peer_hmac_id); 8417 } 8418 /* now lets add any data within the MTU constraints */ 8419 switch (((struct sockaddr *)&net->ro._l_addr)->sa_family) { 8420 #ifdef INET 8421 case AF_INET: 8422 if (net->mtu > (sizeof(struct ip) + sizeof(struct sctphdr))) 8423 omtu = net->mtu - (sizeof(struct ip) + sizeof(struct sctphdr)); 8424 else 8425 omtu = 0; 8426 break; 8427 #endif 8428 #ifdef INET6 8429 case AF_INET6: 8430 if (net->mtu > (sizeof(struct ip6_hdr) + sizeof(struct sctphdr))) 8431 omtu = net->mtu - (sizeof(struct ip6_hdr) + sizeof(struct sctphdr)); 8432 else 8433 omtu = 0; 8434 break; 8435 #endif 8436 default: 8437 /* TSNH */ 8438 omtu = 0; 8439 break; 8440 } 8441 if ((((asoc->state & SCTP_STATE_OPEN) == SCTP_STATE_OPEN) && 8442 (skip_data_for_this_net == 0)) || 8443 (cookie)) { 8444 TAILQ_FOREACH_SAFE(chk, &asoc->send_queue, sctp_next, nchk) { 8445 if (no_data_chunks) { 8446 /* let only control go out */ 8447 *reason_code = 1; 8448 break; 8449 } 8450 if (net->flight_size >= net->cwnd) { 8451 /* skip this net, no room for data */ 8452 *reason_code = 2; 8453 break; 8454 } 8455 if ((chk->whoTo != NULL) && 8456 (chk->whoTo != net)) { 8457 /* Don't send the chunk on this net */ 8458 continue; 8459 } 8460 if (asoc->sctp_cmt_on_off == 0) { 8461 if ((asoc->alternate) && 8462 (asoc->alternate != net) && 8463 (chk->whoTo == NULL)) { 8464 continue; 8465 } else if ((net != asoc->primary_destination) && 8466 (asoc->alternate == NULL) && 8467 (chk->whoTo == NULL)) { 8468 continue; 8469 } 8470 } 8471 if ((chk->send_size > omtu) && ((chk->flags & CHUNK_FLAGS_FRAGMENT_OK) == 0)) { 8472 /*- 8473 * strange, we have a chunk that is 8474 * to big for its destination and 8475 * yet no fragment ok flag. 8476 * Something went wrong when the 8477 * PMTU changed...we did not mark 8478 * this chunk for some reason?? I 8479 * will fix it here by letting IP 8480 * fragment it for now and printing 8481 * a warning. This really should not 8482 * happen ... 8483 */ 8484 SCTP_PRINTF("Warning chunk of %d bytes > mtu:%d and yet PMTU disc missed\n", 8485 chk->send_size, mtu); 8486 chk->flags |= CHUNK_FLAGS_FRAGMENT_OK; 8487 } 8488 if (SCTP_BASE_SYSCTL(sctp_enable_sack_immediately) && 8489 ((asoc->state & SCTP_STATE_SHUTDOWN_PENDING) == SCTP_STATE_SHUTDOWN_PENDING)) { 8490 struct sctp_data_chunk *dchkh; 8491 8492 dchkh = mtod(chk->data, struct sctp_data_chunk *); 8493 dchkh->ch.chunk_flags |= SCTP_DATA_SACK_IMMEDIATELY; 8494 } 8495 if (((chk->send_size <= mtu) && (chk->send_size <= r_mtu)) || 8496 ((chk->flags & CHUNK_FLAGS_FRAGMENT_OK) && (chk->send_size <= asoc->peers_rwnd))) { 8497 /* ok we will add this one */ 8498 8499 /* 8500 * Add an AUTH chunk, if chunk 8501 * requires it, save the offset into 8502 * the chain for AUTH 8503 */ 8504 if (data_auth_reqd) { 8505 if (auth == NULL) { 8506 outchain = sctp_add_auth_chunk(outchain, 8507 &endoutchain, 8508 &auth, 8509 &auth_offset, 8510 stcb, 8511 SCTP_DATA); 8512 auth_keyid = chk->auth_keyid; 8513 override_ok = 0; 8514 SCTP_STAT_INCR_COUNTER64(sctps_outcontrolchunks); 8515 } else if (override_ok) { 8516 /* 8517 * use this data's 8518 * keyid 8519 */ 8520 auth_keyid = chk->auth_keyid; 8521 override_ok = 0; 8522 } else if (auth_keyid != chk->auth_keyid) { 8523 /* 8524 * different keyid, 8525 * so done bundling 8526 */ 8527 break; 8528 } 8529 } 8530 outchain = sctp_copy_mbufchain(chk->data, outchain, &endoutchain, 0, 8531 chk->send_size, chk->copy_by_ref); 8532 if (outchain == NULL) { 8533 SCTPDBG(SCTP_DEBUG_OUTPUT3, "No memory?\n"); 8534 if (!SCTP_OS_TIMER_PENDING(&net->rxt_timer.timer)) { 8535 sctp_timer_start(SCTP_TIMER_TYPE_SEND, inp, stcb, net); 8536 } 8537 *reason_code = 3; 8538 SCTP_LTRACE_ERR_RET(inp, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, ENOMEM); 8539 return (ENOMEM); 8540 } 8541 /* upate our MTU size */ 8542 /* Do clear IP_DF ? */ 8543 if (chk->flags & CHUNK_FLAGS_FRAGMENT_OK) { 8544 no_fragmentflg = 0; 8545 } 8546 /* unsigned subtraction of mtu */ 8547 if (mtu > chk->send_size) 8548 mtu -= chk->send_size; 8549 else 8550 mtu = 0; 8551 /* unsigned subtraction of r_mtu */ 8552 if (r_mtu > chk->send_size) 8553 r_mtu -= chk->send_size; 8554 else 8555 r_mtu = 0; 8556 8557 to_out += chk->send_size; 8558 if ((to_out > mx_mtu) && no_fragmentflg) { 8559 #ifdef INVARIANTS 8560 panic("Exceeding mtu of %d out size is %d", mx_mtu, to_out); 8561 #else 8562 SCTP_PRINTF("Exceeding mtu of %d out size is %d\n", 8563 mx_mtu, to_out); 8564 #endif 8565 } 8566 chk->window_probe = 0; 8567 data_list[bundle_at++] = chk; 8568 if (bundle_at >= SCTP_MAX_DATA_BUNDLING) { 8569 break; 8570 } 8571 if (chk->sent == SCTP_DATAGRAM_UNSENT) { 8572 if ((chk->rec.data.rcv_flags & SCTP_DATA_UNORDERED) == 0) { 8573 SCTP_STAT_INCR_COUNTER64(sctps_outorderchunks); 8574 } else { 8575 SCTP_STAT_INCR_COUNTER64(sctps_outunorderchunks); 8576 } 8577 if (((chk->rec.data.rcv_flags & SCTP_DATA_LAST_FRAG) == SCTP_DATA_LAST_FRAG) && 8578 ((chk->rec.data.rcv_flags & SCTP_DATA_FIRST_FRAG) == 0)) 8579 /* 8580 * Count number of 8581 * user msg's that 8582 * were fragmented 8583 * we do this by 8584 * counting when we 8585 * see a LAST 8586 * fragment only. 8587 */ 8588 SCTP_STAT_INCR_COUNTER64(sctps_fragusrmsgs); 8589 } 8590 if ((mtu == 0) || (r_mtu == 0) || (one_chunk)) { 8591 if ((one_chunk) && (stcb->asoc.total_flight == 0)) { 8592 data_list[0]->window_probe = 1; 8593 net->window_probe = 1; 8594 } 8595 break; 8596 } 8597 } else { 8598 /* 8599 * Must be sent in order of the 8600 * TSN's (on a network) 8601 */ 8602 break; 8603 } 8604 } /* for (chunk gather loop for this net) */ 8605 } /* if asoc.state OPEN */ 8606 no_data_fill: 8607 /* Is there something to send for this destination? */ 8608 if (outchain) { 8609 /* We may need to start a control timer or two */ 8610 if (asconf) { 8611 sctp_timer_start(SCTP_TIMER_TYPE_ASCONF, inp, 8612 stcb, net); 8613 /* 8614 * do NOT clear the asconf flag as it is 8615 * used to do appropriate source address 8616 * selection. 8617 */ 8618 } 8619 if (cookie) { 8620 sctp_timer_start(SCTP_TIMER_TYPE_COOKIE, inp, stcb, net); 8621 cookie = 0; 8622 } 8623 /* must start a send timer if data is being sent */ 8624 if (bundle_at && (!SCTP_OS_TIMER_PENDING(&net->rxt_timer.timer))) { 8625 /* 8626 * no timer running on this destination 8627 * restart it. 8628 */ 8629 sctp_timer_start(SCTP_TIMER_TYPE_SEND, inp, stcb, net); 8630 } 8631 /* Now send it, if there is anything to send :> */ 8632 if ((error = sctp_lowlevel_chunk_output(inp, 8633 stcb, 8634 net, 8635 (struct sockaddr *)&net->ro._l_addr, 8636 outchain, 8637 auth_offset, 8638 auth, 8639 auth_keyid, 8640 no_fragmentflg, 8641 bundle_at, 8642 asconf, 8643 inp->sctp_lport, stcb->rport, 8644 htonl(stcb->asoc.peer_vtag), 8645 net->port, NULL, 8646 0, 0, 8647 so_locked))) { 8648 /* error, we could not output */ 8649 if (error == ENOBUFS) { 8650 SCTP_STAT_INCR(sctps_lowlevelerr); 8651 asoc->ifp_had_enobuf = 1; 8652 } 8653 if (from_where == 0) { 8654 SCTP_STAT_INCR(sctps_lowlevelerrusr); 8655 } 8656 SCTPDBG(SCTP_DEBUG_OUTPUT3, "Gak send error %d\n", error); 8657 if (hbflag) { 8658 if (*now_filled == 0) { 8659 (void)SCTP_GETTIME_TIMEVAL(&net->last_sent_time); 8660 *now_filled = 1; 8661 *now = net->last_sent_time; 8662 } else { 8663 net->last_sent_time = *now; 8664 } 8665 hbflag = 0; 8666 } 8667 if (error == EHOSTUNREACH) { 8668 /* 8669 * Destination went unreachable 8670 * during this send 8671 */ 8672 sctp_move_chunks_from_net(stcb, net); 8673 } 8674 *reason_code = 6; 8675 /*- 8676 * I add this line to be paranoid. As far as 8677 * I can tell the continue, takes us back to 8678 * the top of the for, but just to make sure 8679 * I will reset these again here. 8680 */ 8681 ctl_cnt = bundle_at = 0; 8682 continue; /* This takes us back to the 8683 * for() for the nets. */ 8684 } else { 8685 asoc->ifp_had_enobuf = 0; 8686 } 8687 endoutchain = NULL; 8688 auth = NULL; 8689 auth_offset = 0; 8690 if (bundle_at || hbflag) { 8691 /* For data/asconf and hb set time */ 8692 if (*now_filled == 0) { 8693 (void)SCTP_GETTIME_TIMEVAL(&net->last_sent_time); 8694 *now_filled = 1; 8695 *now = net->last_sent_time; 8696 } else { 8697 net->last_sent_time = *now; 8698 } 8699 } 8700 if (!no_out_cnt) { 8701 *num_out += (ctl_cnt + bundle_at); 8702 } 8703 if (bundle_at) { 8704 /* setup for a RTO measurement */ 8705 tsns_sent = data_list[0]->rec.data.TSN_seq; 8706 /* fill time if not already filled */ 8707 if (*now_filled == 0) { 8708 (void)SCTP_GETTIME_TIMEVAL(&asoc->time_last_sent); 8709 *now_filled = 1; 8710 *now = asoc->time_last_sent; 8711 } else { 8712 asoc->time_last_sent = *now; 8713 } 8714 if (net->rto_needed) { 8715 data_list[0]->do_rtt = 1; 8716 net->rto_needed = 0; 8717 } 8718 SCTP_STAT_INCR_BY(sctps_senddata, bundle_at); 8719 sctp_clean_up_datalist(stcb, asoc, data_list, bundle_at, net); 8720 } 8721 if (one_chunk) { 8722 break; 8723 } 8724 } 8725 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_LOGGING_ENABLE) { 8726 sctp_log_cwnd(stcb, net, tsns_sent, SCTP_CWND_LOG_FROM_SEND); 8727 } 8728 } 8729 if (old_start_at == NULL) { 8730 old_start_at = start_at; 8731 start_at = TAILQ_FIRST(&asoc->nets); 8732 if (old_start_at) 8733 goto again_one_more_time; 8734 } 8735 /* 8736 * At the end there should be no NON timed chunks hanging on this 8737 * queue. 8738 */ 8739 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_LOGGING_ENABLE) { 8740 sctp_log_cwnd(stcb, net, *num_out, SCTP_CWND_LOG_FROM_SEND); 8741 } 8742 if ((*num_out == 0) && (*reason_code == 0)) { 8743 *reason_code = 4; 8744 } else { 8745 *reason_code = 5; 8746 } 8747 sctp_clean_up_ctl(stcb, asoc, so_locked); 8748 return (0); 8749 } 8750 8751 void 8752 sctp_queue_op_err(struct sctp_tcb *stcb, struct mbuf *op_err) 8753 { 8754 /*- 8755 * Prepend a OPERATIONAL_ERROR chunk header and put on the end of 8756 * the control chunk queue. 8757 */ 8758 struct sctp_chunkhdr *hdr; 8759 struct sctp_tmit_chunk *chk; 8760 struct mbuf *mat; 8761 8762 SCTP_TCB_LOCK_ASSERT(stcb); 8763 sctp_alloc_a_chunk(stcb, chk); 8764 if (chk == NULL) { 8765 /* no memory */ 8766 sctp_m_freem(op_err); 8767 return; 8768 } 8769 chk->copy_by_ref = 0; 8770 SCTP_BUF_PREPEND(op_err, sizeof(struct sctp_chunkhdr), M_DONTWAIT); 8771 if (op_err == NULL) { 8772 sctp_free_a_chunk(stcb, chk, SCTP_SO_NOT_LOCKED); 8773 return; 8774 } 8775 chk->send_size = 0; 8776 mat = op_err; 8777 while (mat != NULL) { 8778 chk->send_size += SCTP_BUF_LEN(mat); 8779 mat = SCTP_BUF_NEXT(mat); 8780 } 8781 chk->rec.chunk_id.id = SCTP_OPERATION_ERROR; 8782 chk->rec.chunk_id.can_take_data = 1; 8783 chk->sent = SCTP_DATAGRAM_UNSENT; 8784 chk->snd_count = 0; 8785 chk->flags = 0; 8786 chk->asoc = &stcb->asoc; 8787 chk->data = op_err; 8788 chk->whoTo = NULL; 8789 hdr = mtod(op_err, struct sctp_chunkhdr *); 8790 hdr->chunk_type = SCTP_OPERATION_ERROR; 8791 hdr->chunk_flags = 0; 8792 hdr->chunk_length = htons(chk->send_size); 8793 TAILQ_INSERT_TAIL(&chk->asoc->control_send_queue, 8794 chk, 8795 sctp_next); 8796 chk->asoc->ctrl_queue_cnt++; 8797 } 8798 8799 int 8800 sctp_send_cookie_echo(struct mbuf *m, 8801 int offset, 8802 struct sctp_tcb *stcb, 8803 struct sctp_nets *net) 8804 { 8805 /*- 8806 * pull out the cookie and put it at the front of the control chunk 8807 * queue. 8808 */ 8809 int at; 8810 struct mbuf *cookie; 8811 struct sctp_paramhdr parm, *phdr; 8812 struct sctp_chunkhdr *hdr; 8813 struct sctp_tmit_chunk *chk; 8814 uint16_t ptype, plen; 8815 8816 /* First find the cookie in the param area */ 8817 cookie = NULL; 8818 at = offset + sizeof(struct sctp_init_chunk); 8819 8820 SCTP_TCB_LOCK_ASSERT(stcb); 8821 do { 8822 phdr = sctp_get_next_param(m, at, &parm, sizeof(parm)); 8823 if (phdr == NULL) { 8824 return (-3); 8825 } 8826 ptype = ntohs(phdr->param_type); 8827 plen = ntohs(phdr->param_length); 8828 if (ptype == SCTP_STATE_COOKIE) { 8829 int pad; 8830 8831 /* found the cookie */ 8832 if ((pad = (plen % 4))) { 8833 plen += 4 - pad; 8834 } 8835 cookie = SCTP_M_COPYM(m, at, plen, M_DONTWAIT); 8836 if (cookie == NULL) { 8837 /* No memory */ 8838 return (-2); 8839 } 8840 #ifdef SCTP_MBUF_LOGGING 8841 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_MBUF_LOGGING_ENABLE) { 8842 struct mbuf *mat; 8843 8844 for (mat = cookie; mat; mat = SCTP_BUF_NEXT(mat)) { 8845 if (SCTP_BUF_IS_EXTENDED(mat)) { 8846 sctp_log_mb(mat, SCTP_MBUF_ICOPY); 8847 } 8848 } 8849 } 8850 #endif 8851 break; 8852 } 8853 at += SCTP_SIZE32(plen); 8854 } while (phdr); 8855 if (cookie == NULL) { 8856 /* Did not find the cookie */ 8857 return (-3); 8858 } 8859 /* ok, we got the cookie lets change it into a cookie echo chunk */ 8860 8861 /* first the change from param to cookie */ 8862 hdr = mtod(cookie, struct sctp_chunkhdr *); 8863 hdr->chunk_type = SCTP_COOKIE_ECHO; 8864 hdr->chunk_flags = 0; 8865 /* get the chunk stuff now and place it in the FRONT of the queue */ 8866 sctp_alloc_a_chunk(stcb, chk); 8867 if (chk == NULL) { 8868 /* no memory */ 8869 sctp_m_freem(cookie); 8870 return (-5); 8871 } 8872 chk->copy_by_ref = 0; 8873 chk->send_size = plen; 8874 chk->rec.chunk_id.id = SCTP_COOKIE_ECHO; 8875 chk->rec.chunk_id.can_take_data = 0; 8876 chk->sent = SCTP_DATAGRAM_UNSENT; 8877 chk->snd_count = 0; 8878 chk->flags = CHUNK_FLAGS_FRAGMENT_OK; 8879 chk->asoc = &stcb->asoc; 8880 chk->data = cookie; 8881 chk->whoTo = net; 8882 atomic_add_int(&chk->whoTo->ref_count, 1); 8883 TAILQ_INSERT_HEAD(&chk->asoc->control_send_queue, chk, sctp_next); 8884 chk->asoc->ctrl_queue_cnt++; 8885 return (0); 8886 } 8887 8888 void 8889 sctp_send_heartbeat_ack(struct sctp_tcb *stcb, 8890 struct mbuf *m, 8891 int offset, 8892 int chk_length, 8893 struct sctp_nets *net) 8894 { 8895 /* 8896 * take a HB request and make it into a HB ack and send it. 8897 */ 8898 struct mbuf *outchain; 8899 struct sctp_chunkhdr *chdr; 8900 struct sctp_tmit_chunk *chk; 8901 8902 8903 if (net == NULL) 8904 /* must have a net pointer */ 8905 return; 8906 8907 outchain = SCTP_M_COPYM(m, offset, chk_length, M_DONTWAIT); 8908 if (outchain == NULL) { 8909 /* gak out of memory */ 8910 return; 8911 } 8912 #ifdef SCTP_MBUF_LOGGING 8913 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_MBUF_LOGGING_ENABLE) { 8914 struct mbuf *mat; 8915 8916 for (mat = outchain; mat; mat = SCTP_BUF_NEXT(mat)) { 8917 if (SCTP_BUF_IS_EXTENDED(mat)) { 8918 sctp_log_mb(mat, SCTP_MBUF_ICOPY); 8919 } 8920 } 8921 } 8922 #endif 8923 chdr = mtod(outchain, struct sctp_chunkhdr *); 8924 chdr->chunk_type = SCTP_HEARTBEAT_ACK; 8925 chdr->chunk_flags = 0; 8926 if (chk_length % 4) { 8927 /* need pad */ 8928 uint32_t cpthis = 0; 8929 int padlen; 8930 8931 padlen = 4 - (chk_length % 4); 8932 m_copyback(outchain, chk_length, padlen, (caddr_t)&cpthis); 8933 } 8934 sctp_alloc_a_chunk(stcb, chk); 8935 if (chk == NULL) { 8936 /* no memory */ 8937 sctp_m_freem(outchain); 8938 return; 8939 } 8940 chk->copy_by_ref = 0; 8941 chk->send_size = chk_length; 8942 chk->rec.chunk_id.id = SCTP_HEARTBEAT_ACK; 8943 chk->rec.chunk_id.can_take_data = 1; 8944 chk->sent = SCTP_DATAGRAM_UNSENT; 8945 chk->snd_count = 0; 8946 chk->flags = 0; 8947 chk->asoc = &stcb->asoc; 8948 chk->data = outchain; 8949 chk->whoTo = net; 8950 atomic_add_int(&chk->whoTo->ref_count, 1); 8951 TAILQ_INSERT_TAIL(&chk->asoc->control_send_queue, chk, sctp_next); 8952 chk->asoc->ctrl_queue_cnt++; 8953 } 8954 8955 void 8956 sctp_send_cookie_ack(struct sctp_tcb *stcb) 8957 { 8958 /* formulate and queue a cookie-ack back to sender */ 8959 struct mbuf *cookie_ack; 8960 struct sctp_chunkhdr *hdr; 8961 struct sctp_tmit_chunk *chk; 8962 8963 cookie_ack = NULL; 8964 SCTP_TCB_LOCK_ASSERT(stcb); 8965 8966 cookie_ack = sctp_get_mbuf_for_msg(sizeof(struct sctp_chunkhdr), 0, M_DONTWAIT, 1, MT_HEADER); 8967 if (cookie_ack == NULL) { 8968 /* no mbuf's */ 8969 return; 8970 } 8971 SCTP_BUF_RESV_UF(cookie_ack, SCTP_MIN_OVERHEAD); 8972 sctp_alloc_a_chunk(stcb, chk); 8973 if (chk == NULL) { 8974 /* no memory */ 8975 sctp_m_freem(cookie_ack); 8976 return; 8977 } 8978 chk->copy_by_ref = 0; 8979 chk->send_size = sizeof(struct sctp_chunkhdr); 8980 chk->rec.chunk_id.id = SCTP_COOKIE_ACK; 8981 chk->rec.chunk_id.can_take_data = 1; 8982 chk->sent = SCTP_DATAGRAM_UNSENT; 8983 chk->snd_count = 0; 8984 chk->flags = 0; 8985 chk->asoc = &stcb->asoc; 8986 chk->data = cookie_ack; 8987 if (chk->asoc->last_control_chunk_from != NULL) { 8988 chk->whoTo = chk->asoc->last_control_chunk_from; 8989 atomic_add_int(&chk->whoTo->ref_count, 1); 8990 } else { 8991 chk->whoTo = NULL; 8992 } 8993 hdr = mtod(cookie_ack, struct sctp_chunkhdr *); 8994 hdr->chunk_type = SCTP_COOKIE_ACK; 8995 hdr->chunk_flags = 0; 8996 hdr->chunk_length = htons(chk->send_size); 8997 SCTP_BUF_LEN(cookie_ack) = chk->send_size; 8998 TAILQ_INSERT_TAIL(&chk->asoc->control_send_queue, chk, sctp_next); 8999 chk->asoc->ctrl_queue_cnt++; 9000 return; 9001 } 9002 9003 9004 void 9005 sctp_send_shutdown_ack(struct sctp_tcb *stcb, struct sctp_nets *net) 9006 { 9007 /* formulate and queue a SHUTDOWN-ACK back to the sender */ 9008 struct mbuf *m_shutdown_ack; 9009 struct sctp_shutdown_ack_chunk *ack_cp; 9010 struct sctp_tmit_chunk *chk; 9011 9012 m_shutdown_ack = sctp_get_mbuf_for_msg(sizeof(struct sctp_shutdown_ack_chunk), 0, M_DONTWAIT, 1, MT_HEADER); 9013 if (m_shutdown_ack == NULL) { 9014 /* no mbuf's */ 9015 return; 9016 } 9017 SCTP_BUF_RESV_UF(m_shutdown_ack, SCTP_MIN_OVERHEAD); 9018 sctp_alloc_a_chunk(stcb, chk); 9019 if (chk == NULL) { 9020 /* no memory */ 9021 sctp_m_freem(m_shutdown_ack); 9022 return; 9023 } 9024 chk->copy_by_ref = 0; 9025 chk->send_size = sizeof(struct sctp_chunkhdr); 9026 chk->rec.chunk_id.id = SCTP_SHUTDOWN_ACK; 9027 chk->rec.chunk_id.can_take_data = 1; 9028 chk->sent = SCTP_DATAGRAM_UNSENT; 9029 chk->snd_count = 0; 9030 chk->flags = 0; 9031 chk->asoc = &stcb->asoc; 9032 chk->data = m_shutdown_ack; 9033 chk->whoTo = net; 9034 if (chk->whoTo) { 9035 atomic_add_int(&chk->whoTo->ref_count, 1); 9036 } 9037 ack_cp = mtod(m_shutdown_ack, struct sctp_shutdown_ack_chunk *); 9038 ack_cp->ch.chunk_type = SCTP_SHUTDOWN_ACK; 9039 ack_cp->ch.chunk_flags = 0; 9040 ack_cp->ch.chunk_length = htons(chk->send_size); 9041 SCTP_BUF_LEN(m_shutdown_ack) = chk->send_size; 9042 TAILQ_INSERT_TAIL(&chk->asoc->control_send_queue, chk, sctp_next); 9043 chk->asoc->ctrl_queue_cnt++; 9044 return; 9045 } 9046 9047 void 9048 sctp_send_shutdown(struct sctp_tcb *stcb, struct sctp_nets *net) 9049 { 9050 /* formulate and queue a SHUTDOWN to the sender */ 9051 struct mbuf *m_shutdown; 9052 struct sctp_shutdown_chunk *shutdown_cp; 9053 struct sctp_tmit_chunk *chk; 9054 9055 m_shutdown = sctp_get_mbuf_for_msg(sizeof(struct sctp_shutdown_chunk), 0, M_DONTWAIT, 1, MT_HEADER); 9056 if (m_shutdown == NULL) { 9057 /* no mbuf's */ 9058 return; 9059 } 9060 SCTP_BUF_RESV_UF(m_shutdown, SCTP_MIN_OVERHEAD); 9061 sctp_alloc_a_chunk(stcb, chk); 9062 if (chk == NULL) { 9063 /* no memory */ 9064 sctp_m_freem(m_shutdown); 9065 return; 9066 } 9067 chk->copy_by_ref = 0; 9068 chk->send_size = sizeof(struct sctp_shutdown_chunk); 9069 chk->rec.chunk_id.id = SCTP_SHUTDOWN; 9070 chk->rec.chunk_id.can_take_data = 1; 9071 chk->sent = SCTP_DATAGRAM_UNSENT; 9072 chk->snd_count = 0; 9073 chk->flags = 0; 9074 chk->asoc = &stcb->asoc; 9075 chk->data = m_shutdown; 9076 chk->whoTo = net; 9077 if (chk->whoTo) { 9078 atomic_add_int(&chk->whoTo->ref_count, 1); 9079 } 9080 shutdown_cp = mtod(m_shutdown, struct sctp_shutdown_chunk *); 9081 shutdown_cp->ch.chunk_type = SCTP_SHUTDOWN; 9082 shutdown_cp->ch.chunk_flags = 0; 9083 shutdown_cp->ch.chunk_length = htons(chk->send_size); 9084 shutdown_cp->cumulative_tsn_ack = htonl(stcb->asoc.cumulative_tsn); 9085 SCTP_BUF_LEN(m_shutdown) = chk->send_size; 9086 TAILQ_INSERT_TAIL(&chk->asoc->control_send_queue, chk, sctp_next); 9087 chk->asoc->ctrl_queue_cnt++; 9088 return; 9089 } 9090 9091 void 9092 sctp_send_asconf(struct sctp_tcb *stcb, struct sctp_nets *net, int addr_locked) 9093 { 9094 /* 9095 * formulate and queue an ASCONF to the peer. ASCONF parameters 9096 * should be queued on the assoc queue. 9097 */ 9098 struct sctp_tmit_chunk *chk; 9099 struct mbuf *m_asconf; 9100 int len; 9101 9102 SCTP_TCB_LOCK_ASSERT(stcb); 9103 9104 if ((!TAILQ_EMPTY(&stcb->asoc.asconf_send_queue)) && 9105 (!sctp_is_feature_on(stcb->sctp_ep, SCTP_PCB_FLAGS_MULTIPLE_ASCONFS))) { 9106 /* can't send a new one if there is one in flight already */ 9107 return; 9108 } 9109 /* compose an ASCONF chunk, maximum length is PMTU */ 9110 m_asconf = sctp_compose_asconf(stcb, &len, addr_locked); 9111 if (m_asconf == NULL) { 9112 return; 9113 } 9114 sctp_alloc_a_chunk(stcb, chk); 9115 if (chk == NULL) { 9116 /* no memory */ 9117 sctp_m_freem(m_asconf); 9118 return; 9119 } 9120 chk->copy_by_ref = 0; 9121 chk->data = m_asconf; 9122 chk->send_size = len; 9123 chk->rec.chunk_id.id = SCTP_ASCONF; 9124 chk->rec.chunk_id.can_take_data = 0; 9125 chk->sent = SCTP_DATAGRAM_UNSENT; 9126 chk->snd_count = 0; 9127 chk->flags = CHUNK_FLAGS_FRAGMENT_OK; 9128 chk->asoc = &stcb->asoc; 9129 chk->whoTo = net; 9130 if (chk->whoTo) { 9131 atomic_add_int(&chk->whoTo->ref_count, 1); 9132 } 9133 TAILQ_INSERT_TAIL(&chk->asoc->asconf_send_queue, chk, sctp_next); 9134 chk->asoc->ctrl_queue_cnt++; 9135 return; 9136 } 9137 9138 void 9139 sctp_send_asconf_ack(struct sctp_tcb *stcb) 9140 { 9141 /* 9142 * formulate and queue a asconf-ack back to sender. the asconf-ack 9143 * must be stored in the tcb. 9144 */ 9145 struct sctp_tmit_chunk *chk; 9146 struct sctp_asconf_ack *ack, *latest_ack; 9147 struct mbuf *m_ack; 9148 struct sctp_nets *net = NULL; 9149 9150 SCTP_TCB_LOCK_ASSERT(stcb); 9151 /* Get the latest ASCONF-ACK */ 9152 latest_ack = TAILQ_LAST(&stcb->asoc.asconf_ack_sent, sctp_asconf_ackhead); 9153 if (latest_ack == NULL) { 9154 return; 9155 } 9156 if (latest_ack->last_sent_to != NULL && 9157 latest_ack->last_sent_to == stcb->asoc.last_control_chunk_from) { 9158 /* we're doing a retransmission */ 9159 net = sctp_find_alternate_net(stcb, stcb->asoc.last_control_chunk_from, 0); 9160 if (net == NULL) { 9161 /* no alternate */ 9162 if (stcb->asoc.last_control_chunk_from == NULL) { 9163 if (stcb->asoc.alternate) { 9164 net = stcb->asoc.alternate; 9165 } else { 9166 net = stcb->asoc.primary_destination; 9167 } 9168 } else { 9169 net = stcb->asoc.last_control_chunk_from; 9170 } 9171 } 9172 } else { 9173 /* normal case */ 9174 if (stcb->asoc.last_control_chunk_from == NULL) { 9175 if (stcb->asoc.alternate) { 9176 net = stcb->asoc.alternate; 9177 } else { 9178 net = stcb->asoc.primary_destination; 9179 } 9180 } else { 9181 net = stcb->asoc.last_control_chunk_from; 9182 } 9183 } 9184 latest_ack->last_sent_to = net; 9185 9186 TAILQ_FOREACH(ack, &stcb->asoc.asconf_ack_sent, next) { 9187 if (ack->data == NULL) { 9188 continue; 9189 } 9190 /* copy the asconf_ack */ 9191 m_ack = SCTP_M_COPYM(ack->data, 0, M_COPYALL, M_DONTWAIT); 9192 if (m_ack == NULL) { 9193 /* couldn't copy it */ 9194 return; 9195 } 9196 #ifdef SCTP_MBUF_LOGGING 9197 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_MBUF_LOGGING_ENABLE) { 9198 struct mbuf *mat; 9199 9200 for (mat = m_ack; mat; mat = SCTP_BUF_NEXT(mat)) { 9201 if (SCTP_BUF_IS_EXTENDED(mat)) { 9202 sctp_log_mb(mat, SCTP_MBUF_ICOPY); 9203 } 9204 } 9205 } 9206 #endif 9207 9208 sctp_alloc_a_chunk(stcb, chk); 9209 if (chk == NULL) { 9210 /* no memory */ 9211 if (m_ack) 9212 sctp_m_freem(m_ack); 9213 return; 9214 } 9215 chk->copy_by_ref = 0; 9216 9217 chk->whoTo = net; 9218 if (chk->whoTo) { 9219 atomic_add_int(&chk->whoTo->ref_count, 1); 9220 } 9221 chk->data = m_ack; 9222 chk->send_size = 0; 9223 /* Get size */ 9224 chk->send_size = ack->len; 9225 chk->rec.chunk_id.id = SCTP_ASCONF_ACK; 9226 chk->rec.chunk_id.can_take_data = 1; 9227 chk->sent = SCTP_DATAGRAM_UNSENT; 9228 chk->snd_count = 0; 9229 chk->flags |= CHUNK_FLAGS_FRAGMENT_OK; /* XXX */ 9230 chk->asoc = &stcb->asoc; 9231 9232 TAILQ_INSERT_TAIL(&chk->asoc->control_send_queue, chk, sctp_next); 9233 chk->asoc->ctrl_queue_cnt++; 9234 } 9235 return; 9236 } 9237 9238 9239 static int 9240 sctp_chunk_retransmission(struct sctp_inpcb *inp, 9241 struct sctp_tcb *stcb, 9242 struct sctp_association *asoc, 9243 int *cnt_out, struct timeval *now, int *now_filled, int *fr_done, int so_locked 9244 #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING) 9245 SCTP_UNUSED 9246 #endif 9247 ) 9248 { 9249 /*- 9250 * send out one MTU of retransmission. If fast_retransmit is 9251 * happening we ignore the cwnd. Otherwise we obey the cwnd and 9252 * rwnd. For a Cookie or Asconf in the control chunk queue we 9253 * retransmit them by themselves. 9254 * 9255 * For data chunks we will pick out the lowest TSN's in the sent_queue 9256 * marked for resend and bundle them all together (up to a MTU of 9257 * destination). The address to send to should have been 9258 * selected/changed where the retransmission was marked (i.e. in FR 9259 * or t3-timeout routines). 9260 */ 9261 struct sctp_tmit_chunk *data_list[SCTP_MAX_DATA_BUNDLING]; 9262 struct sctp_tmit_chunk *chk, *fwd; 9263 struct mbuf *m, *endofchain; 9264 struct sctp_nets *net = NULL; 9265 uint32_t tsns_sent = 0; 9266 int no_fragmentflg, bundle_at, cnt_thru; 9267 unsigned int mtu; 9268 int error, i, one_chunk, fwd_tsn, ctl_cnt, tmr_started; 9269 struct sctp_auth_chunk *auth = NULL; 9270 uint32_t auth_offset = 0; 9271 uint16_t auth_keyid; 9272 int override_ok = 1; 9273 int data_auth_reqd = 0; 9274 uint32_t dmtu = 0; 9275 9276 SCTP_TCB_LOCK_ASSERT(stcb); 9277 tmr_started = ctl_cnt = bundle_at = error = 0; 9278 no_fragmentflg = 1; 9279 fwd_tsn = 0; 9280 *cnt_out = 0; 9281 fwd = NULL; 9282 endofchain = m = NULL; 9283 auth_keyid = stcb->asoc.authinfo.active_keyid; 9284 #ifdef SCTP_AUDITING_ENABLED 9285 sctp_audit_log(0xC3, 1); 9286 #endif 9287 if ((TAILQ_EMPTY(&asoc->sent_queue)) && 9288 (TAILQ_EMPTY(&asoc->control_send_queue))) { 9289 SCTPDBG(SCTP_DEBUG_OUTPUT1, "SCTP hits empty queue with cnt set to %d?\n", 9290 asoc->sent_queue_retran_cnt); 9291 asoc->sent_queue_cnt = 0; 9292 asoc->sent_queue_cnt_removeable = 0; 9293 /* send back 0/0 so we enter normal transmission */ 9294 *cnt_out = 0; 9295 return (0); 9296 } 9297 TAILQ_FOREACH(chk, &asoc->control_send_queue, sctp_next) { 9298 if ((chk->rec.chunk_id.id == SCTP_COOKIE_ECHO) || 9299 (chk->rec.chunk_id.id == SCTP_STREAM_RESET) || 9300 (chk->rec.chunk_id.id == SCTP_FORWARD_CUM_TSN)) { 9301 if (chk->sent != SCTP_DATAGRAM_RESEND) { 9302 continue; 9303 } 9304 if (chk->rec.chunk_id.id == SCTP_STREAM_RESET) { 9305 if (chk != asoc->str_reset) { 9306 /* 9307 * not eligible for retran if its 9308 * not ours 9309 */ 9310 continue; 9311 } 9312 } 9313 ctl_cnt++; 9314 if (chk->rec.chunk_id.id == SCTP_FORWARD_CUM_TSN) { 9315 fwd_tsn = 1; 9316 } 9317 /* 9318 * Add an AUTH chunk, if chunk requires it save the 9319 * offset into the chain for AUTH 9320 */ 9321 if ((auth == NULL) && 9322 (sctp_auth_is_required_chunk(chk->rec.chunk_id.id, 9323 stcb->asoc.peer_auth_chunks))) { 9324 m = sctp_add_auth_chunk(m, &endofchain, 9325 &auth, &auth_offset, 9326 stcb, 9327 chk->rec.chunk_id.id); 9328 SCTP_STAT_INCR_COUNTER64(sctps_outcontrolchunks); 9329 } 9330 m = sctp_copy_mbufchain(chk->data, m, &endofchain, 0, chk->send_size, chk->copy_by_ref); 9331 break; 9332 } 9333 } 9334 one_chunk = 0; 9335 cnt_thru = 0; 9336 /* do we have control chunks to retransmit? */ 9337 if (m != NULL) { 9338 /* Start a timer no matter if we suceed or fail */ 9339 if (chk->rec.chunk_id.id == SCTP_COOKIE_ECHO) { 9340 sctp_timer_start(SCTP_TIMER_TYPE_COOKIE, inp, stcb, chk->whoTo); 9341 } else if (chk->rec.chunk_id.id == SCTP_ASCONF) 9342 sctp_timer_start(SCTP_TIMER_TYPE_ASCONF, inp, stcb, chk->whoTo); 9343 chk->snd_count++; /* update our count */ 9344 if ((error = sctp_lowlevel_chunk_output(inp, stcb, chk->whoTo, 9345 (struct sockaddr *)&chk->whoTo->ro._l_addr, m, 9346 auth_offset, auth, stcb->asoc.authinfo.active_keyid, 9347 no_fragmentflg, 0, 0, 9348 inp->sctp_lport, stcb->rport, htonl(stcb->asoc.peer_vtag), 9349 chk->whoTo->port, NULL, 9350 0, 0, 9351 so_locked))) { 9352 SCTP_STAT_INCR(sctps_lowlevelerr); 9353 return (error); 9354 } 9355 endofchain = NULL; 9356 auth = NULL; 9357 auth_offset = 0; 9358 /* 9359 * We don't want to mark the net->sent time here since this 9360 * we use this for HB and retrans cannot measure RTT 9361 */ 9362 /* (void)SCTP_GETTIME_TIMEVAL(&chk->whoTo->last_sent_time); */ 9363 *cnt_out += 1; 9364 chk->sent = SCTP_DATAGRAM_SENT; 9365 sctp_ucount_decr(stcb->asoc.sent_queue_retran_cnt); 9366 if (fwd_tsn == 0) { 9367 return (0); 9368 } else { 9369 /* Clean up the fwd-tsn list */ 9370 sctp_clean_up_ctl(stcb, asoc, so_locked); 9371 return (0); 9372 } 9373 } 9374 /* 9375 * Ok, it is just data retransmission we need to do or that and a 9376 * fwd-tsn with it all. 9377 */ 9378 if (TAILQ_EMPTY(&asoc->sent_queue)) { 9379 return (SCTP_RETRAN_DONE); 9380 } 9381 if ((SCTP_GET_STATE(asoc) == SCTP_STATE_COOKIE_ECHOED) || 9382 (SCTP_GET_STATE(asoc) == SCTP_STATE_COOKIE_WAIT)) { 9383 /* not yet open, resend the cookie and that is it */ 9384 return (1); 9385 } 9386 #ifdef SCTP_AUDITING_ENABLED 9387 sctp_auditing(20, inp, stcb, NULL); 9388 #endif 9389 data_auth_reqd = sctp_auth_is_required_chunk(SCTP_DATA, stcb->asoc.peer_auth_chunks); 9390 TAILQ_FOREACH(chk, &asoc->sent_queue, sctp_next) { 9391 if (chk->sent != SCTP_DATAGRAM_RESEND) { 9392 /* No, not sent to this net or not ready for rtx */ 9393 continue; 9394 } 9395 if (chk->data == NULL) { 9396 SCTP_PRINTF("TSN:%x chk->snd_count:%d chk->sent:%d can't retran - no data\n", 9397 chk->rec.data.TSN_seq, chk->snd_count, chk->sent); 9398 continue; 9399 } 9400 if ((SCTP_BASE_SYSCTL(sctp_max_retran_chunk)) && 9401 (chk->snd_count >= SCTP_BASE_SYSCTL(sctp_max_retran_chunk))) { 9402 /* Gak, we have exceeded max unlucky retran, abort! */ 9403 SCTP_PRINTF("Gak, chk->snd_count:%d >= max:%d - send abort\n", 9404 chk->snd_count, 9405 SCTP_BASE_SYSCTL(sctp_max_retran_chunk)); 9406 atomic_add_int(&stcb->asoc.refcnt, 1); 9407 sctp_abort_an_association(stcb->sctp_ep, stcb, NULL, so_locked); 9408 SCTP_TCB_LOCK(stcb); 9409 atomic_subtract_int(&stcb->asoc.refcnt, 1); 9410 return (SCTP_RETRAN_EXIT); 9411 } 9412 /* pick up the net */ 9413 net = chk->whoTo; 9414 switch (net->ro._l_addr.sa.sa_family) { 9415 #ifdef INET 9416 case AF_INET: 9417 mtu = net->mtu - SCTP_MIN_V4_OVERHEAD; 9418 break; 9419 #endif 9420 #ifdef INET6 9421 case AF_INET6: 9422 mtu = net->mtu - SCTP_MIN_OVERHEAD; 9423 break; 9424 #endif 9425 default: 9426 /* TSNH */ 9427 mtu = net->mtu; 9428 break; 9429 } 9430 9431 if ((asoc->peers_rwnd < mtu) && (asoc->total_flight > 0)) { 9432 /* No room in peers rwnd */ 9433 uint32_t tsn; 9434 9435 tsn = asoc->last_acked_seq + 1; 9436 if (tsn == chk->rec.data.TSN_seq) { 9437 /* 9438 * we make a special exception for this 9439 * case. The peer has no rwnd but is missing 9440 * the lowest chunk.. which is probably what 9441 * is holding up the rwnd. 9442 */ 9443 goto one_chunk_around; 9444 } 9445 return (1); 9446 } 9447 one_chunk_around: 9448 if (asoc->peers_rwnd < mtu) { 9449 one_chunk = 1; 9450 if ((asoc->peers_rwnd == 0) && 9451 (asoc->total_flight == 0)) { 9452 chk->window_probe = 1; 9453 chk->whoTo->window_probe = 1; 9454 } 9455 } 9456 #ifdef SCTP_AUDITING_ENABLED 9457 sctp_audit_log(0xC3, 2); 9458 #endif 9459 bundle_at = 0; 9460 m = NULL; 9461 net->fast_retran_ip = 0; 9462 if (chk->rec.data.doing_fast_retransmit == 0) { 9463 /* 9464 * if no FR in progress skip destination that have 9465 * flight_size > cwnd. 9466 */ 9467 if (net->flight_size >= net->cwnd) { 9468 continue; 9469 } 9470 } else { 9471 /* 9472 * Mark the destination net to have FR recovery 9473 * limits put on it. 9474 */ 9475 *fr_done = 1; 9476 net->fast_retran_ip = 1; 9477 } 9478 9479 /* 9480 * if no AUTH is yet included and this chunk requires it, 9481 * make sure to account for it. We don't apply the size 9482 * until the AUTH chunk is actually added below in case 9483 * there is no room for this chunk. 9484 */ 9485 if (data_auth_reqd && (auth == NULL)) { 9486 dmtu = sctp_get_auth_chunk_len(stcb->asoc.peer_hmac_id); 9487 } else 9488 dmtu = 0; 9489 9490 if ((chk->send_size <= (mtu - dmtu)) || 9491 (chk->flags & CHUNK_FLAGS_FRAGMENT_OK)) { 9492 /* ok we will add this one */ 9493 if (data_auth_reqd) { 9494 if (auth == NULL) { 9495 m = sctp_add_auth_chunk(m, 9496 &endofchain, 9497 &auth, 9498 &auth_offset, 9499 stcb, 9500 SCTP_DATA); 9501 auth_keyid = chk->auth_keyid; 9502 override_ok = 0; 9503 SCTP_STAT_INCR_COUNTER64(sctps_outcontrolchunks); 9504 } else if (override_ok) { 9505 auth_keyid = chk->auth_keyid; 9506 override_ok = 0; 9507 } else if (chk->auth_keyid != auth_keyid) { 9508 /* different keyid, so done bundling */ 9509 break; 9510 } 9511 } 9512 m = sctp_copy_mbufchain(chk->data, m, &endofchain, 0, chk->send_size, chk->copy_by_ref); 9513 if (m == NULL) { 9514 SCTP_LTRACE_ERR_RET(inp, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, ENOMEM); 9515 return (ENOMEM); 9516 } 9517 /* Do clear IP_DF ? */ 9518 if (chk->flags & CHUNK_FLAGS_FRAGMENT_OK) { 9519 no_fragmentflg = 0; 9520 } 9521 /* upate our MTU size */ 9522 if (mtu > (chk->send_size + dmtu)) 9523 mtu -= (chk->send_size + dmtu); 9524 else 9525 mtu = 0; 9526 data_list[bundle_at++] = chk; 9527 if (one_chunk && (asoc->total_flight <= 0)) { 9528 SCTP_STAT_INCR(sctps_windowprobed); 9529 } 9530 } 9531 if (one_chunk == 0) { 9532 /* 9533 * now are there anymore forward from chk to pick 9534 * up? 9535 */ 9536 for (fwd = TAILQ_NEXT(chk, sctp_next); fwd != NULL; fwd = TAILQ_NEXT(fwd, sctp_next)) { 9537 if (fwd->sent != SCTP_DATAGRAM_RESEND) { 9538 /* Nope, not for retran */ 9539 continue; 9540 } 9541 if (fwd->whoTo != net) { 9542 /* Nope, not the net in question */ 9543 continue; 9544 } 9545 if (data_auth_reqd && (auth == NULL)) { 9546 dmtu = sctp_get_auth_chunk_len(stcb->asoc.peer_hmac_id); 9547 } else 9548 dmtu = 0; 9549 if (fwd->send_size <= (mtu - dmtu)) { 9550 if (data_auth_reqd) { 9551 if (auth == NULL) { 9552 m = sctp_add_auth_chunk(m, 9553 &endofchain, 9554 &auth, 9555 &auth_offset, 9556 stcb, 9557 SCTP_DATA); 9558 auth_keyid = fwd->auth_keyid; 9559 override_ok = 0; 9560 SCTP_STAT_INCR_COUNTER64(sctps_outcontrolchunks); 9561 } else if (override_ok) { 9562 auth_keyid = fwd->auth_keyid; 9563 override_ok = 0; 9564 } else if (fwd->auth_keyid != auth_keyid) { 9565 /* 9566 * different keyid, 9567 * so done bundling 9568 */ 9569 break; 9570 } 9571 } 9572 m = sctp_copy_mbufchain(fwd->data, m, &endofchain, 0, fwd->send_size, fwd->copy_by_ref); 9573 if (m == NULL) { 9574 SCTP_LTRACE_ERR_RET(inp, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, ENOMEM); 9575 return (ENOMEM); 9576 } 9577 /* Do clear IP_DF ? */ 9578 if (fwd->flags & CHUNK_FLAGS_FRAGMENT_OK) { 9579 no_fragmentflg = 0; 9580 } 9581 /* upate our MTU size */ 9582 if (mtu > (fwd->send_size + dmtu)) 9583 mtu -= (fwd->send_size + dmtu); 9584 else 9585 mtu = 0; 9586 data_list[bundle_at++] = fwd; 9587 if (bundle_at >= SCTP_MAX_DATA_BUNDLING) { 9588 break; 9589 } 9590 } else { 9591 /* can't fit so we are done */ 9592 break; 9593 } 9594 } 9595 } 9596 /* Is there something to send for this destination? */ 9597 if (m) { 9598 /* 9599 * No matter if we fail/or suceed we should start a 9600 * timer. A failure is like a lost IP packet :-) 9601 */ 9602 if (!SCTP_OS_TIMER_PENDING(&net->rxt_timer.timer)) { 9603 /* 9604 * no timer running on this destination 9605 * restart it. 9606 */ 9607 sctp_timer_start(SCTP_TIMER_TYPE_SEND, inp, stcb, net); 9608 tmr_started = 1; 9609 } 9610 /* Now lets send it, if there is anything to send :> */ 9611 if ((error = sctp_lowlevel_chunk_output(inp, stcb, net, 9612 (struct sockaddr *)&net->ro._l_addr, m, 9613 auth_offset, auth, auth_keyid, 9614 no_fragmentflg, 0, 0, 9615 inp->sctp_lport, stcb->rport, htonl(stcb->asoc.peer_vtag), 9616 net->port, NULL, 9617 0, 0, 9618 so_locked))) { 9619 /* error, we could not output */ 9620 SCTP_STAT_INCR(sctps_lowlevelerr); 9621 return (error); 9622 } 9623 endofchain = NULL; 9624 auth = NULL; 9625 auth_offset = 0; 9626 /* For HB's */ 9627 /* 9628 * We don't want to mark the net->sent time here 9629 * since this we use this for HB and retrans cannot 9630 * measure RTT 9631 */ 9632 /* (void)SCTP_GETTIME_TIMEVAL(&net->last_sent_time); */ 9633 9634 /* For auto-close */ 9635 cnt_thru++; 9636 if (*now_filled == 0) { 9637 (void)SCTP_GETTIME_TIMEVAL(&asoc->time_last_sent); 9638 *now = asoc->time_last_sent; 9639 *now_filled = 1; 9640 } else { 9641 asoc->time_last_sent = *now; 9642 } 9643 *cnt_out += bundle_at; 9644 #ifdef SCTP_AUDITING_ENABLED 9645 sctp_audit_log(0xC4, bundle_at); 9646 #endif 9647 if (bundle_at) { 9648 tsns_sent = data_list[0]->rec.data.TSN_seq; 9649 } 9650 for (i = 0; i < bundle_at; i++) { 9651 SCTP_STAT_INCR(sctps_sendretransdata); 9652 data_list[i]->sent = SCTP_DATAGRAM_SENT; 9653 /* 9654 * When we have a revoked data, and we 9655 * retransmit it, then we clear the revoked 9656 * flag since this flag dictates if we 9657 * subtracted from the fs 9658 */ 9659 if (data_list[i]->rec.data.chunk_was_revoked) { 9660 /* Deflate the cwnd */ 9661 data_list[i]->whoTo->cwnd -= data_list[i]->book_size; 9662 data_list[i]->rec.data.chunk_was_revoked = 0; 9663 } 9664 data_list[i]->snd_count++; 9665 sctp_ucount_decr(asoc->sent_queue_retran_cnt); 9666 /* record the time */ 9667 data_list[i]->sent_rcv_time = asoc->time_last_sent; 9668 if (data_list[i]->book_size_scale) { 9669 /* 9670 * need to double the book size on 9671 * this one 9672 */ 9673 data_list[i]->book_size_scale = 0; 9674 /* 9675 * Since we double the booksize, we 9676 * must also double the output queue 9677 * size, since this get shrunk when 9678 * we free by this amount. 9679 */ 9680 atomic_add_int(&((asoc)->total_output_queue_size), data_list[i]->book_size); 9681 data_list[i]->book_size *= 2; 9682 9683 9684 } else { 9685 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_LOG_RWND_ENABLE) { 9686 sctp_log_rwnd(SCTP_DECREASE_PEER_RWND, 9687 asoc->peers_rwnd, data_list[i]->send_size, SCTP_BASE_SYSCTL(sctp_peer_chunk_oh)); 9688 } 9689 asoc->peers_rwnd = sctp_sbspace_sub(asoc->peers_rwnd, 9690 (uint32_t) (data_list[i]->send_size + 9691 SCTP_BASE_SYSCTL(sctp_peer_chunk_oh))); 9692 } 9693 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_FLIGHT_LOGGING_ENABLE) { 9694 sctp_misc_ints(SCTP_FLIGHT_LOG_UP_RSND, 9695 data_list[i]->whoTo->flight_size, 9696 data_list[i]->book_size, 9697 (uintptr_t) data_list[i]->whoTo, 9698 data_list[i]->rec.data.TSN_seq); 9699 } 9700 sctp_flight_size_increase(data_list[i]); 9701 sctp_total_flight_increase(stcb, data_list[i]); 9702 if (asoc->peers_rwnd < stcb->sctp_ep->sctp_ep.sctp_sws_sender) { 9703 /* SWS sender side engages */ 9704 asoc->peers_rwnd = 0; 9705 } 9706 if ((i == 0) && 9707 (data_list[i]->rec.data.doing_fast_retransmit)) { 9708 SCTP_STAT_INCR(sctps_sendfastretrans); 9709 if ((data_list[i] == TAILQ_FIRST(&asoc->sent_queue)) && 9710 (tmr_started == 0)) { 9711 /*- 9712 * ok we just fast-retrans'd 9713 * the lowest TSN, i.e the 9714 * first on the list. In 9715 * this case we want to give 9716 * some more time to get a 9717 * SACK back without a 9718 * t3-expiring. 9719 */ 9720 sctp_timer_stop(SCTP_TIMER_TYPE_SEND, inp, stcb, net, 9721 SCTP_FROM_SCTP_OUTPUT + SCTP_LOC_4); 9722 sctp_timer_start(SCTP_TIMER_TYPE_SEND, inp, stcb, net); 9723 } 9724 } 9725 } 9726 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_LOGGING_ENABLE) { 9727 sctp_log_cwnd(stcb, net, tsns_sent, SCTP_CWND_LOG_FROM_RESEND); 9728 } 9729 #ifdef SCTP_AUDITING_ENABLED 9730 sctp_auditing(21, inp, stcb, NULL); 9731 #endif 9732 } else { 9733 /* None will fit */ 9734 return (1); 9735 } 9736 if (asoc->sent_queue_retran_cnt <= 0) { 9737 /* all done we have no more to retran */ 9738 asoc->sent_queue_retran_cnt = 0; 9739 break; 9740 } 9741 if (one_chunk) { 9742 /* No more room in rwnd */ 9743 return (1); 9744 } 9745 /* stop the for loop here. we sent out a packet */ 9746 break; 9747 } 9748 return (0); 9749 } 9750 9751 static void 9752 sctp_timer_validation(struct sctp_inpcb *inp, 9753 struct sctp_tcb *stcb, 9754 struct sctp_association *asoc) 9755 { 9756 struct sctp_nets *net; 9757 9758 /* Validate that a timer is running somewhere */ 9759 TAILQ_FOREACH(net, &asoc->nets, sctp_next) { 9760 if (SCTP_OS_TIMER_PENDING(&net->rxt_timer.timer)) { 9761 /* Here is a timer */ 9762 return; 9763 } 9764 } 9765 SCTP_TCB_LOCK_ASSERT(stcb); 9766 /* Gak, we did not have a timer somewhere */ 9767 SCTPDBG(SCTP_DEBUG_OUTPUT3, "Deadlock avoided starting timer on a dest at retran\n"); 9768 if (asoc->alternate) { 9769 sctp_timer_start(SCTP_TIMER_TYPE_SEND, inp, stcb, asoc->alternate); 9770 } else { 9771 sctp_timer_start(SCTP_TIMER_TYPE_SEND, inp, stcb, asoc->primary_destination); 9772 } 9773 return; 9774 } 9775 9776 void 9777 sctp_chunk_output(struct sctp_inpcb *inp, 9778 struct sctp_tcb *stcb, 9779 int from_where, 9780 int so_locked 9781 #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING) 9782 SCTP_UNUSED 9783 #endif 9784 ) 9785 { 9786 /*- 9787 * Ok this is the generic chunk service queue. we must do the 9788 * following: 9789 * - See if there are retransmits pending, if so we must 9790 * do these first. 9791 * - Service the stream queue that is next, moving any 9792 * message (note I must get a complete message i.e. 9793 * FIRST/MIDDLE and LAST to the out queue in one pass) and assigning 9794 * TSN's 9795 * - Check to see if the cwnd/rwnd allows any output, if so we 9796 * go ahead and fomulate and send the low level chunks. Making sure 9797 * to combine any control in the control chunk queue also. 9798 */ 9799 struct sctp_association *asoc; 9800 struct sctp_nets *net; 9801 int error = 0, num_out = 0, tot_out = 0, ret = 0, reason_code = 0; 9802 unsigned int burst_cnt = 0; 9803 struct timeval now; 9804 int now_filled = 0; 9805 int nagle_on; 9806 int frag_point = sctp_get_frag_point(stcb, &stcb->asoc); 9807 int un_sent = 0; 9808 int fr_done; 9809 unsigned int tot_frs = 0; 9810 9811 asoc = &stcb->asoc; 9812 /* The Nagle algorithm is only applied when handling a send call. */ 9813 if (from_where == SCTP_OUTPUT_FROM_USR_SEND) { 9814 if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_NODELAY)) { 9815 nagle_on = 0; 9816 } else { 9817 nagle_on = 1; 9818 } 9819 } else { 9820 nagle_on = 0; 9821 } 9822 SCTP_TCB_LOCK_ASSERT(stcb); 9823 9824 un_sent = (stcb->asoc.total_output_queue_size - stcb->asoc.total_flight); 9825 9826 if ((un_sent <= 0) && 9827 (TAILQ_EMPTY(&asoc->control_send_queue)) && 9828 (TAILQ_EMPTY(&asoc->asconf_send_queue)) && 9829 (asoc->sent_queue_retran_cnt == 0)) { 9830 /* Nothing to do unless there is something to be sent left */ 9831 return; 9832 } 9833 /* 9834 * Do we have something to send, data or control AND a sack timer 9835 * running, if so piggy-back the sack. 9836 */ 9837 if (SCTP_OS_TIMER_PENDING(&stcb->asoc.dack_timer.timer)) { 9838 sctp_send_sack(stcb, so_locked); 9839 (void)SCTP_OS_TIMER_STOP(&stcb->asoc.dack_timer.timer); 9840 } 9841 while (asoc->sent_queue_retran_cnt) { 9842 /*- 9843 * Ok, it is retransmission time only, we send out only ONE 9844 * packet with a single call off to the retran code. 9845 */ 9846 if (from_where == SCTP_OUTPUT_FROM_COOKIE_ACK) { 9847 /*- 9848 * Special hook for handling cookiess discarded 9849 * by peer that carried data. Send cookie-ack only 9850 * and then the next call with get the retran's. 9851 */ 9852 (void)sctp_med_chunk_output(inp, stcb, asoc, &num_out, &reason_code, 1, 9853 from_where, 9854 &now, &now_filled, frag_point, so_locked); 9855 return; 9856 } else if (from_where != SCTP_OUTPUT_FROM_HB_TMR) { 9857 /* if its not from a HB then do it */ 9858 fr_done = 0; 9859 ret = sctp_chunk_retransmission(inp, stcb, asoc, &num_out, &now, &now_filled, &fr_done, so_locked); 9860 if (fr_done) { 9861 tot_frs++; 9862 } 9863 } else { 9864 /* 9865 * its from any other place, we don't allow retran 9866 * output (only control) 9867 */ 9868 ret = 1; 9869 } 9870 if (ret > 0) { 9871 /* Can't send anymore */ 9872 /*- 9873 * now lets push out control by calling med-level 9874 * output once. this assures that we WILL send HB's 9875 * if queued too. 9876 */ 9877 (void)sctp_med_chunk_output(inp, stcb, asoc, &num_out, &reason_code, 1, 9878 from_where, 9879 &now, &now_filled, frag_point, so_locked); 9880 #ifdef SCTP_AUDITING_ENABLED 9881 sctp_auditing(8, inp, stcb, NULL); 9882 #endif 9883 sctp_timer_validation(inp, stcb, asoc); 9884 return; 9885 } 9886 if (ret < 0) { 9887 /*- 9888 * The count was off.. retran is not happening so do 9889 * the normal retransmission. 9890 */ 9891 #ifdef SCTP_AUDITING_ENABLED 9892 sctp_auditing(9, inp, stcb, NULL); 9893 #endif 9894 if (ret == SCTP_RETRAN_EXIT) { 9895 return; 9896 } 9897 break; 9898 } 9899 if (from_where == SCTP_OUTPUT_FROM_T3) { 9900 /* Only one transmission allowed out of a timeout */ 9901 #ifdef SCTP_AUDITING_ENABLED 9902 sctp_auditing(10, inp, stcb, NULL); 9903 #endif 9904 /* Push out any control */ 9905 (void)sctp_med_chunk_output(inp, stcb, asoc, &num_out, &reason_code, 1, from_where, 9906 &now, &now_filled, frag_point, so_locked); 9907 return; 9908 } 9909 if ((asoc->fr_max_burst > 0) && (tot_frs >= asoc->fr_max_burst)) { 9910 /* Hit FR burst limit */ 9911 return; 9912 } 9913 if ((num_out == 0) && (ret == 0)) { 9914 /* No more retrans to send */ 9915 break; 9916 } 9917 } 9918 #ifdef SCTP_AUDITING_ENABLED 9919 sctp_auditing(12, inp, stcb, NULL); 9920 #endif 9921 /* Check for bad destinations, if they exist move chunks around. */ 9922 TAILQ_FOREACH(net, &asoc->nets, sctp_next) { 9923 if (!(net->dest_state & SCTP_ADDR_REACHABLE)) { 9924 /*- 9925 * if possible move things off of this address we 9926 * still may send below due to the dormant state but 9927 * we try to find an alternate address to send to 9928 * and if we have one we move all queued data on the 9929 * out wheel to this alternate address. 9930 */ 9931 if (net->ref_count > 1) 9932 sctp_move_chunks_from_net(stcb, net); 9933 } else { 9934 /*- 9935 * if ((asoc->sat_network) || (net->addr_is_local)) 9936 * { burst_limit = asoc->max_burst * 9937 * SCTP_SAT_NETWORK_BURST_INCR; } 9938 */ 9939 if (asoc->max_burst > 0) { 9940 if (SCTP_BASE_SYSCTL(sctp_use_cwnd_based_maxburst)) { 9941 if ((net->flight_size + (asoc->max_burst * net->mtu)) < net->cwnd) { 9942 /* 9943 * JRS - Use the congestion 9944 * control given in the 9945 * congestion control module 9946 */ 9947 asoc->cc_functions.sctp_cwnd_update_after_output(stcb, net, asoc->max_burst); 9948 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_LOG_MAXBURST_ENABLE) { 9949 sctp_log_maxburst(stcb, net, 0, asoc->max_burst, SCTP_MAX_BURST_APPLIED); 9950 } 9951 SCTP_STAT_INCR(sctps_maxburstqueued); 9952 } 9953 net->fast_retran_ip = 0; 9954 } else { 9955 if (net->flight_size == 0) { 9956 /* 9957 * Should be decaying the 9958 * cwnd here 9959 */ 9960 ; 9961 } 9962 } 9963 } 9964 } 9965 9966 } 9967 burst_cnt = 0; 9968 do { 9969 error = sctp_med_chunk_output(inp, stcb, asoc, &num_out, 9970 &reason_code, 0, from_where, 9971 &now, &now_filled, frag_point, so_locked); 9972 if (error) { 9973 SCTPDBG(SCTP_DEBUG_OUTPUT1, "Error %d was returned from med-c-op\n", error); 9974 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_LOG_MAXBURST_ENABLE) { 9975 sctp_log_maxburst(stcb, asoc->primary_destination, error, burst_cnt, SCTP_MAX_BURST_ERROR_STOP); 9976 } 9977 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_LOGGING_ENABLE) { 9978 sctp_log_cwnd(stcb, NULL, error, SCTP_SEND_NOW_COMPLETES); 9979 sctp_log_cwnd(stcb, NULL, 0xdeadbeef, SCTP_SEND_NOW_COMPLETES); 9980 } 9981 break; 9982 } 9983 SCTPDBG(SCTP_DEBUG_OUTPUT3, "m-c-o put out %d\n", num_out); 9984 9985 tot_out += num_out; 9986 burst_cnt++; 9987 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_LOGGING_ENABLE) { 9988 sctp_log_cwnd(stcb, NULL, num_out, SCTP_SEND_NOW_COMPLETES); 9989 if (num_out == 0) { 9990 sctp_log_cwnd(stcb, NULL, reason_code, SCTP_SEND_NOW_COMPLETES); 9991 } 9992 } 9993 if (nagle_on) { 9994 /* 9995 * When the Nagle algorithm is used, look at how 9996 * much is unsent, then if its smaller than an MTU 9997 * and we have data in flight we stop, except if we 9998 * are handling a fragmented user message. 9999 */ 10000 un_sent = ((stcb->asoc.total_output_queue_size - stcb->asoc.total_flight) + 10001 (stcb->asoc.stream_queue_cnt * sizeof(struct sctp_data_chunk))); 10002 if ((un_sent < (int)(stcb->asoc.smallest_mtu - SCTP_MIN_OVERHEAD)) && 10003 (stcb->asoc.total_flight > 0) && 10004 ((stcb->asoc.locked_on_sending == NULL) || 10005 sctp_is_feature_on(inp, SCTP_PCB_FLAGS_EXPLICIT_EOR))) { 10006 break; 10007 } 10008 } 10009 if (TAILQ_EMPTY(&asoc->control_send_queue) && 10010 TAILQ_EMPTY(&asoc->send_queue) && 10011 stcb->asoc.ss_functions.sctp_ss_is_empty(stcb, asoc)) { 10012 /* Nothing left to send */ 10013 break; 10014 } 10015 if ((stcb->asoc.total_output_queue_size - stcb->asoc.total_flight) <= 0) { 10016 /* Nothing left to send */ 10017 break; 10018 } 10019 } while (num_out && 10020 ((asoc->max_burst == 0) || 10021 SCTP_BASE_SYSCTL(sctp_use_cwnd_based_maxburst) || 10022 (burst_cnt < asoc->max_burst))); 10023 10024 if (SCTP_BASE_SYSCTL(sctp_use_cwnd_based_maxburst) == 0) { 10025 if ((asoc->max_burst > 0) && (burst_cnt >= asoc->max_burst)) { 10026 SCTP_STAT_INCR(sctps_maxburstqueued); 10027 asoc->burst_limit_applied = 1; 10028 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_LOG_MAXBURST_ENABLE) { 10029 sctp_log_maxburst(stcb, asoc->primary_destination, 0, burst_cnt, SCTP_MAX_BURST_APPLIED); 10030 } 10031 } else { 10032 asoc->burst_limit_applied = 0; 10033 } 10034 } 10035 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_LOGGING_ENABLE) { 10036 sctp_log_cwnd(stcb, NULL, tot_out, SCTP_SEND_NOW_COMPLETES); 10037 } 10038 SCTPDBG(SCTP_DEBUG_OUTPUT1, "Ok, we have put out %d chunks\n", 10039 tot_out); 10040 10041 /*- 10042 * Now we need to clean up the control chunk chain if a ECNE is on 10043 * it. It must be marked as UNSENT again so next call will continue 10044 * to send it until such time that we get a CWR, to remove it. 10045 */ 10046 if (stcb->asoc.ecn_echo_cnt_onq) 10047 sctp_fix_ecn_echo(asoc); 10048 return; 10049 } 10050 10051 10052 int 10053 sctp_output( 10054 struct sctp_inpcb *inp, 10055 struct mbuf *m, 10056 struct sockaddr *addr, 10057 struct mbuf *control, 10058 struct thread *p, 10059 int flags) 10060 { 10061 if (inp == NULL) { 10062 SCTP_LTRACE_ERR_RET_PKT(m, inp, NULL, NULL, SCTP_FROM_SCTP_OUTPUT, EINVAL); 10063 return (EINVAL); 10064 } 10065 if (inp->sctp_socket == NULL) { 10066 SCTP_LTRACE_ERR_RET_PKT(m, inp, NULL, NULL, SCTP_FROM_SCTP_OUTPUT, EINVAL); 10067 return (EINVAL); 10068 } 10069 return (sctp_sosend(inp->sctp_socket, 10070 addr, 10071 (struct uio *)NULL, 10072 m, 10073 control, 10074 flags, p 10075 )); 10076 } 10077 10078 void 10079 send_forward_tsn(struct sctp_tcb *stcb, 10080 struct sctp_association *asoc) 10081 { 10082 struct sctp_tmit_chunk *chk; 10083 struct sctp_forward_tsn_chunk *fwdtsn; 10084 uint32_t advance_peer_ack_point; 10085 10086 SCTP_TCB_LOCK_ASSERT(stcb); 10087 TAILQ_FOREACH(chk, &asoc->control_send_queue, sctp_next) { 10088 if (chk->rec.chunk_id.id == SCTP_FORWARD_CUM_TSN) { 10089 /* mark it to unsent */ 10090 chk->sent = SCTP_DATAGRAM_UNSENT; 10091 chk->snd_count = 0; 10092 /* Do we correct its output location? */ 10093 if (chk->whoTo) { 10094 sctp_free_remote_addr(chk->whoTo); 10095 chk->whoTo = NULL; 10096 } 10097 goto sctp_fill_in_rest; 10098 } 10099 } 10100 /* Ok if we reach here we must build one */ 10101 sctp_alloc_a_chunk(stcb, chk); 10102 if (chk == NULL) { 10103 return; 10104 } 10105 asoc->fwd_tsn_cnt++; 10106 chk->copy_by_ref = 0; 10107 chk->rec.chunk_id.id = SCTP_FORWARD_CUM_TSN; 10108 chk->rec.chunk_id.can_take_data = 0; 10109 chk->asoc = asoc; 10110 chk->whoTo = NULL; 10111 chk->data = sctp_get_mbuf_for_msg(MCLBYTES, 0, M_DONTWAIT, 1, MT_DATA); 10112 if (chk->data == NULL) { 10113 sctp_free_a_chunk(stcb, chk, SCTP_SO_NOT_LOCKED); 10114 return; 10115 } 10116 SCTP_BUF_RESV_UF(chk->data, SCTP_MIN_OVERHEAD); 10117 chk->sent = SCTP_DATAGRAM_UNSENT; 10118 chk->snd_count = 0; 10119 TAILQ_INSERT_TAIL(&asoc->control_send_queue, chk, sctp_next); 10120 asoc->ctrl_queue_cnt++; 10121 sctp_fill_in_rest: 10122 /*- 10123 * Here we go through and fill out the part that deals with 10124 * stream/seq of the ones we skip. 10125 */ 10126 SCTP_BUF_LEN(chk->data) = 0; 10127 { 10128 struct sctp_tmit_chunk *at, *tp1, *last; 10129 struct sctp_strseq *strseq; 10130 unsigned int cnt_of_space, i, ovh; 10131 unsigned int space_needed; 10132 unsigned int cnt_of_skipped = 0; 10133 10134 TAILQ_FOREACH(at, &asoc->sent_queue, sctp_next) { 10135 if ((at->sent != SCTP_FORWARD_TSN_SKIP) && 10136 (at->sent != SCTP_DATAGRAM_NR_ACKED)) { 10137 /* no more to look at */ 10138 break; 10139 } 10140 if (at->rec.data.rcv_flags & SCTP_DATA_UNORDERED) { 10141 /* We don't report these */ 10142 continue; 10143 } 10144 cnt_of_skipped++; 10145 } 10146 space_needed = (sizeof(struct sctp_forward_tsn_chunk) + 10147 (cnt_of_skipped * sizeof(struct sctp_strseq))); 10148 10149 cnt_of_space = M_TRAILINGSPACE(chk->data); 10150 10151 if (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) { 10152 ovh = SCTP_MIN_OVERHEAD; 10153 } else { 10154 ovh = SCTP_MIN_V4_OVERHEAD; 10155 } 10156 if (cnt_of_space > (asoc->smallest_mtu - ovh)) { 10157 /* trim to a mtu size */ 10158 cnt_of_space = asoc->smallest_mtu - ovh; 10159 } 10160 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_LOG_TRY_ADVANCE) { 10161 sctp_misc_ints(SCTP_FWD_TSN_CHECK, 10162 0xff, 0, cnt_of_skipped, 10163 asoc->advanced_peer_ack_point); 10164 10165 } 10166 advance_peer_ack_point = asoc->advanced_peer_ack_point; 10167 if (cnt_of_space < space_needed) { 10168 /*- 10169 * ok we must trim down the chunk by lowering the 10170 * advance peer ack point. 10171 */ 10172 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_LOG_TRY_ADVANCE) { 10173 sctp_misc_ints(SCTP_FWD_TSN_CHECK, 10174 0xff, 0xff, cnt_of_space, 10175 space_needed); 10176 } 10177 cnt_of_skipped = cnt_of_space - sizeof(struct sctp_forward_tsn_chunk); 10178 cnt_of_skipped /= sizeof(struct sctp_strseq); 10179 /*- 10180 * Go through and find the TSN that will be the one 10181 * we report. 10182 */ 10183 at = TAILQ_FIRST(&asoc->sent_queue); 10184 if (at != NULL) { 10185 for (i = 0; i < cnt_of_skipped; i++) { 10186 tp1 = TAILQ_NEXT(at, sctp_next); 10187 if (tp1 == NULL) { 10188 break; 10189 } 10190 at = tp1; 10191 } 10192 } 10193 if (at && SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_LOG_TRY_ADVANCE) { 10194 sctp_misc_ints(SCTP_FWD_TSN_CHECK, 10195 0xff, cnt_of_skipped, at->rec.data.TSN_seq, 10196 asoc->advanced_peer_ack_point); 10197 } 10198 last = at; 10199 /*- 10200 * last now points to last one I can report, update 10201 * peer ack point 10202 */ 10203 if (last) 10204 advance_peer_ack_point = last->rec.data.TSN_seq; 10205 space_needed = sizeof(struct sctp_forward_tsn_chunk) + 10206 cnt_of_skipped * sizeof(struct sctp_strseq); 10207 } 10208 chk->send_size = space_needed; 10209 /* Setup the chunk */ 10210 fwdtsn = mtod(chk->data, struct sctp_forward_tsn_chunk *); 10211 fwdtsn->ch.chunk_length = htons(chk->send_size); 10212 fwdtsn->ch.chunk_flags = 0; 10213 fwdtsn->ch.chunk_type = SCTP_FORWARD_CUM_TSN; 10214 fwdtsn->new_cumulative_tsn = htonl(advance_peer_ack_point); 10215 SCTP_BUF_LEN(chk->data) = chk->send_size; 10216 fwdtsn++; 10217 /*- 10218 * Move pointer to after the fwdtsn and transfer to the 10219 * strseq pointer. 10220 */ 10221 strseq = (struct sctp_strseq *)fwdtsn; 10222 /*- 10223 * Now populate the strseq list. This is done blindly 10224 * without pulling out duplicate stream info. This is 10225 * inefficent but won't harm the process since the peer will 10226 * look at these in sequence and will thus release anything. 10227 * It could mean we exceed the PMTU and chop off some that 10228 * we could have included.. but this is unlikely (aka 1432/4 10229 * would mean 300+ stream seq's would have to be reported in 10230 * one FWD-TSN. With a bit of work we can later FIX this to 10231 * optimize and pull out duplcates.. but it does add more 10232 * overhead. So for now... not! 10233 */ 10234 at = TAILQ_FIRST(&asoc->sent_queue); 10235 for (i = 0; i < cnt_of_skipped; i++) { 10236 tp1 = TAILQ_NEXT(at, sctp_next); 10237 if (tp1 == NULL) 10238 break; 10239 if (at->rec.data.rcv_flags & SCTP_DATA_UNORDERED) { 10240 /* We don't report these */ 10241 i--; 10242 at = tp1; 10243 continue; 10244 } 10245 if (at->rec.data.TSN_seq == advance_peer_ack_point) { 10246 at->rec.data.fwd_tsn_cnt = 0; 10247 } 10248 strseq->stream = ntohs(at->rec.data.stream_number); 10249 strseq->sequence = ntohs(at->rec.data.stream_seq); 10250 strseq++; 10251 at = tp1; 10252 } 10253 } 10254 return; 10255 } 10256 10257 void 10258 sctp_send_sack(struct sctp_tcb *stcb, int so_locked 10259 #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING) 10260 SCTP_UNUSED 10261 #endif 10262 ) 10263 { 10264 /*- 10265 * Queue up a SACK or NR-SACK in the control queue. 10266 * We must first check to see if a SACK or NR-SACK is 10267 * somehow on the control queue. 10268 * If so, we will take and and remove the old one. 10269 */ 10270 struct sctp_association *asoc; 10271 struct sctp_tmit_chunk *chk, *a_chk; 10272 struct sctp_sack_chunk *sack; 10273 struct sctp_nr_sack_chunk *nr_sack; 10274 struct sctp_gap_ack_block *gap_descriptor; 10275 struct sack_track *selector; 10276 int mergeable = 0; 10277 int offset; 10278 caddr_t limit; 10279 uint32_t *dup; 10280 int limit_reached = 0; 10281 unsigned int i, siz, j; 10282 unsigned int num_gap_blocks = 0, num_nr_gap_blocks = 0, space; 10283 int num_dups = 0; 10284 int space_req; 10285 uint32_t highest_tsn; 10286 uint8_t flags; 10287 uint8_t type; 10288 uint8_t tsn_map; 10289 10290 if ((stcb->asoc.sctp_nr_sack_on_off == 1) && 10291 (stcb->asoc.peer_supports_nr_sack == 1)) { 10292 type = SCTP_NR_SELECTIVE_ACK; 10293 } else { 10294 type = SCTP_SELECTIVE_ACK; 10295 } 10296 a_chk = NULL; 10297 asoc = &stcb->asoc; 10298 SCTP_TCB_LOCK_ASSERT(stcb); 10299 if (asoc->last_data_chunk_from == NULL) { 10300 /* Hmm we never received anything */ 10301 return; 10302 } 10303 sctp_slide_mapping_arrays(stcb); 10304 sctp_set_rwnd(stcb, asoc); 10305 TAILQ_FOREACH(chk, &asoc->control_send_queue, sctp_next) { 10306 if (chk->rec.chunk_id.id == type) { 10307 /* Hmm, found a sack already on queue, remove it */ 10308 TAILQ_REMOVE(&asoc->control_send_queue, chk, sctp_next); 10309 asoc->ctrl_queue_cnt--; 10310 a_chk = chk; 10311 if (a_chk->data) { 10312 sctp_m_freem(a_chk->data); 10313 a_chk->data = NULL; 10314 } 10315 if (a_chk->whoTo) { 10316 sctp_free_remote_addr(a_chk->whoTo); 10317 a_chk->whoTo = NULL; 10318 } 10319 break; 10320 } 10321 } 10322 if (a_chk == NULL) { 10323 sctp_alloc_a_chunk(stcb, a_chk); 10324 if (a_chk == NULL) { 10325 /* No memory so we drop the idea, and set a timer */ 10326 if (stcb->asoc.delayed_ack) { 10327 sctp_timer_stop(SCTP_TIMER_TYPE_RECV, 10328 stcb->sctp_ep, stcb, NULL, SCTP_FROM_SCTP_OUTPUT + SCTP_LOC_5); 10329 sctp_timer_start(SCTP_TIMER_TYPE_RECV, 10330 stcb->sctp_ep, stcb, NULL); 10331 } else { 10332 stcb->asoc.send_sack = 1; 10333 } 10334 return; 10335 } 10336 a_chk->copy_by_ref = 0; 10337 a_chk->rec.chunk_id.id = type; 10338 a_chk->rec.chunk_id.can_take_data = 1; 10339 } 10340 /* Clear our pkt counts */ 10341 asoc->data_pkts_seen = 0; 10342 10343 a_chk->asoc = asoc; 10344 a_chk->snd_count = 0; 10345 a_chk->send_size = 0; /* fill in later */ 10346 a_chk->sent = SCTP_DATAGRAM_UNSENT; 10347 a_chk->whoTo = NULL; 10348 10349 if ((asoc->numduptsns) || 10350 (!(asoc->last_data_chunk_from->dest_state & SCTP_ADDR_REACHABLE))) { 10351 /*- 10352 * Ok, we have some duplicates or the destination for the 10353 * sack is unreachable, lets see if we can select an 10354 * alternate than asoc->last_data_chunk_from 10355 */ 10356 if ((asoc->last_data_chunk_from->dest_state & SCTP_ADDR_REACHABLE) && 10357 (asoc->used_alt_onsack > asoc->numnets)) { 10358 /* We used an alt last time, don't this time */ 10359 a_chk->whoTo = NULL; 10360 } else { 10361 asoc->used_alt_onsack++; 10362 a_chk->whoTo = sctp_find_alternate_net(stcb, asoc->last_data_chunk_from, 0); 10363 } 10364 if (a_chk->whoTo == NULL) { 10365 /* Nope, no alternate */ 10366 a_chk->whoTo = asoc->last_data_chunk_from; 10367 asoc->used_alt_onsack = 0; 10368 } 10369 } else { 10370 /* 10371 * No duplicates so we use the last place we received data 10372 * from. 10373 */ 10374 asoc->used_alt_onsack = 0; 10375 a_chk->whoTo = asoc->last_data_chunk_from; 10376 } 10377 if (a_chk->whoTo) { 10378 atomic_add_int(&a_chk->whoTo->ref_count, 1); 10379 } 10380 if (SCTP_TSN_GT(asoc->highest_tsn_inside_map, asoc->highest_tsn_inside_nr_map)) { 10381 highest_tsn = asoc->highest_tsn_inside_map; 10382 } else { 10383 highest_tsn = asoc->highest_tsn_inside_nr_map; 10384 } 10385 if (highest_tsn == asoc->cumulative_tsn) { 10386 /* no gaps */ 10387 if (type == SCTP_SELECTIVE_ACK) { 10388 space_req = sizeof(struct sctp_sack_chunk); 10389 } else { 10390 space_req = sizeof(struct sctp_nr_sack_chunk); 10391 } 10392 } else { 10393 /* gaps get a cluster */ 10394 space_req = MCLBYTES; 10395 } 10396 /* Ok now lets formulate a MBUF with our sack */ 10397 a_chk->data = sctp_get_mbuf_for_msg(space_req, 0, M_DONTWAIT, 1, MT_DATA); 10398 if ((a_chk->data == NULL) || 10399 (a_chk->whoTo == NULL)) { 10400 /* rats, no mbuf memory */ 10401 if (a_chk->data) { 10402 /* was a problem with the destination */ 10403 sctp_m_freem(a_chk->data); 10404 a_chk->data = NULL; 10405 } 10406 sctp_free_a_chunk(stcb, a_chk, so_locked); 10407 /* sa_ignore NO_NULL_CHK */ 10408 if (stcb->asoc.delayed_ack) { 10409 sctp_timer_stop(SCTP_TIMER_TYPE_RECV, 10410 stcb->sctp_ep, stcb, NULL, SCTP_FROM_SCTP_OUTPUT + SCTP_LOC_6); 10411 sctp_timer_start(SCTP_TIMER_TYPE_RECV, 10412 stcb->sctp_ep, stcb, NULL); 10413 } else { 10414 stcb->asoc.send_sack = 1; 10415 } 10416 return; 10417 } 10418 /* ok, lets go through and fill it in */ 10419 SCTP_BUF_RESV_UF(a_chk->data, SCTP_MIN_OVERHEAD); 10420 space = M_TRAILINGSPACE(a_chk->data); 10421 if (space > (a_chk->whoTo->mtu - SCTP_MIN_OVERHEAD)) { 10422 space = (a_chk->whoTo->mtu - SCTP_MIN_OVERHEAD); 10423 } 10424 limit = mtod(a_chk->data, caddr_t); 10425 limit += space; 10426 10427 flags = 0; 10428 10429 if ((asoc->sctp_cmt_on_off > 0) && 10430 SCTP_BASE_SYSCTL(sctp_cmt_use_dac)) { 10431 /*- 10432 * CMT DAC algorithm: If 2 (i.e., 0x10) packets have been 10433 * received, then set high bit to 1, else 0. Reset 10434 * pkts_rcvd. 10435 */ 10436 flags |= (asoc->cmt_dac_pkts_rcvd << 6); 10437 asoc->cmt_dac_pkts_rcvd = 0; 10438 } 10439 #ifdef SCTP_ASOCLOG_OF_TSNS 10440 stcb->asoc.cumack_logsnt[stcb->asoc.cumack_log_atsnt] = asoc->cumulative_tsn; 10441 stcb->asoc.cumack_log_atsnt++; 10442 if (stcb->asoc.cumack_log_atsnt >= SCTP_TSN_LOG_SIZE) { 10443 stcb->asoc.cumack_log_atsnt = 0; 10444 } 10445 #endif 10446 /* reset the readers interpretation */ 10447 stcb->freed_by_sorcv_sincelast = 0; 10448 10449 if (type == SCTP_SELECTIVE_ACK) { 10450 sack = mtod(a_chk->data, struct sctp_sack_chunk *); 10451 nr_sack = NULL; 10452 gap_descriptor = (struct sctp_gap_ack_block *)((caddr_t)sack + sizeof(struct sctp_sack_chunk)); 10453 if (highest_tsn > asoc->mapping_array_base_tsn) { 10454 siz = (((highest_tsn - asoc->mapping_array_base_tsn) + 1) + 7) / 8; 10455 } else { 10456 siz = (((MAX_TSN - highest_tsn) + 1) + highest_tsn + 7) / 8; 10457 } 10458 } else { 10459 sack = NULL; 10460 nr_sack = mtod(a_chk->data, struct sctp_nr_sack_chunk *); 10461 gap_descriptor = (struct sctp_gap_ack_block *)((caddr_t)nr_sack + sizeof(struct sctp_nr_sack_chunk)); 10462 if (asoc->highest_tsn_inside_map > asoc->mapping_array_base_tsn) { 10463 siz = (((asoc->highest_tsn_inside_map - asoc->mapping_array_base_tsn) + 1) + 7) / 8; 10464 } else { 10465 siz = (((MAX_TSN - asoc->mapping_array_base_tsn) + 1) + asoc->highest_tsn_inside_map + 7) / 8; 10466 } 10467 } 10468 10469 if (SCTP_TSN_GT(asoc->mapping_array_base_tsn, asoc->cumulative_tsn)) { 10470 offset = 1; 10471 } else { 10472 offset = asoc->mapping_array_base_tsn - asoc->cumulative_tsn; 10473 } 10474 if (((type == SCTP_SELECTIVE_ACK) && 10475 SCTP_TSN_GT(highest_tsn, asoc->cumulative_tsn)) || 10476 ((type == SCTP_NR_SELECTIVE_ACK) && 10477 SCTP_TSN_GT(asoc->highest_tsn_inside_map, asoc->cumulative_tsn))) { 10478 /* we have a gap .. maybe */ 10479 for (i = 0; i < siz; i++) { 10480 tsn_map = asoc->mapping_array[i]; 10481 if (type == SCTP_SELECTIVE_ACK) { 10482 tsn_map |= asoc->nr_mapping_array[i]; 10483 } 10484 if (i == 0) { 10485 /* 10486 * Clear all bits corresponding to TSNs 10487 * smaller or equal to the cumulative TSN. 10488 */ 10489 tsn_map &= (~0 << (1 - offset)); 10490 } 10491 selector = &sack_array[tsn_map]; 10492 if (mergeable && selector->right_edge) { 10493 /* 10494 * Backup, left and right edges were ok to 10495 * merge. 10496 */ 10497 num_gap_blocks--; 10498 gap_descriptor--; 10499 } 10500 if (selector->num_entries == 0) 10501 mergeable = 0; 10502 else { 10503 for (j = 0; j < selector->num_entries; j++) { 10504 if (mergeable && selector->right_edge) { 10505 /* 10506 * do a merge by NOT setting 10507 * the left side 10508 */ 10509 mergeable = 0; 10510 } else { 10511 /* 10512 * no merge, set the left 10513 * side 10514 */ 10515 mergeable = 0; 10516 gap_descriptor->start = htons((selector->gaps[j].start + offset)); 10517 } 10518 gap_descriptor->end = htons((selector->gaps[j].end + offset)); 10519 num_gap_blocks++; 10520 gap_descriptor++; 10521 if (((caddr_t)gap_descriptor + sizeof(struct sctp_gap_ack_block)) > limit) { 10522 /* no more room */ 10523 limit_reached = 1; 10524 break; 10525 } 10526 } 10527 if (selector->left_edge) { 10528 mergeable = 1; 10529 } 10530 } 10531 if (limit_reached) { 10532 /* Reached the limit stop */ 10533 break; 10534 } 10535 offset += 8; 10536 } 10537 } 10538 if ((type == SCTP_NR_SELECTIVE_ACK) && 10539 (limit_reached == 0)) { 10540 10541 mergeable = 0; 10542 10543 if (asoc->highest_tsn_inside_nr_map > asoc->mapping_array_base_tsn) { 10544 siz = (((asoc->highest_tsn_inside_nr_map - asoc->mapping_array_base_tsn) + 1) + 7) / 8; 10545 } else { 10546 siz = (((MAX_TSN - asoc->mapping_array_base_tsn) + 1) + asoc->highest_tsn_inside_nr_map + 7) / 8; 10547 } 10548 10549 if (SCTP_TSN_GT(asoc->mapping_array_base_tsn, asoc->cumulative_tsn)) { 10550 offset = 1; 10551 } else { 10552 offset = asoc->mapping_array_base_tsn - asoc->cumulative_tsn; 10553 } 10554 if (SCTP_TSN_GT(asoc->highest_tsn_inside_nr_map, asoc->cumulative_tsn)) { 10555 /* we have a gap .. maybe */ 10556 for (i = 0; i < siz; i++) { 10557 tsn_map = asoc->nr_mapping_array[i]; 10558 if (i == 0) { 10559 /* 10560 * Clear all bits corresponding to 10561 * TSNs smaller or equal to the 10562 * cumulative TSN. 10563 */ 10564 tsn_map &= (~0 << (1 - offset)); 10565 } 10566 selector = &sack_array[tsn_map]; 10567 if (mergeable && selector->right_edge) { 10568 /* 10569 * Backup, left and right edges were 10570 * ok to merge. 10571 */ 10572 num_nr_gap_blocks--; 10573 gap_descriptor--; 10574 } 10575 if (selector->num_entries == 0) 10576 mergeable = 0; 10577 else { 10578 for (j = 0; j < selector->num_entries; j++) { 10579 if (mergeable && selector->right_edge) { 10580 /* 10581 * do a merge by NOT 10582 * setting the left 10583 * side 10584 */ 10585 mergeable = 0; 10586 } else { 10587 /* 10588 * no merge, set the 10589 * left side 10590 */ 10591 mergeable = 0; 10592 gap_descriptor->start = htons((selector->gaps[j].start + offset)); 10593 } 10594 gap_descriptor->end = htons((selector->gaps[j].end + offset)); 10595 num_nr_gap_blocks++; 10596 gap_descriptor++; 10597 if (((caddr_t)gap_descriptor + sizeof(struct sctp_gap_ack_block)) > limit) { 10598 /* no more room */ 10599 limit_reached = 1; 10600 break; 10601 } 10602 } 10603 if (selector->left_edge) { 10604 mergeable = 1; 10605 } 10606 } 10607 if (limit_reached) { 10608 /* Reached the limit stop */ 10609 break; 10610 } 10611 offset += 8; 10612 } 10613 } 10614 } 10615 /* now we must add any dups we are going to report. */ 10616 if ((limit_reached == 0) && (asoc->numduptsns)) { 10617 dup = (uint32_t *) gap_descriptor; 10618 for (i = 0; i < asoc->numduptsns; i++) { 10619 *dup = htonl(asoc->dup_tsns[i]); 10620 dup++; 10621 num_dups++; 10622 if (((caddr_t)dup + sizeof(uint32_t)) > limit) { 10623 /* no more room */ 10624 break; 10625 } 10626 } 10627 asoc->numduptsns = 0; 10628 } 10629 /* 10630 * now that the chunk is prepared queue it to the control chunk 10631 * queue. 10632 */ 10633 if (type == SCTP_SELECTIVE_ACK) { 10634 a_chk->send_size = sizeof(struct sctp_sack_chunk) + 10635 (num_gap_blocks + num_nr_gap_blocks) * sizeof(struct sctp_gap_ack_block) + 10636 num_dups * sizeof(int32_t); 10637 SCTP_BUF_LEN(a_chk->data) = a_chk->send_size; 10638 sack->sack.cum_tsn_ack = htonl(asoc->cumulative_tsn); 10639 sack->sack.a_rwnd = htonl(asoc->my_rwnd); 10640 sack->sack.num_gap_ack_blks = htons(num_gap_blocks); 10641 sack->sack.num_dup_tsns = htons(num_dups); 10642 sack->ch.chunk_type = type; 10643 sack->ch.chunk_flags = flags; 10644 sack->ch.chunk_length = htons(a_chk->send_size); 10645 } else { 10646 a_chk->send_size = sizeof(struct sctp_nr_sack_chunk) + 10647 (num_gap_blocks + num_nr_gap_blocks) * sizeof(struct sctp_gap_ack_block) + 10648 num_dups * sizeof(int32_t); 10649 SCTP_BUF_LEN(a_chk->data) = a_chk->send_size; 10650 nr_sack->nr_sack.cum_tsn_ack = htonl(asoc->cumulative_tsn); 10651 nr_sack->nr_sack.a_rwnd = htonl(asoc->my_rwnd); 10652 nr_sack->nr_sack.num_gap_ack_blks = htons(num_gap_blocks); 10653 nr_sack->nr_sack.num_nr_gap_ack_blks = htons(num_nr_gap_blocks); 10654 nr_sack->nr_sack.num_dup_tsns = htons(num_dups); 10655 nr_sack->nr_sack.reserved = 0; 10656 nr_sack->ch.chunk_type = type; 10657 nr_sack->ch.chunk_flags = flags; 10658 nr_sack->ch.chunk_length = htons(a_chk->send_size); 10659 } 10660 TAILQ_INSERT_TAIL(&asoc->control_send_queue, a_chk, sctp_next); 10661 asoc->my_last_reported_rwnd = asoc->my_rwnd; 10662 asoc->ctrl_queue_cnt++; 10663 asoc->send_sack = 0; 10664 SCTP_STAT_INCR(sctps_sendsacks); 10665 return; 10666 } 10667 10668 void 10669 sctp_send_abort_tcb(struct sctp_tcb *stcb, struct mbuf *operr, int so_locked 10670 #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING) 10671 SCTP_UNUSED 10672 #endif 10673 ) 10674 { 10675 struct mbuf *m_abort, *m, *m_last; 10676 struct mbuf *m_out, *m_end = NULL; 10677 struct sctp_abort_chunk *abort; 10678 struct sctp_auth_chunk *auth = NULL; 10679 struct sctp_nets *net; 10680 uint32_t vtag; 10681 uint32_t auth_offset = 0; 10682 uint16_t cause_len, chunk_len, padding_len; 10683 10684 SCTP_TCB_LOCK_ASSERT(stcb); 10685 /*- 10686 * Add an AUTH chunk, if chunk requires it and save the offset into 10687 * the chain for AUTH 10688 */ 10689 if (sctp_auth_is_required_chunk(SCTP_ABORT_ASSOCIATION, 10690 stcb->asoc.peer_auth_chunks)) { 10691 m_out = sctp_add_auth_chunk(NULL, &m_end, &auth, &auth_offset, 10692 stcb, SCTP_ABORT_ASSOCIATION); 10693 SCTP_STAT_INCR_COUNTER64(sctps_outcontrolchunks); 10694 } else { 10695 m_out = NULL; 10696 } 10697 m_abort = sctp_get_mbuf_for_msg(sizeof(struct sctp_abort_chunk), 0, M_DONTWAIT, 1, MT_HEADER); 10698 if (m_abort == NULL) { 10699 if (m_out) { 10700 sctp_m_freem(m_out); 10701 } 10702 if (operr) { 10703 sctp_m_freem(operr); 10704 } 10705 return; 10706 } 10707 /* link in any error */ 10708 SCTP_BUF_NEXT(m_abort) = operr; 10709 cause_len = 0; 10710 m_last = NULL; 10711 for (m = operr; m; m = SCTP_BUF_NEXT(m)) { 10712 cause_len += (uint16_t) SCTP_BUF_LEN(m); 10713 if (SCTP_BUF_NEXT(m) == NULL) { 10714 m_last = m; 10715 } 10716 } 10717 SCTP_BUF_LEN(m_abort) = sizeof(struct sctp_abort_chunk); 10718 chunk_len = (uint16_t) sizeof(struct sctp_abort_chunk) + cause_len; 10719 padding_len = SCTP_SIZE32(chunk_len) - chunk_len; 10720 if (m_out == NULL) { 10721 /* NO Auth chunk prepended, so reserve space in front */ 10722 SCTP_BUF_RESV_UF(m_abort, SCTP_MIN_OVERHEAD); 10723 m_out = m_abort; 10724 } else { 10725 /* Put AUTH chunk at the front of the chain */ 10726 SCTP_BUF_NEXT(m_end) = m_abort; 10727 } 10728 if (stcb->asoc.alternate) { 10729 net = stcb->asoc.alternate; 10730 } else { 10731 net = stcb->asoc.primary_destination; 10732 } 10733 /* Fill in the ABORT chunk header. */ 10734 abort = mtod(m_abort, struct sctp_abort_chunk *); 10735 abort->ch.chunk_type = SCTP_ABORT_ASSOCIATION; 10736 if (stcb->asoc.peer_vtag == 0) { 10737 /* This happens iff the assoc is in COOKIE-WAIT state. */ 10738 vtag = stcb->asoc.my_vtag; 10739 abort->ch.chunk_flags = SCTP_HAD_NO_TCB; 10740 } else { 10741 vtag = stcb->asoc.peer_vtag; 10742 abort->ch.chunk_flags = 0; 10743 } 10744 abort->ch.chunk_length = htons(chunk_len); 10745 /* Add padding, if necessary. */ 10746 if (padding_len > 0) { 10747 if ((m_last == NULL) || sctp_add_pad_tombuf(m_last, padding_len)) { 10748 sctp_m_freem(m_out); 10749 return; 10750 } 10751 } 10752 (void)sctp_lowlevel_chunk_output(stcb->sctp_ep, stcb, net, 10753 (struct sockaddr *)&net->ro._l_addr, 10754 m_out, auth_offset, auth, stcb->asoc.authinfo.active_keyid, 1, 0, 0, 10755 stcb->sctp_ep->sctp_lport, stcb->rport, htonl(vtag), 10756 stcb->asoc.primary_destination->port, NULL, 10757 0, 0, 10758 so_locked); 10759 SCTP_STAT_INCR_COUNTER64(sctps_outcontrolchunks); 10760 } 10761 10762 void 10763 sctp_send_shutdown_complete(struct sctp_tcb *stcb, 10764 struct sctp_nets *net, 10765 int reflect_vtag) 10766 { 10767 /* formulate and SEND a SHUTDOWN-COMPLETE */ 10768 struct mbuf *m_shutdown_comp; 10769 struct sctp_shutdown_complete_chunk *shutdown_complete; 10770 uint32_t vtag; 10771 uint8_t flags; 10772 10773 m_shutdown_comp = sctp_get_mbuf_for_msg(sizeof(struct sctp_chunkhdr), 0, M_DONTWAIT, 1, MT_HEADER); 10774 if (m_shutdown_comp == NULL) { 10775 /* no mbuf's */ 10776 return; 10777 } 10778 if (reflect_vtag) { 10779 flags = SCTP_HAD_NO_TCB; 10780 vtag = stcb->asoc.my_vtag; 10781 } else { 10782 flags = 0; 10783 vtag = stcb->asoc.peer_vtag; 10784 } 10785 shutdown_complete = mtod(m_shutdown_comp, struct sctp_shutdown_complete_chunk *); 10786 shutdown_complete->ch.chunk_type = SCTP_SHUTDOWN_COMPLETE; 10787 shutdown_complete->ch.chunk_flags = flags; 10788 shutdown_complete->ch.chunk_length = htons(sizeof(struct sctp_shutdown_complete_chunk)); 10789 SCTP_BUF_LEN(m_shutdown_comp) = sizeof(struct sctp_shutdown_complete_chunk); 10790 (void)sctp_lowlevel_chunk_output(stcb->sctp_ep, stcb, net, 10791 (struct sockaddr *)&net->ro._l_addr, 10792 m_shutdown_comp, 0, NULL, 0, 1, 0, 0, 10793 stcb->sctp_ep->sctp_lport, stcb->rport, 10794 htonl(vtag), 10795 net->port, NULL, 10796 0, 0, 10797 SCTP_SO_NOT_LOCKED); 10798 SCTP_STAT_INCR_COUNTER64(sctps_outcontrolchunks); 10799 return; 10800 } 10801 10802 static void 10803 sctp_send_resp_msg(struct sockaddr *src, struct sockaddr *dst, 10804 struct sctphdr *sh, uint32_t vtag, 10805 uint8_t type, struct mbuf *cause, 10806 uint8_t use_mflowid, uint32_t mflowid, 10807 uint32_t vrf_id, uint16_t port) 10808 { 10809 struct mbuf *o_pak; 10810 struct mbuf *mout; 10811 struct sctphdr *shout; 10812 struct sctp_chunkhdr *ch; 10813 struct udphdr *udp; 10814 int len, cause_len, padding_len, ret; 10815 10816 #ifdef INET 10817 struct sockaddr_in *src_sin, *dst_sin; 10818 struct ip *ip; 10819 10820 #endif 10821 #ifdef INET6 10822 struct sockaddr_in6 *src_sin6, *dst_sin6; 10823 struct ip6_hdr *ip6; 10824 10825 #endif 10826 10827 /* Compute the length of the cause and add final padding. */ 10828 cause_len = 0; 10829 if (cause != NULL) { 10830 struct mbuf *m_at, *m_last = NULL; 10831 10832 for (m_at = cause; m_at; m_at = SCTP_BUF_NEXT(m_at)) { 10833 if (SCTP_BUF_NEXT(m_at) == NULL) 10834 m_last = m_at; 10835 cause_len += SCTP_BUF_LEN(m_at); 10836 } 10837 padding_len = cause_len % 4; 10838 if (padding_len != 0) { 10839 padding_len = 4 - padding_len; 10840 } 10841 if (padding_len != 0) { 10842 if (sctp_add_pad_tombuf(m_last, padding_len)) { 10843 sctp_m_freem(cause); 10844 return; 10845 } 10846 } 10847 } else { 10848 padding_len = 0; 10849 } 10850 /* Get an mbuf for the header. */ 10851 len = sizeof(struct sctphdr) + sizeof(struct sctp_chunkhdr); 10852 switch (dst->sa_family) { 10853 #ifdef INET 10854 case AF_INET: 10855 len += sizeof(struct ip); 10856 break; 10857 #endif 10858 #ifdef INET6 10859 case AF_INET6: 10860 len += sizeof(struct ip6_hdr); 10861 break; 10862 #endif 10863 default: 10864 break; 10865 } 10866 if (port) { 10867 len += sizeof(struct udphdr); 10868 } 10869 mout = sctp_get_mbuf_for_msg(len + max_linkhdr, 1, M_DONTWAIT, 1, MT_DATA); 10870 if (mout == NULL) { 10871 if (cause) { 10872 sctp_m_freem(cause); 10873 } 10874 return; 10875 } 10876 SCTP_BUF_RESV_UF(mout, max_linkhdr); 10877 SCTP_BUF_LEN(mout) = len; 10878 SCTP_BUF_NEXT(mout) = cause; 10879 if (use_mflowid != 0) { 10880 mout->m_pkthdr.flowid = mflowid; 10881 mout->m_flags |= M_FLOWID; 10882 } 10883 #ifdef INET 10884 ip = NULL; 10885 #endif 10886 #ifdef INET6 10887 ip6 = NULL; 10888 #endif 10889 switch (dst->sa_family) { 10890 #ifdef INET 10891 case AF_INET: 10892 src_sin = (struct sockaddr_in *)src; 10893 dst_sin = (struct sockaddr_in *)dst; 10894 ip = mtod(mout, struct ip *); 10895 ip->ip_v = IPVERSION; 10896 ip->ip_hl = (sizeof(struct ip) >> 2); 10897 ip->ip_tos = 0; 10898 ip->ip_id = ip_newid(); 10899 ip->ip_off = 0; 10900 ip->ip_ttl = MODULE_GLOBAL(ip_defttl); 10901 if (port) { 10902 ip->ip_p = IPPROTO_UDP; 10903 } else { 10904 ip->ip_p = IPPROTO_SCTP; 10905 } 10906 ip->ip_src.s_addr = dst_sin->sin_addr.s_addr; 10907 ip->ip_dst.s_addr = src_sin->sin_addr.s_addr; 10908 ip->ip_sum = 0; 10909 len = sizeof(struct ip); 10910 shout = (struct sctphdr *)((caddr_t)ip + len); 10911 break; 10912 #endif 10913 #ifdef INET6 10914 case AF_INET6: 10915 src_sin6 = (struct sockaddr_in6 *)src; 10916 dst_sin6 = (struct sockaddr_in6 *)dst; 10917 ip6 = mtod(mout, struct ip6_hdr *); 10918 ip6->ip6_flow = htonl(0x60000000); 10919 if (V_ip6_auto_flowlabel) { 10920 ip6->ip6_flow |= (htonl(ip6_randomflowlabel()) & IPV6_FLOWLABEL_MASK); 10921 } 10922 ip6->ip6_hlim = MODULE_GLOBAL(ip6_defhlim); 10923 if (port) { 10924 ip6->ip6_nxt = IPPROTO_UDP; 10925 } else { 10926 ip6->ip6_nxt = IPPROTO_SCTP; 10927 } 10928 ip6->ip6_src = dst_sin6->sin6_addr; 10929 ip6->ip6_dst = src_sin6->sin6_addr; 10930 len = sizeof(struct ip6_hdr); 10931 shout = (struct sctphdr *)((caddr_t)ip6 + len); 10932 break; 10933 #endif 10934 default: 10935 len = 0; 10936 shout = mtod(mout, struct sctphdr *); 10937 break; 10938 } 10939 if (port) { 10940 if (htons(SCTP_BASE_SYSCTL(sctp_udp_tunneling_port)) == 0) { 10941 sctp_m_freem(mout); 10942 return; 10943 } 10944 udp = (struct udphdr *)shout; 10945 udp->uh_sport = htons(SCTP_BASE_SYSCTL(sctp_udp_tunneling_port)); 10946 udp->uh_dport = port; 10947 udp->uh_sum = 0; 10948 udp->uh_ulen = htons(sizeof(struct udphdr) + 10949 sizeof(struct sctphdr) + 10950 sizeof(struct sctp_chunkhdr) + 10951 cause_len + padding_len); 10952 len += sizeof(struct udphdr); 10953 shout = (struct sctphdr *)((caddr_t)shout + sizeof(struct udphdr)); 10954 } else { 10955 udp = NULL; 10956 } 10957 shout->src_port = sh->dest_port; 10958 shout->dest_port = sh->src_port; 10959 shout->checksum = 0; 10960 if (vtag) { 10961 shout->v_tag = htonl(vtag); 10962 } else { 10963 shout->v_tag = sh->v_tag; 10964 } 10965 len += sizeof(struct sctphdr); 10966 ch = (struct sctp_chunkhdr *)((caddr_t)shout + sizeof(struct sctphdr)); 10967 ch->chunk_type = type; 10968 if (vtag) { 10969 ch->chunk_flags = 0; 10970 } else { 10971 ch->chunk_flags = SCTP_HAD_NO_TCB; 10972 } 10973 ch->chunk_length = htons(sizeof(struct sctp_chunkhdr) + cause_len); 10974 len += sizeof(struct sctp_chunkhdr); 10975 len += cause_len + padding_len; 10976 10977 if (SCTP_GET_HEADER_FOR_OUTPUT(o_pak)) { 10978 sctp_m_freem(mout); 10979 return; 10980 } 10981 SCTP_ATTACH_CHAIN(o_pak, mout, len); 10982 switch (dst->sa_family) { 10983 #ifdef INET 10984 case AF_INET: 10985 if (port) { 10986 if (V_udp_cksum) { 10987 udp->uh_sum = in_pseudo(ip->ip_src.s_addr, ip->ip_dst.s_addr, udp->uh_ulen + htons(IPPROTO_UDP)); 10988 } else { 10989 udp->uh_sum = 0; 10990 } 10991 } 10992 ip->ip_len = len; 10993 if (port) { 10994 #if defined(SCTP_WITH_NO_CSUM) 10995 SCTP_STAT_INCR(sctps_sendnocrc); 10996 #else 10997 shout->checksum = sctp_calculate_cksum(mout, sizeof(struct ip) + sizeof(struct udphdr)); 10998 SCTP_STAT_INCR(sctps_sendswcrc); 10999 #endif 11000 if (V_udp_cksum) { 11001 SCTP_ENABLE_UDP_CSUM(o_pak); 11002 } 11003 } else { 11004 #if defined(SCTP_WITH_NO_CSUM) 11005 SCTP_STAT_INCR(sctps_sendnocrc); 11006 #else 11007 mout->m_pkthdr.csum_flags = CSUM_SCTP; 11008 mout->m_pkthdr.csum_data = 0; 11009 SCTP_STAT_INCR(sctps_sendhwcrc); 11010 #endif 11011 } 11012 #ifdef SCTP_PACKET_LOGGING 11013 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_LAST_PACKET_TRACING) { 11014 sctp_packet_log(o_pak); 11015 } 11016 #endif 11017 SCTP_IP_OUTPUT(ret, o_pak, NULL, NULL, vrf_id); 11018 break; 11019 #endif 11020 #ifdef INET6 11021 case AF_INET6: 11022 ip6->ip6_plen = len - sizeof(struct ip6_hdr); 11023 if (port) { 11024 #if defined(SCTP_WITH_NO_CSUM) 11025 SCTP_STAT_INCR(sctps_sendnocrc); 11026 #else 11027 shout->checksum = sctp_calculate_cksum(mout, sizeof(struct ip6_hdr) + sizeof(struct udphdr)); 11028 SCTP_STAT_INCR(sctps_sendswcrc); 11029 #endif 11030 if ((udp->uh_sum = in6_cksum(o_pak, IPPROTO_UDP, sizeof(struct ip6_hdr), len - sizeof(struct ip6_hdr))) == 0) { 11031 udp->uh_sum = 0xffff; 11032 } 11033 } else { 11034 #if defined(SCTP_WITH_NO_CSUM) 11035 SCTP_STAT_INCR(sctps_sendnocrc); 11036 #else 11037 mout->m_pkthdr.csum_flags = CSUM_SCTP_IPV6; 11038 mout->m_pkthdr.csum_data = 0; 11039 SCTP_STAT_INCR(sctps_sendhwcrc); 11040 #endif 11041 } 11042 #ifdef SCTP_PACKET_LOGGING 11043 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_LAST_PACKET_TRACING) { 11044 sctp_packet_log(o_pak); 11045 } 11046 #endif 11047 SCTP_IP6_OUTPUT(ret, o_pak, NULL, NULL, NULL, vrf_id); 11048 break; 11049 #endif 11050 default: 11051 SCTPDBG(SCTP_DEBUG_OUTPUT1, "Unknown protocol (TSNH) type %d\n", 11052 dst->sa_family); 11053 sctp_m_freem(mout); 11054 SCTP_LTRACE_ERR_RET_PKT(mout, NULL, NULL, NULL, SCTP_FROM_SCTP_OUTPUT, EFAULT); 11055 return; 11056 } 11057 SCTP_STAT_INCR(sctps_sendpackets); 11058 SCTP_STAT_INCR_COUNTER64(sctps_outpackets); 11059 SCTP_STAT_INCR_COUNTER64(sctps_outcontrolchunks); 11060 return; 11061 } 11062 11063 void 11064 sctp_send_shutdown_complete2(struct sockaddr *src, struct sockaddr *dst, 11065 struct sctphdr *sh, 11066 uint8_t use_mflowid, uint32_t mflowid, 11067 uint32_t vrf_id, uint16_t port) 11068 { 11069 sctp_send_resp_msg(src, dst, sh, 0, SCTP_SHUTDOWN_COMPLETE, NULL, 11070 use_mflowid, mflowid, 11071 vrf_id, port); 11072 } 11073 11074 void 11075 sctp_send_hb(struct sctp_tcb *stcb, struct sctp_nets *net, int so_locked 11076 #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING) 11077 SCTP_UNUSED 11078 #endif 11079 ) 11080 { 11081 struct sctp_tmit_chunk *chk; 11082 struct sctp_heartbeat_chunk *hb; 11083 struct timeval now; 11084 11085 SCTP_TCB_LOCK_ASSERT(stcb); 11086 if (net == NULL) { 11087 return; 11088 } 11089 (void)SCTP_GETTIME_TIMEVAL(&now); 11090 switch (net->ro._l_addr.sa.sa_family) { 11091 #ifdef INET 11092 case AF_INET: 11093 break; 11094 #endif 11095 #ifdef INET6 11096 case AF_INET6: 11097 break; 11098 #endif 11099 default: 11100 return; 11101 } 11102 sctp_alloc_a_chunk(stcb, chk); 11103 if (chk == NULL) { 11104 SCTPDBG(SCTP_DEBUG_OUTPUT4, "Gak, can't get a chunk for hb\n"); 11105 return; 11106 } 11107 chk->copy_by_ref = 0; 11108 chk->rec.chunk_id.id = SCTP_HEARTBEAT_REQUEST; 11109 chk->rec.chunk_id.can_take_data = 1; 11110 chk->asoc = &stcb->asoc; 11111 chk->send_size = sizeof(struct sctp_heartbeat_chunk); 11112 11113 chk->data = sctp_get_mbuf_for_msg(chk->send_size, 0, M_DONTWAIT, 1, MT_HEADER); 11114 if (chk->data == NULL) { 11115 sctp_free_a_chunk(stcb, chk, so_locked); 11116 return; 11117 } 11118 SCTP_BUF_RESV_UF(chk->data, SCTP_MIN_OVERHEAD); 11119 SCTP_BUF_LEN(chk->data) = chk->send_size; 11120 chk->sent = SCTP_DATAGRAM_UNSENT; 11121 chk->snd_count = 0; 11122 chk->whoTo = net; 11123 atomic_add_int(&chk->whoTo->ref_count, 1); 11124 /* Now we have a mbuf that we can fill in with the details */ 11125 hb = mtod(chk->data, struct sctp_heartbeat_chunk *); 11126 memset(hb, 0, sizeof(struct sctp_heartbeat_chunk)); 11127 /* fill out chunk header */ 11128 hb->ch.chunk_type = SCTP_HEARTBEAT_REQUEST; 11129 hb->ch.chunk_flags = 0; 11130 hb->ch.chunk_length = htons(chk->send_size); 11131 /* Fill out hb parameter */ 11132 hb->heartbeat.hb_info.ph.param_type = htons(SCTP_HEARTBEAT_INFO); 11133 hb->heartbeat.hb_info.ph.param_length = htons(sizeof(struct sctp_heartbeat_info_param)); 11134 hb->heartbeat.hb_info.time_value_1 = now.tv_sec; 11135 hb->heartbeat.hb_info.time_value_2 = now.tv_usec; 11136 /* Did our user request this one, put it in */ 11137 hb->heartbeat.hb_info.addr_family = net->ro._l_addr.sa.sa_family; 11138 hb->heartbeat.hb_info.addr_len = net->ro._l_addr.sa.sa_len; 11139 if (net->dest_state & SCTP_ADDR_UNCONFIRMED) { 11140 /* 11141 * we only take from the entropy pool if the address is not 11142 * confirmed. 11143 */ 11144 net->heartbeat_random1 = hb->heartbeat.hb_info.random_value1 = sctp_select_initial_TSN(&stcb->sctp_ep->sctp_ep); 11145 net->heartbeat_random2 = hb->heartbeat.hb_info.random_value2 = sctp_select_initial_TSN(&stcb->sctp_ep->sctp_ep); 11146 } else { 11147 net->heartbeat_random1 = hb->heartbeat.hb_info.random_value1 = 0; 11148 net->heartbeat_random2 = hb->heartbeat.hb_info.random_value2 = 0; 11149 } 11150 switch (net->ro._l_addr.sa.sa_family) { 11151 #ifdef INET 11152 case AF_INET: 11153 memcpy(hb->heartbeat.hb_info.address, 11154 &net->ro._l_addr.sin.sin_addr, 11155 sizeof(net->ro._l_addr.sin.sin_addr)); 11156 break; 11157 #endif 11158 #ifdef INET6 11159 case AF_INET6: 11160 memcpy(hb->heartbeat.hb_info.address, 11161 &net->ro._l_addr.sin6.sin6_addr, 11162 sizeof(net->ro._l_addr.sin6.sin6_addr)); 11163 break; 11164 #endif 11165 default: 11166 return; 11167 break; 11168 } 11169 net->hb_responded = 0; 11170 TAILQ_INSERT_TAIL(&stcb->asoc.control_send_queue, chk, sctp_next); 11171 stcb->asoc.ctrl_queue_cnt++; 11172 SCTP_STAT_INCR(sctps_sendheartbeat); 11173 return; 11174 } 11175 11176 void 11177 sctp_send_ecn_echo(struct sctp_tcb *stcb, struct sctp_nets *net, 11178 uint32_t high_tsn) 11179 { 11180 struct sctp_association *asoc; 11181 struct sctp_ecne_chunk *ecne; 11182 struct sctp_tmit_chunk *chk; 11183 11184 if (net == NULL) { 11185 return; 11186 } 11187 asoc = &stcb->asoc; 11188 SCTP_TCB_LOCK_ASSERT(stcb); 11189 TAILQ_FOREACH(chk, &asoc->control_send_queue, sctp_next) { 11190 if ((chk->rec.chunk_id.id == SCTP_ECN_ECHO) && (net == chk->whoTo)) { 11191 /* found a previous ECN_ECHO update it if needed */ 11192 uint32_t cnt, ctsn; 11193 11194 ecne = mtod(chk->data, struct sctp_ecne_chunk *); 11195 ctsn = ntohl(ecne->tsn); 11196 if (SCTP_TSN_GT(high_tsn, ctsn)) { 11197 ecne->tsn = htonl(high_tsn); 11198 SCTP_STAT_INCR(sctps_queue_upd_ecne); 11199 } 11200 cnt = ntohl(ecne->num_pkts_since_cwr); 11201 cnt++; 11202 ecne->num_pkts_since_cwr = htonl(cnt); 11203 return; 11204 } 11205 } 11206 /* nope could not find one to update so we must build one */ 11207 sctp_alloc_a_chunk(stcb, chk); 11208 if (chk == NULL) { 11209 return; 11210 } 11211 chk->copy_by_ref = 0; 11212 SCTP_STAT_INCR(sctps_queue_upd_ecne); 11213 chk->rec.chunk_id.id = SCTP_ECN_ECHO; 11214 chk->rec.chunk_id.can_take_data = 0; 11215 chk->asoc = &stcb->asoc; 11216 chk->send_size = sizeof(struct sctp_ecne_chunk); 11217 chk->data = sctp_get_mbuf_for_msg(chk->send_size, 0, M_DONTWAIT, 1, MT_HEADER); 11218 if (chk->data == NULL) { 11219 sctp_free_a_chunk(stcb, chk, SCTP_SO_NOT_LOCKED); 11220 return; 11221 } 11222 SCTP_BUF_RESV_UF(chk->data, SCTP_MIN_OVERHEAD); 11223 SCTP_BUF_LEN(chk->data) = chk->send_size; 11224 chk->sent = SCTP_DATAGRAM_UNSENT; 11225 chk->snd_count = 0; 11226 chk->whoTo = net; 11227 atomic_add_int(&chk->whoTo->ref_count, 1); 11228 11229 stcb->asoc.ecn_echo_cnt_onq++; 11230 ecne = mtod(chk->data, struct sctp_ecne_chunk *); 11231 ecne->ch.chunk_type = SCTP_ECN_ECHO; 11232 ecne->ch.chunk_flags = 0; 11233 ecne->ch.chunk_length = htons(sizeof(struct sctp_ecne_chunk)); 11234 ecne->tsn = htonl(high_tsn); 11235 ecne->num_pkts_since_cwr = htonl(1); 11236 TAILQ_INSERT_HEAD(&stcb->asoc.control_send_queue, chk, sctp_next); 11237 asoc->ctrl_queue_cnt++; 11238 } 11239 11240 void 11241 sctp_send_packet_dropped(struct sctp_tcb *stcb, struct sctp_nets *net, 11242 struct mbuf *m, int len, int iphlen, int bad_crc) 11243 { 11244 struct sctp_association *asoc; 11245 struct sctp_pktdrop_chunk *drp; 11246 struct sctp_tmit_chunk *chk; 11247 uint8_t *datap; 11248 int was_trunc = 0; 11249 int fullsz = 0; 11250 long spc; 11251 int offset; 11252 struct sctp_chunkhdr *ch, chunk_buf; 11253 unsigned int chk_length; 11254 11255 if (!stcb) { 11256 return; 11257 } 11258 asoc = &stcb->asoc; 11259 SCTP_TCB_LOCK_ASSERT(stcb); 11260 if (asoc->peer_supports_pktdrop == 0) { 11261 /*- 11262 * peer must declare support before I send one. 11263 */ 11264 return; 11265 } 11266 if (stcb->sctp_socket == NULL) { 11267 return; 11268 } 11269 sctp_alloc_a_chunk(stcb, chk); 11270 if (chk == NULL) { 11271 return; 11272 } 11273 chk->copy_by_ref = 0; 11274 len -= iphlen; 11275 chk->send_size = len; 11276 /* Validate that we do not have an ABORT in here. */ 11277 offset = iphlen + sizeof(struct sctphdr); 11278 ch = (struct sctp_chunkhdr *)sctp_m_getptr(m, offset, 11279 sizeof(*ch), (uint8_t *) & chunk_buf); 11280 while (ch != NULL) { 11281 chk_length = ntohs(ch->chunk_length); 11282 if (chk_length < sizeof(*ch)) { 11283 /* break to abort land */ 11284 break; 11285 } 11286 switch (ch->chunk_type) { 11287 case SCTP_PACKET_DROPPED: 11288 case SCTP_ABORT_ASSOCIATION: 11289 case SCTP_INITIATION_ACK: 11290 /** 11291 * We don't respond with an PKT-DROP to an ABORT 11292 * or PKT-DROP. We also do not respond to an 11293 * INIT-ACK, because we can't know if the initiation 11294 * tag is correct or not. 11295 */ 11296 sctp_free_a_chunk(stcb, chk, SCTP_SO_NOT_LOCKED); 11297 return; 11298 default: 11299 break; 11300 } 11301 offset += SCTP_SIZE32(chk_length); 11302 ch = (struct sctp_chunkhdr *)sctp_m_getptr(m, offset, 11303 sizeof(*ch), (uint8_t *) & chunk_buf); 11304 } 11305 11306 if ((len + SCTP_MAX_OVERHEAD + sizeof(struct sctp_pktdrop_chunk)) > 11307 min(stcb->asoc.smallest_mtu, MCLBYTES)) { 11308 /* 11309 * only send 1 mtu worth, trim off the excess on the end. 11310 */ 11311 fullsz = len; 11312 len = min(stcb->asoc.smallest_mtu, MCLBYTES) - SCTP_MAX_OVERHEAD; 11313 was_trunc = 1; 11314 } 11315 chk->asoc = &stcb->asoc; 11316 chk->data = sctp_get_mbuf_for_msg(MCLBYTES, 0, M_DONTWAIT, 1, MT_DATA); 11317 if (chk->data == NULL) { 11318 jump_out: 11319 sctp_free_a_chunk(stcb, chk, SCTP_SO_NOT_LOCKED); 11320 return; 11321 } 11322 SCTP_BUF_RESV_UF(chk->data, SCTP_MIN_OVERHEAD); 11323 drp = mtod(chk->data, struct sctp_pktdrop_chunk *); 11324 if (drp == NULL) { 11325 sctp_m_freem(chk->data); 11326 chk->data = NULL; 11327 goto jump_out; 11328 } 11329 chk->book_size = SCTP_SIZE32((chk->send_size + sizeof(struct sctp_pktdrop_chunk) + 11330 sizeof(struct sctphdr) + SCTP_MED_OVERHEAD)); 11331 chk->book_size_scale = 0; 11332 if (was_trunc) { 11333 drp->ch.chunk_flags = SCTP_PACKET_TRUNCATED; 11334 drp->trunc_len = htons(fullsz); 11335 /* 11336 * Len is already adjusted to size minus overhead above take 11337 * out the pkt_drop chunk itself from it. 11338 */ 11339 chk->send_size = len - sizeof(struct sctp_pktdrop_chunk); 11340 len = chk->send_size; 11341 } else { 11342 /* no truncation needed */ 11343 drp->ch.chunk_flags = 0; 11344 drp->trunc_len = htons(0); 11345 } 11346 if (bad_crc) { 11347 drp->ch.chunk_flags |= SCTP_BADCRC; 11348 } 11349 chk->send_size += sizeof(struct sctp_pktdrop_chunk); 11350 SCTP_BUF_LEN(chk->data) = chk->send_size; 11351 chk->sent = SCTP_DATAGRAM_UNSENT; 11352 chk->snd_count = 0; 11353 if (net) { 11354 /* we should hit here */ 11355 chk->whoTo = net; 11356 atomic_add_int(&chk->whoTo->ref_count, 1); 11357 } else { 11358 chk->whoTo = NULL; 11359 } 11360 chk->rec.chunk_id.id = SCTP_PACKET_DROPPED; 11361 chk->rec.chunk_id.can_take_data = 1; 11362 drp->ch.chunk_type = SCTP_PACKET_DROPPED; 11363 drp->ch.chunk_length = htons(chk->send_size); 11364 spc = SCTP_SB_LIMIT_RCV(stcb->sctp_socket); 11365 if (spc < 0) { 11366 spc = 0; 11367 } 11368 drp->bottle_bw = htonl(spc); 11369 if (asoc->my_rwnd) { 11370 drp->current_onq = htonl(asoc->size_on_reasm_queue + 11371 asoc->size_on_all_streams + 11372 asoc->my_rwnd_control_len + 11373 stcb->sctp_socket->so_rcv.sb_cc); 11374 } else { 11375 /*- 11376 * If my rwnd is 0, possibly from mbuf depletion as well as 11377 * space used, tell the peer there is NO space aka onq == bw 11378 */ 11379 drp->current_onq = htonl(spc); 11380 } 11381 drp->reserved = 0; 11382 datap = drp->data; 11383 m_copydata(m, iphlen, len, (caddr_t)datap); 11384 TAILQ_INSERT_TAIL(&stcb->asoc.control_send_queue, chk, sctp_next); 11385 asoc->ctrl_queue_cnt++; 11386 } 11387 11388 void 11389 sctp_send_cwr(struct sctp_tcb *stcb, struct sctp_nets *net, uint32_t high_tsn, uint8_t override) 11390 { 11391 struct sctp_association *asoc; 11392 struct sctp_cwr_chunk *cwr; 11393 struct sctp_tmit_chunk *chk; 11394 11395 SCTP_TCB_LOCK_ASSERT(stcb); 11396 if (net == NULL) { 11397 return; 11398 } 11399 asoc = &stcb->asoc; 11400 TAILQ_FOREACH(chk, &asoc->control_send_queue, sctp_next) { 11401 if ((chk->rec.chunk_id.id == SCTP_ECN_CWR) && (net == chk->whoTo)) { 11402 /* 11403 * found a previous CWR queued to same destination 11404 * update it if needed 11405 */ 11406 uint32_t ctsn; 11407 11408 cwr = mtod(chk->data, struct sctp_cwr_chunk *); 11409 ctsn = ntohl(cwr->tsn); 11410 if (SCTP_TSN_GT(high_tsn, ctsn)) { 11411 cwr->tsn = htonl(high_tsn); 11412 } 11413 if (override & SCTP_CWR_REDUCE_OVERRIDE) { 11414 /* Make sure override is carried */ 11415 cwr->ch.chunk_flags |= SCTP_CWR_REDUCE_OVERRIDE; 11416 } 11417 return; 11418 } 11419 } 11420 sctp_alloc_a_chunk(stcb, chk); 11421 if (chk == NULL) { 11422 return; 11423 } 11424 chk->copy_by_ref = 0; 11425 chk->rec.chunk_id.id = SCTP_ECN_CWR; 11426 chk->rec.chunk_id.can_take_data = 1; 11427 chk->asoc = &stcb->asoc; 11428 chk->send_size = sizeof(struct sctp_cwr_chunk); 11429 chk->data = sctp_get_mbuf_for_msg(chk->send_size, 0, M_DONTWAIT, 1, MT_HEADER); 11430 if (chk->data == NULL) { 11431 sctp_free_a_chunk(stcb, chk, SCTP_SO_NOT_LOCKED); 11432 return; 11433 } 11434 SCTP_BUF_RESV_UF(chk->data, SCTP_MIN_OVERHEAD); 11435 SCTP_BUF_LEN(chk->data) = chk->send_size; 11436 chk->sent = SCTP_DATAGRAM_UNSENT; 11437 chk->snd_count = 0; 11438 chk->whoTo = net; 11439 atomic_add_int(&chk->whoTo->ref_count, 1); 11440 cwr = mtod(chk->data, struct sctp_cwr_chunk *); 11441 cwr->ch.chunk_type = SCTP_ECN_CWR; 11442 cwr->ch.chunk_flags = override; 11443 cwr->ch.chunk_length = htons(sizeof(struct sctp_cwr_chunk)); 11444 cwr->tsn = htonl(high_tsn); 11445 TAILQ_INSERT_TAIL(&stcb->asoc.control_send_queue, chk, sctp_next); 11446 asoc->ctrl_queue_cnt++; 11447 } 11448 11449 void 11450 sctp_add_stream_reset_out(struct sctp_tmit_chunk *chk, 11451 int number_entries, uint16_t * list, 11452 uint32_t seq, uint32_t resp_seq, uint32_t last_sent) 11453 { 11454 uint16_t len, old_len, i; 11455 struct sctp_stream_reset_out_request *req_out; 11456 struct sctp_chunkhdr *ch; 11457 11458 ch = mtod(chk->data, struct sctp_chunkhdr *); 11459 old_len = len = SCTP_SIZE32(ntohs(ch->chunk_length)); 11460 11461 /* get to new offset for the param. */ 11462 req_out = (struct sctp_stream_reset_out_request *)((caddr_t)ch + len); 11463 /* now how long will this param be? */ 11464 len = (sizeof(struct sctp_stream_reset_out_request) + (sizeof(uint16_t) * number_entries)); 11465 req_out->ph.param_type = htons(SCTP_STR_RESET_OUT_REQUEST); 11466 req_out->ph.param_length = htons(len); 11467 req_out->request_seq = htonl(seq); 11468 req_out->response_seq = htonl(resp_seq); 11469 req_out->send_reset_at_tsn = htonl(last_sent); 11470 if (number_entries) { 11471 for (i = 0; i < number_entries; i++) { 11472 req_out->list_of_streams[i] = htons(list[i]); 11473 } 11474 } 11475 if (SCTP_SIZE32(len) > len) { 11476 /*- 11477 * Need to worry about the pad we may end up adding to the 11478 * end. This is easy since the struct is either aligned to 4 11479 * bytes or 2 bytes off. 11480 */ 11481 req_out->list_of_streams[number_entries] = 0; 11482 } 11483 /* now fix the chunk length */ 11484 ch->chunk_length = htons(len + old_len); 11485 chk->book_size = len + old_len; 11486 chk->book_size_scale = 0; 11487 chk->send_size = SCTP_SIZE32(chk->book_size); 11488 SCTP_BUF_LEN(chk->data) = chk->send_size; 11489 return; 11490 } 11491 11492 static void 11493 sctp_add_stream_reset_in(struct sctp_tmit_chunk *chk, 11494 int number_entries, uint16_t * list, 11495 uint32_t seq) 11496 { 11497 uint16_t len, old_len, i; 11498 struct sctp_stream_reset_in_request *req_in; 11499 struct sctp_chunkhdr *ch; 11500 11501 ch = mtod(chk->data, struct sctp_chunkhdr *); 11502 old_len = len = SCTP_SIZE32(ntohs(ch->chunk_length)); 11503 11504 /* get to new offset for the param. */ 11505 req_in = (struct sctp_stream_reset_in_request *)((caddr_t)ch + len); 11506 /* now how long will this param be? */ 11507 len = (sizeof(struct sctp_stream_reset_in_request) + (sizeof(uint16_t) * number_entries)); 11508 req_in->ph.param_type = htons(SCTP_STR_RESET_IN_REQUEST); 11509 req_in->ph.param_length = htons(len); 11510 req_in->request_seq = htonl(seq); 11511 if (number_entries) { 11512 for (i = 0; i < number_entries; i++) { 11513 req_in->list_of_streams[i] = htons(list[i]); 11514 } 11515 } 11516 if (SCTP_SIZE32(len) > len) { 11517 /*- 11518 * Need to worry about the pad we may end up adding to the 11519 * end. This is easy since the struct is either aligned to 4 11520 * bytes or 2 bytes off. 11521 */ 11522 req_in->list_of_streams[number_entries] = 0; 11523 } 11524 /* now fix the chunk length */ 11525 ch->chunk_length = htons(len + old_len); 11526 chk->book_size = len + old_len; 11527 chk->book_size_scale = 0; 11528 chk->send_size = SCTP_SIZE32(chk->book_size); 11529 SCTP_BUF_LEN(chk->data) = chk->send_size; 11530 return; 11531 } 11532 11533 static void 11534 sctp_add_stream_reset_tsn(struct sctp_tmit_chunk *chk, 11535 uint32_t seq) 11536 { 11537 uint16_t len, old_len; 11538 struct sctp_stream_reset_tsn_request *req_tsn; 11539 struct sctp_chunkhdr *ch; 11540 11541 ch = mtod(chk->data, struct sctp_chunkhdr *); 11542 old_len = len = SCTP_SIZE32(ntohs(ch->chunk_length)); 11543 11544 /* get to new offset for the param. */ 11545 req_tsn = (struct sctp_stream_reset_tsn_request *)((caddr_t)ch + len); 11546 /* now how long will this param be? */ 11547 len = sizeof(struct sctp_stream_reset_tsn_request); 11548 req_tsn->ph.param_type = htons(SCTP_STR_RESET_TSN_REQUEST); 11549 req_tsn->ph.param_length = htons(len); 11550 req_tsn->request_seq = htonl(seq); 11551 11552 /* now fix the chunk length */ 11553 ch->chunk_length = htons(len + old_len); 11554 chk->send_size = len + old_len; 11555 chk->book_size = SCTP_SIZE32(chk->send_size); 11556 chk->book_size_scale = 0; 11557 SCTP_BUF_LEN(chk->data) = SCTP_SIZE32(chk->send_size); 11558 return; 11559 } 11560 11561 void 11562 sctp_add_stream_reset_result(struct sctp_tmit_chunk *chk, 11563 uint32_t resp_seq, uint32_t result) 11564 { 11565 uint16_t len, old_len; 11566 struct sctp_stream_reset_response *resp; 11567 struct sctp_chunkhdr *ch; 11568 11569 ch = mtod(chk->data, struct sctp_chunkhdr *); 11570 old_len = len = SCTP_SIZE32(ntohs(ch->chunk_length)); 11571 11572 /* get to new offset for the param. */ 11573 resp = (struct sctp_stream_reset_response *)((caddr_t)ch + len); 11574 /* now how long will this param be? */ 11575 len = sizeof(struct sctp_stream_reset_response); 11576 resp->ph.param_type = htons(SCTP_STR_RESET_RESPONSE); 11577 resp->ph.param_length = htons(len); 11578 resp->response_seq = htonl(resp_seq); 11579 resp->result = ntohl(result); 11580 11581 /* now fix the chunk length */ 11582 ch->chunk_length = htons(len + old_len); 11583 chk->book_size = len + old_len; 11584 chk->book_size_scale = 0; 11585 chk->send_size = SCTP_SIZE32(chk->book_size); 11586 SCTP_BUF_LEN(chk->data) = chk->send_size; 11587 return; 11588 } 11589 11590 void 11591 sctp_add_stream_reset_result_tsn(struct sctp_tmit_chunk *chk, 11592 uint32_t resp_seq, uint32_t result, 11593 uint32_t send_una, uint32_t recv_next) 11594 { 11595 uint16_t len, old_len; 11596 struct sctp_stream_reset_response_tsn *resp; 11597 struct sctp_chunkhdr *ch; 11598 11599 ch = mtod(chk->data, struct sctp_chunkhdr *); 11600 old_len = len = SCTP_SIZE32(ntohs(ch->chunk_length)); 11601 11602 /* get to new offset for the param. */ 11603 resp = (struct sctp_stream_reset_response_tsn *)((caddr_t)ch + len); 11604 /* now how long will this param be? */ 11605 len = sizeof(struct sctp_stream_reset_response_tsn); 11606 resp->ph.param_type = htons(SCTP_STR_RESET_RESPONSE); 11607 resp->ph.param_length = htons(len); 11608 resp->response_seq = htonl(resp_seq); 11609 resp->result = htonl(result); 11610 resp->senders_next_tsn = htonl(send_una); 11611 resp->receivers_next_tsn = htonl(recv_next); 11612 11613 /* now fix the chunk length */ 11614 ch->chunk_length = htons(len + old_len); 11615 chk->book_size = len + old_len; 11616 chk->send_size = SCTP_SIZE32(chk->book_size); 11617 chk->book_size_scale = 0; 11618 SCTP_BUF_LEN(chk->data) = chk->send_size; 11619 return; 11620 } 11621 11622 static void 11623 sctp_add_an_out_stream(struct sctp_tmit_chunk *chk, 11624 uint32_t seq, 11625 uint16_t adding) 11626 { 11627 uint16_t len, old_len; 11628 struct sctp_chunkhdr *ch; 11629 struct sctp_stream_reset_add_strm *addstr; 11630 11631 ch = mtod(chk->data, struct sctp_chunkhdr *); 11632 old_len = len = SCTP_SIZE32(ntohs(ch->chunk_length)); 11633 11634 /* get to new offset for the param. */ 11635 addstr = (struct sctp_stream_reset_add_strm *)((caddr_t)ch + len); 11636 /* now how long will this param be? */ 11637 len = sizeof(struct sctp_stream_reset_add_strm); 11638 11639 /* Fill it out. */ 11640 addstr->ph.param_type = htons(SCTP_STR_RESET_ADD_OUT_STREAMS); 11641 addstr->ph.param_length = htons(len); 11642 addstr->request_seq = htonl(seq); 11643 addstr->number_of_streams = htons(adding); 11644 addstr->reserved = 0; 11645 11646 /* now fix the chunk length */ 11647 ch->chunk_length = htons(len + old_len); 11648 chk->send_size = len + old_len; 11649 chk->book_size = SCTP_SIZE32(chk->send_size); 11650 chk->book_size_scale = 0; 11651 SCTP_BUF_LEN(chk->data) = SCTP_SIZE32(chk->send_size); 11652 return; 11653 } 11654 11655 static void 11656 sctp_add_an_in_stream(struct sctp_tmit_chunk *chk, 11657 uint32_t seq, 11658 uint16_t adding) 11659 { 11660 uint16_t len, old_len; 11661 struct sctp_chunkhdr *ch; 11662 struct sctp_stream_reset_add_strm *addstr; 11663 11664 ch = mtod(chk->data, struct sctp_chunkhdr *); 11665 old_len = len = SCTP_SIZE32(ntohs(ch->chunk_length)); 11666 11667 /* get to new offset for the param. */ 11668 addstr = (struct sctp_stream_reset_add_strm *)((caddr_t)ch + len); 11669 /* now how long will this param be? */ 11670 len = sizeof(struct sctp_stream_reset_add_strm); 11671 /* Fill it out. */ 11672 addstr->ph.param_type = htons(SCTP_STR_RESET_ADD_IN_STREAMS); 11673 addstr->ph.param_length = htons(len); 11674 addstr->request_seq = htonl(seq); 11675 addstr->number_of_streams = htons(adding); 11676 addstr->reserved = 0; 11677 11678 /* now fix the chunk length */ 11679 ch->chunk_length = htons(len + old_len); 11680 chk->send_size = len + old_len; 11681 chk->book_size = SCTP_SIZE32(chk->send_size); 11682 chk->book_size_scale = 0; 11683 SCTP_BUF_LEN(chk->data) = SCTP_SIZE32(chk->send_size); 11684 return; 11685 } 11686 11687 int 11688 sctp_send_str_reset_req(struct sctp_tcb *stcb, 11689 int number_entries, uint16_t * list, 11690 uint8_t send_out_req, 11691 uint8_t send_in_req, 11692 uint8_t send_tsn_req, 11693 uint8_t add_stream, 11694 uint16_t adding_o, 11695 uint16_t adding_i, uint8_t peer_asked) 11696 { 11697 11698 struct sctp_association *asoc; 11699 struct sctp_tmit_chunk *chk; 11700 struct sctp_chunkhdr *ch; 11701 uint32_t seq; 11702 11703 asoc = &stcb->asoc; 11704 if (asoc->stream_reset_outstanding) { 11705 /*- 11706 * Already one pending, must get ACK back to clear the flag. 11707 */ 11708 SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, EBUSY); 11709 return (EBUSY); 11710 } 11711 if ((send_out_req == 0) && (send_in_req == 0) && (send_tsn_req == 0) && 11712 (add_stream == 0)) { 11713 /* nothing to do */ 11714 SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, EINVAL); 11715 return (EINVAL); 11716 } 11717 if (send_tsn_req && (send_out_req || send_in_req)) { 11718 /* error, can't do that */ 11719 SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, EINVAL); 11720 return (EINVAL); 11721 } 11722 sctp_alloc_a_chunk(stcb, chk); 11723 if (chk == NULL) { 11724 SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, ENOMEM); 11725 return (ENOMEM); 11726 } 11727 chk->copy_by_ref = 0; 11728 chk->rec.chunk_id.id = SCTP_STREAM_RESET; 11729 chk->rec.chunk_id.can_take_data = 0; 11730 chk->asoc = &stcb->asoc; 11731 chk->book_size = sizeof(struct sctp_chunkhdr); 11732 chk->send_size = SCTP_SIZE32(chk->book_size); 11733 chk->book_size_scale = 0; 11734 11735 chk->data = sctp_get_mbuf_for_msg(MCLBYTES, 0, M_DONTWAIT, 1, MT_DATA); 11736 if (chk->data == NULL) { 11737 sctp_free_a_chunk(stcb, chk, SCTP_SO_LOCKED); 11738 SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, ENOMEM); 11739 return (ENOMEM); 11740 } 11741 SCTP_BUF_RESV_UF(chk->data, SCTP_MIN_OVERHEAD); 11742 11743 /* setup chunk parameters */ 11744 chk->sent = SCTP_DATAGRAM_UNSENT; 11745 chk->snd_count = 0; 11746 if (stcb->asoc.alternate) { 11747 chk->whoTo = stcb->asoc.alternate; 11748 } else { 11749 chk->whoTo = stcb->asoc.primary_destination; 11750 } 11751 atomic_add_int(&chk->whoTo->ref_count, 1); 11752 ch = mtod(chk->data, struct sctp_chunkhdr *); 11753 ch->chunk_type = SCTP_STREAM_RESET; 11754 ch->chunk_flags = 0; 11755 ch->chunk_length = htons(chk->book_size); 11756 SCTP_BUF_LEN(chk->data) = chk->send_size; 11757 11758 seq = stcb->asoc.str_reset_seq_out; 11759 if (send_out_req) { 11760 sctp_add_stream_reset_out(chk, number_entries, list, 11761 seq, (stcb->asoc.str_reset_seq_in - 1), (stcb->asoc.sending_seq - 1)); 11762 asoc->stream_reset_out_is_outstanding = 1; 11763 seq++; 11764 asoc->stream_reset_outstanding++; 11765 } 11766 if ((add_stream & 1) && 11767 ((stcb->asoc.strm_realoutsize - stcb->asoc.streamoutcnt) < adding_o)) { 11768 /* Need to allocate more */ 11769 struct sctp_stream_out *oldstream; 11770 struct sctp_stream_queue_pending *sp, *nsp; 11771 int i; 11772 11773 oldstream = stcb->asoc.strmout; 11774 /* get some more */ 11775 SCTP_MALLOC(stcb->asoc.strmout, struct sctp_stream_out *, 11776 ((stcb->asoc.streamoutcnt + adding_o) * sizeof(struct sctp_stream_out)), 11777 SCTP_M_STRMO); 11778 if (stcb->asoc.strmout == NULL) { 11779 uint8_t x; 11780 11781 stcb->asoc.strmout = oldstream; 11782 /* Turn off the bit */ 11783 x = add_stream & 0xfe; 11784 add_stream = x; 11785 goto skip_stuff; 11786 } 11787 /* 11788 * Ok now we proceed with copying the old out stuff and 11789 * initializing the new stuff. 11790 */ 11791 SCTP_TCB_SEND_LOCK(stcb); 11792 stcb->asoc.ss_functions.sctp_ss_clear(stcb, &stcb->asoc, 0, 1); 11793 for (i = 0; i < stcb->asoc.streamoutcnt; i++) { 11794 TAILQ_INIT(&stcb->asoc.strmout[i].outqueue); 11795 stcb->asoc.strmout[i].chunks_on_queues = oldstream[i].chunks_on_queues; 11796 stcb->asoc.strmout[i].next_sequence_send = oldstream[i].next_sequence_send; 11797 stcb->asoc.strmout[i].last_msg_incomplete = oldstream[i].last_msg_incomplete; 11798 stcb->asoc.strmout[i].stream_no = i; 11799 stcb->asoc.ss_functions.sctp_ss_init_stream(&stcb->asoc.strmout[i], &oldstream[i]); 11800 /* now anything on those queues? */ 11801 TAILQ_FOREACH_SAFE(sp, &oldstream[i].outqueue, next, nsp) { 11802 TAILQ_REMOVE(&oldstream[i].outqueue, sp, next); 11803 TAILQ_INSERT_TAIL(&stcb->asoc.strmout[i].outqueue, sp, next); 11804 } 11805 /* Now move assoc pointers too */ 11806 if (stcb->asoc.last_out_stream == &oldstream[i]) { 11807 stcb->asoc.last_out_stream = &stcb->asoc.strmout[i]; 11808 } 11809 if (stcb->asoc.locked_on_sending == &oldstream[i]) { 11810 stcb->asoc.locked_on_sending = &stcb->asoc.strmout[i]; 11811 } 11812 } 11813 /* now the new streams */ 11814 stcb->asoc.ss_functions.sctp_ss_init(stcb, &stcb->asoc, 1); 11815 for (i = stcb->asoc.streamoutcnt; i < (stcb->asoc.streamoutcnt + adding_o); i++) { 11816 TAILQ_INIT(&stcb->asoc.strmout[i].outqueue); 11817 stcb->asoc.strmout[i].chunks_on_queues = 0; 11818 stcb->asoc.strmout[i].next_sequence_send = 0x0; 11819 stcb->asoc.strmout[i].stream_no = i; 11820 stcb->asoc.strmout[i].last_msg_incomplete = 0; 11821 stcb->asoc.ss_functions.sctp_ss_init_stream(&stcb->asoc.strmout[i], NULL); 11822 } 11823 stcb->asoc.strm_realoutsize = stcb->asoc.streamoutcnt + adding_o; 11824 SCTP_FREE(oldstream, SCTP_M_STRMO); 11825 SCTP_TCB_SEND_UNLOCK(stcb); 11826 } 11827 skip_stuff: 11828 if ((add_stream & 1) && (adding_o > 0)) { 11829 asoc->strm_pending_add_size = adding_o; 11830 asoc->peer_req_out = peer_asked; 11831 sctp_add_an_out_stream(chk, seq, adding_o); 11832 seq++; 11833 asoc->stream_reset_outstanding++; 11834 } 11835 if ((add_stream & 2) && (adding_i > 0)) { 11836 sctp_add_an_in_stream(chk, seq, adding_i); 11837 seq++; 11838 asoc->stream_reset_outstanding++; 11839 } 11840 if (send_in_req) { 11841 sctp_add_stream_reset_in(chk, number_entries, list, seq); 11842 seq++; 11843 asoc->stream_reset_outstanding++; 11844 } 11845 if (send_tsn_req) { 11846 sctp_add_stream_reset_tsn(chk, seq); 11847 asoc->stream_reset_outstanding++; 11848 } 11849 asoc->str_reset = chk; 11850 /* insert the chunk for sending */ 11851 TAILQ_INSERT_TAIL(&asoc->control_send_queue, 11852 chk, 11853 sctp_next); 11854 asoc->ctrl_queue_cnt++; 11855 sctp_timer_start(SCTP_TIMER_TYPE_STRRESET, stcb->sctp_ep, stcb, chk->whoTo); 11856 return (0); 11857 } 11858 11859 void 11860 sctp_send_abort(struct mbuf *m, int iphlen, struct sockaddr *src, struct sockaddr *dst, 11861 struct sctphdr *sh, uint32_t vtag, struct mbuf *cause, 11862 uint8_t use_mflowid, uint32_t mflowid, 11863 uint32_t vrf_id, uint16_t port) 11864 { 11865 /* Don't respond to an ABORT with an ABORT. */ 11866 if (sctp_is_there_an_abort_here(m, iphlen, &vtag)) { 11867 if (cause) 11868 sctp_m_freem(cause); 11869 return; 11870 } 11871 sctp_send_resp_msg(src, dst, sh, vtag, SCTP_ABORT_ASSOCIATION, cause, 11872 use_mflowid, mflowid, 11873 vrf_id, port); 11874 return; 11875 } 11876 11877 void 11878 sctp_send_operr_to(struct sockaddr *src, struct sockaddr *dst, 11879 struct sctphdr *sh, uint32_t vtag, struct mbuf *cause, 11880 uint8_t use_mflowid, uint32_t mflowid, 11881 uint32_t vrf_id, uint16_t port) 11882 { 11883 sctp_send_resp_msg(src, dst, sh, vtag, SCTP_OPERATION_ERROR, cause, 11884 use_mflowid, mflowid, 11885 vrf_id, port); 11886 return; 11887 } 11888 11889 static struct mbuf * 11890 sctp_copy_resume(struct uio *uio, 11891 int max_send_len, 11892 int user_marks_eor, 11893 int *error, 11894 uint32_t * sndout, 11895 struct mbuf **new_tail) 11896 { 11897 struct mbuf *m; 11898 11899 m = m_uiotombuf(uio, M_WAITOK, max_send_len, 0, 11900 (M_PKTHDR | (user_marks_eor ? M_EOR : 0))); 11901 if (m == NULL) { 11902 SCTP_LTRACE_ERR_RET(NULL, NULL, NULL, SCTP_FROM_SCTP_OUTPUT, ENOMEM); 11903 *error = ENOMEM; 11904 } else { 11905 *sndout = m_length(m, NULL); 11906 *new_tail = m_last(m); 11907 } 11908 return (m); 11909 } 11910 11911 static int 11912 sctp_copy_one(struct sctp_stream_queue_pending *sp, 11913 struct uio *uio, 11914 int resv_upfront) 11915 { 11916 int left; 11917 11918 left = sp->length; 11919 sp->data = m_uiotombuf(uio, M_WAITOK, sp->length, 11920 resv_upfront, 0); 11921 if (sp->data == NULL) { 11922 SCTP_LTRACE_ERR_RET(NULL, NULL, NULL, SCTP_FROM_SCTP_OUTPUT, ENOMEM); 11923 return (ENOMEM); 11924 } 11925 sp->tail_mbuf = m_last(sp->data); 11926 return (0); 11927 } 11928 11929 11930 11931 static struct sctp_stream_queue_pending * 11932 sctp_copy_it_in(struct sctp_tcb *stcb, 11933 struct sctp_association *asoc, 11934 struct sctp_sndrcvinfo *srcv, 11935 struct uio *uio, 11936 struct sctp_nets *net, 11937 int max_send_len, 11938 int user_marks_eor, 11939 int *error) 11940 { 11941 /*- 11942 * This routine must be very careful in its work. Protocol 11943 * processing is up and running so care must be taken to spl...() 11944 * when you need to do something that may effect the stcb/asoc. The 11945 * sb is locked however. When data is copied the protocol processing 11946 * should be enabled since this is a slower operation... 11947 */ 11948 struct sctp_stream_queue_pending *sp = NULL; 11949 int resv_in_first; 11950 11951 *error = 0; 11952 /* Now can we send this? */ 11953 if ((SCTP_GET_STATE(asoc) == SCTP_STATE_SHUTDOWN_SENT) || 11954 (SCTP_GET_STATE(asoc) == SCTP_STATE_SHUTDOWN_ACK_SENT) || 11955 (SCTP_GET_STATE(asoc) == SCTP_STATE_SHUTDOWN_RECEIVED) || 11956 (asoc->state & SCTP_STATE_SHUTDOWN_PENDING)) { 11957 /* got data while shutting down */ 11958 SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, ECONNRESET); 11959 *error = ECONNRESET; 11960 goto out_now; 11961 } 11962 sctp_alloc_a_strmoq(stcb, sp); 11963 if (sp == NULL) { 11964 SCTP_LTRACE_ERR_RET(NULL, stcb, net, SCTP_FROM_SCTP_OUTPUT, ENOMEM); 11965 *error = ENOMEM; 11966 goto out_now; 11967 } 11968 sp->act_flags = 0; 11969 sp->sender_all_done = 0; 11970 sp->sinfo_flags = srcv->sinfo_flags; 11971 sp->timetolive = srcv->sinfo_timetolive; 11972 sp->ppid = srcv->sinfo_ppid; 11973 sp->context = srcv->sinfo_context; 11974 (void)SCTP_GETTIME_TIMEVAL(&sp->ts); 11975 11976 sp->stream = srcv->sinfo_stream; 11977 sp->length = min(uio->uio_resid, max_send_len); 11978 if ((sp->length == (uint32_t) uio->uio_resid) && 11979 ((user_marks_eor == 0) || 11980 (srcv->sinfo_flags & SCTP_EOF) || 11981 (user_marks_eor && (srcv->sinfo_flags & SCTP_EOR)))) { 11982 sp->msg_is_complete = 1; 11983 } else { 11984 sp->msg_is_complete = 0; 11985 } 11986 sp->sender_all_done = 0; 11987 sp->some_taken = 0; 11988 sp->put_last_out = 0; 11989 resv_in_first = sizeof(struct sctp_data_chunk); 11990 sp->data = sp->tail_mbuf = NULL; 11991 if (sp->length == 0) { 11992 *error = 0; 11993 goto skip_copy; 11994 } 11995 if (srcv->sinfo_keynumber_valid) { 11996 sp->auth_keyid = srcv->sinfo_keynumber; 11997 } else { 11998 sp->auth_keyid = stcb->asoc.authinfo.active_keyid; 11999 } 12000 if (sctp_auth_is_required_chunk(SCTP_DATA, stcb->asoc.peer_auth_chunks)) { 12001 sctp_auth_key_acquire(stcb, sp->auth_keyid); 12002 sp->holds_key_ref = 1; 12003 } 12004 *error = sctp_copy_one(sp, uio, resv_in_first); 12005 skip_copy: 12006 if (*error) { 12007 sctp_free_a_strmoq(stcb, sp, SCTP_SO_LOCKED); 12008 sp = NULL; 12009 } else { 12010 if (sp->sinfo_flags & SCTP_ADDR_OVER) { 12011 sp->net = net; 12012 atomic_add_int(&sp->net->ref_count, 1); 12013 } else { 12014 sp->net = NULL; 12015 } 12016 sctp_set_prsctp_policy(sp); 12017 } 12018 out_now: 12019 return (sp); 12020 } 12021 12022 12023 int 12024 sctp_sosend(struct socket *so, 12025 struct sockaddr *addr, 12026 struct uio *uio, 12027 struct mbuf *top, 12028 struct mbuf *control, 12029 int flags, 12030 struct thread *p 12031 ) 12032 { 12033 int error, use_sndinfo = 0; 12034 struct sctp_sndrcvinfo sndrcvninfo; 12035 struct sockaddr *addr_to_use; 12036 12037 #if defined(INET) && defined(INET6) 12038 struct sockaddr_in sin; 12039 12040 #endif 12041 12042 if (control) { 12043 /* process cmsg snd/rcv info (maybe a assoc-id) */ 12044 if (sctp_find_cmsg(SCTP_SNDRCV, (void *)&sndrcvninfo, control, 12045 sizeof(sndrcvninfo))) { 12046 /* got one */ 12047 use_sndinfo = 1; 12048 } 12049 } 12050 addr_to_use = addr; 12051 #if defined(INET) && defined(INET6) 12052 if ((addr) && (addr->sa_family == AF_INET6)) { 12053 struct sockaddr_in6 *sin6; 12054 12055 sin6 = (struct sockaddr_in6 *)addr; 12056 if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) { 12057 in6_sin6_2_sin(&sin, sin6); 12058 addr_to_use = (struct sockaddr *)&sin; 12059 } 12060 } 12061 #endif 12062 error = sctp_lower_sosend(so, addr_to_use, uio, top, 12063 control, 12064 flags, 12065 use_sndinfo ? &sndrcvninfo : NULL 12066 ,p 12067 ); 12068 return (error); 12069 } 12070 12071 12072 int 12073 sctp_lower_sosend(struct socket *so, 12074 struct sockaddr *addr, 12075 struct uio *uio, 12076 struct mbuf *i_pak, 12077 struct mbuf *control, 12078 int flags, 12079 struct sctp_sndrcvinfo *srcv 12080 , 12081 struct thread *p 12082 ) 12083 { 12084 unsigned int sndlen = 0, max_len; 12085 int error, len; 12086 struct mbuf *top = NULL; 12087 int queue_only = 0, queue_only_for_init = 0; 12088 int free_cnt_applied = 0; 12089 int un_sent; 12090 int now_filled = 0; 12091 unsigned int inqueue_bytes = 0; 12092 struct sctp_block_entry be; 12093 struct sctp_inpcb *inp; 12094 struct sctp_tcb *stcb = NULL; 12095 struct timeval now; 12096 struct sctp_nets *net; 12097 struct sctp_association *asoc; 12098 struct sctp_inpcb *t_inp; 12099 int user_marks_eor; 12100 int create_lock_applied = 0; 12101 int nagle_applies = 0; 12102 int some_on_control = 0; 12103 int got_all_of_the_send = 0; 12104 int hold_tcblock = 0; 12105 int non_blocking = 0; 12106 uint32_t local_add_more, local_soresv = 0; 12107 uint16_t port; 12108 uint16_t sinfo_flags; 12109 sctp_assoc_t sinfo_assoc_id; 12110 12111 error = 0; 12112 net = NULL; 12113 stcb = NULL; 12114 asoc = NULL; 12115 12116 t_inp = inp = (struct sctp_inpcb *)so->so_pcb; 12117 if (inp == NULL) { 12118 SCTP_LTRACE_ERR_RET(NULL, NULL, NULL, SCTP_FROM_SCTP_OUTPUT, EINVAL); 12119 error = EINVAL; 12120 if (i_pak) { 12121 SCTP_RELEASE_PKT(i_pak); 12122 } 12123 return (error); 12124 } 12125 if ((uio == NULL) && (i_pak == NULL)) { 12126 SCTP_LTRACE_ERR_RET(inp, stcb, net, SCTP_FROM_SCTP_OUTPUT, EINVAL); 12127 return (EINVAL); 12128 } 12129 user_marks_eor = sctp_is_feature_on(inp, SCTP_PCB_FLAGS_EXPLICIT_EOR); 12130 atomic_add_int(&inp->total_sends, 1); 12131 if (uio) { 12132 if (uio->uio_resid < 0) { 12133 SCTP_LTRACE_ERR_RET(inp, stcb, net, SCTP_FROM_SCTP_OUTPUT, EINVAL); 12134 return (EINVAL); 12135 } 12136 sndlen = uio->uio_resid; 12137 } else { 12138 top = SCTP_HEADER_TO_CHAIN(i_pak); 12139 sndlen = SCTP_HEADER_LEN(i_pak); 12140 } 12141 SCTPDBG(SCTP_DEBUG_OUTPUT1, "Send called addr:%p send length %d\n", 12142 (void *)addr, 12143 sndlen); 12144 if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) && 12145 (inp->sctp_socket->so_qlimit)) { 12146 /* The listener can NOT send */ 12147 SCTP_LTRACE_ERR_RET(NULL, NULL, NULL, SCTP_FROM_SCTP_OUTPUT, ENOTCONN); 12148 error = ENOTCONN; 12149 goto out_unlocked; 12150 } 12151 /** 12152 * Pre-screen address, if one is given the sin-len 12153 * must be set correctly! 12154 */ 12155 if (addr) { 12156 union sctp_sockstore *raddr = (union sctp_sockstore *)addr; 12157 12158 switch (raddr->sa.sa_family) { 12159 #ifdef INET 12160 case AF_INET: 12161 if (raddr->sin.sin_len != sizeof(struct sockaddr_in)) { 12162 SCTP_LTRACE_ERR_RET(inp, stcb, net, SCTP_FROM_SCTP_OUTPUT, EINVAL); 12163 error = EINVAL; 12164 goto out_unlocked; 12165 } 12166 port = raddr->sin.sin_port; 12167 break; 12168 #endif 12169 #ifdef INET6 12170 case AF_INET6: 12171 if (raddr->sin6.sin6_len != sizeof(struct sockaddr_in6)) { 12172 SCTP_LTRACE_ERR_RET(inp, stcb, net, SCTP_FROM_SCTP_OUTPUT, EINVAL); 12173 error = EINVAL; 12174 goto out_unlocked; 12175 } 12176 port = raddr->sin6.sin6_port; 12177 break; 12178 #endif 12179 default: 12180 SCTP_LTRACE_ERR_RET(inp, stcb, net, SCTP_FROM_SCTP_OUTPUT, EAFNOSUPPORT); 12181 error = EAFNOSUPPORT; 12182 goto out_unlocked; 12183 } 12184 } else 12185 port = 0; 12186 12187 if (srcv) { 12188 sinfo_flags = srcv->sinfo_flags; 12189 sinfo_assoc_id = srcv->sinfo_assoc_id; 12190 if (INVALID_SINFO_FLAG(sinfo_flags) || 12191 PR_SCTP_INVALID_POLICY(sinfo_flags)) { 12192 SCTP_LTRACE_ERR_RET(inp, stcb, net, SCTP_FROM_SCTP_OUTPUT, EINVAL); 12193 error = EINVAL; 12194 goto out_unlocked; 12195 } 12196 if (srcv->sinfo_flags) 12197 SCTP_STAT_INCR(sctps_sends_with_flags); 12198 } else { 12199 sinfo_flags = inp->def_send.sinfo_flags; 12200 sinfo_assoc_id = inp->def_send.sinfo_assoc_id; 12201 } 12202 if (sinfo_flags & SCTP_SENDALL) { 12203 /* its a sendall */ 12204 error = sctp_sendall(inp, uio, top, srcv); 12205 top = NULL; 12206 goto out_unlocked; 12207 } 12208 if ((sinfo_flags & SCTP_ADDR_OVER) && (addr == NULL)) { 12209 SCTP_LTRACE_ERR_RET(inp, stcb, net, SCTP_FROM_SCTP_OUTPUT, EINVAL); 12210 error = EINVAL; 12211 goto out_unlocked; 12212 } 12213 /* now we must find the assoc */ 12214 if ((inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) || 12215 (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL)) { 12216 SCTP_INP_RLOCK(inp); 12217 stcb = LIST_FIRST(&inp->sctp_asoc_list); 12218 if (stcb) { 12219 SCTP_TCB_LOCK(stcb); 12220 hold_tcblock = 1; 12221 } 12222 SCTP_INP_RUNLOCK(inp); 12223 } else if (sinfo_assoc_id) { 12224 stcb = sctp_findassociation_ep_asocid(inp, sinfo_assoc_id, 0); 12225 } else if (addr) { 12226 /*- 12227 * Since we did not use findep we must 12228 * increment it, and if we don't find a tcb 12229 * decrement it. 12230 */ 12231 SCTP_INP_WLOCK(inp); 12232 SCTP_INP_INCR_REF(inp); 12233 SCTP_INP_WUNLOCK(inp); 12234 stcb = sctp_findassociation_ep_addr(&t_inp, addr, &net, NULL, NULL); 12235 if (stcb == NULL) { 12236 SCTP_INP_WLOCK(inp); 12237 SCTP_INP_DECR_REF(inp); 12238 SCTP_INP_WUNLOCK(inp); 12239 } else { 12240 hold_tcblock = 1; 12241 } 12242 } 12243 if ((stcb == NULL) && (addr)) { 12244 /* Possible implicit send? */ 12245 SCTP_ASOC_CREATE_LOCK(inp); 12246 create_lock_applied = 1; 12247 if ((inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) || 12248 (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_ALLGONE)) { 12249 /* Should I really unlock ? */ 12250 SCTP_LTRACE_ERR_RET(NULL, NULL, NULL, SCTP_FROM_SCTP_OUTPUT, EINVAL); 12251 error = EINVAL; 12252 goto out_unlocked; 12253 12254 } 12255 if (((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) == 0) && 12256 (addr->sa_family == AF_INET6)) { 12257 SCTP_LTRACE_ERR_RET(inp, stcb, net, SCTP_FROM_SCTP_OUTPUT, EINVAL); 12258 error = EINVAL; 12259 goto out_unlocked; 12260 } 12261 SCTP_INP_WLOCK(inp); 12262 SCTP_INP_INCR_REF(inp); 12263 SCTP_INP_WUNLOCK(inp); 12264 /* With the lock applied look again */ 12265 stcb = sctp_findassociation_ep_addr(&t_inp, addr, &net, NULL, NULL); 12266 if ((stcb == NULL) && (control != NULL) && (port > 0)) { 12267 stcb = sctp_findassociation_cmsgs(&t_inp, port, control, &net, &error); 12268 } 12269 if (stcb == NULL) { 12270 SCTP_INP_WLOCK(inp); 12271 SCTP_INP_DECR_REF(inp); 12272 SCTP_INP_WUNLOCK(inp); 12273 } else { 12274 hold_tcblock = 1; 12275 } 12276 if (error) { 12277 goto out_unlocked; 12278 } 12279 if (t_inp != inp) { 12280 SCTP_LTRACE_ERR_RET(inp, stcb, net, SCTP_FROM_SCTP_OUTPUT, ENOTCONN); 12281 error = ENOTCONN; 12282 goto out_unlocked; 12283 } 12284 } 12285 if (stcb == NULL) { 12286 if (addr == NULL) { 12287 SCTP_LTRACE_ERR_RET(inp, stcb, net, SCTP_FROM_SCTP_OUTPUT, ENOENT); 12288 error = ENOENT; 12289 goto out_unlocked; 12290 } else { 12291 /* We must go ahead and start the INIT process */ 12292 uint32_t vrf_id; 12293 12294 if ((sinfo_flags & SCTP_ABORT) || 12295 ((sinfo_flags & SCTP_EOF) && (sndlen == 0))) { 12296 /*- 12297 * User asks to abort a non-existant assoc, 12298 * or EOF a non-existant assoc with no data 12299 */ 12300 SCTP_LTRACE_ERR_RET(inp, stcb, net, SCTP_FROM_SCTP_OUTPUT, ENOENT); 12301 error = ENOENT; 12302 goto out_unlocked; 12303 } 12304 /* get an asoc/stcb struct */ 12305 vrf_id = inp->def_vrf_id; 12306 #ifdef INVARIANTS 12307 if (create_lock_applied == 0) { 12308 panic("Error, should hold create lock and I don't?"); 12309 } 12310 #endif 12311 stcb = sctp_aloc_assoc(inp, addr, &error, 0, vrf_id, 12312 p 12313 ); 12314 if (stcb == NULL) { 12315 /* Error is setup for us in the call */ 12316 goto out_unlocked; 12317 } 12318 if (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) { 12319 stcb->sctp_ep->sctp_flags |= SCTP_PCB_FLAGS_CONNECTED; 12320 /* 12321 * Set the connected flag so we can queue 12322 * data 12323 */ 12324 soisconnecting(so); 12325 } 12326 hold_tcblock = 1; 12327 if (create_lock_applied) { 12328 SCTP_ASOC_CREATE_UNLOCK(inp); 12329 create_lock_applied = 0; 12330 } else { 12331 SCTP_PRINTF("Huh-3? create lock should have been on??\n"); 12332 } 12333 /* 12334 * Turn on queue only flag to prevent data from 12335 * being sent 12336 */ 12337 queue_only = 1; 12338 asoc = &stcb->asoc; 12339 SCTP_SET_STATE(asoc, SCTP_STATE_COOKIE_WAIT); 12340 (void)SCTP_GETTIME_TIMEVAL(&asoc->time_entered); 12341 12342 /* initialize authentication params for the assoc */ 12343 sctp_initialize_auth_params(inp, stcb); 12344 12345 if (control) { 12346 if (sctp_process_cmsgs_for_init(stcb, control, &error)) { 12347 sctp_free_assoc(inp, stcb, SCTP_PCBFREE_FORCE, SCTP_FROM_SCTP_OUTPUT + SCTP_LOC_7); 12348 hold_tcblock = 0; 12349 stcb = NULL; 12350 goto out_unlocked; 12351 } 12352 } 12353 /* out with the INIT */ 12354 queue_only_for_init = 1; 12355 /*- 12356 * we may want to dig in after this call and adjust the MTU 12357 * value. It defaulted to 1500 (constant) but the ro 12358 * structure may now have an update and thus we may need to 12359 * change it BEFORE we append the message. 12360 */ 12361 } 12362 } else 12363 asoc = &stcb->asoc; 12364 if (srcv == NULL) 12365 srcv = (struct sctp_sndrcvinfo *)&asoc->def_send; 12366 if (srcv->sinfo_flags & SCTP_ADDR_OVER) { 12367 if (addr) 12368 net = sctp_findnet(stcb, addr); 12369 else 12370 net = NULL; 12371 if ((net == NULL) || 12372 ((port != 0) && (port != stcb->rport))) { 12373 SCTP_LTRACE_ERR_RET(inp, stcb, net, SCTP_FROM_SCTP_OUTPUT, EINVAL); 12374 error = EINVAL; 12375 goto out_unlocked; 12376 } 12377 } else { 12378 if (stcb->asoc.alternate) { 12379 net = stcb->asoc.alternate; 12380 } else { 12381 net = stcb->asoc.primary_destination; 12382 } 12383 } 12384 atomic_add_int(&stcb->total_sends, 1); 12385 /* Keep the stcb from being freed under our feet */ 12386 atomic_add_int(&asoc->refcnt, 1); 12387 free_cnt_applied = 1; 12388 12389 if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_NO_FRAGMENT)) { 12390 if (sndlen > asoc->smallest_mtu) { 12391 SCTP_LTRACE_ERR_RET(inp, stcb, net, SCTP_FROM_SCTP_OUTPUT, EMSGSIZE); 12392 error = EMSGSIZE; 12393 goto out_unlocked; 12394 } 12395 } 12396 if (SCTP_SO_IS_NBIO(so) 12397 || (flags & MSG_NBIO) 12398 ) { 12399 non_blocking = 1; 12400 } 12401 /* would we block? */ 12402 if (non_blocking) { 12403 if (hold_tcblock == 0) { 12404 SCTP_TCB_LOCK(stcb); 12405 hold_tcblock = 1; 12406 } 12407 inqueue_bytes = stcb->asoc.total_output_queue_size - (stcb->asoc.chunks_on_out_queue * sizeof(struct sctp_data_chunk)); 12408 if ((SCTP_SB_LIMIT_SND(so) < (sndlen + inqueue_bytes + stcb->asoc.sb_send_resv)) || 12409 (stcb->asoc.chunks_on_out_queue >= SCTP_BASE_SYSCTL(sctp_max_chunks_on_queue))) { 12410 SCTP_LTRACE_ERR_RET(inp, stcb, net, SCTP_FROM_SCTP_OUTPUT, EWOULDBLOCK); 12411 if (sndlen > SCTP_SB_LIMIT_SND(so)) 12412 error = EMSGSIZE; 12413 else 12414 error = EWOULDBLOCK; 12415 goto out_unlocked; 12416 } 12417 stcb->asoc.sb_send_resv += sndlen; 12418 SCTP_TCB_UNLOCK(stcb); 12419 hold_tcblock = 0; 12420 } else { 12421 atomic_add_int(&stcb->asoc.sb_send_resv, sndlen); 12422 } 12423 local_soresv = sndlen; 12424 if (stcb->asoc.state & SCTP_STATE_ABOUT_TO_BE_FREED) { 12425 SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, ECONNRESET); 12426 error = ECONNRESET; 12427 goto out_unlocked; 12428 } 12429 if (create_lock_applied) { 12430 SCTP_ASOC_CREATE_UNLOCK(inp); 12431 create_lock_applied = 0; 12432 } 12433 if (asoc->stream_reset_outstanding) { 12434 /* 12435 * Can't queue any data while stream reset is underway. 12436 */ 12437 SCTP_LTRACE_ERR_RET(inp, stcb, net, SCTP_FROM_SCTP_OUTPUT, EAGAIN); 12438 error = EAGAIN; 12439 goto out_unlocked; 12440 } 12441 if ((SCTP_GET_STATE(asoc) == SCTP_STATE_COOKIE_WAIT) || 12442 (SCTP_GET_STATE(asoc) == SCTP_STATE_COOKIE_ECHOED)) { 12443 queue_only = 1; 12444 } 12445 /* we are now done with all control */ 12446 if (control) { 12447 sctp_m_freem(control); 12448 control = NULL; 12449 } 12450 if ((SCTP_GET_STATE(asoc) == SCTP_STATE_SHUTDOWN_SENT) || 12451 (SCTP_GET_STATE(asoc) == SCTP_STATE_SHUTDOWN_RECEIVED) || 12452 (SCTP_GET_STATE(asoc) == SCTP_STATE_SHUTDOWN_ACK_SENT) || 12453 (asoc->state & SCTP_STATE_SHUTDOWN_PENDING)) { 12454 if (srcv->sinfo_flags & SCTP_ABORT) { 12455 ; 12456 } else { 12457 SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, ECONNRESET); 12458 error = ECONNRESET; 12459 goto out_unlocked; 12460 } 12461 } 12462 /* Ok, we will attempt a msgsnd :> */ 12463 if (p) { 12464 p->td_ru.ru_msgsnd++; 12465 } 12466 /* Are we aborting? */ 12467 if (srcv->sinfo_flags & SCTP_ABORT) { 12468 struct mbuf *mm; 12469 int tot_demand, tot_out = 0, max_out; 12470 12471 SCTP_STAT_INCR(sctps_sends_with_abort); 12472 if ((SCTP_GET_STATE(asoc) == SCTP_STATE_COOKIE_WAIT) || 12473 (SCTP_GET_STATE(asoc) == SCTP_STATE_COOKIE_ECHOED)) { 12474 /* It has to be up before we abort */ 12475 /* how big is the user initiated abort? */ 12476 SCTP_LTRACE_ERR_RET(inp, stcb, net, SCTP_FROM_SCTP_OUTPUT, EINVAL); 12477 error = EINVAL; 12478 goto out; 12479 } 12480 if (hold_tcblock) { 12481 SCTP_TCB_UNLOCK(stcb); 12482 hold_tcblock = 0; 12483 } 12484 if (top) { 12485 struct mbuf *cntm = NULL; 12486 12487 mm = sctp_get_mbuf_for_msg(sizeof(struct sctp_paramhdr), 0, M_WAIT, 1, MT_DATA); 12488 if (sndlen != 0) { 12489 for (cntm = top; cntm; cntm = SCTP_BUF_NEXT(cntm)) { 12490 tot_out += SCTP_BUF_LEN(cntm); 12491 } 12492 } 12493 } else { 12494 /* Must fit in a MTU */ 12495 tot_out = sndlen; 12496 tot_demand = (tot_out + sizeof(struct sctp_paramhdr)); 12497 if (tot_demand > SCTP_DEFAULT_ADD_MORE) { 12498 /* To big */ 12499 SCTP_LTRACE_ERR_RET(NULL, stcb, net, SCTP_FROM_SCTP_OUTPUT, EMSGSIZE); 12500 error = EMSGSIZE; 12501 goto out; 12502 } 12503 mm = sctp_get_mbuf_for_msg(tot_demand, 0, M_WAIT, 1, MT_DATA); 12504 } 12505 if (mm == NULL) { 12506 SCTP_LTRACE_ERR_RET(NULL, stcb, net, SCTP_FROM_SCTP_OUTPUT, ENOMEM); 12507 error = ENOMEM; 12508 goto out; 12509 } 12510 max_out = asoc->smallest_mtu - sizeof(struct sctp_paramhdr); 12511 max_out -= sizeof(struct sctp_abort_msg); 12512 if (tot_out > max_out) { 12513 tot_out = max_out; 12514 } 12515 if (mm) { 12516 struct sctp_paramhdr *ph; 12517 12518 /* now move forward the data pointer */ 12519 ph = mtod(mm, struct sctp_paramhdr *); 12520 ph->param_type = htons(SCTP_CAUSE_USER_INITIATED_ABT); 12521 ph->param_length = htons(sizeof(struct sctp_paramhdr) + tot_out); 12522 ph++; 12523 SCTP_BUF_LEN(mm) = tot_out + sizeof(struct sctp_paramhdr); 12524 if (top == NULL) { 12525 error = uiomove((caddr_t)ph, (int)tot_out, uio); 12526 if (error) { 12527 /*- 12528 * Here if we can't get his data we 12529 * still abort we just don't get to 12530 * send the users note :-0 12531 */ 12532 sctp_m_freem(mm); 12533 mm = NULL; 12534 } 12535 } else { 12536 if (sndlen != 0) { 12537 SCTP_BUF_NEXT(mm) = top; 12538 } 12539 } 12540 } 12541 if (hold_tcblock == 0) { 12542 SCTP_TCB_LOCK(stcb); 12543 } 12544 atomic_add_int(&stcb->asoc.refcnt, -1); 12545 free_cnt_applied = 0; 12546 /* release this lock, otherwise we hang on ourselves */ 12547 sctp_abort_an_association(stcb->sctp_ep, stcb, mm, SCTP_SO_LOCKED); 12548 /* now relock the stcb so everything is sane */ 12549 hold_tcblock = 0; 12550 stcb = NULL; 12551 /* 12552 * In this case top is already chained to mm avoid double 12553 * free, since we free it below if top != NULL and driver 12554 * would free it after sending the packet out 12555 */ 12556 if (sndlen != 0) { 12557 top = NULL; 12558 } 12559 goto out_unlocked; 12560 } 12561 /* Calculate the maximum we can send */ 12562 inqueue_bytes = stcb->asoc.total_output_queue_size - (stcb->asoc.chunks_on_out_queue * sizeof(struct sctp_data_chunk)); 12563 if (SCTP_SB_LIMIT_SND(so) > inqueue_bytes) { 12564 if (non_blocking) { 12565 /* we already checked for non-blocking above. */ 12566 max_len = sndlen; 12567 } else { 12568 max_len = SCTP_SB_LIMIT_SND(so) - inqueue_bytes; 12569 } 12570 } else { 12571 max_len = 0; 12572 } 12573 if (hold_tcblock) { 12574 SCTP_TCB_UNLOCK(stcb); 12575 hold_tcblock = 0; 12576 } 12577 /* Is the stream no. valid? */ 12578 if (srcv->sinfo_stream >= asoc->streamoutcnt) { 12579 /* Invalid stream number */ 12580 SCTP_LTRACE_ERR_RET(inp, stcb, net, SCTP_FROM_SCTP_OUTPUT, EINVAL); 12581 error = EINVAL; 12582 goto out_unlocked; 12583 } 12584 if (asoc->strmout == NULL) { 12585 /* huh? software error */ 12586 SCTP_LTRACE_ERR_RET(inp, stcb, net, SCTP_FROM_SCTP_OUTPUT, EFAULT); 12587 error = EFAULT; 12588 goto out_unlocked; 12589 } 12590 /* Unless E_EOR mode is on, we must make a send FIT in one call. */ 12591 if ((user_marks_eor == 0) && 12592 (sndlen > SCTP_SB_LIMIT_SND(stcb->sctp_socket))) { 12593 /* It will NEVER fit */ 12594 SCTP_LTRACE_ERR_RET(NULL, stcb, net, SCTP_FROM_SCTP_OUTPUT, EMSGSIZE); 12595 error = EMSGSIZE; 12596 goto out_unlocked; 12597 } 12598 if ((uio == NULL) && user_marks_eor) { 12599 /*- 12600 * We do not support eeor mode for 12601 * sending with mbuf chains (like sendfile). 12602 */ 12603 SCTP_LTRACE_ERR_RET(NULL, stcb, net, SCTP_FROM_SCTP_OUTPUT, EINVAL); 12604 error = EINVAL; 12605 goto out_unlocked; 12606 } 12607 if (user_marks_eor) { 12608 local_add_more = min(SCTP_SB_LIMIT_SND(so), SCTP_BASE_SYSCTL(sctp_add_more_threshold)); 12609 } else { 12610 /*- 12611 * For non-eeor the whole message must fit in 12612 * the socket send buffer. 12613 */ 12614 local_add_more = sndlen; 12615 } 12616 len = 0; 12617 if (non_blocking) { 12618 goto skip_preblock; 12619 } 12620 if (((max_len <= local_add_more) && 12621 (SCTP_SB_LIMIT_SND(so) >= local_add_more)) || 12622 (max_len == 0) || 12623 ((stcb->asoc.chunks_on_out_queue + stcb->asoc.stream_queue_cnt) >= SCTP_BASE_SYSCTL(sctp_max_chunks_on_queue))) { 12624 /* No room right now ! */ 12625 SOCKBUF_LOCK(&so->so_snd); 12626 inqueue_bytes = stcb->asoc.total_output_queue_size - (stcb->asoc.chunks_on_out_queue * sizeof(struct sctp_data_chunk)); 12627 while ((SCTP_SB_LIMIT_SND(so) < (inqueue_bytes + local_add_more)) || 12628 ((stcb->asoc.stream_queue_cnt + stcb->asoc.chunks_on_out_queue) >= SCTP_BASE_SYSCTL(sctp_max_chunks_on_queue))) { 12629 SCTPDBG(SCTP_DEBUG_OUTPUT1, "pre_block limit:%u <(inq:%d + %d) || (%d+%d > %d)\n", 12630 (unsigned int)SCTP_SB_LIMIT_SND(so), 12631 inqueue_bytes, 12632 local_add_more, 12633 stcb->asoc.stream_queue_cnt, 12634 stcb->asoc.chunks_on_out_queue, 12635 SCTP_BASE_SYSCTL(sctp_max_chunks_on_queue)); 12636 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_BLK_LOGGING_ENABLE) { 12637 sctp_log_block(SCTP_BLOCK_LOG_INTO_BLKA, asoc, sndlen); 12638 } 12639 be.error = 0; 12640 stcb->block_entry = &be; 12641 error = sbwait(&so->so_snd); 12642 stcb->block_entry = NULL; 12643 if (error || so->so_error || be.error) { 12644 if (error == 0) { 12645 if (so->so_error) 12646 error = so->so_error; 12647 if (be.error) { 12648 error = be.error; 12649 } 12650 } 12651 SOCKBUF_UNLOCK(&so->so_snd); 12652 goto out_unlocked; 12653 } 12654 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_BLK_LOGGING_ENABLE) { 12655 sctp_log_block(SCTP_BLOCK_LOG_OUTOF_BLK, 12656 asoc, stcb->asoc.total_output_queue_size); 12657 } 12658 if (stcb->asoc.state & SCTP_STATE_ABOUT_TO_BE_FREED) { 12659 goto out_unlocked; 12660 } 12661 inqueue_bytes = stcb->asoc.total_output_queue_size - (stcb->asoc.chunks_on_out_queue * sizeof(struct sctp_data_chunk)); 12662 } 12663 if (SCTP_SB_LIMIT_SND(so) > inqueue_bytes) { 12664 max_len = SCTP_SB_LIMIT_SND(so) - inqueue_bytes; 12665 } else { 12666 max_len = 0; 12667 } 12668 SOCKBUF_UNLOCK(&so->so_snd); 12669 } 12670 skip_preblock: 12671 if (stcb->asoc.state & SCTP_STATE_ABOUT_TO_BE_FREED) { 12672 goto out_unlocked; 12673 } 12674 /* 12675 * sndlen covers for mbuf case uio_resid covers for the non-mbuf 12676 * case NOTE: uio will be null when top/mbuf is passed 12677 */ 12678 if (sndlen == 0) { 12679 if (srcv->sinfo_flags & SCTP_EOF) { 12680 got_all_of_the_send = 1; 12681 goto dataless_eof; 12682 } else { 12683 SCTP_LTRACE_ERR_RET(inp, stcb, net, SCTP_FROM_SCTP_OUTPUT, EINVAL); 12684 error = EINVAL; 12685 goto out; 12686 } 12687 } 12688 if (top == NULL) { 12689 struct sctp_stream_queue_pending *sp; 12690 struct sctp_stream_out *strm; 12691 uint32_t sndout; 12692 12693 SCTP_TCB_SEND_LOCK(stcb); 12694 if ((asoc->stream_locked) && 12695 (asoc->stream_locked_on != srcv->sinfo_stream)) { 12696 SCTP_TCB_SEND_UNLOCK(stcb); 12697 SCTP_LTRACE_ERR_RET(inp, stcb, net, SCTP_FROM_SCTP_OUTPUT, EINVAL); 12698 error = EINVAL; 12699 goto out; 12700 } 12701 SCTP_TCB_SEND_UNLOCK(stcb); 12702 12703 strm = &stcb->asoc.strmout[srcv->sinfo_stream]; 12704 if (strm->last_msg_incomplete == 0) { 12705 do_a_copy_in: 12706 sp = sctp_copy_it_in(stcb, asoc, srcv, uio, net, max_len, user_marks_eor, &error); 12707 if ((sp == NULL) || (error)) { 12708 goto out; 12709 } 12710 SCTP_TCB_SEND_LOCK(stcb); 12711 if (sp->msg_is_complete) { 12712 strm->last_msg_incomplete = 0; 12713 asoc->stream_locked = 0; 12714 } else { 12715 /* 12716 * Just got locked to this guy in case of an 12717 * interrupt. 12718 */ 12719 strm->last_msg_incomplete = 1; 12720 asoc->stream_locked = 1; 12721 asoc->stream_locked_on = srcv->sinfo_stream; 12722 sp->sender_all_done = 0; 12723 } 12724 sctp_snd_sb_alloc(stcb, sp->length); 12725 atomic_add_int(&asoc->stream_queue_cnt, 1); 12726 if (srcv->sinfo_flags & SCTP_UNORDERED) { 12727 SCTP_STAT_INCR(sctps_sends_with_unord); 12728 } 12729 TAILQ_INSERT_TAIL(&strm->outqueue, sp, next); 12730 stcb->asoc.ss_functions.sctp_ss_add_to_stream(stcb, asoc, strm, sp, 1); 12731 SCTP_TCB_SEND_UNLOCK(stcb); 12732 } else { 12733 SCTP_TCB_SEND_LOCK(stcb); 12734 sp = TAILQ_LAST(&strm->outqueue, sctp_streamhead); 12735 SCTP_TCB_SEND_UNLOCK(stcb); 12736 if (sp == NULL) { 12737 /* ???? Huh ??? last msg is gone */ 12738 #ifdef INVARIANTS 12739 panic("Warning: Last msg marked incomplete, yet nothing left?"); 12740 #else 12741 SCTP_PRINTF("Warning: Last msg marked incomplete, yet nothing left?\n"); 12742 strm->last_msg_incomplete = 0; 12743 #endif 12744 goto do_a_copy_in; 12745 12746 } 12747 } 12748 while (uio->uio_resid > 0) { 12749 /* How much room do we have? */ 12750 struct mbuf *new_tail, *mm; 12751 12752 if (SCTP_SB_LIMIT_SND(so) > stcb->asoc.total_output_queue_size) 12753 max_len = SCTP_SB_LIMIT_SND(so) - stcb->asoc.total_output_queue_size; 12754 else 12755 max_len = 0; 12756 12757 if ((max_len > SCTP_BASE_SYSCTL(sctp_add_more_threshold)) || 12758 (max_len && (SCTP_SB_LIMIT_SND(so) < SCTP_BASE_SYSCTL(sctp_add_more_threshold))) || 12759 (uio->uio_resid && (uio->uio_resid <= (int)max_len))) { 12760 sndout = 0; 12761 new_tail = NULL; 12762 if (hold_tcblock) { 12763 SCTP_TCB_UNLOCK(stcb); 12764 hold_tcblock = 0; 12765 } 12766 mm = sctp_copy_resume(uio, max_len, user_marks_eor, &error, &sndout, &new_tail); 12767 if ((mm == NULL) || error) { 12768 if (mm) { 12769 sctp_m_freem(mm); 12770 } 12771 goto out; 12772 } 12773 /* Update the mbuf and count */ 12774 SCTP_TCB_SEND_LOCK(stcb); 12775 if (stcb->asoc.state & SCTP_STATE_ABOUT_TO_BE_FREED) { 12776 /* 12777 * we need to get out. Peer probably 12778 * aborted. 12779 */ 12780 sctp_m_freem(mm); 12781 if (stcb->asoc.state & SCTP_PCB_FLAGS_WAS_ABORTED) { 12782 SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTP_OUTPUT, ECONNRESET); 12783 error = ECONNRESET; 12784 } 12785 SCTP_TCB_SEND_UNLOCK(stcb); 12786 goto out; 12787 } 12788 if (sp->tail_mbuf) { 12789 /* tack it to the end */ 12790 SCTP_BUF_NEXT(sp->tail_mbuf) = mm; 12791 sp->tail_mbuf = new_tail; 12792 } else { 12793 /* A stolen mbuf */ 12794 sp->data = mm; 12795 sp->tail_mbuf = new_tail; 12796 } 12797 sctp_snd_sb_alloc(stcb, sndout); 12798 atomic_add_int(&sp->length, sndout); 12799 len += sndout; 12800 12801 /* Did we reach EOR? */ 12802 if ((uio->uio_resid == 0) && 12803 ((user_marks_eor == 0) || 12804 (srcv->sinfo_flags & SCTP_EOF) || 12805 (user_marks_eor && (srcv->sinfo_flags & SCTP_EOR)))) { 12806 sp->msg_is_complete = 1; 12807 } else { 12808 sp->msg_is_complete = 0; 12809 } 12810 SCTP_TCB_SEND_UNLOCK(stcb); 12811 } 12812 if (uio->uio_resid == 0) { 12813 /* got it all? */ 12814 continue; 12815 } 12816 /* PR-SCTP? */ 12817 if ((asoc->peer_supports_prsctp) && (asoc->sent_queue_cnt_removeable > 0)) { 12818 /* 12819 * This is ugly but we must assure locking 12820 * order 12821 */ 12822 if (hold_tcblock == 0) { 12823 SCTP_TCB_LOCK(stcb); 12824 hold_tcblock = 1; 12825 } 12826 sctp_prune_prsctp(stcb, asoc, srcv, sndlen); 12827 inqueue_bytes = stcb->asoc.total_output_queue_size - (stcb->asoc.chunks_on_out_queue * sizeof(struct sctp_data_chunk)); 12828 if (SCTP_SB_LIMIT_SND(so) > stcb->asoc.total_output_queue_size) 12829 max_len = SCTP_SB_LIMIT_SND(so) - inqueue_bytes; 12830 else 12831 max_len = 0; 12832 if (max_len > 0) { 12833 continue; 12834 } 12835 SCTP_TCB_UNLOCK(stcb); 12836 hold_tcblock = 0; 12837 } 12838 /* wait for space now */ 12839 if (non_blocking) { 12840 /* Non-blocking io in place out */ 12841 goto skip_out_eof; 12842 } 12843 /* What about the INIT, send it maybe */ 12844 if (queue_only_for_init) { 12845 if (hold_tcblock == 0) { 12846 SCTP_TCB_LOCK(stcb); 12847 hold_tcblock = 1; 12848 } 12849 if (SCTP_GET_STATE(&stcb->asoc) == SCTP_STATE_OPEN) { 12850 /* a collision took us forward? */ 12851 queue_only = 0; 12852 } else { 12853 sctp_send_initiate(inp, stcb, SCTP_SO_LOCKED); 12854 SCTP_SET_STATE(asoc, SCTP_STATE_COOKIE_WAIT); 12855 queue_only = 1; 12856 } 12857 } 12858 if ((net->flight_size > net->cwnd) && 12859 (asoc->sctp_cmt_on_off == 0)) { 12860 SCTP_STAT_INCR(sctps_send_cwnd_avoid); 12861 queue_only = 1; 12862 } else if (asoc->ifp_had_enobuf) { 12863 SCTP_STAT_INCR(sctps_ifnomemqueued); 12864 if (net->flight_size > (2 * net->mtu)) { 12865 queue_only = 1; 12866 } 12867 asoc->ifp_had_enobuf = 0; 12868 } 12869 un_sent = ((stcb->asoc.total_output_queue_size - stcb->asoc.total_flight) + 12870 (stcb->asoc.stream_queue_cnt * sizeof(struct sctp_data_chunk))); 12871 if ((sctp_is_feature_off(inp, SCTP_PCB_FLAGS_NODELAY)) && 12872 (stcb->asoc.total_flight > 0) && 12873 (stcb->asoc.stream_queue_cnt < SCTP_MAX_DATA_BUNDLING) && 12874 (un_sent < (int)(stcb->asoc.smallest_mtu - SCTP_MIN_OVERHEAD))) { 12875 12876 /*- 12877 * Ok, Nagle is set on and we have data outstanding. 12878 * Don't send anything and let SACKs drive out the 12879 * data unless wen have a "full" segment to send. 12880 */ 12881 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_NAGLE_LOGGING_ENABLE) { 12882 sctp_log_nagle_event(stcb, SCTP_NAGLE_APPLIED); 12883 } 12884 SCTP_STAT_INCR(sctps_naglequeued); 12885 nagle_applies = 1; 12886 } else { 12887 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_NAGLE_LOGGING_ENABLE) { 12888 if (sctp_is_feature_off(inp, SCTP_PCB_FLAGS_NODELAY)) 12889 sctp_log_nagle_event(stcb, SCTP_NAGLE_SKIPPED); 12890 } 12891 SCTP_STAT_INCR(sctps_naglesent); 12892 nagle_applies = 0; 12893 } 12894 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_BLK_LOGGING_ENABLE) { 12895 12896 sctp_misc_ints(SCTP_CWNDLOG_PRESEND, queue_only_for_init, queue_only, 12897 nagle_applies, un_sent); 12898 sctp_misc_ints(SCTP_CWNDLOG_PRESEND, stcb->asoc.total_output_queue_size, 12899 stcb->asoc.total_flight, 12900 stcb->asoc.chunks_on_out_queue, stcb->asoc.total_flight_count); 12901 } 12902 if (queue_only_for_init) 12903 queue_only_for_init = 0; 12904 if ((queue_only == 0) && (nagle_applies == 0)) { 12905 /*- 12906 * need to start chunk output 12907 * before blocking.. note that if 12908 * a lock is already applied, then 12909 * the input via the net is happening 12910 * and I don't need to start output :-D 12911 */ 12912 if (hold_tcblock == 0) { 12913 if (SCTP_TCB_TRYLOCK(stcb)) { 12914 hold_tcblock = 1; 12915 sctp_chunk_output(inp, 12916 stcb, 12917 SCTP_OUTPUT_FROM_USR_SEND, SCTP_SO_LOCKED); 12918 } 12919 } else { 12920 sctp_chunk_output(inp, 12921 stcb, 12922 SCTP_OUTPUT_FROM_USR_SEND, SCTP_SO_LOCKED); 12923 } 12924 if (hold_tcblock == 1) { 12925 SCTP_TCB_UNLOCK(stcb); 12926 hold_tcblock = 0; 12927 } 12928 } 12929 SOCKBUF_LOCK(&so->so_snd); 12930 /*- 12931 * This is a bit strange, but I think it will 12932 * work. The total_output_queue_size is locked and 12933 * protected by the TCB_LOCK, which we just released. 12934 * There is a race that can occur between releasing it 12935 * above, and me getting the socket lock, where sacks 12936 * come in but we have not put the SB_WAIT on the 12937 * so_snd buffer to get the wakeup. After the LOCK 12938 * is applied the sack_processing will also need to 12939 * LOCK the so->so_snd to do the actual sowwakeup(). So 12940 * once we have the socket buffer lock if we recheck the 12941 * size we KNOW we will get to sleep safely with the 12942 * wakeup flag in place. 12943 */ 12944 if (SCTP_SB_LIMIT_SND(so) <= (stcb->asoc.total_output_queue_size + 12945 min(SCTP_BASE_SYSCTL(sctp_add_more_threshold), SCTP_SB_LIMIT_SND(so)))) { 12946 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_BLK_LOGGING_ENABLE) { 12947 sctp_log_block(SCTP_BLOCK_LOG_INTO_BLK, 12948 asoc, uio->uio_resid); 12949 } 12950 be.error = 0; 12951 stcb->block_entry = &be; 12952 error = sbwait(&so->so_snd); 12953 stcb->block_entry = NULL; 12954 12955 if (error || so->so_error || be.error) { 12956 if (error == 0) { 12957 if (so->so_error) 12958 error = so->so_error; 12959 if (be.error) { 12960 error = be.error; 12961 } 12962 } 12963 SOCKBUF_UNLOCK(&so->so_snd); 12964 goto out_unlocked; 12965 } 12966 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_BLK_LOGGING_ENABLE) { 12967 sctp_log_block(SCTP_BLOCK_LOG_OUTOF_BLK, 12968 asoc, stcb->asoc.total_output_queue_size); 12969 } 12970 } 12971 SOCKBUF_UNLOCK(&so->so_snd); 12972 if (stcb->asoc.state & SCTP_STATE_ABOUT_TO_BE_FREED) { 12973 goto out_unlocked; 12974 } 12975 } 12976 SCTP_TCB_SEND_LOCK(stcb); 12977 if (sp) { 12978 if (sp->msg_is_complete == 0) { 12979 strm->last_msg_incomplete = 1; 12980 asoc->stream_locked = 1; 12981 asoc->stream_locked_on = srcv->sinfo_stream; 12982 } else { 12983 sp->sender_all_done = 1; 12984 strm->last_msg_incomplete = 0; 12985 asoc->stream_locked = 0; 12986 } 12987 } else { 12988 SCTP_PRINTF("Huh no sp TSNH?\n"); 12989 strm->last_msg_incomplete = 0; 12990 asoc->stream_locked = 0; 12991 } 12992 SCTP_TCB_SEND_UNLOCK(stcb); 12993 if (uio->uio_resid == 0) { 12994 got_all_of_the_send = 1; 12995 } 12996 } else { 12997 /* We send in a 0, since we do NOT have any locks */ 12998 error = sctp_msg_append(stcb, net, top, srcv, 0); 12999 top = NULL; 13000 if (srcv->sinfo_flags & SCTP_EOF) { 13001 /* 13002 * This should only happen for Panda for the mbuf 13003 * send case, which does NOT yet support EEOR mode. 13004 * Thus, we can just set this flag to do the proper 13005 * EOF handling. 13006 */ 13007 got_all_of_the_send = 1; 13008 } 13009 } 13010 if (error) { 13011 goto out; 13012 } 13013 dataless_eof: 13014 /* EOF thing ? */ 13015 if ((srcv->sinfo_flags & SCTP_EOF) && 13016 (got_all_of_the_send == 1)) { 13017 int cnt; 13018 13019 SCTP_STAT_INCR(sctps_sends_with_eof); 13020 error = 0; 13021 if (hold_tcblock == 0) { 13022 SCTP_TCB_LOCK(stcb); 13023 hold_tcblock = 1; 13024 } 13025 cnt = sctp_is_there_unsent_data(stcb, SCTP_SO_LOCKED); 13026 if (TAILQ_EMPTY(&asoc->send_queue) && 13027 TAILQ_EMPTY(&asoc->sent_queue) && 13028 (cnt == 0)) { 13029 if (asoc->locked_on_sending) { 13030 goto abort_anyway; 13031 } 13032 /* there is nothing queued to send, so I'm done... */ 13033 if ((SCTP_GET_STATE(asoc) != SCTP_STATE_SHUTDOWN_SENT) && 13034 (SCTP_GET_STATE(asoc) != SCTP_STATE_SHUTDOWN_RECEIVED) && 13035 (SCTP_GET_STATE(asoc) != SCTP_STATE_SHUTDOWN_ACK_SENT)) { 13036 struct sctp_nets *netp; 13037 13038 /* only send SHUTDOWN the first time through */ 13039 if (SCTP_GET_STATE(asoc) == SCTP_STATE_OPEN) { 13040 SCTP_STAT_DECR_GAUGE32(sctps_currestab); 13041 } 13042 SCTP_SET_STATE(asoc, SCTP_STATE_SHUTDOWN_SENT); 13043 SCTP_CLEAR_SUBSTATE(asoc, SCTP_STATE_SHUTDOWN_PENDING); 13044 sctp_stop_timers_for_shutdown(stcb); 13045 if (stcb->asoc.alternate) { 13046 netp = stcb->asoc.alternate; 13047 } else { 13048 netp = stcb->asoc.primary_destination; 13049 } 13050 sctp_send_shutdown(stcb, netp); 13051 sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWN, stcb->sctp_ep, stcb, 13052 netp); 13053 sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWNGUARD, stcb->sctp_ep, stcb, 13054 asoc->primary_destination); 13055 } 13056 } else { 13057 /*- 13058 * we still got (or just got) data to send, so set 13059 * SHUTDOWN_PENDING 13060 */ 13061 /*- 13062 * XXX sockets draft says that SCTP_EOF should be 13063 * sent with no data. currently, we will allow user 13064 * data to be sent first and move to 13065 * SHUTDOWN-PENDING 13066 */ 13067 if ((SCTP_GET_STATE(asoc) != SCTP_STATE_SHUTDOWN_SENT) && 13068 (SCTP_GET_STATE(asoc) != SCTP_STATE_SHUTDOWN_RECEIVED) && 13069 (SCTP_GET_STATE(asoc) != SCTP_STATE_SHUTDOWN_ACK_SENT)) { 13070 if (hold_tcblock == 0) { 13071 SCTP_TCB_LOCK(stcb); 13072 hold_tcblock = 1; 13073 } 13074 if (asoc->locked_on_sending) { 13075 /* Locked to send out the data */ 13076 struct sctp_stream_queue_pending *sp; 13077 13078 sp = TAILQ_LAST(&asoc->locked_on_sending->outqueue, sctp_streamhead); 13079 if (sp) { 13080 if ((sp->length == 0) && (sp->msg_is_complete == 0)) 13081 asoc->state |= SCTP_STATE_PARTIAL_MSG_LEFT; 13082 } 13083 } 13084 asoc->state |= SCTP_STATE_SHUTDOWN_PENDING; 13085 if (TAILQ_EMPTY(&asoc->send_queue) && 13086 TAILQ_EMPTY(&asoc->sent_queue) && 13087 (asoc->state & SCTP_STATE_PARTIAL_MSG_LEFT)) { 13088 abort_anyway: 13089 if (free_cnt_applied) { 13090 atomic_add_int(&stcb->asoc.refcnt, -1); 13091 free_cnt_applied = 0; 13092 } 13093 sctp_abort_an_association(stcb->sctp_ep, stcb, 13094 NULL, SCTP_SO_LOCKED); 13095 /* 13096 * now relock the stcb so everything 13097 * is sane 13098 */ 13099 hold_tcblock = 0; 13100 stcb = NULL; 13101 goto out; 13102 } 13103 sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWNGUARD, stcb->sctp_ep, stcb, 13104 asoc->primary_destination); 13105 sctp_feature_off(inp, SCTP_PCB_FLAGS_NODELAY); 13106 } 13107 } 13108 } 13109 skip_out_eof: 13110 if (!TAILQ_EMPTY(&stcb->asoc.control_send_queue)) { 13111 some_on_control = 1; 13112 } 13113 if (queue_only_for_init) { 13114 if (hold_tcblock == 0) { 13115 SCTP_TCB_LOCK(stcb); 13116 hold_tcblock = 1; 13117 } 13118 if (SCTP_GET_STATE(&stcb->asoc) == SCTP_STATE_OPEN) { 13119 /* a collision took us forward? */ 13120 queue_only = 0; 13121 } else { 13122 sctp_send_initiate(inp, stcb, SCTP_SO_LOCKED); 13123 SCTP_SET_STATE(&stcb->asoc, SCTP_STATE_COOKIE_WAIT); 13124 queue_only = 1; 13125 } 13126 } 13127 if ((net->flight_size > net->cwnd) && 13128 (stcb->asoc.sctp_cmt_on_off == 0)) { 13129 SCTP_STAT_INCR(sctps_send_cwnd_avoid); 13130 queue_only = 1; 13131 } else if (asoc->ifp_had_enobuf) { 13132 SCTP_STAT_INCR(sctps_ifnomemqueued); 13133 if (net->flight_size > (2 * net->mtu)) { 13134 queue_only = 1; 13135 } 13136 asoc->ifp_had_enobuf = 0; 13137 } 13138 un_sent = ((stcb->asoc.total_output_queue_size - stcb->asoc.total_flight) + 13139 (stcb->asoc.stream_queue_cnt * sizeof(struct sctp_data_chunk))); 13140 if ((sctp_is_feature_off(inp, SCTP_PCB_FLAGS_NODELAY)) && 13141 (stcb->asoc.total_flight > 0) && 13142 (stcb->asoc.stream_queue_cnt < SCTP_MAX_DATA_BUNDLING) && 13143 (un_sent < (int)(stcb->asoc.smallest_mtu - SCTP_MIN_OVERHEAD))) { 13144 /*- 13145 * Ok, Nagle is set on and we have data outstanding. 13146 * Don't send anything and let SACKs drive out the 13147 * data unless wen have a "full" segment to send. 13148 */ 13149 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_NAGLE_LOGGING_ENABLE) { 13150 sctp_log_nagle_event(stcb, SCTP_NAGLE_APPLIED); 13151 } 13152 SCTP_STAT_INCR(sctps_naglequeued); 13153 nagle_applies = 1; 13154 } else { 13155 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_NAGLE_LOGGING_ENABLE) { 13156 if (sctp_is_feature_off(inp, SCTP_PCB_FLAGS_NODELAY)) 13157 sctp_log_nagle_event(stcb, SCTP_NAGLE_SKIPPED); 13158 } 13159 SCTP_STAT_INCR(sctps_naglesent); 13160 nagle_applies = 0; 13161 } 13162 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_BLK_LOGGING_ENABLE) { 13163 sctp_misc_ints(SCTP_CWNDLOG_PRESEND, queue_only_for_init, queue_only, 13164 nagle_applies, un_sent); 13165 sctp_misc_ints(SCTP_CWNDLOG_PRESEND, stcb->asoc.total_output_queue_size, 13166 stcb->asoc.total_flight, 13167 stcb->asoc.chunks_on_out_queue, stcb->asoc.total_flight_count); 13168 } 13169 if ((queue_only == 0) && (nagle_applies == 0) && (stcb->asoc.peers_rwnd && un_sent)) { 13170 /* we can attempt to send too. */ 13171 if (hold_tcblock == 0) { 13172 /* 13173 * If there is activity recv'ing sacks no need to 13174 * send 13175 */ 13176 if (SCTP_TCB_TRYLOCK(stcb)) { 13177 sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_USR_SEND, SCTP_SO_LOCKED); 13178 hold_tcblock = 1; 13179 } 13180 } else { 13181 sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_USR_SEND, SCTP_SO_LOCKED); 13182 } 13183 } else if ((queue_only == 0) && 13184 (stcb->asoc.peers_rwnd == 0) && 13185 (stcb->asoc.total_flight == 0)) { 13186 /* We get to have a probe outstanding */ 13187 if (hold_tcblock == 0) { 13188 hold_tcblock = 1; 13189 SCTP_TCB_LOCK(stcb); 13190 } 13191 sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_USR_SEND, SCTP_SO_LOCKED); 13192 } else if (some_on_control) { 13193 int num_out, reason, frag_point; 13194 13195 /* Here we do control only */ 13196 if (hold_tcblock == 0) { 13197 hold_tcblock = 1; 13198 SCTP_TCB_LOCK(stcb); 13199 } 13200 frag_point = sctp_get_frag_point(stcb, &stcb->asoc); 13201 (void)sctp_med_chunk_output(inp, stcb, &stcb->asoc, &num_out, 13202 &reason, 1, 1, &now, &now_filled, frag_point, SCTP_SO_LOCKED); 13203 } 13204 SCTPDBG(SCTP_DEBUG_OUTPUT1, "USR Send complete qo:%d prw:%d unsent:%d tf:%d cooq:%d toqs:%d err:%d\n", 13205 queue_only, stcb->asoc.peers_rwnd, un_sent, 13206 stcb->asoc.total_flight, stcb->asoc.chunks_on_out_queue, 13207 stcb->asoc.total_output_queue_size, error); 13208 13209 out: 13210 out_unlocked: 13211 13212 if (local_soresv && stcb) { 13213 atomic_subtract_int(&stcb->asoc.sb_send_resv, sndlen); 13214 } 13215 if (create_lock_applied) { 13216 SCTP_ASOC_CREATE_UNLOCK(inp); 13217 } 13218 if ((stcb) && hold_tcblock) { 13219 SCTP_TCB_UNLOCK(stcb); 13220 } 13221 if (stcb && free_cnt_applied) { 13222 atomic_add_int(&stcb->asoc.refcnt, -1); 13223 } 13224 #ifdef INVARIANTS 13225 if (stcb) { 13226 if (mtx_owned(&stcb->tcb_mtx)) { 13227 panic("Leaving with tcb mtx owned?"); 13228 } 13229 if (mtx_owned(&stcb->tcb_send_mtx)) { 13230 panic("Leaving with tcb send mtx owned?"); 13231 } 13232 } 13233 #endif 13234 #ifdef INVARIANTS 13235 if (inp) { 13236 sctp_validate_no_locks(inp); 13237 } else { 13238 SCTP_PRINTF("Warning - inp is NULL so cant validate locks\n"); 13239 } 13240 #endif 13241 if (top) { 13242 sctp_m_freem(top); 13243 } 13244 if (control) { 13245 sctp_m_freem(control); 13246 } 13247 return (error); 13248 } 13249 13250 13251 /* 13252 * generate an AUTHentication chunk, if required 13253 */ 13254 struct mbuf * 13255 sctp_add_auth_chunk(struct mbuf *m, struct mbuf **m_end, 13256 struct sctp_auth_chunk **auth_ret, uint32_t * offset, 13257 struct sctp_tcb *stcb, uint8_t chunk) 13258 { 13259 struct mbuf *m_auth; 13260 struct sctp_auth_chunk *auth; 13261 int chunk_len; 13262 struct mbuf *cn; 13263 13264 if ((m_end == NULL) || (auth_ret == NULL) || (offset == NULL) || 13265 (stcb == NULL)) 13266 return (m); 13267 13268 /* sysctl disabled auth? */ 13269 if (SCTP_BASE_SYSCTL(sctp_auth_disable)) 13270 return (m); 13271 13272 /* peer doesn't do auth... */ 13273 if (!stcb->asoc.peer_supports_auth) { 13274 return (m); 13275 } 13276 /* does the requested chunk require auth? */ 13277 if (!sctp_auth_is_required_chunk(chunk, stcb->asoc.peer_auth_chunks)) { 13278 return (m); 13279 } 13280 m_auth = sctp_get_mbuf_for_msg(sizeof(*auth), 0, M_DONTWAIT, 1, MT_HEADER); 13281 if (m_auth == NULL) { 13282 /* no mbuf's */ 13283 return (m); 13284 } 13285 /* reserve some space if this will be the first mbuf */ 13286 if (m == NULL) 13287 SCTP_BUF_RESV_UF(m_auth, SCTP_MIN_OVERHEAD); 13288 /* fill in the AUTH chunk details */ 13289 auth = mtod(m_auth, struct sctp_auth_chunk *); 13290 bzero(auth, sizeof(*auth)); 13291 auth->ch.chunk_type = SCTP_AUTHENTICATION; 13292 auth->ch.chunk_flags = 0; 13293 chunk_len = sizeof(*auth) + 13294 sctp_get_hmac_digest_len(stcb->asoc.peer_hmac_id); 13295 auth->ch.chunk_length = htons(chunk_len); 13296 auth->hmac_id = htons(stcb->asoc.peer_hmac_id); 13297 /* key id and hmac digest will be computed and filled in upon send */ 13298 13299 /* save the offset where the auth was inserted into the chain */ 13300 *offset = 0; 13301 for (cn = m; cn; cn = SCTP_BUF_NEXT(cn)) { 13302 *offset += SCTP_BUF_LEN(cn); 13303 } 13304 13305 /* update length and return pointer to the auth chunk */ 13306 SCTP_BUF_LEN(m_auth) = chunk_len; 13307 m = sctp_copy_mbufchain(m_auth, m, m_end, 1, chunk_len, 0); 13308 if (auth_ret != NULL) 13309 *auth_ret = auth; 13310 13311 return (m); 13312 } 13313 13314 #ifdef INET6 13315 int 13316 sctp_v6src_match_nexthop(struct sockaddr_in6 *src6, sctp_route_t * ro) 13317 { 13318 struct nd_prefix *pfx = NULL; 13319 struct nd_pfxrouter *pfxrtr = NULL; 13320 struct sockaddr_in6 gw6; 13321 13322 if (ro == NULL || ro->ro_rt == NULL || src6->sin6_family != AF_INET6) 13323 return (0); 13324 13325 /* get prefix entry of address */ 13326 LIST_FOREACH(pfx, &MODULE_GLOBAL(nd_prefix), ndpr_entry) { 13327 if (pfx->ndpr_stateflags & NDPRF_DETACHED) 13328 continue; 13329 if (IN6_ARE_MASKED_ADDR_EQUAL(&pfx->ndpr_prefix.sin6_addr, 13330 &src6->sin6_addr, &pfx->ndpr_mask)) 13331 break; 13332 } 13333 /* no prefix entry in the prefix list */ 13334 if (pfx == NULL) { 13335 SCTPDBG(SCTP_DEBUG_OUTPUT2, "No prefix entry for "); 13336 SCTPDBG_ADDR(SCTP_DEBUG_OUTPUT2, (struct sockaddr *)src6); 13337 return (0); 13338 } 13339 SCTPDBG(SCTP_DEBUG_OUTPUT2, "v6src_match_nexthop(), Prefix entry is "); 13340 SCTPDBG_ADDR(SCTP_DEBUG_OUTPUT2, (struct sockaddr *)src6); 13341 13342 /* search installed gateway from prefix entry */ 13343 LIST_FOREACH(pfxrtr, &pfx->ndpr_advrtrs, pfr_entry) { 13344 memset(&gw6, 0, sizeof(struct sockaddr_in6)); 13345 gw6.sin6_family = AF_INET6; 13346 gw6.sin6_len = sizeof(struct sockaddr_in6); 13347 memcpy(&gw6.sin6_addr, &pfxrtr->router->rtaddr, 13348 sizeof(struct in6_addr)); 13349 SCTPDBG(SCTP_DEBUG_OUTPUT2, "prefix router is "); 13350 SCTPDBG_ADDR(SCTP_DEBUG_OUTPUT2, (struct sockaddr *)&gw6); 13351 SCTPDBG(SCTP_DEBUG_OUTPUT2, "installed router is "); 13352 SCTPDBG_ADDR(SCTP_DEBUG_OUTPUT2, ro->ro_rt->rt_gateway); 13353 if (sctp_cmpaddr((struct sockaddr *)&gw6, 13354 ro->ro_rt->rt_gateway)) { 13355 SCTPDBG(SCTP_DEBUG_OUTPUT2, "pfxrouter is installed\n"); 13356 return (1); 13357 } 13358 } 13359 SCTPDBG(SCTP_DEBUG_OUTPUT2, "pfxrouter is not installed\n"); 13360 return (0); 13361 } 13362 13363 #endif 13364 13365 int 13366 sctp_v4src_match_nexthop(struct sctp_ifa *sifa, sctp_route_t * ro) 13367 { 13368 #ifdef INET 13369 struct sockaddr_in *sin, *mask; 13370 struct ifaddr *ifa; 13371 struct in_addr srcnetaddr, gwnetaddr; 13372 13373 if (ro == NULL || ro->ro_rt == NULL || 13374 sifa->address.sa.sa_family != AF_INET) { 13375 return (0); 13376 } 13377 ifa = (struct ifaddr *)sifa->ifa; 13378 mask = (struct sockaddr_in *)(ifa->ifa_netmask); 13379 sin = (struct sockaddr_in *)&sifa->address.sin; 13380 srcnetaddr.s_addr = (sin->sin_addr.s_addr & mask->sin_addr.s_addr); 13381 SCTPDBG(SCTP_DEBUG_OUTPUT1, "match_nexthop4: src address is "); 13382 SCTPDBG_ADDR(SCTP_DEBUG_OUTPUT2, &sifa->address.sa); 13383 SCTPDBG(SCTP_DEBUG_OUTPUT1, "network address is %x\n", srcnetaddr.s_addr); 13384 13385 sin = (struct sockaddr_in *)ro->ro_rt->rt_gateway; 13386 gwnetaddr.s_addr = (sin->sin_addr.s_addr & mask->sin_addr.s_addr); 13387 SCTPDBG(SCTP_DEBUG_OUTPUT1, "match_nexthop4: nexthop is "); 13388 SCTPDBG_ADDR(SCTP_DEBUG_OUTPUT2, ro->ro_rt->rt_gateway); 13389 SCTPDBG(SCTP_DEBUG_OUTPUT1, "network address is %x\n", gwnetaddr.s_addr); 13390 if (srcnetaddr.s_addr == gwnetaddr.s_addr) { 13391 return (1); 13392 } 13393 #endif 13394 return (0); 13395 }
Cache object: d946562f55c4d12994a7e459a81ec0f0
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]