mptcp_join.sh

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