Quelle  vrf_strict_mode_test.sh   Sprache: Shell

#!/bin/bash
# SPDX-License-Identifier: GPL-2.0

# This test is designed for testing the new VRF strict_mode functionality.

source lib.sh
ret=0

# identifies the "init" network namespace which is often called root network
# namespace.
INIT_NETNS_NAME="init"

PAUSE_ON_FAIL=${PAUSE_ON_FAIL:=no}

TESTS="init testns mix"

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()
{
 if [ "$TESTS" != "none" ]; then
  printf "\nTests passed: %3d\n" ${nsuccess}
  printf "Tests failed: %3d\n"   ${nfail}
 fi
}

log_section()
{
 echo
 echo "################################################################################"
 echo "TEST SECTION: $*"
 echo "################################################################################"
}

ip_expand_args()
{
 local nsname=$1
 local nsarg=""

 if [ "${nsname}" != "${INIT_NETNS_NAME}" ]; then
  nsarg="-netns ${nsname}"
 fi

 echo "${nsarg}"
}

vrf_count()
{
 local nsname=$1
 local nsarg="$(ip_expand_args ${nsname})"

 ip ${nsarg} -o link show type vrf | wc -l
}

count_vrf_by_table_id()
{
 local nsname=$1
 local tableid=$2
 local nsarg="$(ip_expand_args ${nsname})"

 ip ${nsarg} -d -o link show type vrf | grep "table ${tableid}" | wc -l
}

add_vrf()
{
 local nsname=$1
 local vrfname=$2
 local vrftable=$3
 local nsarg="$(ip_expand_args ${nsname})"

 ip ${nsarg} link add ${vrfname} type vrf table ${vrftable} &>/dev/null
}

add_vrf_and_check()
{
 local nsname=$1
 local vrfname=$2
 local vrftable=$3
 local cnt
 local rc

 add_vrf ${nsname} ${vrfname} ${vrftable}; rc=$?

 cnt=$(count_vrf_by_table_id ${nsname} ${vrftable})

 log_test ${rc} 0 "${nsname}: add vrf ${vrfname}, ${cnt} vrfs for table ${vrftable}"
}

add_vrf_and_check_fail()
{
 local nsname=$1
 local vrfname=$2
 local vrftable=$3
 local cnt
 local rc

 add_vrf ${nsname} ${vrfname} ${vrftable}; rc=$?

 cnt=$(count_vrf_by_table_id ${nsname} ${vrftable})

 log_test ${rc} 2 "${nsname}: CANNOT add vrf ${vrfname}, ${cnt} vrfs for table ${vrftable}"
}

del_vrf_and_check()
{
 local nsname=$1
 local vrfname=$2
 local nsarg="$(ip_expand_args ${nsname})"

 ip ${nsarg} link del ${vrfname}
 log_test $? 0 "${nsname}: remove vrf ${vrfname}"
}

config_vrf_and_check()
{
 local nsname=$1
 local addr=$2
 local vrfname=$3
 local nsarg="$(ip_expand_args ${nsname})"

 ip ${nsarg} link set dev ${vrfname} up && \
  ip ${nsarg} addr add ${addr} dev ${vrfname}
 log_test $? 0 "${nsname}: vrf ${vrfname} up, addr ${addr}"
}

read_strict_mode()
{
 local nsname=$1
 local rval
 local rc=0
 local nsexec=""

 if [ "${nsname}" != "${INIT_NETNS_NAME}" ]; then
  # a custom network namespace is provided
  nsexec="ip netns exec ${nsname}"
 fi

 rval="$(${nsexec} bash -c "cat /proc/sys/net/vrf/strict_mode" | \
  grep -E "^[0-1]$")" &> /dev/null
 if [ $? -ne 0 ]; then
  # set errors
  rval=255
  rc=1
 fi

 # on success, rval can be only 0 or 1; on error, rval is equal to 255
 echo ${rval}
 return ${rc}
}

read_strict_mode_compare_and_check()
{
 local nsname=$1
 local expected=$2
 local res

 res="$(read_strict_mode ${nsname})"
 log_test ${res} ${expected} "${nsname}: check strict_mode=${res}"
}

set_strict_mode()
{
 local nsname=$1
 local val=$2
 local nsexec=""

 if [ "${nsname}" != "${INIT_NETNS_NAME}" ]; then
  # a custom network namespace is provided
  nsexec="ip netns exec ${nsname}"
 fi

 ${nsexec} bash -c "echo ${val} >/proc/sys/net/vrf/strict_mode" &>/dev/null
}

enable_strict_mode()
{
 local nsname=$1

 set_strict_mode ${nsname} 1
}

disable_strict_mode()
{
 local nsname=$1

 set_strict_mode ${nsname} 0
}

disable_strict_mode_and_check()
{
 local nsname=$1

 disable_strict_mode ${nsname}
 log_test $? 0 "${nsname}: disable strict_mode (=0)"
}

enable_strict_mode_and_check()
{
 local nsname=$1

 enable_strict_mode ${nsname}
 log_test $? 0 "${nsname}: enable strict_mode (=1)"
}

enable_strict_mode_and_check_fail()
{
 local nsname=$1

 enable_strict_mode ${nsname}
 log_test $? 1 "${nsname}: CANNOT enable strict_mode"
}

strict_mode_check_default()
{
 local nsname=$1
 local strictmode
 local vrfcnt

 vrfcnt=$(vrf_count ${nsname})
 strictmode=$(read_strict_mode ${nsname})
 log_test ${strictmode} 0 "${nsname}: strict_mode=0 by default, ${vrfcnt} vrfs"
}

setup()
{
 modprobe vrf

 setup_ns testns
}

cleanup()
{
 ip netns del $testns 2>/dev/null

 ip link del vrf100 2>/dev/null
 ip link del vrf101 2>/dev/null
 ip link del vrf102 2>/dev/null

 echo 0 >/proc/sys/net/vrf/strict_mode 2>/dev/null
}

vrf_strict_mode_tests_init()
{
 log_section "VRF strict_mode test on init network namespace"

 vrf_strict_mode_check_support init

 strict_mode_check_default init

 add_vrf_and_check init vrf100 100
 config_vrf_and_check init 172.16.100.1/24 vrf100

 enable_strict_mode_and_check init

 add_vrf_and_check_fail init vrf101 100

 disable_strict_mode_and_check init

 add_vrf_and_check init vrf101 100
 config_vrf_and_check init 172.16.101.1/24 vrf101

 enable_strict_mode_and_check_fail init

 del_vrf_and_check init vrf101

 enable_strict_mode_and_check init

 add_vrf_and_check init vrf102 102
 config_vrf_and_check init 172.16.102.1/24 vrf102

 # the strict_modle is enabled in the init
}

vrf_strict_mode_tests_testns()
{
 log_section "VRF strict_mode test on testns network namespace"

 vrf_strict_mode_check_support $testns

 strict_mode_check_default $testns

 enable_strict_mode_and_check $testns

 add_vrf_and_check $testns vrf100 100
 config_vrf_and_check $testns 10.0.100.1/24 vrf100

 add_vrf_and_check_fail $testns vrf101 100

 add_vrf_and_check_fail $testns vrf102 100

 add_vrf_and_check $testns vrf200 200

 disable_strict_mode_and_check $testns

 add_vrf_and_check $testns vrf101 100

 add_vrf_and_check $testns vrf102 100

 #the strict_mode is disabled in the $testns
}

vrf_strict_mode_tests_mix()
{
 log_section "VRF strict_mode test mixing init and testns network namespaces"

 read_strict_mode_compare_and_check init 1

 read_strict_mode_compare_and_check $testns 0

 del_vrf_and_check $testns vrf101

 del_vrf_and_check $testns vrf102

 disable_strict_mode_and_check init

 enable_strict_mode_and_check $testns

 enable_strict_mode_and_check init
 enable_strict_mode_and_check init

 disable_strict_mode_and_check $testns
 disable_strict_mode_and_check $testns

 read_strict_mode_compare_and_check init 1

 read_strict_mode_compare_and_check $testns 0
}

################################################################################
# usage

usage()
{
 cat <<EOF
usage: ${0##*/} OPTS

 -t <test> Test(s) to run (default: all)
   (options: $TESTS)
EOF
}

################################################################################
# main

while getopts ":t:h" opt; do
 case $opt in
  t) TESTS=$OPTARG;;
  h) usage; exit 0;;
  *) usage; exit 1;;
 esac
done

vrf_strict_mode_check_support()
{
 local nsname=$1
 local output
 local rc

 output="$(lsmod | grep '^vrf' | awk '{print $1}')"
 if [ -z "${output}" ]; then
  modinfo vrf || return $?
 fi

 # we do not care about the value of the strict_mode; we only check if
 # the strict_mode parameter is available or not.
 read_strict_mode ${nsname} &>/dev/null; rc=$?
 log_test ${rc} 0 "${nsname}: net.vrf.strict_mode is available"

 return ${rc}
}

if [ "$(id -u)" -ne 0 ];then
 echo "SKIP: Need root privileges"
 exit $ksft_skip
fi

if [ ! -x "$(command -v ip)" ]; then
 echo "SKIP: Could not run test without ip tool"
 exit $ksft_skip
fi

modprobe vrf &>/dev/null
if [ ! -e /proc/sys/net/vrf/strict_mode ]; then
 echo "SKIP: vrf sysctl does not exist"
 exit $ksft_skip
fi

cleanup &> /dev/null

setup
for t in $TESTS
do
 case $t in
 vrf_strict_mode_tests_init|init) vrf_strict_mode_tests_init;;
 vrf_strict_mode_tests_testns|testns) vrf_strict_mode_tests_testns;;
 vrf_strict_mode_tests_mix|mix) vrf_strict_mode_tests_mix;;

 help) echo "Test names: $TESTS"; exit 0;;

 esac
done
cleanup

print_log_test_results

exit $ret