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 ret=0
  10 sin=""
  11 sinfail=""
  12 sout=""
  13 cin=""
  14 cinfail=""
  15 cinsent=""
  16 cout=""
  17 capout=""
  18 ns1=""
  19 ns2=""
  20 ksft_skip=4
  21 timeout_poll=30
  22 timeout_test=$((timeout_poll * 2 + 1))
  23 capture=0
  24 checksum=0
  25 ip_mptcp=0
  26 check_invert=0
  27 validate_checksum=0
  28 init=0
  29
  30 declare -A all_tests
  31 declare -a only_tests_ids
  32 declare -a only_tests_names
  33 declare -A failed_tests
  34 TEST_COUNT=0
  35 TEST_NAME=""
  36 nr_blank=40
  37
  38 export FAILING_LINKS=""
  39
  40 # generated using "nfbpf_compile '(ip && (ip[54] & 0xf0) == 0x30) ||
  41 #                                 (ip6 && (ip6[74] & 0xf0) == 0x30)'"
  42 CBPF_MPTCP_SUBOPTION_ADD_ADDR="14,
  43                                48 0 0 0,
  44                                84 0 0 240,
  45                                21 0 3 64,
  46                                48 0 0 54,
  47                                84 0 0 240,
  48                                21 6 7 48,
  49                                48 0 0 0,
  50                                84 0 0 240,
  51                                21 0 4 96,
  52                                48 0 0 74,
  53                                84 0 0 240,
  54                                21 0 1 48,
  55                                6 0 0 65535,
  56                                6 0 0 0"
  57
  58 init_partial()
  59 {
  60         capout=$(mktemp)
  61
  62         local rndh
  63         rndh=$(mktemp -u XXXXXX)
  64
  65         ns1="ns1-$rndh"
  66         ns2="ns2-$rndh"
  67
  68         local netns
  69         for netns in "$ns1" "$ns2"; do
  70                 ip netns add $netns || exit $ksft_skip
  71                 ip -net $netns link set lo up
  72                 ip netns exec $netns sysctl -q net.mptcp.enabled=1
  73                 ip netns exec $netns sysctl -q net.ipv4.conf.all.rp_filter=0
  74                 ip netns exec $netns sysctl -q net.ipv4.conf.default.rp_filter=0
  75                 if [ $checksum -eq 1 ]; then
  76                         ip netns exec $netns sysctl -q net.mptcp.checksum_enabled=1
  77                 fi
  78         done
  79
  80         check_invert=0
  81         validate_checksum=$checksum
  82         FAILING_LINKS=""
  83
  84         #  ns1         ns2
  85         # ns1eth1    ns2eth1
  86         # ns1eth2    ns2eth2
  87         # ns1eth3    ns2eth3
  88         # ns1eth4    ns2eth4
  89
  90         local i
  91         for i in $(seq 1 4); do
  92                 ip link add ns1eth$i netns "$ns1" type veth peer name ns2eth$i netns "$ns2"
  93                 ip -net "$ns1" addr add 10.0.$i.1/24 dev ns1eth$i
  94                 ip -net "$ns1" addr add dead:beef:$i::1/64 dev ns1eth$i nodad
  95                 ip -net "$ns1" link set ns1eth$i up
  96
  97                 ip -net "$ns2" addr add 10.0.$i.2/24 dev ns2eth$i
  98                 ip -net "$ns2" addr add dead:beef:$i::2/64 dev ns2eth$i nodad
  99                 ip -net "$ns2" link set ns2eth$i up
 100
 101                 # let $ns2 reach any $ns1 address from any interface
 102                 ip -net "$ns2" route add default via 10.0.$i.1 dev ns2eth$i metric 10$i
 103                 ip -net "$ns2" route add default via dead:beef:$i::1 dev ns2eth$i metric 10$i
 104         done
 105 }
 106
 107 init_shapers()
 108 {
 109         local i
 110         for i in $(seq 1 4); do
 111                 tc -n $ns1 qdisc add dev ns1eth$i root netem rate 20mbit delay 1
 112                 tc -n $ns2 qdisc add dev ns2eth$i root netem rate 20mbit delay 1
 113         done
 114 }
 115
 116 cleanup_partial()
 117 {
 118         rm -f "$capout"
 119
 120         local netns
 121         for netns in "$ns1" "$ns2"; do
 122                 ip netns del $netns
 123                 rm -f /tmp/$netns.{nstat,out}
 124         done
 125 }
 126
 127 check_tools()
 128 {
 129         if ! ip -Version &> /dev/null; then
 130                 echo "SKIP: Could not run test without ip tool"
 131                 exit $ksft_skip
 132         fi
 133
 134         if ! iptables -V &> /dev/null; then
 135                 echo "SKIP: Could not run all tests without iptables tool"
 136                 exit $ksft_skip
 137         fi
 138
 139         if ! ip6tables -V &> /dev/null; then
 140                 echo "SKIP: Could not run all tests without ip6tables tool"
 141                 exit $ksft_skip
 142         fi
 143 }
 144
 145 init() {
 146         init=1
 147
 148         check_tools
 149
 150         sin=$(mktemp)
 151         sout=$(mktemp)
 152         cin=$(mktemp)
 153         cinsent=$(mktemp)
 154         cout=$(mktemp)
 155
 156         trap cleanup EXIT
 157
 158         make_file "$cin" "client" 1
 159         make_file "$sin" "server" 1
 160 }
 161
 162 cleanup()
 163 {
 164         rm -f "$cin" "$cout" "$sinfail"
 165         rm -f "$sin" "$sout" "$cinsent" "$cinfail"
 166         cleanup_partial
 167 }
 168
 169 skip_test()
 170 {
 171         if [ "${#only_tests_ids[@]}" -eq 0 ] && [ "${#only_tests_names[@]}" -eq 0 ]; then
 172                 return 1
 173         fi
 174
 175         local i
 176         for i in "${only_tests_ids[@]}"; do
 177                 if [ "${TEST_COUNT}" -eq "${i}" ]; then
 178                         return 1
 179                 fi
 180         done
 181         for i in "${only_tests_names[@]}"; do
 182                 if [ "${TEST_NAME}" = "${i}" ]; then
 183                         return 1
 184                 fi
 185         done
 186
 187         return 0
 188 }
 189
 190 # $1: test name
 191 reset()
 192 {
 193         TEST_NAME="${1}"
 194
 195         TEST_COUNT=$((TEST_COUNT+1))
 196
 197         if skip_test; then
 198                 return 1
 199         fi
 200
 201         if [ "${init}" != "1" ]; then
 202                 init
 203         else
 204                 cleanup_partial
 205         fi
 206
 207         init_partial
 208
 209         return 0
 210 }
 211
 212 # $1: test name
 213 reset_with_cookies()
 214 {
 215         reset "${1}" || return 1
 216
 217         local netns
 218         for netns in "$ns1" "$ns2"; do
 219                 ip netns exec $netns sysctl -q net.ipv4.tcp_syncookies=2
 220         done
 221 }
 222
 223 # $1: test name
 224 reset_with_add_addr_timeout()
 225 {
 226         local ip="${2:-4}"
 227         local tables
 228
 229         reset "${1}" || return 1
 230
 231         tables="iptables"
 232         if [ $ip -eq 6 ]; then
 233                 tables="ip6tables"
 234         fi
 235
 236         ip netns exec $ns1 sysctl -q net.mptcp.add_addr_timeout=1
 237         ip netns exec $ns2 $tables -A OUTPUT -p tcp \
 238                 -m tcp --tcp-option 30 \
 239                 -m bpf --bytecode \
 240                 "$CBPF_MPTCP_SUBOPTION_ADD_ADDR" \
 241                 -j DROP
 242 }
 243
 244 # $1: test name
 245 reset_with_checksum()
 246 {
 247         local ns1_enable=$1
 248         local ns2_enable=$2
 249
 250         reset "checksum test ${1} ${2}" || return 1
 251
 252         ip netns exec $ns1 sysctl -q net.mptcp.checksum_enabled=$ns1_enable
 253         ip netns exec $ns2 sysctl -q net.mptcp.checksum_enabled=$ns2_enable
 254
 255         validate_checksum=1
 256 }
 257
 258 reset_with_allow_join_id0()
 259 {
 260         local ns1_enable=$2
 261         local ns2_enable=$3
 262
 263         reset "${1}" || return 1
 264
 265         ip netns exec $ns1 sysctl -q net.mptcp.allow_join_initial_addr_port=$ns1_enable
 266         ip netns exec $ns2 sysctl -q net.mptcp.allow_join_initial_addr_port=$ns2_enable
 267 }
 268
 269 fail_test()
 270 {
 271         ret=1
 272         failed_tests[${TEST_COUNT}]="${TEST_NAME}"
 273 }
 274
 275 get_failed_tests_ids()
 276 {
 277         # sorted
 278         local i
 279         for i in "${!failed_tests[@]}"; do
 280                 echo "${i}"
 281         done | sort -n
 282 }
 283
 284 print_file_err()
 285 {
 286         ls -l "$1" 1>&2
 287         echo "Trailing bytes are: "
 288         tail -c 27 "$1"
 289 }
 290
 291 check_transfer()
 292 {
 293         local in=$1
 294         local out=$2
 295         local what=$3
 296         local i a b
 297
 298         local line
 299         cmp -l "$in" "$out" | while read -r i a b; do
 300                 local sum=$((0${a} + 0${b}))
 301                 if [ $check_invert -eq 0 ] || [ $sum -ne $((0xff)) ]; then
 302                         echo "[ FAIL ] $what does not match (in, out):"
 303                         print_file_err "$in"
 304                         print_file_err "$out"
 305                         fail_test
 306
 307                         return 1
 308                 else
 309                         echo "$what has inverted byte at ${i}"
 310                 fi
 311         done
 312
 313         return 0
 314 }
 315
 316 do_ping()
 317 {
 318         local listener_ns="$1"
 319         local connector_ns="$2"
 320         local connect_addr="$3"
 321
 322         if ! ip netns exec ${connector_ns} ping -q -c 1 $connect_addr >/dev/null; then
 323                 echo "$listener_ns -> $connect_addr connectivity [ FAIL ]" 1>&2
 324                 fail_test
 325         fi
 326 }
 327
 328 link_failure()
 329 {
 330         local ns="$1"
 331
 332         if [ -z "$FAILING_LINKS" ]; then
 333                 l=$((RANDOM%4))
 334                 FAILING_LINKS=$((l+1))
 335         fi
 336
 337         local l
 338         for l in $FAILING_LINKS; do
 339                 local veth="ns1eth$l"
 340                 ip -net "$ns" link set "$veth" down
 341         done
 342 }
 343
 344 # $1: IP address
 345 is_v6()
 346 {
 347         [ -z "${1##*:*}" ]
 348 }
 349
 350 # $1: ns, $2: port
 351 wait_local_port_listen()
 352 {
 353         local listener_ns="${1}"
 354         local port="${2}"
 355
 356         local port_hex
 357         port_hex="$(printf "%04X" "${port}")"
 358
 359         local i
 360         for i in $(seq 10); do
 361                 ip netns exec "${listener_ns}" cat /proc/net/tcp* | \
 362                         awk "BEGIN {rc=1} {if (\$2 ~ /:${port_hex}\$/ && \$4 ~ /0A/) {rc=0; exit}} END {exit rc}" &&
 363                         break
 364                 sleep 0.1
 365         done
 366 }
 367
 368 rm_addr_count()
 369 {
 370         local ns=${1}
 371
 372         ip netns exec ${ns} nstat -as | grep MPTcpExtRmAddr | awk '{print $2}'
 373 }
 374
 375 # $1: ns, $2: old rm_addr counter in $ns
 376 wait_rm_addr()
 377 {
 378         local ns="${1}"
 379         local old_cnt="${2}"
 380         local cnt
 381
 382         local i
 383         for i in $(seq 10); do
 384                 cnt=$(rm_addr_count ${ns})
 385                 [ "$cnt" = "${old_cnt}" ] || break
 386                 sleep 0.1
 387         done
 388 }
 389
 390 wait_mpj()
 391 {
 392         local ns="${1}"
 393         local cnt old_cnt
 394
 395         old_cnt=$(ip netns exec ${ns} nstat -as | grep MPJoinAckRx | awk '{print $2}')
 396
 397         local i
 398         for i in $(seq 10); do
 399                 cnt=$(ip netns exec ${ns} nstat -as | grep MPJoinAckRx | awk '{print $2}')
 400                 [ "$cnt" = "${old_cnt}" ] || break
 401                 sleep 0.1
 402         done
 403 }
 404
 405 pm_nl_set_limits()
 406 {
 407         local ns=$1
 408         local addrs=$2
 409         local subflows=$3
 410
 411         if [ $ip_mptcp -eq 1 ]; then
 412                 ip -n $ns mptcp limits set add_addr_accepted $addrs subflows $subflows
 413         else
 414                 ip netns exec $ns ./pm_nl_ctl limits $addrs $subflows
 415         fi
 416 }
 417
 418 pm_nl_add_endpoint()
 419 {
 420         local ns=$1
 421         local addr=$2
 422         local flags _flags
 423         local port _port
 424         local dev _dev
 425         local id _id
 426         local nr=2
 427
 428         local p
 429         for p in "${@}"
 430         do
 431                 if [ $p = "flags" ]; then
 432                         eval _flags=\$"$nr"
 433                         [ -n "$_flags" ]; flags="flags $_flags"
 434                 fi
 435                 if [ $p = "dev" ]; then
 436                         eval _dev=\$"$nr"
 437                         [ -n "$_dev" ]; dev="dev $_dev"
 438                 fi
 439                 if [ $p = "id" ]; then
 440                         eval _id=\$"$nr"
 441                         [ -n "$_id" ]; id="id $_id"
 442                 fi
 443                 if [ $p = "port" ]; then
 444                         eval _port=\$"$nr"
 445                         [ -n "$_port" ]; port="port $_port"
 446                 fi
 447
 448                 nr=$((nr + 1))
 449         done
 450
 451         if [ $ip_mptcp -eq 1 ]; then
 452                 ip -n $ns mptcp endpoint add $addr ${_flags//","/" "} $dev $id $port
 453         else
 454                 ip netns exec $ns ./pm_nl_ctl add $addr $flags $dev $id $port
 455         fi
 456 }
 457
 458 pm_nl_del_endpoint()
 459 {
 460         local ns=$1
 461         local id=$2
 462         local addr=$3
 463
 464         if [ $ip_mptcp -eq 1 ]; then
 465                 ip -n $ns mptcp endpoint delete id $id $addr
 466         else
 467                 ip netns exec $ns ./pm_nl_ctl del $id $addr
 468         fi
 469 }
 470
 471 pm_nl_flush_endpoint()
 472 {
 473         local ns=$1
 474
 475         if [ $ip_mptcp -eq 1 ]; then
 476                 ip -n $ns mptcp endpoint flush
 477         else
 478                 ip netns exec $ns ./pm_nl_ctl flush
 479         fi
 480 }
 481
 482 pm_nl_show_endpoints()
 483 {
 484         local ns=$1
 485
 486         if [ $ip_mptcp -eq 1 ]; then
 487                 ip -n $ns mptcp endpoint show
 488         else
 489                 ip netns exec $ns ./pm_nl_ctl dump
 490         fi
 491 }
 492
 493 pm_nl_change_endpoint()
 494 {
 495         local ns=$1
 496         local id=$2
 497         local flags=$3
 498
 499         if [ $ip_mptcp -eq 1 ]; then
 500                 ip -n $ns mptcp endpoint change id $id ${flags//","/" "}
 501         else
 502                 ip netns exec $ns ./pm_nl_ctl set id $id flags $flags
 503         fi
 504 }
 505
 506 pm_nl_check_endpoint()
 507 {
 508         local line expected_line
 509         local need_title=$1
 510         local msg="$2"
 511         local ns=$3
 512         local addr=$4
 513         local _flags=""
 514         local flags
 515         local _port
 516         local port
 517         local dev
 518         local _id
 519         local id
 520
 521         if [ "${need_title}" = 1 ]; then
 522                 printf "%03u %-36s %s" "${TEST_COUNT}" "${TEST_NAME}" "${msg}"
 523         else
 524                 printf "%-${nr_blank}s %s" " " "${msg}"
 525         fi
 526
 527         shift 4
 528         while [ -n "$1" ]; do
 529                 if [ $1 = "flags" ]; then
 530                         _flags=$2
 531                         [ -n "$_flags" ]; flags="flags $_flags"
 532                         shift
 533                 elif [ $1 = "dev" ]; then
 534                         [ -n "$2" ]; dev="dev $1"
 535                         shift
 536                 elif [ $1 = "id" ]; then
 537                         _id=$2
 538                         [ -n "$_id" ]; id="id $_id"
 539                         shift
 540                 elif [ $1 = "port" ]; then
 541                         _port=$2
 542                         [ -n "$_port" ]; port=" port $_port"
 543                         shift
 544                 fi
 545
 546                 shift
 547         done
 548
 549         if [ -z "$id" ]; then
 550                 echo "[skip] bad test - missing endpoint id"
 551                 return
 552         fi
 553
 554         if [ $ip_mptcp -eq 1 ]; then
 555                 line=$(ip -n $ns mptcp endpoint show $id)
 556                 # the dump order is: address id flags port dev
 557                 expected_line="$addr"
 558                 [ -n "$addr" ] && expected_line="$expected_line $addr"
 559                 expected_line="$expected_line $id"
 560                 [ -n "$_flags" ] && expected_line="$expected_line ${_flags//","/" "}"
 561                 [ -n "$dev" ] && expected_line="$expected_line $dev"
 562                 [ -n "$port" ] && expected_line="$expected_line $port"
 563         else
 564                 line=$(ip netns exec $ns ./pm_nl_ctl get $_id)
 565                 # the dump order is: id flags dev address port
 566                 expected_line="$id"
 567                 [ -n "$flags" ] && expected_line="$expected_line $flags"
 568                 [ -n "$dev" ] && expected_line="$expected_line $dev"
 569                 [ -n "$addr" ] && expected_line="$expected_line $addr"
 570                 [ -n "$_port" ] && expected_line="$expected_line $_port"
 571         fi
 572         if [ "$line" = "$expected_line" ]; then
 573                 echo "[ ok ]"
 574         else
 575                 echo "[fail] expected '$expected_line' found '$line'"
 576                 fail_test
 577         fi
 578 }
 579
 580 filter_tcp_from()
 581 {
 582         local ns="${1}"
 583         local src="${2}"
 584         local target="${3}"
 585
 586         ip netns exec "${ns}" iptables -A INPUT -s "${src}" -p tcp -j "${target}"
 587 }
 588
 589 do_transfer()
 590 {
 591         local listener_ns="$1"
 592         local connector_ns="$2"
 593         local cl_proto="$3"
 594         local srv_proto="$4"
 595         local connect_addr="$5"
 596         local test_link_fail="$6"
 597         local addr_nr_ns1="$7"
 598         local addr_nr_ns2="$8"
 599         local speed="$9"
 600         local sflags="${10}"
 601
 602         local port=$((10000 + TEST_COUNT - 1))
 603         local cappid
 604
 605         :> "$cout"
 606         :> "$sout"
 607         :> "$capout"
 608
 609         if [ $capture -eq 1 ]; then
 610                 local capuser
 611                 if [ -z $SUDO_USER ] ; then
 612                         capuser=""
 613                 else
 614                         capuser="-Z $SUDO_USER"
 615                 fi
 616
 617                 capfile=$(printf "mp_join-%02u-%s.pcap" "$TEST_COUNT" "${listener_ns}")
 618
 619                 echo "Capturing traffic for test $TEST_COUNT into $capfile"
 620                 ip netns exec ${listener_ns} tcpdump -i any -s 65535 -B 32768 $capuser -w $capfile > "$capout" 2>&1 &
 621                 cappid=$!
 622
 623                 sleep 1
 624         fi
 625
 626         NSTAT_HISTORY=/tmp/${listener_ns}.nstat ip netns exec ${listener_ns} \
 627                 nstat -n
 628         NSTAT_HISTORY=/tmp/${connector_ns}.nstat ip netns exec ${connector_ns} \
 629                 nstat -n
 630
 631         local extra_args
 632         if [ $speed = "fast" ]; then
 633                 extra_args="-j"
 634         elif [ $speed = "slow" ]; then
 635                 extra_args="-r 50"
 636         elif [[ $speed = "speed_"* ]]; then
 637                 extra_args="-r ${speed:6}"
 638         fi
 639
 640         if [[ "${addr_nr_ns2}" = "fastclose_"* ]]; then
 641                 # disconnect
 642                 extra_args="$extra_args -I ${addr_nr_ns2:10}"
 643                 addr_nr_ns2=0
 644         fi
 645
 646         local local_addr
 647         if is_v6 "${connect_addr}"; then
 648                 local_addr="::"
 649         else
 650                 local_addr="0.0.0.0"
 651         fi
 652
 653         if [ "$test_link_fail" -gt 1 ];then
 654                 timeout ${timeout_test} \
 655                         ip netns exec ${listener_ns} \
 656                                 ./mptcp_connect -t ${timeout_poll} -l -p $port -s ${srv_proto} \
 657                                         $extra_args ${local_addr} < "$sinfail" > "$sout" &
 658         else
 659                 timeout ${timeout_test} \
 660                         ip netns exec ${listener_ns} \
 661                                 ./mptcp_connect -t ${timeout_poll} -l -p $port -s ${srv_proto} \
 662                                         $extra_args ${local_addr} < "$sin" > "$sout" &
 663         fi
 664         local spid=$!
 665
 666         wait_local_port_listen "${listener_ns}" "${port}"
 667
 668         if [ "$test_link_fail" -eq 0 ];then
 669                 timeout ${timeout_test} \
 670                         ip netns exec ${connector_ns} \
 671                                 ./mptcp_connect -t ${timeout_poll} -p $port -s ${cl_proto} \
 672                                         $extra_args $connect_addr < "$cin" > "$cout" &
 673         elif [ "$test_link_fail" -eq 1 ] || [ "$test_link_fail" -eq 2 ];then
 674                 ( cat "$cinfail" ; sleep 2; link_failure $listener_ns ; cat "$cinfail" ) | \
 675                         tee "$cinsent" | \
 676                         timeout ${timeout_test} \
 677                                 ip netns exec ${connector_ns} \
 678                                         ./mptcp_connect -t ${timeout_poll} -p $port -s ${cl_proto} \
 679                                                 $extra_args $connect_addr > "$cout" &
 680         else
 681                 tee "$cinsent" < "$cinfail" | \
 682                         timeout ${timeout_test} \
 683                                 ip netns exec ${connector_ns} \
 684                                         ./mptcp_connect -t ${timeout_poll} -p $port -s ${cl_proto} \
 685                                                 $extra_args $connect_addr > "$cout" &
 686         fi
 687         local cpid=$!
 688
 689         # let the mptcp subflow be established in background before
 690         # do endpoint manipulation
 691         if [ $addr_nr_ns1 != "0" ] || [ $addr_nr_ns2 != "0" ]; then
 692                 sleep 1
 693         fi
 694
 695         if [ $addr_nr_ns1 -gt 0 ]; then
 696                 local counter=2
 697                 local add_nr_ns1=${addr_nr_ns1}
 698                 while [ $add_nr_ns1 -gt 0 ]; do
 699                         local addr
 700                         if is_v6 "${connect_addr}"; then
 701                                 addr="dead:beef:$counter::1"
 702                         else
 703                                 addr="10.0.$counter.1"
 704                         fi
 705                         pm_nl_add_endpoint $ns1 $addr flags signal
 706                         counter=$((counter + 1))
 707                         add_nr_ns1=$((add_nr_ns1 - 1))
 708                 done
 709         elif [ $addr_nr_ns1 -lt 0 ]; then
 710                 local rm_nr_ns1=$((-addr_nr_ns1))
 711                 if [ $rm_nr_ns1 -lt 8 ]; then
 712                         local counter=0
 713                         local line
 714                         pm_nl_show_endpoints ${listener_ns} | while read -r line; do
 715                                 # shellcheck disable=SC2206 # we do want to split per word
 716                                 local arr=($line)
 717                                 local nr=0
 718
 719                                 local i
 720                                 for i in "${arr[@]}"; do
 721                                         if [ $i = "id" ]; then
 722                                                 if [ $counter -eq $rm_nr_ns1 ]; then
 723                                                         break
 724                                                 fi
 725                                                 id=${arr[$nr+1]}
 726                                                 rm_addr=$(rm_addr_count ${connector_ns})
 727                                                 pm_nl_del_endpoint ${listener_ns} $id
 728                                                 wait_rm_addr ${connector_ns} ${rm_addr}
 729                                                 counter=$((counter + 1))
 730                                         fi
 731                                         nr=$((nr + 1))
 732                                 done
 733                         done
 734                 elif [ $rm_nr_ns1 -eq 8 ]; then
 735                         pm_nl_flush_endpoint ${listener_ns}
 736                 elif [ $rm_nr_ns1 -eq 9 ]; then
 737                         pm_nl_del_endpoint ${listener_ns} 0 ${connect_addr}
 738                 fi
 739         fi
 740
 741         local flags="subflow"
 742         if [[ "${addr_nr_ns2}" = "fullmesh_"* ]]; then
 743                 flags="${flags},fullmesh"
 744                 addr_nr_ns2=${addr_nr_ns2:9}
 745         fi
 746
 747         # if newly added endpoints must be deleted, give the background msk
 748         # some time to created them
 749         [ $addr_nr_ns1 -gt 0 ] && [ $addr_nr_ns2 -lt 0 ] && sleep 1
 750
 751         if [ $addr_nr_ns2 -gt 0 ]; then
 752                 local add_nr_ns2=${addr_nr_ns2}
 753                 local counter=3
 754                 while [ $add_nr_ns2 -gt 0 ]; do
 755                         local addr
 756                         if is_v6 "${connect_addr}"; then
 757                                 addr="dead:beef:$counter::2"
 758                         else
 759                                 addr="10.0.$counter.2"
 760                         fi
 761                         pm_nl_add_endpoint $ns2 $addr flags $flags
 762                         counter=$((counter + 1))
 763                         add_nr_ns2=$((add_nr_ns2 - 1))
 764                 done
 765         elif [ $addr_nr_ns2 -lt 0 ]; then
 766                 local rm_nr_ns2=$((-addr_nr_ns2))
 767                 if [ $rm_nr_ns2 -lt 8 ]; then
 768                         local counter=0
 769                         local line
 770                         pm_nl_show_endpoints ${connector_ns} | while read -r line; do
 771                                 # shellcheck disable=SC2206 # we do want to split per word
 772                                 local arr=($line)
 773                                 local nr=0
 774
 775                                 local i
 776                                 for i in "${arr[@]}"; do
 777                                         if [ $i = "id" ]; then
 778                                                 if [ $counter -eq $rm_nr_ns2 ]; then
 779                                                         break
 780                                                 fi
 781                                                 local id rm_addr
 782                                                 # rm_addr are serialized, allow the previous one to
 783                                                 # complete
 784                                                 id=${arr[$nr+1]}
 785                                                 rm_addr=$(rm_addr_count ${listener_ns})
 786                                                 pm_nl_del_endpoint ${connector_ns} $id
 787                                                 wait_rm_addr ${listener_ns} ${rm_addr}
 788                                                 counter=$((counter + 1))
 789                                         fi
 790                                         nr=$((nr + 1))
 791                                 done
 792                         done
 793                 elif [ $rm_nr_ns2 -eq 8 ]; then
 794                         pm_nl_flush_endpoint ${connector_ns}
 795                 elif [ $rm_nr_ns2 -eq 9 ]; then
 796                         local addr
 797                         if is_v6 "${connect_addr}"; then
 798                                 addr="dead:beef:1::2"
 799                         else
 800                                 addr="10.0.1.2"
 801                         fi
 802                         pm_nl_del_endpoint ${connector_ns} 0 $addr
 803                 fi
 804         fi
 805
 806         if [ -n "${sflags}" ]; then
 807                 sleep 1
 808
 809                 local netns
 810                 for netns in "$ns1" "$ns2"; do
 811                         local line
 812                         pm_nl_show_endpoints $netns | while read -r line; do
 813                                 # shellcheck disable=SC2206 # we do want to split per word
 814                                 local arr=($line)
 815                                 local nr=0
 816                                 local id
 817
 818                                 local i
 819                                 for i in "${arr[@]}"; do
 820                                         if [ $i = "id" ]; then
 821                                                 id=${arr[$nr+1]}
 822                                         fi
 823                                         nr=$((nr + 1))
 824                                 done
 825                                 pm_nl_change_endpoint $netns $id $sflags
 826                         done
 827                 done
 828         fi
 829
 830         wait $cpid
 831         local retc=$?
 832         wait $spid
 833         local rets=$?
 834
 835         if [ $capture -eq 1 ]; then
 836             sleep 1
 837             kill $cappid
 838         fi
 839
 840         NSTAT_HISTORY=/tmp/${listener_ns}.nstat ip netns exec ${listener_ns} \
 841                 nstat | grep Tcp > /tmp/${listener_ns}.out
 842         NSTAT_HISTORY=/tmp/${connector_ns}.nstat ip netns exec ${connector_ns} \
 843                 nstat | grep Tcp > /tmp/${connector_ns}.out
 844
 845         if [ ${rets} -ne 0 ] || [ ${retc} -ne 0 ]; then
 846                 echo " client exit code $retc, server $rets" 1>&2
 847                 echo -e "\nnetns ${listener_ns} socket stat for ${port}:" 1>&2
 848                 ip netns exec ${listener_ns} ss -Menita 1>&2 -o "sport = :$port"
 849                 cat /tmp/${listener_ns}.out
 850                 echo -e "\nnetns ${connector_ns} socket stat for ${port}:" 1>&2
 851                 ip netns exec ${connector_ns} ss -Menita 1>&2 -o "dport = :$port"
 852                 cat /tmp/${connector_ns}.out
 853
 854                 cat "$capout"
 855                 fail_test
 856                 return 1
 857         fi
 858
 859         if [ "$test_link_fail" -gt 1 ];then
 860                 check_transfer $sinfail $cout "file received by client"
 861         else
 862                 check_transfer $sin $cout "file received by client"
 863         fi
 864         retc=$?
 865         if [ "$test_link_fail" -eq 0 ];then
 866                 check_transfer $cin $sout "file received by server"
 867         else
 868                 check_transfer $cinsent $sout "file received by server"
 869         fi
 870         rets=$?
 871
 872         if [ $retc -eq 0 ] && [ $rets -eq 0 ];then
 873                 cat "$capout"
 874                 return 0
 875         fi
 876
 877         cat "$capout"
 878         return 1
 879 }
 880
 881 make_file()
 882 {
 883         local name=$1
 884         local who=$2
 885         local size=$3
 886
 887         dd if=/dev/urandom of="$name" bs=1024 count=$size 2> /dev/null
 888         echo -e "\nMPTCP_TEST_FILE_END_MARKER" >> "$name"
 889
 890         echo "Created $name (size $size KB) containing data sent by $who"
 891 }
 892
 893 run_tests()
 894 {
 895         local listener_ns="$1"
 896         local connector_ns="$2"
 897         local connect_addr="$3"
 898         local test_linkfail="${4:-0}"
 899         local addr_nr_ns1="${5:-0}"
 900         local addr_nr_ns2="${6:-0}"
 901         local speed="${7:-fast}"
 902         local sflags="${8:-""}"
 903
 904         local size
 905
 906         # The values above 2 are reused to make test files
 907         # with the given sizes (KB)
 908         if [ "$test_linkfail" -gt 2 ]; then
 909                 size=$test_linkfail
 910
 911                 if [ -z "$cinfail" ]; then
 912                         cinfail=$(mktemp)
 913                 fi
 914                 make_file "$cinfail" "client" $size
 915         # create the input file for the failure test when
 916         # the first failure test run
 917         elif [ "$test_linkfail" -ne 0 ] && [ -z "$cinfail" ]; then
 918                 # the client file must be considerably larger
 919                 # of the maximum expected cwin value, or the
 920                 # link utilization will be not predicable
 921                 size=$((RANDOM%2))
 922                 size=$((size+1))
 923                 size=$((size*8192))
 924                 size=$((size + ( RANDOM % 8192) ))
 925
 926                 cinfail=$(mktemp)
 927                 make_file "$cinfail" "client" $size
 928         fi
 929
 930         if [ "$test_linkfail" -gt 2 ]; then
 931                 size=$test_linkfail
 932
 933                 if [ -z "$sinfail" ]; then
 934                         sinfail=$(mktemp)
 935                 fi
 936                 make_file "$sinfail" "server" $size
 937         elif [ "$test_linkfail" -eq 2 ] && [ -z "$sinfail" ]; then
 938                 size=$((RANDOM%16))
 939                 size=$((size+1))
 940                 size=$((size*2048))
 941
 942                 sinfail=$(mktemp)
 943                 make_file "$sinfail" "server" $size
 944         fi
 945
 946         do_transfer ${listener_ns} ${connector_ns} MPTCP MPTCP ${connect_addr} \
 947                 ${test_linkfail} ${addr_nr_ns1} ${addr_nr_ns2} ${speed} ${sflags}
 948 }
 949
 950 dump_stats()
 951 {
 952         echo Server ns stats
 953         ip netns exec $ns1 nstat -as | grep Tcp
 954         echo Client ns stats
 955         ip netns exec $ns2 nstat -as | grep Tcp
 956 }
 957
 958 chk_csum_nr()
 959 {
 960         local csum_ns1=${1:-0}
 961         local csum_ns2=${2:-0}
 962         local count
 963         local dump_stats
 964         local allow_multi_errors_ns1=0
 965         local allow_multi_errors_ns2=0
 966
 967         if [[ "${csum_ns1}" = "+"* ]]; then
 968                 allow_multi_errors_ns1=1
 969                 csum_ns1=${csum_ns1:1}
 970         fi
 971         if [[ "${csum_ns2}" = "+"* ]]; then
 972                 allow_multi_errors_ns2=1
 973                 csum_ns2=${csum_ns2:1}
 974         fi
 975
 976         printf "%-${nr_blank}s %s" " " "sum"
 977         count=$(ip netns exec $ns1 nstat -as | grep MPTcpExtDataCsumErr | awk '{print $2}')
 978         [ -z "$count" ] && count=0
 979         if { [ "$count" != $csum_ns1 ] && [ $allow_multi_errors_ns1 -eq 0 ]; } ||
 980            { [ "$count" -lt $csum_ns1 ] && [ $allow_multi_errors_ns1 -eq 1 ]; }; then
 981                 echo "[fail] got $count data checksum error[s] expected $csum_ns1"
 982                 fail_test
 983                 dump_stats=1
 984         else
 985                 echo -n "[ ok ]"
 986         fi
 987         echo -n " - csum  "
 988         count=$(ip netns exec $ns2 nstat -as | grep MPTcpExtDataCsumErr | awk '{print $2}')
 989         [ -z "$count" ] && count=0
 990         if { [ "$count" != $csum_ns2 ] && [ $allow_multi_errors_ns2 -eq 0 ]; } ||
 991            { [ "$count" -lt $csum_ns2 ] && [ $allow_multi_errors_ns2 -eq 1 ]; }; then
 992                 echo "[fail] got $count data checksum error[s] expected $csum_ns2"
 993                 fail_test
 994                 dump_stats=1
 995         else
 996                 echo "[ ok ]"
 997         fi
 998         [ "${dump_stats}" = 1 ] && dump_stats
 999 }
1000
1001 chk_fail_nr()
1002 {
1003         local fail_tx=$1
1004         local fail_rx=$2
1005         local count
1006         local dump_stats
1007
1008         printf "%-${nr_blank}s %s" " " "ftx"
1009         count=$(ip netns exec $ns1 nstat -as | grep MPTcpExtMPFailTx | awk '{print $2}')
1010         [ -z "$count" ] && count=0
1011         if [ "$count" != "$fail_tx" ]; then
1012                 echo "[fail] got $count MP_FAIL[s] TX expected $fail_tx"
1013                 fail_test
1014                 dump_stats=1
1015         else
1016                 echo -n "[ ok ]"
1017         fi
1018
1019         echo -n " - failrx"
1020         count=$(ip netns exec $ns2 nstat -as | grep MPTcpExtMPFailRx | awk '{print $2}')
1021         [ -z "$count" ] && count=0
1022         if [ "$count" != "$fail_rx" ]; then
1023                 echo "[fail] got $count MP_FAIL[s] RX expected $fail_rx"
1024                 fail_test
1025                 dump_stats=1
1026         else
1027                 echo "[ ok ]"
1028         fi
1029
1030         [ "${dump_stats}" = 1 ] && dump_stats
1031 }
1032
1033 chk_fclose_nr()
1034 {
1035         local fclose_tx=$1
1036         local fclose_rx=$2
1037         local count
1038         local dump_stats
1039
1040         printf "%-${nr_blank}s %s" " " "ctx"
1041         count=$(ip netns exec $ns2 nstat -as | grep MPTcpExtMPFastcloseTx | awk '{print $2}')
1042         [ -z "$count" ] && count=0
1043         if [ "$count" != "$fclose_tx" ]; then
1044                 echo "[fail] got $count MP_FASTCLOSE[s] TX expected $fclose_tx"
1045                 fail_test
1046                 dump_stats=1
1047         else
1048                 echo -n "[ ok ]"
1049         fi
1050
1051         echo -n " - fclzrx"
1052         count=$(ip netns exec $ns1 nstat -as | grep MPTcpExtMPFastcloseRx | awk '{print $2}')
1053         [ -z "$count" ] && count=0
1054         if [ "$count" != "$fclose_rx" ]; then
1055                 echo "[fail] got $count MP_FASTCLOSE[s] RX expected $fclose_rx"
1056                 fail_test
1057                 dump_stats=1
1058         else
1059                 echo "[ ok ]"
1060         fi
1061
1062         [ "${dump_stats}" = 1 ] && dump_stats
1063 }
1064
1065 chk_rst_nr()
1066 {
1067         local rst_tx=$1
1068         local rst_rx=$2
1069         local ns_invert=${3:-""}
1070         local count
1071         local dump_stats
1072         local ns_tx=$ns1
1073         local ns_rx=$ns2
1074         local extra_msg=""
1075
1076         if [[ $ns_invert = "invert" ]]; then
1077                 ns_tx=$ns2
1078                 ns_rx=$ns1
1079                 extra_msg="   invert"
1080         fi
1081
1082         printf "%-${nr_blank}s %s" " " "rtx"
1083         count=$(ip netns exec $ns_tx nstat -as | grep MPTcpExtMPRstTx | awk '{print $2}')
1084         [ -z "$count" ] && count=0
1085         if [ "$count" != "$rst_tx" ]; then
1086                 echo "[fail] got $count MP_RST[s] TX expected $rst_tx"
1087                 fail_test
1088                 dump_stats=1
1089         else
1090                 echo -n "[ ok ]"
1091         fi
1092
1093         echo -n " - rstrx "
1094         count=$(ip netns exec $ns_rx nstat -as | grep MPTcpExtMPRstRx | awk '{print $2}')
1095         [ -z "$count" ] && count=0
1096         if [ "$count" != "$rst_rx" ]; then
1097                 echo "[fail] got $count MP_RST[s] RX expected $rst_rx"
1098                 fail_test
1099                 dump_stats=1
1100         else
1101                 echo -n "[ ok ]"
1102         fi
1103
1104         [ "${dump_stats}" = 1 ] && dump_stats
1105
1106         echo "$extra_msg"
1107 }
1108
1109 chk_join_nr()
1110 {
1111         local syn_nr=$1
1112         local syn_ack_nr=$2
1113         local ack_nr=$3
1114         local csum_ns1=${4:-0}
1115         local csum_ns2=${5:-0}
1116         local fail_nr=${6:-0}
1117         local rst_nr=${7:-0}
1118         local corrupted_pkts=${8:-0}
1119         local count
1120         local dump_stats
1121         local with_cookie
1122         local title="${TEST_NAME}"
1123
1124         if [ "${corrupted_pkts}" -gt 0 ]; then
1125                 title+=": ${corrupted_pkts} corrupted pkts"
1126         fi
1127
1128         printf "%03u %-36s %s" "${TEST_COUNT}" "${title}" "syn"
1129         count=$(ip netns exec $ns1 nstat -as | grep MPTcpExtMPJoinSynRx | awk '{print $2}')
1130         [ -z "$count" ] && count=0
1131         if [ "$count" != "$syn_nr" ]; then
1132                 echo "[fail] got $count JOIN[s] syn expected $syn_nr"
1133                 fail_test
1134                 dump_stats=1
1135         else
1136                 echo -n "[ ok ]"
1137         fi
1138
1139         echo -n " - synack"
1140         with_cookie=$(ip netns exec $ns2 sysctl -n net.ipv4.tcp_syncookies)
1141         count=$(ip netns exec $ns2 nstat -as | grep MPTcpExtMPJoinSynAckRx | awk '{print $2}')
1142         [ -z "$count" ] && count=0
1143         if [ "$count" != "$syn_ack_nr" ]; then
1144                 # simult connections exceeding the limit with cookie enabled could go up to
1145                 # synack validation as the conn limit can be enforced reliably only after
1146                 # the subflow creation
1147                 if [ "$with_cookie" = 2 ] && [ "$count" -gt "$syn_ack_nr" ] && [ "$count" -le "$syn_nr" ]; then
1148                         echo -n "[ ok ]"
1149                 else
1150                         echo "[fail] got $count JOIN[s] synack expected $syn_ack_nr"
1151                         fail_test
1152                         dump_stats=1
1153                 fi
1154         else
1155                 echo -n "[ ok ]"
1156         fi
1157
1158         echo -n " - ack"
1159         count=$(ip netns exec $ns1 nstat -as | grep MPTcpExtMPJoinAckRx | awk '{print $2}')
1160         [ -z "$count" ] && count=0
1161         if [ "$count" != "$ack_nr" ]; then
1162                 echo "[fail] got $count JOIN[s] ack expected $ack_nr"
1163                 fail_test
1164                 dump_stats=1
1165         else
1166                 echo "[ ok ]"
1167         fi
1168         [ "${dump_stats}" = 1 ] && dump_stats
1169         if [ $checksum -eq 1 ]; then
1170                 chk_csum_nr $csum_ns1 $csum_ns2
1171                 chk_fail_nr $fail_nr $fail_nr
1172                 chk_rst_nr $rst_nr $rst_nr
1173         fi
1174 }
1175
1176 # a negative value for 'stale_max' means no upper bound:
1177 # for bidirectional transfer, if one peer sleep for a while
1178 # - as these tests do - we can have a quite high number of
1179 # stale/recover conversions, proportional to
1180 # sleep duration/ MPTCP-level RTX interval.
1181 chk_stale_nr()
1182 {
1183         local ns=$1
1184         local stale_min=$2
1185         local stale_max=$3
1186         local stale_delta=$4
1187         local dump_stats
1188         local stale_nr
1189         local recover_nr
1190
1191         printf "%-${nr_blank}s %-18s" " " "stale"
1192         stale_nr=$(ip netns exec $ns nstat -as | grep MPTcpExtSubflowStale | awk '{print $2}')
1193         [ -z "$stale_nr" ] && stale_nr=0
1194         recover_nr=$(ip netns exec $ns nstat -as | grep MPTcpExtSubflowRecover | awk '{print $2}')
1195         [ -z "$recover_nr" ] && recover_nr=0
1196
1197         if [ $stale_nr -lt $stale_min ] ||
1198            { [ $stale_max -gt 0 ] && [ $stale_nr -gt $stale_max ]; } ||
1199            [ $((stale_nr - recover_nr)) -ne $stale_delta ]; then
1200                 echo "[fail] got $stale_nr stale[s] $recover_nr recover[s], " \
1201                      " expected stale in range [$stale_min..$stale_max]," \
1202                      " stale-recover delta $stale_delta "
1203                 fail_test
1204                 dump_stats=1
1205         else
1206                 echo "[ ok ]"
1207         fi
1208
1209         if [ "${dump_stats}" = 1 ]; then
1210                 echo $ns stats
1211                 ip netns exec $ns ip -s link show
1212                 ip netns exec $ns nstat -as | grep MPTcp
1213         fi
1214 }
1215
1216 chk_add_nr()
1217 {
1218         local add_nr=$1
1219         local echo_nr=$2
1220         local port_nr=${3:-0}
1221         local syn_nr=${4:-$port_nr}
1222         local syn_ack_nr=${5:-$port_nr}
1223         local ack_nr=${6:-$port_nr}
1224         local mis_syn_nr=${7:-0}
1225         local mis_ack_nr=${8:-0}
1226         local count
1227         local dump_stats
1228         local timeout
1229
1230         timeout=$(ip netns exec $ns1 sysctl -n net.mptcp.add_addr_timeout)
1231
1232         printf "%-${nr_blank}s %s" " " "add"
1233         count=$(ip netns exec $ns2 nstat -as MPTcpExtAddAddr | grep MPTcpExtAddAddr | awk '{print $2}')
1234         [ -z "$count" ] && count=0
1235
1236         # if the test configured a short timeout tolerate greater then expected
1237         # add addrs options, due to retransmissions
1238         if [ "$count" != "$add_nr" ] && { [ "$timeout" -gt 1 ] || [ "$count" -lt "$add_nr" ]; }; then
1239                 echo "[fail] got $count ADD_ADDR[s] expected $add_nr"
1240                 fail_test
1241                 dump_stats=1
1242         else
1243                 echo -n "[ ok ]"
1244         fi
1245
1246         echo -n " - echo  "
1247         count=$(ip netns exec $ns1 nstat -as | grep MPTcpExtEchoAdd | awk '{print $2}')
1248         [ -z "$count" ] && count=0
1249         if [ "$count" != "$echo_nr" ]; then
1250                 echo "[fail] got $count ADD_ADDR echo[s] expected $echo_nr"
1251                 fail_test
1252                 dump_stats=1
1253         else
1254                 echo -n "[ ok ]"
1255         fi
1256
1257         if [ $port_nr -gt 0 ]; then
1258                 echo -n " - pt "
1259                 count=$(ip netns exec $ns2 nstat -as | grep MPTcpExtPortAdd | awk '{print $2}')
1260                 [ -z "$count" ] && count=0
1261                 if [ "$count" != "$port_nr" ]; then
1262                         echo "[fail] got $count ADD_ADDR[s] with a port-number expected $port_nr"
1263                         fail_test
1264                         dump_stats=1
1265                 else
1266                         echo "[ ok ]"
1267                 fi
1268
1269                 printf "%-${nr_blank}s %s" " " "syn"
1270                 count=$(ip netns exec $ns1 nstat -as | grep MPTcpExtMPJoinPortSynRx |
1271                         awk '{print $2}')
1272                 [ -z "$count" ] && count=0
1273                 if [ "$count" != "$syn_nr" ]; then
1274                         echo "[fail] got $count JOIN[s] syn with a different \
1275                                 port-number expected $syn_nr"
1276                         fail_test
1277                         dump_stats=1
1278                 else
1279                         echo -n "[ ok ]"
1280                 fi
1281
1282                 echo -n " - synack"
1283                 count=$(ip netns exec $ns2 nstat -as | grep MPTcpExtMPJoinPortSynAckRx |
1284                         awk '{print $2}')
1285                 [ -z "$count" ] && count=0
1286                 if [ "$count" != "$syn_ack_nr" ]; then
1287                         echo "[fail] got $count JOIN[s] synack with a different \
1288                                 port-number expected $syn_ack_nr"
1289                         fail_test
1290                         dump_stats=1
1291                 else
1292                         echo -n "[ ok ]"
1293                 fi
1294
1295                 echo -n " - ack"
1296                 count=$(ip netns exec $ns1 nstat -as | grep MPTcpExtMPJoinPortAckRx |
1297                         awk '{print $2}')
1298                 [ -z "$count" ] && count=0
1299                 if [ "$count" != "$ack_nr" ]; then
1300                         echo "[fail] got $count JOIN[s] ack with a different \
1301                                 port-number expected $ack_nr"
1302                         fail_test
1303                         dump_stats=1
1304                 else
1305                         echo "[ ok ]"
1306                 fi
1307
1308                 printf "%-${nr_blank}s %s" " " "syn"
1309                 count=$(ip netns exec $ns1 nstat -as | grep MPTcpExtMismatchPortSynRx |
1310                         awk '{print $2}')
1311                 [ -z "$count" ] && count=0
1312                 if [ "$count" != "$mis_syn_nr" ]; then
1313                         echo "[fail] got $count JOIN[s] syn with a mismatched \
1314                                 port-number expected $mis_syn_nr"
1315                         fail_test
1316                         dump_stats=1
1317                 else
1318                         echo -n "[ ok ]"
1319                 fi
1320
1321                 echo -n " - ack   "
1322                 count=$(ip netns exec $ns1 nstat -as | grep MPTcpExtMismatchPortAckRx |
1323                         awk '{print $2}')
1324                 [ -z "$count" ] && count=0
1325                 if [ "$count" != "$mis_ack_nr" ]; then
1326                         echo "[fail] got $count JOIN[s] ack with a mismatched \
1327                                 port-number expected $mis_ack_nr"
1328                         fail_test
1329                         dump_stats=1
1330                 else
1331                         echo "[ ok ]"
1332                 fi
1333         else
1334                 echo ""
1335         fi
1336
1337         [ "${dump_stats}" = 1 ] && dump_stats
1338 }
1339
1340 chk_rm_nr()
1341 {
1342         local rm_addr_nr=$1
1343         local rm_subflow_nr=$2
1344         local invert
1345         local simult
1346         local count
1347         local dump_stats
1348         local addr_ns=$ns1
1349         local subflow_ns=$ns2
1350         local extra_msg=""
1351
1352         shift 2
1353         while [ -n "$1" ]; do
1354                 [ "$1" = "invert" ] && invert=true
1355                 [ "$1" = "simult" ] && simult=true
1356                 shift
1357         done
1358
1359         if [ -z $invert ]; then
1360                 addr_ns=$ns1
1361                 subflow_ns=$ns2
1362         elif [ $invert = "true" ]; then
1363                 addr_ns=$ns2
1364                 subflow_ns=$ns1
1365                 extra_msg="   invert"
1366         fi
1367
1368         printf "%-${nr_blank}s %s" " " "rm "
1369         count=$(ip netns exec $addr_ns nstat -as | grep MPTcpExtRmAddr | awk '{print $2}')
1370         [ -z "$count" ] && count=0
1371         if [ "$count" != "$rm_addr_nr" ]; then
1372                 echo "[fail] got $count RM_ADDR[s] expected $rm_addr_nr"
1373                 fail_test
1374                 dump_stats=1
1375         else
1376                 echo -n "[ ok ]"
1377         fi
1378
1379         echo -n " - rmsf  "
1380         count=$(ip netns exec $subflow_ns nstat -as | grep MPTcpExtRmSubflow | awk '{print $2}')
1381         [ -z "$count" ] && count=0
1382         if [ -n "$simult" ]; then
1383                 local cnt suffix
1384
1385                 cnt=$(ip netns exec $addr_ns nstat -as | grep MPTcpExtRmSubflow | awk '{print $2}')
1386
1387                 # in case of simult flush, the subflow removal count on each side is
1388                 # unreliable
1389                 [ -z "$cnt" ] && cnt=0
1390                 count=$((count + cnt))
1391                 [ "$count" != "$rm_subflow_nr" ] && suffix="$count in [$rm_subflow_nr:$((rm_subflow_nr*2))]"
1392                 if [ $count -ge "$rm_subflow_nr" ] && \
1393                    [ "$count" -le "$((rm_subflow_nr *2 ))" ]; then
1394                         echo "[ ok ] $suffix"
1395                 else
1396                         echo "[fail] got $count RM_SUBFLOW[s] expected in range [$rm_subflow_nr:$((rm_subflow_nr*2))]"
1397                         fail_test
1398                         dump_stats=1
1399                 fi
1400                 return
1401         fi
1402         if [ "$count" != "$rm_subflow_nr" ]; then
1403                 echo "[fail] got $count RM_SUBFLOW[s] expected $rm_subflow_nr"
1404                 fail_test
1405                 dump_stats=1
1406         else
1407                 echo -n "[ ok ]"
1408         fi
1409
1410         [ "${dump_stats}" = 1 ] && dump_stats
1411
1412         echo "$extra_msg"
1413 }
1414
1415 chk_prio_nr()
1416 {
1417         local mp_prio_nr_tx=$1
1418         local mp_prio_nr_rx=$2
1419         local count
1420         local dump_stats
1421
1422         printf "%-${nr_blank}s %s" " " "ptx"
1423         count=$(ip netns exec $ns1 nstat -as | grep MPTcpExtMPPrioTx | awk '{print $2}')
1424         [ -z "$count" ] && count=0
1425         if [ "$count" != "$mp_prio_nr_tx" ]; then
1426                 echo "[fail] got $count MP_PRIO[s] TX expected $mp_prio_nr_tx"
1427                 fail_test
1428                 dump_stats=1
1429         else
1430                 echo -n "[ ok ]"
1431         fi
1432
1433         echo -n " - prx   "
1434         count=$(ip netns exec $ns1 nstat -as | grep MPTcpExtMPPrioRx | awk '{print $2}')
1435         [ -z "$count" ] && count=0
1436         if [ "$count" != "$mp_prio_nr_rx" ]; then
1437                 echo "[fail] got $count MP_PRIO[s] RX expected $mp_prio_nr_rx"
1438                 fail_test
1439                 dump_stats=1
1440         else
1441                 echo "[ ok ]"
1442         fi
1443
1444         [ "${dump_stats}" = 1 ] && dump_stats
1445 }
1446
1447 chk_subflow_nr()
1448 {
1449         local need_title="$1"
1450         local msg="$2"
1451         local subflow_nr=$3
1452         local cnt1
1453         local cnt2
1454
1455         if [ -n "${need_title}" ]; then
1456                 printf "%03u %-36s %s" "${TEST_COUNT}" "${TEST_NAME}" "${msg}"
1457         else
1458                 printf "%-${nr_blank}s %s" " " "${msg}"
1459         fi
1460
1461         cnt1=$(ss -N $ns1 -tOni | grep -c token)
1462         cnt2=$(ss -N $ns2 -tOni | grep -c token)
1463         if [ "$cnt1" != "$subflow_nr" -o "$cnt2" != "$subflow_nr" ]; then
1464                 echo "[fail] got $cnt1:$cnt2 subflows expected $subflow_nr"
1465                 fail_test
1466                 dump_stats=1
1467         else
1468                 echo "[ ok ]"
1469         fi
1470
1471         [ "${dump_stats}" = 1 ] && ( ss -N $ns1 -tOni ; ss -N $ns1 -tOni | grep token; ip -n $ns1 mptcp endpoint )
1472 }
1473
1474 chk_link_usage()
1475 {
1476         local ns=$1
1477         local link=$2
1478         local out=$3
1479         local expected_rate=$4
1480
1481         local tx_link tx_total
1482         tx_link=$(ip netns exec $ns cat /sys/class/net/$link/statistics/tx_bytes)
1483         tx_total=$(stat --format=%s $out)
1484         local tx_rate=$((tx_link * 100 / tx_total))
1485         local tolerance=5
1486
1487         printf "%-${nr_blank}s %-18s" " " "link usage"
1488         if [ $tx_rate -lt $((expected_rate - tolerance)) ] || \
1489            [ $tx_rate -gt $((expected_rate + tolerance)) ]; then
1490                 echo "[fail] got $tx_rate% usage, expected $expected_rate%"
1491                 fail_test
1492         else
1493                 echo "[ ok ]"
1494         fi
1495 }
1496
1497 wait_attempt_fail()
1498 {
1499         local timeout_ms=$((timeout_poll * 1000))
1500         local time=0
1501         local ns=$1
1502
1503         while [ $time -lt $timeout_ms ]; do
1504                 local cnt
1505
1506                 cnt=$(ip netns exec $ns nstat -as TcpAttemptFails | grep TcpAttemptFails | awk '{print $2}')
1507
1508                 [ "$cnt" = 1 ] && return 1
1509                 time=$((time + 100))
1510                 sleep 0.1
1511         done
1512         return 1
1513 }
1514
1515 subflows_tests()
1516 {
1517         if reset "no JOIN"; then
1518                 run_tests $ns1 $ns2 10.0.1.1
1519                 chk_join_nr 0 0 0
1520         fi
1521
1522         # subflow limited by client
1523         if reset "single subflow, limited by client"; then
1524                 pm_nl_set_limits $ns1 0 0
1525                 pm_nl_set_limits $ns2 0 0
1526                 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow
1527                 run_tests $ns1 $ns2 10.0.1.1
1528                 chk_join_nr 0 0 0
1529         fi
1530
1531         # subflow limited by server
1532         if reset "single subflow, limited by server"; then
1533                 pm_nl_set_limits $ns1 0 0
1534                 pm_nl_set_limits $ns2 0 1
1535                 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow
1536                 run_tests $ns1 $ns2 10.0.1.1
1537                 chk_join_nr 1 1 0
1538         fi
1539
1540         # subflow
1541         if reset "single subflow"; then
1542                 pm_nl_set_limits $ns1 0 1
1543                 pm_nl_set_limits $ns2 0 1
1544                 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow
1545                 run_tests $ns1 $ns2 10.0.1.1
1546                 chk_join_nr 1 1 1
1547         fi
1548
1549         # multiple subflows
1550         if reset "multiple subflows"; then
1551                 pm_nl_set_limits $ns1 0 2
1552                 pm_nl_set_limits $ns2 0 2
1553                 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow
1554                 pm_nl_add_endpoint $ns2 10.0.2.2 flags subflow
1555                 run_tests $ns1 $ns2 10.0.1.1
1556                 chk_join_nr 2 2 2
1557         fi
1558
1559         # multiple subflows limited by server
1560         if reset "multiple subflows, limited by server"; then
1561                 pm_nl_set_limits $ns1 0 1
1562                 pm_nl_set_limits $ns2 0 2
1563                 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow
1564                 pm_nl_add_endpoint $ns2 10.0.2.2 flags subflow
1565                 run_tests $ns1 $ns2 10.0.1.1
1566                 chk_join_nr 2 2 1
1567         fi
1568
1569         # single subflow, dev
1570         if reset "single subflow, dev"; then
1571                 pm_nl_set_limits $ns1 0 1
1572                 pm_nl_set_limits $ns2 0 1
1573                 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow dev ns2eth3
1574                 run_tests $ns1 $ns2 10.0.1.1
1575                 chk_join_nr 1 1 1
1576         fi
1577 }
1578
1579 subflows_error_tests()
1580 {
1581         # If a single subflow is configured, and matches the MPC src
1582         # address, no additional subflow should be created
1583         if reset "no MPC reuse with single endpoint"; then
1584                 pm_nl_set_limits $ns1 0 1
1585                 pm_nl_set_limits $ns2 0 1
1586                 pm_nl_add_endpoint $ns2 10.0.1.2 flags subflow
1587                 run_tests $ns1 $ns2 10.0.1.1 0 0 0 slow
1588                 chk_join_nr 0 0 0
1589         fi
1590
1591         # multiple subflows, with subflow creation error
1592         if reset "multi subflows, with failing subflow"; then
1593                 pm_nl_set_limits $ns1 0 2
1594                 pm_nl_set_limits $ns2 0 2
1595                 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow
1596                 pm_nl_add_endpoint $ns2 10.0.2.2 flags subflow
1597                 filter_tcp_from $ns1 10.0.3.2 REJECT
1598                 run_tests $ns1 $ns2 10.0.1.1 0 0 0 slow
1599                 chk_join_nr 1 1 1
1600         fi
1601
1602         # multiple subflows, with subflow timeout on MPJ
1603         if reset "multi subflows, with subflow timeout"; then
1604                 pm_nl_set_limits $ns1 0 2
1605                 pm_nl_set_limits $ns2 0 2
1606                 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow
1607                 pm_nl_add_endpoint $ns2 10.0.2.2 flags subflow
1608                 filter_tcp_from $ns1 10.0.3.2 DROP
1609                 run_tests $ns1 $ns2 10.0.1.1 0 0 0 slow
1610                 chk_join_nr 1 1 1
1611         fi
1612
1613         # multiple subflows, check that the endpoint corresponding to
1614         # closed subflow (due to reset) is not reused if additional
1615         # subflows are added later
1616         if reset "multi subflows, fair usage on close"; then
1617                 pm_nl_set_limits $ns1 0 1
1618                 pm_nl_set_limits $ns2 0 1
1619                 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow
1620                 filter_tcp_from $ns1 10.0.3.2 REJECT
1621                 run_tests $ns1 $ns2 10.0.1.1 0 0 0 slow &
1622
1623                 # mpj subflow will be in TW after the reset
1624                 wait_attempt_fail $ns2
1625                 pm_nl_add_endpoint $ns2 10.0.2.2 flags subflow
1626                 wait
1627
1628                 # additional subflow could be created only if the PM select
1629                 # the later endpoint, skipping the already used one
1630                 chk_join_nr 1 1 1
1631         fi
1632 }
1633
1634 signal_address_tests()
1635 {
1636         # add_address, unused
1637         if reset "unused signal address"; then
1638                 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal
1639                 run_tests $ns1 $ns2 10.0.1.1
1640                 chk_join_nr 0 0 0
1641                 chk_add_nr 1 1
1642         fi
1643
1644         # accept and use add_addr
1645         if reset "signal address"; then
1646                 pm_nl_set_limits $ns1 0 1
1647                 pm_nl_set_limits $ns2 1 1
1648                 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal
1649                 run_tests $ns1 $ns2 10.0.1.1
1650                 chk_join_nr 1 1 1
1651                 chk_add_nr 1 1
1652         fi
1653
1654         # accept and use add_addr with an additional subflow
1655         # note: signal address in server ns and local addresses in client ns must
1656         # belong to different subnets or one of the listed local address could be
1657         # used for 'add_addr' subflow
1658         if reset "subflow and signal"; then
1659                 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal
1660                 pm_nl_set_limits $ns1 0 2
1661                 pm_nl_set_limits $ns2 1 2
1662                 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow
1663                 run_tests $ns1 $ns2 10.0.1.1
1664                 chk_join_nr 2 2 2
1665                 chk_add_nr 1 1
1666         fi
1667
1668         # accept and use add_addr with additional subflows
1669         if reset "multiple subflows and signal"; then
1670                 pm_nl_set_limits $ns1 0 3
1671                 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal
1672                 pm_nl_set_limits $ns2 1 3
1673                 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow
1674                 pm_nl_add_endpoint $ns2 10.0.4.2 flags subflow
1675                 run_tests $ns1 $ns2 10.0.1.1
1676                 chk_join_nr 3 3 3
1677                 chk_add_nr 1 1
1678         fi
1679
1680         # signal addresses
1681         if reset "signal addresses"; then
1682                 pm_nl_set_limits $ns1 3 3
1683                 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal
1684                 pm_nl_add_endpoint $ns1 10.0.3.1 flags signal
1685                 pm_nl_add_endpoint $ns1 10.0.4.1 flags signal
1686                 pm_nl_set_limits $ns2 3 3
1687                 run_tests $ns1 $ns2 10.0.1.1
1688                 chk_join_nr 3 3 3
1689                 chk_add_nr 3 3
1690         fi
1691
1692         # signal invalid addresses
1693         if reset "signal invalid addresses"; then
1694                 pm_nl_set_limits $ns1 3 3
1695                 pm_nl_add_endpoint $ns1 10.0.12.1 flags signal
1696                 pm_nl_add_endpoint $ns1 10.0.3.1 flags signal
1697                 pm_nl_add_endpoint $ns1 10.0.14.1 flags signal
1698                 pm_nl_set_limits $ns2 3 3
1699                 run_tests $ns1 $ns2 10.0.1.1
1700                 chk_join_nr 1 1 1
1701                 chk_add_nr 3 3
1702         fi
1703
1704         # signal addresses race test
1705         if reset "signal addresses race test"; then
1706                 pm_nl_set_limits $ns1 4 4
1707                 pm_nl_set_limits $ns2 4 4
1708                 pm_nl_add_endpoint $ns1 10.0.1.1 flags signal
1709                 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal
1710                 pm_nl_add_endpoint $ns1 10.0.3.1 flags signal
1711                 pm_nl_add_endpoint $ns1 10.0.4.1 flags signal
1712                 pm_nl_add_endpoint $ns2 10.0.1.2 flags signal
1713                 pm_nl_add_endpoint $ns2 10.0.2.2 flags signal
1714                 pm_nl_add_endpoint $ns2 10.0.3.2 flags signal
1715                 pm_nl_add_endpoint $ns2 10.0.4.2 flags signal
1716
1717                 # the peer could possibly miss some addr notification, allow retransmission
1718                 ip netns exec $ns1 sysctl -q net.mptcp.add_addr_timeout=1
1719                 run_tests $ns1 $ns2 10.0.1.1 0 0 0 slow
1720                 chk_join_nr 3 3 3
1721
1722                 # the server will not signal the address terminating
1723                 # the MPC subflow
1724                 chk_add_nr 3 3
1725         fi
1726 }
1727
1728 link_failure_tests()
1729 {
1730         # accept and use add_addr with additional subflows and link loss
1731         if reset "multiple flows, signal, link failure"; then
1732                 # without any b/w limit each veth could spool the packets and get
1733                 # them acked at xmit time, so that the corresponding subflow will
1734                 # have almost always no outstanding pkts, the scheduler will pick
1735                 # always the first subflow and we will have hard time testing
1736                 # active backup and link switch-over.
1737                 # Let's set some arbitrary (low) virtual link limits.
1738                 init_shapers
1739                 pm_nl_set_limits $ns1 0 3
1740                 pm_nl_add_endpoint $ns1 10.0.2.1 dev ns1eth2 flags signal
1741                 pm_nl_set_limits $ns2 1 3
1742                 pm_nl_add_endpoint $ns2 10.0.3.2 dev ns2eth3 flags subflow
1743                 pm_nl_add_endpoint $ns2 10.0.4.2 dev ns2eth4 flags subflow
1744                 run_tests $ns1 $ns2 10.0.1.1 1
1745                 chk_join_nr 3 3 3
1746                 chk_add_nr 1 1
1747                 chk_stale_nr $ns2 1 5 1
1748         fi
1749
1750         # accept and use add_addr with additional subflows and link loss
1751         # for bidirectional transfer
1752         if reset "multi flows, signal, bidi, link fail"; then
1753                 init_shapers
1754                 pm_nl_set_limits $ns1 0 3
1755                 pm_nl_add_endpoint $ns1 10.0.2.1 dev ns1eth2 flags signal
1756                 pm_nl_set_limits $ns2 1 3
1757                 pm_nl_add_endpoint $ns2 10.0.3.2 dev ns2eth3 flags subflow
1758                 pm_nl_add_endpoint $ns2 10.0.4.2 dev ns2eth4 flags subflow
1759                 run_tests $ns1 $ns2 10.0.1.1 2
1760                 chk_join_nr 3 3 3
1761                 chk_add_nr 1 1
1762                 chk_stale_nr $ns2 1 -1 1
1763         fi
1764
1765         # 2 subflows plus 1 backup subflow with a lossy link, backup
1766         # will never be used
1767         if reset "backup subflow unused, link failure"; then
1768                 init_shapers
1769                 pm_nl_set_limits $ns1 0 2
1770                 pm_nl_add_endpoint $ns1 10.0.2.1 dev ns1eth2 flags signal
1771                 pm_nl_set_limits $ns2 1 2
1772                 FAILING_LINKS="1"
1773                 pm_nl_add_endpoint $ns2 10.0.3.2 dev ns2eth3 flags subflow,backup
1774                 run_tests $ns1 $ns2 10.0.1.1 1
1775                 chk_join_nr 2 2 2
1776                 chk_add_nr 1 1
1777                 chk_link_usage $ns2 ns2eth3 $cinsent 0
1778         fi
1779
1780         # 2 lossy links after half transfer, backup will get half of
1781         # the traffic
1782         if reset "backup flow used, multi links fail"; then
1783                 init_shapers
1784                 pm_nl_set_limits $ns1 0 2
1785                 pm_nl_add_endpoint $ns1 10.0.2.1 dev ns1eth2 flags signal
1786                 pm_nl_set_limits $ns2 1 2
1787                 pm_nl_add_endpoint $ns2 10.0.3.2 dev ns2eth3 flags subflow,backup
1788                 FAILING_LINKS="1 2"
1789                 run_tests $ns1 $ns2 10.0.1.1 1
1790                 chk_join_nr 2 2 2
1791                 chk_add_nr 1 1
1792                 chk_stale_nr $ns2 2 4 2
1793                 chk_link_usage $ns2 ns2eth3 $cinsent 50
1794         fi
1795
1796         # use a backup subflow with the first subflow on a lossy link
1797         # for bidirectional transfer
1798         if reset "backup flow used, bidi, link failure"; then
1799                 init_shapers
1800                 pm_nl_set_limits $ns1 0 2
1801                 pm_nl_add_endpoint $ns1 10.0.2.1 dev ns1eth2 flags signal
1802                 pm_nl_set_limits $ns2 1 3
1803                 pm_nl_add_endpoint $ns2 10.0.3.2 dev ns2eth3 flags subflow,backup
1804                 FAILING_LINKS="1 2"
1805                 run_tests $ns1 $ns2 10.0.1.1 2
1806                 chk_join_nr 2 2 2
1807                 chk_add_nr 1 1
1808                 chk_stale_nr $ns2 1 -1 2
1809                 chk_link_usage $ns2 ns2eth3 $cinsent 50
1810         fi
1811 }
1812
1813 add_addr_timeout_tests()
1814 {
1815         # add_addr timeout
1816         if reset_with_add_addr_timeout "signal address, ADD_ADDR timeout"; then
1817                 pm_nl_set_limits $ns1 0 1
1818                 pm_nl_set_limits $ns2 1 1
1819                 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal
1820                 run_tests $ns1 $ns2 10.0.1.1 0 0 0 slow
1821                 chk_join_nr 1 1 1
1822                 chk_add_nr 4 0
1823         fi
1824
1825         # add_addr timeout IPv6
1826         if reset_with_add_addr_timeout "signal address, ADD_ADDR6 timeout" 6; then
1827                 pm_nl_set_limits $ns1 0 1
1828                 pm_nl_set_limits $ns2 1 1
1829                 pm_nl_add_endpoint $ns1 dead:beef:2::1 flags signal
1830                 run_tests $ns1 $ns2 dead:beef:1::1 0 0 0 slow
1831                 chk_join_nr 1 1 1
1832                 chk_add_nr 4 0
1833         fi
1834
1835         # signal addresses timeout
1836         if reset_with_add_addr_timeout "signal addresses, ADD_ADDR timeout"; then
1837                 pm_nl_set_limits $ns1 2 2
1838                 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal
1839                 pm_nl_add_endpoint $ns1 10.0.3.1 flags signal
1840                 pm_nl_set_limits $ns2 2 2
1841                 run_tests $ns1 $ns2 10.0.1.1 0 0 0 speed_10
1842                 chk_join_nr 2 2 2
1843                 chk_add_nr 8 0
1844         fi
1845
1846         # signal invalid addresses timeout
1847         if reset_with_add_addr_timeout "invalid address, ADD_ADDR timeout"; then
1848                 pm_nl_set_limits $ns1 2 2
1849                 pm_nl_add_endpoint $ns1 10.0.12.1 flags signal
1850                 pm_nl_add_endpoint $ns1 10.0.3.1 flags signal
1851                 pm_nl_set_limits $ns2 2 2
1852                 run_tests $ns1 $ns2 10.0.1.1 0 0 0 speed_10
1853                 chk_join_nr 1 1 1
1854                 chk_add_nr 8 0
1855         fi
1856 }
1857
1858 remove_tests()
1859 {
1860         # single subflow, remove
1861         if reset "remove single subflow"; then
1862                 pm_nl_set_limits $ns1 0 1
1863                 pm_nl_set_limits $ns2 0 1
1864                 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow
1865                 run_tests $ns1 $ns2 10.0.1.1 0 0 -1 slow
1866                 chk_join_nr 1 1 1
1867                 chk_rm_nr 1 1
1868         fi
1869
1870         # multiple subflows, remove
1871         if reset "remove multiple subflows"; then
1872                 pm_nl_set_limits $ns1 0 2
1873                 pm_nl_set_limits $ns2 0 2
1874                 pm_nl_add_endpoint $ns2 10.0.2.2 flags subflow
1875                 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow
1876                 run_tests $ns1 $ns2 10.0.1.1 0 0 -2 slow
1877                 chk_join_nr 2 2 2
1878                 chk_rm_nr 2 2
1879         fi
1880
1881         # single address, remove
1882         if reset "remove single address"; then
1883                 pm_nl_set_limits $ns1 0 1
1884                 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal
1885                 pm_nl_set_limits $ns2 1 1
1886                 run_tests $ns1 $ns2 10.0.1.1 0 -1 0 slow
1887                 chk_join_nr 1 1 1
1888                 chk_add_nr 1 1
1889                 chk_rm_nr 1 1 invert
1890         fi
1891
1892         # subflow and signal, remove
1893         if reset "remove subflow and signal"; then
1894                 pm_nl_set_limits $ns1 0 2
1895                 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal
1896                 pm_nl_set_limits $ns2 1 2
1897                 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow
1898                 run_tests $ns1 $ns2 10.0.1.1 0 -1 -1 slow
1899                 chk_join_nr 2 2 2
1900                 chk_add_nr 1 1
1901                 chk_rm_nr 1 1
1902         fi
1903
1904         # subflows and signal, remove
1905         if reset "remove subflows and signal"; then
1906                 pm_nl_set_limits $ns1 0 3
1907                 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal
1908                 pm_nl_set_limits $ns2 1 3
1909                 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow
1910                 pm_nl_add_endpoint $ns2 10.0.4.2 flags subflow
1911                 run_tests $ns1 $ns2 10.0.1.1 0 -1 -2 slow
1912                 chk_join_nr 3 3 3
1913                 chk_add_nr 1 1
1914                 chk_rm_nr 2 2
1915         fi
1916
1917         # addresses remove
1918         if reset "remove addresses"; then
1919                 pm_nl_set_limits $ns1 3 3
1920                 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal id 250
1921                 pm_nl_add_endpoint $ns1 10.0.3.1 flags signal
1922                 pm_nl_add_endpoint $ns1 10.0.4.1 flags signal
1923                 pm_nl_set_limits $ns2 3 3
1924                 run_tests $ns1 $ns2 10.0.1.1 0 -3 0 slow
1925                 chk_join_nr 3 3 3
1926                 chk_add_nr 3 3
1927                 chk_rm_nr 3 3 invert
1928         fi
1929
1930         # invalid addresses remove
1931         if reset "remove invalid addresses"; then
1932                 pm_nl_set_limits $ns1 3 3
1933                 pm_nl_add_endpoint $ns1 10.0.12.1 flags signal
1934                 pm_nl_add_endpoint $ns1 10.0.3.1 flags signal
1935                 pm_nl_add_endpoint $ns1 10.0.14.1 flags signal
1936                 pm_nl_set_limits $ns2 3 3
1937                 run_tests $ns1 $ns2 10.0.1.1 0 -3 0 slow
1938                 chk_join_nr 1 1 1
1939                 chk_add_nr 3 3
1940                 chk_rm_nr 3 1 invert
1941         fi
1942
1943         # subflows and signal, flush
1944         if reset "flush subflows and signal"; then
1945                 pm_nl_set_limits $ns1 0 3
1946                 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal
1947                 pm_nl_set_limits $ns2 1 3
1948                 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow
1949                 pm_nl_add_endpoint $ns2 10.0.4.2 flags subflow
1950                 run_tests $ns1 $ns2 10.0.1.1 0 -8 -8 slow
1951                 chk_join_nr 3 3 3
1952                 chk_add_nr 1 1
1953                 chk_rm_nr 1 3 invert simult
1954         fi
1955
1956         # subflows flush
1957         if reset "flush subflows"; then
1958                 pm_nl_set_limits $ns1 3 3
1959                 pm_nl_set_limits $ns2 3 3
1960                 pm_nl_add_endpoint $ns2 10.0.2.2 flags subflow id 150
1961                 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow
1962                 pm_nl_add_endpoint $ns2 10.0.4.2 flags subflow
1963                 run_tests $ns1 $ns2 10.0.1.1 0 -8 -8 slow
1964                 chk_join_nr 3 3 3
1965                 chk_rm_nr 0 3 simult
1966         fi
1967
1968         # addresses flush
1969         if reset "flush addresses"; then
1970                 pm_nl_set_limits $ns1 3 3
1971                 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal id 250
1972                 pm_nl_add_endpoint $ns1 10.0.3.1 flags signal
1973                 pm_nl_add_endpoint $ns1 10.0.4.1 flags signal
1974                 pm_nl_set_limits $ns2 3 3
1975                 run_tests $ns1 $ns2 10.0.1.1 0 -8 -8 slow
1976                 chk_join_nr 3 3 3
1977                 chk_add_nr 3 3
1978                 chk_rm_nr 3 3 invert simult
1979         fi
1980
1981         # invalid addresses flush
1982         if reset "flush invalid addresses"; then
1983                 pm_nl_set_limits $ns1 3 3
1984                 pm_nl_add_endpoint $ns1 10.0.12.1 flags signal
1985                 pm_nl_add_endpoint $ns1 10.0.3.1 flags signal
1986                 pm_nl_add_endpoint $ns1 10.0.14.1 flags signal
1987                 pm_nl_set_limits $ns2 3 3
1988                 run_tests $ns1 $ns2 10.0.1.1 0 -8 0 slow
1989                 chk_join_nr 1 1 1
1990                 chk_add_nr 3 3
1991                 chk_rm_nr 3 1 invert
1992         fi
1993
1994         # remove id 0 subflow
1995         if reset "remove id 0 subflow"; then
1996                 pm_nl_set_limits $ns1 0 1
1997                 pm_nl_set_limits $ns2 0 1
1998                 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow
1999                 run_tests $ns1 $ns2 10.0.1.1 0 0 -9 slow
2000                 chk_join_nr 1 1 1
2001                 chk_rm_nr 1 1
2002         fi
2003
2004         # remove id 0 address
2005         if reset "remove id 0 address"; then
2006                 pm_nl_set_limits $ns1 0 1
2007                 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal
2008                 pm_nl_set_limits $ns2 1 1
2009                 run_tests $ns1 $ns2 10.0.1.1 0 -9 0 slow
2010                 chk_join_nr 1 1 1
2011                 chk_add_nr 1 1
2012                 chk_rm_nr 1 1 invert
2013         fi
2014 }
2015
2016 add_tests()
2017 {
2018         # add single subflow
2019         if reset "add single subflow"; then
2020                 pm_nl_set_limits $ns1 0 1
2021                 pm_nl_set_limits $ns2 0 1
2022                 run_tests $ns1 $ns2 10.0.1.1 0 0 1 slow
2023                 chk_join_nr 1 1 1
2024         fi
2025
2026         # add signal address
2027         if reset "add signal address"; then
2028                 pm_nl_set_limits $ns1 0 1
2029                 pm_nl_set_limits $ns2 1 1
2030                 run_tests $ns1 $ns2 10.0.1.1 0 1 0 slow
2031                 chk_join_nr 1 1 1
2032                 chk_add_nr 1 1
2033         fi
2034
2035         # add multiple subflows
2036         if reset "add multiple subflows"; then
2037                 pm_nl_set_limits $ns1 0 2
2038                 pm_nl_set_limits $ns2 0 2
2039                 run_tests $ns1 $ns2 10.0.1.1 0 0 2 slow
2040                 chk_join_nr 2 2 2
2041         fi
2042
2043         # add multiple subflows IPv6
2044         if reset "add multiple subflows IPv6"; then
2045                 pm_nl_set_limits $ns1 0 2
2046                 pm_nl_set_limits $ns2 0 2
2047                 run_tests $ns1 $ns2 dead:beef:1::1 0 0 2 slow
2048                 chk_join_nr 2 2 2
2049         fi
2050
2051         # add multiple addresses IPv6
2052         if reset "add multiple addresses IPv6"; then
2053                 pm_nl_set_limits $ns1 0 2
2054                 pm_nl_set_limits $ns2 2 2
2055                 run_tests $ns1 $ns2 dead:beef:1::1 0 2 0 slow
2056                 chk_join_nr 2 2 2
2057                 chk_add_nr 2 2
2058         fi
2059 }
2060
2061 ipv6_tests()
2062 {
2063         # subflow IPv6
2064         if reset "single subflow IPv6"; then
2065                 pm_nl_set_limits $ns1 0 1
2066                 pm_nl_set_limits $ns2 0 1
2067                 pm_nl_add_endpoint $ns2 dead:beef:3::2 dev ns2eth3 flags subflow
2068                 run_tests $ns1 $ns2 dead:beef:1::1 0 0 0 slow
2069                 chk_join_nr 1 1 1
2070         fi
2071
2072         # add_address, unused IPv6
2073         if reset "unused signal address IPv6"; then
2074                 pm_nl_add_endpoint $ns1 dead:beef:2::1 flags signal
2075                 run_tests $ns1 $ns2 dead:beef:1::1 0 0 0 slow
2076                 chk_join_nr 0 0 0
2077                 chk_add_nr 1 1
2078         fi
2079
2080         # signal address IPv6
2081         if reset "single address IPv6"; then
2082                 pm_nl_set_limits $ns1 0 1
2083                 pm_nl_add_endpoint $ns1 dead:beef:2::1 flags signal
2084                 pm_nl_set_limits $ns2 1 1
2085                 run_tests $ns1 $ns2 dead:beef:1::1 0 0 0 slow
2086                 chk_join_nr 1 1 1
2087                 chk_add_nr 1 1
2088         fi
2089
2090         # single address IPv6, remove
2091         if reset "remove single address IPv6"; then
2092                 pm_nl_set_limits $ns1 0 1
2093                 pm_nl_add_endpoint $ns1 dead:beef:2::1 flags signal
2094                 pm_nl_set_limits $ns2 1 1
2095                 run_tests $ns1 $ns2 dead:beef:1::1 0 -1 0 slow
2096                 chk_join_nr 1 1 1
2097                 chk_add_nr 1 1
2098                 chk_rm_nr 1 1 invert
2099         fi
2100
2101         # subflow and signal IPv6, remove
2102         if reset "remove subflow and signal IPv6"; then
2103                 pm_nl_set_limits $ns1 0 2
2104                 pm_nl_add_endpoint $ns1 dead:beef:2::1 flags signal
2105                 pm_nl_set_limits $ns2 1 2
2106                 pm_nl_add_endpoint $ns2 dead:beef:3::2 dev ns2eth3 flags subflow
2107                 run_tests $ns1 $ns2 dead:beef:1::1 0 -1 -1 slow
2108                 chk_join_nr 2 2 2
2109                 chk_add_nr 1 1
2110                 chk_rm_nr 1 1
2111         fi
2112 }
2113
2114 v4mapped_tests()
2115 {
2116         # subflow IPv4-mapped to IPv4-mapped
2117         if reset "single subflow IPv4-mapped"; then
2118                 pm_nl_set_limits $ns1 0 1
2119                 pm_nl_set_limits $ns2 0 1
2120                 pm_nl_add_endpoint $ns2 "::ffff:10.0.3.2" flags subflow
2121                 run_tests $ns1 $ns2 "::ffff:10.0.1.1"
2122                 chk_join_nr 1 1 1
2123         fi
2124
2125         # signal address IPv4-mapped with IPv4-mapped sk
2126         if reset "signal address IPv4-mapped"; then
2127                 pm_nl_set_limits $ns1 0 1
2128                 pm_nl_set_limits $ns2 1 1
2129                 pm_nl_add_endpoint $ns1 "::ffff:10.0.2.1" flags signal
2130                 run_tests $ns1 $ns2 "::ffff:10.0.1.1"
2131                 chk_join_nr 1 1 1
2132                 chk_add_nr 1 1
2133         fi
2134
2135         # subflow v4-map-v6
2136         if reset "single subflow v4-map-v6"; then
2137                 pm_nl_set_limits $ns1 0 1
2138                 pm_nl_set_limits $ns2 0 1
2139                 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow
2140                 run_tests $ns1 $ns2 "::ffff:10.0.1.1"
2141                 chk_join_nr 1 1 1
2142         fi
2143
2144         # signal address v4-map-v6
2145         if reset "signal address v4-map-v6"; then
2146                 pm_nl_set_limits $ns1 0 1
2147                 pm_nl_set_limits $ns2 1 1
2148                 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal
2149                 run_tests $ns1 $ns2 "::ffff:10.0.1.1"
2150                 chk_join_nr 1 1 1
2151                 chk_add_nr 1 1
2152         fi
2153
2154         # subflow v6-map-v4
2155         if reset "single subflow v6-map-v4"; then
2156                 pm_nl_set_limits $ns1 0 1
2157                 pm_nl_set_limits $ns2 0 1
2158                 pm_nl_add_endpoint $ns2 "::ffff:10.0.3.2" flags subflow
2159                 run_tests $ns1 $ns2 10.0.1.1
2160                 chk_join_nr 1 1 1
2161         fi
2162
2163         # signal address v6-map-v4
2164         if reset "signal address v6-map-v4"; then
2165                 pm_nl_set_limits $ns1 0 1
2166                 pm_nl_set_limits $ns2 1 1
2167                 pm_nl_add_endpoint $ns1 "::ffff:10.0.2.1" flags signal
2168                 run_tests $ns1 $ns2 10.0.1.1
2169                 chk_join_nr 1 1 1
2170                 chk_add_nr 1 1
2171         fi
2172
2173         # no subflow IPv6 to v4 address
2174         if reset "no JOIN with diff families v4-v6"; then
2175                 pm_nl_set_limits $ns1 0 1
2176                 pm_nl_set_limits $ns2 0 1
2177                 pm_nl_add_endpoint $ns2 dead:beef:2::2 flags subflow
2178                 run_tests $ns1 $ns2 10.0.1.1
2179                 chk_join_nr 0 0 0
2180         fi
2181
2182         # no subflow IPv6 to v4 address even if v6 has a valid v4 at the end
2183         if reset "no JOIN with diff families v4-v6-2"; then
2184                 pm_nl_set_limits $ns1 0 1
2185                 pm_nl_set_limits $ns2 0 1
2186                 pm_nl_add_endpoint $ns2 dead:beef:2::10.0.3.2 flags subflow
2187                 run_tests $ns1 $ns2 10.0.1.1
2188                 chk_join_nr 0 0 0
2189         fi
2190
2191         # no subflow IPv4 to v6 address, no need to slow down too then
2192         if reset "no JOIN with diff families v6-v4"; then
2193                 pm_nl_set_limits $ns1 0 1
2194                 pm_nl_set_limits $ns2 0 1
2195                 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow
2196                 run_tests $ns1 $ns2 dead:beef:1::1
2197                 chk_join_nr 0 0 0
2198         fi
2199 }
2200
2201 backup_tests()
2202 {
2203         # single subflow, backup
2204         if reset "single subflow, backup"; then
2205                 pm_nl_set_limits $ns1 0 1
2206                 pm_nl_set_limits $ns2 0 1
2207                 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow,backup
2208                 run_tests $ns1 $ns2 10.0.1.1 0 0 0 slow nobackup
2209                 chk_join_nr 1 1 1
2210                 chk_prio_nr 0 1
2211         fi
2212
2213         # single address, backup
2214         if reset "single address, backup"; then
2215                 pm_nl_set_limits $ns1 0 1
2216                 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal
2217                 pm_nl_set_limits $ns2 1 1
2218                 run_tests $ns1 $ns2 10.0.1.1 0 0 0 slow backup
2219                 chk_join_nr 1 1 1
2220                 chk_add_nr 1 1
2221                 chk_prio_nr 1 1
2222         fi
2223
2224         # single address with port, backup
2225         if reset "single address with port, backup"; then
2226                 pm_nl_set_limits $ns1 0 1
2227                 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal port 10100
2228                 pm_nl_set_limits $ns2 1 1
2229                 run_tests $ns1 $ns2 10.0.1.1 0 0 0 slow backup
2230                 chk_join_nr 1 1 1
2231                 chk_add_nr 1 1
2232                 chk_prio_nr 1 1
2233         fi
2234 }
2235
2236 add_addr_ports_tests()
2237 {
2238         # signal address with port
2239         if reset "signal address with port"; then
2240                 pm_nl_set_limits $ns1 0 1
2241                 pm_nl_set_limits $ns2 1 1
2242                 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal port 10100
2243                 run_tests $ns1 $ns2 10.0.1.1
2244                 chk_join_nr 1 1 1
2245                 chk_add_nr 1 1 1
2246         fi
2247
2248         # subflow and signal with port
2249         if reset "subflow and signal with port"; then
2250                 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal port 10100
2251                 pm_nl_set_limits $ns1 0 2
2252                 pm_nl_set_limits $ns2 1 2
2253                 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow
2254                 run_tests $ns1 $ns2 10.0.1.1
2255                 chk_join_nr 2 2 2
2256                 chk_add_nr 1 1 1
2257         fi
2258
2259         # single address with port, remove
2260         if reset "remove single address with port"; then
2261                 pm_nl_set_limits $ns1 0 1
2262                 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal port 10100
2263                 pm_nl_set_limits $ns2 1 1
2264                 run_tests $ns1 $ns2 10.0.1.1 0 -1 0 slow
2265                 chk_join_nr 1 1 1
2266                 chk_add_nr 1 1 1
2267                 chk_rm_nr 1 1 invert
2268         fi
2269
2270         # subflow and signal with port, remove
2271         if reset "remove subflow and signal with port"; then
2272                 pm_nl_set_limits $ns1 0 2
2273                 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal port 10100
2274                 pm_nl_set_limits $ns2 1 2
2275                 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow
2276                 run_tests $ns1 $ns2 10.0.1.1 0 -1 -1 slow
2277                 chk_join_nr 2 2 2
2278                 chk_add_nr 1 1 1
2279                 chk_rm_nr 1 1
2280         fi
2281
2282         # subflows and signal with port, flush
2283         if reset "flush subflows and signal with port"; then
2284                 pm_nl_set_limits $ns1 0 3
2285                 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal port 10100
2286                 pm_nl_set_limits $ns2 1 3
2287                 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow
2288                 pm_nl_add_endpoint $ns2 10.0.4.2 flags subflow
2289                 run_tests $ns1 $ns2 10.0.1.1 0 -8 -2 slow
2290                 chk_join_nr 3 3 3
2291                 chk_add_nr 1 1
2292                 chk_rm_nr 1 3 invert simult
2293         fi
2294
2295         # multiple addresses with port
2296         if reset "multiple addresses with port"; then
2297                 pm_nl_set_limits $ns1 2 2
2298                 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal port 10100
2299                 pm_nl_add_endpoint $ns1 10.0.3.1 flags signal port 10100
2300                 pm_nl_set_limits $ns2 2 2
2301                 run_tests $ns1 $ns2 10.0.1.1
2302                 chk_join_nr 2 2 2
2303                 chk_add_nr 2 2 2
2304         fi
2305
2306         # multiple addresses with ports
2307         if reset "multiple addresses with ports"; then
2308                 pm_nl_set_limits $ns1 2 2
2309                 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal port 10100
2310                 pm_nl_add_endpoint $ns1 10.0.3.1 flags signal port 10101
2311                 pm_nl_set_limits $ns2 2 2
2312                 run_tests $ns1 $ns2 10.0.1.1
2313                 chk_join_nr 2 2 2
2314                 chk_add_nr 2 2 2
2315         fi
2316 }
2317
2318 syncookies_tests()
2319 {
2320         # single subflow, syncookies
2321         if reset_with_cookies "single subflow with syn cookies"; then
2322                 pm_nl_set_limits $ns1 0 1
2323                 pm_nl_set_limits $ns2 0 1
2324                 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow
2325                 run_tests $ns1 $ns2 10.0.1.1
2326                 chk_join_nr 1 1 1
2327         fi
2328
2329         # multiple subflows with syn cookies
2330         if reset_with_cookies "multiple subflows with syn cookies"; then
2331                 pm_nl_set_limits $ns1 0 2
2332                 pm_nl_set_limits $ns2 0 2
2333                 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow
2334                 pm_nl_add_endpoint $ns2 10.0.2.2 flags subflow
2335                 run_tests $ns1 $ns2 10.0.1.1
2336                 chk_join_nr 2 2 2
2337         fi
2338
2339         # multiple subflows limited by server
2340         if reset_with_cookies "subflows limited by server w cookies"; then
2341                 pm_nl_set_limits $ns1 0 1
2342                 pm_nl_set_limits $ns2 0 2
2343                 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow
2344                 pm_nl_add_endpoint $ns2 10.0.2.2 flags subflow
2345                 run_tests $ns1 $ns2 10.0.1.1
2346                 chk_join_nr 2 1 1
2347         fi
2348
2349         # test signal address with cookies
2350         if reset_with_cookies "signal address with syn cookies"; then
2351                 pm_nl_set_limits $ns1 0 1
2352                 pm_nl_set_limits $ns2 1 1
2353                 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal
2354                 run_tests $ns1 $ns2 10.0.1.1
2355                 chk_join_nr 1 1 1
2356                 chk_add_nr 1 1
2357         fi
2358
2359         # test cookie with subflow and signal
2360         if reset_with_cookies "subflow and signal w cookies"; then
2361                 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal
2362                 pm_nl_set_limits $ns1 0 2
2363                 pm_nl_set_limits $ns2 1 2
2364                 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow
2365                 run_tests $ns1 $ns2 10.0.1.1
2366                 chk_join_nr 2 2 2
2367                 chk_add_nr 1 1
2368         fi
2369
2370         # accept and use add_addr with additional subflows
2371         if reset_with_cookies "subflows and signal w. cookies"; then
2372                 pm_nl_set_limits $ns1 0 3
2373                 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal
2374                 pm_nl_set_limits $ns2 1 3
2375                 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow
2376                 pm_nl_add_endpoint $ns2 10.0.4.2 flags subflow
2377                 run_tests $ns1 $ns2 10.0.1.1
2378                 chk_join_nr 3 3 3
2379                 chk_add_nr 1 1
2380         fi
2381 }
2382
2383 checksum_tests()
2384 {
2385         # checksum test 0 0
2386         if reset_with_checksum 0 0; then
2387                 pm_nl_set_limits $ns1 0 1
2388                 pm_nl_set_limits $ns2 0 1
2389                 run_tests $ns1 $ns2 10.0.1.1
2390                 chk_join_nr 0 0 0
2391         fi
2392
2393         # checksum test 1 1
2394         if reset_with_checksum 1 1; then
2395                 pm_nl_set_limits $ns1 0 1
2396                 pm_nl_set_limits $ns2 0 1
2397                 run_tests $ns1 $ns2 10.0.1.1
2398                 chk_join_nr 0 0 0
2399         fi
2400
2401         # checksum test 0 1
2402         if reset_with_checksum 0 1; then
2403                 pm_nl_set_limits $ns1 0 1
2404                 pm_nl_set_limits $ns2 0 1
2405                 run_tests $ns1 $ns2 10.0.1.1
2406                 chk_join_nr 0 0 0
2407         fi
2408
2409         # checksum test 1 0
2410         if reset_with_checksum 1 0; then
2411                 pm_nl_set_limits $ns1 0 1
2412                 pm_nl_set_limits $ns2 0 1
2413                 run_tests $ns1 $ns2 10.0.1.1
2414                 chk_join_nr 0 0 0
2415         fi
2416 }
2417
2418 deny_join_id0_tests()
2419 {
2420         # subflow allow join id0 ns1
2421         if reset_with_allow_join_id0 "single subflow allow join id0 ns1" 1 0; then
2422                 pm_nl_set_limits $ns1 1 1
2423                 pm_nl_set_limits $ns2 1 1
2424                 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow
2425                 run_tests $ns1 $ns2 10.0.1.1
2426                 chk_join_nr 1 1 1
2427         fi
2428
2429         # subflow allow join id0 ns2
2430         if reset_with_allow_join_id0 "single subflow allow join id0 ns2" 0 1; then
2431                 pm_nl_set_limits $ns1 1 1
2432                 pm_nl_set_limits $ns2 1 1
2433                 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow
2434                 run_tests $ns1 $ns2 10.0.1.1
2435                 chk_join_nr 0 0 0
2436         fi
2437
2438         # signal address allow join id0 ns1
2439         # ADD_ADDRs are not affected by allow_join_id0 value.
2440         if reset_with_allow_join_id0 "signal address allow join id0 ns1" 1 0; then
2441                 pm_nl_set_limits $ns1 1 1
2442                 pm_nl_set_limits $ns2 1 1
2443                 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal
2444                 run_tests $ns1 $ns2 10.0.1.1
2445                 chk_join_nr 1 1 1
2446                 chk_add_nr 1 1
2447         fi
2448
2449         # signal address allow join id0 ns2
2450         # ADD_ADDRs are not affected by allow_join_id0 value.
2451         if reset_with_allow_join_id0 "signal address allow join id0 ns2" 0 1; then
2452                 pm_nl_set_limits $ns1 1 1
2453                 pm_nl_set_limits $ns2 1 1
2454                 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal
2455                 run_tests $ns1 $ns2 10.0.1.1
2456                 chk_join_nr 1 1 1
2457                 chk_add_nr 1 1
2458         fi
2459
2460         # subflow and address allow join id0 ns1
2461         if reset_with_allow_join_id0 "subflow and address allow join id0 1" 1 0; then
2462                 pm_nl_set_limits $ns1 2 2
2463                 pm_nl_set_limits $ns2 2 2
2464                 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal
2465                 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow
2466                 run_tests $ns1 $ns2 10.0.1.1
2467                 chk_join_nr 2 2 2
2468         fi
2469
2470         # subflow and address allow join id0 ns2
2471         if reset_with_allow_join_id0 "subflow and address allow join id0 2" 0 1; then
2472                 pm_nl_set_limits $ns1 2 2
2473                 pm_nl_set_limits $ns2 2 2
2474                 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal
2475                 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow
2476                 run_tests $ns1 $ns2 10.0.1.1
2477                 chk_join_nr 1 1 1
2478         fi
2479 }
2480
2481 fullmesh_tests()
2482 {
2483         # fullmesh 1
2484         # 2 fullmesh addrs in ns2, added before the connection,
2485         # 1 non-fullmesh addr in ns1, added during the connection.
2486         if reset "fullmesh test 2x1"; then
2487                 pm_nl_set_limits $ns1 0 4
2488                 pm_nl_set_limits $ns2 1 4
2489                 pm_nl_add_endpoint $ns2 10.0.2.2 flags subflow,fullmesh
2490                 pm_nl_add_endpoint $ns2 10.0.3.2 flags subflow,fullmesh
2491                 run_tests $ns1 $ns2 10.0.1.1 0 1 0 slow
2492                 chk_join_nr 4 4 4
2493                 chk_add_nr 1 1
2494         fi
2495
2496         # fullmesh 2
2497         # 1 non-fullmesh addr in ns1, added before the connection,
2498         # 1 fullmesh addr in ns2, added during the connection.
2499         if reset "fullmesh test 1x1"; then
2500                 pm_nl_set_limits $ns1 1 3
2501                 pm_nl_set_limits $ns2 1 3
2502                 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal
2503                 run_tests $ns1 $ns2 10.0.1.1 0 0 fullmesh_1 slow
2504                 chk_join_nr 3 3 3
2505                 chk_add_nr 1 1
2506         fi
2507
2508         # fullmesh 3
2509         # 1 non-fullmesh addr in ns1, added before the connection,
2510         # 2 fullmesh addrs in ns2, added during the connection.
2511         if reset "fullmesh test 1x2"; then
2512                 pm_nl_set_limits $ns1 2 5
2513                 pm_nl_set_limits $ns2 1 5
2514                 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal
2515                 run_tests $ns1 $ns2 10.0.1.1 0 0 fullmesh_2 slow
2516                 chk_join_nr 5 5 5
2517                 chk_add_nr 1 1
2518         fi
2519
2520         # fullmesh 4
2521         # 1 non-fullmesh addr in ns1, added before the connection,
2522         # 2 fullmesh addrs in ns2, added during the connection,
2523         # limit max_subflows to 4.
2524         if reset "fullmesh test 1x2, limited"; then
2525                 pm_nl_set_limits $ns1 2 4
2526                 pm_nl_set_limits $ns2 1 4
2527                 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal
2528                 run_tests $ns1 $ns2 10.0.1.1 0 0 fullmesh_2 slow
2529                 chk_join_nr 4 4 4
2530                 chk_add_nr 1 1
2531         fi
2532
2533         # set fullmesh flag
2534         if reset "set fullmesh flag test"; then
2535                 pm_nl_set_limits $ns1 4 4
2536                 pm_nl_add_endpoint $ns1 10.0.2.1 flags subflow
2537                 pm_nl_set_limits $ns2 4 4
2538                 run_tests $ns1 $ns2 10.0.1.1 0 0 1 slow fullmesh
2539                 chk_join_nr 2 2 2
2540                 chk_rm_nr 0 1
2541         fi
2542
2543         # set nofullmesh flag
2544         if reset "set nofullmesh flag test"; then
2545                 pm_nl_set_limits $ns1 4 4
2546                 pm_nl_add_endpoint $ns1 10.0.2.1 flags subflow,fullmesh
2547                 pm_nl_set_limits $ns2 4 4
2548                 run_tests $ns1 $ns2 10.0.1.1 0 0 fullmesh_1 slow nofullmesh
2549                 chk_join_nr 2 2 2
2550                 chk_rm_nr 0 1
2551         fi
2552
2553         # set backup,fullmesh flags
2554         if reset "set backup,fullmesh flags test"; then
2555                 pm_nl_set_limits $ns1 4 4
2556                 pm_nl_add_endpoint $ns1 10.0.2.1 flags subflow
2557                 pm_nl_set_limits $ns2 4 4
2558                 run_tests $ns1 $ns2 10.0.1.1 0 0 1 slow backup,fullmesh
2559                 chk_join_nr 2 2 2
2560                 chk_prio_nr 0 1
2561                 chk_rm_nr 0 1
2562         fi
2563
2564         # set nobackup,nofullmesh flags
2565         if reset "set nobackup,nofullmesh flags test"; then
2566                 pm_nl_set_limits $ns1 4 4
2567                 pm_nl_set_limits $ns2 4 4
2568                 pm_nl_add_endpoint $ns2 10.0.2.2 flags subflow,backup,fullmesh
2569                 run_tests $ns1 $ns2 10.0.1.1 0 0 0 slow nobackup,nofullmesh
2570                 chk_join_nr 2 2 2
2571                 chk_prio_nr 0 1
2572                 chk_rm_nr 0 1
2573         fi
2574 }
2575
2576 fastclose_tests()
2577 {
2578         if reset "fastclose test"; then
2579                 run_tests $ns1 $ns2 10.0.1.1 1024 0 fastclose_2
2580                 chk_join_nr 0 0 0
2581                 chk_fclose_nr 1 1
2582                 chk_rst_nr 1 1 invert
2583         fi
2584 }
2585
2586 endpoint_tests()
2587 {
2588         # userspace pm type prevents add_addr
2589         if reset "implicit EP"; then
2590                 pm_nl_set_limits $ns1 2 2
2591                 pm_nl_set_limits $ns2 2 2
2592                 pm_nl_add_endpoint $ns1 10.0.2.1 flags signal
2593                 run_tests $ns1 $ns2 10.0.1.1 0 0 0 slow &
2594
2595                 wait_mpj $ns1
2596                 pm_nl_check_endpoint 1 "creation" \
2597                         $ns2 10.0.2.2 id 1 flags implicit
2598
2599                 pm_nl_add_endpoint $ns2 10.0.2.2 id 33
2600                 pm_nl_check_endpoint 0 "ID change is prevented" \
2601                         $ns2 10.0.2.2 id 1 flags implicit
2602
2603                 pm_nl_add_endpoint $ns2 10.0.2.2 flags signal
2604                 pm_nl_check_endpoint 0 "modif is allowed" \
2605                         $ns2 10.0.2.2 id 1 flags signal
2606                 wait
2607         fi
2608
2609         if reset "delete and re-add"; then
2610                 pm_nl_set_limits $ns1 1 1
2611                 pm_nl_set_limits $ns2 1 1
2612                 pm_nl_add_endpoint $ns2 10.0.2.2 id 2 dev ns2eth2 flags subflow
2613                 run_tests $ns1 $ns2 10.0.1.1 4 0 0 slow &
2614
2615                 wait_mpj $ns2
2616                 pm_nl_del_endpoint $ns2 2 10.0.2.2
2617                 sleep 0.5
2618                 chk_subflow_nr needtitle "after delete" 1
2619
2620                 pm_nl_add_endpoint $ns2 10.0.2.2 dev ns2eth2 flags subflow
2621                 wait_mpj $ns2
2622                 chk_subflow_nr "" "after re-add" 2
2623                 wait
2624         fi
2625 }
2626
2627 # [$1: error message]
2628 usage()
2629 {
2630         if [ -n "${1}" ]; then
2631                 echo "${1}"
2632                 ret=1
2633         fi
2634
2635         echo "mptcp_join usage:"
2636
2637         local key
2638         for key in "${!all_tests[@]}"; do
2639                 echo "  -${key} ${all_tests[${key}]}"
2640         done
2641
2642         echo "  -c capture pcap files"
2643         echo "  -C enable data checksum"
2644         echo "  -i use ip mptcp"
2645         echo "  -h help"
2646
2647         echo "[test ids|names]"
2648
2649         exit ${ret}
2650 }
2651
2652
2653 # Use a "simple" array to force an specific order we cannot have with an associative one
2654 all_tests_sorted=(
2655         f@subflows_tests
2656         e@subflows_error_tests
2657         s@signal_address_tests
2658         l@link_failure_tests
2659         t@add_addr_timeout_tests
2660         r@remove_tests
2661         a@add_tests
2662         6@ipv6_tests
2663         4@v4mapped_tests
2664         b@backup_tests
2665         p@add_addr_ports_tests
2666         k@syncookies_tests
2667         S@checksum_tests
2668         d@deny_join_id0_tests
2669         m@fullmesh_tests
2670         z@fastclose_tests
2671         I@endpoint_tests
2672 )
2673
2674 all_tests_args=""
2675 all_tests_names=()
2676 for subtests in "${all_tests_sorted[@]}"; do
2677         key="${subtests%@*}"
2678         value="${subtests#*@}"
2679
2680         all_tests_args+="${key}"
2681         all_tests_names+=("${value}")
2682         all_tests[${key}]="${value}"
2683 done
2684
2685 tests=()
2686 while getopts "${all_tests_args}cCih" opt; do
2687         case $opt in
2688                 ["${all_tests_args}"])
2689                         tests+=("${all_tests[${opt}]}")
2690                         ;;
2691                 c)
2692                         capture=1
2693                         ;;
2694                 C)
2695                         checksum=1
2696                         ;;
2697                 i)
2698                         ip_mptcp=1
2699                         ;;
2700                 h)
2701                         usage
2702                         ;;
2703                 *)
2704                         usage "Unknown option: -${opt}"
2705                         ;;
2706         esac
2707 done
2708
2709 shift $((OPTIND - 1))
2710
2711 for arg in "${@}"; do
2712         if [[ "${arg}" =~ ^[0-9]+$ ]]; then
2713                 only_tests_ids+=("${arg}")
2714         else
2715                 only_tests_names+=("${arg}")
2716         fi
2717 done
2718
2719 if [ ${#tests[@]} -eq 0 ]; then
2720         tests=("${all_tests_names[@]}")
2721 fi
2722
2723 for subtests in "${tests[@]}"; do
2724         "${subtests}"
2725 done
2726
2727 if [ ${ret} -ne 0 ]; then
2728         echo
2729         echo "${#failed_tests[@]} failure(s) has(ve) been detected:"
2730         for i in $(get_failed_tests_ids); do
2731                 echo -e "\t- ${i}: ${failed_tests[${i}]}"
2732         done
2733         echo
2734 fi
2735
2736 exit $ret