tools/testing/selftests/net/srv6_end_flavors_test.sh

   1 #!/bin/bash
   2 # SPDX-License-Identifier: GPL-2.0
   3 #
   4 # author: Andrea Mayer <andrea.mayer@uniroma2.it>
   5 # author: Paolo Lungaroni <paolo.lungaroni@uniroma2.it>
   6 #
   7 # This script is designed to test the support for "flavors" in the SRv6 End
   8 # behavior.
   9 #
  10 # Flavors defined in RFC8986 [1] represent additional operations that can modify
  11 # or extend the existing SRv6 End, End.X and End.T behaviors. For the sake of
  12 # convenience, we report the list of flavors described in [1] hereafter:
  13 #   - Penultimate Segment Pop (PSP);
  14 #   - Ultimate Segment Pop (USP);
  15 #   - Ultimate Segment Decapsulation (USD).
  16 #
  17 # The End, End.X, and End.T behaviors can support these flavors either
  18 # individually or in combinations.
  19 # Currently in this selftest we consider only the PSP flavor for the SRv6 End
  20 # behavior. However, it is possible to extend the script as soon as other
  21 # flavors will be supported in the kernel.
  22 #
  23 # The purpose of the PSP flavor consists in instructing the penultimate node
  24 # listed in the SRv6 policy to remove (i.e. pop) the outermost SRH from the IPv6
  25 # header.
  26 # A PSP enabled SRv6 End behavior instance processes the SRH by:
  27 #  - decrementing the Segment Left (SL) value from 1 to 0;
  28 #  - copying the last SID from the SID List into the IPv6 Destination Address
  29 #    (DA);
  30 #  - removing the SRH from the extension headers following the IPv6 header.
  31 #
  32 # Once the SRH is removed, the IPv6 packet is forwarded to the destination using
  33 # the IPv6 DA updated during the PSP operation (i.e. the IPv6 DA corresponding
  34 # to the last SID carried by the removed SRH).
  35 #
  36 # Although the PSP flavor can be set for any SRv6 End behavior instance on any
  37 # SR node, it will be active only on such behaviors bound to a penultimate SID
  38 # for a given SRv6 policy.
  39 #                                                SL=2 SL=1 SL=0
  40 #                                                  |    |    |
  41 # For example, given the SRv6 policy (SID List := <X,   Y,   Z>):
  42 #  - a PSP enabled SRv6 End behavior bound to SID Y will apply the PSP operation
  43 #    as Segment Left (SL) is 1, corresponding to the Penultimate Segment of the
  44 #    SID List;
  45 #  - a PSP enabled SRv6 End behavior bound to SID X will *NOT* apply the PSP
  46 #    operation as the Segment Left is 2. This behavior instance will apply the
  47 #    "standard" End packet processing, ignoring the configured PSP flavor at
  48 #    all.
  49 #
  50 # [1] RFC8986: https://datatracker.ietf.org/doc/html/rfc8986
  51 #
  52 # Network topology
  53 # ================
  54 #
  55 # The network topology used in this selftest is depicted hereafter, composed by
  56 # two hosts (hs-1, hs-2) and four routers (rt-1, rt-2, rt-3, rt-4).
  57 # Hosts hs-1 and hs-2 are connected to routers rt-1 and rt-2, respectively,
  58 # allowing them to communicate with each other.
  59 # Traffic exchanged between hs-1 and hs-2 can follow different network paths.
  60 # The network operator, through specific SRv6 Policies can steer traffic to one
  61 # path rather than another. In this selftest this is implemented as follows:
  62 #
  63 #   i) The SRv6 H.Insert behavior applies SRv6 Policies on traffic received by
  64 #      connected hosts. It pushes the Segment Routing Header (SRH) after the
  65 #      IPv6 header. The SRH contains the SID List (i.e. SRv6 Policy) needed for
  66 #      steering traffic across the segments/waypoints specified in that list;
  67 #
  68 #  ii) The SRv6 End behavior advances the active SID in the SID List carried by
  69 #      the SRH;
  70 #
  71 # iii) The PSP enabled SRv6 End behavior is used to remove the SRH when such
  72 #      behavior is configured on a node bound to the Penultimate Segment carried
  73 #      by the SID List.
  74 #
  75 #                cafe::1                      cafe::2
  76 #              +--------+                   +--------+
  77 #              |        |                   |        |
  78 #              |  hs-1  |                   |  hs-2  |
  79 #              |        |                   |        |
  80 #              +---+----+                   +--- +---+
  81 #     cafe::/64    |                             |      cafe::/64
  82 #                  |                             |
  83 #              +---+----+                   +----+---+
  84 #              |        |  fcf0:0:1:2::/64  |        |
  85 #              |  rt-1  +-------------------+  rt-2  |
  86 #              |        |                   |        |
  87 #              +---+----+                   +----+---+
  88 #                  |      .               .      |
  89 #                  |  fcf0:0:1:3::/64   .        |
  90 #                  |          .       .          |
  91 #                  |            .   .            |
  92 #  fcf0:0:1:4::/64 |              .              | fcf0:0:2:3::/64
  93 #                  |            .   .            |
  94 #                  |          .       .          |
  95 #                  |  fcf0:0:2:4::/64   .        |
  96 #                  |      .               .      |
  97 #              +---+----+                   +----+---+
  98 #              |        |                   |        |
  99 #              |  rt-4  +-------------------+  rt-3  |
 100 #              |        |  fcf0:0:3:4::/64  |        |
 101 #              +---+----+                   +----+---+
 102 #
 103 # Every fcf0:0:x:y::/64 network interconnects the SRv6 routers rt-x with rt-y in
 104 # the IPv6 operator network.
 105 #
 106 #
 107 # Local SID table
 108 # ===============
 109 #
 110 # Each SRv6 router is configured with a Local SID table in which SIDs are
 111 # stored. Considering the given SRv6 router rt-x, at least two SIDs are
 112 # configured in the Local SID table:
 113 #
 114 #   Local SID table for SRv6 router rt-x
 115 #   +---------------------------------------------------------------------+
 116 #   |fcff:x::e is associated with the SRv6 End behavior                   |
 117 #   |fcff:x::ef1 is associated with the SRv6 End behavior with PSP flavor |
 118 #   +---------------------------------------------------------------------+
 119 #
 120 # The fcff::/16 prefix is reserved by the operator for the SIDs. Reachability of
 121 # SIDs is ensured by proper configuration of the IPv6 operator's network and
 122 # SRv6 routers.
 123 #
 124 #
 125 # SRv6 Policies
 126 # =============
 127 #
 128 # An SRv6 ingress router applies different SRv6 Policies to the traffic received
 129 # from connected hosts on the basis of the destination addresses.
 130 # In case of SRv6 H.Insert behavior, the SRv6 Policy enforcement consists of
 131 # pushing the SRH (carrying a given SID List) after the existing IPv6 header.
 132 # Note that in the inserting mode, there is no encapsulation at all.
 133 #
 134 #   Before applying an SRv6 Policy using the SRv6 H.Insert behavior
 135 #   +------+---------+
 136 #   | IPv6 | Payload |
 137 #   +------+---------+
 138 #
 139 #   After applying an SRv6 Policy using the SRv6 H.Insert behavior
 140 #   +------+-----+---------+
 141 #   | IPv6 | SRH | Payload |
 142 #   +------+-----+---------+
 143 #
 144 # Traffic from hs-1 to hs-2
 145 # -------------------------
 146 #
 147 # Packets generated from hs-1 and directed towards hs-2 are
 148 # handled by rt-1 which applies the following SRv6 Policy:
 149 #
 150 #   i.a) IPv6 traffic, SID List=fcff:3::e,fcff:4::ef1,fcff:2::ef1,cafe::2
 151 #
 152 # Router rt-1 is configured to enforce the Policy (i.a) through the SRv6
 153 # H.Insert behavior which pushes the SRH after the existing IPv6 header. This
 154 # Policy steers the traffic from hs-1 across rt-3, rt-4, rt-2 and finally to the
 155 # destination hs-2.
 156 #
 157 # As the packet reaches the router rt-3, the SRv6 End behavior bound to SID
 158 # fcff:3::e is triggered. The behavior updates the Segment Left (from SL=3 to
 159 # SL=2) in the SRH, the IPv6 DA with fcff:4::ef1 and forwards the packet to the
 160 # next router on the path, i.e. rt-4.
 161 #
 162 # When router rt-4 receives the packet, the PSP enabled SRv6 End behavior bound
 163 # to SID fcff:4::ef1 is executed. Since the SL=2, the PSP operation is *NOT*
 164 # kicked in and the behavior applies the default End processing: the Segment
 165 # Left is decreased (from SL=2 to SL=1), the IPv6 DA is updated with the SID
 166 # fcff:2::ef1 and the packet is forwarded to router rt-2.
 167 #
 168 # The PSP enabled SRv6 End behavior on rt-2 is associated with SID fcff:2::ef1
 169 # and is executed as the packet is received. Because SL=1, the behavior applies
 170 # the PSP processing on the packet as follows: i) SL is decreased, i.e. from
 171 # SL=1 to SL=0; ii) last SID (cafe::2) is copied into the IPv6 DA; iii) the
 172 # outermost SRH is removed from the extension headers following the IPv6 header.
 173 # Once the PSP processing is completed, the packet is forwarded to the host hs-2
 174 # (destination).
 175 #
 176 # Traffic from hs-2 to hs-1
 177 # -------------------------
 178 #
 179 # Packets generated from hs-2 and directed to hs-1 are handled by rt-2 which
 180 # applies the following SRv6 Policy:
 181 #
 182 #   i.b) IPv6 traffic, SID List=fcff:1::ef1,cafe::1
 183 #
 184 # Router rt-2 is configured to enforce the Policy (i.b) through the SRv6
 185 # H.Insert behavior which pushes the SRH after the existing IPv6 header. This
 186 # Policy steers the traffic from hs-2 across rt-1 and finally to the
 187 # destination hs-1
 188 #
 189 #
 190 # When the router rt-1 receives the packet, the PSP enabled SRv6 End behavior
 191 # associated with the SID fcff:1::ef1 is triggered. Since the SL=1,
 192 # the PSP operation takes place: i) the SL is decremented; ii) the IPv6 DA is
 193 # set with the last SID; iii) the SRH is removed from the extension headers
 194 # after the IPv6 header. At this point, the packet with IPv6 DA=cafe::1 is sent
 195 # to the destination, i.e. hs-1.
 196
 197 # Kselftest framework requirement - SKIP code is 4.
 198 readonly ksft_skip=4
 199
 200 readonly RDMSUFF="$(mktemp -u XXXXXXXX)"
 201 readonly DUMMY_DEVNAME="dum0"
 202 readonly RT2HS_DEVNAME="veth1"
 203 readonly LOCALSID_TABLE_ID=90
 204 readonly IPv6_RT_NETWORK=fcf0:0
 205 readonly IPv6_HS_NETWORK=cafe
 206 readonly IPv6_TESTS_ADDR=2001:db8::1
 207 readonly LOCATOR_SERVICE=fcff
 208 readonly END_FUNC=000e
 209 readonly END_PSP_FUNC=0ef1
 210
 211 PING_TIMEOUT_SEC=4
 212 PAUSE_ON_FAIL=${PAUSE_ON_FAIL:=no}
 213
 214 # IDs of routers and hosts are initialized during the setup of the testing
 215 # network
 216 ROUTERS=''
 217 HOSTS=''
 218
 219 SETUP_ERR=1
 220
 221 ret=${ksft_skip}
 222 nsuccess=0
 223 nfail=0
 224
 225 log_test()
 226 {
 227         local rc="$1"
 228         local expected="$2"
 229         local msg="$3"
 230
 231         if [ "${rc}" -eq "${expected}" ]; then
 232                 nsuccess=$((nsuccess+1))
 233                 printf "\n    TEST: %-60s  [ OK ]\n" "${msg}"
 234         else
 235                 ret=1
 236                 nfail=$((nfail+1))
 237                 printf "\n    TEST: %-60s  [FAIL]\n" "${msg}"
 238                 if [ "${PAUSE_ON_FAIL}" = "yes" ]; then
 239                         echo
 240                         echo "hit enter to continue, 'q' to quit"
 241                         read a
 242                         [ "$a" = "q" ] && exit 1
 243                 fi
 244         fi
 245 }
 246
 247 print_log_test_results()
 248 {
 249         printf "\nTests passed: %3d\n" "${nsuccess}"
 250         printf "Tests failed: %3d\n"   "${nfail}"
 251
 252         # when a test fails, the value of 'ret' is set to 1 (error code).
 253         # Conversely, when all tests are passed successfully, the 'ret' value
 254         # is set to 0 (success code).
 255         if [ "${ret}" -ne 1 ]; then
 256                 ret=0
 257         fi
 258 }
 259
 260 log_section()
 261 {
 262         echo
 263         echo "################################################################################"
 264         echo "TEST SECTION: $*"
 265         echo "################################################################################"
 266 }
 267
 268 test_command_or_ksft_skip()
 269 {
 270         local cmd="$1"
 271
 272         if [ ! -x "$(command -v "${cmd}")" ]; then
 273                 echo "SKIP: Could not run test without \"${cmd}\" tool";
 274                 exit "${ksft_skip}"
 275         fi
 276 }
 277
 278 get_nodename()
 279 {
 280         local name="$1"
 281
 282         echo "${name}-${RDMSUFF}"
 283 }
 284
 285 get_rtname()
 286 {
 287         local rtid="$1"
 288
 289         get_nodename "rt-${rtid}"
 290 }
 291
 292 get_hsname()
 293 {
 294         local hsid="$1"
 295
 296         get_nodename "hs-${hsid}"
 297 }
 298
 299 __create_namespace()
 300 {
 301         local name="$1"
 302
 303         ip netns add "${name}"
 304 }
 305
 306 create_router()
 307 {
 308         local rtid="$1"
 309         local nsname
 310
 311         nsname="$(get_rtname "${rtid}")"
 312
 313         __create_namespace "${nsname}"
 314 }
 315
 316 create_host()
 317 {
 318         local hsid="$1"
 319         local nsname
 320
 321         nsname="$(get_hsname "${hsid}")"
 322
 323         __create_namespace "${nsname}"
 324 }
 325
 326 cleanup()
 327 {
 328         local nsname
 329         local i
 330
 331         # destroy routers
 332         for i in ${ROUTERS}; do
 333                 nsname="$(get_rtname "${i}")"
 334
 335                 ip netns del "${nsname}" &>/dev/null || true
 336         done
 337
 338         # destroy hosts
 339         for i in ${HOSTS}; do
 340                 nsname="$(get_hsname "${i}")"
 341
 342                 ip netns del "${nsname}" &>/dev/null || true
 343         done
 344
 345         # check whether the setup phase was completed successfully or not. In
 346         # case of an error during the setup phase of the testing environment,
 347         # the selftest is considered as "skipped".
 348         if [ "${SETUP_ERR}" -ne 0 ]; then
 349                 echo "SKIP: Setting up the testing environment failed"
 350                 exit "${ksft_skip}"
 351         fi
 352
 353         exit "${ret}"
 354 }
 355
 356 add_link_rt_pairs()
 357 {
 358         local rt="$1"
 359         local rt_neighs="$2"
 360         local neigh
 361         local nsname
 362         local neigh_nsname
 363
 364         nsname="$(get_rtname "${rt}")"
 365
 366         for neigh in ${rt_neighs}; do
 367                 neigh_nsname="$(get_rtname "${neigh}")"
 368
 369                 ip link add "veth-rt-${rt}-${neigh}" netns "${nsname}" \
 370                         type veth peer name "veth-rt-${neigh}-${rt}" \
 371                         netns "${neigh_nsname}"
 372         done
 373 }
 374
 375 get_network_prefix()
 376 {
 377         local rt="$1"
 378         local neigh="$2"
 379         local p="${rt}"
 380         local q="${neigh}"
 381
 382         if [ "${p}" -gt "${q}" ]; then
 383                 p="${q}"; q="${rt}"
 384         fi
 385
 386         echo "${IPv6_RT_NETWORK}:${p}:${q}"
 387 }
 388
 389 # Given the description of a router <id:op> as an input, the function returns
 390 # the <id> token which represents the ID of the router.
 391 # i.e. input: "12:psp"
 392 #      output: "12"
 393 __get_srv6_rtcfg_id()
 394 {
 395         local element="$1"
 396
 397         echo "${element}" | cut -d':' -f1
 398 }
 399
 400 # Given the description of a router <id:op> as an input, the function returns
 401 # the <op> token which represents the operation (e.g. End behavior with or
 402 # withouth flavors) configured for the node.
 403
 404 # Note that when the operation represents an End behavior with a list of
 405 # flavors, the output is the ordered version of that list.
 406 # i.e. input: "5:usp,psp,usd"
 407 #      output: "psp,usd,usp"
 408 __get_srv6_rtcfg_op()
 409 {
 410         local element="$1"
 411
 412         # return the lexicographically ordered flavors
 413         echo "${element}" | cut -d':' -f2 | sed 's/,/\n/g' | sort | \
 414                 xargs | sed 's/ /,/g'
 415 }
 416
 417 # Setup the basic networking for the routers
 418 setup_rt_networking()
 419 {
 420         local rt="$1"
 421         local rt_neighs="$2"
 422         local nsname
 423         local net_prefix
 424         local devname
 425         local neigh
 426
 427         nsname="$(get_rtname "${rt}")"
 428
 429         for neigh in ${rt_neighs}; do
 430                 devname="veth-rt-${rt}-${neigh}"
 431
 432                 net_prefix="$(get_network_prefix "${rt}" "${neigh}")"
 433
 434                 ip -netns "${nsname}" addr \
 435                         add "${net_prefix}::${rt}/64" dev "${devname}" nodad
 436
 437                 ip -netns "${nsname}" link set "${devname}" up
 438         done
 439
 440         ip -netns "${nsname}" link set lo up
 441
 442         ip -netns "${nsname}" link add ${DUMMY_DEVNAME} type dummy
 443         ip -netns "${nsname}" link set ${DUMMY_DEVNAME} up
 444
 445         ip netns exec "${nsname}" sysctl -wq net.ipv6.conf.all.accept_dad=0
 446         ip netns exec "${nsname}" sysctl -wq net.ipv6.conf.default.accept_dad=0
 447         ip netns exec "${nsname}" sysctl -wq net.ipv6.conf.all.forwarding=1
 448 }
 449
 450 # Setup local SIDs for an SRv6 router
 451 setup_rt_local_sids()
 452 {
 453         local rt="$1"
 454         local rt_neighs="$2"
 455         local net_prefix
 456         local devname
 457         local nsname
 458         local neigh
 459
 460         nsname="$(get_rtname "${rt}")"
 461
 462         for neigh in ${rt_neighs}; do
 463                 devname="veth-rt-${rt}-${neigh}"
 464
 465                 net_prefix="$(get_network_prefix "${rt}" "${neigh}")"
 466
 467                 # set underlay network routes for SIDs reachability
 468                 ip -netns "${nsname}" -6 route \
 469                         add "${LOCATOR_SERVICE}:${neigh}::/32" \
 470                         table "${LOCALSID_TABLE_ID}" \
 471                         via "${net_prefix}::${neigh}" dev "${devname}"
 472         done
 473
 474         # Local End behavior (note that "dev" is a dummy interface chosen for
 475         # the sake of simplicity).
 476         ip -netns "${nsname}" -6 route \
 477                 add "${LOCATOR_SERVICE}:${rt}::${END_FUNC}" \
 478                 table "${LOCALSID_TABLE_ID}" \
 479                 encap seg6local action End dev "${DUMMY_DEVNAME}"
 480
 481
 482         # all SIDs start with a common locator. Routes and SRv6 Endpoint
 483         # behavior instaces are grouped together in the 'localsid' table.
 484         ip -netns "${nsname}" -6 rule \
 485                 add to "${LOCATOR_SERVICE}::/16" \
 486                 lookup "${LOCALSID_TABLE_ID}" prio 999
 487
 488         # set default routes to unreachable
 489         ip -netns "${nsname}" -6 route \
 490                 add unreachable default metric 4278198272 \
 491                 dev "${DUMMY_DEVNAME}"
 492 }
 493
 494 # This helper function builds and installs the SID List (i.e. SRv6 Policy)
 495 # to be applied on incoming packets at the ingress node. Moreover, it
 496 # configures the SRv6 nodes specified in the SID List to process the traffic
 497 # according to the operations required by the Policy itself.
 498 # args:
 499 #  $1 - destination host (i.e. cafe::x host)
 500 #  $2 - SRv6 router configured for enforcing the SRv6 Policy
 501 #  $3 - compact way to represent a list of SRv6 routers with their operations
 502 #       (i.e. behaviors) that each of them needs to perform. Every <nodeid:op>
 503 #       element constructs a SID that is associated with the behavior <op> on
 504 #       the <nodeid> node. The list of such elements forms an SRv6 Policy.
 505 __setup_rt_policy()
 506 {
 507         local dst="$1"
 508         local encap_rt="$2"
 509         local policy_rts="$3"
 510         local behavior_cfg
 511         local in_nsname
 512         local rt_nsname
 513         local policy=''
 514         local function
 515         local fullsid
 516         local op_type
 517         local node
 518         local n
 519
 520         in_nsname="$(get_rtname "${encap_rt}")"
 521
 522         for n in ${policy_rts}; do
 523                 node="$(__get_srv6_rtcfg_id "${n}")"
 524                 op_type="$(__get_srv6_rtcfg_op "${n}")"
 525                 rt_nsname="$(get_rtname "${node}")"
 526
 527                 case "${op_type}" in
 528                 "noflv")
 529                         policy="${policy}${LOCATOR_SERVICE}:${node}::${END_FUNC},"
 530                         function="${END_FUNC}"
 531                         behavior_cfg="End"
 532                         ;;
 533
 534                 "psp")
 535                         policy="${policy}${LOCATOR_SERVICE}:${node}::${END_PSP_FUNC},"
 536                         function="${END_PSP_FUNC}"
 537                         behavior_cfg="End flavors psp"
 538                         ;;
 539
 540                 *)
 541                         break
 542                         ;;
 543                 esac
 544
 545                 fullsid="${LOCATOR_SERVICE}:${node}::${function}"
 546
 547                 # add SRv6 Endpoint behavior to the selected router
 548                 if ! ip -netns "${rt_nsname}" -6 route get "${fullsid}" \
 549                         &>/dev/null; then
 550                         ip -netns "${rt_nsname}" -6 route \
 551                                 add "${fullsid}" \
 552                                 table "${LOCALSID_TABLE_ID}" \
 553                                 encap seg6local action ${behavior_cfg} \
 554                                 dev "${DUMMY_DEVNAME}"
 555                 fi
 556         done
 557
 558         # we need to remove the trailing comma to avoid inserting an empty
 559         # address (::0) in the SID List.
 560         policy="${policy%,}"
 561
 562         # add SRv6 policy to incoming traffic sent by connected hosts
 563         ip -netns "${in_nsname}" -6 route \
 564                 add "${IPv6_HS_NETWORK}::${dst}" \
 565                 encap seg6 mode inline segs "${policy}" \
 566                 dev "${DUMMY_DEVNAME}"
 567
 568         ip -netns "${in_nsname}" -6 neigh \
 569                 add proxy "${IPv6_HS_NETWORK}::${dst}" \
 570                 dev "${RT2HS_DEVNAME}"
 571 }
 572
 573 # see __setup_rt_policy
 574 setup_rt_policy_ipv6()
 575 {
 576         __setup_rt_policy "$1" "$2" "$3"
 577 }
 578
 579 setup_hs()
 580 {
 581         local hs="$1"
 582         local rt="$2"
 583         local hsname
 584         local rtname
 585
 586         hsname="$(get_hsname "${hs}")"
 587         rtname="$(get_rtname "${rt}")"
 588
 589         ip netns exec "${hsname}" sysctl -wq net.ipv6.conf.all.accept_dad=0
 590         ip netns exec "${hsname}" sysctl -wq net.ipv6.conf.default.accept_dad=0
 591
 592         ip -netns "${hsname}" link add veth0 type veth \
 593                 peer name "${RT2HS_DEVNAME}" netns "${rtname}"
 594
 595         ip -netns "${hsname}" addr \
 596                 add "${IPv6_HS_NETWORK}::${hs}/64" dev veth0 nodad
 597
 598         ip -netns "${hsname}" link set veth0 up
 599         ip -netns "${hsname}" link set lo up
 600
 601         ip -netns "${rtname}" addr \
 602                 add "${IPv6_HS_NETWORK}::254/64" dev "${RT2HS_DEVNAME}" nodad
 603
 604         ip -netns "${rtname}" link set "${RT2HS_DEVNAME}" up
 605
 606         ip netns exec "${rtname}" \
 607                 sysctl -wq net.ipv6.conf."${RT2HS_DEVNAME}".proxy_ndp=1
 608 }
 609
 610 setup()
 611 {
 612         local i
 613
 614         # create routers
 615         ROUTERS="1 2 3 4"; readonly ROUTERS
 616         for i in ${ROUTERS}; do
 617                 create_router "${i}"
 618         done
 619
 620         # create hosts
 621         HOSTS="1 2"; readonly HOSTS
 622         for i in ${HOSTS}; do
 623                 create_host "${i}"
 624         done
 625
 626         # set up the links for connecting routers
 627         add_link_rt_pairs 1 "2 3 4"
 628         add_link_rt_pairs 2 "3 4"
 629         add_link_rt_pairs 3 "4"
 630
 631         # set up the basic connectivity of routers and routes required for
 632         # reachability of SIDs.
 633         setup_rt_networking 1 "2 3 4"
 634         setup_rt_networking 2 "1 3 4"
 635         setup_rt_networking 3 "1 2 4"
 636         setup_rt_networking 4 "1 2 3"
 637
 638         # set up the hosts connected to routers
 639         setup_hs 1 1
 640         setup_hs 2 2
 641
 642         # set up default SRv6 Endpoints (i.e. SRv6 End behavior)
 643         setup_rt_local_sids 1 "2 3 4"
 644         setup_rt_local_sids 2 "1 3 4"
 645         setup_rt_local_sids 3 "1 2 4"
 646         setup_rt_local_sids 4 "1 2 3"
 647
 648         # set up SRv6 policies
 649         # create a connection between hosts hs-1 and hs-2.
 650         # The path between hs-1 and hs-2 traverses SRv6 aware routers.
 651         # For each direction two path are chosen:
 652         #
 653         # Direction hs-1 -> hs-2 (PSP flavor)
 654         #  - rt-1 (SRv6 H.Insert policy)
 655         #  - rt-3 (SRv6 End behavior)
 656         #  - rt-4 (SRv6 End flavor PSP with SL>1, acting as End behavior)
 657         #  - rt-2 (SRv6 End flavor PSP with SL=1)
 658         #
 659         # Direction hs-2 -> hs-1 (PSP flavor)
 660         #  - rt-2 (SRv6 H.Insert policy)
 661         #  - rt-1 (SRv6 End flavor PSP with SL=1)
 662         setup_rt_policy_ipv6 2 1 "3:noflv 4:psp 2:psp"
 663         setup_rt_policy_ipv6 1 2 "1:psp"
 664
 665         # testing environment was set up successfully
 666         SETUP_ERR=0
 667 }
 668
 669 check_rt_connectivity()
 670 {
 671         local rtsrc="$1"
 672         local rtdst="$2"
 673         local prefix
 674         local rtsrc_nsname
 675
 676         rtsrc_nsname="$(get_rtname "${rtsrc}")"
 677
 678         prefix="$(get_network_prefix "${rtsrc}" "${rtdst}")"
 679
 680         ip netns exec "${rtsrc_nsname}" ping -c 1 -W "${PING_TIMEOUT_SEC}" \
 681                 "${prefix}::${rtdst}" >/dev/null 2>&1
 682 }
 683
 684 check_and_log_rt_connectivity()
 685 {
 686         local rtsrc="$1"
 687         local rtdst="$2"
 688
 689         check_rt_connectivity "${rtsrc}" "${rtdst}"
 690         log_test $? 0 "Routers connectivity: rt-${rtsrc} -> rt-${rtdst}"
 691 }
 692
 693 check_hs_ipv6_connectivity()
 694 {
 695         local hssrc="$1"
 696         local hsdst="$2"
 697         local hssrc_nsname
 698
 699         hssrc_nsname="$(get_hsname "${hssrc}")"
 700
 701         ip netns exec "${hssrc_nsname}" ping -c 1 -W "${PING_TIMEOUT_SEC}" \
 702                 "${IPv6_HS_NETWORK}::${hsdst}" >/dev/null 2>&1
 703 }
 704
 705 check_and_log_hs2gw_connectivity()
 706 {
 707         local hssrc="$1"
 708
 709         check_hs_ipv6_connectivity "${hssrc}" 254
 710         log_test $? 0 "IPv6 Hosts connectivity: hs-${hssrc} -> gw"
 711 }
 712
 713 check_and_log_hs_ipv6_connectivity()
 714 {
 715         local hssrc="$1"
 716         local hsdst="$2"
 717
 718         check_hs_ipv6_connectivity "${hssrc}" "${hsdst}"
 719         log_test $? 0 "IPv6 Hosts connectivity: hs-${hssrc} -> hs-${hsdst}"
 720 }
 721
 722 check_and_log_hs_connectivity()
 723 {
 724         local hssrc="$1"
 725         local hsdst="$2"
 726
 727         check_and_log_hs_ipv6_connectivity "${hssrc}" "${hsdst}"
 728 }
 729
 730 router_tests()
 731 {
 732         local i
 733         local j
 734
 735         log_section "IPv6 routers connectivity test"
 736
 737         for i in ${ROUTERS}; do
 738                 for j in ${ROUTERS}; do
 739                         if [ "${i}" -eq "${j}" ]; then
 740                                 continue
 741                         fi
 742
 743                         check_and_log_rt_connectivity "${i}" "${j}"
 744                 done
 745         done
 746 }
 747
 748 host2gateway_tests()
 749 {
 750         local hs
 751
 752         log_section "IPv6 connectivity test among hosts and gateways"
 753
 754         for hs in ${HOSTS}; do
 755                 check_and_log_hs2gw_connectivity "${hs}"
 756         done
 757 }
 758
 759 host_srv6_end_flv_psp_tests()
 760 {
 761         log_section "SRv6 connectivity test hosts (h1 <-> h2, PSP flavor)"
 762
 763         check_and_log_hs_connectivity 1 2
 764         check_and_log_hs_connectivity 2 1
 765 }
 766
 767 test_iproute2_supp_or_ksft_skip()
 768 {
 769         local flavor="$1"
 770
 771         if ! ip route help 2>&1 | grep -qo "${flavor}"; then
 772                 echo "SKIP: Missing SRv6 ${flavor} flavor support in iproute2"
 773                 exit "${ksft_skip}"
 774         fi
 775 }
 776
 777 test_kernel_supp_or_ksft_skip()
 778 {
 779         local flavor="$1"
 780         local test_netns
 781
 782         test_netns="kflv-$(mktemp -u XXXXXXXX)"
 783
 784         if ! ip netns add "${test_netns}"; then
 785                 echo "SKIP: Cannot set up netns to test kernel support for flavors"
 786                 exit "${ksft_skip}"
 787         fi
 788
 789         if ! ip -netns "${test_netns}" link \
 790                 add "${DUMMY_DEVNAME}" type dummy; then
 791                 echo "SKIP: Cannot set up dummy dev to test kernel support for flavors"
 792
 793                 ip netns del "${test_netns}"
 794                 exit "${ksft_skip}"
 795         fi
 796
 797         if ! ip -netns "${test_netns}" link \
 798                 set "${DUMMY_DEVNAME}" up; then
 799                 echo "SKIP: Cannot activate dummy dev to test kernel support for flavors"
 800
 801                 ip netns del "${test_netns}"
 802                 exit "${ksft_skip}"
 803         fi
 804
 805         if ! ip -netns "${test_netns}" -6 route \
 806                 add "${IPv6_TESTS_ADDR}" encap seg6local \
 807                 action End flavors "${flavor}" dev "${DUMMY_DEVNAME}"; then
 808                 echo "SKIP: ${flavor} flavor not supported in kernel"
 809
 810                 ip netns del "${test_netns}"
 811                 exit "${ksft_skip}"
 812         fi
 813
 814         ip netns del "${test_netns}"
 815 }
 816
 817 test_dummy_dev_or_ksft_skip()
 818 {
 819         local test_netns
 820
 821         test_netns="dummy-$(mktemp -u XXXXXXXX)"
 822
 823         if ! ip netns add "${test_netns}"; then
 824                 echo "SKIP: Cannot set up netns for testing dummy dev support"
 825                 exit "${ksft_skip}"
 826         fi
 827
 828         modprobe dummy &>/dev/null || true
 829         if ! ip -netns "${test_netns}" link \
 830                 add "${DUMMY_DEVNAME}" type dummy; then
 831                 echo "SKIP: dummy dev not supported"
 832
 833                 ip netns del "${test_netns}"
 834                 exit "${ksft_skip}"
 835         fi
 836
 837         ip netns del "${test_netns}"
 838 }
 839
 840 if [ "$(id -u)" -ne 0 ]; then
 841         echo "SKIP: Need root privileges"
 842         exit "${ksft_skip}"
 843 fi
 844
 845 # required programs to carry out this selftest
 846 test_command_or_ksft_skip ip
 847 test_command_or_ksft_skip ping
 848 test_command_or_ksft_skip sysctl
 849 test_command_or_ksft_skip grep
 850 test_command_or_ksft_skip cut
 851 test_command_or_ksft_skip sed
 852 test_command_or_ksft_skip sort
 853 test_command_or_ksft_skip xargs
 854
 855 test_dummy_dev_or_ksft_skip
 856 test_iproute2_supp_or_ksft_skip psp
 857 test_kernel_supp_or_ksft_skip psp
 858
 859 set -e
 860 trap cleanup EXIT
 861
 862 setup
 863 set +e
 864
 865 router_tests
 866 host2gateway_tests
 867 host_srv6_end_flv_psp_tests
 868
 869 print_log_test_results