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