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

   1 #!/bin/bash
   2 # SPDX-License-Identifier: GPL-2.0
   3
   4 . "$(dirname "${0}")/mptcp_lib.sh"
   5
   6 mptcp_lib_check_mptcp
   7
   8 ip -Version > /dev/null 2>&1
   9 if [ $? -ne 0 ];then
  10         echo "SKIP: Cannot not run test without ip tool"
  11         exit ${KSFT_SKIP}
  12 fi
  13
  14 ANNOUNCED=6        # MPTCP_EVENT_ANNOUNCED
  15 REMOVED=7          # MPTCP_EVENT_REMOVED
  16 SUB_ESTABLISHED=10 # MPTCP_EVENT_SUB_ESTABLISHED
  17 SUB_CLOSED=11      # MPTCP_EVENT_SUB_CLOSED
  18
  19 AF_INET=2
  20 AF_INET6=10
  21
  22 evts_pid=0
  23 client4_pid=0
  24 server4_pid=0
  25 client6_pid=0
  26 server6_pid=0
  27 client4_token=""
  28 server4_token=""
  29 client6_token=""
  30 server6_token=""
  31 client4_port=0;
  32 client6_port=0;
  33 app4_port=50002
  34 new4_port=50003
  35 app6_port=50004
  36 client_addr_id=${RANDOM:0:2}
  37 server_addr_id=${RANDOM:0:2}
  38
  39 sec=$(date +%s)
  40 rndh=$(stdbuf -o0 -e0 printf %x "$sec")-$(mktemp -u XXXXXX)
  41 ns1="ns1-$rndh"
  42 ns2="ns2-$rndh"
  43
  44 kill_wait()
  45 {
  46         kill $1 > /dev/null 2>&1
  47         wait $1 2>/dev/null
  48 }
  49
  50 cleanup()
  51 {
  52         echo "cleanup"
  53
  54         rm -rf $file
  55
  56         # Terminate the MPTCP connection and related processes
  57         if [ $client4_pid -ne 0 ]; then
  58                 kill -SIGUSR1 $client4_pid > /dev/null 2>&1
  59         fi
  60         if [ $server4_pid -ne 0 ]; then
  61                 kill_wait $server4_pid
  62         fi
  63         if [ $client6_pid -ne 0 ]; then
  64                 kill -SIGUSR1 $client6_pid > /dev/null 2>&1
  65         fi
  66         if [ $server6_pid -ne 0 ]; then
  67                 kill_wait $server6_pid
  68         fi
  69         if [ $evts_pid -ne 0 ]; then
  70                 kill_wait $evts_pid
  71         fi
  72         local netns
  73         for netns in "$ns1" "$ns2" ;do
  74                 ip netns del "$netns"
  75         done
  76 }
  77
  78 trap cleanup EXIT
  79
  80 # Create and configure network namespaces for testing
  81 for i in "$ns1" "$ns2" ;do
  82         ip netns add "$i" || exit 1
  83         ip -net "$i" link set lo up
  84         ip netns exec "$i" sysctl -q net.mptcp.enabled=1
  85         ip netns exec "$i" sysctl -q net.mptcp.pm_type=1
  86 done
  87
  88 #  "$ns1"              ns2
  89 #     ns1eth2    ns2eth1
  90
  91 ip link add ns1eth2 netns "$ns1" type veth peer name ns2eth1 netns "$ns2"
  92
  93 # Add IPv4/v6 addresses to the namespaces
  94 ip -net "$ns1" addr add 10.0.1.1/24 dev ns1eth2
  95 ip -net "$ns1" addr add 10.0.2.1/24 dev ns1eth2
  96 ip -net "$ns1" addr add dead:beef:1::1/64 dev ns1eth2 nodad
  97 ip -net "$ns1" addr add dead:beef:2::1/64 dev ns1eth2 nodad
  98 ip -net "$ns1" link set ns1eth2 up
  99
 100 ip -net "$ns2" addr add 10.0.1.2/24 dev ns2eth1
 101 ip -net "$ns2" addr add 10.0.2.2/24 dev ns2eth1
 102 ip -net "$ns2" addr add dead:beef:1::2/64 dev ns2eth1 nodad
 103 ip -net "$ns2" addr add dead:beef:2::2/64 dev ns2eth1 nodad
 104 ip -net "$ns2" link set ns2eth1 up
 105
 106 stdbuf -o0 -e0 printf "Created network namespaces ns1, ns2         \t\t\t[OK]\n"
 107
 108 make_file()
 109 {
 110         # Store a chunk of data in a file to transmit over an MPTCP connection
 111         local name=$1
 112         local ksize=1
 113
 114         dd if=/dev/urandom of="$name" bs=2 count=$ksize 2> /dev/null
 115         echo -e "\nMPTCP_TEST_FILE_END_MARKER" >> "$name"
 116 }
 117
 118 make_connection()
 119 {
 120         local file
 121         file=$(mktemp)
 122         make_file "$file" "client"
 123
 124         local is_v6=$1
 125         local app_port=$app4_port
 126         local connect_addr="10.0.1.1"
 127         local listen_addr="0.0.0.0"
 128         if [ "$is_v6" = "v6" ]
 129         then
 130                 connect_addr="dead:beef:1::1"
 131                 listen_addr="::"
 132                 app_port=$app6_port
 133         else
 134                 is_v6="v4"
 135         fi
 136
 137         # Capture netlink events over the two network namespaces running
 138         # the MPTCP client and server
 139         local client_evts
 140         client_evts=$(mktemp)
 141         :>"$client_evts"
 142         ip netns exec "$ns2" ./pm_nl_ctl events >> "$client_evts" 2>&1 &
 143         local client_evts_pid=$!
 144         local server_evts
 145         server_evts=$(mktemp)
 146         :>"$server_evts"
 147         ip netns exec "$ns1" ./pm_nl_ctl events >> "$server_evts" 2>&1 &
 148         local server_evts_pid=$!
 149         sleep 0.5
 150
 151         # Run the server
 152         ip netns exec "$ns1" \
 153            ./mptcp_connect -s MPTCP -w 300 -p $app_port -l $listen_addr > /dev/null 2>&1 &
 154         local server_pid=$!
 155         sleep 0.5
 156
 157         # Run the client, transfer $file and stay connected to the server
 158         # to conduct tests
 159         ip netns exec "$ns2" \
 160            ./mptcp_connect -s MPTCP -w 300 -m sendfile -p $app_port $connect_addr\
 161            2>&1 > /dev/null < "$file" &
 162         local client_pid=$!
 163         sleep 1
 164
 165         # Capture client/server attributes from MPTCP connection netlink events
 166         kill_wait $client_evts_pid
 167
 168         local client_token
 169         local client_port
 170         local client_serverside
 171         local server_token
 172         local server_serverside
 173
 174         client_token=$(sed --unbuffered -n 's/.*\(token:\)\([[:digit:]]*\).*$/\2/p;q' "$client_evts")
 175         client_port=$(sed --unbuffered -n 's/.*\(sport:\)\([[:digit:]]*\).*$/\2/p;q' "$client_evts")
 176         client_serverside=$(sed --unbuffered -n 's/.*\(server_side:\)\([[:digit:]]*\).*$/\2/p;q'\
 177                                       "$client_evts")
 178         kill_wait $server_evts_pid
 179         server_token=$(sed --unbuffered -n 's/.*\(token:\)\([[:digit:]]*\).*$/\2/p;q' "$server_evts")
 180         server_serverside=$(sed --unbuffered -n 's/.*\(server_side:\)\([[:digit:]]*\).*$/\2/p;q'\
 181                                       "$server_evts")
 182         rm -f "$client_evts" "$server_evts" "$file"
 183
 184         if [ "$client_token" != "" ] && [ "$server_token" != "" ] && [ "$client_serverside" = 0 ] &&
 185                    [ "$server_serverside" = 1 ]
 186         then
 187                 stdbuf -o0 -e0 printf "Established IP%s MPTCP Connection ns2 => ns1    \t\t[OK]\n" $is_v6
 188         else
 189                 exit 1
 190         fi
 191
 192         if [ "$is_v6" = "v6" ]
 193         then
 194                 client6_token=$client_token
 195                 server6_token=$server_token
 196                 client6_port=$client_port
 197                 client6_pid=$client_pid
 198                 server6_pid=$server_pid
 199         else
 200                 client4_token=$client_token
 201                 server4_token=$server_token
 202                 client4_port=$client_port
 203                 client4_pid=$client_pid
 204                 server4_pid=$server_pid
 205         fi
 206 }
 207
 208 verify_announce_event()
 209 {
 210         local evt=$1
 211         local e_type=$2
 212         local e_token=$3
 213         local e_addr=$4
 214         local e_id=$5
 215         local e_dport=$6
 216         local e_af=$7
 217         local type
 218         local token
 219         local addr
 220         local dport
 221         local id
 222
 223         type=$(sed --unbuffered -n 's/.*\(type:\)\([[:digit:]]*\).*$/\2/p;q' "$evt")
 224         token=$(sed --unbuffered -n 's/.*\(token:\)\([[:digit:]]*\).*$/\2/p;q' "$evt")
 225         if [ "$e_af" = "v6" ]
 226         then
 227                 addr=$(sed --unbuffered -n 's/.*\(daddr6:\)\([0-9a-f:.]*\).*$/\2/p;q' "$evt")
 228         else
 229                 addr=$(sed --unbuffered -n 's/.*\(daddr4:\)\([0-9.]*\).*$/\2/p;q' "$evt")
 230         fi
 231         dport=$(sed --unbuffered -n 's/.*\(dport:\)\([[:digit:]]*\).*$/\2/p;q' "$evt")
 232         id=$(sed --unbuffered -n 's/.*\(rem_id:\)\([[:digit:]]*\).*$/\2/p;q' "$evt")
 233         if [ "$type" = "$e_type" ] && [ "$token" = "$e_token" ] &&
 234                    [ "$addr" = "$e_addr" ] && [ "$dport" = "$e_dport" ] &&
 235                    [ "$id" = "$e_id" ]
 236         then
 237                 stdbuf -o0 -e0 printf "[OK]\n"
 238                 return 0
 239         fi
 240         stdbuf -o0 -e0 printf "[FAIL]\n"
 241         exit 1
 242 }
 243
 244 test_announce()
 245 {
 246         local evts
 247         evts=$(mktemp)
 248         # Capture events on the network namespace running the server
 249         :>"$evts"
 250         ip netns exec "$ns1" ./pm_nl_ctl events >> "$evts" 2>&1 &
 251         evts_pid=$!
 252         sleep 0.5
 253
 254         # ADD_ADDR using an invalid token should result in no action
 255         local invalid_token=$(( client4_token - 1))
 256         ip netns exec "$ns2" ./pm_nl_ctl ann 10.0.2.2 token $invalid_token id\
 257            $client_addr_id dev ns2eth1 > /dev/null 2>&1
 258
 259         local type
 260         type=$(sed --unbuffered -n 's/.*\(type:\)\([[:digit:]]*\).*$/\2/p;q' "$evts")
 261         stdbuf -o0 -e0 printf "ADD_ADDR 10.0.2.2 (ns2) => ns1, invalid token    \t\t"
 262         if [ "$type" = "" ]
 263         then
 264                 stdbuf -o0 -e0 printf "[OK]\n"
 265         else
 266                 stdbuf -o0 -e0 printf "[FAIL]\n"
 267                 exit 1
 268         fi
 269
 270         # ADD_ADDR from the client to server machine reusing the subflow port
 271         :>"$evts"
 272         ip netns exec "$ns2"\
 273            ./pm_nl_ctl ann 10.0.2.2 token "$client4_token" id $client_addr_id dev\
 274            ns2eth1 > /dev/null 2>&1
 275         stdbuf -o0 -e0 printf "ADD_ADDR id:%d 10.0.2.2 (ns2) => ns1, reuse port \t\t" $client_addr_id
 276         sleep 0.5
 277         verify_announce_event "$evts" "$ANNOUNCED" "$server4_token" "10.0.2.2" "$client_addr_id"\
 278                               "$client4_port"
 279
 280         # ADD_ADDR6 from the client to server machine reusing the subflow port
 281         :>"$evts"
 282         ip netns exec "$ns2" ./pm_nl_ctl ann\
 283            dead:beef:2::2 token "$client6_token" id $client_addr_id dev ns2eth1 > /dev/null 2>&1
 284         stdbuf -o0 -e0 printf "ADD_ADDR6 id:%d dead:beef:2::2 (ns2) => ns1, reuse port\t\t" $client_addr_id
 285         sleep 0.5
 286         verify_announce_event "$evts" "$ANNOUNCED" "$server6_token" "dead:beef:2::2"\
 287                               "$client_addr_id" "$client6_port" "v6"
 288
 289         # ADD_ADDR from the client to server machine using a new port
 290         :>"$evts"
 291         client_addr_id=$((client_addr_id+1))
 292         ip netns exec "$ns2" ./pm_nl_ctl ann 10.0.2.2 token "$client4_token" id\
 293            $client_addr_id dev ns2eth1 port $new4_port > /dev/null 2>&1
 294         stdbuf -o0 -e0 printf "ADD_ADDR id:%d 10.0.2.2 (ns2) => ns1, new port \t\t\t" $client_addr_id
 295         sleep 0.5
 296         verify_announce_event "$evts" "$ANNOUNCED" "$server4_token" "10.0.2.2"\
 297                               "$client_addr_id" "$new4_port"
 298
 299         kill_wait $evts_pid
 300
 301         # Capture events on the network namespace running the client
 302         :>"$evts"
 303         ip netns exec "$ns2" ./pm_nl_ctl events >> "$evts" 2>&1 &
 304         evts_pid=$!
 305         sleep 0.5
 306
 307         # ADD_ADDR from the server to client machine reusing the subflow port
 308         ip netns exec "$ns1" ./pm_nl_ctl ann 10.0.2.1 token "$server4_token" id\
 309            $server_addr_id dev ns1eth2 > /dev/null 2>&1
 310         stdbuf -o0 -e0 printf "ADD_ADDR id:%d 10.0.2.1 (ns1) => ns2, reuse port \t\t" $server_addr_id
 311         sleep 0.5
 312         verify_announce_event "$evts" "$ANNOUNCED" "$client4_token" "10.0.2.1"\
 313                               "$server_addr_id" "$app4_port"
 314
 315         # ADD_ADDR6 from the server to client machine reusing the subflow port
 316         :>"$evts"
 317         ip netns exec "$ns1" ./pm_nl_ctl ann dead:beef:2::1 token "$server6_token" id\
 318            $server_addr_id dev ns1eth2 > /dev/null 2>&1
 319         stdbuf -o0 -e0 printf "ADD_ADDR6 id:%d dead:beef:2::1 (ns1) => ns2, reuse port\t\t" $server_addr_id
 320         sleep 0.5
 321         verify_announce_event "$evts" "$ANNOUNCED" "$client6_token" "dead:beef:2::1"\
 322                               "$server_addr_id" "$app6_port" "v6"
 323
 324         # ADD_ADDR from the server to client machine using a new port
 325         :>"$evts"
 326         server_addr_id=$((server_addr_id+1))
 327         ip netns exec "$ns1" ./pm_nl_ctl ann 10.0.2.1 token "$server4_token" id\
 328            $server_addr_id dev ns1eth2 port $new4_port > /dev/null 2>&1
 329         stdbuf -o0 -e0 printf "ADD_ADDR id:%d 10.0.2.1 (ns1) => ns2, new port \t\t\t" $server_addr_id
 330         sleep 0.5
 331         verify_announce_event "$evts" "$ANNOUNCED" "$client4_token" "10.0.2.1"\
 332                               "$server_addr_id" "$new4_port"
 333
 334         kill_wait $evts_pid
 335         rm -f "$evts"
 336 }
 337
 338 verify_remove_event()
 339 {
 340         local evt=$1
 341         local e_type=$2
 342         local e_token=$3
 343         local e_id=$4
 344         local type
 345         local token
 346         local id
 347
 348         type=$(sed --unbuffered -n 's/.*\(type:\)\([[:digit:]]*\).*$/\2/p;q' "$evt")
 349         token=$(sed --unbuffered -n 's/.*\(token:\)\([[:digit:]]*\).*$/\2/p;q' "$evt")
 350         id=$(sed --unbuffered -n 's/.*\(rem_id:\)\([[:digit:]]*\).*$/\2/p;q' "$evt")
 351         if [ "$type" = "$e_type" ] && [ "$token" = "$e_token" ] &&
 352                    [ "$id" = "$e_id" ]
 353         then
 354                 stdbuf -o0 -e0 printf "[OK]\n"
 355                 return 0
 356         fi
 357         stdbuf -o0 -e0 printf "[FAIL]\n"
 358         exit 1
 359 }
 360
 361 test_remove()
 362 {
 363         local evts
 364         evts=$(mktemp)
 365
 366         # Capture events on the network namespace running the server
 367         :>"$evts"
 368         ip netns exec "$ns1" ./pm_nl_ctl events >> "$evts" 2>&1 &
 369         evts_pid=$!
 370         sleep 0.5
 371
 372         # RM_ADDR using an invalid token should result in no action
 373         local invalid_token=$(( client4_token - 1 ))
 374         ip netns exec "$ns2" ./pm_nl_ctl rem token $invalid_token id\
 375            $client_addr_id > /dev/null 2>&1
 376         stdbuf -o0 -e0 printf "RM_ADDR id:%d ns2 => ns1, invalid token                    \t"\
 377                $client_addr_id
 378         local type
 379         type=$(sed --unbuffered -n 's/.*\(type:\)\([[:digit:]]*\).*$/\2/p;q' "$evts")
 380         if [ "$type" = "" ]
 381         then
 382                 stdbuf -o0 -e0 printf "[OK]\n"
 383         else
 384                 stdbuf -o0 -e0 printf "[FAIL]\n"
 385         fi
 386
 387         # RM_ADDR using an invalid addr id should result in no action
 388         local invalid_id=$(( client_addr_id + 1 ))
 389         ip netns exec "$ns2" ./pm_nl_ctl rem token "$client4_token" id\
 390            $invalid_id > /dev/null 2>&1
 391         stdbuf -o0 -e0 printf "RM_ADDR id:%d ns2 => ns1, invalid id                    \t"\
 392                $invalid_id
 393         type=$(sed --unbuffered -n 's/.*\(type:\)\([[:digit:]]*\).*$/\2/p;q' "$evts")
 394         if [ "$type" = "" ]
 395         then
 396                 stdbuf -o0 -e0 printf "[OK]\n"
 397         else
 398                 stdbuf -o0 -e0 printf "[FAIL]\n"
 399         fi
 400
 401         # RM_ADDR from the client to server machine
 402         :>"$evts"
 403         ip netns exec "$ns2" ./pm_nl_ctl rem token "$client4_token" id\
 404            $client_addr_id > /dev/null 2>&1
 405         stdbuf -o0 -e0 printf "RM_ADDR id:%d ns2 => ns1                                \t"\
 406                $client_addr_id
 407         sleep 0.5
 408         verify_remove_event "$evts" "$REMOVED" "$server4_token" "$client_addr_id"
 409
 410         # RM_ADDR from the client to server machine
 411         :>"$evts"
 412         client_addr_id=$(( client_addr_id - 1 ))
 413         ip netns exec "$ns2" ./pm_nl_ctl rem token "$client4_token" id\
 414            $client_addr_id > /dev/null 2>&1
 415         stdbuf -o0 -e0 printf "RM_ADDR id:%d ns2 => ns1                                \t"\
 416                $client_addr_id
 417         sleep 0.5
 418         verify_remove_event "$evts" "$REMOVED" "$server4_token" "$client_addr_id"
 419
 420         # RM_ADDR6 from the client to server machine
 421         :>"$evts"
 422         ip netns exec "$ns2" ./pm_nl_ctl rem token "$client6_token" id\
 423            $client_addr_id > /dev/null 2>&1
 424         stdbuf -o0 -e0 printf "RM_ADDR6 id:%d ns2 => ns1                               \t"\
 425                $client_addr_id
 426         sleep 0.5
 427         verify_remove_event "$evts" "$REMOVED" "$server6_token" "$client_addr_id"
 428
 429         kill_wait $evts_pid
 430
 431         # Capture events on the network namespace running the client
 432         :>"$evts"
 433         ip netns exec "$ns2" ./pm_nl_ctl events >> "$evts" 2>&1 &
 434         evts_pid=$!
 435         sleep 0.5
 436
 437         # RM_ADDR from the server to client machine
 438         ip netns exec "$ns1" ./pm_nl_ctl rem token "$server4_token" id\
 439            $server_addr_id > /dev/null 2>&1
 440         stdbuf -o0 -e0 printf "RM_ADDR id:%d ns1 => ns2                                \t"\
 441                $server_addr_id
 442         sleep 0.5
 443         verify_remove_event "$evts" "$REMOVED" "$client4_token" "$server_addr_id"
 444
 445         # RM_ADDR from the server to client machine
 446         :>"$evts"
 447         server_addr_id=$(( server_addr_id - 1 ))
 448         ip netns exec "$ns1" ./pm_nl_ctl rem token "$server4_token" id\
 449            $server_addr_id > /dev/null 2>&1
 450         stdbuf -o0 -e0 printf "RM_ADDR id:%d ns1 => ns2                                \t" $server_addr_id
 451         sleep 0.5
 452         verify_remove_event "$evts" "$REMOVED" "$client4_token" "$server_addr_id"
 453
 454         # RM_ADDR6 from the server to client machine
 455         :>"$evts"
 456         ip netns exec "$ns1" ./pm_nl_ctl rem token "$server6_token" id\
 457            $server_addr_id > /dev/null 2>&1
 458         stdbuf -o0 -e0 printf "RM_ADDR6 id:%d ns1 => ns2                               \t" $server_addr_id
 459         sleep 0.5
 460         verify_remove_event "$evts" "$REMOVED" "$client6_token" "$server_addr_id"
 461
 462         kill_wait $evts_pid
 463         rm -f "$evts"
 464 }
 465
 466 verify_subflow_events()
 467 {
 468         local evt=$1
 469         local e_type=$2
 470         local e_token=$3
 471         local e_family=$4
 472         local e_saddr=$5
 473         local e_daddr=$6
 474         local e_dport=$7
 475         local e_locid=$8
 476         local e_remid=$9
 477         shift 2
 478         local e_from=$8
 479         local e_to=$9
 480         local type
 481         local token
 482         local family
 483         local saddr
 484         local daddr
 485         local dport
 486         local locid
 487         local remid
 488
 489         if [ "$e_type" = "$SUB_ESTABLISHED" ]
 490         then
 491                 if [ "$e_family" = "$AF_INET6" ]
 492                 then
 493                         stdbuf -o0 -e0 printf "CREATE_SUBFLOW6 %s (%s) => %s (%s)    "\
 494                                "$e_saddr" "$e_from" "$e_daddr" "$e_to"
 495                 else
 496                         stdbuf -o0 -e0 printf "CREATE_SUBFLOW %s (%s) => %s (%s)         \t"\
 497                                "$e_saddr" "$e_from" "$e_daddr" "$e_to"
 498                 fi
 499         else
 500                 if [ "$e_family" = "$AF_INET6" ]
 501                 then
 502                         stdbuf -o0 -e0 printf "DESTROY_SUBFLOW6 %s (%s) => %s (%s)   "\
 503                                "$e_saddr" "$e_from" "$e_daddr" "$e_to"
 504                 else
 505                         stdbuf -o0 -e0 printf "DESTROY_SUBFLOW %s (%s) => %s (%s)         \t"\
 506                                "$e_saddr" "$e_from" "$e_daddr" "$e_to"
 507                 fi
 508         fi
 509
 510         type=$(sed --unbuffered -n 's/.*\(type:\)\([[:digit:]]*\).*$/\2/p;q' "$evt")
 511         token=$(sed --unbuffered -n 's/.*\(token:\)\([[:digit:]]*\).*$/\2/p;q' "$evt")
 512         family=$(sed --unbuffered -n 's/.*\(family:\)\([[:digit:]]*\).*$/\2/p;q' "$evt")
 513         dport=$(sed --unbuffered -n 's/.*\(dport:\)\([[:digit:]]*\).*$/\2/p;q' "$evt")
 514         locid=$(sed --unbuffered -n 's/.*\(loc_id:\)\([[:digit:]]*\).*$/\2/p;q' "$evt")
 515         remid=$(sed --unbuffered -n 's/.*\(rem_id:\)\([[:digit:]]*\).*$/\2/p;q' "$evt")
 516         if [ "$family" = "$AF_INET6" ]
 517         then
 518                 saddr=$(sed --unbuffered -n 's/.*\(saddr6:\)\([0-9a-f:.]*\).*$/\2/p;q' "$evt")
 519                 daddr=$(sed --unbuffered -n 's/.*\(daddr6:\)\([0-9a-f:.]*\).*$/\2/p;q' "$evt")
 520         else
 521                 saddr=$(sed --unbuffered -n 's/.*\(saddr4:\)\([0-9.]*\).*$/\2/p;q' "$evt")
 522                 daddr=$(sed --unbuffered -n 's/.*\(daddr4:\)\([0-9.]*\).*$/\2/p;q' "$evt")
 523         fi
 524
 525         if [ "$type" = "$e_type" ] && [ "$token" = "$e_token" ] &&
 526                    [ "$daddr" = "$e_daddr" ] && [ "$e_dport" = "$dport" ] &&
 527                    [ "$family" = "$e_family" ] && [ "$saddr" = "$e_saddr" ] &&
 528                    [ "$e_locid" = "$locid" ] && [ "$e_remid" = "$remid" ]
 529         then
 530                 stdbuf -o0 -e0 printf "[OK]\n"
 531                 return 0
 532         fi
 533         stdbuf -o0 -e0 printf "[FAIL]\n"
 534         exit 1
 535 }
 536
 537 test_subflows()
 538 {
 539         local evts
 540         evts=$(mktemp)
 541         # Capture events on the network namespace running the server
 542         :>"$evts"
 543         ip netns exec "$ns1" ./pm_nl_ctl events >> "$evts" 2>&1 &
 544         evts_pid=$!
 545         sleep 0.5
 546
 547         # Attempt to add a listener at 10.0.2.2:<subflow-port>
 548         ip netns exec "$ns2" ./pm_nl_ctl listen 10.0.2.2\
 549            "$client4_port" > /dev/null 2>&1 &
 550         local listener_pid=$!
 551
 552         # ADD_ADDR from client to server machine reusing the subflow port
 553         ip netns exec "$ns2" ./pm_nl_ctl ann 10.0.2.2 token "$client4_token" id\
 554            $client_addr_id > /dev/null 2>&1
 555         sleep 0.5
 556
 557         # CREATE_SUBFLOW from server to client machine
 558         :>"$evts"
 559         ip netns exec "$ns1" ./pm_nl_ctl csf lip 10.0.2.1 lid 23 rip 10.0.2.2\
 560            rport "$client4_port" token "$server4_token" > /dev/null 2>&1
 561         sleep 0.5
 562         verify_subflow_events "$evts" "$SUB_ESTABLISHED" "$server4_token" "$AF_INET" "10.0.2.1"\
 563                               "10.0.2.2" "$client4_port" "23" "$client_addr_id" "ns1" "ns2"
 564
 565         # Delete the listener from the client ns, if one was created
 566         kill_wait $listener_pid
 567
 568         local sport
 569         sport=$(sed --unbuffered -n 's/.*\(sport:\)\([[:digit:]]*\).*$/\2/p;q' "$evts")
 570
 571         # DESTROY_SUBFLOW from server to client machine
 572         :>"$evts"
 573         ip netns exec "$ns1" ./pm_nl_ctl dsf lip 10.0.2.1 lport "$sport" rip 10.0.2.2 rport\
 574            "$client4_port" token "$server4_token" > /dev/null 2>&1
 575         sleep 0.5
 576         verify_subflow_events "$evts" "$SUB_CLOSED" "$server4_token" "$AF_INET" "10.0.2.1"\
 577                               "10.0.2.2" "$client4_port" "23" "$client_addr_id" "ns1" "ns2"
 578
 579         # RM_ADDR from client to server machine
 580         ip netns exec "$ns2" ./pm_nl_ctl rem id $client_addr_id token\
 581            "$client4_token" > /dev/null 2>&1
 582         sleep 0.5
 583
 584         # Attempt to add a listener at dead:beef:2::2:<subflow-port>
 585         ip netns exec "$ns2" ./pm_nl_ctl listen dead:beef:2::2\
 586            "$client6_port" > /dev/null 2>&1 &
 587         listener_pid=$!
 588
 589         # ADD_ADDR6 from client to server machine reusing the subflow port
 590         :>"$evts"
 591         ip netns exec "$ns2" ./pm_nl_ctl ann dead:beef:2::2 token "$client6_token" id\
 592            $client_addr_id > /dev/null 2>&1
 593         sleep 0.5
 594
 595         # CREATE_SUBFLOW6 from server to client machine
 596         :>"$evts"
 597         ip netns exec "$ns1" ./pm_nl_ctl csf lip dead:beef:2::1 lid 23 rip\
 598            dead:beef:2::2 rport "$client6_port" token "$server6_token" > /dev/null 2>&1
 599         sleep 0.5
 600         verify_subflow_events "$evts" "$SUB_ESTABLISHED" "$server6_token" "$AF_INET6"\
 601                               "dead:beef:2::1" "dead:beef:2::2" "$client6_port" "23"\
 602                               "$client_addr_id" "ns1" "ns2"
 603
 604         # Delete the listener from the client ns, if one was created
 605         kill_wait $listener_pid
 606
 607         sport=$(sed --unbuffered -n 's/.*\(sport:\)\([[:digit:]]*\).*$/\2/p;q' "$evts")
 608
 609         # DESTROY_SUBFLOW6 from server to client machine
 610         :>"$evts"
 611         ip netns exec "$ns1" ./pm_nl_ctl dsf lip dead:beef:2::1 lport "$sport" rip\
 612            dead:beef:2::2 rport "$client6_port" token "$server6_token" > /dev/null 2>&1
 613         sleep 0.5
 614         verify_subflow_events "$evts" "$SUB_CLOSED" "$server6_token" "$AF_INET6"\
 615                               "dead:beef:2::1" "dead:beef:2::2" "$client6_port" "23"\
 616                               "$client_addr_id" "ns1" "ns2"
 617
 618         # RM_ADDR from client to server machine
 619         ip netns exec "$ns2" ./pm_nl_ctl rem id $client_addr_id token\
 620            "$client6_token" > /dev/null 2>&1
 621         sleep 0.5
 622
 623         # Attempt to add a listener at 10.0.2.2:<new-port>
 624         ip netns exec "$ns2" ./pm_nl_ctl listen 10.0.2.2\
 625            $new4_port > /dev/null 2>&1 &
 626         listener_pid=$!
 627
 628         # ADD_ADDR from client to server machine using a new port
 629         :>"$evts"
 630         ip netns exec "$ns2" ./pm_nl_ctl ann 10.0.2.2 token "$client4_token" id\
 631            $client_addr_id port $new4_port > /dev/null 2>&1
 632         sleep 0.5
 633
 634         # CREATE_SUBFLOW from server to client machine
 635         :>"$evts"
 636         ip netns exec "$ns1" ./pm_nl_ctl csf lip 10.0.2.1 lid 23 rip 10.0.2.2 rport\
 637            $new4_port token "$server4_token" > /dev/null 2>&1
 638         sleep 0.5
 639         verify_subflow_events "$evts" "$SUB_ESTABLISHED" "$server4_token" "$AF_INET"\
 640                               "10.0.2.1" "10.0.2.2" "$new4_port" "23"\
 641                               "$client_addr_id" "ns1" "ns2"
 642
 643         # Delete the listener from the client ns, if one was created
 644         kill_wait $listener_pid
 645
 646         sport=$(sed --unbuffered -n 's/.*\(sport:\)\([[:digit:]]*\).*$/\2/p;q' "$evts")
 647
 648         # DESTROY_SUBFLOW from server to client machine
 649         :>"$evts"
 650         ip netns exec "$ns1" ./pm_nl_ctl dsf lip 10.0.2.1 lport "$sport" rip 10.0.2.2 rport\
 651            $new4_port token "$server4_token" > /dev/null 2>&1
 652         sleep 0.5
 653         verify_subflow_events "$evts" "$SUB_CLOSED" "$server4_token" "$AF_INET" "10.0.2.1"\
 654                               "10.0.2.2" "$new4_port" "23" "$client_addr_id" "ns1" "ns2"
 655
 656         # RM_ADDR from client to server machine
 657         ip netns exec "$ns2" ./pm_nl_ctl rem id $client_addr_id token\
 658            "$client4_token" > /dev/null 2>&1
 659
 660         kill_wait $evts_pid
 661
 662         # Capture events on the network namespace running the client
 663         :>"$evts"
 664         ip netns exec "$ns2" ./pm_nl_ctl events >> "$evts" 2>&1 &
 665         evts_pid=$!
 666         sleep 0.5
 667
 668         # Attempt to add a listener at 10.0.2.1:<subflow-port>
 669         ip netns exec "$ns1" ./pm_nl_ctl listen 10.0.2.1\
 670            $app4_port > /dev/null 2>&1 &
 671         listener_pid=$!
 672
 673         # ADD_ADDR from server to client machine reusing the subflow port
 674         ip netns exec "$ns1" ./pm_nl_ctl ann 10.0.2.1 token "$server4_token" id\
 675            $server_addr_id > /dev/null 2>&1
 676         sleep 0.5
 677
 678         # CREATE_SUBFLOW from client to server machine
 679         :>"$evts"
 680         ip netns exec "$ns2" ./pm_nl_ctl csf lip 10.0.2.2 lid 23 rip 10.0.2.1 rport\
 681            $app4_port token "$client4_token" > /dev/null 2>&1
 682         sleep 0.5
 683         verify_subflow_events "$evts" "$SUB_ESTABLISHED" "$client4_token" "$AF_INET" "10.0.2.2"\
 684                               "10.0.2.1" "$app4_port" "23" "$server_addr_id" "ns2" "ns1"
 685
 686         # Delete the listener from the server ns, if one was created
 687         kill_wait $listener_pid
 688
 689         sport=$(sed --unbuffered -n 's/.*\(sport:\)\([[:digit:]]*\).*$/\2/p;q' "$evts")
 690
 691         # DESTROY_SUBFLOW from client to server machine
 692         :>"$evts"
 693         ip netns exec "$ns2" ./pm_nl_ctl dsf lip 10.0.2.2 lport "$sport" rip 10.0.2.1 rport\
 694            $app4_port token "$client4_token" > /dev/null 2>&1
 695         sleep 0.5
 696         verify_subflow_events "$evts" "$SUB_CLOSED" "$client4_token" "$AF_INET" "10.0.2.2"\
 697                               "10.0.2.1" "$app4_port" "23" "$server_addr_id" "ns2" "ns1"
 698
 699         # RM_ADDR from server to client machine
 700         ip netns exec "$ns1" ./pm_nl_ctl rem id $server_addr_id token\
 701            "$server4_token" > /dev/null 2>&1
 702         sleep 0.5
 703
 704         # Attempt to add a listener at dead:beef:2::1:<subflow-port>
 705         ip netns exec "$ns1" ./pm_nl_ctl listen dead:beef:2::1\
 706            $app6_port > /dev/null 2>&1 &
 707         listener_pid=$!
 708
 709         # ADD_ADDR6 from server to client machine reusing the subflow port
 710         :>"$evts"
 711         ip netns exec "$ns1" ./pm_nl_ctl ann dead:beef:2::1 token "$server6_token" id\
 712            $server_addr_id > /dev/null 2>&1
 713         sleep 0.5
 714
 715         # CREATE_SUBFLOW6 from client to server machine
 716         :>"$evts"
 717         ip netns exec "$ns2" ./pm_nl_ctl csf lip dead:beef:2::2 lid 23 rip\
 718            dead:beef:2::1 rport $app6_port token "$client6_token" > /dev/null 2>&1
 719         sleep 0.5
 720         verify_subflow_events "$evts" "$SUB_ESTABLISHED" "$client6_token"\
 721                               "$AF_INET6" "dead:beef:2::2"\
 722                               "dead:beef:2::1" "$app6_port" "23"\
 723                               "$server_addr_id" "ns2" "ns1"
 724
 725         # Delete the listener from the server ns, if one was created
 726         kill_wait $listener_pid
 727
 728         sport=$(sed --unbuffered -n 's/.*\(sport:\)\([[:digit:]]*\).*$/\2/p;q' "$evts")
 729
 730         # DESTROY_SUBFLOW6 from client to server machine
 731         :>"$evts"
 732         ip netns exec "$ns2" ./pm_nl_ctl dsf lip dead:beef:2::2 lport "$sport" rip\
 733            dead:beef:2::1 rport $app6_port token "$client6_token" > /dev/null 2>&1
 734         sleep 0.5
 735         verify_subflow_events "$evts" "$SUB_CLOSED" "$client6_token" "$AF_INET6" "dead:beef:2::2"\
 736                               "dead:beef:2::1" "$app6_port" "23" "$server_addr_id" "ns2" "ns1"
 737
 738         # RM_ADDR6 from server to client machine
 739         ip netns exec "$ns1" ./pm_nl_ctl rem id $server_addr_id token\
 740            "$server6_token" > /dev/null 2>&1
 741         sleep 0.5
 742
 743         # Attempt to add a listener at 10.0.2.1:<new-port>
 744         ip netns exec "$ns1" ./pm_nl_ctl listen 10.0.2.1\
 745            $new4_port > /dev/null 2>&1 &
 746         listener_pid=$!
 747
 748         # ADD_ADDR from server to client machine using a new port
 749         :>"$evts"
 750         ip netns exec "$ns1" ./pm_nl_ctl ann 10.0.2.1 token "$server4_token" id\
 751            $server_addr_id port $new4_port > /dev/null 2>&1
 752         sleep 0.5
 753
 754         # CREATE_SUBFLOW from client to server machine
 755         :>"$evts"
 756         ip netns exec "$ns2" ./pm_nl_ctl csf lip 10.0.2.2 lid 23 rip 10.0.2.1 rport\
 757            $new4_port token "$client4_token" > /dev/null 2>&1
 758         sleep 0.5
 759         verify_subflow_events "$evts" "$SUB_ESTABLISHED" "$client4_token" "$AF_INET"\
 760                               "10.0.2.2" "10.0.2.1" "$new4_port" "23" "$server_addr_id" "ns2" "ns1"
 761
 762         # Delete the listener from the server ns, if one was created
 763         kill_wait $listener_pid
 764
 765         sport=$(sed --unbuffered -n 's/.*\(sport:\)\([[:digit:]]*\).*$/\2/p;q' "$evts")
 766
 767         # DESTROY_SUBFLOW from client to server machine
 768         :>"$evts"
 769         ip netns exec "$ns2" ./pm_nl_ctl dsf lip 10.0.2.2 lport "$sport" rip 10.0.2.1 rport\
 770            $new4_port token "$client4_token" > /dev/null 2>&1
 771         sleep 0.5
 772         verify_subflow_events "$evts" "$SUB_CLOSED" "$client4_token" "$AF_INET" "10.0.2.2"\
 773                               "10.0.2.1" "$new4_port" "23" "$server_addr_id" "ns2" "ns1"
 774
 775         # RM_ADDR from server to client machine
 776         ip netns exec "$ns1" ./pm_nl_ctl rem id $server_addr_id token\
 777            "$server4_token" > /dev/null 2>&1
 778
 779         kill_wait $evts_pid
 780         rm -f "$evts"
 781 }
 782
 783 test_subflows_v4_v6_mix()
 784 {
 785         local client_evts
 786         client_evts=$(mktemp)
 787         # Capture events on the network namespace running the client
 788         :>"$client_evts"
 789         ip netns exec "$ns2" ./pm_nl_ctl events >> "$client_evts" 2>&1 &
 790         evts_pid=$!
 791         sleep 0.5
 792
 793         # Attempt to add a listener at 10.0.2.1:<subflow-port>
 794         ip netns exec "$ns1" ./pm_nl_ctl listen 10.0.2.1\
 795            $app6_port > /dev/null 2>&1 &
 796         local listener_pid=$!
 797
 798         # ADD_ADDR4 from server to client machine reusing the subflow port on
 799         # the established v6 connection
 800         :>"$client_evts"
 801         ip netns exec "$ns1" ./pm_nl_ctl ann 10.0.2.1 token "$server6_token" id\
 802            $server_addr_id dev ns1eth2 > /dev/null 2>&1
 803         stdbuf -o0 -e0 printf "ADD_ADDR4 id:%d 10.0.2.1 (ns1) => ns2, reuse port\t\t" $server_addr_id
 804         sleep 0.5
 805         verify_announce_event "$client_evts" "$ANNOUNCED" "$client6_token" "10.0.2.1"\
 806                               "$server_addr_id" "$app6_port"
 807
 808         # CREATE_SUBFLOW from client to server machine
 809         :>"$client_evts"
 810         ip netns exec "$ns2" ./pm_nl_ctl csf lip 10.0.2.2 lid 23 rip 10.0.2.1 rport\
 811            $app6_port token "$client6_token" > /dev/null 2>&1
 812         sleep 0.5
 813         verify_subflow_events "$client_evts" "$SUB_ESTABLISHED" "$client6_token"\
 814                               "$AF_INET" "10.0.2.2" "10.0.2.1" "$app6_port" "23"\
 815                               "$server_addr_id" "ns2" "ns1"
 816
 817         # Delete the listener from the server ns, if one was created
 818         kill_wait $listener_pid
 819
 820         sport=$(sed --unbuffered -n 's/.*\(sport:\)\([[:digit:]]*\).*$/\2/p;q' "$client_evts")
 821
 822         # DESTROY_SUBFLOW from client to server machine
 823         :>"$client_evts"
 824         ip netns exec "$ns2" ./pm_nl_ctl dsf lip 10.0.2.2 lport "$sport" rip 10.0.2.1 rport\
 825            $app6_port token "$client6_token" > /dev/null 2>&1
 826         sleep 0.5
 827         verify_subflow_events "$client_evts" "$SUB_CLOSED" "$client6_token" \
 828                               "$AF_INET" "10.0.2.2" "10.0.2.1" "$app6_port" "23"\
 829                               "$server_addr_id" "ns2" "ns1"
 830
 831         # RM_ADDR from server to client machine
 832         ip netns exec "$ns1" ./pm_nl_ctl rem id $server_addr_id token\
 833            "$server6_token" > /dev/null 2>&1
 834         sleep 0.5
 835
 836         kill_wait $evts_pid
 837         rm -f "$client_evts"
 838 }
 839
 840 test_prio()
 841 {
 842         local count
 843
 844         # Send MP_PRIO signal from client to server machine
 845         ip netns exec "$ns2" ./pm_nl_ctl set 10.0.1.2 port "$client4_port" flags backup token "$client4_token" rip 10.0.1.1 rport "$server4_port"
 846         sleep 0.5
 847
 848         # Check TX
 849         stdbuf -o0 -e0 printf "MP_PRIO TX                                                 \t"
 850         count=$(ip netns exec "$ns2" nstat -as | grep MPTcpExtMPPrioTx | awk '{print $2}')
 851         [ -z "$count" ] && count=0
 852         if [ $count != 1 ]; then
 853                 stdbuf -o0 -e0 printf "[FAIL]\n"
 854                 exit 1
 855         else
 856                 stdbuf -o0 -e0 printf "[OK]\n"
 857         fi
 858
 859         # Check RX
 860         stdbuf -o0 -e0 printf "MP_PRIO RX                                                 \t"
 861         count=$(ip netns exec "$ns1" nstat -as | grep MPTcpExtMPPrioRx | awk '{print $2}')
 862         [ -z "$count" ] && count=0
 863         if [ $count != 1 ]; then
 864                 stdbuf -o0 -e0 printf "[FAIL]\n"
 865                 exit 1
 866         else
 867                 stdbuf -o0 -e0 printf "[OK]\n"
 868         fi
 869 }
 870
 871 make_connection
 872 make_connection "v6"
 873 test_announce
 874 test_remove
 875 test_subflows
 876 test_subflows_v4_v6_mix
 877 test_prio
 878
 879 exit 0