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

   1 #!/bin/bash
   2 # SPDX-License-Identifier: GPL-2.0
   3
   4 ret=0
   5 sin=""
   6 sinfail=""
   7 sout=""
   8 cin=""
   9 cinfail=""
  10 cinsent=""
  11 cout=""
  12 ksft_skip=4
  13 timeout_poll=30
  14 timeout_test=$((timeout_poll * 2 + 1))
  15 mptcp_connect=""
  16 capture=0
  17 checksum=0
  18 do_all_tests=1
  19
  20 TEST_COUNT=0
  21
  22 # generated using "nfbpf_compile '(ip && (ip[54] & 0xf0) == 0x30) ||
  23 #                                 (ip6 && (ip6[74] & 0xf0) == 0x30)'"
  24 CBPF_MPTCP_SUBOPTION_ADD_ADDR="14,
  25                                48 0 0 0,
  26                                84 0 0 240,
  27                                21 0 3 64,
  28                                48 0 0 54,
  29                                84 0 0 240,
  30                                21 6 7 48,
  31                                48 0 0 0,
  32                                84 0 0 240,
  33                                21 0 4 96,
  34                                48 0 0 74,
  35                                84 0 0 240,
  36                                21 0 1 48,
  37                                6 0 0 65535,
  38                                6 0 0 0"
  39
  40 init()
  41 {
  42         capout=$(mktemp)
  43
  44         rndh=$(printf %x $sec)-$(mktemp -u XXXXXX)
  45
  46         ns1="ns1-$rndh"
  47         ns2="ns2-$rndh"
  48
  49         for netns in "$ns1" "$ns2";do
  50                 ip netns add $netns || exit $ksft_skip
  51                 ip -net $netns link set lo up
  52                 ip netns exec $netns sysctl -q net.mptcp.enabled=1
  53                 ip netns exec $netns sysctl -q net.ipv4.conf.all.rp_filter=0
  54                 ip netns exec $netns sysctl -q net.ipv4.conf.default.rp_filter=0
  55                 if [ $checksum -eq 1 ]; then
  56                         ip netns exec $netns sysctl -q net.mptcp.checksum_enabled=1
  57                 fi
  58         done
  59
  60         #  ns1              ns2
  61         # ns1eth1    ns2eth1
  62         # ns1eth2    ns2eth2
  63         # ns1eth3    ns2eth3
  64         # ns1eth4    ns2eth4
  65
  66         for i in `seq 1 4`; do
  67                 ip link add ns1eth$i netns "$ns1" type veth peer name ns2eth$i netns "$ns2"
  68                 ip -net "$ns1" addr add 10.0.$i.1/24 dev ns1eth$i
  69                 ip -net "$ns1" addr add dead:beef:$i::1/64 dev ns1eth$i nodad
  70                 ip -net "$ns1" link set ns1eth$i up
  71
  72                 ip -net "$ns2" addr add 10.0.$i.2/24 dev ns2eth$i
  73                 ip -net "$ns2" addr add dead:beef:$i::2/64 dev ns2eth$i nodad
  74                 ip -net "$ns2" link set ns2eth$i up
  75
  76                 # let $ns2 reach any $ns1 address from any interface
  77                 ip -net "$ns2" route add default via 10.0.$i.1 dev ns2eth$i metric 10$i
  78                 ip -net "$ns2" route add default via dead:beef:$i::1 dev ns2eth$i metric 10$i
  79         done
  80 }
  81
  82 init_shapers()
  83 {
  84         for i in `seq 1 4`; do
  85                 tc -n $ns1 qdisc add dev ns1eth$i root netem rate 20mbit delay 1
  86                 tc -n $ns2 qdisc add dev ns2eth$i root netem rate 20mbit delay 1
  87         done
  88 }
  89
  90 cleanup_partial()
  91 {
  92         rm -f "$capout"
  93
  94         for netns in "$ns1" "$ns2"; do
  95                 ip netns del $netns
  96                 rm -f /tmp/$netns.{nstat,out}
  97         done
  98 }
  99
 100 cleanup()
 101 {
 102         rm -f "$cin" "$cout" "$sinfail"
 103         rm -f "$sin" "$sout" "$cinsent" "$cinfail"
 104         cleanup_partial
 105 }
 106
 107 reset()
 108 {
 109         cleanup_partial
 110         init
 111 }
 112
 113 reset_with_cookies()
 114 {
 115         reset
 116
 117         for netns in "$ns1" "$ns2";do
 118                 ip netns exec $netns sysctl -q net.ipv4.tcp_syncookies=2
 119         done
 120 }
 121
 122 reset_with_add_addr_timeout()
 123 {
 124         local ip="${1:-4}"
 125         local tables
 126
 127         tables="iptables"
 128         if [ $ip -eq 6 ]; then
 129                 tables="ip6tables"
 130         fi
 131
 132         reset
 133
 134         ip netns exec $ns1 sysctl -q net.mptcp.add_addr_timeout=1
 135         ip netns exec $ns2 $tables -A OUTPUT -p tcp \
 136                 -m tcp --tcp-option 30 \
 137                 -m bpf --bytecode \
 138                 "$CBPF_MPTCP_SUBOPTION_ADD_ADDR" \
 139                 -j DROP
 140 }
 141
 142 reset_with_checksum()
 143 {
 144         local ns1_enable=$1
 145         local ns2_enable=$2
 146
 147         reset
 148
 149         ip netns exec $ns1 sysctl -q net.mptcp.checksum_enabled=$ns1_enable
 150         ip netns exec $ns2 sysctl -q net.mptcp.checksum_enabled=$ns2_enable
 151 }
 152
 153 reset_with_allow_join_id0()
 154 {
 155         local ns1_enable=$1
 156         local ns2_enable=$2
 157
 158         reset
 159
 160         ip netns exec $ns1 sysctl -q net.mptcp.allow_join_initial_addr_port=$ns1_enable
 161         ip netns exec $ns2 sysctl -q net.mptcp.allow_join_initial_addr_port=$ns2_enable
 162 }
 163
 164 ip -Version > /dev/null 2>&1
 165 if [ $? -ne 0 ];then
 166         echo "SKIP: Could not run test without ip tool"
 167         exit $ksft_skip
 168 fi
 169
 170 iptables -V > /dev/null 2>&1
 171 if [ $? -ne 0 ];then
 172         echo "SKIP: Could not run all tests without iptables tool"
 173         exit $ksft_skip
 174 fi
 175
 176 ip6tables -V > /dev/null 2>&1
 177 if [ $? -ne 0 ];then
 178         echo "SKIP: Could not run all tests without ip6tables tool"
 179         exit $ksft_skip
 180 fi
 181
 182 print_file_err()
 183 {
 184         ls -l "$1" 1>&2
 185         echo "Trailing bytes are: "
 186         tail -c 27 "$1"
 187 }
 188
 189 check_transfer()
 190 {
 191         in=$1
 192         out=$2
 193         what=$3
 194
 195         cmp "$in" "$out" > /dev/null 2>&1
 196         if [ $? -ne 0 ] ;then
 197                 echo "[ FAIL ] $what does not match (in, out):"
 198                 print_file_err "$in"
 199                 print_file_err "$out"
 200                 ret=1
 201
 202                 return 1
 203         fi
 204
 205         return 0
 206 }
 207
 208 do_ping()
 209 {
 210         listener_ns="$1"
 211         connector_ns="$2"
 212         connect_addr="$3"
 213
 214         ip netns exec ${connector_ns} ping -q -c 1 $connect_addr >/dev/null
 215         if [ $? -ne 0 ] ; then
 216                 echo "$listener_ns -> $connect_addr connectivity [ FAIL ]" 1>&2
 217                 ret=1
 218         fi
 219 }
 220
 221 link_failure()
 222 {
 223         ns="$1"
 224
 225         if [ -z "$FAILING_LINKS" ]; then
 226                 l=$((RANDOM%4))
 227                 FAILING_LINKS=$((l+1))
 228         fi
 229
 230         for l in $FAILING_LINKS; do
 231                 veth="ns1eth$l"
 232                 ip -net "$ns" link set "$veth" down
 233         done
 234 }
 235
 236 # $1: IP address
 237 is_v6()
 238 {
 239         [ -z "${1##*:*}" ]
 240 }
 241
 242 # $1: ns, $2: port
 243 wait_local_port_listen()
 244 {
 245         local listener_ns="${1}"
 246         local port="${2}"
 247
 248         local port_hex i
 249
 250         port_hex="$(printf "%04X" "${port}")"
 251         for i in $(seq 10); do
 252                 ip netns exec "${listener_ns}" cat /proc/net/tcp* | \
 253                         awk "BEGIN {rc=1} {if (\$2 ~ /:${port_hex}\$/ && \$4 ~ /0A/) {rc=0; exit}} END {exit rc}" &&
 254                         break
 255                 sleep 0.1
 256         done
 257 }
 258
 259 rm_addr_count()
 260 {
 261         ns=${1}
 262
 263         ip netns exec ${ns} nstat -as | grep MPTcpExtRmAddr | awk '{print $2}'
 264 }
 265
 266 # $1: ns, $2: old rm_addr counter in $ns
 267 wait_rm_addr()
 268 {
 269         local ns="${1}"
 270         local old_cnt="${2}"
 271         local cnt
 272         local i
 273
 274         for i in $(seq 10); do
 275                 cnt=$(rm_addr_count ${ns})
 276                 [ "$cnt" = "${old_cnt}" ] || break
 277                 sleep 0.1
 278         done
 279 }
 280
 281 do_transfer()
 282 {
 283         listener_ns="$1"
 284         connector_ns="$2"
 285         cl_proto="$3"
 286         srv_proto="$4"
 287         connect_addr="$5"
 288         test_link_fail="$6"
 289         addr_nr_ns1="$7"
 290         addr_nr_ns2="$8"
 291         speed="$9"
 292         bkup="${10}"
 293
 294         port=$((10000+$TEST_COUNT))
 295         TEST_COUNT=$((TEST_COUNT+1))
 296
 297         :> "$cout"
 298         :> "$sout"
 299         :> "$capout"
 300
 301         if [ $capture -eq 1 ]; then
 302                 if [ -z $SUDO_USER ] ; then
 303                         capuser=""
 304                 else
 305                         capuser="-Z $SUDO_USER"
 306                 fi
 307
 308                 capfile=$(printf "mp_join-%02u-%s.pcap" "$TEST_COUNT" "${listener_ns}")
 309
 310                 echo "Capturing traffic for test $TEST_COUNT into $capfile"
 311                 ip netns exec ${listener_ns} tcpdump -i any -s 65535 -B 32768 $capuser -w $capfile > "$capout" 2>&1 &
 312                 cappid=$!
 313
 314                 sleep 1
 315         fi
 316
 317         NSTAT_HISTORY=/tmp/${listener_ns}.nstat ip netns exec ${listener_ns} \
 318                 nstat -n
 319         NSTAT_HISTORY=/tmp/${connector_ns}.nstat ip netns exec ${connector_ns} \
 320                 nstat -n
 321
 322         if [ $speed = "fast" ]; then
 323                 mptcp_connect="./mptcp_connect -j"
 324         elif [ $speed = "slow" ]; then
 325                 mptcp_connect="./mptcp_connect -r 50"
 326         elif [ $speed = "least" ]; then
 327                 mptcp_connect="./mptcp_connect -r 10"
 328         fi
 329
 330         local local_addr
 331         if is_v6 "${connect_addr}"; then
 332                 local_addr="::"
 333         else
 334                 local_addr="0.0.0.0"
 335         fi
 336
 337         if [ "$test_link_fail" -eq 2 ];then
 338                 timeout ${timeout_test} \
 339                         ip netns exec ${listener_ns} \
 340                                 $mptcp_connect -t ${timeout_poll} -l -p $port -s ${srv_proto} \
 341                                         ${local_addr} < "$sinfail" > "$sout" &
 342         else
 343                 timeout ${timeout_test} \
 344                         ip netns exec ${listener_ns} \
 345                                 $mptcp_connect -t ${timeout_poll} -l -p $port -s ${srv_proto} \
 346                                         ${local_addr} < "$sin" > "$sout" &
 347         fi
 348         spid=$!
 349
 350         wait_local_port_listen "${listener_ns}" "${port}"
 351
 352         if [ "$test_link_fail" -eq 0 ];then
 353                 timeout ${timeout_test} \
 354                         ip netns exec ${connector_ns} \
 355                                 $mptcp_connect -t ${timeout_poll} -p $port -s ${cl_proto} \
 356                                         $connect_addr < "$cin" > "$cout" &
 357         else
 358                 ( cat "$cinfail" ; sleep 2; link_failure $listener_ns ; cat "$cinfail" ) | \
 359                         tee "$cinsent" | \
 360                         timeout ${timeout_test} \
 361                                 ip netns exec ${connector_ns} \
 362                                         $mptcp_connect -t ${timeout_poll} -p $port -s ${cl_proto} \
 363                                                 $connect_addr > "$cout" &
 364         fi
 365         cpid=$!
 366
 367         # let the mptcp subflow be established in background before
 368         # do endpoint manipulation
 369         [ $addr_nr_ns1 = "0" -a $addr_nr_ns2 = "0" ] || sleep 1
 370
 371         if [ $addr_nr_ns1 -gt 0 ]; then
 372                 let add_nr_ns1=addr_nr_ns1
 373                 counter=2
 374                 while [ $add_nr_ns1 -gt 0 ]; do
 375                         local addr
 376                         if is_v6 "${connect_addr}"; then
 377                                 addr="dead:beef:$counter::1"
 378                         else
 379                                 addr="10.0.$counter.1"
 380                         fi
 381                         ip netns exec $ns1 ./pm_nl_ctl add $addr flags signal
 382                         let counter+=1
 383                         let add_nr_ns1-=1
 384                 done
 385         elif [ $addr_nr_ns1 -lt 0 ]; then
 386                 let rm_nr_ns1=-addr_nr_ns1
 387                 if [ $rm_nr_ns1 -lt 8 ]; then
 388                         counter=1
 389                         pos=1
 390                         dump=(`ip netns exec ${listener_ns} ./pm_nl_ctl dump`)
 391                         if [ ${#dump[@]} -gt 0 ]; then
 392                                 while [ $counter -le $rm_nr_ns1 ]
 393                                 do
 394                                         id=${dump[$pos]}
 395                                         rm_addr=$(rm_addr_count ${connector_ns})
 396                                         ip netns exec ${listener_ns} ./pm_nl_ctl del $id
 397                                         wait_rm_addr ${connector_ns} ${rm_addr}
 398                                         let counter+=1
 399                                         let pos+=5
 400                                 done
 401                         fi
 402                 elif [ $rm_nr_ns1 -eq 8 ]; then
 403                         ip netns exec ${listener_ns} ./pm_nl_ctl flush
 404                 elif [ $rm_nr_ns1 -eq 9 ]; then
 405                         ip netns exec ${listener_ns} ./pm_nl_ctl del 0 ${connect_addr}
 406                 fi
 407         fi
 408
 409         flags="subflow"
 410         if [[ "${addr_nr_ns2}" = "fullmesh_"* ]]; then
 411                 flags="${flags},fullmesh"
 412                 addr_nr_ns2=${addr_nr_ns2:9}
 413         fi
 414
 415         # if newly added endpoints must be deleted, give the background msk
 416         # some time to created them
 417         [ $addr_nr_ns1 -gt 0 -a $addr_nr_ns2 -lt 0 ] && sleep 1
 418
 419         if [ $addr_nr_ns2 -gt 0 ]; then
 420                 let add_nr_ns2=addr_nr_ns2
 421                 counter=3
 422                 while [ $add_nr_ns2 -gt 0 ]; do
 423                         local addr
 424                         if is_v6 "${connect_addr}"; then
 425                                 addr="dead:beef:$counter::2"
 426                         else
 427                                 addr="10.0.$counter.2"
 428                         fi
 429                         ip netns exec $ns2 ./pm_nl_ctl add $addr flags $flags
 430                         let counter+=1
 431                         let add_nr_ns2-=1
 432                 done
 433         elif [ $addr_nr_ns2 -lt 0 ]; then
 434                 let rm_nr_ns2=-addr_nr_ns2
 435                 if [ $rm_nr_ns2 -lt 8 ]; then
 436                         counter=1
 437                         pos=1
 438                         dump=(`ip netns exec ${connector_ns} ./pm_nl_ctl dump`)
 439                         if [ ${#dump[@]} -gt 0 ]; then
 440                                 while [ $counter -le $rm_nr_ns2 ]
 441                                 do
 442                                         # rm_addr are serialized, allow the previous one to complete
 443                                         id=${dump[$pos]}
 444                                         rm_addr=$(rm_addr_count ${listener_ns})
 445                                         ip netns exec ${connector_ns} ./pm_nl_ctl del $id
 446                                         wait_rm_addr ${listener_ns} ${rm_addr}
 447                                         let counter+=1
 448                                         let pos+=5
 449                                 done
 450                         fi
 451                 elif [ $rm_nr_ns2 -eq 8 ]; then
 452                         ip netns exec ${connector_ns} ./pm_nl_ctl flush
 453                 elif [ $rm_nr_ns2 -eq 9 ]; then
 454                         local addr
 455                         if is_v6 "${connect_addr}"; then
 456                                 addr="dead:beef:1::2"
 457                         else
 458                                 addr="10.0.1.2"
 459                         fi
 460                         ip netns exec ${connector_ns} ./pm_nl_ctl del 0 $addr
 461                 fi
 462         fi
 463
 464         if [ ! -z $bkup ]; then
 465                 sleep 1
 466                 for netns in "$ns1" "$ns2"; do
 467                         dump=(`ip netns exec $netns ./pm_nl_ctl dump`)
 468                         if [ ${#dump[@]} -gt 0 ]; then
 469                                 addr=${dump[${#dump[@]} - 1]}
 470                                 backup="ip netns exec $netns ./pm_nl_ctl set $addr flags $bkup"
 471                                 $backup
 472                         fi
 473                 done
 474         fi
 475
 476         wait $cpid
 477         retc=$?
 478         wait $spid
 479         rets=$?
 480
 481         if [ $capture -eq 1 ]; then
 482             sleep 1
 483             kill $cappid
 484         fi
 485
 486         NSTAT_HISTORY=/tmp/${listener_ns}.nstat ip netns exec ${listener_ns} \
 487                 nstat | grep Tcp > /tmp/${listener_ns}.out
 488         NSTAT_HISTORY=/tmp/${connector_ns}.nstat ip netns exec ${connector_ns} \
 489                 nstat | grep Tcp > /tmp/${connector_ns}.out
 490
 491         if [ ${rets} -ne 0 ] || [ ${retc} -ne 0 ]; then
 492                 echo " client exit code $retc, server $rets" 1>&2
 493                 echo -e "\nnetns ${listener_ns} socket stat for ${port}:" 1>&2
 494                 ip netns exec ${listener_ns} ss -Menita 1>&2 -o "sport = :$port"
 495                 cat /tmp/${listener_ns}.out
 496                 echo -e "\nnetns ${connector_ns} socket stat for ${port}:" 1>&2
 497                 ip netns exec ${connector_ns} ss -Menita 1>&2 -o "dport = :$port"
 498                 cat /tmp/${connector_ns}.out
 499
 500                 cat "$capout"
 501                 ret=1
 502                 return 1
 503         fi
 504
 505         if [ "$test_link_fail" -eq 2 ];then
 506                 check_transfer $sinfail $cout "file received by client"
 507         else
 508                 check_transfer $sin $cout "file received by client"
 509         fi
 510         retc=$?
 511         if [ "$test_link_fail" -eq 0 ];then
 512                 check_transfer $cin $sout "file received by server"
 513         else
 514                 check_transfer $cinsent $sout "file received by server"
 515         fi
 516         rets=$?
 517
 518         if [ $retc -eq 0 ] && [ $rets -eq 0 ];then
 519                 cat "$capout"
 520                 return 0
 521         fi
 522
 523         cat "$capout"
 524         return 1
 525 }
 526
 527 make_file()
 528 {
 529         name=$1
 530         who=$2
 531         size=$3
 532
 533         dd if=/dev/urandom of="$name" bs=1024 count=$size 2> /dev/null
 534         echo -e "\nMPTCP_TEST_FILE_END_MARKER" >> "$name"
 535
 536         echo "Created $name (size $size KB) containing data sent by $who"
 537 }
 538
 539 run_tests()
 540 {
 541         listener_ns="$1"
 542         connector_ns="$2"
 543         connect_addr="$3"
 544         test_linkfail="${4:-0}"
 545         addr_nr_ns1="${5:-0}"
 546         addr_nr_ns2="${6:-0}"
 547         speed="${7:-fast}"
 548         bkup="${8:-""}"
 549         lret=0
 550         oldin=""
 551
 552         # create the input file for the failure test when
 553         # the first failure test run
 554         if [ "$test_linkfail" -ne 0 -a -z "$cinfail" ]; then
 555                 # the client file must be considerably larger
 556                 # of the maximum expected cwin value, or the
 557                 # link utilization will be not predicable
 558                 size=$((RANDOM%2))
 559                 size=$((size+1))
 560                 size=$((size*8192))
 561                 size=$((size + ( $RANDOM % 8192) ))
 562
 563                 cinfail=$(mktemp)
 564                 make_file "$cinfail" "client" $size
 565         fi
 566
 567         if [ "$test_linkfail" -eq 2 -a -z "$sinfail" ]; then
 568                 size=$((RANDOM%16))
 569                 size=$((size+1))
 570                 size=$((size*2048))
 571
 572                 sinfail=$(mktemp)
 573                 make_file "$sinfail" "server" $size
 574         fi
 575
 576         do_transfer ${listener_ns} ${connector_ns} MPTCP MPTCP ${connect_addr} \
 577                 ${test_linkfail} ${addr_nr_ns1} ${addr_nr_ns2} ${speed} ${bkup}
 578         lret=$?
 579 }
 580
 581 dump_stats()
 582 {
 583         echo Server ns stats
 584         ip netns exec $ns1 nstat -as | grep Tcp
 585         echo Client ns stats
 586         ip netns exec $ns2 nstat -as | grep Tcp
 587 }
 588
 589 chk_csum_nr()
 590 {
 591         local msg=${1:-""}
 592         local count
 593         local dump_stats
 594
 595         if [ ! -z "$msg" ]; then
 596                 printf "%02u" "$TEST_COUNT"
 597         else
 598                 echo -n "  "
 599         fi
 600         printf " %-36s %s" "$msg" "sum"
 601         count=`ip netns exec $ns1 nstat -as | grep MPTcpExtDataCsumErr | awk '{print $2}'`
 602         [ -z "$count" ] && count=0
 603         if [ "$count" != 0 ]; then
 604                 echo "[fail] got $count data checksum error[s] expected 0"
 605                 ret=1
 606                 dump_stats=1
 607         else
 608                 echo -n "[ ok ]"
 609         fi
 610         echo -n " - csum  "
 611         count=`ip netns exec $ns2 nstat -as | grep MPTcpExtDataCsumErr | awk '{print $2}'`
 612         [ -z "$count" ] && count=0
 613         if [ "$count" != 0 ]; then
 614                 echo "[fail] got $count data checksum error[s] expected 0"
 615                 ret=1
 616                 dump_stats=1
 617         else
 618                 echo "[ ok ]"
 619         fi
 620         [ "${dump_stats}" = 1 ] && dump_stats
 621 }
 622
 623 chk_fail_nr()
 624 {
 625         local mp_fail_nr_tx=$1
 626         local mp_fail_nr_rx=$2
 627         local count
 628         local dump_stats
 629
 630         printf "%-39s %s" " " "ftx"
 631         count=`ip netns exec $ns1 nstat -as | grep MPTcpExtMPFailTx | awk '{print $2}'`
 632         [ -z "$count" ] && count=0
 633         if [ "$count" != "$mp_fail_nr_tx" ]; then
 634                 echo "[fail] got $count MP_FAIL[s] TX expected $mp_fail_nr_tx"
 635                 ret=1
 636                 dump_stats=1
 637         else
 638                 echo -n "[ ok ]"
 639         fi
 640
 641         echo -n " - frx   "
 642         count=`ip netns exec $ns2 nstat -as | grep MPTcpExtMPFailRx | awk '{print $2}'`
 643         [ -z "$count" ] && count=0
 644         if [ "$count" != "$mp_fail_nr_rx" ]; then
 645                 echo "[fail] got $count MP_FAIL[s] RX expected $mp_fail_nr_rx"
 646                 ret=1
 647                 dump_stats=1
 648         else
 649                 echo "[ ok ]"
 650         fi
 651
 652         [ "${dump_stats}" = 1 ] && dump_stats
 653 }
 654
 655 chk_join_nr()
 656 {
 657         local msg="$1"
 658         local syn_nr=$2
 659         local syn_ack_nr=$3
 660         local ack_nr=$4
 661         local count
 662         local dump_stats
 663
 664         printf "%02u %-36s %s" "$TEST_COUNT" "$msg" "syn"
 665         count=`ip netns exec $ns1 nstat -as | grep MPTcpExtMPJoinSynRx | awk '{print $2}'`
 666         [ -z "$count" ] && count=0
 667         if [ "$count" != "$syn_nr" ]; then
 668                 echo "[fail] got $count JOIN[s] syn expected $syn_nr"
 669                 ret=1
 670                 dump_stats=1
 671         else
 672                 echo -n "[ ok ]"
 673         fi
 674
 675         echo -n " - synack"
 676         count=`ip netns exec $ns2 nstat -as | grep MPTcpExtMPJoinSynAckRx | awk '{print $2}'`
 677         [ -z "$count" ] && count=0
 678         if [ "$count" != "$syn_ack_nr" ]; then
 679                 echo "[fail] got $count JOIN[s] synack expected $syn_ack_nr"
 680                 ret=1
 681                 dump_stats=1
 682         else
 683                 echo -n "[ ok ]"
 684         fi
 685
 686         echo -n " - ack"
 687         count=`ip netns exec $ns1 nstat -as | grep MPTcpExtMPJoinAckRx | awk '{print $2}'`
 688         [ -z "$count" ] && count=0
 689         if [ "$count" != "$ack_nr" ]; then
 690                 echo "[fail] got $count JOIN[s] ack expected $ack_nr"
 691                 ret=1
 692                 dump_stats=1
 693         else
 694                 echo "[ ok ]"
 695         fi
 696         [ "${dump_stats}" = 1 ] && dump_stats
 697         if [ $checksum -eq 1 ]; then
 698                 chk_csum_nr
 699                 chk_fail_nr 0 0
 700         fi
 701 }
 702
 703 # a negative value for 'stale_max' means no upper bound:
 704 # for bidirectional transfer, if one peer sleep for a while
 705 # - as these tests do - we can have a quite high number of
 706 # stale/recover conversions, proportional to
 707 # sleep duration/ MPTCP-level RTX interval.
 708 chk_stale_nr()
 709 {
 710         local ns=$1
 711         local stale_min=$2
 712         local stale_max=$3
 713         local stale_delta=$4
 714         local dump_stats
 715         local stale_nr
 716         local recover_nr
 717
 718         printf "%-39s %-18s" " " "stale"
 719         stale_nr=`ip netns exec $ns nstat -as | grep MPTcpExtSubflowStale | awk '{print $2}'`
 720         [ -z "$stale_nr" ] && stale_nr=0
 721         recover_nr=`ip netns exec $ns nstat -as | grep MPTcpExtSubflowRecover | awk '{print $2}'`
 722         [ -z "$recover_nr" ] && recover_nr=0
 723
 724         if [ $stale_nr -lt $stale_min ] ||
 725            [ $stale_max -gt 0 -a $stale_nr -gt $stale_max ] ||
 726            [ $((stale_nr - $recover_nr)) -ne $stale_delta ]; then
 727                 echo "[fail] got $stale_nr stale[s] $recover_nr recover[s], " \
 728                      " expected stale in range [$stale_min..$stale_max]," \
 729                      " stale-recover delta $stale_delta "
 730                 ret=1
 731                 dump_stats=1
 732         else
 733                 echo "[ ok ]"
 734         fi
 735
 736         if [ "${dump_stats}" = 1 ]; then
 737                 echo $ns stats
 738                 ip netns exec $ns ip -s link show
 739                 ip netns exec $ns nstat -as | grep MPTcp
 740         fi
 741 }
 742
 743 chk_add_nr()
 744 {
 745         local add_nr=$1
 746         local echo_nr=$2
 747         local port_nr=${3:-0}
 748         local syn_nr=${4:-$port_nr}
 749         local syn_ack_nr=${5:-$port_nr}
 750         local ack_nr=${6:-$port_nr}
 751         local mis_syn_nr=${7:-0}
 752         local mis_ack_nr=${8:-0}
 753         local count
 754         local dump_stats
 755         local timeout
 756
 757         timeout=`ip netns exec $ns1 sysctl -n net.mptcp.add_addr_timeout`
 758
 759         printf "%-39s %s" " " "add"
 760         count=`ip netns exec $ns2 nstat -as MPTcpExtAddAddr | grep MPTcpExtAddAddr | awk '{print $2}'`
 761         [ -z "$count" ] && count=0
 762
 763         # if the test configured a short timeout tolerate greater then expected
 764         # add addrs options, due to retransmissions
 765         if [ "$count" != "$add_nr" ] && [ "$timeout" -gt 1 -o "$count" -lt "$add_nr" ]; then
 766                 echo "[fail] got $count ADD_ADDR[s] expected $add_nr"
 767                 ret=1
 768                 dump_stats=1
 769         else
 770                 echo -n "[ ok ]"
 771         fi
 772
 773         echo -n " - echo  "
 774         count=`ip netns exec $ns1 nstat -as | grep MPTcpExtEchoAdd | awk '{print $2}'`
 775         [ -z "$count" ] && count=0
 776         if [ "$count" != "$echo_nr" ]; then
 777                 echo "[fail] got $count ADD_ADDR echo[s] expected $echo_nr"
 778                 ret=1
 779                 dump_stats=1
 780         else
 781                 echo -n "[ ok ]"
 782         fi
 783
 784         if [ $port_nr -gt 0 ]; then
 785                 echo -n " - pt "
 786                 count=`ip netns exec $ns2 nstat -as | grep MPTcpExtPortAdd | awk '{print $2}'`
 787                 [ -z "$count" ] && count=0
 788                 if [ "$count" != "$port_nr" ]; then
 789                         echo "[fail] got $count ADD_ADDR[s] with a port-number expected $port_nr"
 790                         ret=1
 791                         dump_stats=1
 792                 else
 793                         echo "[ ok ]"
 794                 fi
 795
 796                 printf "%-39s %s" " " "syn"
 797                 count=`ip netns exec $ns1 nstat -as | grep MPTcpExtMPJoinPortSynRx |
 798                         awk '{print $2}'`
 799                 [ -z "$count" ] && count=0
 800                 if [ "$count" != "$syn_nr" ]; then
 801                         echo "[fail] got $count JOIN[s] syn with a different \
 802                                 port-number expected $syn_nr"
 803                         ret=1
 804                         dump_stats=1
 805                 else
 806                         echo -n "[ ok ]"
 807                 fi
 808
 809                 echo -n " - synack"
 810                 count=`ip netns exec $ns2 nstat -as | grep MPTcpExtMPJoinPortSynAckRx |
 811                         awk '{print $2}'`
 812                 [ -z "$count" ] && count=0
 813                 if [ "$count" != "$syn_ack_nr" ]; then
 814                         echo "[fail] got $count JOIN[s] synack with a different \
 815                                 port-number expected $syn_ack_nr"
 816                         ret=1
 817                         dump_stats=1
 818                 else
 819                         echo -n "[ ok ]"
 820                 fi
 821
 822                 echo -n " - ack"
 823                 count=`ip netns exec $ns1 nstat -as | grep MPTcpExtMPJoinPortAckRx |
 824                         awk '{print $2}'`
 825                 [ -z "$count" ] && count=0
 826                 if [ "$count" != "$ack_nr" ]; then
 827                         echo "[fail] got $count JOIN[s] ack with a different \
 828                                 port-number expected $ack_nr"
 829                         ret=1
 830                         dump_stats=1
 831                 else
 832                         echo "[ ok ]"
 833                 fi
 834
 835                 printf "%-39s %s" " " "syn"
 836                 count=`ip netns exec $ns1 nstat -as | grep MPTcpExtMismatchPortSynRx |
 837                         awk '{print $2}'`
 838                 [ -z "$count" ] && count=0
 839                 if [ "$count" != "$mis_syn_nr" ]; then
 840                         echo "[fail] got $count JOIN[s] syn with a mismatched \
 841                                 port-number expected $mis_syn_nr"
 842                         ret=1
 843                         dump_stats=1
 844                 else
 845                         echo -n "[ ok ]"
 846                 fi
 847
 848                 echo -n " - ack   "
 849                 count=`ip netns exec $ns1 nstat -as | grep MPTcpExtMismatchPortAckRx |
 850                         awk '{print $2}'`
 851                 [ -z "$count" ] && count=0
 852                 if [ "$count" != "$mis_ack_nr" ]; then
 853                         echo "[fail] got $count JOIN[s] ack with a mismatched \
 854                                 port-number expected $mis_ack_nr"
 855                         ret=1
 856                         dump_stats=1
 857                 else
 858                         echo "[ ok ]"
 859                 fi
 860         else
 861                 echo ""
 862         fi
 863
 864         [ "${dump_stats}" = 1 ] && dump_stats
 865 }
 866
 867 chk_rm_nr()
 868 {
 869         local rm_addr_nr=$1
 870         local rm_subflow_nr=$2
 871         local invert=${3:-""}
 872         local count
 873         local dump_stats
 874         local addr_ns
 875         local subflow_ns
 876
 877         if [ -z $invert ]; then
 878                 addr_ns=$ns1
 879                 subflow_ns=$ns2
 880         elif [ $invert = "invert" ]; then
 881                 addr_ns=$ns2
 882                 subflow_ns=$ns1
 883         fi
 884
 885         printf "%-39s %s" " " "rm "
 886         count=`ip netns exec $addr_ns nstat -as | grep MPTcpExtRmAddr | awk '{print $2}'`
 887         [ -z "$count" ] && count=0
 888         if [ "$count" != "$rm_addr_nr" ]; then
 889                 echo "[fail] got $count RM_ADDR[s] expected $rm_addr_nr"
 890                 ret=1
 891                 dump_stats=1
 892         else
 893                 echo -n "[ ok ]"
 894         fi
 895
 896         echo -n " - sf    "
 897         count=`ip netns exec $subflow_ns nstat -as | grep MPTcpExtRmSubflow | awk '{print $2}'`
 898         [ -z "$count" ] && count=0
 899         if [ "$count" != "$rm_subflow_nr" ]; then
 900                 echo "[fail] got $count RM_SUBFLOW[s] expected $rm_subflow_nr"
 901                 ret=1
 902                 dump_stats=1
 903         else
 904                 echo "[ ok ]"
 905         fi
 906
 907         [ "${dump_stats}" = 1 ] && dump_stats
 908 }
 909
 910 chk_prio_nr()
 911 {
 912         local mp_prio_nr_tx=$1
 913         local mp_prio_nr_rx=$2
 914         local count
 915         local dump_stats
 916
 917         printf "%-39s %s" " " "ptx"
 918         count=`ip netns exec $ns1 nstat -as | grep MPTcpExtMPPrioTx | awk '{print $2}'`
 919         [ -z "$count" ] && count=0
 920         if [ "$count" != "$mp_prio_nr_tx" ]; then
 921                 echo "[fail] got $count MP_PRIO[s] TX expected $mp_prio_nr_tx"
 922                 ret=1
 923                 dump_stats=1
 924         else
 925                 echo -n "[ ok ]"
 926         fi
 927
 928         echo -n " - prx   "
 929         count=`ip netns exec $ns1 nstat -as | grep MPTcpExtMPPrioRx | awk '{print $2}'`
 930         [ -z "$count" ] && count=0
 931         if [ "$count" != "$mp_prio_nr_rx" ]; then
 932                 echo "[fail] got $count MP_PRIO[s] RX expected $mp_prio_nr_rx"
 933                 ret=1
 934                 dump_stats=1
 935         else
 936                 echo "[ ok ]"
 937         fi
 938
 939         [ "${dump_stats}" = 1 ] && dump_stats
 940 }
 941
 942 chk_link_usage()
 943 {
 944         local ns=$1
 945         local link=$2
 946         local out=$3
 947         local expected_rate=$4
 948         local tx_link=`ip netns exec $ns cat /sys/class/net/$link/statistics/tx_bytes`
 949         local tx_total=`ls -l $out | awk '{print $5}'`
 950         local tx_rate=$((tx_link * 100 / $tx_total))
 951         local tolerance=5
 952
 953         printf "%-39s %-18s" " " "link usage"
 954         if [ $tx_rate -lt $((expected_rate - $tolerance)) -o \
 955              $tx_rate -gt $((expected_rate + $tolerance)) ]; then
 956                 echo "[fail] got $tx_rate% usage, expected $expected_rate%"
 957                 ret=1
 958         else
 959                 echo "[ ok ]"
 960         fi
 961 }
 962
 963 wait_for_tw()
 964 {
 965         local timeout_ms=$((timeout_poll * 1000))
 966         local time=0
 967         local ns=$1
 968
 969         while [ $time -lt $timeout_ms ]; do
 970                 local cnt=$(ip netns exec $ns nstat -as TcpAttemptFails | grep TcpAttemptFails | awk '{print $2}')
 971
 972                 [ "$cnt" = 1 ] && return 1
 973                 time=$((time + 100))
 974                 sleep 0.1
 975         done
 976         return 1
 977 }
 978
 979 subflows_tests()
 980 {
 981         reset
 982         run_tests $ns1 $ns2 10.0.1.1
 983         chk_join_nr "no JOIN" "0" "0" "0"
 984
 985         # subflow limited by client
 986         reset
 987         ip netns exec $ns1 ./pm_nl_ctl limits 0 0
 988         ip netns exec $ns2 ./pm_nl_ctl limits 0 0
 989         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 flags subflow
 990         run_tests $ns1 $ns2 10.0.1.1
 991         chk_join_nr "single subflow, limited by client" 0 0 0
 992
 993         # subflow limited by server
 994         reset
 995         ip netns exec $ns1 ./pm_nl_ctl limits 0 0
 996         ip netns exec $ns2 ./pm_nl_ctl limits 0 1
 997         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 flags subflow
 998         run_tests $ns1 $ns2 10.0.1.1
 999         chk_join_nr "single subflow, limited by server" 1 1 0
1000
1001         # subflow
1002         reset
1003         ip netns exec $ns1 ./pm_nl_ctl limits 0 1
1004         ip netns exec $ns2 ./pm_nl_ctl limits 0 1
1005         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 flags subflow
1006         run_tests $ns1 $ns2 10.0.1.1
1007         chk_join_nr "single subflow" 1 1 1
1008
1009         # multiple subflows
1010         reset
1011         ip netns exec $ns1 ./pm_nl_ctl limits 0 2
1012         ip netns exec $ns2 ./pm_nl_ctl limits 0 2
1013         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 flags subflow
1014         ip netns exec $ns2 ./pm_nl_ctl add 10.0.2.2 flags subflow
1015         run_tests $ns1 $ns2 10.0.1.1
1016         chk_join_nr "multiple subflows" 2 2 2
1017
1018         # multiple subflows limited by server
1019         reset
1020         ip netns exec $ns1 ./pm_nl_ctl limits 0 1
1021         ip netns exec $ns2 ./pm_nl_ctl limits 0 2
1022         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 flags subflow
1023         ip netns exec $ns2 ./pm_nl_ctl add 10.0.2.2 flags subflow
1024         run_tests $ns1 $ns2 10.0.1.1
1025         chk_join_nr "multiple subflows, limited by server" 2 2 1
1026
1027         # single subflow, dev
1028         reset
1029         ip netns exec $ns1 ./pm_nl_ctl limits 0 1
1030         ip netns exec $ns2 ./pm_nl_ctl limits 0 1
1031         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 flags subflow dev ns2eth3
1032         run_tests $ns1 $ns2 10.0.1.1
1033         chk_join_nr "single subflow, dev" 1 1 1
1034 }
1035
1036 subflows_error_tests()
1037 {
1038         # If a single subflow is configured, and matches the MPC src
1039         # address, no additional subflow should be created
1040         reset
1041         ip netns exec $ns1 ./pm_nl_ctl limits 0 1
1042         ip netns exec $ns2 ./pm_nl_ctl limits 0 1
1043         ip netns exec $ns2 ./pm_nl_ctl add 10.0.1.2 flags subflow
1044         run_tests $ns1 $ns2 10.0.1.1 0 0 0 slow
1045         chk_join_nr "no MPC reuse with single endpoint" 0 0 0
1046
1047         # multiple subflows, with subflow creation error
1048         reset
1049         ip netns exec $ns1 ./pm_nl_ctl limits 0 2
1050         ip netns exec $ns2 ./pm_nl_ctl limits 0 2
1051         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 flags subflow
1052         ip netns exec $ns2 ./pm_nl_ctl add 10.0.2.2 flags subflow
1053         ip netns exec $ns1 iptables -A INPUT -s 10.0.3.2 -p tcp -j REJECT
1054         run_tests $ns1 $ns2 10.0.1.1 0 0 0 slow
1055         chk_join_nr "multi subflows, with failing subflow" 1 1 1
1056
1057         # multiple subflows, with subflow timeout on MPJ
1058         reset
1059         ip netns exec $ns1 ./pm_nl_ctl limits 0 2
1060         ip netns exec $ns2 ./pm_nl_ctl limits 0 2
1061         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 flags subflow
1062         ip netns exec $ns2 ./pm_nl_ctl add 10.0.2.2 flags subflow
1063         ip netns exec $ns1 iptables -A INPUT -s 10.0.3.2 -p tcp -j DROP
1064         run_tests $ns1 $ns2 10.0.1.1 0 0 0 slow
1065         chk_join_nr "multi subflows, with subflow timeout" 1 1 1
1066
1067         # multiple subflows, check that the endpoint corresponding to
1068         # closed subflow (due to reset) is not reused if additional
1069         # subflows are added later
1070         reset
1071         ip netns exec $ns1 ./pm_nl_ctl limits 0 1
1072         ip netns exec $ns2 ./pm_nl_ctl limits 0 1
1073         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 flags subflow
1074         ip netns exec $ns1 iptables -A INPUT -s 10.0.3.2 -p tcp -j REJECT
1075         run_tests $ns1 $ns2 10.0.1.1 0 0 0 slow &
1076
1077         # updates in the child shell do not have any effect here, we
1078         # need to bump the test counter for the above case
1079         TEST_COUNT=$((TEST_COUNT+1))
1080
1081         # mpj subflow will be in TW after the reset
1082         wait_for_tw $ns2
1083         ip netns exec $ns2 ./pm_nl_ctl add 10.0.2.2 flags subflow
1084         wait
1085
1086         # additional subflow could be created only if the PM select
1087         # the later endpoint, skipping the already used one
1088         chk_join_nr "multi subflows, fair usage on close" 1 1 1
1089 }
1090
1091 signal_address_tests()
1092 {
1093         # add_address, unused
1094         reset
1095         ip netns exec $ns1 ./pm_nl_ctl add 10.0.2.1 flags signal
1096         run_tests $ns1 $ns2 10.0.1.1
1097         chk_join_nr "unused signal address" 0 0 0
1098         chk_add_nr 1 1
1099
1100         # accept and use add_addr
1101         reset
1102         ip netns exec $ns1 ./pm_nl_ctl limits 0 1
1103         ip netns exec $ns2 ./pm_nl_ctl limits 1 1
1104         ip netns exec $ns1 ./pm_nl_ctl add 10.0.2.1 flags signal
1105         run_tests $ns1 $ns2 10.0.1.1
1106         chk_join_nr "signal address" 1 1 1
1107         chk_add_nr 1 1
1108
1109         # accept and use add_addr with an additional subflow
1110         # note: signal address in server ns and local addresses in client ns must
1111         # belong to different subnets or one of the listed local address could be
1112         # used for 'add_addr' subflow
1113         reset
1114         ip netns exec $ns1 ./pm_nl_ctl add 10.0.2.1 flags signal
1115         ip netns exec $ns1 ./pm_nl_ctl limits 0 2
1116         ip netns exec $ns2 ./pm_nl_ctl limits 1 2
1117         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 flags subflow
1118         run_tests $ns1 $ns2 10.0.1.1
1119         chk_join_nr "subflow and signal" 2 2 2
1120         chk_add_nr 1 1
1121
1122         # accept and use add_addr with additional subflows
1123         reset
1124         ip netns exec $ns1 ./pm_nl_ctl limits 0 3
1125         ip netns exec $ns1 ./pm_nl_ctl add 10.0.2.1 flags signal
1126         ip netns exec $ns2 ./pm_nl_ctl limits 1 3
1127         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 flags subflow
1128         ip netns exec $ns2 ./pm_nl_ctl add 10.0.4.2 flags subflow
1129         run_tests $ns1 $ns2 10.0.1.1
1130         chk_join_nr "multiple subflows and signal" 3 3 3
1131         chk_add_nr 1 1
1132
1133         # signal addresses
1134         reset
1135         ip netns exec $ns1 ./pm_nl_ctl limits 3 3
1136         ip netns exec $ns1 ./pm_nl_ctl add 10.0.2.1 flags signal
1137         ip netns exec $ns1 ./pm_nl_ctl add 10.0.3.1 flags signal
1138         ip netns exec $ns1 ./pm_nl_ctl add 10.0.4.1 flags signal
1139         ip netns exec $ns2 ./pm_nl_ctl limits 3 3
1140         run_tests $ns1 $ns2 10.0.1.1
1141         chk_join_nr "signal addresses" 3 3 3
1142         chk_add_nr 3 3
1143
1144         # signal invalid addresses
1145         reset
1146         ip netns exec $ns1 ./pm_nl_ctl limits 3 3
1147         ip netns exec $ns1 ./pm_nl_ctl add 10.0.12.1 flags signal
1148         ip netns exec $ns1 ./pm_nl_ctl add 10.0.3.1 flags signal
1149         ip netns exec $ns1 ./pm_nl_ctl add 10.0.14.1 flags signal
1150         ip netns exec $ns2 ./pm_nl_ctl limits 3 3
1151         run_tests $ns1 $ns2 10.0.1.1
1152         chk_join_nr "signal invalid addresses" 1 1 1
1153         chk_add_nr 3 3
1154
1155         # signal addresses race test
1156         reset
1157         ip netns exec $ns1 ./pm_nl_ctl limits 4 4
1158         ip netns exec $ns2 ./pm_nl_ctl limits 4 4
1159         ip netns exec $ns1 ./pm_nl_ctl add 10.0.1.1 flags signal
1160         ip netns exec $ns1 ./pm_nl_ctl add 10.0.2.1 flags signal
1161         ip netns exec $ns1 ./pm_nl_ctl add 10.0.3.1 flags signal
1162         ip netns exec $ns1 ./pm_nl_ctl add 10.0.4.1 flags signal
1163         ip netns exec $ns2 ./pm_nl_ctl add 10.0.1.2 flags signal
1164         ip netns exec $ns2 ./pm_nl_ctl add 10.0.2.2 flags signal
1165         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 flags signal
1166         ip netns exec $ns2 ./pm_nl_ctl add 10.0.4.2 flags signal
1167
1168         # the peer could possibly miss some addr notification, allow retransmission
1169         ip netns exec $ns1 sysctl -q net.mptcp.add_addr_timeout=1
1170         run_tests $ns1 $ns2 10.0.1.1 0 0 0 slow
1171         chk_join_nr "signal addresses race test" 3 3 3
1172
1173         # the server will not signal the address terminating
1174         # the MPC subflow
1175         chk_add_nr 3 3
1176 }
1177
1178 link_failure_tests()
1179 {
1180         # accept and use add_addr with additional subflows and link loss
1181         reset
1182
1183         # without any b/w limit each veth could spool the packets and get
1184         # them acked at xmit time, so that the corresponding subflow will
1185         # have almost always no outstanding pkts, the scheduler will pick
1186         # always the first subflow and we will have hard time testing
1187         # active backup and link switch-over.
1188         # Let's set some arbitrary (low) virtual link limits.
1189         init_shapers
1190         ip netns exec $ns1 ./pm_nl_ctl limits 0 3
1191         ip netns exec $ns1 ./pm_nl_ctl add 10.0.2.1 dev ns1eth2 flags signal
1192         ip netns exec $ns2 ./pm_nl_ctl limits 1 3
1193         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 dev ns2eth3 flags subflow
1194         ip netns exec $ns2 ./pm_nl_ctl add 10.0.4.2 dev ns2eth4 flags subflow
1195         run_tests $ns1 $ns2 10.0.1.1 1
1196         chk_join_nr "multiple flows, signal, link failure" 3 3 3
1197         chk_add_nr 1 1
1198         chk_stale_nr $ns2 1 5 1
1199
1200         # accept and use add_addr with additional subflows and link loss
1201         # for bidirectional transfer
1202         reset
1203         init_shapers
1204         ip netns exec $ns1 ./pm_nl_ctl limits 0 3
1205         ip netns exec $ns1 ./pm_nl_ctl add 10.0.2.1 dev ns1eth2 flags signal
1206         ip netns exec $ns2 ./pm_nl_ctl limits 1 3
1207         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 dev ns2eth3 flags subflow
1208         ip netns exec $ns2 ./pm_nl_ctl add 10.0.4.2 dev ns2eth4 flags subflow
1209         run_tests $ns1 $ns2 10.0.1.1 2
1210         chk_join_nr "multi flows, signal, bidi, link fail" 3 3 3
1211         chk_add_nr 1 1
1212         chk_stale_nr $ns2 1 -1 1
1213
1214         # 2 subflows plus 1 backup subflow with a lossy link, backup
1215         # will never be used
1216         reset
1217         init_shapers
1218         ip netns exec $ns1 ./pm_nl_ctl limits 0 2
1219         ip netns exec $ns1 ./pm_nl_ctl add 10.0.2.1 dev ns1eth2 flags signal
1220         ip netns exec $ns2 ./pm_nl_ctl limits 1 2
1221         export FAILING_LINKS="1"
1222         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 dev ns2eth3 flags subflow,backup
1223         run_tests $ns1 $ns2 10.0.1.1 1
1224         chk_join_nr "backup subflow unused, link failure" 2 2 2
1225         chk_add_nr 1 1
1226         chk_link_usage $ns2 ns2eth3 $cinsent 0
1227
1228         # 2 lossy links after half transfer, backup will get half of
1229         # the traffic
1230         reset
1231         init_shapers
1232         ip netns exec $ns1 ./pm_nl_ctl limits 0 2
1233         ip netns exec $ns1 ./pm_nl_ctl add 10.0.2.1 dev ns1eth2 flags signal
1234         ip netns exec $ns2 ./pm_nl_ctl limits 1 2
1235         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 dev ns2eth3 flags subflow,backup
1236         export FAILING_LINKS="1 2"
1237         run_tests $ns1 $ns2 10.0.1.1 1
1238         chk_join_nr "backup flow used, multi links fail" 2 2 2
1239         chk_add_nr 1 1
1240         chk_stale_nr $ns2 2 4 2
1241         chk_link_usage $ns2 ns2eth3 $cinsent 50
1242
1243         # use a backup subflow with the first subflow on a lossy link
1244         # for bidirectional transfer
1245         reset
1246         init_shapers
1247         ip netns exec $ns1 ./pm_nl_ctl limits 0 2
1248         ip netns exec $ns1 ./pm_nl_ctl add 10.0.2.1 dev ns1eth2 flags signal
1249         ip netns exec $ns2 ./pm_nl_ctl limits 1 3
1250         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 dev ns2eth3 flags subflow,backup
1251         run_tests $ns1 $ns2 10.0.1.1 2
1252         chk_join_nr "backup flow used, bidi, link failure" 2 2 2
1253         chk_add_nr 1 1
1254         chk_stale_nr $ns2 1 -1 2
1255         chk_link_usage $ns2 ns2eth3 $cinsent 50
1256 }
1257
1258 add_addr_timeout_tests()
1259 {
1260         # add_addr timeout
1261         reset_with_add_addr_timeout
1262         ip netns exec $ns1 ./pm_nl_ctl limits 0 1
1263         ip netns exec $ns2 ./pm_nl_ctl limits 1 1
1264         ip netns exec $ns1 ./pm_nl_ctl add 10.0.2.1 flags signal
1265         run_tests $ns1 $ns2 10.0.1.1 0 0 0 slow
1266         chk_join_nr "signal address, ADD_ADDR timeout" 1 1 1
1267         chk_add_nr 4 0
1268
1269         # add_addr timeout IPv6
1270         reset_with_add_addr_timeout 6
1271         ip netns exec $ns1 ./pm_nl_ctl limits 0 1
1272         ip netns exec $ns2 ./pm_nl_ctl limits 1 1
1273         ip netns exec $ns1 ./pm_nl_ctl add dead:beef:2::1 flags signal
1274         run_tests $ns1 $ns2 dead:beef:1::1 0 0 0 slow
1275         chk_join_nr "signal address, ADD_ADDR6 timeout" 1 1 1
1276         chk_add_nr 4 0
1277
1278         # signal addresses timeout
1279         reset_with_add_addr_timeout
1280         ip netns exec $ns1 ./pm_nl_ctl limits 2 2
1281         ip netns exec $ns1 ./pm_nl_ctl add 10.0.2.1 flags signal
1282         ip netns exec $ns1 ./pm_nl_ctl add 10.0.3.1 flags signal
1283         ip netns exec $ns2 ./pm_nl_ctl limits 2 2
1284         run_tests $ns1 $ns2 10.0.1.1 0 0 0 least
1285         chk_join_nr "signal addresses, ADD_ADDR timeout" 2 2 2
1286         chk_add_nr 8 0
1287
1288         # signal invalid addresses timeout
1289         reset_with_add_addr_timeout
1290         ip netns exec $ns1 ./pm_nl_ctl limits 2 2
1291         ip netns exec $ns1 ./pm_nl_ctl add 10.0.12.1 flags signal
1292         ip netns exec $ns1 ./pm_nl_ctl add 10.0.3.1 flags signal
1293         ip netns exec $ns2 ./pm_nl_ctl limits 2 2
1294         run_tests $ns1 $ns2 10.0.1.1 0 0 0 least
1295         chk_join_nr "invalid address, ADD_ADDR timeout" 1 1 1
1296         chk_add_nr 8 0
1297 }
1298
1299 remove_tests()
1300 {
1301         # single subflow, remove
1302         reset
1303         ip netns exec $ns1 ./pm_nl_ctl limits 0 1
1304         ip netns exec $ns2 ./pm_nl_ctl limits 0 1
1305         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 flags subflow
1306         run_tests $ns1 $ns2 10.0.1.1 0 0 -1 slow
1307         chk_join_nr "remove single subflow" 1 1 1
1308         chk_rm_nr 1 1
1309
1310         # multiple subflows, remove
1311         reset
1312         ip netns exec $ns1 ./pm_nl_ctl limits 0 2
1313         ip netns exec $ns2 ./pm_nl_ctl limits 0 2
1314         ip netns exec $ns2 ./pm_nl_ctl add 10.0.2.2 flags subflow
1315         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 flags subflow
1316         run_tests $ns1 $ns2 10.0.1.1 0 0 -2 slow
1317         chk_join_nr "remove multiple subflows" 2 2 2
1318         chk_rm_nr 2 2
1319
1320         # single address, remove
1321         reset
1322         ip netns exec $ns1 ./pm_nl_ctl limits 0 1
1323         ip netns exec $ns1 ./pm_nl_ctl add 10.0.2.1 flags signal
1324         ip netns exec $ns2 ./pm_nl_ctl limits 1 1
1325         run_tests $ns1 $ns2 10.0.1.1 0 -1 0 slow
1326         chk_join_nr "remove single address" 1 1 1
1327         chk_add_nr 1 1
1328         chk_rm_nr 1 1 invert
1329
1330         # subflow and signal, remove
1331         reset
1332         ip netns exec $ns1 ./pm_nl_ctl limits 0 2
1333         ip netns exec $ns1 ./pm_nl_ctl add 10.0.2.1 flags signal
1334         ip netns exec $ns2 ./pm_nl_ctl limits 1 2
1335         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 flags subflow
1336         run_tests $ns1 $ns2 10.0.1.1 0 -1 -1 slow
1337         chk_join_nr "remove subflow and signal" 2 2 2
1338         chk_add_nr 1 1
1339         chk_rm_nr 1 1
1340
1341         # subflows and signal, remove
1342         reset
1343         ip netns exec $ns1 ./pm_nl_ctl limits 0 3
1344         ip netns exec $ns1 ./pm_nl_ctl add 10.0.2.1 flags signal
1345         ip netns exec $ns2 ./pm_nl_ctl limits 1 3
1346         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 flags subflow
1347         ip netns exec $ns2 ./pm_nl_ctl add 10.0.4.2 flags subflow
1348         run_tests $ns1 $ns2 10.0.1.1 0 -1 -2 slow
1349         chk_join_nr "remove subflows and signal" 3 3 3
1350         chk_add_nr 1 1
1351         chk_rm_nr 2 2
1352
1353         # addresses remove
1354         reset
1355         ip netns exec $ns1 ./pm_nl_ctl limits 3 3
1356         ip netns exec $ns1 ./pm_nl_ctl add 10.0.2.1 flags signal id 250
1357         ip netns exec $ns1 ./pm_nl_ctl add 10.0.3.1 flags signal
1358         ip netns exec $ns1 ./pm_nl_ctl add 10.0.4.1 flags signal
1359         ip netns exec $ns2 ./pm_nl_ctl limits 3 3
1360         run_tests $ns1 $ns2 10.0.1.1 0 -3 0 slow
1361         chk_join_nr "remove addresses" 3 3 3
1362         chk_add_nr 3 3
1363         chk_rm_nr 3 3 invert
1364
1365         # invalid addresses remove
1366         reset
1367         ip netns exec $ns1 ./pm_nl_ctl limits 3 3
1368         ip netns exec $ns1 ./pm_nl_ctl add 10.0.12.1 flags signal
1369         ip netns exec $ns1 ./pm_nl_ctl add 10.0.3.1 flags signal
1370         ip netns exec $ns1 ./pm_nl_ctl add 10.0.14.1 flags signal
1371         ip netns exec $ns2 ./pm_nl_ctl limits 3 3
1372         run_tests $ns1 $ns2 10.0.1.1 0 -3 0 slow
1373         chk_join_nr "remove invalid addresses" 1 1 1
1374         chk_add_nr 3 3
1375         chk_rm_nr 3 1 invert
1376
1377         # subflows and signal, flush
1378         reset
1379         ip netns exec $ns1 ./pm_nl_ctl limits 0 3
1380         ip netns exec $ns1 ./pm_nl_ctl add 10.0.2.1 flags signal
1381         ip netns exec $ns2 ./pm_nl_ctl limits 1 3
1382         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 flags subflow
1383         ip netns exec $ns2 ./pm_nl_ctl add 10.0.4.2 flags subflow
1384         run_tests $ns1 $ns2 10.0.1.1 0 -8 -8 slow
1385         chk_join_nr "flush subflows and signal" 3 3 3
1386         chk_add_nr 1 1
1387         chk_rm_nr 2 2
1388
1389         # subflows flush
1390         reset
1391         ip netns exec $ns1 ./pm_nl_ctl limits 3 3
1392         ip netns exec $ns2 ./pm_nl_ctl limits 3 3
1393         ip netns exec $ns2 ./pm_nl_ctl add 10.0.2.2 flags subflow id 150
1394         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 flags subflow
1395         ip netns exec $ns2 ./pm_nl_ctl add 10.0.4.2 flags subflow
1396         run_tests $ns1 $ns2 10.0.1.1 0 -8 -8 slow
1397         chk_join_nr "flush subflows" 3 3 3
1398         chk_rm_nr 3 3
1399
1400         # addresses flush
1401         reset
1402         ip netns exec $ns1 ./pm_nl_ctl limits 3 3
1403         ip netns exec $ns1 ./pm_nl_ctl add 10.0.2.1 flags signal id 250
1404         ip netns exec $ns1 ./pm_nl_ctl add 10.0.3.1 flags signal
1405         ip netns exec $ns1 ./pm_nl_ctl add 10.0.4.1 flags signal
1406         ip netns exec $ns2 ./pm_nl_ctl limits 3 3
1407         run_tests $ns1 $ns2 10.0.1.1 0 -8 -8 slow
1408         chk_join_nr "flush addresses" 3 3 3
1409         chk_add_nr 3 3
1410         chk_rm_nr 3 3 invert
1411
1412         # invalid addresses flush
1413         reset
1414         ip netns exec $ns1 ./pm_nl_ctl limits 3 3
1415         ip netns exec $ns1 ./pm_nl_ctl add 10.0.12.1 flags signal
1416         ip netns exec $ns1 ./pm_nl_ctl add 10.0.3.1 flags signal
1417         ip netns exec $ns1 ./pm_nl_ctl add 10.0.14.1 flags signal
1418         ip netns exec $ns2 ./pm_nl_ctl limits 3 3
1419         run_tests $ns1 $ns2 10.0.1.1 0 -8 0 slow
1420         chk_join_nr "flush invalid addresses" 1 1 1
1421         chk_add_nr 3 3
1422         chk_rm_nr 3 1 invert
1423
1424         # remove id 0 subflow
1425         reset
1426         ip netns exec $ns1 ./pm_nl_ctl limits 0 1
1427         ip netns exec $ns2 ./pm_nl_ctl limits 0 1
1428         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 flags subflow
1429         run_tests $ns1 $ns2 10.0.1.1 0 0 -9 slow
1430         chk_join_nr "remove id 0 subflow" 1 1 1
1431         chk_rm_nr 1 1
1432
1433         # remove id 0 address
1434         reset
1435         ip netns exec $ns1 ./pm_nl_ctl limits 0 1
1436         ip netns exec $ns1 ./pm_nl_ctl add 10.0.2.1 flags signal
1437         ip netns exec $ns2 ./pm_nl_ctl limits 1 1
1438         run_tests $ns1 $ns2 10.0.1.1 0 -9 0 slow
1439         chk_join_nr "remove id 0 address" 1 1 1
1440         chk_add_nr 1 1
1441         chk_rm_nr 1 1 invert
1442 }
1443
1444 add_tests()
1445 {
1446         # add single subflow
1447         reset
1448         ip netns exec $ns1 ./pm_nl_ctl limits 0 1
1449         ip netns exec $ns2 ./pm_nl_ctl limits 0 1
1450         run_tests $ns1 $ns2 10.0.1.1 0 0 1 slow
1451         chk_join_nr "add single subflow" 1 1 1
1452
1453         # add signal address
1454         reset
1455         ip netns exec $ns1 ./pm_nl_ctl limits 0 1
1456         ip netns exec $ns2 ./pm_nl_ctl limits 1 1
1457         run_tests $ns1 $ns2 10.0.1.1 0 1 0 slow
1458         chk_join_nr "add signal address" 1 1 1
1459         chk_add_nr 1 1
1460
1461         # add multiple subflows
1462         reset
1463         ip netns exec $ns1 ./pm_nl_ctl limits 0 2
1464         ip netns exec $ns2 ./pm_nl_ctl limits 0 2
1465         run_tests $ns1 $ns2 10.0.1.1 0 0 2 slow
1466         chk_join_nr "add multiple subflows" 2 2 2
1467
1468         # add multiple subflows IPv6
1469         reset
1470         ip netns exec $ns1 ./pm_nl_ctl limits 0 2
1471         ip netns exec $ns2 ./pm_nl_ctl limits 0 2
1472         run_tests $ns1 $ns2 dead:beef:1::1 0 0 2 slow
1473         chk_join_nr "add multiple subflows IPv6" 2 2 2
1474
1475         # add multiple addresses IPv6
1476         reset
1477         ip netns exec $ns1 ./pm_nl_ctl limits 0 2
1478         ip netns exec $ns2 ./pm_nl_ctl limits 2 2
1479         run_tests $ns1 $ns2 dead:beef:1::1 0 2 0 slow
1480         chk_join_nr "add multiple addresses IPv6" 2 2 2
1481         chk_add_nr 2 2
1482 }
1483
1484 ipv6_tests()
1485 {
1486         # subflow IPv6
1487         reset
1488         ip netns exec $ns1 ./pm_nl_ctl limits 0 1
1489         ip netns exec $ns2 ./pm_nl_ctl limits 0 1
1490         ip netns exec $ns2 ./pm_nl_ctl add dead:beef:3::2 dev ns2eth3 flags subflow
1491         run_tests $ns1 $ns2 dead:beef:1::1 0 0 0 slow
1492         chk_join_nr "single subflow IPv6" 1 1 1
1493
1494         # add_address, unused IPv6
1495         reset
1496         ip netns exec $ns1 ./pm_nl_ctl add dead:beef:2::1 flags signal
1497         run_tests $ns1 $ns2 dead:beef:1::1 0 0 0 slow
1498         chk_join_nr "unused signal address IPv6" 0 0 0
1499         chk_add_nr 1 1
1500
1501         # signal address IPv6
1502         reset
1503         ip netns exec $ns1 ./pm_nl_ctl limits 0 1
1504         ip netns exec $ns1 ./pm_nl_ctl add dead:beef:2::1 flags signal
1505         ip netns exec $ns2 ./pm_nl_ctl limits 1 1
1506         run_tests $ns1 $ns2 dead:beef:1::1 0 0 0 slow
1507         chk_join_nr "single address IPv6" 1 1 1
1508         chk_add_nr 1 1
1509
1510         # single address IPv6, remove
1511         reset
1512         ip netns exec $ns1 ./pm_nl_ctl limits 0 1
1513         ip netns exec $ns1 ./pm_nl_ctl add dead:beef:2::1 flags signal
1514         ip netns exec $ns2 ./pm_nl_ctl limits 1 1
1515         run_tests $ns1 $ns2 dead:beef:1::1 0 -1 0 slow
1516         chk_join_nr "remove single address IPv6" 1 1 1
1517         chk_add_nr 1 1
1518         chk_rm_nr 1 1 invert
1519
1520         # subflow and signal IPv6, remove
1521         reset
1522         ip netns exec $ns1 ./pm_nl_ctl limits 0 2
1523         ip netns exec $ns1 ./pm_nl_ctl add dead:beef:2::1 flags signal
1524         ip netns exec $ns2 ./pm_nl_ctl limits 1 2
1525         ip netns exec $ns2 ./pm_nl_ctl add dead:beef:3::2 dev ns2eth3 flags subflow
1526         run_tests $ns1 $ns2 dead:beef:1::1 0 -1 -1 slow
1527         chk_join_nr "remove subflow and signal IPv6" 2 2 2
1528         chk_add_nr 1 1
1529         chk_rm_nr 1 1
1530 }
1531
1532 v4mapped_tests()
1533 {
1534         # subflow IPv4-mapped to IPv4-mapped
1535         reset
1536         ip netns exec $ns1 ./pm_nl_ctl limits 0 1
1537         ip netns exec $ns2 ./pm_nl_ctl limits 0 1
1538         ip netns exec $ns2 ./pm_nl_ctl add "::ffff:10.0.3.2" flags subflow
1539         run_tests $ns1 $ns2 "::ffff:10.0.1.1"
1540         chk_join_nr "single subflow IPv4-mapped" 1 1 1
1541
1542         # signal address IPv4-mapped with IPv4-mapped sk
1543         reset
1544         ip netns exec $ns1 ./pm_nl_ctl limits 0 1
1545         ip netns exec $ns2 ./pm_nl_ctl limits 1 1
1546         ip netns exec $ns1 ./pm_nl_ctl add "::ffff:10.0.2.1" flags signal
1547         run_tests $ns1 $ns2 "::ffff:10.0.1.1"
1548         chk_join_nr "signal address IPv4-mapped" 1 1 1
1549         chk_add_nr 1 1
1550
1551         # subflow v4-map-v6
1552         reset
1553         ip netns exec $ns1 ./pm_nl_ctl limits 0 1
1554         ip netns exec $ns2 ./pm_nl_ctl limits 0 1
1555         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 flags subflow
1556         run_tests $ns1 $ns2 "::ffff:10.0.1.1"
1557         chk_join_nr "single subflow v4-map-v6" 1 1 1
1558
1559         # signal address v4-map-v6
1560         reset
1561         ip netns exec $ns1 ./pm_nl_ctl limits 0 1
1562         ip netns exec $ns2 ./pm_nl_ctl limits 1 1
1563         ip netns exec $ns1 ./pm_nl_ctl add 10.0.2.1 flags signal
1564         run_tests $ns1 $ns2 "::ffff:10.0.1.1"
1565         chk_join_nr "signal address v4-map-v6" 1 1 1
1566         chk_add_nr 1 1
1567
1568         # subflow v6-map-v4
1569         reset
1570         ip netns exec $ns1 ./pm_nl_ctl limits 0 1
1571         ip netns exec $ns2 ./pm_nl_ctl limits 0 1
1572         ip netns exec $ns2 ./pm_nl_ctl add "::ffff:10.0.3.2" flags subflow
1573         run_tests $ns1 $ns2 10.0.1.1
1574         chk_join_nr "single subflow v6-map-v4" 1 1 1
1575
1576         # signal address v6-map-v4
1577         reset
1578         ip netns exec $ns1 ./pm_nl_ctl limits 0 1
1579         ip netns exec $ns2 ./pm_nl_ctl limits 1 1
1580         ip netns exec $ns1 ./pm_nl_ctl add "::ffff:10.0.2.1" flags signal
1581         run_tests $ns1 $ns2 10.0.1.1
1582         chk_join_nr "signal address v6-map-v4" 1 1 1
1583         chk_add_nr 1 1
1584
1585         # no subflow IPv6 to v4 address
1586         reset
1587         ip netns exec $ns1 ./pm_nl_ctl limits 0 1
1588         ip netns exec $ns2 ./pm_nl_ctl limits 0 1
1589         ip netns exec $ns2 ./pm_nl_ctl add dead:beef:2::2 flags subflow
1590         run_tests $ns1 $ns2 10.0.1.1
1591         chk_join_nr "no JOIN with diff families v4-v6" 0 0 0
1592
1593         # no subflow IPv6 to v4 address even if v6 has a valid v4 at the end
1594         reset
1595         ip netns exec $ns1 ./pm_nl_ctl limits 0 1
1596         ip netns exec $ns2 ./pm_nl_ctl limits 0 1
1597         ip netns exec $ns2 ./pm_nl_ctl add dead:beef:2::10.0.3.2 flags subflow
1598         run_tests $ns1 $ns2 10.0.1.1
1599         chk_join_nr "no JOIN with diff families v4-v6-2" 0 0 0
1600
1601         # no subflow IPv4 to v6 address, no need to slow down too then
1602         reset
1603         ip netns exec $ns1 ./pm_nl_ctl limits 0 1
1604         ip netns exec $ns2 ./pm_nl_ctl limits 0 1
1605         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 flags subflow
1606         run_tests $ns1 $ns2 dead:beef:1::1
1607         chk_join_nr "no JOIN with diff families v6-v4" 0 0 0
1608 }
1609
1610 backup_tests()
1611 {
1612         # single subflow, backup
1613         reset
1614         ip netns exec $ns1 ./pm_nl_ctl limits 0 1
1615         ip netns exec $ns2 ./pm_nl_ctl limits 0 1
1616         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 flags subflow,backup
1617         run_tests $ns1 $ns2 10.0.1.1 0 0 0 slow nobackup
1618         chk_join_nr "single subflow, backup" 1 1 1
1619         chk_prio_nr 0 1
1620
1621         # single address, backup
1622         reset
1623         ip netns exec $ns1 ./pm_nl_ctl limits 0 1
1624         ip netns exec $ns1 ./pm_nl_ctl add 10.0.2.1 flags signal
1625         ip netns exec $ns2 ./pm_nl_ctl limits 1 1
1626         run_tests $ns1 $ns2 10.0.1.1 0 0 0 slow backup
1627         chk_join_nr "single address, backup" 1 1 1
1628         chk_add_nr 1 1
1629         chk_prio_nr 1 0
1630 }
1631
1632 add_addr_ports_tests()
1633 {
1634         # signal address with port
1635         reset
1636         ip netns exec $ns1 ./pm_nl_ctl limits 0 1
1637         ip netns exec $ns2 ./pm_nl_ctl limits 1 1
1638         ip netns exec $ns1 ./pm_nl_ctl add 10.0.2.1 flags signal port 10100
1639         run_tests $ns1 $ns2 10.0.1.1
1640         chk_join_nr "signal address with port" 1 1 1
1641         chk_add_nr 1 1 1
1642
1643         # subflow and signal with port
1644         reset
1645         ip netns exec $ns1 ./pm_nl_ctl add 10.0.2.1 flags signal port 10100
1646         ip netns exec $ns1 ./pm_nl_ctl limits 0 2
1647         ip netns exec $ns2 ./pm_nl_ctl limits 1 2
1648         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 flags subflow
1649         run_tests $ns1 $ns2 10.0.1.1
1650         chk_join_nr "subflow and signal with port" 2 2 2
1651         chk_add_nr 1 1 1
1652
1653         # single address with port, remove
1654         reset
1655         ip netns exec $ns1 ./pm_nl_ctl limits 0 1
1656         ip netns exec $ns1 ./pm_nl_ctl add 10.0.2.1 flags signal port 10100
1657         ip netns exec $ns2 ./pm_nl_ctl limits 1 1
1658         run_tests $ns1 $ns2 10.0.1.1 0 -1 0 slow
1659         chk_join_nr "remove single address with port" 1 1 1
1660         chk_add_nr 1 1 1
1661         chk_rm_nr 1 1 invert
1662
1663         # subflow and signal with port, remove
1664         reset
1665         ip netns exec $ns1 ./pm_nl_ctl limits 0 2
1666         ip netns exec $ns1 ./pm_nl_ctl add 10.0.2.1 flags signal port 10100
1667         ip netns exec $ns2 ./pm_nl_ctl limits 1 2
1668         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 flags subflow
1669         run_tests $ns1 $ns2 10.0.1.1 0 -1 -1 slow
1670         chk_join_nr "remove subflow and signal with port" 2 2 2
1671         chk_add_nr 1 1 1
1672         chk_rm_nr 1 1
1673
1674         # subflows and signal with port, flush
1675         reset
1676         ip netns exec $ns1 ./pm_nl_ctl limits 0 3
1677         ip netns exec $ns1 ./pm_nl_ctl add 10.0.2.1 flags signal port 10100
1678         ip netns exec $ns2 ./pm_nl_ctl limits 1 3
1679         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 flags subflow
1680         ip netns exec $ns2 ./pm_nl_ctl add 10.0.4.2 flags subflow
1681         run_tests $ns1 $ns2 10.0.1.1 0 -8 -2 slow
1682         chk_join_nr "flush subflows and signal with port" 3 3 3
1683         chk_add_nr 1 1
1684         chk_rm_nr 2 2
1685
1686         # multiple addresses with port
1687         reset
1688         ip netns exec $ns1 ./pm_nl_ctl limits 2 2
1689         ip netns exec $ns1 ./pm_nl_ctl add 10.0.2.1 flags signal port 10100
1690         ip netns exec $ns1 ./pm_nl_ctl add 10.0.3.1 flags signal port 10100
1691         ip netns exec $ns2 ./pm_nl_ctl limits 2 2
1692         run_tests $ns1 $ns2 10.0.1.1
1693         chk_join_nr "multiple addresses with port" 2 2 2
1694         chk_add_nr 2 2 2
1695
1696         # multiple addresses with ports
1697         reset
1698         ip netns exec $ns1 ./pm_nl_ctl limits 2 2
1699         ip netns exec $ns1 ./pm_nl_ctl add 10.0.2.1 flags signal port 10100
1700         ip netns exec $ns1 ./pm_nl_ctl add 10.0.3.1 flags signal port 10101
1701         ip netns exec $ns2 ./pm_nl_ctl limits 2 2
1702         run_tests $ns1 $ns2 10.0.1.1
1703         chk_join_nr "multiple addresses with ports" 2 2 2
1704         chk_add_nr 2 2 2
1705 }
1706
1707 syncookies_tests()
1708 {
1709         # single subflow, syncookies
1710         reset_with_cookies
1711         ip netns exec $ns1 ./pm_nl_ctl limits 0 1
1712         ip netns exec $ns2 ./pm_nl_ctl limits 0 1
1713         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 flags subflow
1714         run_tests $ns1 $ns2 10.0.1.1
1715         chk_join_nr "single subflow with syn cookies" 1 1 1
1716
1717         # multiple subflows with syn cookies
1718         reset_with_cookies
1719         ip netns exec $ns1 ./pm_nl_ctl limits 0 2
1720         ip netns exec $ns2 ./pm_nl_ctl limits 0 2
1721         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 flags subflow
1722         ip netns exec $ns2 ./pm_nl_ctl add 10.0.2.2 flags subflow
1723         run_tests $ns1 $ns2 10.0.1.1
1724         chk_join_nr "multiple subflows with syn cookies" 2 2 2
1725
1726         # multiple subflows limited by server
1727         reset_with_cookies
1728         ip netns exec $ns1 ./pm_nl_ctl limits 0 1
1729         ip netns exec $ns2 ./pm_nl_ctl limits 0 2
1730         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 flags subflow
1731         ip netns exec $ns2 ./pm_nl_ctl add 10.0.2.2 flags subflow
1732         run_tests $ns1 $ns2 10.0.1.1
1733         chk_join_nr "subflows limited by server w cookies" 2 1 1
1734
1735         # test signal address with cookies
1736         reset_with_cookies
1737         ip netns exec $ns1 ./pm_nl_ctl limits 0 1
1738         ip netns exec $ns2 ./pm_nl_ctl limits 1 1
1739         ip netns exec $ns1 ./pm_nl_ctl add 10.0.2.1 flags signal
1740         run_tests $ns1 $ns2 10.0.1.1
1741         chk_join_nr "signal address with syn cookies" 1 1 1
1742         chk_add_nr 1 1
1743
1744         # test cookie with subflow and signal
1745         reset_with_cookies
1746         ip netns exec $ns1 ./pm_nl_ctl add 10.0.2.1 flags signal
1747         ip netns exec $ns1 ./pm_nl_ctl limits 0 2
1748         ip netns exec $ns2 ./pm_nl_ctl limits 1 2
1749         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 flags subflow
1750         run_tests $ns1 $ns2 10.0.1.1
1751         chk_join_nr "subflow and signal w cookies" 2 2 2
1752         chk_add_nr 1 1
1753
1754         # accept and use add_addr with additional subflows
1755         reset_with_cookies
1756         ip netns exec $ns1 ./pm_nl_ctl limits 0 3
1757         ip netns exec $ns1 ./pm_nl_ctl add 10.0.2.1 flags signal
1758         ip netns exec $ns2 ./pm_nl_ctl limits 1 3
1759         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 flags subflow
1760         ip netns exec $ns2 ./pm_nl_ctl add 10.0.4.2 flags subflow
1761         run_tests $ns1 $ns2 10.0.1.1
1762         chk_join_nr "subflows and signal w. cookies" 3 3 3
1763         chk_add_nr 1 1
1764 }
1765
1766 checksum_tests()
1767 {
1768         # checksum test 0 0
1769         reset_with_checksum 0 0
1770         ip netns exec $ns1 ./pm_nl_ctl limits 0 1
1771         ip netns exec $ns2 ./pm_nl_ctl limits 0 1
1772         run_tests $ns1 $ns2 10.0.1.1
1773         chk_csum_nr "checksum test 0 0"
1774
1775         # checksum test 1 1
1776         reset_with_checksum 1 1
1777         ip netns exec $ns1 ./pm_nl_ctl limits 0 1
1778         ip netns exec $ns2 ./pm_nl_ctl limits 0 1
1779         run_tests $ns1 $ns2 10.0.1.1
1780         chk_csum_nr "checksum test 1 1"
1781
1782         # checksum test 0 1
1783         reset_with_checksum 0 1
1784         ip netns exec $ns1 ./pm_nl_ctl limits 0 1
1785         ip netns exec $ns2 ./pm_nl_ctl limits 0 1
1786         run_tests $ns1 $ns2 10.0.1.1
1787         chk_csum_nr "checksum test 0 1"
1788
1789         # checksum test 1 0
1790         reset_with_checksum 1 0
1791         ip netns exec $ns1 ./pm_nl_ctl limits 0 1
1792         ip netns exec $ns2 ./pm_nl_ctl limits 0 1
1793         run_tests $ns1 $ns2 10.0.1.1
1794         chk_csum_nr "checksum test 1 0"
1795 }
1796
1797 deny_join_id0_tests()
1798 {
1799         # subflow allow join id0 ns1
1800         reset_with_allow_join_id0 1 0
1801         ip netns exec $ns1 ./pm_nl_ctl limits 1 1
1802         ip netns exec $ns2 ./pm_nl_ctl limits 1 1
1803         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 flags subflow
1804         run_tests $ns1 $ns2 10.0.1.1
1805         chk_join_nr "single subflow allow join id0 ns1" 1 1 1
1806
1807         # subflow allow join id0 ns2
1808         reset_with_allow_join_id0 0 1
1809         ip netns exec $ns1 ./pm_nl_ctl limits 1 1
1810         ip netns exec $ns2 ./pm_nl_ctl limits 1 1
1811         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 flags subflow
1812         run_tests $ns1 $ns2 10.0.1.1
1813         chk_join_nr "single subflow allow join id0 ns2" 0 0 0
1814
1815         # signal address allow join id0 ns1
1816         # ADD_ADDRs are not affected by allow_join_id0 value.
1817         reset_with_allow_join_id0 1 0
1818         ip netns exec $ns1 ./pm_nl_ctl limits 1 1
1819         ip netns exec $ns2 ./pm_nl_ctl limits 1 1
1820         ip netns exec $ns1 ./pm_nl_ctl add 10.0.2.1 flags signal
1821         run_tests $ns1 $ns2 10.0.1.1
1822         chk_join_nr "signal address allow join id0 ns1" 1 1 1
1823         chk_add_nr 1 1
1824
1825         # signal address allow join id0 ns2
1826         # ADD_ADDRs are not affected by allow_join_id0 value.
1827         reset_with_allow_join_id0 0 1
1828         ip netns exec $ns1 ./pm_nl_ctl limits 1 1
1829         ip netns exec $ns2 ./pm_nl_ctl limits 1 1
1830         ip netns exec $ns1 ./pm_nl_ctl add 10.0.2.1 flags signal
1831         run_tests $ns1 $ns2 10.0.1.1
1832         chk_join_nr "signal address allow join id0 ns2" 1 1 1
1833         chk_add_nr 1 1
1834
1835         # subflow and address allow join id0 ns1
1836         reset_with_allow_join_id0 1 0
1837         ip netns exec $ns1 ./pm_nl_ctl limits 2 2
1838         ip netns exec $ns2 ./pm_nl_ctl limits 2 2
1839         ip netns exec $ns1 ./pm_nl_ctl add 10.0.2.1 flags signal
1840         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 flags subflow
1841         run_tests $ns1 $ns2 10.0.1.1
1842         chk_join_nr "subflow and address allow join id0 1" 2 2 2
1843
1844         # subflow and address allow join id0 ns2
1845         reset_with_allow_join_id0 0 1
1846         ip netns exec $ns1 ./pm_nl_ctl limits 2 2
1847         ip netns exec $ns2 ./pm_nl_ctl limits 2 2
1848         ip netns exec $ns1 ./pm_nl_ctl add 10.0.2.1 flags signal
1849         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 flags subflow
1850         run_tests $ns1 $ns2 10.0.1.1
1851         chk_join_nr "subflow and address allow join id0 2" 1 1 1
1852 }
1853
1854 fullmesh_tests()
1855 {
1856         # fullmesh 1
1857         # 2 fullmesh addrs in ns2, added before the connection,
1858         # 1 non-fullmesh addr in ns1, added during the connection.
1859         reset
1860         ip netns exec $ns1 ./pm_nl_ctl limits 0 4
1861         ip netns exec $ns2 ./pm_nl_ctl limits 1 4
1862         ip netns exec $ns2 ./pm_nl_ctl add 10.0.2.2 flags subflow,fullmesh
1863         ip netns exec $ns2 ./pm_nl_ctl add 10.0.3.2 flags subflow,fullmesh
1864         run_tests $ns1 $ns2 10.0.1.1 0 1 0 slow
1865         chk_join_nr "fullmesh test 2x1" 4 4 4
1866         chk_add_nr 1 1
1867
1868         # fullmesh 2
1869         # 1 non-fullmesh addr in ns1, added before the connection,
1870         # 1 fullmesh addr in ns2, added during the connection.
1871         reset
1872         ip netns exec $ns1 ./pm_nl_ctl limits 1 3
1873         ip netns exec $ns2 ./pm_nl_ctl limits 1 3
1874         ip netns exec $ns1 ./pm_nl_ctl add 10.0.2.1 flags signal
1875         run_tests $ns1 $ns2 10.0.1.1 0 0 fullmesh_1 slow
1876         chk_join_nr "fullmesh test 1x1" 3 3 3
1877         chk_add_nr 1 1
1878
1879         # fullmesh 3
1880         # 1 non-fullmesh addr in ns1, added before the connection,
1881         # 2 fullmesh addrs in ns2, added during the connection.
1882         reset
1883         ip netns exec $ns1 ./pm_nl_ctl limits 2 5
1884         ip netns exec $ns2 ./pm_nl_ctl limits 1 5
1885         ip netns exec $ns1 ./pm_nl_ctl add 10.0.2.1 flags signal
1886         run_tests $ns1 $ns2 10.0.1.1 0 0 fullmesh_2 slow
1887         chk_join_nr "fullmesh test 1x2" 5 5 5
1888         chk_add_nr 1 1
1889
1890         # fullmesh 4
1891         # 1 non-fullmesh addr in ns1, added before the connection,
1892         # 2 fullmesh addrs in ns2, added during the connection,
1893         # limit max_subflows to 4.
1894         reset
1895         ip netns exec $ns1 ./pm_nl_ctl limits 2 4
1896         ip netns exec $ns2 ./pm_nl_ctl limits 1 4
1897         ip netns exec $ns1 ./pm_nl_ctl add 10.0.2.1 flags signal
1898         run_tests $ns1 $ns2 10.0.1.1 0 0 fullmesh_2 slow
1899         chk_join_nr "fullmesh test 1x2, limited" 4 4 4
1900         chk_add_nr 1 1
1901 }
1902
1903 all_tests()
1904 {
1905         subflows_tests
1906         subflows_error_tests
1907         signal_address_tests
1908         link_failure_tests
1909         add_addr_timeout_tests
1910         remove_tests
1911         add_tests
1912         ipv6_tests
1913         v4mapped_tests
1914         backup_tests
1915         add_addr_ports_tests
1916         syncookies_tests
1917         checksum_tests
1918         deny_join_id0_tests
1919         fullmesh_tests
1920 }
1921
1922 usage()
1923 {
1924         echo "mptcp_join usage:"
1925         echo "  -f subflows_tests"
1926         echo "  -e subflows_error_tests"
1927         echo "  -s signal_address_tests"
1928         echo "  -l link_failure_tests"
1929         echo "  -t add_addr_timeout_tests"
1930         echo "  -r remove_tests"
1931         echo "  -a add_tests"
1932         echo "  -6 ipv6_tests"
1933         echo "  -4 v4mapped_tests"
1934         echo "  -b backup_tests"
1935         echo "  -p add_addr_ports_tests"
1936         echo "  -k syncookies_tests"
1937         echo "  -S checksum_tests"
1938         echo "  -d deny_join_id0_tests"
1939         echo "  -m fullmesh_tests"
1940         echo "  -c capture pcap files"
1941         echo "  -C enable data checksum"
1942         echo "  -h help"
1943 }
1944
1945 sin=$(mktemp)
1946 sout=$(mktemp)
1947 cin=$(mktemp)
1948 cinsent=$(mktemp)
1949 cout=$(mktemp)
1950 init
1951 make_file "$cin" "client" 1
1952 make_file "$sin" "server" 1
1953 trap cleanup EXIT
1954
1955 for arg in "$@"; do
1956         # check for "capture/checksum" args before launching tests
1957         if [[ "${arg}" =~ ^"-"[0-9a-zA-Z]*"c"[0-9a-zA-Z]*$ ]]; then
1958                 capture=1
1959         fi
1960         if [[ "${arg}" =~ ^"-"[0-9a-zA-Z]*"C"[0-9a-zA-Z]*$ ]]; then
1961                 checksum=1
1962         fi
1963
1964         # exception for the capture/checksum options, the rest means: a part of the tests
1965         if [ "${arg}" != "-c" ] && [ "${arg}" != "-C" ]; then
1966                 do_all_tests=0
1967         fi
1968 done
1969
1970 if [ $do_all_tests -eq 1 ]; then
1971         all_tests
1972         exit $ret
1973 fi
1974
1975 while getopts 'fesltra64bpkdmchCS' opt; do
1976         case $opt in
1977                 f)
1978                         subflows_tests
1979                         ;;
1980                 e)
1981                         subflows_error_tests
1982                         ;;
1983                 s)
1984                         signal_address_tests
1985                         ;;
1986                 l)
1987                         link_failure_tests
1988                         ;;
1989                 t)
1990                         add_addr_timeout_tests
1991                         ;;
1992                 r)
1993                         remove_tests
1994                         ;;
1995                 a)
1996                         add_tests
1997                         ;;
1998                 6)
1999                         ipv6_tests
2000                         ;;
2001                 4)
2002                         v4mapped_tests
2003                         ;;
2004                 b)
2005                         backup_tests
2006                         ;;
2007                 p)
2008                         add_addr_ports_tests
2009                         ;;
2010                 k)
2011                         syncookies_tests
2012                         ;;
2013                 S)
2014                         checksum_tests
2015                         ;;
2016                 d)
2017                         deny_join_id0_tests
2018                         ;;
2019                 m)
2020                         fullmesh_tests
2021                         ;;
2022                 c)
2023                         ;;
2024                 C)
2025                         ;;
2026                 h | *)
2027                         usage
2028                         ;;
2029         esac
2030 done
2031
2032 exit $ret