name : srv6_end_flavors_test.sh #!/bin/bash # SPDX-License-Identifier: GPL-2.0 # # author: Andrea Mayer <andrea.mayer@uniroma2.it> # author: Paolo Lungaroni <paolo.lungaroni@uniroma2.it> # # This script is designed to test the support for "flavors" in the SRv6 End # behavior. # # Flavors defined in RFC8986 [1] represent additional operations that can modify # or extend the existing SRv6 End, End.X and End.T behaviors. For the sake of # convenience, we report the list of flavors described in [1] hereafter: # - Penultimate Segment Pop (PSP); # - Ultimate Segment Pop (USP); # - Ultimate Segment Decapsulation (USD). # # The End, End.X, and End.T behaviors can support these flavors either # individually or in combinations. # Currently in this selftest we consider only the PSP flavor for the SRv6 End # behavior. However, it is possible to extend the script as soon as other # flavors will be supported in the kernel. # # The purpose of the PSP flavor consists in instructing the penultimate node # listed in the SRv6 policy to remove (i.e. pop) the outermost SRH from the IPv6 # header. # A PSP enabled SRv6 End behavior instance processes the SRH by: # - decrementing the Segment Left (SL) value from 1 to 0; # - copying the last SID from the SID List into the IPv6 Destination Address # (DA); # - removing the SRH from the extension headers following the IPv6 header. # # Once the SRH is removed, the IPv6 packet is forwarded to the destination using # the IPv6 DA updated during the PSP operation (i.e. the IPv6 DA corresponding # to the last SID carried by the removed SRH). # # Although the PSP flavor can be set for any SRv6 End behavior instance on any # SR node, it will be active only on such behaviors bound to a penultimate SID # for a given SRv6 policy. # SL=2 SL=1 SL=0 # | | | # For example, given the SRv6 policy (SID List := <X, Y, Z>): # - a PSP enabled SRv6 End behavior bound to SID Y will apply the PSP operation # as Segment Left (SL) is 1, corresponding to the Penultimate Segment of the # SID List; # - a PSP enabled SRv6 End behavior bound to SID X will *NOT* apply the PSP # operation as the Segment Left is 2. This behavior instance will apply the # "standard" End packet processing, ignoring the configured PSP flavor at # all. # # [1] RFC8986: https://datatracker.ietf.org/doc/html/rfc8986 # # Network topology # ================ # # The network topology used in this selftest is depicted hereafter, composed by # two hosts (hs-1, hs-2) and four routers (rt-1, rt-2, rt-3, rt-4). # Hosts hs-1 and hs-2 are connected to routers rt-1 and rt-2, respectively, # allowing them to communicate with each other. # Traffic exchanged between hs-1 and hs-2 can follow different network paths. # The network operator, through specific SRv6 Policies can steer traffic to one # path rather than another. In this selftest this is implemented as follows: # # i) The SRv6 H.Insert behavior applies SRv6 Policies on traffic received by # connected hosts. It pushes the Segment Routing Header (SRH) after the # IPv6 header. The SRH contains the SID List (i.e. SRv6 Policy) needed for # steering traffic across the segments/waypoints specified in that list; # # ii) The SRv6 End behavior advances the active SID in the SID List carried by # the SRH; # # iii) The PSP enabled SRv6 End behavior is used to remove the SRH when such # behavior is configured on a node bound to the Penultimate Segment carried # by the SID List. # # cafe::1 cafe::2 # +--------+ +--------+ # | | | | # | hs-1 | | hs-2 | # | | | | # +---+----+ +--- +---+ # cafe::/64 | | cafe::/64 # | | # +---+----+ +----+---+ # | | fcf0:0:1:2::/64 | | # | rt-1 +-------------------+ rt-2 | # | | | | # +---+----+ +----+---+ # | . . | # | fcf0:0:1:3::/64 . | # | . . | # | . . | # fcf0:0:1:4::/64 | . | fcf0:0:2:3::/64 # | . . | # | . . | # | fcf0:0:2:4::/64 . | # | . . | # +---+----+ +----+---+ # | | | | # | rt-4 +-------------------+ rt-3 | # | | fcf0:0:3:4::/64 | | # +---+----+ +----+---+ # # Every fcf0:0:x:y::/64 network interconnects the SRv6 routers rt-x with rt-y in # the IPv6 operator network. # # # Local SID table # =============== # # Each SRv6 router is configured with a Local SID table in which SIDs are # stored. Considering the given SRv6 router rt-x, at least two SIDs are # configured in the Local SID table: # # Local SID table for SRv6 router rt-x # +---------------------------------------------------------------------+ # |fcff:x::e is associated with the SRv6 End behavior | # |fcff:x::ef1 is associated with the SRv6 End behavior with PSP flavor | # +---------------------------------------------------------------------+ # # The fcff::/16 prefix is reserved by the operator for the SIDs. Reachability of # SIDs is ensured by proper configuration of the IPv6 operator's network and # SRv6 routers. # # # SRv6 Policies # ============= # # An SRv6 ingress router applies different SRv6 Policies to the traffic received # from connected hosts on the basis of the destination addresses. # In case of SRv6 H.Insert behavior, the SRv6 Policy enforcement consists of # pushing the SRH (carrying a given SID List) after the existing IPv6 header. # Note that in the inserting mode, there is no encapsulation at all. # # Before applying an SRv6 Policy using the SRv6 H.Insert behavior # +------+---------+ # | IPv6 | Payload | # +------+---------+ # # After applying an SRv6 Policy using the SRv6 H.Insert behavior # +------+-----+---------+ # | IPv6 | SRH | Payload | # +------+-----+---------+ # # Traffic from hs-1 to hs-2 # ------------------------- # # Packets generated from hs-1 and directed towards hs-2 are # handled by rt-1 which applies the following SRv6 Policy: # # i.a) IPv6 traffic, SID List=fcff:3::e,fcff:4::ef1,fcff:2::ef1,cafe::2 # # Router rt-1 is configured to enforce the Policy (i.a) through the SRv6 # H.Insert behavior which pushes the SRH after the existing IPv6 header. This # Policy steers the traffic from hs-1 across rt-3, rt-4, rt-2 and finally to the # destination hs-2. # # As the packet reaches the router rt-3, the SRv6 End behavior bound to SID # fcff:3::e is triggered. The behavior updates the Segment Left (from SL=3 to # SL=2) in the SRH, the IPv6 DA with fcff:4::ef1 and forwards the packet to the # next router on the path, i.e. rt-4. # # When router rt-4 receives the packet, the PSP enabled SRv6 End behavior bound # to SID fcff:4::ef1 is executed. Since the SL=2, the PSP operation is *NOT* # kicked in and the behavior applies the default End processing: the Segment # Left is decreased (from SL=2 to SL=1), the IPv6 DA is updated with the SID # fcff:2::ef1 and the packet is forwarded to router rt-2. # # The PSP enabled SRv6 End behavior on rt-2 is associated with SID fcff:2::ef1 # and is executed as the packet is received. Because SL=1, the behavior applies # the PSP processing on the packet as follows: i) SL is decreased, i.e. from # SL=1 to SL=0; ii) last SID (cafe::2) is copied into the IPv6 DA; iii) the # outermost SRH is removed from the extension headers following the IPv6 header. # Once the PSP processing is completed, the packet is forwarded to the host hs-2 # (destination). # # Traffic from hs-2 to hs-1 # ------------------------- # # Packets generated from hs-2 and directed to hs-1 are handled by rt-2 which # applies the following SRv6 Policy: # # i.b) IPv6 traffic, SID List=fcff:1::ef1,cafe::1 # # Router rt-2 is configured to enforce the Policy (i.b) through the SRv6 # H.Insert behavior which pushes the SRH after the existing IPv6 header. This # Policy steers the traffic from hs-2 across rt-1 and finally to the # destination hs-1 # # # When the router rt-1 receives the packet, the PSP enabled SRv6 End behavior # associated with the SID fcff:1::ef1 is triggered. Since the SL=1, # the PSP operation takes place: i) the SL is decremented; ii) the IPv6 DA is # set with the last SID; iii) the SRH is removed from the extension headers # after the IPv6 header. At this point, the packet with IPv6 DA=cafe::1 is sent # to the destination, i.e. hs-1. # Kselftest framework requirement - SKIP code is 4. readonly ksft_skip=4 readonly RDMSUFF="$(mktemp -u XXXXXXXX)" readonly DUMMY_DEVNAME="dum0" readonly RT2HS_DEVNAME="veth1" readonly LOCALSID_TABLE_ID=90 readonly IPv6_RT_NETWORK=fcf0:0 readonly IPv6_HS_NETWORK=cafe readonly IPv6_TESTS_ADDR=2001:db8::1 readonly LOCATOR_SERVICE=fcff readonly END_FUNC=000e readonly END_PSP_FUNC=0ef1 PING_TIMEOUT_SEC=4 PAUSE_ON_FAIL=${PAUSE_ON_FAIL:=no} # IDs of routers and hosts are initialized during the setup of the testing # network ROUTERS='' HOSTS='' SETUP_ERR=1 ret=${ksft_skip} nsuccess=0 nfail=0 log_test() { local rc="$1" local expected="$2" local msg="$3" if [ "${rc}" -eq "${expected}" ]; then nsuccess=$((nsuccess+1)) printf "\n TEST: %-60s [ OK ]\n" "${msg}" else ret=1 nfail=$((nfail+1)) printf "\n TEST: %-60s [FAIL]\n" "${msg}" if [ "${PAUSE_ON_FAIL}" = "yes" ]; then echo echo "hit enter to continue, 'q' to quit" read a [ "$a" = "q" ] && exit 1 fi fi } print_log_test_results() { printf "\nTests passed: %3d\n" "${nsuccess}" printf "Tests failed: %3d\n" "${nfail}" # when a test fails, the value of 'ret' is set to 1 (error code). # Conversely, when all tests are passed successfully, the 'ret' value # is set to 0 (success code). if [ "${ret}" -ne 1 ]; then ret=0 fi } log_section() { echo echo "################################################################################" echo "TEST SECTION: $*" echo "################################################################################" } test_command_or_ksft_skip() { local cmd="$1" if [ ! -x "$(command -v "${cmd}")" ]; then echo "SKIP: Could not run test without \"${cmd}\" tool"; exit "${ksft_skip}" fi } get_nodename() { local name="$1" echo "${name}-${RDMSUFF}" } get_rtname() { local rtid="$1" get_nodename "rt-${rtid}" } get_hsname() { local hsid="$1" get_nodename "hs-${hsid}" } __create_namespace() { local name="$1" ip netns add "${name}" } create_router() { local rtid="$1" local nsname nsname="$(get_rtname "${rtid}")" __create_namespace "${nsname}" } create_host() { local hsid="$1" local nsname nsname="$(get_hsname "${hsid}")" __create_namespace "${nsname}" } cleanup() { local nsname local i # destroy routers for i in ${ROUTERS}; do nsname="$(get_rtname "${i}")" ip netns del "${nsname}" &>/dev/null || true done # destroy hosts for i in ${HOSTS}; do nsname="$(get_hsname "${i}")" ip netns del "${nsname}" &>/dev/null || true done # check whether the setup phase was completed successfully or not. In # case of an error during the setup phase of the testing environment, # the selftest is considered as "skipped". if [ "${SETUP_ERR}" -ne 0 ]; then echo "SKIP: Setting up the testing environment failed" exit "${ksft_skip}" fi exit "${ret}" } add_link_rt_pairs() { local rt="$1" local rt_neighs="$2" local neigh local nsname local neigh_nsname nsname="$(get_rtname "${rt}")" for neigh in ${rt_neighs}; do neigh_nsname="$(get_rtname "${neigh}")" ip link add "veth-rt-${rt}-${neigh}" netns "${nsname}" \ type veth peer name "veth-rt-${neigh}-${rt}" \ netns "${neigh_nsname}" done } get_network_prefix() { local rt="$1" local neigh="$2" local p="${rt}" local q="${neigh}" if [ "${p}" -gt "${q}" ]; then p="${q}"; q="${rt}" fi echo "${IPv6_RT_NETWORK}:${p}:${q}" } # Given the description of a router <id:op> as an input, the function returns # the <id> token which represents the ID of the router. # i.e. input: "12:psp" # output: "12" __get_srv6_rtcfg_id() { local element="$1" echo "${element}" | cut -d':' -f1 } # Given the description of a router <id:op> as an input, the function returns # the <op> token which represents the operation (e.g. End behavior with or # withouth flavors) configured for the node. # Note that when the operation represents an End behavior with a list of # flavors, the output is the ordered version of that list. # i.e. input: "5:usp,psp,usd" # output: "psp,usd,usp" __get_srv6_rtcfg_op() { local element="$1" # return the lexicographically ordered flavors echo "${element}" | cut -d':' -f2 | sed 's/,/\n/g' | sort | \ xargs | sed 's/ /,/g' } # Setup the basic networking for the routers setup_rt_networking() { local rt="$1" local rt_neighs="$2" local nsname local net_prefix local devname local neigh nsname="$(get_rtname "${rt}")" for neigh in ${rt_neighs}; do devname="veth-rt-${rt}-${neigh}" net_prefix="$(get_network_prefix "${rt}" "${neigh}")" ip -netns "${nsname}" addr \ add "${net_prefix}::${rt}/64" dev "${devname}" nodad ip -netns "${nsname}" link set "${devname}" up done ip -netns "${nsname}" link set lo up ip -netns "${nsname}" link add ${DUMMY_DEVNAME} type dummy ip -netns "${nsname}" link set ${DUMMY_DEVNAME} up ip netns exec "${nsname}" sysctl -wq net.ipv6.conf.all.accept_dad=0 ip netns exec "${nsname}" sysctl -wq net.ipv6.conf.default.accept_dad=0 ip netns exec "${nsname}" sysctl -wq net.ipv6.conf.all.forwarding=1 } # Setup local SIDs for an SRv6 router setup_rt_local_sids() { local rt="$1" local rt_neighs="$2" local net_prefix local devname local nsname local neigh nsname="$(get_rtname "${rt}")" for neigh in ${rt_neighs}; do devname="veth-rt-${rt}-${neigh}" net_prefix="$(get_network_prefix "${rt}" "${neigh}")" # set underlay network routes for SIDs reachability ip -netns "${nsname}" -6 route \ add "${LOCATOR_SERVICE}:${neigh}::/32" \ table "${LOCALSID_TABLE_ID}" \ via "${net_prefix}::${neigh}" dev "${devname}" done # Local End behavior (note that "dev" is a dummy interface chosen for # the sake of simplicity). ip -netns "${nsname}" -6 route \ add "${LOCATOR_SERVICE}:${rt}::${END_FUNC}" \ table "${LOCALSID_TABLE_ID}" \ encap seg6local action End dev "${DUMMY_DEVNAME}" # all SIDs start with a common locator. Routes and SRv6 Endpoint # behavior instaces are grouped together in the 'localsid' table. ip -netns "${nsname}" -6 rule \ add to "${LOCATOR_SERVICE}::/16" \ lookup "${LOCALSID_TABLE_ID}" prio 999 # set default routes to unreachable ip -netns "${nsname}" -6 route \ add unreachable default metric 4278198272 \ dev "${DUMMY_DEVNAME}" } # This helper function builds and installs the SID List (i.e. SRv6 Policy) # to be applied on incoming packets at the ingress node. Moreover, it # configures the SRv6 nodes specified in the SID List to process the traffic # according to the operations required by the Policy itself. # args: # $1 - destination host (i.e. cafe::x host) # $2 - SRv6 router configured for enforcing the SRv6 Policy # $3 - compact way to represent a list of SRv6 routers with their operations # (i.e. behaviors) that each of them needs to perform. Every <nodeid:op> # element constructs a SID that is associated with the behavior <op> on # the <nodeid> node. The list of such elements forms an SRv6 Policy. __setup_rt_policy() { local dst="$1" local encap_rt="$2" local policy_rts="$3" local behavior_cfg local in_nsname local rt_nsname local policy='' local function local fullsid local op_type local node local n in_nsname="$(get_rtname "${encap_rt}")" for n in ${policy_rts}; do node="$(__get_srv6_rtcfg_id "${n}")" op_type="$(__get_srv6_rtcfg_op "${n}")" rt_nsname="$(get_rtname "${node}")" case "${op_type}" in "noflv") policy="${policy}${LOCATOR_SERVICE}:${node}::${END_FUNC}," function="${END_FUNC}" behavior_cfg="End" ;; "psp") policy="${policy}${LOCATOR_SERVICE}:${node}::${END_PSP_FUNC}," function="${END_PSP_FUNC}" behavior_cfg="End flavors psp" ;; *) break ;; esac fullsid="${LOCATOR_SERVICE}:${node}::${function}" # add SRv6 Endpoint behavior to the selected router if ! ip -netns "${rt_nsname}" -6 route get "${fullsid}" \ &>/dev/null; then ip -netns "${rt_nsname}" -6 route \ add "${fullsid}" \ table "${LOCALSID_TABLE_ID}" \ encap seg6local action ${behavior_cfg} \ dev "${DUMMY_DEVNAME}" fi done # we need to remove the trailing comma to avoid inserting an empty # address (::0) in the SID List. policy="${policy%,}" # add SRv6 policy to incoming traffic sent by connected hosts ip -netns "${in_nsname}" -6 route \ add "${IPv6_HS_NETWORK}::${dst}" \ encap seg6 mode inline segs "${policy}" \ dev "${DUMMY_DEVNAME}" ip -netns "${in_nsname}" -6 neigh \ add proxy "${IPv6_HS_NETWORK}::${dst}" \ dev "${RT2HS_DEVNAME}" } # see __setup_rt_policy setup_rt_policy_ipv6() { __setup_rt_policy "$1" "$2" "$3" } setup_hs() { local hs="$1" local rt="$2" local hsname local rtname hsname="$(get_hsname "${hs}")" rtname="$(get_rtname "${rt}")" ip netns exec "${hsname}" sysctl -wq net.ipv6.conf.all.accept_dad=0 ip netns exec "${hsname}" sysctl -wq net.ipv6.conf.default.accept_dad=0 ip -netns "${hsname}" link add veth0 type veth \ peer name "${RT2HS_DEVNAME}" netns "${rtname}" ip -netns "${hsname}" addr \ add "${IPv6_HS_NETWORK}::${hs}/64" dev veth0 nodad ip -netns "${hsname}" link set veth0 up ip -netns "${hsname}" link set lo up ip -netns "${rtname}" addr \ add "${IPv6_HS_NETWORK}::254/64" dev "${RT2HS_DEVNAME}" nodad ip -netns "${rtname}" link set "${RT2HS_DEVNAME}" up ip netns exec "${rtname}" \ sysctl -wq net.ipv6.conf."${RT2HS_DEVNAME}".proxy_ndp=1 } setup() { local i # create routers ROUTERS="1 2 3 4"; readonly ROUTERS for i in ${ROUTERS}; do create_router "${i}" done # create hosts HOSTS="1 2"; readonly HOSTS for i in ${HOSTS}; do create_host "${i}" done # set up the links for connecting routers add_link_rt_pairs 1 "2 3 4" add_link_rt_pairs 2 "3 4" add_link_rt_pairs 3 "4" # set up the basic connectivity of routers and routes required for # reachability of SIDs. setup_rt_networking 1 "2 3 4" setup_rt_networking 2 "1 3 4" setup_rt_networking 3 "1 2 4" setup_rt_networking 4 "1 2 3" # set up the hosts connected to routers setup_hs 1 1 setup_hs 2 2 # set up default SRv6 Endpoints (i.e. SRv6 End behavior) setup_rt_local_sids 1 "2 3 4" setup_rt_local_sids 2 "1 3 4" setup_rt_local_sids 3 "1 2 4" setup_rt_local_sids 4 "1 2 3" # set up SRv6 policies # create a connection between hosts hs-1 and hs-2. # The path between hs-1 and hs-2 traverses SRv6 aware routers. # For each direction two path are chosen: # # Direction hs-1 -> hs-2 (PSP flavor) # - rt-1 (SRv6 H.Insert policy) # - rt-3 (SRv6 End behavior) # - rt-4 (SRv6 End flavor PSP with SL>1, acting as End behavior) # - rt-2 (SRv6 End flavor PSP with SL=1) # # Direction hs-2 -> hs-1 (PSP flavor) # - rt-2 (SRv6 H.Insert policy) # - rt-1 (SRv6 End flavor PSP with SL=1) setup_rt_policy_ipv6 2 1 "3:noflv 4:psp 2:psp" setup_rt_policy_ipv6 1 2 "1:psp" # testing environment was set up successfully SETUP_ERR=0 } check_rt_connectivity() { local rtsrc="$1" local rtdst="$2" local prefix local rtsrc_nsname rtsrc_nsname="$(get_rtname "${rtsrc}")" prefix="$(get_network_prefix "${rtsrc}" "${rtdst}")" ip netns exec "${rtsrc_nsname}" ping -c 1 -W "${PING_TIMEOUT_SEC}" \ "${prefix}::${rtdst}" >/dev/null 2>&1 } check_and_log_rt_connectivity() { local rtsrc="$1" local rtdst="$2" check_rt_connectivity "${rtsrc}" "${rtdst}" log_test $? 0 "Routers connectivity: rt-${rtsrc} -> rt-${rtdst}" } check_hs_ipv6_connectivity() { local hssrc="$1" local hsdst="$2" local hssrc_nsname hssrc_nsname="$(get_hsname "${hssrc}")" ip netns exec "${hssrc_nsname}" ping -c 1 -W "${PING_TIMEOUT_SEC}" \ "${IPv6_HS_NETWORK}::${hsdst}" >/dev/null 2>&1 } check_and_log_hs2gw_connectivity() { local hssrc="$1" check_hs_ipv6_connectivity "${hssrc}" 254 log_test $? 0 "IPv6 Hosts connectivity: hs-${hssrc} -> gw" } check_and_log_hs_ipv6_connectivity() { local hssrc="$1" local hsdst="$2" check_hs_ipv6_connectivity "${hssrc}" "${hsdst}" log_test $? 0 "IPv6 Hosts connectivity: hs-${hssrc} -> hs-${hsdst}" } check_and_log_hs_connectivity() { local hssrc="$1" local hsdst="$2" check_and_log_hs_ipv6_connectivity "${hssrc}" "${hsdst}" } router_tests() { local i local j log_section "IPv6 routers connectivity test" for i in ${ROUTERS}; do for j in ${ROUTERS}; do if [ "${i}" -eq "${j}" ]; then continue fi check_and_log_rt_connectivity "${i}" "${j}" done done } host2gateway_tests() { local hs log_section "IPv6 connectivity test among hosts and gateways" for hs in ${HOSTS}; do check_and_log_hs2gw_connectivity "${hs}" done } host_srv6_end_flv_psp_tests() { log_section "SRv6 connectivity test hosts (h1 <-> h2, PSP flavor)" check_and_log_hs_connectivity 1 2 check_and_log_hs_connectivity 2 1 } test_iproute2_supp_or_ksft_skip() { local flavor="$1" if ! ip route help 2>&1 | grep -qo "${flavor}"; then echo "SKIP: Missing SRv6 ${flavor} flavor support in iproute2" exit "${ksft_skip}" fi } test_kernel_supp_or_ksft_skip() { local flavor="$1" local test_netns test_netns="kflv-$(mktemp -u XXXXXXXX)" if ! ip netns add "${test_netns}"; then echo "SKIP: Cannot set up netns to test kernel support for flavors" exit "${ksft_skip}" fi if ! ip -netns "${test_netns}" link \ add "${DUMMY_DEVNAME}" type dummy; then echo "SKIP: Cannot set up dummy dev to test kernel support for flavors" ip netns del "${test_netns}" exit "${ksft_skip}" fi if ! ip -netns "${test_netns}" link \ set "${DUMMY_DEVNAME}" up; then echo "SKIP: Cannot activate dummy dev to test kernel support for flavors" ip netns del "${test_netns}" exit "${ksft_skip}" fi if ! ip -netns "${test_netns}" -6 route \ add "${IPv6_TESTS_ADDR}" encap seg6local \ action End flavors "${flavor}" dev "${DUMMY_DEVNAME}"; then echo "SKIP: ${flavor} flavor not supported in kernel" ip netns del "${test_netns}" exit "${ksft_skip}" fi ip netns del "${test_netns}" } test_dummy_dev_or_ksft_skip() { local test_netns test_netns="dummy-$(mktemp -u XXXXXXXX)" if ! ip netns add "${test_netns}"; then echo "SKIP: Cannot set up netns for testing dummy dev support" exit "${ksft_skip}" fi modprobe dummy &>/dev/null || true if ! ip -netns "${test_netns}" link \ add "${DUMMY_DEVNAME}" type dummy; then echo "SKIP: dummy dev not supported" ip netns del "${test_netns}" exit "${ksft_skip}" fi ip netns del "${test_netns}" } if [ "$(id -u)" -ne 0 ]; then echo "SKIP: Need root privileges" exit "${ksft_skip}" fi # required programs to carry out this selftest test_command_or_ksft_skip ip test_command_or_ksft_skip ping test_command_or_ksft_skip sysctl test_command_or_ksft_skip grep test_command_or_ksft_skip cut test_command_or_ksft_skip sed test_command_or_ksft_skip sort test_command_or_ksft_skip xargs test_dummy_dev_or_ksft_skip test_iproute2_supp_or_ksft_skip psp test_kernel_supp_or_ksft_skip psp set -e trap cleanup EXIT setup set +e router_tests host2gateway_tests host_srv6_end_flv_psp_tests print_log_test_results