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