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