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