+proc_net_pktgen

+so_rcv_listener

+ rtnetlink.sh xfrm_policy.sh

+TEST_PROGS += test_so_rcv.sh

+TEST_PROGS += cmsg_time.sh cmsg_ip.sh

+TEST_PROGS += link_netns.py

+TEST_PROGS += rtnetlink.py

+TEST_GEN_FILES += so_rcv_listener

+TEST_GEN_PROGS += proc_net_pktgen

+ nmaps = None

+ nmaps = len(maps)

+ if nmaps == expected:

+ 'libbpf_global',

+#!/bin/bash

+# SPDX-License-Identifier: GPL-2.0

+

+source lib.sh

+

+IP4=172.16.0.1/24

+TGT4=172.16.0.2

+IP6=2001:db8:1::1/64

+TGT6=2001:db8:1::2

+TMPF=$(mktemp --suffix ".pcap")

+

+cleanup()

+{

+ rm -f $TMPF

+ cleanup_ns $NS

+}

+

+trap cleanup EXIT

+

+tcpdump -h | grep immediate-mode >> /dev/null

+if [ $? -ne 0 ]; then

+ echo "SKIP - tcpdump with --immediate-mode option required"

+ exit $ksft_skip

+fi

+

+# Namespaces

+setup_ns NS

+NSEXE="ip netns exec $NS"

+

+$NSEXE sysctl -w net.ipv4.ping_group_range='0 2147483647' > /dev/null

+

+# Connectivity

+ip -netns $NS link add type dummy

+ip -netns $NS link set dev dummy0 up

+ip -netns $NS addr add $IP4 dev dummy0

+ip -netns $NS addr add $IP6 dev dummy0

+

+# Test

+BAD=0

+TOTAL=0

+

+check_result() {

+ ((TOTAL++))

+ if [ $1 -ne $2 ]; then

+ echo " Case $3 returned $1, expected $2"

+ ((BAD++))

+ fi

+}

+

+# IPV6_DONTFRAG

+for ovr in setsock cmsg both diff; do

+ for df in 0 1; do

+ for p in u U i r; do

+ [ $p == "u" ] && prot=UDP

+ [ $p == "U" ] && prot=UDP

+ [ $p == "i" ] && prot=ICMP

+ [ $p == "r" ] && prot=RAW

+

+ [ $ovr == "setsock" ] && m="-F $df"

+ [ $ovr == "cmsg" ] && m="-f $df"

+ [ $ovr == "both" ] && m="-F $df -f $df"

+ [ $ovr == "diff" ] && m="-F $((1 - df)) -f $df"

+

+ $NSEXE ./cmsg_sender -s -S 2000 -6 -p $p $m $TGT6 1234

+ check_result $? $df "DONTFRAG $prot $ovr"

+ done

+ done

+done

+

+# IP_TOS + IPV6_TCLASS

+

+test_dscp() {

+ local -r IPVER=$1

+ local -r TGT=$2

+ local -r MATCH=$3

+

+ local -r TOS=0x10

+ local -r TOS2=0x20

+ local -r ECN=0x3

+

+ ip $IPVER -netns $NS rule add tos $TOS lookup 300

+ ip $IPVER -netns $NS route add table 300 prohibit any

+

+ for ovr in setsock cmsg both diff; do

+ for p in u U i r; do

+ [ $p == "u" ] && prot=UDP

+ [ $p == "U" ] && prot=UDP

+ [ $p == "i" ] && prot=ICMP

+ [ $p == "r" ] && prot=RAW

+

+ [ $ovr == "setsock" ] && m="-C"

+ [ $ovr == "cmsg" ] && m="-c"

+ [ $ovr == "both" ] && m="-C $((TOS2)) -c"

+ [ $ovr == "diff" ] && m="-C $((TOS )) -c"

+

+ $NSEXE nohup tcpdump --immediate-mode -p -ni dummy0 -w $TMPF -c 4 2> /dev/null &

+ BG=$!

+ sleep 0.05

+

+ $NSEXE ./cmsg_sender $IPVER -p $p $m $((TOS2)) $TGT 1234

+ check_result $? 0 "$MATCH $prot $ovr - pass"

+

+ while [ -d /proc/$BG ]; do

+ $NSEXE ./cmsg_sender $IPVER -p $p $m $((TOS2)) $TGT 1234

+ done

+

+ tcpdump -r $TMPF -v 2>&1 | grep "$MATCH $TOS2" >> /dev/null

+ check_result $? 0 "$MATCH $prot $ovr - packet data"

+ rm $TMPF

+

+ [ $ovr == "both" ] && m="-C $((TOS )) -c"

+ [ $ovr == "diff" ] && m="-C $((TOS2)) -c"

+

+ # Match prohibit rule: expect failure

+ $NSEXE ./cmsg_sender $IPVER -p $p $m $((TOS)) -s $TGT 1234

+ check_result $? 1 "$MATCH $prot $ovr - rejection"

+

+ # Match prohibit rule: IPv4 masks ECN: expect failure

+ if [[ "$IPVER" == "-4" ]]; then

+ $NSEXE ./cmsg_sender $IPVER -p $p $m "$((TOS | ECN))" -s $TGT 1234

+ check_result $? 1 "$MATCH $prot $ovr - rejection (ECN)"

+ fi

+ done

+ done

+}

+

+test_dscp -4 $TGT4 tos

+test_dscp -6 $TGT6 class

+

+# IP_TTL + IPV6_HOPLIMIT

+test_ttl_hoplimit() {

+ local -r IPVER=$1

+ local -r TGT=$2

+ local -r MATCH=$3

+

+ local -r LIM=4

+

+ for ovr in setsock cmsg both diff; do

+ for p in u U i r; do

+ [ $p == "u" ] && prot=UDP

+ [ $p == "U" ] && prot=UDP

+ [ $p == "i" ] && prot=ICMP

+ [ $p == "r" ] && prot=RAW

+

+ [ $ovr == "setsock" ] && m="-L"

+ [ $ovr == "cmsg" ] && m="-l"

+ [ $ovr == "both" ] && m="-L $LIM -l"

+ [ $ovr == "diff" ] && m="-L $((LIM + 1)) -l"

+

+ $NSEXE nohup tcpdump --immediate-mode -p -ni dummy0 -w $TMPF -c 4 2> /dev/null &

+ BG=$!

+ sleep 0.05

+

+ $NSEXE ./cmsg_sender $IPVER -p $p $m $LIM $TGT 1234

+ check_result $? 0 "$MATCH $prot $ovr - pass"

+

+ while [ -d /proc/$BG ]; do

+ $NSEXE ./cmsg_sender $IPVER -p $p $m $LIM $TGT 1234

+ done

+

+ tcpdump -r $TMPF -v 2>&1 | grep "$MATCH $LIM[^0-9]" >> /dev/null

+ check_result $? 0 "$MATCH $prot $ovr - packet data"

+ rm $TMPF

+ done

+ done

+}

+

+test_ttl_hoplimit -4 $TGT4 ttl

+test_ttl_hoplimit -6 $TGT6 hlim

+

+# IPV6 exthdr

+for p in u U i r; do

+ # Very basic "does it crash" test

+ for h in h d r; do

+ $NSEXE ./cmsg_sender -p $p -6 -H $h $TGT6 1234

+ check_result $? 0 "ExtHdr $prot $ovr - pass"

+ done

+done

+

+# Summary

+if [ $BAD -ne 0 ]; then

+ echo "FAIL - $BAD/$TOTAL cases failed"

+ exit 1

+else

+ echo "OK"

+ exit 0

+fi

+ ERN_SEND_MORE,

+ bool msg_more;

+ } cmsg;

+ "\t\t (u = UDP (default); i = ICMP; r = RAW;\n"

+ "\t\t U = UDP with MSG_MORE)\n"

+ "\t\t-c val Set TOS/TCLASS via cmsg\n"

+ "\t\t-C val Set TOS/TCLASS via setsockopt\n"

+ "\t\t-l val Set TTL/HOPLIMIT via cmsg\n"

+ "\t\t-L val Set TTL/HOPLIMIT via setsockopt\n"

+ "\t\t (h = HOP; d = DST; r = RTDST)\n"

+ "\n");

+ if (*optarg == 'u') {

+ } else if (*optarg == 'U') {

+ opt.sock.proto = IPPROTO_UDP;

+ opt.msg_more = true;

+ opt.cmsg.dontfrag.ena = true;

+ opt.cmsg.dontfrag.val = atoi(optarg);

+ opt.cmsg.tclass.ena = true;

+ opt.cmsg.tclass.val = atoi(optarg);

+ opt.cmsg.hlimit.ena = true;

+ opt.cmsg.hlimit.val = atoi(optarg);

+ opt.cmsg.exthdr.ena = true;

+ opt.cmsg.exthdr.val = IPV6_HOPOPTS;

+ opt.cmsg.exthdr.val = IPV6_DSTOPTS;

+ opt.cmsg.exthdr.val = IPV6_RTHDRDSTOPTS;

+

+ if (opt.sock.family == AF_INET) {

+ ca_write_cmsg_u32(cbuf, cbuf_sz, &cmsg_len,

+ SOL_IP, IP_TOS, &opt.cmsg.tclass);

+ ca_write_cmsg_u32(cbuf, cbuf_sz, &cmsg_len,

+ SOL_IP, IP_TTL, &opt.cmsg.hlimit);

+ } else {

+ ca_write_cmsg_u32(cbuf, cbuf_sz, &cmsg_len,

+ SOL_IPV6, IPV6_DONTFRAG, &opt.cmsg.dontfrag);

+ ca_write_cmsg_u32(cbuf, cbuf_sz, &cmsg_len,

+ SOL_IPV6, IPV6_TCLASS, &opt.cmsg.tclass);

+ ca_write_cmsg_u32(cbuf, cbuf_sz, &cmsg_len,

+ SOL_IPV6, IPV6_HOPLIMIT, &opt.cmsg.hlimit);

+ }

+ if (opt.cmsg.exthdr.ena) {

+ cmsg->cmsg_type = opt.cmsg.exthdr.val;

+ if (opt.sock.family == AF_INET) {

+ if (opt.sockopt.tclass &&

+ setsockopt(fd, SOL_IP, IP_TOS,

+ &opt.sockopt.tclass, sizeof(opt.sockopt.tclass)))

+ error(ERN_SOCKOPT, errno, "setsockopt IP_TOS");

+ if (opt.sockopt.hlimit &&

+ setsockopt(fd, SOL_IP, IP_TTL,

+ &opt.sockopt.hlimit, sizeof(opt.sockopt.hlimit)))

+ error(ERN_SOCKOPT, errno, "setsockopt IP_TTL");

+ } else {

+ if (opt.sockopt.dontfrag &&

+ setsockopt(fd, SOL_IPV6, IPV6_DONTFRAG,

+ &opt.sockopt.dontfrag, sizeof(opt.sockopt.dontfrag)))

+ error(ERN_SOCKOPT, errno, "setsockopt IPV6_DONTFRAG");

+ if (opt.sockopt.tclass &&

+ setsockopt(fd, SOL_IPV6, IPV6_TCLASS,

+ &opt.sockopt.tclass, sizeof(opt.sockopt.tclass)))

+ error(ERN_SOCKOPT, errno, "setsockopt IPV6_TCLASS");

+ if (opt.sockopt.hlimit &&

+ setsockopt(fd, SOL_IPV6, IPV6_UNICAST_HOPS,

+ &opt.sockopt.hlimit, sizeof(opt.sockopt.hlimit)))

+ error(ERN_SOCKOPT, errno, "setsockopt IPV6_HOPLIMIT");

+ }

+

+ err = sendmsg(fd, &msg, opt.msg_more ? MSG_MORE : 0);

+ if (opt.msg_more) {

+ err = write(fd, NULL, 0);

+ if (err < 0) {

+ fprintf(stderr, "send more: %s\n", strerror(errno));

+ err = ERN_SEND_MORE;

+ goto err_out;

+ }

+ }

+CONFIG_DEBUG_INFO_BTF=y

+CONFIG_DEBUG_INFO_BTF_MODULES=n

+CONFIG_IPVLAN=m

+CONFIG_CAN=m

+CONFIG_CAN_DEV=m

+CONFIG_CAN_VXCAN=m

+CONFIG_NETKIT=y

+CONFIG_NET_PKTGEN=m

+ show_hint "Technically should fail since address is not on device but kernel allows"

+ show_hint "Technically should fail since address is not on device but kernel allows"

+ # For multicast FDB entries, the VXLAN driver stores a linked list of

+ [[ $ret -eq 0 ]] && ret=$ksft_skip

+ nskip=$((nskip+1))

+ ret=1

+ nfail=$((nfail+1))

+ # gw is not reachable through given dev

+ printf "Tests skipped: %2d\n" ${nskip}

+

+ match="sport 100-200 dport 300-400"

+ getmatch="sport 100 dport 400"

+ getnomatch="sport 100 dport 401"

+ fib_rule6_test_match_n_redirect "$match" "$getmatch" \

+ "$getnomatch" \

+ "sport and dport range redirect to table" \

+ "sport and dport range no redirect to table"

+ fi

+

+ ip rule help 2>&1 | grep sport | grep -q MASK

+ if [ $? -eq 0 ]; then

+ match="sport 0x0f00/0xff00 dport 0x000f/0x00ff"

+ getmatch="sport 0x0f11 dport 0x220f"

+ getnomatch="sport 0x1f11 dport 0x221f"

+ fib_rule6_test_match_n_redirect "$match" "$getmatch" \

+ "$getnomatch" "sport and dport masked redirect to table" \

+ "sport and dport masked no redirect to table"

+ ip rule help 2>&1 | grep -q "DSCP\[/MASK\]"

+ if [ $? -eq 0 ]; then

+ match="dscp 0x0f/0x0f"

+ tosmatch=$(printf 0x"%x" $((0x1f << 2)))

+ tosnomatch=$(printf 0x"%x" $((0x1e << 2)))

+ getmatch="tos $tosmatch"

+ getnomatch="tos $tosnomatch"

+ fib_rule6_test_match_n_redirect "$match" "$getmatch" \

+ "$getnomatch" "dscp masked redirect to table" \

+ "dscp masked no redirect to table"

+

+ match="dscp 0x0f/0x0f"

+ getmatch="from $SRC_IP6 iif $DEV tos $tosmatch"

+ getnomatch="from $SRC_IP6 iif $DEV tos $tosnomatch"

+ fib_rule6_test_match_n_redirect "$match" "$getmatch" \

+ "$getnomatch" "iif dscp masked redirect to table" \

+ "iif dscp masked no redirect to table"

+ fi

+

+

+ match="sport 100-200 dport 300-400"

+ getmatch="sport 100 dport 400"

+ getnomatch="sport 100 dport 401"

+ fib_rule4_test_match_n_redirect "$match" "$getmatch" \

+ "$getnomatch" \

+ "sport and dport range redirect to table" \

+ "sport and dport range no redirect to table"

+ fi

+

+ ip rule help 2>&1 | grep sport | grep -q MASK

+ if [ $? -eq 0 ]; then

+ match="sport 0x0f00/0xff00 dport 0x000f/0x00ff"

+ getmatch="sport 0x0f11 dport 0x220f"

+ getnomatch="sport 0x1f11 dport 0x221f"

+ fib_rule4_test_match_n_redirect "$match" "$getmatch" \

+ "$getnomatch" "sport and dport masked redirect to table" \

+ "sport and dport masked no redirect to table"

+

+ ip rule help 2>&1 | grep -q "DSCP\[/MASK\]"

+ if [ $? -eq 0 ]; then

+ match="dscp 0x0f/0x0f"

+ tosmatch=$(printf 0x"%x" $((0x1f << 2)))

+ tosnomatch=$(printf 0x"%x" $((0x1e << 2)))

+ getmatch="tos $tosmatch"

+ getnomatch="tos $tosnomatch"

+ fib_rule4_test_match_n_redirect "$match" "$getmatch" \

+ "$getnomatch" "dscp masked redirect to table" \

+ "dscp masked no redirect to table"

+

+ match="dscp 0x0f/0x0f"

+ getmatch="from $SRC_IP iif $DEV tos $tosmatch"

+ getnomatch="from $SRC_IP iif $DEV tos $tosnomatch"

+ fib_rule4_test_match_n_redirect "$match" "$getmatch" \

+ "$getnomatch" "iif dscp masked redirect to table" \

+ "iif dscp masked no redirect to table"

+ fi

+(dev->netns_immutable) and most of them probably do not support the

+ check_err $? "Failed to replace $name host entry"

+

+ # Add an entry with arbitrary destination IP. Verify that packets are

+ # not duplicated (this can happen if hardware floods the packets, and

+ # then traps them due to misconfiguration, so software data path repeats

+ # flooding and resends packets).

+ bridge fdb append dev vx1 00:00:00:00:00:00 dst 198.51.100.1 self

+ __test_flood de:ad:be:ef:13:37 192.0.2.100 "flood, unresolved FDB entry"

+ bridge fdb del dev vx1 00:00:00:00:00:00 dst 198.51.100.1 self

+ # The entry should age out when it only forwards traffic

+ $MZ $h1 -c 50 -d 1sec -p 64 -b $mac -B $dst -t icmp -q &

+

+ # Add entries with arbitrary destination IP. Verify that packets are

+ # not duplicated (this can happen if hardware floods the packets, and

+ # then traps them due to misconfiguration, so software data path repeats

+ # flooding and resends packets).

+ bridge fdb append dev vx10 00:00:00:00:00:00 dst 203.0.113.1 self

+ bridge fdb append dev vx20 00:00:00:00:00:00 dst 203.0.113.2 self

+

+ __test_flood de:ad:be:ef:13:37 192.0.2.100 10 \

+ "flood vlan 10, unresolved FDB entry" 10 10 0 10 0

+ __test_flood ca:fe:be:ef:13:37 198.51.100.100 20 \

+ "flood vlan 20, unresolved FDB entry" 10 0 10 0 10

+

+ bridge fdb del dev vx20 00:00:00:00:00:00 dst 203.0.113.2 self

+ bridge fdb del dev vx10 00:00:00:00:00:00 dst 203.0.113.1 self

+ if (tx_socket) {

+ } else {

+ /* Only the receiver exit status determines test success. */

+ fprintf(stderr, "Gro::%s test passed.\n", testname);

+ }

+ # Each test is run 6 times to deflake, because given the receive timing,

+ for tries in {1..6}; do

+ exit_code=$(run_test "${proto}" "${test}")

+ exit $exit_code

+ sh -c 'sysctl -q -w net.mptcp.enabled=1 && \

+ sysctl -q -w net.ipv4.ip_local_port_range="40000 49999" && \

+ ./ip_local_port_range'

+check_command()

+{

+ local cmd=$1; shift

+

+ if [[ ! -x "$(command -v "$cmd")" ]]; then

+ log_test_skip "$cmd not installed"

+ return $EXIT_STATUS

+ fi

+}

+

+require_command()

+{

+ local cmd=$1; shift

+

+ if ! check_command "$cmd"; then

+ exit $EXIT_STATUS

+ fi

+}

+

+from .netns import NetNS, NetNSEnter

+from .ynl import NlError, YnlFamily, EthtoolFamily, NetdevFamily, RtnlFamily, RtnlAddrFamily

+def ksft_not_in(a, b, comment=""):

+ if a in b:

+ _fail("Check failed", a, "in", b, comment)

+

+

+ print("TAP version 13")

+import ctypes

+libc = ctypes.cdll.LoadLibrary('libc.so.6')

+

+

+

+class NetNSEnter:

+ def __init__(self, ns_name):

+ self.ns_path = f"/run/netns/{ns_name}"

+

+ def __enter__(self):

+ self.saved = open("/proc/thread-self/ns/net")

+ with open(self.ns_path) as ns_file:

+ libc.setns(ns_file.fileno(), 0)

+ return self

+

+ def __exit__(self, exc_type, exc_value, traceback):

+ libc.setns(self.saved.fileno(), 0)

+ self.saved.close()

+import os

+import select

+def fd_read_timeout(fd, timeout):

+ rlist, _, _ = select.select([fd], [], [], timeout)

+ if rlist:

+ return os.read(fd, 1024)

+ else:

+ raise TimeoutError("Timeout waiting for fd read")

+

+

+ """

+ Execute a command on local or remote host.

+

+ Use bkg() instead to run a command in the background.

+ """

+ def __init__(self, comm, shell=True, fail=True, ns=None, background=False,

+ host=None, timeout=5, ksft_wait=None):

+ self.ksft_term_fd = None

+ # ksft_wait lets us wait for the background process to fully start,

+ # we pass an FD to the child process, and wait for it to write back.

+ # Similarly term_fd tells child it's time to exit.

+ pass_fds = ()

+ env = os.environ.copy()

+ if ksft_wait is not None:

+ rfd, ready_fd = os.pipe()

+ wait_fd, self.ksft_term_fd = os.pipe()

+ pass_fds = (ready_fd, wait_fd, )

+ env["KSFT_READY_FD"] = str(ready_fd)

+ env["KSFT_WAIT_FD"] = str(wait_fd)

+

+ stderr=subprocess.PIPE, pass_fds=pass_fds,

+ env=env)

+ if ksft_wait is not None:

+ os.close(ready_fd)

+ os.close(wait_fd)

+ msg = fd_read_timeout(rfd, ksft_wait)

+ os.close(rfd)

+ if not msg:

+ raise Exception("Did not receive ready message")

+ if self.ksft_term_fd:

+ os.write(self.ksft_term_fd, b"1")

+ """

+ Run a command in the background.

+

+ Examples usage:

+

+ Run a command on remote host, and wait for it to finish.

+ This is usually paired with wait_port_listen() to make sure

+ the command has initialized:

+

+ with bkg("socat ...", exit_wait=True, host=cfg.remote) as nc:

+ ...

+

+ Run a command and expect it to let us know that it's ready

+ by writing to a special file descriptor passed via KSFT_READY_FD.

+ Command will be terminated when we exit the context manager:

+

+ with bkg("my_binary", ksft_wait=5):

+ """

+ exit_wait=False, ksft_wait=None):

+ shell=shell, fail=fail, ns=ns, host=host,

+ ksft_wait=ksft_wait)

+ self.terminate = not exit_wait and not ksft_wait

+ if shell and self.terminate:

+ print("# Warning: combining shell and terminate is risky!")

+ print("# SIGTERM may not reach the child on zsh/ksh!")

+

+def rand_port(type=socket.SOCK_STREAM):

+ Get a random unprivileged port.

+ with socket.socket(socket.AF_INET6, type) as s:

+ s.bind(("", 0))

+ return s.getsockname()[1]

+class RtnlAddrFamily(YnlFamily):

+ def __init__(self, recv_size=0):

+ super().__init__((SPEC_PATH / Path('rt_addr.yaml')).as_posix(),

+ schema='', recv_size=recv_size)

+#!/usr/bin/env python3

+# SPDX-License-Identifier: GPL-2.0

+

+import time

+

+from lib.py import ksft_run, ksft_exit, ksft_true

+from lib.py import ip

+from lib.py import NetNS, NetNSEnter

+from lib.py import RtnlFamily

+

+

+LINK_NETNSID = 100

+

+

+def test_event() -> None:

+ with NetNS() as ns1, NetNS() as ns2:

+ with NetNSEnter(str(ns2)):

+ rtnl = RtnlFamily()

+

+ rtnl.ntf_subscribe("rtnlgrp-link")

+

+ ip(f"netns set {ns2} {LINK_NETNSID}", ns=str(ns1))

+ ip(f"link add netns {ns1} link-netnsid {LINK_NETNSID} dummy1 type dummy")

+ ip(f"link add netns {ns1} dummy2 type dummy", ns=str(ns2))

+

+ ip("link del dummy1", ns=str(ns1))

+ ip("link del dummy2", ns=str(ns1))

+

+ time.sleep(1)

+ rtnl.check_ntf()

+ ksft_true(rtnl.async_msg_queue.empty(),

+ "Received unexpected link notification")

+

+

+def validate_link_netns(netns, ifname, link_netnsid) -> bool:

+ link_info = ip(f"-d link show dev {ifname}", ns=netns, json=True)

+ if not link_info:

+ return False

+ return link_info[0].get("link_netnsid") == link_netnsid

+

+

+def test_link_net() -> None:

+ configs = [

+ # type, common args, type args, fallback to dev_net

+ ("ipvlan", "link dummy1", "", False),

+ ("macsec", "link dummy1", "", False),

+ ("macvlan", "link dummy1", "", False),

+ ("macvtap", "link dummy1", "", False),

+ ("vlan", "link dummy1", "id 100", False),

+ ("gre", "", "local 192.0.2.1", True),

+ ("vti", "", "local 192.0.2.1", True),

+ ("ipip", "", "local 192.0.2.1", True),

+ ("ip6gre", "", "local 2001:db8::1", True),

+ ("ip6tnl", "", "local 2001:db8::1", True),

+ ("vti6", "", "local 2001:db8::1", True),

+ ("sit", "", "local 192.0.2.1", True),

+ ("xfrm", "", "if_id 1", True),

+ ]

+

+ with NetNS() as ns1, NetNS() as ns2, NetNS() as ns3:

+ net1, net2, net3 = str(ns1), str(ns2), str(ns3)

+

+ # prepare link netnsid and a dummy link needed by certain drivers

+ ip(f"netns set {net3} {LINK_NETNSID}", ns=str(net2))

+ ip("link add dummy1 type dummy", ns=net3)

+

+ cases = [

+ # source, "netns", "link-netns", expected link-netns

+ (net3, None, None, None, None),

+ (net3, net2, None, None, LINK_NETNSID),

+ (net2, None, net3, LINK_NETNSID, LINK_NETNSID),

+ (net1, net2, net3, LINK_NETNSID, LINK_NETNSID),

+ ]

+

+ for src_net, netns, link_netns, exp1, exp2 in cases:

+ tgt_net = netns or src_net

+ for typ, cargs, targs, fb_dev_net in configs:

+ cmd = "link add"

+ if netns:

+ cmd += f" netns {netns}"

+ if link_netns:

+ cmd += f" link-netns {link_netns}"

+ cmd += f" {cargs} foo type {typ} {targs}"

+ ip(cmd, ns=src_net)

+ if fb_dev_net:

+ ksft_true(validate_link_netns(tgt_net, "foo", exp1),

+ f"{typ} link_netns validation failed")

+ else:

+ ksft_true(validate_link_netns(tgt_net, "foo", exp2),

+ f"{typ} link_netns validation failed")

+ ip(f"link del foo", ns=tgt_net)

+

+

+def test_peer_net() -> None:

+ types = [

+ "vxcan",

+ "netkit",

+ "veth",

+ ]

+

+ with NetNS() as ns1, NetNS() as ns2, NetNS() as ns3, NetNS() as ns4:

+ net1, net2, net3, net4 = str(ns1), str(ns2), str(ns3), str(ns4)

+

+ ip(f"netns set {net3} {LINK_NETNSID}", ns=str(net2))

+

+ cases = [

+ # source, "netns", "link-netns", "peer netns", expected

+ (net1, None, None, None, None),

+ (net1, net2, None, None, None),

+ (net2, None, net3, None, LINK_NETNSID),

+ (net1, net2, net3, None, None),

+ (net2, None, None, net3, LINK_NETNSID),

+ (net1, net2, None, net3, LINK_NETNSID),

+ (net2, None, net2, net3, LINK_NETNSID),

+ (net1, net2, net4, net3, LINK_NETNSID),

+ ]

+

+ for src_net, netns, link_netns, peer_netns, exp in cases:

+ tgt_net = netns or src_net

+ for typ in types:

+ cmd = "link add"

+ if netns:

+ cmd += f" netns {netns}"

+ if link_netns:

+ cmd += f" link-netns {link_netns}"

+ cmd += f" foo type {typ}"

+ if peer_netns:

+ cmd += f" peer netns {peer_netns}"

+ ip(cmd, ns=src_net)

+ ksft_true(validate_link_netns(tgt_net, "foo", exp),

+ f"{typ} peer_netns validation failed")

+ ip(f"link del foo", ns=tgt_net)

+

+

+def main() -> None:

+ ksft_run([test_event, test_link_net, test_peer_net])

+ ksft_exit()

+

+

+if __name__ == "__main__":

+ main()

+TEST_GEN_FILES = mptcp_connect pm_nl_ctl mptcp_sockopt mptcp_inq mptcp_diag

+chk_dump_one()

+{

+ local ss_token

+ local token

+ local msg

+

+ ss_token="$(ss -inmHMN $ns | grep 'token:' |\

+ head -n 1 |\

+ sed 's/.*token:\([0-9a-f]*\).*/\1/')"

+

+ token="$(ip netns exec $ns ./mptcp_diag -t $ss_token |\

+ awk -F':[ \t]+' '/^token/ {print $2}')"

+

+ msg="....chk dump_one"

+

+ mptcp_lib_print_title "$msg"

+ if [ -n "$ss_token" ] && [ "$ss_token" = "$token" ]; then

+ mptcp_lib_pr_ok

+ mptcp_lib_result_pass "${msg}"

+ else

+ mptcp_lib_pr_fail "expected $ss_token found $token"

+ mptcp_lib_result_fail "${msg}"

+ ret=${KSFT_FAIL}

+ fi

+}

+

+chk_dump_one

+// SPDX-License-Identifier: GPL-2.0

+/* Copyright (c) 2025, Kylin Software */

+

+#include <linux/sock_diag.h>

+#include <linux/rtnetlink.h>

+#include <linux/inet_diag.h>

+#include <linux/netlink.h>

+#include <sys/socket.h>

+#include <netinet/in.h>

+#include <linux/tcp.h>

+

+#include <unistd.h>

+#include <stdlib.h>

+#include <string.h>

+#include <errno.h>

+#include <stdio.h>

+

+#ifndef IPPROTO_MPTCP

+#define IPPROTO_MPTCP 262

+#endif

+

+struct mptcp_info {

+ __u8 mptcpi_subflows;

+ __u8 mptcpi_add_addr_signal;

+ __u8 mptcpi_add_addr_accepted;

+ __u8 mptcpi_subflows_max;

+ __u8 mptcpi_add_addr_signal_max;

+ __u8 mptcpi_add_addr_accepted_max;

+ __u32 mptcpi_flags;

+ __u32 mptcpi_token;

+ __u64 mptcpi_write_seq;

+ __u64 mptcpi_snd_una;

+ __u64 mptcpi_rcv_nxt;

+ __u8 mptcpi_local_addr_used;

+ __u8 mptcpi_local_addr_max;

+ __u8 mptcpi_csum_enabled;

+ __u32 mptcpi_retransmits;

+ __u64 mptcpi_bytes_retrans;

+ __u64 mptcpi_bytes_sent;

+ __u64 mptcpi_bytes_received;

+ __u64 mptcpi_bytes_acked;

+ __u8 mptcpi_subflows_total;

+ __u8 reserved[3];

+ __u32 mptcpi_last_data_sent;

+ __u32 mptcpi_last_data_recv;

+ __u32 mptcpi_last_ack_recv;

+};

+

+static void die_perror(const char *msg)

+{

+ perror(msg);

+ exit(1);

+}

+

+static void die_usage(int r)

+{

+ fprintf(stderr, "Usage: mptcp_diag -t\n");

+ exit(r);

+}

+

+static void send_query(int fd, __u32 token)

+{

+ struct sockaddr_nl nladdr = {

+ .nl_family = AF_NETLINK

+ };

+ struct {

+ struct nlmsghdr nlh;

+ struct inet_diag_req_v2 r;

+ } req = {

+ .nlh = {

+ .nlmsg_len = sizeof(req),

+ .nlmsg_type = SOCK_DIAG_BY_FAMILY,

+ .nlmsg_flags = NLM_F_REQUEST

+ },

+ .r = {

+ .sdiag_family = AF_INET,

+ /* Real proto is set via INET_DIAG_REQ_PROTOCOL */

+ .sdiag_protocol = IPPROTO_TCP,

+ .id.idiag_cookie[0] = token,

+ }

+ };

+ struct rtattr rta_proto;

+ struct iovec iov[6];

+ int iovlen = 1;

+ __u32 proto;

+

+ req.r.idiag_ext |= (1 << (INET_DIAG_INFO - 1));

+ proto = IPPROTO_MPTCP;

+ rta_proto.rta_type = INET_DIAG_REQ_PROTOCOL;

+ rta_proto.rta_len = RTA_LENGTH(sizeof(proto));

+

+ iov[0] = (struct iovec) {

+ .iov_base = &req,

+ .iov_len = sizeof(req)

+ };

+ iov[iovlen] = (struct iovec){ &rta_proto, sizeof(rta_proto)};

+ iov[iovlen + 1] = (struct iovec){ &proto, sizeof(proto)};

+ req.nlh.nlmsg_len += RTA_LENGTH(sizeof(proto));

+ iovlen += 2;

+ struct msghdr msg = {

+ .msg_name = &nladdr,

+ .msg_namelen = sizeof(nladdr),

+ .msg_iov = iov,

+ .msg_iovlen = iovlen

+ };

+

+ for (;;) {

+ if (sendmsg(fd, &msg, 0) < 0) {

+ if (errno == EINTR)

+ continue;

+ die_perror("sendmsg");

+ }

+ break;

+ }

+}

+

+static void parse_rtattr_flags(struct rtattr *tb[], int max, struct rtattr *rta,

+ int len, unsigned short flags)

+{

+ unsigned short type;

+

+ memset(tb, 0, sizeof(struct rtattr *) * (max + 1));

+ while (RTA_OK(rta, len)) {

+ type = rta->rta_type & ~flags;

+ if (type <= max && !tb[type])

+ tb[type] = rta;

+ rta = RTA_NEXT(rta, len);

+ }

+}

+

+static void print_info_msg(struct mptcp_info *info)

+{

+ printf("Token & Flags\n");

+ printf("token: %x\n", info->mptcpi_token);

+ printf("flags: %x\n", info->mptcpi_flags);

+ printf("csum_enabled: %u\n", info->mptcpi_csum_enabled);

+

+ printf("\nBasic Info\n");

+ printf("subflows: %u\n", info->mptcpi_subflows);

+ printf("subflows_max: %u\n", info->mptcpi_subflows_max);

+ printf("subflows_total: %u\n", info->mptcpi_subflows_total);

+ printf("local_addr_used: %u\n", info->mptcpi_local_addr_used);

+ printf("local_addr_max: %u\n", info->mptcpi_local_addr_max);

+ printf("add_addr_signal: %u\n", info->mptcpi_add_addr_signal);

+ printf("add_addr_accepted: %u\n", info->mptcpi_add_addr_accepted);

+ printf("add_addr_signal_max: %u\n", info->mptcpi_add_addr_signal_max);

+ printf("add_addr_accepted_max: %u\n", info->mptcpi_add_addr_accepted_max);

+

+ printf("\nTransmission Info\n");

+ printf("write_seq: %llu\n", info->mptcpi_write_seq);

+ printf("snd_una: %llu\n", info->mptcpi_snd_una);

+ printf("rcv_nxt: %llu\n", info->mptcpi_rcv_nxt);

+ printf("last_data_sent: %u\n", info->mptcpi_last_data_sent);

+ printf("last_data_recv: %u\n", info->mptcpi_last_data_recv);

+ printf("last_ack_recv: %u\n", info->mptcpi_last_ack_recv);

+ printf("retransmits: %u\n", info->mptcpi_retransmits);

+ printf("retransmit bytes: %llu\n", info->mptcpi_bytes_retrans);

+ printf("bytes_sent: %llu\n", info->mptcpi_bytes_sent);

+ printf("bytes_received: %llu\n", info->mptcpi_bytes_received);

+ printf("bytes_acked: %llu\n", info->mptcpi_bytes_acked);

+}

+

+static void parse_nlmsg(struct nlmsghdr *nlh)

+{

+ struct inet_diag_msg *r = NLMSG_DATA(nlh);

+ struct rtattr *tb[INET_DIAG_MAX + 1];

+

+ parse_rtattr_flags(tb, INET_DIAG_MAX, (struct rtattr *)(r + 1),

+ nlh->nlmsg_len - NLMSG_LENGTH(sizeof(*r)),

+ NLA_F_NESTED);

+

+ if (tb[INET_DIAG_INFO]) {

+ int len = RTA_PAYLOAD(tb[INET_DIAG_INFO]);

+ struct mptcp_info *info;

+

+ /* workaround fort older kernels with less fields */

+ if (len < sizeof(*info)) {

+ info = alloca(sizeof(*info));

+ memcpy(info, RTA_DATA(tb[INET_DIAG_INFO]), len);

+ memset((char *)info + len, 0, sizeof(*info) - len);

+ } else {

+ info = RTA_DATA(tb[INET_DIAG_INFO]);

+ }

+ print_info_msg(info);

+ }

+}

+

+static void recv_nlmsg(int fd, struct nlmsghdr *nlh)

+{

+ char rcv_buff[8192];

+ struct sockaddr_nl rcv_nladdr = {

+ .nl_family = AF_NETLINK

+ };

+ struct iovec rcv_iov = {

+ .iov_base = rcv_buff,

+ .iov_len = sizeof(rcv_buff)

+ };

+ struct msghdr rcv_msg = {

+ .msg_name = &rcv_nladdr,

+ .msg_namelen = sizeof(rcv_nladdr),

+ .msg_iov = &rcv_iov,

+ .msg_iovlen = 1

+ };

+ int len;

+

+ len = recvmsg(fd, &rcv_msg, 0);

+ nlh = (struct nlmsghdr *)rcv_buff;

+

+ while (NLMSG_OK(nlh, len)) {

+ if (nlh->nlmsg_type == NLMSG_DONE) {

+ printf("NLMSG_DONE\n");

+ break;

+ } else if (nlh->nlmsg_type == NLMSG_ERROR) {

+ struct nlmsgerr *err;

+

+ err = (struct nlmsgerr *)NLMSG_DATA(nlh);

+ printf("Error %d:%s\n",

+ -(err->error), strerror(-(err->error)));

+ break;

+ }

+ parse_nlmsg(nlh);

+ nlh = NLMSG_NEXT(nlh, len);

+ }

+}

+

+static void get_mptcpinfo(__u32 token)

+{

+ struct nlmsghdr *nlh = NULL;

+ int fd;

+

+ fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_SOCK_DIAG);

+ if (fd < 0)

+ die_perror("Netlink socket");

+

+ send_query(fd, token);

+ recv_nlmsg(fd, nlh);

+

+ close(fd);

+}

+

+static void parse_opts(int argc, char **argv, __u32 *target_token)

+{

+ int c;

+

+ if (argc < 2)

+ die_usage(1);

+

+ while ((c = getopt(argc, argv, "ht:")) != -1) {

+ switch (c) {

+ case 'h':

+ die_usage(0);

+ break;

+ case 't':

+ sscanf(optarg, "%x", target_token);

+ break;

+ default:

+ die_usage(1);

+ break;

+ }

+ }

+}

+

+int main(int argc, char *argv[])

+{

+ __u32 target_token;

+

+ parse_opts(argc, argv, &target_token);

+ get_mptcpinfo(target_token);

+

+ return 0;

+}

+

+ echo -e "\t-b: bail out after first error, otherwise runs all testcases"

+print_title "Init"

+

+# check path_manager and pm_type sysctl mapping

+if [ -f /proc/sys/net/mptcp/path_manager ]; then

+ ip netns exec "$ns1" sysctl -q net.mptcp.path_manager=userspace

+ pm_type="$(ip netns exec "$ns1" sysctl -n net.mptcp.pm_type)"

+ if [ "${pm_type}" != "1" ]; then

+ test_fail "unexpected pm_type: ${pm_type}"

+ mptcp_lib_result_print_all_tap

+ exit ${KSFT_FAIL}

+ fi

+

+ ip netns exec "$ns1" sysctl -q net.mptcp.path_manager=error 2>/dev/null

+ pm_type="$(ip netns exec "$ns1" sysctl -n net.mptcp.pm_type)"

+ if [ "${pm_type}" != "1" ]; then

+ test_fail "unexpected pm_type after error: ${pm_type}"

+ mptcp_lib_result_print_all_tap

+ exit ${KSFT_FAIL}

+ fi

+

+ ip netns exec "$ns1" sysctl -q net.mptcp.pm_type=0

+ pm_name="$(ip netns exec "$ns1" sysctl -n net.mptcp.path_manager)"

+ if [ "${pm_name}" != "kernel" ]; then

+ test_fail "unexpected path-manager: ${pm_name}"

+ mptcp_lib_result_print_all_tap

+ exit ${KSFT_FAIL}

+ fi

+fi

+

+#

+# Test no conflict of the same name/ifindex in different netns

+#

+ip -netns $NS link add name $DEV index 100 type dummy || fail

+ip -netns $NS link add netns $test_ns name $DEV index 100 type dummy ||

+ fail "Can create in netns without moving"

+ip -netns $test_ns link show dev $DEV >> /dev/null || fail "Device not found"

+ip -netns $NS link del $DEV || fail

+ip -netns $test_ns link del $DEV || fail

+

+def nsim_rxq_reset_down(nf) -> None:

+ """

+ Test that the queue API supports resetting a queue

+ while the interface is down. We should convert this

+ test to testing real HW once more devices support

+ queue API.

+ """

+ with NetdevSimDev(queue_count=4) as nsimdev:

+ nsim = nsimdev.nsims[0]

+

+ ip(f"link set dev {nsim.ifname} down")

+ for i in [0, 2, 3]:

+ nsim.dfs_write("queue_reset", f"1 {i}")

+

+

+ ksft_run([empty_check, lo_check, page_pool_check, napi_list_check,

+ nsim_rxq_reset_down],

+ which pahole >/dev/null 2>&1 || return $ksft_skip

+

+ ovs_drop_subsys=$(pahole -C skb_drop_reason_subsys |

+ awk '/OPENVSWITCH/ { print $3; }' |

+ tr -d ,)

+ ovs_drop_reason_count 0x${ovs_drop_subsys}0001 # OVS_DROP_FLOW_ACTION

+ ovs_drop_reason_count 0x${ovs_drop_subsys}0004 # OVS_DROP_EXPLICIT_ACTION_ERROR

+ ovs_drop_reason_count 0x${ovs_drop_subsys}0003 # OVS_DROP_EXPLICIT_ACTION

+// SPDX-License-Identifier: GPL-2.0

+/*

+ * proc_net_pktgen: kselftest for /proc/net/pktgen interface

+ *

+ * Copyright (c) 2025 Peter Seiderer <ps.report@gmx.net>

+ *

+ */

+#include <errno.h>

+#include <fcntl.h>

+#include <stdlib.h>

+#include <unistd.h>

+

+#include "../kselftest_harness.h"

+

+static const char ctrl_cmd_stop[] = "stop";

+static const char ctrl_cmd_start[] = "start";

+static const char ctrl_cmd_reset[] = "reset";

+

+static const char wrong_ctrl_cmd[] = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789";

+

+static const char thr_cmd_add_loopback_0[] = "add_device lo@0";

+static const char thr_cmd_rm_loopback_0[] = "rem_device_all";

+

+static const char wrong_thr_cmd[] = "forsureawrongcommand";

+static const char legacy_thr_cmd[] = "max_before_softirq";

+

+static const char wrong_dev_cmd[] = "forsurewrongcommand";

+static const char dev_cmd_min_pkt_size_0[] = "min_pkt_size";

+static const char dev_cmd_min_pkt_size_1[] = "min_pkt_size ";

+static const char dev_cmd_min_pkt_size_2[] = "min_pkt_size 0";

+static const char dev_cmd_min_pkt_size_3[] = "min_pkt_size 1";

+static const char dev_cmd_min_pkt_size_4[] = "min_pkt_size 100";

+static const char dev_cmd_min_pkt_size_5[] = "min_pkt_size=1001";

+static const char dev_cmd_min_pkt_size_6[] = "min_pkt_size =2002";

+static const char dev_cmd_min_pkt_size_7[] = "min_pkt_size= 3003";

+static const char dev_cmd_min_pkt_size_8[] = "min_pkt_size = 4004";

+static const char dev_cmd_max_pkt_size_0[] = "max_pkt_size 200";

+static const char dev_cmd_pkt_size_0[] = "pkt_size 300";

+static const char dev_cmd_imix_weights_0[] = "imix_weights 0,7 576,4 1500,1";

+static const char dev_cmd_imix_weights_1[] = "imix_weights 101,1 102,2 103,3 104,4 105,5 106,6 107,7 108,8 109,9 110,10 111,11 112,12 113,13 114,14 115,15 116,16 117,17 118,18 119,19 120,20";

+static const char dev_cmd_imix_weights_2[] = "imix_weights 100,1 102,2 103,3 104,4 105,5 106,6 107,7 108,8 109,9 110,10 111,11 112,12 113,13 114,14 115,15 116,16 117,17 118,18 119,19 120,20 121,21";

+static const char dev_cmd_imix_weights_3[] = "imix_weights";

+static const char dev_cmd_imix_weights_4[] = "imix_weights ";

+static const char dev_cmd_imix_weights_5[] = "imix_weights 0";

+static const char dev_cmd_imix_weights_6[] = "imix_weights 0,";

+static const char dev_cmd_debug_0[] = "debug 1";

+static const char dev_cmd_debug_1[] = "debug 0";

+static const char dev_cmd_frags_0[] = "frags 100";

+static const char dev_cmd_delay_0[] = "delay 100";

+static const char dev_cmd_delay_1[] = "delay 2147483647";

+static const char dev_cmd_rate_0[] = "rate 0";

+static const char dev_cmd_rate_1[] = "rate 100";

+static const char dev_cmd_ratep_0[] = "ratep 0";

+static const char dev_cmd_ratep_1[] = "ratep 200";

+static const char dev_cmd_udp_src_min_0[] = "udp_src_min 1";

+static const char dev_cmd_udp_dst_min_0[] = "udp_dst_min 2";

+static const char dev_cmd_udp_src_max_0[] = "udp_src_max 3";

+static const char dev_cmd_udp_dst_max_0[] = "udp_dst_max 4";

+static const char dev_cmd_clone_skb_0[] = "clone_skb 1";

+static const char dev_cmd_clone_skb_1[] = "clone_skb 0";

+static const char dev_cmd_count_0[] = "count 100";

+static const char dev_cmd_src_mac_count_0[] = "src_mac_count 100";

+static const char dev_cmd_dst_mac_count_0[] = "dst_mac_count 100";

+static const char dev_cmd_burst_0[] = "burst 0";

+static const char dev_cmd_node_0[] = "node 100";

+static const char dev_cmd_xmit_mode_0[] = "xmit_mode start_xmit";

+static const char dev_cmd_xmit_mode_1[] = "xmit_mode netif_receive";

+static const char dev_cmd_xmit_mode_2[] = "xmit_mode queue_xmit";

+static const char dev_cmd_xmit_mode_3[] = "xmit_mode nonsense";

+static const char dev_cmd_flag_0[] = "flag UDPCSUM";

+static const char dev_cmd_flag_1[] = "flag !UDPCSUM";

+static const char dev_cmd_flag_2[] = "flag nonsense";

+static const char dev_cmd_dst_min_0[] = "dst_min 101.102.103.104";

+static const char dev_cmd_dst_0[] = "dst 101.102.103.104";

+static const char dev_cmd_dst_max_0[] = "dst_max 201.202.203.204";

+static const char dev_cmd_dst6_0[] = "dst6 2001:db38:1234:0000:0000:0000:0000:0000";

+static const char dev_cmd_dst6_min_0[] = "dst6_min 2001:db8:1234:0000:0000:0000:0000:0000";

+static const char dev_cmd_dst6_max_0[] = "dst6_max 2001:db8:1234:0000:0000:0000:0000:0000";

+static const char dev_cmd_src6_0[] = "src6 2001:db38:1234:0000:0000:0000:0000:0000";

+static const char dev_cmd_src_min_0[] = "src_min 101.102.103.104";

+static const char dev_cmd_src_max_0[] = "src_max 201.202.203.204";

+static const char dev_cmd_dst_mac_0[] = "dst_mac 01:02:03:04:05:06";

+static const char dev_cmd_src_mac_0[] = "src_mac 11:12:13:14:15:16";

+static const char dev_cmd_clear_counters_0[] = "clear_counters";

+static const char dev_cmd_flows_0[] = "flows 100";

+static const char dev_cmd_spi_0[] = "spi 100";

+static const char dev_cmd_flowlen_0[] = "flowlen 100";

+static const char dev_cmd_queue_map_min_0[] = "queue_map_min 1";

+static const char dev_cmd_queue_map_max_0[] = "queue_map_max 2";

+static const char dev_cmd_mpls_0[] = "mpls 00000001";

+static const char dev_cmd_mpls_1[] = "mpls 00000001,000000f2";

+static const char dev_cmd_mpls_2[] = "mpls 00000f00,00000f01,00000f02,00000f03,00000f04,00000f05,00000f06,00000f07,00000f08,00000f09,00000f0a,00000f0b,00000f0c,00000f0d,00000f0e,00000f0f";

+static const char dev_cmd_mpls_3[] = "mpls 00000f00,00000f01,00000f02,00000f03,00000f04,00000f05,00000f06,00000f07,00000f08,00000f09,00000f0a,00000f0b,00000f0c,00000f0d,00000f0e,00000f0f,00000f10";

+static const char dev_cmd_vlan_id_0[] = "vlan_id 1";

+static const char dev_cmd_vlan_p_0[] = "vlan_p 1";

+static const char dev_cmd_vlan_cfi_0[] = "vlan_cfi 1";

+static const char dev_cmd_vlan_id_1[] = "vlan_id 4096";

+static const char dev_cmd_svlan_id_0[] = "svlan_id 1";

+static const char dev_cmd_svlan_p_0[] = "svlan_p 1";

+static const char dev_cmd_svlan_cfi_0[] = "svlan_cfi 1";

+static const char dev_cmd_svlan_id_1[] = "svlan_id 4096";

+static const char dev_cmd_tos_0[] = "tos 0";

+static const char dev_cmd_tos_1[] = "tos 0f";

+static const char dev_cmd_tos_2[] = "tos 0ff";

+static const char dev_cmd_traffic_class_0[] = "traffic_class f0";

+static const char dev_cmd_skb_priority_0[] = "skb_priority 999";

+

+FIXTURE(proc_net_pktgen) {

+ int ctrl_fd;

+ int thr_fd;

+ int dev_fd;

+};

+

+FIXTURE_SETUP(proc_net_pktgen) {

+ int r;

+ ssize_t len;

+

+ r = system("modprobe pktgen");

+ ASSERT_EQ(r, 0) TH_LOG("CONFIG_NET_PKTGEN not enabled, module pktgen not loaded?");

+

+ self->ctrl_fd = open("/proc/net/pktgen/pgctrl", O_RDWR);

+ ASSERT_GE(self->ctrl_fd, 0) TH_LOG("CONFIG_NET_PKTGEN not enabled, module pktgen not loaded?");

+

+ self->thr_fd = open("/proc/net/pktgen/kpktgend_0", O_RDWR);

+ ASSERT_GE(self->thr_fd, 0) TH_LOG("CONFIG_NET_PKTGEN not enabled, module pktgen not loaded?");

+

+ len = write(self->thr_fd, thr_cmd_add_loopback_0, sizeof(thr_cmd_add_loopback_0));

+ ASSERT_EQ(len, sizeof(thr_cmd_add_loopback_0)) TH_LOG("device lo@0 already registered?");

+

+ self->dev_fd = open("/proc/net/pktgen/lo@0", O_RDWR);

+ ASSERT_GE(self->dev_fd, 0) TH_LOG("device entry for lo@0 missing?");

+}

+

+FIXTURE_TEARDOWN(proc_net_pktgen) {

+ int ret;

+ ssize_t len;

+

+ ret = close(self->dev_fd);

+ EXPECT_EQ(ret, 0);

+

+ len = write(self->thr_fd, thr_cmd_rm_loopback_0, sizeof(thr_cmd_rm_loopback_0));

+ EXPECT_EQ(len, sizeof(thr_cmd_rm_loopback_0));

+

+ ret = close(self->thr_fd);

+ EXPECT_EQ(ret, 0);

+

+ ret = close(self->ctrl_fd);

+ EXPECT_EQ(ret, 0);

+}

+

+TEST_F(proc_net_pktgen, wrong_ctrl_cmd) {

+ for (int i = 0; i <= sizeof(wrong_ctrl_cmd); i++) {

+ ssize_t len;

+

+ len = write(self->ctrl_fd, wrong_ctrl_cmd, i);

+ EXPECT_EQ(len, -1);

+ EXPECT_EQ(errno, EINVAL);

+ }

+}

+

+TEST_F(proc_net_pktgen, ctrl_cmd) {

+ ssize_t len;

+

+ len = write(self->ctrl_fd, ctrl_cmd_stop, sizeof(ctrl_cmd_stop));

+ EXPECT_EQ(len, sizeof(ctrl_cmd_stop));

+

+ len = write(self->ctrl_fd, ctrl_cmd_stop, sizeof(ctrl_cmd_stop) - 1);

+ EXPECT_EQ(len, sizeof(ctrl_cmd_stop) - 1);

+

+ len = write(self->ctrl_fd, ctrl_cmd_start, sizeof(ctrl_cmd_start));

+ EXPECT_EQ(len, sizeof(ctrl_cmd_start));

+

+ len = write(self->ctrl_fd, ctrl_cmd_start, sizeof(ctrl_cmd_start) - 1);

+ EXPECT_EQ(len, sizeof(ctrl_cmd_start) - 1);

+

+ len = write(self->ctrl_fd, ctrl_cmd_reset, sizeof(ctrl_cmd_reset));

+ EXPECT_EQ(len, sizeof(ctrl_cmd_reset));

+

+ len = write(self->ctrl_fd, ctrl_cmd_reset, sizeof(ctrl_cmd_reset) - 1);

+ EXPECT_EQ(len, sizeof(ctrl_cmd_reset) - 1);

+}

+

+TEST_F(proc_net_pktgen, wrong_thr_cmd) {

+ for (int i = 0; i <= sizeof(wrong_thr_cmd); i++) {

+ ssize_t len;

+

+ len = write(self->thr_fd, wrong_thr_cmd, i);

+ EXPECT_EQ(len, -1);

+ EXPECT_EQ(errno, EINVAL);

+ }

+}

+

+TEST_F(proc_net_pktgen, legacy_thr_cmd) {

+ for (int i = 0; i <= sizeof(legacy_thr_cmd); i++) {

+ ssize_t len;

+

+ len = write(self->thr_fd, legacy_thr_cmd, i);

+ if (i < (sizeof(legacy_thr_cmd) - 1)) {

+ /* incomplete command string */

+ EXPECT_EQ(len, -1);

+ EXPECT_EQ(errno, EINVAL);

+ } else {

+ /* complete command string without/with trailing '\0' */

+ EXPECT_EQ(len, i);

+ }

+ }

+}

+

+TEST_F(proc_net_pktgen, wrong_dev_cmd) {

+ for (int i = 0; i <= sizeof(wrong_dev_cmd); i++) {

+ ssize_t len;

+

+ len = write(self->dev_fd, wrong_dev_cmd, i);

+ EXPECT_EQ(len, -1);

+ EXPECT_EQ(errno, EINVAL);

+ }

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_min_pkt_size) {

+ ssize_t len;

+

+ /* with trailing '\0' */

+ len = write(self->dev_fd, dev_cmd_min_pkt_size_0, sizeof(dev_cmd_min_pkt_size_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_min_pkt_size_0));

+

+ /* without trailing '\0' */

+ len = write(self->dev_fd, dev_cmd_min_pkt_size_0, sizeof(dev_cmd_min_pkt_size_0) - 1);

+ EXPECT_EQ(len, sizeof(dev_cmd_min_pkt_size_0) - 1);

+

+ /* with trailing '\0' */

+ len = write(self->dev_fd, dev_cmd_min_pkt_size_1, sizeof(dev_cmd_min_pkt_size_1));

+ EXPECT_EQ(len, sizeof(dev_cmd_min_pkt_size_1));

+

+ /* without trailing '\0' */

+ len = write(self->dev_fd, dev_cmd_min_pkt_size_1, sizeof(dev_cmd_min_pkt_size_1) - 1);

+ EXPECT_EQ(len, sizeof(dev_cmd_min_pkt_size_1) - 1);

+

+ /* with trailing '\0' */

+ len = write(self->dev_fd, dev_cmd_min_pkt_size_2, sizeof(dev_cmd_min_pkt_size_2));

+ EXPECT_EQ(len, sizeof(dev_cmd_min_pkt_size_2));

+

+ /* without trailing '\0' */

+ len = write(self->dev_fd, dev_cmd_min_pkt_size_2, sizeof(dev_cmd_min_pkt_size_2) - 1);

+ EXPECT_EQ(len, sizeof(dev_cmd_min_pkt_size_2) - 1);

+

+ len = write(self->dev_fd, dev_cmd_min_pkt_size_3, sizeof(dev_cmd_min_pkt_size_3));

+ EXPECT_EQ(len, sizeof(dev_cmd_min_pkt_size_3));

+

+ len = write(self->dev_fd, dev_cmd_min_pkt_size_4, sizeof(dev_cmd_min_pkt_size_4));

+ EXPECT_EQ(len, sizeof(dev_cmd_min_pkt_size_4));

+

+ len = write(self->dev_fd, dev_cmd_min_pkt_size_5, sizeof(dev_cmd_min_pkt_size_5));

+ EXPECT_EQ(len, sizeof(dev_cmd_min_pkt_size_5));

+

+ len = write(self->dev_fd, dev_cmd_min_pkt_size_6, sizeof(dev_cmd_min_pkt_size_6));

+ EXPECT_EQ(len, sizeof(dev_cmd_min_pkt_size_6));

+

+ len = write(self->dev_fd, dev_cmd_min_pkt_size_7, sizeof(dev_cmd_min_pkt_size_7));

+ EXPECT_EQ(len, sizeof(dev_cmd_min_pkt_size_7));

+

+ len = write(self->dev_fd, dev_cmd_min_pkt_size_8, sizeof(dev_cmd_min_pkt_size_8));

+ EXPECT_EQ(len, sizeof(dev_cmd_min_pkt_size_8));

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_max_pkt_size) {

+ ssize_t len;

+

+ len = write(self->dev_fd, dev_cmd_max_pkt_size_0, sizeof(dev_cmd_max_pkt_size_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_max_pkt_size_0));

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_pkt_size) {

+ ssize_t len;

+

+ len = write(self->dev_fd, dev_cmd_pkt_size_0, sizeof(dev_cmd_pkt_size_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_pkt_size_0));

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_imix_weights) {

+ ssize_t len;

+

+ len = write(self->dev_fd, dev_cmd_imix_weights_0, sizeof(dev_cmd_imix_weights_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_imix_weights_0));

+

+ len = write(self->dev_fd, dev_cmd_imix_weights_1, sizeof(dev_cmd_imix_weights_1));

+ EXPECT_EQ(len, sizeof(dev_cmd_imix_weights_1));

+

+ len = write(self->dev_fd, dev_cmd_imix_weights_2, sizeof(dev_cmd_imix_weights_2));

+ EXPECT_EQ(len, -1);

+ EXPECT_EQ(errno, E2BIG);

+

+ /* with trailing '\0' */

+ len = write(self->dev_fd, dev_cmd_imix_weights_3, sizeof(dev_cmd_imix_weights_3));

+ EXPECT_EQ(len, -1);

+ EXPECT_EQ(errno, EINVAL);

+

+ /* without trailing '\0' */

+ len = write(self->dev_fd, dev_cmd_imix_weights_3, sizeof(dev_cmd_imix_weights_3) - 1);

+ EXPECT_EQ(len, -1);

+ EXPECT_EQ(errno, EINVAL);

+

+ /* with trailing '\0' */

+ len = write(self->dev_fd, dev_cmd_imix_weights_4, sizeof(dev_cmd_imix_weights_4));

+ EXPECT_EQ(len, -1);

+ EXPECT_EQ(errno, EINVAL);

+

+ /* without trailing '\0' */

+ len = write(self->dev_fd, dev_cmd_imix_weights_4, sizeof(dev_cmd_imix_weights_4) - 1);

+ EXPECT_EQ(len, -1);

+ EXPECT_EQ(errno, EINVAL);

+

+ /* with trailing '\0' */

+ len = write(self->dev_fd, dev_cmd_imix_weights_5, sizeof(dev_cmd_imix_weights_5));

+ EXPECT_EQ(len, -1);

+ EXPECT_EQ(errno, EINVAL);

+

+ /* without trailing '\0' */

+ len = write(self->dev_fd, dev_cmd_imix_weights_5, sizeof(dev_cmd_imix_weights_5) - 1);

+ EXPECT_EQ(len, -1);

+ EXPECT_EQ(errno, EINVAL);

+

+ /* with trailing '\0' */

+ len = write(self->dev_fd, dev_cmd_imix_weights_6, sizeof(dev_cmd_imix_weights_6));

+ EXPECT_EQ(len, -1);

+ EXPECT_EQ(errno, EINVAL);

+

+ /* without trailing '\0' */

+ len = write(self->dev_fd, dev_cmd_imix_weights_6, sizeof(dev_cmd_imix_weights_6) - 1);

+ EXPECT_EQ(len, -1);

+ EXPECT_EQ(errno, EINVAL);

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_debug) {

+ ssize_t len;

+

+ /* debug on */

+ len = write(self->dev_fd, dev_cmd_debug_0, sizeof(dev_cmd_debug_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_debug_0));

+

+ /* debug off */

+ len = write(self->dev_fd, dev_cmd_debug_1, sizeof(dev_cmd_debug_1));

+ EXPECT_EQ(len, sizeof(dev_cmd_debug_1));

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_frags) {

+ ssize_t len;

+

+ len = write(self->dev_fd, dev_cmd_frags_0, sizeof(dev_cmd_frags_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_frags_0));

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_delay) {

+ ssize_t len;

+

+ len = write(self->dev_fd, dev_cmd_delay_0, sizeof(dev_cmd_delay_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_delay_0));

+

+ len = write(self->dev_fd, dev_cmd_delay_1, sizeof(dev_cmd_delay_1));

+ EXPECT_EQ(len, sizeof(dev_cmd_delay_1));

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_rate) {

+ ssize_t len;

+

+ len = write(self->dev_fd, dev_cmd_rate_0, sizeof(dev_cmd_rate_0));

+ EXPECT_EQ(len, -1);

+ EXPECT_EQ(errno, EINVAL);

+

+ len = write(self->dev_fd, dev_cmd_rate_1, sizeof(dev_cmd_rate_1));

+ EXPECT_EQ(len, sizeof(dev_cmd_rate_1));

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_ratep) {

+ ssize_t len;

+

+ len = write(self->dev_fd, dev_cmd_ratep_0, sizeof(dev_cmd_ratep_0));

+ EXPECT_EQ(len, -1);

+ EXPECT_EQ(errno, EINVAL);

+

+ len = write(self->dev_fd, dev_cmd_ratep_1, sizeof(dev_cmd_ratep_1));

+ EXPECT_EQ(len, sizeof(dev_cmd_ratep_1));

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_udp_src_min) {

+ ssize_t len;

+

+ len = write(self->dev_fd, dev_cmd_udp_src_min_0, sizeof(dev_cmd_udp_src_min_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_udp_src_min_0));

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_udp_dst_min) {

+ ssize_t len;

+

+ len = write(self->dev_fd, dev_cmd_udp_dst_min_0, sizeof(dev_cmd_udp_dst_min_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_udp_dst_min_0));

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_udp_src_max) {

+ ssize_t len;

+

+ len = write(self->dev_fd, dev_cmd_udp_src_max_0, sizeof(dev_cmd_udp_src_max_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_udp_src_max_0));

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_udp_dst_max) {

+ ssize_t len;

+

+ len = write(self->dev_fd, dev_cmd_udp_dst_max_0, sizeof(dev_cmd_udp_dst_max_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_udp_dst_max_0));

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_clone_skb) {

+ ssize_t len;

+

+ /* clone_skb on (gives EOPNOTSUPP on lo device) */

+ len = write(self->dev_fd, dev_cmd_clone_skb_0, sizeof(dev_cmd_clone_skb_0));

+ EXPECT_EQ(len, -1);

+ EXPECT_EQ(errno, EOPNOTSUPP);

+

+ /* clone_skb off */

+ len = write(self->dev_fd, dev_cmd_clone_skb_1, sizeof(dev_cmd_clone_skb_1));

+ EXPECT_EQ(len, sizeof(dev_cmd_clone_skb_1));

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_count) {

+ ssize_t len;

+

+ len = write(self->dev_fd, dev_cmd_count_0, sizeof(dev_cmd_count_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_count_0));

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_src_mac_count) {

+ ssize_t len;

+

+ len = write(self->dev_fd, dev_cmd_src_mac_count_0, sizeof(dev_cmd_src_mac_count_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_src_mac_count_0));

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_dst_mac_count) {

+ ssize_t len;

+

+ len = write(self->dev_fd, dev_cmd_dst_mac_count_0, sizeof(dev_cmd_dst_mac_count_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_dst_mac_count_0));

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_burst) {

+ ssize_t len;

+

+ /* burst off */

+ len = write(self->dev_fd, dev_cmd_burst_0, sizeof(dev_cmd_burst_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_burst_0));

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_node) {

+ ssize_t len;

+

+ len = write(self->dev_fd, dev_cmd_node_0, sizeof(dev_cmd_node_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_node_0));

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_xmit_mode) {

+ ssize_t len;

+

+ len = write(self->dev_fd, dev_cmd_xmit_mode_0, sizeof(dev_cmd_xmit_mode_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_xmit_mode_0));

+

+ len = write(self->dev_fd, dev_cmd_xmit_mode_1, sizeof(dev_cmd_xmit_mode_1));

+ EXPECT_EQ(len, sizeof(dev_cmd_xmit_mode_1));

+

+ len = write(self->dev_fd, dev_cmd_xmit_mode_2, sizeof(dev_cmd_xmit_mode_2));

+ EXPECT_EQ(len, sizeof(dev_cmd_xmit_mode_2));

+

+ len = write(self->dev_fd, dev_cmd_xmit_mode_3, sizeof(dev_cmd_xmit_mode_3));

+ EXPECT_EQ(len, sizeof(dev_cmd_xmit_mode_3));

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_flag) {

+ ssize_t len;

+

+ /* flag UDPCSUM on */

+ len = write(self->dev_fd, dev_cmd_flag_0, sizeof(dev_cmd_flag_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_flag_0));

+

+ /* flag UDPCSUM off */

+ len = write(self->dev_fd, dev_cmd_flag_1, sizeof(dev_cmd_flag_1));

+ EXPECT_EQ(len, sizeof(dev_cmd_flag_1));

+

+ /* flag invalid */

+ len = write(self->dev_fd, dev_cmd_flag_2, sizeof(dev_cmd_flag_2));

+ EXPECT_EQ(len, sizeof(dev_cmd_flag_2));

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_dst_min) {

+ ssize_t len;

+

+ len = write(self->dev_fd, dev_cmd_dst_min_0, sizeof(dev_cmd_dst_min_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_dst_min_0));

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_dst) {

+ ssize_t len;

+

+ len = write(self->dev_fd, dev_cmd_dst_0, sizeof(dev_cmd_dst_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_dst_0));

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_dst_max) {

+ ssize_t len;

+

+ len = write(self->dev_fd, dev_cmd_dst_max_0, sizeof(dev_cmd_dst_max_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_dst_max_0));

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_dst6) {

+ ssize_t len;

+

+ len = write(self->dev_fd, dev_cmd_dst6_0, sizeof(dev_cmd_dst6_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_dst6_0));

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_dst6_min) {

+ ssize_t len;

+

+ len = write(self->dev_fd, dev_cmd_dst6_min_0, sizeof(dev_cmd_dst6_min_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_dst6_min_0));

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_dst6_max) {

+ ssize_t len;

+

+ len = write(self->dev_fd, dev_cmd_dst6_max_0, sizeof(dev_cmd_dst6_max_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_dst6_max_0));

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_src6) {

+ ssize_t len;

+

+ len = write(self->dev_fd, dev_cmd_src6_0, sizeof(dev_cmd_src6_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_src6_0));

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_src_min) {

+ ssize_t len;

+

+ len = write(self->dev_fd, dev_cmd_src_min_0, sizeof(dev_cmd_src_min_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_src_min_0));

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_src_max) {

+ ssize_t len;

+

+ len = write(self->dev_fd, dev_cmd_src_max_0, sizeof(dev_cmd_src_max_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_src_max_0));

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_dst_mac) {

+ ssize_t len;

+

+ len = write(self->dev_fd, dev_cmd_dst_mac_0, sizeof(dev_cmd_dst_mac_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_dst_mac_0));

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_src_mac) {

+ ssize_t len;

+

+ len = write(self->dev_fd, dev_cmd_src_mac_0, sizeof(dev_cmd_src_mac_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_src_mac_0));

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_clear_counters) {

+ ssize_t len;

+

+ len = write(self->dev_fd, dev_cmd_clear_counters_0, sizeof(dev_cmd_clear_counters_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_clear_counters_0));

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_flows) {

+ ssize_t len;

+

+ len = write(self->dev_fd, dev_cmd_flows_0, sizeof(dev_cmd_flows_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_flows_0));

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_spi) {

+ ssize_t len;

+

+ len = write(self->dev_fd, dev_cmd_spi_0, sizeof(dev_cmd_spi_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_spi_0)) TH_LOG("CONFIG_XFRM not enabled?");

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_flowlen) {

+ ssize_t len;

+

+ len = write(self->dev_fd, dev_cmd_flowlen_0, sizeof(dev_cmd_flowlen_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_flowlen_0));

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_queue_map_min) {

+ ssize_t len;

+

+ len = write(self->dev_fd, dev_cmd_queue_map_min_0, sizeof(dev_cmd_queue_map_min_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_queue_map_min_0));

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_queue_map_max) {

+ ssize_t len;

+

+ len = write(self->dev_fd, dev_cmd_queue_map_max_0, sizeof(dev_cmd_queue_map_max_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_queue_map_max_0));

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_mpls) {

+ ssize_t len;

+

+ len = write(self->dev_fd, dev_cmd_mpls_0, sizeof(dev_cmd_mpls_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_mpls_0));

+

+ len = write(self->dev_fd, dev_cmd_mpls_1, sizeof(dev_cmd_mpls_1));

+ EXPECT_EQ(len, sizeof(dev_cmd_mpls_1));

+

+ len = write(self->dev_fd, dev_cmd_mpls_2, sizeof(dev_cmd_mpls_2));

+ EXPECT_EQ(len, sizeof(dev_cmd_mpls_2));

+

+ len = write(self->dev_fd, dev_cmd_mpls_3, sizeof(dev_cmd_mpls_3));

+ EXPECT_EQ(len, -1);

+ EXPECT_EQ(errno, E2BIG);

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_vlan_id) {

+ ssize_t len;

+

+ len = write(self->dev_fd, dev_cmd_vlan_id_0, sizeof(dev_cmd_vlan_id_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_vlan_id_0));

+

+ len = write(self->dev_fd, dev_cmd_vlan_p_0, sizeof(dev_cmd_vlan_p_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_vlan_p_0));

+

+ len = write(self->dev_fd, dev_cmd_vlan_cfi_0, sizeof(dev_cmd_vlan_cfi_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_vlan_cfi_0));

+

+ len = write(self->dev_fd, dev_cmd_vlan_id_1, sizeof(dev_cmd_vlan_id_1));

+ EXPECT_EQ(len, sizeof(dev_cmd_vlan_id_1));

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_svlan_id) {

+ ssize_t len;

+

+ len = write(self->dev_fd, dev_cmd_svlan_id_0, sizeof(dev_cmd_svlan_id_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_svlan_id_0));

+

+ len = write(self->dev_fd, dev_cmd_svlan_p_0, sizeof(dev_cmd_svlan_p_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_svlan_p_0));

+

+ len = write(self->dev_fd, dev_cmd_svlan_cfi_0, sizeof(dev_cmd_svlan_cfi_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_svlan_cfi_0));

+

+ len = write(self->dev_fd, dev_cmd_svlan_id_1, sizeof(dev_cmd_svlan_id_1));

+ EXPECT_EQ(len, sizeof(dev_cmd_svlan_id_1));

+}

+

+

+TEST_F(proc_net_pktgen, dev_cmd_tos) {

+ ssize_t len;

+

+ len = write(self->dev_fd, dev_cmd_tos_0, sizeof(dev_cmd_tos_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_tos_0));

+

+ len = write(self->dev_fd, dev_cmd_tos_1, sizeof(dev_cmd_tos_1));

+ EXPECT_EQ(len, sizeof(dev_cmd_tos_1));

+

+ len = write(self->dev_fd, dev_cmd_tos_2, sizeof(dev_cmd_tos_2));

+ EXPECT_EQ(len, sizeof(dev_cmd_tos_2));

+}

+

+

+TEST_F(proc_net_pktgen, dev_cmd_traffic_class) {

+ ssize_t len;

+

+ len = write(self->dev_fd, dev_cmd_traffic_class_0, sizeof(dev_cmd_traffic_class_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_traffic_class_0));

+}

+

+TEST_F(proc_net_pktgen, dev_cmd_skb_priority) {

+ ssize_t len;

+

+ len = write(self->dev_fd, dev_cmd_skb_priority_0, sizeof(dev_cmd_skb_priority_0));

+ EXPECT_EQ(len, sizeof(dev_cmd_skb_priority_0));

+}

+

+TEST_HARNESS_MAIN

+ * packet pattern across the sockets and check if it was received resp.

+ EXPECT_EQ(-1, fd[1]) TH_LOG("should fail to bind because both sockets successfully listened.");

+#!/usr/bin/env python3

+# SPDX-License-Identifier: GPL-2.0

+

+from lib.py import ksft_exit, ksft_run, ksft_ge, RtnlAddrFamily

+import socket

+

+IPV4_ALL_HOSTS_MULTICAST = b'\xe0\x00\x00\x01'

+

+def dump_mcaddr_check(rtnl: RtnlAddrFamily) -> None:

+ """

+ Verify that at least one interface has the IPv4 all-hosts multicast address.

+ At least the loopback interface should have this address.

+ """

+

+ addresses = rtnl.getmaddrs({"ifa-family": socket.AF_INET}, dump=True)

+

+ all_host_multicasts = [

+ addr for addr in addresses if addr['ifa-multicast'] == IPV4_ALL_HOSTS_MULTICAST

+ ]

+

+ ksft_ge(len(all_host_multicasts), 1,

+ "No interface found with the IPv4 all-hosts multicast address")

+

+def main() -> None:

+ rtnl = RtnlAddrFamily()

+ ksft_run([dump_mcaddr_check], args=(rtnl, ))

+ ksft_exit()

+

+if __name__ == "__main__":

+ main()

+ echo 200000 > "/sys/class/net/${ns_dev}/gro_flush_timeout"

+ echo 1 > "/sys/class/net/${ns_dev}/napi_defer_hard_irqs"

+// SPDX-License-Identifier: GPL-2.0

+

+#include <errno.h>

+#include <netdb.h>

+#include <stdbool.h>

+#include <stdio.h>

+#include <stdlib.h>

+#include <string.h>

+#include <unistd.h>

+#include <linux/types.h>

+#include <sys/socket.h>

+#include <netinet/in.h>

+#include <arpa/inet.h>

+

+#ifndef SO_RCVPRIORITY

+#define SO_RCVPRIORITY 82

+#endif

+

+struct options {

+ __u32 val;

+ int name;

+ int rcvname;

+ const char *host;

+ const char *service;

+} opt;

+

+static void __attribute__((noreturn)) usage(const char *bin)

+{

+ printf("Usage: %s [opts] <dst host> <dst port / service>\n", bin);

+ printf("Options:\n"

+ "\t\t-M val Test SO_RCVMARK\n"

+ "\t\t-P val Test SO_RCVPRIORITY\n"

+ "");

+ exit(EXIT_FAILURE);

+}

+

+static void parse_args(int argc, char *argv[])

+{

+ int o;

+

+ while ((o = getopt(argc, argv, "M:P:")) != -1) {

+ switch (o) {

+ case 'M':

+ opt.val = atoi(optarg);

+ opt.name = SO_MARK;

+ opt.rcvname = SO_RCVMARK;

+ break;

+ case 'P':

+ opt.val = atoi(optarg);

+ opt.name = SO_PRIORITY;

+ opt.rcvname = SO_RCVPRIORITY;

+ break;

+ default:

+ usage(argv[0]);

+ break;

+ }

+ }

+

+ if (optind != argc - 2)

+ usage(argv[0]);

+

+ opt.host = argv[optind];

+ opt.service = argv[optind + 1];

+}

+

+int main(int argc, char *argv[])

+{

+ int err = 0;

+ int recv_fd = -1;

+ int ret_value = 0;

+ __u32 recv_val;

+ struct cmsghdr *cmsg;

+ char cbuf[CMSG_SPACE(sizeof(__u32))];

+ char recv_buf[CMSG_SPACE(sizeof(__u32))];

+ struct iovec iov[1];

+ struct msghdr msg;

+ struct sockaddr_in recv_addr4;

+ struct sockaddr_in6 recv_addr6;

+

+ parse_args(argc, argv);

+

+ int family = strchr(opt.host, ':') ? AF_INET6 : AF_INET;

+

+ recv_fd = socket(family, SOCK_DGRAM, IPPROTO_UDP);

+ if (recv_fd < 0) {

+ perror("Can't open recv socket");

+ ret_value = -errno;

+ goto cleanup;

+ }

+

+ err = setsockopt(recv_fd, SOL_SOCKET, opt.rcvname, &opt.val, sizeof(opt.val));

+ if (err < 0) {

+ perror("Recv setsockopt error");

+ ret_value = -errno;

+ goto cleanup;

+ }

+

+ if (family == AF_INET) {

+ memset(&recv_addr4, 0, sizeof(recv_addr4));

+ recv_addr4.sin_family = family;

+ recv_addr4.sin_port = htons(atoi(opt.service));

+

+ if (inet_pton(family, opt.host, &recv_addr4.sin_addr) <= 0) {

+ perror("Invalid IPV4 address");

+ ret_value = -errno;

+ goto cleanup;

+ }

+

+ err = bind(recv_fd, (struct sockaddr *)&recv_addr4, sizeof(recv_addr4));

+ } else {

+ memset(&recv_addr6, 0, sizeof(recv_addr6));

+ recv_addr6.sin6_family = family;

+ recv_addr6.sin6_port = htons(atoi(opt.service));

+

+ if (inet_pton(family, opt.host, &recv_addr6.sin6_addr) <= 0) {

+ perror("Invalid IPV6 address");

+ ret_value = -errno;

+ goto cleanup;

+ }

+

+ err = bind(recv_fd, (struct sockaddr *)&recv_addr6, sizeof(recv_addr6));

+ }

+

+ if (err < 0) {

+ perror("Recv bind error");

+ ret_value = -errno;

+ goto cleanup;

+ }

+

+ iov[0].iov_base = recv_buf;

+ iov[0].iov_len = sizeof(recv_buf);

+

+ memset(&msg, 0, sizeof(msg));

+ msg.msg_iov = iov;

+ msg.msg_iovlen = 1;

+ msg.msg_control = cbuf;

+ msg.msg_controllen = sizeof(cbuf);

+

+ err = recvmsg(recv_fd, &msg, 0);

+ if (err < 0) {

+ perror("Message receive error");

+ ret_value = -errno;

+ goto cleanup;

+ }

+

+ for (cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL; cmsg = CMSG_NXTHDR(&msg, cmsg)) {

+ if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == opt.name) {

+ recv_val = *(__u32 *)CMSG_DATA(cmsg);

+ printf("Received value: %u\n", recv_val);

+

+ if (recv_val != opt.val) {

+ fprintf(stderr, "Error: expected value: %u, got: %u\n",

+ opt.val, recv_val);

+ ret_value = -EINVAL;

+ }

+ goto cleanup;

+ }

+ }

+

+ fprintf(stderr, "Error: No matching cmsg received\n");

+ ret_value = -ENOMSG;

+

+cleanup:

+ if (recv_fd >= 0)

+ close(recv_fd);

+

+ return ret_value;

+}

+static volatile int sk_pair;

+ struct tcp_counters cnt1, cnt2;

+ test_cnt poll_cnt = (cnt_expected == TEST_CNT_GOOD) ? 0 : cnt_expected;

+ if (pwd && test_get_tcp_counters(lsk, &cnt1))

+ test_error("test_get_tcp_counters()");

+ err = test_skpair_wait_poll(lsk, 0, poll_cnt, &sk_pair);

+ sk_pair = err;

+ test_fail("%s: timed out for accept()", tst_name);

+ } else if (err == -EKEYREJECTED) {

+ if (!fault(KEYREJECT))

+ test_fail("%s: key was rejected", tst_name);

+ test_error("test_skpair_wait_poll()");

+ test_fail("%s: ready to accept", tst_name);

+ if (pwd && test_get_tcp_counters(lsk, &cnt2))

+ test_error("test_get_tcp_counters()");

+ test_assert_counters(tst_name, &cnt1, &cnt2, cnt_expected);

+ "TCPAOKeyNotFound", TEST_CNT_NS_KEY_NOT_FOUND, FAULT_TIMEOUT);

+ /* Key rejected by the other side, failing short through skpair */

+ this_ip_dest, -1, 100, 100, 0, NULL, 0, FAULT_KEYREJECT);

+ struct tcp_counters cnt1, cnt2;

+ if (pwd && test_get_tcp_counters(sk, &cnt1))

+ test_error("test_get_tcp_counters()");

+ ret = test_skpair_connect_poll(sk, this_ip_dest, port, cnt_expected, &sk_pair);

+ sk_pair = ret;

+ if (test_get_tcp_counters(sk, &cnt2))

+ test_error("test_get_tcp_counters()");

+ test_assert_counters(tst_name, &cnt1, &cnt2, cnt_expected);

+ } else if (pwd) {

+ test_tcp_counters_free(&cnt1);

+ /*

+ * XXX: The test doesn't increase any counters, see tcp_make_synack().

+ * Potentially, it can be speed up by setting sk_pair = -ETIMEDOUT

+ * but the price would be increased complexity of the tracer thread.

+ */

+ struct tcp_counters ao1, ao2;

+ if (test_get_tcp_counters(sk, &ao1))

+ test_error("test_get_tcp_counters()");

+ if (test_client_verify(sk, 100, nr_packets)) {

+ if (test_get_tcp_counters(sk, &ao2))

+ test_error("test_get_tcp_counters()");

+ if (test_assert_counters("connect", &ao1, &ao2, TEST_CNT_GOOD))

+ before_aogood, ao1.ao.ao_info_pkt_good,

+ ao1.ao.key_cnts[0].pkt_good,

+ after_aogood, ao2.ao.ao_info_pkt_good,

+ ao2.ao.key_cnts[0].pkt_good,

+ struct tcp_counters cnt1, cnt2;

+ if (test_get_tcp_counters(sk, &cnt1))

+ test_error("test_get_tcp_counters()");

+ if (test_get_tcp_counters(sk, &cnt2))

+ test_error("test_get_tcp_counters()");

+ test_assert_counters(NULL, &cnt1, &cnt2, TEST_CNT_GOOD);

+ test_assert_counters(NULL, &cnt1, &cnt2, TEST_CNT_GOOD | TEST_CNT_AO_DROPPED_ICMP);

+ if (test_client_verify(sk, packet_size, packets_nr)) {

+ struct tcp_counters *a, struct tcp_counters *b)

+ test_assert_counters_sk(tst_name, a, b, TEST_CNT_GOOD);

+ test_assert_counters_key(tst_name, &a->ao, &b->ao,

+ rx_cnt_expected ? TEST_CNT_KEY_GOOD : 0,

+ sndid, rcvid);

+ test_tcp_counters_free(a);

+ test_tcp_counters_free(b);

+ struct tcp_counters *begin,

+ struct tcp_counters lsk_c1, lsk_c2;

+ if (test_get_tcp_counters(lsk, &lsk_c1))

+ test_error("test_get_tcp_counters()");

+ if (test_get_tcp_counters(sk, begin))

+ test_error("test_get_tcp_counters()");

+ if (test_get_tcp_counters(lsk, &lsk_c2))

+ test_error("test_get_tcp_counters()");

+ struct tcp_counters *begin)

+ struct tcp_counters end;

+ if (test_get_tcp_counters(sk, &end))

+ test_error("test_get_tcp_counters()");

+ struct tcp_counters tmp;

+ struct tcp_counters tmp;

+ struct tcp_counters *before,

+ if (before && test_get_tcp_counters(sk, before))

+ test_error("test_get_tcp_counters()");

+ if (test_client_verify(sk, msg_sz, msg_nr)) {

+ test_tcp_counters_free(before);

+ struct tcp_counters *before,

+ struct tcp_counters *start)

+ struct tcp_counters end;

+ if (start && test_get_tcp_counters(sk, &end))

+ test_error("test_get_tcp_counters()");

+ if (test_client_verify(sk, msg_len, nr_packets))

+ struct tcp_counters tmp;

+ if (test_client_verify(sk, msg_len, nr_packets))

+ struct tcp_counters tmp;

+ if (test_client_verify(sk, msg_len, nr_packets)) {

+ test_tcp_counters_free(&tmp);

+ struct tcp_counters tmp;

+ void *addr, size_t addr_sz, bool async);

+ * [in process of removal, don't use in new tests]

+ unsigned int port, bool async)

+ (void *)&addr, sizeof(addr), async);

+ return _test_connect_socket(sk, taddr, port, false);

+extern int test_client_verify(int sk, const size_t msg_len, const size_t nr);

+

+struct tcp_counters {

+ struct tcp_ao_counters ao;

+ uint64_t netns_md5_notfound;

+ uint64_t netns_md5_unexpected;

+ uint64_t netns_md5_failure;

+};

+

+extern int test_get_tcp_counters(int sk, struct tcp_counters *out);

+#define TEST_CNT_NS_MD5_NOT_FOUND BIT(12)

+#define TEST_CNT_NS_MD5_UNEXPECTED BIT(13)

+#define TEST_CNT_NS_MD5_FAILURE BIT(14)

+#define _for_each_counter(f) \

+do { \

+ /* per-netns */ \

+ f(ao.netns_ao_good, TEST_CNT_NS_GOOD); \

+ f(ao.netns_ao_bad, TEST_CNT_NS_BAD); \

+ f(ao.netns_ao_key_not_found, TEST_CNT_NS_KEY_NOT_FOUND); \

+ f(ao.netns_ao_required, TEST_CNT_NS_AO_REQUIRED); \

+ f(ao.netns_ao_dropped_icmp, TEST_CNT_NS_DROPPED_ICMP); \

+ /* per-socket */ \

+ f(ao.ao_info_pkt_good, TEST_CNT_SOCK_GOOD); \

+ f(ao.ao_info_pkt_bad, TEST_CNT_SOCK_BAD); \

+ f(ao.ao_info_pkt_key_not_found, TEST_CNT_SOCK_KEY_NOT_FOUND); \

+ f(ao.ao_info_pkt_ao_required, TEST_CNT_SOCK_AO_REQUIRED); \

+ f(ao.ao_info_pkt_dropped_icmp, TEST_CNT_SOCK_DROPPED_ICMP); \

+ /* non-AO */ \

+ f(netns_md5_notfound, TEST_CNT_NS_MD5_NOT_FOUND); \

+ f(netns_md5_unexpected, TEST_CNT_NS_MD5_UNEXPECTED); \

+ f(netns_md5_failure, TEST_CNT_NS_MD5_FAILURE); \

+} while (0)

+

+extern test_cnt test_cmp_counters(struct tcp_counters *before,

+ struct tcp_counters *after);

+extern int test_assert_counters_sk(const char *tst_name,

+ struct tcp_counters *before, struct tcp_counters *after,

+extern int test_assert_counters_key(const char *tst_name,

+extern void test_tcp_counters_free(struct tcp_counters *cnts);

+

+/*

+ * Polling for netns and socket counters during select()/connect() and also

+ * client/server messaging. Instead of constant timeout on underlying select(),

+ * check the counters and return early. This allows to pass the tests where

+ * timeout is expected without waiting for that fixing timeout (tests speed-up).

+ * Previously shorter timeouts were used for tests expecting to time out,

+ * but that leaded to sporadic false positives on counter checks failures,

+ * as one second timeouts aren't enough for TCP retransmit.

+ *

+ * Two sides of the socketpair (client/server) should synchronize failures

+ * using a shared variable *err, so that they can detect the other side's

+ * failure.

+ */

+extern int test_skpair_wait_poll(int sk, bool write, test_cnt cond,

+ volatile int *err);

+extern int _test_skpair_connect_poll(int sk, const char *device,

+ void *addr, size_t addr_sz,

+ test_cnt cond, volatile int *err);

+static inline int test_skpair_connect_poll(int sk, const union tcp_addr taddr,

+ unsigned int port,

+ test_cnt cond, volatile int *err)

+{

+ sockaddr_af addr;

+

+ tcp_addr_to_sockaddr_in(&addr, &taddr, htons(port));

+ return _test_skpair_connect_poll(sk, veth_name,

+ (void *)&addr, sizeof(addr), cond, err);

+}

+

+extern int test_skpair_client(int sk, const size_t msg_len, const size_t nr,

+ test_cnt cond, volatile int *err);

+extern int test_skpair_server(int sk, ssize_t quota,

+ test_cnt cond, volatile int *err);

+

+ * Frees buffers allocated in test_get_tcp_counters().

+ * to test_get_tcp_counters(). Check key counters manually if they

+static inline int test_assert_counters(const char *tst_name,

+ struct tcp_counters *before,

+ struct tcp_counters *after,

+ test_cnt expected)

+ ret = test_assert_counters_sk(tst_name, before, after, expected);

+ ret = test_assert_counters_key(tst_name, &before->ao, &after->ao,

+ expected, -1, -1);

+ test_tcp_counters_free(before);

+ test_tcp_counters_free(after);

+ e->fin ? "F" : "", e->syn ? "S" : "", e->rst ? "R" : "",

+ e->psh ? "P" : "", e->ack ? "." : "",

+static int __test_wait_fd(int sk, struct timeval *tv, bool write)

+ ret = select(sk + 1, NULL, &fds, &efds, tv);

+ ret = select(sk + 1, &fds, NULL, &efds, tv);

+int test_wait_fd(int sk, time_t sec, bool write)

+{

+ struct timeval tv = { .tv_sec = sec, };

+

+ return __test_wait_fd(sk, sec ? &tv : NULL, write);

+}

+

+static bool __skpair_poll_should_stop(int sk, struct tcp_counters *c,

+ test_cnt condition)

+{

+ struct tcp_counters c2;

+ test_cnt diff;

+

+ if (test_get_tcp_counters(sk, &c2))

+ test_error("test_get_tcp_counters()");

+

+ diff = test_cmp_counters(c, &c2);

+ test_tcp_counters_free(&c2);

+ return (diff & condition) == condition;

+}

+

+/* How often wake up and check netns counters & paired (*err) */

+#define POLL_USEC 150

+static int __test_skpair_poll(int sk, bool write, uint64_t timeout,

+ struct tcp_counters *c, test_cnt cond,

+ volatile int *err)

+{

+ uint64_t t;

+

+ for (t = 0; t <= timeout * 1000000; t += POLL_USEC) {

+ struct timeval tv = { .tv_usec = POLL_USEC, };

+ int ret;

+

+ ret = __test_wait_fd(sk, &tv, write);

+ if (ret != -ETIMEDOUT)

+ return ret;

+ if (c && cond && __skpair_poll_should_stop(sk, c, cond))

+ break;

+ if (err && *err)

+ return *err;

+ }

+ if (err)

+ *err = -ETIMEDOUT;

+ return -ETIMEDOUT;

+}

+

+ void *addr, size_t addr_sz, bool async)

+ if (async)

+ err = test_wait_fd(sk, TEST_TIMEOUT_SEC, 1);

+int test_skpair_wait_poll(int sk, bool write,

+ test_cnt cond, volatile int *err)

+{

+ struct tcp_counters c;

+ int ret;

+

+ *err = 0;

+ if (test_get_tcp_counters(sk, &c))

+ test_error("test_get_tcp_counters()");

+ synchronize_threads(); /* 1: init skpair & read nscounters */

+

+ ret = __test_skpair_poll(sk, write, TEST_TIMEOUT_SEC, &c, cond, err);

+ test_tcp_counters_free(&c);

+ return ret;

+}

+

+int _test_skpair_connect_poll(int sk, const char *device,

+ void *addr, size_t addr_sz,

+ test_cnt condition, volatile int *err)

+{

+ struct tcp_counters c;

+ int ret;

+

+ *err = 0;

+ if (test_get_tcp_counters(sk, &c))

+ test_error("test_get_tcp_counters()");

+ synchronize_threads(); /* 1: init skpair & read nscounters */

+ ret = __test_connect_socket(sk, device, addr, addr_sz, true);

+ if (ret < 0) {

+ test_tcp_counters_free(&c);

+ return (*err = ret);

+ }

+ ret = __test_skpair_poll(sk, 1, TEST_TIMEOUT_SEC, &c, condition, err);

+ if (ret < 0)

+ close(sk);

+ test_tcp_counters_free(&c);

+ return ret;

+}

+

+int test_get_tcp_counters(int sk, struct tcp_counters *out)

+ bool c1, c2, c3, c4, c5, c6, c7, c8;

+ out->ao.netns_ao_good = netstat_get(ns, "TCPAOGood", &c1);

+ out->ao.netns_ao_bad = netstat_get(ns, "TCPAOBad", &c2);

+ out->ao.netns_ao_key_not_found = netstat_get(ns, "TCPAOKeyNotFound", &c3);

+ out->ao.netns_ao_required = netstat_get(ns, "TCPAORequired", &c4);

+ out->ao.netns_ao_dropped_icmp = netstat_get(ns, "TCPAODroppedIcmps", &c5);

+ out->netns_md5_notfound = netstat_get(ns, "TCPMD5NotFound", &c6);

+ out->netns_md5_unexpected = netstat_get(ns, "TCPMD5Unexpected", &c7);

+ out->netns_md5_failure = netstat_get(ns, "TCPMD5Failure", &c8);

+ if (c1 || c2 || c3 || c4 || c5 || c6 || c7 || c8)

+ if (err == -ENOENT)

+ return 0;

+ out->ao.ao_info_pkt_good = info.pkt_good;

+ out->ao.ao_info_pkt_bad = info.pkt_bad;

+ out->ao.ao_info_pkt_key_not_found = info.pkt_key_not_found;

+ out->ao.ao_info_pkt_ao_required = info.pkt_ao_required;

+ out->ao.ao_info_pkt_dropped_icmp = info.pkt_dropped_icmp;

+ out->ao.nr_keys = (size_t)nr_keys;

+ out->ao.key_cnts = calloc(nr_keys, sizeof(out->ao.key_cnts[0]));

+ if (!out->ao.key_cnts) {

+ out->ao.key_cnts[nr_keys].sndid = key_dump[nr_keys].sndid;

+ out->ao.key_cnts[nr_keys].rcvid = key_dump[nr_keys].rcvid;

+ out->ao.key_cnts[nr_keys].pkt_good = key_dump[nr_keys].pkt_good;

+ out->ao.key_cnts[nr_keys].pkt_bad = key_dump[nr_keys].pkt_bad;

+test_cnt test_cmp_counters(struct tcp_counters *before,

+ struct tcp_counters *after)

+{

+#define __cmp(cnt, e_cnt) \

+do { \

+ if (before->cnt > after->cnt) \

+ test_error("counter " __stringify(cnt) " decreased"); \

+ if (before->cnt != after->cnt) \

+ ret |= e_cnt; \

+} while (0)

+

+ test_cnt ret = 0;

+ size_t i;

+

+ if (before->ao.nr_keys != after->ao.nr_keys)

+ test_error("the number of keys has changed");

+

+ _for_each_counter(__cmp);

+

+ i = before->ao.nr_keys;

+ while (i--) {

+ __cmp(ao.key_cnts[i].pkt_good, TEST_CNT_KEY_GOOD);

+ __cmp(ao.key_cnts[i].pkt_bad, TEST_CNT_KEY_BAD);

+ }

+#undef __cmp

+ return ret;

+}

+

+int test_assert_counters_sk(const char *tst_name,

+ struct tcp_counters *before,

+ struct tcp_counters *after,

+ test_cnt expected)

+#define __cmp_ao(cnt, e_cnt) \

+ tst_name ?: "", before->cnt, after->cnt); \

+ if ((before->cnt != after->cnt) != !!(expected & e_cnt)) { \

+ tst_name ?: "", (expected & e_cnt) ? "" : "not ", \

+} while (0)

+ _for_each_counter(__cmp_ao);

+int test_assert_counters_key(const char *tst_name,

+ struct tcp_ao_counters *before,

+ struct tcp_ao_counters *after,

+ test_cnt expected, int sndid, int rcvid)

+#define __cmp_ao(i, cnt, e_cnt) \

+ if ((before->key_cnts[i].cnt != after->key_cnts[i].cnt) != !!(expected & e_cnt)) { \

+ tst_name ?: "", (expected & e_cnt) ? "" : "not ",\

+} while (0)

+ __cmp_ao(i, pkt_good, TEST_CNT_KEY_GOOD);

+ __cmp_ao(i, pkt_bad, TEST_CNT_KEY_BAD);

+void test_tcp_counters_free(struct tcp_counters *cnts)

+ free(cnts->ao.key_cnts);

+static ssize_t _test_server_run(int sk, ssize_t quota, struct tcp_counters *c,

+ test_cnt cond, volatile int *err,

+ time_t timeout_sec)

+ ret = __test_skpair_poll(sk, 0, timeout_sec, c, cond, err);

+ ret = __test_skpair_poll(sk, 1, timeout_sec, c, cond, err);

+ssize_t test_server_run(int sk, ssize_t quota, time_t timeout_sec)

+{

+ return _test_server_run(sk, quota, NULL, 0, NULL,

+ timeout_sec ?: TEST_TIMEOUT_SEC);

+}

+

+int test_skpair_server(int sk, ssize_t quota, test_cnt cond, volatile int *err)

+{

+ struct tcp_counters c;

+ ssize_t ret;

+

+ *err = 0;

+ if (test_get_tcp_counters(sk, &c))

+ test_error("test_get_tcp_counters()");

+ synchronize_threads(); /* 1: init skpair & read nscounters */

+

+ ret = _test_server_run(sk, quota, &c, cond, err, TEST_TIMEOUT_SEC);

+ test_tcp_counters_free(&c);

+ return ret;

+}

+

+static ssize_t test_client_loop(int sk, size_t buf_sz, const size_t msg_len,

+ struct tcp_counters *c, test_cnt cond,

+ volatile int *err)

+ char *buf;

+ buf = alloca(buf_sz);

+ if (!buf)

+ return -ENOMEM;

+ randomize_buffer(buf, buf_sz);

+

+ ret = __test_skpair_poll(sk, 1, TEST_TIMEOUT_SEC, c, cond, err);

+ ret = __test_skpair_poll(sk, 0, TEST_TIMEOUT_SEC,

+ c, cond, err);

+int test_client_verify(int sk, const size_t msg_len, const size_t nr)

+ ret = test_client_loop(sk, buf_sz, msg_len, NULL, 0, NULL);

+ if (ret < 0)

+ return (int)ret;

+ return ret != buf_sz ? -1 : 0;

+}

+

+int test_skpair_client(int sk, const size_t msg_len, const size_t nr,

+ test_cnt cond, volatile int *err)

+{

+ struct tcp_counters c;

+ size_t buf_sz = msg_len * nr;

+ ssize_t ret;

+

+ *err = 0;

+ if (test_get_tcp_counters(sk, &c))

+ test_error("test_get_tcp_counters()");

+ synchronize_threads(); /* 1: init skpair & read nscounters */

+

+ ret = test_client_loop(sk, buf_sz, msg_len, &c, cond, err);

+ test_tcp_counters_free(&c);

+ test_cnt poll_cnt = (cnt_expected == TEST_CNT_GOOD) ? 0 : cnt_expected;

+ struct tcp_counters cnt1, cnt2;

+ int sk, lsk, dummy;

+ if (test_get_tcp_counters(sk, &cnt1))

+ test_error("test_get_tcp_counters()");

+ bytes = test_skpair_server(sk, quota, poll_cnt, &dummy);

+ if (test_get_tcp_counters(sk, &cnt2))

+ test_error("test_get_tcp_counters()");

+ test_assert_counters(tst_name, &cnt1, &cnt2, cnt_expected);

+ test_fail("%s(server): %s counter did not increase: %" PRIu64 " <= %" PRIu64,

+ tst_name, cnt_name, after_cnt, before_cnt);

+ test_ok("%s(server): counter %s increased %" PRIu64 " => %" PRIu64,

+ try_server_run("TCP-AO migrate to another socket (server)", port++,

+ try_server_run("TCP-AO with wrong send ISN (server)", port++,

+ try_server_run("TCP-AO with wrong receive ISN (server)", port++,

+ try_server_run("TCP-AO with wrong send SEQ ext number (server)", port++,

+ try_server_run("TCP-AO with wrong receive SEQ ext number (server)",

+ port++, FAULT_TIMEOUT, TEST_CNT_NS_BAD | TEST_CNT_GOOD);

+ if (test_client_verify(sk, msg_len, nr_packets))

+ test_cnt poll_cnt = (cnt_expected == TEST_CNT_GOOD) ? 0 : cnt_expected;

+ struct tcp_counters cnt1, cnt2;

+ int sk, dummy;

+ if (test_get_tcp_counters(sk, &cnt1))

+ test_error("test_get_tcp_counters()");

+ if (test_skpair_client(sk, msg_len, nr_packets, poll_cnt, &dummy)) {

+ test_fail("%s: post-migrate connection is working", tst_name);

+

+ if (test_get_tcp_counters(sk, &cnt2))

+ test_error("test_get_tcp_counters()");

+ test_assert_counters(tst_name, &cnt1, &cnt2, cnt_expected);

+ test_sk_restore("TCP-AO migrate to another socket (client)", port++,

+ test_sk_restore("TCP-AO with wrong send ISN (client)", port++,

+ test_sk_restore("TCP-AO with wrong receive ISN (client)", port++,

+ test_sk_restore("TCP-AO with wrong send SEQ ext number (client)",

+ port++, &saddr, &tcp_img, &ao_img, FAULT_TIMEOUT,

+ test_sk_restore("TCP-AO with wrong receive SEQ ext number (client)",

+ port++, &saddr, &tcp_img, &ao_img, FAULT_TIMEOUT,

+ struct tcp_counters cnt1, cnt2;

+ if (test_get_tcp_counters(lsk, &cnt1))

+ test_error("test_get_tcp_counters()");

+ if (test_get_tcp_counters(lsk, &cnt2))

+ test_error("test_get_tcp_counters()");

+ if (test_assert_counters("active RST server", &cnt1, &cnt2, TEST_CNT_GOOD))

+ struct tcp_counters cnt1, cnt2;

+ if (test_get_tcp_counters(sk, &cnt1))

+ test_error("test_get_tcp_counters()");

+ if (test_get_tcp_counters(sk, &cnt2))

+ test_error("test_get_tcp_counters()");

+ test_assert_counters("passive RST server", &cnt1, &cnt2, TEST_CNT_GOOD);

+ err = _test_connect_socket(sk[i], this_ip_dest, port, i != 0);

+ err = _test_connect_socket(sk[last], this_ip_dest, port, 1);

+ if (test_client_verify(sk[0], packet_sz, quota / packet_sz))

+ struct tcp_counters cnt1, cnt2;

+ if (test_client_verify(sk, packet_sz, quota / packet_sz))

+ if (test_get_tcp_counters(sk, &cnt1))

+ test_error("test_get_tcp_counters()");

+ err = test_client_verify(sk, packet_sz, quota / packet_sz);

+ if (test_get_tcp_counters(sk, &cnt2))

+ test_error("test_get_tcp_counters()");

+ test_assert_counters("client passive RST", &cnt1, &cnt2, TEST_CNT_GOOD);

+ struct tcp_counters before, after;

+ if (test_get_tcp_counters(sk, &before))

+ test_error("test_get_tcp_counters()");

+ sizeof(addr), 0) < 0) {

+ if (test_client_verify(sk, 100, nr_packets)) {

+ if (test_get_tcp_counters(sk, &after))

+ test_error("test_get_tcp_counters()");

+ if (test_assert_counters(tst, &before, &after, TEST_CNT_GOOD)) {

+ if (test_client_verify(sk, 100, nr_packets)) {

+ struct tcp_counters *cnt)

+ if (test_get_tcp_counters(sk, cnt))

+ test_error("test_get_tcp_counters()");

+ struct tcp_counters cnt1, cnt2;

+ client_new_port, &cnt1);

+ if (test_get_tcp_counters(sk, &cnt2))

+ test_error("test_get_tcp_counters()");

+ test_assert_counters(NULL, &cnt1, &cnt2, TEST_CNT_GOOD);

+ struct tcp_counters cnt1, cnt2;

+ if (test_client_verify(sk, msg_len, nr_packets)) {

+ test_server_port + 1, &cnt1);

+ if (test_client_verify(sk, msg_len, nr_packets))

+ if (test_get_tcp_counters(sk, &cnt2))

+ test_error("test_get_tcp_counters()");

+ test_assert_counters(NULL, &cnt1, &cnt2, TEST_CNT_GOOD);

+static volatile int sk_pair;

+ struct tcp_counters cnt1, cnt2;

+ test_cnt poll_cnt = (cnt_expected == TEST_CNT_GOOD) ? 0 : cnt_expected;

+ int lsk, err, sk = -1;

+ if (ao_addr && test_get_tcp_counters(lsk, &cnt1))

+ test_error("test_get_tcp_counters()");

+ err = test_skpair_wait_poll(lsk, 0, poll_cnt, &sk_pair);

+ sk_pair = err;

+ test_fail("%s: timed out for accept()", tst_name);

+ } else if (err == -EKEYREJECTED) {

+ if (!fault(KEYREJECT))

+ test_fail("%s: key was rejected", tst_name);

+ test_error("test_skpair_wait_poll()");

+ test_fail("%s: ready to accept", tst_name);

+ if (ao_addr && test_get_tcp_counters(lsk, &cnt2))

+ test_error("test_get_tcp_counters()");

+ test_assert_counters(tst_name, &cnt1, &cnt2, cnt_expected);

+ if (sk >= 0)

+ try_accept("[server] AO server (INADDR_ANY): AO client", port++, NULL, 0,

+ try_accept("[server] AO server (INADDR_ANY): MD5 client", port++, NULL, 0,

+ TEST_CNT_NS_MD5_UNEXPECTED, 1, FAULT_TIMEOUT);

+ try_accept("[server] AO server (INADDR_ANY): no sign client", port++, NULL, 0,

+ try_accept("[server] AO server (AO_REQUIRED): AO client", port++, NULL, 0,

+ try_accept("[server] AO server (AO_REQUIRED): unsigned client", port++, NULL, 0,

+ try_accept("[server] MD5 server (INADDR_ANY): AO client", port++, &addr_any, 0,

+ TEST_CNT_NS_KEY_NOT_FOUND, 1, FAULT_TIMEOUT);

+ try_accept("[server] MD5 server (INADDR_ANY): MD5 client", port++, &addr_any, 0,

+ try_accept("[server] MD5 server (INADDR_ANY): no sign client", port++, &addr_any,

+ TEST_CNT_NS_MD5_NOT_FOUND, 1, FAULT_TIMEOUT);

+ try_accept("[server] no sign server: AO client", port++, NULL, 0,

+ TEST_CNT_NS_KEY_NOT_FOUND, 0, FAULT_TIMEOUT);

+ try_accept("[server] no sign server: MD5 client", port++, NULL, 0,

+ TEST_CNT_NS_MD5_UNEXPECTED, 1, FAULT_TIMEOUT);

+ try_accept("[server] no sign server: no sign client", port++, NULL, 0,

+ try_accept("[server] AO+MD5 server: AO client (matching)", port++,

+ try_accept("[server] AO+MD5 server: AO client (misconfig, matching MD5)", port++,

+ try_accept("[server] AO+MD5 server: AO client (misconfig, non-matching)", port++,

+ try_accept("[server] AO+MD5 server: MD5 client (matching)", port++,

+ try_accept("[server] AO+MD5 server: MD5 client (misconfig, matching AO)", port++,

+ 100, 100, 0, "TCPMD5Unexpected",

+ TEST_CNT_NS_MD5_UNEXPECTED, 1, FAULT_TIMEOUT);

+ try_accept("[server] AO+MD5 server: MD5 client (misconfig, non-matching)", port++,

+ 100, 100, 0, "TCPMD5Unexpected",

+ TEST_CNT_NS_MD5_UNEXPECTED, 1, FAULT_TIMEOUT);

+ try_accept("[server] AO+MD5 server: no sign client (unmatched)", port++,

+ try_accept("[server] AO+MD5 server: no sign client (misconfig, matching AO)",

+ try_accept("[server] AO+MD5 server: no sign client (misconfig, matching MD5)",

+ 100, 100, 0, "TCPMD5NotFound",

+ TEST_CNT_NS_MD5_NOT_FOUND, 1, FAULT_TIMEOUT);

+ /* Key rejected by the other side, failing short through skpair */

+ try_accept("[server] AO+MD5 server: client with both [TCP-MD5] and TCP-AO keys",

+ 100, 100, 0, NULL, 0, 1, FAULT_KEYREJECT);

+ try_accept("[server] AO+MD5 server: client with both TCP-MD5 and [TCP-AO] keys",

+ 100, 100, 0, NULL, 0, 1, FAULT_KEYREJECT);

+ ret = test_skpair_connect_poll(sk, this_ip_dest, port, 0, &sk_pair);

+ sk_pair = ret;

+ if (ret > 0) /* test_skpair_connect_poll() cleans up on failure */

+ ret = test_skpair_connect_poll(sk, this_ip_dest, port, 0, &sk_pair);

+ if (ret < 0) {

+ if (ret > 0) /* test_skpair_connect_poll() cleans up on failure */

+#!/bin/bash

+# SPDX-License-Identifier: GPL-2.0

+

+source lib.sh

+

+HOSTS=("127.0.0.1" "::1")

+PORT=1234

+TOTAL_TESTS=0

+FAILED_TESTS=0

+

+declare -A TESTS=(

+ ["SO_RCVPRIORITY"]="-P 2"

+ ["SO_RCVMARK"]="-M 3"

+)

+

+check_result() {

+ ((TOTAL_TESTS++))

+ if [ "$1" -ne 0 ]; then

+ ((FAILED_TESTS++))

+ fi

+}

+

+cleanup()

+{

+ cleanup_ns $NS

+}

+

+trap cleanup EXIT

+

+setup_ns NS

+

+for HOST in "${HOSTS[@]}"; do

+ PROTOCOL="IPv4"

+ if [[ "$HOST" == "::1" ]]; then

+ PROTOCOL="IPv6"

+ fi

+ for test_name in "${!TESTS[@]}"; do

+ echo "Running $test_name test, $PROTOCOL"

+ arg=${TESTS[$test_name]}

+

+ ip netns exec $NS ./so_rcv_listener $arg $HOST $PORT &

+ LISTENER_PID=$!

+

+ sleep 0.5

+

+ if ! ip netns exec $NS ./cmsg_sender $arg $HOST $PORT; then

+ echo "Sender failed for $test_name, $PROTOCOL"

+ kill "$LISTENER_PID" 2>/dev/null

+ wait "$LISTENER_PID"

+ check_result 1

+ continue

+ fi

+

+ wait "$LISTENER_PID"

+ LISTENER_EXIT_CODE=$?

+

+ if [ "$LISTENER_EXIT_CODE" -eq 0 ]; then

+ echo "Rcv test OK for $test_name, $PROTOCOL"

+ check_result 0

+ else

+ echo "Rcv test FAILED for $test_name, $PROTOCOL"

+ check_result 1

+ fi

+ done

+done

+

+if [ "$FAILED_TESTS" -ne 0 ]; then

+ echo "FAIL - $FAILED_TESTS/$TOTAL_TESTS tests failed"

+ exit ${KSFT_FAIL}

+else

+ echo "OK - All $TOTAL_TESTS tests passed"

+ exit ${KSFT_PASS}

+fi

+ALL_TESTS="

+ test_set_remote

+ test_change_mc_remote

+"

+source lib.sh

+ ((N == 2))

+ check_err $? "expected 2 remotes after $what, got $N"

+}

+

+# Check FDB default-remote handling across "ip link set".

+test_set_remote()

+{

+ RET=0

+

+ ip_link_add vx up type vxlan id 2000 dstport 4789

+ bridge fdb ap dev vx 00:00:00:00:00:00 dst 192.0.2.20 self permanent

+ bridge fdb ap dev vx 00:00:00:00:00:00 dst 192.0.2.30 self permanent

+ check_remotes "fdb append"

+

+ ip link set dev vx type vxlan remote 192.0.2.30

+ check_remotes "link set"

+

+ log_test 'FDB default-remote handling across "ip link set"'

+}

+

+fmt_remote()

+{

+ local addr=$1; shift

+

+ if [[ $addr == 224.* ]]; then

+ echo "group $addr"

+ echo "remote $addr"

+change_remote()

+{

+ local remote=$1; shift

+

+ ip link set dev vx type vxlan $(fmt_remote $remote) dev v1

+}

+

+check_membership()

+{

+ local check_vec=("$@")

+

+ local memberships

+ memberships=$(

+ netstat -n --groups |

+ sed -n '/^v1\b/p' |

+ grep -o '[^ ]*$'

+ )

+ check_err $? "Couldn't obtain group memberships"

+

+ local item

+ for item in "${check_vec[@]}"; do

+ eval "local $item"

+ echo "$memberships" | grep -q "\b$group\b"

+ check_err_fail $fail $? "$group is_ex reported in IGMP query response"

+ done

+}

+

+test_change_mc_remote()

+{

+ check_command netstat || return

+

+ ip_link_add v1 up type veth peer name v2

+ ip_link_set_up v2

+

+ RET=0

+

+ ip_link_add vx up type vxlan dstport 4789 \

+ local 192.0.2.1 $(fmt_remote 224.1.1.1) dev v1 vni 1000

+

+ check_membership "group=224.1.1.1 fail=0" \

+ "group=224.1.1.2 fail=1" \

+ "group=224.1.1.3 fail=1"

+

+ log_test "MC group report after VXLAN creation"

+

+ RET=0

+

+ change_remote 224.1.1.2

+ check_membership "group=224.1.1.1 fail=1" \

+ "group=224.1.1.2 fail=0" \

+ "group=224.1.1.3 fail=1"

+

+ log_test "MC group report after changing VXLAN remote MC->MC"

+

+ RET=0

+

+ change_remote 192.0.2.2

+ check_membership "group=224.1.1.1 fail=1" \

+ "group=224.1.1.2 fail=1" \

+ "group=224.1.1.3 fail=1"

+

+ log_test "MC group report after changing VXLAN remote MC->UC"

+}

+

+trap defer_scopes_cleanup EXIT

+tests_run

+ $(Q)$(MAKE) -C $(top_srcdir)/tools/net/ynl \

+ GENS="$(YNL_GENS)" RSTS="" libynl.a