tools/testing/selftests/net/mptcp/mptcp_join.sh

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