1#!/bin/bash 2# SPDX-License-Identifier: GPL-2.0 3 4# Double quotes to prevent globbing and word splitting is recommended in new 5# code but we accept it, especially because there were too many before having 6# address all other issues detected by shellcheck. 7#shellcheck disable=SC2086 8 9# ShellCheck incorrectly believes that most of the code here is unreachable 10# because it's invoked by variable name, see how the "tests" array is used 11#shellcheck disable=SC2317 12 13. "$(dirname "${0}")/mptcp_lib.sh" 14 15ret=0 16sin="" 17sinfail="" 18sout="" 19cin="" 20cinfail="" 21cinsent="" 22tmpfile="" 23cout="" 24capout="" 25ns1="" 26ns2="" 27ksft_skip=4 28iptables="iptables" 29ip6tables="ip6tables" 30timeout_poll=30 31timeout_test=$((timeout_poll * 2 + 1)) 32capture=0 33checksum=0 34ip_mptcp=0 35check_invert=0 36validate_checksum=0 37init=0 38evts_ns1="" 39evts_ns2="" 40evts_ns1_pid=0 41evts_ns2_pid=0 42last_test_failed=0 43last_test_skipped=0 44last_test_ignored=1 45 46declare -A all_tests 47declare -a only_tests_ids 48declare -a only_tests_names 49declare -A failed_tests 50TEST_COUNT=0 51TEST_NAME="" 52nr_blank=6 53 54# These var are used only in some tests, make sure they are not already set 55unset FAILING_LINKS 56unset test_linkfail 57unset addr_nr_ns1 58unset addr_nr_ns2 59unset cestab_ns1 60unset cestab_ns2 61unset sflags 62unset fastclose 63unset fullmesh 64unset speed 65 66# generated using "nfbpf_compile '(ip && (ip[54] & 0xf0) == 0x30) || 67# (ip6 && (ip6[74] & 0xf0) == 0x30)'" 68CBPF_MPTCP_SUBOPTION_ADD_ADDR="14, 69 48 0 0 0, 70 84 0 0 240, 71 21 0 3 64, 72 48 0 0 54, 73 84 0 0 240, 74 21 6 7 48, 75 48 0 0 0, 76 84 0 0 240, 77 21 0 4 96, 78 48 0 0 74, 79 84 0 0 240, 80 21 0 1 48, 81 6 0 0 65535, 82 6 0 0 0" 83 84init_partial() 85{ 86 capout=$(mktemp) 87 88 local sec rndh 89 sec=$(date +%s) 90 rndh=$(printf %x $sec)-$(mktemp -u XXXXXX) 91 92 ns1="ns1-$rndh" 93 ns2="ns2-$rndh" 94 95 local netns 96 for netns in "$ns1" "$ns2"; do 97 ip netns add $netns || exit $ksft_skip 98 ip -net $netns link set lo up 99 ip netns exec $netns sysctl -q net.mptcp.enabled=1 100 ip netns exec $netns sysctl -q net.mptcp.pm_type=0 2>/dev/null || true 101 ip netns exec $netns sysctl -q net.ipv4.conf.all.rp_filter=0 102 ip netns exec $netns sysctl -q net.ipv4.conf.default.rp_filter=0 103 if [ $checksum -eq 1 ]; then 104 ip netns exec $netns sysctl -q net.mptcp.checksum_enabled=1 105 fi 106 done 107 108 check_invert=0 109 validate_checksum=$checksum 110 111 # ns1 ns2 112 # ns1eth1 ns2eth1 113 # ns1eth2 ns2eth2 114 # ns1eth3 ns2eth3 115 # ns1eth4 ns2eth4 116 117 local i 118 for i in $(seq 1 4); do 119 ip link add ns1eth$i netns "$ns1" type veth peer name ns2eth$i netns "$ns2" 120 ip -net "$ns1" addr add 10.0.$i.1/24 dev ns1eth$i 121 ip -net "$ns1" addr add dead:beef:$i::1/64 dev ns1eth$i nodad 122 ip -net "$ns1" link set ns1eth$i up 123 124 ip -net "$ns2" addr add 10.0.$i.2/24 dev ns2eth$i 125 ip -net "$ns2" addr add dead:beef:$i::2/64 dev ns2eth$i nodad 126 ip -net "$ns2" link set ns2eth$i up 127 128 # let $ns2 reach any $ns1 address from any interface 129 ip -net "$ns2" route add default via 10.0.$i.1 dev ns2eth$i metric 10$i 130 ip -net "$ns2" route add default via dead:beef:$i::1 dev ns2eth$i metric 10$i 131 done 132} 133 134init_shapers() 135{ 136 local i 137 for i in $(seq 1 4); do 138 tc -n $ns1 qdisc add dev ns1eth$i root netem rate 20mbit delay 1 139 tc -n $ns2 qdisc add dev ns2eth$i root netem rate 20mbit delay 1 140 done 141} 142 143cleanup_partial() 144{ 145 rm -f "$capout" 146 147 local netns 148 for netns in "$ns1" "$ns2"; do 149 ip netns del $netns 150 rm -f /tmp/$netns.{nstat,out} 151 done 152} 153 154check_tools() 155{ 156 mptcp_lib_check_mptcp 157 mptcp_lib_check_kallsyms 158 159 if ! ip -Version &> /dev/null; then 160 echo "SKIP: Could not run test without ip tool" 161 exit $ksft_skip 162 fi 163 164 # Use the legacy version if available to support old kernel versions 165 if iptables-legacy -V &> /dev/null; then 166 iptables="iptables-legacy" 167 ip6tables="ip6tables-legacy" 168 elif ! iptables -V &> /dev/null; then 169 echo "SKIP: Could not run all tests without iptables tool" 170 exit $ksft_skip 171 elif ! ip6tables -V &> /dev/null; then 172 echo "SKIP: Could not run all tests without ip6tables tool" 173 exit $ksft_skip 174 fi 175} 176 177init() { 178 init=1 179 180 check_tools 181 182 sin=$(mktemp) 183 sout=$(mktemp) 184 cin=$(mktemp) 185 cinsent=$(mktemp) 186 cout=$(mktemp) 187 evts_ns1=$(mktemp) 188 evts_ns2=$(mktemp) 189 190 trap cleanup EXIT 191 192 make_file "$cin" "client" 1 >/dev/null 193 make_file "$sin" "server" 1 >/dev/null 194} 195 196cleanup() 197{ 198 rm -f "$cin" "$cout" "$sinfail" 199 rm -f "$sin" "$sout" "$cinsent" "$cinfail" 200 rm -f "$tmpfile" 201 rm -rf $evts_ns1 $evts_ns2 202 cleanup_partial 203} 204 205print_title() 206{ 207 printf "%03u %s\n" "${TEST_COUNT}" "${TEST_NAME}" 208} 209 210print_check() 211{ 212 printf "%-${nr_blank}s%-36s" " " "${*}" 213} 214 215print_info() 216{ 217 # It can be empty, no need to print anything then 218 [ -z "${1}" ] && return 219 220 mptcp_lib_print_info " Info: ${*}" 221} 222 223print_ok() 224{ 225 mptcp_lib_print_ok "[ ok ]${1:+ ${*}}" 226} 227 228print_fail() 229{ 230 mptcp_lib_print_err "[fail]${1:+ ${*}}" 231} 232 233print_skip() 234{ 235 mptcp_lib_print_warn "[skip]${1:+ ${*}}" 236} 237 238# [ $1: fail msg ] 239mark_as_skipped() 240{ 241 local msg="${1:-"Feature not supported"}" 242 243 mptcp_lib_fail_if_expected_feature "${msg}" 244 245 print_check "${msg}" 246 print_skip 247 248 last_test_skipped=1 249} 250 251# $@: condition 252continue_if() 253{ 254 if ! "${@}"; then 255 mark_as_skipped 256 return 1 257 fi 258} 259 260skip_test() 261{ 262 if [ "${#only_tests_ids[@]}" -eq 0 ] && [ "${#only_tests_names[@]}" -eq 0 ]; then 263 return 1 264 fi 265 266 local i 267 for i in "${only_tests_ids[@]}"; do 268 if [ "${TEST_COUNT}" -eq "${i}" ]; then 269 return 1 270 fi 271 done 272 for i in "${only_tests_names[@]}"; do 273 if [ "${TEST_NAME}" = "${i}" ]; then 274 return 1 275 fi 276 done 277 278 return 0 279} 280 281append_prev_results() 282{ 283 if [ ${last_test_failed} -eq 1 ]; then 284 mptcp_lib_result_fail "${TEST_NAME}" 285 elif [ ${last_test_skipped} -eq 1 ]; then 286 mptcp_lib_result_skip "${TEST_NAME}" 287 elif [ ${last_test_ignored} -ne 1 ]; then 288 mptcp_lib_result_pass "${TEST_NAME}" 289 fi 290 291 last_test_failed=0 292 last_test_skipped=0 293 last_test_ignored=0 294} 295 296# $1: test name 297reset() 298{ 299 append_prev_results 300 301 TEST_NAME="${1}" 302 303 TEST_COUNT=$((TEST_COUNT+1)) 304 305 if skip_test; then 306 last_test_ignored=1 307 return 1 308 fi 309 310 print_title 311 312 if [ "${init}" != "1" ]; then 313 init 314 else 315 cleanup_partial 316 fi 317 318 init_partial 319 320 return 0 321} 322 323# $1: test name ; $2: counter to check 324reset_check_counter() 325{ 326 reset "${1}" || return 1 327 328 local counter="${2}" 329 330 if ! nstat -asz "${counter}" | grep -wq "${counter}"; then 331 mark_as_skipped "counter '${counter}' is not available" 332 return 1 333 fi 334} 335 336# $1: test name 337reset_with_cookies() 338{ 339 reset "${1}" || return 1 340 341 local netns 342 for netns in "$ns1" "$ns2"; do 343 ip netns exec $netns sysctl -q net.ipv4.tcp_syncookies=2 344 done 345} 346 347# $1: test name 348reset_with_add_addr_timeout() 349{ 350 local ip="${2:-4}" 351 local tables 352 353 reset "${1}" || return 1 354 355 tables="${iptables}" 356 if [ $ip -eq 6 ]; then 357 tables="${ip6tables}" 358 fi 359 360 ip netns exec $ns1 sysctl -q net.mptcp.add_addr_timeout=1 361 362 if ! ip netns exec $ns2 $tables -A OUTPUT -p tcp \ 363 -m tcp --tcp-option 30 \ 364 -m bpf --bytecode \ 365 "$CBPF_MPTCP_SUBOPTION_ADD_ADDR" \ 366 -j DROP; then 367 mark_as_skipped "unable to set the 'add addr' rule" 368 return 1 369 fi 370} 371 372# $1: test name 373reset_with_checksum() 374{ 375 local ns1_enable=$1 376 local ns2_enable=$2 377 378 reset "checksum test ${1} ${2}" || return 1 379 380 ip netns exec $ns1 sysctl -q net.mptcp.checksum_enabled=$ns1_enable 381 ip netns exec $ns2 sysctl -q net.mptcp.checksum_enabled=$ns2_enable 382 383 validate_checksum=1 384} 385 386reset_with_allow_join_id0() 387{ 388 local ns1_enable=$2 389 local ns2_enable=$3 390 391 reset "${1}" || return 1 392 393 ip netns exec $ns1 sysctl -q net.mptcp.allow_join_initial_addr_port=$ns1_enable 394 ip netns exec $ns2 sysctl -q net.mptcp.allow_join_initial_addr_port=$ns2_enable 395} 396 397# Modify TCP payload without corrupting the TCP packet 398# 399# This rule inverts a 8-bit word at byte offset 148 for the 2nd TCP ACK packets 400# carrying enough data. 401# Once it is done, the TCP Checksum field is updated so the packet is still 402# considered as valid at the TCP level. 403# Because the MPTCP checksum, covering the TCP options and data, has not been 404# updated, the modification will be detected and an MP_FAIL will be emitted: 405# what we want to validate here without corrupting "random" MPTCP options. 406# 407# To avoid having tc producing this pr_info() message for each TCP ACK packets 408# not carrying enough data: 409# 410# tc action pedit offset 162 out of bounds 411# 412# Netfilter is used to mark packets with enough data. 413setup_fail_rules() 414{ 415 check_invert=1 416 validate_checksum=1 417 local i="$1" 418 local ip="${2:-4}" 419 local tables 420 421 tables="${iptables}" 422 if [ $ip -eq 6 ]; then 423 tables="${ip6tables}" 424 fi 425 426 ip netns exec $ns2 $tables \ 427 -t mangle \ 428 -A OUTPUT \ 429 -o ns2eth$i \ 430 -p tcp \ 431 -m length --length 150:9999 \ 432 -m statistic --mode nth --packet 1 --every 99999 \ 433 -j MARK --set-mark 42 || return ${ksft_skip} 434 435 tc -n $ns2 qdisc add dev ns2eth$i clsact || return ${ksft_skip} 436 tc -n $ns2 filter add dev ns2eth$i egress \ 437 protocol ip prio 1000 \ 438 handle 42 fw \ 439 action pedit munge offset 148 u8 invert \ 440 pipe csum tcp \ 441 index 100 || return ${ksft_skip} 442} 443 444reset_with_fail() 445{ 446 reset_check_counter "${1}" "MPTcpExtInfiniteMapTx" || return 1 447 shift 448 449 ip netns exec $ns1 sysctl -q net.mptcp.checksum_enabled=1 450 ip netns exec $ns2 sysctl -q net.mptcp.checksum_enabled=1 451 452 local rc=0 453 setup_fail_rules "${@}" || rc=$? 454 455 if [ ${rc} -eq ${ksft_skip} ]; then 456 mark_as_skipped "unable to set the 'fail' rules" 457 return 1 458 fi 459} 460 461reset_with_events() 462{ 463 reset "${1}" || return 1 464 465 :> "$evts_ns1" 466 :> "$evts_ns2" 467 ip netns exec $ns1 ./pm_nl_ctl events >> "$evts_ns1" 2>&1 & 468 evts_ns1_pid=$! 469 ip netns exec $ns2 ./pm_nl_ctl events >> "$evts_ns2" 2>&1 & 470 evts_ns2_pid=$! 471} 472 473reset_with_tcp_filter() 474{ 475 reset "${1}" || return 1 476 shift 477 478 local ns="${!1}" 479 local src="${2}" 480 local target="${3}" 481 482 if ! ip netns exec "${ns}" ${iptables} \ 483 -A INPUT \ 484 -s "${src}" \ 485 -p tcp \ 486 -j "${target}"; then 487 mark_as_skipped "unable to set the filter rules" 488 return 1 489 fi 490} 491 492# $1: err msg 493fail_test() 494{ 495 ret=1 496 497 print_fail "${@}" 498 499 # just in case a test is marked twice as failed 500 if [ ${last_test_failed} -eq 0 ]; then 501 failed_tests[${TEST_COUNT}]="${TEST_NAME}" 502 dump_stats 503 last_test_failed=1 504 fi 505} 506 507get_failed_tests_ids() 508{ 509 # sorted 510 local i 511 for i in "${!failed_tests[@]}"; do 512 echo "${i}" 513 done | sort -n 514} 515 516check_transfer() 517{ 518 local in=$1 519 local out=$2 520 local what=$3 521 local bytes=$4 522 local i a b 523 524 local line 525 if [ -n "$bytes" ]; then 526 local out_size 527 # when truncating we must check the size explicitly 528 out_size=$(wc -c $out | awk '{print $1}') 529 if [ $out_size -ne $bytes ]; then 530 fail_test "$what output file has wrong size ($out_size, $bytes)" 531 return 1 532 fi 533 534 # note: BusyBox's "cmp" command doesn't support --bytes 535 tmpfile=$(mktemp) 536 head --bytes="$bytes" "$in" > "$tmpfile" 537 mv "$tmpfile" "$in" 538 head --bytes="$bytes" "$out" > "$tmpfile" 539 mv "$tmpfile" "$out" 540 tmpfile="" 541 fi 542 cmp -l "$in" "$out" | while read -r i a b; do 543 local sum=$((0${a} + 0${b})) 544 if [ $check_invert -eq 0 ] || [ $sum -ne $((0xff)) ]; then 545 fail_test "$what does not match (in, out):" 546 mptcp_lib_print_file_err "$in" 547 mptcp_lib_print_file_err "$out" 548 549 return 1 550 else 551 print_info "$what has inverted byte at ${i}" 552 fi 553 done 554 555 return 0 556} 557 558do_ping() 559{ 560 local listener_ns="$1" 561 local connector_ns="$2" 562 local connect_addr="$3" 563 564 if ! ip netns exec ${connector_ns} ping -q -c 1 $connect_addr >/dev/null; then 565 fail_test "$listener_ns -> $connect_addr connectivity" 566 fi 567} 568 569link_failure() 570{ 571 local ns="$1" 572 573 if [ -z "$FAILING_LINKS" ]; then 574 l=$((RANDOM%4)) 575 FAILING_LINKS=$((l+1)) 576 fi 577 578 local l 579 for l in $FAILING_LINKS; do 580 local veth="ns1eth$l" 581 ip -net "$ns" link set "$veth" down 582 done 583} 584 585rm_addr_count() 586{ 587 mptcp_lib_get_counter "${1}" "MPTcpExtRmAddr" 588} 589 590# $1: ns, $2: old rm_addr counter in $ns 591wait_rm_addr() 592{ 593 local ns="${1}" 594 local old_cnt="${2}" 595 local cnt 596 597 local i 598 for i in $(seq 10); do 599 cnt=$(rm_addr_count ${ns}) 600 [ "$cnt" = "${old_cnt}" ] || break 601 sleep 0.1 602 done 603} 604 605rm_sf_count() 606{ 607 mptcp_lib_get_counter "${1}" "MPTcpExtRmSubflow" 608} 609 610# $1: ns, $2: old rm_sf counter in $ns 611wait_rm_sf() 612{ 613 local ns="${1}" 614 local old_cnt="${2}" 615 local cnt 616 617 local i 618 for i in $(seq 10); do 619 cnt=$(rm_sf_count ${ns}) 620 [ "$cnt" = "${old_cnt}" ] || break 621 sleep 0.1 622 done 623} 624 625wait_mpj() 626{ 627 local ns="${1}" 628 local cnt old_cnt 629 630 old_cnt=$(mptcp_lib_get_counter ${ns} "MPTcpExtMPJoinAckRx") 631 632 local i 633 for i in $(seq 10); do 634 cnt=$(mptcp_lib_get_counter ${ns} "MPTcpExtMPJoinAckRx") 635 [ "$cnt" = "${old_cnt}" ] || break 636 sleep 0.1 637 done 638} 639 640kill_events_pids() 641{ 642 mptcp_lib_kill_wait $evts_ns1_pid 643 mptcp_lib_kill_wait $evts_ns2_pid 644} 645 646pm_nl_set_limits() 647{ 648 local ns=$1 649 local addrs=$2 650 local subflows=$3 651 652 if [ $ip_mptcp -eq 1 ]; then 653 ip -n $ns mptcp limits set add_addr_accepted $addrs subflows $subflows 654 else 655 ip netns exec $ns ./pm_nl_ctl limits $addrs $subflows 656 fi 657} 658 659pm_nl_add_endpoint() 660{ 661 local ns=$1 662 local addr=$2 663 local flags _flags 664 local port _port 665 local dev _dev 666 local id _id 667 local nr=2 668 669 local p 670 for p in "${@}" 671 do 672 if [ $p = "flags" ]; then 673 eval _flags=\$"$nr" 674 [ -n "$_flags" ]; flags="flags $_flags" 675 fi 676 if [ $p = "dev" ]; then 677 eval _dev=\$"$nr" 678 [ -n "$_dev" ]; dev="dev $_dev" 679 fi 680 if [ $p = "id" ]; then 681 eval _id=\$"$nr" 682 [ -n "$_id" ]; id="id $_id" 683 fi 684 if [ $p = "port" ]; then 685 eval _port=\$"$nr" 686 [ -n "$_port" ]; port="port $_port" 687 fi 688 689 nr=$((nr + 1)) 690 done 691 692 if [ $ip_mptcp -eq 1 ]; then 693 ip -n $ns mptcp endpoint add $addr ${_flags//","/" "} $dev $id $port 694 else 695 ip netns exec $ns ./pm_nl_ctl add $addr $flags $dev $id $port 696 fi 697} 698 699pm_nl_del_endpoint() 700{ 701 local ns=$1 702 local id=$2 703 local addr=$3 704 705 if [ $ip_mptcp -eq 1 ]; then 706 [ $id -ne 0 ] && addr='' 707 ip -n $ns mptcp endpoint delete id $id $addr 708 else 709 ip netns exec $ns ./pm_nl_ctl del $id $addr 710 fi 711} 712 713pm_nl_flush_endpoint() 714{ 715 local ns=$1 716 717 if [ $ip_mptcp -eq 1 ]; then 718 ip -n $ns mptcp endpoint flush 719 else 720 ip netns exec $ns ./pm_nl_ctl flush 721 fi 722} 723 724pm_nl_show_endpoints() 725{ 726 local ns=$1 727 728 if [ $ip_mptcp -eq 1 ]; then 729 ip -n $ns mptcp endpoint show 730 else 731 ip netns exec $ns ./pm_nl_ctl dump 732 fi 733} 734 735pm_nl_change_endpoint() 736{ 737 local ns=$1 738 local id=$2 739 local flags=$3 740 741 if [ $ip_mptcp -eq 1 ]; then 742 ip -n $ns mptcp endpoint change id $id ${flags//","/" "} 743 else 744 ip netns exec $ns ./pm_nl_ctl set id $id flags $flags 745 fi 746} 747 748pm_nl_check_endpoint() 749{ 750 local line expected_line 751 local msg="$1" 752 local ns=$2 753 local addr=$3 754 local _flags="" 755 local flags 756 local _port 757 local port 758 local dev 759 local _id 760 local id 761 762 print_check "${msg}" 763 764 shift 3 765 while [ -n "$1" ]; do 766 if [ $1 = "flags" ]; then 767 _flags=$2 768 [ -n "$_flags" ]; flags="flags $_flags" 769 shift 770 elif [ $1 = "dev" ]; then 771 [ -n "$2" ]; dev="dev $1" 772 shift 773 elif [ $1 = "id" ]; then 774 _id=$2 775 [ -n "$_id" ]; id="id $_id" 776 shift 777 elif [ $1 = "port" ]; then 778 _port=$2 779 [ -n "$_port" ]; port=" port $_port" 780 shift 781 fi 782 783 shift 784 done 785 786 if [ -z "$id" ]; then 787 test_fail "bad test - missing endpoint id" 788 return 789 fi 790 791 if [ $ip_mptcp -eq 1 ]; then 792 # get line and trim trailing whitespace 793 line=$(ip -n $ns mptcp endpoint show $id) 794 line="${line% }" 795 # the dump order is: address id flags port dev 796 [ -n "$addr" ] && expected_line="$addr" 797 expected_line="$expected_line $id" 798 [ -n "$_flags" ] && expected_line="$expected_line ${_flags//","/" "}" 799 [ -n "$dev" ] && expected_line="$expected_line $dev" 800 [ -n "$port" ] && expected_line="$expected_line $port" 801 else 802 line=$(ip netns exec $ns ./pm_nl_ctl get $_id) 803 # the dump order is: id flags dev address port 804 expected_line="$id" 805 [ -n "$flags" ] && expected_line="$expected_line $flags" 806 [ -n "$dev" ] && expected_line="$expected_line $dev" 807 [ -n "$addr" ] && expected_line="$expected_line $addr" 808 [ -n "$_port" ] && expected_line="$expected_line $_port" 809 fi 810 if [ "$line" = "$expected_line" ]; then 811 print_ok 812 else 813 fail_test "expected '$expected_line' found '$line'" 814 fi 815} 816 817pm_nl_set_endpoint() 818{ 819 local listener_ns="$1" 820 local connector_ns="$2" 821 local connect_addr="$3" 822 823 local addr_nr_ns1=${addr_nr_ns1:-0} 824 local addr_nr_ns2=${addr_nr_ns2:-0} 825 local sflags=${sflags:-""} 826 local fullmesh=${fullmesh:-""} 827 828 local flags="subflow" 829 if [ -n "${fullmesh}" ]; then 830 flags="${flags},fullmesh" 831 addr_nr_ns2=${fullmesh} 832 fi 833 834 # let the mptcp subflow be established in background before 835 # do endpoint manipulation 836 if [ $addr_nr_ns1 != "0" ] || [ $addr_nr_ns2 != "0" ]; then 837 sleep 1 838 fi 839 840 if [ $addr_nr_ns1 -gt 0 ]; then 841 local counter=2 842 local add_nr_ns1=${addr_nr_ns1} 843 local id=10 844 while [ $add_nr_ns1 -gt 0 ]; do 845 local addr 846 if mptcp_lib_is_v6 "${connect_addr}"; then 847 addr="dead:beef:$counter::1" 848 else 849 addr="10.0.$counter.1" 850 fi 851 pm_nl_add_endpoint $ns1 $addr flags signal 852 counter=$((counter + 1)) 853 add_nr_ns1=$((add_nr_ns1 - 1)) 854 id=$((id + 1)) 855 done 856 elif [ $addr_nr_ns1 -lt 0 ]; then 857 local rm_nr_ns1=$((-addr_nr_ns1)) 858 if [ $rm_nr_ns1 -lt 8 ]; then 859 local counter=0 860 local line 861 pm_nl_show_endpoints ${listener_ns} | while read -r line; do 862 # shellcheck disable=SC2206 # we do want to split per word 863 local arr=($line) 864 local nr=0 865 866 local i 867 for i in "${arr[@]}"; do 868 if [ $i = "id" ]; then 869 if [ $counter -eq $rm_nr_ns1 ]; then 870 break 871 fi 872 id=${arr[$nr+1]} 873 rm_addr=$(rm_addr_count ${connector_ns}) 874 pm_nl_del_endpoint ${listener_ns} $id 875 wait_rm_addr ${connector_ns} ${rm_addr} 876 counter=$((counter + 1)) 877 fi 878 nr=$((nr + 1)) 879 done 880 done 881 elif [ $rm_nr_ns1 -eq 8 ]; then 882 pm_nl_flush_endpoint ${listener_ns} 883 elif [ $rm_nr_ns1 -eq 9 ]; then 884 pm_nl_del_endpoint ${listener_ns} 0 ${connect_addr} 885 fi 886 fi 887 888 # if newly added endpoints must be deleted, give the background msk 889 # some time to created them 890 [ $addr_nr_ns1 -gt 0 ] && [ $addr_nr_ns2 -lt 0 ] && sleep 1 891 892 if [ $addr_nr_ns2 -gt 0 ]; then 893 local add_nr_ns2=${addr_nr_ns2} 894 local counter=3 895 local id=20 896 while [ $add_nr_ns2 -gt 0 ]; do 897 local addr 898 if mptcp_lib_is_v6 "${connect_addr}"; then 899 addr="dead:beef:$counter::2" 900 else 901 addr="10.0.$counter.2" 902 fi 903 pm_nl_add_endpoint $ns2 $addr flags $flags 904 counter=$((counter + 1)) 905 add_nr_ns2=$((add_nr_ns2 - 1)) 906 id=$((id + 1)) 907 done 908 elif [ $addr_nr_ns2 -lt 0 ]; then 909 local rm_nr_ns2=$((-addr_nr_ns2)) 910 if [ $rm_nr_ns2 -lt 8 ]; then 911 local counter=0 912 local line 913 pm_nl_show_endpoints ${connector_ns} | while read -r line; do 914 # shellcheck disable=SC2206 # we do want to split per word 915 local arr=($line) 916 local nr=0 917 918 local i 919 for i in "${arr[@]}"; do 920 if [ $i = "id" ]; then 921 if [ $counter -eq $rm_nr_ns2 ]; then 922 break 923 fi 924 local id rm_addr 925 # rm_addr are serialized, allow the previous one to 926 # complete 927 id=${arr[$nr+1]} 928 rm_addr=$(rm_addr_count ${listener_ns}) 929 pm_nl_del_endpoint ${connector_ns} $id 930 wait_rm_addr ${listener_ns} ${rm_addr} 931 counter=$((counter + 1)) 932 fi 933 nr=$((nr + 1)) 934 done 935 done 936 elif [ $rm_nr_ns2 -eq 8 ]; then 937 pm_nl_flush_endpoint ${connector_ns} 938 elif [ $rm_nr_ns2 -eq 9 ]; then 939 local addr 940 if mptcp_lib_is_v6 "${connect_addr}"; then 941 addr="dead:beef:1::2" 942 else 943 addr="10.0.1.2" 944 fi 945 pm_nl_del_endpoint ${connector_ns} 0 $addr 946 fi 947 fi 948 949 if [ -n "${sflags}" ]; then 950 sleep 1 951 952 local netns 953 for netns in "$ns1" "$ns2"; do 954 local line 955 pm_nl_show_endpoints $netns | while read -r line; do 956 # shellcheck disable=SC2206 # we do want to split per word 957 local arr=($line) 958 local nr=0 959 local id 960 961 local i 962 for i in "${arr[@]}"; do 963 if [ $i = "id" ]; then 964 id=${arr[$nr+1]} 965 fi 966 nr=$((nr + 1)) 967 done 968 pm_nl_change_endpoint $netns $id $sflags 969 done 970 done 971 fi 972} 973 974chk_cestab_nr() 975{ 976 local ns=$1 977 local cestab=$2 978 local count 979 980 print_check "cestab $cestab" 981 count=$(mptcp_lib_get_counter ${ns} "MPTcpExtMPCurrEstab") 982 if [ -z "$count" ]; then 983 print_skip 984 elif [ "$count" != "$cestab" ]; then 985 fail_test "got $count current establish[s] expected $cestab" 986 else 987 print_ok 988 fi 989} 990 991# $1 namespace 1, $2 namespace 2 992check_cestab() 993{ 994 if [ -n "${cestab_ns1}" ]; then 995 chk_cestab_nr ${1} ${cestab_ns1} 996 fi 997 if [ -n "${cestab_ns2}" ]; then 998 chk_cestab_nr ${2} ${cestab_ns2} 999 fi 1000} 1001 1002do_transfer() 1003{ 1004 local listener_ns="$1" 1005 local connector_ns="$2" 1006 local cl_proto="$3" 1007 local srv_proto="$4" 1008 local connect_addr="$5" 1009 1010 local port=$((10000 + TEST_COUNT - 1)) 1011 local cappid 1012 local FAILING_LINKS=${FAILING_LINKS:-""} 1013 local fastclose=${fastclose:-""} 1014 local speed=${speed:-"fast"} 1015 1016 :> "$cout" 1017 :> "$sout" 1018 :> "$capout" 1019 1020 if [ $capture -eq 1 ]; then 1021 local capuser 1022 if [ -z $SUDO_USER ] ; then 1023 capuser="" 1024 else 1025 capuser="-Z $SUDO_USER" 1026 fi 1027 1028 capfile=$(printf "mp_join-%02u-%s.pcap" "$TEST_COUNT" "${listener_ns}") 1029 1030 echo "Capturing traffic for test $TEST_COUNT into $capfile" 1031 ip netns exec ${listener_ns} tcpdump -i any -s 65535 -B 32768 $capuser -w $capfile > "$capout" 2>&1 & 1032 cappid=$! 1033 1034 sleep 1 1035 fi 1036 1037 NSTAT_HISTORY=/tmp/${listener_ns}.nstat ip netns exec ${listener_ns} \ 1038 nstat -n 1039 NSTAT_HISTORY=/tmp/${connector_ns}.nstat ip netns exec ${connector_ns} \ 1040 nstat -n 1041 1042 local extra_args 1043 if [ $speed = "fast" ]; then 1044 extra_args="-j" 1045 elif [ $speed = "slow" ]; then 1046 extra_args="-r 50" 1047 elif [ $speed -gt 0 ]; then 1048 extra_args="-r ${speed}" 1049 fi 1050 1051 local extra_cl_args="" 1052 local extra_srv_args="" 1053 local trunc_size="" 1054 if [ -n "${fastclose}" ]; then 1055 if [ ${test_linkfail} -le 1 ]; then 1056 fail_test "fastclose tests need test_linkfail argument" 1057 return 1 1058 fi 1059 1060 # disconnect 1061 trunc_size=${test_linkfail} 1062 local side=${fastclose} 1063 1064 if [ ${side} = "client" ]; then 1065 extra_cl_args="-f ${test_linkfail}" 1066 extra_srv_args="-f -1" 1067 elif [ ${side} = "server" ]; then 1068 extra_srv_args="-f ${test_linkfail}" 1069 extra_cl_args="-f -1" 1070 else 1071 fail_test "wrong/unknown fastclose spec ${side}" 1072 return 1 1073 fi 1074 fi 1075 1076 extra_srv_args="$extra_args $extra_srv_args" 1077 if [ "$test_linkfail" -gt 1 ];then 1078 timeout ${timeout_test} \ 1079 ip netns exec ${listener_ns} \ 1080 ./mptcp_connect -t ${timeout_poll} -l -p $port -s ${srv_proto} \ 1081 $extra_srv_args "::" < "$sinfail" > "$sout" & 1082 else 1083 timeout ${timeout_test} \ 1084 ip netns exec ${listener_ns} \ 1085 ./mptcp_connect -t ${timeout_poll} -l -p $port -s ${srv_proto} \ 1086 $extra_srv_args "::" < "$sin" > "$sout" & 1087 fi 1088 local spid=$! 1089 1090 mptcp_lib_wait_local_port_listen "${listener_ns}" "${port}" 1091 1092 extra_cl_args="$extra_args $extra_cl_args" 1093 if [ "$test_linkfail" -eq 0 ];then 1094 timeout ${timeout_test} \ 1095 ip netns exec ${connector_ns} \ 1096 ./mptcp_connect -t ${timeout_poll} -p $port -s ${cl_proto} \ 1097 $extra_cl_args $connect_addr < "$cin" > "$cout" & 1098 elif [ "$test_linkfail" -eq 1 ] || [ "$test_linkfail" -eq 2 ];then 1099 ( cat "$cinfail" ; sleep 2; link_failure $listener_ns ; cat "$cinfail" ) | \ 1100 tee "$cinsent" | \ 1101 timeout ${timeout_test} \ 1102 ip netns exec ${connector_ns} \ 1103 ./mptcp_connect -t ${timeout_poll} -p $port -s ${cl_proto} \ 1104 $extra_cl_args $connect_addr > "$cout" & 1105 else 1106 tee "$cinsent" < "$cinfail" | \ 1107 timeout ${timeout_test} \ 1108 ip netns exec ${connector_ns} \ 1109 ./mptcp_connect -t ${timeout_poll} -p $port -s ${cl_proto} \ 1110 $extra_cl_args $connect_addr > "$cout" & 1111 fi 1112 local cpid=$! 1113 1114 pm_nl_set_endpoint $listener_ns $connector_ns $connect_addr 1115 check_cestab $listener_ns $connector_ns 1116 1117 wait $cpid 1118 local retc=$? 1119 wait $spid 1120 local rets=$? 1121 1122 if [ $capture -eq 1 ]; then 1123 sleep 1 1124 kill $cappid 1125 fi 1126 1127 NSTAT_HISTORY=/tmp/${listener_ns}.nstat ip netns exec ${listener_ns} \ 1128 nstat | grep Tcp > /tmp/${listener_ns}.out 1129 NSTAT_HISTORY=/tmp/${connector_ns}.nstat ip netns exec ${connector_ns} \ 1130 nstat | grep Tcp > /tmp/${connector_ns}.out 1131 1132 if [ ${rets} -ne 0 ] || [ ${retc} -ne 0 ]; then 1133 fail_test "client exit code $retc, server $rets" 1134 echo -e "\nnetns ${listener_ns} socket stat for ${port}:" 1>&2 1135 ip netns exec ${listener_ns} ss -Menita 1>&2 -o "sport = :$port" 1136 cat /tmp/${listener_ns}.out 1137 echo -e "\nnetns ${connector_ns} socket stat for ${port}:" 1>&2 1138 ip netns exec ${connector_ns} ss -Menita 1>&2 -o "dport = :$port" 1139 cat /tmp/${connector_ns}.out 1140 1141 cat "$capout" 1142 return 1 1143 fi 1144 1145 if [ "$test_linkfail" -gt 1 ];then 1146 check_transfer $sinfail $cout "file received by client" $trunc_size 1147 else 1148 check_transfer $sin $cout "file received by client" $trunc_size 1149 fi 1150 retc=$? 1151 if [ "$test_linkfail" -eq 0 ];then 1152 check_transfer $cin $sout "file received by server" $trunc_size 1153 else 1154 check_transfer $cinsent $sout "file received by server" $trunc_size 1155 fi 1156 rets=$? 1157 1158 if [ $retc -eq 0 ] && [ $rets -eq 0 ];then 1159 cat "$capout" 1160 return 0 1161 fi 1162 1163 cat "$capout" 1164 return 1 1165} 1166 1167make_file() 1168{ 1169 local name=$1 1170 local who=$2 1171 local size=$3 1172 1173 mptcp_lib_make_file $name 1024 $size 1174 1175 print_info "Test file (size $size KB) for $who" 1176} 1177 1178run_tests() 1179{ 1180 local listener_ns="$1" 1181 local connector_ns="$2" 1182 local connect_addr="$3" 1183 1184 local size 1185 local test_linkfail=${test_linkfail:-0} 1186 1187 # The values above 2 are reused to make test files 1188 # with the given sizes (KB) 1189 if [ "$test_linkfail" -gt 2 ]; then 1190 size=$test_linkfail 1191 1192 if [ -z "$cinfail" ]; then 1193 cinfail=$(mktemp) 1194 fi 1195 make_file "$cinfail" "client" $size 1196 # create the input file for the failure test when 1197 # the first failure test run 1198 elif [ "$test_linkfail" -ne 0 ] && [ -z "$cinfail" ]; then 1199 # the client file must be considerably larger 1200 # of the maximum expected cwin value, or the 1201 # link utilization will be not predicable 1202 size=$((RANDOM%2)) 1203 size=$((size+1)) 1204 size=$((size*8192)) 1205 size=$((size + ( RANDOM % 8192) )) 1206 1207 cinfail=$(mktemp) 1208 make_file "$cinfail" "client" $size 1209 fi 1210 1211 if [ "$test_linkfail" -gt 2 ]; then 1212 size=$test_linkfail 1213 1214 if [ -z "$sinfail" ]; then 1215 sinfail=$(mktemp) 1216 fi 1217 make_file "$sinfail" "server" $size 1218 elif [ "$test_linkfail" -eq 2 ] && [ -z "$sinfail" ]; then 1219 size=$((RANDOM%16)) 1220 size=$((size+1)) 1221 size=$((size*2048)) 1222 1223 sinfail=$(mktemp) 1224 make_file "$sinfail" "server" $size 1225 fi 1226 1227 do_transfer ${listener_ns} ${connector_ns} MPTCP MPTCP ${connect_addr} 1228} 1229 1230dump_stats() 1231{ 1232 echo Server ns stats 1233 ip netns exec $ns1 nstat -as | grep Tcp 1234 echo Client ns stats 1235 ip netns exec $ns2 nstat -as | grep Tcp 1236} 1237 1238chk_csum_nr() 1239{ 1240 local csum_ns1=${1:-0} 1241 local csum_ns2=${2:-0} 1242 local count 1243 local extra_msg="" 1244 local allow_multi_errors_ns1=0 1245 local allow_multi_errors_ns2=0 1246 1247 if [[ "${csum_ns1}" = "+"* ]]; then 1248 allow_multi_errors_ns1=1 1249 csum_ns1=${csum_ns1:1} 1250 fi 1251 if [[ "${csum_ns2}" = "+"* ]]; then 1252 allow_multi_errors_ns2=1 1253 csum_ns2=${csum_ns2:1} 1254 fi 1255 1256 print_check "sum" 1257 count=$(mptcp_lib_get_counter ${ns1} "MPTcpExtDataCsumErr") 1258 if [ "$count" != "$csum_ns1" ]; then 1259 extra_msg="$extra_msg ns1=$count" 1260 fi 1261 if [ -z "$count" ]; then 1262 print_skip 1263 elif { [ "$count" != $csum_ns1 ] && [ $allow_multi_errors_ns1 -eq 0 ]; } || 1264 { [ "$count" -lt $csum_ns1 ] && [ $allow_multi_errors_ns1 -eq 1 ]; }; then 1265 fail_test "got $count data checksum error[s] expected $csum_ns1" 1266 else 1267 print_ok 1268 fi 1269 print_check "csum" 1270 count=$(mptcp_lib_get_counter ${ns2} "MPTcpExtDataCsumErr") 1271 if [ "$count" != "$csum_ns2" ]; then 1272 extra_msg="$extra_msg ns2=$count" 1273 fi 1274 if [ -z "$count" ]; then 1275 print_skip 1276 elif { [ "$count" != $csum_ns2 ] && [ $allow_multi_errors_ns2 -eq 0 ]; } || 1277 { [ "$count" -lt $csum_ns2 ] && [ $allow_multi_errors_ns2 -eq 1 ]; }; then 1278 fail_test "got $count data checksum error[s] expected $csum_ns2" 1279 else 1280 print_ok 1281 fi 1282 1283 print_info "$extra_msg" 1284} 1285 1286chk_fail_nr() 1287{ 1288 local fail_tx=$1 1289 local fail_rx=$2 1290 local ns_invert=${3:-""} 1291 local count 1292 local ns_tx=$ns1 1293 local ns_rx=$ns2 1294 local extra_msg="" 1295 local allow_tx_lost=0 1296 local allow_rx_lost=0 1297 1298 if [[ $ns_invert = "invert" ]]; then 1299 ns_tx=$ns2 1300 ns_rx=$ns1 1301 extra_msg="invert" 1302 fi 1303 1304 if [[ "${fail_tx}" = "-"* ]]; then 1305 allow_tx_lost=1 1306 fail_tx=${fail_tx:1} 1307 fi 1308 if [[ "${fail_rx}" = "-"* ]]; then 1309 allow_rx_lost=1 1310 fail_rx=${fail_rx:1} 1311 fi 1312 1313 print_check "ftx" 1314 count=$(mptcp_lib_get_counter ${ns_tx} "MPTcpExtMPFailTx") 1315 if [ "$count" != "$fail_tx" ]; then 1316 extra_msg="$extra_msg,tx=$count" 1317 fi 1318 if [ -z "$count" ]; then 1319 print_skip 1320 elif { [ "$count" != "$fail_tx" ] && [ $allow_tx_lost -eq 0 ]; } || 1321 { [ "$count" -gt "$fail_tx" ] && [ $allow_tx_lost -eq 1 ]; }; then 1322 fail_test "got $count MP_FAIL[s] TX expected $fail_tx" 1323 else 1324 print_ok 1325 fi 1326 1327 print_check "failrx" 1328 count=$(mptcp_lib_get_counter ${ns_rx} "MPTcpExtMPFailRx") 1329 if [ "$count" != "$fail_rx" ]; then 1330 extra_msg="$extra_msg,rx=$count" 1331 fi 1332 if [ -z "$count" ]; then 1333 print_skip 1334 elif { [ "$count" != "$fail_rx" ] && [ $allow_rx_lost -eq 0 ]; } || 1335 { [ "$count" -gt "$fail_rx" ] && [ $allow_rx_lost -eq 1 ]; }; then 1336 fail_test "got $count MP_FAIL[s] RX expected $fail_rx" 1337 else 1338 print_ok 1339 fi 1340 1341 print_info "$extra_msg" 1342} 1343 1344chk_fclose_nr() 1345{ 1346 local fclose_tx=$1 1347 local fclose_rx=$2 1348 local ns_invert=$3 1349 local count 1350 local ns_tx=$ns2 1351 local ns_rx=$ns1 1352 local extra_msg="" 1353 1354 if [[ $ns_invert = "invert" ]]; then 1355 ns_tx=$ns1 1356 ns_rx=$ns2 1357 extra_msg="invert" 1358 fi 1359 1360 print_check "ctx" 1361 count=$(mptcp_lib_get_counter ${ns_tx} "MPTcpExtMPFastcloseTx") 1362 if [ -z "$count" ]; then 1363 print_skip 1364 elif [ "$count" != "$fclose_tx" ]; then 1365 extra_msg="$extra_msg,tx=$count" 1366 fail_test "got $count MP_FASTCLOSE[s] TX expected $fclose_tx" 1367 else 1368 print_ok 1369 fi 1370 1371 print_check "fclzrx" 1372 count=$(mptcp_lib_get_counter ${ns_rx} "MPTcpExtMPFastcloseRx") 1373 if [ -z "$count" ]; then 1374 print_skip 1375 elif [ "$count" != "$fclose_rx" ]; then 1376 extra_msg="$extra_msg,rx=$count" 1377 fail_test "got $count MP_FASTCLOSE[s] RX expected $fclose_rx" 1378 else 1379 print_ok 1380 fi 1381 1382 print_info "$extra_msg" 1383} 1384 1385chk_rst_nr() 1386{ 1387 local rst_tx=$1 1388 local rst_rx=$2 1389 local ns_invert=${3:-""} 1390 local count 1391 local ns_tx=$ns1 1392 local ns_rx=$ns2 1393 local extra_msg="" 1394 1395 if [[ $ns_invert = "invert" ]]; then 1396 ns_tx=$ns2 1397 ns_rx=$ns1 1398 extra_msg="invert" 1399 fi 1400 1401 print_check "rtx" 1402 count=$(mptcp_lib_get_counter ${ns_tx} "MPTcpExtMPRstTx") 1403 if [ -z "$count" ]; then 1404 print_skip 1405 # accept more rst than expected except if we don't expect any 1406 elif { [ $rst_tx -ne 0 ] && [ $count -lt $rst_tx ]; } || 1407 { [ $rst_tx -eq 0 ] && [ $count -ne 0 ]; }; then 1408 fail_test "got $count MP_RST[s] TX expected $rst_tx" 1409 else 1410 print_ok 1411 fi 1412 1413 print_check "rstrx" 1414 count=$(mptcp_lib_get_counter ${ns_rx} "MPTcpExtMPRstRx") 1415 if [ -z "$count" ]; then 1416 print_skip 1417 # accept more rst than expected except if we don't expect any 1418 elif { [ $rst_rx -ne 0 ] && [ $count -lt $rst_rx ]; } || 1419 { [ $rst_rx -eq 0 ] && [ $count -ne 0 ]; }; then 1420 fail_test "got $count MP_RST[s] RX expected $rst_rx" 1421 else 1422 print_ok 1423 fi 1424 1425 print_info "$extra_msg" 1426} 1427 1428chk_infi_nr() 1429{ 1430 local infi_tx=$1 1431 local infi_rx=$2 1432 local count 1433 1434 print_check "itx" 1435 count=$(mptcp_lib_get_counter ${ns2} "MPTcpExtInfiniteMapTx") 1436 if [ -z "$count" ]; then 1437 print_skip 1438 elif [ "$count" != "$infi_tx" ]; then 1439 fail_test "got $count infinite map[s] TX expected $infi_tx" 1440 else 1441 print_ok 1442 fi 1443 1444 print_check "infirx" 1445 count=$(mptcp_lib_get_counter ${ns1} "MPTcpExtInfiniteMapRx") 1446 if [ -z "$count" ]; then 1447 print_skip 1448 elif [ "$count" != "$infi_rx" ]; then 1449 fail_test "got $count infinite map[s] RX expected $infi_rx" 1450 else 1451 print_ok 1452 fi 1453} 1454 1455chk_join_nr() 1456{ 1457 local syn_nr=$1 1458 local syn_ack_nr=$2 1459 local ack_nr=$3 1460 local csum_ns1=${4:-0} 1461 local csum_ns2=${5:-0} 1462 local fail_nr=${6:-0} 1463 local rst_nr=${7:-0} 1464 local infi_nr=${8:-0} 1465 local corrupted_pkts=${9:-0} 1466 local count 1467 local with_cookie 1468 1469 if [ "${corrupted_pkts}" -gt 0 ]; then 1470 print_info "${corrupted_pkts} corrupted pkts" 1471 fi 1472 1473 print_check "syn" 1474 count=$(mptcp_lib_get_counter ${ns1} "MPTcpExtMPJoinSynRx") 1475 if [ -z "$count" ]; then 1476 print_skip 1477 elif [ "$count" != "$syn_nr" ]; then 1478 fail_test "got $count JOIN[s] syn expected $syn_nr" 1479 else 1480 print_ok 1481 fi 1482 1483 print_check "synack" 1484 with_cookie=$(ip netns exec $ns2 sysctl -n net.ipv4.tcp_syncookies) 1485 count=$(mptcp_lib_get_counter ${ns2} "MPTcpExtMPJoinSynAckRx") 1486 if [ -z "$count" ]; then 1487 print_skip 1488 elif [ "$count" != "$syn_ack_nr" ]; then 1489 # simult connections exceeding the limit with cookie enabled could go up to 1490 # synack validation as the conn limit can be enforced reliably only after 1491 # the subflow creation 1492 if [ "$with_cookie" = 2 ] && [ "$count" -gt "$syn_ack_nr" ] && [ "$count" -le "$syn_nr" ]; then 1493 print_ok 1494 else 1495 fail_test "got $count JOIN[s] synack expected $syn_ack_nr" 1496 fi 1497 else 1498 print_ok 1499 fi 1500 1501 print_check "ack" 1502 count=$(mptcp_lib_get_counter ${ns1} "MPTcpExtMPJoinAckRx") 1503 if [ -z "$count" ]; then 1504 print_skip 1505 elif [ "$count" != "$ack_nr" ]; then 1506 fail_test "got $count JOIN[s] ack expected $ack_nr" 1507 else 1508 print_ok 1509 fi 1510 if [ $validate_checksum -eq 1 ]; then 1511 chk_csum_nr $csum_ns1 $csum_ns2 1512 chk_fail_nr $fail_nr $fail_nr 1513 chk_rst_nr $rst_nr $rst_nr 1514 chk_infi_nr $infi_nr $infi_nr 1515 fi 1516} 1517 1518# a negative value for 'stale_max' means no upper bound: 1519# for bidirectional transfer, if one peer sleep for a while 1520# - as these tests do - we can have a quite high number of 1521# stale/recover conversions, proportional to 1522# sleep duration/ MPTCP-level RTX interval. 1523chk_stale_nr() 1524{ 1525 local ns=$1 1526 local stale_min=$2 1527 local stale_max=$3 1528 local stale_delta=$4 1529 local dump_stats 1530 local stale_nr 1531 local recover_nr 1532 1533 print_check "stale" 1534 1535 stale_nr=$(mptcp_lib_get_counter ${ns} "MPTcpExtSubflowStale") 1536 recover_nr=$(mptcp_lib_get_counter ${ns} "MPTcpExtSubflowRecover") 1537 if [ -z "$stale_nr" ] || [ -z "$recover_nr" ]; then 1538 print_skip 1539 elif [ $stale_nr -lt $stale_min ] || 1540 { [ $stale_max -gt 0 ] && [ $stale_nr -gt $stale_max ]; } || 1541 [ $((stale_nr - recover_nr)) -ne $stale_delta ]; then 1542 fail_test "got $stale_nr stale[s] $recover_nr recover[s], " \ 1543 " expected stale in range [$stale_min..$stale_max]," \ 1544 " stale-recover delta $stale_delta" 1545 dump_stats=1 1546 else 1547 print_ok 1548 fi 1549 1550 if [ "${dump_stats}" = 1 ]; then 1551 echo $ns stats 1552 ip netns exec $ns ip -s link show 1553 ip netns exec $ns nstat -as | grep MPTcp 1554 fi 1555} 1556 1557chk_add_nr() 1558{ 1559 local add_nr=$1 1560 local echo_nr=$2 1561 local port_nr=${3:-0} 1562 local syn_nr=${4:-$port_nr} 1563 local syn_ack_nr=${5:-$port_nr} 1564 local ack_nr=${6:-$port_nr} 1565 local mis_syn_nr=${7:-0} 1566 local mis_ack_nr=${8:-0} 1567 local count 1568 local timeout 1569 1570 timeout=$(ip netns exec $ns1 sysctl -n net.mptcp.add_addr_timeout) 1571 1572 print_check "add" 1573 count=$(mptcp_lib_get_counter ${ns2} "MPTcpExtAddAddr") 1574 if [ -z "$count" ]; then 1575 print_skip 1576 # if the test configured a short timeout tolerate greater then expected 1577 # add addrs options, due to retransmissions 1578 elif [ "$count" != "$add_nr" ] && { [ "$timeout" -gt 1 ] || [ "$count" -lt "$add_nr" ]; }; then 1579 fail_test "got $count ADD_ADDR[s] expected $add_nr" 1580 else 1581 print_ok 1582 fi 1583 1584 print_check "echo" 1585 count=$(mptcp_lib_get_counter ${ns1} "MPTcpExtEchoAdd") 1586 if [ -z "$count" ]; then 1587 print_skip 1588 elif [ "$count" != "$echo_nr" ]; then 1589 fail_test "got $count ADD_ADDR echo[s] expected $echo_nr" 1590 else 1591 print_ok 1592 fi 1593 1594 if [ $port_nr -gt 0 ]; then 1595 print_check "pt" 1596 count=$(mptcp_lib_get_counter ${ns2} "MPTcpExtPortAdd") 1597 if [ -z "$count" ]; then 1598 print_skip 1599 elif [ "$count" != "$port_nr" ]; then 1600 fail_test "got $count ADD_ADDR[s] with a port-number expected $port_nr" 1601 else 1602 print_ok 1603 fi 1604 1605 print_check "syn" 1606 count=$(mptcp_lib_get_counter ${ns1} "MPTcpExtMPJoinPortSynRx") 1607 if [ -z "$count" ]; then 1608 print_skip 1609 elif [ "$count" != "$syn_nr" ]; then 1610 fail_test "got $count JOIN[s] syn with a different \ 1611 port-number expected $syn_nr" 1612 else 1613 print_ok 1614 fi 1615 1616 print_check "synack" 1617 count=$(mptcp_lib_get_counter ${ns2} "MPTcpExtMPJoinPortSynAckRx") 1618 if [ -z "$count" ]; then 1619 print_skip 1620 elif [ "$count" != "$syn_ack_nr" ]; then 1621 fail_test "got $count JOIN[s] synack with a different \ 1622 port-number expected $syn_ack_nr" 1623 else 1624 print_ok 1625 fi 1626 1627 print_check "ack" 1628 count=$(mptcp_lib_get_counter ${ns1} "MPTcpExtMPJoinPortAckRx") 1629 if [ -z "$count" ]; then 1630 print_skip 1631 elif [ "$count" != "$ack_nr" ]; then 1632 fail_test "got $count JOIN[s] ack with a different \ 1633 port-number expected $ack_nr" 1634 else 1635 print_ok 1636 fi 1637 1638 print_check "syn" 1639 count=$(mptcp_lib_get_counter ${ns1} "MPTcpExtMismatchPortSynRx") 1640 if [ -z "$count" ]; then 1641 print_skip 1642 elif [ "$count" != "$mis_syn_nr" ]; then 1643 fail_test "got $count JOIN[s] syn with a mismatched \ 1644 port-number expected $mis_syn_nr" 1645 else 1646 print_ok 1647 fi 1648 1649 print_check "ack" 1650 count=$(mptcp_lib_get_counter ${ns1} "MPTcpExtMismatchPortAckRx") 1651 if [ -z "$count" ]; then 1652 print_skip 1653 elif [ "$count" != "$mis_ack_nr" ]; then 1654 fail_test "got $count JOIN[s] ack with a mismatched \ 1655 port-number expected $mis_ack_nr" 1656 else 1657 print_ok 1658 fi 1659 fi 1660} 1661 1662chk_add_tx_nr() 1663{ 1664 local add_tx_nr=$1 1665 local echo_tx_nr=$2 1666 local timeout 1667 local count 1668 1669 timeout=$(ip netns exec $ns1 sysctl -n net.mptcp.add_addr_timeout) 1670 1671 print_check "add TX" 1672 count=$(mptcp_lib_get_counter ${ns1} "MPTcpExtAddAddrTx") 1673 if [ -z "$count" ]; then 1674 print_skip 1675 # if the test configured a short timeout tolerate greater then expected 1676 # add addrs options, due to retransmissions 1677 elif [ "$count" != "$add_tx_nr" ] && { [ "$timeout" -gt 1 ] || [ "$count" -lt "$add_tx_nr" ]; }; then 1678 fail_test "got $count ADD_ADDR[s] TX, expected $add_tx_nr" 1679 else 1680 print_ok 1681 fi 1682 1683 print_check "echo TX" 1684 count=$(mptcp_lib_get_counter ${ns2} "MPTcpExtEchoAddTx") 1685 if [ -z "$count" ]; then 1686 print_skip 1687 elif [ "$count" != "$echo_tx_nr" ]; then 1688 fail_test "got $count ADD_ADDR echo[s] TX, expected $echo_tx_nr" 1689 else 1690 print_ok 1691 fi 1692} 1693 1694chk_rm_nr() 1695{ 1696 local rm_addr_nr=$1 1697 local rm_subflow_nr=$2 1698 local invert 1699 local simult 1700 local count 1701 local addr_ns=$ns1 1702 local subflow_ns=$ns2 1703 local extra_msg="" 1704 1705 shift 2 1706 while [ -n "$1" ]; do 1707 [ "$1" = "invert" ] && invert=true 1708 [ "$1" = "simult" ] && simult=true 1709 shift 1710 done 1711 1712 if [ -z $invert ]; then 1713 addr_ns=$ns1 1714 subflow_ns=$ns2 1715 elif [ $invert = "true" ]; then 1716 addr_ns=$ns2 1717 subflow_ns=$ns1 1718 extra_msg="invert" 1719 fi 1720 1721 print_check "rm" 1722 count=$(mptcp_lib_get_counter ${addr_ns} "MPTcpExtRmAddr") 1723 if [ -z "$count" ]; then 1724 print_skip 1725 elif [ "$count" != "$rm_addr_nr" ]; then 1726 fail_test "got $count RM_ADDR[s] expected $rm_addr_nr" 1727 else 1728 print_ok 1729 fi 1730 1731 print_check "rmsf" 1732 count=$(mptcp_lib_get_counter ${subflow_ns} "MPTcpExtRmSubflow") 1733 if [ -z "$count" ]; then 1734 print_skip 1735 elif [ -n "$simult" ]; then 1736 local cnt suffix 1737 1738 cnt=$(mptcp_lib_get_counter ${addr_ns} "MPTcpExtRmSubflow") 1739 1740 # in case of simult flush, the subflow removal count on each side is 1741 # unreliable 1742 count=$((count + cnt)) 1743 if [ "$count" != "$rm_subflow_nr" ]; then 1744 suffix="$count in [$rm_subflow_nr:$((rm_subflow_nr*2))]" 1745 extra_msg="$extra_msg simult" 1746 fi 1747 if [ $count -ge "$rm_subflow_nr" ] && \ 1748 [ "$count" -le "$((rm_subflow_nr *2 ))" ]; then 1749 print_ok "$suffix" 1750 else 1751 fail_test "got $count RM_SUBFLOW[s] expected in range [$rm_subflow_nr:$((rm_subflow_nr*2))]" 1752 fi 1753 elif [ "$count" != "$rm_subflow_nr" ]; then 1754 fail_test "got $count RM_SUBFLOW[s] expected $rm_subflow_nr" 1755 else 1756 print_ok 1757 fi 1758 1759 print_info "$extra_msg" 1760} 1761 1762chk_rm_tx_nr() 1763{ 1764 local rm_addr_tx_nr=$1 1765 1766 print_check "rm TX" 1767 count=$(mptcp_lib_get_counter ${ns2} "MPTcpExtRmAddrTx") 1768 if [ -z "$count" ]; then 1769 print_skip 1770 elif [ "$count" != "$rm_addr_tx_nr" ]; then 1771 fail_test "got $count RM_ADDR[s] expected $rm_addr_tx_nr" 1772 else 1773 print_ok 1774 fi 1775} 1776 1777chk_prio_nr() 1778{ 1779 local mp_prio_nr_tx=$1 1780 local mp_prio_nr_rx=$2 1781 local count 1782 1783 print_check "ptx" 1784 count=$(mptcp_lib_get_counter ${ns1} "MPTcpExtMPPrioTx") 1785 if [ -z "$count" ]; then 1786 print_skip 1787 elif [ "$count" != "$mp_prio_nr_tx" ]; then 1788 fail_test "got $count MP_PRIO[s] TX expected $mp_prio_nr_tx" 1789 else 1790 print_ok 1791 fi 1792 1793 print_check "prx" 1794 count=$(mptcp_lib_get_counter ${ns1} "MPTcpExtMPPrioRx") 1795 if [ -z "$count" ]; then 1796 print_skip 1797 elif [ "$count" != "$mp_prio_nr_rx" ]; then 1798 fail_test "got $count MP_PRIO[s] RX expected $mp_prio_nr_rx" 1799 else 1800 print_ok 1801 fi 1802} 1803 1804chk_subflow_nr() 1805{ 1806 local msg="$1" 1807 local subflow_nr=$2 1808 local cnt1 1809 local cnt2 1810 local dump_stats 1811 1812 print_check "${msg}" 1813 1814 cnt1=$(ss -N $ns1 -tOni | grep -c token) 1815 cnt2=$(ss -N $ns2 -tOni | grep -c token) 1816 if [ "$cnt1" != "$subflow_nr" ] || [ "$cnt2" != "$subflow_nr" ]; then 1817 fail_test "got $cnt1:$cnt2 subflows expected $subflow_nr" 1818 dump_stats=1 1819 else 1820 print_ok 1821 fi 1822 1823 if [ "${dump_stats}" = 1 ]; then 1824 ss -N $ns1 -tOni 1825 ss -N $ns1 -tOni | grep token 1826 ip -n $ns1 mptcp endpoint 1827 fi 1828} 1829 1830chk_mptcp_info() 1831{ 1832 local info1=$1 1833 local exp1=$2 1834 local info2=$3 1835 local exp2=$4 1836 local cnt1 1837 local cnt2 1838 local dump_stats 1839 1840 print_check "mptcp_info ${info1:0:15}=$exp1:$exp2" 1841 1842 cnt1=$(ss -N $ns1 -inmHM | mptcp_lib_get_info_value "$info1" "$info1") 1843 cnt2=$(ss -N $ns2 -inmHM | mptcp_lib_get_info_value "$info2" "$info2") 1844 # 'ss' only display active connections and counters that are not 0. 1845 [ -z "$cnt1" ] && cnt1=0 1846 [ -z "$cnt2" ] && cnt2=0 1847 1848 if [ "$cnt1" != "$exp1" ] || [ "$cnt2" != "$exp2" ]; then 1849 fail_test "got $cnt1:$cnt2 $info1:$info2 expected $exp1:$exp2" 1850 dump_stats=1 1851 else 1852 print_ok 1853 fi 1854 1855 if [ "$dump_stats" = 1 ]; then 1856 ss -N $ns1 -inmHM 1857 ss -N $ns2 -inmHM 1858 fi 1859} 1860 1861# $1: subflows in ns1 ; $2: subflows in ns2 1862# number of all subflows, including the initial subflow. 1863chk_subflows_total() 1864{ 1865 local cnt1 1866 local cnt2 1867 local info="subflows_total" 1868 local dump_stats 1869 1870 # if subflows_total counter is supported, use it: 1871 if [ -n "$(ss -N $ns1 -inmHM | mptcp_lib_get_info_value $info $info)" ]; then 1872 chk_mptcp_info $info $1 $info $2 1873 return 1874 fi 1875 1876 print_check "$info $1:$2" 1877 1878 # if not, count the TCP connections that are in fact MPTCP subflows 1879 cnt1=$(ss -N $ns1 -ti state established state syn-sent state syn-recv | 1880 grep -c tcp-ulp-mptcp) 1881 cnt2=$(ss -N $ns2 -ti state established state syn-sent state syn-recv | 1882 grep -c tcp-ulp-mptcp) 1883 1884 if [ "$1" != "$cnt1" ] || [ "$2" != "$cnt2" ]; then 1885 fail_test "got subflows $cnt1:$cnt2 expected $1:$2" 1886 dump_stats=1 1887 else 1888 print_ok 1889 fi 1890 1891 if [ "$dump_stats" = 1 ]; then 1892 ss -N $ns1 -ti 1893 ss -N $ns2 -ti 1894 fi 1895} 1896 1897chk_link_usage() 1898{ 1899 local ns=$1 1900 local link=$2 1901 local out=$3 1902 local expected_rate=$4 1903 1904 local tx_link tx_total 1905 tx_link=$(ip netns exec $ns cat /sys/class/net/$link/statistics/tx_bytes) 1906 tx_total=$(stat --format=%s $out) 1907 local tx_rate=$((tx_link * 100 / tx_total)) 1908 local tolerance=5 1909 1910 print_check "link usage" 1911 if [ $tx_rate -lt $((expected_rate - tolerance)) ] || \ 1912 [ $tx_rate -gt $((expected_rate + tolerance)) ]; then 1913 fail_test "got $tx_rate% usage, expected $expected_rate%" 1914 else 1915 print_ok 1916 fi 1917} 1918 1919wait_attempt_fail() 1920{ 1921 local timeout_ms=$((timeout_poll * 1000)) 1922 local time=0 1923 local ns=$1 1924 1925 while [ $time -lt $timeout_ms ]; do 1926 local cnt 1927 1928 cnt=$(mptcp_lib_get_counter ${ns} "TcpAttemptFails") 1929 1930 [ "$cnt" = 1 ] && return 1 1931 time=$((time + 100)) 1932 sleep 0.1 1933 done 1934 return 1 1935} 1936 1937set_userspace_pm() 1938{ 1939 local ns=$1 1940 1941 ip netns exec $ns sysctl -q net.mptcp.pm_type=1 1942} 1943 1944subflows_tests() 1945{ 1946 if reset "no JOIN"; then 1947 run_tests $ns1 $ns2 10.0.1.1 1948 chk_join_nr 0 0 0 1949 fi 1950 1951 # subflow limited by client 1952 if reset "single subflow, limited by client"; then 1953 pm_nl_set_limits $ns1 0 0 1954 pm_nl_set_limits $ns2 0 0 1955 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow 1956 run_tests $ns1 $ns2 10.0.1.1 1957 chk_join_nr 0 0 0 1958 fi 1959 1960 # subflow limited by server 1961 if reset "single subflow, limited by server"; then 1962 pm_nl_set_limits $ns1 0 0 1963 pm_nl_set_limits $ns2 0 1 1964 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow 1965 run_tests $ns1 $ns2 10.0.1.1 1966 chk_join_nr 1 1 0 1967 fi 1968 1969 # subflow 1970 if reset "single subflow"; then 1971 pm_nl_set_limits $ns1 0 1 1972 pm_nl_set_limits $ns2 0 1 1973 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow 1974 run_tests $ns1 $ns2 10.0.1.1 1975 chk_join_nr 1 1 1 1976 fi 1977 1978 # multiple subflows 1979 if reset "multiple subflows"; then 1980 pm_nl_set_limits $ns1 0 2 1981 pm_nl_set_limits $ns2 0 2 1982 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow 1983 pm_nl_add_endpoint $ns2 10.0.2.2 flags subflow 1984 run_tests $ns1 $ns2 10.0.1.1 1985 chk_join_nr 2 2 2 1986 fi 1987 1988 # multiple subflows limited by server 1989 if reset "multiple subflows, limited by server"; then 1990 pm_nl_set_limits $ns1 0 1 1991 pm_nl_set_limits $ns2 0 2 1992 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow 1993 pm_nl_add_endpoint $ns2 10.0.2.2 flags subflow 1994 run_tests $ns1 $ns2 10.0.1.1 1995 chk_join_nr 2 2 1 1996 fi 1997 1998 # single subflow, dev 1999 if reset "single subflow, dev"; then 2000 pm_nl_set_limits $ns1 0 1 2001 pm_nl_set_limits $ns2 0 1 2002 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow dev ns2eth3 2003 run_tests $ns1 $ns2 10.0.1.1 2004 chk_join_nr 1 1 1 2005 fi 2006} 2007 2008subflows_error_tests() 2009{ 2010 # If a single subflow is configured, and matches the MPC src 2011 # address, no additional subflow should be created 2012 if reset "no MPC reuse with single endpoint"; then 2013 pm_nl_set_limits $ns1 0 1 2014 pm_nl_set_limits $ns2 0 1 2015 pm_nl_add_endpoint $ns2 10.0.1.2 flags subflow 2016 speed=slow \ 2017 run_tests $ns1 $ns2 10.0.1.1 2018 chk_join_nr 0 0 0 2019 fi 2020 2021 # multiple subflows, with subflow creation error 2022 if reset_with_tcp_filter "multi subflows, with failing subflow" ns1 10.0.3.2 REJECT && 2023 continue_if mptcp_lib_kallsyms_has "mptcp_pm_subflow_check_next$"; then 2024 pm_nl_set_limits $ns1 0 2 2025 pm_nl_set_limits $ns2 0 2 2026 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow 2027 pm_nl_add_endpoint $ns2 10.0.2.2 flags subflow 2028 speed=slow \ 2029 run_tests $ns1 $ns2 10.0.1.1 2030 chk_join_nr 1 1 1 2031 fi 2032 2033 # multiple subflows, with subflow timeout on MPJ 2034 if reset_with_tcp_filter "multi subflows, with subflow timeout" ns1 10.0.3.2 DROP && 2035 continue_if mptcp_lib_kallsyms_has "mptcp_pm_subflow_check_next$"; then 2036 pm_nl_set_limits $ns1 0 2 2037 pm_nl_set_limits $ns2 0 2 2038 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow 2039 pm_nl_add_endpoint $ns2 10.0.2.2 flags subflow 2040 speed=slow \ 2041 run_tests $ns1 $ns2 10.0.1.1 2042 chk_join_nr 1 1 1 2043 fi 2044 2045 # multiple subflows, check that the endpoint corresponding to 2046 # closed subflow (due to reset) is not reused if additional 2047 # subflows are added later 2048 if reset_with_tcp_filter "multi subflows, fair usage on close" ns1 10.0.3.2 REJECT && 2049 continue_if mptcp_lib_kallsyms_has "mptcp_pm_subflow_check_next$"; then 2050 pm_nl_set_limits $ns1 0 1 2051 pm_nl_set_limits $ns2 0 1 2052 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow 2053 speed=slow \ 2054 run_tests $ns1 $ns2 10.0.1.1 & 2055 2056 # mpj subflow will be in TW after the reset 2057 wait_attempt_fail $ns2 2058 pm_nl_add_endpoint $ns2 10.0.2.2 flags subflow 2059 wait 2060 2061 # additional subflow could be created only if the PM select 2062 # the later endpoint, skipping the already used one 2063 chk_join_nr 1 1 1 2064 fi 2065} 2066 2067signal_address_tests() 2068{ 2069 # add_address, unused 2070 if reset "unused signal address"; then 2071 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal 2072 run_tests $ns1 $ns2 10.0.1.1 2073 chk_join_nr 0 0 0 2074 chk_add_tx_nr 1 1 2075 chk_add_nr 1 1 2076 fi 2077 2078 # accept and use add_addr 2079 if reset "signal address"; then 2080 pm_nl_set_limits $ns1 0 1 2081 pm_nl_set_limits $ns2 1 1 2082 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal 2083 run_tests $ns1 $ns2 10.0.1.1 2084 chk_join_nr 1 1 1 2085 chk_add_nr 1 1 2086 fi 2087 2088 # accept and use add_addr with an additional subflow 2089 # note: signal address in server ns and local addresses in client ns must 2090 # belong to different subnets or one of the listed local address could be 2091 # used for 'add_addr' subflow 2092 if reset "subflow and signal"; then 2093 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal 2094 pm_nl_set_limits $ns1 0 2 2095 pm_nl_set_limits $ns2 1 2 2096 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow 2097 run_tests $ns1 $ns2 10.0.1.1 2098 chk_join_nr 2 2 2 2099 chk_add_nr 1 1 2100 fi 2101 2102 # accept and use add_addr with additional subflows 2103 if reset "multiple subflows and signal"; then 2104 pm_nl_set_limits $ns1 0 3 2105 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal 2106 pm_nl_set_limits $ns2 1 3 2107 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow 2108 pm_nl_add_endpoint $ns2 10.0.4.2 flags subflow 2109 run_tests $ns1 $ns2 10.0.1.1 2110 chk_join_nr 3 3 3 2111 chk_add_nr 1 1 2112 fi 2113 2114 # signal addresses 2115 if reset "signal addresses"; then 2116 pm_nl_set_limits $ns1 3 3 2117 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal 2118 pm_nl_add_endpoint $ns1 10.0.3.1 flags signal 2119 pm_nl_add_endpoint $ns1 10.0.4.1 flags signal 2120 pm_nl_set_limits $ns2 3 3 2121 run_tests $ns1 $ns2 10.0.1.1 2122 chk_join_nr 3 3 3 2123 chk_add_nr 3 3 2124 fi 2125 2126 # signal invalid addresses 2127 if reset "signal invalid addresses"; then 2128 pm_nl_set_limits $ns1 3 3 2129 pm_nl_add_endpoint $ns1 10.0.12.1 flags signal 2130 pm_nl_add_endpoint $ns1 10.0.3.1 flags signal 2131 pm_nl_add_endpoint $ns1 10.0.14.1 flags signal 2132 pm_nl_set_limits $ns2 3 3 2133 run_tests $ns1 $ns2 10.0.1.1 2134 chk_join_nr 1 1 1 2135 chk_add_nr 3 3 2136 fi 2137 2138 # signal addresses race test 2139 if reset "signal addresses race test"; then 2140 pm_nl_set_limits $ns1 4 4 2141 pm_nl_set_limits $ns2 4 4 2142 pm_nl_add_endpoint $ns1 10.0.1.1 flags signal 2143 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal 2144 pm_nl_add_endpoint $ns1 10.0.3.1 flags signal 2145 pm_nl_add_endpoint $ns1 10.0.4.1 flags signal 2146 pm_nl_add_endpoint $ns2 10.0.1.2 flags signal 2147 pm_nl_add_endpoint $ns2 10.0.2.2 flags signal 2148 pm_nl_add_endpoint $ns2 10.0.3.2 flags signal 2149 pm_nl_add_endpoint $ns2 10.0.4.2 flags signal 2150 2151 # the peer could possibly miss some addr notification, allow retransmission 2152 ip netns exec $ns1 sysctl -q net.mptcp.add_addr_timeout=1 2153 speed=slow \ 2154 run_tests $ns1 $ns2 10.0.1.1 2155 2156 # It is not directly linked to the commit introducing this 2157 # symbol but for the parent one which is linked anyway. 2158 if ! mptcp_lib_kallsyms_has "mptcp_pm_subflow_check_next$"; then 2159 chk_join_nr 3 3 2 2160 chk_add_nr 4 4 2161 else 2162 chk_join_nr 3 3 3 2163 # the server will not signal the address terminating 2164 # the MPC subflow 2165 chk_add_nr 3 3 2166 fi 2167 fi 2168} 2169 2170link_failure_tests() 2171{ 2172 # accept and use add_addr with additional subflows and link loss 2173 if reset "multiple flows, signal, link failure"; then 2174 # without any b/w limit each veth could spool the packets and get 2175 # them acked at xmit time, so that the corresponding subflow will 2176 # have almost always no outstanding pkts, the scheduler will pick 2177 # always the first subflow and we will have hard time testing 2178 # active backup and link switch-over. 2179 # Let's set some arbitrary (low) virtual link limits. 2180 init_shapers 2181 pm_nl_set_limits $ns1 0 3 2182 pm_nl_add_endpoint $ns1 10.0.2.1 dev ns1eth2 flags signal 2183 pm_nl_set_limits $ns2 1 3 2184 pm_nl_add_endpoint $ns2 10.0.3.2 dev ns2eth3 flags subflow 2185 pm_nl_add_endpoint $ns2 10.0.4.2 dev ns2eth4 flags subflow 2186 test_linkfail=1 \ 2187 run_tests $ns1 $ns2 10.0.1.1 2188 chk_join_nr 3 3 3 2189 chk_add_nr 1 1 2190 chk_stale_nr $ns2 1 5 1 2191 fi 2192 2193 # accept and use add_addr with additional subflows and link loss 2194 # for bidirectional transfer 2195 if reset "multi flows, signal, bidi, link fail"; then 2196 init_shapers 2197 pm_nl_set_limits $ns1 0 3 2198 pm_nl_add_endpoint $ns1 10.0.2.1 dev ns1eth2 flags signal 2199 pm_nl_set_limits $ns2 1 3 2200 pm_nl_add_endpoint $ns2 10.0.3.2 dev ns2eth3 flags subflow 2201 pm_nl_add_endpoint $ns2 10.0.4.2 dev ns2eth4 flags subflow 2202 test_linkfail=2 \ 2203 run_tests $ns1 $ns2 10.0.1.1 2204 chk_join_nr 3 3 3 2205 chk_add_nr 1 1 2206 chk_stale_nr $ns2 1 -1 1 2207 fi 2208 2209 # 2 subflows plus 1 backup subflow with a lossy link, backup 2210 # will never be used 2211 if reset "backup subflow unused, link failure"; then 2212 init_shapers 2213 pm_nl_set_limits $ns1 0 2 2214 pm_nl_add_endpoint $ns1 10.0.2.1 dev ns1eth2 flags signal 2215 pm_nl_set_limits $ns2 1 2 2216 pm_nl_add_endpoint $ns2 10.0.3.2 dev ns2eth3 flags subflow,backup 2217 FAILING_LINKS="1" test_linkfail=1 \ 2218 run_tests $ns1 $ns2 10.0.1.1 2219 chk_join_nr 2 2 2 2220 chk_add_nr 1 1 2221 chk_link_usage $ns2 ns2eth3 $cinsent 0 2222 fi 2223 2224 # 2 lossy links after half transfer, backup will get half of 2225 # the traffic 2226 if reset "backup flow used, multi links fail"; then 2227 init_shapers 2228 pm_nl_set_limits $ns1 0 2 2229 pm_nl_add_endpoint $ns1 10.0.2.1 dev ns1eth2 flags signal 2230 pm_nl_set_limits $ns2 1 2 2231 pm_nl_add_endpoint $ns2 10.0.3.2 dev ns2eth3 flags subflow,backup 2232 FAILING_LINKS="1 2" test_linkfail=1 \ 2233 run_tests $ns1 $ns2 10.0.1.1 2234 chk_join_nr 2 2 2 2235 chk_add_nr 1 1 2236 chk_stale_nr $ns2 2 4 2 2237 chk_link_usage $ns2 ns2eth3 $cinsent 50 2238 fi 2239 2240 # use a backup subflow with the first subflow on a lossy link 2241 # for bidirectional transfer 2242 if reset "backup flow used, bidi, link failure"; then 2243 init_shapers 2244 pm_nl_set_limits $ns1 0 2 2245 pm_nl_add_endpoint $ns1 10.0.2.1 dev ns1eth2 flags signal 2246 pm_nl_set_limits $ns2 1 3 2247 pm_nl_add_endpoint $ns2 10.0.3.2 dev ns2eth3 flags subflow,backup 2248 FAILING_LINKS="1 2" test_linkfail=2 \ 2249 run_tests $ns1 $ns2 10.0.1.1 2250 chk_join_nr 2 2 2 2251 chk_add_nr 1 1 2252 chk_stale_nr $ns2 1 -1 2 2253 chk_link_usage $ns2 ns2eth3 $cinsent 50 2254 fi 2255} 2256 2257add_addr_timeout_tests() 2258{ 2259 # add_addr timeout 2260 if reset_with_add_addr_timeout "signal address, ADD_ADDR timeout"; then 2261 pm_nl_set_limits $ns1 0 1 2262 pm_nl_set_limits $ns2 1 1 2263 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal 2264 speed=slow \ 2265 run_tests $ns1 $ns2 10.0.1.1 2266 chk_join_nr 1 1 1 2267 chk_add_tx_nr 4 4 2268 chk_add_nr 4 0 2269 fi 2270 2271 # add_addr timeout IPv6 2272 if reset_with_add_addr_timeout "signal address, ADD_ADDR6 timeout" 6; then 2273 pm_nl_set_limits $ns1 0 1 2274 pm_nl_set_limits $ns2 1 1 2275 pm_nl_add_endpoint $ns1 dead:beef:2::1 flags signal 2276 speed=slow \ 2277 run_tests $ns1 $ns2 dead:beef:1::1 2278 chk_join_nr 1 1 1 2279 chk_add_nr 4 0 2280 fi 2281 2282 # signal addresses timeout 2283 if reset_with_add_addr_timeout "signal addresses, ADD_ADDR timeout"; then 2284 pm_nl_set_limits $ns1 2 2 2285 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal 2286 pm_nl_add_endpoint $ns1 10.0.3.1 flags signal 2287 pm_nl_set_limits $ns2 2 2 2288 speed=10 \ 2289 run_tests $ns1 $ns2 10.0.1.1 2290 chk_join_nr 2 2 2 2291 chk_add_nr 8 0 2292 fi 2293 2294 # signal invalid addresses timeout 2295 if reset_with_add_addr_timeout "invalid address, ADD_ADDR timeout"; then 2296 pm_nl_set_limits $ns1 2 2 2297 pm_nl_add_endpoint $ns1 10.0.12.1 flags signal 2298 pm_nl_add_endpoint $ns1 10.0.3.1 flags signal 2299 pm_nl_set_limits $ns2 2 2 2300 speed=10 \ 2301 run_tests $ns1 $ns2 10.0.1.1 2302 chk_join_nr 1 1 1 2303 chk_add_nr 8 0 2304 fi 2305} 2306 2307remove_tests() 2308{ 2309 # single subflow, remove 2310 if reset "remove single subflow"; then 2311 pm_nl_set_limits $ns1 0 1 2312 pm_nl_set_limits $ns2 0 1 2313 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow 2314 addr_nr_ns2=-1 speed=slow \ 2315 run_tests $ns1 $ns2 10.0.1.1 2316 chk_join_nr 1 1 1 2317 chk_rm_tx_nr 1 2318 chk_rm_nr 1 1 2319 chk_rst_nr 0 0 2320 fi 2321 2322 # multiple subflows, remove 2323 if reset "remove multiple subflows"; then 2324 pm_nl_set_limits $ns1 0 2 2325 pm_nl_set_limits $ns2 0 2 2326 pm_nl_add_endpoint $ns2 10.0.2.2 flags subflow 2327 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow 2328 addr_nr_ns2=-2 speed=slow \ 2329 run_tests $ns1 $ns2 10.0.1.1 2330 chk_join_nr 2 2 2 2331 chk_rm_nr 2 2 2332 chk_rst_nr 0 0 2333 fi 2334 2335 # single address, remove 2336 if reset "remove single address"; then 2337 pm_nl_set_limits $ns1 0 1 2338 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal 2339 pm_nl_set_limits $ns2 1 1 2340 addr_nr_ns1=-1 speed=slow \ 2341 run_tests $ns1 $ns2 10.0.1.1 2342 chk_join_nr 1 1 1 2343 chk_add_nr 1 1 2344 chk_rm_nr 1 1 invert 2345 chk_rst_nr 0 0 2346 fi 2347 2348 # subflow and signal, remove 2349 if reset "remove subflow and signal"; then 2350 pm_nl_set_limits $ns1 0 2 2351 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal 2352 pm_nl_set_limits $ns2 1 2 2353 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow 2354 addr_nr_ns1=-1 addr_nr_ns2=-1 speed=slow \ 2355 run_tests $ns1 $ns2 10.0.1.1 2356 chk_join_nr 2 2 2 2357 chk_add_nr 1 1 2358 chk_rm_nr 1 1 2359 chk_rst_nr 0 0 2360 fi 2361 2362 # subflows and signal, remove 2363 if reset "remove subflows and signal"; then 2364 pm_nl_set_limits $ns1 0 3 2365 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal 2366 pm_nl_set_limits $ns2 1 3 2367 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow 2368 pm_nl_add_endpoint $ns2 10.0.4.2 flags subflow 2369 addr_nr_ns1=-1 addr_nr_ns2=-2 speed=10 \ 2370 run_tests $ns1 $ns2 10.0.1.1 2371 chk_join_nr 3 3 3 2372 chk_add_nr 1 1 2373 chk_rm_nr 2 2 2374 chk_rst_nr 0 0 2375 fi 2376 2377 # addresses remove 2378 if reset "remove addresses"; then 2379 pm_nl_set_limits $ns1 3 3 2380 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal id 250 2381 pm_nl_add_endpoint $ns1 10.0.3.1 flags signal 2382 pm_nl_add_endpoint $ns1 10.0.4.1 flags signal 2383 pm_nl_set_limits $ns2 3 3 2384 addr_nr_ns1=-3 speed=10 \ 2385 run_tests $ns1 $ns2 10.0.1.1 2386 chk_join_nr 3 3 3 2387 chk_add_nr 3 3 2388 chk_rm_nr 3 3 invert 2389 chk_rst_nr 0 0 2390 fi 2391 2392 # invalid addresses remove 2393 if reset "remove invalid addresses"; then 2394 pm_nl_set_limits $ns1 3 3 2395 pm_nl_add_endpoint $ns1 10.0.12.1 flags signal 2396 pm_nl_add_endpoint $ns1 10.0.3.1 flags signal 2397 pm_nl_add_endpoint $ns1 10.0.14.1 flags signal 2398 pm_nl_set_limits $ns2 3 3 2399 addr_nr_ns1=-3 speed=10 \ 2400 run_tests $ns1 $ns2 10.0.1.1 2401 chk_join_nr 1 1 1 2402 chk_add_nr 3 3 2403 chk_rm_nr 3 1 invert 2404 chk_rst_nr 0 0 2405 fi 2406 2407 # subflows and signal, flush 2408 if reset "flush subflows and signal"; then 2409 pm_nl_set_limits $ns1 0 3 2410 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal 2411 pm_nl_set_limits $ns2 1 3 2412 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow 2413 pm_nl_add_endpoint $ns2 10.0.4.2 flags subflow 2414 addr_nr_ns1=-8 addr_nr_ns2=-8 speed=slow \ 2415 run_tests $ns1 $ns2 10.0.1.1 2416 chk_join_nr 3 3 3 2417 chk_add_nr 1 1 2418 chk_rm_nr 1 3 invert simult 2419 chk_rst_nr 0 0 2420 fi 2421 2422 # subflows flush 2423 if reset "flush subflows"; then 2424 pm_nl_set_limits $ns1 3 3 2425 pm_nl_set_limits $ns2 3 3 2426 pm_nl_add_endpoint $ns2 10.0.2.2 flags subflow id 150 2427 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow 2428 pm_nl_add_endpoint $ns2 10.0.4.2 flags subflow 2429 addr_nr_ns1=-8 addr_nr_ns2=-8 speed=slow \ 2430 run_tests $ns1 $ns2 10.0.1.1 2431 chk_join_nr 3 3 3 2432 2433 if mptcp_lib_kversion_ge 5.18; then 2434 chk_rm_tx_nr 0 2435 chk_rm_nr 0 3 simult 2436 else 2437 chk_rm_nr 3 3 2438 fi 2439 chk_rst_nr 0 0 2440 fi 2441 2442 # addresses flush 2443 if reset "flush addresses"; then 2444 pm_nl_set_limits $ns1 3 3 2445 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal id 250 2446 pm_nl_add_endpoint $ns1 10.0.3.1 flags signal 2447 pm_nl_add_endpoint $ns1 10.0.4.1 flags signal 2448 pm_nl_set_limits $ns2 3 3 2449 addr_nr_ns1=-8 addr_nr_ns2=-8 speed=slow \ 2450 run_tests $ns1 $ns2 10.0.1.1 2451 chk_join_nr 3 3 3 2452 chk_add_nr 3 3 2453 chk_rm_nr 3 3 invert simult 2454 chk_rst_nr 0 0 2455 fi 2456 2457 # invalid addresses flush 2458 if reset "flush invalid addresses"; then 2459 pm_nl_set_limits $ns1 3 3 2460 pm_nl_add_endpoint $ns1 10.0.12.1 flags signal 2461 pm_nl_add_endpoint $ns1 10.0.3.1 flags signal 2462 pm_nl_add_endpoint $ns1 10.0.14.1 flags signal 2463 pm_nl_set_limits $ns2 3 3 2464 addr_nr_ns1=-8 speed=slow \ 2465 run_tests $ns1 $ns2 10.0.1.1 2466 chk_join_nr 1 1 1 2467 chk_add_nr 3 3 2468 chk_rm_nr 3 1 invert 2469 chk_rst_nr 0 0 2470 fi 2471 2472 # remove id 0 subflow 2473 if reset "remove id 0 subflow"; then 2474 pm_nl_set_limits $ns1 0 1 2475 pm_nl_set_limits $ns2 0 1 2476 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow 2477 addr_nr_ns2=-9 speed=slow \ 2478 run_tests $ns1 $ns2 10.0.1.1 2479 chk_join_nr 1 1 1 2480 chk_rm_nr 1 1 2481 chk_rst_nr 0 0 2482 fi 2483 2484 # remove id 0 address 2485 if reset "remove id 0 address"; then 2486 pm_nl_set_limits $ns1 0 1 2487 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal 2488 pm_nl_set_limits $ns2 1 1 2489 addr_nr_ns1=-9 speed=slow \ 2490 run_tests $ns1 $ns2 10.0.1.1 2491 chk_join_nr 1 1 1 2492 chk_add_nr 1 1 2493 chk_rm_nr 1 1 invert 2494 chk_rst_nr 0 0 invert 2495 fi 2496} 2497 2498add_tests() 2499{ 2500 # add single subflow 2501 if reset "add single subflow"; then 2502 pm_nl_set_limits $ns1 0 1 2503 pm_nl_set_limits $ns2 0 1 2504 addr_nr_ns2=1 speed=slow cestab_ns2=1 \ 2505 run_tests $ns1 $ns2 10.0.1.1 2506 chk_join_nr 1 1 1 2507 chk_cestab_nr $ns2 0 2508 fi 2509 2510 # add signal address 2511 if reset "add signal address"; then 2512 pm_nl_set_limits $ns1 0 1 2513 pm_nl_set_limits $ns2 1 1 2514 addr_nr_ns1=1 speed=slow cestab_ns1=1 \ 2515 run_tests $ns1 $ns2 10.0.1.1 2516 chk_join_nr 1 1 1 2517 chk_add_nr 1 1 2518 chk_cestab_nr $ns1 0 2519 fi 2520 2521 # add multiple subflows 2522 if reset "add multiple subflows"; then 2523 pm_nl_set_limits $ns1 0 2 2524 pm_nl_set_limits $ns2 0 2 2525 addr_nr_ns2=2 speed=slow cestab_ns2=1 \ 2526 run_tests $ns1 $ns2 10.0.1.1 2527 chk_join_nr 2 2 2 2528 chk_cestab_nr $ns2 0 2529 fi 2530 2531 # add multiple subflows IPv6 2532 if reset "add multiple subflows IPv6"; then 2533 pm_nl_set_limits $ns1 0 2 2534 pm_nl_set_limits $ns2 0 2 2535 addr_nr_ns2=2 speed=slow cestab_ns2=1 \ 2536 run_tests $ns1 $ns2 dead:beef:1::1 2537 chk_join_nr 2 2 2 2538 chk_cestab_nr $ns2 0 2539 fi 2540 2541 # add multiple addresses IPv6 2542 if reset "add multiple addresses IPv6"; then 2543 pm_nl_set_limits $ns1 0 2 2544 pm_nl_set_limits $ns2 2 2 2545 addr_nr_ns1=2 speed=slow cestab_ns1=1 \ 2546 run_tests $ns1 $ns2 dead:beef:1::1 2547 chk_join_nr 2 2 2 2548 chk_add_nr 2 2 2549 chk_cestab_nr $ns1 0 2550 fi 2551} 2552 2553ipv6_tests() 2554{ 2555 # subflow IPv6 2556 if reset "single subflow IPv6"; then 2557 pm_nl_set_limits $ns1 0 1 2558 pm_nl_set_limits $ns2 0 1 2559 pm_nl_add_endpoint $ns2 dead:beef:3::2 dev ns2eth3 flags subflow 2560 speed=slow \ 2561 run_tests $ns1 $ns2 dead:beef:1::1 2562 chk_join_nr 1 1 1 2563 fi 2564 2565 # add_address, unused IPv6 2566 if reset "unused signal address IPv6"; then 2567 pm_nl_add_endpoint $ns1 dead:beef:2::1 flags signal 2568 speed=slow \ 2569 run_tests $ns1 $ns2 dead:beef:1::1 2570 chk_join_nr 0 0 0 2571 chk_add_nr 1 1 2572 fi 2573 2574 # signal address IPv6 2575 if reset "single address IPv6"; then 2576 pm_nl_set_limits $ns1 0 1 2577 pm_nl_add_endpoint $ns1 dead:beef:2::1 flags signal 2578 pm_nl_set_limits $ns2 1 1 2579 speed=slow \ 2580 run_tests $ns1 $ns2 dead:beef:1::1 2581 chk_join_nr 1 1 1 2582 chk_add_nr 1 1 2583 fi 2584 2585 # single address IPv6, remove 2586 if reset "remove single address IPv6"; then 2587 pm_nl_set_limits $ns1 0 1 2588 pm_nl_add_endpoint $ns1 dead:beef:2::1 flags signal 2589 pm_nl_set_limits $ns2 1 1 2590 addr_nr_ns1=-1 speed=slow \ 2591 run_tests $ns1 $ns2 dead:beef:1::1 2592 chk_join_nr 1 1 1 2593 chk_add_nr 1 1 2594 chk_rm_nr 1 1 invert 2595 fi 2596 2597 # subflow and signal IPv6, remove 2598 if reset "remove subflow and signal IPv6"; then 2599 pm_nl_set_limits $ns1 0 2 2600 pm_nl_add_endpoint $ns1 dead:beef:2::1 flags signal 2601 pm_nl_set_limits $ns2 1 2 2602 pm_nl_add_endpoint $ns2 dead:beef:3::2 dev ns2eth3 flags subflow 2603 addr_nr_ns1=-1 addr_nr_ns2=-1 speed=slow \ 2604 run_tests $ns1 $ns2 dead:beef:1::1 2605 chk_join_nr 2 2 2 2606 chk_add_nr 1 1 2607 chk_rm_nr 1 1 2608 fi 2609} 2610 2611v4mapped_tests() 2612{ 2613 # subflow IPv4-mapped to IPv4-mapped 2614 if reset "single subflow IPv4-mapped"; then 2615 pm_nl_set_limits $ns1 0 1 2616 pm_nl_set_limits $ns2 0 1 2617 pm_nl_add_endpoint $ns2 "::ffff:10.0.3.2" flags subflow 2618 run_tests $ns1 $ns2 "::ffff:10.0.1.1" 2619 chk_join_nr 1 1 1 2620 fi 2621 2622 # signal address IPv4-mapped with IPv4-mapped sk 2623 if reset "signal address IPv4-mapped"; then 2624 pm_nl_set_limits $ns1 0 1 2625 pm_nl_set_limits $ns2 1 1 2626 pm_nl_add_endpoint $ns1 "::ffff:10.0.2.1" flags signal 2627 run_tests $ns1 $ns2 "::ffff:10.0.1.1" 2628 chk_join_nr 1 1 1 2629 chk_add_nr 1 1 2630 fi 2631 2632 # subflow v4-map-v6 2633 if reset "single subflow v4-map-v6"; then 2634 pm_nl_set_limits $ns1 0 1 2635 pm_nl_set_limits $ns2 0 1 2636 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow 2637 run_tests $ns1 $ns2 "::ffff:10.0.1.1" 2638 chk_join_nr 1 1 1 2639 fi 2640 2641 # signal address v4-map-v6 2642 if reset "signal address v4-map-v6"; then 2643 pm_nl_set_limits $ns1 0 1 2644 pm_nl_set_limits $ns2 1 1 2645 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal 2646 run_tests $ns1 $ns2 "::ffff:10.0.1.1" 2647 chk_join_nr 1 1 1 2648 chk_add_nr 1 1 2649 fi 2650 2651 # subflow v6-map-v4 2652 if reset "single subflow v6-map-v4"; then 2653 pm_nl_set_limits $ns1 0 1 2654 pm_nl_set_limits $ns2 0 1 2655 pm_nl_add_endpoint $ns2 "::ffff:10.0.3.2" flags subflow 2656 run_tests $ns1 $ns2 10.0.1.1 2657 chk_join_nr 1 1 1 2658 fi 2659 2660 # signal address v6-map-v4 2661 if reset "signal address v6-map-v4"; then 2662 pm_nl_set_limits $ns1 0 1 2663 pm_nl_set_limits $ns2 1 1 2664 pm_nl_add_endpoint $ns1 "::ffff:10.0.2.1" flags signal 2665 run_tests $ns1 $ns2 10.0.1.1 2666 chk_join_nr 1 1 1 2667 chk_add_nr 1 1 2668 fi 2669 2670 # no subflow IPv6 to v4 address 2671 if reset "no JOIN with diff families v4-v6"; then 2672 pm_nl_set_limits $ns1 0 1 2673 pm_nl_set_limits $ns2 0 1 2674 pm_nl_add_endpoint $ns2 dead:beef:2::2 flags subflow 2675 run_tests $ns1 $ns2 10.0.1.1 2676 chk_join_nr 0 0 0 2677 fi 2678 2679 # no subflow IPv6 to v4 address even if v6 has a valid v4 at the end 2680 if reset "no JOIN with diff families v4-v6-2"; then 2681 pm_nl_set_limits $ns1 0 1 2682 pm_nl_set_limits $ns2 0 1 2683 pm_nl_add_endpoint $ns2 dead:beef:2::10.0.3.2 flags subflow 2684 run_tests $ns1 $ns2 10.0.1.1 2685 chk_join_nr 0 0 0 2686 fi 2687 2688 # no subflow IPv4 to v6 address, no need to slow down too then 2689 if reset "no JOIN with diff families v6-v4"; then 2690 pm_nl_set_limits $ns1 0 1 2691 pm_nl_set_limits $ns2 0 1 2692 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow 2693 run_tests $ns1 $ns2 dead:beef:1::1 2694 chk_join_nr 0 0 0 2695 fi 2696} 2697 2698mixed_tests() 2699{ 2700 if reset "IPv4 sockets do not use IPv6 addresses" && 2701 continue_if mptcp_lib_kversion_ge 6.3; then 2702 pm_nl_set_limits $ns1 0 1 2703 pm_nl_set_limits $ns2 1 1 2704 pm_nl_add_endpoint $ns1 dead:beef:2::1 flags signal 2705 speed=slow \ 2706 run_tests $ns1 $ns2 10.0.1.1 2707 chk_join_nr 0 0 0 2708 fi 2709 2710 # Need an IPv6 mptcp socket to allow subflows of both families 2711 if reset "simult IPv4 and IPv6 subflows" && 2712 continue_if mptcp_lib_kversion_ge 6.3; then 2713 pm_nl_set_limits $ns1 0 1 2714 pm_nl_set_limits $ns2 1 1 2715 pm_nl_add_endpoint $ns1 10.0.1.1 flags signal 2716 speed=slow \ 2717 run_tests $ns1 $ns2 dead:beef:2::1 2718 chk_join_nr 1 1 1 2719 fi 2720 2721 # cross families subflows will not be created even in fullmesh mode 2722 if reset "simult IPv4 and IPv6 subflows, fullmesh 1x1" && 2723 continue_if mptcp_lib_kversion_ge 6.3; then 2724 pm_nl_set_limits $ns1 0 4 2725 pm_nl_set_limits $ns2 1 4 2726 pm_nl_add_endpoint $ns2 dead:beef:2::2 flags subflow,fullmesh 2727 pm_nl_add_endpoint $ns1 10.0.1.1 flags signal 2728 speed=slow \ 2729 run_tests $ns1 $ns2 dead:beef:2::1 2730 chk_join_nr 1 1 1 2731 fi 2732 2733 # fullmesh still tries to create all the possibly subflows with 2734 # matching family 2735 if reset "simult IPv4 and IPv6 subflows, fullmesh 2x2" && 2736 continue_if mptcp_lib_kversion_ge 6.3; then 2737 pm_nl_set_limits $ns1 0 4 2738 pm_nl_set_limits $ns2 2 4 2739 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal 2740 pm_nl_add_endpoint $ns1 dead:beef:2::1 flags signal 2741 fullmesh=1 speed=slow \ 2742 run_tests $ns1 $ns2 dead:beef:1::1 2743 chk_join_nr 4 4 4 2744 fi 2745} 2746 2747backup_tests() 2748{ 2749 # single subflow, backup 2750 if reset "single subflow, backup" && 2751 continue_if mptcp_lib_kallsyms_has "subflow_rebuild_header$"; then 2752 pm_nl_set_limits $ns1 0 1 2753 pm_nl_set_limits $ns2 0 1 2754 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow,backup 2755 sflags=nobackup speed=slow \ 2756 run_tests $ns1 $ns2 10.0.1.1 2757 chk_join_nr 1 1 1 2758 chk_prio_nr 0 1 2759 fi 2760 2761 # single address, backup 2762 if reset "single address, backup" && 2763 continue_if mptcp_lib_kallsyms_has "subflow_rebuild_header$"; then 2764 pm_nl_set_limits $ns1 0 1 2765 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal 2766 pm_nl_set_limits $ns2 1 1 2767 sflags=backup speed=slow \ 2768 run_tests $ns1 $ns2 10.0.1.1 2769 chk_join_nr 1 1 1 2770 chk_add_nr 1 1 2771 chk_prio_nr 1 1 2772 fi 2773 2774 # single address with port, backup 2775 if reset "single address with port, backup" && 2776 continue_if mptcp_lib_kallsyms_has "subflow_rebuild_header$"; then 2777 pm_nl_set_limits $ns1 0 1 2778 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal port 10100 2779 pm_nl_set_limits $ns2 1 1 2780 sflags=backup speed=slow \ 2781 run_tests $ns1 $ns2 10.0.1.1 2782 chk_join_nr 1 1 1 2783 chk_add_nr 1 1 2784 chk_prio_nr 1 1 2785 fi 2786 2787 if reset "mpc backup" && 2788 continue_if mptcp_lib_kallsyms_doesnt_have "T mptcp_subflow_send_ack$"; then 2789 pm_nl_add_endpoint $ns2 10.0.1.2 flags subflow,backup 2790 speed=slow \ 2791 run_tests $ns1 $ns2 10.0.1.1 2792 chk_join_nr 0 0 0 2793 chk_prio_nr 0 1 2794 fi 2795 2796 if reset "mpc backup both sides" && 2797 continue_if mptcp_lib_kallsyms_doesnt_have "T mptcp_subflow_send_ack$"; then 2798 pm_nl_add_endpoint $ns1 10.0.1.1 flags subflow,backup 2799 pm_nl_add_endpoint $ns2 10.0.1.2 flags subflow,backup 2800 speed=slow \ 2801 run_tests $ns1 $ns2 10.0.1.1 2802 chk_join_nr 0 0 0 2803 chk_prio_nr 1 1 2804 fi 2805 2806 if reset "mpc switch to backup" && 2807 continue_if mptcp_lib_kallsyms_doesnt_have "T mptcp_subflow_send_ack$"; then 2808 pm_nl_add_endpoint $ns2 10.0.1.2 flags subflow 2809 sflags=backup speed=slow \ 2810 run_tests $ns1 $ns2 10.0.1.1 2811 chk_join_nr 0 0 0 2812 chk_prio_nr 0 1 2813 fi 2814 2815 if reset "mpc switch to backup both sides" && 2816 continue_if mptcp_lib_kallsyms_doesnt_have "T mptcp_subflow_send_ack$"; then 2817 pm_nl_add_endpoint $ns1 10.0.1.1 flags subflow 2818 pm_nl_add_endpoint $ns2 10.0.1.2 flags subflow 2819 sflags=backup speed=slow \ 2820 run_tests $ns1 $ns2 10.0.1.1 2821 chk_join_nr 0 0 0 2822 chk_prio_nr 1 1 2823 fi 2824} 2825 2826SUB_ESTABLISHED=10 # MPTCP_EVENT_SUB_ESTABLISHED 2827LISTENER_CREATED=15 #MPTCP_EVENT_LISTENER_CREATED 2828LISTENER_CLOSED=16 #MPTCP_EVENT_LISTENER_CLOSED 2829 2830AF_INET=2 2831AF_INET6=10 2832 2833verify_listener_events() 2834{ 2835 local evt=$1 2836 local e_type=$2 2837 local e_family=$3 2838 local e_saddr=$4 2839 local e_sport=$5 2840 local type 2841 local family 2842 local saddr 2843 local sport 2844 local name 2845 2846 if [ $e_type = $LISTENER_CREATED ]; then 2847 name="LISTENER_CREATED" 2848 elif [ $e_type = $LISTENER_CLOSED ]; then 2849 name="LISTENER_CLOSED " 2850 else 2851 name="$e_type" 2852 fi 2853 2854 print_check "$name $e_saddr:$e_sport" 2855 2856 if ! mptcp_lib_kallsyms_has "mptcp_event_pm_listener$"; then 2857 print_skip "event not supported" 2858 return 2859 fi 2860 2861 type=$(mptcp_lib_evts_get_info type "$evt" "$e_type") 2862 family=$(mptcp_lib_evts_get_info family "$evt" "$e_type") 2863 sport=$(mptcp_lib_evts_get_info sport "$evt" "$e_type") 2864 if [ $family ] && [ $family = $AF_INET6 ]; then 2865 saddr=$(mptcp_lib_evts_get_info saddr6 "$evt" "$e_type") 2866 else 2867 saddr=$(mptcp_lib_evts_get_info saddr4 "$evt" "$e_type") 2868 fi 2869 2870 if [ $type ] && [ $type = $e_type ] && 2871 [ $family ] && [ $family = $e_family ] && 2872 [ $saddr ] && [ $saddr = $e_saddr ] && 2873 [ $sport ] && [ $sport = $e_sport ]; then 2874 print_ok 2875 return 0 2876 fi 2877 fail_test "$e_type:$type $e_family:$family $e_saddr:$saddr $e_sport:$sport" 2878} 2879 2880add_addr_ports_tests() 2881{ 2882 # signal address with port 2883 if reset "signal address with port"; then 2884 pm_nl_set_limits $ns1 0 1 2885 pm_nl_set_limits $ns2 1 1 2886 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal port 10100 2887 run_tests $ns1 $ns2 10.0.1.1 2888 chk_join_nr 1 1 1 2889 chk_add_nr 1 1 1 2890 fi 2891 2892 # subflow and signal with port 2893 if reset "subflow and signal with port"; then 2894 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal port 10100 2895 pm_nl_set_limits $ns1 0 2 2896 pm_nl_set_limits $ns2 1 2 2897 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow 2898 run_tests $ns1 $ns2 10.0.1.1 2899 chk_join_nr 2 2 2 2900 chk_add_nr 1 1 1 2901 fi 2902 2903 # single address with port, remove 2904 # pm listener events 2905 if reset_with_events "remove single address with port"; then 2906 pm_nl_set_limits $ns1 0 1 2907 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal port 10100 2908 pm_nl_set_limits $ns2 1 1 2909 addr_nr_ns1=-1 speed=slow \ 2910 run_tests $ns1 $ns2 10.0.1.1 2911 chk_join_nr 1 1 1 2912 chk_add_nr 1 1 1 2913 chk_rm_nr 1 1 invert 2914 2915 verify_listener_events $evts_ns1 $LISTENER_CREATED $AF_INET 10.0.2.1 10100 2916 verify_listener_events $evts_ns1 $LISTENER_CLOSED $AF_INET 10.0.2.1 10100 2917 kill_events_pids 2918 fi 2919 2920 # subflow and signal with port, remove 2921 if reset "remove subflow and signal with port"; then 2922 pm_nl_set_limits $ns1 0 2 2923 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal port 10100 2924 pm_nl_set_limits $ns2 1 2 2925 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow 2926 addr_nr_ns1=-1 addr_nr_ns2=-1 speed=slow \ 2927 run_tests $ns1 $ns2 10.0.1.1 2928 chk_join_nr 2 2 2 2929 chk_add_nr 1 1 1 2930 chk_rm_nr 1 1 2931 fi 2932 2933 # subflows and signal with port, flush 2934 if reset "flush subflows and signal with port"; then 2935 pm_nl_set_limits $ns1 0 3 2936 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal port 10100 2937 pm_nl_set_limits $ns2 1 3 2938 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow 2939 pm_nl_add_endpoint $ns2 10.0.4.2 flags subflow 2940 addr_nr_ns1=-8 addr_nr_ns2=-2 speed=slow \ 2941 run_tests $ns1 $ns2 10.0.1.1 2942 chk_join_nr 3 3 3 2943 chk_add_nr 1 1 2944 chk_rm_nr 1 3 invert simult 2945 fi 2946 2947 # multiple addresses with port 2948 if reset "multiple addresses with port"; then 2949 pm_nl_set_limits $ns1 2 2 2950 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal port 10100 2951 pm_nl_add_endpoint $ns1 10.0.3.1 flags signal port 10100 2952 pm_nl_set_limits $ns2 2 2 2953 run_tests $ns1 $ns2 10.0.1.1 2954 chk_join_nr 2 2 2 2955 chk_add_nr 2 2 2 2956 fi 2957 2958 # multiple addresses with ports 2959 if reset "multiple addresses with ports"; then 2960 pm_nl_set_limits $ns1 2 2 2961 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal port 10100 2962 pm_nl_add_endpoint $ns1 10.0.3.1 flags signal port 10101 2963 pm_nl_set_limits $ns2 2 2 2964 run_tests $ns1 $ns2 10.0.1.1 2965 chk_join_nr 2 2 2 2966 chk_add_nr 2 2 2 2967 fi 2968} 2969 2970syncookies_tests() 2971{ 2972 # single subflow, syncookies 2973 if reset_with_cookies "single subflow with syn cookies"; then 2974 pm_nl_set_limits $ns1 0 1 2975 pm_nl_set_limits $ns2 0 1 2976 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow 2977 run_tests $ns1 $ns2 10.0.1.1 2978 chk_join_nr 1 1 1 2979 fi 2980 2981 # multiple subflows with syn cookies 2982 if reset_with_cookies "multiple subflows with syn cookies"; then 2983 pm_nl_set_limits $ns1 0 2 2984 pm_nl_set_limits $ns2 0 2 2985 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow 2986 pm_nl_add_endpoint $ns2 10.0.2.2 flags subflow 2987 run_tests $ns1 $ns2 10.0.1.1 2988 chk_join_nr 2 2 2 2989 fi 2990 2991 # multiple subflows limited by server 2992 if reset_with_cookies "subflows limited by server w cookies"; then 2993 pm_nl_set_limits $ns1 0 1 2994 pm_nl_set_limits $ns2 0 2 2995 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow 2996 pm_nl_add_endpoint $ns2 10.0.2.2 flags subflow 2997 run_tests $ns1 $ns2 10.0.1.1 2998 chk_join_nr 2 1 1 2999 fi 3000 3001 # test signal address with cookies 3002 if reset_with_cookies "signal address with syn cookies"; then 3003 pm_nl_set_limits $ns1 0 1 3004 pm_nl_set_limits $ns2 1 1 3005 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal 3006 run_tests $ns1 $ns2 10.0.1.1 3007 chk_join_nr 1 1 1 3008 chk_add_nr 1 1 3009 fi 3010 3011 # test cookie with subflow and signal 3012 if reset_with_cookies "subflow and signal w cookies"; then 3013 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal 3014 pm_nl_set_limits $ns1 0 2 3015 pm_nl_set_limits $ns2 1 2 3016 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow 3017 run_tests $ns1 $ns2 10.0.1.1 3018 chk_join_nr 2 2 2 3019 chk_add_nr 1 1 3020 fi 3021 3022 # accept and use add_addr with additional subflows 3023 if reset_with_cookies "subflows and signal w. cookies"; then 3024 pm_nl_set_limits $ns1 0 3 3025 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal 3026 pm_nl_set_limits $ns2 1 3 3027 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow 3028 pm_nl_add_endpoint $ns2 10.0.4.2 flags subflow 3029 run_tests $ns1 $ns2 10.0.1.1 3030 chk_join_nr 3 3 3 3031 chk_add_nr 1 1 3032 fi 3033} 3034 3035checksum_tests() 3036{ 3037 # checksum test 0 0 3038 if reset_with_checksum 0 0; then 3039 pm_nl_set_limits $ns1 0 1 3040 pm_nl_set_limits $ns2 0 1 3041 run_tests $ns1 $ns2 10.0.1.1 3042 chk_join_nr 0 0 0 3043 fi 3044 3045 # checksum test 1 1 3046 if reset_with_checksum 1 1; then 3047 pm_nl_set_limits $ns1 0 1 3048 pm_nl_set_limits $ns2 0 1 3049 run_tests $ns1 $ns2 10.0.1.1 3050 chk_join_nr 0 0 0 3051 fi 3052 3053 # checksum test 0 1 3054 if reset_with_checksum 0 1; then 3055 pm_nl_set_limits $ns1 0 1 3056 pm_nl_set_limits $ns2 0 1 3057 run_tests $ns1 $ns2 10.0.1.1 3058 chk_join_nr 0 0 0 3059 fi 3060 3061 # checksum test 1 0 3062 if reset_with_checksum 1 0; then 3063 pm_nl_set_limits $ns1 0 1 3064 pm_nl_set_limits $ns2 0 1 3065 run_tests $ns1 $ns2 10.0.1.1 3066 chk_join_nr 0 0 0 3067 fi 3068} 3069 3070deny_join_id0_tests() 3071{ 3072 # subflow allow join id0 ns1 3073 if reset_with_allow_join_id0 "single subflow allow join id0 ns1" 1 0; then 3074 pm_nl_set_limits $ns1 1 1 3075 pm_nl_set_limits $ns2 1 1 3076 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow 3077 run_tests $ns1 $ns2 10.0.1.1 3078 chk_join_nr 1 1 1 3079 fi 3080 3081 # subflow allow join id0 ns2 3082 if reset_with_allow_join_id0 "single subflow allow join id0 ns2" 0 1; then 3083 pm_nl_set_limits $ns1 1 1 3084 pm_nl_set_limits $ns2 1 1 3085 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow 3086 run_tests $ns1 $ns2 10.0.1.1 3087 chk_join_nr 0 0 0 3088 fi 3089 3090 # signal address allow join id0 ns1 3091 # ADD_ADDRs are not affected by allow_join_id0 value. 3092 if reset_with_allow_join_id0 "signal address allow join id0 ns1" 1 0; then 3093 pm_nl_set_limits $ns1 1 1 3094 pm_nl_set_limits $ns2 1 1 3095 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal 3096 run_tests $ns1 $ns2 10.0.1.1 3097 chk_join_nr 1 1 1 3098 chk_add_nr 1 1 3099 fi 3100 3101 # signal address allow join id0 ns2 3102 # ADD_ADDRs are not affected by allow_join_id0 value. 3103 if reset_with_allow_join_id0 "signal address allow join id0 ns2" 0 1; then 3104 pm_nl_set_limits $ns1 1 1 3105 pm_nl_set_limits $ns2 1 1 3106 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal 3107 run_tests $ns1 $ns2 10.0.1.1 3108 chk_join_nr 1 1 1 3109 chk_add_nr 1 1 3110 fi 3111 3112 # subflow and address allow join id0 ns1 3113 if reset_with_allow_join_id0 "subflow and address allow join id0 1" 1 0; then 3114 pm_nl_set_limits $ns1 2 2 3115 pm_nl_set_limits $ns2 2 2 3116 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal 3117 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow 3118 run_tests $ns1 $ns2 10.0.1.1 3119 chk_join_nr 2 2 2 3120 fi 3121 3122 # subflow and address allow join id0 ns2 3123 if reset_with_allow_join_id0 "subflow and address allow join id0 2" 0 1; then 3124 pm_nl_set_limits $ns1 2 2 3125 pm_nl_set_limits $ns2 2 2 3126 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal 3127 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow 3128 run_tests $ns1 $ns2 10.0.1.1 3129 chk_join_nr 1 1 1 3130 fi 3131} 3132 3133fullmesh_tests() 3134{ 3135 # fullmesh 1 3136 # 2 fullmesh addrs in ns2, added before the connection, 3137 # 1 non-fullmesh addr in ns1, added during the connection. 3138 if reset "fullmesh test 2x1"; then 3139 pm_nl_set_limits $ns1 0 4 3140 pm_nl_set_limits $ns2 1 4 3141 pm_nl_add_endpoint $ns2 10.0.2.2 flags subflow,fullmesh 3142 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow,fullmesh 3143 addr_nr_ns1=1 speed=slow \ 3144 run_tests $ns1 $ns2 10.0.1.1 3145 chk_join_nr 4 4 4 3146 chk_add_nr 1 1 3147 fi 3148 3149 # fullmesh 2 3150 # 1 non-fullmesh addr in ns1, added before the connection, 3151 # 1 fullmesh addr in ns2, added during the connection. 3152 if reset "fullmesh test 1x1"; then 3153 pm_nl_set_limits $ns1 1 3 3154 pm_nl_set_limits $ns2 1 3 3155 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal 3156 fullmesh=1 speed=slow \ 3157 run_tests $ns1 $ns2 10.0.1.1 3158 chk_join_nr 3 3 3 3159 chk_add_nr 1 1 3160 fi 3161 3162 # fullmesh 3 3163 # 1 non-fullmesh addr in ns1, added before the connection, 3164 # 2 fullmesh addrs in ns2, added during the connection. 3165 if reset "fullmesh test 1x2"; then 3166 pm_nl_set_limits $ns1 2 5 3167 pm_nl_set_limits $ns2 1 5 3168 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal 3169 fullmesh=2 speed=slow \ 3170 run_tests $ns1 $ns2 10.0.1.1 3171 chk_join_nr 5 5 5 3172 chk_add_nr 1 1 3173 fi 3174 3175 # fullmesh 4 3176 # 1 non-fullmesh addr in ns1, added before the connection, 3177 # 2 fullmesh addrs in ns2, added during the connection, 3178 # limit max_subflows to 4. 3179 if reset "fullmesh test 1x2, limited"; then 3180 pm_nl_set_limits $ns1 2 4 3181 pm_nl_set_limits $ns2 1 4 3182 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal 3183 fullmesh=2 speed=slow \ 3184 run_tests $ns1 $ns2 10.0.1.1 3185 chk_join_nr 4 4 4 3186 chk_add_nr 1 1 3187 fi 3188 3189 # set fullmesh flag 3190 if reset "set fullmesh flag test" && 3191 continue_if mptcp_lib_kversion_ge 5.18; then 3192 pm_nl_set_limits $ns1 4 4 3193 pm_nl_add_endpoint $ns1 10.0.2.1 flags subflow 3194 pm_nl_set_limits $ns2 4 4 3195 addr_nr_ns2=1 sflags=fullmesh speed=slow \ 3196 run_tests $ns1 $ns2 10.0.1.1 3197 chk_join_nr 2 2 2 3198 chk_rm_nr 0 1 3199 fi 3200 3201 # set nofullmesh flag 3202 if reset "set nofullmesh flag test" && 3203 continue_if mptcp_lib_kversion_ge 5.18; then 3204 pm_nl_set_limits $ns1 4 4 3205 pm_nl_add_endpoint $ns1 10.0.2.1 flags subflow,fullmesh 3206 pm_nl_set_limits $ns2 4 4 3207 fullmesh=1 sflags=nofullmesh speed=slow \ 3208 run_tests $ns1 $ns2 10.0.1.1 3209 chk_join_nr 2 2 2 3210 chk_rm_nr 0 1 3211 fi 3212 3213 # set backup,fullmesh flags 3214 if reset "set backup,fullmesh flags test" && 3215 continue_if mptcp_lib_kversion_ge 5.18; then 3216 pm_nl_set_limits $ns1 4 4 3217 pm_nl_add_endpoint $ns1 10.0.2.1 flags subflow 3218 pm_nl_set_limits $ns2 4 4 3219 addr_nr_ns2=1 sflags=backup,fullmesh speed=slow \ 3220 run_tests $ns1 $ns2 10.0.1.1 3221 chk_join_nr 2 2 2 3222 chk_prio_nr 0 1 3223 chk_rm_nr 0 1 3224 fi 3225 3226 # set nobackup,nofullmesh flags 3227 if reset "set nobackup,nofullmesh flags test" && 3228 continue_if mptcp_lib_kversion_ge 5.18; then 3229 pm_nl_set_limits $ns1 4 4 3230 pm_nl_set_limits $ns2 4 4 3231 pm_nl_add_endpoint $ns2 10.0.2.2 flags subflow,backup,fullmesh 3232 sflags=nobackup,nofullmesh speed=slow \ 3233 run_tests $ns1 $ns2 10.0.1.1 3234 chk_join_nr 2 2 2 3235 chk_prio_nr 0 1 3236 chk_rm_nr 0 1 3237 fi 3238} 3239 3240fastclose_tests() 3241{ 3242 if reset_check_counter "fastclose test" "MPTcpExtMPFastcloseTx"; then 3243 test_linkfail=1024 fastclose=client \ 3244 run_tests $ns1 $ns2 10.0.1.1 3245 chk_join_nr 0 0 0 3246 chk_fclose_nr 1 1 3247 chk_rst_nr 1 1 invert 3248 fi 3249 3250 if reset_check_counter "fastclose server test" "MPTcpExtMPFastcloseRx"; then 3251 test_linkfail=1024 fastclose=server \ 3252 run_tests $ns1 $ns2 10.0.1.1 3253 chk_join_nr 0 0 0 0 0 0 1 3254 chk_fclose_nr 1 1 invert 3255 chk_rst_nr 1 1 3256 fi 3257} 3258 3259pedit_action_pkts() 3260{ 3261 tc -n $ns2 -j -s action show action pedit index 100 | \ 3262 mptcp_lib_get_info_value \"packets\" packets 3263} 3264 3265fail_tests() 3266{ 3267 # single subflow 3268 if reset_with_fail "Infinite map" 1; then 3269 test_linkfail=128 \ 3270 run_tests $ns1 $ns2 10.0.1.1 3271 chk_join_nr 0 0 0 +1 +0 1 0 1 "$(pedit_action_pkts)" 3272 chk_fail_nr 1 -1 invert 3273 fi 3274 3275 # multiple subflows 3276 if reset_with_fail "MP_FAIL MP_RST" 2; then 3277 tc -n $ns2 qdisc add dev ns2eth1 root netem rate 1mbit delay 5 3278 pm_nl_set_limits $ns1 0 1 3279 pm_nl_set_limits $ns2 0 1 3280 pm_nl_add_endpoint $ns2 10.0.2.2 dev ns2eth2 flags subflow 3281 test_linkfail=1024 \ 3282 run_tests $ns1 $ns2 10.0.1.1 3283 chk_join_nr 1 1 1 1 0 1 1 0 "$(pedit_action_pkts)" 3284 fi 3285} 3286 3287# $1: ns ; $2: addr ; $3: id 3288userspace_pm_add_addr() 3289{ 3290 local evts=$evts_ns1 3291 local tk 3292 3293 [ "$1" == "$ns2" ] && evts=$evts_ns2 3294 tk=$(mptcp_lib_evts_get_info token "$evts") 3295 3296 ip netns exec $1 ./pm_nl_ctl ann $2 token $tk id $3 3297 sleep 1 3298} 3299 3300# $1: ns ; $2: id 3301userspace_pm_rm_addr() 3302{ 3303 local evts=$evts_ns1 3304 local tk 3305 local cnt 3306 3307 [ "$1" == "$ns2" ] && evts=$evts_ns2 3308 tk=$(mptcp_lib_evts_get_info token "$evts") 3309 3310 cnt=$(rm_addr_count ${1}) 3311 ip netns exec $1 ./pm_nl_ctl rem token $tk id $2 3312 wait_rm_addr $1 "${cnt}" 3313} 3314 3315# $1: ns ; $2: addr ; $3: id 3316userspace_pm_add_sf() 3317{ 3318 local evts=$evts_ns1 3319 local tk da dp 3320 3321 [ "$1" == "$ns2" ] && evts=$evts_ns2 3322 tk=$(mptcp_lib_evts_get_info token "$evts") 3323 da=$(mptcp_lib_evts_get_info daddr4 "$evts") 3324 dp=$(mptcp_lib_evts_get_info dport "$evts") 3325 3326 ip netns exec $1 ./pm_nl_ctl csf lip $2 lid $3 \ 3327 rip $da rport $dp token $tk 3328 sleep 1 3329} 3330 3331# $1: ns ; $2: addr $3: event type 3332userspace_pm_rm_sf() 3333{ 3334 local evts=$evts_ns1 3335 local t=${3:-1} 3336 local ip=4 3337 local tk da dp sp 3338 local cnt 3339 3340 [ "$1" == "$ns2" ] && evts=$evts_ns2 3341 if mptcp_lib_is_v6 $2; then ip=6; fi 3342 tk=$(mptcp_lib_evts_get_info token "$evts") 3343 da=$(mptcp_lib_evts_get_info "daddr$ip" "$evts" $t) 3344 dp=$(mptcp_lib_evts_get_info dport "$evts" $t) 3345 sp=$(mptcp_lib_evts_get_info sport "$evts" $t) 3346 3347 cnt=$(rm_sf_count ${1}) 3348 ip netns exec $1 ./pm_nl_ctl dsf lip $2 lport $sp \ 3349 rip $da rport $dp token $tk 3350 wait_rm_sf $1 "${cnt}" 3351} 3352 3353userspace_tests() 3354{ 3355 # userspace pm type prevents add_addr 3356 if reset "userspace pm type prevents add_addr" && 3357 continue_if mptcp_lib_has_file '/proc/sys/net/mptcp/pm_type'; then 3358 set_userspace_pm $ns1 3359 pm_nl_set_limits $ns1 0 2 3360 pm_nl_set_limits $ns2 0 2 3361 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal 3362 run_tests $ns1 $ns2 10.0.1.1 3363 chk_join_nr 0 0 0 3364 chk_add_nr 0 0 3365 fi 3366 3367 # userspace pm type does not echo add_addr without daemon 3368 if reset "userspace pm no echo w/o daemon" && 3369 continue_if mptcp_lib_has_file '/proc/sys/net/mptcp/pm_type'; then 3370 set_userspace_pm $ns2 3371 pm_nl_set_limits $ns1 0 2 3372 pm_nl_set_limits $ns2 0 2 3373 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal 3374 run_tests $ns1 $ns2 10.0.1.1 3375 chk_join_nr 0 0 0 3376 chk_add_nr 1 0 3377 fi 3378 3379 # userspace pm type rejects join 3380 if reset "userspace pm type rejects join" && 3381 continue_if mptcp_lib_has_file '/proc/sys/net/mptcp/pm_type'; then 3382 set_userspace_pm $ns1 3383 pm_nl_set_limits $ns1 1 1 3384 pm_nl_set_limits $ns2 1 1 3385 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow 3386 run_tests $ns1 $ns2 10.0.1.1 3387 chk_join_nr 1 1 0 3388 fi 3389 3390 # userspace pm type does not send join 3391 if reset "userspace pm type does not send join" && 3392 continue_if mptcp_lib_has_file '/proc/sys/net/mptcp/pm_type'; then 3393 set_userspace_pm $ns2 3394 pm_nl_set_limits $ns1 1 1 3395 pm_nl_set_limits $ns2 1 1 3396 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow 3397 run_tests $ns1 $ns2 10.0.1.1 3398 chk_join_nr 0 0 0 3399 fi 3400 3401 # userspace pm type prevents mp_prio 3402 if reset "userspace pm type prevents mp_prio" && 3403 continue_if mptcp_lib_has_file '/proc/sys/net/mptcp/pm_type'; then 3404 set_userspace_pm $ns1 3405 pm_nl_set_limits $ns1 1 1 3406 pm_nl_set_limits $ns2 1 1 3407 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow 3408 sflags=backup speed=slow \ 3409 run_tests $ns1 $ns2 10.0.1.1 3410 chk_join_nr 1 1 0 3411 chk_prio_nr 0 0 3412 fi 3413 3414 # userspace pm type prevents rm_addr 3415 if reset "userspace pm type prevents rm_addr" && 3416 continue_if mptcp_lib_has_file '/proc/sys/net/mptcp/pm_type'; then 3417 set_userspace_pm $ns1 3418 set_userspace_pm $ns2 3419 pm_nl_set_limits $ns1 0 1 3420 pm_nl_set_limits $ns2 0 1 3421 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow 3422 addr_nr_ns2=-1 speed=slow \ 3423 run_tests $ns1 $ns2 10.0.1.1 3424 chk_join_nr 0 0 0 3425 chk_rm_nr 0 0 3426 fi 3427 3428 # userspace pm add & remove address 3429 if reset_with_events "userspace pm add & remove address" && 3430 continue_if mptcp_lib_has_file '/proc/sys/net/mptcp/pm_type'; then 3431 set_userspace_pm $ns1 3432 pm_nl_set_limits $ns2 1 1 3433 speed=5 \ 3434 run_tests $ns1 $ns2 10.0.1.1 & 3435 local tests_pid=$! 3436 wait_mpj $ns1 3437 userspace_pm_add_addr $ns1 10.0.2.1 10 3438 chk_join_nr 1 1 1 3439 chk_add_nr 1 1 3440 chk_mptcp_info subflows 1 subflows 1 3441 chk_subflows_total 2 2 3442 chk_mptcp_info add_addr_signal 1 add_addr_accepted 1 3443 userspace_pm_rm_addr $ns1 10 3444 userspace_pm_rm_sf $ns1 "::ffff:10.0.2.1" $SUB_ESTABLISHED 3445 chk_rm_nr 1 1 invert 3446 chk_mptcp_info subflows 0 subflows 0 3447 chk_subflows_total 1 1 3448 kill_events_pids 3449 mptcp_lib_kill_wait $tests_pid 3450 fi 3451 3452 # userspace pm create destroy subflow 3453 if reset_with_events "userspace pm create destroy subflow" && 3454 continue_if mptcp_lib_has_file '/proc/sys/net/mptcp/pm_type'; then 3455 set_userspace_pm $ns2 3456 pm_nl_set_limits $ns1 0 1 3457 speed=5 \ 3458 run_tests $ns1 $ns2 10.0.1.1 & 3459 local tests_pid=$! 3460 wait_mpj $ns2 3461 userspace_pm_add_sf $ns2 10.0.3.2 20 3462 chk_join_nr 1 1 1 3463 chk_mptcp_info subflows 1 subflows 1 3464 chk_subflows_total 2 2 3465 userspace_pm_rm_addr $ns2 20 3466 userspace_pm_rm_sf $ns2 10.0.3.2 $SUB_ESTABLISHED 3467 chk_rm_nr 1 1 3468 chk_mptcp_info subflows 0 subflows 0 3469 chk_subflows_total 1 1 3470 kill_events_pids 3471 mptcp_lib_kill_wait $tests_pid 3472 fi 3473 3474 # userspace pm create id 0 subflow 3475 if reset_with_events "userspace pm create id 0 subflow" && 3476 continue_if mptcp_lib_has_file '/proc/sys/net/mptcp/pm_type'; then 3477 set_userspace_pm $ns2 3478 pm_nl_set_limits $ns1 0 1 3479 speed=5 \ 3480 run_tests $ns1 $ns2 10.0.1.1 & 3481 local tests_pid=$! 3482 wait_mpj $ns2 3483 chk_mptcp_info subflows 0 subflows 0 3484 chk_subflows_total 1 1 3485 userspace_pm_add_sf $ns2 10.0.3.2 0 3486 chk_join_nr 1 1 1 3487 chk_mptcp_info subflows 1 subflows 1 3488 chk_subflows_total 2 2 3489 kill_events_pids 3490 mptcp_lib_kill_wait $tests_pid 3491 fi 3492 3493 # userspace pm remove initial subflow 3494 if reset_with_events "userspace pm remove initial subflow" && 3495 continue_if mptcp_lib_has_file '/proc/sys/net/mptcp/pm_type'; then 3496 set_userspace_pm $ns2 3497 pm_nl_set_limits $ns1 0 1 3498 speed=5 \ 3499 run_tests $ns1 $ns2 10.0.1.1 & 3500 local tests_pid=$! 3501 wait_mpj $ns2 3502 userspace_pm_add_sf $ns2 10.0.3.2 20 3503 chk_join_nr 1 1 1 3504 chk_mptcp_info subflows 1 subflows 1 3505 chk_subflows_total 2 2 3506 userspace_pm_rm_sf $ns2 10.0.1.2 3507 # we don't look at the counter linked to the RM_ADDR but 3508 # to the one linked to the subflows that have been removed 3509 chk_rm_nr 0 1 3510 chk_rst_nr 0 0 invert 3511 chk_mptcp_info subflows 1 subflows 1 3512 chk_subflows_total 1 1 3513 kill_events_pids 3514 mptcp_lib_kill_wait $tests_pid 3515 fi 3516 3517 # userspace pm send RM_ADDR for ID 0 3518 if reset_with_events "userspace pm send RM_ADDR for ID 0" && 3519 continue_if mptcp_lib_has_file '/proc/sys/net/mptcp/pm_type'; then 3520 set_userspace_pm $ns1 3521 pm_nl_set_limits $ns2 1 1 3522 speed=5 \ 3523 run_tests $ns1 $ns2 10.0.1.1 & 3524 local tests_pid=$! 3525 wait_mpj $ns1 3526 userspace_pm_add_addr $ns1 10.0.2.1 10 3527 chk_join_nr 1 1 1 3528 chk_add_nr 1 1 3529 chk_mptcp_info subflows 1 subflows 1 3530 chk_subflows_total 2 2 3531 chk_mptcp_info add_addr_signal 1 add_addr_accepted 1 3532 userspace_pm_rm_addr $ns1 0 3533 # we don't look at the counter linked to the subflows that 3534 # have been removed but to the one linked to the RM_ADDR 3535 chk_rm_nr 1 0 invert 3536 chk_rst_nr 0 0 invert 3537 chk_mptcp_info subflows 1 subflows 1 3538 chk_subflows_total 1 1 3539 kill_events_pids 3540 mptcp_lib_kill_wait $tests_pid 3541 fi 3542} 3543 3544endpoint_tests() 3545{ 3546 # subflow_rebuild_header is needed to support the implicit flag 3547 # userspace pm type prevents add_addr 3548 if reset "implicit EP" && 3549 mptcp_lib_kallsyms_has "subflow_rebuild_header$"; then 3550 pm_nl_set_limits $ns1 2 2 3551 pm_nl_set_limits $ns2 2 2 3552 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal 3553 speed=slow \ 3554 run_tests $ns1 $ns2 10.0.1.1 & 3555 local tests_pid=$! 3556 3557 wait_mpj $ns1 3558 pm_nl_check_endpoint "creation" \ 3559 $ns2 10.0.2.2 id 1 flags implicit 3560 chk_mptcp_info subflows 1 subflows 1 3561 chk_mptcp_info add_addr_signal 1 add_addr_accepted 1 3562 3563 pm_nl_add_endpoint $ns2 10.0.2.2 id 33 2>/dev/null 3564 pm_nl_check_endpoint "ID change is prevented" \ 3565 $ns2 10.0.2.2 id 1 flags implicit 3566 3567 pm_nl_add_endpoint $ns2 10.0.2.2 flags signal 3568 pm_nl_check_endpoint "modif is allowed" \ 3569 $ns2 10.0.2.2 id 1 flags signal 3570 mptcp_lib_kill_wait $tests_pid 3571 fi 3572 3573 if reset "delete and re-add" && 3574 mptcp_lib_kallsyms_has "subflow_rebuild_header$"; then 3575 pm_nl_set_limits $ns1 1 1 3576 pm_nl_set_limits $ns2 1 1 3577 pm_nl_add_endpoint $ns2 10.0.2.2 id 2 dev ns2eth2 flags subflow 3578 test_linkfail=4 speed=20 \ 3579 run_tests $ns1 $ns2 10.0.1.1 & 3580 local tests_pid=$! 3581 3582 wait_mpj $ns2 3583 chk_subflow_nr "before delete" 2 3584 chk_mptcp_info subflows 1 subflows 1 3585 3586 pm_nl_del_endpoint $ns2 2 10.0.2.2 3587 sleep 0.5 3588 chk_subflow_nr "after delete" 1 3589 chk_mptcp_info subflows 0 subflows 0 3590 3591 pm_nl_add_endpoint $ns2 10.0.2.2 dev ns2eth2 flags subflow 3592 wait_mpj $ns2 3593 chk_subflow_nr "after re-add" 2 3594 chk_mptcp_info subflows 1 subflows 1 3595 mptcp_lib_kill_wait $tests_pid 3596 fi 3597} 3598 3599# [$1: error message] 3600usage() 3601{ 3602 if [ -n "${1}" ]; then 3603 echo "${1}" 3604 ret=1 3605 fi 3606 3607 echo "mptcp_join usage:" 3608 3609 local key 3610 for key in "${!all_tests[@]}"; do 3611 echo " -${key} ${all_tests[${key}]}" 3612 done 3613 3614 echo " -c capture pcap files" 3615 echo " -C enable data checksum" 3616 echo " -i use ip mptcp" 3617 echo " -h help" 3618 3619 echo "[test ids|names]" 3620 3621 exit ${ret} 3622} 3623 3624 3625# Use a "simple" array to force an specific order we cannot have with an associative one 3626all_tests_sorted=( 3627 f@subflows_tests 3628 e@subflows_error_tests 3629 s@signal_address_tests 3630 l@link_failure_tests 3631 t@add_addr_timeout_tests 3632 r@remove_tests 3633 a@add_tests 3634 6@ipv6_tests 3635 4@v4mapped_tests 3636 M@mixed_tests 3637 b@backup_tests 3638 p@add_addr_ports_tests 3639 k@syncookies_tests 3640 S@checksum_tests 3641 d@deny_join_id0_tests 3642 m@fullmesh_tests 3643 z@fastclose_tests 3644 F@fail_tests 3645 u@userspace_tests 3646 I@endpoint_tests 3647) 3648 3649all_tests_args="" 3650all_tests_names=() 3651for subtests in "${all_tests_sorted[@]}"; do 3652 key="${subtests%@*}" 3653 value="${subtests#*@}" 3654 3655 all_tests_args+="${key}" 3656 all_tests_names+=("${value}") 3657 all_tests[${key}]="${value}" 3658done 3659 3660tests=() 3661while getopts "${all_tests_args}cCih" opt; do 3662 case $opt in 3663 ["${all_tests_args}"]) 3664 tests+=("${all_tests[${opt}]}") 3665 ;; 3666 c) 3667 capture=1 3668 ;; 3669 C) 3670 checksum=1 3671 ;; 3672 i) 3673 ip_mptcp=1 3674 ;; 3675 h) 3676 usage 3677 ;; 3678 *) 3679 usage "Unknown option: -${opt}" 3680 ;; 3681 esac 3682done 3683 3684shift $((OPTIND - 1)) 3685 3686for arg in "${@}"; do 3687 if [[ "${arg}" =~ ^[0-9]+$ ]]; then 3688 only_tests_ids+=("${arg}") 3689 else 3690 only_tests_names+=("${arg}") 3691 fi 3692done 3693 3694if [ ${#tests[@]} -eq 0 ]; then 3695 tests=("${all_tests_names[@]}") 3696fi 3697 3698for subtests in "${tests[@]}"; do 3699 "${subtests}" 3700done 3701 3702if [ ${ret} -ne 0 ]; then 3703 echo 3704 echo "${#failed_tests[@]} failure(s) has(ve) been detected:" 3705 for i in $(get_failed_tests_ids); do 3706 echo -e "\t- ${i}: ${failed_tests[${i}]}" 3707 done 3708 echo 3709fi 3710 3711append_prev_results 3712mptcp_lib_result_print_all_tap 3713 3714exit $ret 3715