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