From patchwork Sun May 28 13:55:57 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jeremy Sowden X-Patchwork-Id: 1786841 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@legolas.ozlabs.org Authentication-Results: legolas.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=vger.kernel.org (client-ip=2620:137:e000::1:20; helo=out1.vger.email; envelope-from=netfilter-devel-owner@vger.kernel.org; receiver=) Authentication-Results: legolas.ozlabs.org; dkim=fail reason="signature verification failed" (2048-bit key; secure) header.d=azazel.net header.i=@azazel.net header.a=rsa-sha256 header.s=20220717 header.b=na77830m; dkim-atps=neutral Received: from out1.vger.email (out1.vger.email [IPv6:2620:137:e000::1:20]) by legolas.ozlabs.org (Postfix) with ESMTP id 4QTgDq5v6vz20W0 for ; Sun, 28 May 2023 23:56:27 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229635AbjE1N4X (ORCPT ); Sun, 28 May 2023 09:56:23 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57088 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229596AbjE1N4R (ORCPT ); Sun, 28 May 2023 09:56:17 -0400 Received: from taras.nevrast.org (unknown [IPv6:2a05:d01c:431:aa03:b7e1:333d:ea2a:b14e]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 1E17FCF for ; Sun, 28 May 2023 06:56:15 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=azazel.net; s=20220717; h=Content-Transfer-Encoding:MIME-Version:References:In-Reply-To: Message-Id:Date:Subject:To:From:Sender:Reply-To:Cc:Content-Type:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Id:List-Help:List-Unsubscribe:List-Subscribe: List-Post:List-Owner:List-Archive; bh=2/ZZL2Jn/fSyKKYSZaj4bvhKc8ZFcKNxqdg1r6uo9xQ=; b=na77830mIOVn0VlLQhlgUnrhdC xkzpvhf/jYipDsvXRV8fR3EjICIPyPEPXcYUrIhsFtvh3ez+tAaQC+SuTu6z1o0aabXEJbb+az3VJ r1QCUj2Kd5LQj8FdswI3I+njIZy5TAsVwzBxUnntuQSEN0tHGD+eMwkRxDcQKPIcM5Rp6cfAviQuX np8/Zmt8Id1RCoEIUDM8tFx00bjoMGwcYbs2rXrKDOtMjQ44jkeSAdo7DgrnGgs5HDa+4EEIxMtYs LrzsbS31wDYiWGtrfTWZTwA3WrEEp6rzgGD7bL8BNJQNqL2+6SKdHJSlymxY/rNdUZomYOyn9NKhn IYgjJNqA==; Received: from [2001:8b0:135f:bcd1:e0cb:4eff:fedf:e608] (helo=ulthar.dreamlands) by taras.nevrast.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.94.2) (envelope-from ) id 1q3GsY-008We9-A5 for netfilter-devel@vger.kernel.org; Sun, 28 May 2023 14:56:14 +0100 From: Jeremy Sowden To: Netfilter Devel Subject: [PATCH libnftnl v3 1/5] include: add new bitwise boolean attributes to nf_tables.h Date: Sun, 28 May 2023 14:55:57 +0100 Message-Id: <20230528135601.1218337-2-jeremy@azazel.net> X-Mailer: git-send-email 2.39.2 In-Reply-To: <20230528135601.1218337-1-jeremy@azazel.net> References: <20230528135601.1218337-1-jeremy@azazel.net> MIME-Version: 1.0 X-SA-Exim-Connect-IP: 2001:8b0:135f:bcd1:e0cb:4eff:fedf:e608 X-SA-Exim-Mail-From: jeremy@azazel.net X-SA-Exim-Scanned: No (on taras.nevrast.org); SAEximRunCond expanded to false X-Spam-Status: No, score=-1.3 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RDNS_NONE,SPF_HELO_FAIL, SPF_PASS,T_SCC_BODY_TEXT_LINE autolearn=no autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: netfilter-devel@vger.kernel.org The kernel now has native support for AND, OR and XOR bitwise operations. Signed-off-by: Jeremy Sowden --- include/linux/netfilter/nf_tables.h | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-) diff --git a/include/linux/netfilter/nf_tables.h b/include/linux/netfilter/nf_tables.h index c48b19333630..f1c455606bcf 100644 --- a/include/linux/netfilter/nf_tables.h +++ b/include/linux/netfilter/nf_tables.h @@ -539,16 +539,27 @@ enum nft_immediate_attributes { /** * enum nft_bitwise_ops - nf_tables bitwise operations * - * @NFT_BITWISE_BOOL: mask-and-xor operation used to implement NOT, AND, OR and - * XOR boolean operations + * @NFT_BITWISE_MASK_XOR: mask-and-xor operation used to implement NOT, AND, OR + * and XOR boolean operations * @NFT_BITWISE_LSHIFT: left-shift operation * @NFT_BITWISE_RSHIFT: right-shift operation + * @NFT_BITWISE_AND: and operation + * @NFT_BITWISE_OR: or operation + * @NFT_BITWISE_XOR: xor operation */ enum nft_bitwise_ops { - NFT_BITWISE_BOOL, + NFT_BITWISE_MASK_XOR, NFT_BITWISE_LSHIFT, NFT_BITWISE_RSHIFT, + NFT_BITWISE_AND, + NFT_BITWISE_OR, + NFT_BITWISE_XOR, }; +/* + * Old name for NFT_BITWISE_MASK_XOR, predating the addition of NFT_BITWISE_AND, + * NFT_BITWISE_OR and NFT_BITWISE_XOR. Retained for backwards-compatibility. + */ +#define NFT_BITWISE_BOOL NFT_BITWISE_MASK_XOR /** * enum nft_bitwise_attributes - nf_tables bitwise expression netlink attributes @@ -561,6 +572,7 @@ enum nft_bitwise_ops { * @NFTA_BITWISE_OP: type of operation (NLA_U32: nft_bitwise_ops) * @NFTA_BITWISE_DATA: argument for non-boolean operations * (NLA_NESTED: nft_data_attributes) + * @NFTA_BITWISE_SREG2: second source register (NLA_U32: nft_registers) * * The bitwise expression supports boolean and shift operations. It implements * the boolean operations by performing the following operation: @@ -584,6 +596,7 @@ enum nft_bitwise_attributes { NFTA_BITWISE_XOR, NFTA_BITWISE_OP, NFTA_BITWISE_DATA, + NFTA_BITWISE_SREG2, __NFTA_BITWISE_MAX }; #define NFTA_BITWISE_MAX (__NFTA_BITWISE_MAX - 1) From patchwork Sun May 28 13:55:58 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jeremy Sowden X-Patchwork-Id: 1786840 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@legolas.ozlabs.org Authentication-Results: legolas.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=vger.kernel.org (client-ip=2620:137:e000::1:20; helo=out1.vger.email; envelope-from=netfilter-devel-owner@vger.kernel.org; receiver=) Authentication-Results: legolas.ozlabs.org; dkim=fail reason="signature verification failed" (2048-bit key; secure) header.d=azazel.net header.i=@azazel.net header.a=rsa-sha256 header.s=20220717 header.b=X5mRk2Il; dkim-atps=neutral Received: from out1.vger.email (out1.vger.email [IPv6:2620:137:e000::1:20]) by legolas.ozlabs.org (Postfix) with ESMTP id 4QTgDq2qghz20Pb for ; Sun, 28 May 2023 23:56:27 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229580AbjE1N4W (ORCPT ); Sun, 28 May 2023 09:56:22 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57090 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229612AbjE1N4S (ORCPT ); Sun, 28 May 2023 09:56:18 -0400 Received: from taras.nevrast.org (unknown [IPv6:2a05:d01c:431:aa03:b7e1:333d:ea2a:b14e]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 1DE72C9 for ; Sun, 28 May 2023 06:56:15 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=azazel.net; s=20220717; h=Content-Transfer-Encoding:MIME-Version:References:In-Reply-To: Message-Id:Date:Subject:To:From:Sender:Reply-To:Cc:Content-Type:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Id:List-Help:List-Unsubscribe:List-Subscribe: List-Post:List-Owner:List-Archive; bh=Ng8PjlQ/1C8/4RrRNiSrwn3iSG41Pq3rvQ3hGBvjkFM=; b=X5mRk2IlhrE8Gd+RIurO4W+5Cw fdMpk1/BlT0xtuBgXrWzFjGeCW2IBGn3Mbpr/ACWOssNyGvJ9a3ipwDE0wqACpLhyitZ+MAd1/dTl hLSLwFUXZ0EAF66QMP7hHoywRzJ2e1Xv6pJIkKkPiwVuzKovhcfk5hamNc+8WNPylV+2/JdkPyeTP hGUyJEh5U5qucOh9L7tgZMb9XkPd6uK28M2znEhektJfPGcPNJISfEjFfL7x/x2Z6i7Gg+XMUW2Pn g3Ki/CPnnz/k5ZFqtqlFbf3K3sgRU/3r0rmW70qd0ONhdzRTiPubljg0CY6RbiuHFqu/9/Mu9oh8C r+gS+A7A==; Received: from [2001:8b0:135f:bcd1:e0cb:4eff:fedf:e608] (helo=ulthar.dreamlands) by taras.nevrast.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.94.2) (envelope-from ) id 1q3GsY-008We9-Ba for netfilter-devel@vger.kernel.org; Sun, 28 May 2023 14:56:14 +0100 From: Jeremy Sowden To: Netfilter Devel Subject: [PATCH libnftnl v3 2/5] expr: bitwise: rename some boolean operation functions Date: Sun, 28 May 2023 14:55:58 +0100 Message-Id: <20230528135601.1218337-3-jeremy@azazel.net> X-Mailer: git-send-email 2.39.2 In-Reply-To: <20230528135601.1218337-1-jeremy@azazel.net> References: <20230528135601.1218337-1-jeremy@azazel.net> MIME-Version: 1.0 X-SA-Exim-Connect-IP: 2001:8b0:135f:bcd1:e0cb:4eff:fedf:e608 X-SA-Exim-Mail-From: jeremy@azazel.net X-SA-Exim-Scanned: No (on taras.nevrast.org); SAEximRunCond expanded to false X-Spam-Status: No, score=-1.3 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RDNS_NONE,SPF_HELO_FAIL, SPF_PASS,T_SCC_BODY_TEXT_LINE autolearn=no autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: netfilter-devel@vger.kernel.org In the next patch we add support for doing AND, OR and XOR operations directly in the kernel, so rename some functions and an enum constant related to mask-and-xor boolean operations. Signed-off-by: Jeremy Sowden --- src/expr/bitwise.c | 8 ++++---- tests/nft-expr_bitwise-test.c | 34 +++++++++++++++++----------------- 2 files changed, 21 insertions(+), 21 deletions(-) diff --git a/src/expr/bitwise.c b/src/expr/bitwise.c index 2d272335e377..4cac017736fe 100644 --- a/src/expr/bitwise.c +++ b/src/expr/bitwise.c @@ -210,8 +210,8 @@ nftnl_expr_bitwise_parse(struct nftnl_expr *e, struct nlattr *attr) } static int -nftnl_expr_bitwise_snprintf_bool(char *buf, size_t remain, - const struct nftnl_expr_bitwise *bitwise) +nftnl_expr_bitwise_snprintf_mask_xor(char *buf, size_t remain, + const struct nftnl_expr_bitwise *bitwise) { int offset = 0, ret; @@ -260,8 +260,8 @@ nftnl_expr_bitwise_snprintf(char *buf, size_t size, int err = -1; switch (bitwise->op) { - case NFT_BITWISE_BOOL: - err = nftnl_expr_bitwise_snprintf_bool(buf, size, bitwise); + case NFT_BITWISE_MASK_XOR: + err = nftnl_expr_bitwise_snprintf_mask_xor(buf, size, bitwise); break; case NFT_BITWISE_LSHIFT: err = nftnl_expr_bitwise_snprintf_shift(buf, size, "<<", bitwise); diff --git a/tests/nft-expr_bitwise-test.c b/tests/nft-expr_bitwise-test.c index 44c4bf06f041..95e9a1952084 100644 --- a/tests/nft-expr_bitwise-test.c +++ b/tests/nft-expr_bitwise-test.c @@ -27,32 +27,32 @@ static void print_err(const char *test, const char *msg) printf("\033[31mERROR:\e[0m [%s] %s\n", test, msg); } -static void cmp_nftnl_expr_bool(struct nftnl_expr *rule_a, - struct nftnl_expr *rule_b) +static void cmp_nftnl_expr_mask_xor(struct nftnl_expr *rule_a, + struct nftnl_expr *rule_b) { uint32_t maska, maskb; uint32_t xora, xorb; if (nftnl_expr_get_u32(rule_a, NFTNL_EXPR_BITWISE_DREG) != nftnl_expr_get_u32(rule_b, NFTNL_EXPR_BITWISE_DREG)) - print_err("bool", "Expr BITWISE_DREG mismatches"); + print_err("mask & xor", "Expr BITWISE_DREG mismatches"); if (nftnl_expr_get_u32(rule_a, NFTNL_EXPR_BITWISE_SREG) != nftnl_expr_get_u32(rule_b, NFTNL_EXPR_BITWISE_SREG)) - print_err("bool", "Expr BITWISE_SREG mismatches"); + print_err("mask & xor", "Expr BITWISE_SREG mismatches"); if (nftnl_expr_get_u32(rule_a, NFTNL_EXPR_BITWISE_OP) != nftnl_expr_get_u32(rule_b, NFTNL_EXPR_BITWISE_OP)) - print_err("bool", "Expr BITWISE_OP mismatches"); + print_err("mask & xor", "Expr BITWISE_OP mismatches"); if (nftnl_expr_get_u16(rule_a, NFTNL_EXPR_BITWISE_LEN) != nftnl_expr_get_u16(rule_b, NFTNL_EXPR_BITWISE_LEN)) - print_err("bool", "Expr BITWISE_LEN mismatches"); + print_err("mask & xor", "Expr BITWISE_LEN mismatches"); nftnl_expr_get(rule_a, NFTNL_EXPR_BITWISE_MASK, &maska); nftnl_expr_get(rule_b, NFTNL_EXPR_BITWISE_MASK, &maskb); if (maska != maskb) - print_err("bool", "Size of BITWISE_MASK mismatches"); + print_err("mask & xor", "Size of BITWISE_MASK mismatches"); nftnl_expr_get(rule_a, NFTNL_EXPR_BITWISE_XOR, &xora); nftnl_expr_get(rule_b, NFTNL_EXPR_BITWISE_XOR, &xorb); if (xora != xorb) - print_err("bool", "Size of BITWISE_XOR mismatches"); + print_err("mask & xor", "Size of BITWISE_XOR mismatches"); } static void cmp_nftnl_expr_lshift(struct nftnl_expr *rule_a, @@ -101,7 +101,7 @@ static void cmp_nftnl_expr_rshift(struct nftnl_expr *rule_a, print_err("rshift", "Expr BITWISE_DATA mismatches"); } -static void test_bool(void) +static void test_mask_xor(void) { struct nftnl_rule *a, *b = NULL; struct nftnl_expr *ex = NULL; @@ -115,10 +115,10 @@ static void test_bool(void) a = nftnl_rule_alloc(); b = nftnl_rule_alloc(); if (a == NULL || b == NULL) - print_err("bool", "OOM"); + print_err("mask & xor", "OOM"); ex = nftnl_expr_alloc("bitwise"); if (ex == NULL) - print_err("bool", "OOM"); + print_err("mask & xor", "OOM"); nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_SREG, 0x12345678); nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_DREG, 0x78123456); @@ -133,26 +133,26 @@ static void test_bool(void) nftnl_rule_nlmsg_build_payload(nlh, a); if (nftnl_rule_nlmsg_parse(nlh, b) < 0) - print_err("bool", "parsing problems"); + print_err("mask & xor", "parsing problems"); iter_a = nftnl_expr_iter_create(a); iter_b = nftnl_expr_iter_create(b); if (iter_a == NULL || iter_b == NULL) - print_err("bool", "OOM"); + print_err("mask & xor", "OOM"); rule_a = nftnl_expr_iter_next(iter_a); rule_b = nftnl_expr_iter_next(iter_b); if (rule_a == NULL || rule_b == NULL) - print_err("bool", "OOM"); + print_err("mask & xor", "OOM"); if (nftnl_expr_iter_next(iter_a) != NULL || nftnl_expr_iter_next(iter_b) != NULL) - print_err("bool", "More 1 expr."); + print_err("mask & xor", "More 1 expr."); nftnl_expr_iter_destroy(iter_a); nftnl_expr_iter_destroy(iter_b); - cmp_nftnl_expr_bool(rule_a,rule_b); + cmp_nftnl_expr_mask_xor(rule_a,rule_b); nftnl_rule_free(a); nftnl_rule_free(b); @@ -268,7 +268,7 @@ static void test_rshift(void) int main(int argc, char *argv[]) { - test_bool(); + test_mask_xor(); if (!test_ok) exit(EXIT_FAILURE); From patchwork Sun May 28 13:55:59 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jeremy Sowden X-Patchwork-Id: 1786844 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@legolas.ozlabs.org Authentication-Results: legolas.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=vger.kernel.org (client-ip=2620:137:e000::1:20; helo=out1.vger.email; envelope-from=netfilter-devel-owner@vger.kernel.org; receiver=) Authentication-Results: legolas.ozlabs.org; dkim=fail reason="signature verification failed" (2048-bit key; secure) header.d=azazel.net header.i=@azazel.net header.a=rsa-sha256 header.s=20220717 header.b=PnUek/rF; dkim-atps=neutral Received: from out1.vger.email (out1.vger.email [IPv6:2620:137:e000::1:20]) by legolas.ozlabs.org (Postfix) with ESMTP id 4QTgDs16Rpz20Pb for ; Sun, 28 May 2023 23:56:29 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229640AbjE1N4Z (ORCPT ); Sun, 28 May 2023 09:56:25 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57094 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229615AbjE1N4U (ORCPT ); Sun, 28 May 2023 09:56:20 -0400 Received: from taras.nevrast.org (unknown [IPv6:2a05:d01c:431:aa03:b7e1:333d:ea2a:b14e]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 49E91D8 for ; Sun, 28 May 2023 06:56:15 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=azazel.net; s=20220717; h=Content-Transfer-Encoding:MIME-Version:References:In-Reply-To: Message-Id:Date:Subject:To:From:Sender:Reply-To:Cc:Content-Type:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Id:List-Help:List-Unsubscribe:List-Subscribe: List-Post:List-Owner:List-Archive; bh=1kGfJ5xQfZaknTJPEvjHVAWSAjzTIxXJJ55SlP5VrE8=; b=PnUek/rFeEdTzVS8v7TF4BU0x+ gn8eUCVR/XS1pwF3oXzg9aDXFChGzGOX4D02LwiE3kuLtaaXPXmwh9mV4IX2QuTA/vfsJujA0H1t+ afuPH9NVRc0e1wTFMLkPdpIGsH0DnMmrCC8nHplCCdGwjvDrI3Y0e2/GuPM6WbP8DIjpS4QMNiLTk aJJp4Q7Izu27o5msNG1zGYa2+yj1BLYr+XqHQp6sZoGpQOa5JiI7NHE/pBfR45E8AbS/f6T9BJnaX 7V7UEWN6GicaaBD6P14Q+ppOyd8uqEAJJsNLX5e5uOQoQSEBMBvoPo5YlUhP8Lanfd8uiRrY1giEA Rw32/LIA==; Received: from [2001:8b0:135f:bcd1:e0cb:4eff:fedf:e608] (helo=ulthar.dreamlands) by taras.nevrast.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.94.2) (envelope-from ) id 1q3GsY-008We9-DD for netfilter-devel@vger.kernel.org; Sun, 28 May 2023 14:56:14 +0100 From: Jeremy Sowden To: Netfilter Devel Subject: [PATCH libnftnl v3 3/5] expr: bitwise: add support for kernel space AND, OR and XOR operations Date: Sun, 28 May 2023 14:55:59 +0100 Message-Id: <20230528135601.1218337-4-jeremy@azazel.net> X-Mailer: git-send-email 2.39.2 In-Reply-To: <20230528135601.1218337-1-jeremy@azazel.net> References: <20230528135601.1218337-1-jeremy@azazel.net> MIME-Version: 1.0 X-SA-Exim-Connect-IP: 2001:8b0:135f:bcd1:e0cb:4eff:fedf:e608 X-SA-Exim-Mail-From: jeremy@azazel.net X-SA-Exim-Scanned: No (on taras.nevrast.org); SAEximRunCond expanded to false X-Spam-Status: No, score=-1.3 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RDNS_NONE,SPF_HELO_FAIL, SPF_PASS,T_SCC_BODY_TEXT_LINE autolearn=no autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: netfilter-devel@vger.kernel.org Hitherto, the kernel has only supported boolean operations of the form: dst = (src & mask) ^ xor where `src` is held in a register, and `mask` and `xor` are immediate values. User space has converted AND, OR and XOR operations to this form, and so one operand has had to be immediate. The kernel now supports performing AND, OR and XOR operations directly, on one register and an immediate value or on two registers, so we make that support available to user space. Signed-off-by: Jeremy Sowden --- include/libnftnl/expr.h | 1 + src/expr/bitwise.c | 61 +++++++++++++++++++++++++++++++++++++++-- 2 files changed, 60 insertions(+), 2 deletions(-) diff --git a/include/libnftnl/expr.h b/include/libnftnl/expr.h index 9873228dd794..f2d79c8adbef 100644 --- a/include/libnftnl/expr.h +++ b/include/libnftnl/expr.h @@ -128,6 +128,7 @@ enum { NFTNL_EXPR_BITWISE_XOR, NFTNL_EXPR_BITWISE_OP, NFTNL_EXPR_BITWISE_DATA, + NFTNL_EXPR_BITWISE_SREG2, }; enum { diff --git a/src/expr/bitwise.c b/src/expr/bitwise.c index 4cac017736fe..06aed46a0e37 100644 --- a/src/expr/bitwise.c +++ b/src/expr/bitwise.c @@ -23,6 +23,7 @@ struct nftnl_expr_bitwise { enum nft_registers sreg; + enum nft_registers sreg2; enum nft_registers dreg; enum nft_bitwise_ops op; unsigned int len; @@ -41,6 +42,11 @@ nftnl_expr_bitwise_set(struct nftnl_expr *e, uint16_t type, case NFTNL_EXPR_BITWISE_SREG: memcpy(&bitwise->sreg, data, sizeof(bitwise->sreg)); break; + case NFTNL_EXPR_BITWISE_SREG2: + if (e->flags & (1 << NFTNL_EXPR_BITWISE_DATA)) + return -1; + memcpy(&bitwise->sreg2, data, sizeof(bitwise->sreg2)); + break; case NFTNL_EXPR_BITWISE_DREG: memcpy(&bitwise->dreg, data, sizeof(bitwise->dreg)); break; @@ -59,6 +65,8 @@ nftnl_expr_bitwise_set(struct nftnl_expr *e, uint16_t type, bitwise->xor.len = data_len; break; case NFTNL_EXPR_BITWISE_DATA: + if (e->flags & (1 << NFTNL_EXPR_BITWISE_SREG2)) + return -1; memcpy(&bitwise->data.val, data, data_len); bitwise->data.len = data_len; break; @@ -78,6 +86,9 @@ nftnl_expr_bitwise_get(const struct nftnl_expr *e, uint16_t type, case NFTNL_EXPR_BITWISE_SREG: *data_len = sizeof(bitwise->sreg); return &bitwise->sreg; + case NFTNL_EXPR_BITWISE_SREG2: + *data_len = sizeof(bitwise->sreg2); + return &bitwise->sreg2; case NFTNL_EXPR_BITWISE_DREG: *data_len = sizeof(bitwise->dreg); return &bitwise->dreg; @@ -110,6 +121,7 @@ static int nftnl_expr_bitwise_cb(const struct nlattr *attr, void *data) switch(type) { case NFTA_BITWISE_SREG: + case NFTA_BITWISE_SREG2: case NFTA_BITWISE_DREG: case NFTA_BITWISE_OP: case NFTA_BITWISE_LEN: @@ -135,6 +147,8 @@ nftnl_expr_bitwise_build(struct nlmsghdr *nlh, const struct nftnl_expr *e) if (e->flags & (1 << NFTNL_EXPR_BITWISE_SREG)) mnl_attr_put_u32(nlh, NFTA_BITWISE_SREG, htonl(bitwise->sreg)); + if (e->flags & (1 << NFTNL_EXPR_BITWISE_SREG2)) + mnl_attr_put_u32(nlh, NFTA_BITWISE_SREG2, htonl(bitwise->sreg2)); if (e->flags & (1 << NFTNL_EXPR_BITWISE_DREG)) mnl_attr_put_u32(nlh, NFTA_BITWISE_DREG, htonl(bitwise->dreg)); if (e->flags & (1 << NFTNL_EXPR_BITWISE_OP)) @@ -181,6 +195,10 @@ nftnl_expr_bitwise_parse(struct nftnl_expr *e, struct nlattr *attr) bitwise->sreg = ntohl(mnl_attr_get_u32(tb[NFTA_BITWISE_SREG])); e->flags |= (1 << NFTNL_EXPR_BITWISE_SREG); } + if (tb[NFTA_BITWISE_SREG2]) { + bitwise->sreg2 = ntohl(mnl_attr_get_u32(tb[NFTA_BITWISE_SREG2])); + e->flags |= (1 << NFTNL_EXPR_BITWISE_SREG2); + } if (tb[NFTA_BITWISE_DREG]) { bitwise->dreg = ntohl(mnl_attr_get_u32(tb[NFTA_BITWISE_DREG])); e->flags |= (1 << NFTNL_EXPR_BITWISE_DREG); @@ -252,6 +270,31 @@ nftnl_expr_bitwise_snprintf_shift(char *buf, size_t remain, const char *op, return offset; } +static int +nftnl_expr_bitwise_snprintf_bool(char *buf, size_t remain, const char *op, + const struct nftnl_expr *e, + const struct nftnl_expr_bitwise *bitwise) +{ + int offset = 0, ret; + + ret = snprintf(buf, remain, "reg %u = ( reg %u %s ", + bitwise->dreg, bitwise->sreg, op); + SNPRINTF_BUFFER_SIZE(ret, remain, offset); + + if (e->flags & (1 << NFTNL_EXPR_BITWISE_SREG2)) + ret = snprintf(buf + offset, remain, "reg %u ", bitwise->sreg2); + else + ret = nftnl_data_reg_snprintf(buf + offset, remain, + &bitwise->data, + 0, DATA_VALUE); + SNPRINTF_BUFFER_SIZE(ret, remain, offset); + + ret = snprintf(buf + offset, remain, ") "); + SNPRINTF_BUFFER_SIZE(ret, remain, offset); + + return offset; +} + static int nftnl_expr_bitwise_snprintf(char *buf, size_t size, uint32_t flags, const struct nftnl_expr *e) @@ -264,10 +307,24 @@ nftnl_expr_bitwise_snprintf(char *buf, size_t size, err = nftnl_expr_bitwise_snprintf_mask_xor(buf, size, bitwise); break; case NFT_BITWISE_LSHIFT: - err = nftnl_expr_bitwise_snprintf_shift(buf, size, "<<", bitwise); + err = nftnl_expr_bitwise_snprintf_shift(buf, size, "<<", + bitwise); break; case NFT_BITWISE_RSHIFT: - err = nftnl_expr_bitwise_snprintf_shift(buf, size, ">>", bitwise); + err = nftnl_expr_bitwise_snprintf_shift(buf, size, ">>", + bitwise); + break; + case NFT_BITWISE_AND: + err = nftnl_expr_bitwise_snprintf_bool(buf, size, "&", e, + bitwise); + break; + case NFT_BITWISE_OR: + err = nftnl_expr_bitwise_snprintf_bool(buf, size, "|", e, + bitwise); + break; + case NFT_BITWISE_XOR: + err = nftnl_expr_bitwise_snprintf_bool(buf, size, "^", e, + bitwise); break; } From patchwork Sun May 28 13:56:00 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jeremy Sowden X-Patchwork-Id: 1786842 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@legolas.ozlabs.org Authentication-Results: legolas.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=vger.kernel.org (client-ip=2620:137:e000::1:20; helo=out1.vger.email; envelope-from=netfilter-devel-owner@vger.kernel.org; receiver=) Authentication-Results: legolas.ozlabs.org; dkim=fail reason="signature verification failed" (2048-bit key; secure) header.d=azazel.net header.i=@azazel.net header.a=rsa-sha256 header.s=20220717 header.b=S++PVVrQ; dkim-atps=neutral Received: from out1.vger.email (out1.vger.email [IPv6:2620:137:e000::1:20]) by legolas.ozlabs.org (Postfix) with ESMTP id 4QTgDr1rK6z20Pb for ; Sun, 28 May 2023 23:56:28 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229637AbjE1N4Y (ORCPT ); Sun, 28 May 2023 09:56:24 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57092 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229607AbjE1N4U (ORCPT ); Sun, 28 May 2023 09:56:20 -0400 Received: from taras.nevrast.org (unknown [IPv6:2a05:d01c:431:aa03:b7e1:333d:ea2a:b14e]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 3B60CD2 for ; Sun, 28 May 2023 06:56:15 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=azazel.net; s=20220717; h=Content-Transfer-Encoding:MIME-Version:References:In-Reply-To: Message-Id:Date:Subject:To:From:Sender:Reply-To:Cc:Content-Type:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Id:List-Help:List-Unsubscribe:List-Subscribe: List-Post:List-Owner:List-Archive; bh=9+q6DIkqDJToMJwJU4sYVKFyIMa/shaYP4Lkzrc9ZXo=; b=S++PVVrQARh2Wge2Y1ws1+FdC7 zjYL6I9kr+pxByZexopILVRFXRufJV7kApgdqEPImqxSqcLd2OfTCiedQgqAR3w5hupKZO1q08Ofv JDnAT+dm6nZ3U/rooOpBDersKpVS3pf1lrPIAGdQLr8QdOICxTJcZOEWOgERoqq9daVroXHo27SuX rEcUtt+kOz3obHzvK5GSOwqLhOA53kW3699u+sJxLbNAmZOqicB8ibk1r50f+lZX7JvrTGCjw0sfh kmEA+faXkegfecpxzjPSZ2vH65NsqIbdyT0grbt/1/c4TNNAc+UUglL5YBFMmhn2sU24XQRE00ALb JuhVeg/Q==; Received: from [2001:8b0:135f:bcd1:e0cb:4eff:fedf:e608] (helo=ulthar.dreamlands) by taras.nevrast.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.94.2) (envelope-from ) id 1q3GsY-008We9-Ev for netfilter-devel@vger.kernel.org; Sun, 28 May 2023 14:56:14 +0100 From: Jeremy Sowden To: Netfilter Devel Subject: [PATCH libnftnl v3 4/5] tests: bitwise: refactor shift tests Date: Sun, 28 May 2023 14:56:00 +0100 Message-Id: <20230528135601.1218337-5-jeremy@azazel.net> X-Mailer: git-send-email 2.39.2 In-Reply-To: <20230528135601.1218337-1-jeremy@azazel.net> References: <20230528135601.1218337-1-jeremy@azazel.net> MIME-Version: 1.0 X-SA-Exim-Connect-IP: 2001:8b0:135f:bcd1:e0cb:4eff:fedf:e608 X-SA-Exim-Mail-From: jeremy@azazel.net X-SA-Exim-Scanned: No (on taras.nevrast.org); SAEximRunCond expanded to false X-Spam-Status: No, score=-1.3 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RDNS_NONE,SPF_HELO_FAIL, SPF_PASS,T_SCC_BODY_TEXT_LINE autolearn=no autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: netfilter-devel@vger.kernel.org Deduplicate shift tests: instead of having separate implementations for left- and right-shifts, have one and pass the operation to it. Signed-off-by: Jeremy Sowden --- tests/nft-expr_bitwise-test.c | 153 ++++++++++------------------------ 1 file changed, 44 insertions(+), 109 deletions(-) diff --git a/tests/nft-expr_bitwise-test.c b/tests/nft-expr_bitwise-test.c index 95e9a1952084..7a821ed69ec1 100644 --- a/tests/nft-expr_bitwise-test.c +++ b/tests/nft-expr_bitwise-test.c @@ -55,52 +55,6 @@ static void cmp_nftnl_expr_mask_xor(struct nftnl_expr *rule_a, print_err("mask & xor", "Size of BITWISE_XOR mismatches"); } -static void cmp_nftnl_expr_lshift(struct nftnl_expr *rule_a, - struct nftnl_expr *rule_b) -{ - uint32_t data_a, data_b; - - if (nftnl_expr_get_u32(rule_a, NFTNL_EXPR_BITWISE_DREG) != - nftnl_expr_get_u32(rule_b, NFTNL_EXPR_BITWISE_DREG)) - print_err("lshift", "Expr BITWISE_DREG mismatches"); - if (nftnl_expr_get_u32(rule_a, NFTNL_EXPR_BITWISE_SREG) != - nftnl_expr_get_u32(rule_b, NFTNL_EXPR_BITWISE_SREG)) - print_err("lshift", "Expr BITWISE_SREG mismatches"); - if (nftnl_expr_get_u32(rule_a, NFTNL_EXPR_BITWISE_OP) != - nftnl_expr_get_u32(rule_b, NFTNL_EXPR_BITWISE_OP)) - print_err("lshift", "Expr BITWISE_OP mismatches"); - if (nftnl_expr_get_u16(rule_a, NFTNL_EXPR_BITWISE_LEN) != - nftnl_expr_get_u16(rule_b, NFTNL_EXPR_BITWISE_LEN)) - print_err("lshift", "Expr BITWISE_LEN mismatches"); - nftnl_expr_get(rule_a, NFTNL_EXPR_BITWISE_DATA, &data_a); - nftnl_expr_get(rule_b, NFTNL_EXPR_BITWISE_DATA, &data_b); - if (data_a != data_b) - print_err("lshift", "Expr BITWISE_DATA mismatches"); -} - -static void cmp_nftnl_expr_rshift(struct nftnl_expr *rule_a, - struct nftnl_expr *rule_b) -{ - uint32_t data_a, data_b; - - if (nftnl_expr_get_u32(rule_a, NFTNL_EXPR_BITWISE_DREG) != - nftnl_expr_get_u32(rule_b, NFTNL_EXPR_BITWISE_DREG)) - print_err("rshift", "Expr BITWISE_DREG mismatches"); - if (nftnl_expr_get_u32(rule_a, NFTNL_EXPR_BITWISE_SREG) != - nftnl_expr_get_u32(rule_b, NFTNL_EXPR_BITWISE_SREG)) - print_err("rshift", "Expr BITWISE_SREG mismatches"); - if (nftnl_expr_get_u32(rule_a, NFTNL_EXPR_BITWISE_OP) != - nftnl_expr_get_u32(rule_b, NFTNL_EXPR_BITWISE_OP)) - print_err("rshift", "Expr BITWISE_OP mismatches"); - if (nftnl_expr_get_u16(rule_a, NFTNL_EXPR_BITWISE_LEN) != - nftnl_expr_get_u16(rule_b, NFTNL_EXPR_BITWISE_LEN)) - print_err("rshift", "Expr BITWISE_LEN mismatches"); - nftnl_expr_get(rule_a, NFTNL_EXPR_BITWISE_DATA, &data_a); - nftnl_expr_get(rule_b, NFTNL_EXPR_BITWISE_DATA, &data_b); - if (data_a != data_b) - print_err("rshift", "Expr BITWISE_DATA mismatches"); -} - static void test_mask_xor(void) { struct nftnl_rule *a, *b = NULL; @@ -158,26 +112,51 @@ static void test_mask_xor(void) nftnl_rule_free(b); } -static void test_lshift(void) +static void cmp_nftnl_expr_shift(const char *opname, + const struct nftnl_expr *rule_a, + const struct nftnl_expr *rule_b) { - struct nftnl_rule *a, *b = NULL; - struct nftnl_expr *ex = NULL; + uint32_t data_a, data_b; + + if (nftnl_expr_get_u32(rule_a, NFTNL_EXPR_BITWISE_DREG) != + nftnl_expr_get_u32(rule_b, NFTNL_EXPR_BITWISE_DREG)) + print_err(opname, "Expr BITWISE_DREG mismatches"); + if (nftnl_expr_get_u32(rule_a, NFTNL_EXPR_BITWISE_SREG) != + nftnl_expr_get_u32(rule_b, NFTNL_EXPR_BITWISE_SREG)) + print_err(opname, "Expr BITWISE_SREG mismatches"); + if (nftnl_expr_get_u32(rule_a, NFTNL_EXPR_BITWISE_OP) != + nftnl_expr_get_u32(rule_b, NFTNL_EXPR_BITWISE_OP)) + print_err(opname, "Expr BITWISE_OP mismatches"); + if (nftnl_expr_get_u16(rule_a, NFTNL_EXPR_BITWISE_LEN) != + nftnl_expr_get_u16(rule_b, NFTNL_EXPR_BITWISE_LEN)) + print_err(opname, "Expr BITWISE_LEN mismatches"); + nftnl_expr_get(rule_a, NFTNL_EXPR_BITWISE_DATA, &data_a); + nftnl_expr_get(rule_b, NFTNL_EXPR_BITWISE_DATA, &data_b); + if (data_a != data_b) + print_err(opname, "Expr BITWISE_DATA mismatches"); +} + +static void test_shift(enum nft_bitwise_ops op) +{ + struct nftnl_rule *a, *b; + struct nftnl_expr *ex; struct nlmsghdr *nlh; char buf[4096]; - struct nftnl_expr_iter *iter_a, *iter_b = NULL; - struct nftnl_expr *rule_a, *rule_b = NULL; + struct nftnl_expr_iter *iter_a, *iter_b; + struct nftnl_expr *rule_a, *rule_b; + const char *opname = op == NFT_BITWISE_LSHIFT ? "lshift" : "rshift"; a = nftnl_rule_alloc(); b = nftnl_rule_alloc(); if (a == NULL || b == NULL) - print_err("lshift", "OOM"); + print_err(opname, "OOM"); ex = nftnl_expr_alloc("bitwise"); if (ex == NULL) - print_err("lshift", "OOM"); + print_err(opname, "OOM"); nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_SREG, 0x12345678); nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_DREG, 0x78123456); - nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_OP, NFT_BITWISE_LSHIFT); + nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_OP, op); nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_LEN, 0x56781234); nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_DATA, 13); @@ -187,83 +166,39 @@ static void test_lshift(void) nftnl_rule_nlmsg_build_payload(nlh, a); if (nftnl_rule_nlmsg_parse(nlh, b) < 0) - print_err("lshift", "parsing problems"); + print_err(opname, "parsing problems"); iter_a = nftnl_expr_iter_create(a); iter_b = nftnl_expr_iter_create(b); if (iter_a == NULL || iter_b == NULL) - print_err("lshift", "OOM"); + print_err(opname, "OOM"); rule_a = nftnl_expr_iter_next(iter_a); rule_b = nftnl_expr_iter_next(iter_b); if (rule_a == NULL || rule_b == NULL) - print_err("lshift", "OOM"); + print_err(opname, "OOM"); if (nftnl_expr_iter_next(iter_a) != NULL || nftnl_expr_iter_next(iter_b) != NULL) - print_err("lshift", "More 1 expr."); + print_err(opname, "More 1 expr."); nftnl_expr_iter_destroy(iter_a); nftnl_expr_iter_destroy(iter_b); - cmp_nftnl_expr_lshift(rule_a,rule_b); + cmp_nftnl_expr_shift(opname, rule_a, rule_b); nftnl_rule_free(a); nftnl_rule_free(b); } -static void test_rshift(void) +static void test_lshift(void) { - struct nftnl_rule *a, *b = NULL; - struct nftnl_expr *ex = NULL; - struct nlmsghdr *nlh; - char buf[4096]; - struct nftnl_expr_iter *iter_a, *iter_b = NULL; - struct nftnl_expr *rule_a, *rule_b = NULL; - - a = nftnl_rule_alloc(); - b = nftnl_rule_alloc(); - if (a == NULL || b == NULL) - print_err("rshift", "OOM"); - ex = nftnl_expr_alloc("bitwise"); - if (ex == NULL) - print_err("rshift", "OOM"); - - nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_SREG, 0x12345678); - nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_DREG, 0x78123456); - nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_OP, NFT_BITWISE_RSHIFT); - nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_LEN, 0x56781234); - nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_DATA, 17); - - nftnl_rule_add_expr(a, ex); - - nlh = nftnl_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234); - nftnl_rule_nlmsg_build_payload(nlh, a); - - if (nftnl_rule_nlmsg_parse(nlh, b) < 0) - print_err("rshift", "parsing problems"); - - iter_a = nftnl_expr_iter_create(a); - iter_b = nftnl_expr_iter_create(b); - if (iter_a == NULL || iter_b == NULL) - print_err("rshift", "OOM"); - - rule_a = nftnl_expr_iter_next(iter_a); - rule_b = nftnl_expr_iter_next(iter_b); - if (rule_a == NULL || rule_b == NULL) - print_err("rshift", "OOM"); - - if (nftnl_expr_iter_next(iter_a) != NULL || - nftnl_expr_iter_next(iter_b) != NULL) - print_err("rshift", "More 1 expr."); - - nftnl_expr_iter_destroy(iter_a); - nftnl_expr_iter_destroy(iter_b); - - cmp_nftnl_expr_rshift(rule_a,rule_b); + test_shift(NFT_BITWISE_LSHIFT); +} - nftnl_rule_free(a); - nftnl_rule_free(b); +static void test_rshift(void) +{ + test_shift(NFT_BITWISE_RSHIFT); } int main(int argc, char *argv[]) From patchwork Sun May 28 13:56:01 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jeremy Sowden X-Patchwork-Id: 1786843 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@legolas.ozlabs.org Authentication-Results: legolas.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=vger.kernel.org (client-ip=2620:137:e000::1:20; helo=out1.vger.email; envelope-from=netfilter-devel-owner@vger.kernel.org; receiver=) Authentication-Results: legolas.ozlabs.org; dkim=fail reason="signature verification failed" (2048-bit key; secure) header.d=azazel.net header.i=@azazel.net header.a=rsa-sha256 header.s=20220717 header.b=Xv0b9WFp; dkim-atps=neutral Received: from out1.vger.email (out1.vger.email [IPv6:2620:137:e000::1:20]) by legolas.ozlabs.org (Postfix) with ESMTP id 4QTgDr4th3z20W0 for ; Sun, 28 May 2023 23:56:28 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229639AbjE1N4Z (ORCPT ); Sun, 28 May 2023 09:56:25 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57096 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229565AbjE1N4V (ORCPT ); Sun, 28 May 2023 09:56:21 -0400 Received: from taras.nevrast.org (unknown [IPv6:2a05:d01c:431:aa03:b7e1:333d:ea2a:b14e]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 5BC1BD9 for ; Sun, 28 May 2023 06:56:16 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=azazel.net; s=20220717; h=Content-Transfer-Encoding:MIME-Version:References:In-Reply-To: Message-Id:Date:Subject:To:From:Sender:Reply-To:Cc:Content-Type:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Id:List-Help:List-Unsubscribe:List-Subscribe: List-Post:List-Owner:List-Archive; bh=vFI0Mp74OzIsFASa+oORTiYNK+wddJ8+czxTQiq8VSQ=; b=Xv0b9WFpVXaPfiVP2C719ZC7LK e9BV0ESuA5TvQpt1JZ6PS5kNThPjcgxMq7C2JxucF6MeDdB27hm8s3WGiE98JGN1CyA5n/mvrgRu5 7vwoI+Zy/aeFZzqDl4hQL94lTMCZ3W4lkRT4S+mZm200ESGuJzmO4FwoSK4P2vA/FEsaEQzek4Ahj Uegf4R2t3VMRqJagH6SMLhFNN6jF3FxIHauq/o9D2Gr2sFxOB8u3JKoT8yIQCaZoe/0cGX0DTbLdf jG/Af+ZuXXKin3pMmoQHh/G28XCXyqqEFsMo9lXz0ZoXr1jeP0x/JMmbSg1bAejMk+SUUkcyyqmse CE/moO+A==; Received: from [2001:8b0:135f:bcd1:e0cb:4eff:fedf:e608] (helo=ulthar.dreamlands) by taras.nevrast.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.94.2) (envelope-from ) id 1q3GsY-008We9-GO for netfilter-devel@vger.kernel.org; Sun, 28 May 2023 14:56:14 +0100 From: Jeremy Sowden To: Netfilter Devel Subject: [PATCH libnftnl v3 5/5] tests: bitwise: add tests for new boolean operations Date: Sun, 28 May 2023 14:56:01 +0100 Message-Id: <20230528135601.1218337-6-jeremy@azazel.net> X-Mailer: git-send-email 2.39.2 In-Reply-To: <20230528135601.1218337-1-jeremy@azazel.net> References: <20230528135601.1218337-1-jeremy@azazel.net> MIME-Version: 1.0 X-SA-Exim-Connect-IP: 2001:8b0:135f:bcd1:e0cb:4eff:fedf:e608 X-SA-Exim-Mail-From: jeremy@azazel.net X-SA-Exim-Scanned: No (on taras.nevrast.org); SAEximRunCond expanded to false X-Spam-Status: No, score=-1.3 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RDNS_NONE,SPF_HELO_FAIL, SPF_PASS,T_SCC_BODY_TEXT_LINE autolearn=no autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: netfilter-devel@vger.kernel.org We already have tests for mask-and-xor operations with constant RHS operands. Add tests for new operations with variable RHS operands. Signed-off-by: Jeremy Sowden --- tests/nft-expr_bitwise-test.c | 105 ++++++++++++++++++++++++++++++++++ 1 file changed, 105 insertions(+) diff --git a/tests/nft-expr_bitwise-test.c b/tests/nft-expr_bitwise-test.c index 7a821ed69ec1..f4b3a7ea2558 100644 --- a/tests/nft-expr_bitwise-test.c +++ b/tests/nft-expr_bitwise-test.c @@ -201,6 +201,99 @@ static void test_rshift(void) test_shift(NFT_BITWISE_RSHIFT); } +static void cmp_nftnl_expr_bool(const char *opname, + const struct nftnl_expr *rule_a, + const struct nftnl_expr *rule_b) +{ + if (nftnl_expr_get_u32(rule_a, NFTNL_EXPR_BITWISE_DREG) != + nftnl_expr_get_u32(rule_b, NFTNL_EXPR_BITWISE_DREG)) + print_err(opname, "Expr BITWISE_DREG mismatches"); + if (nftnl_expr_get_u32(rule_a, NFTNL_EXPR_BITWISE_SREG) != + nftnl_expr_get_u32(rule_b, NFTNL_EXPR_BITWISE_SREG)) + print_err(opname, "Expr BITWISE_SREG mismatches"); + if (nftnl_expr_get_u32(rule_a, NFTNL_EXPR_BITWISE_SREG2) != + nftnl_expr_get_u32(rule_b, NFTNL_EXPR_BITWISE_SREG2)) + print_err(opname, "Expr BITWISE_SREG2 mismatches"); + if (nftnl_expr_get_u32(rule_a, NFTNL_EXPR_BITWISE_OP) != + nftnl_expr_get_u32(rule_b, NFTNL_EXPR_BITWISE_OP)) + print_err(opname, "Expr BITWISE_OP mismatches"); + if (nftnl_expr_get_u16(rule_a, NFTNL_EXPR_BITWISE_LEN) != + nftnl_expr_get_u16(rule_b, NFTNL_EXPR_BITWISE_LEN)) + print_err(opname, "Expr BITWISE_LEN mismatches"); +} + +static void test_bool(enum nft_bitwise_ops op) +{ + struct nftnl_rule *a, *b; + struct nftnl_expr *ex; + struct nlmsghdr *nlh; + char buf[4096]; + struct nftnl_expr_iter *iter_a, *iter_b; + struct nftnl_expr *rule_a, *rule_b; + const char *opname = + op == NFT_BITWISE_AND ? "and" : + op == NFT_BITWISE_OR ? "or" : "xor"; + + a = nftnl_rule_alloc(); + b = nftnl_rule_alloc(); + if (a == NULL || b == NULL) + print_err(opname, "OOM"); + ex = nftnl_expr_alloc("bitwise"); + if (ex == NULL) + print_err(opname, "OOM"); + + nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_SREG, 0x12345678); + nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_SREG2, 0x90abcdef); + nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_DREG, 0x78123456); + nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_OP, op); + nftnl_expr_set_u32(ex, NFTNL_EXPR_BITWISE_LEN, 0x56781234); + + nftnl_rule_add_expr(a, ex); + + nlh = nftnl_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234); + nftnl_rule_nlmsg_build_payload(nlh, a); + + if (nftnl_rule_nlmsg_parse(nlh, b) < 0) + print_err(opname, "parsing problems"); + + iter_a = nftnl_expr_iter_create(a); + iter_b = nftnl_expr_iter_create(b); + if (iter_a == NULL || iter_b == NULL) + print_err(opname, "OOM"); + + rule_a = nftnl_expr_iter_next(iter_a); + rule_b = nftnl_expr_iter_next(iter_b); + if (rule_a == NULL || rule_b == NULL) + print_err(opname, "OOM"); + + if (nftnl_expr_iter_next(iter_a) != NULL || + nftnl_expr_iter_next(iter_b) != NULL) + print_err(opname, "More 1 expr."); + + nftnl_expr_iter_destroy(iter_a); + nftnl_expr_iter_destroy(iter_b); + + cmp_nftnl_expr_bool(opname, rule_a, rule_b); + + nftnl_rule_free(a); + nftnl_rule_free(b); +} + +static void test_and(void) +{ + test_bool(NFT_BITWISE_AND); +} + +static void test_or(void) +{ + test_bool(NFT_BITWISE_OR); +} + +static void test_xor(void) +{ + test_bool(NFT_BITWISE_XOR); +} + int main(int argc, char *argv[]) { test_mask_xor(); @@ -215,6 +308,18 @@ int main(int argc, char *argv[]) if (!test_ok) exit(EXIT_FAILURE); + test_and(); + if (!test_ok) + exit(EXIT_FAILURE); + + test_or(); + if (!test_ok) + exit(EXIT_FAILURE); + + test_xor(); + if (!test_ok) + exit(EXIT_FAILURE); + printf("%s: \033[32mOK\e[0m\n", argv[0]); return EXIT_SUCCESS; }