From nobody Mon Nov 16 13:19:47 2026 X-Original-To: dev-commits-src-all@mlmmj.nyi.freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2610:1c1:1:606c::19:1]) by mlmmj.nyi.freebsd.org (Postfix) with ESMTP id 4jSpPH3zPPz70cXR for ; Mon, 16 Nov 2026 13:19:47 +0000 (UTC) (envelope-from git@FreeBSD.org) Received: from mxrelay.nyi.freebsd.org (mxrelay.nyi.freebsd.org [IPv6:2610:1c1:1:606c::19:3]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange x25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by mx1.freebsd.org (Postfix) with ESMTPS id 4jSpPH1hvwz3MPX for ; Mon, 16 Nov 2026 13:19:47 +0000 (UTC) (envelope-from git@FreeBSD.org) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=freebsd.org; s=dkim; t=1794835187; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding; bh=hbJlq9P7aF55X6yLZKqXFmlswHqiHEKY8DDprC+bIZw=; b=cTj2ur1y+h/aPwLbBhTy/q+HbJ15fWX1TmVmdKL7em6ZjnPD7i71hXj4s5Bgd6t9BxzQgJ CrQjGC5tx74kjGTATHGCYWXXPk2s14n2/CJhKL4nI99P/0wP1Fv/x1VvZp48YgppsNvySb soCpMD9QkenDXE8gnP96DlvTlvYwA4Jxh9lwYfugQl8OfuxmANOlKwpJ06HmsnwIo8pIdc WkwyVVJu19zUBWQhkKMbJefeMeqxsSy7cH8kG6isB5tl4wlgSxPj8nZPWxZfj75CE0hAe9 LZeDbB3/p4w8njw5dzOAZatcxo7tdVtFWg6Orq/VWavKDgFGFLNjUMc4bW0SRA== ARC-Seal: i=1; a=rsa-sha256; d=freebsd.org; s=dkim; cv=none; t=1794835187; b=gNIcku0UpuNNg+rLNFwWUX7yLGDdzqz0ZTmpnCYIbRuoWdP3tmDnngwwfOO9DjYARBOHV/ Fv0TbKyYtBEgxGeiffjbfu+gxS6u+XPbvJhpvm0uErrgBS+gEp9OEyoxCnUwNdFznR/OyW XWntIt8RiSGkgpb9YKwsWY+UAbAT0hURvYZ5cXxR+gYsiKfTf4Fr6ONFp3ULkaHhgXdI9w ttG/e0WuIeyvQEP0NkxlxkpRDYo4TFrlOd/+zkKjKolbYGhUu3WBDdwjOBEkevf0OMrh7R 64wPq/CPPbWoYYEnKwQOai0bbXnR1cISns4J0yslH5drFAUWBZ3LGyIZLDhi7w== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=freebsd.org; s=dkim; t=1794835187; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding; bh=hbJlq9P7aF55X6yLZKqXFmlswHqiHEKY8DDprC+bIZw=; b=pN8exHRO05H0HpYS0EjvqVRRMZovwejZUdVBhJlXn/TZ0NskU/VSpADTJxzIUTzUPb3/VV blv1iNsA2zG2j8OpOiN8NldHa8k+tUkfagDAb/GecwpXWPqW6QfbN1wuziD0/ZRFXGfN4M EQfkzLVtFrcdqQdZRxea5Ad92j2dZIzjIwUSqapdQ0ZYz6tBwU9g+QLls7XkjfpKTiivy8 rY9p3mrhIMau5M0n256gVNYueVZgVRTil5aqmCSZ05V3txuMEhbb4ob7oKTwW7Kl8GjHSy /1Q4FS1wCLWGRHuvvUN318MGQakVHN4eL3DUSLVH36rqjZVBz9Qm5VswPRs+Rw== ARC-Authentication-Results: i=1; mx1.freebsd.org; none Received: from gitrepo.freebsd.org (gitrepo.freebsd.org [IPv6:2610:1c1:1:6068::e6a:5]) by mxrelay.nyi.freebsd.org (Postfix) with ESMTP id 4jSpPH0t5VzvrS for ; Mon, 16 Nov 2026 13:19:47 +0000 (UTC) (envelope-from git@FreeBSD.org) Received: from git (uid 1279) (envelope-from git@FreeBSD.org) id 1c671 by gitrepo.freebsd.org (DragonFly Mail Agent v0.13+ on gitrepo.freebsd.org); Mon, 16 Nov 2026 13:19:47 +0000 To: src-committers@FreeBSD.org, dev-commits-src-all@FreeBSD.org, dev-commits-src-main@FreeBSD.org From: R. Christian McDonald Subject: git: 1b9a8e1dcc69 - main - netipsec: Select outbound transmit queues by SA instead of inner flow List-Archive: https://lists.freebsd.org/archives/dev-commits-src-all X-BeenThere: dev-commits-src-all@freebsd.org List-Id: Commit messages for all branches of the src repository List-Post: List-Help: List-Subscribe: List-Unsubscribe: List-Owner: Precedence: list MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit X-Git-Committer: rcm X-Git-Repository: src X-Git-Refname: refs/heads/main X-Git-Reftype: branch X-Git-Commit: 1b9a8e1dcc69d239c7ec2b2d8aa255fd11c97884 Auto-Submitted: auto-generated Date: Mon, 16 Nov 2026 13:19:47 +0000 Message-Id: <6afb02f3.1c671.2faf2f3f@gitrepo.freebsd.org> The branch main has been updated by rcm: URL: https://cgit.FreeBSD.org/src/commit/?id=1b9a8e1dcc69d239c7ec2b2d8aa255fd11c97884 commit 1b9a8e1dcc69d239c7ec2b2d8aa255fd11c97884 Author: R. Christian McDonald AuthorDate: 2026-11-16 13:10:32 +0000 Commit: R. Christian McDonald CommitDate: 2026-11-16 13:10:32 +0000 netipsec: Select outbound transmit queues by SA instead of inner flow Outbound IPsec packets retain the flow ID of the inner traffic. Multi-queue interfaces use this ID to select a transmit queue (iflib's QIDX()) or a member port (lagg(4) with use_flowid). Consequently, packets belonging to the same security association (SA) can be distributed across independently draining queues. ESP and AH sequence numbers are assigned before encryption, but the packets can be transmitted out of order when different queues drain at different rates. This can cause legitimate packets to fall outside the receiver's anti-replay window and be dropped as possible replays. RFC 4303, Section 3.4.3, makes 32 packets the smallest window a receiver must support, and strongSwan installs that minimum by default. Assign each SA a flow ID derived from a Jenkins hash of its SPI, computed once when the SA is created, from the SPI in host byte order so that the value is the same on every architecture. Set this ID on outbound packets in ipsec{4,6}_perform_request(), with M_HASHTYPE_OPAQUE_HASH, once the SA is known and before ipsec_accel_output(): it then applies whether the SA is processed in software (ESP, AH, and IPCOMP) or by a network interface that implements it, since the offload path keeps the packet header and hands the packet to the interface's own transmit queue selection, and in a bundle the last SA decides. Whether the flow ID selects the queue is up to the consumer: a driver with its own selection (iflib's isc_txq_select) may ignore it. Hashing the SPI distributes SAs across transmit queues regardless of whether the queue-selection mechanism uses low-order bits (iflib) or shifted high-order bits (lagg(4) with flowid_shift). It also avoids the poor distribution that consecutive manually assigned SPIs would produce if used directly. All packets belonging to an SA now select the same transmit queue, eliminating reordering caused by independently draining queues. Reordering before enqueue, including skew in asynchronous crypto completion, remains possible and is addressed separately. Binding an SA to one transmit queue also binds it to one port or path when using lagg(4) with use_flowid or flow-ID-based multipath routing. This trades parallelism within an SA for packet ordering. Scaling a tunnel across multiple queues is instead possible with multiple SAs, each with its own sequence-number space, as supported by RFC 9611's per-resource Child SAs or by separate policies or interfaces. The net.inet.ipsec.sa_flowid sysctl restores the previous inner-flow-based selection. Reviewed by: kib, ae MFC after: 2 weeks Sponsored by: Rubicon Communications, LLC ("Netgate") Differential Revision: https://reviews.freebsd.org/D61194 --- share/man/man4/ipsec.4 | 24 ++++- sys/netipsec/ipsec.c | 5 + sys/netipsec/ipsec.h | 2 + sys/netipsec/ipsec_output.c | 18 ++++ sys/netipsec/key.c | 4 + sys/netipsec/keydb.h | 1 + tests/sys/netipsec/tunnel/Makefile | 3 +- tests/sys/netipsec/tunnel/sa_flowid.sh | 165 +++++++++++++++++++++++++++++++++ 8 files changed, 220 insertions(+), 2 deletions(-) diff --git a/share/man/man4/ipsec.4 b/share/man/man4/ipsec.4 index 0c60e0e3c121..dbc0787fe1c8 100644 --- a/share/man/man4/ipsec.4 +++ b/share/man/man4/ipsec.4 @@ -27,7 +27,7 @@ .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF .\" SUCH DAMAGE. .\" -.Dd May 7, 2026 +.Dd November 4, 2026 .Dt IPSEC 4 .Os .Sh NAME @@ -240,6 +240,7 @@ for tweaking the kernel's IPsec behavior: .It "net.inet.ipsec.natt_cksum_policy integer yes" .It "net.inet.ipsec.check_policy_history integer yes" .It "net.inet.ipsec.random_id integer yes" +.It "net.inet.ipsec.sa_flowid integer yes" .It "net.inet6.ipsec6.ecn integer yes" .It "net.inet6.ipsec6.debug integer yes" .El @@ -292,6 +293,27 @@ If set to 0 and original addresses were configured for corresponding SA by the IKE daemon, the kernel incrementally recomputes checksums for inbound TCP segments and UDP datagrams. If addresses were not configured, the checksums are ignored. +.It Li ipsec.sa_flowid +If set to non-zero (the default), packets leaving the kernel's IPsec +transforms carry a flow ID derived from the SPI of their security association +instead of that of the inner traffic. +An interface, a +.Xr lagg 4 +with +.Cm use_flowid +or a multipath route that selects a transmit queue, port or path by flow ID +then keeps the packets of one SA together, which avoids the reordering of +their sequence numbers between independently draining queues. +Concurrent processing and asynchronous crypto completion can still reorder +them before they are queued. +If set to 0, the packets keep the flow ID of the inner traffic, so one SA may +spread over several queues and its sequence numbers interleave, which a peer +with a small anti-replay window drops. +The ID is set before the packet is handed to a network interface that +implements the security association itself, so such SAs select their queue +the same way. +To spread a tunnel over several queues, ports or paths, use several SAs; +distinct SAs may still select the same one. .It Li ipsec.check_policy_history Enables strict policy checking for inbound packets. By default, inbound security policies check that packets handled by IPsec diff --git a/sys/netipsec/ipsec.c b/sys/netipsec/ipsec.c index d7e72c630f1f..90dcdc8c8c28 100644 --- a/sys/netipsec/ipsec.c +++ b/sys/netipsec/ipsec.c @@ -159,6 +159,8 @@ VNET_DEFINE(int, crypto_support) = CRYPTOCAP_F_HARDWARE | CRYPTOCAP_F_SOFTWARE; * 1 - enabled */ VNET_DEFINE(int, async_crypto) = 0; +/* Derive the flow ID of outbound packets from the SA: one SA, one queue. */ +VNET_DEFINE(int, sa_flowid) = 1; /* * TCP/UDP checksum handling policy for transport mode NAT-T (RFC3948) @@ -211,6 +213,9 @@ SYSCTL_INT(_net_inet_ipsec, OID_AUTO, crypto_support, SYSCTL_INT(_net_inet_ipsec, OID_AUTO, async_crypto, CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(async_crypto), 0, "Use asynchronous mode to parallelize crypto jobs."); +SYSCTL_INT(_net_inet_ipsec, OID_AUTO, sa_flowid, + CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(sa_flowid), 0, + "Derive the flow ID of outbound packets from the SA."); SYSCTL_INT(_net_inet_ipsec, OID_AUTO, check_policy_history, CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(check_policy_history), 0, "Use strict check of inbound packets to security policy compliance."); diff --git a/sys/netipsec/ipsec.h b/sys/netipsec/ipsec.h index b8969e88abbe..260c1cd6b901 100644 --- a/sys/netipsec/ipsec.h +++ b/sys/netipsec/ipsec.h @@ -297,6 +297,7 @@ VNET_DECLARE(int, ip4_ipsec_ecn); VNET_DECLARE(int, ip4_ipsec_random_id); VNET_DECLARE(int, crypto_support); VNET_DECLARE(int, async_crypto); +VNET_DECLARE(int, sa_flowid); VNET_DECLARE(int, natt_cksum_policy); #define IPSECSTAT_INC(name) \ @@ -315,6 +316,7 @@ VNET_DECLARE(int, natt_cksum_policy); #define V_ip4_ipsec_random_id VNET(ip4_ipsec_random_id) #define V_crypto_support VNET(crypto_support) #define V_async_crypto VNET(async_crypto) +#define V_sa_flowid VNET(sa_flowid) #define V_natt_cksum_policy VNET(natt_cksum_policy) #define ipseclog(x) do { if (V_ipsec_debug) log x; } while (0) diff --git a/sys/netipsec/ipsec_output.c b/sys/netipsec/ipsec_output.c index 18a25c0feeff..90f6b634507b 100644 --- a/sys/netipsec/ipsec_output.c +++ b/sys/netipsec/ipsec_output.c @@ -109,6 +109,22 @@ static int ipsec_encap(struct mbuf **mp, struct secasindex *saidx); static size_t ipsec_get_pmtu(struct secasvar *sav); +/* + * Select the transmit queue by SA: its packets then do not reorder between + * independently draining queues. Done before the transforms, software or + * offloaded, so that the SA decides the queue either way; in a bundle the + * last SA decides. Concurrent processing and crypto completions can still + * reorder the packets before they are queued. + */ +static void +ipsec_set_flowid(struct mbuf *m, struct secasvar *sav) +{ + if (V_sa_flowid) { + m->m_pkthdr.flowid = sav->flowid; + M_HASHTYPE_SET(m, M_HASHTYPE_OPAQUE_HASH); + } +} + #ifdef INET static struct secasvar * ipsec4_allocsa(struct ifnet *ifp, struct mbuf *m, const struct ip *ip, @@ -227,6 +243,7 @@ ipsec4_perform_request(struct ifnet *ifp, struct mbuf *m, struct ip *ip1, /* Re-calculate *ip1 after potential change of m in the hook. */ m_copydata(m, 0, sizeof(*ip1), (char *)ip1); + ipsec_set_flowid(m, sav); hwassist = 0; accel = ipsec_accel_output(ifp, m, inp, sp, sav, AF_INET, mtu, &hwassist); @@ -656,6 +673,7 @@ ipsec6_perform_request(struct ifnet *ifp, struct mbuf *m, struct secpolicy *sp, if ((error = ipsec_run_hhooks(&ctx, HHOOK_TYPE_IPSEC_OUT)) != 0) goto bad; + ipsec_set_flowid(m, sav); hwassist = 0; accel = ipsec_accel_output(ifp, m, inp, sp, sav, AF_INET6, mtu, &hwassist); diff --git a/sys/netipsec/key.c b/sys/netipsec/key.c index a2563689798f..c440624536b7 100644 --- a/sys/netipsec/key.c +++ b/sys/netipsec/key.c @@ -42,6 +42,7 @@ #include #include #include +#include #include #include #include @@ -3083,6 +3084,9 @@ key_newsav(const struct sadb_msghdr *mhp, struct secasindex *saidx, } sav->spi = spi; + /* Hash the SPI in host order: the same flow ID on every architecture. */ + spi = ntohl(spi); + sav->flowid = jenkins_hash32(&spi, 1, 0); sav->seq = mhp->msg->sadb_msg_seq; sav->state = SADB_SASTATE_LARVAL; sav->pid = (pid_t)mhp->msg->sadb_msg_pid; diff --git a/sys/netipsec/keydb.h b/sys/netipsec/keydb.h index ccc4a68e78fb..fefe3d385e9b 100644 --- a/sys/netipsec/keydb.h +++ b/sys/netipsec/keydb.h @@ -150,6 +150,7 @@ struct ifp_handle_sav; */ struct secasvar { uint32_t spi; /* SPI Value, network byte order */ + uint32_t flowid; /* flow ID of its packets, from the SPI */ uint32_t flags; /* holder for SADB_KEY_FLAGS */ uint32_t seq; /* sequence number */ pid_t pid; /* message's pid */ diff --git a/tests/sys/netipsec/tunnel/Makefile b/tests/sys/netipsec/tunnel/Makefile index 49fddc403005..0a37711f15c4 100644 --- a/tests/sys/netipsec/tunnel/Makefile +++ b/tests/sys/netipsec/tunnel/Makefile @@ -11,7 +11,8 @@ ATF_TESTS_SH+= empty \ aesni_aes_cbc_256_hmac_sha2_256 \ aesni_aes_gcm_128 \ aesni_aes_gcm_256 \ - chacha20_poly1305 + chacha20_poly1305 \ + sa_flowid TEST_METADATA+= execenv="jail" \ execenv_jail_params="vnet allow.raw_sockets" diff --git a/tests/sys/netipsec/tunnel/sa_flowid.sh b/tests/sys/netipsec/tunnel/sa_flowid.sh new file mode 100755 index 000000000000..d9079e21a09f --- /dev/null +++ b/tests/sys/netipsec/tunnel/sa_flowid.sh @@ -0,0 +1,165 @@ + +. $(atf_get_srcdir)/utils.subr + +# Outbound packets of a tunnel mode SA carry the SA's flow ID, +# jenkins_hash32() of the SPI in host byte order with seed 0, in place of +# the inner packet's. A lagg(4) with use_flowid picks its port from +# (flowid >> flowid_shift) % ports, so with two ports and the default shift +# of 16 the SAs below group as +# 0x1000 (a09625cd) and 0x1001 (e1fead43): bit 16 clear +# 0x1003 (a7bb1c69) and 0x1004 (1cdb9da5): bit 16 set +# while lagg's own header hash, restricted to layer 2, puts every SA on the +# same port. +# +# Each SA carries NFLOW inner flows, 172.16.K.1 .. 172.16.K.NFLOW to +# 172.16.K.254, which have flow IDs of their own: the kernel hashes locally +# generated packets once a multipath route exists. The hash key is a +# constant, so the inner flows of every SA spread over both ports whenever +# their flow IDs reach the lagg. +NFLOW=8 +KEY="12345678901234567890" + +sf_setup() +{ + ist_init + _vnet_check_req lagg + epair0=$(vnet_mkepair) + epair1=$(vnet_mkepair) + vnet_mkjail a ${epair0}a ${epair1}a + vnet_mkjail b ${epair0}b ${epair1}b + for j in a b; do + [ ${j} = a ] && s=a || s=b + jexec ${j} ifconfig ${epair0}${s} up + jexec ${j} ifconfig ${epair1}${s} up + jexec ${j} ifconfig lagg0 create + jexec ${j} ifconfig lagg0 laggproto loadbalance \ + laggport ${epair0}${s} laggport ${epair1}${s} + jexec ${j} ifconfig lo0 up + done + jexec a ifconfig lagg0 inet 10.0.0.1/24 up + jexec b ifconfig lagg0 inet 10.0.0.2/24 up + for k in 0 1 3 4; do + n=1 + while [ ${n} -le ${NFLOW} ]; do + jexec a ifconfig lo0 alias 172.16.${k}.${n}/32 + n=$((n + 1)) + done + jexec b ifconfig lo0 alias 172.16.${k}.254/32 + done + jexec a route -q add -net 172.16.0.0/16 10.0.0.2 + jexec b route -q add -net 172.16.0.0/16 10.0.0.1 + # Give the inner packets flow IDs: net.route.hash_outbound is read-only + # and turns on with the first multipath route. This one carries nothing. + jexec a route -q add -net 192.0.2.0/24 10.0.0.2 + jexec a route -q add -net 192.0.2.0/24 10.0.0.3 + if [ "$(jexec a sysctl -n net.route.hash_outbound)" != 1 ]; then + atf_skip "This test requires net.route.hash_outbound" + fi + for j in a b; do + [ ${j} = a ] && dir=out || dir=in + [ ${j} = a ] && rdir=in || rdir=out + ( + printf "flush;\nspdflush;\n" + for k in 0 1 3 4; do + spi=$((0x1000 + k)); rspi=$((0x2000 + k)) + printf "add 10.0.0.1 10.0.0.2 esp ${spi} -m tunnel -u ${spi} -E aes-gcm-16 \"${KEY}\";\n" + printf "add 10.0.0.2 10.0.0.1 esp ${rspi} -m tunnel -u ${rspi} -E aes-gcm-16 \"${KEY}\";\n" + printf "spdadd 172.16.${k}.0/24 172.16.${k}.254/32 any -P ${dir} ipsec esp/tunnel/10.0.0.1-10.0.0.2/unique:${spi};\n" + printf "spdadd 172.16.${k}.254/32 172.16.${k}.0/24 any -P ${rdir} ipsec esp/tunnel/10.0.0.2-10.0.0.1/unique:${rspi};\n" + done + ) > ${TMPDIR}/ipsec.${j}.conf + atf_check -s exit:0 -o ignore jexec ${j} setkey -f ${TMPDIR}/ipsec.${j}.conf + done + # Resolve ARP and bring the SAs up before counting. + atf_check -s exit:0 -o ignore jexec a ping -c 1 10.0.0.2 + for k in 0 1 3 4; do + atf_check -s exit:0 -o ignore jexec a ping -c 1 -S 172.16.${k}.1 172.16.${k}.254 + done + # Header hashing alone (layer 2 only) cannot tell the SAs apart. + jexec a ifconfig lagg0 use_flowid lagghash l2 +} + +# sf_opackets IF: packets jail a has sent on IF +sf_opackets() +{ + jexec a netstat -ibn -I $1 | awk '$3 ~ /^ /dev/null 2>&1 || + atf_fail "ping from 172.16.$1.${n} over SA 0x100$1 failed" + n=$((n + 1)) + done + d0=$(( $(sf_opackets ${epair0}a) - b0 )); d1=$(( $(sf_opackets ${epair1}a) - b1 )) + echo "SA 0x100$1: ${d0} packets on port 0, ${d1} on port 1" +} + +# sf_member K VAR: set VAR to the lagg port (0 or 1) that carries every +# inner flow of SA 0x100K. +sf_member() +{ + sf_send $1 + if [ ${d0} -ge $((10 * NFLOW)) ] && [ ${d1} -le 2 ]; then + eval $2=0 + elif [ ${d1} -ge $((10 * NFLOW)) ] && [ ${d0} -le 2 ]; then + eval $2=1 + else + atf_fail "SA 0x100$1 did not use one port for all of its flows" + fi +} + +atf_test_case "select" "cleanup" +select_head() +{ + atf_set descr 'lagg(4) use_flowid selects the port of an SA from its flow ID' + atf_set require.user root +} +select_body() +{ + sf_setup + sf_member 0 m0; sf_member 1 m1; sf_member 3 m3; sf_member 4 m4 + echo "ports: 0x1000 -> ${m0}, 0x1001 -> ${m1}, 0x1003 -> ${m3}, 0x1004 -> ${m4}" + if [ "${m0}" != "${m1}" ] || [ "${m3}" != "${m4}" ] || [ "${m0}" = "${m3}" ]; then + atf_fail "SAs did not group by bit 16 of their flow ID" + fi +} +select_cleanup() +{ + vnet_cleanup +} + +atf_test_case "off" "cleanup" +off_head() +{ + atf_set descr 'With net.inet.ipsec.sa_flowid=0 packets keep the inner flow ID' + atf_set require.user root +} +off_body() +{ + sf_setup + atf_check -s exit:0 -o ignore jexec a sysctl net.inet.ipsec.sa_flowid=0 + for k in 0 1 3 4; do + sf_send ${k} + if [ ${d0} -lt 10 ] || [ ${d1} -lt 10 ]; then + atf_fail "the inner flows of SA 0x100${k} did not spread over the ports" + fi + done +} +off_cleanup() +{ + vnet_cleanup +} + +atf_init_test_cases() +{ + atf_add_test_case "select" + atf_add_test_case "off" +}