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