summaryrefslogtreecommitdiffstats
path: root/tests
diff options
context:
space:
mode:
authorPablo Neira Ayuso <pablo@netfilter.org>2015-09-01 20:19:56 +0200
committerPablo Neira Ayuso <pablo@netfilter.org>2015-09-07 19:24:19 +0200
commit760768890e60617acfd144dce875a4a3be14513c (patch)
tree14a3a4f53e81fd9b44c8481e123f2c0ceb6f2bff /tests
parentb7154e52fc417e927bef0bbfa5db6e7a71f28602 (diff)
src: rename existing functions to use the nftnl_ prefix
So we can use the nft_* prefix anytime soon for our upcoming higher level library. After this patch, the nft_* symbols become an alias of the nftnl_* symbols. Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
Diffstat (limited to 'tests')
-rw-r--r--tests/nft-chain-test.c92
-rw-r--r--tests/nft-expr_bitwise-test.c78
-rw-r--r--tests/nft-expr_byteorder-test.c88
-rw-r--r--tests/nft-expr_cmp-test.c72
-rw-r--r--tests/nft-expr_counter-test.c64
-rw-r--r--tests/nft-expr_ct-test.c66
-rw-r--r--tests/nft-expr_exthdr-test.c80
-rw-r--r--tests/nft-expr_immediate-test.c80
-rw-r--r--tests/nft-expr_limit-test.c60
-rw-r--r--tests/nft-expr_log-test.c80
-rw-r--r--tests/nft-expr_lookup-test.c72
-rw-r--r--tests/nft-expr_masq-test.c56
-rw-r--r--tests/nft-expr_match-test.c72
-rw-r--r--tests/nft-expr_meta-test.c64
-rw-r--r--tests/nft-expr_nat-test.c104
-rw-r--r--tests/nft-expr_payload-test.c80
-rw-r--r--tests/nft-expr_queue-test.c66
-rw-r--r--tests/nft-expr_redir-test.c72
-rw-r--r--tests/nft-expr_reject-test.c64
-rw-r--r--tests/nft-expr_target-test.c72
-rw-r--r--tests/nft-parsing-test.c54
-rw-r--r--tests/nft-rule-test.c62
-rw-r--r--tests/nft-set-test.c62
-rw-r--r--tests/nft-table-test.c40
24 files changed, 850 insertions, 850 deletions
diff --git a/tests/nft-chain-test.c b/tests/nft-chain-test.c
index ff8afed..e8f449e 100644
--- a/tests/nft-chain-test.c
+++ b/tests/nft-chain-test.c
@@ -23,83 +23,83 @@ static void print_err(const char *msg)
printf("\033[31mERROR:\e[0m %s\n", msg);
}
-static void cmp_nft_chain(struct nft_chain *a, struct nft_chain *b)
+static void cmp_nftnl_chain(struct nftnl_chain *a, struct nftnl_chain *b)
{
- if (strcmp(nft_chain_attr_get_str(a, NFT_CHAIN_ATTR_NAME),
- nft_chain_attr_get_str(b, NFT_CHAIN_ATTR_NAME)) != 0)
+ if (strcmp(nftnl_chain_attr_get_str(a, NFTNL_CHAIN_ATTR_NAME),
+ nftnl_chain_attr_get_str(b, NFTNL_CHAIN_ATTR_NAME)) != 0)
print_err("Chain name mismatches");
- if (strcmp(nft_chain_attr_get_str(a, NFT_CHAIN_ATTR_TABLE),
- nft_chain_attr_get_str(b, NFT_CHAIN_ATTR_TABLE)) != 0)
+ if (strcmp(nftnl_chain_attr_get_str(a, NFTNL_CHAIN_ATTR_TABLE),
+ nftnl_chain_attr_get_str(b, NFTNL_CHAIN_ATTR_TABLE)) != 0)
print_err("Chain table mismatches");
- if (nft_chain_attr_get_u32(a, NFT_CHAIN_ATTR_FAMILY) !=
- nft_chain_attr_get_u32(b, NFT_CHAIN_ATTR_FAMILY))
+ if (nftnl_chain_attr_get_u32(a, NFTNL_CHAIN_ATTR_FAMILY) !=
+ nftnl_chain_attr_get_u32(b, NFTNL_CHAIN_ATTR_FAMILY))
print_err("Chain family mismatches");
- if (nft_chain_attr_get_u32(a, NFT_CHAIN_ATTR_POLICY) !=
- nft_chain_attr_get_u32(b, NFT_CHAIN_ATTR_POLICY))
+ if (nftnl_chain_attr_get_u32(a, NFTNL_CHAIN_ATTR_POLICY) !=
+ nftnl_chain_attr_get_u32(b, NFTNL_CHAIN_ATTR_POLICY))
print_err("Chain policy mismatches");
- if (nft_chain_attr_get_u32(a, NFT_CHAIN_ATTR_HOOKNUM) !=
- nft_chain_attr_get_u32(b, NFT_CHAIN_ATTR_HOOKNUM))
+ if (nftnl_chain_attr_get_u32(a, NFTNL_CHAIN_ATTR_HOOKNUM) !=
+ nftnl_chain_attr_get_u32(b, NFTNL_CHAIN_ATTR_HOOKNUM))
print_err("Chain hooknum mismatches");
- if (nft_chain_attr_get_s32(a, NFT_CHAIN_ATTR_PRIO) !=
- nft_chain_attr_get_s32(b, NFT_CHAIN_ATTR_PRIO))
+ if (nftnl_chain_attr_get_s32(a, NFTNL_CHAIN_ATTR_PRIO) !=
+ nftnl_chain_attr_get_s32(b, NFTNL_CHAIN_ATTR_PRIO))
print_err("Chain Prio mismatches");
- if (nft_chain_attr_get_u32(a, NFT_CHAIN_ATTR_USE) !=
- nft_chain_attr_get_u32(b, NFT_CHAIN_ATTR_USE))
+ if (nftnl_chain_attr_get_u32(a, NFTNL_CHAIN_ATTR_USE) !=
+ nftnl_chain_attr_get_u32(b, NFTNL_CHAIN_ATTR_USE))
print_err("Chain use mismatches");
- if (nft_chain_attr_get_u64(a, NFT_CHAIN_ATTR_PACKETS) !=
- nft_chain_attr_get_u64(b, NFT_CHAIN_ATTR_PACKETS))
+ if (nftnl_chain_attr_get_u64(a, NFTNL_CHAIN_ATTR_PACKETS) !=
+ nftnl_chain_attr_get_u64(b, NFTNL_CHAIN_ATTR_PACKETS))
print_err("Chain packets mismatches");
- if (nft_chain_attr_get_u64(a, NFT_CHAIN_ATTR_BYTES) !=
- nft_chain_attr_get_u64(b, NFT_CHAIN_ATTR_BYTES))
+ if (nftnl_chain_attr_get_u64(a, NFTNL_CHAIN_ATTR_BYTES) !=
+ nftnl_chain_attr_get_u64(b, NFTNL_CHAIN_ATTR_BYTES))
print_err("Chain bytes mismatches");
- if (nft_chain_attr_get_u64(a, NFT_CHAIN_ATTR_HANDLE) !=
- nft_chain_attr_get_u64(b, NFT_CHAIN_ATTR_HANDLE))
+ if (nftnl_chain_attr_get_u64(a, NFTNL_CHAIN_ATTR_HANDLE) !=
+ nftnl_chain_attr_get_u64(b, NFTNL_CHAIN_ATTR_HANDLE))
print_err("Chain handle mismatches");
- if (strcmp(nft_chain_attr_get_str(a, NFT_CHAIN_ATTR_TYPE),
- nft_chain_attr_get_str(b, NFT_CHAIN_ATTR_TYPE)) != 0)
+ if (strcmp(nftnl_chain_attr_get_str(a, NFTNL_CHAIN_ATTR_TYPE),
+ nftnl_chain_attr_get_str(b, NFTNL_CHAIN_ATTR_TYPE)) != 0)
print_err("Chain type mismatches");
- if (strcmp(nft_chain_attr_get_str(a, NFT_CHAIN_ATTR_DEV),
- nft_chain_attr_get_str(b, NFT_CHAIN_ATTR_DEV)) != 0)
+ if (strcmp(nftnl_chain_attr_get_str(a, NFTNL_CHAIN_ATTR_DEV),
+ nftnl_chain_attr_get_str(b, NFTNL_CHAIN_ATTR_DEV)) != 0)
print_err("Chain device mismatches");
}
int main(int argc, char *argv[])
{
- struct nft_chain *a, *b;
+ struct nftnl_chain *a, *b;
char buf[4096];
struct nlmsghdr *nlh;
- a = nft_chain_alloc();
- b = nft_chain_alloc();
+ a = nftnl_chain_alloc();
+ b = nftnl_chain_alloc();
if (a == NULL || b == NULL)
print_err("OOM");
- nft_chain_attr_set_str(a, NFT_CHAIN_ATTR_NAME, "test");
- nft_chain_attr_set_u32(a, NFT_CHAIN_ATTR_FAMILY, AF_INET);
- nft_chain_attr_set_str(a, NFT_CHAIN_ATTR_TABLE, "Table");
- nft_chain_attr_set_u32(a, NFT_CHAIN_ATTR_POLICY,0x12345678);
- nft_chain_attr_set_u32(a, NFT_CHAIN_ATTR_HOOKNUM, 0x12345678);
- nft_chain_attr_set_s32(a, NFT_CHAIN_ATTR_PRIO, 0x12345678);
- nft_chain_attr_set_u32(a, NFT_CHAIN_ATTR_USE, 0x12345678 );
- nft_chain_attr_set_u64(a, NFT_CHAIN_ATTR_PACKETS, 0x1234567812345678);
- nft_chain_attr_set_u64(a, NFT_CHAIN_ATTR_BYTES, 0x1234567812345678);
- nft_chain_attr_set_u64(a, NFT_CHAIN_ATTR_HANDLE, 0x1234567812345678);
- nft_chain_attr_set_str(a, NFT_CHAIN_ATTR_TYPE, "Prueba");
- nft_chain_attr_set_str(a, NFT_CHAIN_ATTR_DEV, "eth0");
+ nftnl_chain_attr_set_str(a, NFTNL_CHAIN_ATTR_NAME, "test");
+ nftnl_chain_attr_set_u32(a, NFTNL_CHAIN_ATTR_FAMILY, AF_INET);
+ nftnl_chain_attr_set_str(a, NFTNL_CHAIN_ATTR_TABLE, "Table");
+ nftnl_chain_attr_set_u32(a, NFTNL_CHAIN_ATTR_POLICY,0x12345678);
+ nftnl_chain_attr_set_u32(a, NFTNL_CHAIN_ATTR_HOOKNUM, 0x12345678);
+ nftnl_chain_attr_set_s32(a, NFTNL_CHAIN_ATTR_PRIO, 0x12345678);
+ nftnl_chain_attr_set_u32(a, NFTNL_CHAIN_ATTR_USE, 0x12345678 );
+ nftnl_chain_attr_set_u64(a, NFTNL_CHAIN_ATTR_PACKETS, 0x1234567812345678);
+ nftnl_chain_attr_set_u64(a, NFTNL_CHAIN_ATTR_BYTES, 0x1234567812345678);
+ nftnl_chain_attr_set_u64(a, NFTNL_CHAIN_ATTR_HANDLE, 0x1234567812345678);
+ nftnl_chain_attr_set_str(a, NFTNL_CHAIN_ATTR_TYPE, "Prueba");
+ nftnl_chain_attr_set_str(a, NFTNL_CHAIN_ATTR_DEV, "eth0");
/* cmd extracted from include/linux/netfilter/nf_tables.h */
- nlh = nft_chain_nlmsg_build_hdr(buf, NFT_MSG_NEWCHAIN, AF_INET,
+ nlh = nftnl_chain_nlmsg_build_hdr(buf, NFT_MSG_NEWCHAIN, AF_INET,
0, 1234);
- nft_chain_nlmsg_build_payload(nlh, a);
+ nftnl_chain_nlmsg_build_payload(nlh, a);
- if (nft_chain_nlmsg_parse(nlh, b) < 0)
+ if (nftnl_chain_nlmsg_parse(nlh, b) < 0)
print_err("parsing problems");
- cmp_nft_chain(a, b);
+ cmp_nftnl_chain(a, b);
- nft_chain_free(a);
- nft_chain_free(b);
+ nftnl_chain_free(a);
+ nftnl_chain_free(b);
if (!test_ok)
exit(EXIT_FAILURE);
diff --git a/tests/nft-expr_bitwise-test.c b/tests/nft-expr_bitwise-test.c
index 0fe5329..25ad412 100644
--- a/tests/nft-expr_bitwise-test.c
+++ b/tests/nft-expr_bitwise-test.c
@@ -27,85 +27,85 @@ static void print_err(const char *msg)
printf("\033[31mERROR:\e[0m %s\n", msg);
}
-static void cmp_nft_rule_expr(struct nft_rule_expr *rule_a,
- struct nft_rule_expr *rule_b)
+static void cmp_nftnl_rule_expr(struct nftnl_rule_expr *rule_a,
+ struct nftnl_rule_expr *rule_b)
{
uint32_t maska, maskb;
uint32_t xora, xorb;
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_BITWISE_DREG) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_BITWISE_DREG))
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_BITWISE_DREG) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_BITWISE_DREG))
print_err("Expr BITWISE_DREG mismatches");
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_BITWISE_SREG) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_BITWISE_SREG))
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_BITWISE_SREG) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_BITWISE_SREG))
print_err("Expr BITWISE_SREG mismatches");
- if (nft_rule_expr_get_u16(rule_a, NFT_EXPR_BITWISE_LEN) !=
- nft_rule_expr_get_u16(rule_b, NFT_EXPR_BITWISE_LEN))
+ if (nftnl_rule_expr_get_u16(rule_a, NFTNL_EXPR_BITWISE_LEN) !=
+ nftnl_rule_expr_get_u16(rule_b, NFTNL_EXPR_BITWISE_LEN))
print_err("Expr BITWISE_DREG mismatches");
- nft_rule_expr_get(rule_a, NFT_EXPR_BITWISE_MASK, &maska);
- nft_rule_expr_get(rule_b, NFT_EXPR_BITWISE_MASK, &maskb);
+ nftnl_rule_expr_get(rule_a, NFTNL_EXPR_BITWISE_MASK, &maska);
+ nftnl_rule_expr_get(rule_b, NFTNL_EXPR_BITWISE_MASK, &maskb);
if (maska != maskb)
print_err("Size of BITWISE_MASK mismatches");
- nft_rule_expr_get(rule_a, NFT_EXPR_BITWISE_XOR, &xora);
- nft_rule_expr_get(rule_b, NFT_EXPR_BITWISE_XOR, &xorb);
+ nftnl_rule_expr_get(rule_a, NFTNL_EXPR_BITWISE_XOR, &xora);
+ nftnl_rule_expr_get(rule_b, NFTNL_EXPR_BITWISE_XOR, &xorb);
if (xora != xorb)
print_err("Size of BITWISE_XOR mismatches");
}
int main(int argc, char *argv[])
{
- struct nft_rule *a, *b = NULL;
- struct nft_rule_expr *ex = NULL;
+ struct nftnl_rule *a, *b = NULL;
+ struct nftnl_rule_expr *ex = NULL;
struct nlmsghdr *nlh;
char buf[4096];
- struct nft_rule_expr_iter *iter_a, *iter_b = NULL;
- struct nft_rule_expr *rule_a, *rule_b = NULL;
+ struct nftnl_rule_expr_iter *iter_a, *iter_b = NULL;
+ struct nftnl_rule_expr *rule_a, *rule_b = NULL;
uint32_t mask = 0x01010101;
uint32_t xor = 0x12345678;
- a = nft_rule_alloc();
- b = nft_rule_alloc();
+ a = nftnl_rule_alloc();
+ b = nftnl_rule_alloc();
if (a == NULL || b == NULL)
print_err("OOM");
- ex = nft_rule_expr_alloc("bitwise");
+ ex = nftnl_rule_expr_alloc("bitwise");
if (ex == NULL)
print_err("OOM");
- nft_rule_expr_set_u32(ex, NFT_EXPR_BITWISE_SREG, 0x12345678);
- nft_rule_expr_set_u32(ex, NFT_EXPR_BITWISE_DREG, 0x12345678);
- nft_rule_expr_set_u32(ex, NFT_EXPR_BITWISE_LEN, 0x12345678);
- nft_rule_expr_set(ex, NFT_EXPR_BITWISE_MASK, &mask, sizeof(mask));
- nft_rule_expr_set(ex, NFT_EXPR_BITWISE_XOR, &xor, sizeof(xor));
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_BITWISE_SREG, 0x12345678);
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_BITWISE_DREG, 0x12345678);
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_BITWISE_LEN, 0x12345678);
+ nftnl_rule_expr_set(ex, NFTNL_EXPR_BITWISE_MASK, &mask, sizeof(mask));
+ nftnl_rule_expr_set(ex, NFTNL_EXPR_BITWISE_XOR, &xor, sizeof(xor));
- nft_rule_add_expr(a, ex);
+ nftnl_rule_add_expr(a, ex);
- nlh = nft_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
- nft_rule_nlmsg_build_payload(nlh, a);
+ nlh = nftnl_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
+ nftnl_rule_nlmsg_build_payload(nlh, a);
- if (nft_rule_nlmsg_parse(nlh, b) < 0)
+ if (nftnl_rule_nlmsg_parse(nlh, b) < 0)
print_err("parsing problems");
- iter_a = nft_rule_expr_iter_create(a);
- iter_b = nft_rule_expr_iter_create(b);
+ iter_a = nftnl_rule_expr_iter_create(a);
+ iter_b = nftnl_rule_expr_iter_create(b);
if (iter_a == NULL || iter_b == NULL)
print_err("OOM");
- rule_a = nft_rule_expr_iter_next(iter_a);
- rule_b = nft_rule_expr_iter_next(iter_b);
+ rule_a = nftnl_rule_expr_iter_next(iter_a);
+ rule_b = nftnl_rule_expr_iter_next(iter_b);
if (rule_a == NULL || rule_b == NULL)
print_err("OOM");
- if (nft_rule_expr_iter_next(iter_a) != NULL ||
- nft_rule_expr_iter_next(iter_b) != NULL)
+ if (nftnl_rule_expr_iter_next(iter_a) != NULL ||
+ nftnl_rule_expr_iter_next(iter_b) != NULL)
print_err("More 1 expr.");
- nft_rule_expr_iter_destroy(iter_a);
- nft_rule_expr_iter_destroy(iter_b);
+ nftnl_rule_expr_iter_destroy(iter_a);
+ nftnl_rule_expr_iter_destroy(iter_b);
- cmp_nft_rule_expr(rule_a,rule_b);
+ cmp_nftnl_rule_expr(rule_a,rule_b);
- nft_rule_free(a);
- nft_rule_free(b);
+ nftnl_rule_free(a);
+ nftnl_rule_free(b);
if (!test_ok)
exit(EXIT_FAILURE);
diff --git a/tests/nft-expr_byteorder-test.c b/tests/nft-expr_byteorder-test.c
index 456d508..5c09e13 100644
--- a/tests/nft-expr_byteorder-test.c
+++ b/tests/nft-expr_byteorder-test.c
@@ -27,77 +27,77 @@ static void print_err(const char *msg)
printf("\033[31mERROR:\e[0m %s\n", msg);
}
-static void cmp_nft_rule_expr(struct nft_rule_expr *rule_a,
- struct nft_rule_expr *rule_b)
+static void cmp_nftnl_rule_expr(struct nftnl_rule_expr *rule_a,
+ struct nftnl_rule_expr *rule_b)
{
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_BYTEORDER_DREG) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_BYTEORDER_DREG))
- print_err("Expr NFT_EXPR_BYTEORDER_DREG mismatches");
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_BYTEORDER_SREG) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_BYTEORDER_SREG))
- print_err("Expr NFT_EXPR_BYTEORDER_SREG mismatches");
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_BYTEORDER_OP) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_BYTEORDER_OP))
- print_err("Expr NFT_EXPR_BYTEORDER_OP mismatches");
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_BYTEORDER_LEN) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_BYTEORDER_LEN))
- print_err("Expr NFT_EXPR_BYTEORDER_DREG mismatches");
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_BYTEORDER_SIZE) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_BYTEORDER_SIZE))
- print_err("Expr NFT_EXPR_BITWISE_SIZE mismatches");
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_BYTEORDER_DREG) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_BYTEORDER_DREG))
+ print_err("Expr NFTNL_EXPR_BYTEORDER_DREG mismatches");
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_BYTEORDER_SREG) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_BYTEORDER_SREG))
+ print_err("Expr NFTNL_EXPR_BYTEORDER_SREG mismatches");
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_BYTEORDER_OP) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_BYTEORDER_OP))
+ print_err("Expr NFTNL_EXPR_BYTEORDER_OP mismatches");
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_BYTEORDER_LEN) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_BYTEORDER_LEN))
+ print_err("Expr NFTNL_EXPR_BYTEORDER_DREG mismatches");
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_BYTEORDER_SIZE) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_BYTEORDER_SIZE))
+ print_err("Expr NFTNL_EXPR_BITWISE_SIZE mismatches");
}
int main(int argc, char *argv[])
{
- struct nft_rule *a, *b;
- struct nft_rule_expr *ex;
+ struct nftnl_rule *a, *b;
+ struct nftnl_rule_expr *ex;
struct nlmsghdr *nlh;
char buf[4096];
- struct nft_rule_expr_iter *iter_a, *iter_b;
- struct nft_rule_expr *rule_a, *rule_b;
+ struct nftnl_rule_expr_iter *iter_a, *iter_b;
+ struct nftnl_rule_expr *rule_a, *rule_b;
- a = nft_rule_alloc();
- b = nft_rule_alloc();
+ a = nftnl_rule_alloc();
+ b = nftnl_rule_alloc();
if (a == NULL || b == NULL)
print_err("OOM");
- ex = nft_rule_expr_alloc("byteorder");
+ ex = nftnl_rule_expr_alloc("byteorder");
if (ex == NULL)
print_err("OOM");
- nft_rule_expr_set_u32(ex, NFT_EXPR_BYTEORDER_SREG, 0x12345678);
- nft_rule_expr_set_u32(ex, NFT_EXPR_BYTEORDER_DREG, 0x12345678);
- nft_rule_expr_set_u32(ex, NFT_EXPR_BYTEORDER_OP, 0x12345678);
- nft_rule_expr_set_u32(ex, NFT_EXPR_BYTEORDER_LEN, 0x12345678);
- nft_rule_expr_set_u32(ex, NFT_EXPR_BYTEORDER_SIZE, 0x12345678);
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_BYTEORDER_SREG, 0x12345678);
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_BYTEORDER_DREG, 0x12345678);
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_BYTEORDER_OP, 0x12345678);
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_BYTEORDER_LEN, 0x12345678);
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_BYTEORDER_SIZE, 0x12345678);
- nft_rule_add_expr(a, ex);
+ nftnl_rule_add_expr(a, ex);
- nlh = nft_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
- nft_rule_nlmsg_build_payload(nlh, a);
+ nlh = nftnl_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
+ nftnl_rule_nlmsg_build_payload(nlh, a);
- if (nft_rule_nlmsg_parse(nlh, b) < 0)
+ if (nftnl_rule_nlmsg_parse(nlh, b) < 0)
print_err("parsing problems");
- iter_a = nft_rule_expr_iter_create(a);
- iter_b = nft_rule_expr_iter_create(b);
+ iter_a = nftnl_rule_expr_iter_create(a);
+ iter_b = nftnl_rule_expr_iter_create(b);
if (iter_a == NULL || iter_b == NULL)
print_err("OOM");
- rule_a = nft_rule_expr_iter_next(iter_a);
- rule_b = nft_rule_expr_iter_next(iter_b);
+ rule_a = nftnl_rule_expr_iter_next(iter_a);
+ rule_b = nftnl_rule_expr_iter_next(iter_b);
if (rule_a == NULL || rule_b == NULL)
print_err("OOM");
- cmp_nft_rule_expr(rule_a,rule_b);
+ cmp_nftnl_rule_expr(rule_a,rule_b);
- if (nft_rule_expr_iter_next(iter_a) != NULL ||
- nft_rule_expr_iter_next(iter_b) != NULL)
+ if (nftnl_rule_expr_iter_next(iter_a) != NULL ||
+ nftnl_rule_expr_iter_next(iter_b) != NULL)
print_err("More 1 expr.");
- nft_rule_expr_iter_destroy(iter_a);
- nft_rule_expr_iter_destroy(iter_b);
- nft_rule_free(a);
- nft_rule_free(b);
+ nftnl_rule_expr_iter_destroy(iter_a);
+ nftnl_rule_expr_iter_destroy(iter_b);
+ nftnl_rule_free(a);
+ nftnl_rule_free(b);
if (!test_ok)
exit(EXIT_FAILURE);
diff --git a/tests/nft-expr_cmp-test.c b/tests/nft-expr_cmp-test.c
index f411770..b9df3c6 100644
--- a/tests/nft-expr_cmp-test.c
+++ b/tests/nft-expr_cmp-test.c
@@ -27,72 +27,72 @@ static void print_err(const char *msg)
printf("\033[31mERROR:\e[0m %s\n", msg);
}
-static void cmp_nft_rule_expr(struct nft_rule_expr *rule_a,
- struct nft_rule_expr *rule_b)
+static void cmp_nftnl_rule_expr(struct nftnl_rule_expr *rule_a,
+ struct nftnl_rule_expr *rule_b)
{
uint32_t data_lena, data_lenb;
- nft_rule_expr_get(rule_a, NFT_EXPR_CMP_DATA, &data_lena);
- nft_rule_expr_get(rule_b, NFT_EXPR_CMP_DATA, &data_lenb);
+ nftnl_rule_expr_get(rule_a, NFTNL_EXPR_CMP_DATA, &data_lena);
+ nftnl_rule_expr_get(rule_b, NFTNL_EXPR_CMP_DATA, &data_lenb);
if (data_lena != data_lenb)
- print_err("Size of NFT_EXPR_CMP_DATA mismatches");
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_CMP_SREG) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_CMP_SREG))
- print_err("Expr NFT_EXPR_CMP_SREG mismatches");
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_CMP_OP) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_CMP_OP))
- print_err("Expr NFT_EXPR_CMP_OP mismatches");
+ print_err("Size of NFTNL_EXPR_CMP_DATA mismatches");
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_CMP_SREG) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_CMP_SREG))
+ print_err("Expr NFTNL_EXPR_CMP_SREG mismatches");
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_CMP_OP) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_CMP_OP))
+ print_err("Expr NFTNL_EXPR_CMP_OP mismatches");
}
int main(int argc, char *argv[])
{
- struct nft_rule *a, *b;
- struct nft_rule_expr *ex;
+ struct nftnl_rule *a, *b;
+ struct nftnl_rule_expr *ex;
struct nlmsghdr *nlh;
char buf[4096];
- struct nft_rule_expr_iter *iter_a, *iter_b;
- struct nft_rule_expr *rule_a, *rule_b;
+ struct nftnl_rule_expr_iter *iter_a, *iter_b;
+ struct nftnl_rule_expr *rule_a, *rule_b;
uint32_t data_len = 0x01010101;
- a = nft_rule_alloc();
- b = nft_rule_alloc();
+ a = nftnl_rule_alloc();
+ b = nftnl_rule_alloc();
if (a == NULL || b == NULL)
print_err("OOM");
- ex = nft_rule_expr_alloc("cmp");
+ ex = nftnl_rule_expr_alloc("cmp");
if (ex == NULL)
print_err("OOM");
- nft_rule_expr_set(ex, NFT_EXPR_CMP_DATA, &data_len, sizeof(data_len));
- nft_rule_expr_set_u32(ex, NFT_EXPR_CMP_SREG, 0x12345678);
- nft_rule_expr_set_u32(ex, NFT_EXPR_CMP_OP, 0x12345678);
+ nftnl_rule_expr_set(ex, NFTNL_EXPR_CMP_DATA, &data_len, sizeof(data_len));
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_CMP_SREG, 0x12345678);
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_CMP_OP, 0x12345678);
- nft_rule_add_expr(a, ex);
+ nftnl_rule_add_expr(a, ex);
- nlh = nft_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
- nft_rule_nlmsg_build_payload(nlh, a);
+ nlh = nftnl_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
+ nftnl_rule_nlmsg_build_payload(nlh, a);
- if (nft_rule_nlmsg_parse(nlh, b) < 0)
+ if (nftnl_rule_nlmsg_parse(nlh, b) < 0)
print_err("parsing problems");
- iter_a = nft_rule_expr_iter_create(a);
- iter_b = nft_rule_expr_iter_create(b);
+ iter_a = nftnl_rule_expr_iter_create(a);
+ iter_b = nftnl_rule_expr_iter_create(b);
if (iter_a == NULL || iter_b == NULL)
print_err("OOM");
- rule_a = nft_rule_expr_iter_next(iter_a);
- rule_b = nft_rule_expr_iter_next(iter_b);
+ rule_a = nftnl_rule_expr_iter_next(iter_a);
+ rule_b = nftnl_rule_expr_iter_next(iter_b);
if (rule_a == NULL || rule_b == NULL)
print_err("OOM");
- cmp_nft_rule_expr(rule_a, rule_b);
+ cmp_nftnl_rule_expr(rule_a, rule_b);
- if (nft_rule_expr_iter_next(iter_a) != NULL ||
- nft_rule_expr_iter_next(iter_b) != NULL)
+ if (nftnl_rule_expr_iter_next(iter_a) != NULL ||
+ nftnl_rule_expr_iter_next(iter_b) != NULL)
print_err("More 1 expr.");
- nft_rule_expr_iter_destroy(iter_a);
- nft_rule_expr_iter_destroy(iter_b);
- nft_rule_free(a);
- nft_rule_free(b);
+ nftnl_rule_expr_iter_destroy(iter_a);
+ nftnl_rule_expr_iter_destroy(iter_b);
+ nftnl_rule_free(a);
+ nftnl_rule_free(b);
if (!test_ok)
exit(EXIT_FAILURE);
diff --git a/tests/nft-expr_counter-test.c b/tests/nft-expr_counter-test.c
index e27d20a..7c28f08 100644
--- a/tests/nft-expr_counter-test.c
+++ b/tests/nft-expr_counter-test.c
@@ -27,64 +27,64 @@ static void print_err(const char *msg)
printf("\033[31mERROR:\e[0m %s\n", msg);
}
-static void cmp_nft_rule_expr(struct nft_rule_expr *rule_a,
- struct nft_rule_expr *rule_b)
+static void cmp_nftnl_rule_expr(struct nftnl_rule_expr *rule_a,
+ struct nftnl_rule_expr *rule_b)
{
- if (nft_rule_expr_get_u64(rule_a, NFT_EXPR_CTR_BYTES) !=
- nft_rule_expr_get_u64(rule_b, NFT_EXPR_CTR_BYTES))
- print_err("Expr NFT_EXPR_CTR_BYTES mismatches");
- if (nft_rule_expr_get_u64(rule_a, NFT_EXPR_CTR_PACKETS) !=
- nft_rule_expr_get_u64(rule_b, NFT_EXPR_CTR_PACKETS))
- print_err("Expr NFT_EXPR_CTR_PACKETS mismatches");
+ if (nftnl_rule_expr_get_u64(rule_a, NFTNL_EXPR_CTR_BYTES) !=
+ nftnl_rule_expr_get_u64(rule_b, NFTNL_EXPR_CTR_BYTES))
+ print_err("Expr NFTNL_EXPR_CTR_BYTES mismatches");
+ if (nftnl_rule_expr_get_u64(rule_a, NFTNL_EXPR_CTR_PACKETS) !=
+ nftnl_rule_expr_get_u64(rule_b, NFTNL_EXPR_CTR_PACKETS))
+ print_err("Expr NFTNL_EXPR_CTR_PACKETS mismatches");
}
int main(int argc, char *argv[])
{
- struct nft_rule *a, *b;
- struct nft_rule_expr *ex;
+ struct nftnl_rule *a, *b;
+ struct nftnl_rule_expr *ex;
struct nlmsghdr *nlh;
char buf[4096];
- struct nft_rule_expr_iter *iter_a, *iter_b;
- struct nft_rule_expr *rule_a, *rule_b;
+ struct nftnl_rule_expr_iter *iter_a, *iter_b;
+ struct nftnl_rule_expr *rule_a, *rule_b;
- a = nft_rule_alloc();
- b = nft_rule_alloc();
+ a = nftnl_rule_alloc();
+ b = nftnl_rule_alloc();
if (a == NULL || b == NULL)
print_err("OOM");
- ex = nft_rule_expr_alloc("counter");
+ ex = nftnl_rule_expr_alloc("counter");
if (ex == NULL)
print_err("OOM");
- nft_rule_expr_set_u64(ex, NFT_EXPR_CTR_BYTES, 0x123456789abcdef0);
- nft_rule_expr_set_u64(ex, NFT_EXPR_CTR_PACKETS, 0x123456789abcdef0);
- nft_rule_add_expr(a, ex);
+ nftnl_rule_expr_set_u64(ex, NFTNL_EXPR_CTR_BYTES, 0x123456789abcdef0);
+ nftnl_rule_expr_set_u64(ex, NFTNL_EXPR_CTR_PACKETS, 0x123456789abcdef0);
+ nftnl_rule_add_expr(a, ex);
- nlh = nft_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
- nft_rule_nlmsg_build_payload(nlh, a);
+ nlh = nftnl_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
+ nftnl_rule_nlmsg_build_payload(nlh, a);
- if (nft_rule_nlmsg_parse(nlh, b) < 0)
+ if (nftnl_rule_nlmsg_parse(nlh, b) < 0)
print_err("parsing problems");
- iter_a = nft_rule_expr_iter_create(a);
- iter_b = nft_rule_expr_iter_create(b);
+ iter_a = nftnl_rule_expr_iter_create(a);
+ iter_b = nftnl_rule_expr_iter_create(b);
if (iter_a == NULL || iter_b == NULL)
print_err("OOM");
- rule_a = nft_rule_expr_iter_next(iter_a);
- rule_b = nft_rule_expr_iter_next(iter_b);
+ rule_a = nftnl_rule_expr_iter_next(iter_a);
+ rule_b = nftnl_rule_expr_iter_next(iter_b);
if (rule_a == NULL || rule_b == NULL)
print_err("OOM");
- cmp_nft_rule_expr(rule_a, rule_b);
+ cmp_nftnl_rule_expr(rule_a, rule_b);
- if (nft_rule_expr_iter_next(iter_a) != NULL ||
- nft_rule_expr_iter_next(iter_b) != NULL)
+ if (nftnl_rule_expr_iter_next(iter_a) != NULL ||
+ nftnl_rule_expr_iter_next(iter_b) != NULL)
print_err("More 1 expr.");
- nft_rule_expr_iter_destroy(iter_a);
- nft_rule_expr_iter_destroy(iter_b);
- nft_rule_free(a);
- nft_rule_free(b);
+ nftnl_rule_expr_iter_destroy(iter_a);
+ nftnl_rule_expr_iter_destroy(iter_b);
+ nftnl_rule_free(a);
+ nftnl_rule_free(b);
if (!test_ok)
exit(EXIT_FAILURE);
diff --git a/tests/nft-expr_ct-test.c b/tests/nft-expr_ct-test.c
index dd07854..d84fc5e 100644
--- a/tests/nft-expr_ct-test.c
+++ b/tests/nft-expr_ct-test.c
@@ -26,68 +26,68 @@ static void print_err(const char *msg)
printf("\033[31mERROR:\e[0m %s\n", msg);
}
-static void cmp_nft_rule_expr(struct nft_rule_expr *rule_a,
- struct nft_rule_expr *rule_b)
+static void cmp_nftnl_rule_expr(struct nftnl_rule_expr *rule_a,
+ struct nftnl_rule_expr *rule_b)
{
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_CT_KEY) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_CT_KEY))
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_CT_KEY) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_CT_KEY))
print_err("Expr CT_KEY mismatches");
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_CT_DIR) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_CT_DIR))
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_CT_DIR) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_CT_DIR))
print_err("Expr CT_DIR mismatches");
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_CT_DREG) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_CT_DREG))
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_CT_DREG) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_CT_DREG))
print_err("Expr CT_DREG mismatches");
}
int main(int argc, char *argv[])
{
- struct nft_rule *a, *b;
- struct nft_rule_expr *ex;
+ struct nftnl_rule *a, *b;
+ struct nftnl_rule_expr *ex;
struct nlmsghdr *nlh;
char buf[4096];
- struct nft_rule_expr_iter *iter_a, *iter_b;
- struct nft_rule_expr *rule_a, *rule_b;
+ struct nftnl_rule_expr_iter *iter_a, *iter_b;
+ struct nftnl_rule_expr *rule_a, *rule_b;
- a = nft_rule_alloc();
- b = nft_rule_alloc();
+ a = nftnl_rule_alloc();
+ b = nftnl_rule_alloc();
if (a == NULL || b == NULL)
print_err("OOM");
- ex = nft_rule_expr_alloc("ct");
+ ex = nftnl_rule_expr_alloc("ct");
if (ex == NULL)
print_err("OOM");
- nft_rule_expr_set_u32(ex, NFT_EXPR_CT_KEY, 0x1234568);
- nft_rule_expr_set_u32(ex, NFT_EXPR_CT_DIR, 0x12);
- nft_rule_expr_set_u32(ex, NFT_EXPR_CT_DREG, 0x12345678);
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_CT_KEY, 0x1234568);
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_CT_DIR, 0x12);
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_CT_DREG, 0x12345678);
- nft_rule_add_expr(a, ex);
+ nftnl_rule_add_expr(a, ex);
- nlh = nft_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
- nft_rule_nlmsg_build_payload(nlh, a);
+ nlh = nftnl_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
+ nftnl_rule_nlmsg_build_payload(nlh, a);
- if (nft_rule_nlmsg_parse(nlh, b) < 0)
+ if (nftnl_rule_nlmsg_parse(nlh, b) < 0)
print_err("parsing problems");
- iter_a = nft_rule_expr_iter_create(a);
- iter_b = nft_rule_expr_iter_create(b);
+ iter_a = nftnl_rule_expr_iter_create(a);
+ iter_b = nftnl_rule_expr_iter_create(b);
if (iter_a == NULL || iter_b == NULL)
print_err("OOM");
- rule_a = nft_rule_expr_iter_next(iter_a);
- rule_b = nft_rule_expr_iter_next(iter_b);
+ rule_a = nftnl_rule_expr_iter_next(iter_a);
+ rule_b = nftnl_rule_expr_iter_next(iter_b);
if (rule_a == NULL || rule_b == NULL)
print_err("OOM");
- cmp_nft_rule_expr(rule_a, rule_b);
+ cmp_nftnl_rule_expr(rule_a, rule_b);
- if (nft_rule_expr_iter_next(iter_a) != NULL ||
- nft_rule_expr_iter_next(iter_b) != NULL)
+ if (nftnl_rule_expr_iter_next(iter_a) != NULL ||
+ nftnl_rule_expr_iter_next(iter_b) != NULL)
print_err("More 1 expr.");
- nft_rule_expr_iter_destroy(iter_a);
- nft_rule_expr_iter_destroy(iter_b);
- nft_rule_free(a);
- nft_rule_free(b);
+ nftnl_rule_expr_iter_destroy(iter_a);
+ nftnl_rule_expr_iter_destroy(iter_b);
+ nftnl_rule_free(a);
+ nftnl_rule_free(b);
if (!test_ok)
exit(EXIT_FAILURE);
diff --git a/tests/nft-expr_exthdr-test.c b/tests/nft-expr_exthdr-test.c
index c0dc609..d68286d 100644
--- a/tests/nft-expr_exthdr-test.c
+++ b/tests/nft-expr_exthdr-test.c
@@ -27,72 +27,72 @@ static void print_err(const char *msg)
printf("\033[31mERROR:\e[0m %s\n", msg);
}
-static void cmp_nft_rule_expr(struct nft_rule_expr *rule_a,
- struct nft_rule_expr *rule_b)
+static void cmp_nftnl_rule_expr(struct nftnl_rule_expr *rule_a,
+ struct nftnl_rule_expr *rule_b)
{
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_EXTHDR_DREG) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_EXTHDR_DREG))
- print_err("Expr NFT_EXPR_EXTHDR_DREG mismatches");
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_EXTHDR_TYPE) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_EXTHDR_TYPE))
- print_err("Expr NFT_EXPR_EXTHDR_TYPE mismatches");
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_EXTHDR_OFFSET) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_EXTHDR_OFFSET))
- print_err("Expr NFT_EXPR_EXTHDR_OFFSET mismatches");
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_EXTHDR_LEN) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_EXTHDR_LEN))
- print_err("Expr NFT_EXPR_EXTHDR_LEN mismatches");
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_EXTHDR_DREG) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_EXTHDR_DREG))
+ print_err("Expr NFTNL_EXPR_EXTHDR_DREG mismatches");
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_EXTHDR_TYPE) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_EXTHDR_TYPE))
+ print_err("Expr NFTNL_EXPR_EXTHDR_TYPE mismatches");
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_EXTHDR_OFFSET) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_EXTHDR_OFFSET))
+ print_err("Expr NFTNL_EXPR_EXTHDR_OFFSET mismatches");
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_EXTHDR_LEN) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_EXTHDR_LEN))
+ print_err("Expr NFTNL_EXPR_EXTHDR_LEN mismatches");
}
int main(int argc, char *argv[])
{
- struct nft_rule *a, *b;
- struct nft_rule_expr *ex;
+ struct nftnl_rule *a, *b;
+ struct nftnl_rule_expr *ex;
struct nlmsghdr *nlh;
char buf[4096];
- struct nft_rule_expr_iter *iter_a, *iter_b;
- struct nft_rule_expr *rule_a, *rule_b;
+ struct nftnl_rule_expr_iter *iter_a, *iter_b;
+ struct nftnl_rule_expr *rule_a, *rule_b;
- a = nft_rule_alloc();
- b = nft_rule_alloc();
+ a = nftnl_rule_alloc();
+ b = nftnl_rule_alloc();
if (a == NULL || b == NULL)
print_err("OOM");
- ex = nft_rule_expr_alloc("exthdr");
+ ex = nftnl_rule_expr_alloc("exthdr");
if (ex == NULL)
print_err("OOM");
- nft_rule_expr_set_u32(ex, NFT_EXPR_EXTHDR_DREG, 0x12345678);
- nft_rule_expr_set_u32(ex, NFT_EXPR_EXTHDR_TYPE, 0x12);
- nft_rule_expr_set_u32(ex, NFT_EXPR_EXTHDR_OFFSET, 0x12345678);
- nft_rule_expr_set_u32(ex, NFT_EXPR_EXTHDR_LEN, 0x12345678);
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_EXTHDR_DREG, 0x12345678);
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_EXTHDR_TYPE, 0x12);
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_EXTHDR_OFFSET, 0x12345678);
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_EXTHDR_LEN, 0x12345678);
- nft_rule_add_expr(a, ex);
+ nftnl_rule_add_expr(a, ex);
- nlh = nft_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
- nft_rule_nlmsg_build_payload(nlh, a);
- if (nft_rule_nlmsg_parse(nlh, b) < 0)
+ 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("parsing problems");
- iter_a = nft_rule_expr_iter_create(a);
- iter_b = nft_rule_expr_iter_create(b);
+ iter_a = nftnl_rule_expr_iter_create(a);
+ iter_b = nftnl_rule_expr_iter_create(b);
if (iter_a == NULL || iter_b == NULL)
print_err("OOM");
- rule_a = nft_rule_expr_iter_next(iter_a);
- rule_b = nft_rule_expr_iter_next(iter_b);
+ rule_a = nftnl_rule_expr_iter_next(iter_a);
+ rule_b = nftnl_rule_expr_iter_next(iter_b);
if (rule_a == NULL || rule_b == NULL)
print_err("OOM");
- cmp_nft_rule_expr(rule_a, rule_b);
+ cmp_nftnl_rule_expr(rule_a, rule_b);
- if (nft_rule_expr_iter_next(iter_a) != NULL ||
- nft_rule_expr_iter_next(iter_b) != NULL)
+ if (nftnl_rule_expr_iter_next(iter_a) != NULL ||
+ nftnl_rule_expr_iter_next(iter_b) != NULL)
print_err("More 1 expr.");
- nft_rule_expr_iter_destroy(iter_a);
- nft_rule_expr_iter_destroy(iter_b);
- nft_rule_free(a);
- nft_rule_free(b);
+ nftnl_rule_expr_iter_destroy(iter_a);
+ nftnl_rule_expr_iter_destroy(iter_b);
+ nftnl_rule_free(a);
+ nftnl_rule_free(b);
if (!test_ok)
exit(EXIT_FAILURE);
diff --git a/tests/nft-expr_immediate-test.c b/tests/nft-expr_immediate-test.c
index c45cefa..08145bb 100644
--- a/tests/nft-expr_immediate-test.c
+++ b/tests/nft-expr_immediate-test.c
@@ -27,79 +27,79 @@ static void print_err(const char *msg)
printf("\033[31mERROR:\e[0m %s\n", msg);
}
-static void cmp_nft_rule_expr(struct nft_rule_expr *rule_a,
- struct nft_rule_expr *rule_b)
+static void cmp_nftnl_rule_expr(struct nftnl_rule_expr *rule_a,
+ struct nftnl_rule_expr *rule_b)
{
uint32_t data_a, data_b, chain_a, chain_b;
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_IMM_DREG) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_IMM_DREG))
- print_err("Expr NFT_EXPR_IMM_DREG mismatches");
- nft_rule_expr_get(rule_a, NFT_EXPR_IMM_DATA, data_a);
- nft_rule_expr_get(rule_b, NFT_EXPR_IMM_DATA, data_b)
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_IMM_VERDICT) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_IMM_VERDICT))
- print_err("Expr NFT_EXPR_IMM_VERDICT mismatches");
- nft_rule_expr_get(rule_a, NFT_EXPR_IMM_CHAIN, chain_a);
- nft_rule_expr_get(rule_b, NFT_EXPR_IMM_CHAIN, chain_b);
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_IMM_DREG) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_IMM_DREG))
+ print_err("Expr NFTNL_EXPR_IMM_DREG mismatches");
+ nftnl_rule_expr_get(rule_a, NFTNL_EXPR_IMM_DATA, data_a);
+ nftnl_rule_expr_get(rule_b, NFTNL_EXPR_IMM_DATA, data_b)
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_IMM_VERDICT) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_IMM_VERDICT))
+ print_err("Expr NFTNL_EXPR_IMM_VERDICT mismatches");
+ nftnl_rule_expr_get(rule_a, NFTNL_EXPR_IMM_CHAIN, chain_a);
+ nftnl_rule_expr_get(rule_b, NFTNL_EXPR_IMM_CHAIN, chain_b);
if (data_a != data_b)
- print_err("Expr NFT_EXPR_IMM_DATA. Size mismatches");
+ print_err("Expr NFTNL_EXPR_IMM_DATA. Size mismatches");
if (chain_a != chain_b)
- print_err("Expr NFT_EXPR_IMM_CHAIN. Size mismatches");
+ print_err("Expr NFTNL_EXPR_IMM_CHAIN. Size mismatches");
}
int main(int argc, char *argv[])
{
- struct nft_rule *a, *b;
- struct nft_rule_expr *ex;
+ struct nftnl_rule *a, *b;
+ struct nftnl_rule_expr *ex;
struct nlmsghdr *nlh;
char buf[4096];
- struct nft_rule_expr_iter *iter_a, *iter_b;
- struct nft_rule_expr *rule_a, *rule_b;
+ struct nftnl_rule_expr_iter *iter_a, *iter_b;
+ struct nftnl_rule_expr *rule_a, *rule_b;
uint32_t chain_t = 0x12345678;
uint32_t data_t = 0x12345678;
- a = nft_rule_alloc();
- b = nft_rule_alloc();
+ a = nftnl_rule_alloc();
+ b = nftnl_rule_alloc();
if (a == NULL || b == NULL)
print_err("OOM");
- ex = nft_rule_expr_alloc("immediate");
+ ex = nftnl_rule_expr_alloc("immediate");
if (ex == NULL)
print_err("OOM");
- nft_rule_expr_set_u32(ex, NFT_EXPR_IMM_DREG, 0x1234568);
- nft_rule_expr_set(ex, NFT_EXPR_IMM_DATA, &chain_t, sizeof(chain_t));
- nft_rule_expr_set_u32(ex, NFT_EXPR_IMM_VERDICT, 0x12345678);
- nft_rule_expr_set(ex, NFT_EXPR_IMM_CHAIN, &data_t, sizeof(data_t));
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_IMM_DREG, 0x1234568);
+ nftnl_rule_expr_set(ex, NFTNL_EXPR_IMM_DATA, &chain_t, sizeof(chain_t));
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_IMM_VERDICT, 0x12345678);
+ nftnl_rule_expr_set(ex, NFTNL_EXPR_IMM_CHAIN, &data_t, sizeof(data_t));
- nft_rule_add_expr(a, ex);
+ nftnl_rule_add_expr(a, ex);
- nlh = nft_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
- nft_rule_nlmsg_build_payload(nlh, a);
+ nlh = nftnl_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
+ nftnl_rule_nlmsg_build_payload(nlh, a);
- if (nft_rule_nlmsg_parse(nlh, b) < 0)
+ if (nftnl_rule_nlmsg_parse(nlh, b) < 0)
print_err("parsing problems");
- iter_a = nft_rule_expr_iter_create(a);
- iter_b = nft_rule_expr_iter_create(b);
+ iter_a = nftnl_rule_expr_iter_create(a);
+ iter_b = nftnl_rule_expr_iter_create(b);
if (iter_a == NULL || iter_b == NULL)
print_err("OOM");
- rule_a = nft_rule_expr_iter_next(iter_a);
- rule_b = nft_rule_expr_iter_next(iter_b);
+ rule_a = nftnl_rule_expr_iter_next(iter_a);
+ rule_b = nftnl_rule_expr_iter_next(iter_b);
if (rule_a == NULL || rule_b == NULL)
print_err("OOM");
- cmp_nft_rule_expr(rule_a, rule_b);
+ cmp_nftnl_rule_expr(rule_a, rule_b);
- if (nft_rule_expr_iter_next(iter_a) != NULL ||
- nft_rule_expr_iter_next(iter_b) != NULL)
+ if (nftnl_rule_expr_iter_next(iter_a) != NULL ||
+ nftnl_rule_expr_iter_next(iter_b) != NULL)
print_err("More 1 expr.");
- nft_rule_expr_iter_destroy(iter_a);
- nft_rule_expr_iter_destroy(iter_b);
- nft_rule_free(a);
- nft_rule_free(b);
+ nftnl_rule_expr_iter_destroy(iter_a);
+ nftnl_rule_expr_iter_destroy(iter_b);
+ nftnl_rule_free(a);
+ nftnl_rule_free(b);
if (!test_ok)
exit(EXIT_FAILURE);
diff --git a/tests/nft-expr_limit-test.c b/tests/nft-expr_limit-test.c
index 38c3e5b..a81c7ff 100644
--- a/tests/nft-expr_limit-test.c
+++ b/tests/nft-expr_limit-test.c
@@ -28,65 +28,65 @@ static void print_err(const char *msg)
printf("\033[31mERROR:\e[0m %s\n", msg);
}
-static void cmp_nft_rule_expr(struct nft_rule_expr *rule_a,
- struct nft_rule_expr *rule_b)
+static void cmp_nftnl_rule_expr(struct nftnl_rule_expr *rule_a,
+ struct nftnl_rule_expr *rule_b)
{
- if (nft_rule_expr_get_u64(rule_a, NFT_EXPR_LIMIT_RATE) !=
- nft_rule_expr_get_u64(rule_b, NFT_EXPR_LIMIT_RATE))
+ if (nftnl_rule_expr_get_u64(rule_a, NFTNL_EXPR_LIMIT_RATE) !=
+ nftnl_rule_expr_get_u64(rule_b, NFTNL_EXPR_LIMIT_RATE))
print_err("Expr CTR_BYTES mismatches");
- if (nft_rule_expr_get_u64(rule_a, NFT_EXPR_LIMIT_UNIT) !=
- nft_rule_expr_get_u64(rule_b, NFT_EXPR_LIMIT_UNIT))
+ if (nftnl_rule_expr_get_u64(rule_a, NFTNL_EXPR_LIMIT_UNIT) !=
+ nftnl_rule_expr_get_u64(rule_b, NFTNL_EXPR_LIMIT_UNIT))
print_err("Expr CTR_PACKET mismatches");
}
int main(int argc, char *argv[])
{
- struct nft_rule *a, *b;
- struct nft_rule_expr *ex;
+ struct nftnl_rule *a, *b;
+ struct nftnl_rule_expr *ex;
struct nlmsghdr *nlh;
char buf[4096];
- struct nft_rule_expr_iter *iter_a, *iter_b;
- struct nft_rule_expr *rule_a, *rule_b;
+ struct nftnl_rule_expr_iter *iter_a, *iter_b;
+ struct nftnl_rule_expr *rule_a, *rule_b;
- a = nft_rule_alloc();
- b = nft_rule_alloc();
+ a = nftnl_rule_alloc();
+ b = nftnl_rule_alloc();
if (a == NULL || b == NULL)
print_err("OOM");
- ex = nft_rule_expr_alloc("limit");
+ ex = nftnl_rule_expr_alloc("limit");
if (ex == NULL)
print_err("OOM");
- nft_rule_expr_set_u64(ex, NFT_EXPR_LIMIT_RATE, 0x123456789abcdef0);
- nft_rule_expr_set_u64(ex, NFT_EXPR_LIMIT_UNIT, 0x123456789abcdef0);
+ nftnl_rule_expr_set_u64(ex, NFTNL_EXPR_LIMIT_RATE, 0x123456789abcdef0);
+ nftnl_rule_expr_set_u64(ex, NFTNL_EXPR_LIMIT_UNIT, 0x123456789abcdef0);
- nft_rule_add_expr(a, ex);
+ nftnl_rule_add_expr(a, ex);
- nlh = nft_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
- nft_rule_nlmsg_build_payload(nlh, a);
+ nlh = nftnl_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
+ nftnl_rule_nlmsg_build_payload(nlh, a);
- if (nft_rule_nlmsg_parse(nlh, b) < 0)
+ if (nftnl_rule_nlmsg_parse(nlh, b) < 0)
print_err("parsing problems");
- iter_a = nft_rule_expr_iter_create(a);
- iter_b = nft_rule_expr_iter_create(b);
+ iter_a = nftnl_rule_expr_iter_create(a);
+ iter_b = nftnl_rule_expr_iter_create(b);
if (iter_a == NULL || iter_b == NULL)
print_err("OOM");
- rule_a = nft_rule_expr_iter_next(iter_a);
- rule_b = nft_rule_expr_iter_next(iter_b);
+ rule_a = nftnl_rule_expr_iter_next(iter_a);
+ rule_b = nftnl_rule_expr_iter_next(iter_b);
if (rule_a == NULL || rule_b == NULL)
print_err("OOM");
- cmp_nft_rule_expr(rule_a, rule_b);
+ cmp_nftnl_rule_expr(rule_a, rule_b);
- if (nft_rule_expr_iter_next(iter_a) != NULL ||
- nft_rule_expr_iter_next(iter_b) != NULL)
+ if (nftnl_rule_expr_iter_next(iter_a) != NULL ||
+ nftnl_rule_expr_iter_next(iter_b) != NULL)
print_err("More 1 expr.");
- nft_rule_expr_iter_destroy(iter_a);
- nft_rule_expr_iter_destroy(iter_b);
- nft_rule_free(a);
- nft_rule_free(b);
+ nftnl_rule_expr_iter_destroy(iter_a);
+ nftnl_rule_expr_iter_destroy(iter_b);
+ nftnl_rule_free(a);
+ nftnl_rule_free(b);
if (!test_ok)
exit(EXIT_FAILURE);
diff --git a/tests/nft-expr_log-test.c b/tests/nft-expr_log-test.c
index 7e257ab..d231d84 100644
--- a/tests/nft-expr_log-test.c
+++ b/tests/nft-expr_log-test.c
@@ -27,71 +27,71 @@ static void print_err(const char *msg)
test_ok = 0;
}
-static void cmp_nft_rule_expr(struct nft_rule_expr *rule_a,
- struct nft_rule_expr *rule_b)
+static void cmp_nftnl_rule_expr(struct nftnl_rule_expr *rule_a,
+ struct nftnl_rule_expr *rule_b)
{
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_LOG_SNAPLEN) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_LOG_SNAPLEN))
- print_err("Expr NFT_EXPR_LOG_SNAPLEN mismatches");
- if (nft_rule_expr_get_u16(rule_a, NFT_EXPR_LOG_GROUP) !=
- nft_rule_expr_get_u16(rule_b, NFT_EXPR_LOG_GROUP))
- print_err("Expr NFT_EXPR_LOG_GROUP mismatches");
- if (nft_rule_expr_get_u16(rule_a, NFT_EXPR_LOG_QTHRESHOLD) !=
- nft_rule_expr_get_u16(rule_b, NFT_EXPR_LOG_QTHRESHOLD))
- print_err("Expr NFT_EXPR_LOG_QTHRESHOLD mismatches");
- if(strcmp(nft_rule_expr_get_str(rule_a, NFT_EXPR_LOG_PREFIX),
- nft_rule_expr_get_str(rule_b, NFT_EXPR_LOG_PREFIX)) != 0)
- print_err("Expr NFT_EXPR_LOG_PREFIX mismatches");
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_LOG_SNAPLEN) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_LOG_SNAPLEN))
+ print_err("Expr NFTNL_EXPR_LOG_SNAPLEN mismatches");
+ if (nftnl_rule_expr_get_u16(rule_a, NFTNL_EXPR_LOG_GROUP) !=
+ nftnl_rule_expr_get_u16(rule_b, NFTNL_EXPR_LOG_GROUP))
+ print_err("Expr NFTNL_EXPR_LOG_GROUP mismatches");
+ if (nftnl_rule_expr_get_u16(rule_a, NFTNL_EXPR_LOG_QTHRESHOLD) !=
+ nftnl_rule_expr_get_u16(rule_b, NFTNL_EXPR_LOG_QTHRESHOLD))
+ print_err("Expr NFTNL_EXPR_LOG_QTHRESHOLD mismatches");
+ if(strcmp(nftnl_rule_expr_get_str(rule_a, NFTNL_EXPR_LOG_PREFIX),
+ nftnl_rule_expr_get_str(rule_b, NFTNL_EXPR_LOG_PREFIX)) != 0)
+ print_err("Expr NFTNL_EXPR_LOG_PREFIX mismatches");
}
int main(int argc, char *argv[])
{
- struct nft_rule *a, *b;
- struct nft_rule_expr *ex;
+ struct nftnl_rule *a, *b;
+ struct nftnl_rule_expr *ex;
struct nlmsghdr *nlh;
char buf[4096];
- struct nft_rule_expr_iter *iter_a, *iter_b;
- struct nft_rule_expr *rule_a, *rule_b;
+ struct nftnl_rule_expr_iter *iter_a, *iter_b;
+ struct nftnl_rule_expr *rule_a, *rule_b;
- a = nft_rule_alloc();
- b = nft_rule_alloc();
+ a = nftnl_rule_alloc();
+ b = nftnl_rule_alloc();
if (a == NULL || b == NULL)
print_err("OOM");
- ex = nft_rule_expr_alloc("log");
+ ex = nftnl_rule_expr_alloc("log");
if (ex == NULL)
print_err("OOM");
- nft_rule_expr_set_u32(ex, NFT_EXPR_LOG_SNAPLEN, 0x12345678);
- nft_rule_expr_set_u16(ex, NFT_EXPR_LOG_GROUP, 0x1234);
- nft_rule_expr_set_u16(ex, NFT_EXPR_LOG_QTHRESHOLD, 0x1234);
- nft_rule_expr_set_str(ex, NFT_EXPR_LOG_PREFIX, "test");
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_LOG_SNAPLEN, 0x12345678);
+ nftnl_rule_expr_set_u16(ex, NFTNL_EXPR_LOG_GROUP, 0x1234);
+ nftnl_rule_expr_set_u16(ex, NFTNL_EXPR_LOG_QTHRESHOLD, 0x1234);
+ nftnl_rule_expr_set_str(ex, NFTNL_EXPR_LOG_PREFIX, "test");
- nft_rule_add_expr(a, ex);
+ nftnl_rule_add_expr(a, ex);
- nlh = nft_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
- nft_rule_nlmsg_build_payload(nlh, a);
- if (nft_rule_nlmsg_parse(nlh, b) < 0)
+ 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("parsing problems");
- iter_a = nft_rule_expr_iter_create(a);
- iter_b = nft_rule_expr_iter_create(b);
+ iter_a = nftnl_rule_expr_iter_create(a);
+ iter_b = nftnl_rule_expr_iter_create(b);
if (iter_a == NULL || iter_b == NULL)
print_err("OOM");
- rule_a = nft_rule_expr_iter_next(iter_a);
- rule_b = nft_rule_expr_iter_next(iter_b);
+ rule_a = nftnl_rule_expr_iter_next(iter_a);
+ rule_b = nftnl_rule_expr_iter_next(iter_b);
if (rule_a == NULL || rule_b == NULL)
print_err("OOM");
- cmp_nft_rule_expr(rule_a, rule_b);
+ cmp_nftnl_rule_expr(rule_a, rule_b);
- if (nft_rule_expr_iter_next(iter_a) != NULL ||
- nft_rule_expr_iter_next(iter_b) != NULL)
+ if (nftnl_rule_expr_iter_next(iter_a) != NULL ||
+ nftnl_rule_expr_iter_next(iter_b) != NULL)
print_err("More 1 expr.");
- nft_rule_expr_iter_destroy(iter_a);
- nft_rule_expr_iter_destroy(iter_b);
- nft_rule_free(a);
- nft_rule_free(b);
+ nftnl_rule_expr_iter_destroy(iter_a);
+ nftnl_rule_expr_iter_destroy(iter_b);
+ nftnl_rule_free(a);
+ nftnl_rule_free(b);
if (!test_ok)
exit(EXIT_FAILURE);
diff --git a/tests/nft-expr_lookup-test.c b/tests/nft-expr_lookup-test.c
index 38a2a46..b9235a1 100644
--- a/tests/nft-expr_lookup-test.c
+++ b/tests/nft-expr_lookup-test.c
@@ -27,73 +27,73 @@ static void print_err(const char *msg)
printf("\033[31mERROR:\e[0m %s\n", msg);
}
-static void cmp_nft_rule_expr(struct nft_rule_expr *rule_a,
- struct nft_rule_expr *rule_b)
+static void cmp_nftnl_rule_expr(struct nftnl_rule_expr *rule_a,
+ struct nftnl_rule_expr *rule_b)
{
uint32_t data_lena, data_lenb;
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_LOOKUP_SREG) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_LOOPUP_SREG))
- print_err("Expr NFT_EXPR_LOOkUP_SREG mismatches");
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_LOOKUP_DREG) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_LOOPUP_DREG))
- print_err("Expr NFT_EXPR_LOOkUP_DREG mismatches");
- nft_rule_expr_get(rule_a, NFT_EXPR_LOOKUP_SET, &data_lena);
- nft_rule_expr_get(rule_b, NFT_EXPR_LOOKUP_SET, &data_lenb);
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_LOOKUP_SREG) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_LOOPUP_SREG))
+ print_err("Expr NFTNL_EXPR_LOOkUP_SREG mismatches");
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_LOOKUP_DREG) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_LOOPUP_DREG))
+ print_err("Expr NFTNL_EXPR_LOOkUP_DREG mismatches");
+ nftnl_rule_expr_get(rule_a, NFTNL_EXPR_LOOKUP_SET, &data_lena);
+ nftnl_rule_expr_get(rule_b, NFTNL_EXPR_LOOKUP_SET, &data_lenb);
if (data_lena != data_lenb)
- print_err("Expr NFT_EXPR_LOOKUP_SET size mismatches");
+ print_err("Expr NFTNL_EXPR_LOOKUP_SET size mismatches");
}
int main(int argc, char *argv[])
{
- struct nft_rule *a, *b;
- struct nft_rule_expr *ex;
+ struct nftnl_rule *a, *b;
+ struct nftnl_rule_expr *ex;
struct nlmsghdr *nlh;
char buf[4096];
- struct nft_rule_expr_iter *iter_a, *iter_b;
- struct nft_rule_expr *rule_a, *rule_b;
+ struct nftnl_rule_expr_iter *iter_a, *iter_b;
+ struct nftnl_rule_expr *rule_a, *rule_b;
uint32_t lookup_set = 0x12345678;
- a = nft_rule_alloc();
- b = nft_rule_alloc();
+ a = nftnl_rule_alloc();
+ b = nftnl_rule_alloc();
if (a == NULL || b == NULL)
print_err("OOM");
- ex = nft_rule_expr_alloc("lookup");
+ ex = nftnl_rule_expr_alloc("lookup");
if (ex == NULL)
print_err("OOM");
- nft_rule_expr_set_u32(ex, NFT_EXPR_LOOKUP_SREG, 0x12345678);
- nft_rule_expr_set_u32(ex, NFT_EXPR_LOOKUP_DREG, 0x12345678);
- nft_rule_expr_set(ex, NFT_EXPR_LOOKUP_SET, &lookup_set,
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_LOOKUP_SREG, 0x12345678);
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_LOOKUP_DREG, 0x12345678);
+ nftnl_rule_expr_set(ex, NFTNL_EXPR_LOOKUP_SET, &lookup_set,
sizeof(lookup_set));
- nft_rule_add_expr(a, ex);
+ nftnl_rule_add_expr(a, ex);
- nlh = nft_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
- nft_rule_nlmsg_build_payload(nlh, a);
+ nlh = nftnl_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
+ nftnl_rule_nlmsg_build_payload(nlh, a);
- if (nft_rule_nlmsg_parse(nlh, b) < 0)
+ if (nftnl_rule_nlmsg_parse(nlh, b) < 0)
print_err("parsing problems");
- iter_a = nft_rule_expr_iter_create(a);
- iter_b = nft_rule_expr_iter_create(b);
+ iter_a = nftnl_rule_expr_iter_create(a);
+ iter_b = nftnl_rule_expr_iter_create(b);
if (iter_a == NULL || iter_b == NULL)
print_err("OOM");
- rule_a = nft_rule_expr_iter_next(iter_a);
- rule_b = nft_rule_expr_iter_next(iter_b);
+ rule_a = nftnl_rule_expr_iter_next(iter_a);
+ rule_b = nftnl_rule_expr_iter_next(iter_b);
if (rule_a == NULL || rule_b == NULL)
print_err("OOM");
- cmp_nft_rule_expr(rule_a, rule_b);
+ cmp_nftnl_rule_expr(rule_a, rule_b);
- if (nft_rule_expr_iter_next(iter_a) != NULL ||
- nft_rule_expr_iter_next(iter_b) != NULL)
+ if (nftnl_rule_expr_iter_next(iter_a) != NULL ||
+ nftnl_rule_expr_iter_next(iter_b) != NULL)
print_err("More 1 expr.");
- nft_rule_expr_iter_destroy(iter_a);
- nft_rule_expr_iter_destroy(iter_b);
- nft_rule_free(a);
- nft_rule_free(b);
+ nftnl_rule_expr_iter_destroy(iter_a);
+ nftnl_rule_expr_iter_destroy(iter_b);
+ nftnl_rule_free(a);
+ nftnl_rule_free(b);
if (!test_ok)
exit(EXIT_FAILURE);
diff --git a/tests/nft-expr_masq-test.c b/tests/nft-expr_masq-test.c
index 58db7f5..0ecdcc2 100644
--- a/tests/nft-expr_masq-test.c
+++ b/tests/nft-expr_masq-test.c
@@ -25,61 +25,61 @@ static void print_err(const char *msg)
printf("\033[31mERROR:\e[0m %s\n", msg);
}
-static void cmp_nft_rule_expr(struct nft_rule_expr *rule_a,
- struct nft_rule_expr *rule_b)
+static void cmp_nftnl_rule_expr(struct nftnl_rule_expr *rule_a,
+ struct nftnl_rule_expr *rule_b)
{
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_MASQ_FLAGS) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_MASQ_FLAGS))
- print_err("Expr NFT_EXPR_MASQ_FLAGS mismatches");
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_MASQ_FLAGS) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_MASQ_FLAGS))
+ print_err("Expr NFTNL_EXPR_MASQ_FLAGS mismatches");
}
int main(int argc, char *argv[])
{
- struct nft_rule *a, *b;
- struct nft_rule_expr *ex;
+ struct nftnl_rule *a, *b;
+ struct nftnl_rule_expr *ex;
struct nlmsghdr *nlh;
char buf[4096];
- struct nft_rule_expr_iter *iter_a, *iter_b;
- struct nft_rule_expr *rule_a, *rule_b;
+ struct nftnl_rule_expr_iter *iter_a, *iter_b;
+ struct nftnl_rule_expr *rule_a, *rule_b;
- a = nft_rule_alloc();
- b = nft_rule_alloc();
+ a = nftnl_rule_alloc();
+ b = nftnl_rule_alloc();
if (a == NULL || b == NULL)
print_err("OOM");
- ex = nft_rule_expr_alloc("nat");
+ ex = nftnl_rule_expr_alloc("nat");
if (ex == NULL)
print_err("OOM");
- nft_rule_expr_set_u32(ex, NFT_EXPR_MASQ_FLAGS, 0x1234568);
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_MASQ_FLAGS, 0x1234568);
- nft_rule_add_expr(a, ex);
+ nftnl_rule_add_expr(a, ex);
- nlh = nft_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
- nft_rule_nlmsg_build_payload(nlh, a);
+ nlh = nftnl_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
+ nftnl_rule_nlmsg_build_payload(nlh, a);
- if (nft_rule_nlmsg_parse(nlh, b) < 0)
+ if (nftnl_rule_nlmsg_parse(nlh, b) < 0)
print_err("parsing problems");
- iter_a = nft_rule_expr_iter_create(a);
- iter_b = nft_rule_expr_iter_create(b);
+ iter_a = nftnl_rule_expr_iter_create(a);
+ iter_b = nftnl_rule_expr_iter_create(b);
if (iter_a == NULL || iter_b == NULL)
print_err("OOM");
- rule_a = nft_rule_expr_iter_next(iter_a);
- rule_b = nft_rule_expr_iter_next(iter_b);
+ rule_a = nftnl_rule_expr_iter_next(iter_a);
+ rule_b = nftnl_rule_expr_iter_next(iter_b);
if (rule_a == NULL || rule_b == NULL)
print_err("OOM");
- cmp_nft_rule_expr(rule_a, rule_b);
+ cmp_nftnl_rule_expr(rule_a, rule_b);
- if (nft_rule_expr_iter_next(iter_a) != NULL ||
- nft_rule_expr_iter_next(iter_b) != NULL)
+ if (nftnl_rule_expr_iter_next(iter_a) != NULL ||
+ nftnl_rule_expr_iter_next(iter_b) != NULL)
print_err("More 1 expr.");
- nft_rule_expr_iter_destroy(iter_a);
- nft_rule_expr_iter_destroy(iter_b);
- nft_rule_free(a);
- nft_rule_free(b);
+ nftnl_rule_expr_iter_destroy(iter_a);
+ nftnl_rule_expr_iter_destroy(iter_b);
+ nftnl_rule_free(a);
+ nftnl_rule_free(b);
if (!test_ok)
exit(EXIT_FAILURE);
diff --git a/tests/nft-expr_match-test.c b/tests/nft-expr_match-test.c
index 784f2b2..a3e046d 100644
--- a/tests/nft-expr_match-test.c
+++ b/tests/nft-expr_match-test.c
@@ -34,71 +34,71 @@ static void print_err2(const char *msg, uint32_t a, uint32_t b)
printf("\033[31mERROR:\e[0m %s size a: %d b: %d \n", msg, a, b);
}
-static void cmp_nft_rule_expr(struct nft_rule_expr *rule_a,
- struct nft_rule_expr *rule_b)
+static void cmp_nftnl_rule_expr(struct nftnl_rule_expr *rule_a,
+ struct nftnl_rule_expr *rule_b)
{
uint32_t lena, lenb;
- if (strcmp(nft_rule_expr_get_str(rule_a, NFT_EXPR_MT_NAME),
- nft_rule_expr_get_str(rule_b, NFT_EXPR_MT_NAME)) != 0)
- print_err("Expr NFT_EXPR_MT_NAME mismatches");
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_MT_REV) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_MT_REV))
- print_err("Expr NFT_EXPR_MT_REV mismatches");
- nft_rule_expr_get(rule_a, NFT_EXPR_MT_INFO, &lena);
- nft_rule_expr_get(rule_b, NFT_EXPR_MT_INFO, &lenb);
+ if (strcmp(nftnl_rule_expr_get_str(rule_a, NFTNL_EXPR_MT_NAME),
+ nftnl_rule_expr_get_str(rule_b, NFTNL_EXPR_MT_NAME)) != 0)
+ print_err("Expr NFTNL_EXPR_MT_NAME mismatches");
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_MT_REV) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_MT_REV))
+ print_err("Expr NFTNL_EXPR_MT_REV mismatches");
+ nftnl_rule_expr_get(rule_a, NFTNL_EXPR_MT_INFO, &lena);
+ nftnl_rule_expr_get(rule_b, NFTNL_EXPR_MT_INFO, &lenb);
if (lena != lenb)
- print_err2("Expr NFT_EXPR_MT_INFO size mismatches", lena, lenb);
+ print_err2("Expr NFTNL_EXPR_MT_INFO size mismatches", lena, lenb);
}
int main(int argc, char *argv[])
{
- struct nft_rule *a, *b;
- struct nft_rule_expr *ex;
+ struct nftnl_rule *a, *b;
+ struct nftnl_rule_expr *ex;
struct nlmsghdr *nlh;
char buf[4096];
- struct nft_rule_expr_iter *iter_a, *iter_b;
- struct nft_rule_expr *rule_a, *rule_b;
+ struct nftnl_rule_expr_iter *iter_a, *iter_b;
+ struct nftnl_rule_expr *rule_a, *rule_b;
char data[16] = "0123456789abcdef";
- a = nft_rule_alloc();
- b = nft_rule_alloc();
+ a = nftnl_rule_alloc();
+ b = nftnl_rule_alloc();
if (a == NULL || b == NULL)
print_err("OOM");
- ex = nft_rule_expr_alloc("match");
+ ex = nftnl_rule_expr_alloc("match");
if (ex == NULL)
print_err("OOM");
- nft_rule_expr_set_str(ex, NFT_EXPR_MT_NAME, "Tests");
- nft_rule_expr_set_u32(ex, NFT_EXPR_MT_REV, 0x12345678);
- nft_rule_expr_set(ex, NFT_EXPR_MT_INFO, strdup(data), sizeof(data));
- nft_rule_add_expr(a, ex);
+ nftnl_rule_expr_set_str(ex, NFTNL_EXPR_MT_NAME, "Tests");
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_MT_REV, 0x12345678);
+ nftnl_rule_expr_set(ex, NFTNL_EXPR_MT_INFO, strdup(data), sizeof(data));
+ nftnl_rule_add_expr(a, ex);
- nlh = nft_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
- nft_rule_nlmsg_build_payload(nlh, a);
+ nlh = nftnl_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
+ nftnl_rule_nlmsg_build_payload(nlh, a);
- if (nft_rule_nlmsg_parse(nlh, b) < 0)
+ if (nftnl_rule_nlmsg_parse(nlh, b) < 0)
print_err("parsing problems");
- iter_a = nft_rule_expr_iter_create(a);
- iter_b = nft_rule_expr_iter_create(b);
+ iter_a = nftnl_rule_expr_iter_create(a);
+ iter_b = nftnl_rule_expr_iter_create(b);
if (iter_a == NULL || iter_b == NULL)
print_err("OOM");
- rule_a = nft_rule_expr_iter_next(iter_a);
- rule_b = nft_rule_expr_iter_next(iter_b);
+ rule_a = nftnl_rule_expr_iter_next(iter_a);
+ rule_b = nftnl_rule_expr_iter_next(iter_b);
if (rule_a == NULL || rule_b == NULL)
print_err("OOM");
- cmp_nft_rule_expr(rule_a, rule_b);
+ cmp_nftnl_rule_expr(rule_a, rule_b);
- if (nft_rule_expr_iter_next(iter_a) != NULL ||
- nft_rule_expr_iter_next(iter_b) != NULL)
+ if (nftnl_rule_expr_iter_next(iter_a) != NULL ||
+ nftnl_rule_expr_iter_next(iter_b) != NULL)
print_err("More 1 expr.");
- nft_rule_expr_iter_destroy(iter_a);
- nft_rule_expr_iter_destroy(iter_b);
- nft_rule_free(a);
- nft_rule_free(b);
+ nftnl_rule_expr_iter_destroy(iter_a);
+ nftnl_rule_expr_iter_destroy(iter_b);
+ nftnl_rule_free(a);
+ nftnl_rule_free(b);
if (!test_ok)
exit(EXIT_FAILURE);
diff --git a/tests/nft-expr_meta-test.c b/tests/nft-expr_meta-test.c
index d9569ec..411837b 100644
--- a/tests/nft-expr_meta-test.c
+++ b/tests/nft-expr_meta-test.c
@@ -27,64 +27,64 @@ static void print_err(const char *msg)
printf("\033[31mERROR:\e[0m %s\n", msg);
}
-static void cmp_nft_rule_expr(struct nft_rule_expr *rule_a,
- struct nft_rule_expr *rule_b)
+static void cmp_nftnl_rule_expr(struct nftnl_rule_expr *rule_a,
+ struct nftnl_rule_expr *rule_b)
{
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_META_KEY) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_META_KEY))
- print_err("Expr NFT_EXPR_META_KEY mismatches");
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_META_DREG) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_META_DREG))
- print_err("Expr NFT_EXPR_META_DREG mismatches");
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_META_KEY) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_META_KEY))
+ print_err("Expr NFTNL_EXPR_META_KEY mismatches");
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_META_DREG) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_META_DREG))
+ print_err("Expr NFTNL_EXPR_META_DREG mismatches");
}
int main(int argc, char *argv[])
{
- struct nft_rule *a, *b;
- struct nft_rule_expr *ex;
+ struct nftnl_rule *a, *b;
+ struct nftnl_rule_expr *ex;
struct nlmsghdr *nlh;
char buf[4096];
- struct nft_rule_expr_iter *iter_a, *iter_b;
- struct nft_rule_expr *rule_a, *rule_b;
+ struct nftnl_rule_expr_iter *iter_a, *iter_b;
+ struct nftnl_rule_expr *rule_a, *rule_b;
- a = nft_rule_alloc();
- b = nft_rule_alloc();
+ a = nftnl_rule_alloc();
+ b = nftnl_rule_alloc();
if (a == NULL || b == NULL)
print_err("OOM");
- ex = nft_rule_expr_alloc("meta");
+ ex = nftnl_rule_expr_alloc("meta");
if (ex == NULL)
print_err("OOM");
- nft_rule_expr_set_u32(ex, NFT_EXPR_META_KEY, 0x1234568);
- nft_rule_expr_set_u32(ex, NFT_EXPR_META_DREG, 0x12345678);
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_META_KEY, 0x1234568);
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_META_DREG, 0x12345678);
- nft_rule_add_expr(a, ex);
+ nftnl_rule_add_expr(a, ex);
- nlh = nft_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
- nft_rule_nlmsg_build_payload(nlh, a);
- if (nft_rule_nlmsg_parse(nlh, b) < 0)
+ 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("parsing problems");
- iter_a = nft_rule_expr_iter_create(a);
- iter_b = nft_rule_expr_iter_create(b);
+ iter_a = nftnl_rule_expr_iter_create(a);
+ iter_b = nftnl_rule_expr_iter_create(b);
if (iter_a == NULL || iter_b == NULL)
print_err("OOM");
- rule_a = nft_rule_expr_iter_next(iter_a);
- rule_b = nft_rule_expr_iter_next(iter_b);
+ rule_a = nftnl_rule_expr_iter_next(iter_a);
+ rule_b = nftnl_rule_expr_iter_next(iter_b);
if (rule_a == NULL || rule_b == NULL)
print_err("OOM");
- cmp_nft_rule_expr(rule_a, rule_b);
+ cmp_nftnl_rule_expr(rule_a, rule_b);
- if (nft_rule_expr_iter_next(iter_a) != NULL ||
- nft_rule_expr_iter_next(iter_b) != NULL)
+ if (nftnl_rule_expr_iter_next(iter_a) != NULL ||
+ nftnl_rule_expr_iter_next(iter_b) != NULL)
print_err("More 1 expr.");
- nft_rule_expr_iter_destroy(iter_a);
- nft_rule_expr_iter_destroy(iter_b);
- nft_rule_free(a);
- nft_rule_free(b);
+ nftnl_rule_expr_iter_destroy(iter_a);
+ nftnl_rule_expr_iter_destroy(iter_b);
+ nftnl_rule_free(a);
+ nftnl_rule_free(b);
if (!test_ok)
exit(EXIT_FAILURE);
diff --git a/tests/nft-expr_nat-test.c b/tests/nft-expr_nat-test.c
index 8982b98..cef5d08 100644
--- a/tests/nft-expr_nat-test.c
+++ b/tests/nft-expr_nat-test.c
@@ -28,85 +28,85 @@ static void print_err(const char *msg)
printf("\033[31mERROR:\e[0m %s\n", msg);
}
-static void cmp_nft_rule_expr(struct nft_rule_expr *rule_a,
- struct nft_rule_expr *rule_b)
+static void cmp_nftnl_rule_expr(struct nftnl_rule_expr *rule_a,
+ struct nftnl_rule_expr *rule_b)
{
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_NAT_TYPE) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_NAT_TYPE))
- print_err("Expr NFT_EXPR_NAT_TYPE mismatches");
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_NAT_FAMILY) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_NAT_FAMILY))
- print_err("Expr NFT_EXPR_NAT_FAMILY mismatches");
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_NAT_REG_ADDR_MIN) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_NAT_REG_ADDR_MIN))
- print_err("Expr NFT_EXPR_NAT_REG_ADDR_MIN mismatches");
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_NAT_REG_ADDR_MAX) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_NAT_REG_ADDR_MAX))
- print_err("Expr NFT_EXPR_NAT_REG_ADDR_MAX mismatches");
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_NAT_REG_PROTO_MIN) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_NAT_REG_PROTO_MIN))
- print_err("Expr NFT_EXPR_NAT_REG_PROTO_MIN mismatches");
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_NAT_REG_PROTO_MAX) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_NAT_REG_PROTO_MAX))
- print_err("Expr NFT_EXPR_NAT_REG_PROTO_MAX mismatches");
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_NAT_FLAGS) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_NAT_FLAGS))
- print_err("Expr NFT_EXPR_NAT_FLAGS mismatches");
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_NAT_TYPE) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_NAT_TYPE))
+ print_err("Expr NFTNL_EXPR_NAT_TYPE mismatches");
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_NAT_FAMILY) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_NAT_FAMILY))
+ print_err("Expr NFTNL_EXPR_NAT_FAMILY mismatches");
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_NAT_REG_ADDR_MIN) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_NAT_REG_ADDR_MIN))
+ print_err("Expr NFTNL_EXPR_NAT_REG_ADDR_MIN mismatches");
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_NAT_REG_ADDR_MAX) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_NAT_REG_ADDR_MAX))
+ print_err("Expr NFTNL_EXPR_NAT_REG_ADDR_MAX mismatches");
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_NAT_REG_PROTO_MIN) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_NAT_REG_PROTO_MIN))
+ print_err("Expr NFTNL_EXPR_NAT_REG_PROTO_MIN mismatches");
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_NAT_REG_PROTO_MAX) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_NAT_REG_PROTO_MAX))
+ print_err("Expr NFTNL_EXPR_NAT_REG_PROTO_MAX mismatches");
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_NAT_FLAGS) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_NAT_FLAGS))
+ print_err("Expr NFTNL_EXPR_NAT_FLAGS mismatches");
}
int main(int argc, char *argv[])
{
- struct nft_rule *a, *b;
- struct nft_rule_expr *ex;
+ struct nftnl_rule *a, *b;
+ struct nftnl_rule_expr *ex;
struct nlmsghdr *nlh;
char buf[4096];
- struct nft_rule_expr_iter *iter_a, *iter_b;
- struct nft_rule_expr *rule_a, *rule_b;
+ struct nftnl_rule_expr_iter *iter_a, *iter_b;
+ struct nftnl_rule_expr *rule_a, *rule_b;
- a = nft_rule_alloc();
- b = nft_rule_alloc();
+ a = nftnl_rule_alloc();
+ b = nftnl_rule_alloc();
if (a == NULL || b == NULL)
print_err("OOM");
- ex = nft_rule_expr_alloc("nat");
+ ex = nftnl_rule_expr_alloc("nat");
if (ex == NULL)
print_err("OOM");
- nft_rule_expr_set_u32(ex, NFT_EXPR_NAT_TYPE, 0x1234568);
- nft_rule_expr_set_u32(ex, NFT_EXPR_NAT_FAMILY, 0x1234568);
- nft_rule_expr_set_u32(ex, NFT_EXPR_NAT_REG_ADDR_MIN, 0x1234568);
- nft_rule_expr_set_u32(ex, NFT_EXPR_NAT_REG_ADDR_MAX, 0x1234568);
- nft_rule_expr_set_u32(ex, NFT_EXPR_NAT_REG_PROTO_MIN, 0x1234568);
- nft_rule_expr_set_u32(ex, NFT_EXPR_NAT_REG_PROTO_MAX, 0x1234568);
- nft_rule_expr_set_u32(ex, NFT_EXPR_NAT_FLAGS, 0x1234568);
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_NAT_TYPE, 0x1234568);
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_NAT_FAMILY, 0x1234568);
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_NAT_REG_ADDR_MIN, 0x1234568);
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_NAT_REG_ADDR_MAX, 0x1234568);
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_NAT_REG_PROTO_MIN, 0x1234568);
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_NAT_REG_PROTO_MAX, 0x1234568);
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_NAT_FLAGS, 0x1234568);
- nft_rule_add_expr(a, ex);
+ nftnl_rule_add_expr(a, ex);
- nlh = nft_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
- nft_rule_nlmsg_build_payload(nlh, a);
+ nlh = nftnl_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
+ nftnl_rule_nlmsg_build_payload(nlh, a);
- if (nft_rule_nlmsg_parse(nlh, b) < 0)
+ if (nftnl_rule_nlmsg_parse(nlh, b) < 0)
print_err("parsing problems");
- iter_a = nft_rule_expr_iter_create(a);
- iter_b = nft_rule_expr_iter_create(b);
+ iter_a = nftnl_rule_expr_iter_create(a);
+ iter_b = nftnl_rule_expr_iter_create(b);
if (iter_a == NULL || iter_b == NULL)
print_err("OOM");
- rule_a = nft_rule_expr_iter_next(iter_a);
- rule_b = nft_rule_expr_iter_next(iter_b);
+ rule_a = nftnl_rule_expr_iter_next(iter_a);
+ rule_b = nftnl_rule_expr_iter_next(iter_b);
if (rule_a == NULL || rule_b == NULL)
print_err("OOM");
- cmp_nft_rule_expr(rule_a, rule_b);
+ cmp_nftnl_rule_expr(rule_a, rule_b);
- if (nft_rule_expr_iter_next(iter_a) != NULL ||
- nft_rule_expr_iter_next(iter_b) != NULL)
+ if (nftnl_rule_expr_iter_next(iter_a) != NULL ||
+ nftnl_rule_expr_iter_next(iter_b) != NULL)
print_err("More 1 expr.");
- nft_rule_expr_iter_destroy(iter_a);
- nft_rule_expr_iter_destroy(iter_b);
- nft_rule_free(a);
- nft_rule_free(b);
+ nftnl_rule_expr_iter_destroy(iter_a);
+ nftnl_rule_expr_iter_destroy(iter_b);
+ nftnl_rule_free(a);
+ nftnl_rule_free(b);
if (!test_ok)
exit(EXIT_FAILURE);
diff --git a/tests/nft-expr_payload-test.c b/tests/nft-expr_payload-test.c
index 3ce59f9..4911191 100644
--- a/tests/nft-expr_payload-test.c
+++ b/tests/nft-expr_payload-test.c
@@ -28,72 +28,72 @@ static void print_err(const char *msg)
printf("\033[31mERROR:\e[0m %s\n", msg);
}
-static void cmp_nft_rule_expr(struct nft_rule_expr *rule_a,
- struct nft_rule_expr *rule_b)
+static void cmp_nftnl_rule_expr(struct nftnl_rule_expr *rule_a,
+ struct nftnl_rule_expr *rule_b)
{
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_PAYLOAD_DREG) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_PAYLOAD_DREG))
- print_err("Expr NFT_EXPR_PAYLOAD_DREG mismatches");
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_PAYLOAD_BASE) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_PAYLOAD_BASE))
- print_err("Expr NFT_EXPR_PAYLOAD_BASE mismatches");
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_PAYLOAD_OFFSET) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_PAYLOAD_OFFSET))
- print_err("Expr NFT_EXPR_PAYLOAD_OFFSET mismatches");
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_PAYLOAD_LEN) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_PAYLOAD_LEN))
- print_err("Expr NFT_EXPR_PAYLOAD_LEN mismatches");
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_PAYLOAD_DREG) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_PAYLOAD_DREG))
+ print_err("Expr NFTNL_EXPR_PAYLOAD_DREG mismatches");
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_PAYLOAD_BASE) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_PAYLOAD_BASE))
+ print_err("Expr NFTNL_EXPR_PAYLOAD_BASE mismatches");
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_PAYLOAD_OFFSET) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_PAYLOAD_OFFSET))
+ print_err("Expr NFTNL_EXPR_PAYLOAD_OFFSET mismatches");
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_PAYLOAD_LEN) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_PAYLOAD_LEN))
+ print_err("Expr NFTNL_EXPR_PAYLOAD_LEN mismatches");
}
int main(int argc, char *argv[])
{
- struct nft_rule *a, *b;
- struct nft_rule_expr *ex;
+ struct nftnl_rule *a, *b;
+ struct nftnl_rule_expr *ex;
struct nlmsghdr *nlh;
char buf[4096];
- struct nft_rule_expr_iter *iter_a, *iter_b;
- struct nft_rule_expr *rule_a, *rule_b;
+ struct nftnl_rule_expr_iter *iter_a, *iter_b;
+ struct nftnl_rule_expr *rule_a, *rule_b;
- a = nft_rule_alloc();
- b = nft_rule_alloc();
+ a = nftnl_rule_alloc();
+ b = nftnl_rule_alloc();
if (a == NULL || b == NULL)
print_err("OOM");
- ex = nft_rule_expr_alloc("payload");
+ ex = nftnl_rule_expr_alloc("payload");
if (ex == NULL)
print_err("OOM");
- nft_rule_expr_set_u32(ex, NFT_EXPR_PAYLOAD_DREG, 0x1234568);
- nft_rule_expr_set_u32(ex, NFT_EXPR_PAYLOAD_BASE, 0x12345678);
- nft_rule_expr_set_u32(ex, NFT_EXPR_PAYLOAD_OFFSET, 0x12345678);
- nft_rule_expr_set_u32(ex, NFT_EXPR_PAYLOAD_LEN, 0x12345678);
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_PAYLOAD_DREG, 0x1234568);
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_PAYLOAD_BASE, 0x12345678);
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_PAYLOAD_OFFSET, 0x12345678);
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_PAYLOAD_LEN, 0x12345678);
- nft_rule_add_expr(a, ex);
+ nftnl_rule_add_expr(a, ex);
- nlh = nft_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
- nft_rule_nlmsg_build_payload(nlh, a);
- if (nft_rule_nlmsg_parse(nlh, b) < 0)
+ 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("parsing problems");
- iter_a = nft_rule_expr_iter_create(a);
- iter_b = nft_rule_expr_iter_create(b);
+ iter_a = nftnl_rule_expr_iter_create(a);
+ iter_b = nftnl_rule_expr_iter_create(b);
if (iter_a == NULL || iter_b == NULL)
print_err("OOM");
- rule_a = nft_rule_expr_iter_next(iter_a);
- rule_b = nft_rule_expr_iter_next(iter_b);
+ rule_a = nftnl_rule_expr_iter_next(iter_a);
+ rule_b = nftnl_rule_expr_iter_next(iter_b);
if (rule_a == NULL || rule_b == NULL)
print_err("OOM");
- cmp_nft_rule_expr(rule_a, rule_b);
+ cmp_nftnl_rule_expr(rule_a, rule_b);
- if (nft_rule_expr_iter_next(iter_a) != NULL ||
- nft_rule_expr_iter_next(iter_b) != NULL)
+ if (nftnl_rule_expr_iter_next(iter_a) != NULL ||
+ nftnl_rule_expr_iter_next(iter_b) != NULL)
print_err("More 1 expr.");
- nft_rule_expr_iter_destroy(iter_a);
- nft_rule_expr_iter_destroy(iter_b);
- nft_rule_free(a);
- nft_rule_free(b);
+ nftnl_rule_expr_iter_destroy(iter_a);
+ nftnl_rule_expr_iter_destroy(iter_b);
+ nftnl_rule_free(a);
+ nftnl_rule_free(b);
if (!test_ok)
exit(EXIT_FAILURE);
diff --git a/tests/nft-expr_queue-test.c b/tests/nft-expr_queue-test.c
index cfe01b6..a206146 100644
--- a/tests/nft-expr_queue-test.c
+++ b/tests/nft-expr_queue-test.c
@@ -30,66 +30,66 @@ static void print_err(const char *msg)
printf("\033[31mERROR:\e[0m %s\n", msg);
}
-static void cmp_nft_rule_expr(struct nft_rule_expr *rule_a,
- struct nft_rule_expr *rule_b)
+static void cmp_nftnl_rule_expr(struct nftnl_rule_expr *rule_a,
+ struct nftnl_rule_expr *rule_b)
{
- if (nft_rule_expr_get_u16(rule_a, NFT_EXPR_QUEUE_NUM) !=
- nft_rule_expr_get_u16(rule_b, NFT_EXPR_QUEUE_NUM))
- print_err("Expr NFT_EXPR_QUEUE_NUM mismatches");
- if (nft_rule_expr_get_u16(rule_a, NFT_EXPR_QUEUE_TOTAL) !=
- nft_rule_expr_get_u16(rule_b, NFT_EXPR_QUEUE_TOTAL))
- print_err("Expr NFT_EXPR_QUEUE_TOTAL mismatches");
+ if (nftnl_rule_expr_get_u16(rule_a, NFTNL_EXPR_QUEUE_NUM) !=
+ nftnl_rule_expr_get_u16(rule_b, NFTNL_EXPR_QUEUE_NUM))
+ print_err("Expr NFTNL_EXPR_QUEUE_NUM mismatches");
+ if (nftnl_rule_expr_get_u16(rule_a, NFTNL_EXPR_QUEUE_TOTAL) !=
+ nftnl_rule_expr_get_u16(rule_b, NFTNL_EXPR_QUEUE_TOTAL))
+ print_err("Expr NFTNL_EXPR_QUEUE_TOTAL mismatches");
}
int main(int argc, char *argv[])
{
- struct nft_rule *a, *b;
- struct nft_rule_expr *ex;
+ struct nftnl_rule *a, *b;
+ struct nftnl_rule_expr *ex;
struct nlmsghdr *nlh;
char buf[4096];
- struct nft_rule_expr_iter *iter_a, *iter_b;
- struct nft_rule_expr *rule_a, *rule_b;
+ struct nftnl_rule_expr_iter *iter_a, *iter_b;
+ struct nftnl_rule_expr *rule_a, *rule_b;
- a = nft_rule_alloc();
- b = nft_rule_alloc();
+ a = nftnl_rule_alloc();
+ b = nftnl_rule_alloc();
if (a == NULL || b == NULL)
print_err("OOM");
- ex = nft_rule_expr_alloc("queue");
+ ex = nftnl_rule_expr_alloc("queue");
if (ex == NULL)
print_err("OOM");
- nft_rule_expr_set_u16(ex, NFT_EXPR_QUEUE_NUM, 0x123);
- nft_rule_expr_set_u16(ex, NFT_EXPR_QUEUE_TOTAL, 0x2);
- nft_rule_expr_set_u16(ex, NFT_EXPR_QUEUE_FLAGS, 0x2);
+ nftnl_rule_expr_set_u16(ex, NFTNL_EXPR_QUEUE_NUM, 0x123);
+ nftnl_rule_expr_set_u16(ex, NFTNL_EXPR_QUEUE_TOTAL, 0x2);
+ nftnl_rule_expr_set_u16(ex, NFTNL_EXPR_QUEUE_FLAGS, 0x2);
- nft_rule_add_expr(a, ex);
+ nftnl_rule_add_expr(a, ex);
- nlh = nft_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
- nft_rule_nlmsg_build_payload(nlh, a);
+ nlh = nftnl_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
+ nftnl_rule_nlmsg_build_payload(nlh, a);
- if (nft_rule_nlmsg_parse(nlh, b) < 0)
+ if (nftnl_rule_nlmsg_parse(nlh, b) < 0)
print_err("parsing problems");
- iter_a = nft_rule_expr_iter_create(a);
- iter_b = nft_rule_expr_iter_create(b);
+ iter_a = nftnl_rule_expr_iter_create(a);
+ iter_b = nftnl_rule_expr_iter_create(b);
if (iter_a == NULL || iter_b == NULL)
print_err("OOM");
- rule_a = nft_rule_expr_iter_next(iter_a);
- rule_b = nft_rule_expr_iter_next(iter_b);
+ rule_a = nftnl_rule_expr_iter_next(iter_a);
+ rule_b = nftnl_rule_expr_iter_next(iter_b);
if (rule_a == NULL || rule_b == NULL)
print_err("OOM");
- cmp_nft_rule_expr(rule_a, rule_b);
+ cmp_nftnl_rule_expr(rule_a, rule_b);
- if (nft_rule_expr_iter_next(iter_a) != NULL ||
- nft_rule_expr_iter_next(iter_b) != NULL)
+ if (nftnl_rule_expr_iter_next(iter_a) != NULL ||
+ nftnl_rule_expr_iter_next(iter_b) != NULL)
print_err("More 1 expr.");
- nft_rule_expr_iter_destroy(iter_a);
- nft_rule_expr_iter_destroy(iter_b);
- nft_rule_free(a);
- nft_rule_free(b);
+ nftnl_rule_expr_iter_destroy(iter_a);
+ nftnl_rule_expr_iter_destroy(iter_b);
+ nftnl_rule_free(a);
+ nftnl_rule_free(b);
if (!test_ok)
exit(EXIT_FAILURE);
diff --git a/tests/nft-expr_redir-test.c b/tests/nft-expr_redir-test.c
index 4d41c61..a772c8f 100644
--- a/tests/nft-expr_redir-test.c
+++ b/tests/nft-expr_redir-test.c
@@ -25,69 +25,69 @@ static void print_err(const char *msg)
printf("\033[31mERROR:\e[0m %s\n", msg);
}
-static void cmp_nft_rule_expr(struct nft_rule_expr *rule_a,
- struct nft_rule_expr *rule_b)
+static void cmp_nftnl_rule_expr(struct nftnl_rule_expr *rule_a,
+ struct nftnl_rule_expr *rule_b)
{
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_REDIR_REG_PROTO_MIN) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_REDIR_REG_PROTO_MIN))
- print_err("Expr NFT_EXPR_REDIR_REG_PROTO_MIN mismatches");
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_REDIR_REG_PROTO_MAX) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_REDIR_REG_PROTO_MAX))
- print_err("Expr NFT_EXPR_REDIR_REG_PROTO_MAX mismatches");
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_REDIR_FLAGS) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_REDIR_FLAGS))
- print_err("Expr NFT_EXPR_REDIR_FLAGS mismatches");
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_REDIR_REG_PROTO_MIN) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_REDIR_REG_PROTO_MIN))
+ print_err("Expr NFTNL_EXPR_REDIR_REG_PROTO_MIN mismatches");
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_REDIR_REG_PROTO_MAX) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_REDIR_REG_PROTO_MAX))
+ print_err("Expr NFTNL_EXPR_REDIR_REG_PROTO_MAX mismatches");
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_REDIR_FLAGS) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_REDIR_FLAGS))
+ print_err("Expr NFTNL_EXPR_REDIR_FLAGS mismatches");
}
int main(int argc, char *argv[])
{
- struct nft_rule *a, *b;
- struct nft_rule_expr *ex;
+ struct nftnl_rule *a, *b;
+ struct nftnl_rule_expr *ex;
struct nlmsghdr *nlh;
char buf[4096];
- struct nft_rule_expr_iter *iter_a, *iter_b;
- struct nft_rule_expr *rule_a, *rule_b;
+ struct nftnl_rule_expr_iter *iter_a, *iter_b;
+ struct nftnl_rule_expr *rule_a, *rule_b;
- a = nft_rule_alloc();
- b = nft_rule_alloc();
+ a = nftnl_rule_alloc();
+ b = nftnl_rule_alloc();
if (a == NULL || b == NULL)
print_err("OOM");
- ex = nft_rule_expr_alloc("redir");
+ ex = nftnl_rule_expr_alloc("redir");
if (ex == NULL)
print_err("OOM");
- nft_rule_expr_set_u32(ex, NFT_EXPR_REDIR_REG_PROTO_MIN, 0x1234568);
- nft_rule_expr_set_u32(ex, NFT_EXPR_REDIR_REG_PROTO_MAX, 0x23456);
- nft_rule_expr_set_u32(ex, NFT_EXPR_REDIR_FLAGS, 0x1234568);
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_REDIR_REG_PROTO_MIN, 0x1234568);
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_REDIR_REG_PROTO_MAX, 0x23456);
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_REDIR_FLAGS, 0x1234568);
- nft_rule_add_expr(a, ex);
+ nftnl_rule_add_expr(a, ex);
- nlh = nft_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
- nft_rule_nlmsg_build_payload(nlh, a);
+ nlh = nftnl_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
+ nftnl_rule_nlmsg_build_payload(nlh, a);
- if (nft_rule_nlmsg_parse(nlh, b) < 0)
+ if (nftnl_rule_nlmsg_parse(nlh, b) < 0)
print_err("Parsing problems");
- iter_a = nft_rule_expr_iter_create(a);
- iter_b = nft_rule_expr_iter_create(b);
+ iter_a = nftnl_rule_expr_iter_create(a);
+ iter_b = nftnl_rule_expr_iter_create(b);
if (iter_a == NULL || iter_b == NULL)
print_err("OOM");
- rule_a = nft_rule_expr_iter_next(iter_a);
- rule_b = nft_rule_expr_iter_next(iter_b);
+ rule_a = nftnl_rule_expr_iter_next(iter_a);
+ rule_b = nftnl_rule_expr_iter_next(iter_b);
if (rule_a == NULL || rule_b == NULL)
print_err("OOM");
- cmp_nft_rule_expr(rule_a, rule_b);
+ cmp_nftnl_rule_expr(rule_a, rule_b);
- if (nft_rule_expr_iter_next(iter_a) != NULL ||
- nft_rule_expr_iter_next(iter_b) != NULL)
+ if (nftnl_rule_expr_iter_next(iter_a) != NULL ||
+ nftnl_rule_expr_iter_next(iter_b) != NULL)
print_err("More than 1 expr.");
- nft_rule_expr_iter_destroy(iter_a);
- nft_rule_expr_iter_destroy(iter_b);
- nft_rule_free(a);
- nft_rule_free(b);
+ nftnl_rule_expr_iter_destroy(iter_a);
+ nftnl_rule_expr_iter_destroy(iter_b);
+ nftnl_rule_free(a);
+ nftnl_rule_free(b);
if (!test_ok)
exit(EXIT_FAILURE);
diff --git a/tests/nft-expr_reject-test.c b/tests/nft-expr_reject-test.c
index 0678081..657b32d 100644
--- a/tests/nft-expr_reject-test.c
+++ b/tests/nft-expr_reject-test.c
@@ -28,65 +28,65 @@ static void print_err(const char *msg)
printf("\033[31mERROR:\e[0m %s\n", msg);
}
-static void cmp_nft_rule_expr(struct nft_rule_expr *rule_a,
- struct nft_rule_expr *rule_b)
+static void cmp_nftnl_rule_expr(struct nftnl_rule_expr *rule_a,
+ struct nftnl_rule_expr *rule_b)
{
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_REJECT_TYPE) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_REJECT_TYPE))
- print_err("Expr NFT_EXPR_REJECT_TYPE mismatches");
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_REJECT_CODE) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_REJECT_CODE))
- print_err("Expr NFT_EXPR_REJECT_CODE mismatches");
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_REJECT_TYPE) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_REJECT_TYPE))
+ print_err("Expr NFTNL_EXPR_REJECT_TYPE mismatches");
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_REJECT_CODE) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_REJECT_CODE))
+ print_err("Expr NFTNL_EXPR_REJECT_CODE mismatches");
}
int main(int argc, char *argv[])
{
- struct nft_rule *a, *b;
- struct nft_rule_expr *ex;
+ struct nftnl_rule *a, *b;
+ struct nftnl_rule_expr *ex;
struct nlmsghdr *nlh;
char buf[4096];
- struct nft_rule_expr_iter *iter_a, *iter_b;
- struct nft_rule_expr *rule_a, *rule_b;
+ struct nftnl_rule_expr_iter *iter_a, *iter_b;
+ struct nftnl_rule_expr *rule_a, *rule_b;
- a = nft_rule_alloc();
- b = nft_rule_alloc();
+ a = nftnl_rule_alloc();
+ b = nftnl_rule_alloc();
if (a == NULL || b == NULL)
print_err("OOM");
- ex = nft_rule_expr_alloc("reject");
+ ex = nftnl_rule_expr_alloc("reject");
if (ex == NULL)
print_err("OOM");
- nft_rule_expr_set_u32(ex, NFT_EXPR_REJECT_TYPE, 0x1234568);
- nft_rule_expr_set_u32(ex, NFT_EXPR_REJECT_CODE, 0x1234568);
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_REJECT_TYPE, 0x1234568);
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_REJECT_CODE, 0x1234568);
- nft_rule_add_expr(a, ex);
+ nftnl_rule_add_expr(a, ex);
- nlh = nft_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
- nft_rule_nlmsg_build_payload(nlh, a);
+ nlh = nftnl_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
+ nftnl_rule_nlmsg_build_payload(nlh, a);
- if (nft_rule_nlmsg_parse(nlh, b) < 0)
+ if (nftnl_rule_nlmsg_parse(nlh, b) < 0)
print_err("parsing problems");
- iter_a = nft_rule_expr_iter_create(a);
- iter_b = nft_rule_expr_iter_create(b);
+ iter_a = nftnl_rule_expr_iter_create(a);
+ iter_b = nftnl_rule_expr_iter_create(b);
if (iter_a == NULL || iter_b == NULL)
print_err("OOM");
- rule_a = nft_rule_expr_iter_next(iter_a);
- rule_b = nft_rule_expr_iter_next(iter_b);
+ rule_a = nftnl_rule_expr_iter_next(iter_a);
+ rule_b = nftnl_rule_expr_iter_next(iter_b);
if (rule_a == NULL || rule_b == NULL)
print_err("OOM");
- cmp_nft_rule_expr(rule_a, rule_b);
+ cmp_nftnl_rule_expr(rule_a, rule_b);
- if (nft_rule_expr_iter_next(iter_a) != NULL ||
- nft_rule_expr_iter_next(iter_b) != NULL)
+ if (nftnl_rule_expr_iter_next(iter_a) != NULL ||
+ nftnl_rule_expr_iter_next(iter_b) != NULL)
print_err("More 1 expr.");
- nft_rule_expr_iter_destroy(iter_a);
- nft_rule_expr_iter_destroy(iter_b);
- nft_rule_free(a);
- nft_rule_free(b);
+ nftnl_rule_expr_iter_destroy(iter_a);
+ nftnl_rule_expr_iter_destroy(iter_b);
+ nftnl_rule_free(a);
+ nftnl_rule_free(b);
if (!test_ok)
exit(EXIT_FAILURE);
diff --git a/tests/nft-expr_target-test.c b/tests/nft-expr_target-test.c
index 838b3fd..8b09357 100644
--- a/tests/nft-expr_target-test.c
+++ b/tests/nft-expr_target-test.c
@@ -33,73 +33,73 @@ static void print_err2(const char *msg, uint32_t a, uint32_t b)
printf("\033[31mERROR:\e[0m %s size a: %d b: %d \n",msg, a, b);
}
-static void cmp_nft_rule_expr(struct nft_rule_expr *rule_a,
- struct nft_rule_expr *rule_b)
+static void cmp_nftnl_rule_expr(struct nftnl_rule_expr *rule_a,
+ struct nftnl_rule_expr *rule_b)
{
uint32_t lena, lenb;
- if (strcmp(nft_rule_expr_get_str(rule_a, NFT_EXPR_TG_NAME),
- nft_rule_expr_get_str(rule_b, NFT_EXPR_TG_NAME)) != 0)
- print_err("Expr NFT_EXPR_TG_NAME mismatches");
- if (nft_rule_expr_get_u32(rule_a, NFT_EXPR_TG_REV) !=
- nft_rule_expr_get_u32(rule_b, NFT_EXPR_TG_REV))
- print_err("Expr NFT_EXPR_TG_REV mismatches");
- nft_rule_expr_get(rule_a, NFT_EXPR_TG_INFO, &lena);
- nft_rule_expr_get(rule_b, NFT_EXPR_TG_INFO, &lenb);
+ if (strcmp(nftnl_rule_expr_get_str(rule_a, NFTNL_EXPR_TG_NAME),
+ nftnl_rule_expr_get_str(rule_b, NFTNL_EXPR_TG_NAME)) != 0)
+ print_err("Expr NFTNL_EXPR_TG_NAME mismatches");
+ if (nftnl_rule_expr_get_u32(rule_a, NFTNL_EXPR_TG_REV) !=
+ nftnl_rule_expr_get_u32(rule_b, NFTNL_EXPR_TG_REV))
+ print_err("Expr NFTNL_EXPR_TG_REV mismatches");
+ nftnl_rule_expr_get(rule_a, NFTNL_EXPR_TG_INFO, &lena);
+ nftnl_rule_expr_get(rule_b, NFTNL_EXPR_TG_INFO, &lenb);
if (lena != lenb)
- print_err2("Expr NFT_EXPR_TG_INFO size mismatches", lena, lenb);
+ print_err2("Expr NFTNL_EXPR_TG_INFO size mismatches", lena, lenb);
}
int main(int argc, char *argv[])
{
- struct nft_rule *a, *b;
- struct nft_rule_expr *ex;
+ struct nftnl_rule *a, *b;
+ struct nftnl_rule_expr *ex;
struct nlmsghdr *nlh;
char buf[4096];
- struct nft_rule_expr_iter *iter_a, *iter_b;
- struct nft_rule_expr *rule_a, *rule_b;
+ struct nftnl_rule_expr_iter *iter_a, *iter_b;
+ struct nftnl_rule_expr *rule_a, *rule_b;
char data[16] = "0123456789abcdef";
- a = nft_rule_alloc();
- b = nft_rule_alloc();
+ a = nftnl_rule_alloc();
+ b = nftnl_rule_alloc();
if (a == NULL || b == NULL)
print_err("OOM");
- ex = nft_rule_expr_alloc("target");
+ ex = nftnl_rule_expr_alloc("target");
if (ex == NULL)
print_err("OOM");
- nft_rule_expr_set(ex, NFT_EXPR_TG_NAME, "test", strlen("test"));
- nft_rule_expr_set_u32(ex, NFT_EXPR_TG_REV, 0x12345678);
- nft_rule_expr_set(ex, NFT_EXPR_TG_INFO, strdup(data), sizeof(data));
- nft_rule_add_expr(a, ex);
+ nftnl_rule_expr_set(ex, NFTNL_EXPR_TG_NAME, "test", strlen("test"));
+ nftnl_rule_expr_set_u32(ex, NFTNL_EXPR_TG_REV, 0x12345678);
+ nftnl_rule_expr_set(ex, NFTNL_EXPR_TG_INFO, strdup(data), sizeof(data));
+ nftnl_rule_add_expr(a, ex);
- nlh = nft_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
- nft_rule_nlmsg_build_payload(nlh, a);
+ nlh = nftnl_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
+ nftnl_rule_nlmsg_build_payload(nlh, a);
- if (nft_rule_nlmsg_parse(nlh, b) < 0)
+ if (nftnl_rule_nlmsg_parse(nlh, b) < 0)
print_err("parsing problems");
- iter_a = nft_rule_expr_iter_create(a);
- iter_b = nft_rule_expr_iter_create(b);
+ iter_a = nftnl_rule_expr_iter_create(a);
+ iter_b = nftnl_rule_expr_iter_create(b);
if (iter_a == NULL || iter_b == NULL)
print_err("OOM");
- rule_a = nft_rule_expr_iter_next(iter_a);
- rule_b = nft_rule_expr_iter_next(iter_b);
+ rule_a = nftnl_rule_expr_iter_next(iter_a);
+ rule_b = nftnl_rule_expr_iter_next(iter_b);
if (rule_a == NULL || rule_b == NULL)
print_err("OOM");
- cmp_nft_rule_expr(rule_a, rule_b);
+ cmp_nftnl_rule_expr(rule_a, rule_b);
- if (nft_rule_expr_iter_next(iter_a) != NULL ||
- nft_rule_expr_iter_next(iter_b) != NULL)
+ if (nftnl_rule_expr_iter_next(iter_a) != NULL ||
+ nftnl_rule_expr_iter_next(iter_b) != NULL)
print_err("More 1 expr.");
- nft_rule_expr_iter_destroy(iter_a);
- nft_rule_expr_iter_destroy(iter_b);
- nft_rule_free(a);
- nft_rule_free(b);
+ nftnl_rule_expr_iter_destroy(iter_a);
+ nftnl_rule_expr_iter_destroy(iter_b);
+ nftnl_rule_free(a);
+ nftnl_rule_free(b);
if (!test_ok)
exit(EXIT_FAILURE);
diff --git a/tests/nft-parsing-test.c b/tests/nft-parsing-test.c
index 76e89ac..ce3dc4d 100644
--- a/tests/nft-parsing-test.c
+++ b/tests/nft-parsing-test.c
@@ -59,7 +59,7 @@ static void print_detail_error(char *a, char *b)
}
}
-static int compare_test(uint32_t type, struct nft_ruleset *rs,
+static int compare_test(uint32_t type, struct nftnl_ruleset *rs,
const char *filename, FILE *fp)
{
char orig[4096];
@@ -67,12 +67,12 @@ static int compare_test(uint32_t type, struct nft_ruleset *rs,
switch (type) {
case TEST_XML_RULESET:
- nft_ruleset_snprintf(out, sizeof(out), rs,
- NFT_OUTPUT_XML, NFT_OF_EVENT_NEW);
+ nftnl_ruleset_snprintf(out, sizeof(out), rs,
+ NFTNL_OUTPUT_XML, NFTNL_OF_EVENT_NEW);
break;
case TEST_JSON_RULESET:
- nft_ruleset_snprintf(out, sizeof(out), rs,
- NFT_OUTPUT_JSON, NFT_OF_EVENT_NEW);
+ nftnl_ruleset_snprintf(out, sizeof(out), rs,
+ NFTNL_OUTPUT_JSON, NFTNL_OF_EVENT_NEW);
break;
default:
errno = EINVAL;
@@ -107,10 +107,10 @@ static int compare_test(uint32_t type, struct nft_ruleset *rs,
return -1;
}
-static int test_json(const char *filename, struct nft_parse_err *err)
+static int test_json(const char *filename, struct nftnl_parse_err *err)
{
int ret = -1;
- struct nft_ruleset *rs;
+ struct nftnl_ruleset *rs;
FILE *fp;
fp = fopen(filename, "r");
@@ -120,18 +120,18 @@ static int test_json(const char *filename, struct nft_parse_err *err)
return -1;
}
- rs = nft_ruleset_alloc();
+ rs = nftnl_ruleset_alloc();
if (rs == NULL) {
- perror("nft_ruleset_alloc");
+ perror("nftnl_ruleset_alloc");
return -1;
}
- if (nft_ruleset_parse_file(rs, NFT_PARSE_JSON, fp, err) == 0)
+ if (nftnl_ruleset_parse_file(rs, NFTNL_PARSE_JSON, fp, err) == 0)
ret = compare_test(TEST_JSON_RULESET, rs, filename, fp);
else
goto failparsing;
- nft_ruleset_free(rs);
+ nftnl_ruleset_free(rs);
fclose(fp);
return ret;
@@ -140,14 +140,14 @@ failparsing:
fclose(fp);
printf("parsing %s: ", filename);
printf("\033[31mFAILED\e[0m (%s)\n", strerror(errno));
- nft_parse_perror("Reason", err);
+ nftnl_parse_perror("Reason", err);
return -1;
}
-static int test_xml(const char *filename, struct nft_parse_err *err)
+static int test_xml(const char *filename, struct nftnl_parse_err *err)
{
int ret = -1;
- struct nft_ruleset *rs;
+ struct nftnl_ruleset *rs;
FILE *fp;
fp = fopen(filename, "r");
@@ -157,18 +157,18 @@ static int test_xml(const char *filename, struct nft_parse_err *err)
return -1;
}
- rs = nft_ruleset_alloc();
+ rs = nftnl_ruleset_alloc();
if (rs == NULL) {
- perror("nft_ruleset_alloc");
+ perror("nftnl_ruleset_alloc");
return -1;
}
- if (nft_ruleset_parse_file(rs, NFT_PARSE_XML, fp, err) == 0)
+ if (nftnl_ruleset_parse_file(rs, NFTNL_PARSE_XML, fp, err) == 0)
ret = compare_test(TEST_XML_RULESET, rs, filename, fp);
else
goto failparsing;
- nft_ruleset_free(rs);
+ nftnl_ruleset_free(rs);
fclose(fp);
return ret;
@@ -177,7 +177,7 @@ failparsing:
fclose(fp);
printf("parsing %s: ", filename);
printf("\033[31mFAILED\e[0m (%s)\n", strerror(errno));
- nft_parse_perror("Reason", err);
+ nftnl_parse_perror("Reason", err);
return -1;
}
@@ -187,7 +187,7 @@ static int execute_test(const char *dir_name)
struct dirent *dent;
char path[PATH_MAX];
int ret = 0, exit_code = 0;
- struct nft_parse_err *err;
+ struct nftnl_parse_err *err;
d = opendir(dir_name);
if (d == NULL) {
@@ -195,7 +195,7 @@ static int execute_test(const char *dir_name)
exit(EXIT_FAILURE);
}
- err = nft_parse_err_alloc();
+ err = nftnl_parse_err_alloc();
if (err == NULL) {
perror("error");
exit(EXIT_FAILURE);
@@ -233,7 +233,7 @@ static int execute_test(const char *dir_name)
}
closedir(d);
- nft_parse_err_free(err);
+ nftnl_parse_err_free(err);
if (exit_code != 0)
exit(EXIT_FAILURE);
@@ -245,9 +245,9 @@ static int execute_test_file(const char *filename)
{
char path[PATH_MAX];
int ret = 0;
- struct nft_parse_err *err;
+ struct nftnl_parse_err *err;
- err = nft_parse_err_alloc();
+ err = nftnl_parse_err_alloc();
if (err == NULL) {
perror("error");
exit(EXIT_FAILURE);
@@ -264,7 +264,7 @@ static int execute_test_file(const char *filename)
printf("\033[32mOK\e[0m\n");
}
}
- nft_parse_err_free(err);
+ nftnl_parse_err_free(err);
exit(EXIT_FAILURE);
}
if (strcmp(&filename[len-5], ".json") == 0) {
@@ -275,11 +275,11 @@ static int execute_test_file(const char *filename)
printf("\033[32mOK\e[0m\n");
}
}
- nft_parse_err_free(err);
+ nftnl_parse_err_free(err);
exit(EXIT_FAILURE);
}
- nft_parse_err_free(err);
+ nftnl_parse_err_free(err);
return 0;
}
diff --git a/tests/nft-rule-test.c b/tests/nft-rule-test.c
index 80338d0..9365444 100644
--- a/tests/nft-rule-test.c
+++ b/tests/nft-rule-test.c
@@ -24,60 +24,60 @@ static void print_err(const char *msg)
printf("\033[31mERROR:\e[0m %s\n", msg);
}
-static void cmp_nft_rule(struct nft_rule *a, struct nft_rule *b)
+static void cmp_nftnl_rule(struct nftnl_rule *a, struct nftnl_rule *b)
{
- if (nft_rule_attr_get_u32(a, NFT_RULE_ATTR_FAMILY) !=
- nft_rule_attr_get_u32(b, NFT_RULE_ATTR_FAMILY))
+ if (nftnl_rule_attr_get_u32(a, NFTNL_RULE_ATTR_FAMILY) !=
+ nftnl_rule_attr_get_u32(b, NFTNL_RULE_ATTR_FAMILY))
print_err("Rule family mismatches");
- if (strcmp(nft_rule_attr_get_str(a, NFT_RULE_ATTR_TABLE),
- nft_rule_attr_get_str(b, NFT_RULE_ATTR_TABLE)) != 0)
+ if (strcmp(nftnl_rule_attr_get_str(a, NFTNL_RULE_ATTR_TABLE),
+ nftnl_rule_attr_get_str(b, NFTNL_RULE_ATTR_TABLE)) != 0)
print_err("Rule table mismatches");
- if (strcmp(nft_rule_attr_get_str(a, NFT_RULE_ATTR_CHAIN),
- nft_rule_attr_get_str(b, NFT_RULE_ATTR_CHAIN)) != 0)
+ if (strcmp(nftnl_rule_attr_get_str(a, NFTNL_RULE_ATTR_CHAIN),
+ nftnl_rule_attr_get_str(b, NFTNL_RULE_ATTR_CHAIN)) != 0)
print_err("Rule table mismatches");
- if (nft_rule_attr_get_u64(a, NFT_RULE_ATTR_HANDLE) !=
- nft_rule_attr_get_u64(b, NFT_RULE_ATTR_HANDLE))
+ if (nftnl_rule_attr_get_u64(a, NFTNL_RULE_ATTR_HANDLE) !=
+ nftnl_rule_attr_get_u64(b, NFTNL_RULE_ATTR_HANDLE))
print_err("Rule handle mismatches");
- if (nft_rule_attr_get_u32(a, NFT_RULE_ATTR_COMPAT_PROTO) !=
- nft_rule_attr_get_u32(b, NFT_RULE_ATTR_COMPAT_PROTO))
+ if (nftnl_rule_attr_get_u32(a, NFTNL_RULE_ATTR_COMPAT_PROTO) !=
+ nftnl_rule_attr_get_u32(b, NFTNL_RULE_ATTR_COMPAT_PROTO))
print_err("Rule compat_proto mismatches");
- if (nft_rule_attr_get_u32(a, NFT_RULE_ATTR_COMPAT_FLAGS) !=
- nft_rule_attr_get_u32(b, NFT_RULE_ATTR_COMPAT_FLAGS))
+ if (nftnl_rule_attr_get_u32(a, NFTNL_RULE_ATTR_COMPAT_FLAGS) !=
+ nftnl_rule_attr_get_u32(b, NFTNL_RULE_ATTR_COMPAT_FLAGS))
print_err("Rule compat_flags mismatches");
- if (nft_rule_attr_get_u64(a, NFT_RULE_ATTR_POSITION) !=
- nft_rule_attr_get_u64(b, NFT_RULE_ATTR_POSITION))
+ if (nftnl_rule_attr_get_u64(a, NFTNL_RULE_ATTR_POSITION) !=
+ nftnl_rule_attr_get_u64(b, NFTNL_RULE_ATTR_POSITION))
print_err("Rule compat_position mismatches");
}
int main(int argc, char *argv[])
{
- struct nft_rule *a, *b;
+ struct nftnl_rule *a, *b;
char buf[4096];
struct nlmsghdr *nlh;
- a = nft_rule_alloc();
- b = nft_rule_alloc();
+ a = nftnl_rule_alloc();
+ b = nftnl_rule_alloc();
if (a == NULL || b == NULL)
print_err("OOM");
- nft_rule_attr_set_u32(a, NFT_RULE_ATTR_FAMILY, AF_INET);
- nft_rule_attr_set_str(a, NFT_RULE_ATTR_TABLE, "table");
- nft_rule_attr_set_str(a, NFT_RULE_ATTR_CHAIN, "chain");
- nft_rule_attr_set_u64(a, NFT_RULE_ATTR_HANDLE, 0x1234567812345678);
- nft_rule_attr_set_u32(a, NFT_RULE_ATTR_COMPAT_PROTO, 0x12345678);
- nft_rule_attr_set_u32(a, NFT_RULE_ATTR_COMPAT_FLAGS, 0x12345678);
- nft_rule_attr_set_u64(a, NFT_RULE_ATTR_POSITION, 0x1234567812345678);
+ nftnl_rule_attr_set_u32(a, NFTNL_RULE_ATTR_FAMILY, AF_INET);
+ nftnl_rule_attr_set_str(a, NFTNL_RULE_ATTR_TABLE, "table");
+ nftnl_rule_attr_set_str(a, NFTNL_RULE_ATTR_CHAIN, "chain");
+ nftnl_rule_attr_set_u64(a, NFTNL_RULE_ATTR_HANDLE, 0x1234567812345678);
+ nftnl_rule_attr_set_u32(a, NFTNL_RULE_ATTR_COMPAT_PROTO, 0x12345678);
+ nftnl_rule_attr_set_u32(a, NFTNL_RULE_ATTR_COMPAT_FLAGS, 0x12345678);
+ nftnl_rule_attr_set_u64(a, NFTNL_RULE_ATTR_POSITION, 0x1234567812345678);
- nlh = nft_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
- nft_rule_nlmsg_build_payload(nlh, a);
+ nlh = nftnl_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
+ nftnl_rule_nlmsg_build_payload(nlh, a);
- if (nft_rule_nlmsg_parse(nlh, b) < 0)
+ if (nftnl_rule_nlmsg_parse(nlh, b) < 0)
print_err("parsing problems");
- cmp_nft_rule(a,b);
+ cmp_nftnl_rule(a,b);
- nft_rule_free(a);
- nft_rule_free(b);
+ nftnl_rule_free(a);
+ nftnl_rule_free(b);
if (!test_ok)
exit(EXIT_FAILURE);
diff --git a/tests/nft-set-test.c b/tests/nft-set-test.c
index 141dfd3..222b7f2 100644
--- a/tests/nft-set-test.c
+++ b/tests/nft-set-test.c
@@ -24,61 +24,61 @@ static void print_err(const char *msg)
printf("\033[31mERROR:\e[0m %s\n", msg);
}
-static void cmp_nft_set(struct nft_set *a, struct nft_set *b)
+static void cmp_nftnl_set(struct nftnl_set *a, struct nftnl_set *b)
{
- if (strcmp(nft_set_attr_get_str(a, NFT_SET_ATTR_TABLE),
- nft_set_attr_get_str(b, NFT_SET_ATTR_TABLE)) != 0)
+ if (strcmp(nftnl_set_attr_get_str(a, NFTNL_SET_ATTR_TABLE),
+ nftnl_set_attr_get_str(b, NFTNL_SET_ATTR_TABLE)) != 0)
print_err("Set table mismatches");
- if (strcmp(nft_set_attr_get_str(a, NFT_SET_ATTR_NAME),
- nft_set_attr_get_str(b, NFT_SET_ATTR_NAME)) != 0)
+ if (strcmp(nftnl_set_attr_get_str(a, NFTNL_SET_ATTR_NAME),
+ nftnl_set_attr_get_str(b, NFTNL_SET_ATTR_NAME)) != 0)
print_err("Set name mismatches");
- if (nft_set_attr_get_u32(a, NFT_SET_ATTR_FLAGS) !=
- nft_set_attr_get_u32(b, NFT_SET_ATTR_FLAGS))
+ if (nftnl_set_attr_get_u32(a, NFTNL_SET_ATTR_FLAGS) !=
+ nftnl_set_attr_get_u32(b, NFTNL_SET_ATTR_FLAGS))
print_err("Set flags mismatches");
- if (nft_set_attr_get_u32(a, NFT_SET_ATTR_KEY_TYPE) !=
- nft_set_attr_get_u32(b, NFT_SET_ATTR_KEY_TYPE))
+ if (nftnl_set_attr_get_u32(a, NFTNL_SET_ATTR_KEY_TYPE) !=
+ nftnl_set_attr_get_u32(b, NFTNL_SET_ATTR_KEY_TYPE))
print_err("Set key-type mismatches");
- if (nft_set_attr_get_u32(a, NFT_SET_ATTR_KEY_LEN) !=
- nft_set_attr_get_u32(b, NFT_SET_ATTR_KEY_LEN))
+ if (nftnl_set_attr_get_u32(a, NFTNL_SET_ATTR_KEY_LEN) !=
+ nftnl_set_attr_get_u32(b, NFTNL_SET_ATTR_KEY_LEN))
print_err("Set key-len mismatches");
- if (nft_set_attr_get_u32(a, NFT_SET_ATTR_DATA_TYPE) !=
- nft_set_attr_get_u32(b, NFT_SET_ATTR_DATA_TYPE))
+ if (nftnl_set_attr_get_u32(a, NFTNL_SET_ATTR_DATA_TYPE) !=
+ nftnl_set_attr_get_u32(b, NFTNL_SET_ATTR_DATA_TYPE))
print_err("Set data-type mismatches");
- if (nft_set_attr_get_u32(a, NFT_SET_ATTR_DATA_LEN) !=
- nft_set_attr_get_u32(b, NFT_SET_ATTR_DATA_LEN))
+ if (nftnl_set_attr_get_u32(a, NFTNL_SET_ATTR_DATA_LEN) !=
+ nftnl_set_attr_get_u32(b, NFTNL_SET_ATTR_DATA_LEN))
print_err("Set data-len mismatches");
}
int main(int argc, char *argv[])
{
- struct nft_set *a, *b = NULL;
+ struct nftnl_set *a, *b = NULL;
char buf[4096];
struct nlmsghdr *nlh;
- a = nft_set_alloc();
- b = nft_set_alloc();
+ a = nftnl_set_alloc();
+ b = nftnl_set_alloc();
if (a == NULL || b == NULL)
print_err("OOM");
- nft_set_attr_set_str(a, NFT_SET_ATTR_TABLE, "test-table");
- nft_set_attr_set_str(a, NFT_SET_ATTR_NAME, "test-name");
- nft_set_attr_set_u32(a, NFT_SET_ATTR_FLAGS, 0x12345678);
- nft_set_attr_set_u32(a, NFT_SET_ATTR_KEY_TYPE, 0x12345678);
- nft_set_attr_set_u32(a, NFT_SET_ATTR_KEY_LEN, 0x12345678);
- nft_set_attr_set_u32(a, NFT_SET_ATTR_DATA_TYPE, 0x12345678);
- nft_set_attr_set_u32(a, NFT_SET_ATTR_DATA_LEN, 0x12345678);
- nft_set_attr_set_u32(a, NFT_SET_ATTR_FAMILY, 0x12345678);
+ nftnl_set_attr_set_str(a, NFTNL_SET_ATTR_TABLE, "test-table");
+ nftnl_set_attr_set_str(a, NFTNL_SET_ATTR_NAME, "test-name");
+ nftnl_set_attr_set_u32(a, NFTNL_SET_ATTR_FLAGS, 0x12345678);
+ nftnl_set_attr_set_u32(a, NFTNL_SET_ATTR_KEY_TYPE, 0x12345678);
+ nftnl_set_attr_set_u32(a, NFTNL_SET_ATTR_KEY_LEN, 0x12345678);
+ nftnl_set_attr_set_u32(a, NFTNL_SET_ATTR_DATA_TYPE, 0x12345678);
+ nftnl_set_attr_set_u32(a, NFTNL_SET_ATTR_DATA_LEN, 0x12345678);
+ nftnl_set_attr_set_u32(a, NFTNL_SET_ATTR_FAMILY, 0x12345678);
/* cmd extracted from include/linux/netfilter/nf_tables.h */
- nlh = nft_set_nlmsg_build_hdr(buf, NFT_MSG_NEWSET, AF_INET, 0, 1234);
- nft_set_nlmsg_build_payload(nlh, a);
+ nlh = nftnl_set_nlmsg_build_hdr(buf, NFT_MSG_NEWSET, AF_INET, 0, 1234);
+ nftnl_set_nlmsg_build_payload(nlh, a);
- if (nft_set_nlmsg_parse(nlh, b) < 0)
+ if (nftnl_set_nlmsg_parse(nlh, b) < 0)
print_err("parsing problems");
- cmp_nft_set(a,b);
+ cmp_nftnl_set(a,b);
- nft_set_free(a); nft_set_free(b);
+ nftnl_set_free(a); nftnl_set_free(b);
if (!test_ok)
exit(EXIT_FAILURE);
diff --git a/tests/nft-table-test.c b/tests/nft-table-test.c
index 2096ea5..9ae8f48 100644
--- a/tests/nft-table-test.c
+++ b/tests/nft-table-test.c
@@ -24,16 +24,16 @@ static void print_err(const char *msg)
printf("\033[31mERROR:\e[0m %s\n", msg);
}
-static void cmp_nft_table(struct nft_table *a, struct nft_table *b)
+static void cmp_nftnl_table(struct nftnl_table *a, struct nftnl_table *b)
{
- if (strcmp(nft_table_attr_get_str(a, NFT_TABLE_ATTR_NAME),
- nft_table_attr_get_str(b, NFT_TABLE_ATTR_NAME)) != 0)
+ if (strcmp(nftnl_table_attr_get_str(a, NFTNL_TABLE_ATTR_NAME),
+ nftnl_table_attr_get_str(b, NFTNL_TABLE_ATTR_NAME)) != 0)
print_err("table name mismatches");
- if (nft_table_attr_get_u32(a, NFT_TABLE_ATTR_FLAGS) !=
- nft_table_attr_get_u32(b, NFT_TABLE_ATTR_FLAGS))
+ if (nftnl_table_attr_get_u32(a, NFTNL_TABLE_ATTR_FLAGS) !=
+ nftnl_table_attr_get_u32(b, NFTNL_TABLE_ATTR_FLAGS))
print_err("table flags mismatches");
- if (nft_table_attr_get_u32(a, NFT_TABLE_ATTR_FAMILY) !=
- nft_table_attr_get_u32(b, NFT_TABLE_ATTR_FAMILY))
+ if (nftnl_table_attr_get_u32(a, NFTNL_TABLE_ATTR_FAMILY) !=
+ nftnl_table_attr_get_u32(b, NFTNL_TABLE_ATTR_FAMILY))
print_err("tabke family mismatches");
}
@@ -42,30 +42,30 @@ int main(int argc, char *argv[])
char buf[4096];
struct nlmsghdr *nlh;
- struct nft_table *a = NULL;
- struct nft_table *b = NULL;
- a = nft_table_alloc();
- b = nft_table_alloc();
+ struct nftnl_table *a = NULL;
+ struct nftnl_table *b = NULL;
+ a = nftnl_table_alloc();
+ b = nftnl_table_alloc();
if (a == NULL || b == NULL)
print_err("OOM");
- nft_table_attr_set_str(a, NFT_TABLE_ATTR_NAME, "test");
- nft_table_attr_set_u32(a, NFT_TABLE_ATTR_FAMILY, AF_INET);
- nft_table_attr_set_u32(a, NFT_TABLE_ATTR_FLAGS, 0);
+ nftnl_table_attr_set_str(a, NFTNL_TABLE_ATTR_NAME, "test");
+ nftnl_table_attr_set_u32(a, NFTNL_TABLE_ATTR_FAMILY, AF_INET);
+ nftnl_table_attr_set_u32(a, NFTNL_TABLE_ATTR_FLAGS, 0);
/* cmd extracted from include/linux/netfilter/nf_tables.h */
- nlh = nft_table_nlmsg_build_hdr(buf, NFT_MSG_NEWTABLE, AF_INET, 0,
+ nlh = nftnl_table_nlmsg_build_hdr(buf, NFT_MSG_NEWTABLE, AF_INET, 0,
1234);
- nft_table_nlmsg_build_payload(nlh, a);
+ nftnl_table_nlmsg_build_payload(nlh, a);
- if (nft_table_nlmsg_parse(nlh, b) < 0)
+ if (nftnl_table_nlmsg_parse(nlh, b) < 0)
print_err("parsing problems");
- cmp_nft_table(a,b);
+ cmp_nftnl_table(a,b);
- nft_table_free(a);
- nft_table_free(b);
+ nftnl_table_free(a);
+ nftnl_table_free(b);
if (!test_ok)
exit(EXIT_FAILURE);